Dragón sinusoidal: 10 pasos (con imágenes)

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:44

Sine-ese Dragon es una pieza de decoración ambiental para el hogar que emplea movimientos mecánicos y luces para indicarle el pronóstico del tiempo para los próximos tres intervalos de tres horas. Por definición, el ambiente describe el entorno inmediato de algo; por tanto, se decidió que sería apropiado incorporar datos meteorológicos en una pantalla ambiental. El clima es un aspecto que cambia involuntariamente el día de las personas y es un dato que cambia constantemente cada minuto, o incluso hasta un segundo.

El dragón chino es "un símbolo de poder, fuerza y buena suerte" y con frecuencia se le considera de alto valor cultural y tradicional en todo el subcontinente asiático. Además de traer buena fortuna, también se dice que el Dragón Chino tiene potentes poderes que controlan "el agua, la lluvia, los tifones y las inundaciones". En última instancia, se consideró apropiado que el dragón chino representara los datos meteorológicos.

Visualización

El Dragón Sine-ese se manipula en seis puntos principales en tres secciones separadas que representan el pronóstico del tiempo durante tres intervalos de 3 horas. Para cada intervalo de 3 horas, se incluirá la siguiente información:

• Descripción del tiempo: determina el color de la información meteorológica actual.
• Temperatura: especifica la altura del cuerpo.
• Humedad: parpadeo de segmentos LED
• Velocidad del viento: controla la velocidad del cuerpo que se mueve hacia la izquierda y hacia la derecha.

Materiales necesarios

1. Madera contrachapada de 3 mm / Cartón
2. Palillos o tacos de madera de 5 mm
3. 2 fotones de partículas
4. 3 juguetes furtivos
5. 6 servomotores
6. Luces NeoPixel (ya sea un hilo o luces individuales cosidas entre sí)
7. Mucho súper pegamento
8. Hilo conductor
9. Pintura acrilica
10. Tejido decorativo
11. Cortador láser
12. impresora 3d

Paso 1: ¡Arriba y abajo

Su primer paso para construir el Dragón Sine-ese es construir el componente que controla el movimiento hacia arriba y hacia abajo del cuerpo. ¡Que interesante!

1. Descargue los archivos de Adobe Illustrator (.ai) e imprímalos con una máquina cortadora láser.

   upDownBoxWithPlatform.ai debe imprimirse en una cartulina

2. Descargue los archivos de impresión 3D (.stl) y use su impresora 3D favorita para imprimirlos.

   El color no importa para el disco o el volteador de discos. En la segunda imagen, el giradiscos se ha insertado dentro del orificio del disco

3. Ensamble los dos primeros componentes y péguelos juntos como se muestra en las imágenes 3 a 5.

   1. La plataforma
   2. Los surcos para el disco

4. Ahora, arma la caja siguiendo los consejos a continuación.

   1. Los cables del servo deben pasar por la abertura rectangular en el costado de la caja.
   2. El extremo más corto del volteador de discos se conecta al cabezal del servo y el extremo más largo pasa por el orificio del otro lado de la caja con un orificio circular. Esto se demuestra en la imagen 6.
5. Ahora, necesitamos algo para asegurarnos de que la plataforma se mantenga nivelada cuando se gira el disco. Corta el palillo en palitos de 75 mm de largo (imagen 7) y pégalos a través de la parte superior de la caja en la parte superior de la plataforma con pegamento caliente. Asegúrese de que los palos estén nivelados a 90 grados con respecto a la plataforma.
6. Inserte un palo de 212 mm de largo en el orificio central en la parte superior de la caja en la plataforma.

¡Dulce! Ahora tienes una caja completa (imagen 8) para el movimiento hacia arriba y hacia abajo del dragón. Ahora, repita los pasos anteriores dos veces más.

Paso 2: ¿Qué pasa con la izquierda y la derecha?

Ahora, no podemos olvidarnos del movimiento de izquierda y derecha del Dragón Sine-ese, ¿verdad? ¡Saltemos al segundo paso!

