Стъпково меню за контрол на скоростта, управлявано за Arduino: 6 стъпки

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

Тази библиотека SpeedStepper е пренаписване на библиотеката AccelStepper, за да позволи контрол на скоростта на стъпковия двигател. Библиотеката SpeedStepper ви позволява да променяте зададената скорост на двигателя и след това ускорява/забавя до новата зададена скорост, използвайки същия алгоритъм като библиотеката AccelStepper. Библиотеката SpeedStepper също ви позволява да зададете граници плюс и минус и „начална“позиция. Има команда goHome за връщане в началната позиция.

Ограничения: Библиотеката SpeedStepper управлява само изходи за посока и стъпка и затова трябва да бъде свързана към драйвер на мотор, като Easy Driver, за да задвижва действието на стъпковия мотор. Библиотеката AccelStepper предоставя повече опции за шофиране, които могат да бъдат копирани в тази библиотека, ако е необходимо.

Предоставени са три примерни скици, всяка от които може да се изпълнява без двигател или шофьор на мотор. скицата speedStepperPlot издава примерни команди за скорост и командата goHome и генерира график на получената скорост и позиция. Скицата speedStepperSetup предоставя настройка, управлявана от менюто, за да зададе дома и ограниченията на двигателя, а след това да стартира двигателя и да регулира скоростта нагоре и надолу и goHome да завърши. Скицата на speedStepperProfile показва пример за настройка и изпълнение на профил на скорост.

Докато библиотеката AccelStepper осигурява добър контрол на позицията, беше необходим контрол на скоростта за прототипната сонда за топене на лед за събиране на биологични проби в Европа. Ето видео на по -ранна версия на прототипа, която използваше тегло вместо двигател. Редакция 1.1 добави профили на скоростта, след като потребител поиска средство за контрол на профила на скоростта на помпата.

Тази библиотека работи на Arduino Uno и Mega2560, но за прототипа е използвана по -голямата памет / по -бърз процесор SparkFun Redboard Turbo.

Тази инструкция е достъпна и онлайн в библиотеката Stepper Speed Control за Arduino

Консумативи

За да стартирате примерните скици, са необходими само Arduino UNO или Mega2560 и софтуерните библиотеки

За стенд тестване на библиотеката беше използван SparkFun Redboard Turbo с Easy Driver, 200 стъпки/об., 12V 350mA стъпков двигател и 12 DC захранване 2A или по -голямо, напр. https://www.sparkfun.com/products/14934. USB A към микро кабел USB към TTL сериен кабел Arduino IDE V1.8.9 и компютър, на който да се изпълнява. Библиотека на SpeedStepperpfodParser библиотека за nonBlockingInput и pfodBufferedStream класове millisDelay библиотека за неблокиращи закъснения

Стъпка 1: Библиотечни функции

Библиотеката SpeedStepper работи със стъпков двигател, ограничен от граници, зададени от библиотеката. Вижте файла SpeedStepper.h за различните налични библиотечни методи. Ето очертание на логиката зад тях.

Позицията на стъпката се проследява чрез преброяване на броя стъпки (импулси). Библиотеката ограничава позицията да бъде между позициите setPlusLimit (int32_t) и setMinusLimit (int32_t). Ограничението плюс винаги е> = 0, а границата на минус винаги е <= 0. При стартиране позицията на двигателя е 0 (начало) и границите се задават на много големи +/- числа (около +/- 1e9 стъпки). setAcceleration (float) задава колко бързо двигателят ще променя скоростта нагоре или надолу. Когато двигателят наближи границата плюс или минус, той ще се забавя с тази скорост, докато не спре до границата. При стартиране ускорението е настроено на 1,0 стъпки/сек/сек. Настройката за ускорение винаги е число +ve. Знакът на настройката setSpeed (float) задава посоката на движение на двигателя.

setSpeed (float) задава скоростта за ускоряване / забавяне на двигателя до, спрямо текущата му скорост. Скоростта, която може да бъде зададена чрез setSpeed (float) е ограничена, в абсолютна стойност, от настройките, setMaxSpeed (float), по подразбиране 1000 стъпки/sec и setMinSpeed (float), по подразбиране 0.003 стъпки/sec. Тези настройки по подразбиране също са абсолютните ограничения на скоростта, които библиотеката ще приеме за setMaxSpeed () и setMinSpeed (). Ако искате да зададете максимална скорост> 1000 стъпки/сек, ще трябва да редактирате първия ред във файла SpeedStepper.cpp, за да промените maxMaxSpeed (1000) на максималната скорост, която искате. На практика максималната скорост също е ограничена от времето между извикванията към метода run () на библиотеката. За 1000 стъпки / сек методът run () трябва да се извиква поне на всеки 1 mS. Вижте раздела Латентност по -долу.

