Início / Projetos Arduino / Projetos Squids / Intermediário / I11 - Contador de visitantes com leds infravermelhos e Arduino

---

I11 - Contador de visitantes com leds infravermelhos e Arduino

Angelo Luis Ferreira | 15/03/2021 Acessos: 11.042

Objetivo

O objetivo deste projeto é criar um sistema de contagem de visitantes que entram e saem de uma sala. O sistema usará o Arduino e leds infravermelhos (receptores e emissores) para a contagem, e os dados serão exibidos em um display de LCD. Quando a sala ultrapassa o limite permitido de visitantes, o alarme é acionado.

Definições

Led Emissor Infravermelho (IR): Led que emite um sinal IR (infrared ou infravermelho) que pode ser reconhecido por um componente receptor IR. Projetado para emitir sinais infravermelhos em dispositivos remotos e se conectarem em uma placa microcontroladora. A faixa de luz emitida pelo led emissor, cujo comprimento de onda é de aproximadamente 940nm, não é perceptível ao olho humano.

Led Receptor (IR) - Fototransistor: Componente eletrônico que atua como um fotodiodo, permitindo a passagem de corrente elétrica somente com a presença de luz. O fototransistor é parecido com um transistor tradicional, possuindo 2 terminais sendo um o coletor e o outro o emissor, entretanto, a sua base base é ativada pela incidência de radiação infravermelha e não por um sinal digital.

Aplicação

Para fins didáticos e projetos de alarmes, interruptores, detecção de presença, detecção de obstáculos, contagem de elementos em uma esteira transportadora, controle remoto e sistemas robóticos.

Componentes necessários

Referência	Componente	Quantidade	Imagem	Observação
Protoboard	Protoboard 830 pontos	1		No mínimo utilizar protoboard com 400 pontos
Jumpers	Kit cabos ligação macho / macho	1
Led emissor IR	Led emissor IR 3mm ou 5mm	1		–Tensão de operação: 1,2 a 1,4VDC –Corrente de operação: 20mA –Comprimento da onda: 940nm
Fototransistor	Fototransistor 3mm ou 5mm	1		– Tensão de operação: 1,1 a 1,4VDC – Corrente de operação: 10mA – Potência máxima: 60mW – Comprimento da onda: 940nm
Display LCD	Display LCD 16X2	1		LCD que utilize o controlador HD44780 (veja na descrição ou datasheet do componente) O display poderá ser de qualquer cor (fundo verde, azul ou vermelho)
Módulo I2C para display LCD	Módulo I2C com CI PCF8574 (opcional)	1		O módulo I2C poderá vir separado ou já soldado no display LCD (datasheet) Se você não possui um módulo I2C para display LCD, poderá adaptar o projeto para o display LCD sem o adaptador.
Led 5mm	Led 5mm	2		2 LEDs alto brilho ou difuso, sendo um verde e um vermelho Você poderá utilizar também LEDs de 3 ou 5 mm na cor que desejar.
Resistor	Resistor 150Ω	4		Resistores de 150Ω ou superior (usar nos leds emissores e nos leds comuns)
Resistor	Resistor 10KΩ	2		2 Resistor de 4,7KΩ a 10KΩ (usar no fototransistor)
Buzzer	Buzzer ativo 5V 12mm	1		Utilize buzzer, módulo buzzer, auto falante ou um disco piezoelétrico
Arduino UNO	Arduino UNO	1		Você poderá utilizar uma placa Arduino UNO original ou similar

Montagem do Circuito

Conecte os componentes no Protoboard como mostra a figura abaixo. Verifique cuidadosamente os cabos de ligação antes de ligar seu Arduino. Lembre-se que o Arduino deve estar totalmente desconectado da força enquanto você monta o circuito.

Atenção

1. Neste projeto vamos utilizar um display LCD 16x2 com controlador HD44780, que se adapta aos mais diversos projetos com vários modelos de placas e microcontroladores. Este display possui 16 colunas por 2 linhas com backlight (luz de fundo) verde, azul ou vermelha e tem 16 pinos para a conexão. Atenção: Utilize um display LCD com os pinos soldados.

2. Para a montagem do display com adaptador, entenda a estrutura do módulo I2C para display LCD 16x2 / 20X4:

2.1. Na lateral do adaptador encontramos 4 pinos, sendo: 2 pinos para alimentação (Vcc e GND) e 2 pinos para conexão com a interface I2C (SDA e SCL) que deverão estar conectados nos pinos analógicos A4 (SDA) e A5 (SCL) do Arduino Uno ou nos pinos A20 (SDA) e A21 (SCL) do Arduino Mega 2560. Veja a tabela abaixo com onde temos as principais placas Arduino e suas conexões com o I2C.

2.2. Para controlar o contraste do display, utilize o potenciômetro de ajuste de contraste. O jumper lateral, quando utilizado, permite que a luz do fundo (backlight) seja controlada pelo programa ou permaneça apagada.

2.3. A seleção de endereço do adaptador I2C para display LCD, na maioria dos módulos fornecidos no mercado já vêm configurados com o com o endereço 0x27. Se você não sabe qual endereço que o seu módulo I2C e/ou módulo RTC DS3231 está configurado, baixe o seguinte "sketch":

DOWNLOAD - I2C_scanner.ino

2.3.1 Após instalar e rodar o sketch acima, abra o monitor serial que mostrará qual é o endereço que o seu módulo I2C e o módulo RTC DS3231 está configurado:

2.3.1.1 Nos casos em que módulo I2C estiver configurado com uma faixa de endereços diferente do endereço 0X27 altere a alinha de programação -> LiquidCrystal_I2C lcd(0x27,2,1,0,4,5,6,7,3, POSITIVE); com o endereço correto.

2.4. Para saber mais sobre a montagem e utilização de display LCD com módulo I2C leia: Projeto 48 - Como controlar um display LCD com o módulo I2C.

3. Lembre-se que o LED tem polaridade: O terminal maior tem polaridade positiva e o lado do chanfro tem polaridade negativa.

3.1. Portanto, faça a conexão do Arduino no terminal positivo do led (anodo) e o GND no terminal negativo (catodo).

3.2. Para evitar danos ao led é necessário a inclusão de um resistor no circuito. Como o resistor é um limitador da corrente elétrica, ele poderá estar conectado no anodo (terminal maior) ou no catodo (terminal menor) do led, tanto faz.

4. Determinamos o valor do resistor através da tabela prática: Tabela prática de utilização de leds 3mm e 5mm. Entretanto, o mais correto é sempre verificar o datasheet do fabricante do LED para você ter os exatos valores de tensão e corrente do mesmo - leia Leds ligados em série e em paralelo.

4.1. Valores utilizados para nossos projetos: LEDs difusos ou de alto brilho: Vermelho, Laranja e Amarelo: 150 Ω | Led Verde e Azul: 100 Ω

5. O buzzer tem polaridade. Portando, cuidado para não ligar o buzzer invertido. Se você retirar o adesivo superior do buzzzer poderá ver um sinal de positivo (+). Este sinal mostra onde está o pino positivo do componente que deverá estar conectado ao Arduino:

6. Agora monte os leds infravermelhos conforme orientações abaixo:

6.1. É importante salientar que o led emissor tem polaridade. Portanto, conecte o terminal positivo (anodo) no Vcc (5V) e o terminal negativo (catodo) no GND.

6.1.1. Para evitar danos ao led emissor, é necessário incluir um resistor igual ou superior a 100Ω. No nosso exemplo utilizamos resistores de 150Ω.

6.1.2. O resistor funciona como um limitador de corrente do circuito e poderá portanto, estar conectado em qualquer terminal do led, seja positivo ou negativo.

6.2. O Fototransistor funciona de forma similar que um transistor NPN, ou seja, é constituído de Base, Coletor e Emissor. Ao receber luz infravermelha, o fototransistor é ativado após saturação, enviando um sinal de baixo nível (LOW) para o Arduino.

6.2.1. Antes da montagem, observe com atenção a posição dos terminais do led fototransistor:

- Coletor: terminal mais curto (C);
- Emissor: terminal mais comprido (E);

6.2.2. Para a montagem do fototransistor, conecte o terminal maior (E - emissor) no GND e o terminal menor ou o lado com chanfro (C - coletor) em um pino analógico do Arduino. No nosso exemplo utilizamos as portas analógicas A1 e A2.

