#arduinounor4

[adafruit]

Yes! Stemma QT boards work with the Arduino UNO R4! 🎉🔌🛠️📡💡🌐

we just got our UNO R4 WiFi, featuring the Renesas RA4M1 series of chips https://blog.adafruit.com/2023/05/25/eye-on-npi-renesas-ra4m1-microcontroller-series-eyeonnpi-digikey-renesasglobal-digikey-adafruit/ an ESP32 wifi co-processor, an adorable LED grid, and a JST SH 4-pin connector…a.k.a a Qwiic port! Yay it is so great to see this connector becoming standardized on so many platforms. It means that all of our STEMMA QT devices https://www.adafruit.com/category/1018 will work plug-and-play. Here we're testing it with an OLED https://www.adafruit.com/product/938 and SHT41 breakout https://www.adafruit.com/search?q=sht4 we only had to update our demo to use Wire1 instead of Wire, since the secondary I2C bus is used for this connector. No soldering required!

[draegerit]

Arduino UNO R4 Projekt: Weltzeituhr mit LCD Keypad Shield

Wie du das LCD Keypad Shield programmierst, habe ich dir bereits im Beitrag LCD Keypad Shield für Arduino: Einsteigerfreundliches Display mit Tastensteuerung ausführlich erläutert. In diesem Beitrag soll es nun darum gehen, wie du dir eine Weltzeituhr am Arduino UNO R4 programmierst. Der Arduino UNO R4 verfügt über einen ESP32 Chip und mit dem Formfaktor des alten UNO R3 ist dieser bestens geeignet für dieses Projekt. https://youtu.be/uCFm0KZOZh8 Der Aufbau einer Schaltung ist recht einfach, denn das LCD Keypad Shield wird lediglich auf den Mikrocontroller gesteckt.

Das LCD Display verfüg über zwei Zeilen mit je 16 Zeichen, das ist für die Anzeige von Datum, Uhrzeit und der Zeitzone etwas wenig, daher habe ich das auf den Tag, die Uhrzeit und die Zeitzone in Kurzform komprimiert.

Benötigte Ressourcen für dieses kleine Projekt

Wenn du das kleine Projekt nachbauen möchtest, dann benötigst du: - einen Arduino UNO R4 WiFi*, - ein USB-C Datenkabel*, - ein LCD Keypad Shield* Hinweis von mir: Die mit einem Sternchen (*) markierten Links sind Affiliate-Links. Wenn du über diese Links einkaufst, erhalte ich eine kleine Provision, die dazu beiträgt, diesen Blog zu unterstützen. Der Preis für dich bleibt dabei unverändert. Vielen Dank für deine Unterstützung!

NTP Timeserver für die Abfrage von Zeiten

Es gibt im Internet einige NTP Timeserver welche für dieses Projekt verwendet werden können, für dieses Projekt verwende ich ptbtime1.ptb.de von der Physikalisch-technische Bundesanstalt. Wir müssen lediglich für die jeweilige Zeitzone noch Stunden dazu oder abzählen. Liste mit Zeitzonen und TimeOffsets Nachfolgend gebe ich dir eine Tabelle, aus welcher du entnehmen kannst, welchen Offset du für die Zeit verwenden musst. Rechenbeispiele: - für Pacific Standard Time (PST) musst du von der aktuellen Uhrzeit -8h rechnen, - für Japan Standard Time (JST) musst du von der aktuellen Uhrzeit +9h rechnen KontinentZeitzoneUTC ZeitNordamerikaEastern Standard Time (EST)UTC-5Central Standard Time (CST)UTC-6Mountain Standard Time (MST)UTC-7Pacific Standard Time (PST)UTC-8Alaska Standard Time (AKST)UTC-9Hawaii-Aleutian Standard Time (HAST)UTC-10SüdamerikaBrasília Time (BRT)UTC-3Argentina Standard Time (ART)UTC-3Chile Standard Time (CLT)UTC-4Venezuela Standard Time (VET)UTC-4:30EuropaGreenwich Mean Time (GMT)UTC+0Central European Time (CET)UTC+1Eastern European Time (EET)UTC+2British Summer Time (BST)UTC+1AfrikaWest Africa Time (WAT)UTC+1Central Africa Time (CAT)UTC+2East Africa Time (EAT)UTC+3South Africa Standard Time (SAT)UTC+2AsienIndian Standard Time (IST)UTC+5:30China Standard Time (CST)UTC+8Japan Standard Time (JST)UTC+9Australian Eastern Standard Time (AEST)UTC+10Australian Central Standard Time (ACST)UTC+9:30Australian Western Standard Time (AWST)UTC+8OzeanienNew Zealand Standard Time (NZST)UTC+12Fiji Standard Time (FST)UTC+12Tonga Standard Time (TST)UTC+13

Programmieren einer Weltzeituhr mit einem NTP Zeitserver

