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

jueves, 4 de julio de 2024

Uso de Teclado Matricial con LCD

 Teclado Matricial con LCD

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 de un Teclado Matricial con una pantalla LCD que son de los elementos mas utilizados para implementar una interfaz de usuario en un sistema electrónico.

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

Con el objetivo de mostrar como hacer uso de un teclado matricial y una pantalla LCD, implementaremos en nuestro circuito una interfaz de usuario que permite validar una clave numérica de cuatro dígitos, mostrando los respectivos mensajes de solicitud y validación en la pantalla LCD.
Es importante mencionar que existe en internet una amplia informacion de las características y usos de estos dos dispositivos, por lo que recomiendo revisar algunas de estas referencias.

Referencia <Teclado Matricial 1> y <Teclado Matricial>    

Referencia <Pantalla LCD 1> y <Pantalla LCD 2 >

Considerando la necesidad de implementar una interfaz de usuario con Teclado Matricial y Pantalla LCD he descrito un resumen de estos dispositivos considerando el circuito que se montara para la practica.

Teclado Matricial 4x4

La figura 1, muestra la disposición interna de un teclado matricial 4x4, es decir cuatro filas y cuatro columnas, conformando así un total de 16 pulsadores o botones. Notara que el principio de funcionamiento es bastante simple, por ejemplo si presionamos el botón 3 entrara en contacto la fila 0[ROW0] con la columna 2[COL2], y se mantendrá cerrado hasta liberar el botón.

Fig1. Teclado Matricial 4x4

Bajo este principio consideraremos para fines prácticos que las columnas son las salidas y las filas son las entradas del Microcontrolador (MCU), por lo tanto conectar un Teclado Matricial 4x4 requiere al menos 8 pines del MCU.

Las figuras 2 y 3, muestran la distribución de pines de algunos Teclados que mas se comercializan, pero debe considerar que esta informacion debe verificarse con la hoja de datos que proporciona el fabricante.

Fig2. Teclado Matricial tipo Rígido

Fig3. Teclado Matricial tipo Membrana

El proceso del MCU para hacer la lectura de un teclado matricial consiste en realizar un barrido en las salidas, donde únicamente se activa una salida por vez, el método aplicado con las funciones que utilizaremos es un barrido de ceros(walking zeros), y hacer que la entrada o fila tenga un nivel logico bajo cuando se presiona un botón, para esto se requiere colocar resistencias pull-ups en las entradas[ROW] del teclado.
Considerando estos aspectos describiremos los procedimiento y funciones de la librería keypad que utilizaremos.

  • KBSetup(): Configura el Puerto donde se conectara el teclado, es importante mencionar que se debe editar las siguientes definiciones en la cabecera keypad.h
/* USER PORT DEFINITION */
#define KB_PORT PORTB //Puerto asociado
#define KB_TRIS TRISB
//Registro Tris asociado
/* END USER PORT DEFINITIOS */

La disposición del teclado con relación a los pines del puerto asignado, es que los cuatro bits de menor peso(salidas) corresponden a las columnas y los cuatro de mayor peso serán(entradas) las filas, recuerde que las filas necesitas de resistencias pull-ups.
  • KBScan(): Efectúa un ciclo con barrido de ceros en las columnas (walking zeros) para detectar si existe un botón presionado haciendo lectura de las entradas,  esta función retorna cero si no hay un botón presionado. En caso de presionar un botón del teclado la función retorna un código binario(res) que indica la posición(fila, columna) de la matriz. Considerando que un ciclo de barrido requiere pocos ciclos de reloj, es necesario llamar a la función continuamente hasta que el valor de retorno sea diferente a cero, una vez recibido el código del botón, también es importante considerar que el teclado deberá liberarse para evitar una validación continua, a continuación se muestra un ejemplo simple de como leer un botón y esperar hasta que el botón se libere.
res = KBScan(); //Ejecuta el barrido y guarda resultado
if(res != 0)
//Si el resultado, es diferente de 0
{  
/* Codigo para boton presionado */
    valor = KBGetValue(res);
//Convierte el codigo a numero
    while(KBScan()) {};
//Espera liberacion del boton
}
El código descrito anteriormente puede bloquear al programa, si el usuario mantiene presionado el botón de forma indefinida, por lo que se deben tomar medidas adicionales para evitar esta situación.
  • KBGetChar(n): Esta función se utiliza para convertir el código binario del teclado que retorna la función KBScan a un carácter de tipo ascii, si el código no corresponde con un carácter valido, la función devuelve '?'.
  • KBGetValue(n): A diferencia de la anterior función, este convierte el código binario del teclado en un numero decimal, si el código no corresponde con un numero valido, la función devuelve 0xFF.

La Pantalla LCD 20x2

La configuracion de pines para la pantalla LCD corresponde con la distribución que se muestra en la figura 4.

Fig4. Mapa de pines del LCD

GND:  Conexión a tierra 0V
VCC:  Alimentación a 5V
VEE:  Contraste 0V-5V
RS:   Selector modo comando o dato
R/W:  Selector Lectura o Escritura
EN:   Señal de habilitación
DBx:  Bus datos paralelo 8-bit/4-bit
Led+: Ánodo LED para luz de fondo
Led-: Cátodo LED para luz de fondo

Una ventaja de estos módulos LCD, es que cuentan con el modo de operación paralelo de cuatro bit (4-bit mode) que sumado a las lineas de control RS y EN, necesitaremos únicamente 6 pines del MCU para su uso. 

Las capacidades que tiene le modulo LCD van mas allá de lo que se utiliza en esta publicación, para nuestro caso el LCD lo utilizaremos solo para mostrar mensajes con los símbolos ASCII por defecto que posee en su memoria, es por esta razón que no se requieren operaciones de lectura y por lo tanto el pin de control R/W permanecerá en nivel bajo.

