Arduino Tank vezérlés Wi-Fi-n keresztül. A gép vezérlése WiFi-n keresztül ESP8266 NodeMCU Arduino android wifi terhelésvezérléssel

Gondolt már arra, hogy bármilyen elektronikus eszközt okostelefonjával vezéreljen? Egyetértek, nagyon menő lenne egy robotot vagy bármilyen más eszközt okostelefonról irányítani. Egy egyszerű leckét kínálunk kezdőknek és bábuknak, hogyan vezérelhetnek okostelefont Arduino segítségével Bluetooth-on keresztül. Ha ezen lecke után szeretné jobban megismerni az Arduinót, találhat róla könyveket.

1. lépés Mire van szükségünk

Eszközök

Modul - Bluetooth Modul HC 05/06
Tábla - Arduino
Fénykibocsátó dióda (LED)
Ellenállás - 220Ω
Android készülék

Szoftver

Arduino IDE
Android Studio (valójában nem szükséges, mert az Android alkalmazást lent találja)

2. lépés: Hogyan működik

Általában ezt a lépést a végén tesszük meg, de hogy megértse, mit kell elérnünk, nézze meg az eredményt ebben a közbenső lépésben. Az alábbiakban egy lépésről lépésre bemutató videót is közzétettünk.

3. lépés: Elkezdjük összeszerelni az áramkört

Az oktatóanyagunkban szereplő áramkör annyira egyszerű és kicsi, hogy csak néhány kapcsolatot kell létrehoznunk:

Arduino tűk___________Bluetooth modul tűk
RX (0. tű)_________________________________________________________________
TX (1. tű)________________________________RX
5V______________________________VCC
GND____________________________GND

Csatlakoztassa a LED negatívját az Arduino GND-jéhez, a pozitívot pedig a 13-as érintkezőhöz 220–1 kOhm ellenálláson keresztül. Általában az alábbi ábránkon minden teljesen világos.

Ne csatlakoztasd az RX-et RX-hez és a TX-TX-hez Bluetooth-kimeneteket az Arduino-kimenetekhez, nem fogsz adatot fogadni, itt a TX adást, az RX-et vételt jelent.

4. lépés: Töltse fel a programot az Arduino-ba

Most írnunk kell egy programot, és fel kell töltenünk az Arduinónkra. Ha még nem tudja, hogyan kell ezt megtenni, töltsön le könyveket. Az alábbi kód pontosan az, amit be kell töltenünk az Arduino-ba.

/* Bluetooh Basic: LED BE KI * Kódoló - Mayoogh Girish * Webhely - http://bit.do/Avishkar * Az alkalmazás letöltése: https://github.com/Mayoogh/Arduino-Bluetooth-Basic * Ez a program lehetővé teszi, hogy az arduino 13. érintkezőjén lévő LED vezérléséhez Bluetooth-modul segítségével */ char data = 0; //Változó a fogadott adatok tárolására void setup() ( Serial.begin(9600); //Beállítja a baudot a soros adatátvitelhez pinMode(13, OUTPUT); //A 13-as digitális érintkezőt állítja be kimeneti lábnak ) void loop() ( if(Serial.available() > 0) // Adatok küldése csak akkor, ha adatot kap: ( data = Serial.read(); //Olvassa be a bejövő adatokat és tárolja a változó adatban Serial.print(data); // Érték nyomtatása az adatokon belül a soros monitorban Serial.print("\n"); //Új sor if(data == "1") // Ellenőrzi, hogy az adatok értéke egyenlő-e 1 digitalWrite(13, HIGH); // Ha az érték 1, akkor a LED bekapcsol, else if(data == "0") // Ellenőrzi, hogy az adatok értéke egyenlő-e 0 digitalWrite(13, LOW); //Ha az érték 0, akkor a LED kialszik ) )

5. lépés: Hogyan működik a folyamat

A HC 05/06 modul soros kommunikációs csatornán keresztül működik. Az Android alkalmazás egymás után küldi el az adatokat a Bluetooth-modulnak, amikor megnyom egy adott gombot. A másik végén lévő Bluetooth fogadja az adatokat, és a Bluetooth modul TX kapcsolatán (Arduino RX kapcsolaton) keresztül elküldi az Arduino-nak.

Az Arduino-ba betöltött kód ellenőrzi a kapott adatokat és összehasonlítja azokat. Ha "1" jelzés érkezik, a LED kigyullad, majd kialszik, ha "0" érkezik. Nyissa ki a soros port monitort, és figyelje meg a kapott adatokat.

6. lépés: Alkalmazás Android-eszközökhöz

Ebben az oktatóanyagban nem foglalkozunk az Android-eszközökhöz való alkalmazások létrehozásával. Az alkalmazást letöltheti a GitHubon.

Hogyan kell használni az alkalmazást?

Miután Bluetooth-on csatlakoztunk, le kell töltenünk és telepítenünk kell egy alkalmazást, amely okostelefon segítségével :) távolról vezérli a LED-ünket. Az alkalmazást ingyenesen letöltheti az Amazon.com oldalról. Csatlakoztatjuk az okostelefont a HC 05/06 Bluetooth modulhoz:

  1. Kapcsolja be a HC 05/0 modult
  2. Készüléket keresek
  3. A HC 05/06-hoz az alapértelmezett „1234” vagy „0000” (négy nulla) jelszó megadásával csatlakozunk.

Ezt követően telepítjük az alkalmazást okostelefonunkra. Nyissuk ki. Válasszon ki egy eszközt - válassza ki a Bluetooth modult a listából (HC 05/06). Sikeres csatlakoztatás után nyomja meg az ON gombot a LED bekapcsolásához és az OFF gombot a LED kikapcsolásához. Ezután kattintson a „Kapcsolat bontása” gombra, hogy megszakítsa a kapcsolatot a Bluetooth modullal.

Ez egy útmutató volt a bábuk és a kezdők számára, hogyan kell Bluetooth-modult csatlakoztatni az Arduino-hoz. Ez a projekt továbbfejleszthető és magasabb szintre emelhető például otthoni automatizáláshoz okostelefonos vezérléssel, vezérelt robottal és még sok mással.

A firmware, a frissítések és egyéb adatok átvitele forrasztópáka és vezetékek használatával nem a legjobb megoldás az Arduino számára. Az arduino wi-fi mikrokontrollerek azonban nem olcsók, és nem is mindig van rájuk szükség, ezért a felhasználók inkább nem használják fölöslegesen projektjeikben.

Most azonban egy újabb kínai termék hódította meg a piacot: csatlakoztathatja saját esp8266-os wi-fi zavaróját egy Arduino kártyához vagy más rendszerhez, és számos egyéb előnnyel együtt stabil kapcsolatot kap. Tehát nézzük meg az arduino uno wi-fi-t, és hogy megéri-e megvenni ezt a modult, valamint hogy valójában mi is az arduino wi-fi hasonló mikrokontrollerje.

Elérhető Wi-Fi modulok az Arduino számára

Manapság a legtöbb Arduino felhasználó már nem aggódik az ilyen eszközök ára miatt, pedig 3 éve még luxusnak számított egy Arduino wi-fi modul. Mindez az esp8266 wi-fi jammernek köszönhetően, amelynek gyártói egy teljesen új, funkcionalitásában elképesztő, ugyanakkor meglehetősen olcsó terméket vezettek be a piacra, amely jelentős mértékben hozzájárult és versenyt teremtett ebben az irányban.

Így az arduino wi-fi esp8266 ma már a legkedvezőbb árú modulnak számít a piacon, mint minden testvére. Így az ár a külföldi oldalakon 2 dollártól kezdődik, ami lehetővé teszi, hogy ezeket a modulokat kötegekben vásárolja meg, és ne kelljen ezerszer újratöltenie, újraforrasztva az érintkezőket a funkcionalitás fenntartása érdekében.

Eleinte ezt az Arduino wi-fi modult főleg arduino wi-fi pajzsként használták, mivel ez volt a legolcsóbb lehetőség, és semmivel sem volt rosszabb az eredetinél. A készülék valóban szinte legendás, mert az árához képest nincs jelentős hátránya. Számos könyvtár létezik, beleértve a felhasználóikat is, és támogatja a soros buszokon és a legegyszerűbb AT és AT+ parancsokon keresztüli munkát is. Ennek köszönhetően nincs szükség a hírhedt C99 szemantikájának tanulmányozására, ahogy az más, harmadik féltől származó mikrovezérlők esetében gyakran előfordul.

