Arduino - Szybki przewodnik

Arduino to platforma prototypowa (open-source) oparta na łatwym w obsłudze sprzęcie i oprogramowaniu. Składa się z płytki drukowanej, którą można zaprogramować (nazywanej mikrokontrolerem) oraz gotowego oprogramowania o nazwie Arduino IDE (Integrated Development Environment), które służy do zapisywania i przesyłania kodu komputerowego na płytkę fizyczną.

Kluczowe cechy to -

• Płytki Arduino są w stanie odczytać analogowe lub cyfrowe sygnały wejściowe z różnych czujników i przekształcić je w wyjście, takie jak aktywacja silnika, włączanie / wyłączanie diody LED, łączenie się z chmurą i wiele innych działań.

• Możesz kontrolować funkcje swojej płytki, wysyłając zestaw instrukcji do mikrokontrolera na płycie za pośrednictwem Arduino IDE (określanego jako oprogramowanie do ładowania).

• W przeciwieństwie do większości poprzednich programowalnych płytek drukowanych, Arduino nie potrzebuje dodatkowego sprzętu (zwanego programatorem) w celu załadowania nowego kodu na płytkę. Możesz po prostu użyć kabla USB.

• Dodatkowo Arduino IDE wykorzystuje uproszczoną wersję C ++, co ułatwia naukę programowania.

• Wreszcie Arduino zapewnia standardowy współczynnik kształtu, który dzieli funkcje mikrokontrolera w bardziej dostępny pakiet.

Rodzaje tablic

Dostępne są różne rodzaje płyt Arduino w zależności od zastosowanych mikrokontrolerów. Jednak wszystkie płyty Arduino mają jedną wspólną cechę: są programowane przez Arduino IDE.

Różnice zależą od liczby wejść i wyjść (liczby czujników, diod LED i przycisków, których można użyć na jednej płycie), prędkości, napięcia roboczego, współczynnika kształtu itp. Niektóre karty są zaprojektowane do wbudowania i nie mają programowania interfejs (sprzęt), który musiałbyś kupić osobno. Niektóre mogą działać bezpośrednio z akumulatora 3,7 V, inne potrzebują co najmniej 5 V.

Oto lista różnych dostępnych płyt Arduino.

Arduino boards based on ATMEGA328 microcontroller

Nazwa forum	Napięcie robocze	Szybkośc zegara	Cyfrowe we / wy	Wejścia analogowe	PWM	UART	Interfejs programowania
Arduino Uno R3	5V	16 MHz	14	6	6	1	USB przez ATMega16U2
Arduino Uno R3 SMD	5V	16 MHz	14	6	6	1	USB przez ATMega16U2
Czerwona tablica	5V	16 MHz	14	6	6	1	USB przez FTDI
Arduino Pro 3,3 V / 8 MHz	3,3 V.	8 MHz	14	6	6	1	Nagłówek zgodny z FTDI
Arduino Pro 5 V / 16 MHz	5V	16 MHz	14	6	6	1	Nagłówek zgodny z FTDI
Arduino mini 05	5V	16 MHz	14	8	6	1	Nagłówek zgodny z FTDI
Arduino Pro mini 3,3 V / 8 MHz	3,3 V.	8 MHz	14	8	6	1	Nagłówek zgodny z FTDI
Arduino Pro mini 5V / 16MHz	5V	16 MHz	14	8	6	1	Nagłówek zgodny z FTDI
Arduino Ethernet	5V	16 MHz	14	6	6	1	Nagłówek zgodny z FTDI
Arduino Fio	3,3 V.	8 MHz	14	8	6	1	Nagłówek zgodny z FTDI
Płyta główna LilyPad Arduino 328	3,3 V.	8 MHz	14	6	6	1	Nagłówek zgodny z FTDI
Prosta płytka LilyPad Arduino	3,3 V.	8 MHz	9	4	5	0	Nagłówek zgodny z FTDI

Arduino boards based on ATMEGA32u4 microcontroller

Nazwa forum	Napięcie robocze	Szybkośc zegara	Cyfrowe we / wy	Wejścia analogowe	PWM	UART	Interfejs programowania
Arduino Leonardo	5V	16 MHz	20	12	7	1	Natywne USB
Pro micro 5V / 16MHz	5V	16 MHz	14	6	6	1	Natywne USB
Pro micro 3,3 V / 8 MHz	5V	16 MHz	14	6	6	1	Natywne USB
LilyPad Arduino USB	3,3 V.	8 MHz	14	6	6	1	Natywne USB

Arduino boards based on ATMEGA2560 microcontroller

Nazwa forum	Napięcie robocze	Szybkośc zegara	Cyfrowe we / wy	Wejścia analogowe	PWM	UART	Interfejs programowania
Arduino Mega 2560 R3	5V	16 MHz	54	16	14	4	USB przez ATMega16U2B
Mega Pro 3,3 V.	3,3 V.	8 MHz	54	16	14	4	Nagłówek zgodny z FTDI
Mega Pro 5V	5V	16 MHz	54	16	14	4	Nagłówek zgodny z FTDI
Mega Pro Mini 3,3 V.	3,3 V.	8 MHz	54	16	14	4	Nagłówek zgodny z FTDI

Arduino boards based on AT91SAM3X8E microcontroller

Nazwa forum	Napięcie robocze	Szybkośc zegara	Cyfrowe we / wy	Wejścia analogowe	PWM	UART	Interfejs programowania
Arduino Mega 2560 R3	3,3 V.	84 MHz	54	12	12	4	Natywny USB

W tym rozdziale poznamy różne komponenty na płycie Arduino. Przeanalizujemy płytkę Arduino UNO, ponieważ jest to najpopularniejsza płytka w rodzinie płyt Arduino. Ponadto jest to najlepsza płytka do rozpoczęcia pracy z elektroniką i kodowaniem. Niektóre płyty wyglądają nieco inaczej niż ta podana poniżej, ale większość Arduino ma większość tych elementów wspólnych.

	Power USB Płytkę Arduino można zasilać za pomocą kabla USB z komputera. Wszystko, co musisz zrobić, to podłączyć kabel USB do złącza USB (1).
	Power (Barrel Jack) Płytki Arduino mogą być zasilane bezpośrednio z zasilacza sieciowego AC poprzez podłączenie go do gniazda Barrel Jack (2).
	Voltage Regulator Zadaniem regulatora napięcia jest kontrola napięcia podawanego na płytkę Arduino oraz stabilizacja napięć stałych wykorzystywanych przez procesor i inne elementy.
	Crystal Oscillator Oscylator kwarcowy pomaga Arduino w radzeniu sobie z problemami z czasem. Jak Arduino oblicza czas? Odpowiedź brzmi: używając oscylatora kwarcowego. Liczba wydrukowana na górze kryształu Arduino to 16.000H9H. Mówi nam, że częstotliwość wynosi 16 000 000 herców lub 16 MHz.
	Arduino Reset Możesz zresetować swoją płytkę Arduino, czyli uruchomić program od początku. Możesz zresetować płytę UNO na dwa sposoby. Najpierw za pomocą przycisku resetowania (17) na płycie. Po drugie, możesz podłączyć zewnętrzny przycisk resetowania do pinu Arduino oznaczonego RESET (5).
	Pins (3.3, 5, GND, Vin) 3,3 V (6) - Dostarcz napięcie wyjściowe 3,3 V 5 V (7) - Zasilanie 5 woltów wyjściowych Większość komponentów używanych z płytą Arduino działa dobrze przy napięciu 3,3 V i 5 V. GND (8) (masa) - Na Arduino znajduje się kilka pinów GND, z których każdy może być użyty do uziemienia obwodu. Vin (9) - Ten pin może być również używany do zasilania płyty Arduino z zewnętrznego źródła zasilania, takiego jak zasilacz sieciowy AC.
	Analog pins Płyta Arduino UNO ma sześć analogowych pinów wejściowych od A0 do A5. Piny te mogą odczytywać sygnał z czujnika analogowego, takiego jak czujnik wilgotności lub czujnik temperatury, i konwertować go na wartość cyfrową, która może być odczytana przez mikroprocesor.
	Main microcontroller Każda płytka Arduino ma własny mikrokontroler (11). Możesz założyć, że to mózg twojej tablicy. Główny układ scalony (układ scalony) w Arduino różni się nieco w zależności od płytki. Mikrokontrolery są zwykle firmy ATMEL. Musisz wiedzieć, jaki układ scalony ma twoja płyta, zanim załadujesz nowy program z Arduino IDE. Te informacje są dostępne w górnej części IC. Więcej informacji na temat konstrukcji i funkcji układu scalonego można znaleźć w arkuszu danych.
	ICSP pin Głównie ICSP (12) to AVR, mały nagłówek programistyczny dla Arduino składający się z MOSI, MISO, SCK, RESET, VCC i GND. Jest często określany jako SPI (Serial Peripheral Interface), który można uznać za „rozszerzenie” wyjścia. Właściwie podporządkowujesz urządzenie wyjściowe do mastera magistrali SPI.
	Power LED indicator Ta dioda LED powinna zaświecić się po podłączeniu Arduino do źródła zasilania, aby wskazać, że płyta jest prawidłowo zasilana. Jeśli ta lampka się nie włącza, oznacza to, że coś jest nie tak z połączeniem.
	TX and RX LEDs Na swojej płycie znajdziesz dwie etykiety: TX (nadawanie) i RX (odbiór). Pojawiają się w dwóch miejscach na płycie Arduino UNO. Najpierw na pinach cyfrowych 0 i 1, aby wskazać piny odpowiedzialne za komunikację szeregową. Po drugie, diody TX i RX (13). Dioda TX miga z różną prędkością podczas wysyłania danych szeregowych. Szybkość flashowania zależy od szybkości transmisji używanej przez kartę. RX miga podczas odbierania.
	Digital I/O Płyta Arduino UNO ma 14 cyfrowych pinów I / O (15) (z których 6 zapewnia wyjście PWM (modulacja szerokości impulsu). Piny te mogą być skonfigurowane do pracy jako wejściowe piny cyfrowe do odczytu wartości logicznych (0 lub 1) lub jako cyfrowe piny wyjściowe do sterowania różnymi modułami, takimi jak diody LED, przekaźniki itp. Piny oznaczone „~” mogą służyć do generowania PWM.
	AREF AREF oznacza analogowe odniesienie. Czasami jest używany do ustawiania zewnętrznego napięcia odniesienia (między 0 a 5 V) jako górnej granicy dla pinów wejścia analogowego.

Po zapoznaniu się z głównymi częściami płyty Arduino UNO, jesteśmy gotowi, aby dowiedzieć się, jak skonfigurować Arduino IDE. Gdy się tego dowiemy, będziemy gotowi do wgrania naszego programu na płytę Arduino.

W tej sekcji w prostych krokach dowiemy się, jak skonfigurować Arduino IDE na naszym komputerze oraz przygotować płytkę do odbioru programu przez kabel USB.

Step 1- Najpierw musisz mieć swoją płytkę Arduino (możesz wybrać swoją ulubioną płytkę) i kabel USB. Jeśli używasz Arduino UNO, Arduino Duemilanove, Nano, Arduino Mega 2560 lub Diecimila, będziesz potrzebować standardowego kabla USB (wtyczka A do wtyczki B), takiego rodzaju, jaki można podłączyć do drukarki USB, jak pokazano na poniższym obrazku.

Jeśli używasz Arduino Nano, będziesz potrzebować kabla A do Mini-B, jak pokazano na poniższym obrazku.

Step 2 − Download Arduino IDE Software.

Możesz pobrać różne wersje Arduino IDE ze strony pobierania na oficjalnej stronie Arduino. Musisz wybrać oprogramowanie, które jest zgodne z Twoim systemem operacyjnym (Windows, IOS lub Linux). Po zakończeniu pobierania pliku rozpakuj plik.

Step 3 − Power up your board.

Arduino Uno, Mega, Duemilanove i Arduino Nano automatycznie pobierają energię z połączenia USB do komputera lub zewnętrznego zasilacza. Jeśli używasz Arduino Diecimila, musisz upewnić się, że płyta jest skonfigurowana do pobierania energii z połączenia USB. Źródło zasilania jest wybierane za pomocą zworki, małego kawałka plastiku, który pasuje do dwóch z trzech pinów między USB a gniazdem zasilania. Sprawdź, czy znajduje się na dwóch pinach znajdujących się najbliżej portu USB.

Podłącz płytkę Arduino do komputera za pomocą kabla USB. Powinna zaświecić się zielona dioda LED zasilania (oznaczona PWR).

Step 4 − Launch Arduino IDE.

Po pobraniu oprogramowania Arduino IDE należy rozpakować folder. W folderze znajduje się ikona aplikacji z etykietą nieskończoności (application.exe). Kliknij dwukrotnie ikonę, aby uruchomić IDE.

Step 5 − Open your first project.

Po uruchomieniu oprogramowania masz dwie opcje -

• Utwórz nowy projekt.
• Otwórz przykład istniejącego projektu.

Aby utworzyć nowy projekt, wybierz Plik → New.

Aby otworzyć istniejący przykład projektu, wybierz Plik → Przykład → Podstawy → Miga.

Tutaj wybieramy tylko jeden z przykładów z nazwą Blink. Włącza i wyłącza diodę LED z pewnym opóźnieniem. Możesz wybrać dowolny inny przykład z listy.

Step 6 − Select your Arduino board.

Aby uniknąć błędu podczas wgrywania programu na płytkę, musisz wybrać poprawną nazwę płytki Arduino, która pasuje do płytki podłączonej do komputera.

Przejdź do Narzędzia → Tablica i wybierz swoją tablicę.

Tutaj wybraliśmy płytkę Arduino Uno zgodnie z naszym samouczkiem, ale musisz wybrać nazwę pasującą do płyty, której używasz.

Step 7 − Select your serial port.

Wybierz urządzenie szeregowe płyty Arduino. Iść doTools → Serial Portmenu. Prawdopodobnie będzie to port COM3 lub nowszy (porty COM1 i COM2 są zwykle zarezerwowane dla sprzętowych portów szeregowych). Aby się tego dowiedzieć, możesz odłączyć płytę Arduino i ponownie otworzyć menu, wpis, który zniknie, powinien znajdować się na płycie Arduino. Podłącz ponownie kartę i wybierz ten port szeregowy.

Step 8 − Upload the program to your board.

Zanim wyjaśnimy, w jaki sposób możemy wgrać nasz program na płytkę, musimy zademonstrować funkcję każdego symbolu pojawiającego się na pasku narzędzi Arduino IDE.

A - Służy do sprawdzania, czy jest jakiś błąd kompilacji.

B - Służy do wgrywania programu do płyty Arduino.

C - Skrót używany do tworzenia nowego szkicu.

D - Służy do bezpośredniego otwierania jednego z przykładowych szkiców.

E - Służy do zapisywania szkicu.

F - Monitor szeregowy używany do odbierania danych szeregowych z karty i wysyłania danych szeregowych do karty.

Teraz wystarczy kliknąć przycisk „Prześlij” w środowisku. Poczekaj kilka sekund; na płycie będą migać diody RX i TX. Jeśli przesyłanie się powiedzie, na pasku stanu pojawi się komunikat „Przesyłanie zakończone”.

Note - Jeśli masz Arduino Mini, NG lub inną płytkę, musisz fizycznie nacisnąć przycisk resetowania na płytce, bezpośrednio przed kliknięciem przycisku przesyłania w oprogramowaniu Arduino.

W tym rozdziale dogłębnie zbadamy strukturę programu Arduino i poznamy więcej nowych terminologii używanych w świecie Arduino. Oprogramowanie Arduino jest oprogramowaniem typu open source. Kod źródłowy środowiska Java jest udostępniany na licencji GPL, a biblioteki mikrokontrolerów C / C ++ objęte są licencją LGPL.

Sketch - Pierwsza nowa terminologia to program Arduino o nazwie „sketch”.

Struktura

Programy Arduino można podzielić na trzy główne części: Structure, Values (zmienne i stałe) oraz Functions. W tym samouczku dowiemy się krok po kroku o oprogramowaniu Arduino i jak możemy napisać program bez błędów składni lub kompilacji.

Zacznijmy od Structure. Struktura oprogramowania składa się z dwóch głównych funkcji -

• Funkcja Setup ()
• Funkcja Loop ()

Void setup ( ) {

}

• PURPOSE - The setup()funkcja jest wywoływana, gdy rozpoczyna się szkic. Służy do inicjalizacji zmiennych, trybów pinów, rozpoczęcia korzystania z bibliotek itp. Funkcja konfiguracji zostanie uruchomiona tylko raz, po każdym włączeniu lub zresetowaniu płyty Arduino.

• INPUT - -

• OUTPUT - -

• RETURN - -

Void Loop ( ) {

}

• PURPOSE - Po utworzeniu pliku setup() funkcja, która inicjuje i ustawia wartości początkowe, plik loop()function robi dokładnie to, co sugeruje jego nazwa, i wykonuje pętle po kolei, umożliwiając programowi zmianę i reakcję. Użyj go, aby aktywnie sterować płytą Arduino.

• INPUT - -

• OUTPUT - -

• RETURN - -

Typy danych w C odnoszą się do rozbudowanego systemu używanego do deklarowania zmiennych lub funkcji różnych typów. Typ zmiennej określa, ile miejsca zajmuje ona w pamięci i jak jest interpretowany przechowywany wzór bitowy.

Poniższa tabela zawiera wszystkie typy danych, których będziesz używać podczas programowania Arduino.

unieważnić	Boolean	zwęglać	Niepodpisany znak	bajt	int	Unsigned int	słowo
długo	Długo bez znaku	krótki	pływak	podwójnie	szyk	Tablica ciągów znaków	Obiekt łańcuchowy

unieważnić

Słowo kluczowe void jest używane tylko w deklaracjach funkcji. Wskazuje, że funkcja nie powinna zwrócić żadnych informacji do funkcji, z której została wywołana.

Przykład

Void Loop ( ) {
   // rest of the code
}

Boolean

Boolean zawiera jedną z dwóch wartości, prawda lub fałsz. Każda zmienna boolowska zajmuje jeden bajt pamięci.

Przykład

boolean val = false ; // declaration of variable with type boolean and initialize it with false
boolean state = true ; // declaration of variable with type boolean and initialize it with true

Zwęglać

Typ danych zajmujący jeden bajt pamięci, który przechowuje wartość znakową. Literały znakowe są zapisywane w pojedynczych cudzysłowach w następujący sposób: „A”, a dla wielu znaków w łańcuchach stosuje się podwójne cudzysłowy: „ABC”.

Jednak znaki są przechowywane jako liczby. Możesz zobaczyć konkretne kodowanie na wykresie ASCII . Oznacza to, że możliwe jest wykonywanie operacji arytmetycznych na znakach, w których używana jest wartość ASCII znaku. Na przykład „A” + 1 ma wartość 66, ponieważ wartość ASCII dużej litery A wynosi 65.

Przykład

Char chr_a = ‘a’ ;//declaration of variable with type char and initialize it with character a
Char chr_c = 97 ;//declaration of variable with type char and initialize it with character 97

unsigned char

Unsigned charjest typem danych bez znaku, który zajmuje jeden bajt pamięci. Typ danych unsigned char koduje liczby od 0 do 255.

Przykład

Unsigned Char chr_y = 121 ; // declaration of variable with type Unsigned char and initialize it with character y

bajt

Bajt przechowuje 8-bitową liczbę bez znaku, od 0 do 255.

Przykład

byte m = 25 ;//declaration of variable with type byte and initialize it with 25

int

Liczby całkowite są podstawowym typem danych do przechowywania liczb. int przechowuje wartość 16-bitową (2-bajtową). Daje to zakres od -32 768 do 32767 (minimalna wartość -2 ^ 15 i maksymalna wartość (2 ^ 15) - 1).

Plik introzmiar różni się w zależności od deski. Na przykład w Arduino Due plikintprzechowuje wartość 32-bitową (4-bajtową). Daje to zakres od -2 147 483 648 do 2 147 483 647 (minimalna wartość -2 ^ 31 i maksymalna (2 ^ 31) - 1).

Przykład

int counter = 32 ;// declaration of variable with type int and initialize it with 32

Unsigned int

Liczba int bez znaku (liczby całkowite bez znaku) jest taka sama, jak int, ponieważ przechowują wartość 2-bajtową. Jednak zamiast przechowywać liczby ujemne, przechowują tylko wartości dodatnie, dając użyteczny zakres od 0 do 65 535 (2 ^ 16) - 1). Due przechowuje 4-bajtową (32-bitową) wartość z zakresu od 0 do 4 294 967 295 (2 ^ 32 - 1).

Przykład

Unsigned int counter = 60 ; // declaration of variable with 
   type unsigned int and initialize it with 60

Słowo

Na płytach Uno i innych opartych na ATMEGA słowo przechowuje 16-bitową liczbę bez znaku. Na Due and Zero przechowuje 32-bitową liczbę bez znaku.

Przykład

word w = 1000 ;//declaration of variable with type word and initialize it with 1000

Długo

Długie zmienne to zmienne o rozszerzonym rozmiarze do przechowywania liczb i przechowują 32 bity (4 bajty), od -2 147 483 648 do 2 147 483 647.

Przykład

Long velocity = 102346 ;//declaration of variable with type Long and initialize it with 102346

unsigned long

Długie zmienne bez znaku to zmienne o rozszerzonym rozmiarze do przechowywania liczb i przechowują 32 bity (4 bajty). W przeciwieństwie do standardowych długich długości, długie bez znaku nie będą przechowywać liczb ujemnych, dzięki czemu ich zakres wynosi od 0 do 4 294 967 295 (2 ^ 32 - 1).

Przykład

Unsigned Long velocity = 101006 ;// declaration of variable with 
   type Unsigned Long and initialize it with 101006

krótki

Skrót to 16-bitowy typ danych. We wszystkich Arduino (opartych na ATMega i ARM), short przechowuje 16-bitową (2-bajtową) wartość. Daje to zakres od -32 768 do 32767 (minimalna wartość -2 ^ 15 i maksymalna wartość (2 ^ 15) - 1).

Przykład

short val = 13 ;//declaration of variable with type short and initialize it with 13

pływak

Typ danych dla liczby zmiennoprzecinkowej to liczba z kropką dziesiętną. Liczby zmiennoprzecinkowe są często używane do przybliżania wartości analogowych i ciągłych, ponieważ mają większą rozdzielczość niż liczby całkowite.

Liczby zmiennoprzecinkowe mogą być tak duże, jak 3,4028235E + 38 i tak niskie, jak -3,4028235E + 38. Są przechowywane jako 32 bity (4 bajty) informacji.

Przykład

float num = 1.352;//declaration of variable with type float and initialize it with 1.352

podwójnie

Na płytach Uno i innych opartych na ATMEGA liczba zmiennoprzecinkowa podwójnej precyzji zajmuje cztery bajty. Oznacza to, że podwójna implementacja jest dokładnie taka sama jak zmiennoprzecinkowa, bez zwiększenia precyzji. W Arduino Due dublety mają 8-bajtową (64-bitową) precyzję.

Przykład

double num = 45.352 ;// declaration of variable with type double and initialize it with 45.352

Zanim zaczniemy wyjaśniać typy zmiennych, bardzo ważny temat, który musimy upewnić się, że w pełni rozumiesz, nazywa się variable scope.

Co to jest zakres zmienny?

Zmienne w języku programowania C, z których korzysta Arduino, mają właściwość o nazwie scope. Zasięg to obszar programu i istnieją trzy miejsca, w których można zadeklarować zmienne. Oni są -

• Wewnątrz funkcji lub bloku, który jest nazywany local variables.
• W definicji parametrów funkcji, która nazywa się formal parameters.
• Poza wszystkimi funkcjami, który jest nazywany global variables.

Zmienne lokalne

Zmienne zadeklarowane wewnątrz funkcji lub bloku są zmiennymi lokalnymi. Mogą być używane tylko przez instrukcje, które znajdują się wewnątrz tej funkcji lub bloku kodu. Nie wiadomo, czy zmienne lokalne działają poza swoimi własnymi. Poniżej znajduje się przykład z użyciem zmiennych lokalnych -

Void setup () {

}

Void loop () {
   int x , y ;
   int z ; Local variable declaration
   x = 0;
   y = 0; actual initialization
   z = 10;
}

Zmienne globalne

Zmienne globalne są definiowane poza wszystkimi funkcjami, zwykle w górnej części programu. Zmienne globalne zachowają swoją wartość przez cały okres istnienia programu.

Dostęp do zmiennej globalnej można uzyskać za pomocą dowolnej funkcji. Oznacza to, że zmienna globalna jest dostępna do użycia w całym programie po jej zadeklarowaniu.

Poniższy przykład używa zmiennych globalnych i lokalnych -

Int T , S ;
float c = 0 ; Global variable declaration

Void setup () {

}

Void loop () {
   int x , y ;
   int z ; Local variable declaration
   x = 0;
   y = 0; actual initialization
   z = 10;
}

Operator to symbol, który mówi kompilatorowi, aby wykonał określone funkcje matematyczne lub logiczne. Język C jest bogaty we wbudowane operatory i zapewnia następujące typy operatorów -

• Operatory arytmetyczne
• Operatory porównania
• Operatory boolowskie
• Operatory bitowe
• Operatory złożone

Operatory arytmetyczne

Załóżmy, że zmienna A zawiera 10, a zmienna B 20, a następnie -

Pokaż przykład

Imię operatora	Operator prosty	Opis	Przykład
operator przypisania	=	Przechowuje wartość po prawej stronie znaku równości w zmiennej po lewej stronie znaku równości.	A = B.
dodanie	+	Dodaje dwa operandy	A + B da 30
odejmowanie	-	Odejmuje drugi operand od pierwszego	A - B da -10
mnożenie	*	Pomnóż oba operandy	A * B da 200
podział	/	Podziel licznik przez mianownik	B / A da 2
modulo	%	Operator modułu i reszta po dzieleniu całkowitoliczbowym	B% A da 0

Operatory porównania

Załóżmy, że zmienna A zawiera 10, a zmienna B 20, a następnie -

Pokaż przykład

Imię operatora	Operator prosty	Opis	Przykład
równy	==	Sprawdza, czy wartość dwóch operandów jest równa, czy nie, jeśli tak, warunek staje się prawdziwy.	(A == B) nie jest prawdą
nie równa się	! =	Sprawdza, czy wartość dwóch operandów jest równa, czy nie, jeśli wartości nie są równe, warunek staje się prawdziwy.	(A! = B) jest prawdą
mniej niż	<	Sprawdza, czy wartość lewego operandu jest mniejsza niż wartość prawego operandu. Jeśli tak, warunek staje się prawdziwy.	(A <B) jest prawdą
Lepszy niż	>	Sprawdza, czy wartość lewego operandu jest większa niż wartość prawego operandu, jeśli tak, warunek staje się prawdziwy.	(A> B) nie jest prawdą
mniejszy lub równy	<=	Sprawdza, czy wartość lewego operandu jest mniejsza lub równa wartości prawego operandu, jeśli tak, warunek staje się prawdziwy.	(A <= B) jest prawdą
większe bądź równe	> =	Sprawdza, czy wartość lewego operandu jest większa lub równa wartości prawego operandu, jeśli tak, warunek staje się prawdziwy.	(A> = B) nie jest prawdą

Operatory boolowskie

Załóżmy, że zmienna A zawiera 10, a zmienna B 20, a następnie -

Pokaż przykład

Imię operatora	Operator prosty	Opis	Przykład
i	&&	Nazywany operatorem logicznym AND. Jeśli oba operandy są niezerowe, warunek staje się prawdziwy.	(A && B) jest prawdą
lub	||	Nazywany operatorem logicznym OR. Jeśli którykolwiek z dwóch operandów jest niezerowy, warunek staje się prawdziwy.	(A || B) jest prawdą
nie	!	Nazywany operatorem logicznym NOT. Służy do odwracania stanu logicznego operandu. Jeśli warunek jest spełniony, operator logiczny NOT spowoduje fałsz.	! (A && B) jest fałszem

Operatory bitowe

Załóżmy, że zmienna A zawiera 60, a zmienna B 13, a następnie -

Pokaż przykład

