E’ da diverso tempo che provo schede della serie MKR. Mi piace molto il form factor e quindi la possibilità di inserirle in maniera molto semplice in pcb custom. Nonostante ciò ho riscontrato alcune anomalie sulla scheda MKR Zero. Questa scheda è predisposta per essere alimentata tramite una batteria LiPo da 3.7V. Sulla documentazione viene specificato che il led ON, normalmente acceso con alimentazione da porta usb, dovrebbe essere spento se la scheda è alimentata a batteria.

Ho notato che nelle mie schede MKR ZERO, tutte nuove e acquistare dallo store ufficiale, presentano delle anomalie; infatti alimentando la scheda da LiPo, il led ON risulta parzialmente acceso.

Ho eseguito diversi controlli sullo schema elettrico e cercato sul web se altri utenti riscontrano gli stessi fenomeni ma senza trovare soluzioni.

Nella MKR ZERO la gestione della batteria è affidata al chip MCP738312. Seguendo lo schema riportato di seguito proverò a fare un ragionamento su come dovrebbe funzionare il circuito:

Nel caso in cui non sia presente la batteria, la tensione potrà arrivare al pin VDD dell’integrato MCP738312 in tre modi, dalla USB, Dal pin Vin e dal pin 5V. Inoltre questa tensione raggiungerà anche il pin VIN del regolatore U2, tramite il diodo Q3B, fornendo alimentazione alla scheda.

In questa situazione il mosfet Q3A, di tipo P-channel, risulta spento perché al suo gate è presente una tensione positiva. In questo modo, se fosse presente una batteria (e ammettendo che essa sia completamente carica e che quindi il regolatore sia in sleep mode) la tensione non raggiungerebbe la batteria stessa.

[the_ad id=”6199″]

Se invece la batteria fosse scarica e l’integrato MCP738312 Inizierà a ricaricarla. Nel mio caso la VBat misurata sul connettore J2 è di circa 3.82Vdc e quindi non raggiungerà l’integrato U2 perché il diodo del mosfet Q3A è interdetto (potenziale sull’anodo minore del catodo).

La mia domanda è questa, il mosfet Q3A sarebbe stato possibile sostituirlo con un semplice diodo?

Ora ammettiamo di alimentare la scheda solo con la batteria LiPo.
Il ragionamento è il seguente: Il diodo del mosfet Q3A porterà la tensione della batteria all’integrato U2 alimentando la scheda. In questa situazione ho però una tensione di circa 1.8V sulla linea dei 5V che teoricamente non dovrebbe esserci. Questa tensione va ad alimentare il diodo DL1 che viene leggermente acceso e ovviamente incide sui consumi della batteria in modo significativo.

Questa alimentazione da dove proviene? E’ un difetto dell’integrato MCP738312 che riporta parte della tensione della batteria sul pin VDD?

Qualcuno può verificare quanto scritto e se in possesso di una scheda MKR ZERO verificare la mia tesi?

The post Alimentare a batteria una MKR ZERO appeared first on Esperimenti con logiche programmabili.

I dispositivi alimentati a batteria hanno circuiti integrati capaci di avere un assorbimento di corrente nell’ordine dei uA.

Per poter avere la certezza che possa funzionare per diversi mesi, due sono le soluzioni più immediate, quella di utilizzare una fonte di energia capace di fornire tutta la corrente per sostenere il circuito elettronico (come una batteria capiente o un sistema basato su pannello solare), oppure quella di progettare il circuito elettronico affinché possa assorbire una corrente irrisoria.

Usare una batteria capiente o un pannello solare permette di non preoccuparci tanto degli assorbimenti dei componenti elettronici ma in questo caso dobbiamo fare i conti con installazioni con ingombri maggiori e costi maggiori, mentre utilizzare batterie a basso costo con ingombri ridotti otteniamo semplicità di installazione e costi decisamente inferiori.

Un componente che generalmente troviamo in ogni circuito elettronico è il regolatore di tensione. Questo componente è fondamentale per avere un assorbimento estremamente basso. Infatti se alcuni componenti possiamo disabilitarli o mandarli in modalità basso consumo, il circuito di regolazione deve avere un consumo intrinseco di corrente molto basso in modo da non incidere sul consumo totale di corrente.

Come scegliere il regolatore di tensione.

La prima cosa da sapere è la quantità di corrente massima assorbita dal circuito. Questa può essere calcolata in funzione dei componenti scelti oppure più precisamente misurata utilizzando un comune tester.

Il regolatore di tensione deve avere come parametro principale la capacità di fornire tutta la corrente richiesta dal circuito. Ora verifichiamo il parametro solitamente indicato con la voce quiescent current, che indica la corrente minima necessaria per far funzionare il regolatore.
Più è basso questo valore più andiamo a risparmiare corrente durante le fasi di sleep mode del circuito.

Nel caso del componente MCP1307 il valore di quiescent current è di soli 2uA.

In definitiva per chi è alle prese nel realizzare circuiti a basso assorbimento troverà nel regolatore MCP1703 un valido componente capace di fornire sufficiente corrente al circuito e bassissimi consumi.

The post MCP1703 regolatore di tensione a basso consumo appeared first on Esperimenti con logiche programmabili.

L’acquisizione di segnali analogici permette l’interfacciamento del Flyport Ethernet con svariate tipologie di sensori e trasduttori che forniscono una tensione analogica in funzione della grandezza fisica misurata.
Il modulo dispone di 4 ingressi analogici (p18, p20, p23, p25) con una risoluzione di 10bit (valori restituiti da 0 a 1023) ed una tensione di riferimento molto precisa fissata a 2.048V.
I pin analogici non supportano tensioni superiori a 3.3V quindi dobbiamo stare attenti al valore di tensione che sarà applicato sul pin analogico.

Dato che la tensione di riferimento è di 2.048V, il convertitore analogico digitale fornirà il valore intero zero(0) quando in ingresso sarà presente una tensione di 0V, fornirà invece il valore 1023 quando sul pin analogico sarà presente una tensione pari a 2.048V. Superata questa soglia, fino al valore consentito di 3.3V il convertitore restituirà sempre 1023.

La relazione tra valore di conversione e tensione è la seguente

tensione di riferimento / risoluzione => 2.048/1024 = 0.002V

quindi se il convertitore restituirà il valore di 560, potremmo facilmente constatare che sul pin analogico sarà presente la tensione di 1.12V

valore conversione * valore minimo di conversione => 560 * 0.002 = 1.12V

Ho realizzato il seguente circuito per provare le istruzioni che acquisiscono il segnale analogico presente sul pin p18.

il pin p24 è quello che fornisce la 3.3Vdc, il pin p22 è la massa ed il pi p18 è l’ingresso analogico 4 del modulo Flyport Ethernet.
Il potenziometro PT è da 5Kohm mentre la resistenza R è da 47Ohm e serve per evitare il cortocircuito nel caso in cui ci sia un malfunzionamento della meccanica del potenziometro che porta il collegamento della 3.3Vdc direttamente al gnd.

Le istruzioni per acquisire il segnale analogico sono molto semplici, i commenti nel codice illustrano questo procedimento:

[c]<br />#include "taskFlyport.h"<br /><br />void FlyportTask()<br />{<br /><%%KEEPWHITESPACE%%>  int Valore_ADC = 0;<br /><%%KEEPWHITESPACE%%>  char Dato_ADC[5];<br /><br /><%%KEEPWHITESPACE%%>  while(1)<br /><%%KEEPWHITESPACE%%>  {<br /><%%KEEPWHITESPACE%%>    //acquisisco ildato presente sul pin p18<br /><%%KEEPWHITESPACE%%>    Valore_ADC = ADCVal(4);<br /><%%KEEPWHITESPACE%%>    //converto il valore intero in un array di char<br /><%%KEEPWHITESPACE%%>    sprintf(Dato_ADC, "%d\n", Valore_ADC);<br /><%%KEEPWHITESPACE%%>    //invio il dato al serial monitor<br /><%%KEEPWHITESPACE%%>    UARTWrite(1, Dato_ADC);<br /><%%KEEPWHITESPACE%%>    //attesa di 1 secondo<br /><%%KEEPWHITESPACE%%>    vTaskDelay(100);<br /><%%KEEPWHITESPACE%%>  }<br />}<br />[/c]