Ennek megfelelően még egy kezdő is másodpercek alatt kitalálja, a szakember pedig használhatja a már elkészített könyvtárakat. További előnyök közé tartozik:

  1. A processzor 160 MHz-es, de 32 bites, ami némi nyomot hagy a teljesítményen. De érdemes megjegyezni, hogy a modult továbbra is az Arduino kártyákkal együtt használják, amelyek maguk is levágják a magas frekvenciákat és felemésztik az erőforrások nagy részét ismeretlen okokból.
  2. Az esp8266 wi-fi modult kiadó gyártó nem hagyta abba az érdekes projekteket, és most már egy sor bizonyított minőségű mikrokontroller található.
  3. Modern hálózati biztonsági szabványok. Természetesen a WPA és a WPA2 már nem olyan biztonságos, mint szeretnénk, de jelenlétük nem tehet mást, mint egy ilyen olcsó kontrollerben.
  4. 16 kimeneti port, köztük 10 bites, lehetővé téve az alaplappal való kísérletezést.

Ennél is fontosabb, hogy a doboz típusától függően akár 4 megabájt állandó memóriát is találhat, és ez nagyban leegyszerűsíti a nagy könyvtárakkal, sőt egyes médiafájlokkal való munkát. Hiszen a legtöbb Arduino táblán még az 1 megabájt is megfizethetetlen luxusnak számít.

Az esp8266 wi-fi jellemzői minden bizonnyal biztatóak, különösen drágább versenytársaival összehasonlítva, de egy olyan felhasználónak, akinek nincs korábbi tapasztalata ezekkel a kártyákkal, kérdése lesz a csatlakoztatás módját illetően. Az a tény, hogy a modulnak sokkal több tűje van, mint amennyit a kezdők látni szoktak, és ennek megfelelően pánikba esnek. Ha azonban megérti a helyzetet, akkor a valóságban nincs semmi bonyolult. Elég forrasztóanyagot és forrasztópákát felhalmozni, és csak elolvasni az utasításokat.

Wi-Fi modul csatlakoztatása Arduinohoz

Nézzük meg az esp8266 esp 12e csatlakoztatását és mi az az esp8266 wi-fi uart híd. Végül is a modul csatlakoztatása és konfigurációja veti fel a legtöbb kérdést.


Először is döntse el, hogy a mikrokontroller melyik verziójával rendelkezik. Az elsőben a LED-ek a tűk közelében vannak beépítve, a másodikban, amelyet nemrégiben kezdtek gyártani, a jelzőlámpák az antenna közelében helyezkednek el.

Csatlakozás előtt le kell töltenie a legújabb firmware-t, amely lehetővé teszi, hogy a csomagok átváltási árfolyamát 9600 egységnyi információra növelje másodpercenként. És ellenőrizzük a kapcsolatot egy usb-ttl kábel és a CoolTerm megfelelő termináljával.


A fent leírt kábel csatlakoztatására szolgáló érintkezők szabványosak, de a tápellátás az Arduino 3,3 voltos tűjén keresztül érkezik. Fontos megjegyezni, hogy az alaplap által szolgáltatott maximális áramerősség nem állítható 150 mA fölé, az esp8266 esp 07 és az esp8266 szellemes felhő wi-fi modul arduinohoz pedig 240 mA-t igényel.

Ha azonban nincs más áramforrás, használhatja az Arduino szabványos verzióját, de a tábla ereje csorbát szenved. Bár, ha a terhelés nem nagy, akkor a 70 mA is elég, készüljünk fel a mikrokontroller hirtelen újraindításaira csúcsterhelési időkben, és ennek megfelelően írjunk szoftvert, hogy az a kártya túlterhelése nélkül szűrje és ossza szét a fájlokat.


Egy másik csatlakozási lehetőség alább látható. Fontos - az RX-TX érintkezők szálkereszttel vannak összekötve. Mivel az ESP8266 modul jelszintje 3,3 V, az Arduinoé pedig 5 V, a jelszint átalakításához rezisztív feszültségosztót kell használnunk.

Wi-Fi modul regisztrálása Arduino-ban

Mint ismeretes, megfelelő tapasztalat birtokában az esp8266 ex 12e shield párosítható okostelefonnal, de a kezdőknek nehézséget okoz az esp8266 esp 12 regisztrálása az Arduino rendszerben. Valójában elegendő csatlakoztatni a modult, és ellenőrizni a működőképességét számos szabványos AT-parancs kiadásával a hibakeresési menün keresztül.

Például villogást adhat hozzá egy szabványos LED-del (a fenti csatlakozási rajzhoz):

#define TXD 1 // GPIO1/TXD01 void setup() ( pinMode(TXD, OUTPUT); ) void loop() ( digitalWrite(TXD, HIGH); delay(1000); digitalWrite(TXD, LOW); delay(1000) ;)

Amint a tábla megerősíti, hogy látja a mikrokontrollert a rendszerben, megkezdheti vele a teljes munkát. Érdemes azonban megjegyezni, hogy ha magát az Arduino kártyát csak a vezérlő csatlakoztatására használják a projektben, ez irracionális.

Elegendő egy USB-UART konverter, mivel az esp8266 nem használja az Arduino „agyát”, a flash memóriája pedig bőven elegendő néhány alapvető könyvtár és firmware tárolására. Ennek megfelelően nincs értelme extra pénzt költeni egy segédkártyára, ha egyszerűen ráforraszthatja az átalakítóra, és tovább használhatja a projektben. Ugyanakkor egy kiegészítő áramforrás csatlakoztatásával, és nem kell aggódni, hogy az adatok továbbítása a legdöntőbb pillanatban leáll a rendszer tápellátásának hiánya miatt.

Fontos jegyzet! Az utolsó áramkörhöz szokás szerint feltöltjük a vázlatot az Arduinóba, de mivel az ESP8266 modul a 0 és 1 érintkezőkhöz csatlakozik, a programozás lehetetlenné válik. A fordító hibát jelez. Válassza le az ESP8266-hoz vezető vezetékeket a 0 és 1 érintkezőkről, végezze el a programozást, majd helyezze vissza a tűket a helyükre, és nyomja meg az Arduino reset gombját.

Egyre nagyobb népszerűségnek örvend, és az Arduino máris magához ragadja a kezdeményezést – felveszi ezeket a Wi-Fi modulokat a támogatott kártyák listájára.
De hogyan lehet csatlakoztatni az Arduino-hoz? Egyáltalán megoldható valahogy Arduino nélkül? Ez a mai cikk pontosan erről fog szólni.

A jövőre nézve azt mondom, hogy lesz egy második, gyakorlatiasabb cikk a firmware-ről és az ESP8266 modul programozásáról az Arduino IDE fejlesztői környezetben. De először a dolgok.

Ez a videó teljesen megismétli a cikkben bemutatott anyagot.



Jelenleg ennek a modulnak számos változata létezik, íme néhány közülük:

És itt van az ESP01, ESP03, ESP12 pinoutja:


* Ez a kép kikapcsolt állapotban jó minőségben megtekinthető. pighixxx.com webhely.

Én személy szerint az ESP07-es verziót szeretem a legjobban. Legalábbis amiatt, hogy van fém képernyő (megvédi a mikroáramköröket a külső interferencia ellen, ezáltal stabilabb működést biztosít), saját kerámia antenna, külső antenna csatlakozója. Kiderül, ha egy külső antennát csatlakoztatunk hozzá, például mint pl biquadrat, akkor jó tartományt érhet el. Ezen kívül van jó néhány bemeneti/kimeneti port, az úgynevezett GPIO (General Purpose Input Output port), hasonlóan az Arduino tűihez.

Térjünk vissza a bárány Wi-Fi moduljainkhoz és az Arduinóhoz. Ebben a cikkben az ESP8266 (ESP01 modell) Arduino Nano V3-hoz való csatlakoztatását fogom megvizsgálni.

Ez az információ azonban a legtöbb ESP8266 modulra és különféle Arduino kártyákra is vonatkozik, például a legnépszerűbb Arduino UNO-ra.

