EM Applications of ElectromagneticsBuilt using ChatGPT · Connected engineering reference
Home › Arduino Boards — What You Need to Know
On this page

Arduino Boards — What You Need to Know

Arduino Uno development board showing the microcontroller, USB connector, power jack, digital pins and analog pins.
The classic Arduino Uno makes the microcontroller, power, digital I/O, analog inputs, serial interfaces, and USB programming connection physically visible. Image source: Creative Tools via Wikimedia Commons, CC BY 2.0.
30-second intuitionAn Arduino board is a microcontroller development platform, not a magical electronics box. The board gives you a processor, clock, power regulation, USB programming, and accessible I/O pins; the Arduino software layer hides much of the MCU complexity. To use Arduino well, understand both levels: the easy API and the real hardware underneath.
sensor / switch→GPIO / ADC / timer / bus→microcontroller→control logic→driver / actuator / communication

1. First concept: Arduino is an ecosystem

“Arduino” can mean several things:

The hardware family now spans simple 8-bit AVR boards, 32-bit Arm boards, ESP32-based boards, dual-core STM32 boards, industrial modules, and Linux-capable hybrid boards.

Official board overview: Arduino Hardware.

2. Microcontroller versus microprocessor

A microcontroller (MCU) typically contains

\[\boxed{ \text{CPU} + \text{Flash} + \text{RAM} + \text{GPIO} + \text{timers} + \text{ADC} + \text{serial peripherals} }\]

on one chip.

A microprocessor / application processor usually relies on external memory and often runs a full OS such as Linux.

Classic Arduino development is MCU-based and normally runs one firmware image directly on the hardware.

Modern Arduino products now also include hybrid Linux + MCU boards such as the UNO Q family.

3. Board families worth recognizing

You do not need to memorize every Arduino board.

Know the role of these families:

Family / board Why it matters
UNO R3 classic 8-bit AVR reference platform
UNO R4 Minima / WiFi modern 32-bit Arm replacement in UNO form factor
UNO Q newer Linux + MCU hybrid architecture
Nano family compact, breadboard-friendly embedded/IoT boards
MKR family compact 32-bit IoT/communications-oriented boards
MEGA 2560 many I/O pins, classic AVR architecture
GIGA R1 WiFi high-performance dual-core STM32 with many I/O/peripherals
Portenta industrial/professional high-performance modules

Arduino’s current hardware catalog explicitly spans UNO, Nano, GIGA, Portenta, industrial, and newer Linux/AI-capable boards. Arduino Hardware

4. UNO R3 — the classic reference

The UNO R3 uses an ATmega328P.

Important ideas:

Why it still matters:

The main limitation is not functionality—it is compute/memory headroom.

5. UNO R4 — modern UNO architecture

The UNO R4 Minima and UNO R4 WiFi use a Renesas RA4M1 Arm Cortex-M4 at 48 MHz.

Compared with UNO R3, UNO R4 adds

The UNO R4 WiFi additionally includes an ESP32-S3 for Wi-Fi and Bluetooth and a 12×8 LED matrix.

Official specifications list 256 kB Flash, 32 kB RAM, 14 digital I/O, 6 analog inputs, one DAC, CAN, and 5 V GPIO operation. Arduino UNO R4 WiFi

6. Important UNO R3 → R4 electrical difference

Do not assume every UNO-compatible board can source the same pin current.

Arduino specifies approximately

This matters when driving

The general rule is:

Check the specific board’s datasheet, not the board shape.

7. Nano family

Nano boards are compact and breadboard friendly.

Current examples include:

Nano ESP32

Arduino Nano ESP32

Nano 33 BLE Rev2

Arduino Nano 33 BLE Rev2

The lesson is that “Nano” describes a form factor more than one processor architecture.

8. MKR family

MKR boards were designed around compact connected systems.

For example, the MKR WiFi 1010 uses

Arduino MKR WiFi 1010

MKR boards are useful for learning

9. GIGA R1 WiFi

The GIGA R1 WiFi is a much more capable board.

It uses an STM32H747 with

Arduino GIGA R1 WiFi

This is closer to a serious embedded-control platform than a simple beginner board.

10. Portenta H7

The Portenta H7 is built around an STM32H747 dual-core MCU.

Important capabilities include

Arduino Portenta H7

Portenta is where the Arduino ecosystem begins overlapping heavily with professional embedded development.

11. UNO Q and Linux-capable Arduino boards

The Arduino ecosystem now also includes boards where a Linux-capable application processor works alongside a microcontroller.

This changes the architecture:

\[\boxed{ \text{Linux application processor} + \text{real-time MCU} }\]

instead of one bare-metal MCU.

This type of board is useful when a project needs

while still retaining deterministic low-level I/O through an MCU.

Treat these boards conceptually closer to a single-board computer + MCU than to a traditional Uno.

12. Voltage level is one of the first things to check

Two common logic domains are

\[5\ \mathrm V\]

