Dragon Sine-ese : 10 étapes (avec photos)

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:09

Sine-ese Dragon est une pièce de décoration d'ambiance qui utilise des mouvements mécaniques et des lumières pour vous indiquer les prévisions météorologiques pour les trois prochains intervalles de trois heures. Par définition, ambient décrit l'environnement immédiat de quelque chose; il a donc été décidé qu'il était approprié d'incorporer des données météorologiques dans un affichage ambiant. La météo est un aspect qui change involontairement la journée des gens et est une information qui change constamment à chaque minute, voire à la seconde près.

Le dragon chinois est «un symbole de pouvoir, de force et de chance» et est souvent considéré comme une valeur culturelle et traditionnelle élevée à travers le sous-continent asiatique. En plus d'apporter la bonne fortune, le dragon chinois aurait également de puissants pouvoirs qui contrôlent "l'eau, les précipitations, les typhons et les inondations". En fin de compte, le dragon chinois a été jugé approprié pour représenter les données météorologiques.

Visualisation

Le Dragon Sine-ese est manipulé à six points principaux à trois sections distinctes représentant les prévisions météorologiques pour trois intervalles de 3 heures. Pour chaque intervalle de 3 heures, les informations suivantes seront incluses:

• Description météorologique - détermine la couleur des informations météo actuelles.
• Température - spécifie la hauteur du corps
• Humidité - clignotement des segments LED
• Vitesse du vent - contrôle la vitesse du corps se déplaçant à gauche et à droite.

Matériaux nécessaires

1. Contreplaqué 3 mm/Carton
2. Chevilles ou baguettes en bois de 5 mm
3. 2 photons de particules
4. 3 jouets moulants
5. 6 servomoteurs
6. Lumières NeoPixel (soit un brin, soit des lumières individuelles cousues ensemble)
7. Beaucoup de super colle
8. Fil conducteur
9. Peinture acrylique
10. Tissu décoratif
11. Découpeur laser
12. Imprimante 3D

Étape 1: De haut en bas

Votre toute première étape pour construire le Dragon Sine-ese consiste à construire le composant qui contrôle les mouvements de haut en bas du corps. Comme c'est excitant !

1. Téléchargez les fichiers Adobe Illustrator (.ai) et imprimez-les à l'aide d'une machine de découpe laser.

   upDownBoxWithPlatform.ai doit être imprimé sur un carton

2. Téléchargez les fichiers d'impression 3D (.stl) et utilisez votre imprimante 3D préférée pour les imprimer.

   La couleur n'a pas d'importance pour le disque ou le tourne-disque. Dans la deuxième image, le tourne-disque a été inséré à l'intérieur du trou du disque

3. Assemblez les deux premiers composants et collez-les ensemble comme indiqué sur les images 3 à 5.

   1. La plateforme
   2. Les rainures pour le disque

4. Maintenant, assemblez la boîte en suivant les conseils ci-dessous.

   1. Les fils du servo doivent passer par l'ouverture rectangulaire sur le côté de la boîte.
   2. L'extrémité la plus courte du tourne-disque est fixée à la tête d'asservissement et l'extrémité la plus longue passe par le trou de l'autre côté de la boîte avec un trou circulaire dessus. C'est ce que montre l'image 6.
5. Maintenant, nous avons besoin de quelque chose pour nous assurer que la plate-forme reste à niveau lorsque le disque est tourné. Coupez la baguette en bâtonnets de 75 mm de long (image 7) et collez-les à travers le haut de la boîte dans le haut de la plate-forme à l'aide de colle chaude. Assurez-vous que les bâtons sont nivelés à 90 degrés par rapport à la plate-forme.
6. Insérez un bâton de 212 mm de long dans le trou du milieu sur le dessus de la boîte sur la plate-forme.

Doux! Vous disposez maintenant d'une boîte complète (image 8) pour le mouvement de haut en bas du dragon. Maintenant, répétez les étapes ci-dessus deux fois de plus !

Étape 2: qu'en est-il de la gauche et de la droite ?

Maintenant, nous ne pouvons pas oublier le mouvement gauche et droit du Dragon Sine-ese, n'est-ce pas ? Passons à la deuxième étape !