1. Descargue los archivos de Adobe Illustrator (.ai) e imprímalos con una máquina cortadora láser.

   1. leftRightBoxWithPlatforms.ai debe imprimirse en una cartulina.
   2. El archivo armTurner.ai debe imprimirse en un material de 3 mm de grosor.

2. Descargue los archivos de impresión 3D (.stl) y use su impresora 3D favorita para imprimirlos.

   ¡Asegúrate de imprimir dos de los brazos! El color no importa aquí

3. Ensamble las dos plataformas juntas como se muestra en la imagen 3 usando pegamento caliente.

4. Arma la caja. Si bien puede ser complicado hacerlo, es más fácil de lograr si:

   1. Insertar las dos plataformas entre las dos ranuras grandes a ambos lados de la caja.
   2. Colocando el primer brazo en la parte superior de la plataforma superior.
   3. Enhebrar el volteador de brazos a través del brazo y luego la plataforma superior.
   4. Colocando el segundo brazo en la parte superior de la plataforma inferior.
   5. Enhebrar el volteador de brazos a través del segundo brazo y luego la plataforma inferior.
   6. Pegar el volteador de brazos a través de la abertura rectangular del volteador de brazos impreso en 3D.
   7. El otro extremo del volteador va encima del servomotor.
   8. Agregue las piezas superior, inferior y posterior a la caja.

Su caja ensamblada final debe verse como la sexta imagen. ¡Ahora puedes repetir eso dos veces más!

Al final de este paso, debe tener seis cajas con tres de cada uno de los sistemas de movimiento arriba / abajo e izquierda / derecha.

Paso 3: Sosteniendo el cuerpo… ¿CÓMO?

¡Buena pregunta! Ahí es cuando entran esos titulares slinky impresos en 3D. Descargue el archivo.stl incluido e imprímalo con una impresora 3D. Asegúrese de imprimir 6 soportes en total para las 6 cajas diferentes.

Si ha visto la imagen del soporte furtivo de arriba, la sorpresa se ha arruinado: ¡ese es el color de nuestro Dragón Sine-ese!

Paso 4: Pero esas cajas no son tan bonitas …

¡Y estoy de acuerdo! Por eso vamos a utilizar un cortador láser para cortar una caja mucho más atractiva para contener todas esas cajas y ocultarlas.

Descargue esos archivos de Adobe Illustrator y recórtelos con el cortador láser. El diseño de las nubes fue dibujado a mano por uno de los colaboradores. ¡Siéntete libre de modificarlos eliminándolos dentro del archivo ilustrador y agregando tu propio diseño como mejor te parezca! A continuación se muestran los pasos sugeridos para armar todo.

1. Ensamble y pegue las tres piezas del primer archivo (outerBoxFinal_1) juntas.
2. No agregue la pieza del segundo archivo (outsideBoxFinal_2) todavía.
3. Coloque la pieza del tercer archivo (outsideBoxFinal_3) en la parte inferior de la caja y debería cerrarse en la parte superior. Pegue ÚNICAMENTE en la parte inferior de la caja.
4. Imprima innerBoxesPlatform dos veces. Pega las dos piezas que tienen grandes agujeros rectangulares. Luego, pega tres de las piezas restantes juntas. Finalmente, péguelo al otro juego pegado con agujeros.
5. Coloque la plataforma en la parte inferior de la caja grande.
6. Inserte las 6 cajas más pequeñas en sus lugares correspondientes en la plataforma.
7. Ahora, coloque la pieza del segundo archivo (outsideBoxFinal_2) en la parte superior de la caja y péguela alrededor del borde. Los orificios de la pieza superior deben alinearse con los orificios de las cajas más pequeñas. Si no es así, reorganice sus cajas más pequeñas. No agregue pegamento a las cajas más pequeñas en absoluto.
8. Si está utilizando una placa de pruebas que tiene una pieza adhesiva en la parte inferior, colóquela cerca del centro de la pieza inferior en un lugar donde, cuando cierre la caja, la placa de pruebas junto con los fotones deberían desaparecer. Hay pequeñas ranuras en la pieza inferior que facilitan la conexión a los fotones desde el exterior.

