Учење основног Ардуино програмирања - Водич за придошлице

У овом упутству ћемо научити како се изводи основно програмирање Ардуина кроз примере кодова и примера програма. Овај водич може бити изузетно вредан курс за све новопридошле који желе да разумеју основе кроз лак, разумљив језик.

Увод

Према википедиа микроконтролер је еквивалентан мини рачунару уграђеном у један ИЦ чип, који има сопствени процесор језгра, програмабилне улазе, меморију и излазну периферну опрему.

Микроконтролер постаје толико користан за корисника јер нуди уграђени процесор, меморију и улазно / излазне портове (који се називају и ГПИО или оптички улазно / излазни пинови) којима корисник може управљати према било којој жељеној спецификацији.

У овом упутству ћемо радити са Ардуино Уно плочом за учење и тестирање програма. За тестирање и интеграцију хардверског склопа користићемо плочу.

Сада кренимо брзо и научимо како започети са Ардуино програмирањем.

1.2 Инсталирање софтвера (Виндовс)

За ово ће вам требати приступ Интернету, који бисте очигледно имали на рачунару. Идите на следећу везу и преузмите ИДЕ софтвер:

Виндовс ЗИП датотека за инсталацију без администратора

Након преузимања, у фолдеру за преузимање пронаћи ћете икону за подешавање Ардуино, која би изгледала овако:

Једном када ово добијете, можете једноставно двапут кликнути на њега и инсталирати Ардуино интегрисано развојно окружење (ИДЕ) на свој рачунар. Комплетан процес се може приказати на следећем видео снимку:

1.4 Почевши од нашег првог круга

Пре него што започнемо са учењем стварних техника програмирања, за сваког почетника било би корисно започети са основном компонентом као што је ЛЕД и разумети како је повезати са Ардуином.

Као што знамо, ЛЕД је диода која емитује светлост која има поларитет и неће светлити ако није повезана са правим половима напајања.

Још један аспект ЛЕД диода је да ови уређаји раде са малом струјом и могу се тренутно оштетити ако одговарајуће израчунати отпорник није укључен у серију са једним од његових пинова.

По правилу, 330 охма 1/4 вата је сасвим идеално за сваких 5 В пораста улазног напајања како би се струја ограничила на потребан безбедни ниво. Према томе, за 5В то може бити 330 охма, за 10В 680 охма и тако даље.

Коришћење Бреадбоард-а за скупштину

Уверите се да знате како се користи плоча за хлеб пре него што смо испробали туториал објашњен у овом поглављу, јер бисмо овде користили плочу за све експерименте.

Основно подешавање ЛЕД везе може се видети у наставку:

Горе можете видети 3 основне компоненте:

1. ЛЕД од 5 мм, 20 мА
2. отпорник од 1/4 вата од 330 ома
3. Ан Ардуино Боард

Само саставите систем према дијаграму.

Затим прикључите 5В са УСБ рачунара на Ардуино. Чим то учините, видећете како ЛЕД светли.

Знам да је то прилично основно, али увек је добро почети од нуле. Будите сигурни да ће ствари почети да постају све занимљивије како напредујемо.

1.5 Контрола ЛЕД диоде са Ардуином

Сада ћемо научити како да контролишемо ЛЕД помоћу програма Ардуино.

Да бисмо написали програм, морамо имати најмање 2 функције у сваком програму.

Функција се може схватити као низ програмских израза којима се може доделити име, као што је дато у наставку:

1. поставити() ово се позива или извршава током почетка програма.
2. лооп () ово се позива или изводи понављајуће током читавог оперативног периода Ардуина.

Стога, иако можда нема практичну функционалност, технички најкраћи легитимни Ардуино програм може се написати као:

Најједноставнији програм

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

Можда сте приметили да у многим програмским језицима систем започиње приказивањем једноставног отиска „Хелло, Ворлд“ на екрану

Електронски еквивалент ове фразе у интерпретацији микроконтролера је трептање ЛЕД-а УКЉУЧЕНО И ИСКЉУЧЕНО.

Ово је најосновнији програм који се може написати и применити како би указао на правилно функционисање система.

Покушаћемо да применимо и разумемо процедуру путем следећег дела кода:

Унос 1.2: лед1 / лед1.пде

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)
}

Овај код конфигурише одређени пин на који је прикључена наша ЛЕД лампица. Другим речима, код говори Ардуину да контролише аспект „писања“ на овом пину, уместо да га „чита“.

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

Горњи редови указују на стварно извршење пријаве. Код започиње писањем и приказивањем ХИГХ на одговарајућој ЛЕД вези, УКЉУЧУЈУЋИ ЛЕД.

Овде израз ХИГХ једноставно значи добијање + 5В на дотични пин Ардуина. Термин ЛОВ који допуњује једноставно означава нулу или 0В на назначеном пину.

