• Codice Python sul Raspberry SQLite
• Codice sull’Arduino MKR Zero

Il progetto che ho realizzato riguarda il monitoraggio di temperatura e umidità all’interno di un locale tecnico. I dati rilevati da un sensore DHT22 vengono acquisti da una Arduino MKR Zero e tramite una shield MKR ETH inviati a un computer Raspberry PI 4 che dopo averli acquisiti li memorizza all’interno di una tabella SQLite.

Il protocollo utilizzato per l’invio dei dati si basa su UDP come abbiamo visto in questo articolo.

I dati sarebbero potuti essere memorizzati in un semplice file di testo ma ho preferito usare un database in modo tale da estrarli in modo rapido utilizzando semplici query. Il database contiene per ora una tabella contenente i seguenti campi:

Il codice seguente gira sul Raspberry Pi 4; ho inserito diversi commenti che spiegano le varie istruzioni contenute nel programma:

import sqlite3
import socket
import threading
import time

#IP computer locale
UDP_IP_ADDR = "192.168.178.50"
#Porta computer locale
UDP_PORT_NUMBER = 20002

ip_port_Data = (UDP_IP_ADDR, UDP_PORT_NUMBER)
   
def client_Receive_Data():
    print("Avvio THREAD Receive Data...")
    serversocket1 = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    serversocket1.bind(("192.168.178.30", 20001))
    msgToSend = str.encode("DB_OK")
    
    #crea connessione al database
    connection = sqlite3.connect('lopro.db')
    cursor = connection.cursor()
        
    try:            
        while True:            
            data, address = serversocket1.recvfrom(1024)
            strData = bytes.decode(data).split(":")
         
            sql = """ INSERT INTO tbl_log(Temperatura, Umidita) VALUES ('{}', '{}');""".format(strData[0], strData[1])
            
            print(sql)
            
            cursor.execute(sql)
            connection.commit()

            #invia al device una risposta
            serversocket1.sendto(msgToSend, ip_port_Data)
            time.sleep(1)
    except:
        print("errore")
        msgToSend = str.encode("ERRORE")
        serversocket1.sendto(msgToSend, ip_port_Data)
        connection.close()

def crea_tabella():
    #una volta creata la tabella possiamo evitare di chiamare
    #questa funzione ad ogni esecuzione del programma
    #crea connessione al database
    connection = sqlite3.connect('lopro.db')
    cursor = connection.cursor()
 
    #Se esiste la tabella cancellala
    #cursor.execute("DROP TABLE IF EXISTS tbl_log")
 
    # Crea la tabella se non esiste
    table = """ CREATE TABLE IF NOT EXISTS tbl_log (
            ID INTEGER PRIMARY KEY AUTOINCREMENT,
            Data TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
            Temperatura VARCHAR(50) NOT NULL,
            Umidita VARCHAR(50) NOT NULL      
        ); """
 
    cursor.execute(table)
    cursor.close()
    connection.close()

 
def list_rows():
    print("list rows..")
    #crea connessione al database
    connection = sqlite3.connect('lopro.db')

    sql = """ SELECT * FROM tbl_log;"""

    cursor = connection.cursor()
    cursor.execute(sql)
    rows = cursor.fetchall()

    for row in rows:
        print(row)

    # Close the connection
    connection.close()

if __name__=="__main__":
    #Rimuovere il commento per creare la tabella
    #crea_tabella()
    #list_rows()
    #Avvio un thred
    print("Start program")
    t1 = threading.Thread(target=client_Receive_Data)
    t1.start()

Questo è invece il codice che gira sulla Arduino MKR Zero; ho inserito diversi commenti che spiegano le varie istruzioni contenute nel programma:

#include <SPI.h>
#include <Ethernet.h>
#include <EthernetUdp.h>
#include <DHT.h>

#define DHTPIN 6
#define DHTTYPE DHT22

// creo un MAC address e un IP address per la scheda Arduino
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
IPAddress ip(192, 168, 178, 50);

//creo un ip address per il raspberry
IPAddress ip_remote(192, 168, 178, 30);
//creo una porta per la scheda Arduino
unsigned int localPort = 20002; 

