Paano Gumamit ng MQTT Gamit ang Raspberry Pi at ESP8266: 8 Mga Hakbang (na may Mga Larawan)

2024 May -akda: John Day | [email protected]. Huling binago: 2024-01-30 13:13

Sa Instructable na ito, ipapaliwanag ko kung ano ang MQTT protocol at kung paano ito ginagamit upang makipag-usap sa pagitan ng mga aparato. Pagkatapos, bilang isang praktikal na pagpapakita, ipapakita ko sa iyo kung paano mag-set up ng isang simpleng dalawang system ng kliyente, kung saan ang isang module ng ESP8266 ay magpapadala ng isang mensahe sa isang programa ng Python kapag ang isang pindutan ay naitulak. Partikular, gumagamit ako ng isang module ng Adafruit HUZZAH para sa proyektong ito, isang Raspberry Pi at isang desktop computer. Ang Raspberry Pi ay kumikilos bilang MQTT broker, at ang client ng Python ay tatakbo mula sa isang hiwalay na desktop computer (opsyonal, dahil maaari itong patakbuhin sa Raspberry Pi).

Upang sundin kasama ang Instructable na ito, kakailanganin mong magkaroon ng ilang pangunahing kaalaman sa electronics, at kung paano gamitin ang Arduino software. Dapat ay pamilyar ka rin sa paggamit ng isang interface ng command line (para sa Raspberry Pi). Inaasahan kong, kapag nakuha mo ang kaalaman tungkol sa kung ano ang MQTT, at kung paano ito gamitin sa isang pangunahing senaryo, makakalikha ka ng iyong sariling mga proyekto ng IoT!

Mga Kinakailangan na Bahagi

• 1 x Raspberry Pi, konektado sa isang lokal na network (tumatakbo si Jessie)
• 1 x ESP8266 Modyul (Adafruit HUZZAH)
• 1 x Breadboard
• 3 x Jumper Wires (Lalaki-sa-Lalaki)
• 1 x Pushbutton
• 1 x 10k Ohm Resistor (Brown-Black-Orange color code)

Nilikha ko ang Ituturo na ito, tulad ng palaging interesado sa akin ang MQTT bilang isang protokol at maraming iba't ibang mga paraan na magagamit ito. Gayunpaman, tila hindi ko mawari kung paano mag-code ng mga aparato upang magamit ito. Ito ay dahil hindi ko alam / naintindihan kung ano talaga ang nangyayari sa aking "Hello, World!" mula sa aparato A at ipadala ito sa aparato B. Samakatuwid, nagpasya akong isulat ang Ituturo na ito upang (sana) turuan ka kung paano ito gumagana, at upang patibayin ang aking sariling pag-unawa dito!

Hakbang 1: Ano ang MQTT?

Ang MQTT, o MQ Telemetry Transport, ay isang messaging protocol na nagpapahintulot sa maraming mga aparato na makipag-usap sa bawat isa. Sa kasalukuyan, ito ay isang tanyag na protokol para sa Internet of Things, kahit na ginamit ito para sa iba pang mga layunin - halimbawa, Facebook Messenger. Kagiliw-giliw na MQTT ay naimbento noong 1999 - nangangahulugang kasing edad ko ito!

Ang MQTT ay batay sa ideya na maaaring mag-publish o mag-subscribe ang mga aparato sa mga paksa. Kaya, halimbawa. Kung naitala ng Device # 1 ang temperatura mula sa isa sa mga sensor nito, maaari itong mai-publish ang isang mensahe na naglalaman ng halagang naitala ng temperatura, sa isang paksa (hal. "Temperatura"). Ang mensaheng ito ay ipinadala sa isang MQTT Broker, na maaari mong isipin bilang isang switch / router sa isang lokal na network ng lugar. Kapag natanggap ng MQTT Broker ang mensahe, ipapadala ito sa anumang mga aparato (sa kasong ito, Device # 2) na naka-subscribe sa parehong paksa.