and

\[3.3\ \mathrm V.\]

Never assume a 3.3 V input is 5 V tolerant.

Examples:

Connecting 5 V directly into a non-tolerant 3.3 V input can damage the MCU.

Use

when necessary.

13. GPIO

A GPIO pin can usually be configured as

Arduino hides the register details with

pinMode(8, OUTPUT);
digitalWrite(8, HIGH);

Underneath, the MCU is changing direction and output registers.

For fast or deterministic work, direct register/peripheral access can be dramatically faster than repeated high-level calls.

14. Inputs must not float

A disconnected CMOS input can assume unpredictable values.

Use

A switch is often wired as

\[\text{GPIO} \rightarrow \text{switch} \rightarrow GND\]

with an internal pull-up enabled.

15. Debouncing

Mechanical switches do not transition cleanly.

Contacts bounce for milliseconds.

Solutions include

Never interpret every raw edge from a mechanical button as a genuine press.

16. ADC

For a deeper treatment of converter architecture and specifications—including ENOB, SINAD, SFDR, INL/DNL, jitter, SAR/pipeline/delta-sigma ADCs, DAC settling and RF converters—see ADC & DAC — Data Converters.

An ADC converts voltage into a digital code.

For an ideal $N$-bit ADC,

\[LSB = \frac{V_{REF}}{2^N}.\]

A 10-bit ADC with 5 V reference gives approximately

\[LSB\approx4.88\ \mathrm{mV}.\]

Important ADC concepts:

Higher nominal bit depth does not automatically mean equivalent effective resolution.

17. ADC input is not infinitely benign

The ADC often contains a sample-and-hold capacitor.

A high source impedance may not charge that capacitor quickly enough.

Therefore sensor-output impedance matters.

Possible solutions:

This becomes important when measuring precision analog signals.

18. DAC versus PWM

A real DAC outputs an analog voltage.

PWM produces a pulse train with duty cycle

\[D=\frac{t_{ON}}{T}.\]

The average is approximately

\[V_{avg}=DV_{DD}\]

after suitable low-pass filtering.

Do not confuse

analogWrite(...)

with a physical DAC unless the selected pin/board actually contains one.

UNO R4 includes a DAC; UNO R3 does not.

19. PWM

PWM is useful for

PWM relies on hardware timers.

Changing timer configuration can therefore affect other functions or libraries that use the same timer.

20. Timers

Timers are among the most important MCU peripherals.

They can generate

For serious embedded work, learn the MCU’s timer architecture beyond

delay(...)

because hardware timers provide much better timing precision.

21. Interrupts

An interrupt temporarily suspends normal code to service an event.

Typical interrupt sources:

An interrupt service routine should usually be

Avoid long delays, printing large messages, or doing heavy computation inside an ISR.

22. Polling versus interrupt-driven design

Polling:

if (digitalRead(pin)) {
    // respond
}

is simple.

Interrupt-driven systems react asynchronously.

A good embedded architecture often combines

23. UART

UART is asynchronous serial communication.

Signals:

Important parameters:

UART is excellent for

24. I²C

I²C uses

Multiple devices share the same bus and use addresses.

Important points:

Typical devices:

25. SPI

SPI commonly uses

Advantages:

Disadvantage:

Common SPI devices:

For RF laboratory automation, SPI is particularly important because many PLLs, attenuators, switches, and transceiver ICs are register-programmed through SPI.

26. CAN

CAN is a robust differential communication bus widely used in

Important distinction:

A microcontroller’s CAN peripheral is not the entire physical interface.

You normally still need an external CAN transceiver connected to CAN-H/CAN-L.

The UNO R4 includes a CAN controller but requires an external transceiver for a real CAN bus.

27. USB

Modern Arduino boards may support USB as more than just a serial-programming cable.

Depending on the MCU, USB can provide

The UNO R4’s native USB capability, for example, allows HID functionality.

28. Wi-Fi and Bluetooth

Wireless boards typically contain either

Know the difference between

Wireless protocols bring additional concerns:

29. Sensors

Arduino is excellent for quickly interfacing sensors.

Common sensor outputs include

A sensor interface is not just code.

Also understand

30. Driving loads: never power motors directly from GPIO

GPIO is meant for logic-level current.

Do not directly drive

Use a driver stage such as

For inductive loads, include a flyback path.

31. MOSFET low-side switch

A common architecture is

\[\text{GPIO} \rightarrow \text{gate resistor} \rightarrow \text{logic MOSFET} \rightarrow \text{load}.\]

The MCU controls the MOSFET; it does not supply the load current.

Check

32. Grounds must have a reference relationship

If two circuits communicate using single-ended logic, they normally need a common reference ground.

However, careless grounding can create

For noisy motors or RF systems, think about current return paths, not merely whether two points are labeled GND.

33. Powering the board

Possible sources include

Do not blindly feed voltage into multiple power inputs simultaneously.

Check

A linear regulator dropping