Даље, позивамо delay() чија је функција стварање кашњења кроз милисекунде (1/1000 део секунде). Пошто се унесе цифра 500, примењено кашњење ће трајати 1/2 секунде.

Чим истекне ова 1/2 секунде, извршава се следећи ред који искључује ЛЕД са ЛОВ термином на истом пину.

Следећа линија опет генерише кашњење од 1/2 секунде, како би ЛЕД диода остала ИСКЉУЧЕНА 1/2 секунде.

А процес се наставља бесконачно извршавањем линија кода, све док се Ардуино одржава напајаним.

Пре него што пређете на следећи ниво, препоручио бих вам да програмирате горњи код и проверите да ли сте у стању да правилно примените секвенцу ЛЕД ОН / ОФ или не.

Будући да је подразумевана ЛЕД лампица у Ардуину повезана са пином # 13, требало би да одмах реагује на горњи програм и почне да трепери. Међутим, ако установите да ваша спољна ЛЕД лампица не трепће, онда би могло доћи до грешке у вези са ЛЕД лампицом, можете покушати да преокренете поларитет ЛЕД-а и надамо се да ће и она трептати.

Можете се играти са временом кашњења тако што ћете променити бројку „500“ на неку другу вредност и пронаћи ЛЕД да „преслушава“ команде и узрокује да трепери према наведеним вредностима кашњења.

Али запамтите, ако видите да ЛЕД не трепће са константном брзином од 1 секунде, без обзира на промену времена кашњења, то може значити да код не ради због неке грешке. Јер ће се Ардуино подразумевано програмирати са брзином треперења од 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. Језик вашег програма разликоваће велика и мала слова. На пример израз миВар не може се записати као МиВар.
2. Размаци свих врста који се могу извршити притискањем тастатуре, на крају се приказују као јединствени размак и то ви видите или разумете само ви, рачунар то неће узети у обзир. Једноставно речено, слободни размаци било које врсте неће имати никаквог утицаја на резултате кода.
3. Сваки блок кода мора бити приложен левим и десним завојним заградама, '{' и '}'
4. Бројчане цифре не треба одвајати зарезима. На пример, 1000 можда неће бити записано као 1000.
5. Свака линија кода затворена између витичастих заграда мора завршити тачком и зарезом

Стварање занимљиве секвенце ЛЕД светла са Ардуином

У нашем претходном поглављу научили смо како непрекидно трептати ЛЕД УКЉУЧИВАЊЕ / ИСКЉУЧИВАЊЕ са константном стопом одлагања.

Сада ћемо научити како се различити облици кашњења могу извршити на истој ЛЕД-у надоградњом програмског кода.

Нећемо користити спољну ЛЕД, радије ћемо користити подразумевану ЛЕД уграђену у Ардуино плочу на пин # 13. Овај малени СМД ЛЕД можете пронаћи одмах иза УСБ конектора.

2.2 Разумевање ИФ изјава

У овом одељку ћемо научити како нам контролне структуре омогућавају покретање појединачних кодова, а понекад чак и понављање, према потреби.

Изјава ако постаје 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

Можете пронаћи да је ово слично коду у првом реду, изузев чињенице да му недостаје термин цонст.

То је једноставно зато што овај код није константа. Уместо тога, ово је дефинисано као а променљива , која има својство променљиве вредности током програмирања.

У горњем примеру можете видети да се овој променљивој приписује вредност 1000. Запамтите, такве променљиве које су затворене у витичасте заграде морају бити строго записане само у паровима витичастих заграда и називају се „локалним“ променљивим.

Алтернативно, променљиве за које се претпоставља да су изван коврџавих заграда, попут оне о којој сада разговарамо, препознају се као „глобалне“ и могу се извршити готово било где унутар програмског кода.

Крећући се напред, можете видети да су кодови између редова 9 и 11 такође слични првом програму, без обзира на то што ствари почињу да постају занимљивије након реда 11. Да видимо како!

delayTime = delayTime - 100

У овом коду видимо да је подразумевана вредност кашњење се модификује одузимањем 100 од њега.

Значење 100 одузима се од почетне вредности 1000, пружајући му нову вредност од 900.

Кроз следећу слику покушаћемо да схватимо неколико математичких оператора који се користе у језику Ардуино.

Хајде сада да проценимо кодове између редова 13 и 15.

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

Главни циљ горњег дела кода је осигурати да ЛЕД настави трептати без икаквих прекида.

Због чињенице да се 100 одузима од оригинала кашњење , спречава трептање ЛЕД-а да достигне нулу и омогућава трептање да се непрекидно наставља.

Следећа слика приказује неколико оператора упоређивања које бисмо користили у нашим кодовима:

У нашем горенаведеном коду могли смо да тестирамо да је 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)
}

У горе наведеном добро видите да се у 10. реду код извршава само када се delayTime је мање или једнако 100, ако не, тада се извршава код у 13. реду, али обоје се никада не може догодити, применит ће се 10. ред или код 13. ретка, никада обоје.

