Com a estrutura "mecânica" do nosso primeiro protótipo de carro robótico, vamos a partir de agora elaborar o funcionamento dos motores que devem fazer parte desse projeto.
Vamos começar estruturando o funcionamento, dei uma pesquisada e achei interessante fazermos para o nosso primeiro protótipo de carrinho robótico o mais comum encontrado feito pelos "hobbistas", um carrinho que desvia de obstáculos.
Antes da montagem final foi estruturado a parte de processamento e testes em protoboard, visando eliminar qualquer surpresa no projeto.
fonte; próprio autor
A ligação de todo o circuito conforme as fotos podem ser vistas no esquema abaixo.
fonte: próprio autor
Para entendermos melhor o funcionamento do nosso protótipo, vamos analisar a sua lógica de funcionamento. Abaixo está estruturado em fluxograma como deve funcionar o nosso carrinho.
fonte: próprio autor
E vamos aos testes. Foi montado em protoboard todo o esquema de funcionamento do sistema para um primeiro teste. De uma maneira geral funcionou bem, apresentando alguns pequenos erros, que atribuo aos contatos, geralmente montagem em "proto" apresenta muito mau contato, deixando o usuário maluco para descobrir o erro. Bem no vídeo é possível ver o funcionamento básico do protótipo.
Na terceira parte do projeto estarei apresentando o código fonte final com comentários e a montagem passo a passo da parte do processador e da eletrônica sobre a base do carrinho.
Curtiu? Compartilhe!
Acesse e inscreva-se no canal.
Define-se ponte H como um circuito da eletrônica que pertence à classe das potências e do tipo chopper, que permite variação na velocidade de motores DC, além da comutação de sentido na rotação por meio de um sinal PWM (pulse with modulation).
Recebem o nome de H devido a constituição de sua forma quando montado, é constituído de quatro chaves/ interruptores que comutam em pares simultaneamente, fazendo com que a corrente "passe"em uma direção ou em outra.
O acionamento das chaves devem ser sempre feitos na diagonal, evitando assim curto no circuito e mau funcionamento. A colocação de diodos entre as chaves também é um recurso útil para proteção e economia de energia quando ela não está em uso.
Existem componentes eletrônicos que facilitam a vida do usuário apresentando a ponte H pronta e aplicável em diversos circuitos, são alguns componentes como os L293, L293D, L298N, SN754410 e outros.
fonte: próprio autor
Módulo Ponte H L298N
Os módulos Ponte H L298N estão projetados para controlar não somente o sentido de rotação de motores por controle PWM dos Arduinos como também relés, motores de passo, motores DC e solenóides. Esse módulo já foi utilizado em um dos nossos projetos anteriores e demonstrou bastante capacidade de carga.
fonte: http://www.msseletronica.com/
Controlando motores com o drive Ponte H L298N
O módulo L298N possui terminais onde é possivel realizar a ligação de dois motores DC ou um motor de passo de 4 fios (1), pinos de controle do PWM dos motores onde o usuário escolhe controlar ou não a velocidade dos mesmos (2), saída regulada + 5V, quando jumper estiver acionado ou entrada de + 5V quando o módulo estiver sem o jumper (3), entrada para alimentação externa (4), GND (5) e pinos dos controles dos motores (6).
fonte: próprio autor
Motor DC
fonte: próprio autor
Usando o programa abaixo como teste, é possível acionar os motores (motor 1 e motor 2), fazendo com que os dois motores iniciem ligados juntos depois de um tempo determinado o motor 1 gire no sentido horário e anti-horário, pare e o motor 2 gire no sentido anti-horário e horário e pare, para logo iniciar o ciclo novamente.
/** Código Exemplo **/
// Elaborado por Tony Emerson Marim em 29/10/2016.
/** mecatronizei@gmail.com **/
/** Acionamento de motores CC**/
//Definicoes pinos Arduino ligados a entrada da Ponte H
int IN1 = 4;
int IN2 = 5;
int IN3 = 6;
int IN4 = 7;
void setup()
{
//Define os pinos como saida
pinMode(IN1, OUTPUT);
pinMode(IN2, OUTPUT);
pinMode(IN3, OUTPUT);
pinMode(IN4, OUTPUT);
}
void loop()
{
//Gira o Motor A no sentido horario
digitalWrite(IN1, HIGH);
digitalWrite(IN2, LOW);
//Gira o Motor B no sentido horario
digitalWrite(IN3, HIGH);
digitalWrite(IN4, LOW);
delay(2000);
//Para o motor A
digitalWrite(IN1, HIGH);
digitalWrite(IN2, HIGH);
//Para o motor B
digitalWrite(IN3, HIGH);
digitalWrite(IN4, HIGH);
delay(500);
//Gira o Motor A no sentido horario
digitalWrite(IN1, HIGH);
digitalWrite(IN2, LOW);
delay(1000);
//Para o motor A
digitalWrite(IN1, HIGH);
digitalWrite(IN2, HIGH);
delay(500);
//Gira o Motor B no sentido anti-horario
digitalWrite(IN3, LOW);
digitalWrite(IN4, HIGH);
delay(1000);
//Para o motor B
digitalWrite(IN3, HIGH);
digitalWrite(IN4, HIGH);
delay(500);
//Gira o Motor B no sentido horario
digitalWrite(IN3, HIGH);
digitalWrite(IN4, LOW);
delay(1000);
//Para o motor B
digitalWrite(IN3, HIGH);
digitalWrite(IN4, HIGH);
delay(500);
//Gira o Motor A no sentido anti-horario
digitalWrite(IN1, LOW);
digitalWrite(IN2, HIGH);
delay(1000);
//Para o motor A
digitalWrite(IN1, HIGH);
digitalWrite(IN2, HIGH);
delay(500);
}
fonte: próprio autor
Motor de passo
fonte: próprio autor
No programa exemplo vai ser acionado um motor de passo de forma que os pinos de saída do Arduino vão acionando as bobinas em pares, movimentando o motor em pequenos intervalos acionando-o.
*Lembrando que, no circuito não está demonstrado mas o fio de alimentação do motor de passo é conectado diretamente à fonte.*
/** Código Exemplo **/
// Elaborado por Tony Emerson Marim em 29/10/2016.
/** mecatronizei@gmail.com **/
/** Acionamento de motor de passo**/
// Conexoes modulo - Arduino
int IN1 = 4;
int IN2 = 5;
int IN3 = 6;
int IN4 = 7;
void setup()
{
// Define os pinos como saida
pinMode(IN1,OUTPUT);
pinMode(IN2,OUTPUT);
pinMode(IN3,OUTPUT);
pinMode(IN4,OUTPUT);
}
int tempo = 10;
void loop()
{
// Passo 1
digitalWrite(IN1, 1);
digitalWrite(IN2, 0);
digitalWrite(IN3, 0);
digitalWrite(IN4, 1);
delay(tempo);
// Passo 2
digitalWrite(IN1, 0);
digitalWrite(IN2, 1);
digitalWrite(IN3, 0);
digitalWrite(IN4, 1);
delay(tempo);
// Passo 3
digitalWrite(IN1, 0);
digitalWrite(IN2, 1);
digitalWrite(IN3, 1);
digitalWrite(IN4, 0);
delay(tempo);
// Passo 4
digitalWrite(IN1, 1);
digitalWrite(IN2, 0);
digitalWrite(IN3, 1);
digitalWrite(IN4, 0);
delay(tempo);
}
fonte: próprio autor
O procedimento de alimentação por meio de fonte externa também pode ser feito para motores DC que necessitam de uma tensão maior. É um procedimento parecido com esse que vamos adotar na concepção do nosso primeiro modelo de carro robótico.
No vídeo abaixo é demonstrado as ligações e os funcionamentos dos códigos.
Copie os códigos e execute para testar seu módulo Drive Ponte H.
Curtiu?Compartilhe e assine o canal para estarmos sempre melhorando o nosso trabalho.
Os servo motores são motores que no uso industrial funcionam geralmente com corrente contínua e destacam-se por sua rotação suave e uniforme, torque constante, baixo nível de ruído e de vibração e boa capacidade de sobrecarga.
Os servo motores necessitam de um sinal pulsado digital como referência, o PWM (pulse with modulation), controlado por sua largura e utiliza um sensor de posicionamento para verificar sua posição denominado encoder.
O encolder utiliza sensores ópticos instalados internamente que fornecem pulsos que são interpretados como direção, movimento ou direção.
Os micro servo motores seguem os mesmos princípios dos motores industriais, mas em escala reduzidas e de fácil aquisição no mercado atual. Assim como os servos industriais, os servos utilizados em protótipos robóticos são motores CC com um circuito de controle de posição acoplado e possuem uma faixa de posição fixa sem dar uma volta completa sobre seu eixo.
fonte: próprio autor
Compõem sua estrutura uma caixa onde encontram-se acondicionados todas as suas partes:
engrenagens de redução que são responsáveis pela redução da rotação do motor e transferem torque para o eixo principal, além de movimentar o potenciômetro acoplado ao mesmo;
motor;
potenciômetro, monitora a posição do eixo de controle;
circuito de controle, faz monitoramento do potenciômetro e o acionamento do motor obtendo uma posição pré-determinada
Para testar seu micro servo, copie e cole o código fonte exemplo. No primeiro exemplo o servo movimenta sua rotação com variações angulares de 0°, 90°, 180° e 45° constantemente e com intervalos de 2 segundos entre os movimentos e no segundo exemplo é possível conseguir movimentar o eixo do motor por meio de um potênciomentro.
Para esses exemplos devem ser usadas a biblioteca <Servo.h> que está inserida na IDE do próprio Arduino.
Exemplo 1
/** Código Exemplo **/
// Elaborado por Tony Emerson Marim em 29/10/2016.
/** mecatronizei@gmail.com **/
/** Sequencia angular do servo**/
//Carrega a biblioteca Servo
#include <Servo.h>
Servo motor;
void setup()
{
motor.attach(3);//Pino de controle do sinal do servo
}
void loop ()
{
motor.write(0);//movimento angula 1
delay(2000);
motor.write(90);//movimento angular 2
delay(2000);
motor.write(180);//movimento angular 3
delay(2000);
motor.write(45);//movimento angular 4
delay(2000);
}
Exemplo 2
/** Código Exemplo **/
// Elaborado por Tony Emerson Marim em 29/10/2016.
/** mecatronizei@gmail.com **/
/** Movimento angular do servo por potenciometro**/
//Carrega a biblioteca Servo
#include "Servo.h"
Servo motor;
void setup()
{
motor.attach(3);//Pino de controle do sinal do servo
}
void loop()
{
// Lê o valor do Potenciometro
int angle = analogRead(0);
// Mapeia o valor de 0 a 180 graus
angle=map(angle, 0, 1023, 0, 180);
// Repassa o angulo ao ServoWrite
motor.write(angle);
// Delay de 15ms para o Servo alcançar a posição
delay(15);
}
Ligação do circuito
A ligação do circuito para o funcionamento é simples, existem conectados ao Servo 3 fios, vermelho normalmente relacionado ao pino de alimentação +5V, preto ou marrom no GND e laranja ou branco conectado ao pino de controle do Arduino que pode ser definido pelo usuário.
No blog existem diversos outros artigos de projetos que podem ser revistos ou usados como exemplo em outras aplicações, como o Braço robótico. Vamos voltar a aplicar os conceitos do servo motor durante as próximas etapas de fabricação dos nossos carros robóticos.
Um dos projetos realizados com microcontroladores que mais despertam o interesse no assunto é o desenvolvimento de carros robóticos, onde o usuário tem a possibilidade de deixar a imaginação fluir e desenvolver situações desafiadoras para fazer com que seu "carrinho" supere todos os limites e situações.
fonte: próprio autor
Para que o projeto se torne viável e o desenvolvedor entenda seu funcionamento, usa-se costumeiramente diversos componentes que existem no mercado e que venha a atender a necessidade da lógica utilizada por cada um. Mas antes de começarmos a projetar e demonstrar alguns modelos de carro robótico existem alguns elementos comuns em todos eles.
O primeiro modelo que vou apresentar é montado em um chassi comum encontrado no mercado, com dois motores elétricos DC com redução e um rodízio livre.
Vamos começar a montagem do chassi. Lembrando que o exemplo que está sendo mostrado no artigo é somente uma sugestão, ficando livre para o usuário buscar a melhor maneira de acoplar os componentes na plataforma.
fonte: próprio autor
fonte: próprio autor
fonte: próprio autor
fonte: próprio autor
A primeira etapa da montagem depois de concluída deve ter essa aparência, podendo assim passarmos para as etapas de programação e funcionamento do nosso primeiro carro robótico.
No gif abaixo está a versão 1.0 do carrinho que fiz a alguns meses atrás e deve ser parecido com uma das versões que iremos realizar durante os artigos futuros.
fonte: próprio autor
No próximo artigo, estaremos estudando um módulo que já foi usado em um dos nossos projeto, o módulo Ponte H.
O display TFT 2.4" LCD shield é a solução para quem procura uma alternativa com tela touch para seus projetos com Arduino.
Com uma resolução de 320 x 240 px , esquema de cores de 18 bits e exibição de até 262k tonalidades diferentes, além de um slot para cartão de memória SD e tela touch resistiva.
Outro ponto favorável para essa telinha LCD é o baixo custo e é claro, sua plicação deixa qualquer projeto mais bonito e interessante.
fonte: próprio autor
A shield LCD Touch fica com um design bonito em qualquer escolha de Arduino Uno ou Mega, eu particularmente prefiro quando acoplado junto ao Mega devido a sua maior quantidade de I/Os.
Conectando LCD ao Arduino
Na tabela abaixo segue uma descrição da pinagem da ligação do LCD ao Arduino, lembrando que essa montagem foi testada em dois modelos de placas microcontroladas, Arduino Uno e Arduino Mega.
fonte: próprio autor
A facilidade do projeto permite que a LCD seja conectada diretamente nos pinos do Arduino, mas muita ATENÇÃO, na parte traseira do Shield existe um capacitor SMD, que deve ser cuidadosamnte isolado para evitar acidentes com seu hardware.
fonte: próprio autor
Código fonte teste
/**Teste LCD Touch
//** Elaborado por Tony Marim
//** Baseado no código original de FILIPEFLOP
/** mecatronizei@gmail.com **/
#include <Adafruit_GFX.h> // Core graphics library
#include <Adafruit_TFTLCD.h> // Hardware-specific library
//Definicao de cores
#define BLACK 0x0000
#define BLUE 0x001F
#define RED 0xF800
#define GREEN 0x07E0
#define CYAN 0x07FF
#define MAGENTA 0xF81F
#define YELLOW 0xFFE0
#define WHITE 0xFFFF
//CS, CD, WR, RD, RESET
Adafruit_TFTLCD tft(A3, A2, A1, A0, A4);
void setup(void)
{
Serial.begin(9600);
Serial.println("Teste de LCD 8 Bits");
tft.reset();
delay(500);
tft.begin(0x9341);
}
void loop()
{
tft.setRotation(3);
teste_texto(RED);
delay(5000);
tft.setRotation(0);
teste_linhas(GREEN);
delay(50);
teste_retangulo_cheio(BLUE, RED);
delay(50);
tft.fillScreen(BLACK);
teste_circulos(10, YELLOW);
delay(50);
teste_triangulos();
delay(500);
teste_retangulos();
delay(500);
}
void teste_texto(uint16_t color)
{
tft.fillScreen(BLACK);
tft.setTextColor(WHITE);
tft.setTextSize(3);
tft.setCursor(0, 20);
tft.println("MECATRONIZANDO");
tft.setTextColor(RED);
tft.setCursor(0, 50);
tft.println("Curta");
tft.setTextColor(BLUE);
tft.setCursor(0, 80);
tft.println("Compartilhe");
tft.setTextColor(GREEN);
tft.setCursor(0, 110);
tft.println("Inscreva-se");
tft.setTextColor(GREEN);
tft.setCursor(0, 150);
tft.println("mecatronizar.blog");
delay(2000);
}
void teste_linhas(uint16_t color)
{
tft.fillScreen(BLACK);
for (uint16_t x = 0; x < tft.width(); x += 6)
{
tft.drawLine(0, 0, x, tft.height() - 1, color);
}
for (uint16_t y = 0; y < tft.height(); y += 6)
{
tft.drawLine(0, 0, tft.width() - 1, y, color);
}
}
void teste_retangulo_cheio(uint16_t color1, uint16_t color2)
{
tft.fillScreen(BLACK);
for (uint16_t x = tft.width() - 1; x > 6; x -= 6)
{
tft.fillRect(tft.width() / 2 - x / 2, tft.height() / 2 - x / 2 , x, x, color1);
tft.drawRect(tft.width() / 2 - x / 2, tft.height() / 2 - x / 2 , x, x, color2);
}
}
void teste_circulos(uint8_t radius, uint16_t color)
{
for (uint16_t x = radius; x < tft.width(); x += radius * 2)
{
for (uint16_t y = radius; y < tft.height(); y += radius * 2) {
tft.fillCircle(x, y, radius, YELLOW);
}
}
for (uint16_t x = 0; x < tft.width() + radius; x += radius * 2)
{
for (uint16_t y = 0; y < tft.height() + radius; y += radius * 2)
{
tft.drawCircle(x, y, radius, GREEN);
}
}
}
void teste_triangulos()
{
tft.fillScreen(BLACK);
for (uint16_t i = 0; i < tft.width() / 2; i += 5)
{
tft.drawTriangle(tft.width() / 2, tft.height() / 2 - i,
tft.width() / 2 - i, tft.height() / 2 + i,
tft.width() / 2 + i, tft.height() / 2 + i, tft.Color565(0, 0, i));
}
}
void teste_retangulos()
{
tft.fillScreen(BLACK);
for (uint16_t x = tft.width(); x > 20 ; x -= 6)
{
tft.fillRoundRect(tft.width() / 2 - x / 2, tft.height() / 2 - x / 2 , x, x, x / 8, tft.Color565(0, x, 0));
}
}
Para esse código foram utilizadas bibliotecas que você pode baixar ao final do post com todos os arquivos do projeto.
Diversas imagens são apresentadas na tela e imprime algumas strings.
fonte:próprio autor
Acionando Leds por touch
No próximo código uma tela com algumas opções são apresentadas ao usuário, que pode fazer uso das opções para acionamentos diversos, e como dizemos, "onde eu aciono um led, eu aciono quase tudo!"
Para a execução desse projeto você deve ter à disponibilidade:
* o modelo do LCD apresentado no esquema se difere do apresentado em vídeo devido a sua falta no software Fritzing*
Nesse programa, saídas digitais são acionadas quando o comando é dado via touch na tela de 2.4'', fazendo com que os leds acendam na ordem que o usuário desejar.
Assim como em diversos projetos demonstrados em posts anteriores, uma eletrônica de potência pode ser capaz de fazer acionamentos com tensões maiores, tornando a aplicação mais interessante para acionamentos em automações residenciais ou industriais.
Uma aplicação desse tipo vai ser apresentado a seguir.
Acionando dispositivos
Vamos fazer dois acionamentos distintos com potências diferentes para demonstrar o funcionamento do circuito.
Você precisa ter em mãos além do Arduino e do LDC TFT 2.4":
No vídeo é demonstrado o funcionamento de dispositivos distintos que fazem uso de potências distintas, o acionamento da lâmpada ocorre por meio de contato "seco" pelo módulo relé, enquanto a trava faz usos da capacidade de inversão de sentido para ser acionada e desacionada presente no módulo ponte H, estudaremos mais a fundo esse módulo brevemente na construção de alguns projetos.
Como de costume os arquivos para a reprodução desse projeto encontra-se nesse LINK. Muito obrigado e continue acompanhando o blog, curtindo a página no Facebook e compartilhando o canal
O módulo de sensor ultrassônico HC-SR04 é comumente usado em projetos com Arduino
para realização em leituras de distâncias que podem variar entre 2 centímetros e 4 metros, permitindo uma precisão de 3 milímetros.
Baseado no envio e recebimento de sinais ultrassonicos pelos sensores, calcula a distância entre o sensor e o objeto com base no tempo entre o envio (Trigger) e o retorno (Echo) do sinal.
O inicio de transmissão ocorre com um pulso de 10 us, seguido por 8 pulsos de 40 KHz, ode o sensor aguarda o retorno, determinando uma distância por meio de uma equação onde:
Distância = (Tempo Echo * velocidade do som) /2
Conexão com o Arduino
A ligação do Arduino com o módulo sensor ultrassônico é bastante simples: no modulo são encontrados 4 pinos, VCC, Trigger, ECHO e GND.
Abaixo um exemplo de ligação do módulo em um Arduino Uno.
fonte: próprio autor
Código fonte (exemplo)
//Teste Sensor Ultrassonico
//Elaboração: Tony Emerson Marim
//=== http://mecatronizar.blogspot.com.br ===
//
// Baseado no programa original de FILIPEFLOP
//Carrega a biblioteca do sensor ultrassonico
#include <Ultrasonic.h>
//Define os pinos para o trigger e echo
#define pino_trigger 2
#define pino_echo 3
//Inicializa o sensor nos pinos definidos acima
Ultrasonic ultrasonic(pino_trigger, pino_echo);
void setup()
{
Serial.begin(9600);
Serial.println("Lendo dados do sensor...");
}
void loop()
{
//Le as informacoes do sensor, em cm e pol
float cmMsec, inMsec;
long microsec = ultrasonic.timing();
cmMsec = ultrasonic.convert(microsec, Ultrasonic::CM);
inMsec = ultrasonic.convert(microsec, Ultrasonic::IN);
//Exibe informacoes no serial monitor
Serial.print("Distancia em cm: ");
Serial.print(cmMsec);
Serial.print(" - Distancia em milimetros: ");
Serial.println((float)cmMsec*10.0);
Serial.print(" - Distancia em polegadas: ");
Serial.println(inMsec);
delay(1000);
}
No código acima uma leitura de distância em três unidades diferentes centímetro, milímetro e polegada e imprime os valores medidos no monitor serial do Arduino.
Para o funcionamento ideal desse módulo, faz-se necessário declarar no código fonte uma biblioteca Ultrassonic.h, que estarei disponibilizando ao final do projeto.
fonte: próprio autor
Projeto medidor de distâncias
Vamos nesse projeto fazer uso de um sensor ultrassônico para funcionar como uma trena eletrônica fazendo medidas de objetos colocados à sua frente, e mostrando em um display LCD as distâncias medidas.
Os componentes usados para a construção do projeto são:
1 Aruino (estarei usando um Arduino nano nessa demonstração)
1 protoboard
1 módulo sensor HC-SR 04
1 visor LCD 16x2
1 potênciometro 10Kohm
1 transistor 2N2222 (NPN)
2 resistores 10Kohm
1 pushbutton
1 buzzer 5VCC
cabos jumper
fonte: próprio autor
Quando o botão for acionado sinais ultrassônicos são disparados pelo sensor até localizar um objetos e calcular o tempo de retorno exibindo o valor da distância.
Existe no projeto um transistor 2N2222 tipo NPN um resistor e um potenciômetro, ambos com uma resistência de 10Kohms, responsáveis para o funcionamento do display a cada leitura. Um buzzer faz com que o usuário se atente para uma condição onde o dispositivo fica fora do alcance para medição e o retorno de toda leitura vai ser demonstrada em um visor LCD 16X2.
Para o funcionamento do visor segue um tutorial simples da ligação de um visor LCD no arduino (tutorial) onde está disponível também informações sobre a biblioteca necessária para seu funcionamento.
Esquema de ligação
Seguindo o desenho abaixo todos os componentes necessários para o funcionamentos estão expostos como sugestão para o sistema.
fonte: próprio autor
O código fonte
//Medidor com Ultrassonico e LCD
//Elaboração: Tony Emerson Marim
//=== http://mecatronizar.blogspot.com.br ===
// Variáveis do processo
int l = 255;
int PINO_TRIGGER = 9;
int PINO_ECHO = 8;
#define BUTTON 10
#define LUMIN 7
#define PINO_TRIGGER 9
#define PINO_ECHO 8
#define NOTE_A4 440
// Bibliotecas utilizadas
#include <LiquidCrystal.h>
#include <Ultrasonic.h>
// Pinagem utilizada na biblioteca do LCD
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
void setup() {
pinMode(BUTTON, INPUT);
pinMode(PINO_TRIGGER, OUTPUT );
pinMode(PINO_ECHO, INPUT );
pinMode(LUMIN, OUTPUT);
Serial.begin( 115200 );
Serial.println( "Ultrasonic ranging module: ");
// Especificação de coluna e linha na LCD
lcd.begin(16, 2);
}
void loop() {
while(digitalRead(BUTTON) == LOW) { // Estado da leitura enquanto sinal baixo
analogWrite(LUMIN, 0);
lcd.clear();
noTone(6);
}
analogWrite(LUMIN, l);
digitalWrite(PINO_TRIGGER, LOW); // sinal baixo no pino Trigger
digitalWrite(PINO_TRIGGER, HIGH); // envia pulso de 10us no pino
delayMicroseconds( 100 );
digitalWrite(PINO_TRIGGER, LOW);
long duration = pulseIn(PINO_ECHO, HIGH);
long r = 3.4 * duration / 2; // Lógica matemática da distância
float distance = r / 100.00;
lcd.setCursor(0, 0);
lcd.print("tempo: ");
lcd.print(duration);
lcd.print(" us ");
lcd.setCursor(0, 1);
if( duration > 38000 ) {
lcd.println("fora de alcance ");
tone(6, NOTE_A4);
} // condição se duração for maior que 38ms para encontrar um obstáculo
else {
lcd.print("dist: ");
lcd.print(distance); lcd.println(" cm "); noTone(6);
}
delay( 5000 ); // tempo ativo na LCD para leitura dos dados
}
Nesse circuito o sensor ultrassom de pois de enviar uma rajada de pulsos, calcula a distância do objeto e retorna o valor em unidades métricas para ser exibida pela LCD, que também recebe o tempo de retorno do trabalho executado. Caso o objeto esteja fora de alcance do sensor um sinal sonoro é emitido até que se torne possível encontrar o obstáculo.
fonte: prórpio autor
No vídeo abaixo é possível assistir uma demonstração do circuito em funcionamento.
Você pode encontrar para baixar a biblioteca do módulo Ultrasonic nesse LINK.
Caso seja necessário, todos os arquivos para realização do projeto encontra-se nesse LINK.
Gostou? Curta nossa página no Facebook, assine nosso canal e compartilhe nossos vídeos!
