Главная

Готовые Arduino роботы. Четвероногий робот на базе Arduino Гусеничная машина на Arduino, управляемая с сотового телефона

Доброго времени суток! Перед вами, дорогие , арт-робот, который может разрисовывать различные сферические или яйцевидные предметы размером от 4 до 9 см.

Для его изготовления понадобится 3D-принтер, набор стандартных инструментов + Arduino.

Примечание: Не стоит ставить крест на проектах, в которых используются 3D-принтер. При желании всегда можно найти место или способ, где можно заказать печать необходимых для проекта деталей.

Шаг 1: Немного о роботе

Арт-робот — двухосевая самоделка , которая может наносить рисунок на большинстве сферических поверхностей. Робот настраивается под определённый тип предмета (шары для пинг-понга, рождественские украшения, лампочки и яйца (утиные, гусиные, куриные …).

Для вращения сферического предмета и перемещения манипулятора используются высокоточные шаговые двигатели с высоким крутящим моментом, а для подъёма механизма ручки — тихий и надежный сервопривод SG90.

Шаг 2: Необходимые детали

Для того, чтобы сделать поделку своими руками нам понадобится:

2x подшипника 623;
Шпилька диаметром 3 мм и длиной 80-90 мм;
1x пружина (длиной 10 мм и диаметром 4,5 мм);
2x шаговых двигателя NEMA 17 (крутящий момент 4,4 кг / см);
Кабели для двигателей (длиной 14 + 70 см);
USB-кабель;
1x сервопривод SG90;
Arduino Leonardo;
shield JJRobots;

2xA4988 драйвера для шаговых двигателей;
Блок питания 12В / 2A;
11x винтов M3 6 мм;
4x винта M3 16 мм;
4x гайки M3;
2x 20-мм присоски;
1x гайка-барашек M3;
1x маркер;

Шаг 3: Общая схема

В качестве «шпаргалки» можете воспользоваться данной схемой.

Шаг 4: Давайте начинать!

Робот двигает манипулятором, с закрепленным на нём маркером, что приводится в действие шаговым двигателем. Другой шаговый двигатель отвечает за поворот объекта, на который наносится рисунок (яйцо, шарик …). Для удерживания предмета на месте используются две присоски: одна, прикрепленная к шаговому двигателю, а другая на противоположной стороне предмета. Маленькая пружина будет давить на присоску, помогая ей удерживать предмет. Для поднятия/опускания маркера используется сервопривод SG90.

Шаг 5: Манипулятор

Установим гайку в отверстие, подготовленное для неё и закрутим 16 мм винт. Сделаем то же самое для держателя предметов (справа на изображении выше). При создании шарнира для манипулятора использовались 2 16 мм винта. Этот шарнир должен свободно вращаться после закручивания винтов.

Шаг 6: Присоски

Установим одну из присосок внутрь отверстия в держателе предметов.

Шаг 7: Крепление шаговых двигателей

Закрепим оба шаговых двигателя к основной раме с помощью 8-ми винтов.

Шаг 8: Ось вращения

Разместим все элементы, как показано на изображении выше.

Присоска;
Гайка;
Верхняя часть;
Пружина;
Подшипник 623 (должен быть встроен в левую чашку);
Левая чашка;
Свободное пространство для основной рамы;
Правая чашка;
Подшипник 623;
Разделительное кольцо;
Гайка-барашек (M3).

Шаг 9: Размещаем все по своим местам

Вставим собранный манипулятор на ось шагового двигателя.

Установим левую опору на ось шагового двигателя.

Маркер и яйцо установлены в качестве примера (сейчас размещать их не нужно).

ПРИМЕЧАНИЕ: Сервопривод потребует корректировок. Нужно будет повторно установить его угол во время процесса калибровки.

Шаг 10: Электроника

Закрепим электронику на тыльной стороне основной рамы с помощью винтов (2-х будет достаточно).

Подключим кабеля.

Если вы перепутаете полярности при подключении шаговых двигателей, то они будут просто вращаться в противоположном направлении, но с сервоприводом ситуация будет не такой уж и безобидной! Поэтому дважды проверяйте полярность перед подключением!

Шаг 11: Программирование Arduino Leonardo

Запрограммируем Arduino Leonardo с помощью программной среды Arduino IDE (v 1.8.1).

Загрузим Arduino IDE (v 1.8.1) и установим программу;
Запустим программное обеспечение. Выберем плату Arduino Leonardo и соответствующий COM-ПОРТ в меню «tools-> board»;
Откроем и загрузим код Sphere-O-Bot. Распакуем все файлы внутрь одной папки и назовём её «Ejjduino_ARDUINO».

Шаг 12: Арт-робот готов к созданию произведений искусства

Шаг 13: Управление роботом

Программное обеспечение Inkscape. Загрузим и установим программное обеспечение Inkscape (рекомендую стабильную версию 0.91).

Загрузим и установим расширение EggBot Control (версия 2.4.0 была полностью протестирована).

Расширение EggBot Control для Inkscape — это инструмент, который необходимо использовать при тестировании и калибровке EggBot, а также перенесении рисунки на яйцо. Сначала нужно запустить Inkscape. После запуска Inkscape появится меню «Расширения», а в нём уже нужно выбрать подменю «Eggbot». Если не видите подменю Eggbot, то вы неправильно установили расширения. Выполните резервное копирование и внимательно следуйте инструкциям по установке расширений.

На этом всё, спасибо за внимание!)