L’unica raccomandazione nell’uso dei pin analogici è quella di non superare mai la tensione massima in ingressi di 3.3Vdc. Nel caso in cui la tensione da acquisire fosse maggiore si potrebbe adottare un semplice partitore di tensione.

The post Flyport Ethernet leggere dai pin analogici appeared first on Esperimenti con logiche programmabili.

Quando osservo i robot industriali assemblare, saldare, fresare o posizionare oggetti con una precisione sconcertante rimango affascinato dalla capacità umana di poter costruire queste macchine.
Anche nelle nostre abitazioni sono presenti oggetti dotati di parti meccaniche, che compiono movimenti molto precisi, come ad esempio le stampanti, i plotter e gli scanner.
Questi dispositivi hanno in comune tra loro un particolare dispositivo chiamato motore passo passo (stepper motor).
E’ un trasduttore elettromeccanico che converte degli impulsi elettrici in un movimento fisico. Ad ogni impulso elettrico corrisponde un movimento del rotore; questo spostamento viene chiamato step.
A differenza del motore in corrente continua i motori passo passo possono mantenere la propria velocità di rotazione costante, anche con carico applicato, senza usare sistemi di controreazione (tachimetriche o encoder).
Il motore eroga una coppia elevata, anche con bassi numeri di giri, possiede accelerazioni e frenate repentine ed è capace di mantenere il carico applicato fermo in posizione, senza vibrazioni.

Naturalmente esistono anche degli svantaggi, tra cui la necessità di utilizzare un circuito elettrico di pilotaggio, un rendimento energetico basso, una velocità di rotazione ridotta ed un costo di acquisto elevato.

La figura seguente mostra, in maniera semplificata, il principio di costruzione di un motore passo passo.

Il movimento del rotore avviene alimentando le bobine in modo consecutivo. Eccitando solo la bobina A1 il rotore si posiziona verso NORD, eccitando solo la bobina B1 il rotore si posiziona in direzione EST, eccitando solo la bobina A2 il rotore si posiziona in direzione SUD ed infine eccitando solo la bobina B2 il rotore si posiziona in direzione OVEST.
La tabella seguente riassumere la sequenza.

Seguendo le fasi di alimentazioni A1-B1-A2-B2 il rotore si sposterà in senso orario, invertendo la sequenza B2-A2-B1-A1 il rotore si sposterà in senso antiorario. E’ importante alimentare le bobine in modo sequenziale perché il rotore deve seguire in maniera lineare il campo elettromagnetico generato dalle bobine.

Naturalmente nei motori passo passo reali la sequenza delle 4 fasi fa girare l’albero di un solo passo (step). Il numero dei passi è una caratteristica costruttiva del motore, solitamente ha un valore di 200 step/giro, ma ne esistono anche da 20, 24, 48 e 400 step/giro. Il numero di step può essere espresso in gradi sessagesimali, ad esempio un motore da 7.5° equivale ad uno con 48 step/giro (360°/7.5°=48).
Le 4 fasi di alimentazione delle bobine (considerando un ipotetico motore da 1 step/giro), viene rappresentata dalla figura seguente:

La sequenza di alimentazione è solitamente gestita da un integrato a logica programmabile mentre il compito di fornire l’energia è demandato ad un ponte ad H. Abbiamo affrontato l’utilizzo del ponte H in questo precedente articolo. Per essere più precisi, avendo 4 fili, dobbiamo usare due ponti H uno che alimenta le bobine A1 e A2 e l’altro che alimenta le bobine B1 e B2.

In questo tutorial ho usato come microcontrollore la Arduino Leonardo e come doppio ponte H il driver L298N prodotto da ST Microelectronics. Il motore è un 48 passi/giro operante a 12Vdc, smontato da una vecchia stampante non più funzionante.

Collegamento dei componenti

Il circuito elettrico che permette di pilotare il motore è rappresentato nella figura seguente:

riassumo i collegamenti tramite la tabella seguente

i diodi in contro fase servono per proteggere le uscite dell’integrato L298N da eventuali sovratensioni generate durante l’alimentazione delle bobine.

Il codice necessario per pilotare il motore rispecchia quanto detto precedentemente. In pratica è necessario alimentare in modo consecutivo le bobine rispettando le quatto fasi.

void setup()
{
  //i pin 2-3-4-5 sono
  //configurati come uscite
  pinMode(2, OUTPUT);
  pinMode(3, OUTPUT);
  pinMode(4, OUTPUT);
  pinMode(5, OUTPUT);

  //forzo le uscite a livello logico basso
  digitalWrite(2, LOW);
  digitalWrite(3, LOW);
  digitalWrite(4, LOW);
  digitalWrite(5, LOW);
}

void loop()
{
  //FASE 1
  //Alimento solo la prima bobina
  digitalWrite(2, HIGH);
  digitalWrite(3, LOW);
  digitalWrite(4, LOW);
  digitalWrite(5, LOW);
  delay(10);

  //FASE 2
  //Alimento solo la seconda bobina
  digitalWrite(2, LOW);
  digitalWrite(3, HIGH);
  digitalWrite(4, LOW);
  digitalWrite(5, LOW);
  delay(10);

  //FASE 3
  //Alimento solo la terza bobina
  digitalWrite(2, LOW);
  digitalWrite(3, LOW);
  digitalWrite(4, HIGH);
  digitalWrite(5, LOW);
  delay(10);

  //fase 4
  //Alimento solo la quarta bobina
  digitalWrite(2, LOW);
  digitalWrite(3, LOW);
  digitalWrite(4, LOW);
  digitalWrite(5, HIGH);
  delay(10);

}

Una volta caricato lo sketch, l’albero del motore inizierà a girare in senso orario. Per invertire la rotazione è sufficiente alimentare le bobine dalla fase 4 alla fase 1.

Cambiando il valore del delay() otterremmo una variazione di velocità nella rotazione del rotore.

Se avete delle stampanti vecchie potete subito passare alla pratica realizzando piccoli meccanismi e semplici robot. Volendo si possono collegare alla Leonardo 2 driver L298N per pilotare altrettanti motori passo passo, questo vi permette di poter controllare i due motori simultaneamente creando sistemi meccanici più complessi.

The post L298N pilotare motore passo passo bipolare appeared first on Esperimenti con logiche programmabili.

Molte applicazioni richiedono la variazione continua di alcuni parametri, come ad esempio un alimentatore, un amplificatore audio, un termostato o un varilight che solitamente impiegano un potenziometro analogico e l’intervento manuale di una persona per effettuare queste variazioni.
Possiamo digitalizzare questi sistemi impiegando lo stesso principio di regolazione basato su potenziometro ma invece di agire fisicamente sulla manopola di regolazione possiamo utilizzare dei comandi software per incrementare decrementare il valore resistivo del potenziometro.

Il componente che andremmo ad usare è l’integrato MCP4131-103 prodotto dalla Microchip. E’ un integrato a 8 pin che possiamo comandare tramite il protocollo seriale SPI.
Al suo interno troviamo un potenziometro da 10Kohm.

Il potenziometro è composto da una rete resistiva composta da 128 elementi  il cui valore totale è, nel nostro modello, di 10Kohm. Tramite software possiamo spostare la posizione dello Wiper, che corrisponde al contatto strisciante di un potenziometro meccanico. Gli spostamenti dello Wiper vengono definiti steps e vanno dalla posizione 00H (Wiper collegato al pin P0A) alla posizione 80H(Wiper collegato al pin P0B).
Il potenziometro digitale MCP4131 permette un massimo di 129 steps.

Il datasheet è comune a diversi potenziometri digitali quindi per poter capire quale siano i comandi corretti per pilotare il nostro modello dobbiamo esaminare le parti che ci interessano. La prima sezione riguarda le Caratteristiche del dispositivo (Device Features)

Da questa tabella deduciamo che il dispositivo ha un singolo potenziometro, che i valori della posizione dello Wiper sono memorizzati in RAM (piuttosto che sulla EEPROM). L’interfaccia di comunicazione è SPI, i numeri di Steps sono 129 e il range con cui possiamo alimentare l’integrato va da 1.8Vdc a 5.5Vdc.

L’MCP4131 supporta comandi a 8 bit e a 16 bit. Il comando a 8 bit permette di incrementare o decrementare il valore dello Wiper di uno steps per volta mentre il comando a 16 bit permette di scrivere direttamente sulla RAM il valore della posizione dello Wiper.

