Jogo da velha com base em STONE TFT LCD e STM32

Resumo

Tic-tac-toe é um jogo jogado em uma grade de 3 por 3, semelhante ao gobang. Recebe esse nome porque o tabuleiro geralmente não desenha bordas e as linhas de grade são organizadas em um jogo da velha. As ferramentas necessárias para o jogo são apenas papel e caneta. Em seguida, dois jogadores representando O e X se revezam para deixar marcas na grade. Quaisquer três marcas formam uma linha reta, que é a vencedora.

Este artigo é usar o microcontrolador STM32 e o display LCD STONE para desenvolver um jogo simples de jogo da velha.

Materiais necessários para o experimento

• Visor LCD STONE STWI070WT-01 TFT
• Placa STM32

O princípio do sistema

Especifique que o primeiro toque na tela deve ser O, o segundo toque na tela é X, vem fazendo este ciclo. Defina 8 matrizes para armazenar o número de O e X em cada linha, coluna e diagonal de cada grade, desde que haja três da mesma marca é a vitória, então haverá uma caixa vermelha piscando para provar a vitória do linha, coluna ou diagonal e, em seguida, toque em redefinir para iniciar o jogo novamente.

A seguir está o fluxograma:

Design de hardware do sistema STM32 e STONE LCD Display

(A) Visor LCD STONE

1. Design de hardware do “jogo da velha”

Use o display STONE LCD da Beijing STONE Technology co., Ltd, o modelo é STWI070WT-01, com um display TFT integrado e controlador de toque.

1.  STVC070WT-01 recursos do produto

Parâmetro Físico
Tamanho	7 polegadas
Resolução	800 × RGB × 480
Espaçamento de pixels	0.0642 (L) × 0.1790 (A) mm
Cor	262,144 cores (18 bits)
Área de visualização	154.08 (L) × 85.92 (A) mm
exibição Dimension	186.4mmx105.5mm
Dimensão total	186.4 mm x 105.5 mm x 17.4 mm (tipo padrão) 186.4 mm x 105.5 mm x 23.8 mm (com porta Ethernet)
Peso líquido	300g
Ecrã
Tipo de luz de fundo	CONDUZIU
Brilho	300cd/m2 (o brilho pode ser ajustável em 100 níveis)
Contraste	500:1
Vida da luz de fundo	300,000 horas
Ângulo de visão	70 ° / 70 ° / 50 ° / 70 ° (L / R / U / D)
Painel TFT	Um painel de classe da indústria
Tela sensível ao toque	Toque de resistência de 4 fios/toque capacitivo/sem tela de toque
Modo de tela:	Digital
Subcontratante
CPU	Cortex A8
Taxa de atualização	1G Hz
Taxa máxima de quadros	60 FPS
Interface
Interface Serial	Nível RS232 / RS422 / RS485 / TTL
Interface Ethernet	10M / 100M (opcional)
Interface sem fio	Wi-Fi / Bluetooth (opcional)
Download de arquivo de projeto	Porta USB 2.0 ou disco de armazenamento U
Fonte de alimentação do laboratório
Tensão nominal	+ 12V DC ou + 5V DC
Faixa de tensão permitida	+ 7V DC… + 28V DC ou + 5V DC
Máx. transitórios permitidos	+ 28V
Tempo entre dois transientes	50 segundos mínimo
Fusível Interno	2A fusível de auto-recuperação
Consumo de energia	3.0 W
Condições ambientais
Máx. temperatura ambiente permitidaOperaçãoArmazenamento	-20℃~ +70℃-30℃~ +80℃
Humidade relativaOperaçãoArmazenamento	55°C,85%60°C,90%
Carregamento de choqueOperaçãoArmazenamento	15 g/11 mseg 25 g/6 mseg
vibraçãoOperaçãoArmazenamento	0.035 mm (10 – 58 Hz)/ 1 g (58 – 500 Hz) 3.5 mm (5 – 8,5 Hz)/ 1 g (8.5 – 500 Hz)
Pressão barométricaOperaçãoArmazenamento	706 a 1030 hPa581 a 1030 hPa
Imunidade a ruídos
Descarga estática (descarga de contato/descarga de ar)	EN 61000-4-2 6 kV / 8 kV
Irradiação RF	EN 61000-4-310 V/m, 80% AM1 kHz
Modulação de pulso	ENV 50204900 MHz ± 5 MHz 10 V/mef., 50% ED, 200 Hz
Condução RF	EN 61000-4-6150 kHz – 80 MHz 10 V, 80% AM, 1 kHz
Interferência de explosãoLinhas de alimentaçãoLinhas de dados de processoLinhas de sinal	EN 61000-4-42kV2kV1kV
Dispositivo de suporte
Porta UART	SuporteRS232/RS422/RS485/TTL
Porta de rede	Suporte Porta Ethernet/Wi-Fi/Bluetooth
Memória flash	Suporte Padrão 256 MB, Estenda 1 GB ou 2 GB
Cigarra	Suporte
RTC	Suporte
Porta USB	SupportOnline Download por cabo USB
Interface de disco de armazenamento U	Support.Offline Baixar ou copiar dados do usuário
Tela sensível ao toque	Resistência de 4 fios / capacitiva
Fonte de vetor	Formato TTF padrão
Imagem	Suporte ao formato PNG / JPG / BMP / SVG / GIF
Interface de Áudio	Suporte ao formato WAVO comprimento de um único arquivo de áudio não é limitado, teoricamente até 4096 arquivos de áudio, a potência do alto-falante é de 8 ohms 2 watts ou 4 ohms 3 watts
Conjunto de Comandos	Conjuntos de comandos simplificados e unificados

