radio module with ssr relay and arduino nano

Prolunga relè v2.0 – Python & Atmega328p

0
3 settimane fa
Scritto da Rocco Musolino in ,

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:

<!DOCTYPE html>
 
<html>
<head><title>Play with light!</title>
<script src="jquery-1.9.1.min.js"></script>
 
<script>
 
var k = "off"; //variabile che definisce lo stato della luce sulla pagina web. La inizializziamo ad "off".
 
function toggle(p_val){ //p_val = "on" oppure "off"
if (!(k == p_val)){ // un comando è stato inviato, si invia il comando all'attuatore.
$.get("switch.php", { action: p_val })
.done(function(data) {
//segue codice per switch dell'img.
if (p_val == "on") {
$('#icona_luce').attr("src", "light-on.png");
} else {
$('#icona_luce').attr("src", "light-off.png");
}
k = p_val;
});
}
 
}
 
 
function img_click(){
if (k == "off"){
toggle("on");
}
else
toggle("off");
 
}
 
 
function check_status(){
$.get("switch.php?status", function(data) {
  toggle(data); // a prescindere dal valore, con questa funzione richamata ciclicamente si verifica la sincronizzazione tra pagina web e attuatore.
});
 
}
 
setInterval("check_status()", 3000);
 
</script>
 
</head>
<body>
 
<center>
<br/><br/>
<a href="#" onclick="img_click();"><img src="light-off.png" id="icona_luce" /></a>
 
</center>
 
</body>
</html>

Codice switch.php per processare il comando ricevuto dall’interfaccia:

<?php
 
if (isset($_GET['action'])) {
 
$comando = $_GET['action'];
$comando = preg_replace('/[^a-zA-Z0-9]/', '', $comando); //vengono filtrati tutti i caratteri speciali, disponibili lettere minuscole, maiuscole e numeri.
$ip = $_SERVER['REMOTE_ADDR'];
 
//scriviamo il file di log.txt che ci indica il comando lanciato, a che ora, e da qualche indirizzo IP:
 
// . . .
 
 
//scriviamo il file di comando.txt
 
$filename= "comando.txt";
$file = fopen($filename, "r+") or exit("errore apertura file");
$random = rand(1000,9999);
$str = fwrite($file, "$comando $random");
 
 
}
 
//se è presente il parametro "status", verrà restituito l'ultimo valore nel file di log. Questo parametro viene usato dalla richiesta in AJAX per ottenere il valore.
 
if (isset($_GET['status'])){
$filename = "comando.txt";
$file=fopen($filename,"r") or exit("Impossibile aprire il file!");
$str = fread($file, filesize($filename));
 
echo substr($str, 0, strpos($str, " "));
}
 
?>

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 <VirtualWire.h>
 
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 <VirtualWire.h>
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.

20130308_130432

Prolunga relè v1.0 – Python & Atmega328p

1
1 mese fa
Scritto da Rocco Musolino in ,

Questo progetto, è di facile implementazione e mette in evidenza in alcuni casi, quanto possa essere pratica una prolunga pilotabile da dispositivi mobile e interfacce disparate.

Il progetto consta di 3 componenti hardware e di un software di gestione, che può dialogare con più tipi di interfacce.

Tra i componenti essenziali abbiamo:
- 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 … )

* Vedremo come sia possibile in seguito, con la seconda versione del progetto, permettere il dialogo tra scheda di prototipazione e pc, attraverso moduli radio (frequenze sui 433Mhz).

Il progetto, così composto, permette di accendere qualsiasi abat-jour, toaster, ventilatore, elettrodomestico.. dal web, attraverso una pratica e semplicissima interfaccia web.

Qui di seguito qualche foto del progetto nella versione 1.0:




Qua il codice Python 3.2 (interagisce con la seriale):

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

In questa variante il retrieving dell’informazione viene effettuato a monte. Il comando da eseguire viene preso in remoto sul sito web, che contiene l’interfaccia web.

