Arduino RF Sensor Decoder: 5 Hakbang

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

Ang dati kong bahay ay may dala nang paunang naka-install na sistema ng seguridad na mayroong mga sensor ng pintuan, isang sensor ng paggalaw, at isang control panel. Lahat ay mahirap i-wire sa isang malaking kahon ng electronics sa isang aparador at may mga tagubilin para sa pag-wire ng isang landline na telepono upang awtomatikong mag-dial out sakaling may alarma. Kapag sinubukan kong maglaro dito natuklasan ko na ang isa sa mga sensor ng pintuan ay hindi kumpletong na-install at ang isa pa ay paulit-ulit dahil sa hindi tamang pagkakahanay. Napakarami para sa propesyonal na pag-install na binabanggit sa card ng negosyo ng kumpanya ng seguridad. Ang aking solusyon sa panahong iyon ay upang bumili ng isang pares ng mga security camera sa internet at isang murang alarma sa wireless security.

Mabilis sa ngayon at ang wireless alarm na iyon ay nakaupo sa isang kahon sa aking basement. Matapos ang aking acquisition ng isang murang tagatanggap ng RF nagpasya akong tingnan kung maaari kong mai-decode ang mga mensahe na naihatid ng iba't ibang mga sensor ng alarma at mga remote na mayroon ako. Naisip ko na dahil lahat sila ay nagtrabaho kasama ang murang kahon ng alarma na dapat silang lahat gumamit ng parehong format ng mensahe na may iba't ibang ID lamang. Hindi nagtagal nalaman ko na magkatulad lamang sila sa pangkalahatang istraktura ng mga mensahe. Kaya't ang proyekto ay mabilis na nagpunta mula sa walang halaga hanggang sa napaka-interesante.

Hakbang 1: Mga Modyul ng Sensor

Tulad ng nakikita mo sa mga larawan sa itaas ng mga transmiter kasama ang mga bukas na sensor, mga detector ng paggalaw, mga remote ng arming, at isang wireless keypad na ginamit para sa pag-program ng alarm box. Bilang ito ay lumabas, walang dalawa sa mga aparatong ito ang gumagamit ng parehong haba ng pag-sync o tagal ng bit. Ang nag-iisa lamang, bukod sa haba ng mensahe, ay ang pangunahing format ng mga piraso. Ang bawat bit ay tumatagal ng isang nakapirming tagal ng oras na may pagkakaiba sa pagitan ng isang zero at isang pagiging cycle ng tungkulin ng mataas / mababang mga bahagi.

Ang magandang waveform na ipinakita sa itaas ay HINDI kung ano ang una kong natanggap. Sapagkat maraming trapiko sa 433-MHz frequency band na kailangan kong tiyakin na buhayin ang sensor bago ko itakda ang saklaw upang gumawa ng isang solong gatilyo. Sa kasamaang palad ang mga sensor ay naglabas ng maraming mga kopya ng mensahe ng data kapag naaktibo at ang mga remote at keypad ay nagpapatuloy sa paglabas ng mga mensahe hangga't pinindot ang isang susi. Sa pamamagitan ng paggamit ng saklaw na natukoy ko ang haba ng pag-sync at ang tagal ng data ng mga tagal para sa bawat item. Tulad ng nabanggit dati, ang mga oras ng pag-sync ay magkakaiba at ang mga oras ng bit ay magkakaiba ngunit ang mga format ng mensahe lahat ay may mababang antas na pag-sync na sinusundan ng 24 na data bit at isang stop stop. Sapat na iyon sa akin upang makapagtayo ng isang pangkaraniwang decoder sa software nang hindi kinakailangang i-hard code ang lahat ng magkakaibang mga detalye para sa bawat aparato.

Hakbang 2: Hardware

Orihinal na nagtayo ako ng isang sensor decoder gamit ang isang PIC microcontroller at wika ng pagpupulong. Naglalaro ako kasama ng mga variant ng Arduino kamakailan kaya naisip kong makikita ko kung matutularan ko ito. Ang simpleng eskematiko ay ipinapakita sa itaas at mayroon ding larawan ng aking prototype. Ang ginawa ko lang ay gumamit ng tatlong karaniwang mga wire ng lumulukso upang pumunta mula sa Arduino Nano patungo sa RF receiver board. Lakas at isang solong linya ng data ang kailangan.

Kung nabasa mo ang aking Instructable sa "3-in-1 na Oras at Pagpapakita ng Panahon" makikita mo na gumagamit ako ng isang karaniwang RXB6, 433-MHz na tatanggap. Maaari kang makakuha ng tunay na murang mga tatanggap upang gumana sa maikling saklaw na kinakailangan para sa proyektong ito ngunit inirerekumenda ko pa rin ang paggamit ng isang super-heterodyne na tatanggap.

Hakbang 3: Software

Ang software ay nagko-convert ang natanggap na mga piraso sa ipinapakita ASCII character. Ito ay naglalabas ng halaga ng haba ng pag-sync, at ang haba ng 1 at 0 na mga piraso. Dahil alam ko na ang haba ng pag-sync at ang mga medyo format, maaaring naisulat ko ang software para sa kanila. Sa halip, napagpasyahan kong makita kung maisusulat ko ito upang maisaayos ang haba ng pag-sync at upang awtomatikong malaman ang mga bits ng data. Iyon ay dapat gawing mas madaling baguhin kung sakaling nais kong subukang makita ang iba pang mga format sa anumang oras. Mahalagang tandaan na ang software ay hindi alam kung ang unang piraso ng isang mensahe ay isang 1 o isang 0. Ipinapalagay na ito ay isang 1 ngunit, kung malalaman nito na dapat itong isang zero, babaligtarin nito ang mga piraso sa nakumpletong mensahe bago ipadala ito sa serial port.

