Mostrando las entradas con la etiqueta PIC16F887. Mostrar todas las entradas
Mostrando las entradas con la etiqueta PIC16F887. 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

martes, 2 de julio de 2024

I2C Comunicacion Maestro Esclavo PIC16F

Comunicación Maestro Esclavo PIC16F

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. 

En esta ocasión veremos como hacer uso del modulo MSSP para implementar una comunicaciones bidireccional entre dos PIC16F utilizando el protocolo I2C, y que nos servirá para aplicar esta comunicación a diversos dispositivos y/o sensores que hacen uso de esta interfaz.

La programación se realizara utilizando MPLABX y el compilador XC8 ambos disponibles en la pagina de microchip. Aquí dejo los enlaces de las versiones utilizadas para nuestro ejemplo:  <<MPLABX v6.20>>   <<XC8 v2.45>>

Mencionar también que es necesario contar con conocimientos mínimos sobre programación en lenguaje C y el uso de microcontroladores PIC16.

Introducción al Tema

I2C es un protocolo de comunicación síncrono que posibilita la interconexión de múltiples de dispositivos mediante un bus común, conformado por dos lineas de conexión, una del tipo bidireccional para los datos (SDA) y una linea de sincronismo para el reloj (SCL), tal como se observa en la figura 1.

Fig1. Bus I2C (Wikipedia)
Un aspecto interesante de este bus, es que el protocolo I2C incorpora el proceso de direccionamiento Maestro-Esclavo por software, es decir que la conexión lógica entre dos dispositivos se determina por un campo de informacion de direccionamiento que se envía al inicio de la comunicación. Los microcontroladores que disponen de este recurso establecen la señalización de manera automática, y en el caso de no contar con este recurso también es posible implementarlo mediante software.

Antes de continuar, es importante saber que existe bastante informacion relacionado al protocolo I2C en la web y canales de internet, por lo que compartiré un par de enlaces que nos ayudaran con la introducción:

Con esta lectura daremos por hecho que sabemos como funciona I2C, y estamos con la necesidad de utilizar esta interfaz en algún proyecto electrónico, en este caso utilizaremos un microcontrolador PIC16F que disponga del modulo MSSP.

Modulo Serial SSP/MSSP

Es importante mencionar que los microcontroladores PIC de 8-bit con capacidad de comunicación I2C disponen de unos los siguientes módulos:

  • MSSP (Master Synchronous Serial Port): Este modulo posibilita la comunicación I2C en modo maestro y esclavo, soportando por hardware toda la señalización necesaria para I2C.
  • SSP (Synchronous Serial Port): Posibilita la comunicación I2C en modo esclavo, y provee señalización de inicio y parada para la implementación del modo maestro mediante software.

Dado que el modulo MSSP es un recurso mas completo que el SSP, nos centraremos en su configuracion tomando como referencia el microcontrolador PIC16F887. En la hoja de datos del PIC16F887 encontrara el diagramas de bloque del modulo MSSP- I2C para la operación en ambos modos Maestro y Esclavo. siendo los siguientes registros de memoria utilizados para implementar esta comunicación:

  • SSPSR (Registro de desplazamiento temporal): Este no registro no es directamente accesible, y su función es recuperar o enviar en serie los bits que conforman el dato.  
  • SSPBUF (Registro de dato): Contiene el dato según el caso. si se trata de una recepción, los bits recibidos en el registro SSPSR se cargan a SSPBUF para su lectura, y en el caso de una transmisión, el dato que contiene SSPBUF se carga al registro SSPSR para enviar los bits.
  • SSPADD (Registro para Dirección o Contador): En modo esclavo, este registro sirve para establecer una dirección de 7 bits del protocolo I2C, y en modo maestro con este registro es posible configurar la frecuencia del reloj de acuerdo a la siguiente relación: Fi2clk = Fosc/(4*(SSPADD+1))
  • SSPSTAT (Registro de estado). Únicamente el bit SMP deberá ser ajustado dependiendo de la frecuencia utilizada para el reloj, los valores predeterminados para este fin son SMP=1 para 100Khz./1MHz y SMP=0 para 400KHz. Los bits de lectura D/A, P, S, R/W, UA y BF son utilizando para indicar el estado de la señalización durante la comunicación.
  • SSPCON1 (Registro de configuracion 1):

Los bits de este registro establecen la siguiente configuracion del modulo; WCOL y SSPOV indican el estado de colisión o desbordamiento en el bus, este estado requiere restablecimiento de la funcionalidad; El bit SSPEN habilita la operación del modulo; El bit CKP en modo esclavo permite controlar la liberación del reloj(clock streetch), y finalmente los cuatro bits SSPM:3:0 determinan los siguientes modos de operación:

Para nuestro caso practico estos bits mantendrán los siguientes valores: modo esclavo de 7-bits SSPM=0110 y modo maestro SSPM=1000
  • SSPCON2: Registro de configuracion 2

Los bits de este registro son utilizados en el modo maestro para establecer la señalización necesaria durante la comunicación I2C, la manipulación de estos se dan dentro de las funciones que posee la librería i2c.

Configuración MSSP modo Maestro

Los aspectos importantes a considerar en un dispositivo maestro, es este provee la señal del reloj en el pin SCL, por lo que es necesario configurarlo, además el maestro es responsable del direccionamiento a los dispositivos esclavos conectados al bus, y por lo tanto debe asegurarse un nivel logico para el estado de reposo, para este fin se agregan unas resistencias pull-up a las lineas SDA y SCL.

La configuracion de los pines asociados a SDA y SCL se establecen de manera automática al configurar y habilitar el modulo MSSP como maestro.

Consideraremos como ejemplo de configuracion del siguiente código, un dispositivo I2C maestro con frecuencia de 100KHz,  y donde la frecuencia de oscilación del PIC16F887 sera de 8MHz.

     /*MSSP MODO I2C MASTER Fosc=8MHz -> rate=100KHz*/
    SSPSTATbits.SMP = 1;
//Slew rate 1=off(100KHz/1MHz) 0=On(400KHz)
    SSPADD = 19;
//[Fosc/(4 * rate)]-1 para 100KHz
    SSPCONbits.SSPM = 0b1000;
//Fosc/(4*(SPADD+1))
    SSPCONbits.SSPEN = 1;
//Activa el modulo MSSP

Configuración MSSP modo Esclavo

En un dispositivo esclavo, se debe considerar que este posee un dirección única de 7 bits entre los demás dispositivos conectados al bus I2C, aunque es posible el direccionamiento a 10 bits, este modo no se tratara en nuestro caso. 

En el modo esclavo el modulo MSSP del PIC16F887 requiere que los pines asociados a SDA y SCL estén configurados como entradas digitales. Además debido que el inicio de la comunicación es establecida por el dispositivo maestro, es importante que la notificación de este evento se apoye en la bandera de interrupción SSPIF. En esta caso la funcionalidad del la comunicación I2C se establecerá dentro de la rutina de interrupción ISR.

      /*MSSP MODO I2C SLAVE Fosc=8MHz -> rate=100KHz*/
    TRISCbits.TRISC3 = 1;
//SCL configura el pin como entrada
    TRISCbits.TRISC4 = 1;
//SDA configura el pin como entrada
    SSPSTATbits.SMP = 1;
//Slew rate 1=off(100KHz/1MHz) 0=On(400KHz)
    SSPADD = I2CADDR;
//Direccion del esclavo SPADD[7:1]
    SSPCONbits.SSPM = 0b0110;
//Modo esclavo a 7-bit
    SSPCONbits.CKP = 1;
//0=Hold clock low 1=Release Clock
    SSPCONbits.SSPEN = 1;
//Activa el modulo MSSP
    PIR1bits.SSPIF = 0;
//Limpia la bandera de evento I2C
    PIE1bits.SSPIE = 1;
//Activa la interrupcion del evento I2C

Esquema de Circuito

Se describe el esquema del circuito que se utilizara para desmostar la comunicación I2C Maestro-Esclavo entre los microcontroladores PIC16F887.

Fig2. Circuito de prueba Maestro-Esclavo PIC16F

El circuito que se ilustra en la figura 2, muestra la interconexión de ambos microcontroladores PIC16F al bus I2C mediante los pines SDA y SCL, donde las resistencias pull-up aseguran un nivel logico del bus en estado de reposo.

Cada PIC16F posee cuatro diodos LED conectados a los pines de salida RB0:RB3 y cuatro conmutadores a los pines de entrada RB4:RB7 del PORTB, adicionalmente hay un diodo LED conectado al pin RE2, que sirve para indicar actividad del programa mediante un destello.

A fines de una mejor comprensión del esquema, el PIC16F de la izquierda sera el Maestro y el PIC16F de la derecha el Esclavo, por lo tanto el funcionamiento del circuito sera el siguiente: Se establece en ambos una comunicación bidireccional utilizando I2C de tal manera que el PIC maestro muestra a través de los LED conectados a su salida el nivel logico que tienen los conmutadores del PIC esclavo y así mismo los niveles lógicos en los conmutadores del PIC maestro se mostraran en los LED del PIC esclavo.

Como se menciono mas arribe, en ambos PIC16F el LED del pin RE2 destellara cada segundo para indicar actividad en sus respectivos programas.