Néhány szó az ESP01 lábakról:

VccÉs GND(a fenti képen ezek 8 és 1) - étel, lábonként Vcc benyújtható, a dokumentációból ítélve, 3-3,6 V között, A GND- földelés (mínusz teljesítmény). Láttam, hogy egy ember csatlakoztatta ezt a modult két AA elemhez (a tápfeszültség ebben az esetben körülbelül 2,7 V volt), és a modul működőképes. Ennek ellenére a fejlesztők jelezték azt a feszültségtartományt, amelyben a modulnak garantáltan működnie kell; ha másikat használ, az a te problémád.

Figyelem! Ez a modul 3,3 V-os logikára épül, míg az Arduino többnyire 5 V-os logikára épül. Az 5 V könnyen károsíthatja az ESP8266-ot, ezért az Arduino-tól külön kell táplálni.

- Az Arduinómnak van egy lába, ahol 3,3 V van írva, miért ne használnád?

Valószínűleg azt gondolod. Az a helyzet, hogy az ESP8266 eléggé energiaigényes modul, csúcsidőben akár 200 mA-es áramot is tud fogyasztani, ilyen áram leadására alapból szinte egyetlen Arduino sem képes, kivéve az Arduino Due-t, amelyben a 3,3 V-os vonal mentén az áram elérheti a 800 mA-t, ami bőven elég, egyéb esetekben azt tanácsolom, hogy használjon további 3,3 V-os stabilizátort, például AMS1117 3,3 V-ot. Rengeteg ilyen van Kínában és nálunk is.

Láb RST 6 - a modul újraindítására szolgáló hardver számára készült, rövid időre alacsony logikai szint alkalmazásával a modul újraindul. Bár ezt elhanyagoltam a videóban, mégis azt tanácsolom „nyomja” ezt a lábat egy 10 kOhm-os ellenállással a tápegység pozitív oldalára, a jobb stabilitás elérése érdekében a modul működésében, különben a legkisebb interferenciára is újraindítanám.

Láb CP_PD 4 (vagy más módon HU) - ismét arra szolgál, hogy a modult energiatakarékos üzemmódba „bekötjük”, amelyben nagyon kevés áramot fogyaszt. Hát megint... Nem ártana ezt a lábat 10 kOhm-os ellenállással pozitívra "nyomni" Pitalova A videóban ezt a lábat hülyén rövidre zártam Vcc-re, mert nem volt kéznél ilyen ellenállás.

Lábak RXD0 7 TXD0 2 - hardveres UART, amelyet villogásra használnak, de senki sem tiltja, hogy ezeket a portokat GPIO-ként használják (GPIO3 és GPIO1). Valamiért a képen nincs jelölve a GPIO3, de az adatlapon ez van:

Mellesleg a lábra TXD0 2 a „Connect” LED csatlakoztatva van, és akkor világít, ha a GPIO1 logikai szintje alacsony, vagy ha a modul küld valamit UART-on keresztül.

GPIO0 5 - nem csak I/O port lehet, hanem programozási módba is helyezheti a modult. Ez úgy történik, hogy ezt a portot egy alacsony logikai szintre csatlakoztatja ("lenyomja" a GND-re), és táplálja a modult. A videóban ezt egy normál gombbal csinálom. Villogás után ne felejtsük el kihúzni a jumpert/megnyomni a gombot (villogás közben nem szükséges nyomva tartani a gombot, bekapcsoláskor a modul programozási módba kerül és újraindításig benne marad).

GPIO2 3 - bemeneti/kimeneti port.

És még egy fontos pont, a Wi-Fi modul minden GPIO-ja 6mA-ig biztonságosan leadhatja az áramot, hogy ne égjen le, ügyeljen arra, hogy az ellenállásokat sorba helyezze a bemeneti/kimeneti portokkal... Ne feledje Ohm törvényét R = U/I = 3,3 V / 0,006 A = 550 Ohm, azaz 560 Ohm-on. Vagy elhanyagoljuk, aztán csodálkozunk, hogy miért nem működik.

Az ESP01-ben minden GPIO támogatja a PWM-et, így a négy GPIO-nkhoz, azaz a GPIO0-3-hoz csatlakoztathat egy motormeghajtót, ala L293 / L298, és kormányozhat két motort, például hajókat, vagy RGB Wi-Fi-t készíthet. Igen, igen, ezen a modulon sok minden van, és egyszerű projektekhez nincs szükség Arduino hegedűsre, csak a villogásra. És ha ESP07-et használ, akkor általában a portok majdnem ugyanazok, mint az Uno portjai, ami lehetővé teszi, hogy magabiztosan nélkülözze az Arduino-t. Igaz, van egy kellemetlen pillanat, az ESP01-nek egyáltalán nincs analóg portja, az ESP07-nek pedig csak egy van, az ADC. Ez természetesen megnehezíti az analóg érzékelőkkel való munkát. Ebben az esetben egy Arduino analóg multiplexer segít.

Úgy tűnik, mindent a pinout magyaráz meg, és itt van az ESP8266 és az Arduino Nano csatlakoztatásának diagramja:

Látod a jumpert az Arduino Nano RST és GND érintkezőin? Erre azért van szükség, hogy az Arduino ne zavarja a modul firmware-jét; az ESP8266 Arduino segítségével történő csatlakoztatása esetén ez előfeltétel.

Továbbá, ha Arduinohoz csatlakozik, a modul RX-jének az arduino RX-éhez kell mennie, TX - TX. Ennek az az oka, hogy a konverter chip eleve keresztmintában csatlakozik az Arduino érintkezőihez.

Szintén fontos a modul RX vonala mentén 1 kOhm-os és 2 kOhm-os ellenállásokból álló rezisztív osztó (két darab 1 kOhm-os ellenállásból készíthető sorba kapcsolással). Mert az Arduino 5 V-os logikájú, a modul pedig 3.3-as. Kiderült, hogy ez egy primitív szintátalakító. Ott kell lennie, mert az RXD TXD modul lábai nem bírják az 5 V-ot.

Nos, teljesen megteheti az Arduino nélkül, ha az ESP8266-ot egy szokásos USB-UART konverteren keresztül csatlakoztatja. Az Arduino-hoz való csatlakozás esetén tulajdonképpen egy szabványos usb és uart interfész konvertert használunk, megkerülve az agyakat. Szóval miért költenél extra pénzt, ha egyáltalán meg tudod csinálni az Arduino nélkül? Csak ebben az esetben csatlakoztatjuk a modul RXD-jét a konverter TXD-RXD-hez.

Ha túl lusta a csatlakozásokkal bajlódni, ellenállásokkal és stabilizátorokkal babrálni, akkor vannak kész NodeMcu megoldások:

Itt minden sokkal egyszerűbb: csatlakoztassa a kábelt a számítógéphez, telepítse az illesztőprogramokat és a programot, csak ne felejtse el használni a GPIO0 jumperét/gombját, hogy a modult firmware módba kapcsolja.

Nos, valószínűleg ennyi az elmélettel, a cikk elég hosszúra sikerült, és a gyakorlati részt, a modul firmware-jét és programozását egy kicsit később teszem közzé.

Az egyre összetettebb projektek tanulmányozása és tervezése során eljön az idő, amikor felmerül az igény és a vágy, hogy megtanulják, hogyan kell dolgozni egy olyan általános kommunikációs típussal, mint a WiFi. Mivel ez a fajta kommunikáció lehetővé teszi, hogy kényelmesen egyetlen hálózatot hozzon létre okosotthoni eszközei számára, és vezérelje azokat például mobiltelefonról, táblagépről vagy számítógépről, vagyis valódi okosotthont hozzon létre, amely költséges. tízszer kevesebbet fizet, mintha kész megoldásokat vásárolna a boltban. A WiFi használata természetesen nem korlátozódik erre, és annyi példa van az ilyen típusú kommunikáció használatára, hogy nincs értelme felsorolni őket, és ha erre az oldalra került, az azt jelenti, hogy már valamilyen oknál fogva használja a WiFi-t, csak ki kell találnia, hogyan kell helyesen dolgozni vele.

A legolcsóbb és legnépszerűbb WiFi modul alapján fogjuk kitalálni ESP8266-01. Weboldalunkon megvásárolhatja az ESP8266-01 WiFi modult.

