Изучаване на основно Arduino програмиране - Урок за новодошлите

Изучаване на основно Arduino програмиране - Урок за новодошлите

В този урок научаваме как да правим основно програмиране на Arduino чрез примерни кодове и примерни програми. Този урок може да бъде изключително ценен курс за всички новодошли, които искат да разберат основите чрез лесен и разбираем език.



Въведение

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

Микроконтролерът става толкова полезен за потребителя, тъй като предлага вграден процесор, памет и портове за вход / изход (наричани още GPIO или пинове за вход / изход с общо предназначение), които можем да контролираме от потребителя според желаните спецификации.





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

Сега нека се придвижим бързо и да научим как да започнем с програмирането на Arduino.



1.2 Инсталиране на софтуера (Windows)

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

Windows ZIP файл за не администраторска инсталация

След изтеглянето ще намерите иконата за настройка на Arduino в папката за изтегляне, която би изглеждала така:

икона за изтегляне на arduino

След като получите това, можете просто да кликнете два пъти върху него и да инсталирате Arduino интегрираната среда за разработка (IDE) на вашия компютър. Пълният процес може да бъде визуализиран в следното видео:

https://youtu.be/x7AMn1paCeU

1.4 Започвайки с първата ни верига

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

Както знаем, светодиодът е светодиод, който има полярност и няма да свети, ако не е свързан с правилните захранващи полюси.

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

Като правило, 330 ома 1/4 вата е напълно идеален за всеки 5V покачване на захранващия вход, за да се ограничи токът до необходимото безопасно ниво. Следователно за 5V може да е 330 ома, за 10V може да е 680 ома и т.н.

Използване на макет за събрание

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

Основната настройка на LED връзката може да се види по-долу:

LED с Arduino

Можете да видите 3 основни компонента по-горе:

  1. Светодиод 5mm, 20mA
  2. 330 омов 1/4 ватен резистор
  3. An Дъска Arduino

Просто сглобете системата според схемата.

След това включете 5V от компютърния USB към Arduino. Веднага след като направите това, ще видите, че LED светва.

Знам, че това е доста основно, но винаги е добре да започнем от нулата. Бъдете сигурни, че нещата ще започнат да стават все по-интересни, докато напредваме.

1.5 Управление на светодиода с Arduino

Сега ще научим как да управляваме светодиод с програма Arduino.

За да напишем програма, трябва да имаме поне 2 функции във всяка програма.

Функция може да се разбира като поредица от програмни изрази, които могат да бъдат присвоени с име, както е дадено по-долу:

  1. настройвам() това се извиква или изпълнява по време на старта на програмата.
  2. цикъл () това се извиква или изпълнява повтарящо се през целия оперативен период на Arduino.

Следователно, въпреки че може да няма практическа функционалност, технически най-кратката легитимна програма Arduino може да бъде написана като:

Най-проста програма

void setup()
{
}
void loop()
{
}

Може би сте забелязали, че в много от езиците за програмиране системата започва с показване на обикновен отпечатък „Hello, World“ на екрана на дисплея

Електронният еквивалент на тази фраза в интерпретацията на микроконтролера е да мига светодиод ON и OFF.

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

Ще се опитаме да приложим и разберем процедурата чрез следния код:

Листинг 1.2: led1 / led1.pde

const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
void loop()
{
digitalWrite(kPinLed, HIGH)
delay(500)
digitalWrite(kPinLed, LOW)
delay(500)
}

Добре, сега нека разберем какво означава всеки ред от кода и как работи за изпълнение на функцията:

const int kPinLed = 13

Това работи като константа, която ни позволява да я използваме по време на целия курс по програмиране, без да е необходимо да използваме действителната стойност, която е настроена спрямо нея.

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

void setup()
{
pinMode(kPinLed, OUTPUT)
}

Този код конфигурира конкретния щифт, към който е свързан нашият светодиод. С други думи, кодът казва на Arduino да контролира аспекта „писане“ на този щифт, вместо да го „чете“.

void loop()
{
digitalWrite(kPinLed, HIGH)
delay(500)
digitalWrite(kPinLed, LOW)
delay(500)
}

Горните редове показват действителното изпълнение на приложението. Кодът започва с писане и изобразяване на HIGH на съответната LED връзка, като се включва LED.

Тук терминът HIGH просто означава получаване на + 5V на съответния щифт на Arduino. Допълващият термин LOW просто показва нула или 0V на обозначения щифт.

След това извикваме delay() чиято функция е да създава закъснение през милисекунди (1/1000 от секундата). Тъй като е въведена цифрата 500, приложеното забавяне ще бъде за 1/2 секунда.

Веднага след изтичането на тази 1/2 секунда се изпълнява следващият ред, който изключва светодиода с LOW термина на същия щифт.

Следващият ред още веднъж генерира закъснение от 1/2 секунда, за да позволи на светодиода да остане изключен за 1/2 секунди.

И процесът продължава безкрайно чрез изпълнението на редовете на кода, стига Arduino да бъде захранван.

Преди да преминете към следващото ниво, бих ви препоръчал да програмирате горния код и да проверите дали сте в състояние да внедрите правилно LED / ON последователност.

Тъй като светодиодът по подразбиране в Arduino е свързан с щифт # 13, той трябва незабавно да отговори на горната програма и да започне да мига. Ако обаче откриете, че вашият външен светодиод не мига, тогава може да има повреда в връзката с вашия светодиод, можете да опитате да обърнете полярността на вашия светодиод и да се надяваме да видите и той да мига.

Можете да играете с времето на закъснение, като промените цифрата „500“ на някаква друга стойност и откриете светодиода, който „слуша“ командите и го кара да мига според посочените стойности на закъснение.

Но не забравяйте, ако видите, че светодиодът не мига с постоянна скорост от 1 секунда, независимо от промяната на времето на забавяне, това може да означава, че кодът не работи поради някаква грешка. Тъй като по подразбиране Arduino ще бъде програмиран с мигаща скорост от 1 секунда. Следователно този процент трябва да се променя според вашия код, за да се потвърди коректната му работа.

1.7 Коментари

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

Въпреки това, за да се гарантира, че потребителят може да се позовава на смисъла на редовете и да ги разбира, често може да бъде полезно и разумно да напише обяснението до желаните редове от кодове.

Те се наричат коментари които са написани само за справка от хора или потребители и са кодирани, за да позволят на компютрите да го игнорират безопасно.

Езикът на тези коментари е написан с няколко формата:

  1. Блоковият стил на коментар, при който описанието на коментара е затворено под началния символ / * и завършващия символ * /
  2. Това не трябва да ограничава в един ред, а може да бъде разширено до следващите следващи редове в зависимост от дължината на коментара или описанието, както е показано в следващия пример:

/ * Това е коментар * /

/ * И това е * /

/* И
* това
* като
* добре */

За писане на кратко описание на един ред за коментар, две наклонени символи // в началото стават достатъчни. Това казва на компютъра, че този ред няма нищо общо с действителния код и трябва да бъде игнориран. Например:

// Това е коментар, който компютрите ще игнорират.

Ето пример за справка:

/*
* Program Name: Blink
* Author: Alan Smith
* Description:
* Turns an LED on for one half second, then off for one half second repeatedly.
*/

/* Pin Definitions */
const int kPinLed = 13
/*
* Function Name: setup
* Purpose: Run once when the system powers up.
*/
void setup()
{
pinMode(kPinLed, OUTPUT)
}
/*
* Function name: loop
* Purpose: Runs over and over again, as long as the Arduino has power
*/
void loop()
{
digitalWrite(kPinLed, HIGH)
delay(500)
digitalWrite(kPinLed, LOW)
delay(500)
}

