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

EX35 - Fechadura de segurança com teclado digital usando Arduino

    Muitas vezes, precisamos proteger um quarto em nossa casa ou escritório para que ninguém possa acessar o quarto sem nossa permissão e garantir proteção contra roubo ou perda de nossos acessórios e ativos importantes. Existem tantos tipos de sistemas de segurança presentes hoje, mas nos bastidores, para autenticação, todos eles se baseiam em impressão digital, identificação de rosto, leitor de RFID, senha, padrões, etc. Entre todas as soluções, a de menor custo é usar um sistema baseado em senha.     Portanto, neste projeto, construí uma fechadura com teclado Arduino que pode ser montada em qualquer uma das portas existentes para protegê-las com uma senha digital. 
    Antes de construir nosso projeto de travamento de porta com senha, primeiro precisamos coletar os componentes necessários e, em seguida, seguir em frente e seguir o processo de construção passo a passo. Lista de componentes:
  • Arduino Uno com microcontrolador Atmega 328p
  • 16 x 2 LCD (tela de cristal líquido)
  • Teclado de matriz 4 x 4 para Arduino
  • Servo motor
  • Fechadura de porta impressa em 3D / fechadura de porta personalizada
  • Componentes adicionais para fonte de alimentação de carregador móvel de 1 Amp 5 Volt
  • Caixas de plástico, parafusos, invólucro de plástico, etc.
Diagrama de circuito para a fechadura do teclado Arduino
Figura 01 - Diagrama elétrico

    O diagrama de circuito completo para nosso projeto de travamento de porta com teclado digital baseado em Arduino é mostrado na figura 01.
    Em primeiro lugar, partimos do cérebro deste projeto que é a placa Arduino UNO. A placa Arduino é conectada a um LCD e um servo motor. O servo motor é usado para empurrar (travar) ou puxar (destravar) a trava da porta.     Um LCD 16 x 2 é necessário para exibir a mensagem pelo Arduino, 16 x 2 significa que tem 16 números de colunas e 2 números de linhas. 
    Aqui, estou usando um servo motor Towerpro SG90 de 5v para fazer a trava. É um servo motor de nível básico e funciona bem com o Arduino sem nenhum circuito ou módulo externo. Conecte o servo motor com o pino D3 do Arduino Digital e com uma fonte de alimentação de 5 volts. Este servo motor tem um total de 3 linhas de entrada (GND, + 5V e LINHA DE SINAL).
    Neste projeto, usei um teclado de matriz 4 x 4 (mas a parte do teclado 4 x 4 não está disponível para fazer essa representação gráfica), mas não se preocupe, pois o teclado de matriz 4 x 3 também funciona bem com minha codificação . Precisamos de um teclado para entrada de senha e travar manualmente nosso armário personalizado. É composto por 16 teclas (soft switch) 4 teclas em linhas (R1, R2, R3, R4) e 4 teclas em colunas (C1, C2, C3, C4) quando uma tecla pressionada, estabelece uma conexão entre as linhas correspondentes e colunas. A tabela abaixo mostra como conectar seu Arduino com o teclado.
  • Pino 1 (linha 1) Pin Analógico A1
  • Pino 2 (linha 2) Pin Analógico A2
  • Pino 3 (linha 3) Pin Analógico A3
  • Pino 4 (linha 4) Pin Analógico A4
  • Pino 5 (colunas 1) Pin Analógico A5
  • Pino 6 (colunas 2) Pino digital 0
  • Pino 7 (colunas 3) Pino digital 1
  • Pino 8 (colunas 4) Pino digital 2
Código Arduino para fechadura digital do teclado
    O código completo da fechadura da porta do Arduino pode ser encontrado na parte inferior desta página. Você pode carregar o código diretamente, mas é recomendável ler os parágrafos abaixo para entender como o código funciona. Além disso, é importante certificar-se de que adicionou a seguinte biblioteca de teclado ao IDE do Arduino para compilar o código com êxito. Para isso basta abrir o link abaixo e baixar o arquivo ZIP. Em seguida, em seu IDE Arduino, navegue até Sketch -> Incluir Biblioteca -> Add.ZIP Library e navegue até o arquivo que você acabou de baixar.
    Depois de inserir todos os arquivos de cabeçalho e biblioteca, atribua todos os pinos para LCD e defina o comprimento da senha e defina a posição inicial do servo para 0. Depois disso, pegue um tipo de dados “char” para declarar o número que pode contê-lo incluindo o caractere nulo.
//#include <Keypad.h>
#include <LiquidCrystal.h>
#include <Servo.h>
Servo myservo;
LiquidCrystal lcd (8, 9, 4, 5, 6, 7);
#define Password_Lenght 7 // Give enough room for six chars + NULL char
int pos = 0;    // variable to store the servo position
char Data[Password_Lenght]; // 6 is the number of chars it can hold + the null char = 7
char Master[Password_Lenght] = "123456";
    Com este pedaço de código (char Master [Password_Lenght] = "123456";) - sob o Char Master, eu declaro a senha da fechadura da porta, em seguida, atribuo o número de linhas e colunas no teclado e também declaro keyMaps e conectar com linhas e colunas. Na configuração void, inicialize o servo sinal pino D3, servo status fechado e imprima o nome do projeto / dispositivo / empresa com 3 segundos de atraso no tempo de LCD de inicialização do dispositivo.
