Настройка на GiggleBot Line Follower - Разширени: 7 стъпки

2024 Автор: John Day | [email protected]. Последно модифициран: 2024-01-30 07:52

В тази много кратка инструкция ще настроите своя собствен GiggleBot да следва черна линия. В този друг урок GiggleBot Line Follower ние кодирахме строго настройващите стойности, за да работят според този сценарий. Може да искате да го накарате да се държи по -добре, като измислите други печалби.

В този урок ние ви показваме 2 скрипта, които могат да се заредят на различни BBC micro: бита, така че един от тях да бъде поставен в GiggleBot, а с другия, двата бутона се използват за преминаване през меню и настройване на различни параметри. Изпращането на тези актуализирани параметри се извършва по радиото.

Стъпка 1: Необходими компоненти

Ще ви трябва следното:

1. Робот GiggleBot за micro: bit.
2. x3 AA батерии
3. x2 BBC micro: bits - единият за GiggleBot, а другият действа като дистанционно за настройка на параметрите.
4. Батерия за 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, което ще се използва за настройка на следните параметри:

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 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 увеличава/намалява съответната стойност. Това е все едно да настроите часовника на таблото на стара кола. Опциите са следните:

1. Опциите 0-1 са за Kp печалба.
2. 2-3 опции са за печалбата Ki.
3. 4-5 опции са за Kd печалба.
4. 6-7 опции са за задаване на зададената стойност за момента, в който двигателите започнат да се забавят.
5. 8-9 опции са за настройка на минималната скорост.

Имайте предвид, че четните числа в менюто са за увеличаване на съответните стойности, а за нечетните е точно обратното.

Също така, когато натиснете бутон B на BBC micro: bit на GiggleBot, ще видите на екрана, направен от Neopixel, броя на изминалите милисекунди от последното нулиране и броя на циклите, през които роботът е преминал - с тези 2 можете да изчислите скоростта на актуализиране на робота.

И накрая и най -важното, измислих 2 настройки за GiggleBot. Единият от тях е за това, когато светодиодите на Neopixel са изключени, а другият е за случаите, когато е друго. Светодиодите Neopixel се използват, за да покажат в коя посока е натрупана грешката.

1 -ви набор от настройки на параметрите (с изключени 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 -ри набор от настройки на параметрите (с включени 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 micro: bit на GiggleBot. Това ще накара светодиодите NeoPixel да мигат по такъв начин, че да показват в коя посока се натрупва грешката.

Стъпка 6: GiggleBot работи с изключени NeoPixels

Това е пример за стартиране на GiggleBot с първите параметри за настройка, намерени в предишната стъпка. В този пример светодиодите на NeoPixel са изключени.

Стъпка 7: GiggleBot работи с включени неопиксели

Това е пример за стартиране на GiggleBot с втория набор от параметри за настройка, намерен в стъпка 5. В този пример са включени светодиодите NeoPixel.

Забележете как в този пример GiggleBot има по -трудно време да следва линията - това е така, защото светодиодите на Neopixel "изяждат" процесорното време на BBC micro: bit. Ето защо трябваше да намалим скоростта на актуализиране от 70 на 50.