lunes, 27 de abril de 2015

Como programar un display LCD de 16x2 con el PICAXE 8M2

La pantalla LCD que usé en este proyecto es de las más económicas y de las que no tienen luz de fondo, pero el funcionamiento es básicamente el mismo.

Primero voy a mostrar cómo imprimir mensajes en la LCD de manera manual; el objetivo de esto es para saber cómo se envían los datos a la LCD y tú mismo puedas desarrollar la plantilla de código que pueda manejar una LCD. Después voy a utilizar el PICAXE 8M2 para imprimir los mensajes.

La LCD puede ser manejada en formato de 8 o 4 bits. Para los humanos es más fácil manejar el formato de 8 bits que el de 4 bits, pero para un microcontrolador es lo mismo. En el formato de 4 bits se utilizan menos pines de salida, por lo tanto un micro normalmente maneja la LCD en formato de 4 bits. A pesar de esto algunas plantillas de código para manejar LCDs utilizan el formato de 8 bits (como Arduino y PIC) pero para el caso de PICAXE lo vamos a manejar con tan sólo 3 salidas del microcontrolador, esto nos ayuda bastante cuando en nuestro proyecto tenemos muy pocas salidas disponibles.

El circuito para manejar la LCD de forma manual es el siguiente:



NOTA: La parte del circuito para enviar el pulso "habilitar" (S9) también puede ser un flip-flop SR u otro que ustedes conozcan. Yo lo hice con un 555 configurado en monoestable. El objetivo es mandar un único pulso sin rebote mecánico.

La tabla de comandos que la LCD entiende es la siguiente:



En la tabla se indica con un * los valores de inicio de la LCD aunque puede variar un poco.


Formato de 8 bits

Vamos a ver cómo se inicia una LCD en formato de 8 bits:

  • Primero poner en cero el pin RS de la LCD (para enviar comandos).
  • Después ingresar los siguientes números en hexadecimal. Tener en cuenta que después de cada número se debe enviar un pulso al pin de "enable" de la LCD:
  • 30
  • 38
  • 0F
  • 84 (Enviar este comando sólo si el cursor no aparece en la primer celda)

Con estos comando el cursor debe estar parpadeando en la primer celda visible. Si no es así verificar que la alimentación sea la correcta (5 volts y algunas LCD manejan 3 volts), que todo esté bien conectado y por último revisar que el contraste sea el correcto.

Se puede jugar con los comandos para realizar varias acciones por ejemplo: que el cursor se desplace hacia la izquierda, que no sea visible el cursor, desplazar la ventana de visualización de la LCD, limpiar pantalla, etc.

Ahora para ingresar un caracter en formato de 8 bits ingresamos el código hexadecimal según la siguiente tabla de caracteres ASCII:



Existen celdas vacías en la tabla, quiere decir que los caracteres de esas celdas varían según el fabricante de las LCDs. Llena tu propia tabla con los caracteres que imprime tu LCD.

Observa que en la primer columna dice CGRAM (generador de caracteres de la memoria RAM) y hay un total de 16 direcciones (00 - 0F) para generar caracteres diferentes a los de la tabla ASCII.

Para generar tu propio caracter, primero dibújalo en un cuaderno haciendo una tabla de 8x8 cuadros, las primeras tres columnas no se imprimen en la LCD puesto que cada matriz donde se imprimen caracteres son de 5x7 y 5x8 (columnas x filas). De la tabla de 8x8 que dibujaste genera el código hexadecimal para cada fila y ahora introduce lo siguiente:

  • Con el cursor en la posición de inicio visible ajusta el pin de RS en 1 lógico (para imprimir un caracter).
  • Ahora imprime el primer caracter de la CGRAM, para esto ajusta el 00 y envía el pulso de enable (se imprimirá un caracter que es basura), esto sólo es para que veas como cambia el contenido del caracter.
  • Después cambia al modo comando (RS = 0) e ingresa la primera dirección de CGRAM que es con el comando 40 (vea tabla de comandos).
  • Nuevamente cambia al modo caracter (RS = 1) y ahora introduce el código de cada fila que obtuviste de tu propio caracter seguido de un pulso de enable.
  • Cuando envíes el último caracter cambia al modo comando y envía el comando limpiar pantalla (01).