Можда сте приметили да за разлику од онога што смо урадили у нашем претходном одељку 2.2, овде нисмо упоређивали са 0, већ у поређењу са 100. То је зато што смо у овом примеру у поређењу ПРЕ него што смо одузели 100, супротно у одељку 2.2, упоредили НАКОН одузети. Можете ли рећи шта се могло догодити да смо упоређивали 0 уместо 100?

2.4 ВХИЛЕ изјаве

ДО док Изјава је прилично слична ако изјава, осим истине да изазива опетовано извршавање блока кода (који може бити између коврџавих заграда) толико дуго док су услови применљиви, а ово функционише без иначе изјава.

Следећи пример ће вам помоћи да ово боље разумете

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). Заправо се 'труе' не користи, већ се претпоставља да када ништа није лажно, онда је све што је укључено тачно.

Изгледа мало чудно, али посао обавља прилично лепо.

Покушаћемо да схватимо ситуацију кроз следећи пример.

Понекад можете наићи на код како је дат у наставку:

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

Ово је кодирано, чини се да ће ЛЕД изведба наставити да вози бицикл заувек, све док је доступна снага.

Међутим, једна лоша страна ове врсте кода може настати када случајно корисник примени = уместо ==.

Сигуран сам да већ знате да = означава задатак, што значи да се користи за означавање изабране вредности променљивом, док се == користи за наметање теста ако је вредност била иста.

На пример, претпоставимо да вам је била потребна ЛЕД лампица да трепће узастопно и убрзано, али погрешно сте користили = уместо ==.

Тада би се код појавио овако:

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 односи на фалсе, мислиће да то није тачно и зауставиће спровођење delayTime = 1000, али уместо тога функција delayTime се одржава на 0 током петље ().

Ово изгледа врло непожељно !!

Дакле, увек двапут проверите свој програм да бисте били сигурни да нисте направили такве глупе грешке.

2.6 Комбинације

Понекад ћете можда осећати потребу да тестирате више ствари заједно. Као, можда ћете желети да испитате да ли је променљива била између два броја. Иако се ово може имплементирати помоћу наредбе иф више пута, можда је погодније користити логичке комбинације за боље и лакше читање.

Примена комбинација на логичким терминима може се извршити помоћу 3 методе, као што је приказано у следећој табели:

Било би занимљиво знати да оператор НОТ може радити као прекидач за променљиву која може бити означена као било која истина или лажно (или НИСКО или ВИСОКО).

Следећи пример илуструје услов:

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
}

Можете пронаћи нешто јединствено у линији са за.

То је шифра и ++? . Ово је корисно за програмере који су прилично лењи и желе да примене кодирање помоћу прикладних пречица

Горе наведени термин познат је као сложени оператери, јер они раде посао комбиновања једног оператора доделе са другим оператором доделе. Најпопуларније од њих могу се приказати у следећој табели:

Открићете да се у изјави фор налазе 3 под-изјаве. Структуриран је како је приказано у наставку:

for (statement1conditionstatement2){
// statements
}

Изјава бр. 1 јавља се одмах на почетку и само једном. Стање се тестира сваки пут током трајања петље. Кад год је истина унутар витичастих заграда спроводи се наредна изјава бр. У случају а лажно, систем прелази на следећи блок кода.

Повезивање више ЛЕД диода

У реду, сада ћемо видети како можемо повезати већи број ЛЕ-ова да бисмо добили занимљивије ефекте.

Повежите ЛЕД и Ардуино као што је приказано доле. Црвена жица заправо није потребна, али с обзиром да је увек добра идеја да обе шине за напајање буду укључене у плочу за постављање, има смисла.

Хајде сада да поправимо програм који ће нам омогућити да проверимо да ли је наш хардвер правилно конфигурисан или не.

Увек се препоручује кодирање и извршавање малих битова програма корак по корак како би се проверило да ли су одговарајући хардвери исправно ожичени или не.

Ово помаже у брзом решавању могућих грешака.

Пример кода у наставку даје ЛЕД 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

Шта је улаз

Тако смо научили како управљати стварима користећи Ардуино. У овом поглављу ћемо разговарати о томе како осетити стварни свет повезивањем уноса спољних параметара.

3.1 Коришћење тастера

Сви знамо шта је тастер и како то функционише. То је врста прекидача или дугмета који на тренутак повезује сигнал са једне фазе круга на другу док је у депресивном стању и прекида сигнал када се пусти.

3.1.1 Једно дугме и ЛЕД

Повезаћемо Ардуино дугметом са Ардуином према горе приказаним детаљима и научићемо основни рад и имплементацију подешавања.

Означени тастер који се назива и тастер са микро прекидачем, има укупно 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)
}

Прво што урадимо је да поправимо буттонПин као УЛАЗНИ. Па то је сасвим основно, знам.

