Super Simple Raspberry Pi 433MHz Home Automation: 7 Hakbang

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

Ang tutorial na ito ay isa sa marami pagdating sa paggamit ng isang Raspberry Pi upang makontrol ang mga wireless na aparato sa paligid ng bahay. Tulad ng marami pang iba, ipapakita nito sa iyo kung paano gumamit ng isang murang pares ng transmitter / receiver na naka-hook sa iyong Pi upang makipag-ugnay sa mga aparatong nagpapatakbo sa karaniwang ginagamit na 433MHz radio frequency band. Partikular nitong ipapakita sa iyo kung paano i-on o i-off ang anumang aparato na de-kuryente gamit ang iyong Pi sa pamamagitan ng paglilipat ng mga utos sa isang hanay ng mga socket ng kuryente na kontrolado ng 433MHz.

Bakit ko nilikha ang tutorial na ito kung maraming mayroon na? Higit sa lahat dahil halos lahat ng iba pang mga tutorial na natagpuan ko ay tila labis na kumplikado ng mga bagay, lalo na sa panig ng software. Napansin ko na umaasa sila nang labis sa mga aklatan ng third-party, script o mga snippet ng code upang magawa ang lahat ng gawain. Marami ang hindi magpapaliwanag kung ano ang ginagawa ng pinagbabatayan na code - hihilingin ka lang nila na itulak ang dalawa o tatlong piraso ng software sa iyong Pi at magpatupad ng isang pangkat ng mga utos, walang mga katanungan. Nais kong subukan at gamitin ang aking Pi upang buksan at patayin ang mga de-koryenteng aparato sa paligid ng aking tahanan gamit ang isang hanay ng mga malayuang kontrolado na mga socket ng 433MHz, ngunit nais kong lumikha ng aking sariling bersyon ng system na naiintindihan ko, sana tinanggal ang pangangailangan na gumamit ng mga aklatan o script ng ibang tao.

Iyon ay tungkol sa tutorial na ito. Ang panig ng software ng sistemang ito ay binubuo ng dalawang napaka-simpleng mga script ng Python - isa para sa pagtanggap at pagrekord ng mga signal, at isa para sa paglilipat ng mga signal na ito pabalik sa mga wireless power socket. Ang aktwal na pagtanggap / paghahatid ng signal ay nakasalalay lamang sa madaling gamiting RPi. GPIO library na kung saan, kahit papaano para sa akin, ay paunang naka-install sa Raspbian. Ang library na ito ay maaari ring mai-import nang direkta sa Python.

Para sa proyektong ito kakailanganin mo:

Isang Raspberry Pi. Anumang modelo ay dapat na gumana, gumamit ako ng isang all-in-one starter kit, ngunit marahil kailangan mo lamang ng gitnang yunit

Isang pares ng transmiter / receiver ng 433MHz. Ang mga pinaka-karaniwang ginagamit sa ganitong uri ng proyekto ay tila ito. Ang pagbili ng isang pakete ng limang tulad ng naka-link ay nagsisiguro na mayroon kang ilang mga ekstrang

Isang hanay ng mga socket ng kuryente na kontrolado ng 433MHz. Ginamit ko ang mga ito na lubos kong inirerekumenda, ngunit maraming mga magagamit na mga modelo. Tiyaking tiyakin lamang na gumana ang mga ito sa dalas na ito

Ang ilang mga accessories sa circuit-building. Inirerekumenda ko ang paggamit ng isang breadboard at ilang mga jumper cables upang gawing madali ang proseso ng pagbuo ng circuit hangga't maaari.

[Kung magpapasya kang bumili ng anuman sa mga produktong ito, lubos kong pahalagahan kung mai-access mo ang mga listahan gamit ang mga link sa itaas - sa ganoong paraan, nakakakuha ako ng isang maliit na bahagi ng kita nang walang labis na gastos sa iyo!]

Hakbang 1: Pag-set up ng Unit ng Tagatanggap

