Telêmetro laser de fase caseiro. Telêmetro ultrassônico Precisão de medição de distância com sensor HC SR04

Hoje veremos outro dispositivo auxiliar eletrônico que certamente será útil em um canteiro de obras (e qualquer homem estará envolvido na construção mais cedo ou mais tarde) - um medidor de distância ultrassônico com display LCD. Quando você precisa medir a distância entre objetos ou um tamanho pequeno, uma fita métrica comum vem imediatamente à mente. Isso se justifica quando se trabalha com tamanhos pequenos - até alguns metros. Mas quando você precisar medir a altura de uma casa, a distância entre paredes adjacentes em uma sala grande, um telêmetro ultrassônico eletrônico será simplesmente insubstituível. Isto se aplica especialmente à medição da altura dos tetos - afinal, você não estará procurando uma escada ou cadeiras de escalada. No geral, esta é uma daquelas ferramentas que deve ter. E para economizar, esse exemplar foi encomendado no site dealextreme.

  • tela de LCD
  • Medição de distância - até 20 metros
  • Precisão: ± 1,0 cm
  • Iluminação a laser
  • Unidades: pés/metros
  • Alimentado por bateria G6F22 (incluída)
  • Preço no Dilextream - $ 22

A especificação técnica descreve que a precisão da medição é de 1 cm. Se você comparar os telêmetros ultrassônicos com os laser, é claro que eles são um pouco inferiores em precisão, mas lembre-se de que essas são categorias de preços diferentes. Se você precisar de um telêmetro de até um milímetro, terá que gastar mais de US$ 50, e isso raramente se justifica.

Aqui o laser brilha durante a medição - e um ponto aparece na superfície por um segundo. O medidor pode fornecer leituras falsas ao refletir o sinal em algumas superfícies curvas complexas. Você deve medir cada ponto, em posições diferentes, cerca de 3 vezes para garantir que está obtendo leituras boas e confiáveis.

Circuito telêmetro

O circuito é baseado em um processador EM78P468NQS e alguns amplificadores operacionais LM358 E LM833. As informações são exibidas em uma grande tela LCD. Realmente não tem luz de fundo, mas achamos que ninguém fará trabalho no escuro :)

O medidor é muito econômico; as baterias incluídas duram muito tempo, pois o consumo de corrente é mínimo.

O controle do dispositivo é simples - ligue a energia pressionando o botão LIGADO DESLIGADO e pressione brevemente a tecla central. Neste caso, o emissor do telêmetro deve ser mantido estritamente perpendicular ao plano de medição. Para isso, existe ainda um pequeno nível na caixa, com bola de ar e marcas.

Existe uma função interessante para calcular automaticamente a área de uma sala. Para fazer isso, pressione o botão modo e meça sequencialmente o comprimento, altura e largura. Imediatamente temos na tela o valor da área ou de todo o volume.

Conclusão

Em alguns casos, você realmente só precisa de uma fita métrica comum e, às vezes, um telêmetro ultrassônico será muito útil. São como hexágonos – todos eles têm que estar lá. Mais cedo ou mais tarde, alguém será necessário. E 500-1000r não é muito dinheiro para este dispositivo. Além disso, a qualidade de construção é excelente e está funcionando bem há um ano.

Discuta o artigo ULTRASSÔNICO RANGE FINDER

Neste artigo falarei sobre como fiz um telêmetro a laser e o princípio de seu funcionamento. Deixe-me observar imediatamente que o design é uma maquete e não pode ser usado para uso prático. Isso foi feito apenas para garantir que fosse realista montar você mesmo o telêmetro de fase.

Teoria

Muitas vezes surge a opinião de que, com a ajuda de um laser, a distância é medida apenas medindo diretamente o tempo de “vôo” do pulso de laser do laser até o objeto refletor e vice-versa. Na verdade, este método (chamado pulso ou tempo de voo, TOF) é usado principalmente em casos onde as distâncias ao objeto desejado são bastante grandes (>100m). Como a velocidade da luz é muito alta, é muito difícil medir com precisão o tempo de voo da luz e, portanto, a distância, em um pulso de laser. A luz viaja 1 metro em aproximadamente 3,3 ns, portanto a precisão da medição do tempo deve ser de nanossegundos, embora a precisão da medição da distância ainda seja de dezenas de centímetros. Para medir intervalos de tempo com tanta precisão, são utilizados FPGAs e microcircuitos especializados.

