#arduinounor3

[draegerit]

Farbsensor TCS34725 und Arduino: Schritt-für-Schritt-Anleitung

In diesem Beitrag möchte ich dir den kleinen, günstigen Farbsensor TCS34725 vorstellen und zeigen, wie du diesen am Arduino UNO R3 anschließt und programmierst. Im Beitrag Arduino Lektion 60: Sensor für Licht, Farbe und Gesten (APDS-9960) habe ich dir bereits ein multifunktionales Modul vorgestellt, welches ebenso die Farbe erkennen kann. Dieser Sensor stellt jedoch eine günstige Alternative dar, wenn man lediglich das Feature der Farberkennung benötigt. https://youtu.be/WoLlCKWz2ok Der TCS34725 überzeugt durch seine einfache Integration über die I2C-Schnittstelle und die umfangreiche Unterstützung durch Bibliotheken wie die von Adafruit. Mit diesem Sensor lassen sich präzise RGB-Werte und Umgebungslichtdaten messen, was ihn ideal für Projekte wie Farbkalibrierung, Beleuchtungsautomatisierung oder DIY-Roboter macht.

In diesem Beitrag zeige ich dir nicht nur, wie du den Sensor anschließt, sondern auch, wie du die erfassten Farbwerte in deinem Projekt nutzen kannst. Als praktisches Beispiel verbinden wir eine RGB-LED, die die vom Sensor erkannten Farben in Echtzeit darstellt. So kannst du die Farberkennung auf anschauliche Weise erleben.

Bezug des Farbsensors TCS34725

Den hier vorgestellten Farbsensor bekommst du sehr günstig auf den einschlägigen Plattformen. - ebay.de* - ab 2,32 € - aliexpress.com - 2,59 € - amazon.de* - 3 € 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 des Farbsensors

Der Farbsensor verfügt über eine I2C Schnittstelle und kann mit 5 V und 3.3V betrieben werden. Die beiden sehr leuchtstarken LEDs sind dauerhaft aktiv, können aber nach Bedarf über den Pin LED deaktiviert werden.

Aufbau des Farbsensors TCS34725

Anschluss des Farbsensors TCS34725 via I2C an den Arduino

Durch die erwähnte I2C Schnittstelle ist der Anschluss an den Arduino sehr einfach und wir benötigen für diesen lediglich vier Breadboardkabel. Zusätzlich zum Farbsensor wird eine RGB-LED integriert, die die vom Sensor erkannten Farben visuell darstellt.

Für den Aufbau der Schaltung am Arduino benötigst du: - einen Arduino kompatiblen Mikrocontroller - Arduino UNO R3* - Arduino Nano V3* - ein passendes Datenkabel* - diverse Breadboardkabel*, männlich - männlich, 10 cm - ein 170 Pin / 400 Pin Breadboard* - eine RGB LED 5050* 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 des Farbsensors TCS34725 am Arduino UNO R3

Für die Programmierung des Arduino verwende ich die Arduino IDE 2.3.3 welche du unter https://www.arduino.cc/en/software für Windows, macOS und Linux herunterladen kannst. Für das Ansteuern / auslesen des Farbsensors benötigen wir zusätzlich eine Bibliothek, hier gibt es diverse auf dem Markt welche ebenso kostenfrei erhältlich sind. Ich habe mit der Adafruit TCS34725 erfolgreich die Farbe auslesen können und möchte dir diese herzlich empfehlen. Um die Bibliothek zu installieren, musst du links den Bibliotheksverwalter (1) öffnen und dort nach "Adafruit TCS34725" (2) suchen. Im ersten Eintrag wählst du hier die Schaltfläche "INSTALLIEREN" (3). Diese Bibliothek hat eine Abhängigkeit zu Adafruit BusIO welches wir ebenso installieren müssen, daher klicken wir in dem Dialog ebenso auf "ALLE INSTALLIEREN" (4)

Nachfolgend möchte ich dir zeigen, wie du die Farbe auslesen und auf einer RGB LED darstellen kannst. Es wird zunächst nur die Farbe Rot, Grün und Blau dargestellt. // Bibliotheken zur Steuerung und Auslesung des Farbsensors #include #include "Adafruit_TCS34725.h" // Pins, an denen die RGB-LED angeschlossen ist #define red 10 #define green 9 #define blue 11 // Instanziieren eines Objekts vom Typ Adafruit_TCS34725 mit spezifischen Parametern Adafruit_TCS34725 tcs = Adafruit_TCS34725(TCS34725_INTEGRATIONTIME_614MS, TCS34725_GAIN_1X); // Variablen zum Speichern der Farbdaten und Lichtwerte uint16_t r, g, b, c, colorTemp, lux; void setup(void) { // Starten der seriellen Kommunikation mit einer Baudrate von 9600 Serial.begin(9600); // Definieren der LED-Pins als Ausgänge pinMode(red, OUTPUT); pinMode(green, OUTPUT); pinMode(blue, OUTPUT); // Initialisieren der Kommunikation mit dem Farbsensor tcs.begin(); } void loop(void) { // Auslesen der Rohdaten (Rot, Grün, Blau, Klarheit) vom Sensor tcs.getRawData(&r, &g, &b, &c); // Berechnen der Farbtemperatur in Kelvin colorTemp = tcs.calculateColorTemperature_dn40(r, g, b, c); // Berechnen der Beleuchtungsstärke (Lux) lux = tcs.calculateLux(r, g, b); // Berechnen der RGB-Werte für Rot, Grün und Blau basierend auf den Rohdaten byte rgbColorRed = calcColorValue(r, c); byte rgbColorGreen = calcColorValue(g, c); byte rgbColorBlue = calcColorValue(b, c); // Vergleichen der RGB-Werte, um die dominante Farbe zu ermitteln byte maxColor = compareValues(rgbColorRed, rgbColorGreen, rgbColorBlue); // Überprüfen, welche der Farben (Rot, Grün, Blau) dominiert bool isMainColorRed = maxColor == rgbColorRed; bool isMainColorGreen = maxColor == rgbColorGreen; bool isMainColorBlue = maxColor == rgbColorBlue; // Setzen der LED-Farben basierend auf der dominanten Farbe analogWrite(red, isMainColorRed ? 255 : 0); analogWrite(green, isMainColorGreen ? 255 : 0); analogWrite(blue, isMainColorBlue ? 255 : 0); // Ausgabe der Farbtemperatur und Lux-Werte auf der seriellen Schnittstelle Serial.println("Color Temp: " + String(colorTemp, DEC) + " K"); Serial.println("Lux: " + String(lux, DEC)); Serial.println("Rot: " + String(r, DEC)); Serial.println("Grün: " + String(g, DEC)); Serial.println("Blau: " + String(b, DEC)); Serial.println("Klarheit: " + String(c, DEC)); // Ausgabe der berechneten RGB-Werte auf der seriellen Schnittstelle Serial.print("RGB-Wert: (" + String(rgbColorRed, DEC) + "," + String(rgbColorGreen) + "," + String(rgbColorBlue) + ")"); } // Berechnet den RGB-Wert aus einem Farbwert (Rot, Grün oder Blau) und dem Klarheitswert uint16_t calcColorValue(uint16_t color, uint16_t clarityValue) { double rgbColorValue = (double)color / (double)clarityValue; return round(rgbColorValue * 255); } // Vergleicht die RGB-Werte und gibt die dominante Farbe zurück byte compareValues(byte r, byte g, byte b) { if (r > g && r > b) { return r; } else if (g > r && g > b) { return g; } else if (b > r && b > g) { return b; } return 0; } Umrechnen des Farbwertes in RGB Werte Vom Sensor erhalten wir lediglich die Rohdaten für die Farbinformationen um daraus einen RGB Wert zu berechnen nutze ich nachfolgende Formel:

Bedeutung der Variablen: - 255: Die maximale RGB-Wert-Skala, auf die die Werte angepasst werden. - Farbwert (color): Der Rohwert eines Farbkanals (Rot, Grün oder Blau), den der Sensor liefert. - Klarheitswert (clarityValue): Ein Maß für die Gesamtlichtintensität (Summe aller Farben und Helligkeit), um die Farbe zu normalisieren. // Berechnet den RGB-Wert aus einem Farbwert (Rot, Grün oder Blau) und dem Klarheitswert uint16_t calcColorValue(uint16_t color, uint16_t clarityValue) { double rgbColorValue = (double)color / (double)clarityValue; return round(rgbColorValue * 255); } Ermitteln der Farbe (einfache Lösung) Zunächst konzentriere ich mich darauf, die drei Grundfarben Rot, Grün und Blau darzustellen. Dafür verwende ich zu Beginn drei einfarbige Würfel in Rosa, Grün und Blau. Anhand der berechneten RGB-Werte lässt sich die dominante Farbe bestimmen, die dann über die RGB-LED visualisiert wird. // Berechnen der RGB-Werte für Rot, Grün und Blau basierend auf den Rohdaten byte rgbColorRed = calcColorValue(r, c); byte rgbColorGreen = calcColorValue(g, c); byte rgbColorBlue = calcColorValue(b, c); // Vergleichen der RGB-Werte, um die dominante Farbe zu ermitteln byte maxColor = compareValues(rgbColorRed, rgbColorGreen, rgbColorBlue); // Überprüfen, welche der Farben (Rot, Grün, Blau) dominiert bool isMainColorRed = maxColor == rgbColorRed; bool isMainColorGreen = maxColor == rgbColorGreen; bool isMainColorBlue = maxColor == rgbColorBlue; // Setzen der LED-Farben basierend auf der dominanten Farbe analogWrite(red, isMainColorRed ? 255 : 0); analogWrite(green, isMainColorGreen ? 255 : 0); analogWrite(blue, isMainColorBlue ? 255 : 0);

Erweitern der Schaltung um einen Abstandssensor um die LEDs / den Sensor zu aktivieren

Wenn man etwas Stromsparen und ebenso auch den Sensor schonen möchte, dann kann man einen kleinen Abstandssensor in die Schaltung integrieren und so die LEDs und die Messung abhängig davon mach, ob sich ein Gegenstand vor dem Sensor befindet.

Für die Schaltung verwende ich einen Infrarotabstandssensor welcher einen digitalen und analogen Ausgang hat. Da mich lediglich interessiert, ob sich ein Gegenstand vor dem Sensor befindet, verwende ich den digitalen Ausgang, welchen man über einen Drehpotentiometer einstellen kann.

