Съдържание:
- Автор John Day [email protected].
- Public 2024-01-30 07:52.
- Последно модифициран 2025-01-23 14:36.
В тази много кратка инструкция ще настроите своя собствен GiggleBot да следва черна линия. В този друг урок GiggleBot Line Follower ние кодирахме строго настройващите стойности, за да работят според този сценарий. Може да искате да го накарате да се държи по -добре, като измислите други печалби.
В този урок ние ви показваме 2 скрипта, които могат да се заредят на различни BBC micro: бита, така че един от тях да бъде поставен в GiggleBot, а с другия, двата бутона се използват за преминаване през меню и настройване на различни параметри. Изпращането на тези актуализирани параметри се извършва по радиото.
Стъпка 1: Необходими компоненти
Ще ви трябва следното:
- Робот GiggleBot за micro: bit.
- x3 AA батерии
- x2 BBC micro: bits - единият за GiggleBot, а другият действа като дистанционно за настройка на параметрите.
- Батерия за BBC micro: bit - като тази, която се предлага в пакета BBC micro: bit.
Вземете робота GiggleBot за 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 (update_rate променлива).
Като се има предвид текущата реализация, най -високата скорост на актуализация, която може да бъде постигната, е 70 и ако run_neopixels е зададено на True, тогава само 50 е постижимо. Така че по някакъв начин бихте могли да кажете, че скоростта на актуализиране по подразбиране е точно на ръба на това, което BBC micro: bit може да направи.
Само за запис, сензорът за последовател на линия може да връща актуализации 100 пъти в секунда.
Забележка: В следния скрипт може да липсват интервали и това изглежда се дължи на някакъв проблем при показването на GitHub Gists. Щракнете върху същността, за да ви отведе до страницата на GitHub, където можете да копирате и поставите кода.
GiggleBot PID Line Follower Tuner (изисква дистанционно, за да го настроите) - xjfls23
| от внос на microbit* |
| от gigglebot import* |
| от utime import sleep_ms, ticks_us |
| внос на радио |
| ustruct за импортиране |
| # инициализирайте радио и GB неопиксели |
| radio.on () |
| neo = init () |
| # време |
| update_rate = 70 |
| # стойности на печалба по подразбиране |
| Kp = 0.0 |
| Ki = 0.0 |
| Kd = 0,0 |
| зададена стойност = 0,5 |
| trigger_point = 0.0 |
| min_speed_percent = 0.2 |
| базова_скорост = 100 |
| last_position = зададена точка |
| интеграл = 0,0 |
| run_neopixels = False |
| center_pixel = 5# където централният пиксел на усмивката се намира на GB |
| # тюркоаз = кортеж (карта (ламбда x: int (x / 5), (64, 224, 208))) # цвят, който да се използва за изчертаване на грешката с неопикселите |
| # тюркоаз = (12, 44, 41) # което е точно горното тюркоазено коментирано над това |
| error_width_per_pixel = 0.5/3# максимална грешка, разделена на броя сегменти между всеки неопиксел |
| defupper_bound_linear_speed_reducer (абсорбция на грешка, тригерна точка, горна граница, най -малка_моторна мощност, най -висока_моторна мощност): |
| глобална base_speed |
| if abs_error> = trigger_point: |
| # 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) / (upper_bound - trigger_point) |
| мощност на двигателя = базова_скорост * (най -малка_моторна_мощност + (1- y) * (най -висока_моторна_мощност - най -малка_моторна_мощност)) |
| връщане на моторната мощност |
| иначе: |
| връщане на базовата_скорост * най -високата_моторна_мощност |
| run = False |
| предишна_грешка = 0 |
| общо_време = 0.0 |
| общо_сметки = 0 |
| whileTrue: |
| # ако е натиснат бутон а, започнете да следвате |
| ако button_a.is_pressed (): |
| run = True |
| # но ако е натиснат бутон b, спрете последователя на реда |
| ако button_b.is_pressed (): |
| run = False |
| интеграл = 0,0 |
| предишна_грешка = 0.0 |
| display.scroll ('{} - {}'. формат (total_time, total_counts), delay = 100, wait = False) |
| общо_време = 0.0 |
| общо_сметки = 0 |
| pixels_off () |
| Спри се() |
| sleep_ms (500) |
| ако изпълнението е True: |
| # прочетете линейните сензори |
| start_time = ticks_us () |
| # проверете дали сме актуализирали Kp/Kd печалбите с дистанционно |
| опитвам: |
| Kp, Ki, Kd, trigger_point, min_speed_percent = ustruct.unpack ('fffff', radio.receive_bytes ()) |
| set_eyes () |
| с изключение наTypeError: |
| пропуск |
| надясно, наляво = сензор за четене (LINE_SENSOR, ДВЕТЕ) |
| # ред е вляво, когато позиция <0,5 |
| # ред е вдясно, когато позиция> 0,5 |
| # ред е в средата, когато позиция = 0,5 |
| # това е средно претеглена аритметична стойност |
| опитвам: |
| позиция = дясно /плаващо (ляво + дясно) |
| с изключение на ZeroDivisionError: |
| позиция = 0,5 |
| ако позиция == 0: позиция = 0.001 |
| ако позиция == 1: позиция = 0,999 |
| # използвайте PD контролер |
| грешка = позиция - зададена точка |
| интеграл += грешка |
| корекция = Kp * грешка + Ki * интеграл + Kd * (грешка - предишна_грешка) |
| previous_error = грешка |
| # изчислете оборотите на двигателя |
| motor_speed = upper_bound_linear_speed_reducer (abs (грешка), зададена точка * тригерна точка, зададена стойност, min_speed_percent, 1.0) |
| leftMotorSpeed = скорост на мотора + корекция |
| rightMotorSpeed = скорост на мотора - корекция |
| # запалете неопикселите, за да покажете в каква посока трябва да върви GiggleBot |
| ако run_neopixels еTrueand 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- (грешка_ширина_на_пиксел * i -abs (грешка)) / грешка_ширина_на_пиксел |
| # осветява текущия пиксел |
| ако грешка <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 |
| ако rightMotorSpeed> 100: |
| rightMotorSpeed = 100 |
| leftMotorSpeed = leftMotorSpeed - rightMotorSpeed +100 |
| ако е оставенMotorSpeed <-100: |
| leftMotorSpeed = -100 |
| ако rightMotorSpeed <-100: |
| rightMotorSpeed = -100 |
| # задействайте двигателите |
| set_speed (leftMotorSpeed, rightMotorSpeed) |
| задвижване () |
| # печат ((грешка, скорост на двигателя)) |
| с изключение: |
| # в случай, че попаднем в някакъв непоправим проблем |
| пропуск |
| # и поддържайте честотата на контура |
| end_time = ticks_us () |
| delay_diff = (end_time - start_time) /1000 |
| общо_време += забавяне_диф |
| общо_сметки += 1 |
| if1.0/ update_rate - delay_diff> 0: |
| сън (1.0/ update_rate - delay_diff) |
вижте rawgigglebot_line_follower_tuner.py, хоствано с ❤ от GitHub
Стъпка 4: Настройка на тунера (дистанционно)
Следващото нещо, което трябва да направим, е да прехвърлим скрипта за изпълнение + към втория BBC micro: bit. Този втори micro: bit ще действа като дистанционно към GiggleBot, което ще се използва за настройка на следните параметри:
- Kp = пропорционално усилване за PID контролера.
- Ki = интегрална печалба за PID контролера.
- Kd = деривативно усилване за PID контролера.
- trigger_point = точката, изразена в проценти между минималната и максималната скорост на GiggleBot, където скоростта започва да се намалява линейно, докато достигне минималната скорост.
- min_speed_percent = минималната скорост, изразена в проценти от максималната скорост.
Останалите 2 променливи, които могат да бъдат настроени, са директно кодирани в скрипта, който се намира на GiggleBot: update_rate и base_speed, който представлява максималната скорост. Както е описано в документацията, максималната скорост, която може да бъде зададена за GiggleBot, е 100, което също е стойността по подразбиране за нашия GiggleBot.
Забележка: В следния скрипт може да липсват интервали и това изглежда се дължи на някакъв проблем при показването на GitHub Gists. Щракнете върху същността, за да ви отведе до страницата на GitHub, където можете да копирате и поставите кода.
GiggleBot Remote PID Line Follower Tuner (изисква другата част) - xjfls23
| от внос на microbit* |
| от utime import 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 ('{} - {}'. format (currentSetting, печалби [int (currentSetting /2)]), забавяне = 100, чакане = False) |
| radio.on () |
| showMenu () |
| whileTrue: |
| updated = False |
| ако button_a.is_pressed (): |
| currentSetting = (currentSetting +1) % (2*5) |
| актуализиран = Вярно |
| ако 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', *печалби)) |
| актуализиран = Вярно |
| ако е актуализиран: |
| showMenu () |
| sleep_ms (200) |
вижте rawgigglebot_line_follower_configurator.py хоствано с ❤ от GitHub
Стъпка 5: Настройване на GiggleBot
Поставете GiggleBot на пистата, включете го и го оставете да работи. Междувременно ще трябва постоянно да го връщате на пистата и да настройвате печалбите/параметрите с другия BBC micro: bit, който държите в ръката си.
За да стартирате GiggleBot, натиснете бутон A на BBC micro: bit на GiggleBot и за да го спрете и по този начин да нулирате състоянието му, натиснете бутона B.
На дистанционния BBC micro: bit натискането на бутон А ще ви преведе през всяка опция в менюто му, а бутон B увеличава/намалява съответната стойност. Това е все едно да настроите часовника на таблото на стара кола. Опциите са следните:
- Опциите 0-1 са за Kp печалба.
- 2-3 опции са за печалбата Ki.
- 4-5 опции са за Kd печалба.
- 6-7 опции са за задаване на зададената стойност за момента, в който двигателите започнат да се забавят.
- 8-9 опции са за настройка на минималната скорост.
Имайте предвид, че четните числа в менюто са за увеличаване на съответните стойности, а за нечетните е точно обратното.
Също така, когато натиснете бутон B на BBC micro: bit на GiggleBot, ще видите на екрана, направен от Neopixel, броя на изминалите милисекунди от последното нулиране и броя на циклите, през които роботът е преминал - с тези 2 можете да изчислите скоростта на актуализиране на робота.
И накрая и най -важното, измислих 2 настройки за GiggleBot. Единият от тях е за това, когато светодиодите на Neopixel са изключени, а другият е за случаите, когато е друго. Светодиодите Neopixel се използват, за да покажат в коя посока е натрупана грешката.
1 -ви набор от настройки на параметрите (с изключени NeoPixel светодиоди)
- Kp = 32,0
- Ki = 0,5
- Kd = 80,0
- trigger_setpoint = 0,3 (което е 30%)
- min_speed_percent = 0.2 (което е 20%)
- base_speed = 100 (известен още като максимална скорост)
- update_rate = 70 (работи при 70Hz)
2 -ри набор от настройки на параметрите (с включени NeoPixel светодиоди)
- Kp = 25,0
- Ki = 0,5
- Kd = 35,0
- trigger_setpoint = 0,3 (което е 30%)
- min_speed_percent = 0.3 (което е 30%)
- base_speed = 70 (известен още като максимална скорост)
- update_rate = 50 (работи при 50Hz)
- Също така променливата run_neopixels трябва да бъде зададена на True в скрипта, който се зарежда в BBC micro: bit на GiggleBot. Това ще накара светодиодите NeoPixel да мигат по такъв начин, че да показват в коя посока се натрупва грешката.
Стъпка 6: GiggleBot работи с изключени NeoPixels
Това е пример за стартиране на GiggleBot с първите параметри за настройка, намерени в предишната стъпка. В този пример светодиодите на NeoPixel са изключени.
Стъпка 7: GiggleBot работи с включени неопиксели
Това е пример за стартиране на GiggleBot с втория набор от параметри за настройка, намерен в стъпка 5. В този пример са включени светодиодите NeoPixel.
Забележете как в този пример GiggleBot има по -трудно време да следва линията - това е така, защото светодиодите на Neopixel "изяждат" процесорното време на BBC micro: bit. Ето защо трябваше да намалим скоростта на актуализиране от 70 на 50.
Препоръчано:
PID Line Follower Atmega328P: 4 стъпки
PID Line Follower Atmega328P: ВЪВЕДЕНИЕ Тази инструкция е за създаване на ефективен и надежден Line Follower с PID (пропорционално-интегрално-производно) управление (математическо), работещо в мозъка му (Atmega328P). Линейният последовател е автономен робот, който следва или
Arduino Line Follower Wallrides Класна бяла дъска: 8 стъпки (със снимки)
Arduino Line Follower Wallrides Бяла дъска за класната стая: Следването на линията на земята е твърде скучно! Опитахме се да погледнем под различен ъгъл на последователите на линиите и да ги пренесем в друга равнина - към училищната дъска. Вижте какво се получи от това
Част 3: GPIO: ARM Монтаж: Line Follower: TI-RSLK: 6 стъпки
Част 3: GPIO: ARM Монтаж: Line Follower: TI-RSLK: Здравейте. Това е следващата вноска, в която продължаваме да използваме ARM монтаж (вместо език от по-високо ниво). Вдъхновението за този Instructable е Lab 6 от Комплектът за обучение по роботика на Texas Instruments, или TI-RSLK. Ще използваме микрофона
GoPiGo3 Line Follower: 8 стъпки
GoPiGo3 Line Follower: В този урок ние вземаме последовател на линия и го използваме на GoPiGo3, за да го накараме да следва черна линия
GiggleBot Line Follower Използване на Python: 5 стъпки
GiggleBot Line Follower Използване на Python: Този път ние програмираме в MicroPython Dexter Industries GiggleBot да следва черна линия, използвайки своя вграден сензор за последователен ред. GiggleBot трябва да бъде сдвоен с BBC micro: bit, за да може да бъдат контролирани по подходящ начин. Ако