Superenkel Raspberry Pi 433MHz hjemmeautomatisering: 7 trinn

2024 Forfatter: John Day | [email protected]. Sist endret: 2024-01-30 11:24

Denne opplæringen er en av mange når det gjelder bruk av en Raspberry Pi for å kontrollere trådløse enheter rundt i hjemmet. Som mange andre vil det vise deg hvordan du bruker et billig sender/mottakerpar som er koblet til din Pi for å samhandle med enheter som opererer på det vanlige 433MHz radiofrekvensbåndet. Det vil spesifikt vise deg hvordan du slår en elektrisk enhet på eller av ved hjelp av Pi ved å overføre kommandoer til et sett med 433MHz fjernstyrte stikkontakter.

Hvorfor opprettet jeg denne opplæringen hvis så mange allerede eksisterer? Hovedsakelig fordi stort sett alle de andre opplæringsprogrammene jeg kom over syntes å overkomplisere ting, spesielt på programvaresiden. Jeg la merke til at de stolte sterkt på tredjepartsbiblioteker, skript eller kodebiter for å gjøre alt arbeidet. Mange ville ikke engang forklare hva den underliggende koden gjorde - de ville bare be deg om å skyve to eller tre stykker programvare på din Pi og utføre en haug med kommandoer, ingen spørsmål. Jeg hadde veldig lyst til å prøve å bruke Pi til å slå elektriske enheter på og av rundt hjemmet mitt ved hjelp av et sett med 433MHz fjernkontrollerte kontakter, men jeg ønsket å lage min egen versjon av systemet som jeg kunne forstå, forhåpentligvis eliminere behovet for bruke andres biblioteker eller skript.

Det er det denne opplæringen handler om. Programvaresiden til dette systemet består av to veldig enkle Python -skript - ett for mottak og registrering av signaler, og ett for overføring av disse signalene tilbake til de trådløse stikkontaktene. Selve mottak/overføring av signalet er bare avhengig av det brukervennlige RPi. GPIO-biblioteket som, i hvert fall for meg, ble forhåndsinstallert med Raspbian. Dette biblioteket kan også importeres direkte til Python.

For dette prosjektet trenger du:

En bringebær Pi. Enhver modell burde fungere. Jeg brukte et alt-i-ett-startsett, men kanskje trenger du bare sentralenheten

Et 433MHz sender/mottakerpar. De som er mest brukt i denne typen prosjekter ser ut til å være disse. Å kjøpe en pakke med fem som den som er koblet, sikrer at du har noen få reservedeler

Et sett med 433MHz fjernstyrte stikkontakter. Jeg brukte disse som jeg vil anbefale på det sterkeste, men det finnes utallige modeller tilgjengelig. Bare sørg for at de opererer på denne frekvensen

Noen kretsbyggende tilbehør. Jeg vil anbefale å bruke et brødbrett og noen startkabler for å gjøre kretsbyggingsprosessen så enkel som mulig.

[Hvis du bestemmer deg for å kjøpe noen av disse produktene, ville jeg sette stor pris på det hvis du får tilgang til listene ved hjelp av koblingene ovenfor - på den måten får jeg en liten andel av fortjenesten uten ekstra kostnad for deg!]

Trinn 1: Sette opp mottakerenheten

Før du kan bruke Pi til å sende kommandoer til de fjernstyrte stikkontaktene, må du vite hvilke spesifikke signaler de reagerer på. De fleste fjernstyrte stikkontakter leveres med et håndsett som kan brukes til å slå bestemte enheter på eller av. Når det gjelder de jeg kjøpte, har håndsettet fire rader med sammenkoblede PÅ/AV -knapper, som hver sender et PÅ- eller AV -signal til en bestemt kontakt.

