Crea un robot guidato da Lidar con GiggleBot: 8 passaggi

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:02

In questo tutorial, stiamo facendo in modo che GiggleBot affronti le difficoltà di un labirinto.

Stiamo montando un servo sul GiggleBot su cui colleghiamo un sensore di distanza. Durante il funzionamento, il servo ruoterà avanti e indietro in modo che il sensore di distanza possa misurare la distanza fino a ciascun ostacolo. Funziona in modo molto simile a un sensore LIDAR che di solito è molto più costoso.

Allo stesso tempo, GiggleBot sta inviando questi dati a un micro:bit BBC remoto che visualizza sulla sua matrice di LED 5x5 la sua posizione relativa agli ostacoli.

Il tuo compito è essere in grado di navigare nel GiggleBot solo guardando ciò che viene mostrato sull'altro micro:bit della BBC. Per controllare il GiggleBot, vengono utilizzati i pulsanti sul telecomando BBC micro:bit.

Sembra divertente! Andiamo al dunque, vero?

Passaggio 1: componenti richiesti

Avremo bisogno di:

1. Un GiggleBot.
2. Una batteria per il micro:bit della BBC. Viene fornito con un micro: bit BBC nel suo pacchetto.
3. x3 batterie AA per GiggleBot.
4. Un cavo Grove per collegare il sensore di distanza al GiggleBot.
5. Un servo kit di DexterIndustries.
6. x3 BBC micro: bit. Uno per il GiggleBot e uno usato per controllare il robot da lontano.
7. Un sensore di distanza di DexterIndustries.

Ottieni il robot GiggleBot per il micro:bit della BBC qui!

Passaggio 2: assemblaggio del robot

Per rendere il GiggleBot pronto per essere programmato, dobbiamo assemblarlo, anche se non c'è molto da fare.

Inserisci le 3 batterie AA nel suo vano sotto il GiggleBot.

Assemblare il pacchetto servo. Al suo braccio rotante del servo, usa l'ultimo foro per fissare il servo sui connettori frontali del GiggleBot. Puoi usare una vite e/o un filo per renderlo più stabile al suo posto. Oppure puoi incollarlo a caldo sulla lavagna. Nel mio caso, ho usato una vite e un filo corto per legare il braccio del servo alla scheda GiggleBot.

Quando monti il braccio del servo sul servo, assicurati che il servo sia già impostato sulla posizione 80. Puoi farlo chiamando gigglebot.set_servo(gigglebot. RIGHT, 80). Puoi leggere altro a questo proposito qui.

Quindi, posiziona il sensore di distanza sul lato anteriore del pacchetto servo e fissalo come nell'esempio sopra.

Infine, collega il sensore di distanza con un cavo Grove a una qualsiasi delle 2 porte I2C e il servomotore alla porta destra che si trova sul GiggleBot: la porta giusta è menzionata su di essa.

Passaggio 3: crea il tuo labirinto - Opzionale

In questo caso, ho usato un mucchio di scatole per creare una pista a circuito chiuso, simile a una NASCAR.

A questo punto, puoi diventare davvero creativo e renderlo quanto contorto vuoi o renderlo super lungo perché dipende davvero da te.

Oppure, se non vuoi affatto una traccia, puoi mettere il GiggleBot in una cucina o in un soggiorno, ad esempio, che dovrebbe essere abbastanza buono perché ci sono molti muri e ostacoli che devi ancora evitare.

Passaggio 4: configurazione dell'ambiente

