Mostrando las entradas con la etiqueta PIC16F886. Mostrar todas las entradas
Mostrando las entradas con la etiqueta PIC16F886. Mostrar todas las entradas

sábado, 27 de julio de 2024

Programar PIC16F con Bootloader


Programación de PIC16 con TinyBootloader

Que tal, soy Pablo y te doy la bienvenida por visitar mi blog relacionado con la programación de microcontroladores PIC, mencionar que estoy abierto a cualquier critica constructiva con referencia a esta publicación.

En esta entrada quiero mostrar como utilizar un cargador o bootloader en los microcontroladores PIC16F88x, si bien es posible adaptar el código fuente a una gran variedad de modelos  PIC16F y PIC18F,  solo considerare esos modelos porque son los que habitualmente utilizo en los ejemplos publicados en este blog. Entre las herramientas que utilizaremos están:
  • Un programador para PIC, que permite grabar el bootloader
  •  Una cable de interfaz o adaptador USB-UART
  • El software del bootloader <TinyBootloader> para Windows o la variante <TinyBootloader> para linux.
  • Software de desarrollo MPLABx cualquier versión.

Introducción

Un bootloader es un programa reducido que permite transferir el código de nuestro programa al microcontrolador MCU, esto sin necesidad de utilizar grabador como el pickit, para llevar a cabo esta transferencia se utiliza uno de los puertos de comunicación serial uart o usb del MCU. La ventaja que conlleva utilizar un bootloader es sobre todo facilitar la actualización del código o firmware de un circuito basado en MCU, utilizando una PC.
 
Un bootloader o cargador aprovecha la característica que tienen los MCU de modificar su memoria de programa en tiempo de ejecución, en el caso de los PIC esta característica la denominan Self-Write Program Memory, no todos los modelos poseen esta opción, pero gracias a esto el código bootloader que reside en la memoria del PIC, puede transferir cada byte de un nuevo firmware desde una PC hasta la memoria de programa (Actualización)
Existen varios cargadores bootloader disponibles para PIC, cada uno con características propias en cuanto a soporte y requerimientos de memoria, para nuestro caso utilizaremos el conocido TinyBooloader, siendo uno los de aspectos mas relevantes su tamaño, que ocupar solo 100 posiciones de memoria y es adaptable a varios modelos PIC, este cargador utiliza el modulo UART de comunicación serial.

Fig1. Software del Cargador Tiny Bootloader

Encontrara mayor información sobre las características de esta cargador y una clara descripción de su funcionamiento en la pagina de su autor: Claudiu Chiculita, abajo dejo el enlace
 
 En su pagina también encontrara una lista de PIC's que han sido probados con TinyBootloader, y una tabla comparativa con otros cargadores.  
 
Desarrollo

Para hacer uso del cargador TinyBootloader en nuestro PIC16F, debemos descargar el software que es gratuito y además posee el código fuente del cargador:

<Enlace para descarga de TinyBootloader>

Una vez descargado este software, que es un archivo zip, lo descomprimiremos en un carpeta y notaremos que en su estructura están el programa ejecutable, las fuentes de cargador y algunos ficheros boot generados, utilizaremos un programador Pickit3 para cargar un bootloader en la memoria del PIC. Hay dos caminos para abordar este punto:

  • Utilizar un firmware bootloader(ficheros boot) generado para un modelo de PIC, con la frecuencia del oscilador y velocidad de comunicación serial, preestablecidos.

  • Compilar el código fuente, para ajustar al modelo de PIC, la frecuencia del oscilador y velocidad de comunicación serial que necesitamos en nuestro circuito, para esto recomiendo utilizar la antigua versión MPLAB, dado que el código fuente esta escrito en este IDE.

Como verán la primera opción es la forma mas simple de implementar el cargador, porque solo necesitamos descargar el firmware bootloader para nuestro modelo de PIC, por eso dejare una lista de enlace para los PIC16F887 y PIC16F886 que utilizo en los ejemplos de este blog:
 
 
Los pasos para grabar el bootloader en el PIC, con nuestro programador Pickit3 o cualquier otro que se disponga, son primero realizar la conexión necesaria del programador al PIC, respetando las indicaciones de la programación en circuito <ICSP>, luego utilizando el software del programador en mi caso MPLABX IPE pasamos el bootloader al PIC, como se ve en las figura 2 y 3. 

Fig2. Carga del Bootloader en Tarjeta PIC16F
 

Fig2. Grabando el bootloader en el PIC

Una vez cargado el bootloader en el PIC, conectamos el adaptador USB-UART al puerto de nuestro ordenador y el otro extremo del adaptador a los pines RXD, TXD del PIC en forma cruzada, así mismo se deberán conectar las lineas de GND en ambos extremos, como se observa en el diagrama que muestra la figura 3. El adaptador que utilizare sera el CP2102 de Silicon Labs, el cual debe ser reconocido por el sistema operativo, si usas Windows el asistente iniciara el proceso de instalación de manera automática y como resulta se asignara un serial COMxx en la lista de dispositivos. En caso de que el asistente de instalación no funcione deberá proceder a la instalación manual, para lo cual debe descargar del driver desde la pagina que provee el fabricante.

Fig3. Conexión USB-UART al PIC
 
Una vez completada la instalación del controlador para el adaptador USB-UART, abrimos el programa TinyBootloader, seleccionamos el puerto COMx asignado en la instalación y la velocidad de comunicación. 
 
Luego presionado el boton [CheckPIC] verificamos el reconocimiento del PIC, este paso nos sirve también para confirmar la comunicación correcta entre la aplicación y el bootloader del PIC. Para llevar a cabo esta prueba es importante mencionar que el PIC debe estar en modo boot, por lo tanto deberá reiniciarlo.
 
(Nota) Cuando suministra energía al PIC, este se mantiene en modo bootloader por unos 5 segundos, y luego pasara a modo normal, la verificación [CheckPIC] y actualización [Write Flash] solo puede llevarse a cabo en modo bootloader 

Fig4. Ajuste y verificación TinyBootloader
 
