Arduino UNO R4 WiFi - Programmieren mit Arduino

Lesezeit: 12 Minuten

Inhalt

Pinbelegung
Board installieren
LED-Matrix
Text scrollen
RTC-Modul
QWIIC
Bluetooth (BLE)
WiFi

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 06.07.23)

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

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.07.23) 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.

# include "RTC.h"

void setup() 
{
  Serial.begin(9600);

  RTC.begin();

  // aktuelles Datum/Zeit setzen
  RTCTime Zeit(11, Month::JULY, 2023, 8, 32, 00, DayOfWeek::MONDAY, SaveLight::SAVING_TIME_ACTIVE);
  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);
}

QWIIC

Auf dem Board befindet sich ein zweiter I2C-Anschluss mit QWIIC-Stecker.

Beispielprogramm ➨Wetterstation

Bluetooth (BLE)

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);

// eingebaute LED
int LED = 13;

void setup()
{
  Serial.begin(9600);

  // pinMode festlegen
  pinMode(LED, 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 UNO R4 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(Auswahl.value());
          Serial.println(" -> LED ein");
          digitalWrite(LED, HIGH);
        }

        // LED ausschalten
        if (Auswahl.value() == 0)
        {
          Serial.print(Auswahl.value());
          Serial.println(F(" -> LED aus"));
          digitalWrite(LED, LOW);
        }    
      }
    }
  }
}

App LightBlue

WiFi

Beispiel: Das Programm zeigt im Browser 6 Zufallszahlen an.
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 < 7; 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: 25. Mrz 2024 @ 15:47

Pin­be­le­gung

Board instal­lie­ren

Board aus­wäh­len