Infrarot Abstandssensor - TCRT5000

Rückseite des Infrarot Abstandssensors Im Code müssen wir recht wenig anpassen, denn der digitale Ausgang wird ähnlich einem Taster abgefragt und wir reagieren wenn dier LOW ist. Sollte der Ausgang HIGH sein so führen wir keine Messung durch und deaktivien ebenso die RGB LED (alle Farbwerte auf 0). #define led 5 #define irSensor 7 void setup(void) { ... pinMode(led, OUTPUT); pinMode(irSensor, INPUT); digitalWrite(led, HIGH); ... } void loop(void) { if (digitalRead(irSensor) == HIGH) { digitalWrite(led, LOW); analogWrite(red, 0); analogWrite(green, 0); analogWrite(blue, 0); return; } digitalWrite(led, HIGH); ... } Read the full article

[dhakarobotics]

Explore the Arduino Uno R3 (CH9102 Drive) – Standard Quality at an Affordable Price in Bangladesh!

Looking for a reliable and budget-friendly microcontroller board? The Arduino Uno R3 with CH9102 drive is the perfect choice for hobbyists, students, and professionals. It offers excellent performance at a price that won’t break the bank.

Why Choose the Arduino Uno R3?

-CH9102 Drive: Ensures smooth and stable USB communication, making your programming experience hassle-free.

-Standard Quality: Built to meet industry standards, offering reliable performance for all your projects.

-

Affordable: Get top-notch quality at an unbeatable price, making it accessible for everyone.

Now available in Bangladesh! Start your electronics journey with the Arduino Uno R3 and bring your ideas to life.

Click here to purchase the product: https://dhakarobotics.com/.../1006-arduino-uno-r3.../

Contact Us: +8801740298319

visit our website: https://dhakarobotics.com/

[alinagentry90]

 Make LED Circuit In Tinkercad 

Free live Session to learn how to make LED Circuit In Tinkercad. Let's learn to make LED Circuity with us Live!! .

Youtube link - https://www.youtube.com/live/pvX_QSH5C5M?feature=share

[jualarduinomurah-blog]

jual arduino terpercaya...

#arduino #arduinouno #arduinounooriginal #arduinounor3starterkit #arduinounor3 #tutorialarduino #arduinounosmd #arduinounodatasheet #shieldarduinouno #softwarearduino #boarduino #boardarduinouno #mikrokontrolerarduino

[surfandesign3d]

ALAT BANTU TUNA NETRA BERBASIS ARDUINO NANO Designer : @SURFAN_DESIGN3D ====================================== SURFAN DESIGN ~ LAYANAN DESAIN 3D BERKUALITAS DENGAN HARGA KOMPETITIF ====================================== SURFAN DESIGN melayani : ✅ Jasa ️Desain Produk ✅ Jasa Desain mesin ✅ Jasa Desain booth ✅ Jasa Desain furniture ✅ Jasa Render & visualisasi ✅ Jasa Drafter (gambar teknik 2d) ✅ Jasa Animasi desain ✅ Jasa Reverse Engineering ✅ Jasa desain menggunakan software berbasis : ▶️ Jasa desain Autocad ▶️ Jasa desain SolidWorks ▶️ Jasa desain Autodesk Inventor ▶️ Jasa desain Fusion360 ▶ ️Jasa desain SketchUP ▶️ Jasa desain 3dsMAX ▶️ Jasa desain Rhinoceros 3d ====================================== 👉Pemesanan via DM/WA (fast respon) : 📱 0858-7992-7791 ====================================== 📌LINE : [at] ved0052n (use @) 📌Instagram : @surfan_design3d 📌Facebook : [at] SurfanDesign3D 📌Email : surfandesign@gmail.com ====================================== #arduinonano #arduinojogja #arduinolove #arduinomega2560 #arduinos #arduinoprojects #arduinorobot #victoriaarduino #arduino_uno #arduinoday #arduinoshield #arduinocnc #arduinod16 #arduinoindonesia #arduinoleonardo #arduinod17 #arduinolover #arduino #jasaarduino #arduinobasics #arduinomega #arduinoboard #arduinouno #arduinofun #arduinounor3 #arduinoprogramming #jualarduino #arduinotutorial #arduinoproject #arduinomurah https://www.instagram.com/p/BtnwvxLhryK/?utm_source=ig_tumblr_share&igshid=tkq0ji23msiv

[jayquest]

Wonder what kind of #art I'll make with this #ArduinoUnoR3 clone. This kit was only around $15. 🤓 https://ift.tt/2xPNF9A

[draegerit]

Farbsensor TCS34725 und Arduino: Schritt-für-Schritt-Anleitung

In diesem Beitrag möchte ich dir den kleinen, günstigen Farbsensor TCS34725 vorstellen und zeigen, wie du diesen am Arduino UNO R3 anschließt und programmierst. Im Beitrag Arduino Lektion 60: Sensor für Licht, Farbe und Gesten (APDS-9960) habe ich dir bereits ein multifunktionales Modul vorgestellt, welches ebenso die Farbe erkennen kann. Dieser Sensor stellt jedoch eine günstige Alternative dar, wenn man lediglich das Feature der Farberkennung benötigt. https://youtu.be/WoLlCKWz2ok Der TCS34725 überzeugt durch seine einfache Integration über die I2C-Schnittstelle und die umfangreiche Unterstützung durch Bibliotheken wie die von Adafruit. Mit diesem Sensor lassen sich präzise RGB-Werte und Umgebungslichtdaten messen, was ihn ideal für Projekte wie Farbkalibrierung, Beleuchtungsautomatisierung oder DIY-Roboter macht.

In diesem Beitrag zeige ich dir nicht nur, wie du den Sensor anschließt, sondern auch, wie du die erfassten Farbwerte in deinem Projekt nutzen kannst. Als praktisches Beispiel verbinden wir eine RGB-LED, die die vom Sensor erkannten Farben in Echtzeit darstellt. So kannst du die Farberkennung auf anschauliche Weise erleben.

Bezug des Farbsensors TCS34725

Den hier vorgestellten Farbsensor bekommst du sehr günstig auf den einschlägigen Plattformen. - ebay.de* - ab 2,32 € - aliexpress.com - 2,59 € - amazon.de* - 3 € 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 des Farbsensors

Der Farbsensor verfügt über eine I2C Schnittstelle und kann mit 5 V und 3.3V betrieben werden. Die beiden sehr leuchtstarken LEDs sind dauerhaft aktiv, können aber nach Bedarf über den Pin LED deaktiviert werden.

Aufbau des Farbsensors TCS34725

Anschluss des Farbsensors TCS34725 via I2C an den Arduino

Durch die erwähnte I2C Schnittstelle ist der Anschluss an den Arduino sehr einfach und wir benötigen für diesen lediglich vier Breadboardkabel. Zusätzlich zum Farbsensor wird eine RGB-LED integriert, die die vom Sensor erkannten Farben visuell darstellt.

Für den Aufbau der Schaltung am Arduino benötigst du: - einen Arduino kompatiblen Mikrocontroller - Arduino UNO R3* - Arduino Nano V3* - ein passendes Datenkabel* - diverse Breadboardkabel*, männlich - männlich, 10 cm - ein 170 Pin / 400 Pin Breadboard* - eine RGB LED 5050* 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 des Farbsensors TCS34725 am Arduino UNO R3

Für die Programmierung des Arduino verwende ich die Arduino IDE 2.3.3 welche du unter https://www.arduino.cc/en/software für Windows, macOS und Linux herunterladen kannst. Für das Ansteuern / auslesen des Farbsensors benötigen wir zusätzlich eine Bibliothek, hier gibt es diverse auf dem Markt welche ebenso kostenfrei erhältlich sind. Ich habe mit der Adafruit TCS34725 erfolgreich die Farbe auslesen können und möchte dir diese herzlich empfehlen. Um die Bibliothek zu installieren, musst du links den Bibliotheksverwalter (1) öffnen und dort nach "Adafruit TCS34725" (2) suchen. Im ersten Eintrag wählst du hier die Schaltfläche "INSTALLIEREN" (3). Diese Bibliothek hat eine Abhängigkeit zu Adafruit BusIO welches wir ebenso installieren müssen, daher klicken wir in dem Dialog ebenso auf "ALLE INSTALLIEREN" (4)

Nachfolgend möchte ich dir zeigen, wie du die Farbe auslesen und auf einer RGB LED darstellen kannst. Es wird zunächst nur die Farbe Rot, Grün und Blau dargestellt. // Bibliotheken zur Steuerung und Auslesung des Farbsensors #include #include "Adafruit_TCS34725.h" // Pins, an denen die RGB-LED angeschlossen ist #define red 10 #define green 9 #define blue 11 // Instanziieren eines Objekts vom Typ Adafruit_TCS34725 mit spezifischen Parametern Adafruit_TCS34725 tcs = Adafruit_TCS34725(TCS34725_INTEGRATIONTIME_614MS, TCS34725_GAIN_1X); // Variablen zum Speichern der Farbdaten und Lichtwerte uint16_t r, g, b, c, colorTemp, lux; void setup(void) { // Starten der seriellen Kommunikation mit einer Baudrate von 9600 Serial.begin(9600); // Definieren der LED-Pins als Ausgänge pinMode(red, OUTPUT); pinMode(green, OUTPUT); pinMode(blue, OUTPUT); // Initialisieren der Kommunikation mit dem Farbsensor tcs.begin(); } void loop(void) { // Auslesen der Rohdaten (Rot, Grün, Blau, Klarheit) vom Sensor tcs.getRawData(&r, &g, &b, &c); // Berechnen der Farbtemperatur in Kelvin colorTemp = tcs.calculateColorTemperature_dn40(r, g, b, c); // Berechnen der Beleuchtungsstärke (Lux) lux = tcs.calculateLux(r, g, b); // Berechnen der RGB-Werte für Rot, Grün und Blau basierend auf den Rohdaten byte rgbColorRed = calcColorValue(r, c); byte rgbColorGreen = calcColorValue(g, c); byte rgbColorBlue = calcColorValue(b, c); // Vergleichen der RGB-Werte, um die dominante Farbe zu ermitteln byte maxColor = compareValues(rgbColorRed, rgbColorGreen, rgbColorBlue); // Überprüfen, welche der Farben (Rot, Grün, Blau) dominiert bool isMainColorRed = maxColor == rgbColorRed; bool isMainColorGreen = maxColor == rgbColorGreen; bool isMainColorBlue = maxColor == rgbColorBlue; // Setzen der LED-Farben basierend auf der dominanten Farbe analogWrite(red, isMainColorRed ? 255 : 0); analogWrite(green, isMainColorGreen ? 255 : 0); analogWrite(blue, isMainColorBlue ? 255 : 0); // Ausgabe der Farbtemperatur und Lux-Werte auf der seriellen Schnittstelle Serial.println("Color Temp: " + String(colorTemp, DEC) + " K"); Serial.println("Lux: " + String(lux, DEC)); Serial.println("Rot: " + String(r, DEC)); Serial.println("Grün: " + String(g, DEC)); Serial.println("Blau: " + String(b, DEC)); Serial.println("Klarheit: " + String(c, DEC)); // Ausgabe der berechneten RGB-Werte auf der seriellen Schnittstelle Serial.print("RGB-Wert: (" + String(rgbColorRed, DEC) + "," + String(rgbColorGreen) + "," + String(rgbColorBlue) + ")"); } // Berechnet den RGB-Wert aus einem Farbwert (Rot, Grün oder Blau) und dem Klarheitswert uint16_t calcColorValue(uint16_t color, uint16_t clarityValue) { double rgbColorValue = (double)color / (double)clarityValue; return round(rgbColorValue * 255); } // Vergleicht die RGB-Werte und gibt die dominante Farbe zurück byte compareValues(byte r, byte g, byte b) { if (r > g && r > b) { return r; } else if (g > r && g > b) { return g; } else if (b > r && b > g) { return b; } return 0; } Umrechnen des Farbwertes in RGB Werte Vom Sensor erhalten wir lediglich die Rohdaten für die Farbinformationen um daraus einen RGB Wert zu berechnen nutze ich nachfolgende Formel:

Bedeutung der Variablen: - 255: Die maximale RGB-Wert-Skala, auf die die Werte angepasst werden. - Farbwert (color): Der Rohwert eines Farbkanals (Rot, Grün oder Blau), den der Sensor liefert. - Klarheitswert (clarityValue): Ein Maß für die Gesamtlichtintensität (Summe aller Farben und Helligkeit), um die Farbe zu normalisieren. // Berechnet den RGB-Wert aus einem Farbwert (Rot, Grün oder Blau) und dem Klarheitswert uint16_t calcColorValue(uint16_t color, uint16_t clarityValue) { double rgbColorValue = (double)color / (double)clarityValue; return round(rgbColorValue * 255); } Ermitteln der Farbe (einfache Lösung) Zunächst konzentriere ich mich darauf, die drei Grundfarben Rot, Grün und Blau darzustellen. Dafür verwende ich zu Beginn drei einfarbige Würfel in Rosa, Grün und Blau. Anhand der berechneten RGB-Werte lässt sich die dominante Farbe bestimmen, die dann über die RGB-LED visualisiert wird. // Berechnen der RGB-Werte für Rot, Grün und Blau basierend auf den Rohdaten byte rgbColorRed = calcColorValue(r, c); byte rgbColorGreen = calcColorValue(g, c); byte rgbColorBlue = calcColorValue(b, c); // Vergleichen der RGB-Werte, um die dominante Farbe zu ermitteln byte maxColor = compareValues(rgbColorRed, rgbColorGreen, rgbColorBlue); // Überprüfen, welche der Farben (Rot, Grün, Blau) dominiert bool isMainColorRed = maxColor == rgbColorRed; bool isMainColorGreen = maxColor == rgbColorGreen; bool isMainColorBlue = maxColor == rgbColorBlue; // Setzen der LED-Farben basierend auf der dominanten Farbe analogWrite(red, isMainColorRed ? 255 : 0); analogWrite(green, isMainColorGreen ? 255 : 0); analogWrite(blue, isMainColorBlue ? 255 : 0);

Erweitern der Schaltung um einen Abstandssensor um die LEDs / den Sensor zu aktivieren

Wenn man etwas Stromsparen und ebenso auch den Sensor schonen möchte, dann kann man einen kleinen Abstandssensor in die Schaltung integrieren und so die LEDs und die Messung abhängig davon mach, ob sich ein Gegenstand vor dem Sensor befindet.

Für die Schaltung verwende ich einen Infrarotabstandssensor welcher einen digitalen und analogen Ausgang hat. Da mich lediglich interessiert, ob sich ein Gegenstand vor dem Sensor befindet, verwende ich den digitalen Ausgang, welchen man über einen Drehpotentiometer einstellen kann.

Infrarot Abstandssensor - TCRT5000

Rückseite des Infrarot Abstandssensors Im Code müssen wir recht wenig anpassen, denn der digitale Ausgang wird ähnlich einem Taster abgefragt und wir reagieren wenn dier LOW ist. Sollte der Ausgang HIGH sein so führen wir keine Messung durch und deaktivien ebenso die RGB LED (alle Farbwerte auf 0). #define led 5 #define irSensor 7 void setup(void) { ... pinMode(led, OUTPUT); pinMode(irSensor, INPUT); digitalWrite(led, HIGH); ... } void loop(void) { if (digitalRead(irSensor) == HIGH) { digitalWrite(led, LOW); analogWrite(red, 0); analogWrite(green, 0); analogWrite(blue, 0); return; } digitalWrite(led, HIGH); ... } Read the full article

[dhakarobotics]

Arduino Uno R3 with Cable (Original Atmel MGA16u2) - is now at Dhaka Robotics

Are you ready to take your DIY projects to the next level? The Arduino Uno R3 is here to help you bring your ideas to life! Whether you’re a beginner or an experienced maker, this versatile microcontroller board is perfect for all your creative needs.

Click here to purchase the product: https://dhakarobotics.com/.../1029-arduino-uno-r3-with.../

Contact Us: +8801740298319

visit our website: https://dhakarobotics.com/

[draegerit]

Zeitgesteuerte Schaltung mit Arduino: Programmieren von RTC, LCD und Relaismodul

Über eine zeitgesteuerte Schaltung kannst du Verbraucher zu einem bestimmten Zeitpunkt aktivieren/deaktivieren. Dieses kleine Projekt wird mit dem Arduino UNO R3, einem 2x20 Zeichen LCD-Display und Relais Shield umgesetzt. Der Arduino nutzt eine Echtzeituhr (RTC), um das Datum und die Uhrzeit genau zu erfassen, sodass Schaltvorgänge pünktlich ausgeführt werden können. Die aktuelle Uhrzeit wird auf dem LCD-Display dargestellt, während das Relaismodul externe Geräte wie Lampen oder Motoren steuert. Diese zeitgesteuerte Schaltung eignet sich ideal für Automatisierungsprojekte, bei denen Aktionen zu festgelegten Zeiten ablaufen sollen. Im Folgenden erkläre ich dir Schritt für Schritt, wie du die Komponenten anschließt und programmierst. https://www.youtube.com/watch?v=hZaCMxE3oEo Ein Follower auf TikTok hat mich auf die Idee für diesen Beitrag gebracht, daher möchte ich mich an dieser Stelle ganz besonders bei Armin F. für den inspirierenden Vorschlag bedanken.

LCD-Display mit Datum & Uhrzeit von einer RTC am Arduino UNO R3 Auf meinem TikTok Kanal habe ich dir bereits zu diesem Beitrag, mehrere Videos veröffentlicht, in welchen ich den Aufbau der Schaltung, das Programmieren in der Arduino IDE sowie das Einstellen von Zeitpunkten für das Schalten von Verbraucher erläutert habe. - Teil 1 - Aufbauen der Schaltung - Teil 2 - Programmieren eines LCD-Displays über die Arduino IDE am Arduino UNO R3

Wie soll das kleine Projekt funktionieren?

Der Arduino UNO R3 erhält die aktuelle Uhrzeit und das Datum von der RTC. Zu einem festgelegten Zeitpunkt schaltet er dann das Relais. So weit, so unkompliziert. Über die serielle Schnittstelle lässt sich einerseits der Zeitpunkt für eine Aktion einstellen und andererseits die RTC mit dem richtigen Datum und der Uhrzeit konfigurieren. In meinem Projekt verwende ich ein zweifaches Relaismodul, wodurch ich zwei verschiedene Schaltzeitpunkte festlegen kann.

Benötigte Ressourcen für dieses Projekt

Für den Aufbau des Projektes verwende ich nachfolgende Bauteile: - einen Arduino UNO R3* - ein USB-Datenkabel* - eine RTC DS3231* - ein I2C LCD-Display* - ein Relais Shield* - diverse Breadboardkabel*, 10 cm, männlich - weiblich

Module - zeitgesteuerte Schaltung am Arduino 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 Schaltung

Der Aufbau am Arduino UNO R3 ist recht einfach, du schließt die RTC & das LCD-Display via I2C an und das 2fach Relaismodul über zwei digitale Pins.

zeitgesteuerte Schaltung mit dem Arduino UNO R3, RTC und LCD-Display Nachfolgend die Tabelle mit den Daten, wie die Bauteile an den Arduino angeschlossen wurden. BauteilArduino UNO R3Kabelfarbe2fach Relais ModulVCC5 VrotGNDGNDschwarzIN1D9braunIN2D8blauRealtimeClock (RTC DS3132)VCC5 VrotGNDGNDschwarzSDAA4gelbSCLA5grünLCD-DisplayVCC5 VrotGNDGNDschwarzSDAA4gelbSCLA5grün Statt dem betagten Arduino UNO R3 könntest du auch den neuen UNO R4 Minima oder UNO R4 WiFi nutzen, alle drei Mikrocontroller sind untereinander kompatibel. Oder wenn du noch platzsparender sein möchtest, dann den Arduino Nano V3.

Zeitgesteuerte Schaltung in der Arduino IDE programmieren