void setup()
{ myservo.attach(3);
  ServoClose();
  lcd.begin(16, 2);
  lcd.print(" Arduino Door");
  lcd.setCursor(0, 1);
  lcd.print("--Look project--");
  delay(3000);
  lcd.clear();
}
    Na função de loop, a condição if-else simples está lá. De acordo com o status (está bloqueado automaticamente), imprima "Porta está fechada" com 3 segundos de atraso e o servo gira para a posição fechada, os dados da porta contam como 1, caso contrário, oa trava da porta permanece aberta e os dados contam 0, o servo aberto gire para a posição 0 graus a 180 graus e para fechar vai de 180 a 0. As funções de abertura e fechamento do servo são mostradas abaixo.
void ServoOpen()
{   for (pos = 180; pos >= 0; pos -= 5) { // goes from 0 degrees to 180 degrees
    // in steps of 1 degree
    myservo.write(pos);              // tell servo to go to position in variable 'pos'
    delay(15);                       // waits 15ms for the servo to reach the position
  }
}
void ServoClose()
{  for (pos = 0; pos <= 180; pos += 5) { // goes from 180 degrees to 0 degrees
    myservo.write(pos);              // tell servo to go to position in variable 'pos'
    delay(15);                       // waits 15ms for the servo to reach the position
  }
}
    Escreva a posição do servo com 15 segundos de atraso para atingir a posição do servo. Na função void open, imprima no LCD “Enter Password” e então a condição especifica que a senha inserida deve ser a mesma da chave personalizada, dentro deste corpo os dados são contados e armazena o caractere no array de dados, incrementado e a senha de entrada impressa no LCD se o o comprimento dos dados (número da chave) e a senha de entrada correspondem ao Data Master (onde as chaves predefinidas estão presentes). Em seguida, como uma ação LCD limpa, servo drive, imprima no LCD “A porta está aberta” e o contador de dados é zerado.
    Se a chave de entrada não corresponder ao mestre de dados, como uma ação no LCD, limpe a impressão no LCD "Senha errada" para notificar com 1 segundo de atraso e permanecer em sua posição de bloqueio com o contador de dados definido como 1 e continuar este processo em um loop .
if (data_count == Password_Lenght - 1) // if the array index is equal to the number of expected chars, compare data to master
  {   if (!strcmp(Data, Master)) // equal to (strcmp(Data, Master) == 0)
    { lcd.clear();
      ServoOpen();
      lcd.print("  Door is Open");
      door = 0;
    }
    else
    { lcd.clear();
      lcd.print("  Wrong Password");
      delay(1000);
      door = 1;
    }
    clearData();
  }
Figura 02 - Peças 3D para "Fechadura de Segurança"
    Se você quiser mais segurança, terá que imprimir um modelo 3D de fechadura que funcione internamente com este servo. Você pode baixar os arquivos STL necessários no link abaixo e imprimi-los em 3D se tiver acesso a uma impressora 3D: 20_03_31 Peças 3D para Fechadura de segurança.
    No início do projeto, no momento em que o ligamos pela primeira vez, precisamos fornecer o nome do projeto (você pode exibir o nome da empresa também) para que pareça inteligente e exclusivo como um dispositivo comercial (como você pode ver em a imagem abaixo).
    Com 3 segundos de atraso , tranque rapidamente a porta e verifique diretamente no display o status da fechadura da porta conforme mostrado na imagem abaixo.
Figura 03 - Tela LCD.
    Quando você trava manualmente a porta pressionando a tecla “#”, primeiro mostra a porta está fechada por 1 segundo e, em seguida, exibe Digite a senha . Por outro lado, quando a porta é destrancada digitando a senha correta, aparece a mensagem Porta aberta .

    Se a porta permanecer destravada, será exibido - A porta está aberta contanto que você bloqueie a porta manualmente de acordo com a codificação. Eu forneci o código e você pode personalizar as configurações alterando o parâmetro de exibição do código conforme necessário. Você também pode verificar o trabalho completo com o vídeo no link na parte inferior desta página.
Figura 04 - Telas do display LCD.

    O arquivo do código fonte Fechadura de Segurança com teclado está disponível em: 21_03_31_Fechadura_de_Segurança_com_teclado _SRG (PDF).


    O arquivo do diagrama elétrico Fechadura de Segurança com teclado estará disponível em: 21_03_31_Circuito_Fechadura_de_Segurança_com_teclado″ SRG (PDF).

© Direitos de autor. 2021: Gomes; Sinésio Raimundo. Última atualização: 20/03/2021 

segunda-feira, 29 de março de 2021

Aula 15 - Micro Servo Motor 9g SG90 com Arduino Uno

