posta Archivi - Arduino: i miei progetti

Eccomi di nuovo…costretto a casa dalla piena del Seveso ne approfitto per aggiornare il blog.

Nei precedenti post abbiamo:

letto i dati dai sensori di movimento
letto i dati dal sensore di rumore
collegato la ethernet shield ed inviata una mail

A questo punto possiamo mettere insieme i vari pezzi.

Inoltre avendo a casa una telecamera D-Link DCS-930L ho deciso di inserirla in questo progetto.

Per non tenere accesa la telecamera tutto il giorno vorrei fare in modo che si accenda solo nel momento in cui viene individuato un movimento.
Non solo: poterla accenderla da remoto nel caso in cui ho voglia di verificare cosa succede in casa.
Per non complicarmi la vita ho deciso di comprare una ciabatta wireless (sempre a 433 Mhz) tipo queste. Collegata la webcam alla ciabatta posso comandarla tramite arduino, basta solo scoprire il codice di trasmissione come fatto precedentemente con i sensori di movimento!
Utilizzando il telecomando in dotazione alla prese quindi ho determinato:

Codice accensione ciabatta	Codice spegnimento ciabatta
1394001	1394004

Ho quindi tutti i codici sensori che necessito, posso aggiungere il modulo di trasmissione ad Arduino.

Il risultato finale è questo:

I collegamenti, rispetto a quanto fatto nelle precedenti “puntate”, li ho dovuti modificare in quanto ho scoperto che i pin 10, 11, 12 e 13 vengono utilizzati in modo esclusivo dall’ethernet shield.

Quindi riepilogando i collegamenti sono:

Sensore Rumore

Vcc	5 V
GND	GND
SNG	Pin 5 (digitale)

Sensore ricevente 433 Mhz

Pin Ricevitore	Pin Arduino
Vcc	5 V
GND	GND
DATA	Pin 2 (digitale)

Sensore trasmittente 433 Mhz

Pin Ricevitore	Pin Arduino
Vcc	5 V
GND	GND
DATA	Pin 9 (digitale)

Il codice per verificare se il tutto funziona quindi :

/*
 Ricezione dai sensori porte
 Trasmissione verso telecamera
 rivelazione rumore

 http://code.google.com/p/rc-switch/

 Need help? http://forum.ardumote.com
 */

#include <String.h>
#include <RCSwitch.h>
#include <Time.h>
#include <SPI.h>
#include <Ethernet.h>

/* Informazioni Ethernet*/

byte mac[] = {
  0x00, 0xAA, 0xBB, 0xCC, 0xDE, 0x02 };
int SERIAL_BAUD        = 9600;
int TRASMIT_PIN       = 9;
int RECEIVE_PIN       = 0;
int NOISE_DIGITAL_PIN =    5;
//Sensori
long PORTA_INGRESSO_SENSORE  = 3557625;
long PORTA_CUCINA_SENSORE = 10521177;
long SEGNALE_ACCENZIONE_WEBCAM = 1394001;
long SEGNALE_SPEGNIMENTO_WEBCAM= 1394004;

EthernetClient client;
EthernetServer server(8081);
char smtpServer[] = "smtpcorp.com";
RCSwitch mySwitch = RCSwitch();

void setup() {
  Serial.begin(SERIAL_BAUD);
  pinMode(SERIAL_BAUD, INPUT);
  mySwitch.enableReceive(RECEIVE_PIN);
  mySwitch.enableTransmit(TRASMIT_PIN);
  setupComm();
}

