Komunikasi Serial Arduino - Menghubungkan Arduino dengan Komputer

- 9600 bps   : Standard untuk kebanyakan aplikasi
- 19200 bps  : 2x lebih cepat dari 9600
- 38400 bps  : Untuk aplikasi yang memerlukan speed tinggi
- 57600 bps  : High speed applications
- 115200 bps : Maximum speed untuk Arduino Uno

1
// Program Serial Communication Dasar
2
// Mengirim "Hello World" ke Serial Monitor
3

4
void setup() {
5
  // Initialize komunikasi serial dengan baud rate 9600
6
  Serial.begin(9600);
7

8
  // Tunggu koneksi serial terbentuk (untuk Leonardo/Micro)
9
  while (!Serial) {
10
    ; // wait for serial port to connect
11
  }
12

13
  Serial.println("=== Arduino Serial Communication ===");
14
  Serial.println("Program Started!");
15
  Serial.println("Type something and press Enter...");
16
}
17

18
void loop() {
19
  // Kirim counter setiap 2 detik
20
  static unsigned long lastTime = 0;
21
  static int counter = 0;
22

23
  if (millis() - lastTime >= 2000) {
24
    lastTime = millis();
25
    counter++;
26

27
    Serial.print("Counter: ");
28
    Serial.println(counter);
29
  }
30
}

1
Serial.print("Hello");     // Tanpa newline
2
Serial.println("World");   // Dengan newline (\r\n)

1
void setup() {
2
  Serial.begin(9600);
3
  Serial.println("Arduino Ready - Send commands:");
4
  Serial.println("LED ON  - Turn on LED");
5
  Serial.println("LED OFF - Turn off LED");
6
  Serial.println("STATUS  - Show current status");
7

8
  pinMode(LED_BUILTIN, OUTPUT);
9
}
10

11
void loop() {
12
  // Cek apakah ada data serial yang masuk
13
  if (Serial.available() > 0) {
14
    // Baca string sampai newline
15
    String inputString = Serial.readString();
16
    inputString.trim(); // Hapus whitespace
17

18
    // Convert ke uppercase untuk case-insensitive
19
    inputString.toUpperCase();
20

21
    // Process command
22
    if (inputString == "LED ON") {
23
      digitalWrite(LED_BUILTIN, HIGH);
24
      Serial.println("LED turned ON");
25
    }
26
    else if (inputString == "LED OFF") {
27
      digitalWrite(LED_BUILTIN, LOW);
28
      Serial.println("LED turned OFF");
29
    }
30
    else if (inputString == "STATUS") {
31
      Serial.print("LED Status: ");
32
      Serial.println(digitalRead(LED_BUILTIN) ? "ON" : "OFF");
33
    }
34
    else {
35
      Serial.println("Unknown command: " + inputString);
36
      Serial.println("Available commands: LED ON, LED OFF, STATUS");
37
    }
38
  }
39
}

1
Serial.print(data);          // Print tanpa newline
2
Serial.println(data);        // Print dengan newline
3
Serial.write(data);          // Send raw bytes
4
Serial.printf(format, ...);  // Formatted output (ESP32)

1
Serial.available();          // Jumlah bytes yang tersedia
2
Serial.read();              // Baca satu byte
3
Serial.readString();        // Baca string sampai timeout
4
Serial.readStringUntil(terminator); // Baca sampai karakter tertentu
5
Serial.parseInt();          // Parse integer dari serial
6
Serial.parseFloat();        // Parse float dari serial

1
Serial.flush();             // Tunggu sampai transmisi selesai
2
Serial.setTimeout(time);    // Set timeout untuk read functions
3
Serial.find(target);        // Cari string dalam buffer

1
// Sensor monitoring dengan output terformat
2
const int potPin = A0;
3
const int ldrPin = A1;
4
const int tempPin = A2;
5

6
void setup() {
7
  Serial.begin(9600);
8

9
  // Print header
10
  Serial.println("=== Sensor Data Logger ===");
11
  Serial.println("Time(ms)\tPot\tLDR\tTemp");
12
  Serial.println("--------------------------------");
13
}
14

