HAL_GPIO_EXTI_IRQHandler().
HAL_GPIO_EXTI_Callback().
No olvidar que todo est trabajando a 3V, por lo tanto los niveles lgicos son de 3V tenga especial
cuidado de no mezclar niveles digitales de 5V puesto que podra daar el microcontrolador cortex.
En el diagrama electrnico de la placa Discovery podemos ver que este pulsador (botn azul) es
conectado a nivel alto cuando es pulsado siendo su estado normal un nivel bajo.
Recuerde que todos los niveles lgicos son tomados sobre los 3V si coloca un pulsador fuera de la
placa no olvide conectarlo a 3V y no a oros voltajes que pueden provocar daos en la placa.
Capitulo II.
EXTI (Interrupciones externas).
Igual que Cortex M4, hay un controlador para las interrupciones llamado NVIC (Nested Vector
Interrupt Controller) con soporte para 240 fuentes de interrupcin con 256 niveles de prioridad.
Cada interrupcin tiene un vector (Interrupciones Vectorizadas) donde se aloja el cdigo (ISR) que
trata la interrupcin.
Hay dos formas de tratar las prioridades: preemption priorities y sub priorities.
El que tiene mayor prioridad (preemption priorities) se ejecuta en primer lugar, cuando dos
interrupciones tienen la misma prioridad el que tiene mayor prioridad secundaria (sub priorities) se
ejecutar primero. Si ambas tienen igual prioridad y sub-prioridad la interrupcin que ocurra
primero se ejecutar primero (orden de llegada).
Se debe tener cuidado al utilizar HAL_Delay () desde una rutina de interrupcin (ISR), la
interrupcin del SysTick debe tener mayor prioridad (numricamente menor) que la interrupcin
perifrica. De lo contrario se bloquear la ISR escrita por el usuario.
Vemos un ejemplo de interrupcin para el conversor analgico.
La configuracin de la interrupcin del mdulo se realiza en el archivo stm32f7xx_hal_msp.c, en
este archivo la funcin HAL_ADC_MspInit() realiza la configuracin. Ya est establecido que si
utiliza la interrupcin del ADC esta funcin ser llamada desde el archivo stm32f7xx_hal_adc.c.
Cada perifrico cuya interrupcin este activa tendr una funcin similar para configurar el
hardware, por ejemplo para la UART seria HAL_UART_MspInit().
La biblioteca HAL simplifica grandemente el tratamiento de las interrupcin, dos funciones
trasparentan el trabajo de CMSIS sin embargo el proceso de interrupcin a nivel de hardware sigue
siendo tan complejo y de cuidado como siempre.
HAL_NVIC_SetPriority(ADC_IRQn, n, n1);
Donde ADC_IRQn es el nombre del perifrico que activa su interrupcin, n es el nivel de prioridad
y n1 el de sub-prioridad.
HAL_NVIC_EnableIRQ(ADC_IRQn);
Esta funcin activa la interrupcin para este perifrico.
Cortex M7 tienen caractersticas mejoradas para reducir la latencia en el llamado a la ISR respecto
de M4.
Las interrupciones se enumeran desde el cero, siendo el nmero de menor valor la mayor prioridad,
con nmeros negativos se enumeran las excepciones. El archivo stm32f7xx.h proporciona el
nmero de interrupcin y de excepcin. En el caso del KEIL, ARM proporciona dentro del archivo
startup_stm32f7xx.s una plantilla para el manejo de interrupciones y excepciones.
; External Interrupts
DCD EXTI4_IRQHandler ; EXTI Line4
DCD DMA1_Stream0_IRQHandler ; DMA1 Stream 0
DCD DMA1_Stream1_IRQHandler ; DMA1 Stream 1
DCD DMA1_Stream2_IRQHandler ; DMA1 Stream 2
DCD DMA1_Stream3_IRQHandler ; DMA1 Stream 3
DCD DMA1_Stream4_IRQHandler ; DMA1 Stream 4
DCD DMA1_Stream5_IRQHandler ; DMA1 Stream 5
DCD DMA1_Stream6_IRQHandler ; DMA1 Stream 6
DCD ADC_IRQHandler ; ADC1, ADC2 and ADC3s
DCD CAN1_TX_IRQHandler ; CAN1 TX
DCD CAN1_RX0_IRQHandler ; CAN1 RX0
etc
etc
Normalmente encontrar que los servicios de interrupciones se escriben en el archivo
stm32f7xx_it.c.
Se recomienda consultar el manual de controlador para tener mas detalles sobre los tiempos
involucrados en los llamados a interrupciones. Hay 16 lneas de interrupcin externa EXTI0, EXTI1,
EXTI2......EXTI15 con una gran cantidad de pines GPIO que se pueden configurar para
interrupciones externas.
Todos los puertos tienen la capacidad de disparar una interrupcin por evento externo. Para utilizar
las lneas de interrupcin externa, el puerto debe estar configurado en el modo de entrada y la
interrupcin se puede configurar por flanco de subida, de bajada o ambos.
En el siguiente ejemplo vemos como funciona la interrupcin exterior disparada por el pin
conectado al botn de usuario (botn azul). Este pulsador est conectado en el puerto GPIO_I en el
pin 11 de este puerto.
Para configurar el funcionamiento de este pulsador como generador de interrupcin podemos
escribir la siguiente funcin. La interrupcin se define en el pin 11 del GPIO_I por flanco de subida
y un nivel de prioridad bajo (0x0F)
void Config_inte_pulsador(void) {
GPIO_InitTypeDef GPIO_boton;
__HAL_RCC_GPIOI_CLK_ENABLE();
GPIO_boton.Pin = GPIO_PIN_11;
GPIO_boton.Mode = GPIO_MODE_INPUT;
GPIO_boton.Pull = GPIO_NOPULL;
GPIO_boton.Speed = GPIO_SPEED_FAST;
GPIO_boton.Mode = GPIO_MODE_IT_RISING;
HAL_GPIO_Init(GPIOI, &GPIO_boton);
HAL_NVIC_SetPriority((IRQn_Type)(EXTI15_10_IRQn), 0x0F, 0x00);
HAL_NVIC_EnableIRQ((IRQn_Type)(EXTI15_10_IRQn));
}
Si observa la lnea HAL_NVIC_SetPriority((IRQn_Type)(EXTI15_10_IRQn), 0x0F, 0x00) es
donde se configura una interrupcin en un pin especfico y su nivel de prioridad, en el archivo
startup_stm32f746xx.s se puede ver la declaracin de esta lnea IRQ.
DCD EXTI15_10_IRQHandler ; External Line[15:10]s
Es importante no olvidar que el nombre usado en nuestra funcin de interrupcin debe ser el mismo
que est declarado en el archivo startup_stm32f746xx.s.
En el archivo stm32f7xx_it.c podemos encontrar la funcin que trata el evento del botn.
/******************************************************************************/
/* STM32F7xx Peripherals Interrupt Handlers */
/* Add here the Interrupt Handler for the used peripheral(s) (PPP), for the */
/* available peripheral interrupt handler's name please refer to the startup */
/* file (startup_stm32f7xx.s). */
/******************************************************************************/
.
.
.
void EXTI15_10_IRQHandler(void){
/* EXTI line interrupt detected */
if(__HAL_GPIO_EXTI_GET_IT(GPIO_PIN_11) != RESET)
{
HAL_GPIO_TogglePin(GPIOI, GPIO_PIN_1);
__HAL_GPIO_EXTI_CLEAR_IT(GPIO_PIN_11);
}
.
.
Luego veremos que es posible incluir esta funcin en el propio archivo principal donde se encuentra
la funcin main().
Como se mencionaba anteriormente los Cortex M tiene una tecnologa muy eficiente para reducir la
latencia entre interrupciones.
Conociendo la pantalla grfica.
La placa entrenadora trae una pantalla grfica TFT ya montada, con una resolucin de 480 por 272
pxeles, el chip FT5336 es el encargado de su control. El Touch del tipo capacitivo es controlado
mediante el protocolo I2C . El estado del Touch-Secreen es reportado al programa del usuario
mediante los campos de una estructura que se encuentra en el archivo stm32746g_discovery_ts.h.
Esta estructura tiene los siguientes campos:
typedef struct{
uint8_t touchDetected;
uint16_t touchX[TS_MAX_NB_TOUCH];
uint16_t touchY[TS_MAX_NB_TOUCH];
#if (TS_MULTI_TOUCH_SUPPORTED == 1)
uint8_t touchWeight[TS_MAX_NB_TOUCH];
uint8_t ouchEventId[TS_MAX_NB_TOUCH];
uint8_t touchArea[TS_MAX_NB_TOUCH];
uint32_t gestureId;
#endif /* TS_MULTI_TOUCH_SUPPORTED == 1 */
} TS_StateTypeDef;
Los tres primeros campos permiten casi el control total de la pantalla, contiene la indicacin si la
pantalla ha sido tocada y la coordenada X/Y donde la pantalla se ha activado. Para disponer de la
pantalla necesitamos la siguiente configuracin en nuestro proyecto.
Los dos archivos marcados son los encargados del manejo de la pantalla en lo que respecta a su
aspecto visible, y stm32746g_discovery_ts.c maneja el Touch-Screen.
Si bien el desarrollo de interfaces grficas suele ser una tarea engorrosa, tenemos distintas opciones
para su creacin y depende mucho de lo que necesitemos hacer y los tiempos en juego para resolver
el problema. Sin duda dos puntos son relevantes a la hora de crear una pantalla que interacta con el
usuario.
1. La interfaz se debe ver atractiva, un diseo interesante y simptico, colores y movimiento
son muy tiles para esto. No es lo mismo un simple icono de un botn pintado de color, que
un botn pintado con sensacin de profundidad cuando se lo oprime. La interfaz tambin
debe ser intuitiva. Algo que solo con mirarla ya intuimos lo que hay que hacer haciendo el
trabajo del usuario mas sencillo y entendible.
2. Cuando la interfaz tiene un control del hardware, una accin determinada activa o desactiva
algn componente electrnico ya sea en la propia placa o de electrnica exterior, esto debe
tener un funcionamiento franco y directo no teniendo el usuario que actuar mas de una vez
en un botn para que este se accione.
Como veremos en las lneas siguientes, es bastante simple crear un botn y condicionar su
funcionamiento a determinadas condiciones y acciones de la misma forma como sera un pulsador
fsico.
Para crear interfaces grficas podemos hacer uso de software especializado en esas tareas como es
el caso de StemWin, con el podemos hacer una interfaz grfica muy rpidamente.
Resultado final en la pantalla fsica del trabajo en realizado con StemWin.
En lo personal creo que el uso de software especializado es particularmente til cuando se necesitan
interfaces complejas que incorporan mltiples indicadores y actuadores grficos, debe quedar claro
que el software solo crea el aspecto visible, la interaccin con el hardware sigue siendo
responsabilidad del programador de la aplicacin puesto que es el quien conoce que componentes
electrnicos sern afectados por la interfaz.
Creando una interfaz grfica.
Veamos a ver un ejemplo donde una accin en la pantalla enciende o apaga dos LED's colocados en
los pines del puerto.
En este ejemplo se han definido dos botones, cada uno controla un LED conectados en los pines
GPIO_I 2 y GPIO_I 3.
En la imagen anterior se puede apreciar donde sern colocados los respectivos LED's, la accin
sobre los pulsadores virtuales se reflejar en un cambio de estado en estos pines.
Para el diseo de la grfica en la pantalla nos centraremos en las funciones ya definidas para la
creacin de botones y marcos de trabajo.
Para realizar el trabajo necesitamos de varios archivos de cabecera.
#include <stdio.h>
#include "main.h"
#include "stm32f7xx_hal.h"
#include "stm32f7xx.h"
#include "stm32746g_discovery.h"
#include "stm32746g_discovery_lcd.h"
#include "stm32746g_discovery_ts.h"
#include "ft5336.h"
La funcin principal inicia llamando a varias funciones de configuracin inicial.
int main(void){
MPU_Config();
CPU_CACHE_Enable();
HAL_Init();
SystemClock_Config();
Configurar_LED();
BSP_LCD_Init();
BSP_LCD_LayerDefaultInit(LTDC_ACTIVE_LAYER, SDRAM_DEVICE_ADDR);
BSP_LCD_SelectLayer(LTDC_ACTIVE_LAYER);
Touchscreen_SetHint();
..
..
..
MPU_Config(),SystemClock_Config(), HAL_Init(), son funciones de configuraciones genricas
primarias que incluso pueden no estar presentes en el archivo principal siendo su accin
transparente al usuario y su configuracin se hace efectiva por medio de campos de estructuras que
son completadas en otros archivos, por el ejemplo el funcionamiento del reloj y PLL se puede
configurar directamente desde el archivo system_stm32f7xx.c.
La funcin Configurar_LED() es la encargada de los GPIO donde estn conectados los LED,
configura los dos pines en el GPIO_I y estos inician en estado bajo.
El contenido de la funcin seria como sigue.
void Configurar_LED(void) {
GPIO_InitTypeDef GPIO_LED;
__HAL_RCC_GPIOI_CLK_ENABLE();
GPIO_LED.Pin = GPIO_PIN_2 | GPIO_PIN_3;
GPIO_LED.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_LED.Pull = GPIO_PULLUP;
GPIO_LED.Speed = GPIO_SPEED_HIGH;
HAL_GPIO_Init(GPIOI, &GPIO_LED);
HAL_GPIO_WritePin(GPIOI, GPIO_PIN_2, GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIOI, GPIO_PIN_3, GPIO_PIN_RESET);
}
Las funciones relativas al funcionamiento de la pantalla grfica, funciones de inicio como
BSP_LCD_Init() o configuracin de capas visibles, BSP_LCD_LayerDefaultInit() y funciones que
hacen visible la la grfica de la pantalla como BSP_LCD_SelectLayer(), todas se encuentran en el
archivo stm32746g_discovery_lcd.c, incluso las funciones de alineacin de texto, seleccin de
fuentes y formas de dibujo se encuentran en ese archivo. Estas funciones deben ser invocadas antes
de usar la pantalla y son las encargadas de configurar la pantalla en un modo genrico.
CPU-CACHE_Enable() es la funcin encargada de activar o desactivar los cache internos del
procesador. El software StemWin requiere para su correcto funcionamiento que el cache este
deshabilitado, esto puede ser un problema cuando se necesita todo el desempeo del procesador y
su mximo rendimiento operativo.
Una vez que los llamados a las funciones primarias se han completado, podemos empezar a darle
forma a la presentacin de la pantalla, lo que no cambiar, los elementos estticos como nombres
ttulos y cuadros generales.
Para esto se ha definido la siguiente funcin.
void Pantalla_Inicio(void){
BSP_LCD_Clear(LCD_COLOR_WHITE); // Pinta la pantalla con el color blanco
BSP_LCD_SetTextColor(LCD_COLOR_BLACK); // El color del texto ser negro.
BSP_LCD_FillRect(0, 0, BSP_LCD_GetXSize(),80); // Se crea un cuadro negro
BSP_LCD_SetTextColor(LCD_COLOR_WHITE); // Color del texo pasa a blanco
BSP_LCD_SetBackColor(LCD_COLOR_BLACK); // Color del fondo pasa a negro
BSP_LCD_SetFont(&Font24); // La fuente sera de 24 pxeles para el ttulo
BSP_LCD_DisplayStringAt(0,15,(uint8_t *)"Firtec Argentina", CENTER_MODE);
BSP_LCD_SetFont(&Font12); // Cambia la fuente a 12 pxeles para subttulo
BSP_LCD_DisplayStringAt(0, 45, (uint8_t *)"Ejemplo de uso para el Touchscreen",
CENTER_MODE);
BSP_LCD_SetTextColor(LCD_COLOR_BLACK); // Color del texto y dibujos negro
BSP_LCD_DrawRect(11, 91, 22,102); // Dibuja un recuadro negro
}
Las funciones son bastante intuitivas, por ejemplo:
BSP_LCD_DrawRect(11, 91, 22,102)
Tiene los siguientes argumentos:
Coordenada X = 11, Coordenada Y = 91, Ancho del recuadro = 22, Altura del recuadro = 102.
La funcin BSP_LCD_DisplayStringAt(0, 45, (uint8_t *)" Texo",CENTER_MODE) se utiliza para
desplegar texto en la pantalla, tiene los siguientes argumentos.
Coordenada X = 0, Coordenada Y = 45, Luego el texto a mostrar y como se alinear, tres son las
opciones, CENTER_MODE, LEFT_MODE o RIGHT_MODE. (Centrado, alineado a la izquierda o
alineado a la derecha).
Si vuelve unas pginas hacia atrs y mira la imagen que muestra la pantalla que estamos creando
ver que hasta el momento solo tenemos los cuadros, los textos del ttulo, subttulo y colores de
fondo y letras, pero no hemos creado botones.
Para crear un botn nada mas simple que la funcin BSP_LCD_FillRect(60, 115, 190, 52), esta
funcin bsicamente crea y rellena un rectngulo con un color previamente definido, recuerde que
la funcin BSP_LCD_SetTextColor() define el color tanto para textos como para dibujos. La
funcin que completa el rectngulo tiene los siguientes argumentos:
Coordenada X = 60, Coordenada Y = 115, Ancho del recuadro = 190, Altura del recuadro = 52,
esto crea un recuadro slido de un color determinado en las coordenadas definidas del ancho y alto
especificado. Observe la siguiente imagen, suponga el el recuadro que acaba de crear es el negro
que se ve debajo del recuadro azul.
Lo siguiente ser crear el recuadro azul y que el recuadro negro parezca la sombra del primero.
Estas dos funciones cumplen con este trabajo.
BSP_LCD_SetTextColor(LCD_COLOR_BLUE);
BSP_LCD_FillRect(65, 110, 190, 50);
La primera cambia el color del pincel de trabajo a azul y la segunda desplaza ligeramente la
posicin del rectngulo lo que genera la ilusin de sombra debajo del rectngulo azul.
Para posicionar correctamente el texto sobre el botn solo basta con seleccionar el color del texto y
el color de fondo mas la posicin donde el mensaje ser puesto.
Las siguientes lneas de cdigo cumplen con este trabajo.
BSP_LCD_SetTextColor(LCD_COLOR_YELLOW);
BSP_LCD_SetBackColor(LCD_COLOR_BLUE);
BSP_LCD_SetFont(&Font20);
BSP_LCD_DisplayStringAt(120, 127, (uint8_t *)"LED|SI", LEFT_MODE);
En el proyecto se puede ver que hay dos indicadores circulares que reflejaran el estado de los LED's
fsicos. Circulo vaco para LED apagado y crculo lleno para LED encendido.
Primero cambiamos el color del pincel de trabajo, elegimos verde.
BSP_LCD_SetTextColor(LCD_COLOR_GREEN)
Luego creamos un crculo solido de color verde con la funcin que crea y llena crculos.
BSP_LCD_FillCircle(340, 135, 20)
Luego simplemente creamos otro crculo del mismo color del fondo (blanco en este caso) pero un
poco mas pequeo. Cambiamos al color blanco que es el color del fondo.
BSP_LCD_SetTextColor(LCD_COLOR_WHITE)
Y luego se crea el nuevo crculo en las mimas coordenadas X, Y pero de dimetro ligeramente
inferior, la idea es rellenar el centro con el color del fondo.
BSP_LCD_FillCircle(340, 135, 17)
Cuanto mas pequeo sea el crculo interno, mas grueso ser el trazo del contorno visible resultante.
Para cambiar de estado el LED virtual solo debemos pintar el circulo interior de color verde o
rojo segn el caso para mostrar el LED encendido.
Botones interactivos.
Para crear un botn interactivo es necesario utilizar el touch y poder detectar una accin en la
pantalla en un lugar especfico. En esta pantalla el touch es del tipo capacitivo, dos placas de vidrio
impregnadas con xido de indio y estao, al pasar una corriente elctrica por esta capa se carga con
una cantidad de electrones formando un condensador, la conductibilidad de la piel humana genera
una diferencia en la capacidad y midiendo esto se puede ubicar el lugar exacto de la perturbacin. Si
bien las pantallas resistivas son mas econmicas que las capacitivas, estas ltimas permiten el
multi-touch (detectar varios dedos en la pantalla), otro punto a considerar es que la resolucin es el
tamao del dedo mientras que en las resistivas la resolucin es a pxel. Sin embargo en las resistivas
cualquier objeto en contacto con la pantalla la activa, en las capacitivas no.
Lo primero que vamos hacer es detectar la presencia del touch con la funcin BSP_TS_Init().
status = BSP_TS_Init(BSP_LCD_GetXSize(), BSP_LCD_GetYSize());
if (status != TS_OK){
BSP_LCD_SetBackColor(LCD_COLOR_WHITE);
BSP_LCD_SetTextColor(LCD_COLOR_RED);
BSP_LCD_DisplayStringAt(0,BSP_LCD_GetYSize()-95,(uint8_t *)"Touchscreen
ERROR!!", CENTER_MODE);
while(1);}
Esto permite verificar que todas las libreras para el manejo del touch estn correctamente cargadas
ya que estamos solicitando a la pantalla que nos informe la geometra del touch. Todo el manejo del
touch se encuentra en los archivos stm32746g_discovery_ts.c y stm32746g_discovery_ts.h .
Todo el funcionamiento del programa esta centrado en un bucle infinito y lo primero es consultar
los campos de la estructura &TS_State contenida en el archivo stm32746g_discovery_ts.h,
obtenemos la coordenada X, Y y mediante el campo touchDetected podemos saber si la pantalla ha
sido tocada.
Una vez que la accin sobre la pantalla ha sido detectada debemos saber si la accin ha sido en un
lugar especfico, por ejemplo sobre un botn, para esto se acota la respuesta a una regin en la
siguiente lnea:
if ((( x >= 80) & (x <= 230)) & ((y >= 110) & ( y <= 148)))
Si esto es vlido, se cambia el estado de una bandera que usaremos como semforo indicador de
estado y saber en que paso del programa estamos. Se cambia el estado del LED virtual.
BSP_LCD_SetTextColor(LCD_COLOR_GREEN);
BSP_LCD_FillCircle(340, 135, 20);
Y tambin se activa el LED fsico.
HAL_GPIO_WritePin(GPIOI, GPIO_PIN_2, GPIO_PIN_SET);
Las siguientes lneas generan la ilusin de profundidad, como si el botn se hunde tapando la
sombra y cambia el texto en e botn.
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
BSP_LCD_FillRect(65, 110, 190, 50);
BSP_LCD_SetTextColor(LCD_COLOR_BLUE);
BSP_LCD_FillRect(60, 115, 190, 52);
BSP_LCD_SetTextColor(LCD_COLOR_YELLOW);
BSP_LCD_SetBackColor(LCD_COLOR_BLUE);
BSP_LCD_SetFont(&Font20);
BSP_LCD_DisplayStringAt(120,127,(uint8_t *)"LED|NO",LEFT_MODE);
Necesitamos saber cuando el usuario deja de presionar el botn, un bucle espera que la propia
estructura de control del touch mediante el campo touchDetected retorne 0 indicando que no hay
accin sobre la pantalla.
while(TS_State.touchDetected !=0)
BSP_TS_GetState(&TS_State);
Cuando la pantalla es liberada se cambia el estado de la bandera y se vuelve a pintar el botn en la
posicin, color y texto originales creando la ilusin de movimiento y profundidad.
A continuacin puede ver el texto completo que controla los dos botones y los LED's.
while (1){
BSP_TS_GetState(&TS_State);
x = TS_State.touchX[0];
y = TS_State.touchY[0];
if(TS_State.touchDetected)
{
if ((( x >= 80) & (x <= 230)) & ((y >= 110) & ( y <= 148))){
if(bandera == 0){
BSP_LCD_SetTextColor(LCD_COLOR_GREEN);
BSP_LCD_FillCircle(340, 135, 20);
HAL_GPIO_WritePin(GPIOI, GPIO_PIN_2, GPIO_PIN_SET);
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
BSP_LCD_FillRect(65, 110, 190, 50);
BSP_LCD_SetTextColor(LCD_COLOR_BLUE);
BSP_LCD_FillRect(60, 115, 190, 52);
BSP_LCD_SetTextColor(LCD_COLOR_YELLOW);
BSP_LCD_SetBackColor(LCD_COLOR_BLUE);
BSP_LCD_SetFont(&Font20);
BSP_LCD_DisplayStringAt(120,127,(uint8_t *)"LED|NO",
LEFT_MODE);
while(TS_State.touchDetected !=0)
BSP_TS_GetState(&TS_State);
BSP_LCD_SetTextColor(LCD_COLOR_BLACK);
BSP_LCD_FillRect(60, 115, 190, 52);
BSP_LCD_SetTextColor(LCD_COLOR_BLUE);
BSP_LCD_FillRect(65, 110, 190, 50);
BSP_LCD_SetTextColor(LCD_COLOR_YELLOW);
BSP_LCD_SetBackColor(LCD_COLOR_BLUE);
BSP_LCD_SetFont(&Font20);
BSP_LCD_DisplayStringAt(120, 127, (uint8_t *)"LED|NO",
LEFT_MODE);
bandera = 1;
}
else{
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
BSP_LCD_FillCircle(340, 135, 17);
HAL_GPIO_WritePin(GPIOI, GPIO_PIN_2,
GPIO_PIN_RESET);
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
BSP_LCD_FillRect(65, 110, 190, 50);
BSP_LCD_SetTextColor(LCD_COLOR_BLUE);
BSP_LCD_FillRect(60, 115, 190, 52);
BSP_LCD_SetTextColor(LCD_COLOR_YELLOW);
BSP_LCD_SetBackColor(LCD_COLOR_BLUE);
BSP_LCD_SetFont(&Font20);
BSP_LCD_DisplayStringAt(120, 127, (uint8_t *)"LED|
SI", LEFT_MODE);
while(TS_State.touchDetected !=0)
BSP_TS_GetState(&TS_State);
BSP_LCD_SetTextColor(LCD_COLOR_BLACK);
BSP_LCD_FillRect(60, 115, 190, 52);
BSP_LCD_SetTextColor(LCD_COLOR_BLUE);
BSP_LCD_FillRect(65, 110, 190, 50);
BSP_LCD_SetTextColor(LCD_COLOR_YELLOW);
BSP_LCD_SetBackColor(LCD_COLOR_BLUE);
BSP_LCD_SetFont(&Font20);
BSP_LCD_DisplayStringAt(120, 127, (uint8_t *)"LED|
SI", LEFT_MODE);
bandera = 0;
}
}
if ((( x >= 80) & (x <= 230)) & ((y >= 187) & ( y <= 230))){
if(b == 0){
BSP_LCD_SetTextColor(LCD_COLOR_RED);
BSP_LCD_FillCircle(340, 210, 20);
HAL_GPIO_WritePin(GPIOI, GPIO_PIN_3, GPIO_PIN_SET);
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
BSP_LCD_FillRect(65, 185, 190, 50);
BSP_LCD_SetTextColor(LCD_COLOR_BLUE);
BSP_LCD_FillRect(60, 190, 190, 52);
BSP_LCD_SetTextColor(LCD_COLOR_YELLOW);
BSP_LCD_SetBackColor(LCD_COLOR_BLUE);
BSP_LCD_SetFont(&Font20);
BSP_LCD_DisplayStringAt(120, 200,(uint8_t *)"LED|NO", LEFT_MODE);
while(TS_State.touchDetected !=0)
BSP_TS_GetState(&TS_State);
BSP_LCD_SetTextColor(LCD_COLOR_BLACK);
BSP_LCD_FillRect(60, 190, 190, 52);
BSP_LCD_SetTextColor(LCD_COLOR_BLUE);
BSP_LCD_FillRect(65, 185, 190, 50);
BSP_LCD_SetTextColor(LCD_COLOR_YELLOW);
BSP_LCD_SetBackColor(LCD_COLOR_BLUE);
BSP_LCD_SetFont(&Font20);
BSP_LCD_DisplayStringAt(120, 200, (uint8_t *)"LED|NO", LEFT_MODE);
b = 1;
}
else{
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
BSP_LCD_FillCircle(340, 210, 17);
HAL_GPIO_WritePin(GPIOI, GPIO_PIN_3, GPIO_PIN_RESET);
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
BSP_LCD_FillRect(65, 185, 190, 50);
BSP_LCD_SetTextColor(LCD_COLOR_BLUE);
BSP_LCD_FillRect(60, 190, 190, 52);
BSP_LCD_SetTextColor(LCD_COLOR_YELLOW);
BSP_LCD_SetBackColor(LCD_COLOR_BLUE);
BSP_LCD_SetFont(&Font20);
BSP_LCD_DisplayStringAt(120, 200, (uint8_t *)"LED|SI",
LEFT_MODE);
while(TS_State.touchDetected !=0)
BSP_TS_GetState(&TS_State);
BSP_LCD_SetTextColor(LCD_COLOR_BLACK);
BSP_LCD_FillRect(60, 190, 190, 52);
BSP_LCD_SetTextColor(LCD_COLOR_BLUE);
BSP_LCD_FillRect(65, 185, 190, 50);
BSP_LCD_SetTextColor(LCD_COLOR_YELLOW);
BSP_LCD_SetBackColor(LCD_COLOR_BLUE);
BSP_LCD_SetFont(&Font20);
BSP_LCD_DisplayStringAt(120, 200, (uint8_t *)"LED|SI",
LEFT_MODE);
b = 0;
}
}
}
}
}
Capitulo III.
Ejemplo de lectura de TAG RFID.
RFID o identificacin por radiofrecuencia es un sistema de almacenamiento y recuperacin de datos
remoto que usa dispositivos denominados etiquetas, tarjetas, transpondedores o Tags RFID. El
propsito fundamental de la tecnologa RFID es transmitir la identidad de un objeto o persona
mediante ondas de radio.
Las etiquetas RFID o Tags, son unos dispositivos pequeos, similares a una calco autoadesiva, que
pueden ser adheridas o incorporadas a un producto, un animal o una persona. Contiene la antena
para permitirles recibir y responder a peticiones por radiofrecuencia desde un emisor-receptor
RFID. Las etiquetas pasivas no necesitan alimentacin elctrica interna, mientras que las activas s.
Una de las ventajas del uso de radiofrecuencia en lugar de otras tecnologas, es que no se requiere
visin directa entre emisor y receptor.
