Superenkelt Raspberry Pi 433MHz Hemautomation: 7 steg

2024 Författare: John Day | [email protected]. Senast ändrad: 2024-01-30 12:45

Denna handledning är en av många när det gäller att använda en Raspberry Pi för att styra trådlösa enheter i hemmet. Liksom många andra kommer det att visa dig hur du använder ett billigt sändar-/mottagarpar kopplat till din Pi för att interagera med enheter som arbetar på det vanliga 433MHz radiofrekvensbandet. Det kommer specifikt att visa dig hur du slår på eller av någon elektrisk enhet med din Pi genom att överföra kommandon till en uppsättning 433MHz fjärrstyrda eluttag.

Varför skapade jag den här självstudien om det redan finns så många? Främst för att i stort sett alla andra självstudier jag stötte på verkade överkomplicera saker, särskilt på programvarusidan. Jag märkte att de litade starkt på tredjepartsbibliotek, skript eller kodavsnitt för att göra allt arbete. Många skulle inte ens förklara vad den underliggande koden gjorde - de skulle bara be dig att skjuta två eller tre programvaror på din Pi och utföra en massa kommandon, inga frågor. Jag ville verkligen försöka använda min Pi för att slå på och stänga av elektriska enheter runt mitt hem med en uppsättning 433MHz fjärrkontrollerade uttag, men jag ville skapa min egen version av systemet som jag kunde förstå, förhoppningsvis eliminera behovet av använda någon annans bibliotek eller skript.

Det är vad denna handledning handlar om. Programvarans sida av detta system består av två mycket enkla Python -skript - ett för att ta emot och spela in signaler och ett för att överföra dessa signaler tillbaka till de trådlösa eluttagen. Själva mottagningen/överföringen av signalen är endast beroende av det lättanvända RPi. GPIO-biblioteket som, åtminstone för mig, kom förinstallerat med Raspbian. Detta bibliotek kan också importeras direkt till Python.

För detta projekt behöver du:

En hallon Pi. Varje modell borde fungera, jag använde ett allt-i-ett-startpaket, men kanske behöver du bara centralenheten

Ett 433MHz sändar-/mottagarpar. De som oftast används i denna typ av projekt verkar vara dessa. Att köpa ett paket med fem som det länkade garanterar att du har några reservdelar

En uppsättning 433MHz fjärrstyrda eluttag. Jag använde dessa som jag rekommenderar starkt, men det finns otaliga modeller tillgängliga. Se bara till att de fungerar på denna frekvens

Några kretsbyggande tillbehör. Jag rekommenderar att du använder en brödbräda och några bygelkablar för att göra kretsbyggnadsprocessen så enkel som möjligt.

[Om du bestämmer dig för att köpa någon av dessa produkter skulle jag uppskatta det mycket om du får tillgång till listorna med ovanstående länkar - på det sättet får jag en liten del av vinsten utan extra kostnad för dig!]

Steg 1: Konfigurera mottagarenheten

Innan du kan använda din Pi för att skicka kommandon till de fjärrstyrda uttagen måste du veta vilka specifika signaler de svarar på. De flesta fjärrkontrollerade uttag levereras med en handenhet som kan användas för att slå på eller stänga av specifika enheter. När det gäller de jag köpte har handenheten fyra rader med parade PÅ/AV -knappar, som var och en skickar ut en PÅ- eller AV -signal till en viss uttagsenhet.

Detta väcker en fråga - hur vet vi vilka knappar som motsvarar vilket uttag? Detta beror faktiskt på vilken modell du har. En av de främsta anledningarna till att jag valde min speciella uttagstil (länkad i inledningen) är att enheterna kan konfigureras med en fysisk omkopplare för att få ett visst uttag att reagera på en viss uppsättning PÅ/AV -knappar på handenheten. Detta innebär också att du kan koppla ur och flytta uttagen runt huset med vetskap om att varje enhet alltid svarar på samma ON/OFF -signaler.

När du väl har förstått hur dina uttag samverkar med handenheten måste du använda din 433MHz mottagarenhet (bilden ovan) för att "sniffa" de koder som skickas ut av handenheten. När du har registrerat vågformerna för dessa koder kan du replikera dem med Python och skicka ut dem med sändarenheten.

Det första du ska göra här är att ansluta stiften på din mottagare till rätt GPIO -stift på Pi. Mottagarenheten har fyra stift, men bara tre av dem behövs. Jag tror att båda de centrala stiften ger samma utgång, så du behöver bara ansluta till en av dem (om du inte vill strömma de mottagna signalerna till två separata GPIO -stift).

