Arduino Uno R4

Mit dem Arduino Uno R4 wird zum ersten Mal kein Microcontroller von ATMega eingesetzt, wie es noch beim Vorgängermodell der Fall war.

technische Daten Arduino Uno R4

Der Arduino Uno R4 kommt in zwei verschiedenen Versionen daher. Beide werden von einer RA4M1 CPU mit 48 Mhz angetrieben und besitzen 256 kB Flash und 32 kB RAM. Gegenüber dem R3 verdreifacht sich damit der Takt und die Boards haben achtmal so viel Flash- und 16 mal so viel Hauptspeicher.Das WiFi-Modell besitzt zusätzlich zum minima Board einen Wifi-Chip, der über einen ESP32 angebunden ist und ein LED-Matrix-Display, dass 8 Zeilen mit 12 LED umfasst.

	WiFi	minima
Abmessung	68,85mm * 53,34mm	68,85mm * 53,34mm
Stromversorgung	6-24V	6-24V
Betriebsspannung	5V	5V
CPU	Renesas RA4M1 (Arm® Cortex®-M4) ESP32-S3	Renesas RA4M1 (Arm® Cortex®-M4)
Speicher	256 kB Flash, 32 kB RAM	256 kB Flash, 32 kB RAM
Takt	48 MHz	48 Mhz
GPIO	6 Analog / 14 Digital	6 Analog / 14 Digital
I²C	1	1
PWM	6	6
USB	USB-C	USB-C
SPI	1	1
UART	1	1
CAN-Bus	1	1
WiFi	+	–
sonstiges	Reset-Button 12*8px LED-Matrix (Wifi-Modell) QWIIC Buchse	Reset-Button

Beide Varianten haben denselben Formfaktor. Die GPIO Spezifikation und I/O Möglichkeiten sind mehr oder weniger vom R3 übernommen worden. Erfreulicherweise ist die USB-Buchse jetzt USB-C.

Der neue Prozessor und der Speicher benötigen natürlich mehr Strom, so dass jeder GPIO Pin nur noch mit max. 0,8A belastet werden darf.

Das WiFi-Modell besitzt eine LED Matrix mit 8* 12 Pixeln, mit der ich mich natürlich sofort beschäftigen wollte. Mich interessiert natürlich auch die QWIIC Buchse, an der sich ein I²C Gerät einfach einstöpseln lässt.

LED-Matrix

Die aktuellste Version der Arduino IDE erkennt die MCU sofort als „Arduino Uno R4 Wifi“ und installiert mit dem Treiber auch die notwendigen Bibliotheken mit.

Für den ersten Versuch orientiere ich mich an dem Beispiel auf der Arduino Website

Für die Ansteuerung des LED Felds benötigst du dieses Header File:

#include "Arduino_LED_Matrix.h"

Die LED-Matrix wird im Programm durch ein byte Array mit 0 ( LED dunkel) und 1 (LED hell) repräsentiert.

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

Ich habe nicht genug Fantasie, um aus dem Code zu erkennen, was daraus wird.

Besser erkennbar wird es vielleicht, wenn ich den Programmcode weglasse und nur die Matrix aus Nullen und Einsen zeige:

   001100011000 
   010010100100 
   010001000100 
   001000001000 
   000100010000 
   000010100000 
   000001000000 
   000000000000 

Falls du es immer noch nicht sehen solltest, hier die Lösung.

Da mir die Bitfummelei im Sourcecode zu umständlich ist, hab ich mir einen kleinen Editor geschrieben, der mir das Array generiert. Du kannst ihn hier runterladen.

Wifi

Auch das Wifi Modul wollte ich natürlich ausprobieren:

Dazu habe ich zunächst eine Datei mit den Loginparametern erstellt.

arduino_secrets.h

#define SECRET_SSID ">ssid>"
#define SECRET_PASS "<passwort>"

Du musst dort natürlich deine konkreten Werte einsetzen.

Auch dieser Sketch orientiert sich im Wesentlichen am Beispielprogramm von Arduino.

#include <WiFiS3.h>
#include <Arduino.h>
#include "arduino_secrets.h"

// Netzwerk ws_ssid und Passwort
const char* ws_ssid = SECRET_SSID;
const char* ws_pass = SECRET_PASS;

// WiFiServer-Objekt erstellen, das auf Port 80 hört
WiFiServer webserver(80);

void setup() {
  // Serielle Kommunikation starten
  Serial.begin(9600);
  while (!Serial);

  // Mit dem WLAN verbinden
  Serial.print("Verbinde mit ");
  Serial.println(ws_ssid);
  WiFi.begin(ws_ssid, ws_pass);

  // Warten, bis die Verbindung hergestellt ist
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }

  // Verbunden, IP-Adresse ausgeben
  Serial.println("");
  Serial.println("WiFi verbunden.");
  Serial.print("IP Adresse: ");
  Serial.println(WiFi.localIP());

  // Webserver starten
  webserver.begin();
}