Memória
Memória flash	256 MB padrão, extensão de 1 GB ou 2 GB
Quantidade de memória para imagem	De acordo com a capacidade da imagem, sugira o formato “PNG, BMP, JPG, SVG, GIF”.

(B) placa STM32

Usando uma placa STM32, o chip do STM32 é o CKS32F303.

A família STM32 de núcleos ARM Cortex-M0, M0 +, M3, M4 e M7 foi projetada para aplicações embarcadas que requerem alto desempenho, baixo custo e baixo consumo de energia.

• Fonte de alimentação 2.0V-3.6V
• Pinos de E / S compatíveis com 5 V
• Excelente modo de relógio seguro
• Modo de baixo consumo com função de despertar
• Oscilador RC interno
• Circuito de reinicialização embutido
• Faixa de temperatura operacional.
• -40 ° C a + 85 ° C ou 105 ° C

Projeto de software do sistema

O processo de desenvolvimento do display STM32 e STONE LCD

1: crie o projeto e carregue as imagens necessárias no projeto.

2: usar o software Stone-designer para criar relacionamentos associados dinamicamente; os principais controles são: “Botão”, “imagem”;

3: simulação e compilação de software para gerar arquivos executáveis.

4: o display LCD é conectado ao PC via USB e copia o arquivo executável para a tela.

Primeiro crie um novo projeto conforme mostrado abaixo.

Em segundo lugar, importe todas as imagens para o recurso

Em seguida, defina os controles de botão para cada grade e torne os botões invisíveis. 

Não se esqueça de definir o botão de reset!

O efeito finalizado é mostrado abaixo:

Depois disso, adicione controles de imagem a cada grade da mesma maneira e defina-os como imagens brancas.

Por fim, adicione o controle gif e defina-o como invisível.

As partes do efeito acabado são mostradas abaixo:

Diagrama de conexão do circuito

Compartilhamento de código

/ * Inclui —————————————————————— * / 

#incluir “stm32f0xx_hal.h” 

#include “Uart.h” 

#inclui “string.h” 

#incluir “ws2812.h” 

#incluir “IWDG.h” 

RGB_COLOR USER_RGB_COLOR; 

Unsigned char TX_Mode = 1; // Sinalizador de tipo de transmissão bit 1: 232 0: TTL 

char não assinado BLINK_2 = 0; 

caractere unsigned RX3_BUF [32]; // Buffer de recepção de três níveis personalizado 

# define BUTTON1 0x81 

# define BUTTON2 0x82 

# define BUTTON3 0x83 

# define BUTTON4 0x84 

# define BUTTON5 0x85 

# define BUTTON6 0x86 

# define BUTTON7 0x87 

# define BUTTON8 0x88 

# define BUTTON9 0x89 

# define BUTTON0 0x8A 

#define LIMPAR 0x8E 

sem sinal int r_flag1 = 0; 

sem sinal int quan [4] [2] = {0}; 

não assinado int cha [4] [2] = {0}; 

sem sinal int quan_hang1 = 0; 

sem sinal int quan_hang2 = 0; 

sem sinal int quan_hang3 = 0; 

sem sinal int quan_lie1 = 0; 

sem sinal int quan_lie2 = 0; 

sem sinal int quan_lie3 = 0; 

sem sinal int quan_zuoxia = 0; 

sem sinal int quan_youxia = 0; 

sem sinal int cha_hang1 = 0; 

sem sinal int cha_hang2 = 0; 

