• 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.

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.