Figura 01 - Micro servo motor

    As placas Arduino podem ser utilizadas para diversas funções, e graças a sua incrível versatilidade, é possível controlar sensores, módulos e até mesmo motores. Vamos utilizar um servo motor com o Arduino, tudo isso de forma simples e intuitiva. 
    O Micro Servo Motor SG90 9g é um item essencial para projetos de robótica, mecatrônica e diversos outros projetos. Na robótica, o servo motor é responsável por movimentar braços, pernas e mãos dos robôs. No automodelismo o servo motor é utilizado para virar as rodas dianteiras dos carrinhos e no aeromodelismo é utilizado para controlar os flaps das asas dos aviões.
Figura 02 - Interligação da placa
Arduino ao Micro servo motor

    
Ao utilizar o Micro Servo Motor SG90 9g é possível controlar o giro e a posição do mesmo através dos comandos enviados pela placa arduino. Após o envio do comando para que o servo altere sua posição, o mesmo verifica sua posição atual e em seguida executa o comando girando até a posição indicada.
    Especificações técnicas do Micro Servo 9g:
  • Voltagem de Operação: 3,0 – 7,2v
  • Velocidade: 0,12 seg/60Graus (4,8v) sem carga
  • Torque: 1,2 kg.cm (4,8v) e 1,6 kg.cm (6,0v)
  • Temperatura de Operação.: -30C ~ +60C
  • Dimensões.: 32x30x12 mm
  • Tipo de Engrenagem: Nylon
  • Tamanho cabo: 245 mm
  • Peso: 9g
    As conexões desse motor com a placa Arduino são bastante simples. Tudo o que é preciso fazer é conectar a alimentação do Micro Servo 9g ao Arduino: Fio Marrom com GND, depois o fio Vermelho no pino 5v da placa. Por fim, conecte o Fio Laranja na Porta Digital 6 (D6).

 
#define SERVO 6 // Porta Digital 6 PWM
 
Servo s; // Variável Servo
int pos; // Posição Servo
 
void setup ()
{
  s.attach(SERVO);
  Serial.begin(9600);
  s.write(0); // Inicia motor posição zero
}
 
void loop()
{
  for(pos = 0; pos < 90; pos++)
  {
    s.write(pos);
  delay(15);
  }
delay(1000);
  for(pos = 90; pos >= 0; pos--)
  {
    s.write(pos);
    delay(15);
  }
}
O manual com diagrama elétrico da placa do Micro Servo Motor 9g SG90 está disponível em: Micro Servo Motor 9g SG90 .

© Direitos de autor. 2020: Gomes; Sinésio Raimundo. Última atualização: 02/04/2021 

segunda-feira, 22 de março de 2021

Aula 14 - Programação e controle de Arduino com aplicativo Android Blynk

Figura 01 - Login no aplicativo Blynk
     
   Vamos mostrar como controlar as portas do Arduino via bluetooth diretamente pelo smartphone Android, usando o software Blynk.

Blynk

    O Blynk é uma aplicativo para iOS e Android usado para controlar placas como Arduino e Raspberry Pi através da internet ou bluetooth, como veremos nesta postagem. 

    É uma excelente ferramenta para você que deseja criar um projeto de IoT ( Internet das Coisas) de forma rápida e prática, já que conta com um sistema de objetos com funções pré-definidas, bastando arrastar e soltar no layout de sua preferência. O Blynk funciona com mais de 400 tipos de placas diferentes, desde o Arduino e Raspberry, ESP8266 NodeMCU, Wemos, ESP32, MicroBit, Particle, Feather, Intel Edison e muitas outras. 

Figura 02 - Criar novo projeto no aplicativo Blynk
    Para funcionar, o Blynk usa um sistema de “créditos de energia”, que você utiliza conforme adiciona widgets ao seu projeto. Um botão, custa 200 créditos, um timer, mais 200, e esses créditos são debitados do valor total que você recebe quando se cadastra no aplicativo (2000 créditos). Quando você atinge o limite de créditos é possível comprar mais pelo aplicativo.

    Para começar, instale o aplicativo Blynk da Playstore ou Appstore. Ao criar uma conta e fazer o login, conforme figura 01, você receberá um "token" em seu e-mail. Mantenha esse token de autenticação que será usado nos projetos. agora siga estas etapas conforme figura 02:

  • Crie uma conta e faça o login;
  • Crie um novo projeto;
  • Nomeie esse projeto como “Arduino BT”;
Figura 03 - Token e escolha de "widget' no Blynk

Preencha essas informações. Agora selecione os objetos que irá utilizar confrome figura 03:
  • Clique no objeto e aplique esses parâmetros;

    Após a criação do login (figura 01), você estará na tela principal do aplicativo. Depois de selecionar a opção "New Project" e na tela seguinte "Create New Project", dê um nome ao seu projeto e escolha o tipo de dispositivo que vai usar (figura 02 e figura 03). No meu caso, utilizei como nome de projeto Arduino BT, selecionei a placa Arduino Uno e logo depois o tipo de conexão, Bluetooth:
  • Agora clique no ícone de adição e adicione um widget Bluetooth e dois botões (figura 04).

    