Даље, додељујемо ВИСОКО до УЛАЗНИ пин. Питате се, како је могуће написати било шта на улазу? Наравно, ово може бити занимљиво.

Заправо, додељивање ХИГХ за Ардуино улаз укључује / искључује унутрашњи отпорник на извлачење од 20 к Охма (ЛОВ на овом пину га искључује).

Још једно питање које можете поставити је шта је отпорник на извлачење. Објаснио сам свеобухватан чланак о пулл-уп отпорницима које ви научите то овде .

ОК, идемо даље, погледајмо сада главни код петље:

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

Када притиснете тастер, жичана игла се спаја са масом, што чини а ЛОВ до те игле. И док је у нестиснутом стању, држи се исти пин ВИСОКО или + 5В путем 20К унутрашњег отпорника на извлачење.

Овде желимо да Ардуино упали ЛЕД када се притисне тастер (ЛОВ), зато пишемо ХИГХ за излаз за сваки одговор ЛОВ-а са дугмета, док је притиснуто.

3.1.2 Два тастера и ЛЕД

Па, можда се питате да је горе приказана акција могла да се уради и без Ардуина. Разумем, међутим, ово је моћан камен да научим како се дугме може користити са Ардуном.

До овог тренутка проучавали смо писање кодова за УКЉУЧЕНО (ВИСОКО) или ИСКЉУЧЕНО (ЛОВ) ЛЕД.

Сада да видимо како се осветљеност ЛЕД-а може контролисати помоћу Ардуина.

То се може урадити на два начина:

1. Ограничавањем количине струје на ЛЕД
2. Коришћењем ПВМ или модулација ширине импулса, у којој се напајање ЛЕД диоде врло брзо УКЉУЧУЈЕ / ИСКЉУЧУЈЕ по некој жељеној брзини, производећи просечно осветљење чији би интензитет зависио од ПВМ-а.

На Ардуино плочи ПВМ подршка је доступна на пиновима означеним тилдом (~), а то су пинови 3, 4,5,9,10 и 11) на 500Хз (500 пута у секунди). Корисник може да пружи било коју вредност између 0 и 255, при чему се 0 односи на ВИСОКО или никакво + 5В, а 255 говори Ардуину да стално добија ВИСОКО или + 5В. За покретање ових наредби морат ћете приступити аналогВрите () са жељеном вриједношћу.

Можете претпоставити да је ПВМ к / 255 где је к жељена вредност коју желите да пошаљете путем analogWrite().

Подесите Ардуино и друге параметре као што је горе приказано.

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) илуструје јединствену функцију унутар Ардуина познату као цонстраин ().

Ова интерна функција садржи код сродан следећем:

инт ограничење (инт вредност, инт мин, инт мак)
{
if(value > max){
value = max
}
if(value value = min
}
return value
}

Сви кодови о којима се расправљало пре овога су започети празнина , што је значило да се ништа не враћа (воид). Док горњи код започиње са инт , што указује да враћа цео број. О томе ћемо више разговарати у каснијим одељцима, тренутно само запамтите да цео број нема ниједан делимични део.

Тачно, дакле, ово подразумева, код: ledBrightness = constrain(ledBrightness, 0, 255) додељује ledBrightness to be within the range of 0 and 255.

Следећи ред запошљава analogWrite да командује Ардуино да примени ПВМ на изабрани пин са жељеном вредношћу.

Следећи ред ствара кашњење од 20 милисекунди, ово је да би се осигурало да не прилагодимо јело брже од 50 Хз или 50 пута у секунди. То је зато што људи могу бити много спорији од Ардуина. Стога, ако кашњење није направљено, програм би могао да нас натера да осетимо да је притиском на прво дугме искључено ЛЕД, а притиском на друго дугме (ОН), покушајте сами да потврдите.

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

Идемо напред и научимо како да користимо потенциометри са Ардуином.

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

Повежите приказане параметре са својим Ардуином као што је приказано горе.

Пот ће имати 3 терминала. Средњи терминал ће се повезати са АНАЛОГ ИН 0 на Ардуину. Преостала два спољашња терминала могу бити повезана на + 5В и 0В шине за напајање.

Програмирајмо и проверимо резултате:

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 је додељен као А0, при чему је А пречица за опис једног од аналогних пинова. Међутим, А0 се такође односи на пин # 14, А1 на пин # 15 и тако даље, а они вам омогућавају да се користите као дигитални улази / излази у случају да вам остане без пинова за експеримент. Али имајте на уму да дигиталне пинове не можете користити као аналогне.
2. Ред: ledBrightness = map(sensorValue, 0, 1023, 0, 255) представља нову унутрашњу функцију у Ардуину познату као Мапа(). Ова карактеристика се поново калибрише из датог опсега у други, назван као мап (валуе, фромЛов, фромХигх, тоЛов, тоХигх). Ово може постати пресудно пошто analogueRead даје вредност у опсегу од 0-1023, али аналогВрите може да прихвати вредност од 0-255.

