Arduino na may esp8266

Ang ESP8266-01 ay naging isang mahusay na module upang mapatay ang lahat ng aming uhaw para sa mga proyekto ng IOT. Mula nang mailabas ito, bumuo ito ng isang malakas na pamayanan at umunlad sa isang madaling gamitin, mura at makapangyarihang Wi-Fi module. Ang isa pang open-source platform na mas sikat ay ang Arduino, mayroon na itong tone-toneladang mga proyekto na itinayo sa paligid nito. Ang pagsasama-sama sa dalawang platform na ito ay magbubukas ng mga pintuan para sa maraming mga makabagong proyekto, kaya sa tutorial na ito matututunan namin kung paano i-interface ang module na ESP8266-01 sa Arduino. Sa ganitong paraan makakapagpadala o makakatanggap kami ng data sa pagitan ng Arduino at Internet.

Para sa layunin ng tutorial na ito ay babasahin namin ang oras, petsa, temperatura at halumigmig mula sa internet gamit ang isang API na may ESP8266-01. Pagkatapos ay ipadala ang mga halagang ito sa isang Arduino board at ipakita ang mga ito sa 16 * 2 LCD screen. Parang cool diba !! Kaya't magsimula tayo.

Mga Materyal na Kinakailangan:

Lupon ng Arduino (Anumang bersyon)
ESP8266-01
FTDI programmer board na may pagpipiliang 3.3V
16x2 LCD
Potensyomiter
Push button
Mga kumokonekta na mga wire
Breadboard

Paano gumagana ang mga bagay?

Bago tayo sumisid, mahalagang malaman kung paano talaga gagana ang bagay na ito. Talaga, kailangan nating magsimula sa module na ESP8266-01. Gagamitin namin ang Arduino IDE upang iprograma ang ESP8266 at isusulat ang code upang magamit ang isang API upang mabasa ang isang JSON file sa pamamagitan ng kahilingan sa http. Pagkatapos ay bibigyan namin parirala ang file na JSON na ito upang makuha lamang ang kinakailangang impormasyon mula sa kumpletong JSON file.

Kapag ang impormasyon ay nasusulat ay mai-print namin ito gamit ang serial na komunikasyon. Ang mga serial line na ito ay konektado sa Arduino, upang mabasa ng Arduino ang impormasyong ipinadala mula sa ESP8266. Kapag nabasa at naproseso na ang impormasyon ipapakita namin ito sa LCD screen.

Okay lang, kung hindi mo pa lubos na naintindihan ito, sapagkat pareho din kaming matututunan sa natitirang tutorial na ito.

Pagprogram ng ESP8266-01:

Ipinapalagay ng tutorial na ito na mayroon kang ilang karanasan sa module na ESP8266. Kung hindi pagkatapos, inirerekumenda na basahin ang sumusunod na tatlong mga tutorial upang maunawaan ito.

Pagsisimula sa ESP8266-01
Pagprogram ng ESP8266-01 gamit ang mga utos ng AT
Programming ang ESP8266-01 gamit ang Arduino IDE at Flashing memory nito

Maaari mo ring suriin ang aming lahat ng mga proyekto sa ESP8266 dito.

Narito puprogram namin ang module na ESP8266-01 gamit ang Arduino IDE. Para sa hardware ginagamit namin ang board ng FTDI na may 3.3V sa programa ng ESP8266, dahil gagawin nitong simple ang hardware. Ang circuit diagram para sa pagkonekta ng iyong ESP8266 sa board ng FTDI ay ipinapakita sa ibaba.

Tiyaking natutugunan ang mga sumusunod na kundisyon

1. Ang ESP8266-01 ay 3.3V lang ang mapagparaya, huwag gumamit ng 5V. Kaya itakda lamang ang FTDI sa 3.3V mode.

2. Ang GPIO_0 ay dapat na saligan para sa mode ng pagprograma