Para que nuestro MCU pueda mostrar mensajes en el LCD, se debe completar un proceso de inicialización de acuerdo a requerimientos de tiempo descritos en la hoja de datos del fabricante, considerando de forma general los tiempos máximos para la temporización las señales, la librería lcd que utilizaremos en nuestra implementación,  contiene una sección de código para definir estos valores de acuerdo a un modelo especifico.  A continuación se describen algunos de los procedimientos de mayor uso en nuestro programa.

  • LCD_Setup(): Este procedimiento configura el puerto asociado al los pines del LCD, donde es posible definir los cuatro pines de menor peso de cualquier puerto del MCU y de forma separadas los dos pines de control RS y EN. En segunda instancia este procedimiento lleva a cabo la inicialización del modulo LCD, siendo por defecto la siguiente configuracion:
1) Bus de datos en modo 4-bit y multi-linea;
2) Incremento de posición automático;
3) Muestra el cursor sin destellar;
4) Limpia la pantalla e inicializa el cursor.

La definición del puerto asociado a los pines del LCD y los valores de temporización se lleva a cabo modificando las siguientes lineas de código en la cabecera lcd.h. Por defecto los cuatro pines DB4 al DB7 del LCD corresponden con los primeros cuatro bits del puerto en el PIC, es posible cambiar la asignación a los últimos cuatro bits del puerto agregando la #define LCD_UPPER_DB en la cabecera.

/* USER PORT DEFINITION */
#define LCD_PORT PORTD  //Puerto asociado
#define LCD_TRIS TRISD 
//Registro Tris asociado
#define LCD_RS PORTDbits.RD4
//Pin RS Asociado
#define LCD_EN PORTDbits.RD5
//Pin EN Asociado
#define LCD_RS_TRIS TRISDbits.TRISD4
//Pin Tris RS
#define LCD_EN_TRIS TRISDbits.TRISD5
//Pin Tris EN
#ifndef _XTAL_FREQ
    #define _XTAL_FREQ 8000000
//Define Frecuencia
#endif  

/* END USER PORT DEFINITIONS */

  • LCD_WriteCMD(Cmd): Este procedimiento permite enviar un comando de la lista de definiciones al modulo LCD, siendo algunos ejemplos de uso, los siguientes:
LCD_WriteCmd(LCD_CLEAR); //Limpia la pantalla LCD
LCD_WriteCmd(LCD_DISPLAY & LCD_DCURSOROFF); //Sin cursor
LCD_WriteCmd(LCD_DISPLAY & LCD_DBLINKOFF); //Sin destello
LCD_WriteCmd(LCD_HOME); //Iniciliza el cursor
  • LCD_WriteMsg(*str): El procedimiento sirve para mostrar un mensaje de texto en la pantalla LCD, considerando que el mensaje iniciara en la posición que tiene el cursor. El contenido del mensaje(str) corresponde a un arreglo de caracteres con carácter nulo al final(null_string).
  • LCD_WriteChar(data): El procedimiento muestra en la pantalla LCD y en la posición del cursor, un único carácter val, el dato(data) debe formar parte de la tabla de caracteres ascii. 
  • LCD_WriteNum(num, padn): A diferencia del anterior procedimiento, este muestra en el LCD desde la posición del cursor un valor decimal entero de 16-bits(val), mismo que puede alinearse con una cantidad de ceros a la izquierda (padn).
  • LCD_GotoXY(col, row): El procedimiento permite posicionar el cursor en la pantalla LCD, considerando una distribución de filas y columnas donde las filas(row) representan la cantidad de lineas que generalmente son:
    • 0: Linea 1
    • 1: Linea 2
    • 2: Linea 3
    • 4: Linea 4
Las columnas este caso son las posiciones del cursor en cada linea, en el caso de una pantalla de 16x2, las columnas(col) serán de 0 al 15.

Esquema del Circuito

Diagrama de circuito elaborado en ISIS Proteus V8.0

Fig5. Esquema del circuito electrónico
Como se observa en la figura 5, el PIC16F887 tiene conectado seis lineas del PORTD[5:0] a los pines de la pantalla LCD, y ocho lineas del PORTB[7:0] al Teclado Matricial, las entradas del PORTB tendrán activadas las resistencias pull-up internas. Aclarar que el circuito de este diagrama tiene las conexiones mínimas para la simulación en Proteus, por esta razón no se muestran las conexiones de alimentación del PIC16F y el pin de contraste VEE.
Notara también que el teclado utilizado en el diagrama es una matriz 4x3, por lo tanto no hay columna 4, sin embargo esto no afectara el funcionamiento del programa, siempre que respete el orden correcto en las conexiones al puerto del PIC considerando la distribución de las figuras 2 y 3.
Para conocer si el programa esta en funcionamiento normal, se conecta un LED al pin RE2 mismo que destellara cada segundo. 

Programa del Microcontrolador

El programa que implementaremos para ensayar el Teclado Matricial y pantalla LCD tendrá como propósito, mostrar en la pantalla un Mensaje de solicitud de contraseña "PASSWORD", para que el usuario introduzca con el teclado una contraseña de cuatro dígitos y luego validar con el código "3022", y dependiendo de esta validación se mostrara un mensaje de "CORRECTO" o "ERROR". El proceso que sigue el programa se ilustra en el diagrama de la figura 6.

Fig6. Secuencia del programa
En la codificación del programa se considera que la frecuencia de operación de PIC16F887 es de 8MHz, con esta definición se configura el temporizador TMR0 para generar interrupciones de 1ms, esto lapso de tiempo es la base para llamar consecutivamente al procedimiento que recibirá y validara la contraseña. La siguiente entrada <TMR0 configuracion y uso>, muestra con mayor detalle el uso del modulo TMR0.

/*Programa Principal*/
void main(void)

