Arduino, Modules and Shields: A Practical Guide to Choosing and Connecting Hardware

Arduino makes it straightforward to turn an idea into a working electronic prototype. Pick a board, connect a sensor, install a library and upload a sketch: within minutes you can see live readings. The difficult part often starts when a second module or a shield is added. A connector fits but uses the wrong voltage; two I²C devices respond at the same address; a display quietly reserves a pin needed elsewhere; or a motor causes the board to reset.

This guide explains what an Arduino board actually does, how modules and shields differ, and how to choose parts that will work together. It also includes a small, testable temperature, humidity and pressure logger. The principles apply to classroom builds and to prototypes destined for a custom PCB.

Scope: This article covers low-voltage electronics powered from a suitable USB supply. Check the manual and the exact product revision before applying power. A connector shape or a printed “Arduino compatible” label is not an electrical specification.

What Is Arduino?

Arduino is an ecosystem of programmable boards, software tools, libraries and documented examples. In a typical build, the board’s microcontroller runs a sketch: a program with setup(), executed once on start-up, and loop(), executed repeatedly. The Arduino IDE compiles and uploads that program through the board’s supported connection. Arduino’s software page and documentation hub are the starting points for a specific board’s setup and pinout.

The board reads inputs such as a button, analogue voltage or digital sensor, then drives outputs such as an LED or a control signal. It cannot supply arbitrary current from a GPIO pin. Loads that need more current require a driver and a supply chosen for the load. A board’s 5 V or 3.3 V pin also has a finite current budget; the safe allowance depends on the board, power source and regulator. Check those figures in its manual rather than assuming the USB connector makes every attached device safe to power.

“Arduino” does not refer to one interchangeable pinout or processor. Compare three useful reference boards:

Arduino documents the UNO R3’s 14 digital I/O and six analogue inputs, the UNO R4 WiFi’s 5 V GPIO, and the Nano ESP32’s 3.3 V pins. These are board-level facts; check an individual peripheral’s limits separately. The voltage a board accepts at its power input is not the voltage its GPIO safely accepts.

Board, Module or Shield: What Is the Difference?

The Arduino board provides the processor, power circuitry and accessible pins. A module is a smaller function block such as a sensor or display breakout. It connects through wires or a cable and may include a regulator, level shifter, pull-up resistors or none of these. A shield is a larger add-on board intended to mate with a particular board’s header pattern; a shield may contain several modules’ worth of circuitry.

The distinction is mechanical as well as functional. A four-wire sensor breakout can be repositioned on a breadboard and reused with a different board. An UNO-format shield stacks neatly but may cover headers, reserve pins and conflict with another shield. A Nano-format carrier or a Qwiic/I²C breakout is not automatically an UNO-format shield. Always identify the exact board, module or shield revision before following someone else’s wiring diagram.

These categories describe common arrangements, not universal specifications. Some sensor modules with the same chip use different regulators or I²C pull-ups. Read the breakout board documentation as well as the sensor chip datasheet.

Understand the Four Common Interfaces

Analogue input

An analogue input converts an input voltage into a number. It is useful for a potentiometer or an analogue-output sensor. The valid voltage range and resolution depend on the board and its configured reference. Do not assume every analogRead() result means 0–5 V or that all boards return the same resolution by default. A digital sensor may contain an analogue sensing element internally but expose only a digital interface.

GPIO and PWM

GPIO stands for general-purpose input/output. A digital input reads a low or high logic state; a digital output drives one. INPUT_PULLUP can give a button a defined idle state without an external resistor when the board supports it. PWM (pulse-width modulation) switches a pin at a rate with a chosen duty cycle. It is useful for dimming an LED through an appropriate circuit, but it is not the same as a smooth analogue voltage. Confirm which pins support PWM on the selected board.

I²C

