Kn34pc – arduino-радиоуправление на модел на кола
Arduino-радиоуправление на
модел на кола
/radiocopter.ru/конструкции/…
Част I: Предаване на фиксирани команди чрез
nRF24L01
Част II: Предаване на пропорционални команди чрез nRF24L01
Част III.A: Радиоуправление на модел на кола с nRF24L01
Част III.B: Радиоуправление на модел на кола с nRF24L01
Част IV: 2WD, 2Motors, 2Servos RC Car,
радиоуправляем модел на кола с nRF24L01
Посвещавам тази статия на моя приятел
Николай Др. Николов, с когото направихме
много устройства в моделистиката в младежките ни години.
В моделистиката често са необходими освен пропорционални команди, така и
фиксирани команди. Например: да включите светлини или клаксон на кола, да
завъртите оръдие на модел на танк или да го накарате да “гръмне”.
Оказа се, че в моята любима библиотека интернет има подобни проекти, но главно с
цел обучение и практика. След като отделих цял ден в търсене на подобни проекти,
накрая се оказа, че в действителност има само един такъв, който е мултиплициран
и модифициран от двама-трима автори. Проектът онагледява изпращане на команда
от една Arduino платка към друга чрез натискане на бутон в предаващата, а
включване/изключване на светодиод в приемащата.
Естествено беше да изпробвам този обучителен проект. И каква беше изненадата ми
и неприятното чувство, когато още при проверката се установи грешка. От
практиката ми, се оказва, че неведнъж съм се натъквал на такива, бих ги нарекъл,
“кухи” проекти в интернет сайтове. Разбира се, ядосах се, и тогава реших да
публикувам моя статия на същата тема – без скрити кодове, без условности, без
преднамерени “грешки” – с четири команди и четири светодиода.
След това реших да отделя повече време и да разгледам в подробности
публикуваните кодове, за да ви покажа необходимите корекции за да стане той
работещ. Той има за цел да покаже основния програмен код за предаване на една
команда от бутон в предавател чрез nRF24L01 към приемник, в който командата се
реализира визуално с включване и изключване на LED светодиод. Този проект може
да намерите на няколко web сайта, но най-добре е описан в
[2]:
За предаване на данните се използва дума, байт, наречен msg(0). В предавателя,
след инициализиране на вход за бутон, на неговото състояние, както и при какво
ниво следва да предава това състояние, то на това състояние се определя стойност
111, което число се изпраща към приемника с msg(0). В приемника се получава
думата msg(0) след което с няколко програмни реда се извлича числото 111 и то
служи като команда за управление на светодиода.
Обръщам внимание, че ако просто направите copy-paste на публикуваните кодове за
предавател и приемник, няма да постигнете никакъв резултат. Необходимо е да
въведете правилния синтаксис за инициализация на библиотеките.
Тоест, вместо:
#include “nRF24L01.h” следва да бъде: #include <nRF24L01.h>
#include “RF24.h” следва да бъде: #include <RF24.h>
И все пак, чисто методично статията има своето значение и аз силно препоръчвам
да я прочетете и изпробвате кодовете, които може да вземете от архива в моята
статия с нанесените поправки.
Цитираните по-горе кодове са с илюстративна цел. Те не отчитат лошите контакти
на бутоните, че натискането на един бутон е съпроводено често с много импулси
поради тях. За да се избегне ефекта от ненадейно случайно преминаване през
състоянията включено/изключено в Arduino IDE е съобразена специална команда за
работа с тактилни бутони, на чието използване може да обърнете внимание в
приложените в архива мои скечове. Описанието на тази и други команди може да
намерите на официални сайт на Arduino:
Debounce:
https://www.arduino.cc/en/Tutorial/Debounce
Тази команда се използва заедно с millis(). Тя има за цел в кратък период от
време да провери повторно състоянието на натиснатия бутон за потвърждение на
неговото състояние: включено/изключено. Как се отразява това практически –
именно едно натискане на бутона съответства само на една команда и не се влияе
от трепкането и лошия контакт.
В архива към статията предлагам три комплекта кодове за предаване на една, три и
на четири команди. Накратко принципът е следния:
Предавател:
a) включваме необходимите библиотеки.
b) наименуваме си байт чрез който ще предаваме данните “TxRx”.
c) инициализираме входовете на Arduino към които свързваме бутоните.
d) отваряме канал за предаване чрез модула nRF24L01.
e) всяка команда директно чете състоянието на бутона и го записва в TxRx.
f) предаваме данните чрез командата:
bool ok = radio.write(TxRx, sizeof(TxRx));
която означава, че ако в байта има данни, то те се предават чрез думата “TxRx”
към nRF24L01.
Приемник:
a) Действията от първите три подточки на предавателя са същите.
b) Отваряме канал за приемане чрез nRF24L01.
c) Проверяваме дали радиото приема и ако е така инициализираме четене на байта “TxRx”
d) Следва цикъла който чете за всеки светодиод поотделно своята си дума TxRx[…],
дали е или не е включен светодиода и команда за включване
digitalWrite(led,
ledOn);
Чрез оформяне на последователни цикли се разчитат съответните команди, идващи с
номерацията на носещата дума “TxRx[…]”
Зажележка №1: последователността на номерацията на думите в предавателя трябва
да бъде в съответствие с последователността на номерацията в приемника за да се
осигури последователност и сигурност на командите.
Забележка №2: възможно е броя на думите в предавателя да бъде по-голям от броя
на думите в приемника, но обратното не е възможно и води до объркване на
последователността на командите и нестабилно случайно включване.
Ако проследите моите кодове, ще видите, че двете забележки са изпълнени.
Например: броя на думите, които съответстват на командите в предавателя са шест,
а в приемника са програмирани три (в единия код, четири в другия) но стриктно е
спазена последователността им – 1, 2, 3.
Забележка №3: определят се броя на думите според броя на командите като TxRx[6],
но тяхната последователност започва с TxRx[0] и задължително завършва най-много
с TxRx[5], тоест нулата “0” е значещо число (0-5).
Забележка №4: в предавателя след инициализацията на определен вход за бутон, не
използвам последователен резистор към захранването каквато е дадената схема в
посочената литература. Използвам възможностите, които дава Arduino, а именно
поставям входа във високо състояние, следователно директното свързване на бутон
от входа към маса ще сменя това състояние от високо в ниско:
pinMode(3, INPUT_PULLUP);
Забележка №5: в приемника нарочно, с експериментална цел, използвам
възможностите на Arduino да инициализа аналоговите входове в цифрови. За целта
инициализацията има следния вид:
int led1 = 14;
където номерацията “14” съответства на последователността на аналоговите изходи
като цифрови на Arduino:
А0 = 14;
А1 = 15;
А2 = 16;
А3 = 17;
А4 = 18;
А5 = 19;
Същото не е валидно за останалите изводи А6 и А7.
Всъщност, идеята да тествам работата на аналоговите входове на Arduino като
цифрови, съвсем не беше случайна. Тестът е свързан с факта, че Wi-Fi модула
nRF24L01 използва пет цифрови извода, с което количеството им спада почти
наполовина, а за моите проекти са ми необходими колкото се може повече. От друга
страна, както знаете, цифровите изходи с ШИМ за Arduino UNO и Nano са 3, 5, 6,
9, 10, 11 и очевидно nRF24L01 “унищожава” 9, 10, и 11. За да се справя с този
проблем и увелича полезните изводи с ШИМ програмирам свързването на модула чрез
изводи 7, 8, 11, 12 и 13, като по този начин освобождавам още два изхода с ШИМ,
които замествам със 7 и 8. Но губя тях.
Е, то угодия няма, нали? И тогава се
оказа, че мога да допълня количеството на цифровите изходи като взема от
аналоговите, които не са ми необходими.
Надявам се тази статия да ви е полезна. Накрая искам да добавя, че описания
принцип на предаване на команди може да се използва и за други несложни
механизми, в противен случай ще ви се наложи това да стане с масиви от данни,
което не е обект на този материал. Аз, самият, не съм достигнал до това ниво.
А сега ще ви покажа с няколко снимки как изглежда “опитната постановка”, както
поотделно на двете части от нея, така и заедно при изключено и включено
състояние. За улеснение съм запоил светодиодите и последователните на тях
резистори от 220 Ω директно към платката. Конструкцията, както може би
забелязахте е с две платки Arduino Nano. Едната е монтирана за предавател на
елементарна печатна платка, а другата като приемник на шийлд за Arduino Nano.
Ето заедно:
Със следващите няколко снимки ще илюстрирам работата на описания (комплект)
програмен код.
И все пак, силно препоръчвам да изпробвате работата на този код. Ще останете
доволни.
Архив с Arduino
.ino файлове:
one_button_plus_led.zip [zip,ino][2kb]
three_buttons_plus_leds.zip [zip,ino][2kb]
four_buttons_plus_leds.zip [zip,ino][2kb]
Подаването на командите с бутони е плавно, меко, няма присветвания или
моментни резки промени на състоянията включено/изключено. Аз, лично, тествам
всеки код, който ми се струва интересен. Една част от тях не “тръгват” от първия
път, но с малко мислене, внимателно вникване в чуждата идея успявам да
възстановя тяхната работа.
А ето сега в няколко последователни снимки може да видите визуалния ефект от
включване и изключван на светодиодите в приемника в зависимост от подадената от
предавателя команда:
Благодаря на Александр за основата на кода (http://sadeb.ru/).
***
След като разгледах принципа и
програмния код за предаване на команди от тактилни бутони, които в приемната
страна след декодиране се онагледяваха с включване и изключване на светодиоди,
сега ще разгледам предаването на пропорционални команди със същия Wi-Fi модул.
За разлика от предаването на фиксирани команди, които се прилагат към аналогови
или цифрови входове на Arduino и имат логически характер само с две нива, “0”
или “1”, предаването на пропорционални команди се осъществява чрез изменение на
входното ниво на даден аналогов вход, което в приемната част се декодира и за да
бъде командата пропорционална (да съответства на завъртането на оста на
потенциометъра в предавателя) се използват цифровите изходи с ШИМ (широчинно-импулсна
модулация). Разбира се и подходящи за целта изпълнителни механизми, като
например сервомотори, сервомашинки и др. Трябва да имаме предвид техническите
характеристики на Arduino Nano, а именно че при осъществяване на приемната част
изводите с ШИМ (PWM) са шест – 3, 5, 6, 9, 10 и 11. За този проект тези
ограничения са спазени, тъй като ще използваме пет сервомашинки, а един изход с
ШИМ остава свободен.
Аз ще илюстрирам експеримента, описан в тази статия, чрез сервомашинки, които
лесно се намират на пазара и са достатъчно евтини. И бих искал да подчертая, че
всеки, който използва този програмен код лесно би могъл да го преработи според
своите проекти и изисквания.
И сега малко
разяснения на програмния код в предавателя и приемника.
Както казах вече няколкократно ограниченията, с които се сблъскваме при
осъществяване на по-големи проекти с много допълнителни модули, идват от
спецификациите на процесора. И пак искам да повторя – моята цел е да покаже
възможностите на Arduino, поради което НЕ използвам разширителни платки (експандери
като PCF8574).
– Комуникацията между предавателя и приемника се осъществява чрез Wi-Fi модула
nRF24L01, който от своя страна изисква включването на оперативната библиотека
RF24.h (nRF24.h).
– Предаването на данни се извършва чрез байт, чието наименование е vit[5], като
всяка една команда е номерирана и тъй като “0” е значеща цифра, то номерацията е
N=n-1, тоест с единица по-малка. Тоест, за байта vit[5], съответните команди се
предават чрез vit[0], vit[1] и т.н. до vit[4].
– В приемника данните от същия байт се приемат и се извличат отделните команди.
За улеснение съм направил пълно съответствие като, например, първата команда
vit[0] носи информация за pot1 (потенциометър 1) и управлява Servo1.
И в предавателя и в приемника използвам командата за мащабиране map(). В
предавателя: чрез нея поставям крайните стойности за потенциометрите, свързани
към аналоговите входове на Arduino, а приемника: мащабирам крайните стойности за
изпълнение от серво механизмите.
В предавателя:
pot1 = map((analogRead(A0)), 0, 1023, -225, 225); //servo 1
В приемника:
pot1 = map(pot1, 0, 1023, 80, -250); //80-центриране; -250-обхват
Забележителното е, че посоката на движение на механизмите може да се променя
само чрез един минус или плюс при мащабирането на крайните стойности.
Храдуерното изпълнение е също опростено. Модулът nRF24L01 се свързва в
предавателя традиционно към изводи 9, 10, 11, 12, 13, а в приемника
нетрадиционно към 14, 15, 11, 12, 13, като по този начин освобождавам изходи 9 и
10, които са с възможност за ШИМ. Обръщам внимание, че първите два извода (9,
10) могат да бъдат избираеми. По този начин получавам възможност за по-пълно
използване на ШИМ:
servo1.attach(3);
servo2.attach(5);
servo3.attach(6);
servo4.attach(9);
servo5.attach(10);
Разбира се на снимките, които след малко ще покажа, изпълнението на предавателя
е върху печатна платка, но всъщност използвам една от по-старите платки за
предавател от друга конструкция. С това доста улесних “събирането” на монтажа.
Потенциометрите запоих директно за изводите на Arduino платката и с това си
спестих много кабели за връзка. Но в приемника нещата не стояха по същия начин.
За радост си бях купил една платка за монтаж на Arduino Nano, която се оказа от
полза. Единствено трябваше да си изработя сам кабел за връзка между Arduino и
Wi-Fi модула nRF24L01. Но ето как изглеждат предавателната и приемната част на
този малък проект:
Предавателната част:
Приемната част:
На следващото видео може да видите демонстрация на работата на програмния код в
комплекта предавател–приемник.
tx_servo_5.zip [zip,ino][1kb]
rx_servo_5.zip [zip,ino][1kb]
***
В края на последната си статия посветена на един мой проект
за “Управление на модел на танк по радиоканал” с използване на модул на 2400 MHz
(Част III), засегнах така нареченото пропорционално управление или както
простичко го представих: “скоростта се променя в зависимост от педала на газта”.
С тази статия ще представя следващия си проект за пропорционално радиоуправление
на модел, но този път на автомобил. Разликата в управленията на танк и кола са в
премахването на един мотор и въвеждането на серво-машинка или още известна в
моделистиката като “рулева” машинка. Последната се използва за плавно управление
на волана, тоест на ъгъла на завоя на предните колела.
Началото е винаги трудно и започва с намиране на подходящите
за целта модули, но след като проекта “отлежи” в главата и мислите се подредят,
идеята се избистря и идва началото на осъществяването му. Намирането на подходящ
модел на кола също е трудност, а и не е необходимо да бъде скъпоструваща. Ето
така намерих моя модел. За разлика от други мои статии, в които показвам
последователно пътя на осъществяването им, тук с две последователно снимки ще
покажа направо шасито опразнено от оригиналните части след нея с монтирана моята
печатна платка с Arduino и драйвера за мотор SN754410 (L293D) :
На първата снимка може да видите шасито на колата почти в
първоначален вид, от което съм свалил всички излишни оригинални модули, които не
са необходими за моя проект. На мястото на управлението на волана съм монтирал
рулева серво-машинка, чиято ос е съединена с кормилната щанга посредством
най-обикновен добре оразмерен меден проводник с подходящо сечение (0,9…1,0
мм).
На следващата снимка е показано шасито на модела в почти
завършен вид, като остава да се свърже драйвера SN754410 с мотора, който съм
запазил от оригиналната конструкция:
Следват снимките на завършения с окабеляването модел:
Най-трудната част от механичната преработка беше монтажа на рулевата машинка (серво). Първо трябваше да й намеря подходящо място, леко
отместена от центъра за да има достатъчно разстояние от нейната ос до окачването
на кормилната щанга. След като първо подредих елементите върху шасито за да
намеря тяхното точно разположение, ги фиксирах с по една капка моментно лепило,
което ми помагаше да получа твърда конструкция върху която да продължа
надграждането. От друга страна, залепването не е критично, така че ако бях
допуснал грешка лесно можеше да я поправя. Оказа се, че съм работил прецизно и
разлепване и донагласяване не беше необходимо. Ето как изградих кормилното
управление с рулева серво-машинка на предните колела:
Както казах по-горе, запазих оригиналното задно окачване и
електромотора, който го задвижваше. Възползвам се от наличните възможности,
които позволяваше шасито, включително от наличие на кутия за 5 броя батерии
размер АА. Вида на задния мост е показан на следващите снимки:
Вече споменах, че за този проект съм избрал интегралния драйвер за управление на постояннотоков електромотор SN754410. Той е пълен
еквивалент на известния L293D, но с подобрени технически характеристики.
Сравнение може да направите от приложените datasheets.
Но ако искате да се презастраховате, защото, например, не знаете електромотора,
който сте избрали с каква консумация на ток е, препоръчвам по-мощния драйвер за
мотори L298D.
За да избегна смущенията (искренето), които предизвиква
колектора на мотора при въртене се наложи да направя импровизиран филтър
паралелно на изводите му с два керамични кондензатора по 100 nF, като единия им
край запоих за корпуса на мотора, който следваше да замася:
Според оригиналната конструкция на шасито, избрах място за
бъдещата печатна платка, оразмерих я, а след това направих същото с подходяща
кутия за бъдещото дистанционно управление, поръчах платките за изработка. След
две седмици те бяха готови и седнах на работната маса. Ето каква красота се
получи:
След завършване на окабеляването между отделните модули в
бъдещата кола, тя придоби следния вид:
И накрая остана да намеря подходяща кутия за дистанционното
управление. В повечето фабрични модели дистанционното управление е с размери
около 120 х 80 мм. Размерът изглежда е избран по чисто биологични причини –
идеално пасва в ръцете на човек, независимо дете или възрастен. И аз се насочих
към приблизително същия размер за кутия.
А ето и дистанционното управление на модела:
И след като направих тестовете на радиоуправляемия модел в още незавършен вид,
дойде момента да го “събера” в кола. И все пак по-интересно ми беше докато можех
да наблюдавам и се възхищавам на движението на механиката – рулевата серво-машинка, която въртеше волана за завой наляво или надясно,
движението напред-назад на задния мост.
По време на практическата изработка и тестовете установих, че оригиналния
редуктор на модела прескача на определена позиция и след като го отворих,
забелязах, че една от зъбните предавки е с един счупен зъб (или просто фабрично
е отсъствал). Тогава реших, че е по-бързо да заместя редуктора с нов,
закупих такъв с предавателно число, което осигуряваше около 200 оборота в
минута. По този начин скоростта на модела се запазваше.
Но ето как изглеждаше модела с този редуктор:
Но моята цел беше да използвам изцяло модела на кола в
неговия оригинал. И така една вечер след един уморителен работен ден, седнах на
работната маса за да се разтоваря от ежедневието и разглобих редуктора на
колата. Именно тогава установих липсата на един зъб от предавката. В първия
момент почти реших да оставя колата в горния вид, но като поставих кабината
върху шасито се оказа, че тя опира в колелата, които бяха с 6 мм по-голям
диаметър. Тогава се заех с ръчната поправка на оригиналния редуктор. Трябваше да
попълня мястото на липсващия зъб с друг, който се налагаше да измайсторя. Взех бормашинката и със свредло с Ф = 1 мм аксиално пробих отвор точно в средата
между двата зъба с дълбочина до оста на зъбното колело.
Разбира се, изискваше
изключителна прецизност за да улуча точно в средата помежду им. След това
отрязах парченце меден емайлиран проводник с Ф = 0,85 мм, което вкарах в готовия
отвор, подравних неговия връх по височина с останалите зъби. С една триъгълна
часовникарска пиличка оформих върха във формата на триъгълник и импровизацията
заприлича съвсем на истински зъб. След като завърших с тези фини операции
внимателно с моментно лепило (“Момент”, “Капчица” или “Каноконлит”) фиксирах
новия зъб и го оставих да съхне 24 часа. На следващата вечер сглобих отново
оригиналния редуктор, изпитах въртенето му при различни обороти както напред,
така и назад. Останах доволен от резултата и тогава отново го монтирах на
колата.
Завършения модел на колата след пълното сглобяване придоби
следния вид:
От огромно значение за правилната работа на двигателите е
правилния избор на драйвер за мотор. Преди всичко за да пуснем в движение
електромоторите трябва да знаем техния ток на консумация при нормално
натоварване и при товар близък до спиране на мотора. Обикновено разликата между
тока на продължителна работа и пиковия ток е до 3-4 пъти. Но за да издържи
максималния ток на товара, самата интегрална схема драйвер за мотор трябва да
отговоря на тези параметри. Производителите обикновено публикуват тези значения
на консумирания ток и би следвало още преди да си изберем мотори и драйвери да
се съобразим с техническите им характеристики. Например, ако консумирания ток на
електромотора със средно натоварване е около 0,2-0,5А, а задържайки оста на
въртене тока се повишава до 0,8-1,0А следва избрания от нас драйвер за мотор да
отговаря на тези изисквания. Моята практика установи, че тока, максималното
захранващо напрежение и максималната разсейвана мощност имат пряка връзка.
Например, най-нежния от използваните в моите конструкции драйвери се оказа
китайския L9110. При еднакви условия с други драйвери, независимо, че съм го
захранвал с подходящо напрежение (12V) при пуска на моторите той “изгаряше”
буквално за 4-5 секунди, докато при захранващо напрежение 9V работеше
безупречно.
Поради горната забележка, появила се след натрупания опит от
експериментите ми в конструкциите на радиоуправляеми модели на танк и кола,
реших да ви дам сравнителна таблица на най-важните параметри на моторни
драйвери, които най-често се намират на пазара у нас:
В модела на кола, който съм показал на снимките по-горе
използвам единият от двойния драйвер за мотор SN754410:
На входа “Enable” подавам командите от ШИМ на Arduino. Чрез
командите на “Input_1” и “Input_2” сменям посоките на въртене на мотора, с което
осъществявам движение на модела на колата напред-назад, а с ШИМ управлявам
скоростта. В западните публикации може да срещнете определението “Speed
Controller”, съответстващо на този начин на управление на мотори.
Както се вижда от снимките по-горе, Arduino опростява
изключително хардуера на едно радиоуправление. Практически, както дистанционното
управление с предавател, така и приемната част, имат по няколко елемента/модула
като основната функция се изпълнява от процесора на платките Arduino.
Приемната част съдържа платка Arduino, радиомодул и драйвер
за мотор, като последния може да бъде един от описаните в таблицата по-горе.
Печатната платка е съобразена с геометрията на избрания от мене модел на
радиоуправляема кола.
Предавателя съдържа платка Arduino, джойстик (по ваше желание
може отделни за командите напред-назад, наляво-надясно), ВЧ трансивер с модул
nRF24L01, работещ на 2400 MHz и няколко кабелчета, с които се осъществяват
връзките помежду им.
Следващата схема изпълнена с програмата на Fritzing дава
представа за дистанционното управление и неговото изпълнение:
Подобна е схeмата на приемната част, в която също основния
модул е платката Arduino в комбинация с радиомодула nRF24L01 и моторния драйвер,
независимо, че е показан L298D:
Със следващото видео демонстрирам движението на готовия
модел.
Добавяне на фиксирани команди:
След като завърших този успешен проект, се замислих дали не
мога да добавя още команди за изпълнение към програмния код. Засега наличните
команди бяха: напред-назад, наляво-надясно. Но трябваше да се съобразя и с
останалите свободни цифрови пинове в приемника. Досега заетите бяха: един за
серво-машинка, три за пропорционално управление на мотора и пет за ВЧ модул
nRF24L01, тоест всичко девет от общо тринадесет цифрови пина на Arduino.
1. В предавателя добавих сензор за изтощаване на батерията LOW BATT. Като индикатор свързах червен светодиод, който трябваше да светне при
спадане на напрежението на батерията до 5,5V. Избрах тази стойност, тъй като
съгласно техническите характеристики на използваната микропроцесорна платка
Arduino Nano V3, тя запазваше работоспособността си в интервала 6V-12V.
За целта инициирах аналогов вход А7, на който включих резистивен делител 3,3 kОм и 2,2 kОм, съответно 3,3 kОм към батерията и входа, а
2,2 kОм между входа и маса. Както виждате общата стойност на резисторите е 5,5
kОм, което веднага означава, че при спад на напрежение на батерията до 5,5V, на
входа А7 ще се подаде потенциал 2,2V. Като имаме предвид, че аналогово-цифровия
преобразувател е с 1024 стъпки, това означава, че на една стъпка отговаря
напрежение 4,88 mV. Следователно за да се детектира на входа напрежението 2,2 V,
следва да програмирам 450 стъпки (450 х 4,88 mV = 2,196 V).
В програмния код включих няколко реда, с които детектирам
това напрежение на аналогов вход А7 и ако то е по-малко от 2,2V на цифров изход
D2 се подава високо ниво HIGH, а директно към D2 е свързан светодиод към маса
през резистор 330 Om.
Опростено, тази функция може да се представи по следния
начин:
If U(A7) < 2,2 V, то тогава D2 = LOW, ако НЕ, то D2 = HIGH
Освен сензорът за ниско напрежение на батерията, добавих две
фиксирани команди с бутони. Така си осигурих развлекателни опции като включване
на фарове и габарити (или каквито други би могло да ни хрумне). Това са
цифровите пинове D4 и D7. Двата пина са програмирани да се инициализират при
високо напрежение (INPUT_PULLUP), така че бутоните да се свържат към маса и
командата да бъде превключване към ниско ниво.
Всички команди се предават чрез думата TXword[4], където [4]
е броя на командите.
2. В приемника добавих няколко реда в кода, с които да детектирам изпращаните от предавателя двете допълнителни фиксирани команди. И
тук използвам думата TXword[4], която се изпраща от предавателя. При
детектирането й, изваждам всяка една от командите на цифровите пинове D3-D8. И в
приемника ВЧ модул е свързан към същите пинове D9-D13. Цифровите пинове, за
които се свързват серво-машинката (D3) и пропорционалното управление на мотора
ENB (D5) са избрани с ШИМ, за да бъде това възможно.
Накрая чрез този програмен код моделът на радиоуправляема
кола придоби достатъчно на брой команди, които всеки може да използва за
различни цели. Аз, лично, предпочетох атракциите със светлини.
Архив: rx_tx_nrf24l01 [zip,ino][2kb]
***
Акцентът в тази статия е върху механичната преработка на
модел на кола, който съм превърнал от една елементарна механична играчка в радиоуправляем модел.
Преди много години недалече от Централна поща се намираше
Културния център на бившата Германска Демократична Република. Веднъж през 1985
година, разхождайки се из центъра на града, се отбих в него, просто да погледам
и поразсея. Така забелязах една детска играчка, лека кола с кабелно дистанционно
управление и веднага си я купих.
В последствие тази кола се превърна в базов модел за моите експерименти в моделистиката, с които ме зарази колегата ми и приятел Николай. Много бързо
направихме предавател с ШИМ модулатор и приемник с радиоуправлние на 27Mhz,
които публикувахме по-късно в няколко статии в списание “Радио, телевизия и
електроника” / 1988 г. Тази играчка влезе в игрите и на моето малко момиченце,
като аз управлявах колата, а тя возеше в нея куклите си Барби и техните
куфарчета от и до импровизираните “автогара” и “ж.п. гара”. Е, тя порасна, но аз
продължих да си играя. Един ден, много по-късно в годините, видях друга
подходяща детска кола – Мерцедес, която също купих. Преработих я като прехвърлих
в нея радиоуправлението от жълтата германска кола. (Мерцедесът все още
съществува и работи).
А сега, когато вече опознах възможностите на Arduino, се сетих отново за старата
жълта количка. Един ден се качих на тавана, извадих частите й от кашона и
започнах с носталгия да ги сглобявам. Количката заприлича на показаната по-горе
на снимките. Тогава ми хрумна да я възстановя заедно със сладките си спомени от
детските години на дъщеря ми и да я направя с Arduino управление.
Ето такава е историята на настоящия проект, в който няма нищо
ново като програмен код, освен спомените за едно безвъзвратно отминало време.
Преработките, които съм направил, бих могъл да класифицирам в
следните направления:
А) преработка на предния мост и добавяне на кормилно
управление със сервомеханизъм
Б) преработка на задния мост с добавяне на подходящ
електромотор и редукция
В) електронно управление с Arduino
1. Преден мост.
Предният мост трябва да управлява посоката на движението на
модела. За целта ми беше необходимо сервоуправление и подходящо окачване на сервото към кормилната щанга. Но за съжаление, оригиналът не изпълняваше такива
функции и се наложи сам да изработя кормилна рейка, която се явяваше свързващото
звено между предния мост и сервомашинката. Решението беше изключително простичко
– едно парченце меден проводник от електроинсталация 3 х 1,5 кв. мм. подходящо
огънато и закрепено към кормилната щанга и сервомашинката:
Ухото в левия край на рейката служи
за закрепване към кормилната щанга, а засечката на 90 градуса за закрепване към
сервото. И двете части имат малък луфт за да осигурят свободното движение на
сервото, рейката и кормилната щанга. Ухото се нанизва върху предварително
закрепено винтче М2 закрепено перпендикулярно на щангата, а засечката в един от
фабричните отвори на сервомеханизма, който също предварително е разширен до Ф =
1,5 мм. Реално проводникът е с Ф = 1,3 мм. Може сами да направите изчислението,
като имате предвид, че сечението е S = 1,5 кв.мм., а всъщност ето готовия
отговор – 1,23 мм. Така се осигурява достатъчно свобода на движение на рейката в
отвора на сервомашинката. Може би се питате защо вземам подобни предохранителни
конструктивни мерки – защото трябва да превърна въртеливото движение на сервото
в постъпателно движение на кормилната щанга, тоест от движение в полукръг в
линейно движение и така да осигуря завъртане в ляво и дясно на предните колела и
промяна на посоката на движение на модела.
Ето как осъществих горната промяна в конструкцията на модела:
И при този модел, както в предишния, фиксирах сервомашинката с две капки
моментно лепило за да мога да извърша механичното закрепване и настройка на
дължината на кормилната рейка от меден проводник. След като завърша окончателно
модела, ще закрепя сервомашинката с допълнителна планка, която ще заздрави
конструкцията, но за тези настройки тя не е необходима.
На следващите снимки съм показал управлението на предния мост
заедно с шасито на модела на кола, чиито размери съм имал предвид при
осъществяване на преработката на конструкцията:
Както се вижда от горните снимки, постъпателното движение на
кормилната рейка се осъществява без затруднение в пространството между калниците
на предните колела. В пространството над рулевата (серво) машинка ще монтирам
платката, която вмества Arduino и високочестотния модул за радиоуправление
nRF24L01.
С това най-трудната част от преработката на модела е
осъществена и преминавам към:
2. Заден мост.
Основната преработка на задния мост е редуктора и е свързано
с установяване на такива обороти на задната ос, че движението на модела да бъде
със скорост около 5 км/час, така че модела да може лесно да се управлява както
от дете, така и от възрастен. Тази преработка се наложи поради прекалено бързото
движение на модела с оригиналните зъбчати колела. За да намаля скоростта се
наложи да увелича предавателното число на предавката. Това водеше неминуемо към
разместването на зъбните колела. Най-голямата трудност, с която се сблъсках беше разпробиването на нови отвори в металната конструкция за оси на зъбните колела.
Тук наистина страдах от точност – бургията се хлъзгаше по повърхността и се
наложи да разпробия първо с много тънка, а след това с по-голям диаметър докато
достигна до желания размер. За да се случи всичко това, първо наредих върху един
бял лист А4 всички зъбни колела, очертах ги, измерих разстоянията между осите,
преброих броя на зъбите и преизчислих предавателните числа. Така се наложи да
сменя още веднъж зъбните колела с друг брой зъби. На следващата снимка съм
показал преработения редуктор, като на него рязко се отличават по цвят
добавените зъбни колела:
А ето изглед на редуктора от две страни:
Електромоторът, който монтирах е със захранващо напрежение
12V, но работи при спад на напрежението до 6V. На неговите изводи съм запоил
филтриращи кондензатори 2х100nF/63V, а корпусът на мотора ще заземя (за общия
минус). Ето окончателния вид на конструкцията на задния мост:
Върху тази конструкция отново съм монтирал шасито, което
покрива механизмите и придава допълнителна якост на конструкцията:
3. Електронно управление.
Механиката вече е готова, но колата все още не. Оставащото
възможно място е твърде малко и след внимателно замерване успях да включа в него
електронната част, състояща се от приемник nRF24L01, Arduino Nano, драйвер за
мотори TB6612. Последния управлява два мотора, от който аз използвам половината.
Драйверът позволява управление с ШИМ, което удовлетворява моите изисквания за
въвеждане на пропорционалност в управлението (тоест, по-бавно или по-бързо
движение на мотора). Но ето и вида на електронната част след като получих
печатната платка:
Следва видът на печатната платка, върху която са монтирани
основната част от елементите и модулите:
На следващите снимки съм показал свързването на електронното
управление към останалата механическа част на колата – сервомашинка и двигател.
В този вид колата вече беше в работно състояние и проведох първите експерименти
за работоспособност. В този вид извърших настройките на центъра на рулевата
сервомашинка така, че в първоначално състояние предните колела да застанат в
състояние на права посока :
В този вид, нетърпеливо закачих батериите и изпробвах колата.
Останах доволен от резултата и реших да продължа с довършителните дейности по
сглобяването й до завършен вид. От конструктивна гледна точка моделът на колата
е “измислен” добре – шаси, две половини на кабината. Именно с тях трябваше да
продължа.
Ето и полуготовия й вид:
Дори и в този полуготов вид колата беше годна за употреба. Окабеляването между платките, батериите и мотора отзад направих по канала,
образуван от кардана, върху който е импровизирания скоростен лост. Цялата
електронна част съм монтирал в отсека между двата предни калника като драйверът
за мотори TB6612 е под платката с Arduino и nRF24L01.
А на следващите снимки е окончателния вид на модела:
Схемите на
свързване на платките са същите,
като единствено е сменен драйверът за мотори. Изходите за управление на драйвера
са цифрови пинове 5, 6 и 7, които се свързват към входове АIN1 и AIN2 на
драйвера ТВ6612, като по-специално pin 5 се свързва към вход PWM. Съответно
изходите за електродвигателя са на AO1 и AO2. Входoве STBY и VCC се свързват към
5V на Arduino платката, а VM към батерията с която се захранва колата. Модулът
TB6612 може да се намери в различни разновидности, които много си приличат.
Ето
две от тях, като аз съм използвал първата:
С цел предотвратяване на смущенията от колектора на двигателя
съм замасил корпуса му към минуса на схемата, а паралелно на изводите съм запоил
два кондензатора по 100nF към корпуса му.
Прилагам два файла с графични оригинали, които са по-скоро за
ориентир, тъй като те са направени спрямо геометричните размери на конкретната
кола:
pcb_arduino_car_2.zip [zip,pcb][16kb]
Използваният програмен код е различен, но запазва основната идея и
функционалността му:
rx_tx_nrf24l01_2.zip [zip,ino][2kb]
Може да намерите в интернет радиоуправляеми модели в
най-различни изпълнения, освен описаните от мен по радиоканал с модул nRF24L01.
Например чрез блутут или смарт телефон с ОС Android.
***
Целта на този проект е максимално използване на цифровите изходи на Arduino. За
управлението на един модел е важно използването на цифровите изходи, позволяващи
ШИМ (PWM), а именно D3, D5, D6, D9, D10, D11. Но първото ограничение идва от
употребата на високочестотния модул nRF24L01, който използва за връзка с Arduino
пет цифрови извода – D9, D10, D11, D12, D13.
След внимателно обмисляне на възможностите които позволява Arduino, най-после
идеята за проекта придоби следния вид – радиоуправление на модел на кола чрез ВЧ
модул, задвижване на два мотора, управление на сервомашинка за посоката на
движение, управление на сервомашинка за въртене на светлини, включване и
изключване на предни светлини, включване и изключване на задни светлини (или
габарити), използване на ШИМ изводи за управление на скоростта на моторите.
Изходите за серийна комуникация D0 и D1 не се използват за да не се нарушава
серийния порт за връзка с компютъра.
Очевидно е, че броят на цифровите изходи на Arduino не достигат. Затова направих
следната конфигурация на приемната част:
D0 – Serial I/O не се използва
D1 – Serial I/O не се използва
D2 – MotorL1, извод 1 на левия мотор
D3 – Servomotor L/R, ШИМ за управление на посоката, ляво-дясно
D4 – MotorL2, извод 2 на левия мотор
D5 – PWA Motor1, ШИМ за управление на скоростта на левия мотор
D6 – PWA Motor1, ШИМ за управление на скоростта на левия мотор
D7 – MotorR1, извод 1 на десния мотор
D8 – MotorR2, извод 2 на десния мотор
D9 – nRF24L01
D10 – nRF24L01
D11 – nRF24L01
D12 – nRF24L01
D13 – nRF24L01
Както и част от аналоговите изводи, но като цифрови:
А0 – цифров изход за включване и изключване на предни светлини
А1 – цифров изход за включване и изключване на задни светлини (габарити)
По този начин радиоуправлемия модел е с пет канала за управление с по две
команди, а именно:
1. Канал 1 – напред/назад
2. Канал 2 – наляво/надясно за посока на движение
3. Канал 3 – наляво/надясно за светлини
4. Канал 4 – включване/изключване на предни светлини
5. Канал 5 – включване/изключване на задни светлини (или габарити)
както и възможност чрез ШИМ (D5 и D6) за управление на скоростта на движение на
модела по-бързо, по-бавно.
Поради спецификата на командите в предавателя няма такава наситеност при
използването на изводите на Arduino:
А0 – джойстик за движение напред-назад
А1 – джойстик за определяне на посока наляво/надясно
А3 – сензор за измерване напрежението на батерията
А4 – за въртене на светлините със сервомашинка
А7 – индикатор за спадане на напрежението на батерията
D4 – свързване на Бутон за включване/изключване на светлини
D7 – свързване на Бутон за включване/изключване на светлини (габарити)
До тук разказах за идейната част на бъдещия програмен код. Но дотолкова бях
сигурен в неговата реализация, че успоредно с разработката му започнах
снабдяването с необходимите механични части за бъдещия модел на кола. Точно тази
задача се оказа бавна и трудна, но в Китай има всичко, и всичко може да се
поръча и достави на “мижави” цени. Сроковете на доставка бяха от около един
месец до два месеца, което като цяло забави реализацията на този проект. Ако за
предишните модели, описани в предходни мои статии, използвах готови играчки,
този път изцяло разработката на раиоуправляемата кола беше моя. Истински преден
мост, истински лагери, истински кормилни щанги! Ето. Това беше идеята на втората
част от тази разработка! Механичните части се продаваха на баснословни цени в
мащаб 1:8 до 1:16. Аз трябваше сам да съобразя, сам да реша. Взех правилни и
грешни решения, които в последствие се наложи да поправя. Но на края събрах
всички необходими механични части, които може да видите на следващата снимка:
Може би поглеждайки към тази снимка бихте казали – ама, нищо работа! Но не е
съвсем така – всички части са с определени размери и мащаб, така че да могат да
се сглобят и накрая да се получи модела на кола. Защото иначе, е наистина – нищо
работа. В процеса на работата по проекта се оказа, че вместо да търся кормилни
щанги за предния мост, просто мога да използвам за ос един добре почистен
електрод за заваряване Ф=2.5, от който отрязвах необходимата дължина, а после с
плашка М2.5 навих съответната резба, за която се закрепваха накрайниците за
управление.
Е, може би, точно затова този проект се проточи почти година и половина.
След тази толкова дълга подготовка, най-вече, снабдяване с необходимите
механични части, първо изработих едно експериментално шаси от текстолит с
програмата си за изчертаване на печатни платки. Беше много важно чрез него да
напасна отделните елементи при изработването на предния мост на модела на кола.
Двете предни колела трябваше да се въртят наляво и надясно напълно симетрично, а
това означаваше изключителна точност при изработването на кормилните щанги както
и щангата за връзка със серво машинката. Също така трябваше да определя
максималния ъгъл на завиване така че в крайно ляво и дясно положения колелата да
не опират в шасито с което се ограничава тяхното движение. Последното трябваше
да извърша както механически според ъгъла на завъртане на серво машинката, така
и програмно, като в същото време трябваше да спазя центрирането, така че в
неутрално положение на машинката колелата да бъдат изправени, а тя да се движи
направо. Но накрая, след доста прецизна работа, много внимание, и най-вече много
търпение, се получи:
Е, разбира се, че с нетърпение побързах да си направя подходящата печатна
платка върху която да монтирам Arduino, драйвера за мотори SN754410 (L293) и
средномощни транзистори 2N2219 (или български аналози 2T6551), чиято задача беше
да включват светодиодите за светлините за да не се свързват последните директно
към изходите на процесора, чийто номинален ток е 20mA, а максималния 40mA.
Всички връзки върху печатната платка за модулите изпълних с куплунзи, което
позволяваше бърза смяна на модули. Е, някой ще каже, че не е необходима печатна
платка, след като целия монтаж може да се направи обемен с подходящите
проводници. Аз бих отговорил – така е по-подредено, по-прибрано и по-красиво. А
и за движещ се модел – много по-устойчив на механични сътресения и удари.
Печатната платка закрепих с втулки за готовото шаси, след което намерих касетка
за две батерии размер R6 с които да извърша автономното захранване на модела.
Батериите които използвам в моделите си са Li-Ion 3,7V/1400 mA/h. Капацитетът на
батериите позволява издръжливост при интензивно натоварване около 40-50 минути,
но искам да отбележа, че частите е достатъчно за да събере и по-големия размер
батерии 18500. Ето как изглежда експерименталния модел:
Сега предстоеше създаването на истинския модел. По вече изпитания начин,
изчертах елементите на предното окачване и платката за светлините, чиято дължина
беше съобразена с разстоянието между предните колела, където щях да я монтирам:
Една доста прецизна дейност беше изчертаването на шасито на радиоуправляемата
кола. То не само трябваше да бъде съразмерно, да позволява въртене на предния
мост наляво-надясно, но и да събере електронните елементи, моторите,
серво машинките, електронната платка и батериите:
Все пак, при това описание нека да не забравяме микропроцесорната платка Arduino
и разположението на нейните изводи – аналогови и цифрови входове-изходи:
И щом погледнете схемата на входно-изходните изводи (пинове) на Arduino,
спомнете си за началото на статията и идеята за максимално използване на
изводите на Arduino. Очевидно е, че “празно” място наистина няма. Но точно по
този начин се изпълняват всички описани в началото на статията команди при
максимално използване на входно-изходните шини.
Печатната платка, която разработих е в пълно съответствие както с използваните
команди и техните Arduino изводи, така и с физическите размери на колата:
Тази платка позволява захранване на Arduino с 5V от вградения стабилизатор или
от външен интегрален стабилизатор LM7805. Също така дава възможност серво-
машинките да бъдат захранвани от друг, отделен стабилизатор LM7805 за да се
изключи влиянието на високия стартовия ток на моторчетата им върху
електрониката. Но също така е предвидена възможност, ако използваме двигатели с
напрежение над 12V (например 24 волта) да предпазим Arduino от високо напрежение
като го захраним от трети отделен за целта стабилизатор LM7810 или LM7808.
Разбира се, електромоторите също трябва да бъдат съобразени по мощност с
използвания драйвер за управление L293 (SN754410). За експеримента съм използвал
два мотора за Arduino smart car, които се захранват с напрежение 6V и
редукторите им имат подходящо за моите цели обороти – 200RPM. В процеса на
експеримента използвах и по-мощни мотори с по-голям метален редуктор, но за
съжаление бяха само 120RPM и колата се движеше твърде бавно, с което атракцията
губеше смисъла си. Но ако в бъдеще намеря такива мотори с 200-250RPM непременно
ще ги сменя, тъй като прецизността и мощността с тях е много по-висока:
И ако в експерименталния модел нямах съществени изисквания за въртящ момент към
серво машинката, за която избрах микро серво SG90S, то за този модел с габаритна
дължина 35см. се наложи да избера сервомашники с среден или голям въртящ момент,
oт 4кг/см до 13кг/см. Аз избрах Futaba S3003 и TowerPro MG996. Техните
двигатели са по-мощни и съответно стартовия ток достига 1,5А, поради което
захраних двете машинки от отделен стабилизатор LM7805.
Естествено този избор в процеса на експеримента също подлежеше на прецизиране и
като се има предвид, че едната серво машинка носи само платката с въртящите
светлини и за да получа унификация, накрая се спрях само на модела на Futaba
S3003, 4kg/cm и максимален ток до 800 mA.
Свързването на изводите според цвета на проводника е:
Чер – маса, минус
Червен – 5V
Бял – сигнал ШИМ от Arduino
Възможно е да се срещнат и други оцветявания:
Чер – маса, минус
Кафяв – 5V
Жълт – сигнал ШИМ от Arduino
И след всичко казано досега, ето най-после сглобения модел на раздиоуправляем
модел на кола с два мотора, две серво машинки, две отделни команди фиксирани
команди (светлини):
На горната снимка се виждат всички модули, свързването и монтажа им върху
шасито. Забележимо е и предното окачване, като единствено серво машинката за
управление на предния мост за смяна на посоката на движение наляво-надясно е под
платката, с което се спестява достатъчно място за други експерименти с други
модули и мотори.
Ето предното окачване с кормилните щанги:
На следващата снимка може да видите модела отпред:
Забележка: светодиодите се командват чрез буферни транзистори и се захранват
през токоограничаващи резистори със стойност 390Ω от захранването.
Резисторите определят тока през светодиодите приблизително на 18-20mA. Ако се
използват мотори за 12V, в този случай резисторите трябва да бъдат със стойност
620Ω.
Платката за светлините позволява свързването на шест светодиода, като съм
предвидил един чифт за “къси” светлини и два чифта за “дълги” светлини, като
последните имат значително излъчване, имитиращи фаровете на реален автомобил.
Със следващото видео може да се запознаете с функциите на радиоуправляемия
модел:
В интернет няма да намерите много такива проекти. А като този с пет канала на
управление, всеки с по две команди си е направо моя приумица. Но все пак нека да
спомена, че програмния код, който съм написал за този проект, представлява
разширен код на оригинала на руския любител Александр само с управление на един
мотор и едно серво:
http://sadeb.ru. Подобен на него е програмния код в
моята
статия Част I.
Архив:
rx_5_commands.zip [zip,ino][1kb]
tx_5_commands.zip [zip,ino][2kb]
pcb_2023_d.zip [zip,pcb][8kb]
1.
Arduino Wireless Laser Turret
2.
Arduino Remote Control Car (w/ Nrf24l01 and L298n)
3.
Радиоуправляемый автомобиль на Arduino
4.
Делаем машинку на радиоуправлении на Arduino Uno
5.
RF Control System for R/C Vehicle Based on Arduino and NRF24L01
6.
Make a 4WD RC Car
7. 500 схем
пропорционального управления [zip,djvu][3,2mb]
8.
Wiring the NRF24L01 2.4GHz Radio as Remote Switching
9.
Arduino Wireless Remote with 2.5GHz NRF24L01
10.
Wireless remote using 2.4 GHz nRF24L01: Simple tutorial using of nRF24L01 &
Aarduino
11.
Arduino Nano v3.0 pinout
12.
L293D [pdf][601kb]
13. SN754410 [pdf][109kb]
А ето и книгата, от която съм се учил преди много години:
14. Гюнтер Миль,
“Электронное дистанционное управление моделями” [zip,djvu][15,0mb]
Валери Терзиев
доп.
24 октомври 2023 година,
13 февруари 2023 година, доп.
17 февруари 2023 година, доп. 13 февруари 2023 година,
доп.
20 септември 2023 година, доп.
6 ноември 2023 година, доп. 28 февруари 2023
година
Машинка на радиоуправлении своими руками.
Наиболее просто реализовать радиоуправление самодельной машинкой, при этом делая что либо самостоятельно, можно используя радиомодули
NRF24L01 (можно заказать по ссылке)
, плату Ардуино
например Arduino UNO (купить по ссылке)
(или любую другую Ардуино или подобную плату). Также понадобятся драйверы для управления двигателями, можно использовать например L293D если двигатели потребляют ток до 600мА, сами двигатели, батарейки и некоторые дополнительные элементы. В рулевой системе машинки можно установить такой же линейный актуатор с шаговым двигателем которые используются в дисководах. Механика рулевой системы должна быть такой чтобы не было необходимости в большой силе двигателя для того чтобы осуществить поворот. Если поворот осуществляется достаточно легко то можно сделать полношаговое управление двигателем с использованием одной фазы на каждом шаге, если при всех стараниях не получилось сделать достаточно легко поворачивающиеся передние колёса то для решения проблемы поворота можно сделать полношаговое управление с использованием двух фаз на каждом шаге и немного увеличить напряжение питания при этом увеличиться момент и потребление тока в следствии чего батарейки будут быстрее разряжаться но зато рулевая система будет более надёжной. Для движения вперёд и назад можно использовать любой подходящий и достаточно мощный коллекторный электродвигатель постоянного тока в котором реверс осуществляется сменой полярности подаваемого на него напряжения. У большинства таких двигателей обороты слишком большие и момент слишком мал для того чтобы можно было использовать прямую передачу на колёса без редуктора (например надев колесо на вал двигателя). Редуктор можно использовать готовый или изготовить самостоятельно. Если редуктор изготавливается самостоятельно но необходимо уделить достаточно внимания его изготовлению и по возможности избежать фрикционных и ремённых передач а делать только с шестерёнками, если этого не получилось то ремённые или фрикционные передачи необходимо делать очень качественно. При изготовлении механических частей машинки для скрепления частей можно использовать цианоакрилатный клей (например
клей (можно заказать по ссылке)
) т.к. он достаточно прочно держит любые поверхности и быстро твердеет (такие клея твердеют не от высыхания а от контакта с влажными поверхностями (полимеризацию вызывает щелочная среда)). Простота изготовления электроники позволяет сосредоточиться на механике но давайте всё же рассмотрим схему приёмника:
Рисунок 1 – Приёмник
Радиомодуль NRF24L01 взаимодействует с платой Arduino через интерфейс SPI. Питание 3.3В на радиомодуль идёт с платы Arduino (в плате есть стабилизатор напряжения). На саму плату Ардуино подаётся 9В от 6ти пальчиковых батареек соединённых последовательно. Это питание следует подавать через специальный разъём (понятно из рисунка 1). На плате есть стабилизатор на 5В. Между выводом GND и 3.3В радиомодуляNRF24L01 стоит конденсатор для сглаживания пульсаций напряжения которые могут появляться например при работе двигателей. Драйверы запитываются непосредственно от батареек, один из драйверов целиком используется для управления шаговым двигателем, другой для управления коллекторным, светодиодными фонарями и пьезодинамиком. Пьезодинамик можно поставить на тот же полумост драйвера что и фонари т.к. он издаёт звуки только от переменного напряжения. Скетч в Ардуино загружается при отключенном питании. Давайте рассмотрим скетч:
#include “SPI.h”
#include “nRF24L01.h”
#include “RF24.h”
RF24 radio(9,10);
const uint64_t pipe = 0xF0F0F0F0E1LL;
char data = ‘z’;
char data_turning = ‘s’;
//20 binary 00010100
//24 binary 00011000
//40 binary 00101000
//36 binary 00100100
unsigned char arr[4]={20,24,40,36};
unsigned char counter = 0;
unsigned char out_condit = 0;
unsigned char out_going = 0;
void stepper_rotate()
{
if (data_turning == ‘l’)
{
counter ;
if(counter〉3)counter=0;
out_condit = arr[counter];
}
else if (data_turning == ‘r’)
{
if(counter==0)
{
out_condit = arr[0];
counter=3;
}
else
{
out_condit = arr[counter];
counter–;
}
}
else if(data_turning == ‘s’)
{
out_condit = 0;
}
}
void bebep()
{
for(int i=0;i〈5000;i )
{
digitalWrite(8, HIGH);
delayMicroseconds(100);
digitalWrite(8, LOW);
delayMicroseconds(100);
}
}
void setup(void)
{
radio.begin();
radio.setRetries(15,15);
radio.openReadingPipe(1,pipe);
radio.startListening();
pinMode(2, OUTPUT);
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
pinMode(7, OUTPUT);
pinMode(8, OUTPUT);
digitalWrite(2, LOW);
digitalWrite(3, LOW);
digitalWrite(4, LOW);
digitalWrite(5, LOW);
digitalWrite(6, LOW);
digitalWrite(7, LOW);
digitalWrite(8, LOW);
}
void loop(void)
{
if ( radio.available() )
{
radio.read( &data, sizeof(char) );
switch(data)
{
//мотор
case ‘a’:
out_going = 128;
break;
case ‘b’:
out_going = 64;
break;
case ‘c’:
out_going = 0;
break;
//фары
case ‘d’:
digitalWrite(8, HIGH);
break;
case ‘e’:
digitalWrite(8, LOW);
break;
//гудок
case ‘f’:
bebep();
break;
//руль
case ‘r’:
data_turning = ‘r’;
break;
case ‘l’:
data_turning = ‘l’;
break;
case ‘s’:
data_turning = ‘s’;
break;
}
}
//руль
stepper_rotate();
PORTD &= 195;//binary 11000011
PORTD |= out_condit;
//мотор
PORTD &= 63;//binary 00111111
PORTD |= out_going;
delay(12);
}
Это скетч для приёмника, в первых трёх строчках этого скетча подключаются заголовочные файлы для простой реализации связи по SPI и использования радиомодуля NRF24L01 . Следующая строка – это создание экземпляра класса “RF24”, первым параметром в конструктор этого класса передаётся номер пина Ардуино который следует соединить с CE радиомодуля а вторым параметром – номер пина который следует соединить с CSN радиомодуля. Следующая строка – это адрес канала, он должен быть одинаковым у приёмника и передатчика. Далее идёт инициализация переменных. В переменную “data” записывается принятый по радио символ. В переменную “data_turning” записывается символ который определяет будет ли вращаться ротор шагового двигателя рулевой системы и если да то в какую сторону. Далее идёт массив состояний порта для управления шаговым двигателем. Переменная “counter” вспомогательная для функции управления шаговым двигателем. Дальше идёт функция управления шаговым двигателем “stepper_rotate()” после неё идёт функция создания гудка “bebep()”. В функции “setap” происходит инициализация радиомодуля и выводов Ардуино. В функции “loop” принимается символ и в соответствии с принятым символом совершаются определённые действия.
Передатчик можно изготовить на любом Ардуино. Рассмотрим схему передатчика:
Рисунок 2 – Передатчик
У каждого Arduino есть выводы SPI но обычно на плате они не подписаны, выяснить где эти выводы находятся можно из документации на конкретное Arduino. На рисунке 2 показан джойстик, джойстик обычно можно представить в виде набора кнопок. Если соответствующая кнопка нажата то на соответствующем выводе Arduino появиться низкое напряжение (логический ноль), если кнопка не нажата то на выводе будет высокое напряжение (логическая единица) т.к. этот вывод соединён с 5В через резистор с сопротивлением 10кОм (можно использовать резистор с другим близким к 10кОм сопротивлением) эти 5В берутся с вывода Ардуино. Ардуино можно питать одной батарейкой “Крона” на 9В, это питание также подаётся на Arduino через специальный разъём. Скетч также загружается при отключенном питании. Скетч для передатчика:
#include <SPI.h>
#include “nRF24L01.h”
#include “RF24.h”
RF24 radio(9,10);
const uint64_t pipe = 0xF0F0F0F0E1LL;
char data=’a’;
boolean but_forward_before;
boolean but_forward;
boolean but_back_before;
boolean but_back;
boolean but_left_before;
boolean but_left;
boolean but_right_before;
boolean but_right;
boolean but_fire_before;
boolean but_fire;
void sendData()
{
radio.openWritingPipe(pipe);
radio.startListening();
radio.write( &data, sizeof(char) );
delay(20);
}
void setup(void)
{
//Serial.begin(57600);
radio.begin();
radio.setRetries(15,15);
radio.openWritingPipe(pipe);
radio.startListening();
//установки для кнопок
pinMode(2, INPUT);
digitalWrite(2, HIGH);
pinMode(3, INPUT);
digitalWrite(3, HIGH);
pinMode(4, INPUT);
digitalWrite(4, HIGH);
pinMode(5, INPUT);
digitalWrite(5, HIGH);
pinMode(6, INPUT);
digitalWrite(6, HIGH);
}
void loop(void)
{
but_forward = digitalRead(2);
but_back = digitalRead(3);
but_left = digitalRead(4);
but_right = digitalRead(5);
but_fire = digitalRead(6);
if(but_forward_before && !but_forward)
{
data = ‘a’;
sendData();
}
else if(but_back_before && !but_back)
{
data = ‘b’;
sendData();
}
else if((!but_forward_before && but_forward) || (!but_back_before && but_back))
{
data = ‘c’;
sendData();
}
if(but_left_before && !but_left)
{
data = ‘l’;
sendData();
}
else if(but_right_before && !but_right)
{
data = ‘r’;
sendData();
}
else if((!but_left_before && but_left) || (!but_right_before && but_right))
{
data = ‘s’;
sendData();
}
if(but_fire_before && !but_fire)
{
data = ‘f’;
sendData();
}
but_forward_before = but_forward;
but_back_before = but_back;
but_left_before = but_left;
but_right_before = but_right;
but_fire_before = but_fire;
delay(80);
}
Первые 6 строчек аналогичны тем что в скетче для приёмника, далее идут переменные которые используются для хранения текущих и предыдущих состояний кнопок джойстика. Функция “sendData()” отсылает символ который записан в переменной “data”. В функции “setup” происходит инициализация радиомодуля и настройка необходимых выводов. В функции “loop” происходит отправка символа для движения вперёд если кнопка “вперёд” переходит из не нажатого состояния в нажатое, если тоже самое происходит в кнопкой “назад” то отсылается символ для движения машинки назад, если кнопка “вперёд” переходит из нажатого состояния в ненажатое или кнопка “назад” переходит из нажатого состояния в не нажатое то отправляется символ для остановки машинки, аналогично и для рулевой системы, есть ещё символ для гудка и он отправляется если кнопка “гудок” переходит из не нажатого состояния в нажатое. В общем скетчи достаточно простые, скачать их можно по ссылке: https://yadi.sk/d/K0HfKwcojCuaX.
Корпус лучше сделать из картона т.к. он не мешает прохождению радиосигнала, к тому же его можно красиво раскрасить:
Процесс сборки (неполный и ускоренный для экономии времени) машинки с некоторыми комментариями а также демонстрацию работы можно увидеть на видео:
КАРТА БЛОГА (содержание)
