Supereenvoudige Raspberry Pi 433MHz domotica - Ajarnpa

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:17

Deze tutorial is een van de vele als het gaat om het gebruik van een Raspberry Pi om draadloze apparaten in huis te bedienen. Net als vele anderen, zal het je laten zien hoe je een goedkoop zender / ontvanger-paar gebruikt dat is aangesloten op je Pi om te communiceren met apparaten die werken op de veelgebruikte 433 MHz-radiofrequentieband. Het zal je specifiek laten zien hoe je elk elektrisch apparaat aan of uit kunt zetten met je Pi door commando's te verzenden naar een set van 433MHz op afstand bestuurbare stopcontacten.

Waarom heb ik deze tutorial gemaakt als er al zoveel bestaan? Vooral omdat vrijwel alle andere tutorials die ik tegenkwam dingen te ingewikkeld leken te maken, vooral aan de softwarekant. Ik merkte dat ze sterk afhankelijk waren van bibliotheken, scripts of codefragmenten van derden om al het werk te doen. Velen zouden niet eens uitleggen wat de onderliggende code aan het doen was - ze zouden je gewoon vragen om twee of drie stukjes software op je Pi te schuiven en een aantal opdrachten uit te voeren, zonder dat er vragen worden gesteld. Ik wilde echt proberen mijn Pi te gebruiken om elektrische apparaten in en uit mijn huis aan en uit te zetten met behulp van een set 433 MHz op afstand bestuurbare stopcontacten, maar ik wilde mijn eigen versie van het systeem maken die ik kon begrijpen, hopelijk eliminerend de noodzaak om de bibliotheken of scripts van iemand anders gebruiken.

Dat is waar deze tutorial over gaat. De softwarekant van dit systeem bestaat uit twee zeer eenvoudige Python-scripts - één voor het ontvangen en opnemen van signalen, en één voor het terugzenden van deze signalen naar de draadloze stopcontacten. De daadwerkelijke ontvangst/transmissie van het signaal is alleen afhankelijk van de gebruiksvriendelijke RPi. GPIO-bibliotheek die, althans voor mij, vooraf was geïnstalleerd met Raspbian. Deze bibliotheek kan ook rechtstreeks in Python worden geïmporteerd.

Voor dit project heb je nodig:

Een Raspberry Pi. Elk model zou moeten werken, ik heb een alles-in-één starterkit gebruikt, maar misschien heb je alleen de centrale eenheid nodig

Een zender/ontvanger-paar van 433 MHz. De meest gebruikte in dit soort projecten lijken deze te zijn. Het kopen van een pakket van vijf zoals het gekoppelde zorgt ervoor dat je een paar reserveonderdelen hebt

Een set van 433MHz op afstand bedienbare stopcontacten. Ik heb deze gebruikt die ik ten zeerste zou aanbevelen, maar er zijn talloze modellen beschikbaar. Zorg er wel voor dat ze op deze frequentie werken

Enkele accessoires voor het bouwen van circuits. Ik raad aan om een breadboard en wat startkabels te gebruiken om het circuitbouwproces zo eenvoudig mogelijk te maken.

[Als u besluit een van deze producten te kopen, zou ik het zeer op prijs stellen als u de aanbiedingen opent via de bovenstaande links - op die manier krijg ik een klein deel van de winst zonder extra kosten voor u!]

Stap 1: De ontvanger instellen

Voordat je je Pi kunt gebruiken om opdrachten naar de op afstand bestuurbare sockets te sturen, moet je weten op welke specifieke signalen ze reageren. De meeste stopcontacten met afstandsbediening worden geleverd met een handset die kan worden gebruikt om specifieke eenheden in of uit te schakelen. In het geval van degene die ik heb gekocht, heeft de handset vier rijen gepaarde AAN/UIT-knoppen, die elk een AAN- of UIT-signaal naar een bepaalde contactdoos sturen.

Dit roept een vraag op - hoe weten we welke knoppen overeenkomen met welke socket? Dit hangt eigenlijk af van het model dat je hebt. Een van de belangrijkste redenen waarom ik mijn specifieke type socket heb gekozen (gekoppeld in de inleiding) is dat de units kunnen worden geconfigureerd met een fysieke schakelaar om een bepaalde socket te laten reageren op een bepaalde reeks AAN/UIT-knoppen op de handset. Dit betekent ook dat u de stopcontacten kunt loskoppelen en door het hele huis kunt verplaatsen, wetende dat elke unit altijd op dezelfde AAN/UIT-signalen zal reageren.

