Giochi di luce IoT Cloud rimane in tema festività natalizie aggiungendo un pizzico di IoT al progetto.
avrai già letto, probabilmente gli articoli dedicati alle luci di natale e al controllo IoT dell’Arduino Uno R4 WiFI:
Giochi di luce natalizi Arduino R4
ed ho pensato… perché non unire i due progetti e realizzare un sistema di controllo delle luci direttamente controllato dal Cloud Arduino ?
Ecco fatto .. in questo articolo leggerai come realizzare i tuoi giochi di luce IoT cloud.
Giochi di luce IoT Cloud
Rispetto all’articolo in cui hai letto come controllare le luci dei giochi natalizi con una Arduino Uno R4 Minima, in questo progetto avrai bisogno della uno R4 WiFi.
L’Arduino Uno R4 WiFi dispone, infatti, della componente WiFi per connettersi alla tua rete ed al Cloud.
Ho mantenuto il pulsante per cambiare i giochi di luce in modo che il progetto sia utilizzabile anche quando non è disponibile una connessione internet.
To mostro prima il video per comprendere meglio come funziona:
Lo schema del progetto
lo schema del progetto giochi di luce IoT Cloud non cambia rispetto a quello che hai visto usando l’arduino uno r4 minima, infatti non ho modificato la scheda utilizzata nel disegno:
tuttavia nelle immagini e nel video avrai visto che la scheda da utilizzare è la R4 WiFi.
Notice
Probabilmente avrai pensato: ma io ho piu di 7 luci sul mio albero di natale, o dove vorrei utilizzare il progetto, come faccio ?
Puoi usare i 7 pin come 7 canali di accensione di più luci in modo che combinati tra essi facciano l’effetto che desideri.
Ricorda in tal caso che non puoi collegare le luci direttamente ad Arduino ma dovrai procurarti dei driver di controllo per le singole linee come questi che ti permetteranno di controllare luci da 5v a 36v.
Lo sketch dei giochi di luce IoT Cloud
Lo sketch che puoi utilizzare è diviso in 3 parti:
- giochi di luce IoT: main sketch;
- frames.h: contiene il codice dei numeri da visualizzare sulla matrice led;
- thingProperties.h: con le impostazioni per connetterti all’Arduino Cloud IoT;
avrai quindi nell’IDE arduino 3 tab, una situazione simile:
Partendo dal primo iniziamo a vedere come sono composti:
Giochi di luce IoT
l’ho definito main sketch in quanto contiene le funzioni principali: setup e loop:
#include "thingProperties.h"
#include "Arduino_LED_Matrix.h"
#include "frames.h"
int minpin = 2;
int maxpin = 8;
int fadeUp = 1000;
int fadeDown = 1000;
int fadeUpPin[] = {0,0,0,0,0,0,0,0,0};
int fadeDownPin[] = {0,0,0,0,0,0,0,0,0};
int currFadeVal[] = {0,0,0,0,0,0,0,0,0};
int pinButton = 13;
int game = 0;
int totalGame = 9;
int fLampeggio = 500;
int status = WL_IDLE_STATUS;
boolean pressButton = false;
ArduinoLEDMatrix matrix;
/**************************************************************************************************/
void SoftPWMBegin() { Serial.begin( 115200 ); Serial.println( "Start" ); delay(1500); };
void SoftPWMSet(int pin, int value) {
if (value == HIGH) value=255;
if (value == LOW) value=0;
if (value > currFadeVal[pin] ) {
if (fadeDownPin[pin] == 0) { analogWrite( pin,value );
} else if (fadeUpPin[pin] == 255) { analogWrite( pin,value );
} else {
int stepTime = (fadeUpPin[pin]/(value-currFadeVal[pin]))+1;
for (int v=currFadeVal[pin]; v<=value; v++) { if (digitalRead( pinButton ) == HIGH) { return; } analogWrite( pin,v ); delay(stepTime); };
}
}
if (value < currFadeVal[pin] ) {
if (fadeDownPin[pin] == 0) {
analogWrite( pin,value );
} else {
int stepTime = (fadeDownPin[pin]/(currFadeVal[pin]-value))+1;
for (int v=currFadeVal[pin]; v>=value; v--) { if (digitalRead( pinButton ) == HIGH) { return; } analogWrite( pin,v ); delay(stepTime); };
}
}
currFadeVal[pin]=value;
}
void SoftPWMSetFadeTime(int pin, int fadeUp, int fadeDown) { fadeUpPin[pin] = fadeUp; fadeDownPin[pin] = fadeDown; }
void SoftPWMSetPercent(int pin, int percent) { SoftPWMSet(pin, ((uint16_t)percent * 255) / 100); }
/**************************************************************************************************/
void resetLinee() { Serial.println( " ..reset.. " ); for ( int l=minpin; l<=maxpin; l++) { SoftPWMSetFadeTime(l, 0, 0); SoftPWMSet(l, LOW); } }
void game_one() {
Serial.println( " ..one.. " );
for ( int i=minpin; i<=maxpin; i++) { SoftPWMSetFadeTime(i, fadeUp, fadeDown); }
for ( int l=minpin; l<=maxpin; l++)
{
if ((digitalRead( pinButton ) == HIGH) || (pressButton)) { break; }
SoftPWMSetPercent(l, 100);
if (l >= (minpin+1)) { SoftPWMSetPercent((l-1), 0); }
if (l == minpin) { SoftPWMSetPercent((maxpin), 0); }
delay(fadeUp);
}
}
void game_two() {
Serial.println( " ..two.. " );
for ( int i=minpin; i<=maxpin; i++) { SoftPWMSetFadeTime(i, fadeUp/2, fadeDown/2); }
int middle=int ((maxpin/2)+1);
int cur1=0;
for ( int b=minpin; b<=middle; b++) {
if ((digitalRead( pinButton ) == HIGH) || (pressButton)) { break; }
int e=(maxpin-cur1);
SoftPWMSetPercent(b, 100);
SoftPWMSetPercent(e, 100);
cur1++;
delay(fadeUp);
}
for ( int b=middle; b>=minpin; b--) {
if ((digitalRead( pinButton ) == HIGH) || (pressButton)) { break; }
int e=(maxpin-cur1)+1;
SoftPWMSetPercent(b, 0);
SoftPWMSetPercent(e, 0);
cur1--;
delay(fadeDown);
}
delay(fadeUp);
}
void game_three() {
Serial.print( " ..three.. " );
for ( int i=minpin; i<=maxpin; i++) { SoftPWMSetFadeTime(i, 0, 0); }
for ( int i=minpin; i<=maxpin; i++) {
if ((digitalRead( pinButton ) == HIGH) || (pressButton)) { break; }
float val=int (i/2);
if ( (float(i)/2) == val) SoftPWMSetPercent(i, 0);
else SoftPWMSetPercent(i, 100);
}
delay(fadeUp/2);
for ( int i=minpin; i<=maxpin; i++) {
if ((digitalRead( pinButton ) == HIGH) || (pressButton)) { break; }
float val=int (i/2);
if ( (float(i)/2) == val) SoftPWMSetPercent(i, 100);
else SoftPWMSetPercent(i, 0);
}
delay(fadeUp/2);
Serial.println( " ..three end .. " );
}
void game_four() {
Serial.println( " ..four.. " );
for ( int i=minpin; i<=maxpin; i++) { SoftPWMSetFadeTime(i, 0, 0); }
for ( int i=minpin; i<=maxpin; i++) {
if ((digitalRead( pinButton ) == HIGH) || (pressButton)) { break; }
SoftPWMSetPercent(i, 0);
delay(100);
SoftPWMSetPercent(i, 100);
delay(100);
}
}
void game_five() {
Serial.println( " ..five.. " );
for ( int i=minpin; i<=maxpin; i++) { SoftPWMSetFadeTime(i, 0, 0); }
for ( int i=minpin; i<=maxpin; i++) { if ((digitalRead( pinButton ) == HIGH) || (pressButton)) { break; } SoftPWMSetPercent(i, 0); }
delay(100);
for ( int i=minpin; i<=maxpin; i++) { if ((digitalRead( pinButton ) == HIGH) || (pressButton)) { break; } SoftPWMSetPercent(i, 100); }
delay(100);
}
void game_six() {
Serial.println( " ..six.. " );
for ( int i=minpin; i<=maxpin; i++) { SoftPWMSetFadeTime(i, fadeUp, fadeDown); }
for ( int i=minpin; i<=maxpin; i++) {
if ((digitalRead( pinButton ) == HIGH) || (pressButton)) { break; }
float val=int (i/2);
if ( (float(i)/2) == val) SoftPWMSetPercent(i, 0);
else SoftPWMSetPercent(i, 100);
}
delay(fadeUp/2);
for ( int i=minpin; i<=maxpin; i++) {
if ((digitalRead( pinButton ) == HIGH) || (pressButton)) { break; }
float val=int (i/2);
if ( (float(i)/2) == val) SoftPWMSetPercent(i, 100);
else SoftPWMSetPercent(i, 0);
}
delay(fadeDown/2);
}
void game_seven() {
Serial.println( " ..seven.. " );
for ( int i=minpin; i<=maxpin; i++) { SoftPWMSetFadeTime(i, 0, 0); }
int middle=int ((maxpin/2)+1);
int cur1=0;
for ( int b=minpin; b<=middle; b++) {
if ((digitalRead( pinButton ) == HIGH) || (pressButton)) { break; }
int e=(maxpin-cur1);
SoftPWMSetPercent(b, 100);
SoftPWMSetPercent(e, 100);
cur1++;
delay(fadeUp/2);
}
for ( int b=middle; b>=minpin; b--) {
if ((digitalRead( pinButton ) == HIGH) || (pressButton)) { break; }
int e=(maxpin-cur1)+1;
SoftPWMSetPercent(b, 0);
SoftPWMSetPercent(e, 0);
cur1--;
delay(fadeDown/2);
}
delay(fadeUp/2);
}
void game_eight() {
Serial.println( " ..eight.. " );
for ( int i=minpin; i<=maxpin; i++) { SoftPWMSetFadeTime(i, fadeUp*2, fadeDown*2 ); }
for ( int i=minpin; i<=maxpin; i++) { if ((digitalRead( pinButton ) == HIGH) || (pressButton)) { break; } SoftPWMSetPercent(i, 100); }
delay(fadeUp);
for ( int i=minpin; i<=maxpin; i++) { if ((digitalRead( pinButton ) == HIGH) || (pressButton)) { break; } SoftPWMSetPercent(i, 0); }
delay(fadeDown);
}
/**************************************************************************************************/
void setup() {
SoftPWMBegin();
matrix.begin();
initProperties();
// Connect to Arduino IoT Cloud
ArduinoCloud.begin(ArduinoIoTPreferredConnection);
/*
The following function allows you to obtain more information
related to the state of network and IoT Cloud connection and errors
the higher number the more granular information you’ll get.
The default is 0 (only errors).
Maximum is 4
*/
setDebugMessageLevel(2);
ArduinoCloud.printDebugInfo();
for ( int i=minpin; i<=maxpin; i++) { pinMode( i,OUTPUT ); SoftPWMSetFadeTime(i, 0, 0); SoftPWMSet(i, HIGH); }
for ( int i=minpin; i<=maxpin; i++) { SoftPWMSetFadeTime(i, fadeUp/2, fadeDown/2); SoftPWMSet(i, LOW); }
pinMode(pinButton, INPUT);
}
/**************************************************************************************************/
void loop() {
ArduinoCloud.update();
if (digitalRead( pinButton ) == LOW) {
if ( pressButton ) { pressButton = false; game += 1; resetLinee(); }
if (game == 1) { game_one(); }
if (game == 2) { game_two(); }
if (game == 3) { game_three(); }
if (game == 4) { game_four(); }
if (game == 5) { game_five(); }
if (game == 6) { game_six(); }
if (game == 7) { game_seven(); }
if (game == 8) { game_eight(); }
if (game == 9) {
Serial.print("In Game: "); Serial.println( game );
game_one(); if ((digitalRead( pinButton ) == HIGH) || (pressButton)) { return; }
game_two(); if ((digitalRead( pinButton ) == HIGH) || (pressButton)) { return; }
for ( int n=0; n<=10; n++ ) { game_three(); } if ((digitalRead( pinButton ) == HIGH) || (pressButton)) { return; }
for ( int n=0; n<=10; n++ ) { game_four(); } if ((digitalRead( pinButton ) == HIGH) || (pressButton)) { return; }
for ( int n=0; n<=10; n++ ) { game_five(); } if ((digitalRead( pinButton ) == HIGH) || (pressButton)) { return; }
game_six(); if ((digitalRead( pinButton ) == HIGH) || (pressButton)) { return; }
for ( int n=0; n<=10; n++ ) { game_seven(); } if ((digitalRead( pinButton ) == HIGH) || (pressButton)) { return; }
game_eight(); if ((digitalRead( pinButton ) == HIGH) || (pressButton)) { return; }
}
if (game > totalGame) { game = 1; } ;
} else { pressButton = true; }
}
/*
Since LedBuiltin is READ_WRITE variable, onLedBuiltinChange() is
executed every time a new value is received from IoT Cloud.
*/
void onLedBuiltinChange() {
// Add your code here to act upon LedBuiltin change
digitalWrite(LED_BUILTIN, led_Builtin);
}
/*
Since LedMatrix is READ_WRITE variable, onLedMatrixChange() is
executed every time a new value is received from IoT Cloud.
*/
void onLedMatrixChange() {
matrix.loadFrame( matrixNumber[led_Matrix] );
if ( game != led_Matrix ) { game = (led_Matrix-1); pressButton = true; }
}
è certamente la parte più corposa ed impegnativa del progetto, ma per il 90% identica a quanto letto nei due precedenti articoli da cui siamo partiti.
Analizzeremo solo le parti nuove come la linea 016: che introduce la variabile status in cui sarà memorizzato lo stato della connessione ad internet;
le linee 053-210: sono le stesse che hai già letto nel precedente articolo dedicato ai giochi di luce con Arduino Minima, sono solo state spostate prima delle funzioni setup e loop;
linea 216: richiama la funzione initProperties che troverai nel file thingProperties e che serve ad inizializzare la connessione verso il Cloud IoT;
allo stesso modo le linee 219-229: sono state copiate dallo sketch di connessione all’arduino cloud;
nella funzione setup è rimasto tutto invariato.
Nella funzione loop trovi una modifica alla prima linea la 240: che richiama, ad ogni ciclo di loop il metodo update dell’ArduinoCloud;
nel gioco 9 alle linee 256-263: ho aggiunto, per ogni linea, un check simile a quello presente in ogni gioco di luce, il cui scopo è verificare che il pulsante sia stato premuto per cambiare gioco prima che la sequenza finisca.
Infine alla linea 285: nella funzione onLedMatrixChange quando un nuovo numero viene inviato dall’IoT Dashboard controlli se il gioco di luce in esecuzione è differente da quello impostato e lo reimposti.
Frames.h
Come anticipato contiene il codice dei numeri da visualizzare sulla matrice led, lo hai già letto nell’articolo dedicato all’utilizzo della matrice led della R4 wifi:
const uint32_t matrixNumber[][4] = {
{ 0x600f019, 0x81981981, 0x980f0060, 66 },
{ 0xe01e036, 0x600600, 0x601f81f8, 66 },
{ 0x600f019, 0x80300600, 0xc01801f8, 66 },
{ 0xf019801, 0x80300300, 0x181980f0, 66 },
{ 0xf01f03b, 0x3303fc3, 0xfc030030, 66 },
{ 0x1f81f818, 0x1f00f80, 0x181f81f0, 66 },
{ 0x600f018, 0x1f01981, 0x981980f0, 66 },
{ 0x1f81f801, 0x80300600, 0xc0180180, 66 },
{ 0xf019819, 0x80f01981, 0x981980f0, 66 },
{ 0xf019819, 0x80f80180, 0x181f00e0, 66 }
};
si tratta del medesimo file presentato nell’articolo della matrice di led via Iot Cloud solo compattata per vederla meglio nel suo insieme.
ThingProperties.h
Contiene le impostazioni SSID, Password, Device key necessarie per connettere il progetto all’Arduino Cloud IoT.
Anche questo file lo hai incontrato nel progetto dedicato all’IoT Cloud e matrice led.
// Code generated by Arduino IoT Cloud, DO NOT EDIT.
#include <ArduinoIoTCloud.h>
#include <Arduino_ConnectionHandler.h>
const char DEVICE_LOGIN_NAME[] = "[device login name ricavato dall'IoT Cloud]";
const char SSID[] = "[SSID del tuo WiFi]"; // Network SSID (name)
const char PASS[] = "[Pass del WiFi]"; // Network password (use for WPA, or use as key for WEP)
const char DEVICE_KEY[] = "[key device id o Secret device password fornita dal Cloud Arduino]"; // Secret device password
void onLedMatrixChange();
void onLedBuiltinChange();
int led_Matrix;
bool led_Builtin;
void initProperties(){
ArduinoCloud.setBoardId(DEVICE_LOGIN_NAME);
ArduinoCloud.setSecretDeviceKey(DEVICE_KEY);
ArduinoCloud.addProperty(led_Matrix, READWRITE, ON_CHANGE, onLedMatrixChange);
ArduinoCloud.addProperty(led_Builtin, READWRITE, ON_CHANGE, onLedBuiltinChange);
}
WiFiConnectionHandler ArduinoIoTPreferredConnection(SSID, PASS);
non ci sono molte differenze rispetto al progetto da cui siamo partiti, e di cui trovi il link sopra, dovrai sostituire i valori relativi al tuo device_login_name, ssid, password e secret password.
In questo modo il tuo device si collegherà alla tua rete WiFi ed al cloud IoT Arduino pronto a ricevere i comandi e far partire i giochi di luce.
Il blog mauroalfieri.it ed i suoi contenuti sono distribuiti con Licenza