sem sinal int cha_hang3 = 0; 

sem sinal int cha_lie1 = 0; 

sem sinal int cha_lie2 = 0; 

sem sinal int cha_lie3 = 0; 

sem sinal int cha_zuoxia = 0; 

sem sinal int cha_youxia = 0; // sem sinal int r_flag10 = 0; 

void SystemClock_Config (void); 

void Error_Handler (void); 

estático void MX_GPIO_Init (void); 

int main (void) 

{ 

uint8_t cor_buf = 0; 

// Seleção de Função 

/ * Reinicializa todos os periféricos, inicializa a interface Flash e o Systick. * / 

HAL_Init (); 

/ * Configure o relógio do sistema * / 

SystemClock_Config (); 

/ * Inicializar todos os periféricos configurados * / 

MX_GPIO_Init (); 

TX_Mode = HAL_GPIO_ReadPin (GPIOA, GPIO_PIN_4); 

if (TX_Mode) 

MX_USART1_UART_Init (); 

// 232 Inicialização 

outro 

MX_USART1_UART_Init2 (); 

// Inicialização TTl 

enquanto (1) 

{ 

if (TX_Mode! = HAL_GPIO_ReadPin (GPIOA, GPIO_PIN_4)) 

HAL_NVIC_SystemReset (); 

// Reversão do jumper, reinicialização e reinicialização 

if (MNG_USART1.RX_OVER_FLG == TRUE) 

// 

Bit de sinalizador de recebimento de dados seriais 

{ 

RX3_BUF [0] = MNG_USART1.RX_BUF [7]; 

// Método 2: Obter nome de controle de comprimento fixo 

RX3_BUF [1] = MNG_USART1.RX_BUF [8]; 

RX3_BUF [2] = MNG_USART1.RX_BUF [9]; 

RX3_BUF [3] = MNG_USART1.RX_BUF [10]; 

RX3_BUF [4] = MNG_USART1.RX_BUF [11]; 

RX3_BUF [5] = MNG_USART1.RX_BUF [12]; 

RX3_BUF [6] = MNG_USART1.RX_BUF [13]; 

//RX3_BUF[7]=MNG_USART1.RX_BUF[14]; 

if ((strcmp (“button1”, (const char *) RX3_BUF)) == 0) 

// Selecione o controle

{ 

cor_buf = BOTÃO1; 

}

if ((strcmp (“button2”, (const char *) RX3_BUF)) == 0) 

{ 

cor_buf = BOTÃO2; 

}

if ((strcmp (“button3”, (const char *) RX3_BUF)) == 0) 

{ 

cor_buf = BOTÃO3; 

}

if ((strcmp (“button4”, (const char *) RX3_BUF)) == 0) 

{ 

cor_buf = BOTÃO4; 

}

if ((strcmp (“button5”, (const char *) RX3_BUF)) == 0) 

{ 

cor_buf = BOTÃO5; 

}

if ((strcmp (“button6”, (const char *) RX3_BUF)) == 0) 

{ 

cor_buf = BOTÃO6; 

}

if ((strcmp (“button7”, (const char *) RX3_BUF)) == 0) 

{ 

cor_buf = BOTÃO7; 

}

if ((strcmp (“button8”, (const char *) RX3_BUF)) == 0) 

{ 

cor_buf = BOTÃO8; 

}

if ((strcmp (“button9”, (const char *) RX3_BUF)) == 0) 

{ 

cor_buf = BOTÃO9; 

}

if ((strcmp (“button0”, (const char *) RX3_BUF)) == 0) 

{ 

cor_buf = BOTÃO0; 

}

alternar (color_buf) 

{ 

caso BOTÃO1: 

// if (r_flag1 == 0) 

if ((r_flag1 == 0) && (MNG_USART1.RX_BUF [14] == 0x02)) 

{ 

memset (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

r_flag1 ^ = 1; 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” definir_imagem \ ”, \” tipo \ ”: \” imagem \ ”, \” widget \ ”: \” imagem2 \ ”, \” imagem \ ”: \” círculo \ ”}> ET”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

r_flag1 ^ = 1; 

quan_hang1 ++; 

quan_lie1 ++; 

quan_youxia ++;  

// memset (RX3_BUF, 0,7); 

//memset(MNG_USART1.RX_BUF,0,USART1_RX_LEN); 

cor_buf = LIMPAR; 

}

else if ((r_flag1 == 1) && (MNG_USART1.RX_BUF [14] == 0x02)) 

{ 

memset (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” definir_imagem \ ”, \” tipo \ ”: \” imagem \ ”, \” widget \ ”: \” imagem2 \ ”, \” imagem \ ”: \” x \ ”}> ET”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

r_flag1 = 0; 

cha_hang1 ++; 

cha_lie1 ++; 

cha_youxia ++; 

// memset (RX3_BUF, 0,7); 

cor_buf = LIMPAR; 

}

// r_flag1 = 1; 

break; 

caso BOTÃO2: 

if ((r_flag1 == 0) && (MNG_USART1.RX_BUF [14] == 0x02)) 

{ 

memset (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” definir_imagem \ ”, \” tipo \ ”: \” imagem \ ”, \” widget \ ”: \” imagem3 \ ”, \” imagem \ ”: \” círculo \ ”}> ET”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

r_flag1 = 1; 

quan_hang1 ++; 

quan_lie2 ++; 

// memset (RX3_BUF, 0,7); 

cor_buf = LIMPAR; 

}

else if ((r_flag1 == 1) && (MNG_USART1.RX_BUF [14] == 0x02)) 

{ 

memset (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” definir_imagem \ ”, \” tipo \ ”: \” imagem \ ”, \” widget \ ”: \” imagem3 \ ”, \” imagem \ ”: \” x \ ”}> ET”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

r_flag1 = 0; 

cha_hang1 ++; 

cha_lie2 ++; 

// memset (RX3_BUF, 0,7); 

cor_buf = LIMPAR; 

}

break; 

caso BOTÃO3: 

if ((r_flag1 == 0) && (MNG_USART1.RX_BUF [14] == 0x02)) 

{ 

memset (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” definir_imagem \ ”, \” tipo \ ”: \” imagem \ ”, \” widget \ ”: \” imagem4 \ ”, \” imagem \ ”: \” círculo \ ”}> ET”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

r_flag1 = 1; 

quan_hang1 ++; 

quan_lie3 ++; 

quan_zuoxia ++; 

// memset (RX3_BUF, 0,7); 

cor_buf = LIMPAR; 

}

else if ((r_flag1 == 1) && (MNG_USART1.RX_BUF [14] == 0x02)) 

{ 

memset (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” definir_imagem \ ”, \” tipo \ ”: \” imagem \ ”, \” widget \ ”: \” imagem4 \ ”, \” imagem \ ”: \” x \ ”}> ET”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

r_flag1 = 0; 

cha_hang1 ++; 

cha_lie3 ++; 

cha_zuoxia ++; 

// memset (RX3_BUF, 0,7); 

cor_buf = LIMPAR; 

}

break; 

caso BOTÃO4: 

if ((r_flag1 == 0) && (MNG_USART1.RX_BUF [14] == 0x02)) 

{ 

memset (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” definir_imagem \ ”, \” tipo \ ”: \” imagem \ ”, \” widget \ ”: \” imagem5 \ ”, \” imagem \ ”: \” círculo \ ”}> ET”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

r_flag1 = 1; 

quan_hang2 ++; 

quan_lie1 ++; 

// memset (RX3_BUF, 0,7); 

// r_flag10 = 1; 

cor_buf = LIMPAR; 

}

else if ((r_flag1 == 1) && (MNG_USART1.RX_BUF [14] == 0x02)) 

{ 

memset (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” definir_imagem \ ”, \” tipo \ ”: \” imagem \ ”, \” widget \ ”: \” imagem5 \ ”, \” imagem \ ”: \” x \ ”}> ET”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

r_flag1 = 0; 

cha_hang2 ++; 

cha_lie1 ++; 

// memset (RX3_BUF, 0,7); 

cor_buf = LIMPAR; 

}

break; 

caso BOTÃO5: 

if ((r_flag1 == 0) && (MNG_USART1.RX_BUF [14] == 0x02)) 

{ 

memset (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” definir_imagem \ ”, \” tipo \ ”: \” imagem \ ”, \” widget \ ”: \” imagem6 \ ”, \” imagem \ ”: \” círculo \ ”}> ET”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

r_flag1 = 1; 

quan_hang2 ++; 

quan_lie2 ++; 

quan_zuoxia ++; 

quan_youxia ++; 

// memset (RX3_BUF, 0,7); 

cor_buf = LIMPAR; 

}

else if ((r_flag1 == 1) && (MNG_USART1.RX_BUF [14] == 0x02)) 

{ 

memset (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” definir_imagem \ ”, \” tipo \ ”: \” imagem \ ”, \” widget \ ”: \” imagem6 \ ”, \” imagem \ ”: \” x \ ”}> ET”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

r_flag1 = 0; 

cha_hang2 ++; 

cha_lie2 ++; 

cha_zuoxia ++; 

cha_youxia ++; 

// memset (RX3_BUF, 0,7); 

cor_buf = LIMPAR; 

}

break; 

caso BOTÃO6: 

if ((r_flag1 == 0) && (MNG_USART1.RX_BUF [14] == 0x02)) 

{ 

memset (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” definir_imagem \ ”, \” tipo \ ”: \” imagem \ ”, \” widget \ ”: \” imagem7 \ ”, \” imagem \ ”: \” círculo \ ”}> ET”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

r_flag1 = 1; 

quan_hang2 ++; 

quan_lie3 ++; 

// memset (RX3_BUF, 0,7); 

cor_buf = LIMPAR; 

}

else if ((r_flag1 == 1) && (MNG_USART1.RX_BUF [14] == 0x02))

{ 

memset (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” definir_imagem \ ”, \” tipo \ ”: \” imagem \ ”, \” widget \ ”: \” imagem7 \ ”, \” imagem \ ”: \” x \ ”}> ET”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

r_flag1 = 0; 

cha_hang2 ++; 

cha_lie3 ++; 

// memset (RX3_BUF, 0,7); 

cor_buf = LIMPAR; 

}

break; 

caso BOTÃO7: 

if ((r_flag1 == 0) && (MNG_USART1.RX_BUF [14] == 0x02)) 

{ 

memset (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” definir_imagem \ ”, \” tipo \ ”: \” imagem \ ”, \” widget \ ”: \” imagem8 \ ”, \” imagem \ ”: \” círculo \ ”}> ET”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

r_flag1 = 1; 

quan_hang3 ++; 

quan_lie1 ++; 

quan_zuoxia ++; 

// memset (RX3_BUF, 0,7); 

cor_buf = LIMPAR; 

}

else if ((r_flag1 == 1) && (MNG_USART1.RX_BUF [14] == 0x02)) 

{ 

memset (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” definir_imagem \ ”, \” tipo \ ”: \” imagem \ ”, \” widget \ ”: \” imagem8 \ ”, \” imagem \ ”: \” x \ ”}> ET”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

r_flag1 = 0; 

cha_hang3 ++; 

cha_lie1 ++; 

cha_zuoxia ++; 

// memset (RX3_BUF, 0,7); 

cor_buf = LIMPAR; 

}

break; 

caso BOTÃO8: 

if ((r_flag1 == 0) && (MNG_USART1.RX_BUF [14] == 0x02)) 

{ 

memset (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” definir_imagem \ ”, \” tipo \ ”: \” imagem \ ”, \” widget \ ”: \” imagem9 \ ”, \” imagem \ ”: \” círculo \ ”}> ET”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

r_flag1 = 1; 

quan_hang3 ++; 

quan_lie2 ++; 

// memset (RX3_BUF, 0,7); 

cor_buf = LIMPAR; 

}

else if ((r_flag1 == 1) && (MNG_USART1.RX_BUF [14] == 0x02)) 

{ 

memset (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” definir_imagem \ ”, \” tipo \ ”: \” imagem \ ”, \” widget \ ”: \” imagem9 \ ”, \” imagem \ ”: \” x \ ”}> ET”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

r_flag1 = 0; 

cha_hang3 ++; 

cha_lie2 ++; 

// memset (RX3_BUF, 0,7); 

cor_buf = LIMPAR; 

}

break; 

caso BOTÃO9: 

if ((r_flag1 == 0) && (MNG_USART1.RX_BUF [14] == 0x02)) 

{ 

memset (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” definir_imagem \ ”, \” tipo \ ”: \” imagem \ ”, \” widget \ ”: \” imagem10 \ ”, \” imagem \ ”: \” círculo \ ”}> ET”);

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

r_flag1 = 1; 

quan_hang3 ++; 

quan_lie3 ++; 

quan_youxia ++; 

// memset (RX3_BUF, 0,7); 

cor_buf = LIMPAR; 

}

else if ((r_flag1 == 1) && (MNG_USART1.RX_BUF [14] == 0x02)) 

{ 

memset (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” definir_imagem \ ”, \” tipo \ ”: \” imagem \ ”, \” widget \ ”: \” imagem10 \ ”, \” imagem \ ”: \” x \ ”}> ET”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

r_flag1 = 0; 

cha_hang3 ++; 

cha_lie3 ++; 

cha_youxia ++; 

// memset (RX3_BUF, 0,7); 

cor_buf = LIMPAR; 

}

break; 

caso BOTÃO0: 

r_flag1 = 0; 

quan_hang1=quan_hang2=quan_hang3=cha_hang1=cha_hang2=cha_hang3=0; 

quan_lie1=quan_lie2=quan_lie3=cha_lie1=cha_lie2=cha_lie3=0; 

quan_zuoxia = quan_youxia = cha_zuoxia = cha_youxia = 0; 

memset (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” definir_imagem \ ”, \” tipo \ ”: \” imagem \ ”, \” widget \ ”: \” imagem2 \ ”, \” imagem \ ”: \” bai \ ”}> ET”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

memset (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” definir_imagem \ ”, \” tipo \ ”: \” imagem \ ”, \” widget \ ”: \” imagem3 \ ”, \” imagem \ ”: \” bai \ ”}> ET”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

memset (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” definir_imagem \ ”, \” tipo \ ”: \” imagem \ ”, \” widget \ ”: \” imagem4 \ ”, \” imagem \ ”: \” bai \ ”}> ET”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

memset (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” definir_imagem \ ”, \” tipo \ ”: \” imagem \ ”, \” widget \ ”: \” imagem5 \ ”, \” imagem \ ”: \” bai \ ”}> ET”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

memset (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” definir_imagem \ ”, \” tipo \ ”: \” imagem \ ”, \” widget \ ”: \” imagem6 \ ”, \” imagem \ ”: \” bai \ ”}> ET”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

memset (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” definir_imagem \ ”, \” tipo \ ”: \” imagem \ ”, \” widget \ ”: \” imagem7 \ ”, \” imagem \ ”: \” bai \ ”}> ET”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

memset (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” definir_imagem \ ”, \” tipo \ ”: \” imagem \ ”, \” widget \ ”: \” imagem8 \ ”, \” imagem \ ”: \” bai \ ”}> ET”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

memset (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” definir_imagem \ ”, \” tipo \ ”: \” imagem \ ”, \” widget \ ”: \” imagem9 \ ”, \” imagem \ ”: \” bai \ ”}> ET”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1);

memset (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” definir_imagem \ ”, \” tipo \ ”: \” imagem \ ”, \” widget \ ”: \” imagem10 \ ”, \” imagem \ ”: \” bai \ ”}> ET”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

memset (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” set_visible \ ”, \” digite \ ”: \” widget \ ”, \” widget \ ”: \” gif4 \ ”, \” visível \ ”: false}> ET ”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

memset (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” set_visible \ ”, \” digite \ ”: \” widget \ ”, \” widget \ ”: \” gif5 \ ”, \” visível \ ”: false}> ET ”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

memset (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” set_visible \ ”, \” digite \ ”: \” widget \ ”, \” widget \ ”: \” gif6 \ ”, \” visível \ ”: false}> ET ”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

memset (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” set_visible \ ”, \” digite \ ”: \” widget \ ”, \” widget \ ”: \” gif7 \ ”, \” visível \ ”: false}> ET ”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

memset (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” set_visible \ ”, \” digite \ ”: \” widget \ ”, \” widget \ ”: \” gif8 \ ”, \” visível \ ”: false}> ET ”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

memset (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” set_visible \ ”, \” digite \ ”: \” widget \ ”, \” widget \ ”: \” gif9 \ ”, \” visível \ ”: false}> ET ”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

memset (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” set_visible \ ”, \” digite \ ”: \” widget \ ”, \” widget \ ”: \” gif10 \ ”, \” visível \ ”: false}> ET ”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

memset (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” set_visible \ ”, \” digite \ ”: \” widget \ ”, \” widget \ ”: \” gif11 \ ”, \” visível \ ”: false}> ET ”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

// memset (RX3_BUF, 0,7); 

memset (MNG_USART1.RX_BUF, 0, USART1_RX_LEN); 

break; 

default: 

MNG_USART1.RX_OVER_FLG = FALSO; 

break; 

}

//////////////////////////////////////////////////////// //////////////////// 

if ((quan_hang1 == 3) || (cha_hang1 == 3)) 

{ 

memset (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” set_visible \ ”, \” digite \ ”: \” widget \ ”, \” widget \ ”: \” gif4 \ ”, \” visível \ ”: true}> ET ”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

quan_hang1=quan_hang2=quan_hang3=cha_hang1=cha_hang2=cha_hang3=0; 

quan_lie1=quan_lie2=quan_lie3=cha_lie1=cha_lie2=cha_lie3=0; 

quan_zuoxia = quan_youxia = cha_zuoxia = cha_youxia = 0; 

}

else if ((quan_hang2 == 3) || (cha_hang2 == 3)) 

{ 

memset (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” set_visible \ ”, \” digite \ ”: \” widget \ ”, \” widget \ ”: \” gif5 \ ”, \” visível \ ”: true}> ET ”);

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

quan_hang1=quan_hang2=quan_hang3=cha_hang1=cha_hang2=cha_hang3=0; 

quan_lie1=quan_lie2=quan_lie3=cha_lie1=cha_lie2=cha_lie3=0; 

quan_zuoxia = quan_youxia = cha_zuoxia = cha_youxia = 0; 

}