Als u eenmaal weet hoe uw stopcontacten samenwerken met de handset, moet u uw 433MHz-ontvanger (hierboven afgebeeld) gebruiken om de codes te 'snuiven' die door de handset worden verzonden. Nadat u de golfvormen van deze codes hebt vastgelegd, kunt u ze repliceren met Python en ze verzenden met behulp van de zendereenheid.

Het eerste dat u hier moet doen, is de pinnen op uw ontvanger aansluiten op de juiste GPIO-pinnen op de Pi. De ontvangereenheid heeft vier pinnen, maar er zijn er maar drie nodig. Ik denk dat beide centrale pinnen dezelfde output geven, dus je hoeft er maar één op aan te sluiten (tenzij je de ontvangen signalen naar twee aparte GPIO-pinnen wilt streamen).

De afbeelding hierboven vat de bedrading zo'n beetje samen. Elke pin op de ontvanger kan rechtstreeks worden aangesloten op de corresponderende pin op de Pi. Ik gebruik een breadboard en startkabels om het proces een beetje eleganter te maken. Merk op dat u elke GPIO-gegevenspin kunt kiezen om verbinding te maken met een van de centrale ontvangerpinnen. Ik gebruikte de pin gemarkeerd als '23' op mijn Pi-header.

BELANGRIJK: Als u de pin gemarkeerd met '3v3' in de bovenstaande afbeelding aansluit op een pin met een hogere spanning op de Pi (bijvoorbeeld 5v), beschadigt u de Pi waarschijnlijk omdat de GPIO-pinnen geen spanningen boven 3v3 kunnen verdragen. Als alternatief kunt u hem van stroom voorzien met 5v en een spanningsdeler instellen om een veilige spanning naar de DATA-pin te sturen.

Het bereik van de ontvanger zal bij deze spanning niet erg groot zijn, zeker als er geen antenne is aangesloten. Je hebt hier echter geen groot bereik nodig - zolang de ontvanger de signalen van de handset kan opvangen wanneer ze naast elkaar worden gehouden, is dat alles wat we nodig hebben.

Stap 2: De handsetcodes opsnuiven

Nu je ontvanger is aangesloten op de Pi, kun je beginnen met de eerste spannende fase van dit project - het snuffelen. Dit houdt in dat het bijgevoegde Python-script wordt gebruikt om het signaal op te nemen dat door de handset wordt verzonden wanneer op elke knop wordt gedrukt. Het script is heel eenvoudig en ik raad je ten zeerste aan om het te bekijken voordat je het uitvoert - het punt van dit project is tenslotte dat je niet blindelings de code van iemand anders uitvoert!

Voordat u dit proces start, moet u ervoor zorgen dat u over de Python-bibliotheken beschikt die nodig zijn om het sniffer-script uit te voeren. Ze staan bovenaan het script:

van datetime import datetime

importeer matplotlib.pyplot als pyplot importeer RPi. GPIO als GPIO

De RPi. GPIO- en datetime-bibliotheken werden meegeleverd met mijn Raspbian-distributie, maar ik moest de matplotlib-bibliotheek als volgt installeren:

sudo apt-get install python-matplotlib

Deze bibliotheek is een veelgebruikte bibliotheek voor het plotten van grafieken die ook buiten dit project erg handig is, dus installeren kan zeker geen kwaad! Zodra uw bibliotheken up-to-date zijn, kunt u beginnen met het opnemen van gegevens. Zo werkt het script:

Wanneer het wordt uitgevoerd (met het commando 'python ReceiveRF.py'), zal het de gedefinieerde GPIO-pin configureren als een gegevensinvoer (pin 23 standaard). Het zal dan continu de pin bemonsteren en loggen of het een digitale 1 of 0 ontvangt. Dit gaat door voor een ingestelde duur (standaard 5 seconden). Wanneer deze tijdslimiet is bereikt, stopt het script met het opnemen van gegevens en wordt de GPIO-invoer afgesloten. Vervolgens voert het een kleine nabewerking uit en zet het de ontvangen invoerwaarde uit tegen de tijd. Nogmaals, als je vragen hebt over wat het script doet, kun je deze waarschijnlijk zelf beantwoorden nadat je hebt gekeken hoe het werkt. Ik heb geprobeerd de code zo leesbaar en eenvoudig mogelijk te maken.