Bago mo magamit ang iyong Pi upang magpadala ng mga utos sa mga socket na kontrolado ng remote, kailangan mong malaman kung anong tukoy na mga signal ang tinugon nila. Karamihan sa mga remote-control sockets ay nagpapadala ng isang handset na maaaring magamit upang i-on o i-off ang mga tukoy na yunit. Sa kaso ng mga binili ko, ang handset ay may apat na hanay ng mga ipinares na ON / OFF na pindutan, na ang bawat isa ay nagpapadala ng isang ON o OFF signal sa isang partikular na socket unit.

Nagdadala ito ng isang katanungan - paano natin malalaman kung aling mga pindutan ang tumutugma sa aling socket? Talagang nakasalalay ito sa modelo na mayroon ka. Ang isa sa mga pangunahing kadahilanan na pinili ko ang aking partikular na estilo ng socket (naka-link sa pagpapakilala) ay ang mga yunit ay maaaring mai-configure ng isang pisikal na switch upang makagawa ng isang partikular na socket na tumugon sa isang partikular na hanay ng mga ON / OFF na pindutan sa handset. Nangangahulugan din ito na maaari mong i-unplug at ilipat ang mga socket sa paligid ng bahay na alam na ang bawat unit ay palaging tutugon sa parehong mga signal na ON / OFF.

Kapag naisip mo kung paano nakikipag-ugnay ang iyong mga socket sa handset, kakailanganin mong gamitin ang iyong unit ng tatanggap na 433MHz (nakalarawan sa itaas) upang 'sniff' ang mga code na ipinapadala ng handset. Kapag naitala mo ang mga waveform ng mga code na ito, maaari mong kopyahin ang mga ito gamit ang Python at ipadala ang mga ito gamit ang transmitter unit.

Ang unang bagay na gagawin dito ay i-wire ang mga pin sa iyong tatanggap sa tamang mga GPIO pin sa Pi. Ang unit ng tatanggap ay may apat na mga pin, ngunit tatlo lamang sa mga ito ang kinakailangan. Sa palagay ko kapwa sa gitnang mga pin ay nagbibigay ng parehong output, kaya kailangan mo lamang kumonekta sa isa sa mga ito (maliban kung nais mong i-stream ang natanggap na mga signal sa dalawang magkakahiwalay na mga GPIO pin).

Ang imahe sa itaas ay medyo nagbubuod sa mga kable. Ang bawat pin sa receiver ay maaaring mai-wire nang direkta sa kaukulang pin sa Pi. Gumagamit ako ng isang breadboard at jumper cables upang gawing mas matikas ang proseso. Tandaan na maaari kang pumili ng anumang pin ng data ng GPIO upang kumonekta sa alinman sa mga gitnang pin ng tatanggap. Ginamit ko ang pin na minarkahang '23' sa aking header ng Pi.

MAHALAGA: Kung ikokonekta mo ang pin na minarkahang '3v3' sa imahe sa itaas sa isang mas mataas na boltahe na pin sa Pi (hal. 5v), maaari mong sirain ang Pi dahil ang mga pin ng GPIO ay hindi maaaring tiisin ang mga voltages sa itaas ng 3v3. Bilang kahalili, maaari mong paganahin ito sa 5v at i-set up ang isang boltahe divider upang magpadala ng isang ligtas na boltahe sa pin ng DATA.

Ang saklaw ng tatanggap ay hindi magiging napakalaki sa boltahe na ito, lalo na kung ang isang antena ay hindi konektado. Gayunpaman, hindi mo kailangan ng isang mahabang saklaw dito - hangga't maaaring kunin ng tatanggap ang mga signal mula sa handset kapag hawak ang mga ito sa tabi mismo ng isa't isa, iyon lang ang kailangan natin.

Hakbang 2: Pag-sniff ng Mga Code ng Handset

Ngayon na ang iyong tatanggap ay naka-wire hanggang sa Pi, maaari mong simulan ang unang kapanapanabik na yugto ng proyektong ito - ang singhot. Nagsasangkot ito ng paggamit ng nakakabit na script ng Python upang maitala ang signal na ipinadala ng handset kapag pinindot ang bawat pindutan. Napakadali ng script, at lubos kong inirerekumenda na tingnan mo ito bago mo ito patakbuhin - pagkatapos ng lahat, ang punto ng proyektong ito ay hindi mo lamang palakihin ang pagpapatakbo ng code ng iba!