void loop() {

  getClientConnection();
  if (detectNoise()){
    Serial.print("Rumore");
    email("Attenzione, rilevato rumore in casa!");
    accendiCam(SEGNALE_ACCENZIONE_WEBCAM) ;
  }

  if (mySwitch.available()) {

    int value = mySwitch.getReceivedValue();

    Serial.print(value);
    if (value == 0) {
      Serial.print("Unknown encoding");
      Serial.print("\n");
    }
    else {
      long receivedValue = mySwitch.getReceivedValue();
      if (receivedValue == PORTA_INGRESSO_SENSORE) {
        Serial.print("Attenzione! Porta ingresso aperta!");
        Serial.print("\n");
        email("Attenzione, porta ingresso aperta!");
        accendiCam(SEGNALE_ACCENZIONE_WEBCAM) ;
        delay(1000);
      }
      else if(receivedValue == PORTA_CUCINA_SENSORE) {
        Serial.print("Attenzione! Porta cucina aperta!");
        Serial.print("\n");
        email("Attenzione, porta cucina aperta!");
        accendiCam(SEGNALE_ACCENZIONE_WEBCAM) ;
        delay(1000);
      }  

      Serial.print("Received ");
      Serial.print( receivedValue);
      Serial.print(" / ");
      Serial.print( mySwitch.getReceivedBitlength() );
      Serial.print("bit ");
      Serial.print("Protocol: ");
      Serial.println( mySwitch.getReceivedProtocol() );
    }

    mySwitch.resetAvailable();
  }

}

bool detectNoise ()
{
  bool rit = false;
  if (digitalRead(NOISE_DIGITAL_PIN) == HIGH)
  {
    rit = true;
  }
  return rit;
} 

void accendiCam(long value)
{
  mySwitch.send(value, 24);
  mySwitch.send(value, 24);
  mySwitch.send(value, 24);
  mySwitch.send(value, 24);
  mySwitch.send(value, 24);
} 

void setupComm()
{
  Serial.println("Trying to connect");
  Serial.print("\n");
  if (!Ethernet.begin(mac)){
    Serial.println("Failed to DHCP");
    while(true);
  }

  Serial.print("My IP address: ");
  for (byte thisByte = 0; thisByte < 4; thisByte++) {
    Serial.print(Ethernet.localIP()[thisByte], DEC);
    Serial.print(".");
  }
  Serial.println("fine");
}

// Call to send an email.
bool email(char* text)
{
  bool success = false;
  Serial.println("Sending email...");
  Serial.print("\n");
  Serial.println("SMTP server...");
  Serial.print(smtpServer); 

  if (client.connect(smtpServer, 2525)){
    Serial.println("connected");
    delay(100);
    client.println("EHLO arduino");
    for(int i=0; i<999; ++i){
      if(client.read() > 0)
        break;
    }
    Serial.println("responded");
    Serial.print("\n");
    client.println("AUTH LOGIN");
    client.println("xxxxxxx");           //vedi precedente post per la spiegazione
    client.println("yyyyyy");   //vedi precedenti post per la spiegazione     

    client.println("MAIL FROM:<dumm@gmail.com>");
    for(int i=0; i<999; ++i){
      if(client.read() > 0)
        break;
    } 

    client.println("RCPT TO:<giuseppe.scola@gmail.com>"); 

    for(int i=0; i<999; ++i){
      if(client.read() > 0)
        break;
    } 

    client.println("DATA");
    for(int i=0; i<999; ++i){
      if(client.read() > 0)
        break;
    }

    client.println("from: giuseppe.scola@gmail.com");
    client.println("to: giuseppe.scola@gmail.com");
    client.println("SUBJECT: ArduAlarm");
    client.println("");
    client.println(text);
    client.println(".");
    client.println("QUIT");
    for(int i=0; i<999; ++i){
      if(i > 998){
        Serial.println("error: No response");
      }
      if(client.read() > 0)
        break;
    }
    success = true;
    client.println();
    Serial.println("end");
    Serial.print("\n");
  }
  else {
    Serial.println("Failed");
    Serial.print("\n");
    client.println("QUIT");
  }
  client.stop();
  return success;
}