В итоге получился довольно забавный робот , который может видеть перед собой препятствия, анализировать ситуацию и затем, только выбрав лучший маршрут, едет дальше. Робот получился очень маневренным. Он способен разворачиваться на 180 градусов, а угол поворота составляет 45 и 90 градусов. В качестве основного контроллера автор использовал Iteaduino, который является аналогом Arduino.

Материалы и инструменты для изготовления робота:
- микроконтроллер (Arduino или ему подобный Iteaduino);
- ультразвуковой датчик;
- держатель для батареек;
- китайские игрушки для создания колесной базы (можно купить готовую);
- кусачки;
- клей;
- провода;
- моторчики;
- ДВП;
- лобзик;
- транзисторы (D882 P).

Процесс изготовления робота:

Шаг первый. Создание колесной базы
Для того чтобы создать колесную базу автор прикупил две китайские игрушечные машинки. Впрочем, по этому поводу можно и не беспокоиться, если есть лишние деньги, так как уже готовую базу можно купить. С помощью кусачек машинки были разрезаны на две части, чтобы образовалось две ведущих оси. Далее эти части были склеены. Впрочем, в таком случае можно поработать и паяльником, пластмасса отлично спаивается.

Выбирая машинки, лучше всего брать игрушки с обычными колесами, так как, по словам автора, с такими шипами как у него, робот сильно скачет.

Есть еще один такой момент, когда от моторчиков будут выводиться провода, на одном из них нужно не забыть сменить полярность.

Шаг второй. Изготовление верхней крышки
Верхняя крышка робота изготавливается из ДВП, также для этих целей можно использовать толстый картон. В крышке можно увидеть прямоугольно отверстие, оно должно быть расположено так, чтобы ось сервопривода, которая будет в него вставлена, располагалась симметрично. Что касается отверстия посередине, то через него будут выводиться провода.

Шаг третий. Начинка робота
Для подключения шасси лучше всего использовать отдельный источник питания, поскольку для питания контроллера требуется 9В, а для моторчиков нужно всего 3В. Вообще в шасси таких машинок уже встроены держатели батареек, их просто нужно соединить параллельно.

К контроллеру моторчики подключаются при помощи транзисторов типа D882 P. Они были вытащены из старого пульта управления машинкой. Лучше всего конечно использовать силовые транзисторы типа TIP120Б, но автор выбирал просто по подходящим характеристикам. Вся электронная часть подключается по указанной схеме.

После прошивки робота он будет готов к тестированию. Чтобы робот успевал развернуться на определенный угол, нужно правильно выбрать время работы моторчиков.

Что касается датчиков, то ультразвуковой нужно подключить к 7-му цифровому выходу микроконтроллера. Серводвигатель подключается к 3-му цифровому входу, база транзистора левого мотора подключается к 11 контакту, а база правого к 10-му.

Если в качестве питания будет использоваться Крона, то минус подключается к GND, а плюс к VIN. Еще к GND нужно подключить эмиттер транзистора и отрицательный контакт от источника питания шасси робота.

Давайте поговорим о том как можно использовать Ардуино для создания робота, который балансирует как Сигвей.

Сигвей от англ. Segway – двухколесное средство передвижения стоя, оснащенное электроприводом. Еще их называют гироскутерами или электрическими самокатами.

Вы когда-нибудь задумывались, как работает Сигвей? В этом уроке мы постараемся показать вам, как сделать робота Ардуино, который уравновешивает себя точно так же, как Segway.

Чтобы сбалансировать робота, двигатели должны противодействовать падению робота. Это действие требует обратной связи и корректирующих элементов. Элемент обратной связи - , который обеспечивает как ускорение, так и вращение во всех трех осях (). Ардуино использует это, чтобы знать текущую ориентацию робота. Корректирующим элементом является комбинация двигателя и колеса.

В итоге должен получиться примерно такой друг:

Схема робота

Модуль драйвера двигателя L298N:

Мотор редуктора постоянного тока с колесом:

Самобалансирующийся робот по существу является перевернутым маятником. Он может быть лучше сбалансирован, если центр массы выше относительно колесных осей. Высший центр масс означает более высокий момент инерции массы, что соответствует более низкому угловому ускорению (более медленное падение). Вот почему мы положили батарейный блок на верх. Однако высота робота была выбрана исходя из наличия материалов 🙂

