Primeiros Passos com o BRIICK APDS-9960

Introdução

Já pensou em controlar seus projetos Maker com gestos como o Tom Cruise em Minority Report? Com o Briick Sensor de Gestos e Cores APDS-9960, que é capaz de ler gestos, isso é possível! Além disso, ele também é capaz de ler proximidade, luz ambiente e cores. Realmente um sensor completo.

Neste tutorial veremos como instalar a biblioteca para leitura do sensor e como ler todas as funcionalidades do sensor, para você poder controlar seus projetos sem precisar tocar em nada.

Lista de Materiais

Lista completa de produtos

comprar

BlackBoard Edge

R$ 142,40 no PIX

BRIICK - Sensor de Gestos e Cores APDS-9960

R$ 47,40 no PIX

Cabo USB Micro B 80cm

R$ 9,40 no PIX

Observação: a BlackBoard Edge é vendida "sozinha", portanto é necessário adquirir um cabo Micro USB separadamente se não possuir um.

Conceitos Teóricos

Antes de colocarmos a mão na massa e utilizar o sensor na prática, vamos entender um pouco melhor como ele funciona.

Detecção de Gestos

Para a detecção de gestos, o sensor APDS-9960 utiliza um LED IR e quatro fotodiodos dispostos em forma de um quadrado, como mostrado na imagem abaixo. O encapsulamento do sensor conta com lentes especiais que foram dimensionadas para otimizar ao máximo o funcionamento do LED IR e dos fotodiodos, o que faz com o sensor seja preciso na detecção de gestos.

disposicao-componentes — Disposição dos Componentes do Sensor
Fonte: MyTecTutor

Com essa disposição dos fotodiodos, o sensor é capaz de detectar os gestos pela ordem/sentido da reflexão da luz IR emitida pelo LED interno. Por exemplo, se você passar sua mão da esquerda para a direita, o sensor da esquerda verá a reflexão de luz primeiro; em seguida os sensores de cima e baixo verão com menos intensidade; e por último o sensor da direita verá a reflexão da luz. Desta forma, o microcontrolador interno do sensor interpreta a sequência de leituras dos sensores, verifica se é um dos gestos conhecidos/esperados e então transmite para o microcontrolador principal (no caso do ESP32 da Edge) o gesto lido. Feito isso, cabe a nós, desenvolvedores de projetos, atuarmos da maneira que quisermos de acordo com os gestos lidos.

Detecção de Proximidade

O sensor também se aproveita da reflexão da luz IR do LED para medir a proximidade de obstáculos à frente do sensor. Isso é feito de maneira semelhante à detecção de gestos, porém, ao invés de ler um fotodiodo de cada vez, o microcontrolador do sensor lê a tensão de saída de todos os fotodiodos e calcula uma média das leituras para retornar a proximidade do obstáculo detectado.

Leitura de Luz Ambiente e Cores

Além dos fotodiodos de detecção de gestos, o sensor APDS-9960 também conta com 4 fotodiodos adicionais que possuem filtro para luz IR, e cada um é específico para um tipo específico de cor de luz RGBC (Red "R" - Vermelho, Green "G" - Verde, Blue "B" - Azul e Clear "C"- Branco). Com estes fotodiodos sozinhos, o microcontrolador do sensor é capaz de medir a variação de tensão de cada um deles e retornar para o microcontrolador principal a intensidade de luz de cada cor.

Circuito

Os módulos Briick foram desenvolvidos para facilitar a vida do maker, portanto o circuito elétrico é extremamente simples. Basta conectar a BlackBoard Edge ao módulo utilizando o cabo incluso com o módulo, como na imagem abaixo.

conexao-modulo — Conexão do Módulo à Placa

Vale lembrar que vários módulos Briick podem ser conectados em série e tanto faz a posição dos módulos nesta linha, todos funcionarão corretamente.

Instalação da Biblioteca

Para ler todas as funções do sensor APDS-9960, precisamos instalar uma biblioteca, e isso pode ser feito diretamente pelo "Gerenciador de Bibliotecas" da Arduino IDE. Para abri-lo na Arduino IDE 2.0, clique sobre o ícone de livros na barra lateral. Caso esteja utilizando uma IDE anterior à versão 2.0, siga o caminho da imagem a seguir, ou pressione "Ctrl+Shift+l".

