Temporizador de control remoto con NodeMCU: 14 pasos

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

Aquí crearemos un temporizador usando NodeMCU y Adafruit. ¡Vamos a mostrar nuestro temporizador con una tira de LED y podremos controlarlo usando nuestro teléfono o computadora!

Nuestro objetivo:

Crea un temporizador usando una tira de LED que podemos: iniciar, pausar y reiniciar usando nuestro teléfono o computadora.

Suministros

Hardware:

• NodeMCU ESP 8266
• Tira de LED Adafruit NeoPixel

Bibliotecas:

• Adafruit_NeoPixel.h
• AdafruitIO_WiFi.h

Otro:

Una conexión WiFi decente

Paso 1: ¡Creemos un feed en Adafruit

Ahora que tenemos todo lo que necesitamos, ¡estamos listos para comenzar a construir! Primero que nada tenemos que crear un feed en Adafruit. Adafruit es un servicio que nos facilita mucho la conexión de nuestro Arduino a Internet y la creación de funciones útiles de control remoto. Si aún no lo ha hecho, regístrese en Adafruit.

¡Ahora creemos un nuevo feed

Podemos nombrar nuestro feed como queramos, lo llamo "temporizador".

Lo que hace un feed es registrar todo lo que hacemos en nuestro tablero (que crearemos en solo un minuto) y envía esos datos a nuestro tablero, pero eso es algo que veremos una vez que tengamos datos para enviar.

Paso 2: Ahora hagamos un tablero …

Ahora, de la misma manera que hicimos un feed, crearemos un nuevo Tablero. Llamaré a mi tablero: 'interfaz de temporizador' porque eso es básicamente lo que será nuestro tablero: una interfaz con los botones para controlar nuestro temporizador.

Paso 3: Obtenga nuestra clave

Si queremos conectar nuestro Arduino a nuestro feed, necesitamos obtener nuestra clave Adafruit, esta es su contraseña secreta que se asegurará de que solo usted pueda conectarse a sus feeds.

Puede obtener su clave haciendo clic en el botón amarillo AIO Key en la parte superior derecha de su pantalla en Adafruit.

Guarde esta clave en algún lugar, la necesitaremos más tarde.

¡No compartas tu clave! De lo contrario, las personas con malas intenciones podrían conectarse a sus feeds y dispositivos.

Paso 4: Abra el ejemplo de lectura de feeds

Ahora abramos nuestro IDE de Arduino e iniciemos el proceso de codificación. En primer lugar, necesitamos tener instalada la biblioteca Adafruit IO Arduino.

¿No sabes cómo instalar bibliotecas? esta es una gran guía de Adafruit: Bibliotecas Arduino

Adafruit ofrece muchos ejemplos prediseñados para que los usemos y aprendamos. Uno de estos ejemplos es: adafruitio_21_feed_read. Puede encontrar este ejemplo aquí: Archivo - Ejemplos Adafruit IO Arduino adafruitio_21_feed_read

(disculpe mi interfaz holandesa en la imagen)

Paso 5: Configuremos nuestra conexión

Si ha abierto con éxito el boceto adafruitio_21_feed_read, debería ver 2 pestañas en su boceto: adafruitio_21_feed_read y config.h. Este boceto se hizo para que podamos conectarnos al feed que hicimos en el paso 1.

Para conectarnos a este feed, debemos completar algunos detalles sobre nuestro WiFi y nuestra cuenta de Adafruit,

Viajemos a config.h, aquí completaremos los siguientes detalles:

Su nombre de usuario de Adafruit:

#define IO_USERNAME "joopert"

Tu clave de Adafruit:

#define IO_KEY "1234567890abcdefghijklmnop"

El nombre de tu WiFi:

#define WIFI_SSID "MyWifi"

Y tu contraseña de WiFi:

#define WIFI_PASS "aVerySecretPassword"

Ahora regresemos a la pestaña adafruitio_21_feed_read y completemos:

Su nombre de usuario de Adafruit … de nuevo:

#define FEED_OWNER "joopert"