1. Téléchargez les fichiers Adobe Illustrator (.ai) et imprimez-les à l'aide d'une machine de découpe laser.

   1. leftRightBoxWithPlatforms.ai doit être imprimé sur un carton.
   2. Le fichier armTurner.ai doit être imprimé sur un matériau de 3 mm d'épaisseur.

2. Téléchargez les fichiers d'impression 3D (.stl) et utilisez votre imprimante 3D préférée pour les imprimer.

   Assurez-vous d'imprimer deux des bras! La couleur n'a pas d'importance ici

3. Assemblez les deux plates-formes ensemble comme indiqué sur l'image 3 à l'aide de colle chaude.

4. Assemblez la boîte. Bien que cela puisse être difficile à faire, il est plus facile d'y parvenir en:

   1. Insertion des deux plates-formes entre les deux grandes fentes de part et d'autre de la boîte.
   2. Placer le premier bras sur le dessus de la plate-forme supérieure.
   3. Enfiler le retourneur de bras à travers le bras puis la plate-forme supérieure.
   4. Placer le deuxième bras sur le dessus de la plate-forme inférieure.
   5. Enfiler le retourneur de bras à travers le deuxième bras, puis la plate-forme inférieure.
   6. Coller le retourneur de bras à travers l'ouverture rectangulaire du retourneur de bras imprimé en 3D.
   7. L'autre extrémité du retourneur va au-dessus du servomoteur.
   8. Ajoutez les pièces du haut, du bas et du dos à la boîte.

Votre boîte assemblée finale devrait ressembler à la sixième photo. Maintenant, vous pouvez répéter cela deux fois de plus !

À la fin de cette étape, vous devriez avoir six boîtes avec trois chacun des systèmes de mouvement haut/bas et gauche/droite.

Étape 3: Soutenir le corps… COMMENT ?

Bonne question! C'est à ce moment-là qu'interviennent ces supports slinky imprimés en 3D. Téléchargez le fichier.stl inclus et imprimez-le à l'aide d'une imprimante 3D. Assurez-vous d'imprimer 6 supports au total pour les 6 boîtes différentes.

Si vous avez vu la photo du support moulant ci-dessus, la surprise a été gâchée - c'est la couleur de notre dragon Sine-ese !

Étape 4: Mais ces boîtes ne sont pas si jolies…

Et je suis d'accord! C'est pourquoi nous allons utiliser un cutter laser pour découper une boîte beaucoup plus attrayante pour contenir toutes ces boîtes et les cacher.

Téléchargez ces fichiers Adobe Illustrator et découpez-les à l'aide du cutter laser. La conception des nuages a été dessinée à la main par l'un des contributeurs. N'hésitez pas à les modifier en les supprimant dans le fichier illustrator et en ajoutant votre propre design comme bon vous semble ! Vous trouverez ci-dessous les étapes suggérées pour tout assembler.

1. Assemblez et collez les trois pièces du premier fichier (outerBoxFinal_1) ensemble.
2. N'ajoutez pas encore la pièce du deuxième fichier (outerBoxFinal_2).
3. Mettez le morceau du troisième fichier (outerBoxFinal_3) au bas de la boîte et il devrait se fermer en haut. Collez UNIQUEMENT au fond de la boîte.
4. Imprimez innerBoxesPlatform deux fois. Collez les deux pièces qui ont de grands trous rectangulaires ensemble. Ensuite, collez trois des pièces restantes ensemble. Enfin, collez-le à l'autre ensemble collé avec des trous.
5. Placez la plate-forme au fond de la grande boîte.
6. Insérez les 6 petites boîtes dans leurs emplacements correspondants sur la plate-forme.
7. Maintenant, placez la pièce du deuxième fichier (outerBoxFinal_2) sur le dessus de la boîte et collez autour du bord. Les trous sur la pièce supérieure doivent s'aligner avec les trous sur les plus petites boîtes. Sinon, réorganisez vos petites boîtes. N'ajoutez pas du tout de colle aux petites boîtes.
8. Si vous utilisez une planche à pain qui a une pièce collante en bas, placez-la près du centre de la pièce du bas dans un endroit où lorsque vous fermez la boîte, la planche à pain et les photons devraient disparaître. Il y a de petites fentes sur la pièce inférieure pour vous permettre de vous connecter plus facilement aux photons depuis l'extérieur.