caminho-gerenciador — Caminho para o "Gerenciador de Bibliotecas"

Com o gerenciador aberto, independentemente da versão, digite "apds-9960" no campo de pesquisa e busque pela biblioteca desenvolvida pela Sparkfun, como demarcado na imagem abaixo.

Com a biblioteca encontrada, pressione o botão "Instalar" e aguarde alguns instantes. Assim que a biblioteca estiver instalada, será apresentada uma etiqueta "Instalada" ao lado da versão da biblioteca, como na próxima imagem.

biblioteca-instalada — Biblioteca Instalada

Testes das Funcionalidades

Como o sensor APDS-9960 possui três funcionalidades distintas, iremos testá-las separadamente, até porque o sensor deve ser configurado para cada modo de operação.

A partir deste momento gravaremos os códigos de demonstração na BlackBoard Edge. Portanto, caso ainda não tenha feito as configurações iniciais dela, siga o tutorial Primeiros Passos com a BlackBoard Edge.

Leitura de Proximidade

Código

A primeira funcionalidade que veremos deve ser a mais simples do sensor, que é a de proximidade. Para isso, carregue o código a seguir para a sua Edge.

/*******************************************************************************
* Primeiros Passos com o Briick APDS-9960 (v1.0)
* 
* Codigo para exibir a leitura de proximidade com o APDS-9960.
* 
* Copyright 2023 RoboCore.
* Escrito por Giovanni de Castro (23/02/2023).
* 
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version (<https://www.gnu.org/licenses/>).
*******************************************************************************/

// Adicao da biblioteca
#include <SparkFun_APDS9960.h>

// Criacao do objeto para leitura do sensor
SparkFun_APDS9960 apds = SparkFun_APDS9960();

// Variavel que armazenara a leitura de proximidade do sensor
uint8_t proximidade = 0;

void setup() {
  
  // Inicializacao do monitor serial
  Serial.begin(115200);
  
  // Inicializacao da comunicacao I2C com o sensor
  if ( apds.init() ) {
    Serial.println("Sensor APDS-9960 iniciado com sucesso!");
  } else {
    Serial.println("Falha na inicializacao do sensor...");
  }
  
  // Configura o sensor para operar no modo de leitura de proximidade
  if ( apds.enableProximitySensor(false) ) {
    Serial.println("Sensor configurado para modo de leitura de proximidade!");
  } else {
    Serial.println("Falha na configuracao de modo de operacao do sensor...");
  }
  
  Serial.println("Aproxime ou afaste um objeto do sensor...");
}

void loop() {
  
  // Verifica se ha leitura de proximidade disponivel, e se sim, salva o valor na variavel "proximidade"
  if ( apds.readProximity(proximidade) ) {
    // Exibe a leitura no monitor serial
    Serial.print("Proximidade: ");
    Serial.println(proximidade);
  }
  
  delay(250);
  
}

Entendendo o Código

No início do código incluímos a biblioteca instalada anteriormente e criamos o objeto apds para a leitura do sensor através da biblioteca. Em seguida, para finalizar as declarações globais do código, criamos a variável proximidade para armazenar as leituras de proximidade coletadas pelo sensor.

Já nas configurações do código, iniciamos o monitor serial na velocidade de 115200 bps, verificamos a inicialização da comunicação I2C com o sensor através da condição if (apds.init()) e verificamos se a configuração do sensor foi realmente salva para o modo de leitura de proximidade através da condição if (apds.enableProximitySensor(false)) (o parâmetro "false" indica que a interrupção do sensor está desativada).

Por fim, na repetição do código, verificamos se o sensor possui uma leitura de proximidade disponível e se ela foi salva corretamente à variável proximidade através do comando if (apds.readProximity(proximidade)). Caso essa condição seja verdadeira, exibimos a leitura no monitor serial, a cada 250 milissegundos.

O Que Deve Acontecer

Após carregar o código para a placa, abra o monitor serial com a velocidade de 115200 bps e veja que o valor retornado irá variar entre 0 (sem obstáculos próximos) e 255 (menor proximidade ao sensor), como mostrado na captura de tela a seguir.

resultado-proximidade — Resultado da Leitura de Proximidade

