La fondazione Raspberry PI (www.raspberrypi.org) ci stupisce nuovamente introducendo la piccola PI ZERO, una nuova scheda dalle dimensioni disarmanti e dal costo di appena 5 dollari. Un piccolo computer (o meglio una piccola scheda madre) che permetterà di realizzare una miriade di progetti investendo una cifra irrisoria, ala portata di tutti.
Se qualche anno fa eravamo abituati ad avere in allegato alle riviste di tecnologia un dvd in omaggio piuttosto che piccoli gadget elettronici, oggi sembra incredibile vedere la PI Zero allegata alla rivista MagPI! Un computer in omaggio allegato alla rivista!

Nonostante il prezzo di lancio di 5 dollari, il SoC utilizzato (Broadcom BCM2835) è identico a quella della Raspberry PI Model A+ ma con una frequenza da 1GHz e una Ram da 512MB.

Per capire meglio la famiglia di schede, ho realizzato una tabella comparativa che mostra quali siano le differenze principali tra i vari modelli, allo scopo di avere un riferimento quando vorremo acquistarne una:

Raspberry PI	PI ZERO	Model A+	Model B	Model B+	2 Model B
Tipo SoC	Broadcom BCM2835	Broadcom BCM2835	Broadcom BCM2835	Broadcom BCM2835	Broadcom BCM2836
Processore	ARMv11 single core	ARMv6 single core	ARMv6 single core	ARMv6 single core	ARMv7 Quad Core
Frequenza CPU	1GHz	700MHz	700MHz	700MHz	900MHz
Ram	512MB SDRAM	256MB SDRAM	256MB SDRAM	512MB SDRAM	1GB SDRAM
Numero Porte USB	1	1	2	4	4
Porta Ethernet	NO	NO	SI	SI	SI
Numero porte GPIO	40	40	26	40	40

Questa nuova scheda a mio parere si candida per essere impiegata principalmente nei progetti elettronici del segmento domotica e IoT poiché il suo basso assorbimento di energia e le dimensioni contenute (lunghezza 65mm, altezza 30mm, Spessore 5mm) sono certamente una caratteristica peculiare.

La tabella seguente compara i vari assorbimenti tra le schede PI

La ZERO ha assorbimenti in linea con la A+, nonostante abbia il processore overcloccato a 1GHz. Per progetti dove l’alimentazione è un punto critico (circuiti alimentati a batteria) si potrebbe agire sui file di configurazione, della distribuzione Raspbian, per diminuire la velocità di clock (test che personalmente  non ho provato).

In conclusione credo che questa scheda sia un ottima opportunità per chi ha intenzione di arricchire il proprio bagaglio tecnico in ambiente Linux e per realizzare progetti con un investimento davvero irrisorio.

The post Pi ZERO il primo Raspberry PI a 5 dollari appeared first on Esperimenti con logiche programmabili.

Molti utenti che hanno realizzato il tutorial Scheda relè remota con Arduino e Webduino, dopo aver constatato il funzionamento del codice hanno poi implementato il codice per la gestione di ulteriori relè. A questo punto si sono accorti che il codice smette di funzionare e Arduino UNO sembra bloccata.
Tutto ciò avviene perché aggiungendo istruzioni contenenti stringhe ad un certo punto si arriva a saturare la memoria SRAM, questo è il motivo per cui la scheda va in blocco. La mancanza di memoria SRAM di fatto non permette di eseguire le istruzioni del nostro sketch.

Come è possibile risolvere il problema senza aumentare la memoria SRAM?

Sapiamo che la scheda possiede anche una memoria EEPROM da 1KB, e che tramite la funzione PROGMEM possiamo memorizzarci delle stringhe.

Anche la libreria Webduino permette di salvare e richiamare le stringhe dalla memoria EEPROM, quindi possiamo usare questa funzionalità per liberare SRAM e permettere la normale esecuzione del codice.

Vediamo come modificare una porzione del codice del precedente articolo:

[c]
if(Rele1 == true)
server.print(“<tr><td style=\”color: red;\”>RELE 1 ON</td><td>”);
else
server.print(“<tr><td style=\”color: black;\”>RELE 1 OFF</td><td>”);
[/c]

