Como usar apds9960 rgb e sensor de gestos com arduino

Hoje, a maioria dos telefones vem com recurso de controle de gestos para abrir ou fechar qualquer aplicativo, iniciar música, atender chamadas, etc. Este é um recurso muito útil para economizar tempo e também parece legal para controlar qualquer dispositivo com gestos. Anteriormente, usamos o acelerômetro para construir um robô controlado por gestos e um mouse aéreo controlado por gestos. Mas hoje aprendemos a fazer a interface de um sensor de gesto APDS9960 com o Arduino. Este sensor também possui um sensor RGB para detecção de cores, que também será utilizado neste tutorial. Portanto, você não precisa usar sensores separados para detecção de gestos e cores, embora um sensor dedicado para detecção de cores esteja disponível - o sensor de cores TCS3200 que já usamos com o Arduino para construir uma máquina de classificação de cores.

Componentes Requeridos

1. Arduino UNO
2. APDS9960 RGB e Sensor de Gestos
3. LCD 16x2
4. Chave DPDT
5. Pot 100K e resistor de 10K
6. Cabos Jumper

Introdução ao APDS-9960 RGB de proximidade digital e sensor de gestos

APDS9960 é um sensor multifuncional. Ele pode detectar gestos, luz ambiente e valores RGB na luz. Este sensor também pode ser usado como sensor de proximidade e é usado principalmente em smartphones, para desativar a tela sensível ao toque durante o atendimento a uma chamada.

Este sensor consiste em quatro fotodiodos. Esses fotodiodos detectam a energia infravermelha refletida que é transmitida por um LED integrado. Assim, sempre que qualquer gesto é realizado, essa energia IR fica obstruída e reflete de volta para o sensor, agora o sensor detecta a informação (direção, velocidade) sobre o gesto e a converte em informação digital. Este sensor pode ser usado para medir a distância do obstáculo detectando a luz infravermelha refletida. Possui filtros de bloqueio de UV e IV para detecção de cores RGB e produz dados de 16 bits para cada cor.

A pinagem do sensor APDS-9960 é mostrada abaixo. Este sensor funciona no protocolo de comunicação I ² C. Consome 1 µA de corrente e é alimentado por 3,3 V, portanto, tome cuidado e não o conecte com pino de 5 V O pino INT aqui é o pino de interrupção, que é usado para conduzir a comunicação I ² C. E o pino VL é o pino de alimentação opcional para o LED on-board se o jumper PS não estiver conectado. Se o jumper PS estiver fechado, você só precisará alimentar o pino VCC, ele fornecerá energia para ambos - o módulo e o LED IV.

Diagrama de circuito

As conexões para APDS960 com Arduino são muito simples. Usaremos um botão DPDT para alternar entre os dois modos RGB Sensing e Gesture Sensing. Em primeiro lugar, os pinos de comunicação I2C SDA e SCL do APDS9960 são conectados ao pino A4 e A5 do Arduino, respectivamente. Conforme declarado anteriormente, a tensão operacional para o sensor é 3,3 V, portanto, VCC e GND do APDS9960 são conectados a 3,3 V e GND do Arduino. O pino de interrupção (INT) do APDS9960 é conectado ao pino D2 do Arduino.

Para LCD, os pinos de dados (D4-D7) são conectados aos pinos digitais D6-D3 do Arduino e os pinos RS e EN são conectados aos D6 e D7 do Arduino. V0 do LCD é conectado ao potenciômetro e um potenciômetro de 100K é usado para controlar o brilho do LCD. Para os botões DPDT, usamos apenas 3 pinos. O segundo pino é conectado ao pino D7 do Arduino para entrada e os outros dois são conectados ao GND e VCC seguido por um resistor de 10K.

Programando Arduino para Gestos e Detecção de Cores

A parte de programação é simples e fácil e o programa completo com um vídeo de demonstração é fornecido no final deste tutorial.

Primeiro, precisamos instalar uma biblioteca feita por Sparkfun. Para instalar esta biblioteca, navegue até Sketch-> Incluir Biblioteca-> Gerenciar Bibliotecas.

Agora na barra de pesquisa digite “Sparkfun APDS9960” e clique no botão instalar ao ver a biblioteca.

E estamos prontos para ir. Vamos começar.

Portanto, primeiro devemos incluir todos os arquivos de cabeçalho necessários. O primeiro arquivo de cabeçalho LiquidCrystal.h é usado para funções de LCD. O segundo arquivo de cabeçalho Wire.h é usado para a comunicação I ² C e o último SparkFun_APDS996.h é usado para o sensor APDS9960.

#incluir #incluir #incluir

Agora, nas próximas linhas, definimos os pinos do botão e do LCD.

const int buttonPin = 7; const int rs = 12, en = 11, d4 = 6, d5 = 5, d6 = 4, d7 = 3; LiquidCrystal lcd (rs, en, d4, d5, d6, d7);

Na próxima parte, definimos uma macro para o pino de interrupção que está conectado no pino digital 2 e uma variável buttonState para o estado atual do botão e isr_flag para a rotina de serviço de interrupção.

#define APDS9960_INT 2 int buttonState; int isr_flag = 0;

