Sistemas Digitais e Arduino Aplicado

quinta-feira, 11 de março de 2021

EX31 - Partida e reversão de motor de indução com display TFT Touch 2.4″ por Arduino

A Partida direta com reversão, de motor de indução com Arduino destina-se a máquinas que partem em vazio ou com carga e permitindo a inversão do sentido de rotação em partidas normais (< 10 s). A codificação prevê o desligar o circuito através de acionamento de uma tecla do display TFT Touch 2.4″ no comando desligar, há mais dois acionamento um para ligar no sentido horário e outro anti-horário. Há ainda a sinalização para falha, painel energizado e indicação de sentido horário e anti-horário através do display.

O arquivo do código fonte Partida e reversão de motor de indução com display TFT Touch 2.4″ está disponível em: 21_02_13_Partida_reversão_motor _TFT_Touch_2.4″ _SRG (PDF).

O arquivo do diagrama elétrico Partida e reversão de motor de indução está disponível em: 21_02_25_Circuito_Partida_reversão_motor _TFT_Touch 2.4″ SRG (PDF).

quarta-feira, 10 de março de 2021

EX30 - Programação Arduino com "Display Touch Arduino Shield": Controle de acesso

Figura 01 - Tela de controle de acesso.

Esta atividade como objetivo construir o desenho de um painel de acesso com senha. Para fazer isso, inicializamos os botões que iremos utilizar para digitar a senha de acesso, fazemos isso através do método "Init Button" que recebe como parâmetros: Referência do objeto de acesso a tela, posição X na tela, posição Y na tela, altura, largura, cor da borda, cor de preenchimento do botão, cor de preenchimento do botão ao ser apertado, texto que deve ser escrito no botão e tamanho da fonte.

Temos também que definir o locar para escrever a senha de acesso na tela, para fazer isso, iremos criar um retângulo branco na tela, onde a string será escrita a medida em que os botões forem sendo pressionados. O resultado será semelhante ao da figura 01.

Figura 02 - Tela de acesso autorizado.

A leitura da tela é realizada através da função "Obter Toque", que é responsável por descobrir se a tela foi pressionada ou não, e além disso determinar em qual posição (x,y) a tela foi pressionada. Para determinarmos se de fato um clique na tela foi feito, utilizamos o bloco if e verificamos se a força feita é maior do que o valor mínimo determinado.
Se o botão tiver sido de fato pressionado, a variável pressed receberá o valor true, caso contrário terá como resultado false. esse valor será posteriormente utilizado em um bloco if onde caso o botão tenha sido realmente pressionado iremos além de atualizar a variável pressionado para true, obteremos as cordenadas x e y de onde foi feito o toque.

Figura 03 - Tela de acesso negado.

Temos também a função "Check Pressed" responsável por executar todos os comandos associados aos botões, sendo eles: escrever adicionar a senha digitos de 0 a 9; apagar o último caractere digitado; realizar uma tentativa de acesso ao sistema e mudar a animação do botão quando ele for pressionado.
Inicialmente, mudamos a animação de algum dos botões através da função "Draw Button", ao receber o parâmetro true altera a cor do botão para preto, que definimos no início do código através do "Init Button". Logo em seguida, chamamos uma função denominada "Espera Soltar".

Figura 04 - "Controle de acesso"

Dentro da função validar acesso, iremos realizar a validação da senha, comparando a senha digitada pelo usuário e a senha padrão. Para isso, iremos simplesmente comparar a nossa string senha com o define "SENHA VALIDA", caso o valor seja igual, mostramos a mensagem “Acesso Autorizado”, aguardamos um total de 3 segundos e voltamos a tela de acesso. Caso contrário mostramos a mensagem “Acesso Negado” aguardamos um total de 3 segundos e voltamos a tela de acesso.

Código do "Controle de acesso" do "Display Touch Arduino Shield" está disponível em: 21_03_17_Controle_de_acesso_com_"Display_Touch_Arduino_Shield".

Referência: Almeida, Danilo: << Primeiros passos shield lcd tft 2.4" touchscreen >>.

terça-feira, 9 de março de 2021

EX29 – Utilizando o Touch Screen para acionar LED's

O display TFT Touch 2.4″ para Arduino é um prático display com resolução de 320×240 pixels em formato de shield, ou seja, basta encaixar o display no Arduino, carregar a biblioteca e em poucos minutos você pode gerar textos e gráficos na tela, deixando o seu projeto mais atrativo.

   A conexão do display no Arduino não tem muito segredo, bastando prestar uma certa atenção para encaixar corretamente a placa no Arduino, conforme a imagem abaixo. O slot para cartão SD deve ficar do mesmo lado do conector USB.
   No caso do Arduino Uno, o correto seria você utilizar algum shield adicional para poder utilizar o display em conjunto com algum sensor ou módulo. Mesmo assim sobrariam 3 pinos para conexão desses componentes. A interface do cartão SPI não foi utilizada nesta aplicação, foram este pinos que foram utilizados para ligação dos LED's.
   Com o display calibrado, vamos montar um pequeno circuito com Arduino UNO e o display TFT 2.4″ para acionar leds conectados nas portas 10, 11, 12 e 13 do Arduino. Você pode substituir posteriormente os leds por relés, por exemplo, e criar um projeto de automação residencial. São inúmeras possibilidades.

