Maak een Lidar-geleide robot met de GiggleBot: 8 stappen

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:17

In deze tutorial laten we de GiggleBot de moeilijkheden van een doolhof aanpakken.

We monteren een servo op de GiggleBot waarop we een afstandssensor bevestigen. Tijdens het rennen gaat de servo heen en weer draaien, zodat de afstandssensor de afstand tot elk obstakel kan meten. Dit werkt net als een LIDAR-sensor die meestal veel duurder is.

Tegelijkertijd stuurt de GiggleBot deze gegevens naar een externe BBC micro:bit die op zijn 5-bij-5 matrix van LED's zijn relatieve positie ten opzichte van de obstakels weergeeft.

Jouw taak is om alleen door de GiggleBot te kunnen navigeren door te kijken naar wat er op de andere BBC micro:bit wordt getoond. Om de GiggleBot te bedienen, worden de knoppen op de externe BBC micro:bit gebruikt.

Dat klinkt leuk! Laten we beginnen, zullen we?

Stap 1: Vereiste componenten

We hebben nodig:

1. Een GiggleBot.
2. Een batterijpakket voor de BBC micro:bit. Het wordt geleverd met een BBC micro:bit in zijn pakket.
3. x3 AA-batterijen voor de GiggleBot.
4. Een Grove-kabel om de afstandssensor op de GiggleBot aan te sluiten.
5. Een servokit van DexterIndustries.
6. x3 BBC micro:bits. Een voor de GiggleBot en een om de robot op afstand te besturen.
7. Een afstandssensor van DexterIndustries.

Download hier de GiggleBot-robot voor de BBC micro:bit!

Stap 2: De robot in elkaar zetten

Om de GiggleBot klaar te maken om te worden geprogrammeerd, moeten we hem in elkaar zetten, hoewel er niet veel aan gedaan hoeft te worden.

Plaats de 3 AA-batterijen in het compartiment onder de GiggleBot.

Stel het servopakket samen. Gebruik het laatste gat om de servo op de voorste connectoren van de GiggleBot te bevestigen aan de roterende arm van de servo. U kunt een schroef en/of wat draad gebruiken om het stabieler op zijn plaats te maken. Of je kunt het heet op het bord lijmen. In mijn geval gebruikte ik een schroef en een korte draad om de servo-arm aan het GiggleBot-bord te binden.

Zorg er bij het monteren van de servo-arm op de servo voor dat de servo al op positie 80 staat. U kunt dat doen door gigglebot.set_servo(gigglebot. RIGHT, 80) aan te roepen. Daar kun je hier meer over lezen.

Plaats vervolgens de afstandssensor op de voorzijde van het servopakket en bevestig deze zoals in bovenstaand voorbeeld.

Sluit ten slotte de afstandssensor met een Grove-kabel aan op een van de 2 I2C-poorten en de servomotor op de juiste poort op de GiggleBot - de juiste poort staat erop vermeld.

Stap 3: Maak je eigen doolhof - optioneel

In dit geval heb ik een aantal dozen gebruikt om een track met een gesloten lus te maken, vergelijkbaar met een NASCAR-track.

Bij deze stap kun je heel creatief worden en het maken hoe verdraaid je wilt of het super lang maken, want het is echt aan jou.

Of als je helemaal geen baan wilt, kun je de GiggleBot bijvoorbeeld in een keuken of woonkamer plaatsen - dat zou goed genoeg moeten zijn, want er zijn genoeg muren en obstakels die je nog moet vermijden.

Stap 4: De omgeving instellen

Om de BBC micro:bit in MicroPython te kunnen programmeren, moet je er een editor voor instellen (de Mu Editor) en de GiggleBot MicroPython Runtime als runtime instellen. Daarvoor moet je de instructies op deze pagina volgen. Vanaf dit moment wordt versie v0.4.0 van de runtime gebruikt.

Stap 5: De GiggleBot programmeren - Deel I

Laten we eerst het GiggleBot-script instellen. Dit script zorgt ervoor dat de GiggleBot zijn servomotor 160 graden (80 graden in elke richting) draait, terwijl hij tegelijkertijd 10 metingen van de afstandssensor per omwenteling doet.

Als hij is ingeschakeld, staat de GiggleBot klaar totdat hij een commando van de afstandsbediening ontvangt. Er kunnen maar 3 commando's zijn: vooruit, naar links of naar rechts.

Opmerking: het volgende script bevat mogelijk ontbrekende spaties en dit lijkt te wijten te zijn aan een probleem bij het weergeven van GitHub Gists. Klik op de kern om naar de GitHub-pagina te gaan waar u de code kunt kopiëren en plakken.

Op afstand bestuurbare LIDAR-gebaseerde GiggleBot

van gigglebot-import*

van distance_sensor import DistanceSensor

van microbit import slaap

van utime import ticks_us, sleep_us

import ustruct

radio importeren

# stop de robot als hij al in beweging is

stop()

# radio inschakelen

radio.op()

# afstandssensor object