else if ((quan_hang3 == 3) || (cha_hang3 == 3)) 

{ 

memset (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” set_visible \ ”, \” digite \ ”: \” widget \ ”, \” widget \ ”: \” gif6 \ ”, \” visível \ ”: true}> ET ”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

quan_hang1=quan_hang2=quan_hang3=cha_hang1=cha_hang2=cha_hang3=0; 

quan_lie1=quan_lie2=quan_lie3=cha_lie1=cha_lie2=cha_lie3=0; 

quan_zuoxia = quan_youxia = cha_zuoxia = cha_youxia = 0; 

}

else if ((quan_lie1 == 3) || (cha_lie1 == 3)) 

{ 

memset (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” set_visible \ ”, \” digite \ ”: \” widget \ ”, \” widget \ ”: \” gif7 \ ”, \” visível \ ”: true}> ET ”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

quan_hang1=quan_hang2=quan_hang3=cha_hang1=cha_hang2=cha_hang3=0; 

quan_lie1=quan_lie2=quan_lie3=cha_lie1=cha_lie2=cha_lie3=0; 

quan_zuoxia = quan_youxia = cha_zuoxia = cha_youxia = 0; 

}

else if ((quan_lie2 == 3) || (cha_lie2 == 3)) 

{ 

memset (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” set_visible \ ”, \” digite \ ”: \” widget \ ”, \” widget \ ”: \” gif8 \ ”, \” visível \ ”: true}> ET ”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

quan_hang1=quan_hang2=quan_hang3=cha_hang1=cha_hang2=cha_hang3=0; 

quan_lie1=quan_lie2=quan_lie3=cha_lie1=cha_lie2=cha_lie3=0; 

quan_zuoxia = quan_youxia = cha_zuoxia = cha_youxia = 0; 

}