Paso 5: ¿Juguetes Slinky? ¡Oh mi

Cuerpo del dragón:

1. Combine tres slinkies con pegamento termofusible o cinta adhesiva.

2. Mide la longitud y el diámetro de los slinkies y corta un trozo de tela decorativa.

3. Traiga los dos extremos de la tela y cóselos.

4. Una vez que hayas terminado de coserlos, desliza los slinkies como si fueran un calcetín.

5. Coser los extremos del slinky a la tela cosida.

Paso 6: ¡Imprime tu dragón

Partes impresas en 3D del dragón:

1. Las partes fueron tomadas de

2. Usamos solo la cabeza, las piernas y los ojos.

3. Después de imprimir la pieza en 3D, alísela con papel de lija y acetona.

4. Pinte las partes de la forma que desee decorarlas.

Paso 7: ¡Es hora de intensificar tu dragón con NeoPixels

Segmento de luz:

1. Si lo desea, simplemente puede usar una hebra de neopixel para crear las luces (se nos acabaron las hebras).

2. Usamos 20 luces de neopixel y las conectamos mediante cables. Estos cables se soldaron sobre ellos y se conectaron al fotón usando cableado rojo para que coincida con el tema del dragón.

3. También puedes coser tus luces de neopixel en un trozo de tela largo, pero no las usamos porque teníamos un slinky hecho de metal.

Montaje de las piezas: Asegure el segmento de luz dentro del cuerpo del dragón con hilos o alambres. Asegúrese de poder conectar las luces al fotón dentro de la caja base. Pega la cabeza, las patas y la cola al cuerpo con pegamento. Una vez que estén en su lugar, asegure el cuerpo en los soportes deslizantes que imprimimos antes. Ahora el cuerpo está listo para ser programado.

Paso 8: ¡Tiempo de programación

Dado que usaremos dos fotones de partículas para trabajar con seis servomotores separados (un fotón solo puede funcionar con cuatro), escribiremos dos códigos separados pero similares para que se muestren en los microcontroladores.

Ahora, para el primer microcontrolador …

En un archivo Arduino (.ino), incluya las siguientes bibliotecas y definiciones:

#include "neopixel.h"

#include "ArduinoJson.h"

#define PIXEL_PIN D4

#define PIXEL_COUNT 18

A continuación, declare las siguientes variables:

Adafruit_NeoPixel strip = 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; // debe estar entre 0 y 180 (en grados) int positionUpDown_2 = 180; // debe estar entre 0 y 180 (en grados) int leftRight_2 = 1; // 0 = izquierda, 1 = derecha int upDown_2 = 1; // 0 = arriba, 1 = abajo 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) + JSSON_OBJECT_SIZE (5) + JSSONIZE 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 (2) JSJON_OBJECT_SIZE (JSON_OBJECT_SIZE) (5) + 76 * JSON_OBJECT_SIZE (8) + 12490; Cadena weatherArray [3]; flotante temperatureArray [3]; flotante humedadArray [3]; flotar windSpeedArray [3]; String timestampArray [3]; int upDownMaxDegree [3]; int leftRightSpeed [3]; String allData5DaysForecast;

Haga clic aquí para aprender cómo configurar webhooks. Cuando haya terminado, agregue las siguientes declaraciones y funciones y realice los cambios apropiados si es necesario:

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

Las siguientes funciones controlan los movimientos arriba / abajo e izquierda / derecha del dragón:

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--; si (positionUpDown_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); }

Para poder cambiar los movimientos en un intervalo, se crean temporizadores.

Temporizador timerLeftRight1 (100, changeLeftRight1);

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

La función de configuración finalmente se agrega a continuación. Asegúrese de realizar los cambios adecuados en las líneas de código que tratan con webhooks.