Étape 5: Jouets Slinky ?? Oh mon

Corps du dragon:

1. Combinez trois slinkies ensemble en utilisant de la colle chaude ou du ruban adhésif.

2. Mesurez la longueur et le diamètre des slinkies et coupez un morceau de tissu décoratif.

3. Ramenez les deux extrémités du tissu et cousez-les ensemble.

4. Une fois que vous avez fini de les coudre, glissez les slinkies comme une chaussette.

5. Cousez les extrémités du slinky sur le tissu cousu.

Étape 6: imprimez votre dragon

Pièces imprimées en 3D du dragon:

1. Les pièces proviennent de

2. Nous n'avons utilisé que la tête, les jambes et les yeux.

3. Après avoir imprimé la pièce en 3D, lissez-la à l'aide de papier de verre et d'acétone.

4. Peignez les pièces comme vous le souhaitez pour les décorer.

Étape 7: Il est temps d'intensifier votre dragon avec NeoPixels

Segment lumineux:

1. Vous pouvez simplement utiliser un brin néopixel pour créer les lumières si vous le souhaitez. (Nous avons manqué de brins).

2. Nous avons utilisé 20 lumières néopixels et les avons connectées à l'aide de fils. Ces fils ont été soudés sur eux et connectés au photon à l'aide d'un câblage rouge afin qu'il corresponde au thème du dragon.

3. Vous pouvez également coudre vos lumières néopixels sur un long morceau de tissu, mais nous ne les avons pas utilisées car nous avions un slinky en métal.

Assemblage des pièces: Fixez le segment lumineux à l'intérieur du corps du dragon à l'aide de fils ou de fils. Assurez-vous que vous pouvez connecter les lumières au photon à l'intérieur de la boîte de base. Fixez la tête, les pattes et la queue au corps à l'aide de colle. Une fois qu'ils sont en place, fixez le corps dans les supports souples que nous avons imprimés auparavant. Maintenant, le corps est prêt à être programmé.

Étape 8: Temps de programmation

Étant donné que nous utiliserons deux photons de particules pour travailler avec six servomoteurs distincts (un photon ne peut fonctionner qu'avec quatre), nous écrirons deux codes distincts mais similaires à flasher sur les microcontrôleurs.

Maintenant, pour le premier microcontrôleur…

Dans un fichier Arduino (.ino), incluez les bibliothèques et les définitions suivantes:

#include "neopixel.h"

#include "ArduinoJson.h"

#define PIXEL_PIN D4

#define PIXEL_COUNT 18

Ensuite, déclarez les variables suivantes:

Bande Adafruit_NeoPixel = Adafruit_NeoPixel(PIXEL_COUNT, PIXEL_PIN);

Servo servoLeftRight_1; Servo servoUpDown_1; Servo servoLeftRight_2; Servo servoUpDown_2; int positionGaucheDroite_1 = 0; int positionUpDown_1 = 0; int leftRight_1 = 1; int upDown_1 = 1; int positionGaucheDroite_2 = 100; // doit être compris entre 0 et 180 (en degrés) int positionUpDown_2 = 180; // doit être compris entre 0 et 180 (en degrés) int leftRight_2 = 1; //0=gauche, 1=droite int upDown_2 = 1; //=up, 1=down 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_OB12JECT_SIZE 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_SIZE (5) + 76*JSON_OBJECT_SIZE(8) + 12490; Chaîne weatherArray[3]; Tableau de température flottante[3]; float humiditéArray[3]; float windSpeedArray[3]; Chaîne timestampArray[3]; int upDownMaxDegree[3]; int leftRightSpeed[3]; Chaîne allData5DaysForecast;

Cliquez ici pour savoir comment configurer des webhooks. Lorsque vous avez terminé, ajoutez les déclarations et fonctions suivantes et apportez les modifications appropriées si nécessaire:

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

Les fonctions suivantes contrôlent les mouvements haut/bas et gauche/droite du dragon:

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); }

