Arduino編程參考手冊中文版 .doc

《Arduino編程參考手冊中文版 .doc》由會員分享，可在線閱讀，更多相關(guān)《Arduino編程參考手冊中文版 .doc（93頁珍藏版）》請在裝配圖網(wǎng)上搜索。

1、Arduino編程參考手冊 程序結(jié)構(gòu) 4 控制語句 5 if 5 if...else 6 for 8 switch case 10 while 11 do...while 12 break 12 continue 13 return 14 goto 15 相關(guān)語法 16 分號 16 大括號 16 注釋 18 define 19 include 20 算術(shù)運算符 21 賦值 21 加，減，乘，除 21 取模 22 比較運算符 24 if(條件) and ==, !=, <, > (比較運算符) 24 布爾運算符 26 指針運算符 27 位運算

2、 27 位與 27 位或 28 位異或 30 位非 32 左移、右移 33 復(fù)合運算符 35 自加++ 35 自減-- 35 復(fù)合加+= 35 復(fù)合減-= 36 復(fù)合乘*= 36 復(fù)合除/= 36 復(fù)合與&= 36 復(fù)合或|= 36 變量 36 常量 36 宏定義 37 整型常量 38 浮點數(shù)常量 40 數(shù)據(jù)類型 41 void 41 boolean 42 char 43 unsigned char 43 byte 43 int 44 unsigned int 45 word 46 long 46 unsigned long 47

3、float 48 double 49 string 49 String(c++) 51 array 52 數(shù)據(jù)類型轉(zhuǎn)換 54 char() 54 byte() 54 int() 55 word() 55 long() 56 float() 56 變量作用域&修飾符 57 變量作用域 57 static (靜態(tài)變量) 58 volatile (易變變量) 60 const (不可改變變量) 61 輔助工具 62 sizeof() (sizeof運算符) 62 ASCII碼表 63 基本函數(shù) 65 數(shù)字I/O 65 pinMode() 65 digit

4、alWrite() 66 digitalRead() 67 模擬I/O 68 analogReference() 68 analogRead() 69 analogWrite() 70 高級I/O 71 shiftOut() 71 pulseIn() 72 時間 73 millis() 73 delay(ms) 73 delayMicroseconds(us) 74 數(shù)學(xué)庫 75 min() 75 max() 76 abs() 76 constrain() 76 map() 77 pow() 78 sqrt() 78 三角函數(shù) 78 sin(),co

5、s(),tan() 78 隨機數(shù) 79 randomSeed() 79 random() 79 位操作 80 設(shè)置中斷函數(shù) 81 a 81 achInterrupt() 81 detachInterrupt() 82 interrupts() 83 noInterrupts() 83 串口通訊 84 begin() 84 available() 84 read() 87 flush() 88 print() 88 println() 92 write() 92 peak() 93 serialEvent() 93 程序結(jié)構(gòu) (本節(jié)直譯自Ardui

6、no官網(wǎng)最新Reference) 在Arduino中, 標準的程序入口main函數(shù)在內(nèi)部被定義, 用戶只需要關(guān)心以下兩個函數(shù): setup() 當(dāng)Arduino板起動時setup()函數(shù)會被調(diào)用。用它來初始化變量，引腳模式，開始使用某個庫，等等。該函數(shù)在Arduino板的每次上電和復(fù)位時只運行一次。 loop() 在創(chuàng)建setup函數(shù)，該函數(shù)初始化和設(shè)置初始值，loop()函數(shù)所做事的正如其名，連續(xù)循環(huán)，允許你的程序改變狀態(tài)和響應(yīng)事件?？梢杂盟鼇韺崟r控制arduino板。 示例： int bu onPin = 3; void setup() { Seria

7、l.begin(9600); //初始化串口 pinMode(bu onPin, INPUT); //設(shè)置3號引腳為輸入模式 } void loop() { if (digitalRead(bu onPin) == HIGH) serialWrite(H); else serialWrite(L); delay(1000); } 控制語句 if if，用于與比較運算符結(jié)合使用，測試是否已達到某些條件，例如一個輸入數(shù)據(jù)在某個范圍之外。使用格式如下： if (value > 50) { // 這里加入你的代碼 }

8、 該程序測試value是否大于50。如果是，程序?qū)?zhí)行特定的動作。換句話說，如果圓括號中的語句為真，大括號中的語句就會執(zhí)行。如果不是，程序?qū)⑻^這段代碼。大括號可以被省略，如果這么做，下一行（以分號結(jié)尾）將成為唯一的條件語句。 if (x > 0) digitalWrite(LEDpin, HIGH); if (x > 0) digitalWrite(LEDpin, HIGH); if (x > 0){ digitalWrite(LEDpin, HIGH); } if (x > 0){ digitalWrite(LEDpin1, H

9、IGH); digitalWrite(LEDpin2, HIGH); } // 都是正確的 圓括號中要被計算的語句需要一個或多個操作符。 if...else 與基本的if語句相比，由于允許多個測試組合在一起，if/else可以使用更多的控制流。例如，可以測試一個模擬量輸入，如果輸入值小于500，則采取一個動作，而如果輸入值大于或等于500，則采取另一個動作。代碼看起來像是這樣： if (pinFiveInput < 500) { // 動作A } else { // 動作B