Опитът да зададете скорост по -малка от минималната скорост ще доведе до спиране на двигателя. Всеки от тези сеттери има съответния гетер, вижте файла SpeedStepper.h. За скорост getSetSpeed () връща зададената от вас скорост чрез setSpeed (), докато getSpeed () връща текущата скорост на двигателя, която варира при ускоряване/забавяне до зададената от вас скорост. Ако двигателят не върви в посоката, която мислите за +ve, можете да се обадите на invertDirectionLogic (), за да смените посоката, в която двигателят се движи за +ve скорости.

getCurrentPosition () връща текущата позиция на двигателя в сравнение с 'home' (0). Можете да отмените текущата позиция на двигателя setCurrentPosition (int32_t). Новата позиция е ограничена да бъде в рамките на зададените граници плюс/минус.

Първоначално двигателят е спрян в позиция 0. Извикването на setSpeed (50.0) ще го накара да ускори в посока +ve до максимална скорост от 50 стъпки/мин. Извикването на hardStop () незабавно ще спре двигателя, където се намира. От друга страна, извикването на метода stop () ще настрои скоростта на нула и ще забави двигателя до спиране. Извикването stopAndSetHome () ще спре незабавно двигателя и ще зададе позицията му на 0. Стойностите на границите плюс/минус не се променят, но сега се препращат към тази нова позиция 0 (начало). Извикването на goHome () ще върне стъпката в тази позиция 0 (начална) и ще спре. Извикването на setSpeed () ще отмени прибирането.

Библиотеката SpeedStepper също така осигурява контрол на профила на скоростта чрез методите setProfile (SpeedProfileStruct* profileArray, size_t arrayLen), startProfile (), stopProfile (), за прекъсване на работещ профил и isProfileRunning (). Вижте примерната скица на speedStepperProfile.

Стъпка 2: Изпълнение на примера SpeedStepperPlot без двигател

Инсталирайте Arduino IDE V1.8.9 Изтеглете и инсталирайте библиотеката SpeedStepper Запазете SpeedStepper.zip и след това използвайте елемента от менюто на Arduino IDE Sketch → Include Library → Add. ZIP library за импортиране на библиотеката Изтеглете и инсталирайте и библиотеката millisDelay

Отворете примерната скица на Примери → SpeedStepper → speedStepperPlot (Рестартирайте IDE, ако е необходимо). Тази скица е конфигурирана да работи със сериен, напр. UNO и Mega и т.н. За работа с SparkFun Redboard Turbo вижте по -долу.

Не е необходима платка на водача или стъпков двигател за изпълнение на този пример. Тези примери използват D6 и D7 като изход. Можете да промените изходните щифтове на всеки цифров изход, като промените настройките STEP_PIN и DIR_PIN близо до горната част на скицата.

Качете скицата на борда и след това отворете Инструменти → Сериен плотер на 115200 бода, за да покажете графиката на скоростта (ЧЕРВЕНО) и позицията (СИНЯ) Ограничението на плюс е зададено на 360, което кара скоростта да се покачи до нула от около 100 точки по оста x. Минималната граница е -510. Позицията спира на ~ -390, защото скоростта е поискана на 0.0. В точката 380 на оста x се издава goHome cmd, който връща стъпката в позиция нула.

Тази скица speedStepperPlot използва millisDelays за времево превключване между различни скорости и ускорения. В много случаи използването на SpeedStepperProfile, както в следващия пример, е по -просто.

Стъпка 3: Изпълнение на примера SpeedStepperProfile без двигател

Отворете примерната скица на Примери → SpeedStepper → speedStepperPlot, тази скица създава горния график, използвайки сериен плотер Arduino и е пример за изпълнение на предписан профил на скорост, например, ако работите с помпа.

Степърните профили за скорост са съставени от масив от SpeedProfileStruct, който е дефиниран във файла SpeedStepper.h.