La dirección del dispositivo esclavo se establecerá en 0x3E, por lo tanto si el Maestro quiere enviar informacion al Esclavo deberá establecer el siguiente protocolo de comunicación:

Fig3. Maestro envía dato al Esclavo
Si el maestro quiere recibir informacion del esclavo, recordemos que únicamente el maestro es quien establece la comunicación I2C, por lo tanto para recibir un dato del esclavo, el maestro puede establecer el siguiente protocolo de comunicación:

Fig4. Maestro recibe dato del Esclavo
Puesto que se trata de una comunicación bidireccional donde el maestro debe enviar datos del estado en sus entradas al esclavo y mostrar en sus salidas los niveles lógicos que tienen las entradas del esclavo, es posible que el maestro establezca este intercambio con el siguiente protocolo.

Fig5. Maestro envía y recibe dato del Esclavo

Utilizaremos el ultimo caso, considerando un intervalo de 200ms entre cada comunicación o dialogo I2C entre ambos PIC16F, los intervalos estarán apoyados con las interrupciones del temporizador TMR0. Si deseas conocer como configurar este modulo, te recomiendo revisar la siguiente entrada; 

<Usos del TMRO>

Programación del PIC16F887

Seguidamente se detalla parte del código del programa que se utiliza en ambos PIC16F, se comentara según el caso que instrucción corresponde al Maestro y al Esclavo.  Mas abajo se dejan los enlaces para que pueda descargar el código completo del proyecto en MPLABx.

#include <xc.h>
#include <stdint.h>
#include "i2c.h"
#define LEDpin PORTEbits.RE2
#define I2CADDR 0x7E
//Dirección 7-bit I2C 0111-111x (3Eh)
typedef struct
//Estructura de Puerto
{
    unsigned OUTpins :4;
//Salida LEDS
    unsigned INPpins :4;
//Entrada Conmutadores
} PORTstruct_t;
volatile PORTstruct_t PORT __at(0x006);
//Asocia al PORTB
volatile uint8_t tick1ms = 0;
//Bandera 1ms
uint16_t cntms = 0;
//Contador de ms
uint8_t i2cdata = 0;
//dato i2c
void setupMCU(void);
//Procedimiento de configuracion
void taskLED(void);
//Procedimiento destello LED RE2
void taskI2C(void);
//Procedimiento comunicación Maestro

void main(void) //Programa principal
{
    setupMCU();
//Configuración del PIC16F
    while(1)
//Bucle indefinido del programa
    {
        if(tick1ms) //bucle Intervalo 0.001seg
        {
            tick1ms = 0;
            taskLED();
//Tarea destellar LED
            taskI2C();
//Comunicación I2C, solo en modo maestro
        }
    }
}
void setupMCU(void)
//Configuración del PIC
{
    OSCCONbits.IRCF = 0b111;
//Fosc=8MHz Tcy=0.5uS Oscilador RC
    while(OSCCONbits.HTS == 0){};
//Espera
    ANSEL = 0;
//Desactiva los puertos AN0 al AN7
    ANSELH = 0;
//Desactiva los puertos AN8 al AN13
    TRISB = 0xF0;
//Pines RB0-RB3 salidas y RB4-RB7 entradas
    PORTB = 0x00;
//Salidas PORTB en nivel 0
    TRISEbits.TRISE2 = 0;
//Pin de salida LED
    PORTEbits.RE2 = 0;
//Salida del pin en nivel 0
    OPTION_REGbits.nRBPU = 0;
//Activa pull-ups entradas PORTB
    PORT.OUTpins = 0;
//Establece en 0 las salidas
   
/*CONFIGURACION TIMER0 1MS Fosc=8Mhz*/
    OPTION_REGbits.T0CS = 0;
//Modo Termporizador
    OPTION_REGbits.PSA = 0;
//Con prescala
    OPTION_REGbits.PS = 0b011;
//Prescala 1:16
    TMR0 = 131;
//256-(time/((pre)*(4/Fosc))) time=0.001 seg
    INTCONbits.T0IF = 0;
//Limpia bandera
    INTCONbits.T0IE = 1;
//Activa
interrupción del TMR0
  
  /*CONFIGURACION MSSP MODO I2C MASTER Fosc=8MHz -> rate=100KHz*/
      
Codigo de la configuracion en modo Maestro

    /*MSSP MODO I2C SLAVE Fosc=8MHz -> rate=100KHz*/
        Codigo de la configuracion en modo Esclavo
    /*CONFIGURA INTERRUPCIONES*/
    INTCONbits.GIE = 1;
}

 

Código del Maestro

Aquí se describen las instrucciones del procedimiento taskI2C utilizado en el programa del dispositivo Maestro, note que este código es llamada a un intervalo de 0.001 segundo, pero al utilizar un contador cnt vera que la comunicación ocurre cada 200 llamadas al procedimiento, esto es 5 veces por segundo.