Можда мислите да је, с обзиром на то да је могуће контролисати осветљеност ЛЕД диоде променљивим отпором, једноставно лонац могао бити довољан у сврху, зашто употреба Ардуина. Па, опет, то је само основа да се покаже како се пот може конфигурисати са Ардуином.

Нема проблема, сада ћемо урадити нешто што се не може без Ардуина.

У овом експерименту видећемо како се променљиви отпор лонца може користити за контролу брзине треперења или брзине ЛЕД-а.

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

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

До овог одељка смо разговарали о променљивој инт. Међутим, можда постоји још много променљивих типова којима можете да приступите. Списак можете прочитати у наставку:

Тренутно је можда само пресудно знати да за складиштење релативно великог броја за инт променљива, могли бисте да користите израз дуго или а лонг инт.

Овде можете видети још једну занимљиву функцију која се зове милис ().

То ствара временски распон у милисекундама на којима је Ардуино радио у току свог рада од почетка (ово ће се ресетовати на 0 након сваких 50 дана). Овде се враћа дуго јер ако се врати инт , бројање на дужи период можда неће бити могуће. Можете ли да одговорите тачно колико дуго? Одговор је 32.767 секунди.

Стога, уместо да користимо делаи (), проверавамо да ли постоји милис (), а чим прође одређени број милисекунди, мењамо ЛЕД. Због тога чувамо време у коме смо га последњи пут променили последњи пут променљиву, тако да нам омогућава да је поново проверимо кад год желимо.

3.3 РГБ ЛЕД диоде

До сада смо се играли са једнобојном ЛЕД лампицом. Иако би се ЛЕД боја могла променити заменом ЛЕД-а другом бојом, али како би било да се користе РГБ ЛЕД диоде за промену ЛЕД боја без промене ЛЕД-а?

РГБ ЛЕД је у основи ЛЕД са црвеном, зеленом и плавом ЛЕД која је уграђена и спојена у једну ЛЕД. Има један заједнички проводник који иде на земљу или 0В опскрбну шину, док су остала 3 извода напајана разноврсним ПВМ позитивним сигналима за спровођење предвиђених мешање боја .

Можете повезати уређај како је приказано доле:

Можда изгледа мало сложено, али заправо је реплика нашег ранијег дизајна ЛЕД управљања помоћу ПВМ-а.

Ево кода програма за вежбање:

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)
}

Након отпремања овог кода, само погледајте како подешавања лонца стварају занимљив светлосни ефекат на РГБ, то може бити права забава.

Открићете да када се сва 3 лонца помакну на максималне положаје, уместо беле боје видећете црвену. То је зато што је црвена боја најистакнутија међу 3 боје и стога доминира у овој ситуацији. Међутим, можете експериментисати са функцијом Мапа() , пре извођења на црвени део ЛЕД диоде, како би се створила разумнија равнотежа.

Аудио са Ардуином

У овом одељку ћемо научити како додати основни звук и музику у Ардуино подешавање.

Видећемо како пребацити сигнал на повезани звучник са жељеном фреквенцијом.

Тачније, покушаће се са средњом нотом, која је фреквенција од 440 Хз.

Да бисмо то урадили, једноставно ћемо пустити ноту средње А и оптимизовати сигнал синусног таласа квадратним таласом.

Такође ћемо израчунати колико времена звучник може остати УКЉУЧЕН тужбом формуле:

тимеДелаи = 1 секунда / 2 к фреквенција тона.

тимеДелаи = 1 секунда / 2 к 440

тимеДелаи = 1136 микросекунди

4.1 Прикључимо Ардуино плочу

4.2 Додавање једноставне белешке

О функцији смо већ разговарали кашњење () где је јединица у милисекундама (секунда / 1000), међутим наћи ћете још једну функцију delayMicroseconds() где је јединица у микросекундама (милисекунда / 1000).

За садашње подешавање програмирамо код за укључивање / искључивање + 5В на одабраном пину повезаном са звучником, брзином од 440 импулса у секунди.

Подсетимо, у последњој дискусији утврдили смо вредност 1136 микросекунди за предвиђену аудио ноту.

Дакле, ево програма за ово, који ће вам омогућити да чујете звучну ноту од 440 Хз чим програмирате ардуино са повезаним звучником.

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)
}

Помоћу горње апликације могуће је направити звучну ноту, што такође значи да можемо створити музику по сопственом избору.

Из кода схватамо да Ардуино укључује неколико интегрисаних функција које додатно доприносе стварању музике.

Први је тон () који ради са 2 елемента заједно са трећим опционим елементом, означеним као тон (пин, фреквенција, трајање). или тон (пин, фреквенција)

Обоје су одређени да извршавају временски период који сте одредили.