1.8 Отстраняване на неизправности

Ако откриете, че вашата програма показва „грешка“ при компилиране или някакъв друг проблем, следващите съвети вероятно ще ви помогнат да проверите отново кода си, за да се отървете от препятствието.

  1. Езикът на вашата програма ще има предвид малки и големи букви. Например изразът myVar не може да се напише като MyVar.
  2. Всички пропуски, които могат да бъдат изпълнени чрез писане от клавиатурата, в крайна сметка се изобразяват като единично пространство и е видимо или разбираемо само от вас, компютърът няма да вземе това предвид. Казано по-просто, свободните интервали от всякакъв вид няма да окажат никакво влияние върху резултатите от кода.
  3. Всеки блок код трябва да бъде заграден с лява и дясна къдрава скоба, „{“ и '}'
  4. Цифрите на числата не трябва да се разделят със запетаи. Например 1000 може да не се запише като 1000.
  5. Всеки кодов ред, затворен между къдравите скоби, трябва да завършва с точка и запетая

Създаване на интересна LED светлинна последователност с Arduino

В предишната ни глава научихме как да мига непрекъснато ON / OFF LED с постоянна скорост на забавяне.

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

Няма да използваме външен светодиод, а по-скоро ще използваме светодиода по подразбиране, вграден в платката Arduino на щифт # 13. Можете да намерите този малък SMD светодиод точно зад USB конектора.

2.2 Разбиране на изявленията за IF

В този раздел ще научим как контролните структури ни позволяват да изпълняваме отделни кодове и понякога дори повтарящо се, както се изисква.

Изявлението ако става 1-ва контролна структура. Следното изпълнение показва как се използва:

const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
int delayTime = 1000
void loop()
{
delayTime = delayTime - 100
if(delayTime <= 0){ // If the delay time is zero or less, reset it.
delayTime = 1000
}
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
}

Ще се опитаме да разберем горния код поетапно и да научим как това може да се използва за други подобни изпълнения.

Кодовете между 1-ви и 7-ми ред са точно подобни на нашата първоначална програма.

Първата модификация всъщност се случва на 8-ми ред.

int delayTime = 1000

Можете да откриете, че това е подобно на кода на 1-ви ред, като изключва факта, че липсва терминът конст.

Това е просто защото този код не е константа. Вместо това това се определя като a променлива , който има свойството на променлива стойност в хода на програмирането.

В горния пример можете да видите, че тази променлива се приписва на стойност 1000. Не забравяйте, че такива променливи, които са затворени в къдрави скоби, трябва да бъдат строго записани само в двойки къдрави скоби и се наричат ​​„локални“ променливи.

Като алтернатива променливите, за които се предполага, че са извън къдрави скоби, като тази, която обсъждаме сега, се разпознават като „глобални“ и могат да бъдат изпълнени почти навсякъде в рамките на програмен код.

Продължавайки напред, можете да видите, че кодовете между ред 9 и 11 също са подобни на първата програма, но нещата започват да стават интересни след ред 11. Нека видим как!

delayTime = delayTime - 100

В този код виждаме, че стойността по подразбиране на закъснение се модифицира чрез изваждане на 100 от него.

Значение 100 се изважда от първоначалната му стойност 1000, като му предоставя нова стойност 900.

Чрез следващото изображение ще се опитаме да разберем някои от математическите оператори, използвани в езика Arduino.

Символи на Arduino Math Operator

Сега нека оценим кодовете между ред 13 и 15.

if(delayTime <= 0){ // If the delay time is zero or less, reset it.
delayTime = 1000
}

Основната цел на горната част от кода е да гарантира, че светодиодът продължава да мига без никакво прекъсване.

Поради факта, че 100 се приспадат от оригинала закъснение , той предотвратява мигането на LED да достигне нула и позволява мигането да продължи непрекъснато.

Следващото изображение показва няколко оператора за сравнение, които бихме използвали в нашите кодове:

сравнителен оператор за кодове на arduino

В горния ни код бихме могли да тестваме кода като if(delayTime == 0).

Тъй като обаче отрицателната цифра може да бъде еднакво лоша, ние не се съгласихме и това е препоръчителна практика.

Помислете какъв може да е резултатът, ако се бяхме опитали да извадим 300 вместо 100 от delayTime?

Така че сега може би сте разбрали, че ако delayTime се записва като по-малко или равно на нула, тогава времето за забавяне ще бъде върнато на първоначалната цифра 1000.

digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)

Последните 4 реда от кода, както е показано по-горе, стават отговорни за непрекъснатото включване / изключване на светодиода.

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

2.3 ДРУГИ изявления

Тук ще научим защо и как ако терминът може да има клауза друго така че да реши ситуацията в случай ако твърдението е невярно.

Съжалявам, ако това ви звучи твърде объркващо, не се притеснявайте, ще се опитаме да го разберем със следния пример:

const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
int delayTime = 1000
void loop()
{
if(delayTime <= 100){ // If it is less than or equal to 100, reset it
delayTime = 1000
}
else{
delayTime = delayTime - 100
}
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
}

В горното можете добре да видите, че в десетия ред кодът се изпълнява само когато delayTime е по-малко или равно на 100, ако не, тогава се изпълнява кодът в 13-ия ред, но и двете заедно никога не могат да се случат, ще бъдат внедрени или 10-ият или 13-ият ред, никога и двете.

Може би сте забелязали, че за разлика от това, което направихме в предишния ни раздел 2.2, тук не сравнихме с 0, а в сравнение със 100. Това е така, защото в този пример, сравнен ПРЕДИ да извадихме 100, обратно в раздел 2.2, сравнихме СЛЕД изваден. Можете ли да кажете какво би могло да се случи, ако сравнихме 0 вместо 100?

2.4 WHILE изявления

ДА СЕ докато изявление е доста подобно на ако , с изключение на истината, че причинява многократно изпълнение на блок от код (който може да е между къдрави скоби) за толкова дълго време, когато условията са приложими, и това работи без друго изявление.

Следващият пример ще ви помогне да разберете това по-добре

const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
int delayTime = 1000
void loop()
{
while(delayTime > 0){ // while delayTime is greater than 0
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
delayTime = delayTime - 100
}
while(delayTime <1000){ // while delayTime is less than 1000
delayTime = delayTime + 100 // do this first so we don’t have a loop with delayTime = 0
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
}
}

Можете ли да познаете за какво е програмиран горният код? Е, той е проектиран да мига светодиода по-бързо и след това по-бавно.

2.5 Какво е вярно и невярно?

На език за програмиране, невярно се отнася до нула (0). Всъщност „true“ не се използва, вместо това се приема, че когато нищо не е фалшиво, тогава всичко, което е включено, е true.

Изглежда малко странно, но върши работата доста добре.

Ще се опитаме да разберем ситуацията чрез следния пример.

Понякога може да срещнете код, както е даден по-долу:

while (1){
digitalWrite(kPinLed, HIGH)
delay(100)
digitalWrite(kPinLed, LOW)
delay(100)
}

Това е кодирано, изглежда, че светодиодното изпълнение ще продължи да се движи завинаги, докато е налична мощност.

Въпреки това, един недостатък на този тип код може да възникне, когато случайно потребителят приложи a = вместо ==.

Сигурен съм, че вече знаете, че = означава присвояване, което означава, че се използва за обозначаване на избрана стойност на променлива, докато a == се използва за налагане на тест, ако стойността е била същата.

