Drago Sine-ese: 10 Passi (con Immagini)

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:04

Sine-ese Dragon è un pezzo di arredamento per la casa che utilizza movimenti meccanici e luci per comunicarti le previsioni del tempo per i prossimi tre intervalli di tre ore. Per definizione, l'ambiente descrive gli immediati dintorni di qualcosa; quindi è stato deciso di incorporare i dati meteorologici in un display ambientale. Il meteo è un aspetto che cambia involontariamente la giornata delle persone ed è un'informazione che cambia costantemente ogni minuto, o addirittura al secondo.

Il drago cinese è "un simbolo di potere, forza e buona fortuna" ed è spesso considerato un alto valore culturale e tradizionale in tutto il subcontinente asiatico. Oltre a portare fortuna, si dice che il drago cinese abbia anche potenti poteri che controllano "acqua, pioggia, tifoni e inondazioni". Alla fine, il drago cinese è stato ritenuto appropriato per rappresentare i dati meteorologici.

Visualizzazione

Il Drago Sine-ese viene manipolato in sei punti principali in tre sezioni separate che rappresentano le previsioni del tempo per tre intervalli di 3 ore. Per ogni intervallo di 3 ore, saranno incluse le seguenti informazioni:

• Descrizione meteo: determina il colore delle informazioni meteo correnti.
• Temperatura - specifica l'altezza del corpo
• Umidità - lampeggio dei segmenti LED
• Velocità del vento: controlla la velocità del corpo che si muove a sinistra ea destra.

Materiali richiesti

1. Compensato/cartone da 3 mm
2. Bacchette o tasselli in legno da 5 mm
3. 2 fotoni di particelle
4. 3 giocattoli sinuosi
5. 6 servomotori
6. Luci NeoPixel (un filo o luci singole cucite insieme)
7. Tanta super colla
8. Filo conduttivo
9. Colori acrilici
10. Tessuto decorativo
11. Taglio laser
12. stampante 3d

Passaggio 1: su e giù

Il tuo primo passo per costruire il Drago Sine-ese è costruire il componente che controlla il movimento su e giù del corpo. Che emozione!

1. Scarica i file Adobe Illustrator (.ai) e stampali utilizzando una macchina da taglio laser.

   upDownBoxWithPlatform.ai dovrebbe essere stampato su un cartone

2. Scarica i file di stampa 3D (.stl) e usa la tua stampante 3D preferita per stamparli.

   Il colore non ha importanza per il disco o per il giradischi. Nella seconda immagine, il giradischi è stato inserito all'interno del foro del disco

3. Assemblare i primi due componenti e incollarli insieme come mostrato nelle immagini da 3 a 5.

   1. La piattaforma
   2. Le scanalature per il disco

4. Ora, assembla la scatola seguendo i suggerimenti di seguito.

   1. I cavi del servo dovrebbero passare attraverso l'apertura rettangolare sul lato della scatola.
   2. L'estremità più corta del giradischi viene attaccata alla testa del servo e l'estremità più lunga passa attraverso il foro dell'altro lato della scatola con un foro circolare su di esso. Ciò è dimostrato nella figura 6.
5. Ora, abbiamo bisogno di qualcosa per garantire che la piattaforma rimanga livellata quando il disco viene girato. Taglia le bacchette in bastoncini lunghi 75 mm (figura 7) e incollali attraverso la parte superiore della scatola nella parte superiore della piattaforma usando la colla a caldo. Assicurati che i bastoncini siano livellati a 90 gradi rispetto alla piattaforma.
6. Inserisci un bastoncino lungo 212 mm nel foro centrale sulla parte superiore della scatola sulla piattaforma.

Dolce! Ora hai una scatola completa (figura 8) per il movimento su e giù del drago. Ora, ripeti i passaggi precedenti altre due volte!

Passaggio 2: che dire di sinistra e destra?

Ora, non possiamo dimenticare il movimento sinistro e destro del Drago Sine-ese, vero? Passiamo al secondo passaggio!

1. Scarica i file Adobe Illustrator (.ai) e stampali utilizzando una macchina da taglio laser.

   1. leftRightBoxWithPlatforms.ai dovrebbe essere stampato su un cartone.
   2. Il file armTurner.ai deve essere stampato su un materiale di 3 mm di spessore.

