GiggleBot Line Follower usando Python: 5 passaggi

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

Questa volta, stiamo programmando in MicroPython il GiggleBot di Dexter Industries per seguire una linea nera utilizzando il suo sensore di linea integrato.

Il GiggleBot deve essere accoppiato con un micro:bit BBC per poter essere controllato in modo appropriato.

Se questo tutorial è troppo avanzato per te e la programmazione di GiggleBot è troppo per ora, puoi sempre seguire il tutorial iniziale che mostra come programmare il robot in MakeCode qui. Il tutorial collegato ti guiderà attraverso le basi.

Passaggio 1: componenti richiesti

Sono necessari i seguenti componenti hardware:

1. x3 batterie AA - nel mio caso sto usando batterie ricaricabili che hanno un voltaggio complessivamente inferiore.
2. Un robot GiggleBot di Dexter Industries per il micro:bit.
3. Un micro:bit della BBC.

Naturalmente, è necessario anche un cavo micro USB per programmare il micro: bit della BBC: questo cavo è generalmente incluso nella confezione del micro: bit della BBC oppure è sempre possibile utilizzarne uno utilizzato per caricare gli smartphone (Android).

Ottieni il GiggleBot per il micro:bit qui

Passaggio 2: imposta le tracce

Dovrai passare attraverso la stampa di alcune tessere e la progettazione delle tue tracce. Puoi utilizzare le nostre tessere in modo da essere sicuro al 100% di replicare le nostre condizioni. Oppure, se ti senti avventuroso, puoi usare del nastro adesivo nero e crearne uno tuo. Ecco il PDF per le piastrelle che abbiamo usato.

La traccia sopra è composta dal seguente numero di tessere diverse:

• 12 tessere di tipo #1.
• 5 tessere di tipo #2.
• 3 modelli del tipo di tessera #5.
• 3 modelli del tipo di tessera #6: qui ti ritroverai con una tessera in più.

Quindi, stampali e tagliali. Prova a posizionarli come nella foto sopra e tieni presente che sul lato in alto a destra del binario, 2 tessere devono sovrapporsi l'una all'altra - questo è previsto nel caso ti stia chiedendo se stai facendo qualcosa di sbagliato.

Passaggio 3: 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 4: Programmazione di GiggleBot

Prima di iniziare, il runtime MicroPython di GiggleBot contiene il runtime classico per il micro:bit della BBC e altre librerie per supportare GiggleBot e altri sensori di Dexter Industries.

Dopo averlo configurato, apri il seguente script nell'editor Mu e fai clic su Flash. Questo farà lampeggiare il GiggleBot MicroPython Runtime e lo script che hai appena aperto sul tuo BBC micro:bit. Lo script è mostrato anche in basso.

Una volta completato il processo di flashing, impila il micro:bit BBC nel GiggleBot con i neopixel della scheda rivolti in avanti, posizionalo sulla traccia e accendilo.

Si noti che nello script sono già impostati il PID e altre 2 costanti (il setpoint di velocità e le costanti di velocità minima).

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 PID Line Follower - Ottimizzato con NeoPixel

dall'importazione di microbit*

da importazione gigglebot*

da utime import sleep_ms, ticks_us

import usstruct

# inizializza i neopixel GB

neo = inizia()

# tempi

update_rate =50

# guadagni/costanti (assumendo che la tensione della batteria sia di circa 4.0 volt)

Kp = 25,0

Ki = 0,5

Kd = 35,0

trigger_point =0.3

min_speed_percent =0.3

velocità_base =70

setpoint =0,5

ultima_posizione = setpoint

integrale =0.0

run_neopixels =Vero

center_pixel =5# dove il pixel centrale del sorriso si trova sul GB

# turchese = tuple(map(lambda x: int(x / 5), (64, 224, 208))) # colore da usare per disegnare l'errore con i neopixel

# turchese = (12, 44, 41) # che è esattamente il turchese sopra commentato sopra questo

error_width_per_pixel =0.5/3# errore massimo diviso per il numero di segmenti tra ogni neopixel

defupper_bound_linear_speed_reducer(abs_error, trigger_point, upper_bound, più piccolo_motor_power, più alto_motor_power):

base_speed globale

if abs_error >= trigger_point:

# x0 = 0.0

# y0 = 0.0

# x1 = limite_superiore - trigger_point

# y1 = 1.0

# x = abs_error - trigger_point

# y = y0 + (x - x0) * (y1 - y0) / (x1 - x0)

# uguale a

