Das Board UNO R4 WiFi stellt neben dem Mikrocontroller auch ein ESP32-Modul bereit. Damit können Verbindungen zu WLAN-Netzwerken und anderen Bluetooth-Geräten aufgebaut werden.
Pinbelegung

Quelle: 🔗https://docs.arduino.cc/hardware/uno-r4-wifi (eigene Bearbeitung abgerufen am 27.07.24)
An diese Ein- und Ausgänge können zum Beispiel ⇒LEDs, Lautsprecher, Displays, Motoren oder Sensoren angeschlossen werden. Der Mikrocontroller kann alle diese Bauteile steuern, Signale auslesen und aufgrund der gelesenen Daten verschiedene Aktionen auslösen.

digitale Pins
- Der Reset-Knopf startet das gerade hochgeladene Programm neu.
- Die digitalen Ein-/Ausgänge liefern im Normalfall ein HIGH (1) oder LOW (0). Eine Ausnahme bilden die mit einem ~ gekennzeichneten Pins. Sie können mit der ⇒Pulsweitenmodulation angesprochen werden.
- Die analogen Eingänge messen die anliegende Spannung. Diese Spannung (5V) wird vom Analog-Digital-Wandler (ADC = Analog Digital Converter) in digitale Werte zwischen 0 und 1023 (10 Bit) umgewandelt.
Die Standardauflösung kann auf 12 Bit (0−4096) oder 14 Bit (0−65355) erhöht werden.
void setup()
{
// Auflösung 14 Bit
analogReadResolution(14);
Serial.begin(9600);
}
void loop()
{
// Wert von A0 anzeigen
Serial.println(analogRead(A0));
delay(500);
}
- Der ⇒SPI-Bus verwendet die Eingänge D10 CS (Chip Select), D11 COPI (Controller Out Peripherie In), D12 CIPO (Controller In Peripherie Out) und D13 SCK (Serial Clock)
- Die Eingänge SCL und SDA werden über den ⇒I2C-Bus angesteuert.
- QWIIC ist ein zusätzlicher I2C-Bus
Die verbundenen Geräte können mit einem Programm abgefragt werden.
#include "Wire.h"
void setup()
{
// Wire1 ⇒ QWICC
Wire1.begin();
Serial.begin(9600);
delay(500);
Serial.print("I2C Scanner QWIIC");
}
void loop()
{
byte Fehler, Adresse;
int Geraete = 0;
Serial.println("Starte Scanvorgang");
for (Adresse = 1; Adresse < 127; Adresse++)
{
// Übertragung starten
Wire1.beginTransmission(Adresse);
// wenn die Übertragung beendet wird
Fehler = Wire1.endTransmission();
if (Fehler == 0)
{
Serial.print("I2C Gerät gefunden - Adresse: 0x");
if (Adresse < 16) Serial.print("0");
Serial.print(Adresse, HEX);
Serial.println("");
Geraete++;
}
}
if (Geraete == 0) Serial.println("Keine I2C Geräte gefunden\n");
else Serial.println("Scanvorgang abgeschlossen");
delay(10000);
}
- die Pins 0 (RX - Receiver = Empfänger) und 1 (TX -Transmitter = Sender) werden für die Kommunikation mit dem Computer über die USB-Schnittstelle verwendet. Sie können nur dann als digitale Ein- oder Ausgänge verwendet werden, wenn der Arduino über eine externe Stromzufuhr betrieben wird.
Board installieren

- Icon für den Boardverwalter anklicken oder Werkzeuge-> Board -> Boardverwalter
- nach dem UNO R4 Board suchen
- Board installieren
Board auswählen
![]() | ![]() |
Linux | Windows |
BLE Terminal (iOS)
![]() | ![]() |
LightBlue (iOS Android)
![]() | ![]() | ![]() |
Android zeigt als Name LED schalten | ||
![]() | ![]() | ![]() |
Der Name des USB-Ports unterscheidet sich je nach dem verwendeten Betriebssystem.
LED-Matrix