10、} else中可以進行另一個if測試，這樣多個相互獨立的測試就可以同時進行。每一個測試一個接一個地執(zhí)行直到遇到一個測試為真為止。當(dāng)發(fā)現(xiàn)一個測試條件為真時，與其關(guān)聯(lián)的代碼塊就會執(zhí)行，然后程序?qū)⑻酵暾膇f/else結(jié)構(gòu)的下一行。如果沒有一個測試被驗證為真。缺省的else語句塊，如果存在的話，將被設(shè)為默認行為，并執(zhí)行。 注意：一個else if語句塊可能有或者沒有終止else語句塊，同理。每個else if分支允許有無限多個。 if (pinFiveInput < 500) { // 執(zhí)行動作A } else if (pinFiveInput >= 1000) {

11、// 執(zhí)行動作B } else { // 執(zhí)行動作C } 另外一種表達互斥分支測試的方式，是使用switch case語句。 for for語句 描述 for語句用于重復(fù)執(zhí)行被花括號包圍的語句塊。一個增量計數(shù)器通常被用來遞增和終止循環(huán)。for語句對于任何需要重復(fù)的操作是非常有用的。常常用于與數(shù)組聯(lián)合使用以收集數(shù)據(jù)/引腳。for循環(huán)的頭部有三個部分： for (初始化部分; 條件判斷部分; 數(shù)據(jù)遞增部分) { //語句塊 。。。 } 初始化部分被第一個執(zhí)行，且只執(zhí)行一次。每次通過這個循環(huán)，條件判斷部分將被測試;如果為真，語句塊和數(shù)據(jù)遞增部分就會被執(zhí)行,然

12、后條件判斷部分就會被再次測試，當(dāng)條件測試為假時，結(jié)束循環(huán)。 示例： //使用一個PWM引腳使LED燈閃爍 int PWMpin = 10; // LED在10號引腳串聯(lián)一個470歐姆的電阻 void setup() { //這里無需設(shè)置 } void loop() { for (int i=0; i <= 255; i++){ analogWrite(PWMpin, i); delay(10); } } 編碼提示： C中的for循環(huán)比在其它計算機語言中發(fā)現(xiàn)的for循環(huán)要靈活的多，包括BASIC。三個頭元素中的

13、任何一個或全部可能被省略，盡管分號是必須的。而且初始化部分、條件判斷部分和數(shù)據(jù)遞增部分可以是任何合法的使用任意變量的C語句。且可以使用任何數(shù)據(jù)類型包括floats。這些不常用的類型用于語句段也許可以為一些罕見的編程問題提供解決方案。 例如，在遞增部分中使用一個乘法將形成對數(shù)級增長： for(int x = 2; x < 100; x = x * 1.5){ println(x); } 輸出: 2,3,4,6,9, ,19,28,42,63,94 另一個例子，在一個for循環(huán)中使一個LED燈漸漸地變亮和變暗： void loop() { int x = 1;

14、 for (int i = 0; i > -1; i = i + x){ analogWrite(PWMpin, i); if (i == 255) x = -1; // 在峰值切換方向 delay(10); } } switch case switch case 語句 就像if語句，switch...case通過允許程序員根據(jù)不同的條件指定不同的應(yīng)被執(zhí)行的代碼來控制程序流。特別地，一個switch語句對一個變量的值與case語句中指定的值進行比較。當(dāng)一個case語句被發(fā)現(xiàn)其值等于該變量的值。就會運行這

15、個case語句下的代碼。 break關(guān)鍵字將中止并跳出switch語句段，常常用于每個case語句的最后面。如果沒有break語句，switch語句將繼續(xù)執(zhí)行下面的表達式（“持續(xù)下降”）直到遇到break，或者是到達switch語句的末尾。 示例： switch (var) { case 1: //當(dāng)var等于1執(zhí)行這里 break; case 2: //當(dāng)var等于2執(zhí)行這里 break; default: // 如果沒有匹配項，將執(zhí)行此缺省段 // default

16、段是可選的 } 語法 switch (var) { case label: // statements break; case label: // statements break; default: // statements } 參數(shù) var: 與不同的case中的值進行比較的變量 label: 相應(yīng)的case的值 while while循環(huán) 描述： while循環(huán)將會連續(xù)地?zé)o限地循環(huán)，直到圓括號（）中的表達式變?yōu)榧?。被測試的變量必須被改變，否則while循環(huán)將永遠不會中止。這

17、可以是你的代碼，比如一個遞增的變量，或者是一個外部條件，比如測試一個傳感器。 語法： while(expression){ // statement(s) } 參數(shù)： expression - 一個（布爾型）C語句，被求值為真或假 示例： var = 0; while(var < 200){ // 做兩百次重復(fù)的事情 var++; } do...while do循環(huán) do循環(huán)與while循環(huán)使用相同方式工作，不同的是條件是在循環(huán)的末尾被測試的，所以do循環(huán)總是至少會運行一次。 do { // 語句塊 } while (測試

18、條件); 示例： do { delay(50); // 等待傳感器穩(wěn)定 x = readSensors(); // 檢查傳感器的值 } while (x < 100); break break用于中止do，for，或while循環(huán)，繞過正常的循環(huán)條件。它也用于中止switch語句。 示例： for (x = 0; x < 255; x ++) { digitalWrite(PWMpin, x); sens = analogRead(sensorPin); if (sens > threshold){

19、 // bail out on sensor detect x = 0; break; } delay(50); } continue continue語句跳過一個循環(huán)的當(dāng)前迭代的余下部分。（do，for，或while）。通過檢查循環(huán)測試條件它將繼續(xù)進行隨后的迭代。 示例： for (x = 0; x < 255; x ++) { if (x > 40 && x < 0){ // create jump in values continue; } dig

20、italWrite(PWMpin, x); delay(50); } return 終止一個函數(shù)，并向被調(diào)用函數(shù)并返回一個值，如果你想的話。 語法： return; return value; // both forms are valid 參數(shù)： value: 任何類型的變量或常量 示例： //一個函數(shù)，用于對一個傳感器輸入與一個閾值進行比較 int checkSensor(){ if (analogRead(0) > 400) { return 1; else{ retur

21、n 0; } } return 關(guān)鍵字對測試一段代碼很方便，不需“注釋掉”大段的可能是錯誤的代碼。 void loop(){ //在此測試代碼是個好想法 return; // 這里是功能不正常的代碼 // 這里的代碼永遠也不會執(zhí)行 } goto 在程序中轉(zhuǎn)移程序流到一個標記點 語法： label: goto label; // sends program flow to the label 提示： 在C程序中不建議使用goto，而且一些C編程書的作者主張永遠不要使用goto語句，但是明智地使用它可以簡化某些代碼。許多程序員不贊成使

22、用goto的原因是，無節(jié)制地使用goto語句很容易產(chǎn)生執(zhí)行流混亂的很難被調(diào)試程序。盡管如是說，仍然有很多使用goto語句而大大簡化編碼的實例。其中之一就是從一個很深的循環(huán)嵌套中跳出去，或者是if邏輯塊，在某人些條件下。 示例： for(byte r = 0; r < 255; r++){ for(byte g = 255; g > -1; g--){ for(byte b = 0; b < 255; b++){ if (analogRead(0) > 250){ goto bailout;} // 其它語句。

23、。。 } } } bailout: 相關(guān)語法 分號 用于一個語句的結(jié)束 示例 int a = 0; 提示 忘記在一行的末尾加一個分號將產(chǎn)生一個編譯器錯誤。該錯誤信息可能是明顯的，且會提及丟失分號，但也許不會。如果出現(xiàn)一個不可理喻的或看起來不合邏輯的錯誤，其中一個首先要做的事就是檢查分號丟失。編譯器會在前一行的附近發(fā)出抱怨。 大括號 大括號（又稱括弧或花括號）是C語言的主要組成部分。它們用在幾個不同的結(jié)構(gòu)中，大致如下，這可能會令初學(xué)者感到困惑。 一個左大括號必須有一個右大括號跟在后面。這是一個常被稱為平衡括號的條件。Arduino ID

24、E（集成開發(fā)環(huán)境）包含一個方便的特性以檢驗平衡大括號。只需選擇一個大括號，甚至直接在一個大括號后面點擊插入點，然后它的邏輯上的同伴就會高亮顯示。 目前此功能有些許錯誤，因為IDE經(jīng)常在文本中（錯誤地）發(fā)現(xiàn)一個已經(jīng)被注釋掉的大括號。 初級程序員，和從BASIC轉(zhuǎn)到C的程序員常常發(fā)現(xiàn)使用大括號令人困惑或畏縮。畢竟，用同樣的大括號在子例程（函數(shù)）中替換RETURN語句，在條件語句中替換ENDIF語句和在FOR循環(huán)中替換NEXT語句。 由于大括號的使用是如此的多樣，當(dāng)插入一個需要大括號的結(jié)構(gòu)時，直接在打出開括號之后打出閉括號是個不錯的編程實踐。然后在大括號之間插入一些回車符，接著開始插入

25、語句。你的大括號，還有你的態(tài)度，將永遠不會變得不平衡。 不平衡的大括號常常導(dǎo)致古怪的，難以理解的編譯器錯誤，有時在大型程序中很難查出。因為它們的多樣的使用，大括號對于程序的語法也是極其重要的，對一個大括號移動一行或兩行常常顯著地影響程序的意義。 大括號的主要用法 //函數(shù) void myfunction(datatype argument){ statements(s) } //循環(huán) while (boolean expression) { statement(s) } do { st

26、atement(s) } while (boolean expression); for (initialisation; termination condition; incrementing expr) { statement(s) } //條件語句 if (boolean expression) { statement(s) } else if (boolean expression) { statement(s) } else { s

27、tatement(s) } 注釋 注釋是程序中的一些行，用于讓自己或他人了解程序的工作方式。他們會被編譯器忽略，而不會輸出到控制器，所以它們不會占用Atmega芯片上的任何空間。 注釋唯一的目的是幫助你理解（或記憶）你的程序是怎樣工作的，或者是告知其他人你的程序是怎樣工作的。標記一行為注釋只有兩種方式： 示例 x = 5; //這是一個單行注釋。此斜線后的任何內(nèi)容都是注釋 //直到該行的結(jié)尾 /* 這是多行注釋 - 用它來注釋掉整個代碼塊 if (gwb == 0){ //在多行注釋中使用單行注釋是沒有問題的 x =

28、3; /* 但是其中不可以使用另一個多行注釋 - 這是不合法的 */ } //別忘了加上“關(guān)閉”注釋符 - 它們必須是平衡的 */ 提示 當(dāng)實驗代碼時，“注釋掉”你的程序的一部分來移除可能是錯誤的行是一種方便的方法。這不是把這些行從程序中移除，而是把它們放到注釋中，所以編譯器就會忽略它們。這在定位問題時，或者當(dāng)程序無法編譯通過且編譯錯誤信息很古怪或沒有幫助時特別有用。 define #define 宏定義 宏定義是一個有用的C組件，它允許程序員在程序編譯前給常量取一個名字。在arduino中定義的常量不會在芯片中占用任何程序空間。編譯器在編譯

