What Can I Do With an Arduino? A Practical Datalogger Build & FAQ

When makers ask, "what can I do with an Arduino?", the most honest answer is: almost anything that requires reading sensors, controlling actuators, or logging data. But abstract lists of "top 10 projects" rarely help you actually build something. To answer this practically, we are going to build a multi-protocol environmental datalogger. This single build covers I2C (for sensors and displays), SPI (for storage), and serial data parsing—the foundational triad of 90% of embedded projects.

By the end of this guide, you will have a working bench instrument that logs temperature, humidity, and barometric pressure to an SD card while displaying live readings on an OLED screen. We will also cover the exact debugging steps when things go wrong, and answer the most common long-tail questions about Arduino capabilities.

The "What Can I Do" Starter Spec Sheet

This build targets the Arduino Uno R4 Minima (ABX00080). While the classic Uno R3 works fine, the R4 Minima features a 48 MHz Renesas RA4M1 ARM Cortex-M4 processor, giving you more headroom for floating-point math and faster SPI bus speeds without breaking the $20 price point.

Parts List & 2026 Pricing

Component	Exact Variant / Part Number	Protocol	Est. Price
Microcontroller	Arduino Uno R4 Minima (ABX00080)	N/A	$20.00
Environmental Sensor	Adafruit BME280 Breakout (2652)	I2C / SPI	$19.95
Display	SSD1306 128x64 Monochrome OLED (I2C)	I2C	$12.50
Storage	Catalex MicroSD Adapter + 8GB FAT32 Card	SPI	$8.00
Wiring & Power	830-point breadboard, 22 AWG jumper wires, 5V USB-C PSU	N/A	$15.00

Pin Mapping Table

The Uno R4 Minima maintains backward compatibility with the classic Uno footprint, but features dedicated I2C headers. For breadboard simplicity, we will use the A4/A5 I2C lines and the standard ICSP-adjacent SPI pins.

Module	Module Pin	Arduino Uno R4 Pin	Notes
BME280 & OLED (Shared I2C Bus)	SDA / SCL	A4 / A5	Ensure 4.7kΩ pull-ups are on the breakout boards
BME280 & OLED	VCC / GND	5V / GND	Both modules have onboard 3.3V regulators
MicroSD Adapter	CS (SS)	D10	Must be D10 for hardware SS on Uno architecture
MicroSD Adapter	MOSI / MISO / SCK	D11 / D12 / D13	Standard hardware SPI bus

Step-by-Step Assembly

1. Prep the SD Card: Format your MicroSD card to FAT32 using your PC. The Arduino SD library will fail to mount exFAT or NTFS partitions larger than 32GB.
2. Seat the MCU: Place the Arduino Uno R4 Minima across the center trench of the breadboard.
3. Wire the I2C Bus: Connect A4 to the SDA rail and A5 to the SCL rail. Run power (5V) and ground to the opposite rails. Plug in both the BME280 and the OLED display to these shared rails. I2C is a multi-drop bus; as long as their addresses don't conflict (0x76 for BME, 0x3C for OLED), they will share the wires perfectly.
4. Wire the SPI Bus: Connect the SD adapter's CS to D10, MOSI to D11, MISO to D12, and SCK to D13. Bench tip: Cheap Catalex SD adapters often lack logic level shifters. If your SD card gets hot to the touch, add a 2.2kΩ/3.3kΩ voltage divider on the MOSI, SCK, and CS lines to drop the 5V logic down to the 3.3V the SD card expects.
5. Verify Power Draw: The OLED, BME280, and SD card write spikes can pull up to 150mA. Ensure your USB-C power supply is rated for at least 1A to prevent brownouts.

Complete Compilable Code

This sketch targets the Arduino Uno R4 Minima. Before compiling, use the Arduino IDE Library Manager to install Adafruit BME280 Library, Adafruit SSD1306, and Adafruit Unified Sensor. The built-in SD and SPI libraries are used for storage.

#include <Wire.h>
#include <SPI.h>
#include <SD.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_BME280.h>
#include <Adafruit_SSD1306.h>

// --- PIN DEFINITIONS ---
#define SD_CHIP_SELECT 10
#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64
#define OLED_RESET -1
#define OLED_I2C_ADDR 0x3C
#define BME_I2C_ADDR 0x76

// --- OBJECT INITIALIZATION ---
Adafruit_BME280 bme;
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);
File dataFile;

void setup() {
  Serial.begin(115200);
  while (!Serial) { delay(10); } // Wait for serial port (native USB on R4)

  // 1. Initialize OLED Display
  if (!display.begin(SSD1306_SWITCHCAPVCC, OLED_I2C_ADDR)) {
    Serial.println(F("SSD1306 allocation failed"));
    while (true); // Halt execution
  }
  display.clearDisplay();
  display.setTextSize(1);
  display.setTextColor(SSD1306_WHITE);
  display.setCursor(0, 0);
  display.println("System Booting...");
  display.display();

  // 2. Initialize BME280 Sensor
  if (!bme.begin(BME_I2C_ADDR)) {
    Serial.println("Could not find a valid BME280 sensor, check wiring!");
    display.clearDisplay();
    display.setCursor(0,0);
    display.print("ERR: BME280\nCheck I2C Addr");
    display.display();
    while (true);
  }

  // 3. Initialize SD Card
  if (!SD.begin(SD_CHIP_SELECT)) {
    Serial.println("SD card failed, or not present");
    display.clearDisplay();
    display.setCursor(0,0);
    display.print("ERR: SD Card\nCheck FAT32 Format");
    display.display();
    while (true);
  }

  // Write CSV Header if file is new
  dataFile = SD.open("datalog.csv", FILE_WRITE);
  if (dataFile) {
    if (dataFile.size() == 0) {
      dataFile.println("Temp_C,Humidity_Pct,Pressure_hPa");
    }
    dataFile.close();
  }

  display.clearDisplay();
  display.setCursor(0, 0);
  display.println("Sensors Online.");
  display.println("Logging to SD...");
  display.display();
  delay(1000);
}