Bilden ovan sammanfattar ganska mycket ledningarna. Varje stift på mottagaren kan kopplas direkt till motsvarande stift på Pi. Jag använder en brödbräda och bygelkablar för att göra processen lite mer elegant. Observera att du kan välja vilken GPIO -datapinne som helst för att ansluta till någon av de centrala mottagarstiften. Jag använde stiftet märkt som '23' på min Pi -rubrik.

VIKTIGT: Om du ansluter stiftet märkt '3v3' i bilden ovan till ett högre spänningsstift på Pi (t.ex. 5v), kommer du förmodligen att skada Pi eftersom GPIO -stiften inte tål spänningar över 3v3. Alternativt kan du driva den med 5v och ställa in en spänningsdelare för att skicka en säker spänning till DATA -stiftet.

Mottagarens räckvidd kommer inte att vara särskilt stort vid denna spänning, särskilt om en antenn inte är ansluten. Du behöver dock inte en lång räckvidd här - så länge mottagaren kan hämta signalerna från handenheten när de hålls bredvid varandra, det är allt vi behöver.

Steg 2: Sniffa upp handenhetskoderna

Nu när din mottagare är ansluten till Pi kan du starta den första spännande etappen av detta projekt - snuset. Detta innebär att man använder det bifogade Python -skriptet för att spela in signalen som sänds av handenheten när varje knapp trycks in. Skriptet är väldigt enkelt, och jag rekommenderar starkt att du tittar på det innan du kör det - trots allt är poängen med det här projektet att du inte bara blindt kör någon annans kod!

Innan du startar den här processen måste du se till att du har de Python -bibliotek som behövs för att köra sniffer -skriptet. De listas högst upp i manuset:

från datetime import datetime

importera matplotlib.pyplot som pyplot importera RPi. GPIO som GPIO

RPi. GPIO- och datetime -biblioteken inkluderades i min Raspbian -distribution, men jag var tvungen att installera matplotlib -biblioteket enligt följande:

sudo apt-get install python-matplotlib

Detta bibliotek är ett vanligt använt grafritningsbibliotek som är mycket användbart även utanför detta projekt, så att installera det kan definitivt inte skada! När dina bibliotek är uppdaterade är du redo att börja spela in data. Så här fungerar skriptet:

När den körs (med kommandot 'python ReceiveRF.py') kommer den att definiera GPIO -stiftet som en datainmatning (pin 23 som standard). Den kommer sedan att ständigt prova pinnen och logga om den tar emot en digital 1 eller 0. Detta fortsätter under en viss varaktighet (5 sekunder som standard). När denna tidsgräns har uppnått, kommer skriptet att sluta spela in data och stänga av GPIO -ingången. Den utför sedan lite efterbehandling och plottar det mottagna ingångsvärdet mot tiden. Återigen, om du har frågor om vad manuset gör, kan du förmodligen svara på dem själv efter att ha tittat på hur det fungerar. Jag har försökt göra koden så läsbar och enkel som möjligt.

Vad du behöver göra är att se upp när skriptet indikerar att det har ** Startat inspelning **. När det här meddelandet visas bör du hålla ned en av knapparna på handenheten i ungefär en sekund. Var noga med att hålla den nära mottagaren. När manuset har slutfört inspelningen kommer det att använda matplotlib för att plotta en grafisk vågform av signalen som den har tagit emot under inspelningsintervallet. Observera att om du är ansluten till din Pi med en SSH -klient som PuTTY måste du också öppna ett X11 -program för att tillåta vågformen att visas. Jag använder xMing för detta (och för andra saker som fjärrskrivbord i min Pi). För att tillåta tomten att visas, starta helt enkelt xMing innan du kör skriptet och vänta på att resultaten ska visas.

När ditt matplotlib -fönster visas bör intresseområdet inom tomten vara ganska uppenbart. Du kan använda kontrollerna längst ner i fönstret för att zooma in tills du kan välja höjd- och nedgångar för signalen som sänds av handenheten medan knappen hölls nedtryckt. Se bilden ovan för ett exempel på en komplett kod. Signalen kommer förmodligen att bestå av mycket korta pulser åtskilda av liknande tidsperioder där ingen signal tas emot. Detta block av korta pulser kommer sannolikt att följas av en längre period där ingenting tas emot, varefter mönstret kommer att upprepas. När du har identifierat mönstret som tillhör en enda instans av koden, ta en sådan skärmdump högst upp på denna sida och fortsätt till nästa steg för att tolka den.

Steg 3: Transkribera den resulterande signalen

