Nauka podstawowego programowania w Arduino - samouczek dla początkujących

W tym samouczku nauczymy się, jak wykonać podstawowe programowanie Arduino za pomocą przykładowych kodów i przykładowych programów. Ten samouczek może być niezwykle cennym kursem dla wszystkich nowicjuszy, którzy chcą nauczyć się podstaw za pomocą prostego i zrozumiałego języka.

Wprowadzenie

Według wikipedia mikrokontroler jest odpowiednikiem mini komputera zbudowanego w pojedynczym układzie scalonym, posiadającego własny procesor rdzeniowy, programowalne wejścia, pamięć i wyjściowe urządzenia peryferyjne.

Mikrokontroler staje się tak przydatny dla użytkownika, ponieważ oferuje wbudowany procesor, pamięć i porty wejścia / wyjścia (zwane również GPIO lub pinami wejścia / wyjścia ogólnego przeznaczenia), którymi możemy sterować przez użytkownika zgodnie z dowolnymi wymaganiami.

W tym samouczku będziemy pracować z płytą Arduino Uno do nauki i testowania programów. Do testowania i integracji montażu sprzętu użyjemy płytki stykowej.

Teraz przejdźmy szybko i dowiedzmy się, jak rozpocząć programowanie w Arduino.

1.2 Instalacja oprogramowania (Windows)

W tym celu będziesz potrzebować dostępu do internetu, który oczywiście miałbyś w swoim komputerze. Przejdź do poniższego łącza i pobierz oprogramowanie IDE:

Plik ZIP systemu Windows do instalacji przez administratora

Po pobraniu w folderze pobierania znajdziesz ikonę konfiguracji Arduino, która wyglądałaby tak:

Gdy to uzyskasz, możesz po prostu dwukrotnie kliknąć i zainstalować Arduino zintegrowane środowisko programistyczne (IDE) na swoim komputerze. Cały proces można zwizualizować na poniższym filmie:

1.4 Zaczynając od naszego pierwszego obwodu

Zanim zaczniemy uczyć się rzeczywistych technik programowania, dla każdego początkującego przydatne byłoby rozpoczęcie od podstawowego elementu, takiego jak dioda LED, i zrozumienie, jak połączyć go z Arduino.

Jak wiemy, dioda LED jest diodą elektroluminescencyjną, która ma polaryzację i nie będzie świecić, jeśli nie zostanie połączona z odpowiednimi biegunami zasilania.

Innym aspektem związanym z diodami LED jest to, że urządzenia te działają przy niskim prądzie i mogą ulec natychmiastowemu uszkodzeniu, jeśli odpowiednio obliczony rezystor nie zostanie połączony szeregowo z jednym z jego pinów.

Zasadą jest, że napięcie 330 omów 1/4 wata jest idealne dla każdego wzrostu napięcia wejściowego o 5 V, aby ograniczyć prąd do wymaganego bezpiecznego poziomu. Dlatego dla 5 V może wynosić 330 omów, dla 10 V może wynosić 680 omów i tak dalej.

Używanie Breadboard do złożenia

Upewnij się, że wiesz, jak używać pliku Płytka prototypowa przed wypróbowaniem samouczka wyjaśnionego w tym rozdziale, ponieważ do wszystkich eksperymentów będziemy używać tablicy prototypowej.

Podstawową konfigurację połączenia LED można zobaczyć poniżej:

Powyżej można zobaczyć 3 podstawowe komponenty:

1. Dioda LED 5 mm, 20 mA
2. rezystor 330 omów 1/4 wata
3. Na Płytka Arduino

Wystarczy zmontować system zgodnie ze schematem.

Następnie podłącz 5V z USB komputera do Arduino. Jak tylko to zrobisz, zobaczysz świecącą się diodę LED.

Wiem, że to dość proste, ale zawsze dobrze jest zacząć od zera. Zapewniamy, że w miarę postępów sprawy będą stawać się coraz bardziej interesujące.

1.5 Sterowanie diodą LED za pomocą Arduino

Teraz nauczymy się, jak sterować diodą LED za pomocą programu Arduino.

Aby napisać program, musimy mieć co najmniej 2 funkcje w każdym programie.

Funkcję można rozumieć jako ciąg instrukcji programistycznych, którym można nadać nazwę, jak podano poniżej:

1. Ustawiać() jest to wywoływane lub wykonywane podczas uruchamiania programu.
2. pętla() jest to wywoływane lub wykonywane w sposób powtarzalny przez cały okres operacyjny Arduino.

Dlatego, chociaż może nie mieć praktycznej funkcjonalności, technicznie najkrótszy legalny program Arduino można zapisać jako:

Najprostszy program

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

Być może zauważyłeś, że w wielu językach programowania system zaczyna się od wyświetlenia prostego wydruku „Hello, World” na ekranie

Elektronicznym odpowiednikiem tego wyrażenia w interpretacji mikrokontrolera jest zaświecenie i wyłączenie diody LED.

Jest to najbardziej podstawowy program, jaki można napisać i wdrożyć, aby wskazać poprawne działanie systemu.

Spróbujemy zaimplementować i zrozumieć procedurę za pomocą następującego fragmentu kodu:

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

OK, teraz zrozummy, co oznacza każdy wiersz kodu i jak działa wykonanie funkcji:

const int kPinLed = 13

Działa to jak stała, która pozwala nam używać jej podczas całego kursu programowania, bez konieczności używania rzeczywistej wartości, która jest do niej przypisana.

Zgodnie ze standardowymi regułami takie stałe są rozpoznawane na początku litery do . Chociaż nie jest to obowiązkowe, sprawia, że ​​wszystko jest jaśniejsze i łatwiejsze do zrozumienia, gdy masz ochotę przejrzeć szczegóły kodu.

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

Ten kod konfiguruje konkretny pin, do którego jest podłączona nasza dioda LED. Innymi słowy, kod mówi Arduino, aby kontrolował aspekt „pisania” na tym pinie, zamiast go „czytać”.

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

Powyższe wiersze wskazują faktyczne wykonanie aplikacji. Kod zaczyna się od napisania i wyprowadzenia HIGH na odpowiednim połączeniu LED, włączając diodę LED.

Tutaj termin WYSOKI oznacza po prostu uzyskanie + 5 V na odpowiednim pinie Arduino. Uzupełniający termin LOW oznacza po prostu zero lub 0 V na wyznaczonym pinie.

Następnie wywołujemy delay() którego funkcją jest tworzenie opóźnienia w milisekundach (1/1000 sekundy). Ponieważ wprowadzono liczbę 500, zaimplementowane opóźnienie będzie wynosić 1/2 sekundy.

Po upływie tego 1/2 sekundy wykonywany jest następny wiersz, który wyłącza diodę LED z terminem LOW na tym samym pinie.

Kolejna linia ponownie generuje 1/2 sekundy opóźnienia, aby dioda LED pozostawała WYŁĄCZONA przez 1/2 sekundy.

Proces jest kontynuowany w nieskończoność poprzez wykonywanie linii kodu, dopóki Arduino jest zasilane.

Przed przejściem do następnego poziomu radziłbym zaprogramować powyższy kod i sprawdzić, czy jesteś w stanie poprawnie zaimplementować sekwencję LED ON / OF.

Ponieważ domyślna dioda w Arduino jest połączona z pinem # 13, powinna natychmiast zareagować na powyższy program i zacząć migać. Jeśli jednak zauważysz, że zewnętrzna dioda LED nie miga, może to oznaczać błąd połączenia z diodą LED, możesz spróbować odwrócić polaryzację diody LED i miejmy nadzieję, że również miga.