Sa proyektong ito, maglalathala kami sa isang paksa gamit ang isang ESP8266, at lumilikha ng isang script ng Python na mag-subscribe sa parehong paksang ito, sa pamamagitan ng isang Raspberry Pi na kikilos bilang MQTT Broker. Ang dakilang bagay tungkol sa MQTT ay ito ay magaan, kaya perpekto ito para sa pagtakbo sa mga maliliit na microcontroller tulad ng isang ESP8266, ngunit malawak din itong magagamit - upang mapapatakbo din namin ito sa isang script ng Python.

Sana, sa pagtatapos ng proyektong ito, magkakaroon ka ng pag-unawa sa kung ano ang MQTT at kung paano ito gamitin para sa iyong sariling mga proyekto sa hinaharap.

Hakbang 2: Pag-install ng MQTT Broker sa Raspberry Pi

Upang mai-set up ang aming MQTT system, kailangan namin ng isang broker, tulad ng ipinaliwanag sa nakaraang hakbang. Para sa Raspberry Pi, gagamitin namin ang "Mosquitto" MQTT broker. Bago namin ito mai-install, palaging pinakamahusay na i-update ang aming Raspberry Pi.

sudo apt-get update

sudo apt-get upgrade

Kapag nagawa mo na ito, mag-install ng mosquitto at pagkatapos ay ang mga package ng mosquitto-kliyente.

sudo apt-get install mosquitto -y

sudo apt-get install mosquitto-kliyente -y

Kapag natapos mo na ang pag-install ng dalawang pakete na ito, kakailanganin naming i-configure ang broker. Ang file ng pagsasaayos ng mosquitto broker ay matatagpuan sa /etc/mosquitto/mosquitto.conf, kaya buksan ito sa iyong paboritong text editor. Kung wala kang isang paboritong text editor o hindi alam kung paano gamitin ang alinman sa mga editor ng linya ng utos, gagamit ako ng nano upang masundan mo ang sumusunod:

sudo nano /etc/mosquitto/mosquitto.conf

Sa ilalim ng file na ito, dapat mong makita ang linya:

isama ang_dir /etc/mosquitto/conf.d

Tanggalin ang linyang ito. Idagdag ang mga sumusunod na linya sa ilalim ng file.

allow_anonymous false

password_file / etc / mosquitto / pwfile listener 1883

Sa pamamagitan ng pagta-type ng mga linyang iyon, sinabi namin sa mosquitto na hindi namin nais ang sinumang kumokonekta sa aming broker na hindi nagbibigay ng isang wastong username at password (sasakay kami upang maitakda ang mga ito sa isang segundo) at nais naming makinig ng mga mensahe sa port number 1883.

Kung hindi mo nais na mangangailangan ang broker ng isang username at password, huwag isama ang unang dalawang linya na idinagdag namin (hal. Allow_anonymous … at password_file…). Kung nagawa mo ito, pagkatapos ay laktawan upang muling i-reboot ang Raspberry Pi.

Isara ngayon (at i-save) ang file na iyon. Kung sumusunod ka kasama ang halimbawa ng nano, pindutin ang CTRL + X, at i-type ang Y kapag sinenyasan.

Dahil sinabi lamang namin sa mosquitto na ang mga gumagamit na sumusubok na gamitin ang MQTT broker ay kailangang ma-authenticate, kailangan namin ngayon sabihin sa mosquitto kung ano ang username at password! Kaya, i-type ang sumusunod na utos - pinapalitan ang username ng username na gusto mo - pagkatapos ay ipasok ang password na nais mo kapag na-prompt (Tandaan: kung, sa pag-edit ng file ng pagsasaayos, tinukoy mo ang ibang landas ng password_file, palitan ang landas sa ibaba ng isa na ginamit mo).

sudo mosquitto_passwd -c / etc / mosquitto / pwfile username

