Arduino Uno R4 WiFi & Minima: Unterschiede zum R3, erstes Projekt

Der Arduino Uno R4 ist die vierte Version des Uno, des meistgenutzten Entwicklungsboards der Welt, und der erste Uno mit einem 32-Bit-Prozessor statt eines 8-Bit-AVR. Es gibt ihn in zwei Varianten: den schlichten, günstigeren Uno R4 Minima und den Uno R4 WiFi mit WLAN, Bluetooth und einer 12x8-LED-Matrix. Beide behalten Größe, Pinbelegung und 5-V-Betriebsspannung des R3 bei, sodass die meisten Shields und Schaltungen unverändert passen. Dafür ist der Programmspeicher 8-mal so groß, der Prozessor 3-mal so schnell, und es gibt einen echten Analogausgang (DAC), einen CAN-Bus, eine eingebaute Uhr (RTC) und Unterstützung für USB-Tastatur und -Maus.

In dieser Anleitung erfährst du genau, worin sich der R4 vom R3 unterscheidet, wie du zwischen Minima und WiFi wählst, welche alten Sketche und Bibliotheken problemlos laufen und welche nicht kompilieren, und warum du die Grenze von 8 mA pro Pin beachten musst. Zum Schluss bauen wir dein erstes Projekt, das LED-Matrix und WLAN des R4 WiFi gemeinsam nutzt und sich vom Handy aus steuern lässt.

Was ist der Arduino Uno R4? Die Modelle Minima und WiFi

Im Herzen beider Modelle sitzt der Mikrocontroller RA4M1 (R7FA4M1AB3CFM) von Renesas: ein Arm-Cortex-M4-Kern mit 48 MHz und Gleitkommaeinheit (FPU). Anders als die meisten 32-Bit-Boards läuft dieser Chip mit 5 V, und genau das war der wichtigste Grund, warum Arduino den RA4M1 für den R4 gewählt hat. Der Minima trägt nur diesen Chip. Das WiFi-Modell hat zusätzlich ein ESP32-S3-MINI-1-Modul, das WLAN und Bluetooth liefert und gleichzeitig als Brücke dient, die über USB mit deinem Computer spricht. Weil der ESP32-S3 mit 3,3 V arbeitet, sitzt zwischen den beiden Chips ein Pegelwandler.

Unterschiede zwischen Uno R3 und Uno R4

Die wichtigsten Zeilen der Tabelle sind Speicher und Geschwindigkeit. Die 2 KB SRAM des R3 sind mit ein paar String-Variablen und einem Displaypuffer voll; bei Projekten mit OLED-Display, langen Arrays oder JSON-Verarbeitung beginnt das Board zufällig einzufrieren oder neu zu starten. Die 32 KB des R4 beseitigen dieses Problem fast vollständig. Dank FPU laufen Gleitkommarechnungen (Sensorkalibrierung, PID, Trigonometrie) in Hardware und sind um ein Vielfaches schneller als auf dem R3. Auch bei der Versorgung hat sich viel getan: Der Linearregler des R3 wird bei 12 V heiß, der R4 nutzt dagegen einen Schaltregler (Buck-Wandler), nimmt deshalb bis zu 24 V an und bleibt deutlich kühler.

Neue Hardware im R4

• 12-Bit-DAC (A0): Anders als PWM erzeugt er eine echte analoge Spannung; man nutzt ihn für Audio, Sinuswellen und einen einfachen Signalgenerator. Die Bibliothek analogWave aus dem Boardpaket erzeugt Sinus-, Rechteck- und Sägezahnwellen mit einer einzigen Zeile.
• 14-Bit-ADC: Mit analogReadResolution(14) liest du Werte von 0 bis 16383; bei 5 V Referenz ist ein Schritt etwa 0,3 mV groß, beim R3 sind es 4,9 mV. Damit alte Sketche nicht kaputtgehen, ist die Standardauflösung weiterhin 10 Bit.
• Eingebauter Operationsverstärker: an den Pins A1 (+), A2 (–) und A3 (Ausgang); damit verstärkst du kleine Sensorsignale ohne zusätzlichen Chip. Die Grundlagen findest du unter Was ist ein Operationsverstärker?
• CAN-Bus: der robuste Kommunikationsbus aus Auto und Industrie; du nutzt ihn mit einem Transceiver-Modul wie SN65HVD230 oder TJA1050 und der Bibliothek Arduino_CAN aus dem Boardpaket.
• RTC: hält Datum und Uhrzeit ohne zusätzliches Modul (Bibliothek RTC.h). Wenn du beim R4 WiFi eine Batterie mit 1,6 bis 3,6 V an den VRTC-Pin anschließt, läuft die Uhr weiter, auch wenn die Versorgung des Boards wegfällt.
• USB-HID: Das Board kann sich am Computer als Tastatur oder Maus anmelden; früher brauchte man dafür einen Leonardo (USB-Tastatur mit dem Arduino Leonardo).
• Kapazitive Berührung: Einige Pins funktionieren mit der Bibliothek Arduino_CapacitiveTouch ohne zusätzliches Modul als Touch-Taster.