Bago mo simulan ang prosesong ito, kakailanganin mong tiyakin na mayroon ka ng mga library ng Python upang patakbuhin ang sniffer script. Nakalista ang mga ito sa tuktok ng script:

mula sa datime import datime

import matplotlib.pyplot bilang pyplot import RPi. GPIO bilang GPIO

Ang RPi. GPIO at mga libraryong datime ay kasama sa aking pamamahagi ng Raspbian, ngunit kailangan kong i-install ang matplotlib library tulad ng sumusunod:

sudo apt-get install python-matplotlib

Ang silid-aklatan na ito ay isang karaniwang ginagamit na graph plotting library na napaka kapaki-pakinabang kahit sa labas ng proyektong ito, kaya't siguradong hindi ito makakasama sa pag-install. Kapag napapanahon ang iyong mga aklatan, handa ka na upang simulan ang pagrekord ng data. Narito kung paano gumagana ang script:

Kapag ito ay pinatakbo (gamit ang command na 'python ReceiveRF.py'), isasaayos nito ang tinukoy na GPIO pin bilang isang input ng data (pin 23 bilang default). Patuloy na sususubukan nito ang pin at mag-log kung tumatanggap ito ng isang digital na 1 o 0. Ito ay nagpapatuloy sa isang itinakdang tagal (5 segundo bilang default). Kapag naabot ang limitasyon sa oras na ito, tititigil ng script ang pagrekord ng data at isasara ang input ng GPIO. Gumagawa ito pagkatapos ng isang maliit na post-processing at balak ang natanggap na halaga ng pag-input laban sa oras. Muli, kung mayroon kang mga katanungan tungkol sa kung ano ang ginagawa ng script, marahil maaari mong sagutin ang mga ito sa iyong sarili pagkatapos tingnan kung paano ito gumagana. Sinubukan kong gawing nababasa at simple hangga't maaari ang code.

Ano ang kailangan mong gawin ay mag-ingat para sa kung isinasaad ng script na mayroon itong ** Nagsimulang pag-record **. Kapag lumitaw ang mensaheng ito, dapat mong pindutin nang matagal ang isa sa mga pindutan sa handset nang halos isang segundo. Siguraduhing hawakan ito malapit sa tatanggap. Kapag natapos na ang pag-record ng script, gagamitin nito ang matplotlib upang magbalangkas ng isang grapiko na form ng alon ng signal na natanggap nito sa pagitan ng recording interval. Mangyaring tandaan, kung nakakonekta ka sa iyong Pi gamit ang isang SSH client tulad ng PuTTY, kakailanganin mo ring buksan ang isang X11 application upang payagan ang gelombang na ipakita. Gumagamit ako ng xMing para dito (at para sa iba pang mga bagay tulad ng remote-desktopping sa aking Pi). Upang payagan na maipakita ang balangkas, simulan lamang ang xMing bago mo patakbuhin ang script at hintaying lumitaw ang mga resulta.

Kapag ang iyong matplotlib window ay lilitaw, ang lugar ng interes sa loob ng isang lagay ng lupa ay dapat na medyo halata. Maaari mong gamitin ang mga kontrol sa ilalim ng window upang mag-zoom in hanggang sa mapili mo ang matataas at pinakamababang signal na nailipat ng handset habang pinipigilan ang pindutan. Tingnan ang imahe sa itaas para sa isang halimbawa ng isang kumpletong code. Ang senyas ay marahil ay binubuo ng napakaikling pulso na pinaghiwalay ng magkatulad na tagal ng panahon kung saan walang signal na natanggap. Ang harang na ito ng maiikling pulso ay maaaring sundin ng isang mas mahabang panahon kung saan walang natanggap, pagkatapos na ang pattern ay ulitin. Kapag natukoy mo ang pattern na pag-aari ng isang solong halimbawa ng code, kumuha ng screenshot na tulad nito sa tuktok ng pahinang ito, at magpatuloy sa susunod na hakbang upang bigyang kahulugan ito.

Hakbang 3: Paglilipat ng Signal ng Resulta

