Συντονισμός του GiggleBot Line Follower - Advanced: 7 βήματα

2024 Συγγραφέας: John Day | [email protected]. Τελευταία τροποποίηση: 2024-01-30 08:35

Σε αυτό το πολύ σύντομο Instructables θα ρυθμίσετε το δικό σας GiggleBot για να ακολουθήσετε μια μαύρη γραμμή. Σε αυτό το άλλο σεμινάριο GiggleBot Line Follower, κωδικοποιήσαμε σκληρά τις τιμές συντονισμού ώστε να λειτουργούν σύμφωνα με αυτό το σενάριο. Wantσως θελήσετε να το κάνετε να συμπεριφέρεται καλύτερα με άλλα κέρδη.

Σε αυτό το σεμινάριο, σας παρουσιάζουμε 2 δέσμες ενεργειών που μπορούν να φορτωθούν και οι δύο σε διαφορετικό μικροσκόπιο BBC: bits έτσι ώστε το ένα από αυτά να τοποθετηθεί στο GiggleBot και με το άλλο, τα 2 κουμπιά χρησιμοποιούνται για να περάσετε από ένα μενού και να συντονίσετε διαφορετικά Παράμετροι. Η αποστολή αυτών των ενημερωμένων παραμέτρων γίνεται μέσω του ραδιοφώνου.

Βήμα 1: Απαιτούμενα εξαρτήματα

Θα χρειαστείτε τα εξής:

1. Ένα ρομπότ GiggleBot για το micro: bit.
2. x3 Μπαταρίες AA
3. x2 BBC micro: bits - το ένα για το GiggleBot και το άλλο που λειτουργεί ως τηλεχειριστήριο για τις παραμέτρους συντονισμού.
4. Μπαταρία για ένα μικροσκόπιο BBC: bit - όπως αυτή που περιλαμβάνεται στο πακέτο του BBC micro: bit.

Αποκτήστε το GiggleBot Robot για το BBC micro: bit εδώ

Βήμα 2: Ρύθμιση των κομματιών και του περιβάλλοντος

Πρέπει επίσης να δημιουργήσετε πραγματικά τα κομμάτια σας (λήψη, εκτύπωση, κοπή και ταινία πλακιδίων) και, στη συνέχεια, να ρυθμίσετε το περιβάλλον (το IDE και το χρόνο εκτέλεσης).

Δεδομένου ότι αυτό το σεμινάριο σχετίζεται πολύ με αυτό το άλλο σεμινάριο με τίτλο GiggleBot Line Follower, απλώς πηγαίνετε εκεί και ακολουθήστε τα βήματα 2 και 3 και στη συνέχεια επιστρέψτε εδώ.

Όσο για το IDE, μπορείτε να χρησιμοποιήσετε το πρόγραμμα επεξεργασίας Mu και για το χρόνο εκτέλεσης, πρέπει να κατεβάσετε το GiggleBot MicroPython Runtime. Μπορείτε να κατεβάσετε το χρόνο εκτέλεσης από την τεκμηρίωσή του εδώ. Μεταβείτε στο κεφάλαιο Τεκμηρίωση Ξεκινώντας και ακολουθήστε αυτές τις οδηγίες σχετικά με τη ρύθμιση του περιβάλλοντος. Από εκείνη τη στιγμή, χρησιμοποιείται η έκδοση v0.4.0 του χρόνου εκτέλεσης.

Βήμα 3: Ρύθμιση του GiggleBot

Πριν αναβοσβήνει ο χρόνος εκτέλεσης στο GiggleBot, βεβαιωθείτε ότι έχετε επιλέξει την επιθυμητή ταχύτητα και ρυθμό ενημέρωσης για το GiggleBot: από προεπιλογή, η ταχύτητα έχει οριστεί σε 100 (μεταβλητή base_speed) και ο ρυθμός ενημέρωσης έχει οριστεί σε 70 (μεταβλητή_βάθμισης_αναφοράς).

Δεδομένης της τρέχουσας εφαρμογής, το υψηλότερο ποσοστό ενημέρωσης που μπορεί να επιτευχθεί είναι 70 και εάν το run_neopixels έχει οριστεί σε True, τότε μόνο 50 είναι εφικτό. Έτσι, κατά κάποιον τρόπο, θα μπορούσατε να πείτε ότι το προεπιλεγμένο ποσοστό ενημέρωσης βρίσκεται ακριβώς στην άκρη του τι μπορεί να κάνει το BBC micro: bit.

Απλώς για την ιστορία, ο αισθητήρας παρακολούθησης γραμμής μπορεί να επιστρέψει ενημερώσεις 100 φορές το δευτερόλεπτο.

Σημείωση: Το ακόλουθο σενάριο μπορεί να έχει κενά κενά και αυτό φαίνεται να οφείλεται σε κάποιο πρόβλημα στην εμφάνιση των GitHub Gists. Κάντε κλικ στην ουσία για να μεταφερθείτε στη σελίδα του GitHub, όπου μπορείτε να αντιγράψετε-επικολλήσετε τον κώδικα.

GiggleBot PID Line Follower Tuner (απαιτεί τηλεχειριστήριο για να το συντονίσετε) - xjfls23

από εισαγωγή microbit*

από εισαγωγή gigglebot*

από utime εισαγωγή sleep_ms, ticks_us

εισαγωγή ραδιοφώνου

εισαγωγή ustruct

# προετοιμασία ραδιοφώνου και νεοπροστοιχείων GB

radio.on ()

neo = init ()

# χρονισμός

βαθμός ενημέρωσης = 70

# προεπιλεγμένες τιμές κέρδους

Kp = 0,0

Ki = 0,0

Kd = 0,0

setpoint = 0,5

σημείο_ ενεργοποίησης = 0,0

min_speed_percent = 0,2

base_speed = 100

last_position = setpoint

ολοκλήρωμα = 0,0

run_neopixels = Λάθος

center_pixel = 5# όπου το κεντρικό pixel του χαμόγελου βρίσκεται στο GB

# turquoise = tuple (map (lambda x: int (x / 5), (64, 224, 208)))

# τυρκουάζ = (12, 44, 41) # που είναι ακριβώς το παραπάνω τιρκουάζ που σχολιάστηκε πάνω από αυτό

error_width_per_pixel = 0,5/3# μέγιστο σφάλμα διαιρούμενο με τον αριθμό των τμημάτων μεταξύ κάθε νεοπροστοιχείου

defupper_bound_linear_speed_reducer (abs_error, trigger_point, above_bound, μικρότερη_κινητική_δύναμη, υψηλότερη_κινητική_δύναμη):

παγκόσμια βασική ταχύτητα

εάν abs_error> = σημείο_ ενεργοποίησης:

# x0 = 0,0

# y0 = 0,0

# x1 = πάνω_δεσμ. - σημείο_ ενεργοποίησης

# y1 = 1,0

# x = abs_error - σημείο_ ενεργοποίησης

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

# το ίδιο με

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

motor_power = base_speed * (μικρότερη_κινητική_δύναμη + (1- έτη) * (υψηλότερη_κινητική_δύναμη - μικρότερη_κινητική_δύναμη))

επιστροφή_κινητήρα

αλλού:

επιστροφή base_speed * υψηλότερη_κινητική_δύναμη

τρέξιμο = Λάθος

προηγούμενο_σφάλμα = 0

συνολικός χρόνος = 0,0

total_counts = 0

ενώ Αλήθεια:

# αν πατηθεί το κουμπί a τότε ξεκινήστε να ακολουθείτε

εάν button_a.is_pressed ():

τρέχω = True

# αλλά αν πατηθεί το κουμπί b σταματήστε τον ακόλουθο γραμμής

εάν button_b.is_pressed ():

τρέξιμο = Λάθος

ολοκλήρωμα = 0,0

προηγούμενο_σφάλμα = 0,0

display.scroll ('{} - {}'. format (total_time, total_counts), delay = 100, wait = False)

συνολικός χρόνος = 0,0

total_counts = 0

pixels_off ()

να σταματήσει()

sleep_ms (500)

αν τρέξει isTrue:

# διαβάστε τους αισθητήρες γραμμής

start_time = ticks_us ()

# ελέγξτε αν έχουμε ενημερώσει τα κέρδη Kp/Kd με ένα τηλεχειριστήριο

προσπαθήστε:

Kp, Ki, Kd, trigger_point, min_speed_percent = ustruct.unpack ('fffff', radio.receive_bytes ())

set_eyes ()

εκτόςTypeError:

πέρασμα

δεξιά, αριστερά = read_sensor (LINE_SENSOR, BOTH)

# γραμμή είναι στα αριστερά όταν η θέση <0,5

# γραμμή είναι στα δεξιά όταν η θέση είναι> 0,5

# γραμμή είναι στη μέση όταν η θέση = 0,5

# είναι ένας σταθμισμένος αριθμητικός μέσος όρος

προσπαθήστε:

θέση = δεξιά /πλωτήρας (αριστερά + δεξιά)

εκτόςZeroDivisionError:

θέση = 0,5

αν θέση == 0: θέση = 0,001

αν θέση == 1: θέση = 0,999

# χρησιμοποιήστε έναν ελεγκτή PD

σφάλμα = θέση - σημείο ρύθμισης

ολοκλήρωμα += σφάλμα

διόρθωση = Kp * error + Ki * integral + Kd * (error - previous_error)

previous_error = σφάλμα

# υπολογίστε τις στροφές του κινητήρα

motor_speed = upper_bound_linear_speed_reducer (abs (σφάλμα), setpoint * trigger_point, setpoint, min_speed_percent, 1.0)

leftMotorSpeed = ταχύτητα_κινητήρα + διόρθωση

rightMotorSpeed = ταχύτητα_κινητήρα - διόρθωση

# φωτίστε τα neopixels για να δείξετε σε ποια κατεύθυνση πρέπει να πάει το GiggleBot

αν το run_neopixels είναι αληθινό και total_counts %3 == 0:

για i inb '\ x00 / x01 / x02 / x03 / x04 / x05 / x06 / x07 / x08':

neo = (0, 0, 0)

για i inb '\ x00 / x01 / x02 / x03':

ifabs (σφάλμα)> error_width_per_pixel * i:

αν σφάλμα <0:

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

αλλού:

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

αλλού:

ποσοστά = 1- (error_width_per_pixel * i -abs (error)) / error_width_per_pixel

# φωτίστε το τρέχον εικονοστοιχείο

αν σφάλμα <0:

# neo [center_pixel + i] = πλειάδα (χάρτης (λάμδα x: int (x * ποσοστό), τιρκουάζ))

neo [center_pixel + i] = (int (12* τοις εκατό), int (44* τοις εκατό), int (41* τοις εκατό))

αλλού:

# neo [center_pixel - i] = πλειάδα (χάρτης (λάμδα x: int (x * ποσοστό), τιρκουάζ))

neo [center_pixel - i] = (int (12* τοις εκατό), int (44* τοις εκατό), int (41* τοις εκατό))

Διακοπή

neo.show ()

προσπαθήστε:

# κλιπ τα μοτέρ

αν μείνειMotorSpeed> 100:

leftMotorSpeed = 100

rightMotorSpeed = rightMotorSpeed - leftMotorSpeed +100

αν είναι σωστόMotorSpeed> 100:

rightMotorSpeed = 100

leftMotorSpeed = leftMotorSpeed - rightMotorSpeed +100

αν μείνειMotorSpeed <-100:

leftMotorSpeed = -100

αν είναι σωστόMotorSpeed <-100:

rightMotorSpeed = -100

# ενεργοποιήστε τους κινητήρες

set_speed (leftMotorSpeed, rightMotorSpeed)

οδηγώ()

# εκτύπωση ((σφάλμα, ταχύτητα_κινητήρα))

εκτός:

# σε περίπτωση που αντιμετωπίσουμε κάποιο αδιόρθωτο ζήτημα

πέρασμα

# και διατηρήστε τη συχνότητα του βρόχου

end_time = ticks_us ()

delay_diff = (ώρα λήξης - ώρα έναρξης) /1000

total_time += delay_diff

total_counts += 1

if1.0/ update_rate - delay_diff> 0:

ύπνος (1.0/ βαθμός ενημέρωσης - delay_diff)

προβολή rawgigglebot_line_follower_tuner.py που φιλοξενείται με ❤ από το GitHub

Βήμα 4: Ρύθμιση του δέκτη (τηλεχειριστήριο)

Το επόμενο πράγμα που πρέπει να κάνουμε είναι να αναβοσβήσουμε το σενάριο χρόνου εκτέλεσης + στο 2ο μικρόφωνο του BBC: bit. Αυτό το δεύτερο μικρό: bit θα λειτουργήσει ως τηλεχειριστήριο στο GiggleBot, το οποίο θα χρησιμοποιηθεί για τον συντονισμό των ακόλουθων παραμέτρων:

1. Kp = αναλογικό κέρδος για τον ελεγκτή PID.
2. Ki = αναπόσπαστο κέρδος για τον ελεγκτή PID.
3. Kd = παράγωγο κέρδος για τον ελεγκτή PID.
4. trigger_point = το σημείο που εκφράζεται σε ποσοστά μεταξύ της ελάχιστης και της μέγιστης ταχύτητας του GiggleBot όπου η ταχύτητα αρχίζει να μειώνεται γραμμικά μέχρι να φτάσει στην ελάχιστη ταχύτητα.
5. min_speed_percent = η ελάχιστη ταχύτητα που εκφράζεται σε ποσοστό της μέγιστης ταχύτητας.

Οι άλλες 2 εναλλακτικές μεταβλητές που μπορούν να συντονιστούν κωδικοποιούνται άμεσα με σκληρό τρόπο στο σενάριο που βρίσκεται στο GiggleBot: το update_rate και το base_speed που αντιπροσωπεύει τη μέγιστη ταχύτητα. Όπως περιγράφεται στην τεκμηρίωση, η μέγιστη ταχύτητα που μπορεί να οριστεί για το GiggleBot είναι 100, η οποία είναι επίσης η προεπιλεγμένη τιμή για το GiggleBot.

Σημείωση: Το ακόλουθο σενάριο μπορεί να έχει κενά κενά και αυτό φαίνεται να οφείλεται σε κάποιο πρόβλημα στην εμφάνιση των GitHub Gists. Κάντε κλικ στην ουσία για να μεταφερθείτε στη σελίδα του GitHub, όπου μπορείτε να αντιγράψετε-επικολλήσετε τον κώδικα.

GiggleBot Remote PID Line Follower Tuner (απαιτεί το άλλο μέρος) - xjfls23

από εισαγωγή microbit*

από utime εισαγωγή sleep_ms

εισαγωγή ραδιοφώνου

εισαγωγή ustruct

# 1ο στοιχείο είναι το κέρδος Kp

# 2ο στοιχείο είναι το κέρδος Ki

# 3ο στοιχείο είναι το κέρδος Kd

# 4ο στοιχείο είναι το σημείο ενεργοποίησης για τους κινητήρες να μειώσουν την ταχύτητα (0 -> 1)

# 5ο στοιχείο είναι η ελάχιστη ταχύτητα για κινητήρες όπως εκφράζεται σε ποσοστά (0 -> 1)

κέρδη = [0.0, 0.0, 0.0, 1.0, 0.0]

stepSize = 0,1

# 0 και 1 για το 1ο στοιχείο

# 2 και 3 για το 2ο στοιχείο

currentSetting = 0

defshowMenu ():

display.scroll ('{} - {}'. μορφή (currentSetting, κέρδη [int (currentSetting /2)]), καθυστέρηση = 100, αναμονή = False)

radio.on ()

showMenu ()

ενώ Αλήθεια:

ενημερωμένο = Λάθος

εάν button_a.is_pressed ():

currentSetting = (currentSetting +1) % (2*5)

ενημερωμένο = True

εάν button_b.is_pressed ():

εάν currentSetting %2 == 0:

# αύξηση κέρδους όταν το currentSetting είναι 0 ή 2 ή..

ifint (currentSetting /2) σε [0, 2]:

κερδίζει [int (currentSetting /2)] += 10* stepSize

αλλού:

κερδίζει [int (currentSetting /2)] += stepSize

αλλού:

# αύξηση κέρδους όταν το currentSetting είναι 1 ή 3 ή..

ifint (currentSetting /2) σε [0, 2]:

κερδίζει [int (currentSetting /2)] -= 10* stepSize

αλλού:

κερδίζει [int (currentSetting /2)] -= stepSize

radio.send_bytes (ustruct.pack ('fffff', *gains))

ενημερωμένο = True

αν ενημερωθεί:

showMenu ()

sleep_ms (200)

προβολή rawgigglebot_line_follower_configurator.py που φιλοξενείται με ❤ από το GitHub

Βήμα 5: Ρύθμιση του GiggleBot

Τοποθετήστε το GiggleBot στο κομμάτι, ενεργοποιήστε το και αφήστε το να τρέξει. Εν τω μεταξύ, θα πρέπει συνεχώς να το επαναφέρετε στην πίστα και να συντονίσετε τα κέρδη/παραμέτρους με το άλλο μικρόφωνο του BBC: κομμάτι που κρατάτε στο χέρι σας.

Για να ξεκινήσετε το GiggleBot, πατήστε το κουμπί A στο μικροσκόπιο του BBC του GiggleBot: bit και για να το σταματήσετε και έτσι να επαναφέρετε την κατάσταση, πατήστε το κουμπί Β.