Nella figura il comando a 8 bit è composto da 2 bit di dati (che non vengono utilizzati), 2 bit di comando (incremento – decremento)  e 4 bit che definiscono l’indirizzo di memoria che vogliamo usare (indirizzo dello Wiper 00h).
Nella figura del comando a 16 bit la prima parte è identica a quella a 8 bit con la differenza che nei 2 bit di comando possiamo specificare se scrivere o leggere dall’area di memoria del dispositivo, i restanti 8 bit compongono il Data Byte che ci permette di indicare direttamente il valore dello Wiper.

Gli indirizzi di memoria disponibili sono i seguenti:

nel nostro caso utilizzeremmo l’indirizzo 00h, che corrisponde all’unico Wiper disponibile all’interno del nostro chip.

I bit di commando invece sono i seguenti:

Passando alla pratica, se volessi inviare un comando di incremento al Wiper dell’MCP4131, usando la modalità a 8bit, invierei tramite SPI il valore decimale 4

Per decrementare il valore corrente dello Wiper bisogna spedire via SPI il valore decimale 8:

Se volessi spostare il Wiper al centro della sua corsa, utilizzerei la modalità a 16 bit, inviando per primo il dato contenente l’indirizzo di memoria che vogliamo usare e il comando di scrittura

Seguito dal valore della posizione dove vogliamo spostare lo Wiper, in questo esempio il valore 64 decimale (128/2) corrisponde a metà corsa.

Ora che conosciamo come utilizzare il chip possiamo passare alla pratica collegando la porta SPI dell’Arduino all’MCP4131. Nel mio caso ho utilizzato un Arduino Leonardo (la porta SPI è disponibile sui pin dell’header ICSP). Lo schema è il seguente:

L’uscita W è collegata all’ingresso analogico A0 della Leonardo, in questo modo posso misurare il valore di tensione disponibile su tale piedino.
Il Pin B dell’MCP4131, corrispondente alla posizione 00H è collegato a massa mentre il pin A corrispondente alla posizione 80H è collegato alla 5Vdc.
Il codice seguente posiziona lo Wiper nella posizione 00H, ottenendo cosi una tensione pressochè nulla sul pin W (poiche internamente il pin W è collegato con il pin B).

[c]
#include <SPI.h>

void setup()
{
//Definisco il pin come uscita
//il pin 2 viene usato per selezionare il
//chip all’interno di un collegamento SPI
pinMode (2, OUTPUT);

//Inizializzo la libreria SPI
SPI.begin();

//Inizializzo la porta seriale
Serial.begin(9600);

//metto alta la linea CS per
//deselezionare il chip MCP4131
digitalWrite(2, HIGH);

}

void loop()
{
//Inizializzo la posizione dello Wiper
byte Posizione = 0;

//Per selezionare l’MCP4131
//metto basso la linea CS del
//potenziometro digitale
digitalWrite(2, LOW);

//Invio il primo byte per eseguire una scrittura
//sul registro Wiper
SPI.transfer(0);
//Invio il valore della posizione dello Wiper
//valori da 00H a 80H (0-128 in decimale)
SPI.transfer(Posizione);

//metto alta la linea CS per
//deselezionare il chip MCP4131
digitalWrite(2, HIGH);

//eseguo la lettura sul pin analogico A0
//in questo pin è collegato il pin Wiper
//del potenziometro digitale
int Data = analogRead(0);

//spedisco il dato letto al serial Monitor
//Valori da 0 a 1023
Serial.println(Data);

//ritardo di mezzo secondo
delay(500);
}
[/c]

Aprendo il serial monitor otterremmo dei valori prossimi allo zero poichè la tensione in ingresso del pin A0 sarà nulla. Questo è ciò che avviene all’interno dell’MCP4131:

Per posizionare lo Wiper verso il pin A, collegato alla 5Vdc, dobbiamo scrivere sull’indirizzo 00H il valore 80H, come descritto nel codice seguente:

[c]
#include <SPI.h>

void setup()
{
//Definisco il pin come uscita
//il pin 2 viene usato per selezionare il
//chip all’interno di un collegamento SPI
pinMode (2, OUTPUT);

//Inizializzo la libreria SPI
SPI.begin();

//Inizializzo la porta seriale
Serial.begin(9600);

//metto alta la linea CS per
//deselezionare il chip MCP4131
digitalWrite(2, HIGH);

}

void loop()
{
//Inizializzo la posizione dello Wiper
byte Posizione = 128;

//Per selezionare l’MCP4131
//metto basso la linea CS del
//potenziometro digitale
digitalWrite(2, LOW);

//Invio il primo byte per eseguire una scrittura
//sul registro Wiper
SPI.transfer(0);
//Invio il valore della posizione dello Wiper
//valori da 00H a 80H (0-128 in decimale)
SPI.transfer(Posizione);

//metto alta la linea CS per
//deselezionare il chip MCP4131
digitalWrite(2, HIGH);

//eseguo la lettura sul pin analogico A0
//in questo pin è collegato il pin Wiper
//del potenziometro digitale
int Data = analogRead(0);

//spedisco il dato letto al serial Monitor
//Valori da 0 a 1023
Serial.println(Data);

//ritardo di mezzo secondo
delay(500);
}
[/c]

In questo caso aprendo il serial monitor leggeremmo dei valori prossimi a 1023 in quanto sul pin analogico A0 sarà presente la tensione di 5Vdc.
Internamente otterremo questo risultato:

Di conseguenza per avere tutti gli altri valori intermedi potremmo cambiare il valore della variabile Posizione assegnandole valori tra 0 e 128.

The post Usare il potenziometro digitale MCP4131-103 appeared first on Esperimenti con logiche programmabili.

Se anche tu hai difficoltà a ricordare le date degli appuntamenti e sei un tipo creativo e non ti accontenti dei classici promemoria via cellulare, tablet o computer, ma vuoi realizzare qualcosa di insolito, puoi sfruttare la tua passione per l’elettronica e la tua voglia di costruire per realizzare questo progetto di promemoria con Arduino.

Avendo già le basi per poter lavorare con l’integrato RTC DS1307 puoi sfruttare la ram non volatile di questo chip per memorizzare circa 18 date e permettere, ad Arduino, di avvisarti tramite display, led rgb, twitter o quello che ti viene in mente!!

L’idea è quella di utilizzare l’RTC per memorizzare il dato di tempo e sfruttare i 56 byte di flash ram aggiuntive per memorizzare le date degli avvenimenti. Arduino ha il compito di comparare le date e di agire di conseguenza pilotando le uscite digitali.

Parto dal presupposto che la data e l’ora del RTC sia già stata impostata come spiegato nel precedente tutorial.
Per memorizzare le date degli avvenimenti possiamo usare un array di 3 byte (Giorno Mese ed Anno), il codice è il seguente:

[c]
//inserisco la libreria per il bus I2C
#include <Wire.h>

//Variabile per memorizzare l’indirizzo della ram del DS1307
byte IndRam = 0x00;
//array per la data (G M A)
byte Data[3];

void setup()
{
//init bus I2C
Wire.begin();
//init seriale
Serial.begin(9600);

//imposto l’indirizzo iniziale della user ram
IndRam = 0x08;

//avvio la comunicazione con il DS1307
//indirizzo 0x68
Wire.beginTransmission(0x68);
//specifico l’indirizzo a cui voglio accedere
Wire.write(IndRam);

//imposto la data 25/04/12 in esadecimale
Data[0] = 0x19; //giorno 25
Data[1] = 0x04; //mese   04
Data[2] = 0x0C;  //anno   12

//scrivo i 3 byte negli indirizzi 0x08 0x09 0x0A
Wire.write(Data,3);

//chiudo la comunicazione
Wire.endTransmission();

}

void loop()
{}

[/c]

Nel datasheet del DS1307 la ram aggiuntiva inizia all’indirizzo 0x08 e finisce all’indirizzo 0x3F e, sapendo che per memorizzare una data servono 3 byte (G M A), devi sommare alla variabile IndRam valori multipli di 3.
Ad esempio per memorizzare la seconda data IndRam varrà 0x08 + 3 per la terza data 0x08+6 e cosi via fino a 0x08+51, ottenendo così 18 date memorizzabili.