Leitura de Luz e Cores

Código

A próxima função que testaremos é a de leitura de luz ambiente e cores do sensor. Para isso, carregue o código a seguir para a sua Edge.

/*******************************************************************************
* Primeiros Passos com o Briick APDS-9960 (v1.0)
* 
* Codigo para exibir a leitura de luz ambiente e de cores RGB pelo APDS-9960.
* 
* Copyright 2023 RoboCore.
* Escrito por Giovanni de Castro (23/02/2023).
* 
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version (<https://www.gnu.org/licenses/>).
*******************************************************************************/

// Adicao da biblioteca
#include <SparkFun_APDS9960.h>

// Criacao do objeto para leitura do sensor
SparkFun_APDS9960 apds = SparkFun_APDS9960();

// Declaracao das variaveis que armazenarao as leituras de luminosidade
uint16_t luz_ambiente = 0;
uint16_t luz_vermelha = 0;
uint16_t luz_verde = 0;
uint16_t luz_azul = 0;

void setup() {
  
  // Inicializacao do monitor serial
  Serial.begin(115200);

  // Inicializacao da comunicacao I2C com o sensor
  if ( apds.init() ) {
    Serial.println("Sensor APDS-9960 iniciado com sucesso!");
  } else {
    Serial.println("Falha na inicializacao do sensor...");
  }
  
  // Start running the APDS-9960 light sensor (no interrupts)
  if ( apds.enableLightSensor(false) ) {
    Serial.println("Sensor configurado para modo de leitura de luz!");
  } else {
    Serial.println("Falha na configuracao de modo de operacao do sensor...");
  }
  
  Serial.println("Aproxime objetos coloridos e tampe o sensor...");

}

void loop() {
  
  // Verifica se ha leitura de luz ambiente disponivel
  if ( apds.readAmbientLight(luz_ambiente) ){
    // Exibe o valor no monitor serial
    Serial.print("Ambiente: ");
    Serial.print(luz_ambiente);
  }
  // Verifica se ha leitura de luz vermelha disponivel
  if ( apds.readRedLight(luz_vermelha) ){
    // Exibe o valor no monitor serial
    Serial.print(" | Vermelho: ");
    Serial.print(luz_vermelha);
  }
  // Verifica se ha leitura de luz verde disponivel
  if ( apds.readGreenLight(luz_verde) ){
    // Exibe o valor no monitor serial
    Serial.print(" | Verde: ");
    Serial.print(luz_verde);
  }
  // Verifica se ha leitura de luz azul disponivel
  if ( apds.readBlueLight(luz_azul) ){
    // Exibe o valor no monitor serial
    Serial.print(" | Azul: ");
    Serial.println(luz_azul);
  }
  
  delay(100);
  
}

Entendendo o Código

Este código se inicia da mesma forma que o código anterior, com a inclusão da biblioteca e a criação do objeto de leitura do sensor pela biblioteca. Além disso, também são criadas as variáveis que armazenarão as leituras das luzes RGBC do sensor.

Já nas configurações do código, da mesma forma que no código anterior, iniciamos o monitor serial e a comunicação I2C com o sensor, e então verificamos se a configuração do sensor foi realmente salva para o modo de leitura de proximidade através da condição if ( apds.enableLightSensor(false) ) (o parâmetro "false" indica que a interrupção do sensor está desativada).

Por fim, verificamos se há uma leitura de luz respectiva para cada tipo de luz RGBC disponível pelo sensor e se as leituras foram salvas corretamente para as respectivas variáveis. Se cada condição for verdadeira, as leituras são exibidas no monitor serial a cada 100 milissegundos.

O Que Deve Acontecer

Após carregar o código para a placa, abra o monitor serial com a velocidade de 115200 bps e veja as leituras de luminosidade do padrão RGBC. Cubra o sensor com a sua mão e veja que o valor de todas as leituras reduzirão. Além disso, aproxime objetos vermelhos, verdes e azuis do sensor (o alcance do sensor não é muito grande, então o objeto deve estar bem próximo) e veja que o valor da cor do objeto aproximado será maior do que os valores das demais cores.

resultad-luz-cores — Resultado da Leitura de Luz e Cores

Leitura de Gestos

Código