15
void loop() {
16
  // Baca semua sensor
17
  int potValue = analogRead(potPin);
18
  int ldrValue = analogRead(ldrPin);
19
  int tempValue = analogRead(tempPin);
20

21
  // Convert temperature (jika menggunakan LM35)
22
  float temperature = (tempValue * 5.0 / 1024.0) * 100.0;
23

24
  // Print timestamp
25
  Serial.print(millis());
26
  Serial.print("\t");
27

28
  // Print sensor values dengan tab separator
29
  Serial.print(potValue);
30
  Serial.print("\t");
31
  Serial.print(ldrValue);
32
  Serial.print("\t");
33
  Serial.println(temperature, 1); // 1 decimal place
34

35
  delay(1000); // Update setiap detik
36
}

1
void setup() {
2
  Serial.begin(9600);
3
  Serial.println("JSON Sensor Data Stream");
4
}
5

6
void loop() {
7
  // Baca sensor values
8
  int potValue = analogRead(A0);
9
  int ldrValue = analogRead(A1);
10
  float temperature = (analogRead(A2) * 5.0 / 1024.0) * 100.0;
11

12
  // Create JSON string
13
  Serial.print("{");
14
  Serial.print("\"timestamp\":");
15
  Serial.print(millis());
16
  Serial.print(",\"sensors\":{");
17
  Serial.print("\"potentiometer\":");
18
  Serial.print(potValue);
19
  Serial.print(",\"light\":");
20
  Serial.print(ldrValue);
21
  Serial.print(",\"temperature\":");
22
  Serial.print(temperature, 2);
23
  Serial.print("}}");
24
  Serial.println();
25

26
  delay(2000);
27
}

1
const int redPin = 9;
2
const int greenPin = 10;
3
const int bluePin = 11;
4

5
struct RGBColor {
6
  int red;
7
  int green;
8
  int blue;
9
};
10

11
RGBColor currentColor = {0, 0, 0};
12

13
void setup() {
14
  Serial.begin(9600);
15
  pinMode(redPin, OUTPUT);
16
  pinMode(greenPin, OUTPUT);
17
  pinMode(bluePin, OUTPUT);
18

19
  printHelp();
20
}
21

22
void loop() {
23
  if (Serial.available() > 0) {
24
    String command = Serial.readString();
25
    command.trim();
26

27
    processCommand(command);
28
  }
29
}
30

31
void processCommand(String cmd) {
32
  cmd.toUpperCase();
33

34
  if (cmd.startsWith("RGB ")) {
35
    // Parse RGB values: "RGB 255,128,64"
36
    String values = cmd.substring(4);
37
    parseRGBValues(values);
38
  }
39
  else if (cmd == "RED") {
40
    setColor(255, 0, 0);
41
  }
42
  else if (cmd == "GREEN") {
43
    setColor(0, 255, 0);
44
  }
45
  else if (cmd == "BLUE") {
46
    setColor(0, 0, 255);
47
  }
48
  else if (cmd == "OFF") {
49
    setColor(0, 0, 0);
50
  }
51
  else if (cmd == "STATUS") {
52
    printStatus();
53
  }
54
  else if (cmd == "HELP") {
55
    printHelp();
56
  }
57
  else {
58
    Serial.println("Error: Unknown command '" + cmd + "'");
59
    Serial.println("Type HELP for available commands");
60
  }
61
}
62

63
void parseRGBValues(String values) {
64
  int commaIndex1 = values.indexOf(',');
65
  int commaIndex2 = values.lastIndexOf(',');
66

67
  if (commaIndex1 != -1 && commaIndex2 != -1 && commaIndex1 != commaIndex2) {
68
    int r = values.substring(0, commaIndex1).toInt();
69
    int g = values.substring(commaIndex1 + 1, commaIndex2).toInt();
70
    int b = values.substring(commaIndex2 + 1).toInt();
71

72
    // Validate ranges
73
    r = constrain(r, 0, 255);
74
    g = constrain(g, 0, 255);
75
    b = constrain(b, 0, 255);
76

77
    setColor(r, g, b);
78
  } else {
79
    Serial.println("Error: Invalid RGB format. Use: RGB r,g,b");
80
  }
81
}
82

83
void setColor(int r, int g, int b) {
84
  currentColor.red = r;
85
  currentColor.green = g;
86
  currentColor.blue = b;
87

88
  analogWrite(redPin, r);
89
  analogWrite(greenPin, g);
90
  analogWrite(bluePin, b);
91

92
  Serial.print("Color set to RGB(");
93
  Serial.print(r);
94
  Serial.print(", ");
95
  Serial.print(g);
96
  Serial.print(", ");
97
  Serial.print(b);
98
  Serial.println(")");
99
}
100