6.2.3. Para que haja estabilidade na recepção dos sinais será necessário a inclusão de um resistor entre 4,7KΩ e 10KΩ conectado no terminal do coletor do fototransistor (terminal mais curto) e no VCC (5V). Veja a imagem abaixo:

6.2.4. Conexão com o pino analógico do Arduino: o fototransistor envia um sinal analógico para o Arduino que será convertido em sinal digital através do ADC (Conversor Analógico Digital). Entretanto, podemos fazer a leitura digital do pino analógico através da função digitalRead(), onde será enviado um sinal de baixo ou de alto nível, dependendo se o fototransistor está recebendo ou não a luz infravermelha. Veja as condições abaixo:

6.2.4.1. Quando o fototransistor é bloqueado, ou seja, não recebe luz infravermelha, o valor enviado será 1 (HIGH). Entretanto, como a luz ambiente também emite radiação infravermelha, o fototransistor pode receber esta radiação e não acusar o bloqueio, mesmo com o filtro de luz que existe no componente. Portanto, o monitoramento da luz ambiente poderá ser necessário.

 6.2.4.2. Quando o fototransistor volta a receber luz infravermelha ele é ativado e envia um sinal de baixo nível 0 (LOW) para o Arduino.

6.3. Veja o esquema elétrico abaixo para a conexão de um sensor no Arduino. No nosso exemplo utilizamos R1 = 150Ω e R2 = 10KΩ

6. A montagem do nosso projeto foi realizada em um protoboard de 400 pontos e 2 mini-protoboards. Verifique se o seu protoboard possui linhas de alimentação contínuas ou separadas.

Incluindo biblioteca LiquidCrystal_I2C

Atenção: Caso você opte pela utilização do display de LCD sem o módulo I2C, siga os procedimentos do Projeto 38 - Controlando um display LCD (instalação e comandos básicos) e não instale a biblioteca abaixo.

Para que o módulo I2C funcione corretamente é necessário adicionarmos a biblioteca LiquidCrystal_I2C no IDE do Arduino. Uma das grandes vantagens das placas Arduino é a diversidade de bibliotecas disponíveis que podem ser utilizadas em seus programas. Estas bibliotecas podem ser criadas para a linguagem "C" ou especificamente para o Arduino, reduzindo drasticamente o tempo gasto com programação. Veja a tabela Coletânea de bibliotecas para módulos.

Download dos arquivos da biblioteca LiquidCrystal_I2C

 DOWNLOAD - NewliquidCrystal_1.3.4.zip

Para saber detalhes desta biblioteca clique aqui.

Instalando a biblioteca pelo IDE do Arduino

Após fazer o download do arquivo NewliquidCrystal_1.3.4.zip com todos os arquivos da biblioteca compactados no formato zip, abra o IDE do Arduino e siga o tutorial: Como incluir uma biblioteca no IDE do Arduino.

Utilizando a biblioteca LiquidCrystal_I2C

Para instalação e utilização da biblioteca para o módulo I2C como comunicação para um display LCD siga o tutorial: Projeto 48 - Como controlar um display LCD com o módulo I2C

Código do Projeto (Sketch)

1) Faça o dowload e abra o arquivo projetoI11.ino no IDE do Arduino:  DOWNLOAD - projetoI11.ino

Obs. 1: Nos casos em que módulo I2C estiver configurado com um endereço diferente do endereço 0X27, altere a alinha de programação -> LiquidCrystal_I2C lcd(0x27,2,1,0,4,5,6,7,3, POSITIVE); com o endereço correto. - Veja o tutorial Projeto 48 - Como controlar um display LCD com o módulo I2C

Obs. 2: Se estiver utilizando um display de LCD 20 X 4, altere o comando da linha 36 para lcd.begin (20,4);

Obs. 3: Se não possuir o módulo I2C utilize apenas o display LCD conforme Projeto 38 - Controlando um display LCD (instalação e comandos básicos).

Ou se preferir, copie e cole o código abaixo no IDE do Arduino:

/*******************************************************************************
*
*    Projeto I11 - Controle de visitantes - Arduino
*    Data: 11/03/2021
*    Autor: Angelo Luis Ferreira
*            http://squids.com.br/arduino
*
*******************************************************************************/
#include //Carrega a biblioteca lcd com I2C