Zwei dieser Funktionen kannst du sofort ausprobieren. Der folgende Sketch gibt über den DAC nacheinander steigende Spannungen aus und liest dieselbe Spannung mit dem 14-Bit-ADC zurück. Verbinde einfach A0 und A1 mit einem Jumperkabel und öffne den Seriellen Monitor mit 115200 Baud:

1// A0 (DAC) ile A1'i bir jumper kabloyla bağla / connect A0 (DAC) to A1 with a jumper wire
2
3void setup() {
4  Serial.begin(115200);
5  while (!Serial) {}            // USB seri port açılana kadar bekle / wait for the USB serial port
6  analogWriteResolution(12);    // DAC: 0–4095
7  analogReadResolution(14);     // ADC: 0–16383
8}
9
10void loop() {
11  for (int value = 0; value < 4096; value += 512) {
12    analogWrite(DAC, value);              // A0'dan gerçek analog gerilim / true analog voltage on A0
13    delay(10);
14    int raw = analogRead(A1);             // 14 bit okuma / 14-bit reading
15    float volts = raw * 5.0 / 16383.0;    // 5 V referans / 5 V reference
16    Serial.print("DAC: ");
17    Serial.print(value);
18    Serial.print("  ADC: ");
19    Serial.print(raw);
20    Serial.print("  V: ");
21    Serial.println(volts, 3);
22    delay(500);
23  }
24}

In der Ausgabe siehst du, dass der gelesene Wert jedes Mal um etwa 2048 steigt, wenn der DAC-Wert um 512 zunimmt: Ein Schritt des 12-Bit-Ausgangs entspricht 4 Schritten des 14-Bit-Eingangs. Gerechnet haben wir mit 5,0 V, doch wenn das Board über USB versorgt wird, sinkt die 5-V-Leitung wegen der Schutzdiode auf etwa 4,7 V. Für genaue Messungen misst du den 5V-Pin mit dem Multimeter und setzt diesen Wert statt 5.0 in die Formel ein. Die Zeile while (!Serial) verhindert, dass die ersten Zeilen verloren gehen, bevor der Serielle Monitor offen ist; soll das Board ohne Computer laufen, lösch diese Zeile, sonst wartet das Programm dort für immer. Die Grundlagen des Analoglesens findest du im Artikel ADC und Analog-Digital-Wandlung.

Die Stromgrenze pro Pin: Warum 8 mA beim R4?

Diesen Unterschied übersehen Umsteiger auf den R4 am häufigsten. Der ATmega328P des R3 liefert locker 20 mA pro Pin (absolutes Maximum 40 mA), deshalb hängen die meisten Beispiele im Netz eine LED mit 220 Ω direkt an einen Pin. Für den R4 nennt Arduino dagegen höchstens 8 mA pro Pin. Rechnen wir mit dem ohmschen Gesetz: Treibt ein 5-V-Pin eine rote LED (etwa 2 V) über 220 Ω, fließen (5 − 2) / 220 ≈ 13,6 mA, fast das Doppelte der R4-Grenze. Die LED leuchtet wahrscheinlich trotzdem, doch der Pin kann mit der Zeit Schaden nehmen, und dieser Schaden summiert sich meist unbemerkt.

Laufen alte Sketche und Bibliotheken auf dem R4?

Kurz gesagt: die meisten ja. Sketche mit Standardbefehlen wie digitalWrite, analogRead, millis, Serial, Wire (I2C), SPI, EEPROM, Servo und tone kompilieren auf dem R4 ohne Änderungen. Probleme gibt es bei Code, der direkt auf die Hardware des ATmega328P zugreift: schnelle Pin-Operationen über Register wie PORTB und DDRD, Timer1-Einstellungen, Header-Dateien, die mit avr/ beginnen, und Bibliotheken, die all das nutzen, kompilieren auf dem R4 nicht. Ein Sketch mit PORTB bricht zum Beispiel mit 'PORTB' was not declared in this scope ab.