101
void printStatus() {
102
  Serial.print("Current RGB: (");
103
  Serial.print(currentColor.red);
104
  Serial.print(", ");
105
  Serial.print(currentColor.green);
106
  Serial.print(", ");
107
  Serial.print(currentColor.blue);
108
  Serial.println(")");
109
}
110

111
void printHelp() {
112
  Serial.println("=== RGB LED Controller ===");
113
  Serial.println("Available commands:");
114
  Serial.println("RGB r,g,b  - Set custom RGB values (0-255)");
115
  Serial.println("RED        - Set color to red");
116
  Serial.println("GREEN      - Set color to green");
117
  Serial.println("BLUE       - Set color to blue");
118
  Serial.println("OFF        - Turn off all LEDs");
119
  Serial.println("STATUS     - Show current color");
120
  Serial.println("HELP       - Show this help");
121
  Serial.println("Examples:");
122
  Serial.println("  RGB 255,128,0");
123
  Serial.println("  RED");
124
  Serial.println("  OFF");
125
}

1
struct SensorConfig {
2
  int interval;
3
  bool enabled;
4
  float threshold;
5
};
6

7
SensorConfig config = {1000, true, 25.0};
8

9
void setup() {
10
  Serial.begin(9600);
11
  Serial.println("Advanced Serial Parser");
12
  printConfig();
13
}
14

15
void loop() {
16
  if (Serial.available() > 0) {
17
    String input = Serial.readStringUntil('\n');
18
    input.trim();
19

20
    if (input.length() > 0) {
21
      parseCommand(input);
22
    }
23
  }
24

25
  // Main sensor loop
26
  if (config.enabled) {
27
    static unsigned long lastReading = 0;
28
    if (millis() - lastReading >= config.interval) {
29
      lastReading = millis();
30

31
      float sensorValue = analogRead(A0) * (5.0 / 1023.0);
32
      Serial.print("Sensor: ");
33
      Serial.print(sensorValue, 2);
34

35
      if (sensorValue > config.threshold) {
36
        Serial.print(" [ALERT: Above threshold!");
37
      }
38
      Serial.println();
39
    }
40
  }
41
}
42

43
void parseCommand(String cmd) {
44
  // Split command dan parameter
45
  int spaceIndex = cmd.indexOf(' ');
46
  String command = cmd;
47
  String parameter = "";
48

49
  if (spaceIndex != -1) {
50
    command = cmd.substring(0, spaceIndex);
51
    parameter = cmd.substring(spaceIndex + 1);
52
  }
53

54
  command.toUpperCase();
55

56
  if (command == "SET") {
57
    handleSetCommand(parameter);
58
  }
59
  else if (command == "GET") {
60
    handleGetCommand(parameter);
61
  }
62
  else if (command == "CONFIG") {
63
    printConfig();
64
  }
65
  else if (command == "RESET") {
66
    resetConfig();
67
  }
68
  else {
69
    Serial.println("Error: Unknown command. Available: SET, GET, CONFIG, RESET");
70
  }
71
}
72

73
void handleSetCommand(String param) {
74
  int equalIndex = param.indexOf('=');
75
  if (equalIndex == -1) {
76
    Serial.println("Error: Use format SET parameter=value");
77
    return;
78
  }
79

80
  String key = param.substring(0, equalIndex);
81
  String value = param.substring(equalIndex + 1);
82

83
  key.toLowerCase();
84

85
  if (key == "interval") {
86
    int newInterval = value.toInt();
87
    if (newInterval >= 100 && newInterval <= 10000) {
88
      config.interval = newInterval;
89
      Serial.println("Interval updated to " + String(newInterval) + "ms");
90
    } else {
91
      Serial.println("Error: Interval must be 100-10000ms");
92
    }
93
  }
94
  else if (key == "enabled") {
95
    if (value == "true" || value == "1") {
96
      config.enabled = true;
97
      Serial.println("Sensor enabled");
98
    } else if (value == "false" || value == "0") {
99
      config.enabled = false;
100
      Serial.println("Sensor disabled");
101
    } else {
102
      Serial.println("Error: Use true/false or 1/0");
103
    }
104
  }
105
  else if (key == "threshold") {
106
    float newThreshold = value.toFloat();
107
    if (newThreshold >= 0 && newThreshold <= 5.0) {
108
      config.threshold = newThreshold;
109
      Serial.println("Threshold updated to " + String(newThreshold, 2));
110
    } else {
111
      Serial.println("Error: Threshold must be 0-5.0");
112
    }
113
  }
114
  else {
115
    Serial.println("Error: Unknown parameter. Available: interval, enabled, threshold");
116
  }
117
}
118

