Micropython HC -SRTOP 10 Sensor ultrassônico - Esptop 10 e Thonny IDE

Micropython é amplamente utilizado com microcontroladores e sistemas incorporados. Podemos escrever código e bibliotecas dentro do Micropython IDE e interface vários sensores. Este artigo o guiará sobre a distância de medição usando o ESP32 com o sensor HC-SR04.

Esp32 com sensor ultrassônico HC-SR04 usando micropython

Interface Esp32 com ultrassônico apenas exige que dois fios sejam conectados. Usando sensores ultrassônicos, podemos medir a distância do objeto e pode desencadear respostas com base nesse sistema, como a colisão de veículos, evitando sistemas.

Usando Micropython, que é uma linguagem projetada para ESP32 e outros microcontroladores, podemos interface vários sensores como o HC-SR04. Código Micropython será escrito que calcula o tempo gasto pela onda de sonar para alcançar de sensor para objeto e voltar ao objeto. Posteriormente usando a fórmula de distância, podemos calcular a distância do objeto.

Aqui estão alguns destaques principais do sensor HC-SR04:

Características	Valor
Tensão operacional	5V DC
Corrente operacional	15m
Frequência de operação	40kHz
Alcance min	2cm/ 1 polegada
Faixa máxima	400cm/ 13 pés
Precisão	3mm
Ângulo de medição	<15 degree

HC-SR04 PILOUTO HC-SR04 contém a seguir quatro pinos:

• VCC: Conecte -se ao PIN ESP32 VIN
• GND: Conecte -se ao GND
• Trig: PIN para receber sinal de controle da placa ESP32
• Eco: Enviar sinal de volta. A placa de microcontrolador recebe esse sinal para calcular a distância usando o tempo

Como as obras ultrassônicas

Depois que o sensor HC-SR04 está conectado com Esp32, um sinal no Trig O PIN será gerado pela placa. Uma vez que o sinal for recebido no pino TRIG do sensor HC-SR04, será gerada uma onda ultrassônica que deixa o sensor e atinge o objeto ou o corpo de obstáculos. Depois de acertá -lo, voltará à superfície do objeto.

Uma vez que a onda refletida chegar de volta ao sensor que recebe 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 Formula a distância.

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 para o objeto e de volta ao final do sensor. Então a distância real é o sinal que é igual a metade dessa distância.

Esquemático

A seguir, o esquema para interface o ESP32 com 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 Pin GND e Vin com pinos de sensor.

Sensor ultrassônico HC-SR04	PIN ESP32
Trig	GPIO 5
Eco	GPIO 18
Gnd	Gnd
VCC	Vin

Hardware

Os seguintes componentes são obrigados a programar o sensor ultrassônico:

• Esp32
• HC-SR04
• Pão de pão
• Fios de jumper

Como configurar o Ultrassonic 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 ao longo das etapas para concluir a configuração do ESP32 com sensor ultrassônico em Thonny IDE usando Micropython.

Passo 1: Agora abre 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 código a seguir na janela THONNY IDE Editor.

Máquina de importação, tempo
do pino de importação da máquina
Classe HCSR04:
# echo_timeout_us é baseado no limite de faixa de chip (400cm)
def __init __ (self, trigger_pin, echo_pin, echo_timeout_us = 500*2*30):
auto.echo_timeout_us = echo_timeout_us
# Init gatilho pino (out)
auto.trigger = pin (trigger_pin, modo = pin.Fora, puxe = nenhum)
auto.acionar.valor (0)
# Init eco pino (in)
auto.echo = pin (echo_pin, modo = pino.Em, puxe = nenhum)
def _send_pulse_and_wait (self):
auto.acionar.valor (0) # estabilize o sensor
tempo.Sleep_us (5)
auto.acionar.valor (1)
# Envie um pulso de 10us.
tempo.Sleep_us (10)
auto.acionar.valor (0)
tentar:
pulse_time = máquina.time_pulse_us (self.eco, 1, eu.echo_timeout_us)
retornar pulse_time
Exceto OSerror como Ex:
se ex.args [0] == 110: # 110 = Etimedout
Raise OSERROR ('fora do alcance')
levantar ex
DEF DOUSTE_MM (self):
pulse_time = self._send_pulse_and_wait ()
mm = pulse_time * 100 // 582
retornar mm
DEF DOUSTE_CM (self):
pulse_time = self._send_pulse_and_wait ()
cms = (pulse_time / 2) / 29.1
Retornar CMS

Passo 2: Depois de escrever o biblioteca Código dentro da janela do editor agora temos para salvá -lo dentro do dispositivo Micropython.

Etapa 3: Vá para: Arquivo> Salvar ou pressione Ctrl + s.

Passo 4: Uma nova janela aparecerá. Verifique se o ESP32 está conectado com o PC. Selecione Micropython Dispositivo para salvar o arquivo da biblioteca.

Etapa 5: Salve o arquivo de biblioteca ultrassônica com nome HCSR04.py e clique OK.

Agora, a biblioteca de sensores ultrassônicos HCSR04 é 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 fornecido abaixo e salve -o dentro do principal.py ou bota.py arquivo. Este código imprimirá a distância de qualquer objeto que venha na frente do HC-SR04.

O código iniciado chamando bibliotecas importantes, como HCSR04 e tempo biblioteca junto com dormir para dar atrasos.

Em seguida, criamos um novo objeto com um nome sensor. Este objeto está levando três argumentos diferentes: gatilho, eco e tempo limite. Aqui o tempo limite é definido como o tempo máximo após o sensor sair do alcance.

Sensor = hcsr04 (trigger_pin = 5, echo_pin = 18, echo_timeout_us = 10000)

Para medir e economizar distância, um novo objeto nomeado distância é criado. Este objeto economizará distância em cm.

distância = sensor.a distância_cm ()

Escreva o código a seguir para obter dados em mm.

distância = sensor.a distância_mm ()

Em seguida, imprimimos o resultado no Micropython IDE Shell.

Imprimir ('Distância:', Distância, 'CM')

No final, um atraso de 1 s é dado.

sono (1)

O código completo é dado abaixo:

De HCSR04 Importar HCSR04
Desde o tempo de importação do sono
# ESP32
Sensor = hcsr04 (trigger_pin = 5, echo_pin = 18, echo_timeout_us = 10000)
# ESP8266
#sensor = hcsr04 (trigger_pin = 12, echo_pin = 14, echo_timeout_us = 10000)
enquanto é verdade:
distância = sensor.a distância_cm ()
Imprimir ('Distância:', Distância, 'CM')
sono (1)

Depois de escrever e salvar código dentro do dispositivo Micropython, agora corro o sensor ultrassônico principal.py Código do arquivo. Clique no botão Play ou pressione F5.

Saída de 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 do shell. Agora o objeto é colocado a 5 cm do sensor ultrassônico.

Saída de sensor ultrassônico quando o objeto está longe

Agora, para verificar nosso resultado, colocaremos objetos longe do sensor e verificaremos o funcionamento do sensor ultrassônico. Coloque objetos como mostrados 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 é aprox. 15 cm do sensor ultrassônico.

Conclusão

A distância de medição tem uma ótima 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 abordará todas as etapas necessárias para se integrar e começar a medir a distância com ESP32.