Control de GLCD de 128x64 puntos

Aunque son un poco mas costosos que los LCD de caracteres, pueden ser útiles a la hora de mostrar gráficamente algún parámetro, por ejemplo barras, animaciones, figuras geométricas, texto y también imágenes o fotos. 
Para manejar una imagen o foto por ejemplo tenemos que tener en cuenta que necesitamos de un microcontrolador con buena memoria y velocidad, ya que el renderisado se realiza de forma secuencial, por ejemplo el microcontrolador utilizado para este ejemplo no es suficiente para mostrar una imagen.
En este ejemplo se mostrara un voltimetro y amperimetro, dentro de unos recuadros, con texto informativo y demás.
Para este ejemplo estoy utilizando las librerías para CCS, HDM64GS12.c y graphics.c
La librería HDM64GS12, posee el control del GLCD propiamente dicho y dentro de la misma en su encabezado encontraremos el pinout del mismo para poder conectarlo. El GLCD debe tener el controlador KS0108, debemos tener en cuenta que en el pinout debe tener los pines de selección de chip CS1 y CS2.
La librería Graphics es la librería que nos permitirá dibujar y escribir en el mismo, que detallare las funciones principales de la misma (de todas formas pueden verlo en el encabezado de la librería).

Funciones para controlar el GLCD:

glcd_line(x1, y1, x2, y2, color)
Dibuja una linea desde la coordenada (x1,y1) hasta (x2,y2), la variable color puede ser ON o OFF, esta es la que habilita la linea o no (para mostrarla o no).

glcd_rect(x1, y1, x2, y2, fill, color)
Dibuja un rectángulo desde la coordenada (x1,y1) hasta (x2,y2), la variable fill es para rellenar el rectángulo si esta en YES, o solo dibuja el contorno con NO. la variable color al igual que en el resto de las funciones es la que habilita o no el rectángulo.

glcd_bar(x1, y1, x2, y2, width, color)
Dibuja una barra desde la coordenada (x1,y1) hasta (x2,y2), la variable width es el número de pixel de ancho de la barra, la variable color al igual que en el resto de las funciones es la que habilita o no la barra.

glcd_circle(x, y, radius, fill, color)
Dibuja un circulo en la coordenada (x,y), la variable radius es el numero de pixeles de radio de del circulo, a variable fill es para rellenar el circulo si esta en YES, o solo dibuja el contorno con NO. la variable color al igual que en el resto de las funciones es la que habilita o no el circulo.

glcd_text57(x, y, textptr, size, color)
Escribe texto en la coordenada (x,y), la variable textptr es la variable puntero donde esta alojado el carácter o string, a variable size es el tamaño del carácter, la variable color al igual que en el resto de las funciones es la que habilita o no el texto.

glcd_pixel(x, y, color)
Dibuja un punto o pixel en la dirección de la coordenada (x,y), la variable color al igual que en el resto de las funciones es la que habilita o no el punto o pixel.


A continuación mostrare el pinout del GLCD:



En este programa realizaremos un voltimetro y amperimetro que utilizara 2 canales ADC.
Se implementa el PIC16F887 por la cantidad de pines y puertos del mismo, recordemos que este GLCD requiere de una cantidad considerable de pines.

  1. #include <16F887.h>
  2. #device adc=10
  3. #fuses HS,NOWDT,NOPROTECT,NOLVP
  4. #use delay(clock=20000000)
  5. #include <HDM64GS12.c>
  6. #include <graphics.c>
  7. void main(){
  8.    int16 voltajeADC, voltajeADC_ant,
  9.          corrienteADC, corrienteADC_ant;
  10.    setup_adc_ports(sAN0|sAN1|VSS_VDD);
  11.    setup_adc(ADC_CLOCK_DIV_2);
  12.    char nombre[]="Electgpl";
  13.    char parametro[]="   [V]       [A]   ";
  14.    char voltaje[9];
  15.    char corriente[9];
  16.    glcd_init(ON);
  17.    glcd_rect(1, 1, 127, 63, NO, ON);
  18.    glcd_rect(3, 3, 125, 13, NO, ON);
  19.    glcd_text57(41, 5, nombre, 1, ON);
  20.    glcd_rect(3, 15, 125, 25, NO, ON);
  21.    glcd_text57(8, 17, parametro, 1, ON);
  22.    glcd_rect(3, 27, 125, 61, NO, ON);
  23.    while(true){
  24.       set_adc_channel(0);
  25.       delay_us(10);
  26.       voltajeADC=read_adc();
  27.       if(voltajeADC_ant != voltajeADC){
  28.          glcd_text57(13, 38, voltaje, 2, OFF);
  29.          sprintf(voltaje, "%1.2f", (float)voltajeADC*5/1023.0);
  30.          voltaje[4] = '\0';
  31.          glcd_text57(13, 38, voltaje, 2, ON);  
  32.          voltajeADC_ant=voltajeADC;
  33.       }
  34.       set_adc_channel(1);
  35.       delay_us(10);
  36.       corrienteADC=read_adc();
  37.       if(corrienteADC_ant != corrienteADC){
  38.          glcd_text57(70, 38, corriente, 2, OFF);
  39.          sprintf(corriente, "%1.2f", (float)corrienteADC*5/1023.0);
  40.          corriente[4] = '\0';
  41.          glcd_text57(70, 38, corriente, 2, ON);  
  42.          corrienteADC_ant=corrienteADC;
  43.       }  
  44.    }
  45. }

