Γνωριμία με το κιτ
Η ρομποτική πλατφόρμα Kitronik Autonomous Robotics Platform (Buggy) for Pico αποτελεί την πρόταση της βρετανικής Kitronik για μια εύκολη και διασκεδαστική εισαγωγή στα ρομποτικά οχήματα, με τη βοήθεια μικροελεγκτών τύπου Raspberry Pi Pico.
Πρόκειται για ένα αυτόνομο ρομπότ που σου επιτρέπει να μάθεις βασικές έννοιες της ρομποτικής και του προγραμματισμού, ενώ παράλληλα μπορείς να προσαρμόσεις πάνω του επιπλέον αισθητήρες και ηλεκτρονικά εξαρτήματα επεκτείνοντας περαιτέρω τις δυνατότητές του! Η εύχρηστη πλατφόρμα του ρομπότ, περιλαμβάνει ακόμα και σημεία στερέωσης αποστατών M3 και M4, ώστε να προσαρμόσεις πάνω της τα τυπωμένα εξαρτήματα που εσύ θα σχεδιάσεις!
Το κιτ περιλαμβάνει:
- Ρομποτική πλατφόρμα PCB
- Αναλογικό αισθητήρα γραμμής με 3 φωτοτρανζίστορ (Line following board)
- Αισθητήρα απόστασης υπερήχων (HC-SR04 ultrasonic sensor)
- Τροχούς και ελαστικά (x2)
H ρομποτική πλατφόρμα της Kitronik διαθέτει:
- In-line geared DC motors (x2)
- RGB LED (x4)
- Buzzer
- Push-button
- Διακόπτη τροφοδοσίας (on/off)
- Υποδοχείς servo (x4)
- Υποδοχείς αισθητήρων απόστασης (x2)
- Υποδοχέα αισθητήρα γραμμής
- Θήκες μπαταριών
Τεχνικά χαρακτηριστικά:
- Μήκος πλατφόρμας: 126mm
- Πλάτος πλατφόρμας: 80mm
- Διάμετρος τροχών (με ελαστικά): 67,5mm
- Τάση τροφοδοσίας: 4,8-6V
Επιπλέον θα χρειαστείς:
Συναρμολόγησε το!
Η συναρμολόγηση του ρομπότ είναι πανεύκολη! Τοποθέτησε τα ελαστικά στους τροχούς και έπειτα προσάρμοσε τις ρόδες στους κινητήρες. Στο κάτω μέρος της πλατφόρμας υπάρχει υποδοχή για τον αισθητήρα γραμμής της Kitronik, ενώ ο αισθητήρας απόστασης μπορεί να τοποθετηθεί στο μπροστινό ή στο πίσω μέρος του ρομπότ. Το Pico τοποθετείται περίπου στο κέντρο της πλατφόρμας, με την υποδοχή του καλωδίου του στραμμένη προς το πίσω μέρος του ρομπότ. Τέλος, πρόσθεσε τις μπαταρίες στις αντίστοιχες θήκες και το ρομποτάκι είναι έτοιμο!
MicroPython modules
Η Kitronik έχει αναπτύξει εξειδικευμένα modules (αρθρώματα) για τη MicroPython που καθιστούν τον προγραμματισμό του ρομπότ εξαιρετικά απλό, ακόμα και για αρχάριους. H ομάδα της GRobotronics συμπλήρωσε τα διαθέσιμα εργαλεία με ένα ακόμα module που σου επιτρέπει να εμβαθύνεις στην τεχνική του line following. Έτσι, έχεις τη δυνατότητα να δοκιμάσεις διαφορετικές ρυθμίσεις και παραμέτρους, χρησιμοποιώντας το ταχύτατο ρομποτάκι της Kitronik ως πολύτιμο εργαλείο στη διαδικασία μάθησης!
Κατέβασε το module PicoAutonomousRobotics από το αποθετήριο της Kitronik και το module GrobotronicsPicoRobotLF από το αποθετήριο της GRobotronics.
MicroPython firmware
Αν δεν έχεις ξαναχρησιμοποιήσει MicroPython για τον προγραμματισμό του Pico, θα πρέπει αρχικά να εγκαταστήσεις το MicroPython firmware. Εντόπισε την πλακέτα σου και κατέβασε το αντίστοιχο firmware από το site της MicroPython. Κρατώντας πατημένο το κουμπί “BOOTSEL”, σύνδεσε με ένα USB καλώδιο τον μικροελεγκτή με τον υπολογιστή και έπειτα ελευθέρωσε το κουμπί. Το μόνο που χρειάζεται να κάνεις είναι να αντιγράψεις το αρχείο uf2 του firmware στον φάκελο του Pico που θα εμφανιστεί ή απλώς να το μεταφέρεις εκεί με “drag and drop”.
Επιλογή editor
Για τον προγραμματισμό του Pico με Python μπορείς να χρησιμοποιήσεις είτε το Thonny (Python IDE για αρχάριους), είτε να γράψεις κώδικα στο Visual Studio Code -τον δημοφιλέστερο open source code editor.
Visual Studio Code
Αν χρησιμοποιείς ήδη το Visual Studio Code και δεν θέλεις να αλλάξεις editor, για να προγραμματίσεις το Pico θα πρέπει να προσθέσεις την αντίστοιχη επέκταση. Κάνε κλικ στο εικονίδιο των Extensions στην αριστερή στήλη, γράψε στο πλαίσιο αναζήτησης τη λέξη “micropico” και τέλος πάτησε “Install”.
Φτιάξε έναν φάκελο στον υπολογιστή για το project σου (π.χ. με το όνομα “pico project”) και σύνδεσε το Pico με τον υπολογιστή. Ύστερα επίλεξε File > Open Folder και άνοιξε τον φάκελο που μόλις δημιούργησες. Για να δεις τις επιλογές που σου δίνει η επέκταση πάτησε CTRL+Shift+P και πληκτρολόγησε “micropico” στο πλαίσιο που εμφανίζεται. Διάλεξε την επιλογή “MicroPico: Configure project” και αυτόματα θα δημιουργηθούν κάποια αναγκαία αρχεία. Επίσης, στο κάτω μέρος του VS Code θα εμφανιστούν επιλογές για την αλληλεπίδραση με το Pico.
Επιλέγοντας “Run” από το κάτω μέρος του παράθυρου, ένα πρόγραμμα σε Python τρέχει στην MicroPython του Pico, γι’ αυτό και δεν απαιτείται καν να είναι εγκατεστημένη η Python στον υπολογιστή. Όμως η απλή εκτέλεση ενός αρχείου δεν επιφέρει τη μόνιμη αντιγραφή του στην πλακέτα. Η λειτουργία “Run” είναι χρήσιμη για τη δοκιμή του κώδικα, αλλά δεν αποθηκεύει το πρόγραμμα στο Pico.
Για τις δοκιμές σου, θα χρειαστεί να αποσυνδέσεις το καλώδιο, ώστε το ρομπότ να μπορεί να κινείται ελεύθερα. Επομένως, θα πρέπει όχι μόνο να αποθηκεύσεις στο Pico όλα τα αρχεία του project, αλλά επιπλέον να δώσεις στο κύριο πρόγραμμα το όνομα “main.py” ώστε να εκτελείται αυτόματα κάθε φορά που τροφοδοτείται το Pico.
Αφού δημιουργήσεις ή αντιγράψεις το αρχείο “main.py” στον φάκελο του project και επιπλέον μεταφέρεις όλα τα απαραίτητα αρχεία των module στον ίδιο φάκελο, κάνε δεξί κλικ στα αρχεία που θα βρεις στην αριστερή στήλη και έπειτα επίλεξε “Upload file to Pico”. Μόλις ολοκληρώσεις αυτή τη διαδικασία, μπορείς να αφαιρέσεις το καλώδιο, να μεταφέρεις το ρομποτ (π.χ. σε κάποια πίστα) και να τροφοδοτήσεις το Pico από τις μπαταρίες του ρομπότ έχοντας το διακόπτη του στη θέση “on”.
Μην παραλείπεις να ανεβάζεις το κύριο πρόγραμμα στο Pico κάθε φορά που κάνεις αλλαγές, ώστε να ενημερώνεται το αρχείο με την πιο πρόσφατη έκδοση του κώδικα. Επίσης, στο κάτω μέρος του παράθυρου θα βρεις και την επιλογή “All commands”, η οποία σου επιτρέπει να δεις όλες τις διαθέσιμες λειτουργίες της επέκτασης MicroPico, διευκολύνοντάς σε στη διαχείριση του project και των αρχείων σου.
Thonny IDE
Μπορείς να βρεις βασικές οδηγίες για τον προγραμματισμό του Pico με το Thonny στο site της Kitronik: First steps with the Raspberry Pi Pico and Thonny.
Επιπλέον, ακολουθώντας τα παρακάτω βήματα, θα μπορέσεις να αποθηκεύσεις τα modules και το κύριο πρόγραμμα απευθείας στον μικροελεγκτή σου:
- Σύνδεσε το Pico με τον υπολογιστή μέσω καλωδίου και κάνε κλικ στο “Stop”.
- Πήγαινε στο “Προβολή” και επίλεξε “Αρχεία”.
- Βρες τα αρχεία των modules στους φακέλους του υπολογιστή σου.
- Κάνε δεξί κλικ σε κάθε αρχείο και έπειτα πάτησε “Ανέβασμα στο”.
- Αποθήκευσε ή μεταφόρτωσε το κύριο πρόγραμμα ως “main.py”, ώστε να εκτελείται αυτόματα όταν το Pico τροφοδοτείται.
Βασικές εντολές χειρισμού του ρομπότ
Στη αρχή του προγράμματος πρόσθεσε, εκτός των άλλων module, και αυτό της Kitronik. Δημιούργησε το αντικείμενο robot της κλάσης KitronikPicoRobotBuggy και τρέξε ένα πρώτο δοκιμαστικό πρόγραμμα, ενεργοποιώντας το buzzer με την εντολή robot.beepHorn(), για να βεβαιωθείς ότι όλα λειτουργούν σωστά. Μην ξεχάσεις να θέσεις τον διακόπτη του ρομπότ στη θέση “on”!
from PicoAutonomousRobotics import KitronikPicoRobotBuggy
from time import sleep
import random
robot = KitronikPicoRobotBuggy()
robot.beepHorn() 
Στη συνέχεια φτιάξε τις συναρτήσεις random_colors() και turn_off_leds() για να χειριστείς τα RGB LED. Οι συναρτήσεις περιλαμβάνουν τη for ώστε να πραγματοποιούνται 4 επαναλήψεις, όσα και τα LED που διαθέτει η πλατφόρμα. Το LED 0 είναι το μπροστά αριστερά, το LED 1 είναι το μπροστά δεξιά, LED 2 είναι το πίσω δεξιά και το LED 3 είναι το πίσω αριστερά. Η εντολή robot.setLED(led, color) καθορίζει το LED που θα φωτιστεί και το αντίστοιχο χρώμα που θα έχει. Το χρώμα -αλλά και η φωτεινότητα- ορίζεται από τις τρεις συνιστώσες (R, G, B) οι οποίες παίρνουν τιμές από 0 έως 255. Τελικά αφού σεταριστούν τα LED, ενεργοποιούνται με την εντολή robot.show(). Συνεπώς, με τη συνάρτηση random_colors() τα 4 LED ανάβουν διαδοχικά κάθε μισό δευτερόλεπτο σε τυχαία χρώματα, γιατί σε κάθε μία από τις μεταβλητές red, green, blue καταχωρείται ένας τυχαίος ακέραιος αριθμός από 0 έως 255. Με τη συνάρτηση turn_off_leds(), όλα τα LED σβήνουν μαζί καθώς οι τιμές (R, G, B) είναι 0, ενώ δεν υπάρχει κάποια καθυστέρηση και οι 4 επαναλήψεις πραγματοποιούνται σχεδόν ακαριαία.
from PicoAutonomousRobotics import KitronikPicoRobotBuggy
from time import sleep
import random
robot = KitronikPicoRobotBuggy()
def random_colors():
for i in range(4):
red = random.randint(0, 255)
green = random.randint(0, 255)
blue = random.randint(0, 255)
robot.setLED(i, (red, green, blue))
robot.show()
sleep(0.5)
def turn_off_leds():
for i in range(4):
robot.setLED(i, (0, 0, 0))
robot.show()
robot.beepHorn()
random_colors()
turn_off_leds() Χρησιμοποίησε την εντολή robot.motorOn(“motor”, “direction”, speed) για να θέσεις σε κίνηση το ρομπότ. Για να κατανοήσεις τη λειτουργία της, φτιάξε μια συνάρτηση παρόμοια με την motors_test() που φαίνεται παρακάτω. Πληκτρολόγησε “l” ή “r” για να επιλέξεις τον αριστερό ή τον δεξιό κινητήρα και “f” ή “r” για να καθορίσεις τη φορά περιστροφής του. Η τιμή της τρίτης παραμέτρου καθορίζει την ταχύτητα περιστροφής του κινητήρα και παίρνει τιμές από 0 έως 100. Για να σταματήσεις τους κινητήρες πρόσθεσε στο τέλος της συνάρτησης τις εντολές robot.motorOff(“motor”). Μην παραλείψεις να καλέσεις και αυτή τη συνάρτηση στο τέλος του κώδικα ώστε να εκτελεστεί!
from PicoAutonomousRobotics import KitronikPicoRobotBuggy
from time import sleep
import random
robot = KitronikPicoRobotBuggy()
def random_colors():
for i in range(4):
red = random.randint(0, 255)
green = random.randint(0, 255)
blue = random.randint(0, 255)
robot.setLED(i, (red, green, blue))
robot.show()
sleep(0.5)
def turn_off_leds():
for i in range(4):
robot.setLED(i, (0, 0, 0))
robot.show()
def motors_test():
robot.motorOn("l", "f", 20)
robot.motorOn("r", "f", 20)
sleep(0.4)
robot.motorOn("l", "r", 20)
robot.motorOn("r", "r", 20)
sleep(0.4)
robot.motorOn("l", "r", 20)
robot.motorOn("r", "f", 20)
sleep(0.4)
robot.motorOn("l", "f", 20)
robot.motorOn("r", "r", 20)
sleep(0.4)
robot.motorOff("l")
robot.motorOff("r")
robot.beepHorn()
random_colors()
turn_off_leds()
motors_test()Τα “μάτια” του ρομπότ
Ώρα για τον προγραμματισμό του αισθητήρα απόστασης! Τοποθέτησέ τον στο μπροστινό μέρος και χρησιμοποίησε μια δομή επανάληψης για να εμφανίσεις τις μετρήσεις στην οθόνη. Συμπλήρωσε “f” ή ”r” στην εντολή robot.getDistance(“sensor”) για να δηλώσεις αν ο αισθητήρας απόστασης είναι τοποθετημένος στον μπροστά ή στον πίσω υποδοχέα της πλατφόρμας. Στρογγυλοποίησε τις μετρήσεις στο πρώτο δεκαδικό ψηφίο και πειραματίσου τοποθετώντας αντικείμενα μπροστά από το ρομπότ.
from PicoAutonomousRobotics import KitronikPicoRobotBuggy
from time import sleep
robot = KitronikPicoRobotBuggy()
robot.beepHorn()
while True:
distance = robot.getDistance("f")
distance = round(distance, 1)
print("Distance:", distance, "cm")
sleep(0.5)
Έπειτα δοκίμασε έναν αυτοματισμό: κάνε το ρομπότ να ακινητοποιείται όταν συναντά κάποιο εμπόδιο! Ο αισθητήρας HC-SR04 μπορεί να καταγράψει τιμές από 2cm έως 400cm. Προγραμμάτισε το ρομπότ να σταματά αν η απόσταση είναι μικρότερη από 15cm και ταυτόχρονα μεγαλύτερη από 2cm, ενώ παράλληλα φώτισε έντονα κόκκινα τα πίσω LED. Δοκίμασε αρχικά το παρακάτω πρόγραμμα και έπειτα πρόσθεσε έναν ακόμα αισθητήρα απόστασης στο πίσω μέρος του ρομπότ και προγραμμάτισέ το να παρκάρει μόνο του!
from PicoAutonomousRobotics import KitronikPicoRobotBuggy
robot = KitronikPicoRobotBuggy()
robot.beepHorn()
while True:
distance = robot.getDistance("f")
if distance < 15 and distance > 2:
robot.motorOff("l")
robot.motorOff("r")
robot.setLED(0, (255, 255, 100))
robot.setLED(1, (255, 255, 100))
robot.setLED(2, (255, 0, 0))
robot.setLED(3, (255, 0, 0))
robot.show()
else:
robot.motorOn("l", "f", 10, jumpStart=True)
robot.motorOn("r", "f", 10, jumpStart=True)
robot.setLED(0, (255, 255, 150))
robot.setLED(1, (255, 255, 150))
robot.setLED(2, (50, 0, 0))
robot.setLED(3, (50, 0, 0))
robot.show()Η Kitronik έχει συμπεριλάβει στο module PicoAutonomousRobotics τη λειτουργία “jump start” που βοηθά τους κινητήρες κατά την εκκίνηση της περιστροφής τους όταν η ταχύτητα παίρνει χαμηλές τιμές. Πρακτικά οι κινητήρες δουλεύουν αρχικά στο 100% για 20ms και στη συνέχεια η ταχύτητα περιστροφής τους επανέρχεται στην προεπιλεγμένη τιμή.
Στο προηγούμενο παράδειγμα, η ενεργοποίηση της λειτουργίας “jump start” δεν είναι επιθυμητή καθώς οι κινητήρες μπορεί να φαίνεται ότι λειτουργούν συνεχόμενα αλλά στην πραγματικότητα ενεργοποιούνται για πάρα πολύ λίγο με πολύ μεγάλη συχνότητα. Αυτό συμβαίνει διότι οι επαναλήψεις, άρα και ο έλεγχος των συνθηκών της if-else, πραγματοποιούνται ακατάπαυστα και πολύ γρήγορα. Αν η λειτουργία “jump start” ήταν ενεργοποιημένη, το ρομποτάκι θα δούλευε μόνιμα με τους κινητήρες στο 100% και δεν θα προλάβαινε να λειτουργήσει στην ταχύτητα που προγραμματίστηκε.
Η τέταρτη παράμετρος της εντολής robot.motorOn(“motor”, “direction”, speed, jumpStart) είναι αυτή που ενεργοποιεί/απενεργοποιεί τη λειτουργία “jump start”. Υπάρχει όμως ένα μικρό σφάλμα στη λογική του κώδικα του αρχείου PicoAutonomousRobotics.py: πληκτρολογόντας “jumpStart=True” απενεργοποιείται ενώ με τη ρύθμιση “jumpStart=False” ενεργοποιείται. Το παράδοξο λύνεται διαγράφοντας τον τελεστή “not” στη γραμμή 55 του αρχείου. Ο παραπάνω κώδικας όμως δεν αναφέρεται σε κάποια τροποποιημένη εκδοχή του module PicoAutonomousRobotics και απλώς χρησιμοποιείται η αντίστροφη λογική για να ξεπεραστεί το πρόβλημα.
Τεχνικές ακολουθίας γραμμής
Το ρομποτάκι της Kitronic για το Pico είναι μια εξαιρετική επιλογή για να εξασκηθεί κάποιος στην τεχνική line following, χάρη στους ισχυρούς κινητήρες του και στον τριπλό αναλογικό αισθητήρα γραμμής. Χρησιμοποίησε την πίστα της Kitronik ή σχεδίασε τη δική σου πίστα κολλώντας μαύρη μονωτική ταινία πάνω σε ανοιχτόχρωμη επιφάνεια (όχι απαραίτητα λευκή).
Συνδύασε το module της GRobotronics (GRobotronicsPicoRobotLF) με αυτό της Kitronik (PicoAutonomousRobotics) ώστε να επιτύχεις line following με απλό ή πιο σύνθετο τρόπο, καθώς και να βελτιστοποιήσεις τη λειτουργία των αισθητήρων γραμμής. Το αρχείο GRobotronicsPicoRobotLF.py παρέχει τέσσερις βασικές μεθόδους (method) που μπορείς να αξιοποιήσεις:
- stop_robot(): Σταματά το ρομπότ, με τα LED να φωτίζονται κόκκινα όσο παραμένει ακινητοποιημένο.
- robot_adjustment(): Χρησιμοποιείται για το καλιμπράρισμα των τριών αισθητήρων γραμμής του ρομπότ, ώστε να εξαλειφθούν οι μεταξύ τους διαφορές και παράλληλα να προσαρμοστούν στις ιδιαιτερότητες της εκάστοτε επιφάνειας. Η διαδικασία γίνεται σύροντας το ρομπότ αργά μπρος-πίσω κάθετα στη μαύρη γραμμή, ώστε οι αισθητήρες του line following board να περάσουν εξ ολοκλήρου πάνω από τη λευκή και τη μαύρη επιφάνεια. Με αυτόν τον τρόπο, καταγράφονται οι μέγιστες και οι ελάχιστες τιμές που μπορούν να ανιχνεύσουν οι τρεις αισθητήρες. Αν δεν εκτελέσεις αυτή τη μέθοδο πριν ξεκινήσει το ρομπότ το line following, ορίζονται ως ελάχιστες και μέγιστες οι ακραίες τιμές που έχει τη δυνατότητα να καταγράψει το Pico με “αναλογική ανάγνωση”, δηλαδή 0 και 65535 αντίστοιχα. Η καταγραφή των τιμών ολοκληρώνεται όταν πατηθεί το κουμπί της πλατφόρμας. Αν επιλέξεις να κρατήσεις το καλώδιο συνδεδεμένο στο ρομπότ, μπορείς να δεις στην οθόνη του υπολογιστή πως μεταβάλλονται οι μέγιστες και οι ελάχιστες τιμές που καταγράφονται από τους τρεις αισθητήρες. Τελικά, αυτές οι διαφορές που προκύπτουν για τους τρεις αισθητήρες και οφείλονται στα διαφορετικά κατασκευαστικά χαρακτηρίστηκα τους, εξαλείφονται μέσω του module GRobotronicsPicoRobotLF. Καθ’ όλη τη διάρκεια της διαδικασίας τα LED του ρομπότ παραμένουν λευκά.
- simple_line_following(speed): Εδώ το ρομπότ ακολουθεί απλά τη μαύρη γραμμή, ελέγχοντας ποιοι αισθητήρες την ανιχνεύουν. Αν και οι τρεις αισθητήρες βρεθούν πάνω από λευκή επιφάνεια το ρομπότ σταματά. Αν ο κεντρικός αισθητήρας ανιχνεύσει τη γραμμή το ρομπότ κινείται ευθεία με ταχύτητα ίση με τη speed. Αν το ρομπότ παρεκκλίνει αρκετά από τη γραμμή, ο κεντρικός αισθητήρας θα βρεθεί πάνω από λευκή επιφάνεια, ενώ το ίδιο θα συμβεί και με ένα από τους δύο πλαϊνούς αισθητήρες. Σε αυτή την περίπτωση οι κινητήρες του ρομπότ θα περιστραφούν κατάλληλα -με ταχύτητες ίσες με speed αλλά με αντίθετη φορά– ώστε να επανέλθει και πάλι στη σωστή πορεία. Καθ’ όλη τη διάρκεια του απλού line following τα LED του ρομπότ παραμένουν πράσινα.
- advanced_line_following(Kp, Ki, Kd, speed): Αυτή η μέθοδος χρησιμοποιεί τον PID έλεγχο για πιο ακριβές line following. Τα LED παραμένουν μπλε καθ’ όλη τη διάρκεια της διαδικασίας. Οι παράμετροι Kp, Ki, Kd και speed καθορίζουν την ταχύτητα και την ακρίβεια του line following, ενώ πρέπει να προσαρμόζονται ανάλογα με την κατάσταση του ρομπότ (κινητήρες, μπαταρίες κ.ά.). Στη συνέχεια του οδηγού, παρέχονται συμβουλές για την επιλογή των κατάλληλων συντελεστών για βέλτιστη απόδοση.
Στο παράδειγμα που ακολουθεί, χρησιμοποιείται η κλάση Timer και η συνάρτηση check_button(timer), ώστε η τιμή της μεταβλητής state να αυξάνεται κατά 1 κάθε φορά που πατιέται το κουμπί της πλατφόρμας. Ο έλεγχος για το πάτημα του κουμπιού γίνεται κάθε 200ms, αποφεύγοντας έτσι πολλαπλές αλλαγές στην τιμή της state σε κάθε πάτημα.
Κατά την έναρξη του προγράμματος, η state παίρνει αρχική τιμή 0 και το ρομπότ βρίσκεται σε διαδικασία καταγραφής τιμών από τους αισθητήρες για να βελτιστοποιηθεί η λειτουργία τους. Με το πρώτο πάτημα του κουμπιού, η state γίνεται 1, το καλιμπράρισμα διακόπτεται και μπορείς να τοποθετήσεις το ρομπότ κατά μήκος της γραμμής, ώστε να βρίσκεται στην κατάλληλη θέση για να ακολουθήσει τη γραμμή. Με το επόμενο πάτημα, η state γίνεται 2 και το ρομπότ αρχίζει να εκτελεί απλό line following. Στη συνέχεια, με ένα ακόμα πάτημα, η state γίνεται 3 και το ρομπότ σταματά, επιτρέποντας την επανατοποθέτησή του στη γραμμή. Με ένα ακόμα τελικό πάτημα σε αυτήν τη σειρά, η state γίνεται 4 και το ρομπότ εκτελεί το ακριβέστερο PID line following. Με το επόμενο πάτημα, η state επιστρέφει στην τιμή 1 και η ακολουθία 1-2-3-4 επαναλαμβάνεται.
from PicoAutonomousRobotics import KitronikPicoRobotBuggy
from GRobotronicsPicoRobotLF import LineFollowing
from machine import Timer
robot = KitronikPicoRobotBuggy()
lf_robot = LineFollowing(robot)
def check_button(timer):
global state
buttonValue = robot.button.value()
if buttonValue == 1:
state += 1
if state > 4:
state = 1
debounceTimer = Timer(-1)
debounceTimer.init(period=200, mode=Timer.PERIODIC, callback=check_button)
state = 0
SIMPLE_LF_SPEED = 20
ADVANCED_LF_SPEED = 30
Kp = 0.3
Ki = 0.001
Kd = 5
while True:
if state == 0:
lf_robot.robot_adjustment()
elif state == 1 or state == 3:
lf_robot.stop_robot()
elif state == 2:
lf_robot.simple_line_following(SIMPLE_LF_SPEED)
elif state == 4:
lf_robot.advanced_line_following(Kp, Ki, Kd, ADVANCED_LF_SPEED) Επιλογή συντελεστών Kp, Ki, Kd
Υπάρχουν διάφοροι τρόποι για την εύρεση του ιδανικού συνδυασμού των τιμών των συντελεστών Kp, Ki, Kd, που περιλαμβάνουν ακόμα και μετρήσεις (π.χ. μέθοδος Ziegler-Nichols). Μπορείς ωστόσο να βρεις εκείνες τις τιμές που θα σου δώσουν ένα πολύ καλό αποτέλεσμα, απλώς παρατηρώντας την κίνηση του ρομπότ και δοκιμάζοντας τιμές με βάση τη συμπεριφορά του.
- Βήμα 1: Ξεκίνα με Ki=0 και Kd=0 και δώσε στο Kp μια μικρή τιμή.
- Βήμα 2: Άρχισε να αυξάνεις σταδιακά το Κp. Θέλεις το ρομπότ να ακολουθεί τη γραμμή χωρίς να αποκλίνει υπερβολικά. Αν το ρομπότ δεν αντιδρά αρκετά γρήγορα, αύξησε περαιτέρω το Kp. Αν παρατηρήσεις μεγάλες ταλαντώσεις γύρω από τη γραμμή, μείωσε το Kp.
- Βήμα 3: Με το Kp σε ικανοποιητικό επίπεδο, δώσε στο Kd μια μικρή τιμή.
- Βήμα 4: Άρχισε να αυξάνεις σταδιακά το Κd. Αν οι ταλαντώσεις μειώνονται καθώς αυξάνεις το Kd, συνέχισε μέχρι να σταθεροποιηθεί το ρομπότ. Αν παρατηρήσεις ότι το ρομπότ αρχίζει να αντιδρά πιο αργά και καθυστερεί η απόκρισή του, τότε το Kd μπορεί να είναι πολύ υψηλό.
- Βήμα 5: Ρύθμισε το Ki σε μια πολύ μικρή τιμή.
- Βήμα 6: Άρχισε να αυξάνεις σταδιακά το Κi. Σκοπός του Κi είναι να εξαλείψει το “σφάλμα σταθερής κατάστασης” που μπορεί να εμφανίζεται και επιπλέον κάνει τη διόρθωση εντονότερη στις περιπτώσεις που το ρομπότ βρίσκεται αρκετή ώρα εκτός της ιδανικής τροχιάς (π.χ. στο εξωτερικό μέρος μιας καμπής). Αν οι ταλαντώσεις αρχίσουν να αυξάνονται σημαντικά με την αύξηση του Κi, τότε το Κi μπορεί να είναι πολύ υψηλό.
Σύνδεσμοι
Pico-series Microcontrollers – Raspberry Pi Documentation
Kitronik Autonomous Robotics Platform (Buggy) for Pico – Kitronik Ltd