Az ilyen modulok egyik fő előnye a memória és a saját mikrokontroller jelenléte az alaplapon, amely lehetővé teszi a független működést azáltal, hogy a vázlatot közvetlenül magába a modulba tölti be.

Valójában az ESP8266 WiFi modulnak elég sok módosítása van, és ezeket itt nem soroljuk fel; miután megtanulta, hogyan kell dolgozni az egyikkel, könnyen elkezdhet dolgozni másokkal. Azonnal szeretném megjegyezni, hogy a WiFi-vel való munka meglehetősen nehéz feladatnak tűnhet, és ha kevés befejezett projekt van a poggyászában, jobb, ha egyelőre feladja a WiFi kommunikációt, és projektjeiben rádiókommunikációt használ. sokkal könnyebben érthető. Egész közösségek, tematikus fórumok jönnek létre a WiFi modulokkal való munkavégzéshez, ami ismét bizonyítja, hogy a legtöbb embernek milyen nehéz azonnal megérteni az ilyen típusú kommunikációt, és az összes információ újraolvasása után a legtöbb ember egyszerűen feladja. Valószínűleg egyedül e cikk keretein belül nem fogok tudni minden fontos információt belefoglalni, és nincs is értelme, különben újabb rendetlenség lesz. Megpróbálom a legfontosabb pontok szigorú sorrendjének útját követni, hogy elkezdje megérteni az ilyen típusú kommunikáció működési elvét, majd egyszerűen fejleszteni tudja saját készségeit ebben az irányban.

Tehát kezdjük, és először nézzük meg a WiFi modul érintkezőit ESP8266-01.

VCC- modul tápellátás 3V-tól 3,6V-ig

GND- Föld.

RST- A modul újraindításáért felelős kimenet alaphelyzetbe állítása.

CH_PD- "chip kikapcsolás", amikor áramot kap, a modul működése aktiválódik.

TX- adatátvitel (UART interfész)

RX- adatvétel (UART interfész)

GPIO0

GPIO2- általános célú I/O port

A GPIO0 és GPIO2 tűk pontosan ugyanazok a digitális tűk, amelyekkel Arduino kártyákon dolgozunk a különféle érzékelőkkel való összekapcsoláshoz, és az ESP8266-01 modul belső WiFi mikrokontrollerén való független működés megvalósítása esetén használatosak.

Az ESP8266-01 modul megbízható táplálásához használjon külső stabilizált 3,3 V-os tápegységet, és jobb, ha nem próbálja meg az Arduino kártyáról áramot venni, mivel a modul akár 215 mA áramot is fogyaszt, és ennek rossz vége lehet a hibakereső kártyának. Honnan lehet stabilizált 3,3 V-os tápegységet szerezni, remélem nem jelent problémát, különben még korai lenne ezzel a modullal foglalkozni. Például szívesen használom ezt a 3,3 V-os és 5,0 V-os YWRobot tápmodult az áramkörök gyors összeállítására a kenyérsütőtáblákon, amely lehetővé teszi, hogy gyorsan 3,3 V vagy 5 V stabilizált feszültséget kapjon a kenyérsütőtábla megfelelő tápútjain.

A plusz csatlakoztatása (+) a 3,3 V-os tápegységünkről a tűre VCC ESP8266-01 modul, és mínusz (-) csatlakoztassa a tápegységet a kimenethez GND. Ebben az állapotban a modulon lévő piros LED kigyullad, jelezve, hogy a tápellátás megfelelően van csatlakoztatva. A modul aktiválásához a plusz csatlakoztatása is szükséges (+) tápegység kimenettel CH_PD ESP8266-01 modulon, és célszerű ezt közvetlenül egy 10 kOhm-os ellenálláson keresztül megtenni. Most, amikor bekapcsoljuk a tápfeszültséget, a modulon lévő piros LED-nek világítania kell, a kék LED-nek pedig gyorsan fel kell villannia párszor. Ha ez történik veled, akkor minden rendben van, mindent megfelelően csatlakoztatott, és a modul működik. Ellenkező esetben ellenőrizze újra a kapcsolatot, vagy cserélje ki a modult, mert valószínűleg nem működik.

Menj tovább. Az ESP8266 WiFi modullal való együttműködéshez USB-UART adapterre van szükségünk. Különféle adapterek léteznek, például: FT232RL, CP2102, PL2303. De feltételezzük, hogy nincsenek ilyen adapterei, és USB-UART adapterként Arduino kártyát fogunk használni. Ehhez egy Arduino NANO táblát fogok használni, de bármilyen mást is használhatsz, ami a rendelkezésedre áll. A csatlakozás minden táblán azonos. A csatlakozást az alábbi ábra szerint végezzük.

Nézzük, mit csináltunk itt. Azonnal vegye figyelembe, hogy az Arduino táblán lévő érintkezőket jumperrel csatlakoztattuk RSTÉs GND. Ez a manipuláció letiltja a mikrokontrollert, és lehetővé teszi, hogy valódi USB-UART adaptert készítsünk Arduino kártyánkból.

Mivel az ESP8266-01 WiFi modult külön külső tápegységről tápláljuk, ne feledje, hogy projektjeinkben mindig minden tápegység földelését kell csatlakoztatnunk. Ezért csatlakoztatjuk a kimenetet GND Arduino táblák földeléssel (-) külső 3,3 V-os tápegységünk, amelyet az ESP8266-01 modul táplálására terveztek.

Következtetés TX csatlakoztassa az Arduino kártyát a tűhöz TX ESP8266-01 modul. Ez a vonal továbbítja az adatokat a WiFi modulról az Arduino kártyára. Bárki, aki ismeri az UART interfészt, elgondolkozhat: "De hogy lehet ez? Mindenhol azt tanították, hogy a TX-nek csatlakoznia kell az RX-hez. A TX információt továbbít, az RX pedig fogad." És igazad lesz. Így van, a TX mindig az RX-hez van kötve, de abban az esetben, ha Arduinóból készítünk UART adaptert, akkor az eszközöket közvetlenül kell csatlakoztatni. Tekintsük ezt a szabály alóli kivételnek.

Vonal RX Arduino kártyáját is közvetlenül a vonalhoz csatlakoztatjuk RX ESP8266-01 modul. Ez a vonal továbbítja az információkat az Arduino kártyáról a WiFi modul kártyájára. De ezt a kapcsolatot egy úgynevezett feszültségosztón keresztül hozzuk létre, amely két ellenállásból áll, amelyek névleges értéke 1 kOhm és 2 kOhm. Ezen a vonalon két ellenállással (feszültségosztó) kell csökkentenünk a feszültséget, mivel az Arduino kártya 5 V feszültségű logikai jelet továbbít, a WiFi modul pedig 3,3 V feszültséggel működik. A logikai jel konvertálásához használhatunk egy speciális logikai szint átalakító kártyát, ami természetesen helyesebb lenne, de tegyük fel, hogy nincs ilyen, és egy egyszerűbb utat kellett választanunk, és egy feszültségosztó.

Most már mindent csatlakoztattunk, ami a további munkához szükséges, de van még 3 nem használt érintkezőnk ( GPIO0, GPIO2És RST) tovább WiFi modul ESP8266-01. A WiFi modul stabil működéséhez ezeket a még nem használt tűket pozitívra kell húznunk (+) modul tápvezetékei 10 kOhm-os ellenállásokon keresztül.

Ez megkímél minket a különféle interferenciáktól (interferenciáktól), és stabilabbá teszi a modul működését. Jobb azonnal megtenni. Ellenkező esetben ne lepődjön meg azon, hogy a modulja folyamatosan túlterhelt, érthetetlen információkat produkál, vagy egyáltalán nem akar működni. A felhúzó ellenállások használata a mikrokontroller nem használt lábain alapszabály lehet, ha stabil működést szeretne a projektjeiben.

És ismét ellenőrizzük az ESP8266-01 WiFi modul működését. Kapcsolja be a tápfeszültséget, és ellenőrizze, hogy a piros LED világít, és a kék LED párszor felvillan. Ha minden így történik, akkor remek, menjünk tovább. Ellenkező esetben ellenőrizzük a csatlakozások helyességét, valamint az összes érintkező minőségét. Lehet, hogy csak triviális szituáció, amikor mindent átellenőrzött tízszer, és megbizonyosodott arról, hogy minden megfelelően van csatlakoztatva, de amikor bekapcsolja a modult, azt látja, hogy a kék LED nem viselkedik megfelelően, folyamatosan világít, folyamatosan villog, vagy egyáltalán nem reagál semmire. Ennek oka lehet egyes vonalak gyenge érintkezése. Például, amikor egy áramkört összeszerel egy kenyérpanelre, az egyik ellenállás nem ül szorosan a helyére, és ez interferenciát okoz. Ellenőrizze a csatlakozások minőségét. A modul nagyon érzékeny. Ezt ne hanyagold el. Ez az instabil működés gyakori oka.

Általában készen vagyunk a kapcsolattal. Most fel kell készítenünk az Arduino IDE programot az ESP8266-01 WiFi modullal való együttműködéshez. Ehhez le kell töltenünk és telepítenünk kell az Arduino IDE-be a szükséges archívumot könyvtárakkal, példákkal és ESP-kártyákkal, amely ezt követően lehetővé teszi számunkra, hogy vázlatokat közvetlenül az ESP8266-01 modul mikrovezérlőjére töltsünk fel, módosítsuk a firmware-t stb. Ebben a cikkben valószínűleg nem lesz szükségünk ezekre a beállításokra, de számomra úgy tűnik, hogy miután kitaláltuk, hogyan kell csatlakoztatni a modult, az eljárás helyes lesz, ha azonnal letöltünk mindent, ami az Arduino IDE-vel való működéshez szükséges. . Itt elvileg minden egyszerű.

Indítsa el a programot Arduino IDEés lépjen a menübe "Fájl" - "Beállítások"

A megjelenő ablakban a felső mezőbe írjuk, hogy „esp8266”. Ennek eredményeként csak a szükséges firmware lesz az ablakban. Ha rákattint a firmware-re, megjelenik egy gomb "Telepítés". Kattintson a gombra "Telepítés"és várja meg, amíg minden telepítve van. Az archívum elég nagy, körülbelül 150 megabájt, szóval várni kell.

A telepítés befejezése után. Újraindítjuk az Arduino IDE-t, és megnézzük, hogyan jelentek meg az új ESP kártyák az „Eszközök” - „Táblák” menüben. Ez minden. Elkészültünk az Arduino IDE beállításával. Egyelőre nincs szükségünk ezekre a beállításokra, de a jövőbeni munkában nem fogjuk tudni nélkülözni őket.

Mindent összekötöttünk és felkészültünk, most már elkezdhetjük megérteni a vezérlőket. Valójában most továbbra is ellenőrizzük és konfiguráljuk a modult AT parancsokkal, és nincs mód nélküle. A WiFi modulok úgy vannak megvalósítva, hogy a velük folytatott kommunikáció úgynevezett AT parancsok segítségével történik, amelyek a modul firmware-ébe vannak bekötve. Nem fogunk itt felsorolni minden AT parancsot, elég sok van belőlük, és ha mindent alaposan át akarunk tanulmányozni, könnyen megtalálhatjuk őket az interneten. És most csak a legszükségesebbeket fogjuk használni az induláshoz.

Így az Arduino kártyánkat USB-kábellel csatlakoztatjuk a számítógéphez. És egy külső áramforrás, amely táplálja WiFi modul ESP8266-01 Még nem kell bekapcsolni. Elindítjuk az Arduino IDE programot, az „Eszközök” menüből kiválasztjuk az Arduino táblánkat, az én esetemben az Arduino NANO, te pedig kiválasztod a sajátodat. Ne felejtse el kiválasztani azt a portot sem, amelyhez az Arduino csatlakozik. Remélem, megérti mindezt, és tudja, hogyan kell csinálni.

Nyitott port figyelés "Eszközök" - "Port Monitor". A port sebességének kiválasztása 74880 (ezzel a sebességgel a modul elindul), és válassza ki az „NL & CR” pontot a bal oldali listából

Most csatlakoztatunk egy külső áramforrást, amely a WiFi modulunkat táplálja. Ezt követően körülbelül a következő információkat kell látnia a portfigyelőben.

Itt láthatunk néhány információt a WiFi modulunkról (sebesség, a fedélzeti memória mennyisége stb.). A kapott információ a WiFi modul firmware verziójától függően eltérő lehet. Ne erre koncentráljunk. Valami más is fontos. Az alábbiakban értelmetlen karakterkészletet látunk, ez azt jelenti, hogy az általunk beállított port sebesség (74880 baud) csak a modul kezdeti betöltésére alkalmas, hogy ezeket az információkat normálisan lássuk, de ez a sebesség nem alkalmas normál kommunikációra a WiFi modult.

A megfelelő portsebesség kiválasztásához egyszerűen módosítjuk a port sebességét, és szimbólumokat küldünk a portra (a felső mező és a küldés gomb) NÁL NÉL amíg választ nem kapunk rendben. Ha éppen most próbál karaktereket küldeni NÁL NÉL 74880-as sebességgel a portra, válaszul még egy-két értelmetlen karaktert kap.

Próbálja azonnal beállítani a sebességet 115 200 baudra, és küldjön egy AT parancsot. Leggyakrabban a modulok ilyen sebességgel villognak.

Ezt a képet kell látnia a portmonitoron. Ha továbbra is érthetetlen karakterkészletet kap válaszul, csökkentse a sebességet, és küldje újra NÁL NÉL parancsol addig, amíg vissza nem jön a válasz rendben. Ha az összes sebességet kipróbálta, és nem kapta meg a helyes választ, akkor nincs szerencséje, és a modul nem szabványos sebességgel villog a firmware-rel. Ezután már csak a modul frissítése marad normál firmware-rel, de ez egy külön cikk témája.

Remélem, hogy minden rendben van, és a megfelelő sebességet választotta. Egyébként, ha megpróbálja kikapcsolni és újra bekapcsolni a WiFi modult, miután kiválasztotta a megfelelő sebességet, akkor ugyanazok a kezdeti információk helyett, amelyek 74880 baud sebességgel helyesen voltak megjelenítve, éppen ellenkezőleg, lásd a karakterek zavaros halmazát, de a végén látni fogja a „kész” szót. De lehetőségünk van arra, hogy ezeket a kezdeti információkat normál formában, megfelelő sebességgel tekintsük meg; ehhez programozottan újra kell indítanunk a modult az AT paranccsal AT+RST.

Az ESP8266-01 WiFi modul firmware-verziójának megtudásához parancsot kell küldenie a portfigyelőnek AT+GMRés válaszul hozzávetőlegesen a következő információkat kapja:

Az ESP8266-01 WiFi modul hozzáférési pont és kliens módban is működhet. Ahhoz, hogy a modul egyszerre minden üzemmódban működjön, küldje el a parancsot a portfigyelőnek AT+CWMODE=3és válaszul meg kell kapnia rendben.

Csapat AT+CWLAP lehetővé teszi az összes WiFi hozzáférési pont megtekintését, amelyet a modul jelenleg lát. Az én modulom például jelenleg csak három WiFi hozzáférési pontot lát a lefedettségi területén. A válasznak valami ilyesminek kell lennie:

Például ismerjük a harmadik hozzáférési pont jelszavát, és a hozzá való csatlakozáshoz végrehajtjuk a parancsot AT+CWJAP="név","jelszó", az én esetemben ez a parancs így néz ki AT+CWJAP="dsl_unlim_512_home","11111111", amire sikeres választ kapunk:

A parancs paraméterei az ESP8266-01 WiFi modul flash memóriájába íródnak, és ha kikapcsoljuk és újra bekapcsoljuk a modult, akkor automatikusan ehhez a hozzáférési ponthoz fog csatlakozni. Nézd, véletlenül ne hagyj szóközt a parancsban, különben választ fogsz kapni HIBA. Kérjük, vegye figyelembe, hogy a legújabb firmware-verziókban javasolt a parancs használata AT+CWJAP_CUR, vagyis a parancs így fog kinézni AT+CWJAP_CUR="név","jelszó". Ha hirtelen elfelejtettük, hogy a modulunk melyik hozzáférési ponthoz csatlakozik, akkor parancsot kell küldenünk AT+CWJAP? vagy AT+CWJAP_CUR?és válaszul megkapjuk azt a hozzáférési pontot, amelyhez a WiFi modul éppen csatlakozik.

Csatlakozással és kezdeti beállítással WiFi modul ESP8266-01 kitaláltuk. A modul működik és készen áll a jövőbeni projektek megvalósítására. Egyszerűen nem lehetséges egyetlen cikk keretein belül elemezni a modullal való munkavégzés összes lehetséges példáját, és ezzel a következő cikkekben fogunk foglalkozni. Aki pedig nem nagyon jártas a programozásban, de nagyon szeretné gyorsan elkezdeni a projektek kezelését WiFi használatával, annak ajánlom, hogy ismertesse meg őket a RemoteXY WiFi projekttervezővel. Ez az oldal segít abban, hogy egyszerűen létrehozzon egy vezérlőfelületet mobiltelefonjához vagy táblagépéhez, és ezzel vezérelje eszközét, amelyhez WiFi modult csatlakoztat.

Ebből a cikkből megtudhatja, hogyan hozhat létre egy olyan rendszert, amely mobilalkalmazás segítségével be- és kikapcsolhatja az egyenáramú terhelést. Azt is megtanulja, hogyan kell azonnal végrehajtani ezt a feladatot, vagy hogyan használhatja előre beállított időzítőket a terhelések be- és kikapcsolására.

A projekt áttekintése

Ezt a rendszert úgy valósíthatja meg, hogy egy meghatározott ideig egyenáramú terhelést kell bekapcsolnia. Androidos alkalmazásunk segít ebben, hardveres felület, billentyűzet vagy LCD kijelző nélkül.

kiegészítők

ESP8266 Fejlesztési Tanács közgyűlése

Az ESP8266 egy alacsony költségű SoC integrált mikrokontrollerrel és teljes TCP/IP protokoll veremmel, ami azt jelenti, hogy közvetlenül hozzáférhet a Wi-Fi hálózathoz.

Mivel ennek a chipnek saját mikrokontrollerje van, ráteheti az alkalmazás kódját, vagy egyszerűen használhatja a modult Wi-Fi adó-vevőként, amit ebben a projektben fogunk megtenni. Hatékonyabb lenne ezt a modult adó-vevőként és vezérlőként is használni, de képzési célból egy Arduino segítségével fogunk kommunikálni a modullal.

Az ESP8266 chip különböző modulokban érkezik. Az ESP-01 modult fogjuk használni. Természetesen bármilyen más modult használhat.

Először is tudnia kell, hogy a modul 3,3 V-on működik, és az Arduino magas logikai szintű feszültségének azonosnak kell lennie, hogy elkerüljük a modulunk károsodását. Ehhez egy feszültségszint-átalakítóra van szükség az Arduino kártya (amely 5 V-on működik) és a modul között. A jó hír az, hogy a konverternek csak egy tűre lesz szüksége, hogy elküldje az Arduino-nak, mivel a fogadó érintkező általában felismeri az ESP8266 3,3 V-os logikai jeleit.

Ennek az átalakításnak az egyik legegyszerűbb módja a Sparkfun áramköre. Kész modult rendelhet.

Szintátalakító 5V → 3,3V

Az alábbi ábra a modulunk kivezetését mutatja az ESP8266-on:

KövetkeztetésCélja
UTXDAdatátvitel UART-on keresztül
URXDAdatok fogadása UART-on keresztül. A csatlakoztatott kimenetnek 3,3 V-nak kell lennie.
CH_PDKikapcsolás: az alacsony bemenet kikapcsolja a chipet, a magas bemenet bekapcsolja; A modul normál működéséhez csatlakoztatni kell a tápvezetékhez.
GPIO0Betöltéskor: a szintnek magasnak kell lennie ahhoz, hogy normál töltési módba lépjen; alacsony szint speciális rendszerindítási módba lép.
GPIO2Indításkor: az alacsony szint hatására a rendszerbetöltő flash boot módba lép; a magas szint normál rendszerindítási módot okoz.
RSTVisszaállítás; aktív szint - alacsony.
GNDFöld.
VCCTeljesítmény/3,3V.

A modul megfelelő 3,3 V-os tápellátásához az LM317-et, egy konfigurálható lineáris feszültségszabályozót használtam, amelynek kimeneti árama legfeljebb 1,5 A.

Jegyzet: Ne használja az Arduino 3,3 V-os érintkezőjét, mivel az Arduino kártyán található 3,3 V-os feszültségszabályozó nem tudja biztosítani a modul által igényelt áramerősséget, különösen az átvitel közbeni csúcsfogyasztás során.

A logikai szint konverterhez BS170-et használtam (BSS138 helyett); mindkettő jól működik.

Most már csatlakoztathatja a modult a számítógépéhez egy USB-TTL átalakítóval, és tesztelheti.

Relé kenyértábla összeállítás

A relé vezérléséhez BC337 bipoláris NPN tranzisztort használtam, 1 kOhm-os ellenállással az alapon. A tekercs fordított feszültség elleni védelemre 1n4007 diódát használtam.

Úgy döntöttem, hogy a relé alaphelyzetben zárt (NC) érintkezőjét csatlakoztatom a testhez.

Arduino kód

Most egy problémával állunk szemben. Az ESP8266 az UART-ot használja interfészként az AT parancsokhoz, míg az Arduino Uno (amely az Atmega328-at használja) csak egy UART porttal rendelkezik. Ez a port már csatlakoztatva van az USB-TTL hídhoz, valamint a 0 és 1 érintkezőkhöz.

Megoldásként használhat emulátort az UART porthoz egy másik Arduino digitális tűn az AltSoftSerial vagy SoftwareSerial könyvtárak használatával. Ez lehetővé teszi, hogy továbbra is rendelkezzen egy hardveres UART-porttal a hibakereséshez és az üzenetek kinyomtatásához a konzolon, valamint egy szoftverporttal a modullal való kommunikációhoz.

Sokan (köztük jómagam is) problémákról számoltak be a szoftver soros portjával kapcsolatban nagy adatátviteli sebességnél – például az esp8266-nál, 115200 bps-nál. Elmondhatom, hogy a modulból kapott adatok 50%-a megsérül, ha szoftveres UART-t használsz, az Arduino-ból a modulba átvitt adatokból pedig majdnem 100%-a helyes lesz. Ezeket az eredményeket az RX és TX vonalak jeleinek figyelése után kaptam.

Megoldásként néhány definiáló direktívát adtam a kódhoz, hogy könnyebben válasszon hardveres és szoftveres UART portok között. Ne feledje, hogy nem használhatja ugyanazt a portot hibakereséshez és a modullal való kommunikációhoz, ezért ezek közül kell választani.

//uncomment Serial.*** ha hardveres soros portot (0,1 érintkező) szeretne használni az ESP-vel való kommunikációhoz //uncomment esp8266.*** ha szoftveres soros portot (2,3 érintkező) szeretne használni ) az ESP-vel való kommunikációhoz #define esp8266_Available() Serial.available() //esp8266.available() #define esp8266_Find(ARG) Serial.find(ARG) //esp8266.find(ARG) #define esp8266_Serial read() //esp8266 .read() #define esp8266_Write(ARG1,ARG2) Serial.write(ARG1,ARG2) //esp8266.write(ARG1,ARG2) #define esp8266_Print(ARG) Serial.print(ARG) // esp8266.print(ARG)

A forrásban megtalálja annak a kódnak a részét, amely a modult az útválasztóval együtt telepíti:

SendCommand("AT+RST\r\n", 2000, DEBUG); // indítsa újra a modult sendCommand("AT+CWMODE=1\r\n", 1000, DEBUG); // konfigurálás hozzáférési pontként sendCommand("AT+CWJAP=\"tur\",\"341983#tur\"\r\n", 3000, DEBUG); //**** SSID és JELSZÓ MÓDOSÍTÁSA A HÁLÓZAT SZERINT ******// delay(10000); sendCommand("AT+CIFSR\r\n", 1000, DEBUG); // az IP-cím lekérése sendCommand("AT+CIPMUX=1\r\n", 1000, DEBUG); // több kapcsolat beállítása sendCommand("AT+CIPSERVER=1,1337\r\n", 1000, DEBUG); // kiszolgáló engedélyezése a 1337-es porton

