- Избор на части за самобалансиращ се робот
- 3D печат и сглобяване на нашия самобалансиращ се робот
- Електрическа схема
- Код на самобалансиращ се робот
- Работа на Arduino Self Balancing Robot
След като бях вдъхновен от RYNO мотори и други самобалансиращи скутери от Segway, винаги съм искал да създам нещо свое Arduino Segway Robot. Мислейки за известно време, реших да изградя самостоятелно балансиращ робот, използвайки Arduino. По този начин бих могъл да разбера основната концепция зад всички тези скутери и също така да науча как работи PID алгоритъмът.
След като започнах да изграждам, разбрах, че този бот е малко предизвикателство за изграждане. Има толкова много опции, от които можете да избирате и следователно объркванията започват правилно от избора на двигателите и остават до настройка на PID стойностите. И има толкова много неща, които трябва да вземете предвид като тип батерия, положение на батерията, сцепление на колелото, тип водач на мотора, поддържане на CoG (Център на тежестта) и много други.
Но нека ви го разбия, след като го изградите, ще се съгласите, че не е толкова трудно, колкото звучи. Така че нека си признаем, в този урок ще документирам моя опит в изграждането на самобалансиращ се робот. Може да сте абсолютно начинаещ, който тепърва започва или може да сте кацнали тук след дълго разочарование, че не сте накарали бота си да работи. Това място има за цел да бъде вашата крайна дестинация. Така че нека да започнем……
Избор на части за самобалансиращ се робот
Преди да ви разкажа всички опции за изграждане на бота, позволете ми да изброя елементите, които съм използвал в този самобалансиращ се робот
- Arduino UNO
- Двигатели с постоянен ток с редуктор (жълт цвят) - 2Nos
- L298N Моторен драйвер модул
- MPU6050
- Чифт колела
- 7.4V литиево-йонна батерия
- Свързващи проводници
- 3D отпечатано тяло
Можете да смесите и да изберете за някой от горните компоненти въз основа на наличността, за да направите свой собствен самобалансиращ се робот, просто се уверете, че компонентите отговарят на следните критерии.
Контролер: Контролерът, който използвах тук, е Arduino UNO, защо, защото е просто лесен за използване. Можете също да използвате Arduino Nano или Arduino mini, но бих ви препоръчал да се придържате към UNO, тъй като можем да го програмираме директно без външен хардуер.
Двигатели: Най-добрият избор на двигател, който можете да използвате за самобалансиращ се робот, без съмнение ще бъде Stepper motor. Но за да улесня нещата, използвах мотор с постоянен ток. Да не е задължително да имате степер; ботът работи добре и с тези евтини често предлагани жълти мотори с постоянен ток.
Двигател на двигателя: Ако сте избрали двигатели с постоянен ток като моите, тогава можете да използвате модула на драйвера L298N като мен, или дори L293D трябва да работи добре. Научете повече за управлението на постояннотоков двигател с помощта на L293D и Arduino.
Колела: Не подценявайте тези момчета; Трудно ми беше да разбера, че проблемът е в колелата ми. Затова се уверете, че колелата ви имат добро сцепление с пода, който използвате. Гледайте внимателно, захватът ви никога не трябва да позволява на колелата ви да се плъзгат по пода.
Акселерометър и жироскоп: Най-добрият избор на акселерометър и жироскоп за вашия бот ще бъде MPU6050. Затова не се опитвайте да изградите такъв с нормален акселерометър като ADXL345 или нещо подобно, той просто няма да работи. Ще разберете защо в края на тази статия. Можете също да проверите нашата специална статия за използването на MPU6050 с Arduino.
Батерия: Нуждаем се от възможно най-лека батерия и работното напрежение трябва да бъде повече от 5V, за да можем да захранваме Arduino директно без усилващ модул. Така че идеалният избор ще бъде 7,4V Li-полимерна батерия. Тук, тъй като имах 7.4V литиево-йонна батерия, която е лесно достъпна, я използвах. Но не забравяйте, че Li-po е по-изгоден от Li-ion.
Шаси: Друго място, където не трябва да правите компромиси, е шасито на вашите ботове. Можете да използвате картон, дърво, пластмаса всичко, с което сте добри. Но просто се уверете, че шасито е здраво и не трябва да мърда, когато ботът се опитва да балансира. Проектирах от собствено шаси на Solidworks, като заключих от другите ботове и го отпечатах 3D. Ако имате принтер, можете също да отпечатате дизайна, файловете за дизайн ще бъдат прикачени в предстоящото заглавие.
3D печат и сглобяване на нашия самобалансиращ се робот
Ако сте решили да отпечатате 3D същото шаси, което използвам за изграждане на моя бот, тогава STL файловете могат да бъдат изтеглени от thingiverse. Също така добавих дизайнерските файлове заедно с него, така че можете също да го модифицирате според вашите предпочитания за персонала.
Частите нямат надвиснали структури, така че можете лесно да ги отпечатате без никакви опори и запълване от 25% ще работи добре. Дизайнът е доста прост и всеки основен принтер трябва да може да се справи с него с лекота. Използвах софтуера Cura за нарязване на модела и отпечатах с помощта на моя Tevo Tarantula, настройката е показана по-долу.
Ще трябва да отпечатате част от тялото, както и четири части за монтиране на двигателя. Сглобяването е доста право напред; използвайте 3 мм гайки и болтове, за да закрепите двигателя и платките на място. След сглобяването трябва да изглежда нещо подобно, показано на снимката по-долу.
Действителният дизайн беше планиран с задвижващия модул L298N в долната стойка на Arduino и батерията върху него, както е показано по-горе. Ако следвате същия ред, можете директно да завиете дъската през предоставените отвори и да използвате жичен етикет за Li-po батерията. Тази подредба също трябва да работи, с изключение на супер обикновените колела, които трябваше да сменя по-късно.
В моя бот смених позицията на батерията и Arduino UNO платката за по-лесно програмиране, а също така трябваше да въведа перфектна платка за завършване на връзките. Така че ботът ми не изглеждаше така, както планирах в началния етап. След като завърших тестването на програмирането на окабеляване и всичко, роботът ми с две колела най-накрая изглежда така
Електрическа схема
Създаването на връзки за този базиран на Arduino самобалансиращ се робот е доста просто. Това е самобалансиращ се робот, използващ Arduino и MPU6050, така че ние искаме да свържем MPU6050 с Arduino и да свържем двигателите чрез модула за двигател на двигателя. Цялата настройка се захранва от 7,4V литиево-йонна батерия. Схемата за същото е показана по-долу.
Модулът на драйвера Arduino и L298N Motor се захранва директно през Vin pin и 12V терминал, съответно. Вграденият регулатор на платката Arduino ще преобразува входните 7.4V в 5V и ATmega IC и MPU6050 ще се захранват от него. Двигателите с постоянен ток могат да работят от напрежение 5V до 12V. Но ще свържем положителния проводник 7.4V от батерията към входния терминал 12V на модула на двигателя. Това ще накара двигателите да работят със 7.4V. Следващата таблица ще изброи как е свързан модулът на драйвера на двигателя MPU6050 и L298N с Arduino.
|
Компонентен щифт |
Arduino Pin |
|
MPU6050 |
|
|
Vcc |
+ 5V |
|
Земя |
Gnd |
|
SCL |
A5 |
|
SDA |
A4 |
|
INT |
D2 |
|
L298N |
|
|
IN1 |
D6 |
|
IN2 |
D9 |
|
IN3 |
D10 |
|
IN4 |
D11 |
MPU6050 комуникира с Arduino чрез I2C интерфейс, така че използваме SPI щифтовете A4 и A5 на Arduino. Двигателите с постоянен ток са свързани към ШИМ щифтове D6, D9 D10 и D11 съответно. Трябва да ги свържем с PWM щифтове, защото ще контролираме скоростта на постояннотоковия двигател чрез промяна на работния цикъл на PWM сигналите. Ако не сте запознати с тези два компонента, препоръчително е да прочетете упътването за MPU6050 Interfacing и L298N Motor driver.
Код на самобалансиращ се робот
Сега трябва да програмираме нашата дъска Arduino UNO, за да балансира робота. Тук се случва цялата магия; концепцията зад него е проста. Трябва да проверим дали ботът е наклонен към предната или задната страна с помощта на MPU6050 и след това дали е наклонен отпред трябва да завъртим колелата в посока напред и ако е наклонен към гърба трябва да завъртим колелата в обратна посока.
В същото време ние също трябва да контролираме скоростта, с която се въртят колелата, ако ботът е леко дезориентиран от централната позиция, колелата се въртят бавно и скоростта се увеличава, когато се отдалечава повече от централната позиция. За да постигнем тази логика, използваме алгоритъма PID, който има централната позиция като зададена точка и нивото на дезориентация като изход.
За да знаем текущата позиция на бота, използваме MPU6050, който е комбиниран 6-осен акселерометър и сензор за жироскоп. За да получим надеждна стойност на позицията от сензора, трябва да използваме стойността както на акселерометъра, така и на жироскопа, тъй като стойностите от акселерометъра имат проблеми с шума и стойностите от жироскопа са склонни да се отклоняват с времето. Така че трябва да комбинираме и двете и да получим стойността на наклона и въртене на нашия робот, от които ще използваме само стойността на наклона.
Звучи малко накланяне на главата, нали? Но не се притеснявайте, благодарение на общността Arduino имаме лесно достъпни библиотеки, които могат да извършат изчислението на PID и също така да получат стойността на отклонение от MPU6050. Библиотеката е разработена съответно от br3ttb и jrowberg. Преди да продължите да изтегляте техните библиотеки, оформете следната връзка и ги добавете към вашата директория на Arduino lib.
github.com/br3ttb/Arduino-PID-Library/blob/master/PID_v1.h
github.com/jrowberg/i2cdevlib/tree/master/Arduino/MPU6050
Сега, когато имаме библиотеки, добавени към нашата IDE на Arduino. Нека започнем програмирането за нашия самобалансиращ се робот. Както винаги пълният код за балансиращия робот MPU6050 е даден в края на тази страница, тук просто обяснявам най-важните фрагменти в кода. По-рано казаният код се изгражда върху примера на MPU6050, ние просто ще оптимизираме кода за нашата цел и ще добавим PID и техниката за управление на нашия самобалансиращ се робот.
Първо включваме библиотеките, необходими за работата на тази програма. Те включват вградената I2C библиотека, PID библиотека и MPU6050 библиотека, които току-що изтеглихме.
#include "I2Cdev.h" #include
След това декларираме променливите, необходими за получаване на данните от сензора MPU6050. Четем както гравитационния вектор, така и стойностите на кватерниона и след това изчисляваме стойността на въртене и въртене на бота. В YPR поплавък масив ще проведе на крайния резултат.
// MPU контрол / статус варира bool dmpReady = false; // задаваме вярно, ако инициализацията на DMP е била успешна uint8_t mpuIntStatus; // съдържа действителен байт за състояние на прекъсване от MPU uint8_t devStatus; // връщане на състоянието след всяка операция на устройството (0 = успех ,! 0 = грешка) uint16_t packetSize; // очакван размер на DMP пакета (по подразбиране е 42 байта) uint16_t fifoCount; // преброяване на всички байтове в момента във FIFO uint8_t fifoBuffer; // FIFO буфер за съхранение // ориентация / движение варира Quaternion q; // кватернион контейнер VectorFloat гравитация; // гравитационен вектор float ypr; // наклон / наклон / ролка контейнер и вектор на гравитацията
След това идва много важният сегмент на кода и тук ще прекарате дълго време в настройка за правилния набор от стойности. Ако вашият робот е изграден с много добър център на тежестта и компонентите са разположени симетрично (което в повечето случаи не е), тогава стойността на зададената точка ще ви бъде 180. В противен случай свържете бота си със серийния монитор на Arduino и го наклонете до намерите добра позиция за балансиране, прочетете стойността, показана на серийния монитор и това е вашата стойност на зададената точка. Стойността на Kp, Kd и Ki трябва да бъде настроена според вашия бот. Нито един идентичен бот няма да има еднакви стойности на Kp, Kd и Ki, така че няма да избяга от него. Гледайте видеоклипа в края на тази страница, за да получите представа как да коригирате тези стойности.
/ ********* Настройте тези 4 стойности за вашия BOT ********* / двойна зададена стойност = 176; // задайте стойността, когато ботът е перпендикулярен на земята, като използвате сериен монитор. // Прочетете документацията на проекта на circuitdigest.com, за да научите как да задавате тези стойности double Kp = 21; // Задайте този първи двоен Kd = 0.8; // Задайте това второ двойно Ki = 140; // Накрая задайте това / ****** Настройка на края на стойностите ********* /
В следващия ред инициализираме PID алгоритъма чрез предаване на входните променливи input, output, set point, Kp, Ki и Kd. От тях вече сме задали стойностите на зададената точка Kp, Ki и Kd в горния фрагмент от код. Стойността на входа ще бъде текущата стойност на отклонението, която се отчита от сензора MPU6050, а стойността на изхода ще бъде стойността, която се изчислява от алгоритъма PID. Така че основно PID алгоритъмът ще ни даде изходна стойност, която трябва да се използва за коригиране на входната стойност, за да бъде тя близо до зададената точка.
PID pid (& input, & output, & setpoint, Kp, Ki, Kd, DIRECT);
Във функцията за настройка на кухини инициализираме MPU6050, като конфигурираме DMP (Цифров процесор на движение). Това ще ни помогне при комбинирането на данните от акселерометъра с данните на жироскопа и ще осигури надеждна стойност на Yaw, Pitch и Roll. Няма да навлизаме много дълбоко в това, тъй като то ще бъде далеч извън темата. Във всеки случай един сегмент от код, който трябва да потърсите във функцията за настройка, е стойностите на изместване на жироскопа. Всеки MPU6050 сензор има свои собствени стойности на отмествания, можете да използвате тази скица на Arduino, за да изчислите стойността на отместването на вашия сензор и да актуализирате следващите редове съответно във вашата програма.
// предоставете свои собствени отмествания на жироскоп тук, мащабирани за минимална чувствителност mpu.setXGyroOffset (220); mpu.setYGyroOffset (76); mpu.setZGyroOffset (-85); mpu.setZAccelOffset (1688);
Ние също трябва да инициализираме цифровите PWM щифтове, които използваме за свързване на нашите двигатели. В нашия случай това са D6, D9, D10 и D11. Така че ние инициализираме тези щифтове, тъй като изходните щифтове ги правят НИСКИ по подразбиране.
// Инициализирайте мотор outpu щифтове pinMode (6, ИЗХОД); pinMode (9, ИЗХОД); pinMode (10, ИЗХОД); pinMode (11, ИЗХОД); // По подразбиране изключете и двата двигателя analogWrite (6, LOW); analogWrite (9, LOW); analogWrite (10, LOW); analogWrite (11, LOW);
Във функцията на основния контур проверяваме дали данните от MPU6050 са готови за четене. Ако отговорът е „да“, ние го използваме за изчисляване на стойността на PID и след това показваме входната и изходната стойност на PID на сериен монитор, само за да проверим как реагира PID. След това въз основа на стойността на изхода решаваме дали ботът трябва да се движи напред или назад или да стои неподвижно.
Тъй като предполагаме, че MPU6050 ще върне 180, когато ботът е изправен. Ще получим положителни стойности на корекция, когато ботът пада напред, а ще получим отрицателни стойности, ако ботът пада назад. Затова проверяваме за това състояние и извикваме съответните функции, за да преместим бота напред или назад.
while (! mpuInterrupt && fifoCount <packetSize) { // без mpu данни - извършване на PID изчисления и извеждане към двигатели pid.Compute (); // Отпечатайте стойността на входа и изхода на сериен монитор, за да проверите как работи. Serial.print (вход); Serial.print ("=>"); Serial.println (изход); if (input> 150 && input <200) {// Ако ботът пада if (output> 0) // Падане към предния напред (); // Завъртете колелата напред в противен случай, ако (изход <0) // Падане назад Обратно (); // Завъртете колелата назад } else // Ако ботът не пада Stop (); // Дръжте колелата неподвижни }
В изходна променлива PID реши също колко бързо мотора трябва да се върти. Ако ботът тъкмо е на път да падне, ние правим незначителна корекция, като въртим бавно колелото. Ако тези незначителни корекции не работят и въпреки това, ако ботът пада надолу, ние увеличаваме скоростта на двигателя. Стойността на това колко бързо се въртят колелата ще се определя от алгоритъма PI. Имайте предвид, че за функцията Reverse сме умножили стойността на изхода с -1, за да можем да преобразуваме отрицателната стойност в положителна.
void Forward () // Код за завъртане на колелото напред { analogWrite (6, изход); analogWrite (9,0); analogWrite (10, изход); analogWrite (11,0); Serial.print ("F"); // Информация за отстраняване на грешки } void Reverse () // Код за завъртане на колелото назад { analogWrite (6,0); analogWrite (9, изход * -1); analogWrite (10,0); analogWrite (11, изход * -1); Serial.print ("R"); } void Stop () // Код за спиране на двете колела { analogWrite (6,0); analogWrite (9,0); analogWrite (10,0); analogWrite (11,0); Serial.print ("S"); }
Работа на Arduino Self Balancing Robot
След като сте готови с хардуера, можете да качите кода на вашата платка Arduino. Уверете се, че връзките са правилни, тъй като използваме литиево-йонна батерия е необходима изключителна предпазливост. Така че двойно проверете за къси съединения и се уверете, че терминалите няма да влязат в контакт, дори ако ботът ви има някои малки въздействия. Включете модула си и отворете серийния си монитор, ако вашият Arduino може да комуникира успешно с MPU6050 и ако всичко работи както се очаква, трябва да видите следния екран.
Тук виждаме входните и изходните стойности на PID алгоритъма във формата input => output . Ако ботът е перфектно балансиран, стойността на изхода ще бъде 0. Входната стойност е текущата стойност от сензора MPU6050. Азбуката „F“ представлява, че ботът се движи напред, а „R“ представлява, че ботът е в обратна посока.
По време на началните етапи на PID препоръчвам да оставите вашия Arduino кабел свързан към бота, за да можете лесно да наблюдавате стойностите на входа и изхода, а също така ще бъде лесно да коригирате и качите програмата си за стойности Kp, Ki и Kd. На видеото по-долу показва цялостното функциониране на бота и също показва как да поправите PID стойности.
Надявам се това да ви помогне да създадете свой собствен балансиращ робот, ако имате някакъв проблем да го накарате да работи, след това оставете въпросите си в раздела за коментари по-долу или използвайте форумите за повече технически въпроси. Ако искате повече забавление, можете също да използвате същата логика, за да създадете робот за балансиране на топки.