Στο απομακρυσμένο μικροσκόπιο BBC: bit, το πάτημα του κουμπιού A θα σας μεταφέρει σε κάθε επιλογή στο μενού του και το κουμπί B αυξάνει/μειώνει την αντίστοιχη τιμή. Είναι σαν να βάζεις το ρολόι στο ταμπλό ενός παλιού αυτοκινήτου. Οι επιλογές είναι οι εξής:

1. Οι επιλογές 0-1 είναι για κέρδος Kp.
2. 2-3 επιλογές είναι για το κέρδος Ki.
3. 4-5 επιλογές είναι για κέρδος Kd.
4. 6-7 επιλογές είναι για τη ρύθμιση του σημείου ρύθμισης για τη στιγμή που οι κινητήρες αρχίζουν να επιβραδύνονται.
5. 8-9 επιλογές είναι για τον καθορισμό της ελάχιστης ταχύτητας.

Λάβετε υπόψη ότι οι άρτιοι αριθμοί στο μενού είναι για την αύξηση των αντίστοιχων τιμών και για τους περιττούς είναι ακριβώς το αντίθετο.

Επίσης, όταν πατάτε το κουμπί Β στο μικροσκόπιο του BBC του GiggleBot: bit, θα δείτε στην οθόνη του Neopixel τον αριθμό των χιλιοστών του δευτερολέπτου που έχει περάσει από την τελευταία επαναφορά και τον αριθμό των κύκλων που έχει περάσει το ρομπότ - με αυτά τα 2 μπορείτε να υπολογίσετε το ποσοστό ενημέρωσης του ρομπότ.

Τέλος και το πιο σημαντικό, έχω βρει 2 συντονίσεις για το GiggleBot. Το ένα από αυτά είναι όταν τα LED Neopixel είναι απενεργοποιημένα και το άλλο όταν είναι διαφορετικά. Οι λυχνίες LED Neopixel χρησιμοποιούνται για να δείξουν σε ποια κατεύθυνση έχει συσσωρευτεί το σφάλμα.

1ο σετ ρύθμισης των παραμέτρων (με σβηστά LED NeoPixel)

1. Kp = 32,0
2. Ki = 0,5
3. Kd = 80,0
4. trigger_setpoint = 0,3 (που είναι 30%)
5. min_speed_percent = 0,2 (που είναι 20%)
6. base_speed = 100 (γνωστή και ως μέγιστη ταχύτητα)
7. update_rate = 70 (τρέχει @70Hz)

2ο σετ ρύθμισης των παραμέτρων (με τα LED NeoPixel αναμμένα)

1. Kp = 25,0
2. Ki = 0,5
3. Kd = 35,0
4. trigger_setpoint = 0,3 (που είναι 30%)
5. min_speed_percent = 0,3 (που είναι 30%)
6. base_speed = 70 (γνωστή και ως μέγιστη ταχύτητα)
7. update_rate = 50 (τρέχει @50Hz)
8. Επίσης, η μεταβλητή run_neopixels πρέπει να οριστεί σε True στο σενάριο που φορτώνεται στο μικρόβιο του BBC του GiggleBot: bit. Αυτό θα κάνει τα LED NeoPixel να αναβοσβήνουν με τέτοιο τρόπο ώστε να δείχνουν προς ποια κατεύθυνση συσσωρεύεται το σφάλμα.

Βήμα 6: Εκτέλεση του GiggleBot με απενεργοποιημένα τα NeoPixels

Αυτό είναι ένα παράδειγμα εκτέλεσης του GiggleBot με τις πρώτες παραμέτρους συντονισμού που βρέθηκαν στο προηγούμενο βήμα. Αυτό το παράδειγμα έχει τα LED NeoPixel απενεργοποιημένα.

Βήμα 7: Εκτέλεση του GiggleBot με ενεργοποιημένα τα neopixels

Αυτό είναι ένα παράδειγμα εκτέλεσης του GiggleBot με το 2ο σετ παραμέτρων ρύθμισης που βρέθηκε στο βήμα 5. Αυτό το παράδειγμα έχει τις λυχνίες LED NeoPixel ενεργοποιημένες.

Παρατηρήστε πώς σε αυτό το παράδειγμα, το GiggleBot δυσκολεύεται να ακολουθήσει τη γραμμή - αυτό συμβαίνει επειδή τα LED Neopixel "τρώνε" τον χρόνο CPU του BBC micro: bit. Γι 'αυτό έπρεπε να μειώσουμε το ποσοστό ενημέρωσης από 70 σε 50.