Статиите принадлежат на Категория Ардуино схеми



Въртяща се уеб камера с Arduino

Източник: cxem.net

Превел от руски: Т. Б.

arduino47-1c

В тази статия се разказва за това, как да поставите уеб камера върху сервозадвижване, поставена в рамка от конструктор и нейното управление с помощта на Arduino.

Неотдавна аз си зададох въпроса, какво друго можем да направим с Arduino, освен да светодиоди да премигат.
Тази идея ми дойде по време на утрешен разговор с колеги по Skype, и аз реших да направя, така че те да могат с помощта на уеб камерата да наблюдават какво става в нашия офис. В една дъждовна неделя, споделих идеята си с моя приятел и ние направихме Arducam.

Преди този проект бях прочел няколко подобни статии, в някои от коит се използваше джойстик. Имах джойстик от стара PS3 конзола, затова реших да го използвам.

arduino47-2c

Рамка от конструктор

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

arduino47-3c

 

Свързване към вала на сервозадвижването

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

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

arduino47-4c

 

arduino47-3c

 

Монтаж на уеб камерата

Уеб камера

Използвах уеб камерана фирмата Logitech.
Може би, ще бъде от полза използването на противотежест с нея, за да я направите по-лека, но това не е моя уеб камера, на на офиса, и затова не съм го направил.

arduino47-6c

Разпределение на тежестта

Добавих 2 дебели уплътнения, за да избегна напрягането на вала на уеб камерата. Те смесват тежестта на камерата и рамката с вала на сервозадвижването.

arduino47-7c

 

Монтаж на уеб камерата

Закрепващият елемент на уеб камерата се състои от кръг с отвори, съвпадащи с остта на вала. това позволява осигуряването на тяга между вала и кръга.
Пространството създадено от уплътнението, предотвратява натискането на вала.

arduino47-8c

 

Проблеми:

– Камерата не е закрепена в рамката, и тя ще пада, ако тя е максимално наклонена.
– Отворите в констуктора над сервозадвижването са големи, и позволяват сервозадвижването да прави значителни хоризонтални движения на товара.
– Въртящият момент причинява прекомерно завъртание на уеб камерата, която от своя страна нарушава сервозадвижването. Искам да опитам да го изправим чрез завъртане на камерата с 1 градус назад след периода на непрекъснато двиежение, но аз предпочитам механичното решение. Може би може да постигнете това чрез добавянето на редуктор и поставянето на уеб камерата на отделен вал с ремъчна предавка?
– … Или пък да използвате по-мощно сервозадвижване.

Електроника

Свързване на сервозадвижването и светодиодите
Сервозадвижването притежава 3 проводника:
– GND
– +5V
– Данни
Аз използвах 9 пинов конектор за управление на сервозадвижването. Светодиода е свързван към +5V и GND през резистор към линията +5V и ще се засветва при подаване на захранващото напрежение.

arduino47-9c

Свързване на джойстика
Намираше ми се стар джойстик от PS3 конзола.
За да разбера как функционира джойстика и неговата електроника, на мен ми помогнаха статиите от Finnio и jhoffnun.

arduino47-10c

 

arduino47-11c

 

Управление на сервозадвижването

Arduino
Програмата за Arduino, както и файла на проекта може да свалите отдолу или да вземете от github. Програмата позволява да управлявате уеб камера с помоща на USB и джойстик. Може да използвате модем-контролер/ емулаторно терминално приложение, като например Minicom или Putty за свързване с USB порт.

Инсталиране спрямо центъра:
– При включването програмата ще установа сервозадвижването на 90 градуса.
– И при натискането на „m“

Завъртане наляво и надясно
– Когато джойстика се премести в хоризонталната равнина.
– наляво при натискането на ‘F’
– Надясно при натискането на ‘J’

Node.js
За да облекчим управлението на arducam, ние направихме уеб сървър в node.js. Повече информация може да намерите на сайта на проект github.

Възможни подобрения:
– Осигуряване завъртане на камерата чрез бутоните със стрелки;
– Реализиране на завъртане на 1 градус назад за облекчаване натоварването на сервозадвижването, възникващо при въртящия момент от тежестта на уеб камерата.

Оригинална статия.

Прикрепени файлове: Arducam.rar (989 kB)

Електронен водомер с Arduino

Източник: cxem.net

Превел от руски: Т. Б.

Този проект е създаден в лабораторията Teague за измерване потреблението на вода и температура в реално време, записване на данните и предаването им посредством интернет.

Сърцето на устройството се явява датчик за потока вода. Цените на този тип датчици варират в широк диапазон. Ние се спряхме на един сравнително евтин датчик за поток вода(в Русия около 2000 RUB,~56 BGN) INS-FM14N на фирмата Koolance.

arduino1-1_water

Датчика пристига в комплект с интерфейсна платка, но тя необходима, тъй като датчика се свързва лесно директно към микроконтролер. По този начин се редуцира броя на свързващите проводници и се намалят габаритите на крайното устройство. Принципа на работа на разходометъра на течност е прост – когато през датчика протича вода, тя привежда в движение колело, на чиито перки е закрепен малък магнит. Датчикът на Хол прочита оборотите на колелото и извежда импулси. Импулсите от своя страна се прочитат от външно устройство и по този начин се измерва разхода на вода.
В допълнение към разходометъра, ние използвахме термодтчик(терморезистор) за измерване температурата на водата.

arduino1-2_water_circ

 

И понеже желаехме да предадем всички данни за разхода на водата чрез интернет, то за тази цел ние използвахме контролера YellowJacket Arduino с вграден Wi-Fi модул. Когато контролера открие потока от вода, той периодично (от 1 до 15 сек. – зависи от настройките на безжичната връзка) изпраща данните към сървъра. Използва се GET заявка, с указани ID и данни, скриптът разположен на сървъра съхранява информацията, а след това се генерира HTML-страница за визуализация на данните.

За няколко часа ние сглобихме 4 работещи устройства, всяко едно които съдържа: Wi-Fi Arduiono, датчик за температура, разходометър и два фитинга за неговото свързване с крана за вода. Всички четири устройства поставихме на различни места в нашата лаборатория.

arduino1-3_water

За визуализирането на данните ние използвахме графическият инструмент на HTML5. С помощта на модула за структури и динамично визуализиране на слоеве, ние направихме данните да могат да се наблюдават от всякакъв тип устройство: смартфон, iPad и дори стационарен компютър и проектор.

arduino1-4_water

 

Може да свалете архива с проекта за Arduino и код за PHP и HTML5 отдолу.

Видео на работещото устройство:

TEAGUE Give Water from TEAGUE on Vimeo.

Оригинална статия: labs.teague.com

Прикрепени файлове: >>> Архив <<<

CxemCAR 2 – Управление на радио модел (автомобил) през Android с видео излъчване в реално време (Bluetooth & Wi-Fi)

Източник:  english.cxem.net

Автор: Koltykov A.V.

Превод: Т. Б.

В интернет съществуват много статии относно използването на радио управляемите модели на автомобили с IP или Web-базирана камера. Но повечето от тях използват лаптоп или интернет рутер с Open-WRT или DD-WRT фърмуейр. Показването на видео сигнала и управлението на RC автомобила в такива проекти обикновенно се реализира с PC или Лаптоп. В тази статия се описва управлението верижна платформа от всяко едно Android-устройство(таблет, смартфон, и.т.н), както и показването на видео сигнал в реално време и управлението над завъртането и/или наклона на IP-Камерата. Всички необходими части са останали напрактика непроменени в първият проект на CxemCAR, направени са промени, за да работят Android приложенията с Wi-Fi IP камерата.

