#Modulino

[draegerit]

Regentropfen-Jagd: Ein einfaches Arduino-Spiel

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

Benötigte Ressourcen für dieses Projekt

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

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

Alternativ kannst du das kleine Spiel auch mit zwei Taster aufbauen und programmieren, dann benötigst du: - zwei Taster*, - zwei 10 kOhm Widerstände*, - ein Piezo Buzzer*, - diverse Breadboardkabel*, - ein 400 Pin Breadboard* Hinweis von mir: Die mit einem Sternchen (*) markierten Links sind Affiliate-Links. Wenn du über diese Links einkaufst, erhalte ich eine kleine Provision, die dazu beiträgt, diesen Blog zu unterstützen. Der Preis für dich bleibt dabei unverändert. Vielen Dank für deine Unterstützung!

Aufbau der kleinen Schaltung mit dem Arduino Plug and Make Kit

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

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

Programmieren des Spieles in der Arduino IDE

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

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

Alternativer Aufbau & Programmierung mit Taster am Arduino

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

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

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

[jazzluca]

STEELJAW ( Core ) Movie Studio Series 86

Sdoganata ormai la nuova tendenza di far uscire i vari Cassettebot singolarmente come Core Class, ecco arrivare il buon STEELJAW, il leone giallo di Blaster ed esordito col resto dei colleghi nel film del 1986, e quindi di conseguenza nella linea Studio Series 86.

Come MICROCASSETTA non si presenta però benissimo, con un disguise non così efficace nell'unico lato che di solito dovrebbe richiamare la modalità alternativa, come accade sin dai cassettebot G1 originali, dato che si vedono abbastanza bene le due armi che finiranno sulle cosce del leone robotico e pure le due metà della testa, ma questo direi che è anche il minimo.

Quello che davvero rovina la magia, nonostante il dettaglio centrale che simula il vetrino cui si intravede il nastro interno della cassetta, sono i due fori, che non sono proprio tali ma appena scavati, di cui UNO SOLO è colorato di grigio e l'altro no!

Da quel che ne so, ci sono parti di plastica che non è possibile dipingere, da cui deduco l'eventuale motivo per cui un foro non sia dipinto, sito evidentemente in tal tipo di plastica, MA l'effetto così è davvero brutto, e quasi quasi tanto valeva non dipingere di grigio l'altro, per non creare questa asimmetria.

Però, perlomeno, messo adeguatamente all'interno del vano del petto di Blaster, il "foro" grigio s'intravede attraverso il vetro e fa la sua figura, dai. ^^'

La TRASFORMAZIONE è completamente diversa dal Fender originale del 1986, non più con la cassetta in in piedi ma ora sdraiata, cosa già vista nei vari Ravage Generations e Masterpiece negli ultimi anni, con le due metà del muso che spuntano dai lati a sinistra per poi ripiegarsi ed unirsi, formando così testa e criniera, che si solleva, mentre le zampe posteriori e quindi le anteriori si abbassano prendendo posizione.

In teoria potrebbe anche bastare così, dato che il LEONE robotico è grossomodo bello che formato, con una criniera bella ampia che ricorda il settei del cartone e con tanto di laser sulle cosce già annessi e pure direzionabili, ma effettivamente mancherebbe ALMENO una cosa, ovvero la coda, che potevano anche mettercela, piccina e ripiegabile, ma invece c'è sul… sedere di Steeljaw un'articolazione un po' inutile che forse serve per fargli divaricare un po' le zampe posteriori.

Ed a proposito di articolazioni il nostro ha appunto le armi mobili e le zampine che si muovono solo frontalmente a livello di spalle ed anche, così come la testa può abbassarsi, ma appunto a venire incontro all'estetica del leone robotico ci pensa un apposito modulo con un po' di schiena, la coda e le due ali ( queste due separabili ) che nel G1 erano parti delle due armi staccabili.

