UNO R3 Dip Development Board ATMega328

• Digital I/O: D0–D13 (PWM on D3, D5, D6, D9, D10, D11)
• Analog In: A0–A5 (I²C on A4=SDA, A5=SCL)
• SPI: D10 (SS), D11 (MOSI), D12 (MISO), D13 (SCK)
• UART: D0 (RX), D1 (TX)
• Power: 5 V, 3.3 V (~50 mA), GND, VIN (7–12 V recommended)
• Reset: RST pin and on-board button (socketed MCU is user-replaceable)

Tip: Use a separate supply for motors/servos; connect grounds together.

Quick sketches to verify I/O, ADC, and I²C.

Blink (D13 LED)

// UNO R3 DIP — Blink built-in LED
void setup(){ pinMode(LED_BUILTIN, OUTPUT); }
void loop(){ digitalWrite(LED_BUILTIN, HIGH); delay(500); digitalWrite(LED_BUILTIN, LOW); delay(500); }

Read Analog (A0) and Print

// UNO R3 DIP — Read A0 and print voltage
void setup(){ Serial.begin(115200); }
void loop(){
  int v = analogRead(A0);              // 0..1023
  float volts = v * (5.0/1023.0);      // ~0..5 V
  Serial.print("A0: "); Serial.print(v);
  Serial.print("  (~"); Serial.print(volts, 2); Serial.println(" V)");
  delay(200);
}

I²C Scanner (A4/A5)

#include <Wire.h>
// UNO R3 DIP — Quick I2C scanner
void setup(){
  Serial.begin(115200);
  Wire.begin(); // A4=SDA, A5=SCL
}
void loop(){
  byte count=0;
  for (byte addr=1; addr<127; addr++){
    Wire.beginTransmission(addr);
    if (Wire.endTransmission()==0){
      Serial.print("Found I2C device: 0x"); Serial.println(addr, HEX);
      count++; delay(2);
    }
  }
  if(!count) Serial.println("No I2C devices found.");
  delay(1000);
}

Talk to the UNO via USB serial on Raspberry Pi OS.

Python: Read Serial from UNO

# On the Pi: pip install pyserial
import serial, time

ser = serial.Serial('/dev/ttyACM0', 115200, timeout=1)  # or /dev/ttyUSB0
time.sleep(2)  # UNO resets on open
try:
  while True:
    line = ser.readline().decode(errors='ignore').strip()
    if line: print("UNO:", line)
except KeyboardInterrupt:
  pass
finally:
  ser.close()

Enable Serial Access

• Find the port: ls /dev/ttyACM* or /dev/ttyUSB*
• Add user to dialout: sudo usermod -aG dialout $USER (reboot)

ESP32/ESP8266 ↔ UNO: Use UART (3.3 V logic on ESP) or I²C/SPI level-shifted. UNO TX (5 V) must be level-shifted or divided before feeding ESP RX. Always share GND.

ESP32 (Arduino core): UART bridge to UNO

#include <HardwareSerial.h>
// ESP32 pins: RX2=16, TX2=17 (default), connect to UNO: TX -> divider -> ESP32 RX2, ESP32 TX2 -> UNO RX
HardwareSerial Uno(2);
void setup(){
  Serial.begin(115200);
  Uno.begin(115200, SERIAL_8N1, 16, 17); // RX, TX
}
void loop(){
  if (Uno.available()) Serial.write(Uno.read());
  if (Serial.available()) Uno.write(Serial.read());
}

ESP8266 (Arduino core): Read UNO lines

// Use a CH divider on UNO TX -> ESP8266 RX (GPIO3)
void setup(){ Serial.begin(115200); }   // UART0 on ESP8266
void loop(){
  if (Serial.available()){
    String s = Serial.readStringUntil('\n');
    Serial.print("[UNO] "); Serial.println(s);
  }
}

ESP-IDF (C): UART echo with UNO

#include "driver/uart.h"
#include "driver/gpio.h"
#define UARTN UART_NUM_1
#define TXD   (GPIO_NUM_17)
#define RXD   (GPIO_NUM_16)  // UNO->ESP (level-shift to 3.3 V!)

void app_main(void){
  const uart_config_t cfg = {
    .baud_rate=115200, .data_bits=UART_DATA_8_BITS, .parity=UART_PARITY_DISABLE,
    .stop_bits=UART_STOP_BITS_1, .flow_ctrl=UART_HW_FLOWCTRL_DISABLE
  };
  uart_param_config(UARTN, &cfg);
  uart_set_pin(UARTN, TXD, RXD, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE);
  uart_driver_install(UARTN, 1024, 0, 0, NULL, 0);

  uint8_t buf[128];
  while (1) {
    int n = uart_read_bytes(UARTN, buf, sizeof(buf), pdMS_TO_TICKS(20));
    if (n > 0) uart_write_bytes(UARTN, (const char*)buf, n); // echo back
  }
}

For I²C, set UNO as peripheral with a library (e.g., Wire on 0x12) and ESP32 as master; use bidirectional level shifting. See Resources → Espressif for ESP-IDF drivers and examples.

Official UNO R3 (ATmega16U2) is usually plug-and-play. Some clones use CH340/CP210x/FT232 USB bridges.

Windows

• UNO (ATmega16U2): native WinUSB/COM.
• CH340/CH341: install CH341 Driver (GitHub).

macOS

• Many bridges supported natively; use notarized installers if needed.
• Ports appear as /dev/tty.usbmodem* or /dev/tty.usbserial*.

Linux / Raspberry Pi OS

• Usually plug-and-play (cdc_acm, ch341).
• If permission denied, add user to dialout and re-login.

Arduino

• Arduino Project Hub
• Arduino Playground
• Arduino IDE Download
• Install Arduino Libraries

Raspberry Pi

• Raspberry Pi Projects
• GPIO Zero Docs
• Raspberry Pi Docs
• Raspberry Pi Software
• Pi Getting Started

Espressif

• ESP-IDF Programming Guide (Official)
• ESP-IDF “Get Started”
• Espressif Technical Docs / Datasheets / Design Guidelines
• Espressif Docs (ReadTheDocs mirror)
• ESP-IDF GitHub Repository
• ESP-IDF Examples (Resources)
• ESP8266 RTOS SDK (Legacy)
• ESP8266 RTOS SDK (GitHub)
• Espressif Matter (Docs)
• Espressif Matter (GitHub)
• Espressif Systems — YouTube
• ESP-IDF Tutorials — Playlist/Search
• PlatformIO + ESP-IDF
• Arduino Core for ESP32 (GitHub)

Drivers / Other

• CH341 Driver (GitHub)

Important Notice For educational, prototype, experimental, laboratory and R&D use only.(non-RoHS)

WEEE

Not subject to WEEE marking; obligations apply to final equipment.

Manufacturer

Little Muffins Things Limited
166 River Heights, 90 High Street
London E15 2GQ
littlemuffinsthings.com

EU Responsible Person

eucomply OU
Parnu mnt. 139b–141
13117 Tallinn, Estonia
hello@eucompliancepartner.com