//Define os pinos que serão utilizados para ligação ao display
LiquidCrystal_I2C lcd(0x27,2,1,0,4,5,6,7,3, POSITIVE);

// hardware - conexões
const byte pinoFotoEntradaSala = A1; // Pino analógico conectado ao fototransistor
const byte pinoFotoSaidaSala = A2; // Pino analógico conectado ao fototransistor
const byte pinoLedVerde = 12; // led verde
const byte pinoLedVermelho = 11; // led vermelho
const byte pinoBuzzer = 7; // buzzer
const byte pinoButton = 3; // push button

// variáveis
int toneVal = 0;
int toneAdjustment = 2000;
float sinVal;

int entrada = 0;
int saida = 0;

int contaSala = 0;
int limite = 10;

byte e = 0; // controle entrada
byte s = 0; // controle saíd

// =====================================================================================
// configuração inicial
void setup(){
  Serial.begin(9600); //Inicialização do monitor serial
  lcd.begin(16, 2); // Define o display com 16 colunas e 2 linhas
  lcd.clear();
  pinMode(pinoFotoEntradaSala, INPUT); //Define o pino como entrada no Arduino
  pinMode(pinoFotoSaidaSala, INPUT); //Define o pino como entrada no Arduino
  pinMode(pinoLedVerde, OUTPUT); // Define o pino como saída do Arduino
  pinMode(pinoLedVermelho, OUTPUT); // Define o pino como saída do Arduino
  pinMode(pinoButton, INPUT_PULLUP); // Defino o pino de entrada Arduino com pullup interno

  noTone(pinoBuzzer); // interrompe o tom 

  // acende led verde
  acendeLed();

  // mostra no lcd
  lcd.clear();
  show();
}

// =====================================================================================
// loop infinito
void loop(){

  entra(); // verifica acesso a entrada
  sai(); // verificar acesso a saída
  
  if (e == 2) {
    entrada++;
    show();
  }
  if (s == 2) {
    saida++;
    show();
  }

  // verifica se número de visitantes é maior que o limite
  if (contaSala > limite) sirene();

  // verifica se os dois sensores foram ativados
  if (s == 1 || e == 1) { // apenas um sensor foi ativoado
    ajustaSensores();
  } else zera(); // zera tudo se pressionar o botão
}

// FUNÇÕES ======================================================================================

// ajusta sensores
void ajustaSensores() {
   apagaLeds();
   
  if (!digitalRead(pinoButton)) {
    e = 0;
    s = 0;
    acendeLed();
    while (!digitalRead(pinoButton)) {}
    delay(50);
    monitora();
  }
}

// acessa sensor de entrada (primeiro sensor ao entrar)
void entra() {
   // verifica sensor de entrada
  if (digitalRead(pinoFotoEntradaSala)) {
    while (digitalRead(pinoFotoEntradaSala)) {} // aguarda passar pelo sensor   
     delay(50);          
     if (e == 0 && s == 0) {
      e = 1;
     } else if (e == 0 && s == 1) {
      s = 2;
     } else {
      e = 1;
      s = 0;
     }
    monitora(); 
 }
}

// acessa sensor de saída (primeiro sensor ao sair)
void sai() {
  // verifica sensor de saida
  if (digitalRead(pinoFotoSaidaSala)) {
    while (digitalRead(pinoFotoSaidaSala)) {} // aguarda passar pelo sensor
    delay(50);       
    
    if (s == 0 && e == 0) {
      s = 1;
     } else if (s == 0  && e == 1) {
      e = 2;
     } else {
      e = 0;
      s = 1;
     }
   monitora(); 
  } 
}

// zera tudo ao pressionar o botão
void zera() {
  if (!digitalRead(pinoButton)) {
    e = 0;
    s = 0;
    entrada = 0;
    saida = 0;
    contaSala = 0;
    show();
    while (!digitalRead(pinoButton)) {}
    delay(50);
    monitora();
  }
}