Този проект е изграден на базата на Arduino. За да управляваме автомобила използваме Bluetooth канал. Като IP камера използвах популярният модел Foscam FI8918 (80-100$).

Както се вижда и на фигурата отгоре, взаимодействието между смартфона и следената платформа се реализира директно върху Bluetooth-канал, а взаимодействието с камерата се реализира върху Wi-Fi канал, но през рутера. А това е голям недостатък – тъй като без рутера, всички действия с камерата няма да функционират, например на улицата или някъде другаде в града. Опитах се да направя директно управление посредтвом Wi-Fi, включвайки Host режима на Wi-Fi адаптера на Android устройството. Но нищо не се получи. Ще се опитам на направя директно взаимодействие без рутера. Има някакво предположение, че това ще изисква камера с поддържана функция Wi-Fi Direct.

IP-Camera

IP-камерата Foscam FI8918 осигурява видео поток във формат MJPEG (Motion JPEG), при който всеки кадър се компресира посредством популярния JPEG алгоритъм за компресия на изображения. При разделителна способност на видео потока 320×240, FPS е 25-30. Ако разделителната способност на видеото е 640×480, честотата FPS пада около 2 пъти. За Android през интернет съществува MJPEG клас за обработка и визуализация на информацията при активност.

Моделът FI8918 притежава функция на завъртане и накланяне на камерата посредством уеб-интерфейса. В този проект, тази възможност също е реализирана. Функциите на Foscam камерите са добре документирани (погледнете файла IPCAM CGI SDK V1.7). Покажете видео потока на адрес „http://192.168.1.10:8081/videostream.cgi?user=cxemcar&pwd=cxemcar&resolution=8“, където user- е потребителското име, pwd- е паролата, resolution- видео разделителната способност (8 – 320x240px, 16 – 640x480px)

За да управляваме движенията на камерата (функцията завъртане/ накланяне) се използва скрипта
decoder_control.cgi, а параметъра „command“ задава следните команди:
0 – движение на камерата нагоре
1 – спри движението нагоре
2 – движение надолу
3 – спри движение надолу
4 – движение наляво
5 – спри движението наляво
6 – движение надясно
7 – спри движението надясно
25 – установи във средата
26 – вертикален „патрул“
27 – Спри вертикален „патрул“
28 – хоризонтален „патрул“
29 – Спри хоризонтален „патрул“

В Android приложението използвах само взаимодействие с два скрипта , но както бе отбелязано отгоре, посредством CGI скриптовете могат да се правят много неща:
get_camera_params.cgi – получава текущите настройки на камерата. Скрипта връща разделителната способност, осветеноста, контраста, режима на работа 50/60 Hz, завъртане на изображението.
camera_control.cgi – настройки на камерата.
reboot.cgi – рестартиране на камерата.
restore_factory.cgi – връщане на първоначалните настройки на камерата.
get_params.cgi – информазия относно камерата и много нейни параметри.
set_datetime.cgi – за настройка на часа и датата.
set_network.cgi – мрежови настройки.
set_wifi.cgi – Wi-Fi мрежа.
set_ddns.cgi – настройка над параметрите за Dynamic DNS.
set_ftp.cgi – настройка на FTP връзката.
set_mail.cgi – настройка за ПОЩА.
И.т.н.

Камерата се конфигурира за работа с статичен IP адрес. За да може да бъде достъпна през Android приложение. Въпреки, че Foscam поддържа DDNS услуги, вие може да използвате и динамичен IP адрес.

Шаси

Тъй като IP-камерата представлява масивна конструкция, то и платформата трябва да бъде с подходящ размер. Като шаси използвах широко разпространената ходова част „Rover 5“.

платформата идва с горен капак

Капакът е изрязан от пластмасата и монтиран върху малък рафт, за да се поставят батериите захранващи камерата и моторите, батерията захранваща Arduino и 5V преобразувател на напрежение захранващ камерата.

с прикрепен капак:

с промяна за ключа за включване/ зареждане:

Батериите и платката на преобразувателя са поставени в шасито. Капака е изрязан с отвори за проводниците, за да се управлява платката, камерата и драйвера за мотора. За да зареждате батериите поставихме 2 конектора.

IP-camera, Arduino, Bluetooth-модул и драйвера за мотора са монтирани върху капака на шасито.

За електронните компоненти са изрязани пластмасови амортисьори и малък капак закрепен с болтове, който може да бъде премахнат ако е необходимо.

Хардуер

Необходимите компоненти са почти идентични с тези от проекта Arduino RC car. но е добавена камера, и се изисква 5V захранване. Затова беше добавен понижаващ регулатор на напрежение чрез чипа LM2596.

Използвани от: Bluetooth модул HC-06, Arduino Nano v3 и драйвер за моторите L298N. Ако захранвате Arduino платката от 4V и нагоре, между изводите RX (Модула HC-06) с TX(платката Arduino) е необходимо да поставите делител на напрежение, тъй като логическото ниво на HC-06 е 3.3V. Още по-добре е, ако използвате специализиран чип, като например MAX232.

Скиците за Arduino са останали същите, и са публикувани на страницата на GitHub’e (хипервръзката отдолу).

Софтуер

Софтуера е написан в open-source средата IDE Eclipse. Структурата на проекта:

Проектът съдържа 4 дейности: основна, относно програмата, работеща с Flash и основната дейност за управлението на шасито и показването на видео потока. За да се работи с MJPEG видео потока, съществуват следните 2 клака: MjpegInputStream and MjpegView.

Програмата съдържа меню със следните настройки:

Дейности по управлението, както следва:

От ляво са разположени ботоните за управление на платформата, в средата е визуализиран видео потока от камерата, а от дясно са бутоните са управление на завъртането и наклона на камерата.

Ако сте запознати с програмирането на PC, вие бихте могли да реализирате управление на платформата от вашия компютър през интернет и други среди.

Project for Android (GitHub)
Project for Arduino (GitHub)

 

Ръководство за Бърз Старт със Серво-моторите

 

Автор:  JoelEB

Източник:   sparkfun.com

Превод:  Т. Б.

Има голям избор от двигатели, от които да избирате, и понякога не е съвсем ясно, кой от тях най-добре ще пасне
за вашето конкретно приложение. В това ръководство, ние ще дискутираме един от тези мотори, стъпковият мотор, и
кога е най-добре да се спрем на стъпков мотор, а не на друг. Ние също така ще дискутираме, как да използваме този мотор
с платката за лесно управление на серво-мотори „EasyDriver Motor Driver board“, която е и един от най-простите
драйвери.

 

ИЗИСКВАНИЯ

Тук отдолу е даден списък на нещата, които е *препоръчително да имате:
+ Драйверна Платка „EasyDriver Stepper Motor Driver“
+ Малък Серво-мотор
+ Breadboard платка
+ Мъжки-към-мъжки мостови проводничета
+ Рейка тип „Male Break Away Headers – Straight“ – Права
+ Arduino Uno (или подобен микроконтролер)
+ Поялник и аксесоари към него
+ 12V Захранващ Източник (или регулируем захранващ източник)

КАК ВСЪЩНОСТ РАБОТИ