Beginnen wir nun und programmieren die Schaltung in der Arduino IDE. In meinem Fall nutze ich die Arduino IDE 2. Schritt 1 - programmieren des LCD-Displays Fangen wir zunächst im ersten Schritt mit dem LCD-Display an, dieses haben wir via I2C angeschlossen und daher benötigen zunächst auch eine spezielle Bibliothek. Diese Bibliothek können wir vom GitHub Repository johnrickman / LiquidCrystal_I2C als ZIP-Datei herunterladen. //Bibliothek zum ansteuern des LCD-Display via I2C #include //Das Display wird über //die I2C Adresse 0x27 angesteuert //es hat 20 Zeichen pro Zeile //es hat 2 Zeilen LiquidCrystal_I2C lcd(0x27, 20, 2); void setup() { //initialisieren des Displays lcd.init(); //aktivieren der Hintergrundbeleuchtung lcd.backlight(); //setzen des Cursors auf die erste Zelle im Display lcd.setCursor(0, 0); //schreiben eines Textes lcd.print("Fr. 20.10.2024"); //setzen des Cursors auf die zweite Zeile im Display lcd.setCursor(0, 1); //schreiben eines Textes lcd.print("18:35:23 Uhr"); } void loop() { //bleibt leer } Der Code bewirkt, dass auf dem LCD-Display in der ersten Zeile das Datum und in der zweiten Zeile die Uhrzeit angezeigt wird. Solltest du keinen Text sehen, so empfehle ich dir zunächst den Drehpoti für die Helligkeit auf der Rückseite zu drehen.

Schritt 2 - programmieren der RealtimeClock Die Realtimeclock wird via I2C angesteuert und liefert uns einen Zeitstempel aus Datum & Uhrzeit. Jedoch müssen wir dieser initial einen solchen Zeitstempel setzen. Programm - setzen und auslesen eines Zeitstempels an einer RTCHerunterladen Schritt 2.1 - setzen eines Zeitstempels Den Zeitstempel im Format TT.MM.YYY SS:MM:SS also zum Beispiel "20.09.2024 18:35:34" (ohne Anführungszeichen) senden wir via seriellen Monitor an den Mikrocontroller. Über die Funktion readDataFromSerial() werden diese Daten empfangen und ausgewertet. Die Bestandteile des Zeitstempels werden anschließend an die Funktion rtcWriteTimestamp übergeben. // I2C Adresse des RTC DS3231 #define RTC_I2C_ADDRESS 0x68 struct Zeitstempel { String datum; String zeit; }; char linebuf = {}; bool readData = false; void setup() { Serial.begin(9600); ... } void loop() { readDataFromSerial(); if (readData) { String timestamp = linebuf; //Das Datum muss inkl. den Punkten 10 Zeichen lang sein String datum = timestamp.substring(0,10); String tag = datum.substring(0,2); String monat = datum.substring(3,5); String jahr = datum.substring(6,10); //Die Uhrzeit beginnt ab dem 11 Zeichen aus dem Zeitstempel String uhrzeit = timestamp.substring(11); String stunde = uhrzeit.substring(0,2); String minute = uhrzeit.substring(3,5); String sekunde = uhrzeit.substring(6); rtcWriteTimestamp(stunde.toInt(), minute.toInt(), stunde.toInt(), tag.toInt(), monat.toInt(), jahr.toInt()); } ... } void readDataFromSerial() { //Zähler für die Zeichen byte counter = 0; readData = false; //Wenn Daten verfügbar sind dann... if (Serial.available() > 0) { delay(250); readData = true; //solange Daten von der seriellen Schnittstelle //empfangen werden... while (Serial.available()) { //speichern der Zeichen in dem Char Array char c = Serial.read(); if (c != 'n') { linebuf = c; if (counter < sizeof(linebuf) - 1) { counter++; } } } Serial.println(linebuf); } else { readData = false; } } void rtcWriteTimestamp(int stunde, int minute, int sekunde, int tag, int monat, int jahr){ Wire.beginTransmission(RTC_I2C_ADDRESS); Wire.write(0); // Der Wert 0 aktiviert das RTC Modul. Wire.write(decToBcd(sekunde)); Wire.write(decToBcd(minute)); Wire.write(decToBcd(stunde)); Wire.write(decToBcd(0)); // Wochentag unberücksichtigt Wire.write(decToBcd(tag)); Wire.write(decToBcd(monat)); Wire.write(decToBcd(jahr-2000)); Wire.endTransmission(); } Schritt 2.2 - auslesen eines Zeitstempels Wenn wir den Zeitstempel gesetzt haben, dann können wir diesen wieder auslesen. void loop() { ... //bleibt leer Zeitstempel zeitstempel = readRtc(); lcd.setCursor(0, 0); lcd.print(zeitstempel.datum); lcd.setCursor(0, 1); lcd.print(zeitstempel.zeit); delay(500); } //auslesen der Daten von der RealtimeClock Zeitstempel readRtc() { //Aufbau der Verbindung zur Adresse 0x68 Wire.beginTransmission(RTC_I2C_ADDRESS); Wire.write(0); Wire.endTransmission(); Wire.requestFrom(RTC_I2C_ADDRESS, 7); int sekunde = bcdToDec(Wire.read() & 0x7f); int minute = bcdToDec(Wire.read()); int stunde = bcdToDec(Wire.read() & 0x3f); int wochentag = bcdToDec(Wire.read()); int tag = bcdToDec(Wire.read()); int monat = bcdToDec(Wire.read()); int jahr = bcdToDec(Wire.read()) + 2000; char datum; sprintf(datum, "d.d.", tag, monat, jahr); char zeit; sprintf(zeit, "d:d:d Uhr", stunde, minute, sekunde); return { datum, zeit }; } Schritt 3 - aktivieren der Relais via Zeitstempel In meinem Fall habe ich ein 2fach Relais Shield in die Schaltung integriert, du kannst auch Shields mit deutlich mehr Relais erwerben und integrieren, die nachfolgend gezeigt Funktion bleibt dieselbe. struct Relais { int digitalPin; String desc; Zeitstempel actionON; Zeitstempel actionOFF; }; Relais relais1 = { 9, "Relais #1", { "20.09.2024", "22:21:00" }, { "20.09.2024", "22:21:10" } }; Relais relais2 = { 8, "Relais #2", { "20.09.2024", "22:21:10" }, { "20.09.2024", "22:21:15" } }; void setup() { ... pinMode(relais1.digitalPin, OUTPUT); pinMode(relais2.digitalPin, OUTPUT); digitalWrite(relais1.digitalPin, HIGH); digitalWrite(relais2.digitalPin, HIGH); } void loop() { ... checkCurrentTimestamp(relais1, zeitstempel); checkCurrentTimestamp(relais2, zeitstempel); } void checkCurrentTimestamp(Relais relais, Zeitstempel zeitstempel) { if (zeitstempel.datum == relais.actionON.datum && zeitstempel.zeit == relais.actionON.zeit) { Serial.println("aktivieren"); digitalWrite(relais.digitalPin, LOW); } else if (zeitstempel.datum == relais.actionOFF.datum && zeitstempel.zeit == relais.actionOFF.zeit) { Serial.println("deaktivieren"); digitalWrite(relais.digitalPin, HIGH); } }

Fazit und Ausblick

Mit diesem Beitrag habe ich dir nun gezeigt wie eine zeitgesteuerte Schaltung am Arduino UNO R3 mit einer RTC und einem Relaisshield aufgebaut und programmiert wird. Diese Schaltung kannst du selbstverständlich auch mit dem neuen UNO R4 WiFi aufbauen und so die Zeit von einem NTP-Server abrufen und auch andere smarter Schalter wie den Shelly 1PM Mini steuern. Read the full article

[dhakarobotics]

Arduino Uno R3 with Cable (Original Atmel MGA16u2) - is now at Dhaka Robotics.

আপনি কি আপনার DIY ইলেকট্রনিক্স প্রকল্পগুলি প্রাণবন্ত করতে প্রস্তুত? Arduino Uno R3 নতুনদের জন্য নিখুঁত সূচনা পয়ে��্ট এবং প্রোফেসনালদের জন্য এটি নির্ভরযোগ্য । Original Atmel MGA16u2 দ্বারা চালিত, এই মাইক্রোকন্ট্রোলার বোর্ডটি অতুলনীয় পারফরম্যান্স এবং সামঞ্জস্যতা সরবরাহ করে। আপনি রোবট, হোম অটোমেশন সিস্টেম তৈরি করছেন অথবা কেবল পরীক্ষা-নিরীক্ষাই করছেন , Arduino Uno R3 হল আপনার জন্য সঠিক সরঞ্জাম।

আপনি অনলাইনে আমাদের ওয়েবসাইটে ভিসিট করে সরাসরি অর্ডার করতে পারবেন।

পণ্য কেনার লিংক : https://dhakarobotics.com/.../1029-arduino-uno-r3-with.../

যেকোনো প্রোয়জনে কল করুন এই নম্বরে :

+8801740298319

Visit Our Website: https://dhakarobotics.com/

[draegerit]

Grove 8x8 LED Matrix am Arduino: Einsteigerfreundliche Programmieranleitung

In diesem Beitrag möchte ich dir zeigen, wie du die Grove 8x8 LED Matrix am Arduino UNO R3 programmierst. Der Vorteil von diesem Modul ist es, dass du keine umständliche Verkabelung vornehmen musst, da die Grove Schnittstelle einheitlich ist und ein vorkonfektioniertes Kabel verwendet wird.

Grove 8x8 LED Matrix am Arduino: Einsteigerfreundliche Programmieranleitung Im Beitrag Arduino Lektion 8: Max7219 8×8 LED Shield habe ich dir bereits ein ähnliches Modul mit dem Chip MAX7219 vorgestellt. Hier soll es nun um eine Matrix mit dem Treiber HT16K33 gehen.

Bezug einer 8x8 LED Matrix mit Grove Schnittstelle

Das mir vorliegende Modul habe ich auf ebay.de für rund 9 € zzgl. Versandkosten erstanden. Du bekommst dieses Modul aber etwas günstiger bei BerryBase für derzeit 8 € zzgl. Versandkosten. Lieferumfang Im Lieferumfang der LED Matrix ist neben der Matrix noch ein kleines Grove Kabel für den Anschluss, sowie ein Zettel mit den wichtigsten technischen Daten.

Auf der LED Matrix ist noch eine kleine Schutzfolie, welche du abziehen kannst, ich lasse diese jedoch drauf.

Aufbau der 8x8 LED Matrix

Auf der Rückseite findest du die Grove Schnittstelle, sowie zwei Lötpunkte für die optionale externe Stromversorgung. Des Weiteren kannst du die I2C Adresse 0x70 via 3 Lötbrücken ändern.