2. Scarica i file di stampa 3D (.stl) e usa la tua stampante 3D preferita per stamparli.

   Assicurati di stampare due delle braccia! Il colore non ha importanza qui

3. Assemblare le due piattaforme insieme come mostrato in figura 3 utilizzando la colla a caldo.

4. Metti insieme la scatola. Sebbene possa essere difficile farlo, è più facile da ottenere:

   1. Inserimento delle due piattaforme tra le due grandi fessure su entrambi i lati della scatola.
   2. Posizionando il primo braccio sulla parte superiore della piattaforma superiore.
   3. Infilare il girabraccio attraverso il braccio e poi la piattaforma superiore.
   4. Posizionando il secondo braccio sulla parte superiore della piattaforma inferiore.
   5. Infilare il girabraccio attraverso il secondo braccio e poi la piattaforma inferiore.
   6. Attaccare il girabraccio attraverso l'apertura rettangolare del girabraccio stampato in 3D.
   7. L'altra estremità del tornio va sopra il servomotore.
   8. Aggiungi i pezzi superiore, inferiore e posteriore alla scatola.

La tua ultima scatola assemblata dovrebbe assomigliare alla sesta immagine. Ora puoi ripeterlo altre due volte!

Alla fine di questo passaggio, dovresti avere sei caselle con tre ciascuno dei sistemi di movimento su/giù e sinistra/destra.

Passaggio 3: sostenere il corpo… COME?

Buona domanda! È allora che entrano in gioco quei supporti slinky stampati in 3D. Scarica il file.stl incluso e stampalo utilizzando una stampante 3D. Assicurati di stampare 6 supporti in totale per le 6 diverse scatole.

Se hai visto l'immagine del supporto slinky sopra, la sorpresa è stata rovinata: questo è il colore del nostro Drago Sine-ese!

Passaggio 4: ma quelle scatole non sono così carine…

E sono d'accordo! Questo è il motivo per cui utilizzeremo un laser cutter per tagliare una scatola molto più attraente per contenere tutte quelle scatole e nasconderle.

Scarica quei file di Adobe Illustrator e ritagliali usando il laser cutter. Il design delle nuvole è stato disegnato a mano da uno dei contributori. Sentiti libero di modificarli rimuovendoli all'interno del file Illustrator e aggiungendo il tuo design come meglio credi! Di seguito sono riportati i passaggi suggeriti per mettere insieme il tutto.

1. Assemblare e incollare insieme tutti e tre i pezzi del primo file (outerBoxFinal_1).
2. Non aggiungere ancora il pezzo dal secondo file (outerBoxFinal_2).
3. Metti il pezzo dal terzo file (outerBoxFinal_3) in fondo alla scatola e dovrebbe chiudersi in alto. Colla SOLO nella parte inferiore della scatola.
4. Stampa innerBoxesPlatform due volte. Incolla insieme i due pezzi che hanno grandi fori rettangolari. Quindi, incolla insieme tre dei pezzi rimanenti. Infine, incollalo all'altro set incollato con i fori.
5. Posiziona la piattaforma nella parte inferiore della scatola grande.
6. Inserisci tutte e 6 le scatole più piccole nei punti corrispondenti sulla piattaforma.
7. Ora, posiziona il pezzo del secondo file (outerBoxFinal_2) sulla parte superiore della scatola e incolla intorno al bordo. I fori sul pezzo superiore dovrebbero allinearsi con i fori sulle scatole più piccole. In caso contrario, riorganizza le tue scatole più piccole. Non aggiungere assolutamente colla alle scatole più piccole.
8. Se stai usando una breadboard che ha un pezzo appiccicoso nella parte inferiore, posizionalo vicino al centro del pezzo inferiore in un punto in cui quando chiudi la scatola, la breadboard insieme ai fotoni dovrebbe scomparire. Ci sono piccole fessure sul pezzo inferiore che facilitano la connessione ai fotoni dall'esterno.

Passaggio 5: giocattoli slinky?? Oh mio

Corpo del drago:

1. Combina tre slinky insieme usando colla a caldo o nastro adesivo.

2. Misura la lunghezza e il diametro degli elastici e taglia un pezzo di tessuto decorativo.