29、時會將這些常量引用替換為定義的值。 這雖然可能有些有害的副作用，舉例來說，一個已被定義的常量名被包含在一些其它的常量或變量名中。那樣的話該文本將被替換成被定義的數(shù)字（或文本）。 通常，用const關(guān)鍵字定義常量是更受歡迎的且用來代替#define會很有用。 Arduino宏定義與C宏定義有同樣的語法 語法 #define constantName value 注意‘#’是必須的 示例： #define ledPin 3 // 編譯器在編譯時會將任何提及l(fā)edPin的地方替換成數(shù)值3。 提示 #define語句的后面分號。如果你加了一個，編譯器將會在進

30、一步的頁面引發(fā)奇怪的錯誤。 #define ledPin 3; // this is an error 類似地，包含一個等號通常也會在進一步的頁面引發(fā)奇怪的編譯錯誤。 #define ledPin = 3 // this is also an error include #include 包含 #include用于在你的sketch中包含外部的庫。這使程序員可以訪問一個巨大的標準C庫（預(yù)定義函數(shù)集合）的集合。 AVR C庫（AVR是Atmel芯片的一個基準，Arduino正是基于它）的主參考手冊頁在這里。 注意#include和#define相似，沒有分號

31、終止符，且如果你加了，編譯器會產(chǎn)生奇怪的錯誤信息。 示例 該示例包含一個用于輸出數(shù)據(jù)到程序空間閃存的庫，而不是內(nèi)存。這會為動態(tài)內(nèi)存需求節(jié)省存儲空間且使需要創(chuàng)建巨大的查找表變得更實際。 #include prog_uin 6_t myConstants[] PROGMEM = {0, 40, 702 , 9 8, 0, 25764, 8456, 0,0,0,0,0,0,0,0,29810,8968,29762,29762,4500}; 算術(shù)運算符 賦值 =賦值運算符（單個等號） 把等號右邊的值存儲到等號左邊的變量中。 在C語言

32、中單個等號被稱為賦值運算符。它與在代數(shù)課中的意義不同，后者象征等式或相等。賦值運算符告訴微控制器求值等號右邊的變量或表達式，然后把結(jié)果存入等號左邊的變量中。 示例 int sensVal; //聲明一個名為sensVal的整型變量 senVal = analogRead(0); //存儲（數(shù)字的）0號模擬引腳的輸入電壓值到sensVal 編程技巧 賦值運算符（=號）左邊的變量需要能夠保存存儲在其中的值。如果它不足以大到容納一個值，那個存儲在該變量中的值將是錯誤的。 不要混淆賦值運算符[ = ]（單個等號）和比較

33、運算符[ == ]（雙等號），后者求值兩個表達式是否相等。 加，減，乘，除 描述 這些運算符（分別）返回兩人運算對象的和，差，積，商。這些操作受運算對象的數(shù)據(jù)類型的影響。所以，例如，9 / 4結(jié)果是2，如果9和2是整型數(shù)。這也意味著運算會溢出，如果結(jié)果超出其在相應(yīng)的數(shù)據(jù)類型下所能表示的數(shù)。（例如，給整型數(shù)值 767加1結(jié)果是- 768）。如果運算對象是不同的類型，會用那個較大的類型進行計算。 如果其中一個數(shù)字（運算符）是float類型或double類型，將采用浮點數(shù)進行計算。 示例 y = y + 3; x = x - 7; i = j * 6; r = r / 5;

34、 語法 result = value1 + value2; result = value1 - value2; result = value1 * value2; result = value1 / value2; 參數(shù)： value1:任何變量或常量 value2:任何變量或常量 編程技巧： 要知道整型常量默認為int型，因此一些常量計算可能會溢出（例如：60 * 1000將產(chǎn)生負的結(jié)果） 選擇一個大小足夠大的變量以容納你的最大的計算結(jié)果。 要知道你的變量在哪一點將會“翻轉(zhuǎn)”且要知道在另一個方向上會發(fā)生什么，例如：（0 - 1）或（0 - 768）。 對

35、于數(shù)學(xué)需要分數(shù)，就使用浮點變量，但是要注意它們的缺點：占用空間大，計算速度慢。 使用強制類型轉(zhuǎn)換符例如：（int)myFloat以在運行中轉(zhuǎn)換一個變量到另一個類型。 取模 %（取模） 描述 計算一個數(shù)除以另一個數(shù)的余數(shù)。這對于保持一個變量在一個特定的范圍很有用（例如：數(shù)組的大?。?。 語法 result = dividend % divisor 參數(shù) dividend: 被除數(shù) divisor: 除數(shù) 結(jié)果：余數(shù) 示例 x = 7 % 5; // x now contains 2 x = 9 % 5; // x now contain

36、s 4 x = 5 % 5; // x now contains 0 x = 4 % 5; // x now contains 4 示例代碼 /* update one value in an array each time through a loop */ int values[10]; int i = 0; void setup() {} void loop() { values[i] = analogRead(0); i = (i + 1) % 10; // modulo operator rolls over variabl

37、e } 提示： 取模運算符不能用于浮點型數(shù)。 比較運算符 if(條件) and ==, !=, <, > (比較運算符) if，用于和比較運算符聯(lián)合使用，測試某一條件是否到達，例如一個輸入超出某一數(shù)值。if條件測試的格式： if (someVariable > 50) { // do something here } 該程序測試someVariable是否大于50。如果是， 程序執(zhí)行特定的動作。換句話說，如果圓括號中的語句為真，花括號中的語句就會運行。否則，程序跳過該代碼。 if語句后的花括號可能被省略。如果這么做了，下一行（由分號定義的行）就會

38、變成唯一的條件語句。 if (x > 0) digitalWrite(LEDpin, HIGH); if (x > 0) digitalWrite(LEDpin, HIGH); if (x > 0){ digitalWrite(LEDpin, HIGH); } if (x > 0){ digitalWrite(LEDpin1, HIGH); digitalWrite(LEDpin2, HIGH); } // all are correct 圓括號中被求值的語句需要

39、使用一個或多個運算符： 比較運算符： x == y (x is equal to y) x != y (x is not equal to y) x < y (x is less than y) x > y (x is greater than y) x <= y (x is less than or equal to y) x >= y (x is greater than or equal to y) 警告： 小心偶然地使用單個等號（例如if(x = 10)）。單個等號是賦值運算符，這里設(shè)置x為10（將值10存入變量x）。改用雙等號（例如i

40、f (x == 10)）,這個是比較運算符，用于測試x是否等于10。后者只在x等于10時返回真，但是前者將總是為真。 這是因為C如下求值語句if(x=10)：10分配給x（切記單個等號是賦值運算符），因此x現(xiàn)在為10。然后if條件求值10，其總是為真，由于任何非零數(shù)值都為真值。由此，if (x = 10)將總是求值為真，這不是使用if語句所期望的結(jié)果。另外，變量x將被設(shè)置為10，這也不是期望的操作。 if也可以是使用[if...else]的分支控制結(jié)構(gòu)的一部分。 布爾運算符 它們可用于if語句中的條件 && （邏輯與） 只有在兩個操作數(shù)都為真時才返回真，例如： if (digit

41、alRead(2) == HIGH && digitalRead(3) == HIGH) { // read two switches // ... } 只在兩個輸入都為高時返回真 || （邏輯或） 任意一個為真時返回真，例如： if (x > 0 || y > 0) { // ... } x或y任意一個大于0時返回真 ! （非） 當(dāng)操作數(shù)為假時返回真，例如： if (!x) { // ... } 若x為假返回真（即如果x等于0） 警告 確保你沒有把布爾與運算符，&&（兩個與符號）錯認為按位與運算符&（單個與符號）。

42、它們是完全不同的概念。 同樣，不要混淆布爾或運算符||（雙豎杠）與按位或運算符|（單豎杠）。 按位取反~（波浪號）看起來與布爾非!有很大不同（感嘆號或程序員口中的“棒”），但是你仍然必須確保在什么地方用哪一個。 例如 if (a >= 10 && a <= 20){} // true if a is between 10 and 20 指針運算符 &（引用）和 *（間接引用） 指針對于Ｃ初學(xué)者來說是更復(fù)雜的對象之一。并且可能寫大量的Arduino程序甚至都不會遇到指針。 無論如何，巧妙地控制特定的數(shù)據(jù)結(jié)構(gòu)，使用指針可以簡化代碼，而且在自己工具箱中擁有熟練控制指針的知識

43、是很方便的。 位運算 位與 按位與（&） 按位操作符在變量的位級執(zhí)行運算。它們幫助解決各種常見的編程問題。以下大部分資料來自一個有關(guān)位數(shù)學(xué)的優(yōu)秀教程，或許可以在這里找到。[1] 描述和語法 以下是所有這些運算符的描述和語法。更詳細的資料或許可以在參考指南中找到。 按位與（&） 在C++中按位與運算符是單個與符號， 用于其它兩個整型表達式之間使用。按位與運算獨立地在周圍的表達式的每一位上執(zhí)行操作。根據(jù)這一規(guī)則：如果兩個輸入位都是1，結(jié)果輸出1，否則輸出0。表達這一思想的另一個方法是： 0 0 1 1 operand1 0 1 0

44、 1 operand2 ---------- 0 0 0 1 (operand1 & operand2) - returned result 在Arduino中，int型是16位的。所以在兩個整型表達式之間使用&將會導(dǎo)致16個與運算同時發(fā)生。代碼片斷就像這樣： int a = 92; // in binary: 00000000010 00 int b = 101; // in binary: 000000000 00101 int c = a & b; // result: 000000

45、0001000100, or 68 in decimal. 在a和b的16位的每一位將使用按位與處理。且所有16位結(jié)果存入C中，以二進制存入的結(jié)果值01000100，即十進制的68。 按位與的其中一個最常用的用途是從一個整型數(shù)中選擇特定的位，常被稱為掩碼屏蔽?？慈缦率纠? 位或 按位或（|） 在C++中按位或運算符是垂直的條桿符號，|。就像&運算符，|獨立地計算它周圍的兩個整型表達式的每一位。（當(dāng)然）它所做的是不同的（操作)。兩個輸入位其中一個或都是1按位或?qū)⒌玫?，否則為0。換句話說： 0 0 1 1 operand1 0 1 0

46、1 operand2 ---------- 0 1 1 1 (operand1 | operand2) - returned result 這是一個使用一小斷C++代碼描述的按位或（運算）的例子： int a = 92; // in binary: 00000000010 00 int b = 101; // in binary: 000000000 00101 int c = a | b; // result: 000000000 01, or 5 in decimal.

47、 按位與和按位或的一個共同的工作是在端口上進行程序員稱之為讀-改-寫的操作。在微控制器中，每個端口是一個8位數(shù)字，每一位表示一個引腳的狀態(tài)。寫一個端口可以同時控制所有的引腳。 PORTD是內(nèi)建的參照數(shù)字口0，1，2，3，4，5，6，7的輸出狀態(tài)的常量。如果一個比特位是1，那么該引腳置高。（引腳總是需要用pinMode()指令設(shè)置為輸出模式）。所以如果我們寫入PORTD = B00 0001；我們就會讓引腳2，3和7輸出高。一個小小的問題是，我們同時也改變了某些引腳的0，1狀態(tài)。這用于Arduino與串口通訊，所以我們可能會干擾串口通訊。 我們的程序規(guī)則是： 僅僅獲取和清除我們想

48、控制的與相應(yīng)引腳對應(yīng)的位（使用按位與）。 合并要修改的PORTD值與所控制的引腳的新值（使用按位或）。 int i; // counter variable int j; void setup(){ DDRD = DDRD | B 00; // set direction bits for pins 2 to 7, leave 0 and 1 untouched (xx | 00 == xx) // same as pinMode(pin, OUTPUT) for pins 2 to 7 Serial.begin(9600); } void loop(){

49、 for (i=0; i<64; i++){ PORTD = PORTD & B000000 ; // clear out bits 2 - 7, leave pins 0 and 1 untouched (xx & == xx) j = (i << 2); // shift variable up to pins 2 - 7 - to avoid pins 0 and 1 PORTD = PORTD | j; // combine the port information with the new information fo

50、r LED pins Serial.println(PORTD, BIN); // debug to show masking delay(100); } } 位異或 按位異或（^） 在C++中有一個有點不尋常的操作，它被稱為按位異或，或者XOR（在英語中，通常讀作“eks-or”）。按位異或運算符使用符號^。該運算符與按位或運算符“|”非常相似 ,唯一的不同是當(dāng)輸入位都為1時它返回0。 0 0 1 1 operand1 0 1 0 1 operand2 ---------- 0 1 1 0 (

51、operand1 ^ operand2) - returned result 看待XOR的另一個視角是，當(dāng)輸入不同時結(jié)果為1，當(dāng)輸入相同時結(jié)果為0。 這里是一個簡單的示例代碼： int x = ; // binary: 00 int y = 10; // binary: 1010 int z = x ^ y; // binary: 0 0, or decimal 6 “^”運算符常用于翻轉(zhuǎn)整數(shù)表達式的某些位（例如從0變?yōu)?，或從1變?yōu)?）。在一個按位異或操作中，如果相應(yīng)的掩碼位為1， 該位將翻轉(zhuǎn)，如果為0

52、，該位不變。以下是一個閃爍引腳5的程序. // Blink_Pin_5 // demo for Exclusive OR void setup(){ DDRD = DDRD | B00100000; // set digital pin five as OUTPUT Serial.begin(9600); } void loop(){ PORTD = PORTD ^ B00100000; // invert bit 5 (digital pin 5), leave others untouched delay(100); } 位非 按位取反（~） 在C++中按

53、位取反運算符為波浪符“~”。不像“&”和“|”，按位取反運算符應(yīng)用于其右側(cè)的單個操作數(shù)。按位取反操作會翻轉(zhuǎn)其每一位。0變?yōu)?，1變?yōu)?。例如： 0 1 operand1 ---------- 1 0 ~ operand1 int a = 103; // binary: 000000000 00 int b = ~a; // binary: 00 000 = -104 看到此操作的結(jié)果為一個負數(shù)：-104，你可能會感到驚訝，這是因為一個整型變量的最高位是所謂的符號位。如果最高位為1，

54、該整數(shù)被解釋為負數(shù)。這里正數(shù)和負數(shù)的編碼被稱為二進制補碼。欲了解更多信息，請參閱維基百科條目：補碼。 順便說一句，值得注意的是，對于任何整數(shù)x， ~x 與 -x-1 相等。 有時候，符號位在有符號整數(shù)表達式中能引起一些不期的意外。 左移、右移 左移運算（<<），右移運算（>>） 描述 From The Bitmath Tutorial in The Playground 在C++中有兩個移位運算符：左移運算符<<和右移運算符>>。這些運算符將使左邊操作數(shù)的每一位左移或右移其右邊指定的位數(shù)。 語法 variable << number_of_bits v

55、ariable >> number_of_bits 參數(shù)
*variable - (byte, int, long) number_of_bits integer <=
示例：

    int a = 5;        // binary: 0000000000000101
    int b = a << 3;   // binary: 0000000000101000, or 40 in decimal
    int c = b >> 3;   // binar
 
                                
56、y: 0000000000000101, or back to 5 like we started with


當(dāng)把x左移y位（x << y），x中最左邊的y位將會丟失。
   int a = 5;        // binary: 0000000000000101
    int b = a << 14;  // binary: 0100000000000000 - 101中的第一個1被丟棄

如果您確信沒有值被移出，理解左移位運算符一個簡單的辦法是，把它的左操作數(shù)乘2將提高其冪值。例如，要生成2的乘方，可以使用以下表達式：
    1 <<  0  ==    1
 
 
                                
57、   1 <<  1  ==    2
    1 <<  2  ==    4
    1 <<  3  ==    8
    ...
    1 <<  8  ==  256
    1 <<  9  ==  5

    1 << 10  == 1024
    ...
 

當(dāng)把x右移y位，x的最高位為1，該行為依賴于x的確切的數(shù)據(jù)類型。如果x的類型是int，最高位為符號位，決定x是不是負數(shù)，正如我們在上面已經(jīng)討論過的。在這種情況下，符號位會復(fù)制到較低的位：
  int x = -16;     // binary: 
0000
    int y = x
 
                                
58、 >> 3;  // binary: 
0

該行為，被稱為符號擴展，常常不是你所期待的。反而，你可能希望移入左邊的是0。事實上右移規(guī)則對于無符合整型表達式是不同的。所以你可以使用強制類型轉(zhuǎn)換來避免左邊移入1。
  int x = -16;                   // binary: 
0000
    int y = (unsigned int)x >> 3;  // binary: 000
0
 

如果你可以很小心地避免符號擴展，你可以使用右移位運算符>>，作為除以2的冪的一種方法。例如
   int x = 1000;
    int y = x 
 
                                
59、>> 3;   // 1000除以8，得y = 
5.
復(fù)合運算符
自加++
i++; //相當(dāng)于 i = i + 1;
自減--
i--; //相當(dāng)于 i = i - 1;
復(fù)合加+=
i+=5; //相當(dāng)于 i = i + 5;
復(fù)合減-=
i-=5; //相當(dāng)于 i = i - 5;
復(fù)合乘*=
i*=5; //相當(dāng)于 i = i * 5;
復(fù)合除/=
i/=5; //相當(dāng)于 i = i / 5;
復(fù)合與&=
i&=5; //相當(dāng)于 i = i & 5;
復(fù)合或|=
i|=5; //相當(dāng)于 i = i | 5;
變量
常量
constants是在
 
                                
60、Arduino語言里預(yù)定義的變量。它們被用來使程序更易閱讀。我們按組將常量分類。
邏輯層定義，true與false（布爾Boolean常量）
在Arduino內(nèi)有兩個常量用來表示真和假：true和 false。
false
在這兩個常量中false更容易被定義。false被定義為0（零）。
true
true通常被定義為1，這是正確的，但true具有更廣泛的定義。在布爾含義（Boolean sense）里任何 非零 整數(shù) 為true。所以在布爾含義內(nèi)-1，2和-200都定義為ture。 需要注意的是true和false常量，不同于HIGH，LOW，INPUT和OUTPUT，需要全部
 
                                
61、小寫。
——這里引申一下題外話arduino是大小寫敏感語言（case sensitive）。
引腳電壓定義，HIGH和LOW
當(dāng)讀?。╮ead）或?qū)懭耄╳rite）數(shù)字引腳時只有兩個可能的值： HIGH 和 LOW 。
HIGH
HIGH（參考引腳）的含義取決于引腳（pin）的設(shè)置，引腳定義為INPUT或OUTPUT時含義有所不同。當(dāng)一個引腳通過pinMode被設(shè)置為INPUT，并通過digitalRead讀?。╮ead）時。如果當(dāng)前引腳的電壓大于等于3V，微控制器將會返回為HIGH。 引腳也可以通過pinMode被設(shè)置為INPUT，并通過digitalWrite設(shè)置為HIGH。輸
 
                                
62、入引腳的值將被一個內(nèi)在的20K上拉電阻 控制 在HIGH上，除非一個外部電路將其拉低到LOW。 當(dāng)一個引腳通過pinMode被設(shè)置為OUTPUT，并digitalWrite設(shè)置為HIGH時，引腳的電壓應(yīng)在5V。在這種狀態(tài)下，它可以 輸出電流 。例如，點亮一個通過一串電阻接地或設(shè)置為LOW的OUTPUT屬性引腳的LED。
LOW
LOW的含義同樣取決于引腳設(shè)置，引腳定義為INPUT或OUTPUT時含義有所不同。當(dāng)一個引腳通過pinMode配置為INPUT，通過digitalRead設(shè)置為讀?。╮ead）時，如果當(dāng)前引腳的電壓小于等于2V，微控制器將返回為LOW。 當(dāng)一個引腳通過pinMode
 
                                
63、配置為OUTPUT，并通過digitalWrite設(shè)置為LOW時，引腳為0V。在這種狀態(tài)下，它可以 倒灌 電流。例如，點亮一個通過串聯(lián)電阻連接到+5V，或到另一個引腳配置為OUTPUT、HIGH的的LED。
數(shù)字引腳（Digital pins）定義，INPUT和OUTPUT
數(shù)字引腳當(dāng)作 INPUT 或 OUTPUT都可以 。用pinMode()方法使一個數(shù)字引腳從INPUT到OUTPUT變化。
引腳（Pins）配置為輸入（Inputs）
Arduino（Atmega）引腳通過pinMode()配置為 輸入（INPUT） 即是將其配置在一個高阻抗的狀態(tài)。配置為INPUT的引腳可以理解為
 
                                
64、引腳取樣時對電路有極小的需求，即等效于在引腳前串聯(lián)一個100兆歐姆(Megohms)的電阻。這使得它們非常利于讀取傳感器，而不是為LED供電。
引腳（Pins）配置為輸出（Outputs）
引腳通過pinMode()配置為 輸出（OUTPUT） 即是將其配置在一個低阻抗的狀態(tài)。
這意味著它們可以為電路提供充足的電流。Atmega引腳可以向其他設(shè)備/電路提供（提供正電流positive current）或倒灌（提供負電流negative current）達40毫安（mA）的電流。這使得它們利于給LED供電，而不是讀取傳感器。輸出（OUTPUT）引腳被短路的接地或5V電路上會受到損壞甚至燒毀
 
                                
65、。Atmega引腳在為繼電器或電機供電時，由于電流不足，將需要一些外接電路來實現(xiàn)供電。
宏定義
#define  HIGH   0x1
            高電平
#define     LOW   0x0
            低電平
#define     INPUT   0x0
            輸入
#define     OUTPUT   0x1
            輸出
#define     true   0x1
            真
#define     false   0x0
            假
#define   
 
                                
66、  PI   3.14159265
            PI.
#define     HALF_PI   1.57079
            二分之一PI
#define     TWO_PI   6.28
85
            二倍PI
#define     DEG_TO_RAD   0.01745
9
            弧度轉(zhuǎn)角度
#define     RAD_TO_DEG   57.2957786
            角度轉(zhuǎn)弧度
整型常量
整數(shù)常量
整數(shù)常量是直接在程序中使用的數(shù)字，如
。默認情況下，這些數(shù)字被視為int，但你可以通過U和L修飾符進行更多的限制（見下文）。 通常情況下，整數(shù)常量默認為十進制，但可以加上特殊前綴表示為其他進制。
進制           例子      格式      備注
10（十進制）     
         無   
2（二進制）  B
0
    前綴B   只適用于8位的值（0到255）字符0-1有效
8（八進制）  0173        前綴