Vídeo do telêmetro em ação:

O alcance operacional do telêmetro resultante era bastante pequeno: 1,5-2 m, dependendo da refletância do objeto.
Para aumentar o alcance, você pode usar um refletor especial para o qual o feixe de laser deverá ser direcionado.
Para experimentos, fiz um refletor de lente, composto por uma lente com papel fosco no foco. Este desenho reflete a luz para o mesmo ponto de onde foi emitida, porém, o diâmetro do feixe aumenta.
Foto do refletor:

Uso do refletor:


Como você pode ver, a distância até o refletor é de 6,4 metros (na realidade era cerca de 6,3). Neste caso, o sinal aumenta tanto que deve ser atenuado direcionando o feixe de laser para a borda do refletor.

A precisão do telêmetro resultante é de 1 a 2 centímetros, o que corresponde à precisão da medição da mudança de fase - 0,2 a 0,5 graus. Ao mesmo tempo, para atingir tal precisão, a média dos dados precisa ser calculada por muito tempo - uma medição leva 0,5 segundos. Isso pode ser devido ao uso de PLL para geração de sinal - ele apresenta bastante jitter. Embora eu acredite que para um protótipo caseiro, cuja parte analógica é feita de maneira um tanto desajeitada e que contém fios bastante longos, mesmo essa precisão é bastante boa.
Observo que não consegui encontrar na Internet um único projeto de telêmetro de fase existente (pelo menos com um diagrama de projeto), razão pela qual escrevi este artigo.

Tag:

  • telêmetro a laser
  • stm32
  • stm32f4discovery
Adicionar tags

O Sensor Ultrassônico de Proximidade HC-SR04 (e módulos similares) usa ondas ultrassônicas para determinar a distância até um objeto.

De modo geral, precisaremos descobrir a distância até o objeto, pois o próprio sensor simplesmente leva em consideração o tempo que leva para captar o eco das ondas sonoras que envia. É assim:

  1. O módulo envia ondas sonoras e ao mesmo tempo aplica tensão a um pino de eco especial.
  2. O módulo capta o sinal refletido e remove a tensão do pino.

Isso é tudo que um telêmetro ultrassônico faz. Podemos determinar a distância nós mesmos, porque sabemos quanto tempo o som levou para viajar do módulo e voltar (por quanto tempo o pino de eco ficou energizado) e também sabemos a velocidade do som no ar. Mas não entraremos em muitos detalhes e deixaremos o Arduino fazer todos os cálculos.

A propósito, apesar do princípio de funcionamento de todos os sensores ultrassônicos ser o mesmo, NEM TODOS ELES produzem a mesma saída de tensão no pino de eco. Portanto, se você possui um módulo diferente do HC-S04, então preste atenção no quarto passo, que descreve possíveis problemas, e verifique se o seu módulo está na lista. Se não estiver lá, você terá que descobrir por conta própria.

Etapa 1: montagem de hardware DIY

A montagem é muito simples (montar tudo desconectado da tensão):

  1. Conecte 5V do Arduino ao pino VCC no módulo
  2. Conecte o GND do Arduino ao GND no módulo
  3. Conecte o pino digital 7 do Arduino ao pino Trig do módulo
  4. Conecte o módulo digital 8 do Arduino ao pino Echo do módulo

Etapa 2: Programando o Módulo HC-SR04

Para ver os resultados do programa, você precisa executar o serial monitor no Arduino. Se você não está familiarizado com esse recurso, agora é a hora de abri-lo e aprender mais sobre ele – é uma ótima ferramenta para ajudá-lo a depurar seu código. Na interface do Arduino, olhe no canto direito, lá você encontrará um botão que inicia o monitor serial, parece uma lupa, clique nele e o monitor abrirá (ou selecione TOOLS/Serial Monitor, ou pressione Ctrl+ Shift+M).

Aqui está um esboço do programa de trabalho:

// Início do Sketch para Aruino -
// Define constantes (constantes não mudam e se você tentar redefini-las você receberá um erro em tempo de compilação)
const int triggerPin = 7; // cria uma constante chamada "triggerPin" e atribui o pino digital 7 a ela
const int echoPin = 8; // cria uma constante chamada "echoPin" e atribui o pino digital 8 a ela
// Definir variáveis ​​(as variáveis ​​podem e geralmente mudam durante o programa, elas podem conter quaisquer valores calculados)
duração interna = 0; // cria uma variável chamada "duration" para armazenar o valor retornado por pulseIn, inicialmente definido como "0"
distância interna = 0; // cria uma variável para armazenar um valor calculado como a distância até o objeto na frente do sensor, inicialmente o valor é definido como “0”
void setup() // Nesta seção você pode configurar sua placa e outros parâmetros necessários para a execução do seu programa.
{
Serial.begin(9600); // inicializa a comunicação serial via USB entre o Arduino e o computador, precisaremos disso
//define modos de pin
pinMode(triggerPin, SAÍDA); // “triggerPin” será usado para OUTPUT, o número do pino é declarado acima na seção “Definindo Variáveis”
pinMode(echoPin, INPUT); // “echoPin” será usado para INPUT, o número do pino é declarado acima na seção “Definindo Variáveis”
) // fim da configuração
// tudo o que foi escrito acima é lido pelo programa apenas uma vez - na inicialização ou no reset
void loop() // o código do programa na parte em loop é lido continuamente e repetido até que a energia seja desligada ou até que um reset seja feito
{
digitalWrite(triggerPin, ALTO); //começa a enviar ondas ultrassônicas do módulo HC-SR04
atraso(5); // uma pequena pausa, é necessária para que o módulo funcione corretamente (você pode reduzir este valor, meus outros programas funcionam com valor 1)
digitalWrite(triggerPin, LOW); //interrompe as ondas ultrassônicas provenientes do módulo HC-SR04
duração = pulseIn(echoPin, HIGH); //função especial que permite determinar o período de tempo em que a tensão foi aplicada ao pino de eco no último ciclo de ultrassom concluído
atraso(10); // novamente uma pequena pausa. É necessário para a estabilidade; uma pausa muito curta pode não produzir resultados.
distância = (duração/2) / 58; //converte duração em distância (o valor armazenado em “duração” é dividido por 2, então esse valor é dividido por 58**) ** para centímetros
atraso(500); // outra pausa para estabilidade - você pode brincar com o valor, mas isso pode arruinar o programa, então use 500 por padrão
Serial.print(distância); //envia o valor da distância calculada para o monitor serial
Serial.println("cm"); //adiciona a palavra “cm” após o valor da distância e move o cursor no monitor serial para uma nova linha
Serial.println(); //adiciona uma linha em branco no monitor serial (para facilitar a leitura)
) // Fim do loop

_________________________________________________

Assim, depois de ler minhas instruções, percebi que o esboço do programa não correspondia à minha compreensão de simplicidade. Portanto, estou postando o mesmo esboço com comentários leves.

//Programa do módulo sensor de distância ultrassônico HC-SC04
const int triggerPin = 7; //aciona para 7
const int echoPin = 8; // ECO às 8
duração interna = 0; // armazena o valor de pulseIn
distância interna = 0; // armazena o valor da distância calculada
configuração nula()
{
Serial.begin(9600);
pinMode(triggerPin, SAÍDA); //define os modos de pin
pinMode(echoPin, INPUT);
}
loop vazio()
{
digitalWrite(triggerPin, ALTO); //começa a enviar ultrassom
atraso(5); //comando necessário, configurável (mas não inferior a 10 microssegundos)
digitalWrite(triggerPin, LOW); // módulo para de enviar ultrassom
duração = pulseIn(echoPin, HIGH); //determina por quanto tempo o pino ECHO ficou energizado
atraso(10); //comando necessário, configurável, mas com cuidado
distância = (duração/2) / 58; //calcula a distância em cm do objeto
atraso(500); //pausa para estabilidade, diminuir pode quebrar o fluxo do programa, é melhor deixar como está
Serial.print(distância); //envia o valor atual armazenado em distância para o monitor serial
Serial.println("cm"); // exibe a palavra "cm" imediatamente após a distância
Serial.println(); // cria uma linha vazia no monitor serial (para facilitar a leitura)
}

Também anexarei arquivos .ino às instruções