{
    setupMCU();
//Configuracion del PIC
    LCDSetup();
//Inicia el modulo LCD
    KBSetup(); 
//Inicia el KeyPad
    while(1)
    {
        if(tick1ms)
//Se valida cada 1ms
        {
            tick1ms = 0;
//Limpia bandera
            taskLED(); 
//Tarea destello LED
            taskAPP(); 
//Tarea de la Aplicación
        }
    }
}
 

/*Tarea de la Aplicacion*/
void taskAPP(void)
{
    static uint8_t keycnt, state = 0;
//variables no volátiles
    static uint16_t cnt = 0;
//variable contador
    uint8_t res, value;
//variables temporales
    switch(state)
    {
        case 0:
//S0-Muestra mensaje
            LCDGotoXY(0,0);
//Posiciona el cursor linea 1
            LCDWriteMsg(" PASSWORD");
            LCDGotoXY(1,0);
//Posiciona el curso linea 2
            LCDWriteMsg("  [    ]");
            LCDGotoXY(1,3);
//Posiciona linea 2, col 3
            cnt = 0;
//inicia contador de ms
            keycnt = 0;
//Inicia contador de dígitos
            state = 1;
//carga estado 1
            break;
        case 1:
//S1-Lectura del teclado
            res = KBScan();
//Lectura del Teclado
            if(res)
//Si hay dato valido
            {
                if(cnt++ > 99)
//Repite para confirmación del botón
                {
                    value = KBGetChar(res);
//Recupera valor a char
                    LCDWriteChar(value);
//Escribe valor en pantalla
                    state = 2;
//Carga estado 2
                }
            } else cnt = 0;
            break;
        case 2:
//Contador de dígitos ingresados
            password[keycnt] = value;
//Agrega dígito al password 
            keycnt++;
//Incrementa contador de dígitos
            if(keycnt > 3)
//Mas de tres dígitos recibidos
            {
                password[keycnt] = 0;
                state = 4;
//Carga estado 4 para validar password
            }
            else state = 3;
//Carga estado 3 para recibir otro dígito
            break;
        case 3:
//Espera liberación del botón
            if(!KBScan()) state = 1;
//Lectura del siguiente dígito
            break;
        case 4:
//Compara contraseña
            LCDGotoXY(1,0);
//Posiciona Cursor linea 2
            res = (uint8_t) strcmp("3022", password);
//Compara
            if(res == 0) LCDWriteMsg(" Correcto");
//Código correcto
            else LCDWriteMsg("  Error ");
//Código incorrecto
            state = 5;
//Carga estado 5
            break;
        case 5:
//Genera retardo antes de reiniciar
            if(cnt++ > 1999)
//Espera hasta 2000ms
            {
                LCDWriteCMD(LCD_CLEAR);
//Limpia la pantalla
                state = 0;
//Carga estado 0
            }
            break;
    }
}

Funcionamiento

Una vez cargado el programa en el PIC16F, el circuito comienza a destellar el LED una vez por segundo, esto indica que el programa se encuentra en funcionamiento normal, así mismo la pantalla LCD mostrara el mensaje "PASSWORD", solicitando ingresar la contraseña, entonces puede ingresar los dígitos utilizando el teclado, en el instante que ingrese el cuarto dígito, se procederá a validar el código y mostrar en la pantalla si es "Correcto" o "Error", este mensaje se mantendrá un par se segundos para luego reiniciar el proceso, donde se pedirá nuevamente ingresar otra contraseña. La figura 7 muestra la implementación física del circuito.

Fig7. Implementacion del circuito
Los dígitos ingresados se muestran en la pantalla, y deben corresponder con el numero de botón del teclado, lo que nos indica que la conexión es correcta, caso contrario debe revisar la distribución de los pines.

Conclusiones

Se verifico correctamente el funcionamiento del Teclado Matricial y la pantalla LCD con el PIC16F887, completando así el propósito de esta publicación.
Aquí dejo los enlaces para que puedas descargar el proyecto MPLABX, mismo que se encuentran comprimidos con 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 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, 26 de febrero de 2020

Menu LCD con Encoder Rotativo

Menú LCD utilizando Encoder Rotativo


Muchas gracias por tu visita a este blog que trata acerca de la programación de micro-controladores PIC, en esta ocasión veremos como elaborar un pequeño menú de selección para una pantalla LCD utilizando un encoder rotativo para la navegación.

Se dará por entendido que ya se cuenta con un dominio medio avanzado de programación en lenguaje C y electrónica en general por lo que la presente entrada se enfocara directamente en el código de ejemplo sin profundizar los conceptos teóricos de base. La programación se realizara utilizando el compilador XC8 y el entorno de desarrollo MPLABX, ambos disponibles de forma gratuita en la pagina de microchip.
 
El código principal del proyecto main.c referencia a funciones del LCD que se encuentran en el archivo local lcd.c, todos los archivos mencionados se encuentran dentro de la carpeta del proyecto MPLABX y puedes descargarlo en el enlace que dejare al final.

1- ESQUEMA DE CIRCUITO



Se utilizara los pines RD0-RD3 para enviar datos en modo 4-bit a la pantalla LCD, los pines RD4(RS)-RD5(EN) para señal de control, el pin RW estará conectado de forma permanente a nivel bajo esto porque utilizaremos la pantalla únicamente para mostrar información. Adicional a esto el pin RD6 permite activar la luz de fondo mediante un transistor Bipolar.
El Encoder rotativo requiere el uso de resistencias pull-ups para establecer los niveles lógicos validos, por este motivo se emplearan las resistencias internas que posee el PORTB, además también se agregaran los capacitores de desacople para minimizar el efecto de reboote. La siguiente imagen muestra el montaje final utilizando la placa de pruebas B8P40.


El siguiente diagrama nos dará una idea general de como funciona el programa del microcontrolador, básicamente se implementara dentro del bucle principal procedimientos separados para manejar el destello de un LED cada medio segundo, la lectura del Pulsador del encoder y el manejo del menú en pantalla en función del encoder. Para conseguir que esto trabaje en un mismo bucle se aplicara el concepto de una maquina de estado finito para cada procedimiento con la siguiente designación: TaskLED1, TaskBUT1, TaskMENU1.