Dette gir et spørsmål - hvordan vet vi hvilke knapper som tilsvarer hvilken kontakt? Dette avhenger faktisk av modellen du har. En av hovedgrunnene til at jeg valgte min spesielle stikkontakt (lenket i innledningen) er at enhetene kan konfigureres med en fysisk bryter for å få en bestemt kontakt til å reagere på et bestemt sett med PÅ/AV -knapper på håndsettet. Dette betyr også at du kan koble fra og flytte stikkontaktene rundt i huset vel vitende om at hver enhet alltid vil svare på de samme PÅ/AV -signalene.

Når du har funnet ut hvordan kontaktene dine samhandler med håndsettet, må du bruke din 433MHz mottaker (bildet ovenfor) for å "snuse" kodene som sendes ut av håndsettet. Når du har registrert bølgeformene til disse kodene, kan du replikere dem ved hjelp av Python og sende dem ut ved hjelp av senderenheten.

Det første du må gjøre her er å koble pinnene på mottakeren til de riktige GPIO -pinnene på Pi. Mottakerenheten har fire pinner, men bare tre av dem er nødvendige. Jeg tror at begge de sentrale pinnene gir samme utgang, så du trenger bare å koble til en av dem (med mindre du vil streame de mottatte signalene til to separate GPIO -pinner).

Bildet ovenfor oppsummerer stort sett ledningene. Hver pinne på mottakeren kan kobles direkte til den tilsvarende pinnen på Pi. Jeg bruker et brødbrett og startkabler for å gjøre prosessen litt mer elegant. Vær oppmerksom på at du kan velge hvilken som helst GPIO -datapinne for å koble til en av de sentrale mottakerpinnene. Jeg brukte pinnen merket som '23' på Pi -hodet mitt.

VIKTIG: Hvis du kobler pinnen merket '3v3' i bildet ovenfor til en pin med høyere spenning på Pi (f.eks. 5v), vil du sannsynligvis skade Pi da GPIO -pinnene ikke tåler spenninger over 3v3. Alternativt kan du slå den på med 5v og sette opp en spenningsdeler for å sende en sikker spenning til DATA -pinnen.

Rekkevidden til mottakeren vil ikke være veldig stor ved denne spenningen, spesielt hvis en antenne ikke er tilkoblet. Du trenger imidlertid ikke en lang rekkevidde her - så lenge mottakeren kan hente signalene fra håndsettet når de holdes like ved siden av hverandre, er det alt vi trenger.

Trinn 2: Sniffing av håndsettkodene

Nå som mottakeren er koblet til Pi, kan du starte den første spennende fasen av dette prosjektet - sniffen. Dette innebærer å bruke det vedlagte Python -skriptet til å registrere signalet som sendes av håndsettet når du trykker på hver knapp. Skriptet er veldig enkelt, og jeg vil anbefale deg å ta en titt på det før du kjører det - tross alt er poenget med dette prosjektet at du ikke bare blindt kjører andres kode!

Før du starter denne prosessen, må du sørge for at du har Python -bibliotekene som trengs for å kjøre sniffer -skriptet. De er oppført øverst i manuset:

fra datetime import datetime

importer matplotlib.pyplot som pyplot importer RPi. GPIO som GPIO

RPi. GPIO- og datetime -bibliotekene ble inkludert i min Raspbian -distribusjon, men jeg måtte installere matplotlib -biblioteket som følger:

sudo apt-get install python-matplotlib

Dette biblioteket er et ofte brukt grafplottingsbibliotek som er veldig nyttig selv utenfor dette prosjektet, så det kan definitivt ikke skade å installere det! Når bibliotekene dine er oppdaterte, er du klar til å begynne å registrere data. Slik fungerer skriptet:

Når den kjøres (ved hjelp av kommandoen 'python ReceiveRF.py'), vil den konfigurere den definerte GPIO -pinnen som en datainngang (pin 23 som standard). Den vil deretter kontinuerlig prøve pinnen og logge om den mottar en digital 1 eller 0. Dette fortsetter i en angitt varighet (5 sekunder som standard). Når denne tidsgrensen er nådd, stopper skriptet opptak av data og stenger GPIO -inngangen. Den utfører deretter litt etterbehandling og plotter den mottatte inngangsverdien mot tiden. Igjen, hvis du har spørsmål om hva skriptet gjør, kan du sannsynligvis svare på dem selv etter å ha sett på hvordan det fungerer. Jeg har prøvd å gjøre koden så lesbar og enkel som mulig.