Per poter programmare BBC micro:bit in MicroPython, devi impostare un editor per esso (l'editor Mu) e impostare GiggleBot MicroPython Runtime come runtime. Per questo, devi seguire le istruzioni in questa pagina. A partire da questo momento, viene utilizzata la versione v0.4.0 del runtime.

Passaggio 5: Programmazione di GiggleBot - Parte I

Per prima cosa, impostiamo lo script di GiggleBot. Questo script farà ruotare il servomotore GiggleBot di 160 gradi (80 gradi in ciascuna direzione) e allo stesso tempo effettuerà 10 letture dal sensore di distanza per giro.

Una volta acceso, GiggleBot rimarrà in attesa fino a quando non riceverà un comando dal telecomando. Possono esserci solo 3 comandi: avanti, a sinistra oa destra.

Nota: il seguente script potrebbe avere spazi bianchi mancanti e ciò sembra essere dovuto a qualche problema nella visualizzazione di GitHub Gists. Fai clic sull'essenza per portarti alla sua pagina GitHub dove puoi copiare e incollare il codice.

GiggleBot basato su LIDAR telecomandato

da importazione gigglebot*

from distance_sensor import DistanceSensor

da microbit import sleep

da utime import ticks_us, sleep_us

import usstruct

importare radio

# ferma il robot se è già in movimento

fermare()

# abilita la radio

radio.on()

# oggetto sensore di distanza

ds = Sensore di distanza()

ds.start_continuous()

tempo_ruota =0.7# misurato in secondi

ruotare_span =160# misurato in gradi

ruotare_passi = 10

overhead_compensation =1.05# definito in percentuale

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

last_read_time = 0

radar = array di byte (ruota_passi)

servo_rotate_direction =0# 0 per andare verso l'alto (0->160) e 1 altrimenti

indice_radar =0

set_servo(DESTRA, 0)

mentreVero:

# leggi dal radar

if ticks_us() - last_read_time > time_per_step:

# letto dal sensore di distanza

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

last_read_time = ticks_us()

print(indice_radar)

# fai la logica per ruotare il servo da sinistra a destra

if radar_index == ruotare_passi -1 e servo_rotate_direction ==0:

set_servo(DESTRA, 0)

servo_rotate_direction =1

elif radar_index ==0 e servo_rotate_direction ==1:

set_servo (DESTRA, rotazione_span)

servo_rotate_direction =0

altro:

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

# e invia i valori radar

radio.send_bytes(radar)

Tentativo:

# leggi i comandi del robot

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

# e azionare i motori in caso di comandi ricevuti

set_speed(lmotore, rmotore)

unità()

eccezioneTipoErrore:

passaggio

visualizza rawgigglebot_lidar_robot.py ospitato con ❤ da GitHub

Passaggio 6: programmazione del telecomando - Parte II

Ciò che resta da fare è programmare il secondo micro:bit della BBC che funge da telecomando.

Il telecomando viene utilizzato per visualizzare sul suo schermo di 5x5 pixel la distanza relativa agli ostacoli. Al massimo, ci saranno 10 pixel accesi.

Allo stesso tempo, il telecomando ti offre la possibilità di controllare a distanza il GiggleBot premendo i suoi 2 pulsanti: spostati in avanti, a sinistra e a destra.

Nota: il seguente script potrebbe avere spazi bianchi mancanti e ciò sembra essere dovuto a qualche problema nella visualizzazione di GitHub Gists. Fai clic sull'essenza per portarti alla sua pagina GitHub dove puoi copiare e incollare il codice.

GiggleBot basato su LIDAR telecomandato - Codice remoto

da microbit import sleep, display, button_a, button_b

import usstruct

importare radio

importare matematica

radio.on()

ruotare_passi = 10

ruotare_span =160# in gradi

ruotare_passo = ruotare_span / ruotare_passi

distanza_max =50# in centimetri

side_length_leds =3# misurato in # di pixel

radar = array di byte (ruota_passi)

xar = array di byte (ruota_passi)

yar =bytearray(rotate_steps)

save_xar =bytearray(rotate_steps)

yar_salvato =array_byte(ruota_passi)

velocità_motore =50

mentreVero:

stato = radio.receive_bytes_into(radar)

se lo stato non è Nessuno:

# display.clear()

per c, val inenumerate(radar):

se radar[c] <= max_distanza:

# calcola le coordinate 2d di ciascuna distanza

angolo = ruotare_passi / (rotare_passi -1) * ruotare_passi * c

angolo += (180- ruotare_span) /2.0

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

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

# scala le distanze per adattarle al display microbit 5x5

x_c = x_c * (side_length_leds -1) / max_distanza

y_c = y_c * (side_length_leds +1) / max_distanza

# riposiziona le coordinate

x_c += (side_length_leds -1)

y_c = (side_length_leds +1) - y_c

# coordinate rotonde esattamente dove si trovano i LED

se x_c - math.floor(x_c) <0.5:

x_c = math.floor(x_c)

altro:

x_c = math.ceil(x_c)

se y_c - math.floor(y_c) <0.5:

y_c = math.floor(y_c)

altro:

y_c = math.ceil(y_c)

xar[c] = x_c

yar[c] = y_c

altro:

xar[c] =0

anno[c] =0

display.clear()

per x, y inzip(xar, yar):

display.set_pixel(x, y, 9)

# print(list(zip(xar, yar, radar)))

statoA = pulsante_a.è_premuto()

statoB = button_b.is_pressed()

se statoA e statoB:

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

print('avanti')

se statoA e non statoB:

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

print('sinistra')

se non lo stato A e lo stato B:

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

print('giusto')

se non statoA enon statoB:

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

print('stop')

visualizza rawgigglebot_lidar_remote.py ospitato con ❤ da GitHub

Passaggio 7: interpretazione dello schermo remoto

"loading="lazy" controlla il GiggleBot, hai le seguenti opzioni:

1. Premi il pulsante A e il pulsante B per far avanzare GiggleBot.
2. Premi il pulsante A per far girare il GiggleBot a sinistra.
3. Premi il pulsante B per far girare il GiggleBot verso destra.

Per vedere in quale direzione vengono rilevati gli ostacoli più vicini, basta guardare sullo schermo del telecomando (il micro: bit remoto BBC che stai tenendo). Dovresti essere in grado di controllare GiggleBot da molto lontano senza guardarlo.