閱讀(11.4k) 書簽贊(0) 我要糾錯

Arduino的快速指南

2018-12-26 16:47 更新

Arduino - Overview

Arduino是一個基于易于使用的硬件和軟件的原型平臺(開源)。它包括一個可編程的電路板(稱為微控制器)和一個稱為Arduino IDE(集成開發(fā)環(huán)境)的現(xiàn)成軟件，用于將計算機代碼寫入并上傳到物理板。

主要特點是 -

Arduino板卡能夠讀取來自不同傳感器的模擬或數(shù)字輸入信號，并將其轉(zhuǎn)換為輸出，例如激活電機，打開/關(guān)閉LED，連接到云和許多其他操作。
您可以通過Arduino IDE(稱為上傳軟件)向板上的微控制器發(fā)送一組指令來控制板功能。
與大多數(shù)以前的可編程電路板不同，Arduino不需要額外的硬件(稱為編程器)，以便將新代碼加載到板上。您可以簡單地使用USB電纜。
此外，Arduino IDE使用C ++的簡化版本，使其更容易學(xué)習(xí)編程。
最后，Arduino提供了一個標準的外形規(guī)格，將微控制器的功能打破成更易于使用的封裝。

Board Types

根據(jù)使用的不同微控制器，可提供各種Arduino板。然而，所有Arduino板都有一個共同點:它們通過Arduino IDE編程。

差異基于輸入和輸出的數(shù)量(可以在單個板上使用的傳感器，LED和按鈕的數(shù)量)，速度，工作電壓，外形尺寸等。一些電路板設(shè)計為嵌入式并且沒有編程接口(硬件)，您需要單獨購買。有些可以直接從3.7V電池運行，其他人需要至少5V。

這里有一個不同的Arduino板的列表。

基于ATMEGA328微控制器的Arduino板卡

Board Name	Operating Volt	Clock Speed	Digital i/o	Analog Inputs	PWM	UART	Programming Interface
Arduino Uno R3	5V	16MHz	14	6	6	1	USB via ATMega16U2
Arduino Uno R3 SMD	5V	16MHz	14	6	6	1	USB via ATMega16U2
Red Board	5V	16MHz	14	6	6	1	USB via FTDI
Arduino Pro 3.3v/8 MHz	3.3V	8MHz	14	6	6	1	FTDI-Compatible Header
Arduino Pro 5V/16MHz	5V	16MHz	14	6	6	1	FTDI-Compatible Header
Arduino mini 05	5V	16MHz	14	8	6	1	FTDI-Compatible Header
Arduino Pro mini 3.3v/8mhz	3.3V	8MHz	14	8	6	1	FTDI-Compatible Header
Arduino Pro mini 5v/16mhz	5V	16MHz	14	8	6	1	FTDI-Compatible Header
Arduino Ethernet	5V	16MHz	14	6	6	1	FTDI-Compatible Header
Arduino Fio	3.3V	8MHz	14	8	6	1	FTDI-Compatible Header
LilyPad Arduino 328 main board	3.3V	8MHz	14	6	6	1	FTDI-Compatible Header
LilyPad Arduino simply board	3.3V	8MHz	9	4	5	0	FTDI-Compatible Header

基于ATMEGA32u4微控制器的Arduino板卡

Board Name	Operating Volt	Clock Speed	Digital i/o	Analog Inputs	PWM	UART	Programming Interface
Arduino Leonardo	5V	16MHz	20	12	7	1	Native USB
Pro micro 5V/16MHz	5V	16MHz	14	6	6	1	Native USB
Pro micro 3.3V/8MHz	5V	16MHz	14	6	6	1	Native USB
LilyPad Arduino USB	3.3V	8MHz	14	6	6	1	Native USB

基于ATMEGA2560微控制器的Arduino板卡

Board Name	Operating Volt	Clock Speed	Digital i/o	Analog Inputs	PWM	UART	Programming Interface
Arduino Mega 2560 R3	5V	16MHz	54	16	14	4	USB via ATMega16U2B
Mega Pro 3.3V	3.3V	8MHz	54	16	14	4	FTDI-Compatible Header
Mega Pro 5V	5V	16MHz	54	16	14	4	FTDI-Compatible Header
Mega Pro Mini 3.3V	3.3V	8MHz	54	16	14	4	FTDI-Compatible Header

基于AT91SAM3X8E微控制器的Arduino板卡

Board Name	Operating Volt	Clock Speed	Digital i/o	Analog Inputs	PWM	UART	Programming Interface
Arduino Mega 2560 R3	3.3V	84MHz	54	12	12	4	USB native

Arduino - Board Description

在本章中，我們將了解Arduino板上的不同組件。我們將研究Arduino UNO板，因為它是Arduino板系列中最受歡迎的板。此外，它是開始使用電子和編碼的最佳板。有些板子看起來有點不同于下面給出的，但大多數(shù)Arduinos有大部分這些組件是共同的。

	電源USB Arduino板可以使用計算機的USB電纜供電。所有您需要做的是將USB電纜連接到USB連接(1)。
	電源(Barrel Jack) Arduino板可以通過將其連接到桶形插座(2)直接從交流電源供電。
	穩(wěn)壓器電壓調(diào)節(jié)器的功能是控制提供給Arduino板的電壓，并穩(wěn)定處理器和其他元件使用的直流電壓。
	晶體振蕩器晶振幫助Arduino處理時間問題。 Arduino如何計算時間？答案是，通過使用晶體振蕩器。在Arduino晶體頂部打印的數(shù)字是16.000H9H。它告訴我們，頻率是16,000,000赫茲或16MHz。
	Arduino重設(shè) 你可以重置你的Arduino板，即從一開始你的程序。您可以通過兩種方式重置UNO板。首先，通過使用板上的復(fù)位按鈕(17)。其次，您可以將外部復(fù)位按鈕連接到標有RESET(5)的Arduino引腳。
	引腳(3.3，5，GND，Vin) 3.3V(6) - 電源3.3輸出電壓 5V(7) - 電源5輸出電壓與Arduino板使用的大多數(shù)組件工作正常與3.3伏和5伏。 GND(8)(接地) - Arduino上有幾個GND引腳，其中任何一個都可用于將電路接地。 Vin(9) - 此引腳也可用于從外部電源(如交流主電源)為Arduino板供電。
	模擬引腳 Arduino UNO板有五個模擬輸入引腳A0到A5。這些引腳可以從模擬傳感器(如濕度傳感器或溫度傳感器)讀取信號，并將其轉(zhuǎn)換為可由微處理器讀取的數(shù)字值。
	主微控制器每個Arduino板都有自己的微控制器(11)。你可以假設(shè)它作為你的董事會的大腦。 Arduino上的主IC(集成電路)與板對板略有不同。微控制器通常是ATMEL公司的。在從Arduino IDE加載新程序之前，你必須知道你的板子有什么IC。此信息位于IC頂部。有關(guān)IC結(jié)構(gòu)和功能的更多詳細信息，請參見數(shù)據(jù)表。
	ICSP pin 大多數(shù)情況下，ICSP(12)是一個AVR，一個由MOSI，MISO，SCK，RESET，VCC和GND組成的Arduino的微小編程頭。它通常被稱為SPI(串行外設(shè)接口)，其可以被認為是輸出的“擴展"。實際上，您正在將輸出設(shè)備驅(qū)動到SPI總線的主機。
	電源LED指示燈當您將Arduino插入電源以指示電路板已正確上電時，此LED應(yīng)點亮。如果這個指示燈不亮，那么連接有問題。
	TX和RX LED TX和RX LED ...
	數(shù)字I / O Arduino UNO板有14個數(shù)字I / O引腳(15)(其中6個提供PWM(脈寬調(diào)制)輸出)這些引腳可配置為輸入數(shù)字引腳，用于讀取邏輯值(0或1)或數(shù)字輸出引腳來驅(qū)動不同的模塊，如LED，繼電器等。標有“?"的引腳可用于產(chǎn)生PWM。
	AREF AREF代表模擬參考。它有時用于設(shè)置外部參考電壓(0和5伏之間)作為模擬輸入引腳的上限。

Arduino - Installation

在了解Arduino UNO主板的主要部分后，我們準備好學(xué)習(xí)如何設(shè)置Arduino IDE。一旦我們學(xué)到這一點，我們將準備好在Arduino板上傳我們的程序。

在本節(jié)中，我們將學(xué)習(xí)簡單的步驟，如何在我們的計算機上設(shè)置Arduino IDE，并準備板通過USB電纜接收程序。

第1步 - 首先，您必須有您的Arduino板(你可以選擇你最喜歡的板子)和一根USB電纜。如果您使用Arduino UNO，Arduino Duemilanove，Nano，Arduino Mega 2560或Diecimila，您將需要一個標準USB電纜(A插頭到B插頭)，您將連接到USB打印機，如下圖所示。

如果使用Arduino Nano，您將需要A到Mini-B電纜，如下圖所示。

步驟2 - 下載Arduino IDE軟件。

您可以從下載頁面獲得不同版本的Arduino IDE Arduino官方網(wǎng)站。您必須選擇與操作系統(tǒng)(Windows，IOS或Linux)兼容的軟件。文件下載完成后，解壓縮文件。

步驟3 - 打開您的開發(fā)板。

Arduino Uno，Mega，Duemilanove和Arduino Nano通過USB連接到計算機或外部電源自動獲取電源。如果您使用Arduino Diecimila，您必須確保電路板配置為從USB連接提取電源。電源選擇使用跳線，一小塊塑料安裝在USB和電源插孔之間的三個引腳中的兩個。檢查它是否在最靠近USB端口的兩個引腳上。

使用USB電纜將Arduino板連接到計算機。綠色電源LED(標有PWR)應(yīng)發(fā)光。

步驟4 - 啟動Arduino IDE。

下載Arduino IDE軟件后，需要解壓縮該文件夾。在文件夾中，您可以找到帶有無窮大標簽(application.exe)的應(yīng)用程序圖標。雙擊該圖標以啟動IDE。

步驟5 - 開啟第一個專案。

一旦軟件啟動，您有兩個選項 -

Create a new project.
Open an existing project example.

要創(chuàng)建新項目，請選擇文件→新建。

要打開現(xiàn)有項目示例，請選擇文件→示例→基本→Blink。

在這里，我們只選擇一個名為 Blink 的示例。它打開和關(guān)閉LED有一些時間延遲。您可以從列表中選擇任何其他示例。

步驟6 - 選擇您的Arduino主板。

為了避免在將程序上載到板上時出現(xiàn)任何錯誤，必須選擇與連接到計算機的板匹配的正確的Arduino板名稱。

轉(zhuǎn)到工具→板并選擇您的板。

在這里，我們根據(jù)我們的教程選擇了Arduino Uno板，但是你必須選擇與你使用的板匹配的名字。

步驟7 - 選擇串行端口。

選擇Arduino板的串行設(shè)備。轉(zhuǎn)到工具→串行端口菜單。這可能是COM3或更高(COM1和COM2通常保留為硬件串行端口)。要找到，你可以斷開你的Arduino板，并重新打開菜單，消失的條目應(yīng)該是Arduino板。重新連接電路板并選擇該串行端口。

步驟8 - 將程序上傳到您的主板。

在解釋如何將我們的程序上傳到開發(fā)板之前，我們必須演示Arduino IDE工具欄中出現(xiàn)的每個符號的功能。

A - 用于檢查是否存在編譯錯誤。

B - 用于將程序上傳到Arduino板。

C - 用于創(chuàng)建新草圖的快捷方式。

D - 用于直接打開示例草圖之一。

E - 用于保存草圖。

F - 用于從板接收串行數(shù)據(jù)并將串行數(shù)據(jù)發(fā)送到板的串行監(jiān)視器。

現(xiàn)在，只需點擊環(huán)境中的“上傳"按鈕。等待幾秒鐘; 您將看到板上的RX和TX LED，閃爍。如果上傳成功，則狀態(tài)欄中將顯示“完成上傳"消息。

注意 - 如果您有Arduino Mini，NG或其他電路板，則需要在單擊Arduino軟件上的上傳按鈕之前，立即按下電路板上的復(fù)位按鈕。

Arduino - Program Structure

在本章中，我們將深入研究Arduino程序結(jié)構(gòu)，并將學(xué)習(xí)更多Arduino世界中使用的新術(shù)語。 Arduino軟件是開源的。 Java環(huán)境的源代碼在GPL下發(fā)布，C / C ++微控制器庫在LGPL下。

草圖 - 第一個新的術(shù)語是名為“草圖"的Arduino程序。

Structure

Arduino程序可以分為三個主要部分:結(jié)構(gòu)，值(變量和常量)和函數(shù)。在本教程中，我們將逐步了解Arduino軟件程序，以及如何編寫程序，而不會出現(xiàn)任何語法或編譯錯誤。

讓我們從結(jié)構(gòu)開始。軟件結(jié)構(gòu)包括兩個主要功能 -

Setup( ) function
Loop( ) function

Void setup ( ) {

}

目的 - 草圖啟動時會調(diào)用 setup()函數(shù)。使用它來初始化變量，引腳模式，開始使用庫等。在每次上電或復(fù)位Arduino板之后，設(shè)置功能將只運行一次。
INPUT - -
OUTPUT - -
返回 - -

Void Loop ( ) {

}

目的 - 創(chuàng)建用于初始化并設(shè)置初始值的 setup()函數(shù)后， loop() ，并循環(huán)連續(xù)，允許您的程序更改和響應(yīng)。使用它來主動控制Arduino板。
INPUT - -
OUTPUT - -
返回 - -

Arduino - Data Types

C中的數(shù)據(jù)類型是指用于聲明不同類型的變量或函數(shù)的擴展系統(tǒng)。變量的類型確定它在存儲器中占用多少空間以及如何解釋存儲的位模式。

下表提供了您將在Arduino編程期間使用的所有數(shù)據(jù)類型。

void	Boolean	char	Unsigned char	byte	int	Unsigned int	word
long	Unsigned long	short	float	double	array	String-char array	String-object

void

void關(guān)鍵字僅用于函數(shù)聲明。它表示該函數(shù)預(yù)計不會向調(diào)用它的函數(shù)返回任何信息。

Example

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

Boolean

布爾值保存兩個值之一，true或false。每個布爾變量占用一個字節(jié)的內(nèi)存。

Example

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 false

Char

一種數(shù)據(jù)類型，占用存儲字符值的一個字節(jié)的內(nèi)存。字符文字用單引號寫成:\'A\'，對于多個字符，字符串使用雙引號:“ABC"。

但是，字符存儲為數(shù)字。您可以在 ASCII圖表中查看特定編碼。這意味著可以對字符進行算術(shù)運算，其中使用字符的ASCII值。例如，\'A\'+ 1的值為66，因為大寫字母A的ASCII值為65。

Example

Char chr_a = ‘a(chǎn)’ ;//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

無符號字符是一種無符號數(shù)據(jù)類型，占用一個字節(jié)的內(nèi)存。 unsigned char數(shù)據(jù)類型對0到255之間的數(shù)字進行編碼。

Example

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

byte

一個字節(jié)存儲一個8位無符號數(shù)，從0到255。

Example

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

int

整數(shù)是數(shù)字存儲的主數(shù)據(jù)類型。 int存儲16位(2字節(jié))值。這產(chǎn)生-32,768至32,767的范圍(最小值為-2 ^ 15，最大值為(2 ^ 15)-1)。

int 大小因板而異。例如，在Arduino Due中， int 存儲32位(4字節(jié))值。這產(chǎn)生-2,147,483,648至2,147,483,647(最小值-2 ^ 31和最大值(2 ^ 31)-1)的范圍。

Example

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

Unsigned int

無符號整數(shù)(無符號整數(shù))與存儲2字節(jié)值的方式相同。然而，它們不是存儲負數(shù)，而是存儲正值，產(chǎn)生0到65,535(2 ^ 16)-1的有用范圍。 Due存儲4字節(jié)(32位)值，范圍從0到4,294,967,295(2 ^ 32-1)。

Example

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

Word

在Uno和其他基于ATMEGA的主板上，一個字存儲一個16位無符號數(shù)。在到期和零時，它存儲一個32位無符號數(shù)。

Example

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

Long

長變量是用于數(shù)字存儲的擴展大小變量，并存儲32位(4字節(jié))，從2,147,483,648到2,147,483,647。

Example

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

unsigned long

無符號長變量是用于數(shù)字存儲的擴展大小變量，并存儲32位(4字節(jié))。與標準長整數(shù)不同，無符號整數(shù)不會存儲負數(shù)，使得它們的范圍為0到4,294,967,295(2 ^ 32 - 1)。

Example

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

short

short是16位數(shù)據(jù)類型。在所有Arduinos(基于ATMega和ARM)，一個短存儲一個16位(2字節(jié))的值。這產(chǎn)生-32,768至32,767的范圍(最小值為-2 ^ 15，最大值為(2 ^ 15)-1)。

Example

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

float

浮點數(shù)的數(shù)據(jù)類型是具有小數(shù)點的數(shù)字。浮點數(shù)通常用于近似模擬值和連續(xù)值，因為它們的分辨率高于整數(shù)。

浮點數(shù)可以大到3.4028235E + 38，也可以低到3.4028235E + 38。它們被存儲為32位(4字節(jié))的信息。

Example

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

double

在Uno和其他基于ATMEGA的主板上，雙精度浮點數(shù)占用四個字節(jié)。也就是說，double實現(xiàn)與float完全相同，精度沒有增益。在Arduino Due上，雙精度具有8字節(jié)(64位)精度。

Example

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

Arduino - Variables & Constants

在我們開始解釋變量類型之前，一個非常重要的主題我們需要確保，你完全理解稱為變量范圍。

What is Variable Scope?

Arduino使用的C編程語言中的變量具有名為scope的屬性。范圍是程序的一個區(qū)域，有三個地方可以聲明變量。他們是 -

Inside a function or a block, which is called local variables.
In the definition of function parameters, which is called formal parameters.
Outside of all functions, which is called global variables.

Local Variables

在函數(shù)或塊中聲明的變量是局部變量。它們只能由該函數(shù)或代碼塊中的語句使用。局部變量不知道在它們自己之外運行。以下是使用局部變量的示例 -

Void setup () {

}

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

Global Variables

全局變量定義在所有函數(shù)之外，通常在程序的頂部。全局變量將在程序的整個生命周期中保持其價值。

全局變量可以通過任何函數(shù)訪問。也就是說，一個全局變量可以在整個程序中聲明后使用。

以下示例使用全局變量和局部變量 -

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

Arduino - Operators

運算符是一個符號，它告訴編譯器執(zhí)行特定的數(shù)學(xué)或邏輯函數(shù)。 C語言具有豐富的內(nèi)置運算符，并提供以下類型的運算符:

Arithmetic Operators
Comparison Operators
Boolean Operators
Bitwise Operators
Compound Operators

Arithmetic Operators

假設(shè)變量A保持10，變量B保持20，則 -

Show Example

Operator name	Operator simple	Description	Example
assignment operator	=	Stores the value to the right of the equal sign in the variable to the left of the equal sign.	A = B
addition	+	Adds two operands	A + B will give 30
subtraction	-	Subtracts second operand from the first	A - B will give -10
multiplication	*	Multiply both operands	A * B will give 200
division	/	Divide numerator by denominator	B / A will give 2
modulo	%	Modulus Operator and remainder of after an integer division	B % A will give 0

Comparison Operators

假設(shè)變量A保持10，變量B保持20，則 -

Show Example

Operator name	Operator simple	Description	Example
equal to	==	Checks if the value of two operands is equal or not, if yes then condition becomes true.	(A == B) is not true
not equal to	!=	Checks if the value of two operands is equal or not, if values are not equal then condition becomes true.	(A != B) is true
less than	<	Checks if the value of left operand is less than the value of right operand, if yes then condition becomes true.	(A < B) is true
greater than	>	Checks if the value of left operand is greater than the value of right operand, if yes then condition becomes true.	(A > B) is not true
less than or equal to	<=	Checks if the value of left operand is less than or equal to the value of right operand, if yes then condition becomes true.	(A <= B) is true
greater than or equal to	>=	Checks if the value of left operand is greater than or equal to the value of right operand, if yes then condition becomes true.	(A >= B) is not true

Boolean Operators

假設(shè)變量A保持10，變量B保持20，則 -

Show Example

Operator name	Operator simple	Description	Example
and	&&	Called Logical AND operator. If both the operands are non-zero then then condition becomes true.	(A && B) is true
or	\|\|	Called Logical OR Operator. If any of the two operands is non-zero then then condition becomes true.	(A \|\| B) is true
not	!	Called Logical NOT Operator. Use to reverses the logical state of its operand. If a condition is true then Logical NOT operator will make false.	!(A && B) is false

Bitwise Operators

假設(shè)變量A保持10，變量B保持20，則 -

Show Example

Operator name	Operator simple	Description	Example
and	&	Binary AND Operator copies a bit to the result if it exists in both operands.	(A & B) will give 12 which is 0000 1100
or	\|	Binary OR Operator copies a bit if it exists in either operand	(A \| B) will give 61 which is 0011 1101
xor	^	Binary XOR Operator copies the bit if it is set in one operand but not both.	(A ^ B) will give 49 which is 0011 0001
not	~	Binary Ones Complement Operator is unary and has the effect of 'flipping' bits.	(~A ) will give -60 which is 1100 0011
shift left	<<	Binary Left Shift Operator. The left operands value is moved left by the number of bits specified by the right operand.	A << 2 will give 240 which is 1111 0000
shift right	>>	Binary Right Shift Operator. The left operands value is moved right by the number of bits specified by the right operand.	A >> 2 will give 15 which is 0000 1111

Compound Operators

假設(shè)變量A保持10，變量B保持20，則 -

Show Example

Operator name	Operator simple	Description	Example
increment	++	Increment operator, increases integer value by one	A++ will give 11
decrement	--	Decrement operator, decreases integer value by one	A-- will give 9
compound addition	+=	Add AND assignment operator. It adds right operand to the left operand and assign the result to left operand	B += A is equivalent to B = B+ A
compound subtraction	-=	Subtract AND assignment operator. It subtracts right operand from the left operand and assign the result to left operand	B -= A is equivalent to B = B - A
compound multiplication	*=	Multiply AND assignment operator. It multiplies right operand with the left operand and assign the result to left operand	B= A is equivalent to B = B A
compound division	/=	Divide AND assignment operator. It divides left operand with the right operand and assign the result to left operand	B /= A is equivalent to B = B / A
compound modulo	%=	Modulus AND assignment operator. It takes modulus using two operands and assign the result to left operand	B %= A is equivalent to B = B % A
compound bitwise or	\|=	bitwise inclusive OR and assignment operator	A \|= 2 is same as A = A \| 2
compound bitwise and	&=	Bitwise AND assignment operator	A &= 2 is same as A = A & 2

Arduino - Control Statements

決策結(jié)構(gòu)要求程序員指定要由程序評估或測試的一個或多個條件。如果條件被確定為真，并且可選地，如果條件被確定為假，則應(yīng)當與要執(zhí)行的一個或多個語句一起執(zhí)行。

以下是在大多數(shù)編程語言中找到的典型決策結(jié)構(gòu)的一般形式 -

控制語句是控制程序執(zhí)行流程的源代碼中的元素。他們是 -

S.NO.	Control Statement & Description
1	If statement 它采用括號中的表達式和語句或語句塊。如果表達式為真，則執(zhí)行語句或語句塊，否則跳過這些語句。
2	If …else statement 一個 if 語句后面可以有一個可選的else語句，當表達式為false時執(zhí)行。
3	If…else if …else statement if 語句之后可以有一個可選的 else if ... else 語句，這對于使用single if ... else if語句測試各種條件非常有用。
4	switch case statement 類似于if語句， switch ... case 通過允許程序員指定應(yīng)在各種條件下執(zhí)行的不同代碼來控制程序的流程。
5	Conditional Operator ? : 條件運算符？ :是C中唯一的三元運算符。

Arduino - Loops

編程語言提供允許更復(fù)雜的執(zhí)行路徑的各種控制結(jié)構(gòu)。

循環(huán)語句允許我們多次執(zhí)行一個語句或一組語句，以下是大多數(shù)編程語言中循環(huán)語句的一般形式 -

C編程語言提供以下類型的循環(huán)來處理循環(huán)需求。

S.NO.	Loop & Description
1	while loop while循環(huán)將連續(xù)循環(huán)，無限循環(huán)，直到圓括號()內(nèi)的表達式變?yōu)榧佟?/span> 某些東西必須改變被測試的變量，或者while循環(huán)永遠不會退出。
2	do…while loop do ... while 循環(huán)類似于while循環(huán)。在while循環(huán)中，循環(huán)繼續(xù)條件在循環(huán)開始時測試，然后再執(zhí)行循環(huán)體。
3	for loop A for循環(huán)執(zhí)行語句預(yù)定次數(shù)。循環(huán)的控制表達式在for循環(huán)括號內(nèi)完全初始化，測試和操作。
4	Nested Loop C語言允許您在另一個循環(huán)內(nèi)使用一個循環(huán)。下面的例子說明了這個概念。
5	Infinite loop 它是沒有終止條件的循環(huán)，因此循環(huán)變?yōu)闊o限。

Arduino - Functions

函數(shù)允許在代碼段中構(gòu)造程序以執(zhí)行單獨的任務(wù)。創(chuàng)建函數(shù)的典型情況是當需要在程序中多次執(zhí)行相同的操作時。

將代碼片段標準化為函數(shù)具有幾個優(yōu)點 -

函數(shù)幫助程序員保持組織。通常這有助于概念化程序。
函數(shù)將一個動作編碼在一個地方，以便函數(shù)只需要考慮一次并調(diào)試一次。
如果代碼需要更改，這也減少了修改錯誤的幾率。
函數(shù)使整個草圖更小和更緊湊，因為代碼段被重復(fù)使用多次。
它們使得通過使其模塊化在其他程序中重用代碼變得更容易，并且使用函數(shù)通常使得代碼更可讀。

在Arduino草圖或程序中有兩個必需的函數(shù)，即setup()和loop()。其他函數(shù)必須在這兩個函數(shù)的括號之外創(chuàng)建。

定義函數(shù)的最常用的語法是 -

Function Declaration

一個函數(shù)聲明在任何其他函數(shù)之外，高于或低于循環(huán)函數(shù)。

我們可以用兩種不同的方式聲明函數(shù) -

第一種方法是在循環(huán)函數(shù)上面寫入一個函數(shù)原型的函數(shù)的一部分，它包括 -

Function return type
Function name
Function argument type, no need to write the argument name

函數(shù)原型后面必須加上分號(;)。

以下示例顯示使用第一種方法的函數(shù)聲明的演示。

Example

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
}

第二部分，稱為函數(shù)定義或聲明，必須在循環(huán)函數(shù)下聲明，它包括 -

Function return type
Function name
Function argument type, here you must add the argument name
The function body (statements inside the function executing when the function is called)

以下示例演示使用第二種方法的函數(shù)聲明。

Example

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
}

第二種方法只是在循環(huán)函數(shù)上面聲明函數(shù)。

Arduino - Strings

字符串用于存儲文本。它們可用于在LCD或Arduino IDE串行監(jiān)視器窗口中顯示文本。字符串也可用于存儲用戶輸入。例如，用戶在鍵盤上連接到Arduino的字符。

在Arduino編程中有兩種類型的字符串:

Arrays of characters, which are the same as the strings used in C programming.
The Arduino String, which lets us use a string object in a sketch.

在本章中，我們將學(xué)習(xí)Arduino草圖中的字符串，對象和字符串的使用。在本章結(jié)束時，您將學(xué)習(xí)在草圖中使用哪種類型的字符串。

String Character Arrays

我們要學(xué)習(xí)的第一種類型的字符串是字符串 char 的一系列字符。在上一章中，我們學(xué)習(xí)了一個數(shù)組是什么; 連續(xù)一系列相同類型的變量存儲在內(nèi)存中。字符串是一個char變量數(shù)組。

字符串是一個特殊的數(shù)組，在字符串的末尾有一個額外的元素，它總是具有值0(零)。這被稱為“空終止字符串"。

String Character Array Example

此示例將顯示如何創(chuàng)建字符串并將其打印到串行監(jiān)視器窗口。

示例

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() { 

}

以下示例顯示了字符串由什么組成; 一個具有可打印字符的字符數(shù)組和0作為數(shù)組的最后一個元素，表示這是字符串結(jié)束的位置。通過使用 Serial.println()并傳遞字符串的名稱，可以將字符串打印到Arduino IDE Serial Monitor窗口。

這個相同的例子可以以更方便的方式編寫，如下所示 -

示例

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

void loop() {

}

在這個草圖中，編譯器計算字符串數(shù)組的大小，并且自動使用null終止字符串。一個數(shù)組是六個元素長，由五個字符后跟一個零，其創(chuàng)建方式與上一個草圖完全相同。

Manipulating String Arrays

我們可以在草圖中更改字符串數(shù)組，如下圖所示。

Example

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() {

}

Result

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

草圖以下列方式工作。

Creating and Printing the String

在上面給出的草圖中，創(chuàng)建一個新的字符串，然后打印出來顯示在串行監(jiān)視器窗口中。

Shortening the String

通過用零終止零(2)替換字符串中的第14個字符來縮短字符串。這是從0開始計算的字符串數(shù)組中的元素號13。

打印字符串時，所有字符都打印到新的空終止零。其他字符不消失; 它們?nèi)匀淮嬖谟趦?nèi)存中，并且字符串數(shù)組仍然是相同的大小。唯一的區(qū)別是任何使用字符串的函數(shù)只能看到第一個空終止符。

Changing a Word in the String

最后，草圖用“茶"代替“蛋糕"一詞(3)。它首先必須用空格替換空終止符，如[13]，以便將字符串恢復(fù)為原始創(chuàng)建的格式。

新字符用單詞“tea"覆蓋單詞“cake"的“cak"。這是通過覆蓋單個字符。 “蛋糕"的“e"被替換為新的空結(jié)束字符。結(jié)果是字符串實際上以兩個空字符終止，原始字符在字符串的末尾，而新字符替換“蛋糕"中的“e"。這在打印新字符串時沒有區(qū)別，因為打印字符串的函數(shù)在遇到第一個空終止符時停止打印字符串字符。

Functions to Manipulate String Arrays

上一個sketch通過訪問字符串中的單個字符以手動方式操作字符串。為了更容易操作字符串數(shù)組，您可以編寫自己的函數(shù)來執(zhí)行，也可以使用 C 語言庫中的一些字符串函數(shù)。

Given below is the list Functions to Manipulate String Arrays

S.No.	Functions & Description
1	String() String類是版本0019的核心部分，允許您以比字符數(shù)組更復(fù)雜的方式使用和操作文本字符串。您可以連接字符串，附加到它們，搜索和替換子字符串等。它比一個簡單的字符數(shù)組占用更多的內(nèi)存，但它也更有用。作為參考，字符數(shù)組被稱為具有小“s"的字符串，String類的實例被稱為具有大寫字母S的字符串。注意，“雙引號"中指定的常量字符串被視為char數(shù)組，不是String類的實例
2	charAt() 訪問字符串的特定字符。
3	compareTo() 比較兩個字符串，測試一個是在另一個之前還是之后，或者它們是否相等。字符串使用字符的ASCII值逐字符比較。這意味著，例如，\'a\'在\'b\'之前但在\'A\'之后。數(shù)字在字母之前。
4	concat() 將參數(shù)附加到字符串。
5	c_str() 將字符串的內(nèi)容轉(zhuǎn)換為C樣式的以null結(jié)尾的字符串。請注意，這可以直接訪問內(nèi)部String緩沖區(qū)，應(yīng)謹慎使用。特別是，你不應(yīng)該通過返回的指針修改字符串。當您修改String對象或者它被銷毀時，由c_str()先前返回的任何指針將變得無效，不應(yīng)該再使用。
6	endsWith() 測試String是否以另一個字符串的字符結(jié)尾。
7	equals() 比較兩個字符串的相等性。比較是區(qū)分大小寫的，意味著字符串“hello"不等于字符串“HELLO"。
8	equalsIgnoreCase() 比較兩個字符串的相等性。比較不區(qū)分大小寫，意味著String(“hello")等于字符串(“HELLO")。
9	getBytes() 將字符串的字符復(fù)制到提供的緩沖區(qū)。
10	indexOf() 在另一個字符串中查找字符或字符串。默認情況下，它從字符串的開始搜索，但也可以從給定的索引開始，允許找到字符或字符串的所有實例。
11	lastIndexOf() 在另一個字符串中查找字符或字符串。默認情況下，它從字符串的結(jié)尾搜索，但也可以從給定的索引向后工作，允許定位字符或字符串的所有實例。
12	length() 返回字符串的長度，以字符為單位。 (請注意，這不包括尾隨的空字符。)
13	remove() 修改就地，字符串從提供的索引中刪除字符到字符串的結(jié)尾或從提供的索引到索引加計數(shù)。
14	replace() String replace()函數(shù)允許您用另一個字符替換給定字符的所有實例。您還可以使用replace用不同的子字符串替換字符串的子字符串。
15	reserve() String reserve()函數(shù)允許您在內(nèi)存中分配一個用于操作字符串的緩沖區(qū)。
16	setCharAt() 設(shè)置String的字符。對現(xiàn)有長度以外的索引沒有影響。
17	startsWith() 測試字符串是否以另一個字符串的字符開頭。
18	toCharArray() 將字符串的字符復(fù)制到提供的緩沖區(qū)。
19	substring() 獲取字符串的子字符串。起始索引是包含性的(相應(yīng)的字符包含在子字符串中)，但可選的結(jié)束索引是排它的(相應(yīng)的字符不包括在子字符串中)。如果省略結(jié)束索引，子字符串將繼續(xù)到字符串的結(jié)尾。
20	toInt() 將有效的字符串轉(zhuǎn)換為整數(shù)。輸入字符串應(yīng)以整數(shù)開始。如果字符串包含非整數(shù)，函數(shù)將停止執(zhí)行轉(zhuǎn)換。
21	到Float() 將有效的字符串轉(zhuǎn)換為浮點型。輸入字符串應(yīng)以數(shù)字開頭。如果字符串包含非數(shù)字字符，則函數(shù)將停止執(zhí)行轉(zhuǎn)換。例如，字符串“123.45"，“123"和“123fish"分別轉(zhuǎn)換為123.45,123.00和123.00。注意，“123.456"近似為123.46。還要注意，浮點數(shù)只有6-7個十進制數(shù)字的精度，更長的字符串可能會被截斷。
22	toLowerCase() 獲取字符串的小寫版本。從1.0開始，toLowerCase()修改字符串到位，而不是返回一個新的。
23	toUpperCase() 獲取字符串的大寫版本。從1.0開始，toUpperCase()修改字符串，而不是返回一個新的。
24	trim() 獲取一個版本的字符串，刪除任何前導(dǎo)和尾隨空格。從1.0開始，trim()修改字符串，而不是返回一個新的。

下一個草圖使用一些C字符串函數(shù)。

Example

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() {

}

Result

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

草圖以下列方式工作。

Print the String

新創(chuàng)建的字符串將打印到串行監(jiān)視器窗口，如以前的草圖所做。

Get the Length of the String

strlen()函數(shù)用于獲取字符串的長度。字符串的長度僅適用于可打印字符，不包括空終止符。

該字符串包含17個字符，因此我們在串行監(jiān)視器窗口中看到17個字符。

Get the Length of the Array

運算符sizeof()用于獲取包含字符串的數(shù)組的長度。長度包括空終止符，因此長度比字符串的長度多1。

sizeof()看起來像一個函數(shù)，但技術(shù)上是一個運算符。它不是C字符串庫的一部分，但在草圖中用于顯示數(shù)組大小和字符串大小(或字符串長度)之間的差異。

Copy a String

strcpy()函數(shù)用于將str []字符串復(fù)制到out_num []數(shù)組。 strcpy()函數(shù)將傳遞給它的第二個字符串復(fù)制到第一個字符串中。這個字符串的副本現(xiàn)在存在于out_num []數(shù)組中，但只占用了數(shù)組的18個元素，因此我們在數(shù)組中仍然有22個自由char元素。這些自由元素在內(nèi)存中的字符串之后找到。

將字符串復(fù)制到數(shù)組中，以便我們在數(shù)組中有一些額外的空間用于草圖的下一部分，這是在字符串的末尾添加一個字符串。

Append a String to a String (Concatenate)

草圖將一個字符串連接到另一個字符串，這稱為并置。這是使用strcat()函數(shù)完成的。 strcat()函數(shù)將傳遞給它的第二個字符串傳遞到傳遞給它的第一個字符串的末尾。

連接后，打印字符串的長度以顯示新的字符串長度。然后打印數(shù)組的長度，以顯示在40個元素長的數(shù)組中有一個25個字符長的字符串。

請記住，25個字符的長字符串實際上占用了26個字符的數(shù)組，因為null終止零。

Array Bounds

當使用字符串和數(shù)組時，在字符串或數(shù)組的邊界內(nèi)工作是非常重要的。在示例草圖中，創(chuàng)建了一個長度為40個字符的數(shù)組，以分配可用于處理字符串的內(nèi)存。

如果數(shù)組太小，我們試圖復(fù)制一個大于數(shù)組的字符串，那么字符串將復(fù)制到數(shù)組的末尾。超出數(shù)組末尾的內(nèi)存可能包含草圖中使用的其他重要數(shù)據(jù)，然后將被我們的字符串覆蓋。如果超出字符串末尾的內(nèi)存溢出，它可能會導(dǎo)致草圖崩潰或?qū)е乱馔庑袨椤?/span>

Arduino - String Object

在Arduino編程中使用的第二種類型的字符串是字符串對象。

What is an Object?

對象是一個包含數(shù)據(jù)和函數(shù)的構(gòu)造。字符串對象可以像變量一樣創(chuàng)建，并分配一個值或字符串。 String對象包含對包含在String對象中的字符串數(shù)據(jù)進行操作的函數(shù)(在面向?qū)ο缶幊?OOP)中稱為“方法")。

下面的草圖和解釋將清楚一個對象是什么，以及如何使用String對象。

Example

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() { 

}

Result

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

創(chuàng)建字符串對象，并在草圖頂部分配一個值(或字符串)。

String my_str = "This is my string." ;

這將創(chuàng)建一個名為 my_str 的String對象，并給它一個值“這是我的字符串"。

這可以與創(chuàng)建變量并為其分配一個值(如整數(shù))相比較 -

int my_var = 102;

草圖以下列方式工作。

Printing the String

該字符串可以打印到串行監(jiān)視器窗口，就像字符數(shù)組字符串。

Convert the String to Upper-case

創(chuàng)建的字符串對象my_str，有多個可以操作的函數(shù)或方法。這些方法通過使用對象名稱后跟點運算符(。)和要使用的函數(shù)的名稱來調(diào)用。

my_str.toUpperCase();

toUpperCase()函數(shù)對包含在類型為String的 my_str 對象中的字符串進行操作，并將對象包含的字符串數(shù)據(jù)(或文本)轉(zhuǎn)換為大寫字符。 String類包含的函數(shù)列表可以在Arduino String參考中找到。從技術(shù)上講，String被稱為一個類，用于創(chuàng)建String對象。

Overwrite a String

賦值運算符用于為替換舊字符串的 my_str 對象分配一個新字符串

my_str = "My new string." ;

賦值運算符不能用于字符數(shù)組字符串，但僅適用于String對象。

Replacing a Word in the String

replace()函數(shù)用于替換傳遞給它的第二個字符串傳遞給它的第一個字符串。 replace()是另一個內(nèi)置到String類中的函數(shù)，因此可以在String對象my_str上使用。

Getting the Length of the String

通過使用length()可以很容易地獲得字符串的長度。在示例草圖中，由length()返回的結(jié)果直接傳遞到Serial.println()，而不使用中間變量。

When to Use a String Object

字符串對象比字符串字符數(shù)組更容易使用。該對象具有內(nèi)置函數(shù)，可以對字符串執(zhí)行多個操作。

使用String對象的主要缺點是，它使用了大量的內(nèi)存，并可以迅速使用Arduinos的RAM內(nèi)存，這可能會導(dǎo)致Arduino掛起，崩潰或行為意外。如果在Arduino上的草圖很小，并限制對象的使用，那么應(yīng)該沒有問題。

字符數(shù)組字符串更難使用，你可能需要編寫自己的函數(shù)來操作這些類型的字符串。其優(yōu)點是，你可以控制字符串數(shù)組的大小，所以你可以保持數(shù)組小，以節(jié)省內(nèi)存。

你需要確保你不要超出數(shù)組邊界的字符串數(shù)組的末尾。 String對象沒有這個問題，并且會處理你的字符串邊界，只要有足夠的內(nèi)存來操作。 String對象可以嘗試在內(nèi)存不足時寫入不存在的內(nèi)存，但不會在其操作的字符串的末尾寫入。

Where Strings are Used

在本章中，我們研究了字符串，它們在內(nèi)存中的行為及其操作。

當我們研究如何從串行監(jiān)視器窗口獲取用戶輸入并將輸入保存在字符串中時，本課程的下一部分將介紹字符串的實際用法。

Arduino - Time

Arduino提供四種不同的時間操作功能。他們是 -

S.No.	Function & Description
1	delay () function delay()函數(shù)的工作方式非常簡單。它接受單個整數(shù)(或數(shù)字)參數(shù)。此數(shù)字表示時間(以毫秒為單位)。
2	delayMicroseconds () function delayMicroseconds()函數(shù)接受單個整數(shù)(或數(shù)字)參數(shù)。有一千毫秒在一毫秒，和一百萬微秒在一秒鐘。
3	millis () function 此函數(shù)用于返回當時的毫秒數(shù)，Arduino板開始運行當前程序。
4	micros () function micros()函數(shù)返回從時間開始的微秒數(shù)，Arduino板開始運行當前程序。該數(shù)字溢出，即在大約70分鐘后回到零。

Arduino - Arrays

數(shù)組是具有相同類型的連續(xù)的一組存儲器位置。要引用數(shù)組中的特定位置或元素，我們指定數(shù)組的名稱和數(shù)組中特定元素的位置編號。

下圖給出了一個名為C的整數(shù)數(shù)組，它包含11個元素。通過給出數(shù)組名稱后跟特定元素的位置編號([])，您引用這些元素中的任何一個。位置編號更正式地稱為下標或索引(此數(shù)字指定從數(shù)組開始的元素數(shù))。第一個元素具有下標0(零)，有時稱為零元素。

因此，數(shù)組C的元素是C [0](發(fā)音為“C sub zero")，C [1]，C [2]等等。陣列C中的最高下標是10，其比陣列(11)中的元素的數(shù)量小1。數(shù)組名遵循與其他變量名相同的約定。

下標必須是整數(shù)或整數(shù)表達式(使用任何整數(shù)類型)。如果程序使用表達式作為下標，則程序評估表達式以確定下標。例如，如果我們假設(shè)變量a等于5，變量b等于6，那么語句將2添加到數(shù)組元素C [11]。

下標數(shù)組名是一個左值，它可以在賦值的左側(cè)使用，就像非數(shù)組變量名一樣。

讓我們更仔細地檢查給定圖中的數(shù)組C. 整個數(shù)組的名稱是C.它的11個元素被稱為C [0]到C [10]。 C [0]的值為-45，C [1]的值為6，C [2]的值為0，C [7]的值為62，C [10]的值為 78。

要打印包含在數(shù)組C的前三個元素中的值的總和，我們將寫 -

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

要將C [6]的值除以2并將結(jié)果賦給變量x，我們將寫為 -

x = C[ 6 ] / 2;

Declaring Arrays

數(shù)組占用內(nèi)存中的空間。要指定元素的類型和數(shù)組所需的元素數(shù)量，請使用形式的聲明 -

type arrayName [ arraySize ] ;

編譯器保留適當?shù)膬?nèi)存量。 (回想一個聲明，它保留內(nèi)存更恰當?shù)胤Q為定義)。 arraySize必須是大于零的整數(shù)常量。例如，要告訴編譯器為整數(shù)數(shù)組C保留11個元素，請使用聲明 -

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

數(shù)組可以聲明為包含任何非引用數(shù)據(jù)類型的值。例如，字符串類型的數(shù)組可以用于存儲字符串。

Examples Using Arrays

本節(jié)提供了許多演示如何聲明，初始化和操作數(shù)組的例子。

Example 1: Declaring an Array and using a Loop to Initialize the Array’s Elements

程序聲明一個10元素的整數(shù)數(shù)組 n 。行a-b使用 For 語句將數(shù)組元素初始化為零。與其他自動變量一樣，自動數(shù)組不會隱式初始化為零。第一個輸出語句(行c)顯示在后續(xù)for語句(行d-e)中打印的列的列標題，以列表格式打印數(shù)組。

示例

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

結(jié)果 - 它會產(chǎn)生以下結(jié)果 -

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

Element

Value

Example 2: Initializing an Array in a Declaration with an Initializer List

數(shù)組元素也可以在數(shù)組聲明中通過帶有等號的數(shù)組名和以逗號分隔的逗號分隔的初始值的列表來初始化。程序使用初始化器列表初始化具有10個值(行a)的整數(shù)數(shù)組，并以表格格式(行b-c)打印數(shù)組。

示例

// 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 ) // initialize elements of array n 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’) ;
   } 
}

結(jié)果 - 它會產(chǎn)生以下結(jié)果 -

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

Element

Value

Example 3: Summing the Elements of an Array

通常，數(shù)組的元素表示要在計算中使用的一系列值。例如，如果數(shù)組的元素表示考試成績，則教授可能希望總計數(shù)組的元素并使用該和來計算考試的類平均值。程序?qū)?0元素整數(shù)數(shù)組 a 中包含的值進行求和。

示例

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

結(jié)果 - 它會產(chǎn)生以下結(jié)果 -

Total of array elements: 849

數(shù)組對Arduino很重要，應(yīng)該需要更多的關(guān)注。以下與數(shù)組相關(guān)的重要概念應(yīng)該清楚Arduino -

S.NO.	Concept & Description
1	Passing Arrays to Functions 要將數(shù)組參數(shù)傳遞給函數(shù)，請指定沒有任何括號的數(shù)組的名稱。
2	Multi-Dimensional Arrays 具有兩個維度(即，下標)的數(shù)組通常表示由以行和列排列的信息組成的值的表。

Arduino - I/O Functions

Arduino板上的引腳可以配置為輸入或輸出。我們將解釋這些模式下引腳的功能。重要的是要注意，大多數(shù)Arduino模擬引腳可以以與數(shù)字引腳完全相同的方式配置和使用。

Pins Configured as INPUT

Arduino引腳默認配置為輸入，因此在使用它們作為輸入時，不需要使用 pinMode()顯式聲明為輸入。以這種方式配置的引腳被稱為處于高阻抗狀態(tài)。輸入引腳對它們采樣的電路提出非常小的要求，相當于引腳前面的100兆歐的串聯(lián)電阻。

這意味著將輸入引腳從一個狀態(tài)切換到另一個狀態(tài)需要非常小的電流。這使得引腳可用于諸如實現(xiàn)電容式觸摸傳感器或?qū)ED讀作光電二極管的任務(wù)。

被配置為pinMode(pin，INPUT)的引腳，沒有任何連接到它們，或者連接到它們的未連接到其他電路的引線，報告引腳狀態(tài)似乎隨機變化，從環(huán)境拾取電噪聲，或電容耦合狀態(tài) 的附近針。

Pull-up Resistors

如果沒有輸入，上拉電阻通常用于將輸入引腳轉(zhuǎn)向到已知狀態(tài)。這可以通過在輸入上添加上拉電阻(to + plus; 5V)或下拉電阻(接地電阻)來實現(xiàn)。 10K電阻是上拉或下拉電阻的良好值。

Using Built-in Pull-up Resistor with Pins Configured as Input

Atmega芯片內(nèi)置了20000個上拉電阻，可通過軟件訪問。通過將 pinMode()設(shè)置為INPUT_PULLUP可訪問這些內(nèi)置上拉電阻。這有效地反轉(zhuǎn)了INPUT模式的行為，其中HIGH表示傳感器關(guān)閉，LOW表示傳感器打開。此上拉的值取決于所使用的微控制器。在大多數(shù)基于AVR的板上，該值保證在20kΩ和50kΩ之間。在Arduino Due上，它在50kΩ和150kΩ之間。有關(guān)確切值，請參考板上微控制器的數(shù)據(jù)手冊。

當將傳感器連接到配置有INPUT_PULLUP的引腳時，另一端應(yīng)連接到地。在簡單開關(guān)的情況下，這導(dǎo)致當開關(guān)打開時引腳讀取高，當按下開關(guān)時引腳讀取低。上拉電阻提供足夠的電流來點亮與配置為輸入的引腳微調(diào)連接的LED。如果項目中的LED似乎工作，但很昏暗，這可能是發(fā)生了什么。

控制引腳是高電平還是低電平的相同寄存器(內(nèi)部芯片存儲器位置)控制上拉電阻。因此，當引腳處于INPUTmode狀態(tài)時，被配置為具有上拉電阻的引腳將被配置為HIGH，如果引腳被pinMode()切換到OUTPUT模式。這也在另一個方向工作，并且如果切換到具有pinMode()的輸入，留在高電平狀態(tài)的輸出引腳將設(shè)置上拉電阻。

示例

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

Pins Configured as OUTPUT

配置為具有pinMode()的OUTPUT的引腳被稱為處于低阻抗狀態(tài)。這意味著它們可以向其他電路提供大量的電流。 Atmega引腳可以向其他器件/電路提供(提供正電流)或吸收(提供負電流)高達40 mA(毫安)的電流。這是足以照亮LED的電流(不要忘記串聯(lián)電阻)，或者運行許多傳感器，但沒有足夠的電流來運行繼電器，電磁閥或電機。

試圖從輸出引腳運行高電流器件，可能損壞或破壞引腳中的輸出晶體管，或損壞整個Atmega芯片。通常，這導(dǎo)致微控制器中的“死"引腳，但是剩余的芯片仍然充分地起作用。因此，最好通過470Ω或1k電阻將OUTPUT引腳連接到其他器件，除非特定應(yīng)用需要從引腳提取的最大電流。

pinMode() Function

pinMode()函數(shù)用于將特定引腳配置為輸入或輸出。可以使用INPUT_PULLUP模式使能內(nèi)部上拉電阻。此外，INPUT模式顯式禁止內(nèi)部上拉。

pinMode() Function Syntax

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

pin - 您希望設(shè)置模式的引腳的編號
模式 - INPUT，OUTPUT或INPUT_PULLUP。

示例

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

digitalWrite() Function

digitalWrite()功能用于向數(shù)字引腳寫入HIGH或LOW值。如果該引腳已配置為具有 pinMode()的OUTPUT，其電壓將被設(shè)置為相應(yīng)的值:5V(或3.3V板上的3.3V)對于HIGH，0V(接地)對于LOW。如果引腳配置為INPUT，則digitalWrite()將使能(HIGH)或禁止(LOW)輸入引腳上的內(nèi)部上拉。建議將 pinMode()設(shè)置為INPUT_PULLUP，以啟用內(nèi)部上拉電阻。

如果不將pinMode()設(shè)置為OUTPUT，并將LED連接到引腳，則在調(diào)用digitalWrite(HIGH)時，LED可能會變暗。沒有明確設(shè)置pinMode()，digitalWrite()將使能內(nèi)部上拉電阻，它像一個大電流限制電阻。

digitalWrite() Function Syntax

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

pin - 您希望設(shè)置模式的引腳的編號
值 - HIGH或LOW。

示例

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
}

analogRead( ) function

Arduino能夠檢測是否有一個電壓施加到其引腳，并通過digitalRead()函數(shù)報告。在開/關(guān)傳感器(其檢測物體的存在)和模擬傳感器之間存在差異，其值連續(xù)變化。為了讀取這種類型的傳感器，我們需要一個不同類型的引腳。

在Arduino板的右下部分，您將看到六個標記為“模擬輸入"的引腳。這些特殊引腳不僅可以判斷是否有電壓施加到它們，而且它的值。通過使用 analogRead()函數(shù)，我們可以讀取施加到其中一個引腳的電壓。

此函數(shù)返回0和1023之間的數(shù)字，表示0和5伏特之間的電壓。例如，如果施加到引腳號0的電壓為2.5V，則analogRead(0)返回512。

analogRead() function Syntax

analogRead(pin);

pin - 要讀取的模擬輸入引腳的編號(大多數(shù)電路板上為0至5，Mini和Nano上為0至7，Mega上為0至15)

示例

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
}

Arduino - Advanced I/O Function

在本章中，我們將學(xué)習(xí)一些高級的輸入和輸出函數(shù)。

analogReference() Function

配置用于模擬輸入的參考電壓(即用作輸入范圍頂部的值)。選項是 -

DEFAULT - 5伏(5V Arduino板)或3.3伏(3.3V Arduino板)的默認模擬參考值
INTERNAL - 內(nèi)置參考，ATmega168或ATmega328上的1.1伏特，ATmega8上的2.56伏特(不適用于Arduino Mega)
INTERNAL1V1 - 內(nèi)置1.1V參考(僅限Arduino Mega)
INTERNAL2V56 - 內(nèi)建的2.56V參考(僅限Arduino Mega)
EXTERNAL - 施加到AREF引腳的電壓(僅限0到5V)用作參考

analogReference() Function Syntax

analogReference (type);

type - 可以使用以下任何類型(DEFAULT，INTERNAL，INTERNAL1V1，INTERNAL2V56，EXTERNAL)

對AREF引腳的外部參考電壓不要使用小于0V或大于5V的任何值。如果在AREF引腳上使用外部參考，則必須在調(diào)用 analogRead()函數(shù)之前將模擬參考設(shè)置為EXTERNAL。否則，將短路有效參考電壓(內(nèi)部生成的)和AREF引腳，可能會損壞Arduino板上的微控制器。

或者，您可以通過5K電阻將外部參考電壓連接到AREF引腳，從而允許在外部和內(nèi)部參考電壓之間切換。

注意，電阻將改變用作參考的電壓，因為AREF引腳上有一個內(nèi)部32K電阻。兩者用作分壓器。例如，通過電阻器施加的2.5V將在AREF引腳處產(chǎn)生2.5 * 32 /(32＆amp;加; 5)=?2.2V。

示例

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
}

Arduino - Character Functions

所有數(shù)據(jù)作為字符輸入計算機，包括字母，數(shù)字和各種特殊符號。在本節(jié)中，我們討論C ++用于檢查和處理單個字符的能力。

字符處理庫包括執(zhí)行字符數(shù)據(jù)的有用測試和操作的幾個函數(shù)。每個函數(shù)接收一個字符，表示為int或EOF作為參數(shù)。字符通常作為整數(shù)操作。

記住，EOF通常具有值-1，并且一些硬件架構(gòu)不允許負值存儲在char變量中。因此，字符處理函數(shù)將字符操作為整數(shù)。

下表總結(jié)了字符處理庫的功能。使用字符處理庫中的函數(shù)時，請包含< cctype> 標題。

S.No.	Prototype & Description
1	int isdigit(int c) 如果c是數(shù)字，則返回1，否則返回0。
2	int isalpha(int c) 如果c是字母，則返回1，否則返回0。
3	int isalnum(int c) 如果c是數(shù)字或字母，則返回1，否則返回0。
4	int isxdigit(int c) 如果c是十六進制數(shù)字字符，則返回1，否則返回0。 (有關(guān)二進制，八進制，十進制和十六進制數(shù)字的詳細說明，請參見附錄D，數(shù)字系統(tǒng)。)
5	int islower(int c) 如果c是小寫字母，則返回1，否則返回0。
6	int isupper(int c) 如果c是大寫字母，則返回1; 0否則。
7	int isspace(int c) 如果c是空格字符換行符(\'\\ n\')，空格，則返回1 (\'\\ f\')，回車符(\'\\ r\')，水平制表符(\'\\ t\')或垂直制表符(\'\\ v\')，否則為0。
8	int iscntrl(int c) 如果c是控制字符，返回1，如換行符(\'\\ n\')，換頁符(\'\\ f\')，回車符(\'\\ r\')，水平制表符 \\ v\')，alert(\'\\ a\')或退格(\'\\ b\') - 否則為0。
9	int ispunct(int c) 如果c是除空格，數(shù)字或字母以外的打印字符，則返回1，否則返回0。
10	int isprint(int c) 如果c是包含空格(\'\')的打印字符，則返回1，否則返回0。
11	int isgraph(int c) 如果c是除空格(\'\')之外的打印字符，則返回1，否則返回0。

Examples

以下示例演示如何使用函數(shù) isdigit，isalpha，isalnum 和 isxdigit 。函數(shù) isdigit 確定其參數(shù)是否為數(shù)字(0-9)。函數(shù) isalpha 確定其參數(shù)是大寫字母(A-Z)還是小寫字母(a-z)。函數(shù) isalnum 確定其參數(shù)是大寫，小寫字母還是數(shù)字。函數(shù) isxdigit 確定其參數(shù)是否為十六進制數(shù)字(A-F，a-f，0-9)。

Example 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 () {

}

Result

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

我們使用每個函數(shù)的條件運算符(？:)來確定字符串“is a"或字符串“is not a"是否應(yīng)該在每個測試字符的輸出中打印。例如，行 a 表示如果\'8\'是數(shù)字，即如果 isdigit 返回真(非零)值，則打印字符串“8 is a" 。如果\'8\'不是數(shù)字(即，如果 isdigit 返回0)，則打印字符串“8不是a"。

Example 2

以下示例演示了函數(shù) islower 和 isupper 的使用。函數(shù) islower 確定其參數(shù)是否為小寫字母(a-z)。函數(shù) isupper 確定其參數(shù)是否為大寫字母(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 () {

}

Result

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

Example 3

以下示例演示如何使用函數(shù) isspace，iscntrl，ispunct，isprint 和 isgraph 。

函數(shù) isspace 確定其參數(shù)是否為空格字符，如空格(\'\')，換頁符(\'\\ f\')，換行符(\'\\ n\' \\ r\')，水平制表符(\'\\ t\')或垂直制表符(\'\\ v\')。
函數(shù) iscntrl 確定其參數(shù)是否為控制字符，如水平制表符(\'\\ t\')，垂直制表符(\'\\ v\' \\ a\')，backspace(\'\\ b\')，回車(\'\\ r\')或換行符(\'\\ n\')。
函數(shù) ispunct 確定其參數(shù)是否是除空格，數(shù)字或字母之外的打印字符，如$，＃，(，)，[，]，{，}，; 。
函數(shù) isprint 確定其參數(shù)是否為可以在屏幕上顯示的字符(包括空格字符)。
函數(shù) isgraph 測試與isprint相同的字符，但不包括空格字符。

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 () {

}

Result

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

Arduino - Math Library

Arduino數(shù)學(xué)庫(math.h)包括一些用于操作浮點數(shù)的有用的數(shù)學(xué)函數(shù)。

Library Macros

以下是在標題math.h中定義的宏:

Macros	Value	Description
M_E	2.7182818284590452354	The constant e.
M_LOG2E	1.4426950408889634074 / * log_2 e * /	The logarithm of the e to base 2
M_1_PI	0.31830988618379067154 / * 1 / pi * /	The constant 1/pi
M_2_PI	0.63661977236758134308 / * 2 / pi * /	The constant 2/pi
M_2_SQRTPI	1.12837916709551257390 / * 2 / sqrt(pi)* /	The constant 2/sqrt(pi)
M_LN10	2.30258509299404568402 / * log_e 10 * /	The natural logarithm of the 10
M_LN2	0.69314718055994530942 / * log_e 2 * /	The natural logarithm of the 2
M_LOG10E	0.43429448190325182765 / * log_10 e * /	The logarithm of the e to base 10
M_PI	3.14159265358979323846 / * pi * /	The constant pi
M_PI_2	3.3V1.57079632679489661923 / * pi / 2 * /	The constant pi/2
M_PI_4	0.78539816339744830962 / * pi / 4 * /	The constant pi/4
M_SQRT1_2	0.70710678118654752440 / * 1 / sqrt(2)* /	The constant 1/sqrt(2)
M_SQRT2	1.41421356237309504880 / * sqrt(2)* /	The square root of 2
acosf	-	The alias for acos() function
asinf	-	The alias for asin() function
atan2f	-	The alias for atan2() function
cbrtf	-	The alias for cbrt() function
ceilf	-	The alias for ceil() function
copysignf	-	The alias for copysign() function
coshf	-	The alias for cosh() function
expf	-	The alias for exp() function
fabsf	-	The alias for fabs() function
fdimf	-	The alias for fdim() function
floorf	-	The alias for floor() function
fmaxf	-	The alias for fmax() function
fminf	-	The alias for fmin() function
fmodf	-	The alias for fmod() function
frexpf	-	The alias for frexp() function
hypotf	-	The alias for hypot() function
INFINITY	-	INFINITY constant
isfinitef	-	The alias for isfinite() function
isinff	-	The alias for isinf() function
isnanf	-	The alias for isnan() function
ldexpf	-	The alias for ldexp() function
log10f	-	The alias for log10() function
logf	-	The alias for log() function
lrintf	-	The alias for lrint() function
lroundf	-	The alias for lround() function

Given below is the list of macros defined in the header math.h

Library Functions

以下函數(shù)在標題 math.h 中定義 -

Given below is the list of functions are defined in the header math.h

S.No.	Library Function & Description
1	double acos(double __x) acos()函數(shù)計算__x的反余弦的主值。返回的值在[0，π]弧度的范圍內(nèi)。對不在范圍[-1，+1]中的參數(shù)發(fā)生域錯誤。
2	double asin(double __x) asin()函數(shù)計算__x的正弦的主值。返回值的范圍為[-pi / 2，pi / 2]弧度。對不在范圍[-1，+1]中的參數(shù)發(fā)生域錯誤。
3	double atan(double __x) atan()函數(shù)計算__x的反正切的主值。返回值的范圍為[-pi / 2，pi / 2]弧度。
4	double atan2(double __y，double __x) atan2()函數(shù)計算__y / __x的反正切的主值，使用兩個參數(shù)的符號確定返回值的象限。返回的值在[-pi，+ pi]弧度范圍內(nèi)。
5	double cbrt(double __x) cbrt()函數(shù)返回__x的立方根。
6	double ceil(double __x) ceil()函數(shù)返回大于或等于__x的最小整數(shù)值，表示為浮點數(shù)。
7	static double copysign(double __x，double __y) copysign()函數(shù)返回__x，但帶有__y的符號。即使__x或__y是NaN或零，它們也會工作。
8	double cos(double __x) cos()函數(shù)返回__x的余弦，以弧度表示。
9	double cosh(double __x) cosh()函數(shù)返回__x的雙曲余弦值。
10	double exp(double __x) exp()函數(shù)返回__x的指數(shù)值。
11	雙晶圓廠(double __x) fabs()函數(shù)計算浮點數(shù)__x的絕對值。
12	double fdim(double __x，double __y) fdim()函數(shù)返回max(__ x - __y，0)。如果__x或__y或兩者都是NaN，則返回NaN。
13	雙層(double __x) floor()函數(shù)返回小于或等于__x的最大整數(shù)值，表示為浮點數(shù)。
14	double fma(double __x，double __y，double __z) fma()函數(shù)執(zhí)行浮點乘法。這是操作(__x * __y)+ __z，但中間結(jié)果不會四舍五入到目標類型。這有時可以提高計算的精度。
15	double fmax(double __x，double __y) fmax()函數(shù)返回兩個值__x和__y中的較大值。如果參數(shù)是NaN，則返回另一個參數(shù)。如果兩個參數(shù)都是NaN，則返回NaN。
16	double fmin(double __x，double __y) fmin()函數(shù)返回兩個值__x和__y中較小的一個。如果參數(shù)是NaN，則返回另一個參數(shù)。如果兩個參數(shù)都是NaN，則返回NaN。
17	double fmod(double __x，double__y) 函數(shù)fmod()返回__x / __y的浮點余數(shù)。
18	*double frexp(double __x，int __pexp)** frexp()函數(shù)將浮點數(shù)拆分為歸一化分數(shù)和2的積分冪。它將整數(shù)存儲在__pexp指向的int對象中。如果__x是正常浮點數(shù)，則frexp()函數(shù)返回值v，使得v具有在區(qū)間[1/2，1)或零中的幅度，并且__x等于乘以冪__pexp的v乘2。如果__x為零，則結(jié)果的兩個部分都為零。如果__x不是有限數(shù)字，則frexp()按原樣返回__x，并通過__pexp存儲0。注釋 - 此實現(xiàn)允許零指針作為指令跳過存儲指數(shù)。
19	double hypot(double __x，double__y) hypot()函數(shù)返回sqrt(__ x * __ x + __y * __ y)。這是直角三角形的斜邊長度，邊長為__x和__y，或者點(__x，__y)與原點的距離。使用此函數(shù)代替直接公式是明智的，因為錯誤小得多。沒有小的__x和__y下溢。如果結(jié)果在范圍內(nèi)，則不會溢出。
20	static int isfinite(double __x) 如果__x是有限的:not加或減無窮大，而不是 NaN ，則isfinite()函數(shù)返回非零值。
21	int isinf(double __x) 如果參數(shù)__x是正無窮大，函數(shù)isinf()返回1，如果__x是負無窮大，函數(shù)isinf()返回-1，否則返回0。注意 - GCC 4.3可以用內(nèi)聯(lián)代碼替換這個函數(shù)，返回?zé)o窮大(gcc bug＃35509)的1值。
22	int isnan(double __x) 如果參數(shù)__x表示“不是數(shù)字"( NaN )對象，則函數(shù)isnan()返回1，否則返回0。
23	double ldexp(double __x，int __exp) ldexp()函數(shù)將浮點數(shù)乘以2的積分冪。它返回__x乘以2的值乘以冪__exp。
24	double log(double __x) log()函數(shù)返回參數(shù)__x的自然對數(shù)。
25	double log10(double __x) log10()函數(shù)將參數(shù)__x的對數(shù)返回為10。
26	長印(double __x) 長印(double __x)... 返回舍入的長整數(shù)值。如果__x不是有限數(shù)字或溢出，則此實現(xiàn)將返回LONG_MIN值(0x80000000)。
27	長圓形(雙__x) lround()函數(shù)將__x舍入到最接近的整數(shù)，但是在離開零(而不是最接近的偶整數(shù))的情況下舍入一半的情況。此函數(shù)類似于round()函數(shù)，但它的返回值類型不同，并且可能發(fā)生溢出。返回舍入的長整數(shù)值。如果__x不是有限數(shù)字或溢出，則此實現(xiàn)將返回LONG_MIN值(0x80000000)。
28	*double modf(double __x，double __iptr)** modf()函數(shù)將參數(shù)__x打破為整數(shù)和小數(shù)部分，每個部分與參數(shù)具有相同的符號。它將整數(shù)部分存儲為__iptr指向的對象中的double。 modf()函數(shù)返回__x的帶符號小數(shù)部分。注意 - 此實現(xiàn)跳過使用零指針進行寫入。但是，GCC 4.3可以用不允許使用NULL地址避免存儲的內(nèi)聯(lián)代碼替換此函數(shù)。
29	*float modff(float __x，float __iptr)** modf()的別名。
30	double pow(double __x，double __y) 函數(shù)pow()將__x的值返回到指數(shù)__y。
31	雙輪(雙__x) round()函數(shù)將__x舍入到最接近的整數(shù)，但是在離開零(而不是最接近的偶整數(shù))的情況下舍入中途的情況。溢出是不可能的。返回舍入值。如果__x是一個積分或無限的，則返回__x本身。如果__x是 NaN ，則返回 NaN 。
32	int signbit(double __x) 如果__x的值的符號位置1，則signbit()函數(shù)返回非零值。這與\'__x< 0.0\'，因為IEEE 754浮點允許對零進行簽名。比較`-0.0＆ 0.0\'是false，但是“signbit(-0.0)"將返回一個非零值。
33	double sin(double __x) sine()函數(shù)返回__x的正弦，以弧度表示。
34	double sinh(double __x) sinh()函數(shù)返回__x的雙曲正弦值。
35	double sqrt(double __x) sqrt()函數(shù)返回__x的非負平方根。
36	雙正方形(雙__x) 函數(shù)square()返回__x * __x。注意 - 此功能不屬于C標準定義。
37	double tan(double __x) tan()函數(shù)返回__x的正切，以弧度表示。
38	double tanh(double __x) tanh()函數(shù)返回__x的雙曲正切。
39	double trunc(double __x) trunc()函數(shù)將__x舍入到絕對值不大的最近的整數(shù)。

Example

以下示例顯示如何使用最常用的math.h庫函數(shù) -

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() {

}

Result

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

Arduino - Trigonometric Functions

你需要使用三角學(xué)，就像計算移動物體的距離或角速度。 Arduino提供了傳統(tǒng)的三角函數(shù)(sin，cos，tan，asin，acos，atan)，可以通過寫他們的原型來概括。 Math.h包含三角函數(shù)的原型。

Trigonometric Exact Syntax

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

Example

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

Arduino - Due & Zero

Arduino Due是基于Atmel SAM3X8E ARM Cortex-M3 CPU的微控制器板。它是基于32位ARM內(nèi)核微控制器的第一個Arduino板。

重要功能 -

It has 54 digital input/output pins (of which 12 can be used as PWM outputs)
12 analog inputs
4 UARTs (hardware serial ports)
84 MHz clock, an USB OTG capable connection
2 DAC (digital to analog), 2 TWI, a power jack, an SPI header, a JTAG header
Reset button and an erase button

Characteristics of the Arduino Due Board

Operating volt	CPU speed	Analog in/out	Digital IO/ PWM	EEPROM [KB]	SRAM [KB]	Flash [KB]	USB	UART
3.3 Volt	84 Mhz	12/2	54/12	-	96	512	2 micro	4

Communication

4 Hardware UARTs
2 I2C
1 CAN Interface (Automotive communication protocol)
1 SPI
1 Interface JTAG (10 pin)
1 USB Host (like as Leonardo)
1 Programming Port

與大多數(shù)Arduino板不同，Arduino Due板運行在3.3V。 I / O引腳可以承受的最大電壓為3.3V。將高于3.3V的電壓施加到任何I / O引腳可能會損壞電路板。

該板包含支持微控制器所需的一切。您可以使用micro-USB電纜將其連接到計算機，或者使用AC-to-DC適配器或電池為其供電以開始使用。 Due與所有工作在3.3V的Arduino屏蔽兼容。

Arduino Zero

零是由UNO建立的平臺的簡單和強大的32位擴展。零板通過提供更高的性能，為設(shè)備提供各種項目機會來擴展系列，并且作為學(xué)習(xí)32位應(yīng)用程序開發(fā)的一個偉大的教育工具。

重要特點是 -

Zero應(yīng)用程序涵蓋從智能物聯(lián)網(wǎng)設(shè)備，可穿戴技術(shù)，高科技自動化，到瘋狂的機器人。
該板由Atmel的SAMD21 MCU供電，該MCU配有32位ARMCortex?M0 +內(nèi)核。
其最重要的特性之一是Atmel的嵌入式調(diào)試器(EDBG)，它提供了一個完整的調(diào)試接口，無需額外的硬件，顯著增加了軟件調(diào)試的易用性。
EDBG還支持可用于器件和引導(dǎo)加載程序編程的虛擬COM端口。

Characteristics of the Arduino Zero board

Operating volt	CPU speed	Analog in/out	Digital IO/ PWM	EEPROM [KB]	SRAM [KB]	Flash [KB]	USB	UART
3.3 Volt	48 Mhz	6/1	14/10	-	32	256	2 micro	2

與大多數(shù)Arduino和Genuino主板不同，Zero運行在3.3V。 I / O引腳可以承受的最大電壓為3.3V。將高于3.3V的電壓施加到任何I / O引腳可能會損壞電路板。

該板包含支持微控制器所需的一切。您可以使用micro-USB電纜將其連接到計算機，也可以使用AC-to-DC適配器或電池為其供電以開始使用。零點與工作在3.3V的所有屏蔽兼容。

Arduino - Pulse Width Modulation

脈沖寬度調(diào)制或PWM是用于改變脈沖串中的脈沖的寬度的常用技術(shù)。 PWM有許多應(yīng)用，如控制伺服和速度控制器，限制電機和LED的有效功率。

Basic Principle of PWM

脈寬調(diào)制基本上是一種方波，具有變化的高低時間。基本PWM信號如下圖所示。

有很多術(shù)語與PWM相關(guān) -

準時 - 時間信號持續(xù)時間較長。
關(guān)閉時間 - 時間信號的持續(xù)時間低。
周期 - 它表示為PWM信號的導(dǎo)通時間和關(guān)斷時間的總和。
占空比 - 它表示為在PWM信號周期內(nèi)保持開啟的時間信號的百分比。

Period

如圖所示，T sub表示導(dǎo)通時間，T suboff表示信號的截止時間。期間是開和關(guān)時間的和，并且如下式所示計算:

$$T_{total} = T_{on}+T_{off}$$

Duty Cycle

占空比被計算為該時間段的接通時間。使用上面計算的周期，占空比計算為 -

$$D = \frac{T_{on}}{T_{on}+T_{off}} = \frac{T_{on}}{T_{total}}$$

analogWrite() Function

analogWrite()函數(shù)將模擬值(PWM波)寫入引腳。它可用于以不同的亮度點亮LED或以各種速度驅(qū)動電機。在調(diào)用analogWrite()函數(shù)之后，引腳將生成指定占空比的穩(wěn)定方波，直到下一次調(diào)用analogWrite()或調(diào)用相同引腳上的digitalRead()或digitalWrite()。大多數(shù)引腳上的PWM信號頻率約為490 Hz。在Uno和類似的板上，引腳5和6的頻率約為980Hz。 Leonardo上的針腳3和11也以980Hz運行。

在大多數(shù)Arduino板上(具有ATmega168或ATmega328)，此功能在引腳3，5，6，9，10和11上工作。在Arduino Mega上，它在引腳2-13和44-46上工作。老Arduino 具有ATmega8的板僅支持引腳9,10和11上的 analogWrite()。

Arduino Due在引腳2至13以及引腳DAC0和DAC1上支持 analogWrite()。與PWM引腳不同，DAC0和DAC1是數(shù)模轉(zhuǎn)換器，用作真正的模擬輸出。

在調(diào)用analogWrite()之前，不需要調(diào)用pinMode()將引腳設(shè)置為輸出。

analogWrite() Function Syntax

analogWrite ( pin , value ) ;

value - 占空比:0(始終關(guān)閉)和255(始終打開)之間。

示例

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
}

Arduino - Random Numbers

要生成隨機數(shù)，可以使用Arduino隨機數(shù)函數(shù)。我們有兩個功能 -

randomSeed(seed)
random()

randomSeed (seed)

函數(shù)randomSeed(seed)重置Arduino的偽隨機數(shù)生成器。雖然random()返回的數(shù)字的分布基本上是隨機的，但是序列是可預(yù)測的。您應(yīng)該將發(fā)電機重置為某個隨機值。如果您有一個未連接的模擬引腳，它可能會拾取來自周圍環(huán)境的隨機噪聲。這些可以是無線電波，宇宙射線，來自蜂窩電話的電磁干擾，熒光燈等。

Example

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

random( )

隨機函數(shù)生成偽隨機數(shù)。以下是語法。

random( ) Statements Syntax

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

Example

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

讓我們現(xiàn)在刷新我們對一些基本概念的知識，例如位和字節(jié)。

Bits

位只是一個二進制數(shù)字。

二進制系統(tǒng)使用兩個數(shù)字，0和1。
類似于十進制數(shù)字系統(tǒng)，其中數(shù)字的數(shù)字不具有相同的值，位的“有效性"取決于其在二進制數(shù)中的位置。例如，十進制數(shù)666中的數(shù)字相同，但具有不同的值。

Bytes

一個字節(jié)由8位組成。

如果一個位是一個數(shù)字，邏輯上字節(jié)表示數(shù)字。
可以對它們執(zhí)行所有數(shù)學(xué)運算。
一個字節(jié)中的數(shù)字也不具有相同的含義。
最左邊的位具有被稱為最高有效位(MSB)的最大值。
最右邊的位具有最小值，因此稱為最低有效位(LSB)。
由于可以以256種不同的方式組合一個字節(jié)的八個零和一個，所以可以由一個字節(jié)表示的最大十進制數(shù)是255(一個組合表示零)。

Arduino - Interrupts

中斷停止Arduino的當前工作，以便可以做一些其他工作。

假設(shè)你坐在家里，和別人聊天。突然電話響了。您停止聊天，拿起電話與來電者通話。當你完成電話交談后，在電話鈴響之前，你回去和人聊天。

同樣，你可以認為主程序是聊天的，電話鈴聲會導(dǎo)致你停止聊天。中斷服務(wù)程序是在電話上通話的過程。當電話通話結(jié)束時，你回到你的主程序聊天。此示例準確地說明了中斷如何使處理器執(zhí)行操作。

主程序運行并在電路中執(zhí)行某些功能。但是，當發(fā)生中斷時，主程序在執(zhí)行另一個程序時停止。當該例程結(jié)束時，處理器再次返回主程序。

Important features

這里有一些關(guān)于中斷的重要功能 -

中斷可以來自各種來源。在這種情況下，我們使用的是由數(shù)字引腳上的狀態(tài)改變觸發(fā)的硬件中斷。
大多數(shù)Arduino設(shè)計有兩個硬件中斷(稱為“interrupt0"和“interrupt1")分別硬連接到數(shù)字I / O引腳2和3。
Arduino Mega有六個硬件中斷，包括引腳21,20,19和18上的附加中斷(“中斷2"到“中斷5")。
您可以使用稱為“中斷服務(wù)程序"(通常稱為ISR)的特殊函數(shù)來定義例程。
您可以定義例程并在上升沿，下降沿或兩者都指定條件。在這些特定條件下，將處理中斷。
每次在輸入引腳上發(fā)生事件時，都可以自動執(zhí)行該功能。

Types of Interrupts

有兩種類型的中斷 -

硬件中斷 - 它們響應(yīng)外部事件而發(fā)生，例如外部中斷引腳變?yōu)楦唠娖交虻碗娖健?/span>
軟件中斷 - 它們響應(yīng)于在軟件中發(fā)送的指令而發(fā)生。 “Arduino語言"支持的唯一類型的中斷是attachInterrupt()函數(shù)。

Using Interrupts in Arduino

中斷在Arduino程序中非常有用，因為它有助于解決時序問題。中斷的良好應(yīng)用是讀取旋轉(zhuǎn)編碼器或觀察用戶輸入。通常，ISR應(yīng)盡可能短且快。如果您的草圖使用多個ISR，則一次只能運行一個。其他中斷將在當前完成之后執(zhí)行，其順序取決于它們具有的優(yōu)先級。

通常，全局變量用于在ISR和主程序之間傳遞數(shù)據(jù)。要確保ISR和主程序之間共享的變量正確更新，請將它們聲明為volatile。

attachInterrupt Statement Syntax

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.

以下三個常量被預(yù)定義為有效值 -

LOW 可在引腳為低電平時觸發(fā)中斷。
CHANGE 可在引腳更改值時觸發(fā)中斷。
每當引腳從高電平變?yōu)榈碗娖綍r， FALLING 。

示例

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
}

Arduino - Communication

已經(jīng)定義了數(shù)百個通信協(xié)議來實現(xiàn)這種數(shù)據(jù)交換。每個協(xié)議可以分為兩種類型之一:并行或串行。

Parallel Communication

通過輸入/輸出端口在Arduino和外設(shè)之間進行并行連接是較短距離(最多幾米)的理想解決方案。然而，在其他情況下，當需要在兩個設(shè)備之間建立較長距離的通信時，不可能使用并行連接。并行接口同時傳輸多個位。它們通常需要數(shù)據(jù)總線 - 通過八條，十六條或更多的線路進行傳輸。數(shù)據(jù)在巨大的，崩潰的1和0的波傳輸。

Advantages and Drawbacks of Parallel Communication

并行通信肯定有其優(yōu)勢。它比串行，直接和相對容易實現(xiàn)更快。然而，它需要許多輸入/輸出(I / O)端口和線路。如果你不得不將一個項目從一個基本的Arduino Uno移動到一個Mega，你知道一個微處理器上的I / O線可能是寶貴的，很少。因此，我們更喜歡串行通信，犧牲針腳空間的潛在速度。

Serial Communication Modules

今天，大多數(shù)Arduino板都是用幾種不同的串行通信系統(tǒng)作為標準設(shè)備。

使用這些系統(tǒng)中的哪一個取決于以下因素:

How many devices the microcontroller has to exchange data with?
How fast the data exchange has to be?
What is the distance between these devices?
Is it necessary to send and receive data simultaneously?

有關(guān)串行通信的最重要的事情之一是協(xié)議，應(yīng)該嚴格遵守。它是一組規(guī)則，必須應(yīng)用這些規(guī)則，使得設(shè)備可以正確地解釋它們相互交換的數(shù)據(jù)。幸運的是，Arduino自動處理這一點，使程序員/用戶的工作減少到簡單的寫(要發(fā)送的數(shù)據(jù))和讀(接收的數(shù)據(jù))。

Types of Serial Communications

串行通信可以進一步分類為 -

同步 - 同步的設(shè)備使用相同的時鐘，它們的時序彼此同步。
異步 - 異步設(shè)備具有自己的時鐘，并由前一狀態(tài)的輸出觸發(fā)。

很容易找出設(shè)備是否同步。如果給所有連接的設(shè)備提供相同的時鐘，則它們是同步的。如果沒有時鐘線，它是異步的。

例如，UART(通用異步收發(fā)器)模塊是異步的。

異步串行協(xié)議有一些內(nèi)置的規(guī)則。這些規(guī)則只是幫助確保穩(wěn)健且無錯誤的數(shù)據(jù)傳輸?shù)臋C制。這些機制，我們得到避免外部時鐘信號，是 -

Synchronization bits
Data bits
Parity bits
Baud rate

Synchronization Bits

同步位是與每個數(shù)據(jù)包一起傳送的兩個或三個特殊位。它們是起始位和停止位。正確的名稱，這些位分別標記數(shù)據(jù)包的開始和結(jié)束。

始終只有一個起始位，但停止位的數(shù)量可以配置為一個或兩個(盡管通常保持為1)。

起始位始終由從1到0的空閑數(shù)據(jù)線指示，而停止位將通過將線保持在1處而轉(zhuǎn)換回空閑狀態(tài)。

Data Bits

每個分組中的數(shù)據(jù)量可以設(shè)置為從5到9位的任何大小。當然，標準數(shù)據(jù)大小是你的基本8位字節(jié)，但其他大小有它們的用途。 7位數(shù)據(jù)包可以比8更有效，特別是如果你只是傳輸7位ASCII字符。

Parity Bits

用戶可以選擇是否應(yīng)該有奇偶校驗位，如果是，則奇偶校驗應(yīng)該是奇數(shù)還是偶數(shù)。如果數(shù)據(jù)位中的1的數(shù)目是偶數(shù)，則奇偶校驗位為0。奇數(shù)的平等恰恰相反。

Baud Rate

術(shù)語波特率用于表示每秒傳輸?shù)奈粩?shù)[bps]。注意，它是指位，而不是字節(jié)。協(xié)議通常要求每個字節(jié)與幾個控制位一起傳輸。這意味著串行數(shù)據(jù)流中的一個字節(jié)可以包括11個比特。例如，如果波特率為300bps，則每秒可以傳輸最大37字節(jié)和最小27字節(jié)。

Arduino UART

以下代碼將使Arduino在啟動時發(fā)送hello world。

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

void loop() {

}

將Arduino草圖上傳到Arduino后，在Arduino IDE的右上部分打開串行監(jiān)視器。

在串行監(jiān)視器的頂部框中鍵入任何內(nèi)容，然后按鍵盤上的發(fā)送或輸入。這將發(fā)送一系列字節(jié)到Arduino。

以下代碼返回它作為輸入接收的任何內(nèi)容。

以下代碼將使Arduino根據(jù)提供的輸入提供輸出。

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

請注意， Serial.print 和 Serial.println 將發(fā)回實際的ASCII代碼，而 Serial.write 將返回實際的文本。有關(guān)詳細信息，請參閱ASCII代碼。

Arduino - Inter Integrated Circuit

內(nèi)部集成電路(I2C)是用于微控制器和新一代專用集成電路之間的串行數(shù)據(jù)交換的系統(tǒng)。當它們之間的距離很短(接收器和發(fā)射器通常在同一個印刷電路板上)時使用。通過兩根導(dǎo)線建立連接。一個用于數(shù)據(jù)傳輸，另一個用于同步(時鐘信號)。

如下圖所示，一個設(shè)備始終是主設(shè)備。它在通信開始之前執(zhí)行一個從芯片的尋址。以這種方式，一個微控制器可以與112個不同的設(shè)備通信。波特率通常為100 Kb / sec(標準模式)或10 Kb / sec(慢波特率模式)。最近出現(xiàn)了波特率為3.4 Mb / s的系統(tǒng)。通過I2C總線通信的器件之間的距離限制為幾米。

Board I2C Pins

I2C總線由兩個信號SCL和SDA組成。 SCL是時鐘信號，SDA是數(shù)據(jù)信號。當前總線主機總是產(chǎn)生時鐘信號。一些從設(shè)備可能迫使時鐘低時延遲主設(shè)備發(fā)送更多數(shù)據(jù)(或者在主設(shè)備嘗試將時鐘發(fā)出之前需要更多時間來準備數(shù)據(jù))。這被稱為“時鐘伸展"。

以下是不同Arduino板卡的引腳 -

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

Arduino I2C

我們有兩種模式 - 主代碼和從機代碼 - 使用I2C連接兩個Arduino板。他們是 -

Master Transmitter / Slave Receiver
Master Receiver / Slave Transmitter

Master Transmitter / Slave Receiver

讓我們現(xiàn)在看看什么是主發(fā)送器和從接收器。

Master Transmitter

以下函數(shù)用于初始化Wire庫，并將I2C總線作為主器件或從器件加入。這通常只調(diào)用一次。

Wire.begin(address) - 在我們的例子中，地址是7位從地址，因為未指定主機，它將作為主機加入總線。
Wire.beginTransmission(address) - 開始向給定地址的I2C從器件發(fā)送數(shù)據(jù)。
Wire.write(value) - 用于從主設(shè)備傳輸?shù)綇脑O(shè)備的隊列字節(jié)(在beginTransmission()和endTransmission()之間的調(diào)用)。
Wire.endTransmission() - 結(jié)束由beginTransmission()開始的對從設(shè)備的傳輸，并傳輸由wire.write()排隊的字節(jié)。

示例

#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

使用以下功能 -

Wire.begin(address) - 地址是7位從機地址。
Wire.onReceive(接收數(shù)據(jù)處理程序) - 當從設(shè)備從主設(shè)備接收數(shù)據(jù)時調(diào)用的函數(shù)。
Wire.available() - 返回可用于使用Wire.read()檢索的字節(jié)數(shù)，應(yīng)在Wire.onReceive()處理程序中調(diào)用。

示例

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

Master Receiver / Slave Transmitter

讓我們現(xiàn)在看看什么是主接收器和從發(fā)送器。

Master Receiver

主器件，被編程為請求，然后讀取從唯一尋址的從器件Arduino發(fā)送的數(shù)據(jù)字節(jié)。

使用以下功能 -

Wire.requestFrom(地址，字節(jié)數(shù)) - 由主設(shè)備用于從從設(shè)備請求字節(jié)。然后可以使用函數(shù)wire.available()和wire.read()函數(shù)檢索字節(jié)。

示例

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

Slave Transmitter

使用以下功能。

Wire.onRequest(handler) - 當主設(shè)備從此從設(shè)備請求數(shù)據(jù)時調(diào)用該函數(shù)。

示例

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

Arduino - Serial Peripheral Interface

串行外設(shè)接口(SPI)總線是用于串行通信的系統(tǒng)，其使用多達四個導(dǎo)體，通常為三個。一個導(dǎo)體用于數(shù)據(jù)接收，一個導(dǎo)體用于數(shù)據(jù)發(fā)送，一個導(dǎo)體用于同步，以及一個導(dǎo)體用于選擇與之通信的設(shè)備。它是一個全雙工連接，這意味著數(shù)據(jù)被同時發(fā)送和接收。最大波特率高于I2C通信系統(tǒng)中的波特率。

Board SPI Pins

SPI使用以下四根導(dǎo)線 -

SCK - 這是由主機驅(qū)動的串行時鐘。
MOSI - 這是主器件驅(qū)動的主輸出/從器件輸入。
MISO - 這是由主設(shè)備驅(qū)動的主輸入/從設(shè)備輸出。
SS - 這是從機選擇線。

使用以下功能。你必須包括SPI.h.

SPI.begin() - 通過將SCK，MOSI和SS設(shè)置為輸出來初始化SPI總線，將SCK和MOSI拉低，將SS拉高。
SPI.setClockDivider(divider) - 相對于系統(tǒng)時鐘設(shè)置SPI時鐘分頻器。在基于AVR的板上，可用的分頻器為2，4，8，16，32，64或128.默認設(shè)置為SPI_CLOCK_DIV4，它將SPI時鐘設(shè)置為系統(tǒng)時鐘的四分之一(5 Mhz 板在20MHz)。
分隔符 - 它可以是(SPI_CLOCK_DIV2，SPI_CLOCK_DIV4，SPI_CLOCK_DIV8，SPI_CLOCK_DIV16，SPI_CLOCK_DIV32，SPI_CLOCK_DIV64，SPI_CLOCK_DIV128)。
SPI.transfer(val) - SPI傳輸基于同時發(fā)送和接收:接收的數(shù)據(jù)在receivedVal中返回。
SPI.transfer(val) - SPI傳輸基于同時發(fā)送和接收:接收的數(shù)據(jù)在receivedVal中返回。...

我們在SPI中有四種操作模式，如下所示:

模式0(默認值) - 時鐘通常為低電平(CPOL = 0)，數(shù)據(jù)在從低電平到高電平(前沿)(CPHA = 0)的轉(zhuǎn)換時采樣。
模式1 - 時鐘通常為低電平(CPOL = 0)，并且數(shù)據(jù)在從高電平到低電平(后沿)(CPHA = 1)的轉(zhuǎn)換時采樣。
模式2 - 時鐘通常為高電平(CPOL = 1)，數(shù)據(jù)在從高電平到低電平(前沿)(CPHA = 0)的轉(zhuǎn)換時采樣。
模式3 - 時鐘通常為高電平(CPOL = 1)，數(shù)據(jù)在從低電平到高電平(后沿)(CPHA = 1)的轉(zhuǎn)換時采樣。
SPI.attachInterrupt(handler) - 當從設(shè)備從主設(shè)備接收數(shù)據(jù)時調(diào)用的函數(shù)。

現(xiàn)在，我們將兩個Arduino UNO板連接在一起; 一個作為主機，另一個作為從機。

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

地面是常見的。以下是兩個電路板之間的連接的圖解表示 -

讓我們看看SPI作為主機和SPI作為從機的例子。

SPI as MASTER

Example

#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 as SLAVE

Example

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

Arduino - Blinking LED

LED是小型，強大的燈，用于許多不同的應(yīng)用。首先，我們將工作在閃爍LED，微控制器的Hello World。它就像打開和關(guān)閉燈一樣簡單。建立這個重要的基線將為您提供堅實的基礎(chǔ)，因為我們致力于更復(fù)雜的實驗。

Components Required

您將需要以下組件 -

1 × Breadboard
1 × Arduino Uno R3
1 × LED
1 × 330Ω Resistor
2 × Jumper

Procedure

按照電路圖并連接面包板上的組件，如下圖所示。

注意 - 要了解LED的極性，請仔細查看。兩個腿中較短的，朝向燈泡的平邊緣指示負端子。

如電阻器的元件需要將其端子彎曲成90°角，以適當?shù)剡m應(yīng)面包板插座。您也可以將端子切短。

Sketch

在計算機上打開Arduino IDE軟件。在Arduino語言編碼將控制你的電路。通過單擊新建打開新的草圖文件。

Arduino Code

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

Code to Note

pinMode(2，OUTPUT) - 在使用Arduino的引腳之前，您需要告訴Arduino Uno R3它是一個INPUT還是OUTPUT。我們使用一個內(nèi)置的“函數(shù)"pinMode()來做到這一點。

digitalWrite(2，HIGH) - 當使用引腳作為OUTPUT時，可以將其命令為HIGH(輸出5伏)或LOW(輸出0伏)。

Result

你應(yīng)該看到你的LED打開和關(guān)閉。如果沒有看到所需的輸出，請確保您已正確組裝電路，并驗證并將代碼上傳到電路板。

Arduino - Fading LED

這個例子演示了在熄滅LED時使用analogWrite()函數(shù)。 AnalogWrite使用脈沖寬度調(diào)制(PWM)，以非?？焖俚卮蜷_和關(guān)閉數(shù)字引腳，開/關(guān)之間具有不同的比率，以創(chuàng)建衰減效果。

Components Required

您將需要以下組件 -

1 × Breadboard
1 × Arduino Uno R3
1 × LED
1 × 330Ω Resistor
2 × Jumper

Procedure

按照電路圖并連接面包板上的組件，如下圖所示。

注意 - 要了解LED的極性，請仔細查看。兩個腿中較短的，朝向燈泡的平邊緣指示負端子。

如電阻器的元件需要將其端子彎曲成90°角，以適當?shù)剡m應(yīng)面包板插座。您也可以將端子切短。

Sketch

在計算機上打開Arduino IDE軟件。在Arduino語言編碼將控制你的電路。通過單擊新建打開新的草圖文件。

Arduino Code

/*
   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);
}

Code to Note

在將引腳9聲明為您的LED引腳之后，在代碼的setup()函數(shù)中沒有做任何事情。您將在代碼的主循環(huán)中使用的analogWrite()函數(shù)需要兩個參數(shù):一個告訴函數(shù)哪個引腳要寫入，另一個指示寫入哪個PWM值。

為了使LED熄滅和亮起，逐漸將PWM值從0(一直關(guān)閉)逐漸增加到255(一直開啟)，然后回到0，以完成周期。在上面給出的草圖中，PWM值使用稱為亮度的變量設(shè)置。每次通過循環(huán)，它增加變量 fadeAmount 的值。

如果亮度在其值的任一極值(0或255)，則fadeAmount變?yōu)槠湄撝怠?/span> 換句話說，如果fadeAmount是5，那么它被設(shè)置為-5。如果它是-5，那么它被設(shè)置為5.下一次通過循環(huán)，這個改變也導(dǎo)致亮度改變方向。

analogWrite()可以非常快速地更改PWM值，因此草圖結(jié)束時的延遲控制淡入淡出的速度。嘗試改變延遲的值，看看它如何改變衰落效果。

Result

你應(yīng)該看到你的LED亮度逐漸變化。

Arduino - Reading Analog Voltage

此示例將向您展示如何讀取模擬引腳0上的模擬輸入。輸入從analogRead()轉(zhuǎn)換為電壓，并打印輸出到Arduino軟件(IDE)的串行監(jiān)視器。

Components Required

您將需要以下組件 -

1 × Breadboard
1 × Arduino Uno R3
1 × 5K variable resistor (potentiometer)
2 × Jumper

Procedure

按照電路圖并連接面包板上的組件，如下圖所示。

Potentiometer

電位計(或電位計)是一種簡單的機電換能器。它將來自輸入操作器的旋轉(zhuǎn)或線性運動轉(zhuǎn)換為電阻變化。這種變化是(或可以)用于控制從高保真系統(tǒng)的體積到巨大集裝箱船的方向的任何東西。

我們知道的鍋最初被稱為變阻器(本質(zhì)上是可變線繞電阻)。現(xiàn)在可用的罐的種類現(xiàn)在相當驚人，并且初學(xué)者(特別是)可能非常難以確定哪種類型適合于給定的任務(wù)。幾個不同的鍋類型，它們都可以用于相同的任務(wù)，使得工作更難。

左邊的圖像顯示鍋的標準原理圖符號。右邊的圖像是電位計。

Sketch

在計算機上打開Arduino IDE軟件。在Arduino語言編碼將控制你的電路。通過單擊新建打開一個新的草圖文件。

Arduino Code

/*
   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);
}

Code to Note

在下面給出的程序或草圖中，您在設(shè)置功能中做的第一件事是開始串行通信，以9600位/秒，在您的主板和您的計算機之間用線 -

Serial.begin(9600);

在代碼的主循環(huán)中，您需要建立一個變量來存儲來自電位器的電阻值(其范圍在0到1023之間，非常適合int數(shù)據(jù)類型)

int sensorValue = analogRead(A0);

要將值從0-1023更改為對應(yīng)于電壓的范圍，引腳正在讀取，您需要創(chuàng)建另一個變量，一個float，并做一點計算。要在0.0和5.0之間縮放數(shù)字，將5.0除以1023.0，再乘以sensorValue -

float voltage= sensorValue * (5.0 / 1023.0);

最后，您需要將此信息打印到串口窗口。你可以用最后一行代碼中的Serial.println()命令來做到這一點 -

Serial.println(voltage)

現(xiàn)在，通過單擊頂部綠色欄右側(cè)的圖標或按Ctrl + Shift + M打開Arduino IDE中的串行監(jiān)視器。

Result

你會看到一個穩(wěn)定的數(shù)字流從0.0到5.0。當您轉(zhuǎn)動電位器時，這些值會改變，對應(yīng)于引腳A0上的電壓。

Arduino - LED Bar Graph

此示例顯示如何讀取模擬引腳0處的模擬輸入，將值從analogRead()轉(zhuǎn)換為電壓，并將其輸出到Arduino軟件(IDE)的串行監(jiān)視器。

Components Required

您將需要以下組件 -

1 × Breadboard
1 × Arduino Uno R3
1 × 5k ohm variable resistor (potentiometer)
2 × Jumper
8 × LED or you can use (LED bar graph display as shown in the image below)

Procedure

按照電路圖并連接面包板上的組件，如下圖所示。

Sketch

在計算機上打開Arduino IDE軟件。在Arduino語言編碼將控制你的電路。通過單擊新建打開一個新的草圖文件。

10 Segment LED Bar Graph

這些10段條形圖LED有許多用途。具有緊湊的占地面積，簡單的連接，它們易于原型或成品。基本上，它們是容納在一起的10個單獨的藍色LED，每個具有單獨的陽極和陰極連接。

它們也有黃色，紅色和綠色的顏色。

注意 - 這些條形圖上的引腳可能與數(shù)據(jù)表中列出的內(nèi)容不同。將裝置旋轉(zhuǎn)180度將校正變化，使得銷11成為第一銷。

Arduino Code

/*
   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);
      }
   }
}

Code to Note

草圖的工作方式如下:首先，您閱讀輸入。將輸入值映射到輸出范圍，在這種情況下為十個LED。然后，您設(shè)置一個 for-loop 以迭代輸出。如果系列中的輸出數(shù)量低于映射的輸入范圍，則將其打開。如果沒有，你把它關(guān)閉。

Result

當模擬讀數(shù)的值增加時，您將看到LED逐個打開，而當讀數(shù)減少時，LED逐個關(guān)閉。

Arduino - Keyboard Logout

本示例使用鍵盤庫在您的計算機上注銷您的用戶會話，當ARDUINO UNO上的引腳2被拉到地面時。草圖在兩個或三個鍵的同時按順序模擬按鍵，并且在短暫的延遲之后，它釋放它們。

警告 - 當您使用 Keyboard.print()命令時，Arduino接管您的計算機鍵盤。為確保在使用此功能運行草圖時不會失去對計算機的控制，請在調(diào)用Keyboard.print()之前設(shè)置可靠的控制系統(tǒng)。此草圖旨在僅在引腳拉到地后發(fā)送鍵盤命令。

Components Required

您將需要以下組件 -

1 × Breadboard
1 × Arduino Leonardo, Micro, or Due board
1 × pushbutton
1 × Jumper

Procedure

按照電路圖并掛接面包板上的組件，如下圖所示。

Sketch

在計算機上打開Arduino IDE軟件。在Arduino語言編碼將控制你的電路。通過單擊新建打開一個新的草圖文件。

對于本例，您需要使用Arduino IDE 1.6.7

注意 - 您必須在Arduino庫文件中包含鍵盤庫。使用名稱庫(突出顯示)將鍵盤庫文件復(fù)制并粘貼到文件中，如以下屏幕截圖所示。

Arduino Code

/*
   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);
}

Code to Note

在將程序上傳到開發(fā)板之前，請確保將正在使用的正確操作系統(tǒng)分配給平臺變量。

在草圖運行時，按下按鈕將引腳2連接到地，板將發(fā)送注銷序列到USB連接的PC。

Result

當將引腳2連接到地時，它執(zhí)行注銷操作。

它使用以下鍵盤組合注銷 -

在 Windows 上，按CTRL-ALT-DEL，然后按ALT-l
在 Ubuntu ，CTRL-ALT-DEL和ENTER
在 OSX 上，CMD-SHIFT-q

Arduino - Keyboard Message

在此示例中，當按下按鈕時，文本字符串作為鍵盤輸入發(fā)送到計算機。字符串報告按鈕按下的次數(shù)。一旦你有了編程和接線，打開你喜歡的文本編輯器看到的結(jié)果。

警告 - 當您使用 Keyboard.print()命令時，Arduino接管您的計算機鍵盤。為確保在使用此功能運行草圖時不會失去對計算機的控制，請在調(diào)用 Keyboard.print()之前設(shè)置可靠的控制系統(tǒng)。這個草圖包括一個按鈕來切換鍵盤，以便它只在按下按鈕后運行。

Components Required

您將需要以下組件 -

1 × Breadboard
1 × Arduino Leonardo, Micro, or Due board
1 × momentary pushbutton
1 × 10k ohm resistor

Procedure

按照電路圖并連接面包板上的組件，如下圖所示。

Sketch

在計算機上打開Arduino IDE軟件。在Arduino語言編碼將控制你的電路。通過單擊新建打開一個新的草圖文件。

Arduino Code

/*
   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;
}

Code to Note

將按鈕的一個端子連接到Arduino上的引腳4。將另一個引腳連接到5V。使用電阻作為下拉電阻，通過將其從引腳4連接到地來提供對地的參考。

一旦你編寫了電路板，拔下USB電纜，打開一個文本編輯器，并將文本光標放在打字區(qū)域。通過USB再次將板連接到計算機，然后按按鈕寫入文檔。

Result

通過使用任何文本編輯器，它將顯示通過Arduino發(fā)送的文本。

Arduino - Mouse Button Control

使用鼠標庫，您可以使用Arduino Leonardo，Micro或Due來控制計算機的屏幕光標。

此特定示例使用五個按鈕來移動屏幕上的光標。四個按鈕是定向的(上，下，左，右)，一個是用于鼠標左鍵單擊。來自Arduino的光標移動總是相對的。每次讀取輸入時，相對于其當前位置更新光標的位置。

每當按下一個方向按鈕時，Arduino將移動鼠標，將HIGH輸入映射到適當方向的范圍5。

第五按鈕用于控制來自鼠標的左擊。當按鈕被釋放時，計算機將識別事件。

Components Required

您將需要以下組件 -

1 × Breadboard
1 × Arduino Leonardo, Micro or Due board
5 × 10k ohm resistor
5 × momentary pushbuttons

Procedure

按照電路圖并掛接面包板上的組件，如下圖所示。

Sketch

在計算機上打開Arduino IDE軟件。在Arduino語言編碼將控制你的電路。通過單擊新建打開一個新的草圖文件。

對于本例，您需要使用Arduino IDE 1.6.7

Arduino Code

/*
   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);
}

Code to Note

使用micro-USB電纜將電路板連接到計算機。這些按鈕連接到引腳2至6的數(shù)字輸入。確保使用10k下拉電阻。

Arduino - Keyboard Serial

此示例偵聽來自串行端口的字節(jié)。當接收到，板子發(fā)送一個擊鍵回到計算機。發(fā)送的擊鍵比接收的擊鍵高一個，因此如果從串行監(jiān)視器發(fā)送“a"，您將從連接到計算機的電路板接收到“b"。 “1"將返回“2"，依此類推。

警告 - 當您使用 Keyboard.print()命令時，Leonardo，Micro或Due板會占用計算機的鍵盤。為確保在使用此功能運行草圖時不會失去對計算機的控制，請在調(diào)用Keyboard.print()之前設(shè)置可靠的控制系統(tǒng)。該草圖旨在僅在板通過串行端口接收到一個字節(jié)后才發(fā)送一個Keyboard命令。

Components Required

您將需要以下組件 -

1 × Arduino Leonardo, Micro, or Due board

Procedure

只需使用USB電纜將電路板連接到計算機。

Sketch

在計算機上打開Arduino IDE軟件。在Arduino語言編碼將控制你的電路。通過單擊新建打開一個新的草圖文件。

注意 - 您必須在Arduino庫文件中包含鍵盤庫。將鍵盤庫文件復(fù)制并粘貼到文件中，名稱\'libraries\'以黃色突出顯示。

Arduino Code

/*
   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);
   }
}

Code to Note

一旦編程，打開你的串口監(jiān)視器并發(fā)送一個字節(jié)。板子將回復(fù)一個擊鍵，這是一個更高的數(shù)字。

Result

當你發(fā)送一個字節(jié)時，板子將以一個高于Arduino IDE串行監(jiān)視器的數(shù)字的鍵擊來回復(fù)。

Arduino - Humidity Sensor

在本節(jié)中，我們將學(xué)習(xí)如何使用不同的傳感器連接我們的Arduino板。我們將討論以下傳感器 -

Humidity sensor (DHT22)
Temperature sensor (LM35)
Water detector sensor (Simple Water Trigger)
PIR SENSOR
ULTRASONIC SENSOR
GPS

Humidity Sensor (DHT22)

DHT-22(也稱為AM2302)是一個數(shù)字輸出，相對濕度和溫度傳感器。它使用電容式濕度傳感器和熱敏電阻測量周圍空氣，并在數(shù)據(jù)引腳上發(fā)送數(shù)字信號。

在本例中，您將了解如何將此傳感器與Arduino UNO一起使用。室溫和濕度將打印到串行監(jiān)視器上。

The DHT-22 Sensor

連接很簡單。左邊的第一個引腳為3-5V電源，第二個引腳連接到數(shù)據(jù)輸入引腳，最右邊的引腳連接到地。

Technical Details

電源 - 3-5V
最大電流 - 2.5mA
濕度 - 0-100％，精確度為2-5％
溫度 - 40至80°C，精度為±0.5°C

Components Required

您將需要以下組件 -

1 × Breadboard
1 × Arduino Uno R3
1 × DHT22
1 × 10K ohm resistor

Procedure

按照電路圖并掛接面包板上的組件，如下圖所示。

Sketch

在計算機上打開Arduino IDE軟件。在Arduino語言編碼將控制你的電路。通過單擊新建打開一個新的草圖文件。

Arduino Code

// 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");
}

Code to Note

DHT22傳感器具有四個端子(V cc，DATA，NC，GND)，它們連接到電路板，如下:

DATA pin to Arduino pin number 2
V_cc pin to 5 volt of Arduino board
GND pin to the ground of Arduino board
We need to connect 10k ohm resistor (pull up resistor) between the DATA and the V_cc pin

一旦硬件連接完成，您需要添加DHT22庫到您的Arduino庫文件，如前所述。

Result

您將看到串口監(jiān)視器上的溫度和濕度顯示，每2秒更新一次。

Arduino - Temperature Sensor

溫度傳感器LM35系列是精密集成電路溫度器件，輸出電壓與攝氏溫度成線性比例。

LM35器件優(yōu)于以開爾文校準的線性溫度傳感器，因為用戶不需要從輸出中減去大的恒定電壓以獲得方便的Centigrade縮放。 LM35器件不需要任何外部校準或調(diào)整，即可在室溫下提供±1/4°C的溫度范圍，在-55°C至150°C的溫度范圍內(nèi)提供±3°C的典型精度。

Technical Specifications

Calibrated directly in Celsius (Centigrade)
Linear + 10-mV/°C scale factor
0.5°C ensured accuracy (at 25°C)
Rated for full ?55°C to 150°C range
Suitable for remote applications

Components Required

您將需要以下組件 -

1 × Breadboard
1 × Arduino Uno R3
1 × LM35 sensor

Procedure

按照電路圖并連接面包板上的組件，如下圖所示。

Sketch

在計算機上打開Arduino IDE軟件。在Arduino語言編碼將控制你的電路。通過單擊新建打開一個新的草圖文件。

Arduino Code

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
}

Code to Note

LM35傳感器具有三個端子:V sub，V out out和GND。我們將連接傳感器如下 -

Connect the +V_s to +5v on your Arduino board.
Connect V_out to Analog0 or A0 on Arduino board.
Connect GND with GND on Arduino.

模數(shù)轉(zhuǎn)換器(ADC)基于公式ADC值=樣本* 1024 /參考電壓(＆amp; plus; 5v)將模擬值轉(zhuǎn)換為數(shù)字逼近。因此，對于5伏參考，數(shù)字近似將等于輸入電壓* 205。

Result

您將看到串口監(jiān)視器上的溫度顯示，每秒更新一次。

Arduino - Water Detector / Sensor

水傳感器磚設(shè)計用于水檢測，可廣泛應(yīng)用于檢測降雨，水位，甚至液體泄漏。

將水傳感器連接到Arduino是檢測泄漏，溢出，洪水，雨水等的好方法。它可用于檢測水的存在，水位，體積和/或不存在。雖然這可以用來提醒你澆水你的植物，有一個更好的Grove傳感器。傳感器具有暴露跡線的陣列，當檢測到水時讀取LOW。

在本章中，我們將水傳感器連接到Arduino上的數(shù)字引腳8，并將使用非常方便的LED來幫助識別水傳感器何時與水源接觸。

Components Required

您將需要以下組件 -

1 × Breadboard
1 × Arduino Uno R3
1 × Water Sensor
1 × led
1 × 330 ohm resistor

Procedure

按照電路圖并連接面包板上的組件，如下圖所示。

Sketch

在計算機上打開Arduino IDE軟件。在Arduino語言編碼將控制你的電路。通過單擊新建打開一個新的草圖文件。

Arduino Code

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

Code to Note

水傳感器具有三個端子-S，V out(＆amp;正;)和GND( - )。按如下所示連接傳感器 -

Connect the +V_s to +5v on your Arduino board.
Connect S to digital pin number 8 on Arduino board.
Connect GND with GND on Arduino.
Connect LED to digital pin number 9 in Arduino board.

當傳感器檢測到水時，Arduino上的引腳8變?yōu)榈碗娖?，然后Arduino上的LED打開。

Result

當傳感器檢測到水時，指示燈將亮起。

Arduino - PIR Sensor

PIR傳感器允許您感測運動。它們用于檢測人是否移入或移出傳感器的范圍。它們通常存在于家庭或企業(yè)中使用的電器和小工具中。它們通常被稱為PIR，“被動紅外"，“熱電"或“IR運動"傳感器。

以下是PIR傳感器的優(yōu)點 -

Small in size
Wide lens range
Easy to interface
Inexpensive
Low-power
Easy to use
Do not wear out

PIR由熱電傳感器制成，圓形金屬罐在中心具有矩形晶體，其可以檢測紅外輻射的水平。一切都發(fā)射低水平的輻射，和更熱的東西，越多的輻射發(fā)射。運動檢測器中的傳感器分成兩半。這是為了檢測運動(變化)，而不是平均IR水平。兩個半部被連接，使得它們彼此抵消。如果一半看到比另一個更多或更少的紅外輻射，輸出將擺動高或低。

PIR具有可調(diào)設(shè)置，并且在3針接地/輸出/電源板中安裝了接頭。

對于許多基本項目或需要檢測一個人離開或進入該區(qū)域的產(chǎn)品，PIR傳感器是偉大的。請注意，PIR不會告訴您周圍的人數(shù)或其與傳感器的接近程度。鏡頭通常固定在一定距離的掃掠，它們有時被寵物在房子里。

Components Required

您將需要以下組件 -

1 × Breadboard
1 × Arduino Uno R3
1 × PIR Sensor (MQ3)

Procedure

按照電路圖進行連接，如下圖所示。

Sketch

在計算機上打開Arduino IDE軟件。在Arduino語言編碼將控制你的電路。通過單擊新建打開一個新的草圖文件。

Arduino Code

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

Code to Note

PIR傳感器具有三個端子:V sub，OUT和GND。按如下所示連接傳感器 -

Connect the +V_cc to +5v on Arduino board.
Connect OUT to digital pin 2 on Arduino board.
Connect GND with GND on Arduino.

您可以通過位于傳感器板底部的兩個可變電阻器來調(diào)整傳感器靈敏度和延遲時間。

一旦傳感器檢測到任何運動，Arduino將通過串行端口發(fā)送一條消息，說明檢測到運動。 PIR感測運動將延遲一定時間以檢查是否存在新運動。如果沒有檢測到運動，Arduino將發(fā)送一條新消息，說明運動已經(jīng)結(jié)束。

Result

如果檢測到運動，您將在串行端口上看到一條消息，當運動停止時，將顯示另一條消息。

Arduino - Ultrasonic Sensor

HC-SR04超聲波傳感器使用聲納來確定物體的距離，就像蝙蝠一樣。它提供了優(yōu)異的非接觸范圍檢測，具有高精度和穩(wěn)定的讀數(shù)，易于使用的包裝，從2厘米到400厘米或1“到13英尺。

該操作不受陽光或黑色材料的影響，盡管在聲學(xué)上，軟的材料如布可能難以檢測。它配有超聲波發(fā)射器和接收器模塊。

Technical Specifications

Power Supply ? +5V DC
Quiescent Current ? <2mA
Working Current ? 15mA
Effectual Angle ? <15°
Ranging Distance ? 2cm – 400 cm/1″ – 13ft
Resolution ? 0.3 cm
Measuring Angle ? 30 degree

Components Required

您將需要以下組件 -

1 × Breadboard
1 × Arduino Uno R3
1 × ULTRASONIC Sensor (HC-SR04)

Procedure

按照電路圖進行連接，如下圖所示。

Sketch

在計算機上打開Arduino IDE軟件。在Arduino語言編碼將控制你的電路。通過單擊新建打開一個新的草圖文件。

Arduino Code

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

Code to Note

在計算機上打開Arduino IDE軟件。在Arduino語言編碼將控制你的電路。通過單擊新建打開一個新的草圖文件。...

Connect the +5V pin to +5v on your Arduino board.
Connect Trigger to digital pin 7 on your Arduino board.
Connect Echo to digital pin 6 on your Arduino board.
Connect GND with GND on Arduino.

在我們的程序中，我們通過串口顯示傳感器測量的距離，單位為英寸和厘米。

Result

您將在Arduino串行監(jiān)視器上看到傳感器測量的距離，單位為英寸和厘米。

Arduino - Connecting Switch

Pushbuttons or switches connect two open terminals in a circuit. This example turns on the LED on pin 2 when you press the pushbutton switch connected to pin 8.

Pull-down Resistor

Pull-down resistors are used in electronic logic circuits to ensure that inputs to Arduino settle at expected logic levels if external devices are disconnected or are at high-impedance. As nothing is connected to an input pin, it does not mean that it is a logical zero. Pull down resistors are connected between the ground and the appropriate pin on the device.

An example of a pull-down resistor in a digital circuit is shown in the following figure. A pushbutton switch is connected between the supply voltage and a microcontroller pin. In such a circuit, when the switch is closed, the micro-controller input is at a logical high value, but when the switch is open, the pull-down resistor pulls the input voltage down to the ground (logical zero value), preventing an undefined state at the input.

The pull-down resistor must have a larger resistance than the impedance of the logic circuit, or else it might pull the voltage down too much and the input voltage at the pin would remain at a constant logical low value, regardless of the switch position.

Components Required

You will need the following components ?

1 × Arduino UNO board
1 × 330 ohm resistor
1 × 4.7K ohm resistor (pull down)
1 × LED

Procedure

Follow the circuit diagram and make the connections as shown in the image given below.

Sketch

Open the Arduino IDE software on your computer. Coding in the Arduino language will control your circuit. Open a new sketch File by clicking on New.

Arduino Code

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

Code to Note

When the switch is open, (pushbutton is not pressed), there is no connection between the two terminals of the pushbutton, so the pin is connected to the ground (through the pull-down resistor) and we read a LOW. When the switch is closed (pushbutton is pressed), it makes a connection between its two terminals, connecting the pin to 5 volts, so that we read a HIGH.

Result

LED is turned ON when the pushbutton is pressed and OFF when it is released.

Arduino - DC Motor

In this chapter, we will interface different types of motors with the Arduino board (UNO) and show you how to connect the motor and drive it from your board.

There are three different type of motors ?

DC motor
Servo motor
Stepper motor

A DC motor (Direct Current motor) is the most common type of motor. DC motors normally have just two leads, one positive and one negative. If you connect these two leads directly to a battery, the motor will rotate. If you switch the leads, the motor will rotate in the opposite direction.

Warning ? Do not drive the motor directly from Arduino board pins. This may damage the board. Use a driver Circuit or an IC.

We will divide this chapter into three parts ?

Just make your motor spin
Control motor speed
Control the direction of the spin of DC motor

Components Required

You will need the following components ?

1x Arduino UNO board
1x PN2222 Transistor
1x Small 6V DC Motor
1x 1N4001 diode
1x 270 Ω Resistor

Procedure

Follow the circuit diagram and make the connections as shown in the image given below.

Precautions

Take the following precautions while making the connections.

First, make sure that the transistor is connected in the right way. The flat side of the transistor should face the Arduino board as shown in the arrangement.
Second, the striped end of the diode should be towards the +5V power line according to the arrangement shown in the image.

Spin ControlArduino Code

int motorPin = 3;

void setup() {

}

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

Code to Note

The transistor acts like a switch, controlling the power to the motor. Arduino pin 3 is used to turn the transistor on and off and is given the name 'motorPin' in the sketch.

Result

Motor will spin in full speed when the Arduino pin number 3 goes high.

Motor Speed Control

Following is the schematic diagram of a DC motor, connected to the Arduino board.

Arduino Code

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

Code to Note

The transistor acts like a switch, controlling the power of the motor. Arduino pin 3 is used to turn the transistor on and off and is given the name 'motorPin' in the sketch.

When the program starts, it prompts you to give the values to control the speed of the motor. You need to enter a value between 0 and 255 in the Serial Monitor.

In the 'loop' function, the command 'Serial.parseInt' is used to read the number entered as text in the Serial Monitor and convert it into an 'int'. You can type any number here. The 'if' statement in the next line simply does an analog write with this number, if the number is between 0 and 255.

Result

The DC motor will spin with different speeds according to the value (0 to 250) received via the serial port.

Spin Direction Control

To control the direction of the spin of DC motor, without interchanging the leads, you can use a circuit called an H-Bridge. An H-bridge is an electronic circuit that can drive the motor in both directions. H-bridges are used in many different applications. One of the most common application is to control motors in robots. It is called an H-bridge because it uses four transistors connected in such a way that the schematic diagram looks like an "H."

We will be using the L298 H-Bridge IC here. The L298 can control the speed and direction of DC motors and stepper motors, and can control two motors simultaneously. Its current rating is 2A for each motor. At these currents, however, you will need to use heat sinks.

Components Required

You will need the following components ?

1 × L298 bridge IC
1 × DC motor
1 × Arduino UNO
1 × breadboard
10 × jumper wires

Procedure

Following is the schematic diagram of the DC motor interface to Arduino Uno board.

The above diagram shows how to connect the L298 IC to control two motors. There are three input pins for each motor, Input1 (IN1), Input2 (IN2), and Enable1 (EN1) for Motor1 and Input3, Input4, and Enable2 for Motor2.

Since we will be controlling only one motor in this example, we will connect the Arduino to IN1 (pin 5), IN2 (pin 7), and Enable1 (pin 6) of the L298 IC. Pins 5 and 7 are digital, i.e. ON or OFF inputs, while pin 6 needs a pulse-width modulated (PWM) signal to control the motor speed.

The following table shows which direction the motor will turn based on the digital values of IN1 and IN2.

IN1	IN2	Motor Behavior
		BRAKE
1		FORWARD
	1	BACKWARD
1	1	BRAKE

Pin IN1 of the IC L298 is connected to pin 8 of Arduino while IN2 is connected to pin 9. These two digital pins of Arduino control the direction of the motor. The EN A pin of IC is connected to the PWM pin 2 of Arduino. This will control the speed of the motor.

To set the values of Arduino pins 8 and 9, we have used the digitalWrite() function, and to set the value of pin 2, we have to use the analogWrite() function.

Connection Steps

Connect 5V and the ground of the IC to 5V and the ground of Arduino, respectively.
Connect the motor to pins 2 and 3 of the IC.
Connect IN1 of the IC to pin 8 of Arduino.
Connect IN2 of the IC to pin 9 of Arduino.
Connect EN1 of IC to pin 2 of Arduino.
Connect SENS A pin of IC to the ground.
Connect Arduino using Arduino USB cable and upload the program to Arduino using Arduino IDE software.
Provide power to Arduino board using power supply, battery, or USB cable.

Arduino Code

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

Result

The motor will run first in the clockwise (CW) direction for 3 seconds and then counter-clockwise (CCW) for 3 seconds.

Arduino - Servo Motor

A Servo Motor is a small device that has an output shaft. This shaft can be positioned to specific angular positions by sending the servo a coded signal. As long as the coded signal exists on the input line, the servo will maintain the angular position of the shaft. If the coded signal changes, the angular position of the shaft changes. In practice, servos are used in radio-controlled airplanes to position control surfaces like the elevators and rudders. They are also used in radio-controlled cars, puppets, and of course, robots.

Servos are extremely useful in robotics. The motors are small, have built-in control circuitry, and are extremely powerful for their size. A standard servo such as the Futaba S-148 has 42 oz/inches of torque, which is strong for its size. It also draws power proportional to the mechanical load. A lightly loaded servo, therefore, does not consume much energy.

The guts of a servo motor is shown in the following picture. You can see the control circuitry, the motor, a set of gears, and the case. You can also see the 3 wires that connect to the outside world. One is for power (+5volts), ground, and the white wire is the control wire.

Working of a Servo Motor

The servo motor has some control circuits and a potentiometer (a variable resistor, aka pot) connected to the output shaft. In the picture above, the pot can be seen on the right side of the circuit board. This pot allows the control circuitry to monitor the current angle of the servo motor.

If the shaft is at the correct angle, then the motor shuts off. If the circuit finds that the angle is not correct, it will turn the motor until it is at a desired angle. The output shaft of the servo is capable of traveling somewhere around 180 degrees. Usually, it is somewhere in the 210-degree range, however, it varies depending on the manufacturer. A normal servo is used to control an angular motion of 0 to 180 degrees. It is mechanically not capable of turning any farther due to a mechanical stop built on to the main output gear.

The power applied to the motor is proportional to the distance it needs to travel. So, if the shaft needs to turn a large distance, the motor will run at full speed. If it needs to turn only a small amount, the motor will run at a slower speed. This is called proportional control.

How Do You Communicate the Angle at Which the Servo Should Turn?

The control wire is used to communicate the angle. The angle is determined by the duration of a pulse that is applied to the control wire. This is called Pulse Coded Modulation. The servo expects to see a pulse every 20 milliseconds (.02 seconds). The length of the pulse will determine how far the motor turns. A 1.5 millisecond pulse, for example, will make the motor turn to the 90-degree position (often called as the neutral position). If the pulse is shorter than 1.5 milliseconds, then the motor will turn the shaft closer to 0 degrees. If the pulse is longer than 1.5 milliseconds, the shaft turns closer to 180 degrees.

Components Required

You will need the following components ?

1 × Arduino UNO board
1 × Servo Motor
1 × ULN2003 driving IC
1 × 10 KΩ Resistor

Procedure

Follow the circuit diagram and make the connections as shown in the image given below.

Sketch

Open the Arduino IDE software on your computer. Coding in the Arduino language will control your circuit. Open a new sketch File by clicking on New.

Arduino Code

/* 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);
}

Code to Note

Servo motors have three terminals - power, ground, and signal. The power wire is typically red, and should be connected to the 5V pin on the Arduino. The ground wire is typically black or brown and should be connected to one terminal of ULN2003 IC (10 -16). To protect your Arduino board from damage, you will need some driver IC to do that. Here we have used ULN2003 IC to drive the servo motor. The signal pin is typically yellow or orange and should be connected to Arduino pin number 9.

Connecting the Potentiometer

A voltage divider/potential divider are resistors in a series circuit that scale the output voltage to a particular ratio of the input voltage applied. Following is the circuit diagram ?

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

V_out is the output potential, which depends on the applied input voltage (V_in) and resistors (R₁ and R₂) in the series. It means that the current flowing through R₁ will also flow through R₂ without being divided. In the above equation, as the value of R₂ changes, the V_out scales accordingly with respect to the input voltage, V_in.

Typically, a potentiometer is a potential divider, which can scale the output voltage of the circuit based on the value of the variable resistor, which is scaled using the knob. It has three pins: GND, Signal, and +5V as shown in the diagram below ?

Result

By changing the pot’s NOP position, servo motor will change its angle.

Arduino - Stepper Motor

A Stepper Motor or a step motor is a brushless, synchronous motor, which divides a full rotation into a number of steps. Unlike a brushless DC motor, which rotates continuously when a fixed DC voltage is applied to it, a step motor rotates in discrete step angles.

The Stepper Motors therefore are manufactured with steps per revolution of 12, 24, 72, 144, 180, and 200, resulting in stepping angles of 30, 15, 5, 2.5, 2, and 1.8 degrees per step. The stepper motor can be controlled with or without feedback.

Imagine a motor on an RC airplane. The motor spins very fast in one direction or another. You can vary the speed with the amount of power given to the motor, but you cannot tell the propeller to stop at a specific position.

Now imagine a printer. There are lots of moving parts inside a printer, including motors. One such motor acts as the paper feed, spinning rollers that move the piece of paper as ink is being printed on it. This motor needs to be able to move the paper an exact distance to be able to print the next line of text or the next line of an image.

There is another motor attached to a threaded rod that moves the print head back and forth. Again, that threaded rod needs to be moved an exact amount to print one letter after another. This is where the stepper motors come in handy.

How a Stepper Motor Works?

A regular DC motor spins in only direction whereas a Stepper motor can spin in precise increments.

Stepper motors can turn an exact amount of degrees (or steps) as desired. This gives you total control over the motor, allowing you to move it to an exact location and hold that position. It does so by powering the coils inside the motor for very short periods of time. The disadvantage is that you have to power the motor all the time to keep it in the position that you desire.

All you need to know for now is that, to move a stepper motor, you tell it to move a certain number of steps in one direction or the other, and tell it the speed at which to step in that direction. There are numerous varieties of stepper motors. The methods described here can be used to infer how to use other motors and drivers which are not mentioned in this tutorial. However, it is always recommended that you consult the datasheets and guides of the motors and drivers specific to the models you have.

Components Required

You will need the following components ?

1 × Arduino UNO board
1 × small bipolar stepper Motor as shown in the image given below
1 × LM298 driving IC

Procedure

Follow the circuit diagram and make the connections as shown in the image given below.

Sketch

Open the Arduino IDE software on your computer. Coding in the Arduino language will control your circuit. Open a new sketch File by clicking New.

Arduino Code

/* 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);
}

Code to Note

This program drives a unipolar or bipolar stepper motor. The motor is attached to digital pins 8 - 11 of Arduino.

Result

The motor will take one revolution in one direction, then one revolution in the other direction.

Arduino - Tone Library

In this chapter, we will use the Arduino Tone Library. It is nothing but an Arduino Library, which produces square-wave of a specified frequency (and 50% duty cycle) on any Arduino pin. A duration can optionally be specified, otherwise the wave continues until the stop() function is called. The pin can be connected to a piezo buzzer or a speaker to play the tones.

Warning ? Do not connect the pin directly to any audio input. The voltage is considerably higher than the standard line level voltages, and can damage sound card inputs, etc. You can use a voltage divider to bring the voltage down.

Components Required

You will need the following components ?

1 × 8-ohm speaker
1 × 1k resistor
1 × Arduino UNO board

Procedure

Follow the circuit diagram and make the connections as shown in the image given below.

Sketch

Open the Arduino IDE software on your computer. Coding in the Arduino language will control your circuit. Open a new sketch File by clicking New.

To make the pitches.h file, either click the button just below the serial monitor icon and choose "New Tab", or use Ctrl+Shift+N.

Then paste the following code ?

/*************************************************
* 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

Save the above given code as pitches.h

Arduino Code

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

Code to Note

The code uses an extra file, pitches.h. This file contains all the pitch values for typical notes. For example, NOTE_C4 is middle C. NOTE_FS4 is F sharp, and so forth. This note table was originally written by Brett Hagman, on whose work the tone() command was based. You may find it useful whenever you want to make musical notes.

Result

You will hear musical notes saved in the pitches.h. file.

Arduino - Wireless Communication

The wireless transmitter and receiver modules work at 315 Mhz. They can easily fit into a breadboard and work well with microcontrollers to create a very simple wireless data link. With one pair of transmitter and receiver, the modules will only work communicating data one-way, however, you would need two pairs (of different frequencies) to act as a transmitter/receiver pair.

Note ? These modules are indiscriminate and receive a fair amount of noise. Both the transmitter and receiver work at common frequencies and do not have IDs.

Receiver Module Specifications

Product Model ? MX-05V
Operating voltage ? DC5V
Quiescent Current ? 4mA
Receiving frequency ? 315Mhz
Receiver sensitivity ? -105DB
Size ? 30 * 14 * 7mm

Transmitter Module Specifications

Product Model ? MX-FS-03V
Launch distance ? 20-200 meters (different voltage, different results)
Operating voltage ? 3.5-12V
Dimensions ? 19 * 19mm
Operating mode ? AM
Transfer rate ? 4KB / S
Transmitting power ? 10mW
Transmitting frequency ? 315Mhz
An external antenna ? 25cm ordinary multi-core or single-core line
Pinout from left → right ? (DATA; V_CC; GND)

Components Required

You will need the following components ?

2 × Arduino UNO board
1 × Rf link transmitter
1 × Rf link receiver

Procedure

Follow the circuit diagram and make the connections as shown in the image given below.

Sketch

Open the Arduino IDE software on your computer. Coding in the Arduino language will control your circuit. Open a new sketch File by clicking New.

Note ? You must include the keypad library in your Arduino library file. Copy and paste the VirtualWire.lib file in the libraries folder as highlighted in the screenshot given below.

Arduino Code for Transmitter

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

Code to Note

This is a simple code. First, it will send character '1' and after two seconds it will send character '0' and so on.

Arduino Code for Receiver

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

Code to Note

The LED connected to pin number 5 on the Arduino board is turned ON when character '1' is received and turned OFF when character '0' received.

Arduino - Network Communication

The CC3000 WiFi module from Texas Instruments is a small silver package, which finally brings easy-to-use, affordable WiFi functionality to your Arduino projects.

It uses SPI for communication (not UART!) so you can push data as fast as you want or as slow as you want. It has a proper interrupt system with IRQ pin so you can have asynchronous connections. It supports 802.11b/g, open/WEP/WPA/WPA2 security, TKIP & AES. A built-in TCP/IP stack with a "BSD socket" interface supports TCP and UDP in both the client and the server mode.

Components Required

You will need the following components ?

1 × Arduino Uno
1 × Adafruit CC3000 breakout board
1 × 5V relay
1 × Rectifier diode
1 × LED
1 × 220 Ohm resistor
1 × Breadboard and some jumper wires

For this project, you just need the usual Arduino IDE, the Adafruit’s CC3000 library, and the CC3000 MDNS library. We are also going to use the aREST library to send commands to the relay via WiFi.

Procedure

Follow the circuit diagram and make the connections as shown in the image given below.

The hardware configuration for this project is very easy.

Connect the IRQ pin of the CC3000 board to pin number 3 of the Arduino board.
VBAT to pin 5, and CS to pin 10.
Connect the SPI pins to Arduino board: MOSI, MISO, and CLK to pins 11, 12, and 13, respectively.
V_in is connected to Arduino 5V, and GND to GND.

Let us now connect the relay.

After placing the relay on the breadboard, you can start identifying the two important parts on your relay: the coil part which commands the relay, and the switch part where we will attach the LED.

First, connect pin number 8 of Arduino board to one pin of the coil.
Connect the other pin to the ground of Arduino board.

You also have to place the rectifier diode (anode connected to the ground pin) over the pins of the coil to protect your circuit when the relay is switching.

Connect the +5V of Arduino board to the common pin of the relay’s switch.
Finally, connect one of the other pin of the switch (usually, the one which is not connected when the relay is off) to the LED in series with the 220 Ohm resistor, and connect the other side of the LED to the ground of Arduino board.

Testing Individual Components

You can test the relay with the following sketch ?

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

Code to Note

The code is self-explanatory. You can just upload it to the board and the relay will switch states every second, and the LED will switch ON and OFF accordingly.

Adding WiFi Connectivity

Let us now control the relay wirelessly using the CC3000 WiFi chip. The software for this project is based on the TCP protocol. However, for this project, Arduino board will be running a small web server, so we can “l(fā)isten" for commands coming from the computer. We will first take care of Arduino sketch, and then we will see how to write the server-side code and create a nice interface.

First, the Arduino sketch. The goal here is to connect to your WiFi network, create a web server, check if there are incoming TCP connections, and then change the state of the relay accordingly.

Important Parts of the Code

#include <Adafruit_CC3000.h>
#include <SPI.h>
#include <CC3000_MDNS.h>
#include <Ethernet.h>
#include <aREST.h>

You need to define inside the code what is specific to your configuration, i.e. Wi-Fi name and password, and the port for TCP communications (we have used 80 here).

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

We can then create the CC3000 instance, server and aREST instance ?

// Server instance
   Adafruit_CC3000_Server restServer(LISTEN_PORT); // DNS responder instance
   MDNSResponder mdns; // Create aREST instance
   aREST rest = aREST();

In the setup() part of the sketch, we can now connect the CC3000 chip to the network ?

cc3000.connectToAP(WLAN_SSID, WLAN_PASS, WLAN_SECURITY);

How will the computer know where to send the data? One way would be to run the sketch once, then get the IP address of the CC3000 board, and modify the server code again. However, we can do better, and that is where the CC3000 MDNS library comes into play. We will assign a fixed name to our CC3000 board with this library, so we can write down this name directly into the server code.

This is done with the following piece of code ?

if (!mdns.begin("arduino", cc3000)) {
   while(1);
}

We also need to listen for incoming connections.

restServer.begin();

Next, we will code the loop() function of the sketch that will be continuously executed. We first have to update the mDNS server.

mdns.update();

The server running on Arduino board will wait for the incoming connections and handle the requests.

Adafruit_CC3000_ClientRef client = restServer.available();
rest.handle(client);

It is now quite easy to test the projects via WiFi. Make sure you updated the sketch with your own WiFi name and password, and upload the sketch to your Arduino board. Open your Arduino IDE serial monitor, and look for the IP address of your board.

Let us assume for the rest here that it is something like 192.168.1.103.

Then, simply go to your favorite web browser, and type ?

192.168.1.103/digital/8/1

You should see that your relay automatically turns ON.

Building the Relay Interface

We will now code the interface of the project. There will be two parts here: an HTML file containing the interface, and a client-side Javascript file to handle the clicks on the interface. The interface here is based on the aREST.js project, which was made to easily control WiFi devices from your computer.

Let us first see the HTML file, called interface.html. The first part consists importing all the required libraries for the interface ?

<head>
   <meta charset = utf-8 />
   <title> Relay Control </title>
   <link rel = "stylesheet" type = "text/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>

Then, we define two buttons inside the interface, one to turn the relay on, and the other to turn it off again.

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

Now, we also need a client-side Javascript file to handle the clicks on the buttons. We will also create a device that we will link to the mDNS name of our Arduino device. If you changed this in Arduino code, you will need to modify it here as well.

// Create device
var device = new Device("arduino.local");
// Button

$('#on').click(function() {
   device.digitalWrite(8, 1);
});

$('#off').click(function() {
   device.digitalWrite(8, 0);
});

The complete code for this project can be found on the GitHub repository. Go into the interface folder, and simply open the HTML file with your favorite browser. You should see something similar inside your browser ?

Try to click a button on the web interface; it should change the state of the relay nearly instantly.

If you managed to get it working, bravo! You just built a Wi-Fi-controlled light switch. Of course, you can control much more than lights with this project. Just make sure your relay supports the power required for the device you want to control, and you are good to go.

以上內(nèi)容是否對您有幫助：

寫筆記

我要補充