Code zoeken

Cursus Les 8 van 10: Raspberry Pi Pico Slimme Auto – Les 8: Servomotor en objectvolging

Deze les maakt deel uit van: Raspberry Pi Pico 4WD Smart Car

Cursus Les 8 van 10: Raspberry Pi Pico Slimme Auto – Les 8: Servomotor en objectvolging

Deze les uit de Raspberry Pi Pico Smart Car-cursus van Robojax onderzoekt de functionaliteit van een servomotor en hoe je deze kunt gebruiken om een objectvolgende of "volg je hand"-robot te creëren. Het project gaat verder dan eenvoudige motorregeling en demonstreert hoe je een servogestuurde ultrasone sensor combineert met intelligente Python-logica om een auto te creëren die actief een object binnen zijn bereik zoekt en volgt. Dit is een fundamenteel concept in de robotica, waarmee je interactieve projecten kunt bouwen, zoals een robot die een persoon volgt, een slim huisdier dat apporteert, of een autonome beveiligingscamera die beweging volgt. De les behandelt ook een tweede, eenvoudiger project: een auto die automatisch objecten binnen een specifieke afstandszone nadert, duwt en zich ervan terugtrekt.

pi_pico_4WD_follow-hand

Hardware en componenten

Dit project is gebaseerd op de SunFounder Raspberry Pi Pico 4WD-autokit. De belangrijkste componenten die in deze les worden gebruikt, zijn:

  • Raspberry Pi Pico-board
  • 4WD Smart Car-chassis met motoren
  • Servomotor (idealiter een servomotor met metalen tandwielen voor duurzaamheid)
  • Ultrasone afstandssensor (HC-SR04)
  • Motorstuurboard (onderdeel van de autokit)
  • RGB-LED (voor visuele feedback)
  • Stroombron (batterijpakket voor de auto)
PICOBOARDWHITEANGLE2_1200x857

De servomotor vormt de kern van de functionaliteit van deze les. In tegenstelling tot een standaard gelijkstroommotor die continu draait, is een servomotor ontworpen om naar een specifieke hoekpositie te draaien en deze vast te houden, doorgaans tussen 0 en 180 graden. Dit maakt hem perfect voor het nauwkeurig richten van de ultrasone sensor. De kwaliteit van een servo wordt vaak bepaald door het tandwielmateriaal (plastic versus metaal) en het koppel, dat de sterkte en duurzaamheid bepaalt.

Hoe het werkt

Het onderstaande diagram legt uit hoe de code werkt. 

pi_pico_4WD_follow-hand_flow_chart

Bekabelingsgids

De bekabeling voor deze les is eenvoudig, omdat deze voortbouwt op de vooraf geassembleerde autokit. De cruciale verbinding is de servomotor, die moet worden aangesloten op een specifieke GPIO-pin op de Pico.

In de video verbindt de instructeur de servo met pin nummer 18 op de Raspberry Pi Pico. De ultrasone sensor is bovenop de servoarm gemonteerd, zodat deze naar links en rechts kan worden gedraaid om het gebied te scannen. De rest van de bekabeling voor de motoren, RGB-LED en voeding wordt verondersteld vooraf te zijn aangesloten vanuit eerdere lessen in de cursus.

Voor een gedetailleerde visuele gids verwijzen we naar het onderstaande bedradingsschema.

Sunfounder_Pico4DW-08-Follow-hand-ultrasonic_direction

Uitleg van de code

De Python-code voor deze les is gebouwd rond een aangepaste pico_4wd-bibliotheek, die complexe hardware-interacties vereenvoudigt. De door de gebruiker configureerbare delen bevinden zich bovenaan het script en bepalen het gedrag van de auto.

Hier zijn de belangrijkste variabelen die je kunt aanpassen om het "volg je hand"-gedrag van je robot te personaliseren:

  • car.RADAR_REFERENCE = 25: Dit is de maximale afstand in centimeters die de sensor kan "zien". Elk object voorbij deze afstand wordt genegeerd. Je kunt dit verhogen om de auto gevoeliger te maken of verlagen om een dichterbij object te vereisen.
  • car.RADAR_MAX_ANGLE = 45 & car.RADAR_MIN_ANGLE = -45: Deze definiëren de meest linkse (45) en meest rechtse (-45) hoeken die de servo scant. Dit creëert een gezichtsveld van 90 graden voor de auto.
  • car.RADAR_STEP_ANGLE = 10: Dit is de stapgrootte (in graden) die de servo gebruikt om tussen scanpunten te bewegen. Een kleinere stap (bijv. 5) geeft een fijnere resolutie, maar duurt langer om een volledige scan te voltooien. Een grotere stap (bijv. 15) scant sneller, maar met lagere precisie.
  • MOTOR_FORWARD_POWER = 40: Dit stelt het motorvermogen in (0-100) dat wordt gebruikt wanneer de auto vooruit beweegt naar het gedetecteerde object. Pas dit aan om de achtervolgsnelheid van de auto te wijzigen.
  • MOTOR_TURNING_POWER = 40: Dit stelt het motorvermogen in dat wordt gebruikt wanneer de auto draait om het object onder ogen te zien. Een hogere waarde zorgt ervoor dat de auto agressiever draait.

