Távirányítású időzítő NodeMCU -val: 14 lépés

2024 Szerző: John Day | [email protected]. Utoljára módosítva: 2024-01-30 09:41

Itt létrehozunk egy időzítőt NodeMCU és Adafruit segítségével. Az időzítőnket LED szalaggal jelenítjük meg, és telefonon vagy számítógépen keresztül tudjuk irányítani!

A mi célunk:

Hozzon létre egy időzítőt egy LED -szalag segítségével, amelyre képesek vagyunk: elindítani, szüneteltetni és visszaállítani telefonunk vagy számítógépünk segítségével.

Kellékek

Hardver:

• NodeMCU ESP 8266
• Adafruit NeoPixel LED szalag

Könyvtárak:

• Adafruit_NeoPixel.h
• AdafruitIO_WiFi.h

Egyéb:

Korrekt WiFi kapcsolat

Lépés: Hozzon létre egy feedet az Adafruitban

Most, hogy megvan minden, amire szükségünk van, készen állunk az építkezésre! Először is létre kell hoznunk egy takarmányt az Adafruitban. Az Adafruit egy olyan szolgáltatás, amely igazán megkönnyíti számunkra az Arduino internethez való csatlakoztatását és hasznos távirányítású funkciók létrehozását. Ha még nem tette meg, regisztráljon az Adafruitra.

Most hozzunk létre egy új hírcsatornát

A hírcsatornának bármit elnevezhetünk, amit akarunk, én „időzítőnek” hívom.

A hírcsatorna mindent rögzít az irányítópultunkon (amit csak egy perc alatt létrehozunk), és elküldi ezeket az adatokat a testületünknek, de ezt meg fogjuk nézni, amint meg kell küldeni az adatokat.

2. lépés: Készítsünk egy irányítópultot

Most, ugyanúgy, ahogy hírcsatornát készítettünk, létrehozunk egy új irányítópultot. Fel fogom hívni a műszerfalomat: "időzítő interfész", mert alapvetően ez lesz a műszerfalunk: egy interfész az időzítő vezérléséhez szükséges gombokkal.

3. lépés: Szerezd meg a kulcsunkat

Ha az Arduino -t össze szeretnénk kapcsolni a hírcsatornánkkal, meg kell szereznünk az Adafruit kulcsunkat, ez a titkos jelszava, amely biztosítja, hogy csak Ön tudjon csatlakozni a hírcsatornákhoz.

A kulcsot az Adafruit képernyőjének jobb felső sarkában található sárga AIO Key gombra kattintva szerezheti be.

Mentse el ezt a kulcsot valahol, később szükségünk lesz rá.

Ne ossza meg a kulcsát! Ellenkező esetben rossz szándékú emberek csatlakozhatnak az Ön hírcsatornáihoz és eszközeihez.

4. lépés: Nyissa meg a Feed olvasási példát

Most nyissuk meg az Arduino IDE -t, és indítsuk el a kódolási folyamatot. Először telepítenünk kell az Adafruit IO Arduino könyvtárat.

Nem tudja, hogyan kell telepíteni a könyvtárakat? ez az Adafruit nagyszerű útmutatója: Arduino Libraries

Az Adafruit sok előre elkészített példát kínál számunkra, amelyeket felhasználhatunk és tanulhatunk tőlük. Az egyik ilyen példa: adafruitio_21_feed_read. Ezt a példát itt találja: Fájl - Példák Adafruit IO Arduino adafruitio_21_feed_read

(elnézést a holland felülettől a képen)

5. lépés: Állítsuk be a kapcsolatot

Ha sikeresen megnyitotta az adafruitio_21_feed_read vázlatot, akkor két lapot kell látnia a vázlatában: adafruitio_21_feed_read és config.h. Ez a vázlat azért készült, hogy csatlakozhassunk az 1. lépésben készített hírcsatornához.

Ahhoz, hogy ehhez a hírcsatornához csatlakozhassunk, meg kell adnunk néhány adatot a WiFi -ről és az Adafruit -fiókunkról,

Utazzunk a config.h címre, itt töltsük ki a következő adatokat:

Az Ön Adafruit felhasználóneve:

#define IO_USERNAME "joopert"

Az Adafruit kulcsa:

#define IO_KEY "1234567890abcdefghijklmnop"

A WiFi neve:

#define WIFI_SSID "MyWifi"

És a WiFi jelszava:

#define WIFI_PASS "aVerySecretPassword"