Como referencia de tiempo para cada repetición del bucle utilizaremos un retardo de una milésima de segundo, esto nos permitirá un control de tiempo para el resto del programa. También es importante mencionar que la gestión de tiempo en este ejemplo no posee un alto grado de precisión debido que el uso de __delay_ms(1) no incluye los ciclos de maquina adicionales para el manejo del bucle y llamadas internas dentro de este. Se puede mejorar la precisión utilizando una interrupción del temporizador sincronizada con una referencia externa RTC o GPS pero es un tema que no se considera en esta sección.

Ahora trataremos de describir el programa en varias secciones:

2- INICIO Y CONFIGURACIÓN

Las siguientes lineas corresponden al encabezado que incluye las librerías y definiciones utilizadas en el resto del programa, los comentarios de cada linea nos ayudaran a comprender mejor el funcionamiento. 

#include <xc.h>
#include <stdio.h>
#include <stdlib.h>
#define _XTAL_FREQ 4000000     //Definición del reloj interno para Tcy = 1uS
#define LED1pin PORTEbits.RE2 //Pin del LED1
#define BUT1pin PORTBbits.RB0 //Pulsador del Encoder
#define ENCApin PORTBbits.RB1 //Señal A(DATO) del Encoder
#define ENCBpin PORTBbits.RB2 //Señal B(CLK) de Enconder
#define KEYUP 1
#define KEYDOWN 2
#define LCD_PORT PORTD //Puerto de datos para LCD
#define LCD_TRIS TRISD    //Registro de configuración LCD
#define LCD_RS PORTDbits.RD4 //Pin de control RS del LCD
#define LCD_EN PORTDbits.RD5 //Pin de control EN del LCD
#define LCD_BACKLIGHT PORTDbits.RD6 //Control de luz de fondo LCD
#include "lcd.h"

La lista de variables a utilizar se declara de la siguiente manera: 

enum led {LEDOFF, LEDON} led1st; //Lista de estados para el LED
enum but {RELEASE, PRESSED} but1st; //Lista de estados para el BUT
enum men {NORMAL, AJUSTE, RETARDO} men1st; //Lista de estados MENU
volatile char keysense = 0; //Variable de captura para el encoder
char menusel = 0;      //Variable para guardar el indice actual del menú

char but1OK = false; //Variable de captura para el pulso BUT en RB0
char lcdtext[20], hora = 12, min = 0, sec = 0; //Variables para control de hora
unsigned int seccnt = 0; //Contador de segundos


El inicio de los puertos y variables antes del bucle del programa principal contiene las siguientes lineas:

ANSEL = 0; //Deshabilita pines analogicos AN0-AN7
ANSELH = 0; //Deshabilita pines analogicos AN8-AN13
TRISEbits.TRISE2 = 0; //Configura como salida pin LED1
LED1pin = 0; //Apaga el LED1
TRISB = 0xFF; //Configura como entrada los pines del PORTB
EnablePU(); //Activa las resistencias pull-up del PORTB
TRISD = 0; //Configura todo el PORTC como salida
PORTD = 0; //Coloca en nivel bajo todos los pines del PORTD
led1st = LEDOFF; //Estado inical del LED1
but1st = RELEASE; //Estado inicial del pulsador BUT1
men1st = NORMAL; //Estado inicial del Menú LCD
__delay_ms(1000);
LCDSetup(LINES2); //Inicia el modulo LCD a dos lineas
LCDPuts(" L.C.D. PIC16F "); //Escribe el mensaje en la primera linea
LCDGotoln(1);//Cambia el cursos a la segunda linea LCD
IOCBbits.IOCB1 = 1; //Habilita la interrupción por cambio RB1(DATO)
INTCONbits.RBIE = 1;//Habilita la interrupción por cambio de estado PORTB
INTCONbits.GIE = 1; //Habilita la interrupción global.


Se hará uso de la interrupción por cambio de estado unicamente en el pin RB1 que corresponde a la linea A(DAT) del encoder, entonces cada vez que se gire la perilla en cualquier sentido habrá un cambio de nivel en este pin que se atenderá inmediatamente en la rutina de interrupción para determinar el sentido de giro, en nuestro caso vamos definir cada sentido como KEYUP(hacia arriba) y KEYDOWN(hacia abajo), esta definición es utilizada para la navegación en el menú de opciones.


3- DESTELLO DEL LED

Aquí explicaremos como trabaja el procedimiento TaskLED1 que es llamado en el bucle del programa principal cada milésima de segundo, para esto observe la siguiente imagen que nos muestra un diagrama de transiciones para los dos posibles estados que tiene este LED.
En este caso el estado del LED depende unicamente de un contador cnt que se incremente con cada llamada(1ms), entonces cuando el valor de este contador es de 500 que en tiempo suma unos 0.5 segundos se efectuá un cambio de estado, logrando con esto un destello continuo del LED. Abajo puede observar el código de este procedimiento y se dará cuenta que puede modificar fácilmente estos tiempos, incluso puede crear un destello con tiempos de encendido y apagado de led asimétricos.


void TaskLED1()
{
   static unsigned int cnt = 0;
   switch(led1st)
   {
       case LEDOFF:
       {
          cnt = cnt + 1;
          if(cnt == 500)
          {
             cnt = 0;
             LED1pin = 1; //Activa el LED
             led1st = LEDON;
          }
       } break;
       case LEDON:
      {
         cnt = cnt + 1;
         if(cnt == 500)
         {
            cnt = 0;
            LED1pin = 0; //Apaga el LED
             led1st = LEDOFF;
          }
       } break;
   }
}



4- LECTURA DEL PULSADOR
  