Завершенный вариант самостоятельно балансирующего робота можно посмотреть на рисунке выше. В верхней части находятся шесть Ni-Cd-батарей для питания печатной платы. В промежутках между моторами используется 9-вольтовая батарея для драйвера двигателя.

Теория

В теории управления, удерживая некоторую переменную (в данном случае позицию робота), требуется специальный контроллер, называемый ПИД (пропорциональная интегральная производная). Каждый из этих параметров имеет «прирост», обычно называемый Kp, Ki и Kd. PID обеспечивает коррекцию между желаемым значением (или входом) и фактическим значением (или выходом). Разница между входом и выходом называется «ошибкой».

ПИД-регулятор уменьшает погрешность до наименьшего возможного значения, постоянно регулируя выход. В нашем самобалансирующем роботе Arduino вход (который является желаемым наклоном в градусах) устанавливается программным обеспечением. MPU6050 считывает текущий наклон робота и подает его на алгоритм PID, который выполняет вычисления для управления двигателем и удерживает робота в вертикальном положении.

PID требует, чтобы значения Kp, Ki и Kd были настроены на оптимальные значения. Инженеры используют программное обеспечение, такое как MATLAB, для автоматического вычисления этих значений. К сожалению, мы не можем использовать MATLAB в нашем случае, потому что это еще больше усложнит проект. Вместо этого мы будем настраивать значения PID. Вот как это сделать:

Сделайте Kp, Ki и Kd равными нулю.
Отрегулируйте Kp. Слишком маленький Kp заставит робота упасть, потому что исправления недостаточно. Слишком много Kp заставляет робота идти дико вперед и назад. Хороший Kp сделает так, что робот будет совсем немного отклоняться назад и вперед (или немного осциллирует).
Как только Kp установлен, отрегулируйте Kd. Хорошее значение Kd уменьшит колебания, пока робот не станет почти устойчивым. Кроме того, правильное Kd будет удерживать робота, даже если его толькать.
Наконец, установите Ki. При включении робот будет колебаться, даже если Kp и Kd установлены, но будет стабилизироваться во времени. Правильное значение Ki сократит время, необходимое для стабилизации робота.

Поведение робота можно посмотреть ниже на видео:

Код Ардуино самобалансирующего робота

Нам понадобилось четыре внешних библиотеки, для создания нашего робота. Библиотека PID упрощает вычисление значений P, I и D. Библиотека LMotorController используется для управления двумя двигателями с модулем L298N. Библиотека I2Cdev и библиотека MPU6050_6_Axis_MotionApps20 предназначены для чтения данных с MPU6050. Вы можете загрузить код, включая библиотеки в этом репозитории .

#include #include #include "I2Cdev.h" #include "MPU6050_6Axis_MotionApps20.h" #if I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE #include "Wire.h" #endif #define MIN_ABS_SPEED 20 MPU6050 mpu; // MPU control/status vars bool dmpReady = false; // set true if DMP init was successful uint8_t mpuIntStatus; // holds actual interrupt status byte from MPU uint8_t devStatus; // return status after each device operation (0 = success, !0 = error) uint16_t packetSize; // expected DMP packet size (default is 42 bytes) uint16_t fifoCount; // count of all bytes currently in FIFO uint8_t fifoBuffer; // FIFO storage buffer // orientation/motion vars Quaternion q; // quaternion container VectorFloat gravity; // gravity vector float ypr; // yaw/pitch/roll container and gravity vector //PID double originalSetpoint = 173; double setpoint = originalSetpoint; double movingAngleOffset = 0.1; double input, output; //adjust these values to fit your own design double Kp = 50; double Kd = 1.4; double Ki = 60; PID pid(&input, &output, &setpoint, Kp, Ki, Kd, DIRECT); double motorSpeedFactorLeft = 0.6; double motorSpeedFactorRight = 0.5; //MOTOR CONTROLLER int ENA = 5; int IN1 = 6; int IN2 = 7; int IN3 = 8; int IN4 = 9; int ENB = 10; LMotorController motorController(ENA, IN1, IN2, ENB, IN3, IN4, motorSpeedFactorLeft, motorSpeedFactorRight); volatile bool mpuInterrupt = false; // indicates whether MPU interrupt pin has gone high void dmpDataReady() { mpuInterrupt = true; } void setup() { // join I2C bus (I2Cdev library doesn"t do this automatically) #if I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE Wire.begin(); TWBR = 24; // 400kHz I2C clock (200kHz if CPU is 8MHz) #elif I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_FASTWIRE Fastwire::setup(400, true); #endif mpu.initialize(); devStatus = mpu.dmpInitialize(); // supply your own gyro offsets here, scaled for min sensitivity mpu.setXGyroOffset(220); mpu.setYGyroOffset(76); mpu.setZGyroOffset(-85); mpu.setZAccelOffset(1788); // 1688 factory default for my test chip // make sure it worked (returns 0 if so) if (devStatus == 0) { // turn on the DMP, now that it"s ready mpu.setDMPEnabled(true); // enable Arduino interrupt detection attachInterrupt(0, dmpDataReady, RISING); mpuIntStatus = mpu.getIntStatus(); // set our DMP Ready flag so the main loop() function knows it"s okay to use it dmpReady = true; // get expected DMP packet size for later comparison packetSize = mpu.dmpGetFIFOPacketSize(); //setup PID pid.SetMode(AUTOMATIC); pid.SetSampleTime(10); pid.SetOutputLimits(-255, 255); } else { // ERROR! // 1 = initial memory load failed // 2 = DMP configuration updates failed // (if it"s going to break, usually the code will be 1) Serial.print(F("DMP Initialization failed (code ")); Serial.print(devStatus); Serial.println(F(")")); } } void loop() { // if programming failed, don"t try to do anything if (!dmpReady) return; // wait for MPU interrupt or extra packet(s) available while (!mpuInterrupt && fifoCount < packetSize) { //no mpu data - performing PID calculations and output to motors pid.Compute(); motorController.move(output, MIN_ABS_SPEED); } // reset interrupt flag and get INT_STATUS byte mpuInterrupt = false; mpuIntStatus = mpu.getIntStatus(); // get current FIFO count fifoCount = mpu.getFIFOCount(); // check for overflow (this should never happen unless our code is too inefficient) if ((mpuIntStatus & 0x10) || fifoCount == 1024) { // reset so we can continue cleanly mpu.resetFIFO(); Serial.println(F("FIFO overflow!")); // otherwise, check for DMP data ready interrupt (this should happen frequently) } else if (mpuIntStatus & 0x02) { // wait for correct available data length, should be a VERY short wait while (fifoCount < packetSize) fifoCount = mpu.getFIFOCount(); // read a packet from FIFO mpu.getFIFOBytes(fifoBuffer, packetSize); // track FIFO count here in case there is > 1 packet available // (this lets us immediately read more without waiting for an interrupt) fifoCount -= packetSize; mpu.dmpGetQuaternion(&q, fifoBuffer); mpu.dmpGetGravity(&gravity, &q); mpu.dmpGetYawPitchRoll(ypr, &q, &gravity); input = ypr * 180/M_PI + 180; } }