utilizzando le funzioni della libreria Webduino, per memorizzare le stringhe nella EEPROM

[c]
//memorizza le stringhe sulla EEPROM
P(str_rele1ON) = “<tr><td style=\”color: red;\”>RELE 1 ON</td><td>”;
P(str_rele1OFF) = “<tr><td style=\”color: black;\”>RELE 1 OFF</td><td>”;

if(Rele1 == true)
//richiama la stringa dalla eeprom
server.printP(str_rele1ON);
else
//richiama la stringa dalla eeprom
server.printP(str_rele1OFF);
[/c]

il codice precedente fa uso dell’istruzione P() e del metodo printP().

P() ha il compito di memorizzare la stringa nella EEPROM proprio come accade con l’istruzione PROGMEM. per richiamare la stringa è sufficiente richiamarla utilizzando il metodo printP() dell’oggetto server.

In definitiva se volete aggiungere più relè è sufficiente modificare il codice del tutorial come nell’esempio precedente.

The post Webduino scheda relè evitare blocco Arduino UNO appeared first on Esperimenti con logiche programmabili.

La tecnologia di illuminazione a led si è ormai evoluta ed inizia ad essere presente in modo pronunciato in molti ambienti, dalla casa agli uffici fino ad arrivare all’illuminazione pubblica (vedi progetto di lampada di cortesia a led).

I vantaggi in termini di risparmio energetico sono enormi e la qualità della luce emessa sta raggiungendo un comfort visivo soddisfacente.

Anche nell’arredamento troviamo soluzioni molto interessanti che vanno dalla lampada da salotto multicolore alle luci di cortesia nei piani cottura oppure alle barre led impermeabili poste nel box doccia.

Vista la nostra passione per l’auto-costruzione possiamo realizzare un dispositivo basato su Arduino per pilotare una barra led RGB. Per questo tutorial ho usato una Arduino Leonardo e uno spezzone di 10 cm di una strip led RGB da un metro. Questo modello viene alimentato a 12Vdc e un modulo assorbe, con tutti i led accesi circa 55mA (quindi un metro assorbe circa 550mA).

Un elemento RGB è composto da 3 LED distinti (LED Rosso, LED Verde, LED Blu) disposti in modo da poter interagire tra loro per formare diversi colori complementari.

Il modo più semplice per accendere i led è di collegare uno dei pin (B,R,G) verso massa; non è necessario utilizzare delle resistenze per limitare la corrente perché sono già integrate nel circuito.

Vediamo ora come usare Arduino per accendere e spegnere singolarmente i vari led. Il circuito da realizzare è il seguente e si basa su tre transistor PNP tipo BC337.

Le basi dei tre transistors sono collegate ai pin 3, 5 e 6 non a caso poiché su questi pin è disponibile anche il segnale PWM che utilizzeremo per andare a pilotare i led RGB in modo migliore.

void setup()
{
 //led Rosso
 pinMode(5, OUTPUT);
 //led verde
 pinMode(6, OUTPUT);
 //led blu
 pinMode(3, OUTPUT);
 //init seriale
 Serial.begin(9600);
}

void loop() 
{
 //se arrivano dati...
 if (Serial.available())
 {
  //leggi il carattere in arrivo
  byte data = Serial.read();
  if(data == 'q') //accende il led blu
   digitalWrite(3, HIGH);
  else if (data == 'w') //spegne il led blu
   digitalWrite(3, LOW);
 
  if(data == 'a') //accende il led verde
   digitalWrite(5, HIGH);
  else if (data == 's') //spegne il led verde
   digitalWrite(5, LOW);
  if(data == 'z') //accende il led rosso
   digitalWrite(6, HIGH);
  else if (data == 'x') //spegne il led rosso
   digitalWrite(6, LOW);
 }
}

Il codice precedente permette di accendere o spegnere i led inviando tramite serial monitor dei caratteri di comando. L’effetto che otteniamo è una miscelazione dei colori.