Em seguida, um objeto é criado para o SparkFun_APDS9960, para que possamos acessar os movimentos dos gestos e buscar os valores RGB.

SparkFun_APDS9960 apds = SparkFun_APDS9960 (); uint16_t ambient_light = 0; uint16_t red_light = 0; uint16_t green_light = 0; uint16_t blue_light = 0;

Na função de configuração , a primeira linha é buscar o valor do botão (baixo / alto) e a segunda e terceira linhas definem a interrupção e o pino do botão como entrada. apds.init () inicializa o sensor APDS9960 e o lcd.begin (16,2) inicializa o LCD.

void setup () { buttonState = digitalRead (buttonPin); pinMode (APDS9960_INT, INPUT); pinMode (buttonPin, INPUT); apds.init (); lcd.begin (16, 2); }

Na função de loop , a primeira linha obtém os valores do botão e os armazena na variável buttonState definida anteriormente. Agora nas próximas linhas estamos verificando os valores do botão, se estiver alto então habilitamos o sensor de luz e se estiver baixo inicializamos o sensor de gestos.

O attachInterrupt () é uma função usada para interrupção externa que neste caso é interrupção do sensor. O primeiro argumento nesta função é o número de interrupção. No Arduino UNO, existem dois pinos digitais de interrupção - 2 e 3 indicados por INT.0 e INT.1. E o conectamos ao pino 2, então escrevemos 0 lá. O segundo argumento chama a função interruptRoutine () que é definida posteriormente. O último argumento é FALLING para que ele acione a interrupção quando o pino vai de alto para baixo. Saiba mais sobre as interrupções do Arduino aqui.

void loop () { buttonState = digitalRead (buttonPin); if (buttonState == HIGH) { apds.enableLightSensor (true); }

Na próxima parte, verificamos o pino do botão. Se estiver alto, inicie o processo para o sensor RGB. Em seguida, verifique se o sensor de luz está lendo valores ou não. Se não for capaz de ler os valores, nesse caso, imprima o " Erro ao ler os valores da luz". E se ele puder ler os valores, compare os valores das três cores e o que for mais alto, imprima essa cor no LCD.

if (buttonState == HIGH) { if (! apds.readAmbientLight (ambient_light) - ! apds.readRedLight (red_light) - ! apds.readGreenLight (green_light) - ! apds.readBlueLight (blue_light)) { lcd.print ("Erro ao ler os valores da luz"); } else { if (red_light> green_light) { if (red_light> blue_light) { lcd.print ("Red"); atraso (1000); lcd.clear (); } ……. ………..

Nas próximas linhas verifique novamente o pino do botão, e se estiver baixo o processo do sensor de Gestos. Em seguida, verifique se há isr_flag e, se for 1, uma função detachInterrupt () é chamada. Esta função é usada para desligar a interrupção. A próxima linha chama o handleGesture () que é uma função definida posteriormente. Nas próximas linhas, defina isr_flag como zero e anexe a interrupção.

else if (buttonState == LOW) { if (isr_flag == 1) { detachInterrupt (0); handleGesture (); isr_flag = 0; attachInterrupt (0, interruptRoutine, FALLING); } }

A próxima é a função interruptRoutine () . Esta função é usada para transformar a variável isr_flag em 1, para que o serviço de interrupção possa ser inicializado.

void interruptRoutine (). { isr_flag = 1; }

A função handleGesture () é definida na próxima parte. Esta função verifica em primeiro lugar a disponibilidade do sensor de gestos. Se estiver disponível, ele lê os valores do gesto e verifica qual gesto é (PARA CIMA, PARA BAIXO, DIREITA, ESQUERDA, DISTANTE, PRÓXIMO) e imprime os valores correspondentes no LCD.

void handleGesture () { if (apds.isGestureAvailable ()) { switch (apds.readGesture ()) { case DIR_UP: lcd.print ("UP"); atraso (1000); lcd.clear (); pausa; case DIR_DOWN: lcd.print ("DOWN"); atraso (1000); lcd.clear (); pausa; case DIR_LEFT: lcd.print ("LEFT"); atraso (1000); lcd.clear (); pausa; case DIR_RIGHT: lcd.print ("RIGHT"); atraso (1000); lcd.clear (); pausa; case DIR_NEAR: lcd.print ("NEAR"); atraso (1000); lcd.clear (); pausa; case DIR_FAR: lcd.print ("FAR"); atraso (1000); lcd.clear (); pausa; padrão: lcd.print ("NENHUM"); atraso (1000); lcd.clear (); } } }

Finalmente, carregue o código para o Arduino e espere o sensor inicializar. Agora, enquanto o botão está DESLIGADO, significa que está no modo de gestos. Portanto, tente mover as mãos nas direções esquerda, direita, para cima e para baixo. Para um gesto distante , mantenha sua mão a uma distância de 2-4 polegadas do sensor por 2-3 segundos e remova-a. E para um gesto de aproximação, mantenha sua mão longe do sensor, aproxime-a e remova-a.

Agora ligue o botão para colocá-lo no modo de detecção de cor e pegue os objetos vermelhos, azuis e verdes um por um perto do sensor. Irá imprimir a cor do objeto.