I2C Adressen via Lötbrücken Wenn du die Lötbrücken verbindest, dann kannst du diese Matrix über nachfolgende I2C Adressen ansteuern. Dabei kannst du auch mehrere Muster wählen und so zwischen 8 I2C Adressen auswählen. Verbundene PinsI2C Adresse-0x70A00x71A10x72A20x72A0 & A10x73A0 & A20x75A1 & A20x76A0, A1 & A20x77 Zur Ermittlung der I2C Adressen habe ich den I2C Scanner von https://playground.arduino.cc/Main/I2cScanner/ verwendet.

Zusätzliche Ressourcen für die Programmierung am Arduino

Damit du diese LED Matrix programmieren kannst, benötigst du entweder - ein Grove Adapterkabel, oder - ein Grove Base Shield für den Arduino UNO R3, oder - ein Seeeduino Nano

Grove Adapterkabel zu Breadboardpins

Grove Base Shield für den Arduino UNO R3

Seeeduino Nano Das Grove Base Shield hat mehrere Grove Buchsen digital & analog und somit bietet dieses eine sehr große Bandbreite an Möglichkeiten für Projekte. Wenn du lediglich die LED Matrix programmieren möchtest und du hast bereits einen Arduino Nano oder Arduino UNO dann

Programmieren der LED Matrix am Arduino via I2C

Damit die LED Matrix mit HT16K33 Treiber angesteuert werden kann, müssen wir in der Arduino IDE eine zusätzliche Bibliothek installieren. Diese können wir uns als ZIP-Datei vom GitHub Repository Seeed-Studio/Grove_LED_Matrix_Driver_HT16K33 herunterladen. Weitere Informationen zu diesem Modul findest du auf der englischen Wikiseite von Seeedstudio https://wiki.seeedstudio.com/Grove-LED_Matrix_Driver-HT16K33/. Anzeigen eines Smileys auf der LED Matrix Für die Erstellung eines Smileys kannst du den LED Matrix Editor unter https://xantorohara.github.io/led-matrix-editor/ verwenden. Dieser Onlineeditor gibt dir die Möglichkeit, mit der Maus auf der LED Matrix einzelne LEDs zu aktivieren / deaktivieren.

LED Matrix Editor von Xantorohara Auf der rechten Seite findest du ein Stück Code, welchen du in dein Arduino Programm integrieren kannst. In meinem Fall habe ich ein lachendes Smiley gezeichnet und erhalte den Wert "0x3c4299a581a5423c". Die Bibliothek liefert zusätzlich ein paar Beispiele, welche mit der default I2C Adresse 0x70 lauffähig sind. Von diesen Beispielen wähle ich zunächst "displaycustom_pictures" und modifiziere dieses etwas. //Bibliotheken zum kommunizieren mit der LED Matrix #include #include "Grove_LED_Matrix_Driver_HT16K33.h" //Wert für ein lachenden Smiley const uint64_t smiley = 0x3c4299a581a5423c; //instanz einer LED Matrix Matrix_8x8 matrix; void setup() { //beginn der I2C kommunikation Wire.begin(); //beginn der kommunikation mit der LED Matrix matrix.init(); //setzen der Helligkeit der Matrix //Werte sind zwischen 0 und 15 //wobei 0 dunkel ist und 15 das hellste matrix.setBrightness(5); //In welcher Frequenz die LED Matrix blinken soll, //Werte sind: //- BLINK_OFF > kein blinken, //- BLINK_1HZ > langsames blinken, //- BLINK_2HZ > schnelles blinken, matrix.setBlinkRate(BLINK_OFF); } void loop() { //anzeigen eines Bildes matrix.writeOnePicture(smiley); //absenden der Daten matrix.display(); //eine Pause von 10 Sekunden delay(10000); } Auf der Matrix hat man natürlich nur begrenzte Möglichkeiten zur Darstellung von Bildern, jedoch für so kleine Smileys und Pfeile ist dieses bestens geeignet.