Например, да предположим, че сте изисквали светодиод да мига с последователно ускоряване и повтарящо се, но неправилно е използвал = вместо ==.

След това кодът ще се появи по следния начин:

int delayTime = 1000
void loop()
{
if(delayTime = 0){ // WRONG!!! the = should have been ==
delayTime = 1000
}
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
delayTime = delayTime - 100
}

Грешката ще присвои 0 на delayTime и ще доведе до ако изявление, за да се провери дали 0 е вярно или не. Тъй като 0 се отнася за false, той ще помисли, че не е вярно и ще спре прилагането на delayTime = 1000, но вместо това функцията delayTime се провежда на 0 по време на цикъла ().

Това изглежда много нежелано !!

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

2.6 Комбинации

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

Внедряването на комбинации на логически термини може да се извърши с 3 метода, както е показано в следващата таблица:

таблица, показваща методите за комбиниране на Arduino

Би било интересно да се знае, че операторът NOT може да работи като превключвател за променлива, която може да бъде обозначена като една от двете вярно или невярно (или НИСКО или ВИСОКО).

Следващият пример илюстрира условието:

int ledState = LOW
void loop()
{
ledState = !ledState // toggle value of ledState
digitalWrite(kPinLed, ledState)
delay(1000)
}

Тук ledState ще бъде НИСКО и в последствие, щом ledState = !ledState, ще стане ВИСОКО. Следващият цикъл ще причини ledState да бъде ВИСОКО, когато ledState = !ledState е ниско.

2.7 ЗА изявления

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

Нека разберем това със следния пример:

const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
void loop()
{
for(int i = 0 i <4 i++){
digitalWrite(kPinLed, HIGH)
delay(200)
digitalWrite(kPinLed, LOW)
delay(200)
}
delay(1000) // 1 second
}

Можете да намерите нещо уникално в линията с за.

Това е кодът i ++? . Това е полезно за програмисти, които са доста мързеливи и искат да внедрят кодиране чрез удобни преки пътища

Горният термин е известен като съставни оператори, тъй като те вършат работата по комбиниране на един оператор за присвояване с друг оператор за присвояване. Най-популярните от тях могат да бъдат визуализирани в следната таблица:

arduino съставни оператори

Ще откриете, че има 3 под-изявления в изявление за. Той е структуриран, както е показано по-долу:

for (statement1conditionstatement2){
// statements
}

Изявлението # 1 се появява в началото и само веднъж. Състоянието се тества всеки път по време на цикъла. Когато и да е вярно вътре в къдравите скоби, следващият оператор №2 се налага. В случай на a невярно, системата преминава към следващия блок код.

Свързване на още светодиоди

Добре, сега ще видим как можем да свържем по-голям брой светодиоди за получаване на по-интересни ефекти.

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

Arduino множество LED връзки

Сега нека поправим програма, която ще ни позволи да проверим дали нашият хардуер е правилно конфигуриран или не.

Винаги се препоръчва да се кодират и изпълняват малки битове програми, за да се провери дали съответният хардуер е свързан правилно или не.

Това помага бързо да се отстранят възможни грешки.

Примерът на кода по-долу предоставя LED 2 до 5 специфичен модел, като ги завърта един след друг по цикличен начин.

const int kPinLed1 = 2
const int kPinLed2 = 3
const int kPinLed3 = 4
const int kPinLed4 = 5
void setup()
{
pinMode(kPinLed1, OUTPUT)
pinMode(kPinLed2, OUTPUT)
pinMode(kPinLed3, OUTPUT)
pinMode(kPinLed4, OUTPUT)
}
void loop()
{
// turn on each of the LEDs in order
digitalWrite(kPinLed1, HIGH)
delay(100)
digitalWrite(kPinLed2, HIGH)
delay(100)
digitalWrite(kPinLed3, HIGH)
delay(100)
digitalWrite(kPinLed4, HIGH)
delay(100)
// turn off each of the LEDs in order
digitalWrite(kPinLed1, LOW)
delay(100)
digitalWrite(kPinLed2, LOW)
delay(100)
digitalWrite(kPinLed3, LOW)
delay(100)
digitalWrite(kPinLed4, LOW)
}

Както може да забележите, няма нищо лошо в кода, освен факта, че той изглежда дълъг и следователно склонен към грешки.

Разбира се, има по-добри начини да напишете горния код, следващият раздел ще го разкрие.

2.9 Представяне на масиви

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

const int k_numLEDs = 4
const int kPinLeds[k_numLEDs] = {2,3,4,5} // LEDs connected to pins 2-5
void setup()
{
for(int i = 0 i pinMode(kPinLeds[i], OUTPUT)
}
}
void loop()
{
for(int i = 0 i digitalWrite(kPinLeds[i], HIGH)
delay(100)
}
for(int i = k_numLEDs - 1 i >= 0 i--){
digitalWrite(kPinLeds[i], LOW)
delay(100)
}
}

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

const int k_numLEDs = 4

Горният код определя колко максимални елемента трябва да имаме в масива. Този код ни помага в следващите раздели да гарантираме, че всичко е записано в масив и нищо, след като масивът завърши.

const int kPinLeds[k_numLEDs] = {2,3,4,5} // LEDs connected to pins 2-5

В този следващ ред настройваме структурата на масива. Числата в скобата показват броя на елементите в масива. Въпреки че действителното количество можеше да бъде написано, писането като константи работи по-добре. Стойностите обикновено могат да се видят в скобата със запетаи и да обозначат стойностите в масива.

Когато намерите масив, индексиран с числото 0, това показва първия елемент в масива, както е показано в code: k_LEDPins is k_LEDPins[0]

По същия начин последният елемент ще бъде показан като k_LEDPins[3], тъй като броят от 0 до 3 е 4.

void setup()
{
for(int i = 0 i pinMode(kPinLeds[i], OUTPUT)
}
}

Горният код показва използването на цикъл за преминаване през всеки елемент на масив и за задаването им като ИЗХОДИ. Внедряваме квадратни скоби заедно с индекса, за да достигнем до всеки от елементите в масива.

ако се чудите дали е възможно да използвате пин # 2 за пин # 5 без масиви, отговорът е да, възможно е. Но в този пример това не е направено, защото не го направихме по този начин. В следващите раздели можете да премахнете подхода на масива, ако избраните изходни щифтове не са на линия.

Продължавайки напред, нека видим какво прави следващият блок код:

for(int i = 0 i digitalWrite(kPinLeds[i], HIGH)
delay(100)
}

Тук кодът преминава през всеки от светодиодите, за да ги включва последователно с интервал или закъснение от 100 милисекунди.

for(int i = k_numLEDs - 1 i >= 0 i--){
digitalWrite(kPinLeds[i], LOW)
delay(100)
}

Използването на горния код показва как приложението на за цикъл може да се използва за придвижване през цикъла дори в обратен ред.

Започва от k_numLEDs - 1, защото масивите са нулево индексирани. Не започваме от k_LEDPins[4] защото това би довело до пресичане на финала на масива.

Кодът използва> = 0 за проверка, така че първият елемент с индекс 0 да не бъде пропуснат или пренебрегнат.

Глава 3

Какво е вход

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

3.1 Използване на бутони

Всички знаем какво е бутон и как работи. Това е вид превключвател или бутон, който свързва за миг сигнал от една степен на верига, докато е в депресирано състояние, и прекъсва сигнала, когато се освободи.

3.1.1 Един бутон и светодиод

бутон за интерфейс с Arduino