y = (abs_error - trigger_point) / (upper_bound - trigger_point)

potenza_motore = velocità_base * (potenza_motore_minima + (1- y) * (potenza_motore_massima - potenza_motore_minima))

restituire motor_power

altro:

return base_speed *high_motor_power

corri = falso

errore_precedente = 0

mentreVero:

# se viene premuto il pulsante a, inizia a seguire

if button_a.is_pressed():

corri = Vero

# ma se viene premuto il pulsante b ferma il line follower

if button_b.is_pressed():

corri = falso

integrale =0.0

errore_precedente =0.0

pixels_off()

fermare()

sleep_ms(500)

se run isTrue:

# leggi i sensori di linea

start_time = ticks_us()

destra, sinistra = read_sensor(LINE_SENSOR, BOTH)

# la riga è a sinistra quando la posizione < 0,5

# la linea è a destra quando la posizione > 0,5

# la linea è al centro quando posizione = 0,5

# è una media aritmetica ponderata

Tentativo:

posizione = destra / float (sinistra + destra)

tranneZeroDivisionError:

posizione =0,5

# l'intervallo deve essere (0, 1) e non [0, 1]

se posizione ==0: posizione =0.001

se posizione ==1: posizione =0.999

# usa un controller PD

errore = posizione - setpoint

integrale += errore

correzione = Kp * errore + Ki * integrale + Kd * (errore - errore_precedente)

errore_precedente = errore

# calcola le velocità del motore

motor_speed = upper_bound_linear_speed_reducer(abs(error), setpoint * trigger_point, setpoint, min_speed_percent, 1.0)

leftMotorSpeed = motor_speed + correzione

rightMotorSpeed = motor_speed - correzione

# accendi i neopixel in base all'errore indicato

se run_neopixels isTrueand total_counts %3==0:

per i inb'\x00\x01\x02\x03\x04\x05\x06\x07\x08':

neo = (0, 0, 0)

per i inb'\x00\x01\x02\x03':

ifabs(errore) > error_width_per_pixel * i:

se errore <0:

# neo[center_pixel + i] = turchese

neo[center_pixel + i] = (12, 44, 41)

altro:

# neo[center_pixel - i] = turchese

neo[center_pixel + i] = (12, 44, 41)

altro:

percent =1- (error_width_per_pixel * i -abs(error)) / error_width_per_pixel

# illumina il pixel corrente

se errore <0:

# neo[center_pixel + i] = tuple(map(lambda x: int(x * percentuale), turchese))

neo[center_pixel + i] = (int(64* percento /5), int(224* percento /5), int(208* percento /5))

altro:

# neo[center_pixel - i] = tuple(map(lambda x: int(x * percentuale), turchese))

neo[center_pixel - i] = (int(64* percento /5), int(224* percento /5), int(208* percento /5))

rottura

neo.mostra()

Tentativo:

# taglia le velocità del motore

se sinistraMotorSpeed >100:

leftMotorSpeed =100

rightMotorSpeed = rightMotorSpeed - leftMotorSpeed +100

se destraMotorSpeed >100:

rightMotorSpeed =100

leftMotorSpeed = leftMotorSpeed - rightMotorSpeed +100

se sinistraMotorSpeed <-100:

sinistraMotorSpeed =-100

se rightMotorSpeed <-100:

RightMotorSpeed =-100

# azionare i motori

set_speed(leftMotorSpeed, rightMotorSpeed)

unità()

# print((errore, velocità_motore))

tranne:

# nel caso dovessimo riscontrare qualche problema irrisolvibile

passaggio

# e mantenere la frequenza del loop

end_time = ticks_us()

delay_diff = (end_time - start_time) /1000

if1000.0/ update_rate - delay_diff >0:

sleep(1000.0/ update_rate - delay_diff)

visualizza rawgigglebot_tuned_line_follower.py ospitato con ❤ da GitHub

Passaggio 5: lasciarlo funzionare

Ci sono 2 pulsanti sul micro BBC: bit: pulsante A e pulsante B:

• Premendo il pulsante A si imposta GiggleBot in modo che segua la linea (se presente).
• Premendo il pulsante B si ferma il GiggleBot e si ripristina tutto in modo da poterlo riutilizzare.

Si consiglia vivamente di non sollevare il GiggleBot mentre sta seguendo una linea e poi rimetterlo su di esso perché l'errore che sta calcolando potrebbe accumularsi e rovinare completamente il percorso del robot. Se vuoi sollevarlo, premi il pulsante B e poi quando lo rimetti premi nuovamente A.