Un maggior controllo dei led RGB possiamo ottenerlo utilizzando il segnale PWM generato da Arduino. In questo modo abbiamo la possibilità di creare dissolvenze per creare combinazioni di colori visivamente più interessanti.
Il codice seguente permette di accendere e spegnere il led BLU in modo graduale tramite una dissolvenza:

void setup()
{
 //led Rosso
 pinMode(5, OUTPUT);
 //led verde
 pinMode(6, OUTPUT);
 //led blu
 pinMode(3, OUTPUT);
 //init seriale
 Serial.begin(9600);
}

void loop()
{
 //Aumenta il duty cycle da 100% a 0%
 for(byte sfuma = 0; sfuma < 255; sfuma++)
 {
  analogWrite(3, sfuma);
  delay(40);
 }
 //diminuisci il duty cycle da 100% a 0%
 for(byte sfuma = 255; sfuma > 0; sfuma--)
 {
  analogWrite(3, sfuma);
  delay(40);
 }
}

Se volessi miscelare i colori potrei scrivere qualcosa del genere

void setup()
{
 //led Rosso
 pinMode(5, OUTPUT);
 //led verde
 pinMode(6, OUTPUT);
 //led blu
 pinMode(3, OUTPUT);
 //init seriale
 Serial.begin(9600);
}

void loop()
{
 //accendo il led rosso
 digitalWrite(6, HIGH);
 //Aumenta il duty cycle da 100% a 0%
 for(byte sfuma = 0; sfuma < 255; sfuma++)
 {
  analogWrite(3, sfuma);
  delay(40);
 }

 //spengo il rosso
 digitalWrite(6, LOW);
 //accendo il verde
 digitalWrite(5, HIGH);
 //diminuisci il duty cycle da 100% a 0%
 for(byte sfuma = 255; sfuma > 0; sfuma--)
 {
  analogWrite(3, sfuma);
  delay(40);
 }
}

Le combinazioni che possiamo creare sono innumerevoli, potete provare a sperimentare creando effetti luminosi che possono abbellire i vostri ambienti.

The post Pilotare striscia LED RGB appeared first on Esperimenti con logiche programmabili.

Mi piace realizzare progetti che impiegano dispositivi esistenti che, magari messi da parte per lungo tempo, si rivelano ottimi per costruire nuovi dispositivi.
La lampada led a batteria è un oggetto molto comune che si compra a basso costo nelle bancarelle delle fiere di elettronica. Date le sue dimensioni ridotte è possibile utilizzarla per illuminare tutte quelle piccole aree dove non abbiamo previsto una fonte di illuminazione fissa e dove non abbiamo la possibilità di portare dei cavi elettrici se non tramite opere murarie.

Non potendo tenere accesa la lampada per ore, causa scaricamento repentino della batteria, ho realizzato un piccolo circuito che tramite un sensore PIR e un relè permetta l’accensione della lampada solo al passaggio di una persona (o comunque qualsiasi cosa che si muove![tranne mosche e zanzare!]). Adoperando anche una fotoresistenza riesco a gestire l’accensione solo nelle ore notturne.
Tutto il sistemino è gestito da un parsimonioso ATtiny85.

Lo schema del circuito è il seguente:

Le batterie della lampada (che forniscono nel mio caso circa 7Vdc) hanno anche il compito di alimentare il circuito. Il regolatore di tensione 7805 stabilizza e fornisce alimentazione al circuito. L’ATtiny85 acquisisce il segnale analogico proveniente dalla fotoresistenza e il segnale digitale proveniente dal sensore PIR. Tramite il transistor comando un micro relè che cortocircuita l’interruttore meccanico posto sulla lampada, provocandone l’accensione.

Il codice che governa l’ATtiny85 è il seguente:

void setup()
{
  //uscita per comandare il rele
  pinMode(0, OUTPUT);
  //ingresso per sensore pir
  pinMode(4, INPUT);
}

void loop()
{
  //leggo il valore analogico proveniente dalla fotoresistenza
  int FotoR = analogRead(3);
  //leggo lo stato del segnale pir
  byte inp = digitalRead(4);

  //se il sensore pi rileva un movimento...
  if (inp == HIGH)
  {
    //controlla se la luce ambiente è insufficiente
    if (FotoR <= 150)
    {
      //attiva il relè pe accendere la lampada led
      digitalWrite(0, HIGH);
      //tieni la lampada accesa per 30 secondi
      Ritardo();
    }
  }
else
  //altrimenti tieni il relè disattivato
  digitalWrite(0, LOW);
}