Ahora explicaremos como trabaja el procedimiento TaskBUT1, sobre el mismo principio de llamar al procedimiento cada milésima de segundo, en este caso hay dos estados posibles, que el pulsador sea presionado(PRESSED) y que el pulsador este liberado(RELEASED), en este caso el cambio de estado va depender del valor en la entrada del pulsador BUT1 y los tiempos mínimos para cada estado se controlan con el contador cnt, la idea de esto es minimizar el efecto de rebote que posee un pulsador mecánico, además para la confirmación se emplea una variable bandera but1OK que se activara únicamente si el pulsador se presiona y se libera respetando los tiempos mínimos de control.

Observe el código del procedimiento y notara que puede hacer ajustes de tiempo para la confirmación, además la bandera but1OK es una variable global que se utilizara en otra sección del programa principal.

void TaskBUT1(void)
{
    static unsigned int cnt = 0;
    switch(but1st)
    {
        case RELEASE:
       {
           if(BUT1pin == 0)
           {
              cnt = cnt + 1;
             if(cnt > 200)
             {
                but1st = PRESSED;
                cnt = 0;
             }
           }
            else cnt = 0;
       } break;
       case PRESSED:
       {
          if(BUT1pin)
          {
             cnt = cnt + 1;
             if(cnt > 200)
             {
                 but1st = RELEASE;
                 cnt = 0;
                 but1OK = 1; //Confirma que el botón fue presionado y liberado
             }
          }
          else cnt = 0;
       } break;
   }
}


5- CREACIÓN DEL MENÚ LCD

Muy bien, ahora es momento de empezar definir nuestro menú con las opciones de selección, considero como un ejemplo básico un menú de dos niveles sin encabezado puesto que utilizaremos una pantalla de solo dos lineas, la siguiente imagen ilustra con mayor claridad la navegación que el usuario puede efectuar en este menú.




El estado de la pantalla trabajara en dos modos manejados por el programa principal, se tiene el modo normal en la que se mostrar una mensaje con información de la hora y el modo ajuste que permitirá la navegación por el menú. El pulsador del encoder representara la confirmación para cambiar de modo en el programa principal.

Entonces para tratar de sistematizar este menú a través de la programación en lenguaje C declararemos cada mensaje del menú como una constante en el siguiente orden. 


const char menu_000[] = "  MENÚ A    ";
const char menu_001[] = "  MENÚ B    ";
const char menu_002[] = "  SALIR        ";
const char menu_010[] = "  Opción 1    ";
const char menu_011[] = "  Opción 2    ";
const char menu_012[] = "  Opción 3    ";
const char menu_013[] = "  Atrás         ";
const char menu_020[] = "  Opción 4    ";
const char menu_021[] = "  Opción 5    ";
const char menu_022[] = "  Opción 6    ";
const char menu_023[] = "  Opción 7    ";
const char menu_024[] = "  Atrás          ";


Ahora definiremos una estructura para la navegación dentro del menú considerando las posibles opciones para el usuario.

typedef const struct
{
    const char *text;   //Mensaje
    char mpoints;       //Cantidad de items en el submenu
    char btUP;            //Navegación hacia arriba

    char btDOWN;      //Navegación hacia abajo
    char btENTER;    //Aceptar o ingresar a opción
    void (*fp) (void);   //Puntero a Función
} menustruc;


La ultima linea en la estructura representa un puntero de función que se llamara cuando la selección implique realizar una tarea particular. Establecemos un arreglo de la estructura final con los mensajes y valores de navegación utilizados en nuestro menú.

menustruc menú[] =
{
    {menú_000, 3, 0, 1, 3, 0},           //0 MENÚ A
    {menú_001, 3, 0, 2, 7, 0},           //1 MENÚ B
    {menú_002, 3, 1, 2, 2, 0},           //2 SALIR
    {menú_010, 4, 3, 4, 4, func1},    //3
    {menú_011, 4, 3, 5, 5, func2},    //4
    {menú_012, 4, 4, 6, 6, func3},    //5
    {menú_013, 4, 5, 6, 0, 0},           //6
    {menú_020, 5, 7, 8, 8, func4},    //7
    {menú_021, 5, 7, 9, 9, func5},    //8
    {menú_022, 5, 8, 10, 10, func6},//9
    {menú_023, 5, 9, 11, 11, func7},//10
    {menú_024, 5, 10, 11, 1, 0},       //11
};


Si tienes dudas hasta aquí, déjame decirte que estas por buen camino, así que tomate el tiempo necesario porque tratare de explicar mejor esta estructura; en cada linea deje un comentario con un valor que representa el índice de cada opción, este valor es almacenado en la variable global menusel, por ejemplo analicemos el índice 2 que corresponde a:  {menu_002, 3, 1, 2, 0, 0}

Según la estructura menustruc, el primer elemento es el mensaje const char *text que se inicializa con menu_002, esto en otras palabras es el mensaje "SALIR", luego se tiene el elemento mpoints que cuenta con 3 posibles opciones que son MENU A, MENU B y SALIR. El siguiente elemento de la estructura es btUP =1 que determina cual es el índice superior y btDOWN = 2 el índice inferior estos valores limitan el desplazamiento del cursor dentro del menú de opciones. finalmente el elemento btENTER = 0 indica el índice seleccionado en caso de presionar el pulsador del encoder, la acción asociada a esta selección deberá permitir salir del modo Ajuste. 
La siguiente imagen le ayudara a entender mejor como se estructura este menú y también se dará cuenta que podría fácilmente agregar opciones y mas niveles.



El procedimiento ShowMenu(), se encarga de manejar la navegación del menú dentro del programa y la mista debe actualizarse cada vez que ocurra un cambio en el encoder. el código se elaboro en base a un ejemplo que encontré en la red hace mucho tiempo, por esta razón no pode ubicar la referencia para dejar el respectivo enlace.

