API tools faq
paste
Electgpl

PIC - Estación Interna V1 - 1826

Electgpl
Sep 13th, 2017
60
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 13.33 KB | None | 0 0
raw download clone embed print report
  1. //*********************************************************************************************************
  2. // Programa para la estación meteorológica Interna inalámbrica
  3. // El programa recibe Temperatura, Humedad y Luminosidad por interrupción
  4. // El sistema mide Temperatura y Humedad interior
  5. // El enlace se realiza mediante una comunicación ASK OOK UHF sobre UART Invertido a 600bps
  6. // Se muestra de en un LCD de 2x16 medición interna y externa
  7. //*********************************************************************************************************
  8. #include <16F1826.h>                                           //Biblioteca del microcontrolador
  9. #fuses NOMCLR, NOWDT, INTRC_IO                                 //Configuración de fuses
  10. #use delay(int=4000000)                                        //Configuración del clock interno a 4MHz
  11. #use rs232(baud=600,parity=N,xmit=PIN_B5,rcv=PIN_B1,bits=8)    //Configuración de UART 600bps 8 N 1
  12. #define LCD_ENABLE_PIN  PIN_A7                                 //Redefine pin de LCD
  13. #define LCD_RS_PIN      PIN_A4                                 //Redefine pin de LCD
  14. #define LCD_RW_PIN      PIN_A6                                 //Redefine pin de LCD
  15. #define LCD_DATA4       PIN_B4                                 //Redefine pin de LCD
  16. #define LCD_DATA5       PIN_B5                                 //Redefine pin de LCD
  17. #define LCD_DATA6       PIN_B6                                 //Redefine pin de LCD
  18. #define LCD_DATA7       PIN_B7                                 //Redefine pin de LCD
  19. #include <LCD.c>                                               //bilioteca del LCD 2x16
  20. //*********************************************************************************************************
  21. // Variables
  22. //*********************************************************************************************************
  23. #define HEADER 200                                             //Definición de valor Header para el payload
  24. #define DATA PIN_A3                                            //Pin del bus de un hilo para el DHT11
  25. static int8 datoInt[2];                                        //Variable donde se alojan los datos internos
  26. static int8 payload[5];                                        //Variable donde se aloja el payload
  27. static int8 datoExt[3];                                        //Variable donde se alojan los datos externos
  28. //*********************************************************************************************************
  29. // Función Interrupción UART que realiza el parse de datos, validación de Header y Checksum
  30. // Si validación y Checksum son validos, carga el vector DATO para ser utilizado
  31. //*********************************************************************************************************
  32. int8 i=0;                                                      //Variable para el contador de bytes de entrada
  33. #int_RDA                                                       //Interrupción por dato en UART
  34. void intser(){                                                 //Función de servicio de interrupción
  35.    payload[i++]=getc();                                        //Guarda byte de entrada en payload. incrementa indice
  36.    if(i>5){                                                    //Si el indice es mayor que 5 se asume que se completa el payload
  37.       if(payload[0]==HEADER){                                  //Validación que el Header sea 200 (seteado en el transmisor)
  38.          if(payload[1]+payload[2]+payload[3]-payload[4]==0){   //Validación de checksum, si datos leídos son igual a checksum
  39.             datoExt[0]=payload[1];                             //Cargamos los datos en el vector
  40.             datoExt[1]=payload[2];                             //Cargamos los datos en el vector
  41.             datoExt[2]=payload[3];                             //Cargamos los datos en el vector
  42.          }
  43.       }
  44.       i=0;                                                     //Una vez que se completan los 5 bytes, se reinicia el contador
  45.    }
  46. }
  47. //*********************************************************************************************************
  48. // Trama DHT11 - Segun Datasheet
  49. // ____             ____      ____                                       ___
  50. //     |___________|    |____|    |.....................................|
  51. //     |   18ms    |    |80us|80us|               5x8 bit               |
  52. //     |    PIC    |    |                  DHT11 respuesta              | Fin de
  53. //     |  request  |    |  2x80us, intRH, decRH, intT, decT, checksum   | Trama
  54. // ____          ________
  55. //     |________|        |...                        0 bit
  56. //      <-50us-> <-27us->
  57. // ____          _________________________
  58. //     |________|                         |...       1 bit
  59. //      <-50us-> <---------70us---------->
  60. //*********************************************************************************************************
  61. unsigned int trama[5];                                         //Vector donde se alojan los datos
  62. //*********************************************************************************************************
  63. // Funcion de recepcio de Byte
  64. // Lee el valor leído en la trama y lo separa realizando shift
  65. // Retorna el valor en forma de byte, es utilizado en la función recibeDato()
  66. //*********************************************************************************************************
  67. unsigned int recibeByte(){                                     //Función que recibe un Byte
  68.    unsigned int8 valorLeido = 0;                               //Valor de retorno de la función
  69.    int8 i=0;                                                   //Inicialización del indice
  70.    for(i=0; i<8; i++){                                         //Iteración para recepción de bits
  71.       valorLeido <<= 1;                                        //Registro de desplazamiento de bits
  72.       while(!input(DATA));                                     //Espera a DATA = 0
  73.       delay_us(30);                                            //Demora de 30us (Del Datasheet)
  74.       if(input(DATA)){                                         //Pregunta si DATA = 1
  75.           valorLeido |= 1;                                     //Realiza toggle del valor leido
  76.       }
  77.       while(input(DATA));                                      //Espera a DATA = 1
  78.    }
  79.    return valorLeido;                                          //Retorna el valor leido
  80. }
  81. //*********************************************************************************************************
  82. // Función de recepción de dato para el DHT11
  83. // Recibe los valores de temperatura y humedad (parte entera y decimales por separado)
  84. // Recibe el checksum enviado por el DHT11 y lo compara con el leído en el programa
  85. //*********************************************************************************************************
  86. unsigned int recibeDato(){                                     //Función que recibe el Dato
  87.    int validacion = 0;                                         //Variable de Validación
  88.    int checksum = 0;                                           //Variable de deteccion de cambios de secuencia
  89.    int8 j=0;                                                   //Variable para el lazo for
  90.    output_high(DATA);                                          //Set DATA = 1  
  91.    output_low(DATA);                                           //Set DATA = 0
  92.    delay_ms(18);                                               //Demora de 18ms (Del Datasheet)
  93.    output_high(DATA);                                          //Set DATA = 1
  94.    delay_us(25);                                               //Demora de 25ms (Del Datasheet)
  95.    validacion = input(DATA);                                   //Mueve valor de DATA a Validacion
  96.    delay_us(80);                                               //Espera 80us (Del Datasheet)
  97.    validacion = input(DATA);                                   //Mueve valor de DATA a Validacion
  98.    if(!validacion){                                            //Si Validación = 0, Error de secuencia
  99.       printf( "Error en Checksum \r");                         //Muestra leyenda de error
  100.    }
  101.    delay_us(80);                                               //Espera 80us (Del Datasheet)
  102.    for(j=0; j<5; j++){                                         //Lazo de carga de bytes de datos
  103.        trama[j] = recibeByte();                                //Carga del vector de datos
  104.    }
  105.    output_high(DATA);                                          //Set DATA = 1
  106.    for(j=0; j<4; j++){                                         //Lazo de carga de bytes de verificacion
  107.        checksum += trama[j];                                   //Carga de bytes de verificación
  108.    }
  109.    if(checksum == trama[4]){                                   //Si la secuencia de verificación es correcta
  110.       return 0;                                                //Se retorna 0 y se realiza la lectura
  111.    }
  112. }
  113. //*********************************************************************************************************
  114. // Lee DHT11
  115. //*********************************************************************************************************
  116. void leeDHT11(void){                                           //Función que lee el DHT11
  117.    if(recibeDato()==0){                                        //Consulta si hay dato en la entrada del DHT11
  118.       datoInt[0]=trama[2];                                     //Carga el valor de temperatura DHT en byte 1 del payload
  119.       datoInt[1]=trama[0];                                     //Carga el valor de humedad DHT en byte 2 del payload
  120.    }
  121. }
  122. //*********************************************************************************************************
  123. // Impresion de Pantalla
  124. //*********************************************************************************************************
  125. void impPantalla(void){                                        //Función que imprime pantalla
  126.    lcd_gotoxy(1,2);                                            //Posiciona el cursor en la pantalla
  127.    printf(lcd_putc,"%2u",datoExt[0]);                          //Imprime Temperatura Exterior
  128.    lcd_gotoxy(3,2);                                            //Posiciona el cursor en la pantalla
  129.    lcd_putc(0xDF);                                             //Imprime unidad de medida
  130.    lcd_gotoxy(4,2);                                            //Posiciona el cursor en la pantalla
  131.    lcd_putc("C");                                              //Imprime unidad de medida
  132.    lcd_gotoxy(6,2);                                            //Posiciona el cursor en la pantalla
  133.    printf(lcd_putc,"%2u",datoExt[1]);                          //Imprime Humedad Exterior
  134.    lcd_gotoxy(8,2);                                            //Posiciona el cursor en la pantalla
  135.    lcd_putc("%RH");                                            //Imprime unidad de medida
  136.    lcd_gotoxy(12,2);                                           //Posiciona el cursor en la pantalla
  137.    printf(lcd_putc,"%3u",datoExt[2]);                          //Imprime Luminosidad Exterior
  138.    lcd_gotoxy(15,2);                                           //Posiciona el cursor en la pantalla
  139.    lcd_putc("%L");                                             //Imprime unidad de medida
  140.    lcd_gotoxy(3,1);                                            //Posiciona el cursor en la pantalla
  141.    printf(lcd_putc,"%2u",datoInt[0]);                          //Imprime Temperatura Interior
  142.    lcd_gotoxy(5,1);                                            //Posiciona el cursor en la pantalla
  143.    lcd_putc(0xDF);                                             //Imprime unidad de medida
  144.    lcd_gotoxy(6,1);                                            //Posiciona el cursor en la pantalla
  145.    lcd_putc("C");                                              //Imprime unidad de medida
  146.    lcd_gotoxy(10,1);                                           //Posiciona el cursor en la pantalla
  147.    printf(lcd_putc,"%2u",datoInt[1]);                          //Imprime Humedad Exterior
  148.    lcd_gotoxy(12,1);                                           //Posiciona el cursor en la pantalla
  149.    lcd_putc("%RH");                                            //Imprime unidad de medida
  150. }
  151. //*********************************************************************************************************
  152. // Programa principal, Realiza la lectura de DHT11, lectura de batería y recibe los datos por UART
  153. // Lee la temperatura y humedad interna, realiza un pronóstico aproximado
  154. //*********************************************************************************************************
  155. void main(){                                                   //Función principal
  156.    enable_interrupts(global);                                  //Habilita interrupciones globales
  157.    enable_interrupts(int_rda);                                 //Habilita interrupción de dato en UART
  158.    lcd_init();                                                 //Inicializa LCD
  159.    while(true){                                                //Loop principal infinito
  160.       leeDHT11();                                              //Función que lee DHT11
  161.       delay_ms(2000);                                          //Delay de Actualizacion
  162.       impPantalla();                                           //Imprime pantalla LCD
  163.       delay_ms(2000);                                          //Delay de Actualizacion
  164.    }
  165. }
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!