Ngayon na natukoy mo ang bloke ng mga pana-panahong pagtaas at pagbaba na naaayon sa signal ng isang partikular na pindutan, kakailanganin mo ng isang paraan ng pag-iimbak at pagbibigay kahulugan nito. Sa halimbawa ng signal sa itaas, mapapansin mo na mayroon lamang dalawang natatanging mga pattern na bumubuo sa buong signal block. Minsan nakikita mo ang isang maikling mataas na sinusundan ng isang mahabang mababa, at kung minsan ito ay ang kabaligtaran - isang mahabang mataas na sinusundan ng isang maikling mababa. Kapag naglalarawan ako ng aking mga signal, nagpasya akong gamitin ang sumusunod na kombensyon sa pagpapangalan:

1 = short_on + long_off0 = long_on + short_off

Tingnan muli ang naka-label na form ng alon, at makikita mo ang ibig kong sabihin. Kapag natukoy mo ang katumbas na mga pattern sa iyong signal, ang kailangan mo lang gawin ay bilangin ang mga 1 at 0 upang buuin ang pagkakasunud-sunod. Kapag na-transcript, ang signal sa itaas ay maaaring isulat tulad ng sumusunod:

1111111111111010101011101

Ngayon ay kailangan mo lamang ulitin ang prosesong ito upang i-record at isalin ang mga signal na naaayon sa iba pang mga pindutan sa iyong handset, at nakumpleto mo ang unang bahagi ng proseso!

Bago ka makapagpadala ulit ng mga signal gamit ang transmitter, may kaunti pang gawain na dapat gawin. Ang tiyempo sa pagitan ng mga matataas at pinakamababang tumutugma sa isang 1 o isang 0 ay napakahalaga, at kailangan mong tiyakin na alam mo kung gaano katagal ang isang 'short_on' o isang 'long_off' na talagang tumatagal. Para sa aking mga code, mayroong tatlong piraso ng impormasyon sa tiyempo na kailangan kong kunin upang makaya ang mga signal:

• Ang tagal ng isang 'maikling' agwat, ibig sabihin, ang simula ng isang 1 o ang pagtatapos ng isang 0.
• Ang tagal ng isang 'mahabang' agwat, ibig sabihin, ang pagtatapos ng isang 1 o ang simula ng isang 0.
• Ang tagal ng isang 'pinalawak' na agwat. Napansin ko na kapag hinawakan ko ang isang pindutan pababa sa handset, mayroong isang 'pinalawak na_off' na panahon sa pagitan ng bawat paulit-ulit na halimbawa ng signal block. Ang pagkaantala na ito ay ginagamit para sa pag-synchronize at mayroong isang nakapirming tagal.

Upang matukoy ang mga halagang ito sa tiyempo, maaari mong gamitin ang pag-andar ng pag-zoom sa window ng matplotlib upang mag-zoom hanggang sa at ilagay ang cursor sa mga nauugnay na bahagi ng signal. Ang pagbasa ng lokasyon ng cursor sa ilalim ng window ay dapat payagan kang matukoy kung gaano kalawak ang bawat bahagi ng signal na tumutugma sa isang mahaba, maikli o pinalawig na agwat. Tandaan na ang x-axis ng isang lagay ng lupa ay kumakatawan sa oras, at ang x sangkap ng readout ng cursor ay nasa mga yunit ng segundo. Para sa akin, ang mga lapad ay ang mga sumusunod (sa segundo):

