Automazione domestica super semplice Raspberry Pi 433MHz: 7 passaggi

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:03

Questo tutorial è uno dei tanti quando si tratta di utilizzare un Raspberry Pi per controllare i dispositivi wireless in casa. Come molti altri, ti mostrerà come utilizzare una coppia trasmettitore/ricevitore economica collegata al tuo Pi per interagire con i dispositivi che operano sulla banda di frequenza radio 433 MHz comunemente utilizzata. Ti mostrerà in particolare come accendere o spegnere qualsiasi dispositivo elettrico usando il tuo Pi trasmettendo i comandi a una serie di prese di corrente telecomandate a 433 MHz.

Perché ho creato questo tutorial se ne esistono già così tanti? Principalmente perché praticamente tutti gli altri tutorial in cui mi sono imbattuto sembravano complicare eccessivamente le cose, specialmente sul lato software. Ho notato che facevano molto affidamento su librerie, script o frammenti di codice di terze parti per fare tutto il lavoro. Molti non spiegherebbero nemmeno cosa stava facendo il codice sottostante: ti chiederebbero solo di inserire due o tre software sul tuo Pi ed eseguire una serie di comandi, senza fare domande. Volevo davvero provare a usare il mio Pi per accendere e spegnere i dispositivi elettrici intorno alla mia casa usando una serie di prese telecomandate a 433 MHz, ma volevo creare la mia versione del sistema che potessi capire, si spera eliminando la necessità di utilizzare le librerie o gli script di qualcun altro.

Questo è ciò di cui tratta questo tutorial. Il lato software di questo sistema è costituito da due script Python molto semplici: uno per la ricezione e la registrazione dei segnali e uno per la trasmissione di questi segnali alle prese di alimentazione wireless. L'effettiva ricezione/trasmissione del segnale si basa solo sulla libreria RPi. GPIO di facile utilizzo che, almeno per me, è stata preinstallata con Raspbian. Questa libreria può anche essere importata direttamente in Python.

Per questo progetto avrai bisogno di:

Un lampone Pi. Qualsiasi modello dovrebbe funzionare, ho usato uno starter kit all-in-one, ma forse ti serve solo l'unità centrale

Una coppia trasmettitore/ricevitore a 433 MHz. Quelli più comunemente usati in questo tipo di progetti sembrano essere questi. L'acquisto di una confezione da cinque come quella collegata ti assicura di avere alcuni pezzi di ricambio

Un set di prese di corrente telecomandate da 433 MHz. Ho usato questi che consiglio vivamente, ma ci sono innumerevoli modelli disponibili. Assicurati solo che operino su questa frequenza

Alcuni accessori per la costruzione di circuiti. Consiglierei di utilizzare una breadboard e alcuni cavi jumper per rendere il processo di creazione del circuito il più semplice possibile.

[Se decidi di acquistare uno di questi prodotti, ti sarei molto grato se accedi agli elenchi utilizzando i link sopra - in questo modo, ottengo una piccola quota dei profitti senza costi aggiuntivi per te!]

Passaggio 1: configurazione dell'unità di ricezione

Prima di poter usare il tuo Pi per inviare comandi alle prese telecomandate, devi sapere a quali segnali specifici rispondono. La maggior parte delle prese telecomandate viene fornita con un microtelefono che può essere utilizzato per accendere o spegnere unità specifiche. Nel caso di quelli che ho acquistato, il portatile ha quattro file di pulsanti ON/OFF accoppiati, ognuno dei quali invia un segnale ON o OFF a una particolare unità presa.