Ще свържем Arduino с бутон с Arduino съгласно показаните по-горе подробности и ще научим основните работи и изпълнение на настройката.

Посоченият бутон, който се нарича още бутон за микро превключване, има общо 4 щифта (2 чифта от всяка страна). При натискане всяка двойка щифтове се съединяват вътрешно и позволяват връзка или проводимост през тях.

В този пример използваме само една двойка от тези щифтове или контакти, другата двойка е без значение и поради това се игнорира.

Нека продължим, прилагаме следния код и проверете дали работи!

const int kPinButton1 = 2
const int kPinLed = 9
void setup()
{
pinMode(kPinButton1, INPUT)
digitalWrite(kPinButton1, HIGH) // turn on pull-up resistor
pinMode(kPinLed, OUTPUT)
}
void loop()
{
if(digitalRead(kPinButton1) == LOW){
digitalWrite(kPinLed, HIGH)
}
else{
digitalWrite(kPinLed, LOW)
}
}

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

void setup()
{
pinMode(kPinButton1, INPUT)
digitalWrite(kPinButton1, HIGH) // turn on pull-up resistor
pinMode(kPinLed, OUTPUT)
}

Първото нещо, което правим, е да поправим buttonPin като ВХОД. Е, това е съвсем основно, знам.

След това задаваме ВИСОКО към ВХОД щифт. Чудите се, как е възможно да напишете нещо на входа? Разбира се, това може да е интересно.

Всъщност присвояването на HIGH на вход Arduino превключва вътрешен 20k Ohm издърпващ резистор ON (LOW на този щифт го изключва).

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

Добре, продължавайки, сега нека разгледаме основния код на цикъла:

void loop()
{
if(digitalRead(kPinButton1) == LOW){
digitalWrite(kPinLed, HIGH)
}
else{
digitalWrite(kPinLed, LOW)
}
}

Когато натиснете бутона, жичният щифт се свързва със земята, което прави a НИСКО към този щифт. И докато в непресовано състояние се държи същият щифт ВИСОКО или + 5V чрез 20K вътрешен издърпващ резистор.

Тук искаме Arduino да свети светодиода при натискане на бутона (LOW), затова пишем HIGH за изхода за всеки отговор на LOW от бутона, докато е натиснат.

3.1.2 Два бутона и светодиод

Е, може би се чудите, че показаното по-горе действие би могло да се направи и без Arduino. Разбирам обаче това стръмно камъче, за да науча как бутонът може да се използва с Arduno.

До този момент проучихме писането на кодове или за включване (HIGH) или за изключване (LOW) на светодиод.

Сега нека видим как яркостта на LED може да се контролира с Arduino.

Може да се направи по два метода:

  1. Чрез ограничаване на количеството ток до светодиода
  2. Като се използва ШИМ или широчинно-импулсна модулация, при която захранването към светодиода се включва / изключва с някаква желана скорост много бързо, произвеждайки средно осветление, чийто интензитет ще зависи от ШИМ.

В Arduino платка се предлага поддръжка на ШИМ на щифтове, маркирани с тилда (~), които са щифтове 3, 4,5,9,10 и 11) при 500Hz (500 пъти в секунда). Потребителят може да предостави всякаква стойност между 0 и 255, където 0 се отнася до HIGH или no + 5V, а 255 казва на Arduino да получава HIGH или + 5V през цялото време. За иницииране на тези команди ще трябва да осъществите достъп до analogWrite () с желаната стойност.

Може да приемете, че ШИМ е x / 255, където x е желаната стойност, която искате да изпратите чрез analogWrite().

ШИМ контрол на Arduino

Настройте Arduino и други параметри, както е показано по-горе.

const int kPinButton1 = 2
const int kPinButton2 = 3
const int kPinLed = 9
void setup()
{
pinMode(kPinButton1, INPUT)
pinMode(kPinButton2, INPUT)
pinMode(kPinLed, OUTPUT)
digitalWrite(kPinButton1, HIGH) // turn on pullup resistor
digitalWrite(kPinButton2, HIGH) // turn on pullup resistor
}
int ledBrightness = 128
void loop()
{
if(digitalRead(kPinButton1) == LOW){
ledBrightness--
}
else if(digitalRead(kPinButton2) == LOW){
ledBrightness++
}
ledBrightness = constrain(ledBrightness, 0, 255)
analogWrite(kPinLed, ledBrightness)
delay(20)
}

Тук може да намерите 3 реда, които се нуждаят от обяснение.

ledBrightness = constrain(ledBrightness, 0, 255)
25 analogWrite(kPinLed, ledBrightness)
26 delay(20)

Редът: ledBrightness = constrain(ledBrightness, 0, 255) илюстрира уникална функция в Arduino, известна като constrain ().

Тази вътрешна функция включва код, подобен на следното:

int ограничение (int стойност, int min, int max)
{
if(value > max){
value = max
}
if(value value = min
}
return value
}

Всички кодове, обсъдени преди това, започнаха с нищожен , което означаваше да не се връща нищо (void). Докато горният код започва с инт , което показва, че връща цяло число. Ще обсъдим повече за това в следващите раздели, в момента просто помнете, че едно цяло число няма дробни части.

Добре, това предполага, че кодът: ledBrightness = constrain(ledBrightness, 0, 255) присвоява ledBrightness to be within the range of 0 and 255.

Следващият ред използва analogWrite да командва Arduino да прилага ШИМ върху избрания пин с желаната стойност.

Следващият ред създава закъснение от 20 милисекунди, това е, за да се гарантира, че не коригираме яденето по-бързо от 50 Hz или 50 пъти в секунда. Това е така, защото хората могат да бъдат много по-бавни от Arduino. Следователно, ако забавянето не бъде направено, програмата може да ни накара да почувстваме, че натискането на първия бутон изключва светодиода и натискането на втория бутон го включва (опитайте сами, за да потвърдите).

3.2 Потенциометри

Нека да продължим напред и да се научим как да използваме потенциометри с Arduino.

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

Използване на потенциометър с Arduino

Свържете показаните параметри с вашия Arduino, както е показано по-горе.

Потът ще има 3 терминала. Средният терминал ще се свърже с ANALOG IN 0 на Arduino. Останалите два външни терминала могат да бъдат свързани към + 5V и 0V захранващи релси.

Нека програмираме и проверим резултатите:

const int kPinPot = A0
const int kPinLed = 9
void setup()
{
pinMode(kPinPot, INPUT)
pinMode(kPinLed, OUTPUT)
}
void loop()
{
int ledBrightness
int sensorValue = 0
sensorValue = analogRead(kPinPot)
ledBrightness = map(sensorValue, 0, 1023, 0, 255)
analogWrite(kPinLed, ledBrightness)
}

Ще откриете няколко неща, които може да изглеждат изцяло нови и да не са включени в нито един от нашите по-ранни кодове.

  1. Константата kPinPot е зададен като A0, където A е пряк път за описване на един от аналоговите щифтове. A0 обаче се отнася и за пин # 14, А1 до пин # 15 и т.н., и те ви позволяват да бъдете използвани като цифрови входове / изходи, в случай че свършите пиновете за експеримент. Но не забравяйте, че не можете да използвате цифрови щифтове като аналогови щифтове.
  2. Редът: ledBrightness = map(sensorValue, 0, 1023, 0, 255) представя нова вътрешна функция в Arduino, известна като карта (). Тази функция прекалибрира от даден диапазон в друг, наречен като map (стойност, отLow, отHigh, toLow, toHigh). Това може да стане от решаващо значение, тъй като analogueRead издава стойност в диапазона от 0-1023, но analogWrite може да приеме стойност от 0-255.

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

