#ArduinoUNOR4WiFi

[draegerit]

Einfache DIY-IoT-Lösung: Shelly DUO Lampe mit Arduino steuern

In diesem Beitrag zeige ich dir, wie du mit dem Arduino Plug and Make Kit eine vielseitige DIY-IoT-Lösung umsetzen kannst. Am Beispiel einer Shelly DUO Lampe lernst du, smarte Geräte über externe Komponenten wie Taster, Sensoren oder Potentiometer zu steuern. Dabei erfährst du, wie du REST-Schnittstellen mit dem Arduino nutzen kannst – eine Methode, die sich leicht auf zahlreiche andere Projekte und Geräte übertragen lässt. https://youtu.be/4ZAafdWfUwE Zum Arduino Plug and Make Kit habe ich dir bereits einige Beiträge veröffentlicht und auch gezeigt, wie einfach es ist, mit diesem Kit in die Welt der Mikrocontrollerprogrammierung einzutauchen. - Arduino Plug and Make Kit: Richtungsanzeige mit Modulino Movement - Arduino Plug and Make Kit: Abstandskontrolle mit Alarmfunktion - Einsteigerprojekt: Pixel Chaser mit dem Arduino Plug and Make Kit - Arduino Plug and Make Kit: Was ist drin und wie benutzt man es?

6 Achsen Lagesensor via Qwiic Schnittstelle am Arduino UNO R4 WiFi

Arduino Plug and Make Kit - Komponenten für das Alarmprojekt

Schaltung - Pixel Chaser am Arduino Plug and Make Kit Für diesen Beitrag verwende ich die Shelly DUO Lampe, die in zwei Varianten erhältlich ist: eine einfache Version mit Funktionen zur Helligkeits- und Farbintensitätssteuerung, wie ich sie verwende, und eine RGB-Version, bei der auch die Farbe individuell eingestellt werden kann.

Ziel dieses IoT-Projektes

Das Ziel dieses Projektes ist es aufzuzeigen, wie man ein smartes Gerät wie die Shelly DUO Lampe vom Arduino aus steuern kann. Dabei verwende ich den Arduino UNO R4 WiFi welcher über einen ESP32-S3 Chip verfügt, welcher diesem Mikrocontroller die Bluetooth und auch WiFi Features hinzufügt.

Arduino UNO R4 WiFi

Arduino UNO R4 WiFi

Lieferumfang - Arduino UNO R4 WiFi Alternativ kannst du dieses auch über die Arduino Cloud lösen, dann kannst du diese über ein Dashboard steuern, dazu kommt aber ein separater Beitrag.

Was wird für dieses IoT Projekt benötigt?

Wenn du dieses IoT-Projekt nachbauen möchtest, dann benötigst du: - einen Arduino Plug and Make Kit* - ein USB-Typ-C Datenkabel* - eine Shelly DUO* Lampe - ein E26 Sockel** - eine 2Adrige Zuleitung**

Sensoren & Aktoren 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! ** Der E26 Sockel sowie die Zuleitung, bekommst du im örtlichen Baumarkt sehr günstig und daher kann ich dir hier keinen günstigen Link zum kauf anbieten.

Aufbau der Schaltung

Die Schaltung am Arduino ist recht einfach, ich verwende hier wie erwähnt das Arduino Plug and Make Kit. Dieses Kit enthält alles, was du auf der Seite des Arduino benötigst. Die Shelly DUO Lampe benötigt hier lediglich einen E26 Sockel, welche wir einzeln im Baumarkt erhalten und über eine 2Adrige Zuleitung mit Strom versorgt wird.

Arduino & Shelly DUO Lampe

Schaltung mit dem Arduino Plug and Make Kit Durch die Qwiic Schnittstelle am Arduino UNO R4 WiFi ist der Aufbau sehr einfach. Die Aktoren in der Schaltung werden hintereinander mit den entsprechenden Kabeln angeschlossen und via I2C programmiert.

Regeln der Shelly DUO Lampe über den Arduino