arquivos

  1. HCSR04BareBones.ino - este arquivo é bastante comentado e contém algumas informações sobre o módulo HC-SR04, bem como informações de montagem.
  2. BareBonesLight.ino - um módulo com um pequeno número de comentários

Aqui está meu conselho. Eu sei que o código funciona, mas antes de anexar os arquivos às instruções, verifiquei tudo e o monitor serial mostrou consistentemente “0 cm”. O problema acabou sendo um módulo queimado e substituí-lo corrigiu a situação.

Veja como o programa responde se você decidir brincar com os valores dos comandos de atraso. Através da experiência, descobri que diminuir os valores de atraso ou defini-los como 0 pode levar o programa a um estado inoperante.

Depois de configurar o seu dispositivo, o único limite é a sua imaginação. Você pode verificar se os objetos estacionários estão à mesma distância e permanecem estacionários. Você pode usar o monitor para receber notificações quando um objeto passar pelo sensor, etc.

Usei o diagrama acima para determinar se todos os objetos estão a mais de 60 cm do sensor. Três diodos e um tweeter foram usados ​​no projeto. Quando todos os objetos estavam a mais de 60 cm, o LED verde estava aceso. Quando algo se aproximava de menos de 60 cm, o diodo verde apagava e a luz vermelha acendia. Se o objeto permanecesse próximo por algum tempo, o segundo diodo vermelho acenderia e o bipe começaria a apitar. Quando o objeto se afastou 60 cm, o sinal sonoro silenciou, os diodos vermelhos apagaram e a luz verde acendeu novamente. Isso não evitou todos os alarmes falsos, mas funcionou na maioria dos casos em que um pássaro passou voando pelo sensor ou um esquilo curioso passou correndo.

Etapa 4: problemas conhecidos

Se você vir o modelo do seu módulo ultrassônico neste parágrafo, role abaixo. Espero que você encontre seu problema e o resolva.

  1. EUA-105
  2. DYP-ME007TX

Módulo US-105

O módulo ultrassônico US-105 usa um pino GPIO no pino ECHO, o que significa diferentes cálculos para determinar a distância. Ao fixar o GPIO ao pino ECHO, o pino não é mantido energizado durante o envio de uma onda. Em vez disso, quando o ultrassom refletido é recebido, uma voltagem específica é aplicada ao pino ECHO que é proporcional ao tempo que a onda de ultrassom leva para viajar e retornar ao sensor. O código a seguir funcionará com este módulo:

// Código do módulo ultrassônico US-105 unsigned int EchoPin = 2; unsigned int TrigPin = 3; longo não assinado Time_Echo_us = 0; //Len_mm_X100 = comprimento*100 sem sinal longo Len_mm_X100 = 0; sem sinal longo Len_Integer = 0; // int não assinado Len_Fraction = 0; void setup() ( Serial.begin(9600); pinMode(EchoPin, INPUT); pinMode(TrigPin, OUTPUT); ) void loop() ( digitalWrite(TrigPin, HIGH); delayMicroseconds(50); digitalWrite(TrigPin, LOW) ;Time_Echo_us = pulseIn(EchoPin, HIGH); Serial.print(Len_Integer,DEC);< 10) Serial.print("0"); Serial.print(Len_Fraction, DEC); Serial.println("mm"); delay(1000); } // Конец программы

Módulo DYP-ME007TX

// Código para módulo ultrassônico DYP-ME007TX /* Instruções de conexão * 5V do Arduino para VCC no módulo * GNG do Arduino para GND no módulo * OUT do módulo para o pino digital 7 no Arduino */ #include #define RXpin 7 #define TXpin 7 SoftwareSerial mySerial(RXpin, TXpin); mili longo = 0; byte meubuffer = (0); byte bitpos = 0; void setup() ( Serial.begin(9600); mySerial.begin(9600); ) void loop() ( bitpos = 0; while (mySerial.available()) ( if (bitpos< 4) { mybuffer = mySerial.read(); } else break; } mySerial.flush(); mili = mybuffer << 8 | mybuffer; Serial.print("Distance: "); Serial.print(mili / 25.4); Serial.print (" inches"); Serial.println(); delay(500); }