Значения Kp, Ki, Kd могут работать или не работать. Если они этого не делают, выполните шаги, описанные выше. Обратите внимание, что наклона в коде установлен на 173 градуса. Вы можете изменить это значение, если хотите, но обратите внимание, что это угол наклона, которым должен поддерживаться роботом. Кроме того, если ваши двигатели слишком быстры, вы можете отрегулировать значения motorSpeedFactorLeft и motorSpeedFactorRight.

На этом пока всё. До встречи.

На Arduino очень легко делать разные машинки с дистанционным управлением, простыми сенсорами и логикой. Поэтому линейка эта невероятно популярна. Продается множество совместимых с ней сенсоров и плат расширения. Интернет наполнен готовыми программными библиотеками и проектами с открытым исходным кодом на все случаи жизни. Практически все вопросы, которые у тебя возникнут в процессе освоения Arduino, уже кем-то задавались, и ты всегда найдешь ответ.

Давай с чего-нибудь начнем? Главный вопрос - выбор контроллера. Существует множество ревизий Arduino, а также сторонних клонов, построенных на основе этих версий. Вот, пожалуй, два самых интересных для нас класса:

Arduino Uno - лучший выбор новичка, самая простая, бюджетная и распространенная плата. В основе - чип ATmega328 с тактовой частотой в 16 МГц, 32 Кб флеш-памяти, 2 Кб ОЗУ и 1 Кб EEPROM. В Uno 14 цифровых входов/выходов, которые могут использоваться для управления сенсорами и сервоприводами и другими устройствами;

Arduino Mega / Mega 2560 - плата, которая подойдет в случае, когда ты заранее знаешь, что проект будет сложным. Главное отличие - большее количество входов/выходов (48 в Mega, 54 в Mega 2560). Также тут намного больше памяти: 8 Кб ОЗУ, 4 Кб EEPROM, а флеш-памяти 128 и 256 Кб (в Mega и Mega 2560 соответственно). Между собой платы также отличаются чипом, скоростью USB и некоторыми другими характеристиками.

Разумеется, еще есть Arduino Pro, Arduino LilyPad и многие другие. Но сейчас давай остановимся на первых двух моделях. В нашем случае все довольно просто: Mega нужна для робота с большим количеством ног.

Первый код

Для начала установим Arduino IDE (arduino.cc) - это кросс-платформенная бесплатная среда разработки. Теперь, если мы подключим наш Arduino, мы сможем попробовать написать первый код на самом простом примере: программе мигания светодиодом. На большинстве Arduino-контроллеров он есть и подключен к пину 13. Кстати, в мире Arduino программы принято называть скетчами. Вот текст скетча с комментариями:

