What is Serial Communication?

Serial communication sends data one bit at a time over a wire. On the tinyCore, it’s what happens when you plug in the USB-C cable and open the Serial Monitor in Arduino IDE — the board sends text and numbers to your computer, and your computer can send commands back. It’s your primary way to see what your code is doing.

Why This Matters for Your Projects

The Serial Monitor is the single most important debugging tool you have. There’s no step-through debugger in Arduino — when something isn’t working, you figure out why by printing values and messages to the Serial Monitor at key points in your code. You’ll use Serial.println() in virtually every project you build.

How It Actually Works

The Basics

The specific protocol your tinyCore uses over USB is called UART (Universal Asynchronous Receiver/Transmitter). “Asynchronous” means there’s no shared clock wire — both sides agree on a speed ahead of time (called the baud rate) and send bits at that speed.

When you call Serial.begin(115200) in your code, you’re telling the ESP32-S3 to initialize the serial port at 115,200 bits per second. The Serial Monitor in Arduino IDE must be set to the same baud rate, or the received data will be garbled nonsense.

void setup() {
  Serial.begin(115200);
  delay(2000);              // give USB time to connect
  Serial.println("tinyCore ready!");
}

Note

ESP32-S3 note: Because the tinyCore uses native USB (USB-CDC), the baud rate number is technically ignored by the hardware — USB manages its own timing. But Serial.begin() is still required to initialize the driver, and you should still match the baud rate in the Serial Monitor. Use 115200 as your default.

Sending Data: Serial.print() and Serial.println()

Two functions you’ll use constantly:

• Serial.print("text") — prints text, stays on the same line
• Serial.println("text") — prints text, then moves to a new line

void loop() {
  int sensorValue = analogRead(1);
  Serial.print("Sensor: ");
  Serial.println(sensorValue);
  delay(500);
}

Output in Serial Monitor:

Sensor: 512
Sensor: 487
Sensor: 501

You can print strings, integers, floats, and hex values. Serial.println() is what you’ll reach for 90% of the time.

The Serial Monitor

Open it with Ctrl+Shift+M (Mac: Cmd+Shift+M), or click the magnifying glass icon in the top-right of Arduino IDE. Make sure the baud rate dropdown at the bottom matches the value in your Serial.begin() call.

The Serial Monitor also has an input field at the top — you can type text and send it to the board. Your code reads incoming data with Serial.available() and Serial.read():

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

The Serial Plotter

The Serial Plotter (Tools → Serial Plotter) graphs numerical data in real time. It’s incredibly useful for visualizing sensor readings, IMU data, or any changing value.

To use it, print numbers separated by commas, with a Serial.println() at the end of each set:

void loop() {
  float accelX = getAccelX();
  float accelY = getAccelY();
  float accelZ = getAccelZ();

  Serial.print(accelX);
  Serial.print(",");
  Serial.print(accelY);
  Serial.print(",");
  Serial.println(accelZ);   // newline triggers a new data point

  delay(50);
}

For labeled traces, use label:value pairs:

AccelX:0.12,AccelY:-0.98,AccelZ:0.04

Caution

You can’t have the Serial Monitor and Serial Plotter open at the same time — they share the same serial connection. Close one before opening the other.

On the tinyCore

USB-CDC: No Bridge Chip Needed

Most older Arduino boards (like the Uno) have a separate USB-to-UART bridge chip that converts USB signals to serial. The ESP32-S3 doesn’t need this — it has native USB built directly into the chip. Your tinyCore connects to your computer using USB-CDC (Communications Device Class), meaning the ESP32-S3 acts as a USB serial device directly.

This is why the tinyCore has just a USB-C connector with no additional serial hardware.

Serial vs Serial0

When the tinyCore is configured with “USB CDC On Boot: Enabled” (the recommended setting):

Object	Maps To	Used For
Serial	USB-CDC	Communicating with your computer via USB
Serial0	UART0 (GPIO 43 TX, GPIO 44 RX)	Talking to external serial devices (GPS modules, other boards, etc.)

For most projects, you’ll only use Serial. You’d only touch Serial0 if you’re wiring up an external serial device like a GPS module or another microcontroller.

// To your computer (over USB):
Serial.begin(115200);
Serial.println("Hello over USB");

// To an external serial device (over UART pins):
Serial0.begin(9600);
Serial0.println("Hello over UART");

The delay(2000) After Serial.begin()

Because the tinyCore uses USB-CDC, there’s a brief moment after power-on where the USB connection isn’t ready yet. If your code prints something immediately after Serial.begin(), it may get lost. Adding a short delay gives the connection time to establish:

void setup() {
  Serial.begin(115200);
  delay(2000);             // wait for USB to connect
  Serial.println("Ready");
}

Some example code uses while(!Serial); instead, which waits indefinitely for the Serial Monitor to open. The problem: if you’re running your project without a computer (on battery, for example), this line blocks your program forever. Use the delay instead, or add a timeout:

unsigned long start = millis();
while (!Serial && (millis() - start < 3000)) {
  // wait up to 3 seconds, then continue anyway
}

Common Baud Rates

Baud Rate	When to Use
9600	Legacy Arduino Uno examples, basic low-speed sensors
115200	Default for ESP32 boards. Use this.
230400–921600	High-throughput data logging, fast sensor streams

Common Problems and Fixes

Nothing shows up in Serial Monitor

1. Did you call Serial.begin(115200) in setup()?
2. Does the baud rate in the Serial Monitor dropdown match your code?
3. Is the correct COM port selected? (Tools → Port — pick the one that appears when you plug in the board)
4. Did you add delay(2000) after Serial.begin()? Early messages may be lost without it.

Garbled / garbage characters Almost always a baud rate mismatch. If your code uses Serial.begin(115200) but the Serial Monitor is set to 9600, you’ll see random symbols. Set both to the same value.

Board won’t run until Serial Monitor is opened Your code probably has while(!Serial); — this waits forever for a USB connection. Replace it with a timeout (shown above) or just use delay(2000).

Nothing prints after upload The ESP32-S3 may reset after upload but before the Serial Monitor reopens. Close and reopen the Serial Monitor, or press the reset button on the tinyCore.

Quick Reference

Feature	tinyCore ESP32-S3
USB type	Native USB-CDC (no bridge chip)
Default baud rate	115200
Serial maps to	USB-CDC (to your computer)
Serial0 maps to	UART0 (GPIO 43 TX / GPIO 44 RX)
USB speed	Up to 12 Mbps (Full Speed USB)
Startup delay needed	delay(2000) after Serial.begin()

Learn More

• Use the Serial Monitor & Plotter — hands-on serial tutorial
• What is GPIO? — the physical pins behind TX/RX
• Read Analog Sensor Values — print sensor data to the Serial Monitor

Video: Understanding the Arduino Serial Port

Paul McWhorter (Top Tech Boy) — “Arduino Tutorial 11: Understanding the Arduino Serial Port and Print Commands.” A patient, clear walkthrough of Serial.begin(), Serial.print(), and the Serial Monitor.