Temporitzador controlat a distància amb NodeMCU: 14 passos

2024 Autora: John Day | [email protected]. Última modificació: 2024-01-30 08:13

Aquí crearem un temporitzador amb NodeMCU i Adafruit. Mostrarem el nostre temporitzador amb una tira LED i podrem controlar-lo mitjançant el nostre telèfon o ordinador.

El nostre objectiu:

Creeu un temporitzador mitjançant una tira LED que puguem: iniciar, pausar i restablir mitjançant el nostre telèfon o ordinador.

Subministraments

Maquinari:

• NodeMCU ESP 8266
• Tira LED Adafruit NeoPixel

Biblioteques:

• Adafruit_NeoPixel.h
• AdafruitIO_WiFi.h

Altres:

Una connexió WiFi decent

Pas 1: creem un feed a Adafruit

Ara que tenim tot el que necessitem, estem preparats per començar a construir. Primer de tot, hem de crear un feed a Adafruit. Adafruit és un servei que ens facilita molt la connexió del nostre Arduino a Internet i fer funcions de control remot útils. Si encara no ho heu fet, inscriviu-vos a Adafruit.

Ara creem un nou feed

Podem anomenar el nostre feed a qualsevol cosa que vulguem, ho dic "temporitzador".

El que fa un feed és enregistrar tot el que fem al nostre tauler (que crearem en tan sols un minut) i enviarem aquestes dades al nostre tauler, però això és una cosa que ens fixarem un cop tinguem dades per enviar.

Pas 2: ara fem un tauler

Ara, de la mateixa manera que hem creat un feed, crearem un nou tauler. Cridaré al meu tauler: "interfície de temporitzador", perquè bàsicament serà el nostre tauler: una interfície amb els botons per controlar el nostre temporitzador.

Pas 3: obteniu la nostra clau

Si volem connectar el nostre Arduino al nostre canal d'informació, necessitem obtenir la nostra clau Adafruit, aquesta és la vostra contrasenya secreta que us assegurarà que només us pugueu connectar als vostres canals d'informació.

Podeu obtenir la vostra clau fent clic al botó groc de la tecla AIO a la part superior dreta de la pantalla a Adafruit.

Deseu aquesta clau en algun lloc, la necessitarem més endavant.

No compartiu la vostra clau. En cas contrari, les persones amb males intencions es podrien connectar als vostres feeds i dispositius.

Pas 4: obriu l'exemple de lectura de feeds

Ara obrim el nostre ID Arduino i comencem el procés de codificació. Primer de tot, hem de tenir instal·lada la biblioteca Adafruit IO Arduino.

No sabeu com instal·lar biblioteques? aquesta és una gran guia d'Adafruit: Arduino Libraries

Adafruit ofereix una gran quantitat d’exemples prefabricats per fer-los servir i aprendre. Un d’aquests exemples és: adafruitio_21_feed_read. Podeu trobar aquest exemple aquí: Fitxer - Exemples Adafruit IO Arduino adafruitio_21_feed_read

(disculpeu la meva interfície holandesa a la imatge)

Pas 5: configurem la nostra connexió

Si heu obert l'esbós adafruitio_21_feed_read, hauríeu de veure dues pestanyes al vostre esbós: adafruitio_21_feed_read i config.h. Aquest esbós s'ha fet perquè puguem connectar-nos al feed que hem fet al pas 1.

Per connectar-nos a aquest canal d'informació, hem d'emplenar alguns detalls sobre la nostra connexió WiFi i el nostre compte d'Adafruit,

Viatgem a config.h, aquí emplenarem les dades següents:

El vostre nom d'usuari d'Adafruit:

#define IO_USERNAME "joopert"

La vostra clau Adafruit:

#define IO_KEY "1234567890abcdefghijklmnop"

El nom del vostre WiFi:

#define WIFI_SSID "MyWifi"

I la vostra contrasenya WiFi:

#define WIFI_PASS "aPasswordMoltSecret"

Tornem ara a la pestanya adafruitio_21_feed_read i emplenem:

El vostre nom d'usuari d'Adafruit … de nou:

#define FEED_OWNER "joopert"

I, finalment, el vostre nom de feed (del feed que vam fer al pas 1):

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

Pas 6: comproveu la connexió a Adafruit IO

Per comprovar si els passos que hem fet abans s’han executat correctament, penjarem el nostre esbós al NodeMCU. Si obriu el vostre monitor sèrie, hauria de ser semblant a la imatge de més amunt. Primer, el monitor sèrie us mostra que intenta connectar-vos al vostre WiFi i a Adafruit. si està complet, hauria de dir:

Adafruit IO connectat

Aquesta és una gran notícia. Ara podem començar a afegir funcions al nostre temporitzador …

Pas 7: Permet el LED

Ara és hora d’encendre la nostra tira LED.

Connecteu la tira LED al PIN D5 (si no trobeu el D5, connecteu-lo a un altre PIN i canvieu el LED_PIN al codi).

Definiu una tira LED

El següent codi afegirà la biblioteca NeoPixel (obteniu més informació sobre aquesta biblioteca aquí: https://learn.adafruit.com/adafruit-neopixel-uberguide/arduino-library-use) i assegureu-vos que el nostre Arduino sap on és la nostra tira LED i quantes llums té. Si la vostra tira LED té especificacions diferents, canvieu-la al codi.

Afegiu el codi següent A sobre de la configuració nul·la ():

// configureu la connexió NeoPixel # include #ifdef _AVR_ #include #endif

#define LED_PIN D5 // On està connectada la tira LED?

#define LED_COUNT 30 // Quants píxels té?

#define BRIGHTNESS 50 // Lluminositat NeoPixel, de 0 (mín.) a 255 (màx.)

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

Engegueu la tira LED

Ara engegarem la nostra tira LED i configurarem la brillantor (la brillantor va de 0 min a 255 màx., Però us recomano 50 … 255 és MOLT brillant).

Afegiu el codi següent A la configuració nul·la ():

strip.begin (); // INICIALITZAR NeoPixel strip object (OBLIGATORI) strip.show (); // Desactiveu tots els píxels ASAP strip.setBrightness (50); // Estableix BRIGHTNESS a 1/5 aproximadament (màxim = 255)

ledsOn (); // Crida a la funció per encendre cada LED un per un

Enceneu els llums

Potser ja us heu adonat que anomenem una funció que encara no existeix, que serà la nostra pròxima part de codificació. Si volem encendre els llums hem de crear un "bucle for" que encengui cada LED individualment un per un (no sabeu què és un bucle for? Consulteu-lo aquí: www.arduino.cc/reference/ ca / language / structure / control-structure / for /).

Ara crearem la funció: ledsOn ();

Afegiu el codi següent SOTA void handleMessage ():

void ledsOn () {for (int i = 0; i <strip.numPixels (); i ++) {// Per a cada píxel de la tira … strip.setPixelColor (i, 0, 0, 255); // Estableix el color del píxel en blau strip.show (); // Actualitza la tira perquè coincideixi}}

Carrega

Ara és la part divertida, carregem el nostre codi al NodeMCU … Si tot funciona correctament, la vostra tira LED ara hauria de quedar totalment blava.

No apareixen píxels ?: heu connectat la tira al PIN correcte? O potser es perd la vostra connexió a Internet.

Només apareixen alguns píxels ?: comproveu si heu definit la quantitat adequada de píxels.

Pas 8: afegiu temporització al temporitzador

Ara ens assegurarem que el nostre temporitzador realment … bé … vegades, alguna cosa.

Hi ha diferents maneres de sincronitzar amb Arduino, una és delay (), això atura el processament de la nostra placa durant un període de temps definit. No ho utilitzarem, ja que el nostre Arduino bàsicament es congela durant el retard i volem que la nostra placa s’actualitzi regularment. Així que farem servir Millis (), aquesta és una manera més elegant de fer el temps a Arduino, amb Millis () encara podem executar codi entre intervals.

Si us interessa saber com funciona això, podeu consultar aquest article:

Afegim el codi de Millis ():

Poseu aquest codi A sobre de la configuració nul·la ()

unsigned long previousMillis = 0; // emmagatzemarà l'última vegada que es va actualitzar la tira LED entre 1000 intervals; // interval del nostre temporitzador (mil·lisegons)

I posem aquest codi al bucle buit ():

corrent llarg sense signar Millis = millis ();// iniciar TIMER RYTHM ********************************************** ********* if (actualMillis - anteriorMillis> = interval) {anteriorMillis = actualMillis;

// final TIMER RYTHM *********************************************** ***********

El que acabem de fer va ser crear un ritme perquè la nostra tira LED apagués els LED, al següent pas afegirem el codi per fer-ho.

Pas 9: compte enrere

En aquest pas: farem una funció que ens assegurarà que cada segon (o l'interval que hàgiu establert) apaguem UN LED al final de la tira fins que tots els nostres LED estiguin apagats.

A la part superior, crearem un "int" anomenat "leds". Més tard, això indicarà al nostre temporitzador quants leds encara ha d'apagar.

Afegiu el codi següent A sobre de la configuració nul·la ():

int leds = LED_COUNT-1; // com a quants píxels s’han d’il·luminar

Afegim ara la funció 'temporitzador ();', això apagarà un llum cada segon

Afegiu el codi següent SOTA el void ledsOn ():

void timer () {strip.setPixelColor (leds, 0, 0, 0);

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

Volem donar una opinió a l'usuari que el temporitzador es realitza després que s'hagin esgotat tots els llums. Amb 'blinkie ();' els LED parpellejaran de vermell després de finalitzar el temporitzador.

Afegiu el codi següent A sobre de la configuració nul·la ():

int blinkStatus = 1; // li diu al blinkie (); funció si la llum ha d’estar encesa o apagada

Afegiu el codi següent SOTA el temporitzador de buit ():

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

blinkStatus = 0; strip.clear (); } else {blinkStatus = 1; for (int i = 0; i <strip.numPixels (); i ++) {// Per a cada píxel de la tira … strip.setPixelColor (i, 255, 0, 0); // Estableix el color del píxel (en memòria RAM) strip.show (); // Actualitza la tira perquè coincideixi}}}}

Finalment, hem de cridar la funció al nostre bucle buit ();, Recordeu el TIMER RYTHM que vam afegir al pas 8? En aquesta sentència if anomenarem la funció temporitzador ();.

TIMER RYTHM ara hauria de ser així:

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

if (actualMillis - anteriorMillis> = interval) {anteriorMillis = actualMillis; temporitzador (); strip.show ();} // // TIMER RYTHM *************************************** ******************

Ara pengeu aquest codi.

Ara mateix, la vostra tira LED hauria d'apagar 1 LED cada segon i parpellejar en vermell quan acabi …

Ara fem que es controli a distància aquest amant de la mare!

Pas 10: feu que es controli a distància: primera part

Tenim el nostre temporitzador, està molt bé, però us vaig prometre que podríeu controlar-lo amb el vostre telèfon, oi? Entrem a la fase final del nostre projecte: fer que el nostre temporitzador es controli a distància.

Encara teniu la pestanya Adafruit oberta? Anem a tornar a io.adafruit.com i anem al nostre tauler de la interfície del temporitzador i creem un bloc nou: TOGGLE

1. Connecteu el commutador al feed TIMER
2. Establiu el valor ACTIVAT a: 1
3. Establiu el valor OFF en: 0

La raó és que Adafruit no envia dades de text al nostre NodeMCU, sinó només números.

Si voleu, també podeu donar nom a l'activador de commutació, potser: "Interruptor d'activació / desactivació"

Tornem ara a l’IDE Arduino

Només per assegurar-nos que el nostre codi estigui actualitzat, CARREGEM el nostre codi una vegada més.

OBRI EL MONITOR DE SERIE un cop hàgiu acabat de carregar i PREMEU EL TOGGLE al nostre tauler d'Adafruit unes quantes vegades. Ara hauríem de veure alguna cosa semblant al nostre monitor sèrie:

rebut <- 0 rebut <- 1 rebut <- 0 rebut <- 1 rebut <- 0

Això significa que realment podem enviar controls al nostre NodeMCU.

Si no rebeu aquests missatges, comproveu si les vostres dades d'Adafruit a config.h encara són correctes.

Pas 11: Feu que es controli a distància: Part II

Ara només queda fer alguna cosa amb els nostres controls rebuts.

Per fer-ho hem d’alterar la nostra sentència TIMER RYTHM if al bucle void (); una mica.

Direm al nostre NodeMCU que només hauria d'iniciar el temporitzador un cop hàgim rebut "1" (que significa: ACTIVAT) d'Adafruit.

Primer recollim les dades que ens envia Adafruit

Afegiu el codi següent A sobre de la configuració nul·la ():

int adaData; // recull les dades que AdaFruit ens envia

Ara recopilem aquestes dades

Afegiu el codi següent DINTRE del void handleMessage ():

adaData = dades-> toInt ();

Canviem el nostre bucle buit ();

TIMER RYTHM ara hauria de ser així:

// iniciar TIMER RYTHM ********************************************** ********* if (actualMillis - anteriorMillis> = interval) {anteriorMillis = actualMillis; if (adaData == 0) {Serial.println ("no estic en execució"); } else if (adaData == 1) {timer (); } strip.show (); } // finalitza TIMER RYTHM ********************************************* ************

CARREGA el teu codi …

Ara hauríeu de poder activar i desactivar el temporitzador mitjançant l’interruptor d’Adafruit.

Pas 12: Juga al voltant! Ja hem acabat … o ho fem?

En aquest moment hauríeu de tenir un temporitzador remot que funcioni completament. Si és això per a vosaltres, gràcies per venir amb aquest projecte.

Si voleu continuar una mica més, en els propers passos afegirem un botó RESET per al nostre temporitzador.

Pas 13: EXTRA: Crea un botó momentani

Tornem al nostre tauler. Ara volem CREAR UN NOU BLOC de nou.

1. Crea un botó momentani
2. Connecteu-lo al feed "temporitzador"
3. Establiu el valor de la premsa a: 2
4. ELIMINEU el valor de llançament
5. Dóna-li un bon color!

Convenientment, el botó momentani ja es diu "Restableix".

Quan hàgiu creat aquest bloc, proveu-lo, el botó funcionarà si rebeu:

rebut <- 2

Al vostre monitor sèrie.

Si no veieu aquest missatge, proveu de tornar a penjar l'esbós

Pas 14: EXTRA: afegiu la funció de restabliment

Per fer que el botó de restabliment faci qualsevol cosa, hem d'afegir una funció que restableixi tots els LED a l'estat original.

Afegiu el codi següent SOTA el void blinkie ():

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

Ara només queda trucar a la nostra funció, per això hem de canviar TIMER RYTHM per última vegada

TIMER RYTHM ara hauria de ser així:

// iniciar TIMER RYTHM ********************************************** ********* if (currentMillis - previousMillis> = interval) {previousMillis = currentMillis if (adaData == 0) {Serial.println ("no estic en execució"); } else if (adaData == 1) {timer (); } else if (adaData == 2) {rerun (); } strip.show (); } // finalitza TIMER RYTHM ********************************************* ************

CARREGA el teu codi …

Ara també hauríeu de poder restablir el temporitzador prement el botó.