// Дадим этому пину имя LED: const int LED = 13; void setup() { // Инициализация цифрового пина // для вывода: pinMode(LED, OUTPUT); } void loop() { // Подать уровень логической единицы // на пин 13 (зажечь светодиод): digitalWrite(LED, HIGH); // Приостановить выполнение скетча // на секунду: delay(1000); // Подать уровень логического нуля // на пин 13 (потушить светодиод): digitalWrite(LED, LOW); // Снова приостановить выполнение // скетча на секунду: delay(1000); }

Обрати внимание на функции setup и loop. Они должны присутствовать в любом Arduino-скетче. Setup вызывается единожды при включении или после перезапуска контроллера. Если хочешь, чтобы код выполнялся только один раз, его следует размещать именно здесь. Чаще всего это всевозможные процедуры инициализации чего-либо. Наш скетч не исключение: цифровые пины Arduino могут работать и как входы, и как выходы. В функции setup мы говорим, что пин 13 будет работать как цифровой выход контроллера.

После того как функция setup завершит свою работу, автоматически запускается замкнутый цикл, внутри которого будет вызываться функция loop. От нас требуется написать, что мы хотим там выполнять. А мы хотим подать на пин 13 уровень логической единицы (5 В), то есть зажечь светодиод, затем подождать одну секунду (1000 в миллисекундах), потом подать уровень логического нуля (0 В) и опять подождать одну секунду. Следующий вызов loop все повторит.

Теперь «заливаем» наш скетч в контроллер. Нет, нам не понадобится программатор. Контроллеры Arduino, кроме наших скетчей, содержат специальную программу - bootloader, которая, в частности, управляет загрузкой кода из компьютера. Так что для заливки скетча нам понадобится только USB-кабель и пункт меню File → Upload (Ctrl + U) в Arduino IDE.

Ключевой вопрос

А сколько, собственно, нам нужно ног? Определимся во множестве конфигураций шагающих роботов. По количеству ног:

biped - двуногий (прототип - человек);
quadruped - четвероногий (прототип - большинство млекопитающих животных);
hexapod - шестиногий (прототип - большинство насекомых);
octopod - восьминогий (прототип - пауки, скорпионы, крабы и другие членистоногие).

Кроме количества ног, важна и конфигурация каждой. Главной характеристикой ноги является количество степеней свободы, или dimensions of freedom (DOF). Степень свободы - это способность поворачиваться или изгибаться вокруг одной оси (реже - поступательно двигаться вдоль нее). Очевидно, что если степень свободы одна, то на такой ноге далеко не уйдешь. Ноги с двумя степенями свободы (2DOF) уже позволяют двигаться многоногим роботам, хотя 2DOF дает возможность свободно перемещать кончик ноги только в одной плоскости. А 3DOF-нога перемещает «стопу» в 3D-пространстве (если, конечно, не все три оси параллельны). Есть и 4DOF-ноги, которые просто увеличивают гибкость и диапазон перемещения ноги. У насекомых чаще всего 4DOF-лапы.

Что это значит для нас? В дешевых любительских роботах каждую степень свободы реализует один двигатель, точнее, сервопривод, или серв. Конфигурация ног однозначно определяет, сколько таких сервов нужно. Так, 3DOF-гексапод потребует 18 сервов, а 4DOF-паук - уже 32. Не пугайся количества, маленькие сервоприводы, используемые в любительских радиоуправляемых моделях, очень дешевы. В интернет-магазинах их можно найти по запросу micro servo.

Чтобы программировать сервоприводы, достаточно знать, что в них уже есть контроллер, который делает основную работу. И все, что нужно, - подавать питание и цифровой сигнал, сообщающий контроллеру, в какую позицию мы хотим повернуть вал привода. Об их конструкции легко найти информацию. Протокол у них самый простой из всех цифровых протоколов связи: широтно-импульсная модуляция - ШИМ (PWM на английском). У всех простых сервов есть разъем с тремя контактами: земля, +5 В (вольтаж может отличаться в зависимости от размера и мощности) и сигнальный вход. Arduino-контроллеры могут двумя различными способами генерировать такой сигнал. Первый - аппаратный PWM, который сам чип умеет выдавать на нескольких из своих цифровых I/O-пинов. Второй - программный. Программный позволяет получить одновременно больше различных PWM-сигналов, чем аппаратный. Для него под Arduino предоставляется удобная обертка - библиотека Servo. Она позволяет использовать одновременно 12 сервоприводов на большинстве малогабаритных контроллеров (Uno, Due, Nano) и 48 сервоприводов на Arduino Mega и ему подобных. Сигнальный контакт серва подключается к цифровому выводу Arduino. Земля и питание - очевидно, к земле и питанию, они могут быть общими для всех сервов. В трехпроводных шлейфах сервов черный или коричневый - это земля, посередине обычно красный +5 В и, наконец, белый или желтый - сигнальный. С программной точки зрения управление предельно простое:

Servo myservo; // Сервопривод на 9-м пине Arduino myservo.attach(9); // Повернуть в положение на 90º myservo.write(90);