Most térjünk vissza az adafruitio_21_feed_read fülre, és töltsük ki:

Az Adafruit felhasználóneved… ismét:

#define FEED_OWNER "joopert"

És végül a hírcsatorna neve (az 1. lépésben készített hírcsatornából):

AdafruitIO_Feed *sharedFeed = io.feed ("időzítő", FEED_OWNER);

6. lépés: Ellenőrizze a kapcsolatot az Adafruit IO -val

Annak ellenőrzésére, hogy az előző lépéseket helyesen hajtottuk -e végre, feltöltjük vázlatunkat a NodeMCU -ba. Ha kinyitja a soros monitort, annak valahogy úgy kell kinéznie, mint a fenti képen. Először a soros monitor mutatja, hogy megpróbál csatlakozni a WiFi -hez és az Adafruithoz. ha ez teljes, akkor ezt kell írni:

Az Adafruit IO csatlakoztatva

Ez remek hír! Most elkezdhetjük hozzáadni a funkciókat az időzítőnkhöz…

7. lépés: Engedélyezze a LED -et

Itt az ideje, hogy bekapcsoljuk a LED szalagot!

Csatlakoztassa a LED -szalagot a D5 PIN -kódhoz (ha nem találja a D5 -öt, csatlakoztassa azt egy másik PIN -kódhoz, és módosítsa a LED_PIN kódot).

Határozza meg a LED szalagot