Det du trenger å gjøre er å se etter når skriptet indikerer at det har ** Startet opptak **. Når denne meldingen vises, bør du trykke og holde inne en av knappene på håndsettet i omtrent et sekund. Sørg for å holde den nær mottakeren. Når skriptet er ferdig med innspillingen, vil det bruke matplotlib til å plotte en grafisk bølgeform for signalet det har mottatt i løpet av opptaksintervallet. Vær oppmerksom på at hvis du er koblet til Pi -en din med en SSH -klient som PuTTY, må du også åpne en X11 -applikasjon for å la bølgeformen vises. Jeg bruker xMing til dette (og til andre ting, for eksempel fjerning av datamaskinen til Pi-en min). For å la plottet vises, bare start xMing før du kjører skriptet og venter på at resultatene skal vises.

Når matplotlib -vinduet ditt vises, bør interesseområdet i tomten være ganske åpenbart. Du kan bruke kontrollene nederst i vinduet for å zoome inn til du kan velge høyder og nedturer for signalet som sendes av håndsettet mens knappen ble holdt nede. Se bildet ovenfor for et eksempel på en komplett kode. Signalet vil trolig bestå av svært korte pulser atskilt med lignende tidsperioder der det ikke mottas noe signal. Denne blokken med korte pulser vil trolig bli fulgt av en lengre periode der ingenting mottas, hvoretter mønsteret vil gjenta seg. Når du har identifisert mønsteret som tilhører en enkelt forekomst av koden, tar du et sånt skjermbilde øverst på denne siden, og fortsetter til neste trinn for å tolke det.

Trinn 3: Transkribering av det resulterende signalet

Nå som du har identifisert blokken med periodiske høyder og nedturer som tilsvarer signalet til en bestemt knapp, trenger du en måte å lagre og tolke det på. I signaleksemplet ovenfor vil du legge merke til at det bare er to unike mønstre som utgjør hele signalblokken. Noen ganger ser du en kort høy etterfulgt av en lang lav, og noen ganger er det motsatt - en lang høy etterfulgt av en kort lav. Da jeg transkriberte signalene mine, bestemte jeg meg for å bruke følgende navnekonvensjon:

1 = short_on + long_off0 = long_on + short_off

Se igjen på den merkede bølgeformen, så ser du hva jeg mener. Når du har identifisert de tilsvarende mønstrene i signalet ditt, er det bare å telle 1 og 0 for å bygge opp sekvensen. Når det transkriberes, kan signalet ovenfor skrives som følger:

1111111111111010101011101

Nå trenger du bare å gjenta denne prosessen for å registrere og transkribere signalene som tilsvarer de andre knappene på håndsettet, og du har fullført den første delen av prosessen!

Før du kan sende signalene på nytt ved hjelp av senderen, er det litt mer arbeid å gjøre. Timingen mellom høyder og nedturer som tilsvarer en 1 eller en 0 er veldig viktig, og du må sørge for at du vet hvor lenge en 'kort_on' eller en 'lang_off' faktisk varer. For kodene mine var det tre deler av tidsinformasjon jeg måtte trekke ut for å replikere signalene:

• Varigheten av et "kort" intervall, dvs. begynnelsen på en 1 eller slutten av en 0.
• Varigheten av et "langt" intervall, dvs. slutten av en 1 eller begynnelsen av en 0.
• Varigheten av et "utvidet" intervall. Jeg la merke til at da jeg holdt en knapp nede på håndsettet, var det en forlenget_off -periode mellom hver gjentatte forekomst av signalblokken. Denne forsinkelsen brukes til synkronisering og har en fast varighet.

