Início / Projetos Arduino / Projetos Squids / Intermediário / I20 - Como criar um cronômetro automático para medir velocidade - Sensores Reflexivos com Arduino

---

I20 - Como criar um cronômetro automático para medir velocidade - Sensores Reflexivos com Arduino

Angelo Luis Ferreira | 19/01/2023 Acessos: 3.879

Objetivo

Criar um cronômetro com acionamento automático para medir o tempo em que um objeto leva para ir de um ponto A para um ponto B. O projeto consiste em colocar um sensor ótico reflexivo para disparar o cronômetro no início do trajeto e um outro sensor no final do trajeto onde o objeto deve percorrer. O tempo cronometrado é exibido em um display LCD. Ao final da leitura, é exibido também a velocidade média em que o objeto se deslocou do sensor de partida até o sensor de chegada.

Utilizamos no projeto 2 módulos sensor de obstáculo reflexivo infravermelho que atuarão automaticamente para acionar o cronômetro ao detectar o objeto no início e parar o cronômetro ao detectar o objeto no final do trajeto pré definido.

Considerações importantes:

1. O módulo sensor de obstáculo reflexivo pode sofrer interferências se a iluminação externa estiver muito acentuada, podendo deixar o sensor ativado o tempo todo. Se isso acontecer, tente reduzir a iluminação externa onde será realizado o projeto.

1.1. O material do objeto que se deseja detectar também pode interferir no funcionamento do sensor. Quanto mais reflexivo o material, maior a distância que será detectado.

2. O alcance de detecção do sensor ótico reflexivo varia de 2 a 30cm, podendo ser ajustado por intermédio de um potenciômetro (trimpot) acoplado ao módulo. O alcance detecção é a distância de operação entre o sensor e o objeto a ser detectado.

2.1. Se precisar de distâncias maiores, você pode substituí-los por leds infravermelho (led emissor e led receptor) posicionados  para criar uma barreira invisível entre eles. Veja I12 - Cronômetro com pause controlado por leds infravermelhos - Arduino.

3. O módulo sensor de obstáculo reflexivo trabalha com lógica invertida, ou seja, quando não está detectando nenhum obstáculo, a sua saída se mantém em nível lógico alto (5V). Quando o sensor detecta algum obstáculo a sua tensão cai para próximo de zero, mantendo-se neste caso em nível lógico baixo (0V).

Definições

Módulo sensor de obstáculo reflexivo Infravermelho: Componente eletrônico constituído por dois LEDs infravermelhos paralelos. Esses dois LEDs são responsáveis por dizer se há ou não um objeto na frente do sensor. A foto abaixo mostra o  O sensor de obstáculo pode ser utilizado para automatizar sistemas de controle eletrônico e é muito utilizado em robôs seguidores de linha.

O módulo sensor de obstáculo é um componente composto por um emissor e um receptor Infravermelho, mais o CI comparador, que facilita a sua conexão com o Arduino, Pic ou Raspberry.

Led Emissor Infravermelho (IR): Led que emite um sinal IR (infrared ou infravermelho) que pode ser reconhecido por um componente receptor infravermelho. Projetado para emitir sinais infravermelhos em dispositivos remotos podem ser utilizados em projetos com microcontroladores. A faixa de luz emitida pelo led emissor 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.

Velocidade Média: Razão entre o deslocamento (caminho percorrido por um objeto) e o intervalo de tempo que foi necessário para percorrer esse caminho. No projeto, o caminho percorrido será a distância entre os sensores. Utilizaremos a unidade de medida para a velocidade média, definida pelo Sistema Internacional de Unidades (S.I.), que é m/s (metros por segundo).

Referências

I04 - Como usar o módulo sensor de refletância IR para identificar uma faixa - Arduino

I12 - Cronômetro com pause controlado por leds infravermelhos - Arduino

Como usar temporizadores no Arduino

Projeto 48 - Como controlar um display LCD com o módulo I2C

Projeto 38 - Controlando um display LCD (instalação e comandos básicos) (Caso não possua um módulo I2C e queria adaptar o projeto para usar o display LCD)

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
Módulo sensor de obstáculo reflexivo infravermelho	Módulo Sensor de Reflexivo Infravermelho	1		– Tensão de operação: 3,3 - 5,0 VDC - Circuito integrado controlador: LM393 – Distância máxima detecção: 30cm
Display LCD	Display LCD 16X2 com pinos soldados	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	1		1 LED alto brilho ou difuso (qualquer cor) Você poderá utilizar também LEDs de 3 mm na cor que desejar.
Resistor	Resistor 150Ω	1		1 Resistor de 150Ω ou superior - usar no led comum
Arduino UNO	Arduino UNO R3	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 energia elétrica 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.

1.1. Este projeto foi desenvolvido para um display LCD com controlador HD44780 em conjunto com o módulo serial I2C (soldado).

