Automatizare la domiciliu super simplă Raspberry Pi 433MHz: 7 pași

2024 Autor: John Day | [email protected]. Modificat ultima dată: 2024-01-30 11:45

Acest tutorial este unul dintre multe când vine vorba de utilizarea unui Raspberry Pi pentru a controla dispozitivele fără fir din casă. La fel ca multe altele, vă va arăta cum să utilizați o pereche ieftină de emițător / receptor conectată la Pi pentru a interacționa cu dispozitivele care funcționează pe banda de frecvență radio de 433 MHz frecvent utilizată. Acesta vă va arăta în mod specific cum să porniți sau să dezactivați orice dispozitiv electric folosind Pi-ul dvs. prin transmiterea comenzilor către un set de prize de alimentare de 433 MHz controlate de la distanță.

De ce am creat acest tutorial dacă există deja atât de multe? În principal pentru că aproape toate celelalte tutoriale pe care le-am întâlnit păreau să complice prea mult lucrurile, mai ales din partea software-ului. Am observat că s-au bazat foarte mult pe biblioteci terțe, scripturi sau fragmente de cod pentru a face toată treaba. Mulți nici măcar nu ar explica ce face codul de bază - v-ar cere doar să împingeți două sau trei bucăți de software pe Pi și să executați o grămadă de comenzi, fără întrebări. Mi-am dorit foarte mult să încerc și să folosesc Pi-ul meu pentru a porni și opri dispozitivele electrice în jurul casei mele folosind un set de prize de 433 MHz controlate de la distanță, dar am vrut să creez propria mea versiune a sistemului pe care să o înțeleg, eliminând, sperăm, nevoia de a folosiți bibliotecile sau scripturile altcuiva.

Despre acest tutorial este vorba. Partea software a acestui sistem constă din două scripturi Python foarte simple - unul pentru recepționarea și înregistrarea semnalelor și unul pentru transmiterea acestor semnale înapoi la prizele wireless. Recepția / transmisia efectivă a semnalului se bazează doar pe biblioteca RPi. GPIO ușor de utilizat care, cel puțin pentru mine, a venit preinstalată cu Raspbian. Această bibliotecă poate fi importată direct în Python.

Pentru acest proiect veți avea nevoie de:

Un Raspberry Pi. Orice model ar trebui să funcționeze, am folosit un kit de pornire all-in-one, dar poate aveți nevoie doar de unitatea centrală

O pereche transmițător / receptor de 433 MHz. Cele mai frecvent utilizate în acest tip de proiect par a fi acestea. Cumpărarea unui pachet de cinci, precum cel conectat, vă asigură că aveți câteva piese de schimb

Un set de prize de alimentare de 433 MHz controlate de la distanță. Le-am folosit pe care le-aș recomanda, dar există nenumărate modele disponibile. Asigurați-vă că funcționează pe această frecvență

Unele accesorii pentru construirea circuitelor. Aș recomanda utilizarea unei plăci de calcul și a unor cabluri jumper pentru a face procesul de construire a circuitului cât mai ușor posibil.

[Dacă decideți să cumpărați oricare dintre aceste produse, aș aprecia foarte mult dacă accesați listele folosind link-urile de mai sus - în acest fel, obțin o mică parte din profituri fără costuri suplimentare!]

Pasul 1: Configurarea unității receptoare

Înainte de a putea utiliza Pi-ul dvs. pentru a trimite comenzi către prizele controlate de la distanță, trebuie să știți la ce semnale specifice răspund. Majoritatea prizelor cu telecomandă sunt livrate cu un receptor care poate fi utilizat pentru a porni sau opri unități specifice. În cazul celor pe care le-am cumpărat, receptorul are patru rânduri de butoane ON / OFF asociate, fiecare dintre ele trimitând un semnal ON sau OFF către o anumită unitate de soclu.