Otra forma de generar un caracter más fácil es utilizando la herramienta "LCD CGRAM Wizard" del software PICAXE editor porque es más rápido dibujar ahí y te genera el código hexadecimal. Además de entrega el código para que envíes la información de forma serial a un chip especial.



Ya tienes tu primer caracter generado en la memoria RAM, recuerda que tienes 15 direcciones de memoria más para almacenar otros caracteres. Además una vez que la LCD se desconecte de la alimentación la memoria RAM se borra y por lo tanto se pierden los caracteres ya generados.


Formato de 4 bits


En el caso del formato en 4 bits sólo se usan los 4 bits más significativos (b4 - b7) para enviar los datos y los comandos. Este formato es más tardado y puede ser confuso para los humanos, pero para un microcontrolador es más eficiente porque requiere de menos pines de salida.


Entonces vamos a ver cómo se inicia la LCD en formato de 4 bits:

  • Primero pasar al modo comando (RS = 0)
  • Después conectar los bits menos significativos (b0 - b3) a 0 lógico.
  • Ahora ingresar los siguientes comandos seguidos de un pulso enable cada uno:
  • 2 (En realidad se envía el 20 porque hasta ahora la LCD está trabajando en el formato 8 bits)
  • 2
  • 8
  • 0
  • F
  • 8 (Enviar estos dos comandos sólo si el cursor no aparece en la primer celda)
  • 4

Para imprimir un caracter pasamos al modo caracter (RS = 1) y si queremos imprimir el caracter "A" entonces introducir el códígo hexadecimal 41 pero primero se envía el 4 y después el 1.

Lo mismo ocurre para generar un caracter en la memoria RAM.



Espero que me haya explicado bien aún así les comparto un artículo que lo explica mucho mejor que yo.




Manejar una LCD usando el microcontrolador PICAXE 8M2

En el manual número de 3 de PICAXE, mencionan que sólo hay tres maneras de programar una LCD. En las dos primeras se necesita un chip especial para recibir los datos de manera serial desde el microcontolador y en la tercera opción es conexión directa, pero si no cuentas con este tipo de chip especial, en ese caso la interfaz que puedes utilizar es una derivación de la conexión directa. El microcontrolador PICAXE 8M2 sólo tiene 4 salidas y en la conexión directa se requieren de 6 salidas como mínimo para programar la LCD (4 bits de datos, 1 bit de RS y 1 bit para enable) pero utilizando un registro de corrimiento serial-paralelo de 8 bits como el 74LS164 ó el 74HC164 sólo necesitamos 3 salidas de nuestro microcontrolador. Además de que su precio es muy accesible, va de $7 a $10 aproximadamente (pesos mexicanos), ni siquiera un dólar de EEUU.

El diagrama del circuito es el siguiente:

Una salida del microcontrolador es para los datos, otra para la entrada de reloj del registro de corrimiento y la tercera para el pulso de enable de la LCD, El bit de selección del RS es una de las salidas del registro de corrimiento.

La siguiente plantilla de código sirve para este tipo de conexión y para una frecuencia de trabajo de 4 MHz:

;***********************************************************************************************
;    INICIALIZACION DE VARIABLES
;***********************************************************************************************
EEPROM 0,("PICAXE 8M2+")
EEPROM 16,("w4 = +")
symbol clock = C.4
symbol enable = C.2
symbol dato = C.1
low clock
low enable
low dato
;***********************************************************************************************
;    PROGRAMA PRINCIPAL
;***********************************************************************************************
gosub ini_lcd
let w4=987
bintoascii w4,b10,b11,b12,b13,b14 ; Separa la variable w4 en cinco variables
gosub imprime
end
;***********************************************************************************************
;    SUBRUTINAS
;***********************************************************************************************
imprime:
let b0=b10
gosub numero
let b0=b11
gosub numero
let b0=b12
gosub numero
let b0=b13
gosub numero
let b0=b14
gosub numero
return

numero:
let b3=1
let b5=0
num:
high dato ;RS = 1
pulsout clock,1
for b4=0 to 3
let b2 = b0*b3 & %10000000 'Realiza un corrimiento a la izquierda y aplica una máscara
let b3=b3*2
if b2 = 128 then
high dato
pulsout clock,1
else
low dato
pulsout clock,1
endif
next b4
pulsout enable,1
pause 10
inc b5
if b5 = 2 then ' Se puede sustituir esta parte por un ciclo for anidado con el anterior
return ' pero parece que a veces no funciona bien
else
goto num
endif

