bool b1=0；//布爾值，只有0和1，使用“！” 取反操作
byte be；//一個字節存儲8位無符號數，范圍0-255
int i; //整數，占用兩個字節，整數范圍-32767~+32767
long a；//長整型，占四個字節，范圍-2147483647~2147483647
float b;//浮點類型，
char c='A';
String d="hello world";//字符串
unsigned int e；//無符號整型，范圍0-65535
unsigned long f；//無符號長整型，范圍0-4294967295
const int g=1；//表示為常量整數，常亮定義后，不能對他的值進行更改。
Arduino 語法手冊
http://wiki.geek-workshop.com/doku.php?id=arduino:arduino_language_reference
變量部分
常量constants
HIGH|LOW
INPUT|OUTPUT
true | false
constants是在Arduino語言里預定義的變量。它們被用來使程序更易閱讀。我們按組將常量分類。
邏輯層定義，true與false（布爾Boolean常量）
在Arduino內有兩個常量用來表示真和假：true和 false。
false
在這兩個常量中false更容易被定義。false被定義為0（零）。
true
true通常被定義為1，這是正確的，但true具有更廣泛的定義。在布爾含義（Boolean sense）里任何 非零 整數 為true。所以在布爾含義內-1，2和-200都定義為ture。
需要注意的是true和false常量，不同於HIGH，LOW，INPUT和OUTPUT，需要全部小寫。
——這里引申一下題外話arduino是大小寫敏感語言（case sensitive）。
引腳電壓定義，HIGH和LOW
當讀取（read）或寫入（write）數字引腳時只有兩個可能的值： HIGH 和 LOW 。
HIGH
HIGH（參考引腳）的含義取決於引腳（pin）的設置，引腳定義為INPUT或OUTPUT時含義有所不同。
當一個引腳通過pinMode被設置為INPUT，並通過digitalRead讀取（read）時。如果當前引腳的電壓大於等於3V，微控制器將會返回為HIGH。引腳也可以通過pinMode被設置為INPUT，並通過digitalWrite設置為HIGH。輸入引腳的值將被一個內在的20K上拉電阻 控制 在HIGH上，除非一個外部電路將其拉低到LOW。當一個引腳通過pinMode被設置為OUTPUT，並digitalWrite設置為HIGH時，引腳的電壓應在5V。在這種狀態下，它可以 輸出電流 。例如，點亮一個通過一串電阻接地或設置為LOW的OUTPUT屬性引腳的LED。
LOW
LOW的含義同樣取決於引腳設置，引腳定義為INPUT或OUTPUT時含義有所不同。當一個引腳通過pinMode配置為INPUT，通過digitalRead設置為讀取（read）時，如果當前引腳的電壓小於等於2V，微控制器將返回為LOW。當一個引腳通過pinMode配置為OUTPUT，並通過digitalWrite設置為LOW時，引腳為0V。在這種狀態下，它可以 倒灌 電流。例如，點亮一個通過串聯電阻連接到+5V，或到另一個引腳配置為OUTPUT、HIGH的的LED。
數字引腳（Digital pins）定義，INPUT和OUTPUT
數字引腳當作 INPUT 或 OUTPUT都可以 。用pinMode()方法使一個數字引腳從INPUT到OUTPUT變化。
引腳（Pins）配置為輸入（Inputs）
Arduino（Atmega）引腳通過pinMode()配置為 輸入（INPUT） 即是將其配置在一個高阻抗的狀態。配置為INPUT的引腳可以理解為引腳取樣時對電路有極小的需求，即等效於在引腳前串聯一個100兆歐姆(Megohms)的電阻。這使得它們非常利於讀取傳感器，而不是為LED供電。
引腳（Pins）配置為輸出（Outputs）
引腳通過pinMode()配置為 輸出（OUTPUT） 即是將其配置在一個低阻抗的狀態。
這意味着它們可以為電路提供充足的電流。Atmega引腳可以向其他設備/電路提供（提供正電流positive current）或倒灌（提供負電流negative current）達40毫安（mA）的電流。這使得它們利於給LED供電，而不是讀取傳感器。輸出（OUTPUT）引腳被短路的接地或5V電路上會受到損壞甚至燒毀。Atmega引腳在為繼電器或電機供電時，由於電流不足，將需要一些外接電路來實現供電。
integer constants
整數常量
整數常量是直接在程序中使用的數字，如123。默認情況下，這些數字被視為int，但你可以通過U和L修飾符進行更多的限制（見下文）。通常情況下，整數常量默認為十進制，但可以加上特殊前綴表示為其他進制。
| 進制 |
例子 |
格式 |
備注 |
| 10（十進制） |
123 |
無 |
|
| 2（二進制） |
B1111011 |
前綴'B' |
只適用於8位的值（0到255）字符0-1有效 |
| 8（八進制） |
0173 |
前綴”0” |
字符0-7有效 |
| 16（十六進制） |
0x7B |
前綴”0x” |
字符0-9，A-F，A-F有效 |
小數是十進制數。這是數學常識。如果一個數沒有特定的前綴，則默認為十進制。
二進制以2為基底，只有數字0和1是有效的。
示例:
101 //和十進制5等價 （1*2^2 + 0*2^1 + 1*2^0）
二進制格式只能是8位的，即只能表示0-255之間的數。如果輸入二進制數更方便的話，你可以用以下的方式：
myInt = (B11001100 * 256) + B10101010; // B11001100 作為高位。
八進制是以8為基底，只有0-7是有效的字符。前綴“0”（數字0）表示該值為八進制。
0101 // 等同於十進制數65 ((1 * 8^2) + (0 * 8^1) + 1)
警告:八進制數0前綴很可能無意產生很難發現的錯誤，因為你可能不小心在常量前加了個“0”，結果就悲劇了。
十六進制以16為基底，有效的字符為0-9和A-F。十六進制數用前綴“0x”（數字0，字母愛克斯）表示。請注意，A-F不區分大小寫，就是說你也可以用a-f。
示例:
0x101 // 等同於十進制257 ((1 * 16^2) + (0 * 16^1) + 1)
U & L 格式
默認情況下，整型常量被視作int型。要將整型常量轉換為其他類型時，請遵循以下規則：
'u' or 'U' 指定一個常量為無符號型。（只能表示正數和0） 例如: 33u
'l' or 'L' 指定一個常量為長整型。（表示數的范圍更廣） 例如: 100000L
'ul' or 'UL' 這個你懂的，就是上面兩種類型，稱作無符號長整型。 例如：32767ul
floating point constants
浮點常量
和整型常量類似，浮點常量可以使得代碼更具可讀性。浮點常量在編譯時被轉換為其表達式所取的值。
例子
n = .005; 浮點數可以用科學記數法表示。'E'和'e'都可以作為有效的指數標志。
| 浮點數 |
被轉換為 |
被轉換為 |
| 10.0 |
|
10 |
| 2.34E5 |
2.34 * 10^5 |
234000 |
| 67E-12 |
67.0 * 10^-12 |
0.000000000067 |
數據類型
void
void
void只用在函數聲明中。它表示該函數將不會被返回任何數據到它被調用的函數中。
例子
//功能在“setup”和“loop”被執行
//但沒有數據被返回到高一級的程序中
void setup()
{
// ...
}
void loop()
{
// ...
}
boolean
布爾
一個布爾變量擁有兩個值，true或false。（每個布爾變量占用一個字節的內存。）
例子
int LEDpin = 5; // LED與引腳5相連
int switchPin = 13; // 開關的一個引腳連接引腳13，另一個引腳接地。
boolean running = false;
void setup()
{
pinMode(LEDpin, OUTPUT);
pinMode(switchPin, INPUT);
digitalWrite(switchPin, HIGH); // 打開上拉電阻
}
void loop()
{
if (digitalRead(switchPin) == LOW)
{ // 按下開關 - 使引腳拉向高電勢
delay(100); // 通過延遲，以濾去開關抖動產生的雜波
running = !running; // 觸發running變量
digitalWrite(LEDpin, running) //點亮LED
}
}
char
描述
一個數據類型，占用1個字節的內存存儲一個字符值。字符都寫在單引號，如'A'（多個字符（字符串）使用雙引號，如“ABC”）。
字符以編號的形式存儲。你可以在ASCII表中看到對應的編碼。這意味着字符的ASCII值可以用來作數學計算。（例如'A'+ 1，因為大寫A的ASCII值是65，所以結果為66）。如何將字符轉換成數字參考serial.println命令。
char數據類型是有符號的類型，這意味着它的編碼為-128到127。對於一個無符號一個字節（8位）的數據類型，使用byte數據類型。
例如
char myChar = 'A';
char myChar = 65; // both are equivalent
unsigned char
unsigned char
描述
一個無符號數據類型占用1個字節的內存。與byte的數據類型相同。
無符號的char數據類型能編碼0到255的數字。
為了保持Arduino的編程風格的一致性，byte數據類型是首選。
例子
unsigned char myChar = 240;
byte
byte
描述
一個字節存儲8位無符號數，從0到255。
例子
byte b = B10010; // "B" 是二進制格式（B10010等於十進制18）
int
int
簡介
整數是基本數據類型，占用2字節。整數的范圍為-32,768到32,767（ -2^15 ~（2^15)-1）。
整數類型使用2的補碼方式存儲負數。最高位通常為符號位，表示數的正負。其余位被“取反加1”（此處請參考補碼相關資料，不再贅述）。
Arduino為您處理負數計算問題，所以數學計算對您是透明的（術語：實際存在，但不可操作。相當於“黑盒”）。但是，當處理右移位運算符（»）時，可能有未預期的編譯過程。
示例
int ledPin = 13;
語法
int var = val;
var - 變量名
val - 賦給變量的值
提示
當變量數值過大而超過整數類型所能表示的范圍時（-32,768到32,767），變量值會“回滾”（詳情見示例）。
int x
x = -32,768;
x = x - 1; // x 現在是 32,767。
x = 32,767;
x = x + 1; // x 現在是 -32,768。
unsigned int
描述
unsigned int（無符號整型）與整型數據同樣大小，占據2字節。它只能用於存儲正數而不能存儲負數，范圍0~65,535 (2^16) - 1)。
無符號整型和整型最重要的區別是它們的最高位不同，既符號位。在Arduino整型類型中，如果最高位是1，則此數被認為是負數，剩下的15位為按2的補碼計算所得值。
例子
unsigned int ledPin = 13;
語法
unsigned int var = val;
var - 無符號變量名稱
val - 給變量所賦予的值
編程提示
當變量的值超過它能表示的最大值時它會“滾回”最小值，反向也會出現這種現象。
unsigned int x
x = 0;
x = x - 1; //x現在等於65535--向負數方向滾回
x = x + 1; //x現在等於0--滾回
word
word（字符）
描述
一個存儲一個16字節無符號數的字符，取值范圍從0到65535，與unsigned int相同。
例子
word w = 10000;
long
long
描述
長整數型變量是擴展的數字存儲變量，它可以存儲32位（4字節）大小的變量，從-2,147,483,648到2,147,483,647。
例子
long speedOfLight = 186000L; //參見整數常量‘L’的說明
語法
long var = val;
var - 長整型變量名
var - 賦給變量的值
unsigned long
描述
無符號長整型變量擴充了變量容量以存儲更大的數據，它能存儲32位(4字節)數據。與標准長整型不同無符號長整型無法存儲負數，其范圍從0到4,294,967,295（2 ^ 32 - 1）。
例子
unsigned long time;
void setup()
{
Serial.begin(9600);
}
void loop()
{
Serial.print("Time: ");
time = millis();
//程序開始后一直打印時間
Serial.println(time);
//等待一秒鍾，以免發送大量的數據
delay(1000);
}
語法
unsigned long var = val;
var - 你所定義的變量名
val - 給變量所賦的值
float
float
描述
float，浮點型數據，就是有一個小數點的數字。浮點數經常被用來近似的模擬連續值，因為他們比整數更大的精確度。浮點數的取值范圍在3.4028235 E+38 ~ -3.4028235E +38。它被存儲為32位（4字節）的信息。
float只有6-7位有效數字。這指的是總位數，而不是小數點右邊的數字。與其他平台不同的是，在那里你可以使用double型得到更精確的結果（如15位），在Arduino上，double型與float型的大小相同。
浮點數字在有些情況下是不准確的，在數據大小比較時，可能會產生奇怪的結果。例如 6.0 / 3.0 可能不等於 2.0。你應該使兩個數字之間的差額的絕對值小於一些小的數字，這樣就可以近似的得到這兩個數字相等這樣的結果。
浮點運算速度遠遠慢於執行整數運算，例如，如果這個循環有一個關鍵的計時功能，並需要以最快的速度運行，就應該避免浮點運算。程序員經常使用較長的程式把浮點運算轉換成整數運算來提高速度。
舉例
float myfloat;
float sensorCalbrate = 1.117;
語法
float var = val;
var——您的float型變量名稱
val——分配給該變量的值
示例代碼
int x;
int y;
float z;
x = 1;
y = x / 2; // Y為0，因為整數不能容納分數
z = (float)x / 2.0; // Z為0.5（你必須使用2.0做除數，而不是2）
double
double
描述
雙精度浮點數。占用4個字節。
目前的arduino上的double實現和float相同，精度並未提高。
提示
如果你從其他地方得到的代碼中包含了double類變量，最好檢查一遍代碼以確認其中的變量的精確度能否在arduino上達到。
string（字符串）
描述
文本字符串可以有兩種表現形式。你可以使用字符串數據類型（這是0019版本的核心部分），或者你可以做一個字符串，由char類型的數組和空終止字符('\0')構成。（求助，待潤色-Leo）本節描述了后一種方法。而字符串對象（String object）將讓你擁有更多的功能，同時也消耗更多的內存資源，關於它的詳細信息，請參閱頁面（String object）[超鏈接]
舉例
以下所有字符串都是有效的聲明。
char Str1[15];
char Str2[8] = {'a', 'r', 'd', 'u', 'i', 'n', 'o'};
char Str3[8] = {'a', 'r', 'd', 'u', 'i', 'n', 'o', '\0'};
char Str4[ ] = "arduino";
char Str5[8] = "arduino";
char Str6[15] = "arduino";
聲明字符串的解釋
在Str1中 聲明一個沒有初始化的字符數組
在Str2中 聲明一個字符數組（包括一個附加字符），編譯器會自動添加所需的空字符
在Str3中 明確加入空字符
在Str4中 用引號分隔初始化的字符串常數，編譯器將調整數組的大小，以適應字符串常量和終止空字符
在Str5中 初始化一個包括明確的尺寸和字符串常量的數組
在Str6中 初始化數組，預留額外的空間用於一個較大的字符串
空終止字符
一般來說，字符串的結尾有一個空終止字符（ASCII代碼0）。以此讓功能函數（例如Serial.pring()）知道一個字符串的結束。否則，他們將從內存繼續讀取后續字節，而這些並不屬於所需字符串的一部分。
這意味着，你的字符串比你想要的文字包含更多的個字符空間。這就是為什么Str2和Str5需要八個字符，即使“Arduino”只有七個字符 - 最后一個位置會自動填充空字符。str4將自動調整為八個字符，包括一個額外的空。在Str3的，我們自己已經明確地包含了空字符(寫入'\ 0')。
需要注意的是，字符串可能沒有一個最后的空字符（例如在Str2中您已定義字符長度為7，而不是8）。這會破壞大部分使用字符串的功能，所以不要故意而為之。如果你注意到一些奇怪的現象（在字符串中操作字符），基本就是這個原因導致的了。
單引號？還是雙引號？
定義字符串時使用雙引號（例如“ABC”），而定義一個單獨的字符時使用單引號（例如'A'）
包裝長字符串
你可以像這樣打包長字符串： char myString[] = “This is the first line” ” this is the second line” ” etcetera”;
字符串數組
當你的應用包含大量的文字，如帶有液晶顯示屏的一個項目，建立一個字符串數組是非常便利的。因為字符串本身就是數組，它實際上是一個兩維數組的典型。
在下面的代碼，”char*”在字符數據類型char后跟了一個星號'*'表示這是一個“指針”數組。所有的數組名實際上是指針，所以這需要一個數組的數組。指針對於C語言初學者而言是非常深奧的部分之一，但我們沒有必要了解詳細指針，就可以有效地應用它。
樣例
char* myStrings[]={
"This is string 1", "This is string 2", "This is string 3",
"This is string 4", "This is string 5","This is string 6"};
void setup(){
Serial.begin(9600);
}
void loop(){
for (int i = 0; i < 6; i++){
Serial.println(myStrings[i]);
delay(500);
}
}
String - object
描述
String類，是0019版的核心的一部分，允許你實現比運用字符數組更復雜的文字操作。你可以連接字符串，增加字符串，尋找和替換子字符串以及其他操作。它比使用一個簡單的字符數組需要更多的內存，但它更方便。
僅供參考，字符串數組都用小寫的string表示而String類的實例通常用大寫的String表示。注意，在“雙引號”內指定的字符常量通常被作為字符數組，並非String類實例。
函數
String
charAt()
compareTo()
concat()
endsWith()
equals()
equalsIgnoreCase()
GetBytes()
indexOf()
lastIndexOf
length
replace()
setCharAt()
startsWith()
substring()
toCharArray()
toLowerCase()
toUpperCase()
trim()
操作符
[]（元素訪問）
+（串連）
==（比較）
舉例
StringConstructors
StringAdditionOperator
StringIndexOf
StringAppendOperator
StringLengthTrim
StringCaseChanges
StringReplace
StringCharacters
StringStartsWithEndsWith
StringComparisonOperators
StringSubstring
array -（數組）
Arrays （數組）
數組是一種可訪問的變量的集合。Arduino的數組是基於C語言的，因此這會變得很復雜，但使用簡單的數組是比較簡單的。
創建（聲明）一個數組
下面的方法都可以用來創建（聲明）數組。
myInts [6];
myPins [] = {2，4，8，3，6};
mySensVals [6] = {2，4，-8，3，2};
char message[6] = "hello";
你聲明一個未初始化數組，例如myPins。
在myPins中，我們聲明了一個沒有明確大小的數組。編譯器將會計算元素的大小，並創建一個適當大小的數組。
當然，你也可以初始化數組的大小，例如在mySensVals中。請注意，當聲明一個char類型的數組時，你初始化的大小必須大於元素的個數，以容納所需的空字符。
訪問數組
數組是從零開始索引的，也就說，上面所提到的數組初始化，數組第一個元素是為索引0，因此：
mySensVals [0] == 2，mySensVals [1] == 4，
依此類推 。
這也意味着，在包含十個元素的數組中，索引九是最后一個元素。因此，
int myArray[10] = {9,3,2,4,3,2,7,8,9,11};
// myArray[9]的數值為11
// myArray[10]，該索引是無效的，它將會是任意的隨機信息（內存地址）
出於這個原因，你在訪問數組應該小心。若訪問的數據超出數組的末尾（即索引數大於你聲明的數組的大小- 1），則將從其他內存中讀取數據。從這些地方讀取的數據，除了產生無效的數據外，沒有任何作用。向隨機存儲器中寫入數據絕對是一個壞主意，通常會導致不愉快的結果，如導致系統崩潰或程序故障。要排查這樣的錯誤是也是一件難事。不同於Basic或JAVA，C語言編譯器不會檢查你訪問的數組是否大於你聲明的數組。
指定一個數組的值：
mySensVals [0] = 10;
從數組中訪問一個值：
X = mySensVals [4];
數組和循環
數組往往在for循環中進行操作，循環計數器可用於訪問每個數組元素。例如，將數組中的元素通過串口打印，你可以這樣做：
int i;
for (i = 0; i < 5; i = i + 1) {
Serial.println(myPins[i]);
}
數據類型轉換
char()
char
描述
將一個變量的類型變為char。
語法
char(x)
參數
x：任何類型的值
返回
char
byte()
byte()
描述
將一個值轉換為字節型數值。
語法
byte(x)
參數
X：任何類型的值
返回
字節
int()
簡介
將一個值轉換為int類型。
語法
int(x)
參數
x:一個任何類型的值
返回值
int類型的值
word()
描述：把一個值轉換為word數據類型的值，或由兩個字節創建一個字符。
語法：word(x)
word(h, l)
參數：X：任何類型的值
H：高階（最左邊）字節
L：低序（最右邊）字節
返回：字符
long()
描述：將一個值轉換為長整型數據類型。
語法：long(x)
參數：x:任意類型的數值
返回：長整型數
float()
描述：將一個值轉換為float型數值。
語法：float(x)
參數：X：任何類型的值
返回：float型數
注釋：見float中關於Arduino浮點數的精度和限制的詳細信息。
變量作用域 & 修飾符
variable scope
變量的作用域
在Arduino使用的C編程語言的變量，有一個名為 作用域(scope) 的屬性 。這一點與類似BASIC的語言形成了對比，在BASIC語言中所有變量都是 全局(global) 變量。
在一個程序內的全局變量是可以被所有函數所調用的。局部變量只在聲明它們的函數內可見。在Arduino的環境中，任何在函數（例如，setup(),loop()等）外聲明的變量，都是全局變量。
當程序變得更大更復雜時，局部變量是一個有效確定每個函數只能訪問其自己變量的途徑。這可以防止，當一個函數無意中修改另一個函數使用的變量的程序錯誤。
有時在一個for循環內聲明並初始化一個變量也是很方便的選擇。這將創建一個只能從for循環的括號內訪問的變量。
例子：
int gPWMval; // 任何函數都可以調用此變量
void setup()
{
// ...
}
void loop()
{
int i; // "i" 只在 "loop" 函數內可用
float f; // "f" 只在 "loop" 函數內可用
// ...
for (int j = 0; j <100; j++){
//變量j只能在循環括號內訪問
}
}
static
static關鍵字用於創建只對某一函數可見的變量。然而，和局部變量不同的是，局部變量在每次調用函數時都會被創建和銷毀，靜態變量在函數調用后仍然保持着原來的數據。
靜態變量只會在函數第一次調用的時候被創建和初始化。
例子
/* RandomWalk
* Paul Badger 2007
* RandomWalk函數在兩個終點間隨機的上下移動
* 在一個循環中最大的移動由參數“stepsize”決定
*一個靜態變量向上和向下移動一個隨機量
*這種技術也被叫做“粉紅噪聲”或“醉步”
*/
#define randomWalkLowRange -20
#define randomWalkHighRange 20
int stepsize;
INT thisTime;
int total;
void setup()
{
Serial.begin(9600);
}
void loop()
{ // 測試randomWalk 函數
stepsize = 5;
thisTime = randomWalk(stepsize);
serial.println（thisTime）;
delay(10);
}
int randomWalk(int moveSize){
static int place; // 在randomwalk中存儲變量
// 聲明為靜態因此它在函數調用之間能保持數據，但其他函數無法改變它的值
place = place + (random(-moveSize, moveSize + 1));
if (place < randomWalkLowRange){ //檢查上下限
place = place + (randomWalkLowRange - place); // 將數字變為正方向
}
else if(place > randomWalkHighRange){
place = place - (place - randomWalkHighRange); // 將數字變為負方向
}
return place;
}
volatile
volatile關鍵字
volatile這個關鍵字是變量修飾符，常用在變量類型的前面，以告訴編譯器和接下來的程序怎么對待這個變量。
聲明一個volatile變量是編譯器的一個指令。編譯器是一個將你的C/C++代碼轉換成機器碼的軟件，機器碼是arduino上的Atmega芯片能識別的真正指令。
具體來說，它指示編譯器編譯器從RAM而非存儲寄存器中讀取變量，存儲寄存器是程序存儲和操作變量的一個臨時地方。在某些情況下，存儲在寄存器中的變量值可能是不准確的。
如果一個變量所在的代碼段可能會意外地導致變量值改變那此變量應聲明為volatile，比如並行多線程等。在arduino中，唯一可能發生這種現象的地方就是和中斷有關的代碼段，成為中斷服務程序。
例子
//當中斷引腳改變狀態時，開閉LED
int pin = 13;
volatile int state = LOW;
void setup()
{
pinMode(pin, OUTPUT);
attachInterrupt(0, blink, CHANGE);
}
void loop()
{
digitalWrite(pin, state);
}
void blink()
{
state = !state;
}
const
const關鍵字
const關鍵字代表常量。它是一個變量限定符，用於修改變量的性質，使其變為只讀狀態。這意味着該變量，就像任何相同類型的其他變量一樣使用，但不能改變其值。如果嘗試為一個const變量賦值，編譯時將會報錯。
const關鍵字定義的常量，遵守 variable scoping 管轄的其他變量的規則。這一點加上使用 #define的缺陷 ，使 const 關鍵字成為定義常量的一個的首選方法。
例子
const float pi = 3.14;
float x;
// ....
x = pi * 2; // 在數學表達式中使用常量不會報錯
pi = 7; // 錯誤的用法 - 你不能修改常量值，或給常量賦值。
#define 或 const
您可以使用 const 或 ＃define 創建數字或字符串常量。但 arrays, 你只能使用 const。 一般 const 相對 的＃define是首選 的定義常量語法。
輔助工具
sizeof()
描述
sizeof操作符返回一個變量類型的字節數，或者該數在數組中占有的字節數。
語法
sizeof(variable)
參數
variable: 任何變量類型或數組（如int，float，byte）
示例代碼
sizeof操作符用來處理數組非常有效，它能很方便的改變數組的大小而不用破壞程序的其他部分。
這個程序一次打印出一個字符串文本的字符。嘗試改變一下字符串。
char myStr[] = "this is a test";
int i;
void setup(){
Serial.begin(9600);
}
{0}void{/0}{1} {/1}{2}loop{/2}{1}() {{/1}
for (i = 0; i < sizeof(myStr) - 1; i++){
Serial.print(i, DEC);
Serial.print(" = ");
Serial.println(myStr[i], BYTE);
}
}
請注意sizeof返回字節數總數。因此，較大的變量類型，如整數，for循環看起來應該像這樣。
for (i = 0; i < (sizeof(myInts)/sizeof(int)) - 1; i++) {
//用myInts[i]來做些事
}
Arduino 語法手冊
http://wiki.geek-workshop.com/doku.php?id=arduino:arduino_language_reference
變量部分
常量constants
HIGH|LOW
INPUT|OUTPUT
true | false
constants是在Arduino語言里預定義的變量。它們被用來使程序更易閱讀。我們按組將常量分類。
在Arduino內有兩個常量用來表示真和假：true和 false。
在這兩個常量中false更容易被定義。false被定義為0（零）。
true通常被定義為1，這是正確的，但true具有更廣泛的定義。在布爾含義（Boolean sense）里任何 非零 整數 為true。所以在布爾含義內-1，2和-200都定義為ture。需要注意的是true和false常量，不同於HIGH，LOW，INPUT和OUTPUT，需要全部小寫。
——這里引申一下題外話arduino是大小寫敏感語言（case sensitive）。
當讀取（read）或寫入（write）數字引腳時只有兩個可能的值： HIGH 和 LOW 。
HIGH（參考引腳）的含義取決於引腳（pin）的設置，引腳定義為INPUT或OUTPUT時含義有所不同。當一個引腳通過pinMode被設置為INPUT，並通過digitalRead讀取（read）時。如果當前引腳的電壓大於等於3V，微控制器將會返回為HIGH。引腳也可以通過pinMode被設置為INPUT，並通過digitalWrite設置為HIGH。輸入引腳的值將被一個內在的20K上拉電阻 控制 在HIGH上，除非一個外部電路將其拉低到LOW。當一個引腳通過pinMode被設置為OUTPUT，並digitalWrite設置為HIGH時，引腳的電壓應在5V。在這種狀態下，它可以 輸出電流 。例如，點亮一個通過一串電阻接地或設置為LOW的OUTPUT屬性引腳的LED。
LOW的含義同樣取決於引腳設置，引腳定義為INPUT或OUTPUT時含義有所不同。當一個引腳通過pinMode配置為INPUT，通過digitalRead設置為讀取（read）時，如果當前引腳的電壓小於等於2V，微控制器將返回為LOW。當一個引腳通過pinMode配置為OUTPUT，並通過digitalWrite設置為LOW時，引腳為0V。在這種狀態下，它可以 倒灌 電流。例如，點亮一個通過串聯電阻連接到+5V，或到另一個引腳配置為OUTPUT、HIGH的的LED。
數字引腳（Digital pins）定義，INPUT和OUTPUT
數字引腳當作 INPUT 或 OUTPUT都可以 。用pinMode()方法使一個數字引腳從INPUT到OUTPUT變化。
Arduino（Atmega）引腳通過pinMode()配置為 輸入（INPUT） 即是將其配置在一個高阻抗的狀態。配置為INPUT的引腳可以理解為引腳取樣時對電路有極小的需求，即等效於在引腳前串聯一個100兆歐姆(Megohms)的電阻。這使得它們非常利於讀取傳感器，而不是為LED供電。
引腳通過pinMode()配置為 輸出（OUTPUT） 即是將其配置在一個低阻抗的狀態。
這意味着它們可以為電路提供充足的電流。Atmega引腳可以向其他設備/電路提供（提供正電流positive current）或倒灌（提供負電流negative current）達40毫安（mA）的電流。這使得它們利於給LED供電，而不是讀取傳感器。輸出（OUTPUT）引腳被短路的接地或5V電路上會受到損壞甚至燒毀。Atmega引腳在為繼電器或電機供電時，由於電流不足，將需要一些外接電路來實現供電。
integer constants
整數常量是直接在程序中使用的數字，如123。默認情況下，這些數字被視為int，但你可以通過U和L修飾符進行更多的限制（見下文）。通常情況下，整數常量默認為十進制，但可以加上特殊前綴表示為其他進制。
| 進制 |
例子 |
格式 |
備注 |
| 10（十進制） |
123 |
無 |
|
| 2（二進制） |
B1111011 |
前綴'B' |
只適用於8位的值（0到255）字符0-1有效 |
| 8（八進制） |
0173 |
前綴”0” |
字符0-7有效 |
| 16（十六進制） |
0x7B |
前綴”0x” |
字符0-9，A-F，A-F有效 |
小數是十進制數。這是數學常識。如果一個數沒有特定的前綴，則默認為十進制。
二進制以2為基底，只有數字0和1是有效的。
示例:
101 //和十進制5等價 （1*2^2 + 0*2^1 + 1*2^0）
二進制格式只能是8位的，即只能表示0-255之間的數。如果輸入二進制數更方便的話，你可以用以下的方式：
myInt = (B11001100 * 256) + B10101010; // B11001100 作為高位。
八進制是以8為基底，只有0-7是有效的字符。前綴“0”（數字0）表示該值為八進制。
0101 // 等同於十進制數65 ((1 * 8^2) + (0 * 8^1) + 1)
警告:八進制數0前綴很可能無意產生很難發現的錯誤，因為你可能不小心在常量前加了個“0”，結果就悲劇了。
十六進制以16為基底，有效的字符為0-9和A-F。十六進制數用前綴“0x”（數字0，字母愛克斯）表示。請注意，A-F不區分大小寫，就是說你也可以用a-f。
示例:
0x101 // 等同於十進制257 ((1 * 16^2) + (0 * 16^1) + 1)
默認情況下，整型常量被視作int型。要將整型常量轉換為其他類型時，請遵循以下規則：
'u' or 'U' 指定一個常量為無符號型。（只能表示正數和0） 例如: 33u
'l' or 'L' 指定一個常量為長整型。（表示數的范圍更廣） 例如: 100000L
'ul' or 'UL' 這個你懂的，就是上面兩種類型，稱作無符號長整型。 例如：32767ul
floating point constants
和整型常量類似，浮點常量可以使得代碼更具可讀性。浮點常量在編譯時被轉換為其表達式所取的值。
例子
n = .005; 浮點數可以用科學記數法表示。'E'和'e'都可以作為有效的指數標志。
| 浮點數 |
被轉換為 |
被轉換為 |
| 10.0 |
|
10 |
| 2.34E5 |
2.34 * 10^5 |
234000 |
| 67E-12 |
67.0 * 10^-12 |
0.000000000067 |
數據類型
void
void只用在函數聲明中。它表示該函數將不會被返回任何數據到它被調用的函數中。
例子
//功能在“setup”和“loop”被執行
//但沒有數據被返回到高一級的程序中
void setup()
{
// ...
}
void loop()
{
// ...
}
boolean
一個布爾變量擁有兩個值，true或false。（每個布爾變量占用一個字節的內存。）
例子
int LEDpin = 5; // LED與引腳5相連
int switchPin = 13; // 開關的一個引腳連接引腳13，另一個引腳接地。
boolean running = false;
void setup()
{
pinMode(LEDpin, OUTPUT);
pinMode(switchPin, INPUT);
digitalWrite(switchPin, HIGH); // 打開上拉電阻
}
void loop()
{
if (digitalRead(switchPin) == LOW)
{ // 按下開關 - 使引腳拉向高電勢
delay(100); // 通過延遲，以濾去開關抖動產生的雜波
running = !running; // 觸發running變量
digitalWrite(LEDpin, running) //點亮LED
}
}
char
描述
一個數據類型，占用1個字節的內存存儲一個字符值。字符都寫在單引號，如'A'（多個字符（字符串）使用雙引號，如“ABC”）。
字符以編號的形式存儲。你可以在ASCII表中看到對應的編碼。這意味着字符的ASCII值可以用來作數學計算。（例如'A'+ 1，因為大寫A的ASCII值是65，所以結果為66）。如何將字符轉換成數字參考serial.println命令。
char數據類型是有符號的類型，這意味着它的編碼為-128到127。對於一個無符號一個字節（8位）的數據類型，使用byte數據類型。
例如
char myChar = 'A';
char myChar = 65; // both are equivalent
unsigned char
描述
一個無符號數據類型占用1個字節的內存。與byte的數據類型相同。
無符號的char數據類型能編碼0到255的數字。
為了保持Arduino的編程風格的一致性，byte數據類型是首選。
例子
unsigned char myChar = 240;
byte
描述
一個字節存儲8位無符號數，從0到255。
例子
byte b = B10010; // "B" 是二進制格式（B10010等於十進制18）
int
整數是基本數據類型，占用2字節。整數的范圍為-32,768到32,767（ -2^15 ~（2^15)-1）。
整數類型使用2的補碼方式存儲負數。最高位通常為符號位，表示數的正負。其余位被“取反加1”（此處請參考補碼相關資料，不再贅述）。
Arduino為您處理負數計算問題，所以數學計算對您是透明的（術語：實際存在，但不可操作。相當於“黑盒”）。但是，當處理右移位運算符（»）時，可能有未預期的編譯過程。
示例
int ledPin = 13;
語法
int var = val;
var - 變量名
val - 賦給變量的值
提示
當變量數值過大而超過整數類型所能表示的范圍時（-32,768到32,767），變量值會“回滾”（詳情見示例）。
int x
x = -32,768;
x = x - 1; // x 現在是 32,767。
x = 32,767;
x = x + 1; // x 現在是 -32,768。
unsigned int
描述
unsigned int（無符號整型）與整型數據同樣大小，占據2字節。它只能用於存儲正數而不能存儲負數，范圍0~65,535 (2^16) - 1)。
無符號整型和整型最重要的區別是它們的最高位不同，既符號位。在Arduino整型類型中，如果最高位是1，則此數被認為是負數，剩下的15位為按2的補碼計算所得值。
例子
unsigned int ledPin = 13;
語法
unsigned int var = val;
var - 無符號變量名稱
val - 給變量所賦予的值
編程提示
當變量的值超過它能表示的最大值時它會“滾回”最小值，反向也會出現這種現象。
unsigned int x
x = 0;
x = x - 1; //x現在等於65535--向負數方向滾回
x = x + 1; //x現在等於0--滾回
word
描述
一個存儲一個16字節無符號數的字符，取值范圍從0到65535，與unsigned int相同。
例子
word w = 10000;
long
描述
長整數型變量是擴展的數字存儲變量，它可以存儲32位（4字節）大小的變量，從-2,147,483,648到2,147,483,647。
例子
long speedOfLight = 186000L; //參見整數常量‘L’的說明
語法
long var = val;
var - 長整型變量名
var - 賦給變量的值
unsigned long
描述
無符號長整型變量擴充了變量容量以存儲更大的數據，它能存儲32位(4字節)數據。與標准長整型不同無符號長整型無法存儲負數，其范圍從0到4,294,967,295（2 ^ 32 - 1）。
例子
unsigned long time;
void setup()
{
Serial.begin(9600);
}
void loop()
{
Serial.print("Time: ");
time = millis();
//程序開始后一直打印時間
Serial.println(time);
//等待一秒鍾，以免發送大量的數據
delay(1000);
}
語法
unsigned long var = val;
var - 你所定義的變量名
val - 給變量所賦的值
float
描述
float，浮點型數據，就是有一個小數點的數字。浮點數經常被用來近似的模擬連續值，因為他們比整數更大的精確度。浮點數的取值范圍在3.4028235 E+38 ~ -3.4028235E +38。它被存儲為32位（4字節）的信息。
float只有6-7位有效數字。這指的是總位數，而不是小數點右邊的數字。與其他平台不同的是，在那里你可以使用double型得到更精確的結果（如15位），在Arduino上，double型與float型的大小相同。
浮點數字在有些情況下是不准確的，在數據大小比較時，可能會產生奇怪的結果。例如 6.0 / 3.0 可能不等於 2.0。你應該使兩個數字之間的差額的絕對值小於一些小的數字，這樣就可以近似的得到這兩個數字相等這樣的結果。
浮點運算速度遠遠慢於執行整數運算，例如，如果這個循環有一個關鍵的計時功能，並需要以最快的速度運行，就應該避免浮點運算。程序員經常使用較長的程式把浮點運算轉換成整數運算來提高速度。
舉例
float myfloat;
float sensorCalbrate = 1.117;
語法
float var = val;
var——您的float型變量名稱
val——分配給該變量的值
示例代碼
int x;
int y;
float z;
x = 1;
y = x / 2; // Y為0，因為整數不能容納分數
z = (float)x / 2.0; // Z為0.5（你必須使用2.0做除數，而不是2）
double
描述
雙精度浮點數。占用4個字節。
目前的arduino上的double實現和float相同，精度並未提高。
提示
如果你從其他地方得到的代碼中包含了double類變量，最好檢查一遍代碼以確認其中的變量的精確度能否在arduino上達到。
string - char array
描述
文本字符串可以有兩種表現形式。你可以使用字符串數據類型（這是0019版本的核心部分），或者你可以做一個字符串，由char類型的數組和空終止字符('\0')構成。（求助，待潤色-Leo）本節描述了后一種方法。而字符串對象（String object）將讓你擁有更多的功能，同時也消耗更多的內存資源，關於它的詳細信息，請參閱頁面（String object）[超鏈接]
舉例
以下所有字符串都是有效的聲明。
char Str1[15];
char Str2[8] = {'a', 'r', 'd', 'u', 'i', 'n', 'o'};
char Str3[8] = {'a', 'r', 'd', 'u', 'i', 'n', 'o', '\0'};
char Str4[ ] = "arduino";
char Str5[8] = "arduino";
char Str6[15] = "arduino";
在Str1中 聲明一個沒有初始化的字符數組
在Str2中 聲明一個字符數組（包括一個附加字符），編譯器會自動添加所需的空字符
在Str3中 明確加入空字符
在Str4中 用引號分隔初始化的字符串常數，編譯器將調整數組的大小，以適應字符串常量和終止空字符
在Str5中 初始化一個包括明確的尺寸和字符串常量的數組
在Str6中 初始化數組，預留額外的空間用於一個較大的字符串
一般來說，字符串的結尾有一個空終止字符（ASCII代碼0）。以此讓功能函數（例如Serial.pring()）知道一個字符串的結束。否則，他們將從內存繼續讀取后續字節，而這些並不屬於所需字符串的一部分。
這意味着，你的字符串比你想要的文字包含更多的個字符空間。這就是為什么Str2和Str5需要八個字符，即使“Arduino”只有七個字符 - 最后一個位置會自動填充空字符。str4將自動調整為八個字符，包括一個額外的空。在Str3的，我們自己已經明確地包含了空字符(寫入'\ 0')。
需要注意的是，字符串可能沒有一個最后的空字符（例如在Str2中您已定義字符長度為7，而不是8）。這會破壞大部分使用字符串的功能，所以不要故意而為之。如果你注意到一些奇怪的現象（在字符串中操作字符），基本就是這個原因導致的了。
定義字符串時使用雙引號（例如“ABC”），而定義一個單獨的字符時使用單引號（例如'A'）
你可以像這樣打包長字符串： char myString[] = “This is the first line” ” this is the second line” ” etcetera”;
當你的應用包含大量的文字，如帶有液晶顯示屏的一個項目，建立一個字符串數組是非常便利的。因為字符串本身就是數組，它實際上是一個兩維數組的典型。
在下面的代碼，”char*”在字符數據類型char后跟了一個星號'*'表示這是一個“指針”數組。所有的數組名實際上是指針，所以這需要一個數組的數組。指針對於C語言初學者而言是非常深奧的部分之一，但我們沒有必要了解詳細指針，就可以有效地應用它。
char* myStrings[]={
"This is string 1", "This is string 2", "This is string 3",
"This is string 4", "This is string 5","This is string 6"};
void setup(){
Serial.begin(9600);
}
void loop(){
for (int i = 0; i < 6; i++){
Serial.println(myStrings[i]);
delay(500);
}
}
String - object
描述
String類，是0019版的核心的一部分，允許你實現比運用字符數組更復雜的文字操作。你可以連接字符串，增加字符串，尋找和替換子字符串以及其他操作。它比使用一個簡單的字符數組需要更多的內存，但它更方便。
僅供參考，字符串數組都用小寫的string表示而String類的實例通常用大寫的String表示。注意，在“雙引號”內指定的字符常量通常被作為字符數組，並非String類實例。
String
charAt()
compareTo()
concat()
endsWith()
equals()
equalsIgnoreCase()
GetBytes()
indexOf()
lastIndexOf
length
replace()
setCharAt()
startsWith()
substring()
toCharArray()
toLowerCase()
toUpperCase()
trim()
[]（元素訪問）
+（串連）
==（比較）
舉例
StringConstructors
StringAdditionOperator
StringIndexOf
StringAppendOperator
StringLengthTrim
StringCaseChanges
StringReplace
StringCharacters
StringStartsWithEndsWith
StringComparisonOperators
StringSubstring
array -（數組）
數組是一種可訪問的變量的集合。Arduino的數組是基於C語言的，因此這會變得很復雜，但使用簡單的數組是比較簡單的。
下面的方法都可以用來創建（聲明）數組。
myInts [6];
myPins [] = {2，4，8，3，6};
mySensVals [6] = {2，4，-8，3，2};
char message[6] = "hello";
你聲明一個未初始化數組，例如myPins。
在myPins中，我們聲明了一個沒有明確大小的數組。編譯器將會計算元素的大小，並創建一個適當大小的數組。
當然，你也可以初始化數組的大小，例如在mySensVals中。請注意，當聲明一個char類型的數組時，你初始化的大小必須大於元素的個數，以容納所需的空字符。
數組是從零開始索引的，也就說，上面所提到的數組初始化，數組第一個元素是為索引0，因此：
mySensVals [0] == 2，mySensVals [1] == 4，
依此類推 。
這也意味着，在包含十個元素的數組中，索引九是最后一個元素。因此，
int myArray[10] = {9,3,2,4,3,2,7,8,9,11};
// myArray[9]的數值為11
// myArray[10]，該索引是無效的，它將會是任意的隨機信息（內存地址）
出於這個原因，你在訪問數組應該小心。若訪問的數據超出數組的末尾（即索引數大於你聲明的數組的大小- 1），則將從其他內存中讀取數據。從這些地方讀取的數據，除了產生無效的數據外，沒有任何作用。向隨機存儲器中寫入數據絕對是一個壞主意，通常會導致不愉快的結果，如導致系統崩潰或程序故障。要排查這樣的錯誤是也是一件難事。不同於Basic或JAVA，C語言編譯器不會檢查你訪問的數組是否大於你聲明的數組。
mySensVals [0] = 10;
X = mySensVals [4];
數組往往在for循環中進行操作，循環計數器可用於訪問每個數組元素。例如，將數組中的元素通過串口打印，你可以這樣做：
int i;
for (i = 0; i < 5; i = i + 1) {
Serial.println(myPins[i]);
}
數據類型轉換
char()
描述
將一個變量的類型變為char。
語法
char(x)
參數
x：任何類型的值
返回
char
byte()
byte()
描述
將一個值轉換為字節型數值。
語法
byte(x)
參數
X：任何類型的值
返回
字節
int()
簡介
將一個值轉換為int類型。
語法
int(x)
參數
x:一個任何類型的值
int類型的值
word()
描述：把一個值轉換為word數據類型的值，或由兩個字節創建一個字符。
語法：word(x)
word(h, l)
參數：X：任何類型的值
H：高階（最左邊）字節
L：低序（最右邊）字節
返回：字符
long()
描述：將一個值轉換為長整型數據類型。
語法：long(x)
參數：x:任意類型的數值
返回：長整型數
float()
描述：將一個值轉換為float型數值。
語法：float(x)
參數：X：任何類型的值
返回：float型數
注釋：見float中關於Arduino浮點數的精度和限制的詳細信息。
變量作用域 & 修飾符
variable scope
在Arduino使用的C編程語言的變量，有一個名為 作用域(scope) 的屬性 。這一點與類似BASIC的語言形成了對比，在BASIC語言中所有變量都是 全局(global) 變量。
在一個程序內的全局變量是可以被所有函數所調用的。局部變量只在聲明它們的函數內可見。在Arduino的環境中，任何在函數（例如，setup(),loop()等）外聲明的變量，都是全局變量。
當程序變得更大更復雜時，局部變量是一個有效確定每個函數只能訪問其自己變量的途徑。這可以防止，當一個函數無意中修改另一個函數使用的變量的程序錯誤。
有時在一個for循環內聲明並初始化一個變量也是很方便的選擇。這將創建一個只能從for循環的括號內訪問的變量。
例子：
int gPWMval; // 任何函數都可以調用此變量
void setup()
{
// ...
}
void loop()
{
int i; // "i" 只在 "loop" 函數內可用
float f; // "f" 只在 "loop" 函數內可用
// ...
for (int j = 0; j <100; j++){
//變量j只能在循環括號內訪問
}
}
static
static關鍵字用於創建只對某一函數可見的變量。然而，和局部變量不同的是，局部變量在每次調用函數時都會被創建和銷毀，靜態變量在函數調用后仍然保持着原來的數據。
靜態變量只會在函數第一次調用的時候被創建和初始化。
例子
/* RandomWalk
* Paul Badger 2007
* RandomWalk函數在兩個終點間隨機的上下移動
* 在一個循環中最大的移動由參數“stepsize”決定
*一個靜態變量向上和向下移動一個隨機量
*這種技術也被叫做“粉紅噪聲”或“醉步”
*/
#define randomWalkLowRange -20
#define randomWalkHighRange 20
int stepsize;
INT thisTime;
int total;
void setup()
{
Serial.begin(9600);
}
void loop()
{ // 測試randomWalk 函數
stepsize = 5;
thisTime = randomWalk(stepsize);
serial.println（thisTime）;
delay(10);
}
int randomWalk(int moveSize){
static int place; // 在randomwalk中存儲變量
// 聲明為靜態因此它在函數調用之間能保持數據，但其他函數無法改變它的值
place = place + (random(-moveSize, moveSize + 1));
if (place < randomWalkLowRange){ //檢查上下限
place = place + (randomWalkLowRange - place); // 將數字變為正方向
}
else if(place > randomWalkHighRange){
place = place - (place - randomWalkHighRange); // 將數字變為負方向
}
return place;
}
volatile
volatile這個關鍵字是變量修飾符，常用在變量類型的前面，以告訴編譯器和接下來的程序怎么對待這個變量。
聲明一個volatile變量是編譯器的一個指令。編譯器是一個將你的C/C++代碼轉換成機器碼的軟件，機器碼是arduino上的Atmega芯片能識別的真正指令。
具體來說，它指示編譯器編譯器從RAM而非存儲寄存器中讀取變量，存儲寄存器是程序存儲和操作變量的一個臨時地方。在某些情況下，存儲在寄存器中的變量值可能是不准確的。
如果一個變量所在的代碼段可能會意外地導致變量值改變那此變量應聲明為volatile，比如並行多線程等。在arduino中，唯一可能發生這種現象的地方就是和中斷有關的代碼段，成為中斷服務程序。
例子
//當中斷引腳改變狀態時，開閉LED
int pin = 13;
volatile int state = LOW;
void setup()
{
pinMode(pin, OUTPUT);
attachInterrupt(0, blink, CHANGE);
}
void loop()
{
digitalWrite(pin, state);
}
void blink()
{
state = !state;
}
const
const關鍵字代表常量。它是一個變量限定符，用於修改變量的性質，使其變為只讀狀態。這意味着該變量，就像任何相同類型的其他變量一樣使用，但不能改變其值。如果嘗試為一個const變量賦值，編譯時將會報錯。
const關鍵字定義的常量，遵守 variable scoping 管轄的其他變量的規則。這一點加上使用 #define的缺陷 ，使 const 關鍵字成為定義常量的一個的首選方法。
例子
const float pi = 3.14;
float x;
// ....
x = pi * 2; // 在數學表達式中使用常量不會報錯
pi = 7; // 錯誤的用法 - 你不能修改常量值，或給常量賦值。
您可以使用 const 或 ＃define 創建數字或字符串常量。但 arrays, 你只能使用 const。 一般 const 相對 的＃define是首選 的定義常量語法。
輔助工具
sizeof()
描述
sizeof操作符返回一個變量類型的字節數，或者該數在數組中占有的字節數。
語法
sizeof(variable)
參數
variable: 任何變量類型或數組（如int，float，byte）
示例代碼
sizeof操作符用來處理數組非常有效，它能很方便的改變數組的大小而不用破壞程序的其他部分。
這個程序一次打印出一個字符串文本的字符。嘗試改變一下字符串。
char myStr[] = "this is a test";
int i;
void setup(){
Serial.begin(9600);
}
{0}void{/0}{1} {/1}{2}loop{/2}{1}() {{/1}
for (i = 0; i < sizeof(myStr) - 1; i++){
Serial.print(i, DEC);
Serial.print(" = ");
Serial.println(myStr[i], BYTE);
}
}
請注意sizeof返回字節數總數。因此，較大的變量類型，如整數，for循環看起來應該像這樣。
for (i = 0; i < (sizeof(myInts)/sizeof(int)) - 1; i++) {
//用myInts[i]來做些事
}