Aceasta ridică o întrebare - de unde știm ce butoane corespund cu care soclu? Acest lucru depinde de fapt de modelul pe care îl aveți. Unul dintre principalele motive pentru care am ales stilul meu particular de soclu (legat în introducere) este că unitățile pot fi configurate cu un comutator fizic pentru a face ca un anumit soclu să răspundă unui anumit set de butoane ON / OFF de pe receptor. Acest lucru înseamnă, de asemenea, că puteți deconecta și muta prizele în jurul casei știind că fiecare unitate va răspunde întotdeauna la aceleași semnale ON / OFF.

După ce ați aflat modul în care prizele dvs. interacționează cu receptorul, va trebui să utilizați unitatea de recepție de 433 MHz (în imaginea de mai sus) pentru a „adulmeca” codurile trimise de receptor. Odată ce ați înregistrat formele de undă ale acestor coduri, le puteți reproduce folosind Python și le puteți trimite folosind unitatea transmițătoare.

Primul lucru de făcut aici este să conectați pinii receptorului la pinii GPIO corecți de pe Pi. Unitatea receptor are patru pini, dar sunt necesari doar trei. Cred că ambii pini centrali oferă aceeași ieșire, deci trebuie doar să vă conectați la unul dintre ei (cu excepția cazului în care doriți să transmiteți semnalele recepționate la doi pini GPIO separați).

Imaginea de mai sus rezumă destul de mult cablarea. Fiecare pin de pe receptor poate fi conectat direct la pinul corespunzător de pe Pi. Folosesc o placă de cablu și cabluri jumper pentru a face procesul mai elegant. Rețineți că puteți alege orice pin de date GPIO pentru a vă conecta la oricare dintre pinii receptorului central. Am folosit pinul marcat ca „23” pe antetul meu Pi.

IMPORTANT: Dacă conectați pinul marcat „3v3” în imaginea de mai sus la un pin de tensiune mai mare de pe Pi (de exemplu, 5v), probabil că veți deteriora Pi, deoarece pinii GPIO nu pot tolera tensiuni peste 3v3. Alternativ, îl puteți alimenta cu 5v și configura un divizor de tensiune pentru a trimite o tensiune sigură la pinul DATA.

Gama receptorului nu va fi foarte mare la această tensiune, mai ales dacă nu este conectată o antenă. Cu toate acestea, nu aveți nevoie de o rază lungă de acțiune aici - atâta timp cât receptorul poate prelua semnalele de pe receptor atunci când acestea sunt ținute unul lângă celălalt, de asta avem nevoie doar.

Pasul 2: Adulmecarea codurilor receptorului

Acum că receptorul dvs. este conectat la Pi, puteți începe prima etapă interesantă a acestui proiect - sniff. Aceasta implică utilizarea scriptului Python atașat pentru a înregistra semnalul transmis de receptor atunci când fiecare buton este apăsat. Scriptul este foarte simplu și v-aș recomanda cu nerăbdare să aruncați o privire înainte de al rula - până la urmă, scopul acestui proiect este că nu veți rula doar orbește codul altcuiva!

Înainte de a începe acest proces, va trebui să vă asigurați că aveți bibliotecile Python necesare pentru a rula scriptul sniffer. Acestea sunt listate în partea de sus a scriptului:

din datetime import datetime

import matplotlib.pyplot ca pyplot import RPi. GPIO ca GPIO

Bibliotecile RPi. GPIO și datetime au fost incluse cu distribuția mea Raspbian, dar a trebuit să instalez biblioteca matplotlib după cum urmează:

sudo apt-get install python-matplotlib

Această bibliotecă este o bibliotecă de reprezentare a graficelor utilizată în mod obișnuit, care este foarte utilă chiar și în afara acestui proiect, deci instalarea acesteia cu siguranță nu poate afecta! Odată ce bibliotecile dvs. sunt actualizate, sunteți gata să începeți înregistrarea datelor. Iată cum funcționează scenariul:

Când este rulat (utilizând comanda 'python ReceiveRF.py'), va configura pinul GPIO definit ca intrare de date (pinul 23 implicit). Apoi va testa în mod continuu pinul și va înregistra dacă acesta primește un digital 1 sau 0. Acest lucru continuă pentru o durată stabilită (5 secunde în mod implicit). Când această limită de timp este atinsă, scriptul va opri înregistrarea datelor și va închide intrarea GPIO. Apoi efectuează puțină post-procesare și trasează valoarea de intrare primită în funcție de timp. Din nou, dacă aveți întrebări despre ceea ce face scriptul, probabil că le puteți răspunde singur după ce ați analizat cum funcționează. Am încercat să fac codul cât mai ușor de citit și mai simplu posibil.