Wie du dich mit einem Mikrocontroller zu einem WiFi Netzwerk verbindest, habe ich dir bereits in einigen Beiträgen ausführlich erläutert. Jedoch nehme ich dich in der nachfolgenden Schritt-für-Schritt-Anleitung an die Hand, sodass du alle Informationen in diesem Beitrag findest. Schritt 1 - Installation der benötigten Bibliotheken Für die Abfrage der Zeit aus dem Internet benötigen wir eine Bibliothek, ich verwende hier NTPClient welche als ZIP-Datei vom GitHub Repository arduino-libraries/NTPClient heruntergeladen werden kann. Schritt 2 - Aufbau einer WiFi Verbindung Im ersten richtigen Schritt programmieren wir die WiFi Verbindung, dieses ist recht einfach und mit wenigen Zeilen Code erledigt. //Bibliotheken zum aufbau einer WiFi Verbindung #include #include //Die Zugangsdaten zum WiFi-Netzwerk const char *ssid = "*****"; const char *password = "*****"; void setup() { //beginn der seriellen Kommunikation Serial.begin(115200); //Aufbau der WiFi Verbindung WiFi.begin(ssid, password); //solange noch keine Verbindung hergestellt wurde, soll //eine Pause von 500ms eingelegt werden, //ein Punkt auf der seriellen Schnittstelle ausgegeben werden while (WiFi.status() != WL_CONNECTED) { delay(500); Serial.print("."); } //Wenn die Verbindung erfolgreich aufgebaut wurde, dann //wird der nchfolgende Text angezeigt. Serial.print("Erfolgreich zu "); Serial.print(ssid); Serial.println(" verbunden!"); } void loop() { //bleibt leer } Wenn die Verbindung zum Netzwerk hergestellt wurde, dann erscheint auf der seriellen Schnittstelle die Ausgabe vom Text "Erfolgreich zu verbunden!". Schritt 3 - Abfrage einer Zeit von einem NTPServer Wie erwähnt möchte ich die Daten vom Zeitserver der Physikalisch-technische Bundesanstalt abrufen. Die Adresse von diesem ist ptbtime1.ptb.de. //Bibliotheken zum aufbau einer WiFi Verbindung #include #include //Die Zugangsdaten zum WiFi-Netzwerk const char *ssid = "*****"; const char *password = "*****"; void setup() { //beginn der seriellen Kommunikation Serial.begin(115200); //Aufbau der WiFi Verbindung WiFi.begin(ssid, password); //solange noch keine Verbindung hergestellt wurde, soll //eine Pause von 500ms eingelegt werden, //ein Punkt auf der seriellen Schnittstelle ausgegeben werden while (WiFi.status() != WL_CONNECTED) { delay(500); Serial.print("."); } //Wenn die Verbindung erfolgreich aufgebaut wurde, dann //wird der nchfolgende Text angezeigt. Serial.print("Erfolgreich zu "); Serial.print(ssid); Serial.println(" verbunden!"); } void loop() { //bleibt leer } Die Ausgabe auf der seriellen Schnittstelle ist wiefolgt: - erste Zeile, der Hinweis das die WiFi-Verbindung aufgebaut wurde, - zweite bis n-te Zeile, die Uhrzeit vom NTPServer

Wenn noch keine Verbindung zum Server hergestellt wurde, dann kann auch einmal die Uhrzeit mit 01:00:00 geliefert werden. Hier muss man lediglich ein paar Sekunden warten. In der Grafik ist ersichtlich, dass die Uhrzeit um eine Stunde verschoben ist, bedingt durch die europäische Sommerzeit. Um dies anzupassen, wird die Funktion setTimeOffset am Objekt timeClient aufgerufen, welches in der setup-Funktion initialisiert wird. Dabei wird der Funktion einmalig ein Parameter von 7200 Sekunden übergeben, was zwei Stunden entspricht. timeClient.setTimeOffset(7200); Schritt 4 - Ausgeben der Daten auf dem LCD Display Das LCD Display hat maximal 16 Zeichen für je zwei Zeilen zur Verfügung, anders als bei OLED Displays kann man hier nicht durch die Auswahl einer kleineren Schriftart für mehr Platz sorgen. Man muss quasi Abstriche machen. Damit wir mit dem LCD Display kommunizieren können, importieren wir die LiquidCrystal Bibliothek welche bei der Arduino IDE 2.x dabei ist. //Bibliotheken zum aufbau einer WiFi Verbindung #include #include //Bibliothek zum kommunizieren mit einem Zeitserver #include //Bibliothek zum kommunizieren mit dem LCD Display #include //Objekt vom Typ LiquidCrystal initialisieren LiquidCrystal lcd(8, 9, 4, 5, 6, 7); //Die Zugangsdaten zum WiFi-Netzwerk const char *ssid = "*****"; const char *password = "******"; WiFiUDP ntpUDP; NTPClient timeClient(ntpUDP, "ptbtime1.ptb.de", 3600, 60000); void setup() { //beginn der seriellen Kommunikation Serial.begin(115200); //Aufbau der WiFi Verbindung WiFi.begin(ssid, password); //solange noch keine Verbindung hergestellt wurde, soll //eine Pause von 500ms eingelegt werden, //ein Punkt auf der seriellen Schnittstelle ausgegeben werden while (WiFi.status() != WL_CONNECTED) { delay(500); Serial.print("."); } //Wenn die Verbindung erfolgreich aufgebaut wurde, dann //wird der nchfolgende Text angezeigt. Serial.print("Erfolgreich zu "); Serial.print(ssid); Serial.println(" verbunden!"); //beginn der Kommunikation mit dem Zeitserver timeClient.begin(); //Zeitoffset von 1h für die europäische Sommerzeit timeClient.setTimeOffset(7200); //Das verbaute LCD Display hat 16 Zeichen mit zwei Zeilen. //Die Bibliothek kann für viele weitere verwendet werden, daher müssen //diese Daten übergeben werden. lcd.begin(16, 2); } void loop() { //aktualisieren der Daten timeClient.update(); //Ausgeben eines formatierten Zeitstempels String formattedTime = timeClient.getFormattedTime(); Serial.println(formattedTime); //Daten im LCD Display leeren lcd.clear(); //Anzeigen der Uhrzeit lcd.print(formattedTime); //eine Pause von 1 Sekunde delay(1000); } Die Uhrzeit wird nun nicht nur auf der seriellen Schnittstelle ausgegeben, sondern auch auf dem LCD Display.