119
void handleGetCommand(String param) {
120
  param.toLowerCase();
121

122
  if (param == "interval") {
123
    Serial.println("Interval: " + String(config.interval) + "ms");
124
  }
125
  else if (param == "enabled") {
126
    Serial.println("Enabled: " + String(config.enabled ? "true" : "false"));
127
  }
128
  else if (param == "threshold") {
129
    Serial.println("Threshold: " + String(config.threshold, 2));
130
  }
131
  else if (param == "all") {
132
    printConfig();
133
  }
134
  else {
135
    Serial.println("Error: Unknown parameter. Available: interval, enabled, threshold, all");
136
  }
137
}
138

139
void printConfig() {
140
  Serial.println("=== Current Configuration ===");
141
  Serial.println("Interval: " + String(config.interval) + "ms");
142
  Serial.println("Enabled: " + String(config.enabled ? "true" : "false"));
143
  Serial.println("Threshold: " + String(config.threshold, 2));
144
  Serial.println("============================");
145
}
146

147
void resetConfig() {
148
  config.interval = 1000;
149
  config.enabled = true;
150
  config.threshold = 25.0;
151
  Serial.println("Configuration reset to defaults");
152
  printConfig();
153
}

1
// Debug level constants
2
#define DEBUG_NONE    0
3
#define DEBUG_ERROR   1
4
#define DEBUG_WARNING 2
5
#define DEBUG_INFO    3
6
#define DEBUG_VERBOSE 4
7

8
int currentDebugLevel = DEBUG_INFO;
9

10
void setup() {
11
  Serial.begin(9600);
12
  debugPrintln("System started", DEBUG_INFO);
13
  debugPrintln("Debug level: " + String(currentDebugLevel), DEBUG_INFO);
14
}
15

16
void loop() {
17
  static int loopCounter = 0;
18
  loopCounter++;
19

20
  debugPrintln("Loop " + String(loopCounter), DEBUG_VERBOSE);
21

22
  // Simulate some sensor reading
23
  int sensorValue = analogRead(A0);
24

25
  if (sensorValue > 900) {
26
    debugPrintln("High sensor value detected: " + String(sensorValue), DEBUG_WARNING);
27
  }
28

29
  if (sensorValue > 1000) {
30
    debugPrintln("CRITICAL: Sensor value out of range!", DEBUG_ERROR);
31
  }
32

33
  debugPrint("Sensor: ", DEBUG_INFO);
34
  debugPrintln(String(sensorValue), DEBUG_INFO);
35

36
  delay(1000);
37
}
38

39
void debugPrint(String message, int level) {
40
  if (level <= currentDebugLevel) {
41
    Serial.print(getDebugPrefix(level));
42
    Serial.print(message);
43
  }
44
}
45

46
void debugPrintln(String message, int level) {
47
  if (level <= currentDebugLevel) {
48
    Serial.print(getDebugPrefix(level));
49
    Serial.println(message);
50
  }
51
}
52

53
String getDebugPrefix(int level) {
54
  switch (level) {
55
    case DEBUG_ERROR:   return "[ERROR] ";
56
    case DEBUG_WARNING: return "[WARN]  ";
57
    case DEBUG_INFO:    return "[INFO]  ";
58
    case DEBUG_VERBOSE: return "[DEBUG] ";
59
    default:            return "[?]     ";
60
  }
61
}

1
// Buffer untuk menghindari fragmentasi String
2
char inputBuffer[64];
3
int bufferIndex = 0;
4

5
void setup() {
6
  Serial.begin(9600);
7
  Serial.println("Optimized Serial Communication");
8
}
9

