EX37 - Detector de cores usando Arduino Uno

Figura 01 - Módulo Sensor TCS3200

    Neste projeto, faremos a interface do sensor de cores TCS3200 com o Arduino UNO. O TCS3200 é um sensor de cores que pode detectar qualquer número de cores com a programação correta. TCS3200 contém matrizes RGB (Red Green Blue). Conforme mostrado na figura em nível microscópico, pode-se ver as caixas quadradas dentro do olho no sensor. Essas caixas quadradas são matrizes RGB.  

    Cada uma dessas caixas contém três sensores, um para detectar a intensidade da luz VERMELHA, um para detectar a intensidade da luz VERDE e o último para detectar a intensidade da luz AZUL.

    Cada uma das matrizes de sensores nessas três matrizes é selecionada separadamente, dependendo do requisito. Por isso é conhecido como  sensor programável. O módulo pode ser caracterizado para detectar a cor específica e deixar as outras. Ele contém filtros para esse propósito de seleção. 

Há um quarto modo que não é um modo de filtro. Sem modo de filtro, o sensor detecta luz branca. 

    Componentes necessários: Hardware e Software:  

• ARDUINO UNO, 
• Fonte de alimentação (5v), 
• LED's vermelho, verde e azul, 
• Display JHD_162A LCD (16 * 2LCD), 
• Sensor de cores TCS3200.
• Software: ARDUINO IDE.

    Diagrama de circuito e explicação do trabalho

    No LCD 16x2 existem 16 pinos ao todo, se houver uma luz de fundo, se não houver luz de fundo, haverá 14 pinos. Pode-se ligar ou deixar os pinos da luz de fundo. Agora, nos 14 pinos, há 8 pinos de dados (7-14 ou D0-D7), 2 pinos de fonte de alimentação (1 e 2 ou VSS e VDD ou GND e + 5v), 3º pino para controle de contraste (VEE-controla a espessura dos caracteres mostrado), e 3 pinos de controle (RS & RW & E)

Figura 02 - Detector de cores com Sensor TCS3200

    No circuito, você pode observar que tirei apenas dois pinos de controle. O bit de contraste e READ / WRITE não são usados ​​com frequência, portanto, podem ser colocados em curto com o aterramento. Isso coloca o LCD no mais alto contraste e modo de leitura. Precisamos apenas controlar os pinos ENABLE e RS para enviar caracteres e dados de acordo. As conexões que são feitas para LCD são fornecidas abaixo:

• PIN1 ou VSS para aterrar;
• PIN2 ou VDD ou VCC para alimentação de + 5v;
• PIN3 ou VEE para aterrar (oferece contraste máximo ou mínimo);
• PIN4 ou RS (Registrar Seleção) para o PIN8 do ARDUINO UNO;
• PIN5 ou RW (leitura / gravação) para aterrar (coloca o LCD no modo de leitura e facilita a comunicação para o usuário);
• PIN6 ou EN (Ativar) para PIN9 do ARDUINO UNO;
• PIN11 ou D4 a PIN4 do ARDUINO UNO;
• PIN12 ou D5 a PIN5 do ARDUINO UNO;
• PIN13 ou D6 a PIN6 do ARDUINO UNO;
• PIN14 ou D7 a PIN7 do ARDUINO UNO

    As conexões que são feitas para o sensor de cores são fornecidas abaixo:

• VDD para + 5V
• GND para GROUND
• OE (habilitação de saída) para GND
• S0 para PIN0 do ARDUINO UNO;
• S1 para PIN1 do ARDUINO UNO;
• S2 para PIN2 do ARDUINO UNO;
• S3 para PIN3 do ARDUINO UNO;
• OUT para PIN A1 do ARDUINO UNO;

    As conexões que são feitas para os LED's são fornecidas abaixo:

• LED Vermelho na saída A3
• LED Verde da saída A4
• LED Azul da saída A5

 

Figura 03 - Sensor TCS3200

   A cor que precisa ser detectada pelo sensor de cores é selecionada por dois pinos S2 e S3. Com esses dois pinos de controle lógico, podemos dizer ao sensor qual cor de intensidade de luz deve ser medida.

    Digamos que precisamos sentir a intensidade da cor VERMELHA de que precisamos definir os dois pinos como BAIXO. Feito isso, o sensor detecta a intensidade e envia o valor para o sistema de controle dentro do módulo.

• S2 S3 Tipo de Fotodiodo;
• L L Vermelho;
• L H Azul;
• H L Branco (sem filtro);
• H H Verde;

Figura 04 - Diagrama funcional do
Sensor TCS3200

    O sistema de controle dentro do módulo é mostrado na figura. A intensidade da luz medida pela matriz é enviada à corrente para o conversor de frequência. O que ele faz é, ele emite uma onda quadrada cuja frequência é em relação à corrente enviada por ARRAY.

    Portanto, temos um sistema que envia uma onda quadrada cuja frequência depende da intensidade da luz da cor que é selecionada por S2 e S3.