У недостатку временског периода, музика ће се репродуковати до позива тон () се извршава поново или док не извршите ниједан ().

То ће бити потребно урадити помоћу функције одлагања у случају да је репродукција музике једина основна ствар коју имплементирате.

Време трајања може бити пресудно, јер омогућава време колико се музика пушта, тако да можете слободно да радите и друге ствари. Чим протекне трајање, музика престаје.

Следећа функција ниједан () обрађује један параметар и зауставља изабрани тон на одређеном додељеном пину.

Необично упозорење: било када тон () функција је имплементирана, ПВМ функција на пин 3 и 11 ће престати да ради.

Стога, кад год се у програму користи додатак за звучник, пазите да не користите поменуту иглу за звучнике, већ испробајте неке друге игле за причвршћивање звучника.

У реду, па ево програма за примену музике на звучнику, иако то није права музика, већ основна нота на скали Ц.

#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)
}

У горњем коду сте можда приметили нешто ново и то је #дефинисати .

Овај термин делује као команда за претрагу и замену за рачунар док се врши компајлирање.

Кад год пронађе прву ствар испред размака, замењује је преосталим делом линије (која се назива макронаредбама).

Дакле, у овом примеру када рачунар види НАПОМЕНА_Е4 брзо га замењује количином 330.

За више напомена и прилагођавања можете упутити датотеку на вашем УСБ стицк-у под називом терени.х , где се већина фреквенција може наћи према вашим жељама.

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

Горњи код изгледа добро, али изгледа да има много понављања, требало би да постоји неки начин да се та понављања скрате, зар не?

До сада смо радили са две основне функције укључене у Ардуино. Сад је можда време да створимо сопствене функције.

Свака функција мора започети типом променљиве са којом може бити повезана. На пример функција празнина односи се на тип који не враћа ништа па отуда назив воид. Напомена, већ смо разговарали о листи променљивих у нашим ранијим одељцима, можда ћете желети да их упутите.

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

Сваки од параметара добија свој тип заједно са именом и на крају цлосе ')' заграде.

Ови параметри се могу применити унутар функције у облику променљивих.

Погледајмо пример у наставку где развијамо функцију тзв оурТоне () дизајниран за спајање тон () са кашњење () линија, на начин да се функција престаје враћати док нота не заврши са репродукцијом тона.

Ове функције имплементирамо у наш претходни код и добијамо доњи програм, погледајте последње редове:

#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)
}

На првом реду можете јасно видети увод #инцлуде изјава. Посао ове изјаве је да подигне целу датотеку између наводника и постави је у положај #инцлуде изјава. Према стандардним правилима, они су строго постављени на почетку програма.

Поглавље 5

Мерење температуре

Само да се сетимо, упамтите, уместо да пишете велике програме, увек је паметно писати и анализирати мале делове кодова, што помаже у брзом проналажењу грешака.

5.1 Серијски монитор

До сада се чини да шифре о којима смо разговарали није тако лако омогућити брзо решавање проблема. Овде ћемо покушати да олакшамо надзор и лакше решимо могући проблем.

Ардуино има функцију која му омогућава да 'одговори' са рачунаром. Можете приметити да су пин0 и пин1 означени као РКС и ТКС један поред другог. Ове пинове заправо прати засебни ИЦ у Ардуину који их надограђује да читају преко УСБ кабла док је прикључен на рачунар.

Доњи одељак приказује пуноправни програм, молим вас, наставите, научићемо о новим уносима у коду након тога. Овај код је исти као и изражени одељак 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)

Овде други ред сугерише да ће следећа ствар која излази из серијског порта започети у следећој линији. Тако се друга линија разликује од прве линије.