void Ritardo()
{
  //ritardo di 30 secondi

  for(byte Ciclo = 0; Ciclo <= 30; Ciclo++)
  {
    delay(1000);
  }
}

Per programmare l’ATtiny85 potete usare un Arduino UNO come spiegato in questo tutorial. Per chi possiede un programmatore dedicato come quello descritto nel precedente articolo potete usare lo schema seguente per caricare lo sketch nel microcontrollore.

Attenzione il connettore da utilizzare dellUSBasp è il J5

La lampada del led è costata circa 15€ mentre per i componenti del circuito o speso circa 10-12€.

Per usare il circuito all’esterno consiglio di utilizzare un buon contenitore, per evitare che umidità o pioggia possano causare rotture o cortocircuiti.

The post Lampada di cortesia a batteria con ATtiny85 appeared first on Esperimenti con logiche programmabili.

Tra le applicazioni che trovo molto richieste è la scheda relè da gestire tramite smartphone. Utilizzando la libreria Webduino riusciamo a realizzare un dispositivo semplice e funzionale basato su pochi componenti quali Arduino Ethernet, dei classici relè, un router wifi (presente ormai nelle nostre abitazioni) e uno smartphone.

La figura seguente illustra il progetto di questo articolo:

Arduino Ethernet è collegato tramite cavo lan al router e permette di gestire i relè collegati ai pin digitali tramite una applicazione web basata sulla libreria Webduino. Tramite lo smarthphone o un pc collegato alla rete locale possiamo gestire i relè semplicemente usando un browser web.

Per la parte software ho deciso di usare la libreria webduino perché fornisce tutto il necessario per la gestione delle richieste http.

Lo schema elettrico del prototipo che ho realizzato è il seguente:

Il codice caricato sul dispositivo è disponibile nel seguente listato:

[c]

#include <Ethernet.h>
#include <SPI.h>
#include <WebServer.h> //libreria webduino