Da una parte quindi abbiamo il leone alato ora completo, dall'altra però abbiamo un accessorio partformer che nella cassettina in se' non troverebbe posto, ma qui diciamo viene in soccorso Blaster stesso, che in quanto Generations WfC e Legacy contemporaneamente, ha parecchi fori per armi sparsi nel corpo e quindi vi si può alloggiare il modulo alato quando Fender magari è nel vano cassette di Radiorobot.

Ma "per fortuna" S.J. seppur piccino come cassettebot nella classe Core, come già i suoi colleghi Decepticon Rumble e compagnia, ha un accessorio in più, ovvero un'ALTOPARLANTE che serve più che altro al suo padrone Blaster per sistemarglielo su una mano, citando così una scena dei cartoni dove Radiorobot esibiva questa funzionalità per espletare i suoi poteri sonori.

Ma, facendo finta che questo accessorio possa essere usato anche da Steeljaw stesso, ecco che abbiamo un ulteriore apposito modulino che va a sostituire quello alato della schiena e che serve da tramite per potervi sistemare l'altoparlante sul nostro leone robotico.

Visto che sostituisce le ali, si può credere che questi si "trasformino" nell'altoparlante, e ok, ma più che altro è il modulino in se' che è ridondante, dato che è un altro cosino che va nascosto su Blaster, quindi tanto valeva mettere un perno direttamente sulla schiena alata e amen.

Certo, visto il prezzo da Core e la piccolezza del cassettebot, meglio un po' di massa in più che no, ma a sto punto potevano invece recuperare, ad esempio, le due armi di Eject e Rewind, che non metterci il modulino per l'altoparlante.

Infine, belli i dettagli degli occhietti azzurri e dell'interno della bocca rossa, così come i "fori" farlocchi sulla criniera grigio scuri, e se da una parte ali e fucili sono dorati come nel settei, peccato che il corpo del leone sia tutto giallo ma senza gli stinchi delle zampe grigie come nel giocattolo originale che nel settei del cartone.

Insomma, ovviamente acquisto doveroso per chi vuol completare la famigliola di Blaster, anche se fa un po' storcere naso il discorso del partforming, sopratutto quello del succitato modulino, ma più che altro speriamo che non salti fuori in un altro eventuale pack con altre migliorie o che, visto che è da Siege che sti cassettebot li stanno aggiornando un po' troppo frettolosamente, e quindi magari per avere Ramhorn o altre versioni dei suoi colleghi ci faranno ricomprare lui o Blaster per l'ennesima volta. Speriamo bene! ^^'

-Videorecensione

[letraindemanu]

Talents : les beaux véhicules routiers de Keta Boulet

Talents : les beaux véhicules routiers de Keta Boulet

Episode 378 • Keta est un modéliste rencontré dans les locaux du Club ferroviaire Noiséen qui s’est lancé dans la conception de modèles routiers en impression 3D. Les prototypes qu’il m’a présenté sont de toute beauté. C’est lors d’une de mes visites au Club ferroviaire Noiséen (CFN93), basé à Noisy-le-Sec (Seine-Saint-Denis), que j’ai fait la connaissance de Keta Boulet. Ce modéliste…

[spaccio-kagehina]

Modulino carino carino lool

https://docs.google.com/forms/d/1iSBJBHx1q1fA4inpsugjLeVfQUqJyVFsiLwZ9XDCWTg/viewform?edit_requested=true

[parolerandagie]

Io, tu, noi, voi, gli altri e le loro vite...

A vivere la vita degli altri, siamo tutti bravissimi.

Ci è sempre chiarissimo dove hanno sbagliato ed altrettanto sapremmo esattamente cosa fare per rimediare all’errore.

Le loro relazioni? Semplicissime da leggere, da vivere, da capire, da massimizzare in termini di felicità, ma anche chiaro, ci appare, quando andrebbero terminate e perché, o quando invece varrebbe la pena ostinarsi a continuare.