Figura 04 - Configuração dos objetos no Blynk
 Clique no primeiro botão e aplique esses parâmetros. Nomeie o botão como 'Lâmpada', no caso de PIN adicionar o pino virtual V0, selecione a opção 'Switch' em vez de 'Push'. Faça o mesmo para o outro botão e apenas altere o nome para 'Ventilador' e o PIN para V1.

    Vamos agora colocar o "widget" do Bluetooth na nossa tela. É com ele que vamos selecionar o HC-05 conectado ao Arduino e permitir que o programa faça a conexão com ele quando estiver rodando. Clique no sinal de + novamente e selecione a opção Bluetooth, será criado então um novo botão no nosso layout, que eu coloquei acima dos botões de acionamento.

    Clique no botão bluetooth que você acabou de criar para configurar a conexão. Lembre-se de que você já deve ter pareado o seu smartphone com o HC-05 anteriormente para que ele apareça na lista.
Figura 05 - Conexão do HC-05 no Blynk
    Selecione Connect Bluetooth Device, depois selecione o dispositivo pareado anteriormente. No exemplo, o HC-05 está nomeado como ARDUINOECIA.

    Com isso finalizamos a configuração do aplicativo Blynk. Vamos agora carregar o sketch no Arduino que vai reconhecer essa configuração.

Programa para controlar Arduino por bluetooth com Blynk

    Para programar o sistema, precisaremos do IDE do Arduino com a biblioteca SoftwareSerial.h . Normalmente, ele é pré-instalado no Arduino IDE.
    Também usaremos o aplicativo Blynk para controlar os aparelhos por meio de smartphones. Além disso, também precisamos instalar a biblioteca Blynk para Arduino. 
   
Figura 06 - Esboço do controle de cargas com Arduino e Blynk

O programa que vamos carregar no Arduino é muito simples, pois todo o controle de recepção e portas é feito pela biblioteca Blynk. Instale a biblioteca à partir da própria IDE do Arduino, no menu Sketch -> Incluir Biblioteca -> Gerenciar bibliotecas.
    Neste projeto, o principal componente que iremos utilizar é o módulo Bluetooth HC-05. Também precisaremos de um microcontrolador para controlar todas as operações. Para isso, vamos usar o Arduino UNO. Mas você pode usar outras placas como Mega, Nano, Mini, etc. 
    Em seguida, vamos precisar de um smartphone para controlar todos os aparelhos. Em seguida, precisaremos de um módulo de relé para ligar e desligar os aparelhos.     O número de canais ou relés no módulo depende do número de aparelhos que você deseja controlar. Para simplificar, usaremos um módulo de relé de 2 canais. 
Figura 07 - Circuito elétrico do controle de cargas com
Arduino e Blynk

Além de tudo isso, também precisaremos de uma placa de ensaio e alguns fios de jumper para as conexões.
  • Os pinos VCC e GND do módulo Bluetooth são conectados aos pinos 5V e GND do Arduino, respectivamente. O pino TX do Bluetooth é conectado ao pino RX do Arduino e o pino RX do Bluetooth é conectado ao pino TX do Arduino. O resto dos pinos do módulo Bluetooth permanecem abertos.
  • VCC e GND do módulo de relé são conectados ao pino 5V e GND do Arduino, respectivamente. Os pinos IN1 e IN2 do relé são conectados aos pinos D6 e D5 do Arduino, respectivamente.
  • Agora conexões para a luz e o ventilador. Estamos levando luz e ventilador que funcionam em 220 a 230V. Assim, um fio (de preferência -ve ou fio neutro) da fonte de alimentação é conectado à luz e o outro fio (de preferência + ve ou fase) é cortado e uma extremidade é conectada ao pino comum de um relé e a outra extremidade é conectado ao pino NÃO (normalmente aberto) do relé. O mesmo é feito para o ventilador mantendo-o paralelo à luz.
    Para resumir todas essas conexões, fornecemos um diagrama de circuito na figura 06. Ao configurar o aplicativo Blynk, lembre-se de que você recebe uma quantidade limitada de crédito que limita o número de botões que você pode adicionar. Embora você possa comprar mais crédito.

O arquivo do código fonte Controle de Arduino com aplicativo Blink está disponível em: 21_02_14_Controle_de_Arduino_com_aplicativo_Blink_SRG (PDF).

O arquivo do diagrama elétrico - Partida e reversão de motor de indução com Arduino está disponível em: 21_02_14_Circuito_Controle_de_Arduino_com_aplicativo_Blink_SRG (PDF).

© Direitos de autor. 2020: Gomes; Sinésio Raimundo. Última atualização: 02/03/2021 

quarta-feira, 17 de março de 2021

EX34 - Programação Ladder em Arduino: Controle de semáforo de rua e avenida

Comando de um semáforo de cruzamento entre rua e avenida que entra em operação no ciclo automático com prioridade para liberação de veículos na avenida com comando em ladder para Arduino Uno. 

O arquivo do código fonte Ladder - Controle de semáforo de rua e avenida com Arduino está disponível em: 21_02_02_Semáforo_rua_avenida_Arduino_SRG (PDF)