Большинство сервов умеют вращать вал на 180°, и для них 90° - среднее положение. Для упрощения подключения сервов к плате Arduino существует ряд решений. Самое каноничное - это Sensors Shield. Установив его на Uno и подав на клеммы питание для сервов, можно их разъемы подключать прямо в него.

Батарея

Еще один важный вопрос - питание. Если у тебя продвинутая плата, которая позволяет снабжать всю систему по одной линии питания (и двигатели сервов не дадут помех в работу контроллера), то можно обойтись одним источником. Выбор огромен, лучше всего, конечно, Li-Ion/Li-Po брикеты для радиомоделек. Но им нужны и соответствующие зарядные устройства. Если у тебя контроллер попроще (Uno/Due/Nano), то можно питать его отдельно, например 9-вольтовой «Кроной», а сервоприводы подключить к основной мощной батарее. Так сервоприводам точно хватит питания. В случае литиевых аккумуляторов нужно еще тщательней, чем обычно, следить за напряжением, чтобы не было переразряда (допустимые напряжения стоит уточнить для конкретного типа батареи). Для этого на робота-Слейпнира, о котором дальше пойдет речь, также прикручен маленький цифровой вольтметр.

Робожук своими руками

Набор

Контроллер Arduino Uno: 1150 р.
Три серводвигателя. Я использовал HXT500, 200 р. за штуку
Батарейный отсек для «Кроны» с выключателем: 50 р.
Батарейка «Крона»: 145 р.
ИК-приемник: 90 р.
Стальная проволока диаметром примерно 1,5 мм. Я, к примеру, использовал сломанный венчик для взбивания яиц

Итого: 2035 р.

DmitryDzz: Я хочу предложить тебе сделать небольшого дистанционно управляемого шестиногого робожука на базе контроллера Arduino Uno. Лапки будут иметь одну степень свободы, управление будет происходить с помощью обычного ТВ-пульта.

Надо сказать, что это цены дорогих московских магазинов. В китайских интернет-магазинах все это обойдется раза в два дешевле. Считая доставку. Правда, ждать придется, по моему опыту, от двух недель до трех месяцев.

Более простой способ - взять набор-конструктор, потому что на первых шагах одного контроллера будет мало. Сейчас много магазинов предлагают такие наборы. Например, есть замечательный интернет-магазин «Амперка» . Здесь тебе предложат несколько подобных конструкторов, отличающихся наполненностью и, конечно, ценой. Мне вполне хватило самого простого - «Матрешка X». В него входит контроллер Arduino Uno, USB-кабель для подключения к компьютеру, доска для прототипирования (незаменимая вещь!), набор перемычек, светодиоды, резисторы и прочая мелочь.

В этом же магазине есть раздел «Вики», где ты найдешь даже замечательные короткие видеоуроки, переведенные на русский язык. Обязательно посмотри их. И конечно, есть форум, где тебе наверняка постараются помочь.

Что понадобится из инструментов:

паяльник и все, что нужно для пайки. Паять много не придется, и особого мастерства не потребуется;
термоклеевой пистолет и стержни к нему;
пассатижи для работы с проволокой.

Если все собрали, приступим!

Управление

Перейдем к первому шагу: нам надо научиться взаимодействовать с пультом ДУ и выведать коды нажатий на некоторые его кнопки. Эти коды потом пригодятся для скетча управления роботом.

На этом этапе понадобится еще ИК-приемник и хорошо бы иметь доску для прототипирования. Подавляющее большинство ИК-пультов работают на несущих частотах 36 кГц, 38 кГц или 40 кГц (Panasonic, Sony). Исключение составляют пульты Sharp (56 кГц), Bang & Olufsen (455 кГц) и, может, кто-то еще более экзотический. Поэтому нам вполне подойдет любой ИК-приемник на 36, 38 или 40 кГц. Частота может точно не совпадать с несущей частотой сигнала. В таком случае чувствительность приемника будет снижаться, но на практике я не заметил дискомфорта, используя ИК-приемник TSOP2136 (36 кГц - последние две цифры - частота) и пульт ДУ Sony (40 кГц).

Итак, для большинства пультов подойдут ИК-приемники TSOP21xx, TSOP22xx, TSOP312xx. Две последние цифры могут быть 36, 37, 38 или 40. Перед включением ИК-приемника уточни разводку его контактов - их всего три: +5V (питание), GND (земля), Vs (выход). Соберем схему, как на иллюстрации (разводка для TSOP2136).

Как видишь, к аналоговому входу контроллера A0 мы подключили выход ИК-приемника.

Вот как выглядит код скетча:

#include "IRremote.h" // Аналоговый вход контроллера, // к которому подключен ИК-приемник: const int IR_PIN = A0; // Создаем объект ИК-приемник: IRrecv irrecv(IR_PIN); void setup() { Serial.begin(9600); Serial.println("ready"); // Начинаем прослушивание ИК- // сигналов: irrecv.enableIRIn(); } void loop() { // Описываем структуру results, // в которую будут помещаться // принятые и декодированные // ИК-команды: decode_results results; // Если ИК-команда принята и успешно // декодирована, то выводим // полученный код в последовательный // порт контроллера: if (irrecv.decode(&results)) { Serial.println(results.value); irrecv.resume(); } }