Nu när du har identifierat blocket med periodiska toppar och dalar som motsvarar en viss knapps signal, behöver du ett sätt att lagra och tolka det. I exemplet ovan kommer du att märka att det bara finns två unika mönster som utgör hela signalblocket. Ibland ser du en kort hög följt av en lång låg, och ibland är det motsatsen - en lång hög följt av en kort låg. När jag transkriberade mina signaler bestämde jag mig för att använda följande namnkonvention:

1 = short_on + long_off0 = long_on + short_off

Titta igen på den märkta vågformen så ser du vad jag menar. När du väl har identifierat motsvarande mönster i din signal är det bara att räkna 1: orna och 0: orna för att bygga upp sekvensen. Vid transkribering kan ovanstående signal skrivas enligt följande:

1111111111111010101011101

Nu behöver du bara upprepa denna process för att spela in och transkribera signalerna som motsvarar de andra knapparna på din telefon, och du har slutfört den första delen av processen!

Innan du kan skicka signalerna igen med sändaren finns det lite mer arbete att göra. Tiden mellan toppar och nedgångar motsvarande 1 eller 0 är mycket viktig, och du måste se till att du vet hur länge en 'short_on' eller 'long_off' faktiskt varar. För mina koder var det tre bitar av tidsinformation jag behövde extrahera för att replikera signalerna:

• Varaktigheten av ett "kort" intervall, dvs början av ett 1 eller slutet av ett 0.
• Varaktigheten av ett "långt" intervall, dvs slutet av ett 1 eller början av ett 0.
• Varaktigheten av ett "förlängt" intervall. Jag märkte att när jag höll en knapp nedtryckt på handenheten var det en "förlängd_avstängningsperiod" mellan varje upprepad instans av signalblocket. Denna fördröjning används för synkronisering och har en fast varaktighet.

För att bestämma dessa tidsvärden kan du använda zoomfunktionen i matplotlib -fönstret för att zooma in hela vägen och placera markören över de relevanta delarna av signalen. Markörplaceringsavläsningen längst ner i fönstret bör låta dig avgöra hur bred varje del av signalen är som motsvarar ett långt, kort eller förlängt intervall. Observera att x-axeln i diagrammet representerar tid, och x-komponenten i marköravläsningen är i sekunder. För mig var bredderna följande (i sekunder):

• short_delay = 0,00045
• long_delay = 0,00090 (dubbelt så länge som en 'short')
• förlängd_fördröjning = 0,0096

Steg 4: Konfigurera sändarenheten

När du har samlat dina koder och tidsdata kan du koppla bort din mottagarenhet eftersom du inte längre behöver den. Du kan sedan ansluta sändaren direkt till de relevanta Pi GPIO -stiften som visas i bilden ovan. Jag har funnit att stiften på sändarenheterna är märkta, vilket gör processen enklare.

I det här fallet är det OK att driva enheten med 5v -matningen från Pi eftersom DATA -stiftet inte kommer att skicka signaler till Pi, bara ta emot dem. Dessutom kommer en 5v strömförsörjning att ge mer överföringsområde än att använda 3v3 matningen. Återigen kan du ansluta DATA -stiftet till valfri stift på Pi. Jag använde stift 23 (samma som för mottagaren).

En annan sak jag skulle rekommendera att göra är att lägga till en antenn i det lilla hålet längst upp till höger på sändaren. Jag använde en 17 cm lång bit rak tråd. Vissa källor rekommenderar en tråd med liknande längd. Jag är inte säker på vilken som är bättre, men den raka ledningen ger tillräckligt med räckvidd för att jag ska kunna sätta på/stänga av uttagen från valfri plats i min lilla lägenhet. Det är bäst att löda antennen, men jag tog bara bort lite av plasten från tråden och svepte kopparen genom hålet.

När sändaren väl är ansluten är det allt hårdvaruinställning gjort! Det enda som återstår att göra nu är att sätta upp dina uttag runt huset och titta på sändarprogrammet.

Steg 5: Överföring av signaler med Pi

Det är här det andra Python -skriptet kommer in. Det är utformat för att vara lika enkelt som det första, om inte mer. Återigen, ladda ner den och titta över koden. Du måste redigera skriptet för att överföra de korrekta signalerna enligt data som du spelade in i steg 3, så nu är det bra att snabbt titta på det.

De bibliotek som behövs för att köra detta skript var alla förinstallerade på min Pi, så ingen ytterligare installation behövdes. De listas högst upp i manuset:

importtid

importera sys importera RPi. GPIO som GPIO

Under bibliotekets import finns informationen du måste redigera. Så här ser det ut som standard (detta är informationen som motsvarar mina uttag enligt bestämning med steg 3):

