Arduino UNO R4 Minima und UNO R4 WiFi: Einstieg, Unterschiede und Migration vom UNO R3

Arduino UNO R4: Zwei Varianten, ein Formfaktor

Der Arduino UNO R4 ist der Nachfolger des sehr verbreiteten UNO R3. Äußerlich bleiben Pinleisten, Shield-Format und die Arduino-IDE weitgehend vertraut. Intern arbeitet aber kein 8-Bit-AVR mehr, sondern ein deutlich leistungsfähigerer 32-Bit-Mikrocontroller.

Beide R4-Modelle verwenden den Renesas RA4M1 mit ARM-Cortex-M4-Kern bei 48 MHz. Gegenüber dem ATmega328P des UNO R3 stehen wesentlich mehr Speicher und modernere Peripherie zur Verfügung.

UNO R3: ATmega328P, 16 MHz, 32 KB Flash, 2 KB SRAM
UNO R4 Minima / WiFi: Renesas RA4M1, 48 MHz, 256 KB Flash, 32 KB SRAM
Beide UNO R4: 5-V-Logik, USB-C, 12-Bit-DAC, CAN-Controller (für einen CAN-Bus ist zusätzlich ein externer Transceiver nötig), integrierter Operationsverstärker
UNO R4 WiFi zusätzlich: ESP32-S3 für WLAN und Bluetooth Low Energy sowie 12×8-LED-Matrix

Der UNO R4 ist kein UNO R3 mit schnellerem Takt. Die Architektur wechselt von AVR auf ARM. Arduino-Sketches mit den üblichen Funktionen funktionieren oft direkt, Code mit AVR-spezifischen Registern oder Bibliotheken muss aber angepasst werden.

UNO R4 Minima oder UNO R4 WiFi auswählen

UNO R4 Minima: Für klassische Elektronikprojekte

Der UNO R4 Minima ist die schlanke und günstigere Variante. Er eignet sich besonders, wenn du ein UNO-kompatibles Board für Sensoren, Aktoren, Motorsteuerungen oder eigene Schaltungen suchst und kein WLAN benötigst.

Gleiche Rechenleistung und Haupt-Mikrocontroller wie beim WiFi-Modell
Kompatibler UNO-Pinout für viele klassische Shields
Gut für Steuerungen, Messprojekte und CAN-Anwendungen
Keine integrierte WLAN-, Bluetooth- oder LED-Matrix-Funktion

UNO R4 WiFi: Für vernetzte Projekte und schnelle Prototypen

Der UNO R4 WiFi enthält zusätzlich einen ESP32-S3. Dieser übernimmt WLAN- und Bluetooth-Low-Energy-Funktionen, während der RA4M1 weiterhin dein eigentlicher Arduino-Mikrocontroller ist. Dadurch musst du nicht zwischen einem klassischen UNO und einem WLAN-Board wählen.

WLAN im 2,4-GHz-Band
Bluetooth Low Energy
Integrierte 12×8-LED-Matrix für Statusanzeigen, Symbole und kleine Animationen
Qwiic-Anschluss (I²C) für steckbare 3,3-V-Sensoren – ohne Löten und ohne separaten Pegelwandler
Praktisch für MQTT, Web-APIs, Arduino Cloud und IoT-Projekte
Etwas komplexer bei Fehlersuche, da zusätzlich die Firmware des ESP32-S3 beteiligt ist

Wähle den Minima, wenn du kein WLAN brauchst und möglichst einfach starten möchtest. Der WiFi lohnt sich, sobald dein Projekt Daten ins Netzwerk senden, eine Weboberfläche bereitstellen oder Statusinformationen direkt auf der Matrix anzeigen soll.

Stromversorgung und USB-C richtig verwenden