Tulad ng binago lamang namin ang file ng pagsasaayos ng mosquitto, dapat naming i-reboot ang Raspberry Pi.

sudo reboot

Kapag natapos na ng pag-reboot ang Raspberry Pi, dapat ay mayroon kang isang ganap na gumaganang MQTT broker! Susunod, susubukan naming makipag-ugnay dito, gamit ang isang bilang ng iba't ibang mga aparato / pamamaraan!

Hakbang 3: Pagsubok sa Broker

Kapag na-install mo na ang mosquitto sa Raspberry Pi, maaari mo itong bigyan ng isang mabilis na pagsubok - upang matiyak na ang lahat ay gumagana nang tama. Para sa hangaring ito, mayroong dalawang mga utos na maaari naming magamit sa linya ng utos. mosquitto_pub at mosquitto_sub. Sa hakbang na ito, gagabayan ka namin sa pamamagitan ng paggamit ng bawat isa sa mga ito upang subukan ang aming broker.

Upang masubukan ang broker, kakailanganin mong buksan ang dalawang mga window ng command line. Kung gumagamit ka ng Putty o ibang SSH client, ito ay kasing simple ng pagbubukas ng isa pang window ng SSH at pag-log in tulad ng dati. Kung ina-access mo ang iyong Pi mula sa isang UNIX terminal, eksaktong pareho ito. Kung gumagamit ka ng Raspberry Pi nang direkta, kakailanganin mong buksan ang dalawang mga window ng terminal sa GUI mode (gagamitin ang command startxcan upang simulan ang GUI).

Ngayong binuksan mo ang dalawang bintana, maaari na kaming magsimula sa pagsubok. Sa isa sa dalawang mga terminal, i-type ang sumusunod na utos, palitan ang username at password ng mga na-set up mo sa nakaraang hakbang.

mosquitto_sub -d -u username -P password -t test

Kung nagpasya kang hindi magtakda ng isang username at password sa nakaraang hakbang, pagkatapos mula ngayon, huwag pansinin ang mga flag na -u at -P sa mga utos. Kaya, bilang isang halimbawa, ang utos ng mosquitto_sub ay magiging:

mosquitto_sub -d -t test

Mag-subscribe ang utos ng mosquitto_sub sa isang paksa, at ipapakita ang anumang mga mensahe na ipinadala sa tinukoy na paksa sa window ng terminal. Dito, -d nangangahulugang debug mode, kaya't ang lahat ng mga mensahe at aktibidad ay magiging output sa screen. -u at -P ay dapat na nagpapaliwanag sa sarili. Panghuli, -t ang pangalan ng paksang nais naming mag-subscribe - sa kasong ito, "pagsubok".

Susunod, sa kabilang window ng terminal, susubukan naming mai-publish ang isang mensahe sa paksang "pagsubok". I-type ang sumusunod, na naaalala muli upang baguhin ang username at password:

mosquitto_pub -d -u username -P password -t test -m "Hello, World!"

Kapag pinindot mo ang pagpasok, dapat mong makita ang iyong mensahe na "Kamusta, Mundo!" lumitaw sa unang window ng terminal na ginamit namin (upang mag-subscribe). Kung ito ang kaso, handa ka na upang magsimulang magtrabaho sa ESP8266!

Hakbang 4: Pag-set up ng ESP8266 (Adafruit HUZZAH)

Ang hakbang na ito kung tiyak sa Adafruit HUZZAH (dahil iyon ang ginagamit ko upang makumpleto ang proyektong ito). Kung gumagamit ka ng ibang Arduino / ESP8266 aparato, maaari mong laktawan ang hakbang na ito. Gayunpaman, payuhan ko kayo na basahin ito, kung sakaling may anumang impormasyon dito na maaaring nauugnay sa iyo.

Para sa proyektong ito, ipaprograma ko ang HUZZAH gamit ang Arduino software. Kaya, kung hindi mo pa nagagawa, tiyaking i-install ang Arduino software (mas bago sa 1.6.4). Maaari mo itong i-download dito.