Figura 05 - Resposta de frequência do
Sensor TCS3200

    A frequência do sinal enviada pelo módulo pode ser modulada dependendo do uso. Podemos alterar a largura de banda da frequência do sinal de saída.

• S0 S1 Escala de frequência de saída (f 0 )
• L L Desligar
• L H 2%
• H L 20%
• H H 100%

    A escala de frequência é feita por dois bits S0 e S1. Por conveniência, vamos limitar a escala de frequência a 20%. Isso é feito configurando S0 para alto e S1 para BAIXO. Este recurso é útil quando estamos usando o módulo em um sistema com clock baixo. A sensibilidade da matriz à cor é mostrada na figura 04.

    Embora cores diferentes tenham sensibilidade diferente, para um uso normal não fará muita diferença.

Figura 06 - Detector de cores com Arduino e
Sensor TCS3200

    O Arduino UNO aqui envia sinal ao módulo para detectar cores e os dados recebidos pelo módulo são mostrados no LCD 16 * 2 conectado a ele. O Arduino UNO detecta três intensidades de cor separadamente e as mostra no LCD.

    O Arduino UNO pode detectar a duração do pulso do sinal pelo qual podemos obter a frequência da onda quadrada enviada pelo módulo. Com a frequência disponível, podemos combiná-la com a cor do sensor.

• Frequência interna = pulseIn (A1, LOW);

    Como por condição acima o Arduino UNO  lê duração do impulso no pino A1 e armazena-o em valor inteiro “frequência”.

    Faremos isso para todas as três cores para reconhecimento de cores . Todas as três intensidades de cor são mostradas por frequências no LCD 16x2.

O manual com diagrama elétrico da placa do Color Sensor TCS3200 está disponìvel em:  Color Sensor TCS3200.

O arquivo do código fonte Detector de cores  está disponível em: 21_03_27_Detector_de_cores_SRG (PDF).

O arquivo do diagrama elétrico Detector de cores estará disponível em: 21_03_27_Circuito_Detector_de_cores_SRG (PDF).

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

Aula 15 - Sensor de Reconhecimento de Cor TCS3200 com Arduino Uno

 
   O Sensor de Cor TCS230 (TCS3200) é um módulo composto por 64 fotodiodos que são divididos da seguinte forma: 16 possuem filtros para a cor vermelha, 16 para a cor verde, 16 para a cor azul e 16 não possuem filtro. Além disso, o sensor possui quatro LEDs brancos para iluminação e oito pinos de conexão.
    Os 64 fotodiodos estão distribuídos no Sensor de Cor TCS230 (TCS3200) uniformemente e são responsáveis por captar a luminosidade, filtrar as cores recebidas e em seguida gerar na saída do sensor um sinal de onda quadrada que traz informações sobre a intensidade das cores primárias (Red (Vermelho) / Green (Verde) / Blue (Azul)). A partir destas informações é possível verificar qual a cor que o sensor identificou. Especificações e características:

• Controlador: TCS230
• Tensão de operação: 3 a 5VDC
• Melhor faixa de detecção: 10mm
• Margem de erro típica: 0.2% a 50KHz

 

   O sensor de cor TCS3200 é um detector de cor completo e inclui um sensor RGB TAOS TCS3200 e 4 LEDs brancos.  O TCS3200 pode detectar e medir uma gama quase ilimitada de cores visíveis. É indicado para aplicações onde seja necessária a detecção da cor de um determinado objeto, superfície ou luz ambiente por exemplo.

    O TCS3200 tem uma variedade de fotodetectores, cada um com um filtro vermelho, verde ou azul, ou sem filtro (claro). Os filtros de cada cor são distribuídos uniformemente por toda a matriz de modo a eliminar distorção. O dispositivo possui um oscilador que produz uma saída de onda quadrada, cuja frequência é proporcional à intensidade da cor lida.

    O sensor possui na sua estrutura 64 fotodiodos, sendo que 16 deles tem filtro para a cor azul, 16 para a cor verde, 16 para a cor vermelha e os 16 restantes não tem nenhum tipo de filtro. A saída de dados do sensor é feita através do pino OUT, e o controle da leitura é feita por meio dos pinos S0, S1, S2 e S3, nas laterais do módulo. A alimentação vai de 2.7V à 5.5V.

    Esse controle é configurado conforme a cor que queremos detectar. Usando a tabela abaixo, onde os pinos S0 e S1 definem a escala de frequência de saída de sinal, e os pinos S2 e S3 que determinam quais deles devem ser ativados para detectarmos a cor desejada.

    Para ligar o sensor de cor ao Arduino, utilizamos as portas digitais de 2 à 6 : o pino OUT do sensor ligado à porta 2, e os pinos de controle S0, S1, S2 e S3 ligados às portas 3, 4, 5 e 6 respectivamente. Vamos montar um circuito utilizando o Sensor de cor TCS3200 e um Display LCD 16×2, que mostra os valores de R, G e B (Vermelho,Verde e Azul) do objeto próximo ao sensor.

    O programa não utiliza nenhuma biblioteca específica, já que estamos trabalhando apenas com as portas digitais do Arduino. Para o display, utilizamos a biblioteca LiquidCrystal, que já está instalada na IDE do Arduino.

