#arduinoplugandmakekit

Im neuen Dialog kannst du oben dem neuen Sketch einen Namen vergeben (39) und findest den Hinweis auf den verknüpfen Mikrocontroller (40). Über die Schaltfläche "Upload" (41) kannst du dein Sketch auf den Mikrocontroller überspielen. Den nachfolgenden Code kopieren wir in das Fenster vom Sketch. Wenn du deine Variablen wie hier im Beitrag benannt hast, dann sollte dieser 1:1 funktionieren. #include // Bibliothek für das Modulino-Framework, das Sensoren und Taster unterstützt. #include "thingProperties.h" // Enthält die Konfiguration der Arduino Cloud Eigenschaften. #define indicatorLED 13 // Definiert die LED an Pin 13 zur Statusanzeige. ModulinoThermo umweltsensor; // Objekt für den Umweltsensor (Temperatur und Luftfeuchtigkeit). ModulinoButtons taster; // Objekt für das Taster-Modul. const int TASTER_A = 0; // Pin-Definition für den Taster A. long lastAction = -1; // Speichert den letzten Zeitpunkt einer Aktion. const int PAUSE = 2500; // Zeitspanne (in ms) zwischen zwei Aktionen. void setup() { Serial.begin(9600); // Initialisiert die serielle Kommunikation mit 9600 Baud. delay(1500); // Wartet 1,5 Sekunden, um den Mikrocontroller zu stabilisieren. initProperties(); // Konfiguriert die Cloud-Variablen und definiert, wie diese behandelt werden (Lesen, Schreiben, Callback-Funktionen bei Änderungen). ArduinoCloud.begin(ArduinoIoTPreferredConnection); // Startet die Verbindung zur Arduino Cloud über die bevorzugte Verbindungsmethode. setDebugMessageLevel(2); // Setzt die Debug-Ebene für detailliertere Nachrichten. ArduinoCloud.printDebugInfo(); // Gibt Debug-Informationen zur Arduino Cloud-Verbindung aus. Modulino.begin(); // Initialisiert das Modulino-System. umweltsensor.begin(); // Startet den Umweltsensor. taster.begin(); // Startet das Taster-Modul. } void loop() { ArduinoCloud.update(); // Aktualisiert die Verbindung zur Arduino Cloud, um Daten zu synchronisieren. long currentMillis = millis(); // Holt die aktuelle Zeit in Millisekunden seit Start. if (currentMillis > (lastAction + PAUSE)) { // Führt die folgenden Aktionen nur alle 2,5 Sekunden aus. lastAction = currentMillis; if (active) { // Wenn die Wetterstation aktiv ist: temperatur = umweltsensor.getTemperature(); // Liest die Temperatur vom Sensor aus und speichert sie in der Cloud-Variable. humidity = umweltsensor.getHumidity(); // Liest die Luftfeuchtigkeit vom Sensor aus und speichert sie in der Cloud-Variable. } } if (taster.update() && taster.isPressed(TASTER_A)) { // Prüft, ob der Taster aktualisiert wurde und Taster A gedrückt ist. active = !active; // Wechselt den Status der Wetterstation (aktiv/inaktiv). onActiveChange(); // Ruft die Funktion auf, die auf Änderungen der "active"-Variable reagiert. } delay(50); // Fügt eine kurze Pause ein, um die Schleife zu stabilisieren. } void onTemperaturChange() { // Funktion wird aufgerufen, wenn sich die Temperatur in der Arduino Cloud ändert. } void onHumidityChange() { // Funktion wird aufgerufen, wenn sich die Luftfeuchtigkeit in der Arduino Cloud ändert. } void onActiveChange() { digitalWrite(indicatorLED, active); // Schaltet die Status-LED basierend auf dem "active"-Status ein oder aus. } Schritt 5 - Upload & Test Sobald du den Sketch auf den Mikrocontroller hochgeladen hast werden deine Daten übertragen und im Dashboard visualisiert. smarte Wetterstation - Arduino Cloud Read the full article

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

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

Programm: Anzeigen der Richtung des Modulino Movement an der LED-Matrix des Arduino UNO R4 WiFiHerunterladen #include "Modulino.h" #include "Arduino_LED_Matrix.h" #include "frames.h" ModulinoMovement movement; ArduinoLEDMatrix matrix; float x, y, z; float difference = 0.3; const int ROWS = 8; const int COLS = 12; const int PAUSE = 200; void setup() { Serial.begin(9600); Modulino.begin(); movement.begin(); matrix.begin(); } void loop() { movement.update(); x = movement.getX(); y = movement.getY(); z = movement.getZ(); if (abs(x) >= 0 && abs(x) = 0 && abs(y) = abs(y)) { if (x > 0) { matrix.renderBitmap(pfeilRechts, ROWS, COLS); } else { matrix.renderBitmap(pfeilLinks, ROWS, COLS); } } else if (abs(y) >= abs(x)) { if (y > 0) { matrix.renderBitmap(pfeilVorne, ROWS, COLS); } else { matrix.renderBitmap(pfeilHinten, ROWS, COLS); } } delay(PAUSE); } Read the full article

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