Timer controlat de la distanță cu NodeMCU: 14 pași

2024 Autor: John Day | [email protected]. Modificat ultima dată: 2024-01-30 11:43

Aici vom crea un cronometru folosind un NodeMCU și Adafruit. Vom afișa temporizatorul cu o bandă LED și îl vom putea controla folosind telefonul sau computerul nostru!

Scopul nostru:

Creați un cronometru folosind o bandă LED pe care o putem: porni, întrerupe și reseta folosind telefonul sau computerul nostru.

Provizii

Hardware:

• NodeMCU ESP 8266
• Benzi LED Adafruit NeoPixel

Biblioteci:

• Adafruit_NeoPixel.h
• AdafruitIO_WiFi.h

Alte:

O conexiune WiFi decentă

Pasul 1: Să creăm un feed în Adafruit

Acum, că avem tot ce ne trebuie, suntem gata să începem să construim! În primul rând trebuie să creăm un feed în Adafruit. Adafruit este un serviciu care ne face foarte ușor să ne conectăm Arduino la internet și să facem funcții utile controlate de la distanță. Dacă nu ați făcut-o deja, înscrieți-vă la Adafruit.

Acum să creăm un nou feed

Putem numi feedul nostru oricum dorim, îl numesc „temporizator”.

Ceea ce face un feed este să înregistreze tot ceea ce facem în tabloul nostru de bord (pe care îl vom crea în doar un minut) și să trimitem aceste date către consiliul nostru, dar la asta ne vom uita odată ce avem de trimis date.

Pasul 2: Acum să facem un tablou de bord

Acum, în același mod în care am creat un feed, vom crea un nou tablou de bord. Îmi voi numi tabloul de bord: „interfață cu temporizator”, pentru că asta va fi practic tabloul nostru de bord: o interfață cu butoanele care ne controlează temporizatorul.

Pasul 3: Obțineți cheia noastră

Dacă dorim să ne conectăm Arduino la fluxul nostru, trebuie să obținem cheia Adafruit, aceasta este parola dvs. secretă, care vă va asigura că numai dvs. vă puteți conecta la fluxurile dvs.

Puteți obține cheia făcând clic pe butonul galben AIO Key din partea dreaptă sus a ecranului din Adafruit.

Salvați această cheie undeva, vom avea nevoie de ea mai târziu.

Nu distribui cheia ta! În caz contrar, persoanele cu intenții proaste se pot conecta la fluxurile și dispozitivele dvs.

Pasul 4: Deschideți Exemplul de citire a fluxului

Acum să deschidem ID-ul nostru Arduino și să începem procesul de codare. În primul rând, trebuie să avem instalată biblioteca Adafruit IO Arduino.

Nu știți cum să instalați biblioteci? acesta este un mare ghid de Adafruit: Arduino Libraries

Adafruit oferă o mulțime de exemple prefabricate pe care să le folosim și să le învățăm. Unul dintre aceste exemple este: adafruitio_21_feed_read. Puteți găsi acest exemplu aici: Fișier - Exemple Adafruit IO Arduino adafruitio_21_feed_read

(scuzați-mi interfața olandeză în imagine)

Pasul 5: Să configurăm conexiunea noastră

Dacă ați deschis cu succes schița adafruitio_21_feed_read, ar trebui să vedeți 2 file în schița dvs.: adafruitio_21_feed_read și config.h. Această schiță a fost făcută astfel încât să ne putem conecta la fluxul pe care l-am făcut la pasul 1.

Pentru a ne conecta la acest feed, trebuie să completăm câteva detalii despre WiFi-ul nostru și contul nostru Adafruit,

Să călătorim la config.h, aici vom completa următoarele detalii:

Numele dvs. de utilizator Adafruit:

#define IO_USERNAME "joopert"

Cheia dvs. Adafruit:

#define IO_KEY "1234567890abcdefghijklmnop"

Numele WiFi-ului tău:

#define WIFI_SSID "MyWifi"

Și parola WiFi:

#define WIFI_PASS "aVerySecretPassword"