Beim Kompilieren siehst du vielleicht eine Warnung wie WARNING: library LiquidCrystal I2C claims to run on avr architecture(s) and may be incompatible with your current board which runs on renesas_uno architecture(s). Das ist kein Fehler; der Autor der Bibliothek hat nur AVR als unterstützte Architektur eingetragen. Wenn der Sketch hochlädt und läuft, ist alles in Ordnung. Bekommst du einen echten Fehler, installiere zuerst die neueste Version der Bibliothek (Bibliothek in Arduino einbinden); hilft das nicht, such dir eine Alternative mit R4-Unterstützung.

Ein weiterer Unterschied verdient Aufmerksamkeit: Der R3 hat eine einzige serielle Schnittstelle, die sowohl mit USB als auch mit den Pins D0/D1 verbunden ist. Beim R4 ist Serial nur USB, und die Pins D0 und D1 arbeiten getrennt als Serial1. Ein alter Sketch, der ein Modul wie ein HC-05-Bluetooth- oder ein GPS-Modul an D0/D1 über Serial liest, empfängt auf dem R4 nichts. Der folgende Brücken-Sketch leitet die Daten des Moduls an den Seriellen Monitor weiter und das, was du im Seriellen Monitor tippst, an das Modul:

1// R4'te Serial = USB, Serial1 = D0 (RX) ve D1 (TX) / on the R4, Serial = USB, Serial1 = D0 (RX) and D1 (TX)
2
3void setup() {
4  Serial.begin(115200);   // bilgisayar (Seri Monitör) / computer (Serial Monitor)
5  Serial1.begin(9600);    // D0/D1'e bağlı modül, örn. HC-05 / module on D0/D1, e.g. HC-05
6}
7
8void loop() {
9  if (Serial1.available()) {
10    Serial.write(Serial1.read());   // modülden bilgisayara / module to computer
11  }
12  if (Serial.available()) {
13    Serial1.write(Serial.read());   // bilgisayardan modüle / computer to module
14  }
15}

Uno R4 in der Arduino IDE einrichten

1. Installiere oder aktualisiere die Arduino IDE 2 (Arduino IDE installieren).
2. Öffne links den Boardverwalter, tippe UNO R4 ein und installiere das Paket Arduino UNO R4 Boards. Es ist ein offizielles Paket, du musst also keine zusätzliche URL eintragen.
3. Schließe das Board mit einem USB-C-Kabel an, das Daten überträgt, und wähle unter Werkzeuge > Board Arduino UNO R4 Minima oder Arduino UNO R4 WiFi.
4. Wähle unter Werkzeuge > Port den Port des Boards, öffne Datei > Beispiele > 01.Basics > Blink und lade den Sketch hoch. Die eingebaute LED an D13 beginnt zu blinken.
5. Erscheint kein Port oder bricht der Upload ab, drücke zweimal schnell die RESET-Taste: Das Board wechselt in den Bootloader-Modus und der Port taucht wieder auf. Alle Upload-Probleme behandelt die Anleitung Arduino Sketch lässt sich nicht hochladen.

Uno R4 WiFi: der ESP32-S3 und die 12x8-LED-Matrix

Standardmäßig läuft auf dem ESP32-S3 des R4 WiFi eine von Arduino aufgespielte Firmware, die Befehle des RA4M1 in WLAN- und Bluetooth-Vorgänge übersetzt. Deinen Sketch schreibst du weiterhin für den RA4M1: Für WLAN nutzt du die mitgelieferte Bibliothek WiFiS3, für Bluetooth die Bibliothek ArduinoBLE. Es gibt zwei wichtige Einschränkungen: Das Modul verbindet sich nur mit 2,4-GHz-Netzen, und weil WLAN und Bluetooth die Antenne teilen, kannst du nicht beides gleichzeitig nutzen. Manche neueren Funktionen brauchen eine aktuelle ESP32-S3-Firmware; aktualisieren kannst du sie in der IDE über Werkzeuge > Firmware Updater.

Die Matrix auf der Vorderseite besteht aus 96 roten LEDs in 8 Zeilen und 12 Spalten. Frisch aus der Verpackung spielt sie eine Tetris-Animation ab. Die LEDs hängen per Charlieplexing an 11 internen Pins des RA4M1; diese Pins sind nicht auf die Buchsenleisten geführt, die Matrix kostet dich also keinen der Pins D0–D13 oder A0–A5. Die Bibliothek Arduino_LED_Matrix aus dem Boardpaket nimmt ein Bild (Frame) in zwei Formen an: als 8x12-Byte-Array oder als drei 32-Bit-Zahlen. Die Array-Variante ist leichter zu lesen, weil du die Form aus Einsen direkt im Code siehst:

1#include "Arduino_LED_Matrix.h"   // kart paketiyle gelir / ships with the board package
2
3ArduinoLEDMatrix matrix;
4
5// 8 satır x 12 sütun: 1 = LED yanar / 8 rows x 12 columns: 1 = LED on
6uint8_t kalp[8][12] = {
7  { 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0 },
8  { 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0 },
9  { 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0 },
10  { 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0 },
11  { 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0 },
12  { 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0 },
13  { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 },
14  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
15};
16
17void setup() {
18  matrix.begin();
19}
20
21void loop() {
22  matrix.renderBitmap(kalp, 8, 12);          // kendi çizimin / your own drawing
23  delay(1000);
24  matrix.loadFrame(LEDMATRIX_EMOJI_HAPPY);   // kütüphanedeki hazır kare / ready-made frame from the library
25  delay(1000);
26  kalp[7][11] = 1;                           // tek bir LED'i yak: satır 7, sütun 11 / turn on one LED: row 7, column 11
27}

renderBitmap() zeigt dein selbst gezeichnetes Array, loadFrame() lädt fertige Bilder aus der Bibliothek: LEDMATRIX_HEART_BIG, LEDMATRIX_EMOJI_HAPPY, LEDMATRIX_EMOJI_SAD und LEDMATRIX_DANGER sind einige davon. Mit loadSequence() und play() spielst du fertige Animationen wie LEDMATRIX_ANIMATION_TETRIS oder LEDMATRIX_ANIMATION_WIFI_SEARCH ab. Um Text auf die Matrix zu schreiben und laufen zu lassen, installierst du die Bibliothek ArduinoGraphics über den Bibliotheksverwalter. Wenn du ein größeres Display willst, schau dir die Artikel MAX7219-LED-Matrix und WS2812B NeoPixel an.

Erstes Projekt: die LED-Matrix per Handy steuern

Jetzt verbinden wir beide Funktionen. Während sich das Board mit deinem Heimnetz verbindet, zeigt die Matrix eine WLAN-Suchanimation; danach erscheint die IP-Adresse als Lauftext. Öffnest du diese Adresse im Browser eines Handys im selben Netz, kannst du per Tastendruck ein Herz, ein fröhliches oder trauriges Gesicht anzeigen, die IP-Adresse erneut laufen lassen oder die Matrix ausschalten. Außer dem Board brauchst du keine Bauteile.

1. Installiere die Bibliothek ArduinoGraphics über den Bibliotheksverwalter; WiFiS3 und Arduino_LED_Matrix sind im Boardpaket enthalten.
2. Ersetze Netzwerkname und Passwort im Sketch durch deine eigenen; achte auf Groß- und Kleinschreibung.
3. Wähle Arduino UNO R4 WiFi als Board, lade den Sketch hoch und öffne den Seriellen Monitor mit 115200 Baud.
4. Gib die IP-Adresse, die auf der Matrix läuft oder im Seriellen Monitor steht, im Browser deines Handys ein.
5. Tippe auf die Tasten der Seite; die Matrix ändert sich sofort.