В скетче используется специальная библиотека IRremote.h, декодирующая сигналы самых разных ИК-пультов. Эта библиотека - открытый проект, скачать ее ты можешь со страницыhttps://github.com/shirriff/Arduino-IRremote. А чтобы ее подключить к нашему проекту, надо выполнить три действия:

каталог библиотеки скопировать в каталог libraries, который, в свою очередь, находится в инсталляционном каталоге Arduino IDE;
перезапустить IDE;
добавить в начало нашего скетча строку #include "IRremote.h".

Теперь в скетче будут доступны функции декодирования ИК-сигналов. Но, чтобы увидеть полученные коды, мы еще будем использовать объект Serial. С его помощью по последовательному порту (все тот же USB-кабель) мы будем передавать коды на компьютер. В функции setup мы выполняем инициализацию объекта Serial. «9600» - это 9600 бод - скорость, которая будет использоваться для передачи данных. После инициализации мы можем производить запись в последовательный порт с помощью функции println. Для просмотра результата этого вывода на компьютере в Arduino IDE выбери пункт меню Tools → Serial Monitor (Ctrl + Shift + M). Только убедись, что в нем установлена скорость 9600 бод.

Итак, питание контроллер получает по USB-кабелю, данные передает по нему же. Загружаем скетч, запускаем Serial Monitor и начинаем жать кнопки пульта ДУ. В окне Serial Monitor должны появляться коды. Протоколы пультов отличаются, иногда это может быть один код, иногда несколько. В любом случае ты всегда можешь выделить коды, уникальные для каждой кнопки пульта.

Нам потребуется 13 кнопок пульта. Я использовал следующие:

1 - плавный поворот налево;
2 - движение вперед;
3 - плавный поворот направо;
4 - поворот налево на месте;
5 - стоп;
6 - поворот направо на месте;
7 - движение назад с поворотом направо;
8 - движение назад;
9 - движение назад с поворотом налево;
синяя кнопка - очень медленно;
желтая - медленно;
зеленая - быстро;
красная - очень быстро.

Запиши коды этих кнопок, позже они понадобятся для скетча управления роботом.

Алгоритм движения

Скетч управления роботом доступен на странице нашего проекта (bit.ly/1dEwNDC). Не забудь изменить значения констант кодов нажатых кнопок пульта на коды своего пульта (константы IR_COMMAND_XXX_CODES в файле ir_command_codes.h).

Скетч подробно мы разбирать не будем, думаю, достаточно комментариев в коде, но один вопрос все же стоит рассмотреть.

Движения насекомых очень интересны. И хоть всем этим жукам падать до земли совсем недалеко, они почему-то всегда устойчивы: в любой момент времени минимум три ноги (две с одной стороны и одна с другой) стоят на поверхности. И пока эти ноги тянут жука к одному ему ведомой цели, три другие подтягиваются, чтобы повторить это движение. Наша задача - сделать что-то похожее.

У нашего робожука три серводвигателя, расположенные в ряд перпендикулярно движению. У левого и правого серводвигателей ось вала направлена вверх, а у центрального - вперед. Задача, например, левой сервомашинки - качать сразу две ноги: левую переднюю и левую заднюю. Они, кстати, жестко соединены между собой и приклеены к качалке этой сервомашинки. Задача центральной сервы - приподнимать то левый бок жука, то правый. Поэтому к качалке этого двигателя крепятся центральные левая и правая ноги, представляющие собой единую П-образную деталь.

Скетч должен обеспечивать движение робота вперед, назад, плавные повороты в движении и повороты на месте. А еще хотелось бы управлять скоростью жука. Чтобы описать эти движения программно, нам пригодится математика. Посмотри на схему.

Синими кружками обозначены ноги робожука, стоящие на поверхности, а белыми - находящиеся в воздухе. Обрати внимание, что при движении вперед или назад левый и правый серводвигатели должны двигаться абсолютно одинаково. А при поворотах на месте двигатели должны крутиться в разных направлениях (симметрично). Еще интересно, что движение вперед и назад отличается только фазой центрального серводвигателя.

Итак, как это реализовано? Мы помним, что контроллер постоянно вызывает функцию loop. Значит, в эту функцию мы должны поместить код, который определяет текущее положение серводвигателей и устанавливает их в это положение. Каждый серводвигатель должен совершать колебательные движения. Рассчитать положение серводвигателя в момент времени t мы сможем по следующей формуле:

X = A sin(2πt/T),

где X - искомое положение серводвигателя, A - амплитуда колебаний, T - период колебаний.