Os sensores de distância ultrassônicos Arduino são muito populares em projetos de robótica devido à sua relativa simplicidade, precisão suficiente e disponibilidade. Podem ser utilizados como dispositivos que auxiliam a evitar obstáculos, obter as dimensões dos objetos, simular um mapa da sala e sinalizar a aproximação ou retirada de objetos. Uma das opções comuns para tal dispositivo é um sensor de distância, cujo design inclui um telêmetro ultrassônico HC SR04. Neste artigo conheceremos o princípio de funcionamento de um sensor de distância, consideraremos diversas opções de conexão a placas Arduino, um diagrama de interação e exemplos de esboços.

A capacidade de um sensor ultrassônico de determinar a distância até um objeto é baseada no princípio do sonar - ao enviar um feixe de ultrassom e receber seu reflexo com atraso, o dispositivo determina a presença de objetos e a distância até eles. Os sinais ultrassônicos gerados pelo receptor, refletidos no obstáculo, retornam a ele após um determinado período de tempo. É esse intervalo de tempo que se torna uma característica que ajuda a determinar a distância até o objeto.

Atenção! Como o princípio de operação é baseado em ultrassom, tal sensor não é adequado para determinar a distância até objetos que absorvem som. Objetos com superfície plana e lisa são ideais para medição.

Descrição do sensor HC SR04

O sensor de distância Arduino é um dispositivo do tipo sem contato e fornece medição e estabilidade altamente precisas. Sua faixa de medição varia de 2 a 400 cm. Seu funcionamento não é significativamente afetado pela radiação eletromagnética e pela energia solar. O kit de módulo com arduino HC SR04 também inclui um receptor e um transmissor.

O telêmetro ultrassônico HC SR04 possui os seguintes parâmetros técnicos:

  • Tensão de alimentação 5V;
  • O parâmetro da corrente operacional é 15 mA;
  • Força atual em estado passivo< 2 мА;
  • Ângulo de visão – 15°;
  • Resolução de toque – 0,3 cm;
  • Ângulo de medição – 30°;
  • Largura de pulso – 10 -6 s.

O sensor está equipado com quatro terminais (padrão 2,54 mm):

  • Contato de potência tipo positivo – +5V;
  • Trig (T) – saída do sinal de entrada;
  • Eco (R) – saída do sinal de saída;
  • GND – Pino “Terra”.

Onde comprar módulo SR04 para Arduino

O sensor de distância é um componente bastante comum e pode ser facilmente encontrado em lojas online. As opções mais baratas (de 40 a 60 rublos por peça), tradicionalmente em um site conhecido.

Módulo sensor de distância HC-SR04 para Arduino Outra opção para o sensor ultrassônico HC-SR04 de um fornecedor confiável
Sensores de proximidade SR05 Ultrassônicos HC-SR05 (desempenho aprimorado) Módulo HC-SR05 HY-SRF05 para UNO R3 MEGA2560 DUE de um fornecedor confiável

Esquema de interação com Arduino

Para obter dados, você deve realizar a seguinte sequência de ações:

  • Aplique um pulso de 10 microssegundos à saída Trig;
  • No telêmetro ultrassônico hc sr04 conectado ao arduino, o sinal será convertido em 8 pulsos com frequência de 40 kHz, que serão enviados adiante através do emissor;
  • Quando os pulsos atingirem o obstáculo, serão refletidos dele e serão recebidos pelo receptor R, que fornecerá um sinal de entrada na saída Echo;
  • No lado do controlador, o sinal recebido deve ser convertido em distância por meio de fórmulas.

Ao dividir a largura do pulso por 58,2, obtemos os dados em centímetros, ao dividir por 148, obtemos os dados em polegadas.

Conectando HC SR04 ao Arduino

Conectar um sensor de distância ultrassônico a uma placa Arduino é bastante simples. O diagrama de conexão é mostrado na figura.

Conectamos o pino terra ao pino GND na placa Arduino e conectamos a saída de energia a 5V. Conectamos as saídas Trig e Echo ao Arduino por meio de pinos digitais. Opção de conexão usando uma placa de ensaio:

Biblioteca para trabalhar com HC SR04

Para facilitar o trabalho com o sensor de distância HC SR04 no Arduino, você pode usar a biblioteca NewPing. Não apresenta problemas de ping e adiciona alguns novos recursos.