//variabili statiche per il mac address e lìip address
static byte mac_Add[] = {
0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
//cambiare l’ip in funzione della propria rete
static byte ip_Add[] = {
192, 168, 0, 220 };
//creazione oggetto Webduino
WebServer webserver("", 80);

//Variabili booleane che memorizzano
//lo stato delle uscite collegate ai relè
boolean Rele1 = false;
boolean Rele2 = false;
boolean Rele3 = false;

//=============================================================================
//funzione pagina Start
void Start(WebServer &server, WebServer::ConnectionType type,
char *url_param, bool param_complete)
{
//restituisce al browser l’intestazione http 200 OK
server.httpSuccess();

//gestisco il tipo di richiesta HEAD
if (type != WebServer::HEAD)
{
String s = "";

if (param_complete == true)
{
s = url_param;

if ( s == "R1=ON")
{
Rele1 = true;
digitalWrite(2, HIGH);
}
else if ( s == "R1=OFF")
{
Rele1 = false;
digitalWrite(2, LOW);
}

if ( s == "R2=ON")
{
Rele2 = true;
digitalWrite(3, HIGH);
}
else if ( s == "R2=OFF")
{
Rele2 = false;
digitalWrite(3, LOW);
}

if ( s == "R3=ON")
{
Rele3 = true;
digitalWrite(4, HIGH);
}
else if ( s == "R3=OFF")
{
Rele3 = false;
digitalWrite(4, LOW);
}
}

//gestisco la pagina html in base allo stato delle uscite di Arduino
P(htmlHead) =
"<html>"
"<head>"
"<title>Arduino Scheda Rele</title>"
"</head>"
"<body>";

server.printP(htmlHead);

server.print("<table border=\"1\">");
server.print("<tr><td>Stato Rele</td><td>Comandi</td></tr>");

if(Rele1 == true)
server.print("<tr><td style=\"color: red;\">RELE 1 ON</td><td>");
else
server.print("<tr><td style=\"color: black;\">RELE 1 OFF</td><td>");

if(Rele1 == false)
server.print("<input type=\"button\" value=\"clicca qui\"
onclick=\"location.href=’index.htm?R1=ON’\">");
else
server.print("<input type=\"button\" value=\"clicca qui\"
onclick=\"location.href=’index.htm?R1=OFF’\">");

server.print("</td></tr>");

if(Rele2 == true)
server.print("<tr><td style=\"color: red;\">RELE 2 ON</td><td>");
else
server.print("<tr><td style=\"color: black;\">RELE 2 OFF</td><td>");

if(Rele2 == false)
server.print("<input type=\"button\" value=\"clicca qui\"
onclick=\"location.href=’index.htm?R2=ON’\">");
else
server.print("<input type=\"button\" value=\"clicca qui\"
onclick=\"location.href=’index.htm?R2=OFF’\">");

server.print("</td></tr>");

if(Rele3 == true)
server.print("<tr><td style=\"color: red;\">RELE 3 ON</td><td>");
else
server.print("<tr><td style=\"color: black;\">RELE 3 OFF</td><td>");

if(Rele3 == false)
server.print("<input type=\"button\" value=\"clicca qui\"
onclick=\"location.href=’index.htm?R3=ON’\">");
else
server.print("<input type=\"button\" value=\"clicca qui\"
onclick=\"location.href=’index.htm?R3=OFF’\">");

server.print("</td></tr>");

server.print("</table></body></html>");

}
}
//=============================================================================

void setup()
{
//inizializzo l’ethernet shield con il mac e il address
Ethernet.begin(mac_Add, ip_Add);

//definisci l’azione di default che verrà eseguita quando l’utente
//naviga nella root del sito
webserver.setDefaultCommand(&Start);
webserver.addCommand("index.htm", &Start);

//avvia il web server
webserver.begin();

delay(100);

//definisci i pin 2 3 4 in uscita
pinMode(2, OUTPUT);
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);

//inizializza i le uscite
digitalWrite(2, LOW);
digitalWrite(3, LOW);
digitalWrite(4, LOW);

}

void loop()
{
//elabora costantemente tutte le richieste provenienti dal browser
webserver.processConnection();
}

[/c]

Nonostante le numerose righe di codice potete capirne il funzionamento semplicemente leggendo i commenti che lo accompagnano.
L’interfaccia web per gestire i relè è la seguente:

Cliccando il bottone con la label “clicca qui” si ottiene una commutazione dello stato dei pin di uscita di Arduino e l’aggiornamento della label Stato Rele.

Anche in questo caso con poco si ottengono dispositivi interessanti e utili.

The post Scheda relè remota con Arduino e Webduino appeared first on Esperimenti con logiche programmabili.

Ci affidiamo sempre più alla qualità costruttiva dei materiali delle nostre cucine e bruciatori, e la possibilità di una fuga di gas sembra remota. Col passare del tempo questi componenti potrebbero usurarsi aumentando in qualche modo il rischio di fuoriuscita di gas.
Autocostruirsi un sistema di rilevamento è piuttosto semplice ed economico, dato che, il costo del sensore e tipicamente inferiore ai 10€.
Questi sensori sono stabili, hanno una lunga vita di esercizio, sono molto precisi ed una elevata sensibilità con una risposta molto veloce.

Il modello MQ5 che ho acquistato è prodotto dalla Hanwei Electronics, ed è progettato per rilevare principalmente gas GPL, Metano e Idrogeno ed in misura minore rileva alcool e monossido di carbonio. Questo sensore è indicato per rilevare il gas comune, utilizzato in ambiente domestico.

Lo schema del circuito è il seguente:

Il sensore MQ5 viene alimentato dalla +5Vdc dell’Arduino anche se, come sempre, consiglio di utilizzare una fonte di energia esterna per evitare di sovraccaricare lo stadio di alimentazione della board.
L’uscita della sonda è collegata all’ingresso analogico A0, una resistenza da 10Kohm collegata a massa crea un partitore di tensione indispensabile per rilevare le variazioni di tensione generate dal sensore.
Ai pin digitali vengono collegati due led, un cicalino e uno stadio relè che permette di azionare una ventola di estrazione.