Стъпковите мотори се различават от постоянно-токовите DC мотори, по това, че те
не просто се въртят в една/ или друга посока, а по това че те могат да се завъртат
на много точен ъгъл (малка стъпка). Представете си моторче върху радио-управляем модел
на самолет. Моторчето се върти изключително бързо в една/ или друга посока. Вие можете
да променяте скоростта косвено чрез подаваната мощност към мотора, но Вие неможете да кажете
на перката да спре на определена позиция. А сега си представете принтер. При него
съществуват доста подвижни части, в това число и мотори. Един такъв мотор, работи докато
хартията се подава към принтера, въртящите се валячета, които придвижват хартията докато върху
нея се отпечатва нещо. Именно този мотор трябва да има възможност да премества хартията на точно
определено отстояние, за да може да се отпечата следващи ред от текст или от изображение.
Съществува друг мотор, който е прикрепен към винтовия плъзгач, който пък премества печатащата глава
напред и назад. Отново, винтовият плъзгач трябва да бъде преместван с точно определена стъпка
за да се отпечатат буквите една след друга. Именно тук стъпковите мотори стават полезни.

Стъпковите мотори могат да се движат на точно определено ъглово количество, в градуси (или стъпки), когато им е наредено.
Този факт Ви дава пълен контрол над мотора, като по този начин Ви позволява, да го придвижите на точно определено
местоположение и да задържите новата позиция. Това се осъществява, чрез захранването на намотки(бобини), които се намират
вътре в самия мотор за *изключително кратки времеви интервали. Единственият недостатък може би, е това че трябва постоянно
да захранвате мотора, ако желаете да запазите текущата нова позиция. Е, разбира се ние няма да навлизаме много в детайлите,
но вие можете да прочетете повече в Wikipedia article (http://en.wikipedia.org/wiki/Stepper_motor/) относно стъпковите
мотори за цялата важна информация. Всичко, което трябва да знаете към този момент, е че за да задвижите един стъпков мотор,
Вие му нареждате да се придвижи с определен брой стъпки в една/ или друга посока, като му указвате и скоростта, с която
трябва да осъществи преместването.

Съществуват различни видове стъпкови мотори, както и съответно драйверни платки, за да ги контролирате.
Методите описани тук, могат да бъдат използвани, за да се загатне как да използвате други мотори и драйвери, които
неса споменати в това ръководство. Обаче, винаги е препоръчително, да си направите справка с *Datasheets и ръководствата на моторите,
както и на драйверите, които са строго специфични според моделите, които притежавате.

КАК ДА ГО ИЗПОЛЗВАМЕ

Тук ние ще дискутираме, как да свържем, закачим и контролираме вашият мотор с фърмуеър (firmware) за Arduino.

„Асемблиране“
Най-елементарният начин, по който можете да използвате драйверната платка „Easy Driver“ е като към нея прикрепите рейки,
за по-лесно поставяне в breadboard платкакта. Тези инструкции предполагат, че Вие използвате метода чрез *Breadboard
платката.

Първата стъпка е да запоите мъжката рейка към драйверната платка „Easy Driver“. Същевременно изключително малък брой
от всички налични изводи на драйверната платка ще бъдат използвани тук. Обаче, силно се препоръчва всички изводи (пинове)
да бъдат запоени, за да се придаде по-голяма стабилност при прикрепянето към Breadboard платката. Изключително прост и
лесен за изпълнение метод, е просто да си „отчупите“ необходимото количество от рейката (спрямо броя на изводите), след
което да ги поставите в Breadboard платката на точните местоположения, да поставите след това модула „Easy Driver“ отгоре,
и едва след това да запоите всички връзки.

ЗАКАЧАНЕ

Веднъж щом сте запоили всички изводи на рейката, е време да закачите модула „Easy Driver“ към вашета
Arduino платка. Използвайте изображението отдолу, и направете всички необходими връзки.

Забележка:
Малкият стъпков мотор изглежда различно от този показан на картината. Той трябва да притежава 4-изводен конектор в края си.
Той ще бъде свързан към 4-изводната мъжка рейка, която сочи нагоре (вижте картина №3 в „Асеблиране“). Поради природата на
този определен стъпков мотор, вие можете да свържете конектора в едната от двете възможни ориентации, напр. или черният
проводник ще бъде отляво или жълтия. Със сигурност ще работи и при двата варианта. Ако ли пък Вие, използвате различен
стъпков мотор, консултирайте се с документацията му, за да откриете кой извод къде трябва да се свърже.

ВАЖНО:
Стъпковите мотори изискват повече мощност, от иначе нормално предоставяната от Arduino платката.
В този пример ние ще захранваме нашето Uno с 12V *външно захранване. Моля забележете, че захранващият вход(M+)
на модула „EasyDriver“ се свързва към Vin извода на Arduino платката. Това ще позволи, да се захранят едновременно,
както Arduino платката, така и мотора с един и същ захранващ източник.

ФЪРМУЕЪР /FIRMWARE/

Веднъж готови със всички връзки, осъществени правилно, Вие можете да качите фърмуера на Arduino. Следният код
е просто примерен и доста елементарен, но Ви позволява да продължите. Разбира се съществуват много подобни примери
в интернет, както и включени „библиотеки за управление на стъпков мотор“ към вашата ардуино среда Arduino IDE.
Чувствайте се свободни, да си играете с кода, да променяте стойности и да наблюдавате реакцията на схемата.
Както и да опитвате други сорс кодове.

СОРС – КОД

// Начало на кода

/*************************
Joel Bartlett
SparkFun Electronics
December 27, 2012

This code controls a stepper motor with the
EasyDriver board. It spins forwards and backwards
***************************/
int dirpin = 2;
int steppin = 3;

void setup()
{
pinMode(dirpin, OUTPUT);
pinMode(steppin, OUTPUT);
}
void loop()
{

int i;

digitalWrite(dirpin, LOW); // Set the direction.
delay(100);

for (i = 0; i<4000; i++) // Iterate for 4000 microsteps.
{
digitalWrite(steppin, LOW); // This LOW to HIGH change is what creates the
digitalWrite(steppin, HIGH); // „Rising Edge“ so the easydriver knows to when to step.
delayMicroseconds(500); // This delay time is close to top speed for this
} // particular motor. Any faster the motor stalls.

digitalWrite(dirpin, HIGH); // Change direction.
delay(100);

for (i = 0; i<4000; i++) // Iterate for 4000 microsteps
{
digitalWrite(steppin, LOW); // This LOW to HIGH change is what creates the
digitalWrite(steppin, HIGH); // „Rising Edge“ so the easydriver knows to when to step.
delayMicroseconds(500); // This delay time is close to top speed for this
} // particular motor. Any faster the motor stalls.

}

// Край на кода

 

ПРОДЪЛЖАВАЙТЕ НАПРЕД

Ето сега вече предполагам, вече сте наясно как можете да управлявате вашия стъпков мотор на най-просто ниво,
време е да преминете на следващото ниво. Съществува голямо количество от информация в и-нет пространството,
свързана с модула „EasyDriver“- в това число и на страницата на производителя. Съществува също чудестно ръководство
на страницата на bildr. Друг чудесен ресурс е схемата на модула „EasyDriver“, която ще Ви даде някаква яснота.
И най-накрая можете да погледете страницата ми с проекти със серво-мотори, Ardduija. В нея, аз използвам
стъпкови мотори, контролирани от EasyDrivers, за да създам X-Y коловози, които придвижвот Ouija платката автоматично.

Вие най-вероятно вече обмисляте, как да включите стъпковите мотори във вашия следващ проект. Успех с начинанията!

Arduino Pachube Клиент

Източник:  arduino.cc

Превод:  Т. Б.

Този пример Ви показва, как да отговорите на HTTP заявка, чрез Ethernet shield.
По специално, то се свързва към „pachube.com“, един безплатен сайт за събиране на информация от сензори (datalogging).
Този пример изисква от вас да си създадете акаунт в „pachube.com“, а също така да си създадете „pachube feed“
(за повече информация относно настройването на входен feed, моля кликнете > тук <).
Вашият Ethernet shield след това ще се свърже към този feed и ще качва там информация от сензора на всеки 10 секунди.

ХАРДУЕРНИ ИЗИСКВАНИЯ

+ Arduino Ethernet Shield или Arduino Ethernet
+ Shield-съвместим с Arduino платката
+ Един аналогов сензор свързан към Ethernet shield-да

СОФТУЕРНИ ИЗИСКВАНИЯ

+ Акаунт в pachube.com
+ Feed в patchube.com, който приема два информационни обекта

СХЕМА

Ethernet shield-да Ви позволява да свържете WizNet Ethernet контролера към Arduino посредством шината SPI.
Той използва изводи с номера 10,11,12 и 13 за SPI връзката към WizNet. По-късните модели на Ethernet shiеld
притежават също така вградена SD карта.
Цифровият „извод 4-ти“ се използа, за да се контролира „извода за контрол над подчинените устройства“ (Slave Select) върху SD картата.

Shield-да трябва да се свърже към мрежа чрез ethernet кабел. Ще се наложи да промените настройките в кода, за да отговарят
на вашите мрежова конфигурация.

*** изображението е проектирано чрез Fritzing. За повече примерни схеми, моля погледнете официялната страница на проекта „Fritzing project“.
В горното изображение, вашата Arduino платка трябва да се постави точно под „Ethernet shield“-да.

 

СХЕМА

На картината: Една CDS фотоклетка с „Изтеглящ-Надолу“ 10k Резистор, свързан към аналоговия извод-0.

 

СОРС КОД

// Начало на кода

/*
Pachube sensor client

This sketch connects an analog sensor to Pachube (http://www.pachube.com)
using a Wiznet Ethernet shield. You can use the Arduino Ethernet shield, or
the Adafruit Ethernet shield, either one will work, as long as it’s got
a Wiznet Ethernet module on board.

This example has been updated to use version 2.0 of the Pachube.com API.
To make it work, create a feed with a datastream, and give it the ID
sensor1. Or change the code below to match your feed.

Circuit:
* Analog sensor attached to analog in 0
* Ethernet shield attached to pins 10, 11, 12, 13

created 15 March 2010
modified 9 Apr 2012
by Tom Igoe with input from Usman Haque and Joe Saavedra

http://arduino.cc/en/Tutorial/PachubeClient
This code is in the public domain.

*/

#include <SPI.h>
#include <Ethernet.h>

#define APIKEY „YOUR API KEY GOES HERE“ // replace your pachube api key here
#define FEEDID 00000 // replace your feed ID
#define USERAGENT „My Project“ // user agent is the project name

// assign a MAC address for the ethernet controller.
// Newer Ethernet shields have a MAC address printed on a sticker on the shield
// fill in your address here:
byte mac[] = {
0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};

// fill in an available IP address on your network here,
// for manual configuration:
IPAddress ip(10,0,1,20);
// initialize the library instance:
EthernetClient client;

// if you don’t want to use DNS (and reduce your sketch size)
// use the numeric IP instead of the name for the server:
IPAddress server(216,52,233,122); // numeric IP for api.pachube.com
//char server[] = „api.pachube.com“; // name address for pachube API

unsigned long lastConnectionTime = 0; // last time you connected to the server, in milliseconds
boolean lastConnected = false; // state of the connection last time through the main loop
const unsigned long postingInterval = 10*1000; //delay between updates to Pachube.com

void setup() {
// Open serial communications and wait for port to open:
Serial.begin(9600);
while (!Serial) {
; // wait for serial port to connect. Needed for Leonardo only
}

// start the Ethernet connection:
if (Ethernet.begin(mac) == 0) {
Serial.println(„Failed to configure Ethernet using DHCP“);
// DHCP failed, so use a fixed IP address:
Ethernet.begin(mac, ip);
}
}

void loop() {
// read the analog sensor:
int sensorReading = analogRead(A0);

// if there’s incoming data from the net connection.
// send it out the serial port. This is for debugging
// purposes only:
if (client.available()) {
char c = client.read();
Serial.print(c);
}

// if there’s no net connection, but there was one last time
// through the loop, then stop the client:
if (!client.connected() && lastConnected) {
Serial.println();
Serial.println(„disconnecting.“);
client.stop();
}

// if you’re not connected, and ten seconds have passed since
// your last connection, then connect again and send data:
if(!client.connected() && (millis() – lastConnectionTime > postingInterval)) {
sendData(sensorReading);
}
// store the state of the connection for next time through
// the loop:
lastConnected = client.connected();
}

// this method makes a HTTP connection to the server:
void sendData(int thisData) {
// if there’s a successful connection:
if (client.connect(server, 80)) {
Serial.println(„connecting…“);
// send the HTTP PUT request:
client.print(„PUT /v2/feeds/“);
client.print(FEEDID);
client.println(„.csv HTTP/1.1“);
client.println(„Host: api.pachube.com“);
client.print(„X-PachubeApiKey: „);
client.println(APIKEY);
client.print(„User-Agent: „);
client.println(USERAGENT);
client.print(„Content-Length: „);

// calculate the length of the sensor reading in bytes:
// 8 bytes for „sensor1,“ + number of digits of the data:
int thisLength = 8 + getLength(thisData);
client.println(thisLength);

// last pieces of the HTTP PUT request:
client.println(„Content-Type: text/csv“);
client.println(„Connection: close“);
client.println();

// here’s the actual content of the PUT request:
client.print(„sensor1,“);
client.println(thisData);

}
else {
// if you couldn’t make a connection:
Serial.println(„connection failed“);
Serial.println();
Serial.println(„disconnecting.“);
client.stop();
}
// note the time that the connection was made or attempted:
lastConnectionTime = millis();
}

// This method calculates the number of digits in the
// sensor reading. Since each digit of the ASCII decimal
// representation is a byte, the number of digits equals
// the number of bytes:

int getLength(int someValue) {
// there’s at least one byte:
int digits = 1;
// continually divide the value by ten,
// adding one to the digit count for each
// time you divide, until you’re at 0:
int dividend = someValue /10;
while (dividend > 0) {
dividend = dividend /10;
digits++;
}
// return the number of digits:
return digits;
}

// Край на кода

Arduino Twitter Клиент

Източник:  arduino.cc

Превод:  Т. Б.

TWITTER КЛИЕНТ

Този пример Ви показва, как да отговорите на HTTP заявка чрез Ethernet shield.
Тази блокова схема се свързва към Twitter чрез Ethernet shield.
Той анализира върнатият XML файл, и търси в него следните два ТАГ-а <text> това tweet </text>

Вие може да използвате Arduino Ethernet Shield-да, или Adafruit Ethernet shild, но все един от двата
ще Ви свърши работа, докато има свързан към себе си Ethernet модул Wiznet.

ХАРДУЕРНИ ИЗИСКВАНИЯ
+ Arduino Ethernet Shield
+ Shild-съвместим с Arduino платката

СОФТУЕРНИ ИЗИСКВАНИЯ
+ Акаунт в twitter.com

СХЕМА

*** изображението е проектирано чрез Fritzing. За повече примерни схеми, моля погледнете официялната страница на проекта „Fritzing project“.

В горното изображение, вашата Arduino платка трябва да се постави точно под „Ethernet shield“-да.

 

СОРС КОД

// Начало на кода

/*
Twitter Client with Strings

This sketch connects to Twitter using an Ethernet shield. It parses the XML
returned, and looks for <text>this is a tweet</text>

You can use the Arduino Ethernet shield, or the Adafruit Ethernet shield,
either one will work, as long as it’s got a Wiznet Ethernet module on board.

This example uses the DHCP routines in the Ethernet library which is part of the
Arduino core from version 1.0 beta 1

This example uses the String library, which is part of the Arduino core from
version 0019.

Circuit:
* Ethernet shield attached to pins 10, 11, 12, 13

created 21 May 2011
modified 9 Apr 2012
by Tom Igoe

This code is in the public domain.

*/
#include <SPI.h>
#include <Ethernet.h>

// Enter a MAC address and IP address for your controller below.
// The IP address will be dependent on your local network:
byte mac[] = {
0x00, 0xAA, 0xBB, 0xCC, 0xDE, 0x01 };
IPAddress ip(192,168,1,20);

// initialize the library instance:
EthernetClient client;

const unsigned long requestInterval = 60000; // delay between requests

char serverName[] = „api.twitter.com“; // twitter URL

boolean requested; // whether you’ve made a request since connecting
unsigned long lastAttemptTime = 0; // last time you connected to the server, in milliseconds

String currentLine = „“; // string to hold the text from server
String tweet = „“; // string to hold the tweet
boolean readingTweet = false; // if you’re currently reading the tweet

void setup() {
// reserve space for the strings:
currentLine.reserve(256);
tweet.reserve(150);

// Open serial communications and wait for port to open:
Serial.begin(9600);
while (!Serial) {
; // wait for serial port to connect. Needed for Leonardo only
}

// attempt a DHCP connection:
Serial.println(„Attempting to get an IP address using DHCP:“);
if (!Ethernet.begin(mac)) {
// if DHCP fails, start with a hard-coded address:
Serial.println(„failed to get an IP address using DHCP, trying manually“);
Ethernet.begin(mac, ip);
}
Serial.print(„My address:“);
Serial.println(Ethernet.localIP());
// connect to Twitter:
connectToServer();
}

void loop()
{
if (client.connected()) {
if (client.available()) {
// read incoming bytes:
char inChar = client.read();

// add incoming byte to end of line:
currentLine += inChar;

// if you get a newline, clear the line:
if (inChar == ‘\n’) {
currentLine = „“;
}
// if the current line ends with <text>, it will
// be followed by the tweet:
if ( currentLine.endsWith(„<text>“)) {
// tweet is beginning. Clear the tweet string:
readingTweet = true;
tweet = „“;
}
// if you’re currently reading the bytes of a tweet,
// add them to the tweet String:
if (readingTweet) {
if (inChar != ‘<‘) {
tweet += inChar;
}
else {
// if you got a „<“ character,
// you’ve reached the end of the tweet:
readingTweet = false;
Serial.println(tweet);
// close the connection to the server:
client.stop();
}
}
}
}
else if (millis() – lastAttemptTime > requestInterval) {
// if you’re not connected, and two minutes have passed since
// your last connection, then attempt to connect again:
connectToServer();
}
}

void connectToServer() {
// attempt to connect, and wait a millisecond:
Serial.println(„connecting to server…“);
if (client.connect(serverName, 80)) {
Serial.println(„making HTTP request…“);
// make HTTP GET request to twitter:
client.println(„GET /1/statuses/user_timeline.xml?screen_name=arduino&count=1 HTTP/1.1“);
client.println(„HOST: api.twitter.com“);
client.println();
}
// note the time of this connect attempt:
lastAttemptTime = millis();
}

// Край на кода

 

Прост WebServer с Arduino

Източник:  arduino.cc
Превел: Т.Б.

УЕБ СЪРВЪР

В този пример, Вие ще използвате вашият Ethernet Shield и вашето Arduino, за да създадете един прост Web сървър.
Използвайки библиотеката за ethernet, вашето устройство ще може да отговаря на http заявки посредством вашият ethernet shield.
След като отворите браузера и въведете адреса (IP адрес) на вашия ethernet shield, вашето Arduino устройство ще отговори с
достатъчен HTML код за браузера, за да се визуализират входните стойности от всички шест аналогови входни извода.

НЕОБХОДИМ ХАРДУЕР

+ Arduino Ethernet Shield
+ Shiled-съвместим с Arduino платката

БЛОК-СХЕМА

„Ethernet shield“-да Ви позволява да се свържете към мрежа посредством ethernet кабел.
Ще се наложи да промените мрежовите настройки в *кода, за да отговарят на вашите мрежови настройки.


*** изображението е проектирано чрез Fritzing. За повече примерни схеми, моля погледнете официялната страница на проекта „Fritzing project“.
В горното изображение, вашата Arduino платка трябва да се постави точно под „Ethernet shield“-да.

СХЕМА

СОРС-КОД

// Начало на кода
/*
Web Server

A simple web server that shows the value of the analog input pins.
using an Arduino Wiznet Ethernet shield.

Circuit:
* Ethernet shield attached to pins 10, 11, 12, 13
* Analog inputs attached to pins A0 through A5 (optional)

created 18 Dec 2009
by David A. Mellis
modified 9 Apr 2012
by Tom Igoe

*/

#include <SPI.h>
#include <Ethernet.h>

// Enter a MAC address and IP address for your controller below.
// The IP address will be dependent on your local network:
byte mac[] = {
0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
IPAddress ip(192,168,1, 177);

// Initialize the Ethernet server library
// with the IP address and port you want to use
// (port 80 is default for HTTP):
EthernetServer server(80);

void setup() {
// Open serial communications and wait for port to open:
Serial.begin(9600);
while (!Serial) {
; // wait for serial port to connect. Needed for Leonardo only
}

// start the Ethernet connection and the server:
Ethernet.begin(mac, ip);
server.begin();
Serial.print(„server is at „);
Serial.println(Ethernet.localIP());
}

void loop() {
// listen for incoming clients
EthernetClient client = server.available();
if (client) {
Serial.println(„new client“);
// an http request ends with a blank line
boolean currentLineIsBlank = true;
while (client.connected()) {
if (client.available()) {
char c = client.read();
Serial.write(c);
// if you’ve gotten to the end of the line (received a newline
// character) and the line is blank, the http request has ended,
// so you can send a reply
if (c == ‘\n’ && currentLineIsBlank) {
// send a standard http response header
client.println(„HTTP/1.1 200 OK“);
client.println(„Content-Type: text/html“);
client.println(„Connnection: close“);
client.println();
client.println(„<!DOCTYPE HTML>“);
client.println(„<html>“);
// add a meta refresh tag, so the browser pulls again every 5 seconds:
client.println(„<meta http-equiv=\“refresh\“ content=\“5\“>“);
// output the value of each analog input pin
for (int analogChannel = 0; analogChannel < 6; analogChannel++) {
int sensorReading = analogRead(analogChannel);
client.print(„analog input „);
client.print(analogChannel);
client.print(“ is „);
client.print(sensorReading);
client.println(„<br />“);
}
client.println(„</html>“);
break;
}
if (c == ‘\n’) {
// you’re starting a new line
currentLineIsBlank = true;
}
else if (c != ‘\r’) {
// you’ve gotten a character on the current line
currentLineIsBlank = false;
}
}
}
// give the web browser time to receive the data
delay(1);
// close the connection:
client.stop();
Serial.println(„client disonnected“);
}
}
// Край на кода

*** Забележка:
Коментарите в началото и края на кода, може да се премахнат при необходимост. //

Ардуино и Контролер за Радио-Контролирана Хоби Количка

Източник:  www.sparkfun.com

Оригинално Заглавие: RC Hobby Controllers and Arduino

Превод: Т.Б.

Дистанционно с Ардуино

Роботите, количките, робо-количките, както и всички видове подобни устройства, изискват някаква степен на отдалечен контрол. В повечето от случаите е наистина изкушаващо да си го реализирате сами посредством модулите Xbee или друга подобна безжична технология. Понякога това не е никак лоша идея, но по-често това е прекалено „изсилване“ /ненужно като параметри хардуерна мощ/ и един от често разочароващите методи. Сега Вие сигурно си мислите, „Спомням си добрите стари дни, когато просто поставях батериите в RC количката, натискайки бутоните – тя започваше да се движи“.

Е, добре дошли отново в тези добри стари дни.

RC предавателят/приемникът комбинират широк обхват от прости и нескъпи решения – справяйки се с сериозни задачи, но най-хубавото за тях, е че те всички отговарят на даден стандарт, което наистина ги прави взаимозаменяеми. С една дума излиза, че е едно и също като начин свързването на RC приемник към вашия Ардуино проект, по същия начин по който свързвате серво мотор, а кодът е също толкова елементарен. В това ръководство, аз ще Ви преведа през основите на пълноценното използване на вашята Ардуино платформа, за да я накарате да интерпретира команди от нескъпо RC дистанционно, за да можете да контролирате всичко /което желаете/, в това число четири-колесен робот и мн. др.

Това звучи страхотно, но Аз Никога не съм докосвал RC Предавател …

Това не е толкова сложно, колкото звучи – ще Ви помогна да навлезете в материята. Радио-контролираните предаватели и приемници обикновенно се използват за управление на модели на колички и самолети. Типичният предавател ще разполага с няколко контролни повърхности, като например скрол или джойстик, както и някои ключове или клавиатури. Всяка степен на свобода, която контролерът Ви осигурява представлява точно определен радио канал. Или с други думи, джойстика заема два канала (x & y), където клавиатурата или ключа ще заема само един канал. RC предавателите най-общо имат между четири и шест от тези канали.

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

Е нека го закачим!

Добре, това е духът! Ние ще закачим няколко канала от RC приемникът, за да разберем как изглежда входа на приемника. RC предавателя/приемника са чифт, разполагам с шест канала, но ние ще видим как точно да ги свържем сега. Това означава, че са ни необходими три цифрови извода, които да прочитат входа, както и 5V, за да захраним приемника. Тук отдолу е дадена схема, по която аз си свързах моите:

Забележете, че RC приемникът е надолу, Обърнах го с цел да направя проводниците по-лесно проследими. Ще са Ви необходими мъжко-женски джъмпери ако разполагате с такива. Ако ли не, Вие може да използвате някои слепнати мъжки и женски джъмпери заедно. Цифровите изводи, който аз избрах са напълно случайни; вие трябва да можете да използвате всеки цифров вход върху Ардуино, който желаете, но горната схема отговаря на кодът по-долу.

Сега нека кача скица и да видим какво е свързцано към тези изводи. „Серво езикът“, който RC приемника създава, всъщност е истинска PWM (Ширичонно Импулсна Модулация). Arduino има удобна функция вградена в него, за прочитане на тези импулси и за връщане на тяхната дължина в милисекунди. Функцията се нарича  pulseIn() . Нега хвърлим един поглед върху простата схема, която написах за да отпечатаме суровия вход на приемника към последователен /сериен/ монитор.

// Начало на кода

/*
 RC PulseIn Serial Read out
 By: Nick Poole
 SparkFun Electronics
 Date: 5
 License: CC-BY SA 3.0 - Creative commons share-alike 3.0
 use this code however you'd like, just keep this license and
 attribute. Let me know if you make hugely, awesome, great changes.
 */

int ch1; // Here's where we'll keep our channel values
int ch2;
int ch3;

void setup() {

  pinMode(5, INPUT); // Set our input pins as such
  pinMode(6, INPUT);
  pinMode(7, INPUT);

  Serial.begin(9600); // Pour a bowl of Serial

}

void loop() {

  ch1 = pulseIn(5, HIGH, 25000); // Read the pulse width of
  ch2 = pulseIn(6, HIGH, 25000); // each channel
  ch3 = pulseIn(7, HIGH, 25000);

  Serial.print("Channel 1:"); // Print the value of
  Serial.println(ch1);        // each channel

  Serial.print("Channel 2:");
  Serial.println(ch2);

  Serial.print("Channel 3:");
  Serial.println(ch3);

  delay(100); // I put this here just to make the terminal
              // window happier
}
// Край на кода

Функцията pulseIn() взима три аргумента:  първият е изводът, на който се появява вашият импулс; втория  представлява типа на импулса, който търсите; и третият представлява число време-прекъсване, което показва колко точно време желаете да чакате този импулс да се появи. Въпросната функция връща като резултат дължината на импулса в микросекунди, и именно по този начин ние ще прочитаме входящите PWM, по същия начин ако беше серво.мотор. Когато Вие изпълните този код, Вие трябва да получите като резултат някакви стойности /числа/ – които се появяват в изхода на терминала. Числата най-вероятно за вас няма да означават нищо, но по същество те трябва като стойности да бъдат някъде между 1000 и 2000. Това което наистина в случая е от значение, е че когато Вие започнете да движите контролната повърхност с това число, да завъртате потенциометри и да превкл. ключове , е хубаво наистина да обърнете внимание на канала, който се засяга. Сега, след като разполагаме с всички тези стойности, ние можем да кодираме различни състояния с тяхна помощ и да правим каквото си пожелаем. Скицата отдолу е моята скица след като я модифицирах, за да поставя тези стойности във функцията pulseIn() в този контекст. // Начало на кода

	 
/*
 RC PulseIn Joystick
 By: Nick Poole
 SparkFun Electronics
 Date: 5
 License: CC-BY SA 3.0 - Creative commons share-alike 3.0
 use this code however you'd like, just keep this license and
 attribute. Let me know if you make hugely, awesome, great changes.
 */

int ch1; // Here's where we'll keep our channel values
int ch2;
int ch3;

void setup() {

pinMode(5, INPUT); // Set our input pins as such
pinMode(6, INPUT);
pinMode(7, INPUT);

Serial.begin(9600); // Pour a bowl of Serial

}

void loop() {

  ch1 = pulseIn(5, HIGH, 25000); // Read the pulse width of
  ch2 = pulseIn(6, HIGH, 25000); // each channel
  ch3 = pulseIn(7, HIGH, 25000);

  if(ch1>1000){Serial.println("Left Switch: Engaged");}
  if(ch1<1000){Serial.println("Left Switch: Disengaged");}
  /* I found that Ch1 was my left switch and that it
  floats around 900 in the off position and jumps to 
  around 1100 in the on position */

Serial.print("Right Stick X:"); // Ch3 was x-axis
Serial.println(map(ch3, 1000,2000,-500,500)); // center at 0

Serial.print("Right Stick Y:"); // Ch2 was y-axis
Serial.println(map(ch2, 1000,2000,-500,500)); // center at 0

Serial.println(); //make some room

delay(100);// I put this here just to make the terminal
           // window happier
}
// Край на кода

Тук можете да видите, че аз съм си представил, коя контролна повърхност, кой канал контролира и същевременно съм написал няколко реда с print функцията, които ще повлияят върху моите действия връху предавателя на чист Английски. Съответно Вие бихте могли да разгърнете това за всеки отделен канал на вашия приемник, вие също така бихте могли да заместите тази скица с Firmata и да контролирате обработващата скица с вашия RC предавател, но аз си мисля, че най-добрата демонстрация, която аз мога да Ви представя е като метна този код на един робот и като го пораздвижа. Е хайде най-накрая да се захващаме.

Радио Приемник Robot Rig?

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

Направих шест реда от три, тъй като предавателят разполага с шест канала, и не Ви е необходимо да го свързвате към рейката на батерията на приемника, тъй като Вие използвате захранването и масата на рейката на серво-мотора. Когато запоите тези вътре, имайте впредвид, че вашия приемник ще бъде обърнат впоследствие наопаки, затова го запоете по подходящ начин. Вие трябва да имате възможност да видите сега как аз съм ги свързал, като наблюдавате изображенията по-горе. Редът с масата е окъсен целия и включен към маса – по същия начин е процедирано с положителния полюс на захранването – след което всеки сигнален извод се разделя към цифровия извод. Това определено не е най-правилния начин за реализиране, но той работи доста добре. А ето и как изглежда шасито с нашия модифициран шийлд Ardumoto и със свързания към него Ardumoto:

Не е никак зле нали? Уверете се, че вашите мотори са свързани по подходящия начин и добавете захранващ източник (9V батерия на мен ми свърши прекрасна работа), тъй като вече е крайно време да го подкараме това нещо. Единствената стъпка, която ни остана е да напишем няколко реда код, за да преведем серво командите за управление към команди за левия/десния серво-мотор. Ще Ви осигуря кода сега и ще го разясня отдолу.

// Начало на кода

	 
/*
 RC PulseIn Joystick Servo Control
 By: Nick Poole
 SparkFun Electronics
 Date: 5
 License: CC-BY SA 3.0 - Creative commons share-alike 3.0
 use this code however you'd like, just keep this license and
 attribute. Let me know if you make hugely, awesome, great changes.
 */

int ch1; // Here's where we'll keep our channel values
int ch2;
int ch3;

int move; // Forward/Back speed
int turn; // Turning Factor

int pwm_a = 3;  //PWM control for motor outputs
int pwm_b = 11;  //PWM control for motor outputs
int dir_a = 12;  //direction control for motor outputs
int dir_b = 13;  //direction control for motor outputs

void setup() {

pinMode(5, INPUT); // Set our input pins as such
pinMode(6, INPUT);
pinMode(7, INPUT);

Serial.begin(9600); // Pour a bowl of Serial (for debugging)

  pinMode(pwm_a, OUTPUT);  //Set control pins to be outputs
  pinMode(pwm_b, OUTPUT);
  pinMode(dir_a, OUTPUT);
  pinMode(dir_b, OUTPUT);

  analogWrite(pwm_a, 0);  
  analogWrite(pwm_b, 0);
}

void loop() {

  ch1 = pulseIn(4, HIGH, 25000); // Read the pulse width of  
  ch2 = pulseIn(5, HIGH, 25000); // each channel
  ch3 = pulseIn(6, HIGH, 25000);
  /*
  if(ch1>1000){Serial.println("Left Switch: Engaged");}
  if(ch1<1000){Serial.println("Left Switch: Disengaged");}

Serial.print("Right Stick X:");
Serial.println(map(ch3, 1000,2000,-500,500));

Serial.print("Right Stick Y:");
Serial.println(map(ch2, 1000,2000,-500,500));

Serial.println();

delay(100);

clearAndHome();
*/

move = map(ch2, 1000,2000, -500, 500); //center over zero
move = constrain(move, -255, 255); //only pass values whose absolutes are
                                   //valid pwm values

/*What we're doing here is determining whether we want to move
forward or backward*/
if(move>0){digitalWrite(dir_a, 1);digitalWrite(dir_b, 1);};
if(move<0){digitalWrite(dir_a, 0);digitalWrite(dir_b, 0); move=abs(move);};

/*Here we're determining whether a left or a right turn is being 
executed*/
turn = map(ch1,1000,2000,-500,500);
turn = constrain(turn, -255, 255);

/*This is where we do some mixing, by subtracting our "turn" 
variable from the appropriate motor's speed we can execute
a turn in either direction*/
if(turn>0){analogWrite(pwm_b, move-turn); analogWrite(pwm_a, move);};
if(turn<0){turn=abs(turn); analogWrite(pwm_a, move-turn); analogWrite(pwm_b, move);};

Serial.print("move:"); //Serial debugging stuff
Serial.println(move);

Serial.print("turn:"); //Serial debugging stuff
Serial.println(turn);

Serial.print("move-turn:"); //Serial debugging stuff
Serial.println(move-turn);

Serial.println(); //Serial debugging stuff
Serial.println();
Serial.println();

}

// Край на кода

Окей, нека да погледна дали мога да обясня как точно се осъществява управлението в горната скица. Това което направих, в основни линии отбелязва посоката на движение напред/назад – отговаряща на моя джойстик, това най-общо са стойности в интервала от -255 до 255, с др.стойност представящ пълната скорост назад/напред. За да комуникирате по този начин с Arduino шийлда, Вие трябва да ги разделите на отделни числа: такива за посока и скорост. За да направя това, аз просто проверих, за да съм сигурен дали въпросното число е положително. Ако е така, аз променях посоката на движение на двата мотора на 1-ца. Ако ли пък въпросното число е отрицателно, то тогава просто задавах посока на двата мотора 0-ла. Всичко, което трябваше да направя след това е да получа „абсолютната стойност“ на това число и да го използвам като моя основна PWM стойност за двата мотора. Аз казвам „основна PWM стойност“, тъй като това не е точно това, което се изпраща като данни към двата мотора, вместо честата на завъртане /оборотите/ да се изважда от едната страна.

Очевидно има и съвсем други подходи, за да реализирате диференциалното управление; с малко повече редове код Вие можете да обърнете, някой конкретен мотор в обратната посока и по този начин да се въртите на място. Също така този код не управлява по начина, по който най-вероятно очаквате, когато карате наобратно. При някои случаи, това трябва да Ви е достатъчно, за да стартирате с Роботите и радио управляемите модели , също така се надявам, че сте били вдъхновени до такава степен, че да грабнете хоби-предавателят за следващия ви проект с робот.

Успешно хакване!

Използвайте Бутон, за да Контролирате Светодиод (LED)

Източник:   arduino.cc

Превел:  Т.Б

 

БУТОН:

Функцията на „бутона без задържане“ или ключа е да свърже две точки (два възела) в схемата, когато го натиснете. Този пример показва как да засветнете вграденият в Arduino платформата светодиод на Извод №13 (pin 13), когато натиснете бутон.

НЕОБХОДИМ ХАРДУЕР:

+ Arduino платформа
+ Бутон без задържане или ключе
+ Резистор 10k
+ Breadboard Учебна платка
+ Мостов проводник (тънък)

СХЕМА:

КЛИКНЕТЕ, ЗА ДА УВЕЛИЧИТЕ ...

Изображението е разработено с помоща на Fritzing. За повече примерни схеми, моля погледнете официалната страница на проекта Fritzing.

Свържете три проводника към Arduino платформата. Първите два от тях, червеният и черния, свържете към двата дълги вертикални реда от страната на Breadboard учебната платка, за да осигурите достъп до захранващо напрежение със стойност 5V и маса. Третият проводник се свързва от „Цифровия Извод №2“ (digital pin 2) към един от изводите на бутона. Този същият извод на бутона се свързва през „изтеглящ резистор“ (в конкретната схема със стойност 10k) към маса. Другият извод на бутона се свързва към захранващо напрежение 5V.

Когато бутона е „отворен“ (т.е. не е натиснат), несъществува връзка между двата извода на бутона, затова извода е свързан към маса (през изтеглящия резистор) и съответно ние ще „прочетем чрез софтуера“, логическо ниво „НИСКО“ („логическа нула“). Когато бутона се затвори (т.е. натисне), той осъществява връзка между своите два извода, свързвайки същевременно извода към 5V, затова ние след това прочитаме „ВИСОКО“ ниво.

Вие бихте могли също така да свържете тази схема по обратният начин, с изтеглящ резистор към „ВИСОКОТО“ ниво, и при натискане на бутона да отивате в „НИСКО“ ниво. Ако предпочетете този вариант, вече описания начин на работа на схемата ще се инвертира (обърне по смисъл), с „нормално“ включен светодиод (LED) и изключвайки се, когато натиснете бутона.

Ако откачите/прекъснете „цифровият входно/изходен извод“ от всичко, оставяйки изтеглящия резистор към „ВИСОКО“ ниво, светодиода може да премигва хаотично. Това става така, тъй като входа „плава“ – това означава, че той през определен времеви интервал ще сменя своето ниво НИСКО -> ВИСОКО и обратно. Ето защо Вие се нуждаете от изтеглящ резистор (pull-up/pull-down) в схемата.

СХЕМА:
КЛИКНЕТЕ, ЗА ДА УВЕЛИЧИТЕ ...

КОД:
/*
Button

Turns on and off a light emitting diode(LED) connected to digital
pin 13, when pressing a pushbutton attached to pin 2.

The circuit:
* LED attached from pin 13 to ground
* pushbutton attached to pin 2 from +5V
* 10K resistor attached to pin 2 from ground

* Note: on most Arduinos there is already an LED on the board
attached to pin 13.

created 2005
by DojoDave
modified 30 Aug 2011
by Tom Igoe

This example code is in the public domain.

http://www.arduino.cc/en/Tutorial/Button
*/

// constants won’t change. They’re used here to
// set pin numbers:
const int buttonPin = 2; // the number of the pushbutton pin
const int ledPin = 13; // the number of the LED pin

// variables will change:
int buttonState = 0; // variable for reading the pushbutton status

void setup() {
// initialize the LED pin as an output:
pinMode(ledPin, OUTPUT);
// initialize the pushbutton pin as an input:
pinMode(buttonPin, INPUT);
}

void loop(){
// read the state of the pushbutton value:
buttonState = digitalRead(buttonPin);

// check if the pushbutton is pressed.
// if it is, the buttonState is HIGH:
if (buttonState == HIGH) {
// turn LED on:
digitalWrite(ledPin, HIGH);
}
else {
// turn LED off:
digitalWrite(ledPin, LOW);
}
}

Премигване без закъснение

Източник:  arduino.cc

Превел:  Т.Б.

 

Понякога Вие трябва да направите две неща едновременно. Например Вие може да поискате да накарате светодиод
(LED) да премигва (или да реализирате някоя време-чувствителна функция) докато същевременно „прочитате“
натискане на бутон или друга входна информация.

В този случай, Вие неможе да използвате функцията delay(), или вие просто бихте прекратили останалите операции,
докато светодиода премигва. Самата програма може да „пропусне“ събитието по „натискането на бутона“,
в случай че това събитие се случи по време на изпълнение на функцията delay().

Тази схема демонстрира, как да накарате светодиод да премигва, чрез употребата на функцията delay().
Тя запомня момента, когато Arduino за последно е засветнал диода. Тогава, всеки път щом премине през функцията loop(),
дали е изминал достатъчно дълъг интервал от време. Ако е изминат въпросният интервал, схемата обръща (toggles) текущото
състояние на светодиода (вкл./изкл.).

НЕОБХОДИМ ХАРДУЕР:

+ Платка Arduino
+ LED Светодиод (с токоограничаващ резистор)

СХЕМА:

 

 

КЛИКНИ, ЗА ДА УВЕЛИЧИШ ...

За да свържете схемата, вземете светодиода и свържете неговия по-дълъг извод, наричан още анод към Извод №13 (pin 13)на Arduino платформата. Свържете по-късият извод на светодиода, наричан още катод към маса (GND).

След това включете Arduino платформата към компютъра, стартирайте работната среда на Arduino и въведете кода отдолу.

СХЕМА:

КЛИКНЕТЕ, ЗА ДА УВЕЛИЧИТЕ ...

Изображението е разработено с помоща на Fritzing. За повече примерни схеми, моля погледнете официалната страница на проекта Fritzing.

КОД:

/* Blink without Delay

Turns on and off a light emitting diode(LED) connected to a digital
pin, without using the delay() function. This means that other code
can run at the same time without being interrupted by the LED code.

The circuit:
* LED attached from pin 13 to ground.
* Note: on most Arduinos, there is already an LED on the board
that’s attached to pin 13, so no hardware is needed for this example.

created 2005
by David A. Mellis
modified 8 Feb 2010
by Paul Stoffregen

This example code is in the public domain.

http://www.arduino.cc/en/Tutorial/BlinkWithoutDelay
*/

// constants won’t change. Used here to
// set pin numbers:
const int ledPin = 13; // the number of the LED pin

// Variables will change:
int ledState = LOW; // ledState used to set the LED
long previousMillis = 0; // will store last time LED was updated

// the follow variables is a long because the time, measured in miliseconds,
// will quickly become a bigger number than can be stored in an int.
long interval = 1000; // interval at which to blink (milliseconds)

void setup() {
// set the digital pin as output:
pinMode(ledPin, OUTPUT);
}

void loop()
{
// here is where you’d put code that needs to be running all the time.

// check to see if it’s time to blink the LED; that is, if the
// difference between the current time and last time you blinked
// the LED is bigger than the interval at which you want to
// blink the LED.
unsigned long currentMillis = millis();

if(currentMillis – previousMillis > interval) {
// save the last time you blinked the LED
previousMillis = currentMillis;

// if the LED is off turn it on and vice-versa:
if (ledState == LOW)
ledState = HIGH;
else
ledState = LOW;

// set the LED with the ledState of the variable:
digitalWrite(ledPin, ledState);
}
}