Ya en este punto solo resta cargar nuestro código al PIC, seleccionando el archivo hex desde la carpeta de nuestro proyecto MPLABX, y luego presionamos el botón de reinicio del PIC, para después de un lapso no mayor a los 5 segundos presionar el botón [Write Flash]. La trasferencia demorar unos segundos dependiendo del tamaño del archivo hex, finalmente nuestro PIC quedara actualizado y listo para funcionar.

Fig5. Programación del PIC con TinyBootloader
 
Conclusiones

Se ha comprobado el funcionamiento del cargador TinyBootloader de forma satisfactoria, utilizando programas básicos para el PIC16F887, si bien la tabla provista por el auto indica pruebas correctas para otros modelos, queda pendiente ir actualizando esta informacion conforme realice pruebas de este cargador en otros modelos de PIC, como recomendación es importante considerar los siguiente aspectos:
  • TinyBootloader no permite realizar cambios a los fusibles de PIC, ya que estos valores se establecen al momento de programar el bootloader vía ICSP.
  • Como el bootloader se aloja en las ultimas 100 posiciones de la memoria Flash del PIC, es necesario que el compilador reserve estas posiciones para su uso. En el caso de XC8 se adicionara al linker dentro de MPLABX los siguientes parámetros --ROM=default,-1F80-1FFF. Donde los últimos valores resaltados, representan el rango de posiciones reservadas. PIC16F887 Flash 8K posiciones, 0000h-1FFFh, ultimas posiciones 1F80-1FFF.  

Fig6. Configuración Proyecto MPLABX para bootloader
 

Sin mas que mencionar agradezco tu visita al blog y espero que el ejemplo visto pueda ser útil en tu formación y el proyecto que desarrollas.

 
Atte. Pablo Zárate Arancibia
email: pablinza@me.com / pablinzte@gmail.com, @pablinzar
Santa Cruz de la Sierra - Bolivia

miércoles, 24 de julio de 2024

Programacion por Estados con Temporizador

 Programación por Estados con Temporizador


Este sitio fue creado para compartir el mutuo interés en la electrónica y en especial la programación de microcontroladores PIC. Agradecido por visitar mi blog te quiero recordar que estoy atento a critica constructiva relacionada con esta publicación. 

Hoy quiero explicar como lograr de forma practica y sencilla la concurrencia de tareas dentro del bucle secuencial de un programa, para lo cual haremos uso del temporizador con interrupción, en microcontroladores PIC y AVR.

Para el caso de un PIC, la programación se realiza utilizando el software MPLABX junto con el compilador XC8 ambos disponibles en la pagina oficial de microchip y en el caso de microcontrolador AVR, utilizaremos la plataforma Arduino dada la facilidad y el amplio uso que tiene.

Mencionar también que en la presente publicación de da por entendido que el visitante o lector, posee medios de programación en lenguaje C y experiencia en el uso de microcontroladores PIC / AVR

Introducción

Dado que los microcontroladores disponen de un microprocesador para ejecutar las instrucciones del programa almacenadas en su memoria, el desarrollo de software se lleva a cabo principalmente con la programación estructurada secuencial, esto es básicamente ejecutar en secuencia múltiples tareas, una después de otra y repitiendo este ciclo de forma indefinida, como puede ver en la figura 1.

Fig1. Ejecución secuencial de cuatro Tareas

Si bien cada tarea puede incluir sentencias selectivas e iterativas, una vez iniciada la ejecución, la tarea debe finalizar para continuar con la siguiente, a simple vista podemos mencionar que la limitaciones que conlleva esta programación se dan debido a los siguientes aspectos:

  • La ejecución de cada tarea demora un tiempo, y no siempre es constante dado que en el proceso pueden existir retardos y condiciones sujetas a eventos que son asíncronos, como notara en la figura 1. se resaltan las magnitudes de tiempo utilizada por cada tarea, siendo en total un valor de 1000 por cada ciclo de ejecución, podemos imaginar que la unidad de medida son millonésimas(us) o milésimas(ms) de segundos.
  • Durante el ciclo secuencial, una tarea deberá esperar la ejecución del resto de tareas, si el tiempo es muy largo se verán afectados aquellos eventos que requieran atención inmediata, por ejemplo la tarea 1 debe esperar un tiempo de 750(50+500+200) para iniciar nuevamente, mientras que la tarea 3, debe esperar 500(200+250+50).

Observe la figura 2 que muestra el código de un par de tareas tomadas del ejemplo, la tarea 1 esta  encargada de obtener un valor de un canal analógico y guardarlo en memoria, y como sabemos este proceso debe primero iniciar la conversion y esperar a que finalice, lo que conlleva a tener tiempos de espera., en cuanto a la tarea 2, responsable de destellar una luz LED, posee tiempos de esperar suficientes para notar el cambio de encendido y apagado.

Fig2. Ejemplo de Código Tarea 1 y Tarea 3

Un enfoque de programación alternativo que vamos a revisar, es la ejecución de tareas concurrentes pero de forma simplificada ya que los PIC/AVR que estamos revisando poseen recursos limitados. No se tocaran detalles del concepto de concurrencia, ya que es un tema bastante amplio y complejo en algunos casos debido al uso que tienen dentro de los sistemas operativos. por lo que enfocare la explicación mas a la practica. 

Entonces sobre este tema mencionare que a diferencia de la estructura secuencial ya vista con antelación, la concurrencia permite que las tareas se lleven a cabo al mismo tiempo, y una técnica para conseguir esto tomando en cuenta un sistema con un solo microprocesador, es hacer que las tareas gestionen su propio estado y el tiempo total del ciclo de ejecución sea muy corto, para que todas las tareas que se ejecutan durante el ciclo secuencial lo mas rápido posible. Observe la figura 3, donde cada una de las cuatro tareas utilizan 0.25 de tiempo, para completar la unidad 1.0.  

Fig3. Concurrencia de cuatro tareas

Se preguntara entonces, ¿Como? es posible hacer esto, y la respuesta seria:

No esperar que las tareas finalicen su trabajo en cada ciclo, y por el contrario hacer que cada tarea tenga control de su estado en base al tiempo y el numero de veces que es invocado. Un modelo de programación aplicable a esta técnica, es la maquina de estados finitos, donde la tarea se divide en estados y las transiciones entre estados están sujetas a condiciones, que se validan únicamente cuando se ejecuta la tarea, observe como seria el código de las tareas 1 y 3 considerado esta técnica. 

Fig4. Código Tarea 1 y Tarea 3

Como notara en la figura 4, ahora la tarea 1, dispone de cinco estados, cada uno de ellos realiza una actividad, lo interesante es que ya no existen esperas, por ejemplo el estado 2, que debe esperar la conversion, ahora solo revisa si la bandera de ocupado (ADC_Busy) sigue activa, y dependiendo esta validación se determina si la tarea mantiene su estado o pasa el estado siguiente. En el caso de la tarea 2, se utiliza un contador de ciclos para determinar los momentos para encender y apagar la luz, pero la tarea nunca se queda esperando.

El concepto de las Maquinas de Estados Finitos al igual que otras técnicas como GRAFCET, implican el uso de diagramas de estado y simbologías propias que no se aplicaran a nuestro ejemplo practico, por esa razón de aqui en adelante haré referencia a esta técnica como Programación por Estados con Temporizador.

Ahora veamos la practica, para conseguir que el ciclo de ejecución posea un tiempo preciso, utilizare un Temporizador y su interrupción, entonces describiré la configuracion de este recurso considerando los módulos temporizadores del PIC16F886 y el ATmega328.

Si quieres conocer mas a profundidad los detalles de los módulos TMR de un PIC16, te recomiendo que revises las siguientes entradas: 

Configuración y uso del <TMR0>  <TMR1>  del PIC16F

Temporizadores en el PIC16F

El microcontrolador PIC16F887 dispone de los siguientes módulos:

  • TMR0 Modulo Contador/Temporizador de 8-bit
  • TMR1 Modulo Contador/Temporizador de 16-bit
  • TMR2 Modulo Temporizador de 8-bit

La operación de estos módulos es similar. Si hablamos de un temporizador significa que un registro contador incrementara su valor con cada pulso proveniente del oscilador utilizado por el PIC, en el caso del TMR1, este registro es de 16-bit, siendo su capacidad de contar desde 0 hasta 65535. Para incrementar la capacidad de contar, cada modulo cuenta con etapas divisoras de frecuencia que puede ajustarse a escalas determinadas.

Cuando el registro contador llega al valor limite, con el siguiente pulso ocurrirá un desbordamiento, donde el contador se reinicia a cero, y la bandera TxIF se activara para notificar este evento, esta bandera debe ser desactivada por programa cuando se complete la atención al evento.

Ahora veremos como configurar el temporizador con el modulo TMR0 y TMR1, para lo cual consideraremos los siguiente: 

La frecuencia del oscilador Fosc = 8000000 Hz, y el tiempo base requerido para ajustar el temporizador sera Tb = 0.001 segundo (1ms)

Configuración del  TMR0

La figura 5, describe los registros específicos asociados a la operación del modulo TMR0, donde se muestran los bits y sus valores por defecto.

Fig5. Registros SFR del TMR0
El código de configuracion considerando Fosc=8MHz y Tb=1ms sera.

 OPTION_REGbits.T0CS = 0;//Modo Termporizador
 OPTION_REGbits.PSA = 0; //Con pre-escala
 OPTION_REGbits.PS = 0b011; //Pre-escala 16:1
 TMR0 = 131; //Tb=1ms TMR0=256-(0.001*Fosc)/(pre*4)
 INTCONbits.T0IF = 0; //Limpia bandera
 INTCONbits.T0IE = 1; //Habilita la interrupción del TMR0
 INTCONbits.GIE = 1; //Habilitador Global ISR

La rutina de servicio a la interrupción tendrá lo siguiente:

void __interrupt() isr() //Rutina de interrupción
{
  if(INTCONbits.T0IF)
//Bandera desbordamiento TMR0
  {
    TMR0 = 131;
//Reinicia contador
    INTCONbits.T0IF = 0; 
//Limpia bandera
  }
}

Configuración del TMR1

La figura 6, describe los registros específicos asociados a la operación del modulo TMR0, donde se muestran los bits y sus valores por defecto.

Fig6. Registros SFR del TMR1
El código de configuracion considerando Fosc=8MHz y Tb=1ms sera.
      T1CONbits.TMR1CS = 0; //Modo temporizador
   T1CONbits.T1CKPS = 0b00;
//Ajuste pre-escala 1:1
   TMR1H = 0xF8;
//Tb=1ms TMR1=65536-[(0.001*8M)/(1:1*4)]
   TMR1L = 0x30;
// 63536 F830h
   PIR1bits.TMR1IF = 0;;
//Limpia la bandera
   T1CONbits.TMR1ON = 1;
//Arranca temporizador
   PIE1bits.TMR1IE = 1; 
//Activa interrupción del T1
  
INTCONbits.PEIE = 1;//Activa interrupción de periféricos
   INTCONbits.GIE = 1;
//Activador global ISR

La rutina de servicio a la interrupción tendrá lo siguiente:

void __interrupt() isr(void) //Rutina de servicio a interrupciones
{ 
    if(PIR1bits.TMR1IF)
//Evento de desbordamiento TMR1
    {
        PIR1bits.TMR1IF = 0;
//Limpia la bandera TMR1
        T1CONbits.TMR1ON = 0;
//Para al contador
        TMR1H = 0xF8;
//Actualiza valor del contador
        TMR1L = 0x30;

        T1CONbits.TMR1ON = 1;
//Arranca al contador
    }
}
 

Temporizadores ATmega

El microcontrolador ATmega328 que es utilizado por la tarjeta Arduino UNO dispone de los siguientes módulos:

  • TC0 Contador/Temporizador de 8-bit
  • TC1 Contador/Temporizador de 16-bit
  • TC2 Contador/Temporizador de 8-bit