lachender Smiley auf der 8x8 LED Matrix Ausgabe von Scrolltext auf der LED Matrix Da wie erwähnt die kleine LED Matrix nur begrenzten Platz für Zeichen bietet, gibt es die Möglichkeit Text auf diesem durchscrollen zu lassen. void loop() { //Funktion zum anzeigen eines Textes auf der LED Matrix, //Parameter: //String - die Zeichenkette welche ausgegeben werden soll, //Zahl - Wert in Millisekunden pro Zeichen //Typ //ACTION_SHIFT - jedes Zeichen einzeln anzeigen, //ACTION_SCROLLING - den Text durch die Matrix scrollen lassen matrix.writeString("Hallo Welt!", 1000, ACTION_SCROLLING); matrix.display(); } Damit ich das Video aufnehmen konnte, sodass meine Kamera den Text erfasst, habe ich ein kleines Tuch vor die LED Matrix gehängt.

Ändern der default I2C Adresse im Programm

Wenn du bereits Sensoren oder Aktoren am I2C Bus angeschlossen hast, dann kann es vorkommen, dass die default I2C Adresse der LED Matrix bereits belegt ist und du diese im Programm überschreiben musst. (Oder auch, wenn du mehrere solcher Matrixen an einem I2C Bus anschließen möchtest.) Dazu findest du in der Funktion setup den Aufruf der Funktion "matrix.ini();". Diese Funktion kann einen Parameter vom Typ uint8_t übernehmen und hat als default den Wert des Feldes HT16K33_DEFAULT_I2C_ADDR. #define HT16K33_DEFAULT_I2C_ADDR 0x70 Wir übergeben also nun den Hexadezimalen Wert, welchen wir aus der Tabelle (siehe I2C Adressen via Lötbrücken) entnehmen können. Und brauchen quasi in unserem Programm nichts weiter anpassen. matrix.init(0x71);

Vergleich zwischen 8x8 LED Matrix - MAX7219 & HT16K33

Zum Schluss möchte ich dir noch gerne die Unterschiede zur LED Matrix mit dem MAX7219 Chip aufzeigen. Diese LED Matrix verfügt ebenso wie die vorgestellte Matrix über 8x8 LEDs und kann ebenso einfach programmiert werden.

8x8 LED Matrix mit HT16K33 Treiberchip

8x8 LED Matrix mit MAX7219 Treiberchip Jedoch kannst du diese Matrix zu mehreren zusammenstecken und so eine schier endlose Anzeige aufbauen.

MAX7219 Shields auf einem Stativ Die LED Matrix mit Grove Schnittstelle jedoch kannst du nicht so kaskadierend aufbauen und somit bist du mit dem Modul in deinen Möglichkeiten stärker beschränkt.

Fazit zur Programmierung der 8x8 LED Matrix mit Grove Schnittstelle am Arduino

Die LED Matrix von Seeedstudio mit Grove Schnittstelle und HT16K33 Treiberchip lässt sich super einfach programmieren. Du benötigst wenig Code und über die I2C Schnittstelle und dem Grovekabel hast du deutlich weniger Verkablung als bei der LED Matrix mit MAX7219, leider vermisse ich hier die Möglichkeit die Module kaskadierend zu verbinden und so ein langes Display für Laufschrift aufzubauen. Mit dem Online LED Matrix Editor kannst du dir jedoch recht einfach kleine Frames für die Matrix erstellen und in den Code kopieren. Ausblick Ich werde nun mal schauen, welche kleinen Projekte man mit dieser Matrix aufbauen kann. Jedoch würde ich eher zu einer RGB Matrix tendieren, denn diese kann bei gleicher Baugröße verschiedenfarbige Pixel anzeigen. Read the full article

[draegerit]

Calliope Mini 3 Tutorial: Datenübertragung zwischen Calliope und Arduino über die serielle Schnittstelle

In diesem Beitrag möchte ich dir erläutern, wie du über die serielle Schnittstelle Daten zwischen dem Calliope und einem Arduino austauschen kannst. Über eine serielle Schnittstelle kannst du Sensordaten und auch Befehle zum steuern eines anderen Mikrocontrollers oder angeschlossenen Aktor senden. https://youtu.be/CQPTF6WixiA Ich habe bereits in verschiedenen Beiträgen hier im Blog sowohl den Calliope Mini 3 als auch den Arduino UNO R3 vorgestellt. Jetzt möchte ich dir anschaulich zeigen, wie du diese beiden Mikrocontroller miteinander verbinden und Daten zwischen ihnen austauschen kannst. Während der Calliope Mini 3 eine Bluetooth-Schnittstelle für drahtlose Datenübertragung bietet, fehlt diese Funktion beim Arduino UNO R3.

Wozu benötigt man eine serielle Verbindung in Zeiten von Bluetooth & WiFi?

Zunächst möchte ich gerne klären, warum wir uns mit dem Aufbau und der Programmierung einer seriellen Verbindung in Zeiten von Bluetooth und WiFi überhaupt befassen. Serielle Schnittstellen sind immer noch relevant, da sie eine zuverlässige und einfache Möglichkeit bieten, Geräte miteinander zu verbinden. Sie sind oft schneller, stabiler und benötigen weniger Energie als drahtlose Verbindungen wie Bluetooth / WiFi. Außerdem sind serielle Schnittstellen in vielen eingebetteten Systemen, Sensoren und IoT-Geräten weit verbreitet.

Benötigte Ressourcen für diesen Beitrag

Wenn du die kleine Schaltung und die damit verbundenen Beispiele nachbauen / programmieren möchtest, dann benötigst du: - einen Calliope Mini 3 mit Datenkabel, - einen Arduino UNO R3 oder Arduino Nano V3 mit passendem Datenkabel, - drei Breadboardkabel 10 cm, männlich - männlich Für die nachfolgenden Beispiele benötigst du noch: - eine 10 mm oder 5 mm LED mit 220 Ohm Vorwiderstand, - ein 170 Pin Breadboard, - zwei Printtaster 12 mm x 12 mm mit Kappe, - einen kleinen Servomotor SG90, - diverse Breadboardkabel

Bauteile für die serielle Verbindung von Calliope zum Arduino Da der Calliope Mini 3 über diverse Sensoren verfügt, zeige ich dir auch Beispiele in welche wir einen Temperatursensor, Lichtsensor, 3-Achsen Lagesensor verwenden und am Arduino auswerten.

Aufbau der seriellen Verbindung zwischen dem Arduino und Calliope Mini 3

Bauen wir zunächst die serielle Verbindung zwischen den beiden Mikrocontrollern auf. Dazu benötigen wir drei Breadboardkabel (männlich - männlich, 10 cm). Wir verwenden jedoch nicht die digitalen Pins D0 & D1 vom Arduino UNO R3, denn diese sind mit dem USB-Anschluss verbunden. Immer wenn wir ein neues Programm auf den Mikrocontroller aufspielen möchten, müssen wir dann die Verbindung zwischen den beiden Mikrocontrollern trennen. Als alternative können wir jeden beliebigen anderen digitalen Pin vom Arduino verwenden. Denn wir lösen dieses Problem im Code mit SoftwareSerial.

serielle Verbindung zwischen einem Calliope Mini 3 und einem Arduino UNO R3 Arduino UNO R3Calliope Mini 3Farbedigitaler Pin D10 - RXP1 - TXliladigitaler Pin D11 - TXP0 - RXorangeGNDGNDweiß Das Pinout vom Calliope Mini 3 findest du entweder einmal auf der Rückseite des Mikrocontrollers und auch nachfolgend in der Grafik.

Pinout der Buchsenleiste am Calliope Mini 3

Testen der seriellen Verbindung

Zunächst möchte ich dir gerne zeigen, wie du deine serielle Verbindung testen kannst. Das ist besonders wichtig, wenn der Code mal nicht so funktioniert, wie du es erwarten würdest und du dich auf die Fehlersuche begeben musst. In der Arduino IDE bekommst du ein kleines Tool, mit welchem du dir die Daten von der seriellen Schnittstelle ausgegeben und auch soweit dieses Zahlen sind, in einem Liniendiagramm visualisieren kannst.

Abfragen der seriellen Schnittstelle am Arduino

Der nachfolgende Code funktioniert für die meisten Mikrocontroller der Arduino Familie, ich beziehe mich jedoch auf den am meisten verbreiteten, den Arduino UNO R3. Mit dem nachfolgenden Code geben wir die empfangenen Daten auf der seriellen Schnittstelle des Arduinos aus und damit können wir dann diese im seriellen Monitor oder seriellen Plotter (soweit diese aus Zahlen bestehen) betrachten. #include // erster Parameter 10 für Pin RX, // zweiter Parameter 11 für Pin TX SoftwareSerial softwareSerial(10, 11); void setup() { //beginn der seriellen Kommunikation mit 9600 baud //auf der "normalen" seriellen Schnittstelle Serial.begin(9600); //beginn der seriellen Kommunikation mit 9600 baud //auf der neuen seriellen Schnittstelle softwareSerial.begin(9600); } void loop() { //Wenn Daten an der Schnittstelle anliegen, dann... if (softwareSerial.available() > 0) { //auslesen und ausgeben der Daten Serial.println(softwareSerial.readString()); } } Mit diesem kleinen Programm lassen wir die Daten, welche vom Calliope Mini 3 gesendet wurden, auf der "normalen" seriellen Schnittstelle ausgeben.

Abfragen der seriellen Schnittstelle am Calliope Mini 3

Eine serielle Verbindung klappt auch in die andere Richtung, daher können wir ebenso gut am Calliope Mini 3 die Daten anzeigen. Hier haben wir die Möglichkeiten, die Daten auf der 5x5 LED Matrix in einem Lauftext anzuzeigen. Wenn die Daten nur aus Zahlen bestehen, dann kannst du diese Werte auch im Datenlogger anzeigen. Der Datenlogger kann nur Zahlen anzeigen. Ein kleiner Hack wäre es den Text als Spaltenname zu verwenden, jedoch ist dieses nicht wirklich brauchbar. Das kleine Programm dazu sieht wie folgt aus:

Programm in MakeCode zum lesen der seriellen Schnittstelle am Calliope Mini 3 Hier die HEX-Datei zum download und importieren in MakeCode. Programm - lesen der seriellen Schnittstelle am Calliope Mini 3Herunterladen Im nachfolgenden kleinen Video demonstriere ich dir, wie ein Text vom Arduino an den Calliope gesendet und dieser als Lauftext auf der 5x5 LED Matrix angezeigt wird.

Schalten einer LED am Arduino mit dem Calliope Mini 3

Als Erstes möchte ich dir gerne zeigen, wie du eine LED am Arduino mit dem Calliope Mini 3 schalten kannst. Es gibt diverse LEDs, ich verwende gerne die 10 mm LED für solche Schaltungen, da hier der 220 Ohm Vorwiderstand entfällt.

Code am Calliope Mini 3 zum Senden von Befehlen über die serielle Schnittstelle In MakeCode schreiben wir nun ein kleines Programm, in welchem wir zunächst beim Starten die serielle Verbindung auf die Pins P0 & P1 mit 9600 Baud umleiten. Wenn der Taster A betätigt wird, dann soll ein A über die serielle Schnittstelle gesendet. Wird der Taster B betätigt, dann wird ein B gesendet. Alternativ kann man auch noch das Logo auf der Rückseite verwenden und mit diesem einen weiteren Befehl senden.

MakeCode - Programm zum senden von Befehlen über die serielle Schnittstelle am Calliope Mini Hier das kleine Programm für MakeCode zum Importieren. Programm - Calliope Mini 3 Taster zum serielles senden von BefehlenHerunterladen Code am Arduino IDE Am Arduino müssen wir jetzt die Befehle vom Calliope Mini empfangen und auswerten. Wie zuvor bereits erläutert verwende ich eine SoftwareSerial Schnittstelle, da diese es einfacher erlaubt das Programm zu wechseln, ohne die Verkabelung zum Calliope Mini zu trennen. #include //10mm LED am digitalen Pin D7 angeschlossen #define ledBlau1 7 //5mm LED am digitalen Pin D6 angeschlossen #define ledBlau2 6 // RX, TX SoftwareSerial softwareSerial(10, 11); void setup() { //beginn der seriellen Kommunikation mit 9600 baud Serial.begin(9600); softwareSerial.begin(9600); //definieren das die Pins der LEDs als Ausgang dienen pinMode(ledBlau1, OUTPUT); pinMode(ledBlau2, OUTPUT); } void loop() { //Wenn Daten an der seriellen Schnittstelle //anliegen, dann... if (softwareSerial.available() > 0) { //lesen der gesamten Zeile String data = softwareSerial.readString(); //entfernen der unnötigen Leerzeichen //am Anfang und Ende data.trim(); //Ausgeben der empfangenen Daten auf //dem seriellen Monitor der Arduino IDE Serial.println(data); //Wenn ein "A" empfangen wurde, dann... if (data == "A") { //LEDs aktivieren digitalWrite(ledBlau1, HIGH); digitalWrite(ledBlau2, HIGH); } else if (data == "B") { //Wenn ein "B" empfangen wurde, //dann sollen die LEDs deaktiviert werden digitalWrite(ledBlau1, LOW); digitalWrite(ledBlau2, LOW); } } }

Steuern eines Servomotors am Arduino mit dem Calliope Mini

Statt eine LED kannst du auch einen Servomotor steuern. Der hier verwendete Servomotor kann einen Winkel zwischen 0° und 180° ansteuern. Den Servomotor schließen wir am digitalen Pin D9 beim Arduino UNO an.

Wir belassen das Programm auf dem Calliope Mini wie zuvor und ändern lediglich das kleine Programm am Arduino. #include #include //Der Servomotor ist am digitalen Pin D9 angeschlossen #define servoPin 9 // RX, TX SoftwareSerial softwareSerial(10, 11); //Erzeugen eines neuen Servoobjektes Servo servo; //Feld zum speichern der Servoposition int servoPosition = 0; //Konstante mit dem Wert wieviele Schritte der Servomotor fahren soll const int SERVO_STEPS = 20; void setup() { //beginn der seriellen Kommunikation mit 9600 baud Serial.begin(9600); softwareSerial.begin(9600); //verbinden des Pins des Servomotors mit dem Servoobjekt servo.attach(servoPin); //anfahren der Position 0 servo.write(servoPosition); } void loop() { //Wenn Daten an der seriellen Schnittstelle //anliegen, dann... if (softwareSerial.available() > 0) { //lesen der gesamten Zeile String data = softwareSerial.readString(); //entfernen der unnötigen Leerzeichen //am Anfang und Ende data.trim(); //Ausgeben der empfangenen Daten auf //dem seriellen Monitor der Arduino IDE Serial.println(data); //Variable zum speichern der neuen Servoposition int newServoPosition = 0; //Soll der Wert auf oder ab gezählt werden? bool countUp = false; //Wenn der empfange Wert "A" ist UND //die aktuelle Servoposition kleiner als 180 ist, dann... if (data == "A" && servoPosition < 180) { //der aktuellen Servoposition die Schritte welche gefahren //werden sollen hinzu addieren newServoPosition = servoPosition + SERVO_STEPS; //das Feld countUp auf true setzen, //so das später das Feld um 1 incrementiert wird countUp = true; } else if (data = "B" && servoPosition > SERVO_STEPS) { //Wenn jedoch ein "B" empfangen wurde UND die //aktuelle Servoposition größer als die Schritte die gefahren werden sollen //ist, dann soll dieser Wert abgezogen werden newServoPosition = servoPosition - SERVO_STEPS; //die Variable countUp wird hier nicht manipuliert / verändert, da //wir diese bereits mit false initialisiert haben } //Schleife, sollange der Wert von servoPosition ungleich des Wertes //der Variable newServoPosition ist, mache... while (servoPosition != newServoPosition) { //prüfen in welche richtung die Variable verändert werden soll if (countUp) { servoPosition = servoPosition + 1; } else { servoPosition = servoPosition - 1; } //anfahren von einem Grad servo.write(servoPosition); //eine kleine Pause von 25 ms. delay(25); //ausgeben der neuen Servoposition auf dem seriellen Monitor Serial.println(servoPosition); } } }

Regeln der Helligkeit einer LED am Arduino mit dem Lichtintensitätssensor vom Calliope Mini

Der Lichtintensitätssensor vom Calliope Mini 3 liefert Werte in bereich von bis 255 das passt sehr gut auf den Wertebereich eines PWM Signals mit welchem wir sehr einfach die Helligkeit einer LED regeln können.

Wenn wir mit einer Taschenlampe auf die LED Matrix leuchten dann erhöht sich der Wert bis zu einem maximum von 255. MakeCode Programm zum seriellen senden der gelesenen Lichtstärke Hier das kleine Programm zum auslesen der Lichtstärke am Calliope Mini 3 und absenden über die serielle Schnittstelle.

Und natürlich das Programm als HEX-Datei zum download und importieren in MakeCode. Programm - lesen und senden der Lichtstärke am Calliope Mini 3 über die serielle SchnittstelleHerunterladen Arduino Code zum setzen eines PWM Signals an einer LED Da der Wert vom Lichtintensitätssensor vom Calliope Mini einen Wert zwischen 0 und 255 liefert können wir diesen 1:1 für unser PWM Signal verwenden und müssen diesen hier lediglich nur empfangen und der LED aks analogen Wert zuweisen. #include #include //die LED ist am digitalen PWM Pin 9 angeschlossen #define led 9 // RX, TX SoftwareSerial softwareSerial(10, 11); void setup() { //beginn der seriellen Kommunikation mit 9600 baud Serial.begin(9600); softwareSerial.begin(9600); //Pin der LED als Ausgang definieren pinMode(led, OUTPUT); } void loop() { //Wenn Daten an der seriellen Schnittstelle //anliegen, dann... if (softwareSerial.available() > 0) { //lesen der gesamten Zeile String data = softwareSerial.readString(); //entfernen der unnötigen Leerzeichen //am Anfang und Ende data.trim(); //Ausgeben der empfangenen Daten auf //dem seriellen Monitor der Arduino IDE Serial.println(data); //schreiben des empfangenen Wertes als PWM Signal auf den Pin der LED //mit der Funktion toInt() wird die Zeichenkette in eine Zahl umgewandelt analogWrite(led, data.toInt()); } } Read the full article

[draegerit]

Scratch & Arduino UNO R3 für Programmieranfänger: Eine einfache Einführung

Komm mit auf eine faszinierende Reise in die Welt der Programmierung! In diesem Beitrag werde ich dir zeigen, wie du mit Scratch und Arduino UNO R3 spielerisch programmieren lernen und eigene interaktive Projekte erstellen kannst. Scratch ist eine einfache visuelle Programmiersprache, während der Arduino UNO R3 dein Projekt mit der physischen Welt verbindet. Entdecke, wie du mit diesen Tools deine Kreativität entfalten kannst und welche Materialien du dafür benötigst. Bist du bereit für dieses aufregende Abenteuer?

Die bunte Entwicklungsumgebung Scratch hatte ich dir bereits im ersten Teil Programmieren lernen mit Scratch (Teil1) vorgestellt. Hier möchte ich dir nun aufzeigen, wie einfach du auch damit einen Mikrocontroller programmieren kannst und somit in die Welt der Elektronik einsteigen kannst.

Was ist Scratch?

Scratch, eine kostenlose Programmierumgebung, entstand an der renommierten MIT-Universität in Massachusetts und wurde 2007 veröffentlicht. Die benutzerfreundliche Software mit ihrem ansprechenden Design ermöglicht Anfängern einen spielerischen Einstieg in die Programmierung. Von einfachen Animationen bis hin zu komplexen Spielen und Simulationen sind vielfältige Projekte möglich.

Scratch 3

Was wird für diesen Beitrag benötigt?

Wenn du die nachfolgenden Schritte zur Installation & Konfiguration sowie die Schaltungen nachstellen möchtest, dann benötigst du: - einen PC oder Laptop mit Microsoft Windows, macOS oder Linux, - einen Arduino UNO R3, - ein USB-Datenkabel, Für die Schaltungen benötigst du noch zusätzlich: - drei LEDs (rot, gelb, grün), - drei Vorwiderstände, - Breadboardkabel, männlich - männlich, 10 cm, - ein 400 Pin Breadboard

Modellvarianten des Arduino UNO R3

Den Mikrocontroller Arduino UNO R3 bekommst du original im Shop unter https://store.arduino.cc/collections/boards für derzeit 24 € zzgl. Versandkosten. Wenn du etwas sparen möchtest, dann kannst du auch zu den China Klonen auf ebay.de oder aliexpress.com greifen. Diese stehen dem Original in nichts nach und haben manchmal sogar noch ein paar zusätzlich Features zum deutlich günstigeren Preis.

Firmware für den Arduino UNO R3

Um einen Mikrocontroller wie den Arduino UNO R3 zu programmieren, müssen wir zusätzlich eine neue Firmware auf diesen installieren. Wenn wir dieses getan haben, dann können wir mit der Erweiterung S4A - "Scratch for Arduino" den Mikrocontroller programmieren. Aufspielen der Firmware auf den Mikrocontroller Die aktuelle Firmware für Scratch for Arduino findest du unter http://s4a.cat/ als INO-Datei. Damit du wiederum diese Datei aufspielen kannst, musst du die Arduino IDE installiert haben (egal ob Klassik oder die neue Version 2.x).

Einrichten von Scratch und erstellen von einem Programm

Im nachfolgenden YouTube-Video erläutere ich dir, wie du Scratch für den Arduino UNO installierst und ein erstes kleines Programm erstellst. https://youtu.be/07HRGyIhXZI

Programmieren in Scratch

Wenn du meinen Blog bereits verfolgst, dann werden dir die Beiträge zum Open Roberta Lab, DUINO EDU bekannt sein, wenn nicht, dann auch nicht schlimm. Was diesen drei Tools gemeinsam haben ist, dass du quasi keine Zeile Code schreiben musst, sondern lediglich grafische Elemente zusammenklicken musst.

Fenster - Scratch für Arduino Beispiel - Blinken der internen LED Fangen wir mit einem Klassiker an, dem Blinken der internen LED (Pin 13) am Arduino UNO.

Ein Programm starten wir damit, dass wir auf die grüne Flagge rechts oben klicken. (Durch das Klicken auf das rote Stopp-Symbol wird das Programm beendet.)

Ggf. kennst du bereits ein Arduino Code, in welchen du die Funktionen Setup & Loop gesehen hast. Die Loop ist eine Funktion, welche fortlaufend ausgeführt wird. In Scratch ist dieses der Block "wiederhole fortlaufend".

Die interne LED ist am digitalen Pin D13 angeschlossen, in Scratch findest du dazu einen Block, mit welchen du einen solchen Pin AN/AUS schalten kannst.

Zwischen den Schritten des einschalten und ausschalten der LED schieben wir jedes Mal den Block zum Warten von einer Sekunde. Hier nun das fertige, kleine Programm.

Programm - blinken der internen LED am Pin 13 Und hier zum Download als SB-Datei zum Öffnen in Scratch für Arduino. Scratch für Arduino (S4A) - Beispiel interne LED blinken lassenHerunterladen

Fazit & Ausblick

Abschließend lässt sich sagen, dass Scratch für Arduino UNO R3 ein vielversprechendes Tool ist, das jedoch noch einige Verbesserungen und Ergänzungen benötigt, um mit anderen ähnlichen Programmen mithalten zu können. Obwohl die Bedienung im Vergleich zu ArduBlock, DUINO EDU und Open Roberta Lab etwas komplizierter ist und nicht alle erforderlichen Blöcke zur Ansteuerung von Sensoren und Aktoren vorhanden sind, bietet Scratch für Arduino dennoch interessante Möglichkeiten. Trotz seiner derzeitigen Einschränkungen ist es eine Plattform, die es wert ist, genauer erkundet zu werden. Die intuitive visuelle Programmierung von Scratch ermöglicht es Anfängern und Fortgeschrittenen, spannende Projekte mit Arduino zu realisieren. Mit etwas Geduld und Experimentierfreude können Benutzer die vorhandenen Blöcke effektiv nutzen und auf kreative Weise eigene Lösungen entwickeln. Es ist zu hoffen, dass die Entwickler von Scratch für Arduino zukünftig weitere Funktionen und Blöcke hinzufügen, um das volle Potenzial dieser Kombination aus Scratch und Arduino auszuschöpfen. Wenn Sie also neugierig auf die Verbindung zwischen visueller Programmierung und der Welt der Mikrocontroller sind, lohnt es sich, regelmäßig vorbeizuschauen und zu sehen, wie sich das Tool weiterentwickelt. Insgesamt bietet Scratch für Arduino eine aufregende Möglichkeit, das Programmieren und die Elektronik zu erlernen und kreative Projekte umzusetzen. Halten Sie Ihren Blog im Auge, um über neue Entwicklungen und Updates zu Scratch für Arduino informiert zu bleiben und inspiriert zu werden, Ihre eigenen Innovationen mit dieser aufstrebenden Plattform zu teilen. Read the full article

[draegerit]

Open Roberta #11 - Flammensensor

Willkommen zu meinem neuesten Beitrag! Hier zeige ich dir, wie du den Grove Flammensensor mit dem Arduino UNO R3 verbindest und im Open Roberta Lab programmierst. Egal, ob du ein Anfänger oder fortgeschrittener Entwickler auf der Arduino-Plattform bist, dieser Artikel bietet dir wertvolle Informationen und praktische Beispiele, um den Flammensensor optimal zu nutzen. Dabei konzentrieren wir uns auf die Verwendung des Open Roberta Labs, und ich empfehle dir den Chrome Browser als ideale Softwareumgebung. Tauche mit mir ein in die spannende Welt des Flammensensors und entdecke, wie du ihn für deine eigenen Projekte einsetzen kannst.

Der Flammensensor verfügt auf der Platine über ein Drehpotentiometer, über welchem man die Empfindlichkeit einstellen kann (760 nm bis 1100 nm).

Dieser digitale Sensor kann dann als Schalter verwendet werden, also wie auch beim Grove Regensensor / Wasser Sensor.

Wo kann ich den Grove Flammensensor einsetzen?

Mit diesem Sensor kannst du erkennen, ob die Flamme an einem Gasherd an ist oder deine Gastherme überwachen (jedoch hat letztere eine eigene Steuerung mit einem eigenen Sensor). Du kannst dir natürlich damit auch eine kleine Schaltung aufbauen und diesen Sensor als versteckten Schalter verwenden, denn wer würde auf die Idee kommen, ein Gerät mit einem Feuerzeug zu aktivieren?

Technische Daten des Grove Flammensensor von Seeed Studio

Hier nun die technischen Daten, welche ich aus der offiziellen Dokumentation zu diesem Sensor entnommen habe. MINMAXTypischEinheitBetriebsspannung4.755.05.30V (DC)Stromaufnahme%mABereich der Spektralbandbreite7601100940nmErfassungsbereich01~mAntwortzeit%μSUmgebungstemperatur-2585~°C

Aufbau einer Schaltung und programmieren in Open Roberta Lab

Im nachfolgenden YouTube-Video erläutere ich dir den Aufbau des Flammensensors und zeige dir, wie dieser im Open Roberta Lab programmiert wird. https://youtu.be/kLcZwoovgKI

Eine kleine Schaltung mit dem Grove Flammensensor am Arduino UNO R3

Bauen wir zunächst eine kleine Schaltung mit diesem Sensor auf. Ich möchte diesen Sensor als versteckten Schalter nutzen und damit ein Relais schalten. Über dieses Relais könnte dann wieder ein Verbraucher (max. 16 A bei 220 V) geschaltet werden.

Schaltung - Arduino UNO mit Flammensensor & Relaisshield In der Schaltung verwende ich den normalen Flammensensor KY-026 & ein Relaisshield. Der Vorteil von Grove Shields / Modulen ist, dass du diese Sensoren / Aktoren mit einem Kabel an den Arduino anschließen kannst.

Programmieren vom Grove Flammensensor in Open Roberta Lab

Nachdem die Schaltung nun fertig ist, können wir mit der Programmierung beginnen. Zuerst müssen wir wie zuvor auch die Schaltung in dem Reiter "Roboterkonfiguration" nachbauen und danach können wir das Programm erstellen.

Open Roberta Lab - Roboterkonfiguration für das Beispiel mit dem Flammensensor Ich habe zusätzlich noch eine LED in die Schaltung integriert, denn so erkennt man eher, ob das Relais angezogen ist. Durch das E-Feuerzeug, welches selber beim Betätigen ein lautes Geräusch von sich gibt, übertönt dieses das Relais.

Open Roberta Lab - Programm zum aktivieren eines Relais & LED mit einem Flammensensor Hier nun das kleine Programm zum Download und Import als XML-Datei in Open Roberta Lab. Open Roberta Lab - Grove_Flammensensor zum aktivieren eines RelaisHerunterladen 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]