// Carrega a biblioteca do LCD
#include <LiquidCrystal.h>
 
// Definicoes dos pinos do sensor TCS3200
int s0=3,s1=4,s2=5,s3=6;
int flag=0;
int counter=0;
// Variaveis cores
int countR=0,countG=0,countB=0;
 
// Pinos do LCD
LiquidCrystal lcd(12, 11, 10, 9, 8, 7);
 
void setup()
 {
   // Inicializa o LCD
   lcd.begin(16, 2);
   // Mensagens iniciais no display
   lcd.setCursor(0,0);
   lcd.print("Cor : --------");
   lcd.setCursor(0,1);
   lcd.print("R:    G:    B:  ");
   Serial.begin(9600);
   // Define os pinos como saida
   pinMode(s0,OUTPUT);
   pinMode(s1,OUTPUT); 
   pinMode(s2,OUTPUT);
   pinMode(s3,OUTPUT);
}
 
void TCS()
{
  // Escala de Frequencia de Saida
  digitalWrite(s1,HIGH);
  digitalWrite(s0,LOW);
  flag=0;
  attachInterrupt(0, ISR_INTO, CHANGE);
  timer2_init();
}
 
void ISR_INTO()
{
  counter++;
}
 
void timer2_init(void)
{
  TCCR2A=0x00;
  TCCR2B=0x07; 
  TCNT2= 100;  
  TIMSK2 = 0x01;
}
 
// Leitura dos valores das cores
int i=0;
ISR(TIMER2_OVF_vect)
{
  TCNT2=100;
  flag++;
  if(flag==1)
  {
    counter=0;
  }
  else if(flag==2)
  {
    // Cor Vermelha (R)
    digitalWrite(s2,LOW);
    digitalWrite(s3,LOW); 
    countR=counter/1.051;
    lcd.setCursor(3,1);
    lcd.print(countR,DEC);
    digitalWrite(s2,HIGH);
    digitalWrite(s3,HIGH);   
  }
  else if(flag==3)
  {
    // Cor Verde (G)
    countG=counter/1.0157;
    lcd.setCursor(9,1);
    lcd.print(countG,DEC); 
    digitalWrite(s2,LOW);
    digitalWrite(s3,HIGH); 
  }
  else if(flag==4)
  {
    // Cor Azul (B)
    countB=counter/1.114;
    lcd.setCursor(15,1);
    lcd.print(countB,DEC);
    Serial.println(countB,DEC);
    digitalWrite(s2,LOW);
    digitalWrite(s3,LOW);
  }
  else
  {
    flag=0; 
    TIMSK2 = 0x00;
  }
    counter=0;
    delay(2);
}
 
void loop()
{
  delay(10);
  TCS();
  // Mostra a cor correspondente no display se
  // o valor da cor for maior do que 5
  if((countR>5)||(countG>5)||(countB>5))
   {
      if((countR>countG)&&(countR>countB))
       {
         lcd.setCursor(6,0);
         lcd.print("            ");   
         lcd.setCursor(6,0);
         lcd.print("Vermelho");
         delay(1000);
       }
      else if((countG>=countR)&&(countG>countB))
       {
         lcd.setCursor(6,0);
         lcd.print("            ");   
         lcd.setCursor(6,0);
         lcd.print("Verde");
         delay(1000);
       } 
     else if((countB>countG)&&(countB>countR))
      {
         lcd.setCursor(6,0);
         lcd.print("            ");   
         lcd.setCursor(6,0);
         lcd.print("Azul");
         delay(1000);
      }
    }
  else 
  {
     delay(100);       
  }
 }

    Para testar o circuito, coloque objetos próximos ao sensor e veja a variação de tons de vermelho (R), Verde (G) e Azul (B). Se uma das três cores ultrapassar o valor 5, a cor correspondente será mostrada na primeira linha do LCD. Para ajustar esse valor, altere a linha: if((countR>5)||(countG>5)||(countB>5))

    Troque o valor 5 por um valor de sua preferência. Altere também a subrotina TCS, que determina a frequência de escala de saída por meio dos pinos S0 e S1 e verifique a variação nos valores das cores.

O manual com diagrama elétrico da placa do Color Sensor TCS3200 está disponìvel em:  Color Sensor TCS3200.

O arquivo do diagrama elétrico Detector de cores estará disponível em: 21_03_27_Circuito_Detector_de_cores_SRG (PDF).

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

EX36 - 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