Starten wir nun und regeln zunächst die Shelly DUO Lampe über den Arduino (später werde ich dir zeigen wie dieses über die Arduino Cloud abläuft). Die smarten Geräte von Shelly bieten hierzu eine kleine REST Schnittstelle, welche wir bedienen können. Das Coole daran, wir benötigen hier keine Authentifizierung, solange wir im selben Netzwerk sind und keine gesetzt sind. (Über die Shelly-Cloud können wir auch von außen darauf zugreifen, dieses ist jedoch nicht Bestandteil von diesem Beitrag.) Auf der Seite UNO R4 WiFi Network Examples finden wir eine sehr ausführliche Dokumentation wie man am Arduino UNO R4 WiFi eine Http Anfrage absendet, jedoch war dieses für die Verbindung zum Shelly nicht möglich. Ich habe nach einigem experimentieren mit der Bibliothek vom GitHub Repositiory arduino-libraries/ArduinoHttpClient erfolgreich geschafft die Lampe zu steuern. Das fertige Programm zum regeln einer Shelly DUO Lampe via Arduino UNO R4 WiFi findest du nachfolgend als ZIP-Datei zum download. Programm: regeln einer Shelly DUO Lampe am Arduino UNO R4 WiFiHerunterladen Schritt 1 - REST Schnittstelle der Shelly DUO Lampe ansprechen Bevor wir vom Arduino die HTTP Anfragen absenden können, müssen wir diese erst einmal ermitteln. In der offiziellen API-Dokumentation der Shelly DUO Lampe (https://shelly-api-docs.shelly.cloud/gen1/#shelly-duo) finden sich die URLs, mit denen die Lampe direkt über den Browser gesteuert werden kann. - den Status der Lampe auslesen > http:///status - eine Eigenschaft setzen > http:///light/0? - turn - on / off - brightness - setzen der Helligkeit von 0 bis 100 - temp - setzen der Temperatur der Lampe von 2700 Kelvin bis 6500 Kelvin Beispiele Auslesen des Status der Shelly DUO Lampe Die Adresse zum Auslesen des Status der Shelly DUO Lampe ist http://192.168.178.195/status, die Ausgabe ist im JSON-Format. In der Ausgabe können wir diverse Schlüssel / Werte paare ablesen, wo wir die derzeitige Konfiguration und den Zustand auslesen können. Im Grund interessiert uns hier lediglich der Abschnit "lights", dort finden wir, ob diese aktiviert ist (ison) welche Helligkeit (brightness) sowie Farbtemperatur (temp) gesetzt ist. "lights": , Aktivieren / Deaktivieren der Lampe Die Lampe lässt sich durch eine Adresse aus dem Browser aktivieren und deaktivieren, dazu nutzen wir die Adresse http://192.168.178.195/light/0 und hängen den Parameter turn mit dem Wert off für AUS bzw. on für AN. Als Antwort erhalten wir ebenso ein JSON mit dem neuen Zustand der Lampe.

Setzen mehrerer Werte über einen HTTP Request Wie das aktivieren / deaktivieren können wir die Farbtemperatur (Parameter temp) und die Helligkeit (Parameter brightness) ebenso über die Adresse setzen. Dazu verketten wir in der Adresse die Parameter mit einem & Symbol.

Aufruf - HTTP Request Shelly DUO Lampe Ein Problem beim Absenden von mehreren Werten mit einer HTTP Anfrage ist, dass im Fehlerfall ein Text analysiert werden muss. Das macht das ganze bei der Programmierung etwas aufwändiger, daher sende ich im späteren Programm die Eigenschaften einzeln ab und werte die Antwort aus. Schritt 2 - Aufbau einer WiFi Verbindung am Arduino UNO R4 WiFi Damit wir eine HTTP Anfrage an die Shelly Lampe senden können, müssen wir uns im selben WiFi Netzwerk befinden. Dazu bauen wir diese erst einmal auf. #include "WiFiS3.h" #define WIFI_SSID "abc" #define WIFI_PWD "123" int status = WL_IDLE_STATUS; void setup() { Serial.begin(115200); Serial.print("Aufbau der Verbindung zu: "); Serial.println(WIFI_SSID); while (status != WL_CONNECTED) { status = WiFi.begin(WIFI_SSID, WIFI_PWD); Serial.print("."); delay(500); } Serial.println(); Serial.print("Verbindung erfolgreich zu "); Serial.print(WIFI_SSID); Serial.println(" aufgebaut!"); Serial.print("IP-Adresse: "); Serial.println(WiFi.localIP()); } void loop(){} Schritt 3 - Absenden einer HTTP Anfrage an die Shelly DUO Lampe vom Arduino Für das Absenden einer HTTP Anfrage vom Arduino UNO R4 WiFi verwende ich die Bibliothek ArduinoHttpClient welche wir über den Bibliotheksverwalter installieren können. Dazu öffnen wir den Bibliotheksverwalter (1) und suchen zunächst nach "ArduinoHttp" aus den Suchergebnissen wählen wir die Schaltfläche INSTALLIEREN (3) am Eintrag "ArduinoHttpClient von Arduino".

Abfragen des Status der Shelly DUO Lampe Starten wir zunächst mit einer einfachen Anfrage an die Shelly Lampe, um den Status abzufragen. Dazu rufen wir via HTTP GET die Adresse /status auf. #include #include "WiFiS3.h" #define WIFI_SSID "abc" #define WIFI_PWD "123" char serverAddress = "192.168.178.195"; WiFiClient wifi; HttpClient client = HttpClient(wifi, serverAddress, 80); int status = WL_IDLE_STATUS; void setup() { Serial.begin(115200); Serial.print("Aufbau der Verbindung zu: "); Serial.println(WIFI_SSID); while (status != WL_CONNECTED) { status = WiFi.begin(WIFI_SSID, WIFI_PWD); Serial.print("."); delay(500); } Serial.println(); Serial.print("Verbindung erfolgreich zu "); Serial.print(WIFI_SSID); Serial.println(" aufgebaut!"); Serial.print("IP-Adresse: "); Serial.println(WiFi.localIP()); readShellyDuoStatus(); } void readShellyDuoStatus() { if (WiFi.status() == WL_CONNECTED) { client.get("/status"); printHttpResponse(); } } int printHttpResponse() { int statusCode = client.responseStatusCode(); Serial.print("HttpStatus Code: "); Serial.println(statusCode); if (statusCode == 200) { String response = client.responseBody(); Serial.print("Antwort: "); Serial.println(response); } client.stop(); return statusCode; } void loop() {} Die Ausgabe des Status im JSON-Format erfolgt beim obigen Code auf der seriellen Schnittstelle. Von diesem können wir nachfolgende Status / Wert ablesen: - den Verbindungsstatus - die IP-Adresse, sowie - die Antwort

Setzen einer Eigenschaft an der Shelly DUO Lampe Die Shelly DUO Lampe benötigt einige Sekunden, bis der neue Wert umgesetzt wird. Daher ist das Regeln der Helligkeit / Farbtemperatur über den Rotary Encoder etwas stockend. Für das Setzen einer Eigenschaft wie Helligkeit und Farbtemperatur rufen wir die Adresse http:///light/0 mit dem jeweiligen Parameter auf. Dabei musst du auf den jeweiligen Gültigkeitsbereich der Werte achten. min. Wertmax. WertHelligkeit0100Temperatur27006500Weiß0100 Der Weißwert leitet sich von der Temperatur ab und beide Werte heben sich ggf. auf, daher empfehle ich dir nur einen von diesen zu verwenden! Beispiel - setzen der Helligkeit Die Adresse zum setzen der Helligkeit wäre beispielsweise http://192.168.178.195/light/0?brightness=50. #include #include "WiFiS3.h" #define WIFI_SSID "abc" #define WIFI_PWD "123" char serverAddress = "192.168.178.195"; WiFiClient wifi; HttpClient client = HttpClient(wifi, serverAddress, 80); int status = WL_IDLE_STATUS; void setup() { Serial.begin(115200); Serial.print("Aufbau der Verbindung zu: "); Serial.println(WIFI_SSID); while (status != WL_CONNECTED) { status = WiFi.begin(WIFI_SSID, WIFI_PWD); Serial.print("."); delay(500); } Serial.println(); Serial.print("Verbindung erfolgreich zu "); Serial.print(WIFI_SSID); Serial.println(" aufgebaut!"); Serial.print("IP-Adresse: "); Serial.println(WiFi.localIP()); readShellyDuoStatus(); sendHttpRequest("/light/0?brightness=", String(50, DEC)); } void readShellyDuoStatus() { sendHttpRequest("/status", ""); } bool sendHttpRequest(String url, String param) { int connectStatus = client.connect(serverAddress, 80); Serial.println(connectStatus); client.get(url + param); return printHttpResponse() == 200; } int printHttpResponse() { int statusCode = client.responseStatusCode(); Serial.print("HttpStatus Code: "); Serial.println(statusCode); if (statusCode == 200) { String response = client.responseBody(); Serial.print("Antwort: "); Serial.println(response); } client.stop(); return statusCode; } void loop() {} Die Antwort von diesem REST-Call ist wieder ein JSON (in der Grafik mit Gelb markiert) aus welchem wir den Status der Lampe (ison) und die Helligkeit (brightness) ablesen können.

Antwort von der Shelly DUO Lampe beim setzen einer Helligkeit über REST-Call Im nächsten Schritt möchte ich dir zeigen wie du diese Antwort parsed und auswertest. Schritt 4 - Parsen des JSON-Response von der Shelly DUO Lampe am Arduino Die Antwort von der Shelly Lampe im JSON-Format können wir mit wenigen Zeilen Code mit der ArduinoJson Bibliothek parsen. Diese Bibliothek ist unter https://arduinojson.org/ sehr gut beschrieben und dokumentiert. Wenn man den Status abruft ist der JSON-Response sehr komplex und enthält alle Daten zu der Lampe: {"wifi_sta":{"connected":true,"ssid":"FRITZBox7590GI24","ip":"192.168.178.195","rssi":-83},"cloud":{"enabled":true,"connected":true},"mqtt":{"connected":false},"time":"13:14","unixtime":1735733673,"serial":56,"has_update":false,"mac":"08F9E07058FD","cfg_changed_cnt":0,"actions_stats":{"skipped":0},"lights":,"meters":,"total":0}],"update":{"status":"idle","has_update":false,"new_version":"20230913-111821/v1.14.0-gcb84623","old_version":"20230913-111821/v1.14.0-gcb84623","beta_version":"20231107-162700/v1.14.1-rc1-g0617c15"},"ram_total":52128,"ram_free":40396,"fs_size":233681,"fs_free":163150,"uptime":2142} Die Antwort beim setzen einer Eigenschaft jedoch entfält lediglich die Werte für die Helligkeit, Farbtemperatur sowie den Weißwert und ob diese Lampe eingeschaltet ist oder eben nicht. {"ison":true,"source":"http","has_timer":false,"timer_started":0,"timer_duration":0,"timer_remaining":0,"brightness":50,"white":100,"temp":6500,"transition":0} Beispiel - parsen einer Antwort beim setzen einer Eigenschaft Über einen Online jsonformatter wie https://jsonformatter.curiousconcept.com/# kann man diese Antwort formatieren lassen und so besser die Schlüssel/Werte Paare ablesen. Wenn man sich die Antwort bzw. Read the full article

[draegerit]

Regentropfen-Jagd: Ein einfaches Arduino-Spiel

Wie du das kleine Spiel "Fange den Regentropfen" am Arduino UNO R4 WiFi programmierst, zeige ich dir hier in diesem neuen Beitrag. Die Idee zu dem Spiel kommt von einem Makerspace, welche dieses für den Calliope Mini umgesetzt haben. https://youtu.be/2SOcPtQ0PkY Um das Spiel aufzubauen, brauchst du neben dem Arduino UNO R4 WiFi noch zwei Taster. Falls du das Arduino Plug and Make Kit besitzt, kannst du das Spiel auch damit umsetzen. Ich werde dir beide Optionen vorstellen, damit du das Projekt unabhängig davon, ob du das Kit hast oder nicht, nachbauen kannst.

Benötigte Ressourcen für dieses Projekt

Das kleine Projekt am Arduino benötigt nicht viele Bauteile: - einen Arduino UNO R4 WiFi, - ein USB-Typ-C Datenkabel, - ein Modulino Buttonshield, - ein Modulino Buzzer, - ein Qwiic Kabel

Bauteile - "Fang den Regentropfen" am Arduino Plug and Make Kit

Alternativ kannst du das kleine Spiel auch mit zwei Taster aufbauen und programmieren, dann benötigst du: - zwei Taster*, - zwei 10 kOhm Widerstände*, - ein Piezo Buzzer*, - diverse Breadboardkabel*, - ein 400 Pin Breadboard* 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!

Aufbau der kleinen Schaltung mit dem Arduino Plug and Make Kit

Der leichteste Weg, das Spiel aufzubauen, gelingt mit dem Arduino Plug and Make Kit, da es bereits alle benötigten Komponenten enthält. Zwar ist das Kit nicht ganz billig, aber es bietet die Möglichkeit, viele weitere Projekte und Spiele zu realisieren. Aus meiner Sicht lohnt sich die Investition daher definitiv. Für dieses kleine Spiel müssen wir lediglich das Button Modulino Shield mit einem Qwiic Kabel mit dem Mikrocontroller verbinden. Mit den Schrauben wird das kleine Modul auf der Modulino Base geschraubt und somit sind wir auch schon fertig mit dem Aufbau.

Das Qwiic Kabel hat eine bestimmte Form, sodass dieses nur in eine bestimmte Richtung in die Buchse gesteckt werden kann, sollte es also etwas schwierig gehen, so prüfe dieses zunächst.

Programmieren des Spieles in der Arduino IDE

Für das Programmieren des Spieles verwende ich wie in den Beiträgen zuvor die Arduino IDE. Hier musst du so weit noch nicht geschehen, den Boardtreiber für den UNO R4 und die Bibliothek für die Modulinos installieren.

Für die LED Matrix benötigen wir noch zusätzlich eine Bibliothek, welche ebenso über den Bibliotheksverwalter samt Abhängigkeiten installieren. Das kleine, fertige Spiel kannst du dir nachfolgend als ZIP-Datei herunterladen. Spiel - "Fang den Regentropfen" mit dem Arduino Plug and Make KitHerunterladen //Bibliothek zum steuern der LED Matrix #include "Arduino_LED_Matrix.h" //Bibliothek zum Kommunizieren mit den Modulinos #include //einbinden der externen Datei animation.h //diese Datei enthält die Smileys für die //LED Matrix #include "animation.h" //Mehrdimensionales Array welches die LED Matrix //wiederspiegelt. uint8_t grid = { { 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, 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 }, }; //Objektinstanzen ArduinoLEDMatrix matrix; ModulinoButtons buttons; ModulinoBuzzer buzzer; //Index der Tasten A & C const int BUTTON_A = 0; const int BUTTON_C = 2; //Felder zum speichern der Koordinaten //eines Regentropfen int raindropXPos = 0; int raindropYPos = 0; //Felder zum speichern der Koordinaten //der Leiste zum fangen des Regentropfen //die XPos ist fest und könnte ebenso als //Konstante gesetzt werden int barXPos = 7; int barYPos = 6; //Geschwindigkeit der Regentropfen //bzw. Pause zwischen den Wechsel der LEDs const int DEFAULT_SPEED = 400; int speed = DEFAULT_SPEED; //Frequenzen für die Töne const int FREQ_TICK = 400; const int FREQ_BAR_MOVE = 200; //Feld zum speichern der letzten Ausführung //des Wechsels der LED long lastAction = -1; //Die Funktion setup wird beim starten und neustarten ausgeführt. void setup() { //beginn mit der Kommunikation mit der LED Matrix matrix.begin(); //beginn der Kommunikation mit den Modulinos Modulino.begin(); buzzer.begin(); buttons.begin(); //die kleinen SMD LEDs an den Tastern A & C //aktivieren buttons.setLeds(true, false, true); //eine Zufallszahl generieren und dem Feld zuweisen raindropYPos = generateRandomNumber(); //aktivieren der Leiste zum fangen des Regentropfens grid = 1; } //Funktion zum bewegen eines Regentropfens void moveRaindrop() { //am Buzzer einen Ton für 75ms. ausgeben buzzer.tone(FREQ_TICK, 75); //Wenn die X-Koordinate größer 0 ist dann den //letzten tropfen löschen if (raindropXPos > 0) { grid = 0; } //aktivieren der LED an der neuen Koordinate grid = 1; //absenden des Arrays und anzeigen der LEDs matrix.renderBitmap(grid, 8, 12); //Wenn die X-Koordinate gleich sieben ist, //dann ist die Runde zuende if (raindropXPos == 7) { //prüfen ob die Y-Position der Leiste mit //der Y-Position des Regentropfens übereinstimmt if (raindropYPos == barYPos) { //anzeigen eines glücklichen Smileys matrix.loadFrame(happy); //Geschwindigkeit erhöhen speed -= 25; } else { //Wenn die Koordinaten nicht übereinstimmen, dann... //anzeigen eines traurigen Smileys matrix.loadFrame(sad); //zurücksetzen der Geschwindigkeit speed = DEFAULT_SPEED; } //eine Pause von 600ms. delay(600); //Zurücksetzen der Felder grid = 0; grid = 1; raindropXPos = 0; //erzeugen einer neuen Zufallszahl raindropYPos = generateRandomNumber(); //anzeigen der LEDs matrix.renderBitmap(grid, 8, 12); } } //Funktion zum erzeugen einer Zufallszahl //zwischen 0 und 7 int generateRandomNumber() { randomSeed(analogRead(0)); return random(8); } //Die Funktion loop wird dauerhaft ausgeführt, bis //der Mikrocontroller keine Strom mehr hat, oder //auf einen Fehler trifft. void loop() { //auslesen der vergangenen Millisekunden seit dem Starten //des Mikrocontrollers long currentMillis = millis(); //prüfen ob eine Ausführung erfolgen soll if (currentMillis > (lastAction + speed)) { //speichern des Zeitpunkts der neuen Ausführung lastAction = currentMillis; //die X-Koordinate des Regentropfens um eins erhöhen raindropXPos += 1; //Funktion zum bewegen des Regentropfens ausführen moveRaindrop(); } //Aktualisieren des Buttons Objektes if (buttons.update()) { //Feld zum speichern ob eine Taste betätigt wurde bool btnPress = false; //Wenn der Taster A gedrückt wurde, dann... if (buttons.isPressed(BUTTON_A)) { //die letzt Koordinate löschen / zurücksetzen grid = 0; //Wenn die Y-Position größer 0 ist, dann.. if (barYPos > 0) { //den Wert um eins verringern barYPos -= 1; } //Feld auf Wahr / True setzen btnPress = true; } else if (buttons.isPressed(BUTTON_C)) { //Wenn der Taster C gedrückt wurde, dann... //die letzt Koordinate löschen / zurücksetzen grid = 0; //Wenn die Y-Position kleiner als 11 ist, dann... if (barYPos < 11) { //die Y-Position um eins erhöhen barYPos += 1; } //Feld auf Wahr / True setzen btnPress = true; } //Wenn ein Taster betätigt wurde, dann... if (btnPress) { //ausgeben eines Tones wenn die Taste betätigt wurde buzzer.tone(FREQ_BAR_MOVE, 75); //aktivieren der neuen Position im Array grid = 1; //absenden der Daten und anzeigen der LEDs matrix.renderBitmap(grid, 8, 12); } } } Die beiden Smileys habe ich in die Datei animations.h ausgelagert, dieses wirkt lediglich das der eigentliche Quellcode nicht unnötig länger wird. const uint32_t happy = { 0x31831, 0x80000404, 0x42081f0, 66 }; const uint32_t sad = { 0x31831, 0x80000001, 0xf0208404, 66 };

Alternativer Aufbau & Programmierung mit Taster am Arduino

Wenn du das Arduino Plug and Make Kit nicht hast, aber trotzdem das kleine Spiel nachbauen möchtest, dann zeige ich dir hier nun den Aufbau und die Programmierung mit einfachen Komponenten. Aufbau der Schaltung Die Schaltung am Arduino UNO R4 WiFi ist mit den beiden Tastern auch recht schnell erledigt. Du kannst diese entweder mit einem PullUp oder PullDown Widerstand anschließen, oder du lässt diesen ganz weg und schaltest den Taster via Code über den internen 10kOhm Widerstand von der MCU.

Schaltung - Arduino mit Taster & Buzzer Der Piezo Buzzer muss an einen PWM Pin des Arduinos angeschlossen werden, diese sind am Board mit einer kleinen Welle / Tilde gekennzeichnet. Prüfen der Schaltung mit einem kleinen Programm Bevor wir in die Programmierung einsteigen, sollten wir prüfen, ob die Schaltung funktioniert und wir die Signale der Taster erfolgreich auswerten können. Dazu schreiben wir ein kleines Programm, welches die Status der Taster prüft und wenn einer betätigt ist, dieses auf der seriellen Schnittstelle ausgibt. //Taster Links am digitalen Pin D3 angeschlossen #define buttonLeft 3 //Taster Rechts am digitalen Pin D2 angeschlossen #define buttonRight 2 //Buzzer am digitalen PWM Pin D5 angeschlossen #define buzzer 5 void setup() { //beginn der seriellen Kommunikation mit 9600 baud Serial.begin(9600); //definieren das die Pins der Taster als Eingang dienen pinMode(buttonLeft, INPUT); pinMode(buttonRight, INPUT); //definieren das der Pin des Buzzers als Ausgang dient pinMode(buzzer, OUTPUT); } void loop() { //Wenn einer der Taster betätigt wird, dann //ist das Signal am digitalen Pin auf HIGH. //Wenn der Linke Taster betätigt wird, dann... if (digitalRead(buttonLeft) == HIGH) { Serial.println("Taster Links betätigt!"); //ausgeben eines hellen Tones für 100ms. tone(buzzer, 600, 100); } else if (digitalRead(buttonRight) == HIGH) { //Wenn der Rechte Taster betätigt wird, dann... Serial.println("Taster Rechts betätigt!"); //ausgeben eines tiefen Tones für 100ms. tone(buzzer, 300, 100); } } Im seriellen Monitor der Arduino IDE siehst du, dass mehrere Signale verarbeitet werden, obwohl wir nur einmal auf den Taster gedrückt haben, dieses nennt man prellen und kann recht einfach unterbunden werden. Wie man einen Taster am Arduino entprellt habe ich dir im Beitrag Arduino Lektion 87: Taster entprellen ausführlich erläutert. Programmieren in der Arduino IDE Für die Programmierung in der Arduino IDE benötigen wir neben dem Boardtreiber für den UNO R4 WiFi und Bibliothek für die LED Matrix noch Bounce2. Über Bounce2 können wir recht einfach die verbundenen Taster entprellen.

Wie man einen Taster entprellt habe ich dir bereits im Beitrag Arduino Lektion 87: Taster entprellen ausführlich erläutert. Nachfolgend der Link zum Download des fertiges Programmes als ZIP-Datei. Programm - Arduino UNO R4 WiFi - Fang den RegentropfenHerunterladen //Bibliothek zum steuern der LED Matrix #include "Arduino_LED_Matrix.h" //Bibliothek zum entprellen eines Tasters #include //einbinden der externen Datei animation.h //diese Datei enthält die Smileys für die //LED Matrix #include "animation.h" //Taster Links am digitalen Pin D3 angeschlossen #define buttonLeftPin 3 //Taster Rechts am digitalen Pin D2 angeschlossen #define buttonRightPin 2 //Buzzer am digitalen PWM Pin D5 angeschlossen #define buzzer 5 //Mehrdimensionales Array welches die LED Matrix //wiederspiegelt. uint8_t grid = { { 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, 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 }, }; //Objektinstanz erstellen ArduinoLEDMatrix matrix; Bounce btnLeft = Bounce(); Bounce btnRight = Bounce(); //Index der Tasten A & C const int BUTTON_A = 0; const int BUTTON_C = 2; //Felder zum speichern der Koordinaten //eines Regentropfen int raindropXPos = 0; int raindropYPos = 0; //Felder zum speichern der Koordinaten //der Leiste zum fangen des Regentropfen //die XPos ist fest und könnte ebenso als //Konstante gesetzt werden int barXPos = 7; int barYPos = 6; //Geschwindigkeit der Regentropfen //bzw. Pause zwischen den Wechsel der LEDs const int DEFAULT_SPEED = 400; int speed = DEFAULT_SPEED; //Frequenzen für die Töne const int FREQ_TICK = 400; const int FREQ_BAR_MOVE = 200; //Feld zum speichern der letzten Ausführung //des Wechsels der LED long lastAction = -1; //Die Funktion setup wird beim starten und neustarten ausgeführt. void setup() { //beginn mit der Kommunikation mit der LED Matrix matrix.begin(); //definieren das die Pins der Taster als Eingang dienen //und verbinden mit den Tasterobjekten btnLeft.attach(buttonLeftPin, INPUT); //Interval zum entprellen auf 5ms. setzen btnLeft.interval(5); btnRight.attach(buttonRightPin, INPUT); btnRight.interval(5); //definieren das der Pin des Buzzers als Ausgang dient pinMode(buzzer, OUTPUT); //eine Zufallszahl generieren und dem Feld zuweisen raindropYPos = generateRandomNumber(); //aktivieren der Leiste zum fangen des Regentropfens grid = 1; } //Funktion zum bewegen eines Regentropfens void moveRaindrop() { //am Buzzer einen Ton für 75ms. ausgeben tone(buzzer, FREQ_TICK, 75); //Wenn die X-Koordinate größer 0 ist dann den //letzten tropfen löschen if (raindropXPos > 0) { grid = 0; } //aktivieren der LED an der neuen Koordinate grid = 1; //absenden des Arrays und anzeigen der LEDs matrix.renderBitmap(grid, 8, 12); //Wenn die X-Koordinate gleich sieben ist, //dann ist die Runde zuende if (raindropXPos == 7) { //prüfen ob die Y-Position der Leiste mit //der Y-Position des Regentropfens übereinstimmt if (raindropYPos == barYPos) { //anzeigen eines glücklichen Smileys matrix.loadFrame(happy); //Geschwindigkeit erhöhen speed -= 25; } else { //Wenn die Koordinaten nicht übereinstimmen, dann... //anzeigen eines traurigen Smileys matrix.loadFrame(sad); //zurücksetzen der Geschwindigkeit speed = DEFAULT_SPEED; } //eine Pause von 600ms. delay(600); //Zurücksetzen der Felder grid = 0; grid = 1; raindropXPos = 0; //erzeugen einer neuen Zufallszahl raindropYPos = generateRandomNumber(); //anzeigen der LEDs matrix.renderBitmap(grid, 8, 12); } } //Funktion zum erzeugen einer Zufallszahl //zwischen 0 und 7 int generateRandomNumber() { randomSeed( Read the full article

[draegerit]

Einsteigerprojekt: Pixel Chaser mit dem Arduino Plug and Make Kit

Ein kleines weiteres Einsteigerprojekt mit dem Arduino Plug and Make Kit ist Pixel Chaser. Du findest in diesem Kit alles, was du für den Aufbau des Spieles benötigst. https://youtu.be/VGD7f0Pg320 Für den Aufbau des Spieles benötigst du: - einen Arduino UNO R4 WiFi, - ein USB-Typ-C Datenkabel - ein Buzzer Modul, - ein 8fach LED Modul, - ein 3fach Taster Modul, - drei Qwiic Anschlusskabel All diese Komponenten sind im Kit enthalten.

Wie funktioniert das Spiel - Pixel Chaser?

Im Spiel "Pixel Chaser" sind acht LEDs in einer Linie angeordnet. Zu Beginn des Spiels wird eine der LEDs zufällig als Ziel ausgewählt und leuchtet rot auf. Eine andere LED bewegt sich kontinuierlich von links nach rechts und zurück entlang der Linie. Der Spieler muss den richtigen Moment abpassen und die Taste A drücken, um die bewegende LED anzuhalten. Ziel ist es, die laufende LED genau über der roten LED zu stoppen. Wenn der Spieler erfolgreich ist, erscheint ein lachender Smiley auf dem Display des Arduino UNO R4 WiFi, und ein positiver Ton wird abgespielt. Außerdem erhöht sich die Geschwindigkeit der laufenden LED, was das Spiel schwieriger macht. Verfehlt der Spieler das Ziel, wird ein trauriger Smiley angezeigt, begleitet von einem tiefen Ton. Danach beginnt das Spiel von vorne, und die Geschwindigkeit der LED wird auf den Anfangswert zurückgesetzt.

Aufbau der Schaltung - Pixel Chaser mit dem Arduino Plug and Make Kit

Der Aufbau des kleinen Einsteigerprojektes ist in drei wenigen Schritten erledigt. Da die Module über eine eindeutige Adresse verfügen kannst du diese auf der Modulino Base beliebig anordnen, du musst dich also nicht zu 100 % an diese Anleitung halten. Wichtig ist lediglich, dass diese mit dem Qwiic Kabel miteinander zum Arduino UNO R4 WiFi verbunden sind.

An den Modulino ist jeweils eine kleine, grüne SMD LED, diese sollte aufleuchten, sobald dein Mikrocontroller Strom bekommt. Dieses kannst du als Indikator nutzen, dass die Modulinos korrekt angeschlossen sind.

Programmieren in der Arduino IDE

Wie du die Modulinos des Arduino Plug and Make Kit in der Arduino IDE programmierst, habe ich dir bereits im ersten Beitrag Arduino Plug and Make Kit: Was ist drin und wie benutzt man es? gezeigt. Durch die I2C Adresse und der sehr einfachen Bibliothek ist die Programmierung besonders für Anfänger geeignet und mit wenig Codezeilen kann man schon beträchtliche Ergebnisse erzielen. Für die Programmierung der Modulinos benötigst du die Bibliothek Modulino welche du über den Bibliotheksverwalter der Arduino IDE installieren kannst.

Nachfolgend das fertige Programm zum Download als ZIP-Datei. PixelChaserHerunterladen Schritt 1 - Importieren der benötigten Bibliotheken Im ersten _Schritt müssen wir die benötigten Bibliotheken dem Code hinzufügen. //Bibliothek zum ansteuern der Modulinos des //Arduino Plug and Make Kit #include //Bibliothek zum ansteuern der LED Matrix des //Arduino UNO R4 WiFi #include "ArduinoGraphics.h" #include "Arduino_LED_Matrix.h" Schritt 2 - Anlegen der Smileys für neutral, gewinn und verloren Die Smileys kannst du auf zwei Wege erstellen, zum einen erstellst du dir ein mehrdimensionales Array mit 8x12 Felder oder du nutzt ganz bequem den LED Matrix Editor von Arduino. Über diesen Editor kannst du mit der Maus dir ein entsprechendes Smiley zeichnen und dir den Code mit der Schaltfläche "" oben rechts herunterladen.

const uint32_t happy = { 0x31831, 0x80000404, 0x42081f0, 66 }; const uint32_t sad = { 0x31831, 0x80000001, 0xf0208404, 66 }; const uint32_t neutral = { 0x31831, 0x80000001, 0xf0000000, 66 }; Damit die Arrays den Code nicht unnötig lang machen, lagere ich diese in eine externe Datei "animation.h" aus und greife aus dem Code dann darauf zu. //Einbinden der Datei "animation.h" mit den //Smileys #include "animation.h" Schritt 3 - Aufleuchten einer zufälligen LED Um einen zufälligen Wert zwischen 0 und 8 (ohne die 8 selbst) zu erzeugen, benutze ich die Funktion random mit dem Parameterwert 8. Da die Range jedoch nur sehr gering ist, kann und wird es vorkommen, dass dieselbe Zahl mehrmals hintereinander kommen kann, daher packe ich den Code in eine While-Schleife und prüfe / handle dieses dort. int catchPixelIndex = -1; void activateRandomPixel() { ... int lastCatchPixelIndex = catchPixelIndex; while (lastCatchPixelIndex == catchPixelIndex) { randomSeed(analogRead(0)); catchPixelIndex = random(8); } ... } Schritt 4 - erzeugen eines Lauflichts Das Lauflicht auf dem 8fach LED-Modul bewegt sich von links nach rechts und wieder zurück. Mit jeder abgeschlossenen Runde erhöht sich die Geschwindigkeit. Bei einer Niederlage wird die Geschwindigkeit jedoch wieder auf den Ausgangswert zurückgesetzt. In diesem Fall wird die Pause im Lauflicht nicht durch den Aufruf der Funktion delay umgesetzt, sondern durch eine Überprüfung, ob die Zeit seit der letzten Aktion die festgelegte Pausenzeit überschritten hat. Wie dieses im Detail funktioniert, habe ich dir bereits im Beitrag Arduino: Ein Sketch ohne delay(ms) schreiben erläutert. int runningPixel = -1; int speed = 350; long lastAction = -1; bool movePixelReverse = false; void loop() { long currentMillis = millis(); if (currentMillis > (lastAction + speed)) { lastAction = currentMillis; movePixel(); } ... } void movePixel() { leds.set(runningPixel, BLUE, 0); if (!movePixelReverse) { if (runningPixel < 8) { runningPixel += 1; } else { runningPixel -= 1; movePixelReverse = true; } } else { if (runningPixel > 0) { runningPixel -= 1; } else { runningPixel += 1; movePixelReverse = false; } } leds.set(runningPixel, BLUE, BRIGHTNESS); leds.show(); leds.set(catchPixelIndex, RED, BRIGHTNESS); leds.show(); } Schritt 5 - Abfragen des Tasters In der loop können wir nun bequem den Taster auslesen und reagieren, wenn dieser gedrückt wurde. Wenn beide Pixel übereinanderliegen, dann gilt dieses als Gewinn und es wird ein hoher Ton ausgegeben sowie ein lachender Smiley, zusätzlich wird die Geschwindigkeit des Lauflichtes erhöht, indem die Pause zwischen den Schritten um 25ms. verringert wird. Sollte jedoch der Spieler nicht gewinnen, so wird ein trauriger Smiley angezeigt und ein tiefer Ton ausgeben. Die Geschwindigkeit des Lauflichtes wird wieder auf die Anfangsgeschwindigkeit gesetzt. const int BUTTON_A = 0; void testBtn() { if (buttons.update()) { if (buttons.isPressed(BUTTON_A)) { if (runningPixel == catchPixelIndex) { buzzer.tone(FREQ_WIN, 750); matrix.loadFrame(happy); speed -= 25; } else { buzzer.tone(FREQ_LOOSE, 750); matrix.loadFrame(sad); speed = DEFAULT_SPEED; } delay(600); matrix.loadFrame(neutral); activateRandomPixel(); } } } Das fertige Programm Hier nun das fertige Programm mit allen Kommentaren zum Quellcode. //Bibliothek zum ansteuern der Modulinos des //Arduino Plug and Make Kit #include //Bibliothek zum ansteuern der LED Matrix des //Arduino UNO R4 WiFi #include "ArduinoGraphics.h" #include "Arduino_LED_Matrix.h" //Einbinden der Datei "animation.h" mit den //Smileys #include "animation.h" //Objektinstanz der LED Matrix ArduinoLEDMatrix matrix; //Objektinstanzen der Modulinos ModulinoBuzzer buzzer; ModulinoPixels leds; ModulinoButtons buttons; //Feld zum speichern des Indexes //des Pixels welches angeklickt werden soll. int catchPixelIndex = -1; //Feld zum speichern des aktuellen aktiven //Pixels im Lauflicht int runningPixel = -1; //Konstante für die identifikation der Taste "A" const int BUTTON_A = 0; //Konstante für die Helligkeit der LEDs const int BRIGHTNESS = 20; //Konstanten für die Töne const int FREQ_WIN = 1200; const int FREQ_LOOSE = 400; //Konstante für die Standardgeschwindigkeit //des Lauflichts const int DEFAULT_SPEED = 350; //aktuelle Geschwindigkeit des Lauflichts int speed = DEFAULT_SPEED; //Feld zum speichern der letzten Ausführung des Lauflichts long lastAction = -1; //Feld zum speichern der Richtung des Lauflichts bool movePixelReverse = false; void setup() { //beginn der Kommunikation mit der LED Matrix des //Arduino UNO R4 WiFi matrix.begin(); //beginn der Kommunikation mit den Modulinos Modulino.begin(); //Initialisieren der I2C Kommunikation mit den //Modulino Sensoren/Aktoren buzzer.begin(); leds.begin(); buttons.begin(); //am Taster Modul lediglich die LED am //Taster "A" aktivieren. buttons.setLeds(true, false, false); //initial einen zufälligen Pixel aktivieren activateRandomPixel(); //auf der LED Matrix ein neutrales Smiley anzeigen matrix.loadFrame(neutral); } //Funktion zum aktivieren eines zufälligen Pixels //an dem 8fach LED Modul. void activateRandomPixel() { //Wenn bereits ein Pixel gesetzt ist dann,... if (catchPixelIndex > -1) { //setzen der Helligkeit auf 0, damit wird, //die LED deaktiviert leds.set(catchPixelIndex, RED, 0); } //ermitteln einer neuen Zufallszahl, //da bei einer Range von 0 bis 7 es vorkommen kann //das mehrmals der gleiche Wert ermittelt wird, //prüft die Schleife dieses und gibt bei //einem Unterschied eine neue Zahl zurück. int lastCatchPixelIndex = catchPixelIndex; while (lastCatchPixelIndex == catchPixelIndex) { randomSeed(analogRead(0)); catchPixelIndex = random(8); } //aktivieren des neuen Pixels leds.set(catchPixelIndex, RED, BRIGHTNESS); //anzeigen des neuen Pixels und löschen des alten leds.show(); } //Funktion zum prüfen und behandeln eines Tastendrucks am //Button Modulino void handleButton() { //aktualisieren des Moduls if (buttons.update()) { //Wenn der Taster "A" betätigt wurde, dann... if (buttons.isPressed(BUTTON_A)) { //prüfen ob der aktuelle Pixel vom Lauflicht dem //Pixel welches gefangen werden soll entspricht. //Wenn dieses so ist, dann gilt die Runde als Gewonnen. if (runningPixel == catchPixelIndex) { //einen hellen Ton für die Dauer von 750ms. ausgeben. buzzer.tone(FREQ_WIN, 750); //ein lachenden Smiley anzeigen matrix.loadFrame(happy); //Die Geschwindigkeit des Lauflichts erhöhen. //Der Wert Speed regelt die Pause innerhalb des Lauflichts. speed -= 25; } else { //Wenn diese beiden Pixel nicht übereinander liegen //gilt die Runde als verloren. //Es wird ein tiefer Ton für die dauer von 750ms. ausgegeben. buzzer.tone(FREQ_LOOSE, 750); //Auf der LED Matrix wird ein trauriger Smiley angezeigt. matrix.loadFrame(sad); //Die Geschwindigkeit wird auf die Ausgangsgeschwindigkeit gesetzt. speed = DEFAULT_SPEED; } //Eine Pause von 600ms. //(Damit der Spieler das Smiley sieht.) delay(600); //anschließend das neutrale Smiley anzeigen matrix.loadFrame(neutral); //und eine neue Runde starten activateRandomPixel(); } } } void movePixel() { leds.set(runningPixel, BLUE, 0); if (!movePixelReverse) { if (runningPixel < 8) { runningPixel += 1; } else { runningPixel -= 1; movePixelReverse = true; } } else { if (runningPixel > 0) { runningPixel -= 1; } else { runningPixel += 1; movePixelReverse = false; } } leds.set(runningPixel, BLUE, BRIGHTNESS); leds.show(); leds.set(catchPixelIndex, RED, BRIGHTNESS); leds.show(); } void loop() { long currentMillis = millis(); if (currentMillis > (lastAction + speed)) { lastAction = currentMillis; movePixel(); } handleButton(); } Read the full article

[draegerit]

Arduino Plug and Make Kit: Abstandskontrolle mit Alarmfunktion

In diesem Beitrag erfährst du Schritt-für-Schritt, wie man eine Abstandskontrolle mit Alarmfunktion mit dem Arduino Plug and Make Kit aufbaut und programmiert. Das neue Arduino Plug and Make Kit habe ich dir bereits im gleichnamigen Beitrag Arduino Plug and Make Kit: Was ist drin und wie benutzt man es? vorgestellt. https://youtu.be/YL-enMuAMBc Das Arduino Plug and Make Kit bekommst du derzeit für knapp 90€ inkl. Versandkosten im offiziellen Shop. Aus diesem Kit verwenden wir den Arduino UNO R4 WiFi, den Laser Distanzsensor, den Piezo Buzzer, das 8fach LED Modul sowie den Rotary Encoder. Zusätzlich benötigen wir noch die Modulino Base, ein paar Schrauben & Muttern sowie die Qwiic Anschlusskabel. Das alles ist im Kit enthalten, du benötigst quasis nurnoch deinen PC und einen kleinen Kreuzschraubendreher.

Arduino UNO R4 WiFi

ToF - Distance Sensor

Buzzer

8fach LED Modul

Rotary Encoder

Wie soll das kleine Projekt funktionieren?

Über den Distanzsensor messen wir dauerhaft einen Abstand zu einem Gegenstand (Wand, Türrahmen etc.) wenn dieser Wert unterschritten wird, dann wird ein Alarm (akustisch und visuell) ausgegeben. Über den Rotary Encoder und der 8x12 LED Matrix vom Arduino UNO R4 WiFi stellen wir den Abstand ein. Dabei wird, wenn wir eine Klick-Aktion am Rotary Encoder ausführen, der aktuelle Wert auf der Matrix ausgegeben.

Benötigte Ressourcen für den Aufbau

Für den Aufbau der Schaltung benötigst du: - einen Arduino UNO R4 WiFi, - ein USB-C Datenkabel, - ein ToF / Laser Distanzsensor, - ein Rotary Encoder, - ein 8fach LED Modul, - ein Piezo Buzzer, sowie - ein paar Schrauben und - einen kleinen Kreuzschraubendreher

Arduino Plug and Make Kit - Komponenten für das Alarmprojekt Ausgenommen vom Kreuzschraubendreher ist alles im Arduino Plug and Make Kit enthalten!

Programmieren der Modulino Sensoren / Aktoren in der Ardino IDE

Das Kit ist ausgelegt, um in der Arduino IDE programmiert zu werden. Du musst jedoch zuvor den Boardtreiber für den Arduino UNO R4 WiFi und die Bibliothek für die Modulino Sensoren / Aktoren installieren.

Zu der Bibliothek Modulino erhältst du zu jedem Sensor / Aktor aus diesem Kit ein ausführliches Beispiel und in der offiziellen Dokumentation nochmal viel mehr Informationen. Programm - Durchgangsalarm mit dem Arduino Plug and Make KitHerunterladen Schritt 1 - Importieren der Bibliotheken und erzeugen der Objektinstanzen Im ersten Schritt importieren wir die benötigten Bibliotheken für das Projekt. (Zur Vorbereitung hatten wir bereits die Modulino Bibliothek installiert.) //Bibliothek zum steuern / auslesen //der Modulino Sensoren / Aktoren #include //Bibliotheken zum steuern der //8x12 LED Matrix am Arduino UNO R4 WiFi #include "ArduinoGraphics.h" #include "Arduino_LED_Matrix.h" Anschließend erzeugen wir uns die Objektinstanzen für unser Projekt. //Objektinstanz der LED-Matrix ArduinoLEDMatrix matrix; //Objektinstanzen der Sensoren / Aktoren ModulinoDistance distance; ModulinoPixels leds; ModulinoKnob knob; ModulinoBuzzer buzzer; Schritt 2 - Initialisieren der Kommunikation mit den Sensoren / Aktoren Nachdem die benötigten Bibliotheken installiert und die Objekte erzeugt wurden, müssen wir die I2C Kommunikation starten. Dazu müssen wir bei den Modulinos lediglich die Funktion "begin" aufrufen. Dieses macht die verwendung dieser Module sehr einfach und komfortabel. void setup() { //beginn der seriellen Kommunikation Serial.begin(9600); //beginn der Kommunikation mit der LED-Matrix matrix.begin(); //Vorbereiten der Kommunikation mit den Modulino //Sensoren / Aktoren Modulino.begin(); //Initialisieren der I2C Kommunikation mit den //Sensoren / Aktoren distance.begin(); leds.begin(); knob.begin(); buzzer.begin(); //Startwert des Rotary Encoders / Knob auf 0 setzen. knob.set(0); } Zusätzlich setze ich den Wert des Rotary Encoders auf 0. Schritt 3 - Auslesen der Sensorwerte und erzeugen des Alarms Im dritten Schritt lesen wir in der Funktion "loop" zunächst den Wert des Rotary Encoders aus und multiplizieren diesen mit 10. Damit müssen wir nicht so viele Umdrehungen machen damit ein Abstand eingestellt werden kann, wenn du kleine Schritte benötigst dann musst du diesen Wert anpassen. //lesen des aktuellen Wertes vom Rotary Encoder //der Wert wird mit 10 multipliziert und abgespeichert int16_t distanceForAlarm = knob.get() * 10; Wenn der Rotary Encoder gedrückt wird, können wir eine zusätzliche Aktion ausführen, in diesem Fall wird der Wert auf der 8x12 LED Matrix angezeigt. //Wenn der Rotary Encoder gedrückt wird, dann... if (knob.isPressed()) { //Aufrufen der Funktion zum Anzeigen des aktuellen //wertes des Rotary Encoder. displayKnobValue(distanceForAlarm); } Wenn der Distanzsensor erkannt wurde, dann lesen wir einen Messwert und vergleichen diesen mit dem eingestellten Abstand vom Rotary Encoder. if (distance.available()) { //Messwert abrufen und abspeichern int measure = distance.get(); //Wenn der messwert kleiner als der abgespeicherte //Wert für den Alarm ist, dann... if (measure < distanceForAlarm) { //Ausgeben des Textes "Alarm" auf der seriellen Schnittstelle Serial.println("Alarm"); //anzeigen eines visuellen Alarms über das 8fach LED Modul visualAlarm(); //ausgeben eines akustischen Alarms über das Piezo Buzzer Modul soundAlarm(); } } Am Ende legen wir noch eine kleine Pause von 20 Millisekunden ein. //eine kleine Pause von 20 ms. delay(20); Schritt 3.1 - Funktion "displayKnobValue" Die Funktion displayKnobValue zeigt den Wert des Übergebenen Parameters auf der 8x12 LED Matrix an. Sollte jedoch der Wert kleiner 0 sein, so wird eine Fehlermeldung angezeigt. /Funktion zum anzeigen eines Textes auf der //LED-Matrix. void displayKnobValue(int16_t value) { matrix.beginDraw(); matrix.stroke(0xFFFFFFFF); matrix.textScrollSpeed(50); String message = "-undefined- "; //Wenn der Wert kleiner 0 ist, dann... if (value < 0) { //erzeugen einer kleinen Fehlermeldung message = "err: val < 0"; } else { //Wenn der wert größer 0 ist, dann müssen wir //eine 12 Zeichen lange Zeichenkette erzeugen. int valueLength = String(value).length(); int partLength = (12 - valueLength) / 2; String part = ""; for (int s = 0; s < partLength; s++) { part += " "; } message = part + String(value) + part; } //ablegen der erstellten Zeichenkette in das Char-Array char text = ""; message.toCharArray(text, 13); //Ausgeben des Textes auf der LED-Matrix //Schriftgröße 4x6 matrix.textFont(Font_4x6); matrix.beginText(0, 1, 0xFFFFFF); matrix.println(text); matrix.endText(SCROLL_LEFT); matrix.endDraw(); } Schritt 3.2 - Funktion "visualAlarm" Die Funktion visualAlarm lässt die LEDs im 25ms. Intervall aufleuchten. //Funktion zum erzeugen eines visuellen Alarms mit //dem 8fach LED Modul. Die LEDs blinken im 25ms. Takt void visualAlarm() { setLEDsStatus(true); delay(25); setLEDsStatus(false); delay(25); } //Funktion zum setzen der LEDs. //Als Parameter wird der erwartete Status übergeben. void setLEDsStatus(bool on) { //Schleife über die LEDs for (int i = 0; i < 8; i++) { //Wenn die LEDs aktiviert werden sollen, dann ist //die Helligkeit auf 100 ansonsten auf 0 leds.set(i, RED, on ? 100 : 0); } //nachdem alle LEDs konfiguriert wurden, dann werden //diese Daten ausgeliefert / angezeigt. leds.show(); } Schritt 3.3 - Funktion "soundAlarm" Mit der Funktion soundAlarm wird der Piezo Buzzer angesteuert und dieser erzeugt einen hellen Ton als zusätzlichen Signal. //Funktion zum erzeugen eines Tones auf //dem Piezo Buzzer Moduls. void soundAlarm() { //die Frequenz des Tones int frequency = 440; //die Dauer int duration = 1000; //erzeugen des Tones buzzer.tone(frequency, duration); delay(50); //abschalten des Tones buzzer.tone(0, duration); delay(25); } Fertiges Projekt - Durchgangsalarm mit dem Arduino Plug and Make Kit Hier nun das fertige Projekt zum kopieren. //Bibliothek zum steuern / auslesen //der Modulino Sensoren / Aktoren #include //Bibliotheken zum steuern der //8x12 LED Matrix am Arduino UNO R4 WiFi #include "ArduinoGraphics.h" #include "Arduino_LED_Matrix.h" //Objektinstanz der LED-Matrix ArduinoLEDMatrix matrix; //Objektinstanzen der Sensoren / Aktoren ModulinoDistance distance; ModulinoPixels leds; ModulinoKnob knob; ModulinoBuzzer buzzer; void setup() { //beginn der seriellen Kommunikation Serial.begin(9600); //beginn der Kommunikation mit der LED-Matrix matrix.begin(); //Vorbereiten der Kommunikation mit den Modulino //Sensoren / Aktoren Modulino.begin(); //Initialisieren der I2C Kommunikation mit den //Sensoren / Aktoren distance.begin(); leds.begin(); knob.begin(); buzzer.begin(); //Startwert des Rotary Encoders / Knob auf 0 setzen. knob.set(0); } void loop() { //lesen des aktuellen Wertes vom Rotary Encoder //der Wert wird mit 10 multipliziert und abgespeichert int16_t distanceForAlarm = knob.get() * 10; //Wenn der Rotary Encoder gedrückt wird, dann... if (knob.isPressed()) { //Aufrufen der Funktion zum Anzeigen des aktuellen //wertes des Rotary Encoder. displayKnobValue(distanceForAlarm); } //Wenn ein ToF Sensor verfügbar ist, dann... if (distance.available()) { //Messwert abrufen und abspeichern int measure = distance.get(); //Wenn der messwert kleiner als der abgespeicherte //Wert für den Alarm ist, dann... if (measure < distanceForAlarm) { //Ausgeben des Textes "Alarm" auf der seriellen Schnittstelle Serial.println("Alarm"); //anzeigen eines visuellen Alarms über das 8fach LED Modul visualAlarm(); //ausgeben eines akustischen Alarms über das Piezo Buzzer Modul soundAlarm(); } } //eine kleine Pause von 20 ms. delay(20); } //Funktion zum anzeigen eines Textes auf der //LED-Matrix. void displayKnobValue(int16_t value) { matrix.beginDraw(); matrix.stroke(0xFFFFFFFF); matrix.textScrollSpeed(50); String message = "-undefined- "; //Wenn der Wert kleiner 0 ist, dann... if (value < 0) { //erzeugen einer kleinen Fehlermeldung message = "err: val < 0"; } else { //Wenn der wert größer 0 ist, dann müssen wir //eine 12 Zeichen lange Zeichenkette erzeugen. int valueLength = String(value).length(); int partLength = (12 - valueLength) / 2; String part = ""; for (int s = 0; s < partLength; s++) { part += " "; } message = part + String(value) + part; } //ablegen der erstellten Zeichenkette in das Char-Array char text = ""; message.toCharArray(text, 13); //Ausgeben des Textes auf der LED-Matrix //Schriftgröße 4x6 matrix.textFont(Font_4x6); matrix.beginText(0, 1, 0xFFFFFF); matrix.println(text); matrix.endText(SCROLL_LEFT); matrix.endDraw(); } //Funktion zum erzeugen eines visuellen Alarms mit //dem 8fach LED Modul. Die LEDs blinken im 25ms. Takt void visualAlarm() { setLEDsStatus(true); delay(25); setLEDsStatus(false); delay(25); } //Funktion zum erzeugen eines Tones auf //dem Piezo Buzzer Moduls. void soundAlarm() { //die Frequenz des Tones int frequency = 440; //die Dauer int duration = 1000; //erzeugen des Tones buzzer.tone(frequency, duration); delay(50); //abschalten des Tones buzzer.tone(0, duration); delay(25); } //Funktion zum setzen der LEDs. //Als Parameter wird der erwartete Status übergeben. void setLEDsStatus(bool on) { //Schleife über die LEDs for (int i = 0; i < 8; i++) { //Wenn die LEDs aktiviert werden sollen, dann ist //die Helligkeit auf 100 ansonsten auf 0 leds.set(i, RED, on ? 100 : 0); } //nachdem alle LEDs konfiguriert wurden, dann werden //diese Daten ausgeliefert / angezeigt. leds.show(); } Read the full article

[draegerit]

Arduino Plug and Make Kit: Was ist drin und wie benutzt man es?

Es gibt von Arduino ganz neu das Arduino Plug and Make Kit, dieses enthält alles, was du für den Start in die Mikrocontrollerprogrammierung benötigst. Was in diesem Kit enthalten ist und wie du die Sensoren & Aktoren am mitgelieferten Arduino UNO R4 WiFi programmierst, erfährst du in den nächsten Abschnitten hier im Beitrag. https://youtu.be/B0mXN7ADJeg

Was ist im Arduino Plug and Make Kit drin?

Das Kit enthält neben einem Arduino UNO R4 WiFi nachfolgende Sensoren & Aktoren: - einen Rotary Encoder (mit Push Funktion) - einen Piezo Buzzer - ein Modul mit 3 Taster - ein Temperatur & rel. Luftfeuchtigkeits-Sensor - ein Distanzsensor Typ VL53L4CD - ein Modul mit 8 RGB LEDs - einen 6-Achsen Lagesensor Zusätzlich findest du am Arduino UNO R4 WiFi noch: - eine 8x12 LED Matrix (in rot), - einen ESP32-S3-Mini

6 Achsen Sensor

3fach Taster Modul

Buzzer

Rotary Encoder

Temperatur & rel. Luftfeuchtigkeits Sensor

8fach LED Modul

ToF - Distance Sensor

Zusätzlich findest du noch eine Modulino Base, auf welche du den Mikrocontroller und deine Schaltung mit den Sensoren & Aktoren aufschrauben kannst. Das sorgt dafür, dass deine Schaltung auf dem Schreibtisch nicht wild umherfliegt. Es ist dafür alles enthalten, du benötigst hier nur noch einen kleinen Kreuzschraubendreher (Größe PH0) und einen Maulschlüssel (Schlüsselweite 5,5). Die Sensoren werden über eine I2C Qwiic Schnittstelle mit dem Mikrocontroller verbunden und daher enthält das Kit zusätzlich noch einige Anschlusskabel.

Einrichten des Arduino UNO R4 WiFi in der Arduino IDE

Dem Kit liegt wie gezeigt ein Arduino UNO R4 WiFi bei, dieser ebenso neue Mikrocontroller verfügt über eine WiFi & Bluetooth Schnittstelle sowie eine LED Matrix schon allein damit könnte man viele Wochenenden verbringen und IoT Projekte umsetzen.

Bevor wir mit den ersten Schaltungen beginnen, richten wir diesen in der Arduino IDE ein, dieses ist bei der Version 2.x besonders einfach geworden.

Aufbau einer Schaltung

Zunächst möchte ich eine kleine Schaltung mit dem 8fach LED Modul sowie dem Rotary Encoder aufbauen. Über den Rotary Encoder kann man zum Beispiel die Geschwindigkeit eines Lauflichts oder die Helligkeit der LEDs steuern. Zusätzlich verfügt der Rotary Encoder noch über ein Tast-Event welches wir ebenso verwenden können, um die Farbe zu wechseln.

Arduino Plug and Make Kit - Schaltung mit 3fach LED Modul & Knob Die Sensoren & Aktoren am Arduino UNO R4 WiFi werden über die Qwiic Schnittstelle verbunden. Das Gute an dieser Schnittstelle ist, dass du die Module kaskadierend hintereinander verbinden kannst. (Im Bild siehst du zwei Module, welche miteinander verbunden sind.)

Programmieren der Sensoren / Aktoren in der Arduino IDE

Damit wir die Module in der Arduino IDE programmieren können, benötigen wir eine zusätzliche Bibliothek. Diese lässt sich über den internen Bibliotheksverwalter mit wenigen Klicks installieren. Zunächst wählst du den Bibliotheksverwalter (1) und suchst dort nach "modulino" (2). Du solltest nun die Schaltfläche "INSTALLIEREN" an der Position 3 finden.

Ich werde jedem Modul im Kit einen separaten Beitrag & Video widmen, hier möchte ich dir nachfolgend an zwei Beispielen zeigen, wie diese programmiert werden. Auf der Seite https://courses.arduino.cc/plugandmake/ findest du viele coole Beispiele zu diesem Kit und der Arduino Cloud. Beispiel 1 - Programmieren der LEDs Am 8fach RGB LED Modul kannst du jede LED in diversen Farben anzeigen. Ebenso kannst du dort kleine Leuchteffekte für ein Lauflicht oder Fading programmieren. Ebenso kannst du über dieses auch die Werte des Distanz-Sensors oder Temperatursensors visualisieren.

gesetzte Farben an dem 8fach LED Modul Programm - anzeigen verschiedener Farben auf dem 8fach LED Modul des Arduino Plug and Make KitHerunterladen //Bibliothek zum steuern / lesen //der Modulino Module #include //Objekt vom Typ ModulinoPixels erzeugen //in diesem Fall das 8fach LED Modul ModulinoPixels leds; //Ablegen von Objekten mit einem RGB-Farbwert ModulinoColor colorBlue(0, 0, 255); ModulinoColor colorRed(255, 0, 0); ModulinoColor colorGreen(0, 255, 0); ModulinoColor colorYellow(255, 255, 0); ModulinoColor colorPurple(128, 0, 128); ModulinoColor colorCyan(0, 255, 255); ModulinoColor colorOlive(128, 128, 0); ModulinoColor colorNavy(0, 0, 128); //Konstante für die Helligkeit der LEDs const int HELLIGKEIT = 10; void setup() { //beginn der I2C Kommunikation Modulino.begin(); //begin der I2C Kommunikation mit dem LED Modul leds.begin(); //setzen der Farbe an der LED //erster Parameter, der Index der LED //zweiter Parameter, die Farbe //dritter Parameter, die Helligkeit leds.set(0, colorBlue, HELLIGKEIT); leds.set(1, colorRed, HELLIGKEIT); leds.set(2, colorGreen, HELLIGKEIT); leds.set(3, colorYellow, HELLIGKEIT); leds.set(4, colorPurple, HELLIGKEIT); leds.set(5, colorCyan, HELLIGKEIT); leds.set(6, colorOlive, HELLIGKEIT); leds.set(7, colorNavy, HELLIGKEIT); //Der Wert für die Helligkeit kann entfallen, //da hier ein Default-Wert von 25 hinterlegt wurde! //Anzeigen der Farben leds.show(); } void loop() { //bleibt leer } Beispiel 2 - steuern eines Lauflichts mit dem Knob Am 8fach LED Modul habe ich ein kleines Lauflicht programmiert, welches mit dem Knob / Rotary Encoder in der Geschwindigkeit gesteuert werden kann. Da der Knob noch zusätzlich über ein Tast-Event verfügt, können wir diesen nutzen, um die Farbe zu wechseln. Programm - steuern eines Lauflichts mit dem Knob am Arduino Plug and Make KitHerunterladen //Bibliothek zum steuern / lesen //der Modulino Module #include //Objekt vom Typ ModulinoPixels erzeugen //in diesem Fall das 8fach LED Modul ModulinoPixels leds; //Objekt vom Typ ModulinoKnob erzeugen //in diesem Fall der Rotary Encoder ModulinoKnob knob; //Ablegen von Objekten mit einem RGB-Farbwert ModulinoColor colorBlue(0, 0, 255); ModulinoColor colorRed(255, 0, 0); ModulinoColor colorGreen(0, 255, 0); //Erzeugen eines Arrays mit den Farben ModulinoColor colors = { colorBlue, colorRed, colorGreen }; //Wert für die Helligkeit const int HELLIGKEIT = 5; //Feld für die Pause, //Der Wert wird aus der Position des Knob //berechnet. int pause = 0; //Aktueller Index für die Farbe int index = 0; //Konstante mit der maximalen Anzahl der Farben. const int MAX_COLORS = 2; void setup() { //beginn der I2C Kommunikation Modulino.begin(); //begin der I2C Kommunikation mit dem LED Modul leds.begin(); //begin der I2C Kommunikation mit dem Rotary Encoder knob.begin(); } //Funktion zum deaktivieren der LEDs void ledsOff(ModulinoColor color) { for (int led = 0; led < 8; led++) { leds.set(led, color, 0); } leds.show(); } //Funktion zum anzeigen einer Farbe void setLEDColor(ModulinoColor color, int index) { leds.set(index, color, HELLIGKEIT); leds.show(); delay(pause); } void loop() { //auslesen der Position vom Knob int position = knob.get(); //berechnen der Pause aus der Position pause = (position > 0 ? position : 1) + 25; //entnehmen der Farbe aus dem Array mit //dem aktuellen Index ModulinoColor color = colors; //Wenn der Knob gedrückt wird, dann... if (knob.isPressed()) { //prüfen ob der aktuelle Index gleich //der maximalen Farbe ist, dann... if (index == MAX_COLORS) { //Wert des Index auf -1 setzen. index = -1; } //erhöhen des Index um 1 index++; } //Schleife über die LEDs //von links nach rechts (von 0 bis 7) for (int led = 0; led < 8; led++) { //setzen der Farbe an der LED setLEDColor(color, led); } //deaktivieren der LEDs ledsOff(color); //Schleife über die LEDs //von rechts nach links (von 7 bis 0) for (int led = 7; led >= 0; led--) { setLEDColor(color, led); } //deaktivieren der LEDs ledsOff(color); } Read the full article

[draegerit]

Arduino UNO R4 WiFi Push-Benachrichtigungen: Verbindung zu Pushbullet per IFTTT erstellen

In diesem Beitrag werde ich dir Schritt für Schritt zeigen, wie du eine Verbindung zwischen deinem Arduino UNO R4 WiFi und Pushbullet über IFTTT herstellen kannst. Das bedeutet, dass du deinem Arduino beibringst, dir eine Nachricht auf dein Smartphone zu schicken, sobald etwas Bestimmtes passiert – sei es das Erreichen einer bestimmten Temperatur, das Auslösen eines Sensors oder etwas ganz anderes.

Aber keine Sorge, du musst kein erfahrener Entwickler sein, um das zu schaffen. Ich werde dir alles haarklein erklären – von der Einrichtung deines Arduino UNO R4 WiFi bis hin zur Erstellung eines IFTTT-Applets, das die Magie geschehen lässt. Also schnapp dir deinen Kaffee (oder deinen Tee) und lass uns loslegen!

Der neue Arduino UNO R4 WiFi im Überblick

Schauen wir uns zunächst den neuen Arduino UNO R4 WiFi kurz an. Dieser neue Mikrocontroller der Arduino Familie kommt mit deutlich mehr Power & Schnittstellen daher: - eine Renesas RA4M1 (Arm Cortex-M4) MCU mit 48 MHz, - 256 KB Flash Speicher und 32 KB RAM, - Unterstützt WiFi & Bluetooth 5.0 Wenn du noch mehr über diesen Mikrocontroller lesen möchtest, dann habe ich dir im Beitrag Schneller, stärker, drahtloser: Der Vergleich von Arduino UNO R4 WiFi und R3 alles über diesen gesondert zusammengetragen.

Was ist der Service IFTTT?

Die Abkürzung IFTTT steht für "If this, than that" und kannst du in einer kostenfreien Version nutzen, um über Schnittstellen mit anderen Services zu kommunizieren. In diesem Beitrag möchte ich diesen Service nutzen um über einen Webhook den Service Pushbullet zu bedienen. Du kannst über IFTTT verschiedene vorkonfigurierte Applets verwenden oder dein eigenes erstellen, beides ist mit wenigen Klicks sehr schnell und vor allem intuitiv erledigt.

Aufbau einer Schaltung und Konfigurieren von IFTTT & Pushbullet am Arduino

Im nachfolgenden YouTube-Video erläutere ich dir, wie du eine Schaltung für das Absenden einer Push-Benachrichtigung am Arduino UNO R4 WiFi absendest. Dabei zeige ich dir im Detail, wie du in IFTTT & Pushbullet vorgehen musst. https://youtu.be/SuuvNOZHqUw

Einrichten eines Kontos in Pushbullet

Bevor wir den Service für Pushbullet in IFTTT verbinden können, müssen wir uns erst einmal ein Konto unter https://www.pushbullet.com/ einrichten. Hier kannst du die mit einem bestehenden Google oder Facebook sehr schnell verbinden. (In meinem Fall habe ich dieses mit meinem Google-Konto getan.)

Webseite Pushbullet

Installieren der App auf dem Handy

Zusätzlich kannst du dir noch eine App für dein Handy herunterladen. Diese bietet dir somit die Möglichkeit deine Push-Benachrichtigungen nicht nur am PC zu empfangen, sondern auch mobil unterwegs. Für die Einrichtung steht ein Wizard bereit, welcher beim ersten Starten der App ausgeführt wird. Hier musst du besonders acht geben, denn die App möchte sehr viele Berechtigungen. In meinem Fall gebe ich keine Berechtigungen für den Zugriff auf meine Kontakte und den SMS Speicher (ich möchte ja lediglich eine Benachrichtigung von meinem Mikrocontroller erhalten).

Wenn die App eingerichtet ist, kannst du zu IFTTT wechseln und den Webhook erstellen. Dabei solltest du dein Handy nicht ganz so weit weglegen, denn du musst dem Service noch die Berechtigung erteilen, mit Pushbullet zu kommunizieren.

Einrichten eines Applets in IFTTT für Pushbullet

Wie du dir ein Konto in IFTTT einrichtest, habe ich dir bereits im Beitrag AZ-Envy – Benachrichtigung per IFTTT versenden erläutert. Hier soll es nun darum gehen, wie du ein Webhook für Pushbullet erstellst. Schritt 1 - Erstellen eines Applets mit Webhook Als Erstes klicken wir auf die Schaltfläche "CREATE" und wählen dann im nächsten Fenster "ADD". Nun müssen wir nach "webhook" suchen und diesen auswählen. Jetzt haben wir die Wahl zwischen einem Webhook mit JsonPayload und einem einfachen Webhook als Request. Wir wählen hier letzteren aus und vergeben diesem einen Namen. Damit ist der Trigger auch fertiggestellt und wir können diese Konfiguration mit "Create trigger" bestätigen.

Webhook mit JsonPayload Es gibt einen speziellen Webhook, mit welchem du zusätzlich ein JSON übergeben kannst. Um jedoch einen Filter zu erstellen, um dieses JSON zu parsen, musst du die bezahlte Version Pro besitzen. Hier möchte ich jedoch darauf eingehen, wie du quasi kostenfrei deine Nachricht benutzerdefiniert aufbauen kannst. Schritt 2 - einbinden von Pushbullet als Aktion Im nächsten Schritt binden wir Pushbullet als Aktion des Applets ein. Hier klicken wir auf die Schaltfläche "ADD" im Bereich "Then That" und suchen im nächsten Fenster nach "Pushbullet". Wir sehen dann, welche Möglichkeiten wir mit Pushbullet haben, wir können eine einfache Nachricht, einen Link, eine Datei sowie einen Ort senden. In unserem Fall möchten wir eine einfache Nachricht senden und wählen somit die Kachel "Push a note" aus. Nun muss dem Service IFTTT die Berechtigung gegeben werden, auf den Account von Pushbullet zuzugreifen. Wenn dieses gegeben ist, können wir abschließend die Nachricht konfigurieren. Hier haben wir die 3 verschiedene Werte welche wir mit eigenen Daten belegen können (value1, value2, value3). Zusätzlich können wir noch den Zeitstempel des Events (OccuredAt) einbinden und den EventName. In meinem Fall nutze ich folgende Maske für meine Nachricht: Nachricht:"{{Value1}}" von " {{Value2}}" um {{OccurredAt}} empfangen. Wenn die Auswahl getroffen wurde, dann bestätigen wir dieses Fenster mit der Schaltfläche "Create action".

Schritt 3 - Fertigstellen des Applets Mit Ende des zweiten Schrittes ist das Applet nun fertiggestellt, nun müssen wir nacheinander auf "Continue" & "Finish" klicken. Im letzten Fenster müssen wir noch sicherstellen, dass der Schieberegler auf "Connected" steht.

Adresse für den Webhook ermitteln Damit wir unseren Webhook benutzen können, müssen wir die Adresse ermitteln. Dazu navigieren wir oben rechts über das Avatarsymbol zu "My services". Dort scrollen wir dann nach unten zu den Link "Webhooks" und klicken im neuen Fenster dann auf "Documentation". Im neuen Fenster sehen wir dann Beispiele inkl. APIKey für unseren erstellten Webhook. Natürlich habe ich meinen ApiKey vor Veröffentlichung des Beitrages gelöscht! Wichtig ist hier, dass der Webhook mit der Methode POST bedient wird!

Testen des Webhooks mit Postman Bevor wir jedoch unser Programm für den Arduino UNO schreiben, testen wir diesen Webhook mit der Anwendung Postman. Dieses nützliche Tool kannst du dir unter https://www.postman.com/downloads/ für Microsoft Windows, macOS und Linux herunterladen. Zunächst fügen wir die Adresse (1) ein (ohne die Parameter), danach setzen wir die Parameter "value1" & "value2" (2) und klicken auf "Send" (3).

Wenn alles geklappt hat, dann erhalten wir die Ausgabe (4). Congratulations! You've fired the simpleMessage event

Aufbauen der Schaltung am Arduino UNO

Bevor wir mit dem Programmieren beginnen, bauen wir fix die Schaltung auf. Ich verwende hier einen Taster für das manuelle und einen Quecksilberschalter für das automatische Absenden eines Requests.

Schaltung - Arduino UNO mit Quecksilberschalter & Taster

Erstellen des Programmes für den Arduino, um eine Push-Benachrichtigung via IFTTT an Pushbullet zu senden

Nun haben wir alle Vorkehrungen geschaffen, um unser Programm für den Arduino UNO zu schreiben. Hier nutze ich das Beispiel "Wi-Fi® Web Client" von https://docs.arduino.cc/tutorials/uno-r4-wifi/wifi-examples als Basis. Zusätzlich binde ich die Bibliothek "UrlEncode" ein, welche mit der Funktion "encodeUrl" eine einfache Möglichkeit bietet, die Parameter zu formatieren. //Bibliotheken zum Aufbau der WiFi-Verbindung #include #include //Bibliothek für das encoding der Parameter #include //Verbindungsdaten zum lokalen WiFi-Netzwerk #define WIFI_SSID "abcd" #define WIFI_PASSWORD "1234" //Taster am digitalen Pin D8 angeschlossen #define taster 8 //Quecksilberschalter am digitalen Pin D2 angeschlossen #define sensor 2 //Der Quecksilberschalter liefert mehrere Signale gleichzeitig, //das würde bedeuten das wir mehrere Push-Benachrichtungen gleichzeitig //erhalten würden. Mit diesen Feldern möchte ich sicherstellen das //nur maximale alle 10 Sekunden eine Nachricht geschickt wird. const int PAUSE_BETWEEN_SENSOR_ACTION = 10000; long lastSensorAction = 0; WiFiClient client; void setup() { //beginn der seriellen Kommunikation mit 9600 baud Serial.begin(9600); //Taster am internen 10 kOhm Pullup Widerstand verbunden pinMode(taster, INPUT_PULLUP); //Pin des Quecksilberschalters als einfachen Eingang definiert pinMode(sensor, INPUT); //Aufbauen der WiFi-Verbindung Serial.print("Verbindungsaufbau zu: "); Serial.println(WIFI_SSID); WiFi.begin(WIFI_SSID, WIFI_PASSWORD); while (WiFi.status() != WL_CONNECTED) { Serial.print("."); delay(500); } IPAddress ip = WiFi.localIP(); Serial.print("IP Address: "); Serial.println(ip); } //Funktion zum absenden eines Requests mit den //Parametern value1 & value2 void sendSimpleHttpMessage(String value1, String value2) { //Wenn eine aktive WiFi-Verbindung existiert, dann... if (WiFi.status() == WL_CONNECTED) { //Adresse des Services char a = "maker.ifttt.com"; //Parameter String getParams = "/trigger/simpleMessage/with/key/{apiKey}?value1=" + urlEncode(value1) + "&value2=" + urlEncode(value2); //Aufbau der Verbindung zum Server über HTTP (Port 80) if (client.connect(a, 80)) { Serial.println("connected to server"); //Absenden der Parameter mit der Methode POST client.println("POST " + getParams + " HTTP/1.1"); client.println("Host: maker.ifttt.com"); client.println("Connection: close"); client.println(); Read the full article

[draegerit]

Arduino UNO R4 WiFi: Programmierung für faszinierende LED-Matrix Effekte

Auf dem neuen Arduino UNO R4 WiFi findest du neben einem ESP32 Chip noch zusätzlich eine 12x8 Matrix mit roten LEDs. Wie du diese LED-Matrix programmierst, möchte ich dir hier in diesem Beitrag ausführlich zeigen.

Den neuen Mikrocontroller habe ich dir bereits im Beitrag Schneller, stärker, drahtloser: Der Vergleich von Arduino UNO R4 WiFi und R3 vorgestellt, hier soll nun speziell um die LED-Matrix gehen. Auf dem Mikrocontroller Arduino UNO R4 WiFi ist vom Hersteller bereits ein kleines Programm installiert, welches auf der LED-Matrix eine kleine Animation anzeigt.

Bibliothek zum Ansteuern der LED-Matrix

Um die LED-Matrix programmieren, zu können, musst du die nachfolgende Bibliothek einbinden: #include "Arduino_LED_Matrix.h" Diese musst du nicht extra installieren, denn diese kommt mit der Installation des Boardtreibers für den Mikrocontroller dazu. Ebenso erhältst du noch zusätzlich ein paar Beispiele in welchen du entnehmen kannst wie zbsp. eine Animation erstellt werden kann.

Beispiele für die LED-Matrix

Online LED-Matrix Editor

Unter https://ledmatrix-editor.arduino.cc/ findest du einen Online LED-Matrix Editor, in welchem du dein Symbol mit der Maus zeichnen und mit einem Klick als Array exportieren kannst.

Aufbau des Arduino LED-Matrix Editor https://youtu.be/P6hkWgOOj1I Erstellen einer Ausgabe von "HALLO!" auf der LED-Matrix Mit dem Online LED-Matrix Editor kannst du dir mit etwas Aufwand einen Lauftext von "HALLO!" erzeugen. Dazu erzeugst du jedes einzelne Frame und dadurch entsteht dieser Text bzw. die Animation eines Lauftextes. Diese Animation kannst du dir über die Schaltfläche "" als Array exportieren und in dein Programm integrieren. Am einfachsten geht es, aber wenn du dir das Beispiel "PlayAnimation.ino" nimmst und dort einfach in Reiter "animation.h" das Array austauscht. Durch diesen kleinen Hack brauchst du keine einzige Zeile Code schreiben und kannst deinen Lauftext auf dem Arduino UNO R4 WiFi direkt hochladen.

Programmieren der LED-Matrix am Arduino UNO R4 WiFi

Du kannst alternativ jedoch auch mit einem mehrdimensionalen Array von 8 Reihen & 12 Spalten jede LED einzeln ansteuern. Das ist zwar etwas komplizierter als über den Online LED-Matrix Editor, jedoch kann man damit ganz andere Dinge bewerkstelligen. #include "Arduino_LED_Matrix.h" //Array mit den Dimensionen der LED Matrix //Es wird der Text "A-Z" angezeigt uint8_t grid_AZ = { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, { 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1 }, { 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1 }, { 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0 }, { 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0 }, { 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0 }, { 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, }; //Es werden die Zahlen "1-9" uint8_t grid_19 = { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0 }, { 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0 }, { 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0 }, { 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0 }, { 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0 }, { 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, }; //initialisieren des Matrix Objektes ArduinoLEDMatrix matrix; void setup() { //beginn der Kommunikation mit der LED Matrix matrix.begin(); } void loop() { //Anzeigen des Textes "A-Z" matrix.renderBitmap(grid_AZ, 8, 12); //eine kleine Pause von 500 Millisekunden delay(500); //Anzeigen des Textes "1-9" matrix.renderBitmap(grid_19, 8, 12); //eine kleine Pause von 500 Millisekunden delay(500); } Der Code bewirkt, dass immer abwechselnd der Text "A-Z" und "1-9" auf der LED Matrix ausgegeben wird. 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

[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