Arduino UNO R4 Minima vs. Arduino UNO R3: Was ist neu?

In diesem Beitrag möchte ich einen Vergleich zwischen dem Arduino UNO R4 Minima und dem UNO R3 vorstellen. Der Arduino UNO R3 ist bereits seit mehreren Jahren erhältlich und wurde oft kopiert, wodurch diverse Versionen von anderen Herstellern verfügbar sind. Der Arduino UNO R4 Minima hingegen ist seit Ende Juni 2023 exklusiv im Arduino Store erhältlich. Du kannst den Arduino UNO R4 Minima am besten mit dem Arduino UNO R3 vergleichen, da ihre Features sehr ähnlich sind. Schaue selbst und entdecke die Unterschiede zwischen ihnen.

Auf diesem Blog habe ich bereits zahlreiche Beiträge dem Arduino UNO R3 gewidmet und dir detailliert gezeigt, wie du ihn programmieren kannst. In diesem Artikel steht jedoch zunächst ein Vergleich im Fokus. In den kommenden Tagen werde ich speziell auf den Arduino UNO R4 Minima zugeschnittene Projekte veröffentlichen, die du aufmerksam verfolgen kannst.

Arduino UNO R4 Minima

Arduino UNO R3 Den beiden neuen Arduino's UNO R4 Minima & WiFi habe ich bereits im ersten Teil kurz und knapp vorgestellt.