1#include "ArduinoGraphics.h"      // Arduino_LED_Matrix'ten ÖNCE eklenmeli / must come BEFORE Arduino_LED_Matrix
2#include "Arduino_LED_Matrix.h"
3#include "WiFiS3.h"
4
5char ssid[] = "AgAdi";            // Wi-Fi adın / your Wi-Fi name
6char pass[] = "Sifre123";         // Wi-Fi şifren / your Wi-Fi password
7
8ArduinoLEDMatrix matrix;
9WiFiServer server(80);
10
11void scrollText(String text) {
12  matrix.beginDraw();
13  matrix.stroke(0xFFFFFFFF);
14  matrix.textScrollSpeed(60);             // her adım 60 ms / 60 ms per step
15  matrix.textFont(Font_5x7);
16  matrix.beginText(0, 1, 0xFFFFFF);
17  matrix.print("   " + text + "   ");
18  matrix.endText(SCROLL_LEFT);            // yazıyı sola kaydır / scroll the text to the left
19  matrix.endDraw();
20}
21
22void sendPage(WiFiClient &client) {
23  client.println("HTTP/1.1 200 OK");
24  client.println("Content-Type: text/html; charset=utf-8");
25  client.println("Connection: close");
26  client.println();
27  client.println("<!DOCTYPE html><html><head><meta name='viewport' content='width=device-width'></head><body>");
28  client.println("<h2>UNO R4 WiFi</h2>");
29  client.println("<p><a href='/kalp'><button>Kalp / Heart</button></a></p>");
30  client.println("<p><a href='/mutlu'><button>Mutlu / Happy</button></a></p>");
31  client.println("<p><a href='/uzgun'><button>Uzgun / Sad</button></a></p>");
32  client.println("<p><a href='/ip'><button>IP</button></a></p>");
33  client.println("<p><a href='/kapat'><button>Kapat / Off</button></a></p>");
34  client.println("</body></html>");
35}
36
37void setup() {
38  Serial.begin(115200);
39  matrix.begin();
40
41  if (WiFi.status() == WL_NO_MODULE) {               // ESP32-S3 yanıt vermiyor / ESP32-S3 not responding
42    Serial.println("WiFi modulu bulunamadi / WiFi module not found");
43    matrix.loadFrame(LEDMATRIX_DANGER);
44    while (true) {}
45  }
46
47  matrix.loadSequence(LEDMATRIX_ANIMATION_WIFI_SEARCH);   // bağlanırken animasyon / animation while connecting
48  matrix.play(true);
49
50  while (WiFi.begin(ssid, pass) != WL_CONNECTED) {
51    Serial.println("Baglaniyor / connecting...");
52    delay(5000);
53  }
54  while (WiFi.localIP() == IPAddress(0, 0, 0, 0)) {   // DHCP adresini bekle / wait for the DHCP address
55    delay(100);
56  }
57
58  server.begin();
59  Serial.print("IP: ");
60  Serial.println(WiFi.localIP());
61  scrollText(WiFi.localIP().toString());     // IP adresini matriste göster / show the IP on the matrix
62  matrix.loadFrame(LEDMATRIX_EMOJI_HAPPY);
63}
64
65void loop() {
66  WiFiClient client = server.available();
67  if (!client) {
68    return;
69  }
70
71  String request = client.readStringUntil('\n');   // ör. "GET /kalp HTTP/1.1" / e.g. "GET /kalp HTTP/1.1"
72  while (client.available()) {
73    client.read();                                 // kalan başlıkları at / discard the remaining headers
74  }
75
76  bool showIp = false;
77  if (request.indexOf("GET /kalp") >= 0) {
78    matrix.loadFrame(LEDMATRIX_HEART_BIG);
79  } else if (request.indexOf("GET /mutlu") >= 0) {
80    matrix.loadFrame(LEDMATRIX_EMOJI_HAPPY);
81  } else if (request.indexOf("GET /uzgun") >= 0) {
82    matrix.loadFrame(LEDMATRIX_EMOJI_SAD);
83  } else if (request.indexOf("GET /kapat") >= 0) {
84    matrix.clear();
85  } else if (request.indexOf("GET /ip") >= 0) {
86    showIp = true;
87  }
88
89  sendPage(client);
90  delay(10);
91  client.stop();                                   // bağlantıyı kapat / close the connection
92
93  if (showIp) {
94    scrollText(WiFi.localIP().toString());         // sayfa gittikten sonra kaydır / scroll after the page is sent
95  }
96}

Die Logik ist einfach: WiFi.begin() wird so lange wiederholt, bis die Verbindung steht; danach wartet der Sketch, bis DHCP eine IP-Adresse vergibt, und startet einen Webserver auf Port 80. Er liest die erste Zeile der Anfrage vom Handy (zum Beispiel "GET /kalp HTTP/1.1"), erkennt mit indexOf(), welche Taste gedrückt wurde, und lädt das passende Bild auf die Matrix. endText(SCROLL_LEFT) hält das Programm an, solange der Text läuft; deshalb lassen wir die IP-Adresse erst erneut laufen, nachdem die Seite gesendet und die Verbindung geschlossen ist. Zeigt die Matrix das Gefahrensymbol und bleibt stehen, antwortet der ESP32-S3 nicht; zieh das USB-Kabel ab, steck es wieder ein und aktualisiere die Firmware. Kommt gar keine Verbindung zustande, gelten die Prüfungen zu 2,4 GHz und Passwort aus dem Artikel ESP32 verbindet sich nicht mit dem WLAN auch hier.