Der UNO R4 verwendet einen USB-C-Anschluss für Programmierung und Versorgung. Ein normales USB-C-Datenkabel reicht aus. Achte darauf, dass es wirklich ein Datenkabel ist: Manche günstigen USB-C-Kabel sind reine Ladekabel und erlauben keine serielle Verbindung zur Arduino-IDE.

Was USB-C am UNO R4 bedeutet

USB-C liefert am Board normalerweise 5 V und stellt die Datenverbindung bereit.
Der Anschluss ist kein USB-C-Power-Delivery-Eingang. Verwende ein übliches 5-V-USB-Netzteil oder einen Computeranschluss.
USB-C macht das Board nicht automatisch zum USB-Host. USB-Sticks oder USB-Tastaturen lassen sich nicht einfach direkt anschließen.
Bei hoher Last für LEDs, Motoren oder Relais solltest du Aktoren über eine passende separate Versorgung betreiben.

Alternativ kannst du das Board über VIN oder die Hohlsteckerbuchse versorgen. Eine typische Eingangsspannung liegt bei 6 bis 24 V. Bei höheren Eingangsspannungen entsteht am Spannungsregler mehr Verlustwärme. Für energiehungrige Projekte ist deshalb eine sauber geregelte 5-V-Versorgung oft sinnvoller als beispielsweise ein 12-V-Steckernetzteil.

Versorge Motoren, LED-Strips und Relaismodule möglichst nicht über den 5-V-Pin des Arduino. Verbinde stattdessen die Masse der externen Versorgung mit GND des UNO R4, damit alle Signale einen gemeinsamen Bezug haben.

5 V und 3,3 V: Kompatibilität ohne beschädigte Sensoren

Der UNO R4 bleibt ein 5-V-Arduino. Seine Ein- und Ausgänge sind für die Verwendung mit vielen UNO-R3-Shields und klassischen 5-V-Bauteilen gedacht. Das ist praktisch beim Umstieg, verlangt bei modernen 3,3-V-Sensoren aber Aufmerksamkeit.

Die wichtigsten Regeln

Ein HIGH-Ausgang des UNO R4 kann ungefähr 5 V ausgeben.
Viele reine 3,3-V-Sensoren und ESP8266-/ESP32-Module dürfen an ihren Signaleingängen keine 5 V erhalten.
Ein 3,3-V-Signal wird an einem 5-V-Eingang nicht in jeder Schaltung zuverlässig als HIGH erkannt. Verlasse dich nicht pauschal darauf.
Der 3,3-V-Pin ist für kleine Verbraucher gedacht, nicht als leistungsstarke Sensor- oder Funkmodulversorgung.
I²C-Pull-up-Widerstände bestimmen den Pegel auf SDA und SCL. Pull-ups nach 5 V können einen 3,3-V-Sensor beschädigen.

Bei einem 3,3-V-Sensor mit I²C, SPI oder UART verwendest du im Zweifel einen Pegelwandler. Bei I²C ist ein bidirektionaler MOSFET-Level-Shifter eine Lösung. Manche Breakout-Boards besitzen bereits Spannungsregler und Pegelwandlung; prüfe trotzdem das Datenblatt des konkreten Moduls. Auf dem UNO R4 WiFi kannst du I²C-Sensoren mit Qwiic-Stecker außerdem direkt und pegelrichtig anschließen, da dieser Anschluss mit 3,3 V arbeitet.

Beispiel: 3,3-V-UART-Modul sicher anbinden

Wenn der UNO R4 Daten an RX eines 3,3-V-Moduls sendet, reduzierst du den 5-V-Pegel mit einem Pegelwandler oder einem Spannungsteiler. Die Rückrichtung vom Modul zum Arduino muss ebenfalls geprüft werden, weil 3,3 V nicht zwingend ein garantiert gültiger HIGH-Pegel sind.

UNO R4 TX (5 V) --- Pegelwandler / Spannungsteiler --- RX des 3,3-V-Moduls
UNO R4 RX        --- Pegelwandler -------------------- TX des 3,3-V-Moduls
UNO R4 GND       -------------------------------------- GND des Moduls