A vázlathurok a Wi-Fi kapcsolaton keresztül érkező parancsokra vár. Jelenleg a következő parancsok támogatottak:

  • „con” a pin állapotának lekéréséhez, logikai magas vagy alacsony;
  • „on=” engedélyezi a megfelelő kimenetet;
  • 'of=' kapcsolja ki a megfelelő kimenetet;
  • A „Tm=n/fS” beállítja az időzítőt a megfelelő kimenet bekapcsolására (n) vagy kikapcsolására (f).

Minden parancsnak van megerősítő válasza.

Megjegyzések:

  • a vázlat egyes részei a ;
  • ha régi SDK-val használ modulokat, akkor ugyanazok a hibák lehetnek, mint én. Ebben az esetben az egyetlen megoldás a firmware frissítése a legújabb verzióra. Az ESP8266 modul firmware-ének frissítéséhez lásd a segítséget. Frissítettem a firmware-t 1.3-ról 1.5.4-re.

Teljes programkód:

#beleértve #define DEBUG 0 // ha hardveres soros portot használ az ESP-vel való kommunikációhoz, módosítsa az értéket 0-ra #define ESPBaudRate 115200 #define HWSBaudRate 115200 #define OUTPUT1 11 #define OUTPUT2 12 #define OUTPUT2 12 #define Serial/PUTun3comment13. *** , ha hardveres soros portot (0,1 érintkező) szeretne használni az ESP-vel való kommunikációhoz //uncomment esp8266.*** ha szoftveres soros portot (2,3 érintkező) szeretne használni a kommunikációhoz az ESP #define esp8266_Available() Serial.available( ) //esp8266.available() #define esp8266_Find(ARG) Serial.find(ARG) //esp8266.find(ARG) #define esp8266_Read() S //esp8266_Read() S /esp8266.read() #define esp8266_Write(ARG1 ,ARG2) Serial.write(ARG1,ARG2) //esp8266.write(ARG1,ARG2) #define esp8266_Print(ARG) Serial.print(ARG) //esp8 ARG) // Az Arduino RX vonalát 2-es érintkezővé teszi, az Arduino TX vonalát pedig 3-as érintkezővé. // Ez azt jelenti, hogy az ESP TX vonalát az Arduino 2-es érintkezőjéhez kell csatlakoztatnia, // és az RX vonal az ESP-től az Arduino 3-as érintkezőjéig. SoftwareSerial esp8266(2, 3); /****************/ bájt OUTPUTstate; byte OUTPUTTMRIsSet ; bájt OUTPUTTMRState ; hosszú OUTPUTTimer; /************/ /***Parancsok**/ String GETSTATE = "con"; // Karakterlánc kérése a mobilalkalmazásból, hogy megtudja az egyes kimenetek állapotát String SETON = "on="; // Karakterlánc kérése a mobilalkalmazástól a kimenet engedélyezéséhez String SETOFF = "of="; // Karakterlánc kérése a mobilalkalmazástól a kimenet kikapcsolásához String TIMER = "tm="; // Sor kérése a mobilalkalmazásból a kilépési időzítő beállításához /**************/ void setup() ( Serial.begin(HWSBaudRate); // Soros port az Arduino üzeneteinek küldéséhez számítógépre esp8266.begin(ESPBaudRate); // Szoftver soros port üzenetek küldéséhez Arduinoból ESP8266-ba pinMode(OUTPUT1, OUTPUT); digitalWrite(OUTPUT1, LOW); pinMode(OUTPUT2, OUTPUT); digitalWrite(OUTPUT2, LOW); pinMode ( OUTPUT3, OUTPUT); digitalWrite(OUTPUT3, LOW); // a modul újraindítása sendCommand("AT+RST\r\n", 2000, DEBUG); // konfigurálás hozzáférési pontként sendCommand("AT+CWMODE=1 \r\ n", 1000, DEBUG); //**** SSID és JELSZÓ MÓDOSÍTÁSA A HÁLÓZAT SZERINT ******// sendCommand("AT+CWJAP=\"tur\",\"341983# tur\ "\r\n", 3000, DEBUG); delay(10000); // IP-cím kérése sendCommand("AT+CIFSR\r\n", 1000, DEBUG); // több kapcsolat beállítása sendCommand( "AT+ CIPMUX=1\r\n", 1000, DEBUG); // a szerver engedélyezése a 1337-es porton sendCommand("AT+CIPSERVER=1,1337\r\n", 1000, DEBUG); if (DEBUG == true) Serial.println("Kiszolgáló kész"); ) void loop() ( if (esp8266_Available()) // ellenőrizze, hogy az esp küldött-e üzenetet ( if (esp8266_Find("+IPD,")) ( // várjon, amíg a soros puffer megtelik (minden soros adat elolvasása) delay( 1000 ); // kapjuk meg a kapcsolatazonosítót, hogy le tudjuk választani az int connectId = esp8266_Read() - 48-at; // vonjuk ki a 48-at, mert a read() függvény decimális értéket ad vissza // az ASCII-ben, és a 0 (az első decimális szám) kezdődik with 48 String closeCommand = "AT+CIPCLOSE="; // parancs létrehozása a kapcsolat bezárásához closeCommand += connectionId; // a kapcsolatazonosító hozzáadása closeCommand += "\r\n"; esp8266_Find("? "); // Ez a karakter határozza meg a parancs elejét az üzenetünkben String InStream; InStream = (char) esp8266_Read(); InStream += (char) esp8266_Read(); InStream += (char) esp8266_Read() if (DEBUG == true) Serial.println(InStream); if (InStream.equals(GETSTATE)) ( // válasz a Status= parancsra<состояние_выхода_1><состояние_выхода_2><состояние_выхода_3>String response = "Állapot="; válasz += OUTPUTstate; válasz += OUTPUTstate; válasz += OUTPUTstate; sendHTTResponse(kapcsolatazonosító, válasz); sendCommand(closeCommand, 1000, DEBUG); // a kapcsolat bezárása ) else if (InStream.equals(SETON)) ( int pinNumber = (esp8266_Read() - 48); // megkapjuk az első számjegyet, azaz ha a pin 13, akkor az 1. számjegy egyenlő 1 int secondNumber = (esp8266_Read() - 48); if (secondNumber >= 0 && secondNumber<= 9) { pinNumber *= 10; pinNumber += secondNumber; // получить вторую цифру, т.е., если вывод 13, то 2-ая цифра равна 3, // и добавить ее к первой цифре } if (pinNumber == OUTPUT1) OUTPUTstate = 1; else if (pinNumber == OUTPUT2) OUTPUTstate = 1; else if (pinNumber == OUTPUT3) OUTPUTstate = 1; digitalWrite(pinNumber, 1); String response = "Confg="; // Отклик на команду Confg=<номер_вывода>válasz += pinNumber; sendHTTResponse(kapcsolatazonosító, válasz); sendCommand(closeCommand, 1000, DEBUG); // a kapcsolat bezárása ) else if (InStream.equals(SETOFF)) ( int pinNumber = (esp8266_Read() - 48); // megkapjuk az első számjegyet, azaz ha a pin 13, akkor az 1. számjegy egyenlő 1 int secondNumber = (esp8266_Read() - 48); if (secondNumber >= 0 && secondNumber<= 9) { pinNumber *= 10; pinNumber += secondNumber; // получить вторую цифру, т.е., если вывод 13, то 2-ая цифра равна 3, // и добавить ее к первой цифре } if (pinNumber == OUTPUT1) OUTPUTstate = 0; else if (pinNumber == OUTPUT2) OUTPUTstate = 0; else if (pinNumber == OUTPUT3) OUTPUTstate = 0; digitalWrite(pinNumber, 0); // изменить состояние вывода String response = "Confg="; // Отклик на команду Confg=<номер_вывода>válasz += pinNumber; sendHTTResponse(kapcsolatazonosító, válasz); sendCommand(closeCommand, 1000, DEBUG); // a kapcsolat bezárása ) else if (InStream.equals(TIMER)) ( int pinNumber = (esp8266_Read() - 48); // megkapjuk az első számjegyet, azaz ha a pin 13, akkor az 1. számjegy egyenlő 1 int secondNumber = (esp8266_Read() - 48); if (secondNumber >= 0 && secondNumber<= 9) { pinNumber *= 10; pinNumber += secondNumber; // получить вторую цифру, т.е., если вывод 13, то 2-ая цифра равна 3, // и добавить ее к первой цифре } if (esp8266_Read() == "n") { if (DEBUG == true) Serial.println("on"); if (pinNumber == OUTPUT1) OUTPUTTMRState = 1; else if (pinNumber == OUTPUT2) OUTPUTTMRState = 1; else if (pinNumber == OUTPUT3) OUTPUTTMRState = 1; } else { if (DEBUG == true) Serial.println("off"); if (pinNumber == OUTPUT1) OUTPUTTMRState = 0; else if (pinNumber == OUTPUT2) OUTPUTTMRState = 0; else if (pinNumber == OUTPUT3) OUTPUTTMRState = 0; } int j = 0; byte Atime; // Таймер может настроен на максимальное значение в 1 сутки // поэтому программа может принять 5 цифр, так как 1 сутки равны 86400 секундам long Time; // Прочитать секунды, значение имеет переменное количество цифр, поэтому читать, пока не получим "s", // что является символом завершения в теле моего сообщения от мобильного телефона while (1) { Time = esp8266_Read(); if (Time == "s") break; Atime[j] = Time - 48 ; j++; } switch (j) // секунды... { case 1: // одна цифра Time = Atime; break; case 2: // две цифры Time = Atime * 10 + Atime; break; case 3: // три цифры Time = Atime * 100 + Atime * 10 + Atime; break; case 4: // четыре цифры Time = Atime * 1000 + Atime * 100 + Atime * 10 + Atime; break; case 5: // пять цифр Time = Atime * 10000 + Atime * 1000 + Atime * 100 + Atime * 10 + Atime[j]; break; } if (DEBUG == true) { Serial.println("Timer:"); Serial.println(Time); } Time = Time * 1000 + millis(); if (DEBUG == true) { Serial.println("Pin:"); Serial.println(pinNumber); } if (pinNumber == OUTPUT1) { OUTPUTTMRIsSet = 1; OUTPUTTimer = Time; } else if (pinNumber == OUTPUT2) { OUTPUTTMRIsSet = 1; OUTPUTTimer = Time; } else if (pinNumber == OUTPUT3) { OUTPUTTMRIsSet = 1; OUTPUTTimer = Time; } String response = "tConfg="; // Отклик на команду tConfg=<номер_вывода>válasz += pinNumber; sendHTTResponse(kapcsolatazonosító, válasz); sendCommand(closeCommand, 1000, DEBUG); // kapcsolat bezárása ) else // nem támogatott parancs érkezett ( String response = "ERROR"; sendHTTPResponse(connectionId, response); sendCommand(closeCommand, 1000, DEBUG); // zárja be a kapcsolatot ) ) ) /*** **Ellenőrizze az időzítőt minden kimenethez******/ if (OUTPUTTMRIsSet != 0 && (OUTPUTTimer)< millis())) { digitalWrite(OUTPUT1, OUTPUTTMRState); OUTPUTstate = OUTPUTTMRState; OUTPUTTMRIsSet = 0; } if (OUTPUTTMRIsSet != 0 && (OUTPUTTimer < millis())) { digitalWrite(OUTPUT2, OUTPUTTMRState); OUTPUTstate = OUTPUTTMRState; OUTPUTTMRIsSet = 0; } if (OUTPUTTMRIsSet != 0 && (OUTPUTTimer < millis())) { digitalWrite(OUTPUT3, OUTPUTTMRState); OUTPUTstate = OUTPUTTMRState; OUTPUTTMRIsSet = 0; } /***************************************/ } /* Name: sendData Description: Функция, используемая для отправки данных на ESP8266. Params: command - данные/команда для отправки; timeout - время ожидания отклика; debug - печатать в консоль?(true = да, false = нет) Returns: Отклик от esp8266 (если есть отклик) */ String sendData(String command, const int timeout, boolean debug) { String response = ""; int dataSize = command.length(); char data; command.toCharArray(data, dataSize); esp8266_Write(data, dataSize); // передача символов на esp8266 if (debug) { Serial.println("\r\n====== HTTP Response From Arduino ======"); Serial.write(data, dataSize); Serial.println("\r\n========================================"); } long int time = millis(); while ((time + timeout) >millis()) ( while (esp8266_Available()) ( // az esp-nek vannak adatok, ezért nyomtassa ki a konzolra char c = esp8266_Read(); // olvassa be a következő karaktert. válasz += c; ) ) if (debug) ( Serial .print(response); ) return válasz; ) /* Név: sendHTTPResponse Leírás: HTTP 200, HTML UTF-8 választ küldő függvény */ void sendHTTPResponse(int connectionId, String content) ( // HTTP-válasz létrehozása String httpResponse; String httpHeader; // HTTP fejléc httpHeader = " HTTP/1.1 200 OK\r\nTartalom típusa: szöveg/html; karakterkészlet=UTF-8\r\n"; httpHeader += "Tartalom hossza: "; httpHeader += content.length(); httpFejléc + = " \r\n"; httpHeader += "Kapcsolat: bezárás\r\n\r\n"; httpResponse = httpHeader + tartalom + " "; // Hiba van a kódban: a tartalom utolsó karaktere " nem kerül elküldésre, ezért hozzáadtam egy extra szóközt sendCIPData(connectionId, httpResponse); ) /* Név: sendCIPDATA Leírás: elküldi a CIPSEND= parancsot ,<данные>*/ void sendCIPData(int connectionId, String data) ( String cipSend = "AT+CIPSEND="; cipSend += connectionId; cipSend += ","; cipSend += data.length(); cipSend += "\r\ n"; sendCommand(cipSend, 1000, DEBUG); sendData(data, 1000, DEBUG); ) /* Név: sendCommand Leírás: Az adatok ESP8266-ra való küldésére szolgáló funkció. Paraméterek: parancs - adat/küldési parancs; timeout – válaszvárakozási idő; debug - nyomtatás a konzolra?(true = yes, false = nem) Visszatér: Válasz az esp8266-tól (ha van válasz) */ String sendCommand(String parancs, const int időtúllépés, logikai hibakeresés) ( String response = ""; esp8266_Print(command ); // karakterek átadása az esp8266-nak long int time = millis(); while ((idő + időtúllépés) > millis()) ( while (esp8266_Available())) ( // az esp rendelkezik adatokkal, ezért nyomtassa ki a konzol char c = esp8266_Read(); // beolvassa a következő karaktert. válasz += c; ) ) if (debug) ( Serial.print(response); ) return response; )