struct SpeedProfileStruct {

скорост на плаване; // целевата скорост в края на тази стъпка unsigned long deltaTms; // времето за ускоряване от текущата скорост (в началото на тази стъпка) до целевата скорост};

Определете масив от SpeedProfileStruct, съдържащ целевата скорост за всяка стъпка и времето, deltaTms, в mS, за да достигнете тази целева скорост от предишната целева скорост. Ако deltaTms е нула или много малка, скоростта ще скочи веднага до новата целева скорост. В противен случай ще се изчисли необходимото ускорение setAcceleration () ще бъде извикано, последвано от извикване към setSpeed () за новата целева скорост. Във всички случаи профилът ще бъде ограничен от съществуващите граници на позицията плюс и минус и настройките за максимална/минимална скорост. Ако искате да задържите скорост, просто повторете предишната скорост с времето, в което искате да я задържите. Тъй като новата целева скорост е същата като текущата скорост, изчисленото ускорение ще бъде нула и няма промяна в скоростта.

Този масив SpeedProfileStruct създава горния график

const SpeedProfileStruct профил = {{0, 0}, // незабавно спиране, ако още не е спряно {0, 1000}, // задържане на нула за 1сек {-50, 0}, // скок до -50 {-200, 2000}, // рампа до -200 {-200, 6000}, // задръжте при -200 за 6 секунди {-50, 2000}, // намалете до -50 {0, 0}, // // спрете незабавно {0, 1500}, // задръжте нула за 1.5сек, 2000}, // рампа до 50 {0, 0}, // // спиране безпроблемно {0, 1000} // задържане на нула // за изчертаване на изход}; const size_t PROFILE_LEN = sizeof (профил) / sizeof (SpeedProfileStruct); // изчисляваме размера на профилния масив

Профилът се задава чрез извикване на setProfile (SpeedProfileStruct* profileArray, size_t arrayLen) напр. stepper.setProfile (профил, PROFILE_LEN);

След като профилът е настроен, извикайте startProfile (), за да започнете да го изпълнявате от текущата скорост на двигателя (обикновено ще започнете от спрян). В края на профила моторът просто ще продължи да работи с последната целева скорост. Методът isProfileRunning () може да бъде извикан, за да се види дали профилът все още работи. Ако искате да спрете профила по -рано, можете да извикате stopProfile (), който ще изостави профила и ще спре двигателя.

Стъпка 4: Изпълнение на примера SpeedStepperSetup без двигател

Примерната скица е проектирана като основа за вашето собствено приложение на стъпков двигател. Той осигурява интерфейс, управляван от менюто, който ви позволява да преминете към двигателя до началното му положение, ако още не е там и след това по желание нулирате границите плюс и минус и след това да стартирате двигателя в този диапазон. Менюто „бягане“ви позволява да увеличавате и намалявате скоростта, да замразите с текущата скорост, да спрете и също да се върнете у дома.

Тази скица илюстрира редица софтуерни функции, които поддържат цикъла () отзивчив, така че можете да добавите свои собствени сензорни входове за управление на стъпката. Необходими са много усилия, за да се избегнат забавяния, които биха попречили на контрола на скоростта. (Вижте Закъсненията са зли)

Инсталирайте библиотеките, използвани за изпълнение на SpeedStepperPlot, по -горе, а след това също инсталирайте библиотеката pfodParser. Библиотеката pfodParser доставя класовете NonBlockingInput и pfodBufferedStream, които се използват за обработка на потребителския вход и изхода на менюто, като блокират цикъла () от изпълнението.

Отворете Примерите → SpeedStepper → speedSpeedSetup пример. Тази скица е конфигурирана да работи със сериен, напр. UNO и Mega и т.н. За работа с SparkFun Redboard Turbo вижте по -долу.

Не е необходима платка на водача или стъпков двигател за изпълнение на този пример. Тези примери използват D6 и D7 като изход. Можете да промените изходните щифтове на всеки цифров изход, като промените настройките STEP_PIN и DIR_PIN близо до горната част на скицата. Качете скицата на дъската и след това отворете Инструменти → Сериен монитор на 115200, за да видите менюто НАСТРОЙКА.

НАСТРОЙКА pos: 0 sp: 0.00 +Lim: 500000 -Lim: -500 LATENCY: stepper: 492uS loop: 0uS p -set Home l -задайте граници h -goHome r -run>

Когато скицата се изпълнява, текущата позиция на стъпката се приема като „начална“(0) позиция. Ако трябва да позиционирате отново стъпката в нейната истинска „начална“позиция, въведете командата p, за да се покаже менюто SET HOME

SET HOME pos: 0 sp: 0.00 + Lim: 1073741808 -Lim: -1073741808 LATENCY: stepper: 752uS loop: 3852uS x -setHome тук и изход + -Forward - -Reverse s -swap Forward/Reverse -hardStop >

Както можете да видите, ограниченията, кодирани в скицата, са премахнати, така че можете да позиционирате отново стъпката навсякъде. Трябва да внимавате да не го карате извън физическите граници или може да нарушите нещо.

Използвайте + cmd, за да започнете да премествате стъпката напред, ако откриете, че се движи в грешна посока, въведете команда или просто празен ред, за да я спрете и след това използвайте командата s, за да размените посоката на напред. Трябва да актуализирате скицата, за да включите извикване на invertDirectionLogic () в настройката, за да поправите това за следващото изпълнение.

Използвайте + / - cmds, за да позиционирате стъпката до правилната нулева позиция. Двигателят стартира бавно и след това увеличава скоростта, докато продължава, просто използвайте и празен ред, за да го спрете. Максималната скорост за това и менюто с ограничения се задава от MAX_SETUP_SPEED в горната част на setupMenus.cpp.

След като двигателят е позициониран в начална позиция, използвайте x cmd, за да зададете отново текущата позиция като 0 и да се върнете в менюто SETUP.

Ако трябва да зададете границите, обикновено само при първоначалната настройка, използвайте l cmd, за да влезете в менюто SET LIMITS

SET LIMITS pos: 0 sp: 0.00 + Lim: 1073741808 -Lim: -1073741808 LATENCY: stepper: 944uS loop: 5796uS l -setLimit here + -Forward - -Reverse h -goHome x -exit -hardStop>

Използвайте + cmd за по -напред към ограничението плюс и след това използвайте l cmd, за да го зададете като ограничение за плюс. След това командата h може да се използва за връщане към 0, а - cmd - за придвижване, ако се придвижва до позицията на двигателя на границата минус. Отново използвайте l cmd, за да зададете границата на минус. Забележете позициите на границите плюс и минус и актуализирайте инструкциите setPlusLimit и setMinusLimit на метода setup () с тези стойности.

Когато ограниченията са зададени, използвайте x cmd, за да се върнете в менюто SETUP и след това можете да използвате r cmd, за да отворите менюто RUN

RUN MENU pos: 0 sp: 3.31 + Lim: 500000 -Lim: -500 LATENCY: stepper: 944uS loop: 5796uS + -Speed up - -Speed down h -goHome. -hardStop-скорост на замръзване> +pos: 4 sp: 9.49 +Lim: 500000 -Lim: -500 LATENCY: stepper: 792uS loop: 5664uS pos: 42 sp: 29.15 +Lim: 500000 -Lim: -500 LATENCY: stepper: 792uS контур: 5664uS pos: 120 sp: 49.09 +Lim: 500000 -Lim: -500 LATENCY: stepper: 792uS loop: 5664uS pos: 238 sp: 69.06 +Lim: 500000 -Lim: -500 LATENCY: stepper: 792uS loop: 5664uS

+ Cmd започва да се ускорява в посока напред и отпечатва позицията и скоростта на всеки 2 секунди. Когато двигателят достигне желаната скорост, можете да спрете ускорението с всеки друг клавиш (или празен вход). Можете да намалите скоростта, като използвате - cmd надолу за спиране. Ако бъде спряно - cmd ще се ускори обратно.

Това меню RUN осигурява ръчно управление на вашия проект. За автоматично управление ще трябва да добавите някои други сензори.

Стъпка 5: Латентност

Управлението на стъпковия двигател зависи от софтуера, командващ всяка стъпка. За да поддържа зададената скорост, вашата скица трябва да извиква метода stepper.run () достатъчно често, за да задейства следващата стъпка в точното време за текущата скорост. За управление чрез сензори трябва да можете бързо да обработвате нови измервания. Разпечатването на позиция/скорост включва две измервания на ЛАТЕНЦИЯТА, за да можете да проверите дали вашата скица е достатъчно бърза.

Стъпково закъснение (pfodBufferedStream)

Стъпковата латентност измерва максималното забавяне между последователни извиквания към метода stepper.run (). За да работи стъпковият двигател с 1000 стъпки в секунда, латентността на стъпковия двигател трябва да бъде по -малка от 1000uS (1mS). Първата версия на тази скица имаше латентност от много милисекунди. За да се преодолеят тези допълнителни извиквания към метода runStepper () (който извиква stepper.run ()), където се добавя чрез кода. Това не реши напълно проблема, защото менюто и изходните отпечатъци блокираха скицата, след като малкият сериен Tx буфер беше пълен. За да се избегне това блокиране, pfodBufferedStream от библиотеката pfodParser беше използван за добавяне на 360 -байтов изходен буфер за печат, в който операторите за печат могат бързо да записват. Тогава pfodBufferedStream освобождава байтовете при скорост на предаване, посочена в този случай 115200. pfodBufferedStream трябва да има опция или да блокира, когато буферът е пълен, или просто да отхвърли символите за препълване. Тук е настроено да изпуска всички допълнителни символи, когато буферът е пълен, така че скицата да не бъде блокирана, чакаща Serial да изпрати символи.

Латентност на цикъла (NonBlockingInput)

Латентността на цикъла измерва максималното забавяне между последователните извиквания на метода loop (). Това задава колко бързо можете да обработвате нови измервания на сензора и да регулирате зададената скорост на двигателя. Колко бързо трябва да бъде, зависи от това какво се опитвате да контролирате.

Закъсненията, дължащи се на изявленията за печат, бяха премахнати с помощта на pfodBufferedStream по -горе, но за да обработите въведеното от потребителя, трябва да вземете само първия знак на въведеното и да игнорирате останалата част от реда. Класът NonBlockingInput в библиотеката на pfodParer се използва за връщане на ненулева символна стойност, когато има въвеждане, използвайки readInput (), и за изчистване и изхвърляне на следните символи, използвайки clearInput (), докато не се получат символи за 10 mS без блокиране на цикъла ()

Разбира се, латентността на цикъла ще се увеличи с допълнителния код, който добавяте, за да прочетете сензорите и да изчислите новата зададена скорост. Много сензорни библиотеки правят сортиране на просто използване на забавяне (..) между стартиране на измерване и извличане на резултата. Ще трябва да пренапишете тези библиотеки, за да използвате millisDelay вместо това, за да вземете измерването след подходящо неблокиращо забавяне.

Стъпка 6: Стартирайте SpeedStepperSetup със стъпков двигател и SparkFun Redboard Turbo

За да стартирате скицата SpeedStepperSetup реално, ще ви е необходим стъпков двигател, драйвер и захранване и в този пример SparkFun Redboard Turbo.

Схемата за свързване по -горе (pdf версия) показва връзките. В скицата SpeedStepperSetup променете дефиницията SERIAL на #define SERIAL Serial1

Стъпков двигател, захранване, драйвер и защита

Има много видове и размери на стъпкови двигатели. Тук за тестване се използва двумотов 12V 350mA стъпков двигател. За захранване на този степер се нуждаете от захранване от 12V или повече и по -голямо от 350mA.

Тази библиотека предоставя само посока и стъпков изход, така че имате нужда от драйвер, който да взаимодейства със стъпковия двигател. Easy Driver и Big Easy Driver контролират тока към бобините на двигателя, така че можете да използвате безопасно захранване с по -високо напрежение, например като използвате 6V захранване за 3.3V мотор. Easy Driver може да захранва между 150mA/намотка и 700mA/намотка. За по -високи токове Big Easy Driver може да захранва до 2A на бобина. Прочетете често задаваните въпроси в долната част на страницата Easy Drive.

Тези примери използват D6 и D7 като стъпка и посока. Можете да промените изходните щифтове на всеки цифров изход, като промените настройките STEP_PIN и DIR_PIN близо до горната част на скицата.

Програмиране на Sparkfun Redboard Turbo

Програмирането на Redboard Turbo е проблематично. Ако не успее да програмира, първо натиснете бутона за нулиране веднъж и отново изберете COM порта в менюто на Arduino Tools и опитайте отново. Ако това не работи, натиснете двукратно бутона за нулиране и опитайте отново.

Свързване на Easy Driver

Два стъпкови двигателя с бобина имат 4 проводника. Използвайте мултицет, за да намерите двойките, които се свързват към всяка намотка и след това свържете една бобина към клемите на Easy Driver A, а другата намотка към терминала B. Няма значение по какъв начин ги свързвате, защото можете да използвате s cmd в менюто за настройка, за да размените посоката на движение.

Захранването на двигателя е свързано към M+ и GND Задайте логическото ниво на платката с 3/5V връзка. Съкратете връзката заедно за 3.3V микропроцесорни изходи, като SparkFun Redboard Turbo (ако го оставите отворен, той е подходящ за 5V цифрови сигнали, например UNO, Mega) Свържете GND, STEP, DIR щифтовете към микропроцесорния GND и стъпката и dir изходни изводи. Не са необходими други връзки за задвижване на двигателя.

USB към TTL сериен кабел

Когато премествате скицата на SpeedStepperSetup от Uno/Mega към Redboard Turbo, можете наивно просто да замените #define SERIAL Serial с #define SERIAL SerialUSB, за да отговаря на серийната връзка на Redboard Turbo USB, но ще откриете, че получената лазерна стъпка е около 10 mS. Това е 10 пъти по -бавно от това за UNO. Това се дължи на начина, по който процесорът Redboard се справя с USB връзката. За да преодолеете това, свържете USB към TTL сериен кабел към D0/D1 и задайте#define SERIAL Serial1, за да използвате хардуерната серийна връзка за управление на стъпковия двигател. Използването на Serial1 дава LATENCY: stepper: 345uS loop: 2016uS, което е 3 пъти по -бързо от UNO за лазерността на stepper и loop

Терминална програма

Серийният монитор на Arduino е малко по -труден за използване за управление на стъпковия двигател, тъй като трябва да въведете char в реда cmd и след това да натиснете Enter, за да го изпратите. По -бързо и по -отзивчиво средство е да отворите терминален прозорец, TeraTerm за компютър (или CoolTerm Mac), свързан към COM към порта USB към TTL кабел. След това в този прозорец натискането на клавиш cmd го изпраща незабавно. Натискането на Enter просто изпраща празен ред.

Настройка на обхвата на скоростта на двигателя

Както е свързано по -горе, Easy Drive е конфигуриран за 1/8 стъпки, така че 1000 стъпки/сек ще завъртят двигателя на 1000/8/200 стъпка/оборот = 0,625 оборота в секунда или максимум 37,5 об/мин. Чрез промяна на входовете на MS1/MS2 можете да превключвате между 1/8, ¼, ½ и пълни стъпки. За пълни стъпки свържете както MS1, така и MS2 към GND. Това ще позволи скорости до 300 оборота в минута. Изборът на подходящите настройки на MS1/MS2 ви позволява да регулирате инсталираното предавателно отношение между двигателя и задвижваната част.

Хардуерна защита

Докато библиотеката SpeedStepper ви позволява да зададете ограничения на позицията за движението на двигателя, прихващането на позицията се извършва чрез преброяване на стъпките, изведени от софтуера. Ако двигателят спре, т.е. въртящият момент е недостатъчен за задвижване на двигателя на следващата стъпка, тогава позицията на софтуера няма да бъде синхронизирана с положението на двигателя. Тогава, когато използвате командата 'goHome', двигателят ще преодолее началната позиция. За да предотвратите повреда на хардуера, трябва да поставите крайните превключватели на твърдите граници, за да изключите захранването на двигателя

Задаване на ограничение на тока на двигателя

Първо го настройте на най -ниската настройка на потенциометъра. т.е. напрежението при TP1 е минимално. Потенциометърът е деликатен, така че не насилвайте потенциометъра покрай механичните спирачки. Настройте бавно постоянната скорост на двигателя, след това бавно завъртете потенциометъра, докато двигателят не прескача или изтръгва между стъпките.

Заключение

Този проект показва как да използвате библиотеката SpeedStepper в практическо приложение. Докато библиотеката AccelStepper осигурява добър контрол на позицията, контролът на скоростта беше необходим за прототипната сонда за топене на лед за събиране на биологични проби в Европа, така че библиотеката на AccelStepper беше пренаписана, за да осигури контрол на скоростта с крайни граници и функция goHome.