Una volta memorizzate le date che ci interessano, è necessario scrivere del codice che confronti questi valori con quelli dell’RTC e di conseguenza eseguire delle operazioni di output.

Per primo recupero il giorno, mese e anno dell’RTC a partire dall’indirizzo  0x04

e poi recupero i dati della user ram per eseguire il confronto quindi:

[c]

void loop()
{
IndRam = 0x04;

//setto l’indirizzo da ddove iniziare
//a leggere
Wire.beginTransmission(0x68);
Wire.write(IndRam);
Wire.endTransmission();

//recupero 3 byte G M A
Wire.requestFrom(0x68, 3);
byte Giorno = Wire.read();
byte Mese = Wire.read();
byte Anno = Wire.read();

Serial.print(Giorno, DEC);
Serial.print("/");
Serial.print(Mese,DEC);
Serial.print("/");
Serial.println(Anno, DEC);

//recupero tutte le date memorizzate nella user ram
//e le confronto con quella attuale dell’RTC

for( byte Ciclo = 0; Ciclo < 54; Ciclo += 3)
{
IndRam = 0x08 + Ciclo;
//Serial.println(IndRam, HEX);

Wire.beginTransmission(0x68);
Wire.write(IndRam);
Wire.endTransmission();

Wire.requestFrom(0x68, 3);
byte memGiorno = Wire.read();
byte memMese = Wire.read();
byte memAnno = Wire.read();

//confronta i dati

if(Giorno == memGiorno && Mese == memMese && Anno == memAnno)
{
//trovata data
//fai qualcosa
Serial.println("Data OK");
}

delay(10);
}

delay(1000);
}
[/c]

Il codice controlla ciclicamente se la data impostata nell’RTC è presente nella user ram in caso affermativo viene printata la stringa Data OK.
Il codice ha un problema, non tiene conto dell’andamento temporale, infatti viene fatto un controllo di valori che non permette di verificare se una data è precedente o successiva a quella impostata.
Il compito del codice dovrebbe essere quello di avvisarci degli avvenimenti futuri mentre dovrebbe escludere quelli passati.

Per poter confrontare le date tra di loro mi sono avvalso della libreria Time che tra le varie funzioni permette di restituire il numero di secondi trascorsi tra il 1 gennaio 1970 e una data definita.
Ottenendo un numero progressivo posso confrontare due date e capirne l’ordine temporale.

Installare e utilizzare la libreria Time

Sul sito ufficiale di Arduino, seguendo questo link possiamo scaricare la libreria. Scompattiamo il file zip nella cartella Arduino 1.0->libraries. Questa operazione produrrà tre cartelle una con nome Time, DS1307RTC e TimeAlarms. Riavviamo l’IDE per aggiornare le lista delle librerie e degli esempi.

Per utilizzare la libreria nello sketch del progetto che stiamo sviluppando, possiamo inserire a mano la clausola

[c]#include <Time.h>[/c]

oppure dal menu dell’ide eseguiamo Sketch->Import Library->Time

Per ottenere i secondi trascorsi dal 1 gennaio 1970 è disponibile la funzione now(), ma prima, giustamente bisogna settare la data di riferimento, per farlo si utilizza la funzione setTime(ora, minuti, secondi, giorno, mese, anno) quindi il codice precedente viene modificato così:

[c]
#include <Wire.h>
//includo la libreria Time
#include <Time.h>

byte IndRam = 0x00;
byte Data[3];

byte val = 0x00;

//queste variabili servono per memorizzare
//la data in secondi trascorsi dal 1 gen 1970
unsigned long UnixData = 0;
unsigned long memUnixData = 0;

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

//imposto l’indirizzo iniziale della user ram
IndRam = 0x08;

//carico una data da ricordare nei primi
//3 byte della user ram
Wire.beginTransmission(0x68);
Wire.write(IndRam);
Data[0] = 0x05; //giorno 05
Data[1] = 0x04; //mese 04
Data[2] = 0x0C; //anno 12
Wire.write(Data,3);
Wire.endTransmission();

delay(100);

//verifico la data appena impostata
//nella user ram
Wire.beginTransmission(0x68);
Wire.write(IndRam);
Wire.endTransmission();

Wire.requestFrom(0x68, 3);
byte data = Wire.read();
Serial.print(data);
Serial.print("/");
data = Wire.read();
Serial.print(data);
Serial.print("/");
data = Wire.read();
Serial.print(data);
Serial.println("/");

delay(100);
}

void loop()
{
//setto l’indirizzo per accedere alla data
//impostata nell’RTC
IndRam = 0x04;
//setto l’indirizzo da dove iniziare
//a leggere
Wire.beginTransmission(0x68);
Wire.write(IndRam);
Wire.endTransmission();

//recupero 3 byte G M A
Wire.requestFrom(0x68, 3);
byte Giorno = Wire.read();
byte Mese = Wire.read();
byte Anno = Wire.read();

//visualizzo la data dell’RTC
Serial.print(Giorno, DEC);
Serial.print("/");
Serial.print(Mese,DEC);
Serial.print("/");
Serial.println(Anno, DEC);

//setto la libreria Time con la data dell’RTC
setTime(0,0,0, Giorno, Mese, (Anno + 2000));
//Recupero i secondi trascorsi tra la data 1 Gen 1970
//e la data dell’RTC
UnixData = now();
//Visualizzo i secondi trascorsi sul Serial Monitor
Serial.println(now());

//recupero tutte le date memorizzate nella ram
//e le confronto con quella attuale dell’RTC
//trasformandole in secondi in modo da poter confrontare
//le date

for( byte Ciclo = 0; Ciclo < 54; Ciclo += 3)
{
//imposto il primo indirizzo della user ram
//e poi proseguo ciclicamente incrementando di
//3 posizioni
IndRam = 0x08 + Ciclo;
//Serial.println(IndRam, HEX);

//setto l’indirizzo
Wire.beginTransmission(0x68);
Wire.write(IndRam);
Wire.endTransmission();

//recupero i tre byte G M A
//dalla user RAM
Wire.requestFrom(0x68, 3);
byte memGiorno = Wire.read();
byte memMese = Wire.read();
byte memAnno = Wire.read();

//imposto la libreria Time con la data dela user RAM
// per convertirla in secondi
setTime(0,0,0, memGiorno, memMese, (memAnno + 2000));
memUnixData = now();
//Serial.println(now());

//confronto la data in secondi dell’RTC con la data
//appena recuperata dalla user ram

if(UnixData == memUnixData)
{
//trovata data
//fai qualcosa
Serial.println("TROVATA!!!");
}

delay(10);
}

delay(1000);
}
[/c]

Il codice ha lo stesso comportamento di quello iniziale ma adesso c’è la possibilità di eseguire il confronto numerico grazie alla conversione in secondi. Ad esempio per escludere tutte le date passate possiamo fare questa semplice modifica

[c]

//escludi le date passate

if(UnixData >= memUnixData)
{
//trovata data
//fai qualcosa
Serial.println("TROVATA!!!");
}

[/c]

oppure eseguire del codice per avvisarci una settimana in anticipo:

[c] //avvisami una settimana prima
//settimana in secondi 60*60*24*7 = 604800

if((memUnixData – UnixData) <= 604800)
{
//trovata data
//fai qualcosa
Serial.println("TROVATA!!!");
}
[/c]

Avendo il modo di eseguire un confronto numerico tra le date ci offre la possibilità di realizzare ulteriori funzioni, come ad esempio sketch che gestiscono l’Arduino a seconda delle date impostate nella user ram.

Per le operazioni da eseguire quando viene trovata una data possiamo eseguire tutte le tipiche funzioni di output che può gestire Arduino.

[c]
//escludi le date passate
if(UnixData >= memUnixData)
{
//trovata data
//fai qualcosa
Serial.println("TROVATA!!!");
}
[/c]

The post Promemoria alternativo con Arduino e RTC appeared first on Esperimenti con logiche programmabili.

Mi è sempre piaciuta l’idea di un orto/giardino automatizzato, magari con Netduino, capace di sfruttare l’irrigazione in modo coscienzioso e senza sprechi d’acqua.
Penso sia uno di quei progetti molto ricercati per la sua evidente utilità pratica, e anche perché la coltivazione e la cura di piante è un istinto innato che ci avvicina alla natura e ci fa sentire bene!