Auf dem Board befindet sich zusätzlich eine 12×8 große LED-Matrix.
Die LED-Matrix kann als ⇒zweidimensionales Array definiert werden. Eine 0 markiert eine ausgeschaltete LED, eine 1 zeigt eine leuchtende LED. Diese Schreibweise hat den Vorteil, dass der Aufbau der Matrix sichtbar wird und eine Änderung schnell möglich ist.
Beispiele:

byte PfeilRechts[8][12] =
{
{ 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, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0 },
{ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0 },
{ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
{ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0 }
};

byte PfeilLinks[8][12] =
{
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
{ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
{ 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
{ 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 }
};
Das vollständige Programm:
#include "Arduino_LED_Matrix.h"
ArduinoLEDMatrix Matrix;
byte PfeilLinks[8][12] =
{
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
{ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
{ 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
{ 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 }
};
byte PfeilRechts[8][12] =
{
{ 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, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0 },
{ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0 },
{ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
{ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0 }
};
void setup()
{
Matrix.begin();
Matrix.renderBitmap(PfeilLinks, 8, 12);
delay(1000);
Matrix.renderBitmap(PfeilRechts, 8, 12);
}
void loop()
{
// bleibt leer, Programm läuft nur einmal
}

Du kannst aber auch den dazugehörigen 🔗Editor (externer Link, abgerufen am 06.11.24) verwenden.
Das vollständige Programm:
#include "Arduino_LED_Matrix.h"
ArduinoLEDMatrix Matrix;
const unsigned long PfeilRechts[] =
{
0x800,
0xcffeffff,
0xfe00c008,
};
const unsigned long PfeilLinks[] =
{
0x10030,
0x7fffff7,
0xff300100,
};
void setup()
{
Matrix.begin();
Matrix.loadFrame(PfeilLinks);
delay(1000);
Matrix.loadFrame(PfeilRechts);
}
void loop()
{
// bleibt leer, Programm läuft nur einmal
}
In der Arduino IDE findest du unter Beispiele -> LED_Matrix das Programm MatrixFrameBuffer. Ich habe das Programm als Vorlage genommen und vereinfacht. Das Programm erzeugt zufällige Pixelmuster.

#include "Arduino_LED_Matrix.h"
// Name der Matrix
ArduinoLEDMatrix Matrix;
#define Reihen 8
#define Spalten 12
int PunktX = 0;
int PunktY = 0;
// Rahmen definieren, beim Start sind alle Pixel ausgeschaltet
byte Rahmen[8][12] =
{
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 1, 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, 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, 0, 0 },
{ 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
};
void setup()
{
// Matrix starten
Matrix.begin();
}
void loop()
{
// Punkte zufällig bestimmen
PunktX = random(Spalten);
PunktY = random(Reihen);
// Pixel zufällig ein- oder ausschalten
int Pixelwert = random(2);
// Rahmen mit den neuen Werte aktualisieren
Rahmen[PunktY][PunktX] = Pixelwert;
// Rahmen anzeigen
Matrix.renderBitmap(Rahmen, 8, 12);
delay(50);
}
Text scrollen
In der Arduino IDE findest du unter Beispiele -> LED_Matrix das Programm TextWithArduinoGraphics. Ich habe das Programm vereinfacht und kommentiert.
Du musst dafür eine zusätzliche Bibliothek installieren.

#include "ArduinoGraphics.h"
#include "Arduino_LED_Matrix.h"
ArduinoLEDMatrix Matrix;
void setup()
{
Matrix.begin();
}
void loop()
{
// Zeichnen starten
Matrix.beginDraw();
// Scrollgeschwindigkeit
Matrix.textScrollSpeed(50);
// Fontgrößen: Font_4x6, Font_5x7
Matrix.textFont(Font_5x7);
// beginText(Spalte, Zeile, Farbe)
Matrix.beginText(0, 1, 0xFFFFFF);
// Text anzeigen
Matrix.print(" Text scrollen ");
// nach links scrollen
Matrix.endText(SCROLL_LEFT);
// Ausgabe beenden
Matrix.endDraw();
}
⇒Beispiel: Temperaturmessung und Anzeige der Daten
RTC-Modul

Auf dem Board befindet sich auch ein RTC-Modul (RTC = Real Time Clock). Es ist allerdings nicht über eine Batterie gepuffert, nach dem Ausschalten muss das aktuelle Datum und die Zeit neu gesetzt werden.
Wenn die Batterie gepuffert werden soll, müssen die Pins VRTC+ und VRTC- mit einem Batteriepack oder einer anderen Stromquelle mit maximal 3,3V verbunden werden.
Die Installation einer zusätzlichen Bibliothek ist nicht notwendig.

#include "RTC.h"
void setup()
{
Serial.begin(9600);
RTC.begin();
// aktuelles Datum/Zeit setzen
// MESZ: SAVING_TIME_ACTIVE
// MEZ: SAVING_TIME_INACTIVE
RTCTime Zeit(12, Month::DECEMBER, 2024, 7, 56, 00, DayOfWeek::THURSDAY, SaveLight::SAVING_TIME_INACTIVE);
RTC.setTime(Zeit);
}
void loop()
{
RTCTime aktuelleZeit;
// aktuelle Zeit holen
RTC.getTime(aktuelleZeit);
// Wochentag als Objekt von DayOfWeek erzeugen
DayOfWeek Wochentag = aktuelleZeit.getDayOfWeek();
switch (Wochentag)
{
case DayOfWeek::SUNDAY:
Serial.print("Sonntag ");
break;
case DayOfWeek::MONDAY:
Serial.print("Montag ");
break;
case DayOfWeek::TUESDAY:
Serial.print("Dienstag ");
break;
case DayOfWeek::WEDNESDAY:
Serial.print("Mittwoch ");
break;
case DayOfWeek::THURSDAY:
Serial.print("Donnerstag ");
break;
case DayOfWeek::FRIDAY:
Serial.print("Freitag ");
break;
case DayOfWeek::SATURDAY:
Serial.print("Samstag ");
break;
}
// wenn Tag < 10 führende 0 ergänzen
if (aktuelleZeit.getDayOfMonth() < 10) Serial.print("0");
Serial.print(aktuelleZeit.getDayOfMonth());
Serial.print(".");
// wenn Monat < 10 führende 0 ergänzen
if (Month2int(aktuelleZeit.getMonth()) < 10) Serial.print("0");
Serial.print(Month2int(aktuelleZeit.getMonth()));
Serial.print(".");
Serial.print(aktuelleZeit.getYear());
Serial.print(" - ");
// Uhrzeit
Serial.print("Uhrzeit: ");
// wenn Stunde < 10 führende 0 ergänzen
if (aktuelleZeit.getHour() < 10) Serial.print("0");
Serial.print(aktuelleZeit.getHour());
Serial.print(":");
// wenn Minuten < 10 führende 0 ergänzen
if (aktuelleZeit.getMinutes() < 10) Serial.print("0");
Serial.print(aktuelleZeit.getMinutes());
Serial.print(":");
// wenn Sekunden < 10 führende 0 ergänzen
if (aktuelleZeit.getSeconds() < 10) Serial.print("0");
Serial.println(aktuelleZeit.getSeconds());
delay(1000);
}
Zeit mit NTP
Benötigte Bibliothek installieren


#include "WiFiS3.h"
#include "NTP.h"
// SSID und Passwort des Routers
char Router[] = "Router_SSID";
char Passwort[] = "xxxxxxxx";
WiFiServer WiFiServer(80);
WiFiClient WiFiClient;
WiFiUDP wifiUdp;
NTP ntp(wifiUdp);
void setup()
{
Serial.begin(9600);
while (!Serial);
delay(1000);
// Verbindung aufbauen
WiFi.begin(Router, Passwort);
while(WiFi.status() != WL_CONNECTED)
{
delay(500);
Serial.print(".");
}
Serial.print("Verbindung aufbauen mit ");
Serial.println(Router);
// Webserver starten
WiFiServer.begin();
// IP des Arduinos anzeigen
Serial.print("IP Adresse Arduino DHCP: ");
Serial.println(WiFi.localIP());
/*
Zeitzone
CEST: Central European Summertime
Beginn europäische Sommerzeit letzter Sonntag im März 2 Uhr GMT + 2 Stunden
*/
ntp.ruleDST("CEST", Last, Sun, Mar, 2, 120);
// CET: Central European Time
// Beginn Normalzeit letzter Sonntag im Oktober 3 Uhr GMT + 1 Stunde
ntp.ruleSTD("CET", Last, Sun, Oct, 3, 60);
// ntp starten
ntp.begin();
}
void loop()
{
// Zeit aktualisieren
ntp.update();
/*
Zeit mit formatedTime() anzeigen:
%d = Tag, %m = Monat, %Y = Jahr, %T = Zeit in Stunden, Minuten, Sekunden
Wochentag anzeigen
*/
switch (ntp.weekDay())
{
case 0:
Serial.print("Sonntag");
break;
case 1:
Serial.print("Montag");
break;
case 2:
Serial.print("Dienstag");
break;
case 3:
Serial.print("Mittwoch");
break;
case 4:
Serial.print("Donnerstag");
break;
case 5:
Serial.print("Freitag");
break;
case 6:
Serial.print("Samstag");
break;
}
Serial.print(", ");
Serial.println(ntp.formattedTime("%d.%m.%Y Uhrzeit: %T"));
delay(1000);
}
QWIIC
Auf dem Board befindet sich ein zweiter I2C-Anschluss mit QWIIC-Stecker.

Beispielprogramm ⇒Wetterstation
Bluetooth (BLE)
Das Programm
Zunächst musst du die Bibliothek ArduinoBLE installieren:


Überprüfe, ob die aktuelle Firmware installiert ist: 🔗https://support.arduino.cc/hc/en-us/articles/9670986058780-Update-the-wireless-connectivity-firmware-on-UNO-R4-WiFi
Das Programm schaltet die eingebaute LED:
1 -> einschalten, 0 -> ausschalten:
#include "ArduinoBLE.h"
/*
eindeutige UUID bestimmen:
https://www.guidgenerator.com/online-guid-generator.aspx
https://www.uuidgenerator.net/
BLERead | BLEWrite | BLENotify
-> schreiben, lesen, Info
*/
// Name BLE-Service
BLEService LEDSchalten("19b10000-e8f2-537e-4f6c-d104768a1214");
BLEUnsignedCharCharacteristic Auswahl("19b10000-e8f2-537e-4f6c-d104768a1214", BLERead | BLEWrite | BLENotify);
void setup()
{
Serial.begin(9600);
// auf serielle Verbindung warten
while (!Serial);
delay(1000);
// pinMode festlegen
pinMode(LED_BUILTIN, OUTPUT);
// BLE starten
if (!BLE.begin()) Serial.println("Bluetooth-Modul konnte nicht gestartet werden!");
else Serial.println("Bluetooth-Modul erfolgreich gestartet!");
// Name festlegen (wird in der App angezeigt) und den Service (LEDSchalten) zuweisen
BLE.setLocalName("LED schalten");
BLE.setAdvertisedService(LEDSchalten);
// Auswahl als Platzhalter für den in der App gewählten Wert
LEDSchalten.addCharacteristic(Auswahl);
// Service LEDSchalten hinzufügen
BLE.addService(LEDSchalten);
// Startwert für die Kommunikation schreiben
Auswahl.writeValue(0);
// Zuweisung starten
BLE.advertise();
}
void loop()
{
// auf die Verbindung zu Geräten warten
BLEDevice Verbindung = BLE.central();
// wenn der R4 WiFi mit einem Gerät verbunden ist ...
if (Verbindung)
{
Serial.println("Verbunden ... ");
// solange der Controller mit einem Gerät verbunden ist ...
while (Verbindung.connected())
{
if (Auswahl.written())
{
// LED einschalten
if (Auswahl.value() == '1')
{
Serial.print(char(Auswahl.value()));
Serial.println(" -> LED ein");
digitalWrite(LED_BUILTIN, HIGH);
}
// LED ausschalten
if (Auswahl.value() == '0')
{
Serial.print(char(Auswahl.value()));
Serial.println(F(" -> LED aus"));
digitalWrite(LED_BUILTIN, LOW);
}
}
}
}
}
Smartphone-Apps
BluetoothLE (iOS)
![]() | ![]() | ![]() | ![]() |
BLE Terminal (iOS)
![]() | ![]() |
LightBlue (iOS Android)
![]() | ![]() | ![]() |
Android zeigt als Name LED schalten | ||
![]() | ![]() | ![]() |
Webserver
Beispiel: Das Programm zeigt im Browser 6 unsortierte Zufallszahlen an. Eine Überprüfung auf Dopplungen findet nicht statt.
Im Seriellen Monitor wird die IP des Arduino UNO R4 angezeigt.

Diese Adresse musst du in einem Browser deiner Wahl eingeben

#include "WiFiS3.h"
char Router[] = "Router_SSID";
char Passwort[] = "xxxxxxxx";
// Minimum/Maximum der Zufallszahlen
const byte Minimum = 1;
const byte Maximum = 49;
WiFiServer WiFiServer(80);
WiFiClient WiFiClient;
void setup()
{
Serial.begin(9600);
// auf serielle Verbindung warten
while (!Serial) ;
delay(500);
// WiFi starten
WiFi.begin(Router, Passwort);
// Verbindung herstellen
while (WiFi.status() != WL_CONNECTED)
{
delay(200);
Serial.print(".");
}
// SSID des Routers anzeigen
Serial.println();
Serial.print("Verbunden mit ");
Serial.println(WiFi.SSID());
// IP anzeigen
Serial.println(WiFi.localIP());
// Webserver starten
WiFiServer.begin();
// IP des Servers/des verbunden Computers anzeigen
Serial.print("Server: ");
Serial.println(WiFi.SSID());
// IP des Arduinos anzeigen
Serial.print("IP Adresse Arduino DHCP: ");
Serial.println(WiFi.localIP());
// Zufallsgenerator mit dem Signal an A0 starten
randomSeed(analogRead(A0));
}
void loop()
{
// auf WiFiClienten warten ...
WiFiClient = WiFiServer.available();
if (WiFiClient)
{
// Seite aufbauen wenn SeiteAufbauen true ist
boolean SeiteAufbauen = true;
// solange der WiFiClient verbunden ist ...
while (WiFiClient.connected())
{
if (WiFiClient.available())
{
// Anforderung vom WiFiClienten lesen ...
char Zeichen = WiFiClient.read();
// wenn als Zeichen neue Zeile (\n) übergeben wird
// SeiteAufbauen true ist -> Seite anzeigen
if (Zeichen == '\n' && SeiteAufbauen)
{
/*
HTML-Seite aufbauen
die folgenden Anweisungen müssen
mit print oder println gesendet werden
println "verschönert" den Quelltext
(erzeugt einen Zeilenumbruch im Quelltext)
*/
WiFiClient.println("HTTP/1.1 200 OK");
WiFiClient.println("Content-type:text/html");
// Leerzeile zwingend erforderlich
WiFiClient.println();
WiFiClient.println("<!doctype html>");
WiFiClient.println("<html>");
WiFiClient.println("<body>");
// <h2> Überschrift H2
WiFiClient.println("<h2>Zufallszahlen</h2>");
// <hr> horizontale Linie
WiFiClient.println("<hr>");
// Zufallszahlen anzeigen
for (int i = 0; i < 6; i++)
{
int Zahl = random(Minimum, Maximum);
WiFiClient.println(Zahl);
WiFiClient.println(" ");
}
WiFiClient.print("<hr>");
// IPs anzeigen
WiFiClient.print("Eigene IP-Adresse: ");
WiFiClient.print(WiFiClient.remoteIP());
WiFiClient.print("</b>");
WiFiClient.print("<br>IP-Adresse Arduino: ");
WiFiClient.print(WiFi.localIP());
WiFiClient.println("</body>");
WiFiClient.println("</html>");
// HTTP-Antwort endet mit neuer Zeile
WiFiClient.println();
// Seite vollständig geladen -> loop verlassen
break;
}
// neue Zeile -> SeiteAufbauen auf true setzen
if (Zeichen == '\n') SeiteAufbauen = true;
// die aktuelle Zeile enthält ein Zeichen
else if (Zeichen != '\r') SeiteAufbauen = false;
}
}
delay(1);
WiFiClient.stop();
}
}
Letzte Aktualisierung: