Kipindi cha 9 kati ya 10: Kuepuka Vizuizi kwa kutumia Gari Mahiri la 4WD la Raspberry Pi Pico

Kipindi cha 9 kati ya 10: Kuepuka Vizuizi kwa kutumia Gari Mahiri la 4WD la Raspberry Pi Pico

Utangulizi

Mwongozo huu, unaotokana na Somo la 9 kati ya 10 la Kozi ya Robojax, unaonyesha jinsi ya kuunda roboti inayoepuka vizuizi kwa kutumia kit cha SunFounder Raspberry Pi Pico 4WD Smart Car. Mradi huu unachanganya kihisi cha ultrasonic kinachoendeshwa na servo na udhibiti wa motor ili kuunda roboti inayoweza kusafiri katika mazingira yake kwa uhuru. Kwa kuzungusha kihisi kama rada, gari hugundua vizuizi na kuchagua kwa busara njia iliyo wazi kuendelea, na kuifanya kuwa utangulizi bora kwa robotiki, ujumuishaji wa vihisi, na urambazaji wa kujitegemea.

Mradi huu si tu kitu cha kuchezea; ni msingi wa matumizi mengi ya vitendo. Hapa kuna mawazo machache ya kukutia hamasa:

• Roboti ya Kujitegemea ya Uchunguzi: Tengeneza roboti inayoweza kuramba na kuchunguza chumba au eneo la nje bila uingiliaji wa binadamu.
• Kisafishaji cha Utupu cha Kisasa: Tumia kanuni zile zile kuunda roboti inayosafiri ndani ya chumba, ikiepuka samani na kuta huku ikisafisha.
• Roboti ya Doria ya Usalama: Programu gari ili kufanya doria kwenye eneo na kutumia kihisi cha ultrasonic kugundua na kuripoti vizuizi au uvamizi usiotarajiwa.
• Jukwaa la Kielimu la AI: Tumia mradi huu kama hatua ya kujifunza algoriti ngumu zaidi kama kutafuta njia na urambazaji wa wakati mmoja na uchoraji ramani (SLAM).

Somo hili linalenga mantiki kuu na msimbo unaowawezesha gari kufanya maamuzi. Gari hutumia motor ya servo kuzungusha kihisi cha ultrasonic, kama rada, kupima umbali kutoka digrii 0 hadi 180. Msimbo huchambua data hii kupata njia pana zaidi iliyo wazi na kuelekeza gari kusonga mbele, kushoto, au kulia ipasavyo. Video inaonyesha mchakato mzima, kuanzia kujaribu vipengele binafsi hadi kuendesha algoriti ya mwisho ya kuepuka vizuizi katika maze ya ulimwengu halisi.

Vifaa/Vipengele

Mradi huu unategemea kit cha SunFounder Raspberry Pi Pico 4WD Smart Car. Vipengele muhimu vinavyotumika katika somo hili ni:

• Bodi ya microcontroller ya Raspberry Pi Pico
• Chasi ya SunFounder 4WD Smart Car yenye motors nne
• Bodi ya kiendesha motor
• Kihisi cha umbali cha ultrasonic (aina ya HC-SR04)
• Motor ya servo (kwa kuzungusha kihisi cha ultrasonic)
• Ugavi wa nishati (betri za gari)

Mwongozo wa Uunganishaji

Kit cha SunFounder kimeundwa kwa ajili ya kuunganishwa kwa urahisi, na uunganishaji kwa kawaida huwa umeunganishwa mapema kupitia bodi maalum ya upanuzi. Kihisi cha ultrasonic huwekwa kwenye motor ya servo, ambayo huunganishwa kwenye bodi kuu ya udhibiti. Mpangilio huu unaruhusu kihisi kuzungushwa kuchunguza mazingira. Kwa mchoro wa kina wa uunganishaji maalum kwa kit chako, tafadhali rejelea nyaraka rasmi za SunFounder.