void loop() {
  // Auf einen neuen Client warten
  WiFiClient client = webserver.available();

  if (client) {
    Serial.println("Neuer Client verbunden");
    String currentLine = "";
    String header = "";

    // Aktuelle Zeit erfassen
    unsigned long currentTime = millis();
    unsigned long previousTime = currentTime;

    // Zeitüberschreitung für die Verbindung (2000 ms)
    const unsigned long timeoutTime = 2000;

    while (client.connected() && (currentTime - previousTime <= timeoutTime)) {
      currentTime = millis();
      if (client.available()) {
        char c = client.read();
        Serial.write(c);
        header += c;
        if (c == '\n') {
          if (currentLine.length() == 0) {
            client.println("HTTP/1.1 200 OK");
            client.println("Content-type:text/html");
            client.println();
            client.println("<!DOCTYPE HTML>");
            client.println("<html>");
            client.println("<head><title>Arduino Webserver</title></head>");
            client.println("<body><h1>Hallo vom Arduino Uno R4 WiFi!</h1></body>");
            client.println("</html>");
            break;
          } else {
            currentLine = "";
          }
        } else if (c != '\r') {
          currentLine += c;
        }
      }
    }

    // Header und Client-Verbindung schließen
    header = "";
    client.stop();
    Serial.println("Client-Verbindung geschlossen");
  }
}

Der Sketch erzeugt einen Webserver auf dem R4 WiFi. In der seriellen Console wird nach Herstellung der Verbindung mit dem AP die IP-Adresse ausgegeben, die dem R4 zugeteilt wurde. In meinem Fall ist es 192.168.179.10. Der Webserver auf dem Uno R4 kann jetzt mit http://92.168.179.10 aufgerufen werden und liefert dann diese Antwort als HTML zurück:

Arduino Uno R4 minima

Für den R4 minima gilt letztlich alles, wie beim WiFi Modell erklärt, ihm fehlen WiFi Modul und LED-Matrix. Auch er ist pinkompatibel zum R3.

Auch die Boardtreiber für das minima werden von der Arduino IDE problemlos installiert, allerdings hatte ich danach Schwierigkeiten, einen Sketch auf das Board zu laden. Ich dachte erst, dass es daran lag, dass ich vorher die WiFi Version angeschlossen hatte, aber auch ein Reboot des Debian Rechners brachte keine Lösung.

Solltest du beim Upload eines Sketches diese Fehlermeldung erhalten:

dfu-util: Cannot open DFU device 2341:0069 found on devnum 12 (LIBUSB_ERROR_ACCESS)

müssen die dev Regeln für den minima angepasst werden. Dafür hat zum Glück schon jemand ein passendes Skript gebaut. Dies speicherst du z.B. unter ~/Downloads und führst dies dann folgendermaßen aus:

cd ~/Downloads
chmod u+x ./post_install.sh
sudo ./post_install.sh

Dadurch werden die dev Regeln so angepasst, dass ich dann mein Ampel Sketch auf den minima übertragen konnte.

Ich verbinde die Ampel wie schon beim R3 mit dem minima. Deshalb kann ich den Sketch 1:1 übernehmen.

int ledRot = 10;
int ledGelb = 11;
int ledGruen = 12;
boolean blinkmode = false;
int phase = 1;// Ampelphase

void setup() {
  // put your setup code here, to run once:
    pinMode(ledRot, OUTPUT);
   pinMode(ledGelb, OUTPUT);
    pinMode(ledGruen, OUTPUT);
}

void loop() {

  if(blinkmode) {
    // Blinkmodus Testmodus
  digitalWrite(ledRot, HIGH);
  digitalWrite(ledGelb, HIGH);
  digitalWrite(ledGruen, HIGH);
  delay(1500);              
  digitalWrite(ledRot, LOW);
  digitalWrite(ledGelb, LOW);
  digitalWrite(ledGruen, LOW);
  delay(200);
  }
  else {
    // Ampelmodus
    switch(phase) {
      case 1:  // Phase rot
        digitalWrite(ledRot, HIGH);
        digitalWrite(ledGelb, LOW);
        digitalWrite(ledGruen, LOW);
        delay(1500);
        phase = 2;
        break;
      case 2: // Phase Rot/Gelb
        digitalWrite(ledRot, HIGH);
        digitalWrite(ledGelb, HIGH);
        digitalWrite(ledGruen, LOW);
        delay(1000);
        phase = 3;
        break;
      case 3:  // Phase Grün
        digitalWrite(ledRot, LOW);
        digitalWrite(ledGelb, LOW);
        digitalWrite(ledGruen, HIGH);
        delay(2000);
        phase = 4;
        break;
      case 4:  // Phase Gelb
        digitalWrite(ledRot, LOW);
        digitalWrite(ledGelb, HIGH);
        digitalWrite(ledGruen, LOW);
        delay(1500);
        phase = 1;
        break;
    }
  }
}

Fazit

Die beiden R4 Modelle haben einen hohen Kompatibilitätsgrad innerhalb der Uno Familie und bringen mit dem WiFi Modell den Arduino ins Netz ohne ein weiteres Shield aufstecken zu müssen. Ich habe bei meinen Tests leider die Erfahrung machen müssen, dass sich das WiFi Modul nicht mit meiner Fritzbox verbinden wollte. Nur beim Gastzugang oder anderen Routern gelang mir dies.

Die LED-Matrix lädt in erster Linie Einsteiger zum Experimentieren ein.

Was mir sehr gefällt: Beide Boards werden mit einer abnehmbarer Plastikabdeckung auf der Unterseite geliefert, die vor mechanischer Beschädigung schützt.

Du findest alle Quellcodedateien auf meinem GIT-Server