Il relè deve essere assolutamente di tipo ermetico per avvitare i piccoli archi di corrente che si manifestano durante il contatto delle lamelle del relè.
La ventola invece deve essere di tipo induttivo, priva quindi di spazzole che potrebbero generare, anche in questo caso piccolissimi ma pericolosi archi di corrente.

I led collegato al pin7 viene impiegato per indicare lo stato di preriscaldamento del sensore, necessario all’avvio per renderlo stabile evitando falsi alarmi. Il led collegato al pin8, e il cicalino collegato al pin9, vengono utilizzati per rappresentare l’eventuale allarme.

Il codice per questo circuito è il seguente:

int gas = 0;
int PreRiscaldo = 0;

void setup()
{
  Serial.begin(9600);

  pinMode(2, OUTPUT); //Relè-ventola
  pinMode(7, OUTPUT); //Riscaldamento
  pinMode(8, OUTPUT); //Allarme
  pinMode(9, OUTPUT); //Buzzer

  digitalWrite(7, HIGH);
  //attendo 5 minuti per stabilizzare la sonda
  for ( PreRiscaldo = 0; PreRiscaldo < 300; PreRiscaldo++)
  {
    delay(1000);
  }
  digitalWrite(7, LOW);
}

void loop()
{
  //Leggo il valore di tensione generato dalla sonda
  gas = analogRead(0);

  //invio i dati al serial Monitor
  Serial.println(gas, DEC);

  //gestisco le soglie e agisco di conseguenza
  if ( gas > 150)
  {
    //cicalino ON
    analogWrite(9, 100);
    //allarme via led ON
    digitalWrite(8, HIGH);
    //attivo relè
    digitalWrite(2, HIGH);
  }
  else
  {
    //cicalino OFF
    analogWrite(9, 100);
    //allarme via led OFF
    digitalWrite(8, LOW);
    //attivo relè
    digitalWrite(2, LOW);
  }

  //acquisisco i dati ogni 1/2 secondo
  delay(500);
}

Nel mio caso la funzione analogRead(0); genera un valore (dopo circa 5 minuti di funzionamento) intorno a 90, avvicinando un accendino e aprendo il gas, questo valore schizza a 800-900, provocando l’azionamento del relè e l’accensione del Led sul pin8.
Potete variare le soglie in base al vostro sensore e alle vostre esigenze di sensibilità.

Per rilevare in maniera efficiente le fughe di gas, il sensore va posizionato in prossimità del pavimento se il gas da rilevare è pesante (Gpl, Propano, Butano) o in prossimità del soffitto se il gas è leggero (vapori di Alcool, Metano, Etanolo).

Questo progetto è stato testato in modo prototipale, non è stata fata alcuna verifica reale di funzionamento, il progetto è quindi da utilizzare solo per scopi didattici. Non mi assumo responsabilità (visto il delicato campo di impiego) di nessun tipo derivate dal un funzionamento anomalo del circuito o da incidenti da esso causati.

The post Monitorare fughe di gas con il sensore MQ5 appeared first on Esperimenti con logiche programmabili.

Continuiamo l’articolo precedente inserendo nello sketch il codice che permette di campionare segnali analogici per poterli inviarli tramite protocollo http.
Utilizzando la funzione analogRead() acquisiamo il valore della tensione presente sul pin analogico, che verrà utilizzato per essere inserito nella pagina html da inviare al client. Con alcuni tag html aggiuntivi abbiamo la possibilità di avere un refresh automatico della pagina che ad intervalli regolari interrogherà il server Arduino, ottenendo automaticamente nuovi campionamenti del segnale analogico.
Il circuito seguente:

In questo esempio la tensione presente sul pin è fissa, ma nulla vieta l’inserimento di un potenziometro o meglio di un sensore analogico come la sonda di temperatura mcp9700a.

Il codice dello sketch rimane essenzialmente invariato tranne per l’inserimento di una variabile per contenere i valori provenienti dalla funzione analogRead() e di qualche riga html aggiuntiva per formattare la pagina:

if (Data_RX == '\n')
{
//campiono il valore di tensione analogia
//in ingresso sul pin0 ella borad Arduino UNO
analogIn0 = analogRead(0);
//Invio la risposta al client
//invio lo status code
pc_client.println("HTTP/1.1 200 OK");
//imposto il data type
pc_client.println("Content-Type: text/html");
pc_client.println();
//invio codice html
pc_client.print("");
pc_client.print("");
//questo codice html permette di eseguireil refresh automatico
//della pagina html
pc_client.print("");
pc_client.print("");
pc_client.print("

Valore analogico letto dal pin 0");
//inserisco nella pagina html il valore acquisito dal pin analogico
pc_client.print(analogIn0);
pc_client.print("

");
//aspetto 1 ms affinche la risposta giunga al browser del client
delay(1);
//esco dal ciclo while una volta completato l'invio della risposta
break;
}

Non serve altro, è veramente semplice inviare via http i dati acquisiti dall’Arduino.
Possiamo certamente utilizzare anche gli altri ingressi analogici o come nel prossimo esempio leggere lo stato di alcuni pin digitali.
Per impiegare i pin digitali dobbiamo, nel blocco setup(),  specificare quali intendiamo utilizzare come ingressi. Per una semplice prova io ho usato il pin6 e il pin7:

void setup()
{
//inizializza lo shield con il mac e l'ip
Ethernet.begin(mac, ip);
//inizializza l'oggetto server
ArduinoServer.begin();
//definisco i pin6 e pin7 come ingressi
pinMode(6, INPUT);
pinMode(7, INPUT);
}

La funzione digitalRead() acquisisce il valore dello stato dei pin in esame e lo memorizza in una variabile precedentemente dichiarata. Questo valore viene successivamente inviato al client tramite la pagina html

if (Data_RX == '\n')
{
//leggo lo stato dei pin digitali 6 e 7
valPin6 = digitalRead(6);
valPin7 = digitalRead(7);

//campiono il valore di tensione analogia
//in ingresso sul pin0 ella borad Arduino UNO
analogIn0 = analogRead(0);

//Invio la risposta al client
//invio lo status code
pc_client.println("HTTP/1.1 200 OK");
//imposto il data type
pc_client.println("Content-Type: text/html");
pc_client.println();
//invio codice html
pc_client.print("");
pc_client.print("");
//questo codice html permette di eseguireil refresh automatico
//della pagina html
pc_client.print("");
pc_client.print("");
pc_client.print("

Valore analogico letto dal pin 0");
//inserisco nella pagina html il valore acquisito dal pin analogico
pc_client.print(analogIn0);
pc_client.print("

");

//inserisco nella pagina htm lo stato dei pin in ingresso
if(valPin6 == HIGH)
//se il valore è alto
pc_client.print("Stato pin6 = HIGH");
else
//se il valore è basso
pc_client.print("Stato pin6 = LOW");

pc_client.println("
");

if(valPin7 == HIGH)
//se il valore è alto
pc_client.print("Stato pin7 = HIGH");
else
//se il valore è basso
pc_client.print("Stato pin7 = LOW");

pc_client.print("");

//aspetto 1 ms affinche la risposta giunga al browser del client
delay(1);
//esco dal ciclo while una volta completato l'invio della risposta
break;
}

Anche questo codice risulta semplice e i commenti che lo accompagnano descrivono bene le varie istruzioni. Dopo aver caricato lo sketch sull’Arduino ho messo il pin6 alla +5Vdc e il pin 7 a massa ottenendo il risultato seguente:

Naturalmente i pin 10-11-12-13, sono utilizzati per la comunicazioni SPI con l’ethernet shield e quindi, non possono essere impiegati per altri scopi senza interferire nella comunicazione stessa.

Vi rimando al prossimo articolo dove vedremo come utilizzare il browser per inviare comandi alla board Arduino, nel frattempo potete sperimentare con le nozioni acquisite per aumentare le vostre capacità nell’uso della athernet shield.

A presto!

The post Leggere dagli ingressi analogici da remoto con Arduino appeared first on Esperimenti con logiche programmabili.