Imię operatora	Operator prosty	Opis	Przykład
i	&	Operator binarny AND kopiuje trochę do wyniku, jeśli istnieje w obu operandach.	(A i B) dadzą 12, czyli 0000 1100
lub	|	Operator binarny OR kopiuje bit, jeśli istnieje w którymkolwiek operandzie	(A | B) da 61, czyli 0011 1101
xor	^	Binarny operator XOR kopiuje bit, jeśli jest ustawiony w jednym operandzie, ale nie w obu.	(A ^ B) da 49, czyli 0011 0001
nie	~	Operator dopełniacza binarnego jest jednoargumentowy i powoduje „odwracanie” bitów.	(~ A) da -60, czyli 1100 0011
przesuń w lewo	<<	Binarny operator przesunięcia w lewo. Wartość lewych operandów jest przesuwana w lewo o liczbę bitów określoną przez prawy operand.	<< 2 da 240, czyli 1111 0000
przesuń w prawo	>>	Binarny operator przesunięcia w prawo. Wartość lewego operandu jest przesuwana w prawo o liczbę bitów określoną przez prawy operand.	>> 2 da 15, czyli 0000 1111

Operatory złożone

Załóżmy, że zmienna A zawiera 10, a zmienna B 20, a następnie -

Pokaż przykład

Imię operatora	Operator prosty	Opis	Przykład
przyrost	++	Operator inkrementacji, zwiększa wartość całkowitą o jeden	A ++ da 11
ubytek	-	Operator zmniejszania, zmniejsza wartość całkowitą o jeden	A-- da 9
dodatek związku	+ =	Dodaj operator przypisania AND. Dodaje prawy operand do lewego operandu i przypisuje wynik do lewego operandu	B + = A jest równoważne B = B + A
odejmowanie złożone	- =	Operator odejmowania AND przypisania. Odejmuje prawy operand od lewego operandu i przypisuje wynik lewemu operandowi	B - = A jest równoważne B = B - A
mnożenie złożone	* =	Operator mnożenia AND przypisania. Mnoży prawy operand z lewym operandem i przypisuje wynik do lewego operandu	B * = A jest równoważne B = B * A
podział złożony	/ =	Operator dzielenia AND. Dzieli lewy operand z prawym operandem i przypisuje wynik lewemu operandowi	B / = A jest równoważne B = B / A
złożone modulo	% =	Operator modułu AND przypisania. Pobiera moduł używając dwóch operandów i przypisuje wynik do lewego operandu	B% = A jest równoważne B = B% A
złożone bitowe lub	| =	bitowy operator OR i przypisanie	A | = 2 to to samo, co A = A | 2
złożone bitowe i	& =	Operator przypisania bitowego AND	A & = 2 to to samo, co A = A & 2

Struktury decyzyjne wymagają, aby programista określił jeden lub więcej warunków do oceny lub przetestowania przez program. Powinien znajdować się wraz z instrukcją lub instrukcjami do wykonania, jeśli warunek zostanie określony jako prawdziwy, i opcjonalnie z innymi instrukcjami do wykonania, jeśli warunek zostanie określony jako fałszywy.

Poniżej przedstawiono ogólną formę typowej struktury podejmowania decyzji występującej w większości języków programowania -

Instrukcje sterujące to elementy w kodzie źródłowym, które kontrolują przebieg wykonywania programu. Oni są -

S.NO.	Oświadczenie i opis kontroli
1	Jeśli oświadczenie Przyjmuje wyrażenie w nawiasach i instrukcję lub blok instrukcji. Jeśli wyrażenie jest prawdziwe, to instrukcja lub blok instrukcji zostanie wykonany, w przeciwnym razie instrukcje te zostaną pominięte.
2	Jeśli… else oświadczenie Na if po instrukcji może następować opcjonalna instrukcja else, która jest wykonywana, gdy wyrażenie jest fałszywe.
3	Jeśli… else if… else oświadczenie Plik if po instrukcji może następować opcjonalne else if...else instrukcja, która jest bardzo przydatna do testowania różnych warunków przy użyciu pojedynczej instrukcji if ... else if.
4	instrukcja switch case Podobnie jak w przypadku instrukcji if, switch...case steruje przepływem programów, umożliwiając programistom określenie różnych kodów, które powinny być wykonywane w różnych warunkach.
5	Operator warunkowy? : Operator warunkowy? : jest jedynym operatorem trójskładnikowym w C.

Języki programowania zapewniają różne struktury kontrolne, które pozwalają na bardziej skomplikowane ścieżki wykonywania.

Instrukcja pętli pozwala nam wielokrotnie wykonać instrukcję lub grupę instrukcji, a następująca po niej jest ogólną postacią instrukcji pętli w większości języków programowania -

Język programowania C zapewnia następujące typy pętli do obsługi wymagań pętli.

S.NO.	Pętla i opis
1	pętla while while pętle będą się zapętlać w sposób ciągły i nieskończony, aż wyrażenie wewnątrz nawiasu () stanie się fałszywe. Coś musi zmienić testowaną zmienną, inaczej pętla while nigdy się nie zakończy.
2	zrobić… pętla while Plik do…whilepętla jest podobna do pętli while. W pętli while warunek kontynuacji pętli jest testowany na początku pętli przed wykonaniem jej treści.
3	dla pętli ZA for loopwykonuje instrukcje określoną liczbę razy. Wyrażenie sterujące pętli jest inicjowane, testowane i przetwarzane całkowicie w nawiasach pętli for.
4	Zagnieżdżona pętla Język C pozwala na użycie jednej pętli wewnątrz innej pętli. Poniższy przykład ilustruje tę koncepcję.
5	Nieskończona pętla Jest to pętla bez warunku kończącego, więc pętla staje się nieskończona.

Funkcje pozwalają na strukturyzację programów w segmenty kodu w celu wykonania poszczególnych zadań. Typowym przypadkiem tworzenia funkcji jest wielokrotne wykonywanie tej samej czynności w programie.

Standaryzacja fragmentów kodu na funkcje ma kilka zalet -

• Funkcje pomagają programiście zachować porządek. Często pomaga to w konceptualizacji programu.

• Funkcje kodyfikują jedno działanie w jednym miejscu, tak że wystarczy tylko raz przemyśleć i zdebugować funkcję.

• Zmniejsza to również szanse na błędy w modyfikacji, jeśli kod wymaga zmiany.

• Funkcje sprawiają, że cały szkic jest mniejszy i bardziej zwarty, ponieważ sekcje kodu są wielokrotnie używane.

• Ułatwiają ponowne użycie kodu w innych programach, czyniąc go modułowym, a używanie funkcji często sprawia, że ​​kod jest bardziej czytelny.

W szkicu Arduino lub programie są wymagane dwie funkcje, tj. Setup () i loop (). Inne funkcje należy utworzyć poza nawiasami kwadratowymi tych dwóch funkcji.

Najpopularniejsza składnia do definiowania funkcji to -

Deklaracja funkcji

Funkcja jest deklarowana poza innymi funkcjami, powyżej lub poniżej funkcji pętli.

Funkcję możemy zadeklarować na dwa różne sposoby -

Pierwszym sposobem jest po prostu napisanie części wywoływanej funkcji a function prototype powyżej funkcji pętli, która składa się z -

• Zwracany typ funkcji
• Nazwa funkcji
• Typ argumentu funkcji, nie ma potrzeby wpisywania nazwy argumentu

Po prototypie funkcji należy umieścić średnik (;).

Poniższy przykład przedstawia demonstrację deklaracji funkcji przy użyciu pierwszej metody.

Przykład

int sum_func (int x, int y) // function declaration {
   int z = 0;
   z = x+y ;
   return z; // return the value
}

void setup () {
   Statements // group of statements
}

Void loop () {
   int result = 0 ;
   result = Sum_func (5,6) ; // function call
}

Druga część, nazywana definicją lub deklaracją funkcji, musi zostać zadeklarowana poniżej funkcji pętli, która składa się z -

• Zwracany typ funkcji
• Nazwa funkcji
• Typ argumentu funkcji, tutaj musisz dodać nazwę argumentu
• Treść funkcji (instrukcje wewnątrz funkcji wykonywane, gdy funkcja jest wywoływana)

Poniższy przykład demonstruje deklarację funkcji przy użyciu drugiej metody.

Przykład

int sum_func (int , int ) ; // function prototype

void setup () {
   Statements // group of statements
}

Void loop () {
   int result = 0 ;
   result = Sum_func (5,6) ; // function call
}

int sum_func (int x, int y) // function declaration {
   int z = 0;
   z = x+y ;
   return z; // return the value
}

Druga metoda po prostu deklaruje funkcję powyżej funkcji pętli.

Ciągi są używane do przechowywania tekstu. Mogą być używane do wyświetlania tekstu na wyświetlaczu LCD lub w oknie monitora szeregowego Arduino IDE. Ciągi znaków są również przydatne do przechowywania danych wejściowych użytkownika. Na przykład znaki, które użytkownik wpisuje na klawiaturze podłączonej do Arduino.

W programowaniu Arduino istnieją dwa typy ciągów -

• Tablice znaków, które są takie same, jak łańcuchy używane w programowaniu w C.
• Arduino String, który pozwala nam użyć obiektu string w szkicu.

W tym rozdziale nauczymy się ciągów znaków, obiektów i ich użycia w szkicach Arduino. Pod koniec rozdziału dowiesz się, jakiego rodzaju sznurka użyć w szkicu.

Tablice znaków ciągów

Pierwszym typem ciągu, którego się nauczymy, jest łańcuch będący serią znaków danego typu char. W poprzednim rozdziale dowiedzieliśmy się, czym jest tablica; kolejny szereg tego samego typu zmiennej przechowywany w pamięci. Łańcuch to tablica zmiennych typu char.

Łańcuch to specjalna tablica, która ma jeden dodatkowy element na końcu łańcucha, który zawsze ma wartość 0 (zero). Nazywa się to „ciągiem zakończonym wartością zerową”.

Przykład tablicy znaków ciągu

Ten przykład pokaże, jak utworzyć łańcuch i wydrukować go w oknie monitora szeregowego.

Example

void setup() {
   char my_str[6]; // an array big enough for a 5 character string
   Serial.begin(9600);
   my_str[0] = 'H'; // the string consists of 5 characters
   my_str[1] = 'e';
   my_str[2] = 'l';
   my_str[3] = 'l';
   my_str[4] = 'o';
   my_str[5] = 0; // 6th array element is a null terminator
   Serial.println(my_str);
}

void loop() { 

}

Poniższy przykład pokazuje, z czego składa się ciąg; tablica znaków ze znakami drukowalnymi i 0 jako ostatnim elementem tablicy, aby pokazać, że na tym kończy się ciąg. Ciąg można wydrukować w oknie monitora szeregowego Arduino IDE przy użyciuSerial.println() i przekazując nazwę ciągu.

Ten sam przykład można napisać w wygodniejszy sposób, jak pokazano poniżej -

Example

void setup() {
   char my_str[] = "Hello";
   Serial.begin(9600);
   Serial.println(my_str);
}

void loop() {

}

W tym szkicu kompilator oblicza rozmiar tablicy ciągów, a także automatycznie kończy ciąg z zerem. Tablica, która ma sześć elementów i składa się z pięciu znaków, po których następuje zero, jest tworzona dokładnie w taki sam sposób, jak w poprzednim szkicu.

Manipulowanie tablicami łańcuchowymi

Możemy zmienić tablicę strun w szkicu, jak pokazano na poniższym szkicu.

Przykład

void setup() {
   char like[] = "I like coffee and cake"; // create a string
   Serial.begin(9600);
   // (1) print the string
   Serial.println(like);
   // (2) delete part of the string
   like[13] = 0;
   Serial.println(like);
   // (3) substitute a word into the string
   like[13] = ' '; // replace the null terminator with a space
   like[18] = 't'; // insert the new word
   like[19] = 'e';
   like[20] = 'a';
   like[21] = 0; // terminate the string
   Serial.println(like);
}

void loop() {

}

Wynik

I like coffee and cake
I like coffee
I like coffee and tea

Szkic działa w następujący sposób.

Tworzenie i drukowanie łańcucha

Na powyższym szkicu tworzony jest nowy ciąg, a następnie drukowany do wyświetlenia w oknie Serial Monitor.

Skracanie sznurka

Łańcuch jest skracany poprzez zastąpienie 14-tego znaku w ciągu znakiem zerowym kończącym zero (2). To jest element numer 13 w tablicy ciągów liczący od 0.

Kiedy drukowany jest łańcuch, wszystkie znaki są drukowane aż do nowego zerowego kończącego zero. Pozostałe postacie nie znikają; nadal istnieją w pamięci, a tablica ciągów ma nadal ten sam rozmiar. Jedyną różnicą jest to, że każda funkcja, która działa z ciągami znaków, będzie widzieć ciąg tylko do pierwszego terminatora null.

Zmiana słowa w ciągu

Wreszcie szkic zastępuje słowo „ciasto” słowem „herbata” (3). Najpierw musi zastąpić terminator zerowy w miejscu takim jak [13] spacją, aby łańcuch został przywrócony do pierwotnie utworzonego formatu.

Nowe znaki nadpisują „cak” słowa „ciasto” słowem „herbata”. Odbywa się to poprzez nadpisywanie poszczególnych znaków. Litera „e” słowa „placek” jest zastępowana nowym znakiem kończącym wartość null. W rezultacie ciąg jest faktycznie zakończony dwoma znakami pustymi, oryginalnym na końcu łańcucha i nowym, który zastępuje „e” w słowie „ciasto”. Nie ma to znaczenia, kiedy drukowany jest nowy ciąg, ponieważ funkcja, która drukuje ciąg, przestaje drukować znaki ciągu, gdy napotka pierwszy terminator zerowy.

Funkcje do manipulowania tablicami ciągów

Poprzedni szkic manipulował łańcuchem w sposób ręczny, uzyskując dostęp do poszczególnych znaków w ciągu. Aby ułatwić manipulowanie tablicami łańcuchowymi, możesz napisać własne funkcje, aby to zrobić, lub użyć niektórych funkcji łańcuchowych zC biblioteka językowa.

Poniżej podano listę Funkcje służące do manipulowania tablicami łańcuchowymi

S.No.	Funkcje i opis
1	String() Klasa String, będąca częścią rdzenia od wersji 0019, umożliwia używanie i manipulowanie ciągami tekstu w bardziej złożony sposób niż robią to tablice znaków. Możesz łączyć ciągi, dołączać do nich, wyszukiwać i zamieniać podciągi i nie tylko. Zajmuje więcej pamięci niż prosta tablica znaków, ale jest też bardziej przydatna. Dla odniesienia tablice znaków są określane jako ciągi z małym „s”, a wystąpienia klasy String są określane jako ciągi z dużą literą S. Należy pamiętać, że ciągi stałe, określone w „cudzysłowach”, są traktowane jako tablice znaków, nie instancje klasy String
2	charAt() Uzyskaj dostęp do określonego znaku String.
3	compareTo() Porównuje dwa ciągi, sprawdzając, czy jeden występuje przed, po drugim lub czy są równe. Łańcuchy są porównywane znak po znaku przy użyciu wartości znaków ASCII. Oznacza to na przykład, że „a” występuje przed „b”, ale po „A”. Liczby poprzedzają litery.
4	concat() Dołącza parametr do ciągu.
5	c_str() Konwertuje zawartość ciągu na ciąg w stylu C zakończony znakiem null. Zauważ, że daje to bezpośredni dostęp do wewnętrznego bufora String i powinno być używane z ostrożnością. W szczególności nigdy nie należy modyfikować ciągu znaków za pomocą zwróconego wskaźnika. Kiedy modyfikujesz obiekt String lub gdy jest on zniszczony, każdy wskaźnik poprzednio zwrócony przez c_str () staje się nieważny i nie powinien być dłużej używany.
6	endsWith() Sprawdza, czy String kończy się znakami innego Stringa.
7	equals() Porównuje dwa ciągi pod kątem równości. W porównaniu rozróżniana jest wielkość liter, co oznacza, że ​​Ciąg „cześć” nie jest równy Ciągowi „HELLO”.
8	equalsIgnoreCase() Porównuje dwa ciągi pod kątem równości. W porównaniu nie jest rozróżniana wielkość liter, co oznacza, że ​​Ciąg („cześć”) jest równy Ciągowi („HELLO”).
9	getBytes() Kopiuje znaki ciągu do podanego buforu.
10	indexOf() Lokalizuje znak lub ciąg w innym ciągu. Domyślnie wyszukuje od początku Stringa, ale może też zacząć od danego indeksu, pozwalając na zlokalizowanie wszystkich wystąpień znaku lub String.
11	lastIndexOf() Lokalizuje znak lub ciąg w innym ciągu. Domyślnie wyszukuje od końca Stringa, ale może również pracować wstecz od danego indeksu, umożliwiając zlokalizowanie wszystkich wystąpień znaku lub String.
12	length() Zwraca długość ciągu w znakach. (Należy pamiętać, że nie obejmuje to końcowego znaku null).
13	remove() Modyfikuj w miejscu, ciąg usuwający znaki z podanego indeksu do końca ciągu lub z podanego indeksu do indeksu i liczby.
14	replace() Funkcja String replace () umożliwia zastąpienie wszystkich wystąpień danego znaku innym znakiem. Możesz również użyć funkcji replace w celu zastąpienia podciągów łańcucha innym podciągiem.
15	reserve() Funkcja String Reserve () umożliwia przydzielenie buforu w pamięci do manipulowania napisami.
16	setCharAt() Ustawia znak String. Nie ma wpływu na indeksy poza istniejącą długością String.
17	startsWith() Sprawdza, czy String zaczyna się od znaków innego String.
18	toCharArray() Kopiuje znaki ciągu do podanego buforu.
19	substring() Pobierz podciąg String. Indeks początkowy jest włącznie (odpowiedni znak jest zawarty w podłańcuchu), ale opcjonalny indeks końcowy jest wyłączny (odpowiedni znak nie jest zawarty w podciągu). Jeśli indeks końcowy zostanie pominięty, podciąg jest kontynuowany do końca String.
20	toInt() Konwertuje prawidłowy ciąg znaków na liczbę całkowitą. Ciąg wejściowy powinien rozpoczynać się liczbą całkowitą. Jeśli łańcuch zawiera liczby nie będące liczbami całkowitymi, funkcja przestanie wykonywać konwersję.
21	toFloat() Konwertuje prawidłowy ciąg znaków na liczbę zmiennoprzecinkową. Ciąg wejściowy powinien zaczynać się od cyfry. Jeśli ciąg zawiera znaki inne niż cyfry, funkcja przestanie wykonywać konwersję. Na przykład ciągi „123,45”, „123” i „123fish” są konwertowane odpowiednio na 123,45, 123,00 i 123,00. Zwróć uwagę, że wartość „123,456” jest przybliżona wartością 123,46. Zauważ też, że liczby zmiennoprzecinkowe mają tylko 6-7 cyfr dziesiętnych precyzji i że dłuższe ciągi mogą zostać obcięte.
22	toLowerCase() Pobierz wersję String z małymi literami. Od wersji 1.0 toLowerCase () modyfikuje ciąg znaków w miejscu zamiast zwracać nowy.
23	toUpperCase() Pobierz wersję String z dużymi literami. Od wersji 1.0 toUpperCase () modyfikuje ciąg znaków w miejscu zamiast zwracać nowy.
24	trim() Uzyskaj wersję String z usuniętymi wszystkimi wiodącymi i końcowymi białymi znakami. Od wersji 1.0 funkcja trim () modyfikuje ciąg znaków zamiast zwracać nowy.

W następnym szkicu użyto niektórych funkcji napisów C.

Przykład

void setup() {
   char str[] = "This is my string"; // create a string
   char out_str[40]; // output from string functions placed here
   int num; // general purpose integer
   Serial.begin(9600);

   // (1) print the string
   Serial.println(str);

   // (2) get the length of the string (excludes null terminator)
   num = strlen(str);
   Serial.print("String length is: ");
   Serial.println(num);

   // (3) get the length of the array (includes null terminator)
   num = sizeof(str); // sizeof() is not a C string function
   Serial.print("Size of the array: ");
   Serial.println(num);

   // (4) copy a string
   strcpy(out_str, str);
   Serial.println(out_str);

   // (5) add a string to the end of a string (append)
   strcat(out_str, " sketch.");
   Serial.println(out_str);
   num = strlen(out_str);
   Serial.print("String length is: ");
   Serial.println(num);
   num = sizeof(out_str);
   Serial.print("Size of the array out_str[]: ");
   Serial.println(num);
}

void loop() {

}

Wynik

This is my string
String length is: 17
Size of the array: 18
This is my string
This is my string sketch.
String length is: 25
Size of the array out_str[]: 40

Szkic działa w następujący sposób.

Wydrukuj ciąg

Nowo utworzony ciąg jest drukowany w oknie monitora szeregowego, tak jak w poprzednich szkicach.

Uzyskaj długość sznurka

Funkcja strlen () służy do uzyskania długości łańcucha. Długość ciągu dotyczy tylko drukowalnych znaków i nie zawiera terminatora null.

Ciąg zawiera 17 znaków, więc widzimy 17 wydrukowanych w oknie Serial Monitor.

Uzyskaj długość tablicy

Operator sizeof () służy do pobierania długości tablicy zawierającej ciąg. Długość obejmuje terminator null, więc długość jest o jeden większa niż długość ciągu.

sizeof () wygląda jak funkcja, ale technicznie jest operatorem. Nie jest częścią biblioteki ciągów C, ale został użyty w szkicu, aby pokazać różnicę między rozmiarem tablicy a rozmiarem ciągu (lub długością łańcucha).

Skopiuj ciąg

Funkcja strcpy () służy do kopiowania ciągu str [] do tablicy out_num []. Funkcja strcpy () kopiuje drugi przekazany do niej łańcuch do pierwszego. Kopia łańcucha istnieje teraz w tablicy out_num [], ale zajmuje tylko 18 elementów tablicy, więc nadal mamy w tablicy 22 wolne elementy typu char. Te wolne elementy znajdują się po łańcuchu w pamięci.

Ciąg został skopiowany do tablicy, abyśmy mieli dodatkowe miejsce w tablicy do wykorzystania w następnej części szkicu, czyli dodaniu ciągu na końcu łańcucha.

Dołącz ciąg do ciągu (konkatenacja)

Szkic łączy jeden ciąg z drugim, co jest znane jako konkatenacja. Odbywa się to za pomocą funkcji strcat (). Funkcja strcat () umieszcza drugi przekazany do niej ciąg na końcu pierwszego przekazanego do niej ciągu.

Po konkatenacji długość łańcucha jest wypisywana, aby pokazać nową długość łańcucha. Następnie wypisywana jest długość tablicy, aby pokazać, że mamy 25-znakowy ciąg w 40-elementowej tablicy.

Pamiętaj, że 25-znakowy ciąg w rzeczywistości zajmuje 26 znaków tablicy z powodu kończącego zero.

Array Bounds

Podczas pracy z łańcuchami i tablicami bardzo ważne jest, aby pracować w granicach ciągów lub tablic. W przykładowym szkicu utworzono tablicę o długości 40 znaków w celu przydzielenia pamięci, której można by użyć do manipulowania łańcuchami.

Jeśli tablica byłaby zbyt mała i próbowaliśmy skopiować do niej ciąg, który jest większy niż tablica, ciąg zostałby skopiowany na koniec tablicy. Pamięć poza końcem tablicy mogłaby zawierać inne ważne dane użyte w szkicu, które następnie zostałyby nadpisane przez nasz ciąg. Jeśli pamięć poza końcem łańcucha zostanie przepełniona, może to spowodować awarię szkicu lub nieoczekiwane zachowanie.

Drugim typem ciągu używanym w programowaniu Arduino jest obiekt String.

Co to jest przedmiot?

Obiekt to konstrukcja zawierająca zarówno dane, jak i funkcje. Obiekt String można utworzyć tak jak zmienną i przypisać mu wartość lub ciąg. Obiekt String zawiera funkcje (w programowaniu obiektowym (OOP) nazywane „metodami”), które operują na danych łańcuchowych zawartych w obiekcie String.

Poniższy szkic i wyjaśnienie wyjaśni, czym jest obiekt i jak jest używany obiekt String.

Przykład

void setup() { 
   String my_str = "This is my string.";
   Serial.begin(9600);

   // (1) print the string
   Serial.println(my_str);

   // (2) change the string to upper-case
   my_str.toUpperCase();
   Serial.println(my_str);

   // (3) overwrite the string
   my_str = "My new string.";
   Serial.println(my_str);

   // (4) replace a word in the string
   my_str.replace("string", "Arduino sketch");
   Serial.println(my_str);

   // (5) get the length of the string
   Serial.print("String length is: ");
   Serial.println(my_str.length());
}

void loop() { 

}

Wynik

This is my string.
THIS IS MY STRING.
My new string.
My new Arduino sketch.
String length is: 22

Tworzony jest obiekt łańcuchowy i przypisywana jest mu wartość (lub ciąg) w górnej części szkicu.

String my_str = "This is my string." ;

Spowoduje to utworzenie obiektu String o nazwie my_str i nadaje mu wartość „To jest mój ciąg”.

Można to porównać do tworzenia zmiennej i przypisywania jej wartości, takiej jak liczba całkowita -

int my_var = 102;

Szkic działa w następujący sposób.

Drukowanie sznurka

Łańcuch można wydrukować w oknie monitora szeregowego, tak jak ciąg tablicy znaków.

Przekonwertuj ciąg na wielkie litery

Utworzony obiekt string my_str ma wiele funkcji lub metod, które można na nim operować. Te metody są wywoływane przy użyciu nazwy obiektu, po której następuje operator kropki (.), A następnie nazwa funkcji, która ma zostać użyta.

my_str.toUpperCase();

Plik toUpperCase() funkcja działa na ciągu zawartym w my_strobiekt typu String i konwertuje dane ciągu (lub tekst), które zawiera obiekt, na znaki z dużych liter. Listę funkcji, które zawiera klasa String, można znaleźć w dokumentacji Arduino String. Technicznie rzecz biorąc, String nazywa się klasą i służy do tworzenia obiektów typu String.

Zastąp ciąg

Operator przypisania służy do przypisywania nowego ciągu do my_str obiekt, który zastępuje stary ciąg

my_str = "My new string." ;

Operator przypisania nie może być używany w ciągach znaków tablicy, ale działa tylko na obiektach typu String.

Zastępowanie słowa w ciągu

Funkcja replace () zastępuje pierwszy przekazany do niej ciąg drugim przekazanym do niej. replace () to kolejna funkcja wbudowana w klasę String i dlatego jest dostępna do użycia w obiekcie String my_str.

Pobieranie długości sznurka

Uzyskanie długości łańcucha można łatwo wykonać za pomocą length (). W przykładowym szkicu wynik zwracany przez length () jest przekazywany bezpośrednio do Serial.println () bez użycia zmiennej pośredniej.

Kiedy używać obiektu typu String

Obiekt String jest znacznie łatwiejszy w użyciu niż tablica znaków ciągu. Obiekt ma wbudowane funkcje, które mogą wykonywać wiele operacji na łańcuchach.

Główną wadą korzystania z obiektu String jest to, że zużywa on dużo pamięci i może szybko zużywać pamięć RAM Arduino, co może spowodować zawieszenie, awarię lub nieoczekiwane zachowanie Arduino. Jeśli szkic na Arduino jest mały i ogranicza użycie obiektów, to nie powinno być problemów.

Ciągi tablic znaków są trudniejsze w użyciu i może być konieczne napisanie własnych funkcji, aby operować na tego typu łańcuchach. Zaletą jest to, że masz kontrolę nad rozmiarem tworzonych tablic ciągów, dzięki czemu możesz zachować małe tablice, aby zaoszczędzić pamięć.

Musisz się upewnić, że nie piszesz poza końcem granic tablicy za pomocą tablic ciągów. Obiekt String nie ma tego problemu i zajmie się za Ciebie granicami łańcucha, pod warunkiem, że jest wystarczająco dużo pamięci, aby mógł na nim operować. Obiekt String może próbować zapisywać do pamięci, która nie istnieje, gdy zabraknie pamięci, ale nigdy nie zapisuje na końcu ciągu, na którym działa.

Gdzie używane są ciągi znaków

W tym rozdziale przestudiowaliśmy o strunach, ich zachowaniu w pamięci i ich operacjach.