Abito in un piccolo paese dove ogni famiglia possiede un piccolo orto per la coltivazione di verdure e frutti. La tecnica di irrigazione principale è quella a solco (scorrimento), decisamente svantaggiosa e poco efficace per l’eccessivo spreco d’acqua.
Fortunatamente oggi ci sono molte tecnologie efficienti che permettono l’impiego di sistemi programmabili per la gestione delle attività di irrigazione.

Anche io ho voluto sviluppare il mio sistema a microcontrollore per gestire le fasi di irrigazione di un piccolo orto.
Per la realizzazione di questo sistema bisogna avere un minimo di esperienza nella coltivazione di piante ed essere consapevoli che ci dovremmo sporcare le mani!!

La tecnica di irrigazione migliore per questo progetto si basa sulla microirrigazione a goccia. E’ necessario quindi procurarci tutto il materiale per l’impianto. Le mie informazioni progettuali sono da considerare di carattere generale, dato che il sistema è influenzato da vari parametri come, la tipologia del terreno (inclinazione, consistenza, composizione, esposizione agli agenti atmosferici) il tipo e la quantità di piantine da coltivare.La figura seguente rappresenta un tipico impianto a goccia automatizzato:

La cisterna contiene l’acqua necessaria ad irrigare le piante, le sue dimensioni variano a seconda della dimensione dell’orto, un valore sufficiente per una autonomia di 2-3 settimane potrebbe essere di 1000 litri.
Subito dopo troviamo il filtro, questo elemento è essenziale per un impianto di microirrigazione in quanto blocca le impurità dell’acqua che col tempo potrebbero otturare i gocciolatori.
L’elettrovalvola è un rubinetto elettronico che permette, tramite la centralina elettronica, di gestire tutte le fasi d’irrigazione. La centralina riceve input dai sensori di umidità, temperatura e luminosità, in questo modo possiamo sviluppare algoritmi che gestiscono l’irrigazione in funzione dei parametri ambientali.

Il tubo di mandata principale permette di alimentare i vari rami dell’impianto, ogni ramo (ala gocciolante) è sezionabile tramite un minirubinetto, questo permette di effettuare operazioni di manutenzione anche durante l’irrigazione.
L’ala gocciolante è composta da un tubo, solitamente da 16mm, dove sono collocati i gocciolatori. Ogni gocciolatore irriga una singola pianta.

La realizzazione dell’impianto dipende dalla dimensione del terreno a disposizione e dal numero e tipo di piante da coltivare. Secondo la mia esperienza vi posso dire che per il fabbisogno di una famiglia di 5-6 persone potete coltivare i seguenti prodotti

• 20 piante Pomodoro
• 10 piante Melanzane
• 10 piante Peperoni
• 20 piante Fagiolini
• 10 piante Cetrioli
• 5 piante Zucchine
• 20 piante Lattuga

naturalmente ognuno può aumentare o diminuire queste quantità a seconda delle preferenze e dei gusti personali.
Per quanto riguarda la distanza tra gocciolatori possiamo dimensionare in questo modo

• 40-50 cm per Pomodori, Melanzane, Peperoni, Fagiolini e Cetrioli
• 60-70 cm per le Zucchine
• 15-20 cm per le Lattughe

Mentre la distanza tra un ala gocciolante e la successiva può variare da 40-50 cm a  80-100cm a seconda dello spazio a disposizione, e della comodità che vogliamo avere per passare tra i filari.

Dopo l’assemblaggio dell’impianto è necessario verificare che tutti i gocciolatori funzionino a dovere e che non ci siano perdite d’acqua dai raccordi di connessione.

La parte che ora bisogna studiare, riguarda la centralina elettronica. Certamente sul mercato esistono vari modelli con prezzi anche di poche decine di euro, che potrebbero farci abbandonare l’idea dell’autocostruzione, ma il nostro scopo è quello di sperimentare e imparare nuovi concetti per poi applicarli in altri ambiti o per accrescere il nostro bagaglio culturale.

Apro una piccola parentesi sull’elettrovalvola: a parte le varie dimensioni e capacità idriche, esistono modelli a 24Vac e a 9Vcc. Volendo creare un impianto autonomo è meglio utilizzare il modello a 9Vcc in modo da eliminare qualsiasi trasformatore. Il costo delle elettrovalvole in continua è purtroppo superiore a quelle in ca (circa 30€).

Il circuito elettronico deve acquisire come input i dati dai sensori e pilotare l’elettrovalvola per un tempo che può essere fisso o variabile a seconda del software che andremmo a sviluppare.
Come microcontrollore possiamo optare per diverse soluzioni come Netduino piuttosto che Arduino o Picmicro. Certamente un fattore importante è il costo, che si aggira intono ai 30€ per Netduino/Arduino mentre per i Picmicro siamo intorno ai 3-8€.
In una prima fase possiamo usare Netduino per creare un prototipo, per poi eseguire un porting del progetto su Picmicro in modo da abbattere i costi di realizzazione della centralina.

I sensori del mio prototipo sono tre, un sensore di temperatura analogico tipo MCP9700a, un sensore di luminosità basato su fotoresistenza e un sensore di umidità realizzato con due puntali da inserire nel terreno.
Il Netduino acquisisce tramite gli ingressi analogici questi segnali e in base al suo software gestisce un piccolo relè che va a pilotare l’elettrovalvola.
Nella figura seguente è rappresentato lo schema a blocchi:

Credo che le informazioni di questo articolo siano sufficienti per iniziare a costruire il proprio orto automatizzato. Certamente le nozioni per la realizzazione dell’impianto di microirrigazione sono da approfondire ma con un po di manualità si può apprendere da soli come impostare e realizzare il proprio sistema idrico.
Per quanto riguarda la parte della realizzazione della centralina elettronica vi rimando al prossimo articolo.

The post Netduino e irrigazione automatica fai da te (Teoria) appeared first on Esperimenti con logiche programmabili.

Nella prima parte abbiamo visto come comunicare con il sensore di temperatura MCP9803 utilizzando il bus I2C per leggere il valore di temperatura contenuto nel Temperature Register.
Proveremmo ora a fare qualcosa di più interessante variando alcuni parametri del sensore. Il circuito elettrico è sempre quello impiegato nella prima parte dell’articolo.

Il register pointer permette di selezionare 4 registri differenti a seconda di come vengono impostati i bit P0 e P1.

Per cambiare la risoluzione del convertitore dobbiamo accedere al registro di configurazione. Come mostra la tabella della figura precedente bisogna impostare il bit P1 a 0 ed il bit P0 a 1.

La figura seguente Riporto in figura il registro Configuration register  come illustrato nel datasheet:

Come è possibile osservare questo registro permette di eseguire diverse operazioni. Quella che a noi ci interessa è relativa alla sezione Resolution (Bit5 e Bit6). Quando il sensore di temperatura viene alimentato i bit di questo registro sono impostati tutti a 0 (Power-up default).

Le operazioni che dobbiamo eseguire per impostare la risoluzione del convertitore a 12bit sono le seguenti:

1. Selezionare il sensore tramite l’indirizzo
2. Selezionare il registro di configurazione
3. Impostare i bit5 e il bit6 a 1
4. Selezionare il registro della temperatura
5. Leggere dal registro della temperatura

Queste sono le illustrazioni presenti nel datasheet:

Il master invia un comando di Start, invia un byte contenente l’indirizzo del sensore (7bit) e il flag di lettura/scrittura, nel nostro esempio 1001000 (0x90 in esadecimale). Il sensore risponde con un acknowledges (ACK), il master invia il secondo un byte che sarà scritto sul Pointer Register. Questo valore è 00000001 (0x01 in esadecimale) che seleziona il Configuration Register. Il sensore risponde con un acknowledges. Il master invia un terzo byte 01100000 (0x60 in esadecimale) che sarà scritto nel configuration register. Il sensore risponde con un acknowledges. Il master termina la comunicazione con un comando di Stop.

Ora possiamo eseguire la procedura di lettura come abbiamo visto nella prima parte:

Riassumiamo la procedura:

• Il master invia un comando di Start
• Il master invia un byte contenente l’indirizzo dello slave e il flag di lettura/scrittura impostato su lettura (1).
• Il sensore risponde con un acknowledges.
• Il master legge il primo byte dallo slave e  invia un acknowledges.
• Il master legge il secondo Byte e invia un not acknowledges(NAK) per indicare allo slave la fine della lettura.
• Il master invia il comando di stop.