void ShowMenu()
{
    uint8_t lcnt = 0, from = 0, till = 0, temp = 0;
    while(till <= menusel)
        till += menu[till].mpoints;      //Índice de posición máxima
    from = till - menu[menusel].mpoints; //Índice de posición mínima
    till --;
    temp = from;
    if(menusel >= (from + 1) && (menusel <= (till-1))) //Si requiere desplazar
    {  
        from = menusel - 1;
        till = from + 1;
        for(from; from <= till; from ++)
        {
            LCDGotoln(lcnt);
            LCDPuts(menu[from].text);
            lcnt++;
        }
        LCDGotoln(1); //Coloca el curso al principio de la segunda linea
        LCDPutc(0x7E); //Escribe el caracter ->
    }
    else
    {
        if(menusel < (from + 1))
        {
            till = from  + 1;
            for (from; from <= till; from ++)
            {
                LCDGotoln(lcnt);
                LCDPuts(menu[from].text);
                lcnt++;
            }
            LCDGotoln(menusel - temp);
            LCDPutc(0x7E);
        }
        if(menusel == till)
        {
            from = till - 1;
            for (from; from <= till; from ++)
            {
                LCDGotoln(lcnt);
                LCDPuts(menu[from].text);
                lcnt++;
            }
            LCDGotoln(1);
            LCDPutc(0x7E);
        }
    }
}


6- MENÚ Y LECTURA DE ENCODER

El procedimiento que controla la navegación del menú mediante el enconder se llama TaskMENU1, que cuenta con tres estados que son dependientes de la variable cnt y la acción sobre el encoder.

El estado NORMAL tiene como objetivo mostrar en la pantalla el tiempo en formato hora-minuto-segundo, el tiempo de actualización esta condicionado por cnt para medio segundo. La única condición que determina un cambio de estado es que la bandera but1OK se active, esto nos indica que se presiono y libero el pulsador del encoder para cambiar al estado AJUSTE.

El estado AJUSTE nos muestra el menú llamando al procedimiento ShowMenu, y su actualización va depender únicamente de un cambio en el encoder, este cambio puede ser: Aceptar la opción actual but1OK, desplazar arriba KeyUP o desplazar abajo KeyDOWN; El desplazamiento es detectado por el cambio de estado en el pin RB1, siendo la rutina de interrupción la responsable de determinar el sentido(variable keysense). Cada vez que se detecte un cambio en el encoder el estado cambiara a RETARDO.

El estado RETARDO cumple la tarea de mantener un tiempo mínimo de espera para un nuevo cambio en el encoder, esto permite en cierta manera ajustar la sensibilidad de cambio, otra tarea que se realiza es rehabilitar la interrupción por cambio de estado para un nuevo evento; Finalmente la activación de la bandera but1OK mientras el índice del menú es igual a 2 corresponde a seleccionar la opción SALIR, logrando con esto retornar al estado NORMAL para mostrar el tiempo nuevamente. Esta breve explicación se puede resumir en el siguiente diagrama de estados
 



void TaskMENU1()
{
   static unsigned int cnt = 0;
   switch(men1st)
   {
     case NORMAL:
    {
      cnt ++;
       if(cnt > 499)
       {
         LCDGotoln(1);
         sprintf(lcdtext, " [%02u:%02u:%02u]", hora, min, sec);
         LCDPuts(lcdtext);
         cnt = 0;
       }
       if(but1OK == 1)
      {
        but1OK = 0;
        men1st = AJUSTE;
        LCDSet(CLEAR);
        ShowMenu();
        cnt = 0;
     }
   } break;
   case AJUSTE:
  {
     if(keysense || but1OK)
    {
       if(keysense == KEYUP) menusel = menu[menusel].btUP;
       if(keysense == KEYDOWN) menusel = menu[menusel].btDOWN;
       if(but1OK)
       {
          if(menu[menusel].fp != 0) //Si hay un puntero valido en la seleccion
          menu[menusel].fp(); //Ejecuta la funcion asociada al puntero
          else
          menusel = menu[menusel].btENTER; //Mantiene la posición
       }
       cnt = 0;
       men1st = RETARDO;
       ShowMenu(); //Actualiza el menu en pantalla
     }
   } break;
   case RETARDO:
   {
      cnt ++;
      if(cnt > 100)
     {
        keysense = PORTB;
        INTCONbits.RBIF = 0;
       INTCONbits.RBIE = 1;
       keysense = 0;
       if(but1OK)
      {
         but1OK = 0;
         if(menusel == 2) //Opción de salir
        { 
           LCDSet(CLEAR);
           LCDPuts(" L.C.D. PIC16F ");
           LCDGotoln(1);
           men1st = NORMAL;
           cnt = 0;
           break;
        }
     }
     men1st = AJUSTE;
    }
   } break;
  }

} 

Las siguientes lineas corresponden a la rutina de interrupción del programa, note que la ejecución de RBIE = 0 deshabilita la re-entrada hasta que el evento actual sea atendido por el programa principal, es importante adicionar condensadores de desacople para una mejor respuesta del encoder.

void interrupt isr()
{
    if(INTCONbits.RBIF && INTCONbits.RBIE)
    {
       if(ENCApin) //if DAT = 1
      {
         if(ENCBpin) keysense = KEYUP;
         else keysense = KEYDOWN;
       }
       else //if(DAT = 0)
       {
          if(ENCBpin) keysense = KEYDOWN;
          else keysense = KEYUP;
       }
       INTCONbits.RBIE = 0; //Deshabilita la interrupción.
       INTCONbits.RBIF = 0;
    }
}


7- FUNCIONAMIENTO

Dentro del programa principal, la estructura del bucle indefinido es muy simple de comprender gracias a que el resto de los procedimiento son llamados a intervalos continuos como maquinas de estado finito, El único proceso efectuado en el bucle es el de actualizar las variables del tiempo que son la hora, minuto y segundo. Observe la siguiente imagen:
 

Una vez programado el PIC, como pantalla de inicio no mostrara el tiempo transcurrido. Observe la imagen
 