Questo fa sorgere una domanda: come facciamo a sapere quali pulsanti corrispondono a quale presa? Questo in realtà dipende dal modello che hai. Uno dei motivi principali per cui ho scelto il mio particolare stile di presa (collegato nell'introduzione) è che le unità possono essere configurate con un interruttore fisico per fare in modo che una particolare presa risponda a un particolare set di pulsanti ON/OFF sul telefono. Ciò significa anche che puoi scollegare e spostare le prese in giro per casa sapendo che ogni unità risponderà sempre agli stessi segnali ON/OFF.

Una volta che hai capito come le tue prese interagiscono con il telefono, dovrai usare il tuo ricevitore a 433 MHz (nella foto sopra) per "annusare" i codici inviati dal telefono. Una volta registrate le forme d'onda di questi codici, è possibile replicarle utilizzando Python e inviarle tramite l'unità di trasmissione.

La prima cosa da fare qui è collegare i pin del ricevitore ai pin GPIO corretti sul Pi. L'unità ricevente ha quattro pin, ma ne occorrono solo tre. Penso che entrambi i pin centrali diano la stessa uscita, quindi devi solo connetterti a uno di essi (a meno che tu non voglia trasmettere i segnali ricevuti a due pin GPIO separati).

L'immagine sopra riassume praticamente il cablaggio. Ciascun pin del ricevitore può essere collegato direttamente al pin corrispondente sul Pi. Uso una breadboard e cavi jumper per rendere il processo un po' più elegante. Si noti che è possibile scegliere qualsiasi pin dati GPIO da collegare a uno dei pin del ricevitore centrale. Ho usato il pin contrassegnato come "23" sulla mia intestazione Pi.

IMPORTANTE: se colleghi il pin contrassegnato con "3v3" nell'immagine sopra a un pin a tensione più alta sul Pi (ad es. 5v), probabilmente danneggerai il Pi poiché i pin GPIO non possono tollerare tensioni superiori a 3v3. In alternativa, puoi alimentarlo con 5v e impostare un partitore di tensione per inviare una tensione sicura al pin DATI.

La portata del ricevitore non sarà molto ampia a questa tensione, soprattutto se non è collegata un'antenna. Tuttavia, non è necessario un lungo raggio qui - purché il ricevitore possa ricevere i segnali dal ricevitore quando sono tenuti uno accanto all'altro, questo è tutto ciò di cui abbiamo bisogno.

Passaggio 2: sniffare i codici del telefono

Ora che il tuo ricevitore è collegato al Pi, puoi iniziare la prima entusiasmante fase di questo progetto: l'annusare. Ciò comporta l'utilizzo dello script Python allegato per registrare il segnale trasmesso dal telefono quando viene premuto ciascun pulsante. Lo script è molto semplice e ti consiglio vivamente di dargli un'occhiata prima di eseguirlo - dopotutto, il punto di questo progetto è che non eseguirai alla cieca il codice di qualcun altro!

Prima di iniziare questo processo, dovrai assicurarti di avere le librerie Python necessarie per eseguire lo script sniffer. Sono elencati nella parte superiore dello script:

da datetime import datetime

importa matplotlib.pyplot come pyplot importa RPi. GPIO come GPIO

Le librerie RPi. GPIO e datetime sono state incluse nella mia distribuzione Raspbian, ma ho dovuto installare la libreria matplotlib come segue:

sudo apt-get install python-matplotlib

Questa libreria è una libreria di grafici comunemente usata che è molto utile anche al di fuori di questo progetto, quindi installarla sicuramente non guasta! Una volta che le tue librerie sono aggiornate, sei pronto per iniziare a registrare i dati. Ecco come funziona lo script:

Quando viene eseguito (usando il comando 'python ReceiveRF.py'), configurerà il pin GPIO definito come input di dati (pin 23 per impostazione predefinita). Quindi campiona continuamente il pin e registra se sta ricevendo un 1 o uno 0 digitale. Questo continua per una durata impostata (5 secondi per impostazione predefinita). Quando viene raggiunto questo limite di tempo, lo script interromperà la registrazione dei dati e chiuderà l'input GPIO. Quindi esegue una piccola post-elaborazione e traccia il valore di input ricevuto rispetto al tempo. Di nuovo, se hai domande su cosa sta facendo lo script, probabilmente puoi rispondere tu stesso dopo aver visto come funziona. Ho cercato di rendere il codice il più leggibile e semplice possibile.

Quello che devi fare è fare attenzione quando lo script indica che ha **iniziato la registrazione**. Quando viene visualizzato questo messaggio, è necessario tenere premuto uno dei pulsanti sul ricevitore per circa un secondo. Assicurati di tenerlo vicino al ricevitore. Una volta che lo script ha terminato la registrazione, utilizzerà matplotlib per tracciare una forma d'onda grafica del segnale che ha ricevuto durante l'intervallo di registrazione. Tieni presente che se sei connesso al tuo Pi utilizzando un client SSH come PuTTY, dovrai anche aprire un'applicazione X11 per consentire la visualizzazione della forma d'onda. Uso xMing per questo (e per altre cose come il desktop remoto nel mio Pi). Per consentire la visualizzazione del grafico, avviare semplicemente xMing prima di eseguire lo script e attendere che vengano visualizzati i risultati.

Una volta visualizzata la finestra matplotlib, l'area di interesse all'interno della trama dovrebbe essere abbastanza ovvia. È possibile utilizzare i controlli nella parte inferiore della finestra per ingrandire fino a quando non si è in grado di individuare gli alti e i bassi del segnale trasmesso dal telefono mentre si tiene premuto il pulsante. Vedere l'immagine sopra per un esempio di codice completo. Il segnale sarà probabilmente costituito da impulsi molto brevi separati da periodi di tempo simili in cui non viene ricevuto alcun segnale. Questo blocco di brevi impulsi sarà probabilmente seguito da un periodo più lungo in cui non viene ricevuto nulla, dopodiché il modello si ripeterà. Una volta identificato il pattern appartenente a una singola istanza del codice, fai uno screenshot come quello nella parte superiore di questa pagina e vai al passaggio successivo per interpretarlo.

Passaggio 3: trascrivere il segnale risultante

Ora che hai identificato il blocco di alti e bassi periodici corrispondente al segnale di un particolare pulsante, avrai bisogno di un modo per memorizzarlo e interpretarlo. Nell'esempio del segnale sopra, noterai che ci sono solo due modelli unici che compongono l'intero blocco del segnale. A volte vedi un breve massimo seguito da un lungo minimo, e a volte è l'opposto: un lungo massimo seguito da un breve minimo. Quando stavo trascrivendo i miei segnali, ho deciso di utilizzare la seguente convenzione di denominazione:

1 = short_on + long_off0 = long_on + short_off

Guarda di nuovo la forma d'onda etichettata e vedrai cosa intendo. Una volta identificati i modelli equivalenti nel segnale, tutto ciò che devi fare è contare gli 1 e gli 0 per costruire la sequenza. Una volta trascritto, il segnale di cui sopra può essere scritto come segue:

1111111111111010101011101

Ora devi solo ripetere questo processo per registrare e trascrivere i segnali corrispondenti agli altri pulsanti del tuo telefono e hai completato la prima parte del processo!

Prima di poter inviare nuovamente i segnali utilizzando il trasmettitore, c'è ancora un po' di lavoro da fare. Il tempismo tra i massimi e i minimi corrispondenti a 1 o 0 è molto importante e devi assicurarti di sapere quanto dura effettivamente un "short_on" o un "long_off". Per i miei codici, c'erano tre informazioni di temporizzazione che dovevo estrarre per replicare i segnali:

• La durata di un intervallo "corto", ovvero l'inizio di un 1 o la fine di uno 0.
• La durata di un intervallo "lungo", ovvero la fine di un 1 o l'inizio di uno 0.
• La durata di un intervallo "esteso". Ho notato che quando ho tenuto premuto un pulsante sul ricevitore, c'era un periodo di "extended_off" tra ogni istanza ripetuta del blocco del segnale. Questo ritardo viene utilizzato per la sincronizzazione e ha una durata fissa.

Per determinare questi valori di temporizzazione, è possibile utilizzare la funzione di zoom nella finestra matplotlib per ingrandire completamente e posizionare il cursore sulle parti pertinenti del segnale. La lettura della posizione del cursore nella parte inferiore della finestra dovrebbe consentire di determinare l'ampiezza di ciascuna parte del segnale che corrisponde a un intervallo lungo, breve o esteso. Si noti che l'asse x del grafico rappresenta il tempo e il componente x della lettura del cursore è in unità di secondi. Per me, le larghezze erano le seguenti (in secondi):

• short_delay = 0.00045
• long_delay = 0.00090 (il doppio di un 'short')
• ritardo_esteso = 0.0096

Passaggio 4: configurazione dell'unità trasmettitore

Una volta raccolti i codici e i dati di temporizzazione, puoi scollegare l'unità ricevente poiché non ti servirà più. È quindi possibile collegare il trasmettitore direttamente ai pin GPIO Pi rilevanti come mostrato nell'immagine sopra. Ho scoperto che i pin sulle unità del trasmettitore sono etichettati, il che rende il processo più semplice.

In questo caso, è OK alimentare l'unità utilizzando l'alimentazione 5v dal Pi poiché il pin DATI non invierà segnali al Pi, ma solo li riceverà. Inoltre, un alimentatore 5v fornirà un raggio di trasmissione maggiore rispetto all'utilizzo dell'alimentatore 3v3. Di nuovo, puoi collegare il pin DATA a qualsiasi pin appropriato sul Pi. Ho usato il pin 23 (lo stesso del ricevitore).

Un'altra cosa che consiglierei di fare è aggiungere un'antenna al piccolo foro in alto a destra del trasmettitore. Ho usato un pezzo di filo dritto lungo 17 cm. Alcune fonti consigliano un filo a spirale di lunghezza simile. Non sono sicuro di quale sia il migliore, ma il filo dritto fornisce una portata sufficiente per accendere/spegnere le prese da qualsiasi punto del mio piccolo appartamento. È meglio saldare l'antenna, ma ho appena rimosso parte della plastica dal filo e ho avvolto il rame attraverso il foro.

Una volta che il trasmettitore è cablato, questa è tutta la configurazione hardware fatta! L'unica cosa che resta da fare ora è impostare le prese intorno alla casa e dare un'occhiata al programma del trasmettitore.

Passaggio 5: trasmissione dei segnali utilizzando il Pi

È qui che entra in gioco il secondo script Python. È progettato per essere semplice come il primo, se non di più. Di nuovo, scaricalo e controlla il codice. Dovrai modificare lo script per trasmettere i segnali corretti in base ai dati registrati nel passaggio 3, quindi ora è un buon momento per dargli una rapida occhiata.

Le librerie necessarie per eseguire questo script erano tutte preinstallate sul mio Pi, quindi non sono state necessarie ulteriori installazioni. Sono elencati nella parte superiore dello script:

tempo di importazione

import sys import RPi. GPIO come GPIO

Sotto le importazioni della libreria ci sono le informazioni che dovrai modificare. Ecco come appare per impostazione predefinita (queste sono le informazioni corrispondenti ai miei socket come determinato utilizzando il passaggio 3):

a_on = '11111111111111010101011101'

a_off = '11111111111111010101010111' b_on = '1111111111101110101011101' b_off = '11111111111011101010101111' c_on = '1111111111101011101011101' c_off = '1111111111101011101010111' d_on = '1111111111101000090 = '111111111110101011101111_ritardo lungo 0,001100100 = 0,0000 =11000090 = '11111111111010101'

Qui abbiamo otto stringhe di codice (due per ogni coppia di pulsanti on/off sul mio telefono - potresti avere più o meno codici) seguite dalle tre informazioni sui tempi determinate anche nel passaggio 3. Prenditi il tempo per assicurarti di avere inserito correttamente queste informazioni.

Una volta che sei soddisfatto dei codici/ritardi che hai inserito nello script (puoi rinominare le variabili della stringa di codice se lo desideri), sei praticamente pronto per provare il sistema! Prima di farlo, dai un'occhiata alla funzione translate_code() nello script. È qui che avviene l'effettiva interazione con il trasmettitore. Questa funzione si aspetta che una delle stringhe di codice venga inviata come argomento. Quindi apre il pin definito come output GPIO e scorre ogni carattere nella stringa di codice. Quindi accende o spegne il trasmettitore in base alle informazioni di temporizzazione immesse per creare una forma d'onda che corrisponda alla stringa di codice. Invia ogni codice più volte (10 per impostazione predefinita) per ridurre la possibilità che venga perso e lascia un extended_delay tra ogni blocco di codice, proprio come il portatile.

Per eseguire lo script, puoi utilizzare la seguente sintassi del comando:

python TransmitRF.py codice_1 codice_2 …

È possibile trasmettere più stringhe di codice con una singola esecuzione dello script. Ad esempio, per attivare i socket (a) e (b) e disattivare il socket (c), eseguire lo script con il seguente comando:

python TransmitRF.py a_on b_on c_off

Passaggio 6: una nota sulla precisione dei tempi

Come accennato, la tempistica tra gli impulsi on/off trasmessi è piuttosto importante. Lo script TransmitRF.py utilizza la funzione time.sleep() di python per creare le forme d'onda con gli intervalli di impulso corretti, ma va notato che questa funzione non è del tutto accurata. La durata dell'attesa dello script prima di eseguire l'operazione successiva può dipendere dal carico del processore in quel dato istante. Questo è un altro motivo per cui TransmitRF.py invia ogni codice più volte, nel caso in cui la funzione time.sleep() non sia in grado di costruire correttamente una determinata istanza del codice.

Personalmente non ho mai avuto problemi con time.sleep() quando si tratta di inviare i codici. So tuttavia che il mio time.sleep() tende ad avere un errore di circa 0,1 ms. L'ho determinato utilizzando lo script SleepTest.py allegato che può essere utilizzato per fornire una stima di quanto sia accurata la funzione time.sleep() del tuo Pi. Per le mie particolari prese telecomandate, il ritardo più breve che dovevo implementare era di 0,45 ms. Come ho detto, non ho avuto problemi con i socket che non rispondono, quindi sembra che 0,45 ± 0,1 ms sia abbastanza buono.

Esistono altri metodi per garantire che il ritardo sia più accurato; ad esempio, potresti utilizzare un chip PIC dedicato per generare i codici, ma cose del genere esulano dallo scopo di questo tutorial.

Passaggio 7: conclusione

Questo progetto ha presentato un metodo per controllare qualsiasi elettrodomestico utilizzando un Raspberry Pi e un set di prese telecomandate a 433MHz, con particolare attenzione alla semplicità e alla trasparenza. Questo è il progetto più eccitante e flessibile per cui ho usato il mio Pi e ci sono applicazioni illimitate per questo. Ecco alcune cose che ora posso fare grazie al mio Pi:

• Accendi una stufa elettrica accanto al mio letto mezz'ora prima che suoni la sveglia.
• Spegni il riscaldamento un'ora dopo che sono andato a dormire.
• Accendi la luce del comodino quando suona la sveglia, così non mi riaddormento.
• e molti altri…

Per la maggior parte di queste attività, utilizzo la funzione crontab all'interno di Linux. Ciò consente di impostare attività pianificate automatiche per eseguire lo script TransmitRF.py in orari specifici. Puoi anche usare il comando Linux at per eseguire attività una tantum (che, per me, dovevano essere installate separatamente usando "sudo apt-get install at"). Ad esempio, per accendere il mio riscaldamento mezz'ora prima che la mia sveglia suoni la mattina successiva, tutto ciò che devo fare è digitare:

alle 05:30

python TransmitRF.py c_on

Puoi anche utilizzare questo progetto insieme al mio sistema di monitoraggio domestico Dropbox per controllare gli elettrodomestici su Internet! Grazie per la lettura e se desideri chiarire qualcosa o condividere la tua opinione, per favore pubblica un commento!