E casa loro, sapremmo noi come arredarla, così come sapremmo investire i loro risparmi, vestire decentemente i loro corpi, scegliere i regali natalizi per i loro cari, abbinare cravatte, allacciare scarpe, ordinare al ristorante, sapere cosa pensare di chi e di che cosa…insomma, fossimo anche uno ed uno solo degli altri, si spalancherebbe davanti a noi la pi�� felice, serena, compiuta e realizzata delle vite…

...ma allora, e concorderete con me, abbiamo l’Eden a portata di mano…

...basta scambiarsi le vite!

Ognuno di noi si scambia la vita con un altro, uno di quelli di cui la vita sapremmo vivere perfettamente, uno di quelli che ci pare non capire proprio come dovrebbe vivere mentre noi al posto suo…, uno di quelli che ci fanno indignare per quanto semplice sarebbe ed invece loro no.

Pensateci, anche matematicamente (o meglio, aritmeticamente) funzionerebbe, perché là fuori il numero di vite in giro è pari a quello degli individui…e contrattualmente basterebbe un modulino uguale per tutti, tipo noi sottoscritti, dalle ore icsedipsilon del giorno zetaevvudoppia, concordiamo sullo scambiarci le vite (dal PIN del Bancomat alla password di Netflix, passando per il profilo Facebook e la tessera punti della Coop)…due firme e via…fatto…

....insomma, siamo ad una firma dall’estasi e dalla soddisfazione perenne!

Sicuro di trovarvi d’accordo, attendo proposte di scambio, telefonare ore pasti, no perditempo.

[10lustri]

Mi domando quanti anni sono che non prendo il caffè a letto

Ricordo bene che l’ultima volta è stato in albergo dove ero per lavoro. Ci avevano comunicato la sera prima che l’appuntamento era spostato dalle 8:30 alle 11, e così, prima di addormentarmi avevo compilato il modulino della richiesta della colazione in camera. Un extra non coperto dalle spese rimborsabili, ma come recita il proverbio "vale più un gusto che un casale" ...e poi che si hanno a fare i soldi se non per prendersi un piacere ogni tanto, i soldi mica esistono solo per la bolletta della luce o del gas o per nutrire e crescere i figli. Dicevo dell'albergo: ordinai una colazione americana con uova strapazzate, niente bacon che di mattina lo trovo troppo forte e al suo posto prosciutto, mortadella, formaggio, toast, una spremuta d’arancia rossa, caffè americano e, naturalmente,  un espresso.

Il piacere l'ho preso tutto. Dopo aver ritirato la colazione mi rimisi nel letto, e per prima cosa bevvi l'espresso, altrimenti si sarebbe freddato, sorseggiandolo senza zucchero per sentirne l’aroma. Solo dopo mi son dedicato alla ricca e inusuale colazione e infine una doccia bollente quasi a ratificare mattina di lusso e pigrizia.

Indubbiamente un bel ricordo... però... però non è la stessa cosa di quando ti portano il caffè a letto, tra l’altro non devi alzarti e arrivare alla porta ad aprire al cameriere. 

Il caffè a letto ti arriva che ancora dormi un sonno nel quale confusamente hai sentito i rumori della cucina, la moka che veniva caricata, il fornello acceso, il caffè che uscendo soffiava il proprio profumo. E poi, come in una continuazione del sogno che stai facendo, il caffè arriva.  Apri un occhio, ti scosti un po' al centro del letto per permettere a lei che ti sta portando il caffè di sedersi. Prendi il secondo cuscino lo metti dietro la schiena insieme al tuo e con uno sforzo sovrumano ti metti seduto. Poi con le mani ancora addormentate prendi la tua tazzina fumante, ringrazi con uno sguardo carico di dedizione e sorseggi lentamente il tuo caffè. Guardando lei che analogamente a te lo beve, seduta al lato del letto con indosso la tua camicia, le gambe accavallate, lo sguardo fuori oltre la finestra a scoprire il mondo che si sveglia.