Kapag na-install mo na ang Arduino software, buksan ito at mag-navigate sa File-> Mga Kagustuhan. Narito dapat mong makita (malapit sa ilalim ng window) isang text box na may label na: "Mga Karagdagang Mga URL ng Manager ng Boards". Sa text box na ito, kopyahin at i-paste ang sumusunod na link:

arduino.esp8266.com/stable/package_esp8266com_index.json

Mag-click sa OK upang mai-save ang iyong mga pagbabago. Ngayon buksan ang Board Manager (Tools-> Board-> Board Manager) at hanapin ang ESP8266. I-install ang esp8266 ng pakete ng Komunidad ng ESP8266. I-restart ang Arduino software.

Ngayon, bago namin mai-program ang board, kailangan naming pumili ng ilang iba't ibang mga pagpipilian. Sa pagpipilian ng menu ng Mga tool, piliin ang Adafruit HUZZAH ESP8266 para sa Lupon, 80 MHz para sa Frequency ng CPU (maaari mong gamitin ang 160 MHz kung nais mong i-overclock ito, ngunit sa ngayon gagamitin ko ang 80 MHz), 4M (3M SPIFFS) para sa Laki ng Flash, at 115200 para sa Bilis ng Pag-upload. Gayundin, tiyaking piliin ang COM port na iyong ginagamit (depende ito sa iyong pag-set up).

Bago ka makapag-upload ng anumang code, kailangan mong tiyakin na ang HUZZAH ay nasa bootloader mode. Upang paganahin ito, pindutin nang matagal ang pindutan sa pisara na may markang GPIO0, at habang hawak ito, pindutin din ang pindutang I-reset. Pagkatapos, pakawalan ang pindutang I-reset, at pagkatapos ang GPIO0. Kung nagawa mo ito nang tama, ang pulang LED na dumating noong pinindot mo ang GPIO0 ay dapat na ngayong malabo.

Upang mag-upload ng code sa microcontroller, siguraduhin muna na ang HUZZAH ay nasa bootloader mode, pagkatapos ay i-click lamang ang upload button sa Arduino IDE.

Kung nagkakaproblema ka sa pag-set up ng HUZZAH, ang karagdagang impormasyon ay matatagpuan sa sariling tutorial ng Adafruit.

Hakbang 5: Pagprogram ng ESP8266

Magsisimula na kaming mag-program ng ESP8266, ngunit bago kami magsimula, kakailanganin mong i-install ang mga sumusunod na aklatan sa manager ng Arduino Library (Sketch-> Isama ang Mga Aklatan-> Pamahalaan ang Mga Aklatan)

• Bounce2
• PubSubClient

Kapag na-install mo na ang mga aklatan na iyon, magagawa mong patakbuhin ang code na isinama ko sa Instructable na ito (MQTT_Publish.zip). Tinitiyak kong i-puna ito upang maunawaan mo kung ano ang ginagawa ng bawat seksyon, at inaasahan nitong paganahin kang iakma ito sa iyong mga pangangailangan.

Tandaan na baguhin ang mga pare-pareho sa tuktok ng code upang ang iyong ESP8266 ay maaaring kumonekta sa iyong WiFi network at sa iyong MQTT Broker (ang Raspberry Pi).

Kung nagpasya kang hindi magtakda ng isang username at password para sa MQTT Broker, sa halip i-download ang MQTT_PublishNoPassword.zip file sa halip.

Hakbang 6: Pag-install ng Python Client (paho-mqtt)

Sa kabutihang palad, ang hakbang na ito ay napaka-simple! Upang mai-install ang mosquitto python client, kailangan mo lamang i-type ang sumusunod sa linya ng utos (Linux / Mac) o kahit na command prompt (Windows).

pip install paho-mqtt