Ang mga oras ng pag-sync ng pulso at ang mga data bit ay natutukoy sa pamamagitan ng paggamit ng panlabas na makagambalang input ng INT0 upang mag-trigger ng isang makagambala na handler. Maaaring mag-trigger ang INT0 sa pagtaas, pagbagsak, o parehong gilid, o sa isang matatag na mababang antas. Naputol ang software sa magkabilang gilid at sinusukat ang dami ng oras na ang pulso ay mananatiling mababa. Pinapasimple nito ang mga bagay dahil ang pagsisimula / pag-sync ng mensahe ay isang mababang antas ng pulso at ang mga piraso ay maaaring matukoy batay sa kanilang mababang antas na oras.

Tukuyin muna ng interrupt handler kung ang nakuha na bilang ay sapat na haba upang maging isang start / sync pulse. Ang iba't ibang mga aparato na ginamit ko ang pag-sync ng mga pulso ng 4, 9, 10, at 14 milliseconds. Ang tinukoy na mga pahayag para sa min / max na pinapayagan na mga halaga ng pag-sync ay nasa harap ng software at kasalukuyang itinakda para sa 3 at 16 milliseconds. Ang mga oras ng bit ay magkakaiba rin sa pagitan ng mga sensor kaya't ang algorithm para sa pag-decode ng mga bits ay kailangang isaalang-alang iyon. Ang bit time ng unang bit ay nai-save tulad ng oras ng isang kasunod na bit na may isang makabuluhang pagkakaiba mula sa unang bit. Ang isang direktang paghahambing ng kasunod na mga oras ng bit ay hindi posible kaya ang isang "fudge factor" na tumutukoy ("Pagkakaiba-iba") ay ginagamit. Nagsisimula ang pag-decode ng bit sa pamamagitan ng pag-aakalang ang unang data bit ay palaging naitala bilang isang lohika 1. Ang halagang iyon ay nai-save at pagkatapos ay ginamit upang subukan ang kasunod na mga piraso. Kung ang isang kasunod na bilang ng data bit ay nasa loob ng window ng pagkakaiba-iba ng na-save na halaga pagkatapos ito ay naitala rin bilang isang lohika 1. Kung ito ay nasa labas ng pagkakaiba-iba ng window ng nai-save na halaga pagkatapos ito ay naitala bilang isang lohika 0. Kung ang lohika 0 Ang oras ng bit ay mas maikli kaysa sa unang kaunting oras at pagkatapos ay isang flag ay nakatakda upang sabihin sa software na ang mga byte ay kailangang baligtarin bago ipakita. Ang tanging kaso kung saan nabigo ang algorithm na ito ay kapag ang mga piraso sa isang mensahe ay lahat ng 0. Maaari nating tanggapin ang limitasyon na iyon sapagkat ang uri ng mensahe ay walang katuturan.

Ang mga sensor na interesado ako sa lahat ay may haba ng mensahe na 24 data bits ngunit ang software ay hindi limitado sa haba na iyon. Mayroong isang buffer hanggang sa pitong byte (higit na maaaring maidagdag) at tumutukoy para sa minimum at maximum na haba ng mensahe sa mga byte. Ang software ay naka-set up upang mangolekta ng mga piraso, i-convert ang mga ito sa mga byte, pansamantalang maiimbak ang mga ito, at pagkatapos ay i-output ang mga ito sa ASCII format sa pamamagitan ng serial port. Ang kaganapan na nagpapalitaw ng output ng mensahe ay ang pagtanggap ng isang bagong pulso ng pagsisimula / pag-sync.

Hakbang 4: Pag-log ng Data

Ang software ay naka-set up upang ma-output ang na-convert na data bilang mga character na ASCII sa pamamagitan ng serial (TX) na output ng Arduino. Kapag ginawa ko ang bersyon ng PIC kailangan kong mag-interface sa isang terminal program sa PC upang maipakita ang data. Ang isang bentahe ng Arduino IDE ay mayroon itong naka-built na function na Serial Monitor. Itinakda ko ang serial port rate sa 115.2k at pagkatapos ay itakda ang window ng Serial Monitor sa parehong rate. Ang screen shot dito ay nagpapakita ng isang tipikal na display na may mga output mula sa iba't ibang mga sensor na mayroon ako. Tulad ng nakikita mo, ang data kung minsan ay hindi perpekto ngunit madali mong matutukoy kung ano ang tunay na halaga ng bawat sensor dapat.

Hakbang 5: Sample Receiver Software

Nagsama ako ng isang sample na listahan ng software na nagpapakita kung paano mo magagamit ang nakolektang impormasyon upang makatanggap ng isang tukoy na hanay ng mga code para sa iyong aplikasyon. Ang halimbawang ito ay na-set up upang tularan ang isa sa aking mga malalayong outlet ng Etekcity. Ang isang utos ay binuksan ang LED na itinayo sa Nano (D13) at ang iba pang utos ay pinapatay ang LED. Kung wala kang isang LED na naka-built sa iyong Arduino, pagkatapos ay idagdag ang risistor at LED tulad ng ipinakita sa diagram. Sa isang tunay na aplikasyon ang pagpapaandar na ito ay magpapasara / patay para sa isang outlet ng elektrisidad (gamit ang isang relay o isang triac). Ang mga oras ng pag-sync, oras ng bit, at inaasahang mga byte ng data ay tinukoy sa harap para sa kadalian ng pagbabago. Maaari mong gamitin ang anuman sa mga natitirang linya ng data upang i-on / i-off ang mga bagay, atbp para sa iyong tukoy na application. Idagdag lamang ang naaangkop na command code na tumutukoy at palitan ang LED on / off na lohika sa "loop" upang umangkop sa iyong mga pangangailangan.