E mentre beve il caffè può capitare che, facendo finta di nulla, con il suo sguardo apparente perso oltre il vetro che vi separa dal resto del mondo, lei poggi la sua mano sinistra sulla tua coscia, quasi a ricercare un equilibrio tra il materasso e la tazzina del caffè tenuta dalla mano destra.  E può capitare che impercettibilmente tu sposti la tua gamba sinistra, proprio quella gamba dove lei, accarezzandototi lievissimamente, tiene poggiata la sua mano, sposti quella tua gamba ancor più verso sinistra, verso quel bordo del letto dove lei è seduta fino a sfiorarle delicatamente la schiena e dandole la possibilità  di appoggiarsi.  

Da quel caffè, e da quei due leggeri contatti può nascere un mondo. 

[tuttinfascioteca]

Buongiorno 😃 A richiesta lascio Ethen aperto fino alle 12.00 di oggi 🥰 ➡️totali Pura 💦 in arrivo tramite e-mail 📧 Maaaaaa il modulino per i calzini 🧦 più matti del mondo lo avete già visto?!🤭 A partire dal numero 23 Adulto&Bambino ❤️anche in abbinamento ❤️ (presso Tuttinfascioteca) https://www.instagram.com/p/CKvbNfNlnz-/?igshid=r1h1qzu1kf03

[impetuswave]

Ideas to actively work with

[hellowhatisnewposts]

Modulino: both script and module in Perl 3 by fanf2 |

[draegerit]

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

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

6 Achsen Lagesensor via Qwiic Schnittstelle am Arduino UNO R4 WiFi

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

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

Ziel dieses IoT-Projektes

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

Arduino UNO R4 WiFi

Arduino UNO R4 WiFi

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

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

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

Sensoren & Aktoren Hinweis von mir: Die mit einem Sternchen (*) markierten Links sind Affiliate-Links. Wenn du über diese Links einkaufst, erhalte ich eine kleine Provision, die dazu beiträgt, diesen Blog zu unterstützen. Der Preis für dich bleibt dabei unverändert. Vielen Dank für deine Unterstützung! ** Der E26 Sockel sowie die Zuleitung, bekommst du im örtlichen Baumarkt sehr günstig und daher kann ich dir hier keinen günstigen Link zum kauf anbieten.

Aufbau der Schaltung

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

Arduino & Shelly DUO Lampe

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

Regeln der Shelly DUO Lampe über den Arduino

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

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

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

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

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

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

[newseveryhourly]

In the Python world it is quite straight forward to make files work either as executables or as modules. In Perl it is a bit strange, but doable. http://ift.tt/2BFkQjc

[draegerit]

Einsteigerprojekt: Pixel Chaser mit dem Arduino Plug and Make Kit

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

Wie funktioniert das Spiel - Pixel Chaser?

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

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

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

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

Programmieren in der Arduino IDE

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

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

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

[draegerit]

Arduino Plug and Make Kit: Abstandskontrolle mit Alarmfunktion

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

Arduino UNO R4 WiFi

ToF - Distance Sensor

Buzzer

8fach LED Modul

Rotary Encoder

Wie soll das kleine Projekt funktionieren?

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

Benötigte Ressourcen für den Aufbau

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

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

Programmieren der Modulino Sensoren / Aktoren in der Ardino IDE

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

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

[draegerit]

Arduino Plug and Make Kit: Richtungsanzeige mit Modulino Movement

Das neue Arduino Plug and Make Kit habe ich dir bereits im passenden Beitrag vorgestellt, heute soll es um den Modulino Movement gehen, mit welchen man auf dem Arduino UNO R4 WiFi die Richtung anzeigen lassen kann. https://youtu.be/hbDoi3HJMIY Der Modulino Movement Sensor ist ein 6 Achsen Lagesensor vom Typ LSM6DSOXTR dieser verfügt über zwei Qwiic Schnittstellen, mit welche dieser direkt mit dem Mikrocontroller verbunden wird. Mit der zweiten Schnittstelle kannst du zusätzlich noch andere Sensoren / Aktoren anschließen. Die Sensoren / Aktoren werden via I2C angesprochen und verfügen somit jeweils über eine eindeutige Adresse.