Uunganishaji wa msingi unahusisha pini za trigger na echo za kihisi cha ultrasonic, na pini ya ishara ya motor ya servo, zote zikiunganishwa kwenye pini maalum za GPIO kwenye Raspberry Pi Pico. Kiendesha motor pia kinaunganishwa kwenye Pico kudhibiti motors nne za kuendesha. Video inataja kwamba nyaraka kamili, ikiwa ni pamoja na michoro ya uunganishaji, zinapatikana kwa kupakuliwa na kit.

Maelezo ya Msimbo

Somo hili linalenga mantiki ndani ya mfano wa `obstacle_avoid`. Msimbo umeandikwa kwa MicroPython. Wakati programu kamili inapatikana kwa kupakuliwa, tutazingatia vigezo muhimu vinavyoweza kubadilishwa na mtumiaji vinavyodhibiti tabia ya gari. Hivi kwa kawaida hupatikana juu ya hati.

Hapa kuna vigezo kuu unavyoweza kurekebisha ili kuboresha utendaji wa roboti yako:

# Vigezo vya rada na mwendo
radar_reference = 20  # Umbali wa chini kwa cm unaochukuliwa kuwa salama
step_angle = 10       # Ongezeko la pembe kwa kila hatua ya skan ya rada
forward_speed = 30    # Kasi ya motor kwa kusonga mbele (0-100)
turn_speed = 50       # Kasi ya motor kwa kugeuka (0-100)
forward_scan_angle = 50  # Pembe ambayo servo inaskana wakati hakuna kizuizi kinachogunduliwa

• radar_reference: Hii ni umbali muhimu wa usalama kwa sentimita. Ikiwa kizuizi kitagunduliwa karibu kuliko thamani hii, gari litazingatia kuwa "hatari" na kuanza ujanja wa kuepuka. Katika video, hii imewekwa kwa cm 20.
• step_angle: Hii inafafanua usahihi wa skan ya rada. Thamani ndogo (kwa mfano, digrii 10) inamaanisha skan ya kina zaidi lakini inachukua muda mrefu. Thamani kubwa ingekuwa haraka lakini inaweza kukosa vizuizi nyembamba.
• forward_speed & turn_speed: Hizi zinadhibiti nguvu inayotumwa kwa motors. Unaweza kuzirekebisha kubadilisha kasi ya jumla na wepesi wa gari. Kasi ya kugeuka mara nyingi huwekwa juu zaidi kuhakikisha gari linaweza kugeuka kwa ufanisi.
• forward_scan_angle: Wakati hakuna hatari ya haraka mbele, gari hupunguza skan yake kwa pembe hii (inayozingatia mbele) kuangalia vizuizi mara kwa mara kwenye njia yake ya moja kwa moja, kuruhusu mwendo wa mbele laini zaidi.

Video hilo pia linaelezea mantiki kuu ya kufanya maamuzi. Kazi ya `get_direction()` inachambua orodha ya usomaji wa umbali (uliobadilishwa kuwa 1 na 0 kwa salama/hatari) ili kupata njia pana zaidi inayoendelea ya "1". Kulingana na mahali njia hii pana ilipo, kazi inarudisha mwelekeo: "mbele", "kushoto", au "kulia". Kitanzi kikuu basi hutekeleza kitendo kinacholingana, kikigeuza gari na kuchanganua tena hadi njia iliyo mbele iwe wazi.

Mradi/Demonstration ya Moja kwa Moja

Video inatoa demonstration kamili ya mradi. Inaanza kwa kujaribu sensor ya ultrasonic pekee kuonyesha jinsi inavyopima umbali na kuchapisha thamani kwenye shell. Mwalimu kisha anaelezea algorithm ya kukwepa vizuizi kwa kutumia flowchart, akifafanua mchakato wa kufanya maamuzi wa kugeuka kushoto na kulia. Hatimaye, gari linawekwa kwenye maze ndogo iliyoundwa kutoka kwa masanduku ili kuonyesha tabia kamili ya kukwepa vizuizi ikifanya kazi. Gari linafanikiwa kupitia maze, likigeuka kushoto na kulia kupata njia wazi mbele.

Sura za Video