// mostra no lcd
void show() {
  calcula();
  tone(pinoBuzzer, 500);
  lcd.clear();
  // mostra número de pessoas dentro da sala
  lcd.setCursor(0,0);
  lcd.print("Na Sala: ");
  lcd.setCursor(9,0);
  lcd.print(contaSala);
  if (contaSala >= limite) {
    lcd.setCursor(13,0);
    lcd.print("LOT");
    if (contaSala > limite) sirene();
  } else {
    lcd.setCursor(12,0);
    lcd.print("L:");
    lcd.setCursor(14,0);
    lcd.print(limite - contaSala);    
  }
  noTone(pinoBuzzer); // interrompe o tom   
  // mostra número de pessoas que entraram
  lcd.setCursor(0,1);
  lcd.print("Ent: ");
  lcd.setCursor(5,1);
  lcd.print(entrada);
  // mostra número de pessoas que sairam
  lcd.setCursor(9,1);
  lcd.print("Sai: ");
  lcd.setCursor(14,1);
  lcd.print(saida);
  apagaLeds();
  delay(500);
  acendeLed();
  e = 0;
  s = 0;   
}

// calucla o número de visitantes na sala
void calcula() {
  // calcula o número de visitantes dentro da sala
  contaSala = entrada - saida;
  if (contaSala < 0) {
    contaSala = 0;
    saida = entrada;    
  }
}

// acende led Verde ou vermelho
void acendeLed() {
  if (contaSala >= limite) {
    digitalWrite(pinoLedVermelho, 1);
  } else {
    digitalWrite(pinoLedVerde, 1);
  }  
}

// apaga leds
void apagaLeds() {
  digitalWrite(pinoLedVerde, LOW);
  digitalWrite(pinoLedVermelho, LOW);
}

 // função sirene
void sirene(){
  //tocar
   tone(pinoBuzzer, 100); 
   delay(0);   
   noTone(pinoBuzzer); // interrompe o tom        
  }

// monitora "s" e "e"
void monitora() {
    Serial.print(e);
    Serial.print(" | ");
    Serial.println(s);
}

Vídeo

Como o projeto deve funcionar

1. Ao iniciar o programa, aparecerá na tela do display LCD os valores zerados para:  visitantes dentro da sala (Na Sala), visitantes que entraram na sala (Ent) e visitantes que saíram da sala (Sai). Mostra também quantos visitantes poderão entrar na sala, que no caso são 10 visitantes livres (L).

2. Ao passar no sentido de entrada (na figura abaixo - entra), o programa irá incrementar em 1 o número de visitantes que entram na sala e ao passar no sentido de saída (na figura abaixo - sai), os sensores irão incrementar em 1 os visitantes que saem da sala. Também serão exibidos no display LCD o total de pessoas que estão na sala (Na Sala) e o número de visitantes que ainda podem entrar (L).

2.2.1. Os visitantes somente podem entrar ou sair da sala quando o led verde estiver aceso.

 3. Quando a sala atingir o limite de visitantes, o led vermelho ficará aceso. Isto significa que visitantes não podem mais entrar na sala, somente podem sair.

4. Caso entre visitantes com o led vermelho aceso, um alarme irá ser disparado pelo buzzer.  Para desarmar o alarme, visitantes devem sair da sala para atingir o limite permitido.

5. ATENÇÃO: Para que o projeto funcione corretamente, é necessário que haja um alinhamento entre os emissores e os receptores. Poderá haver também uma interferência pela luz ambiente. Neste caso, procure reduzir a iluminação externa aos sensores.

5.1. Para monitorar se os sensores estão funcionando corretamente, abra o Monitor Serial. O número a esquerda representa o sensor de entrada, que pode ser 0 (não acionado), 1 (acionado 1 vez), 2 (quando os dois sensores forem acionados, porém, o sensor de entrada foi acionado primeiro). Já o número da direita representa o sensor de saída, que pode ser 0 (não acionado), 1 (acionado 1 vez), 2 (quando os dois sensores forem acionados, porém, o sensor de saída foi acionado primeiro).

 5.2. Sensor de entrada e sensor de saída

6. Reset: Para zerar todos valores, clique no botão (push button).

7. Correção: Podem ocorrer falhas quando o programa faz a leitura de apenas um sensor, por exemplo. Neste caso, se houver falha, os dois leds ficarão apagados. Para corrigir, clique no botão (push button) e espere o led verde ou vermelho acender para dar continuidade.

Comentários