Faça um robô guiado por Lidar com o GiggleBot: 8 etapas

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:37

Neste tutorial, estamos fazendo o GiggleBot enfrentar as dificuldades de um labirinto.

Estamos montando um servo no GiggleBot no qual anexamos um sensor de distância. Durante a execução, o servo irá girar para frente e para trás para que o sensor de distância possa medir a distância até cada obstáculo. Isso funciona como um sensor LIDAR, que geralmente é muito mais caro.

Ao mesmo tempo, o GiggleBot está enviando esses dados para um micro: bit remoto da BBC que exibe em sua matriz 5 por 5 de LEDs sua posição relativa aos obstáculos.

Seu trabalho é ser capaz de navegar no GiggleBot apenas olhando o que é mostrado no outro micro: bit da BBC. Para controlar o GiggleBot, são usados os botões do micro: bit BBC remoto.

Isso parece divertido! Vamos começar, vamos?

Etapa 1: Componentes necessários

Vamos precisar de:

1. Um GiggleBot.
2. Uma bateria para BBC micro: bit. Ele vem com um micro: bit BBC em sua embalagem.
3. x3 pilhas AA para o GiggleBot.
4. Um cabo Grove para conectar o sensor de distância ao GiggleBot.
5. Um kit Servo da DexterIndustries.
6. x3 BBC micro: bits. Um para o GiggleBot e outro usado para controlar o robô de longe.
7. Um sensor de distância da DexterIndustries.

Obtenha o robô GiggleBot para o micro BBC: um pouco aqui!

Etapa 2: montagem do robô

Para deixar o GiggleBot pronto para ser programado, precisamos montá-lo, embora não haja muito o que fazer.

Insira as 3 baterias AA em seu compartimento embaixo do GiggleBot.

Monte o pacote servo. Em seu braço rotativo do servo, use o último orifício para fixar o servo nos conectores frontais do GiggleBot. Você pode usar um parafuso e / ou algum fio para torná-lo mais estável em seu lugar. Ou você pode colá-lo com cola quente no quadro. No meu caso, usei um parafuso e um fio curto para amarrar o braço do servo à placa GiggleBot.

Ao montar o braço do servo no servo, certifique-se de que o servo já esteja definido para a posição 80. Você pode fazer isso chamando gigglebot.set_servo (gigglebot. RIGHT, 80). Você pode ler mais sobre isso aqui.

Em seguida, coloque o sensor de distância na parte frontal do pacote do servo e fixe-o como no exemplo acima.

Finalmente, conecte o sensor de distância com um cabo Grove a qualquer uma das 2 portas I2C e o servo motor à porta direita do GiggleBot - a porta certa é mencionada nele.

Etapa 3: Crie seu próprio labirinto - opcional

Neste caso, usei um monte de caixas para criar uma trilha de loop fechado, semelhante a uma NASCAR.

Nesta etapa, você pode ser realmente criativo e torná-lo o quão distorcido você quiser ou torná-lo superlongo porque realmente depende de você.

Ou se você não quiser uma pista, você pode colocar o GiggleBot em uma cozinha ou sala de estar, por exemplo - isso deve ser bom o suficiente porque existem muitas paredes e obstáculos que você ainda precisa evitar.

Etapa 4: Configurando o ambiente

Para que você seja capaz de programar o BBC micro: bit em MicroPython, você deve configurar um editor para ele (o Editor Mu) e definir o GiggleBot MicroPython Runtime como seu tempo de execução. Para isso, você deve seguir as instruções desta página. A partir deste momento, a versão v0.4.0 do runtime é usada.

Etapa 5: Programando o GiggleBot - Parte I

Primeiro, vamos configurar o script do GiggleBot. Este script fará com que o GiggleBot gire seu servo motor 160 graus (80 graus em cada direção) enquanto, ao mesmo tempo, faz 10 leituras do sensor de distância por volta.

Quando ligado, o GiggleBot ficará em espera até receber um comando do controle remoto. Só pode haver 3 comandos: avançar, para a esquerda ou para a direita.

Observação: o script a seguir pode ter espaços em branco ausentes e isso parece ser devido a algum problema na exibição de Gist Gists do GitHub. Clique na essência para ir para a página do GitHub, onde você pode copiar e colar o código.

GiggleBot baseado em LIDAR com controle remoto

da importação do gigglebot *

from distance_sensor importar DistanceSensor

do sono de importação de microbit

de utime import ticks_us, sleep_us

import ustruct

rádio de importação

# pare o robô se ele já estiver se movendo

Pare()

# ativar rádio

radio.on ()

# objeto sensor de distância

ds = DistanceSensor ()

ds.start_continuous ()

rotate_time = 0.7 # medido em segundos

rotate_span = 160 # medido em graus

rotate_steps = 10

overhead_compensation = 1.05 # definido em porcentagens

time_per_step = 10 ** 6 * rotate_time / (rotate_steps * overhead_compensation)

last_read_time = 0

radar = bytearray (rotate_steps)

servo_rotate_direction = 0 # 0 para ir para cima (0-> 160) e 1 caso contrário

radar_index = 0