De hoofdlogica van de main()-functie is een continue lus. Deze roept eerst car.radar_scan() aan, die een string van '1'en en '0'en retourneert die aangeeft of er een object is gedetecteerd bij elke scanhoek (een '1' betekent dat er een object binnen de referentieafstand is). De code analyseert vervolgens deze string om de grootste groep opeenvolgende '1'en te vinden, wat het centrum van het gedetecteerde object aangeeft. Op basis van waar dit centrum zich in het scanveld bevindt, krijgt de auto het commando om naar links te draaien, naar rechts te draaien of vooruit te bewegen om zichzelf op het object uit te lijnen en het te volgen.

Live projectdemonstratie

De video geeft een duidelijke demonstratie van het project in actie. De instructeur voert eerst een testscript uit om te laten zien hoe de servomotor naar nauwkeurige hoeken zoals 90, 0 en -90 graden kan worden bewogen. Dit is cruciaal voor het begrijpen van het bereik van de servo en voor het correct monteren van de ultrasone sensor.

Na het monteren van de sensor wordt de functie "hand volgen" getoond. Terwijl de instructeur zijn hand voor de auto beweegt, scant de op de servo gemonteerde sensor naar links en rechts. De logica van de auto verwerkt de sensorgegevens en draait de wielen om naar de gedetecteerde hand te sturen, waardoor deze effectief over de vloer wordt gevolgd. De demonstratie benadrukt hoe de auto een object kan volgen terwijl het beweegt en zijn richting dienovereenkomstig aanpast. Een tweede project wordt ook getoond, waarbij de auto is geprogrammeerd om een object te benaderen en te duwen als het tussen 10 en 20 centimeter afstand wordt gedetecteerd, en om achteruit te rijden als het object te dichtbij komt (onder 10 centimeter).

Belangrijkste Leerpunten

Deze les is een uitstekende introductie tot het gebruik van servomotoren voor het creëren van interactief robotgedrag. Door een servo te combineren met een afstandssensor kun je een robot bouwen met een "gevoel voor zicht" die actief zijn omgeving kan volgen en erop kan reageren. De mogelijkheid om parameters zoals scanhoeken, stapgrootte en motorvermogen af te stemmen, maakt een fijnmazige controle over het gedrag van de robot mogelijk, wat een cruciale vaardigheid is voor elk robotica-project.

Hoofdstukken

  • [00:00] Introductie tot servomotor en objectvolging
  • [01:48] Kenmerken en mogelijkheden van de cursusset
  • [03:08] Werking van de servomotor begrijpen
  • [06:08] Servomotor testen met Python-code
  • [09:59] Uitleg van de functie "hand volgen"
  • [10:49] Demonstratie van de functionaliteit "hand volgen"
  • [15:37] Project: object duwen en achteruitrijden
  • [18:40] Demonstratie van het objectduwproject
  • [19:25] Conclusie en volgende stappen

Afbeeldingen

pico-4wd_main
pico-4wd_main
PICOBOARDWHITEANGLE2_1200x857
PICOBOARDWHITEANGLE2_1200x857
pi_pico_4WD_follow-hand
pi_pico_4WD_follow-hand
pi_pico_4WD_follow-hand_flow_chart
pi_pico_4WD_follow-hand_flow_chart
Sunfounder_Pico4DW-08-Follow-hand-ultrasonic_direction
Sunfounder_Pico4DW-08-Follow-hand-ultrasonic_direction
905-Lesson 8/10 Pi Pico 4WD card Python code: follow hand
Taal: C++
# Lesson 8/10 Pi Car Pico 4WD: Follow hand
# Download and resource page https://robojax.com/RJT630

import pico_4wd as car

car.RADAR_REFERENCE = 25
car.RADAR_MAX_ANGLE = 45
car.RADAR_MIN_ANGLE = -45
car.RADAR_STEP_ANGLE = 10
MOTOR_FORWARD_POWER = 40
MOTOR_TURNING_POWER = 40

def main():
    while True:
        radar_data = car.radar_scan()
        if isinstance(radar_data, int):
            continue
        radar_data = [str(i) for i in radar_data]
        radar_data = "".join(radar_data)
        paths = radar_data.split("1")
        length_list = []
        for path in paths:
            length_list.append(len(path))
        if max(length_list) == 0:
            car.move("stop") 
        else:
            i = length_list.index(max(length_list))
            pos = radar_data.index(paths[i])
            pos += (len(paths[i]) - 1) / 2
            delta = len(radar_data) / 3
            if pos < delta:
                car.move("right", MOTOR_TURNING_POWER)
            elif pos > 2 * delta:
                car.move("left", MOTOR_TURNING_POWER)
            else:
                #if radar_data[int(len(radar_data)/2-1)] == "0":
                #    car.move("stop")
                #else:
                car.move("forward", MOTOR_FORWARD_POWER)

try:
    main()
finally:
    car.move("stop")
    car.set_light_off()

Hulpmiddelen en referenties

Nog geen middelen.

Bestanden📁

Geen bestanden beschikbaar.