Für einfache Projekte ist ein Sensorboard, das ausdrücklich 3,3 V bis 5 V als Betriebsspannung und Logikpegel unterstützt, die unkomplizierteste Wahl.

Erste Schritte in der Arduino IDE

Installiere eine aktuelle Arduino IDE und wähle anschließend das passende Board-Paket. Der UNO R4 benötigt das Paket Arduino UNO R4 Boards; das alte AVR-Paket für den UNO R3 reicht nicht aus.

Öffne in der Arduino IDE den Boardverwalter.
Suche nach Arduino UNO R4 Boards und installiere das Paket.
Verbinde das Board mit einem USB-C-Datenkabel.
Wähle unter Werkzeuge → Board entweder „Arduino UNO R4 Minima“ oder „Arduino UNO R4 WiFi“.
Wähle unter Werkzeuge → Port den passenden seriellen Port.
Lade zunächst einen einfachen Blink-Sketch hoch.

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
}

void loop() {
  digitalWrite(LED_BUILTIN, HIGH);
  delay(500);
  digitalWrite(LED_BUILTIN, LOW);
  delay(500);
}

Der Sketch ist bewusst identisch zum UNO R3. Genau das ist die Stärke der Arduino-API: Für Standardaufgaben wie digitalWrite(), analogRead(), Wire und Serial bleibt dein Einstieg vertraut.

Die LED-Matrix des UNO R4 WiFi verwenden

Die 12×8-LED-Matrix gibt es nur auf dem UNO R4 WiFi. Sie eignet sich für Icons, Laufschriften, Messwerte in sehr kompakter Form und Debug-Ausgaben ohne zusätzliches Display. Gesteuert wird sie mit der Bibliothek Arduino_LED_Matrix.

Dieses Beispiel zeigt ein einfaches Smiley-Symbol. Jede Zeile besteht aus zwölf Binärwerten: 1 schaltet eine LED ein, 0 lässt sie aus.

#include <Arduino_LED_Matrix.h>

ArduinoLEDMatrix matrix;