annuler le changementLeftRight2() {

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); }

annuler le changementUpDown1() {

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

annuler le changementUpDown2() {

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); }

Pour pouvoir changer les mouvements dans un intervalle, des minuteries sont créées.

Minuteur timerLeftRight1 (100, changeLeftRight1);

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

La fonction de configuration est finalement ajoutée ensuite. Assurez-vous d'apporter les modifications appropriées aux lignes de code qui traitent des webhooks.

void setup() { // démarre les minuteries météo timerWeatherForecast.start(); timerWeatherCurrent.start(); //Neopixels strip.begin(); // Mettez l'initialisation comme pinMode et commencez les fonctions ici. // Configurez le servomoteur Micro ServoLeftRight_1.attach(D1); servoUpDown_1.attach(D0); servoLeftRight_2.attach(D3); servoUpDown_2.attach(D2); servoLeftRight_1.write(positionLeftRight_1); //initialiser la position du servo servoUpDown_1.write(positionUpDown_1); //initialiser la position du servo servoLeftRight_2.write(positionLeftRight_2); //initialisation de la position du servo servoUpDown_2.write(positionUpDown_2); //initialisation de la position du servo timerLeftRight1.start(); timerLeftRight2.start(); timerUpDown1.start(); timerUpDown2.start(); // Ouvre une console Serial.begin(9600); retard (2000); Serial.println("Bonjour !"); // Abonnez-vous aux webhooks get_weather5DayForecast et get_currentWeather Particle.subscribe("hook-response/get_weather5DayForecast", gotWeather5DayForecast, MY_DEVICES); Particle.subscribe("hook-response/get_currentWeather/0", gotCurrentWeatherData, MY_DEVICES); getCurrentWeather(); getWeather5DayForecast(); }

Une fonction de boucle n'est pas utilisée pour ce projet. Nous ne pouvons pas oublier les fonctions pour gérer les données reçues des webhooks !

void gotWeather5DayForecast(const char *event, const char *data){ allData5DaysForecast += data; // enregistre toutes les données dans une chaîne. int allData5DaysForecastLen = allData5DaysForecast.length(); char buffer[allData5DaysForecastLen + 1]; allData5DaysForecast.toCharArray(tampon, allData5DaysForecastLen + 1); // crée un tampon pour la chaîne int bufferLength = sizeof(buffer); DynamicJsonBuffer jsonBufferWeather(bufferLength); JsonObject& root = jsonBufferWeather.parseObject(buffer); // Teste si l'analyse réussit. if (!root.success()) { //Serial.println("Analyse des prévisions météo à 5 jours…ERREUR !"); revenir; } entier i = 1; JsonArray& list = root["list"]; for (JsonObject& currentObject: list){ if (i < 3){ JsonObject& main = currentObject["main"]; température du flotteur = main["temp"]; int humidité = main["humidité"]; JsonObject& weather = currentObject["weather"][0]; const char* météoInfo = météo["principal"]; float windSpeed = currentObject["wind"]["speed"]; const char* timestamp = currentObject["dt_txt"]; int tempFah = convertToFahrenheit(température); int servoMaxDegree = updateUpDown(tempFah); upDownMaxDegree = servoMaxDegree; int servoIncrement = updateleftRight(windSpeed); leftRightSpeed = servoIncrement; setColor(météoInfo, i); tableautempérature = tempFah; tableau d'humidité = humidité; TableauMétéo = InfoMétéo; tableauVitessevent =Vitessevent; timestampArray = timestamp; je++; } else{ pause; } } }

void gotCurrentWeatherData(const char *event, const char *data){ DynamicJsonBuffer jsonBufferWeather(bufferSizeCurrent); JsonObject& root = jsonBufferWeather.parseObject(data); // Teste si l'analyse réussit. if (!root.success()) { //Serial.println("Analyse de la météo actuelle…ERREUR!"); revenir; } JsonObject& weather = root["weather"][0]; const char* météo_main = météo["main"]; JsonObject& main = root["main"]; float main_temp = main["temp"]; int main_humidity = main["humidité"]; float wind_speed = root["wind"]["speed"]; 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(weather_main, 0); WeatherArray[0] = weather_main; tableautempérature[0] = tempFah; humidityArray[0]= main_humidity; windSpeedArray[0] = wind_speed; timestampArray[0] = timestamp; }

Ci-dessous, vous pouvez trouver des fonctions supplémentaires qui contrôlent la mise à jour des positions des servomoteurs, la conversion de la température de Kelvin en Fahrenheit et le réglage des couleurs des LED.

int updateUpDown(float temp){ //Mappez le degré sur une plage de [0, 180] float servoMaxDegree = temp * 45 / 31 + (990 / 31); Serial.print("nouveau degré d'asservissement: "); Serial.println(servoMaxDegree); retourner servoMaxDegree; }

int updateleftRight(vitesse du vent flottant){

//Mappez la vitesse du vent sur une plage de [1, 100] float servoIncrement = windSpeed * 99 / 26 + 1; Serial.print("nouvelle valeur d'incrément d'asservissement: "); Serial.println(servoIncrement); retour servoIncrément; }

int convertToFahrenheit(float tempKel){

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

void setColor(String weatherDesc, int index){

int ledIndex = 0; if (index == 0){ ledIndex = 0; } else if (index == 1){ ledIndex = 6; } else if (index == 2){ ledIndex = 12; } else{ return; } if(weatherDesc == "Clear") { //jaune pour (int j = ledIndex; j < ledIndex+6; j++){ strip.setPixelColor(j, strip. Color(253, 219, 62));// bande jaune.show(); retard(20); } } else if(weatherDesc == "Nuages"){ //gris pour (int j = ledIndex; j < ledIndex+6; j++){ strip.setPixelColor(j, strip. Color(223, 229, 237)); //bande grise.show(); retard(20); } } else if (weatherDesc == "Snow"){ //blanc pour (int j = ledIndex; j < ledIndex+6; j++){ strip.setPixelColor(j, strip. Color(255, 225, 225)); //bande blanche.show(); retard(20); } } else if (weatherDesc == "Rain"){//blue for (int j = ledIndex; j < ledIndex+6; j++){ strip.setPixelColor(j, strip. Color(119, 191, 246)); //bande bleue.show(); retard(20); } } else{ //rouge pour (int j = ledIndex; j < ledIndex+6; j++){ strip.setPixelColor(j, strip. Color(254, 11, 5));//red strip.show(); retard(20); } } }

Une fois que vous avez tout ajouté à votre fichier Arduino, compilez-le. S'il n'y a pas d'erreurs, allez-y et flashez le code sur le premier photon. L'étape suivante vous fournira un code similaire à flasher sur le deuxième photon.

Étape 9: la programmation continue

Étant donné que le code du deuxième photon est presque identique à celui du premier, l'intégralité du code est copié et collé ci-dessous:

#include "ArduinoJson.h"

Servo servoLeftRight_3;

Servo servoUpDown_3;

int positionGaucheDroite_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_SIZE (5) + 76*JSON_OBJECT_SIZE(8) + 12490;

Chaîne weatherArray[3];

Tableau de température flottante[3]; float humiditéArray[3]; float windSpeedArray[3]; Chaîne timestampArray[3]; int upDownMaxDegree[3]; int leftRightSpeed[3];

Chaîne allData5DaysForecast;

void getWeather5DayForecast()

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

Minuteur timerWeatherForecast(60000, getWeather5DayForecast); //10, 800 000 ms = 3 jours

void getCurrentWeather()

{ Particule.publish("get_currentWeather2"); }

Minuterie timerWeatherCurrent(60000, getCurrentWeather);

annuler le changementLeftRight3() {

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); }

annuler le changementUpDown3() {

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

Minuteur timerLeftRight3(100, changeLeftRight3);

Minuterie timerUpDown3(10, changeUpDown3);

void setup() {

// démarre les minuteries météo timerWeatherForecast.start(); timerWeatherCurrent.start(); // Mettez l'initialisation comme pinMode et commencez les fonctions ici. // Configurez le servomoteur Micro ServoLeftRight_3.attach(D1); servoUpDown_3.attach(D0);

servoLeftRight_3.write(positionLeftRight_3); //initialisation de la position du servo

servoUpDown_3.write(positionUpDown_3); //initialisation de la position du servo

timerLeftRight3.start();

timerUpDown3.start(); // Ouvre une console Serial.begin(9600); retard (2000); Serial.println("Bonjour !"); // Abonnez-vous aux webhooks get_weather5DayForecast et 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 *événement, const char *données)

{ allData5DaysForecast += data; // enregistre toutes les données dans une chaîne. int allData5DaysForecastLen = allData5DaysForecast.length(); char buffer[allData5DaysForecastLen + 1]; allData5DaysForecast.toCharArray(tampon, allData5DaysForecastLen + 1); // crée un tampon pour la chaîne int bufferLength = sizeof(buffer); DynamicJsonBuffer jsonBufferWeather(bufferLength); JsonObject& root = jsonBufferWeather.parseObject(buffer); //Serial.println(allData5DaysForecast); // Teste si l'analyse réussit. if (!root.success()) { //Serial.println("Analyse des prévisions météo à 5 jours…ERREUR !"); revenir; } entier i = 1; JsonArray& list = root["list"]; for (JsonObject& currentObject: list){ if (i < 3){ JsonObject& main = currentObject["main"]; température du flotteur = main["temp"]; int humidité = main["humidité"]; JsonObject& weather = currentObject["weather"][0]; const char* météoInfo = météo["principal"]; float windSpeed = currentObject["wind"]["speed"]; const char* timestamp = currentObject["dt_txt"]; int tempFah = convertToFahrenheit(température); int servoMaxDegree = updateUpDown(tempFah); upDownMaxDegree = servoMaxDegree; int servoIncrement = updateleftRight(windSpeed); leftRightSpeed = servoIncrement; tableautempérature = tempFah; tableau d'humidité = humidité; TableauMétéo = InfoMétéo; tableauVitessevent =Vitessevent; timestampArray = timestamp; je++; } else{ pause; } } }

void gotCurrentWeatherData (const char * événement, const char * données)

{ DynamicJsonBuffer jsonBufferWeather(bufferSizeCurrent); JsonObject& root = jsonBufferWeather.parseObject(data); //Série.println(données); // Teste si l'analyse réussit. if (!root.success()) { //Serial.println("Analyse de la météo actuelle…ERREUR!"); revenir; } JsonObject& weather = root["weather"][0]; const char* météo_main = météo["main"]; JsonObject& main = root["main"]; float main_temp = main["temp"]; int main_humidity = main["humidité"]; float wind_speed = root["wind"]["speed"]; 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; tableautempérature[0] = tempFah; humidityArray[0]= main_humidity; windSpeedArray[0] = wind_speed; timestampArray[0] = timestamp; }

int updateUpDown(float temp){

//Mappez le degré sur une plage de [0, 180] float servoMaxDegree = temp * 45 / 31 + (990 / 31); Serial.print("nouveau degré d'asservissement: "); Serial.println(servoMaxDegree); retourner servoMaxDegree; }

int updateleftRight(vitesse du vent flottant){

//Mappez la vitesse du vent sur une plage de [1, 100] float servoIncrement = windSpeed * 99 / 26 + 1; Serial.print("nouvelle valeur d'incrément d'asservissement: "); Serial.println(servoIncrement); retour servoIncrément; }

int convertToFahrenheit(float tempKel){

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

Tu l'as fait! Vous avez réussi à traverser la section programmation du projet ! Maintenant, assurez-vous d'effectuer tout le câblage et les connexions des servomoteurs et des néopixels à la maquette et aux microcontrôleurs. REMARQUE: insérez les chevilles/baguettes supplémentaires dans les fentes verticales des boîtiers pour les mouvements gauche et droit du corps. L'autre extrémité doit être reliée au corps du dragon.

Étape 10: Profitez de votre dragon

Toutes nos félicitations! Vous avez construit un dragon Sine-ese à partir de zéro ! Maintenant, tout ce que vous avez à faire est de vous asseoir et de profiter de votre affichage ambiant !

REMARQUE: Ce projet a été construit dans le cadre d'un cours de Joan Bempong et Soundarya Muthuvel. La page du cours se trouve ici.