Aquí les dejo el enlace para la descarga del proyecto MPLABX, para lo cual utilice la version 2.1 del compilador XC8.




8- CONCLUSIONES


Como habrán visto la implementación de este menú no es difícil, pero el ejemplo que se describe en esta entrada no esta adaptado a ninguna situación real y en este punto hay que ser claros en decir que el diseño de un menú responde a una necesidad particular en cada aplicación, esto supone que el programador necesitara modificar la estructura y considerar condiciones adicionales dentro de la navegación. Un procedimiento que no se ha descrito a profundidad en este blog pero que es clave en la personalización del menú es ShowMenu, basicamente en sus lineas se pueden crear ventanas, encabezados, desplazamientos, etc. Después veré trabajar en otro ejemplo utilizando otra configuración para un nuevo menú.

Saludos.
Pablo Zarate Arancibia
Ingeniero Electrónico
pablinzte@gmail.com

miércoles, 5 de junio de 2019

I2C Utilizar un LCD con PCF8574

Modulo PCF8574x con el PIC16F
Fig1. Modulo PCF8574 y LCD

Antes que nada quiero agradecer tu visita a este blog relacionado con la programación de micro-controladores PIC, En esta ocasión veremos como utilizar un circuito integrado (CI) de expansión bastante practico y económico para conectar un modulo LCD con nuestro microcontrolador (MCU), utilizando únicamente dos lineas de comunicación gracias al protocolo serial I2C y el CI PCF8574x. El objetivo de esta sección es enviar mensajes a la pantalla LCD utilizando el protocolo de comunicación I2C entre el PIC16F887 y el PCF8574x.
 
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. Al finalizar la sección les dejare el enlace para descargar la carpeta del proyecto que contiene todos los archivos citados en la presente publicación, también te recomiendo revisar los siguientes enlaces donde se explicar con mayor detalle el <Uso del TMRO> y la <Comunicación I2C>

Modulo PCF8574x con el PIC16F
 
El PC8574x es básicamente un modulo de conversion serie a paralelo, utilizado con el objetivo de expandir los puertos de entrada y salida de un sistema electrónico, como es el caso de un MCU que no dispone de puertos suficientes.
La comunicación con el PCF8574x se establece utilizando el conocido protocolo I2C, el caso de los microcontroladores PIC de gama media, estos disponen de un modulo de comunicación serial síncrono denominado SSP/MSSP,  que facilitan la implementación los protocolos SPI(Serial Peripheral Interface) e I2C(Inter-Integrated Circuit). En la codificación de nuestro programa utilizaremos la librería pcflcd donde se incluyen los procedimientos I2C necesarios para comunicarnos con el chip PCF8754x.

Paso 1. Sobre el Módulo PCF8574x.
I2C es un protocolo serial desarrollado por Phillips Semiconductors en la década de los 80, y fue concebido principalmente para comunicar dispositivos que están montados en un mismo sistema o circuito impreso.

Fig2. Pinout del PC8574x

El chip PCF8574 fabricado por Texas Instrument es un expansor paralelo de 8 bits controlado por I2C que opera a una velocidad estándar de 100KHz, diseñados para proveer monitoreo y control serial de forma fácil y económica. Existen dos variantes de este chip que son el PCF8574 y PCF8574A que se diferencian únicamente por el rango o mapa de dirección que pueden utilizar conforme a los valores lógicos en sus pines A2:A0.
 
Fig3. Tabla de direccionamiento PCF8574

Una gran ventaja de este protocolo es que establece una interfaz bidireccional maestro esclavo de hasta 128 dispositivos, aunque en la practica cada dispositivo limita su rango de asignación a un determinado mapa que puede ser configurado de forma externa o mediante instrucciones sobre el mismo protocolo.

Fig4. Conexión del Bus I2C
 
Implementar el bus I2C con el chip PCF es bastante simple, si observa la figura 4, solo se requiere utilizar resistencias pull-up por cada pin del microcontrolador, establecer la dirección de cada dispositivo conectado y su respectiva alimentación.

La figura 5, muestra el esquema de circuito necesario para la conexión del PCF8574A con las ocho lineas requeridas por el modulo LCD y las dos lineas de comunicación I2C del MCU.
 
Fig5. Esquema de conexión PCF8574A
Algo interesante es que este circuito esta disponible como un modulo genérico producido para aplicaciones de prototipo rápido, y que goza de bastante popularidad por su bajo costo económico($us. 3), incluso planteando comprar los elementos por separados no se justifica el precio por el trabajo y tiempo necesario para el montaje. Salvo que se trate de un producto final.

Fig6. Modulo PCF8574x
 
Por defecto este modulo tiene las lineas A2:A0 con nivel lógico alto que define una dirección de 27h (PCF8574) y 3Fh(PCF8574A); Si requiere agregar mas dispositivos o modificar la dirección necesitara soldar o conectar las siguientes lineas o pads en la parte posterior del modulo, de acuerdo a la figura 7.

Fig7. Pads para direccionamiento

Otro detalle es que el modulo ya cuenta con las resistencias pull-up requeridas por la interfaz y no sera necesario agregar estas resistencias incluso si utiliza otros dispositivos o sensores I2C.


Paso 2. Conectar el Modulo al PIC16F.
Fig8. Conexión al PIC16F

Solo necesitara identificar y conectar las cuatro lineas que posee el modulo, dos corresponden a la alimentación(5V/GND), y dos para la comunicación SDA(datos) y SCL(reloj). Muchas pantallas LCD cuentan con una luz de retroiluminacion(Backlight) que puede ser controlador a través de la interfaz siempre que coloque un puente(jumper) en el conector J2. 
 
El modulo también posee un potenciómetro que permite ajustar el contraste que la pantalla, deberá establecer un valor adecuado al momento de ensayar el programa.


Paso 3. Programación y envió de mensajes.