ini_lcd:
pause 100
pulsout clock,1 'RS = 0
pulsout clock,1
pulsout clock,1
high dato
pulsout clock,1
low dato
pulsout clock,1
pulsout enable,1
pause 10
let b6=$28
gosub comando
let b6=$0F
gosub comando
let b6=$01
gosub comando
let b6=$84
gosub comando
let b1=0
gosub mensaje
let b6=$C4
gosub comando
let b1=16
gosub mensaje
return

comando:
let b3=1
let b5=0
cmd:
low dato ;RS = 0
pulsout clock,1
for b4=0 to 3
let b2 = b6*b3 & %10000000
let b3=b3*2
if b2 = 128 then
high dato
pulsout clock,1
else
low dato
pulsout clock,1
endif
next b4
pulsout enable,1
pause 10
inc b5
if b5 = 2 then
return
else
goto cmd
endif

mensaje:
read b1,b0
if b0 = 43 then
return
endif
let b3=1
let b5=0
men:
high dato ;RS = 1
pulsout clock,1
for b4=0 to 3
let b2 = b0*b3 & %10000000
let b3=b3*2
if b2 = 128 then
high dato
pulsout clock,1
else
low dato
pulsout clock,1
endif
next b4
pulsout enable,1
pause 10
inc b5
if b5 = 2 then
inc b1
goto mensaje
else
goto men
endif

NOTAS:

  • Esta plantilla sólo inicia la LCD y es capaz de enviar comandos y mensajes pero no tiene la función para generar caracteres en la memoria RAM, eso se los dejo a ustedes ;).
  • Cuando se maneja la LCD con un microcontrolador se debe tener en cuenta la frecuencia de trabajo del microcontrolador, porque se requiere de un cierto tiempo de espera entre los pulsos, si el microcontrolador trabaja a una frecuencia alta y la LCD no responde correctamente, seguramente es por los tiempos entre cada instrucción.

La relación entre pulsos y tiempo es la siguiente:

Aquí el vídeo



Agradecimentos:
Ing. Juan Manuel Cobilt Catana
Ing. Edgar R. Calderón Díaz
Profesores del IPN de la ESIME Zacatenco de la carrera de ingeniería en comunicaciones y electrónica, sin ellos no habría podido realizar este pequeño trabajo.

viernes, 18 de abril de 2014

Contador de eventos hasta 999,999 con interrupciones

Esta es la tercera versión del contador de eventos con el picaxe18M2+, pero esta vez usando interrupciones. Cabe resaltar varios puntos importantes:
*Las interrupciones están por default en el puerto C (revisen el manual para más detalles).
*No se pueden usar interrupciones con multitareas.
*La rutina de interrupción debe de tener el nombre de "interrupt:".
*Asegurarse de habilitar las interrupciones antes del programa principal.
*Los puertos de interrupción son muy pocos, en este  microcontrolador me parece que tiene solo dos (el C.0 y el C.2), pero verifiquen ustedes mismos.
Por esto mismo modifiqué el programa y el diagrama en algunas cosas:

Diagrama:



Programa:
 ;***********************************************************************************************
;    CONFIGURACION DE LOS PUERTOS
;***********************************************************************************************
let dirsB = %11111111        ;Puerto B como salidas digitales
let dirsC = %11001110        ;C.0, C.4 y C.5 como entradas digitales
;***********************************************************************************************
;    INICIALIZACION DE VARIABLES
;***********************************************************************************************
let b1=0
let b2=0
let b3=0
let b4=0
let b5=0
let b6=0
;***********************************************************************************************
;    VECTOR DE INTERRUPCION
;***********************************************************************************************
setint $00000001,00000001
;***********************************************************************************************
;    PROGRAMA PRINCIPAL
;***********************************************************************************************
main:
let pinsB=b6
pulsout B.7,100            ;Se activa solo el transistor de las centenas de millar
let pinsB=b5
pulsout C.1,100            ;Se activa solo el transistor de las decenas de millar
let pinsB=b4
pulsout C.2,100            ;Se activa solo el transistor de las unidades de millar
let pinsB=b3
pulsout C.3,100            ;Se activa solo el transistor de las centenas
let pinsB=b2
pulsout C.6,100            ;Se activa solo el transistor de las decenas
let pinsB=b1
pulsout C.7,100            ;Se activa solo el transistor de las unidades
goto main