Ce trebuie să faceți este să căutați când scriptul indică faptul că a început ** Înregistrarea **. Odată ce apare acest mesaj, trebuie să apăsați și să țineți apăsat unul dintre butoanele de pe receptor timp de aproximativ o secundă. Asigurați-vă că îl țineți aproape de receptor. Odată ce scriptul a terminat de înregistrat, va folosi matplotlib pentru a trasa o formă de undă grafică a semnalului pe care l-a primit în timpul intervalului de înregistrare. Vă rugăm să rețineți, dacă sunteți conectat la Pi utilizând un client SSH, cum ar fi PuTTY, va trebui, de asemenea, să deschideți o aplicație X11 pentru a permite afișarea formei de undă. Folosesc xMing pentru acest lucru (și pentru alte lucruri, cum ar fi transferul de la distanță în Pi). Pentru a permite afișarea complotului, pur și simplu porniți xMing înainte de a rula scriptul și așteptați să apară rezultatele.

Odată ce apare fereastra matplotlib, zona de interes din complot ar trebui să fie destul de evidentă. Puteți utiliza comenzile din partea de jos a ferestrei pentru a mări până când veți putea selecta maximele și minimele semnalului transmis de receptor în timp ce butonul a fost ținut apăsat. Vedeți imaginea de mai sus pentru un exemplu de cod complet. Semnalul va consta probabil din impulsuri foarte scurte separate de perioade similare de timp în care nu se recepționează semnal. Acest bloc de impulsuri scurte va fi probabil urmat de o perioadă mai lungă în care nu se primește nimic, după care modelul se va repeta. După ce ați identificat modelul care aparține unei singure instanțe a codului, faceți o captură de ecran de genul acesta în partea de sus a acestei pagini și continuați cu pasul următor pentru al interpreta.

Pasul 3: Transcrierea semnalului rezultat

Acum că ați identificat blocul de maxime și minime periodice corespunzător semnalului unui anumit buton, veți avea nevoie de un mod de stocare și interpretare a acestuia. În exemplul de semnal de mai sus, veți observa că există doar două modele unice care alcătuiesc întregul bloc de semnal. Uneori vedeți un maxim scurt urmat de un minim lung și uneori este opusul - un maxim lung urmat de un minim scurt. Când mi-am transcris semnalele, am decis să folosesc următoarea convenție de denumire:

1 = short_on + long_off0 = long_on + short_off

Uită-te din nou la forma de undă etichetată și vei vedea la ce mă refer. Odată ce ați identificat modelele echivalente din semnalul dvs., tot ce trebuie să faceți este să numărați 1 și 0 pentru a construi secvența. Când este transcris, semnalul de mai sus poate fi scris după cum urmează:

1111111111111010101011101

Acum trebuie doar să repetați acest proces pentru a înregistra și transcrie semnalele corespunzătoare celorlalte butoane de pe receptor și ați finalizat prima parte a procesului!

Înainte de a putea retrimite semnalele folosind transmițătorul, mai este ceva de făcut. Timpul dintre maxime și minime corespunzător unui 1 sau un 0 este foarte important și trebuie să vă asigurați că știți cât durează de fapt un „short_on” sau un „long_off”. Pentru codurile mele, existau trei informații de sincronizare pe care trebuia să le extrag pentru a reproduce semnalele:

• Durata unui interval „scurt”, adică începutul unui 1 sau sfârșitul unui 0.
• Durata unui interval „lung”, adică sfârșitul unui 1 sau începutul unui 0.
• Durata unui interval „extins”. Am observat că, când am ținut un buton apăsat pe receptor, a existat o perioadă „extinsă” de la fiecare instanță repetată a blocului de semnal. Această întârziere este utilizată pentru sincronizare și are o durată fixă.