3. Ang pag-reset ng pin ay dapat na konektado sa pamamagitan ng isang pindutan sa ground pin. Ang pindutang ito ay dapat na pinindot bago i-upload ang code. Sa bawat oras na ang pindutan ay pinindot ang asul na LED sa module ng ESP8266-01 ay magiging mataas upang ipahiwatig na ang module ay na-reset.

Kapag natapos na ang mga koneksyon buksan ang Arduino IDE at suriin kung nagawa mong mag-upload ng isang sample na programa ng matagumpay. Kung hindi ka sigurado kung paano gamitin ang Arduino IDE upang mag-upload ng programa sa ESP8266 pagkatapos sundin ang Programming ESP8266 kasama ang Arduino upang malaman ito. Sa puntong ito ipinapalagay ko na matagumpay mong na-upload ang blink program.

. Ang kumpletong programa ay ibinibigay sa dulo ng pahinang ito nang higit pa sa ibaba ipinapaliwanag ko ang mga ito bilang maliit na mga snippet. Kinakailangan din ng programa ang aklatan ng Arduino JSON na mag-ipon, kaya kung hindi mo naidagdag ang library sa iyong Arduino IDE, pagkatapos ay idagdag ito sa pamamagitan ng pag-download mula sa Arduino JSON library mula sa Github.

Ang ESP8266 ay kailangang kumonekta sa internet upang makuha ang data tungkol sa petsa, oras, temperatura at halumigmig. Kaya kailangan mong payagan itong kumonekta sa iyong Wi-Fi sa pamamagitan ng pagpapatunay ng SSID at Password sa mga linya sa ibaba

const char * ssid = "JIO-Fi"; // Ipasok ang iyong Wi-Fi SSID const char * password = "Pas123"; // Enter you Wi-Fi Password

Sa loob ng pag- andar ng pag- setup () sinusuri namin kung ang ESP ay makakakonekta sa Wi-Fi, kung hindi maghihintay ito doon magpakailanman sa pamamagitan lamang ng pag-print ng "Kumokonekta.." sa serial monitor.