;***********************************************************************************************
;    RUTINA DE INTERRUPCION
;***********************************************************************************************
interrupt:
let pinsB=b6
pulsout B.7,100            ;Se activa solo el transistor de las centenas de millar
let pinsB=b5
pulsout C.1,100            ;Se activa solo el transistor de las decenas de millar
let pinsB=b4
pulsout C.2,100            ;Se activa solo el transistor de las unidades de millar
let pinsB=b3
pulsout C.3,100            ;Se activa solo el transistor de las centenas
let pinsB=b2
pulsout C.6,100            ;Se activa solo el transistor de las decenas
let pinsB=b1
pulsout C.7,100            ;Se activa solo el transistor de las unidades
if pinC.0 = 1 then interrupt
setint $00000001,00000001    ;Activamos una vez más la interrupción  
inc b1                ; Se incrementa el contador de unidades en 1
if b1=10 then
    let b1=0
    inc b2
endif
if b2>9 then
    let b2=0
    inc b3
endif
if b3>9 then
    let b3=0
    inc b4
endif
if b4>9 then
    let b4=0
    inc b5
endif
if b5>9 then
    let b5=0
    inc b6
endif
if b6>9 then
    let b6=0
endif
return

Video:


jueves, 17 de abril de 2014

Contador de eventos hasta 999,999 usando multitareas PICAXE18M2+

Con la actual generación de picaxe (M2 y X2) algunos chips como el 18M2+ tienen más capacidades en cada pin. El picaxe18M2+ ahora viene con más salidas y entradas digitales, por lo que podemos controlar más cosas con un solo chip. A diferencia del contador anterior, éste utiliza la nueva función de multitareas. Gracias a esta función podemos realizar varias tareas (hasta 8 con este chip) al "mismo tiempo" como si estuvieran 8 chips en un sólo encapsulado. Para este contador use sólo 3 tareas paralelas. Use 6 displays por que ya no caben más en una protoboard pero se pueden agregar hasta el número de salidas disponibles (menos las 4 que van al 74LS48) que tenga en el microcontrolador. Algo importante de aclarar es que en el anterior contador utilicé resistores de 390 ohms en cada salida del 74LS48 pero al revisar la ficha técnica, leí que no necesita resistores externos y efectivamente los displays que use no los necesitaron porque se ven bien. Pero con algunos de mis compañeros discutimos bastante el tema y observamos que los displays que son más oscuros o casi negros eran los que menos se veían a pesar de llevar resistores (los que yo uso son displays que son muy claros, en tonalidades de gris), y creemos que para que se vean mejor sólo necesitan más corriente y por lo tanto necesitan un 74HC48 y otro transistor con más potencia. Parece que no tiene nada que ver pero ustedes saquen sus propias conclusiones.

Material:
*1 Microcontrolador PICAXE18M2+
*1 IC 74LS48
*6 Displays de siete segmentos cátodo común
*6 Transistores BC547B
*6 Resistores de 820 ohms, 2 de 1000 ohms y 1 de 22000 ohms
*1 Push button

Diagrama:

Programa:

start0:
;***********************************************************************************************
;    CONFIGURACION DE LOS PUERTOS
;***********************************************************************************************
let dirsB = %11111111        ;Puerto B como salidas digitales
let dirsC = %11001111        ;C.4 y C.5 como entradas digitales
;***********************************************************************************************
;    INICIALIZACION DE VARIABLES
;***********************************************************************************************
let b1=0
let b2=0
let b3=0
let b4=0
let b5=0
let b6=0

;***********************************************************************************************
;    PROGRAMA PRINCIPAL
;***********************************************************************************************
main:
let pinsB=b6
pulsout C.0,100            ;Se activa solo el transistor de las centenas de millar
let pinsB=b5
pulsout C.1,100            ;Se activa solo el transistor de las decenas de millar
let pinsB=b4
pulsout C.2,100            ;Se activa solo el transistor de las unidades de millar
let pinsB=b3
pulsout C.3,100            ;Se activa solo el transistor de las centenas
let pinsB=b2
pulsout C.6,100            ;Se activa solo el transistor de las decenas
let pinsB=b1
pulsout C.7,100            ;Se activa solo el transistor de las unidades
goto main