Utilizzando la tabella di esempio possiamo apprendere come i dati verranno scritti nel Temperature Register:

Prendiamo per esempio la colonna 12bit ed una temperatura ambiente di 25.4375°C, il valore binario presente nel Temperature Register è 000110010111. Il primo byte letto dal pic è 00011001 mentre il secondo byte letto è 01110000.
Il primo byte letto dal pic è quello più significativo mentre il secondo è quello meno significativo. Per ottenere il valore della temperatura ambiente, campionata dal sensore, dobbiamo prendere il valore binario del secondo byte e unirlo al valore binario del primo byte in questo modo

00011001 + 0111 => 000110010111

il valore ottenuto è 000110010111 che convertito in decimale diviene 407. La temperatura viene calcolata utilizzando la formula seguente:

n nel nostro caso vale -4 perché la risoluzione del convertitore è settata a 12bit, di conseguenza la nostra formula per calcolare la temperatura diventa:

407 * 2^-4 => 407 * 0.0625 => 25.4375°C

Il codice di esempio seguente è compilato e caricato sul pic16f876, sono presenti numerosi commenti che illustrano il funzionamento del programma:

unsigned short Primo_Byte = 0;
unsigned short Secondo_Byte = 0;

void main()
{
//inizializzo la porta UART
//a 9600bps
UART1_Init(9600);
//Inizializzo la porta I2C
//con una velocità di 400Khz
I2C1_Init(400000);

//Attendo 100 millisecondi
Delay_ms(100);

//procedura per variare la risoluzione
//del convertitore digitale
//invio uno Start sul bus I2C
I2C1_Start();
//Invio l'indirizzo 1001000
//setto il bit per la scrittura
I2C1_Wr(0x90); //10010000
//Seleziono il registro di configurazione
I2C1_Wr(0x01); //00000001
//scrivo sul Configuration Register il valore 96
//per impostare 12bit di risoluzione
I2C1_Wr(0x60);
//termino la comunicazione
I2C1_Stop();

//invio uno Start sul bus I2C
I2C1_Start();
//Invio l'indirizzo 1001000
//setto il bit per la scrittura
I2C1_Wr(0x90); //10010000
//scrivo sul Register point il valore 0
//per accedere al Temperature Register
I2C1_Wr(0x00);

//ciclo infinito per leggere
//continuamente la temperatura
while (1)
{
//invio uno Start sul bus I2C
I2C1_Start();

//Invio l'indirizzo 1001000
//setto il bit per la scrittura
I2C1_Wr(0x91); //10010001
//leggo il primo Byte ed invio un acknowledge
Primo_Byte = I2C1_Rd(1);
//leggo il primo Byte ed invio un NOT acknowledge
Secondo_Byte = I2C1_Rd(0);
//Invio uno stop sul bus I2C
I2C1_Stop();

//Invio sulla seriale i dati letti dal sensore
UART1_Write(Primo_Byte);
UART1_Write(Secondo_Byte);

//attendo 2 secondi tra una lettura e la
//sucessiva
Delay_ms(2000);

}
}

Quello che adesso rimane da fare è il software lato pc che acquisisce i dati dalla seriale. Ho utilizzato Visual C# per creare un’applicazione windows form.
Anche in questo caso il codice seguente è ricco di commenti che permettono di capire meglio il programma:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;

using System.Collections;
using System.IO.Ports;

namespace SensoreTemperaturaMCP9803
{
public partial class frmMain : Form
{
//variabili per la lettura dalla seriale
Double temperaturaRX = 0;
Int16 Temperatura = 0;
Byte[] bytesRicevuti = new Byte[2];

//creo un delegate per accedere dal thread secondario a quello principale
public delegate void AggiornaTXT(string _str);

/// <summary>
/// questa funzione permette di accedere alla textbox da un thread secondario
/// </summary>
/// <param name="str">Testo da inserire nella textbox</param>
public void FormTxtUpdate(string str)
{
if (this.txtTemperatura.InvokeRequired)
{
AggiornaTXT updaterdelegate = new AggiornaTXT(FormTxtUpdate);
this.Invoke(updaterdelegate, new object[] { str });
}
else
{
txtTemperatura.Text = str;
}
}

/// <summary>
/// Questa funzione converte un valore binario in un valore a 16 bit
/// </summary>
/// <param name="ValoreBinario">Valore in bit</param>
/// <param name="Start">Indice di partenza del BitArray</param>
/// <param name="NumBit">Numero di bit da convertire</param>
/// <returns></returns>
private Int16 ConverToDecimal(BitArray ValoreBinario, Int32 Start, Int32 NumBit)
{
Int32 Ciclo = 0;
Int16 Valore = 0;

for (Ciclo = 0; Ciclo < NumBit; Ciclo++)
{
if (ValoreBinario[Ciclo + Start])
Valore |= (Int16)(1 << Ciclo);
}

return (Valore);
}

public frmMain()
{
InitializeComponent();
}

/// <summary>
/// Questo evento viene generato ala ricezione di un byte sulla seriale
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void RS232_DataReceived(object sender, SerialDataReceivedEventArgs e)
{
//questa funzione viene eseguita in un thread secondario

//quando sono disponibili almeno 2 byte inizia
//l'elaborazione
if (RS232.BytesToRead >= 2)
{
//leggi 2 byte e memorizzali nell'array bytesRicevuti
RS232.Read(bytesRicevuti, 0, 2);

//inverto l'array
Array.Reverse(bytesRicevuti);
//converto l'array di 2 byte in un array di bit
BitArray ba = new BitArray(bytesRicevuti);

//ottengo il valore della temperatura utilizzando solo i bit validi
//versione con risoluzione a 9bit
//Temperatura = ConverToDecimal(ba, 7, 8);
//calcolo il valore della temperatura
//se il valore del convertiore è a 9 bit devo moltiplicare per 0.5
//temperaturaRX = Temperatura * 0.5;

//ottengo il valore della temperatura utilizzando solo i bit validi
//versione con risoluzione a 12bit
Temperatura = ConverToDecimal(ba, 4, 12);
//calcolo il valore della temperatura
//se il valore del convertiore è a 12 bit devo moltiplicare per 0.0625
temperaturaRX = Temperatura * 0.0625;

//rappresento il valore della temperatura nella textbox
FormTxtUpdate(Convert.ToString(temperaturaRX) + " °C");
}
}

private void frmMain_Load(object sender, EventArgs e)
{
//apro la seriale per iniziare a leggere i dati
RS232.Open();
}

private void frmMain_FormClosed(object sender, FormClosedEventArgs e)
{
//alla chiusura del form chiudo la comunicazione seriale
RS232.Close();
}

private void btnChiudi_Click(object sender, EventArgs e)
{
//chiudi
Close();
}
}
}

Le operazioni che esegue il programma sono riassunte in questo modo:

• La porta seriale viene aperta per poter acquisire i dati
• Un gestore di evento viene scatenato quando sulla seriale arrivano dei dati
• Il gestore di evento leggere due byte alla volta.
• Il gestore di evento elabora i due byte in modo da ottenere il valore decimale del dato della temperatura
• Il valore della temperatura è visualizzato su un controllo textbox

Adesso potete divertirvi con il codice per creare un datalogger della temperatura e magari creare un sistema con più sensori di temperatura.

Come sempre suggerimenti e critiche sono sempre ben accette.

Buon divertimento!

The post Accedere ai registri dell’MCP9803 (2° parte) appeared first on Esperimenti con logiche programmabili.

Il mondo dell’elettronica, come sapiamo, è composto da migliaia di componenti che svolgono funzioni dedicate, come un sensore di temperatura, oppure sono capaci di gestire diverse operazioni come nel caso dei microcontrollori.
La tecnologia analogica ha pian piano lasciato il posto a quella digitale e i componenti hanno iniziato a colloquiare tra loro utilizzando vari protocolli di comunicazione (insieme di regole che determinano il funzionamento della comunicazione).
Oggi, la maggior parte dei circuiti utilizza un microcontrollore, il cui compito è quello di gestire il circuito ed i componenti ad esso collegato.
Nel caso di sistemi complessi i componenti che creano il circuito sono diversi e possono saturare la capacità fisica di collegamento del microcontrollore, come nel caso proposto in figura.