habang (WiFi.status ()! = WL_CONNected) {// Maghintay hanggang ang Wi-Fi ay konektado pagkaantala (1000); Serial.print ("Kumokonekta.."); // Print Connecting.. hanggang sa maitaguyod ang koneksyon }

Ang susunod na hakbang ay ang napakahalagang hakbang. Kung matagumpay ang koneksyon sa Wi-Fi kailangan naming humiling ng isang kahilingan sa pagkuha ng http na basahin ang JSON file mula sa internet. Sa tutorial na ito ginagamit ko ang API na ibinigay ng wunderground.com. Kaya't kung nagpaplano kang gumamit ng pareho maaari kang makakuha sa link at pag-signup para sa libreng API key o gumamit ng anumang API na iyong pinili. Kapag natapos mo na ang iyong API magtatapos ka sa isang link na tulad nito sa ibaba

Tandaan: Binago ko ang API key ng link na ito upang hindi ito gumana. Panatilihing naka-secure ang iyong API key at huwag magbahagi.

Ginagamit ang aking API dito upang makuha ang data ng panahon ng Chennai. Maaari kang gumamit ng anumang API. Ngunit kapag na-load mo ang API sa anumang browser dapat itong bumalik ng isang JSON file. Halimbawa binabalik ng aking API ang sumusunod na JSON file

Maaaring ibalik ng iyo ng isang file ang iba't ibang data. Maaari naming suriin kung ang file na JSON na ito ay natanggap din ng aming ESP8266 sa pamamagitan ng pagbabasa nito at pag- print ng JSON sa aming serial monitor gamit ang mga sumusunod na linya

int httpCode = http.GET (); // pass a get request if (httpCode> 0) {// Suriin ang nagbabalik na code // payload = http.getString (); // Itago ang halaga sa varibale Payload para sa pag-debug // Serial.println (payload); // I-print ang payload para sa pag-debug kung hindi man magkomento sa parehong mga linya

Kinomento ko ang mga linyang ito, dahil kinakailangan lamang ito para sa pagsubok. Kapag natiyak mo na ang ESP8266 ay makakakuha ng data ng JSON oras na para sa pagbigkas ng data sa Data. Tulad ng nakikita mo ang data na ito ay malaki at karamihan sa mga halaga ay walang silbi maliban sa mga kinakailangan para sa amin tulad ng petsa, oras, temperatura at halumigmig.

Kaya ginagamit namin ang JSON Arduino library upang paghiwalayin ang mga halagang kinakailangan para sa amin at iimbak ito sa isang variable. Posible ito dahil ang mga halaga sa JSON file ay itinalaga bilang mga pares ng halaga ng pangalan. Kaya't ang pangalang ito ay isang string na hahawak sa halagang kinakailangan para sa amin.

Upang magawa ito kailangan nating lumipat sa isang website na susuriin ang JSON file at bibigyan kami ng Arduino code. Oo ganun kadali iyon. Magpatuloy sa https://arduinojson.org/assistant/ at i-paste ang file na JSON na na-load namin sa aming browser at pindutin ang enter. Kapag tapos na ang minahan ay tumingin ng tulad nito sa ibaba

Mag-scroll pababa nang kaunti upang makita ang programa ng pagbuyser na awtomatikong nilikha

Ang kailangan mo lang gawin ay piliin ang variable na gusto mo, kopyahin ang mga ito at i-paste ito sa iyong Arduino IDE, tulad ng nagawa ko rito

/ * Phrasing Data gamit ang JSON librarey * / // Gumamit ng https://arduinojson.org/assistant/ upang makuha ang mga halagang binibigkas para sa iyong JSON string const size_t bufferSize = JSON_OBJECT_SIZE (0) + JSON_OBJECT_SIZE (1) + JSON_OBJECT_SIZE (2) + 2 * JSON_OBJECT_SIZE (3) + JSON_OBJECT_SIZE (8) + JSON_OBJECT_SIZE (12) + JSON_OBJECT_SIZE (56) + 2160; DynamicJsonBuffer jsonBuffer (bufferSize); JsonObject & root = jsonBuffer.parseObject (http.getString ()); / * Wakas ng Data ng Phrasing * / // Ipakita ang halaga ng kasalanan sa nais na mga variable na JsonObject & current_observation = root; // under current_observation JsonObject & current_observation_observation_location = kasalukuyang_observation; // under observ_location const char * current_observation_station_id = current_observation; // "ICHENNAI1" // kunin ang mga detial ng lokasyon const char * current_observation_local_time_rfc822 = kasalukuyang_observation; // Local time // get the local time const char * current_observation_temperature_string = current_observation; // "90.7 F (32.6 C)" // get the temperatura value const char * current_observation_relative_humidity = current_observation; // "73%" // makuha ang halagang halumigmig

Kopyahin ko lang ang mga variable na kasalukuyang_observation_station_id, kasalukuyang_observation_local_time_rfc822, kasalukuyang_observation_temperature_string at kasalukuyang_observation_relative_humidity . Dahil pinaplano naming ipakita lamang ang apat na data sa aming LCD screen.

Sa wakas, nakuha namin ang data na kailangan namin mula sa internet at nai-save ito bilang isang variable na maaari naming komportable na magamit. Upang maipadala ang data na ito sa Arduino mayroon lamang kaming isulat sa kanila nang serial kahit na ang Serial monitor. Ang mga sumusunod na linya ay eksaktong eksaktong gagawin

// I-print ang mga variable sa pamamagitan ng serial monitor Serial.print (current_observation_station_id); // ipadala ang mga detalye ng lokasyon sa pagkaantala ng Arduino (100); // antala ng katatagan Serial.print (current_observation_local_time_rfc822); // ipadala ang mga detalye ng lokal na oras sa pagkaantala ng Arduino (100); // antala ng katatagan Serial.print (current_observation_temperature_string); // ipadala ang mga detalye ng temperatura sa pagkaantala ng Arduino (100); // antala ng katatagan Serial.print (current_observation_relative_humidity); // ipadala ang mga detalye ng kahalumigmigan sa pagkaantala ng Arduino (100); // pagkaantala ng katatagan

Tandaan na ginamit ko ang Serial.print () at hindi Serial.println () dahil ang utos na Serial.println () ay idugtong ang isang / n at / r kasama ang data na hindi kinakailangan para sa amin. Nagdagdag din kami ng pagkaantala ng 10 segundo upang ang ESP ay magpapadala lamang ng mga halagang ito sa isang agwat ng 10 segundo sa Arduino.

Pagkonekta sa ESP8266-01 kay Arduino:

Sa ngayon ay nai-program namin ang aming ESP8266-01 upang mabasa ang kinakailangang data mula sa internet sa pagitan ng 10 segundo at ipadala ito nang serial. Ngayon kailangan naming i- interface ang ESP sa Arduino upang mabasa namin ang serial data na ito. Kailangan din naming magdagdag ng isang 16 * 2 LCD display sa Arduino upang maipakita namin ang natanggap na data mula sa module na ESP8266. Ang circuit diagram upang i-interface ang module ng ESP8266 na may Arduino ay ipinapakita sa ibaba

Siguraduhin na ang GPIO_0 pin ay naiwan nang libre, paganahin ang module lamang gamit ang 3.3V pin ng Arduino at pindutin ang push button upang ilagay ang module ng ESP sa operating module. Ngayon ang program na na-upload namin sa ESP ay dapat na nagsimulang magtrabaho at ang module ay dapat na ipadala ang data sa pamamagitan ng serial pin sa Arduino. Ang mga serial pin na ito ay konektado sa pin number 6 at 7 sa Arduino. Kaya maaari naming gamitin ang software serial options sa Arduino upang mabasa ang serial data na ito mula sa mga pin.

Programa ng Arduino at Paggawa:

Ang kumpletong programa ng Arduino ay ibinibigay din kasama ang code ng ESP sa dulo ng pahinang ito. Maaari kang mag-scroll pababa upang matingnan ang programa o magbasa pa kung nais mong maunawaan ang programa.

Ang interfacing program ay medyo simple, kailangan lang naming gamitin ang software serial library upang mabasa ang data mula sa pin 6 at 7 at ipakita ang mga ito sa LCD screen. Dahil ang natanggap na data ay nasa format ng string kailangan naming gamitin ang pagpipiliang substring upang masira ang kargamento sa aming kinakailangan o kahit mai-convert ito sa integer kung kinakailangan. Kaya't nagsisimula kami sa pamamagitan ng pagtukoy sa mga pin kung saan nakakonekta ang LCD.

Const int rs = 8, en = 9, d4 = 10, d5 = 11, d6 = 12, d7 = 13; // Pins kung saan ang LCD ay konektado sa LiquidCrystal lcd (rs, en, d4, d5, d6, d7);

Dahil nakakonekta namin ang mga Rx at Tx na pin ng ESP8266 sa 6 at 7 ^th pin ng Arduino kailangan naming simulan ang serial ng Software para sa mga pin na iyon upang matanggap namin ang serial data mula sa kanila. Mayroon akong mga pangalan na ito bilang ESP_Serial, maaari mo pangalanan ang mga ito anumang nais mo

SoftwareSerial ESP_Serial (6,7); // Tx, Rx

Sa loob ng pag- andar ng pag- setup () sinisimulan namin ang serial na komunikasyon para sa Serial monitor at para din sa serial ng software. Kung maaari mong alalahanin na ginawa namin ang programa ng ESP upang makipag-usap sa 9600 baud rate kaya't gagamitin namin ang parehong rate ng baud para sa serial software ng software. Nagpapakita rin kami ng isang maliit na mensahe ng intro sa LCD sa loob ng 2 segundo.

void setup () {lcd.begin (16, 2); // Gumagamit kami ng isang 16 * 2 LCD display lcd.print ("Arduino & ESP"); // Ipakita ang isang intro na mensahe Serial.begin (115200); ESP_Serial.begin (9600); pagkaantala (2000); lcd.clear (); }

Sa loob ng pangunahing pag- andar ng loop () kailangan nating suriin kung ang ESP8266 ay nagpapadala ng anumang bagay. Kung ito ay, binabasa namin ang string mula sa ESP8266 at i-save ito sa isang variable na tinatawag na payload. Ang variable na payload ay uri ng String at hahawak nito ang kumpletong ipinadala na impormasyon na module ng module na ESP8266.

habang (ESP_Serial.available ()> 0) {payload = ESP_Serial.readString ();

Ngayon kailangan nating hatiin ang string na ito sa maliliit na tipak upang magamit natin ang mga ito para sa aming sariling layunin, sa kasong ito kailangan nating hatiin ang mga ito upang maipakita ang mga ito sa LCD screen. Madali itong magagawa sa pamamagitan ng paggamit ng pag- andar ng substring sa Arduino. Kailangan mong malaman ang posisyon ng bawat character upang magamit ang pag- andar ng substring na ito. Maaari mong i-print ang payload sa serial monitor upang malaman ang posisyon ng mga character at gamitin ang mga ito upang ikategorya ang mga substrings tulad ng ipinakita sa ibaba.

local_date = payload.substring (14, 20); local_time = payload.substring (26, 31); temperatura = payload.substring (48, 54); Humidity = payload.substring (55, 60);

Ngayon ay maaari akong magpatuloy at gamitin ang mga variable na ito upang mai -print ang mga ito sa serial monitor o i-print lamang ang mga ito sa LCD. Gayunpaman ang pag-print sa kanila sa Serial monitor ay makakatulong sa amin o suriin kung ang mga substrings ay nahati nang tama. Susunod ay nai-print lamang namin ang mga ito sa LCD display gamit ang mga sumusunod na linya

lcd.clear (); lcd.setCursor (1, 0); lcd.print (local_date); lcd.setCursor (8, 0); lcd.print (local_time); lcd.setCursor (1, 1); lcd.print (temperatura); lcd.setCursor (10, 1); lcd.print (Humidity);

I-upload ang programa sa Arduino, at tiyakin na ang mga koneksyon ay tulad ng ipinakita sa itaas na diagram ng circuit. Ayusin ang kaibahan ng LCD display hanggang sa makita mo nang malinaw ang mga bagay. Dapat mong makita ang mensahe ng Intro sa LCD at pagkatapos pagkatapos ng ilang segundo ang mga detalye tulad ng petsa, oras, temperatura at Humidity ay dapat ipakita sa LCD screen tulad ng ipinakita sa ibaba.

Maaari mo ring mapansin ang asul na humantong sa pagpikit ng ESP8266 sa tuwing papasok ang Data. Kung hindi mo ito nakikita nangangahulugan ito na ang ESP ay wala sa mode ng pagprogramo subukang pindutin ang I-reset ang pindutan suriin din ang mga koneksyon.

Katulad nito maaari mong gamitin ang anumang API upang makakuha ng anumang kinakailangang data mula sa internet at pakainin ito sa Arduino at iproseso ang iyong trabaho sa Arduino. Mayroong tone-toneladang API na magagamit sa internet at sa lahat ng mga maaari kang makagawa ng isang walang limitasyong bilang ng mga proyekto. Inaasahan kong naintindihan mo ang proyekto at nasiyahan sa pagbuo nito. Kung naharap mo ang anumang problema, i-post ang mga ito sa seksyon ng komento sa ibaba o sa aming mga forum.

Mahahanap mo rito ang aming lahat ng mga kaugnay na proyekto ng ESP8266.