-
Здравейте,
Тези дни се зачетох по темата, поради предстоящ проект, в който исках да избягам от стандартните механизми за стрелки. И реших да започна нова тема точно за Ардуино, тъй като технологията е евтина, а е достатъчно атрактивна.
Един контролер за 8 серво-та е от порядъка на долар- два, самото серво също е в този порядък.
Възниква в мен единствено въпросът за обръщането на поляритета на сърцето на стрелката. Аз се сещам за два начина- с бистабилно реле на 5V, което се обръща с ключа за задаване на командата или с механична връзка на краен изключвател към сервото в двете крайни му позиции, които да захранват сърцето.
Естествено в темата можем да поместване кодове за управление, както и различни хитринки, за управлението на механизмите.
В последните години виждам все повече гари направени по този начин, като те или са с управление от компютър или със стандартното изпълнение от пулт с ключета и/или бутони.
И понеже във форума има хора, за които това не е непозната област, реших, че е хубаво да си имаме отделна тема.
-
Идеята е добра и ако се развие полезна дискусия без излишни изхвърляния, ще е успех за форума.
Бих добавил към казаното от Емил "И понеже във форума има хора, за които това не е непозната област, реших, че е хубаво да си имаме отделна тема", че ще е много полезно и за хора като мен не толкова навътре в тази област. :hi:
-
Нека да започнем с ръководствата на български език.
https://playground.arduino.cc/Bulgarian/Nachalo (https://playground.arduino.cc/Bulgarian/Nachalo)
https://playground.arduino.cc/Bulgarian/Rykovodstva (https://playground.arduino.cc/Bulgarian/Rykovodstva)
На сайта има доста примери, както и в самите книжлета
Ето пример за Arduino Nano контролер: https://www.aliexpress.com/item/Freeshipping-Nano-3-0-controller-compatible-for-arduino-nano-CH340-USB-driver-NO-CABLE/32341832857.html?spm=2114.search0104.3.7.a8Q37b&ws_ab_test=searchweb0_0,searchweb201602_3_10152_10065_10151_10068_10171_10084_10083_10119_10080_10304_10082_10081_10110_10137_10111_10302_10060_10112_10113_10155_10114_10154_438_10056_10055_10054_10182_10059_100031_10099_10078_10079_10103_10073_10102_10120_5360020_10052_10053_10142_10107_10050_10051-10050_10120,searchweb201603_1,ppcSwitch_5&btsid=37b64b9e-2a67-4e83-8835-68e6a4795b78&algo_expid=a5ab6583-1f33-42e6-a6b7-b35a10e914db-3&algo_pvid=a5ab6583-1f33-42e6-a6b7-b35a10e914db (https://www.aliexpress.com/item/Freeshipping-Nano-3-0-controller-compatible-for-arduino-nano-CH340-USB-driver-NO-CABLE/32341832857.html?spm=2114.search0104.3.7.a8Q37b&ws_ab_test=searchweb0_0,searchweb201602_3_10152_10065_10151_10068_10171_10084_10083_10119_10080_10304_10082_10081_10110_10137_10111_10302_10060_10112_10113_10155_10114_10154_438_10056_10055_10054_10182_10059_100031_10099_10078_10079_10103_10073_10102_10120_5360020_10052_10053_10142_10107_10050_10051-10050_10120,searchweb201603_1,ppcSwitch_5&btsid=37b64b9e-2a67-4e83-8835-68e6a4795b78&algo_expid=a5ab6583-1f33-42e6-a6b7-b35a10e914db-3&algo_pvid=a5ab6583-1f33-42e6-a6b7-b35a10e914db)
И за 10 бр серво моторчета: https://www.aliexpress.com/item/Free-Shipping-10PCS-SG90-9g-Mini-Micro-Servo-for-RC-for-RC-250-450-Helicopter-Airplane/32551162930.html?spm=a2g0s.8937460.0.0.zkgGpD (https://www.aliexpress.com/item/Free-Shipping-10PCS-SG90-9g-Mini-Micro-Servo-for-RC-for-RC-250-450-Helicopter-Airplane/32551162930.html?spm=a2g0s.8937460.0.0.zkgGpD)
Та какво представлява контролера:
(https://erelement.com/images/arduino/Iteaduino-nano.jpg)
Пълното му описание е тук:https://www.itead.cc/wiki/Iteaduino_Nano (https://www.itead.cc/wiki/Iteaduino_Nano)
Характеристики:
Размери: 43mm x 18mm
Микроконтролер: Atmel ATmega328P
Flash: 32KB, от които свободни 30KB, a 2KB заети от буутлоудъра
RAM: 2KB
EEPROM: 1KB
Тактова честота: 16MHz
Зареден с Arduino Nano буутлоудър
Захранване: 5V от USB или пин 5V, или 6V – 12V на пина Vin
Работно напрежение: 5V
Входно/изходни портове (I/O): 20 броя, от които:
Цифрови портове: до 20 бр.
Аналогови входове: до 8 бр.
PWM (ШИМ): до 6 бр.
UART, I2C и SPI интерфейси
USB-сериен порт конвертор: CP2102
Програмира се с Ардуино IDE, като Ардуино Нано
За по-лесно включване на захранвания, както и комуникацията със серво машинките може да се вземе една платчица, на която да набодете контролера:
(https://cdn.itead.cc/media/wysiwyg/Products/nano2.jpg)
-
Офф.. Това е прекалено силно казано "аналогово" управление... Чиста проба си е цифрово.. И следователно не е за тоя раздел...
-
Преди да разчепкаме контролера, портовете му, и кода за управление ще сложа малко снимки, предоставени ни от румънските ни приятели. Те са на изработената стойка за серво машинките, така, както те са я проектрали и използват.
Стойката е от 2мм плексиглас, рязана на лазер и залепена и служи за закрепване на сервото, двата крайни изключвателя, които се ползват за обръщане поляритета на сърцето на стрелката (не за спиране завъртането на сервото), както и фиксиране на лостчето за преместване на езика на стрелката (изработено от 0,8мм стоманена тел)
(http://media.snimka.bg/s1/5952/038148506-big.jpg?r=0)
(http://media.snimka.bg/s1/5952/038148507-big.jpg?r=0)
(http://media.snimka.bg/s1/5952/038148508-big.jpg?r=0)
(http://media.snimka.bg/s1/5952/038148509-big.jpg?r=0)
(http://media.snimka.bg/s1/5952/038148510-big.jpg?r=0)
(http://media.snimka.bg/s1/5952/038148511-big.jpg?r=0)
(http://media.snimka.bg/s1/5952/038148513-big.jpg?r=0)
(http://media.snimka.bg/s1/5952/038148514-big.jpg?r=0)
(http://media.snimka.bg/s1/5952/038148515-big.jpg?r=0)
(http://media.snimka.bg/s1/5952/038148516-big.jpg?r=0)
(http://media.snimka.bg/s1/5952/038148517-big.jpg?r=0)
(http://media.snimka.bg/s1/5952/038148522-big.jpg?r=0)
(http://media.snimka.bg/s1/5952/038148523-big.jpg?r=0)
Ъгълът на завъртане на сервото се определя в кода за управление, като според него се фиксират двата изключвателя. Самият ъгъл пробно се установява след монтажа и се донапасва в кода за всеки механизъм, като зависи какъв ход има езика на стрелката, колко е дебела основата на макета и т.н. едва след като се регурира той, се закрепват финално двата контактора.
Причината поляритета да се прави с два контактора е избягването на смяна на поляритета в момент, когато езика не е напълно отлепен от главната релса (за Peco стрелки сърцето и езика са с еднакъв поляритет) и предизвикване на късо в DCC бустера.
-
Ето и каталожния номер на крайния изключвател:
http://www.tme.eu/ro/details/msm-22/microcomut-cu-lama-cu-mont-prin-apas/ninigi/msw-22/ (http://www.tme.eu/ro/details/msm-22/microcomut-cu-lama-cu-mont-prin-apas/ninigi/msw-22/)
-
Та да подхванем контролера.
ето му схемата на всички варианти на пиновете
(http://www.pighixxx.com/test/wp-content/uploads/2014/11/nano.png)
Ето и описанието на пиновете, както и възможните позиции и функции, които могат да изпълняват:
https://www.arduino.cc/en/uploads/Main/ArduinoNanoManual23.pdf (https://www.arduino.cc/en/uploads/Main/ArduinoNanoManual23.pdf)
Всички лилавки портове могат да бъдат използвани, т.е. имаме 18/19 порта, на които трябва да включим серво, ключета за указване на посоката на сервото, и ако искаме светлинна индикация индикация. Тъй като всичко е въпрос на програмиране имаме няколко възможности:
1. да използваме ЦК ключе с което да задаваме посоката на езика на стрелката- при този вариант ще имаме 3 пина за стрелка (2 за посока и един за серво) или 5 пина ако искаме да имаме и индикация.... при този вариант на един контролер ще съберем 3 стрелки
2. ако изполваме маршрути и с един бутон оказваме маршрут, тогава с един бутон ще управляваме всички стрелки по маршрута. При този вариант може да имаме 8 серво машинки и 10 маршрута, но без обратна индикация. Индикацията можем да я вземем от например крайните изключватели (напомням, че е забранено да се захранват принадлежности от DCC верига). Така можем да покрием едната гърловина на поне 7 коловозна гара.
3. Има и трети вариант в който може да се закачат 6 сервота, 6 управляващи вериги и 6 индикатора за посоката на стрелката.
-
...
1. да използваме ЦК ключе с което да задаваме посоката на езика на стрелката- при този вариант ще имаме 3 пина за стрелка (2 за посока и един за серво) или 5 пина ако искаме да имаме и индикация.... при този вариант на един контролер ще съберем 3 стрелки
...
Ако на ЦК ключетата едниният края е на „-“ - GND, ти трябват само по ЕДИН пин за управление на стрелка, и на него ще подаваш “-“ (GND) ако искаш да преместиш стерлката в “минусовото“ и положение, или няма да подаваш нищо (резистор към плюса) ако искаш стралката да отиде в нормалното си “плюсово“ положение (например). И още един пин за сервото.
-
Започвам стъпка по стъпка да опитам да обясня как се конфигурира контролера. Споменатото от Митко ще го обяснявам с конкретни примери при разглеждане вариантите на реализиране.
За да конфигурирате Ардуино ви е необходим безплатен софтуер (IDE). Чрез него пишете кода и го уплоудвате на контролера. Наличен е софтуер за windows, Linux, Mac OS X.
https://www.arduino.cc/en/Guide/HomePage (https://www.arduino.cc/en/Guide/HomePage)
Инсталационната процедура за Windows: https://www.arduino.cc/en/Guide/Windows (https://www.arduino.cc/en/Guide/Windows)
Писането на кода е много подобен на С++
Първата стъпка ще е само едно серво свързано към Ардуино, за да тестваме различни комбинации:
Постановка И ЗА ДВАТА ПРИМЕРА:
(http://thenscaler.com/wp-content/uploads/2014/11/sweep_BB.png)
Пример 1: Свързваме сервото към порт 9, караме сервото да се позиционира на 90 градуса
===================================
Кода:
#include <Servo.h> // compiler directive to get the servo library
Servo myservo; // създаваме обект серво, а с ПРОМЕНЛИВАТА "MYSERVO" ЩЕ ДОСТЪПВАМЕ И КОНТРОЛИРАМЕ ОБЕКТА
void setup() // setup функцията се изпълнява веднъж при стартиране
{
myservo.attach(9); // СВЪРЗВАМЕ СЕРВОТО КЪМ ПИН 9
myservo.write(90); // ПОЗИЦИОНИРАМЕ СЕРВОТО НА 90 ГРАДУСА
}
void loop() // функцията се изпълнява постоянно и последователно докато не се изключи захранването
{
// в случая не правим нищо
}
====================================
Пример 2: Свързваме сервото към порт 9, караме сервото да се завърта от 0 до 180 градуса и обратно на стъпки през един градус
====================================
Кода
#include <Servo.h> // compiler directive to get the servo library
Servo myservo; // създаваме обект серво
int pos=0 // променлива за съхранение на позицията на сервото
void setup() // setup функцията се изпълнява веднъж при стартиране
{
myservo.attach(9); // СВЪРЗВАМЕ СЕРВОТО КЪМ ПИН 9
}
void loop() //функцията се изпълнява постоянно и последователно
{
for(pos=0;pos,180;pos+=1) //преминава от 0 до 180 градуса през един градус
{
myservo.write(pos); //казва на сервото да се позиционира на позиция равна на pos
delay(15) //чака 15 ms сервото да достигне позицията
}
for(pos=180;pos>=1;pos-=1)// преминава от 180 до 0 градуса през един градус
{
myservo.write(pos); //казва на сервото да се позиционира на позиция равна на pos
delay(15) //чака 15 ms сервото да достигне позицията
}
}
-
Пример 3 със същата постановка: Сервото се върти от 0 до 180 и обратно с пауза от 2 секунди.
В този пример ще сменя умишлено името на обекта
#include <Servo.h> // compiler directive to get the servo library
Servo Servo1; // създаваме обект серво
void setup() // setup функцията се изпълнява веднъж при стартиране
{
myservo.attach(8); // СВЪРЗВАМЕ СЕРВОТО КЪМ ПИН 8
}
void loop() //функцията се изпълнява постоянно и последователно
{
Servo1.write(180); //казва на сервото да се позиционира на позиция равна на 180
delay(2000) //чака 2000 ms
Servo1.write(0); //казва на сервото да се позиционира на позиция равна на 0
delay(2000) //чака 2000 ms
}
-
С аруиното може да движиш и стъпкови мотори., може би с тях ще имате по-голям успех от колкото със серво машинка.
-
Да споделя моя скромен опит с Ардуино. Не претендирам че съм специалист на тема електроника и програмиране но
имам и се базикам и с трите варианта на контролера или реплики на оригинала с имената "Нано", "Уно" и "Мега".
(https://farm5.staticflickr.com/4325/36027516951_dcc66a0f3c_h.jpg) (https://flic.kr/p/WTCrBn)IMG_20170725_190745 (https://flic.kr/p/WTCrBn) by Dimitar Stefanoff (https://www.flickr.com/photos/126320898@N06/), on Flickr
Разликата между тях са размерите, броя портове и размера на паметта и процесорите. Имам разни датчици, бутони, превключватели, релета, експериментални "дъски" ,"шилдове"и не на последно място серво и стъпкови мотори - всичко окабелено и стандартизирано.
(https://farm5.staticflickr.com/4300/35321097214_dcae07b1a2_h.jpg) (https://flic.kr/p/VPcRCJ)IMG_20170725_191249 (https://flic.kr/p/VPcRCJ) by Dimitar Stefanoff (https://www.flickr.com/photos/126320898@N06/), on Flickr
(https://farm5.staticflickr.com/4321/35321078654_e53751660e_h.jpg) (https://flic.kr/p/VPcL7J)IMG_20170725_191313 (https://flic.kr/p/VPcL7J) by Dimitar Stefanoff (https://www.flickr.com/photos/126320898@N06/), on Flickr
(https://farm5.staticflickr.com/4317/36160397765_99bfc0b35c_h.jpg) (https://flic.kr/p/X6nurT)IMG_20170725_191642 (https://flic.kr/p/X6nurT) by Dimitar Stefanoff (https://www.flickr.com/photos/126320898@N06/), on Flickr
Та по темата:
Нямам задвижено на макета нищо за в момета, но експериментирам с програмирането на платките и свързването на елементите. Когато всичко подкарам, тогава ще запоя всичко по шилдовете. На малкия макет си бях направил автоматизация. Управлявах автоматично бариерата когато наближи или се отдалечи влака, влака спираше плавно на перона изчакваше и пак плавно потегляше - "ШИМ" на захранването управлявано от рид-ампули между релсите и магнит на локомотива.
Пограмирам на "miniBloq" това графична среда за програмиране на Ардуино, не може да се сравнява с оригиналния софтуер но за задачите които имам ми стига. Единственото ограничение което имам там е че не мога да програмирам повече от 3 сервомотора на платка, но съм го решил с увеличаване на броя на платките. Управлението на сърцата на стрелките може да стане според мен с обикновено реле, Ардуино си има готови модули, доста от нещата съм ги прибрал на високо и не можах да ги издиря да снимам. Захранвам с най обикновено зарядно за телефон с USB. Забавно е и е доста идейно след като почнеш. Поздрави.
-
Пример 4:
Тъй като през по- голяма част от времето сервото е в покой, не е необходимо то да бъде контролирано , защото шуми. Именно с цел намаляване на шума, можем след изпълнение на командите, които са ни необходими да детачваме серво контрола. При следваща команда за изпълнение първо атачваме, подаваме команда и пак детачваме.
Кода
=========================
#include <Servo.h>
Servo servo; //декларираме си сервото
const int servoPin = 2;// декларираме изхода за контрол на сервото
void setup() {
servo.attach(servoPin); // атачваме сервото за първоначално позициониране
servo.write(90); // завъртаме го на 90 градуса
delay(500); //пауза
servo.detach(); //детачваме сервото да за не шуми
delay(500); //пауза
}
void loop() {
servo.attach(servoPin); //атачваме сервото, като посочваме и пина
servo.write(60); //завъртаме на 60 градуса
delay(500); //пауза
servo.write(120); //завъртаме на 120 градуса
delay(500); //пауза
servo.write(90); // завъртаме на 90 градуса
servo.detach(); //детачваме
delay(500); //пауза
}
-
От тук нататък ще пристъпим към използване на бутони/ключета за контрол на сервото, като входни портове.
За да започна обяснението, ще използвам схема, в която имаме два бутона (вариант 1 от описанието от няколко поста по-горе), единия за обръщане на сервото в права, а другия за обръщане в отклонение. Както казах този вариант е доста разхищаваш от гледна точка на използване на портовете, но е най- близо до логиката, която всички ползваме и в момента по пултовете на макетите си. Естествено вместо два бутона , може да се използва (ON)-OFF-(ON) ЦК ключ, при който имаме една стабилна средна позиция, и две незадържащи крайни позиции.
Описание на опитната постановка:
Използвам схемата от картинката, при която на порт 2 връзвам единия ключ, на порт 3 другия. На порт 9 се връзва сервото. Портове 2 и 3 са постоянно подвързани през резистори 1кОм към маса. Това се налага за да гарантираме и осигурим стабилен нисък потенциал на порта в спокойно състояние, което със сигурност да се отличава от +5V, (висок потенциал), които ще подаваме и ще бъде критерий за превключването.
(https://3.bp.blogspot.com/-oEv5ep8y0Xc/VaPThB3VEyI/AAAAAAAAA4g/q0_h3qrju9A/s400/push%2Bbutton%2Bdrived%2Bservo%2Bmotor%2Bschematic%2Bview.jpg)
(https://1.bp.blogspot.com/-eVvXjzQEXoY/VaPTbCBS7mI/AAAAAAAAA4Y/TcpPlA37c1Q/s400/Control%2Bservo%2Bwith%2Bpush%2Bbutton%2Bswitch%2Bbreadboard%2Bview.jpg)
===================
КОД 1: Завъртаме сервото на 0 градуса за право и 180 градуса за отклонение
Трябва да отбележа, че използваме завъртане през 1 градус до достигане на противоположната позиция като след всеки градус изчакваме с по 15 ms с цел по- бавно завъртане.
#include<Servo.h>
int pos = 0; //декларираме променлива, в която да се записва текущата позиция на завъртането
Servo servo1; //декларираме сервото с име servo1
void setup() {
pinMode(2, INPUT); //декларираме порт 2 за входен
pinMode(3, INPUT); //декларираме порт 3 за входен
servo.attach(9); //декларираме порт 9 за сервото
}
void loop() {
while (digitalRead(2) == HIGH && pos < 180)
{
pos++;
servo1.write(pos);
delay(15);
}
while (digitalRead(3) == HIGH && pos > 0)
{
pos--;
servo1.write(pos);
delay(15);
}
}
====================
КОД2: Ако искаме например завъртането за право да е на 70 градуса, а за отклонение на 110, като началната инициализация на сервото е на 90 градусова позиция, горния код се преработва до следния:
#include<Servo.h>
int pos = 90; //декларираме променлива, в която да се записва текущата позиция на завъртането
Servo servo1; //декларираме сервото с име servo1
void setup() {
pinMode(2, INPUT); //декларираме порт 2 за входен за отклонение
pinMode(3, INPUT); //декларираме порт 3 за входен за право
servo.attach(9); //декларираме порт 9 за сервото
servo1.write(pos); //поставяме сервото на 90 градуса
}
void loop() {
while (digitalRead(2) == HIGH && pos < 110)
{
pos++;
servo1.write(pos);
delay(15);
}
while (digitalRead(3) == HIGH && pos > 70)
{
pos--;
servo1.write(pos);
delay(15);
}
}
-
Недостатък или предимство на горните два кода е, че трябва бутона да бъде натиснат през целия ход на сервото. Ако го пуснете преди да е стигнало крайна позиция сервото ще спре.
Ето и видео демонстрация: https://youtu.be/Y6l4wRgkX-w (https://youtu.be/Y6l4wRgkX-w)
-
Значи този метод не е много сигурен. Ако се спрем на него трябва да има задължително обратна връзка, което усложнява проекта.
-
Би трябвало да има и други възможности.
Например да "смята", че бутона е натиснат за определено време.
Опция за таймер или нещо от сорта.
Или пък да брои колко градуса трябва да стигнат до едно или друго крайно положение. Тоест отново да смята бутона за натиснат до отброяване на определени градуси.
( Май спомена че цикъла ти се състои от стъпки по 1 градус)
Всъщност обратната връзщо в сервото е подобна.
Там разбира, че е завъртял сервото в едно от крайните си положения,
когато изравни показанията на зададените, с тези получени от вградения променлив резистор. Тоест изравнява честотите и спира. Нали всъщност чрез входните честоти, сервото тръгва в определена посока до достигане на нужния ъгъл.
Или нещо такова...
;D
-
Защо го правиш в цикъл? Не става ли нещо като това:
if (digitalRead(2) == HIGH)
{
servo.write(25);
}
elseif (digitalRead(3) == HIGH)
{
servo.write(50);
}
С цилъл и забавяне, стрелката вероятно ще превключва по-бавно (по-мазно, по-реалистично ;D), но трябва допълнителен флаг в кода, за да не се налага бутона да се държи постоянно натиснат. Нещо като напр:
bool button1on = false; // флаг за натиснат бутон
button1on == (digitalRead(2) == HIGH); // проверка преди основния цикъл
// основен цикъл
while (button1on && (pos < 110)) // нататък мисля е ясно
-
Значи този метод не е много сигурен. Ако се спрем на него трябва да има задължително обратна връзка, което усложнява проекта.
Примерчетата по-горе са доста елементарни и не ви съветвам да ги ползвате в този вид. Разбира се те са чудесни за начало, а могат спокойно и да си останат в този вид.
Бутоните могат да се четат по различен начин, с еднократно натискане, със задържане докато сервото стигне до края, с натискане за алтернативна смяна на посоката и т.н. Не е много сложен код.
ПС: Микси написа нещо докато аз се туткам на клавиатурата: тези цикли ги правят хората за да се похвалят колко е хубаво сервото да врътне стрелката за 3 секунди от единия край до другия. Или за 2, ако трябва. Иначе став щрак-щрак.
ПС2: Това атачване по едно време беше където трябва, нещо в последните примери пак избяга където не трябва.
Сериозният проблем е че при изключване на управлението (захранването) стрелките остават в положението, в което са в този момент. При ново включване с тези програмки се приема че сервото е в положение 0, или 90 или колкото сте му написали, но не и колкото е в действителност (а то може и да е 180). На теория това не може да се реши, освен ако няма "крайни изключватели", които да се четат преди въобще да се атачне порта на сервото. Трябва да са направени и да се четат така, че да се разпознават не само двете крайни положения, но и това че стрелката не е преместена докрай (случва се доста често). С първия пример може да си натискате бутона на порт 3 за да "нулирате" стрелката, ама тя хич няма да мръдне, защото ардуиното си знае че е в положение 0. Така че "реалната" програмка за стрелки ще изглежда доста различно.
-
Сериозният проблем е че при изключване на управлението (захранването) стрелките остават в положението, в което са в този момент... Така че "реалната" програмка за стрелки ще изглежда доста различно.
Напълно вярно. По принцип, при всяко включване на захранването, следва да има инциализиране със завъртане на сервото "еди-колко-си-градуса", които градуси да са повече от реалния възможен ход. Това гарантира поставяне в едното крайно положение на стрелката, което се приема за изходно (начално). Дали сервото ще има вграден ограничител/изключвател (да не напъва да върти повече от допустимия механичен ход), зависи от модела и най-вече от цената. Има и такива, които "напъването" не им пречи. Но опрделено трябва да се помисли и за това - как коректно ще се инициализира системата при включване на захранването.
-
Е аз исках темата да бъде и обучителна, и да има примерчета, за да се види как всичко започва. Няма как да плесна код за готова стрелка и 90% от четящите да не разберат нищо.
Искам темата да е полезна, защото е евтино и няма смисъл да пълним хазните на Конрад или Хофман.
идеята е всеки да се научи, а не да ходи и да се моли на този или онзи да му направи нещата.
Ще дойде и по- сложния код, ама нека да стигнем до там. После може да предлагаме кодове и оптимизации, но трябва всички четящи да са на една вълна.
Това, което Милен е предложил ще стане като код. Мислех и аз да направя оптимизация на кода за вариант само с моментно натискане, но все пак съм на работа и го правя при наличие на свободно време :).. Поне е хубаво, че става дискусия, за да родим накрая нещо полезно.
А и в момента чакам да ми дойде поръчката на контролера и сервотата за да мога да тествам всеки код, преди да го плесна тук.
-
Искаме и клипчета от тестовете, а не само код, защото едно клипче струва колкото хиляда реда код.
https://www.youtube.com/watch?v=3XVtUUtfjJE (https://www.youtube.com/watch?v=3XVtUUtfjJE)
:lol: :pleasantry: :drinks:
-
Искаме и клипчета от тестовете, а не само код, защото едно клипче струва колкото хиляда реда код.
https://www.youtube.com/watch?v=3XVtUUtfjJE (https://www.youtube.com/watch?v=3XVtUUtfjJE)
:lol: :pleasantry: :drinks:
Ихххх начи, сега трябва да чакам две -три седмици да дойдат чарколаците. Обаче приемем предложението, защото е градивно и наистина ще има смисъл=> хем проверен и публикуван код, хем нагледен резултат.
Даже ще изтествам наистина дали сервото се ресетира при изключване на захранването, в зависимост от декларирането и атачването в кода.
-
Ихххх начи, сега трябва да чакам две -три седмици да дойдат чарколаците
Само се бъзикам, щото цял ден си мисля, че е петък, а то... Давай още кодове :)
Даже ще изтествам наистина дали сервото се ресетира при изключване на захранването
Това не знам как ще става, освен ако няма някаква пружина вътре. Ще е интересно да се тества. :good:
Дай някакъв datasheet за това моторче, че не намерих в ali-то...
-
Искаме и клипчета от тестовете, а не само код, защото едно клипче струва колкото хиляда реда код.
https://www.youtube.com/watch?v=3XVtUUtfjJE (https://www.youtube.com/watch?v=3XVtUUtfjJE)
:lol: :pleasantry: :drinks:
ФТТ
:lol: :lol: :lol: :lol: :lol: :heat:
ПП. То вярно, че зависи какво качество на сервото сте избрали, но крайни изключватели само усложняват всичко.
След изключване на захранването и последващо възстановяване,
може преди всички операции, да се изпраща до всички машинки,
"установи се на 0 градуса" и готово. Няма да има никакво напъване защото самата им конструкция не го позволява.
Дори да е аналогова машинка (нали се търси простота в схемата и бюджетно изпълнение), ако при началното установяване към всички налично свързани машинки се подаде командата
"отиди на 0 градуса" (широчина на импулса 1 mS), то командата ще изпълнят само тези на които вградения потенциометър им
позволява това. Тоест другите ( не изпълняващи командата) ще
са сравнили данните и просто няма да се завъртят.
(http://2.bp.blogspot.com/-8zaktNV9tmQ/VlADCq147FI/AAAAAAAAACU/KTCuKHurN0s/s1600/waveform.jpg)
А тези които се завъртят, ще спрат в момента който също изравнят подаваните импулси с вътрешната си информация.
И няма да има никакво насилване на машинките.
Всъщност това с "нулирането" им, си е почти задължително,
за да може да се прави периодично с оглед премахването на
натрупаната грешка, която е неизбежна при аналоговите
(същите са от евтините) сервомашинка.
Колкото повече не се "нулират" - толкова повече и натрупаната грешка стана по-голяма, като може дори са се стигне,
че тя (грешката) да не се компенсира от пружинния ефект на лостчето предаващо механичното движение от рамото на сервото, до пластината местеща езика на разклонението.
При цифровите сервомашинка, това е елиминирано, включително и от механични и температурни влияния, но те струват значително по-скъпо...тоест не са предмет на този проект.
:hi:
ПП2. Горе нещо се бъгна и качи само първата част от поста ми...
Ще помоля Милен да го изтрие там - тук е целият пост!
:hi:
-
Сега ще сложа един малко по- сложен код за управление на сервото между 90 и 110 градуса, като в кода се вижда, че с декларирането и атачването се заема положение"Право" на стрелката.
Опитната постановка е за упраление с един бутон, свързан към пин 8 и серво на пин 9, като на пин 8 имаме оново резистор, който да държи масата. Всяко натискане на бутона води до превключване в противоположното положние на стрелката.
(http://thenscaler.com/wp-content/uploads/2014/12/Servo-Control-by-Button-293x300.jpg)
================
КОД:
#include <Servo.h>
// константни променливи използвани за ъглите на сервото в градуси
const int straight = 90;
const int divergent = 110;
// Константни променлилви за пиновете, които се използват
const int buttonpin = 8;
const int servopin = 9;
// константа със стойност за забавяне на движението на сервото в милисекунди
const int step_delay = 70;
// декларираме сервото
Servo myservo;
// глобални променливи за запомняне позицията на сервото
int pos = straight; // current
int old_pos = pos; // previous
void setup()
{
// деклариране на пина за бутона
pinMode(buttonpin, INPUT);
// ето тук казваме директно след атачването да се обърне в права позиция сервото
myservo.attach(servopin); // attach to the servo on pin 9
myservo.write(pos); // set the initial servo position
}
void loop()
{
// всяка итерация започва с промяна на състоянието на бутона
// при натиснат бутон (reads HIGH), се премества сервото
int button_state = digitalRead(buttonpin);
if(button_state == HIGH){
old_pos = pos; // запазва текущата позиция
// променя позицията в обратното състояние
pos = pos == straight ? divergent: straight;
// премества сервото до новата позиция
if(old_pos < pos){ // ако новия ъгъл е по- голям
// завърта (увеличава) серво позицията от старото до новото състояние
for(int i = old_pos + 1; i <= pos; i++){
myservo.write(i); // записва следващата позиция на сервото
delay(step_delay); // пауза
}
} else { // обратно новия ъгъл е по- малък и ли равен
// завърта (намалява) серво позицията
for(int i = old_pos - 1; i >= pos; i--){
myservo.write(i); // записва следващата позиция на сервото
delay(step_delay); // пауза
}
}
}
}// край на цикъла
-
Темата я следя от самото началао. Според мен, трябва да махнете сервото от цялата схема. Направете го със стъпково моторче. На него може да му регулирате градусите, стъпките, броят обороти и скоростта. В записвачките за CD и флопитата има достатъчно малки такива.
-
Jope, отвори тема за стъпкови моторчета и управлението им, за да не мешаме знанието.
Тук темата е за серво и Ардуино. Виждал съм готови гари и искам да я разчоплим до край. Аз в нета примери за стъпкови не съм виждал, и като нямам знанията няма и какво да напиша, но нека не разводняваме.
Необходима ни е конкретика, знание и факти.
Ако имаш такива ги сподели с нас, но не очаквай че ще подхвърляш идея и някой друг ще трябва да я чопли и развива
-
Без да разводнявам темата, ето един пример, който намерих в нета веднага. Достатъчное е изчерпателно описани са кодовте, има и туториали. Нужно ви е единствено да се просветите как действат стъпковите мотори, разликите в тяхната конструкция размери и видове драйвъри. Подкарване на стъпков с драйвър http://www.makerbothy.com/arduino-stepper-motor-control/ и подкарване на стъпков направо с ардуиното http://forum.arduino.cc/index.php?topic=91442.0 Ардуиното е много добър вариант за нас понеже има евтини китайски реплики, които са на достъпна цена. Това ни позволява да се качим на по-горното ниво в хобито. Така, някой от нас имат шанса да развихрим творческото си въображение, като накараме един макет или модул да "оживее" в буквалният смисъл на думата. Ардуиното е приложимо не само за стрелки, ами и за сигнали,бариери, обръщатели отваряне и затваряне на врати(на депото например), задвижване на индустрии и всичко каквото ви дойде на ум. http://www.electroingenio.com/arduino-en/stepper-motor-with-mobile-app/ :hi:
-
Eмчо, ако може да задам въпрос? Може би няколко.
С кой от китовете разполагаш/работиш?
На една от скиците виждам кит с неясно означение (не се чете ясно) Digital + PWM.
Това ли ти е експерименталния кит? Може би е версия R3?
По старите версии нямат възможност да ползват генератор за импулси, а те си трябват независимо кои сервомашинки ще ползваш.
И последен въпрос - смяташ ли да ползваш тъчскрийн дисплей
за визуализация на осъществяваното управление? В мрежата има вече доста такива схеми решения, включително и за малки гарички или контролни постове за стрелкови гърловини. Дори и цветни!
Все пак това зависи и от площа на употребявания тъч дисплей де, а реализацията им явно е много улеснена съгласно ардуиното.
;D
-
Паце, схемите в примерите са примерни от нета, като имат за цел единствено да покажат разнообразието в писането на кода.
Аз лично съм поръчал Ардуино Нано (мисля в първия пост го бях показал), като на повечето примери, картинката е от Ардуино Уно.
в някои от следващите постове мисля да специфицирам точно за Нано, кой порт как може да се използва, но ми трябва да ми е в ръчичките за да го тествам и да съм сигурен , в това което ще напиша.
С тъчскрийна ме слагаш на колене.... Водихме в клуба разговори и имаше такова желание, за съжаление нямам познанията как да стане. Питах германци, но при тях ползват тъчскрийнове и лаптопи в комбинация с централа и декодери по стрелките. А аз искам да видя готов проект и да го разчопля, както ще направя с проекта а гара Липанещи (която участваше в Русе тази година) и да го покажа и разкажа тук.
Ако наистина някой има идея как може да се навърже лаптоп или таблет с ардуино ще съм безкрайно благодарен да сподели, защото ми е наистина интересно, а и нещо разпъването на кабеляци и пултове вече ми е малко тегаво. На срещата през септември в Прага ще огледам всички гари и ще ровя за такова изпълнение.
Милен предложи JMRI софтуер, но хардуерната връзка ми бяга в тъча.
-
JMRI (http://www.jmri.org) е набор от програми и библиотеки на Java, предназначени за контрол и управление на влакове и макети чрез компютър. Компютърът служи за основна станция (централа), откъдето могат да се командват локомотиви, стрелки, сигнали и т.н. Връзката между компютъра и самия макет става през някоя от множеството поддържани фабрични централни станции или през направи-си-сам решения като напр. DCC++ (http://jmri.org/help/en/html/hardware/dccpp/index.shtml) - централа на базата на Ардуино със собствен софтуер с отворен код. Самото управление може да е напълно автоматизирано, като за всеки влак се задава маршрут, разписание и т.н. и макета се превръща в изложба за зрители (като в Miniatur Wunderland) или да е ръчно, от човек, който използва компютъра като един вид по-удобна мишка. Вместо компютър, може да се ползва таблет, телефон или каквото и да е устройство с браузър за визуализиране на контролните панели на гарите и за управление на локомотивите.
Колкото до връзката между JMRI и текущо обсъжданото управление за стрелки с Ардуино - не мсиля, че има готово решение. По-скоро трябва да се заделят два входа в ардуиното и да му се вмъкне малко код за разпознаване на DCC адреси и команди и да се предприема съотетното действие при подадена към него команда. Това ще реши проблема със създаването на механичен контролен панел с множество бутони, но ще създаде други проблеми, тъй като си е ръчкане и писане на доста код. Но пък ще е готино, ако стане - началник-гарата ще се мотае наоколо с един таблет в ръка и ще командва всичко от там.
Друг е въпросът с преоткриването на топлата вода - инвестицията да се проектира, тества и направи такова нещо във време далеч надхвърля цената на това да се купи готова централа, декодери за стрелки и един таблет, с който да се джитка всичко това.
-
Препоръчвам ардуиното уно R3 (digital+pwm), защото
Нано-то бързо ще ти отеснее с оглед желанието да повече серво и т.н.
Колкото до връзка не само с тъчскрийн, но лаптоп и базова
станция която надстроява DCC до DCC++ e именно връзката между DCC и С++ (от там заглавието на надстройката) реализирана чрез отворен код.
Сайта на DCC++ e:
https://github.com/DccPlusPlus/BaseStation/wiki/What-is-DCC--Plus-Plus
Youtube canell:
https://youtu.be/8cBQoI1NfHI
И основното за проекта:
https://sites.google.com/site/dccppsite/home
Като допълнение може и тук:
http://jmri.org/help/en/html/hardware/dccpp/index.shtml
Впрочем допълнителните модули в добавка,
са също на приемливи цени!
Тъчскрийна е от друг проект в допълнение:
http://sguggiari.ch/5_dcc_arduino.php
Имаше и конкретно за гърловина с графичен тъч,
но в момента нямам време да го потърся.
-
Ето го въпросния проект за тъч-а!
http://www.wcmrra.org/content.aspx?page_id=2507&club_id=407609&item_id=1260
(http://s3.amazonaws.com/ClubExpressClubFiles/407609/graphics/single_lcd_1539662057.jpg)
Въпрос на графика и реализация де ...
-
Гледам от известно време: зелената точка си мисля че схванах за какво е (т.е. аз за какво бих я нарисувал на това място и в такъв цвят). Ама двете червени топки - няма да се справя ... Имам някакво подозрение, че ако пипна дясното червено топче то ще позеленее и ще включи двете стрелки за преход от най-долния на средния коловоз. А пък ако пипна зеленото - то ще стане червено и отдясно ще се влиза направо в, а не в отклонение.
Да ама не - на картинката двете есови връзки били щракнати, а отдясно се влиза направо, т.е. забиваш се в стрелката, която не е отворена за теб. Нищо че зелената топка е нагоре. Опитах да прочета въпросната страница - кошмар. Справих се, има си начини да видиш сорса и да разбереш какво е написано зад картинките и рекламите.
pach, нека все пак като слагаме линкове за нещо, (цветен тъч скрин) да е ясно, разбираемо и удобно за работа. За да бъде (евентуално) полезно за четящите. А не да е пример как да не се прави нещо. Най-добре е разбира се да споделяме собствен опит, но дори и да е нещо чуждо - нека да е някакъв добър пример, а не просто един измежду хилядите линкове от гугъла.
-
Преди да продължа със следващата стъпка, а именно връзване на светодиодна индикация, трабва да поясня, че входно-изходните пинове на ардуиното имат ограничения по ток, като максималния е 40 мА, но се препоръчва да не надвишаваме 20мА
Ето една кратка схема за ограниченията както на отделните портове, така и на групите от портове:
(http://arduino-info.wikispaces.com/file/view/ArduinoPinCurrentLimits.jpg/230512334/ArduinoPinCurrentLimits.jpg)
Повече подробности за любопитните: https://playground.arduino.cc/Main/ArduinoPinCurrentLimitations (https://playground.arduino.cc/Main/ArduinoPinCurrentLimitations)
Следващия пример е следствие на последния- управление с един бутон, но с два изхода за светодиоди- единия за право, другия за отклонение. Връщайки се на първия пост в темата отново напомням, че това не е оптималния вариант, защото се хабят излишно портове на Ардуиното. (само лека забежка- моментна, която ще разяснявам в следващи постове- има няколко варианта за използване на един изход , който с логически елемент 74хх да разклоняваме и инвертираме, за да пестим портове на Ардуино)
Ето и опитната постановка:
(http://thenscaler.com/wp-content/uploads/2014/12/Servo-Control-by-Button-with-leds.jpg)
Разчитаме на резисторите на изходите за ограничаване на тока, като дори да използваме от старите светодиоди, можем да направим сметка при 5V и 17мА ток какъв резистор да си сложим
===============
КОД
#include <Servo.h>
// константни променливи използвани за ъглите на сервото в градуси
const int straight = 90;
const int divergent = 110;
// Константни променлилви за пиновете, които се използват
const int divergent_led = 6;
const int straight_led = 7;
const int buttonpin = 8;
const int servopin = 9;
// константа със стойност за забавяне на движението на сервото в милисекунди
const int step_delay = 70;
// декларираме сервото
Servo myservo;
// глобални променливи за запомняне позицията на сервото
int pos = straight; // current
int old_pos = pos; // previous
void setup()
{
// настройване (инициализация) на режима на пиновете, които ще се ползват
pinMode(buttonpin, INPUT);
pinMode(straight_led, OUTPUT);
pinMode(divergent_led, OUTPUT);
// инициализация на сервото
myservo.attach(servopin); // attach to the servo on pin 9
myservo.write(pos); // set the initial servo position
// настройка на първоначалния статус на светодиодите
digitalWrite(straight_led, HIGH);
digitalWrite(divergent_led, LOW);
}
void loop()
{
// всяка итерация започва с промяна на състоянието на бутона
// при натиснат бутон (reads HIGH), се премества сервото
int button_state = digitalRead(buttonpin);
if(button_state == HIGH){
// Изключва LED-а
if(pos == straight){
digitalWrite(straight_led, LOW);
} else {
digitalWrite(divergent_led, LOW);
}
old_pos = pos; // запазваме текущата позиция
// променя позицията в обратното състояние
pos = pos == straight ? divergent: straight;
// премества сервото до новата позиция
if(old_pos < pos){ // ако новия ъгъл е по- голям
//завърта (увеличава) серво позицията от старото до новото състояние
for(int i = old_pos + 1; i <= pos; i++){
myservo.write(i); // записва следващата позиция на сервото
delay(step_delay); // пауза
}
} else { // обратно новия ъгъл е по- малък и ли равен
// завърта (намалява) серво позицията
for(int i = old_pos - 1; i >= pos; i--){
myservo.write(i); // записва следващата позиция на сервото
delay(step_delay); // пауза
}
}
// Запалва съответния LED.
if(pos == straight){
digitalWrite(straight_led, HIGH);
} else {
digitalWrite(divergent_led, HIGH);
}
}
}// край
-
Митко, съжалявам за езика там....но така пишат понякога хамершканците. Още повече, щото смятат, че те са целия свят!!!
"Голяма работа", че например ние не знаем нито кой е Рик Флин,
нито какъв е другия клуб от който са взели макета и какво по дяволите е "Стъфи" дето не работел достатъчно много по него....
Примера по-горе е от план А (в момента са на план С) и съм го
дол само са се види, че едно ардуиното модулче има капацитета и
може да управлява до три стрелки и тъчскрийн цветен дисплей от 5 см.
Както написах и под снимката - останалото е въпрос на графика и код за по-приятно вид. Както и това е важно - вместо евтините китайски драйвири, могат да се сложат всякакви други, които да
врътката коректно сервомашинки. Емчо също по-горе уточнява, че вероятно ще слага разширение в изходите, за да подобри възможностите за натоварването им.
Нали разбираш, че план С, вероятно ще си остане в хамершканците и едва ли ще го споделят със света (дето не го и знаят), така че, излишно си се мъчил да си превеждаш текста - той само казва какво правят, но не и начина по който (ще) става!
:drinks:
А сега като "зарибих" и други за дисплей (и тъчскрийн),
ще следя с интерес темата и уроците от Чаушев!
:hi:
-
Не знам Емчо докъде е докарал проекта ...лято...море... отпуски!!!
:drinks: bg&flag :beach:
Но докато сме на страничната тема за тъч дисплей :victory:
ето едно мноооого приятно възможно решение:
https://youtu.be/E0iDrJERb98
Въпрос на проектиране и всичко което се полага, за да стане
един красив "екранопулт" за управление заедно с ардуйно-то на десет машинки ( разклонения)!
... примерно!!!
Редактора е много готин, но си иска и един тъч на ръка, за да се експериментира все пак за пълните му възможности.
Но за това, като го докарате до екран-а!!!
:hi:
-
.......
===============
КОД
#include <Servo.h>
// константни променливи използвани за ъглите на сервото в градуси
const int straight = 90;
const int divergent = 110;
// Константни променлилви за пиновете, които се използват
const int divergent_led = 6;
const int straight_led = 7;
const int buttonpin = 8;
const int servopin = 9;
// константа със стойност за забавяне на движението на сервото в милисекунди
const int step_delay = 70;
// декларираме сервото
Servo myservo;
// глобални променливи за запомняне позицията на сервото
int pos = straight; // current
int old_pos = pos; // previous
void setup()
{
// настройване (инициализация) на режима на пиновете, които ще се ползват
pinMode(buttonpin, INPUT);
pinMode(straight_led, OUTPUT);
pinMode(divergent_led, OUTPUT);
// инициализация на сервото
myservo.attach(servopin); // attach to the servo on pin 9
myservo.write(pos); // set the initial servo position
// настройка на първоначалния статус на светодиодите
digitalWrite(straight_led, HIGH);
digitalWrite(divergent_led, LOW);
}
void loop()
{
// всяка итерация започва с промяна на състоянието на бутона
// при натиснат бутон (reads HIGH), се премества сервото
int button_state = digitalRead(buttonpin);
if(button_state == HIGH){
// Изключва LED-а
if(pos == straight){
digitalWrite(straight_led, LOW);
} else {
digitalWrite(divergent_led, LOW);
}
old_pos = pos; // запазваме текущата позиция
// променя позицията в обратното състояние
pos = pos == straight ? divergent: straight;
// премества сервото до новата позиция
if(old_pos < pos){ // ако новия ъгъл е по- голям
//завърта (увеличава) серво позицията от старото до новото състояние
for(int i = old_pos + 1; i <= pos; i++){
myservo.write(i); // записва следващата позиция на сервото
delay(step_delay); // пауза
}
} else { // обратно новия ъгъл е по- малък и ли равен
// завърта (намалява) серво позицията
for(int i = old_pos - 1; i >= pos; i--){
myservo.write(i); // записва следващата позиция на сервото
delay(step_delay); // пауза
}
}
// Запалва съответния LED.
if(pos == straight){
digitalWrite(straight_led, HIGH);
} else {
digitalWrite(divergent_led, HIGH);
}
}
}// край
Имаме следният случай - сервото е на позиция 90 градуса, когато схемата се изключва.
При следващо включване при инициализацията /отбелязаното в тъмно/ е дадено сервото да се завърти на 90 градуса.
Реално то е на тези градуси. Какво ще се случи? - Сервото няма да мръдне или ще направи движение?
-
Няма да мръдне!
То си е изравнило исканите показания и подава
обратно, че Е на 90 градуса.
-
Няма да мръдне!
То е изравнило и подава показания че Е на 90 градуса.
Това означава ли, че по този начин решаваме въпроса поставен по-горе от Митко
.....
Сериозният проблем е че при изключване на управлението (захранването) стрелките остават в положението, в което са в този момент. При ново включване с тези програмки се приема че сервото е в положение 0, или 90 или колкото сте му написали, но не и колкото е в действителност (а то може и да е 180). На теория това не може да се реши, освен ако няма "крайни изключватели", които да се четат преди въобще да се атачне порта на сервото. Трябва да са направени и да се четат така, че да се разпознават не само двете крайни положения, но и това че стрелката не е преместена докрай (случва се доста често). С първия пример може да си натискате бутона на порт 3 за да "нулирате" стрелката, ама тя хич няма да мръдне, защото ардуиното си знае че е в положение 0. Така че "реалната" програмка за стрелки ще изглежда доста различно.
-
Значи горе се изразих грешно...
НЕ " подава" а всъщност сравнява.
От ардуиното получава правоъгълен сигнал с честотата му,
която съответства за 90 градуса.
(http://www.robotshop.com/letsmakerobots/files/userpics/u22024/servo_pulse_width.jpg)
Когато сравни този сигнал
със настоящият си вътрешен който е за 90 градуса, " вижда"
че няма къде да "ходи". Тук има една тънкост - зависи колко финно е настроен сигнала от вън и сервото с какво качество е.
Ако има минимална разлика то ще я изравни чрез помръдвване,
което може и да не се отрази на управляевото разклонение.
За това се предвиждат винаги пружинни елементи в "трансмисията" които обикновенно са пружинна тел която компенсира такива потрепване и наместване.
Тоест тук няма значение какво иска ардуиното в новото си пускане, а какво може да изпълни сервото. Ако то се окаже
на други градуси , ще има други данни в себе си и ще се движи докато не ги изравни с тези подавани му отвън.
Пример:
Начално включване.
Ардуиното подава сигнал "дай на 90 градуса" което е с една честота от 1.5 ms.
Сервото получава захранване и понеже датчика му е на 90 градуса само си генерира вътрешния сигнал също от 1.5 ms
Сравнява двата сигнала и мръдва само ако се различават.
Това се отнася за цифровите серво. Аналоговите са по грубички и сравняват не честота, а напрежение ( май), но всъщност вече едва ли някой ползва аналоговите някъде
-
Това означава ли, че по този начин решаваме въпроса поставен по-горе от Митко
Нещата са малко по-дебели.
Има кодове в нета, при които след всяка команда към сервото положението му се записва във флеша. А при стартиране се чете от там последното записано положение. Така при включване на тока всичко тръгва от там където си е било.
Обаче, като включиш захранването на сервото и ардуиното, не е ясно какъв сигнал ще даде ардуиното на управляващата жица. Най-често там сигналът се появява по-късно, поради което при включване на тока най-често всичките сервА се зачукват в една крайна позиция, а ако си напарвил онази хитрост с флеш паметта след това хукват в предишното си положение. Още по шибано е ако механически не си предвидил сервото да се върти от край до край, а ако разчиташ само на управлението му за да го ограничиш до даден ъгъл на завъртане. Тогава при включване може спокойно да потрошиш или изкривиш нещо.
Тука хитринката се прави с едно РЕЛЕ, управлявано от ардуиното, което да включва захранването на серво машинките само по команда от програмата. Така можеш да инициализираш всичко, вкл. управляващия пин на сервото, и чак тогава да му щракнеш захранването. Също така захранването можеш и да го изключиш след завъртане на сервото, т.е. след изпълнение на командата и завъртането му докъдето трябва. Така сервото няма да жужи около зададенто му положение.
Пак остава неприятен момент, че някои от серво машинките при включване на захранването им се разхождат открай до край, независимо какви хитрини правиш и какво им подаваш на третата жица. Но обикновено такива се случват рядко. Като пробваш с един модел машинки и видиш че работят както трябва (с тези неща, написани по-горе), и като си ги харесаш и по цена и по доставка, работиш с този модел, и постваш тук барабар със снимките. Като не става с един модел - пак пишеш тук и т.н. докато стане.
-
Мдааааа ...ето още един тънък момент - куплирането му със ардуиното. Интересно другите как са решили тази тънкост?
Митко дава една доста интересна и лесна реализация!
:hi:
...и е прав - трябва на живо да се експериментира до задоволителен резултат.
-
Няма да мръдне!
То си е изравнило исканите показания и подава
обратно, че Е на 90 градуса.
Никой нищо не подава обратно. Сервото не може да се чете къде е останало. Ардуиното помни положението от последната команда. Т.е. функцията read() връща положението от последната write() команда, а не къде е сервото в действителност. Ако сервото е било на 90 гр. и му подадеш команда да отиде на 90 гр, то няма да мръдне, а след командата ардуиното ще запомни че вече е на 90 гр.
-
Митко, коригирал съм се почти веднага в следващи пост и точно
това съм написал в него, намира се под този който коментираш ти.
Не знам защо не си го прочел!?
-
Ами може пък и да съм го прочел. И да съм го разбрал двусмислено. Кое е серво, кое е ардуино, кой кого управлява, кое е цифрово, кое пък толкова "фино да е настроено отвън". Видях че пишеш и за някакви честоти и т.н. И понеже някои неща не са така, ако искаш - смятай го че съм повторил - но не всичко, а това което смятам че е вярното.
-
Не е нужно да стигаме до разправии. Предлагам ако нещо не е пълно просто да се допълваме.
В събота сигурно ще взема нещата от Емо и ще видя как ще се "запознаем" с Ардуиното. Че може да не си допаднем, знае ли човек.
-
Сега ще сложа един малко по- сложен код за управление на сервото между 90 и 110 градуса, като в кода се вижда, че с декларирането и атачването се заема положение"Право" на стрелката.
Опитната постановка е за упраление с един бутон, свързан към пин 8 и серво на пин 9, като на пин 8 имаме оново резистор, който да държи масата. Всяко натискане на бутона води до превключване в противоположното положние на стрелката.
(http://thenscaler.com/wp-content/uploads/2014/12/Servo-Control-by-Button-293x300.jpg)
================
КОД:
#include <Servo.h>
// константни променливи използвани за ъглите на сервото в градуси
const int straight = 90;
const int divergent = 110;
// Константни променлилви за пиновете, които се използват
const int buttonpin = 8;
const int servopin = 9;
// константа със стойност за забавяне на движението на сервото в милисекунди
const int step_delay = 70;
// декларираме сервото
Servo myservo;
// глобални променливи за запомняне позицията на сервото
int pos = straight; // current
int old_pos = pos; // previous
void setup()
{
// деклариране на пина за бутона
pinMode(buttonpin, INPUT);
// ето тук казваме директно след атачването да се обърне в права позиция сервото
myservo.attach(servopin); // attach to the servo on pin 9
myservo.write(pos); // set the initial servo position
}
void loop()
{
// всяка итерация започва с промяна на състоянието на бутона
// при натиснат бутон (reads HIGH), се премества сервото
int button_state = digitalRead(buttonpin);
if(button_state == HIGH){
old_pos = pos; // запазва текущата позиция
// променя позицията в обратното състояние
pos = pos == straight ? divergent: straight;
// премества сервото до новата позиция
if(old_pos < pos){ // ако новия ъгъл е по- голям
// завърта (увеличава) серво позицията от старото до новото състояние
for(int i = old_pos + 1; i <= pos; i++){
myservo.write(i); // записва следващата позиция на сервото
delay(step_delay); // пауза
}
} else { // обратно новия ъгъл е по- малък и ли равен
// завърта (намалява) серво позицията
for(int i = old_pos - 1; i >= pos; i--){
myservo.write(i); // записва следващата позиция на сервото
delay(step_delay); // пауза
}
}
}
}// край на цикъла
Някой може ли да ми разясни потъмнения код?
-
Щом казваш Митко... :scratch_ones_head:
Щом взеха да се виждат разправии на останалите, аз спирам до тук. :hi:
Павка, най-добре пробвай - не е сложно.
Ето ти едно възможно решение с "липсващите" честоти.
Впрочем драйверната платка е много приятно допълнение и е
за 16 канала. В кода е даден елементарен принцип на действие.
Ти ( вие) го обвържете с бутоните за всеки канал ( както по-горе
сте го описали). Под клипа има линкове и към библиотеката с
премерния код. Дори започва именно с инициалиализация на
честотите за различните ъгли в рамките на 50-те херца
( виж горния ми пост диаграмата - периода е от тези 50 херца,
а коефициента на запълване дава трите основни честоти за ъглите).
Цената е " съвместима" с цената на платките с процесорчето и
драйвера.
Драйвера на платката има и други възможни функции
като например управление на стъпков двигател ( на мястото на
двата ДС мотора), а от него до управление на обръщателно кръг
са вече броени на пръсти оставащите стъпки.
Демонстрацията е с по-малък брой сервомашинки ( цифрови)
за това ползват адаптера. Бих препоръчал по-хубаво захранване за 16 машинки (SG90):
https://youtu.be/QjX4JKU_I9M
От тук нататък и аз като останалите очаквам да споделите
резултатите от пробите. Така е по-лесно явно.... :hi:
Успех!!!
-
Потъмненият код:
pos = pos == straight ? divergent: straight;
означава:
Ако pos е равно на straight, тогава pos става равно на divergent, иначе pos става равно на straight;
все едно имаш:
if (pos == straight)
pos = divergent
else
pos = straight
или казано на друг език:
if (a > b) {
result = x;
} else {
result = y;
}
може да се запише като:
result = a > b ? x : y;
-
Благодарско, много разбираемо обяснение.
:drinks:
-
Само да вметна: ако ще използваш готов код, а няма да си го пишеш сам, ето едно руско творение за три машинки с три бутона и едновременна работа, със запомняне във флеша. И със светодиоди. По добре почни от него, а не от началото.
говорил один мой знакомый: "Это баг, которы вовсе не баг, потому что в скрипах все правильно".
Грешу на сервы...
Сори, комменты кривые, особенно с реверсом, но думаю мысль понятна. Смысл тот же, что у местного ServoMotion.
Код:
//подключаемые библиотеки
#include <EEPROM.h>
#include <Bounce2.h>
#include <Servo.h>
//переменные конфигурации
int servoAngles[][2]={{0,90},{0,90},{0,90}}; // углы отклонения сервоприводов {"прямо", "в бок"}
byte servoReverce[]={0,0,0}; //реверс углов сервоприводов (если в положении "прямо" угол задан во втором элементе предыдущего массива, то поставить 1.)
int servoSpeed[]={10,10,10}; //скорость вращения сервопривода. указано количество миллисекунд поаорота на 1 градус
//переменные определяюще ножки подключения
int normalLed[]={8,10,12}; //ножки подключения светодиода показывающего прямое положение стрелки
int routeLed[]={9,11,13}; //ножки подключения светодиода показывающего положение стрелки "в бок"
int servoPins[]={3,5,6}; //ножки подключения провода управления сервопривода
int buttonPins[]={2,4,7}; //ножки подключения кнопок переключения
//переменные используемые при повороте сервопривода
byte CurrentPosition[]={0,0,0}; //текущее положение сервопривода. 0=прямо, 1=в бок.
int currentAngle[]={0,0,0};//текущий угол поворота сервопривода
unsigned long nextTime[]={0,0,0};// время следующего поворота на 1 градус
unsigned long currentTime; //текущее время
byte dir;// направление поворота сервопривода
//объекты сервоприводов и антидребезка кнопок
const int servos=sizeof(servoPins)/sizeof(int);
Servo servoServos[servos];
Bounce servoBouncer[servos];
void setup() {
for(int i=0;i<servos;i++){
pinMode(buttonPins, INPUT);
servoBouncer = Bounce();
servoBouncer.attach(buttonPins);
servoBouncer.interval(5);
pinMode(normalLed, OUTPUT);
pinMode(routeLed, OUTPUT);
if(EEPROM.read(i) > 1){
EEPROM.update(i,0);
}
CurrentPosition=EEPROM.read(i);
digitalWrite(normalLed, !CurrentPosition);
digitalWrite(routeLed, CurrentPosition);
servoServos.attach(servoPins);
if(servoReverce){
servoServos.write(servoAngles[!CurrentPosition]);
currentAngle=servoAngles[!CurrentPosition];
}
else {
servoServos.write(servoAngles[CurrentPosition]);
currentAngle=servoAngles[CurrentPosition];
}
}
delay(1000);
for(int i=0;i<servos;i++){
servoServos.detach();
}
}
void loop() {
currentTime=millis();
for(int i=0;i<servos;i++){
if(nextTime>0 && nextTime<currentTime){
if(currentAngle>=servoAngles[0] && currentAngle<=servoAngles[1]){
nextTime=currentTime+servoSpeed;
if(servoReverce){
dir=!CurrentPosition;
}
else {
dir=CurrentPosition;
}
if(dir){
currentAngle++;
}
else {
currentAngle--;
}
if(servoAngles[1]/currentAngle == 2 || servoAngles[1]/currentAngle == 2.5 ){
digitalWrite(normalLed, !CurrentPosition);
digitalWrite(routeLed, CurrentPosition);
}
servoServos.write(currentAngle);
}
else{
nextTime=0;
servoServos.detach();
}
}
if(servoBouncer.update()){
if(servoBouncer.read()==LOW){
CurrentPosition=!CurrentPosition;
EEPROM.update(i,CurrentPosition);
nextTime=currentTime;
if(servoReverce){
currentAngle=servoAngles[CurrentPosition];
}
else {
currentAngle=servoAngles[!CurrentPosition];
}
servoServos.attach(servoPins);
}
}
}
}
И клипче как работи: https://www.youtube.com/watch?v=akvCsXheF6A (https://www.youtube.com/watch?v=akvCsXheF6A)
В тмоя код не виждам къде превиш detach ...
-
Само да вметна: ако ще използваш готов код, а няма да си го пишеш сам, ето едно руско творение за три машинки с три бутона и едновременна работа, със запомняне във флеша. И със светодиоди. По добре почни от него, а не от началото.
говорил один мой знакомый: "Это баг, которы вовсе не баг, потому что в скрипах все правильно".
Грешу на сервы...
Сори, комменты кривые, особенно с реверсом, но думаю мысль понятна. Смысл тот же, что у местного ServoMotion.
Код:
//подключаемые библиотеки
#include <EEPROM.h>
#include <Bounce2.h>
#include <Servo.h>
//переменные конфигурации
int servoAngles[][2]={{0,90},{0,90},{0,90}}; // углы отклонения сервоприводов {"прямо", "в бок"}
byte servoReverce[]={0,0,0}; //реверс углов сервоприводов (если в положении "прямо" угол задан во втором элементе предыдущего массива, то поставить 1.)
int servoSpeed[]={10,10,10}; //скорость вращения сервопривода. указано количество миллисекунд поаорота на 1 градус
//переменные определяюще ножки подключения
int normalLed[]={8,10,12}; //ножки подключения светодиода показывающего прямое положение стрелки
int routeLed[]={9,11,13}; //ножки подключения светодиода показывающего положение стрелки "в бок"
int servoPins[]={3,5,6}; //ножки подключения провода управления сервопривода
int buttonPins[]={2,4,7}; //ножки подключения кнопок переключения
//переменные используемые при повороте сервопривода
byte CurrentPosition[]={0,0,0}; //текущее положение сервопривода. 0=прямо, 1=в бок.
int currentAngle[]={0,0,0};//текущий угол поворота сервопривода
unsigned long nextTime[]={0,0,0};// время следующего поворота на 1 градус
unsigned long currentTime; //текущее время
byte dir;// направление поворота сервопривода
//объекты сервоприводов и антидребезка кнопок
const int servos=sizeof(servoPins)/sizeof(int);
Servo servoServos[servos];
Bounce servoBouncer[servos];
void setup() {
for(int i=0;i<servos;i++){
pinMode(buttonPins, INPUT);
servoBouncer = Bounce();
servoBouncer.attach(buttonPins);
servoBouncer.interval(5);
pinMode(normalLed, OUTPUT);
pinMode(routeLed, OUTPUT);
if(EEPROM.read(i) > 1){
EEPROM.update(i,0);
}
CurrentPosition=EEPROM.read(i);
digitalWrite(normalLed, !CurrentPosition);
digitalWrite(routeLed, CurrentPosition);
servoServos.attach(servoPins);
if(servoReverce){
servoServos.write(servoAngles[!CurrentPosition]);
currentAngle=servoAngles[!CurrentPosition];
}
else {
servoServos.write(servoAngles[CurrentPosition]);
currentAngle=servoAngles[CurrentPosition];
}
}
delay(1000);
for(int i=0;i<servos;i++){
servoServos.detach();
}
}
void loop() {
currentTime=millis();
for(int i=0;i<servos;i++){
if(nextTime>0 && nextTime<currentTime){
if(currentAngle>=servoAngles[0] && currentAngle<=servoAngles[1]){
nextTime=currentTime+servoSpeed;
if(servoReverce){
dir=!CurrentPosition;
}
else {
dir=CurrentPosition;
}
if(dir){
currentAngle++;
}
else {
currentAngle--;
}
if(servoAngles[1]/currentAngle == 2 || servoAngles[1]/currentAngle == 2.5 ){
digitalWrite(normalLed, !CurrentPosition);
digitalWrite(routeLed, CurrentPosition);
}
servoServos.write(currentAngle);
}
else{
nextTime=0;
servoServos.detach();
}
}
if(servoBouncer.update()){
if(servoBouncer.read()==LOW){
CurrentPosition=!CurrentPosition;
EEPROM.update(i,CurrentPosition);
nextTime=currentTime;
if(servoReverce){
currentAngle=servoAngles[CurrentPosition];
}
else {
currentAngle=servoAngles[!CurrentPosition];
}
servoServos.attach(servoPins);
}
}
}
}
И клипче как работи: https://www.youtube.com/watch?v=akvCsXheF6A (https://www.youtube.com/watch?v=akvCsXheF6A)
В тмоя код не виждам къде превиш detach ...
Малеееее, ти ме разби. Аз още се уча да различавам променлива от функция
Тук виждам нови за мен неща като - int normalLed[]={8,10,12};
До сега за мен декларирането беше int normalLed=8.
Сега тия скоби и нещата в тях ме хвърляш в оркестъра. Ама ще продължавам да чета.
Благодаря още веднъж.
-
Малеееее, ти ме разби. Аз още се уча да различавам променлива от функция
Тук виждам нови за мен неща като - int normalLed[]={8,10,12};
До сега за мен декларирането беше int normalLed=8.
Сега тия скоби и нещата в тях ме хвърляш в оркестъра. Ама ще продължавам да чета.
Благодаря още веднъж.
Нали са до три машинки - 0, 1 и 2
int normalLed[]={8,10,12};
все едно че имаш
normalLed[0]=8;
normalLed[1]=10;
normalLed[2]=12;
-
Нали са до три машинки - 0, 1 и 2
int normalLed[]={8,10,12};
все едно че имаш
normalLed[0]=8;
normalLed[1]=10;
normalLed[2]=12;
Май вденах - става въпрос за масив.
Ще ми трябва повече време да го асимилирам.
-
Само да докладвам. Ардуиното дойде. Вчера почнах да го ръчкам. За сега карам един светодиод да премигва по мой команди. Тъй като това си е направо нищожно за това нищо не съм пуснал.
-
Ето тук има едно съвсем просто и лесно за разбиране примерче за серво
http://michaelsarduino.blogspot.bg/2017/03/servo-motor-mit-dem-arduino.html (http://michaelsarduino.blogspot.bg/2017/03/servo-motor-mit-dem-arduino.html)
И нещо за ардуино да кажа може и да го знаете но за тези които не го знаят да спомена
че чипа има ограничение за тока въпреки че пише че всеки изход осигурява макс 20mA
истината е че това е максималния ток за целия чип а не за всеки изход по отделно
За ардуино които са изградени с малките квадратни чипчета от типа TQFP/QFN/MLF
За оригиналното ардуино уно с големия чип тип PDIP му дават 40mA но това пак е за целия чип
Така че трябва да се внимава какво се закача на изходите особено с безобидните светодиотчета
щото една проста сметка ако имаш 10 светодиотчета по 3mA сещате се кво се получава ;D
-
Светльо, това което си написал, не знам от къде го знаеш. Може да си го прочел в техн. спец. на производителя, най-добре в оригинал. Може да си го прочел и в някой блог или форум. Или някой да ти го е казал. Съветвам те да вярваш само на първото, освен ако не вярваш в дядо коледа. Иначе - представи си че 10 човека цитират твоя пост, и после някой каже че наистина е така, защото на 10 места пише че е така?
В ардуиното има един чип - ATmega328. Има техн. спец. на чипа, има и на ардуиното - пише точно и ясно: макс. ток на I/O pin - 40 мА. Консумация на самия процесор - от 2 до 19 мА (може и друго да пише) - в зависимост от конкретния чип, честота, SW и т.н. Макс. ток през GND или Vcc - 200 мА. Спокойно можеш да си вържеш 10 светодиода по 3 мА и заедно с чипа ще имаш не повече от 50 мА, при допустими 200.
-
Нещо се е заблудил по невнимание.
Митко е съвсем прав. Виждал съм голямото ардуиното да върти по
четири сервомашинки без проблем.
Но все пак е хубаво когато се прави нещо за обща употреба,
тоест нещо различно от настоящето самообучение, да се купи
някоя от допълнителните платки ( известни още със звучната
"българска" дума - шилдове) за да е съвсем коректно употребата им.
Тук някъде нагоре бях показал такъв "шилд" точно за употребата с повече сервомашинки. Тоест тъкмо нещо като драйверната платка за нашите цели. Даже имаше опция с един ( или два) изхода за стъпкови електромотори.
Тоест хубавото е, че така можем да " вържем попа, за да е кротко селото"!!!
;D
ПП. " 16 channel servo shield for arduino "
(https://img.banggood.com/thumb/water/oaupload/banggood/images/B7/50/e2e63ed9-57b4-48f1-a19c-0962a14e694c.jpg)
Цена около 12$:
https://m.banggood.com/2-Channel-Motor-16-Channel-Servo-Expansion-Board-For-Arduino-UNO-Smart-Car-Chassis-Robot-Arm-p-1051594.html
Работен ток Io: ≤1.2А
Максимална консумация на енергия:
4 W (T = 90 ℃)
Вход за управляващ сигнал:
Високо ниво: 2.3V≤VIH≤VIN;
ниско ниво: -0.3V≤VIL≤1.5V
Работна температура:
-25 ℃ - + 125 ℃
Режим на задвижване:
Двойна голяма мощност H-мост драйвер ( буфер)
Тегло: около 46 грама
Включен пакет:
1 x 2-канала за DC мотори
( или един общ канал за стъпков мотор)
+ 16-канален сервоусилвател
-
Гледам във всяка програмка за въртене на моторче започва със:
#include <Servo.h>
Това доколкото разбрах от ровенето из интернет е някаква готова библиотека.
Въпросите са ми:
1. Явно трябва задължително да се запише този ред в програтамата. Така ли е?
2. Какво точно прави тази библиотека? В смисъл в кода после трябва ли нещо да е съобразено с тази библиотека?
-
Естествено че трябва кодът ти да е съобразен с тази библиотека.
В servo.h хората вече са ти написали много неща, с помощта на които ти можеш да използваш сервото. Когато ти си пишеш твоя код, ти не казваш на сервото какво да прави, а казваш на тази библиотека какво да прави със сервото. За целта в библиотеката са написани и съответните функции, с помощта на които ти да си комуникираш с нея. За това е задължително (според мен) да знаеш какво прави библиотеката.
Можеш да погледнеш в официалния сайт: https://www.arduino.cc/en/Reference/Servo (https://www.arduino.cc/en/Reference/Servo). Написано си е точно какви функции има библиотеката и какво можеш да ползваш от нея. Мисля че това е достатъчно, дори и не само за начало, но и за сериозна употреба на сервото. Ако пък толкова ти е интересно, можеш да потърсиш и детайлите - как работи самата библиотека, и съответно във форумите да прочетеш какви са проблемите с нея, въпреки че и в общото описание (от линка) са дадени всички детайли, които ти трябват.
ПС: на примера, който ти дадох, се ползва три библиотеки. Можеш по същия начин да видиш за какво са и какви функции имат. Според мен ще ти трябват и те. Поне тази за бутоните.
-
1. Тази библиотека включва декларациите за класове и функции, с които се управлява сервото, защото те не са стандартни за езика C.
2. Библиотеката позволява извикване на всички функции и обекти в кода, които указват на сервото какво да прави (как да се завърти). Ако тази библиотека не е включена, всяко извикване като напр. servoServos.attach(servoPins); ще гърми с грешка при компилиране. И тогава ще трябва да се пише и доста код от по-ниско ниво.
P.S. Митко ме е изпреварил, при това с повече подробности :)
-
... servoServos.attach(servoPins); ще гърми с грешка при компилиране.
Не съм сигурен в този компилатор, ама още на Servo myservo; трябва да изгърми.
-
Ето какво съм "открил" до сега:
#include <EEPROM.h> - тази библиотека пази стойностите когато платката е изключена.
#include <Servo.h> - това вече го споменахме - за управлението на машинката
#include <Bounce2.h> - за това обаче още нищо не мога да открия.
-
Библиотеката "<Servo.h>" може също да е с доста различно съдържание, както казва и Митко. Можеш да си я пишеш и сам,
но ще трябва допълнително да четеш на официалният сайт.
За твойте проби и съответно през "прекия път" намери от някъде да си я свалиш готова. Почти всеки който се е заел сериозно с управлението на сервомашинки с ардуиното, предоставя и линк към готова такава библиотека. От теб се иска да я дръпнеш и провериш върши ли ти работа или не точно.
Ето една примерна:
https://github.com/esp8266/Arduino/blob/master/libraries/Servo/src/Servo.h
-
Ето това ти е Bounce2
https://github.com/thomasfredericks/Bounce2 (https://github.com/thomasfredericks/Bounce2)
Дефакто служи за премахване на смущения от контакти на релета ключета и други такива които правят по няколко паразитни
импулса понеже са механични контакти
-
Всъщтност идеята на тея библиотеки е да улесняват обикновените потребители които нямат професионални познания и умения
по програмиране каквато е и самата идея на ардуино. Особено такива в обектното програмиране .
За съжаление обаче пак трябва да имаш познанията по програмиране и да схванеш концепцията на обектите
и как се извикват инстанций на обекти как се достигат членове ако искаш да пишеш собствен код ползвайки готовите библиотеки.
Иначе трябва а ползваш готови програми което не е невъзможно защото дефакто в 99% от случайте това което може да ти дотрябва
някой вече го е написал . И от теб се иска само да си го свалиш и да си го заредиш в ардуиното.
Библиотеката "<Servo.h>" може също да е с доста различно съдържание, както казва и Митко. Можеш да си я пишеш и сам,
Това не е съвсем вярно ако е с различно съдържание той няма да е <Servo.h> ще е <Servo2.h> или <pachServo.h>
библиотеките се свалят от официални сайтове за ардуино библиотеки каквито са https://github.com примерно
в много редки случай за някакви много екзотични неща може да се намерят библиотеки на сайтовете на потребители
такъв случай е примерно библиотека за работа на ардуино с външна памет от типа С93 която аз намерих на сайта на един китаец ;D
Не съм сигурен в този компилатор, ама още на Servo myservo; трябва да изгърми.
Компилатора на ардуино си е съвсем валиден С++ компилатор и е нормално да даде грешка още първия път когато се опиташ да извикаш инстанция на обект който нямаш ;D
-
Така е - обикновенно нормалните софтуеристи именуват всичко,
с подсказващи в имената им определители.
Но има ли още такива софтуеристи (нормални)!!!!?
:lol: :lol: :lol:
Това е брадата шегичка на техен гръб (отново го направих),
но за съжаление тя все още си е актуална.
В горния пример съм дал линк към ESP8266 Servo.h
Но така или иначе, трябва да се намери подходящата библиотека, или да се напише за конкретните нужди.
Примера е даден за да може да се почне от някъде с писането, ако не върши работа за конкретния ни въпрос.
При максималистите става винаги с написване на собствен код, останалите поради липса на време или друго ( по избор) се доверяваме на готовото. Някой дори не го тестват - направо го ползват....да ви звучи познато за България!?
:scratch_ones_head:
шегички разни...
:yes: ;D
-
Може да се каже че всички които програмирането им е професия и тея на които не им е професия но са го приели при сърце като хоби и са достатъчно добри че да споделят кодовете си и да имат последователи са нормални познават различните стилове и нотаций и са си избрали към кой да се придържат и го правят.
Не са нормални такива като мен дето програмирането нито им е професия нито им е чак толкова присърце но са принудени да го научат щото им трябва по една или друга причина. Преди се занимавах с онлайн игри и се наложи да се уча на РНР MySQL няколко години след това се разви много бързо флаш и вече простите уеб базирани игри не можеха да стъпят и на малкия пръст на графиката на флаша и ми омръзна. Сега с ардуино ми се наложи да почета още малко добре че РНР и С++ за много близки и не се наложи кой знае колко усилие една точка като оператор е различна и тея указатели и указатели към указателите . Обектите не ги схванах като концепция още при РНР не мисля да се напъвам и на С++ с тях в крайна сметка аз си пиша за собствена лична употреба не мисля да споделям или да правя уроци .Та в тая връзка ако кода е писан от някой като мен може да има много нетипични неща иначе хората които си се занимават си правят нещата както трябва или както мислят че трябва .
Щото и аз знам как трябва да се пише но пиша така както ми е удобно :lol:
-
Някъде четох, че на Ардуино Нано и Уно може да се вържат до 5 сервомоторчета. На Ардуино Мега имате ли идея колко позволява?
-
Зависи от шилда...но принципно до 16 съм виждал в клип.
Опс...обърках Мега-та с Уно-то :blush2:
http://www.railwaypassion.com/forums/index.php/topic,4987.msg109548.html#msg109548
Без шилд все пак стига до 12 ( за Мега-та):
https://youtu.be/576uNIfUnD8
Ама нали.се сещаш, че ще ти трябва и ново захранване за толкова!?
Ако ползваш сигналите съм този шилд отиваш вече на 24:
https://m.banggood.com/24-Channel-Servo-Motor-Driver-Controller-Module-For-Arduino-Robot-p-934353.html?utm_campaign=7858775_934353&utm_content=1087&p=CS120478587752016125
-
Servo библиотеката поддържа до 48 сервА с Мега, и 12 на останалите. Заради таймерите в процесора. Отделно си сметни крачетата и захранването до къде ще ти стигнат.
-
Servo библиотеката поддържа до 48 сервА с Мега, и 12 на останалите. Заради таймерите в процесора. Отделно си сметни крачетата и захранването до къде ще ти стигнат.
Това ми друг въпрос - как се смята консумацията на сервомашинките? На всички или само не тези дето са в действие?
Няма да се движат всички заедно. Най-много три. Това не би трябваво да е проблем от гледна точка на консумацията, нали?
-
При всяко включване, и при всеки ресет, ще мърдат всичките. Освен ако не им сложиш по някое реле / MOS ключ в захранването и да ги пускаш едно по едно или по няколко, но не всички наведнъж.
-
Само да споделя какво ще правя.
Тази събота би трябвало да сглобя последните модули. Следва корка и полагане на релси и идва момента с Ардуиното.
В момента не съм поръчвал почти нищо. Имам една платка Ардуино Нано + 5 серво моторчета.
Имам една руска книжка за Ардуино и май там четох, че на Нано може да се включат само до 5 моторчета. Идеята ми е платката да се намира на самия модул. Обаче при гърловините идват повече стрелки и ще трябват повече от 1 платка. За това почвам да се замислям дали за гърловините да не взема Ардуино Мега.
За сега си мисля индикацията на таблото да се взима от ключетата, които ще захранват сърцето на стрелката, така че няма да ми трябват допълнителни пинове за обратната връзка. Но ако намешам и светофори вече незнам на колко платки отивам.
Ето и схемата на гарата:
https://www.dropbox.com/s/0pm1aiigwr8q6dn/%D0%95%D0%BB%D0%B8%D1%81%D0%B5%D0%B9%D0%BD%D0%B0%20%D0%9D0%20%2B%20%D0%9D0%D0%B5-Model%20A3.pdf?dl=0 (https://www.dropbox.com/s/0pm1aiigwr8q6dn/%D0%95%D0%BB%D0%B8%D1%81%D0%B5%D0%B9%D0%BD%D0%B0%20%D0%9D0%20%2B%20%D0%9D0%D0%B5-Model%20A3.pdf?dl=0)
като на левия модул при магазията стана една промяна в движение и отпадна една стрелка:
https://www.dropbox.com/s/4h8uxoag8zvjirp/%D0%95%D0%BB%D0%B8%D1%81%D0%B5%D0%B9%D0%BD%D0%B0%20%D0%9F%D0%A0%D0%9E%D0%9C%D0%AF%D0%9D%D0%90%20%D0%BC%D0%B0%D0%B3%D0%B0%D0%B7%D0%B8%D1%8F-05%2C02%2C18.pdf?dl=0 (https://www.dropbox.com/s/4h8uxoag8zvjirp/%D0%95%D0%BB%D0%B8%D1%81%D0%B5%D0%B9%D0%BD%D0%B0%20%D0%9F%D0%A0%D0%9E%D0%9C%D0%AF%D0%9D%D0%90%20%D0%BC%D0%B0%D0%B3%D0%B0%D0%B7%D0%B8%D1%8F-05%2C02%2C18.pdf?dl=0)
Червеното е НОе, синьото НО
-
Гарата е доста сериозна. Чувал съм, че с ардуиното лесно и бързо могат да се направят малки проектчета. Ама тук изглежда дебела работа.
Как ще ги щракате стрелките - с копчета на всеки модул? По едно Нано на всеки модул трябва да свърши работа. Това, което имаш, го запиши с програма за 12 машинки, закачи петте, които имаш, и виж дали и как работят.
Ако искаш да се обвързват светофори с положение на стрелки, наредени маршрути и заети участъци, трябва да имаш връзка между модулите и т.н. По скоро използвай друго Нано само за сигнализацията. Аз бих сложил и още едно, отделно, само за управление - от копчетата на гарата до модулите. Така машинките ще се щракат от всеки модул самостоятелно и независимо. Ако добавиш и управлението - ще може да редиш маршрути, а като добавиш и сигнализацията - ще имаш и нормално светещи лампи. Но влаковете ще могат да се движат и без тези последните две. Програмите за тях няма да се бъркат с програмите за серво машинките и може да си ги доправяш когато и както ти хрумне.
-
Гарата е доста сериозна. Чувал съм, че с ардуиното лесно и бързо могат да се направят малки проектчета. Ама тук изглежда дебела работа.
Как ще ги щракате стрелките - с копчета на всеки модул? По едно Нано на всеки модул трябва да свърши работа. Това, което имаш, го запиши с програма за 12 машинки, закачи петте, които имаш, и виж дали и как работят.
Ако искаш да се обвързват светофори с положение на стрелки, наредени маршрути и заети участъци, трябва да имаш връзка между модулите и т.н. По скоро използвай друго Нано само за сигнализацията. Аз бих сложил и още едно, отделно, само за управление - от копчетата на гарата до модулите. Така машинките ще се щракат от всеки модул самостоятелно и независимо. Ако добавиш и управлението - ще може да редиш маршрути, а като добавиш и сигнализацията - ще имаш и нормално светещи лампи. Но влаковете ще могат да се движат и без тези последните две. Програмите за тях няма да се бъркат с програмите за серво машинките и може да си ги доправяш когато и както ти хрумне.
Моята идея е:
- на всеки модул със стрелки да сложа Нано, а за двете гърловини се чудех дали да не е Мега.
- като натисна копчето за примерно 3-ти коловоз - контролера да обърне съответните две стрелки
- когато включа светофори, евентуално да проверява съответната стрелка дали е обърната правилно и тогава да светне зелено
- на таблото да показва на къде са обърнати стрелките от ключетата отдолу който ще захранват сърцата на стрелката
- таблото на маневрения район - 4 и 5 коловоз на НО, както и целият парк на малките модули в НОе да е дублирано, така че да мога да дам на машиниста да си прави сам маневри, без да закача гаровия персонал - това го видях в Чехия миналата година.
-
Това колко серво машинки може да се включат към едно ардуино зависи от използваната библиотека
Има библиотека наречена софтоерно серво която прави всеки пин на ардуиното способен да командва серво
И съответно мини нано уно те имат приблизитерно еднакъв брой пинове щото ползват един и същ чип 328р
ако искаш много повече съответно мега щото тя е с друг чип с 44 пина докато предходните са с 32 пинови чипове
Обаче има една уловка част от пиновете ще ти трябват за бутони не знам как мислиш да ги включваш тея стрелки
Ако е с дсс един пин ти трябва за дсс сигнала всички други са ти свободни за серво
ама ако ще ползваш бутони примерно 6 пина управляват 9 бутона вързани в матрица 3х3 или 8 пина за 16 бутона вързани в матрица 4х4
В нета има много готови проекти тествани въведени в експлоатация с ардуино както за дсс така и аналогови
-
Това колко серво машинки може да се включат към едно ардуино зависи от използваната библиотека
Май тук трябва да поясня: Всичко, което съм писал в тази тема, се отнася за библиотеките от "официалния" сайт: https://www.arduino.cc/en/Reference/Libraries (https://www.arduino.cc/en/Reference/Libraries). Разбира се че има и други библиотеки, дори и със същите имена, има и такива само за две серво машинки.
-
Това колко серво машинки може да се включат към едно ардуино зависи от използваната библиотека
Има библиотека наречена софтоерно серво която прави всеки пин на ардуиното способен да командва серво
И съответно мини нано уно те имат приблизитерно еднакъв брой пинове щото ползват един и същ чип 328р
ако искаш много повече съответно мега щото тя е с друг чип с 44 пина докато предходните са с 32 пинови чипове
Обаче има една уловка част от пиновете ще ти трябват за бутони не знам как мислиш да ги включваш тея стрелки
Ако е с дсс един пин ти трябва за дсс сигнала всички други са ти свободни за серво
ама ако ще ползваш бутони примерно 6 пина управляват 9 бутона вързани в матрица 3х3 или 8 пина за 16 бутона вързани в матрица 4х4
В нета има много готови проекти тествани въведени в експлоатация с ардуино както за дсс така и аналогови
Да, да с бутон ще бъдат. Питането ми беше, защото имам желание гърловината да бъде на една платка, че един ден като включа и светофори да мога да правя проверка дали е обърната правилно стрелката при опит да се включи зелено.
В този ред на мисли - Ардуиното може ли да се включват две платки каскадно? На едната да бъде изход и с кабел да влиза в другата декларирано като вход?
-
да може да се вържат много платки ардуино една към друга но не е никак лесно
има портоколи няколко по който правят комуникация обаче аз не съм виждал такива разработени неща
може и да има просто аз да не съм попадал понеже аз нямам серво мойте стрелки са с бобини и не съм търсил по принцип.
А да си напишеш сам софтуера си е една доволно трудна и времеемка задача.
Иначе по ДСС ардоино мини може да управлява макс 17 машинки това го имам то го има и като пример
в библиотеката NmraDcc
Иначе ардуино нано мини и уно имат по 18 пина с които можеш да правиш квото искаш
но два от тях рядко се ползват извън основната им функция точно за SPI комуникация D0 и D1 са RX и TX
-
Тогава наистина се замислям за гърловините да ползвам Ардуино Мега, че да ми останат свободни пинове за сигнализация, а за гаражните коловози стрелките ще ги управлявам с Ардуино Нано.
Лявата гърволина е със 8 стрелки - това са 16 пина от платката. Дясната 7 стрелки - 14 пина
Надявам се когато почна светофорите да ми стигнат пиновете.
-
Тогава наистина се замислям ...
Ама ти се замисляш, като че ли ще купуваш бира и ракия - дали ще стигне, дали няма да стигне ... никой не знае.
Нарисувай си цялата схема - с всички бутончета, моторчета, вход / изход към сигнализацията, и виж колко и какви пинове ще ти трябват. Сигналите си ги остави на отделно ардуино.
-
Ама ти се замисляш, като че ли ще купуваш бира и ракия - дали ще стигне, дали няма да стигне ... никой не знае.
Нарисувай си цялата схема - с всички бутончета, моторчета, вход / изход към сигнализацията, и виж колко и какви пинове ще ти трябват. Сигналите си ги остави на отделно ардуино.
Ако са на отделно тогава ще мога ли да правя проверка на къде са обърнати стрелките преди са светне зелено?
Иначе и мен ме блазни мисълта да са на отделни платки, в случай че изгори някоя платка да не спре всичко.
-
Аз разбрах че накъде е обърната стрелката ще разбираш от ключета, с които ще захранваш и сърцата, и лампите на пулта?
-
Аз разбрах че накъде е обърната стрелката ще разбираш от ключета, с които ще захранваш и сърцата, и лампите на пулта?
То май аз съм в грешка как се казват. За това става въпрос:
(http://media.snimka.bg/s1/5952/038148517-big.jpg?r=0)
Но последно ще го правя така - за всяка стрелка ще ми трябват по 3 пина от платката - за бутон, за сервото и за индикация.
Светофорите когато ги правя ще бъдат както предложи - на отделни платки и няма да има връзка със стрелките.
За да е максимално просто - в случай на авария бързо да може да се отстрани.
-
При толкова много стрелки сигнализация и сравнително сложен макет не си ли се замислял за ДСС
това аналогово ли ще го караш
при това сложно коловозно развитие аналогово колко влака ще караш
Ардуиното по принцип е вкарано в дсс проекти като по евтина алтернатива на стандартните модули за стрелки и сигнализация
-
При толкова много стрелки сигнализация и сравнително сложен макет не си ли се замислял за ДСС
това аналогово ли ще го караш
при това сложно коловозно развитие аналогово колко влака ще караш
Ардуиното по принцип е вкарано в дсс проекти като по евтина алтернатива на стандартните модули за стрелки и сигнализация
Не, това е гара за Фремо срещи. Управлението на гарата трябва да е отделно от това за локомотивите.
-
Смятай че стрелките, управлявани с мотори, или серво, нямат две положения, а имат поне три: "ляво", "дясно" и "някъде по средата".
На ардуиното ти предлагам да използваш по три пина на стрелка: един за сервото, един за "на ляво", един за "на дясно". Да подаваш 0 за задействане в съответната посока. Не знам как си го мислил само с един бутон да управляваш една стрелка? Може да стане, но тогава трябва да изчистиш смущенията от контакта (с това bounce2). Освен това какво ще прави този един бутон - ще превключва от текущото положение в другото? Или винаги от + в -? Поне за мен е по-сложно, а и за програмата е по-сложно.
Или този пин ако е на 0 - ляво, ако е на плюс - дясно? Ами ако прекъсне жицата? Т.е. ако контактът на ключа не е идеален? Пак bounce2. А като имаш две ключета - като няма нищо на тях - стрелката не мърда. Като има 0 на едното - пускаш я да върви в едната посока, независимо колко прекъсва или не тази 0. Като пуснеш 0 на другото - врътваш сервото в другата посока. Ако пуснеш 0 и на двете - може и нищо да не правиш, или която нула прочетеш първа - все тая, няма да е страшно за стрелката.
Тези две ключета, които са на рамото, са много хубави и аз взех от тях да слагам. За тях ти предлагам и на двете ключета средният край да е на 0. Когато ключето натисне лоста в крайно положение, на неговия нормално отворен контакт да сложиш индикацията към плюса. Може да е лампа, светодиод и т.н. Този сигнал ще вземеш и за светофорите (ако ти трябва). Пак от тази 0, която ще дойде само в крайно положение на стрелката, може да задействаш едно реленце, което да ти захранва сърцето от съответната релса (ако трябва да го правиш), а пък другото реленце от другия ключ - от другата релса. Така в междинно положение на стрелката сърцето ще е изолирано, което е голямо предимство. Двете реленца не са голям разход - по около левче всяко. Нормално затворените контакти няма да ти трябват. Ако не е ясно какво искам да кажа, ще го драсна на една схемичка. Индикация от самото ардуино няма да има нищо общо с реалното положение на стрелката. А и на един пин индикацията ще ти е 0 или 1, а не с три положения. А индикация от тези ключета ще е действителното положение на стрелката, освет ако не се е извадила телчицата от сервото до езика.
-
В този им вид двете ключета са проектирани да подават захранване на сърцето на стрелката, т.е. те са вързани към релсовите вериги => съгласно FREMO правилата не могат да се използват за захранване на други принадлежности.
Те обаче наистина могат да участват във верига на бистабилни релета, от които едната им управлявана верига да храни сърцето, а другата да се ползва за обратна връзка към Арлекиното.
Павка без чертане на ел. схемите няма да се разминеш. Въпросът е дали искаш малко кабели, тъй като гарата е на доста модули и ще трябва преходници между модулите на кабеляка, + малко портове или ще се ходи на лесна конфигурация с повечко кабели и повече Арлекинота
-
Смятай че стрелките, управлявани с мотори, или серво, нямат две положения, а имат поне три: "ляво", "дясно" и "някъде по средата".
На ардуиното ти предлагам да използваш по три пина на стрелка: един за сервото, един за "на ляво", един за "на дясно". Да подаваш 0 за задействане в съответната посока. Не знам как си го мислил само с един бутон да управляваш една стрелка?.....
В този клип дето си дал като пример в по-преден пост гледам, че с един бутон го правят. За това реших, че може да стане.
https://www.youtube.com/watch?v=akvCsXheF6A (https://www.youtube.com/watch?v=akvCsXheF6A)
-
Павка на клипа е точно - един бутон, а ардуиното брои всяко негово натискане, като изпълнява последователно следващо действие. То се вижда че е с един пин/ проводник а бутона е на "+"
през резистор.
Впрочем човека показва и отговор на твоя въпрос - за ресет
при първоначално вкл. на захранването, независимо къде са ти
спрели машинките.
Остава да влезеш във връзка с човека илида намериш кода,
който сигурно го е публикувал някъде.
има линкове в профила му от тубата към Фейсбук и VK, както и към гогле+!!!
Само ще трябва да експериментираш за общия брои на машинките.
Впрочем като стигнеш до това, може някой от тях да ти "жужат"
Оправяло се чрез прецизиране на тайминга ( таймерите).
Успех!
:yes: ;D
ПП. Впрочем човека ( явно е в Щатите) е реализирал и DCC управление с ардуиното. ...някой тук май правеше опити за такова.
-
С едно бутонче да превключваш стрелката - може да стане, и кодът е точно за такова включване. Аз съм написъл че "на мен ми е сложно". ТАNО си ги прави така - с по едно бутонче, което превключва стрелката от текущото положение в другото. Поне такива спомени имам. Само че той си реди и маршрути - през цялата гърловина и през всички стрелки с начало и край на маршрута, като за релетата на стрелките има и друго управление - ляво и дясно.
Я си представи че утре решиш да сложиш едно бутонче - "движение по трети коловоз" (например). Тогава на стрелката трябва да кажеш точно накъде да се включи. А може и да са няколко стрелки, през които минаваш. Ако имаш само по един бутон на стрелка, трябва да четеш състоянието - на къде е в момента, и да смяташ дали трябва да се превключи или не. Ако си с по две бутончета за стрелка - даваш си директно командите за твоя коловоз.
Дори и една по една да си ги щракаш, трябва да погледнеш индикацията на къде е и тогава да зъкнеш бутончето или не. А ако са две бутончета - цъкъш си посоката без да гледаш на къде е, т.е. и без да ти работи индикацията.
На моя макет първоначално щраках всяка стрелка по отделно. Доста бързо ми писна, беше неудобно, и си сложих по едно копче за коловоз, пък от него да се управляват всички стрелки по пътя. Но то си е въпрос на вкус.
За сърцата: ако на модула има по едно реленце, управлявано от тези ключета на рамото на сервото, ако има захранване на модула (напр. 5 волта, което ще трябва и за сервото, и за ардуиното) ще е захранено и сърцето. Бистабилни релета ще си останат в състоянието, дори и ако се откачи захранването, а положението може да е грешното. Ако не е включено 5-те волта, просто сързето ще остане изолирано, но няма да направи късо или друг проблем. Ще драсна довечера една схемичка, но в крайна сметка всеки си го прави както му харесва.
-
Павка на клипа е точно - един бутон, а ардуиното брои всяко негово натискане, като изпълнява последователно следващо действие. То се вижда че е с един пин/ проводник а бутона е на "+"
през резистор.
Впрочем човека показва и отговор на твоя въпрос - за ресет
при първоначално вкл. на захранването, независимо къде са ти
спрели машинките.
Остава да влезеш във връзка с човека илида намериш кода,
който сигурно го е публикувал някъде.
има линкове в профила му от тубата към Фейсбук и VK, както и към гогле+!!!
Само ще трябва да експериментираш за общия брои на машинките.
Впрочем като стигнеш до това, може някой от тях да ти "жужат"
Оправяло се чрез прецизиране на тайминга ( таймерите).
Успех!
:yes: ;D
ПП. Впрочем човека ( явно е в Щатите) е реализирал и DCC управление с ардуиното. ...някой тук май правеше опити за такова.
И кода го има в поста на Митко:
http://www.railwaypassion.com/forums/index.php/topic,4987.msg109426.html#msg109426 (http://www.railwaypassion.com/forums/index.php/topic,4987.msg109426.html#msg109426)
Проблема ми е, че той ползва масиви и малко се обърквам като искам да го проследя, за да го разуча, че да го нагодя за моя случай.
-
С едно бутонче да превключваш стрелката - може да стане, и кодът е точно за такова включване. Аз съм написъл че "на мен ми е сложно".
Така е - всичко е въпрос на програмиране и удобство. Не е задължително бутоните да са "вързани" към положенията/посоките на стрелките (2 бутона за 2 положения), защото при тройна или английска стрелка ще има два мотора с 4 положения и съответно ще трябват 4 бутона, което води до усложнения по таблото и повече заети входове в контролера. 1 бутон върши чудесна работа като просто някъде в програмата (в променлива или масив) се помни текущото положение (в права или крива, условно 0 или 1) за съответната стрелка и всяко следващо натискане обръща мотора и съответно сменя стойността в променливата. За английска стрелка съответно положенията ще са 0, 1, 2 и 3. За всяко следващо положение ще се превключват два мотора и стойността на променливата ще се увеличава, а при достигане на положение 4 се прави преход към 0 и все сначале. Може дори да се ползват бутони не за стрелки, а за нагласяне на маршрути по съответните коловози. Примерно за 10 коловоза ще има 10 бутона и всяко натискане ще превключва съответните стрелки в съответните позиции. А при желание, може всичко да става и само с 1 бутон - всяко натискане редува маршрут за всеки следващ коловоз, но това вече е извратено, дори и за мен ;D
Тук естествено съм спестил, че трябва да се отчита и липсата на положение (моментът в който сервото върти и е "някъде по средата", както казва Митко), защото това води до усложнения при реденето на маршрути, а именно дали всички стрелки от маршрута да се превключват едновременно (повече стрелки => по-голяма консумация) или една след друга (повече стрелки => повече време за установяване) и как да бъде разпределено това в програмата със съответните проверки и прехващане на всички възможни грешки и изключения. Но както казах и в началото, всичко е въпрос на (правилно) програмиране и (търсено) удобство ;)
-
Хубаво е, ако може, да има и малка прилика с действителността ;D
-
една идея ако искате от мен
щом ви трябват много пинове и много бутони може да пробвате това
ардуино има аналогови входове
аналоговите входове могат да четат стойност на напрежението от 0 до 5 волта като за тоя диапазон изарват стойност на променливата от 0 до 1024 .
Та идеята е следната последователно вързани съпротивления от + захранване към маса примерно 10 броя по 1ком
между всяко от тях единия край на бутона и другия край общ за всички бутони към пин 3 примерно
и с analogRead() се взима стойноста тя ще е разбична за всеки бутон но ще може да се натиска само по 1 едновремено
и като имаш стойност после с мойта любима
switch (var) {
case label1:
// statements
break;
case label2:
// statements
break;
default:
// statements
}
може и с
if (condition)
{
//statement(s)
}
ако ви е по любима. Това е само идея не съм го пробвал но съм пробвал потенциометър и ардуиното си чете както споменах по горе има го и като пример в самата програма за аналогови примери. А е твърде възможно и 20 съпротивления да се вържат по 470 ома и трябва да се види само дали при всяко натискане на един и същ бутон дава една и съща стойност ако има малки разлики
няма да е проблем да се направи диапазон с if
прпимерно нещо такова
int analogPin = 3;
int val = 0;
void setup()
{
Serial.begin(9600); // setup serial
}
void loop()
{
val = analogRead(analogPin); // read the input pin
Serial.println(val); // debug value
if (val>0 && val<10){ //код за задействане на серво }
if (val>10 && val<30){ //код за задействане на серво}
//и така нататък за всички бутони
}
}
}
Най вероятно стойноста няма да е еднаква всеки път ще се различава в некъв малак диапазон щото това зависи от моментната стойност на напрежението все пак входа е доста чувствителен 1024 / 5 = 204,8 еденици на 1 волт се падат
-
Като гледам най-сложната гърловина има 7 стрелки, които могат да се управляват с 10 бутона по "моя си" начин. 20 пина ще стигнат.
-
Искам да се похваля с напредъка.
Дали се вижда този клип?:
https://www.dropbox.com/s/9rrjgm746wd7b73/VIDEO0007.mp4?dl=0 (https://www.dropbox.com/s/9rrjgm746wd7b73/VIDEO0007.mp4?dl=0)
-
Ето и кода който съм ползвал. Не е мой. Емо го е дал като пример на по-предна страница. Аз само го нагодих малко и сложих малко по-разбираеми /поне за мен/ имена на константите и променливите:
#include <Servo.h>
// константи за градусите на сервото
const int pravo = 0;
const int diasno = 90;
// константи за пиновете, които ще се използват
const int butonpin = 6;
const int servopin = 5;
const int led_pravo = 7;
const int led_otklonenie = 9;
// константа за периода на забавяне на върнете на сервото
const int period = 100;
//декрарираме сервото
Servo Strelka1;
//променливи за запомняне позицията на сервото
int pos = pravo; // текуща позиция
int pos_old = diasno; // предишна позиция
void setup() {
// изпълнява се веднъж при пускане на програмата
// декрарираме пиновете, които ще се ползват
pinMode (butonpin,INPUT);
pinMode (led_pravo, OUTPUT);
pinMode (led_otklonenie, OUTPUT);
// атачваме сервото и го караме да се обърне в права позиция
Strelka1.attach(servopin); // закача сервото на пин 5
Strelka1.write(pos); //сервото се обръща в права позиция
//Strelka1.detach();
// настройка първоначален статус на светодиодите
digitalWrite (led_pravo, HIGH);
digitalWrite (led_otklonenie, LOW);
}
void loop() {
// изпълнява се постоянно
// с всяко натискане на бутона се променя позицията на сервото
int buton_push = digitalRead(butonpin);
if(buton_push ==HIGH){
// изключва светодиода за право
if(pos == pravo){
digitalWrite (led_pravo, LOW);}
else{
digitalWrite (led_otklonenie, LOW);
}
pos_old = pos; //запазва текущата позиция
if(pos==pravo)
{pos=diasno;}
else{pos=pravo;}
//pos=pos==pravo ? diasno:pravo; // променя позицията в обратно състояние
//Strelka1.attach(servopin);
if(pos_old<pos){
for(int i = pos_old + 1; i <=pos; i++){
Strelka1.write(i); // записва следващата позиция на сервото
delay(period); // забавяне
// Strelka1.detach();
}
}
//Strelka1.attach(servopin);
if(pos_old>pos){
{
for(int i = pos_old - 1; i >=pos; i--){
Strelka1.write(i); // записва следващата позиция на сервото
delay(period); // забавяне
// Strelka1.detach();
}
}
}
// Светва съответния пин
if (pos == pravo){
digitalWrite (led_pravo, HIGH);
}
else{
digitalWrite (led_otklonenie, HIGH);
}
}
}
Както ще видите в кода съм се опитал да закачам и после да откачам сервото при всяка операция, но не се получи. Явно не съм го сложил на правилното място.
Продължавам борбата.
-
Както ще видите в кода съм се опитал да закачам и после да откачам сервото при всяка операция, но не се получи. Явно не съм го сложил на правилното място.
Премести тези detach с един ред надолу (след скобата) и ще стане. Ама и това attach го мръдни да е след първата скоба на if. Пък на втория if имаш и един комплект излишни скоби.
if(pos_old<pos){
Strelka1.attach(servopin);
for(int i = pos_old + 1; i <=pos; i++){
Strelka1.write(i); // записва следващата позиция на сервото
delay(period); // забавяне
}
Strelka1.detach();
}
if(pos_old>pos){
Strelka1.attach(servopin);
for(int i = pos_old - 1; i >=pos; i--){
Strelka1.write(i); // записва следващата позиция на сервото
delay(period); // забавяне
}
Strelka1.detach();
}
-
Миткооооо.
Велик си. Стана. Работи като часовник.
:drinks:
-
Остана сега да реша другия проблем.
Като спра захранването когато е в основното положение, като го включа всичко е точно.
Обаче, когато го изключа в отклонение не става баш добре. Светодиода светва като за направо, защото така е дадено в програмата, но сервото не мърда. Натискам копчето и все едно платката се събужда - прави един бърз ход до положение "право" и после бавно се придвижва до "оклонение" като светва и съответния светодиод.
-
Ще трябва да си поиграеш още малко за да го видиш откъде е. Сложи някакъв delay(1000) в началото, преди първия attach, че и още един след него, преди първия write. След това нали има detach? Това всичкото да е в setup()
-
тук в setup трябва да се прави проверка с if
digitalWrite (led_pravo, HIGH);
digitalWrite (led_otklonenie, LOW);
примерно както е направена такава във loop
if(pos == pravo){
digitalWrite (led_pravo, HIGH);
digitalWrite (led_otklonenie, LOW);
}
else{
digitalWrite (led_otklonenie, HIGH);
digitalWrite (led_pravo, LOW);
}
а може би ще е по добре и със
switch (pos ) {
case pravo:
digitalWrite (led_pravo, HIGH);
digitalWrite (led_otklonenie, LOW);
break;
case diasno :
digitalWrite (led_otklonenie, HIGH);
digitalWrite (led_pravo, LOW);
break;
default:
digitalWrite (led_otklonenie, LOW);
digitalWrite (led_pravo, LOW);
}
в случай че позицията е неопределена някаде е спряло къдету му е дошло
-
Светльо, в setup не можеш нищо да проверяваш. Сервото не може да се чете. Просто му се дава команда да отиде в началната посока. И се надяваш отгоре да няма влак.
-
Малко встрани от Arduino, някой може ли да предложи читава схема за захранване на серво мотори /5V,3-5A/, при включване да не подскачат/ както се вижда и в клипа на колегата/. Аз ги мъча по DCC, но при подаване на захранването от декодера : (http://media.snimka.bg/s1/6126/038496494.jpg?r=0),
подскачат дразнещо и застават в положението, в което са спрени /cv34 -1/. Пробвах и това :http://www.fucik.name/masinky/servo/Acc_decc_4servo_sch.GIF (http://www.fucik.name/masinky/servo/Acc_decc_4servo_sch.GIF), ефекта е същият. С това http://www.elimex.bg/product/96196/zahranvasht-blok-hy3005d.html (http://www.elimex.bg/product/96196/zahranvasht-blok-hy3005d.html) без управляван пин също подскача.
Най-интересно е, че с това http://www.constructor.bg/mk/Supply.htm (http://www.constructor.bg/mk/Supply.htm), при подаване на напрежение сервото помръдва нищожно малко /може би около 0,5мм/, просто както се вижда е доста по трудоемка схема от горе описните.
Някой пробвал ли е UBEC Servo Power Supply със SG90 и дали има ефект от подобно нещо :https://es.aliexpress.com/item/Hot-1pc-BEC-UBEC-3A-5V-Brushless-Receiver-Servo-Power-Supply-for-RC-Airplane-Aircraft-New/32787549778.html?spm=2114.search0204.3.1.10777051ae5jfo&ws_ab_test=searchweb0_0%2Csearchweb201602_1_10152_10151_10065_10344_10068_10342_10343_10340_10341_10084_10083_10618_10304_10307_10302_5711211_10313_10059_10534_100031_10103_10627_10626_10624_10623_10622_5722411_10621_10620_5711311%2Csearchweb201603_37%2CppcSwitch_5_ppcChannel&algo_expid=e0c1931d-29dd-482f-86bf-d0b6e200d19b-0&algo_pvid=e0c1931d-29dd-482f-86bf-d0b6e200d19b&transAbTest=ae803_5&priceBeautifyAB=0 (https://es.aliexpress.com/item/Hot-1pc-BEC-UBEC-3A-5V-Brushless-Receiver-Servo-Power-Supply-for-RC-Airplane-Aircraft-New/32787549778.html?spm=2114.search0204.3.1.10777051ae5jfo&ws_ab_test=searchweb0_0%2Csearchweb201602_1_10152_10151_10065_10344_10068_10342_10343_10340_10341_10084_10083_10618_10304_10307_10302_5711211_10313_10059_10534_100031_10103_10627_10626_10624_10623_10622_5722411_10621_10620_5711311%2Csearchweb201603_37%2CppcSwitch_5_ppcChannel&algo_expid=e0c1931d-29dd-482f-86bf-d0b6e200d19b-0&algo_pvid=e0c1931d-29dd-482f-86bf-d0b6e200d19b&transAbTest=ae803_5&priceBeautifyAB=0).
-
Светльо, в setup не можеш нищо да проверяваш. Сервото не може да се чете. Просто му се дава команда да отиде в началната посока. И се надяваш отгоре да няма влак.
да абсолютно прав си
не погледнах целия код само последните постове и това което съм написал е безсмислено ;D
-
Сервото не може да се чете. Просто му се дава команда да отиде в началната посока. И се надяваш отгоре да няма влак.
Тука вече трябва да се вкарат онези ключета за двете крайни позиции на рамото. Дали директно, дали през релета, не мога да кажа, но те трябва да се четат на два от входовете на Ардуиното.
И в setup() следва да се проверява тяхното положение. Ако входът за положение "право" е 0 (условно), това ще значи, че рамото е "в отклонение" или "някъде по средата". Прави се цикъл в който се подава команда на сервото да се премести с една стъпка (градус или каквото е там) към положение "право" и след това се проверява отново за 1 на вход "право" - ако е налично, цикълът се прекратява. Така, при включване, стрелката винаги ще преминава в позиция "право".
Но остава проблемът с колоос, зацепена в езика. Тогава, сервото няма да може да се премести в положение "право". Затова следва да се броят и колко стъпки са му подадени, т.е. цикълът трябва да е с for. Ако стъпките са повече от максималния брой, нужни за преместване от едната крайна позиция в другата за дадената стрелка, следва излизане от първия цикъл и позициониране в положение "отклонение" с нов цикъл, при който вече сервото ще се върти в другата посока и ще се чете другото ключе за достигане на крайната позиция.
Ако и при втория цикъл не може да се достигне крайна позиция след максималния брой стъпки за пълно отклонение, следва да се подаде някаква индикация за неизправност в стрелката, защото сервото не работи, някое от ключетата е дефектирало, има прекъсване в окабеляването или някой е омазал баластирането и езика е залепнал.
-
Mixy, така е най-добре, ама ще стане много истинско. Не е за "първи стъпки".
-
Ще трябва да си поиграеш още малко за да го видиш откъде е. Сложи някакъв delay(1000) в началото, преди първия attach, че и още един след него, преди първия write. След това нали има detach? Това всичкото да е в setup()
Махнах detach-а в setup-а и вече работи. Ако е в отклонение изключено, при включване застава в правилна позиция.
Явно му трябва повече време да се "освести"
-
Ще се опитам и аз да споделя какво направих.
Не е по-различно от описаното до тук, но работи успешно.
Използвам Arduino Nano, като с него управлявам четири стрелки.
За всяка стрелка се използват четири извода на Arduino: един за бутона, един за сервота и два за светодиодите, пиказващи положението на стрелката.
Програмката е написана от брат ми - Иван Цанков, който също е запален по това хоби.
Ако Mixy ми помогне ще я публикувам тук.
Иначе платката изглежда така:
(https://s19.postimg.org/5p5makxpf/IMAG0054.jpg)
(https://s19.postimg.org/j62ktfkvn/IMAG0055.jpg)
(https://s19.postimg.org/cfm3k05fn/IMAG0056.jpg)
Направих тестов модул с три стрелки собствено производство. Целта е да тествам стрелките и управлението им със сервота, преди да се захвана с нещо по-сериозно.
Получи се това:
(https://s19.postimg.org/5p5makpzn/IMAG0058.jpg)
И ето как действа:
https://youtu.be/XKqiFnL7eAw (https://youtu.be/XKqiFnL7eAw)
-
Изглежда страхотно. Ще бъда благодарен ако пуснеш кода.
Един въпрос - 4 стрелки всяка ползва по 4 пина това прави 16 пина, а ардуиното има 14?
Ползвате някой от аналоговите ли?
-
Ардуино нано има 19 пина.
Кода не знам как мога да го кача тук. Затова писах, че Mivy трябва да ми помогне.
Иначе мога да ти го изпратя на e-mail, aкo ми кажеш твоя.
В програмката има коментари, които обясняват всичко, включително свързването на бутоните и светодиодите.
-
Не съм сигурен къде точно е проблема с качването на кода, затова ще импровизирам: отваряш си редактора, в който ти е програмата и маркираш целия код (обикновено става с Ctrl-A), след което го копираш в клипборда (Ctrl-C). Накрая започваш нов отговор в темата тук и поставяш кода от клипборда в браузъра (Ctrl-V).
-
Вместо да копирам кода, не може ли да го прикача като файл?
Все пак е доста дълъг.
-
Може, но трябва да използваш външен сървър където да го качиш или пък някоя услуга като Google Disk, Dropbox и др. подобни, след което да пуснеш линк към файла.
-
Това за мен е доста сложно, неразбираемо.
Предпочитам да ти го изпратя на електронна поща и ти да го качиш.
Извинявай, че минах на ти!
-
с любезното съдействие на VladoC:
https://www.dropbox.com/s/zh90gvqrszc43x0/Servo_PWM_Digi.ino?dl=0 (https://www.dropbox.com/s/zh90gvqrszc43x0/Servo_PWM_Digi.ino?dl=0)
-
404 - File not found.
-
сега?
https://www.dropbox.com/s/8gw2006ldt0ww84/Servo_PWM_Digi.ino?dl=0 (https://www.dropbox.com/s/8gw2006ldt0ww84/Servo_PWM_Digi.ino?dl=0)
-
Сега е ОК :)
-
Остана ми да разреша още един проблем. В момента платката работи като часовник - при включване застава в положение "право", светодиодите показват коректно посоката на сервото, самото серво е включено само когато се върти.
Обаче нещо ме мъчи. Сутрин като започва срещата и включа захранването стрелките ще застанат в първоначално положение. Тук драма няма. Драмата, е когато по време на срещата мигне тока - тогава всички стрелки ще застанат в основно положение и ако минава в този момент влак ще стане неприятно.
Гледах различни кодове, но не мога да разбера добре библиотеката EEPROM. Виждам, че чрез нея се запомня текущото положение в секцията loop на програмата, а в setup се използва да се завърти сервото на тази позиция запомнена от библиотеката, а не както аз правя - винаги в права позиция.
Някой дали е запознат с тази библиотека да ми подскаже, с някой прост пример как се работи с нея? Ще съм изключително благодарен.
-
в самата програма има примери за <EEPROM.h>
за Ардуино 1,8,5 от менюто файл-примери- примери за ардуино генй и уно - това е третата секция
пирвия елемент от нея е точно EEPROM
и там има всичко основно изтриване четене записване
-
в самата програма има примери за <EEPROM.h>
за Ардуино 1,8,5 от менюто файл-примери- примери за ардуино генй и уно - това е третата секция
пирвия елемент от нея е точно EEPROM
и там има всичко основно изтриване четене записване
Аз там четох, но честно не можах да се ориентирам. Но друго ми направи впечатление - тази функция пише, че е ограничена по брой записи - 100 000 записа.
-
Това eeprom.h го има в сайта. Има едно read и е дно write. Като им даваш адрес къде да се чете и пише. Има го в последния файл. Има го и в примера на стр. 3, който аз изкопирах.
Ама я ми кажи за какво е това? Мърдаш сервото и всеки път записваш във флеша в какво положение е стрелката. Гасиш, пускаш. И караш сервото да се върти пак до там. Ами нали последно си го оставил там, при пускане на стрелката не и трябва да и даваш никакви команди, тя си е там където си я оставил.
Ами след като си угасил, и после пускаш наново, ако някой отиде да върти сервото на ръка, че да го премести? И да го премести, ти ще прочетеш къде си записал че е стрелката, а не къде в действителност е.
Така че това с eeprom върши работа само за начално светване на правилната лампа за посока, и то не според къде е стрелката, а според къде последно си записал че трябва да е.
Най-доброто е това, което ти написа Милен - в началото четеш ключетата, светваш си правилната лампа за посока и си задаваш правилното начално положение в променливите в програмата. БЕЗ да мърдаш стрелката и да я слагаш в някакво начлно положение. Ако не ти се харчат крачета за входове, можеш винаги при стартиране да не я движиш въобще, и да не палиш никаква лампа. Да отиде човек на място, да види че отгоре няма влак и да натисне някой от бутоните. Тогава всичко да си отиде където искаш и да светне както трябва.
Може и при включване да я мърдаш в "нормалното" и положение, или плюсовата посока.
-
Аз нещо се обърках. От това, което пише Павката излиза, че има някаква обратна връзка или че сервото "знае" на колко градуса е завъртяно и след изключване на тока. И при включване, винаги се установява в правилната посока (условно "направо" за стрелките или на 0 градуса). Така ли е или пак нещо не съм разбрал? :blush2:
Колкото до проблема с премигването на тока или дори спирането за по-дълго време, най-лесното решение е самото ардуино да бъде двойно захранено - нормално и през батерия (като лаптопите). Трябва все пак да се сметне и каква ще е консумацията при работеща програма за да е ясно колко минути ще издържи дадената батерия.
-
Сервото няма памет и не помни последната команда!
След изключване на захранването, сервото остава в положението в което е било.
При включване на захранването, без входен сигнал, сервото не променя положението си.
Сервото няма обратна връзка и Ардуиното не може да прочете нищо от него!
Занимавам се с корабо- и авиомоделизъм от 30 години и не съм срещал серва с памет и обратна връзка.
Все пак има съвременни серва с памет - failsafe, която се програмира чрез апаратурата за управление или чрез специален програматор. Тук за такива серва не става въпрос.
-
Това eeprom.h го има в сайта. Има едно read и е дно write. Като им даваш адрес къде да се чете и пише. Има го в последния файл. Има го и в примера на стр. 3, който аз изкопирах.
Ама я ми кажи за какво е това? Мърдаш сервото и всеки път записваш във флеша в какво положение е стрелката. Гасиш, пускаш. И караш сервото да се върти пак до там. Ами нали последно си го оставил там, при пускане на стрелката не и трябва да и даваш никакви команди, тя си е там където си я оставил.
Ами след като си угасил, и после пускаш наново, ако някой отиде да върти сервото на ръка, че да го премести? И да го премести, ти ще прочетеш къде си записал че е стрелката, а не къде в действителност е.
Така че това с eeprom върши работа само за начално светване на правилната лампа за посока, и то не според къде е стрелката, а според къде последно си записал че трябва да е.
Най-доброто е това, което ти написа Милен - в началото четеш ключетата, светваш си правилната лампа за посока и си задаваш правилното начално положение в променливите в програмата. БЕЗ да мърдаш стрелката и да я слагаш в някакво начлно положение. Ако не ти се харчат крачета за входове, можеш винаги при стартиране да не я движиш въобще, и да не палиш никаква лампа. Да отиде човек на място, да види че отгоре няма влак и да натисне някой от бутоните. Тогава всичко да си отиде където искаш и да светне както трябва.
Може и при включване да я мърдаш в "нормалното" и положение, или плюсовата посока.
Сигурно аз не го обясних като хората.
В момента като се възстанови захранването програмата винаги завърта сервото в положение "право" без значение къде е било преди това.
А ми се иска обратното - сервото да не мърда, а светодиодите да светнат правилно - ако е било в право при изгасването - да светне този диод и обратното. Точно както е на онзи руския пример дето си дал.
-
Ами тогава когато завъртиш сервото в единия край правиш EEPROM.update(0, 0), в другия край - EEPROM.update(0, 1);
При стартиране правиш EEPROM.read(0) и ако е 0 - палиш лампата за едната посока и правиш pos = pravo, ако е 1 - за другата посока и правиш pos = diasno.
-
Сервото няма памет и не помни последната команда! След изключване на захранването, сервото остава в положението в което е било.
И аз така си мисля, че трябва да е, обаче това
Сигурно аз не го обясних като хората. В момента като се възстанови захранването програмата винаги завърта сервото в положение "право" без значение къде е било преди това.
ме хвърля в оркестъра.
:scratch_ones_head: :blink: :wacko:
Има някаква магия тука...
-
Ами тогава когато завъртиш сервото в единия край правиш EEPROM.update(0, 0), в другия край - EEPROM.update(0, 1);
При стартиране правиш EEPROM.read(0) и ако е 0 - палиш лампата за едната посока и правиш pos = pravo, ако е 1 - за другата посока и правиш pos = diasno.
Направих го, но ми дава грешка на потъмнения ред:
#include <Servo.h>
#include <EEPROM.h>
// константи за градусите на сервото
const int pravo = 0;
const int diasno = 90;
// константи за пиновете, които ще се използват
const int butonpin = 6;
const int servopin = 5;
const int led_pravo = 7;
const int led_otklonenie = 9;
// константа за периода на забавяне на върнете на сервото
const int period = 100;
//декрарираме сервото
Servo Strelka1;
//променливи за запомняне позицията на сервото
int pos = pravo; // текуща позиция
int pos_old = diasno; // предишна позиция
void setup() {
// изпълнява се веднъж при пускане на програмата
// декрарираме пиновете, които ще се ползват
pinMode (butonpin,INPUT);
pinMode (led_pravo, OUTPUT);
pinMode (led_otklonenie, OUTPUT);
// атачваме сервото и го караме да се обърне в права позиция
Strelka1.attach(servopin); // закача сервото на пин 5
if (EEPROM.read(0)=0)
{pos=pravo;
digitalWrite (led_pravo, HIGH);}
else {pos=diasno;
digitalWrite (led_otklonenie, HIGH);}
Strelka1.write(pos); //сервото се обръща в права позиция
delay (1000);
Strelka1.detach();
// настройка първоначален статус на светодиодите
//digitalWrite (led_pravo, HIGH);
//digitalWrite (led_otklonenie, LOW);
}
void loop() {
// изпълнява се постоянно
// с всяко натискане на бутона се променя позицията на сервото
int buton_push = digitalRead(butonpin);
if(buton_push ==HIGH){
// изключва светодиода за право
if(pos == pravo){
digitalWrite (led_pravo, LOW);}
else{
digitalWrite (led_otklonenie, LOW);
}
pos_old = pos; //запазва текущата позиция
if(pos==pravo)
{pos=diasno;}
else{pos=pravo;}
//pos=pos==pravo ? diasno:pravo; // променя позицията в обратно състояние
//Strelka1.attach(servopin);
if(pos_old<pos){
Strelka1.attach(servopin);
for(int i = pos_old + 1; i <=pos; i++){
Strelka1.write(i); // записва следващата позиция на сервото
delay(period); // забавяне
// Strelka1.detach();
}
Strelka1.detach();
EEPROM.update(0, 0);
}
//Strelka1.attach(servopin);
if(pos_old>pos){
Strelka1.attach(servopin);
for(int i = pos_old - 1; i >=pos; i--){
Strelka1.write(i); // записва следващата позиция на сервото
delay(period); // забавяне
// Strelka1.detach();
}
Strelka1.detach();
EEPROM.update(0, 1);
}
// Светва съответния пин
if (pos == pravo){
digitalWrite (led_pravo, HIGH);
}
else{
digitalWrite (led_otklonenie, HIGH);
}
}
}
-
Аз там четох, но честно не можах да се ориентирам. Но друго ми направи впечатление - тази функция пише, че е ограничена по брой записи - 100 000 записа.
Това е абсолютно вярно и се отнася за всичко което има памет от типа флаш
флашки декодери пик контролери ардуинота и т.н.
а за грешката в тоя иф ти си направил присвояване а не проверка за сравнение трябва двойно равно ==
освен това присвояваш на отговор от функция
осен това библиотеката до колкото мога да видя от кода че не знам коя е си има променливи за позицията
и явно в .срр файла си има функций за писане и четене от епрома
вместо да се опитваш и ти да пишеш и то явно върху един и същ адрес
пробвай с проверка на pos_old това ще съдържа последното записано нещо преди изгасване на тока
като гледам тия редове
for(int i = pos_old + 1; i <=pos; i++){
for(int i = pos_old - 1; i >=pos; i--){
обаче то може да съдържа стойности явно от 0 до 90 ако е умрялно на 38 примерно кво правим
Това записва стъпките направени от сервото от 0 до 90 и обратно от 90 до 0
иначе кода ще работи така
// атачваме сервото и го караме да се обърне в права позиция
byte value;
value = EEPROM.read(0);
Strelka1.attach(servopin); // закача сервото на пин 5
if (value ==0)
-
обаче то може да съдържа стойности явно от 0 до 90 ако е умрялно на 38 примерно кво правим
Това записва стъпките направени от сервото от 0 до 90 и обратно от 90 до 0
сори направил съм грешнен извод стойностите са само две 0 и 90 то ги записва чак след като излезе от цикъла
;D
-
Направих го, но ми дава грешка на потъмнения ред:
if (EEPROM.read(0)=0)
Направи го
if (EEPROM.read(0)==0)
-
Митко, Светльо,
страхотни сте. Имате :drinks: от мен. Питал съм много хора, но само тук във форума получих съдействие.
Оправих двойното равно, бях объркал посоките и като го изключа отиваше в другата посока, но смених да е ==1 и нещата заспаха.
Малко по-късно ще направя клипче и ще публикувам кода.
Прави ми впечатление, че като включих тази библиотека му трябва маааалко повечко време за инициализация. За сега не е фатално, но ще видя като станат три машинки дали няма да му трябва доста време.
Като стана въпрос за три машинки, за да им запомня и тяхното положение трябва да е така:
if (EEPROM.read(0)==0) - за първата
if (EEPROM.read(1)==0) - за втората
if (EEPROM.read(2)==0) - за третата
и за ъпдейта:
EEPROM.update(0, 1); - за първата
EEPROM.update(1, 1); - за втората
EEPROM.update(2, 1); - за третата
Нали не бъркам?
-
да ама ще трябва да се дописва целия код на програмата трябва да се добавят променливи и за втори и трети бутон
променливите свързани със положението на сервото също ще трябва да се добавят и за второто и за третото
и всичко това да се добави във целия код надолу в програмата
Защо не ползвате тая програма която изкара VladoC гледах е тя е написана професионално
и е доста по добра
А и не си споменал как ще захранваш ардуиното с кво напрежение с 5в или с нещо между 6 и 12 волта
всяко ардуино има вграден стабилизатор и два входа за захранване
за микро са VCC за 5в и RAW за между 6 и 12 волта
мисълта ми е що не си подсигуриш захранване с кондензатор един голям или няколко по малки вързани успорено
консумацията е малка и един 4700мф ще осигури поне 3 сек за да не се ресетва ардуиното от премигвания на тока
-
да ама ще трябва да се дописва целия код на програмата трябва да се добавят променливи и за втори и трети бутон
променливите свързани със положението на сервото също ще трябва да се добавят и за второто и за третото
и всичко това да се добави във целия код надолу в програмата
Защо не ползвате тая програма която изкара VladoC гледах е тя е написана професионално
и е доста по добра
А и не си споменал как ще захранваш ардуиното с кво напрежение с 5в или с нещо между 6 и 12 волта
всяко ардуино има вграден стабилизатор и два входа за захранване
за микро са VCC за 5в и RAW за между 6 и 12 волта
мисълта ми е що не си подсигуриш захранване с кондензатор един голям или няколко по малки вързани успорено
консумацията е малка и един 4700мф ще осигури поне 3 сек за да не се ресетва ардуиното от премигвания на тока
Да, за второто серво, за втория бутон ще се допише. Това няма спор. Там нещата са ми ясни. Не ми беше ясно за тази библиотека, която пази данните.
Тази програма на VladoC е супер, но аз от два месеца се хванах с това и съм супер, мега хипер начинаещ. За това моя код изглежда като за първи клас. По тази причина не можах да се ориентирам добре в програмата на VladoC и не мога да я нагодя за мойта гара. При него се ползват и аналоговите входове, а аз там още не съм запознат. Ако успея да разуча и аналоговите входове на ардуиното ще мога да включвам на едно ардуно по 4 сервота, а не по 3 както е сега. Хубавото на ардуиното, е че след време ако напредна още винаги мога да променя кода.
В момента ардуиното го захранвам със зарядно за GSM. Обаче мисля да го сложа на тази платка, която май си има кондензатор:
https://www.aliexpress.com/item/Free-shipping-NANO-and-UNO-multi-purpose-expansion-board-for-arduino-nano-3-0/32503940168.html?spm=2114.search0104.3.104.27542b20AaSXg5&ws_ab_test=searchweb0_0,searchweb201602_1_10152_10151_10065_10344_10068_10342_10343_10340_10341_10084_10083_10618_10304_10307_10302_5711211_10313_10059_10534_100031_10103_10627_10626_10624_10623_10622_5722411_10621_10620_5711311,searchweb201603_25,ppcSwitch_5&algo_expid=738e151d-f923-4a58-a74b-f015d1fc2fe7-17&algo_pvid=738e151d-f923-4a58-a74b-f015d1fc2fe7&transAbTest=ae803_5&priceBeautifyAB=0 (https://www.aliexpress.com/item/Free-shipping-NANO-and-UNO-multi-purpose-expansion-board-for-arduino-nano-3-0/32503940168.html?spm=2114.search0104.3.104.27542b20AaSXg5&ws_ab_test=searchweb0_0,searchweb201602_1_10152_10151_10065_10344_10068_10342_10343_10340_10341_10084_10083_10618_10304_10307_10302_5711211_10313_10059_10534_100031_10103_10627_10626_10624_10623_10622_5722411_10621_10620_5711311,searchweb201603_25,ppcSwitch_5&algo_expid=738e151d-f923-4a58-a74b-f015d1fc2fe7-17&algo_pvid=738e151d-f923-4a58-a74b-f015d1fc2fe7&transAbTest=ae803_5&priceBeautifyAB=0)
-
При него се ползват и аналоговите входове, а аз там още не съм запознат. Ако успея да разуча и аналоговите входове на ардуиното ще мога да включвам на едно ардуно по 4 сервота, а не по 3 както е сега. Хубавото на ардуиното, е че след време ако напредна още винаги мога да променя кода.
Виж сега всички пинове на кое да е ардуино са дигитални входно изходни
И почти всички пинове имат и допълнителни функций
на тези които ти смяташ само за аналогови това е допълнителна функция
Примерно А0 е дигитален пин 14 можеш да се обръщаш към него с D14
А1 е D15 и Т.н. до А5 който е D19
Обаче ако искаш да четеш аналогови величини което е само стойности на напрежението от 0 до 5 волта
можеш да го правиш само на аналогови пинове
Това са така наречените хардуерни функций тоест те са вградени в самия чип
Друга допълнителна функция е PWM тя е има само на пиновете 3-5-6-9-10-11
само на тези пинове можеш да напишеш
analogWrite (pin, 127);
и ще получиш правоъгълни импулси с коефицент на запълване от 0 до 100% като напишеш една от стойностите от 0 до 255
примерно 127 са падат 50% ако напишеш пин различен от тея дето имат функцията PWM няма да получиш никви импулси
за това и сервото се атачва на някой от тея пинове
има обаче библиотеки софтуерно PWM а и софтуерно серво които карат всеки пин да стане PWM
друга важна допълнителна функция е RX и TX на пиновете 0 и 1 тs е за комуникация SPI
с тях различни платки могат да обменят информация за това и те рядко ще видиш да се ползват в туториалите
но ти ако искаш можеш да ги ползваш като се обърнеш към тях с D0 и D1
за всяко ардуино има такава картинка и по нея лесно можеш да се ориантираш за всички пинове
(http://pcomp2013.aisencc.com/wp-content/uploads/sites/2/2013/09/ARDUINO_V2.png)
-
Демек ако напиша:
const int butonpin = 19;
pinMode (butonpin,INPUT);
Ще мога да ползвам аналогов пин №5
Правилно ли те разбирам?
-
точно така
всеки пин е дигитален входно изходен
pinMode (butonpin,INPUT);
прави точно това казва на чипа че искаш пин 19 да го ползваш за цифров вход
и той вече може да приема сигнали с ТТЛ нива и ще ги отчита като 0 и 1
-
точно така
всеки пин е дигитален входно изходен
Ще го пробвам това тези дни.
Ако се получи ще имам един въпрос към теб - какво пиеш?
Теб и Митко имам много да ви черпя
-
да ама ще трябва да се дописва целия код на програмата трябва да се добавят променливи и за втори и трети бутон
променливите свързани със положението на сервото също ще трябва да се добавят и за второто и за третото
и всичко това да се добави във целия код надолу в програмата
Защо не ползвате тая програма която изкара VladoC гледах е тя е написана професионално
и е доста по добра
А и не си споменал как ще захранваш ардуиното с кво напрежение с 5в или с нещо между 6 и 12 волта
всяко ардуино има вграден стабилизатор и два входа за захранване
за микро са VCC за 5в и RAW за между 6 и 12 волта
мисълта ми е що не си подсигуриш захранване с кондензатор един голям или няколко по малки вързани успорено
консумацията е малка и един 4700мф ще осигури поне 3 сек за да не се ресетва ардуиното от премигвания на тока
Мисля си за един UPS хем да пази от токови удари, хем стабилизатор, хем ако спре тока да изключа нещата.
Тази библиотека ERRPROM нещо не ми харесва, че има живот определен брой записи.
-
е това е най доброто което може да се направи ама е малко скъпо най евтините дето съм виждал са май по 60лв
А и да кажа само може и да знаеш ама да го спомена
тея серво не са малко като консумация принципно му дават само едно да се захранва от ардуиното
ако са повече препоръчват да си ги захраниш с външни 5в и само масите да свържеш на едно
Тази библиотека ERRPROM нещо не ми харесва, че има живот определен брой записи.
това няма нищо общо с библиотеката те всички флаш са така
иначе да не е препоръчително да се ползва усърдно за това съм виждал как го правят когато се нуждае
някой проект от запазване на потребителски данни и всякви такива други величини нужни за програмата
да слагат външно флашче от сорта 24С02 -04 -08 и т.н. те са евтинки и като умре то е на цокълче 8пиново вадиш фърлиаш и тураш друго ;D
-
Мисля си за един UPS хем да пази от токови удари, хем стабилизатор, хем ако спре тока да изключа нещата.
Тази библиотека ERRPROM нещо не ми харесва, че има живот определен брой записи.
Колко ли врътвания ще издържи сервото, или стрелката.
-
Да питам някой дали е наясно.
До сега опитвах да въртя стрелката надясно от 0 градуса на +90. Това е когато стрелката е дясна.
При лява стрелка как трябва да е кода от 0 градуса към -90 или от 270 до 0?
-
Може и да я оставиш от 0 до 90. Може и да я направиш от 90 до 0. Както ти харесва. А най-важното - както си вързал телчетата / тягите за местене на езика.
При лява стрелка как трябва да е кода от 0 градуса към -90 или от 270 до 0?
И двете няма да работят - стандартната servo.h приема стойности от 0 до 180 като позиция.
-
Последното творение - маршрутизация:
https://www.dropbox.com/s/uqweih5osrb1rtj/video-f6cce122cbfc9dfa517f15b055c8c483-V.mp4?dl=0 (https://www.dropbox.com/s/uqweih5osrb1rtj/video-f6cce122cbfc9dfa517f15b055c8c483-V.mp4?dl=0)
Понеже качеството на клипа не е добро, пък и малката много държеше да и се види ръката - в края на клипа, ще дам малко разяснения:
При натискане на горния бутон за 1-ви коловоз - обръща първата стрелка в право положение
При натискане на втория бутон за 2-ри коловоз - обръща първата в отклонение и втората в отклонение
При натиснате на третия бутон за 3-ти коловоз - обръща първата в отклонение, а втората в право положение
Жълтия светодид показва - право положение, червеният отклонение. Не съм сигурен дали се виждат добре на клипа.
-
Загледах се в тази картинка:
(https://cdn.instructables.com/FD5/49FT/IKVFSNX6/FD549FTIKVFSNX6.LARGE.jpg)
и ми направи впечатление, че аналоговите пинове стигат не до А5, ами до А7. Вечерта разгледах и моето ардуино нано - там също са означени до А7. До сега на всякъде съм чел, че аналоговите са 6, както и примера дето е дал Светльо:
(http://pcomp2013.aisencc.com/wp-content/uploads/sites/2/2013/09/ARDUINO_V2.png)
Защо е това разминаване?
Както да питам - нали цифрови пинове 0 и 1 означени като TX1 и RX0 могат да си се ползват както другите?
-
Еми те точно за това са именувани ардуино нано мини про мини уно дуе леонардо и т.н.
Разминаването идва от използвания модел чип а освен това и един и същ модел чип примерно 328р
има няколко корпуса така наречените Package може да се види в пдф файла за чипа
http://ww1.microchip.com/downloads/en/DeviceDoc/Atmel-42735-8-bit-AVR-Microcontroller-ATmega328-328P_Datasheet.pdf
едните корпуси имат 28 пина другите 32 чисто физически за това
в средата за разработване преди да компилираш програмата се избира ардуиното за което се компилира
ако то е с няколко вида чипа излиза меню и за избор на конкретната конфигурация
Както да питам - нали цифрови пинове 0 и 1 означени като TX1 и RX0 могат да си се ползват както другите?
да могат да се ползват като цифрови входно изходни но ако ги ползваш за това няма да можеш да ползваш вече TX1 и RX0 функцията им
ПП
като разгледах файла видях че А6 и А7 които са обозначени по принцип като ADC6 и ADC7 нямат други функций и явно могат да се ползват само за аналогови входове
Тези които са цифрови входно изходни са маркирани като P + буквата на порта + номера примерно PB6
-
ровейки се из ибея ми попадна нещо интересно и евтинко
https://www.ebay.de/itm/PCA9685-16-Channel-12-Bit-PWM-Servo-Motor-Driver-IIC-Module-For-Arduino-Robot/172125479490?_trkparms=aid%3D444000%26algo%3DSOI.DEFAULT%26ao%3D1%26asc%3D49133%26meid%3D45eb603b64fe4df8a6efe7c45acfab0c%26pid%3D100752%26rk%3D6%26rkt%3D6%26mehot%3Dpp%26sd%3D171902620296%26itm%3D172125479490&_trksid=p2047675.c100752.m1982
а ето и от къде китайците са го репликирали и с това може да се управлява
https://cdn-learn.adafruit.com/downloads/pdf/16-channel-pwm-servo-driver.pdf
-
Това не върши ли същата работа?
https://www.aliexpress.com/item/Free-shipping-NANO-and-UNO-multi-purpose-expansion-board-for-arduino-nano-3-0/32503940168.html?spm=2114.search0104.3.97.63602b20zD6dy9&ws_ab_test=searchweb0_0,searchweb201602_4_10152_10151_10065_10344_10068_10342_10343_10340_10341_10696_10084_10083_10618_10304_10307_10302_5711215_10313_10059_10534_100031_10103_10624_10623_443_10622_10621_10620,searchweb201603_37,ppcSwitch_5&algo_expid=59d9d67b-0f92-40d4-9d16-3d2f3d06ee10-16&algo_pvid=59d9d67b-0f92-40d4-9d16-3d2f3d06ee10&transAbTest=ae803_4&priceBeautifyAB=0 (https://www.aliexpress.com/item/Free-shipping-NANO-and-UNO-multi-purpose-expansion-board-for-arduino-nano-3-0/32503940168.html?spm=2114.search0104.3.97.63602b20zD6dy9&ws_ab_test=searchweb0_0,searchweb201602_4_10152_10151_10065_10344_10068_10342_10343_10340_10341_10696_10084_10083_10618_10304_10307_10302_5711215_10313_10059_10534_100031_10103_10624_10623_443_10622_10621_10620,searchweb201603_37,ppcSwitch_5&algo_expid=59d9d67b-0f92-40d4-9d16-3d2f3d06ee10-16&algo_pvid=59d9d67b-0f92-40d4-9d16-3d2f3d06ee10&transAbTest=ae803_4&priceBeautifyAB=0)
-
Това не върши ли същата работа?
https://www.aliexpress.com/item/Free-shipping-NANO-and-UNO-multi-purpose-expansion-board-for-arduino-nano-3-0/32503940168.html?spm=2114.search0104.3.97.63602b20zD6dy9&ws_ab_test=searchweb0_0,searchweb201602_4_10152_10151_10065_10344_10068_10342_10343_10340_10341_10696_10084_10083_10618_10304_10307_10302_5711215_10313_10059_10534_100031_10103_10624_10623_443_10622_10621_10620,searchweb201603_37,ppcSwitch_5&algo_expid=59d9d67b-0f92-40d4-9d16-3d2f3d06ee10-16&algo_pvid=59d9d67b-0f92-40d4-9d16-3d2f3d06ee10&transAbTest=ae803_4&priceBeautifyAB=0 (https://www.aliexpress.com/item/Free-shipping-NANO-and-UNO-multi-purpose-expansion-board-for-arduino-nano-3-0/32503940168.html?spm=2114.search0104.3.97.63602b20zD6dy9&ws_ab_test=searchweb0_0,searchweb201602_4_10152_10151_10065_10344_10068_10342_10343_10340_10341_10696_10084_10083_10618_10304_10307_10302_5711215_10313_10059_10534_100031_10103_10624_10623_443_10622_10621_10620,searchweb201603_37,ppcSwitch_5&algo_expid=59d9d67b-0f92-40d4-9d16-3d2f3d06ee10-16&algo_pvid=59d9d67b-0f92-40d4-9d16-3d2f3d06ee10&transAbTest=ae803_4&priceBeautifyAB=0)
Не,това е съвсем друго - само пасивно разширение на изводите на Ардуиното.
Посочената платка от Светльо си заслужава да се проучи и използва.
-
Намерих един пример, дето доста подробно обясняват /но на мен ще ми трябва повечко време да го вдена/:
https://www.youtube.com/watch?v=y8X9X10Tn1k (https://www.youtube.com/watch?v=y8X9X10Tn1k)
а тук показват как може да се включат 62 такива платки и да се управляват до 992 серво машинки
https://www.youtube.com/watch?v=zLqIWDEWxWc (https://www.youtube.com/watch?v=zLqIWDEWxWc)
-
Хайде, че изоставаш Павка:
https://youtu.be/D-6GDlvAMCI
:lol: :pleasantry:
-
Представям си да отида на среща и целия да се окича в жици. Като мръдна малкия пръст местя стреките за 1-коловоз, показалеца за третия ....
Ще ги смая. :lol:
-
а тук показват как може да се включат 62 такива платки и да се управляват до 992 серво машинки
https://www.youtube.com/watch?v=zLqIWDEWxWc
Да тя платката се управлява по i2c портокол само с 3 пина и докато свършат адресите на i2c стандарта
ама прави ли ви впечатление че има много направено как да включиш сумати външни устройста амного малко
за това как да ги упрпавляваш и командваш всички разчитат на една клавиатура дето се продава за ардуиното
никаде не намирам някой да е направил примерно 20-ина бутона и да е написал код за тях който автоматично да генерира адреси
за i2c или като при компютърните клавиатури да генерира код за всеки бутон. Иначе казано за контрола има много малко материал . ;D
Представям си да отида на среща и целия да се окича в жици. Като мръдна малкия пръст местя стреките за 1-коловоз, показалеца за третия ....
Ще ги смая. :lol:
Не смея да си помисля къде ще закачиш контрола за движение на лока :lol:
-
? pavel75, Павка, нещо стана ли с това ардуино и с тези серво моторчета? На мен до толкова не ми хареса как работят тези sg90, че почти сигурно няма да ги използвам, поне не и за стрелки.
-
? pavel75, Павка, нещо стана ли с това ардуино и с тези серво моторчета? На мен до толкова не ми хареса как работят тези sg90, че почти сигурно няма да ги използвам, поне не и за стрелки.
Ами ще трябва да стане. Обаче покрай срещата в Русе имах задачи за там, после пък от нея малко имах разочарования и за месец си дадох почивка от хобито.
Мисля вече да почвам сериозно да се хващам да довършвам гарата и да продължа работата с ардуино.
За тези машинки си прав - и мен нещо не ме кефят. Особено като ги гледам с тия пластмасови колелца. Хубавото на ардуиното, че лесно могат да се правят промени.
Плановете са ми следните:
1. За сега гарата ще бъде с тях, тъй като ги имам налични. След време мисля да ги смяням със стъпкови моторчета. Но там още нямам нужните познания. Свалих едно от CD ROM, но нещо не мога да се ориентирам в кабелите. Обаче не мисля да се отказвам.
2. Смятам да почна да правя проби с една платчица НС-12 за ардуино и да се помъча част от стрелките да ги управлявам с радио сигнал. Да са без кабели от таблото. Но за това за сега имам само теоретични познания. Искам да го видя на практика как ще стане. Ако го подкарам мисля само част ще бъде с това, че и да го пробвам как ще се държи в реални условия на реална среща. Ако е сполучливо всички ще ги направя така.
3. Имам едно депо, мисля вратите да ги правя да се отварят също с такава машинка. Сега се мъча със зъбните колела. Едната врата ще е директно на машинката, а другата трябва да я измисля.
За сега това е от мен. Обещавам да докладвам за всичко сега като възстановя работата по хобито. Просто до сега бях малко "отпуска"
-
Митко,
гледам има стъпкови моторчета за ардуино на доста добра цена:
https://www.aliexpress.com/store/product/2017-New-5V-Stepper-Motor-28BYJ-48-With-Drive-Test-Module-Board-ULN2003-5-Line-4/1805090_32812678814.html?spm=2114.search0104.3.2.68d624175S1qdN&ws_ab_test=searchweb0_0,searchweb201602_4_10152_10151_10065_10344_10068_10342_10343_10340_10341_10696_10084_10083_10618_10304_10307_10820_10821_10302_10869_10868_10059_100031_10103_10624_10623_10622_10621_10620,searchweb201603_45,ppcSwitch_5&algo_expid=1c1ebf94-c5fc-46c9-87db-d46b6e158cac-0&algo_pvid=1c1ebf94-c5fc-46c9-87db-d46b6e158cac&priceBeautifyAB=0 (https://www.aliexpress.com/store/product/2017-New-5V-Stepper-Motor-28BYJ-48-With-Drive-Test-Module-Board-ULN2003-5-Line-4/1805090_32812678814.html?spm=2114.search0104.3.2.68d624175S1qdN&ws_ab_test=searchweb0_0,searchweb201602_4_10152_10151_10065_10344_10068_10342_10343_10340_10341_10696_10084_10083_10618_10304_10307_10820_10821_10302_10869_10868_10059_100031_10103_10624_10623_10622_10621_10620,searchweb201603_45,ppcSwitch_5&algo_expid=1c1ebf94-c5fc-46c9-87db-d46b6e158cac-0&algo_pvid=1c1ebf94-c5fc-46c9-87db-d46b6e158cac&priceBeautifyAB=0)
Как ти се виждат?
-
На картинка изглеждат добре. Искат захранване, по 4 жици на мотор към ардуиното.
На тая цена - ако поръчваш, запиши и за мен 4 - 5 бройки - да ги пробвам.
-
На картинка изглеждат добре. Искат захранване, по 4 жици на мотор към ардуиното.
На тая цена - ако поръчваш, запиши и за мен 4 - 5 бройки - да ги пробвам.
Поръчал съм ги!
-
Имам нужда от помощ. Хванах се да проблам да управлявам сервото с радио сигнал. Две арудиното - на едното има бутон, на другото е сервото. На двете платки има допълнителен модул НС-12 работещ на 433 MHz, който се връзват на пинове RX и TX.
Успях да го подкарам. Като натисна бутона първото ардуино праща сигнал второто и то завърта сервото. До тук добре. Обаче реших след като завърти сервото да прати обратно сигнал към първото в коя позиция е сервото и там да светне съответния светодиод - дали е в права или отклонение.
Обаче. Това с изпращането на обратния сигнал го сбърках и го сложих на неподходящо място в програмата. При стартиране на ардуиното, то започва да праща постоянно сигнал. Сега ако се опитам да кача нова програма ми казва, че е направило 10 опита да се свърже с ардуиното и не е могло.
Има ли начин за хард ресет на ардуиното?
-
Не те разбрах: опитваш се да качиш нова програма, т.е. да запишеш нов проект? И компютърът ти казва че не може?
-
Не те разбрах: опитваш се да качиш нова програма, т.е. да запишеш нов проект? И компютърът ти казва че не може?
Общо взето - ДА. Трябваше да кача нова програма, за да оправя грешката. Оправих се. Разкачих модула и ардуиното започна да "чува". Обаче май съм прецакал този модул. Докато дойде нов за сега спирам с тези опити.
-
Когато защкачаш различни платки на USB порта, най-често те се виждат на различни COM портове. Т.е. като заредиш една програма на едното ардуино, след това като заредиш друга програма на другото ардуино, трябва за второто отново да си избереш ком порта. И така всеки път като сменяш платките с ардуиното.
Модул можеш да прецакаш с отверка, с чук, с поялник и т.н. Може и с грешно свързване, но обикновено като свържеш един път едни жици повече не се пипат и не може ад гръмне от програми.
-
Проблемът е, че още не мога да разбера какви ги натворих.
Като разкача модула и ардуиното се държи нормално. Закачам му модулчето и ардуиното нито работи нито приема нова програма, само му мига постоянно вградения светодиод.
Трябва да го помисля малко. Сега отивам в клуба да поработя малко физическа работа, че нещо зациклих.
-
Ако споделиш скрипта и схемата сигурно ще може повече да ти съдействаме евентуално :good:
-
Ако споделиш скрипта и схемата сигурно ще може повече да ти съдействаме евентуално :good:
За схемата използвам:
2 бр Ардуино Нано
1 бутон
1 серво моторче
2 бр допълнителен модул за Ардуино - НС 12
Свързани са по следния начин:
1. На първото ардуино на пинове 0 и 1 е включен модула НС 12, а на пин 4 бутона
2. На второто ардуино на пирове 0 и 1 е включен другият модул НС 12, на пин 4 е серво моторчето.
В началото направих съвсем проста програма, колкото да тествам комуникацията. /програмата е следващия пост/. При натискане на бутона от първото Ардуино, то изпраща код. Второто, когато приеме този код завърта сервото. Ето клипче как работеше:
https://www.dropbox.com/s/vqtozdnidxngv1x/VIDEO0015.mp4?dl=0 (https://www.dropbox.com/s/vqtozdnidxngv1x/VIDEO0015.mp4?dl=0)
Имаше малко ядове, че понякога като натиснех копчето, второто ардуино явно приемаше две команди и завърташе два пъти сервото. Това знаех как да го оправя - с функцията millis щях да следя дали е минало някакво време от последното натискане на бутона - примерно 500 мсек и тогава да може повторно да прати код. Понеже не очаквах тук да имам затруднения с това не се хванах сега, а реших програмата малко да я развия и на второто Ардуино като завърти сервото да прати сигнал в коя посока го е врътнало. Ето тук допуснах грешка, че този код го сложих извън IF-a. Качих програмата и Ардуиното започна да излъчва постоянно сигнал. Видях си грешката, оправих кода и се опитах да го кача пак. При компилиране ми казваше, че всичко е ОК, но при качване имаше драма - тръгва да качва и стои много време. След това долу вадеше съобщение, че е направило 10 опита да се свърже с ардуиното и не е могло. Някъде четох, че тази функция е малко тегава, защото докато излъчва не може да прави нищо друго. Нещо като функцията delay. Посъветваха ме да разкача модула НС12 и да пробвам. Направих го и се получи. Върнах първоначалният вариант на програмата, но вече не работеше. Когато приема или изпраща присветват вградени диоди за RX и TX. Това вече не се случваше.
Открих и още нещо - ако НС12 е закачено за Ардуиното дава същата грешка, че не може да качи програмата. Когато го махна този модул програмата се качва без никакви проблеми.
Сега ще кача и кода.
-
КОД НА ПЪРВОТО АРДУИНО:
#include <Servo.h>
#include <SoftwareSerial.h>
SoftwareSerial Ardo1 (0, 1); //Пиновете за НС12
const int butonpin = 4;
void setup() {
Ardo1.begin(9600);
pinMode (butonpin,INPUT);
pinMode (led_pravo, OUTPUT);
pinMode (led_otklonenie, OUTPUT);
}
void loop() {
int buton_push = digitalRead(butonpin);
if(buton_push ==HIGH){
Ardo1.println(15);
}
delay(200);
}
}
КОД НА ВТОРОТО АРДУИНО:
#include <Servo.h>
#include <SoftwareSerial.h>
SoftwareSerial Ardo2 (0, 1); //Пиновете за НС12
const int pravo = 0;
const int diasno = 90;
const int servopin = 4;
// константа за периода на забавяне на върнете на сервото
const int period = 100;
//декрарираме сервото
Servo Strelka1;
//променливи за запомняне позицията на сервото
int pos = pravo; // текуща позиция
int pos_old = diasno; // предишна позиция
void setup() {
Ardo2.begin(9600);
Strelka1.attach(servopin); // закача сервото на пин 5
Strelka1.write(pos); //сервото се обръща в права позиция
delay (1000);
Strelka1.detach();
}
void loop() {
if(Ardo2.available ()>1){
int input = Ardo2.parseInt();
if (input == 15) {
pos_old = pos; //запазва текущата позиция
if(pos==pravo)
{pos=diasno;}
else{pos=pravo;}
Ardo2.flush();
if(pos_old<pos){
Strelka1.attach(servopin);
for(int i = pos_old + 1; i <=pos; i++){
Strelka1.write(i); // записва следващата позиция на сервото
delay(period); // забавяне
//Ardo2.println(16);
}
Strelka1.detach();
}
if(pos_old>pos){
Strelka1.attach(servopin);
for(int i = pos_old - 1; i >=pos; i--){
Strelka1.write(i); // записва следващата позиция на сервото
delay(period); // забавяне
Ardo2.println(17);
}
Strelka1.detach();
}
}
}
}
-
"...Открих и още нещо - ако НС12 е закачено за Ардуиното дава същата грешка, че не може да качи програмата. Когато го махна този модул програмата се качва без никакви проблеми..."
Павка, мисля, че точно това ти е проблема. Когато програмираш Ардуино, задължително изключващ комуникационнивя модул!
-
"...Открих и още нещо - ако НС12 е закачено за Ардуиното дава същата грешка, че не може да качи програмата. Когато го махна този модул програмата се качва без никакви проблеми..."
Павка, мисля, че точно това ти е проблема. Когато програмираш Ардуино, задължително изключващ комуникационнивя модул!
Да, така ме посъветваха. Вече така го правя, но явно съм го съсипал нещо, защото вече не работи.
-
Павка, първо:
При качване на програмите през USB порта не трябва да има нищо закачено на пинове 0 и 1, или ако има нещо то да не им пречи. Независимо дали е HC12 или каквото и да е.
Другото е малко заигравка, на мен не ми харесва и ако можеш го напиши по друг начин, защото не ми е ясно:
- Какво прави Ardo2.println(16)?
- кой ти каза че можеш да използваш функциите от Serial в SoftwareSerial? Гледам Ardo2.parseInt(). Не казвам че не става, ама не съм сигурен.
Освен това при четенето на бутончето според мен задължително използвай макар и най-простата проверка, напр.
четеш бутона, ако е HIGH -> правиш delay(50), четеш пак бутона. Ако пак е HIGH приемаш че е натиснат. Не е нужно да използваш debounce, но поне това сложи, върши работа.
А и на бутоните е добре единият край да е на минус, на маса, на земя или както се нарича. За да не гърми плюса при късо. Тогава при натиснат бутон ще четеш LOW. При инициализацията го правиш pinMode(5, INPUT_PULLUP);
Другото е добре да го оправиш във второто ардуино - като му дадеш една команда да не се бърка докато не я изпълни и дойде втора.
-
Павка, първо:
При качване на програмите през USB порта не трябва да има нищо закачено на пинове 0 и 1, или ако има нещо то да не им пречи. Независимо дали е HC12 или каквото и да е.
Другото е малко заигравка, на мен не ми харесва и ако можеш го напиши по друг начин, защото не ми е ясно:
- Какво прави Ardo2.println(16)?
- кой ти каза че можеш да използваш функциите от Serial в SoftwareSerial? Гледам Ardo2.parseInt(). Не казвам че не става, ама не съм сигурен.
Освен това при четенето на бутончето според мен задължително използвай макар и най-простата проверка, напр.
четеш бутона, ако е HIGH -> правиш delay(50), четеш пак бутона. Ако пак е HIGH приемаш че е натиснат. Не е нужно да използваш debounce, но поне това сложи, върши работа.
А и на бутоните е добре единият край да е на минус, на маса, на земя или както се нарича. За да не гърми плюса при късо. Тогава при натиснат бутон ще четеш LOW. При инициализацията го правиш pinMode(5, INPUT_PULLUP);
Другото е добре да го оправиш във второто ардуино - като му дадеш една команда да не се бърка докато не я изпълни и дойде втора.
При качване на програмите през USB порта не трябва да има нищо закачено на пинове 0 и 1, или ако има нещо то да не им пречи. Независимо дали е HC12 или каквото и да е. - Това го научих по трудния начин
Другото е малко заигравка, на мен не ми харесва и ако можеш го напиши по друг начин, защото не ми е ясно:
- Какво прави Ardo2.println(16)? - Това беше да праща сигнал към първото ардуино. Виж, че е в коментар сега. Забравил съм да го изтрия
- кой ти каза че можеш да използваш функциите от Serial в SoftwareSerial? Гледам Ardo2.parseInt(). Не казвам че не става, ама не съм сигурен. - Гледах примерите от този сайт - https://www.instructables.com/id/Long-Range-18km-Arduino-to-Arduino-Wireless-Commun/ (https://www.instructables.com/id/Long-Range-18km-Arduino-to-Arduino-Wireless-Commun/)
Освен това при четенето на бутончето според мен задължително използвай макар и най-простата проверка, напр.
четеш бутона, ако е HIGH -> правиш delay(50), четеш пак бутона. Ако пак е HIGH приемаш че е натиснат. Не е нужно да използваш debounce, но поне това сложи, върши работа. - Да, това го знаех като проблем, но щях да го оправя по-натам. Сега исках да тествам нещата, който не съм правил никога.
А и на бутоните е добре единият край да е на минус, на маса, на земя или както се нарича. .... Бутона е вързан по следния начин - единият извод е на захранването, другият на пина на ардуиното, като самият пин през съпротивление 1 килоом е вързан на маса.
Другото е добре да го оправиш във второто ардуино - като му дадеш една команда да не се бърка докато не я изпълни и дойде втора.
Тъпото е, че не разбрах какво му направих на тоя модул. Ако знаех как и с какво съм го изгорил или каквото му се е случило щях следващият път да го избегна. Сега като не съм наясно може пак да свърша същата тъпотия.
-
Съйтът, който показа, според мен хич не е за гледане.
Не съм сигурен че си гръмнал модула. Най-вероятно си е жив и здрав. Не знам как го тестваш. Сложи си по едно бутонче и по един светодиод на всяка платка и си провери комуникацията с две кратки програмки, може и готови.
Според мен трябва да си преправиш всичко:
D0 и D1 да не ги използваш. Те сe използват от ардуиното за разни други неща.
println(16) пишеш че си го коментирал, ама същото стои по-долу. println(17) БИ ТРЯБВАЛО да изпрати ASCII поредицата "17" и след нея \r\n. По същия начин изпращаш "15" пък после се мъчиш да го превърнеш с функция от друг обект в integer и т.н. Съветвам те да гледаш официалната arduino страница - там ги има описани функциите, както и на какви чипове и платки работят (ако има разлика). Всичко друго може и някъде с нещо да стане, може и не. На мен ми хареса https://www.allaboutcircuits.com/projects/understanding-and-implementing-the-hc-12-wireless-transceiver-module/ (https://www.allaboutcircuits.com/projects/understanding-and-implementing-the-hc-12-wireless-transceiver-module/) за това НС12.
-
Аз обаче не схващам това защо така сложно се прави
беше коментирано че едно ардуино може да управлява няколко серво
а ти ползваш две за едно и радио модули вместо прости жици .
Това има ли конкретна цели или ?!?
Иначе винаги ще има проблеми при качване на програмата когато към пиновете 0 и 1 които са RX и TX е закачен модул който също има процесор какъвто е твоя в случая .
Ако е закачен такъв без собствен процесор няма проблеми може да си стои .
Съйтът, който показа, според мен хич не е за гледане.
Защо бе Митко кво му е на сайт аз съм доста доволен от него там всички проекти са работещи
няма да коментираме до колко са изпълнени най оптимално или функционално това е въпрос на умения и знания
А освен това можеш да правиш запитвания и да получиш отговори ако нещо не се получава на твоя бедбоард .
А и нещо важно за беглия поглед който хвърлих на проекта вижда се че автора ползва пинове 2 и 3 за RX и TX на модула
а не 0 и 1 :)
-
Аз обаче не схващам това защо така сложно се прави
беше коментирано че едно ардуино може да управлява няколко серво
а ти ползваш две за едно и радио модули вместо прости жици .
Това има ли конкретна цели или ?!?
............
.........
Аз не съм си и помислял да слагам на всяко серво ардуино, ще си бъдат по няколко.
Гарата ще е с 10 модула. На тези със стрелки ще има по едно ардуино. От всяко ардуино трябва да има жици към таблото. Исках да пробвам с радио модула да си спестя жиците към таблото. Тук е едно серво докато разуча нещата.
-
Защо бе Митко кво му е на сайт аз съм доста доволен от него там всички проекти са работещи
няма да коментираме до колко са изпълнени най оптимално или функционално това е въпрос на умения и знания
А освен това можеш да правиш запитвания и да получиш отговори ако нещо не се получава на твоя бедбоард .
А и нещо важно за беглия поглед който хвърлих на проекта вижда се че автора ползва пинове 2 и 3 за RX и TX на модула
а не 0 и 1 :)
Разгледах му сорсовете, затова не ми харесва. А дали едно нещо работи или не - аз предпочитем от начало да не тръгвам по грешен път, пък после да си троша главата как да се оправя.
То и в багажника на мерцедеса влизат торби с цимент, амо това не значи че ако ще возя цимент ще си купя мерцедес ... и след това да им пиша каква калъфка да си постеля.
Мисля че в официалня реф. на ардуиното достатъчно точно е казано какво и как се прави със софт серийните неща. Има си и примери, и всичко.
А пък пинове 0 и 1 не могат да се ползват, ако използавш Serial. Те се управляват директно от библиотеката.
-
Значи може да се направи с жици няма да са от всяко ардуино към таблото
а ще са само две жици и всички ардуинута ще се закачат успоредно на тях така нареченото I2C
и управляващото ще е мастър всички останали са слейв има ги такива примери много
http://www.techbitar.com/how-to-network-many-arduinos-with-sensors-using-i2c.html
http://fab.academany.org/2018/labs/fablabopendot/students/laura-cipriani/assignment/week014.html
Разбира се и с радиомодулите или блутут те са същите по размер ще стане
както си го почнал .
Аз търся грешки в програмата така
за индикация ползвам сериал монитор на Ардуино средата
и на възлови точки от програмата след като си стартирал
Serial.begin(9600);
слагам
Serial.println("..redy1");
Serial.println("..redy2");
Serial.println("..redy3");
И на сериал монитора ще ти излезе ..redy1..redy2..redy3
и така разбирам къде забива програмата и ако не видя нещо грешно слагам на това място след всеки ред от програмата по едно
Serial.println("..redyххххх");
така се хваща точния ред .
Защото и аз както Митко каза по горе мисля че няма как да прецакаш модула софтоерно
може да се прецака при грешно захранване примерно.
Мисля че просто програмата забива някъде може би на някой IF
това което пращаш не отговаря на сравнението или нещо подобно
А и смени пиновете вместо
SoftwareSerial Ardo1 (0, 1); //Пиновете за НС12
ги смени с 2 и 3
SoftwareSerial Ardo1 (2, 3); //Пиновете за НС12
и закачи НС12 на 2 и 3 пин
-
Ще го пробвам тези дни и ще докладвам.
Поздрави
-
... има стъпкови моторчета за ардуино на доста добра цена:
https://www.aliexpress.com/store/product/2017-New-5V-Stepper-Motor-28BYJ-48-With-Drive-Test-Module-Board-ULN2003-5-Line-4/1805090_32812678814.html?spm=2114.search0104.3.2.68d624175S1qdN&ws_ab_test=searchweb0_0,searchweb201602_4_10152_10151_10065_10344_10068_10342_10343_10340_10341_10696_10084_10083_10618_10304_10307_10820_10821_10302_10869_10868_10059_100031_10103_10624_10623_10622_10621_10620,searchweb201603_45,ppcSwitch_5&algo_expid=1c1ebf94-c5fc-46c9-87db-d46b6e158cac-0&algo_pvid=1c1ebf94-c5fc-46c9-87db-d46b6e158cac&priceBeautifyAB=0 (https://www.aliexpress.com/store/product/2017-New-5V-Stepper-Motor-28BYJ-48-With-Drive-Test-Module-Board-ULN2003-5-Line-4/1805090_32812678814.html?spm=2114.search0104.3.2.68d624175S1qdN&ws_ab_test=searchweb0_0,searchweb201602_4_10152_10151_10065_10344_10068_10342_10343_10340_10341_10696_10084_10083_10618_10304_10307_10820_10821_10302_10869_10868_10059_100031_10103_10624_10623_10622_10621_10620,searchweb201603_45,ppcSwitch_5&algo_expid=1c1ebf94-c5fc-46c9-87db-d46b6e158cac-0&algo_pvid=1c1ebf94-c5fc-46c9-87db-d46b6e158cac&priceBeautifyAB=0)
...
Някои първи впечетления за стъпковите моторчета:
+ Изглеждат доста добре, за разлика от евтините серво моторчета. Желязна ламарина, стабилна конструкция. Моторчето е с вграден редуктор 1/64, може да се позиционира на 2048 стъпки в един оборот. В цената си има платка с драйвера, закачаш и всичко тръгва. Стандартната библиотека върши работа и се използва лесно.
Недостатъци:
- 4 пина от ардуиното за моторче. Могат да се намалят на 2, ще го тествам тези дни.
- стандартната библиотека държи винаги под напрежение едната намотка. 250 мА. От това моторчето доста бързо загрява. Също и при движение. Не е горещо, но си топли. Трябва му още един пин с по един транзистор да спира и пуска захранването, може и на всичките моторчета на ардуиното.
- за стрелки трябва обратна връзка, ключета при достигане на двете крайни положения. Без тях не става. Това е още един пин на моторче.
- един оборот се прави най-малко за около 3.5 секунди. По бързо не може. За по-бавно няма проблеми. За стрелки - става - около секунда за превключване е достатъчно бързо.
- уж е с дебела и здрава ос, но днес отворих едно за да се опитам да го подкарам без редуктор. Вътре е с едни фини пластмасови колелца, включително и последните. Не може да се очаква кой-знае каква сила. А пък първите колелца се с модул към 0.25, така че без редуктор няма да може да задвижи кой знае какво.
За сега - толкова. Имам за правене един бретел - 4 стрелки и една камара релсови парчета и сърца за захранване. Ще се хване точно на едно ардуино.
-
Бретел собствено производство. Управлението е с Ардуино Нано.
https://www.youtube.com/watch?v=jrsTqqBPc7U (https://www.youtube.com/watch?v=jrsTqqBPc7U)
-
Много добро!
-
Поздравления за отличната работа при изработването на стрелки, тяхното управление, както и за двете композиции :hi:
-
Един въпрос към запознитете. По тази схема на ардуино Мега, как са отбелязани цифровите пинове, че нещо не мога да се ориентирам?
http://icircuit.net/wp-content/uploads/2014/09/megapdf.jpg (http://icircuit.net/wp-content/uploads/2014/09/megapdf.jpg)
Искам да използвам и светофорите, та ще ми трябват повече пинове.
На ардуино Дуе са дадени кои са цифровете пинове:
http://icircuit.net/wp-content/uploads/2014/09/Arduino-Due-Pin-mapping.png (http://icircuit.net/wp-content/uploads/2014/09/Arduino-Due-Pin-mapping.png)
-
На всички ардуинота всички пинове са цифрови вход и изход демек могат да предават сигнали и да приемат сигнали
И всички пинове имат и допълнителни функци и те са отбелязани на рисунката
В кода просто трябва да видиш кои пинове се извикват и да закачиш на тях
Обаче пиновете не съвпадат на различните ардуинота в смисъл че са на различни места
А и тая картинка не е най подходящата за мега потърси друга на която са обозначени с D
има ги в нета на тая снимка са дадени технически според производителя на портове PA означава порт а и последван от номера на пина всеки порт има по 8
-
Един въпрос към запознитете. По тази схема на ардуино Мега, как са отбелязани цифровите пинове, че нещо не мога да се ориентирам?
На твоята картинка и аз не мога да се ориентирам :)
Ето ти една друга:
(http://www.bajdi.com/wp-content/uploads/2012/01/arduino-mega-2560.jpg)
"Цифровите" са с номерцата от 0 до 54.
Прочети особеностите на тези портове тук (https://www.arduino.cc/en/Tutorial/DigitalPins).
Освен това доста от тях се използват и за други неща, т.е. ако използваш някоя стандартна библиотека, тя може да използва някои от тези пинове. Ето тук (https://store.arduino.cc/arduino-mega-2560-rev3) в Documentation са изброени тези пинове.
Като цифрови можеш да използваш и всичките 16 аналогови пина, означени с А0 до А15, и ти ще ги пишеш по същия начин. Ето ти пример (https://www.arduino.cc/en/Tutorial/AnalogInputPins).