Disclaimer: Ich habe das Arduino Plug and Make Kit für knapp 90 € (inklusive Versandkosten) selbst über den offiziellen Shop gekauft. Alle hier geäußerten Meinungen sind meine eigenen und wurden nicht von Arduino gesponsert oder beeinflusst.

Überblick über das Arduino Plug and Make Kit

Zum Lieferumfang des Arduino Plug and Make Kit gehört unteranderem die Sensoren / Aktoren: - Modulino Knob - ein Rotary Encoder mit Push Funktion, - Modulino Pixels - ein 8fach RGB LED Modul, - Modulino Distance - ein ToF Modul zum Messen von Entfernungen, - Modulino Movement - ein 6 Achsen Lagesensor, - Modulino Buzzer - ein Piezo Buzzer zum Erzeugen von Tönen, - Modulino Thermo - ein Sensor zum Messen von Temperatur & rel. Luftfeuchtigkeit, - Modulino Buttons - ein Modul mit 3 Taster

Arduino UNO R4 WiFi

3fach Taster Modul

Buzzer

Rotary Encoder

6 Achsen Sensor

Temperatur & rel. Luftfeuchtigkeits Sensor

ToF - Distance Sensor

8fach LED Modul Und natürlich gehört noch der Arduino UNO R4 WiFi dazu, welcher über die benötigte Qwiic Schnittstelle verfügt.

Aufbau der Schaltung - Arduino UNO R4 WiFi mit Modulino Movement Sensor

Die Schaltung ist recht schnell auf der Modulino Base aufgebaut, mithilfe der mitgelieferten Schrauben und Abstandshalter wird der Mikrocontroller an seinen Platz geschraubt und im unteren Bereich die Sensoren / Aktoren.

Arduino UNO R4 WiFi mit Modulino Movement Hier zeigt sich leider, dass die Kabel doch etwas kurz geraten sind. Wenn der Movement Sensor angeschraubt wird, sodass dieser parallel zum Mikrocontroller liegt, ist das Qwiic Kabel doch recht stramm.

Programmieren des Modulino Movement in der Arduino IDE

Auf der Seite https://courses.arduino.cc/plugandmake/lessons/modulino-movement/ findest du eine englische Dokumentation zum Modulino Movement mit einem Beispiel, welches ich dir nachfolgend einmal abgewandelt zeige. //Bibliothek für die Modulino Sensoren / Aktoren #include "Modulino.h" //erzeugen einer Objektinstanz vom Typ //Modulino Movement ModulinoMovement movement; void setup() { //beginn der seriellen Kommunikation mit 9600 baud Serial.begin(9600); //begin / Initialisierung der Kommunikation Modulino.begin(); //einrichten der I2C Verbindung zum Sensor movement.begin(); } void loop() { //aktualisieren der Daten vom Sensor movement.update(); //Ausgeben der Daten auf der seriellen Schnittstelle Serial.print("Lage: "); } Auf der seriellen Schnittstelle werden die Daten der Achsen X,Y & Z fortlaufend ausgegeben.

Anzeigen der Richtung mit der LED Matrix vom Arduino UNO R4 WiFi Der mitgelieferte Arduino UNO R4 WiFi verfügt über eine 8x12 LED Matrix (in rot) auf welcher wir recht simple Grafiken und auch Texte anzeigen lassen können. Mithilfe dieser Matrix möchte ich nun mit Pfeilen die Richtung anzeigen.

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

[draegerit]

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

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

Was ist im Arduino Plug and Make Kit drin?

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

6 Achsen Sensor

3fach Taster Modul

Buzzer

Rotary Encoder

Temperatur & rel. Luftfeuchtigkeits Sensor

8fach LED Modul

ToF - Distance Sensor

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

Einrichten des Arduino UNO R4 WiFi in der Arduino IDE

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

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

Aufbau einer Schaltung

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

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

Programmieren der Sensoren / Aktoren in der Arduino IDE

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

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

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