Praktyczne zastosowania ciągów zostaną omówione w następnej części tego kursu, kiedy będziemy badać, jak uzyskać dane wejściowe użytkownika z okna monitora szeregowego i zapisać dane wejściowe w ciągu.

Arduino zapewnia cztery różne funkcje manipulacji czasem. Oni są -

S.No.	Opis funkcji
1	funkcja delay () Sposób delay()działa funkcja jest dość prosta. Akceptuje pojedynczy argument będący liczbą całkowitą (lub liczbą). Ta liczba reprezentuje czas (mierzony w milisekundach).
2	Funkcja delayMicroseconds () Plik delayMicroseconds()funkcja przyjmuje pojedynczy argument będący liczbą całkowitą (lub liczbą). Milisekunda ma tysiąc mikrosekund, a sekunda milion mikrosekund.
3	funkcja millis () Ta funkcja służy do zwracania liczby milisekund w czasie, gdy płyta Arduino rozpoczyna wykonywanie bieżącego programu.
4	Funkcja micros () Funkcja micros () zwraca liczbę mikrosekund od chwili, gdy płyta Arduino rozpocznie wykonywanie bieżącego programu. Ta liczba przepełnia się, tj. Wraca do zera po około 70 minutach.

Tablica to kolejna grupa lokalizacji pamięci, które są tego samego typu. Aby odwołać się do określonej lokalizacji lub elementu w tablicy, określamy nazwę tablicy i numer pozycji konkretnego elementu tablicy.

Poniższa ilustracja przedstawia tablicę liczb całkowitych o nazwie C, która zawiera 11 elementów. Odwołujesz się do dowolnego z tych elementów, podając nazwę tablicy, po której następuje numer pozycji konkretnego elementu w nawiasach kwadratowych ([]). Numer pozycji jest bardziej formalnie nazywany indeksem lub indeksem (liczba ta określa liczbę elementów od początku tablicy). Pierwszy element ma indeks 0 (zero) i jest czasami nazywany elementem zerowym.

Zatem elementy tablicy C to C [0] (wymawiane jako „C poniżej zera”), C [1], C [2] i tak dalej. Najwyższy indeks w tablicy C to 10, czyli o 1 mniej niż liczba elementów w tablicy (11). Nazwy tablic są zgodne z tą samą konwencją, co inne nazwy zmiennych.

Indeks dolny musi być wyrażeniem całkowitym lub całkowitym (przy użyciu dowolnego typu całkowitego). Jeśli program używa wyrażenia jako indeksu dolnego, program ocenia wyrażenie, aby określić indeks. Na przykład, jeśli założymy, że zmienna a jest równa 5, a zmienna b jest równa 6, to instrukcja dodaje 2 do elementu tablicy C [11].

Nazwa tablicy z indeksem to wartość l, może być używana po lewej stronie przypisania, tak jak nazwy zmiennych niebędących tablicami.

Przyjrzyjmy się bliżej tablicy C na podanym rysunku. Nazwą całej tablicy jest C. Jej 11 elementów jest oznaczonych jako C [0] do C [10]. Wartość C [0] to -45, wartość C [1] to 6, wartość C [2] to 0, wartość C [7] to 62, a wartość C [10] to 78.

Aby wydrukować sumę wartości zawartych w pierwszych trzech elementach tablicy C, napisalibyśmy -

Serial.print (C[ 0 ] + C[ 1 ] + C[ 2 ] );

Aby podzielić wartość C [6] przez 2 i przypisać wynik do zmiennej x, napisalibyśmy -

x = C[ 6 ] / 2;

Deklarowanie tablic

Tablice zajmują miejsce w pamięci. Aby określić typ elementów i liczbę elementów wymaganych przez tablicę, użyj deklaracji formularza -

type arrayName [ arraySize ] ;

Kompilator rezerwuje odpowiednią ilość pamięci. (Przypomnijmy, że deklaracja, która rezerwuje pamięć, jest lepiej znana jako definicja). ArraySize musi być stałą liczbą całkowitą większą od zera. Na przykład, aby nakazać kompilatorowi zarezerwowanie 11 elementów na tablicę liczb całkowitych C, użyj deklaracji -

int C[ 12 ]; // C is an array of 12 integers

Można zadeklarować, że tablice zawierają wartości dowolnego typu danych nie będącego odniesieniem. Na przykład tablica typu string może służyć do przechowywania ciągów znaków.

Przykłady używania tablic

Ta sekcja zawiera wiele przykładów pokazujących, jak deklarować, inicjować i manipulować tablicami.

Przykład 1: Deklarowanie tablicy i użycie pętli do inicjalizacji elementów tablicy

Program deklaruje 10-elementową tablicę liczb całkowitych n. Linie a – b używają aForinstrukcja, aby zainicjować elementy tablicy do zer. Podobnie jak inne zmienne automatyczne, tablice automatyczne nie są niejawnie inicjowane do zera. Pierwsza instrukcja wyjściowa (wiersz c) wyświetla nagłówki kolumn wydrukowanych w następnej instrukcji for (wiersze d – e), która drukuje tablicę w formacie tabelarycznym.

Example

int n[ 10 ] ; // n is an array of 10 integers

void setup () {

}

void loop () {
   for ( int i = 0; i < 10; ++i ) // initialize elements of array n to 0 {
      n[ i ] = 0; // set element at location i to 0
      Serial.print (i) ;
      Serial.print (‘\r’) ;
   }
   for ( int j = 0; j < 10; ++j ) // output each array element's value {
      Serial.print (n[j]) ;
      Serial.print (‘\r’) ;
   } 
}

Result - To da następujący wynik -

 
       

        
 
         
Element
 
         
Value
 
        
 
        
 
         
 
0
 
1
 
2
 
3
 
4
 
5
 
6
 
7
 
8
 
9
 
 
         
 
0
 
0
 
0
 
0
 
0
 
0
 
0
 
0
 
0
 
0
 
 
        
 
       
      

Przykład 2: Inicjowanie tablicy w deklaracji za pomocą listy inicjalizującej

Elementy tablicy można również zainicjować w deklaracji tablicy, następując po nazwie tablicy ze znakiem równości i rozdzielaną przecinkami listą inicjatorów. Program używa listy inicjalizacyjnej do inicjalizacji tablicy liczb całkowitych z 10 wartościami (wiersz a) i drukuje tablicę w formacie tabelarycznym (wiersze b – c).

Example

// n is an array of 10 integers
int n[ 10 ] = { 32, 27, 64, 18, 95, 14, 90, 70, 60, 37 } ;

void setup () {

}

void loop () {
   for ( int i = 0; i < 10; ++i ) {
      Serial.print (i) ;
      Serial.print (‘\r’) ;
   }
   for ( int j = 0; j < 10; ++j ) // output each array element's value {
      Serial.print (n[j]) ;
      Serial.print (‘\r’) ;
   } 
}

Result - To da następujący wynik -

 
       

        
 
         
Element
 
         
Value
 
        
 
        
 
         
 
0
 
1
 
2
 
3
 
4
 
5
 
6
 
7
 
8
 
9
 
 
         
 
32
 
27
 
64
 
18
 
95
 
14
 
90
 
70
 
60
 
37
 
 
        
 
       
      

Przykład 3: Sumowanie elementów tablicy

Często elementy tablicy reprezentują serię wartości używanych w obliczeniach. Na przykład, jeśli elementy tablicy reprezentują oceny z egzaminu, profesor może zechcieć zsumować wszystkie elementy tablicy i użyć tej sumy do obliczenia średniej z zajęć z egzaminu. Program sumuje wartości zawarte w 10-elementowej tablicy liczb całkowitycha.

Example

const int arraySize = 10; // constant variable indicating size of array
int a[ arraySize ] = { 87, 68, 94, 100, 83, 78, 85, 91, 76, 87 };
int total = 0;

void setup () {

}
void loop () {
   // sum contents of array a
   for ( int i = 0; i < arraySize; ++i )
      total += a[ i ];
   Serial.print (“Total of array elements : ”) ;
   Serial.print(total) ;
}

Result - To da następujący wynik -

Total of array elements: 849

Tablice są ważne dla Arduino i powinny wymagać dużo więcej uwagi. Następujące ważne pojęcia związane z tablicą powinny być jasne dla Arduino -

S.NO.	Koncepcja i opis
1	Przekazywanie tablic do funkcji Aby przekazać argument tablicy do funkcji, podaj nazwę tablicy bez żadnych nawiasów.
2	Tablice wielowymiarowe Tablice z dwoma wymiarami (tj. Indeksami dolnymi) często reprezentują tabele wartości składające się z informacji uporządkowanych w wierszach i kolumnach.

Piny na płycie Arduino można skonfigurować jako wejścia lub wyjścia. Wyjaśnimy działanie pinów w tych trybach. Należy zauważyć, że większość pinów analogowych Arduino może być konfigurowana i używana dokładnie w taki sam sposób jak piny cyfrowe.

Piny skonfigurowane jako INPUT

Piny Arduino są domyślnie skonfigurowane jako wejścia, więc nie muszą być jawnie deklarowane jako wejścia z pinMode()kiedy używasz ich jako danych wejściowych. Mówi się, że piny skonfigurowane w ten sposób są w stanie wysokiej impedancji. Piny wejściowe stawiają bardzo małe wymagania obwodowi, który próbkują, co odpowiada rezystorowi szeregowemu 100 megaomów przed pinem.

Oznacza to, że przełączenie styku wejściowego z jednego stanu na inny wymaga bardzo małego prądu. To sprawia, że ​​piny są przydatne do takich zadań, jak implementacja pojemnościowego czujnika dotykowego lub odczytywanie diody LED jako fotodiody.

Piny skonfigurowane jako pinMode (pin, INPUT) bez niczego do nich podłączonego lub z podłączonymi do nich przewodami, które nie są podłączone do innych obwodów, zgłaszają pozornie przypadkowe zmiany stanu pinów, wychwytują szum elektryczny z otoczenia lub pojemnościowo łączą stan pobliskiego pinu.

Rezystory podciągające

Rezystory podciągające są często przydatne do sterowania pinem wejściowym w znanym stanie, jeśli nie ma wejścia. Można to zrobić, dodając rezystor podciągający (do + 5V) lub rezystor obniżający (rezystor do masy) na wejściu. Rezystor 10K to dobra wartość dla rezystora podwyższającego lub obniżającego.

Używanie wbudowanego rezystora pull-up z pinami skonfigurowanymi jako wejście

W chipie Atmega jest wbudowanych 20 000 rezystorów podciągających, do których można uzyskać dostęp z poziomu oprogramowania. Dostęp do tych wbudowanych rezystorów podciągających uzyskuje się po ustawieniu opcjipinMode()jako INPUT_PULLUP. To skutecznie odwraca zachowanie trybu INPUT, gdzie WYSOKI oznacza, że ​​czujnik jest wyłączony, a NISKI oznacza, że ​​czujnik jest włączony. Wartość tego podciągania zależy od zastosowanego mikrokontrolera. Na większości płyt opartych na AVR gwarantowana wartość wynosi od 20 kΩ do 50 kΩ. W Arduino Due wynosi od 50 kΩ do 150 kΩ. Dokładną wartość znajdziesz w arkuszu danych mikrokontrolera na swojej płycie.

Podłączając czujnik do pinu skonfigurowanego z INPUT_PULLUP, drugi koniec powinien być podłączony do masy. W przypadku prostego przełącznika powoduje to, że pin wyświetla stan WYSOKI, gdy przełącznik jest otwarty i NISKI, gdy przełącznik jest wciśnięty. Rezystory podciągające dostarczają prąd wystarczający do zaświecenia diody LED słabo podłączonej do pinu skonfigurowanego jako wejście. Jeśli diody LED w projekcie wydają się działać, ale bardzo słabo, prawdopodobnie to się dzieje.

Te same rejestry (wewnętrzne lokalizacje w pamięci chipa), które kontrolują, czy pin jest WYSOKI czy NISKI, sterują rezystorami podciągającymi. W konsekwencji pin, który jest skonfigurowany tak, aby rezystory podciągające były włączone, gdy pin jest w trybie INPUT, będzie miał pin skonfigurowany jako WYSOKI, jeśli pin zostanie następnie przełączony w tryb WYJŚCIA za pomocą pinMode (). Działa to również w drugim kierunku, a pin wyjściowy pozostawiony w stanie WYSOKI będzie miał ustawiony rezystor podciągający, jeśli zostanie przełączony na wejście za pomocą pinMode ().

Example

pinMode(3,INPUT) ; // set pin to input without using built in pull up resistor
pinMode(5,INPUT_PULLUP) ; // set pin to input using built in pull up resistor

Piny skonfigurowane jako OUTPUT

Piny skonfigurowane jako OUTPUT z pinMode () są określane jako w stanie niskiej impedancji. Oznacza to, że mogą dostarczać znaczną ilość prądu do innych obwodów. Piny Atmega mogą dostarczać (dostarczać prąd dodatni) lub odprowadzać (dostarczać prąd ujemny) do 40 mA (miliamperów) prądu do innych urządzeń / obwodów. Jest to wystarczający prąd, aby jasno zapalić diodę LED (nie zapomnij o rezystorze szeregowym) lub uruchomić wiele czujników, ale niewystarczający prąd, aby uruchomić przekaźniki, solenoidy lub silniki.

Próba uruchomienia urządzeń wysokoprądowych z pinów wyjściowych może spowodować uszkodzenie lub zniszczenie tranzystorów wyjściowych w pinie lub uszkodzenie całego układu Atmega. Często skutkuje to „martwym” pinem mikrokontrolera, ale pozostałe chipy nadal działają prawidłowo. Z tego powodu dobrym pomysłem jest podłączenie pinów OUTPUT do innych urządzeń poprzez rezystory 470Ω lub 1k, chyba że dla konkretnego zastosowania wymagany jest maksymalny prąd pobierany z pinów.

Funkcja pinMode ()

Funkcja pinMode () służy do konfigurowania określonego pinu, aby zachowywał się jako wejście lub wyjście. Możliwe jest włączenie wewnętrznych rezystorów podciągających w trybie INPUT_PULLUP. Dodatkowo tryb INPUT wyraźnie wyłącza wewnętrzne podciąganie.

pinMode () Składnia funkcji

Void setup () {
   pinMode (pin , mode);
}

• pin - numer pinu, którego tryb chcesz ustawić

• mode - INPUT, OUTPUT lub INPUT_PULLUP.

Example

int button = 5 ; // button connected to pin 5
int LED = 6; // LED connected to pin 6

void setup () {
   pinMode(button , INPUT_PULLUP); 
   // set the digital pin as input with pull-up resistor
   pinMode(button , OUTPUT); // set the digital pin as output
}

void setup () {
   If (digitalRead(button ) == LOW) // if button pressed {
      digitalWrite(LED,HIGH); // turn on led
      delay(500); // delay for 500 ms
      digitalWrite(LED,LOW); // turn off led
      delay(500); // delay for 500 ms
   }
}

Funkcja digitalWrite ()

Plik digitalWrite()Funkcja służy do zapisywania wartości HIGH lub LOW na cyfrowym pinie. Jeśli pin został skonfigurowany jako WYJŚCIE z pinMode () , jego napięcie zostanie ustawione na odpowiednią wartość: 5 V (lub 3,3 V na płytach 3,3 V) dla WYSOKIE, 0 V (masa) dla NISKIE. Jeśli pin jest skonfigurowany jako INPUT, digitalWrite () włączy (WYSOKI) lub wyłączy (NISKI) wewnętrzne podciąganie na pinie wejściowym. Zaleca się ustawienie pinMode () na INPUT_PULLUP, aby włączyć wewnętrzny rezystor podciągający.

Jeśli nie ustawisz pinMode () na OUTPUT i podłączysz diodę LED do pinu, podczas wywoływania digitalWrite (HIGH) dioda LED może być przyciemniona. Bez jawnego ustawienia pinMode (), digitalWrite () włączy wewnętrzny rezystor podciągający, który działa jak duży rezystor ograniczający prąd.

Składnia funkcji digitalWrite ()

Void loop() {
   digitalWrite (pin ,value);
}

• pin - numer pinu, którego tryb chcesz ustawić

• value - WYSOKA lub NISKA.

Example

int LED = 6; // LED connected to pin 6

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

void setup () { 
   digitalWrite(LED,HIGH); // turn on led
   delay(500); // delay for 500 ms
   digitalWrite(LED,LOW); // turn off led
   delay(500); // delay for 500 ms
}

funkcja analogRead ()

Arduino jest w stanie wykryć, czy na jednym z jego pinów jest napięcie i zgłosić to za pomocą funkcji digitalRead (). Istnieje różnica między czujnikiem włączania / wyłączania (wykrywającym obecność obiektu) a czujnikiem analogowym, którego wartość stale się zmienia. Do odczytania tego typu czujnika potrzebujemy innego typu pinów.

W prawej dolnej części płyty Arduino zobaczysz sześć pinów oznaczonych „Analog In”. Te specjalne szpilki nie tylko informują, czy jest na nich przyłożone napięcie, ale także informują o jego wartości. Korzystając zanalogRead() możemy odczytać napięcie przyłożone do jednego z pinów.

Ta funkcja zwraca liczbę z przedziału od 0 do 1023, która reprezentuje napięcia od 0 do 5 woltów. Na przykład, jeśli do pinu numer 0 przyłożono napięcie 2,5 V, analogRead (0) zwraca 512.

Funkcja analogRead () Składnia

analogRead(pin);

• pin - numer pinu wejścia analogowego do odczytu (od 0 do 5 na większości płyt, od 0 do 7 w Mini i Nano, od 0 do 15 w Mega)

Example

int analogPin = 3;//potentiometer wiper (middle terminal) 
   // connected to analog pin 3 
int val = 0; // variable to store the value read

void setup() {
   Serial.begin(9600); // setup serial
} 

void loop() {
   val = analogRead(analogPin); // read the input pin
   Serial.println(val); // debug value
}

W tym rozdziale poznamy kilka zaawansowanych funkcji wejścia i wyjścia.

Funkcja analogReference ()

Konfiguruje napięcie odniesienia używane na wejściu analogowym (tj. Wartość używaną jako górna granica zakresu wejściowego). Dostępne opcje -

• DEFAULT - Domyślne analogowe napięcie odniesienia 5 V (na płytach Arduino 5 V) lub 3,3 V (na płytach Arduino 3,3 V)

• INTERNAL - Wbudowane odniesienie równe 1,1 V w ATmega168 lub ATmega328 i 2,56 V w ATmega8 (niedostępne w Arduino Mega)

• INTERNAL1V1 - Wbudowane odniesienie 1,1 V (tylko Arduino Mega)

• INTERNAL2V56 - Wbudowane odniesienie 2,56 V (tylko Arduino Mega)

• EXTERNAL - Napięcie przyłożone do pinu AREF (tylko od 0 do 5 V) jest używane jako odniesienie

Składnia funkcji analogReference ()

analogReference (type);

type - może używać dowolnego typu follow (DEFAULT, INTERNAL, INTERNAL1V1, INTERNAL2V56, EXTERNAL)

Nie używaj niczego mniejszego niż 0 V lub więcej niż 5 V jako zewnętrznego napięcia odniesienia na pinie AREF. Jeśli używasz zewnętrznego odniesienia na pinie AREF, musisz ustawić analogowe odniesienie na EXTERNAL przed wywołaniemanalogRead()funkcjonować. W przeciwnym razie zewrze się aktywne napięcie odniesienia (generowane wewnętrznie) i pin AREF, prawdopodobnie uszkadzając mikrokontroler na płycie Arduino.

Alternatywnie można podłączyć zewnętrzne napięcie odniesienia do pinu AREF za pomocą rezystora 5K, umożliwiając przełączanie między zewnętrznym i wewnętrznym napięciem odniesienia.

Należy zauważyć, że rezystor zmieni napięcie używane jako odniesienie, ponieważ na pinie AREF znajduje się wewnętrzny rezystor 32K. Oba działają jako dzielnik napięcia. Na przykład, 2,5 V przyłożone przez rezystor da 2,5 * 32 / (32 + 5) = ~ 2,2 V na pinie AREF.

Example

int analogPin = 3;// potentiometer wiper (middle terminal) connected to analog pin 3 
int val = 0; // variable to store the read value

void setup() {
   Serial.begin(9600); // setup serial
   analogReference(EXTERNAL); // the voltage applied to the AREF pin (0 to 5V only) 
      // is used as the reference.
}

void loop() {
   val = analogRead(analogPin); // read the input pin
   Serial.println(val); // debug value
}

Wszystkie dane są wprowadzane do komputerów jako znaki, które obejmują litery, cyfry i różne symbole specjalne. W tej sekcji omówimy możliwości języka C ++ do badania i manipulowania pojedynczymi znakami.

Biblioteka obsługi znaków zawiera kilka funkcji, które wykonują przydatne testy i manipulują danymi znakowymi. Każda funkcja otrzymuje znak reprezentowany jako int lub EOF jako argument. Znaki są często traktowane jako liczby całkowite.

Pamiętaj, że EOF normalnie ma wartość –1 i że niektóre architektury sprzętowe nie pozwalają na przechowywanie ujemnych wartości w zmiennych char. Dlatego funkcje obsługujące znaki przetwarzają znaki jako liczby całkowite.

Poniższa tabela zawiera podsumowanie funkcji biblioteki obsługi znaków. Korzystając z funkcji z biblioteki obsługi znaków, dołącz rozszerzenie<cctype> nagłówek.

S.No.	Prototyp i opis
1	int isdigit( int c ) Zwraca 1, jeśli c jest cyfrą, a 0 w przeciwnym razie.
2	int isalpha( int c ) Zwraca 1, jeśli c jest literą, a 0 w przeciwnym razie.
3	int isalnum( int c ) Zwraca 1, jeśli c jest cyfrą lub literą, a 0 w innym przypadku.
4	int isxdigit( int c ) Zwraca 1, jeśli c jest cyfrą szesnastkową, a 0 w przeciwnym razie. (Zobacz dodatek D, Systemy liczbowe, aby uzyskać szczegółowe wyjaśnienie liczb binarnych, ósemkowych, dziesiętnych i szesnastkowych).
5	int islower( int c ) Zwraca 1, jeśli c jest małą literą, a 0 w przeciwnym razie.
6	int isupper( int c ) Zwraca 1, jeśli c jest wielką literą; 0 inaczej.
7	int isspace( int c ) Zwraca 1, jeśli c jest znakiem odstępu - nowej linii („\ n”), spacji (''), wysuw strony ('\ f'), powrót karetki ('\ r'), tabulator poziomy ('\ t') lub tabulator pionowy ('\ v') - i 0 w przeciwnym razie.
8	int iscntrl( int c ) Zwraca 1, jeśli c jest znakiem sterującym, takim jak nowa linia ('\ n'), wysuw strony ('\ f'), powrót karetki ('\ r'), tabulator poziomy ('\ t'), tabulator pionowy (' \ v '), alert (' \ a ') lub backspace (' \ b ') - i 0 w przeciwnym razie.
9	int ispunct( int c ) Zwraca 1, jeśli c jest drukowanym znakiem innym niż spacja, cyfra lub litera, i 0 w innym przypadku.
10	int isprint( int c ) Zwraca 1, jeśli c jest drukowanym znakiem zawierającym spację („”) i 0 w innym przypadku.
11	int isgraph( int c ) Zwraca 1, jeśli c jest drukowanym znakiem innym niż spacja („”) i 0 w innym przypadku.

Przykłady

Poniższy przykład demonstruje użycie funkcji isdigit, isalpha, isalnum i isxdigit. Funkcjonowaćisdigitokreśla, czy jego argument jest cyfrą (0–9). Funkcjaisalphaokreśla, czy jego argument jest wielką literą (AZ), czy małą literą (a – z). Funkcjaisalnumokreśla, czy jego argument jest wielką, małą literą czy cyfrą. Funkcjonowaćisxdigit określa, czy jego argument jest cyfrą szesnastkową (A – F, a – f, 0–9).

Przykład 1