3. Porta le due estremità del tessuto e cucile insieme.

4. Una volta che hai finito di cucirli, fai scivolare gli slip come un calzino.

5. Cucire le estremità dello slinky al tessuto cucito.

Passaggio 6: stampa il tuo drago

Parti stampate in 3D del drago:

1. Le parti sono state prese da

2. Abbiamo usato solo la testa, le gambe e gli occhi.

3. Dopo aver stampato in 3D la parte, levigarla con carta vetrata e acetone.

4. Dipingi le parti nel modo in cui desideri decorarle.

Passaggio 7: è ora di potenziare il tuo drago con NeoPixels

Segmento leggero:

1. Puoi semplicemente usare un filo di neopixel per creare le luci, se lo desideri. (Abbiamo finito i fili).

2. Abbiamo usato 20 luci neopixel e le abbiamo collegate usando dei cavi. Questi fili sono stati saldati su di essi e collegati al fotone utilizzando un cablaggio rosso in modo che corrisponda al tema del drago.

3. Puoi anche cucire le tue luci al neopixel su un lungo pezzo di stoffa, ma non le abbiamo usate perché avevamo uno slinky fatto di metallo.

Assemblaggio delle parti: Fissare il segmento di luce all'interno del corpo del drago utilizzando fili o fili. Assicurati di essere in grado di collegare le luci al fotone all'interno della scatola di base. Attacca la testa, le zampe e la coda al corpo usando la colla. Una volta che sono a posto, fissa il corpo nei supporti attillati che abbiamo stampato prima. Ora il corpo è pronto per essere programmato.

Passaggio 8: tempo di programmazione

Poiché utilizzeremo due fotoni di particelle per lavorare con sei servomotori separati (un fotone può funzionare solo con quattro), scriveremo due codici separati ma simili da lampeggiare sui microcontrollori.

Ora, per il primo microcontrollore…

In un file Arduino (.ino), includi le seguenti librerie e definisce:

#include "neopixel.h"

#include "ArduinoJson.h"

#define PIXEL_PIN D4

#define PIXEL_COUNT 18

Quindi, dichiara le seguenti variabili:

striscia Adafruit_NeoPixel = Adafruit_NeoPixel(PIXEL_COUNT, PIXEL_PIN);

Servo servoLeftRight_1; Servo servoUpDown_1; Servo servoLeftRight_2; Servo servoUpDown_2; int positionLeftRight_1 = 0; int positionUpDown_1 = 0; int leftRight_1 = 1; int upDown_1 = 1; int positionLeftRight_2 = 100; // deve essere compreso tra 0 e 180 (in gradi) int positionUpDown_2 = 180; // deve essere compreso tra 0 e 180 (in gradi) int leftRight_2 = 1; //0=sinistra, 1=destra int upDown_2 = 1; //0=su, 1=giù const size_t bufferSizeCurrent = JSON_ARRAY_SIZE(1) + JSON_OBJECT_SIZE(1) + 2*JSON_OBJECT_SIZE(2) + JSON_OBJECT_SIZE(4) + JSON_OBJECT_SIZE(5) + JSON_OBJECT_SIZE(6) + JSON_OBJECT) + 390; const size_t bufferSizeForecast = 38*JSON_ARRAY_SIZE(1) + JSON_ARRAY_SIZE(38) + 2*JSON_OBJECT_SIZE(0) + 112*JSON_OBJECT_SIZE(1) + 39*JSON_OBJECT_SIZE(2) + JSON_OBJECT_SIZE(3) + 38*JSON_OBJECT) (5) + 76*JSON_OBJECT_SIZE(8) + 12490; stringa weatherArray[3]; float temperatureArray[3]; float umiditàArray[3]; float windSpeedArray[3]; Stringa timestampArray[3]; int upDownMaxDegree[3]; int leftRightSpeed[3]; Stringa allData5DaysForecast;

Fare clic qui per informazioni su come impostare i webhook. Al termine, aggiungere le seguenti dichiarazioni e funzioni e apportare le modifiche appropriate se necessario:

void getWeather5DayForecast() { Particle.publish("get_weather5DayForecast"); allData5DaysForecast = ""; } Timer timerWeatherForecast(60000, getWeather5DayForecast); void getCurrentWeather() { Particle.publish("get_currentWeather"); } Timer timerWeatherCurrent(60000, getCurrentWeather);