byte frame[8][12] = {
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  { 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0 },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  { 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0 },
  { 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0 },
  { 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
};

void setup() {
  matrix.begin();
  matrix.renderBitmap(frame, 8, 12);
}

void loop() {
}

Die Matrix ist eine Anzeige, kein universelles Eingabefeld. Ihre Pins stehen dir nicht als zusätzliche freie GPIOs zur Verfügung. Plane sie daher als fest integriertes Ausgabegerät ein.

LED Matrix Tool

Dieses Tool hilft dir dabei, Bilder für das Matrix-Display des Arduino UNO R4 WiFi zu erstellen. Zeichne hierfür dein Bild auf der Zeichenfläche – ein Klick auf Code generieren erstellt den Code für deinen Sketch. Mit Kopieren landet er direkt in deiner Zwischenablage, bereit für die Arduino IDE.

Migration vom UNO R3: Was meist sofort funktioniert

Die meisten einsteigerfreundlichen Sketches lassen sich ohne Änderungen übernehmen. Dazu gehören insbesondere:

Digitale Ein- und Ausgänge mit pinMode(), digitalRead() und digitalWrite()
Timing mit millis(), micros() und delay()
Serielle Kommunikation über Serial
I²C über Wire
SPI über SPI
Übliche Sensorbibliotheken, sofern sie nicht direkt AVR-Hardware ansprechen
Viele Shields im klassischen UNO-Layout

Der UNO R4 ist dabei deutlich schneller: Allein der Takt liegt mit 48 MHz gegenüber 16 MHz rund dreimal so hoch, und der ARM-Kern erledigt pro Takt oft zusätzlich mehr. Damit ist sogar ein Spiel wie Snake auf dem Arduino möglich – wenn auch immer noch nicht so schnell wie auf einem ESP32. Die Geschwindigkeit kann nebenbei allerdings Timing-Fehler sichtbar machen: Code, der versehentlich auf die geringe Geschwindigkeit des UNO R3 angewiesen war, verhält sich auf dem R4 möglicherweise anders.

Typische Anpassungen bei AVR-spezifischem Code

Keine direkten AVR-Register übernehmen

Code mit Registern wie PORTB, DDRD, TCCR1A, ADMUX oder AVR-Interruptvektoren ist nicht portabel. Der RA4M1 besitzt völlig andere Register und Timer. Ersetze solche Stellen möglichst durch Arduino-Funktionen oder suche nach einer Bibliothek, die den UNO R4 unterstützt.

// AVR-spezifisch: nicht für UNO R4 geeignet
DDRB |= (1 << DDB5);

// Portabel: auf UNO R3 und UNO R4 nutzbar
pinMode(LED_BUILTIN, OUTPUT);

Datentypen sind anders groß

Auf dem UNO R3 ist int normalerweise 16 Bit breit. Auf dem UNO R4 ist int 32 Bit breit. Das verhindert manche Überläufe, kann aber Datenprotokolle, Speicherlayouts oder Code mit festen Annahmen verändern.

Verwende für klar definierte Datenbreiten besser Typen aus stdint.h:

#include <stdint.h>

int16_t temperaturZehntelgrad;
uint32_t zeitstempel;
uint8_t status;

PROGMEM und Flash-Daten prüfen

Auf AVR-Boards musste man große konstante Tabellen oft mit PROGMEM im Flash ablegen und mit speziellen Funktionen lesen. Auf dem UNO R4 ist diese AVR-Speichertrennung nicht in derselben Form vorhanden. Häufig reicht ein normales const-Array.

// Für neuen, portablen Code meist ausreichend:
const char text[] = "UNO R4 bereit";

Bestehender Code mit pgm_read_byte(), pgm_read_word() oder AVR-spezifischen PROGMEM-Makros sollte getestet und bei Problemen vereinfacht werden.

EEPROM nicht als selbstverständlich ansehen

Der ATmega328P des UNO R3 besitzt echte EEPROM-Hardware. Beim UNO R4 wird nichtflüchtiger Speicher anders umgesetzt. Wenn dein Projekt Einstellungen dauerhaft speichert, teste die verwendete EEPROM-Bibliothek auf dem R4 gezielt. Besonders wichtig sind Schreibzyklen, Datengröße und das Verhalten nach Reset oder Firmware-Upload.

Analog-Eingänge, PWM und DAC

Der UNO R4 bietet modernere Analogfunktionen als der UNO R3. Die ADC-Hardware arbeitet mit bis zu 14 Bit, während der UNO R3 10 Bit besitzt. Damit du die höhere Auflösung in einem Sketch tatsächlich erhältst, setzt du sie explizit.

void setup() {
  Serial.begin(115200);
  analogReadResolution(14);
}

void loop() {
  int wert = analogRead(A1);
  Serial.println(wert);
  delay(200);
}

Bei 14 Bit liegt der Messbereich bei 0 bis 16383. Die tatsächliche Genauigkeit hängt trotzdem von Referenzspannung, Versorgung, Sensor, Verdrahtung und Störeinflüssen ab. Mehr Bits bedeuten nicht automatisch eine rauschfreie Messung.

Eine Besonderheit ist der echte 12-Bit-DAC am Pin A0. Anders als PWM erzeugt ein DAC eine analoge Ausgangsspannung. Das ist beispielsweise für einfache Signalgeneratoren, Referenzwerte oder Audioexperimente interessant.

void setup() {
  analogWriteResolution(12);
}

void loop() {
  analogWrite(A0, 2048);  // ungefähr halber DAC-Bereich
}

Prüfe bei PWM-Projekten die verwendeten Pins und die erwartete Frequenz. Ein Motorcontroller, ein Servo oder ein LED-Treiber kann empfindlich auf andere Timer- oder PWM-Eigenschaften reagieren als auf dem UNO R3.

Häufige Probleme beim Umstieg und ihre Lösungen

Das Board erscheint nicht in der IDE

Wechsle das USB-C-Kabel; verwende sicher ein Datenkabel.
Vermeide zunächst passive USB-Hubs und teste einen direkten Anschluss am Computer.
Installiere oder aktualisiere das Paket „Arduino UNO R4 Boards“.
Wähle das korrekte Board-Modell und den korrekten Port.
Drücke bei einem fehlgeschlagenen Upload zweimal kurz die Reset-Taste. Das Board startet dann normalerweise im Bootloader-Modus und erscheint oft an einem anderen Port.

Eine alte Bibliothek kompiliert nicht

Meldungen mit Begriffen wie avr, AVR, PORTx oder fehlenden AVR-Headern zeigen meist, dass die Bibliothek nur für den UNO R3 und ähnliche AVR-Boards geschrieben wurde. Suche nach einer aktuellen, architekturübergreifenden Version oder ersetze die Bibliothek durch eine Variante mit ARM-Unterstützung.

Ein 3,3-V-Sensor liefert unplausible Werte oder wird heiß

Trenne die Schaltung sofort, wenn ein Modul ungewöhnlich warm wird. Prüfe dann Versorgungsspannung, Masseverbindung und Signalpegel. Besonders oft sind I²C-Pull-ups versehentlich mit 5 V verbunden oder ein 5-V-TX-Signal wurde direkt auf den Eingang eines 3,3-V-Moduls gelegt.

Ein altes Shield passt mechanisch, funktioniert aber nicht

Das UNO-Layout bedeutet keine vollständige elektrische oder softwareseitige Garantie. Prüfe, ob das Shield spezielle Timer, direkte AVR-Register, eine bestimmte Betriebsspannung oder hohe Stromaufnahme voraussetzt. Einfache Shields für Taster, LEDs oder viele I²C-Sensoren sind meist unkritisch; ältere Ethernet-, Display- oder Motor-Shields benötigen gelegentlich eine angepasste Bibliothek.

WLAN auf dem UNO R4 WiFi verbindet sich nicht

Nutze ein 2,4-GHz-WLAN; 5-GHz-only-Netze funktionieren nicht.
Prüfe SSID und Passwort sorgfältig, einschließlich Groß- und Kleinschreibung.
Aktualisiere bei Bedarf das Board-Paket und die Firmware-Komponenten über die Arduino-IDE.
Teste zunächst mit einem offiziellen WLAN-Beispiel, bevor du MQTT, HTTPS oder Cloud-Code hinzufügst.

Praktische Empfehlung für bestehende UNO-R3-Projekte

Gehe beim Umstieg schrittweise vor. Lade zuerst den unveränderten Sketch auf den UNO R4. Kompiliert er, teste Ein- und Ausgänge, Sensoren und die serielle Ausgabe einzeln. Erst danach lohnt es sich, höhere ADC-Auflösung, DAC, CAN oder die WLAN-Funktionen des R4 WiFi einzubauen.

Board-Paket installieren und Blink-Test durchführen.
Vorhandenen Sketch ohne Optimierungen kompilieren.
AVR-spezifische Codebereiche und alte Bibliotheken identifizieren.
Spannungspegel aller externen Module prüfen.
Timing, PWM, analoge Messwerte und EEPROM-Funktionen einzeln testen.
Beim WiFi-Modell Netzwerk und LED-Matrix erst danach ergänzen.

So bleibt der UNO R4 für dich das, was ein UNO sein soll: ein leicht zugängliches Entwicklungsboard. Gleichzeitig bietet er genug Reserven für größere Programme, präzisere Messungen und – mit dem WiFi-Modell – den direkten Einstieg in vernetzte IoT-Projekte.