//creo degli array di char per la ricezione e l'invio dei
//dati via udp
char packetBuffer[UDP_TX_PACKET_MAX_SIZE];
char chrBuffer[11];

//altre variabili 
String strTempUmid = "";
byte ciclo = 0;

// Creo degli oggetti per l'utilizzo di udp e del 
//sensore dht
EthernetUDP Udp;
DHT dht(DHTPIN, DHTTYPE);

void setup() {
  //inizializzo lo shield mkr eth
  Ethernet.init(5);

  //inizializzo la scheda di rete
  Ethernet.begin(mac, ip);

  //inizializzo la seriale
  Serial.begin(9600);
  
  // verifico la ethernet shield
  if (Ethernet.hardwareStatus() == EthernetNoHardware) {
    Serial.println("MKR ETH non presente o configurata in modo errato!");
    while (true) {
      delay(1);
    }
  }

  //inizializzo l'oggetto udp
  Udp.begin(localPort);
  //inizializzo l'oggetto dht
  dht.begin();
}

void loop() {

  //verifico presenza pacchetti udp in arrivo
  int packetSize = Udp.parsePacket();
  
  //se coi sono pacchetti
  if (packetSize) {
    //Serial.println(packetSize);
    //leggo i pacchetti e gli inserisco nell'array di char
    Udp.read(packetBuffer, UDP_TX_PACKET_MAX_SIZE);
    //printo i dati ricevuti
    Serial.println(packetBuffer);
  }

  //leggo umidità e temperatura dal sensore dht
  float h = dht.readHumidity();
  float t = dht.readTemperature();

  //creo una stringa del tipo temp:umid
  strTempUmid = "";
  strTempUmid.concat(t);
  strTempUmid.concat(":");
  strTempUmid.concat(h);
  //printo la stringa sul ser mon
  Serial.println(strTempUmid);
  //converto la stringa in un array di char
  strTempUmid.toCharArray(chrBuffer, strTempUmid.length());

  //inizializzo la connessione con ip e porta del Raspberry
  Udp.beginPacket(ip_remote, 20001);
  //Scrivo i dati nel buffer
  Udp.write(chrBuffer);
  //invio i dati
  Udp.endPacket();

  //attendo un minuto prima del prossimo invio
  for (ciclo = 0; ciclo < 60; ciclo++)
    delay(1000);

}

Ogni minuto viene inviata una unica stringa contenente i dati di temperatura e umidita che il codice python provvederà a separate in due dati distinti per essere caricati sul database.

Memorizzare solo le variazioni significative su Raspberry SQLite

Possiamo ottimizzare lo spazio sulla tabella (e di conseguenza sul filesystem del Raspberry) memorizzando solo i dati che hanno una variazione significativa. In questo modo il monitoraggio rimane costante perché comunque l’Arduino legge e invia i dati ogni minuto ma posso risparmiare spazio sul database salvando solo le variazioni significative. Sulla tabella memorizzo anche il timestamp e quindi posso ricostruire l’andamento di temperatura e umidità interpolando i dati.

Il codice seguente mostra la modifica alla funzione client_Receive_Data() in modo tale da memorizzare solo i dati che hanno una variazione di 0.5 rispetto ai dati della lettura precedente rilevata dalla scheda Arduino:

def client_Receive_Data():
    print("Avvio THREAD Receive Data...")
    serversocket1 = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    serversocket1.bind(("192.168.178.30", 20001))
        
    # crea connessione al database
    connection = sqlite3.connect('lopro.db')
    cursor = connection.cursor()
    #creo due variabili per memorizzare i dati delle 
    #letture di temp e umid
    temp_prec = 0
    umid_prec = 0
    
    try:
        while True:
            data, address = serversocket1.recvfrom(1024)
            strData = bytes.decode(data).split(":")

            #verifico se i dati appena letti differiscono di 0.5 dai valori della lettuare precedente
            if (abs(temp_prec - float(strData[0])) > 0.5) or (abs(umid_prec - float(strData[1])) > 0.5) :
                print("Variazione di Temp e Hum")  
                sql = """ INSERT INTO tbl_log(Temperatura, Umidita) VALUES ('{}', '{}');""".format(strData[0], strData[1])

                #memorizzo i dati per poterli confrontare con quelli
                #che arrivano dalla scheda arduino
                temp_prec = float(strData[0])
                umid_prec = float(strData[1])
                #visualizzo la stringa sql
                print(sql)
                #eseguo la stringa sql insert avviando una transazione
                cursor.execute(sql)
                #confermo la transazione
                connection.commit()
                
                # invia al device una risposta
                msgToSend = str.encode("DB_OK")
                serversocket1.sendto(msgToSend, ip_port_Data)
            else:
                print("Nessuna variazione di Temp e Hum")  
                # invia al device una risposta
                msgToSend = str.encode("DB_NOK")
                serversocket1.sendto(msgToSend, ip_port_Data)
            
            time.sleep(1)
    except:
        print("errore")
        msgToSend = str.encode("ERRORE")
        serversocket1.sendto(msgToSend, ip_port_Data)
        connection.close()