Le seguenti funzioni controllano i movimenti su/giù e sinistra/destra del drago:

void changeLeftRight1() { if (leftRight_1) { positionLeftRight_1 = positionLeftRight_1 + leftRightSpeed[0]; if (positionLeftRight_1 > 100) { leftRight_1 = 0; } } else { positionLeftRight_1 = positionLeftRight_1 - leftRightSpeed[0]; if (positionLeftRight_1 < 0) { leftRight_1 = 1; } } servoLeftRight_1.write(positionLeftRight_1); }

void changeLeftRight2() {

if (leftRight_2) { positionLeftRight_2 = positionLeftRight_2 + leftRightSpeed[1]; if (positionLeftRight_2 > 100) { leftRight_2 = 0; } } else { positionLeftRight_2 = positionLeftRight_2 - leftRightSpeed[1]; if (positionLeftRight_2 < 0) { leftRight_2 = 1; } } servoLeftRight_2.write(positionLeftRight_2); }

void changeUpDown1() {

if (upDown_1) { positionUpDown_1++; if (positionUpDown_1 > upDownMaxDegree[0]) { upDown_1 = 0; } } else { positionUpDown_1--; if (posizioneUpDown_1 < 1) { upDown_1 = 1; } } servoUpDown_1.write(positionUpDown_1); }

void changeUpDown2() {

if (upDown_2) { positionUpDown_2++; if (positionUpDown_2 > upDownMaxDegree[1]) { upDown_2 = 0; } } else { positionUpDown_2--; if (positionUpDown_2 < 1) { upDown_2 = 1; } } servoUpDown_2.write(positionUpDown_2); }

Per poter modificare i movimenti in un intervallo, vengono creati dei timer.

Timer timerLeftRight1(100, changeLeftRight1);

Timer timerLeftRight2(100, changeLeftRight2); Timer timerUpDown1(10, changeUpDown1); Timer timerUpDown2(10, changeUpDown2);

La funzione di configurazione viene infine aggiunta successivamente. Assicurati di apportare le modifiche appropriate alle righe di codice che si occupano dei webhook.