For å bestemme disse tidsverdiene kan du bruke zoomfunksjonen i matplotlib -vinduet til å zoome helt inn og plassere markøren over de relevante delene av signalet. Avlesningen av markørplasseringen nederst i vinduet skal tillate deg å bestemme hvor bred hver del av signalet er som tilsvarer et langt, kort eller forlenget intervall. Vær oppmerksom på at x-aksen til plottet representerer tid, og x-komponenten i markøravlesningen er i sekunder. For meg var bredden som følger (i sekunder):

• short_delay = 0,00045
• lang_forsinkelse = 0,00090 (dobbelt så lang som en 'kort')
• forlenget_forsinkelse = 0,0096

Trinn 4: Sette opp senderenheten

Når du har samlet kodene og timedataene dine, kan du koble fra mottakerenheten, siden du ikke lenger trenger den. Du kan deretter koble senderen direkte til de relevante Pi GPIO -pinnene som vist på bildet ovenfor. Jeg har funnet ut at pinnene på senderenhetene er merket, noe som gjør prosessen enklere.

I dette tilfellet er det OK å drive enheten med 5v -forsyningen fra Pi, da DATA -pinnen ikke sender signaler til Pi, bare mottar dem. Dessuten vil en 5v strømforsyning gi mer overføringsområde enn bruk av 3v3 forsyning. Igjen kan du koble DATA -pinnen til en hvilken som helst passende pinne på Pi. Jeg brukte pin 23 (det samme som for mottakeren).

En annen ting jeg vil anbefale å gjøre er å legge til en antenne i det lille hullet øverst til høyre på senderen. Jeg brukte et 17 cm langt stykke rett wire. Noen kilder anbefaler en viklet tråd av lignende lengde. Jeg er ikke sikker på hvilken som er bedre, men den rette ledningen gir nok rekkevidde til at jeg kan slå kontakten av/på fra et hvilket som helst sted i min lille leilighet. Det er best å lodde antennen, men jeg fjernet bare litt av plasten fra ledningen og pakket kobberet gjennom hullet.

Når senderen er koblet til, er alt maskinvareoppsettet gjort! Det eneste du trenger å gjøre nå er å sette opp stikkontaktene rundt huset og se på senderprogrammet.

Trinn 5: Overføre signaler ved hjelp av Pi

Det er her det andre Python -skriptet kommer inn. Det er designet for å være like enkelt som det første, om ikke mer. Igjen, vennligst last ned den og se over koden. Du må redigere skriptet for å overføre riktige signaler i henhold til dataene du registrerte i trinn 3, så nå er det på tide å se raskt på det.

Bibliotekene som trengs for å kjøre dette skriptet, var alle forhåndsinstallert på min Pi, så det var ikke nødvendig med ytterligere installasjon. De er oppført øverst i manuset:

importtid

import sys import RPi. GPIO som GPIO

Under bibliotekets import er informasjonen du må redigere. Slik ser det ut som standard (dette er informasjonen som tilsvarer stikkontaktene mine som bestemt ved hjelp av trinn 3):

a_on = '1111111111111011001011101101'

a_off = '1111111111111010101010111' b_on = '1111111111101110101011101' b_off = '1111111111101110101010111' c_on = '1111111111101011101011101' c_off = '1111111111101011101010111' d_on = '1111111111101010111011101 '1100111011001100110011001100110011 (Åre)

Her har vi åtte kodestrenger (to for hvert par av/på -knapper på håndsettet mitt - du kan ha flere eller færre koder) etterfulgt av de tre delene av tidsinformasjon også bestemt i trinn 3. Ta deg tid til å kontrollere at du har angitt denne informasjonen riktig.