Como podemos ver en el código fuente, incluimos las dos librerías necesarias para el GLCD, luego definimos las variables para el ADC y las variables character donde alojaremos los strings a mostrar y las dos variables dinámicas de tensión y corriente.
Luego podemos encontrar la configuración de los dos canales de ADC y seguida de la misma la primera instrucción del GLCD que sera la inicialización del mismo que lo borrara cuando el argumento de la función sea ON.
Ahora pasaremos a la función principal de loop donde se aloja el programa.
Ya que la medición de corriente como la de tensión poseen el mismo código, solo explicare una y la otra es igual.
Como podemos ver, seteamos el canal ADC a leer, esperamos los 10us para conversión segura y luego volcamos el contenido del ADC (de 0 a 1023 por estar seteado a 10bit) a la variable voltajeADC.
Por ahora voy a saltear el if y el intercambio de variables, ya que quiero demostrar de forma sencilla el funcionamiento.
La primer función para escribir de forma dinámica, necesitamos la función sprintf se utiliza para escribir strings por eso la letra s antes de printf, y aquí ingresaremos el string (en este caso voltaje[], luego le sigue el formato de dato "%1.2f" que nos dará un entero y dos decimales y por ultimo el valor que vamos a volcar al string (en este caso realizamos todo el acondicionamiento de la entrada en el mismo lugar, que es multiplicar el valor del ADC por 5V que es el fondo de escala y dividirlo por los 1023 pasos de resolución, así nos mostrara un valor de tensión de 0 a 5V).
Luego podemos encontrar el string voltaje[4] que se iguala a '\0', que se encarga de delimitar el máximo de caracteres a 4.
Ahora debemos enviar el valor que hemos convertido a string en la función sprintf a la función del GLCD glcd_text57() donde damos origen al texto en la posición (13,38), luego viene la variable string, el tamaño de la letra que le he puesto valor 2 (es un valor mediano como para que entren las dos variables) y por ultimo ON que sera el que habilita esta función para que se muestre el valor.
Ahora si nosotros cambiamos un valor por otro, que es lo que va a pasar al medir con el ADC, se sobre escribirán uno sobre el otro y no se entenderá lo que se lee, para ello es el uso del if y el intercambio de variables, como pueden ver el if es verdadero cuando el valor del ADC es distinto al ultimo valor leido por el ADC, esto es para ver si el valor cambio o no.
Una vez que es verdadero porque el valor cambia, se procede a la función glcd_text57 pero con el ultimo valor del argumento OFF ya que esto apaga e texto en ese momento y da lugar a la actualización del mismo, y luego lo pone ON y lo deja ahi hasta que se vuelva a actualizar el valor del ADC y entre al if.
De esta forma se logra actualizar en la pantalla de forma dinámica el valor.



Arduino - Introducción

Qué es Arduino.
Arduino es una placa de desarrollo de Hardware y Software abierto, es decir, se encuentra disponible para la descarga tanto el circuito electrónico y circuito impreso, como también el código fuente de su entorno de programación integrado. https://www.arduino.cc/
Arduino está orientado a estudiantes de informática, a hobbistas, a artistas, estudiantes de electrónica, etc...
Para saber un poco de que se trata una placa de desarrollo, debemos mencionar la utilidad de la misma.
Una placa de desarrollo, es un circuito electrónico el cual adapta una determinada electrónica compleja que requiere de conocimientos avanzados para la operación, a una electrónica más sencilla y resumida para que el usuario pueda utilizar el mismo poder electrónico con un conocimiento mínimo.
Un ejemplo sencillo podría ser el de LEGO NXT, donde se provee de una CPU con interfaces de entrada/salida y una determinada variedad de sensores/actuadores para conectar a esa CPU que luego será programada por un ordenador.
En el caso Arduino sucede lo mismo, tenemos una placa ya ensamblada y funcional donde le conectaremos actuadores, sensores, etc… y solamente restará la programación de la misma.
La ventaja de estas placas de desarrollo es que no debemos perder tiempo en conectar un microcontrolador, su oscilador, su fuente, su interfaz de programación, etc… el desarrollador se enfocará en el programa que uno requiera cargar en el mismo y en la configuración del hardware.
También cabe destacar que para realizar un diseño electrónico desde cero se requieren también fuertes conocimientos en electrónica, lo cual la placa de desarrollo no requiere porque la misma ya se encuentra funcionando.
Existen también otras placas similares a Arduino, otras propuestas de otras marcas que también son OpenHard y OpenSource.
Estas variantes también poseen variantes en la potencia del microcontrolador y en la cantidad de prestaciones de la placa (entradas, salidas, timers, analogicos, pwm, seriales, etc…)

El lenguaje de programación de Arduino desciende del lenguaje Wiring que está basado en C/C++ y Processing que está basado en Java, algo a tener en cuenta es que la gran mayoría de sus librerías se encuentran desarrolladas en C++ con objetos, lo cual sera de gran ayuda si el desarrollador posee conocimientos en programación orientada a objetos, C o C++.

Historia
Arduino nace en Italia en base a otra placa desarrollada por un alumno en una universidad de Colombia con el nombre Wiring, este alumno había desarrollado la placa Wiring, el entorno de desarrollo y el lenguaje. Era una placa muy similar a la conocida como Arduino MEGA, ya que las prestaciones son similares al igual que el tamaño y demás.
Luego por Italia, un grupo de profesores que utilizaban hasta el momento la placa Basic Stamp que es similar a Arduino pero más costosa, quisieron optar por desarrollar una placa basada en la anterior Wiring que pueda ser más económica para la fabricación local y de esa forma más sencilla de obtener para que los alumnos puedan estudiar la materia, Al mismo tiempo se toma el lenguaje de programación y el IDE de forma OpenSource del MIT con el nombre de Processing y de esta forma nace Arduino.

Tipos de Arduinos
Hoy en día vamos a encontrar una gran cantidad de placas Arduino para elegir nuestra mejor opción al momento de diseñar nuestro sistema.
Arduino como fue mencionado anteriormente, es una placa con conectores, fuente y todo lo necesario para utilizar un microcontrolador, pero no solamente es eso, también posee en su interior un puerto serie/usb el cual utilizaremos para cargar el programa en el Arduino, pero también utilizaremos como monitor serial (esta es una opción muy cómoda para depurar un programa).
Lo que nos permite utilizar esta facilidad de cargar un programa en el microcontrolador sin la necesidad de un programador dedicado y costoso, es el uso de un Bootloader en el microcontrolador. Un Bootloader (cargador de arranque) es un pequeño programa que se aloja en una sección de la memoria del microcontrolador que realiza la traducción del programa por el puerto serie hacia la memoria flash del mismo. Con este pequeño programa no requerimos de una placa programadora especial.
Esto hay que tenerlo en cuenta para aquellos que quieran aventurarse en diseñar su propio arduino, cuando ponemos el microcontrolador en la placa debe poseer en su interior el Bootloader precargado, de otra manera no será reconocido por el IDE de arduino.
Vamos a nombrar algunos modelos, pero vamos a dejar el link para que los conozcan de su pagina: https://www.arduino.cc/en/Main/Products


Arduino UNO
Este tal vez sea el más conocido de todos, el más utilizado y el recomendado para comenzar con Arduino, ya que será el que mayor cantidad de ejemplos y tutoriales encontremos por internet al momento de aclarar dudas, pero todos los arduinos son compatibles en cuanto a la programación.



Arduino NANO
Esta es una versión del UNO pero de dimensiones reducidas, para integrarlo en algún dispositivo de dimensiones reducidas donde no podemos contar con el tamaño del UNO, pero posee la misma electrónica y la misma potencia que el modelo UNO



Arduino MEGA
Esta es la opción de potente (aunque existe la version DUE que integra arquitectura ARM de 32 Bit en lugar de AVR de 8 Bit), esta opción posee una mayor cantidad de pines de entrada/salida, como también de puertos series, canales ADC, PWM, etc… Tambien algo importante una memoria mayor, para alojar programas más grandes.