void setup() { // avvia i timer meteorologici timerWeatherForecast.start(); timerMeteoCurrent.start(); //Neopixel strip.begin(); // Metti l'inizializzazione come pinMode e inizia le funzioni qui. // Imposta il Micro Servo servoLeftRight_1.attach(D1); servoUpDown_1.attach(D0); servoLeftRight_2.attach(D3); servoUpDown_2.attach(D2); servoLeftRight_1.write(positionLeftRight_1); //inizializza la posizione del servo servoUpDown_1.write(positionUpDown_1); //inizializza la posizione del servo servoLeftRight_2.write(positionLeftRight_2); //inizializza la posizione del servo servoUpDown_2.write(positionUpDown_2); //inizializza la posizione del servo timerLeftRight1.start(); timerLeftRight2.start(); timerUpDown1.start(); timerUpDown2.start(); // Apre una console Serial.begin(9600); ritardo (2000); Serial.println("Ciao!"); // Iscriviti ai webhook get_weather5DayForecast e get_currentWeather Particle.subscribe("hook-response/get_weather5DayForecast", gotWeather5DayForecast, MY_DEVICES); Particle.subscribe("hook-response/get_currentWeather/0", gotCurrentWeatherData, MY_DEVICES); getCurrentWeather(); getWeather5DayForecast(); }

Una funzione loop non viene utilizzata per questo progetto. Non possiamo dimenticare le funzioni per gestire i dati ricevuti dai webhook!

void gotWeather5DayForecast(const char *event, const char *data){ allData5DaysForecast += data; // salva tutti i dati in una stringa. int allData5DaysForecastLen = allData5DaysForecast.length(); char buffer[allData5DaysForecastLen + 1]; allData5DaysForecast.toCharArray(buffer, allData5DaysForecastLen + 1); // crea un buffer per la stringa int bufferLength = sizeof(buffer); DynamicJsonBuffer jsonBufferWeather(bufferLength); JsonObject& root = jsonBufferWeather.parseObject(buffer); // Verifica se l'analisi ha esito positivo. if (!root.success()) { //Serial.println("Analisi delle previsioni del tempo a 5 giorni…ERRORE!"); Restituzione; } int i = 1; JsonArray& list = root["list"]; for (JsonObject& oggetto corrente: lista){ if (i < 3){ Oggetto Json& main = oggetto corrente["principale"]; float temperatura = main["temp"]; int umidità = main["umidità"]; JsonObject& meteo = currentObject["meteo"][0]; const char* weatherInfo = weather["main"]; float windSpeed = currentObject["wind"]["speed"]; const char* timestamp = currentObject["dt_txt"]; int tempFah = convertToFahrenheit(temperatura); int servoMaxDegree = updateUpDown(tempFah); upDownMaxDegree = servoMaxDegree; int servoIncrement = updateleftRight(windSpeed); leftRightSpeed = servoIncrement; setColor(weatherInfo, i); temperatureArray = tempFah; umiditàArray = umidità; weatherArray = weatherInfo; windSpeedArray = windSpeed; timestampArray = timestamp; io++; } else{ pausa; } } }

void gotCurrentWeatherData(const char *event, const char *data){ DynamicJsonBuffer jsonBufferWeather(bufferSizeCurrent); JsonObject& root = jsonBufferWeather.parseObject(data); // Verifica se l'analisi ha esito positivo. if (!root.success()) { //Serial.println("Analisi del meteo attuale…ERRORE!"); Restituzione; } JsonObject& meteo = root["meteo"][0]; const char* weather_main = meteo["main"]; JsonObject& main = root["main"]; float main_temp = main["temp"]; int main_humidity = main["umidità"]; float wind_speed = root["vento"]["velocità"]; const char* timestamp = root["dt_txt"]; int tempFah = convertToFahrenheit(main_temp); int servoMaxDegree = updateUpDown(tempFah); upDownMaxDegree[0] = servoMaxDegree; int servoIncrement = updateleftRight(wind_speed); leftRightSpeed[0] = servoIncrement; setColor(meteo_principale, 0); weatherArray[0] = weather_main; temperatureArray[0] = tempFah; umiditàArray[0]= main_humidity; windSpeedArray[0] = wind_speed; timestampArray[0] = timestamp; }

Di seguito, puoi trovare funzioni aggiuntive che controllano l'aggiornamento delle posizioni dei servomotori, la conversione della temperatura da Kelvin a Fahrenheit e l'impostazione dei colori dei LED.

int updateUpDown(float temp){ //Mappa il grado su un intervallo di [0, 180] float servoMaxDegree = temp * 45 / 31 + (990 / 31); Serial.print("nuovo grado servo: "); Serial.println(servoMaxDegree); restituire servoMaxDegree; }

int updateleftRight(float windSpeed){

//Mappa la velocità del vento su un intervallo di [1, 100] float servoIncrement = windSpeed * 99 / 26 + 1; Serial.print("nuovo valore incremento servo: "); Serial.println(servoIncrement); ritorno servoIncrement; }

int convertToFahrenheit(float tempKel){

int tempFah = tempKel * 9,0 / 5,0 - 459,67; ritorno tempFah; }

void setColor(String weatherDesc, int index){

int ledIndex = 0; if (indice == 0){ ledIndex = 0; } else if (indice == 1){ ledIndex = 6; } else if (indice == 2){ ledIndex = 12; } else{ ritorno; } if(weatherDesc == "Clear") { //yellow for (int j = ledIndex; j < ledIndex+6; j++){ strip.setPixelColor(j, strip. Color(253, 219, 62));// striscia gialla.show(); ritardo(20); } } else if(weatherDesc == "Nuvole"){ //grey for (int j = ledIndex; j < ledIndex+6; j++){ strip.setPixelColor(j, strip. Color(223, 229, 237)); //striscia grigia.show(); ritardo(20); } } else if (weatherDesc == "Neve"){ //white for (int j = ledIndex; j < ledIndex+6; j++){ strip.setPixelColor(j, strip. Color(255, 225, 225)); //striscia bianca.show(); ritardo(20); } } else if (weatherDesc == "Rain"){//blue for (int j = ledIndex; j < ledIndex+6; j++){ strip.setPixelColor(j, strip. Color(119, 191, 246)); //striscia blu.show(); ritardo(20); } } else{ //red for (int j = ledIndex; j < ledIndex+6; j++){ strip.setPixelColor(j, strip. Color(254, 11, 5));//red strip.show(); ritardo(20); } } }

Una volta che hai aggiunto tutto al tuo file Arduino, compilalo. Se non ci sono errori, vai avanti e invia il codice al primo Photon. Il prossimo passo ti fornirà un codice simile da far lampeggiare sul secondo Photon.

Passaggio 9: la programmazione continua

Poiché il codice per il secondo Photon è quasi identico a quello per il primo, l'intero codice viene copiato e incollato di seguito:

#include "ArduinoJson.h"

Servo servoLeftRight_3;

Servo servoUpDown_3;

int positionLeftRight_3 = 45;

int positionUpDown_3 = 0; int leftRight_3 = 1; int upDown_3 = 1;

const size_t bufferSizeCurrent = JSON_ARRAY_SIZE(1) + JSON_OBJECT_SIZE(1) + 2*JSON_OBJECT_SIZE(2) + JSON_OBJECT_SIZE(4) + JSON_OBJECT_SIZE(5) + JSON_OBJECT_SIZE(6) + JSON_OBJECT_SIZE;(12) + 390

const size_t bufferSizeForecast = 38*JSON_ARRAY_SIZE(1) + JSON_ARRAY_SIZE(38) + 2*JSON_OBJECT_SIZE(0) + 112*JSON_OBJECT_SIZE(1) + 39*JSON_OBJECT_SIZE(2) + JSON_OBJECT_SIZE(3) + 38*JSON_OBJECT) (5) + 76*JSON_OBJECT_SIZE(8) + 12490;

stringa weatherArray[3];

float temperatureArray[3]; float umiditàArray[3]; float windSpeedArray[3]; Stringa timestampArray[3]; int upDownMaxDegree[3]; int leftRightSpeed[3];

Stringa allData5DaysForecast;

void getWeather5DayForecast()

{ Particle.publish("get_weather5DayForecast2"); allData5DaysForecast = ""; }

Timer timerWeatherForecast(60000, getWeather5DayForecast); //10, 800, 000 ms = 3 giorni

void getCurrentWeather()

{ Particle.publish("get_currentWeather2"); }

Timer timerWeatherCurrent(60000, getCurrentWeather);

void changeLeftRight3() {

if (leftRight_3) { positionLeftRight_3 = positionLeftRight_3 + leftRightSpeed[2]; if (positionLeftRight_3 > 100) { leftRight_3 = 0; } } else { positionLeftRight_3 = positionLeftRight_3 - leftRightSpeed[2]; if (positionLeftRight_3 < 0) { leftRight_3 = 1; } } servoLeftRight_3.write(positionLeftRight_3); }

void changeUpDown3() {

if (upDown_3) { positionUpDown_3++; if (positionUpDown_3 > upDownMaxDegree[2]) { upDown_3 = 0; } } else { positionUpDown_3--; if (posizioneUpDown_3 < 1) { upDown_3 = 1; } } servoUpDown_3.write(positionUpDown_3); }

Timer timerLeftRight3(100, changeLeftRight3);

Timer timerUpDown3(10, changeUpDown3);

void setup() {

// avvia i timer meteorologici timerWeatherForecast.start(); timerMeteoCurrent.start(); // Metti l'inizializzazione come pinMode e inizia le funzioni qui. // Imposta il Micro Servo servoLeftRight_3.attach(D1); servoUpDown_3.attach(D0);

servoLeftRight_3.write(positionLeftRight_3); //inizializza la posizione del servo

servoUpDown_3.write(positionUpDown_3); //inizializza la posizione del servo

timerLeftRight3.start();

timerUpDown3.start(); // Apre una console Serial.begin(9600); ritardo (2000); Serial.println("Ciao!"); // Iscriviti ai webhook get_weather5DayForecast e get_currentWeather Particle.subscribe("hook-response/get_weather5DayForecast2", gotWeather5DayForecast, MY_DEVICES); Particle.subscribe("hook-response/get_currentWeather2/0", gotCurrentWeatherData, MY_DEVICES); getCurrentWeather(); getWeather5DayForecast(); }

void gotWeather5DayForecast(const char *event, const char *data)

{ allData5DaysForecast += dati; // salva tutti i dati in una stringa. int allData5DaysForecastLen = allData5DaysForecast.length(); char buffer[allData5DaysForecastLen + 1]; allData5DaysForecast.toCharArray(buffer, allData5DaysForecastLen + 1); // crea un buffer per la stringa int bufferLength = sizeof(buffer); DynamicJsonBuffer jsonBufferWeather(bufferLength); JsonObject& root = jsonBufferWeather.parseObject(buffer); //Serial.println(allData5DaysForecast); // Verifica se l'analisi ha esito positivo. if (!root.success()) { //Serial.println("Analisi delle previsioni del tempo a 5 giorni…ERRORE!"); Restituzione; } int i = 1; JsonArray& list = root["list"]; for (JsonObject& oggetto corrente: lista){ if (i < 3){ Oggetto Json& main = oggetto corrente["principale"]; float temperatura = main["temp"]; int umidità = main["umidità"]; JsonObject& meteo = currentObject["meteo"][0]; const char* weatherInfo = weather["main"]; float windSpeed = currentObject["wind"]["speed"]; const char* timestamp = currentObject["dt_txt"]; int tempFah = convertToFahrenheit(temperatura); int servoMaxDegree = updateUpDown(tempFah); upDownMaxDegree = servoMaxDegree; int servoIncrement = updateleftRight(windSpeed); leftRightSpeed = servoIncrement; temperatureArray = tempFah; umiditàArray = umidità; weatherArray = weatherInfo; windSpeedArray = windSpeed; timestampArray = timestamp; io++; } else{ pausa; } } }

void gotCurrentWeatherData(const char *event, const char *data)

{ DynamicJsonBuffer jsonBufferWeather(bufferSizeCurrent); JsonObject& root = jsonBufferWeather.parseObject(data); //Serial.println(data); // Verifica se l'analisi ha esito positivo. if (!root.success()) { //Serial.println("Analisi del meteo attuale…ERRORE!"); Restituzione; } JsonObject& meteo = root["meteo"][0]; const char* weather_main = meteo["main"]; JsonObject& main = root["main"]; float main_temp = main["temp"]; int main_humidity = main["umidità"]; float wind_speed = root["vento"]["velocità"]; const char* timestamp = root["dt_txt"]; int tempFah = convertToFahrenheit(main_temp); int servoMaxDegree = updateUpDown(tempFah); upDownMaxDegree[0] = servoMaxDegree; int servoIncrement = updateleftRight(wind_speed); leftRightSpeed[0] = servoIncrement; weatherArray[0] = weather_main; temperatureArray[0] = tempFah; umiditàArray[0]= main_humidity; windSpeedArray[0] = wind_speed; timestampArray[0] = timestamp; }

int updateUpDown(float temp){

//Mappa il grado su un intervallo di [0, 180] float servoMaxDegree = temp * 45 / 31 + (990 / 31); Serial.print("nuovo grado servo: "); Serial.println(servoMaxDegree); restituire servoMaxDegree; }

int updateleftRight(float windSpeed){

//Mappa la velocità del vento su un intervallo di [1, 100] float servoIncrement = windSpeed * 99 / 26 + 1; Serial.print("nuovo valore incremento servo: "); Serial.println(servoIncrement); ritorno servoIncrement; }

int convertToFahrenheit(float tempKel){

int tempFah = tempKel * 9,0 / 5,0 - 459,67; ritorno tempFah; }

Ce l'hai fatta! Hai superato la sezione di programmazione del progetto! Ora, assicurati di eseguire tutti i cablaggi e le connessioni dai servomotori e dai neopixel alla breadboard e ai microcontrollori. NOTA: inserisci i tasselli/bacchette extra attraverso le fessure verticali sulle scatole per i movimenti sinistro e destro del corpo. L'altra estremità dovrebbe essere collegata al corpo del drago.

Passaggio 10: goditi il tuo drago

Congratulazioni! Hai costruito da zero un Drago Sine-ese! Ora tutto ciò che devi fare è sederti e goderti il tuo display ambientale!

NOTA: questo progetto è stato realizzato come parte di un corso di Joan Bempong e Soundarya Muthuvel. La pagina del corso la trovate qui.