Agora vamos utilizar o touch screen, simulando botões na tela para acionamento de portas. Você pode utilizar este programa como base para acionar as portas do Arduino ou efetuar a leitura de algum sensor. Carregue o programa no Arduino e você terá uma tela como essa, onde utilizamos as funções do touch screen nos botões do lado direito.

Código da "Touch Screen para acionar LED's" está disponível em: 21_03_24_"Touch_Screen_para_acionar_LED's".

segunda-feira, 8 de março de 2021

EX28 - Breakout Game com "Display Touch Arduino Shield"

Esta é uma versão pequena do clássico videogame de Breakout para Arduino UNO e tela LCD TFT (240x320 pixels), driver ILI9341 com comunicação paralela de 8 bits.

O game Breakout tem várias telas com diferentes linhas e colunas de blocos configuráveis, até oito linhas, com cada duas linhas de uma cor diferente, que podem ser ativadas ou desativadas com padrões diferentes. Usando uma única bola e o painel de toque, o jogador deve derrubar tantos blocos quanto possível usando as paredes e / ou a raquete abaixo para ricochetear a bola contra os blocos e eliminá-los. Se a raquete do jogador errar o rebote da bola, ele perderão uma vez. Cada bloco da linha ganha pontos diferentes.

Cada nível pode configurar o tamanho da raquete e o tamanho da bola. A velocidade da bola aumenta a cada golpe, você pode configurar a velocidade inicial para cada tela. Dependendo do ponto da raquete que atinge a bola, a velocidade horizontal também muda. Na programação você pode definir como novas telas com diferentes padrões de parede. Você pode definir também o padrão de parede é definido como uma matriz de 8x8 bits que corresponde a esta matriz de bits, que irá produzir esta parede, observe que ela é espelhada.

Como jogar: Segure o dispositivo com as mãos e use os dedos polegares sobre a tela para mover a raquete para a esquerda ou para a direita.

Hardware: Este projeto usa um display TFT LCD de 2,4 polegadas com Touchscreen resistiva de 4 fios e um leitor de cartão SD integrado.

Calibrando a tela de toque: Você deve calibrar a tela para que as informações de posição estejam corretas ao tocar na tela. A biblioteca MCUFriend_kbv fornece um exemplo com o nome "TouchScreen_Calibr_native". O exemplo envia os resultados para a porta serial. Inicie o monitor serial do Arduino IDE para que você possa copiar o código gerado pelo exemplo.

Siga as instruções na tela de toque, pressione e segure os marcadores de posição exibidos, que são destacados em branco. Depois de fazer todas as marcas de posição, a calibração da tela é enviada para você na tela de toque e pela porta serial. Para este projeto você precisa dos dados para a "calibração na posição retrato".

Animação: Para mover a imagem pela tela ao longo do tempo, é preciso usar uma velocidade estática e aplicá-la à posição de uma imagem a cada intervalo de tempo.

A resolução do ILI9341 é 240 x 320, portanto, precisamos de dois inteiros de 9 bits para fazer referência a um pixel na tela. Usando inteiros de 16 bits, deixa 6 bits livres para representar uma parte decimal. Chamamos esse número de expoente binário. E podemos usar esses seis bits para ter uma parte decimal variando de 0,000 a 0,63. Portanto, podemos usar matemática inteira evitando aritmética de ponto flutuante. Para obter a parte inteira do número, fazemos uma mudança aritmética para a direita.

Modo de demonstração: Remova o comentário da Diretriz de Definição e a raquete seguirá a bola.

O Código do "Breakout Game" com "Display Touch Arduino Shield" está disponível em: 21_03_17_Breakout-Game_com _com_Display_Touch_Arduino_Shield.

segunda-feira, 1 de março de 2021

Aula 11 - Esquema elétrico e programação Arduino da placa "Display Touch Arduino Shield"

Figura 01 - "Display Touch Arduino Shield"

A placa "Display Touch Arduino Shield" é construída a partir do display TFT de 2,4" que tem resolução de 320×240 pixels, com um esquema de cores de 18 bits que permite a exibição de até 262.000 tonalidades diferentes, tela touch resistiva e um slot para cartão microSD, tudo isso controlado pelo driver ILI9325. Seu formato de shield permite que você acesse todas as funções do display apenas encaixando a placa no Arduino. Com esse display podemos criar interfaces interativas e supervisionar dados em tempo real.

