Serial Communication with Arduino

1. The "Under the Hood" of Serial Communication

Before we write any code, let's understand what's happening at a lower level, as you appreciate knowing the "why" behind the "how". When an Arduino talks to your computer via USB, it's using a form of asynchronous serial communication.

• Serial: Data is sent one single bit at a time over one wire.
• Asynchronous: Unlike some protocols that use a shared clock signal to keep the sender and receiver in sync, this method doesn't. Instead, the sender and receiver must agree on a communication speed beforehand.

This agreed-upon speed is called the baud rate, measured in bits per second. If the Arduino is "speaking" at 9600 bps, the computer must be "listening" at 9600 bps, or the message will be garbled.

The following video provides an excellent deep dive into how a single byte of data is framed and transmitted.

This underlying protocol is managed for us by a dedicated chip on the Arduino board and the Serial library in our code, making it easy to use.

2. Sending Data from Arduino to PC (print, println)

The most common use of serial communication is for the Arduino to send information to the computer. This is invaluable for debugging, as you can print variable values, status messages, or sensor readings to see what your code is doing in real-time.

The Arduino IDE includes a tool called the Serial Monitor which acts as the computer's terminal for this conversation.

Let's look at the three core functions for sending data:

1. Serial.begin(speed): This function starts the serial communication and sets the baud rate. It's almost always placed in the void setup() function. The most common speed is 9600, but other standard rates like 115200 are also used.
2. Serial.print(data): This sends data to the serial port as human-readable text. You can print strings, integers, floats, etc. The cursor remains on the same line after the data is printed.
3. Serial.println(data): This does the same thing as Serial.print(), but adds a carriage return and a newline character at the end, moving the cursor to the next line. This is great for printing distinct pieces of information.

The following video is a great practical walkthrough of these commands.

Your Turn: "Hello, World!" and Sensor Data

Let's write a simple sketch.

1. Open the Arduino IDE.
2. Enter the code below.
3. Connect your Arduino board.
4. Upload the code.
5. Open the Serial Monitor by clicking the magnifying glass icon in the top-right corner of the IDE (or Tools -> Serial Monitor).
6. Crucially, make sure the dropdown menu in the bottom-right of the Serial Monitor is set to 9600 baud.

void setup() {
  // Initialize serial communication at 9600 bits per second
  Serial.begin(9600); 

  // Wait for the serial port to connect. Needed for native USB port only
  while (!Serial) {
    ; 
  }

  Serial.println("Arduino is ready!");
}

void loop() {
  // Print a static message
  Serial.print("Uptime in seconds: ");
  Serial.println(millis() / 1000); // millis() returns milliseconds since start

  // Read an analog pin (leave it unconnected to see floating values)
  int sensorValue = analogRead(A0);
  Serial.print("Analog Pin A0 Value: ");
  Serial.println(sensorValue);
  
  delay(1000); // Wait for a second
}

You should see the uptime and a fluctuating analog value printed to the monitor every second. This simple feedback loop is the foundation of debugging in the Arduino world.

3. Receiving Data from PC to Arduino (available, read)

Now for the other direction: sending commands from the PC to the Arduino. This allows you to create interactive projects. For example, you could type 'H' to turn an LED on and 'L' to turn it off.

The process involves two main functions:

1. Serial.available(): This returns the number of bytes (characters) that have arrived from the PC and are waiting in the serial input buffer. It's essential to check if this is greater than zero before trying to read anything.
2. Serial.read(): This reads one single byte/character from the input buffer.

This check-then-read pattern is fundamental. It's a non-blocking approach: your loop() function can continue running thousands of times per second, and it only acts on serial data when it's actually there.

Example: Two-Way Communication

Let's implement a classic example: controlling the built-in LED by sending commands from the Serial Monitor.

Now, try it yourself. Wire up an external LED or just use the built-in one (LED_BUILTIN). Upload the code from the example in the article.

• Open the Serial Monitor.
• Type 1 and press Enter. The LED should turn on, and the Arduino should send back "LED is ON".
• Type 0 and press Enter. The LED should turn off, and the Arduino should reply with "LED is OFF".

You've just created a complete communication loop!

4. Robust Serial Input: Reading Full Commands

Reading single characters is useful, but often you'll want to send more complex commands, like "set_speed=200". This requires reading a whole string of text.

A common mistake is to assume all the characters arrive at once. As we learned, serial data is slow. A robust program reads characters one by one as they arrive and assembles them into a string, waiting for a special end-marker character (like the 'newline' character, \n, which the Serial Monitor sends when you press Enter) to know the message is complete.

The "Serial Input Basics" tutorial on the Arduino Forum is the gold standard for learning this technique.

This pattern of buffering incoming characters until a delimiter is found is extremely powerful and is a common paradigm in many communication protocols. The same resource also shows how to parse this received string to extract numbers (atoi, atof) or multiple values (strtok), which are techniques you'll be familiar with from other programming languages.

Conclusion

You now have the tools to make your Arduino projects communicate with the outside world. This is a huge step forward, enabling debugging, data logging, and interactive control.

Key Takeaways:

• Serial communication is a method of sending data one bit at a time, governed by a pre-agreed baud rate.
• Use Serial.begin(baud_rate) in setup() to initialize communication.
• Use Serial.print() and Serial.println() to send human-readable data from the Arduino to the PC's Serial Monitor.
• Use the if (Serial.available() > 0) and Serial.read() pattern to receive data from the PC in a non-blocking way.
• For robustly receiving full commands or sentences, read characters into a buffer until you receive an end-marker like a newline (\n).

Next Up

In the final lesson of this module, we'll put everything together. Now that you can read sensors, control outputs, and use the Serial Monitor for debugging, you are ready to integrate an external library to control a more complex component, like an LCD screen or a servo motor. Your new serial communication skills will be essential for troubleshooting as we add this new layer of complexity.