start1:                ;En esta tarea se realiza el conteo
if b1=10 then
    let b1=0
    inc b2
endif
if b2>9 then
    let b2=0
    inc b3
endif
if b3>9 then
    let b3=0
    inc b4
endif
if b4>9 then
    let b4=0
    inc b5
endif
if b5>9 then
    let b5=0
    inc b6
endif
if b6>9 then
    let b6=0
endif
goto start1

start2:
if pinC.5 = 1 then bajo        ;Si es recibido un pulso se espera a que termine el pulso
goto start2
bajo:
if pinC.5 = 0 then incrementa    ;Una vez que termino el pulso se incrementa la variable b1
goto bajo
incrementa:
inc b1
goto start2

Video:

martes, 13 de marzo de 2012

Contador de eventos hasta 9999

Con este proyecto se puede llevar una cuenta de cualquier tipo de eventos, en este caso el contador se activa con un push botton, una aplicación puede ser en un torniquete, donde se cuenta digitalmente cuantas personas han pasado, entre otras.


El programa es el siguiente:
let b1=0
let b2=0
let b3=0
let b4=0
main:                                'Aquí se imprime el número guardado en las variables b1 a b4        
  let b0=128
  let pins=b0|b4
  let b0=64
  let pins=b0|b3
  let b0=32
  let pins=b0|b2
  let b0=16
  let pins=b0|b1
  if input0 is on then otra              'Esperamos a que se presione el botón   
goto main

otra:
  if input0 is off then una             ' Esperamos a que deje de presionar el botón        
goto otra

una:                                           ' Se incrementa el contador de unidades en 1  
  inc b1
  if b1=10 then                          ' Si la unidad llega al diez, que se reinicie en 0            
    let b1=0                               '  y que incremente a las decenas en 1
    inc b2
  endif
  if b2>9 then                           ' Si las decenas llegan a diez, que se reinicie en 0 
    let b2=0                               ' y que incremente a las centenas en 1
    inc b3
  endif
  if b3>9 then                           ' Si las centenas llegan a diez, que se reinicie en 0
    let b3=0                               '  y que incremente a las milésimas en 1
    inc b4
  endif
  if b4>9 then                            ' Si las milésimas llegan a diez, que se reinicie todo
    let b4=0
  endif
goto main


martes, 6 de marzo de 2012

Alarma

Se puede instalar una alarma en cualquier parte además que puede ser activada por un sensor de presencia, de luz, de temperatura, etc., en este caso lo hice con interruptor push button. También se puede cambiar la frecuencia de pítidos del zumbador.

El programa es el siguiente:
main:
  high 1                                     'Se prende el verde
  if pin3 is on then otro
  goto main
otro:
  if pin3 is off then prende
  goto otro
prende:                                     'Se prende la alarma
  low 1
  high 4
  high 2
  if pin3 is on then otra
  pause 50
  low 4,2
  pause 50
  goto prende
otra:
  if pin3 is off then apaga
  goto otra
apaga:
  low 4
  low 2
goto main

Semáforo

Con tan sólo tres salidas del picaxe-18M se puede obtener la frecuencia de cada led. Para obtener un semáforo real se tiene que utilizar un relevador en cada salida pero eso vendrá más adelante.

El programa es el siguiente:
semaforo:
low 7
high 4 'Prende el verde 5 segundos
wait 5
low 4
pause 300
for b0=0 to 1 'Parpadea el verde
   high 4
   pause 300
   low 4
   pause 300
next b0
high 5 'Prende el amarillo 2 segundos
wait 2
low 5
high 7 'Prende el rojo 7 segundos
wait 7
goto semaforo

lunes, 21 de noviembre de 2011

Luces tipo auto fantástico


En este proyecto se muestra cómo se pueden manipular las 8 salidas del PICAXE-18M. Se pueden hacer múltiples combinaciones en la frecuencia que se desee.


El programa es el siguiente:
main:
let pins=0
for b1= 0 to 1
   for b0=0 to 7    'Prende y apaga los led uno por uno del primero al último
      let pins=0
      high b0
      pause 50
   next b0
   for b0=7 to 0 step -1  'Prende y apaga los led uno por uno del último al primero        
      let pins=0
      high b0
      pause 50
   next b0
next b1
goto main