10
void loop() {
11
  // Efficient character-by-character reading
12
  while (Serial.available() > 0) {
13
    char incomingChar = Serial.read();
14

15
    if (incomingChar == '\n' || incomingChar == '\r') {
16
      // End of command
17
      inputBuffer[bufferIndex] = '\0'; // Null terminate
18

19
      if (bufferIndex > 0) {
20
        processBufferedCommand();
21
      }
22

23
      bufferIndex = 0; // Reset buffer
24
    }
25
    else if (bufferIndex < sizeof(inputBuffer) - 1) {
26
      inputBuffer[bufferIndex] = incomingChar;
27
      bufferIndex++;
28
    }
29
    else {
30
      // Buffer overflow protection
31
      Serial.println("Error: Command too long");
32
      bufferIndex = 0;
33
    }
34
  }
35
}
36

37
void processBufferedCommand() {
38
  // Convert to uppercase for case-insensitive comparison
39
  for (int i = 0; inputBuffer[i]; i++) {
40
    inputBuffer[i] = toupper(inputBuffer[i]);
41
  }
42

43
  if (strcmp(inputBuffer, "LED ON") == 0) {
44
    digitalWrite(LED_BUILTIN, HIGH);
45
    Serial.println("OK: LED ON");
46
  }
47
  else if (strcmp(inputBuffer, "LED OFF") == 0) {
48
    digitalWrite(LED_BUILTIN, LOW);
49
    Serial.println("OK: LED OFF");
50
  }
51
  else if (strncmp(inputBuffer, "SET ", 4) == 0) {
52
    // Handle SET commands
53
    char* parameter = inputBuffer + 4; // Skip "SET "
54
    handleSetParameter(parameter);
55
  }
56
  else {
57
    Serial.print("Error: Unknown command '");
58
    Serial.print(inputBuffer);
59
    Serial.println("'");
60
  }
61
}
62

63
void handleSetParameter(char* param) {
64
  // Example: "SET BRIGHTNESS 128"
65
  char* spacePtr = strchr(param, ' ');
66
  if (spacePtr != NULL) {
67
    *spacePtr = '\0'; // Split string
68
    char* valueStr = spacePtr + 1;
69

70
    if (strcmp(param, "BRIGHTNESS") == 0) {
71
      int brightness = atoi(valueStr);
72
      brightness = constrain(brightness, 0, 255);
73
      analogWrite(LED_BUILTIN, brightness);
74
      Serial.print("OK: Brightness set to ");
75
      Serial.println(brightness);
76
    }
77
  }
78
}

1
// Pastikan baud rate sama di kode dan Serial Monitor
2
Serial.begin(9600); // Kode
3
// Serial Monitor juga harus diset ke 9600

1
void setup() {
2
  Serial.begin(9600);
3
  Serial.setTimeout(1000); // Set timeout 1 detik
4
}
5

6
void loop() {
7
  if (Serial.available() > 0) {
8
    String data = Serial.readString();
9
    data.trim(); // Hapus whitespace/newline
10
    // Process data...
11
  }
12
}

1
// Selalu cek available() sebelum read()
2
if (Serial.available() > 0) {
3
  int data = Serial.read();
4
  // Process data...
5
}

1
// Gunakan char array instead of String
2
char buffer[32];
3
Serial.readBytesUntil('\n', buffer, sizeof(buffer));

1
void safeSerialPrint(String data) {
2
  if (Serial) { // Cek koneksi serial
3
    Serial.println(data);
4
  }
5
}
6

7
bool waitForSerial(unsigned long timeout = 5000) {
8
  unsigned long startTime = millis();
9
  while (!Serial && (millis() - startTime < timeout)) {
10
    delay(10);
11
  }
12
  return Serial;
13
}

1
// Consistent command format: COMMAND:PARAMETER:VALUE\n
2
void sendCommand(String cmd, String param, String value) {
3
  Serial.print(cmd);
4
  Serial.print(":");
5
  Serial.print(param);
6
  Serial.print(":");
7
  Serial.println(value);
8
}
9

10
void sendResponse(String status, String message) {
11
  Serial.print("RESPONSE:");
12
  Serial.print(status);
13
  Serial.print(":");
14
  Serial.println(message);
15
}

1
bool isValidNumber(String str) {
2
  for (int i = 0; i < str.length(); i++) {
3
    if (!isDigit(str.charAt(i)) && str.charAt(i) != '.' && str.charAt(i) != '-') {
4
      return false;
5
    }
6
  }
7
  return true;
8
}
9

10
int parseIntSafe(String str, int defaultValue = 0) {
11
  if (isValidNumber(str)) {
12
    return str.toInt();
13
  }
14
  return defaultValue;
15
}