Cada modulo cuenta con los  modos de operación: Normal, CTC, PWM y PWM con corrección de fase. Para nuestro caso trataremos únicamente el modo Normal que representa el modo de operación mas simple donde el registro contador se incrementa con cada pulso de reloj hasta su desbordamiento. En el caso de los AVR la bandera TOVxF se reinicia automáticamente cuando se atiende el evento.

Considerando que utilizaremos una tarjeta Arduino UNO, es importante mencionar que los modulo son utilizados de acuerdo a lo siguiente:

  • TC0: Funciones delay(), millis(), micros() y PWM pines 5,6.
  • TC1: Librería se servomotores Servo.h y PWM 9,10
  • TC2: Función Tone() y PWM 3,11

Por esta razón, para no afectar la funcionalidad de Arduino solo trataremos la configuracion de los temporizadores TC1 y TC2 considerando que la frecuencia del oscilador es Fosc = 16MHz y el tiempo base Tb = 1ms

Configuración del TC1

La figura 7, describe los registros específicos asociados a la operación del modulo TC1, donde se muestran los bits y sus valores por defecto.

Fig7. Registros SFR del TC1
El código de configuracion, considerando los valores defecto sera el siguiente:

  TCCR1A = B00000000;//Registro A Operación Modo Normal
 
TCCR1B = B00000011;//Registro B Ajusta la prescala CS=1:64
 
TCNT1H = 0xFF; //Tb=1ms TCNT1=65535-(0.001*8M/64)=FF05h
 TCNT1L = 0x05;
 TIMSK1 |= 0x01;
//Activa interrupcion TOIE del T1

La rutina de servicio a la interrupción tendrá lo siguiente:

ISR(TIMER1_OVF_vect) //Evento de desbordamiento T1
{
   TCNT1H = 0xFF;
//Reinicia el valor del contador
   TCNT1L = 0x05;
}

Configuración del TC2

La figura 8, describe los registros específicos asociados a la operación del modulo TC2, donde se muestran los bits y sus valores por defecto.

Fig8. Registros SFR del TC2

El código de configuracion, considerando los valores defecto sera el siguiente:

 TCCR2A = B00000000;//Registro A Operación Modo Normal
 
TCCR2B = B00000100;//Registro B Ajusta Prescala CS=1:64
 TCNT2 = 5;
//Tb=1ms TCNT2=255-(0.001*8M/64)=05h
 TIMSK2 |= 0x01;
//Activa la interrupción TOIE del T2

La rutina de servicio a la interrupción tendrá lo siguiente:

 ISR(TIMER2_OVF_vect) //Evento de desbordamiento T2
 {
   TCNT2 = 5;
//Reinicia el valor del contador
 }

Código de Ejemplo

Como practico vamos a crear un programa que permita ejecutar tres tareas de forma concurrente, las tareas que se llevaran a cabo son:

  • Tarea 1: Destello de LED indicador de actividad (taskLED)
  • Tarea 2: Lectura ADC del canal y almacenamiento de resultado (taskADC)
  • Tarea 3: Control de velocidad para motor de pasos (taskSTM)

Realizamos el programa considerando los esquemas de circuito que se observan en la figura 9 y 10. en ambos casos del PIC y AVR utilizaremos el modulo TMR1 y TC1 respectivamente.

Tome en cuenta que los esquemas que se observan en la figuras 9 y 10, son únicamente para fines de simulación,  obviando las conexiones de alimentación y amplificadores de corriente para el motor de pasos.

Circuito y Programa del PIC16F886

Fig9. Esquema de circuito PIC para simulación con Proteus

  Codigo Proyecto MPLABX 