Няма проблеми, сега ще направим нещо, което не може да се направи без Arduino.

В този експеримент ще видим как различното съпротивление на пота може да се използва за контролиране на скоростта на мигане или скоростта на светодиода.

Ето програмата:

const int kPinPot = A0
const int kPinLed = 9
void setup()
{
pinMode(kPinLed, OUTPUT)
}
void loop()
{
int sensorValue
sensorValue = analogRead(kPinPot)
digitalWrite(kPinLed, HIGH)
delay(sensorValue)
digitalWrite(kPinLed, LOW)
delay(sensorValue)
}

3.2.3 Избягване на забавяне ()

Горният код изглежда добре, но светодиодът не може да провери стойността на пота, докато премине през всеки пълен цикъл. За по-дълги закъснения този процес се удължава, потребителят трябва да изчака, за да види отговора на пота, докато го мести. Това забавяне може да бъде избегнато с някои интелигентни програми, така че да позволява на потребителя да провери стойността без минимални закъснения. Ето кода.

const int kPinPot = A0
const int kPinLed = 9
void setup()
{
pinMode(kPinLed, OUTPUT)
}
long lastTime = 0
int ledValue = LOW
void loop()
{
int sensorValue
sensorValue = analogRead(kPinPot)
if(millis() > lastTime + sensorValue){
if(ledValue == LOW){
ledValue = HIGH
}
else{
ledValue = LOW
}
lastTime = millis()
digitalWrite(kPinLed, ledValue)
}
}

И така, какво е различното в горния код? Следващият ред прави разликата.

long lastTime = 0

До този раздел сме обсъждали променливата int. Възможно е обаче да има много други променливи на типа, до които имате достъп. Списъкът може да се прочете по-долу:

Видове променливи на Arduino

Понастоящем може да е изключително важно да се знае, че за съхранение на относително големи номера за инт променлива, можете да използвате термина дълго или а дълъг инт.

Тук можете да видите друга интересна функция, наречена милис ().

Това създава времевия интервал в милисекунди, през който Arduino е работил в хода си от самото начало (това ще се нулира на 0 след всеки 50 дни). Тук се връща дълго, защото ако се върне инт , броенето за дълги периоди може да не е възможно. Бихте ли отговорили колко точно? Отговорът е 32.767 секунди.

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

3.3 RGB светодиоди

Досега сме играли с едноцветен светодиод. Въпреки че цветът на LED може да бъде променен чрез замяна на LED с друг цвят, но какво ще кажете за използване на RGB светодиоди за смяна на LED цветове без смяна на светодиодите?

RGB светодиодът е основно светодиод с червен, зелен и син светодиод, вграден и обединен в един светодиод. Той има един общ проводник, който отива към земята или 0V захранваща шина, докато останалите 3 проводника се захранват с разнообразни PWM положителни сигнали за изпълнение на предвиденото смесване на цветовете .

Можете да свържете настройката, както е показано по-долу:

Контролирайте RGB с Arduino

Може да изглежда малко сложно, но всъщност е копие на нашия по-ранен дизайн на LED управление, използващ ШИМ.

Ето код за практическа програма:

const int kPinPot1 = A0
const int kPinPot2 = A1
const int kPinPot3 = A2
const int kPinLed_R = 6
const int kPinLed_G = 10
const int kPinLed_B = 11
void setup()
{
pinMode(kPinLed_R, OUTPUT)
pinMode(kPinLed_G, OUTPUT)
pinMode(kPinLed_B, OUTPUT)
}
void loop()
{
int potValue
int ledValue
potValue = analogRead(kPinPot1)
ledValue = map(potValue, 0, 1023, 0, 255)
analogWrite(kPinLed_R, ledValue)
potValue = analogRead(kPinPot2)
ledValue = map(potValue, 0, 1023, 0, 255)
analogWrite(kPinLed_G, ledValue)
potValue = analogRead(kPinPot3)
ledValue = map(potValue, 0, 1023, 0, 255)
analogWrite(kPinLed_B, ledValue)
}

След като качите този код, просто вижте как корекциите на пота създават интересен светлинен ефект върху RGB, може да бъде истинско забавление.

Ще откриете, че когато всичките 3 саксии бъдат преместени в максимални позиции, вместо бял цвят ще видите червен. Това е така, защото червеният цвят е най-забележим сред трите цвята и следователно доминира в тази ситуация. Можете обаче да експериментирате с функцията карта () , преди да го изпълните към червената част на светодиода, за да създадете по-разумен баланс.

Аудио с Arduino

В този раздел ще научим как да добавите основен звук и музика към настройка на Arduino.

Ще видим как да превключим сигнал към свързан високоговорител с желана честота.

За да бъдем по-точни, ще се опита средна нота, която е честота от 440 Hz.

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

Също така ще изчислим времето, през което високоговорителят може да остане включен, като съдим формулата:

timeDelay = 1 секунда / 2 x тон Честота.

timeDelay = 1 секунда / 2 x 440

timeDelay = 1136 микросекунди

4.1 Нека закачим дъската Arduino

Използване на звуков ефект в Arduino

4.2 Добавяне на проста бележка

Вече обсъдихме функцията забавяне () където единицата е в милисекунди (секунда / 1000), но ще намерите още една функция delayMicroseconds() където единицата е в микросекунди, (милисекунда / 1000).

За настоящата настройка програмираме код за превключване на + 5V ВКЛ. / ИЗКЛ. На избрания щифт, свързан с високоговорителя, със скорост от 440 импулса в секунда.

Спомнете си, при последното обсъждане определихме стойността 1136 микросекунди за предвидената аудио нота.

И така, ето програмата за това, която ще ви позволи да чуете звукова нота от 440 Hz веднага щом програмирате arduino със свързан високоговорител.

const int kPinSpeaker = 9
const int k_timeDelay = 1136
void setup()
{
pinMode(kPinSpeaker, OUTPUT)
}
void loop()
{
digitalWrite(kPinSpeaker, HIGH)
delayMicroseconds(k_timeDelay)
digitalWrite(kPinSpeaker, LOW)
delayMicroseconds(k_timeDelay)
}

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

От кода разбираме, че Arduino включва няколко интегрирани функции, които допълнително допринасят за създаването на музика.

Първият е тон () който работи с 2 елемента заедно с 3-ти незадължителен елемент, обозначен като тон (пин, честота, продължителност). или тон (пин, честота)

И двете са определени да изпълняват съответния период от време, определен от вас.

При липса на период от време музиката ще продължи да свири до обаждането тон () се изпълнява отново или докато не изпълните notone ().

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

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

Следващата функция noTone () обработва отделен параметър и спира избрания тон на определен зададен щифт.

Особено предупреждение: По всяко време, когато тон () функцията е внедрена, PWM функцията на щифтове 3 и 11 ще спре да работи.

Следователно, когато в програмата се използва приставка за високоговорител, уверете се, че не използвате споменатия щифт за високоговорителите, вместо това опитайте някои други щифтове за прикачване на високоговорителите.

Добре, така че тук е програма за внедряване на музика на високоговорител, макар че тя не е истинска музика, а по-скоро бележка от мащаб C.