Y finalmente su nombre de feed (del feed que hicimos en el paso 1):

AdafruitIO_Feed * sharedFeed = io.feed ("temporizador", FEED_OWNER);

Paso 6: Verifique la conexión a Adafruit IO

Para comprobar si los pasos que dimos antes se han ejecutado correctamente, vamos a subir nuestro sketch al NodeMCU. Si abre su monitor de serie, debería parecerse a la imagen de arriba. Primero, el monitor en serie le muestra que está tratando de conectarse a su WiFi y a Adafruit. si está completo debería decir:

Adafruit IO conectado

¡Esta es una gran noticia! Ahora podemos comenzar a agregar funcionalidad a nuestro temporizador …

Paso 7: Permite LED

¡Ahora es el momento de encender nuestra tira de LED!

Conecte su tira de LED al PIN D5 (si no puede encontrar el D5 conéctelo a otro PIN y cambie el LED_PIN en el código).

Definir tira de LED

El siguiente código agregará la biblioteca NeoPixel (obtenga más información sobre esta biblioteca aquí: https://learn.adafruit.com/adafruit-neopixel-uberguide/arduino-library-use) y se asegurará de que nuestro Arduino sepa dónde está nuestra tira de LED y cuantas luces tiene. Si su tira de LED tiene especificaciones diferentes, cámbiela en el código.

Agregue el siguiente código POR ENCIMA de la configuración vacía ():

// configurar la conexión NeoPixel # include #ifdef _AVR_ #include #endif

#define LED_PIN D5 // ¿Dónde está conectada la tira de LED?

#define LED_COUNT 30 // ¿Cuántos píxeles tiene?

#define BRIGHTNESS 50 // Brillo de NeoPixel, 0 (min) a 255 (max)

Tira de Adafruit_NeoPixel (LED_COUNT, LED_PIN, NEO_GRB + NEO_KHZ800);

Poner en marcha la tira de LED

Ahora iniciaremos nuestra tira de LED y configuraremos el brillo (el brillo va de 0 min a 255 max, pero recomiendo 50… 255 es REALMENTE brillante).

Agregue el siguiente código EN la configuración vacía ():

strip.begin (); // INICIALIZAR el objeto de tira de NeoPixel (OBLIGATORIO) strip.show (); // Apague todos los píxeles lo antes posible strip.setBrightness (50); // Establezca el BRILLO en aproximadamente 1/5 (máx. = 255)

ledsOn (); // Llama a la función para encender cada LED uno por uno

Enciende las luces

Tal vez ya hayas notado que estamos llamando a una función que aún no existe, esa será nuestra próxima parte de la codificación. Si queremos encender nuestras luces, tenemos que crear un 'bucle for' que encienda cada LED individual uno por uno (¿no sabes qué es un bucle for? Compruébalo aquí: www.arduino.cc/reference/ es / idioma / estructura / estructura-de-control / para /).

Ahora vamos a crear la función: ledsOn ();

Agregue el siguiente código ABAJO void handleMessage ():

void ledsOn () {for (int i = 0; i <strip.numPixels (); i ++) {// Para cada píxel en strip… strip.setPixelColor (i, 0, 0, 255); // Establece el color del píxel en azul strip.show (); // Actualiza la tira para que coincida con}}

¡Subir

Ahora es la parte divertida, carguemos nuestro código en NodeMCU… ¡Si todo funciona correctamente, su tira de LED debería volverse completamente azul!

¿No aparecen píxeles ?: ¿Ha conectado la tira al PIN correcto? O tal vez se haya perdido la conexión a Internet.

¿Solo no aparecen algunos píxeles?: ¡Compruebe si ha configurado la cantidad correcta de píxeles!

Paso 8: agregue tiempo al temporizador

Ahora vamos a asegurarnos de que nuestro temporizador realmente… bueno… veces, algo.

Hay diferentes formas de sincronizar con Arduino, una es delay (), esto detiene el procesamiento de nuestra placa por un período de tiempo definido. No vamos a usar esto ya que nuestro Arduino básicamente se congela durante el retraso, y queremos que nuestra placa se actualice con regularidad. Entonces, usaremos Millis (), esta es una forma más elegante de hacer la sincronización en Arduino, con Millis () aún podemos ejecutar código entre intervalos.

Si está interesado en cómo funciona esto, puede consultar este artículo:

Agreguemos el código para Millis ():

Pon este código SOBRE la configuración vacía ()

unsigned long previousMillis = 0; // almacenará la última vez que se actualizó la tira de LED en intervalo = 1000; // intervalo de nuestro temporizador (milisegundos)

Y pongamos este código en el bucle vacío ():

currentMillis largo sin firmar = millis ();// iniciar TIMER RYTHM ****************************************** ********* if (currentMillis - previousMillis> = intervalo) {previousMillis = currentMillis;

// fin TIMER RYTHM ****************************************** ***********

Lo que acabamos de hacer fue crear un ritmo para que nuestra tira de LED apague los LED, en el siguiente paso agregaremos el código para hacer precisamente eso.

Paso 9: ¡Cuenta atrás

En este paso: haremos una función que se asegurará de que cada segundo (o el intervalo que haya establecido) apaguemos UN LED al final de la tira hasta que todos nuestros LED se apaguen.

Crearemos un 'int' en la parte superior llamado 'leds'. Esto luego le dirá a nuestro temporizador cuántos leds aún le quedan por apagar.

Agregue el siguiente código POR ENCIMA de la configuración vacía ():

int leds = LED_COUNT-1; // indica cuántos píxeles deben iluminarse

Ahora agreguemos la función 'timer ();', esto apagará una luz cada segundo

Agregue el siguiente código DEBAJO del void ledsOn ():

temporizador vacío () {strip.setPixelColor (leds, 0, 0, 0);

if (leds> -1) {leds--; } else {blinkie (); }}

Queremos darle algunos comentarios al usuario de que el temporizador está listo después de que todas las luces se hayan apagado. Con 'blinkie ();' los LED parpadearán en rojo después de que termine el temporizador.

Agregue el siguiente código POR ENCIMA de la configuración vacía ():

int blinkStatus = 1; // le dice al blinkie (); función si la luz debe estar encendida o apagada

Agregue el siguiente código DEBAJO del temporizador de vacío ():

void blinkie () {if (blinkStatus == 1) {

blinkStatus = 0; strip.clear (); } else {blinkStatus = 1; for (int i = 0; i <strip.numPixels (); i ++) {// Para cada píxel en strip… strip.setPixelColor (i, 255, 0, 0); // Establecer el color del píxel (en RAM) strip.show (); // Actualiza la tira para que coincida con}}}}

Finalmente tenemos que llamar a la función en nuestro bucle void ();, ¿Recuerda el TIMER RYTHM que agregamos en el paso 8? En esta declaración if llamaremos a la función timer ();.

TIMER RYTHM ahora debería verse así:

// iniciar TIMER RYTHM ****************************************** *********

if (currentMillis - previousMillis> = intervalo) {previousMillis = currentMillis; Temporizador(); strip.show ();} // fin TIMER RYTHM ************************************ ******************

¡Ahora sube este código!

En este momento, su tira de LED debería estar apagando 1 LED cada segundo y parpadear en rojo cuando esté listo …

¡Ahora hagamos que este amante de la madre sea controlado a distancia!

Paso 10: Hágalo controlado a distancia: Parte I

Tenemos nuestro temporizador, todo está bien, pero te prometí que podrías controlarlo con tu teléfono, ¿verdad? Entremos en la etapa final de nuestro proyecto: hacer que nuestro temporizador sea controlado a distancia.

¿Aún tienes la pestaña de Adafruit abierta? Viajemos de regreso a io.adafruit.com y vayamos a nuestro panel de interfaz de temporizador y creemos un nuevo bloque: TOGGLE

1. Conecte la palanca a la alimentación del TEMPORIZADOR
2. Establezca el valor ON en: 1
3. Establezca el valor de APAGADO en: 0

La razón de esto es que Adafruit no envía datos de texto a nuestro NodeMCU, sino solo números.

También puede darle un nombre al Toggle si lo desea, tal vez: 'Interruptor de encendido / apagado'

Ahora volvamos al IDE de Arduino

Solo para asegurarnos de que nuestro código esté actualizado, SUBAMOS nuestro código una vez más.

ABRA EL MONITOR DE SERIE una vez que haya terminado de cargar y PRESIONE EL CAMBIO en nuestro panel de Adafruit varias veces. Ahora deberíamos ver algo como esto apareciendo en nuestro monitor serial:

recibido <- 0 recibido <- 1 recibido <- 0 recibido <- 1 recibido <- 0

¡Esto significa que podemos enviar controles a nuestro NodeMCU!

Si no recibe estos mensajes, verifique si sus datos de Adafruit en su config.h aún son correctos.

Paso 11: Hágalo controlado a distancia: Parte II

Ahora todo lo que queda es hacer algo con nuestros controles recibidos.

Para hacer eso tenemos que alterar nuestra sentencia TIMER RYTHM if en el bucle void (); un poco.

Le diremos a nuestro NodeMCU que solo debería iniciar el temporizador una vez que hayamos recibido '1' (que significa: ON) de Adafruit.

Primero recopilemos los datos que Adafruit nos envía

Agregue el siguiente código POR ENCIMA de la configuración vacía ():

int adaData; // recopila los datos que AdaFruit nos envía

Ahora recopilemos esos datos

Agregue el siguiente código DENTRO de void handleMessage ():

adaData = datos-> toInt ();

Cambiemos nuestro bucle vacío ();

TIMER RYTHM ahora debería verse así:

// iniciar TIMER RYTHM ****************************************** ********* if (currentMillis - previousMillis> = intervalo) {previousMillis = currentMillis; if (adaData == 0) {Serial.println ("no estoy corriendo"); } más si (adaData == 1) {temporizador (); } strip.show (); } // finalizar TIMER RYTHM ***************************************** ************

SUBE su código…

¡Ahora debería poder encender y apagar el temporizador usando el interruptor en Adafruit!

Paso 12: ¡Juega! Terminamos … ¿o sí?

¡Ahora mismo debería tener un temporizador remoto en pleno funcionamiento! Si eso es todo para ti, ¡gracias por acompañar este proyecto!

Si desea continuar un poco más, en los próximos pasos agregaremos un botón RESET para nuestro temporizador.

Paso 13: EXTRA: Crear botón momentáneo

Regresemos a nuestro tablero. Ahora queremos CREAR UN NUEVO BLOQUE nuevamente.

1. Crear un botón momentáneo
2. Conéctelo al feed del 'temporizador'
3. Establezca el valor de la prensa en: 2
4. QUITAR el valor de liberación
5. ¡Dale un bonito color!

¡Convenientemente, el botón momentáneo ya se llama 'Reset'!

Una vez que haya creado este bloque, pruébelo, el botón funciona si recibe:

recibido <- 2

En su monitor de serie.

Si no ve este mensaje, intente volver a cargar el boceto

Paso 14: EXTRA: agregue la función de reinicio

Para que el botón de reinicio haga algo, debemos agregar una función que reinicie todos los LED a su estado original.

Agregue el siguiente código DEBAJO del vacío blinkie ():

void rerun () {leds = LED_COUNT; ledsOn (); }

Ahora todo lo que queda es llamar a nuestra función, para eso tenemos que cambiar TIMER RYTHM una última vez

TIMER RYTHM ahora debería verse así:

// iniciar TIMER RYTHM ****************************************** ********* if (currentMillis - previousMillis> = intervalo) {previousMillis = currentMillis if (adaData == 0) {Serial.println ("no estoy corriendo"); } más si (adaData == 1) {temporizador (); } más si (adaData == 2) {volver a ejecutar (); } strip.show (); } // finalizar TIMER RYTHM ***************************************** ************

SUBE su código…

¡Ahora también debería poder restablecer el temporizador presionando el botón!