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

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

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