Możesz bawić się czasem opóźnienia, zmieniając cyfrę „500” na inną wartość i stwierdzając, że dioda LED „nasłuchuje” poleceń i powoduje jej miganie zgodnie z określonymi wartościami opóźnienia.

Pamiętaj jednak, że jeśli zauważysz, że dioda LED nie miga ze stałą częstotliwością 1 sekundy, niezależnie od zmiany czasu opóźnienia, może to oznaczać, że kod nie działa z powodu jakiegoś błędu. Ponieważ domyślnie Arduino będzie zaprogramowane z częstotliwością migania 1 sekundy. Dlatego stawka ta musi być zmieniana przez kod w celu potwierdzenia jego prawidłowego działania.

1.7 Komentarze

Linie kodów, które zrozumieliśmy powyżej, zostały napisane specjalnie dla oprogramowania komputerowego.

Jednak aby upewnić się, że użytkownik jest w stanie odnieść się do znaczenia wierszy i je zrozumieć, często przydatne i rozsądne może być zapisanie objaśnienia obok żądanych wierszy kodów.

Te są nazywane komentarze które są napisane wyłącznie w celach informacyjnych dla człowieka lub użytkownika i są zakodowane, aby umożliwić komputerom bezpieczne ich ignorowanie.

Język tych komentarzy jest napisany w kilku formatach:

1. Blokowy styl komentarza, w którym opis komentarza jest umieszczony pod symbolem początkowym / * i końcowym * /
2. Nie musi to ograniczać się w jednej linii, ale można je rozszerzyć na kolejne kolejne wiersze w zależności od długości komentarza lub opisu, jak pokazano w poniższym przykładzie:

/ * To jest komentarz * /

/ * Więc to jest * /

/* I
* to
* tak jak
* dobrze */

Do napisania szybkiego opisu w jednym wierszu komentarza wystarczą dwa ukośniki // na początku. To mówi komputerowi, że ta linia nie ma nic wspólnego z rzeczywistym kodem i musi zostać zignorowana. Na przykład:

// To jest komentarz, który komputery będą ignorować.

Oto przykład w celach informacyjnych:

/*
* 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 Rozwiązywanie problemów

Jeśli zauważysz, że program wyświetla „błąd” podczas kompilacji lub inny problem, poniższe wskazówki prawdopodobnie pomogą Ci ponownie sprawdzić kod i pozbyć się przeszkody.

1. W Twoim języku programu będzie rozróżniana wielkość liter. Na przykład wyrażenie myVar nie można zapisać jako MyVar.
2. Wszelkiego rodzaju białe spacje, które mogą być wykonane podczas pisania na klawiaturze, są ostatecznie renderowane jako pojedyncza spacja i są widoczne lub zrozumiałe tylko dla Ciebie, komputer nie weźmie tego pod uwagę. Mówiąc prościej, wolne przestrzenie nie będą miały żadnego wpływu na wyniki kodu.
3. Każdy blok kodu należy ująć w lewy i prawy nawias klamrowy, '{' i '}'
4. Cyfry liczb nie powinny być oddzielane przecinkami. Na przykład 1000 nie może być zapisane jako 1000.
5. Każda linia kodu zawarta między nawiasami klamrowymi musi kończyć się średnikiem

Tworzenie interesującej sekwencji światła LED za pomocą Arduino

W naszym poprzednim rozdziale nauczyliśmy się, jak migać diodą LED w sposób ciągły ze stałym opóźnieniem.

Teraz dowiemy się, jak różne wzorce opóźnienia mogą być wykonywane na tej samej diodzie LED, aktualizując kod programu.

Nie będziemy używać zewnętrznej diody LED, raczej będziemy używać domyślnej diody LED wbudowanej w płytkę Arduino na pinie # 13. Możesz znaleźć tę małą diodę SMD tuż za złączem USB.

2.2 Zrozumienie instrukcji IF

W tej sekcji dowiemy się, w jaki sposób struktury sterujące pozwalają nam uruchamiać poszczególne kody, a czasem nawet powtarzalnie, zgodnie z wymaganiami.

Wyrok gdyby staje się pierwszą strukturą sterowania. Poniższa implementacja pokazuje, jak jest używana:

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

Postaramy się zrozumieć powyższy kod krok po kroku i dowiedzieć się, jak można go wykorzystać w innych podobnych wykonaniach.

Kody między 1. a 7. linią są dokładnie podobne do naszego programu początkowego.

Pierwsza modyfikacja ma miejsce w ósmej linii.

int delayTime = 1000

Może to być podobne do kodu w pierwszym wierszu, z wyjątkiem faktu, że brakuje w nim terminu konst.

Dzieje się tak po prostu dlatego, że ten kod nie jest stałą. Zamiast tego jest to zdefiniowane jako zmienna , który w trakcie programowania ma właściwość wartości zmiennej.

W powyższym przykładzie widać, że zmiennej tej przypisywana jest wartość 1000. Pamiętaj, że takie zmienne, które są zawarte w nawiasach klamrowych, muszą być ściśle zapisane tylko w parach nawiasów i nazywane są zmiennymi „lokalnymi”.

Alternatywnie, zmienne, które powinny znajdować się poza nawiasami klamrowymi, takie jak ta, o której teraz rozmawiamy, są rozpoznawane jako „globalne” i mogą być wykonywane w dowolnym miejscu w kodzie programu.

Idąc dalej, możesz zauważyć, że kody między liniami 9 i 11 są również podobne do kodów pierwszego programu, niemniej jednak po linii 11 sprawy zaczynają się interesować. Zobaczmy, jak to zrobić!

delayTime = delayTime - 100

W tym kodzie widzimy, że domyślna wartość Czas zwłoki jest modyfikowany przez odjęcie od niego 100.

Oznacza to, że 100 odejmuje się od jego początkowej wartości 1000, zapewniając nową wartość 900.

Na poniższym obrazie postaramy się zrozumieć kilka operatorów matematycznych używanych w języku Arduino.

Teraz oceńmy kody między wierszami 13 i 15.

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

Głównym celem powyższego fragmentu kodu jest zapewnienie ciągłego migania diody LED bez żadnych przerw.

Ze względu na fakt, że od oryginału odejmowane jest 100 Czas zwłoki , zapobiega osiągnięciu zera migania diody LED i pozwala na ciągłe miganie.

Poniższy obraz przedstawia kilka operatorów porównania, których użylibyśmy w naszych kodach:

W naszym powyższym kodzie mogliśmy przetestować, czy kod jest if(delayTime == 0).

Ponieważ jednak bycie liczbą ujemną może być równie złe, nie poszliśmy na to i jest to zalecana praktyka.

Pomyśl, jaki byłby wynik, gdybyśmy spróbowali odjąć 300 zamiast 100 z delayTime?

Więc teraz być może zdałeś sobie sprawę, że jeśli delayTime jest zapisywane jako mniejsze lub równe zero, to czas opóźnienia zostanie cofnięty do pierwotnej wartości 1000.

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

Ostatnie 4 wiersze kodu, jak pokazano powyżej, są odpowiedzialne za ciągłe włączanie / wyłączanie, włączanie / wyłączanie diody LED.

Tutaj możesz wyraźnie zauważyć, że zamiast używać liczby liczb, użyliśmy zmiennej do przypisania czasu opóźnienia, abyśmy mogli dostosować go tak, jak chcemy, podczas okresu działania kodu. To fajne, prawda?

2.3 Instrukcje ELSE

Tutaj dowiemy się, dlaczego i jak gdyby termin może mieć klauzulę jeszcze tak, że decyduje o sytuacji w przypadku gdyby stwierdzenie jest fałszywe.

Przepraszam, jeśli brzmi to zbyt zagmatwane, nie martw się, postaramy się to zrozumieć na następującym przykładzie:

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

Powyżej widać, że w dziesiątej linii kod jest wykonywany tylko wtedy, gdy delayTime jest mniejsza lub równa 100, jeśli nie, to wykonywany jest kod z 13. linii, ale oba razem nigdy nie mogą się zdarzyć, albo zostanie zaimplementowany kod 10. albo 13. linii, nigdy oba.

Być może zauważyłeś, że w przeciwieństwie do tego, co zrobiliśmy w poprzedniej sekcji 2.2, tutaj nie porównaliśmy z 0, a raczej z 100. Dzieje się tak, ponieważ w tym przykładzie porównanym PRZED odjęciem 100, przeciwnie w sekcji 2.2, porównaliśmy PO odjęte. Czy możesz powiedzieć, co by się stało, gdybyśmy porównali 0 zamiast 100?

2.4 Instrukcje WHILE

DO podczas oświadczenie jest dość podobne do gdyby instrukcja, z wyjątkiem prawdy, że powoduje ona powtarzające się wykonanie bloku kodu (który może znajdować się w nawiasach klamrowych) przez tak długo, że warunki mają zastosowanie, a to działa bez jeszcze komunikat.

Poniższy przykład pomoże ci to lepiej zrozumieć

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

Czy wiesz, do czego zaprogramowany jest powyższy kod? Cóż, jest przeznaczony do migania diody LED szybciej, a potem wolniej.

2.5 Co jest prawdą, a co fałszem?

W języku programowania fałszywy odnosi się do zera (0). W rzeczywistości „prawda” nie jest używana, zamiast tego przyjmuje się, że jeśli nic nie jest fałszywe, to wszystko, co jest zawarte, jest prawdą.

Wygląda to trochę dziwnie, ale całkiem nieźle spełnia swoje zadanie.

Postaramy się uchwycić sytuację za pomocą następującego przykładu.

Czasami możesz natknąć się na kod podany poniżej:

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

Jest to zakodowane, wygląda na to, że wykonanie diody LED będzie się cyklicznie powtarzać, dopóki dostępna jest długa moc.

Jednak jedna wada tego typu kodu może się pojawić, gdy użytkownik przypadkowo zastosuje znak = zamiast ==.

Jestem pewien, że już wiesz, że = oznacza przypisanie, co oznacza, że ​​jest używane do przypisania wybranej wartości do zmiennej, podczas gdy == służy do wymuszania testu, jeśli wartość była taka sama.

Na przykład przypuśćmy, że wymagasz, aby dioda LED migała z sekwencyjnym przyspieszeniem i powtarzalnie, ale niepoprawnie użyto = zamiast ==.

Kod wyglądałby wtedy następująco:

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
}

Błąd przypisze 0 do delayTime i doprowadzi do gdyby oświadczenie, aby sprawdzić, czy 0 było prawdziwe, czy nie. Ponieważ 0 odnosi się do fałszu, pomyśli, że to nieprawda i zatrzyma wymuszanie delayTime = 1000, ale zamiast tego funkcja delayTime jest utrzymywany na 0 podczas przebiegu pętli ().

To wygląda na bardzo niepożądane !!

Dlatego zawsze dokładnie sprawdzaj program, aby upewnić się, że nie popełniłeś żadnych takich głupich błędów.

2.6 Kombinacje

Czasami możesz poczuć potrzebę przetestowania wielu rzeczy razem. Na przykład możesz chcieć sprawdzić, czy zmienna znajduje się między dwiema liczbami. Chociaż można to zaimplementować za pomocą instrukcji if wiele razy, wygodniejsze może być użycie kombinacji logicznych w celu lepszego i łatwiejszego czytania.

Implementowanie kombinacji na warunkach logicznych można wykonać za pomocą 3 metod, jak pokazano w poniższej tabeli:

Byłoby interesujące wiedzieć, że operator NOT może pracować jako przełącznik dla zmiennej, która może być wyznaczona jako jedna z nich prawdziwe lub fałszywy (lub NISKA lub WYSOKA).

Poniższy przykład ilustruje warunek:

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

Tutaj ledState będzie NISKI, a następnie jak tylko ledState = !ledState zmieni się na WYSOKI. Następująca pętla spowoduje ledState być WYSOKIM, gdy ledState = !ledState jest niski.

2.7 Instrukcje FOR

Teraz postaramy się zrozumieć inną strukturę sterowania, która jest dla pętla. Może to być bardzo przydatne, gdy chcesz zaimplementować coś kilka razy.

Zrozummy to na następującym przykładzie:

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
}

Możesz znaleźć coś wyjątkowego w linii dla.

To jest kod i ++? . Jest to przydatne dla programistów, którzy są raczej leniwi i chcą implementować kodowanie za pomocą wygodnych skrótów

Powyższy termin jest znany jako operatory złożone, ponieważ ich zadaniem jest połączenie jednego operatora przypisania z innym operatorem przypisania. Najpopularniejsze z nich można zwizualizować w poniższej tabeli:

Przekonasz się, że w instrukcji for są 3 pod-oświadczenia. Ma strukturę pokazaną poniżej:

for (statement1conditionstatement2){
// statements
}

Instrukcja nr 1 pojawia się na samym początku i tylko raz. Stan jest każdorazowo sprawdzany w trakcie trwania pętli. Kiedykolwiek to jest prawdziwe wewnątrz nawiasów klamrowych egzekwowana jest kolejna instrukcja nr 2. W przypadku fałszywy, system przechodzi do następnego bloku kodu.

Podłączanie większej liczby diod LED

OK, teraz zobaczymy, jak możemy podłączyć większą liczbę LEdów, aby uzyskać bardziej interesujące efekty.

Podłącz diody LED i Arduino, jak pokazano poniżej. Czerwony przewód w rzeczywistości nie jest potrzebny, ale ponieważ zawsze dobrze jest mieć obie szyny zasilające w płytce prototypowej, konfiguracja ma sens.

Teraz naprawmy program, który pozwoli nam sprawdzić, czy nasz sprzęt jest poprawnie skonfigurowany, czy nie.

Zawsze zaleca się kodowanie i wykonywanie małych fragmentów programów krok po kroku, aby sprawdzić, czy odpowiednie oprogramowanie sprzętowe jest prawidłowo podłączone, czy nie.

Pomaga to szybko rozwiązać potencjalny błąd.

Poniższy przykład kodu przedstawia diodom LED od 2 do 5 określony wzór, obracając je jedna po drugiej w sposób cykliczny.

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

Jak możesz zauważyć, nie ma nic złego w kodzie, poza tym, że wygląda na długi i dlatego jest podatny na błędy.

Oczywiście istnieją lepsze sposoby na napisanie powyższego kodu, następna sekcja pokaże to.

2.9 Wprowadzenie do tablic

Tablice mogą być grupą zmiennych, które mogą być indeksowane numerami indeksu. Poniższy przykład pomoże nam to lepiej zrozumieć.

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

OK, teraz przejrzyjmy każdą sekcję i zrozummy, jak faktycznie działają.

const int k_numLEDs = 4

Powyższy kod definiuje ile maksymalnych elementów powinniśmy mieć w tablicy. Ten kod pomaga nam w kolejnych sekcjach, aby upewnić się, że wszystko jest zapisane w tablicy i nic po zakończeniu tablicy.

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

W następnym wierszu ustalamy strukturę tablicy. Liczby w nawiasach oznaczają liczbę elementów w tablicy. Chociaż rzeczywistą ilość można było zapisać, zapisywanie jako stałych działa lepiej. Wartości można zwykle zobaczyć w nawiasach za pomocą przecinków i przypisać wartości do tablicy.

Kiedy znajdziesz tablicę indeksowaną numerem 0, oznacza to pierwszy element tablicy, jak pokazano w code: k_LEDPins is k_LEDPins[0].

Podobnie ostatni element zostanie wyświetlony jako k_LEDPins[3], ponieważ liczba od 0 do 3 to 4.

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

Powyższy kod pokazuje użycie pętli do przechodzenia przez poszczególne elementy tablicy i ustawiania ich jako WYJŚCIA. Wdrażamy nawiasy kwadratowe wraz z indeksem, aby dotrzeć do każdego elementu tablicy.

jeśli zastanawiasz się, czy możliwe jest użycie pinu # 2 do pinu # 5 bez tablic, odpowiedź brzmi: tak, jest to możliwe. Ale w tym przykładzie nie jest to zrobione, ponieważ nie zrobiliśmy tego w ten sposób. W następnych sekcjach można wyeliminować podejście tablicowe, jeśli wybrane piny wyjściowe nie są w jednej linii.

Idąc dalej, zobaczmy, co robi następny blok kodu:

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

Tutaj kod przechodzi przez każdą z diod LED, aby włączyć je sekwencyjnie z przerwą lub opóźnieniem 100 milisekund.

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

Użycie powyższego kodu pokazuje, w jaki sposób aplikacja dla pętli może służyć do poruszania się po pętli nawet w odwrotnej kolejności.

Zaczyna się od k_numLEDs - 1, ponieważ tablice są indeksowane przez zero. Nie zaczynamy od k_LEDPins[4] ponieważ spowodowałoby to przekroczenie końca tablicy.

Kod używa> = 0 do sprawdzenia, czy pierwszy element pod indeksem 0 nie został pominięty ani zignorowany.

Rozdział 3

Co to jest wejście

Więc nauczyliśmy się obsługiwać rzeczy za pomocą Arduino. W tym rozdziale omówimy, jak wyczuwać świat rzeczywisty, łącząc dane wejściowe z parametrów zewnętrznych.

3.1 Korzystanie z przycisków

Wszyscy wiemy, czym jest przycisk i jak działa. Jest to rodzaj przełącznika lub przycisku, który chwilowo łączy sygnał z jednego stopnia obwodu do drugiego, gdy jest wciśnięty, i przerywa sygnał po zwolnieniu.

3.1.1 Jeden przycisk i dioda LED

Połączymy Arduino za pomocą przycisku z Arduino zgodnie z powyższymi szczegółami i nauczymy się podstaw działania i implementacji konfiguracji.

Wskazany przycisk, zwany także przyciskiem mikroprzełącznika, ma łącznie 4 piny (2 pary z każdej strony). Po wciśnięciu każda para kołków jest połączona wewnętrznie i umożliwia połączenie lub przewodzenie przez nie.

W tym przykładzie używamy tylko jednej pary tych pinów lub styków, druga para jest nieistotna i dlatego jest ignorowana.

Kontynuujmy, stosujemy następujący kod i sprawdźmy, jak działa!

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

Możesz znaleźć tutaj kilka rzeczy, które wyglądają niecodziennie. Rozwiążmy je krok po kroku.

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

Pierwszą rzeczą, którą robimy, jest naprawienie buttonPin jako WEJŚCIE. Wiem, że to dość proste.

Następnie przypisujemy WYSOKI do WEJŚCIE kołek. Zastanawiasz się, jak można cokolwiek napisać na wejściu? Jasne, to może być interesujące.

W rzeczywistości, przypisanie HIGH do wejścia Arduino włącza wewnętrzny rezystor podciągający 20k Ohm (NISKI na tym pinie wyłącza go).

Innym pytaniem, które możesz być, jest to, czym jest rezystor podciągający. Omówiłem obszerny post dotyczący rezystorów podciągających, które ty dowiedz się tutaj .

OK, przechodząc dalej, spójrzmy teraz na główny kod pętli:

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

Po naciśnięciu przycisku styk przewodowy zostaje połączony z masą, co daje efekt a NISKA do tego szpilki. W stanie nie wciśniętym ten sam kołek jest trzymany WYSOKI lub + 5V przez wewnętrzny rezystor podciągający 20K.

Tutaj chcemy, aby Arduino zapalał diodę LED po naciśnięciu przycisku (LOW), dlatego piszemy HIGH dla wyjścia dla każdej odpowiedzi LOW z przycisku, gdy jest wciśnięty.

3.1.2 Dwa przyciski i dioda LED

Cóż, możesz się zastanawiać, że powyższa akcja mogłaby zostać wykonana również bez Arduino. Rozumiem jednak, że jest to kamień do nauczenia się, jak przycisk może być używany z Arduno.

Do tego momentu studiowaliśmy pisanie kodów włączania (WYSOKI) lub wyłączania (NISKI) diody LED.

Zobaczmy teraz, jak można kontrolować jasność diody LED za pomocą Arduino.

Można to zrobić na dwa sposoby:

1. Ograniczając ilość prądu do diody LED
2. Używając PWM lub modulacja szerokości impulsu, w której zasilanie diody LED jest włączane / wyłączane bardzo szybko z pewną żądaną szybkością, wytwarzając średnie oświetlenie, którego intensywność zależy od PWM.

W płycie Arduino obsługa PWM jest dostępna na pinach oznaczonych tyldą (~), które są pinami 3, 4,5, 9,10 i 11) przy 500 Hz (500 razy na sekundę). Użytkownik może podać dowolną wartość od 0 do 255, gdzie 0 oznacza brak WYSOKIEGO lub brak + 5V, a 255 mówi Arduino, aby cały czas uzyskiwał WYSOKI lub + 5V. Aby zainicjować te polecenia, będziesz musiał uzyskać dostęp do analogWrite () z żądaną wartością.

Możesz założyć, że PWM to x / 255, gdzie x jest żądaną wartością, którą chcesz wysłać przez analogWrite().

Skonfiguruj Arduino i inne parametry, jak pokazano powyżej.

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

Możesz znaleźć tutaj 3 wiersze, które wymagają wyjaśnienia.

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

Linia: ledBrightness = constrain(ledBrightness, 0, 255) ilustruje unikalną funkcję wewnątrz Arduino znaną jako constrain ().

Ta funkcja wewnętrzna zawiera kod podobny do następującego:

int constrain (int value, int min, int max)
{
if(value > max){
value = max
}
if(value value = min
}
return value
}

Rozpoczęły się wszystkie omówione wcześniej kody unieważnić , co oznaczało, że niczego nie zwracasz (nieważne). Natomiast powyższy kod zaczyna się od int , co oznacza, że ​​zwraca liczbę całkowitą. Omówimy więcej w dalszych sekcjach, w tej chwili po prostu pamiętaj, że liczba całkowita nie ma żadnych części ułamkowych.

Tak, więc to sugeruje, kod: ledBrightness = constrain(ledBrightness, 0, 255) przypisuje ledBrightness to be within the range of 0 and 255.

Następna linia wykorzystuje analogWrite do poleceń Arduino, aby zastosować PWM na wybranym pinie z żądaną wartością.

Następna linia tworzy opóźnienie 20 milisekund, ma to na celu zapewnienie, że nie dostosujemy ate szybciej niż 50 Hz lub 50 razy na sekundę. Dzieje się tak, ponieważ ludzie mogą być znacznie wolniejsi niż Arduino. Stąd, jeśli opóźnienie nie zostało wykonane, program mógł sprawić, że poczuliśmy, że naciśnięcie pierwszego przycisku wyłącza diodę, a naciśnięcie drugiego włącza ją (spróbuj samodzielnie).

3.2 Potencjometry

Przejdźmy dalej i nauczmy się korzystać potencjometry z Arduino.

Aby dowiedzieć się, jak działa potencjometr lub potencjometr, możesz przeczytać to artykuł .

Połącz pokazane parametry z Arduino, jak pokazano powyżej.

Garnek będzie miał 3 zaciski. Środkowy terminasl połączy się z ANALOG IN 0 na Arduino. Pozostałe dwa zewnętrzne zaciski można podłączyć do szyn zasilających + 5V i 0V.

Zaprogramujmy i sprawdźmy wyniki:

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

Znajdziesz kilka rzeczy, które mogą wyglądać na zupełnie nowe i nie zostały uwzględnione w żadnym z naszych wcześniejszych kodów.

1. Stała kPinPot jest przypisany jako A0, gdzie A jest skrótem do opisania jednego z pinów analogowych. Jednak A0 odnosi się również do pinu # 14, A1 do pinu # 15 i tak dalej, co pozwala na użycie jako cyfrowych wejść / wyjść na wypadek, gdyby zabrakło pinów do eksperymentu. Pamiętaj jednak, że nie możesz używać pinów cyfrowych jako pinów analogowych.
2. Linia: ledBrightness = map(sensorValue, 0, 1023, 0, 255) przedstawia nową wewnętrzną funkcję w Arduino znaną jako mapa(). Ta funkcja dokonuje ponownej kalibracji z danego zakresu do innego, określanego jako map (wartość, fromLow, fromHigh, toLow, toHigh). Może to mieć kluczowe znaczenie, ponieważ analogueRead podaje wartość z zakresu 0–1023, ale analogWrite może przyjąć wartość z przedziału 0–255.

Można by pomyśleć, że skoro można sterować jasnością diody LED poprzez zmieniającą się rezystancję, po prostu do tego celu wystarczyłby garnek, dlaczego warto zastosować Arduino. Cóż, znowu to tylko podstawa, aby pokazać, jak można skonfigurować garnek z Arduino.

Żadnych problemów, teraz zrobimy coś, czego nie da się zrobić bez Arduino.

W tym eksperymencie zobaczymy, jak zmienny opór garnka można wykorzystać do kontrolowania szybkości migania lub częstotliwości diody LED.

Oto program:

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 Unikanie opóźnienia ()

Powyższy kod wygląda dobrze, ale dioda LED nie może sprawdzić wartości potencjometru, dopóki nie przejdzie przez każdy pełny cykl. W przypadku dłuższych opóźnień ten proces wydłuża się, użytkownik musi czekać, aby zobaczyć odpowiedź puli, gdy ją przesuwa. Opóźnienia tego można uniknąć dzięki inteligentnemu programowaniu, dzięki czemu użytkownik może sprawdzić wartość bez minimalnych opóźnień. Oto kod.

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

Więc czym różni się powyższy kod? Różnica jest następująca.

long lastTime = 0

Do tej sekcji dyskutowaliśmy o zmiennej int. Jednak może istnieć wiele innych typów zmiennych, do których można uzyskać dostęp. Listę można przeczytać poniżej:

Obecnie kluczowa może być tylko wiedza, że ​​do przechowywania stosunkowo dużych liczb dla plików int zmiennej, możesz użyć tego terminu długo lub a długi int.

Tutaj możesz zobaczyć inną interesującą funkcję o nazwie millis ().

Daje to przedział czasu w milisekundach, w którym Arduino pracował od początku (po każdych 50 dniach resetuje się do 0). Tutaj wraca długo, bo jeśli wrócił int , liczenie przez długie okresy może nie być możliwe. Czy możesz odpowiedzieć dokładnie, jak długo? Odpowiedź to 32,767 sekund.

Dlatego zamiast używać delay (), sprawdzamy millis (), a gdy tylko upłynie określona liczba milisekund, zmieniamy diodę LED. W związku z tym przechowujemy czas, w którym zmieniliśmy go ostatnio ostatni raz zmienna, dzięki czemu możemy ją ponownie sprawdzić w dowolnym momencie.

3.3 Diody LED RGB

Do tej pory bawiliśmy się jednokolorową diodą LED. Chociaż kolor diody LED można zmienić, zastępując diodę LED innym kolorem, ale co powiesz na użycie diod LED RGB do zmiany kolorów LED bez wymiany diod?

Dioda LED RGB to w zasadzie dioda LED z czerwoną, zieloną i niebieską diodą LED osadzoną i połączoną w jedną diodę LED. Ma jeden wspólny przewód, który idzie do masy lub szyny zasilającej 0V, podczas gdy pozostałe 3 przewody są zasilane zróżnicowanymi dodatnimi sygnałami PWM do realizacji zamierzonego mieszanie kolorów .

Możesz połączyć konfigurację, jak pokazano poniżej:

Może wyglądać na trochę skomplikowaną, ale w rzeczywistości jest to replika naszego wcześniejszego projektu sterowania diodami LED za pomocą PWM.

Oto przykładowy kod programu:

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

Po przesłaniu tego kodu zobacz, jak ustawienia garnków tworzą ciekawy efekt świetlny na RGB, może to być prawdziwa zabawa.

Przekonasz się, że gdy wszystkie 3 pule zostaną przesunięte o maksymalne pozycje, zamiast białego koloru zobaczysz czerwony. Dzieje się tak, ponieważ kolor czerwony jest najbardziej widoczny spośród 3 kolorów i dlatego dominuje w tej sytuacji. Możesz jednak eksperymentować z funkcją mapa() , przed wykonaniem go na czerwonej części diody LED, aby uzyskać bardziej rozsądną równowagę.

Dźwięk z Arduino

W tej sekcji dowiemy się, jak dodać podstawowy dźwięk i muzykę do konfiguracji Arduino.

Zobaczymy, jak przełączyć sygnał do podłączonego głośnika o żądanej częstotliwości.

Dokładniej, wypróbowana zostanie środkowa nuta A, która jest nutą częstotliwości 440 Hz.

Aby to zrobić, zagramy środkową nutę A i zoptymalizujemy sygnał sinusoidalny za pomocą fali prostokątnej.

Ponadto obliczymy czas, przez jaki głośnik może pozostawać WŁĄCZONY, korzystając ze wzoru:

timeDelay = 1 sekunda / 2 x toneFrequency.

timeDelay = 1 sekunda / 2 x 440

timeDelay = 1136 mikrosekund

4.1 Podłączmy płytkę Arduino

4.2 Dodawanie prostej notatki

Omówiliśmy już funkcję opóźnienie() gdzie jednostka jest w milisekundach (sekunda / 1000), jednak znajdziesz jeszcze inną funkcję delayMicroseconds() gdzie jednostka jest w mikrosekundach (milisekunda / 1000).

Dla obecnej konfiguracji programujemy kod włączający / wyłączający + 5V na wybranym pinie połączonym z głośnikiem, z częstotliwością 440 impulsów na sekundę.

Przypomnijmy, w ostatniej dyskusji ustaliliśmy wartość 1136 mikrosekund dla zamierzonej notatki dźwiękowej.

Oto program do tego, który pozwoli ci usłyszeć nutę audio 440 Hz, gdy tylko zaprogramujesz arduino z podłączonym głośnikiem.

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

Dzięki powyższej aplikacji możliwe jest wykonanie notatki dźwiękowej, co oznacza również, że możemy stworzyć muzykę według własnego wyboru.

Z kodu rozumiemy, że Arduino zawiera kilka zintegrowanych funkcji, które dodatkowo przyczyniają się do tworzenia muzyki.

Pierwszy to ton() który działa z 2 elementami wraz z trzecim opcjonalnym elementem, oznaczonym jako ton (pin, częstotliwość, czas trwania). lub ton (pin, częstotliwość)

Oba są przeznaczone do wykonania odpowiedniego okresu czasu wyznaczonego przez Ciebie.

W przypadku braku określonego czasu muzyka będzie odtwarzana do momentu połączenia ton() jest wykonywany ponownie lub do momentu wykonania niejeden ().

Należy to zrobić za pomocą funkcji opóźnienia, na wypadek gdyby odtwarzanie muzyki było jedyną podstawową rzeczą, którą wdrażasz.

Czas trwania może mieć kluczowe znaczenie, ponieważ pozwala określić czas, przez jaki muzyka jest odtwarzana, więc możesz swobodnie robić inne rzeczy. Gdy tylko upłynie czas trwania, muzyka się zatrzymuje.

Następna funkcja niejeden () obsługuje pojedynczy parametr i zatrzymuje wybrany ton na konkretnym przypisanym pinie.

Osobliwe ostrzeżenie: zawsze kiedy ton() funkcja jest zaimplementowana, funkcja PWM na pinach 3 i 11 przestanie działać.

Dlatego za każdym razem, gdy w programie używane jest złącze głośnikowe, nie używaj wspomnianego kołka do głośników, zamiast tego wypróbuj inne kołki do mocowania głośnika.

OK, więc oto program do implementacji muzyki na głośnik, chociaż nie jest to prawdziwa muzyka, a raczej podstawowa nuta 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)
}

W powyższym kodzie mogłeś zauważyć coś nowego i to jest #definiować .

Termin ten działa jak polecenie wyszukiwania i zamiany na komputerze podczas kompilacji.

Zawsze, gdy znajdzie pierwszą rzecz przed spacją, zastępuje ją pozostałą częścią wiersza (zwaną makrami).

Więc w tym przykładzie, gdy komputer widzi UWAGA_E4 szybko zastępuje go ilością 330.

Aby uzyskać więcej uwag i dostosowań, możesz odwołać się do pliku na swojej pamięci USB o nazwie boiska. h , gdzie większość częstotliwości można znaleźć według własnych preferencji.

4.4 Muzyka z funkcjami

Powyższy kod wygląda dobrze, ale wydaje się, że ma wiele powtórzeń, powinna istnieć metoda na skrócenie tych powtórzeń, prawda?

Do tej pory pracowaliśmy z dwiema podstawowymi funkcjami zawartymi w Arduino. Teraz może nadszedł czas, abyśmy stworzyli własne funkcje.

Każda funkcja musi zaczynać się od typu zmiennej, z którą może być powiązana. Na przykład function unieważnić odnosi się do typu, który nic nie zwraca, stąd nazwa void. Uwaga, omówiliśmy już listę zmiennych w naszych wcześniejszych sekcjach, możesz je odnieść.

W związku z tym nazwa funkcji otrzymuje otwarty nawias '(' po którym następuje lista parametrów oddzielonych przecinkami.

Każdy z parametrów uzyskuje swój typ wraz z nazwą, a na końcu zamknięcie ')' nawias.

Te parametry można zastosować w funkcji w postaci zmiennych.

Zobaczmy poniższy przykład, w którym tworzymy funkcję o nazwie ourTone () zaprojektowany do scalania ton() z opóźnienie() linie w taki sposób, że funkcja przestaje powracać, dopóki nuta nie zakończy odtwarzania tonu.

Implementujemy te funkcje w naszym poprzednim kodzie i otrzymujemy poniższy program, patrz ostatnie wiersze:

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

Funkcje mogą być bardzo przydatne, aby ułatwić zrozumienie programu.

Poniżej znajduje się przykład, w którym jesteśmy w stanie określić wybór brzmienia, który chcemy odtworzyć przy użyciu dwóch tablic. Jedna tablica do zachowywania nut, druga do zachowania beatów.

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

W pierwszym wierszu wyraźnie widać wprowadzenie #zawierać komunikat. Zadaniem tego oświadczenia jest pobranie całego pliku między cudzysłowami i umieszczenie go w pozycji #zawierać komunikat. Zgodnie ze standardowymi zasadami są one ściśle umieszczone na początku programu.

Rozdział 5

Pomiar temperatury

Dla przypomnienia, pamiętaj, zamiast pisać w ogóle duże programy, zawsze mądrze jest pisać i analizować małe części kodu, co pomaga w szybkim wyśledzeniu błędów.

5.1 Monitor szeregowy

Do tej pory omówione przez nas kody nie wydają się łatwiejsze do umożliwienia szybkiego rozwiązywania problemów. Tutaj postaramy się ułatwić monitorowanie i łatwiejsze rozwiązywanie ewentualnego problemu.

Arduino ma funkcję, która umożliwia mu „rozmowę” z komputerem. Można zauważyć, że pin0 i pin1 są oznaczone obok siebie jako RX i TX. Te styki są w rzeczywistości śledzone przez oddzielny układ scalony w Arduino, który aktualizuje je do odczytu przez kabel USB, gdy jest podłączony do komputera.

Poniższa sekcja przedstawia pełnoprawny program, przejdź przez niego, później dowiemy się o nowych wpisach w kodzie. Ten kod jest taki sam, jak podano w sekcji 2.2, z wyjątkiem faktu, że zawiera dodatkowe dane, które pozwalają nam zidentyfikować, do czego został zakodowany.

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

Możesz tu zidentyfikować dwie nowe rzeczy, nową linię w Ustawiać() funkcjonować.

Serial.begin(9600)

Ta linia po prostu wyraża konieczność użycia Serial1 kod wymuszający go z prędkością 9600 bodów. (tutaj numer seryjny dotyczy bity wysyłane jedna po drugiej, a baud oznacza szybkość z jaką jest wysyłana). Ta wartość transmisji i ta wewnątrz monitora szeregowego (dowiemy się o tym później) muszą być równe, w przeciwnym razie dane w monitorze szeregowym będą pokazywać śmieci. 9600 jako standard staje się wygodniejszy w użyciu.

Drugi nowy wpis jest następujący

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

Tutaj druga linia sugeruje, że następna rzecz wychodząca z portu szeregowego rozpocznie się w następnej linii. W ten sposób druga linia różni się od pierwszej.

Jeszcze jedną rzeczą, którą możesz zobaczyć, są cudzysłowy ('). Nazywa się to ciągiem znaków, który będzie tutaj używany tylko jako stałe, ponieważ dalsza dyskusja na ten temat może być zbyt skomplikowana i wykraczająca poza zakres.

OK, możemy teraz wgrać powyższy kod do Arduino i zobaczyć, co się stanie.

Co, ojej, nic się nie wydarzyło, dioda LED Arduino nr 13 zamrugała i zatrzymała się, podczas gdy dioda LED Tx nadal migała.

Cóż, to dlatego, że okno monitora szeregowego nie zostało jeszcze naprawione.

Musisz kliknąć pole monitora szeregowego w swoim IDE, jak pokazano powyżej. Nie zapomnij sprawdzić szybkości transmisji znajdującej się w prawym dolnym rogu, domyślnie powinna wynosić 9600 i będzie zgodna z kodem. Jeśli tak nie jest, wybierz 9600.

Poniższy klip wideo wyjaśnia, jak to się robi.

Przejdźmy teraz dalej i dowiedzmy się, jak powyższa funkcja monitora szeregowego może pomóc w przetwarzaniu plików pomiar temperatury za pomocą Arduino

Jako czujnik temperatury użyjemy IC TMP36 o zakresie od -40 do 150 stopni Celsjusza.

Konfigurację można zobaczyć poniżej:

Poniższy kod zainicjuje pomiar temperatury poprzez odczytanie wyjścia z czujnika TMP36 i wysłanie ich do szeregowego monitora ID.

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
}

Rozumiemy kod od góry.

float temperatureC = getTemperatureC()

Tutaj widać, że włączyliśmy typ zmiennej pływak.

Jest to jedyny typ zmiennej, który umożliwia przechowywanie wszystkiego oprócz liczb całkowitych (liczb bez części dziesiętnych lub ułamkowych).

Dokładność zmiennej typu float może wynosić od 6 do 7 cyfr.

Przylegający kod getTemperatureC() to nasza własna funkcja, która oblicza matematycznie i przekształca odczytaną różnicę napięcia z czujnika TMP36 na stopnie Celsjusza.

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
}

W następnej sekcji kodów, ponieważ termin analogIn() jest przypisany do zwracania liczby od 1 do 1023, staje się możliwe oszacowanie napięcia z czujnika poprzez pomnożenie naszego odczytu przez 5, a następnie podzielenie go przez 1024.

Czujnik TMP36 ma generować 0,5 V przy 0 stopniach Celsjusza, a następnie generuje 10 mV na każdy pojedynczy wzrost stopnia Celsjusza.

Oto przybliżenie, które jesteśmy w stanie wygenerować za pomocą obliczeń:

Możesz uznać, że jest to Twoja pierwsza funkcja zwracająca jakąś wartość (zwróć uwagę, że wszystkie pozostałe funkcje do tej pory nie zwróciły żadnej wartości, ponieważ były typu unieważnić ).

Możesz zrozumieć, że aby uzyskać wartość z funkcji, wystarczy dodać powrót a następnie żądany numer, który chcesz zwrócić.

Kiedy mówimy powrót oznacza to, że funkcja zwraca odpowiedź lub odpowiedź za każdym razem, gdy jest wywoływana, co można zastosować do zmiennej.

Gdy jest wysyłany do monitora szeregowego, odczyt jest konwertowany na stopnie Fahrenheita convertToF ().

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

Ta funkcja podnosi zakres Celsjusza i konwertuje go na Fahrenheita.

Aby przeliczyć stopnie Fahrenheita na stopnie Celsjusza, stosujemy wzór Fahrenheit = 9 / 5 (Celsjusza) + 32.

5.3 Łączenie z LCD

Teraz przyjrzyjmy się, jak interfejs lub połączenie wyświetlacz LCD z Arduino w celu uzyskania wizualnego wyświetlania wymaganych wyjść.

W naszej aplikacji zastosujemy graficzny wyświetlacz LCD 84x48, posiadający 84 piksele lub punkty w poziomie i 48 pikseli w pionie. Ponieważ dedykowany kontroler staje się konieczny dla wszystkich wyświetlaczy LCD, obecne urządzenie zawiera również kontroler w postaci kontrolera PCD8544.

W tym samouczku połączymy wyżej określony moduł LCD z Arduino i zastosujemy określone procedury do tworzenia wiadomości tekstowych na wyświetlaczu.

Na poniższym rysunku można znaleźć szczegóły dotyczące interfejsu wyświetlacza LCD, wraz z małym Regulator napięcia 3,3 V. . Ten regulator jest niezbędny, ponieważ wyświetlacz LCD jest przeznaczony do pracy z zasilaniem 3,3 V.

Możesz również zobaczyć 8 pinów z modułu LCD, specyfikacje pinów można sprawdzić w poniższej tabeli:

Zobaczmy teraz, jak możemy połączyć wyświetlacz LCD i odpowiednie parametry z naszym Arduino. Szczegóły można zwizualizować na poniższej ilustracji:

5.4 Komunikacja z LCD

Chociaż możliwe jest napisanie skomplikowanych programów koedukacyjnych do interakcji z LCD z Arduino, raczej nauczymy się, jak zrobić to samo za pomocą bibliotek.

Biblioteki obejmują asortyment kodów, które można szybko zastosować do wybranego programu Arduino.

Umożliwia to użytkownikowi bezproblemowe wywoływanie funkcji bez konieczności wykonywania skomplikowanych prac związanych z kodowaniem.

5.4.1 Jak zainstalować bibliotekę

W tym celu musisz utworzyć katalog zwany bibliotekami w swoim komputerze Arduino IDE, jak wyjaśniono tutaj

5.4.2 Wdrażanie operacji LCD

Tak jak w poprzednim podejściu, najpierw sprawdzimy cały kod, a następnie spróbujemy zrozumieć szczegóły poszczególnych wierszy.

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

Linia zawiera kod #include

Kod #include nakazuje komputerowi pobranie wspomnianego pliku i zastąpienie elementu #include zawartością pliku podczas kompilowania programu.

Element #include może zawierać nawiasy ostre, które wskazują na przeszukiwanie katalogu biblioteki, lub też może zawierać cudzysłowy, co oznacza poszukiwanie w tym samym katalogu, w którym znajduje się program.

Kolejne linie kodu wyrażają wyprowadzenia LCD, a następnie piszemy nową postać zmiennej:

PCD8544 lcd(kPin_CLK, kPin_DIN, kPin_DC, kPin_RESET)

Tutaj wyrażamy zmienną o nazwie lcd mającej typ PCD8544 i poinstruujemy komputer PC, aby przestawił swoje wyprowadzenia związane z Arduino.

W tym procesie opisujemy zmienną komputerowi PC, instruując, w jaki sposób pin clk, din, dc i reset są połączone z Arduino.

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

Linia lcd.init() inicjalizuje działanie wyświetlacza LCD. Po wykonaniu tej czynności następna linia wymusza umieszczenie kursora w lewym górnym rogu wyświetlacza. Następna kolejna linia próbuje wydrukować komunikat „Hello, World”.

Wygląda to całkiem identycznie jak technika, w której wysyłaliśmy wiadomości przez monitor szeregowy. Jedyną różnicą jest użycie kodu lcd.print zamiast serial.print.

Następny blok kodu jest faktycznie wywoływany powtarzalnie.

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

Używając tej linii lcd.setCursor(0,1) ustawiamy kursor w zerowej kolumnie po lewej stronie pierwszego rzędu, nad wyświetlaczem LCD.

Następna linia zawiera skrót: lcd.print(millis())

Jeśli pamiętasz, pracowaliśmy z millis() w naszych wcześniejszych kodach mogliśmy zastosować to samo również tutaj za pomocą kodów:

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

Jednak ze względu na fakt, że nie ma tutaj okresów w milisekundach, dlatego osiągamy to, wysyłając po prostu millis() działają bezpośrednio na lcd.print() .

5.5 Łączenie całości

OK, teraz połączmy wszystkie kody, których nauczyliśmy się powyżej, aby wykonać obwód temperatury LCD i zobaczmy, jak to wygląda:

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

W powyższym programie wszystko wygląda standardowo, z wyjątkiem użycia funkcji setCursor () . Ma to na celu wyrównanie tekstu tak daleko, jak to możliwe, wokół środka wyświetlacza.

Świetny! Gratulacje, właśnie zaprogramowałeś swój własny mały wskaźnik temperatury LCD za pomocą Arduino.

Praktyczne aplikacje Arduino

Ponieważ w tym miejscu szczegółowo omówiliśmy różne techniki programowania, nadszedł czas, aby wypróbować je, stosując je w kilku przydatnych praktycznych implementacjach.

Zaczniemy od czujników i zobaczymy, jak urządzenia czujnikowe mogą być używane z Arduino, wykonując kilka przykładowych kodów.

7.1 Wprowadzenie do czujników

W tym samouczku dowiemy się o szerokiej gamie czujników, których można używać z Arduino. Mogą to być urządzenia takie jak czujnik światła LDR, magnetyczny czujnik halla, czujniki pochylenia, czujnik wibracji, czujnik ciśnienia itp.

Zaczniemy od interfejsu czujnik światła LDR z Arduino, jak pokazano na poniższym schemacie:

Jak wszyscy wiemy, LDR to zależne od światła urządzenie rezystorowe, którego rezystancja zależy od natężenia padającego na jego powierzchnię otoczenia.

Natężenie światła jest odwrotnie proporcjonalne do odczytu rezystancji LDR.

Tutaj dowiemy się, jak tę właściwość można zintegrować z Arduino w celu wykonania użytecznej aplikacji:

Pełny kod programu można zwizualizować, jak podano poniżej:

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

Wszystkie parametry użyte w kodzie zostały już omówione w naszym kursie, którego się do tej pory nauczyliśmy. Możesz sprawdzić wiersze, odwołując się do odpowiednich sekcji.

Wartości zostały wybrane losowo, możesz je łatwo zmienić według własnych preferencji.

Czujnik pochylenia

Czujnik pochylenia to proste urządzenie, którego można użyć do wykrycia przechylenia dowolnego obiektu, na którym jest zainstalowany. Urządzenie w zasadzie ma wewnątrz metalową kulkę, która przechylając się toczy po parze styków, powodując przewodzenie przez te styki. Te styki, zakończone jako przewody przełącznika przechyłu, są używane z zewnętrznym obwodem do wykrywania przewodzenia w wyniku działania przechylania i aktywowania żądanego zastosowania wyjściowego.

Zobaczmy teraz, jak plik czujnik pochylenia urządzenie można podłączyć. Poniższy obraz daje nam wyobrażenie o pełnej konfiguracji:

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

W tym przykładzie domyślna dioda LED styku nr 13 jest używana jako wskaźnik nachylenia.

Wyraźnie widać tutaj włączenie rezystora podciągającego, całkiem podobne do tego, co zrobiliśmy w sekcji 3.1. Dlatego termin LOW wskazuje, że funkcja pochylenia nie jest wyzwalana.

7.4 Przekaźnik kontaktronowy (przekaźnik aktywowany magnesem miniaturowym)

Zobaczmy teraz, jak podłączyć przełącznik przekaźnika lub czujnik pola magnetycznego do Arduino. Kontaktron to rodzaj przełącznika, który aktywuje się lub przewodzi, gdy zbliża się do niego pole magnetyczne lub magnes. Zasadniczo ma parę styków ferromagnetycznych wewnątrz miniaturowej szklanej obudowy, które łączą się lub stykają z powodu przyciągania magnetycznego, gdy magnes znajduje się blisko niego. W takim przypadku zaciski styków wykazują przewodzenie w wyniku zamknięcia styków.

Tutaj również używamy diody LED pinu # 13 do wskazywania odpowiedzi. W razie potrzeby możesz podłączyć zewnętrzną diodę LED z tego pinu, zgodnie z naszymi wcześniejszymi wyjaśnieniami.

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

Terminy kodowe powinny być znane i oczywiste.

7.5 Czujnik drgań wykorzystujący przetwornik piezoelektryczny

W następnym przykładowym programie zobaczymy, jak plik przetwornik piezoelektryczny może służyć jako czujnik drgań do podświetlenia diody LED przez Arduino.

Element piezo w rzeczywistości jest urządzeniem, które generuje wibracje lub oscylacje, gdy częstotliwość jest przyłożona do jego końcówek. Jednak to samo piezo może być użyte w odwrotnym procesie generowanie impulsów elektrycznych w odpowiedzi na wibracje działające na jego ciało. Ta wibracja może mieć postać uderzenia lub uderzenia w powierzchnię piezo.

Skonfiguruj Arduino i element piezo, jak pokazano na poniższym rysunku

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

Próg 100 jest wprowadzany tylko po to, aby upewnić się, że Arduino reaguje tylko na prawdziwe wibracje poprzez uderzenia, a nie na inne mniejsze wibracje, takie jak głośne dźwięki lub klaksony.

Wybór pinu A5 nie jest obowiązkowy, można wybrać dowolne inne wejścia analogowe według własnych preferencji i dopasowując je w kodzie programu.

Używanie silnika serwo z Arduino

Silnik serwo to rodzaj silnika prądu stałego, który można obracać pod precyzyjnymi kątami zgodnie z wymaganiami konkretnego zastosowania. Można to zrobić poprzez zastosowanie obliczonego polecenia do odpowiednich wejść silnika, aby uzyskać dokładny kąt obrotu lub obrotu w zakresie 180 stopni na silniku.

Zazwyczaj silnik serwo ma 3 przewody lub wejścia. Przewody dodatnie są zwykle koloru czerwonego, przewód ujemny lub uziemienia jest czarny, a przewód sterujący lub przewód sygnalizacyjny ma zwykle kolor biały lub żółty.

Arduino ułatwia sterowanie serwomotorem poprzez wbudowany język wsparcia, co sprawia, że ​​sterowanie jest bardzo wygodne i idealne dla serwomotorów.

Poniższy przykład pokaże nam podstawowy program konfiguracyjny do implementacji sterowania serwomotorem przez Arduino:

Kod jest podany poniżej:

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

Widzimy tutaj kilka nowych wpisów. Taką, która mówi dołączonemu przewodowi serwomechanizmu do którego pinu jest przypisany. Drugi to kod, który podaje pinowi wartość z zakresu od 0 do 180 do określenia kąta obrotu serwomechanizmu.

Wniosek

Temat Arduino może być nieskończenie długi, a zatem wykraczający poza zakres tego artykułu. Mam jednak nadzieję, że powyższy samouczek z pewnością pomógł ci w nauce podstaw Arduino i zrozumieniu ważnych parametrów poprzez różne przykładowe kody aplikacji.

Miejmy nadzieję, że więcej informacji może być od czasu do czasu aktualizowanych tutaj, gdy tylko będą dostępne.

W międzyczasie ciesz się kursem programowania, Happy Arduinoing to you !!