I²C uses a shared clock line, SCL, and data line, SDA. Devices on the bus have addresses, so several can share those two signal lines if their addresses do not clash. The lines use pull-up resistors; the resulting bus voltage must be safe for every connected device. Two breakouts may each include pull-ups, changing the combined load. Keep early breadboard runs short, use the board’s labelled SDA/SCL pins, and check the module’s address setting. Arduino’s I²C explanation covers the protocol; a scan can help locate a responsive address but cannot identify a device or prove correct operation.

SPI and UART

SPI normally uses a clock, data lines and a separate chip-select signal for each device. It suits displays and storage where the chosen part needs a faster link, but every shield may claim particular pins. Check whether a shield expects SPI through the six-pin ICSP connector or through particular numbered headers, and compare its schematic with the chosen board. UART is an asynchronous serial link with transmit and receive signals. Its electrical voltage still matters; a “serial” label does not mean that an RS-232 cable or an unknown voltage can be connected directly to Arduino GPIO.

Choosing a Compatible Shield

Header alignment is necessary but insufficient. Arduino’s UNO R4 shield guide notes that UNO R4 boards operate at 5 V and highlights potential issues with 3.3 V peripherals. The R4 may also need a different library implementation from the older AVR-based UNO R3. Before ordering, work through this checklist:

1. Form factor: Is the add-on made for UNO, Nano, MKR or another board family? Do headers, offsets and height match?
2. Logic and supply voltage: What powers the shield, and what voltage appears on every signal it drives back into the board? Look for actual level-shifting circuitry rather than assuming it exists.
3. Pins and peripheral routing: Which pins are reserved for chip select, interrupt, reset, serial, PWM or analogue functions? Do stacked shields claim the same pin?
4. I²C addresses: Can duplicates be changed by a solder jumper or address pin? A different module can still share the same address.
5. Power budget: Add the board, shield and peripheral currents at their actual operating conditions. A motor or bright display may need its own appropriately rated low-voltage supply.
6. Software: Check whether the maintained library supports the board’s processor and core. A successful compile does not prove the hardware pin mapping is right.
7. Mechanical access: Can you still reach reset, USB, headers and mounting holes? Can two shields stack without metal parts touching?

Write these answers in a pin-allocation table before wiring. It is quicker to correct a conflict on paper than after soldering.

Example Build: An I²C Environmental Logger

For a contained first project, connect a documented BME280 temperature, humidity and pressure breakout to an UNO R4 WiFi, then report readings over USB serial. This teaches the module workflow without depending on a shield’s hidden pin assignments. Use a specific breakout rated for 5 V host wiring, such as the Adafruit BME280 breakout described in its Arduino wiring guide. A bare BME280 chip or an unspecified low-cost module may have different voltage limits. Adafruit documents 0x77 as its breakout’s default I²C address and 0x76 as an alternative when its address connection is changed; verify the exact board you have.

Parts and wiring

You need an UNO R4 WiFi, a suitable USB cable, the documented BME280 breakout, four short jumper wires and a breadboard if the breakout uses loose headers. With all power disconnected, connect breakout VIN to the UNO’s 5 V, breakout GND to GND, breakout SCK/SCL to the board’s labelled SCL, and breakout SDI/SDA to labelled SDA. Those label pairs describe the Adafruit breakout’s I²C mode; other boards may label them differently. Inspect the board’s own pinout if a connector differs. Do not connect a bare 3.3 V-only module to the 5 V rail.

Install the Adafruit BME280 Library and its prompted dependencies through the Arduino IDE Library Manager. Select the correct UNO R4 WiFi board and port. The following sketch checks 0x77, then 0x76, and stops if neither responds as a BME280. The serial output includes units and a fixed one-second measurement interval; it does not claim calibrated ambient accuracy.

#include <Wire.h>
#include <Adafruit_BME280.h>

Adafruit_BME280 bme;
uint8_t sensorAddress = 0;
unsigned long nextReading = 0;