Још једна ствар коју можете видети су цитати ('). Ово је познато као низ који ће се овде користити само попут константи, јер даља дискусија о овој теми може бити превише разрађена и изван опсега.

У реду, сада можемо да отпремимо горњи код у Ардуино и видимо шта ће се догодити.

Шта, упс, изгледа да се ништа није догодило, ЛЕД диода Ардуино пин # 13 је затрептала и зауставила се, док је Тк ЛЕД наставио трептати.

Па, то је зато што прозор Сериал Монитор још увек није поправљен.

Морате да кликнете на поље Сериал Монитор у свом ИДЕ-у, као што је приказано горе. Не заборавите да проверите брзину преноса која се налази у доњем десном углу, подразумевано би требало да буде 9600 и подудара се са кодом. Ако није обавезно изаберите 9600.

Следећи видео снимак објашњава како се то ради.

Сада идемо напред и научимо како горња функција серијског монитора може помоћи у обради мерење температуре помоћу Ардуина

Користићемо ИЦ ТМП36 као температурни сензор у опсегу од -40 до 150 степени Целзијуса.

Подешавање се може видети доле:

Следећи код започиње мерење температуре очитавањем излаза са сензора ТМП36 и њиховим слањем на серијски монитор ИД-а.

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() је наша сопствена функција која математички израчунава и претвара осетљиву разлику напона са ТМП36 сензора у степене Целзијуса.

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.

Сензор ТМП36 је одређен да генерише 0,5В на 0 степени Целзијуса, а затим генерише 10мВ за сваки појединачни пораст степена Целзијуса.

Ево апроксимације коју смо у стању да генеришемо прорачунима:

Можете сматрати својом првом функцијом која враћа неку вредност (имајте на уму да све преостале функције до сада нису вратиле никакву вредност јер су типа празнина ).

Можете да схватите да бисте добили функцију из функције, једноставно морате да додате повратак праћен жељеним бројем који желите да вратите.

Кад кажемо повратак то значи да функција враћа одговор или одговор кад год се позове, а који се могу применити на променљиву.

Када се ово пошаље серијском монитору, очитавање се претвара у Фахренхеит цонвертТоФ ().

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

Ова функција узима опсег Целзијуса и претвара га у Фахренхеит.

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

5.3 Повезивање ЛЦД-а

Сада проучимо како да повежемо или повежемо ЛЦД дисплеј са Ардуином за добијање визуелног приказа потребних резултата.

У нашој апликацији запослићемо графички ЛЦД 84к48, хоризонтално 84 пиксела или тачака и вертикалну резолуцију 48 пиксела. Будући да наменски контролер постаје императив за све ЛЦД екране, садашњи уређај такође укључује један у облику ПЦД8544 контролера.

У овом упутству ћемо повезати горе наведени ЛЦД модул са Ардуином и применити одређене рутине за креирање текстуалних порука на екрану.

На следећој слици можете пронаћи детаље у вези са повезивањем ЛЦД-а, заједно са малим 3.3В регулатор напона . Овај регулатор је неопходан јер је ЛЦД одређен за рад са напајањем од 3.3В.

Такође можете видети 8 извода из ЛЦД модула, а спецификације извода могу се проучити из следеће табеле:

Сада да видимо како можемо повезати ЛЦД и релевантне параметре са нашим Ардуином. Детаљи се могу приказати на доњој илустрацији:

5.4 Комуникација са ЛЦД екраном

Иако је могуће написати сложене кораке за интеракцију са ЛЦД-ом из Ардуина, радије ћемо научити како то учинити помоћу библиотека.

Библиотеке чине асортиман кодова који се могу брзо применити за одабрани Ардуино програм.

Ово омогућава кориснику да без напора позове функцију без потребе да пролази кроз сложени рад кодирања.

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

За ово ћете морати да креирате директоријум који се зове библиотеке у вашем рачунару Ардуино ИДЕ, како је објашњено овде

5.4.2 Имплементација ЛЦД операција

Баш као и наш претходни приступ, прво ћемо проверити цео код, а затим покушати да разумемо детаље појединих редова.

#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

Код #инцлуде налаже рачунару да преузме поменуту датотеку и замени елемент #инцлуде садржајем датотеке током компајлирања програма.

Елемент #инцлуде може имати угаоне заграде што указује на претрагу у директоријуму библиотеке, а може имати и наводнике који указују на претрагу у истом директоријуму у којем се програм налази.

Следећи редови кода изражавају ЛЦД пиноутс, а затим напишемо нови облик променљиве:

PCD8544 lcd(kPin_CLK, kPin_DIN, kPin_DC, kPin_RESET)

Овде изражавамо променљиву са именом лцд типа ПЦД8544 и упутујемо ПЦ да надогради своје пиноуте повезане са Ардуином.

У овом процесу описујемо променљиву рачунару упућујући како су пин цлк, дин, дц и ресет повезани са Ардуином.

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

Ред lcd.init() иницијализује рад ЛЦД-а. Једном када се ово изврши, следећи ред намеће курсор у горњем левом углу екрана. И следећи следећи ред труди се да одштампа поруку „Здраво, свет“.

Ово изгледа сасвим идентично техници којом смо слали поруке преко серијског монитора. Једина разлика је употреба кода lcd.print уместо серијског.штампа.

Следећи блок кода се заправо понавља.

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

Користећи ову линију lcd.setCursor(0,1) фиксирамо курсор у 0. колону крајње лево од 1. реда, преко ЛЦД екрана.

Следећи ред користи пречицу: lcd.print(millis())

Ако се сећате, сарађивали смо са millis() у нашим ранијим кодовима, могли смо и овде да применимо исто кроз кодове:

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

Међутим, због чињенице да овде није реч о временским периодима у милисекундама, стога то постижемо једноставним слањем millis() функција директно на lcd.print() .

5.5 Комбиновање целокупне ствари

У реду, хајде сада да комбинујемо све кодове које смо горе научили за прављење ЛЦД температурног круга и да видимо како то изгледа:

#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
}

У горњем програму све изгледа стандардно, осим употребе функције сетЦурсор () . Ово се користи за поравнање текста што је више могуће око средине екрана.