Qui il codice per il microcontrollore arduino:

int val;
int pin = 8;
 
void setup()
{
pinMode(8, OUTPUT);
Serial.begin(9600);
 
}
 
void loop()
{
if (Serial.available())
{
val = Serial.read();
Serial.println(val);
if (val == 110) // n = 110 in dec
{
 digitalWrite(pin, LOW);
}
else if (val == 109) //109 = m in dec
{
 
  digitalWrite(pin, HIGH);
}
}}

Sotto, una parte dell’interfaccia web, molto semplificata, potenzialmente espandibile (fa già uso di tecnologia AJAX):

<!DOCTYPE html>
 
<html>
<head><title>Play with light!</title>
<script src="jquery-1.9.1.min.js"></script>
 
<script>
 
var k = "off"; //variabile che definisce lo stato della luce sulla pagina web. La inizializziamo ad "off".
 
function toggle(p_val){ //p_val = "on" oppure "off"
if (!(k == p_val)){ // un comando è stato inviato, si invia il comando all'attuatore.
$.get("switch.php", { action: p_val })
.done(function(data) {
//segue codice per switch dell'img.
if (p_val == "on") {
$('#icona_luce').attr("src", "light-on.png");
} else {
$('#icona_luce').attr("src", "light-off.png");
}
k = p_val;
});
}
 
}
 
 
function img_click(){
if (k == "off"){
toggle("on");
}
else
toggle("off");
 
}
 
 
function check_status(){
$.get("switch.php?status", function(data) {
  toggle(data); // a prescindere dal valore, con questa funzione richamata ciclicamente si verifica la sincronizzazione tra pagina web e attuatore.
});
 
}
 
setInterval("check_status()", 3000);
 
</script>
 
</head>
<body>
 
<center>
<br/><br/>
<a href="#" onclick="img_click();"><img src="light-off.png" id="icona_luce" /></a>
 
</center>
 
</body>
</html>

E qui di seguito il file in php che si occupa di salvare l’informazione sull’accensione/spegnimento del dispositivo attraverso la web interface.

File Switch.php:

<?php
 
if (isset($_GET['action'])) {
 
$comando = $_GET['action'];
$comando = preg_replace('/[^a-zA-Z0-9]/', '', $comando); //vengono filtrati tutti i caratteri speciali, disponibili lettere minuscole, maiuscole e numeri.
$ip = $_SERVER['REMOTE_ADDR'];
 
//scriviamo il file di log.txt che ci indica il comando lanciato, a che ora, e da qualche indirizzo IP:
 
// . . .
 
 
//scriviamo il file di comando.txt
 
$filename= "comando.txt";
$file = fopen($filename, "r+") or exit("errore apertura file");
$random = rand(1000,9999);
$str = fwrite($file, "$comando $random");
 
 
}
 
//se è presente il parametro "status", verrà restituito l'ultimo valore nel file di log. Questo parametro viene usato dalla richiesta in AJAX per ottenere il valore.
 
if (isset($_GET['status'])){
$filename = "comando.txt";
$file=fopen($filename,"r") or exit("Impossibile aprire il file!");
$str = fread($file, filesize($filename));
 
echo substr($str, 0, strpos($str, " "));
}
 
?>

In alternativa è possibile utilizzare il proprio pc e adattarlo a web server, così da localizzare ulteriormente il sistema di controllo con l’interfaccia web, tutto su uno stesso web server (compreso il modulo scritto in python).

Per comodità potete scaricare l’intero software, con tanto di interfaccia web, nell’archivio compresso, a questo link: DOWNLOAD SORGENTI.

Python 3.2 – Protocollo Telnet e la libreria telnetlib in python

0
1 mese fa
Scritto da Rocco Musolino in

La libreria telnetlib, presente di default nell’installazione dell’interprete Python, consente di utilizzare il protocollo Telnet e stabilire connessioni locali o remote che siano.