Schritt 5 - Anzeigen von unterschiedlichen Weltzeiten auf dem Display Im nächsten Schritt wollen wir jetzt eine Liste von Weltzeiten anlegen und diese nacheinander anzeigen lassen. In der zweiten noch leeren Zeile möchte ich die Zeitzone und die Differenz anzeigen lassen. Weltzeituhr am Arduino UNO R4 WiFi mit dem LCD Keypad ShieldHerunterladen Am einfachsten geht dieses mit einem MenuItem welches nachfolgende Eigenschaften hat: struct MenuItem { double timeOffset; //die Zeit welche abgezogen/addiert werden soll String timezone; //die Bezeichnung der Zeitzone }; Von diesem neuen Datentyp MenuItem können wir uns nun beliebig viele anlegen und in ein Array ablegen. MenuItem item1 = { 1, "CEST (UTC +2)" }; //Central European Summer Time (CEST) MenuItem item2 = { 0, "GMT (UTC +0)" }; //Greenwich Mean Time (GMT) MenuItem item3 = { -4, "CLT (UTC -4)" }; //Chile Standard Time (CLT) MenuItem item4 = { 12, "NZST (UTC +12)" }; //New Zealand Standard Time (NZST) MenuItem item5 = { 9.5, "ACST (UTC +9:30)" }; //Australian Central Standard Time (ACST) MenuItem item6 = { -10, "HAST (UTC -10)" }; //Hawaii-Aleutian Standard Time (HAST) const int NUM_MENUITEMS = 6; MenuItem menu = { item1, item2, item3, item4, item5, item6 }; Wir entnehmen ein MenuItem mit dem aktuellen index aus dem Array. Im Anschluss berechnen wir den Offset. Dieser Offset wird in Sekunden übergeben (1h = 3600 Sekunden). Die nächsten Zeilen dienen dann lediglich um den Zeitstempel wie zuvor zu laden und auf dem Display anzuzeigen. MenuItem item = menu; double timeOffset = item.timeOffset * 3600; timeClient.setTimeOffset(timeOffset); //aktualisieren der Daten timeClient.update(); //Ausgeben eines formatierten Zeitstempels String formattedTime = timeClient.getFormattedTime(); Serial.println(formattedTime); //Daten im LCD Display leeren lcd.clear(); //Anzeigen der Uhrzeit lcd.print(formattedTime); //Anzeigen der Zeitzone lcd.setCursor(0, 1); lcd.print(item.timezone); Die Weltzeiten sollen immer jeweils für 5 Sekunden angezeigt werden, dafür nutze ich eine bekannte Lösung mit einer Pause ohne Delay. Da ich auf die Werte im Array mit der Variable index zugreife erhöhe ich diese damit alle 5 Sekunden jedoch läuft das Programm im Hintergrund weiter. long lastAction = -1; const long PAUSE = 3000; //Alle 5 Sekunden die Zeitzone wechseln long currentMillis = millis(); if (lastAction + PAUSE < currentMillis) { lastAction = currentMillis; if (index < NUM_MENUITEMS-1) { index++; } else { index = 0; } }

Arbeiten mit dem Timestamp

Von der Bibliothek erhalten wir mit der Funktion getEpochTime() einen Zeitstempel in Sekunden. Dieser repräsentiert die vergangenen Sekunden seit dem 01.01.1970. Aus diesem können wir zusätzlich auch das Datum berechnen und somit auf dem Display zusätzlich das Datum anzeigen. Ich habe hier bei der Uhrzeit die Sekunden abgeschnitten und das Jahr auf zweistellig gekürzt.

Das fertige Programm kannst du nachfolgend herunterladen: Anzeige von Datum & Uhrzeit von verschiedenen Zeitzonen am LCD Keypad Shield mit dem Arduino UNO R4 WiFiHerunterladen // Funktion zur Umwandlung eines Unix-Timestamps in ein Datum String formatiereDatum(unsigned long timestamp) { unsigned long days = timestamp / 86400; // Tage seit dem Unix-Epoch unsigned long years = 1970; // Beginn des Unix-Epoch unsigned long remainingDays = days; // Jahr berechnen while (remainingDays >= 365) { if (istSchaltjahr(years)) { remainingDays -= 366; } else { remainingDays -= 365; } years++; } // Monat und Tag berechnen unsigned long months = 0; unsigned long monthLength = 0; while (remainingDays > monthLength) { monthLength = tageImMonat(months, years); remainingDays -= monthLength; months++; } return zweistellig(remainingDays + 1) + "." + zweistellig(months + 1) + "." + String(years % 100); } // Funktion zur Überprüfung, ob ein Jahr ein Schaltjahr ist bool istSchaltjahr(unsigned long year) { return (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0); } // Funktion zur Rückgabe der Anzahl der Tage in einem Monat unsigned long tageImMonat(unsigned long month, unsigned long year) { if (month == 1) { // Februar if (istSchaltjahr(year)) { return 29; } else { return 28; } } else if (month == 3 || month == 5 || month == 8 || month == 10) { // April, Juni, September, November return 30; } else { return 31; } } // Funktion zur Umwandlung eines Unix-Timestamps in eine Uhrzeit String formatiereUhrzeit(unsigned long timestamp) { unsigned long minutes = (timestamp % 3600) / 60; unsigned long hours = (timestamp % 86400) / 3600; return zweistellig(hours) + ":" + zweistellig(minutes); } // Funktion zur Formatierung von Zahlen auf zwei Stellen String zweistellig(unsigned long zahl) { if (zahl < 10) { return "0" + String(zahl); } else { return String(zahl); } } Read the full article

[draegerit]

Arduino UNO R4: LED Matrix Uhr mit NTP-Zeitsynchronisation

In diesem Beitrag möchte ich dir zeigen, wie du am neuen Arduino UNO R4 WiFi eine Laufschrift auf der LED Matrix erzeugst. Als Beispiel möchte ich hier eine Uhrzeit anzeigen, welche ich von einem NTP Server empfange.

Arduino UNO R4: LED Matrix Uhr mit NTP-Zeitsynchronisation Mit diesem Beitrag möchte ich an den bereits veröffentlichten Beitrag Leicht gemacht: Laufschrift auf dem Arduino UNO R4 programmieren anknüpfen. Zu diesem Beitrag habe ich einen Kommentar erhalten, in welchem darauf hingewiesen wurde, dass es eine sehr einfache Lösung dafür gibt.

Benötigte Ressourcen für dieses Projekt

Wenn du dieses kleine Projekt nachbauen möchtest, dann benötigst du lediglich einen Arduino UNO R4 WiFi inkl. Datenkabel.

Arduino UNO R4 WiFi

Arduino UNO R4 WiFi Diesen Mikrocontroller bekommst du, nachdem nun etwas mehr Zeit seit dem Release vergangen ist, recht günstig auf diversen Plattformen. LinkPreisVersandkostenhttps://www.reichelt.de/26,50 €5,95 €https://botland.de/27,90 €4,95 €https://store.arduino.cc/25 €10 €https://www.ebay.de/*ab 23 €- Hinweis von mir: Die mit einem Sternchen (*) markierten Links sind Affiliate-Links. Wenn du über diese Links einkaufst, erhalte ich eine kleine Provision, die dazu beiträgt, diesen Blog zu unterstützen. Der Preis für dich bleibt dabei unverändert. Vielen Dank für deine Unterstützung!

Programmieren einer Laufschrift in der Arduino IDE am Arduino UNO R4 WiFi

Kommen wir zunächst zu einem einfachen Beispiel und geben einen Text auf der LED Matrix des Arduino UNO R4 WiFi aus. Für das erzeugen eines Text als Scrolltext benötigen wir die Bibliothek Arduino Graphics. Die Bibliothek findest du mit dem Suchbegriff "Arduino Graphics" im Bibliotheksverwalter. In meinem Fall liegt derzeit die Version 1.1.0 vor.

//einbinden der Bibliotheken zum //ansteuern der LED Matrix auf dem //Arduino UNO R4 WiFi #include "ArduinoGraphics.h" #include "Arduino_LED_Matrix.h" //erzeugen eines ArduinoLEDMatrix Objektes ArduinoLEDMatrix matrix; void setup() { //beginn der kommunikation mit der LED Matrix matrix.begin(); } void loop() { //beginn des zeichnens matrix.beginDraw(); //alle LEDs deaktivieren matrix.stroke(0xFFFFFFFF); //Geschwindigkeit des Scrolltextes setzen //je niedriger der Wert desto schneller läuft der Text matrix.textScrollSpeed(50); //der Text welcher ausgegeben werden soll const char text = " Hallo Welt! "; //Schriftgröße setzen, //verfügbare Werte sind: // - Font_4x6 // - Font_5x7 matrix.textFont(Font_4x6); //koordinate für den Text //je nach Schriftgröße kann man damit den Text //in der Matrix zentrieren matrix.beginText(0, 1, 0xFFFFFF); //Ausgeben des Textes matrix.println(text); //definieren von wo gescrollt werden soll matrix.endText(SCROLL_LEFT); //beenden des zeichnens matrix.endDraw(); } Programm - einfacher Text als Laufschrift auf der LED Matrix des Arduino UNO R4 WiFiHerunterladen Beispiel - auslesen eines Zeitstempels vom NTP-Server und anzeigen auf der LED Matrix Der Arduino UNO R4 WiFi verfügt, wie der Name es erahnen lässt, über ein zusätzliches WiFi Modul. In diesem Fall ist es ein ESP32-S3-MINI. Über dieses WiFi Modul können wir jetzt mit dem Internet kommunizieren und so auch einen Zeitstempel (Datum & Uhrzeit) von einem NTP Server lesen. Ein NTP Server ist ein Dienst, über welchen wir eine sehr genaue Zeit erhalten können. Jedoch gibt es hier auch immer ein delay beim Lesen, jedoch wird dieses über das Protokoll sehr minimiert, sodass die Zeit immer sehr genau ankommt. Schritt 1 - Aufbau der WiFi Verbindung zum Heimnetzwerk Zunächst müssen wir eine Verbindung zum lokalen Heimnetzwerk aufbauen. Ich habe mir hier das Beispiel ConnectwithWPA.ino vom GitHub Repository arduino / ArduinoCore-renesas gezogen und auf das Minimum gekürzt. #include char ssid = ""; char pass = ""; int status = WL_IDLE_STATUS; void setup() { Serial.begin(9600); Serial.println("Verbindungsaufbau zu: " + String(ssid)); int connectionCounter = 0; while (status != WL_CONNECTED) { Serial.print("."); status = WiFi.begin(ssid, pass); delay(250); if ((connectionCounter % 10) == 0) { Serial.println(); } connectionCounter++; } IPAddress ip = WiFi.localIP(); Serial.print("verbunden mit der IP Adresse: " + ip.toString()); } void loop() { } Wenn der Mikrocontroller startet, dann wird zunächst die Verbindung aufgebaut. Während des Aufbaus wird ein Punkt geschrieben, somit kann man nachvollziehen wie oft nun schon ein Aufbau probiert wurde.

Bei Erfolg wird dann die IP-Adresse ausgegeben. Schritt 2 - Auslesen eines Zeitstempels von einem NTP Server Damit wir mit einem NTP Server kommunizieren können und somit den Zeitstempel erhalten, müssen wir eine zusätzliche Bibliothek installieren Ich habe sehr gute Erfahrung mit der Bibliothek NTPClient von Fabrice Weinberg gesammelt und dir auch bereits am Beispiel ESP8266 – NTP Protokoll für das lesen eines genauen Zeitstempels gezeigt wie man die Daten auslesen und im seriellen Monitor anzeigen lassen kann.

Wenn du das kleine Beispiel ausführst, dann kann es besonders am Anfang vorkommen, dass kein vollständiger / gültiger Zeitstempel empfangen wird (1). Hier hilft es eine kleine Abfrage einzubauen, ob der Wert größer als 1707219755 ist. (Wir können ja schließlich nicht in die Zeit zurückreisen.)

#include #include #include char ssid = ""; char pass = ""; int status = WL_IDLE_STATUS; // the WiFi radio's status WiFiUDP ntpUDP; NTPClient timeClient(ntpUDP, "pool.ntp.org"); //Wochentage, im englischen beginnt die Woche mit dem Sonntag char* wochentage = { "So", "Mo", "Di", "Mi", "Do", "Fr", "Sa" }; void setup() { Serial.begin(9600); Serial.println("Verbindungsaufbau zu: " + String(ssid)); int connectionCounter = 0; while (status != WL_CONNECTED) { Serial.print("."); status = WiFi.begin(ssid, pass); delay(250); if ((connectionCounter % 10) == 0) { Serial.println(); } connectionCounter++; } IPAddress ip = WiFi.localIP(); Serial.println("verbunden mit der IP Adresse: " + ip.toString()); timeClient.begin(); //Offset in Sekunden zur GMT +/- 0 Zeitzone //Für Deutschland muss man 1h = 3600 Sekunden nehmen, //je nach Sommer- /Winterzeit muss jedoch diese //Zeit wieder abgezogen werden. timeClient.setTimeOffset(3600); } void loop() { timeClient.update(); //Zeitstempel auf der Sekunde genau //(Nicht zuverwechseln mit dem UNIX Timestamp welcher auf die Millisekunde genau ist.) unsigned long epochTime = timeClient.getEpochTime(); //Ein gültiger & aktueller Zeitstempel ist größer als 1707219755 if (epochTime < 1707219755) { delay(25); return; } Serial.print("Epoch Time: "); Serial.println(epochTime); //Ausgabe des formatierten Zeitstempels String formattedTime = timeClient.getFormattedTime(); Serial.print("formatierter Zeitstempel: "); Serial.println(formattedTime); //einzelne Werte der Uhrzeit lesen int aktuellerTag = timeClient.getDay(); int aktuelleStunde = timeClient.getHours(); int aktuelleMinute = timeClient.getMinutes(); int aktuelleSekunde = timeClient.getSeconds(); char timestamp; sprintf(timestamp, "Heute ist %s, ::", wochentage, aktuelleStunde, aktuelleMinute, aktuelleSekunde); Serial.println(timestamp); delay(500); } Schritt 3 - Ausgeben der Zeit auf der LED Matrix Zum Schluss wollen wir nun die Zeit auf der LED Matrix ausgeben. Dazu nehmen wir uns zusätzlich das kleine Codebeispiel vom Anfang und binden dieses ein. #include #include "ArduinoGraphics.h" #include "Arduino_LED_Matrix.h" #include #include char ssid = ""; char pass = ""; int status = WL_IDLE_STATUS; // the WiFi radio's status WiFiUDP ntpUDP; NTPClient timeClient(ntpUDP, "pool.ntp.org"); //erzeugen eines ArduinoLEDMatrix Objektes ArduinoLEDMatrix matrix; //Wochentage, im englischen beginnt die Woche mit dem Sonntag char* wochentage = { "So", "Mo", "Di", "Mi", "Do", "Fr", "Sa" }; void setup() { Serial.begin(9600); Serial.println("Verbindungsaufbau zu: " + String(ssid)); int connectionCounter = 0; while (status != WL_CONNECTED) { Serial.print("."); status = WiFi.begin(ssid, pass); delay(250); if ((connectionCounter % 10) == 0) { Serial.println(); } connectionCounter++; } IPAddress ip = WiFi.localIP(); Serial.println("verbunden mit der IP Adresse: " + ip.toString()); timeClient.begin(); //Offset in Sekunden zur GMT +/- 0 Zeitzone //Für Deutschland muss man 1h = 3600 Sekunden nehmen, //je nach Sommer- /Winterzeit muss jedoch diese //Zeit wieder abgezogen werden. timeClient.setTimeOffset(3600); matrix.begin(); } void loop() { timeClient.update(); //Zeitstempel auf der Sekunde genau //(Nicht zuverwechseln mit dem UNIX Timestamp welcher auf die Millisekunde genau ist.) unsigned long epochTime = timeClient.getEpochTime(); //Ein gültiger & aktueller Zeitstempel ist größer als 1707219755 while (epochTime < 1707219755) { epochTime = timeClient.getEpochTime(); delay(25); } //Wochentag auslesen int aktuellerTag = timeClient.getDay(); //auslesen der Stunde int aktuelleStunde = timeClient.getHours(); //auslesen der Minuten int aktuelleMinute = timeClient.getMinutes(); //Aufbau der formatierten Ausgabe auf der LED Matrix //Es wurden die Sekunden entfernt. char timestamp; snprintf(timestamp, 20, "%s, : ", wochentage, aktuelleStunde, aktuelleMinute); matrix.beginDraw(); matrix.stroke(0xFFFFFFFF); matrix.textScrollSpeed(75); matrix.textFont(Font_5x7); matrix.beginText(0, 1, 0xFFFFFF); matrix.println(timestamp); matrix.endText(SCROLL_LEFT); matrix.endDraw(); delay(500); } Read the full article

[draegerit]

Leicht gemacht: Laufschrift auf dem Arduino UNO R4 programmieren

Den Arduino UNO R4 habe ich dir bereits vorgestellt, heute soll es darum gehen wie du eine Laufschrift auf diesem Anzeigen kannst.

Leicht gemacht: Laufschrift auf dem Arduino UNO R4 programmieren Disclaimer: Der Code für dieses Projekt wurde mit freundlicher Genehmigung aus dem GitHub-Repository https://github.com/ClemensAtElektor verwendet. In diesem Beitrag wird erläutert, wie Sie diesen Code für die Anzeige einer Laufschrift nutzen können. Jegliche Rechte am Code liegen beim ursprünglichen Entwickler.

Einbinden als Bibliothek

Ich habe wie erwähnt den Code genommen und in eine Bibliothek umgewandelt, somit kannst du ganz einfach deinen Lauftext mit nur wenigen Zeilen Code erstellen. Die kleine Bibliothek findest du auf meinem GitHUB Repository unter: https://github.com/StefanDraeger/Arduino-UNO-R4/tree/main/R4WiFi_led_matrix/ArduinoUNOR4WiFi-ScrollText Zum Import in die Arduino IDE kannst du dir diese auch als ZIP-Datei herunterladen und einfach über Sketch > Bibliothek einbinden > .ZIP-Bibliothek hinzufügen.

Einbinden einer ZIP-Bibliothek in der Arduino IDE Danach findest du unter Datei > Beispiele > ArduinoUNOR4WiFi-ScrollText ein kleines Beispiel, welches ich dir nachfolgend aber genauer zeigen werde.

"Hello, world!" auf der LED-Matrix ausgeben

Wenn die Bibliothek nun installiert ist, dann können wir mit wenigen Zeilen Code den Text "Hello, world!" auf der LED-Matrix ausgeben. Dazu müssen wir lediglich das Objekt initialisieren und der Funktion "scrollText" zwei Parameter übergeben. Zum einen ist dieses der Text und die Geschwindigkeit in welche diese durchlaufen soll. #include UnoR4ScrollText maxtrix; void setup() { } void loop() { uint8_t banner_text = " Hello, world!"; uint8_t speed = 50; maxtrix.scrollText(banner_text, speed); } Meine Handykamera hat hier wieder Probleme mit der Aufnahme von LED-Matrixen, jedoch denke ich das der Text hier trotzdem noch zu erkennen ist. Arduino UNO R4 WiFi mit Laufschrift

Abschluss & Ausblick

Sowohl die mitgelieferte Bibliothek als auch der originale Quellcode ermöglichen die Anzeige von Laufschrift auf der LED-Matrix des Arduino UNO R4, einschließlich der Darstellung von Texten und Sensorwerten. In meinem kommenden Beitrag plane ich, einen Sensor zu verwenden, um dessen Daten auf der Matrix anzuzeigen. Dank der WiFi-Funktionalität des Arduino UNO R4 sind jedoch noch viele weitere spannende Anwendungen denkbar. Beispielsweise kann man Services wie OpenWeather.org nutzen, um aktuelle Wetterdaten abzurufen und auf der Matrix darzustellen. Die Möglichkeiten, die dieser neue Mikrocontroller bietet, sind schier endlos und laden dazu ein, kreative Projekte zu erforschen und umzusetzen. Read the full article

[draegerit]

Entdecke den neuen Arduino UNO R4: Die neueste Generation des beliebten Mikrocontrollers ist da!

Hey Leute! Heute möchte ich euch die neueste Errungenschaft in der Welt der Mikrocontroller vorstellen - den brandneuen Arduino UNO R4! Dieser beeindruckende Mikrocontroller kommt in zwei Versionen daher: mit WiFi und LED Matrix oder in einer schlanken Minima-Version. In diesem Beitrag gebe ich euch einen ersten Einblick in die technischen Daten und Features beider Modelle. Aber keine Sorge, ich werde jedem der beiden Mikrocontroller bald separate, ausführliche Beiträge widmen.

Technische Daten im Duell: Arduino UNO R4 WiFi vs. Minima

Im Folgenden zeige ich dir eine detaillierte Tabelle mit den technischen Daten beider Mikrocontroller. Du wirst feststellen, dass sich die Daten weitgehend ähneln. Allerdings bietet der Arduino UNO R4 mit WiFi-Unterstützung durch den verbauten ESP32 S3 Chip zusätzliche Funktionen wie WiFi und Bluetooth Low Energy. Tauchen wir nun tiefer ein und erkunden wir diese interessanten Details genauer. Arduino UNO R4 MinimaArduino UNO R4 WiFiMicrocontrollerRenesas RA4M1 (ARM cortex-M4)Taktgeschwindigkeit48 MHzESP32 S3 - bis zu 240 MHzSpeicherR4AM1, 256 kB Flash, 32 kB RAMESP32-S3, 384 kB ROM, 512 kB SRAMSchnittstellenUART, I2C, SPI, CANUSB-SchnittstelleUSB-Typ-Cdigitale Pins14digitale PWM Pins6analoge Pins6DAC1Spannung an den Pins5 VEingangsspannung6-24 Vmax. Stromaufnahme per Pin8 mAFeaturesWiFi, Bluetooth Low Energy (BLE), 12 x 8 LED Matrix (rot)Abmessungen (LxB)68,85 mm x 53,34 mm Besonders cool finde ich die 12x8 LED Matrix, auf welcher wir recht einfach Debug-Ausgaben ausgeben können und somit auf ein zusätzliches Display verzichten könnten.

Arduino UNO R4: Nur im offiziellen Arduino Store erhältlich!

Ich freue mich, bekannt zu geben, dass die beiden Mikrocontroller exklusiv im offiziellen Arduino Store erhältlich sind. Um meine eigenen zu erhalten, habe ich sie dort bestellt und war angenehm überrascht von der moderaten Lieferzeit von knapp 10 Tagen. Angesichts der Tatsache, dass diese beiden Mikrocontroller gerade erst veröffentlicht wurden, war dies keine Überraschung. Wenn du auch in den Genuss dieser bahnbrechenden Technologie kommen möchtest, schau einfach im Arduino Store vorbei und sichere dir deine eigenen Exemplare. Hier sind die direkten Links: - https://store.arduino.cc/products/uno-r4-minima, - https://store.arduino.cc/products/uno-r4-wifi

Lieferumfang der Mikrocontroller

Zum Lieferumfang der Mikrocontroller gehört eine kleine, transparente Adapterplatte sowie einen Satz Aufkleber und ein Garantiezettel.

Was fehlt, ist ein USB-Typ-C Datenkabel. Jedoch sollte dieses fast jeder zu Hause haben.

Verbinden und Einrichten der Mikrocontroller am Windows-PC

Nun gehen wir dazu über, die beiden Mikrocontroller mit dem PC zu verbinden. Obwohl keine geeigneten USB-C Datenkabel im Lieferumfang enthalten sind, sollten diese bei einem Entwickler für Mikrocontroller problemlos verfügbar sein. Sobald ich den Mikrocontroller Arduino UNO R4 Minima an meinen Microsoft Windows 10 PC angeschlossen habe, wurde dieser als "Santiago" erkannt und als serielle Geräte eingebunden.

Der Arduino UNO R4 WiFi wurde als "UNO WiFi R4" erkannt und ebenso als serielles Gerät in dem Gerätemanager eingerichtet.

In der Arduino IDE 2.0 werden beide Mikrocontroller jedoch korrekt angezeigt und somit könnte man beide Mikrocontroller an einem PC verwenden und erkennt, welchen man gerade bespielen würde.

Ausblick

Und das ist erst der Anfang! In den kommenden Tagen werde ich jedem der beiden Mikrocontroller - dem Arduino UNO R4 mit WiFi und der Minima-Version - jeweils einen eigenen Beitrag widmen. Dort werde ich detailliert darauf eingehen, wie du sie in der Arduino IDE programmieren kannst. Du kannst gespannt sein auf jede Menge Code-Beispiele, Tipps und Tricks. Also bleib dran und lass uns gemeinsam in die faszinierende Welt der Programmierung mit dem Arduino UNO R4 eintauchen! Read the full article

[draegerit]

Schneller, stärker, drahtloser: Der Vergleich von Arduino UNO R4 WiFi und R3

Willkommen zu meinem umfassenden Überblick über den brandneuen Arduino UNO R4 WiFi! In diesem Beitrag werfen wir einen detaillierten Blick auf diesen leistungsstarken Mikrocontroller und vergleichen ihn mit seinem betagten Vorgänger, dem Arduino UNO R3 aus dem Jahr 2003. Ich werde dir nicht nur alles über die spannenden Features des Arduino UNO R4 WiFi erzählen, sondern zeige dir auch praktische Beispiele zur Programmierung des verbauten ESP32 Chips und der beeindruckenden 12x8 LED Matrix in der Arduino IDE. Tauche mit mir ein in die Welt der modernen Mikrocontroller und entdecke, wie der Arduino UNO R4 WiFi deine Projekte auf ein ganz neues Level bringen kann. Los geht's!

Arduino UNO R3

Arduino UNO R4 WiFi

Überblick über den Arduino UNO R3

Kommen wir zunächst zum betagten Arduino UNO R3, welcher im Jahr 2003 veröffentlicht wurde. Die erste Version des Arduino UNO kam sogar zunächst mit einer 9poligen RS232 Schnittstelle daher. Um den Arduino UNO R3 hat sich eine große und wie ich finde großartige Community gebildet, welche coole Projekte, Sensoren, Aktoren und Shields erstellt haben. Mit den Jahren kamen dann noch weitere Mikrocontroller dazu wie der Arduino Nano, Leonardo, Micro etc.

Vorstellung des Arduino UNO R4 WiFi

Tauche ein in die faszinierende Welt des Arduino UNO R4 WiFi! Dieser neue Mikrocontroller bewahrt den beliebten UNO Formfaktor und 5 V Betriebsspannung des Vorgängers, UNO R3. Doch der R4 WiFi bietet noch viel mehr!

Mit erweiterter Speicherkapazität und schnellerem Taktsignal ermöglicht er präzisere Berechnungen und die mühelose Umsetzung komplexer Projekte. Du wirst begeistert sein von der verbesserten Leistungsfähigkeit, die dir neue Möglichkeiten eröffnet. Zudem führt der R4 WiFi neue Onboard-Peripheriegeräte wie einen 12-Bit DAC, CAN-Bus und Operationsverstärker ein, die erweiterte Funktionen und Gestaltungsmöglichkeiten bieten. Jetzt kannst du noch anspruchsvollere Projekte realisieren und deine Kreativität voll ausleben. Mit seiner WLAN- und Bluetooth-Unterstützung durch das ESP32-S3-Modul ermöglicht er drahtlose Konnektivität für deine Projekte. Du kannst deine Ideen problemlos vernetzen und drahtlos steuern. Und das ist noch nicht alles! Der R4 WiFi verfügt über eine Qwiic I2C-Schnittstelle für einfache Verbindungen zu Komponenten aus dem Qwiic-Ökosystem. Mit nur wenigen Handgriffen kannst du eine Vielzahl von Sensoren und Aktoren in deine Projekte integrieren. Du kannst den R4 WiFi sogar mit einer LED-Matrix für Animationen oder zur Visualisierung von Sensordaten nutzen. Die leuchtstarke 12x8-Matrix ermöglicht dir eindrucksvolle visuelle Effekte und spart dir zusätzliche Hardware.

Vergleich der technischen Spezifikationen

In der folgenden Tabelle findest du einen detaillierten Vergleich der technischen Daten zwischen dem Arduino UNO R4 WiFi und dem Arduino UNO R3. Diese Übersicht gibt dir einen klaren Überblick über die Unterschiede und Gemeinsamkeiten der beiden Mikrocontroller.

Von den Mikrocontrollern über die Kommunikationsschnittstellen bis hin zu zusätzlichen Features - diese Tabelle hilft dir dabei, die richtige Wahl für dein Projekt zu treffen. Schau dir die Daten genau an und entdecke, welcher Mikrocontroller am besten zu deinen Anforderungen passt. Technische DatenArduino UNO R4 WiFiArduino UNO R3MikrocontrollerRenesas RA4M1 (Arm Cortex-M4)Microchip ATmega328PUSBUSB-Typ-CUSB-Typ-Bdigitale I/O Pins1414analoge Eingänge66DAC1-PWM Pins66SchnittstellenUART (1x), I2C (1x), SPI (1x), CAN (1x)UART (1x), I2C (1x), SPI (1x)Spannung am I/O Pin5V5VEingangsspannung (VIN)6-24V6-20VTaktgeschwindigkeit48MHz16MHzFlash Speicher256 KB32 KBRAM32 KB2 KBZusätzliche FeaturesWiFi und Bluetooth-

Leistungsunterschiede: CPU und Speicher

Ein bedeutender Leistungsunterschied zwischen dem Arduino UNO R4 WiFi und dem Arduino UNO R3 liegt in der CPU und dem verfügbaren Speicher. Während der Arduino UNO R3 ein 8-Bit-System mit 2 KB RAM nutzt, setzt der Arduino UNO R4 WiFi auf eine leistungsstarke 32-Bit-CPU und bietet sowohl 256 KB Flash-Speicher als auch 32 KB RAM. Der Arduino UNO R3 mit seinen 16 MHz Taktfrequenz bietet solide Leistung für viele Anwendungen. Allerdings kann der begrenzte Speicher von nur 32 KB zu Herausforderungen führen, da Entwickler ihren Quellcode sorgfältig optimieren müssen, um den verfügbaren Speicher effizient zu nutzen. Der Arduino UNO R4 WiFi hingegen bietet nicht nur den Vorteil einer 32-Bit-CPU für verbesserte Leistung und präzisere Berechnungen, sondern auch einen erweiterten Speicher. Mit 256 KB Flash-Speicher steht mehr Platz für den Quellcode zur Verfügung, was die Umsetzung komplexerer Projekte erleichtert. Zusätzlich bietet der R4 WiFi 32 KB RAM, um größere Datenmengen effizienter zu verarbeiten. Die Kombination aus einer 32-Bit-CPU und einem größeren Speicher im Arduino UNO R4 WiFi eröffnet Entwicklern neue Möglichkeiten zur Realisierung anspruchsvoller Projekte, ohne sich so stark auf die Optimierung des Speicherbedarfs konzentrieren zu müssen. Insgesamt bietet der Mikrocontroller mit seiner 32-Bit-CPU und dem erweiterten Speicher eine deutliche Leistungssteigerung im Vergleich zum Arduino UNO R3. Dies ermöglicht eine effizientere Entwicklung von anspruchsvollen Projekten und eröffnet neue Perspektiven für kreative Ideen.

Drahtlose Konnektivität: WLAN-Funktionen des UNO R4 WiFi

Der Arduino UNO R4 WiFi ist mit einem leistungsstarken ESP32 S3 ausgestattet, der eine Taktfrequenz von bis zu 240 MHz und einen beeindruckenden 512 kB SRAM bietet. Mit dieser Kombination können wir noch mehr Power aus dem Mikrocontroller herausholen und anspruchsvollere Projekte realisieren.

ESP32-S3-MINI-1 Chip vom Arduino UNO R4 WiFi Es gibt zwar bereits Mikrocontroller im UNO-Formfaktor mit einem ESP32, wie z.B. den Keyestudio ESP32 Plus oder den AZ-Delivery ESP32, die ich bereits auf diesem Blog vorgestellt habe. Aber der Arduino UNO R4 WiFi hat seinen eigenen Charme und bietet zusätzliche Features.

Keyestudio ESP32 Plus

AZ-Delivery D1 ESP32 Um die WiFi-Schnittstelle des UNO R4 WiFi zu programmieren, zeige ich dir in einem speziellen Beispiel, welches ich gesondert veröffentlichen werde. Mit der drahtlosen Konnektivität des Arduino UNO R4 WiFi stehen dir unzählige Möglichkeiten offen. Du kannst drahtlos auf Daten zugreifen, Fernsteuerungen realisieren und sogar IoT-Projekte umsetzen.

Anwendungsbeispiele und Projektmöglichkeiten für beide Modelle

Mit der eingebauten WiFi-Schnittstelle bietet der Arduino UNO R4 eine breite Palette an Anwendungsmöglichkeiten. Du kannst einfache Aktoren schalten oder sogar große IoT-Projekte realisieren, die über ein Dashboard in der Arduino Cloud visualisiert werden können. Der Arduino UNO R3 hat sich besonders in der Lehre zur Mikrocontroller-Programmierung bewährt. Auch ich habe bereits einige Schulungen zur Programmierung von Mikrocontrollern durchgeführt und dabei den Arduino UNO R3 (sowie seinen kleinen Bruder, den Arduino Nano V3) eingesetzt. Hier sind einige bereits veröffentlichte Beiträge zu Arduino-Projekten, die ich verfasst habe und die den Arduino UNO R3 vorstellen: - Arduino Grundkurs im Jugendfreizeitzentrum Schöningen - Arduino Workshop #2 2019: OTTO DIY im JFZ Schöningen - Weihnachtsevent 2019 im JFZ Schöningen – „Löten eines Weihnachtsbaums mit Sound“ Der Arduino UNO R4 WiFi bietet eine Vielzahl von Projektideen, wie z.B. eine Wetterstation, die Daten in der Arduino Cloud speichert, oder ein Webradio. Die Liste der möglichen Projekte für den Arduino UNO R3 kann in diesem Beitrag nicht abschließend aufgeführt werden. Bei einer Google-Suche nach "Arduino UNO R3 Projekte für Anfänger" erhält man beispielsweise 13,6 Millionen Ergebnisse.

Suchergebnisse für "Arduino UNO R3 Projekte für Anfänger"

Preisvergleich und Verfügbarkeit

Der Arduino UNO R4 WiFi sowie der UNO R3 sind im offiziellen Shop von Arduino.cc erhältlich. Derzeit (Stand: 07.07.2023) wird der UNO R4 WiFi für 25 € und der UNO R3 für 24 € zzgl. Versandkosten angeboten. Wenn du jedoch den asiatischen Markt erkundest, zum Beispiel auf Websites wie aliexpress.com oder banggood.com, findest du Angebote für Klone des UNO R3, die weit unter 5 € kosten. - Offizieller Shop von Arduino.cc - Arduino UNO R4 WiFi für 25 €, - Arduino Uno Rev3 für 24 €, - Alternative Bezugsquellen für den UNO R3 - ebay.de ab 8 €, - amazon.de ab 9 €, - aliexpress.com ab 2,56 € Es ist jedoch zu beachten, dass die Lieferzeiten aus dem offiziellen Arduino Shop mit knapp 2 Wochen recht lang sein können. Dies könnte darauf zurückzuführen sein, dass der UNO R4 WiFi ein relativ neuer Mikrocontroller auf dem Markt ist.

Fazit: Welcher Mikrocontroller ist der richtige für dich?

Der UNO R4 WiFi hat mich persönlich durch seine beeindruckenden Features, insbesondere die eingebaute WiFi-Schnittstelle, begeistert. Diese eröffnet eine Fülle von Möglichkeiten und inspiriert zu neuen Ideen. Da der UNO R4 WiFi laut Hersteller zu 100 % kompatibel mit dem Vorgängermodell ist, kann er problemlos den UNO R3 in bestehenden oder alten Projekten ersetzen. Für zukünftige Projekte würde ich sogar eher zum UNO R4 WiFi oder sogar zum UNO R4 Minima tendieren, um von den zusätzlichen Funktionen und der verbesserten Leistung zu profitieren. Read the full article