O shield Lcd 2.4″ possui a interface touchscreen resistiva por onde é possível interagir com a tela sem a necessidade de botões. A tela conta com um total de 13 pinos distribuídos entre alimentação, controle do touch e controle do display. Se você deseja adicionar sensores em conjunto com a tela, recomendo que utilize o Arduino Mega, pois ao acoplar o shield em um Arduino uno você não terá espaço nem pinos para conectar outros dispositivos.

Figura 02 - Pinos do
"Display Touch Arduino Shield"

Vamos dar uma olhada nas pinagens deste módulo de tela LCD TFT de 2,4 ”. Como você pode ver, existem 28 pinos que se encaixam perfeitamente em qualquer Arduino Uno / Arduino Mega. Uma pequena classificação desses pinos é fornecida na tabela abaixo.

Para utilizar o Display Touch Arduino com um Arduino Uno, simplesmente encaixe o display na placa. Um detalhe importante é que você deve utilizar algum material isolante para que o conector USB do Arduino não entre em contato com componentes e/ou trilhas da placa, causando algum curto-circuito.

Você também pode encontrar um slot de cartão SD na parte inferior do módulo mostrado acima, que pode ser usado para carregar um cartão SD com arquivos de imagem bmp, e essas imagens podem ser exibidas em nossa tela LCD TFT usando o programa Arduino.

A tabela 01 mostra os pinos utilizados pelo shield na conexão com um Arduino Uno. Esse TFT Shield com controlador ILI9325 e os programas aqui apresentados funcionam normalmente com o Arduino Uno ou Mega.

Display Shield TFT	Pino e função no Arduino
3,3 v, 5v e Gnd	Alimentação
LCD_RD /	A0 - LCD Control
LCD_WR /	A1 - LCD Control
LCD_RS / Touch_YP	A2 - LCD Control / Touch_Data
LCD_CS / Touch_XP	A3 - LCD Control / Touch_Data
LCD_RST	A4 - LCD Reset
	D0
	D1
LCD_D2	D2 - LCD Data
LCD_D3	D3 - LCD Data
LCD_D4	D4 - LCD Data
LCD_D5	D5 - LCD Data
LCD_D6	D6 - LCD Data
LCD_D7	D7 - LCD Data
LCD_D8 / Touch_YM	D8 - LCD Data / Touch_Data
LCD_D9 / Touch_XP	D9 - LCD Data/ Touch_Data
SD_CS	D10 - SD_Select
SD_DI	D11 - SD_Data
SD_DO	D12 - SD_Data
SD_SCK	D13 - SD_Clock

Os pinos podem ser classificados em quatro tipos: como pinos de comando, pinos de dados, pinos do cartão SD e pinos de alimentação. Não precisamos saber muito sobre o funcionamento detalhado desses pinos, pois eles serão cuidados por nossa biblioteca Arduino.

Outra coisa importante a se notar é o IC da interface, existem muitos tipos de módulos TFT disponíveis no mercado, desde o módulo Adafruit TFT LCD original até clones. Um programa que funciona perfeitamente para o seu Adafruit pode não funcionar da mesma forma para as outras placas. Os programas aqui foram desenvilvidos e tastado na placa usando o IC do driver ili9325. Você pode seguir o tutorial de interface TFT LCD com Arduino para experimentar alguns programas de exemplo básicos e se familiarizar com a tela LCD.

Manual com referências para o "Display Touch Arduino Shield" está disponível em: 21_03_01_Manual_"Display_Touch_Arduino_Shield".

quinta-feira, 18 de fevereiro de 2021

EX28 - Programa: Liga motor com botões no Arduino

O programa abaixo, liga, mantém e desliga o rele K1, que irá acionar o motor trifásico, com botões ligado na placa Arduino.

A primeira coisa que fazemos no início do programa é colocar uma pequena observação sobre o nome do programa, sua função e quem o criou:

1
2
3

// C++ code //Programa : Liga Motor e Sinaleiros //Autor : Sinésio Gomes //Data :04/11/2025

Após os comentários, vem é realizado a declaração e estado inicial das variáveis, com isso cada pino será associados á um componente, não sendo mais necessário saber qual pino está o componente.

// Definição dos pinos de entrada
#define B0 2 // Nome do pino 2
#define RT 3 // Nome do pino 3
#define S0 4 // Nome do pino 4
#define S1 5 // Nome do pino 5

// Definição dos pinos de saída
#define K1 6 // Nome do pino 6
#define Led_Vd 7 // Nome do pino 7
#define Led_Vm 8 // Nome do pino 8
#define Led_Am 9 // Nome do pino 9
#define Buzzer 10 // Nome do pino 10