Guardiamone un esempio qua sotto:

import telnetlib
 
host = input("Inserisci l'HOST: ") #dando la possibilita di scegliere l'host ci si puo' connettere anche a pc remoti
password = input("Inserisci la password: ")
porta = input("Inserisci la porta (23 standard per telnet): ")
 
tn = telnetlib.Telnet(host, porta)
 
tn.read_until(b"login: ") #leggiamo i caratteri fino a login, per posizionarci il cursore subito dopo...
tn.write(password.encode('ascii') + b"\n")
 
while True:
    cmd = input("Inserisci comando: ") #inseriamo un comando da inviare all'host
    if cmd == "end":
        break
    else:
        cmd = cmd + "\n"
        tn.write(cmd.encode("ascii"))
        // ... read response
 
print(tn.read_all().decode('ascii'))

Con un comando come: tn.read_eager() sostituito alla linea “… read response”, possiamo leggere l’output di risposta.

arduino IR remote Control infrared

VLC hacking – Infrared Remote Py-Control 2.0

4
1 mese fa
Scritto da Rocco Musolino in , , ,

Lieto di annunciarvi, la nuova versione dell’Infrared Remote py-control, giunto dunque alla 2.0.
Nella precedente versione, non veniva sfruttata alcuna interfaccia nativa di VLC.
Dunque il risultato poteva essere alquanto macchinoso, e alterato da eventuali focus su finestre diverse da quella di VLC (da qui la necessità nella vecchia versione di assicurarsi che la finestra vlc fosse sempre in primo piano).

In questa nuova versione, vengono introdotti molteplici e fondamentali miglioramenti:

- Il client python interagisce direttamente con VLC attraverso l’interfaccia telnet offerta nativamente dal software (non vi è più alcun uso della libreria pywin32, win32api etc.).
- Nessuna necessità di aver la finestra di VLC in primo piano per potervi lanciare comandi sopra.
- Il protocollo telnet è facilmente integrabile in python, con l’import della libreria telnetlib.
- Il codice risulta più compatto e il software più stabile.

Alcune accortezze per garantre il funzionamento e la messa in funzione del progetto:

- Assicuratevi di avere VLC aperto e che abbiate selezionato dal menu l’interfaccia Telnet. Per farlo, da VLC, Visualizza > Aggiungi Interfaccia > Telnet.

- Potete interagire con l’interfaccia telnet di VLC, sfruttando il client telnet presente in Windows, oppure scaricando PUTTY. (Il software Python sfrutta invece la libreria telnetlib).
A quel punto vi è sufficiente, inserire l’ip (127.0.0.1 se vlc gira in locale) e la porta a cui volete connettervi (di default per vlc 4212, altrimenti la classica telnet è la 23).
Una volta entrati, vi chiederà una password, di default: admin. Dunque potrete dare l’invio e sarete dentro l’interfaccia telnet di VLC, con il comando help, avrete una lista di possibili comandi.

- Volutamente nel client in Python è stata data la possibilità di inserire l’ip sul quale gira l’interfaccia telnet di vlc, così da poter eventualmente controllare anche pc locali con vlc aperto e interfaccia telnet attiva (quindi non per forza vlc deve girare sul pc a cui connettete il ricevitore infrarosso e l’arduino).

- Assicurarsi che i segnali in seriale vengano letti correttamente (potete verificarlo attraverso il Serial Monitor dall’IDE del software Arduino).

- Dall’ide di arduino potete vedere quale è l’attuale porta seriale assegnata al dispositivo, inoltre spesso è probabile che eseguendo due volte il codice python, o prima il serial monitor e poi il client in python, la porta seriale risulti occupata, a quel punto è consigliabile riavviare il pc.

- Il serial monitor di arduino vi è anche utile (indispensabile direi) per mappare la codifica dei pulsanti del vostro telecomando infrarosso. Che andrà sostituita nel codice con quella del vostro telecomando.