void getClientConnection(){

  EthernetClient client = server.available();
  if (client) {
    String postString ="";
    Serial.println("nuova richiesta");
    boolean currentLineIsBlank = true;
    while (client.connected()) {
      if (client.available()) {
        char c = client.read();
        //postString.concat(c);
        if(postString.length()<10){
          postString +=c;
        }
        // Serial.write(c);
        if (c == '\n' && currentLineIsBlank) {
          //if(readString.indexOf("id=1") > 0){
          client.println("HTTP/1.1 200 OK");
          client.println("Content-Type: text/html");
          client.println("Connection: close");  // the connection will be closed after completion of the response
          //client.println("Refresh: 5");  // refresh the page automatically every 5 sec
          client.println();
          client.println("<!DOCTYPE HTML>");
          client.println("<html>");
          //client.println("<h1>Settaggi</h1><br>");
          client.println("<h1>AllarDuino</h1>");
          client.print("<br>");
          client.println("<a href=\"./?on\">Accendi CAM</a>");
          client.println("<a href=\"./?off\">Spegni CAM</a>");
          client.println("</html>");
          break;
          //}
        }

        if (c == '\n') {
          // you're starting a new line
          currentLineIsBlank = true;
        }
        else if (c != '\r') {
          // you've gotten a character on the current line
          currentLineIsBlank = false;
        }

      }
    }  //fine client.connected 

    Serial.println("-------------");
    Serial.println(postString);
    Serial.println("-------------");

    if(postString.indexOf("?on") > 0){
      Serial.println("accendi CAM");
      accendiCam(SEGNALE_ACCENZIONE_WEBCAM);
      client.println("<br/>");
      client.println("<p>Cam accesa</p>");

    }
    if(postString.indexOf("?off") > 0){
      accendiCam(SEGNALE_SPEGNIMENTO_WEBCAM);
      client.println("<br/>");
      client.println("<p>Cam spenta</p>");
    } 

    delay(1);
    // close the connection:
    client.stop();
    Serial.println("client disonnected");
  }
}

Domani o dopo spero di riuscire a commentare un po il codice, soprattutto la parte in cui viene generato l’html.

Ciao di nuovo, mi è arrivata finalmente a casa l’ethernet shield ed è ora di studiarla un po!
Quello che voglio capire è come inviare una mail al mio indirizzo di posta.

Il collegamento ad Arduino UNO è semplicissimo, un’immagine vale più di 1000 parole!

(da instructables.com)

Quindi colleghiamo la presa RJ45 al nostro router e il cavo USB di alimentazione alla presa di alimentazione di Arduino UNO (vedi figura).

(da instructables.com)

Le informazioni fondamentali per procedere sono:

impostazione ip della ethernet shield
impostazione mac address della ethernet shield
impostazioni del server SMTP per invio della mail

Il mio router è in DHCP, quindi assegna automaticamente gli indirizzi ip.
Non ci sono problemi per il MAC Address in quanto si può assegnare un numero in modo arbitrario.

A questo punto ho scoperto ci possono essere due strade per l’invio delle email:

1. Il servizio Temboo mette a disposizione una libreria per l’invio mail tramite gmail (qui le istruzioni)
2. il servizio SMTP2GO che permette di inviare fino a 10 email tramite il proprio SMTP gratuito (registrazione qui).

Ho optato per la seconda strada (servizio SMTP2GO)…soprattutto perche ho scoperto Temboo quando ormai avevo finito di sviluppare con SMTP2GO! Zero voglia di provare Temboo!!!!!
Anzi, se qualcuno ha effettuato delle prove sarei felice di sentire una loro opinione. Thanks

Lato codice ho utlizzato quanto scritto da Nicolaj Joergensen:

#include <SPI.h>;
#include <Ethernet.h>;
 
// Arduino network information
byte mac[] = { 0x00, 0xAA, 0xBB, 0xCC, 0xDE, 0x02 };
EthernetClient client;
char smtpServer[] = "smtpcorp.com";
 
void setup()
{
  Serial.begin(9600);  // per debug
  setupComm();
}
 
void loop()
{
  email("ciao");
  delay(1000);
}
 