Pentru a determina aceste valori de sincronizare, puteți utiliza funcția de zoom din fereastra matplotlib pentru a mări până la capăt și a plasa cursorul peste părțile relevante ale semnalului. Afișarea locației cursorului în partea de jos a ferestrei ar trebui să vă permită să determinați cât de largă este fiecare parte a semnalului care corespunde unui interval lung, scurt sau extins. Rețineți că axa x a graficului reprezintă timpul, iar componenta x a citirii cursorului este în unități de secunde. Pentru mine, lățimile au fost după cum urmează (în secunde):

• întârziere_curtă = 0,00045
• lung_delay = 0.00090 (de două ori mai lung decât un „scurt”)
• întârziere_extinsă = 0,0096

Pasul 4: Configurarea unității emițătoare

Odată ce ați colectat codurile și datele de sincronizare, vă puteți deconecta unitatea de recepție, deoarece nu veți mai avea nevoie de ea. Apoi puteți conecta transmițătorul direct la pinii GPIO Pi relevanți, așa cum se arată în imaginea de mai sus. Am constatat că pinii de pe unitățile transmițătoare sunt etichetate, ceea ce face procesul mai ușor.

În acest caz, este OK să alimentați unitatea utilizând sursa de 5v din Pi, deoarece pinul DATA nu va trimite semnale către Pi, ci doar le va primi. De asemenea, o sursă de alimentare de 5v va oferi mai multă rază de transmisie decât utilizarea sursei de 3v3. Din nou, puteți conecta pinul DATA la orice pin adecvat de pe Pi. Am folosit pinul 23 (la fel ca la receptor).

Un alt lucru pe care aș recomanda să îl fac este să adăugați o antenă în gaura mică din partea dreaptă sus a transmițătorului. Am folosit o bucată de sârmă dreaptă lungă de 17 cm. Unele surse recomandă un fir spiralat de lungime similară. Nu sunt sigur care este mai bine, dar firul drept îmi oferă suficientă rază pentru a porni / dezactiva prizele din orice locație din micul meu apartament. Cel mai bine este să lipiți antena, dar tocmai am scos o parte din plastic din sârmă și am înfășurat cuprul prin gaură.

Odată ce transmițătorul este conectat, asta este tot setarea hardware realizată! Singurul lucru care rămâne de făcut acum este să vă puneți prizele în jurul casei și să aruncați o privire la programul emițătorului.

Pasul 5: Transmiterea semnalelor utilizând Pi

Aici intervine al doilea script Python. Este conceput pentru a fi la fel de simplu ca primul, dacă nu chiar mai mult. Din nou, vă rugăm să îl descărcați și să căutați peste cod. Va trebui să editați scriptul pentru a transmite semnalele corecte în funcție de datele pe care le-ați înregistrat la pasul 3, așa că este momentul potrivit să aruncați o privire rapidă asupra acestuia.

Bibliotecile necesare pentru a rula acest script au fost toate preinstalate pe Pi-ul meu, deci nu a fost necesară nicio altă instalare. Acestea sunt listate în partea de sus a scriptului:

timpul de import

import sys import RPi. GPIO ca GPIO

Sub importurile bibliotecii se află informațiile pe care va trebui să le editați. Iată cum arată în mod implicit (acestea sunt informațiile corespunzătoare socket-urilor mele, determinate folosind pasul 3):

a_on = '111111111111101010101011101'

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

Aici avem opt șiruri de coduri (două pentru fiecare pereche de butoane de pornire / oprire de pe telefonul meu - este posibil să aveți mai multe sau mai puține coduri) urmate de cele trei informații de sincronizare, de asemenea, determinate la pasul 3. Luați timp pentru a vă asigura că aveți ați introdus corect aceste informații.