- Notate bene, al contrario della precedente versione, la versione di python utilizzata è la 3.2, che come ben sapete introduce rispetto alle 2.7 sostanziali cambiamenti anche nella sintassi del linguaggio e nella gestione della codifica dei dati.

- Tutto è stato provato sotto sistema WINDOWS, ma tranquillamente gira anche su LINUX, l’importante è prestare attenzione quando inserite la porta seriale a cui è connesso il dispositivo, sotto windows è in forma: COMx, sotto linux invece: /dev/ttyUSBx oppure /dev/ttySx dove “x” è un numero.

Lo script che segue implementa solo alcune funzioni base, come play, pausa, tutto schermo, aumenta e diminuisci volume. Connessi in telnet all’interfaccia di VLC e lanciato il comando help potete potenzialmente implementare la qualunque.

Codice Client in Python:

import serial
import telnetlib
 
# ATTENZIONE, usare versione python 3.2
# vlc deve aver attiva l'interfaccia telnet, accessibile attraverso: 127.0.0.1:4212 con pass: admin
# usando il client di telnet presente di default in windows o PUTTY si entra nel server telnet di vlc e lanciando il comando help si avra tutta la lista dei possibili comandi: play, pause etc.
 
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()
 
 
print("\n### VLC Infrared Remote Controller Module - ver 2.0 ###\n")
 
# Ci connettiamo in telnet al VLC locale o remoto.
 
host = input("Inserisci l'HOST: ") #dando la possibilita di scegliere l'host ci si puo' connettere anche a pc nella stessa LAN
password = input("Inserisci la password (default: admin): ")
porta = input("Inserisci la porta (4212 per VLC telnet server): ")
 
tn = telnetlib.Telnet(host, porta) #la porta di default per telnet: 23
 
tn.read_until(b"Password: ")
tn.write(password.encode('ascii') + b"\n")
 
 
print("\nDispositivo ricevitore infrarosso collegato e connessione stabilita!\n")
 
pause_toggle = False
def esegui_cmd(comando):
    global pause_toggle
 
    comando = comando[0:-2].decode("utf-8") #ripuliamo il comando eliminando i tag \r\n finali e decodificando. Queste qua sotto sono le codifiche dei tasti del telecomando da me usato.
    if comando == "20FE4DBB": #play/pausa  (la variabile pause_toggle viene introdotta appositamente, per l'effetto di toggle nel caso di un unico pulsante per il play/pausa)
          if pause_toggle:
            cmd = "play\n"
            pause_toggle = not pause_toggle
          else:
            cmd = "pause\n"
            pause_toggle = not pause_toggle
          tn.write(cmd.encode("utf-8"))
    elif comando == "A3C8EDDB": #volume +
        cmd = "volup\n"
        tn.write(cmd.encode("utf-8"))
    elif comando == "F076C13B": #volume -
        cmd = "voldown\n"
        tn.write(cmd.encode("utf-8"))
    elif comando == "D7E84B1B": #next
        cmd = "next\n"
        tn.write(cmd.encode("utf-8"))
    elif comando == "52A3D41F": #prev
        cmd = "prev\n"
        tn.write(cmd.encode("utf-8"))
    elif comando == "E5CFBD7F" : #fullscreen (a tutto schermo)
        cmd = "fullscreen\n"
        tn.write(cmd.encode("utf-8"))
    elif comando == "FFFFFFFF": #pressione continua del tasto, viene ignorata
       pass
 
 
while True:
    comando = ser.readline()
    print(comando)
    esegui_cmd(comando)
    comando = ""

Codice Microcontrollore ATMEGA328p (arduino):

#include <IRremote.h>
 