void taskI2C(void) //Cada 1ms
{
  static uint16_t cnt = 0;
  if(cnt++ > 199)
//Actualiza I2C cada 200ms
  {
   
//I2C Protocol <S><ADDR><W><PORTOUT><R><ADDR><R><PORTIN>
    i2cdata = PORT.INPpins;
//Carga dato con valores de RB4:RB7
    I2CIdle();
//Espera a que el bus este en modo reposo
    I2CStart();
//Inicia la comunicación
    I2CWrite(I2CADDR);
//Direcciona al esclavo para escritura RW=0
    I2CWrite(i2cdata);
//Envia el dato al esclavo
    I2CRestart();
//Reiniciar la comunicación
    I2CWrite(I2CADDR | 0x01);
//Direcciona al esclavo para lectura
    i2cdata = I2CRead();
//Carga el dato recibido del esclavo
    I2CNotAck();
//Señaliza el no-reconocimiento para indicar final
    I2CStop();
//Finaliza la comunicación
    PORT.OUTpins = i2cdata;
//Establece los LEDS con el dato recibido
    cnt = 0;
  }
}

Código del Esclavo

Ahora describiremos el código de comunicación correspondiente al dispositivo Esclavo, donde se denota que el código que maneja la comunicación I2C se encuentran dentro de la rutina de atención a la interrupción ISR, por lo tanto el proceso de atención se da con el evento SSPIF, que indica la presencia de un dato o dirección recibido desde el maestro.

void __interrupt() isr(void)
{
  if(PIR1bits.SSPIF)
//Evento que ocurre en el Receptor
  {
    PIR1bits.SSPIF = 0;
//Limpia la bandera de interrupción
    i2cdata = I2CSlaveRead();
//Lectura del byte recibido
    if((!SSPSTATbits.R_nW) && SSPSTATbits.D_nA)
//Si un dato es recibido
      PORT.OUTpins = i2cdata;
//Establece RB0:RB3 con el valor del dato
    if(SSPSTATbits.R_nW && (!SSPSTATbits.D_nA))
//Si un dato es solicitado
    {
      i2cdata = PORT.INPpins;
//Carga el dato con el valor de RB4:RB7
      I2CSlaveWrite(i2cdata);
//Envía el dato al maestro
    }    
  }
}


Pruebas de comunicación

Fig6. Montaje del circuito con dos PIC16F
Una vez cargado el programa correspondiente a cada PIC16F, notara que en ambos PIC16F887 empieza a destellar el LED una vez por segundo, esto indica que el programa se encuentra en funcionamiento normal. También observara que los cuatro LED de salida están activados, cuando los conmutadores no están cerrados, esta lógica obedece al hecho de que las entradas conectadas al los pines del PORTB RB4:RB7 tienen las entradas con resistencias pull-up activadas, entonces al presionar o cerrar el conmutador el nivel logico recién cambia a 0.
 

Conclusiones

Se verifico correctamente la comunicación I2C entre los microcontroladores PIC16F887, haciendo uso de sus respectivos módulos MSSP, cumpliendo así con el objetivo de esta publicación, si bien las características de I2C van mas allá de los descrito en esta sección, aspectos como el direccionamiento de 10-bit, el modo multi-maestro, el evento de llamada general, etc. El ejemplo que vimos representa la mayoría de los casos de uso con microcontroladores.
Aquí dejo los enlaces para que puedas descargar el proyecto MPLABX, mismo que se encuentra comprimidos en gzip.

También de dejo vídeo donde explico como abrir el proyecto MPLABX y compilar con otro PIC diferente al utilizado. 

Sin mas que mencionar agradezco tu visita al blog y espero que el ejemplo que trabajamos 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


viernes, 19 de enero de 2024

ADC Lectura de corriente AC con ACS712

 Medir consumo de corriente AC220V

Fig1. Modulo ACS712



Este sitio fue creado para compartir el mutuo interés en la electrónica y en especial la programación de microcontroladores PIC. Descrita la introducción te agradezco por visitar mi blog recordando que estoy atento a cualquier consulta o critica constructiva relacionada con esta publicación.

En esta ocasión veremos como medir el consumo de corriente tipo alterna haciendo uso de un modulo muy accesible por su disponibilidad y precio, este modulo se basa en un circuito integrado ACS712.
El propósito que se desea lograr en esta oportunidad es medir con un microcontrolador PIC16F887, la corriente de consumo que tiene una carga conectada al suministro eléctrico domiciliario 220V/50Hz, y mostrar el valor en amperios (A) mediante mensajes de texto enviados por puerto serie UART a una terminal PC. Para llevar a cabo las pruebas se recomienda tomar las debidas precauciones de seguridad sobre todo en la interconexión del modulo AC712 con la carga.