Wat u moet doen, is uitkijken wanneer het script aangeeft dat het **Begin met opnemen** is. Zodra dit bericht verschijnt, moet u een van de knoppen op de handset ongeveer een seconde ingedrukt houden. Zorg ervoor dat u het dicht bij de ontvanger houdt. Zodra het script klaar is met opnemen, zal het matplotlib gebruiken om een grafische golfvorm te plotten van het signaal dat het tijdens het opname-interval heeft ontvangen. Let op: als u met uw Pi bent verbonden via een SSH-client zoals PuTTY, moet u ook een X11-toepassing openen om de golfvorm weer te geven. Ik gebruik hiervoor xMing (en voor andere dingen zoals remote-desktopping in mijn Pi). Om de plot te laten zien, start u gewoon xMing voordat u het script uitvoert en wacht u tot de resultaten verschijnen.

Zodra uw matplotlib-venster verschijnt, zou het interessegebied binnen de plot vrij duidelijk moeten zijn. U kunt de bedieningselementen onder aan het venster gebruiken om in te zoomen totdat u de hoogte- en dieptepunten van het signaal kunt onderscheiden dat door de handset wordt verzonden terwijl de knop werd ingedrukt. Zie de bovenstaande afbeelding voor een voorbeeld van een volledige code. Het signaal zal waarschijnlijk bestaan uit zeer korte pulsen, gescheiden door vergelijkbare perioden waarin geen signaal wordt ontvangen. Dit blok van korte pulsen zal waarschijnlijk worden gevolgd door een langere periode waarin niets wordt ontvangen, waarna het patroon zich herhaalt. Zodra je het patroon hebt geïdentificeerd dat bij een enkele instantie van de code hoort, maak je een screenshot zoals dat bovenaan deze pagina en ga je verder met de volgende stap om het te interpreteren.

Stap 3: Transcriberen van het resulterende signaal

Nu je het blok van periodieke hoge en lage tonen hebt geïdentificeerd die overeenkomen met het signaal van een bepaalde knop, heb je een manier nodig om het op te slaan en te interpreteren. In het bovenstaande signaalvoorbeeld zult u merken dat er slechts twee unieke patronen zijn die het hele signaalblok vormen. Soms zie je een korte high gevolgd door een lange low, en soms is het het tegenovergestelde - een lange high gevolgd door een korte low. Toen ik mijn signalen transcribeerde, besloot ik de volgende naamgevingsconventie te gebruiken:

1 = short_on + long_off0 = long_on + short_off

Kijk nog eens naar de gelabelde golfvorm en je zult zien wat ik bedoel. Zodra u de equivalente patronen in uw signaal hebt geïdentificeerd, hoeft u alleen nog maar de enen en nullen te tellen om de reeks op te bouwen. Wanneer getranscribeerd, kan het bovenstaande signaal als volgt worden geschreven:

1111111111111010101011101

Nu hoeft u dit proces alleen maar te herhalen om de signalen op te nemen en te transcriberen die overeenkomen met de andere knoppen op uw handset, en u hebt het eerste deel van het proces voltooid!

Voordat u de signalen opnieuw kunt verzenden met de zender, is er nog wat werk aan de winkel. De timing tussen de hoogte- en dieptepunten die overeenkomen met een 1 of een 0 is erg belangrijk, en je moet ervoor zorgen dat je weet hoe lang een 'short_on' of een 'long_off' eigenlijk duurt. Voor mijn codes waren er drie stukjes timinginformatie die ik moest extraheren om de signalen te repliceren:

• De duur van een 'kort' interval, d.w.z. het begin van een 1 of het einde van een 0.
• De duur van een 'lang' interval, d.w.z. het einde van een 1 of het begin van een 0.
• De duur van een 'verlengd' interval. Ik merkte dat wanneer ik een knop op de handset ingedrukt hield, er een 'extended_off'-periode was tussen elke herhaalde instantie van het signaalblok. Deze vertraging wordt gebruikt voor synchronisatie en heeft een vaste duur.