Os recursos da biblioteca incluem:

  • Capacidade de trabalhar com diversos sensores ultrassônicos;
  • Pode trabalhar com sensor de distância através de apenas um pino;
  • Não há atraso de 1 segundo quando não há ping de eco;
  • Existe um filtro digital integrado para correção simples de erros;
  • O cálculo de distância mais preciso.

Você pode baixar a biblioteca NewPing

Precisão de medição de distância com sensor HC SR04

A precisão do sensor depende de vários fatores:

  • temperatura e umidade do ar;
  • distância ao objeto;
  • localização relativa ao sensor (conforme diagrama de radiação);
  • qualidade de desempenho dos elementos do módulo sensor.

O princípio de funcionamento de qualquer sensor ultrassônico é baseado no fenômeno de reflexão das ondas acústicas que se propagam no ar. Mas, como você sabe no curso de física, a velocidade de propagação do som no ar depende das propriedades do próprio ar (principalmente da temperatura). O sensor, emitindo ondas e medindo o tempo até que elas retornem, não tem ideia em que meio elas irão se propagar e leva um determinado valor médio para os cálculos. Em condições reais, devido ao fator temperatura do ar, o HC-SR04 pode ter erros de 1 a 3-5 cm.

O fator distância até o objeto é importante porque... a probabilidade de reflexão de objetos vizinhos aumenta e o próprio sinal atenua com a distância.

Além disso, para aumentar a precisão, você precisa direcionar corretamente o sensor: certifique-se de que o objeto esteja dentro do cone do padrão de radiação. Simplificando, os “olhos” do HC-SR04 devem olhar diretamente para o assunto.

Para reduzir erros e incertezas de medição, geralmente são realizadas as seguintes ações:

  • os valores são calculados em média (medimos várias vezes, removemos os picos e depois encontramos a média);
  • usando sensores (por exemplo, ) a temperatura é determinada e fatores de correção são aplicados;
  • o sensor é montado em um servomotor, com o qual “giramos a cabeça”, movendo o padrão de radiação para a esquerda ou para a direita.

Exemplos de uso de um sensor de distância

Vejamos um exemplo de projeto simples com uma placa Arduino Uno e um sensor de distância HC SR04. No esboço receberemos o valor da distância aos objetos e os enviaremos para o monitor de porta no IDE do Arduino. Você pode alterar facilmente o esboço e o diagrama de conexão para que o sensor sinalize quando um objeto está se aproximando ou se afastando.

Conectando o sensor ao Arduino

Ao escrever o esboço, foi usada a seguinte opção de pinagem para conectar o sensor:

  • VCC: +5V
  • Trig – 12 pinos
  • Eco – 11 pinos
  • Terra (GND) – Terra (GND)

Exemplo de esboço

Vamos começar a trabalhar com o sensor imediatamente com uma versão relativamente complexa - sem usar bibliotecas externas.

Neste esboço, realizamos a seguinte sequência de ações:

  • Com um pulso curto (2-5 microssegundos), mudamos o sensor de distância para o modo de ecolocalização, no qual ondas ultrassônicas com frequência de 40 KHz são enviadas para o espaço circundante.
  • Esperamos que o sensor analise os sinais refletidos e determine a distância com base no atraso.
  • Obtemos o valor da distância. Para isso, espere até que o HC SR04 produza um pulso proporcional à distância na entrada ECHO. Determinamos a duração do pulso usando a função pulseIn, que nos retornará o tempo decorrido antes que o nível do sinal mude (no nosso caso, antes que a borda descendente do pulso apareça).
  • Recebido o tempo, convertemos em distância em centímetros dividindo o valor por uma constante (para o sensor SR04 é 29,1 para o sinal “lá”, o mesmo para o sinal “voltar”, o que dará um total de 58,2 ).

Se o sensor de distância não ler o sinal, a conversão do sinal de saída nunca assumirá o valor de um pulso curto - LOW. Como o tempo de atraso de alguns sensores varia dependendo do fabricante, é recomendável definir seu valor manualmente ao usar os esboços acima (fazemos isso no início do ciclo).

Se a distância for superior a 3 metros, na qual o HC SR04 começa a funcionar mal, é melhor definir o tempo de atraso para mais de 20 ms, ou seja, 25 ou 30ms.