La programación se realizara utilizando MPLABX y el compilador XC8 ambos disponibles en la pagina de microchip. Aquí dejo los enlaces de las versiones utilizadas para nuestro ejemplo:

 <<MPLABX v6.15>>   <<XC8 v2.45>>

La configuración del entorno se utiliza el pack PIC16Fxxx_DFP(1.5.151)
Mencionar también que es necesario contar con conocimientos mínimos sobre programación en lenguaje C y el uso de microcontroladores PIC16.

Acerca del efecto HALL 

Se conoce como efecto Hall a la aparición de un campo eléctrico por separación de cargas en el interior de un conductor por el que circula una corriente en presencia de un campo magnético con componente perpendicular al movimiento de las cargas(Wikipedia).

Haciendo referencia a la nota de aplicación del fabricante de sensores Honeywell (Hall Effect Sensing and Application). ilustraremos con mayor claridad este efecto en la tecnología de medición.

Imaginemos una pequeña lamina semiconductora(elemento Hall interno de un sensor) por la que atraviesa una corriente eléctrica; si medimos el voltaje eléctrico en los extremos perpendiculares al flujo de corriente notaremos que ante la ausencia de un campo magnético este voltaje es 0 debido a que la distribución de corriente es uniforme en toda superficie de la lamina.

Fig2. Efecto Hall en ausencia de un campo magnético 

Ahora con la presencia de un campo magnético se produce una fuerza conocida como fuerza de Lorentz que perturba el flujo de corriente ocasionando un diferencia de potencial eléctrico en los extremos, esta diferencia es el voltaje Hall.
 
Fig3. Efecto Hall en presencia de un campo magnético


Entonces podemos deducir que el voltaje Hall es proporcional al producto de la corriente que circula por el elemento y el campo magnético que lo atraviesa, siendo necesario amplificar este valor para que pueda ser capturado por el microcontrolador.


Modulo sensor ACS712

En el sensor de corriente ACS712, se incorpora internamente un camino o pista de cobre superficial por donde circula la corriente de carga, esta corriente de paso genera un campo magnético que a la vez deriva en una diferencia de potencial en los extremos de la sección de pista, esta diferencia es estabilizada y optimizada internamente para conseguir una salida con voltaje proporcional a la corriente. Este sensor posee poca perdida debido a que la resistencia interna de la pista de cobre es muy baja. Algo muy importante de mencionar que el circuito integrado ACS712 a fecha esta descontinuado y por lo tanto no esta recomendado para nuevos diseños, pero el fabricante dispone de nuevos modelo que ofrecen mejores prestaciones.
Como mencione previamente la razón de utilizar este sensor pese a estar descontinuo, es la disponibilidad que hay a un bajo costo económico, en cualquier caso tanto el hardware y software elaborado en este ejemplo adaptable a los modelos actuales del sensor.
Seguidamente listo alguna de las características mas relevantes del sensor ACS712 extraídos de la hoja de datos:
  • Resistencia interna de 1.2 milésimas de Ohm;
  • Error total en salida del 1.5% a 25°C;
  • Aislamiento mínima de 2.1kV RMS;
  • Voltaje de salida proporcional para AC y DC;
  • Voltaje de operación a 5V;
  • Sensibilidad en salida de 66 a 185mV/A.
Las variantes con respecto al sensor ACS712 se listan a continuación:
  • ACS712ELCTR-05B-T ±5A 185mV/A (Hasta 5A);
  • ACS712ELCTR-20A-T ±20A 100mV/A (Hasta 20A);
  • ACS712ELCTR-30A-T ±30A 66mV/A (Hasta 30A).
Fig4. Variantes del modulo ACS
La siguiente gráfica nos ilustra el comportamiento proporcional que tiene el voltaje de salida con respecto a la corriente que se mide con la variante 05B, las gráficas correspondientes a los demás modelos se encuentran en la hoja de datos del fabricante.

Fig5. Voltaje de salida / corriente medida ACS712-05B
Como detalle adicional en referencia a la fig5. notara que la salida del sensor sera de 2.5V sin consumo, por lo tanto el rango de salida considerando la relación de 185mV por amperio, sera de 1.57V — 3.42V. Esto se deduce considerando que el valor máximo de 5 A representa 0.925V (0.185 * 5), siendo el rango 2.5 ± 0.925V.

La siguiente figura muestra el esquema de circuito para el modulo de pruebas ACS-712, el cual posee los elementos esenciales para la operación y conexión al microcontrolador.

Fig6. Esquema de circuito del modulo sensor ACS712
 