• [00:00] Utangulizi wa Kukwepa Vizuizi
• [01:31] Muhtasari wa SunFounder Smart Car Kit na Vipengele
• [02:47] Jinsi Kipengele cha Kukwepa Vizuizi Kinavyofanya Kazi
• [03:34] Kujaribu Sensor ya Ultrasonic
• [07:45] Kuelezea Algorithm ya Kukwepa Vizuizi na Flowchart
• [12:49] Kuchambua Msimbo Mkuu wa Kukwepa Vizuizi
• [15:43] Demonstration ya Moja kwa Moja ya Mantiki ya Kukwepa Vizuizi
• [22:53] Demonstration ya Mwisho na Maze ya Vizuizi
• [24:35] Hitimisho na Hatua Zinazofuata

Bilder

pico-4wd_main

PICOBOARDWHITEANGLE2_1200x857

Sunfounder_Pico4DW-09-Obstacle-avoidance setup with obstacle on the floor

Sunfounder_Pico4DW-09-Obstacle-avoidance_when ultrasonic detects obstacle

pico-4wd_main

PICOBOARDWHITEANGLE2_1200x857

Sunfounder_Pico4DW-09-Obstacle-avoidance setup with obstacle on the floor

Sunfounder_Pico4DW-09-Obstacle-avoidance_when ultrasonic detects obstacle

# Lesson 9/10 Pi Car Pico 4WD: Obstacle avoid
# Download and resource page https://robojax.com/RJT631
import pico_4wd as car
import time

car.RADAR_REFERENCE = 20
car.RADAR_STEP_ANGLE = 10
MOTOR_FORWARD_POWER = 30
MOTOR_TURNING_POWER = 50

FORWARD_SCAN_ANGLE = 50

car.set_radar_scan_angle(FORWARD_SCAN_ANGLE)
status = "Danger"

def get_dir(radar_data):
    # get scan status of 0, 1
    # print(radar_data)
    radar_data = [str(i) for i in radar_data]
    radar_data = "".join(radar_data)
    # Split 0, leaves the free path
    paths = radar_data.split("0")
    # print(paths)
    # print("paths: %s" % paths)
    length_list = []
    # Calculate where is the widest
    for path in paths:
        length_list.append(len(path))
    if max(length_list) < 4:
        return "left"
    # Calculate the direction of the widest 
    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:
        return "left"
    elif pos > 2 * delta:
        return "right"
    else:
        return "forward"

def main():
    global status
    # General
    while True:
        radar_data = car.radar_scan()
        # print("radar_data: %s" % radar_data)
        # If radar data return a int, means scan not finished, and the int is current angle status
        if isinstance(radar_data, int):
            if radar_data == 0 and status != "Danger":
                print("Danger!")
                status = "Danger"
                car.move("stop")
                car.set_radar_scan_angle(180)
            continue
        else:
            status = "Save"
        
        direction = get_dir(radar_data)

        if direction == "left":
            print("turn left")
            distance = car.get_radar_distance_at(-FORWARD_SCAN_ANGLE/2)
            time.sleep(0.5)
            car.move("left", MOTOR_TURNING_POWER)
            while True:
                distance = car.get_radar_distance_at(-FORWARD_SCAN_ANGLE/2)
                status = car.get_radar_status(distance)
                if status == 1:
                    break
            car.move("stop")
            car.set_radar_scan_angle(FORWARD_SCAN_ANGLE)
        elif direction == "right":
            print("turn right")
            distance = car.get_radar_distance_at(FORWARD_SCAN_ANGLE/2)
            time.sleep(0.5)
            car.move("right", MOTOR_TURNING_POWER)
            while True:
                distance = car.get_radar_distance_at(FORWARD_SCAN_ANGLE/2)
                status = car.get_radar_status(distance)
                if status == 1:
                    break
            car.move("stop")
            car.set_radar_scan_angle(FORWARD_SCAN_ANGLE)
        else:
            print("forward")
            car.set_radar_scan_angle(FORWARD_SCAN_ANGLE)
            car.move("forward", MOTOR_FORWARD_POWER)

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