Acum să revenim la fila adafruitio_21_feed_read și să completăm:

Numele dvs. de utilizator Adafruit … din nou:

#define FEED_OWNER "joopert"

Și, în sfârșit, numele dvs. de feed (din feed-ul pe care l-am făcut la pasul 1):

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

Pasul 6: Verificați conexiunea la Adafruit IO

Pentru a verifica dacă pașii pe care i-am făcut înainte au fost executați corect, vom încărca schița noastră pe NodeMCU. Dacă deschideți monitorul serial, ar trebui să arate ca imaginea de mai sus. Mai întâi, monitorul serial vă arată că încearcă să se conecteze la WiFi și la Adafruit. dacă este complet, ar trebui să spună:

Adafruit IO conectat

Aceasta este o veste minunată! Acum putem începe să adăugăm funcționalități temporizatorului nostru …

Pasul 7: Permite LED-ul

Acum este timpul să ne aprindem banda LED!

Conectați banda LED la PIN-ul D5 (dacă nu găsiți D5, conectați-l la un alt PIN și schimbați LED_PIN în cod).

Definiți banda LED

Următorul cod va adăuga biblioteca NeoPixel (aflați mai multe despre această bibliotecă aici: https://learn.adafruit.com/adafruit-neopixel-uberguide/arduino-library-use) și asigurați-vă că Arduino știe unde este banda noastră LED și câte lumini are. Dacă banda dvs. LED are specificații diferite, modificați-o în cod.

Adăugați următorul cod Deasupra setării nule ():

// configurați conexiunea NeoPixel # include #ifdef _AVR_ #include #endif

#define LED_PIN D5 // Unde este conectată banda LED?

#define LED_COUNT 30 // Câți pixeli are?

#define BRIGHTNESS 50 // Luminozitate NeoPixel, 0 (min) până la 255 (max)

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

Porniți banda LED

Acum vom lansa banda LED și vom seta luminozitatea (luminozitatea merge de la 0 min la 255 max, dar recomand 50 … 255 este cu adevărat luminos).

Adăugați următorul cod ÎN setarea nulă ():

strip.begin (); // INITIALIZAȚI obiectul de bandă NeoPixel (NECESAR) strip.show (); // Dezactivați toți pixelii ASAP strip.setBrightness (50); // Setați BRIGHTNESS la aproximativ 1/5 (max = 255)

ledsOn (); // Apelează funcția pentru a porni fiecare LED unul câte unul

Aprinde lumina

Poate ați observat deja că apelăm la o funcție care nu există încă, aceasta va fi următoarea noastră parte a codificării. Dacă dorim să ne aprindem luminile, trebuie să creăm un „for loop” care să aprindă fiecare LED individual unul câte unul (nu știți ce este o buclă for? Verificați-l aici: www.arduino.cc/reference/ en / language / structure / control-structure / for /).

Acum vom crea funcția: ledsOn ();

Adăugați următorul cod SUB void handleMessage ():

void ledsOn () {for (int i = 0; i <strip.numPixels (); i ++) {// Pentru fiecare pixel din bandă … strip.setPixelColor (i, 0, 0, 255); // Setați culoarea pixelului la albastru strip.show (); // Actualizați banda pentru a se potrivi}}

Încărcați

Acum este partea distractivă, să încărcăm codul nostru pe NodeMCU … Dacă totul funcționează corect, banda LED ar trebui să devină albastră!

Nu apar pixeli ?: ați conectat banda la codul PIN corect? Sau poate conexiunea la internet este pierdută.

Nu apar doar câțiva pixeli ?: verificați dacă setați cantitatea potrivită de pixeli!

Pasul 8: Adăugați sincronizarea la cronometru

Acum ne vom asigura că temporizatorul nostru de fapt … ei bine … ori, ceva.

Există diferite moduri de a face sincronizarea cu Arduino, una este delay (), aceasta oprește procesarea plăcii noastre pentru o perioadă de timp definită. Nu vom folosi acest lucru, deoarece Arduino se blochează practic în timpul întârzierii și dorim ca placa noastră să se actualizeze în mod regulat. Deci vom folosi Millis (), acesta este un mod mai elegant de a face sincronizarea în Arduino, cu Millis () putem rula în continuare codul între intervale.

Dacă sunteți interesat de modul în care funcționează, puteți consulta acest articol:

Să adăugăm codul pentru Millis ():

Puneți acest cod Deasupra setării nule ()

unsigned long previousMillis = 0; // va stoca ultima dată când banda LED a fost actualizatăîn interval = 1000; // intervalul temporizatorului nostru (milisecunde)

Și să punem acest cod ÎN bucla void ():

curent lung nesemnat Millis = millis ();// porniți TIMER RYTHM ********************************************** ********* if (currentMillis - previousMillis> = interval) {previousMillis = currentMillis;

// termin TIMER RYTHM ********************************************** ***********

Ceea ce tocmai am făcut a fost să creăm un ritm pentru banda LED pentru a opri LED-urile, în pasul următor vom adăuga codul pentru a face exact acest lucru.

Pasul 9: Numărătoare inversă

În acest pas: vom realiza o funcție care ne va asigura că în fiecare secundă (sau orice interval pe care l-ați setat) oprim UN LED la capătul benzii până când toate LED-urile noastre sunt stinse.

Vom crea un „int” în partea de sus numit „leduri”. Acest lucru va spune mai târziu temporizatorului nostru câte led-uri mai trebuie să se oprească.

Adăugați următorul cod Deasupra setării nule ():

leduri int = LED_COUNT-1; // precum câte pixeli ar trebui aprinși

Acum să adăugăm funcția „timer ();”, aceasta va opri o lumină în fiecare secundă

Adăugați următorul cod SUB LED-urile nul ():

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

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

Vrem să oferim un feedback utilizatorului că temporizatorul se face după ce toate luminile s-au stins. Cu „blinkie ();” LED-urile vor clipi roșu după terminarea cronometrului!

Adăugați următorul cod Deasupra setării nule ():

int blinkStatus = 1; // spune blinkie (); funcționează dacă lumina ar trebui să fie aprinsă sau oprită

Adăugați următorul cod DUPĂ cronometrul gol ():

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

blinkStatus = 0; strip.clear (); } else {blinkStatus = 1; for (int i = 0; i <strip.numPixels (); i ++) {// Pentru fiecare pixel din bandă … strip.setPixelColor (i, 255, 0, 0); // Setați culoarea pixelului (în RAM) strip.show (); // Actualizați banda pentru a se potrivi}}}}

În cele din urmă trebuie să apelăm funcția în bucla noastră de gol ();, Vă amintiți TIMER RYTHM pe care l-am adăugat la pasul 8? În această instrucțiune if vom apela funcția timer ();.

TIMER RYTHM ar trebui să arate acum astfel:

// porniți TIMER RYTHM ********************************************** *********

if (currentMillis - previousMillis> = interval) {previousMillis = currentMillis; temporizator(); strip.show ();} // end TIMER RYTHM ************************************** ******************

Acum încărcați acest cod!

În prezent, banda LED ar trebui să oprească 1 LED în fiecare secundă și să clipească în roșu când ați terminat …

Acum, să facem acest iubit de mamă controlat de la distanță!

Pasul 10: Faceți controlul de la distanță: partea I

Avem temporizatorul nostru, totul e în regulă, dar ți-am promis că vei putea să-l controlezi cu telefonul, nu? Haideți să intrăm în etapa finală a proiectului nostru: realizarea temporizatorului nostru controlat de la distanță.

Aveți în continuare fila Adafruit deschisă? Să călătorim înapoi la io.adafruit.com și să mergem la tabloul de bord al interfeței cu temporizator și să creăm un bloc nou: TOGGLE

1. Conectați comutatorul la fluxul TIMER
2. Setați valoarea ON la: 1
3. Setați valoarea OFF pe: 0

Motivul este că Adafruit nu trimite date text către NodeMCU, ci doar numere.

De asemenea, puteți da Comutatorului un nume dacă doriți, poate: „Comutator pornit / oprit”

Acum să ne întoarcem la IDE-ul Arduino

Doar pentru a ne asigura că codul nostru este actualizat, să ÎNCĂRCĂM codul încă o dată.

DESCHIDE MONITORUL SERIAL după ce ați terminat încărcarea și APĂSAȚI TOGGLE-ul pe tabloul nostru de bord Adafruit de câteva ori. Ar trebui să vedem acum ceva de genul acesta să apară pe monitorul nostru serial:

primit <- 0 primit <- 1 primit <- 0 primit <- 1 primit <- 0

Aceasta înseamnă că putem trimite de fapt controale către NodeMCU!

Dacă nu primiți aceste mesaje, verificați dacă datele dvs. Adafruit din config.h sunt încă corecte.

Pasul 11: Faceți controlul de la distanță: partea II

Acum nu mai rămâne decât să faci ceva cu comenzile noastre primite.

Pentru a face acest lucru, trebuie să modificăm TIMER RYTHM if declarația din bucla void (); putin.

Îi vom spune NodeMCU că ar trebui să pornească temporizatorul numai după ce am primit „1” (care înseamnă: ON) de la Adafruit.

Mai întâi să colectăm datele pe care ni le trimite Adafruit

Adăugați următorul cod Deasupra setării nule ():

int adaData; // colectează datele pe care ni le trimite AdaFruit

Acum să colectăm de fapt aceste date

Adăugați următorul cod INSIDE mânerul gol ():

adaData = date-> toInt ();

Să ne schimbăm bucla de gol ();

TIMER RYTHM ar trebui să arate acum astfel:

// porniți TIMER RYTHM ********************************************** ********* if (currentMillis - previousMillis> = interval) {previousMillis = currentMillis; if (adaData == 0) {Serial.println ("nu rulez"); } else if (adaData == 1) {timer (); } strip.show (); } // sfârșitul TIMER RYTHM ********************************************* ************

ÎNCĂRCAȚI codul …

Acum ar trebui să puteți activa și dezactiva cronometrul folosind comutatorul din Adafruit!

Pasul 12: Joacă-te! Am terminat … sau suntem?

În acest moment ar trebui să aveți un cronometru de la distanță complet funcțional! Dacă asta e pentru tine, atunci îți mulțumesc că ai venit împreună cu acest proiect!

Dacă doriți să continuați puțin mai mult, în următorii pași vom adăuga un buton RESET pentru cronometrul nostru!

Pasul 13: EXTRA: Creați butonul momentan

Să ne întoarcem la tabloul nostru de bord. Acum vrem să creăm din nou un bloc nou.

1. Creați un buton Momentary
2. Conectați-l la fluxul „temporizator”
3. Setați valoarea apăsării la: 2
4. ELIMINAȚI valoarea de lansare
5. Dă-i o culoare frumoasă!

În mod convenabil, butonul momentan este deja numit „Reset”!

Odată ce ați creat acest bloc, testați-l, butonul funcționează dacă primiți:

primit <- 2

În monitorul dvs. serial.

Dacă nu vedeți acest mesaj, încercați să reîncărcați schița

Pasul 14: EXTRA: Adăugați funcția Reset

Pentru a face ca butonul de resetare să facă orice, trebuie să adăugăm o funcție care resetează toate LED-urile înapoi la starea inițială.

Adăugați următorul cod DUPĂ blinkie-ul gol ():

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

Acum nu mai rămâne decât să ne apelăm la funcție, pentru asta trebuie să schimbăm TIMER RYTHM pentru ultima dată

TIMER RYTHM ar trebui să arate acum astfel:

// porniți TIMER RYTHM ********************************************** ********* if (currentMillis - previousMillis> = interval) {previousMillis = currentMillis if (adaData == 0) {Serial.println ("Im not running"); } else if (adaData == 1) {timer (); } else if (adaData == 2) {rerun (); } strip.show (); } // terminați TIMER RYTHM ********************************************* ************

ÎNCĂRCAȚI codul …

Acum ar trebui să puteți reseta temporizatorul apăsând butonul!