void setup() {
  Serial.begin(115200);
  Wire.begin();

  if (bme.begin(0x77)) {
    sensorAddress = 0x77;
  } else if (bme.begin(0x76)) {
    sensorAddress = 0x76;
  } else {
    Serial.println("BME280 not found; check wiring, voltage and address.");
    while (true) { delay(1000); }
  }

  Serial.print("BME280 address: 0x");
  Serial.println(sensorAddress, HEX);
}

void loop() {
  if (millis() < nextReading) return;
  nextReading = millis() + 1000;

  Serial.print("Temperature C: ");
  Serial.print(bme.readTemperature(), 2);
  Serial.print(" | Humidity %: ");
  Serial.print(bme.readHumidity(), 2);
  Serial.print(" | Pressure hPa: ");
  Serial.println(bme.readPressure() / 100.0F, 2);
}

Wire.begin() starts the board’s I²C interface. bme.begin() probes a device and initialises the library; the two tries account for the documented address options. In loop(), millis() spaces readings without a long blocking delay. The library returns pressure in pascals, so dividing by 100 converts it to hectopascals. The displayed decimal places are formatting, not proof of sensor accuracy. If you need robust operation across a millis() rollover, use elapsed-time subtraction instead of the simple comparison shown here.

Open Serial Monitor at 115200 baud. A detected device should print its address and then values approximately once per second. Touching or breathing near the sensor can change a reading, but compare against an independent instrument before making a quantitative accuracy claim. Keep the module away from a warm voltage regulator or computer exhaust if the aim is room temperature.

Testing and Troubleshooting

Test in layers. First upload a known built-in example to prove board selection and USB communication. Then attach one add-on, check supply voltage with a meter, and run the smallest available example. Only after it works should you combine libraries and shields. This process separates a wiring fault from a software conflict.

The most dangerous false assumption in ordinary low-voltage prototyping is that all connector power rails and signal pins tolerate the same voltage. Arduino’s power-consumption guidance explicitly warns that applying 5 V to a 3.3 V pin can damage a board. Make each interconnection’s voltage visible in your wiring notes.

When to Move Beyond the Breadboard

A breadboard is ideal for learning a sensor and checking a library. It becomes less useful when long wires, multiple connectors and repeated handling make a build unreliable. Move to a carrier or custom PCB once the schematic, pin table, voltage domains and software have been tested individually.

The PCB should label supply voltage and connector orientation, provide local decoupling at every active device, keep high-current paths out of sensitive sensor returns, and leave access to programming and debugging connectors. If you are designing a shield, use the board maker’s mechanical drawing rather than measuring a photograph. Include test points for power and critical buses. Treat 3.3 V-to-5 V translation as a circuit design task with a specified interface, not as a jumper-wire trick.

Frequently Asked Questions

Can I use any Arduino shield with any Arduino board?

No. Check the physical headers, logic voltage, power budget, reserved pins and library architecture. A shield that fits an UNO form factor may still depend on an older processor’s registers or a particular SPI connection.

Are Arduino modules always 5 V tolerant?

No. The sensor chip may be 3.3 V-only, and different breakout boards can add different support circuits. Use the exact module’s schematic or product documentation.

Can two I²C modules share the same SDA and SCL pins?

Usually, if the devices have distinct addresses and compatible bus voltage and pull-ups. If two fixed-address devices collide, choose an address option if available or redesign the bus arrangement.

Is a shield better than a separate module?

A shield is convenient for a defined board and may produce tidier wiring. A module offers more placement flexibility. Choose on electrical compatibility and pin use before appearance.

Why does an Arduino reset when a motor starts?

A brief drop in the supply voltage or poor return-current routing is a common cause. Stop the test, check the load’s required current and use a suitable driver and appropriately rated low-voltage power arrangement.

Conclusion

Arduino boards, modules and shields make prototyping fast because their hardware and libraries can be combined. The reliable way to combine them is to verify five things every time: voltage, pin use, bus address, software support and power. Start with one documented module, test it alone, and record the connections before adding another. When a breadboard design has earned its way into a permanent build, explore our PCB design guide or contact PCB Electronics about a labelled carrier board or shield prototype.