Nello scorso articolo abbiamo visto come configurare la Raspberry Pi Pico per poter essere programmata utilizzando il linguaggio MicroPython. In particolare abbiamo installato e configurato Thonny e caricato l’interprete MicroPython sulla scheda Pico.

In questo articolo vediamo come scrivere il nostro primo programma MicroPython e come caricarlo sulla Pico.

Colleghiamo la Pi Pico alla porta usb del computer e lanciamo l’ide Thonny. Dopo qualche istante sulla finestra shell dovremmo vedere la finestra interattiva di Python (REPL):

Utilizzando la finestra Shell è possibile eseguire direttamente dei semplici comandi. In questo modo è possibile testare delle funzioni o piccole parti di codice in modo molto veloce.

Ad esempio digitiamo sulla Shell il seguente codice e premiamo invio

print("Ciao Mondo!! Questa è la mia prima istruzione in MicroPython")

otterremo la risposta della Pico:

niente di entusiasmante! Ma comunque un semplice test per verificare che la scheda stia eseguendo il codice Python.

Scrivere un semplice programma

Nell’editor dei Thonny andiamo a scrivere delle istruzioni un po più utili. Sappiamo che il chip RP2040 è dotato di un sensore di temperature collegato all’ingresso analogico ADC4, quindi con il codice seguente andiamo a prelevare la tensione sulla linea ADC4 per poi convertirla in un valore espresso in gradi centigradi:

import machine
import utime

sensor_temp = machine.ADC(4)
conversion_factor = 3.3 / (65535)

while True:
    reading = sensor_temp.read_u16() * conversion_factor
    temperature = 27 - (reading - 0.706)/0.001721
        
    print(temperature)
    
    utime.sleep(2)

Il codice è stato copiato dal libro Get started with MicroPython.

Premiamo il pulsante Esegui lo script corrente (F5) per eseguire il programma. Thonny ci chiede dove vogliamo salvare il programma, salviamo sulla Raspberry Pi Pico:

Diamo un nome al nostro programma e premiamo sul pulsante OK:

Non appena premiamo il pulsante OK la Raspberry Pi Pico inizierà ad eseguire il programma. Sulla finestra Shell potremmo osservare il valore della temperatura rilevata dal microprocessore.

The post Caricare un programma MicroPython sulla Pi Pico appeared first on Esperimenti con logiche programmabili.

Il sensore di temperatura e umidità DHT11 è uno tra i più popolari nei progetti Arduino quando è necessario acquisire un valore di temperatura e di umidità. Solitamente per leggere i dati da questo sensore viene utilizzata una libreria che permette con poche linee di codice di ottenere il dato di temperatura e dell’umidità.

Esistono numerosi tutorial che mostrano come impiegare queste librerie, in questo articolo cercheremo di capire invece, come leggere i dati del sensore DHT11 utilizzando direttamente le funzioni di Arduino UNO.

Nello schema seguente potete osservare i collegamenti che ho effettuato tra la UNO e il sensore DHT11

Come si può notare i dati vengono ricevuti e trasmessi impiegando un solo filo.

Per prima cosa controlliamo nel datasheet del DHT11 come avviene lo scambio dei dati tra il microcontrollore e il sensore.

Sapendo che i dati transitano su un singolo filo dobbiamo utilizzare una porta digitale della UNO impostandola primariamente come uscita, per inviare la richiesta di acquisizione dati al sensore, secondariamente come ingresso, per ricevere i dati provenienti dal sensore.

Leggendo il datasheet notiamo che per ricevere dati dal sensore DHT11 è necessario inviargli un segnale digitale rispettando determinati tempi tra un livello logico basso ed uno alto; analizziamo nel dettaglio come sono composti questi segnali.

Una volta alimentato il sensore DHT11, questo si pone, dopo circa 1 secondo, in attesa di ricevere un comando. Avendo inserito una resistenza di pull-up, sulla linea dati sarà presente un segnale logico alto.

Per avviare la trasmissione dei dati dobbiamo mettere (tramite la porta della scheda UNO) la linea dati al livello logico basso per almeno 18 ms, e successivamente metterla nuovamente a livello logico alto, come visibile nel diagramma seguente:

In questa fase dobbiamo configurare la porta digitale come un ingresso. Infatti il sensore risponderà mettendo la linea dati a livello logico basso per 80 microsecondi per poi tenerla a livello alto per altri 80 microsecondi:

ora il sensore invierà al microcontrollore 40 bit di dati composti in questo modo, il bit a livello basso sarà composto da un livello logico basso di 50 us seguito da un livello logico alto di circa 27 us, mentre un bit a livello alto sarà composto da un segnale di livello basso per 50 us seguito da un livello logico alto per 70 us.

Quindi riepilogando avremmo una sequenza di trasmissione di questo tipo:

I 40 bit trasmessi sono suddivisi in questo modo:

I primi 8 bit contengono il valore intero del dato di umidità, i seguenti 8 bit contengono il valore decimale del dato di umidità, i successivi 8 bit contengono il valore intero del dato di temperatura, i seguenti 8 bit contengono il valore decimale del dato di temperatura. Gli ultimi 8 bit contengono il valore di CRC.

Il codice seguente permette di acquisire il dato di umidità e di temperatura. I commenti nel codice spiegano in dettaglio le istruzioni utilizzate:

int pin = 2;

unsigned long duration;
unsigned long tmr = 0;
unsigned long tmr_prec = 0;
byte impulsi;
int message[42];
byte Htemperatura;
byte Ltemperatura;
byte Humidita;
byte Lumidita;
byte checksum;

void setup()

{
  //init seriale
  Serial.begin(115200);
  //definisco la porta 2 come uscita
  //in questa porta è collegato il sensore dht11
  pinMode(pin, OUTPUT);
}

void loop()
{
  delay(1000);

  //definisco la porta 2 come uscita
  //in questa porta è collegato il sensore dht11
  pinMode(pin, OUTPUT);
  //sappiamo che sul pin c'è un livello logico alto
  //avvendo inserito la resistenza di pullup
  //metto la linea alivello basso per 20 millisecondi (>18ms)
  digitalWrite(pin, LOW);
  delay(20);
  
  //metto nuovamente la linea a livello logico alto
  digitalWrite(pin, HIGH);

  //imposto la lestta porta come ingresso
  //in modo da ricevere i dati dal sensore dht11
  pinMode(pin, INPUT);
  delayMicroseconds(10);
  
  //inizializzo la variabile a 0, questa variabile consente di tenere
  //traccia del numero di bit ricevuti
  impulsi = 0;
  
  //eseguo un ciclo continuo
  while (true)
  {

    //controllo solo quando è presente un livello alto
    if (digitalRead(2) == HIGH)
    {
      //memorizzo il tempo in microsecondi
      tmr_prec = micros();

      //eseguo un ciclo fintanto che il livello è alto
      while (digitalRead(2) == HIGH)
      {
        ;
      }

      //quando il livello logico diventa basso
      //misuro quanto tempo è durato il livello logico alto
      duration = micros() - tmr_prec;
 
      //memorizzo questo tempo nell'array
      message[impulsi] = duration;
      
      //incremento la variabile per tenere traccia dei bit inviati
      //dal sensore dht11
      impulsi++;
    }

    //quando ho raggiunto 41 bit interrompo il ciclo while
    //i bit sono 41, invece che 40, perchè questo codice
    //misura anche il primo livello alto di 80us che indica l'inizio
    //della trasmissione deii 40 bit di dati 
    if (impulsi == 41)
      break;
  }

  //ora che ho un array contenente i microsecondi di tutti i livelli alti che sono stati inviati
  //dal sensore dht11 devo convertirli in bit digitali
  //trasformo i millisecondi in bit

  //verifico che il primo dato sia di circa 80 us
  if ( message[0] > 75 && message[0] < 95)
  {
    //bit di start ok    
    //elaboro i primo 8 bit e converto, in funzione della larghezza del
    //livello alto, se è un bit di valore 1 o di valore 0
    
    for (byte ciclo = 0; ciclo < 8; ciclo++)
    {
      if (message[ciclo + 1] > 15 && message[ciclo + 1] < 35)
        bitClear(Humidita, 7 - ciclo);

      if (message[ciclo + 1] > 65 && message[ciclo + 1] < 80)
        bitSet(Humidita, 7 - ciclo);
    }

    //continua coni successivi 8 bit
    for (byte ciclo = 0; ciclo < 8; ciclo++)
    {
      if (message[ciclo + 9] > 15 && message[ciclo + 9] < 35)
        bitClear(Lumidita, 7 - ciclo);

      if (message[ciclo + 9] > 65 && message[ciclo + 9] < 80)
        bitSet(Lumidita, 7 - ciclo);
    }

    //continua coni successivi 8 bit
    for (byte ciclo = 0; ciclo < 8; ciclo++)
    {
      if (message[ciclo + 17] > 15 && message[ciclo + 17] < 30)
        bitClear(Htemperatura, 7 - ciclo);

      if (message[ciclo + 17] > 65 && message[ciclo + 17] < 80)
        bitSet(Htemperatura, 7 - ciclo);
    }
    //continua coni successivi 8 bit
    for (byte ciclo = 0; ciclo < 8; ciclo++)
    {
      if (message[ciclo + 25] > 15 && message[ciclo + 25] < 30)
        bitClear(Ltemperatura, 7 - ciclo);

      if (message[ciclo + 25] > 65 && message[ciclo + 25] < 80)
        bitSet(Ltemperatura, 7 - ciclo);
    }
    //continua coni successivi 8 bit
    for (byte ciclo = 0; ciclo < 8; ciclo++)
    {
      if (message[ciclo + 33] > 15 && message[ciclo + 33] < 30)
        bitClear(checksum, 7 - ciclo);

      if (message[ciclo + 33] > 65 && message[ciclo + 33] < 80)
        bitSet(checksum, 7 - ciclo);
    }
  }


  //visualizzo i dati grezzi
  for (byte ciclo = 0; ciclo < 41; ciclo++)
  {
    Serial.print(message[ciclo]);
    Serial.print(" ");
  }

  //visualizzo i dati elaborati
  Serial.println("");
  Serial.print("Umidita ");
  Serial.print(Humidita);
  Serial.print(".");
  Serial.print(Lumidita);
  Serial.print(" temperatura ");
  Serial.print(Htemperatura);
  Serial.print(".");
  Serial.print(Ltemperatura);
  Serial.print(" CheckSUM");
  Serial.println(checksum);

}

