Arduino UNO R4 Minima Tutorial: Umstieg vom UNO R3 – DAC, interne RTC & 14-Bit-ADC nutzen

Was ist neu am UNO R4 Minima?

Unter der Haube steckt statt des alten 8-Bit-ATmega328P jetzt ein Renesas RA4M1 – ein 32-Bit ARM Cortex-M4 mit 48 MHz. Das bedeutet nicht nur dreimal höheren Takt, sondern vor allem: 16-mal mehr RAM und Hardware-Features, für die man beim R3 Zusatzmodule brauchte. Eine Echtzeituhr und ein DAC sind direkt im Chip integriert, dazu kommen 14-Bit-ADC-Auflösung und native USB-Unterstützung (das Board kann sich als Tastatur oder Maus ausgeben).

Was du brauchst

Arduino IDE einrichten

1. 1Öffne den Boardverwalter in der Arduino IDE und suche nach „UNO R4“.
2. 2Installiere das Paket Arduino UNO R4 Boards.
3. 3Wähle unter Werkzeuge → Board den Eintrag Arduino UNO R4 Minima und den passenden Port.

Danach läuft alles wie gewohnt – pinMode, digitalWrite, analogRead und die Standard-Bibliotheken verhalten sich wie beim R3.

Code 1: Sinuston aus dem echten DAC

Der R3 kann mit analogWrite() nur PWM – ein schnell geschaltetes Digitalsignal. Der R4 hat an A0 einen echten 12-Bit-DAC, der stufenlos Spannungen zwischen 0 und 5V ausgibt. Damit erzeugst du saubere Analogsignale, z. B. einen Sinuston für einen kleinen Verstärker oder Piezo-Lautsprecher (über einen Koppelkondensator angeschlossen).

#include "analogWave.h" // im UNO-R4-Boardpaket enthalten

analogWave welle(DAC);

void setup() {
  Serial.begin(115200);
  welle.sine(440); // Kammerton A: 440 Hz Sinus an A0
}

void loop() {
  // Frequenz langsam von 220 auf 880 Hz gleiten lassen
  for (int f = 220; f <= 880; f += 10) {
    welle.freq(f);
    Serial.print("Frequenz: ");
    Serial.print(f);
    Serial.println(" Hz");
    delay(100);
  }
}

Die mitgelieferte analogWave-Bibliothek erzeugt Sinus-, Rechteck- und Sägezahnsignale, ohne dass du dich um Timer kümmern musst. Für eigene Kurvenformen kannst du den DAC auch direkt mit analogWrite(A0, wert) beschreiben, nachdem du analogWriteResolution(12) gesetzt hast.

Code 2: Die interne Echtzeituhr nutzen

Beim R3 brauchte jede Uhr ein externes RTC-Modul wie das DS3231. Der R4 bringt eine RTC im Chip mit – inklusive Alarm-Funktionen. Ohne Pufferbatterie verliert sie beim Trennen der Stromversorgung allerdings die Zeit; für netzbetriebene Projekte (Zeitschaltuhr, Datenlogger mit Zeitstempel) ist sie trotzdem extrem praktisch.

#include "RTC.h" // im UNO-R4-Boardpaket enthalten

void setup() {
  Serial.begin(115200);
  RTC.begin();

  // Startzeit einmalig setzen: 14. Juli 2026, 12:00:00, Dienstag
  RTCTime startzeit(14, Month::JULY, 2026, 12, 0, 0,
                    DayOfWeek::TUESDAY, SaveLight::SAVING_TIME_ACTIVE);
  RTC.setTime(startzeit);
}

void loop() {
  RTCTime jetzt;
  RTC.getTime(jetzt);

  Serial.print(jetzt.getDayOfMonth());
  Serial.print(".");
  Serial.print(Month2int(jetzt.getMonth()));
  Serial.print(".");
  Serial.print(jetzt.getYear());
  Serial.print(" - ");
  Serial.print(jetzt.getHour());
  Serial.print(":");
  Serial.print(jetzt.getMinutes());
  Serial.print(":");
  Serial.println(jetzt.getSeconds());

  delay(1000);
}

Code 3: 14-Bit-ADC – 16-mal feinere Messungen

Der R3 löst Analogwerte mit 10 Bit auf (1024 Stufen). Der R4 schafft 14 Bit – 16.384 Stufen. Bei 5V Referenz bedeutet das: Statt ~4,9 mV pro Stufe erkennst du Änderungen von ~0,3 mV. Das macht sich bei Fotowiderständen, Potis, Spannungsteilern und analogen Sensoren sofort in ruhigeren, feineren Messwerten bemerkbar.

#define SENSOR_PIN A1

void setup() {
  Serial.begin(115200);
  analogReadResolution(14); // R4-Feature: 14 Bit statt 10
}

void loop() {
  // Mittelwert aus 16 Messungen fuer noch ruhigere Werte
  long summe = 0;
  for (int i = 0; i < 16; i++) {
    summe += analogRead(SENSOR_PIN);
    delayMicroseconds(200);
  }
  int roh = summe / 16;                      // 0..16383
  float spannung = roh * 5.0 / 16383.0;      // in Volt

  Serial.print("Rohwert: ");
  Serial.print(roh);
  Serial.print("  =  ");
  Serial.print(spannung, 4); // 4 Nachkommastellen
  Serial.println(" V");

  delay(500);
}

Code 4: Mehr RAM in der Praxis – OLED ohne Speichersorgen

Ein 128x64-OLED braucht allein 1 KB Framebuffer – beim R3 mit seinen 2 KB RAM wird es damit schnell eng. Mit 32 KB auf dem R4 kannst du OLED, große Puffer und Berechnungen kombinieren, ohne an Grenzen zu stoßen. Verkabelung des SSD1306: VCC an 5V, GND an GND, SDA an A4, SCL an A5. Benötigte Bibliotheken: Adafruit SSD1306 und Adafruit GFX.

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

Adafruit_SSD1306 oled(128, 64, &Wire, -1);

// Grosser Messwert-Puffer: beim R3 undenkbar, beim R4 kein Problem
float messHistorie[1000];
int index = 0;

void setup() {
  Serial.begin(115200);
  analogReadResolution(14);
  oled.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  oled.clearDisplay();
}

void loop() {
  float spannung = analogRead(A1) * 5.0 / 16383.0;
  messHistorie[index] = spannung;
  index = (index + 1) % 1000;

  oled.clearDisplay();
  oled.setTextColor(SSD1306_WHITE);
  oled.setTextSize(1);
  oled.setCursor(0, 0);
  oled.print("UNO R4 Minima");
  oled.setTextSize(2);
  oled.setCursor(0, 20);
  oled.print(spannung, 3);
  oled.print(" V");
  oled.setTextSize(1);
  oled.setCursor(0, 50);
  oled.print("Messung #");
  oled.print(index);
  oled.display();

  delay(200);
}

Praxistipps für den Umstieg

Troubleshooting