void loop() {
  float temp = bme.readTemperature();
  float humidity = bme.readHumidity();
  float pressure = bme.readPressure() / 100.0F; // Convert Pa to hPa

  // Update OLED
  display.clearDisplay();
  display.setCursor(0, 0);
  display.printf("Temp: %.1f C\n", temp);
  display.printf("Hum:  %.1f %%\n", humidity);
  display.printf("Pres: %.1f hPa", pressure);
  display.display();

  // Log to SD Card
  dataFile = SD.open("datalog.csv", FILE_WRITE);
  if (dataFile) {
    dataFile.printf("%.2f,%.2f,%.2f\n", temp, humidity, pressure);
    dataFile.close();
  } else {
    Serial.println("Error writing to SD card");
  }

  // Serial output for PC debugging
  Serial.printf("%.2f, %.2f, %.2f\n", temp, humidity, pressure);
  
  delay(2000); // Log every 2 seconds
}

Debugging: First Three Things to Check When It Fails

Embedded debugging is about isolating the failure domain. If your build halts or throws errors in the Serial Monitor, check these three items in order:

1. I2C Address Mismatch

Exact Error String: Could not find a valid BME280 sensor, check wiring!

The Cause: The BME280 breakout boards come in two common I2C addresses: 0x76 and 0x77. Adafruit uses 0x77 by default, while cheaper Amazon/AliExpress clones often use 0x76. Furthermore, the OLED might be 0x3C or 0x3D.

The Fix: Run an I2C Scanner sketch (File > Examples > Wire > I2CScanner). Note the hex addresses that print to the serial monitor. Update #define BME_I2C_ADDR and #define OLED_I2C_ADDR in the code to match your specific hardware.

2. SD Card Filesystem Incompatibility

Exact Error String: SD card failed, or not present

The Cause: The Arduino SD.h library strictly requires a FAT16 or FAT32 partition. Modern 64GB+ cards default to exFAT, which the library cannot parse. Additionally, if D10 is not explicitly set as an OUTPUT and pulled HIGH before SD.begin(), the hardware SPI controller can hang.

The Fix: Use the official SD Memory Card Formatter from the SD Association (not your OS's default format tool) to force a proper FAT32 boot sector. If using a 64GB card, you may need a third-party tool like GUIFormat to bypass Windows' 32GB FAT32 limitation.

3. Power Rail Brownouts

Symptom: No explicit serial error, but the OLED flickers, the SD card writes corrupt data, or the Uno R4 randomly reboots.

The Cause: Writing to an SD card causes current spikes up to 150mA. If you are powering the board via a low-amperage USB hub or a PC port limited to 100mA, the voltage drops below the 4.5V brownout threshold, resetting the microcontroller.

The Fix: Power the Uno R4 via a dedicated 5V/2A USB-C wall adapter. If the issue persists, add a 100µF electrolytic capacitor across the 5V and GND rails on your breadboard to smooth out transient current spikes.

Extending and Simplifying the Build

Once the baseline datalogger is working, you can scale the project to match your exact needs.

Frequently Asked Questions

What can I do with an Arduino Uno without soldering?

You can build fully functional prototypes using solderless breadboards and pre-crimped jumper wires. For an even cleaner, solder-free experience, adopt the Stemma QT / Qwiic ecosystem. By using boards equipped with JST-SH 4-pin connectors (like the Adafruit BME280 or SparkFun OLEDs), you simply plug them together with I2C cables. This eliminates wiring errors and loose connections entirely, allowing you to build complex sensor arrays in minutes.

What can I do with an Arduino to make money?

Selling generic "Arduino projects" is difficult, but selling niche automation solutions is highly profitable. Makers make money by building custom test jigs for local manufacturing shops (e.g., an Arduino-powered bed-of-nails tester that checks PCB continuity), automated prop controllers for escape rooms, or bespoke environmental monitors for greenhouse growers. The value isn't in the $20 board; it's in the $2,000 labor savings your custom code provides the client.

What can I do with an old Arduino Nano?

The classic Arduino Nano (ATmega328P) is perfect for tight-space, low-power applications where the bulkier Uno won't fit. Use it for wearable electronics, drone telemetry nodes, or as a dedicated I2C slave device that offloads sensor polling from a more powerful main controller (like a Raspberry Pi). If you need even less power, you can use an ISP programmer to burn the Arduino bootloader onto a bare ATtiny85 chip, stripping the project down to an 8-pin DIP.

What can I do with an Arduino besides blink an LED?

Once you move past digital writes, the Arduino excels at PID control loops (using the PID_v1 library to maintain exact temperatures or motor speeds), interrupt-driven event counting (like reading a high-speed rotary encoder without blocking the main loop), and Direct Memory Access (DMA) on newer boards like the Uno R4 or ESP32 to stream ADC audio data without CPU intervention. The hardware is capable of industrial-grade control; it just requires moving beyond delay() based programming.