ds = Afstandssensor()

ds.start_continuous()

roteer_tijd =0,7# gemeten in seconden

roterende_span =160# gemeten in graden

roteer_stappen =10

overhead_compensation =1.05# gedefinieerd in percentages

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

last_read_time =0

radar =bytearray(rotate_steps)

servo_rotate_direction =0# 0 om omhoog te gaan (0->160) en anders 1

radar_index =0

set_servo(RIGHT, 0)

whileTrue:

# lees van de radar

if ticks_us() - last_read_time > time_per_step:

# lezen van de afstandssensor

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

last_read_time = ticks_us()

print(radar_index)

# doe de logica voor het draaien van de servo van links naar rechts

if radar_index == rotatiestappen -1en servo_roteren_richting ==0:

set_servo(RIGHT, 0)

servo_rotate_direction = 1

elif radar_index ==0en servo_rotate_direction ==1:

set_servo(RIGHT, roterende_span)

servo_rotate_direction =0

anders:

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

# en stuur de radarwaarden

radio.send_bytes(radar)

proberen:

# lees robotopdrachten

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

# en activeer de motoren als er commando's zijn ontvangen

set_speed(lmotor, rmotor)

rit()

behalveTypeError:

doorgang

bekijk rawgigglebot_lidar_robot.py gehost met ❤ door GitHub

Stap 6: De afstandsbediening programmeren - Deel II

Wat nog moet gebeuren, is het programmeren van de 2e BBC micro:bit die als afstandsbediening fungeert.

De afstandsbediening wordt gebruikt om op het scherm van 5 bij 5 pixels de relatieve afstand tot obstakels weer te geven. Er worden maximaal 10 pixels ingeschakeld.

Tegelijkertijd geeft de afstandsbediening je de mogelijkheid om de GiggleBot op afstand te bedienen door op de 2 knoppen te drukken: vooruit, naar links en naar rechts.

Opmerking: het volgende script bevat mogelijk ontbrekende spaties en dit lijkt te wijten te zijn aan een probleem bij het weergeven van GitHub Gists. Klik op de kern om naar de GitHub-pagina te gaan waar u de code kunt kopiëren en plakken.

Op afstand bestuurbare LIDAR-gebaseerde GiggleBot - afstandsbedieningscode

van microbit import sleep, display, button_a, button_b

import ustruct

radio importeren

wiskunde importeren

radio.op()

roteer_stappen =10

roterende_span =160# in graden

roteren_stap = draaien_span/roteren_stappen

max_distance =50# in centimeters

side_length_leds =3# gemeten in het aantal pixels

radar =bytearray(rotate_steps)

xar =bytearray(rotate_steps)

yar =bytearray(rotate_steps)

save_xar =bytearray(rotate_steps)

save_yar =bytearray(rotate_steps)

motor_snelheid = 50

whileTrue:

status = radio.receive_bytes_into(radar)

als de statusnietGeen is:

# display.clear()

voor c, val inenumerate(radar):

if radar[c] <= max_distance:

# bereken 2d coördinaten van elke afstand

hoek = roteren_stappen / (roteren_stappen -1) * roteren_stappen * c

hoek += (180-rotate_span) /2.0

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

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

# schaal de afstanden zodat ze op het 5x5 microbit-display passen

x_c = x_c * (side_length_leds -1) / max_distance

y_c = y_c * (side_length_leds +1) / max_distance

# herpositioneer coördinaten

x_c += (side_length_leds -1)

y_c = (side_length_leds +1) - y_c

# ronde coördinaten precies waar de LED's zich bevinden

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

x_c = wiskunde.vloer(x_c)

anders:

x_c = wiskunde.ceil(x_c)

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

y_c = wiskunde.vloer(y_c)

anders:

y_c = wiskunde.ceil(y_c)

xar[c] = x_c

yar[c] = y_c

anders:

xar[c] =0

jaar[c] =0

display.clear()

voor x, y inzip(xar, yar):

display.set_pixel(x, y, 9)

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

stateA = button_a.is_pressed()

stateB = button_b.is_pressed()

als staatA en staatB:

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

print('vooruit')

indien staatA en niet staatB:

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

print('links')

indien niet staatA en staatB:

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

print('rechts')

indien niet staatA en niet staatB:

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

print('stop')

bekijk rawgigglebot_lidar_remote.py gehost met ❤ door GitHub

Stap 7: Het externe scherm interpreteren

"loading="lazy" control the GiggleBot, je hebt de volgende opties:

1. Druk op knop A en knop B om de GiggleBot naar voren te bewegen.
2. Druk op knop A om de GiggleBot naar links te draaien.
3. Druk op knop B om de GiggleBot naar rechts te draaien.

Om te zien in welke richting de dichtstbijzijnde obstakels worden gedetecteerd, hoeft u alleen maar op het scherm van de afstandsbediening (de externe BBC micro:bit die u vasthoudt) te kijken. Je zou de GiggleBot van ver moeten kunnen besturen zonder ernaar te kijken.