Odată ce sunteți mulțumit de codurile / întârzierile pe care le-ați introdus în script (puteți redenumi variabilele șirului de cod dacă doriți), sunteți aproape gata să încercați sistemul! Înainte de a face acest lucru, aruncați o privire la funcția transmit_code () din script. Aici are loc interacțiunea reală cu emițătorul. Această funcție se așteaptă ca unul dintre șirurile de cod să fie trimis ca argument. Apoi deschide pinul definit ca o ieșire GPIO și parcurge fiecare caracter din șirul de cod. Apoi pornește sau oprește emițătorul în funcție de informațiile de sincronizare pe care le-ați introdus pentru a construi o formă de undă care să corespundă șirului de cod. Trimite fiecare cod de mai multe ori (10 în mod implicit) pentru a reduce șansa ca acesta să fie ratat și lasă un întârziere extinsă între fiecare bloc de cod, la fel ca receptorul.

Pentru a rula scriptul, puteți utiliza următoarea sintaxă de comandă:

python TransmitRF.py code_1 code_2 …

Puteți transmite mai multe șiruri de coduri cu o singură rulare a scriptului. De exemplu, pentru a activa socket-urile (a) și (b) și socket-ul (c), rulați scriptul cu următoarea comandă:

python TransmitRF.py a_on b_on c_off

Pasul 6: o notă privind precizia de sincronizare

După cum sa menționat, timpul dintre impulsurile de pornire / oprire transmise este destul de important. Scriptul TransmitRF.py folosește funcția python time.sleep () pentru a construi formele de undă cu intervalele de impuls corecte, dar trebuie remarcat faptul că această funcție nu este pe deplin precisă. Lungimea pentru care face ca scriptul să aștepte înainte de a executa următoarea operație poate depinde de încărcarea procesorului în acel moment dat. Acesta este un alt motiv pentru care TransmitRF.py trimite fiecare cod de mai multe ori - doar în cazul în care funcția time.sleep () nu este capabilă să construiască corect o instanță dată a codului.

Personal, nu am avut niciodată probleme cu time.sleep () atunci când vine vorba de trimiterea codurilor. Cu toate acestea, știu că time.sleep () tinde să aibă o eroare de aproximativ 0,1 ms. Am determinat acest lucru folosind scriptul SleepTest.py atașat, care poate fi folosit pentru a oferi o estimare a cât de precisă este funcția Pi a dvs. time.sleep (). Pentru prizele mele cu telecomandă, cea mai scurtă întârziere de care aveam nevoie pentru a fi implementată a fost de 0,45 ms. După cum am spus, nu am avut probleme cu soclurile care nu răspund, așa că se pare că 0,45 ± 0,1 ms este suficient de bun.

Există și alte metode pentru a se asigura că întârzierea este mai precisă; de exemplu, ați putea folosi un cip PIC dedicat pentru a genera codurile, dar lucruri de genul acesta depășesc sfera acestui tutorial.

Pasul 7: Concluzie

Acest proiect a prezentat o metodă pentru controlul oricărui aparat electric folosind un Raspberry Pi și un set de prize 433MHz controlate de la distanță, cu accent pe simplitate și transparență. Acesta este cel mai interesant și flexibil proiect pentru care am folosit Pi-ul meu și există aplicații nelimitate pentru acesta. Iată câteva lucruri pe care le pot face acum datorită Pi-ului meu:

• Porniți un încălzitor electric lângă patul meu cu o jumătate de oră înainte să se declanșeze alarma.
• Opriți încălzitorul la o oră după ce m-am culcat.
• Aprindeți lumina noptierei când se declanșează alarma, astfel încât să nu mă culc din nou.
• si multe altele…

Pentru majoritatea acestor sarcini, folosesc funcția crontab în Linux. Acest lucru vă permite să configurați activități programate automate pentru a rula scriptul TransmitRF.py la anumite ore. De asemenea, puteți utiliza Linux la comandă pentru a rula sarcini unice (care, pentru mine, trebuiau instalate separat folosind „sudo apt-get install at”). De exemplu, pentru a porni încălzitorul cu o jumătate de oră înainte ca alarma să se declanșeze a doua zi dimineață, tot ce trebuie să fac este să tastați:

la 05:30

python TransmitRF.py c_on

De asemenea, ați putea folosi acest proiect împreună cu sistemul meu de monitorizare a casei Dropbox pentru a controla aparatele pe internet! Vă mulțumim pentru lectură și, dacă doriți să clarificați ceva sau să vă împărtășiți părerea, vă rugăm să postați un comentariu!