Si ya has usado el módulo LCD con Arduino probablemente te habrás dado cuenta de que no podemos imprimir por la pantalla cualquier carácter que queramos. Cuando intentamos imprimir ciertos caracteres, como “¡”, “¿” o “ñ” la LCD imprime caracteres extraños ya que no reconoce los que nosotros enviamos. ¿Por qué ocurre esto? ¿Se puede solucionar?
Cuando mandamos comandos o texto al módulo LCD estamos enviando qué se debe imprimir o qué se debe hacer, pero no estamos diciendo cómo hacerlo. En ningún momento le decimos qué píxeles tiene que pintar para dibujar una ‘A’ o cualquier otro carácter, tampoco le decimos qué se debe hacer al pasar por la función clear(). Esto es porque la propia LCD tiene guardados en su memoria interna ciertos caracteres y comandos a los que podemos recurrir.
Cuando enviamos un comando lo que hace la librería de la LCD es enviar una dirección de memoria que se corresponde con la localización del comando a utilizar en el registro (o memoria). La LCD va allí y lo ejecuta. Cuando enviamos texto ocurre algo análogo para imprimir cada carácter. Esto es así ya que es mucho más rápido que tener que comunicar cada vez cómo imprimir cada carácter o comando. De esta manera solo mandamos unos identificadores de dónde encontrar la información necesaria. Si un carácter no se encuentra en la memoria de la LCD, ésta no sabrá cómo pintarla.
Afortunadamente el registro donde se almacenan los caracteres tiene huecos libres donde podremos añadir caracteres personalizados. Concretamente podremos añadir hasta 8.
Como habrás visto en este tipo de LCD, cada carácter ocupa una matriz de 5 columnas por 8 filas. Este es tu lienzo y en él puedes dibujar lo que prefieras.
Ahora que tenemos el diseño, tenemos que convertirlo a algo que el ordenador y la LCD entiendan, es decir, hay que traducirlo a binario: ceros y unos. ¿Cómo lo hacemos? Los píxeles o cuadraditos azules se representan mediante unos, mientras que los que no hemos pintado, los grises, se corresponderán con ceros.
 |
Como ves, la sintaxis a utilizar es muy sencilla, definimos un tipo de dato que será un array o vector de 8 bytes. Cada uno de los componentes o elementos del vector corresponde a una fila de nuestro carácter. En este caso estamos inicializando el vector a la vez que lo declaramos, por eso se escribe entre llaves ‘{}‘ y con punto y coma ‘;‘ al final. Cada componente del vector va separada de la siguiente mediante una coma ‘,‘. El último elemento no hay que separarlo ya que no hay otro después, así que no llevará la coma. |
Cada elemento del vector se define escribiendo una B (se especifica que está en formato binario) seguido de los 5 bits que definen esa fila, es decir, ceros y unos dependiendo de lo que queramos pintar. Ya no parece tan difícil, ¿no?
Ya tenemos nuestro carácter creado, pero todavía no se lo hemos enviado a la LCD para que lo guarde. Para ello, la librería que gestiona la LCD tiene incluida una función con este propósito, la función .createChar():
|
1 |
nombreLCD.createChar(0,personaje); |
El uso es igual al del resto de funciones de la LCD; primero ponemos el nombre con que hemos declarado el módulo, invocamos a la función y pasamos como parámetros dos valores, el primero es la dirección donde se guarda el carácter. Recuerda que podemos guardar hasta 8 caracteres por lo que las direcciones posibles son de 0 a 7 (ambas incluidas). En este caso particular la posición es la 0 (¡debemos recordarla para después!); y el segundo parámetro es el vector que hemos declarado y donde hemos guardado, con ceros y unos, el dibujo que hemos hecho anteriormente.
Ahora la LCD ya conoce nuestro carácter y ya lo tiene guardado en su memoria, es hora de utilizarlo e imprimirlo por pantalla. Para ello, usamos otra de las funciones incluidas en la LCD:
|
1 |
nombreLCD.write(0); |
En este caso la función .write() recibe un parámetro, la dirección que asignamos anteriormente. Sí, por esto tenías que recordarla.
 |
Recuerda: debes saber que estos caracteres se guardan en una memoria de tipo RAM, lo que significa que cada vez que apagues la placa se borrarán todos los caracteres introducidos. Es recomendable que uses la función .createChar(); en el setup, para que se guarde cada vez que se inicie la placa, pero no es obligatorio. |
Vamos a ver el ejemplo completo para que puedas probarlo en tu Arduino y posteriormente replicarlo.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 |
#include "BitbloqLiquidCrystal.h" bool firstTime=true; LiquidCrystal lcd(0); //creamos un objeto LCD //Variable para nuestro caracter byte personaje[8] = { B01110, B01010, B01110, B00100, B11111, B00100, B01010, B10001 }; void setup() { lcd.begin(16, 2); //inicializamos el LCD, 16 columnas, 2 filas lcd.clear(); //borramos cualquier contenido residual lcd.createChar(0,personaje); } void loop() { if(firstTime) //ejecutamos esto solo la primera vez { lcd.clear(); //limpiamos cualquier contenido residual lcd.setCursor(0,0); //ponemos el cursos en la columna 0, fila 0 lcd.write(0); //escribimos lo que hay en la posición 0 firstTime=false; //para que no se vuelva a hacer } } |
Por supuesto, una vez tienes este carácter puedes moverlo por la pantalla o combinar varios caracteres para generar figuras más grandes e incluso animadas, ¿te atreves?
Nota: en la sección de descargas te adjuntamos un PDF con las figuras que hemos utilizado, así como los vectores necesarios para utilizarlos. De regalo también tienes el gusano animado. Puedes probar a animarlo en tu LCD. Nosotros hemos dibujado las figuras utilizando un editor de texto y tablas, pero si buscas en internet hay bastantes páginas y herramientas online que te permiten generar caracteres personalizados.