// Inizializzazione connessione ethernet shield
void setupComm()
{
  Serial.println("Trying to connect");
  if (!Ethernet.begin(mac)){
    Serial.println("Failed to DHCP");
    // verifica della connessione
    while(true);
  }
  delay(10000);
 
  // individuazione dell'indirizzo IP:
  Serial.print("IP address: ");
  for (byte thisByte = 0; thisByte < 4; thisByte++) {
    Serial.print(Ethernet.localIP()[thisByte], DEC);
    Serial.print(".");
  }
  Serial.println();
}
 
// Invio effettivo della mail
bool email(char* text)
{
  bool success = false;
  Serial.println("Sending email...");
 
  if (client.connect(smtpServer, 2525)){            //2525 è la porta del SMTP Server
    Serial.println("connected");
    delay(100);
    client.println("EHLO arduino");
    for(int i=0; i<999; ++i){
      if(client.read() > 0)
        break;
    }
    Serial.println("responded");
 
    client.println("AUTH LOGIN");                     //vedi "http://base64-encoder-online.waraxe.us/"
    client.println("xxxxxxxxxx");           //Username in base 64
    client.println("yyyyyyyyyy");        //Password in base 64
 
    // Put your "from" email address here
    client.println("MAIL FROM:<dumm@gmail.com>"); //Sembra non importi molto quanto scritto qui...
    for(int i=0; i<999; ++i){
      if(client.read() > 0)
      break;
    } 
 
    // Indirizzo di destinazione
    client.println("RCPT TO:<mail@mail.com>"); 
 
    for(int i=0; i<999; ++i){
      if(client.read() > 0)
      break;
    } 
 
    client.println("DATA");
    for(int i=0; i<999; ++i){
      if(client.read() > 0)
        break;
    }
    //Sender
    client.println("from: mail@mail.com"); //Sender address visualizzato nella mail
    client.println("to: mail@mail.com");  //Receiver address visualizzato dalla mail
    client.println("SUBJECT: From your arduino");
    client.println("");
    client.println(text);
    client.println(".");
    client.println("QUIT");
    for(int i=0; i<999; ++i){
      if(i > 998){Serial.println("error: No response");}
      if(client.read() > 0)
        break;
    }
    success = true;
    client.println();
    Serial.println("end");
  } else {
    Serial.println("Failed");
    client.println("QUIT"); //Disconnessione
  }
  client.stop();
  return success;
}

Spiegazione del codice:

riga 5: impostazione del MAC Address: potete scrivere quello il numero che preferite!
riga 7: indirizzo del server SMTP
riga 17:chiamata alla funzione effettiva di invio email. Verrà inviata una mail con testo ciao
riga 25: inizializzazione della scheda ethernet
riga 34-35: visualizzazione dell’indirizzo IP assegnato in DHCP da mio router. Utile se vogliamo fare in modo che la scheda ethernet possa essere utilizzata come webserver e quindi richiamata da un browser.
riga 42: vengono inviati al server SMTP i comandi per l’invio della mail.
riga 58: username del servizio SMTP2GO in base 64.
riga 59: password del servizio SMTP2GO in base 64.
E’ comodo utilizzare questo servizio per trasformare in base 64: http://base64-encoder-online.waraxe.us/
Per esempio la username CICCIO diventa Q0lDQ0lP

Caricato il programma ed uploadato su Arduino UNO ho ricevuto la mia prima mail!
Ho messo un delay alla riga 18, quindi ogni 10 secondi viene inviata una mail! Prestate attenzione con le prove perchè SMTP2GO mette a disposizione (nella versione free) solo l’invio di 10 mail giornaliere

Ho finito con la sperimentazione della ethernet shield per oggi…ho ottenuto quello che volevo.

Lo step successivo è di inviare una mail personalizzata nel momento in cui un sensore dell’antifurto riceve un segnale: la mail dovrà indicarmi quale sensore ha fatto scattare l’allarme (sensore porta, finestra, rumore) con relativa ora.

Ci vediamo alla prossima! (spero presto…)

Ps. Nel frattempo mi è arrivato arduino nano… 🙂 🙂

Tag: posta

Un semplice antifurto: cerchiamo di mettere tutto insieme

Un semplice antifurto: collegamento ethernet shield