else if ((quan_lie3 == 3) || (cha_lie3 == 3)) 

{ 

memset (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” set_visible \ ”, \” digite \ ”: \” widget \ ”, \” widget \ ”: \” gif9 \ ”, \” visível \ ”: true}> ET ”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

quan_hang1=quan_hang2=quan_hang3=cha_hang1=cha_hang2=cha_hang3=0; 

quan_lie1=quan_lie2=quan_lie3=cha_lie1=cha_lie2=cha_lie3=0; 

quan_zuoxia = quan_youxia = cha_zuoxia = cha_youxia = 0; 

}

else if ((quan_zuoxia == 3) || (cha_zuoxia == 3)) 

{ 

memset (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” set_visible \ ”, \” digite \ ”: \” widget \ ”, \” widget \ ”: \” gif11 \ ”, \” visível \ ”: true}> ET ”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

quan_hang1=quan_hang2=quan_hang3=cha_hang1=cha_hang2=cha_hang3=0; 

quan_lie1=quan_lie2=quan_lie3=cha_lie1=cha_lie2=cha_lie3=0; 

quan_zuoxia = quan_youxia = cha_zuoxia = cha_youxia = 0; 

}

else if ((quan_youxia == 3) || (cha_youxia == 3)) 

{ 

memset (MNG_USART1.TX_BUF, 0, USART1_TX_LEN); 

sprintf ((char *) MNG_USART1.TX_BUF, 

“ST <{\” cmd_code \ ”: \” set_visible \ ”, \” digite \ ”: \” widget \ ”, \” widget \ ”: \” gif10 \ ”, \” visível \ ”: true}> ET ”); 

MNG_USART1.TX_Byte_Num = strlen ((const char *) MNG_USART1.TX_BUF); 

USART_TX_Data (MNG_USART1); 

quan_hang1=quan_hang2=quan_hang3=cha_hang1=cha_hang2=cha_hang3=0; 

quan_lie1=quan_lie2=quan_lie3=cha_lie1=cha_lie2=cha_lie3=0; 

quan_zuoxia = quan_youxia = cha_zuoxia = cha_youxia = 0; 

} 