Por fim, veremos a funcionalidade mais empolgante do sensor, que é a de detecção de gestos. Para testar essa funcionalidade, grave o código abaixo para a sua Edge.

/*******************************************************************************
* Primeiros Passos com o Briick APDS-9960 (v1.0)
* 
* Codigo para exibir a deteccao de gestos pelo APDS-9960.
* 
* Copyright 2023 RoboCore.
* Escrito por Giovanni de Castro (23/02/2023).
* 
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version (<https://www.gnu.org/licenses/>).
*******************************************************************************/

// Adicao da biblioteca
#include <SparkFun_APDS9960.h>

// Criacao do objeto para leitura do sensor
SparkFun_APDS9960 apds = SparkFun_APDS9960();

void setup() {

  // Inicializacao do monitor serial
  Serial.begin(115200);

  // Inicializacao da comunicacao I2C com o sensor
  if ( apds.init() ) {
    Serial.println("Sensor APDS-9960 iniciado com sucesso!");
  } else {
    Serial.println("Falha na inicializacao do sensor...");
  }
  
  // Configura o sensor para operar no modo de deteccao de gestos
  if ( apds.enableGestureSensor(false) ) {
    Serial.println("Sensor configurado para modo de leitura de gesto!");
  } else {
    Serial.println("Falha na configuracao de modo de operacao do sensor...");
  }
  
  Serial.println("Faca um gesto acima do sensor...");

}

void loop() {

  // Verifica se ha leitura de gestos disponiveis
  if ( apds.isGestureAvailable() ) {
    // Realiza a leitura de gestos do sensor, e exibe no monitor serial o gesto identificado
    switch ( apds.readGesture() ) {
      case DIR_UP:
        Serial.println("Detectado um gesto para CIMA");
        break;
      case DIR_DOWN:
        Serial.println("Detectado um gesto para BAIXO");
        break;
      case DIR_LEFT:
        Serial.println("Detectado um gesto para ESQUERDA");
        break;
      case DIR_RIGHT:
        Serial.println("Detectado um gesto para DIREITA");
        break;
      case DIR_NEAR:
        Serial.println("Detectado um gesto de APROXIMACAO");
        break;
      case DIR_FAR:
        Serial.println("Detectado um gesto para AFASTAMENTO");
        break;
      default:
        Serial.println("Gesto invalido ou nao compreendido pelo sensor...");
    }
    Serial.println("");
  }
  
  delay(50);
  
}

Entendendo o Código

Iniciamos este código da mesma forma que os códigos anteriores, sem a necessidade de variáveis para armazenar as leituras do sensor, mas configurando-o para a operação de leitura de gestos (condição de verificação if (apds.enableGestureSensor(false)), novamente sem interrupção).

Já na repetição do código, verificamos se há leituras de gestos disponíveis através da condição if (apds.isGestureAvailable()) e então, através de uma condição "switch-case", verificamos o retorno da função apds.readGesture() e exibimos o gesto detectado pelo sensor no monitor serial.

O Que Deve Acontecer

Após carregar o código para a placa, abra o monitor serial com a velocidade de 115200 bps e faça um dos gestos abaixo, tomando como referência o sensor "de pé", ou seja, com a legenda da barra de pinos para baixo.

CIMA: mover a mão de baixo para cima;
BAIXO: mover a mão de cima para baixo;
ESQUERDA: mover a mão da direita para a esquerda;
DIREITA: mover a mão da esquerda para a direita;
APROXIMAÇÃO: mover a mão centralizada no sensor, de longe para perto do sensor;
AFASTAMENTO: mover a mão centralizada no sensor de perto para longe do sensor;

Esses gestos devem ser feitos com certa proximidade do sensor (melhor eficiência entre 2 e 5 cm) e é melhor fazer um movimento relativamente lento.

De toda forma, ao fazer gestos sobre o sensor, você verá que será retornado o gesto feito. Caso o sensor não identifique algum gesto, tente aproximar a mão do sensor e fazer o gesto mais lentamente.

resultado-gestos — Resultado da Leitura de Gestos

Conclusão

Neste tutorial vimos qual biblioteca utilizar para ler todas as funcionalidades do Briick APDS-9960 e agora você já pode implementar essas funcionalidades nos seus projetos.