Documentos de Académico
Documentos de Profesional
Documentos de Cultura
Las Pantalla TFT PDF
Las Pantalla TFT PDF
En esta podemos ver el modelo de cada una de las pantallas y sus características
principales como tamaño en pulgadas, resolución, capacidad de la memoria FLASH para
almacenar el código de programación, la memoria RAM y la cantidad de colores que es capaz
de representar.
Interface de comunicación
Hablamos de que este tipo de pantalla se comunica con otros dispositivos inteligentes
utilizando para ello una comunicación serial con una velocidad establecida por defecto de
9600 Baudios, por lo que solo son necesarias dos líneas de comunicación: TX y RX, a parte
de las líneas de alimentación VCC (+5V) y tierra. Internamente el modulo posee una
interrupción por recepción de datos en el puerto serie, por lo que el dispositivo generalmente
esta “escuchando” de forma continua la línea RX en espera de un comando que le dé una
orden de la función que la pantalla debe realizar. Estas órdenes son en forma de comandos
los cuales poseen cierta estructura y sintaxis que el programador debe respetar. Cabe aclarar
que la pantalla utiliza un lenguaje orientado a objetos y a eventos.
NEXTION EDITOR
Las pantallas de NEXTION poseen una herramienta indispensable utilizada para crear
la interface de usuario y todo lo referente a la programación del modulo para su correcto
funcionamiento. Recordemos que este tipo de pantalla es un dispositivo HMI (interface
humano – maquina), por lo que es un dispositivo inteligente y por lo tanto debe ser
configurado y programado para cumplir con la tarea que se desea, y tener siempre en cuenta
que es un modulo de entrada y salida de datos.
El editor posee una serie de herramientas muy completas para crear interfaces de
usuario – maquina muy realistas, llamativas y altamente interactivas gracias a la posibilidad
de usar imágenes, realizar animaciones y por su puesto al uso de la pantalla táctil de tipo
resistivo. La siguiente imagen describe las partes principales de este editor en el modo de
diseño:
Ing. Francisco Salazar Navarrete
Partes:
1. Lienzo: aquí es donde se colocan todos los controles e imágenes que forman parte de
la interface de usuario – maquina que se está creando. Su tamaño depende del modelo
de la pantalla y su resolución.
2. Barra de herramientas: cuanta con una serie de controles básicos para crear interfaces
amigables e interactivas. Posee diferentes elementos como etiquetas, botones,
checkbox, barras de progreso, barras de desplazamiento, etc.
3. Recursos del proyecto: aquí agregamos las imágenes y las fuentes que se van a utilizar
en un nuevo proyecto.
4. Ventana de eventos: en esta podemos ver los eventos que posee un control que ha
sido seleccionado con anterioridad. También es el lugar donde se codifica los
comandos para que la pantalla realice lo que nosotros deseemos.
5. Ventana de propiedades: aquí aparecen las propiedades del objeto seleccionado, las
cuales podemos modificar a voluntad.
6. Ventana donde se muestran las páginas del proyecto actual.
7. Iconos de acceso rápido a funciones variadas dentro del editor.
El editor también cuenta con un apartado dedicado a la depuración del proyecto, el cual
tiene la particularidad de contar con la posibilidad de realizar simulaciones para determinar
el comportamiento que tendrá la pantalla una vez que se diseñe la interface y se programe.
Mediante el botón “Debug” ubicado en la barra superior del editor llegamos a una pantalla
con la siguiente apariencia:
Ing. Francisco Salazar Navarrete
Partes:
1. Área de simulación.
2. Entrada de comandos para esperar respuesta del modulo.
3. Respuesta del modulo ante una determinada entrada.
Aquí podemos introducir los datos y los comando que deseemos y podemos ver el
comportamiento que tendrá el modulo ante una determinada entrada.
Como ya sabemos este tipo de pantalla es un dispositivo inteligente que interpreta una
serie de comandos que se les son enviados a través del puerto serie, y de acuerdo a los
comandos que recibe, actúa en consecuencia. Debemos tener presente que este dispositivo
posee internamente una interrupción por recepción del puerto serie, de modo que la pantalla
generalmente esta en escucha de la entrada de un dato a través de su línea RX esperando el
momento en que le entrada un dato y a si actúa en consecuencia.
Cuando creamos una interface en las pantallas NEXTION, los controles tienen
asociados un nombre único, así como un nombre para la pagina en donde están ubicados. Por
lo que para poder actuar sobre un determinado control debemos enviar un comando que
involucra: el nombre de la pagina, el nombre del control, la propiedad de este ultimo que se
desea modificar, así como el valor que se le desea asignar. El formato del comando que se
debe enviar desde el microcontrolador PIC para ser recepcionado por la pantalla NEXTION
es de la siguiente manera:
Ing. Francisco Salazar Navarrete
Este comando debe ser enviado como una sola cadena de caracteres y al final terminar
con una secuencia de tres veces el valor 0xFF para indicarle al dispositivo que se ha
finalizado con la recepción de los datos.
Los datos que son transmitidos por la pantalla NEXTION hacia otro dispositivo
inteligente, en este caso un microcontrolador PIC, se realiza por el puerto serial codificado
en una trama de datos cuya cantidad de información va a depender de lo que la pantalla nos
quiere dar a entender. En el primer byte de la trama (el primer dato que es transmitido) nos
indica cual es el significado de la información que se ha enviado, y de acuerdo a esto, los
subsiguientes uno, dos o más datos a transmitir dentro de esa misma trama, siempre
finalizando dicha transmisión mediante tres 0xFF, que como ya sabemos indica que la
pantalla ha terminado de enviar datos. La estructuras de las tramas, así como su significado
es el siguiente:
El usuario ha 0x65+ID_pagina+ID_componente+Tipo_evento+End
presionado sobre un
0x65 control ubicado en la
pantalla. Donde: (0: press event, 1: release event).
Observe que cada suceso posee un byte asociado con una numeración distinta por lo
que cuando la pantalla le envíe un dato al microcontrolador, lo primero que debemos hacer
para interpretar la información es determinar mediante l primer byte que entra, que tipo de
suceso se ha generado y una vez identificado esto se podrá definir cuantos bytes sucesivos
serán recibidos. Por lo tanto, se recomienda crear métodos específicos de recolección de datos
por parte del microcontrolador, dependiendo del suceso que se genero.
En realidad se pueden enviar diferentes tipos de datos desde la pantalla NEXTION hacia el
microcontrolador PIC. Entre ellos tenemos los siguientes:
Enviar el ID de la página actual: esto se realiza mediante el uso del comando “Sendme”, el
cual no lleva ningún parámetro, y la trama enviada sería la siguiente:
0x66 + 0x00 + 0FF + 0FF + 0FFenvía el numero ID de pagina cuyo valor es “0”.
Enviar el ID del control que ha entrado en interacción con el usuario: recordemos que cuando
el usuario presiona la pantalla sobre un control, se puede desencadenar dos tipos de eventos:
Ing. Francisco Salazar Navarrete
el press event y el release event. Esta circunstancia puede ser aprovechada para determinar
cual botón ha sido presionado o soltado, así por ejemplo, la trama se traduciría de la siguiente
manera:
0x65+ 0x01+ 0x00 + 0x01 + 0FF + 0FF + 0FFenvía un “0” que corresponde al ID de un
control ubicado en la pagina cuyo ID es “1” y que se ha generado un evento de tipo “release
event”.
Print “A” envía el código UNICODE de la letra “A” a través del puerto serie.
Print “HOLA” envía el código UNICODE de la cadena “HOLA” a través del puerto
serie.
Observe que el código UNICODE de la letra “H” es 0x48, el de la letra “O” es 0x4F, el de la
letra “L” es 0x4C y el de la letra “A” es 0x41.
Envío de un valor numérico: para enviar un valor numérico se utiliza nuevamente el comando
“print” de la siguiente manera:
0xD0+ 0xA0
Page: vuelve a dibujar todo el contenido de una página en particular. En otras palabras
“refresca” una página. Este comando se utiliza también para pasar de una página a otra dentro
de un proyecto. La sintaxis es:
Donde:
0 Release event
1 Press event
Sendme: provoca que la pantalla retorne el numero de ID de la pagina que está actualmente
visible en ella. Este comando no tiene parámetros.
Cov t0.txt, j0.val,0 convierte el texto de “t0” en valor numérico y lo carga en “j0”.
Ing. Francisco Salazar Navarrete
Vis: muestra o esconde un componente dentro de una determinada página. La sintaxis es:
Donde:
Donde
Touch_j: provoca que la pantalla entre en modo de calibración para el táctil de la pantalla.
Este comando no posee parámetros. Hay que tener en cuenta que las pantallas NEXTION
han sido calibradas de fábrica, así que esta instrucción no se utilizaría bajo condiciones
normales.
Donde:
inicio: corresponde al índice de inicio de la cadena a extraer. El primer carácter tiene indice
“0”.
Strlen: determina la longitud (cantidad de caracteres) que tiene una cadena. Su sintaxis es la
siguiente:
Sentencias de control
if(b0.txt==”start”
{
b0.txt==”stop”
}
else
{
b0.txt==”start”
}
Tener siempre en cuenta los siguientes puntos relacionados a las sentencias de control:
1. Las variables numéricas soportan los siguientes operadores: “>, <, ==, !=, >=, <=”
2. Los caracteres y las cadenas soportan los operadores: “==, !=”
3. El operador de anidamiento “( )” no está permitido. No está soportado las operaciones
de comparación, tales como: if (j0.val + 1> 0).
4. Soporta anidamientos consentencias “if” y “else if”.
Ciclo While: con esta sentencia el ciclo se repite siempre y cuando la condición sea
verdadera.
while(n0.val<100)
{
n0.val++
}
Ciclo FOR: con esta sentencia el ciclo se repite siempre y cuando la condición sea verdadera.
Cls <color>
Donde color puede ser un valor decimal que representa el color o el nombre propio.
Xstr: imprime una cadena de caracteres en las coordenadas y el tamaño deseado. Su sintaxis
es:
Donde:
Nota: cuando se selecciona una imagen o una imagen recortada, en color de fondo se debe
colocar el ID de la imagen.
xstr 0,0,100,30,1,RED,BLACK,1,1,1,"China"
Line 0,0,100,100,RED
Draw: dibuja un rectángulo sin relleno y cuyo borde es coloreado. Su sintaxis es:
La GUI está formada por una etiqueta “t0”, una barra de progreso “j0” y un botón simple
“b0”. La idea es enviar una letra “H” desde el microcontrolador hacia la pantalla, así como
la cadena “Hola” y esta se represente en la etiqueta “t0”. Además se debe enviar a la
pantalla el valor “50” para modificar el valor correspondiente a la barra “j0”. Por otra
parte, cuando un usuario presione el botón “b0” en la pantalla, se deberá encender un LED
ubicado en la patilla RA0 del microcontrolador PIC.La comunicación serial entre el PIC y
la pantalla se simulara por software, donde el PIN RA2 será el de transmisión y el PIN RA3
el de recepción. El circuito eléctrico es el siguiente:
Ing. Francisco Salazar Navarrete
Código fuente:
#include <16F84A.h>
#fuses XT,NOWDT,NOPROTECT,PUT
#use delay(clock=4000000)
#use fast_IO(A)
#use fast_IO(B)
#use RS232(FORCE_SW,baud=9600,xmit=PIN_A2,rcv=PIN_A3,bits=8,parity=N,stop=1)
void main(void)
{
int recibe[7]={0x00,0x00,0x00,0x00};
set_tris_A(0b00001000); //RA3 como entrada, el resto como salida.
//------------------------------------------------------------------------------
//vamos a proceder a enviar a la pantalla NEXTION un caracter
//para ello debemos enviar la siguiente trama de datos:
//1-Primero el nombre de la pagina.
//2-Segundo el nombre del control sobre el cual se desea trabajar.
//3-Tercero la propiedade del control que se desea modificar seguida de su valor
//4-Finalmente una secuencia de final correspondiente a 3 veces 0xFF.
//------------------------------------------------------------------------------
printf("page0.t0.txt=\"%c\"ÿÿÿ",'H'); //enviamos el nombre de la pagina, el control y la propiedad a modificar
//------------------------------------------------------------------------------
//ahora vamos a enviar una cadena de caracteres, siguiendo la secuencia anterior
//------------------------------------------------------------------------------
Ing. Francisco Salazar Navarrete
//------------------------------------------------------------------------------
//ahora procedemos a enviar un caracter numerico, un valor entero.
//------------------------------------------------------------------------------
printf("page0.j0.val=%uÿÿÿ",50); //enviamos el nombre de la pagina, el control y la propiedad a modificar
while(TRUE)
{
//realiza una comparación de cada uno de los byte almacenados en el arreglo de recepción
//para verificar si se siende el LED o no