Велики! Честитамо, управо сте програмирали свој властити мали ЛЦД индикатор температуре користећи Ардуино.

Практичне Ардуино апликације

Будући да смо у овом тренутку детаљно покрили разне технике програмирања, време је да их упознамо тако што ћемо их применити за неколико корисних практичних примена.

Започећемо са сензорима и видећемо како се сензорски уређаји могу користити са Ардуином извршавањем неколико узорака кодова.

7.1 Увод у сензоре

У овом упутству ћемо научити широк спектар сензора који се могу користити са Ардуином. То могу укључивати уређаје попут сензора светлости ЛДР, магнетног сензора ефекта Халл-а, сензора нагиба, сензора вибрација, сензора притиска итд.

Започећемо са повезивањем сензор светлости ЛДР са Ардуином, као што је приказано на следећем дијаграму:

Као што сви знамо, ЛДР је отпорнички уређај зависан од светлости чији отпор зависи од интензитета амбијенталног пада на његову површину.

Интензитет светлости је обрнуто пропорционалан очитавању отпора ЛДР-а.

Овде ћемо научити како се ово својство може интегрисати са Ардуином за извршавање корисне апликације:

Комплетни програмски код се може визуализовати на следећи начин:

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)
}

Сви параметри коришћени у коду су већ разматрани у нашем курсу који смо до сада научили. Редове можете проверити позивањем на одговарајуће одељке.

Вредности су одабране насумично, лако можете да их промените према сопственим жељама.

Сензор нагиба

Сензор нагиба је једноставан уређај који се може користити за откривање дејства нагиба на било ком објекту на коме је инсталиран. Уређај у основи има металну куглу која се при нагињању котрља преко пара контаката изазивајући проводљивост преко тих контаката. Ови контакти који су завршени као водичи нагибног прекидача, користе се са спољним кругом за откривање проводљивости услед нагибног дејства и активирање жељене излазне апликације.

Сада да видимо како а сензор нагиба уређај може бити ожичен. Слика испод даје идеју у вези са комплетном конфигурацијом:

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. Стога израз ЛОВ означава да функција нагиба није активирана.

7.4 Релеј прекидача са језичком (релеј активиран минијатурним магнетом)

Сада да видимо како спојити релејни прекидач или сензор магнетног поља са Ардуином. Релеј трске је врста прекидача који се активира или проводи када му се приближи магнетно поље или магнет. У основи има пар феромагнетних контаката унутар минијатурног стакленог кућишта који се спајају или остварују контакт због магнетног повлачења кад год је магнет у његовој непосредној близини. Када се то догоди, терминали контаката показују проводљивост због затварања контаката.

И овде користимо ЛЕД # 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 Сензор вибрације помоћу Пиезо претварача

У следећем примеру програма видећемо како а пиезо претварач може се користити као сензор вибрације за осветљавање ЛЕД диоде кроз Ардуино.

Пиезо елемент је заправо уређај који генерише вибрације или осцилације када се фреквенција примени преко његових терминала. Међутим, исти пиезо би се могао користити у обрнутом процесу за генерисање електричних импулса као одговор на вибрације које се примењују на његово тело. Ова вибрација може бити у облику куцања или удара о површину пијеза.

Подесите Ардуино и пиезо елемент као што је дато на следећој слици

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 је уведен само како би се осигурало да Ардуино реагује само на истинске вибрације ударцима, а не и на друге мање вибрације попут гласних звукова или сирена.

Избор А5 пина није обавезан, можете одабрати било који други аналогни улаз према вашим жељама и подударањем у програмском коду.

Коришћење серво мотора са Ардуином

Серво мотор је врста једносмерног мотора који се може ротирати под тачним угловима према захтеву одређене примене. То се може постићи применом прорачунате команде на одговарајуће улазе мотора како би се на мотору произвео тачан угао ротације или скретања у опсегу од 180 степени.

Серво мотор обично има 3 жице или улаза. Позитивне жице су обично црвене боје, негативне или уземљене жице су црне, а наредбена жица или сигнална жица су обично беле или жуте боје.

Ардуино олакшава управљање серво мотором помоћу уграђеног језика за подршку што управљање чини врло погодним и идеалним за серво моторе.

Следећи пример ће нам показати основни програм за подешавање имплементације управљања серво мотором кроз Ардуино:

Шифра је дата у наставку:

#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, за одређивање угла ротације на серво-у.

Закључак

Предмет Ардуино може бити бескрајно дугачак, а самим тим и изван делокруга овог чланка. Међутим, надам се да вам је горњи водич сигурно требао помоћи да научите саме основе Ардуина и разумете важне параметре кроз разне примере кодова апликација.

Надамо се да ће се овде повремено ажурирати више информација, кад год су доступне.

У међувремену уживајте у свом курсу програмирања, срећан вам Ардуиноинг !!