O arquivo do diagrama elétrico - Controle de semáforo de rua e avenida com Arduino está disponível em: 21_02_02_Circuito_semáforo_rua_avenida_Arduino_SRG (PDF).

© Direitos de autor. 2020: Gomes; Sinésio Raimundo. Última atualização: 13/02/2021


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

EX33 - Programação Ladder em Arduino: Partida e reversão de motor de indução

Figura 01 - Programação Ladder para
partida e reversão de motor de indução
O software LDmicro gera código hexadecimal para microcontroladores PIC16 e Atmel AVR. Normalmente, o software para esses microcontroladores é escrito em uma linguagem de programação tais como: Assembler, C ou Basic. Já um programa escrito em uma dessas linguagens de programação compreende uma lista de declarações. Essas linguagens são complexas e adequado à arquitetura do processador, que executa internamente uma lista de instruções. 


Os CLP's, por outro lado, são frequentemente programados em `lógica ladder '. Um linguagem de programação mais simples e um programa pode ter a seguinte aparência da figura 01.

Figura 02 - Gravação da programação Ladder para
partida e reversão de motor de indução com AVRDude.

Neste exemplo temos os comandos:

  • As instruções -]  [- são entradas, que se comportam como os contatos de um relé. 
  • As declarações - (   ) - são saídas, que se comportam como a bobina de um contator. 
  • TON é temporizador comatraso para ligar.
Uma série de diferenças são aparentes:

  • O programa é apresentado em formato gráfico, não como uma lista textual de declarações. Muitas pessoas acharão isso mais fácil de compreender.
  • No nível mais básico, os programas parecem diagramas de circuitos, com contatos de relé (entradas) e bobinas (saídas). Isso é intuitivo para programadores com conhecimento teórico de circuitos elétricos.
  • O compilador de lógica ladder cuida do que é programado, então você não tem que escrever código para determinar quando as saídas tem que ser trocads com base em uma mudança nas entradas ou um evento temporizador, e você não precisa especificar a ordem em que esses cálculos devem ocorrer; as ferramentas PLC fazem isso para você.
Figura 03 - Diagrama elétrico do controle para
partida e reversão de motor de indução.
Para gravação utilizei o software AVR_Dude que é um programador em linha de comando muito popular para linha de microcontroladores Atmel AVR. É um projeto open-source e também é utilizado para upload dos programas na plataforma Arduino.

O arquivo do código fonte - Partida e reversão de motor de indução com Arduino está disponível em: 21_02_01_Partida_reversão_motor_indução_Arduino_SRG (PDF).

O arquivo do diagrama elétrico - Partida e reversão de motor de indução com Arduino está disponível em: 21_02_01_Circuito_Partida_reversão_motor_indução_Arduino_SRG (PDF).

© Direitos de autor. 2020: Gomes; Sinésio Raimundo. Última atualização: 13/02/2021

segunda-feira, 15 de março de 2021

Aula 13 - Linguagem de programação Ladder para Arduino

 Programar Arduino em Ladder é interessante pois treinamos outras linguagens de programação, pois devemos entender que essa lógica é vastamente utilizado na indústria, logo, se você tem essa pretensão, esse aprendizado é indispensável. 
Figura 01 - Pinagem ATmega328.


Relembrando que o Arduino Uno é uma placa de desenvolvimento, o componente principal do Arduino é o microcontrolador. O chip que se encontra no centro da placa é responsável por todo o processamento do código que escrevemos. Os outros elementos da placa são acessórios que facilitam o desenvolvimento de projetos, como uma interface USB, regulador de tensão, led onboard, cristal oscilador e tantas outras facilidades.


A maneira como a placa foi construída abstrai, inclusive, a numeração e identificação dos pinos do microcontrolador. Isso é feito separando as entradas analógicas de um lado e as digitais do outro lado e enumerando-as de maneira lógica e de fácil entendimento. Veja o diagrama da pinagem real do microcontrolador ATmega328p. Iremos precisar utilizar os nomes dos pinos originais quando formos trabalhar com o Ladder no Arduino.

Figura 02 - Configuração do controlador no LDmicro.
Existe um compilador chamado LDmicro, ele é usado para programar microcontroladores pic e avr. Como todos nós sabemos, o Arduino é uma placa de prototipagem que tem como base um microcontrolador avr, o ATmega328. Assim, conseguimos, com poucas modificações, e cumprindo alguns passos, programar nosso querido Arduino com a linguagem ladder.

Assim como os outros compiladores, ele gera o arquivo .hex que posteriormente é usado para gravação utilizando gravadores de pic ou avr.

Como você pode ter percebido o ATmega328 não está listado, porém a versão do LDmicro que vamos usar é modificada e nela foram acrescentados vários outros microcontroladores, inclusive o que desejamos.

Figura 03 - Endereçamento dos comandos em Ladder

Em Settings > Microcontrollers selecionamos o ATmega328 e posteriormente em Settings > MCUparameters escrevemos o valor do Crystal Frequency para 16.

Em Instructions encontramos todos os comandos básicos da linguagem ladder, inclusive a entrada como insert contacts e a bobina de saída como insert coil. Ao clicarmos sobre o elemento podemos alterar seu estado, como por exemplo, normalmente-fechado ou normalmente-aberto.

Figura 04 - Programa ladder para Arduino
Repare que ao incluirmos entradas e saídas, o painel abaixo do ambiente de escrita ladder indica e detalha o que foi escrito, vamos nos atentar a essa janela. Os elementos com a legenda “X”, por convenção nossa, sempre indicarão entradas e os elementos com a legenda “Y” indicarão saídas. Ao lado do nome, temos o tipo de elemento, entrada ou saída. Mais adiante, quando falarmos sobre simulação, veremos como funciona o estado. Já na opção “pino no processador”, selecionamos as linhas e determinamos a qual pino físico do microcontrolador o nosso elemento estará conectado. Para fazer o último passo utilizaremos a informação sobre a arquitetura do Arduino que vimos no inicio do artigo.


Veja, na parte do “pino do processador” vamos escolher o pino do processador que se relaciona com o pino da placa Arduino, por exemplo o pino PB1 do microcontrolador é o pino 9 e o PC0 é o pino A0 do Arduino .

Figura 05 - Circuito para teste
Podemos interpretar o código ladder nessa aplicação da mesma forma como interpretamos o exemplo no inicio desse artigo, com a exceção do contato virtual “Pronto para funcionar”. No nosso exemplo cada contato corresponde a uma entrada digital no mundo real, mais precisamente um botão. E a saída corresponde a um LED no mundo real. Assim que apertamos o botão “Ligar” o LED é acionado, bem como o seu respectivo contato, assim mesmo que pressionamos o botão Ligar novamente nada acontece. Em contrapartida, pressionando o botão “Desligar”, ele interrompe o circuito, visto que está normalmente fechado, quando pressionado ele abre o circuito, e assim desligamos o LED.

Agora podemos fazer a simulação, e para tal, basta clicar em simulação e posteriormente em simulação em tempo real. Essa simulação permitirá ao usuário ver a lógica ladder funcionando no programa e conferir a alteração dos estados das bobinas no painel de cor branca na parte de baixo do programa.

Agora, precisamos realizar uma simulação para nos assegurar que está tudo certo e posteriormente podemos compilar. Para compilar basta ir na barra de ferramentas e clicar em Compile. Salve o arquivo .hex onde achar mais conveniente. 

Atenção! o Arduino não está pronto para receber o nosso código!

Figura 06 - Programa Avrdudess para gravação do Arduino 
Abra o Avrdudess já instalado anteriormente e siga os passos como na imagem da figura 05:

  • Selecione Arduino em Programmer, depois a porta de comunicação do Arduino com o computador, normalmente essa porta é o prefixo COM com um numeral ao final que varia de 1 a 9, Baud rate 115200.
  • Em MCU o ATmega328p deve estar selecionado.
  • Bem como em Presets a placa Arduino Uno.
  • Em Flash, clique no botão com 3 pontos e selecione o programa que foi compilado no LDMicro.
  • Por fim, clique em programar!
Construímos uma aplicação em Arduino com apenas uma linha de código e alguns cliques de mouse para configuração do ambiente de desenvolvimento. Veja como nesse caso foi mais fácil usar a solução em ladder do que programar em Arduino C na IDE. Somente a função Setup na IDE já teria mais linhas de código.
A lógica ladder se mostra uma ferramenta muito eficiente para resolução rápida de problemas. Isso se deve, principalmente, a possibilidade de realizar a simulação do sistema e supervisionar a execução do programa degrau por degrau.
Como na indústria, podemos nos beneficiar das facilidades da lógica ladder em projetos onde entradas e saídas digitais são norma. Na presença de entradas ou saídas analógicas, se desejamos realizar cálculos matemáticos complexos ou se o nosso programa conter loops devemos optar por linguagens de programação textuais.

Os programas necessários para usar Ladder no Arduino estão disponíveis em: LDmicro – para programação em ladder e AVRdudess – para gravação do código no Arduino.

© Direitos de autor. 2020: Gomes; Sinésio Raimundo. Última atualização: 27/02/2021

domingo, 14 de março de 2021

EX32 - Programação Arduino com "Display Touch Arduino Shield": Tic Tac Toe - Jogo da velha

Figura 01 - Tic Tac Toe

    Tic Tac Toe (no Brasil - jogo da velha) é um jogo para dois jogadores,  X  e  O , eles se revezam marcando os espaços em uma grade 3 × 3 normalmente desenhada no papel. O jogador que conseguir colocar três de suas marcas em uma linha horizontal, vertical ou diagonal, ganha o jogo. No tutorial de hoje, mostrarei como construir o jogo tic tac toe usando o Arduino e um display TFT touchscreen. 
    Assim como o jogo tic tac toe normal, terá dois jogadores, mas, neste caso, o primeiro jogador será o computador. Acredito que este jogo seja uma ótima introdução à programação de jogos e à Inteligência Artificial, embora não vamos usar nenhum Algoritmo de Inteligência Artificial neste jogo, vamos entender porque os Algoritmos de Inteligência Artificial são necessários em jogos mais complexos.
Figura 02 - Algoritmo do Tic Tac Toe

    
Nosso objetivo com o código é simples, estaremos criando três telas. A primeira tela carregará o botão de início do jogo que, quando pressionado, levará ao próprio jogo. A segunda tela é a própria tela de jogo onde o usuário estará jogando com o computador. A jogabilidade é projetada de forma que o Arduino seja reproduzido primeiro, após o que o jogador individual pode então fazer seu movimento simplesmente tocando a tela e assim por diante. O jogador que consegue colocar três de suas marcas em uma linha horizontal, vertical ou diagonal ganha o jogo, mas eu projetei o jogo de forma que o computador não seja capaz de perder, o melhor que um bom jogador obterá do jogo é um empate.
Figura 03 - Opções do Tic Tac Toe

    
O código do projeto é bastante complexo e, após o download, você verá que ocupa mais de 600 linhas, o que pode ser muito longo para explicar, então irei apenas repassar o conceito. O fluxograma do jogo é mostrado na figura 02.    Quando o jogo começa, o computador escolhe jogar de qualquer canto aleatório e então espera que o jogador humano faça seu próprio movimento. 
    Após a primeira rodada, o jogo verificará cada uma das outras rodadas, se o jogador humano pode vencer com sua próxima jogada. Se for possível vencer, o jogo bloqueia a jogada. Para tornar o jogo interessante e dar uma chance ao jogador humano, às vezes não bloqueamos os movimentos e jogamos em um local aleatório.

O Código do "Tic Tac Toe " do "Display Touch Arduino Shield" está disponível em: 21_03_17_Tic_Tac _Toe _com_"Display_Touch_Arduino_Shield", juntamente com o Graphics_C.

© Direitos de autor. 2020: Gomes; Sinésio Raimundo. Última atualização: 22/03/2021

sexta-feira, 12 de março de 2021

EX31 - Programação Arduino com "Display Touch Arduino Shield": Calculadora Retrô

    Para utilizar o Display Touch Arduino Shield, vamos precisar das bibliotecas: Adafruit_GFX, Adafruit_TFTLCD e Touchscreen. As bibliotecas estão disponíveis neste link. Faça o download, descompacte o arquivo e coloque as bibliotecas dentro da pasta LIBRARIES da IDE do seu Arduino. Reinicie a IDE para que as bibliotecas sejam corretamente carregadas, depois basta incluir no código conforme mostrado abaixo.  
#include <Adafruit_GFX.h> // Biblioteca gráfica principal
#include <
Adafruit_TFTLCD.h> // Biblioteca específica de hardware
#include <TouchScreen.h> // Biblioteca específica do TouchScreen
    Precisamos calibrar a tela LCD para que funcione conforme o esperado, os valores fornecidos aqui são quase universais. As variáveis ​​TS_MINX, TS_MINY, TS_MAXX e TS_MAXY decidem a calibração da Tela. Você pode alterar eles se achar que a calibração não é satisfatória.
# define TS_MINX 150
# define TS_MINY 120

# define TS_MAXX 920

# define TS_MAXY 940
    A tela LCD TFT pode exibir muitas cores, todas essas cores devem ser inseridas em valores hexadecimais. Para torná-lo mais legível, atribuímos esses valores a uma variável conforme mostrado abaixo.
# define Black    0x0000 // Preto
# define Blue     0x001F // Azul
# define Red      0xF800 // Vermelho
# define Green    0x07E0 // Verde

# define
Cyan     0x07FF // Ciano
# define Pink     0xF81F // Rosa
# define Yellow   0xFFE0 // Amarelo
# define White    0xFFFF // Branco
    A comunicação da tela touch resistiva  LCD TFT deve ser definida, para isto atribuímos a função e endereços dos pinos conforme mostrado abaixo.
#define YP A3  // 
#define XM
A2 //
#define YM
9 //
#define XP
8 //
     O controle do display da tela LCD TFT deve ser definida, para isto atribuímos o endereços dos pinos conforme mostrado abaixo:
Adafruit_TFTLCD tft (A3, A2, A1, A0, A4);
Programação Arduino com "Display Touch Arduino Shield": Calculadora Retrô
Figura 01 -  Teclado da
"Calculadora Retrô
"

    Para teste do "Display Touch Arduino Shield", desenvolvi a aplicação "Calculadora Retrô" que está disponível no link após a descrição de cada etapa desenvolvida.
    Vamos projetar a interface do usuário da calculadora. Fiz um layout básico da calculadora com 16 botões e uma unidade de exibição, para construir fiz inicialmente o rascuno do design, mostrado na figura 04. As bibliotecas adicionadas permitirão que você desenhe linhas, retângulo, círculos, caracteres, e muito mais de qualquer cor preferida. Você pode entender as funções disponíveis neste artigo. 
    Usei as habilidades de desenho de linha e caixa para projetar a calculadora que se parece muito com a calculadora dos anos 90. Cada caixa tem largura e altura de 60 pixels, conforme mostrado na figura 04.
    Após o esboço e teste da programação que está mostrado abaixo, temos o resultado final mostrado na figura 03.
  Foi inicialmente desenhado a caixa de resultados acima, as colunas com números na cor preto e caracteres brancos, os caracteres dos operandos também foram desenhados em branco, porém com caixa azul.

//Draw the Result Box
tft.fillRect(0, 0, 240, 80,
WHITE);
//Draw First Column
tft.fillRect (0,260,60,60,
BLUE);
tft.fillRect (0,200,60,60,BLACK);
tft.fillRect (0,140,60,60,BLACK);
tft.fillRect (0,80,60,60,BLACK);
//Draw Third Column
tft.fillRect (120,260,60,60,
BLUE);
tft.fillRect (120,200,60,60,BLACK);
tft.fillRect (120,140,60,60,BLACK);
tft.fillRect (120,80,60,60,BLACK);
//Draw Secound & Fourth Column
for (int b=260; b>=80; b-=60)
{ tft.fillRect (180,b,60,60,BLUE);
tft.fillRect (60,b,60,60,BLACK);}
//Draw Horizontal Lines
for (int h=80; h<=320; h+=60)
tft.drawFastHLine(0, h, 240, WHITE);
//Draw Vertical Lines
for (int v=0; v<=240; v+=60)
tft.drawFastVLine(v, 80, 240, WHITE);
//Display keypad lables
for (int j=0;j<4;j++) {
for (int i=0;i<4;i++) {
tft.setCursor(22 + (60*i), 100 + (60*j));
tft.setTextSize(3);
tft.setTextColor(WHITE);
tft.println(symbol[j][i]);
Figura 02 -  Esboço do telado da
"Calculadora Retrô
"
    Detectando os botõesOutra tarefa desafiadora é detectar o toque do usuário . Cada vez que o usuário toca em algum lugar, podemos ver onde estão as posições X e Y do pixel que ele tocou. Este valor pode ser exibido no monitor serial usando o println conforme mostrado abaixo. 
    Pois desenhamos a caixa com largura e altura de 60 pixels cada e temos quatro Linhas e para colunas a partir de (0,0). A posição de cada caixa pode ser prevista conforme mostrado na imagem da figura 04.
    Agora, já que sabemos a posição de todas as caixas. Quando um usuário toca em qualquer lugar, podemos prever onde ele tocou, comparando seus valores (X, Y) com o valor de cada caixa, conforme mostrado abaixo.
if (X<105 && X>50) //Detecting Buttons on Column 2
{ if (Y>0 && Y<85)
{Serial.println ("Button 0"); //Button 0 is Pressed
if (Number==0)
Number=0;
else
Number = (Number*10) + 0; //Pressed twice
} if (Y>85 && Y<140)
{Serial.println ("Button 2");
if (Number==0)
Number=2;
else
Number = (Number*10) + 2; //Pressed twice
}
    A etapa final é calcular o resultado e exibi-los na tela LCD TFT. Esta calculadora Arduino pode realizar operações com apenas 2 números. Esses dois números são nomeados como variáveis ​​“Num1” e “Num2”. A variável “Número” fornece e obtém valor de Num1 e Num2 e também carrega o resultado.
    Quando um usuário pressiona um botão, um dígito é adicionado ao número. Quando outro botão é pressionado, o dígito anterior é multiplicado por 10 e o novo número é adicionado com ele. Por exemplo, se pressionarmos 8 e, em seguida, pressionarmos 5 e, em seguida, pressionarmos 7. Então, primeiro a variável manterá 8, então (8 * 10) + 5 = 85, então (85 * 10) +7 = 857. Então, finalmente, a variável terá o valor 857 com ele.
if (Y>192 && Y<245)
{Serial.println ("Button 8");
if (Number==0)
Number=8;
else
Number = (Number*10) + 8; //Pressed again
}
    Quando realizamos qualquer operação como adição, quando o usuário pressiona o botão de adição, o valor do Número será transferido para Num1 e o Número será zerado para que fique pronto para receber a entrada do segundo número.
Figura 03 -  "Calculadora Retrô"
    Ao pressionar Igualdade o valor em Número será enviado para Num2 e então o respectivo cálculo (neste caso a adição) será feito e o resultado será armazenado novamente na variável “Número”.
    O funcionamento desta calculadora da tela de toque do Arduino é simples. Você deve fazer o upload do código fornecido abaixo em seu Arduino e ativá-lo. A calculadora é exibida na tela LCD.
    Agora, você pode inserir qualquer número e realizar seus cálculos. Ele está limitado a apenas dois operandos e apenas um operador, por enquanto. Mas, você pode ajustar o código para torná-lo mais prático. Você deve pressionar “C” para limpar o valor na tela todas as vezes após realizar um cálculo. Espero que você tenha entendido o projeto e gostado de construir algo semelhante.

Código da "Calculadora Retrô" do "Display Touch Arduino Shield" está disponível em: 21_03_01_"Calculadora_Retrô"_com_"Display_Touch_Arduino_Shield".


© Direitos de autor. 2020: Gomes; Sinésio Raimundo. Última atualização: 02/03/2021