MNG_USART1.RX_OVER_FLG = FALSO; 

} 

} 

}

/ ** Configuração do relógio do sistema 

*/

void SystemClock_Config (void) 

{ 

RCC_OscInitTypeDef RCC_OscInitStruct; 

RCC_ClkInitTypeDef RCC_ClkInitStruct; 

RCC_PeriphCLKInitTypeDef PeriphClkInit; 

RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI; 

RCC_OscInitStruct.HSIState = RCC_HSI_ON; 

RCC_OscInitStruct.HSICalibrationValue = 16; 

RCC_OscInitStruct.PLL.PLLSState = RCC_PLL_ON; 

RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSI; 

RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL12; 

RCC_OscInitStruct.PLL.PREDIV = RCC_PREDIV_DIV1; 

if (HAL_RCC_OscConfig (& RCC_OscInitStruct)! = HAL_OK) 

{ 

Error_Handler (); 

}

RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_SYSCLK 

| RCC_CLOCKTYPE_PCLK1; 

RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK; 

RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1; 

RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1; 

if (HAL_RCC_ClockConfig (& RCC_ClkInitStruct, FLASH_LATENCY_1)! = HAL_OK) 

{ 

Error_Handler (); 

}

PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_USART1; 

PeriphClkInit.Usart1ClockSelection = RCC_USART1CLKSOURCE_PCLK1; 

if (HAL_RCCEx_PeriphCLKConfig (& PeriphClkInit)! = HAL_OK) 

{ 

Error_Handler (); 

}

HAL_SYSTICK_Config (HAL_RCC_GetHCLKFreq () / 1000); 

HAL_SYSTICK_CLKSourceConfig (SYSTICK_CLKSOURCE_HCLK); 

/ * Configuração de interrupção SysTick_IRQn * / 

HAL_NVIC_SetPriority (SysTick_IRQn, 0, 0); 

}

