Arduino Uno

What it is

The Arduino Uno is a small development board built around Microchip’s ATmega328P, an 8-bit microcontroller. It exposes the chip’s pins on labelled headers, adds a USB port for programming and power, and handles the fiddly parts—the voltage regulator, the clock crystal, the reset circuit—so you can focus on your code and your wiring. For a huge share of robotics learners, the Uno is how they first make a motor spin or a sensor light up.

Its lasting appeal is not raw power—by modern standards it is slow and memory-starved. It is forgiveness. The 5 V pins tolerate the wiring mistakes beginners make, the community has answered nearly every question you can ask, and almost every hobby sensor and driver ships with example code that assumes an Uno.

How it works

You write a sketch—a C++ program with two functions. setup() runs once when the board powers on; loop() runs forever after that. Inside them you read inputs and drive outputs through the pins:

• Digital pins read or write a HIGH/LOW (5 V / 0 V) signal—a button press, an LED, the direction input of a motor driver.
• PWM pins (marked ~) fake an analog voltage by switching on and off very fast. This is how you set motor speed or LED brightness.
• Analog inputs measure a voltage from 0–5 V and report it as a number from 0–1023. This is how you read a potentiometer or an analog line sensor.

The Uno has no operating system. Your code is the only thing running, which makes timing predictable—valuable when you are closing a control loop around a real robot.

When to use it

Reach for an Uno when you are learning, when you want the largest possible pile of compatible tutorials and libraries, or when your robot’s job is simple and real-time: read a few sensors, run a control loop, drive two motors. A line follower, an obstacle-avoider, or a small differential-drive rover are squarely in its comfort zone.

Look elsewhere when you need Wi-Fi or Bluetooth (an ESP32 is the usual upgrade), heavy math or camera vision (a Raspberry Pi), or lots of memory. The Uno’s 2 KB of SRAM fills up faster than beginners expect—long strings and big arrays are the usual culprits.

Common gotchas

• It is a 5 V board. Many modern sensors are 3.3 V and can be damaged by 5 V logic. Check the datasheet before wiring.
• Don’t power motors from the board. The Uno’s regulator can’t supply motor current; use a separate battery and a motor driver. Powering motors directly through the Uno is the most common way beginners brown-out or reset their board.
• delay() blocks everything. While the board is in a delay(), it can’t read sensors or react. For anything responsive, track time with millis() instead.
• Watch your memory. If the board behaves erratically for no clear reason, you may be out of SRAM.

Pinout: what each pin can actually do

Fourteen digital pins and six analog, but they are not interchangeable. Six of them have a second job that matters.

Two of those lines shape most robot designs. D2 and D3 are the only true interrupt pins, which means a robot with two wheel encoders uses both and has none left. And A4/A5 are the I²C bus, so an MPU-6050 plus an analog sensor array on an Uno immediately competes for pins.

This pin pressure is the single most common reason a project outgrows an Uno — not speed, not memory. Fourteen digital and six analog pins disappear quickly once you have a motor driver (6 pins), an encoder pair (4 pins, 2 of them interrupts), and a sensor array (6 analog).

Powering it, and the three ways to get it wrong

The regulator is linear, which means it burns the difference between input and 5 V as heat. At 12 V in and 200 mA drawn, that is (12 − 5) × 0.2 = 1.4 W in a small package, and it gets genuinely hot. Feed it 9 V rather than 12 V if you have the choice.

Three specific mistakes worth naming:

Powering motors from the 5 V pin. The regulator cannot supply motor current, so the rail dips, the board resets, and the symptom looks like a software crash. Motors get their own supply and share only ground.

Feeding the 5 V pin from an unregulated source. That pin is directly on the rail, so anything above about 5.5 V goes straight into the ATmega328P.

Powering from USB and the jack at once. The board handles this (there is a comparator that selects the higher source), but a battery on the jack will not charge and can back-feed through a marginal design on a clone.

What the pins can actually supply

The 3.3 V pin catches people out regularly. It is not a general-purpose rail; it is a 50 mA convenience. An ESP-01 module trying to transmit will brown out on it immediately.

The 2 KB memory problem

The Uno has 32 KB of flash for your program and 2 KB of SRAM for its variables while running. Flash is rarely the constraint. SRAM is, constantly.

Every string literal in a Serial.print is copied into SRAM at startup:

Serial.println("Calibration complete, entering drive mode");   // 43 bytes of SRAM, forever

Twenty such messages is 800 bytes — 40% of the total. The fix is F(), which leaves the string in flash and reads it as needed:

Serial.println(F("Calibration complete, entering drive mode"));  // 0 bytes of SRAM

Arrays are the other consumer. A float is 4 bytes, so a 200-sample logging buffer is 800 bytes and there is no warning at all — the compiler reports flash usage happily and says nothing useful about runtime SRAM.

The symptom of running out is not a clean error. The stack grows down, the heap grows up, and when they meet, variables silently corrupt each other. The board behaves erratically: readings that make no sense, a loop that skips, a reset with no cause. If an Uno starts behaving irrationally after you added a feature, suspect SRAM before anything else.

// Drop this in and watch it while you develop.
int freeRam() {
  extern int __heap_start, *__brkval;
  int v;
  return (int)&v - (__brkval == 0 ? (int)&__heap_start : (int)__brkval);
}

Under about 200 bytes free, expect trouble.

Troubleshooting

Uno or something else?

The Nano deserves particular mention for robots: it is the same ATmega328P with the same code, and it breaks out A6 and A7 as extra analog inputs. For an 8-channel reflectance array that is the difference between fitting and not fitting, which is exactly why line-follower builds so often specify a Nano.

The honest summary: the Uno’s value is that everything works on it the first time. Every library, every tutorial, every wiring diagram assumes it. That is worth more while learning than any specification, and when you outgrow it, the thing you outgrew will almost always be the pin count.