Android alkalmazás

A fenti hardverösszetevők vezérléséhez egy egyszerű Android alkalmazást fogunk használni. Ez az alkalmazás lehetővé teszi számunkra, hogy közvetlenül vagy egy bizonyos idő elteltével be- vagy kikapcsoljuk a kimenetet.

Jegyzet: Az alkalmazáshoz Android 4.0 (IceCreamSandwich) vagy újabb verzió szükséges.

  • Először is ismernie kell a modul IP-címét. Ha szoftveres soros portot használt, az IP-cím kinyomtatásra kerül a konzolon. Ha hardveres soros portot használt, akkor az IP-cím megtekintéséhez kábel segítségével kell figyelnie az RX és TX vonalak adatait. Ismernie kell az Arduino-vázlatban megadott portszámot is. Ezután kattintson a "csatlakozás" gombra, hogy megkapja mindhárom kimenet állapotát. Győződjön meg arról, hogy a Wi-Fi útválasztó be van kapcsolva, és csatlakozik a helyi hálózathoz.
  • Most kattintson bármelyik kapcsolóra, amelyet be/ki szeretne kapcsolni. Amikor csak akarja, kattintson a "frissítés" gombra az összes kimenet állapotának frissítéséhez.
  • Az "Időzítők" fülön beállíthatja a három kimenet bármelyikét, hogy egy bizonyos idő elteltével (0 és 24 óra között) be/ki kapcsoljon.
  • Bármely művelet után megerősítő üzenetet kap, amely jelzi, hogy a parancs sikeresen befejeződött-e, vagy valamilyen hiba történt.

Demo videó

Ez minden! Remélem hasznos volt a cikk. Hagyj megjegyzéseket!