Como ya vimos, la salida OUT, proporciona una señal de voltaje en el rango 2.5 ± 0.925V. según la corriente que circula por la pista IN+/ IN-, esta dependencia se visualiza en la figura 5. 
Como el voltaje aplicado a la carga es una onda sinusoidal alterna 220V con frecuencia de 50Hz en el caso de mi país, la salida del sensor también oscilara, manteniendo el periodo de 20ms. (t=1/f).
La medición que se realizara utilizando el modulo ADC del PIC16F dentro de un periodo de tiempo posibilitara calcular la corriente de consumo, aplicando uno de los siguientes métodos:
 
Método 1) Determinar los valores pico VPK de la señal alterna en un periodo de tiempo, y calcular el valor RMS(Root Mean Square), con el producto VRMS = VPK * 0.707 tal como se se muestra en la figura 7, este calculo es valido únicamente con señales sinusoidales.

Fig7. Calculo de Valor RMS

Método 2) Esta técnica es aplicable a cualquier tipo de señal y consiste en tomar una muestra de los valores absolutos en cada semi-ciclo para determinar un promedio,. Entonces el valor RMS se obtiene aplicando la formula que se muestra en la figura 8.
 
Fig8. Calculo de valor RMS
Si se integra la función seno para un semi-ciclo, se encuentra que el voltaje promedio VPM = VPK * (2/π ).

Una vez calculado el valor RMS(Root Mean Square) la corriente podrá determinarse por la relación de salida Voltaje / Corriente del sensor. En nuestro caso utilizaremos el modulo ACS-712-05B el cual según la hoja de datos posee una sensibilidad de 185mV/A. 
 