Так, в зависимости от момента времени t мы получим изменение величины X в интервале от –A до +A. Серводвигатели могут принимать положение в диапазоне от 0 до 180°. Поэтому колебания нам лучше производить вокруг «нулевого» положения в 90°. И если мы хотим обеспечить колебания с периодом 1 с вокруг положения 90° с амплитудой 30°, то формула преобразуется в следующий вид:

X = 90 + 30 sin(2πt/1000),

где t - это время в миллисекундах, прошедшее от начала колебаний. Для управления скоростью движения робожука мы можем изменять период колебаний. Чем он больше, тем ниже скорость.

А теперь еще раз вернемся к нашей схеме, потому что формула, написанная выше, еще не завершена. Как обеспечить то синхронное, то встречное движение левого и правого серводвигателя? Как менять фазу центрального серводвигателя? Мы должны добавить в нашу формулу фазу колебаний. Сдвиг аргумента синуса на величину π для, например, правого двигателя заставит его работать в противофазу левому, то есть так, как нам надо для поворота на месте. Вот как теперь будет выглядеть наша формула:

X = 90 + 30 sin(2πt/1000 + Φ),

где Φ - фаза колебаний, значение от 0 до 2π.

Посмотри на таблицу, чтобы понять, какими должны быть фазы колебаний для серводвигателей применительно к каждому типу движения.

Сборка

Теперь давай соберем робота на доске для прототипирования и зальем скетч управления.

Это очень важный этап перед сборкой. Попробуй отключить USB-кабель и запитай макет от батарейки «Крона». Проверь все фазы движения и убедись, что все работает. После сборки робота что-либо менять (например, заменить неработающий серводвигатель) будет уже сложнее.

Теперь перейдем к самой сборке. Основной несущий элемент - это батарейный отсек. Я советую использовать отсек закрытого типа и обязательно с выключателем.

Закреплять детали жука проще всего термоклеем. Начни с серводвигателей. Удали ненужные ушки креплений и соедини машинки между собой. Затем приклей эту сборку из трех «серв» к крышке батарейного отсека. Не забывай, что батарейный отсек должен свободно открываться для смены батарейки.

Контроллер проще всего приклеить к отсеку, но мне этот вариант не очень нравится, так как придется навсегда отдать Arduino Uno жуку. Поэтому можно усложнить себе жизнь и использовать разъемы Arduino для крепления батарейного отсека. На нижней части отсека приклей штырьковый разъем с шагом между штырьками 2,54 мм. Он должен располагаться так, чтобы входить в гнездо контроллера в районе цифровых выводов 8–11. Они пока все равно нам не понадобятся. Если разъема под рукой не оказалось, подойдет П-образно изогнутая канцелярская скрепка.

Провода, идущие от батарейного отсека, надо соединить с выводами Vin и соседним с ним GND. Не перепутай полярность! Плюс «Кроны» на Vin, минус на GND. Чтобы обеспечить надежный контакт проводов с Arduino-разъемами, можно просто облудить кончик провода потолще, я же как штекер использовал короткий отрезок скрепки. А место пайки закрыл термоусадочной трубкой.

Разъемы со шлейфов сервоприводов следует срезать, провода питания (+5 В - обычно красный и GND - черный или коричневый) надо объединить и вывести к гнездам 5V и соседнему с ним GND на контроллере. Подключать будем чуть позже. Провода управляющего сигнала (обычно желтый) выводим на цифровые выводы контроллера: левый серводвигатель на пин 2, центральный на пин 4, правый на пин 7.

«+» и «–» ИК-приемника можно просто вставить в разъем Arduino (5V и соседний GND). Правда, согнув пополам, удвоив их толщину. К этим же ножкам питания ИК-приемника припаиваем ранее подведенные провода питания серводвигателей. Выход сигнала ИК-приемника до аналогового входа контроллера А0 уже вряд ли дотянется, и тебе придется наращивать его проводом.

Несколько советов по изготовлению ног. Сначала подготовь левую и правую «передне-задние» ноги. Убедись в их симметричности (обрати внимание и на длины, и на углы изгибов). Начинай клеить ноги, только убедившись, что серводвигатели установлены в «нулевое» положение (90°).

Среднюю пару ног лучше устанавливай в последнюю очередь. Советую сначала сделать средние ноги длиннее, а затем после установки подрезать их до нужной длины. В «нулевом» положении все шесть ног должны стоять на поверхности. Качение средних ног с амплитудой 15° не должно мешать поворотам «передне-задних».

Что дальше?

Робожук - это готовая мобильная платформа на базе одного из самых популярных и доступных контроллеров. Проект открытый: https://github.com/beetle-ringo/arduino . Делай в GitHub форк (ответвление) и добавляй свою функциональность. Дай волю фантазии - добавь ИК-светодиод, и робот готов для робобитвы. Подключи дальномеры, тактильные сенсоры, гироскоп… Научи робота обходить препятствия или ходить по линии, попробуй установить на него веб-камеру. Идей может быть миллион, и ты всегда можешь выбирать самую интересную.