Bezug des Arduino UNO R4 Minima

Wie bereits erwähnt, ist der Mikrocontroller Arduino UNO R4 Minima derzeit (stand 05.07.2023) exklusiv im Onlineshop Arduino.cc erhältlich. Der Preis mit 18 € ist recht günstig für einen neuen Mikrocontroller der Arduino-Familie. Die Versandkosten belaufen sich auf ganze 5 € per UPS und somit kommt man am Ende auf 23 € für diesen Mikrocontroller.

Lieferumfang

Zum Lieferumfang des Mikrocontrollers gehört ein kleiner Satz Aufkleber, ein Garantiezettel sowie eine transparente Acrylplatte für die Montage unter dem Mikrocontroller.

Lieferumfang - Arduino UNO R4 Minima Preisvergleich mit dem Arduino UNO R3 Der Arduino UNO R3 kostet im Onlineshop derzeit 24 € und somit deutlich mehr als der neue R4 Minima. Das könnte natürlich auch gewollt sein, um den neuen Mikrocontroller zu pushen. Die China-Klone des Arduino UNO R3 kosten weit weniger als das Original und können mit diesem sehr gut mithalten. Daher freue ich mich, wenn es die ersten günstigen vom R4 Minima geben wird.

Vergleich der Features vom Arduino UNO R4 & R3

Kommen wir zunächst zum Vergleich der technischen Daten beider Mikrocontroller: Arduino UNO R4 MinimaArduino UNO R3MicrocontrollerRenesas RA4M1 (ARM cortex-M4)ATmega328PTaktgeschwindigkeit48 MHz16 MHzSpeicher256 kB Flash, 32 kB RAM32 kB Flash, 2 kB SRAMSchnittstellenUART, I2C, SPI, CANUART, I2C, SPIUSB-SchnittstelleUSB-Typ-CUSB-Typ-Bdigitale Pins14 (davon 6 PWM Pins)analoge Pins6Eingangsspannung6-24 V6-20VSpannung an den Pins5 V5 Vmax. Stromaufnahme per Pin8 mA20 mAFeaturesBuiltin-LED am digitalen Pin D13Abmessungen (L x B)68,85 mm x 53,34 mm Wir können aus dieser Tabelle entnehmen, dass der neue Arduino UNO R4 Minima eine dreifach höhere Taktgeschwindigkeit und einen achtfach größeren Speicher hat. Besonders zu nennen ist, dass dieser Mikrocontroller noch zusätzlich über eine USB-Typ-C Schnittstelle verfügt und somit die recht betagte USB-Typ-B Schnittstelle ablöst. Vor allem, weil die Kabel ja nun ebenso langsam aussortiert werden können. Erhöhte Toleranz der Eingangsspannung Der Arduino UNO R4 Minima verfügt über eine erweiterte 24-V-Toleranz für einen größeren Eingangsspannungsbereich. Dadurch können Sie Stromversorgungen bis zu 24 V nutzen und problemlos Motoren, LED-Streifen und andere Aktoren integrieren. Die Verwendung einer einzigen Stromquelle vereinfacht Ihre Projekte erheblich. Praktische HID-Integration: Arduino UNO R4 Minima als Maus oder Tastatur verwenden Der Arduino UNO R4 Minima bietet eine eingebaute HID-Unterstützung (Human Interface Device), die es ermöglicht, eine Maus oder Tastatur zu simulieren, wenn er über ein USB-Kabel mit einem Computer verbunden ist. Diese praktische Funktion ermöglicht das Senden von Tastenanschlägen und Mausbewegungen an den Computer und verbessert somit die Benutzerfreundlichkeit und Funktionalität.

Programmieren der beiden Mikrocontroller in der Arduino IDE

Um den Arduino UNO R4 zu nutzen, benötigen wir einen Boardtreiber. In der Arduino IDE 2.0 können wir diesen Treiber über den internen Boardmanager installieren. Hierfür klicken wir auf das entsprechende Symbol (1) und suchen nach "arduino uno r4" (2). Anschließend betätigen wir die "INSTALL" Schaltfläche (3). Nach der Installation ändert sich die Schaltfläche zu "REMOVE" und es wird ein Versions-Tag (4) angezeigt. So können wir den Treiber erfolgreich installieren und verwenden.

Beide Boards haben eine integrierte LED, die jeweils am digitalen Pin D13 angeschlossen und programmiert werden kann. In unserem ersten Beitrag werden wir diese kleine SMD-LED zum Blinken bringen. //die SMD-LED ist am digitalen Pin D13 angeschlossen #define led LED_BUILTIN void setup() { //definieren das der Pin der LED als Ausgang dient pinMode(led, OUTPUT); } void loop() { //aktivieren der LED digitalWrite(led, HIGH); //eine kleine Pause von 500 Millisekunden delay(500); //deaktivieren der LED digitalWrite(led, LOW); //eine kleine Pause von 500 Millisekunden delay(500); } Schauen wir uns einmal die Speicherbelegung auf dem Mikrocontroller genauer an: Programmspeicherplatzmax. ProgrammspeicherplatzBelegung globale Variablenmax. Speicherplatz für globale VariablenArduino UNO R4 Minima33576 Byte262144 Byte2524 Byte32768 ByteArduino UNO R3924 Byte32256 Byte9 Byte2048 Byte Speicherbelegung von Datentypen Bei genauer Betrachtung der Speicherbelegung von Datentypen wird deutlich, warum der UNO R4 mehr Programmspeicherplatz benötigt. (Aber dafür haben wir ja deutlich mehr Speicherplatz.) Der UNO R4 Minima ist ein 32bit System, der UNO R3 lediglich ein 8bit System, daher ist auch die Speicherlegung der Datentypen anders. Arduino UNO R3Arduino UNO R4 Minimabool1 Byte1 Byteshort2 Byte2 Byteint2 Byte4 Bytelong4 Byte4 Bytefloat4 Byte4 Bytedouble4 Byte8 Bytechar1 Byte1 ByteString6 Byte12 Byte

Abschluss

Der neue Arduino UNO R4 Minima bietet zahlreiche Vorteile gegenüber dem UNO R3. Mit einem größeren Speicherplatz und zusätzlichen Debugging-Schnittstellen eröffnet er neue Möglichkeiten für anspruchsvolle Projekte. Die höhere Taktgeschwindigkeit stellt ebenfalls einen Vorteil dar, auch wenn mir bisher die 16 MHz des UNO R3 nicht negativ aufgefallen sind. Als Nächstes werde ich den Arduino UNO R4 WiFi genauer untersuchen, der mit einem zusätzlichen ESP32 S3 aufwartet. Freue dich auch auf maßgeschneiderte Projekte, die speziell für diesen Mikrocontroller entwickelt wurden. Entdecke die spannenden Potenziale des Arduino UNO R4 Minima! Read the full article