• short_delay = 0.00045
• long_delay = 0,00090 (dalawang beses hangga't isang 'maikli')
• pinalawak_delay = 0.0096

Hakbang 4: Pag-set up ng Transmitter Unit

Kapag nakolekta mo ang iyong mga code at data ng tiyempo, maaari mong idiskonekta ang iyong unit ng tatanggap dahil hindi mo na ito kakailanganin. Maaari mo ring i-wire ang transmiter nang direkta sa mga nauugnay na mga pin ng Pi GPIO tulad ng ipinakita sa imahe sa itaas. Nalaman ko na ang mga pin sa mga unit ng transmiter ay may label, na ginagawang mas madali ang proseso.

Sa kasong ito, OK lang na paganahin ang yunit gamit ang supply ng 5v mula sa Pi dahil ang pin ng DATA ay hindi magpapadala ng mga signal sa Pi, natatanggap lamang ang mga ito. Gayundin, ang isang 5v power supply ay magbibigay ng higit pang saklaw ng paghahatid kaysa sa paggamit ng 3v3 supply. Muli, maaari mong ikonekta ang DATA pin sa anumang naaangkop na pin sa Pi. Gumamit ako ng pin 23 (pareho sa tatanggap).

Ang isa pang bagay na inirerekumenda kong gawin ay ang pagdaragdag ng isang antena sa maliit na butas sa kanang tuktok ng transmiter. Gumamit ako ng isang 17cm mahabang piraso ng tuwid na kawad. Inirekomenda ng ilang mapagkukunan ang isang coiled wire na may katulad na haba. Hindi ako sigurado kung alin ang mas mahusay, ngunit ang tuwid na kawad ay nagbibigay ng sapat na saklaw para sa akin upang i-on / i-off ang mga socket mula sa anumang lokasyon sa aking maliit na flat. Mahusay na maghinang ng antena, ngunit inalis ko lamang ang ilan sa mga plastik mula sa kawad at binalot ang tanso sa butas.

Kapag ang transmitter ay wired up, iyon lang ang tapos na ng pag-setup ng hardware! Ang tanging natitirang gawin ngayon ay itakda ang iyong mga socket sa paligid ng bahay at tingnan ang programa ng transmitter.

Hakbang 5: Paghahatid ng Mga Sinyales Gamit ang Pi

Dito pumapasok ang pangalawang script ng Python. Dinisenyo ito upang maging kasing simple ng una, kung hindi higit pa. Muli, mangyaring i-download ito at tingnan ang code. Kakailanganin mong i-edit ang script upang maipadala ang wastong mga signal ayon sa data na naitala mo sa hakbang 3, kaya't isang magandang panahon na upang mabilis itong tingnan.

Ang mga aklatan na kinakailangan upang patakbuhin ang script na ito ay paunang naka-install sa aking Pi, kaya't hindi na kailangan ng karagdagang pag-install. Nakalista ang mga ito sa tuktok ng script:

oras ng pag-import

import sys import RPi. GPIO bilang GPIO

Sa ilalim ng pag-import ng library ay ang impormasyong kakailanganin mong i-edit. Narito kung paano ito nakikita bilang default (ito ang impormasyong naaayon sa aking mga socket na tinutukoy gamit ang hakbang 3):

a_on = '1111111111111010101011101'

a_off = '1111111111111010101010111' b_on = '1111111111101110101011101' b_off = '1111111111101110101010111' c_on = '1111111111101011101011101' c_off = '1111111111101011101010111' d_on = '1111111111101010111011101' d_off = '1111111111101010111010111' short_delay = 0.00045 long_delay = 0.00090 extended_delay = 0.0096

Narito mayroon kaming walong mga string ng code (dalawa para sa bawat pares ng mga on / off na pindutan sa aking handset - maaari kang magkaroon ng higit o mas kaunting mga code) na sinusundan ng tatlong piraso ng impormasyon ng tiyempo na tinukoy din sa hakbang 3. Maglaan ng oras upang matiyak na mayroon ka naipasok nang tama ang impormasyong ito.

Kapag nasisiyahan ka sa mga code / pagkaantala na ipinasok mo sa script (maaari mong palitan ang pangalan ng mga variable ng code string kung gusto mo), handa ka nang subukan ang system! Bago mo gawin, tingnan ang pagpapaandar ng transmit_code () sa script. Dito nangyayari ang aktwal na pakikipag-ugnayan sa transmiter. Inaasahan ng pagpapaandar na ito ang isa sa mga string ng code na maipapadala bilang isang argument. Pagkatapos ay bubukas ang tinukoy na pin bilang isang output ng GPIO at mag-loop sa bawat character sa code string. Pagkatapos ay bubuksan o i-off ang transmitter alinsunod sa impormasyon ng tiyempo na iyong ipinasok upang makabuo ng isang form ng alon na tumutugma sa code string. Nagpapadala ito ng bawat code ng maraming beses (10 bilang default) upang mabawasan ang tsansa na napalampas ito, at nag-iiwan ng isang pinalawak na_delay sa pagitan ng bawat bloke ng code, tulad ng handset.

Upang patakbuhin ang script, maaari mong gamitin ang sumusunod na syntax ng utos:

python TransmitRF.py code_1 code_2…

Maaari kang magpadala ng maraming mga string ng code sa isang solong pagpapatakbo ng script. Halimbawa, upang i-on ang mga socket (a) at (b) at socket (c), patakbuhin ang script gamit ang sumusunod na utos:

python TransmitRF.py a_on b_on c_off

Hakbang 6: Isang Tala sa Katumpakan ng Timing

Tulad ng nabanggit, ang tiyempo sa pagitan ng naihatid na mga on / off na pulso ay medyo mahalaga. Gumagamit ang TransmitRF.py script ng oras. Tulog () ng function ng python upang buuin ang mga waveform na may tamang agwat ng pulso, ngunit dapat pansinin na ang pagpapaandar na ito ay hindi ganap na tumpak. Ang haba kung saan ito nagiging sanhi ng paghihintay ng script bago ipatupad ang susunod na operasyon ay maaaring depende sa load ng processor sa ibinigay na instant. Iyon ay isa pang kadahilanan kung bakit nagpapadala ang TransmitRF.py ng bawat code ng maraming beses - kung sakaling ang time.s Sleep () na pagpapaandar ay hindi magagawang maayos na makabuo ng isang naibigay na halimbawa ng code.

Personal na hindi ako nagkaroon ng mga isyu sa oras. Tulog () pagdating sa pagpapadala ng mga code. Gayunman, alam ko na ang aking oras. Natukoy ko ito gamit ang nakalakip na script ng SleepTest.py na maaaring magamit upang magbigay ng isang pagtatantya kung gaano katumpak ang oras ng pag-andar ng Pi mo. Para sa aking partikular na mga socket na remote-control, ang pinakamaikling pagkaantala na kailangan kong ipatupad ay 0.45ms. Tulad ng sinabi ko, wala pa akong mga isyu sa mga hindi tumutugon na socket, kaya parang 0.45 ± 0.1ms ay sapat na mabuti.

Mayroong iba pang mga pamamaraan para masiguro na ang pagkaantala ay mas tumpak; halimbawa, maaari kang gumamit ng isang nakatuon na chip ng PIC upang makabuo ng mga code, ngunit ang mga bagay na tulad nito ay lampas sa saklaw ng tutorial na ito.

Hakbang 7: Konklusyon

Ang proyektong ito ay nagpakita ng isang pamamaraan para sa pagkontrol ng anumang mga de-koryenteng kasangkapan gamit ang isang Raspberry Pi at isang hanay ng mga 433MHz na remote-control sockets, na may pagtuon sa pagiging simple at transparency. Ito ang pinaka kapana-panabik at nababaluktot na proyekto na ginamit ko para sa aking Pi, at may mga walang limitasyong aplikasyon para dito. Narito ang ilang mga bagay na magagawa ko na ngayon salamat sa aking Pi:

• Buksan ang isang pampainit ng kuryente sa tabi ng aking higaan kalahating oras bago ang aking alarma.
• Patayin ang pampainit isang oras pagkatapos kong makatulog.
• Buksan ang ilaw ng aking higaan kapag namatay ang aking alarma upang hindi ako makatulog muli.
• at marami pang iba…

Para sa karamihan ng mga gawaing ito, ginagamit ko ang pagpapaandar ng crontab sa loob ng Linux. Pinapayagan kang mag-set up ng mga awtomatikong nakaiskedyul na gawain upang patakbuhin ang TransmitRF.py script sa mga tukoy na oras. Maaari mo ring gamitin ang Linux sa utos upang magpatakbo ng mga one-off na gawain (na, para sa akin, kailangang mai-install nang hiwalay gamit ang 'sudo apt-get install at'). Halimbawa, upang buksan ang aking pampainit sa kalahating oras bago mag-alarm ang aking susunod na umaga, ang kailangan ko lang gawin ay ang uri:

sa 05:30

python TransmitRF.py c_on

Maaari mo ring gamitin ang proyektong ito kasabay ng aking Dropbox home monitoring system upang makontrol ang mga gamit sa internet! Salamat sa pagbabasa, at kung nais mong linawin ang isang bagay o ibahagi ang iyong opinyon, mangyaring mag-post ng isang komento!