Esquema de conexión PIC16F y ACS712
La figura 9 muestra el esquema de conexión del microcontrolador PIC16F al modulo ACS712. El circuito se alimenta con +5V y la salida OUT del modulo ACS712 se conecta de forma directa al canal AN0 del PIC16F.
Fig9. Diagrama de conexión del circuito
El conversor ADC del PIC16F posee una resolución de 10-bits, y el rango de voltaje para la conversion sera de 2.5 ± 0.925V(ACS712-05), con el fin de mejorar la sensibilidad de cambio, se utilizara como voltaje de referencia positivo el pin AN3/Vref+, mismo que se conectara al divisor de tensión formado por las resistencias. El voltaje del divisor sera 3.75V (+5 * 10k/(10k+3.3k). 
Con esta configuracion podemos determinar que la sensibilidad en mV por cada bit sera:

(Vref+ - Vref-) / 2^10-bits = (3.75V - 0V) / 1024 = 3.66 mV.

Conociendo este resultado, la relación de cambio en bits por cada amperio sera 185mV/3.66mV = 50.5 bits. (ACS712-05)
 
Por otro lado la comunicación serial con la PC, utiliza un convertidor USB a UART, en nuestro caso es un CP-2102, pero puede ser cualquier otro conversor, porque solo se requiere un par de conexiones a los pines TXD y RXD del PIC16F, finalmente existe un diodo LED conectado al pin RE2 que destellara para indicar la actividad del programa.
 
Programa del Microcontrolador PIC
El objetivo de este programa es medir la corriente de consumo para una carga alterna de 100W utilizando el modulo sensor ACS712, el valor determinado por el PIC16F, se enviara cada segundo por el puerto serie como un mensaje de texto a 9600bps. El método aplicado para el calculo de la corriente es la medición del valor pico Ipk y división por raíz cuadrada como se observa en la figura 7.
El PIC16F opera con un cristal de 20MHz, siendo esta la base de calculo para la configuracion del tiempo de adquisición del convertidor ADC, modulo USART y el temporizador TMR0. Para mayores referencias sobre la operación del convertidor ADC del PIC16F puedes ir al siguiente enlace de una publicación previa de este blog:

En cuanto a los procedimiento y funciones utilizadas en el programa, todo se resume en el código principal main.c con sus respectivos comentarios. En la parte final dejo el enlace para descarga del proyecto MPLABX que contiene todos lo archivos utilizados.
 
void main(void)
{
    setup();
//Configuración de puertos y periféricos
    while(1)
    {
        if(tick1ms)
//Bandera activa cada 1ms
        {
            tick1ms = 0;
//Limpia bandera
          
  taskAPP(); //Ejecuta cada 1ms
        }
        taskADC();
//Ejecuta la tarea continuamente
    }
} 

void setup(void)
{
   
//Oscilador Externo HS=20MHz Tcy = 0.2us
    ANSEL = 0;     
//Pines AN0-AN7 en modo digital
    ANSELH = 0;    
//Pines AN8-AN13 en modo digital
    TRISA = 0xFF;
    ANSELbits.ANS0 = 1;
//Habilita el canal AN0
    ANSELbits.ANS3 = 1;
//Habilita Vref+ AN3
    TRISEbits.TRISE2 = 0;
//Pin de salida LED
   
/* CONFIGURACION UART 9600 BPS*/
    BAUDCTLbits.BRG16 = 0;
//8-bit BaudGen
    TXSTAbits.BRGH = 1;
    TXSTAbits.TXEN = 1;
    RCSTAbits.SPEN = 1;
    SPBRG = 129;
//Formula [20M/(16 * 9600)] - 1
   
/* CONFIGURACION ADC VRAF+*/
    ADCON0bits.ADCS = 0b10; //TAD Fosc/32 = 1.6uS a 20MHz
    ADCON0bits.CHS = 0b0000; //Canal AN0
    ADCON1bits.VCFG0 = 1; //Activa Vref+ = pin AN3/RA3
    ADCON0bits.ADON = 1; //Activa modulo ADC.
   
/* CONFIGURACION TIMER0 1MS*/
    OPTION_REGbits.T0CS = 0;
//Modo temporizador
    OPTION_REGbits.PSA = 0;
//Con prescala
    OPTION_REGbits.PS = 0b100;
//Prescala 1:32
    TMR0 = 100;
//256-(time/[(pre)*(4/Fosc)]) time=0.001 seg
    INTCONbits.T0IF = 0;
//Limpia bandera
    INTCONbits.T0IE = 1;
//Activa interrupción del TMR0
    INTCONbits.GIE = 1;
//Habilita las interrupciones
}

void __interrupt() isr()
{
    if(INTCONbits.T0IF)
//Activa cada 1ms
     {
        INTCONbits.T0IF = 0;
//Limpia bandera
        TMR0 += 100;
//Reinicia contador
        tick1ms = 1;
//Activa bandera 1ms
        if(tickcnt++ > 999)
//Control 0-999 ms
            tickcnt = 0;
//Reinicia contador 1s
    }
}

void taskADC(void) //Procedimiento para lectura ADC
{
    static uint8_t cnt = 0;
    static uint16_t valmax, valmin;
    uint16_t val;
    switch(adst)
    {
        case ADSTART:
//Activa ADC, inicia variables
            ADCON0bits.ADON = 1;
            valmax = 0x0000;
            valmin = 0xFFFF;
            adst = ADREAD;
            break;
        case ADREAD:
//Inicia la lectura
            ADCON0bits.GO = 1;
            adst = ADWAIT;
            break;
        case ADWAIT:
//Espera conversion ADC
            if(ADCON0bits.GO == 0)
            {
                val = ADRESH;
                val = val << 8;
                val = val | ADRESL;
                val = val >> 6;
                if(val > valmax) valmax = val;
                if(val < valmin) valmin = val;
                if(adst == ADWAIT) adst = ADREAD;
            }
            break;
        case ADSTOP:
//Desactiva el ADC
            ADCON0bits.ADON = 0;
            if(valmax > valmin) adraw = valmax - valmin;
            else adraw = 0;
            adst = ADIDLE;
        break;
        case ADIDLE:
//Estado de reposo
            _nop();
    }
}

Luego de llevar a cabo la configuración de los pines y periféricos con el procedimiento setup(), el programa principal debe llevar a cabo las siguientes tareas por cada segundo transcurrido: 
  • Muestreo de señal, por 50m;
  • Enviar mensaje con valor de corriente;
  • Destello de LED de actividad.
Estas tres tareas se llevan cabo con el procedimiento taskAPP() en intervalos de 1ms. mismos que se controlar por la bandera de interrupción del TMR0.

void taskAPP(void)
{
    if(tickcnt == 0)
//Inicia captura ADC en 0ms
        adst = ADSTART;
    if(tickcnt == 50)
        adst = ADSTOP;
//Fin de captura ADC en 50ms
    if(tickcnt == 600) 
//Procesa y muestra datos
    {
        current = (1000UL * adraw) / 50;
//valor en ma
        current = (50UL * current) / 142;
//[100*(current/2)]/142
        printf("AMP=%lu\r\n", current);
    }
    if(tickcnt == 700) LEDpin = 1;
//Activa led en 700ms
    if(tickcnt == 900) LEDpin = 0;
//Desactiva led en 900ms
}


Pruebas de funcionamiento
Antes de abrir el proyecto en MPLABX, asegúrate de tener instalado la ultima versión del compilador XC8, una vez abierto el proyecto, en la ventana del explorador veremos los archivos del programa. Luego de revisar el codigo procedemos a compilar, y si no hay errores todo estara lista para cargar el código al microcontrolador utilizando un programador de PIC. En este punto para llevar a cabo las pruebas de funcionamiento deberás contar con un circuito montado, en mi caso utilice el circuito que se observa en la siguiente imagen.


Fig10. Circuito de pruebas PIC16F
Ya con el programa cargado en memoria del PIC16F y con el suminitro conectado, notara que el led destella una vez por segundo, indicando la correcta ejecución del programa.
Luego debemos conectar una carga a las terminales INA/INB del modulo ADC712, el valor de corriente se mostrara en el ordenador utilizando una terminal serial asociado a un puerto COM del ordenador, yo utilice en este caso HTerm, un programa gratuito y multi-plataforma que puedes descargar con el siguiente enlace: <<HTERM>>.

Para comprender mejor los valores calculados en el microcontrolador, he realizado varias capturas en cada etapa del medición dentro del programa. estos se muestran a continuación.

Fig11. Referencia AN0 con GND/VCC (valmax-valmin)
Considerar que la captura que se muestra en la figura 11, solo es referencial para comprobar el procedimiento de muestreo, dado que en ambas situaciones el voltaje de entrada es constante GND=0V y VCC=5V, la deferencia de los valores picos muestreados deberia ser idealmente 0V, aquí se puede notar que cuando AN0 va conectado directamente a GND, muestra una diferencia de 3 a 6 puntos, que asumo su origen a la improvisación de las conexiones en el protoboard y el ruido propio del sensor
que según la hoja de datos es de ±20mV. A posterior con unas pruebas adicionales sobre el circuito, veré detallar mas esta diferentes que representa un error para la medición.

Fig12. AN0 Conectado al ACS712 (valmax-valmin)

Ya con la entrada AN0 conectado al sensor ACS712, cuando no hay consumo(sin carga), el resultado ya nos muestra un valor debido al error descrito previamente, y con el consumo de 100W (con carga), el resultado aproximado es 62 bits, este valor es pico a pico, es decir la diferencia entre el valor máximo y mínimo registrado, por lo tanto si consideramos solo un semi-ciclo, representaría a la mitad de valor mostrado, esto es Vpk≈31 bits. Para obtener el valor eficaz de estos bits multiplicamos 31 * 0.701 ≈ 22 bits.  
 
Recordemos que la relación de cambio es igual a 50 bits/A, y para una carga de 100W, la corriente eficaz calculara sera 0.45A (100W/220V), entonces el valor en bits considerando la relación de cambio seria 50 * 0.45A ≈ 22 bits. 
 
La captura que se observa en la figura 13, muestra el valor de corriente pico a pico (Ipp) calculado en miliamperios, este calculo se aplico utilizando la regla de tres simple a la diferencia (valmax-valmin) y la relación de cambio de 50bits/A.

Fig13. Valor pico a pico (Ipp) en mA

Como resultado final de la medición, la captura en la figura 14, muestra el calculo del valor eficaz para el valor pico a pico de corriente, lo cual nos arroja un promedio de Irms=420mA, considerando las siete lecturas observadas.

Fig14. Valor eficaz Irms en mA
 
Para contrastar este resultado teórico con la carga de 100W, se conecto un amperímetro en serie con la carga y se procedió a medir la corriente de consumo, misma que se muestra en la figura 15.
Fig15. Valores registrados con Amperímetro
El valor promedio registrado con el instrumento fue de 0.363A es decir 363mA, que representa un valor pico de 570mA (Ipk = Ipm / (2/π )), siendo su valor eficaz  Irms ≈ 403 mA.

Recomendación y Conclusión
Si bien se ha completado la meta de medir la corriente de consumo en alterna para una carga de 100W, el ruido que se presenta en las lecturas incluso si no hay consumo, es un punto a considerar en la aplicación final, recordar este sensor ya fue descontinuado por el fabricante, recomendándose usar el ACS723.
La técnica empleada para medir la corriente eficaz consistió en medir los valores picos de la señal y calcular su valor eficaz, si bien es una manera simple para implementar, es también la mas susceptible al ruido y cambios en la forma sinusoidal de la señal alterna, por eso como una alternativa seria llevar a cabo los calculo basado en el segundo método, lo que requiere a su vez añadir al circuito un rectificador. 
Recomendar nuevamente que la conexión de carga 220VAC a los pines INA / INB del modulo ACS712 debe efectuarse con mucha precaución, considerando todas la medidas de seguridad posible, una mala conexión puede provocar severos daños personales y materiales.

Aquí dejo los enlaces para que puedas descargar el proyecto MPLABX, se encuentra en formato gzip recordando que soy usuario de linux y es probable que necesites modificar algunas referencias para compilar con windows.


Proyecto <<MPLABX ac712p16f>>

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