Acquisizione temperatura e umidità con PIC12F1480 e DHT22

Il progetto si propone di acquisire temperatura e umidità dell'ambiente circostante e d' inviare i dati al
pc dove vengono visualizzati tramite un software realizzato in C#. Quest'ultimo permette la
visualizzazione dei dati in real-time ed il salvataggio per eventuali elaborazioni
iniziamo analizzando lo schema elettrico.

Dallo schema elettrico si nota che il tutto si riduce a pochissimi componenti. Per ridurre le
dimensioni della scheda e risparmiare componenti, si è deciso di non implementare il circuito ICSP.
Sul pin MCRL del microcontrollore si nota la solita configurazione per il reset. la resistenza da 10KΩ
garantisce i 5V durante il normale funzionamento, mentre la resistenza da 100Ω insieme al contatto
collegato a massa resetta il PIC.
Il condensatore da 100nF filtra i disturbi provenienti dall'alimentazione.
Il sensore DHT22 prevede il condensatore da 100nF per il filtraggio dell'alimentazione e la resistenza
di pull-up da 10KΩ sulla linea dati.

Per comunicare con il PC è stato creata l'interfaccia rs232 costituita dal chip MAX232 con i relativi
quattro condensatori da 10mF e la resistenza di pull-up da 1KΩ posta sulla linea TX del PIC.
Il circuito viene alimentato tramite la porta USB del PC.

La visualizzazione a video dei parametri è affidata al software T-RH appositamente creato per questo
hardware e scaricabile qui.
Per far funzionare il software è necessario che sul pc sia installato NET Framework.
Attenzione, se durante l'esecuzione il software visualizza valori senza la virgola, bisogna andare a
sostituire la virgola con il punto in pannello di controllo/ lingua/ cambia ora, data e formato dei numeri/.
Adesso qualche foto della realizzazione:

scheda madre lato componenti

scheda madre lato piste

scheda rs232 lato componenti

scheda rs232 lato piste

scheda madre con DHT22

scheda madre + rs232 + DHT22

Software T-RH

Esempio di curve

Di seguito il codice in mikroC:

/******************************************************************************

MCU                : PIC12F1840
osc                  : oscillatore interno impostato a 8 Mhz
realizzato da     : Ciro marinelli
data                 : 18/01/2017

NOTE:


******************************************************************************/

/*******variabili globali*****************************************************/


unsigned char  Check, T_byte1, T_byte2, RH_byte1, RH_byte2;
unsigned Temp, RH, Sum;
char *text_1 = " 00.0", *text_2 = " 00.0";

//*****configura connessioni sensore********************************************

sbit Data at RA5_bit;
sbit DataDir at TRISA5_bit;

//*****funzione inizio comunicazione col sensore********************************

void StartSignal()
{
 DataDir = 0;     // imposta RA5 come output
 Data    = 0;     // imposta RA5 a zero
 Delay_ms(20);    // attendi 20 millisecondi
 Data    = 1;     // imposta RA5 a uno
 Delay_us(30);    // attendi 30 microsecondi
 DataDir = 1;     // imposta RA5 come input
}

//*****funzione risposta sensore************************************************

void CheckResponse()
{
 Check = 0;
 delay_us(40);
 if (Data == 0)
  {
   delay_us(80);
   if (Data == 1)
    {
    Check = 1;
    delay_us(40);
    }
  }
}

//*****funzione leggi dati******************************************************

char ReadData()
{
 char i, j;
 for(j = 0; j < 8; j++)
   {
    while(!Data);                //Attendo che PORTA.F5 va alto
    delay_us(30);
    if(!Data)
     {
      i&= ~(1<<(7 - j));
     }
     else
        {
         i|= (1 << (7 - j));
         while(Data);            //Attendo che PORTA.F5 va basso
        }
   }
 return i;
}
//*****funzione DHT22***********************************************************

void DHT22(void)
{
      StartSignal();
      CheckResponse();
      if(Check == 1)
       {
        RH_byte1 = ReadData();
        RH_byte2 = ReadData();
        T_byte1 = ReadData();
        T_byte2 = ReadData();
        Sum = ReadData();
        if(Sum == ((RH_byte1+RH_byte2+T_byte1+T_byte2) & 0XFF))
         {
          Temp = T_byte1;
          Temp = (Temp << 8) | T_byte2;
          RH = RH_byte1;
          RH = (RH << 8) | RH_byte2;
          if (Temp > 0X8000)
           {
            Temp = Temp & 0X7FFF;
            text_1[0]="-";
           }
            else
               {
                text_1[0]="";
               }
              
            text_1[1] = (RH / 100) % 10 + 48;
            text_1[2] = (RH / 10) % 10 + 48;
            text_1[4] =  RH % 10 + 48;
            text_2[1] = (Temp / 100) % 10+48;
            text_2[2] = (Temp / 10) % 10+48;
            text_2[4] = Temp % 10 + 48;

            if (UART1_Tx_Idle() == 1)
             {
              UART1_Write_Text("H");
              UART1_Write(text_1[1]);
              UART1_Write(text_1[2]);
              UART1_Write(text_1[3]);
              UART1_Write(text_1[4]);
              UART1_Write_Text("T");
              UART1_Write(text_2[1]);
              UART1_Write(text_2[2]);
              UART1_Write(text_2[3]);
              UART1_Write(text_2[4]);
              UART1_Write_Text("_");
              }
          }
       }
          delay_ms(2000);
}

//*****funzione impostazione pic************************************************

void init_pic(void)
{
 osccon=0X70;                     // imposta l'oscillatore interno a 8MHz  "01110000"
 ansela=0x00;                     // disabilito gli ingressi analogici
 adcon0=0x00;                     // spengo il convertitore A/D
 trisa=0x00;                      // imposta porta come output
 porta=0x00;                      // azzera porta
 UART1_Init(9600);                // Initialize UART module at 9600 bps
}
//*****funzione principale******************************************************

void main()
{
 init_pic();
 while(1)
     {
      DHT22();
     }
}