#define NOTE_C4 262
#define NOTE_D4 294
#define NOTE_E4 330
#define NOTE_F4 349
#define NOTE_G4 392
#define NOTE_A4 440
#define NOTE_B4 494
#define NOTE_C5 523
const int kPinSpeaker = 9
void setup()
{
pinMode(kPinSpeaker, OUTPUT)
}
void loop()
{
tone(kPinSpeaker, NOTE_C4, 500)
delay(500)
tone(kPinSpeaker, NOTE_D4, 500)
delay(500)
tone(kPinSpeaker, NOTE_E4, 500)
delay(500)
tone(kPinSpeaker, NOTE_F4, 500)
delay(500)
tone(kPinSpeaker, NOTE_G4, 500)
delay(500)
tone(kPinSpeaker, NOTE_A4, 500)
delay(500)
tone(kPinSpeaker, NOTE_B4, 500)
delay(500)
tone(kPinSpeaker, NOTE_C5, 500)
delay(500)
noTone(kPinSpeaker)
delay(2000)
}

В горния код може да сте забелязали нещо ново и това #define .

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

Всеки път, когато намери първото нещо преди интервал, той го замества с останалата част от реда (наречена макроси).

Така че в този пример, когато компютърът вижда NOTE_E4 бързо го замества с количеството 330.

За повече бележки и персонализация можете да се обърнете към файл във вашия USB стик с име терени.ч , където повечето от честотите могат да бъдат намерени според вашите предпочитания.

4.4 Музика с функции

Кодът по-горе изглежда добре, но изглежда има много повторения, трябва да има някакъв метод за съкращаване на тези повторения, нали?

Досега сме работили с две основни функции, включени в Arduino. Сега е време да създадем свои собствени функции.

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

Следователно, конкретното име на функция получава отворена скоба '(' последвано от списък с параметри, разделени със запетая.

Всеки от параметрите придобива своя тип заедно с име и накрая затваряне ')' скоби.

Тези параметри могат да бъдат приложени в рамките на функцията под формата на променливи.

Нека да видим пример по-долу, където разработваме функция, наречена ourTone () предназначени за обединяване на тон () с забавяне () линии, по начин, че функцията спира да се връща, докато бележката завърши с възпроизвеждането на тона.

Ние прилагаме тези функции в предишния ни код и получаваме програмата по-долу, вижте последните редове:

#define NOTE_C4 262
#define NOTE_D4 294
#define NOTE_E4 330
#define NOTE_F4 349
#define NOTE_G4 392
#define NOTE_A4 440
#define NOTE_B4 494
#define NOTE_C5 523
const int kPinSpeaker = 9
void setup()
{
pinMode(kPinSpeaker, OUTPUT)
}
void loop()
{
tone(kPinSpeaker, NOTE_C4, 500)
delay(500)
tone(kPinSpeaker, NOTE_D4, 500)
delay(500)
tone(kPinSpeaker, NOTE_E4, 500)
delay(500)
tone(kPinSpeaker, NOTE_F4, 500)
delay(500)
tone(kPinSpeaker, NOTE_G4, 500)
delay(500)
tone(kPinSpeaker, NOTE_A4, 500)
delay(500)
tone(kPinSpeaker, NOTE_B4, 500)
delay(500)
tone(kPinSpeaker, NOTE_C5, 500)
delay(500)
noTone(kPinSpeaker)
delay(2000)
}
void ourTone(int freq, int duration)
{
tone(kPinSpeaker, freq, duration)
delay(duration)
}

Функциите могат да бъдат изключително удобни, за да улеснят разбирането на програмата.

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

#include 'pitches.h'
int kPinSpeaker = 9
#define NUM_NOTES 15
const int notes[NUM_NOTES] = // a 0 represents a rest
{
NOTE_C4, NOTE_C4, NOTE_G4, NOTE_G4,
NOTE_A4, NOTE_A4, NOTE_G4, NOTE_F4,
NOTE_F4, NOTE_E4, NOTE_E4, NOTE_D4,
NOTE_D4, NOTE_C4, 0
}
const int beats[NUM_NOTES] = {
1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 2, 4 }
const int beat_length = 300
void setup()
{
pinMode(kPinSpeaker, OUTPUT)
}
void loop()
{
for (int i = 0 i if (notes[i] == 0) {
delay(beats[i] * beat_length) // rest
}
else {
ourTone(notes[i], beats[i] * beat_length)
}
// pause between notes
noTone(kPinSpeaker)
delay(beat_length / 2)
}
}
void ourTone(int freq, int duration)
{
tone(kPinSpeaker, freq, duration)
delay(duration)
}

Можете ясно да видите на първия ред въвеждането на #include изявление. Работата на това изявление е да вземе целия файл между кавичките и да го постави в позицията на #include изявление. Според стандартните правила те са строго поставени в началото на програмата.

Глава 5

Измерване на температурата

Само за да си припомним, не забравяйте, вместо да пишете големи програми, винаги е разумно да пишете и анализирате малки части от кодове, което помага за бързо проследяване на грешките.

5.1 Сериен монитор

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

Arduino има функция, която му позволява да „отговори обратно“ с компютъра. Може да забележите, че pin0 и pin1 са маркирани като RX an TX един до друг. Тези щифтове всъщност се проследяват от отделна интегрална схема в Arduino, която ги надгражда, за да четат през USB кабела, докато е включен към компютъра.

Разделът по-долу показва пълноценна програма, моля, продължете, ще научим за новите записи в кода след това. Този код е същият като изразения раздел 2.2, с изключение на факта, че включва някои допълнителни данни, които ни позволяват да идентифицираме за какво е кодиран.

const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
Serial.begin(9600)
}
int delayTime = 1000
void loop()
{
delayTime = delayTime - 100
if(delayTime <= 0){ // If it would have been zero or less, reset it.
delayTime = 1000
}
Serial.print('delayTime = ')
Serial.println(delayTime)
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
}

Тук можете да идентифицирате две нови неща, нов ред в настройвам() функция.

Serial.begin(9600)

Този ред просто изразява необходимостта от използване на Сериен1 код, за да го приложите с 9600 бода. (тук сериалът се отнася до бита изпратени един след друг, а бод означава скоростта, с която е изпратена). Тази стойност на бода и тази в серийния монитор (ще научим това по-късно) трябва да са равни, иначе данните в серийния монитор ще показват боклук. Като стандарт 9600 става по-удобно за използване.

Вторият нов запис е както следва

Serial.print('delayTime = ')
Serial.println(delayTime)

Тук вторият ред предполага, че следващото нещо, което излиза от серийния порт, ще започне на следващия ред. По този начин вторият ред се различава от първия ред.