L’utilizzo congiunto di Raspberry e Arduino ci permette di realizzare progetti che superano i limiti dati dalle singole schede.

The post Datalogger con Raspberry SQLite e Arduino appeared first on Esperimenti con logiche programmabili.

L’integrato PCF8591 prodotto da NXP dispone di 4 ingressi analogici con risoluzione di 8 bit e di una uscita analogica sempre ad 8 bit. La sua gestione avviene tramite bus I2C, permettendo così il collegamento nel bus di diversi integrati (per un massimo di 127 unità). Avendo una gestione software semplice ed un costo intorno ai 3€ viene impiegato in diversi shield Arduino per aumentare il numero di porte ADC, inoltre la presenza di una uscita analogica programmabile (DAC) permette di generare segnali utili in diversi progetti e applicazioni.

Nella figura seguente viene mostrato lo schema a blocchi del PCF8591:

Per specificare l’indirizzo del dispositivo all’interno del bus I2C vengono impiegati i pin A0, A1 e A2. La scelta del canale ADC che vogliamo impiegare avviene tramite il registro control byte, configurabile via software come anche la gestione dell’uscita analogica, che in questo tutorial non verrà trattata.

Il circuito di esempio che  utilizza un integrato PCF8591P ed un Arduino UNO, di seguito lo schema:

I pin A0, A1,e A2 sono collegati a massa, quindi il loro valore logico è pari a zero. Sul datasheet del componente possiamo dedurre quale sarà l’indirizzo sul bus I2C seguendo questa tabella:

i quattro bit piu significativi sono fissi e non possono essere cambiati, mentre i tre bit meno significativi sono appunto collegati ai pin A0 A1 e A2. Nello schema essendo collegati a massa, otterremo l’indirizzo del dispositivo che  corrisponderà, al valore binario seguente:

0b1001000

che convertito in esadecimale diventa:

0x48

Una volta stabilito l’indirizzo, è necessario configurare il dispositivo tramite il registro ‘control byte’. Questo registro permette di scegliere il canale analogico da rendere attivo per l’acquisizione (bit 0 e bit 1 A/D Channell Number) e la configurazione degli ingressi analogici (bit4 e bit5 Analog Input Programming).
Le informazioni di questo registro sono riassunte in questo schema, presente nel datasheet:

Tralasciamo il bit per l’uscita analogica (bit6) e il bit  auto increment (bit2), assegnandoli il valore logico zero.
I valori da assegnare al control byte per selezionare i diversi ingressi analogici in configurazione four single-ended inputs (bit4 e bit5 a zero) dovranno essere:

0b00000000 -> 0x00 -> attiva l’ingrasso analogico AIN0
0b00000001 -> 0x01 -> attiva l’ingrasso analogico AIN1
0b00000010 -> 0x02 -> attiva l’ingrasso analogico AIN2
0b00000011 -> 0x03 -> attiva l’ingrasso analogico AIN3

La sequenza di byte da inviare è la seguente:

quindi tramite le dovute istruzioni, invieremo sul bus I2C un primo byte contenente l’indirizzo del dispositivo e un secondo byte riguardante la configurazione interna del dispositivo.
L’integrato PCF8591 è così pronto ad acquisire ed inviare il dato sul canale I2C.
Il codice seguente permette di acquisire un dato analogico sul pin AIN0 e sul pin AIN1 del dispositivo e di inviarlo al serial monitor dell’ IDE Arduino:

//libreria I2C
#include <Wire.h>

void setup()
{
 //inizializzo la libreria Wire
 Wire.begin();
 //init seiale
 Serial.begin(9600);
 //avviso che il programma è avviato
 Serial.println("START");
}

void loop()
{
 //avvio una richiesta di scrittura al
 //dispositivo con indirizzo 0x48
 Wire.beginTransmission(0x48);
 //invio il byte di configurazione
 //in questo caso abilito il canale analogico AIN0
 Wire.write(byte(0x00));
 //fine trasmissione
 Wire.endTransmission();
 //richiedo un byte allo slave che ha indirizzo 0x48
 Wire.requestFrom(0x48, 1);
 //attendo la disponibilità di dati sul bus i2c
 while(Wire.available())
 {
  //leggo il byte che mi invia il PCD8591
  byte c = Wire.read();
  //invio il dato al serial monitor
  Serial.println(c);
 }
 //pausa 10 millis
 delay(10);
 //avvio una richiesta di scrittura al
 //dispositivo con indirizzo 0x48
 Wire.beginTransmission(0x48);
 //invio il byte di configurazione
 //in questo caso abilito il canale analogico AIN01
 Wire.write(byte(0x01));
 //fine trasmissione
 Wire.endTransmission();
 //richiedo un byte allo slave che ha indirizzo 0x04
 Wire.requestFrom(0x48, 1);
 //attendo la disponibilità di dati sul bus i2c
 while(Wire.available())
 {
  //leggo dal bus il dato relativo alla
  //conversione a/d sul pin AIN01
  byte c = Wire.read();
  //invio il dato al pc
  Serial.println(c);
 }
 //esegui il codice ogni secondo
 delay(1000);
}

Sinteticamente viene prima configurato, tramite il ‘control byte’, il dispositivo PCF8591 e successivamente viene avviata una richiesta di lettura dal dispositivo. Per eseguire la lettura dei quattro, è necessario eseguire quattro configurazioni e quattro letture.

The post Come usare l’integrato PCF8591 appeared first on Esperimenti con logiche programmabili.

Il datalogger è uno di circuiti che fanno parte del bagaglio tecnico di chi come noi smanetta con l’elettronica e l’informatica. Il suo funzionamento è in effetti semplice ma allo stesso tempo utile per realizzare tutte quelle applicazioni in cui è necessario acquisire e registrare dati (digitali o analogici), pensiamo a tutti i sistemi di monitoring (energia, gas, acqua …) alle stazioni meteo o a sistemi di controllo. Esistono circuiti dedicati che eseguono funzioni di datalogging locale e remote, persino cloud, dai costi variabili da poche decine di euro a centinaia di euro a seconda della robustezza e della precisione dei circuiti.
Per impadronirci anche di questo aspetto possiamo realizzare il nostro datalogger usando il nostro caro Arduino. Il logging può avvenire sia sui pin analogici che su quelli digitali a seconda dei segnali e dei sensori collegati alla scheda.

In questo tutorial utilizzerò i sei pin analogici della scheda per acquisire dei segnali analogici ed inviarli al pc, tramite la porta seriale, dove avverrà la memorizzazione dei dati. Ho deciso di non memorizzare i dati sulla scheda per far capire come inviare i dati e come sincronizzazione la comunicazione tra i due dispositivi.Come scheda ho impiegato la Arduino Ethernet e lato pc ho utilizzato Microsoft Visual C# 2012 (su Windows 8) per scrivere il programma di logging.

Per mancanza di tempo non ho collegato alla scheda dei sensori o delle fonti analogiche ma ho lasciato i pin analogici ‘appesi’, questo perchè i dispositivi da collegare sono infiniti e quindi lascio a voi il compito di collegarne a piacimento.

Passiamo quindi direttamente al codice caricato sulla Arduino Ethernet:

[c]
//questo arrai contiene i valori provenienti
//dall’acquisizione analogica
byte ana[12];
//avalore intero per memorizzare il dato analogico
int valAn = 0;
//variabile per selezionare il canale analogico
byte in_ana = 0;

void setup()
{
//init seriale
Serial.begin(9600);
}