A következő kód hozzáadja a NeoPixel könyvtárat (erről a könyvtárról itt talál további információt: https://learn.adafruit.com/adafruit-neopixel-uberguide/arduino-library-use), és győződjön meg arról, hogy az Arduino ismeri a LED-szalag helyét, és hány lámpája van. Ha a LED -szalag különböző specifikációkkal rendelkezik, módosítsa a kódban.

Adja hozzá a következő kódot az üres beállítás () fölé:

// a NeoPixel kapcsolat beállítása #include #ifdef _AVR_ #include #endif

#define LED_PIN D5 // Hová van csatlakoztatva a LED szalag?

#define LED_COUNT 30 // Hány pixel van benne?

#define BRIGHTNESS 50 // NeoPixel fényerő, 0 (perc) - 255 (max)

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

Indítsa el a LED szalagot

Most elindítjuk a LED szalagot, és beállítjuk a fényerőt (a fényerő 0 perctől 255 -ig terjed, de azt javaslom, hogy az 50… 255 TÉNYLEG világos).

Adja hozzá a következő kódot az üres beállításhoz ():

strip.begin (); // INICIALIZÁLÁS NeoPixel szalag objektum (SZÜKSÉGES) strip.show (); // Kapcsolja ki az összes pixelt ASAP strip.setBrightness (50); // Állítsa a FÉNYESSÉGET körülbelül 1/5 értékre (max = 255)

ledsOn (); // Felhívja a funkciót, hogy egyesével kapcsolja be az egyes LED -eket

Kapcsold fel a lámpát

Talán már észrevette, hogy olyan funkciót hívunk meg, amely még nem létezik, ez lesz a következő kódolási részünk. Ha fel akarjuk kapcsolni a lámpákat, létre kell hoznunk egy „for loop” -ot, amely egyenként kapcsolja be az egyes LED -eket (nem tudja, mi az a for loop? Nézze meg itt: www.arduino.cc/reference/ hu/language/structure/control-structure/for/).

Most létrehozzuk a függvényt: ledsOn ();

Adja hozzá a következő kódot az alábbi void handleMessage () kódhoz:

void ledsOn () {for (int i = 0; i <strip.numPixels (); i ++) {// Minden csíkban lévő pixelhez… strip.setPixelColor (i, 0, 0, 255); // Állítsa a képpont színét kék csíkra. Show (); // Frissítse a csíkot a megfelelőre}}

Feltöltés

Most ez a szórakoztató rész, töltsük fel kódunkat a NodeMCU -ba … Ha minden megfelelően működik, a LED -szalagnak most teljesen kékre kell váltania!

Nem jelennek meg képpontok ?: csatlakoztatta a csíkot a megfelelő PIN -kódhoz? Vagy esetleg megszakadt az internetkapcsolat.

Csak néhány pixel nem jelenik meg ?: ellenőrizze, hogy a megfelelő mennyiségű képpontot állította be!

8. lépés: Adja hozzá az időzítést az időzítőhöz

Most megbizonyosodunk arról, hogy az időzítőnk valójában… hát… alkalommal, valami.

Az Arduino segítségével különböző módokon lehet időzíteni, az egyik a delay (), ez leállítja a táblánk feldolgozását egy meghatározott időre. Ezt nem fogjuk használni, mivel az Arduino alapvetően lefagy a késleltetés alatt, és azt szeretnénk, ha az alaplapunk rendszeresen frissülne. Tehát a Millist () fogjuk használni, ez egy elegánsabb módja az időzítésnek az Arduino -ban, a Millis () segítségével továbbra is futtathatunk kódot az intervallumok között.

Ha érdekel, hogyan működik ez, akkor nézd meg ezt a cikket:

Adjuk hozzá a Millis () kódját:

Tegye ezt a kódot az üres beállítás fölé ()

unsigned long previousMillis = 0; // tárolja a LED -szalag utolsó frissítésének idejét intervallum = 1000; // időzítőnk intervalluma (ezredmásodperc)

Tegyük ezt a kódot a void loop -ba ():

előjel nélküli hosszú áramMillis = millis ();// start TIMER RYTHM ******************************************** ********* if (currentMillis - previousMillis> = intervallum) {previousMillis = currentMillis;

// vége IDŐZÍTŐ RYTHM ******************************************** ***********

Az imént tettünk egy ritmust a LED -szalagunkhoz a LED -ek kikapcsolásához, a következő lépésben hozzáadjuk a kódot.

9. lépés: Visszaszámlálás

Ebben a lépésben: létrehozunk egy funkciót, amely biztosítja, hogy másodpercenként (vagy bármilyen beállított időközönként) lekapcsoljuk az EGY LED -et a csík végén, amíg az összes LED ki nem alszik.

Létrehozunk egy "int" -t a tetején, az úgynevezett "led". Ez később megmondja az időzítőnknek, hogy hány lednek kell még kikapcsolnia.

Adja hozzá a következő kódot a void setup () fölé:

int ledek = LED_COUNT-1; // megmondja, hogy hány képpontot kell megvilágítani

Most tegyük hozzá a 'timer ();' funkciót, ez másodpercenként kikapcsol

Adja hozzá a következő kódot a void ledsOn () alatt:

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

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

Szeretnénk néhány visszajelzést adni a felhasználónak arról, hogy az időzítő az összes lámpa kiégése után elkészült. 'Blinkie ();' a LED -ek pirosan villognak az időzítés után!

Adja hozzá a következő kódot az üres beállítás () fölé:

int blinkStatus = 1; // elmondja a blinkie -t (); funkció, ha a lámpának be- vagy kikapcsolnia kell

Adja hozzá a következő kódot a void timer () alatt:

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

blinkStatus = 0; strip.clear (); } else {blinkStatus = 1; for (int i = 0; i <strip.numPixels (); i ++) {// A szalag minden pixeléhez… strip.setPixelColor (i, 255, 0, 0); // A pixel színének beállítása (RAM -ban) strip.show (); // Frissítse a csíkot a megfelelőre}}}}

Végül meg kell hívnunk a függvényt az üres ciklusunkban ();, Emlékszel a 8. lépésben hozzáadott TIMER RYTHM -re? Ebben az if utasításban hívjuk a függvényt timer ();.

A TIMER RYTHM most így néz ki:

// start TIMER RYTHM ******************************************** *********

if (currentMillis - previousMillis> = intervallum) {previousMillis = currentMillis; időzítő(); strip.show ();} // end TIMER RYTHM ************************************** *******************

Most töltse fel ezt a kódot!

Jelenleg a LED -szalagnak másodpercenként 1 LED -et kell kikapcsolnia, és pirosan kell villognia, ha elkészült…

Most tegyük távirányíthatóvá ezt az anyaszerelmet!

10. lépés: Legyen távirányítású: I. rész

Megvan az időzítőnk, minden rendben és dandy, de megígértem neked, hogy a telefonoddal tudod majd irányítani? Lépjünk be projektünk utolsó szakaszába: időzítőnk távirányításúvá tétele.

Még mindig nyitva van az Adafruit lapja? Utazzunk vissza az io.adafruit.com oldalra, és menjünk az időzítő felületének műszerfalára, és hozzunk létre egy új blokkot: TOGGLE

1. Csatlakoztassa a kapcsolót a TIMER feedhez
2. Állítsa be az ON értéket: 1
3. Állítsa az OFF értéket: 0 -ra

Ennek az az oka, hogy az Adafruit nem szöveges adatokat küld a NodeMCU -hoz, hanem csak számokat.

A Toggle -nek nevet is adhat, ha úgy tetszik, például: „Be/Ki kapcsoló”

Most térjünk vissza az Arduino IDE -hez

Csak hogy a kódunk naprakész legyen, töltsük fel még egyszer a kódunkat.

Nyissa meg a SOROZATI MONITORT, miután befejezte a feltöltést, és nyomja meg néhányszor az Adafruit műszerfalán lévő kapcsolót. Most valami ilyesmit kellene látnunk a soros monitorunkban:

kapott <- 0 kapott <- 1 kapott <- 0 kapott <- 1 kapott <- 0

Ez azt jelenti, hogy ténylegesen elküldhetjük a vezérlőket a NodeMCU -nak!

Ha nem kapja meg ezeket az üzeneteket, ellenőrizze, hogy a konfigurációban megadott Adafruit adatok továbbra is helyesek -e.

11. lépés: Távirányítás: II. Rész

Most már csak az a dolgunk, hogy valamit tegyünk a kapott vezérlőkkel.

Ehhez módosítanunk kell a TIMER RYTHM if utasításunkat a void loop -ban (); kicsit.

Megmondjuk a NodeMCU -nak, hogy csak akkor indítsa el az időzítőt, ha megkaptuk az 1 -et (ami azt jelenti: BE) az Adafruit -tól.

Először gyűjtsük össze az Adafruit által küldött adatokat

Adja hozzá a következő kódot az üres beállítás () fölé:

int adaData; // összegyűjti az AdaFruit által küldött adatokat

Most gyűjtsük össze ezeket az adatokat

Adja hozzá a következő kódot az üres fogantyú belsejébenMessage ():

adaData = adatok-> toInt ();

Változtassuk meg a void loopunkat ();

A TIMER RYTHM most így néz ki:

// start TIMER RYTHM ******************************************** ********* if (currentMillis - previousMillis> = intervallum) {previousMillis = currentMillis; if (adaData == 0) {Serial.println ("im not running"); } else if (adaData == 1) {timer (); } strip.show (); } // vége TIMER RYTHM ******************************************* ************

TÖLTSE fel a kódját…

Most már képesnek kell lennie az időzítő be- és kikapcsolására az Adafruit kapcsolójával!

12. lépés: Játssz körül! Végeztünk… vagy igen?

Jelenleg egy teljesen működő távoli időzítővel kell rendelkeznie! Ha ez neked való, akkor köszönöm, hogy részt vettél ebben a projektben!

Ha egy kicsit tovább szeretné folytatni, a következő néhány lépésben hozzáadunk egy RESET gombot az időzítőhöz!

13. lépés: EXTRA: Hozzon létre pillanatnyi gombot

Térjünk vissza a műszerfalunkhoz. Most megint új blokkot akarunk létrehozni.

1. Hozzon létre egy pillanatnyi gombot
2. Csatlakoztassa az "időzítő" hírcsatornához
3. Állítsa be a préselési értéket: 2
4. Távolítsa el a kioldási értéket
5. Adj szép színt!

Kényelmesen a pillanatnyi gombot már „Reset” -nek hívják!

Miután létrehozta ezt a blokkot, próbálja ki, a gomb működik, ha megkapja:

kapott <- 2

A soros monitorban.

Ha nem látja ezt az üzenetet, próbálja meg újra feltölteni a vázlatot

14. lépés: EXTRA: Adja hozzá a Reset funkciót

Ahhoz, hogy a reset gomb bármit megtegyen, hozzá kell adnunk egy funkciót, amely visszaállítja az összes LED -et az eredeti állapotba.

Adja hozzá a következő kódot a void blinkie () alatt:

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

Most már csak a függvényünk hívása maradt, ehhez utoljára meg kell változtatnunk az IDŐZÍTŐ RITMÁT

A TIMER RYTHM most így néz ki:

// start TIMER RYTHM ******************************************** ********* if (currentMillis - previousMillis> = intervallum) {previousMillis = currentMillis if (adaData == 0) {Serial.println ("im not running"); } else if (adaData == 1) {timer (); } else if (adaData == 2) {rerun (); } strip.show (); } // vége IDŐZÍTŐ RYTHM ******************************************* ************

TÖLTSE fel a kódját…

Most már képesnek kell lennie az időzítő visszaállítására a gomb megnyomásával!