Ben presto si è capito che per snellire questo tipo di circuiti era necessario creare un meccanismo capace di ottimizzare l’interconnessione tra componenti e microcontrollore. Il sistema più efficace è certamente quello di adottare un bus di collegamento, che permette lo scambio di dati, tra componenti e microcontrollore, utilizzando pochi fili comuni.
La figura seguente mostra un esempio di bus dove diversi componenti sono interconnessi utilizzando solo 2 fili. Il microcontrollore in questo caso deve gestire la comunicazione utilizzando un protocollo comune a tutti i componenti.
Diverse aziende svilupparono dei protocolli che col tempo sono divenuti degli standard, in questo modo componenti e microcontrollori hanno iniziato a scambiarsi dati in modo semplice ed efficiente.

La Philips negli anni ’80 sviluppò il Bus I2C (Inter Integrated Circuit pronunciato i-quadro-ci o i-due-ci), un protocollo seriale che usa due fili per instaurare la comunicazione con i componenti.

Tipicamente questo protocollo richiede un master (il microcontrollore che gestisce la comunicazione), e uno o più componenti slave (sensori, ADC, DAC, memorie ecc… che inviano i dati al microcontrollore).
Gli slave vengono identificati nel bus tramite un indirizzo univoco. Il master invia sulla linea l’indirizzo dello slave con cui vuole instaurare la comunicazione.
E’ possibile un sistema con più master (multimaster) ma la comunicazione deve sempre essere gestita da un master alla volta.

Il bus I2C permette di collegare agli stessi due fili ben 112 dispositivi. La velocità di comunicazione non è elevatissima e puoi variare, tipicamente, da un minimo di 10Kbits/s fino a 400Kbits/s (sviluppi successivi del bus I2c hanno permesso velocità fino a 3.4Mbits/S e interconnessioni di 1024 componenti).

I segnali presenti sui fili sono chiamati SDA (Signal DAta) per il trasferimento dei dati e SCL (Serial Clock Line) per la sincronizzazione della linea. In figura è rappresentato il diagramma dei segnali:

Il master deve eseguire, per avviare la comunicazione, una commutazione della linea SDA dallo stato alto allo stato basso, quando il segnale SCL è alto (vedi riquadro Start).
Successivamente il master può inviare dati sulla linea SDA.
Quando il segnale SCL è basso il master inizia a scrivere il valore del bit (1 o 0); quando il segnale SCL è alto, il bit è stabile e può essere letto dallo slave (riquadro BIT1).Questo procedimento si ripete per tutti i bit (Riquadro BIT2 e BIT N).
Quando tutti i bit sono stati inviati, la comunicazione termina quando il master riporta la linea SDA a livello alto in concomitanza del livello alto della linea SCL (riquadro Stop).

Questo esempio spiega il comportamento tipico dei segnali sul bus.

La comunicazione tra master e slave è risulta nella pratica più complessa di quanto espresso precedentemente. Per capire meglio è utile analizzare un esempio reale, perciò ho realizzato un semplice circuito che impiega un Pic 16F876 e un sensore di temperatura digitale MCP9803 che colloquiano utilizzando il bus I2C.

Lo schema elettrico è il seguente:

Il circuito utilizza un microcontrollore per comunicare con il sensore di temperatura MCP9803. I dati acquisiti vengono acquisiti e inviati tramite la porta UART del pic al pc. Il Max233 converte i segnali TTL in segnali RS232.

Partiamo con lo studio del datasheet del sensore MCP9803. Le caratteristiche principali sono riassunte nella tanella seguente:

Il pin 1 (SDA) del sensore è collegato direttamente al pin 15 del pic (SDA), mentre il pin 2 (SCLK) del sensore è collegato al pin 14 del pic (SCL).

I pin 5, 6, 7 del sensore (A0, A1, A2) permettono di definire l’indirizzo del dispositivo all’interno del bus. Sul datasheet possiamo leggere come viene impostato:

Per comporre l’indirizzo sono necessari 7 bit. Nei modelli 9800/xxxx gli indirizzi sono predefiniti, mentre nell’MCP9803 i bit A3, A4, A5, A6 sono scelti dalla casa costruttrice e i bit A0, A1, A2 sono impostabili dall’utente.

Nel circuito in questione, i pin A0, A1, A2 sono collegati a massa, quindi a valore logico 0, di conseguenza l’indirizzo del nostro sensore è 1001000 (0x48 in esadecimale).

Bene ora l’MCP9803 può essere identificato dal pic usando l’indirizzo a 7 bit.

Scorrendo il datasheet, andiamo nella sezione register:

Il sensore ha un registro che permette di accedere ai vari registri interni, come ad esempio il Configuration Register dove possiamo cambiare la risoluzione del convertitore digitale. Vedremmo poi come cambiare la risoluzione da 9bit (valore di default) a 12bit.
Quello che ci serve ora è leggere il dato del ‘Temperature Register’. Per selezionarlo è sufficiente porre il bit0(P0) e il bit1(P1) a 0 (Questo registro è a 0 per default ma eseguiamo comunque l’operazione ai fini didattici).

Ora studiamo la sezione dove è illustrata la sequenza di comunicazione tra il master ed il sensore MCP9803.

Si inizia con il comando di start (SDA va basso quando SCLK è alto – vedi box rosso ‘S’) poi il master scrive i 7 bit dell’indirizzo dello slave (1001000) più un bit che definisce se vogliamo leggere o scrivere nei registri dello slave (Se questo bit è a 1 leggeremo i dati dallo slave se è a 0 scriveremo i dati nello slave).
Questa informazione del bit che definisce la lettura o la scrittura è presente in questa sezione del datasheet.

Il master invia il seguente valore binario 10010000 (0x90 in esadecimale) per scrivere sullo slave.
Dopo l’invio del byte sul bus I2C, lo slave risponde con un acknowledges (pone la linea SDA bassa quando il SCLK è alto).
Ora il master invia un secondo byte per scrivere sul register point il valore necessario a selezionare il registro Temperature Regiser (Bito e Bit1 a 0). Il sensore risponde con un altro acknowledges.

Adesso che abbiamo impostato il sensore, per leggere dal registro contenente il dato della temperatura, possiamo avviare l’operazione di lettura.
Controlliamo ancora il datasheet  e appuriamo che il dato della temperatura è espresso con due byte.

L’operazione per leggere due byte consecutivi dal registro selezionato è rappresentata in figura:

Inviamo un comando si Start, poi l’indirizzo dello slave (0x48) ed il bit di selezione lettura/Scrittura impostato a 1(lettura). Il valore binario risultante è 10010001 (0x91 in esadecimale).

Il sensore risponde con un acknowledges. Il master esegue la lettura del primo byte, invia un acknowledges, legge il secondo byte ed invia un not acknowledges (indica allo slave la fine della lettura).
Il master termina la comunicazione inviando un comando di stop (riquadro P).

Il codice che permette al pic di eseguire tutte queste operazioni è stato scritto utilizzando MikroC Pro della Mikroelektronika. Il linguaggio, basato sulla sintassi del C, risulta molto semplice e facile da scrivere.
Inoltre sono disponibili molte librerie che svolgono molte operazioni tra le quali quella relativa all’uso del bus I2C.

Il codice caricato sul pic16F876 è il seguente:

unsigned short Primo_Byte = 0;
unsigned short Secondo_Byte = 0;

void main()
{
//inizializzo la porta UART
//a 9600bps
UART1_Init(9600);
//Inizializzo la porta I2C
//con una velocità di 400Khz
I2C1_Init(400000);

//Attendo 100 millisecondi
Delay_ms(100);

//invio uno Start sul bus I2C
I2C1_Start();
//Invio l'indirizzo 1001000
//setto il bit per la scrittura
I2C1_Wr(0x90); //10010000
//scrivo sul Register point il valore 0
//per accedere al Temperature Register
I2C1_Wr(0x00);

//ciclo infinito per leggere
//continuamente la temperatura
while (1)
{
//invio uno Start sul bus I2C
I2C1_Start();

//Invio l'indirizzo 1001000
//setto il bit per la scrittura
I2C1_Wr(0x91); //10010001
//leggo il primo Byte ed invio un acknowledge
Primo_Byte = I2C1_Rd(1);
//leggo il primo Byte ed invio un NOT acknowledge
Secondo_Byte = I2C1_Rd(0);
//Invio uno stop sul bus I2C
I2C1_Stop();

//Invio sulla seriale i dati letti dal sensore
UART1_Write(Primo_Byte);
UART1_Write(Secondo_Byte);

//attendo 2 secondi tra una lettura e la
//sucessiva
Delay_ms(2000);

}
}

