Eespecials - unisciti ai ranghi dei Blinkers!
Oggi, in 5 minuti, imposteremo il controllo dell'ESP8266 dal tuo smartphone (iOS o Android) utilizzando il nuovo servizio cloud Blink. Video e dettagli sotto il taglio.
Installa l'app Blynk sul tuo smartphone
Registrati nell'applicazione e crea un nuovo progetto.
Immettere il nome del progetto, ad esempio ESP8266... In campo Modello hardware scegliere ESP8266... (spero che tu abbia notato un elenco impressionante di hardware supportato) Generato automaticamente Token di autenticazione invia alla tua casella di posta.
Dopo aver premuto il pulsante Creare ti verrà presentato un campo vuoto per progettare l'interfaccia utente del tuo pannello di controllo ESP8266.
Fare clic sul segno più in alto a destra: verrà visualizzata la barra degli strumenti Widget Box per aggiungere widget alla tua dashboard. Va notato che l'elenco dei widget continuerà a crescere.
Per la prova, seleziona il tipo di widget Pulsante - questo widget verrà immediatamente aggiunto al tuo pannello. Modificalo con un tocco. Il nome può essere lasciato vuoto, appena a destra puoi scegliere il colore dell'indicatore, nel campo PIN DI USCITA seleziona a destra Digitale, ea sinistra qualsiasi pin libero GPIO... Di seguito cambia il tipo di pulsante in Interruttore.
Successivamente, installa la libreria Blynk nell'IDE di Arduino. Le istruzioni ufficiali ti aiuteranno in questo. Puoi anche prendere l'ultima versione della libreria direttamente dal repository e installarla manualmente. Quindi, seleziona un esempio ESP8266_Standalone e scrivici dentro Token di autenticazioneche abbiamo ricevuto per posta, SSID e password la tua rete WiFi. Compila e carica lo schizzo su ESP8266.
In precedenza ha inventato una ruota per costruire dispositivi di monitoraggio Arduino.
Era interessante.
/ * - Nuovo progetto - Questo codice sorgente dell'interfaccia utente grafica è stato generato automaticamente dall'editor RemoteXY. Per compilare questo codice utilizzando la libreria RemoteXY 2.3.5 o versione successiva, scaricare tramite il collegamento http://remotexy.com/en/library/ Per connettersi utilizzando l'app mobile RemoteXY tramite il collegamento http://remotexy.com/en/download/ - per ANDROID 4.3.1 o versione successiva; - per iOS 1.3.5 o versione successiva; Questo codice sorgente è un software gratuito; è possibile ridistribuirlo e / o modificarlo secondo i termini della GNU Lesser General Public License come pubblicata dalla Free Software Foundation; o la versione 2.1 della licenza o (a tua scelta) qualsiasi versione successiva. * / //////////////////////////////////////////// // RemoteXY include la libreria // /////////////////////////////////////////// / // determinare la modalità di connessione e collegare la libreria RemoteXY #define REMOTEXY_MODE__ESP8266_HARDSERIAL_CLOUD #include
Usiamo un panino dalle tavole.
All'improvviso tutto ha funzionato subito:
È passata un'ora dal momento in cui il servizio cloud RemoteXY è stato scoperto alla foto sopra.
Funzionalità di lavoro con RemoteXY.
1. È tutto molto semplice. Va bene a modo suo. È improbabile che Blynk e Cayenne, ad esempio, vengano risolti da zero in un'ora. Per utilizzare, ad esempio, "KaScada Cloud" è necessario acquistarne uno speciale.
2. Non c'è elaborazione e memorizzazione dei dati sul lato server: non c'è connessione con la scheda - l'applicazione si blocca "Nessuna connessione".
3. Solo 5 elementi di design sono gratuiti, ma l'applicazione PRO non costa più di mezza giornata di tempo speso.
4. È possibile da una applicazione comunicare con la scheda sia tramite il server cloud che direttamente. La verità non è allo stesso tempo, naturalmente. Ed è impossibile cambiare rapidamente: è necessario modificare lo schizzo nella lavagna. È anche possibile comunicare tra lo smartphone e la scheda tramite Bluetooth e USB.
La programmazione di una varietà di microcontrollori e microcomputer, come Arduino, Raspberry Pi e simili, è una delle attività più interessanti e rilevanti. Il design dei dispositivi su queste piattaforme è andato oltre l'hobby dei geek e dei programmatori professionisti: queste schede vengono utilizzate per creare robot, macchine utensili, quadricotteri, dispositivi IoT (casa intelligente), server e persino interfacce audio Hi-Fi.
Sfortunatamente, il mercato dei microcontrollori è altamente segmentato. Sono programmati attraverso vari ambienti e interfacce. Un progetto chiamato Blynk mira a salvare la situazione.
Blynk è un servizio basato su cloud per la creazione di pannelli di controllo grafici ed è adatto per un'ampia gamma di microcomputer e microcontrollori. Laddove in precedenza era necessario scrivere un'interfaccia I / O completa o acquistare moduli aggiuntivi per raccogliere informazioni dai sensori, ora puoi cavartela con un lavoro di cinque minuti a Blynk.
Per creare il tuo progetto gestito tramite Blynk, hai bisogno di pochissimo: installa l'applicazione (sono disponibili le versioni per iOS e Android) o utilizza un modulo web. Qui dovrai registrarti in un unico passaggio: inserisci la tua email e la password. La registrazione è necessaria perché Blynk è una soluzione cloud e senza di essa qualsiasi utente può ottenere il controllo sul componente hardware.
Chi fosse interessato può installare il server in locale. In questo caso, l'accesso a Internet non è richiesto.
L'applicazione richiederà determinate abilità. Innanzitutto, è necessario associare il computer o lo smartphone alla scheda programmabile. Il programma supporta la connessione alle schede attraverso un'ampia varietà di interfacce:
- USB (seriale),
- Adafruit CC3000 WiFi,
- Arduino WiFi Shield ufficiale,
- Schermo Ethernet ufficiale (W5100),
- ENC28J60,
- ESP8266 (modem WiFi),
- SeeedStudio Ethernet Shield V2.0 (W5200),
- RN-XV WiFly,
- ESP8266.
Oltre a configurare la connessione, è sufficiente collegare correttamente i moduli del futuro dispositivo. Dopodiché, nel modulo di lavoro dell'applicazione, è necessario aggiungere i moduli disponibili (widget), configurare gli indirizzi di output necessari e specificare i parametri desiderati (se necessario, è possibile scrivere il proprio codice) A proposito, il drag'n'drop viene utilizzato per creare un widget o un programma. Sono disponibili molti simulatori di dispositivi di controllo per il controllo: interruttori, cursori, display, per ognuno dei quali è possibile scrivere la propria logica. Esistono moduli separati per la visualizzazione e l'organizzazione delle informazioni dai sensori richiesti sotto forma di grafici.
Pertanto, la piattaforma è adatta sia ai principianti che agli utenti più avanzati che non vogliono perdere tempo a scrivere applicazioni per la gestione dei progetti: dalla lettura dei dati da una stazione meteorologica e dal controllo di una casa intelligente al controllo dei robot.
Tutte le informazioni necessarie per iniziare sono pubblicate sul sito web ufficiale. Blynk lo è, quindi tutti possono partecipare alla creazione di nuove funzionalità. Al momento, l'uso del servizio è completamente gratuito, in futuro la situazione cambierà un po ', prima di tutto, a causa della monetizzazione di nuove funzioni. Ad esempio, è già noto che l'accesso alle interfacce GPIO verrà acquistato come acquisto in-app.
Blynk attualmente lavora con le seguenti schede:
- Arduino: Uno, Nano, Mini, Pro Mini, Pro Micro, Mega, YÚN (Bridge), Due;
- Raspberry Pi;
- Particella (ex Spark Core);
- ESP8266;
- TinyDuino (CC3000);
- Wicked WildFire (CC3000).
La connessione tramite il server cloud RemoteXY consente di controllare il dispositivo da qualsiasi parte del mondo in cui è presente Internet.
L'ESP8266 verrà configurato come client per connettersi all'hotspot WiFi. Il punto di accesso deve avere accesso a Internet. La libreria RemoteXY fornirà la registrazione del dispositivo al server cloud.
L'app mobile si connetterà al server cloud e non direttamente al dispositivo. Pertanto, il dispositivo sarà accessibile da qualsiasi punto di Internet.
Nota:Al momento, una connessione tramite un server cloud è in fase di test. Pertanto, sono possibili interruzioni del server.
Passaggio 1. Crea un progetto GUI
Passaggio 5. Configurare ESP8266
Il modulo ESP8266 deve essere configurato. Il tuo modulo potrebbe già avere le impostazioni predefinite richieste, ma è meglio verificarlo.
Cosa devi controllare:
- Il modulo ha un firmware che supporta i comandi AT della versione non inferiore alla v0.40;
- Il modulo è configurato per una velocità di 115200.
Passaggio 6: collega ESP8266 ad Arduino Uno
Collega ESP8266 ad Arduino Uno secondo lo schema seguente. Notare che i pin RX-TX sono collegati in modo incrociato.
Poiché i livelli del segnale di ESP8266 sono 3,3 V e Arduino è 5 V, è necessario utilizzare un partitore di tensione resistivo per convertire il livello del segnale.
Passaggio 7. Carica lo schizzo su Arduino.
Lo schizzo viene caricato su Arduino nel solito modo. Tuttavia, a causa del fatto che il modulo ESP8266 è collegato ai pin 0 e 1, la programmazione diventa impossibile. Il compilatore mostrerà un errore.
Prima della programmazione, scollegare i fili che vanno all'ESP8266 dai pin 0 e 1. Eseguire la programmazione. Quindi rimetti i contatti a posto. Premi il pulsante di ripristino di Arduino.
Nota:Il primo segno che la programmazione è andata a buon fine è un LED blu lampeggiante sul modulo ESP8266 subito dopo il ripristino. Il LED blu lampeggiante indica lo scambio di dati tra Arduino e ESP8266. In questi mezzi secondi, Arduino configura ESP8266 per connettersi al punto di accesso. Dopo un po ', il LED lampeggerà di nuovo, il che significa un tentativo di registrazione sul server cloud RemoteXY.
Passaggio 8. Connettiti dall'applicazione mobile.
Controllare l'alimentazione ESP8266
È anche possibile che il tuo ESP8266 non abbia abbastanza alimentazione. Alcune schede Arduino hanno un debole regolatore di tensione 3,3 V che non è in grado di erogare 200-300 mA in condizioni di picco. In questo caso, vedrai anche un'interruzione nella sequenza dei comandi nel Monitor seriale.
Vadim Kolesnik, Tiraspol
Sviluppo emozionante, facile e veloce di dispositivi IoT completi su Arduino utilizzando il servizio cloud
Informazione Generale
myDevices sviluppa software e applicazioni per l'Internet of Things (IoT) ed è una divisione di Avanquest. myDevices Cayenne è la prima applicazione drag-and-drop e servizio cloud per lo sviluppo semplificato di progetti IoT su Raspberry Pi.
Sul portale Radiolotsman che ho recentemente pubblicato, in cui ho cercato di rivelare i principali vantaggi e capacità del sistema quando si lavora su un computer a scheda singola Raspberry Pi (RPi). Ma il progetto Cayenne è in continua evoluzione, gli sviluppatori, facendo affidamento sui desideri degli utenti, stanno gradualmente aggiungendo nuove funzioni, eliminando carenze ed errori.
Lo sviluppo di dispositivi IoT su Arduino e Raspberry Pi è fondamentalmente diverso quando si lavora con Cayenne. Per quanto riguarda il Raspberry Pi, la piattaforma Cayenne può essere considerata un ambiente di sviluppo visivo: colleghiamo fisicamente varie periferiche alla scheda Raspberry Pi e quindi lavoriamo solo nell'ambiente online Cayenne (impostazione widget, elaborazione dati, scrittura algoritmi di automazione).
Per quanto riguarda Arduino, il cruscotto Cayenne (dashboard) è solo un insieme di widget e controlli che visualizzano i dati ricevuti dai sensori e trasmettono i dati dell'utente per controllare uno o un altro attuatore. Il lavoro diretto con sensori, attuatori, periferiche aggiuntive (ad esempio un display, una seconda tastiera), l'elaborazione delle condizioni di automazione è assegnata al microcontrollore. In altre parole, tutto si riduce allo sviluppo standard di Arduino; l'utente scrive il codice del programma da solo, ma con l'integrazione delle funzioni IoT flessibili della Cayenne nel progetto. Questo è, a mio avviso, il principale vantaggio della Cayenne: è possibile collegare al sistema qualsiasi sensore e attuatore, non limitato alla lista delle periferiche supportate.
Interfaccia utente e preparazione per il lavoro
Per quanto riguarda l'interfaccia utente del sistema, le sue impostazioni, metodi di controllo e widget sulla dashboard, tutto questo rimane simile al sistema sul Raspberry Pi, ovviamente, ad eccezione di alcuni elementi univoci insiti in quest'ultimo (ad esempio, desktop remoto, stato della memoria, carico del processore). Pertanto, per comprendere le basi del lavoro con il sistema, consiglio di leggere gli articoli. Tutte le informazioni nell'articolo sono rilevanti sia per l'interfaccia web del sistema che per l'interfaccia dell'applicazione mobile. L'articolo contiene anche un elenco di periferiche supportate.
Per sviluppare un dispositivo o un'applicazione IoT, abbiamo bisogno di:
- Avere un proprio account sul servizio Cayenne (è possibile utilizzarne uno esistente);
- Installa l'IDE di Arduino;
- Aggiungi la libreria delle funzioni Cayenne all'IDE di Arduino;
- Configurare l'IDE di Arduino: selezionare la scheda e la porta COM a cui è connesso;
- Collega una scheda di espansione Ethernet Shield o Wi-Fi Shield ad Arduino (o usa una scheda Arduino con un'interfaccia di rete integrata).
Penso che il processo di installazione dell'IDE di Arduino, così come la scelta della scheda e della porta, sia autoesplicativo e passeremo a quello principale.
La libreria Cayenne per Arduino può essere installata facilmente e rapidamente utilizzando il gestore della libreria (Figura 2).
Dopo aver installato la libreria, possiamo usarla nelle nostre applicazioni e una nuova cartella denominata Cayenne apparirà nella sezione degli esempi di schizzo. A mio parere, questi esempi non comprendono appieno come lavorare con il sistema, ma comunque vale la pena studiarli e, inoltre, ricorda che c'è un'enorme sezione di documentazione sul sistema Cayenne. In generale, questa libreria è un insieme di schizzi che semplificano la connessione e lo scambio di dati tra sensori / attuatori e il servizio cloud.
Dopo aver completato le operazioni preparatorie, impostato l'ambiente di sviluppo e collegato la scheda di espansione Ethernet Shield, è possibile iniziare a sviluppare il dispositivo IoT.
Colleghiamo la scheda Arduino al computer tramite USB, colleghiamo il cavo LAN all'Ethernet Shield. Nel browser Internet, accediamo all'account Cayenne e nel pannello di controllo aggiungiamo un nuovo dispositivo: Arduino. Successivamente, selezioniamo il tipo di scheda, il metodo di connessione a Internet (ci sono alcune opzioni), prestiamo attenzione alla chiave di autorizzazione univoca per il nostro dispositivo e aspettiamo che la scheda Arduino sia collegata alla Cayenne (Figura 3).
Per ogni nuovo dispositivo viene generata una nuova chiave univoca, che successivamente si potrà trovare nelle impostazioni del dispositivo (scheda).
Non appena scegli il metodo di connessione alla rete, apparirà una finestra con il codice sorgente del programma del microcontrollore. Questo è il minimo richiesto per connettere il dispositivo al servizio cloud. Tieni presente che la tua chiave di autorizzazione è già indicata nel testo del programma ed è collegata una libreria che corrisponde al metodo di connessione alla rete selezionato (Figura 4). Copia questo codice nell'IDE di Arduino, compila e carica sulla scheda. Se tutto è stato configurato correttamente, nel pannello di controllo della Cayenne appariranno un nuovo dispositivo attivo e un nuovo dashboard, dove ora puoi aggiungere widget e controlli. Inoltre, già in questa fase, puoi controllare da remoto le porte digitali e analogiche disponibili di Arduino senza scrivere una sola riga di codice: aggiungi un pulsante widget sulla dashboard, specifica il tipo di porta (digitale), il suo nome sulla scheda e salva il widget. Ora, facendo clic sul pulsante nel browser, cambierai lo stato logico della porta. Inoltre è semplice, aggiungendo gli appositi widget, è possibile controllare le uscite PWM, ricevere dati "grezzi" dagli ingressi analogici di Arduino, monitorare lo stato degli ingressi digitali.
Sviluppo di un dispositivo utilizzando un esempio specifico
Ora ti parlerò delle caratteristiche e delle funzioni aggiuntive del sistema. Ad esempio, ho messo insieme un semplice sistema che include:
- Scheda Arduino Uno;
- Scheda di espansione Ethernet Shield sul controller WIZnet W5100;
- Sensore di temperatura DS18B20;
- Fotoresistenza;
- Termistore;
- Diversi LED;
- Display OLED su controller SSD1306.
La Figura 5 mostra un diagramma schematico del collegamento di sensori e LED ad Arduino.
Permettimi di ricordarti che puoi trovare le risposte alla maggior parte delle domande relative al collegamento di vari sensori e attuatori nella sezione della documentazione.
Penso che non ci saranno domande sul collegamento di LED, un sensore di temperatura digitale e un display OLED. I sensori analogici di luce e temperatura sono collegati agli ingressi analogici secondo il circuito del divisore resistivo. In questo caso, per il circuito del termistore, è necessario conoscere la resistenza esatta del resistore R6, questo valore verrà utilizzato nel codice sorgente per i calcoli.
Dopo aver collegato gli elementi indicati nel diagramma, scriveremo uno schizzo di Arduino, quindi installeremo i widget necessari sulla dashboard di Cayenne. Al momento, uno schizzo minimo è già stato caricato nella scheda Arduino e la scheda è definita nel cruscotto di Cayenne. Come ho detto sopra, in questa fase possiamo aggiungere widget per controllare i LED D1, D2, nonché ricevere dati "grezzi" dagli ingressi analogici a cui sono collegati il \u200b\u200btermistore e la fotoresistenza (Figure 6, 7).
Senza scrivere una sola riga di codice Arduino, abbiamo già un semplice sistema di controllo e monitoraggio remoto (Figura 8).
Per utilizzare sensori di temperatura digitali, termistori, PWM, ad esempio, per controllare il LED D2, sarà necessario aggiungere uno schizzo minimo. Per prima cosa, definiamo le librerie richieste.
#includere< CayenneEthernet.h> // usa la scheda di espansione Ethernet Shield
#includere< CayenneTemperature.h> // funzioni per convertire i dati da un termistore
#includere< OneWire.h> // funzioni per lavorare con il bus 1-Wire
#includere< DallasTemperature.h> // funzioni per lavorare con sensori di temperatura digitali
#includere< Arduino.h> // costanti e variabili standard del linguaggio Arduino
#includere< U8x8lib.h> // libreria per lavorare con il display OLED in modalità testo
#includere< Wire.h> // supporto per l'interfaccia hardware I 2 C
#define VIRTUAL_PIN_1 V0 // canale virtuale per il sensore DS18B20
#define VIRTUAL_PIN_2 V1 // - per termistore
#define VIRTUAL_PIN_3 V2 // - per LED D2, riceveremo i dati sul valore PWM attraverso questo canale
#define LED2_PWM 6 // porta Arduino reale a cui è collegato il LED D2
I circuiti virtuali non sono porte I / O digitali o analogiche. Durante la lettura diretta degli ingressi analogici, l'utente riceve i dati dall'ADC a 10 bit del microcontrollore. I valori restituiti dall'ADC sono compresi nell'intervallo 0 ... 1023 e sono proporzionali alla tensione su questo ingresso. In altre parole, se colleghi un sensore di temperatura all'ingresso analogico di Arduino, non otterrai un valore di temperatura, sono necessarie ulteriori conversioni e calcoli matematici per convertire tensione - temperatura.
I canali virtuali sono progettati per semplificare la conversione, la formattazione e l'elaborazione dei dati. Questo è uno strumento piuttosto potente che viene utilizzato per comunicare tra Arduino e Cayenne e per formattare facilmente i dati in modo che possano essere facilmente visualizzati sulla dashboard. Ricorda, i collegamenti virtuali non hanno parametri fisici.
Cayenne.virtualWrite (V1, 123) // trasferimento del valore intero sul collegamento virtuale V1
Cayenne.virtualWrite (V2, 12.34) // trasmette valori in virgola mobile sul canale virtuale V2
Ad esempio, dopo aver letto un sensore di temperatura analogico, possiamo convertire il valore in gradi Celsius con una riga di codice e trasferire questo valore al dashboard. Inoltre, i canali virtuali consentono di controllare eventuali periferiche collegate alle porte analogiche o digitali di Arduino senza dover scrivere alcun codice aggiuntivo. Attualmente, sono supportati due tipi di dati con cui funzionano i canali virtuali: integer (integer) e floating point (float). In futuro è previsto il supporto per i tipi di caratteri e gli array. Sulla dashboard, tramite un canale virtuale, è possibile connettere e configurare un widget personalizzato per la visualizzazione in base al tipo di dati ricevuti.
// Porta digitale a cui verranno collegati i sensori DS18B20. Non utilizzare le porte Arduino 0 e 1 (Rx / Tx).
const int ds18b20_Pin \u003d 2;
// La porta analogica a cui è collegato il termistore.
const int thermistorPin \u003d 0;
// Resistenza di una resistenza fissa (9 kOhm), collegata in serie al termistore a terra.
resistenza al galleggiamento costante \u003d 9000;
// Chiave di autorizzazione Cayenne. Puoi trovarlo nell'interfaccia web di Cayenne nella scheda delle impostazioni del dispositivo.
token char \u003d "640c9oedi4";
OneWire oneWire (ds18b20_Pin);
DallasTemperature sensori (& oneWire);
Termistore termistore (termistorePin, resistenza);
A tua discrezione, in quasi tutte le fasi, puoi aggiungere l'output di debug tramite la porta seriale al codice sorgente.
Nella sezione di inizializzazione, specificheremo le seguenti funzioni:
void setup ()
{
Cayenne.begin (token); // connettersi alla Cayenne con la chiave di autorizzazione specificata
sensori.begin (); // inizializzazione dei sensori di temperatura digitali
u8x8.begin (); // inizializzazione e output di informazioni di testo sul display OLED
u8x8.setPowerSave (0);
u8x8.setFont (u8x8_font_torussansbold8_r);
u8x8.drawString (2.0, "Cayenne Test");
u8x8.drawString (1,2, "Sistema in esecuzione");
}
Nel ciclo principale del programma, avremo solo una funzione:
void loop ()
{
Cayenne.run ();
}
Tutte le comunicazioni con il cruscotto Cayenne vengono eseguite utilizzando diverse funzioni:
CAYENNE_IN (Virtual_Pin) - definisce una funzione che viene chiamata quando il dispositivo riceve dati aggiornati tramite il collegamento virtuale dal server Cayenne.
CAYENNE_OUT (Virtual_Pin) - definisce una funzione che viene chiamata quando i dati aggiornati dal dispositivo devono essere inviati al server Cayenne.
CAYENNE_CONNECTED () - la funzione viene eseguita ogni volta che il dispositivo è connesso al server Cayenne. In generale, questa funzione viene utilizzata per la sincronizzazione.
Cayenne.syncAll () - una funzione che richiede al server Cayenne di sincronizzare tutti i widget. Le porte analogiche e digitali di Arduino verranno ripristinate e ogni canale virtuale genererà un evento CAYENNE_IN.
Cayenne.syncVirtual (Virtual_Pin) - sincronizzazione sul canale virtuale specificato. Come risultato dell'esecuzione, viene chiamato il gestore CAYENNE_IN corrispondente.
Nel mio circuito il LED D2 è collegato alla porta digitale D6 di Arduino. Questa porta ha una funzione alternativa: uscita PWM. Per implementare il controllo remoto di questi LED in modalità PWM, dobbiamo ricevere i dati dalla dashboard. Per fare ciò, scriveremo una funzione che verrà eseguita durante l'aggiornamento dei dati sul canale virtuale V2:
CAYENNE_IN (V2)
{
// recupera i dati sul valore PWM dalla dashboard (cursore)
int PWMValue \u003d getValue.asInt (); // valore compreso tra 0 e 1023
analogWrite (LED2_PWM, PWMValue / 4); // per PWM, il valore deve essere compreso tra 0 e 255
}
Ora sulla dashboard, aggiungi il widget "Slider" con il nome LED_2 PWM (PWM), e nelle sue impostazioni indicheremo che funziona tramite il canale virtuale 2 (Figura 9).
Dopo aver caricato lo schizzo sulla lavagna, puoi utilizzare il cursore sul cruscotto Cayenne per controllare la luminosità del LED D2. Tutto è molto veloce e semplice ...
CAYENNE_OUT (V0)
{
sensori.requestTemperatures (); // recupera i dati dai sensori di temperatura digitali.
// trasforma i dati dal termistore, formattalo e invialo al server tramite il canale virtuale V1
Cayenne.celsiusWrite (V1, thermistor.getCelsius ());
// formatta i dati dal sensore di temperatura digitale e li invia al server tramite il canale virtuale V0
Cayenne.celsiusWrite (V0, sensori.getTempCByIndex (0));
}
A causa dell'uso di canali virtuali, l'intero codice funzione per il trasferimento di dati completamente diversi è costituito da due righe. Sul cruscotto, aggiungi i widget per il sensore di temperatura DS18B20 e il termistore (sono già pronti nel pannello di controllo). Impostiamo i widget, carichiamo lo schizzo nella lavagna e ... il gioco è fatto (Figure 10a, 10b)!
|
||||
| Figura 10. | Vista dashboard Cayenne per controllo Arduino (sensori di temperatura, illuminazione, controllo LED D1, controllo PWM LED D2): |
|||
Non dimenticare che le stesse funzioni di controllo e monitoraggio sono disponibili nell'applicazione mobile. Tutti i widget installati nell'interfaccia web possono essere visualizzati nell'applicazione mobile (Figura 10b).
La vista esterna del dispositivo con le periferiche collegate è mostrata nella Figura 11.
La capacità di sviluppare dispositivi IoT wireless
Avrai notato che in alcuni screenshot puoi vedere il mio pannello di controllo, dove oltre ad Arduino Uno e Raspberry Pi c'è un dispositivo chiamato ESP8266-1. Esatto, questo è un dispositivo aggiuntivo sul noto modulo ESP-12 (ESP8266), che è collegato al server Cayenne tramite Wi-Fi e ha il proprio cruscotto separato (Figure 12a, 12b). Un tale dispositivo è un'unità di monitoraggio e controllo wireless. Il modulo è collegato a due LED (uno è collegato all'uscita PWM dell'ESP8266) e un sensore di temperatura digitale DS18B20.
|
||||
| Figura 12. | Cruscotto per dispositivo wireless sul modulo ESP-12: a) interfaccia web, b) applicazione mobile. |
|||
Con il supporto del core ESP8266 nell'IDE di Arduino, l'implementazione di dispositivi IoT wireless con Cayenne non è diversa dallo sviluppo con Arduino. In altre parole, qualsiasi modulo sul chip ESP8266 è una scheda Arduino con un'interfaccia Wi-Fi. Per questo modulo Wi-Fi, scriviamo uno schizzo simile, utilizziamo le stesse librerie per lavorare con i sensori, abbiamo accesso alle porte di ingresso / uscita digitali e analogiche. Questo modulo ha accumulato un'enorme quantità di informazioni, documentazione e sviluppi vari.
Lo schema di collegamento delle periferiche al modulo ESP8266 è mostrato in Figura 13. Ho utilizzato un modulo ESP-12 separato senza montante con circuito di alimentazione integrato e interfaccia di programmazione, cosa che ha notevolmente complicato il lavoro in fase di download dello schizzo. L'opzione migliore sarebbe quella di utilizzare un modulo già pronto del tipo nodeMCU v3, realizzato nel fattore di forma Arduino e dotato di un circuito di corrispondenza dell'interfaccia. (Un punto molto importante quando si programma un modulo). La vista esterna del modulo con LED collegati e un sensore di temperatura è mostrata nella Figura 14.
Per quanto riguarda la connessione al server Cayenne e lo scambio di dati, tutto è come per Arduino. Tutti i concetti di canali virtuali vengono preservati, vengono utilizzate le stesse funzioni e viene utilizzata anche una chiave di autorizzazione univoca. L'unica differenza è nella fase di connessione del modulo a Internet.
Per collegare un dispositivo al modulo ESP8266 si procede come se si aggiungesse una qualsiasi scheda Arduino e si giunge alla fase di attesa del collegamento del dispositivo alla Cayenne, dove verrà generato uno sketch minimo.
Dobbiamo cambiare questo schizzo. Colleghiamo le seguenti librerie:
#include "CayenneDefines.h" // Costanti e variabili di Cayenne
#include "BlynkSimpleEsp8266.h" // funziona per lavorare con ESP8266
#include "CayenneWiFiClient.h" // funziona per implementare un client Wi-Fi
token char \u003d "3yj62u9ogi";
char ssid \u003d "Network_SSID"; // SSID e password per la tua rete Wi-Fi.
char password \u003d "Network_Password";
Nella sezione di inizializzazione, aggiungi la riga:
Cayenne.begin (token, ssid, password);
Compiliamo, carichiamo nel modulo (richiede più tempo del caricamento nella scheda Arduino), attendiamo la connessione e l'attivazione del nuovo dispositivo nella dashboard di Cayenne. Successivamente, tutto è come per Arduino: aggiungiamo funzioni per lavorare con sensori e porte I / O, aggiungiamo widget alla dashboard. Semplicemente fantastico, non è vero ?!
Conclusione
Sulla base dei risultati del lavoro con la Cayenne su Raspberry Pi e Arduino, posso sicuramente dire che il Raspberry Pi non dovrebbe essere utilizzato per lo sviluppo di dispositivi IoT, anche con il Cayenne. Lo stesso non si può dire per l'Arduino che nonostante le risorse limitate, la mancanza di multitasking, la bassa potenza di elaborazione (sebbene questo sia un punto controverso, viste le caratteristiche delle nuove schede Arduino su processori ARM), è ideale per sviluppare dispositivi IoT semplici e sistemi domotici.
Inoltre, in questo contesto, il principale vantaggio di Arduino, come ho notato sopra, è la capacità di sviluppare autonomamente un dispositivo, studiare circuiti, scrivere codice, sviluppare capacità di programmazione, nonostante le argomentazioni di programmatori professionisti che non si possono imparare a programmare con Arduino. Forse, ma ... In relazione ad Arduino, la piattaforma Cayenne fornisce solo un'interfaccia utente grafica e alcune semplificazioni nell'elaborazione dei dati. È necessario sviluppare tutto il resto da soli, inclusa l'elaborazione primaria dei dati dai sensori, un sottosistema di elaborazione degli eventi, nonché le condizioni e gli algoritmi di automazione. Ora aggiungi ad Arduino la semplicità di sviluppare dispositivi IoT wireless sul modulo Wi-Fi ESP8266 e il supporto già ufficiale (anche se non completo) dell'ultimo chip ESP32, che dispone di ricche periferiche a bordo, e hai grandi opportunità per sviluppare dispositivi fondamentalmente nuovi e attrarre questo processo non è solo per i dilettanti, ma anche per i professionisti.
Al momento della scrittura, Cayenne non ha segnalato il supporto ufficiale per i moduli basati sul chip ESP8266. Inizialmente, questo è il merito della comunità: i dilettanti e gli ingegneri che lavorano o utilizzano l'IDE di Arduino e conoscono il supporto per ESP8266, utilizzando le librerie Cayenne sono stati in grado di connettersi e utilizzare ESP8266. Ma anche a quel tempo, era già possibile conoscere un gran numero di diversi progetti di dispositivi IoT wireless sui forum della comunità di Cayenne.
Dopo aver testato a lungo i miei dispositivi su Arduino ed ESP8266, posso dire che quest'ultimo è molto stabile. L'affidabilità piuttosto bassa di Arduino con Ethernet Shield è dovuta al noto problema del congelamento del controller W5100, ma ci sono diversi modi per risolverlo, sia hardware che software. La mia ipotesi è che questo non si applichi alle schede Arduino con Ethernet o Wi-Fi integrati.
Non è passato molto tempo da quando l'articolo Raspberry Pi e Cayenne è stato scritto, ma ci sono molte più nuove funzionalità e periferiche supportate. Oltre ad avere una vasta selezione di varie schede di espansione, sensori e attuatori, librerie corrispondenti, progetti ed esempi per Arduino, ora gli utenti di Cayenne hanno accesso a dispositivi LoRa, reti e servizi, librerie per supportare il protocollo di rete MQTT per Arduino, C, C ++, mBed, librerie per collaborando con il broker Mosquito MQTT. Sicuramente, per lo sviluppo di dispositivi IoT e sistemi domotici su Arduino, consiglierei i servizi Cayenne.