1.2.  Se você não possui um módulo I2C para display LCD, poderá adaptar o projeto para o display LCD sem o adaptador. Veja como montar o display no projeto Projeto 38 - Controlando um display LCD (instalação e comandos básicos).

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":

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.5. 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. Para a montagem do módulo sensor reflexivo no circuito faça a conexão como mostra a figura abaixo:

5.1. Conexão com o pino digital do Arduino: O fototransistor funciona com lógica invertida: quando ativado, ou seja, quando detecta um objeto qualquer, envia um sinal digital de baixo nível "0" (LOW). Quando não ativado, envia um sinal digital de alto nível "1" (HIGH).

5.1.1. A distância de operação do sensor irá depender da cor do material do objeto a ser detectado e da calibragem do módulo, que veremos mais adiante neste tutorial.

5.1.2. Quando utilizamos faixas ou objetos pouco reflexivos (cor preta), o fotoresistor não irá receber pouca ou nenhuma luz infravermelha e enviará um sinal em alto nível (HIGH). Quando ele detecta um piso mais claro, por exemplo, emitirá um sinal em baixo nível (LOW), ou vice e versa. Este é o princípio utilizado em carrinhos seguidores de linha.

5.2. Segue abaixo figura com as principais características do sensor de obstáculo reflexivo.

4. A montagem do nosso projeto foi realizada em um protoboard 400 pontos e dois mini protoboards que você poderá substituir por blocos de isopor (poliestireno expandido) ou papelão, por exemplo:

Testando a montagem do circuito

1. Para verificarmos se a montagem do circuito está correta, rode o sketch abaixo e verifique:

1.1. Ao aproximarmos um objeto ou o dedo do sensor esquerdo ou sensor direito, sem precisar tocá-los, o led irá acender. Distanciando o dedo ou um objeto de um do sensor, o led se apagará imediatamente.

int pinLed = 12;         // led conectado no pino digital 12
int pinSensorLeft = 2;   // módulo conectado no pino digital 2 (esquerdo)
int pinSensorRight = 3;  // módulo conectado no pino digital 3 (direito)
    
void setup(){ 
  pinMode(pinSensorLeft, INPUT);     // define como entrada
  pinMode(pinSensorRight, INPUT);    // define como entrada
  pinMode(pinLed, OUTPUT);           // define como saída   
  digitalWrite(pinLed, LOW);         // led inicia apagado
}  
   
void loop(){
  if (digitalRead(pinSensorLeft) == LOW || digitalRead(pinSensorRight) == LOW){ // se for LOW 
        digitalWrite(pinLed, HIGH);   // acende o led
  } else {                            // caso contrário
        digitalWrite(pinLed, LOW);    // apaga o led
  }    
}

Calibragem da distância de operação do módulo

1. O módulo sensor de obstáculo é fornecido com o potenciômetro (trimpot) para a calibragem.

1.1. Girando o botão no sentido horário ou sentido anti-horário, podemos aumentar ou diminuir a sensibilidade do sensor, aumentando ou diminuindo a distância de operação.

1.2. Utilizando o teste de montagem anterior, defina a melhor distância de operação que você deseja.

Atenção: A calibragem deverá ser feita para cada objeto específico, pois a distância de trabalho do sensor pode variar com o tipo de material (mais reflexivo ou menos reflexivo) e em função iluminação ambiente local.

Código do Projeto (Sketch)

1) Faça o dowload e abra o arquivo projetoI20.ino no IDE do Arduino: DOWNLOAD - projetoI22.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)

Obs.4: Altere o valor da variável distance, linha 20 do sketch, substituindo-o pela valor real da distância entre os sensores que você instalou. A distância medida deverá ser convertida em metros. Isso é necessário para calcular o valor da velocidade média real estimada, quando um objeto percorre o trajeto entre os dois sensores reflexivos instalados no seu projeto. Obs.: Neste exemplo utilizamos a distância de 20 centímetros, ou seja, 0,2 metros.

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

/*******************************************************************************
*
*    I20: Cronômetro e velocidade usando módulo infraRed (reflexivo)
*    Autor: Angelo Luis Ferreira
*    Data: 10/01/2022
*    
*             http://squids.com.br/arduino             
*
*******************************************************************************/
#include             //Carrega a biblioteca lcd com I2C

LiquidCrystal_I2C lcd(0x27,2,1,0,4,5,6,7,3, POSITIVE); // Cria instância do objeto "lcd"(biblioteca LiquidCrystal_I2C.h)

// Constantes de conexão do Arduino
const byte sensor1 = 2;                    // Pino Arduino em que o sensor reflexivo esquerdo está conectado
const byte sensor2 = 3;                    // Pino Arduino em que o sensor reflexivo direito está conectado
const byte led = 12;                       // Pino Arduino em que o led está conectado

// Variáveis iniciais
 float distance = 0.2;                     // distância entre os dois sensores reflexivos (altere com o valor real)
 uint32_t t = 0;                           // Variável para zerar o cronômetro
 uint32_t timer;                           // Variável para armazenar tempo do cronômetro em milissegundos