#define PIN_TRIG 12 #define PIN_ECHO 11 longa duração, cm; void setup() ( // Inicializa a comunicação pela porta serial Serial.begin (9600); // Define as entradas e saídas pinMode(PIN_TRIG, OUTPUT); pinMode(PIN_ECHO, INPUT); ) void loop() ( // Primeiro gera um pulso curto com duração de 2 a 5 microssegundos digitalWrite(PIN_TRIG, LOW); delayMicroseconds(5); digitalWrite(PIN_TRIG, HIGH); // Ajustando o nível do sinal para alto, aguarde cerca de 10 microssegundos. com frequência de 40 KHz. delayMicroseconds(10); digitalWrite(PIN_TRIG, LOW); // Tempo de atraso do sinal acústico no echolocator. distância cm = (duração / 2) / 29.1; print("Distância ao objeto: "); Serial.print(cm);

Esboce usando a biblioteca NewPing

Agora vamos ver um esboço usando a biblioteca NewPing. O código será significativamente simplificado, porque todas as ações descritas anteriormente estão ocultas dentro da biblioteca. Basta criar um objeto da classe NewPing, especificando os pinos com os quais conectamos o sensor de distância e utilizar os métodos do objeto. No nosso exemplo, para obter a distância em centímetros, precisamos usar ping_cm().

#incluir #define PIN_TRIG 12 #define PIN_ECHO 11 #define MAX_DISTANCE 200 // Constante para determinar a distância máxima que consideraremos correta. // Criamos um objeto cujos métodos usaremos para obter a distância. // Como parâmetros passamos os números dos pinos aos quais estão conectadas as saídas ECHO e TRIG do sensor NewPing sonar(PIN_TRIG, PIN_ECHO, MAX_DISTANCE); void setup() ( // Inicializa a comunicação através da porta serial a uma velocidade de 9600 Serial.begin(9600); ) void loop() ( // Atraso de início necessário para operação correta. delay(50); // Obtém o valor do sensor de distância e salve-o em uma variável unsigned int distance = sonar.ping_cm() // Imprime a distância no monitor da porta Serial.print(distance) Serial.println("cm");

Um exemplo de conexão de um telêmetro ultrassônico HC SR04 com um pino

A conexão do HC-SR04 ao Arduino pode ser feita usando um único pino. Esta opção é útil se você estiver trabalhando em um projeto grande e não tiver pinos livres suficientes. Para conectar, basta instalar um resistor de 2,2K entre os pinos TRIG e ECHO e conectar o pino TRIG ao Arduino.

#incluir #define PIN_PING 12 // O pino do Arduino está conectado aos pinos trigger e echo do sensor de distância #define MAX_DISTANCE 200 // A distância máxima que podemos controlar (400-500cm). Sonar NewPing (PIN_PING, PIN_PING, MAX_DISTANCE); // Ajusta pinos e distância máxima void setup() ( Serial.begin(9600); // Abre um protocolo com dados e frequência de transmissão de 115200 bps. ) void loop() ( delay(50); // Atraso de 50 ms entre ondas geradas 29 ms – valor mínimo permitido unsigned int distanceSm = sonar.ping(); // Cria um sinal, obtém seu parâmetro de duração em µs (uS). e exibir o resultado (0 corresponde a exceder o limite permitido) Serial.println("cm");

Breves conclusões

Sensores de distância ultrassônicos são versáteis e precisos o suficiente para serem usados ​​na maioria dos projetos amadores. O artigo discute o sensor HC SR04 extremamente popular, que se conecta facilmente à placa Arduino (para isso você deve fornecer imediatamente dois pinos livres, mas existe uma opção de conexão com um pino). Existem várias bibliotecas gratuitas para trabalhar com o sensor (apenas uma delas, NewPing, é discutida no artigo), mas você pode prescindir delas - o algoritmo para interagir com o controlador interno do sensor é bastante simples, mostramos neste artigo.

Com base na minha própria experiência, o sensor HC-SR04 tem precisão de um centímetro em distâncias de 10 cm a 2 m. Em distâncias mais curtas e mais longas, pode ocorrer forte interferência, que depende muito dos objetos ao redor e do método de uso. Mas na maior parte, o HC-SR04 fez um ótimo trabalho.