Prolunga relè v2.0 - Python & Atmega328p
Ecco presentata la versione 2.0 del modulo per il controllo remoto di elettrodomestici.
Nella versione precedente abbiamo visto i componenti essenziali:
- Una prolunga elettrica, con un'uscita femmina.
- Un microcontrollore con uscita seriale (che collegheremo ad un pc* )
- Un relè che supporti alte tensioni (Io ho scelto un SSR - Solid State Relay ... )
A cui aggiungiamo adesso:
- Alimentatore DC 12V 1A.
- Moduli radio ricevente/trasmittente con frequenza a 433Mhz (una frequenza libera nel nostro paese).
Il codice Python e l'interfaccia web, rimangono INVARIATI, quindi potete utilizzare gli stessi della versione 1.0, che riportiamo qua per comodità:
Codice Python:
import serial
import sys
import time
import os
import win32com.client #incluso nel pacchetto pywin32
import urllib.request
SERIALPORT = input("Inserire la porta seriale a cui e' connesso il dispositivo: ")
# Set up serial port
try:
ser = serial.Serial(SERIALPORT, 9600)
except serial.SerialException:
print('No device connected - exiting...')
time.sleep(4)
sys.exit()
'''
try: #cancelliamo il file dei comandi se non e' in uso.
os.remove('C:\\xampp\\htdocs\\luce\\comando.txt')
except:
pass
'''
print("### Light Module - Jupiter Home-System 1.4 ###\n")
print("In attesa di comandi dall'interfaccia web...")
#COMANDI
def esegui_cmd(comando):
global ser
global on
if comando == "on":
ser.write("m".encode('latin1'))
print("Luce accesa! :)")
elif comando == "off":
ser.write("n".encode('latin1'))
print("Luce spenta...!")
else:
print("Comando non riconosciuto...")
#LISTENING
id_code = 0000
while True:
try:
response = urllib.request.urlopen('http://www.roccomusolino.com/luce/comando.txt')
x = response.read()
x = x.decode("utf-8")
if id_code != x[-4:]:
cmd = x[0:x.index(" ")] #estrae dalla riga solo il comando
esegui_cmd(cmd)
id_code = x[-4:] #aggiorniamo con le 4 cifre dell'id finale (e' di tipo str)
except:
pass
#END
Codice interfaccia:
Play with light!
Codice switch.php per processare il comando ricevuto dall'interfaccia:
Ciò che viene introdotto è una modifica nei codici dei microcontrollori, ora sono 2 e non più 1, ed entrambi montano rispettivamente un modulo per la trasmissione e la ricezione radio a 433Mhz.
La trasmittete TX è collegata in seriale al PC. Come nella foto seguente:
La ricevente RX fa parte del circuito che pilota il relè allo stato solido.
Per ottenere un lavoro pulito, l'arduino è stato inscatolato e viene alimentato attraverso un alimentatore 12V collegato a "T" con la stessa prolunga che alimenterà l'elettrodomestico (usando pin VIN).
Il trasmettitore è collegato al micro-controllore, e grazie alla libreria VirtualWire riceve facilmente comandi dalla trasmittente TX.
Giu qualche foto esplicativa:
Questo è il codice che andrà caricato nell'arduino trasmettitore:
//Transmitter - Arduino connesso in seriale, riceve "m" o "n" da tastiera e spedisce via radio 433mhz le stringhe "on" oppure "off"
#include
int val;
void setup()
{
Serial.begin(9600); // Debugging only
// Initialise the IO and ISR
vw_set_ptt_inverted(true); // Required for DR3100
vw_setup(2000); // Bits per sec
}
void loop()
{
if (Serial.available())
{
val = Serial.read();
Serial.println(val);
if (val == 110) // n = 110 in dec
{
const char *msg = "off";
vw_send((uint8_t *)msg, strlen(msg));
vw_wait_tx(); // Wait until the whole message is gone
}
else if (val == 109) //109 = m in dec
{
const char *msg = "on";
vw_send((uint8_t *)msg, strlen(msg));
vw_wait_tx(); // Wait until the whole message is gone
}
}
delay(200);
}
Questo invece il codice per l'arduino ricevente, che si collega al relè attraverso il pin digitale 8:
// Reicever - Al pin 8 è connesso il relè.
#include
void setup()
{
//Serial.begin(9600); // Debugging only
pinMode(8, OUTPUT);
// Initialise the IO and ISR
vw_set_ptt_inverted(true); // Required for DR3100
vw_setup(2000); // Bits per sec
vw_rx_start(); // Start the receiver PLL running
}
void loop()
{
uint8_t buf[VW_MAX_MESSAGE_LEN];
uint8_t buflen = VW_MAX_MESSAGE_LEN;
if (vw_get_message(buf, &buflen)) // Non-blocking
{
int i;
String x = ""; //conterrà la stringa ricevuta
for (i = 0; i < buflen; i++)
{
//Serial.print(buf[i], HEX);
//Serial.print(" ");
//Serial.print((char) buf[i]); //casting a carattere del codice ascii
x += (char)buf[i];
}
//Serial.println("");
if (x == "on"){ // Se il mex ricevuto è "on"
//Serial.println(x);
digitalWrite(8, HIGH);
}else if(x == "off"){
digitalWrite(8, LOW);
}
}
}
Nei moduli visti in foto, non sono state ancora saldate le due antenne. Come antenna si possono utilizzare fili di rame.. (smaltati o meno, poco cambia, quelli smaltati avranno soltanto una maggiore resistenza all'ossidazione, che comunque non compromette il segnale, dei fili di rame si possono riciclare da cavi telefonici o di rete).
La domanda ora è, quanto devono essere lunghe le antenne? Esiste un modo per calcolare la lunghezza ottimale di un'antenna:
Quando si realizza un'antenna per un dispositivo RF il massimo lo si ottiene con un'antenna che è lunga quanto la lunghezza d'onda (lambda) da trasmettere/ricevere. La formula per calcolare tale lunghezza d'onda è la seguente:
Lambda = v/f
Dove v è la velocità di propagazione nel mezzo di trasmissione, che nell'etere è pari alla velocità della luce, 300.000 Km/s, espressa in metri, ed f è la lunghezza d'onda, in Hertz.
Qiundi per 433 MHz si ha
300.000.000/433.000.000=0,6928 m
Quindi 69,28 cm.
Ora, siccome spesso non è praticabile fare l'antenna di pari lunghezza di lambda, si ricorre alle frazioni.
Quindi si usa lambda mezzi, lambda quarti ecc.. cioè lambda/2, lambda/4 ecc...
Un quarto di lambda nel nostro caso è appunto 69.28/4 = 17.32 cm.
Dunque per una frequenza di 433Mhz necessitiamo di un'antenna di 17.32 cm che è un quarto d'onda della lunghezza ottimale.
Per comodità potete scaricare l'intero software, in versione 2.0, con tanto di interfaccia web, nell'archivio compresso, a questo link: DOWNLOAD SORGENTI.