a_on = '1111111111111100101101101101'

a_off = '1111111111111010101010111' b_on = '1111111111101110101011101' b_off = '1111111111101110101111111' c_on = '1111111111101011101011101' c_off = '1111111111101011101010111' d_on = '1111111111101010111011101 '11_11001100110011001100111000110011001100110011001100110011 (Åre)

Här har vi åtta kodsträngar (två för varje par på/av -knappar på min handenhet - du kan ha fler eller färre koder) följt av de tre delarna av tidsinformation som också bestäms i steg 3. Ta dig tid att se till att du har angav denna information korrekt.

När du är nöjd med de koder/fördröjningar du har angett i skriptet (du kan byta namn på kodsträngvariablerna om du vill) är du ganska redo att testa systemet! Innan du gör det, ta en titt på funktionen transmit_code () i skriptet. Det är här den faktiska interaktionen med sändaren sker. Denna funktion förväntar sig att en av kodsträngarna ska skickas in som ett argument. Den öppnar sedan den definierade stiftet som en GPIO -utgång och går igenom varje tecken i kodsträngen. Den slår sedan på eller av sändaren enligt den tidsinformation du angav för att bygga upp en vågform som matchar kodsträngen. Den skickar varje kod flera gånger (10 som standard) för att minska risken för att den missas och lämnar en förlängd_fördröjning mellan varje kodblock, precis som handenheten.

För att köra skriptet kan du använda följande kommandosyntax:

python TransmitRF.py code_1 code_2 …

Du kan överföra flera kodsträngar med en enda körning av skriptet. Till exempel, för att slå på sockets (a) och (b) och socket (c), kör manuset med följande kommando:

python TransmitRF.py a_on b_on c_off

Steg 6: En anmärkning om tidsnoggrannhet

Som nämnts är tidpunkten mellan de överförda på/av -pulserna ganska viktig. TransmitRF.py -skriptet använder pythons funktion time.sleep () för att bygga upp vågformerna med rätt pulsintervall, men det bör noteras att denna funktion inte är helt korrekt. Längden för vilken det får skriptet att vänta innan nästa operation utförs kan bero på processorbelastningen vid det givna ögonblicket. Det är en annan anledning till att TransmitRF.py skickar varje kod flera gånger - bara om funktionen time.sleep () inte kan konstruera en given instans av koden korrekt.

Jag har personligen aldrig haft problem med time.sleep () när det gäller att skicka koderna. Jag vet dock att min time.sleep () tenderar att ha ett fel på cirka 0,1 ms. Jag bestämde detta med det bifogade SleepTest.py -skriptet som kan användas för att ge en uppskattning av hur exakt din Pi's time.sleep () -funktion är. För mina speciella fjärrstyrda uttag var den kortaste fördröjningen jag behövde implementera 0,45 ms. Som sagt har jag inte haft problem med icke-mottagliga uttag, så det verkar som att 0,45 ± 0,1 ms är tillräckligt bra.

Det finns andra metoder för att säkerställa att fördröjningen är mer exakt; till exempel kan du använda ett dedikerat PIC -chip för att generera koderna, men sådana saker ligger utanför ramen för denna handledning.

Steg 7: Slutsats

Detta projekt har presenterat en metod för att styra alla elektriska apparater med en Raspberry Pi och en uppsättning 433MHz fjärrkontrollerade uttag, med fokus på enkelhet och transparens. Detta är det mest spännande och flexibla projektet som jag har använt min Pi till, och det finns gränslösa applikationer för det. Här är några saker jag nu kan göra tack vare min Pi:

• Slå på en elvärmare bredvid min säng en halvtimme innan mitt larm går.
• Stäng av värmaren en timme efter att jag har sovit.
• Tänd sänglampan när mitt larm går så att jag inte somnar om.
• och många fler…

För de flesta av dessa uppgifter använder jag crontab -funktionen inom Linux. Detta låter dig konfigurera automatiska schemalagda uppgifter för att köra TransmitRF.py -skriptet vid specifika tidpunkter. Du kan också använda kommandot Linux på för att köra engångsuppgifter (som för mig behövde installeras separat med "sudo apt-get install at"). Till exempel, för att slå på min värmare en halvtimme innan mitt larm går nästa morgon, är allt jag behöver göra att skriva:

klockan 05:30

python TransmitRF.py c_on

Du kan också använda det här projektet tillsammans med mitt Dropbox -hemövervakningssystem för att styra apparater över internet! Tack för att du läste, och om du vill förtydliga något eller dela med dig av din åsikt, skicka en kommentar!