Още нещо, което можете да видите, са кавички ('). Това е известно като низ, който тук ще се използва само като константи, защото по-нататъшната дискусия по тази тема може да бъде твърде сложна и извън обхвата.

Добре, вече можем да качим горния код в Arduino и да видим какво ще се случи.

Какво, уф, изглежда, че нищо не се е случило, светодиодът Arduino № 13 мига и спира, докато светодиодът Tx продължава да мига.

Е, това е, защото прозорецът на Serial Monitor все още не е фиксиран.

Трябва да щракнете върху полето Serial Monitor във вашата IDE, както е показано по-горе. Не забравяйте да проверите скоростта на предаване в долния десен ъгъл, по подразбиране тя трябва да бъде 9600 и ще съответства на кода. Ако не е задължително да изберете 9600.

Следващият видеоклип обяснява как се прави.

https://youtu.be/ENg8CUyXm10

Сега нека продължим напред и да научим как горната функция на Serial Monitor може да помогне за обработката на измерване на температурата с помощта на Arduino

Ще използваме IC TMP36 като температурен сензор с обхват от -40 до 150 градуса по Целзий.

Настройката може да се види по-долу:

TMP36 с Arduino за измерване на температурата

Следващият код ще започне измерването на температурата, като отчете изхода от сензора TMP36 и ги изпрати на серийния монитор на идентификатора.

const int kPinTemp = A0
void setup()
{
Serial.begin(9600)
}
void loop()
{
float temperatureC = getTemperatureC()
Serial.print(temperatureC)
Serial.println(' degrees C')
// now convert to Fahrenheit
float temperatureF = convertToF(temperatureC)
Serial.print(temperatureF)
Serial.println(' degrees F')
delay(500)
}
float getTemperatureC()
{
int reading = analogRead(kPinTemp)
float voltage = (reading * 5.0) / 1024
// convert from 10 mv per degree with 500mV offset
// to degrees ((voltage - 500mV) * 100)
return (voltage - 0.5) * 100
}
float convertToF(float temperatureC)
{
return (temperatureC * 9.0 / 5.0) + 32.0
}

Нека разберем кода отгоре.

float temperatureC = getTemperatureC()

Тук можете да видите, че сме включили типа променлива плувка.

Това е единственият тип променлива, който разполага със съхраняване на всичко с изключение на цели числа (числа без десетични или дробни части).

Точността от плаваща променлива може да бъде до 6 до 7 цифри.

Прилежащият код getTemperatureC() е нашата собствена функция, която математически изчислява и преобразува усетената разлика в напрежението от сензора TMP36 в градуси по Целзий.

float getTemperatureC()
{
int reading = analogRead(kPinTemp)
float voltage = (reading * 5.0) / 1024
// convert from 10 mv per degree with 500mV offset
// to degrees ((voltage - 500mV) * 100)
return (voltage - 0.5) * 100
}

В следващия раздел на кодовете, тъй като терминът analogIn() е възложено да върне цифра между 1 и 1023, става възможно да оценим напрежението от сензора, като умножим показанията си по 5 и след това го разделим с 1024.

Сензорът TMP36 е определен за генериране на 0.5V при 0 градуса по Целзий и впоследствие генерира 10mV за всяко едно повишаване на градуса по Целзий.

Ето приближението, което можем да генерираме чрез изчисленията:

Калибриране на температурата на Arduino

Можете да считате за първата си функция, която връща някаква стойност (имайте предвид, че всички останали функции досега не са връщали никаква стойност, тъй като са от типа нищожен ).

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

Когато казваме връщане това означава, че функцията връща отговор или отговор, когато е извикан, който може да бъде приложен към променлива.

Когато това се изпрати до серийния монитор, показанията се преобразуват във Фаренхайт convertToF ().

float convertToF(float temperatureC)
{
return (temperatureC * 9.0 / 5.0) + 32.0
}

Тази функция улавя диапазона на Целзий и го преобразува във Фаренхайт.

За преобразуване на Фаренхайт в Целзий ние прилагаме формулата Фаренхайт = 9 / 5 (по Целзий) + 32.

5.3 Връзка с LCD

Сега нека изучим как да свързваме или свързваме ЛСД дисплей с Arduino за получаване на визуален дисплей за необходимите изходи.

В нашето приложение ще използваме графичен LCD с размери 84x48, имащ 84 пиксела или точки хоризонтално и 48 пиксела вертикална разделителна способност. Тъй като специалният контролер става задължителен за всички LCD дисплеи, настоящото устройство включва и такъв под формата на контролер PCD8544.

В този урок ще свържем посочения по-горе LCD модул с Arduino и ще приложим определени рутини за създаване на текстови съобщения на дисплея.

На следващата фигура можете да намерите подробности относно свързването на LCD, заедно с малка 3.3V регулатор на напрежение . Този регулатор е необходим, тъй като LCD е определен за работа с захранване от 3.3V.

Можете също да видите 8 пинота от LCD модула, спецификациите на пиновете могат да бъдат проучени от следната таблица:

Детайли за изписване на LCD

Сега нека видим как можем да свържем LCD и съответните параметри с нашия Arduino. Подробностите могат да бъдат визуализирани на показаната по-долу илюстрация:

Основно обучение за Arduino

5.4 Комуникация с LCD

Въпреки че е възможно да се напишат сложни coeds за взаимодействие с LCD от Arduino, по-скоро ще се научим как да правим същото с помощта на библиотеки.

Библиотеките включват асортимент от кодове, които могат бързо да бъдат приложени за избрана програма Arduino.

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

5.4.1 Как да инсталирате библиотеката

За това ще трябва да създадете директория, наречена библиотеки в компютъра ви Arduino IDE, както е обяснено тук

5.4.2 Прилагане на LCD операциите

Подобно на предишния ни подход, първо ще проверим целия код и след това ще се опитаме да разберем подробностите за отделните редове.

#include
const int kPin_CLK = 5
const int kPin_DIN = 6
const int kPin_DC = 7
const int kPin_RESET = 8
PCD8544 lcd(kPin_CLK, kPin_DIN, kPin_DC, kPin_RESET)
void setup()
{
lcd.init()
lcd.setCursor(0,0)
lcd.print('Hello, World!')
}
void loop()
{
lcd.setCursor(0,1)
lcd.print(millis())
}

Редът включва кода #include

Кодът #include инструктира компютъра да вземе споменатия файл и да замени елемента #include със съдържанието на файла по време на компилирането на програмата.

Елементът #include може да има ъглови скоби, което показва търсене в директория на библиотеката, алтернативно може да притежава и кавички, което показва търсене в същата директория, в която се намира програмата.

Следващите редове на кода изразяват LCD разпечатките и след това пишем нова форма на променлива:

PCD8544 lcd(kPin_CLK, kPin_DIN, kPin_DC, kPin_RESET)

Тук ние изразяваме променлива с името lcd от типа PCD8544 и инструктираме компютъра да реградира своите пиноти, свързани с Arduino.

В този процес ние описваме променливата към компютъра, като инструктираме как пин clk, din, dc и reset са свързани с Arduino.

void setup()
{
lcd.init()
lcd.setCursor(0,0)
lcd.print('Hello, World!')
}

Линията lcd.init() инициализира работата на LCD. След като това се изпълни, следващият ред налага курсор в горния ляв ъгъл на дисплея. И следващият следващ ред прави усилия да отпечата съобщението „Здравей, Свят“.

Това изглежда съвсем идентично с техниката, при която изпращаме съобщения през серийния монитор. Единствената разлика е използването на кода lcd.print вместо serial.print.

Следващият блок код всъщност се извиква повтарящо се.

void loop()
{
lcd.setCursor(0,1)
lcd.print(millis())
}

Използвайки този ред lcd.setCursor(0,1) фиксираме курсора към 0-тата колона най-вляво от 1-ви ред, над LCD дисплея.

Следващият ред използва пряк път: lcd.print(millis())

Ако си спомняте, работихме с millis() в нашите по-ранни кодове, бихме могли да приложим същото и тук чрез кодовете:

long numMillis = millis()
lcd.print(numMillis)

Поради факта, че тук не са включени периоди от милисекунда, следователно го постигаме, като просто изпращаме millis() функция директно към lcd.print() .

5.5 Комбиниране на цялото нещо

Добре, сега нека комбинираме всички кодове, които научихме по-горе за създаване на LCD температурна верига, и нека видим как изглежда:

#include
const int kPin_CLK = 5
const int kPin_DIN = 6
const int kPin_DC = 7
const int kPin_RESET = 8
const int kPin_Temp = A0
PCD8544 lcd(kPin_CLK, kPin_DIN, kPin_DC, kPin_RESET)
void setup()
{
lcd.init()
lcd.setCursor(10,0)
lcd.print('Temperature:')
}
void loop()
{
float temperatureC = getTemperatureC()
// now convert to Fahrenheit
float temperatureF = convertToF(temperatureC)
lcd.setCursor(21,1)
lcd.print(temperatureC)
lcd.print(' C')
lcd.setCursor(21,2)
lcd.print(temperatureF)
lcd.print(' F')
delay(100)
}
float getTemperatureC()
{
int reading = analogRead(kPin_Temp)
float voltage = (reading * 5.0) / 1024
// convert from 10 mv per degree with 500mV offset
// to degrees ((voltage - 500mV) * 100)
return (voltage - 0.5) * 100
}
float convertToF(float temperatureC)
{
return (temperatureC * 9.0 / 5.0) + 32.0
}

Всичко изглежда стандартно в горната програма, с изключение на използването на функцията setCursor () . Това се използва за подравняване на текста, доколкото е възможно, около центъра на дисплея.

Страхотен! И поздравления, току-що сте програмирали своя собствен LCD индикатор за температура, използвайки Arduino.

Практически приложения на Arduino

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

Ще започнем със сензори и ще видим как сензорните устройства могат да се използват с Arduino, като изпълним няколко примерни кода.

7.1 Въведение в сензорите

В този урок ще научим относно голямото разнообразие от сензори, които могат да се използват с Arduino. Те могат да включват устройства като LDR сензор за светлина, магнитен сензор за ефект на Хол, сензори за наклон, сензор за вибрации, сензор за налягане и т.н.

Ще започнем с взаимодействието на светлинен сензор LDR с Arduino, както е показано на следната диаграма:

използвайте LDR с Arduino

Както всички знаем, LDR е светлозависимо резисторно устройство, чието съпротивление зависи от интензивността на околната среда, падаща върху повърхността му.

Интензитетът на светлината е обратно пропорционален на отчитането на съпротивлението на LDR.

Тук ще научим как това свойство може да бъде интегрирано с Arduino за изпълнение на полезно приложение:

Пълният код на програмата може да бъде визуализиран, както е дадено по-долу:

const int kPin_Photocell = A0
void setup()
{
Serial.begin(9600)
}
void loop()
{
int value = analogRead(kPin_Photocell)
Serial.print('Analog Reading = ')
Serial.print(value)
if(value <200){
Serial.println(' - Dark')
}else if(value <400){
Serial.println(' - Dim')
}
else if(value <600){
Serial.println(' - Light')
}
else if(value <800){
Serial.println(' - Bright')
}
else{
Serial.println(' - Very Bright')
}
delay(1000)
}

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

Стойностите са избрани произволно, можете лесно да промените според вашите предпочитания.

Сензор за наклон

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

Сега да видим как a сензор за наклон устройството може да бъде свързано. Изображението по-долу ни дава представа относно пълната конфигурация:

интегриращ сензор за наклон с Arduino

const int kPin_Tilt = 3
const int kPin_LED = 13
void setup()
{
pinMode(kPin_Tilt, INPUT)
digitalWrite(kPin_Tilt, HIGH) // turn on built-in pull-up resistor
pinMode(kPin_LED, OUTPUT)
}
void loop()
{
if(digitalRead(kPin_Tilt) == HIGH){
digitalWrite(kPin_LED, LOW)
}
else{
digitalWrite(kPin_LED, HIGH)
}
}

В този пример като индикатор за наклон се използва светодиодът по подразбиране № 13.

Тук можете ясно да видите включването на издърпващия резистор, доста подобно на това, което направихме в раздел 3.1. Следователно терминът LOW показва, че функцията за накланяне не се задейства.

7.4 Реле на тръстиков превключвател (реле с миниатюрен магнит)

Сега нека видим как да свържете релеен превключвател или сензор за магнитно поле с Arduino. Тръстиковото реле е вид превключвател, който се активира или провежда, когато магнитно поле или магнит се доближат до него. По същество той има двойка феромагнитни контакти в миниатюрно стъклено заграждение, които се свързват или осъществяват контакт поради магнитно издърпване, когато магнитът е в непосредствена близост до него. Когато това се случи, клемите на контактите показват проводимост поради затваряне на контактите.

Тук също използваме светодиода pin 13 за индикация на реакцията. Можете да свържете външен светодиод от този щифт, ако е необходимо съгласно нашите предишни обяснения.

const int kPinReedSwitch = 2
const int kPinLed = 13
void setup()
pinMode(kPinReedSwitch, INPUT)
digitalWrite(kPinReedSwitch, HIGH) // turn on pullup resistor
pinMode(kPinLed, OUTPUT)
}
void loop()
{
if(digitalRead(kPinReedSwitch) == LOW){
digitalWrite(kPinLed, HIGH)
}
else{
digitalWrite(kPinLed, LOW)
}
}