Om deze timingwaarden te bepalen, kunt u de zoomfunctie in het matplotlib-venster gebruiken om helemaal in te zoomen en de cursor op de relevante delen van het signaal te plaatsen. De uitlezing van de cursorlocatie onderaan het venster zou u moeten toelaten om te bepalen hoe breed elk deel van het signaal is dat overeenkomt met een lang, kort of verlengd interval. Merk op dat de x-as van de grafiek de tijd vertegenwoordigt en dat de x-component van de cursoruitlezing in eenheden van seconden is. Voor mij waren de breedtes als volgt (in seconden):

• korte_vertraging = 0.00045
• long_delay = 0.00090 (twee keer zo lang als een 'short')
• extended_delay = 0,0096

Stap 4: De zender instellen

Zodra u uw codes en timinggegevens hebt verzameld, kunt u uw ontvanger loskoppelen omdat u deze niet langer nodig hebt. U kunt de zender vervolgens rechtstreeks aansluiten op de relevante Pi GPIO-pinnen, zoals weergegeven in de bovenstaande afbeelding. Ik heb ontdekt dat de pinnen op de zendereenheden zijn gelabeld, wat het proces eenvoudiger maakt.

In dit geval is het OK om het apparaat van stroom te voorzien met behulp van de 5v-voeding van de Pi, omdat de DATA-pin geen signalen naar de Pi verzendt, maar deze alleen ontvangt. Ook zal een 5v-voeding meer zendbereik bieden dan het gebruik van de 3v3-voeding. Nogmaals, u kunt de DATA-pin aansluiten op elke geschikte pin op de Pi. Ik gebruikte pin 23 (dezelfde als voor de ontvanger).

Een ander ding dat ik zou aanraden om te doen, is een antenne toe te voegen aan het kleine gaatje in de rechterbovenhoek van de zender. Ik gebruikte een 17 cm lang stuk rechte draad. Sommige bronnen bevelen een opgerolde draad van vergelijkbare lengte aan. Ik weet niet zeker wat beter is, maar de rechte draad biedt voldoende bereik om de stopcontacten vanaf elke locatie in mijn kleine flat aan of uit te zetten. Het is het beste om de antenne te solderen, maar ik heb net een deel van het plastic van de draad verwijderd en het koper door het gat gewikkeld.

Zodra de zender is aangesloten, is de hardware-instelling voltooid! Het enige wat je nu nog hoeft te doen is je stopcontacten in huis ophangen en het zenderprogramma bekijken.

Stap 5: Signalen verzenden met behulp van de Pi

Dit is waar het tweede Python-script om de hoek komt kijken. Het is ontworpen om net zo eenvoudig te zijn als het eerste, zo niet meer. Nogmaals, download het en bekijk de code. U moet het script bewerken om de juiste signalen te verzenden volgens de gegevens die u in stap 3 hebt vastgelegd, dus dit is een goed moment om er een snelle blik op te werpen.

De bibliotheken die nodig waren om dit script uit te voeren, waren allemaal vooraf geïnstalleerd op mijn Pi, dus verdere installatie was niet nodig. Ze staan bovenaan het script:

import tijd

import sys importeer RPi. GPIO als GPIO

Onder de bibliotheekimport staat de informatie die u moet bewerken. Hier is hoe het er standaard uitziet (dit is de informatie die overeenkomt met mijn sockets zoals bepaald met stap 3):

a_on = '111111111111100101011101'

a_off = '1111111111111010101010111' b_on = '1111111111101110101011101' b_off = '111111111110110101010111' c_on = '1111111111101011101011101' c_off = '11111111111010111010111' d_on = '1111111111101110101011101' d11111010 = '1111111111101011101011101' d_on = '1111111111101011101011101' d111110101 = '111110101

Hier hebben we acht codereeksen (twee voor elk paar aan/uit-knoppen op mijn handset - u kunt meer of minder codes hebben) gevolgd door de drie stukjes timinginformatie die ook in stap 3 zijn bepaald. Neem de tijd om ervoor te zorgen dat u deze gegevens correct ingevoerd.