#pragma config FOSC=INTRC_NOCLKOUT,WDTE=OFF,LVP=OFF
#include <xc.h>
void setup(void);
void taskLED(void);
//Prototipo de función
void taskADC(void);
void taskSTM(void);
uint16_t speed = 0;
//Variable para control de velocidad
volatile uint8_t tickms = 0;
void main()
{
    setup();
    while(1)
    {
        if(tickms)
//Bandera activada en ISR cada 1ms
        {
            tickms = 0;
//Limpia la bandera
            taskLED();
//Destella el led cada segundo
            taskADC();
//Lectura ADC canal 0
            taskSTM();
//Control de pasos en motor
        }
    }
}
void __interrupt() isr()
//Rutina de interrupción
{

  if(INTCONbits.T0IF)
//Bandera desbordamiento TMR0
  {
    TMR0 = 131;
//Reinicia contador TMR1
    INTCONbits.T0IF = 0;
//Limpia bandera del TMR1
    tickms = 1;
  }
}
void setup(void)
{
    OSCCONbits.IRCF = 0b111;
//Selecciona Fosc=8MHz
    while(OSCCONbits.HTS == 0);
//Espera Fosc estable
    TRISBbits.TRISB5 = 0;
//Modo Salida LED
    TRISB &= 0b11110000;
//
Salidas B0=L1 B1=L2 B2=L3 B4=L4
    ANSEL = 0; //Deshabilita pines analógicos AN0-7
    ANSELH = 0;
//
Deshabilita pines analógicos AN8-13
    /* CONFIGURACIÓN ADC-10 Canal0 para Fosc=8Mhz*/
    ANSELbits.ANS0 = 1;
//Habilita canal AN0
    ADCON0bits.ADCS = 0b10;
//TAD=4us > 1.6us (8MHz/32)
    ADCON0bits.CHS = 0;
//Selecciona Canal 0
   
/* CONFIGURACION TMR0 1ms para Fosc=8MHz*/
    OPTION_REGbits.T0CS = 0;
//Modo Temporizador
    OPTION_REGbits.PSA = 0;
//Con pre-escala
    OPTION_REGbits.PS = 0b011;
//Pre-escala 16:1
    TMR0 = 131;
//Tb=1ms TMR0=256-(0.001*Fosc)/(pre*4)
    INTCONbits.T0IF = 0;
//Limpia bandera
    INTCONbits.T0IE = 1;
//Habilita interrupción del TMR0
    INTCONbits.GIE = 1;
//Habilitador Global ISR
}
void taskLED(void)
//Tarea para destellar el led
{
  static uint16_t cnt = 0;
  if(cnt++ > 999)
//Cada segundo
  {
    cnt = 0;
    PORTBbits.RB5 = 1;
//Activa led a 0 seg
  }
  if(cnt == 200) PORTBbits.RB5 = 0;
//Apaga led a 0.2 seg
}
void taskADC(void)
//Tarea para leer el canal ADC0
{
  static uint8_t state = 0;
  static uint16_t cnt = 0;
  uint16_t adcval;
  switch(state)
  {
    case 0:
      ADCON0bits.ADON = 1;
//Activa el modulo AD
      state = 1;
      break;
    case 1:
      ADCON0bits.GO = 1;
//Inicia la conversion AD
      state = 2;
      break;
    case 2:
      if(ADCON0bits.GO == 0)
//Espera fin conversion
      {
        adcval = ADRESL;
        adcval |= (uint16_t) (ADRESH << 8);
        adcval >>= 6;
//Corrige alineación ADRESH:ADRESL
        speed = adcval;
        ADCON0bits.ADON = 0;
//Desactiva el modulo AD
        cnt = 0;
        state = 3;
      }
      break;
    case 3:
      if(cnt > 499)
//Espera 500 ms
        state = 0;
      else cnt = cnt + 1;
      break;
  }
}
void taskSTM(void)
{
  static uint8_t state = 0, res;
  static uint16_t cnt = 0;
  cnt = cnt + 1;
  switch(state)
  {
    case 0:
//Estado de Motor Paso 1
      if(cnt > speed)
      {
        res = PORTB & 0xF0;
        PORTB = res | 0b0011;
        cnt = 0;
        state = 1;
      } break;
    case 1:
//Estado de Motor Paso 2
      if(cnt > speed)
      {
        res = PORTB & 0xF0;
        PORTB = res | 0b0110;
        cnt = 0;
        state = 2;
      } break;
    case 2:
//Estado de Motor Paso 3
      if(cnt > speed)
      {
        res = PORTB & 0xF0;
        PORTB = res | 0b1100;
        cnt = 0;
        state = 3;
      } break;
    case 3:
//Estado de Motor Paso 4
      if(cnt > speed)
      {
        res = PORTB & 0xF0;
        PORTB = res | 0b1001;
        cnt = 0;
        state = 0;
      } break;
  }
}

Circuito y Programa del ATmega328
Fig10. Esquema de circuito AVR para simulación en Proteus

  Código sketch Arduino  

volatile uint8_t tickms = 0; //Bandera para indicar 1ms
uint16_t speed = 0;
//Variable para control de velocidad
void setup()
{
  DDRB |= _BV(DDB5);
//Salida pin RB5 UNO=D13
  DDRB |= B00001111;
//Salida pines B0=L1 B1=L2 B2=L3 B3=L4
  DDRC = 0xFF;
//Salidas pines del PORTC
  DDRC &= ~_BV(DDC0);
//Entrada pin PC0
 
/*CONFIGURACION TC1 como temporizador a 1ms Fosc=16MHz*/
  TCCR1A = 0x00;
//Modo Normal
  TCCR1B = 0x03;
//Registro B Prescala CS=1:64
  TCNT1H = 0xFF;
//t=1ms TCNT1=65535-(0.001*Fosc/64)=FF05h
  TCNT1L = 0x05;
  TIMSK1 |= 0x01;
//Activa interrupción TOIE del T1
 
/*CONFIGURACIÓN ADC Canal 0, Modo Free Running a 125Khz*/
  ADMUX = 0x40;
//AVcc referencia, MUX canal 0
  ADMUX |= _BV(ADLAR);
//ADC Alineado a la izquierda ADCH:ADCL
  ADCSRA = 0x07;
//Pre 1:128 16M/128 = 125Khz
  DIDR0 |= _BV(ADC0D);
//Habilita pin en modo analógico
}
void loop()
{
  if(tickms)
//Bandera activada en ISR cada 1ms
  {
    tickms = 0;
//Limpia la bandera
    taskLED();
//Destella el led cada segundo
    taskADC();
//Lectura ADC canal 0
    taskSTM();
//Control de pasos en motor
  }
}
ISR(TIMER1_OVF_vect)
//Interrupción Desbordamiento del T1
{
  TCNT1H = 0xFF;
//Reinicia el contador
  TCNT1L = 0x05;
  tickms = 1;
//Activa la bandera
}
void taskLED()
//Tarea para destellar el led
{
  static uint16_t cnt = 0;
  if(cnt++ > 999)
//Cada segundo
  {
    cnt = 0;
    PORTB |= _BV(PORTB5);
//Activa led a 0 seg
  }
  if(cnt == 200) PORTB &= ~_BV(PORTB5);
//Apaga led a 0.2 seg
}
void taskADC()
//Tarea para leer el canal ADC0
{
  static uint8_t state = 0;
  static uint16_t cnt = 0;
  uint16_t adcval;
  switch(state)
  {
    case 0:
      ADCSRA |= _BV(ADEN);
//Activa el modulo AD
      state = 1;
      break;
    case 1:
      ADCSRA |= _BV(ADSC);
//Inicia la conversion AD
      state = 2;
      break;
    case 2:
      if((ADCSRA & _BV(ADSC))==0)
//Espera fin conversion
      {
        adcval = ADCL;
        adcval |= (ADCH << 8);
        adcval >>= 6;
//Corrige alineación ADCH:ADCL
        speed = adcval;
        ADCSRA &= ~_BV(ADEN);
//Desactiva el modulo AD
        cnt = 0;
        state = 3;
      }
      break;
    case 3:
      if(cnt > 499)
//Espera 500 ms
        state = 0;
      else cnt = cnt + 1;
      break;
  }
}
void taskSTM()
{
  static uint8_t state = 0, res;
  static uint16_t cnt = 0;
  cnt = cnt + 1;
  switch(state)
  {
    case 0:
//Estado de Motor Paso 1
      if(cnt > speed)
      {
        res = PORTB & 0xF0;
        PORTB = res | B00000011;
        cnt = 0;
        state = 1;
      } break;
    case 1:
//Estado de Motor Paso 2
      if(cnt > speed)
      {
        res = PORTB & 0xF0;
        PORTB = res | B0110;
        cnt = 0;
        state = 2;
      } break;
    case 2:
//Estado de Motor Paso 3
      if(cnt > speed)
      {
        res = PORTB & 0xF0;
        PORTB = res | B1100;
        cnt = 0;
        state = 3;
      } break;
    case 3:
//Estado de Motor Paso 4
      if(cnt > speed)
      {
        res = PORTB & 0xF0;
        PORTB = res | B1001;
        cnt = 0;
        state = 0;
      } break;
  }
}