set_servo (DIREITO, 0)

whileTrue:

# lido do radar

if ticks_us () - last_read_time> time_per_step:

# lido do sensor de distância

radar [radar_index] = int (ds.read_range_continuous () / 10)

last_read_time = ticks_us ()

imprimir (radar_index)

# faça a lógica para girar o servo da esquerda para a direita

if radar_index == rotate_steps -1and servo_rotate_direction == 0:

set_servo (DIREITO, 0)

servo_rotate_direction = 1

elif radar_index == 0and servo_rotate_direction == 1:

set_servo (RIGHT, rotate_span)

servo_rotate_direction = 0

outro:

radar_index + = 1if servo_rotate_direction == 0else-1

# e enviar os valores do radar

radio.send_bytes (radar)

Experimente:

# ler comandos do robô

lmotor, rmotor = ustruct.unpack ('bb', radio.receive_bytes ())

# e acionar os motores caso haja algum comando recebido

set_speed (lmotor, rmotor)

dirigir()

exceptTypeError:

passar

visualizar rawgigglebot_lidar_robot.py hospedado com ❤ por GitHub

Etapa 6: Programando o Remoto - Parte II

O que falta fazer é programar o segundo micro: bit BBC que atua como um controle remoto.

O controle remoto é usado para exibir em sua tela feita de 5 por 5 pixels a distância relativa aos obstáculos. No máximo, haverá 10 pixels ativados.

Ao mesmo tempo, o controle remoto oferece a capacidade de controlar remotamente o GiggleBot pressionando seus 2 botões: mover para frente, para a esquerda e para a direita.

Observação: o script a seguir pode ter espaços em branco ausentes e isso parece ser devido a algum problema na exibição de Gist Gists do GitHub. Clique na essência para ir para a página do GitHub, onde você pode copiar e colar o código.

GiggleBot baseado em LIDAR controlado remotamente - Código Remoto

de microbit importação sleep, display, button_a, button_b

import ustruct

rádio de importação

importar matemática

radio.on ()

rotate_steps = 10

rotate_span = 160 # em graus

rotate_step = rotate_span / rotate_steps

max_distance = 50 # em centímetros

side_length_leds = 3 # medido no número de pixels

radar = bytearray (rotate_steps)

xar = bytearray (rotate_steps)

yar = bytearray (rotate_steps)

save_xar = bytearray (rotate_steps)

save_yar = bytearray (rotate_steps)

velocidade_motor = 50

whileTrue:

status = radio.receive_bytes_into (radar)

se o status não for nenhum:

# display.clear ()

para c, val inenumerate (radar):

se radar [c] <= distância_máx:

# calcula coordenadas 2D de cada distância

ângulo = rotate_steps / (rotate_steps -1) * rotate_step * c

ângulo + = (180- rotate_span) /2.0

x_c = math.cos (ângulo * math.pi /180.0) * radar [c]

y_c = math.sin (ângulo * math.pi /180.0) * radar [c]

# dimensionar as distâncias para caber no display de micro-ondas 5x5

x_c = x_c * (side_length_leds -1) / max_distance

y_c = y_c * (side_length_leds +1) / max_distance

# reposicionar coordenadas

x_c + = (side_length_leds -1)

y_c = (side_length_leds +1) - y_c

# coordena exatamente onde os LEDs são encontrados

se x_c - math.floor (x_c) <0,5:

x_c = math.floor (x_c)

outro:

x_c = math.ceil (x_c)

se y_c - math.floor (y_c) <0,5:

y_c = math.floor (y_c)

outro:

y_c = math.ceil (y_c)

xar [c] = x_c

yar [c] = y_c

outro:

xar [c] = 0

yar [c] = 0

display.clear ()

para x, y inzip (xar, yar):

display.set_pixel (x, y, 9)

# imprimir (lista (zip (xar, yar, radar)))

stateA = button_a.is_pressed ()

stateB = button_b.is_pressed ()

se estadoA e estadoB:

radio.send_bytes (ustruct.pack ('bb', motor_speed, motor_speed))

imprimir ('encaminhar')

se estado A e não estado B:

radio.send_bytes (ustruct.pack ('bb', motor_speed, -motor_speed))

imprimir ('esquerda')

ifnot stateA e stateB:

radio.send_bytes (ustruct.pack ('bb', -motor_speed, motor_speed))

imprimir ('direita')

ifnot stateA andnot stateB:

radio.send_bytes (ustruct.pack ('bb', 0, 0))

imprimir ('parar')

veja rawgigglebot_lidar_remote.py hospedado com ❤ por GitHub

Etapa 7: interpretando a tela remota

"loading =" preguiçoso "controle o GiggleBot, você tem as seguintes opções:

1. Pressione o botão A e o botão B para mover o GiggleBot para frente.
2. Pressione o botão A para girar o GiggleBot para a esquerda.
3. Pressione o botão B para girar o GiggleBot para a direita.

Para ver em que direção os obstáculos mais próximos são detectados, basta olhar na tela do controle remoto (o micro BBC remoto: bit que você está segurando). Você deve ser capaz de controlar o GiggleBot de longe sem olhar para ele.