/ ** Configuração de pinagem 

*/

static void MX_GPIO_Init (void) 

{ 

GPIO_InitTypeDef GPIO_InitStruct; 

/ * Habilitar relógio de portas GPIO * / 

__HAL_RCC_GPIOA_CLK_ENABLE (); 

GPIO_InitStruct.Pin = GPIO_PIN_7; 

GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP; 

GPIO_InitStruct.Pull=GPIO_PULLDOWN; 

GPIO_InitStruct.Speed ​​= GPIO_SPEED_FREQ_HIGH; 

HAL_GPIO_Init (GPIOA, & GPIO_InitStruct); 

GPIO_InitStruct.Pin = GPIO_PIN_4; 

GPIO_InitStruct.Mode = GPIO_MODE_INPUT; 

GPIO_InitStruct.Pull=GPIO_PULLUP; 

GPIO_InitStruct.Speed ​​= GPIO_SPEED_FREQ_HIGH; 

HAL_GPIO_Init (GPIOA, & GPIO_InitStruct); 

}

/ * CÓDIGO DE USUÁRIO BEGIN 4 * /

/ * FIM DO CÓDIGO DO USUÁRIO 4 * / 

/ **

* @brief Esta função é executada em caso de ocorrência de erro. 

* @param Nenhum 