Als je eenmaal tevreden bent met de codes/vertragingen die je in het script hebt ingevoerd (je kunt de codereeksvariabelen desgewenst hernoemen), ben je zo goed als klaar om het systeem uit te proberen! Bekijk voordat u dit doet de functie send_code() in het script. Hier vindt de daadwerkelijke interactie met de zender plaats. Deze functie verwacht dat een van de codestrings als argument wordt verzonden. Het opent vervolgens de gedefinieerde pin als een GPIO-uitvoer en loopt door elk teken in de codereeks. Vervolgens wordt de zender in- of uitgeschakeld volgens de timinginformatie die u hebt ingevoerd om een golfvorm op te bouwen die overeenkomt met de codereeks. Het verzendt elke code meerdere keren (standaard 10) om de kans te verkleinen dat deze wordt gemist, en laat een extended_delay achter tussen elk codeblok, net als de handset.

Om het script uit te voeren, kunt u de volgende opdrachtsyntaxis gebruiken:

python TransmitRF.py code_1 code_2 …

U kunt meerdere codereeksen verzenden met een enkele uitvoering van het script. Om bijvoorbeeld sockets (a) en (b) aan en socket (c) uit te schakelen, voert u het script uit met de volgende opdracht:

python TransmitRF.py a_on b_on c_off

Stap 6: een opmerking over timingnauwkeurigheid

Zoals gezegd is de timing tussen de uitgezonden aan/uit-pulsen vrij belangrijk. Het TransmitRF.py-script gebruikt de functie time.sleep() van python om de golfvormen met de juiste pulsintervallen op te bouwen, maar het moet worden opgemerkt dat deze functie niet helemaal nauwkeurig is. De lengte waarvoor het script wacht voordat de volgende bewerking wordt uitgevoerd, kan afhangen van de processorbelasting op dat moment. Dat is nog een reden waarom TransmitRF.py elke code meerdere keren verzendt - voor het geval de functie time.sleep() niet in staat is om een bepaald exemplaar van de code correct te construeren.

Ik heb persoonlijk nooit problemen gehad met time.sleep() als het gaat om het verzenden van de codes. Ik weet echter wel dat mijn time.sleep() een fout van ongeveer 0,1 ms heeft. Ik heb dit bepaald met behulp van het bijgevoegde SleepTest.py-script dat kan worden gebruikt om een schatting te geven van hoe nauwkeurig de time.sleep()-functie van je Pi is. Voor mijn specifieke op afstand bediende sockets was de kortste vertraging die ik moest implementeren 0,45 ms. Zoals ik al zei, heb ik geen problemen gehad met niet-reagerende sockets, dus het lijkt erop dat 0,45 ± 0,1 ms goed genoeg is.

Er zijn andere methoden om ervoor te zorgen dat de vertraging nauwkeuriger is; je zou bijvoorbeeld een speciale PIC-chip kunnen gebruiken om de codes te genereren, maar dat soort dingen valt buiten het bestek van deze tutorial.

Stap 7: Conclusie

Dit project heeft een methode gepresenteerd voor het besturen van elk elektrisch apparaat met behulp van een Raspberry Pi en een set van 433MHz op afstand bedienbare stopcontacten, met een focus op eenvoud en transparantie. Dit is het meest opwindende en flexibele project waarvoor ik mijn Pi heb gebruikt, en er zijn onbeperkte toepassingen voor. Hier zijn enkele dingen die ik nu kan doen dankzij mijn Pi:

• Zet een half uur voordat mijn wekker afgaat een elektrische kachel naast mijn bed aan.
• Zet de verwarming uit een uur nadat ik ben gaan slapen.
• Zet mijn bedlampje aan als mijn wekker afgaat, zodat ik niet weer in slaap val.
• en nog veel meer…

Voor de meeste van deze taken gebruik ik de crontab-functie binnen Linux. Hiermee kunt u automatisch geplande taken instellen om het TransmitRF.py-script op specifieke tijden uit te voeren. Je kunt ook het Linux at-commando gebruiken om eenmalige taken uit te voeren (die voor mij afzonderlijk moesten worden geïnstalleerd met 'sudo apt-get install at'). Om bijvoorbeeld mijn verwarming een half uur voordat mijn wekker de volgende ochtend afgaat aan te zetten, hoef ik alleen maar te typen:

om 05:30

python TransmitRF.py c_on

Je zou dit project ook kunnen gebruiken in combinatie met mijn Dropbox-thuismonitoringsysteem om apparaten via internet te bedienen! Bedankt voor het lezen, en als je iets wilt verduidelijken of je mening wilt delen, plaats dan een reactie!