Stromversorgung: VIN, 5V und 3,3-V-Pin

Der R4 nimmt an der DC-Buchse oder am VIN-Pin 6–24 V an; der Buck-Wandler auf der Platine setzt das auf 5 V herab. Laut Arduinos Dokumentation zum R4 WiFi lassen sich bei Versorgung über VIN etwa 1,2 A aus dem 5V-Pin ziehen; bei USB-Versorgung verkraftet das Board bis zu 2 A, das echte Limit setzt aber der USB-Port deines Computers. Dieser Strom ist für Sensoren und kleine Module gedacht, nicht für Motoren und Servos. Der 3,3-V-Pin des Minima wird vom internen Regler des RA4M1 gespeist und reicht deshalb nur für kleine Sensoren; versorge stromhungrige Module wie einen ESP-01 oder ein nRF24L01 mit PA+LNA-Antenne nicht darüber. Der R4 WiFi hat außerdem einen OFF-Pin (mit GND verbunden schaltet er die 5-V-Versorgung des Boards ab) und einen VRTC-Pin für die RTC-Batterie. Alle Versorgungsoptionen findest du unter Wie versorgt man einen Arduino mit Strom?

Projektideen mit dem Uno R4

• WLAN-Wetterstation: Zeig die mit einem DHT11 gemessene Temperatur als Lauftext auf der Matrix und zugleich auf einer Seite, die du am Handy öffnest.
• Matrix-Spiele: Snake, Tetris oder ein springender Ball auf der 12x8-Matrix; mehr Ideen findest du im Artikel Arduino-Spieleprojekte.
• Internetuhr: Hol die Uhrzeit aus dem Internet (NTP), schreib sie in die eingebaute RTC und halte sie mit einer Batterie am VRTC-Pin auch bei Stromausfall.
• USB-Makrotastatur: Bau ein Tastenfeld mit vier Tastern, das am Computer Tastenkürzel auslöst; dank der HID-Unterstützung des R4 brauchst du keinen Leonardo.
• Klang mit dem DAC: Erzeuge mit der Bibliothek analogWave eine Sinuswelle an A0 und bau mit einem Audioverstärker und einem Lautsprecher einen einfachen Synthesizer.
• Lampe per Handy schalten: Kombiniere den Webserver aus diesem Artikel mit einem Relaismodul und schalte eine Lampe aus der Ferne ein.

Häufige Fehler und ihre Lösungen

Welches Board solltest du kaufen: R3, R4 Minima oder R4 WiFi?

• Uno R4 WiFi: die beste Wahl, wenn deine Projekte ins Internet, mit dem Handy oder über Bluetooth kommunizieren sollen und du eine fertige Anzeige auf dem Board möchtest. Auch für Einsteiger macht er Spaß, weil du sofort auf der Matrix siehst, dass dein Code läuft.
• Uno R4 Minima: passt, wenn du keine Funkverbindung brauchst und mehr Speicher, Geschwindigkeit, einen DAC und USB-C willst. Dank SWD-Anschluss ist er auch eine gute Wahl, wenn du einen externen Debugger anschließen und deinen Code Schritt für Schritt ausführen möchtest.
• Uno R3 oder ein kompatibler Klon: weiterhin sinnvoll, wenn du alte Projekte mit AVR-spezifischen Bibliotheken hast, Lehrbuchbeispiele exakt nachbauen willst oder die geringsten Kosten suchst; seine Pins vertragen 20 mA problemlos.
• ESP32: Willst du WLAN mit mehr Pins zu einem niedrigeren Preis, ist auch ein ESP32-Board eine Überlegung wert; denk nur daran, dass er mit 3,3 V arbeitet (Arduino oder ESP32?).

Kurz gesagt ist der Uno R4 ein Upgrade, das die gewohnte Einfachheit des Uno beibehält und Speicher, Geschwindigkeit und neue Hardware hinzufügt; behalte nur die 8-mA-Grenze und den Unterschied bei Serial1 im Kopf. Um die Pins des Boards genau kennenzulernen, wirf einen Blick auf den Artikel Arduino-Uno-Pinbelegung. In der BlueGrays-App findest du LED-, Taster-, Sensor-, LCD- und LED-Matrix-Projekte für den Arduino Uno mit Schaltplänen und Code Schritt für Schritt; diese Projekte nutzen Standardbefehle und laufen daher auch auf dem R4, du musst nur die LED-Vorwiderstände auf 470 Ω erhöhen.