MicroPython é amplamente utilizado com microcontroladores e sistemas embarcados. Podemos escrever código e bibliotecas dentro do MicroPython IDE e interagir com vários sensores. Este artigo irá guiá-lo na medição de distância usando o ESP32 com sensor HC-SR04.
ESP32 com sensor ultrassônico HC-SR04 usando MicroPython
A interface do ESP32 com ultrassônico requer apenas a conexão de dois fios. Usando sensores ultrassônicos, podemos medir a distância do objeto e desencadear respostas com base neste sistema, como sistemas de prevenção de colisão de veículos.
Usando o MicroPython, que é uma linguagem projetada para ESP32 e outros microcontroladores, podemos interagir com vários sensores como o HC-SR04 . O código MicroPython será escrito, calculando o tempo que a onda do SONAR leva para chegar do sensor ao objeto e voltar ao objeto. Mais tarde, usando a fórmula da distância, podemos calcular a distância do objeto.
Aqui estão alguns dos principais destaques do sensor HC-SR04:
| Características | Valor |
| Tensão operacional | 5V DC |
| Corrente Operacional | 15mA |
| Frequência de operação | 40KHz |
| minha faixa | 2 cm/ 1 polegada |
| Alcance Máximo | 400 cm/13 pés |
| Precisão | 3 mm |
| ângulo de medição | <15 graus |
Pinagem HC-SR04 HC-SR04 contém o seguinte quatro pinos:
- Vc: Conecte ao pino ESP32 Vin
- Terra: Conectar ao GND
- Trig: Pino para receber o sinal de controle da placa ESP32
- Eco: Enviar sinal de volta. A placa do microcontrolador recebe este sinal para calcular a distância usando o tempo
Como funciona o ultrassom
Após o sensor HC-SR04 ser conectado ao ESP32, um sinal no Trig pin será gerado pela placa. Assim que o sinal for recebido no pino de disparo do sensor HC-SR04, será gerada uma onda ultrassônica que sai do sensor e atinge o objeto ou o corpo do obstáculo. Depois de bater, ele voltará para a superfície do objeto.
Assim que a onda refletida chegar de volta ao sensor, um pulso de sinal no pino de eco será gerado. O ESP32 recebe o sinal do pino de eco e calcula a distância entre o objeto e o sensor usando Distância-Fórmula.
A distância total calculada deve ser dividida por dois dentro do código ESP32, pois a distância que obtemos originalmente é igual à distância total do sensor ao objeto e de volta à extremidade receptora do sensor. Então a distância real é o sinal que é igual a metade dessa distância.
Esquema
A seguir está o esquema para interface do ESP32 com o sensor ultrassônico:
Conecte o gatilho e o pino de eco do sensor com GPIO 5 e GPIO 18 do ESP32 respectivamente. Conecte também o pino ESP32 GND e Vin com os pinos do sensor.
| Sensor Ultrassônico HC-SR04 | Pino ESP32 |
| Trig | GPIO5 |
| Eco | GPIO 18 |
| GND | GND |
| VCC | VENHA |
hardware
Os seguintes componentes são necessários para programar o sensor ultrassônico:
- ESP32
- HC-SR04
- Protoboard
- Fios de jumper
Como configurar o Ultrasonic HC-SR04 com ESP32 usando o MicroPython
Antes de podermos programar o ESP32 com um sensor ultrassônico, precisamos instalar uma biblioteca nele. Conecte a placa ESP32 ao PC. Siga as etapas para concluir a configuração do ESP32 com sensor ultrassônico no Thonny IDE usando o MicroPython.
Passo 1: Agora abra o Thonny IDE. Crie um novo arquivo na janela do editor Vá para : Arquivo>Novo ou pressione Ctrl + N .
Depois que o novo arquivo for aberto, cole o seguinte código na janela do editor Thonny IDE.
importar máquina , Tempoa partir de máquina importar Alfinete
classe HCSR04:
# echo_timeout_us é baseado no limite de alcance do chip (400cm)
def __quente__ ( auto , gatilho_pin , echo_pin , echo_timeout_us = 500 * dois * 30 ) :
auto . echo_timeout_us = echo_timeout_us
# Init trigger pin (out)
auto . acionar = Alfinete ( gatilho_pin , modo = Alfinete. FORA , puxar = Nenhum )
auto . acionar . valor ( 0 )
# Pino de eco de inicialização (entrada)
auto . eco = Alfinete ( echo_pin , modo = Alfinete. DENTRO , puxar = Nenhum )
def _send_pulse_and_wait ( auto ) :
auto . acionar . valor ( 0 ) # Estabilize o sensor
Tempo . sleep_us ( 5 )
auto . acionar . valor ( 1 )
# Envie um pulso de 10 us.
Tempo . sleep_us ( 10 )
auto . acionar . valor ( 0 )
tentar :
pulse_time = máquina. time_pulse_us ( auto . eco , 1 , auto . echo_timeout_us )
Retorna pulse_time
exceto OSError Como ex:
E se ex. argumentos [ 0 ] == 110 : # 110 = ETIMEDOUT
levantar OSError ( 'Fora de alcance' )
levantar ex
def distância_mm ( auto ) :
pulse_time = auto ._send_pulse_and_wait ( )
milímetros = pulso_tempo * 100 // 582
Retorna milímetros
def distância_cm ( auto ) :
pulse_time = auto ._send_pulse_and_wait ( )
cms = ( pulso_tempo / dois ) / 29.1
Retorna cms
Passo 2: Depois de escrever o biblioteca código dentro da janela do editor agora temos que salvá-lo dentro do dispositivo MicroPython.
Etapa 3: Vamos para : Arquivo>Salvar ou pressione Ctrl + S .
Passo 4: Uma nova janela aparecerá. Certifique-se de que o ESP32 esteja conectado ao PC. Selecione o dispositivo MicroPython para salvar o arquivo da biblioteca.
Passo 5: Salve o arquivo da biblioteca ultrassônica com o nome hcsr04.py e clique OK .
Agora a biblioteca de sensores ultrassônicos hcsr04 foi adicionada com sucesso à placa ESP32. Agora podemos chamar funções de biblioteca dentro do código para medir a distância de diferentes objetos.
Código para sensor ultrassônico usando MicroPython
Para o código do sensor ultrassônico, crie um novo arquivo ( Ctrl + N ). Na janela do editor, digite o código abaixo e salve-o dentro do main.py ou boot.py Arquivo. Este código imprimirá a distância de qualquer objeto que vier na frente do HC-SR04.
O código começou chamando bibliotecas importantes, como HCSR04 e Tempo biblioteca junto com dorme dar atrasos.
Em seguida, criamos um novo objeto com um nome sensor . Este objeto recebe três argumentos diferentes: trigger, echo e timeout. Aqui, o tempo limite é definido como o tempo máximo após o sensor sair da faixa.
sensor = HCSR04 ( gatilho_pin = 5 , echo_pin = 18 , echo_timeout_us = 10000 )Para medir e economizar distância, um novo objeto chamado distância é criado. Este objeto economizará distância em cm.
distância = sensor. distância_cm ( )Escreva o código a seguir para obter dados em mm.
distância = sensor. distância_mm ( )Em seguida, imprimimos o resultado no shell do MicroPython IDE.
imprimir ( 'Distância:' , distância , 'cm' )No final, é dado um atraso de 1 segundo.
dorme ( 1 )O código completo é dado abaixo:
a partir de hcsr04 importar HCSR04a partir de Tempo importar dorme
# ESP32
sensor = HCSR04 ( gatilho_pin = 5 , echo_pin = 18 , echo_timeout_us = 10000 )
# ESP8266
#sensor = HCSR04(trigger_pin=12, echo_pin=14, echo_timeout_us=10000)
enquanto Verdadeiro :
distância = sensor. distância_cm ( )
imprimir ( 'Distância:' , distância , 'cm' )
dorme ( 1 )
Depois de escrever e salvar o código dentro do dispositivo MicroPython, agora executo o sensor ultrassônico main.py código do arquivo. Clique no botão play ou pressione F5 .
Saída do sensor ultrassônico quando o objeto está próximo
Agora coloque um objeto próximo ao sensor ultrassônico e verifique a distância medida na janela do monitor serial do Arduino IDE.
A distância do objeto é mostrada no terminal shell. Agora o objeto é colocado a 5 cm do sensor ultrassônico.
Saída do sensor ultrassônico quando o objeto está distante
Agora, para verificar nosso resultado, colocaremos objetos longe do sensor e verificaremos o funcionamento do sensor ultrassônico. Coloque os objetos como mostrado na imagem abaixo:
A janela de saída nos dará uma nova distância e como podemos ver que o objeto está longe do sensor, então a distância medida é de aprox. 15 cm do sensor ultrassônico.
Conclusão
A medição de distância tem uma grande aplicação quando se trata de robótica e outros projetos, existem diferentes maneiras de medir a distância. HC-SR04 com ESP32 pode medir a distância de diferentes objetos. Aqui, este artigo cobrirá todas as etapas necessárias para integrar e começar a medir a distância com o ESP32.