Il pic acquisisce il segnale ed invia i dati grezzi al pc che dovrà interpretarli ed elaborarli secondo la formula presente nel datasheet:

dove Code è il dato grezzo letto dal sensore, mentre n dipende dal valore di risoluzione del convertitore (-1 per 9bit di risoluzione, -2 per 10bit di risoluzione, -3 per 11bit di risoluzione e -4 per 12bit di risoluzione).

Il datasheet mostra una tabella di esempio che possiamo usare per capire come avviene questo calcolo:

L’esempio con 9bit di risoluzione e una temperatura ambiente di 125°C produce un valore binario formato da 9bit, suddivisi in due byte, il primo con valore binario di 01111101 e il secondo con valore binario 00000000 (vedi riquadri 1° Byte e 2° Byte). Questi due byte devono essere uniti per formare un valore intero.
Il primo byte è quello più significativo mentre il secondo è quello meno significativo, quindi uniamo il bit del secondo byte al primo:

01111101 + 0 = 011111010 => 0xFA (esadeciale) => 250 (Decimale)

Ora applichiamo la formula per calcolare la temperatura

250 * 2^-1 = 250 * 0.5 = 125°C

Nella seconda parte illustrerò come acquisire i dati inviati dal pic con la seriale e come cambiare la risoluzione di campionamento da 9bit a 12bit.

Come sempre aspetto i vostri suggerimenti.

The post Protocollo I2C e sensore di temperatura MCP9803 (1°parte) appeared first on Esperimenti con logiche programmabili.

Sfruttiamo il Netduino per la realizzazione di un dispositivo che permette la lettura della temperatura tramite il sensore MCP9700A.
Il sensore fornisce una tensione analogica proporzionale alla temperatura rilevata. E’ un dispositivo molto semplice e compatto, ha tre pin, uno per l’alimentazione, uno per la massa e uno per la tensione analogica di uscita.

Per capire come collegare questo sensore al Netduino analizziamo prima le sue caratteristiche. Può essere alimentato da un intervallo di tensione che va da 2.3Vdc a 5.5Vdc, misura temperature che vanno da un minimo di -40°C a un massimo di 125°C con una precisione tipica di -+1°C (-+2°C massima). Ad una temperatura di 0°C il dispositivo eroga in uscita una tensione di 500mV utile come riferimento di partenza per il nostro circuito. La variazione di un grado produce una variazione di tensione di 10mV. La minima tensione in uscita dal sensore è di 100mV mentre quella massima è di 1.75V.
Per approfondire tutti gli aspetti di questo sensore potete consultare il suo datasheet.
La tabella seguente mostra un riassunto di quanto detto:

Il grafico seguente mostra invece la curva di risposta del sensore.

La precisione del sensore è garantita alimentandolo a 3.3Vdc. In effetti, a parità di temperatura rilevata, alimentandolo prima a 3.3Vdc e poi a 5Vdc ho notato delle differenze di tensione in uscita dal sensore.
Come sappiamo il gli ingressi analogici del Netduino possono accettare una tensione massima di 3.3Vdc, l’MCP9700A può essere collegato direttamente all’ingresso analogico poiché la sua massima tensione in uscita è pari a 1.75Vdc.
Il Netduino dispone di un’alimentazione da 3.3Vdc che ho utilizzato per alimentare il sensore.

Il valore di tensione in uscita dal sensore viene collegato all’ingresso A0 del Netduino per essere digitalizzato; questo dato viene inviato al PC usando la comunicazione RS232.

Il circuito elettrico è il seguente.

Il software per la gestione del circuito è composto da una parte relativa all’acquisizione del segnale analogico del sensore e da una parte che gestisce la comunicazione RS232 con il PC.
Di seguito il codice C#:

public static void Main()
{
SerialPort UART1 = new SerialPort("COM1", 9600, Parity.None,
8, StopBits.One);
AnalogInput AN0 = new AnalogInput(Pins.GPIO_PIN_A0);
Byte[] IntToByte = new Byte[2];
Int16 Analog0 = 0;

UART1.Open();

while (true)
{
//acquisisci il valore analogico
Analog0 = (Int16)AN0.Read();

//copio il valore intero in due byte
IntToByte[0] = (byte)(Analog0 & 0xff);
IntToByte[1] = (byte)((Analog0 >> 8) & 0xff);

//invia al pc un informazione
UART1.Write(IntToByte, 0, IntToByte.Length);
//attendi 500 millisecondi
Thread.Sleep(500);
}

UART1.Close();
}

Dopo aver definito gli oggetti per la comunicazione seriale e per l’acquisizione del segnale analogico, il programma entra in un ciclo infinito e ogni 500 millisecondi la funzione Read() esegue una lettura del segnale analogico proveniente dal sensore MCP9700A, questo valore è memorizzato in una variabile intera.
Per poter spedire questo valore tramite l’oggetto UART1, devo convertirlo in un array di Byte. Le istruzioni seguenti svolgono questo compito

//copio il valore intero in due byte
IntToByte[0] = (byte)(Analog0 & 0xff);
IntToByte[1] = (byte)((Analog0 >> 8) & 0xff);

Queste istruzioni servono a mettere i primi 8bit della variabile Analog0(16bit) nel primo byte dell’array e i successivi bit nel secondo byte dell’array.
Ho realizzato questa illustrazione per spiegare meglio cosa avviene utilizzando le funzioni precendenti:

Colleghiamo il Netduino al pc per alimentare il circuito ed eseguiamo il Debug(f5) per caricare il programma. A compilazione e programmazione avvenuta, avviamo hyper terminal per leggere i dati dalla seriale. Per maggiorni informazioni su hyper terminal potete rileggere l’articolo riguardante Netduino e RS232.

Ora che tutto è funzionante dobbiamo ragionare sull’interpretazione dei dati inviati al pc. La proporzione seguente ci permette di ottenere il valore della tensione sull’ingresso analogico in base al valore intero che il Netduino invia al pc:

MaxTenADC : Risol_ADC = TensADC : ValInt

dove:
MaxTenADC = 3.3Vdc tensione massima applicabile al pin analogico del Netduino
Risol_ADC = 10bit (1024) massima risoluzione del convertitore analogico digitale del Netduino
TensADC = tensione applicata al pin analogico
ValInt = valore intero ottenuto dalla conversione

Facciamo un esempio pratico, se il Netdino invia al pc un valore di 156 possiamo calcolare la tensione in ingresso in questo modo:

(MaxTenADC * ValInt) / Risol_ADC

(3.3Vdc * 156) / 1024 = 0.502 Vdc

quindi sull’ingresso analogico misureremo una tensione di circa 500 mVdc. Considerando la curva di risposta del sensore appuriamo che, con una tensione di 500mV, la temperatura misurata è di 0°C. Il datasheet ci dice che ad ogni variazione di grado corrisponde una variazione di 10mV, ciò ci permette di fare un calcolo per ottenere il valore in gradi in base al numero inviato dal Netduino via seriale.

(((3.3Vdc * 156) / 1024) – 0.5)/0.01 = 0.2°C

dove:
3.3Vdc è la tensione massima applicabile all’ingresso analogico
156 è il valore intero ottenuto dalla conversione analogico digitale
1024 è il massimo valore intero ottenibile con la conversione analogico digitale
0.5 è la tensione del sensore a 0°C
0.01 è la variazione di tensione per ogni grado (10mv/°C)

con questo semplice esperimento abbiamo creato un termometro capace di inviare i dati ad un pc. Volendo possiamo acquistare un ulteriore sensore di temperatura e collegarlo ad un altro ingresso analogico per creare un termometro differenziale.
In allegato trovate un file di progetto C# per leggere i dati dalla seriale.

Vi aspetto con commenti e suggerimenti e vi rimando al prossimo esperimento!

The post MCP9700A Netduino e sensore di temperatura analogico appeared first on Esperimenti con logiche programmabili.