Serial Input: Reading What You Type

Serial has been one-way so far: the Arduino talks, you read. The same connection carries traffic the other way, and that turns a sketch into something you can operate.

Three calls do nearly all of it:

• Serial.available() — how many characters are waiting. Zero means nothing has arrived.
• Serial.read() — takes the next character and removes it.
• Serial.parseInt() — reads a whole number.

The idea that trips everyone is that input arrives one character at a time, and slowly. Type 42 and press enter, and the Arduino may see the 4 before the 2 has even left your laptop. A sketch that reads once and assumes the whole message arrived gets the 4 and nothing else.

So the pattern is always the same: check whether anything is waiting, and only then read. Never read without asking first — Serial.read() on an empty buffer returns -1, and a sketch that ignores that ends up processing a character that never existed.

No wiring. You will type into the Serial Monitor's input box at 9600 baud.

→ Reading from Serial — the same ground with hardware attached. → ASCII Basics — why '5' and 5 are different numbers.

Reading one character

void setup() {
  Serial.begin(9600);
  Serial.println("Type something");
}

void loop() {
  if (Serial.available() > 0) {
    char c = Serial.read();
    Serial.print("got: ");
    Serial.println(c);
  }
}

Type hi and press enter. You get three lines — h, i, and a newline character. Each character is separate.

Serial.available() is the guard. Without it, Serial.read() returns -1 every time round an empty loop, thousands of times a second.

The newline

Pressing enter sends an extra character. The dropdown at the bottom of the Serial Monitor controls which — usually Newline.

That stray character is behind most "it works but there is an extra blank line" reports. To ignore it:

char c = Serial.read();
if (c == '\n' || c == '\r') {
  return;      // skip line endings
}

'5' is not 5

A serial-driven blink.

Combine everything: type a number and the built-in LED blinks that many times.

• Serial.setTimeout(50) so it responds quickly.
• Reject anything below 1 or above 20, with a message saying why.
• Print a countdown as it blinks: blink 1 of 5, blink 2 of 5.
• Use a for loop for the blinking and a function void blinkTimes(int n) for the work.

While the blinking runs, the sketch is inside delay() and cannot read anything you type. Type during a long blink and see what happens when it finishes.

Think about it: those keystrokes were not lost — they waited in the buffer and arrived all at once. Where were they kept, and what do you think happens if you type far more than the sketch ever reads?