\[V_{in}-V_{out}\]

dissipates approximately

\[P=(V_{in}-V_{out})I.\]

34. Decoupling

Digital switching creates current transients.

Good practice includes

For custom Arduino-compatible hardware, the MCU datasheet’s decoupling recommendations matter.

35. Arduino program structure

A basic sketch contains

void setup() {
    // runs once
}

void loop() {
    // repeats forever
}

This is convenient but conceptually equivalent to

\[\text{initialization} \rightarrow \text{infinite control loop}.\]

Once you understand that, Arduino becomes much less mysterious.

36. Avoid blocking code

Code such as

delay(1000);

stops ordinary program progress for that interval.

For responsive systems, prefer time-based scheduling:

if (millis() - last >= interval) {
    last = millis();
    // task
}

This is the beginning of cooperative embedded scheduling.

37. State machines

A robust embedded program often uses explicit states:

\[\boxed{ IDLE \rightarrow ARMED \rightarrow MEASURE \rightarrow PROCESS \rightarrow REPORT }\]

State machines scale much better than deeply nested delays and conditional statements.

38. Memory

Understand the difference between

On small AVR boards, RAM is extremely limited.

Symptoms of memory problems can include

39. Integer sizes matter

Embedded processors use fixed-width data types.

Prefer explicit types when size matters:

uint8_t
uint16_t
uint32_t
int32_t

Be alert to

For example,

3 / 2

is integer division and produces 1, not 1.5.

40. Floating point

Modern 32-bit MCUs often handle floating point far better than an 8-bit AVR.

The RA4M1 used on UNO R4 includes an Arm Cortex-M4 with FPU support.

Still, floating point may be unnecessary for simple timing, counters, and fixed-point control.

Choose numeric representation based on precision, speed, and determinism.

41. Libraries are useful—but inspect assumptions

Libraries speed development dramatically.

But check

Two libraries can conflict because both expect exclusive use of the same hardware peripheral.

42. Arduino core versus MCU datasheet

The Arduino API might expose

analogRead()

but the actual MCU ADC has many more controls:

For deeper work, move through this hierarchy:

\[\boxed{ \text{Arduino function} \rightarrow \text{Arduino core implementation} \rightarrow \text{MCU peripheral} \rightarrow \text{datasheet/reference manual}. }\]

43. Debugging

Basic debugging:

More advanced boards support hardware debugging through

The Nano ESP32, for example, supports onboard debugging without an external probe.

44. Logic analyzer versus oscilloscope

Use a logic analyzer for

Use an oscilloscope for

A digital bus can decode correctly while still having poor analog signal integrity.

45. Real-time behavior

Arduino is often used bare metal or with lightweight scheduling.

Real-time behavior depends on

If deterministic timing matters, measure it with a scope or logic analyzer.

Do not assume a line of C++ runs at a predictable instant just because the code looks simple.

46. RTOS

On more advanced boards, a real-time operating system can provide

An RTOS helps organize complex systems but does not automatically make them deterministic.

You still need to understand scheduling and shared-resource behavior.

47. Arduino for RF and laboratory work

Arduino can be very useful for

For example,

\[\text{Arduino} \xrightarrow{SPI} \text{PLL / DSA / RF switch}\]

can create a simple custom RF-control subsystem.

48. What Arduino is not good at

A typical Arduino MCU is not the right tool for

Use

when the application demands it.

49. Arduino versus Raspberry Pi

Arduino MCU board

Raspberry Pi / Linux SBC

A common system uses both:

\[\boxed{ \text{Linux computer} \leftrightarrow \text{Arduino/MCU} \leftrightarrow \text{real-time hardware}. }\]

50. Arduino versus FPGA

Arduino executes instructions sequentially on a CPU.

An FPGA implements hardware logic that operates in parallel.

Use an FPGA when you need

Use Arduino when you need fast development and MCU-level control.

51. What you should be able to do

A useful Arduino skill set is the ability to:

If you can do these things, you understand Arduino at an engineering level rather than only at a tutorial level.

52. Board-selection summary

Need Good starting category
Learn basic embedded electronics UNO R4 / UNO R3
Modern 5 V prototype UNO R4
Wi-Fi/Bluetooth in UNO format UNO R4 WiFi
Small Wi-Fi/Bluetooth project Nano ESP32
BLE + inertial sensing Nano 33 BLE / Sense
Battery/IoT prototype MKR
Many I/O / advanced robotics GIGA R1
Professional/industrial MCU system Portenta
Linux + real-time MCU UNO Q / newer Q-class board
Extreme deterministic digital logic FPGA instead of Arduino

53. Official references

For a deeper board-level treatment of I²C, SPI, UART, USB and high-speed interface layout, see Hardware Interfaces & PCB/Flex Design.

Related: Measurements & Instruments · Computational Methods · Silicon Interfaces & SoC · Signal Integrity & Power Integrity · Microwave & Space Electronics Components