void loop()
{
//verifico la presenza di un dato sulla
//porta seriale
if(Serial.available() > 0)
{
//se arriva un byte dal pc leggilo
byte data = Serial.read();
//controllo se il dato in arrivo dal pc corrisponde
//al carattere di avvio acquisizione
if(data == ‘#’)
{
//inizializzo la variabile per la selezione del
//primo canale analogico
in_ana = 0;
//eseguo un ciclo for per acquisire ciclicamente tutti i
//canali analogici da A0 a A5
for(int Ciclo = 0; Ciclo <12; Ciclo += 2)
{
//leggo il canale analogico
valAn = analogRead(in_ana);
//il valore intero viene diviso in due byte e caricato
//nell’array dichiarato precedentemente
ana[Ciclo] = highByte(valAn);
ana[Ciclo + 1] = lowByte(valAn);
//piccolo delay tra una acquisizione e l’altra
delay(1);
//incremento il canale di acquisizione
in_ana++;
}
//dopo 6 cicli spedisco tutti e 12 i byte al pc
Serial.write(ana,12);
}
}
}
[/c]

Le parti più importanti di questo codice sono il secondo blocco if che ha il compito di verificare quando il byte ricevuto è uguale al carattere #, in questo modo l’invio dei dati è subordinato alle richieste del pc. Questo permette di avere una trasmissione concordata che evita l’utilizzo di sincronismi per poter leggere coerentemente i dati acquisiti.
L’altro blocco è quello for, che ha il compito di acquisire il dato analogico e di caricarlo sull’array che verrà inviato al pc. Per farlo vengono utilizzate le istruzioni highByte() e lowByte() che hanno il compito di suddividere la variabile int valAn(composta da due byte) in due byte contenenti gli 8 bit più significativi e gli 8 bit meno significativi, questo infatti giustifica l’array da 12 byte.

La figura seguente mostra quanto detto:

volendo si potrebbe spedire direttamente il valore intero ma credo che questo approccio semplifica meglio la stesura e la comprensione dei programmi lato Arduino e lato pc.

Il datalogger sul pc

La finestra del programma che acquisisce e registra i dati è mostrata di seguito:

La parte principale del software di acquisizione dei dati da Arduino è la seguente:

[csharp]

//avvia l’acquisizione dei dati
//inviando ad arduino il carattere #
rs232.Write("#");

//entro nel ciclo
while (Continua)
{
//attendo che arduino invii i 12 byte
//contenenti i dati dalla conversione
//analogico digitale
if (rs232.BytesToRead == 12)
{
//leggo tutti i 12 byte e le assegno
//ad un array di byte
rs232.Read(dataRX, 0, 12);

//prendo il primo ed il secondo byte e li unico per
//formare yn valore intero a 16 bit
myShort = (short)(dataRX[0] << 8 | dataRX[1]);
txtValAn01.Text = myShort.ToString();

myShort = (short)(dataRX[2] << 8 | dataRX[3]);
txtValAn02.Text = myShort.ToString();

myShort = (short)(dataRX[4] << 8 | dataRX[5]);
txtValAn03.Text = myShort.ToString();

myShort = (short)(dataRX[6] << 8 | dataRX[7]);
txtValAn04.Text = myShort.ToString();

myShort = (short)(dataRX[8] << 8 | dataRX[9]);
txtValAn05.Text = myShort.ToString();

myShort = (short)(dataRX[10] << 8 | dataRX[11]);
txtValAn06.Text = myShort.ToString();

//dopo aver acquisito i dati esco dal ciclo
break;
}
}
[/csharp]

Il programma acquisisce i dati provenienti dalla scheda e li visualizza nelle apposite caselle di testo, in contemporanea viene creato un file di testo, nella stessa cartella dove viene posto il fil eseguibile, dove verranno memorizzati i dati.

Per eseguire l’applicazione è necessario installare nel proprio pc il Microsoft .Net Framework 4.5

In allegato trovate sia il file eseguibile sia il codice dell’applicazione.

Download File eseguibile: ArduinoDataLogger (~7KB)

Download File sorgente: ArduinoDataLogger_Source (~82KB)

The post Arduino datalogger con pc 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.