* @retval Nenhum 

*/ 

void Error_Handler (void) 

{ 

/ * CÓDIGO DE USUÁRIO BEGIN Error_Handler * / 

/ * O usuário pode adicionar sua própria implementação para relatar o estado de retorno de erro HAL * / 

enquanto (1) 

{

}

/ * CÓDIGO DE USUÁRIO FIM Error_Handler * / 

}

#ifdef USE_FULL_ASSERT 

/ **

* @brief Relata o nome do arquivo de origem e o número da linha de origem 

* onde ocorreu o erro assert_param. 

* @param file: ponteiro para o nome do arquivo de origem 

* @param line: assert_param número da fonte da linha de erro 

* @retval Nenhum 

*/ 

void assert_failed (arquivo uint8_t *, linha uint32_t) 

{ 

/ * CÓDIGO DE USUÁRIO BEGIN 6 * / 

/ * O usuário pode adicionar sua própria implementação para relatar o nome do arquivo e o número da linha, 

ex: printf (“Valor de parâmetro errado: arquivo% s na linha% d \ r \ n”, arquivo, linha) * / 

/ * FIM DO CÓDIGO DO USUÁRIO 6 * / 

}

#fim se 

/ **

*@} 

*/ 

/ **

*@} 

*/

/ ************************* (C) COPYRIGHT STMicroelectronics ***** FIM DO ARQUIVO **** /

Resultados finais mostram

Fonte: Plato Data Intelligence