Tandaan: Ang prompt ng utos ng Windows ay maaaring magkaroon ng isang isyu sa pagpapatakbo ng pip command kung hindi mo tinukoy na nais mong mai-install ang pip at idinagdag ang sawa sa iyong variable na PATH noong na-install mo ang Python. Mayroong isang bilang ng mga paraan ng pag-aayos nito, ngunit sa palagay ko ang muling pag-install muli ng Python ay ang pinakamadaling paraan. Kung may pag-aalinlangan - bigyan ito ng google!

Hakbang 7: Python Client - Nag-subscribe

Sa hakbang na ito, i-set up namin ang script ng Python (alinman sa Raspberry Pi mismo o sa isa pang computer na konektado sa network) upang hawakan ang lahat ng mga mensahe na ipinadala (nai-publish) ng ESP8266 sa paksa ng MQTT.

Isinama ko ang code ng sawa sa ibaba (PythonMQTT_Subscribe.py), na kung saan ay nagkomento upang matulungan kang maunawaan kung ano ang nangyayari, ngunit ipapaliwanag ko rin ang ilan sa mga pangunahing tampok.

Kung hindi ka nagtakda ng isang username at password para sa koneksyon ng MQTT nang mas maaga, i-download ang PythonMQTT_SubscribeNoPassword.py file sa halip.

Hakbang 8: Pakikipag-usap sa Pagitan ng Mga Device ng ESP8266

Kung nais mong mag-set up ng isang IoT network, halimbawa, maaaring gusto mong makipag-usap sa pagitan ng mga aparato ng ESP8266. Sa kabutihang palad, hindi ito mas kumplikado kaysa sa code na isinulat namin dati, gayunpaman, mayroong isang pares ng mga kilalang pagbabago.

Para sa isang ESP na magpadala ng data sa isa pa, ang unang ESP ay kakailanganing mag-publish sa paksa, at ang pangalawang ESP ay kailangang mag-subscribe sa paksang iyon. Papayagan ng pag-set up na ito para sa isang one-way na pag-uusap - ESP (1) hanggang sa ESP (2). Kung nais namin na makipag-usap ang ESP (2) sa ESP (1), makakalikha kami ng isang bagong paksa, kung saan i-publish ang ESP (2), at ang ESP (1) ay mag-subscribe. Sa kabutihang palad, maaari kaming magkaroon ng maraming mga subscriber sa parehong paksa, kaya kung nais mong magpadala ng data sa isang bilang ng mga system, kakailanganin mo lamang ang isang paksa (kung saan lahat sila ay nag-subscribe, maliban sa aparato kung saan nagpapadala ng data, tulad nito ay naglalathala).

Kung kailangan mo ng tulong sa pag-alam kung ano ang kailangang gawin ng bawat aparato, isipin ang tungkol sa system bilang isang silid ng mga tao. Kung ang ESP (1) ay naglalathala, maaari mong isipin ang aparatong ito bilang isang "speaker", at ang anumang mga aparato na nag-subscribe sa paksa ay "mga tagapakinig" sa halimbawang ito.

Nagsama ako ng ilang halimbawa ng code sa ibaba, na nagpapakita kung paano maaaring mag-subscribe ang isang ESP8266 sa isang paksa, at makinig para sa ilang mga mensahe - 1 at 0. Kung natanggap ang 1, ang on-board LED (para sa HUZZAH - GPIO 0) ay nakabukas. Kung natanggap ang 0, ang LED na ito ay papatayin.

Kung nais mong iproseso ang mas kumplikadong data, dapat itong gawin sa pagpapa-function na NatanggapMessage (tingnan ang code).

Para sa iyong sariling mga proyekto, kung kailangan mong parehong magpadala at tumanggap ng data, maaari mong isama ang pagpapaandar na pag-publish mula sa nakaraang halimbawa sa code na kasama sa hakbang na ito. Dapat itong hawakan sa pangunahing pagpapaandar ng Arduino loop ().

Tandaan na baguhin ang mga variable sa tuktok ng code upang umangkop sa iyong network!