Conclusiones 

Como recomendación, considerar los siguientes aspectos:
  • Hay una relación entre el tiempo base (Tb) y el tiempo utilizado en cada ciclo, este ultimo va depender de la cantidad de tareas y las instrucciones que se ejecutan a nivel individual, donde la suma total de tiempo no debe ser mayor al tiempo base. 
  • Si utiliza un tiempo base menor a 1ms, el MCU debe poseer la capacidad de ejecutar las instrucciones de todas las tareas en un ciclo, este punto se puede garantizar incrementando la frecuencia del oscilador, pero hay limites que deben ser revisados.
  • Si utiliza un tiempo de base mayor a 1ms, no habrá inconvenientes con la ejecución, pero debe contar que incrementar el tiempo base, hace que el sistema sea menos sensible, y podrían ocasiones algunos inconvenientes en la tratamiento de los puertos E/S.
Abajo dejare un breve vídeo que muestra el funcionamiento del programa, en ambos casos utilice una placa de pruebas donde la conexión al motor de 5V se realizo con un driver basado en el amplificador ULN2003, el montaje del circuito se observa en las siguientes imágenes.
 
Fig11. Montaje del circuito con ATmega328

Fig12. Montaje del circuito con PIC16F



Repositorio git con ejemplo sencillos que utilizan la ejecución de tareas concurrentes con temporizador: https://github.com/pablinza/elt436
Sin mas que mencionar agradezco tu visita al blog y espero que el ejemplo visto pueda ser útil en tu formación y el proyecto que desarrollas.
Atte. Pablo Zárate Arancibia
email: pablinza@me.com / pablinzte@gmail.com, @pablinzar
Santa Cruz de la Sierra - Bolivia

jueves, 6 de junio de 2019

Temperatura y Humedad con DHT-11/22

Sensor Humedad/Temperatura DHT con PIC

Fig1. Circuito con Sensor DHT11

Muchas gracias por tu visita a este blog relacionado con la programación de micro-controladores PIC, en esta entrada quiero mostrarles como utilizar los sensores DHT para medir la humedad relativa y temperatura ambiental que nos servirán para implementar aplicaciones y/o estaciones de información meteorología.

El objetivo de esta entrada es realizar la lectura adecuada del sensor DHT con un microcontrolador PIC16F en la que se establece una comunicación serial asíncrona por un solo cable, con un protocolo similar a 1-Wire conforme a las especificaciones técnicas del sensor.

La programación del microcontrolador PIC se lleva a cabo con el software  de diseño  MPLABX  y el compilador de lenguaje C para PIC XC8, ambos disponibles en la pagina de microchip de forma gratuita. Aquí dejo los enlaces de las versiones utilizadas para nuestro ejemplo:   
 
Acerca del Sensor DHT

Es un sensor digital para medir la Humedad relativa y Temperatura ambiental, cuenta con un procesador interno que realiza la medición de un elemento capacitivo y un termistor, proporcionando el resultado a través de una señal digital. La interfaz de comunicación con el PIC utiliza una linea bidireccional en modo half-duplex. Seguidamente describiremos los dos modelos identificados como DHT11 y DHT22 que trabajan entre 3.3 a 5.0V y poseen un encapsulado y disposición de pines compatible con las siguientes diferencias  técnicas:


Fig2. Descripción de pines DHT11/22

  • DHT11: Trabaja con un rango de medición de temperatura de 0 a 50 °C con una exactitud de ±2.0 y 1°C de precisión y el rango de medición para la humedad relativa es de 20% a 80% con una exactitud del 5% y 1% de precisión. En ambos casos el resultado esta conformado por 16-bit siendo un byte para el valor entero y el otro byte para el decimal, pero este modelo posee una resolución de 8-bit por que únicamente se emplea la parte entera del resultado. Los ciclos de lectura debe ser como mínimo 2 segundos.

  • DHT22: El rango de  medición de temperatura es de  -40°C a 80 °C con exactitud de ±0.5 °C y precisión de 0.1°C. El rango de humedad es de 0 a 100% RH con exactitud del 2% y precisión del 0.1%. El resultado de ambas mediciones esta conformado por 16-bit,  el tiempo entre lecturas debe ser de 2 segundos.

A simple vista podemos destacar que la principal diferencia entre ambos modelos es el rango de operación y la exactitud pero también hay diferencias en el proceso para establecer la comunicación con el sensor y el resultado de una medición, además que los ciclos de lectura en un DHT22 son mas lentos (2 a 5 segundos) debido a su mayor precisión en el resultado.


Protocolo de comunicación DHT

Como ya mencionamos previamente el voltaje de operación nominal para estos sensores es de 5V, pero pueden trabajar a menor voltaje 3.3V considerando que la distancia entre el sensor y el MCU sera mucho menor, adames en el pin de comunicación SDA(DATA) es necesario adicionar una resistencia en modo pull-up de 4.7k con la que es posible conectar a una distancia de 30 metros, una resistencia de mayor reduce esta distancia de conexión, también es recomendable agregar una capacitor de 100nF entre VDD y GND  para un mejor filtrado en el voltaje de alimentación, la figura 3 muestra la conexión necesaria entre el sensor y el MCU.