Кодовите термини трябва да са познати и да се обясняват.

7.5 Вибрационен сензор с помощта на Piezo Transducer

В следващата примерна програма ще видим как a пиезо преобразувател може да се използва като вибрационен сензор за осветяване на светодиод чрез Arduino.

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

Настройте Arduino и пиезо елемент, както е дадено на следващата фигура

използване на пиезо като сензор за вибрации с Arduino

const int kPinSensor = A5
const int kPinLed = 13
const int k_threshold = 100
int ledState = LOW // variable used to store the last LED status, to toggle the light
void setup()
{
pinMode(kPinLed, OUTPUT) // declare the ledPin as as OUTPUT
}
void loop()
{
int val = analogRead(kPinSensor)
if (val >= k_threshold) {
ledState = !ledState // toggle the value of ledState
digitalWrite(kPinLed, ledState)
delay(20) // for debouncing
}
}

Прагът 100 е въведен само за да се гарантира, че Arduino реагира само на истинските вибрации чрез удари, а не и на други по-малки вибрации като от силни звуци или клаксони.

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

Използване на серво мотор с Arduino

Серво моторът е тип двигател с постоянен ток, който може да се завърти под точни ъгли според нуждите на конкретно приложение. Това може да се направи чрез прилагане на изчислена команда към съответните входове на двигателя, за да се получи точен ъгъл на въртене или завъртане в диапазона от 180 градуса на двигателя.

Обикновено серво мотор има 3 проводника или входа. Положителните проводници обикновено са червени на цвят, отрицателните или заземяващите проводници са черни, а командният или сигнализиращият проводник обикновено са бели или жълти на цвят.

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

Следващият пример ще ни покаже основната програма за настройка за внедряване на управление на сервомотора чрез Arduino:

Arduino серво моторно управление

Кодът е даден по-долу:

#include
Servo servo1
const int kPinPot = A0
const int kPinServo1 = 9
void setup()
{
servo1.attach(kPinServo1)
}
void loop()
{
int val = analogRead(kPinPot)
val = map(val, 0, 1023, 0, 180)
servo1.write(val)
delay(15)
}

Тук можем да видим няколко нови записа. Този, който съобщава на прикрепения проводник на серво на какъв пин е назначен. Другият е кодът, който осигурява на щифта стойност между 0 и 180, за определяне на ъгъла на въртене на серво.

Заключение

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

Надяваме се тук да се актуализира от време на време повече информация, когато е налична.

Междувременно се насладете на вашия курс по програмиране, честит Arduinoing за вас !!




Предишна: Верига за измерване на алкохол, използваща сензорния модул MQ-3 Напред: Контролирана от мобилен телефон верига за подаване на кучета