Questo semplice codice ha permesso di capire come acquisiere ed elaborare i dati inviati dal sensore dht11.

The post Arduino dht11 lettura grezza dei dati appeared first on Esperimenti con logiche programmabili.

La conversione di grandezze fisiche in elettriche è un aspetto che prima o poi viene affrontato quando iniziamo a realizzare piccoli esperimenti con Arduino. Oggi la sensoristica è ricca di dispositivi capaci di svolgere questa conversione (come il sensore di temperatura TMP36).

Nello specifico, per quanto riguarda la misura della temperatura abbiamo in commercio dispositivi di ogni sorta, da quelli ultrasensibili a quelli con precisioni dell’ordine del centesimo di grado, dai costi contenuti ai costi esorbitanti. A tal proposito ho in precedenza utilizzato sia il sensore di temperatura analogico MCP9700 sia il sensore digitale MCP9803.

Il segnale di conversione di questi sensori può essere sia analogico (variazione di tensione in funzione della variazione della temperatura) sia digitale (con convertitore analogico digitale ed invio dei dati su linea I2C, SPI o 1Wire).

Per i nostri esperimenti ci accontenteremmo di un sensore molto diffuso, dal costo contenuto e dal semplice utilizzo, il sensore TMP36 prodotto da Analog Device.

Il TMP36 permette di acquisire temperature comprese nell’intervallo tra -40°C e +125°C restituendo in uscita valori di tensione lineari tra circa 0.1Vdc e 1.7Vdc. Una variazione di grado produce una variazione della tensione di uscita pari a 10mV; alla temperatura di 0°C il sensore eroga una tensione di 500mV.

Il circuito che ho realizzato è molto banale, si limita a collegare il sensore direttamente ad Arduino UNO tramite la porta analogica A0:

guardando frontalmente il TMP36 troviamo sul lato sinistro il pin di alimentazione, sul pin centrale il segnale in uscita e sul pin destro il collegamento a massa.

Il primo sketch di esempio legge dalla porta analogica A0 il valore di tensione che eroga il TMP36:

void setup()
{
  //Init Seriale
  Serial.begin(9600);
}

void loop()
{
  delay(500);
  int val_ADC = analogRead(0);
  //invio il dato acquisito al pc
  Serial.println(val_ADC);
}

Il codice precedente non fa altro che convertire in forma digitale la tensione presente sul piedino A0, generata dal TMP36. Questo valore deve essere ora interpretato in modo da ottenere direttamente il valore in °C. Per far ciò abbiamo bisogno del datasheet del componente, e precisamente il grafico di conversione °C/Vdc, rappresentato anche nella figura seguente:

come possiamo osservare dal grafico (per il TMP36 la linea b evidenziata in rosso) per una tensione di uscita di 0.5Vdc il sensore rileva la temperatura di 0°C. Questo dato ci permette subito di intuire che tensioni inferiori a 0.5Vdc indicano una temperatura sotto lo zero. Inoltre sapiamo che una variazione di grado si ripercuote con una variazione di tensione di 10mV. Quindi, passando agli esempi, se sul pin A0 sono presenti 510mV significa che il sensore sta rilevando una temperatura di 1°C (510mV – 500mV = 10 mV variazione di 1°C).