// Declaração do tipo e estado inicial das variáveis
bool estado_B0 = 0; // Reset do pino 2
bool estado_RT = 0; // Reset do pino 3
bool estado_S0 = 0; // Reset do pino 4
bool estado_S1 = 0; // Reset do pino 5

A terceira parte da programação é a estrutura do setup(). É nela que definimos quais componentes (pino) do Arduino serão utilizados como entradas e saídas e o estado inicial dos pinos de saída.

void setup()
{
//Define a porta das chaves como entradas e dos led,s como saida
  pinMode(B0, INPUT); // Pinos como entradas
  pinMode(RT, INPUT);
  pinMode(S0, INPUT);
  pinMode(S1, INPUT);
  
  pinMode(K1, OUTPUT); // Pinos como saídas
  pinMode(Led_Vd, OUTPUT);  
  pinMode(Led_Vm, OUTPUT);
  pinMode(Led_Am, OUTPUT);
  pinMode(Buzzer, OUTPUT);

  digitalWrite (K1, 0); // Reset dos pinos
  digitalWrite (Led_Vd, 0); 
  digitalWrite (Led_Vm, 0);
  digitalWrite (Led_Am, 0);
  digitalWrite (Buzzer, 0);
}

Por último, temos o loop(), que contém as instruções para acender e apagar os led's e o rele k1 conforme são acionados as chaves, cada chave terá uma função diferente.

void loop() // Laço principal

{ estado_B0 = digitalRead (B0); // Lê entrada B0 - Emergência estado_RT = digitalRead (RT); // Lê entrada RT - Rele Térmico estado_S0 = digitalRead (S0); // Lê entrada S0 - Desliga estado_S1 = digitalRead (S1); // Lê entrada S1 - Liga if (estado_S1 == 1) {digitalWrite (Led_Vd, 1); digitalWrite (Led_Vm, 0);} if (estado_S0 == 0) { digitalWrite (Led_Vd, 0); digitalWrite (Led_Vm, 1);} if (estado_RT == 1) {digitalWrite (Led_Am, 0);} else {digitalWrite (Led_Am,1); digitalWrite (Led_Vm,0); digitalWrite (Led_Vd,0); } if (estado_B0 == 1) {digitalWrite (Buzzer, 1);} else {digitalWrite (Buzzer,0); digitalWrite (Led_Am,0); digitalWrite (Led_Vm,0); digitalWrite (Led_Vd,0); } }

Para esta estrutura de programação iremos utilizar o "if". O if é uma das estruturas mais básicas de programação em geral. O "if" significa "se" em inglês, e é exatamente isso que ele faz: ele verifica uma expressão e, apenas se ela for verdadeira, executa um conjunto de comandos. Em linguagem natural, ele executa uma lógica do tipo: "se isso for verdadeiro, então faça aquilo". Quando usamos um "if", ele segue o seguinte formato:

if(condição) { ... }

A lógica é muito simples: sempre que a condição for verdadeira, os comandos entre { e } são executados, caso contrário o programa prossegue sem executá-los. Vamos ver então como fica a função.

Função condicional da primeira chave, que liga 01 led, dentro do "loop()" ...

45

46

47

48

// Função da primeira chave, se acionada
 if (estado_S0 == 0) { digitalWrite (Led_Vd, 1); 
                       digitalWrite (Led_Vm, 0);
                     } 
 

Função condicional da segunda chave, que pisca dois Led's três vezes, dentro do "loop()" ...

// Função da segunda chave, se acionada
if (estado_S1 == 0) {  digitalWrite (Led_Vd, 0);
                       digitalWrite (Led_Vm, 1);
                       delay(500);  
                       digitalWrite (Led_Vd, 1);
                       digitalWrite (Led_Vm, 0);
                       delay(500);
// A estrutura de programação acima irá se repetir três vezes.
                     } 
 

Agora iremos utilizar o "if-else". O if-else, também conhecido como if-then-else, pode ser visto como uma extensão do comando if. Else em inglês significa "caso contrário", e ele faz exatamente o que o nome diz: "se isso for verdadeiro, então faça aquilo, caso contrário, faça outra coisa". Ele segue o seguinte formato:

if(condição) { ...  } else { ... }

Para a função condicional da terceira chave, que liga o Buzzer por 5 segundos, e apagar os Led's dentro do "loop()" ...

// Função da terceira chave, se acionada
if (estado_S2 == 1) {digitalWrite (Buzzer, 1);
                    } 

else {digitalWrite (Buzzer,0);
        delay(5000);
        digitalWrite (Led_Vd, 1);
        digitalWrite (Led_Vm, 1);
      }
                      
} 

Arquivo do código fonte - Controle de Led's por chaves está disponível em: 25_10_02_Controle_de_Motor_SRG. (PDF)