A fin de facilitar la rápida implementación del modulo en nuestra aplicación, se crearon los siguientes procedimientos y funciones incluidas en la cabecera pcdlcd.h. Debe revisar este archivo para efectuar algunas configuraciones necesarias antes de proceder a llamar cualquier procedimiento o función de esta librería.

Recuerde que el campo de dirección definido en el programa como PCFADDR dependerá de los valores lógicos que tienen los pines A2:A0 del chip PCF8574, estos pines por defecto tiene nivel logico 1, por lo tanto la dirección resultando sera de acuerdo al siguiente formato I2C.
 1. Para un Modulo PCF8574A PCFADDR=7Eh
 

 2. Para un Modulo PCF8574 PCFADDR=4Eh

Ahora mostraremos la lista de los procedimientos que podemos utilizar para enviar mensajes a nuestra pantalla LCD.
  • PCFSetupLCD(): Este procedimiento lleva a cabo la inicialización del modulo LCD, siendo por defecto la siguiente configuracion:
    1) Bus de datos en modo 4-bit y multi-linea;
    2) Incremento de posición automático;
    3) Muestra el cursor sin destellar;
    4) Limpia la pantalla e inicializa el cursor.
    La definición del puerto asociado a los pines del LCD y los valores de temporización se lleva a cabo modificando las siguientes lineas de código en la cabecera pcflcd.h.

    /* USER PORT DEFINITION */
    #define PCFADDR 0x7E //PCF8574A
    #define _XTAL_FREQ 8000000

    /* END USER PORT DEFINITIONS */

  • PCF_WriteCmd(): Este procedimiento permite enviar un comando al LCD, siendo algunos ejemplos de uso, los siguientes:
PCF_WriteCmd(LCD_CLEAR); //Limpia la pantalla LCD
PCF_WriteCmd(LCD_DISPLAY & LCD_DCURSOROFF); //Sin cursor
PCF_WriteCmd(LCD_DISPLAY & LCD_DBLINKOFF); //Sin destello
PCF_WriteCmd(LCD_FUNCTIONSET & LCD_FSET4BIT & FSETLINE1); //Una linea
PCF_WriteCmd(LCD_HOME); //Iniciliza el cursor

  • PCF_WriteMsg(*p): Este procedimiento sirve mostrar un mensaje en la pantalla LCD, se entiende que el mensaje iniciara en la posición actual que tiene el cursor. 
  • PCF_WriteChar(val): El procedimiento muestra en la pantalla LCD, el carácter val, se debe considerar la posición que tiene el cursor antes de llamar a este procedimiento.
  • PCF_GotoXY(x,y): El procedimiento permite posicionar el cursor en la pantalla, siendo x,y la combinación fila, columna de la pantalla.
  • PCFSetLED(): Permite encender la luz de fondo de la pantalla.
  • PCFClearLED(): Permite apagar la luz de fondo de la pantalla
Paso 4. Prueba y Simulación.
Ahora escribiremos un pequeño programa para poner en practica y demostrar el uso de una pantalla LCD donde utilizaremos los procedimientos previamente descritos, el programa se codifica considerando que la frecuencia del oscilador interno del PIC es de 8MHz.

El siguiente código es parte del programa que muestra un mensaje inicial en la primera linea y el valor de un contador de segundos en la segunda linea, adicionalmente se tiene un LED conectado al pin RE2 con el fin de generar un destello cada segundo, el destello es indicador de que el programa esta corriendo de manera regular. Aclarar que el código que se muestra solo corresponde con la funcionalidad básica del programa, por lo tanto te recomiendo que descargues el proyecto MPLABx y revises los archivos donde se encuentra el código completo.

#include <xc.h>
#include <stdint.h>
#include <stdio.h>
#define LEDpin PORTEbits.RE2
volatile uint8_t tick1ms = 0;
uint16_t cntms = 0;
#include "i2c.h"
#include "pcflcd.h"
char msg[8];
//Char array

void main(void)
{
    setupMCU();
//Inicializa el Microcontrolador
    PCFSetupLCD();
//Inicia el LCD
    PCFSetLED();  
//Enciende la luz de fondo
    PCFGotoXY(0,2);
//Coloca el cursor en la posición 2 de la fila 0
    PCFWriteMsg("** U.E.B **");
//Muestra el mensaje
    PCFWriteCMD(LCD_DISPLAY & LCD_DBLINKOFF);
//Muestra el cursor
    while(1)
    {
        if(tick1ms)
//Validacion en cada ms
        {
            tick1ms = 0;
            taskLED();
//Ajecuta la tarea para destellar el LED
            taskAPP();
//Muestra el contador de segundos
        }
    }
}

void taskAPP(void)
{
    static uint16_t cnt = 0;
    static uint8_t seg = 0;
    if(cnt++ > 999)
//Se valida cada segundo.
    {
        cnt = 0;
        seg = seg + 1;
//Incrementa el contador de segundos
        if(seg > 59) seg = 0;
//Reinicia el contador de segundos
        PCFGotoXY(1,0);
//Coloca el cursor en la posición 0 de la fila 2
        sprintf(msg, "SEG:%02u", seg);
//Cadena personalizada
        PCFWriteMsg(msg);
//Muestra la cadena con valores del segundo   
    }
} 


Fig9. Montaje del circuito PIC16F

Paso 5. Conclusiones y Recomendaciones.
Luego de hacer la demostración del programa podemos concluir que podemos implementar fácilmente este modulo I2C para ahorrarnos entre 4 y 6 lineas o pines del PIC. Si bien la librería solo contiene procedimientos básicos para mostrar mensajes, con un mayor conocimiento de las instrucciones del controlador LCD es posible realizar modificaciones que permitan efectuar operaciones menos frecuentes como ser desplazamientos y generación de caracteres personalizados.
 
Este es el enlace para descargar el proyecto MPLABX  <PCFLCDP16F>
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 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