void setup () {
   Serial.begin (9600);
   Serial.print ("According to isdigit:\r");
   Serial.print (isdigit( '8' ) ? "8 is a": "8 is not a");
   Serial.print (" digit\r" );
   Serial.print (isdigit( '8' ) ?"# is a": "# is not a") ;
   Serial.print (" digit\r");
   Serial.print ("\rAccording to isalpha:\r" );
   Serial.print (isalpha('A' ) ?"A is a": "A is not a");
   Serial.print (" letter\r");
   Serial.print (isalpha('A' ) ?"b is a": "b is not a");
   Serial.print (" letter\r");
   Serial.print (isalpha('A') ?"& is a": "& is not a");
   Serial.print (" letter\r");
   Serial.print (isalpha( 'A' ) ?"4 is a":"4 is not a");
   Serial.print (" letter\r");
   Serial.print ("\rAccording to isalnum:\r");
   Serial.print (isalnum( 'A' ) ?"A is a" : "A is not a" );

   Serial.print (" digit or a letter\r" );
   Serial.print (isalnum( '8' ) ?"8 is a" : "8 is not a" ) ;
   Serial.print (" digit or a letter\r");
   Serial.print (isalnum( '#' ) ?"# is a" : "# is not a" );
   Serial.print (" digit or a letter\r");
   Serial.print ("\rAccording to isxdigit:\r");
   Serial.print (isxdigit( 'F' ) ?"F is a" : "F is not a" );
   Serial.print (" hexadecimal digit\r" );
   Serial.print (isxdigit( 'J' ) ?"J is a" : "J is not a" ) ;
   Serial.print (" hexadecimal digit\r" );
   Serial.print (isxdigit( '7' ) ?"7 is a" : "7 is not a" ) ;

   Serial.print (" hexadecimal digit\r" );
   Serial.print (isxdigit( '$' ) ? "$ is a" : "$ is not a" );
   Serial.print (" hexadecimal digit\r" );
   Serial.print (isxdigit( 'f' ) ? “f is a" : "f is not a");
   
}

void loop () {

}

Wynik

According to isdigit:
8 is a digit
# is not a digit
According to isalpha:
A is a letter
b is a letter
& is not a letter
4 is not a letter
According to isalnum:
A is a digit or a letter

8 is a digit or a letter
# is not a digit or a letter
According to isxdigit:
F is a hexadecimal digit
J is not a hexadecimal digit
7 is a hexadecimal digit

$ is not a hexadecimal digit
f is a hexadecimal digit

Używamy operatora warunkowego (?:)z każdą funkcją, aby określić, czy łańcuch „jest”, czy też ciąg „nie jest”, powinien być wypisywany na wyjściu dla każdego testowanego znaku. Na przykład linea wskazuje, że jeśli „8” jest cyfrą - tj. jeśli isdigitzwraca wartość prawdziwą (niezerową) - drukowany jest łańcuch "8 to a". Jeśli „8” nie jest cyfrą (tj. Jeśliisdigit zwraca 0), drukowany jest ciąg „8 nie jest”.

Przykład 2

Poniższy przykład demonstruje użycie funkcji islower i isupper. Funkcjaislowerokreśla, czy jego argument jest małą literą (a – z). Funkcjonowaćisupper określa, czy argument jest wielką literą (A – Z).

int thisChar = 0xA0;

void setup () {
   Serial.begin (9600);
   Serial.print ("According to islower:\r") ;
   Serial.print (islower( 'p' ) ? "p is a" : "p is not a" );
   Serial.print ( " lowercase letter\r" );
   Serial.print ( islower( 'P') ? "P is a" : "P is not a") ;
   Serial.print ("lowercase letter\r");
   Serial.print (islower( '5' ) ? "5 is a" : "5 is not a" );
   Serial.print ( " lowercase letter\r" );
   Serial.print ( islower( '!' )? "! is a" : "! is not a") ;
   Serial.print ("lowercase letter\r");

   Serial.print ("\rAccording to isupper:\r") ;
   Serial.print (isupper ( 'D' ) ? "D is a" : "D is not an" );
   Serial.print ( " uppercase letter\r" );
   Serial.print ( isupper ( 'd' )? "d is a" : "d is not an") ;
   Serial.print ( " uppercase letter\r" );
   Serial.print (isupper ( '8' ) ? "8 is a" : "8 is not an" );
   Serial.print ( " uppercase letter\r" );
   Serial.print ( islower( '$' )? "$ is a" : "$ is not an") ;
   Serial.print ("uppercase letter\r ");
}

void setup () {

}

Wynik

According to islower:
p is a lowercase letter
P is not a lowercase letter
5 is not a lowercase letter
! is not a lowercase letter

According to isupper:
D is an uppercase letter
d is not an uppercase letter
8 is not an uppercase letter
$ is not an uppercase letter

Przykład 3

Poniższy przykład demonstruje użycie funkcji isspace, iscntrl, ispunct, isprint i isgraph.

• Funkcja isspace określa, czy jego argument jest znakiem spacji, takim jak spacja (''), wysuw formularza ('\ f'), znak nowej linii ('\ n'), powrót karetki ('\ r'), tabulator poziomy ('\ t ') lub tabulator pionowy (' \ v ').

• Funkcja iscntrl określa, czy jego argumentem jest znak sterujący, taki jak tabulator poziomy ('\ t'), tabulator pionowy ('\ v'), wysuw strony ('\ f'), alert ('\ a'), backspace ('\ b '), powrót karetki (' \ r ') lub znak nowej linii (' \ n ').

• Funkcja ispunct określa, czy jego argument jest drukowanym znakiem innym niż spacja, cyfra lub litera, na przykład $, #, (,), [,], {,},;: lub%.

• Funkcja isprint określa, czy jego argument jest znakiem, który można wyświetlić na ekranie (łącznie ze znakiem spacji).

• Funkcja isgraph testuje te same znaki co isprint, ale znak spacji nie jest uwzględniany.

void setup () {
   Serial.begin (9600);
   Serial.print ( " According to isspace:\rNewline ") ;
   Serial.print (isspace( '\n' )? " is a" : " is not a" );
   Serial.print ( " whitespace character\rHorizontal tab") ;
   Serial.print (isspace( '\t' )? " is a" : " is not a" );
   Serial.print ( " whitespace character\n") ;
   Serial.print (isspace('%')? " % is a" : " % is not a" );
   
   Serial.print ( " \rAccording to iscntrl:\rNewline") ;
   Serial.print ( iscntrl( '\n' )?"is a" : " is not a" ) ;
   Serial.print (" control character\r");
   Serial.print (iscntrl( '$' ) ? " $ is a" : " $ is not a" );
   Serial.print (" control character\r");
   Serial.print ("\rAccording to ispunct:\r");
   Serial.print (ispunct(';' ) ?"; is a" : "; is not a" ) ;
   Serial.print (" punctuation character\r");
   Serial.print (ispunct('Y' ) ?"Y is a" : "Y is not a" ) ;
   Serial.print ("punctuation character\r");
   Serial.print (ispunct('#' ) ?"# is a" : "# is not a" ) ;
   Serial.print ("punctuation character\r");

   Serial.print ( "\r According to isprint:\r");
   Serial.print (isprint('$' ) ?"$ is a" : "$ is not a" );
   Serial.print (" printing character\rAlert ");
   Serial.print (isprint('\a' ) ?" is a" : " is not a" );
   Serial.print (" printing character\rSpace ");
   Serial.print (isprint(' ' ) ?" is a" : " is not a" );
   Serial.print (" printing character\r");
   
   Serial.print ("\r According to isgraph:\r");
   Serial.print (isgraph ('Q' ) ?"Q is a" : "Q is not a" );
   Serial.print ("printing character other than a space\rSpace ");
   Serial.print (isgraph (' ') ?" is a" : " is not a" );
   Serial.print ("printing character other than a space ");
}

void loop () {

}

Wynik

According to isspace:
Newline is a whitespace character
Horizontal tab is a whitespace character
% is not a whitespace character
According to iscntrl:
Newline is a control character
$ is not a control character
According to ispunct:
; is a punctuation character
Y is not a punctuation character
# is a punctuation character
According to isprint:
$ is a printing character
Alert is not a printing character
Space is a printing character
According to isgraph:
Q is a printing character other than a space
Space is not a printing character other than a space

Biblioteka Arduino Math (math.h) zawiera szereg przydatnych funkcji matematycznych do manipulowania liczbami zmiennoprzecinkowymi.

Biblioteka makr

Poniżej znajdują się makra zdefiniowane w nagłówku math.h -

Poniżej podano listę makr zdefiniowanych w nagłówku math.h

Makra	Wartość	Opis
MNIE	2.7182818284590452354	Stała e.
M_LOG2E	1.4426950408889634074 / * log_2 e * /	Logarytm e o podstawie 2
M_1_PI	0.31830988618379067154 / * 1 / pi * /	Stała 1 / pi
M_2_PI	0.63661977236758134308 / * 2 / pi * /	Stała 2 / pi
M_2_SQRTPI	1.12837916709551257390 / * 2 / sqrt (pi) * /	Stała 2 / sqrt (pi)
M_LN10	2.30258509299404568402 / * log_e 10 * /	Logarytm naturalny z 10
M_LN2	0.69314718055994530942 / * log_e 2 * /	Logarytm naturalny z 2
M_LOG10E	0.43429448190325182765 / * log_10 e * /	Logarytm e do podstawy 10
M_PI	3.14159265358979323846 /* Liczba Pi */	Stała pi
M_PI_2	3,3V1,57079632679489661923 / * pi / 2 * /	Stała pi / 2
M_PI_4	0.78539816339744830962 / * pi / 4 * /	Stała pi / 4
M_SQRT1_2	0.70710678118654752440 / * 1 / sqrt (2) * /	Stała 1 / sqrt (2)
M_SQRT2	1.41421356237309504880 / * sqrt (2) * /	Pierwiastek kwadratowy z 2
acosf	-	Alias ​​funkcji acos ()
asinf	-	Alias ​​funkcji asin ()
atan2f	-	Alias ​​funkcji atan2 ()
cbrtf	-	Alias ​​funkcji cbrt ()
ceilf	-	Alias ​​funkcji ceil ()
copysignf	-	Alias ​​funkcji copysign ()
coshf	-	Alias ​​funkcji cosh ()
expf	-	Alias ​​funkcji exp ()
fabsf	-	Alias ​​funkcji fabs ()
fdimf	-	Alias ​​funkcji fdim ()
piętro	-	Alias ​​funkcji floor ()
fmaxf	-	Alias ​​funkcji fmax ()
fminf	-	Alias ​​funkcji fmin ()
fmodf	-	Alias ​​funkcji fmod ()
frexpf	-	Alias ​​funkcji frexp ()
hypotf	-	Alias ​​funkcji hypot ()
NIESKOŃCZONOŚĆ	-	INFINITY stała
isfinitef	-	Alias ​​funkcji isfinite ()
isinff	-	Alias ​​funkcji isinf ()
isnanf	-	Alias ​​funkcji isnan ()
ldexpf	-	Alias ​​funkcji ldexp ()
log10f	-	Alias ​​funkcji log10 ()
logf	-	Alias ​​funkcji log ()
lrintf	-	Alias ​​funkcji lrint ()
lroundf	-	Alias ​​funkcji lround ()

Funkcje biblioteki

W nagłówku zdefiniowano następujące funkcje math.h -

Poniżej podano listę funkcji zdefiniowanych w nagłówku math.h

S.No.	Funkcja i opis biblioteki
1	double acos (double __x) Funkcja acos () oblicza główną wartość arcus cosinus z __x. Zwrócona wartość mieści się w zakresie [0, pi] radianów. Błąd domeny występuje w przypadku argumentów spoza zakresu [-1, +1].
2	double asin (double __x) Funkcja asin () oblicza główną wartość łuku sinusoidalnego z __x. Zwrócona wartość mieści się w zakresie [-pi / 2, pi / 2] radianów. Błąd domeny występuje w przypadku argumentów spoza zakresu [-1, +1].
3	double atan (double __x) Funkcja atan () oblicza główną wartość stycznej łuku z __x. Zwrócona wartość mieści się w zakresie [-pi / 2, pi / 2] radianów.
4	double atan2 (double __y, double __x) Funkcja atan2 () oblicza główną wartość łuku tangensa __y / __x, używając znaków obu argumentów do określenia kwadrantu zwracanej wartości. Zwrócona wartość mieści się w zakresie [-pi, + pi] radianów.
5	double cbrt (double __x) Funkcja cbrt () zwraca pierwiastek sześcienny z __x.
6	double ceil (double __x) Funkcja ceil () zwraca najmniejszą wartość całkowitą większą lub równą __x, wyrażoną jako liczba zmiennoprzecinkowa.
7	static double copysign (double __x, double __y) Funkcja copysign () zwraca __x, ale ze znakiem __y. Działają nawet wtedy, gdy __x lub __y to NaN lub zero.
8	double cos(double __x) Funkcja cos () zwraca cosinus funkcji __x mierzony w radianach.
9	double cosh (double __x) Funkcja cosh () zwraca hiperboliczny cosinus z __x.
10	double exp (double __x) Funkcja exp () zwraca wykładniczą wartość __x.
11	double fabs (double __x) Funkcja fabs () oblicza wartość bezwzględną liczby zmiennoprzecinkowej __x.
12	double fdim (double __x, double __y) Funkcja fdim () zwraca wartość max (__ x - __y, 0). Jeśli __x lub __y lub oba mają wartość NaN, zwracany jest NaN.
13	double floor (double __x) Funkcja floor () zwraca największą wartość całkowitą mniejszą lub równą __x, wyrażoną jako liczba zmiennoprzecinkowa.
14	double fma (double __x, double __y, double __z) Funkcja fma () wykonuje wielokrotne dodawanie zmiennoprzecinkowe. To jest operacja (__x * __y) + __z, ale wynik pośredni nie jest zaokrąglany do typu docelowego. Czasami może to poprawić precyzję obliczeń.
15	double fmax (double __x, double __y) Funkcja fmax () zwraca większą z dwóch wartości __x i __y. Jeśli argument ma wartość NaN, zwracany jest drugi argument. Jeśli oba argumenty mają wartość NaN, zwracany jest NaN.
16	double fmin (double __x, double __y) Funkcja fmin () zwraca mniejszą z dwóch wartości __x i __y. Jeśli argument ma wartość NaN, zwracany jest drugi argument. Jeśli oba argumenty mają wartość NaN, zwracany jest NaN.
17	double fmod (double __x, double__y) Funkcja fmod () zwraca zmiennoprzecinkową resztę z __x / __y.
18	double frexp (double __x, int * __pexp) Funkcja frexp () dzieli liczbę zmiennoprzecinkową na znormalizowany ułamek i całkowitą potęgę 2. Przechowuje liczbę całkowitą w obiekcie int wskazywanym przez __pexp. Jeśli __x jest normalną liczbą zmiennoprzecinkową, funkcja frexp () zwraca wartość v, taką, że v ma wielkość w przedziale [1/2, 1) lub zero, a __x równa się v razy 2 podniesione do potęgi __pexp. Jeśli __x jest równe zero, obie części wyniku są równe zero. Jeśli __x nie jest liczbą skończoną, funkcja frexp () zwraca __x bez zmian i przechowuje 0 do __pexp. Note - Ta implementacja zezwala na zerowy wskaźnik jako dyrektywę do pominięcia przechowującego wykładnika.
19	double hypot (double __x, double__y) Funkcja hypot () zwraca sqrt (__ x * __ x + __y * __ y). Jest to długość przeciwprostokątnej trójkąta prostokątnego o bokach o długości __x i __y lub odległość punktu (__x, __y) od początku. Używanie tej funkcji zamiast bezpośredniego wzoru jest rozsądne, ponieważ błąd jest znacznie mniejszy. Brak niedomiaru z małymi __x i __y. Brak przepełnienia, jeśli wynik jest w zakresie.
20	static int isfinite (double __x) Funkcja isfinite () zwraca wartość różną od zera, jeśli __x jest skończone: nie plus lub minus nieskończoność i nie NaN.
21	int isinf (double __x) Funkcja isinf () zwraca 1, jeśli argument __x jest dodatnią nieskończonością, -1 jeśli __x jest ujemną nieskończonością, a 0 w przeciwnym razie. Note - GCC 4.3 może zastąpić tę funkcję wbudowanym kodem, który zwraca wartość 1 dla obu nieskończoności (błąd gcc nr 35509).
22	int isnan (double __x) Funkcja isnan () zwraca 1, jeśli argument __x reprezentuje „nie-liczbę” (NaN), w przeciwnym razie 0.
23	double ldexp (double __x, int __exp ) Funkcja ldexp () mnoży liczbę zmiennoprzecinkową przez całkowitą potęgę 2. Zwraca wartość __x razy 2 podniesioną do potęgi __exp.
24	double log (double __x) Funkcja log () zwraca logarytm naturalny argumentu __x.
25	double log10(double __x) Funkcja log10 () zwraca logarytm argumentu __x o podstawie 10.
26	long lrint (double __x) Funkcja lrint () zaokrągla __x do najbliższej liczby całkowitej, zaokrąglając przypadki w połowie długości do kierunku parzystej liczby całkowitej. (Oznacza to, że wartości 1,5 i 2,5 są zaokrąglane do 2). Ta funkcja jest podobna do funkcji rint (), ale różni się typem zwracanej wartości i tym, że możliwe jest jej przepełnienie. Returns Długa liczba całkowita w zaokrągleniu. Jeśli __x nie jest liczbą skończoną lub przepełnieniem, ta realizacja zwraca wartość LONG_MIN (0x80000000).
27	long lround (double __x) Funkcja lround () zaokrągla __x do najbliższej liczby całkowitej, ale zaokrągla przypadki w połowie odległości od zera (zamiast do najbliższej parzystej liczby całkowitej). Ta funkcja jest podobna do funkcji round (), ale różni się typem zwracanej wartości i tym, że możliwe jest jej przepełnienie. Returns Długa liczba całkowita w zaokrągleniu. Jeśli __x nie jest liczbą skończoną lub wystąpiło przepełnienie, ta realizacja zwraca wartość LONG_MIN (0x80000000).
28	double modf (double __x, double * __iptr ) Funkcja modf () dzieli argument __x na części całkowite i ułamkowe, z których każda ma ten sam znak co argument. Przechowuje integralną część jako podwójną w obiekcie wskazywanym przez __iptr. Funkcja modf () zwraca część ułamkową __x ze znakiem. Note- Ta implementacja pomija pisanie przez wskaźnik zerowy. Jednak GCC 4.3 może zastąpić tę funkcję kodem wbudowanym, który nie pozwala na użycie adresu NULL w celu uniknięcia przechowywania.
29	float modff (float __x, float * __iptr) Alias ​​dla modf ().
30	double pow (double __x, double __y) Funkcja pow () zwraca wartość __x do wykładnika __y.
31	double round (double __x) Funkcja round () zaokrągla __x do najbliższej liczby całkowitej, ale zaokrągla przypadki w połowie odległości od zera (zamiast do najbliższej parzystej liczby całkowitej). Przelew jest niemożliwy. Returns Wartość zaokrąglona. Jeśli __x jest całką lub nieskończoną, zwracany jest sam __x. Jeśli __x jestNaN, następnie NaN jest zwracany.
32	int signbit (double __x) Funkcja signbit () zwraca wartość różną od zera, jeśli wartość __x ma ustawiony bit znaku. To nie to samo, co `__x <0.0 ', ponieważ zmiennoprzecinkowy IEEE 754 pozwala na podpisywanie zera. Porównanie „-0,0 <0,0” jest fałszywe, ale „signbit (-0,0)” zwróci wartość różną od zera.
33	double sin (double __x) Funkcja sin () zwraca sinus z __x, mierzony w radianach.
34	double sinh (double __x) Funkcja sinh () zwraca hiperboliczny sinus z __x.
35	double sqrt (double __x) Funkcja sqrt () zwraca nieujemny pierwiastek kwadratowy z __x.
36	double square (double __x) Funkcja square () zwraca __x * __x. Note - Ta funkcja nie należy do standardowej definicji C.
37	double tan (double __x) Funkcja tan () zwraca tangens __x, mierzony w radianach.
38	double tanh ( double __x) Funkcja tanh () zwraca hiperboliczną tangens z __x.
39	double trunc (double __x) Funkcja trunc () zaokrągla __x do najbliższej liczby całkowitej nie większej w wartości bezwzględnej.

Przykład

Poniższy przykład pokazuje, jak używać najpopularniejszych funkcji biblioteki math.h -

double double__x = 45.45 ;
double double__y = 30.20 ;

void setup() {
   Serial.begin(9600);
   Serial.print("cos num = ");
   Serial.println (cos (double__x) ); // returns cosine of x
   Serial.print("absolute value of num = ");
   Serial.println (fabs (double__x) ); // absolute value of a float
   Serial.print("floating point modulo = ");
   Serial.println (fmod (double__x, double__y)); // floating point modulo
   Serial.print("sine of num = ");
   Serial.println (sin (double__x) ) ;// returns sine of x
   Serial.print("square root of num : ");
   Serial.println ( sqrt (double__x) );// returns square root of x
   Serial.print("tangent of num : ");
   Serial.println ( tan (double__x) ); // returns tangent of x
   Serial.print("exponential value of num : ");
   Serial.println ( exp (double__x) ); // function returns the exponential value of x.
   Serial.print("cos num : ");

   Serial.println (atan (double__x) ); // arc tangent of x
   Serial.print("tangent of num : ");
   Serial.println (atan2 (double__y, double__x) );// arc tangent of y/x
   Serial.print("arc tangent of num : ");
   Serial.println (log (double__x) ) ; // natural logarithm of x
   Serial.print("cos num : ");
   Serial.println ( log10 (double__x)); // logarithm of x to base 10.
   Serial.print("logarithm of num to base 10 : ");
   Serial.println (pow (double__x, double__y) );// x to power of y
   Serial.print("power of num : ");
   Serial.println (square (double__x)); // square of x
}

void loop() {

}

Wynik

cos num = 0.10
absolute value of num = 45.45
floating point modulo =15.25
sine of num = 0.99
square root of num : 6.74
tangent of num : 9.67
exponential value of num : ovf
cos num : 1.55
tangent of num : 0.59
arc tangent of num : 3.82
cos num : 1.66
logarithm of num to base 10 : inf
power of num : 2065.70

Musisz używać trygonometrii praktycznie tak, jak obliczanie odległości poruszającego się obiektu lub prędkości kątowej. Arduino zapewnia tradycyjne funkcje trygonometryczne (sin, cos, tan, asin, acos, atan), które można podsumować, pisząc ich prototypy. Math.h zawiera prototyp funkcji trygonometrycznej.

Dokładna składnia trygonometryczna

double sin(double x); //returns sine of x radians
double cos(double y); //returns cosine of y radians
double tan(double x); //returns the tangent of x radians
double acos(double x); //returns A, the angle corresponding to cos (A) = x
double asin(double x); //returns A, the angle corresponding to sin (A) = x
double atan(double x); //returns A, the angle corresponding to tan (A) = x

Przykład

double sine = sin(2); // approximately 0.90929737091
double cosine = cos(2); // approximately -0.41614685058
double tangent = tan(2); // approximately -2.18503975868

Arduino Due to płytka mikrokontrolera oparta na procesorze Atmel SAM3X8E ARM Cortex-M3. Jest to pierwsza płytka Arduino oparta na 32-bitowym mikrokontrolerze z rdzeniem ARM.

Ważne funkcje -

• Posiada 54 cyfrowe piny wejściowe / wyjściowe (z których 12 może służyć jako wyjścia PWM)
• 12 wejść analogowych
• 4 UART (sprzętowe porty szeregowe)
• Zegar 84 MHz, połączenie USB OTG
• 2 DAC (cyfrowo-analogowe), 2 TWI, gniazdo zasilania, złącze SPI, złącze JTAG
• Przycisk resetowania i przycisk kasowania

Charakterystyka płytki Arduino Due

Napięcie robocze	Prędkość procesora	Wejście / wyjście analogowe	Cyfrowe IO / PWM	EEPROM [KB]	SRAM [KB]	Flash [KB]	USB	UART
3,3 wolt	84 Mhz	12/2	54/12	-	96	512	2 mikro	4

Komunikacja

• 4 sprzętowe UART
• 2 I2C
• 1 interfejs CAN (protokół komunikacji samochodowej)
• 1 SPI
• 1 interfejs JTAG (10 pinów)
• 1 host USB (jak Leonardo)
• 1 port programowania

W przeciwieństwie do większości płyt Arduino, płyta Arduino Due działa pod napięciem 3,3 V. Maksymalne napięcie, które mogą tolerować piny I / O, wynosi 3,3 V. Przyłożenie napięć wyższych niż 3,3 V do któregokolwiek z pinów I / O może spowodować uszkodzenie płyty.

Płytka zawiera wszystko co potrzebne do obsługi mikrokontrolera. Możesz po prostu podłączyć go do komputera za pomocą kabla micro-USB lub zasilać go za pomocą adaptera AC-to-DC lub baterii, aby rozpocząć. Due jest kompatybilny ze wszystkimi osłonami Arduino pracującymi przy napięciu 3,3 V.

Arduino Zero

Zero to proste i wydajne 32-bitowe rozszerzenie platformy stworzonej przez ONZ. Płytka Zero rozszerza rodzinę, zapewniając zwiększoną wydajność, umożliwiając różnorodne projekty dla urządzeń i działa jako doskonałe narzędzie edukacyjne do nauki tworzenia aplikacji 32-bitowych.

Ważne cechy to -

• Aplikacje Zero obejmują inteligentne urządzenia IoT, technologię do noszenia, zaawansowaną automatyzację i szaloną robotykę.

• Płyta jest zasilana przez mikrokontroler SAMD21 firmy Atmel, który zawiera 32-bitowy rdzeń ARM Cortex® M0 +.

• Jedną z jego najważniejszych cech jest Embedded Debugger (EDBG) firmy Atmel, który zapewnia pełny interfejs debugowania bez konieczności stosowania dodatkowego sprzętu, znacznie zwiększając łatwość obsługi debugowania programowego.

• EDBG obsługuje również wirtualny port COM, którego można używać do programowania urządzeń i bootloadera.

Charakterystyka płytki Arduino Zero

Napięcie robocze	Prędkość procesora	Wejście / wyjście analogowe	Cyfrowe IO / PWM	EEPROM [KB]	SRAM [KB]	Flash [KB]	USB	UART
3,3 wolt	48 Mhz	6/1	14/10	-	32	256	2 mikro	2

W przeciwieństwie do większości płyt Arduino i Genuino, Zero działa pod napięciem 3,3 V. Maksymalne napięcie, które mogą tolerować piny I / O, wynosi 3,3 V. Przyłożenie napięć wyższych niż 3,3 V do któregokolwiek z pinów I / O może spowodować uszkodzenie płyty.

Płytka zawiera wszystko co potrzebne do obsługi mikrokontrolera. Możesz po prostu podłączyć go do komputera za pomocą kabla micro-USB lub zasilić go za pomocą adaptera AC-to-DC lub baterii, aby rozpocząć. Zero jest kompatybilny ze wszystkimi ekranami pracującymi przy 3,3V.

Modulacja szerokości impulsu lub PWM to powszechna technika używana do zmiany szerokości impulsów w ciągu impulsów. PWM ma wiele zastosowań, takich jak sterowanie serwomechanizmami i regulatorami prędkości, ograniczanie efektywnej mocy silników i diod LED.

Podstawowa zasada PWM

Modulacja szerokości impulsu jest zasadniczo falą prostokątną o zmiennym czasie wysokim i niskim. Na poniższym rysunku przedstawiono podstawowy sygnał PWM.

Z PWM związane są różne terminy -

• On-Time - Czas trwania sygnału czasu jest długi.

• Off-Time - Czas trwania sygnału czasu jest niski.

• Period - Jest reprezentowany jako suma czasu włączenia i wyłączenia sygnału PWM.

• Duty Cycle - Jest reprezentowany jako procent sygnału czasu, który pozostaje włączony w okresie sygnału PWM.

Kropka

Jak pokazano na rysunku, T _on oznacza czas włączenia, a T _off oznacza czas wyłączenia sygnału. Okres jest sumą czasów włączenia i wyłączenia i jest obliczany zgodnie z następującym równaniem -

Cykl pracy

Cykl pracy jest obliczany jako czas pracy w danym okresie. Wykorzystując okres obliczony powyżej, cykl pracy jest obliczany jako -

Funkcja analogWrite ()

Plik analogWrite()funkcja zapisuje wartość analogową (falę PWM) do pinu. Może służyć do oświetlania diod LED o różnej jasności lub napędzania silnika z różnymi prędkościami. Po wywołaniu funkcji analogWrite () pin wygeneruje stałą falę prostokątną o określonym cyklu pracy do następnego wywołania analogWrite () lub wywołania digitalRead () lub digitalWrite () na tym samym pinie. Częstotliwość sygnału PWM na większości pinów wynosi około 490 Hz. Na płytach Uno i podobnych piny 5 i 6 mają częstotliwość około 980 Hz. Piny 3 i 11 w Leonardo również pracują z częstotliwością 980 Hz.

Na większości płyt Arduino (tych z ATmega168 lub ATmega328) ta funkcja działa na pinach 3, 5, 6, 9, 10 i 11. Na Arduino Mega działa na pinach 2 - 13 i 44 - 46. Starsze Arduino płyty z obsługą tylko ATmega8 analogWrite() na stykach 9, 10 i 11.

Arduino Due obsługuje analogWrite()na pinach od 2 do 13 oraz pinach DAC0 i DAC1. W przeciwieństwie do pinów PWM, DAC0 i DAC1 są przetwornikami cyfrowo-analogowymi i działają jako prawdziwe wyjścia analogowe.

Nie musisz wywoływać pinMode (), aby ustawić pin jako wyjście przed wywołaniem analogWrite ().

Składnia funkcji analogWrite ()

analogWrite ( pin , value ) ;

value - cykl pracy: od 0 (zawsze wyłączony) do 255 (zawsze włączony).

Example

int ledPin = 9; // LED connected to digital pin 9
int analogPin = 3; // potentiometer connected to analog pin 3
int val = 0; // variable to store the read value

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

void loop() {
   val = analogRead(analogPin); // read the input pin
   analogWrite(ledPin, (val / 4)); // analogRead values go from 0 to 1023, 
      // analogWrite values from 0 to 255
}

Aby wygenerować liczby losowe, możesz użyć funkcji liczb losowych Arduino. Mamy dwie funkcje -

• randomSeed(seed)
• random()

randomSeed (nasiona)

Funkcja randomSeed (seed) resetuje generator liczb pseudolosowych Arduino. Chociaż rozkład liczb zwracanych przez random () jest zasadniczo losowy, sekwencja jest przewidywalna. Powinieneś zresetować generator do jakiejś losowej wartości. Jeśli masz niepodłączony pin analogowy, może on odbierać losowe szumy z otoczenia. Mogą to być fale radiowe, promienie kosmiczne, zakłócenia elektromagnetyczne z telefonów komórkowych, światła fluorescencyjne i tak dalej.

Przykład

randomSeed(analogRead(5)); // randomize using noise from analog pin 5

losowy( )

Funkcja losowa generuje liczby pseudolosowe. Poniżej znajduje się składnia.

random () Składnia instrukcji

long random(max) // it generate random numbers from 0 to max
long random(min, max) // it generate random numbers from min to max

Przykład

long randNumber;

void setup() {
   Serial.begin(9600);
   // if analog input pin 0 is unconnected, random analog
   // noise will cause the call to randomSeed() to generate
   // different seed numbers each time the sketch runs.
   // randomSeed() will then shuffle the random function.
   randomSeed(analogRead(0));
}

void loop() {
   // print a random number from 0 to 299
   Serial.print("random1=");
   randNumber = random(300);
   Serial.println(randNumber); // print a random number from 0to 299
   Serial.print("random2=");
   randNumber = random(10, 20);// print a random number from 10 to 19
   Serial.println (randNumber);
   delay(50);
}

Odświeżmy teraz naszą wiedzę o niektórych podstawowych pojęciach, takich jak bity i bajty.

Bity

Trochę to tylko cyfra binarna.

• System binarny wykorzystuje dwie cyfry, 0 i 1.

• Podobnie jak w systemie liczb dziesiętnych, w którym cyfry liczby nie mają tej samej wartości, „znaczenie” bitu zależy od jego pozycji w liczbie binarnej. Na przykład cyfry w liczbie dziesiętnej 666 są takie same, ale mają różne wartości.

Bajty

Bajt składa się z ośmiu bitów.

• Jeśli bit jest cyfrą, logiczne jest, że bajty reprezentują liczby.

• Można na nich wykonywać wszystkie operacje matematyczne.

• Cyfry w bajcie również nie mają tego samego znaczenia.

• Najbardziej lewy bit ma największą wartość zwaną Najbardziej znaczącym bitem (MSB).

• Najbardziej prawy bit ma najmniejszą wartość i dlatego nazywany jest najmniej znaczącym bitem (LSB).

• Ponieważ osiem zer i jedynek z jednego bajtu można łączyć na 256 różnych sposobów, największa liczba dziesiętna, którą można przedstawić za pomocą jednego bajtu, to 255 (jedna kombinacja oznacza zero).

Przerwania zatrzymują bieżącą pracę Arduino tak, że można wykonać inną pracę.

Przypuśćmy, że siedzisz w domu i rozmawiasz z kimś. Nagle dzwoni telefon. Przestajesz rozmawiać i podnosisz telefon, aby porozmawiać z dzwoniącym. Po zakończeniu rozmowy telefonicznej wróć do rozmowy z tą osobą, zanim zadzwonił telefon.

Podobnie możesz myśleć o głównej procedurze jako o rozmowie z kimś, dzwonek telefonu powoduje, że przestajesz rozmawiać. Procedura obsługi przerwań to proces rozmowy telefonicznej. Po zakończeniu rozmowy telefonicznej wracasz do swojej głównej rutyny czatowania. Ten przykład wyjaśnia dokładnie, w jaki sposób przerwanie powoduje działanie procesora.

Program główny działa i wykonuje jakąś funkcję w obwodzie. Jednak gdy wystąpi przerwanie, program główny zatrzymuje się, podczas gdy wykonywana jest inna procedura. Po zakończeniu tej procedury procesor wraca do procedury głównej.

Ważne funkcje

Oto kilka ważnych funkcji dotyczących przerwań -

• Przerwania mogą pochodzić z różnych źródeł. W tym przypadku używamy przerwania sprzętowego, które jest wyzwalane przez zmianę stanu na jednym z pinów cyfrowych.

• Większość konstrukcji Arduino ma dwa przerwania sprzętowe (nazywane „przerwaniem0” i „przerwaniem1”) podłączone na stałe do cyfrowych styków we / wy 2 i 3.

• Arduino Mega ma sześć przerwań sprzętowych, w tym dodatkowe przerwania (od „przerwania2” do „przerwania5”) na stykach 21, 20, 19 i 18.

• Procedurę można zdefiniować za pomocą specjalnej funkcji zwanej „Procedurą obsługi przerwania” (zwykle znanej jako ISR).

• Możesz zdefiniować procedurę i określić warunki na zboczu narastającym, opadającym lub obu. W tych szczególnych warunkach przerwanie byłoby obsługiwane.

• Możliwe jest automatyczne wykonywanie tej funkcji za każdym razem, gdy zdarzenie ma miejsce na pinie wejściowym.

Rodzaje przerwań

Istnieją dwa rodzaje przerwań -

• Hardware Interrupts - Występują w odpowiedzi na zdarzenie zewnętrzne, takie jak wysoki lub niski pin przerwania zewnętrznego.

• Software Interrupts- Występują w odpowiedzi na polecenie przesłane w oprogramowaniu. Jedynym rodzajem przerwań obsługiwanym przez „język Arduino” jest funkcja attachInterrupt ().

Używanie przerwań w Arduino

Przerwania są bardzo przydatne w programach Arduino, ponieważ pomagają w rozwiązywaniu problemów z synchronizacją. Dobrym zastosowaniem przerwania jest odczyt enkodera obrotowego lub obserwacja wejścia użytkownika. Ogólnie rzecz biorąc, ISR powinien być możliwie krótki i szybki. Jeśli twój szkic używa wielu ISR, tylko jeden może działać naraz. Inne przerwania będą wykonywane po zakończeniu bieżącego w kolejności zależnej od ich priorytetu.

Zazwyczaj zmienne globalne są używane do przekazywania danych między ISR a głównym programem. Aby upewnić się, że zmienne współdzielone między ISR a głównym programem są poprawnie aktualizowane, zadeklaruj je jako nietrwałe.

Składnia instrukcji attachInterrupt

attachInterrupt(digitalPinToInterrupt(pin),ISR,mode);//recommended for arduino board
attachInterrupt(pin, ISR, mode) ; //recommended Arduino Due, Zero only
//argument pin: the pin number
//argument ISR: the ISR to call when the interrupt occurs; 
   //this function must take no parameters and return nothing. 
   //This function is sometimes referred to as an interrupt service routine.
//argument mode: defines when the interrupt should be triggered.

Poniższe trzy stałe są wstępnie zdefiniowane jako prawidłowe wartości -

• LOW wyzwalanie przerwania, gdy pin jest niski.

• CHANGE wyzwalanie przerwania za każdym razem, gdy pin zmienia wartość.

• FALLING za każdym razem, gdy pin przechodzi z wysokiego na niski.

Example

int pin = 2; //define interrupt pin to 2
volatile int state = LOW; // To make sure variables shared between an ISR
//the main program are updated correctly,declare them as volatile.

void setup() {
   pinMode(13, OUTPUT); //set pin 13 as output
   attachInterrupt(digitalPinToInterrupt(pin), blink, CHANGE);
   //interrupt at pin 2 blink ISR when pin to change the value
} 
void loop() { 
   digitalWrite(13, state); //pin 13 equal the state value
} 

void blink() { 
   //ISR function
   state = !state; //toggle the state when the interrupt occurs
}

Aby zapewnić taką wymianę danych, zdefiniowano setki protokołów komunikacyjnych. Każdy protokół można podzielić na jedną z dwóch kategorii: równoległy lub szeregowy.

Komunikacja równoległa

Równoległe połączenie Arduino z urządzeniami peryferyjnymi za pośrednictwem portów wejścia / wyjścia jest idealnym rozwiązaniem na krótsze odległości do kilku metrów. Jednak w innych przypadkach, gdy konieczne jest nawiązanie komunikacji między dwoma urządzeniami na większe odległości, nie jest możliwe zastosowanie połączenia równoległego. Interfejsy równoległe przesyłają wiele bitów w tym samym czasie. Zwykle wymagają szyn danych - przesyłających przez osiem, szesnaście lub więcej przewodów. Dane są przesyłane w ogromnych, załamujących się falach jedynek i zer.

Zalety i wady komunikacji równoległej

Komunikacja równoległa z pewnością ma swoje zalety. Jest szybszy niż seryjny, prosty i stosunkowo łatwy do wdrożenia. Jednak wymaga wielu portów wejścia / wyjścia (I / O) i linii. Jeśli kiedykolwiek musiałeś przenieść projekt z podstawowego Arduino Uno na Mega, wiesz, że linie I / O na mikroprocesorze mogą być cenne i nieliczne. Dlatego preferujemy komunikację szeregową, poświęcając potencjalną prędkość na rzecz nieruchomości pinowych.

Moduły komunikacji szeregowej

Obecnie większość płyt Arduino jest zbudowanych z kilkoma różnymi systemami komunikacji szeregowej w standardzie.

To, który z tych systemów jest używany, zależy od następujących czynników -

• Z iloma urządzeniami mikrokontroler ma wymieniać dane?
• Jak szybka musi być wymiana danych?
• Jaka jest odległość między tymi urządzeniami?
• Czy konieczne jest jednoczesne wysyłanie i odbieranie danych?

Jedną z najważniejszych rzeczy dotyczących komunikacji szeregowej jest Protocol, których należy ściśle przestrzegać. Jest to zbiór reguł, które należy zastosować, aby urządzenia mogły poprawnie interpretować wymieniane przez siebie dane. Na szczęście Arduino dba o to automatycznie, dzięki czemu praca programisty / użytkownika sprowadza się do prostego zapisu (dane do przesłania) i odczytu (dane odebrane).

Rodzaje komunikacji szeregowej

Komunikację szeregową można dalej sklasyfikować jako -

• Synchronous - Urządzenia, które są zsynchronizowane, używają tego samego zegara, a ich czas jest zsynchronizowany ze sobą.

• Asynchronous - Urządzenia, które są asynchroniczne, mają własne zegary i są wyzwalane przez wyjście poprzedniego stanu.

Łatwo jest dowiedzieć się, czy urządzenie jest synchroniczne, czy nie. Jeśli ten sam zegar jest podany do wszystkich podłączonych urządzeń, są one synchroniczne. Jeśli nie ma linii zegara, jest asynchroniczna.

Na przykład moduł UART (Universal Asynchronous Receiver Transmitter) jest asynchroniczny.

Asynchroniczny protokół szeregowy ma wiele wbudowanych reguł. Zasady te to nic innego jak mechanizmy, które zapewniają solidne i wolne od błędów przesyłanie danych. Te mechanizmy, które otrzymujemy, aby uniknąć zewnętrznego sygnału zegarowego, to:

• Bity synchronizacji
• Bity danych
• Bity parzystości
• Szybkość transmisji

Bity synchronizacji

Bity synchronizacji to dwa lub trzy specjalne bity przesyłane z każdym pakietem danych. Są to bit startu i bitu stopu. Zgodnie z ich nazwą bity te oznaczają odpowiednio początek i koniec pakietu.

Zawsze jest tylko jeden bit początkowy, ale liczbę bitów stopu można skonfigurować na jeden lub dwa (chociaż zwykle pozostaje jeden).

Bit początkowy jest zawsze wskazywany przez bezczynną linię danych przechodzącą od 1 do 0, podczas gdy bity stopu przechodzą z powrotem do stanu bezczynności, utrzymując linię na 1.

Bity danych

Ilość danych w każdym pakiecie można ustawić na dowolny rozmiar od 5 do 9 bitów. Z pewnością standardowy rozmiar danych to podstawowy 8-bitowy bajt, ale inne rozmiary mają swoje zastosowania. 7-bitowy pakiet danych może być bardziej wydajny niż 8, zwłaszcza jeśli przesyłasz tylko 7-bitowe znaki ASCII.

Bity parzystości

Użytkownik może wybrać, czy ma być bit parzystości, czy nie, a jeśli tak, to czy parzystość ma być nieparzysta czy parzysta. Bit parzystości wynosi 0, jeśli liczba jedynek między bitami danych jest parzysta. Nieparzysty parytet jest wręcz przeciwny.

Szybkość transmisji

Termin szybkość transmisji jest używany do określenia liczby bitów przesyłanych na sekundę [bps]. Zauważ, że odnosi się do bitów, a nie bajtów. Zazwyczaj protokół wymaga, aby każdy bajt był przesyłany wraz z kilkoma bitami sterującymi. Oznacza to, że jeden bajt w szeregowym strumieniu danych może składać się z 11 bitów. Na przykład, jeśli szybkość transmisji wynosi 300 bps, to można przesyłać maksymalnie 37 i minimum 27 bajtów na sekundę.

Arduino UART

Poniższy kod sprawi, że Arduino wyśle ​​powitanie do świata po uruchomieniu.

void setup() {
   Serial.begin(9600); //set up serial library baud rate to 9600
   Serial.println("hello world"); //print hello world
}

void loop() {

}

Po przesłaniu szkicu Arduino do Arduino otwórz monitor szeregowy

w prawej górnej części Arduino IDE.

Wpisz cokolwiek w górnym polu monitora szeregowego i naciśnij wyślij lub enter na klawiaturze. Spowoduje to wysłanie serii bajtów do Arduino.

Poniższy kod zwraca wszystko, co otrzymuje jako dane wejściowe.

Poniższy kod sprawi, że Arduino dostarczy dane wyjściowe w zależności od dostarczonego wejścia.

void setup() {
   Serial.begin(9600); //set up serial library baud rate to 9600
}

void loop() {
   if(Serial.available()) //if number of bytes (characters) available for reading from { 
      serial port
      Serial.print("I received:"); //print I received
      Serial.write(Serial.read()); //send what you read
   }
}

Zauważ, że Serial.print i Serial.println odeśle rzeczywisty kod ASCII, podczas gdy Serial.writeodeśle rzeczywisty tekst. Aby uzyskać więcej informacji, zobacz kody ASCII.

Układ scalony (I2C) to układ do szeregowej wymiany danych pomiędzy mikrokontrolerami a wyspecjalizowanymi układami scalonymi nowej generacji. Jest używany, gdy odległość między nimi jest niewielka (odbiornik i nadajnik znajdują się zwykle na tej samej płytce drukowanej). Podłączenie odbywa się za pomocą dwóch przewodów. Jeden służy do przesyłania danych, a drugi do synchronizacji (sygnał zegarowy).

Jak widać na poniższym rysunku, jedno urządzenie jest zawsze urządzeniem głównym. Wykonuje adresowanie jednego chipa slave przed rozpoczęciem komunikacji. W ten sposób jeden mikrokontroler może komunikować się z 112 różnymi urządzeniami. Szybkość transmisji wynosi zwykle 100 Kb / s (tryb standardowy) lub 10 Kb / s (tryb małej szybkości transmisji). Niedawno pojawiły się systemy o szybkości transmisji 3,4 Mb / s. Odległość między urządzeniami, które komunikują się po magistrali I2C jest ograniczona do kilku metrów.

Piny płyty I2C

Magistrala I2C składa się z dwóch sygnałów - SCL i SDA. SCL to sygnał zegarowy, a SDA to sygnał danych. Obecny nadrzędny magistrali zawsze generuje sygnał zegarowy. Niektóre urządzenia podrzędne mogą czasami wymuszać niski zegar, aby opóźnić wysyłanie większej liczby danych przez urządzenie główne (lub wymagać więcej czasu na przygotowanie danych, zanim master spróbuje je wyrejestrować). Nazywa się to „rozciąganiem zegara”.

Poniżej znajdują się piny dla różnych płyt Arduino -

• Uno, Pro Mini A4 (SDA), A5 (SCL)
• Mega, Due 20 (SDA), 21 (SCL)
• Leonardo, Yun 2 (SDA), 3 (SCL)

Arduino I2C

Mamy dwa tryby - kod główny i kod slave - do połączenia dwóch płytek Arduino za pomocą I2C. Oni są -

• Nadajnik główny / odbiornik podrzędny
• Odbiornik główny / nadajnik podrzędny

Nadajnik główny / odbiornik podrzędny

Zobaczmy teraz, co jest nadajnikiem głównym i odbiornikiem podrzędnym.

Nadajnik główny

Następujące funkcje służą do inicjalizacji biblioteki Wire i dołączania do magistrali I2C jako master lub slave. Zwykle jest to wywoływane tylko raz.

• Wire.begin(address) - Adres to 7-bitowy adres slave w naszym przypadku, ponieważ master nie jest określony i dołączy do magistrali jako master.

• Wire.beginTransmission(address) - Rozpocznij transmisję do urządzenia slave I2C z podanym adresem.

• Wire.write(value) - Kolejkuje bajty do transmisji z urządzenia głównego do urządzenia podrzędnego (pomiędzy wywołaniami funkcji beginTransmission () i endTransmission ()).

• Wire.endTransmission() - Kończy transmisję do urządzenia podrzędnego, która została rozpoczęta przez beginTransmission () i przesyła bajty, które były ustawione w kolejce przez wire.write ().

Example

#include <Wire.h> //include wire library

void setup() //this will run only once { 
   Wire.begin(); // join i2c bus as master
} 

short age = 0; 

void loop() {   
   Wire.beginTransmission(2); 
   // transmit to device #2
   Wire.write("age is = ");
   Wire.write(age); // sends one byte
   Wire.endTransmission(); // stop transmitting
   delay(1000); 
}

Slave Receiver

Używane są następujące funkcje -

• Wire.begin(address) - Adres to 7-bitowy adres slave.

• Wire.onReceive(received data handler) - Funkcja wywoływana, gdy urządzenie slave otrzymuje dane od mastera.

• Wire.available() - Zwraca liczbę bajtów dostępnych do pobrania za pomocą Wire.read (). Powinno to zostać wywołane wewnątrz procedury obsługi Wire.onReceive ().

Example

#include <Wire.h> //include wire library

void setup() {  //this will run only once
   Wire.begin(2); // join i2c bus with address #2
   Wire.onReceive(receiveEvent); // call receiveEvent when the master send any thing 
   Serial.begin(9600); // start serial for output to print what we receive 
}

void loop() {   
   delay(250); 
}

//-----this function will execute whenever data is received from master-----//

void receiveEvent(int howMany) { 
   while (Wire.available()>1) // loop through all but the last {
      char c = Wire.read(); // receive byte as a character
      Serial.print(c); // print the character
   }
}

Odbiornik główny / nadajnik podrzędny

Zobaczmy teraz, co jest głównym odbiornikiem i nadajnikiem podrzędnym.

Główny odbiornik

Master jest zaprogramowany do żądania, a następnie odczytywania bajtów danych, które są wysyłane z unikalnie adresowanego Slave Arduino.

Używana jest następująca funkcja -

Wire.requestFrom(address,number of bytes)- Używany przez mastera do żądania bajtów z urządzenia slave. Bajty można następnie pobrać za pomocą funkcji wire.available () i wire.read ().

Example

#include <Wire.h> //include wire library void setup() { 
   Wire.begin(); // join i2c bus (address optional for master) 
   Serial.begin(9600); // start serial for output
} 

void loop() { 
   Wire.requestFrom(2, 1); // request 1 bytes from slave device #2
   while (Wire.available()) // slave may send less than requested {
      char c = Wire.read(); // receive a byte as character
      Serial.print(c); // print the character
   } 
   delay(500); 
}

Nadajnik Slave

Używana jest następująca funkcja.

Wire.onRequest(handler) - Funkcja jest wywoływana, gdy master żąda danych z tego urządzenia slave.

Example

#include <Wire.h> 

void setup() { 
   Wire.begin(2); // join i2c bus with address #2
   Wire.onRequest(requestEvent); // register event
} 

Byte x = 0;

void loop() { 
   delay(100); 
} 

// function that executes whenever data is requested by master
// this function is registered as an event, see setup()

void requestEvent() { 
   Wire.write(x); // respond with message of 1 bytes as expected by master
   x++; 
}

Magistrala Serial Peripheral Interface (SPI) to system komunikacji szeregowej, który wykorzystuje do czterech przewodów, zwykle trzech. Jeden przewodnik służy do odbierania danych, jeden do wysyłania danych, jeden do synchronizacji, a drugi do wyboru urządzenia do komunikacji. Jest to połączenie typu full duplex, co oznacza, że ​​dane są wysyłane i odbierane jednocześnie. Maksymalna prędkość transmisji jest wyższa niż w systemie komunikacji I2C.

Piny tablicy SPI

SPI wykorzystuje następujące cztery przewody -

• SCK - To jest zegar szeregowy sterowany przez mastera.

• MOSI - To jest wyjście master / wejście slave sterowane przez master.

• MISO - To jest wejście master / wyjście slave sterowane przez master.

• SS - To jest przewód wyboru urządzenia podrzędnego.

Używane są następujące funkcje. Musisz dołączyć SPI.h.

• SPI.begin() - Inicjuje magistralę SPI, ustawiając SCK, MOSI i SS na wyjściach, ciągnąc SCK i MOSI w stan niski i wysoki SS.

• SPI.setClockDivider(divider)- Aby ustawić dzielnik zegara SPI względem zegara systemowego. Na płytach opartych na AVR dostępne są dzielniki 2, 4, 8, 16, 32, 64 lub 128. Domyślne ustawienie to SPI_CLOCK_DIV4, które ustawia zegar SPI na jedną czwartą częstotliwości zegara systemowego (5 MHz dla płyty przy 20 MHz).

• Divider - Może to być (SPI_CLOCK_DIV2, SPI_CLOCK_DIV4, SPI_CLOCK_DIV8, SPI_CLOCK_DIV16, SPI_CLOCK_DIV32, SPI_CLOCK_DIV64, SPI_CLOCK_DIV128).

• SPI.transfer(val) - Transfer SPI opiera się na jednoczesnym wysyłaniu i odbieraniu: odebrane dane są zwracane w formacie receivedVal.

• SPI.beginTransaction(SPISettings(speedMaximum, dataOrder, dataMode)) - speedMaximum to zegar, dataOrder (MSBFIRST lub LSBFIRST), dataMode (SPI_MODE0, SPI_MODE1, SPI_MODE2 lub SPI_MODE3).

W SPI mamy cztery tryby pracy w następujący sposób -

• Mode 0 (the default) - Zegar jest zwykle niski (CPOL = 0), a dane są próbkowane przy przejściu od niskiego do wysokiego (zbocze narastające) (CPHA = 0).

• Mode 1 - Zegar jest normalnie niski (CPOL = 0), a dane są próbkowane przy przejściu od wysokiego do niskiego (zbocze opadające) (CPHA = 1).

• Mode 2 - Zegar jest zwykle wysoki (CPOL = 1), a dane są próbkowane przy przejściu od wysokiego do niskiego (zbocze narastające) (CPHA = 0).

• Mode 3 - Zegar jest zwykle wysoki (CPOL = 1), a dane są próbkowane przy przejściu od niskiego do wysokiego (zbocze opadające) (CPHA = 1).

• SPI.attachInterrupt(handler) - Funkcja wywoływana, gdy urządzenie slave otrzymuje dane od mastera.

Teraz połączymy ze sobą dwie płyty Arduino UNO; jeden jako pan, a drugi jako niewolnik.

• (SS): pin 10
• (MOSI): pin 11
• (MISO): pin 12
• (SCK): pin 13

Ziemia jest wspólna. Poniżej znajduje się schematyczne przedstawienie połączenia między obiema płytami -

Zobaczmy przykłady SPI jako Master i SPI jako Slave.

SPI jako MASTER

Przykład

#include <SPI.h>

void setup (void) {
   Serial.begin(115200); //set baud rate to 115200 for usart
   digitalWrite(SS, HIGH); // disable Slave Select
   SPI.begin ();
   SPI.setClockDivider(SPI_CLOCK_DIV8);//divide the clock by 8
}

void loop (void) {
   char c;
   digitalWrite(SS, LOW); // enable Slave Select
   // send test string
   for (const char * p = "Hello, world!\r" ; c = *p; p++) {
      SPI.transfer (c);
      Serial.print(c);
   }
   digitalWrite(SS, HIGH); // disable Slave Select
   delay(2000);
}

SPI jako SLAVE

Przykład

#include <SPI.h>
char buff [50];
volatile byte indx;
volatile boolean process;

void setup (void) {
   Serial.begin (115200);
   pinMode(MISO, OUTPUT); // have to send on master in so it set as output
   SPCR |= _BV(SPE); // turn on SPI in slave mode
   indx = 0; // buffer empty
   process = false;
   SPI.attachInterrupt(); // turn on interrupt
}
ISR (SPI_STC_vect) // SPI interrupt routine { 
   byte c = SPDR; // read byte from SPI Data Register
   if (indx < sizeof buff) {
      buff [indx++] = c; // save data in the next index in the array buff
      if (c == '\r') //check for the end of the word
      process = true;
   }
}

void loop (void) {
   if (process) {
      process = false; //reset the process
      Serial.println (buff); //print the array on serial monitor
      indx= 0; //reset button to zero
   }
}

Diody LED to małe, mocne światła, które są używane w wielu różnych zastosowaniach. Na początek zajmiemy się miganiem diody, czyli Hello World mikrokontrolerów. Jest to tak proste, jak włączanie i wyłączanie światła. Ustanowienie tego ważnego punktu odniesienia zapewni solidne podstawy, ponieważ pracujemy nad bardziej złożonymi eksperymentami.

Wymagane składniki

Będziesz potrzebował następujących komponentów -

• 1 × Breadboard
• 1 × Arduino Uno R3
• 1 × LED
• Rezystor 1 × 330Ω
• 2 × sweter

Procedura

Postępuj zgodnie ze schematem obwodu i podłącz komponenty na płytce stykowej, jak pokazano na poniższym obrazku.

Note- Aby sprawdzić biegunowość diody LED, przyjrzyj się jej uważnie. Krótsza z dwóch nóżek, w kierunku płaskiej krawędzi żarówki, wskazuje biegun ujemny.

Komponenty, takie jak rezystory, muszą mieć wygięte zaciski pod kątem 90 °, aby prawidłowo dopasować gniazda płytki stykowej. Możesz także skrócić terminale.

Naszkicować

Otwórz oprogramowanie Arduino IDE na swoim komputerze. Kodowanie w języku Arduino będzie sterować twoim obwodem. Otwórz nowy plik szkicu, klikając Nowy.

Kod Arduino

/*
   Blink
   Turns on an LED on for one second, then off for one second, repeatedly.
*/

// the setup function runs once when you press reset or power the board

void setup() {  // initialize digital pin 13 as an output.
   pinMode(2, OUTPUT);
}

// the loop function runs over and over again forever

void loop() {
   digitalWrite(2, HIGH); // turn the LED on (HIGH is the voltage level)
   delay(1000); // wait for a second
   digitalWrite(2, LOW); // turn the LED off by making the voltage LOW
   delay(1000); // wait for a second
}

Kod do uwagi

pinMode(2, OUTPUT)- Zanim będziesz mógł użyć jednego z pinów Arduino, musisz powiedzieć Arduino Uno R3, czy jest to WEJŚCIE czy WYJŚCIE. W tym celu używamy wbudowanej „funkcji” o nazwie pinMode ().

digitalWrite(2, HIGH) - Gdy używasz styku jako WYJŚCIA, możesz ustawić go na WYSOKI (wyjście 5 V) lub NISKI (wyjście 0 V).

Wynik

Powinieneś zobaczyć, jak dioda LED włącza się i wyłącza. Jeśli wymagane wyjście nie jest widoczne, upewnij się, że poprawnie zmontowałeś obwód, zweryfikowałeś i załadowałeś kod na swoją płytkę.

Ten przykład demonstruje użycie funkcji analogWrite () do wygaszania diody LED. AnalogWrite wykorzystuje modulację szerokości impulsu (PWM), bardzo szybko włączając i wyłączając cyfrowy pin z różnymi stosunkami między włączaniem i wyłączaniem, aby stworzyć efekt zanikania.

Wymagane składniki

Będziesz potrzebował następujących komponentów -

• 1 × Breadboard
• 1 × Arduino Uno R3
• 1 × LED
• Rezystor 1 × 330Ω
• 2 × sweter

Procedura

Postępuj zgodnie ze schematem obwodu i podłącz komponenty na płytce stykowej, jak pokazano na poniższym obrazku.

Note- Aby sprawdzić biegunowość diody LED, przyjrzyj się jej uważnie. Krótsza z dwóch nóżek, w kierunku płaskiej krawędzi żarówki, wskazuje biegun ujemny.

Komponenty, takie jak rezystory, muszą mieć wygięte zaciski pod kątem 90 °, aby prawidłowo dopasować gniazda płytki stykowej. Możesz także skrócić terminale.

Naszkicować

Otwórz oprogramowanie Arduino IDE na swoim komputerze. Kodowanie w języku Arduino będzie sterować twoim obwodem. Otwórz nowy plik szkicu, klikając Nowy.

Kod Arduino

/*
   Fade
   This example shows how to fade an LED on pin 9 using the analogWrite() function.

   The analogWrite() function uses PWM, so if you want to change the pin you're using, be
   sure to use another PWM capable pin. On most Arduino, the PWM pins are identified with
   a "~" sign, like ~3, ~5, ~6, ~9, ~10 and ~11.
*/

int led = 9; // the PWM pin the LED is attached to
int brightness = 0; // how bright the LED is
int fadeAmount = 5; // how many points to fade the LED by
// the setup routine runs once when you press reset:

void setup() {
   // declare pin 9 to be an output:
   pinMode(led, OUTPUT);
}

// the loop routine runs over and over again forever:

void loop() {
   // set the brightness of pin 9:
   analogWrite(led, brightness);
   // change the brightness for next time through the loop:
   brightness = brightness + fadeAmount;
   // reverse the direction of the fading at the ends of the fade:
   if (brightness == 0 || brightness == 255) {
      fadeAmount = -fadeAmount ;
   }
   // wait for 30 milliseconds to see the dimming effect
   delay(300);
}

Kod do uwagi

Po zadeklarowaniu pinu 9 jako pinu LED, nie ma nic do zrobienia w funkcji setup () twojego kodu. Funkcja analogWrite (), której będziesz używać w głównej pętli twojego kodu, wymaga dwóch argumentów: jednego, wskazującego funkcji, na którym pinie ma pisać, a drugiego wskazującego, jaką wartość PWM zapisać.

Aby zgasić i włączyć diodę LED, stopniowo zwiększaj wartości PWM od 0 (całkowicie wyłączone) do 255 (całkowicie włączone), a następnie z powrotem do 0, aby zakończyć cykl. W powyższym szkicu wartość PWM jest ustawiana za pomocą zmiennej zwanej jasnością. Za każdym razem w pętli zwiększa się o wartość zmiennejfadeAmount.

Jeśli jasność osiągnie skrajną wartość (0 lub 255), wartość fadeAmount jest zmieniana na wartość ujemną. Innymi słowy, jeśli fadeAmount wynosi 5, to jest ustawione na -5. Jeśli wynosi -5, to jest ustawione na 5. Przy następnym przejściu przez pętlę zmiana ta powoduje również zmianę kierunku jasności.

analogWrite()może bardzo szybko zmienić wartość PWM, więc opóźnienie na końcu szkicu kontroluje prędkość przejścia. Spróbuj zmienić wartość opóźnienia i zobacz, jak zmienia efekt zanikania.

Wynik

Powinieneś zobaczyć, jak jasność diody LED zmienia się stopniowo.

Ten przykład pokaże, jak odczytać wejście analogowe na pinie analogowym 0. Wejście jest konwertowane z analogRead () na napięcie i drukowane na szeregowym monitorze oprogramowania Arduino (IDE).

Wymagane składniki

Będziesz potrzebował następujących komponentów -

• 1 × Breadboard
• 1 × Arduino Uno R3
• Rezystor zmienny 1 × 5K (potencjometr)
• 2 × sweter

Procedura

Postępuj zgodnie ze schematem obwodu i podłącz komponenty na płytce stykowej, jak pokazano na poniższym obrazku.

Potencjometr

Potencjometr (lub potencjometr) to prosty przetwornik elektromechaniczny. Przekształca ruch obrotowy lub liniowy od operatora wejściowego na zmianę oporu. Ta zmiana jest (lub może być) używana do kontrolowania wszystkiego, od głośności systemu hi-fi do kierunku ogromnego kontenerowca.

Potencjometr, jaki znamy, był pierwotnie znany jako reostat (zasadniczo zmienny rezystor drutowy). Różnorodność dostępnych garnków jest teraz dość zdumiewająca, a początkującemu (w szczególności) może być bardzo trudno ustalić, który typ jest odpowiedni do danego zadania. Kilka różnych typów garnków, które można wykorzystać do tego samego zadania, utrudnia pracę.

Obraz po lewej stronie przedstawia standardowy schematyczny symbol garnka. Obraz po prawej stronie to potencjometr.

Naszkicować

Otwórz oprogramowanie Arduino IDE na swoim komputerze. Kodowanie w języku Arduino będzie sterować twoim obwodem. Otwórz nowy plik szkicu, klikając Nowy.

Kod Arduino

/*
   ReadAnalogVoltage
   Reads an analog input on pin 0, converts it to voltage, 
   and prints the result to the serial monitor.
   Graphical representation is available using serial plotter (Tools > Serial Plotter menu)
   Attach the center pin of a potentiometer to pin A0, and the outside pins to +5V and ground.
*/

// the setup routine runs once when you press reset:

void setup() {
   // initialize serial communication at 9600 bits per second:
   Serial.begin(9600);
}

// the loop routine runs over and over again forever:

void loop() {
   // read the input on analog pin 0:
   int sensorValue = analogRead(A0);
   // Convert the analog reading (which goes from 0 - 1023) to a voltage (0 - 5V):
   float voltage = sensorValue * (5.0 / 1023.0);
   // print out the value you read:
   Serial.println(voltage);
}

Kod do uwagi

W programie lub szkicu podanym poniżej, pierwszą rzeczą, którą wykonujesz w funkcji konfiguracji, jest rozpoczęcie komunikacji szeregowej z prędkością 9600 bitów na sekundę między płytą a komputerem za pomocą linii -

Serial.begin(9600);

W głównej pętli twojego kodu musisz ustalić zmienną do przechowywania wartości rezystancji (która będzie między 0 a 1023, idealna dla typu danych int) pochodzącej z twojego potencjometru -

int sensorValue = analogRead(A0);

Aby zmienić wartości z 0-1023 na zakres odpowiadający napięciu, które odczytuje pin, musisz utworzyć inną zmienną, pływak i wykonać małe obliczenia. Aby wyskalować liczby z zakresu od 0,0 do 5,0, należy podzielić 5,0 przez 1023,0 i pomnożyć przez wartość sensorValue -

float voltage= sensorValue * (5.0 / 1023.0);

Na koniec musisz wydrukować te informacje w oknie numeru seryjnego. Możesz to zrobić za pomocą polecenia Serial.println () w ostatniej linii kodu -

Serial.println(voltage)

Teraz otwórz Serial Monitor w Arduino IDE, klikając ikonę po prawej stronie górnego zielonego paska lub naciskając Ctrl + Shift + M.

Wynik

Zobaczysz stały strumień liczb z zakresu 0,0 - 5,0. W miarę obracania potencjometru wartości będą się zmieniać, odpowiednio do napięcia na pinie A0.

Ten przykład pokazuje, jak odczytać wejście analogowe na pinie analogowym 0, przekonwertować wartości z analogRead () na napięcie i wydrukować je na monitorze szeregowym oprogramowania Arduino (IDE).

Wymagane składniki

Będziesz potrzebował następujących komponentów -

• 1 × Breadboard
• 1 × Arduino Uno R3
• Rezystor zmienny 1 × 5 kΩ (potencjometr)
• 2 × sweter
• 8 × LED lub możesz użyć (wyświetlacz słupkowy LED, jak pokazano na poniższym obrazku)

Procedura

Postępuj zgodnie ze schematem obwodu i podłącz komponenty na płytce stykowej, jak pokazano na poniższym obrazku.

Naszkicować

Otwórz oprogramowanie Arduino IDE na swoim komputerze. Kodowanie w języku Arduino będzie sterować twoim obwodem. Otwórz nowy plik szkicu, klikając Nowy.

10-segmentowy wykres słupkowy LED

Te 10-segmentowe diody LED z wykresami słupkowymi mają wiele zastosowań. Dzięki niewielkim rozmiarom, prostemu podłączeniu, są łatwe do prototypowania lub gotowych produktów. Zasadniczo jest to 10 oddzielnych niebieskich diod LED umieszczonych razem, każda z indywidualnym połączeniem anody i katody.

Są również dostępne w kolorach żółtym, czerwonym i zielonym.

Note- Pinezka na tych wykresach słupkowych może różnić się od podanych w arkuszu danych. Obrócenie urządzenia o 180 stopni skoryguje zmianę, ustawiając pin 11 jako pierwszy w linii.

Kod Arduino

/*
   LED bar graph
   Turns on a series of LEDs based on the value of an analog sensor. 
   This is a simple way to make a bar graph display. 
   Though this graph uses 8LEDs, you can use any number by
      changing the LED count and the pins in the array.
   This method can be used to control any series of digital
      outputs that depends on an analog input.
*/

// these constants won't change:
const int analogPin = A0; // the pin that the potentiometer is attached to
const int ledCount = 8; // the number of LEDs in the bar graph
int ledPins[] = {2, 3, 4, 5, 6, 7, 8, 9}; // an array of pin numbers to which LEDs are attached

void setup() {
   // loop over the pin array and set them all to output:
   for (int thisLed = 0; thisLed < ledCount; thisLed++) {
      pinMode(ledPins[thisLed], OUTPUT);
   }
}

void loop() {
   // read the potentiometer:
   int sensorReading = analogRead(analogPin);
   // map the result to a range from 0 to the number of LEDs:
   int ledLevel = map(sensorReading, 0, 1023, 0, ledCount);
   // loop over the LED array:
   for (int thisLed = 0; thisLed < ledCount; thisLed++) {
      // if the array element's index is less than ledLevel,
      // turn the pin for this element on:
      if (thisLed < ledLevel) {
         digitalWrite(ledPins[thisLed], HIGH);
      }else { // turn off all pins higher than the ledLevel:
         digitalWrite(ledPins[thisLed], LOW);
      }
   }
}

Kod do uwagi

Szkic działa w ten sposób: najpierw czytasz dane wejściowe. Mapujesz wartość wejściową do zakresu wyjściowego, w tym przypadku dziesięciu diod LED. Następnie skonfigurowałeśfor-loopdo iteracji wyjść. Jeśli numer wyjścia w serii jest niższy niż zamapowany zakres wejściowy, włącz go. Jeśli nie, wyłącz ją.

Wynik

Zobaczysz, że dioda LED zapala się pojedynczo, gdy wartość odczytu analogowego rośnie i wyłącza się pojedynczo, gdy odczyt maleje.

W tym przykładzie wykorzystano bibliotekę klawiatury do wylogowania użytkownika z sesji użytkownika na komputerze, gdy pin 2 na ARDUINO UNO jest podciągnięty do masy. Szkic symuluje naciśnięcie klawisza w sekwencji dwóch lub trzech klawiszy jednocześnie i po krótkiej chwili zwalnia je.

Warning - Kiedy używasz Keyboard.print()polecenie, Arduino przejmuje klawiaturę komputera. Aby mieć pewność, że nie stracisz kontroli nad komputerem podczas wykonywania szkicu z tą funkcją, skonfiguruj niezawodny system sterowania przed wywołaniem Keyboard.print (). Ten szkic jest przeznaczony do wysyłania polecenia klawiatury tylko po wyciągnięciu szpilki do masy.

Wymagane składniki

Będziesz potrzebował następujących komponentów -

• 1 × Breadboard
• 1 × płyta Arduino Leonardo, Micro lub Due
• 1 × przycisk
• 1 × skoczek

Procedura

Postępuj zgodnie ze schematem obwodu i podłącz komponenty na płytce stykowej, jak pokazano na poniższym obrazku.

Naszkicować

Otwórz oprogramowanie Arduino IDE na swoim komputerze. Kodowanie w języku Arduino będzie sterować twoim obwodem. Otwórz nowy plik szkicu, klikając Nowy.

W tym przykładzie musisz użyć Arduino IDE 1.6.7

Note- Musisz dołączyć bibliotekę klawiatury do pliku biblioteki Arduino. Skopiuj i wklej plik biblioteki klawiatury do pliku z nazwami bibliotek (podświetlonymi), jak pokazano na poniższym zrzucie ekranu.

Kod Arduino

/*
   Keyboard logout
   This sketch demonstrates the Keyboard library.
   When you connect pin 2 to ground, it performs a logout.
   It uses keyboard combinations to do this, as follows:
   On Windows, CTRL-ALT-DEL followed by ALT-l
   On Ubuntu, CTRL-ALT-DEL, and ENTER
   On OSX, CMD-SHIFT-q
   To wake: Spacebar.
   Circuit:
   * Arduino Leonardo or Micro
   * wire to connect D2 to ground.
*/

#define OSX 0
#define WINDOWS 1
#define UBUNTU 2

#include "Keyboard.h"

// change this to match your platform:
int platform = WINDOWS;

void setup() {
   // make pin 2 an input and turn on the
   // pullup resistor so it goes high unless
   // connected to ground:
   
   pinMode(2, INPUT_PULLUP);
   Keyboard.begin();
}

void loop() {
   while (digitalRead(2) == HIGH) {
      // do nothing until pin 2 goes low
      delay(500);
   }
   
   delay(1000);
   
   switch (platform) {
      case OSX:
      Keyboard.press(KEY_LEFT_GUI);
	  
      // Shift-Q logs out:
      Keyboard.press(KEY_LEFT_SHIFT);
      Keyboard.press('Q');
      delay(100);
	  
      // enter:
      Keyboard.write(KEY_RETURN);
      break;
	  
      case WINDOWS:
      // CTRL-ALT-DEL:
      Keyboard.press(KEY_LEFT_CTRL);
      Keyboard.press(KEY_LEFT_ALT);
      Keyboard.press(KEY_DELETE);
      delay(100);
      Keyboard.releaseAll();
	  
      //ALT-l:
      delay(2000);
      Keyboard.press(KEY_LEFT_ALT);
      Keyboard.press('l');
      Keyboard.releaseAll();
      break;
	  
      case UBUNTU:
      // CTRL-ALT-DEL:
      Keyboard.press(KEY_LEFT_CTRL);
      Keyboard.press(KEY_LEFT_ALT);
      Keyboard.press(KEY_DELETE);
	  
      delay(1000);
      Keyboard.releaseAll();
	  
      // Enter to confirm logout:
      Keyboard.write(KEY_RETURN);
      break;
   }
   
   // do nothing:
   while (true);
}

Keyboard.releaseAll();

   // enter:
      Keyboard.write(KEY_RETURN);
      break;
      case WINDOWS:
	  
   // CTRL-ALT-DEL:
      Keyboard.press(KEY_LEFT_CTRL);
      Keyboard.press(KEY_LEFT_ALT);
      Keyboard.press(KEY_DELETE);
      delay(100);
      Keyboard.releaseAll();
	  
   //ALT-l:
      delay(2000);
      Keyboard.press(KEY_LEFT_ALT);
      Keyboard.press('l');
      Keyboard.releaseAll();
      break;
	  
   case UBUNTU:
      // CTRL-ALT-DEL:
      Keyboard.press(KEY_LEFT_CTRL);
      Keyboard.press(KEY_LEFT_ALT);
      Keyboard.press(KEY_DELETE);
      delay(1000);
      Keyboard.releaseAll();
	  
      // Enter to confirm logout:
      Keyboard.write(KEY_RETURN);
      break;
   }
   
// do nothing:
   while (true);
}

Kod do uwagi

Zanim załadujesz program na swoją tablicę, upewnij się, że przypisałeś właściwy system operacyjny, którego aktualnie używasz, do zmiennej platformy.

Gdy szkic jest uruchomiony, naciśnięcie przycisku połączy pin 2 z masą, a płyta wyśle ​​sekwencję wylogowania do komputera podłączonego przez USB.

Wynik

Po podłączeniu styku 2 do masy wykonuje operację wylogowania.

Do wylogowania używa następujących kombinacji klawiszy -

• Na Windows, CTRL-ALT-DEL, a następnie ALT-l

• Na Ubuntu, CTRL-ALT-DEL i ENTER

• Na OSX, CMD-SHIFT-q

W tym przykładzie po naciśnięciu przycisku ciąg tekstowy jest wysyłany do komputera jako dane wejściowe z klawiatury. Ciąg informuje o liczbie naciśnięć przycisku. Po zaprogramowaniu i podłączeniu Leonardo otwórz swój ulubiony edytor tekstu, aby zobaczyć wyniki.

Warning - Kiedy używasz Keyboard.print()polecenie, Arduino przejmuje klawiaturę komputera. Aby mieć pewność, że podczas wykonywania szkicu z tą funkcją nie stracisz kontroli nad komputerem, przed zadzwonieniem skonfiguruj niezawodny system sterowaniaKeyboard.print(). Ten szkic zawiera przycisk do przełączania klawiatury, tak aby działał tylko po naciśnięciu przycisku.

Wymagane składniki

Będziesz potrzebował następujących komponentów -

• 1 × Breadboard
• 1 × płyta Arduino Leonardo, Micro lub Due
• 1 × przycisk chwilowy
• Rezystor 1 × 10 kΩ

Procedura

Postępuj zgodnie ze schematem obwodu i podłącz komponenty na płytce stykowej, jak pokazano na poniższym obrazku.

Naszkicować

Otwórz oprogramowanie Arduino IDE na swoim komputerze. Kodowanie w języku Arduino będzie sterować twoim obwodem. Otwórz nowy plik szkicu, klikając Nowy.

Kod Arduino

/*
   Keyboard Message test For the Arduino Leonardo and Micro,
      Sends a text string when a button is pressed.
   The circuit:
   * pushbutton attached from pin 4 to +5V
   * 10-kilohm resistor attached from pin 4 to ground
*/

#include "Keyboard.h"
const int buttonPin = 4; // input pin for pushbutton
int previousButtonState = HIGH; // for checking the state of a pushButton
int counter = 0; // button push counter

void setup() {
   pinMode(buttonPin, INPUT); // make the pushButton pin an input:
   Keyboard.begin(); // initialize control over the keyboard:
}

void loop() {
   int buttonState = digitalRead(buttonPin); // read the pushbutton:
   if ((buttonState != previousButtonState)&& (buttonState == HIGH)) // and it's currently pressed: {
      // increment the button counter
      counter++;
      // type out a message
      Keyboard.print("You pressed the button ");
      Keyboard.print(counter);
      Keyboard.println(" times.");
   }
   // save the current button state for comparison next time:
   previousButtonState = buttonState;
}

Kod do uwagi

Podłącz jeden zacisk przycisku do styku 4 na Arduino. Podłącz drugi pin do 5V. Użyj rezystora jako pull-down, zapewniając odniesienie do masy, podłączając go od pinu 4 do masy.

Po zaprogramowaniu płytki odłącz kabel USB, otwórz edytor tekstu i umieść kursor tekstowy w obszarze pisania. Podłącz ponownie płytkę do komputera przez USB i naciśnij przycisk, aby pisać w dokumencie.

Wynik

Korzystając z dowolnego edytora tekstu, wyświetli tekst przesłany przez Arduino.

Korzystając z biblioteki myszy, możesz sterować kursorem na ekranie komputera za pomocą Arduino Leonardo, Micro lub Due.

W tym konkretnym przykładzie zastosowano pięć przycisków do przesuwania kursora na ekranie. Cztery przyciski są kierunkowe (w górę, w dół, w lewo, w prawo), a jeden służy do kliknięcia lewym przyciskiem myszy. Ruch kursora z Arduino jest zawsze względny. Za każdym razem, gdy czytane jest wejście, pozycja kursora jest aktualizowana względem jego bieżącej pozycji.

Za każdym razem, gdy zostanie naciśnięty jeden z przycisków kierunkowych, Arduino przesunie mysz, mapując wejście WYSOKIE do zakresu 5 w odpowiednim kierunku.

Piąty przycisk służy do sterowania lewym przyciskiem myszy. Po zwolnieniu przycisku komputer rozpozna zdarzenie.

Wymagane składniki

Będziesz potrzebował następujących komponentów -

• 1 × Breadboard
• 1 × płyta Arduino Leonardo, Micro lub Due
• Rezystor 5 × 10 kΩ
• 5 przycisków chwilowych

Procedura

Postępuj zgodnie ze schematem obwodu i podłącz komponenty na płytce stykowej, jak pokazano na poniższym obrazku.

Naszkicować

Otwórz oprogramowanie Arduino IDE na swoim komputerze. Kodowanie w języku Arduino będzie sterować twoim obwodem. Otwórz nowy plik szkicu, klikając Nowy.

W tym przykładzie musisz użyć Arduino IDE 1.6.7

Kod Arduino

/*
   Button Mouse Control
   For Leonardo and Due boards only .Controls the mouse from 
   five pushbuttons on an Arduino Leonardo, Micro or Due.
   Hardware:
   * 5 pushbuttons attached to D2, D3, D4, D5, D6
   The mouse movement is always relative. This sketch reads
   four pushbuttons, and uses them to set the movement of the mouse.
   WARNING: When you use the Mouse.move() command, the Arduino takes
   over your mouse! Make sure you have control before you use the mouse commands.
*/

#include "Mouse.h"
// set pin numbers for the five buttons:
const int upButton = 2;
const int downButton = 3;
const int leftButton = 4;
const int rightButton = 5;
const int mouseButton = 6;
int range = 5; // output range of X or Y movement; affects movement speed
int responseDelay = 10; // response delay of the mouse, in ms

void setup() {
   // initialize the buttons' inputs:
   pinMode(upButton, INPUT);
   pinMode(downButton, INPUT);
   pinMode(leftButton, INPUT);
   pinMode(rightButton, INPUT);
   pinMode(mouseButton, INPUT);
   // initialize mouse control:
   Mouse.begin();
}

void loop() {
   // read the buttons:
   int upState = digitalRead(upButton);
   int downState = digitalRead(downButton);
   int rightState = digitalRead(rightButton);
   int leftState = digitalRead(leftButton);
   int clickState = digitalRead(mouseButton);
   // calculate the movement distance based on the button states:
   int xDistance = (leftState - rightState) * range;
   int yDistance = (upState - downState) * range;
   // if X or Y is non-zero, move:
   if ((xDistance != 0) || (yDistance != 0)) {
      Mouse.move(xDistance, yDistance, 0);
   }

   // if the mouse button is pressed:
   if (clickState == HIGH) {
      // if the mouse is not pressed, press it:
      if (!Mouse.isPressed(MOUSE_LEFT)) {
         Mouse.press(MOUSE_LEFT);
      }
   } else {                           // else the mouse button is not pressed:
      // if the mouse is pressed, release it:
      if (Mouse.isPressed(MOUSE_LEFT)) {
         Mouse.release(MOUSE_LEFT);
      }
   }
   // a delay so the mouse does not move too fast:
   delay(responseDelay);
}

Kod do uwagi

Podłącz swoją płytkę do komputera za pomocą kabla micro-USB. Przyciski są podłączone do wejść cyfrowych od pinów 2 do 6. Upewnij się, że używasz rezystorów pull-down 10k.

Ten przykład nasłuchuje bajtu pochodzącego z portu szeregowego. Po odebraniu płyta wysyła naciśnięcie klawisza z powrotem do komputera. Wysłane naciśnięcie klawisza jest o jeden wyższe niż odebrane, więc jeśli wyślesz „a” z monitora szeregowego, otrzymasz literę „b” z płytki podłączonej do komputera. „1” zwróci „2” i tak dalej.

Warning - Kiedy używasz Keyboard.print()polecenie, płyta Leonardo, Micro lub Due przejmuje klawiaturę komputera. Aby mieć pewność, że nie stracisz kontroli nad komputerem podczas wykonywania szkicu z tą funkcją, skonfiguruj niezawodny system sterowania przed wywołaniem Keyboard.print (). Ten szkic ma na celu wysłanie polecenia klawiatury tylko po tym, jak płytka otrzyma bajt przez port szeregowy.

Wymagane składniki

Będziesz potrzebował następujących komponentów -

• 1 × płyta Arduino Leonardo, Micro lub Due

Procedura

Wystarczy podłączyć płytkę do komputera za pomocą kabla USB.

Naszkicować

Otwórz oprogramowanie Arduino IDE na swoim komputerze. Kodowanie w języku Arduino będzie sterować twoim obwodem. Otwórz nowy plik szkicu, klikając Nowy.

Notes- Musisz dołączyć bibliotekę klawiatury do pliku biblioteki Arduino. Skopiuj i wklej plik biblioteki klawiatury do pliku z nazwą „biblioteki” podświetloną na żółto.

Kod Arduino

/*
   Keyboard test
   For the Arduino Leonardo, Micro or Due Reads
      a byte from the serial port, sends a keystroke back. 
   The sent keystroke is one higher than what's received, e.g. if you send a, you get b, send
      A you get B, and so forth.
   The circuit:
   * none
*/

#include "Keyboard.h"

void setup() {
   // open the serial port:
   Serial.begin(9600);
   // initialize control over the keyboard:
   Keyboard.begin();
}

void loop() {
   // check for incoming serial data:
   if (Serial.available() > 0) {
      // read incoming serial data:
      char inChar = Serial.read();
      // Type the next ASCII value from what you received:
      Keyboard.write(inChar + 1);
   }
}

Kod do uwagi

Po zaprogramowaniu otwórz monitor szeregowy i wyślij bajt. Tablica odpowie naciśnięciem klawisza, czyli o jeden numer wyżej.

Wynik

Płytka odpowie naciśnięciem klawisza, który jest o jeden numer wyższy na monitorze szeregowym Arduino IDE, gdy wyślesz bajt.

W tej sekcji dowiemy się, jak połączyć naszą płytkę Arduino z różnymi czujnikami. Omówimy następujące czujniki -

• Czujnik wilgotności (DHT22)
• Czujnik temperatury (LM35)
• Czujnik wody (Simple Water Trigger)
• CZUJNIK PIR
• CZUJNIK ULTRADŹWIĘKOWY
• GPS

Czujnik wilgotności (DHT22)

DHT-22 (zwany również AM2302) to czujnik wyjścia cyfrowego, wilgotności względnej i temperatury. Wykorzystuje pojemnościowy czujnik wilgotności i termistor do pomiaru otaczającego powietrza i wysyła sygnał cyfrowy na pin danych.

W tym przykładzie dowiesz się, jak używać tego czujnika z Arduino UNO. Temperatura i wilgotność w pomieszczeniu zostaną wydrukowane na monitorze szeregowym.

Czujnik DHT-22

Połączenia są proste. Pierwszy styk po lewej stronie do zasilania 3-5 V, drugi styk do styku wejścia danych, a styk po prawej stronie do masy.

Szczegóły techniczne

• Power - 3-5V

• Max Current - 2,5 mA

• Humidity - Dokładność 0-100%, 2-5%

• Temperature - 40 do 80 ° C, dokładność ± 0,5 ° C

Wymagane składniki

Będziesz potrzebował następujących komponentów -

• 1 × Breadboard
• 1 × Arduino Uno R3
• 1 × DHT22
• Rezystor 1 × 10 kΩ

Procedura

Postępuj zgodnie ze schematem obwodu i podłącz komponenty na płytce stykowej, jak pokazano na poniższym obrazku.

Naszkicować

Otwórz oprogramowanie Arduino IDE na swoim komputerze. Kodowanie w języku Arduino będzie sterować twoim obwodem. Otwórz nowy plik szkicu, klikając Nowy.

Kod Arduino

// Example testing sketch for various DHT humidity/temperature sensors

#include "DHT.h"
#define DHTPIN 2 // what digital pin we're connected to
// Uncomment whatever type you're using!
//#define DHTTYPE DHT11 // DHT 11
#define DHTTYPE DHT22 // DHT 22 (AM2302), AM2321
//#define DHTTYPE DHT21 // DHT 21 (AM2301)
// Connect pin 1 (on the left) of the sensor to +5V
// NOTE: If using a board with 3.3V logic like an Arduino Due connect pin 1
// to 3.3V instead of 5V!
// Connect pin 2 of the sensor to whatever your DHTPIN is
// Connect pin 4 (on the right) of the sensor to GROUND
// Connect a 10K resistor from pin 2 (data) to pin 1 (power) of the sensor
// Initialize DHT sensor.
// Note that older versions of this library took an optional third parameter to
// tweak the timings for faster processors. This parameter is no longer needed
// as the current DHT reading algorithm adjusts itself to work on faster procs.
DHT dht(DHTPIN, DHTTYPE);

void setup() {
   Serial.begin(9600);
   Serial.println("DHTxx test!");
   dht.begin();
}

void loop() {
   delay(2000); // Wait a few seconds between measurements
   float h = dht.readHumidity();
   // Reading temperature or humidity takes about 250 milliseconds!
   float t = dht.readTemperature();
   // Read temperature as Celsius (the default)
   float f = dht.readTemperature(true);
   // Read temperature as Fahrenheit (isFahrenheit = true)
   // Check if any reads failed and exit early (to try again).
   if (isnan(h) || isnan(t) || isnan(f)) {
      Serial.println("Failed to read from DHT sensor!");
      return;
   }
   
   // Compute heat index in Fahrenheit (the default)
   float hif = dht.computeHeatIndex(f, h);
   // Compute heat index in Celsius (isFahreheit = false)
   float hic = dht.computeHeatIndex(t, h, false);
   Serial.print ("Humidity: ");
   Serial.print (h);
   Serial.print (" %\t");
   Serial.print ("Temperature: ");
   Serial.print (t);
   Serial.print (" *C ");
   Serial.print (f);
   Serial.print (" *F\t");
   Serial.print ("Heat index: ");
   Serial.print (hic);
   Serial.print (" *C ");
   Serial.print (hif);
   Serial.println (" *F");
}

Kod do uwagi

Czujnik DHT22 posiada cztery zaciski (V _cc , DATA, NC, GND), które są połączone z płytką w następujący sposób -

• Pin DATA do pinu Arduino nr 2
• Pin V _cc do 5 woltów płytki Arduino
• Pin GND do masy płytki Arduino
• Musimy podłączyć rezystor 10 kΩ (rezystor podciągający) między DANE a pinem V _cc

Po wykonaniu połączeń sprzętowych należy dodać bibliotekę DHT22 do pliku biblioteki Arduino, jak opisano wcześniej.

Wynik

Na monitorze portu szeregowego zobaczysz wyświetlacz temperatury i wilgotności, który jest aktualizowany co 2 sekundy.

Czujniki temperatury serii LM35 to precyzyjne układy scalone do pomiaru temperatury z napięciem wyjściowym liniowo proporcjonalnym do temperatury Celsjusza.

Urządzenie LM35 ma przewagę nad liniowymi czujnikami temperatury skalibrowanymi w kelwinach, ponieważ użytkownik nie musi odejmować dużego stałego napięcia od wyjścia, aby uzyskać wygodne skalowanie w stopniach Celsjusza. Urządzenie LM35 nie wymaga żadnej zewnętrznej kalibracji ani przycinania, aby zapewnić typową dokładność ± ¼ ° C w temperaturze pokojowej i ± ¾ ° C w pełnym zakresie temperatur od -55 ° C do 150 ° C.

Specyfikacja techniczna

• Kalibrowany bezpośrednio w stopniach Celsjusza (Celsjusza)
• Liniowy współczynnik skali + 10 mV / ° C
• 0,5 ° C zapewniona dokładność (przy 25 ° C)
• Oceniono na pełny zakres od -55 ° C do 150 ° C
• Nadaje się do zastosowań zdalnych

Wymagane składniki

Będziesz potrzebował następujących komponentów -

• 1 × Breadboard
• 1 × Arduino Uno R3
• Czujnik 1 × LM35

Procedura

Postępuj zgodnie ze schematem obwodu i podłącz komponenty na płytce stykowej, jak pokazano na poniższym obrazku.

Naszkicować

Otwórz oprogramowanie Arduino IDE na swoim komputerze. Kodowanie w języku Arduino będzie sterować twoim obwodem. Otwórz nowy plik szkicu, klikając Nowy.

Kod Arduino

float temp;
int tempPin = 0;

void setup() {
   Serial.begin(9600);
}

void loop() {
   temp = analogRead(tempPin);
   // read analog volt from sensor and save to variable temp
   temp = temp * 0.48828125;
   // convert the analog volt to its temperature equivalent
   Serial.print("TEMPERATURE = ");
   Serial.print(temp); // display temperature value
   Serial.print("*C");
   Serial.println();
   delay(1000); // update sensor reading each one second
}

Kod do uwagi

Czujnik LM35 ma trzy zaciski - V _s , V _out i GND. Czujnik podłączymy w następujący sposób -

• Połącz + V _s do + 5V na Arduino pokładzie.
• Podłącz _wyjście V do Analog0 lub A0 na płycie Arduino.
• Połącz GND z GND na Arduino.

Przetwornik analogowo-cyfrowy (ADC) przekształca wartości analogowe w przybliżenie cyfrowe w oparciu o wzór Wartość ADC = próbka * 1024 / napięcie odniesienia (+ 5 V). Tak więc z odniesieniem +5 V, przybliżenie cyfrowe będzie równe napięciu wejściowemu * 205.

Wynik

Na monitorze portu szeregowego zobaczysz wyświetlacz temperatury, który jest aktualizowany co sekundę.

Cegła czujnika wody jest przeznaczona do wykrywania wody, która może być szeroko stosowana do wykrywania opadów deszczu, poziomu wody, a nawet wycieków cieczy.

Podłączenie czujnika wody do Arduino to świetny sposób na wykrycie wycieku, rozlania, zalania, deszczu itp. Może być używany do wykrywania obecności, poziomu, objętości i / lub braku wody. Chociaż można to wykorzystać do przypomnienia o podlewaniu roślin, istnieje lepszy do tego czujnik Grove. Czujnik ma szereg odsłoniętych śladów, które wskazują NISKI, gdy wykryta zostanie woda.

W tym rozdziale podłączymy czujnik wody do cyfrowego pinu 8 na Arduino i wykorzystamy bardzo poręczną diodę LED, która pomoże zidentyfikować, kiedy czujnik wody styka się ze źródłem wody.

Wymagane składniki

Będziesz potrzebował następujących komponentów -

• 1 × Breadboard
• 1 × Arduino Uno R3
• 1 × czujnik wody
• 1 × led
• Rezystor 1 × 330 omów

Procedura

Postępuj zgodnie ze schematem obwodu i podłącz komponenty na płytce stykowej, jak pokazano na poniższym obrazku.

Naszkicować

Otwórz oprogramowanie Arduino IDE na swoim komputerze. Kodowanie w języku Arduino będzie sterować twoim obwodem. Otwórz nowy plik szkicu, klikając Nowy.

Kod Arduino

#define Grove_Water_Sensor 8 // Attach Water sensor to Arduino Digital Pin 8
#define LED 9 // Attach an LED to Digital Pin 9 (or use onboard LED)

void setup() {
   pinMode(Grove_Water_Sensor, INPUT); // The Water Sensor is an Input
   pinMode(LED, OUTPUT); // The LED is an Output
}

void loop() {
   /* The water sensor will switch LOW when water is detected.
   Get the Arduino to illuminate the LED and activate the buzzer
   when water is detected, and switch both off when no water is present */
   if( digitalRead(Grove_Water_Sensor) == LOW) {
      digitalWrite(LED,HIGH);
   }else {
      digitalWrite(LED,LOW);
   }
}

Kod do uwagi

Czujnik wody ma trzy zaciski - S, V _out (+) i GND (-). Podłącz czujnik w następujący sposób -

• Połącz + V _s do + 5V na Arduino pokładzie.
• Podłącz S do cyfrowego pinu numer 8 na płycie Arduino.
• Połącz GND z GND na Arduino.
• Podłącz diodę LED do cyfrowego pinu nr 9 na płytce Arduino.

Kiedy czujnik wykryje wodę, pin 8 na Arduino staje się LOW, a następnie dioda LED na Arduino zostaje włączona.

Wynik

Zobaczysz, że dioda sygnalizacyjna zaświeci się, gdy czujnik wykryje wodę.

Czujniki PIR pozwalają wykrywać ruch. Służą do wykrywania, czy człowiek wszedł lub wyszedł poza zasięg czujnika. Są powszechnie stosowane w urządzeniach i gadżetach używanych w domu lub w firmach. Są one często określane jako czujniki PIR, „pasywna podczerwień”, „piroelektryczne” lub „czujniki ruchu na podczerwień”.

Oto zalety czujników PIR -

• Mały rozmiar
• Szeroki zakres soczewek
• Łatwy w obsłudze
• Inexpensive
• Low-power
• Łatwy w użyciu
• Nie zużywaj się

PIR są zbudowane z czujników piroelektrycznych, okrągłej metalowej puszki z prostokątnym kryształem pośrodku, która może wykrywać poziomy promieniowania podczerwonego. Wszystko emituje promieniowanie o niskim poziomie, a im coś jest cieplejsze, tym więcej promieniowania jest emitowane. Czujnik w czujniku ruchu jest podzielony na dwie części. Ma to na celu wykrycie ruchu (zmiany), a nie średnie poziomy IR. Dwie połówki są połączone tak, że znoszą się nawzajem. Jeśli jedna połowa widzi więcej lub mniej promieniowania podczerwonego niż druga, moc wyjściowa będzie się zmieniać wysoko lub nisko.

Czujniki PIR mają regulowane ustawienia i mają zainstalowany nagłówek w 3-pinowych podkładkach uziemiających / wyjściowych / zasilających.

W przypadku wielu podstawowych projektów lub produktów, które muszą wykryć, kiedy osoba wyszła lub weszła na dany obszar, czujniki PIR są świetne. Należy pamiętać, że czujniki PIR nie informują o liczbie osób w pobliżu ani o ich bliskości do czujnika. Soczewki często są przymocowane do pewnego odchylenia na odległość i czasami są uruchamiane przez zwierzęta domowe w domu.

Wymagane składniki

Będziesz potrzebował następujących komponentów -

• 1 × Breadboard
• 1 × Arduino Uno R3
• 1 × czujnik PIR (MQ3)

Procedura

Postępuj zgodnie ze schematem obwodu i wykonaj połączenia, jak pokazano na poniższym obrazku.

Naszkicować

Otwórz oprogramowanie Arduino IDE na swoim komputerze. Kodowanie w języku Arduino będzie sterować twoim obwodem. Otwórz nowy plik szkicu, klikając Nowy.

Kod Arduino

#define pirPin 2
int calibrationTime = 30;
long unsigned int lowIn;
long unsigned int pause = 5000;
boolean lockLow = true;
boolean takeLowTime;
int PIRValue = 0;

void setup() {
   Serial.begin(9600);
   pinMode(pirPin, INPUT);
}

void loop() {
   PIRSensor();
}

void PIRSensor() {
   if(digitalRead(pirPin) == HIGH) {
      if(lockLow) {
         PIRValue = 1;
         lockLow = false;
         Serial.println("Motion detected.");
         delay(50);
      }
      takeLowTime = true;
   }
   if(digitalRead(pirPin) == LOW) {
      if(takeLowTime){
         lowIn = millis();takeLowTime = false;
      }
      if(!lockLow && millis() - lowIn > pause) {
         PIRValue = 0;
         lockLow = true;
         Serial.println("Motion ended.");
         delay(50);
      }
   }
}

Kod do uwagi

Czujnik PIR ma trzy zaciski - V _cc , OUT i GND. Podłącz czujnik w następujący sposób -

• Podłącz + V _cc do + 5v na płycie Arduino.
• Podłącz OUT do cyfrowego pinu 2 na płycie Arduino.
• Połącz GND z GND na Arduino.

Czułość czujnika i czas opóźnienia można regulować za pomocą dwóch zmiennych rezystorów umieszczonych w dolnej części płytki czujnika.

Gdy czujnik wykryje ruch, Arduino wyśle ​​wiadomość przez port szeregowy z informacją, że wykryto ruch. Ruch czujnika PIR opóźni się o pewien czas, aby sprawdzić, czy pojawił się nowy ruch. Jeśli nie zostanie wykryty ruch, Arduino wyśle ​​nową wiadomość z informacją, że ruch się zakończył.

Wynik

Zobaczysz komunikat na swoim porcie szeregowym, jeśli zostanie wykryty ruch i inny komunikat, gdy ruch ustanie.

Czujnik ultradźwiękowy HC-SR04 wykorzystuje SONAR do określenia odległości obiektu, tak jak robią to nietoperze. Oferuje doskonałe bezkontaktowe wykrywanie zasięgu z wysoką dokładnością i stabilnymi odczytami w łatwym w użyciu opakowaniu od 2 cm do 400 cm lub 1 ”do 13 stóp.

Na działanie nie ma wpływu światło słoneczne ani czarny materiał, chociaż pod względem akustycznym miękkie materiały, takie jak tkanina, mogą być trudne do wykrycia. Dostarczany w komplecie z nadajnikiem ultradźwiękowym i modułem odbiornika.

Specyfikacja techniczna

• Zasilanie - + 5 V DC
• Prąd spoczynkowy - <2mA
• Prąd roboczy - 15mA
• Efektywny kąt - <15 °
• Zasięg - 2 cm - 400 cm / 1 ″ - 13 stóp
• Rozdzielczość - 0,3 cm
• Kąt pomiaru - 30 stopni

Wymagane składniki

Będziesz potrzebował następujących komponentów -

• 1 × Breadboard
• 1 × Arduino Uno R3
• 1 × czujnik ultradźwiękowy (HC-SR04)

Procedura

Postępuj zgodnie ze schematem obwodu i wykonaj połączenia, jak pokazano na rysunku poniżej.

Naszkicować

Otwórz oprogramowanie Arduino IDE na swoim komputerze. Kodowanie w języku Arduino będzie sterować twoim obwodem. Otwórz nowy plik szkicu, klikając Nowy.

Kod Arduino

const int pingPin = 7; // Trigger Pin of Ultrasonic Sensor
const int echoPin = 6; // Echo Pin of Ultrasonic Sensor

void setup() {
   Serial.begin(9600); // Starting Serial Terminal
}

void loop() {
   long duration, inches, cm;
   pinMode(pingPin, OUTPUT);
   digitalWrite(pingPin, LOW);
   delayMicroseconds(2);
   digitalWrite(pingPin, HIGH);
   delayMicroseconds(10);
   digitalWrite(pingPin, LOW);
   pinMode(echoPin, INPUT);
   duration = pulseIn(echoPin, HIGH);
   inches = microsecondsToInches(duration);
   cm = microsecondsToCentimeters(duration);
   Serial.print(inches);
   Serial.print("in, ");
   Serial.print(cm);
   Serial.print("cm");
   Serial.println();
   delay(100);
}

long microsecondsToInches(long microseconds) {
   return microseconds / 74 / 2;
}

long microsecondsToCentimeters(long microseconds) {
   return microseconds / 29 / 2;
}

Kod do uwagi

Czujnik ultradźwiękowy ma cztery zaciski - + 5V, wyzwalacz, echo i GND połączone w następujący sposób -

• Podłącz pin + 5V do + 5v na swojej płycie Arduino.
• Podłącz wyzwalacz do cyfrowego pinu 7 na płycie Arduino.
• Podłącz Echo do cyfrowego pinu 6 na płycie Arduino.
• Połącz GND z GND na Arduino.

W naszym programie wyświetliliśmy odległość zmierzoną przez czujnik w calach i cm poprzez port szeregowy.

Wynik

Na szeregowym monitorze Arduino zobaczysz odległość zmierzoną przez czujnik w calach i cm.

Przyciski lub przełączniki łączą dwa otwarte zaciski w obwodzie. Ten przykład włącza diodę LED na pinie 2 po naciśnięciu przełącznika przyciskowego podłączonego do styku 8.

Rezystor obniżający

Rezystory obniżające są stosowane w elektronicznych obwodach logicznych, aby zapewnić, że wejścia do Arduino ustalają się na oczekiwanych poziomach logicznych, jeśli urządzenia zewnętrzne są odłączone lub mają wysoką impedancję. Ponieważ nic nie jest podłączone do pinu wejściowego, nie oznacza to, że jest to logiczne zero. Rezystory pull down są podłączane między masą a odpowiednim pinem urządzenia.

Przykład rezystora obniżającego w obwodzie cyfrowym pokazano na poniższym rysunku. Przełącznik przyciskowy jest podłączony pomiędzy napięciem zasilania a pinem mikrokontrolera. W takim obwodzie, gdy wyłącznik jest zwarty, wejście mikrokontrolera ma logiczną wysoką wartość, ale gdy przełącznik jest rozwarty, rezystor obniżający ciągnie napięcie wejściowe do masy (wartość zera logicznego), nieokreślony stan na wejściu.

Rezystor obniżający musi mieć większą rezystancję niż impedancja obwodu logicznego, w przeciwnym razie może zbytnio obniżyć napięcie, a napięcie wejściowe na pinie pozostanie na stałym logicznie niskim poziomie, niezależnie od położenia przełącznika.

Wymagane składniki

Będziesz potrzebował następujących komponentów -

• 1 × płyta Arduino UNO
• Rezystor 1 × 330 omów
• Rezystor 1 × 4,7 K ohm (pull down)
• 1 × LED

Procedura

Postępuj zgodnie ze schematem obwodu i wykonaj połączenia, jak pokazano na rysunku poniżej.

Naszkicować

Otwórz oprogramowanie Arduino IDE na swoim komputerze. Kodowanie w języku Arduino będzie sterować twoim obwodem. Otwórz nowy plik szkicu, klikając Nowy.

Kod Arduino

// constants won't change. They're used here to
// set pin numbers:
const int buttonPin = 8; // the number of the pushbutton pin
const int ledPin = 2; // the number of the LED pin
// variables will change:
int buttonState = 0; // variable for reading the pushbutton status

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

void loop() {
   // read the state of the pushbutton value:
   buttonState = digitalRead(buttonPin);
   // check if the pushbutton is pressed.
   // if it is, the buttonState is HIGH:
   if (buttonState == HIGH) {
      // turn LED on:
      digitalWrite(ledPin, HIGH);
   } else {
      // turn LED off:
      digitalWrite(ledPin, LOW);
   }
}

Kod do uwagi

Gdy wyłącznik jest rozwarty (przycisk nie jest wciśnięty) nie ma połączenia między dwoma zaciskami przycisku, więc pin jest połączony z masą (poprzez rezystor pull-down) i odczytujemy LOW. Gdy przełącznik jest zamknięty (przycisk jest wciśnięty), tworzy połączenie między dwoma zaciskami, podłączając pin do 5 V, tak że odczytamy WYSOKI.

Wynik

Dioda świeci się, gdy przycisk jest wciśnięty i gaśnie, gdy jest zwolniony.

W tym rozdziale połączymy różne typy silników z płytą Arduino (UNO) i pokażemy, jak podłączyć silnik i sterować nim z płyty.

Istnieją trzy różne typy silników -

• Silnik prądu stałego
• Siłownik
• Silnik krokowy

Silnik prądu stałego (silnik prądu stałego) jest najpopularniejszym typem silnika. Silniki prądu stałego zwykle mają tylko dwa przewody, jeden dodatni i jeden ujemny. Jeśli podłączysz te dwa przewody bezpośrednio do akumulatora, silnik będzie się obracał. Jeśli zmienisz przewody, silnik będzie się obracał w przeciwnym kierunku.

Warning- Nie steruj silnikiem bezpośrednio z pinów płyty Arduino. Może to spowodować uszkodzenie tablicy. Użyj obwodu sterownika lub układu scalonego.

Podzielimy ten rozdział na trzy części -

• Po prostu wpraw silnik w ruch
• Kontroluj prędkość silnika
• Kontroluj kierunek wirowania silnika prądu stałego

Wymagane składniki

Będziesz potrzebował następujących komponentów -

• 1x płytka Arduino UNO
• 1x tranzystor PN2222
• 1x mały silnik 6 V DC
• 1x dioda 1N4001
• 1x Rezystor 270 Ω

Procedura

Postępuj zgodnie ze schematem obwodu i wykonaj połączenia, jak pokazano na rysunku poniżej.

Środki ostrożności

Podczas wykonywania połączeń należy zachować następujące środki ostrożności.

• Najpierw upewnij się, że tranzystor jest podłączony we właściwy sposób. Płaska strona tranzystora powinna być skierowana w stronę płytki Arduino, jak pokazano na układzie.

• Po drugie, pasiasta końcówka diody powinna być skierowana w stronę linii zasilającej + 5V zgodnie z układem pokazanym na obrazku.

Spin ControlArduino Code

int motorPin = 3;

void setup() {

}

void loop() {
   digitalWrite(motorPin, HIGH);
}

Kod do uwagi

Tranzystor działa jak przełącznik, kontrolując moc silnika. Pin 3 Arduino służy do włączania i wyłączania tranzystora i otrzymuje w szkicu nazwę „motorPin”.

Wynik

Silnik będzie się obracał z pełną prędkością, gdy pin nr 3 Arduino stanie się wysoki.

Kontrola prędkości silnika

Poniżej znajduje się schemat ideowy silnika prądu stałego, podłączonego do płytki Arduino.

Kod Arduino

int motorPin = 9;

void setup() {
   pinMode(motorPin, OUTPUT);
   Serial.begin(9600);
   while (! Serial);
   Serial.println("Speed 0 to 255");
}

void loop() {
   if (Serial.available()) {
      int speed = Serial.parseInt();
      if (speed >= 0 && speed <= 255) {
         analogWrite(motorPin, speed);
      }
   }
}

Kod do uwagi

Tranzystor działa jak przełącznik, kontrolując moc silnika. Pin 3 Arduino służy do włączania i wyłączania tranzystora i otrzymuje w szkicu nazwę „motorPin”.

Gdy program się uruchamia, wyświetla monit o podanie wartości sterujących prędkością silnika. Musisz wprowadzić wartość od 0 do 255 w monitorze szeregowym.

W funkcji „pętla” polecenie „Serial.parseInt” służy do odczytywania liczby wprowadzonej jako tekst w monitorze szeregowym i konwertowania jej na liczbę „int”. Tutaj możesz wpisać dowolną liczbę. Instrukcja „if” w następnym wierszu po prostu wykonuje zapis analogowy o tej liczbie, jeśli liczba zawiera się w przedziale od 0 do 255.

Wynik

Silnik prądu stałego będzie się obracał z różnymi prędkościami w zależności od wartości (od 0 do 250) odebranej przez port szeregowy.

Kontrola kierunku wirowania

Aby kontrolować kierunek wirowania silnika prądu stałego, bez zamiany wyprowadzeń, można użyć obwodu o nazwie H-Bridge. Mostek H to obwód elektroniczny, który może napędzać silnik w obu kierunkach. Mostki typu H są używane w wielu różnych zastosowaniach. Jedną z najczęstszych aplikacji jest sterowanie silnikami w robotach. Nazywa się to mostkiem H, ponieważ wykorzystuje cztery tranzystory połączone w taki sposób, że schemat wygląda jak litera „H.”.

Będziemy używać tutaj układu scalonego mostka H L298. L298 może sterować prędkością i kierunkiem silników prądu stałego i silników krokowych oraz może sterować dwoma silnikami jednocześnie. Jego prąd znamionowy wynosi 2A dla każdego silnika. Jednak przy tych prądach będziesz musiał użyć radiatorów.

Wymagane składniki

Będziesz potrzebował następujących komponentów -

• 1 x mostek L298 IC
• 1 × silnik prądu stałego
• 1 × Arduino UNO
• 1 × płytka prototypowa
• 10 x przewody połączeniowe

Procedura

Poniżej znajduje się schemat ideowy interfejsu silnika prądu stałego do płyty Arduino Uno.

Powyższy schemat pokazuje, jak podłączyć L298 IC do sterowania dwoma silnikami. Istnieją trzy styki wejściowe dla każdego silnika: Wejście1 (IN1), Wejście2 (IN2) i Włączenie1 (EN1) dla silnika1 i wejścia3, wejścia4 i zezwolenia2 dla silnika2.

Ponieważ w tym przykładzie będziemy sterować tylko jednym silnikiem, podłączymy Arduino do IN1 (pin 5), IN2 (pin 7) i Enable1 (pin 6) układu scalonego L298. Piny 5 i 7 są cyfrowe, tj. Wejścia ON lub OFF, podczas gdy pin 6 wymaga sygnału modulowanego szerokością impulsu (PWM) do sterowania prędkością silnika.

Poniższa tabela pokazuje, w jakim kierunku będzie obracał się silnik, na podstawie wartości cyfrowych IN1 i IN2.

W 1	W 2	Zachowanie motoryczne
		HAMULEC
1		NAPRZÓD
	1	DO TYŁU
1	1	HAMULEC

Pin IN1 układu scalonego L298 jest podłączony do pinu 8 Arduino, podczas gdy IN2 jest podłączony do pinu 9. Te dwa cyfrowe piny Arduino sterują kierunkiem silnika. Pin EN A układu scalonego jest podłączony do pinu 2 PWM Arduino. Pozwoli to kontrolować prędkość silnika.

Do ustawienia wartości pinów 8 i 9 Arduino wykorzystaliśmy funkcję digitalWrite (), natomiast do ustawienia wartości pinu 2 musimy skorzystać z funkcji analogWrite ().

Kroki połączenia

• Podłącz 5 V i masę układu scalonego odpowiednio do 5 V i uziemienia Arduino.
• Podłącz silnik do pinów 2 i 3 układu scalonego.
• Podłącz IN1 układu scalonego do pinu 8 Arduino.
• Podłącz IN2 układu scalonego do pinu 9 Arduino.
• Podłącz EN1 układu scalonego do pinu 2 Arduino.
• Podłącz pin SENS A układu scalonego do masy.
• Podłącz Arduino za pomocą kabla Arduino USB i załaduj program do Arduino za pomocą oprogramowania Arduino IDE.
• Dostarcz zasilanie do płyty Arduino za pomocą zasilacza, baterii lub kabla USB.

Kod Arduino

const int pwm = 2 ; //initializing pin 2 as pwm
const int in_1 = 8 ;
const int in_2 = 9 ;
//For providing logic to L298 IC to choose the direction of the DC motor

void setup() {
   pinMode(pwm,OUTPUT) ; //we have to set PWM pin as output
   pinMode(in_1,OUTPUT) ; //Logic pins are also set as output
   pinMode(in_2,OUTPUT) ;
}

void loop() {
   //For Clock wise motion , in_1 = High , in_2 = Low
   digitalWrite(in_1,HIGH) ;
   digitalWrite(in_2,LOW) ;
   analogWrite(pwm,255) ;
   /* setting pwm of the motor to 255 we can change the speed of rotation
   by changing pwm input but we are only using arduino so we are using highest
   value to driver the motor */
   //Clockwise for 3 secs
   delay(3000) ;
   //For brake
   digitalWrite(in_1,HIGH) ;
   digitalWrite(in_2,HIGH) ;
   delay(1000) ;
   //For Anti Clock-wise motion - IN_1 = LOW , IN_2 = HIGH
   digitalWrite(in_1,LOW) ;
   digitalWrite(in_2,HIGH) ;
   delay(3000) ;
   //For brake
   digitalWrite(in_1,HIGH) ;
   digitalWrite(in_2,HIGH) ;
   delay(1000) ;
}

Wynik

Silnik będzie pracował najpierw w kierunku zgodnym z ruchem wskazówek zegara (CW) przez 3 sekundy, a następnie w kierunku przeciwnym do ruchu wskazówek zegara (CCW) przez 3 sekundy.

Silnik serwo to małe urządzenie, które ma wał wyjściowy. Wał ten można ustawić w określonych pozycjach kątowych, wysyłając do serwomechanizmu zakodowany sygnał. Dopóki zakodowany sygnał istnieje na linii wejściowej, serwo będzie utrzymywać kątowe położenie wału. Jeśli zakodowany sygnał zmienia się, zmienia się położenie kątowe wału. W praktyce serwomechanizmy są używane w samolotach sterowanych radiowo do pozycjonowania powierzchni sterowych, takich jak windy i stery. Są również używane w samochodach sterowanych radiowo, marionetkach i oczywiście robotach.

Serwa są niezwykle przydatne w robotyce. Silniki są małe, mają wbudowane obwody sterujące i są niezwykle mocne jak na swój rozmiar. Standardowe serwo, takie jak Futaba S-148, ma moment obrotowy 42 uncji / cale, który jest silny jak na swój rozmiar. Pobiera również moc proporcjonalnie do obciążenia mechanicznego. Dlatego lekko obciążone serwo nie zużywa dużo energii.

Wnętrze serwomotoru pokazano na poniższym rysunku. Możesz zobaczyć obwód sterujący, silnik, zestaw kół zębatych i obudowę. Możesz również zobaczyć 3 przewody, które łączą się ze światem zewnętrznym. Jeden służy do zasilania (+ 5 V), uziemienia, a biały przewód to przewód sterujący.

Działanie serwomotoru

Silnik serwo ma kilka obwodów sterujących i potencjometr (rezystor zmienny, inaczej potencjometr) podłączony do wału wyjściowego. Na powyższym obrazku garnek widać po prawej stronie płytki drukowanej. Potencjometr ten umożliwia układowi sterowania monitorowanie kąta prądu serwomotoru.

Jeśli wał jest ustawiony pod odpowiednim kątem, silnik wyłącza się. Jeśli obwód stwierdzi, że kąt jest nieprawidłowy, obróci silnik, aż znajdzie się pod żądanym kątem. Wał wyjściowy serwomechanizmu może poruszać się gdzieś około 180 stopni. Zwykle jest to gdzieś w zakresie 210 stopni, jednak różni się w zależności od producenta. Normalne serwo służy do sterowania ruchem kątowym od 0 do 180 stopni. Mechanicznie nie jest w stanie obracać się dalej z powodu mechanicznego ogranicznika wbudowanego w główne koło wyjściowe.

Moc przyłożona do silnika jest proporcjonalna do odległości, jaką musi pokonać. Tak więc, jeśli wał musi obrócić się na dużą odległość, silnik będzie pracował z pełną prędkością. Jeśli trzeba obrócić tylko nieznacznie, silnik będzie pracował z mniejszą prędkością. To się nazywaproportional control.

Jak komunikujesz się, pod jakim kątem powinno się obracać serwo?

Przewód sterujący służy do przekazywania kąta. Kąt jest określany przez czas trwania impulsu, który jest podawany na przewód sterujący. To się nazywaPulse Coded Modulation. Serwo spodziewa się zobaczyć impuls co 20 milisekund (0,02 sekundy). Długość impulsu określi, jak daleko obraca się silnik. Na przykład impuls 1,5 milisekundy spowoduje obrót silnika do pozycji 90 stopni (często nazywanej położeniem neutralnym). Jeśli impuls jest krótszy niż 1,5 milisekundy, silnik obróci wał bliżej 0 stopni. Jeśli impuls jest dłuższy niż 1,5 milisekundy, wałek obraca się bliżej 180 stopni.

Wymagane składniki

Będziesz potrzebował następujących komponentów -

• 1 × płyta Arduino UNO
• 1 × silnik serwo
• 1 × układ napędowy ULN2003
• Rezystor 1 × 10 kΩ

Procedura

Postępuj zgodnie ze schematem obwodu i wykonaj połączenia, jak pokazano na rysunku poniżej.

Naszkicować

Otwórz oprogramowanie Arduino IDE na swoim komputerze. Kodowanie w języku Arduino będzie sterować twoim obwodem. Otwórz nowy plik szkicu, klikając Nowy.

Kod Arduino

/* Controlling a servo position using a potentiometer (variable resistor) */

#include <Servo.h>
   Servo myservo; // create servo object to control a servo
   int potpin = 0; // analog pin used to connect the potentiometer
   int val; // variable to read the value from the analog pin

void setup() {
   myservo.attach(9); // attaches the servo on pin 9 to the servo object
}

void loop() {
   val = analogRead(potpin);
   // reads the value of the potentiometer (value between 0 and 1023)
   val = map(val, 0, 1023, 0, 180);
   // scale it to use it with the servo (value between 0 and 180)
   myservo.write(val); // sets the servo position according to the scaled value
   delay(15);
}

Kod do uwagi

Serwomotory mają trzy zaciski - zasilania, masy i sygnału. Przewód zasilający jest zwykle czerwony i powinien być podłączony do pinu 5 V w Arduino. Przewód uziemiający jest zwykle czarny lub brązowy i powinien być podłączony do jednego zacisku układu scalonego ULN2003 (10-16). Aby chronić swoją płytę Arduino przed uszkodzeniem, będziesz potrzebować do tego układu scalonego sterownika. Tutaj użyliśmy układu scalonego ULN2003 do napędzania silnika serwo. Pin sygnałowy jest zazwyczaj żółty lub pomarańczowy i powinien być podłączony do pinu nr 9 Arduino.

Podłączanie potencjometru

Dzielnik napięcia / dzielnik potencjału to rezystory w obwodzie szeregowym, które skalują napięcie wyjściowe do określonego stosunku przyłożonego napięcia wejściowego. Poniżej znajduje się schemat obwodu -

$$ V_ {out} = (V_ {in} \ times R_ {2}) / (R_ {1} + R_ {2}) $$

V _out to potencjał wyjściowy, który zależy od przyłożonego napięcia wejściowego (V _in ) i rezystorów (R ₁ i R ₂ ) w szeregu. Oznacza to, że prąd płynący przez R ₁ przepłynie również przez R ₂ bez podziału. W powyższym równaniu, jak wartość R ₂ zmiany, V _poza wagą odpowiednio w stosunku do napięcia zasilania V, _na .

Potencjometr jest zwykle dzielnikiem potencjału, który może skalować napięcie wyjściowe obwodu na podstawie wartości rezystora zmiennego, która jest skalowana za pomocą pokrętła. Ma trzy piny: GND, sygnał i + 5 V, jak pokazano na poniższym schemacie -

Wynik

Zmieniając pozycję NOP potencjometru, serwomotor zmieni swój kąt.

Silnik krokowy lub silnik krokowy to bezszczotkowy silnik synchroniczny, który dzieli pełny obrót na kilka kroków. W przeciwieństwie do bezszczotkowego silnika prądu stałego, który obraca się w sposób ciągły po przyłożeniu do niego stałego napięcia stałego, silnik krokowy obraca się w dyskretnych krokach.

Dlatego silniki krokowe są wytwarzane z krokami na obrót 12, 24, 72, 144, 180 i 200, co daje kąty stopniowania 30, 15, 5, 2,5, 2 i 1,8 stopnia na stopień. Silnik krokowy może być sterowany ze sprzężeniem zwrotnym lub bez.

Wyobraź sobie silnik w samolocie RC. Silnik obraca się bardzo szybko w jednym lub drugim kierunku. Możesz zmieniać prędkość wraz z ilością mocy przekazywanej do silnika, ale nie możesz nakazać śmigłu, aby zatrzymał się w określonej pozycji.

Teraz wyobraź sobie drukarkę. Wewnątrz drukarki znajduje się wiele ruchomych części, w tym silniki. Jeden taki silnik działa jak podajnik papieru, obracające się rolki, które przesuwają kawałek papieru podczas drukowania na nim atramentu. Silnik ten musi być w stanie przesunąć papier na dokładną odległość, aby móc wydrukować następny wiersz tekstu lub następny wiersz obrazu.

Do gwintowanego pręta jest przymocowany inny silnik, który przesuwa głowicę drukującą w przód iw tył. Ponownie, ten gwintowany pręt musi zostać przesunięty o dokładną wielkość, aby wydrukować jedną literę po drugiej. Tutaj przydają się silniki krokowe.

Jak działa silnik krokowy?

Zwykły silnik prądu stałego obraca się tylko w jednym kierunku, podczas gdy silnik krokowy może obracać się w precyzyjnych przyrostach.

Silniki krokowe mogą obracać się o dokładną liczbę stopni (lub kroków) według potrzeb. Daje to całkowitą kontrolę nad silnikiem, umożliwiając przesunięcie go w dokładne miejsce i utrzymanie go w tej pozycji. Czyni to poprzez zasilanie cewek wewnątrz silnika przez bardzo krótki czas. Wadą jest to, że musisz cały czas zasilać silnik, aby utrzymać go w pożądanej pozycji.

Wszystko, co musisz na razie wiedzieć, to to, że aby ruszyć silnik krokowy, każesz mu wykonać określoną liczbę kroków w jednym lub drugim kierunku i podaj prędkość, z jaką ma kroczyć w tym kierunku. Istnieje wiele odmian silników krokowych. Opisane tutaj metody mogą być wykorzystane do wywnioskowania, jak używać innych silników i sterowników, o których nie wspomniano w tym samouczku. Jednak zawsze zaleca się zapoznanie się z arkuszami danych i instrukcjami silników i sterowników specyficznymi dla posiadanych modeli.

Wymagane składniki

Będziesz potrzebował następujących komponentów -

• 1 × płyta Arduino UNO
• 1 × mały bipolarny silnik krokowy, jak pokazano na poniższym obrazku
• 1 × LM298 jazdy IC

Procedura

Postępuj zgodnie ze schematem obwodu i wykonaj połączenia, jak pokazano na rysunku poniżej.

Naszkicować

Otwórz oprogramowanie Arduino IDE na swoim komputerze. Kodowanie w języku Arduino będzie sterować twoim obwodem. Otwórz nowy plik szkicu, klikając Nowy.

Kod Arduino

/* Stepper Motor Control */

#include <Stepper.h>
const int stepsPerRevolution = 90;
// change this to fit the number of steps per revolution
// for your motor
// initialize the stepper library on pins 8 through 11:
Stepper myStepper(stepsPerRevolution, 8, 9, 10, 11);

void setup() {
   // set the speed at 60 rpm:
   myStepper.setSpeed(5);
   // initialize the serial port:
   Serial.begin(9600);
}

void loop() {
   // step one revolution in one direction:
   Serial.println("clockwise");
   myStepper.step(stepsPerRevolution);
   delay(500);
   // step one revolution in the other direction:
   Serial.println("counterclockwise");
   myStepper.step(-stepsPerRevolution);
   delay(500);
}

Kod do uwagi

Ten program steruje jednobiegunowym lub bipolarnym silnikiem krokowym. Silnik jest podłączony do cyfrowych pinów 8-11 Arduino.

Wynik

Silnik wykona jeden obrót w jednym kierunku, a następnie jeden obrót w drugim.

W tym rozdziale będziemy używać biblioteki brzmień Arduino. To nic innego jak biblioteka Arduino, która wytwarza falę prostokątną o określonej częstotliwości (i 50% cyklu pracy) na dowolnym pinie Arduino. Opcjonalnie można określić czas trwania, w przeciwnym razie fala będzie kontynuowana do momentu wywołania funkcji stop (). Kołek można podłączyć do brzęczyka piezoelektrycznego lub głośnika, aby odtwarzać dźwięki.

Warning- Nie podłączaj pinu bezpośrednio do żadnego wejścia audio. Napięcie jest znacznie wyższe niż standardowe napięcia na poziomie sieci i może uszkodzić wejścia karty dźwiękowej itp. Aby obniżyć napięcie, można użyć dzielnika napięcia.

Wymagane składniki

Będziesz potrzebował następujących komponentów -

• Głośnik 1 × 8 omów
• Rezystor 1 × 1k
• 1 × płyta Arduino UNO

Procedura

Postępuj zgodnie ze schematem obwodu i wykonaj połączenia, jak pokazano na rysunku poniżej.

Naszkicować

Otwórz oprogramowanie Arduino IDE na swoim komputerze. Kodowanie w języku Arduino będzie sterować twoim obwodem. Otwórz nowy plik szkicu, klikając Nowy.

Aby utworzyć plik pitches.h, kliknij przycisk znajdujący się tuż pod ikoną monitora szeregowego i wybierz opcję „Nowa karta” lub użyj kombinacji Ctrl + Shift + N.

Następnie wklej następujący kod -

/*************************************************
* Public Constants
*************************************************/

#define NOTE_B0 31
#define NOTE_C1 33
#define NOTE_CS1 35
#define NOTE_D1 37
#define NOTE_DS1 39
#define NOTE_E1 41
#define NOTE_F1 44
#define NOTE_FS1 46
#define NOTE_G1 49
#define NOTE_GS1 52
#define NOTE_A1 55
#define NOTE_AS1 58
#define NOTE_B1 62
#define NOTE_C2 65
#define NOTE_CS2 69
#define NOTE_D2 73
#define NOTE_DS2 78
#define NOTE_E2 82
#define NOTE_F2 87
#define NOTE_FS2 93
#define NOTE_G2 98
#define NOTE_GS2 104
#define NOTE_A2 110
#define NOTE_AS2 117
#define NOTE_B2 123
#define NOTE_C3 131
#define NOTE_CS3 139
#define NOTE_D3 147
#define NOTE_DS3 156
#define NOTE_E3 165
#define NOTE_F3 175
#define NOTE_FS3 185
#define NOTE_G3 196
#define NOTE_GS3 208
#define NOTE_A3 220
#define NOTE_AS3 233
#define NOTE_B3 247
#define NOTE_C4 262
#define NOTE_CS4 277
#define NOTE_D4 294
#define NOTE_DS4 311
#define NOTE_E4 330
#define NOTE_F4 349
#define NOTE_FS4 370
#define NOTE_G4 392
#define NOTE_GS4 415
#define NOTE_A4 440
#define NOTE_AS4 466
#define NOTE_B4 494
#define NOTE_C5 523
#define NOTE_CS5 554
#define NOTE_D5 587
#define NOTE_DS5 622
#define NOTE_E5 659
#define NOTE_F5 698
#define NOTE_FS5 740
#define NOTE_G5 784
#define NOTE_GS5 831
#define NOTE_A5 880
#define NOTE_AS5 932
#define NOTE_B5 988
#define NOTE_C6 1047
#define NOTE_CS6 1109
#define NOTE_D6 1175
#define NOTE_DS6 1245
#define NOTE_E6 1319
#define NOTE_F6 1397
#define NOTE_FS6 1480
#define NOTE_G6 1568
#define NOTE_GS6 1661
#define NOTE_A6 1760
#define NOTE_AS6 1865
#define NOTE_B6 1976
#define NOTE_C7 2093
#define NOTE_CS7 2217
#define NOTE_D7 2349
#define NOTE_DS7 2489
#define NOTE_E7 2637
#define NOTE_F7 2794
#define NOTE_FS7 2960
#define NOTE_G7 3136
#define NOTE_GS7 3322
#define NOTE_A7 3520
#define NOTE_AS7 3729
#define NOTE_B7 3951
#define NOTE_C8 4186
#define NOTE_CS8 4435
#define NOTE_D8 4699
#define NOTE_DS8 4978

Zapisz powyższy kod jako pitches.h

Kod Arduino

#include "pitches.h"
// notes in the melody:
int melody[] = {
NOTE_C4, NOTE_G3,NOTE_G3, NOTE_GS3, NOTE_G3,0, NOTE_B3, NOTE_C4};
// note durations: 4 = quarter note, 8 = eighth note, etc.:

int noteDurations[] = {
   4, 8, 8, 4,4,4,4,4 
};

void setup() {
   // iterate over the notes of the melody:
   for (int thisNote = 0; thisNote < 8; thisNote++) {
      // to calculate the note duration, take one second
      // divided by the note type.
      //e.g. quarter note = 1000 / 4, eighth note = 1000/8, etc.
      int noteDuration = 1000/noteDurations[thisNote];
      tone(8, melody[thisNote],noteDuration);
      //pause for the note's duration plus 30 ms:
      delay(noteDuration +30);
   }
}

void loop() {
   // no need to repeat the melody.
}

Kod do uwagi

Kod używa dodatkowego pliku, pitches.h. Ten plik zawiera wszystkie wartości wysokości dla typowych nut. Na przykład NOTE_C4 to środek C. NOTE_FS4 to Fis i tak dalej. Ta tabela nut została pierwotnie napisana przez Bretta Hagmana, na którego pracy opierała się komenda tone (). Może ci się to przydać, gdy chcesz robić nuty.

Wynik

Usłyszysz nuty zapisane w dźwiękach. H. plik.

Bezprzewodowe moduły nadajnika i odbiornika pracują z częstotliwością 315 MHz. Z łatwością mieszczą się w płytce prototypowej i dobrze współpracują z mikrokontrolerami, tworząc bardzo proste bezprzewodowe łącze danych. Z jedną parą nadajnika i odbiornika, moduły będą komunikować dane tylko w jedną stronę, jednak potrzebne byłyby dwie pary (o różnych częstotliwościach), aby działać jako para nadajnik / odbiornik.

Note- Te moduły są bezkrytyczne i odbierają sporo szumu. Zarówno nadajnik, jak i odbiornik pracują na wspólnych częstotliwościach i nie mają identyfikatorów.

Specyfikacje modułu odbiornika

• Model produktu - MX-05V
• Napięcie robocze - DC5V
• Prąd spoczynkowy - 4mA
• Częstotliwość odbioru - 315 Mhz
• Czułość odbiornika - -105DB
• Rozmiar - 30 * 14 * 7 mm

Specyfikacje modułu nadajnika

• Model produktu - MX-FS-03V
• Odległość startu - 20-200 metrów (inne napięcie, różne wyniki)
• Napięcie robocze - 3,5-12 V.
• Wymiary - 19 * 19 mm
• Tryb pracy - AM
• Szybkość transferu - 4KB / S
• Moc nadawcza - 10 mW
• Częstotliwość nadawania - 315 Mhz
• Antena zewnętrzna - 25cm zwykła linia wielożyłowa lub jednożyłowa
• Pinout od lewej → prawej - (DANE; V _CC ; GND)

Wymagane składniki

Będziesz potrzebował następujących komponentów -

• 2 × płyta Arduino UNO
• 1 × nadajnik łącza RF
• 1 × odbiornik łącza RF

Procedura

Postępuj zgodnie ze schematem obwodu i wykonaj połączenia, jak pokazano na rysunku poniżej.

Naszkicować

Otwórz oprogramowanie Arduino IDE na swoim komputerze. Kodowanie w języku Arduino będzie sterować twoim obwodem. Otwórz nowy plik szkicu, klikając Nowy.

Note- Musisz dołączyć bibliotekę klawiatury do pliku biblioteki Arduino. Skopiuj i wklej plik VirtualWire.lib do folderu bibliotek, jak zaznaczono na zrzucie ekranu podanym poniżej.

Kod Arduino dla nadajnika

//simple Tx on pin D12
#include <VirtualWire.h>
char *controller;

void setup() {
   pinMode(13,OUTPUT);
   vw_set_ptt_inverted(true);
   vw_set_tx_pin(12);
   vw_setup(4000);// speed of data transfer Kbps
}

void loop() {
   controller="1" ;
   vw_send((uint8_t *)controller, strlen(controller));
   vw_wait_tx(); // Wait until the whole message is gone
   digitalWrite(13,1);
   delay(2000);
   controller="0" ;
   vw_send((uint8_t *)controller, strlen(controller));
   vw_wait_tx(); // Wait until the whole message is gone
   digitalWrite(13,0);
   delay(2000);
}

Kod do uwagi

To jest prosty kod. Najpierw wyśle ​​znak „1”, a po dwóch sekundach wyśle ​​znak „0” i tak dalej.

Kod Arduino dla odbiornika

//simple Rx on pin D12
#include <VirtualWire.h>

void setup() {
   vw_set_ptt_inverted(true); // Required for DR3100
   vw_set_rx_pin(12);
   vw_setup(4000); // Bits per sec
   pinMode(5, OUTPUT);
   vw_rx_start(); // Start the receiver PLL running
}

void loop() {
   uint8_t buf[VW_MAX_MESSAGE_LEN];
   uint8_t buflen = VW_MAX_MESSAGE_LEN;
   if (vw_get_message(buf, &buflen)) // Non-blocking {
      if(buf[0]=='1') {
         digitalWrite(5,1);
      }
      if(buf[0]=='0') {
         digitalWrite(5,0);
      }
   }
}

Kod do uwagi

Dioda LED podłączona do pinu nr 5 na płycie Arduino zapala się po odebraniu znaku „1” i gaśnie po odebraniu znaku „0”.

Moduł Wi-Fi CC3000 firmy Texas Instruments to małe srebrne opakowanie, które w końcu zapewnia łatwą w użyciu, niedrogą funkcjonalność Wi-Fi w projektach Arduino.

Używa SPI do komunikacji (nie UART!), Więc możesz przesyłać dane tak szybko, jak chcesz lub tak wolno, jak chcesz. Ma odpowiedni system przerwań z pinem IRQ, dzięki czemu możesz mieć połączenia asynchroniczne. Obsługuje zabezpieczenia 802.11b / g, otwarte / WEP / WPA / WPA2, TKIP i AES. Wbudowany stos TCP / IP z interfejsem „gniazda BSD” obsługuje protokoły TCP i UDP zarówno w trybie klienta, jak i serwera.

Wymagane składniki

Będziesz potrzebował następujących komponentów -

• 1 × Arduino Uno
• 1 × Tablica rozdzielcza Adafruit CC3000
• Przekaźnik 1 × 5 V.
• 1 × dioda prostownicza
• 1 × LED
• Rezystor 1 × 220 Ohm
• 1 × Płytka prototypowa i kilka przewodów połączeniowych

Do tego projektu wystarczy zwykłe środowisko Arduino IDE, biblioteka Adafruit CC3000 oraz biblioteka CC3000 MDNS. Zamierzamy również wykorzystać bibliotekę aREST do wysyłania poleceń do przekaźnika przez WiFi.

Procedura

Postępuj zgodnie ze schematem obwodu i wykonaj połączenia, jak pokazano na rysunku poniżej.

Konfiguracja sprzętu dla tego projektu jest bardzo łatwa.

• Podłącz pin IRQ płyty CC3000 do styku numer 3 płyty Arduino.
• VBAT do pinu 5 i CS do pinu 10.
• Podłącz piny SPI do płyty Arduino: MOSI, MISO i CLK odpowiednio do pinów 11, 12 i 13.
• V _w połączony jest Arduino 5V oraz GND do GND.

Podłączmy teraz przekaźnik.

Po umieszczeniu przekaźnika na płytce stykowej można przystąpić do identyfikacji dwóch ważnych części przekaźnika: części cewkowej, która steruje przekaźnikiem oraz części przełącznika, do której przymocujemy diodę.

• Najpierw podłącz pin numer 8 płyty Arduino do jednego pinu cewki.
• Podłącz drugi pin do masy płyty Arduino.

Musisz również umieścić diodę prostowniczą (anodę podłączoną do bolca uziemienia) nad pinami cewki, aby chronić obwód, gdy przekaźnik się przełącza.

• Podłącz + 5V płytki Arduino do wspólnego styku przełącznika przekaźnika.

• Na koniec podłącz jeden z drugiego pinu przełącznika (zwykle ten, który nie jest podłączony, gdy przekaźnik jest wyłączony) do diody LED szeregowo z rezystorem 220 Ohm i podłącz drugą stronę diody do masy Arduino deska.

Testowanie poszczególnych komponentów

Możesz przetestować przekaźnik za pomocą następującego szkicu -

const int relay_pin = 8; // Relay pin

void setup() {
   Serial.begin(9600);
   pinMode(relay_pin,OUTPUT);
}

void loop() {
   // Activate relay
   digitalWrite(relay_pin, HIGH);
   // Wait for 1 second
   delay(1000);
   // Deactivate relay
   digitalWrite(relay_pin, LOW);
   // Wait for 1 second
   delay(1000);
}

Kod do uwagi

Kod nie wymaga objaśnień. Możesz po prostu załadować go na płytkę, a przekaźnik będzie przełączał stany co sekundę, a dioda LED będzie się odpowiednio włączać i wyłączać.

Dodawanie łączności WiFi

Sterujmy teraz przekaźnikiem bezprzewodowo za pomocą układu CC3000 WiFi. Oprogramowanie dla tego projektu oparte jest na protokole TCP. Jednak dla tego projektu na płytce Arduino będzie działał mały serwer WWW, dzięki czemu będziemy mogli „nasłuchiwać” poleceń przychodzących z komputera. Najpierw zajmiemy się szkicem Arduino, a potem zobaczymy, jak napisać kod po stronie serwera i stworzyć ładny interfejs.

Najpierw szkic Arduino. Celem jest połączenie się z siecią Wi-Fi, utworzenie serwera WWW, sprawdzenie, czy są przychodzące połączenia TCP, a następnie odpowiednia zmiana stanu przekaźnika.

Ważne części Kodeksu

#include <Adafruit_CC3000.h>
#include <SPI.h>
#include <CC3000_MDNS.h>
#include <Ethernet.h>
#include <aREST.h>

Musisz zdefiniować w kodzie, co jest specyficzne dla twojej konfiguracji, tj. Nazwa Wi-Fi i hasło oraz port komunikacji TCP (użyliśmy tutaj 80).

// WiFi network (change with your settings!)
   #define WLAN_SSID "yourNetwork" // cannot be longer than 32 characters!
   #define WLAN_PASS "yourPassword"
   #define WLAN_SECURITY WLAN_SEC_WPA2 // This can be WLAN_SEC_UNSEC, WLAN_SEC_WEP, 
   // WLAN_SEC_WPA or WLAN_SEC_WPA2

// The port to listen for incoming TCP connections
   #define LISTEN_PORT 80

Następnie możemy utworzyć instancję CC3000, serwer i instancję aREST -

// Server instance
   Adafruit_CC3000_Server restServer(LISTEN_PORT); // DNS responder instance
   MDNSResponder mdns; // Create aREST instance
   aREST rest = aREST();

W części szkicu setup () możemy teraz podłączyć układ CC3000 do sieci -

cc3000.connectToAP(WLAN_SSID, WLAN_PASS, WLAN_SECURITY);

Skąd komputer będzie wiedział, gdzie wysłać dane? Jednym ze sposobów byłoby jednokrotne uruchomienie szkicu, a następnie pobranie adresu IP karty CC3000 i ponowna modyfikacja kodu serwera. Jednak możemy zrobić to lepiej i właśnie w tym miejscu do gry wkracza biblioteka CC3000 MDNS. Za pomocą tej biblioteki przypiszemy stałą nazwę do naszej płyty CC3000, abyśmy mogli zapisać tę nazwę bezpośrednio w kodzie serwera.

Odbywa się to za pomocą następującego fragmentu kodu -

if (!mdns.begin("arduino", cc3000)) {
   while(1);
}

Musimy również nasłuchiwać połączeń przychodzących.

restServer.begin();

Następnie zakodujemy funkcję loop () szkicu, która będzie wykonywana w sposób ciągły. Najpierw musimy zaktualizować serwer mDNS.

mdns.update();

Serwer działający na płycie Arduino będzie czekał na połączenia przychodzące i obsłuży żądania.

Adafruit_CC3000_ClientRef client = restServer.available();
rest.handle(client);

Testowanie projektów przez WiFi jest teraz dość łatwe. Upewnij się, że zaktualizowałeś szkic własną nazwą Wi-Fi i hasłem, i prześlij szkic na swoją płytę Arduino. Otwórz monitor szeregowy Arduino IDE i poszukaj adresu IP swojej płyty.

Do końca załóżmy, że jest to coś w rodzaju 192.168.1.103.

Następnie przejdź do ulubionej przeglądarki internetowej i wpisz -

192.168.1.103/digital/8/1

Powinieneś zobaczyć, że twój przekaźnik automatycznie się włącza.

Budowanie interfejsu przekaźnika

Teraz zakodujemy interfejs projektu. Będą tutaj dwie części: plik HTML zawierający interfejs i plik JavaScript po stronie klienta, który obsługuje kliknięcia interfejsu. Interfejs tutaj jest oparty naaREST.js projekt, który powstał w celu łatwego sterowania urządzeniami WiFi z poziomu komputera.

Najpierw zobaczmy plik HTML o nazwie interface.html. Pierwsza część polega na zaimportowaniu wszystkich wymaganych bibliotek do interfejsu -

<head>
   <meta charset = utf-8 />
   <title> Relay Control </title>
   <link rel = "stylesheet" type = "text/css" 
      href = "https://maxcdn.bootstrapcdn.com/bootstrap/3.3.4/css/bootstrap.min.css">
   <link rel="stylesheet" type = "text/css" href = "style.css">
   <script type = "text/javascript" 
      src = "https://code.jquery.com/jquery-2.1.4.min.js"></script>
   <script type = "text/javascript" 
      src = "https://cdn.rawgit.com/Foliotek/AjaxQ/master/ajaxq.js"></script>
   <script type = "text/javascript" 
      src = "https://cdn.rawgit.com/marcoschwartz/aREST.js/master/aREST.js"></script>
   <script type = "text/javascript" 
      src = "script.js"></script>
</head>

Następnie definiujemy dwa przyciski wewnątrz interfejsu, jeden do włączania przekaźnika, a drugi do ponownego wyłączania.

<div class = 'container'>
   <h1>Relay Control</h1>
   <div class = 'row'>
      <div class = "col-md-1">Relay</div>
      <div class = "col-md-2">
         <button id = 'on' class = 'btn btn-block btn-success'>On</button>
      </div>
      <div class = "col-md-2">
         <button id = 'off' class = 'btn btn-block btn-danger'>On</button>
      </div>
   </div>
</div>

Teraz potrzebujemy również pliku Javascript po stronie klienta do obsługi kliknięć przycisków. Stworzymy również urządzenie, które połączymy z nazwą mDNS naszego urządzenia Arduino. Jeśli zmieniłeś to w kodzie Arduino, musisz to również zmodyfikować tutaj.

// Create device
var device = new Device("arduino.local");
// Button

$('#on').click(function() {
   device.digitalWrite(8, 1);
});

$('#off').click(function() {
   device.digitalWrite(8, 0);
});

Pełny kod tego projektu można znaleźć na GitHubmagazyn. Przejdź do folderu interfejsu i po prostu otwórz plik HTML w swojej ulubionej przeglądarce. Powinieneś zobaczyć coś podobnego w swojej przeglądarce -

Spróbuj kliknąć przycisk w interfejsie internetowym; powinien niemal natychmiast zmienić stan przekaźnika.

Jeśli udało Ci się to uruchomić, brawo! Właśnie zbudowałeś wyłącznik światła sterowany przez Wi-Fi. Oczywiście w tym projekcie możesz kontrolować znacznie więcej niż tylko światła. Po prostu upewnij się, że Twój przekaźnik obsługuje moc wymaganą dla urządzenia, którym chcesz sterować, i jesteś gotowy do pracy.