Når du er fornøyd med kodene/forsinkelsene du har angitt i skriptet (du kan gi nytt navn til kodestrengvariablene), er du ganske klar til å prøve ut systemet! Før du gjør det, ta en titt på funksjonen transmit_code () i skriptet. Det er her det faktiske samspillet med senderen skjer. Denne funksjonen forventer at en av kodestrengene skal sendes inn som et argument. Den åpner deretter den definerte pinnen som en GPIO -utgang og går gjennom hvert tegn i kodestrengen. Den slår deretter senderen på eller av i henhold til tidsinformasjonen du skrev inn for å bygge opp en bølgeform som matcher kodestrengen. Den sender hver kode flere ganger (10 som standard) for å redusere sjansen for at den blir savnet, og etterlater en forlenget_forsinkelse mellom hver kodeblokk, akkurat som håndsettet.

For å kjøre skriptet kan du bruke følgende kommandosyntaks:

python TransmitRF.py code_1 code_2 …

Du kan overføre flere kodestrenger med en enkelt kjøring av skriptet. For eksempel, for å slå sockets (a) og (b) på og socket (c) av, kjør skriptet med følgende kommando:

python TransmitRF.py a_on b_on c_off

Trinn 6: En merknad om tidsnøyaktighet

Som nevnt er timingen mellom de overførte på/av -pulser ganske viktig. TransmitRF.py -skriptet bruker pythons time.sleep () -funksjon for å bygge opp bølgeformene med riktige pulsintervaller, men det bør bemerkes at denne funksjonen ikke er helt nøyaktig. Lengden det får skriptet til å vente før den neste operasjonen utføres, kan avhenge av prosessorbelastningen på det gitte øyeblikket. Det er en annen grunn til at TransmitRF.py sender hver kode flere ganger - bare hvis funksjonen time.sleep () ikke er i stand til å konstruere en gitt forekomst av koden på riktig måte.

Jeg har personlig aldri hatt problemer med time.sleep () når det gjelder sending av kodene. Jeg vet imidlertid at min time.sleep () har en tendens til å ha en feil på omtrent 0,1 ms. Jeg bestemte dette ved å bruke det vedlagte SleepTest.py -skriptet som kan brukes til å gi et estimat av hvor nøyaktig din Pi's time.sleep () -funksjon er. For mine spesielle fjernstyrte stikkontakter var den korteste forsinkelsen jeg trengte å implementere 0,45 ms. Som jeg sa, jeg har ikke hatt problemer med ikke-responsive kontakter, så det virker som om 0,45 ± 0,1 ms er bra nok.

Det finnes andre metoder for å sikre at forsinkelsen er mer nøyaktig; for eksempel kan du bruke en dedikert PIC -brikke til å generere kodene, men slike ting er utenfor omfanget av denne opplæringen.

Trinn 7: Konklusjon

Dette prosjektet har presentert en metode for å kontrollere ethvert elektrisk apparat ved hjelp av en Raspberry Pi og et sett med 433MHz fjernstyrte stikkontakter, med fokus på enkelhet og gjennomsiktighet. Dette er det mest spennende og fleksible prosjektet jeg har brukt min Pi til, og det er ubegrensede applikasjoner for det. Her er noen ting jeg kan gjøre takket være min Pi:

• Slå på en elektrisk varmeapparat ved siden av sengen min en halv time før alarmen går.
• Slå av varmeapparatet en time etter at jeg har sovet.
• Slå på nattlyset når alarmen går, slik at jeg ikke sovner igjen.
• og mange flere…

For de fleste av disse oppgavene bruker jeg crontab -funksjonen i Linux. Dette lar deg konfigurere automatiske planlagte oppgaver for å kjøre TransmitRF.py -skriptet på bestemte tidspunkter. Du kan også bruke Linux at-kommandoen til å kjøre engangsoppgaver (som for meg måtte installeres separat ved hjelp av 'sudo apt-get install at'). For eksempel, for å slå på varmeapparatet en halv time før alarmen går neste morgen, er alt jeg trenger å gjøre å skrive:

klokken 05:30

python TransmitRF.py c_on

Du kan også bruke dette prosjektet sammen med Dropbox -hjemmemonitoreringssystemet mitt for å kontrollere apparater over internett! Takk for at du leser, og hvis du vil avklare noe eller dele din mening, vennligst legg ut en kommentar!