void setup () {// iniciar los temporizadores meteorológicos timerWeatherForecast.start (); timerWeatherCurrent.start (); // Neopixels strip.begin (); // Ponga la inicialización como pinMode y comience las funciones aquí. // Configurar el Micro Servo servoLeftRight_1.attach (D1); servoUpDown_1.attach (D0); servoLeftRight_2.attach (D3); servoUpDown_2.attach (D2); servoLeftRight_1.write (positionLeftRight_1); // inicializar la posición del servo servoUpDown_1.write (positionUpDown_1); // inicializar la posición del servo servoLeftRight_2.write (positionLeftRight_2); // inicializar la posición del servo servoUpDown_2.write (positionUpDown_2); // inicializar la posición del servo timerLeftRight1.start (); timerLeftRight2.start (); timerUpDown1.start (); timerUpDown2.start (); // Abra una consola Serial.begin (9600); retraso (2000); Serial.println ("¡Hola!"); // Suscríbete a los webhooks get_weather5DayForecast y get_currentWeather Particle.subscribe ("hook-response / get_weather5DayForecast", gotWeather5DayForecast, MY_DEVICES); Particle.subscribe ("gancho-respuesta / get_currentWeather / 0", gotCurrentWeatherData, MY_DEVICES); getCurrentWeather (); getWeather5DayForecast (); }

No se utiliza una función de bucle para este proyecto. ¡No podemos olvidar las funciones para manejar los datos recibidos de los webhooks!

void gotWeather5DayForecast (const char * evento, const char * data) {allData5DaysForecast + = data; // guarda todos los datos en una cadena. int allData5DaysForecastLen = allData5DaysForecast.length (); búfer de caracteres [allData5DaysForecastLen + 1]; allData5DaysForecast.toCharArray (búfer, allData5DaysForecastLen + 1); // crea un búfer para la cadena int bufferLength = sizeof (búfer); DynamicJsonBuffer jsonBufferWeather (bufferLength); JsonObject & root = jsonBufferWeather.parseObject (búfer); // Prueba si el análisis se realiza correctamente. if (! root.success ()) {//Serial.println("Preparando el pronóstico del tiempo para 5 días… ¡ERROR! "); regreso; } int i = 1; JsonArray & list = root ["lista"]; for (JsonObject & currentObject: list) {if (i <3) {JsonObject & main = currentObject ["principal"]; temperatura de flotación = principal ["temp"]; int humedad = principal ["humedad"]; JsonObject & weather = currentObject ["weather"] [0]; const char * weatherInfo = clima ["principal"]; flotar windSpeed = currentObject ["viento"] ["velocidad"]; 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; humedadArray = humedad; weatherArray = weatherInfo; windSpeedArray = windSpeed; timestampArray = marca de tiempo; i ++; } else {descanso; }}}

void gotCurrentWeatherData (const char * evento, const char * datos) {DynamicJsonBuffer jsonBufferWeather (bufferSizeCurrent); JsonObject & root = jsonBufferWeather.parseObject (datos); // Prueba si el análisis se realiza correctamente. if (! root.success ()) {//Serial.println("Parsing for current weather … ERROR! "); regreso; } JsonObject & weather = root ["clima"] [0]; const char * weather_main = weather ["principal"]; JsonObject & main = root ["principal"]; float main_temp = main ["temp"]; int main_humidity = main ["humedad"]; float wind_speed = root ["viento"] ["velocidad"]; 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; temperatureArray [0] = tempFah; matriz_humedad [0] = humedad_principal; windSpeedArray [0] = wind_speed; timestampArray [0] = marca de tiempo; }

A continuación, puede encontrar funciones adicionales que controlan la actualización de las posiciones de los servomotores, la conversión de temperatura de Kelvin a Fahrenheit y la configuración de los colores de los LED.

int updateUpDown (float temp) {// Asigna el grado a un rango de [0, 180] float servoMaxDegree = temp * 45/31 + (990/31); Serial.print ("nuevo grado de servo:"); Serial.println (servoMaxDegree); return servoMaxDegree; }

int updateleftRight (float windSpeed) {

// Asigna la velocidad del viento a un rango de [1, 100] float servoIncrement = windSpeed * 99/26 + 1; Serial.print ("nuevo valor de incremento de servo:"); Serial.println (servoIncrement); return servoIncrement; }

int convertToFahrenheit (float tempKel) {

int tempFah = tempKel * 9.0 / 5.0 - 459.67; return tempFah; }

void setColor (String weatherDesc, int index) {

int ledIndex = 0; si (índice == 0) {ledIndex = 0; } más si (índice == 1) {ledIndex = 6; } más si (índice == 2) {ledIndex = 12; } else {volver; } if (weatherDesc == "Clear") {// amarillo para (int j = ledIndex; j <ledIndex + 6; j ++) {strip.setPixelColor (j, strip. Color (253, 219, 62)); // franja amarilla.show (); retraso (20); }} else if (weatherDesc == "Clouds") {// gris para (int j = ledIndex; j <ledIndex + 6; j ++) {strip.setPixelColor (j, strip. Color (223, 229, 237)); // tira gris.show (); retraso (20); }} else if (weatherDesc == "Snow") {// blanco para (int j = ledIndex; j <ledIndex + 6; j ++) {strip.setPixelColor (j, strip. Color (255, 225, 225)); // tira blanca.show (); retraso (20); }} else if (weatherDesc == "Rain") {// azul para (int j = ledIndex; j <ledIndex + 6; j ++) {strip.setPixelColor (j, strip. Color (119, 191, 246)); // franja azul.show (); retraso (20); }} else {// rojo para (int j = ledIndex; j <ledIndex + 6; j ++) {strip.setPixelColor (j, strip. Color (254, 11, 5)); // rojo strip.show (); retraso (20); }}}

Una vez que tenga todo agregado a su archivo Arduino, compílelo. Si no hay errores, continúe y muestre el código al primer Photon. El siguiente paso le proporcionará un código similar que se mostrará en el segundo Fotón.

Paso 9: la programación continúa

Debido a que el código del segundo Fotón es casi idéntico al del primero, el código completo se copia y pega a continuación:

#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_ (6)

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 (2) JSJON_OBJECT_SIZE (JSOBON_OBJECT_SIZE) (5) + 76 * JSON_OBJECT_SIZE (8) + 12490;

Cadena weatherArray [3];

flotante temperatureArray [3]; flotante humedadArray [3]; flotar windSpeedArray [3]; String timestampArray [3]; int upDownMaxDegree [3]; int leftRightSpeed [3];

String allData5DaysForecast;

void getWeather5DayForecast ()

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

Temporizador timerWeatherForecast (60000, getWeather5DayForecast); // 10, 800, 000 ms = 3 días

void getCurrentWeather ()

{Particle.publish ("get_currentWeather2"); }

Temporizador 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--; si (positionUpDown_3 <1) {upDown_3 = 1; }} servoUpDown_3.write (positionUpDown_3); }

Temporizador timerLeftRight3 (100, changeLeftRight3);

Temporizador timerUpDown3 (10, changeUpDown3);

configuración vacía () {

// iniciar los temporizadores meteorológicos timerWeatherForecast.start (); timerWeatherCurrent.start (); // Ponga la inicialización como pinMode y comience las funciones aquí. // Configurar el Micro Servo servoLeftRight_3.attach (D1); servoUpDown_3.attach (D0);

servoLeftRight_3.write (positionLeftRight_3); // inicializar la posición del servo

servoUpDown_3.write (positionUpDown_3); // inicializar la posición del servo

timerLeftRight3.start ();

timerUpDown3.start (); // Abra una consola Serial.begin (9600); retraso (2000); Serial.println ("¡Hola!"); // Suscríbete a los webhooks get_weather5DayForecast y 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 * evento, const char * datos)

{allData5DaysForecast + = datos; // guarda todos los datos en una cadena. int allData5DaysForecastLen = allData5DaysForecast.length (); búfer de caracteres [allData5DaysForecastLen + 1]; allData5DaysForecast.toCharArray (búfer, allData5DaysForecastLen + 1); // crea un búfer para la cadena int bufferLength = sizeof (búfer); DynamicJsonBuffer jsonBufferWeather (bufferLength); JsonObject & root = jsonBufferWeather.parseObject (búfer); //Serial.println(allData5DaysForecast); // Prueba si el análisis se realiza correctamente. if (! root.success ()) {//Serial.println("Preparando el pronóstico del tiempo para 5 días… ¡ERROR! "); regreso; } int i = 1; JsonArray & list = root ["lista"]; for (JsonObject & currentObject: list) {if (i <3) {JsonObject & main = currentObject ["principal"]; temperatura de flotación = principal ["temp"]; int humedad = principal ["humedad"]; JsonObject & weather = currentObject ["weather"] [0]; const char * weatherInfo = clima ["principal"]; flotar windSpeed = currentObject ["viento"] ["velocidad"]; const char * timestamp = currentObject ["dt_txt"]; int tempFah = convertToFahrenheit (temperatura); int servoMaxDegree = updateUpDown (tempFah); upDownMaxDegree = servoMaxDegree; int servoIncrement = updateleftRight (windSpeed); leftRightSpeed = servoIncrement; temperatureArray = tempFah; humedadArray = humedad; weatherArray = weatherInfo; windSpeedArray = windSpeed; timestampArray = marca de tiempo; i ++; } else {descanso; }}}

void gotCurrentWeatherData (const char * evento, const char * datos)

{DynamicJsonBuffer jsonBufferWeather (bufferSizeCurrent); JsonObject & root = jsonBufferWeather.parseObject (datos); //Serial.println(data); // Prueba si el análisis se realiza correctamente. if (! root.success ()) {//Serial.println("Parsing for current weather … ERROR! "); regreso; } JsonObject & weather = root ["clima"] [0]; const char * weather_main = weather ["principal"]; JsonObject & main = root ["principal"]; float main_temp = main ["temp"]; int main_humidity = main ["humedad"]; float wind_speed = root ["viento"] ["velocidad"]; 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; matriz_humedad [0] = humedad_principal; windSpeedArray [0] = wind_speed; timestampArray [0] = marca de tiempo; }

int updateUpDown (temperatura flotante) {

// Asigna el grado a un rango de [0, 180] float servoMaxDegree = temp * 45/31 + (990/31); Serial.print ("nuevo grado de servo:"); Serial.println (servoMaxDegree); return servoMaxDegree; }

int updateleftRight (float windSpeed) {

// Asigna la velocidad del viento a un rango de [1, 100] float servoIncrement = windSpeed * 99/26 + 1; Serial.print ("nuevo valor de incremento de servo:"); Serial.println (servoIncrement); return servoIncrement; }

int convertToFahrenheit (float tempKel) {

int tempFah = tempKel * 9.0 / 5.0 - 459.67; return tempFah; }

¡Lo hiciste! ¡Has superado la sección de programación del proyecto! Ahora, asegúrese de hacer todo el cableado y las conexiones desde los servomotores y neopíxeles hasta la placa de pruebas y los microcontroladores. NOTA: inserte las clavijas / palillos extra a través de las ranuras verticales de las cajas para los movimientos izquierdo y derecho del cuerpo. El otro extremo debe estar conectado al cuerpo del dragón.

Paso 10: ¡Disfruta de tu dragón

¡Felicidades! ¡Has construido un Dragón Sine-ese desde cero! ¡Ahora todo lo que tiene que hacer es sentarse y disfrutar de su pantalla ambiental!

NOTA: Este proyecto fue construido como parte de un trabajo de curso por Joan Bempong y Soundarya Muthuvel. La página del curso se puede encontrar aquí.