Fig3. Conexión entre el Sensor y el MCU
 

Para establecer la comunicación bidireccional a través de la linea SDA(DATA) el microcontrolador (MCU) utilizara un pin configurado como salida al momento de establecer un nivel bajo en SDA y como entrada tri-state para leer los niveles de SDA, utilizando el siguiente procedimiento de señalización y su respectiva temporización:

Fig4. Protocolo de comunicación MCU - Sensor
 
  • Señal de Establecimiento (Start signal): Normalmente la linea SDA se encuentra en un estado ALTO, entonces en esta etapa el MCU establece la linea SDA en nivel BAJO por un tiempo de 1ms(DHT22) o 18ms(DHT11) para luego liberar la linea a su estado inicial es decir un nivel ALTO.

  • Señal de Respuesta (Response signal): En esta etapa el MCU tiene configurado el pin como entrada tri-state esperando a que el sensor coloque la linea SDA en nivel BAJO como respuesta al Start Signal, la duración este cambio sera al menos 80us y luego el sensor libera la linea SDA por un tiempo mínimo de 80us. A partir de este momento el sensor empezar a enviar los datos de la ultima medición efectuada.

  • Datos (Data transfer): En esta etapa el MCU mantiene el pin como entrada tr-state para recibir los 40-bits de datos por parte del sensor, cada bit se interpretara conforme a la siguiente regla de tiempos:

    • (Bit 0) Nivel BAJO por 50us y ALTO por 25 a 28us.

    • (Bit 1) Nivel BAJO por 50us y ALTO por 70us.

Una vez completado el procedimiento de comunicación, el resultado de 40 bits recibidos del sensor mantienen el formato de campos que se muestra en la figura 5, donde los dos bytes mas significativos representan el valor de la humedad, los siguientes dos bytes corresponden a la temperatura y finalmente el ultimo byte se utiliza para verificar error de paridad y es un resultado de sumar los cuatro primeros bytes del dato.

 
Fig5. Trama con los datos recibidos del sensor
 
El MCU deberá procesar la trama de datos recibido de acuerdo al modelo del sensor, conforme a los siguiente ejemplo:
Trama de 40-bit recibidos del sensor DHT11
 <00110101><00000000>  <00011000><00000000><01001101> 
      RHint          RHdec              TEint        TEdec       Paridad    
 
Para verificar si hay error de paridad, bastara sumando los cuatro primeros bytes de la trama y si este resultado es igual al ultimo byte nos indicaría que no hay error en los datos. Para obtener el valor de Humedad relativa solo cambiamos la representación del primer byte que es un numero entero a su equivalente decimal.
<00110101> = 35h = 53 %
Para obtener el valor de Temperatura aplicamos al byte 3 el paso anterior, es decir.
<00011000> = 18h = 24 °C.
Otro ejemplo considerando ahora la respuesta del un sensor DHT22 es la siguiente Trama.  
Trama de 40-bit recibidos del sensor DHT22
 <00000010><10010010>  <00000001><00001101><01001101> 
      RHint          RHdec              TEint        TEdec       Paridad    
La verificacion del error de paridad es similar al caso anterior, en cuanto los demás datos para obtener la humedad relativa se puede efectuar el siguiente calculo tomando los dos bytes (16-bit) juntos.
<00000010 10010010> = 292h, entonces cada dígito 2 * 256 + 9 * 16 + 2 = 658 / 10 = 65.8 %
La temperatura se obtiene aplicando el siguiente calculo.
 <00000001 00001101> =10Dh = 1 * 256 + 0 * 16 + 13 =  269 / 10 = 26.9 °C.
 
Un punto a tomar en cuenta con el modelo DHT22, es a temperaturas bajo cero el primer bit correspondiente al campo de temperatura (TEint) indica el signo del resultado, en tal sentido el MCU deberá efectuar la verificacion correspondiente para la correcta interpretación de la magnitud.

Esquema del Circuito PIC16F
El circuito que utilizaremos para la prueba de este sensor se muestran en la figura 6, en primera instancia hay únicamente un sensor DHT conectado al pin RB4 y un modulo convertidor USB/UART a los pines de comunicación del modulo UART a fin de enviar los recibidos del sensor y mostrar los valores de temperatura y humedad considerando los cálculos que vimos previamente.
 
 
Fig6. Esquema del circuito PIC
Notara que en el esquema del circuito no se observa la resistencia pull-up que requiere la linea SDA del sensor, esto es así porque activaremos la resistencia interna que posee el pin del MCU, el circuito tampoco la etapa de alimentación y reinicio que necesita el PIC16F, dando por hecho que ya están implementadas estas conexiones. Finalmente el diodo LED1 servirá para indicar el funcionamiento adecuado del programa mediante un destello por cada segundo. 
 
Programación del PIC
A fin de facilitar el uso de este sensor utilizaremos un grupo de funciones incluidas en la librería dht.c/dht.h que forman parte de los ficheros del proyecto MPLABX.
Antes de describir las funciones que utilizaremos con el sensor, se deberán personalizar en el archivo de cabecera dht.h las siguientes definiciones:
#define _XTAL_FREQ 8000000
/* USER PORT DEFINITION */
#define DHT_PORT    PORTB  
//Puerto asociado al Sensor
#define DHT_TRIS    TRISB  
//Registro de Configuración del Puerto
#define DHT_DEV1 0x10      
//Mascara del pin RB4 conectado al DHT 
/* END USER PORT DEFINITION */ 

Ahora mostraremos la lista de los procedimientos que podemos utilizar para hacer uso de este sensor:

DHTSetup(devmask): Este procedimiento configura los pines definidos en la cabecera para su posterior uso con el sensor DHT, el pin colocar por defecto la linea SDA en nivel ALTO. Siendo posible iniciar uno o mas pines a los que se conectara un sensor, por ejemplo:

DHTSetup(DHT_DEV1); //Configura un pin DHT
DHTSetup(DHT_DEV1|DHT_DEV2|DHT_DEV3);
//Configura tres pines DHT

DHTStart(devmask, type): Es una función que establece el pulso de inicio y retorna uno (1) al finalizar el pulso ya cuando el nivel de la linea SDA es ALTO. Es importante recalcar que esta función debe llamarse consecutivamente hasta que devuelva un uno (1) y luego de esto recién iniciar la lectura del sensor.

DHTRead(devmask, type, dst): Esta es la función encargada de recibir los 40-bits del sensor DHT, el resultado estará almacenado en la dirección dado por el parámetro dst (puntero a byte) y retorna uno (1) solo si la verificacion de paridad es correcta. Debe tomar en cuenta que esta función es bloqueante y se deberia evitar interrupciones mientras se ejecuta. A continuación veremos el siguiente ejemplo de uso.

if(DHTStart(DHT_DEV1, DHT11)) //Emite pulso de inicio DHT11
{
     INTCONbits.GIE = 0;
//Desactiva interrupción global
    res = DHTRead(DHT_DEV1, DHT11, buffer); //Lectura de los 40-bits
    INTCONbits.GIE = 1; //Activa interrupción global
    if(res) //Valido solo si la paridad es correcta
    {
        //Se procesan los datos almacenados en buffer 
        printf("Raw Hu=%X%X Te=%X%X\r\n",buffer[0],buffer[1],buffer[2],buffer[3]);  
     }
}

DHTUpdate(type, src): Este procedimiento es el encargado de procesar el resultado de 40-bits de una lectura previa, y obtener los valores de humedad relativa y temperatura en el sistema decimal, para esto la librería utiliza una estructura de datos DHT con los siguientes campos:

typedef struct
{
    uint8_t tem;
//Temperatura parte entera
    uint8_t temr;
//Temperatura parte decimal (fracción)
    uint8_t hum;
//Humedad parte entera
    uint8_t humr;
//Humedad parte decimal
} DHT_t;

 
El uso del procedimiento es bastante simple y se refleja en el siguiente ejemplo:
if(DHTStart(DHT_DEV1, DHT11))
{
    INTCONbits.GIE = 0;
    if(DHTRead(DHT_DEV1, DHT11, buffer))
    {
      printf("Raw Hu=%X%X Te=%X%X\r\n",buffer[0],buffer[1],buffer[2],buffer[3]);
      DHTUpdate(DHT11, buffer);
      printf("Final Hu=%u Te=%u\r\n",DHT.hum, DHT.tem);
    }
    INTCONbits.GIE = 1;
}

Si el código descrito previamente se ejecuta de manera continua con un periodo mayor a los dos segundos, el resultado que obtenemos conectando un terminal serie desde nuestro ordenador sera como muestra la figura 7.
 
Fig7. Resultado de la lectura de un sensor DHT11

Un programa completo para llevar a cabo la lectura del sensor DHT11 con intervalos de dos segundos, tendría la siguiente estructura:

void main(void)
{
    MCUSetup();
    DHTSetup(DHT_DEV1);
    while(1)
    {
        if(tickms)
//Valida cada ms
        {
            tickms = 0;
            taskLED();
//Destellar LED
           
taskDHT(); //Lectura y envío datos Sensor
        }
    }
}

Donde la tarea para efectuar la lectura taskDHT que es llamada continuamente cada un milisegundo, controlara su estado de ejecución a través del siguiente código:

void taskDHT(void) //Periodo de ejecución 1ms
{
    static uint8_t state = 0;
    static uint16_t cnt = 0;
    uint8_t res;
    cnt++;
    switch(state)
    {
            case 0:
//Lectura y muestra del sensor DEV1
            if(DHTStart(DHT_DEV1, DHT11))
            {
                INTCONbits.GIE = 0;
                res = DHTRead(DHT_DEV1, DHT11, buffer);
                INTCONbits.GIE = 1;
                if(res)
//Si paridad es correcta
                {
                    DHTUpdate(DHT11, buffer);
                    print("Final Hu=");
                    printByte(DHT.hum);
                    print("% Te=");
                    printByte(DHT.tem);
                    print("\'C\r\n");                  
                }
                state = 1;
//próxima espera
            }
            break;
        case 1:
//Espera nuevo ciclo dos segundos
            if(cnt == 2000)
            {
                cnt = 0;
                state = 0;
            }
            break;   
    }
}

Una vez compilado y preparado el código en el PIC, se llevaran a cabo las conexiones del circuito incluido la comunicación con una terminal serial desde el ordenado (PC), entonces el resultado que nos arrojara el MCU sera el que se muestra en la figura 8.

Fig8. Datos obtenidos del sensor DHT11

Los procedimientos que se mostraron con antelación son parte del archivo principal main.c que contiene el proyecto, este archivo contiene código adicional que no se ha detallando en la presente publicación, por esta razón dejo el enlace para que puedas descargarlo y analizar con mas detalles desde el IDE MPLABX. <Proyecto DHT11 con PIC16>

Si quieres ver como compilar e implementar los proyectos de este blog, elaborados con MPLABX mira este vídeo.<Compilando proyectos MPLABX> 

Mas abajo de dejo el enlace de  vídeo de mi canal en el que se realiza una practica utilizando mas de un sensor DHT.

 
Conclusiones y Recomendaciones

Luego de hacer la demostración del programa podemos concluir que podemos implementar fácilmente cualquiera de estos dos sensores.
Una desventaja con estos sensores es la velocidad de las lecturas y el tiempo de espera para realizar una lectura nueva que es mayor a dos segundos, aunque en muchos casos puede no ser un inconveniente debido a que la Temperatura y Humedad relativa son variables que no cambian de forma rápida.

Sin mas que mencionar agradezco tu visita al blog y espero que el ejemplo visto pueda ser útil en tu formación y el proyecto que desarrollas.

Atentamente, Pablo Zárate Arancibia  email: pablinza@me.com / pablinzte@gmail.com, @pablinzar

Santa Cruz de la Sierra - Bolivia