/*
Ricevitore infrarosso. (la parte frontale del ricevitore è quella con la mezza sfera).
 
primo piedino: è il segnale collegato al pin digitale 7. (è il primo piedino partendo da sinistra).
secondo piedino: è il GND, collegato ad una resistenza 330ohm e poi al pin GND. (piedino centrale).
terzo piedino: collegato a 5V (piedino a destra).
 
Sfrutta la libreria IRremote.h (non presente di default, quindi scaricatela).
Sito con esempi di codice per la ricezione e l'invio: http://www.arcfn.com/2009/08/multi-protocol-infrared-remote-library.html
 
*/
 
int RECV_PIN = 7;
IRrecv irrecv(RECV_PIN);
decode_results results;
 
void setup()
{
  Serial.begin(9600);
  irrecv.enableIRIn(); // Start the receiver
}
 
void loop() {
  if (irrecv.decode(&results)) {
    Serial.println(results.value, HEX); //inviamo il segnale letto in seriale
    irrecv.resume(); // Receive the next value
  }
}

Vista la parte software, per la parte hardware ciò che ci necessita è davvero alla portata di tutti:

- Una board con input digitali e uscita seriale (con connessione USB al pc), quindi oserei dire Arduino & cloni.
- Un telecomando normalissimo a infrarossi.
- Un ricevitore infrarosso che collegheremo alla board.

Eventualmente, telecomano e ricevitore spesso possono essere acquistati assieme. Segue un’immagine esplicativa:

Per qualsiasi suggerimento o aiuto, vi invitiamo a commentare qui sotto. Grazie!

Rocco

Porta lettere notifica quando il postino arriva.

0
2 mesi fa
Scritto da Rocco Musolino in

Parliamo di un progetto, apparso in rete qualche giorno fa. Controllare la posta non diventa più un semplice affacciarsi dalla finestra per scorgere il postino, o uscire in pieno inverno per controllare se la lettera che aspettavamo è arrivata. Felix, ha modificato la sua cassetta delle lettere, inserendo i componenti visibili in foto:

Nel progetto viene usato un Monteino, che è un clone di Arduino. E’ molto compatto e dotato di un modulo RF (RadioFrequency) saldato sotto la board, che si prende cura della comunicazione radio, con una stazione posta all’intero della casa. Il funzionamento è garantito da una batteria di 9V, un Hall Sensor posto sullo sportellino e un magnete, posto sul “telaio” della cassetta delle lettere. L’Hall Sensor è collegato alla board, e rileva quando un campo magnetico è in prossimità del sensore, in questo modo, possiamo facilmente rilevare, l’apertura e chiusura della cassetta della posta.
Quando l’Arduino rileva un cambiamento al sensore, invia dei segnali radio alla stazione base posta all’interno della casa, che collegata ad un Raspberry Pi, può notificare la cosa all’utente in svariati modi.
Subito sotto un video illustrativo:

Adafruit Gemma

Adafruit presenta Gemma, la nuova piattaforma indossabile

0
2 mesi fa
Scritto da Rocco Musolino in ,

Gemma è una piccola piattaforma programmabile indossabile, dal diametro di 25mm = 1 pollice. E’ dotata di un microcontrollore Attiny85 programmabile dall’IDE di Arduino con USB. Con questa piccola piattaforma potrete realizzare tanti progetti indossabili.

La cosa interessante di Gemma è la grandezza, la metà rispetto all’altra nota piattaforma concorrente, Lilypad (50mm). L’unica vera limitazione forse, sono i soli 3 pin di Input/Output. Per il resto, è perfetta per progetti indossabili che richiedono requisiti di compattezza e leggerezza.

Gemma è ancora in sviluppo, su Adafruit però, potete restare aggiornati per quando verrà finalmente rilasciata.

Qui in basso un riepilogo delle caratteristiche:

- Micro-controllore ATtiny85 con 3 pins di I/O, uno di quali consente input analogico e gli altri 2 output modulati (PWM).
- Programmabile con connessione Micro USB.
- Regolatore Onboard 3.3v e led di accensione
- Bottone Reset
- Design ultra compatto, solo 1″ (25mm) diametro & spessore 4mm.

Torna all'inizio