void setup() {
  Serial.begin(9600);                     // Inicia a comunicação serial (Monitor Serial)
  lcd.begin(16, 2);                       // Inicia e define o display com 16 colunas e 2 linhas (lcd c/ I2C)
  pinMode(sensor1, INPUT);                // Define o pino do sensor1 como entrada
  pinMode(sensor2, INPUT);                // Define o pino do sensor1 como entrada
  pinMode(led, OUTPUT);                   // Define o LED como saída
  digitalWrite(led, LOW);                 // Define led desligado
  reset();                                // zera o display do cronômetro
}

void loop() {
  checkSensor();                        // verifica se o sensor 1 foi ativado
}

void checkSensor() {
  if (!digitalRead(sensor1)) {          // SE sensor fototransistor (1) estiver ATIVADO
    digitalWrite(led, HIGH);            // led LIGADO 
    reset();                            // zera o display do cronômetor   
    t = millis();                       // seta início da contagem (zera a contagem)
    while (digitalRead(sensor2)) {      // aguarda ativar o sensor fototransistor (2) para parar o cronômetro
      cron();                           // cronometro ativo (rodando)
    }    
    digitalWrite(led, LOW);             // led DESLIGADO
    speedShow();                        // calcula e mostra a velocidade
  } else {                              // SE sensor fototransistor (1) estiver NÃO ATIVADO
    digitalWrite(led, LOW);             // led DESLIGADO
  }
}

// gera o cronômetro
void cron() {  
  // incia o cronômetro
  timer = (millis() - t);                // Armazerna em milissegundos o tempo do cronômetro     
  uint32_t segundos =  timer / 1000;     // Armazena em segundos o tempo do cronômetro

  //Mostra os valores no display LCD
  lcd.setCursor(7,0);
  lcd.print((segundos / 60) / 10);      // Dezena de minuto  
  lcd.setCursor(8,0);
  lcd.print((segundos / 60) % 10);      // Unidade de minuto
  lcd.setCursor(9,0);
  lcd.print(":");
  lcd.setCursor(10,0);
  lcd.print((segundos % 60) / 10);      // Dezena de segundo
  lcd.setCursor(11,0);
  lcd.print((segundos % 60) % 10);      // unidade de segundo
  lcd.setCursor(12,0);
  lcd.print(",");
  lcd.setCursor(13,0);
  lcd.print((timer / 10) % 10);         // Décimo de segundo
  lcd.setCursor(14,0);
  lcd.print((timer % 10) % 10);         // Centésimo de segundo 
}

// calcula e mostra a velocidade
void speedShow(){
  float milisecond = timer;                              // transforma a variável timer em float
  float avaregeSpeed = (distance/(milisecond/1000));     // calcula a velocidade média (V = metros/segundos)
  lcd.setCursor(0,1);
  lcd.print("Veloc: ");
  lcd.print(avaregeSpeed, 2);                            // imprime velocidade média na tela (2 casas decimais)
  lcd.print(" m/s");
}

// zera cronômetro
void reset() {
  //Zera cronômetro:
  lcd.clear();                            // Limpa display LCD
  lcd.setCursor(0,0);
  lcd.print("Timer: ");
  lcd.setCursor(7,0);                     // Posiciona o cursor no display coluna 4, linha 0 
  lcd.print("00:00,00");                  
}

Vídeo

Como o projeto deve funcionar

1. Ao iniciar o programa, o display LCD irá exibir os valores zerados no cronômetro, sendo: " 00:00,00".

2. Ao aproximar do sensor reflexivo esquerdo (partida) , inicia-se o a contagem do cronômetro. É exibido no display LCD os valores dos minutos, segundos e centésimos de segundos.

3. Quando o objeto se aproxima do sensor reflexivo direito (chegada), interrompe-se a contagem do cronômetro, indicando no display o tempo em que o objeto percorreu entre o sensor esquerdo (partida) e o sensor direito (chegada).

4. Após a interrupção do cronômetro ao chegar no sensor direito, é exibido também no display LCD a velocidade média em que o objeto percorreu essa distância.

5. Ao se aproximar novamente do sensor reflexivo esquerdo (partida) é reiniciado o ciclo, repetindo-o quantas vezes desejar.

Importante:

a) Não esqueça de calibrar os sensores, encontrando as distâncias adequadas entre o sensor e o objeto a ser detectado. Essa distância varia de 2 a 30cm.

b) A luz ambiente pode alterar a detecção dos objetos. Se você não conseguir resolver calibrando os sensores, reduza um pouca a iluminação do ambiente onde você está executando o projeto.

c) Para conseguir obter a velocidade média real (aproximada), é necessário alterar o programa com a distância medida entre os sensores

Desafios

Com base neste projeto, resolva o seguinte desafio:  Desafio 99

Comentários