Non ci resta che interpretare i dati a nostra disposizione e scrivere uno sketch che restituisca il valore in °C:

//variabili globali
int val_Adc = 0;
float temp = 0;

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

void loop()
{
  //leggo dalla porta A0
  val_Adc = analogRead(0);
  //converto il segnale acquisito in un valore
  //espresso in gradi centigradi
  temp = ((val_Adc * 0.00488) - 0.5) / 0.01;
  //invio il dato sulla seriale
  Serial.println(temp);
  //ritardo di mezzo secondo
  delay(500);
}

la formula che converte il valore acquisito in gradi centigradi è la seguente

°C = ((valoreADC * PrecisioneADC) – TensioneZeroGradi) / stepGradoTensione

dove

°C = valore della temperatura in gradi centigradi
valoreADC = valore della conversione analogico digitale restituito da analogRead
PrecisioneADC = questo valore è ottenuto dividendo la tensione di riferimento dell’ADC (default 5Vdc) e il numero massimo restituito dalla conversione (1024). (5Vdc /1024 = 0.00488)
TensioneZeroGradi = indica la tensione di uscita dal sensore quando rileva una temperatura di 0°C
stepGradoTensione = indica la variazione di tensione per ogni variazione di grado (0.01 = 10 mV)

Come aumentare la risoluzione nelle letture del TMP36

Eseguendo l’ultimo sketch ci accorgiamo che i valori di temperatura non sono proprio quelli che ci aspettiamo. Considerando la precisione del sensore TMP36 che si attesta a +/- 2°C per tutta la scala, otteniamo comunque dei valori che differiscono di circa 5-7°C dal valore reale. Questo ‘errore’ dipende da diversi fattori tra cui imprecisione dell’ADC, rumore del segnale e approssimazione dei valori nei calcoli.
Per limitare questi errori possiamo adottare due tecniche, la prima è quella di usare il pin AREF dell’Arduino UNO per dare al convertitore analogico digitale dell’ATmega328 un riferimento di tensione più basso (di default è 5Vdc), l’altra tecnica è quella di effettuare diverse letture ed eseguire una media dei valori letti.

Nello schema seguente viene indicato come collegare il pin AREF al pin power di 3.3Vdc:

Anche via software dobbiamo indicare al microcontrollore che intendiamo usare il pin AREF per le operazioni di conversione A-D. l’istruzione è la analogReference() e viene impiegata in questo modo:

//variabili globali
int val_Adc = 0;
float temp = 0;

void setup()
{
 //init seriale
 Serial.begin(9600);
 //utilizzando l'istruzione analogReference
 //indico al convertitore AD che deve impiegare
 //la tensione presente sul pin AREF come
 //valore di riferimento per la conversione
 analogReference(EXTERNAL);
}

Usando la tensione di 3.3Vdc come riferimento per la conversione analogico digitale otteniamo che il valore PrecisioneADC nella formula precedente cambia da 0.00488 a 0.0032 (3.3Vdc / 1024 = 0.0032), aumentando così la precisione della formula.
Impieghiamo anche la lettura multipla di valori per cercare di minimizzare le fluttuazioni, come descritto nel codice seguente:

int val_Adc = 0;
float temp = 0;

void setup()
{
 //init seriale
 Serial.begin(9600);
 //utilizzando l istruzione analogReference
 //indico al convertitore AD che deve impiegare
 //la tensione presente sul pin AREF come
 //valore di riferimento per la conversione
 analogReference(EXTERNAL);
}

void loop()
{
 //ritardo di mezzo secondo
 delay(500);
 //init variabile
 val_Adc = 0;
 //eseguo un ciclo
 for(byte Ciclo = 0; Ciclo < 100; Ciclo++)
 {
  //acquisisco il valore e lo sommo alla
  //variabile
  val_Adc += analogRead(0);
  //questo ritardo serve per dare il tempo
  //all ADC di eseguire correttamente
  //la prossima acquisizione
  delay(10);
 }

 //eseguo la media dei 100 valori letti
 val_Adc /= 100;
 //calcolo la temperatura in °C
 temp = ((val_Adc * 0.0032) - 0.5) / 0.01;
 //invio i dati al computer
 Serial.println(temp);
}

in questo modo otterremmo delle misure di temperatura che si avvicineranno molto al valore reale.

The post Arduino e sensore di temperatura TMP36 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.