Arduino學習指南
簡介
您來對地方了：）
從地鐵實驗者指南開始！
Adafruit Metro和Metro Express的實驗者指南旨在為制作者，藝術家，黑客，學生，教育工作者，或想開始使用Metro或Metro M0 Express的任何人。
本指南中有許多電路，可讓您熟悉諸如學習不同類型的電子組件等技能（以及它們的工作方式），對Adafruit Metro或Metro Express進行編程，面包板和修改代碼。
已經有可以通過Arduino IDE編程的零件和板上了嗎？該指南也將為您服務！
按照本指南的順序進行操作，您將對Adafruit Metro感到滿意，足以完成自己的項目（或者至少足以嘗試Adafruit學習系統中數千個項目之一）
關于實驗者指南
實驗者指南是Oomlout的awesomeARDX套件的擴展版本，但與Adafruit Metro Classic和Metro M0 Express兼容。有許多新的電路可以利用Metro Classic和/或Express，也有許多小項目可以自己完成。
這些指南是為結合使用“經典” Metro（ATmega328）或 Metro M0 Express（ATSAMD21） Metro
，您可以使用零件構建所有電路從Adafruit商店。我們甚至在“零件”頁面中提供了每個電路的零件鏈接。
Electronics Primer
無需任何電子經驗即可使用該套件。以下是有關識別每個組件的一些詳細信息，也許了解它們會容易一些。如果您在任何時候都擔心某個組件的使用方式或為何無法正常工作，那么互聯網會提供很多建議，或者您可以在我們的社區支持論壇上獲得幫助
通過顏色代碼識別電阻器
圖形以上對于“資源管理器”指南非常有用-大多數CIRC都在使用它們。電阻具有不同的值，如果以后卡住，請查閱此圖。如果您想快速識別電阻真的好，請玩我們的有趣的iOS游戲：Mho‘s Resistance
引線夾
該套件中的某些組件帶有很多長導線。為了使它們與面包板更兼容，可以進行一些更改。
LED：
夾住引線，使長引線約為10mm（3長度為/8英寸），而短的則為?7毫米（9/32英寸）。如果您不擁有推剪，則可以在Adafruit商店拿起CHP17齊平斜嘴剪
電阻：
將引線彎曲以便與圓柱體成90度角。您可以通過用鉗子將其彎曲到90度的桌面角落來精確地做到這一點。
然后將它們剪斷，使其長約6mm（1/4“）。
其他組件：
其他組件可能需要裁剪。
：TMP36和NPN
雖然TMP36模擬溫度傳感器和NPN晶體管相似，但它們執行的任務卻截然不同。為了避免在電路中混淆它們，請使用這兩張圖片來確定您擁有的部分：
零件字段指南
（所有這些部分都可以在Metro Experimenterskit中找到，單擊將圖像放大）
零件圖片名稱和用途？如何識別線索要尋找的內容
LED ：當小電流通過時發光。通過它。 （僅在一個方向上）看起來像一個迷你燈泡。2（再長一點，這個連接到正）只能在一個方向上工作。
需要一個限流電阻器
二極管：電子等效于單向閥。允許電流在一個方向上流動，而不能在另一個方向上流動。通常是一個圓柱體，其導線從兩端伸出。 （以及指示極性的偏心線）2僅在一個方向上起作用（如果結束，電流將流過
電阻：：限制可流經電路的電流量。圓柱體，其中任一根導線均伸出結束。使用顏色編碼系統顯示該值（有關詳細信息，請參見“識別電阻器”部分）2簡單捕獲錯誤的值（使用前仔細檢查顏色）
晶體管：使用小電流來切換或放大更大的電流。有許多不同的包裝，但您可以從包裝中讀取零件號（此套件中為P2N2222AG）并在線查找數據表。3（基礎，收集器，發射極）正確插拔（通常在基極引腳上也需要一個限流電阻）
Servo：獲取定時脈沖并將其轉換一個帶有3根導線的塑料盒從一側伸出，一個帶有塑料角的軸從頂部伸出。3插頭未極化，因此請確保插頭插入正確。
直流電動機：在電流通過時旋轉。 p》這很簡單，它看起來像馬達。通常是帶有一端伸出軸的圓柱體。2使用額定值為
壓電式：電流脈沖會使其產生喀噠聲。脈沖流會使其發出聲音。在此工具包中，它裝在一個黑色小桶中，但有時它們只是一個金盤。2難于濫用。
集成電路（IC/“芯片”）：可封裝任意范圍零件ID寫在包裝的外部（有時需要用燈或放大鏡才能讀取）p》2至100（此套件具有3根導線的TMP36和16根導線的74HC595）。正確的方向（檢查標記，通常是引腳1上方的半月形。）
按鈕：在按下時完成電路。一點方形，底部引出，頂部有一個按鈕。4這些都是almo stt，以便可以將它們插入90度角。
電位計：根據軸的角位置產生可變電阻。它們可以包裝成許多不同的形狀，尋找刻度盤以識別該零件。3偶然購買對數
光傳感器：產生取決于入射光量的可變電阻。通常是一個帶有透明頂部和頂部的小圓盤。2請記住，在提供有用的輸入之前，它必須位于分壓器中。
p》
繼電器：一個電控開關。高矩形，下方帶有引腳。尺寸范圍從小到非常大（有些繼電器甚至可以控制火車軌道！）5到8（汽車繼電器通常有5針，此套件中的繼電器有8針）正確的方向。檢查繼電器上的標記，通常是前兩個插針上方的小矩形。繼電器的底部有時會帶有標記，指示線圈的位置。
根據紅外光量產生可變電阻。通常是一個帶有凹凸的小矩形。3請確保不要將其向后放置。
當有小電流通過時發出紅外光。 （僅在一個方向上）就像一個小燈泡。2僅在一個方向上起作用。
按照NEC紅外傳輸協議發出紅外光脈沖。就像電視遙控器。0難以濫用。
關于Arduino編程
使用C語言編程的Adafruit Metrois。這是一個快速的入門教程，面向有一點編程經驗并且只需要簡要介紹C和Arduino IDE的特性的人。如果您發現這些概念有些令人生畏，請放心，您可以開始遍歷電路，并逐步了解其中的大部分內容。
有關此處討論的主題的更深入說明并用該語言查看“ Arduino.cc參考”頁面。
Arduino IDE
現在已經安裝并配置了Arduino，下面我們來看看。雙擊Arduino圖標將其打開。它將在稱為 IDE 的工作空間中打開：
不要感到不知所措-隨著《實驗者指南》的進展，您將學習使用IDE的各個部分。
結構
您可以想到Arduino項目的結構，例如建筑物的腳手架。必須遵循特定的結構，否則所有結構都將崩潰（并且無法編譯）。
void setup（） { }
兩個大括號之間的所有代碼 { } 僅在Metro程序第一次運行時運行。
下載：file
復制代碼
void setup（） {
// put your setup code here， to run once
} void setup（） {
// put your setup code here， to run once
}
void loop（） { }
此功能在 void setup（）具有完成。它運行一次后，它將一次又一次地永遠運行，直到斷電為止。
下載：文件
復制代碼
void loop（） {
// put your main code here， to run repeatedly
} void loop（） {
// put your main code here， to run repeatedly
}
語法
其中一個稍微 令人沮喪 C的元素是其格式要求或語法。雖然令人沮喪，但這也使該語言非常強大。如果您還記得以下內容，則應該沒事：
// （單行注釋）
在編寫新草圖或查看舊草圖時，對標出您的想法很重要。為此，請輸入兩個正斜杠，直到行尾的所有內容都將被程序忽略。
下載：文件
復制代碼
// this is a comment， it won’t get run by the compiller
this is not a comment， it will cause an error when run！！ // this is a comment， it won‘t get run by the compiller
this is not a comment， it will cause an error when run！！
/* */ （多行注釋）
如果您有很多話要說，您可以使用多行注釋在多行上鍵入。這兩個符號之間的所有內容都將在程序中被忽略，就像單行注釋一樣。
下載：文件
復制代碼
/*
* Oh， hey！
* hi there！
*/ /*
* Oh， hey！
* hi there！
*/
{ } （卷曲括號）
這些用于標記代碼塊的開始和結束時間。您會看到它在函數和循環中使用。
下載：文件
復制代碼
void serialPrintHello （）
{ // code begins
Serial.println（“Hello”）;
} // code ends void serialPrintHello （）
{ // code begins
Serial.println（“Hello”）;
} // code ends
; （分號）
每行代碼必須必須結束用分號。缺少分號將導致您的代碼拒絕編譯。往往很難找到它們，將它們視為代碼的隱藏并尋求擁護者，而且很難忽略它們并導致錯誤。
下載：文件
復制代碼
// this will compile
int servoPin = 5;
// this won’t compile， it‘s missing a semicolon
int servoPin = 5 // this will compile
int servoPin = 5;
// this won’t compile， it‘s missing a semicolon
int servoPin = 5
變量
無非就是以智能方式移動數字的指令。變量用于移動。
int （整數）
主要功能。該整數以 2字節（或16位）的形式存儲數字。它沒有小數位，將存儲在-32，768和32，767之間的值。
下載：文件
復制代碼
// this makes the variable i store the value 2
int i = 2; // this makes the variable i store the value 2
int i = 2;
long
當整數不夠大時使用long。占用 4字節（32位）RAM，并且其范圍比整數大：-2，147，483，648和2，147，483，647之間。
下載：文件
復制代碼
// this makes the variable j store the value 2000083647
j = 2000083647 // this makes the variable j store the value 2000083647
j = 2000083647
bool （布爾值）
布爾值是一個簡單的變量，可以為True或False。真對應于位“ 1”，假對應于位“ 0”，它僅是一位。
下載：文件
復制代碼
// let’s make a boolean called openSource and
// set it to True
bool openSource = True;
// now let‘s make a variable called closedSource and
// set it to False
bool closeDSource = False; // let’s make a boolean called openSource and
// set it to True
bool openSource = True;
// now let‘s make a variable called closedSource and
// set it to False
bool closeDSource = False;
float
用于浮點運算，例如小數。 Pi是一個超長十進制數3.1415 。。.，但可以將其表示為浮點數，以使其具有更高的精度（3.14比僅3精度更高）。它占用4個字節（32位）的RAM，范圍在-3.4028235E + 38和3.4028235E + 38之間。
下載：文件
復制代碼
// integers can’t store decimal points
int pi = 3;
// so we use a float！
float pi = 3.14; // integers can‘t store decimal points
int pi = 3;
// so we use a float！
float pi = 3.14;
char （字符）
存儲一個字符，使用ASCII碼（即“ A” = 65）。使用一個字節（8位）的RAM。 Metrohandles字符串是char數組。
下載：文件
復制代碼
// mychar stores the letter A， represented by an ascii value of 65
char myChar = ’A‘; // mychar stores the letter A， represented by an ascii value of 65
char myChar = ’A‘;
數學
現在我們可以將數字存儲在變量中了，我們將要對其進行操作：
=（等于）
使某些東西與其他東西相等。
下載：文件
復制代碼
// b equals one
int b = 1;
// now， the value stored in b equals b times 2， which is one
b = b * 2; // b equals one
int b = 1;
// now， the value stored in b equals b times 2， which is one
b = b * 2;
％（模）
給出除法運算的其余部分。
下載：文件
復制代碼
// 12 divided by 10 = 1.2， modulo （%） will give us the remainder only
int mod = 12%10
// the value stored in int mod now equals 2 // 12 divided by 10 = 1.2， modulo （%） will give us the remainder only
int mod = 12%10
// the value stored in int mod now equals 2
+（加法）
將兩個數字加在一起。
下載：文件
復制代碼
int i = 2+2
// the value stored in int i now equals 4 int i = 2+2
// the value stored in int i now equals 4
-（減法）
從另一個數字中減去一個數字。
下載：文件
復制代碼
int f = 4-2
// the value stored in int f now equals 2 int f = 4-2
// the value stored in int f now equals 2
*（乘法）
將兩個數字相乘。
下載：文件
復制代碼
int z = 5*2
// the value stored in int z now equals 10 int z = 5*2
// the value stored in int z now equals 10
/（部門）
劃分兩個數字。
下載：文件
復制代碼
int y = 10/2
// the value stored in int y now equals 5 int y = 10/2
// the value stored in int y now equals 5
控制流程
程序能夠控制執行流程（下一步運行）。這些是您應該熟悉的幾個基本元素：
If 條件
如果條件為真，則將在花括號之間執行代碼如果條件也為假，它將測試else條件，否則將執行else代碼。
下載：file
復制代碼
int i = 0;
if（i 》 5） {
// this code does not execute， i is not greater than 5
}
else if （i 》 2） {
// this code also does not execute， i is not greater than 2
}
else {
// this code DOES execute， i is none of the above， so it falls into
// this category
} int i = 0;
if（i 》 5） {
// this code does not execute， i is not greater than 5
}
else if （i 》 2） {
// this code also does not execute， i is not greater than 2
}
else {
// this code DOES execute， i is none of the above， so it falls into
// this category
}
for（） 循環
在您要重復一段代碼多次（可以遞增i ++或遞減i--或使用任何變量）。
下載：file
復制代碼
for （int i = 1; i 《 5; i++） {
// this code will run 4 times
} for （int i = 1; i 《 5; i++） {
// this code will run 4 times
}
數字輸入/輸出
Metro（或Metro Express）的右側有一個標頭，其中包含13個數字引腳。這些引腳可以設置為0到1023之間的數字值。以下命令僅與這些引腳有關：
pinMode（pin， mode）
用于設置引腳的模式。
Pin是您要尋址的PIN碼，數字0-19。您還可以在模擬引腳0-5上設置數字pinMode。 0-5的映射為14-19。
模式可以設置為 INPUT 或 OUTPUT
下載：文件
復制代碼
// a red LED is connected on Pin #11
int redLedPin = 11;
void setup（）
{
// set the red LED as an OUTPUT
pinMode（redLedPin， OUTPUT）;
} // a red LED is connected on Pin #11
int redLedPin = 11;
void setup（）
{
// set the red LED as an OUTPUT
pinMode（redLedPin， OUTPUT）;
}
digitalWrite（pin， value）
如果使用pinMode將引腳設置為 OUTPUT ，則可以將其設置為 HIGH或低電平。將引腳設置為高會將其上拉至+ 3.3V或+ 5V。將其設置為低將使其接地，或為零伏。
下載：file
復制代碼
// this code will flash the LED on and off forever
void loop（）
{
// set the pin high to turn ON the LED
digitalWrite（redLedPin， HIGH）;
delay（500）;
// set the pin low to turn OFF the LED
digitalWrite（redLedPin， LOW）;
delay（500）;
} // this code will flash the LED on and off forever
void loop（）
{
// set the pin high to turn ON the LED
digitalWrite（redLedPin， HIGH）;
delay（500）;
// set the pin low to turn OFF the LED
digitalWrite（redLedPin， LOW）;
delay（500）;
}
digitalRead（pin）
將圖釘設置為輸入后，您可以使用它返回高（拉至+5伏）還是低（拉至地面）。
下載：文件
復制代碼
// this will store the value of sensorPin in an integer called sensorValue
int sensorValue = digitalRead（sensorPin）; // this will store the value of sensorPin in an integer called sensorValue
int sensorValue = digitalRead（sensorPin）;
模擬輸入/輸出
盡管Metro是數字板，但它能夠做模擬操作。這對于獲取精確的傳感器值很有用。 以下是處理非數字化內容的方法：
analogWrite（pin， value）
在“引擎蓋”的技巧，Metro能夠通過脈沖寬度調制寫入模擬值。您可以寫入0到255之間的任何值。
下載：文件
復制代碼
void loop（）
{
// set the LED to full brightness
analogWrite（ledPin， 255）;
// turn the LED off
analogWrite（ledPin， 0）;
} void loop（）
{
// set the LED to full brightness
analogWrite（ledPin， 255）;
// turn the LED off
analogWrite（ledPin， 0）;
}
analogRead（pin）
讀取模擬引腳的值。返回的值可以在0到1024之間。
下載：文件
復制代碼
sensorVal = analogRead（sensorPin）; sensorVal = analogRead（sensorPin）;
下載
實驗者指南提供了可用的源代碼和面包板圖，可在我們的GitHub上免費下載：
貼圖
我們使用開源工具Fritzing設計了您在本指南中看到的面包板布局圖。如果要查看或修改這些模板中的任何一個，請單擊下面的按鈕：
注意：大多數圖都包含用于Fritzing的組件從Adafruit Fritzing零件/板庫中獲得。您需要下載并安裝此訂單才能編輯圖表。
實驗者指南的面包板裝飾圖
代碼
Metro Explorers Guide Code
存儲在github Githubrepository中的所有本指南代碼的最新版本。隨時向該存儲庫提交問題，貢獻，請求和修改，我們將回答您在社區支持論壇中遇到的任何問題。
我擁有什么板？
本指南旨在與Metro和Metro Express一起使用。判斷您的木板是否是快遞的主要方法是在木板上說“表達”。 Metro Express的底部還有一個SWD端口，該端口不在Metro上。下圖指出了這兩個區別：
我有地鐵
此指南將在不做任何修改的情況下正常工作，請按照常規步驟進行操作，并玩得開心！
我有Metro Express
在閱讀本指南時，有兩件事需要注意：
1）接線：有些電路有一個額外的接線頁面，稱為“ Metro Express接線”，有些則沒有。如果您要查找的電路沒有此子頁面，請使用常規的Metro接線。如果您看到“ Metro Express接線”頁面，請使用該頁面中的接線代替。
2）代碼：如果需要對以下內容進行修改Metro Express的代碼，將顯示將代碼切換為Metro Express兼容代碼的說明。
設置Metro
MetroX Classic/Express Kit用戶：您設置了嗎？
如果尚未組裝Metro或Metro Express，半尺寸面包板和安裝板，請單擊此處獲取說明
您需要一個Adafruit Metroor Metro Express。
如果您沒有購買Metro實驗者工具包，則可能要購買一塊半尺寸的面包板和用于面包板的塑料安裝板。
USB Mi cro電纜
我對此壓力還不夠。 確保您的USB電纜連接良好。頑皮的USB電纜會真的毀了您的一天，就像鞋子上的石頭一樣。扔掉不良的電纜，并用優質的電纜代替它們-它們的用途是一次性的！
許多人有問題，因為他們選擇了“僅充電”的USB電纜，而不是“數據/同步”的電纜。絕對確保您擁有高質量的同步電纜。如果遇到問題，很可能會使用僅可充電的電纜。
為Metro供電！
如果您有Metro，那么接下來的這些步驟將使您在Arduino環境中進行設置。如果不確定所用的板子，請單擊此處。
將USB Micro電纜連接到Metro的USB端口。 打開 LED應變為穩定的綠色，并保持點亮狀態。
Arduino Bootloader檢查。
接下來，您要檢查Metro是否使用Arduino編程引導加載程序，這是使用所必需的。
插入電源（確保打開 LED指示燈已打開）時，迅速按一下“重置” 按鈕。您會看到它快速閃爍 3 次。它的發生速度非常快，因此請不要擔心是否看不到所有三個閃爍。
下載Arduino軟件
這是免費應用程序，您將使用該應用程序編寫程序并進行交談到您的地鐵。以下是大多數操作系統上的安裝說明（以及運行CodeBender的Chromebook用戶的瀏覽器！）。
轉到官方Arduino軟件頁面
點擊單擊上面的按鈕轉到官方軟件頁面（https://www.arduino.cc/zh/Main/Software），您會看到一個類似以下的框：
上面的圖片顯示的是Arduino 1.8.3，但我看到了另一個版本。
別擔心，Arduino軟件在下常量修訂版，并且上面的屏幕截圖不代表最新版本。下載適合您平臺的版本。
Windows設置
適用于Windows的下載
使用 Windows Installer下載并安裝。 .zip文件（非管理員安裝）是不 推薦。
（Windows）安裝Arduino
單擊 Windows Installer 鏈接到下載安裝程序，然后雙擊以啟動它。
您可能會收到警告，詢問您是否確定要運行安裝程序。可以，單擊是
有一個開源許可證可以單擊。在默認位置安裝
您可以使用默認設置安裝選項
最后，將需要一兩分鐘來安裝
完成后，您將安裝軟件：
（Windows ）安裝驅動程序
根據您的Arduino兼容，您可能需要為USB到串行轉換器安裝單獨的驅動程序
對于所有Adafruit兼容產品，我們都有多合一安裝程序，它將安裝所有Adafruit板驅動程序。它還將安裝FTDI和CP210x驅動程序
點擊下面下載我們的驅動程序安裝程序：
下載Adafruit Boards Windows驅動程序安裝程序
下載并運行安裝程序
運行安裝程序！由于我們也捆綁了SiLabs和FTDI驅動程序，因此您需要單擊許可證
選擇要安裝的驅動程序（建議選擇所有這些，這樣您就不必在開始探索其他Arduino兼容產品時就不必擔心安裝驅動程序了。
點擊安裝進行安裝’
您不需要重新啟動計算機，但這不是壞的主意！/p》
（Windows）查找您的串行COM端口
要驗證您的Arduino驅動程序是否正確安裝，請將其插入USB并打開設備管理器。您可以在控制面板（搜索設備管理器）中找到設備管理器
打開設備管理器時，找到名為 Ports 的部分并將其展開：
您會在一些顯示的文本旁邊看到一個圖標》 Arduino UNO（COMxx），其中 xx 是數字
如果您有Metro，它不會說Arduino UNO，而只是說 USB串行端口（COMxx）
COM號可能會有所不同，但應該類似于 COM3 或 COM4 。 COM代表“通信”，每個都有一個唯一的編號，稱為COM端口號。在這種情況下，COM端口號為COM18。
您可以拔下Arduino，以查看COM端口設備消失并在插入時重新出現。
如果您 don ‘t 看到Arduino出現，請檢查：
您的電纜是數據電纜還是僅可充電？嘗試使用另一條USB電纜
嘗試使用另一條USB端口！
驗證是否已安裝驅動程序，您隨時可以嘗試再次安裝它們（從不傷人）
檢查Arduino不需要其他驅動程序，您的供應商可以在必要時為您提供正確的驅動程序
Mac設置
下載macOS或OS X
下載Mac OS X的版本，解壓縮.zip文件，然后將“應用程序”拖出文件夾。
（macOS/OS X）安裝Arduino
點擊 Mac OS X安裝程序鏈接以下載安裝程序
然后雙擊以展開/啟動它
它將自動為您提供 Arduino應用藍綠色圖標：
（macOS/OS X）找到您的串行端口
現在，我們要確保您的Metro與計算機正確通信。在您的應用程序文件夾中，找到實用程序文件夾，然后雙擊它。
然后，找到名為“終端” 的應用程序。雙擊以打開它：
終端打開后，系統會提示您。在其中鍵入以下內容：
ls /dev/cu*
鍵入后，您應該會看到一行包含文本 /dev/cu.usbmodemxxxx OR /dev/cu.usbserial-xxxxx 。 xxxx的可以是任何字母或數字。如果看到此消息，則說明驅動程序已正確安裝，并且在計算機上已找到Metro。
如果您不習慣使用Terminal，則還有另一種（更簡便的）方法檢查所有東西是否都已正確安裝。點擊菜單欄上的蘋果圖標。在下拉菜單中，單擊關于本機。
然后，單擊系統報告。 System Profiler將打開，然后在硬件下拉菜單中單擊 USB 。您應該將Adafruit Metro 328視為USB設備之一。
（macOS/OS X）安裝驅動程序
下一步，您將要獲取并安裝FTDI VCP驅動程序和SiLabs CP210x驅動程序。
首先，導航至FTDI VCP站點并獲取適用于您的OS X版本和平臺的驅動程序。
然后解壓縮文件并安裝.dmg文件。
您還將需要SiLabs CP210x驅動程序。您可以從SiLabs網站獲得它們。
然后解壓縮文件并安裝.dmg文件。
驗證macOS/OS XDrivers
我們只想驗證所有設置是否正確。插入Metro Classic，然后打開Arduino IDE并導航到工具》端口。
您應該看到一個列為/dev/cu.usbserial 的設備，其后是數字和/或字母。這是您的Metro Classic。
如果看不到此內容，請確保正確安裝了FTDI和SILabs驅動程序（適用于正確的OS版本和平臺）。然后，檢查您正在使用的USB端口（嘗試另一個端口）或電纜（您可能正在使用僅充電電纜）。
Linux設置
Linux版下載
32位和64位Linux都有下載選項。下載所用系統的版本，手動解壓縮.tar文件，然后安裝軟件。
（Linux）安裝Arduino
單擊匹配的 Linux Installer 鏈接（32位，64位或ARM）下載安裝程序-將文件保存到“下載”文件夾中
從終端程序中， cd 到下載目錄，然后用 tar xf arduino * .xz 解壓縮該軟件包，然后 cd 進入創建的 arduino-nnn 文件夾：
運行 。/install.sh 以安裝軟件。我安裝了舊的Ubuntu，因此收到警告，但確實為我創建了該桌面圖標！
（Linux）安裝驅動程序
Linux不會”假設您運行的是v2.6或更高版本的內核，則無需安裝任何驅動程序，這幾乎可以肯定。這些說明假定您正在運行Ubuntu。每個Linux發行版都不同，但是其他發行版的說明應該足夠基本。
您可以通過在終端窗口中運行 uname -a 來驗證內核版本，請注意該內核是版本 2.6.20
，而該內核是 3.2.0-23
一些較舊的Linux發行版用于安裝 brltty （盲文設備），這會與Arduino發生沖突。 如果已安裝Brltty，則必須將其卸載！請通過在終端窗口中運行sudo apt-get remove brltty 或同等功能來卸載。如果它說沒有安裝，那就可以了。如果您沒有運行Debian衍生的安裝程序，請使用必要的工具來驗證您是否沒有 brltty 運行
（Linux）在Arduino中找到您的串行端口
，確認綠色LED點亮，然后在終端窗口中輸入 ls/dev/ttyUSB * ，您應該會看到一個名為ttyUSB0的設備文件
如果您似乎找不到它，請使用 dmesg |在插入Arduino之后立即查找尾部，并尋找有關將設備文件放置在何處的提示。例如，這里說串行設備轉換器現在已連接到ttyUSB0
如果您看到類似這樣的內容
［ 1900.712000］ ftdi_sio 2-10:1.0： FTDI USB Serial Device converter detected
［ 1900.712000］ drivers/usb/serial/ftdi_sio.c： Detected FT232BM
［ 1900.712000］ usb 2-10： FTDI USB Serial Device converter now attached to ttyUSB0
［ 1901.868000］ usb 2-10： usbfs： interface 0 claimed by ftdi_sio while ’brltty‘ sets config #1
［ 1901.872000］ ftdi_sio ttyUSB0： FTDI USB Serial Device converter now disconnected from ttyUSB0
［ 1901.872000］ ftdi_sio 2-10:1.0： device disconnected
這意味著您尚未卸載 brltty ，應重試。
為Metro Express配置Arduino
此頁面僅適用于Metro EXPRESS用戶，如果您使用的是常規Metro，則可以忽略此頁面。
如果您已按照“設置Metro Express”頁面進行操作，則應該準備好滾。我們需要對Arduino進行一些修改，以使其能夠與Metro Express一起使用。
Metro Express Arduino IDE設置
下載并安裝最新版本的Arduino IDE 后，您可以將需要啟動IDE并導航到首選項菜單。您可以通過 Windows 或 Linux 中的 File 菜單或 OS上的 Arduino 菜單訪問它X 。
將彈出一個對話框，如下所示。
我們將向新的其他董事會管理器URL 選項中添加一個URL。 URL列表以逗號分隔，您只需添加一次每個URL。新的Adafruit開發板和對現有開發板的更新將在每次打開時由開發板管理器自動提取。這些URL指向Board Manager用來建立可用和已安裝板列表的索引文件。
要查找可以添加的URL的最新列表，您可以訪問第三方板列表Arduino IDE Wiki上的URL。在此示例中，我們只需要向IDE添加一個URL，但是 您可以通過用逗號分隔 來添加多個URL。將下面的鏈接復制并粘貼到Arduino IDE首選項的 Additional Boards Manager URLs 選項中。
https://adafruit.github.io/arduino-board-index/package_adafruit_index.json
以下是每個Adafruit提供的軟件包的簡短說明，當您添加URL時，它們將在Board Manager中可用：
Adafruit AVR Boards -包括對Flora，Gemma，Feather 32u4，Trinket和Trinket Pro的支持。
Adafruit SAMD板-包括對Feather M0，Metro M0，Circuit Playground Express的支持，Gemma M0和Trinket M0
Arduino Leonardo和Micro MIDI-USB -使用arcore項目為Flora，Feather 32u4，Micro和Leonardo添加了USB over MIDI支持。/li》
如果要支持多個開發板，例如ESP8266和Adafruit，請在文本框中輸入兩個URL，并用逗號（，）隔開
完成后，單擊確定以保存新的偏好設置。接下來，我們將研究使用Board Manager安裝板。
現在繼續下一步，實際安裝板支持包！
在Arduino IDE中使用Metro Express
自Metro Express開始M0使用運行在48 MHz的ATSAMD21芯片，您可以很容易地使其與Arduino IDE一起使用。大多數庫（包括諸如NeoPixels和display之類的流行庫）都可以與M0一起使用，尤其是使用i2c或SPI的設備和傳感器。
現在，您已經在Arduino IDE首選項中添加了適當的URL。在上一頁中，可以通過導航到工具-》委員會菜單來打開委員會管理器。
董事會管理器打開后，點擊窗口左上角的類別下拉菜單，然后選擇已貢獻。然后，您將能夠選擇并安裝由添加到首選項中的URL提供的木板。
安裝SAMD支持
首先，安裝 Arduino SAMD開發板版本 1.6.15 或更高版本
您可以在頂部搜索欄中鍵入 Arduino SAMD ，然后在看到該條目時，單擊安裝
安裝Adafruit SAMD
接下來，您可以安裝Adafruit SAMD軟件包以添加板文件定義
您可以鍵入 Adafruit SAMD ”，然后在看到條目時，單擊安裝
即使從理論上講您不會不需要-我建議重新啟動IDE
退出并重新打開Arduino IDE ，以確保所有板卡均已正確安裝。現在，您應該能夠選擇并上傳到工具-》面板菜單中列出的新面板。
從下拉列表中選擇 Adafruit Metro M0 Express 。
CIRC01：LED閃爍
我們在做什么
LED（發光二極管）用于各種聰明的事情，這就是為什么我們將它們包括在本指南中的原因。我們將以一個非常簡單的開始，反復打開和關閉，以產生令人愉快的閃爍效果。首先，請從零件頁面中獲取零件，然后根據布局圖插入所有零件。
零件
讓我們首先收集我們的部分：
10mm藍色LED
如果您想從Adafruit商店訂購更多這些10mm LED，請單擊此處！
560歐姆電阻
顏色：綠色》藍色》棕色
如果您想從Adafruit商店訂購更多電阻，請單擊此處！ （它們的電阻為470歐姆，但可以用）
面包板接線束
如果您想從Adafruit商店訂購更多電線，請單擊此處！
Adafruit Metro（或Metro Express）+面包板+安裝板
如果您尚未組裝，我們將為您提供方便的指南！
如果d想從Adafruit商店訂購額外的塑料安裝板，Adafruit Metro，AdafruitMetro Express或Mini-Breadboard，請點擊此處！
接線
面包板布局
將部件連接到面包板上，如下所示。
步驟
將LED的較長的一端連接到Metro上的 Pin13 。較短的導線應通過電阻器連接到接地端子。
Metro能夠為面包板提供5V電壓。使用紅色電線將Metro上的 5V引腳連接到面包板的左側電源導軌。將Metro的 GND引腳連接到電源軌的最右側。
將560 Ohm電阻器的一根分支連接到電源的較短分支。電阻。該電阻的另一端用黑色電線連接到電源軌（這將是您的地線）。
您完成的電路應該與上面的布局相同。繼續操作之前，請確保驗證所有連接。
Breadboard布局表
每個電路都附帶一個可打印的布局表，以放置在迷你面包板上。您可以使用標題（或磁帶）來壓住它們，如下所示：
單擊此處下載適用于CIRC01的可打印面包板布局表
代碼
Arduino編輯器提供了一個使LED閃爍的好例子。無需輸入任何內容，只需在Arduino編輯器中單擊以下內容： File》 Examples》 1.Basic》 Blink
接下來，我們希望Arduino知道什么當前正在使用板。為此，請導航至工具》板》 Arduino/Genuino Uno
最后，我們需要上傳程序。為此，請將Metroboard插入USB端口。然后在工具》串行端口》（您的Metro的串行/COM端口）中選擇適當的端口。接下來，通過轉到文件》上傳（或按鍵盤上的 ctrl + u ）
上傳該程序。到Metro上，您應該會看到Metro和面包板上的LED閃爍。
Blink
如果無法從Arduino的示例加載Blink Sketch，可以將以下代碼復制并粘貼到編輯器中。
下載：項目Zip 或 CIRC01_BLINK_LED.ino | 在Github上查看
復制代碼
/*
Blink
Turns on an LED on for one second， then off for one second， repeatedly.
Most Arduinos have an on-board LED you can control. On the UNO， MEGA and ZERO
it is attached to digital pin 13， on MKR1000 on pin 6. LED_BUILTIN is set to
the correct LED pin independent of which board is used.
If you want to know what pin the on-board LED is connected to on your Arduino model， check
the Technical Specs of your board at https://www.arduino.cc/en/Main/Products
This example code is in the public domain.
modified 8 May 2014
by Scott Fitzgerald
modified 2 Sep 2016
by Arturo Guadalupi
modified 8 Sep 2016
by Colby Newman
*/
// the setup function runs once when you press reset or power the board
void setup（） {
// initialize digital pin LED_BUILTIN as an output.
pinMode（LED_BUILTIN， OUTPUT）;
}
// the loop function runs over and over again forever
void loop（） {
digitalWrite（LED_BUILTIN， HIGH）; // turn the LED on （HIGH is the voltage level）
delay（1000）; // wait for a second
digitalWrite（LED_BUILTIN， LOW）; // turn the LED off by making the voltage LOW
delay（1000）; // wait for a second
}
/*
Blink
Turns on an LED on for one second， then off for one second， repeatedly.
Most Arduinos have an on-board LED you can control. On the UNO， MEGA and ZERO
it is attached to digital pin 13， on MKR1000 on pin 6. LED_BUILTIN is set to
the correct LED pin independent of which board is used.
If you want to know what pin the on-board LED is connected to on your Arduino model， check
the Technical Specs of your board at https://www.arduino.cc/en/Main/Products
This example code is in the public domain.
modified 8 May 2014
by Scott Fitzgerald
modified 2 Sep 2016
by Arturo Guadalupi
modified 8 Sep 2016
by Colby Newman
*/
// the setup function runs once when you press reset or power the board
void setup（） {
// initialize digital pin LED_BUILTIN as an output.
pinMode（LED_BUILTIN， OUTPUT）;
}
// the loop function runs over and over again forever
void loop（） {
digitalWrite（LED_BUILTIN， HIGH）; // turn the LED on （HIGH is the voltage level）
delay（1000）; // wait for a second
digitalWrite（LED_BUILTIN， LOW）; // turn the LED off by making the voltage LOW
delay（1000）; // wait for a second
}
CIRC01是否有問題？
LED不亮？
LED僅在一個方向上工作tion。嘗試將其取出并扭曲180度。 （不必擔心，向后安裝它不會造成永久損害）。
程序未上傳？
有時會發生這種情況，最可能的原因是串行端口混亂，您可以在 tools》串行端口》
仍然沒有成功嗎？
斷路不好玩，請在Adafruit支持論壇中發布，我們會盡快與您聯系。
變得更好
恭喜您使用Adafruit Metro構建了您的第一個賽道！
讓我們一起努力，使您的賽道變得更好，并了解一些以后將很有用的技巧/提示。
更換針腳
LED已連接到引腳13，但我們可以使用METRO的任何引腳。要進行更改，可以將電線插入插針13中，然后將其移至您選擇的插針中（從0到13）。
您也可以使用模擬0-5，模擬＃0為14，模擬＃1是15，等等。
然后在代碼中更改所有出現的LED_BUILTIN-》 newpin 。也就是說，將每個LED_BUILTIN更改為8
，然后上傳草圖：按 ctrl + u
更改閃爍時間
一秒鐘一秒鐘不滿意？在代碼中更改以下行：
digitalWrite（LED_BUILTIN， HIGH）;
delay（time on）; //（seconds * 1000）
digitalWrite（LED_BUILTIN， LOW）;
delay（time off）; //（seconds * 1000）
控制亮度
帶有數字（在/off）控制METRO可以模擬（亮度）方式控制某些引腳。 （有關更多細節，請參見后面的電路）。一起玩吧。通過將所有LED_BUILTIN替換為9
，將LED更改為引腳9 ：（也請更改導線）替換 { } 的 loop（）帶有以下行：
analogWrite（9， new number）;
注意在上面的行中，
new number是介于0到255之間的任何數字。0會完全關閉LED。 255是LED的最大亮度。 0到255之間的任何值都是變化的亮度。隨便找一個喜歡的人。
衰落
我們將使用另一個附帶的示例程序。要打開，請轉到文件》示例》 3.模擬》褪色
然后上傳到您的板上，觀察LED漸入漸出。
CIRC02：8個LED有趣
我們在做什么
我們使一個LED閃爍，現在是時候賭注了。讓我們連接八個。我們還將有機會通過創建各種照明序列來擴展Metroa。該電路也是一個不錯的設置，可以嘗試編寫自己的程序并了解Metro的工作原理。
在控制LED的過程中，我們開始研究一些簡單的編程方法以使程序保持小尺寸：for（）循環和array［］的
零件
5mm綠色LED
x8（CIRC02需要8個）
如果您想從Adafruit商店訂購額外的綠色LED，請單擊此處！
560歐姆電阻
x8（對于CIRC02，您需要其中8個電阻）
（它們是相同的您在CIRC01中使用的電阻器，顏色來自：綠色》藍色》棕色）
如果您想從Adafruit商店訂購更多電阻器，請單擊此處！ （它們的電阻為470歐姆，但可以用）
面包板接線束
如果您想從Adafruit商店訂購更多電線，請單擊此處！
Adafruit Metro（或Metro Express）+面包板+安裝板
如果您尚未組裝，我們將為您提供方便的指南！
如果d想從Adafruit商店訂購額外的塑料安裝板，Adafruit Metro，AdafruitMetro Express或Mini-Breadboard，請點擊此處！
接線
面包板布局
步驟
首先，將8個綠色LED連接到面包板上。如布局圖中所示，將它們隔開一個孔非常有用。
接下來，從底部的綠色LED開始，將綠色LED的較長邊連接到地鐵上的數字引腳。從 Pin 2 開始，一直到 Pin 9 。（提示：使用不同的顏色線對您的LED進行顏色編碼）
然后，連接8個（560ohm）電阻連接到LED的較短一側。
Metro能夠為面包板提供5V電壓。使用紅色電線將Metro上的 5V引腳連接到面包板的左側電源導軌。將Metro的 GND引腳連接到電源軌的最右側。
完成的電路應與上面的布局相同。繼續操作之前，請確保驗證所有連接。
單擊此處下載適用于CIRC02的可打印面包板布局表
代碼
CIRC02代碼不是默認的Arduino草圖之一。要使用它，請從下面復制代碼并將其粘貼到新的Arduino Sketch （ctrl + n/command + n）
下載：Project Zip 或 CIRC02_8_LEDS.ino | 在Github上查看
復制代碼
/* ---------------------------------------------------------
* | Arduino Experimentation Kit Example Code |
* | CIRC-02 。： 8 LED Fun ：。 （Multiple LEDs） |
* ---------------------------------------------------------
*
* A few Simple LED animations
*
* For more information on this circuit http://tinyurl.com/d2hrud
*
*/
//LED Pin Variables
int ledPins［］ = {2，3，4，5，6，7，8，9}; //An array to hold the pin each LED is connected to
//i.e. LED #0 is connected to pin 2， LED #1， 3 and so on
//to address an array use ledPins［0］ this would equal 2
//and ledPins［7］ would equal 9
/*
* setup（） - this function runs once when you turn your Arduino on
* We the three control pins to outputs
*/
void setup（）
{
//Set each pin connected to an LED to output mode （pulling high （on） or low （off）
for（int i = 0; i 《 8; i++）{ //this is a loop and will repeat eight times
pinMode（ledPins［i］，OUTPUT）; //we use this to set each LED pin to output
} //the code this replaces is below
/* （commented code will not run）
* these are the lines replaced by the for loop above they do exactly the
* same thing the one above just uses less typing
pinMode（ledPins［0］，OUTPUT）;
pinMode（ledPins［1］，OUTPUT）;
pinMode（ledPins［2］，OUTPUT）;
pinMode（ledPins［3］，OUTPUT）;
pinMode（ledPins［4］，OUTPUT）;
pinMode（ledPins［5］，OUTPUT）;
pinMode（ledPins［6］，OUTPUT）;
pinMode（ledPins［7］，OUTPUT）;
（end of commented code）*/
}
/*
* loop（） - this function will start after setup finishes and then repeat
* we call a function called oneAfterAnother（）。 if you would like a different behaviour
* uncomment （delete the two slashes） one of the other lines
*/
void loop（） // run over and over again
{
oneAfterAnotherNoLoop（）; //this will turn on each LED one by one then turn each off
//oneAfterAnotherLoop（）; //does the same as oneAfterAnotherNoLoop but with
//much less typing
//oneOnAtATime（）; //this will turn one LED on then turn the next one
//on turning the
//former off （one LED will look like it is scrolling
//along the line
//inAndOut（）; //lights the two middle LEDs then moves them out then back
//in again
}
/*
* oneAfterAnotherNoLoop（） - Will light one LED then delay for delayTime then light
* the next LED until all LEDs are on it will then turn them off one after another
*
* this does it without using a loop which makes for a lot of typing.
* oneOnAtATimeLoop（） does exactly the same thing with less typing
*/
void oneAfterAnotherNoLoop（）{
int delayTime = 100; //the time （in milliseconds） to pause between LEDs
//make smaller for quicker switching and larger for slower
digitalWrite（ledPins［0］， HIGH）; //Turns on LED #0 （connected to pin 2 ）
delay（delayTime）; //waits delayTime milliseconds
digitalWrite（ledPins［1］， HIGH）; //Turns on LED #1 （connected to pin 3 ）
delay（delayTime）; //waits delayTime milliseconds
digitalWrite（ledPins［2］， HIGH）; //Turns on LED #2 （connected to pin 4 ）
delay（delayTime）; //waits delayTime milliseconds
digitalWrite（ledPins［3］， HIGH）; //Turns on LED #3 （connected to pin 5 ）
delay（delayTime）; //waits delayTime milliseconds
digitalWrite（ledPins［4］， HIGH）; //Turns on LED #4 （connected to pin 6 ）
delay（delayTime）; //waits delayTime milliseconds
digitalWrite（ledPins［5］， HIGH）; //Turns on LED #5 （connected to pin 7 ）
delay（delayTime）; //waits delayTime milliseconds
digitalWrite（ledPins［6］， HIGH）; //Turns on LED #6 （connected to pin 8 ）
delay（delayTime）; //waits delayTime milliseconds
digitalWrite（ledPins［7］， HIGH）; //Turns on LED #7 （connected to pin 9 ）
delay（delayTime）; //waits delayTime milliseconds
//Turns Each LED Off
digitalWrite（ledPins［7］， LOW）; //Turns on LED #0 （connected to pin 2 ）
delay（delayTime）; //waits delayTime milliseconds
digitalWrite（ledPins［6］， LOW）; //Turns on LED #1 （connected to pin 3 ）
delay（delayTime）; //waits delayTime milliseconds
digitalWrite（ledPins［5］， LOW）; //Turns on LED #2 （connected to pin 4 ）
delay（delayTime）; //waits delayTime milliseconds
digitalWrite（ledPins［4］， LOW）; //Turns on LED #3 （connected to pin 5 ）
delay（delayTime）; //waits delayTime milliseconds
digitalWrite（ledPins［3］， LOW）; //Turns on LED #4 （connected to pin 6 ）
delay（delayTime）; //waits delayTime milliseconds
digitalWrite（ledPins［2］， LOW）; //Turns on LED #5 （connected to pin 7 ）
delay（delayTime）; //waits delayTime milliseconds
digitalWrite（ledPins［1］， LOW）; //Turns on LED #6 （connected to pin 8 ）
delay（delayTime）; //waits delayTime milliseconds
digitalWrite（ledPins［0］， LOW）; //Turns on LED #7 （connected to pin 9 ）
delay（delayTime）; //waits delayTime milliseconds
}
/*
* oneAfterAnotherLoop（） - Will light one LED then delay for delayTime then light
* the next LED until all LEDs are on it will then turn them off one after another
*
* this does it using a loop which makes for a lot less typing.
* than oneOnAtATimeNoLoop（） does exactly the same thing with less typing
*/
void oneAfterAnotherLoop（）{
int delayTime = 100; //the time （in milliseconds） to pause between LEDs
//make smaller for quicker switching and larger for slower
//Turn Each LED on one after another
for（int i = 0; i 《= 7; i++）{
digitalWrite（ledPins［i］， HIGH）; //Turns on LED #i each time this runs i
delay（delayTime）; //gets one added to it so this will repeat
} //8 times the first time i will = 0 the final
//time i will equal 7;
//Turn Each LED off one after another
for（int i = 7; i 》= 0; i--）{ //same as above but rather than starting at 0 and counting up
//we start at seven and count down
digitalWrite（ledPins［i］， LOW）; //Turns off LED #i each time this runs i
delay（delayTime）; //gets one subtracted from it so this will repeat
} //8 times the first time i will = 7 the final
//time it will equal 0
}
/*
* oneOnAtATime（） - Will light one LED then the next turning off all the others
*/
void oneOnAtATime（）{
int delayTime = 100; //the time （in milliseconds） to pause between LEDs
//make smaller for quicker switching and larger for slower
for（int i = 0; i 《= 7; i++）{
int offLED = i - 1; //Calculate which LED was turned on last time through
if（i == 0） { //for i = 1 to 7 this is i minus 1 （i.e. if i = 2 we will
offLED = 7; //turn on LED 2 and off LED 1）
} //however if i = 0 we don’t want to turn of led -1 （doesn‘t exist）
//instead we turn off LED 7， （looping around）
digitalWrite（ledPins［i］， HIGH）; //turn on LED #i
digitalWrite（ledPins［offLED］， LOW）; //turn off the LED we turned on last time
delay（delayTime）;
}
}
/*
* inAndOut（） - This will turn on the two middle LEDs then the next two out
* making an in and out look
*/
void inAndOut（）{
int delayTime = 100; //the time （in milliseconds） to pause between LEDs
//make smaller for quicker switching and larger for slower
//runs the LEDs out from the middle
for（int i = 0; i 《= 3; i++）{
int offLED = i - 1; //Calculate which LED was turned on last time through
if（i == 0） { //for i = 1 to 7 this is i minus 1 （i.e. if i = 2 we will
offLED = 3; //turn on LED 2 and off LED 1）
} //however if i = 0 we don’t want to turn of led -1 （doesn‘t exist）
//instead we turn off LED 7， （looping around）
int onLED1 = 3 - i; //this is the first LED to go on ie. LED #3 when i = 0 and LED
//#0 when i = 3
int onLED2 = 4 + i; //this is the first LED to go on ie. LED #4 when i = 0 and LED
//#7 when i = 3
int offLED1 = 3 - offLED; //turns off the LED we turned on last time
int offLED2 = 4 + offLED; //turns off the LED we turned on last time
digitalWrite（ledPins［onLED1］， HIGH）;
digitalWrite（ledPins［onLED2］， HIGH）;
digitalWrite（ledPins［offLED1］， LOW）;
digitalWrite（ledPins［offLED2］， LOW）;
delay（delayTime）;
}
//runs the LEDs into the middle
for（int i = 3; i 》= 0; i--）{
int offLED = i + 1; //Calculate which LED was turned on last time through
if（i == 3） { //for i = 1 to 7 this is i minus 1 （i.e. if i = 2 we will
offLED = 0; //turn on LED 2 and off LED 1）
} //however if i = 0 we don’t want to turn of led -1 （doesn‘t exist）
//instead we turn off LED 7， （looping around）
int onLED1 = 3 - i; //this is the first LED to go on ie. LED #3 when i = 0 and LED
//#0 when i = 3
int onLED2 = 4 + i; //this is the first LED to go on ie. LED #4 when i = 0 and LED
//#7 when i = 3
int offLED1 = 3 - offLED; //turns off the LED we turned on last time
int offLED2 = 4 + offLED; //turns off the LED we turned on last time
digitalWrite（ledPins［onLED1］， HIGH）;
digitalWrite（ledPins［onLED2］， HIGH）;
digitalWrite（ledPins［offLED1］， LOW）;
digitalWrite（ledPins［offLED2］， LOW）;
delay（delayTime）;
}
}
/* ---------------------------------------------------------
* | Arduino Experimentation Kit Example Code |
* | CIRC-02 。： 8 LED Fun ：。 （Multiple LEDs） |
* ---------------------------------------------------------
*
* A few Simple LED animations
*
* For more information on this circuit http://tinyurl.com/d2hrud
*
*/
//LED Pin Variables
int ledPins［］ = {2，3，4，5，6，7，8，9}; //An array to hold the pin each LED is connected to
//i.e. LED #0 is connected to pin 2， LED #1， 3 and so on
//to address an array use ledPins［0］ this would equal 2
//and ledPins［7］ would equal 9
/*
* setup（） - this function runs once when you turn your Arduino on
* We the three control pins to outputs
*/
void setup（）
{
//Set each pin connected to an LED to output mode （pulling high （on） or low （off）
for（int i = 0; i 《 8; i++）{ //this is a loop and will repeat eight times
pinMode（ledPins［i］，OUTPUT）; //we use this to set each LED pin to output
} //the code this replaces is below
/* （commented code will not run）
* these are the lines replaced by the for loop above they do exactly the
* same thing the one above just uses less typing
pinMode（ledPins［0］，OUTPUT）;
pinMode（ledPins［1］，OUTPUT）;
pinMode（ledPins［2］，OUTPUT）;
pinMode（ledPins［3］，OUTPUT）;
pinMode（ledPins［4］，OUTPUT）;
pinMode（ledPins［5］，OUTPUT）;
pinMode（ledPins［6］，OUTPUT）;
pinMode（ledPins［7］，OUTPUT）;
（end of commented code）*/
}
/*
* loop（） - this function will start after setup finishes and then repeat
* we call a function called oneAfterAnother（）。 if you would like a different behaviour
* uncomment （delete the two slashes） one of the other lines
*/
void loop（） // run over and over again
{
oneAfterAnotherNoLoop（）; //this will turn on each LED one by one then turn each off
//oneAfterAnotherLoop（）; //does the same as oneAfterAnotherNoLoop but with
//much less typing
//oneOnAtATime（）; //this will turn one LED on then turn the next one
//on turning the
//former off （one LED will look like it is scrolling
//along the line
//inAndOut（）; //lights the two middle LEDs then moves them out then back
//in again
}
/*
* oneAfterAnotherNoLoop（） - Will light one LED then delay for delayTime then light
* the next LED until all LEDs are on it will then turn them off one after another
*
* this does it without using a loop which makes for a lot of typing.
* oneOnAtATimeLoop（） does exactly the same thing with less typing
*/
void oneAfterAnotherNoLoop（）{
int delayTime = 100; //the time （in milliseconds） to pause between LEDs
//make smaller for quicker switching and larger for slower
digitalWrite（ledPins［0］， HIGH）; //Turns on LED #0 （connected to pin 2 ）
delay（delayTime）; //waits delayTime milliseconds
digitalWrite（ledPins［1］， HIGH）; //Turns on LED #1 （connected to pin 3 ）
delay（delayTime）; //waits delayTime milliseconds
digitalWrite（ledPins［2］， HIGH）; //Turns on LED #2 （connected to pin 4 ）
delay（delayTime）; //waits delayTime milliseconds
digitalWrite（ledPins［3］， HIGH）; //Turns on LED #3 （connected to pin 5 ）
delay（delayTime）; //waits delayTime milliseconds
digitalWrite（ledPins［4］， HIGH）; //Turns on LED #4 （connected to pin 6 ）
delay（delayTime）; //waits delayTime milliseconds
digitalWrite（ledPins［5］， HIGH）; //Turns on LED #5 （connected to pin 7 ）
delay（delayTime）; //waits delayTime milliseconds
digitalWrite（ledPins［6］， HIGH）; //Turns on LED #6 （connected to pin 8 ）
delay（delayTime）; //waits delayTime milliseconds
digitalWrite（ledPins［7］， HIGH）; //Turns on LED #7 （connected to pin 9 ）
delay（delayTime）; //waits delayTime milliseconds
//Turns Each LED Off
digitalWrite（ledPins［7］， LOW）; //Turns on LED #0 （connected to pin 2 ）
delay（delayTime）; //waits delayTime milliseconds
digitalWrite（ledPins［6］， LOW）; //Turns on LED #1 （connected to pin 3 ）
delay（delayTime）; //waits delayTime milliseconds
digitalWrite（ledPins［5］， LOW）; //Turns on LED #2 （connected to pin 4 ）
delay（delayTime）; //waits delayTime milliseconds
digitalWrite（ledPins［4］， LOW）; //Turns on LED #3 （connected to pin 5 ）
delay（delayTime）; //waits delayTime milliseconds
digitalWrite（ledPins［3］， LOW）; //Turns on LED #4 （connected to pin 6 ）
delay（delayTime）; //waits delayTime milliseconds
digitalWrite（ledPins［2］， LOW）; //Turns on LED #5 （connected to pin 7 ）
delay（delayTime）; //waits delayTime milliseconds
digitalWrite（ledPins［1］， LOW）; //Turns on LED #6 （connected to pin 8 ）
delay（delayTime）; //waits delayTime milliseconds
digitalWrite（ledPins［0］， LOW）; //Turns on LED #7 （connected to pin 9 ）
delay（delayTime）; //waits delayTime milliseconds
}
/*
* oneAfterAnotherLoop（） - Will light one LED then delay for delayTime then light
* the next LED until all LEDs are on it will then turn them off one after another
*
* this does it using a loop which makes for a lot less typing.
* than oneOnAtATimeNoLoop（） does exactly the same thing with less typing
*/
void oneAfterAnotherLoop（）{
int delayTime = 100; //the time （in milliseconds） to pause between LEDs
//make smaller for quicker switching and larger for slower
//Turn Each LED on one after another
for（int i = 0; i 《= 7; i++）{
digitalWrite（ledPins［i］， HIGH）; //Turns on LED #i each time this runs i
delay（delayTime）; //gets one added to it so this will repeat
} //8 times the first time i will = 0 the final
//time i will equal 7;
//Turn Each LED off one after another
for（int i = 7; i 》= 0; i--）{ //same as above but rather than starting at 0 and counting up
//we start at seven and count down
digitalWrite（ledPins［i］， LOW）; //Turns off LED #i each time this runs i
delay（delayTime）; //gets one subtracted from it so this will repeat
} //8 times the first time i will = 7 the final
//time it will equal 0
}
/*
* oneOnAtATime（） - Will light one LED then the next turning off all the others
*/
void oneOnAtATime（）{
int delayTime = 100; //the time （in milliseconds） to pause between LEDs
//make smaller for quicker switching and larger for slower
for（int i = 0; i 《= 7; i++）{
int offLED = i - 1; //Calculate which LED was turned on last time through
if（i == 0） { //for i = 1 to 7 this is i minus 1 （i.e. if i = 2 we will
offLED = 7; //turn on LED 2 and off LED 1）
} //however if i = 0 we don’t want to turn of led -1 （doesn‘t exist）
//instead we turn off LED 7， （looping around）
digitalWrite（ledPins［i］， HIGH）; //turn on LED #i
digitalWrite（ledPins［offLED］， LOW）; //turn off the LED we turned on last time
delay（delayTime）;
}
}
/*
* inAndOut（） - This will turn on the two middle LEDs then the next two out
* making an in and out look
*/
void inAndOut（）{
int delayTime = 100; //the time （in milliseconds） to pause between LEDs
//make smaller for quicker switching and larger for slower
//runs the LEDs out from the middle
for（int i = 0; i 《= 3; i++）{
int offLED = i - 1; //Calculate which LED was turned on last time through
if（i == 0） { //for i = 1 to 7 this is i minus 1 （i.e. if i = 2 we will
offLED = 3; //turn on LED 2 and off LED 1）
} //however if i = 0 we don’t want to turn of led -1 （doesn‘t exist）
//instead we turn off LED 7， （looping around）
int onLED1 = 3 - i; //this is the first LED to go on ie. LED #3 when i = 0 and LED
//#0 when i = 3
int onLED2 = 4 + i; //this is the first LED to go on ie. LED #4 when i = 0 and LED
//#7 when i = 3
int offLED1 = 3 - offLED; //turns off the LED we turned on last time
int offLED2 = 4 + offLED; //turns off the LED we turned on last time
digitalWrite（ledPins［onLED1］， HIGH）;
digitalWrite（ledPins［onLED2］， HIGH）;
digitalWrite（ledPins［offLED1］， LOW）;
digitalWrite（ledPins［offLED2］， LOW）;
delay（delayTime）;
}
//runs the LEDs into the middle
for（int i = 3; i 》= 0; i--）{
int offLED = i + 1; //Calculate which LED was turned on last time through
if（i == 3） { //for i = 1 to 7 this is i minus 1 （i.e. if i = 2 we will
offLED = 0; //turn on LED 2 and off LED 1）
} //however if i = 0 we don’t want to turn of led -1 （doesn‘t exist）
//instead we turn off LED 7， （looping around）
int onLED1 = 3 - i; //this is the first LED to go on ie. LED #3 when i = 0 and LED
//#0 when i = 3
int onLED2 = 4 + i; //this is the first LED to go on ie. LED #4 when i = 0 and LED
//#7 when i = 3
int offLED1 = 3 - offLED; //turns off the LED we turned on last time
int offLED2 = 4 + offLED; //turns off the LED we turned on last time
digitalWrite（ledPins［onLED1］， HIGH）;
digitalWrite（ledPins［onLED2］， HIGH）;
digitalWrite（ledPins［offLED1］， LOW）;
digitalWrite（ledPins［offLED2］， LOW）;
delay（delayTime）;
}
}
編譯并上傳
在上傳之前，重要的一步是驗證代碼是否可以編譯。點擊工具欄上的檢查按鈕（或者，對于Mac用戶，在鍵盤上按 control + r 或 command + r ）來編譯您的代碼。
如果編譯沒有錯誤，請將草圖上載到電路板（單擊此處可獲取有關如何從上一個電路執行此操作的更新）。上傳后，您應該會看到動畫的LED燈顯示。
不起作用？ CIRC02與GIF不匹配？
某些LED無法點亮
很容易向后插入LED。檢查無法正常工作的LED，并確保它們正確定位。
操作不正確
八根電線很容易穿過一對。仔細檢查第一個LED是否插入插針2，然后再插入每個插針。
不起作用？
很容易意外地將電線放錯了位置，注意。與試圖找出問題相比，抽出一切并重新開始通常更容易。
仍然不起作用？
我們會幫助您！在Adafruit支持論壇中發布，我們將盡快與您聯系。
變得更好
切換到循環
厭倦了看燈光秀嗎？是否要制作自己的動畫，更改動畫或了解循環功能？讓我們使CIRC02更好！
在void loop（）過程中，有4行。最后三個都以//開頭。這意味著該行是注釋（它將不會運行）。我們可以通過刪除注釋將程序切換為使用循環（如果您想了解有關注釋的更多信息，我們將撰寫一篇精彩的文章！）。
首先，在void loop（）內添加斜杠以禁用oneAfterAnotherNoLoop（）運行過程：
oneAfterAnotherNoLoop（）; -》 //oneAfterAnotherNoLoop（）;
接下來，我們將刪除注釋（斜杠）以使oneAfterAnotherLoop（）過程可以循環運行：
//oneAfterAnotherLoop（）; -》 oneAfterAnotherLoop（）;
我們應該立即驗證我們的代碼是否可以正確編譯，單擊復選標記（或 ctrl/command + r）。如果一切都編譯正確，請繼續并將新程序上傳（ ctrl + u ）到您的Metro。
運行程序后，發生了什么變化？
沒有變化！兩個過程都運行相同的動畫。（單擊以顯示答案）
這兩個過程之間有什么區別：oneAfterAnotherNoLoop（）和oneAfterAnotherLoop（ ）？
oneAfterAnotherNoLoop（）運行動畫而不使用循環這使得很多打字。 使用oneAfterAnotherLoop（）將需要更少的鍵入來運行相同的動畫！ （單擊以顯示答案）
其他動畫
厭倦了此動畫嗎？還有更多動畫供您玩耍！
要啟用它們，請取消注釋（只需刪除//）第3行和第4行，這樣：
//oneOnAtATime（）;-》 oneOnAtATime（）;
//inAndOut（）;-》 inAndOut（）;
然后將程序（ ctrl + u ）上傳到您的電路板上，并享受新的燈光動畫。
制作自己的動畫
繼續并進入隨附的代碼，然后開始進行更改。
要告訴Metro 打開LED ，
digitalWrite（pinNumber， HIGH）;
如果您想告訴Metro 關閉LED指示燈，
digitalWrite（pinNumber， LOW）;
鍵入！您所做的更改不會破壞任何內容。
CIRC03：旋轉電機旋轉
我們在做什么
Metro的引腳非常適合直接控制小型電器，例如LED。但是，在處理較大的物品（例如玩具馬達或洗衣機）時，需要使用外部晶體管。
晶體管非常有用。它使用小得多的電流來切換大量電流。晶體管具有3個引腳。對于負型（ NPN ）晶體管，請將負載連接到集電極，將發射極連接到地。然后，當小電流從基極流向發射極時，電流將流經晶體管，并且您的電動機將旋轉（這是在將Metropins 設置為高時發生的）。有關晶體管的更深入說明，請單擊此處。
字面上有成千上萬種不同類型的晶體管，可以使每種情況完美匹配。我們選擇了 P2N2222 ，這是一種非常通用的通用晶體管。在我們的案例中，重要的因素是它的最大電壓（ 40v ）和最大電流（ 600毫安）都足夠我們的玩具電機使用（可以找到完整的詳細信息）在其數據表中）。
零件
DCToy/Hobby Motor
如果您想從Adafruit商店訂購另一臺DC Motor，請單擊此處！
晶體管（PN2222或MPS2222 ）
如果您想從Adafruit商店訂購額外的NPN晶體管，請單擊此處！
2.2k歐姆電阻
顏色：紅色》紅色》紅色
如果您想從Adafruit商店訂購額外的2.2k歐姆電阻，請單擊此處！
二極管（1N4001 ）
如果您想從Adafruit商店訂購更多二極管，請單擊此處！
面包板接線束
如果您想從Adafruit商店訂購更多電線，請點擊此處！
Adafruit Metro（或Metro Express）+面包板+安裝板
組裝好了，我們有一個方便的指南！
如果您想訂購額外的塑料安裝板，Adafruit Metro，Adafrui tMetro Express或Adafruit商店的Mini-Breadboard單擊此處！
接線
MetroX套件隨附的電機的吸力不超過250mA，但是如果您使用其他電機，則很容易吸收1000mA電流，這超出了USB端口的承受能力！如果不確定電機的電流消耗，請通過壁式適配器（而不只是USB）為Metro供電。
之前從CIRC03開始，您應注意以下事項：
晶體管的平側應面向地鐵。
二極管的條紋 側面應朝向地鐵的底部
在此使用的電阻電路不同于過去的兩個電路（CIRC01/CIRC02）。確保色帶顯示為 red》 red》 red 。
div》 Steps
將Metro上的 GND 和 5V 連接到紅色和藍色電源軌。
確保晶體管的平坦側面向地鐵。將發射器（如上圖所示）連接到 GND 導軌。首先將 Base 連接到2.2k Ohm電阻，然后 連接到5V電壓軌。暫時離開收集器。
將二極管的條紋引線連接到 5V 干線和非條紋引線
藍色電動機導線應連接到條紋的電阻器的收集器。
二極管 引線。將紅色電動機導線連接到二極管的底部（無條紋）。
重新閱讀圖表上方的說明，以確保未做任何改動連接組件時出錯。 這與現在連接電動機導線的方式無關緊要。
單擊此處下載適用于以下情況的可打印面包板布局表： CIRC03
代碼
就像在前面的電路中所做的一樣，將代碼復制并粘貼到新的Arduino草圖中。然后編譯并將其上傳到您的Metro。
Download：Project Zip 或 CIRC03_MOTOR.ino | 在Github上查看
復制代碼
/* -----------------------------------------------------------
* | Arduino Experimentation Kit Example Code |
* | CIRC-03 。： Spin Motor Spin ：。 （Transistor and Motor） |
* -----------------------------------------------------------
*
* The Arduinos pins are great for driving LEDs however if you hook
* up something that requires more power you will quickly break them.
* To control bigger items we need the help of a transistor.
* Here we will use a transistor to control a small toy motor
*
*
*/
int motorPin = 9; // define the pin the motor is connected to
// （if you use pin 9，10，11 or 3you can also control speed）
/*
* setup（） - this function runs once when you turn your Arduino on
* We set the motors pin to be an output （turning the pin high （+5v） or low （ground） （-））
* rather than an input （checking whether a pin is high or low）
*/
void setup（）
{
pinMode（motorPin， OUTPUT）;
}
/*
* loop（） - this function will start after setup finishes and then repeat
* we call a function called motorOnThenOff（）
*/
void loop（） // run over and over again
{
motorOnThenOff（）;
//motorOnThenOffWithSpeed（）;
//motorAcceleration（）;
}
/*
* motorOnThenOff（） - turns motor on then off
* （notice this code is identical to the code we used for
* the blinking LED）
*/
void motorOnThenOff（）{
int onTime = 2500; //the number of milliseconds for the motor to turn on for
int offTime = 1000; //the number of milliseconds for the motor to turn off for
digitalWrite（motorPin， HIGH）; // turns the motor On
delay（onTime）; // waits for onTime milliseconds
digitalWrite（motorPin， LOW）; // turns the motor Off
delay（offTime）; // waits for offTime milliseconds
}
/*
* motorOnThenOffWithSpeed（） - turns motor on then off but uses speed values as well
* （notice this code is identical to the code we used for
* the blinking LED）
*/
void motorOnThenOffWithSpeed（）{
int onSpeed = 200; // a number between 0 （stopped） and 255 （full speed）
int onTime = 2500; //the number of milliseconds for the motor to turn on for
int offSpeed = 50; // a number between 0 （stopped） and 255 （full speed）
int offTime = 1000; //the number of milliseconds for the motor to turn off for
analogWrite（motorPin， onSpeed）; // turns the motor On
delay（onTime）; // waits for onTime milliseconds
analogWrite（motorPin， offSpeed）; // turns the motor Off
delay（offTime）; // waits for offTime milliseconds
}
/*
* motorAcceleration（） - accelerates the motor to full speed then
* back down to zero
*/
void motorAcceleration（）{
int delayTime = 50; //milliseconds between each speed step
//Accelerates the motor
for（int i = 0; i 《 256; i++）{ //goes through each speed from 0 to 255
analogWrite（motorPin， i）; //sets the new speed
delay（delayTime）; // waits for delayTime milliseconds
}
//Decelerates the motor
for（int i = 255; i 》= 0; i--）{ //goes through each speed from 255 to 0
analogWrite（motorPin， i）; //sets the new speed
delay（delayTime）; // waits for delayTime milliseconds
}
}
/* -----------------------------------------------------------
* | Arduino Experimentation Kit Example Code |
* | CIRC-03 。： Spin Motor Spin ：。 （Transistor and Motor） |
* -----------------------------------------------------------
*
* The Arduinos pins are great for driving LEDs however if you hook
* up something that requires more power you will quickly break them.
* To control bigger items we need the help of a transistor.
* Here we will use a transistor to control a small toy motor
*
*
*/
int motorPin = 9; // define the pin the motor is connected to
// （if you use pin 9，10，11 or 3you can also control speed）
/*
* setup（） - this function runs once when you turn your Arduino on
* We set the motors pin to be an output （turning the pin high （+5v） or low （ground） （-））
* rather than an input （checking whether a pin is high or low）
*/
void setup（）
{
pinMode（motorPin， OUTPUT）;
}
/*
* loop（） - this function will start after setup finishes and then repeat
* we call a function called motorOnThenOff（）
*/
void loop（） // run over and over again
{
motorOnThenOff（）;
//motorOnThenOffWithSpeed（）;
//motorAcceleration（）;
}
/*
* motorOnThenOff（） - turns motor on then off
* （notice this code is identical to the code we used for
* the blinking LED）
*/
void motorOnThenOff（）{
int onTime = 2500; //the number of milliseconds for the motor to turn on for
int offTime = 1000; //the number of milliseconds for the motor to turn off for
digitalWrite（motorPin， HIGH）; // turns the motor On
delay（onTime）; // waits for onTime milliseconds
digitalWrite（motorPin， LOW）; // turns the motor Off
delay（offTime）; // waits for offTime milliseconds
}
/*
* motorOnThenOffWithSpeed（） - turns motor on then off but uses speed values as well
* （notice this code is identical to the code we used for
* the blinking LED）
*/
void motorOnThenOffWithSpeed（）{
int onSpeed = 200; // a number between 0 （stopped） and 255 （full speed）
int onTime = 2500; //the number of milliseconds for the motor to turn on for
int offSpeed = 50; // a number between 0 （stopped） and 255 （full speed）
int offTime = 1000; //the number of milliseconds for the motor to turn off for
analogWrite（motorPin， onSpeed）; // turns the motor On
delay（onTime）; // waits for onTime milliseconds
analogWrite（motorPin， offSpeed）; // turns the motor Off
delay（offTime）; // waits for offTime milliseconds
}
/*
* motorAcceleration（） - accelerates the motor to full speed then
* back down to zero
*/
void motorAcceleration（）{
int delayTime = 50; //milliseconds between each speed step
//Accelerates the motor
for（int i = 0; i 《 256; i++）{ //goes through each speed from 0 to 255
analogWrite（motorPin， i）; //sets the new speed
delay（delayTime）; // waits for delayTime milliseconds
}
//Decelerates the motor
for（int i = 255; i 》= 0; i--）{ //goes through each speed from 255 to 0
analogWrite（motorPin， i）; //sets the new speed
delay（delayTime）; // waits for delayTime milliseconds
}
}
CIRC03遇到問題了嗎？
電動機不旋轉嗎？
如果您采購了自己的晶體管，請仔細檢查數據手冊以確保其引腳排列與PN2222兼容（許多反向）。
檢查電動機
如果您購買了自己的電動機，請仔細檢查其是否可以在5伏電壓下正常工作消耗太多力量。
仍然有問題嗎？
有時Metro板會與計算機斷開連接。嘗試拔出插頭，然后將其重新插入USB端口。
是否嘗試了上述步驟？還是不能解決您的問題？
別擔心，我們會幫助你！在Adafruit支持論壇中發布，我們將盡快與您聯系。
變得更好
控制速度
我們使用Metro的功能來更早地控制LED的亮度。現在，我們將使用相同的功能來控制電動機的速度。
大都會使用稱為 Pulse Width Modulation （ PWM 》 ）。這取決于METRO能夠真正，迅速地運行。 Metro不會直接控制來自引腳的電壓，而是會非常快速地打開和關閉引腳。
在計算機世界中，該電壓會從0伏到5伏一秒鐘，但在人類世界中，我們將其視為電壓。例如：如果Metrois PWM在 50％處，我們會看到 50％變暗，因為我們的眼睛不夠快，無法看到它閃爍。晶體管具有相同的功能。 （如果您需要對此概念的直觀解釋，請單擊此處）
不相信我嗎？ 嘗試一下！
將下面的代碼段復制并粘貼到代碼的loop（）函數中：
下載：文件
復制代碼
// motorOnThenOff（）;
motorOnThenOffWithSpeed（）;
// motorAcceleration（）; // motorOnThenOff（）;
motorOnThenOffWithSpeed（）;
// motorAcceleration（）;
然后上傳程序。
您可以通過將變量onSpeed和offSpeed更改為 0 （停止電動機）和 255 （滿功率！）
加速和減速
為什么要以兩種速度停止？為什么不對電動機進行加速和減速。
為此，只需將loop（）代碼更改為：
下載：文件
復制代碼
// motorOnThenOff（）;
// motorOnThenOffWithSpeed（）;
motorAcceleration（）; // motorOnThenOff（）;
// motorOnThenOffWithSpeed（）;
motorAcceleration（）;
然后上傳程序并觀察電動機緩慢加速到全速然后再次減速。
如果您想更改加速度，請更改變量delayTime（越大，表示加速時間越長）設置為其他值。
CIRC04：單個伺服器
旋轉電機很有趣，但是當涉及到需要運動控制的項目時，它們往往會讓我們想要更多。
答案是？業余愛好伺服器。它們是批量生產的，可以廣泛使用，價格從幾美元到幾百美元不等。
內部有一個小型變速箱（使機芯更強勁）和一些電子設備（以使其更易于控制）。標準伺服器的位置在0到180度之間。
（Simon Monk的Arduino課程14.伺服電機的伺服定位圖片）
定位是通過定時脈沖控制的，時間間隔在1.25毫秒（0度）到1.75毫秒（180度）（對于90度為1.5毫秒）。時間因制造商而異。如果每25-50毫秒發送一次脈沖，則伺服將平穩運行。 Adafruit Metro的一大功能是它具有一個軟件庫，該庫可以使用單行代碼來控制伺服器
零件
迷你伺服器
如果您想從Adafruit商店訂購額外的迷你伺服器，請單擊此處！
Adafruit商店中還有許多其他尺寸和類型的伺服器，請查看我們的產品
3-Pin標頭
如果想要從Adafruit商店訂購額外的割臺，請單擊此處！ （這些是40針，但您可以輕松將它們分開）
面包板接線束
如果您想從Adafruit商店訂購更多電線，請單擊此處！
Adafruit Metro（或Metro Express）+面包板+安裝板
如果您尚未組裝此指南，我們將為您提供方便的指南！
如果您想從Adafruit商店訂購額外的塑料安裝板，Adafruit Metro，AdafruitMetro Express或Mini-Breadboard，請單擊此處！
接線
CIRC04的接線比您制作的最后兩個電路簡單得多。
在地鐵上連接 5V 引腳 面包板上的電源軌。
連接Metro上的 GND 引腳 《接地在試驗板上的接地軌。
將伺服器的陰端連接到3-Pin接頭。
將3-Pin插頭插入面包板上的任何行中。
將接地軌連接到棕色伺服線。
將電源軌連接到紅色伺服線。
將 Metro針9 連接到橙色伺服導線（信號）。
如果遇到問題，請查看下面的“連接詳細信息”以獲取接線幫助。
連接詳細信息：
面包板伺服
接地導軌黑色/棕色（接地）
電源導軌紅色（+ 5V）
Metro Pin 9 橙色（信號）
面包板布局表
單擊此處下載適用于CIRC01的可打印面包板布局表
代碼
我們要使用的伺服代碼包含在Arduino中（就像CIRC001一樣），位于：文件》示例》伺服》掃描。
加載草圖后，將其編譯并上傳到您的Metro并查看伺服器的運動！
Sweep
如果您無法從Arduino隨附的示例中加載Sweep，則下面是完整的源代碼，可以將其復制/粘貼到Arduino編輯器中。
下載：項目Zip 或 CIRC04_SERVO.ino | 在Github上查看
復制代碼
/* Sweep
by BARRAGAN
This example code is in the public domain.
modified 8 Nov 2013
by Scott Fitzgerald
http://www.arduino.cc/en/Tutorial/Sweep
*/
#include
Servo myservo; // create servo object to control a servo
// twelve servo objects can be created on most boards
int pos = 0; // variable to store the servo position
void setup（） {
myservo.attach（9）; // attaches the servo on pin 9 to the servo object
}
void loop（） {
for （pos = 0; pos 《= 180; pos += 1） { // goes from 0 degrees to 180 degrees
// in steps of 1 degree
myservo.write（pos）; // tell servo to go to position in variable ’pos‘
delay（15）; // waits 15ms for the servo to reach the position
}
for （pos = 180; pos 》= 0; pos -= 1） { // goes from 180 degrees to 0 degrees
myservo.write（pos）; // tell servo to go to position in variable ’pos‘
delay（15）; // waits 15ms for the servo to reach the position
}
}
/* Sweep
by BARRAGAN
This example code is in the public domain.
modified 8 Nov 2013
by Scott Fitzgerald
http://www.arduino.cc/en/Tutorial/Sweep
*/
#include
Servo myservo; // create servo object to control a servo
// twelve servo objects can be created on most boards
int pos = 0; // variable to store the servo position
void setup（） {
myservo.attach（9）; // attaches the servo on pin 9 to the servo object
}
void loop（） {
for （pos = 0; pos 《= 180; pos += 1） { // goes from 0 degrees to 180 degrees
// in steps of 1 degree
myservo.write（pos）; // tell servo to go to position in variable ’pos‘
delay（15）; // waits 15ms for the servo to reach the position
}
for （pos = 180; pos 》= 0; pos -= 1） { // goes from 180 degrees to 0 degrees
myservo.write（pos）; // tell servo to go to position in variable ’pos‘
delay（15）; // waits 15ms for the servo to reach the position
}
}
不起作用？
Servo Not Twisting？
即使使用彩色電線，也仍然很容易將伺服器向后插入。可能是這種情況。如果需要幫助，請檢查連接表。
地鐵上的引誘和閃爍的LED？
如果伺服器開始運動然后抽動，并且METRO板上有閃爍的指示燈，則說明您使用的電源不足挑戰。使用新電池代替USB應該可以解決此問題。
我的伺服器根本沒有移動
我們犯了一個或兩個錯誤，就是忘記將電源（紅色和棕色的電線）連接到+5伏并接地。再次檢查連接是否有故障。
什么都沒有，我需要幫助
我們會幫助您！在Adafruit支持論壇中發布，我們將盡快與您聯系。
變得更好
電位器控制
我們尚未嘗試輸入，但是如果您想控制電動機，則電位器是一個不錯的選擇，而Arduino編輯器提供了一個示例程序。我們將學習CIRC08中的電位計，但是可以通過修改CIRC04來弄濕這種輸入。
零件
您只需要在此電路中增加一部分：藍色微調電位器。您可以在框中找到它：
面包板微調電位器-10k
如果您想在Adafruit商店購買一個額外的微調鍋，請單擊此處！
連接電位計
對其進行接線，以使兩個最外面的引腳連接到電源和接地導軌。 內部引腳應轉到Metro的模擬引腳0。請注意，我們正在使用模擬引腳而不是數字引腳這一次，它們位于地鐵左側的左側，而不是右側。
MetroBreadboard圖
請小心- Trim電位計連接到3.3 v 輸入在Metro上，而不是5V電源線上。
加載示例代碼
將電位器控制加載到修訂的CIRC04上的代碼由Arduino在
文件》伺服》旋鈕下提供。草圖，編譯并將其上傳到您的Metro。左右移動電位器，您應該會看到伺服器隨之移動。
自定時
盡管使用Metro隨附的庫很容易控制伺服器，但有時候弄清楚如何自己編寫程序還是很有趣的。試試吧！請記住，我們直接控制脈沖，因此您可以使用此方法來控制Metro的20個可用引腳上的伺服器（在執行此操作之前，您需要高度優化此代碼）。
其他有趣的伺服創意
Servos可用于進行各種操作東西的。 Adafruit學習系統是查找帶有伺服器的有趣項目的絕佳資源。
以下是我們的一些最愛：
動畫伺服尾巴：誰能想到沒有尾巴？只需一個伺服器和一點點數學，我們就可以實現它！
您曾經想建造一個機器人，但不知道從哪里開始嗎？或者。。.您是否正在尋找一個可以割牙的項目？
這種伺服控制的動畫機器人頭使用兩個伺服器進行運動，兩個揚聲器的眼睛和一個LED嘴進行友好的遠程控制機器人。
我們組裝好的云臺套件是使用兩個微型伺服器使項目實現全范圍運動的理想方法。云臺可以左右旋轉約180°，并可以上下左右傾斜150°。它還完全組裝在一起，包括兩個Micro Servos（SG-90或SG-92型）和38mm x 36mm的空間，可安裝相機或傳感器或任何您喜歡的東西。
Sandblaster是Blue Buggy的變體Cox International的氣動沙地車可以按比例縮小，轉換為電動并可以3D打印！
您可以使用它來探索避障，自動導航，無人駕駛車輛設計或輔助遠程控制。或者…早上建造，下午比賽！
為您當地的hackerspace/makerspace或全家之夜瘋狂！
》
CIRC05：另外8個LED
是時候開始使用它們喜歡的芯片或集成電路了。芯片的外部包裝可能非常具有欺騙性。例如，Metroboard上的芯片（微控制器）和我們將在該電路中使用的芯片（移位寄存器）看起來非常相似，但實際上卻完全不同。 Metroboard上的Atmel 328p芯片的價格為幾美元，而74HC595的價格為幾十美分。這是一個很好的介紹性芯片，一旦您習慣了使用它及其數據表，芯片的世界就會變成您的牡蠣。
移位寄存器（也稱為a串行到并行轉換器），僅使用三個Metropins即可為您提供額外的8個輸出（以控制LED等）。它們也可以鏈接在一起，從而使用相同的四個引腳為您提供幾乎無限數量的輸出。要使用它，您需要“插入”數據，然后將其鎖定（鎖存）。
為此，您可以將數據引腳設置為 HIGH 或 LOW ，為時鐘脈沖，然后設置再次向數據引腳發送信號并重復時鐘脈沖，直到移出8位數據為止。然后，您對鎖存器進行脈沖處理，并將8位傳輸到移位寄存器引腳。聽起來很復雜，但是真的很簡單。 （單擊此處可更深入地了解移位寄存器的工作原理）
零件
5毫米紅色LED
數量：x8
如果您要訂購點擊此處，更多來自Adafruit商店的紅色LED（它們會發出很好的指示燈！）！
74HC595移位寄存器
如果您要訂購更多移位寄存器在Adafruit商店中，請單擊此處！
560歐姆電阻器
數量：x8
顏色：綠色》藍色》棕色
如果您想從Adafruit商店訂購更多電阻，請單擊此處！ （它們的電阻為470歐姆，但可以用）
面包板接線束
如果您想從Adafruit商店訂購更多電線，請單擊此處！
Adafruit Metro（或Metro Express）+面包板+安裝板
如果您尚未組裝，我們將為您提供方便的指南！
如果d想從Adafruit商店訂購額外的塑料安裝板，Adafruit Metro，AdafruitMetro Express或Mini-Breadboard，請點擊此處！
接線
CIRC05的接線要比其他電路復雜得多。但是，這并非不可能，只是需要一些時間和耐心。
將此步驟分為三個較大的步驟，依次執行所有步驟，您將獲得有趣的LED表演！ p》
ChipOrientation
移位寄存器的放置位置應使半月圓圈應面向面包板的頂部。
步驟1：連接電源/GND
在沒有太多電線的情況下，更容易查看該圖。首先，我們連接電路上的所有電源和接地點。 注意，我們正在通過將左側導軌連接到右側導軌來擴展電源和接地導軌。這是為了便于訪問并使所有內容保持整潔。
我們還將插入電阻器。電阻插入LED的陰極（較短端），然后接地。
第2步：將數據引腳連接到Metro
地鐵上的插針2、3和4對應于數據（插針14）
上的strong》，鎖存（引腳12）和時鐘（引腳11）。
第3步：連接LED
下一步是連接LED到移位寄存器。我們在下面提供了一個方便的說明，以及最終的圖表。
完成LED布線后，請仔細檢查全部根據最終圖進行接線。之后，轉到“代碼”部分。
面包板布局表
單擊此處下載適用于CIRC05的可打印面包板布局表
代碼
將下面的代碼復制/粘貼到一個空白的草圖中。然后編譯并將其上傳到您的Metro。
下載：Project Zip 或 CIRC05_SHIFT_REGISTER.ino | 在Github上查看
復制代碼
/* ---------------------------------------------------------
* | Arduino Experimentation Kit Example Code |
* | CIRC-05 。： 8 More LEDs ：。 （74HC595 Shift Register） |
* ---------------------------------------------------------
*
* We have already controlled 8 LEDs however this does it in a slightly
* different manner. Rather than using 8 pins we will use just three
* and an additional chip.
*
*
*/
//Pin Definitions
//Pin Definitions
//The 74HC595 uses a serial communication
//link which has three pins
int data = 2;
int clock = 3;
int latch = 4;
//Used for single LED manipulation
int ledState = 0;
const int ON = HIGH;
const int OFF = LOW;
/*
* setup（） - this function runs once when you turn your Arduino on
* We set the three control pins to outputs
*/
void setup（）
{
pinMode（data， OUTPUT）;
pinMode（clock， OUTPUT）;
pinMode（latch， OUTPUT）;
}
/*
* loop（） - this function will start after setup finishes and then repeat
* we set which LEDs we want on then call a routine which sends the states to the 74HC595
*/
void loop（） // run over and over again
{
int delayTime = 100; //the number of milliseconds to delay between LED updates
for（int i = 0; i 《 256; i++）{
updateLEDs（i）;
delay（delayTime）;
}
}
/*
* updateLEDs（） - sends the LED states set in ledStates to the 74HC595
* sequence
*/
void updateLEDs（int value）{
digitalWrite（latch， LOW）; //Pulls the chips latch low
shiftOut（data， clock， MSBFIRST， value）; //Shifts out the 8 bits to the shift register
digitalWrite（latch， HIGH）; //Pulls the latch high displaying the data
}
/*
* updateLEDsLong（） - sends the LED states set in ledStates to the 74HC595
* sequence. Same as updateLEDs except the shifting out is done in software
* so you can see what is happening.
*/
void updateLEDsLong（int value）{
digitalWrite（latch， LOW）; //Pulls the chips latch low
for（int i = 0; i 《 8; i++）{ //Will repeat 8 times （once for each bit）
int bit = value & B10000000; //We use a “bitmask” to select only the eighth
//bit in our number （the one we are addressing this time through
value = value 《《 1; //we move our number up one bit value so next time bit 7 will be
//bit 8 and we will do our math on it
if（bit == 128）{digitalWrite（data， HIGH）;} //if bit 8 is set then set our data pin high
else{digitalWrite（data， LOW）;} //if bit 8 is unset then set the data pin low
digitalWrite（clock， HIGH）; //the next three lines pulse the clock pin
delay（1）;
digitalWrite（clock， LOW）;
}
digitalWrite（latch， HIGH）; //pulls the latch high shifting our data into being displayed
}
//These are used in the bitwise math that we use to change individual LEDs
//For more details http://en.wikipedia.org/wiki/Bitwise_operation
int bits［］ = {B00000001， B00000010， B00000100， B00001000， B00010000， B00100000， B01000000， B10000000};
int masks［］ = {B11111110， B11111101， B11111011， B11110111， B11101111， B11011111， B10111111， B01111111};
/*
* changeLED（int led， int state） - changes an individual LED
* LEDs are 0 to 7 and state is either 0 - OFF or 1 - ON
*/
void changeLED（int led， int state）{
ledState = ledState & masks［led］; //clears ledState of the bit we are addressing
if（state == ON）{ledState = ledState | bits［led］;} //if the bit is on we will add it to ledState
updateLEDs（ledState）; //send the new LED state to the shift register
}
/* ---------------------------------------------------------
* | Arduino Experimentation Kit Example Code |
* | CIRC-05 。： 8 More LEDs ：。 （74HC595 Shift Register） |
* ---------------------------------------------------------
*
* We have already controlled 8 LEDs however this does it in a slightly
* different manner. Rather than using 8 pins we will use just three
* and an additional chip.
*
*
*/
//Pin Definitions
//Pin Definitions
//The 74HC595 uses a serial communication
//link which has three pins
int data = 2;
int clock = 3;
int latch = 4;
//Used for single LED manipulation
int ledState = 0;
const int ON = HIGH;
const int OFF = LOW;
/*
* setup（） - this function runs once when you turn your Arduino on
* We set the three control pins to outputs
*/
void setup（）
{
pinMode（data， OUTPUT）;
pinMode（clock， OUTPUT）;
pinMode（latch， OUTPUT）;
}
/*
* loop（） - this function will start after setup finishes and then repeat
* we set which LEDs we want on then call a routine which sends the states to the 74HC595
*/
void loop（） // run over and over again
{
int delayTime = 100; //the number of milliseconds to delay between LED updates
for（int i = 0; i 《 256; i++）{
updateLEDs（i）;
delay（delayTime）;
}
}
/*
* updateLEDs（） - sends the LED states set in ledStates to the 74HC595
* sequence
*/
void updateLEDs（int value）{
digitalWrite（latch， LOW）; //Pulls the chips latch low
shiftOut（data， clock， MSBFIRST， value）; //Shifts out the 8 bits to the shift register
digitalWrite（latch， HIGH）; //Pulls the latch high displaying the data
}
/*
* updateLEDsLong（） - sends the LED states set in ledStates to the 74HC595
* sequence. Same as updateLEDs except the shifting out is done in software
* so you can see what is happening.
*/
void updateLEDsLong（int value）{
digitalWrite（latch， LOW）; //Pulls the chips latch low
for（int i = 0; i 《 8; i++）{ //Will repeat 8 times （once for each bit）
int bit = value & B10000000; //We use a “bitmask” to select only the eighth
//bit in our number （the one we are addressing this time through
value = value 《《 1; //we move our number up one bit value so next time bit 7 will be
//bit 8 and we will do our math on it
if（bit == 128）{digitalWrite（data， HIGH）;} //if bit 8 is set then set our data pin high
else{digitalWrite（data， LOW）;} //if bit 8 is unset then set the data pin low
digitalWrite（clock， HIGH）; //the next three lines pulse the clock pin
delay（1）;
digitalWrite（clock， LOW）;
}
digitalWrite（latch， HIGH）; //pulls the latch high shifting our data into being displayed
}
//These are used in the bitwise math that we use to change individual LEDs
//For more details http://en.wikipedia.org/wiki/Bitwise_operation
int bits［］ = {B00000001， B00000010， B00000100， B00001000， B00010000， B00100000， B01000000， B10000000};
int masks［］ = {B11111110， B11111101， B11111011， B11110111， B11101111， B11011111， B10111111， B01111111};
/*
* changeLED（int led， int state） - changes an individual LED
* LEDs are 0 to 7 and state is either 0 - OFF or 1 - ON
*/
void changeLED（int led， int state）{
ledState = ledState & masks［led］; //clears ledState of the bit we are addressing
if（state == ON）{ledState = ledState | bits［led］;} //if the bit is on we will add it to ledState
updateLEDs（ledState）; //send the new LED state to the shift register
}
不起作用？
Metro的電源LED熄滅
芯片向后插入。關閉Metro的電源，然后旋轉芯片，使芯片上的半月形切口朝向面包板的頂部。
仍然無效？
對不起，聽起來像是破唱片，但請務必確保您的接線是正確的。如果您不確定：取出所有東西，然后重新開始。
是否感到沮喪？
此電路既簡單又復雜，請讓我們知道您對它的失望，以便我們在以后的版本中解決該問題。
變得更好
艱難的方式
地鐵使復雜的動作非常簡單。一個完美的例子是數據的轉移和處理。但是，Metro的優點之一就是您可以調整要實現的難度。
在loop（）中，將updateLEDs（i）;切換為updateLEDsLong（i）;
您這次運行時是否注意到任何不同？
您不應該擁有的！代碼執行的動作沒有什么不同。通過使用串行外圍設備接口，將代碼更改為一次與LED通訊。
控制單個LED
就像CIRC02一樣，您可以單獨控制面包板上的LED。八個LED的當前狀態以一個8位值存儲（有關此主題的更多信息，我們有關于Binary和Hex的Collin’s Lab很棒的視頻）。提供的代碼已經處理了位操作。
要控制單個LED，我們將loop（）中的代碼替換為以下內容：
下載：文件
復制代碼
int delayTime = 100; // # of ms to delay btween LED updates
for（int i=0; i《8; i++）{
changeLED（i， ON）;
delay（delayTime）;
}
for（int i=0;i《8;i++）{
changeLED（i，OFF）;
delay（delayTime）;
}
int delayTime = 100; // # of ms to delay btween LED updates
for（int i=0; i《8; i++）{
changeLED（i， ON）;
delay（delayTime）;
}
for（int i=0;i《8;i++）{
changeLED（i，OFF）;
delay（delayTime）;
}
然后，將其編譯并上傳到Metro。該代碼將導致LED依次點亮，然后熄滅。通讀代碼和鏈接以更好地了解其工作原理。
更多動畫
如果您執行的是CIRC02，則“做得更好”部分中有一部分涉及添加其他動畫。在此電路中更改LED的格式將相似。
CIRC02可讓您使用
digitalWrite（LED， state）
CIRC05使用changeLED（）例程執行相同的操作：
changeLED（LED， state）
您可以通過以下方式重新使用CIRC02的其他動畫中的代碼： CIRC02進入此草圖，然后將所有digitalWrite（）例程更改為changeLED（）。您還需要更改其他一些內容，只需遵循編譯器錯誤即可解決。
CIRC06：壓電音樂
至此，我們已經控制了光，運動和電子。接下來讓我們解決聲音。但是聲音是一種 analog 現象，我們的 digital Metro將如何應對？我們將再次依靠其令人難以置信的速度來模擬模擬行為。
我們將在Metro的數字引腳之一上附加一個壓電元件。壓電元件每次在受到電流脈沖時都會發出喀噠聲。如果我們以適當的頻率（例如每秒440次使音符 A變成音符）對其進行脈動，則這些點擊會同時產生音符。
讓我們開始實驗并讓您的Metro播放“ Twinkle Twinkle Little Star”！
零件
Piezo 蜂鳴器
如果您想從Adafruit商店訂購另一個Pizeo蜂鳴器，請單擊此處！
面包板接線束
如果您想從Adafruit商店訂購更多電線，請單擊此處！
Adafruit Metro（或Metro Express）+面包板+安裝板
如果您尚未組裝此手冊，我們將為您提供方便的指南！
如果您愿意或在Adafruit商店中購買額外的塑料安裝板，Adafruit Metro，AdafruitMetro Express或Mini-Breadboard，請單擊此處！
接線
比CIRC05接線容易得多：
連接GND和5V電壓軌。
將壓電的一側連接到 GND
將壓電的另一端連接到Metro的數字引腳9
面包板布局表
單擊此處下載適用于CIRC06的可打印面包板布局表
代碼
將下面的代碼復制/粘貼到一個空白的草圖中。然后編譯并將其上傳到您的Metro。
下載：Project Zip 或 CIRC06_PIEZO.ino | 在Github上查看
復制代碼
// CIRC06 - Music with Piezo
int speakerPin = 9;
int length = 15; // the number of notes
char notes［］ = “ccggaagffeeddc ”; // a space represents a rest
int beats［］ = { 1， 1， 1， 1， 1， 1， 2， 1， 1， 1， 1， 1， 1， 2， 4 };
int tempo = 300;
void playNote（char note， int duration） {
char names［］ = { ‘c’， ‘d’， ‘e’， ‘f’， ‘g’， ‘a’， ‘b’， ‘C’ };
int tones［］ = { 1915， 1700， 1519， 1432， 1275， 1136， 1014， 956 };
// play the tone corresponding to the note name
for （int i = 0; i 《 8; i++） {
if （names［i］ == note） {
tone（speakerPin， tones［i］， duration）;
}
}
}
void setup（） {
pinMode（speakerPin， OUTPUT）;
}
void loop（） {
for （int i = 0; i 《 length; i++） {
if （notes［i］ == ‘ ’） {
delay（beats［i］ * tempo）; // rest
} else {
playNote（notes［i］， beats［i］ * tempo）;
}
// pause between notes
delay（tempo / 2）;
}
}
// CIRC06 - Music with Piezo
int speakerPin = 9;
int length = 15; // the number of notes
char notes［］ = “ccggaagffeeddc ”; // a space represents a rest
int beats［］ = { 1， 1， 1， 1， 1， 1， 2， 1， 1， 1， 1， 1， 1， 2， 4 };
int tempo = 300;
void playNote（char note， int duration） {
char names［］ = { ‘c’， ‘d’， ‘e’， ‘f’， ‘g’， ‘a’， ‘b’， ‘C’ };
int tones［］ = { 1915， 1700， 1519， 1432， 1275， 1136， 1014， 956 };
// play the tone corresponding to the note name
for （int i = 0; i 《 8; i++） {
if （names［i］ == note） {
tone（speakerPin， tones［i］， duration）;
}
}
}
void setup（） {
pinMode（speakerPin， OUTPUT）;
}
void loop（） {
for （int i = 0; i 《 length; i++） {
if （notes［i］ == ‘ ’） {
delay（beats［i］ * tempo）; // rest
} else {
playNote（notes［i］， beats［i］ * tempo）;
}
// pause between notes
delay（tempo / 2）;
}
}
不起作用？
揚聲器沒有聲音
給出尺寸壓電元件的形狀和形狀很容易錯過面包板上的正確孔。嘗試仔細檢查其位置。
在播放旋律時無法思考嗎？
只是因為想起壓電元件，上傳程序，然后重新插入。
對一閃一閃的小星星感到厭倦了嗎？
代碼已編寫，因此您可以輕松添加自己的歌曲，請查看“使之更好”部分，以獲取有關修改代碼的更多信息。
變得更好
每個音符的時機是根據變量計算的，因此我們可以調整每個音符的聲音或時機。要更改旋律的速度，我們只需要更改一行：
int tempo = 300; -》 int tempo = （new #）;
將new #更改為更大的數字可以降低音樂的速度，或者將其更改為較小的數字可以提高音樂的速度！
調整音符
如果您擔心音符有點過時，也可以解決此問題。注釋是根據程序頂部注釋塊中的公式計算得出的。但是要調整單個音符，只需向上或向下調整它們在tones ［］數組中的值，直到聽起來正確為止。每個音符在名稱［］數組中均與其名稱匹配。
例如：如果我們希望 c（c = 1915）具有更高的音高，則需要找到它的初始值：
char names［］ = { ‘c’， ‘d’， ‘e’， ‘f’， ‘g’， ‘a’， ‘b’， ‘C’ };
int tones［］ = { 1915， 1700， 1519， 1432， 1275， 1136， 1014， 956 };
，然后將tones ［］中的數字更改為更大的數字，讓我們開始吧 1975 ：
char names［］ = { ‘c’， ‘d’， ‘e’， ‘f’， ‘g’， ‘a’， ‘b’， ‘C’ };
int tones［］ = { 1975， 1700， 1519， 1432， 1275， 1136， 1014， 956 };
組成自己的旋律：
程序已預設為播放“ Twinkle Twinkle Little”
一首歌曲采用一個整數（int length）和兩個數組（char notes［］和int beats［］ ）。
int length-定義音符數量
char notes［］-定義每個音符
int beat［］-定義每個音符將播放多長時間
Twinkle Twinkle Little Star
下載：文件
復制代碼
int length = 15;
char notes［］ = {“ccggaagffeeddc”};
int beats［］ = { 1， 1， 1， 1， 1， 1， 2， 1， 1， 1， 1， 1， 1， 2， 4 }; int length = 15;
char notes［］ = {“ccggaagffeeddc”};
int beats［］ = { 1， 1， 1， 1， 1， 1， 2， 1， 1， 1， 1， 1， 1， 2， 4 };
生日快樂（第一行）
下載：文件
復制代碼
int length = 13;
char notes［］ = {“ccdcfeccdcgf”};
int beats［］ = {1，1，1，1，1，2，1，1，1，1，1，2，4}; int length = 13;
char notes［］ = {“ccdcfeccdcgf”};
int beats［］ = {1，1，1，1，1，2，1，1，1，1，1，2，4};
要熟悉代碼的工作方式，始終最好看一下示例。以上是兩首歌。運行它們，然后修改它們以組成您自己的旋律。
CIRC07：按下按鈕
到目前為止，我們完全專注于產出。現在是讓我們的Metroto聆聽，觀看和感受的時候了。我們將從一個簡單的按鈕開始。
連接按鈕很簡單。上拉電阻只有一個組件，可能看起來不合適。之所以會包含此內容，是因為Metro不會以與我們相同的方式進行感知（即：按鈕按下，按鈕未按下）。相反，它查看引腳上的電壓并確定它是 HIGH 還是 LOW 。按下該按鈕時，將其設置為將Metro的引腳 LOW 拉低，但是，如果未按下該按鈕，則引腳的電壓將浮動（導致偶然的錯誤）。為了使Metroto在未按下按鈕時可靠地將引腳讀取為HIGH，我們在電路中添加了上拉電阻。
零件
按鈕 數量：x2
如果您想訂購更多按鈕在Adafruit商店中，請單擊此處！
5毫米紅色LED
如果您想從Adafruit訂購更多紅色LED（它們可以很好地顯示指示燈！）商店，請點擊此處！
10K歐姆電阻
顏色：棕色》黑色》橙色
數量：x2
如果您想從Adafruit商店訂購更多的10k歐姆上拉電阻，請單擊此處！
560歐姆電阻
顏色：綠色》藍色》棕色
如果您想從Adafruit商店訂購更多電阻，請單擊此處！ （它們的電阻為470歐姆，但可以用）
面包板接線束
如果您想從Adafruit商店訂購更多電線，請單擊此處！
Adafruit Metro（或Metro Express）+面包板+安裝板
如果您尚未組裝，我們將為您提供方便的指南！
如果d想從Adafruit商店訂購額外的塑料安裝板，Adafruit Metro，AdafruitMetro Express或Mini-Breadboard，請點擊此處！
接線
CIRC07的接線很簡單-電線連接到Metrosit上的開關端子和電阻之間的數字引腳。
專業提示：將按鈕推入面包板時，注意不要將腿向外彎曲太多，否則不會與面包板接觸。就位在面包板的空隙中。
面包板布局表
單擊此處下載適用于CIRC07的可打印面包板布局表
代碼
此代碼在Arduino編輯器中為您提供：文件》示例》 2.數字》按鈕。將其加載到Arduino編輯器，然后編譯并將其上傳到您的Metro。
代碼：
下載：Project Zip 或 CIRC07_BUTTON.ino | 在Github上查看
復制代碼
/*
Button
Turns on and off a light emitting diode（LED） connected to digital pin 13，
when pressing a pushbutton attached to pin 2.
The circuit：
- LED attached from pin 13 to ground
- pushbutton attached to pin 2 from +5V
- 10K resistor attached to pin 2 from ground
- Note： on most Arduinos there is already an LED on the board
attached to pin 13.
created 2005
by DojoDave
modified 30 Aug 2011
by Tom Igoe
This example code is in the public domain.
http://www.arduino.cc/en/Tutorial/Button
*/
// constants won‘t change. They’re used here to set pin numbers：
const int buttonPin = 2; // the number of the pushbutton pin
const int ledPin = 13; // 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）;
}
}
/*
Button
Turns on and off a light emitting diode（LED） connected to digital pin 13，
when pressing a pushbutton attached to pin 2.
The circuit：
- LED attached from pin 13 to ground
- pushbutton attached to pin 2 from +5V
- 10K resistor attached to pin 2 from ground
- Note： on most Arduinos there is already an LED on the board
attached to pin 13.
created 2005
by DojoDave
modified 30 Aug 2011
by Tom Igoe
This example code is in the public domain.
http://www.arduino.cc/en/Tutorial/Button
*/
// constants won‘t change. They’re used here to set pin numbers：
const int buttonPin = 2; // the number of the pushbutton pin
const int ledPin = 13; // 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）;
}
}
無效？
燈不亮
按鈕正方形，因此很容易以錯誤的方式放置它。將其旋轉90度，看看它是否開始工作。
燈光不褪色
我們經常犯一些愚蠢的錯誤，當您從簡單打開關閉到褪色時，請記住將LED電線從插針13移到引腳9。
感覺不知所措？
不用擔心，這些電路都被超級精簡地簡化了組件的制作很容易，但是一旦將它們放在一起，便是極限。
變得更好
電燈開關
有點讓人不知所措（“我不需要地鐵就能完成 this ！”），讓我們使用地鐵來做一些更復雜的事情。我們將做一個電燈開關。面包板上的一個按鈕將打開燈，另一個按鈕將其關閉！
這非常簡單，我們只需要更改幾行代碼即可：
下載：文件
復制代碼
int ledPin = 13; // choose the pin for the LED
int buttonPin1 = 3; // button 1
int buttonPin2 = 2; // button 2
void setup（） {
pinMode（ledPin， OUTPUT）; // declare LED as output
pinMode（buttonPin1， INPUT）; // make button 1 an input
pinMode（buttonPin1， INPUT）; // make button 2 an input
}
void loop（） {
if （digitalRead（buttonPin1） == LOW） {
digitalWrite（ledPin， LOW）; // turn LED OFF
}
else if （digitalRead（buttonPin2） == LOW） {
digitalWrite（ledPin， HIGH）; // turn LED ON
}
} int ledPin = 13; // choose the pin for the LED
int buttonPin1 = 3; // button 1
int buttonPin2 = 2; // button 2
void setup（） {
pinMode（ledPin， OUTPUT）; // declare LED as output
pinMode（buttonPin1， INPUT）; // make button 1 an input
pinMode（buttonPin1， INPUT）; // make button 2 an input
}
void loop（） {
if （digitalRead（buttonPin1） == LOW） {
digitalWrite（ledPin， LOW）; // turn LED OFF
}
else if （digitalRead（buttonPin2） == LOW） {
digitalWrite（ledPin， HIGH）; // turn LED ON
}
}
將代碼復制并粘貼到空白草圖中，將其上傳到電路板上，然后開始打開和關閉LED。
褪色
讓我們使用按鈕來控制模擬信號。為此，您需要將連接LED的電線從9中的 Pi n 13 更改為 P
在代碼中，更改：
int ledPin = 13; -》 int ledPin = 9;
下一步，更改 loop（）讀取的代碼：
下載：文件
復制代碼
int value = 0;
void loop（） {
if（digitalRead（buttonPin1） == LOW）{
value--;
}
else if（digitalRead（buttonPin2） == LOW）{
value++;
}
value = constrain（value， 0， 255）;
analogWrite（ledPin， value）;
delay（10）;
} int value = 0;
void loop（） {
if（digitalRead（buttonPin1） == LOW）{
value--;
}
else if（digitalRead（buttonPin2） == LOW）{
value++;
}
value = constrain（value， 0， 255）;
analogWrite（ledPin， value）;
delay（10）;
}
更改淡入淡出速度
如果您希望LED淡入或淡出，則只需更改一行代碼：
delay（10）; -》 delay（new #）;
要淡化更快：將數字減小。
要使變慢淡入淡出：請增大數字。
CIRC08：扭曲
除了數字引腳外，Metro還具有6個可用于模擬輸入的引腳。
這些輸入采用電壓（從0到5伏）并將其轉換為數字在0（0伏特）和1023（5伏特）（10位分辨率）之間。
利用這些輸入的非常有用的設備是電位計（也稱為可變電阻器）。當它的外部引腳上連接有5伏電壓時，中間引腳將讀取0到5伏之間的某個值，具體取決于其旋轉角度（即，中間2.5伏）。然后，我們可以將返回的值用作程序中的變量。
零件
面包板微調電位器-10k
如果您想從Adafruit商店購買一個額外的修剪鍋，請單擊此處！
5mm紅色LED
如果您想從Adafruit商店訂購更多的紅色LED（它們使指示燈很好！），請單擊此處！
560歐姆電阻
顏色：綠色》藍色》棕色
如果您想從Adafruit商店請點擊這里！ （它們的電阻為470歐姆，但可以用）
面包板接線束
如果您想從Adafruit商店訂購更多電線，請單擊此處！
Adafruit Metro（或Metro Express）+面包板+安裝板
如果您尚未組裝，我們將為您提供方便的指南！
如果d想從Adafruit商店訂購額外的塑料安裝板，Adafruit Metro，AdafruitMetro Express或Mini-Breadboard，請點擊此處！
接線
CIRC08可以快速接線：
LED的長端連接到560歐姆的電阻，該電阻接地。
較短的（陰極）端連接到地鐵的數字引腳13
電位器的中間引腳連接到模擬引腳0
電位計連接到 5V 和 GND 電源軌。
可打印的面包板圖紙
點擊此處下載適用于CIRC08的可打印的面包板布局圖紙
Metro Express的接線
如果您使用的是Adafruit Metro Express，則應使用以下接線。如果您不確定自己擁有什么板，請檢查此頁面。
面包板上的電源軌應連接到Metro Express上的3.3V引腳
代碼
Arduino包含此示例，在以下位置找到它：文件》示例》 3.Analog》模擬輸入
然后編譯并將其上傳到您的Metro。調整電位計以更改LED的亮度。
如果找不到或加載示例，代碼如下：
下載：Project Zip 或 CIRC08_POTENTIOMETER。 ino | 在Github上查看
復制代碼
/*
Analog Input
Demonstrates analog input by reading an analog sensor on analog pin 0 and
turning on and off a light emitting diode（LED） connected to digital pin 13.
The amount of time the LED will be on and off depends on
the value obtained by analogRead（）。
The circuit：
* Potentiometer attached to analog input 0
* center pin of the potentiometer to the analog pin
* one side pin （either one） to ground
* the other side pin to +5V
* LED anode （long leg） attached to digital output 13
* LED cathode （short leg） attached to ground
* Note： because most Arduinos have a built-in LED attached
to pin 13 on the board， the LED is optional.
Created by David Cuartielles
modified 30 Aug 2011
By Tom Igoe
This example code is in the public domain.
http://www.arduino.cc/en/Tutorial/AnalogInput
*/
int sensorPin = A0; // select the input pin for the potentiometer
int ledPin = 13; // select the pin for the LED
int sensorValue = 0; // variable to store the value coming from the sensor
void setup（） {
// declare the ledPin as an OUTPUT：
pinMode（ledPin， OUTPUT）;
}
void loop（） {
// read the value from the sensor：
sensorValue = analogRead（sensorPin）;
// turn the ledPin on
digitalWrite（ledPin， HIGH）;
// stop the program for milliseconds：
delay（sensorValue）;
// turn the ledPin off：
digitalWrite（ledPin， LOW）;
// stop the program for for milliseconds：
delay（sensorValue）;
}
/*
Analog Input
Demonstrates analog input by reading an analog sensor on analog pin 0 and
turning on and off a light emitting diode（LED） connected to digital pin 13.
The amount of time the LED will be on and off depends on
the value obtained by analogRead（）。
The circuit：
* Potentiometer attached to analog input 0
* center pin of the potentiometer to the analog pin
* one side pin （either one） to ground
* the other side pin to +5V
* LED anode （long leg） attached to digital output 13
* LED cathode （short leg） attached to ground
* Note： because most Arduinos have a built-in LED attached
to pin 13 on the board， the LED is optional.
Created by David Cuartielles
modified 30 Aug 2011
By Tom Igoe
This example code is in the public domain.
http://www.arduino.cc/en/Tutorial/AnalogInput
*/
int sensorPin = A0; // select the input pin for the potentiometer
int ledPin = 13; // select the pin for the LED
int sensorValue = 0; // variable to store the value coming from the sensor
void setup（） {
// declare the ledPin as an OUTPUT：
pinMode（ledPin， OUTPUT）;
}
void loop（） {
// read the value from the sensor：
sensorValue = analogRead（sensorPin）;
// turn the ledPin on
digitalWrite（ledPin， HIGH）;
// stop the program for milliseconds：
delay（sensorValue）;
// turn the ledPin off：
digitalWrite（ledPin， LOW）;
// stop the program for for milliseconds：
delay（sensorValue）;
}
不起作用？
偶爾工作
這很可能是由于與電位器的引腳。通常可以通過向下點擊電位器來解決此問題。
不起作用？
確保您沒有將電位計的抽頭意外連接到數字引腳0而不是模擬引腳0（電源引腳下方的引腳行）。
是否仍然向后？
您可以嘗試顛倒操作電路。有時這會有所幫助。
使用Arduino串行繪圖儀
我們將開始繪制。。.值！ Arduino帶有一個很酷的工具，稱為串行繪圖儀。它可以實時顯示變量。這對于可視化數據，對代碼進行故障排除以及將變量可視化為波形非常有用。
我們首先需要修改CIRC08的代碼。將以下代碼復制并粘貼到Arduino編輯器中。然后編譯并上傳。
下載：文件
復制代碼
/*
Analog Input， but with Serial Plotter！
Demonstrates analog input by reading an analog sensor on analog pin 0 and
turning on and off a light emitting diode（LED） connected to digital pin 13.
The amount of time the LED will be on and off depends on
the value obtained by analogRead（）。
The circuit：
* Potentiometer attached to analog input 0
* center pin of the potentiometer to the analog pin
* one side pin （either one） to ground
* the other side pin to +5V
* LED anode （long leg） attached to digital output 13
* LED cathode （short leg） attached to ground
* Note： because most Arduinos have a built-in LED attached
to pin 13 on the board， the LED is optional.
Created by David Cuartielles
modified 30 Aug 2011
By Tom Igoe
This example code is in the public domain.
http://www.arduino.cc/en/Tutorial/AnalogInput
*/
int sensorPin = A0; // select the input pin for the potentiometer
int ledPin = 13; // select the pin for the LED
int sensorValue = 0; // variable to store the value coming from the sensor
void setup（） {
// declare the ledPin as an OUTPUT：
pinMode（ledPin， OUTPUT）;
// begin the serial monitor @ 9600 baud
Serial.begin（9600）;
}
void loop（） {
// read the value from the sensor：
sensorValue = analogRead（sensorPin）;
Serial.println（sensorValue）;
Serial.print（“ ”）;
delay（20）;
} /*
Analog Input， but with Serial Plotter！
Demonstrates analog input by reading an analog sensor on analog pin 0 and
turning on and off a light emitting diode（LED） connected to digital pin 13.
The amount of time the LED will be on and off depends on
the value obtained by analogRead（）。
The circuit：
* Potentiometer attached to analog input 0
* center pin of the potentiometer to the analog pin
* one side pin （either one） to ground
* the other side pin to +5V
* LED anode （long leg） attached to digital output 13
* LED cathode （short leg） attached to ground
* Note： because most Arduinos have a built-in LED attached
to pin 13 on the board， the LED is optional.
Created by David Cuartielles
modified 30 Aug 2011
By Tom Igoe
This example code is in the public domain.
http://www.arduino.cc/en/Tutorial/AnalogInput
*/
int sensorPin = A0; // select the input pin for the potentiometer
int ledPin = 13; // select the pin for the LED
int sensorValue = 0; // variable to store the value coming from the sensor
void setup（） {
// declare the ledPin as an OUTPUT：
pinMode（ledPin， OUTPUT）;
// begin the serial monitor @ 9600 baud
Serial.begin（9600）;
}
void loop（） {
// read the value from the sensor：
sensorValue = analogRead（sensorPin）;
Serial.println（sensorValue）;
Serial.print（“ ”）;
delay（20）;
}
調用Serial.println（value）時，串行繪圖儀會將該變量放在繪圖上。繪圖的Y軸會自動調整大小。
如果要 繪圖 多個變量，您將每個變量都需要一個Serial.println（value）調用，用Serial.print（“ ”）或Serial.print（“ ”）分隔：
Serial.print（variable1）;
Serial.print（“ ”）;
Serial.println（variable2）;
讓我們嘗試使用上面的新代碼。編譯并上傳上述程序，然后導航至工具》串行繪圖儀。該代碼使用9600的波特率，請確保在串行監視器中也將其設置為9600。
左右旋轉微調電位器時，應該會看到類似以下內容：
變得更好
閾值切換
有時，當值超過某個閾值時，您將希望切換輸出。
要使用電位計來實現此目的，請更改loop（）代碼至：
下載：文件
復制代碼
void loop（） {
int threshold = 512;
if（analogRead（sensorPin） 》 threshold） {
digitalWrite（ledPin， HIGH）;
}
else {
digitalWrite（ledPin， LOW）;
}
}
void loop（） {
int threshold = 512;
if（analogRead（sensorPin） 》 threshold） {
digitalWrite（ledPin， HIGH）;
}
else {
digitalWrite（ledPin， LOW）;
}
}
當值大于512（電位器刻度盤的一半）時，這將使LED點亮，您可以通過更改閾值。
漸變
讓我們直接從電位計控制LED的亮度。為此，我們需要首先更改LED所連接的引腳。
將導線從 Pin 13 移至 Pin 9 ，然后更改以下內容代碼行：
int ledPin = 13; -》 int ledPin = 9;
然后，將循環代碼更改為：
下載：文件
復制代碼
void loop（） {
int value = analogRead（potPin） / 4;
analogWrite（ledPin， value）;
} void loop（） {
int value = analogRead（potPin） / 4;
analogWrite（ledPin， value）;
}
上傳代碼并觀看您的LED相對于電位計旋轉的衰減。 （ Note ：之所以將其除以4是因為AnalogRead（）函數返回的值是0到1023（10位），而analogWrite（）的值是0到255（8位） ））
控制伺服器
這是一個非常簡潔的示例，它帶來了幾個改變閾值的電路。像在CIRC-04中一樣連接伺服器：
然后打開示例程序旋鈕（文件》示例》伺服》旋鈕）。上傳到您的麥德龍（METRO），然后在轉動電位計時觀察伺服軸的轉動。
CIRC09：淺色
盡管從電位計獲取輸入對于人體控制實驗很有用，但是當我們要進行環境控制實驗時我們應該使用什么呢？
我們使用完全相同的原理，但沒有使用電位計（基于扭力的電阻），使用光敏電阻（基于光的電阻）。 Metrocan無法直接感應電阻（感應電壓），因此我們設置了一個分壓器。感測引腳上的確切電壓是可以計算的，但出于我們的目的（僅感測相對光），我們可以嘗試使用這些值并查看對我們有用的值。當傳感器光線充足，而在黑暗中則會產生較高的值。
零件
5毫米紅色LED
如果您想從Adafruit商店訂購更多紅色LED（它們可以很好地顯示指示燈！），請點擊此處！
照片傳感器
如果您想從Adafruit商店訂購其他光敏電阻，請單擊此處！
10K歐姆電阻
顏色：棕色》黑色》橙色
如果您想從Adafr訂購更多的10k歐姆上拉電阻uit shop，請點擊這里！
560歐姆電阻
顏色： 綠色》藍色》棕色
如果您想在Adafruit商店訂購更多電阻，請單擊此處！ （它們的電阻為470歐姆，但可以用）
面包板接線束
如果您想從Adafruit商店訂購更多電線，請單擊此處！
Adafruit Metro（或Metro Express）+面包板+安裝板
如果您尚未組裝，我們將為您提供方便的指南！
如果d想從Adafruit商店訂購額外的塑料安裝板，Adafruit Metro，AdafruitMetro Express或Mini-Breadboard，請點擊此處！
接線
將LED：陽極連接到引腳9 。陰極連接到560歐姆電阻，然后接地。
連接光敏電阻。將10k歐姆電阻的一端連接到電源軌。將其另一端連接到A0，然后將其連接到光敏電阻的一端。電阻的另一端應接地。
可打印的面包板布局表
單擊此處下載適用于CIRC09的可打印的面包板布局表
Metro Express的接線
如果您使用的是Adafruit Metro Express，則應使用以下接線。如果您不確定自己擁有什么板，請檢查此頁面。
面包板上的電源軌應連接到Metro Express上的3.3V引腳
代碼
將以下代碼復制并粘貼到新的Arduino草圖中。然后，編譯并將其上傳到您的Metro。
下載：Project Zip 或CIRC09_LIGHT.ino | 在Github上查看
復制代碼
// CIRC09 - Light
int lightPin = A0;
int ledPin = 9;
void setup（）
{
pinMode（ledPin， OUTPUT）;
}
void loop（）
{
int lightLevel = analogRead（lightPin）;
lightLevel = map（lightLevel， 0， 700， 0， 255）;
analogWrite（ledPin， lightLevel）;
}
// CIRC09 - Light
int lightPin = A0;
int ledPin = 9;
void setup（）
{
pinMode（ledPin， OUTPUT）;
}
void loop（）
{
int lightLevel = analogRead（lightPin）;
lightLevel = map（lightLevel， 0， 700， 0， 255）;
analogWrite（ledPin， lightLevel）;
}
不起作用？
如果光電傳感器出現問題：將其翻轉，方向可能是
LED保持黑暗
這是一個錯誤，如果他們只能制造出可以雙向工作的LED，我們就會不斷地犯錯。
它不響應光照變化。
鑒于光敏電阻上導線的間距不是標準的，因此很容易放錯位置。仔細檢查其正確位置。
仍然不能正常工作嗎？
您所在的房間可能太亮或太暗。嘗試打開或關閉燈，看看是否有幫助。或者，如果您附近有手電筒，請嘗試一下。
變得更好
反轉響應
也許您想要相反的響應。不用擔心，只要更改即可，我們就可以輕松逆轉此響應：
analogWrite（ledPin， lightLevel）;-》 analogWrite（ledPin， 255 - lightLevel）;
上傳修改后的草圖并觀察響應的變化。
與其控制LED響應光線的亮度，不如根據閾值打開或關閉它。使用以下命令更改 loop（）代碼：
下載：文件
復制代碼
void loop（）{
int threshold = 300;
if（analogRead（lightPin） 》 threshold）{
digitalWrite（ledPin， HIGH）;
}
else{
digitalWrite（ledPin， LOW）;
}
} void loop（）{
int threshold = 300;
if（analogRead（lightPin） 》 threshold）{
digitalWrite（ledPin， HIGH）;
}
else{
digitalWrite（ledPin， LOW）;
}
}
光控伺服器
此電路使用Metro和Metro Express使用相同的布線。確保將電源軌插入3V而不是5V。
讓我們使用我們新發現的光感應技能來控制伺服器（同時進行一些Arduino代碼黑客攻擊）。連接連接到引腳9的伺服器（如在CIRC-04中）。然后打開旋鈕示例程序（與我們在CIRC-08中使用的程序相同）文件》示例》 Library-Servo》旋鈕。將代碼上傳到您的電路板上，并觀察其未修改的工作原理。
使用伺服的全部范圍
您會注意到，伺服將僅在其范圍的有限范圍內運行。這是因為在分壓電路中，我們使用模擬引腳0上的電壓范圍不是0至5伏，而是介于兩個較小的值之間（這些值將根據您的設置而變化）。要解決此問題，請使用以下行：val = map（val， 0， 1023， 0， 179）;（有關操作的提示，請單擊此處）
了解更多！
如果您想了解光電傳感器背后的魔力，我們有一個學習指南，詳細說明該主題
CIRC10：溫度
我們將用Metro衡量的下一個現象是什么？ 溫度。
為此，我們將使用隱藏在與P2N2222AG晶體管 TMP36 相同的封裝中的相當復雜的IC（集成電路） 。它具有三個引腳，接地，信號和電源。并且易于使用。
它在信號引腳上每攝氏度輸出10毫伏（為了測量冰點以下的溫度，偏移量為500 mV，例如25攝氏度= 750 mV，0攝氏度= 500mV）。要將其從數字值轉換為度，我們將使用Arduino的一些數學功能。然后要顯示它，我們將使用IDE的功能之一，即調試窗口。我們將通過串行連接輸出該值以在屏幕上顯示。讓我們開始吧。
另外一點，該電路使用Arduino IDE的串行監視器。要打開它，首先上傳程序，然后單擊看起來像帶有天線的正方形的按鈕。
零件
模擬溫度傳感器看起來很像NPN晶體管，確保上面顯示“ TMP36”！
我是使用NPN 晶體管還是TMP36 溫度傳感器？
Adafruit Metro（或Metro Express）+面包板+安裝板
如果您尚未組裝，我們將為您提供方便指南！
如果您想從Adafruit商店訂購額外的塑料安裝板，Adafruit Metro，AdafruitMetro Express或Mini-Breadboard，請點擊此處！
模擬溫度傳感器
如果您想要一個額外的溫度傳感器，可以從Adafruit商店購買一個，請點擊此處
面包板接線束
I如果您想從Adafruit商店訂購更多電線，請點擊此處！
接線
請注意溫度傳感器的引腳排列。接線錯誤會迅速加熱。
i》
連接
可打印的面包板表
單擊此處下載適用于CIRC10的可打印的面包板布局表
Metro Express的接線
如果您使用的是Adafruit Metro Express，則應使用以下接線。如果您不確定自己擁有什么板，請檢查此頁面。
面包板上的電源軌應連接到Metro Express上的3.3V引腳
代碼
復制/粘貼以下代碼。
然后編譯并將其上傳到您的Metro。
下載：Project Zip 或 CIRC10_TEMPERATURE.ino | 在Github上查看
復制代碼
/*
* CIRC10： Temperature
* for use with both the Metro and Metro Express
*
* by Brent Rubell for Adafruit Industries. Support Open Source， buy Adafruit！
*/
#define ANALOGREFVOLTAGE 5.555
//TMP36 Pin
int temperaturePin = A0;
void setup（） {
// Start the Serial connection
Serial.begin（9600）;
}
void loop（） {
float temperature = 0;
temperature = getVoltage（temperaturePin）;
Serial.println（temperature）;
// Convert to degrees C
temperature = （temperature - .5） * 100;
Serial.println（temperature）;
delay（1000）;
}
float getVoltage（int pin） {
return（float（analogRead（pin））* float（ANALOGREFVOLTAGE/1023.000））;
}
/*
* CIRC10： Temperature
* for use with both the Metro and Metro Express
*
* by Brent Rubell for Adafruit Industries. Support Open Source， buy Adafruit！
*/
#define ANALOGREFVOLTAGE 5.555
//TMP36 Pin
int temperaturePin = A0;
void setup（） {
// Start the Serial connection
Serial.begin（9600）;
}
void loop（） {
float temperature = 0;
temperature = getVoltage（temperaturePin）;
Serial.println（temperature）;
// Convert to degrees C
temperature = （temperature - .5） * 100;
Serial.println（temperature）;
delay（1000）;
}
float getVoltage（int pin） {
return（float（analogRead（pin））* float（ANALOGREFVOLTAGE/1023.000））;
}
使用Arduino串行監視器
單擊Arduino IDE工具欄上的放大鏡圖標。您應該會看到串行監視器彈出并開始打印數字。
不起作用？
似乎沒有發生
此程序沒有向外的指示，表明它正在運行。要查看結果，您必須打開Arduino IDE的串行監視器。
顯示亂碼
之所以會發生這種情況，是因為串行監視器以不同于預期的速度接收數據。要解決此問題，請單擊顯示為“ *** baud”的下拉框，并將其更改為“ 9600 baud”。
溫度值不變
嘗試用手指捏住傳感器以加熱它或按一袋在上面放冰以使其冷卻。
變得更好
輸出電壓
這是更改一個行的簡單問題。我們的傳感器每攝氏度輸出10mv，因此要獲取電壓，我們只需顯示getVoltage（）的結果。刪除該行：
temperature = （temperature - .5） * 100;
輸出華氏度
同樣，這是一個簡單的更改，僅需數學即可。要達到攝氏度C -》 F，我們使用公式：
（F = C * 1.8）+ 32）
添加以下行：
temperature = （（（temperature - .5） * 100）*1.8） + 32; 在Serial.println（temperature）;
更多信息輸出
讓我們在串行輸出中添加一條消息，使內容變為出現在“串行監視器”中的信息更豐富。
為此，請更改以下行：
Serial.println（temperature）;
至：
Serial.print（temperature）;
然后，我們在另一行上添加另一行包含有關溫度的信息的文本：
Serial.println（“ degrees centigrade”）;
更改為第一行意味著下次輸出時，它會顯示在同一行上。
更改串行速度
如果您希望在串行線路時間內輸出大量數據，本質。目前，我們以9600波特的速度傳輸信號，但可能會有更快的傳輸速度。
要更改此更改，請更改線路：
Serial.begin（9600）;
到：
Serial.begin（115200）;
上傳草圖，請打開串行監視器，然后在下拉菜單中將速度從9600波特更改為115200波特。現在，您的數據傳輸速度快了12倍。
CIRC10.5：溫度警報
CIRC10 僅在連接到串行監視器時起作用。讓我們將電路板從電線上解放出來，制作一個獨立式電路！
這是一個 bonus 電路！
使用9V電池運行Metro Express
，我們將制作一個獨立的警報來警告我們。
9V電池夾是實驗工具包中隨附的零件之一。
如果您有9V電池，請將其卡入電池夾中，然后將其插入電池盒的插孔中。地鐵：
我們的溫度傳感器現在用9V電池供電。這太棒了，但是我們仍然沒有辦法警告溫度太高/太冷。
添加壓電！
Piezo元素是在CIRC06中首次引入的。您將其發送為數字輸出，并且蜂鳴。下一步是當壓電超過一定溫度時會發出嗡嗡聲。只需對電路進行最少的修改，即可將壓電體用作警報器：
溫度警報的代碼如下（將其復制并粘貼到空白的Arduino草圖中），編譯并將其上傳到您的Metro：
下載：Project Zip 或 CIRC10_5_TEMP_ALARM.ino | 在Github上查看
復制代碼
/* CIRC10.5： Temperature Alarm
* （a bonus circuit for MetroX）
*
* by Brent Rubell for Adafruit Industries
*/
#define ANALOGREFVOLTAGE 5.555
// TMP36 Pin
int temperaturePin = A0;
// Piezo Pin
int piezoPin = 8;
// Freezing
float freezeTemp = 0;
// Boiling
float boilTemp = 26;
void setup（）
{
// Start the Serial connection
Serial.begin（9600）;
}
void loop（）
{
float temperature = 0;
temperature = getVoltage（temperaturePin）;
// Convert to degrees C
temperature = （temperature - .5） * 100;
Serial.println（temperature）;
if（temperature 《 freezeTemp） {
tone（piezoPin， 1100， 1000）;
}
else if（temperature 》 boilTemp） {
tone（piezoPin， 1100， 1000）;
}
delay（1000）;
}
float getVoltage（int pin） {
return（float（analogRead（pin））* float（ANALOGREFVOLTAGE/1023.000））;
}
/* CIRC10.5： Temperature Alarm
* （a bonus circuit for MetroX）
*
* by Brent Rubell for Adafruit Industries
*/
#define ANALOGREFVOLTAGE 5.555
// TMP36 Pin
int temperaturePin = A0;
// Piezo Pin
int piezoPin = 8;
// Freezing
float freezeTemp = 0;
// Boiling
float boilTemp = 26;
void setup（）
{
// Start the Serial connection
Serial.begin（9600）;
}
void loop（）
{
float temperature = 0;
temperature = getVoltage（temperaturePin）;
// Convert to degrees C
temperature = （temperature - .5） * 100;
Serial.println（temperature）;
if（temperature 《 freezeTemp） {
tone（piezoPin， 1100， 1000）;
}
else if（temperature 》 boilTemp） {
tone（piezoPin， 1100， 1000）;
}
delay（1000）;
}
float getVoltage（int pin） {
return（float（analogRead（pin））* float（ANALOGREFVOLTAGE/1023.000））;
}
更改變量
我們在攝氏溫度中預定義了凍結和沸騰變量，但是如果您要使用華氏度（或kelvinjust，請將下面的變量更改為其他值：
float freezeTemp = 0;
float boilTemp = 26;
CIRC11：繼電器的負載更大
下一個電路有點挑戰。我們結合了在CIRC03中使用晶體管來控制繼電器的知識。
繼電器是一種電控機械開關。小塑料盒內有一個電磁體，當通電時，該電磁體會使開關跳閘（通常會發出非常令人滿意的咔嗒聲）。您可以購買大小不等的繼電器，該繼電器的大小從套件中的四分之一到冰箱一樣大，每個繼電器都可以切換一定量的電流。它們非常有趣，因為它們具有某種物理元素。
雖然到目前為止我們玩過的所有芯片有時都很有趣，但是您可能只想連接一百個開關來控制宏偉的東西。繼電器使您能夠幻想它，然后使用Arduino控制它。現在，運用當今的技術來控制過去。 （1N4001二極管用作反激二極管，請單擊此處以獲取有關反激二極管的更多信息）
零件
DPDT中繼
560歐姆電阻
QTY：x2
顏色：綠色》藍色》棕色
如果您想從Adafruit商店訂購更多電阻，請單擊此處！ （它們的電阻為470歐姆，但可以用）
2.2k歐姆電阻
顏色：紅色》紅色》紅色
如果您想從Adafruit商店訂購額外的2.2k Ohm電阻器，請單擊此處！
此電路使用NPN晶體管，而不是TMP36傳感器。
我是使用NPN 晶體管還是TMP36 溫度傳感器？
晶體管（PN2222或MPS2222）
如果您想從Adafruit商店訂購額外的NPN晶體管，請單擊此處！
二極管（1N4001）
如果您想在Adafruit商店訂購更多二極管，請單擊此處！
5mm紅色LED
如果您愿意從Adafruit商店訂購更多的紅色LED（它們使指示燈很好！），請單擊此處！
5mm綠色LED
如果您要訂購額外的綠色Adafruit的LED商店，請點擊此處！
面包板接線束
如果您想從Adafruit商店訂購更多電線，請單擊此處！
Adafruit Metro（或Metro Express）+面包板+安裝板
如果您尚未組裝此板，我們將為您提供方便的指南！
如果您要訂購額外的塑料安裝板，Adafruit Metro，AdafruitMetro Express或Adafruit Shop的迷你面包板請單擊此處！
接線
接線：
確保晶體管的平坦面朝向地鐵。
繼電器接線的特寫
確保 DPDT中繼面頂部的小方塊面包板的頂部。另外，請確保DPDT繼電器的二極管面 右側上的條紋。
可打印面包板布局表
點擊此處下載適用于CIRC11的可打印面包板布局表
代碼
將下面的代碼復制并粘貼到空白的Arduino草圖中。然后編譯并將其上傳到您的Metro。
下載：Project Zip 或 CIRC11_RELAY.ino | 在Github上查看
復制代碼
// CIRC11 - Relay
int relayPin = 2;
void setup（） {
pinMode（relayPin， OUTPUT）;
}
void loop（） {
digitalWrite（relayPin， HIGH）;
delay（1000）;
digitalWrite（relayPin， LOW）;
delay（1000）;
}
// CIRC11 - Relay
int relayPin = 2;
void setup（） {
pinMode（relayPin， OUTPUT）;
}
void loop（） {
digitalWrite（relayPin， HIGH）;
delay（1000）;
digitalWrite（relayPin， LOW）;
delay（1000）;
}
不起作用？
什么都沒發生
示例代碼使用了第13針，我們將繼電器連接到引腳2。請確保您在代碼中做了以下更改：
LED_BUILTIN -》 2
沒有點擊聲音
電路的晶體管或線圈部分無法正常工作。檢查晶體管是否正確插入。
效果不佳或無法正常工作
隨附的繼電器設計為焊接而不是在面包板上使用。因此，您可能需要按入以確保其正常工作（并且有時會彈出）。
變得更好
反電動勢脈沖
用LED替換二極管。您會看到它每次“吸收”線圈電壓尖峰時都會閃爍。關閉。
控制電機
在CIRC-03中，我們使用晶體管控制了電動機。但是，如果要控制更大的電動機，則繼電器是一個不錯的選擇。為此，只需卸下紅色LED并將電動機連接到位即可。
控制電動機方向
需要完成一些復雜的改進。為了控制直流電動機的旋轉方向，我們必須能夠使流過直流電動機的電流方向反向。要手動執行此操作，我們需要反轉引線。要進行電操作，我們需要一種稱為h橋的東西。這可以通過使用DPDT繼電器來控制電動機的方向來完成，并連接以下電路。它看起來很復雜，但僅需使用幾根額外的導線即可完成。嘗試一下。
示意圖布局
面包板布局
CIRC12：七彩光芒
我們使一個LED閃爍并按順序控制8個。現在該控制顏色了。使用RGB LED（單個外殼中實際上有3個LED），我們可以產生我們內心想要的任何顏色。
我們通過顏色混合來做到這一點，需要的是深入研究使用彩色玻璃紙以產生不同顏色的基礎藝術時代（如果您不記得很久了，請不要擔心，這里有一個色輪可以幫助您）。
零件
RGB LED
如果您想從Adafruit商店購買另一個RGB LED，請單擊此處。
560歐姆電阻 》
數量：x3
顏色： 綠色》藍色》棕色
如果您想從Adafruit商店訂購更多電阻，請點擊此處！ （它們的電阻為470歐姆，但可以用）
面包板接線束
如果您想從Adafruit商店訂購更多電線，請單擊此處！
Adafruit Metro（或Metro Express）+面包板+安裝板
如果您尚未組裝，我們將為您提供方便的指南！
如果d想從Adafruit商店訂購額外的塑料安裝板，Adafruit Metro，AdafruitMetro Express或Mini-Breadboard，請點擊此處！
接線
下方：
將第一個RGB LED支路連接到560歐姆電阻，然后引腳9
將第二個RGB LED支路連接到560歐姆電阻，然后引腳10
將第一個RGB LED支路連接到560歐姆電阻，然后引腳11
請注意， RGB LED的strong》最長的腳連接到電源軌5V。
可打印的面包板布局表
單擊此處下載用于CIRC12的可打印的面包板布局表
Metro Express的接線
如果您使用的是Adafruit Metro Express，則應使用以下接線。如果您不確定自己擁有什么板，請檢查此頁面。
面包板上的電源軌應連接到Metro Express上的3.3V引腳
代碼
將下面的代碼復制并粘貼到空白的Arduino草圖中。然后編譯并將其上傳到您的Metro。
下載：Project Zip 或 CIRC12_RGB_LED.ino | 在Github上查看
復制代碼
// CIRC12 - RGB LED
// RGB LED PINS
// three pins：
// 9 = RED
// 10 = GREEN
// 11 = BLUE
int ledDigitalOne［］ = {9， 10， 11};
// define on as low
// （because you use a common anode RGB LED）
const boolean ON = LOW;
// define off as high
const boolean OFF = HIGH;
// Predefined Colors
const boolean RED［］ = {ON， OFF， OFF};
const boolean GREEN［］ = {OFF， ON， OFF};
const boolean BLUE［］ = {OFF， OFF， ON};
const boolean YELLOW［］ = {ON， ON， OFF};
const boolean CYAN［］ = {OFF， ON， ON};
const boolean MAGENTA［］ = {ON， OFF， ON};
const boolean WHITE［］ = {ON， ON， ON};
const boolean BLACK［］ = {OFF， OFF， OFF};
//An Array that stores the predefined colors
const boolean* COLORS［］ =
{RED， GREEN， BLUE，YELLOW， CYAN， MAGENTA，
WHITE， BLACK};
void setup（） {
for（int i = 0; i 《 3; i++）{
// set the 3 pins as outputs
pinMode（ledDigitalOne［i］， OUTPUT）;
}
}
void loop（） {
// set the color of the LED
setColor（ledDigitalOne， CYAN）;
// randomize it
// randomColor（）;
}
void randomColor（）{
// get random number within range of colors
int rand = random（0， sizeof（COLORS） / 2）;
setColor（ledDigitalOne， COLORS［rand］）;
delay（1000）;
}
void setColor（int* led， const boolean* color） {
for（int i = 0; i 《 3; i++）{
digitalWrite（led［i］， color［i］）;
}
}
// CIRC12 - RGB LED
// RGB LED PINS
// three pins：
// 9 = RED
// 10 = GREEN
// 11 = BLUE
int ledDigitalOne［］ = {9， 10， 11};
// define on as low
// （because you use a common anode RGB LED）
const boolean ON = LOW;
// define off as high
const boolean OFF = HIGH;
// Predefined Colors
const boolean RED［］ = {ON， OFF， OFF};
const boolean GREEN［］ = {OFF， ON， OFF};
const boolean BLUE［］ = {OFF， OFF， ON};
const boolean YELLOW［］ = {ON， ON， OFF};
const boolean CYAN［］ = {OFF， ON， ON};
const boolean MAGENTA［］ = {ON， OFF， ON};
const boolean WHITE［］ = {ON， ON， ON};
const boolean BLACK［］ = {OFF， OFF， OFF};
//An Array that stores the predefined colors
const boolean* COLORS［］ =
{RED， GREEN， BLUE，YELLOW， CYAN， MAGENTA，
WHITE， BLACK};
void setup（） {
for（int i = 0; i 《 3; i++）{
// set the 3 pins as outputs
pinMode（ledDigitalOne［i］， OUTPUT）;
}
}
void loop（） {
// set the color of the LED
setColor（ledDigitalOne， CYAN）;
// randomize it
// randomColor（）;
}
void randomColor（）{
// get random number within range of colors
int rand = random（0， sizeof（COLORS） / 2）;
setColor（ledDigitalOne， COLORS［rand］）;
delay（1000）;
}
void setColor（int* led， const boolean* color） {
for（int i = 0; i 《 3; i++）{
digitalWrite（led［i］， color［i］）;
}
}
有問題嗎？
LED保持暗或顯示不正確的顏色
使用四個插針LED如此緊密地結合在一起，有時很容易將其放錯位置。嘗試仔細檢查每個插針的位置。
綠色和藍色似乎相反
某些RGB LED交換了綠色和藍色，更改您的代碼，以便交換引腳并重新上傳！
看到紅色
紅色RGB LED中的二極管可能比其他兩個二極管亮一些。要使顏色更平衡，請嘗試使用較高的電阻器（或兩個串聯的電阻器）。
正在尋找更多內容？
如果您想做更多的事情，為什么不檢查一下可從中獲得的所有可愛的額外內容和鮑勃Adafruit商店。
變得更好
更多顏色
我想在您之前，您對藍綠色發光的LED印象不那么深刻。要顯示其他顏色，請將代碼中的顏色更改為其他顏色之一：
setColor（ledDigitalOne， CYAN）;-》 setColor（ledDigitalOne， newColor）
》
顯示隨機顏色
當然我們除了顯示恒定的顏色外，還可以做更多的事情。若要查看如何在隨機顏色之間循環，請將loop（）代碼更改為：
下載：文件
復制代碼
void loop（） {
//setColor（ledDigitalOne， CYAN）;
randomColor（）;
} void loop（） {
//setColor（ledDigitalOne， CYAN）;
randomColor（）;
}
模擬色彩控制
雖然在顏色之間進行切換很有趣，但當將RGB LED與模擬控制。使用PWM（脈沖寬度調制），幾乎可以產生任何顏色并在它們之間褪色。遺憾的是，對于上面的部分，此代碼太長了，因此請單擊下面的代碼以查看該代碼：
模擬色彩控制代碼
CIRC13：壓縮
力敏電阻（FSR）是使您能夠檢測施加在其上的壓力的傳感器。它們類似于電位計（例如在CIRC08中），除了通過扭力來改變電阻外，FSR的電阻會隨著壓力而變化。
FSR由2個由隔離層分隔的層組成。按下的次數越多，有源元件上與半導體接觸的點就越多，這會使電阻降低。它們不適用于檢測精確的重量，但對檢測擠壓，推擠和戳戳非常有用。如果您想更深入地研究FSR的工作原理，ladyada有很好的學習指南，其中涵蓋了更多的技術細節。
零件
5毫米綠色LED
如果您要訂購更多的綠色LED，請從Adafruit商店，請單擊此處！
力敏感電阻器
如果要從Adafruit商店訂購力敏感電阻器，請單擊此處！
10K歐姆電阻
顏色：棕色》黑色》橙色
如果您要訂購更多的10k ohm上拉電阻Adafruit商店的電阻器，請單擊此處！
560歐姆電阻
顏色： 綠色》藍色》棕色
如果您想從Adafruit商店訂購更多電阻器，請單擊此處！ （它們的電阻為470歐姆，但可以用）
面包板接線束
如果您想從Adafruit商店訂購更多電線，請單擊此處！
Adafruit Metro（或Metro Express）+面包板+安裝板
如果您尚未組裝，我們將為您提供方便的指南！
如果d想從Adafruit商店訂購額外的塑料安裝板，Adafruit Metro，AdafruitMetro Express或Mini-Breadboard，請點擊此處！
布線
該電路的布線對于地鐵和地鐵快遞。請注意，電源軌連接到3V而不是5V。
最后一個電路易于構建，但使用起來確實很有趣：
力敏電阻的一端（ FSR）連接到電源軌。
FSR的另一端連接到模擬引腳2 和一個10k歐姆上拉電阻。
連接一個紅色的LED指示燈連接到引腳9 和一個560歐姆的限流電阻。
可打印的面包板布局表
點擊此處下載適用于CIRC13的可打印的面包板布局表
代碼
將下面的代碼復制并粘貼到空白的Arduino草圖中。然后編譯并將其上傳到您的Metro。
下載：Project Zip 或 CIRC13_FSR.ino | 在Github上查看
復制代碼
/*
* Force Sensitive Resistor Test Code
*
* The intensity of the LED will vary with the amount of pressure on the sensor
*/
int sensePin = 2; // the pin the FSR is attached to
int ledPin = 9; // the pin the LED is attached to （use one capable of PWM）
void setup（） {
Serial.begin（9600）;
pinMode（ledPin， OUTPUT）; // declare the ledPin as an OUTPUT
}
void loop（） {
int value = analogRead（sensePin） / 4; //the voltage on the pin divded by 4 （to
//scale from 10 bits （0-1024） to 8 （0-255）
analogWrite（ledPin， value）; //sets the LEDs intensity proportional to
//the pressure on the sensor
Serial.println（value）; //print the value to the debug window
}
/*
* Force Sensitive Resistor Test Code
*
* The intensity of the LED will vary with the amount of pressure on the sensor
*/
int sensePin = 2; // the pin the FSR is attached to
int ledPin = 9; // the pin the LED is attached to （use one capable of PWM）
void setup（） {
Serial.begin（9600）;
pinMode（ledPin， OUTPUT）; // declare the ledPin as an OUTPUT
}
void loop（） {
int value = analogRead（sensePin） / 4; //the voltage on the pin divded by 4 （to
//scale from 10 bits （0-1024） to 8 （0-255）
analogWrite（ledPin， value）; //sets the LEDs intensity proportional to
//the pressure on the sensor
Serial.println（value）; //print the value to the debug window
}
不起作用？
LED指示燈不亮？
LED只能在一個中工作方向。嘗試將其取出并扭曲180度。 （不必擔心，向后安裝它不會造成永久損害）。
漸變為快/慢
這是FSR對壓力的響應不是線性的結果。但是不要擔心可以在代碼中對其進行更改（請查看“使它變得更好”部分中的詳細信息）
正在尋找更多內容？
您很幸運-本指南中有額外的 CIRC 界面和包括了幾個 PROJ 項目！查看左側的側邊欄以獲取完整列表。
變得更好
校準范圍
雖然光線正在逐漸消失，但其響應可能并不十分完美。要調整響應，我們需要在代碼中再增加一行：
map（value， fromLow， fromHigh， toLow， toHigh）
要校準傳感器，我們可以像使用CIRC- 11。打開串行監視器，然后在完全按下傳感器時將fromLow值替換為值顯示。
然后，將fromHigh值替換為未按下的值。
最后，填寫范圍toLow = 0和toHigh = 255
結果將如下所示：
下載：文件
復制代碼
int value = analogRead（sensePin）;
map（value， 125， 854， 0， 255）;
analogWrite（ledPin， value）; int value = analogRead（sensePin）;
map（value， 125， 854， 0， 255）;
analogWrite（ledPin， value）;
RGB Strongperson測試
步驟馬上通過Adafruit Metro High Striker Game來測試自己的力量！只有最強的人才能成功！讓我們使用RGB LED快速修改電路以指示強度級別，并修改代碼以顯示有人按下力敏電阻的力度。
圖：RGB +力電阻器
下面的代碼將需要首先運行，然后進行修改。運行它后，打開串行監視器，并盡可能用力按力敏電阻。印刷的值是有人可以在電路上按下FSR的maxForce。將maxForce設置為串行監視器中的值：
// set maxForce
int maxForce = FORCEVALUE;
設置了maxForce之后，祝您好運！我們提供了一個串行打印輸出，以顯示您壓下FSR的程度。
下載：file
復制代碼
/*
FSR Strongperson Test for Metro （and Metro Express）
Utilizes a FSR and a RGB LED to test how strong you are.
Created 7 July 2017
By Brent Rubell for Adafruit Industries
Support Open Source ~ buy Adafruit
*/
// fsr pin
int sensePin = A2;
// rgb led pins
int rgbLED［］ = {9， 10， 11};
// common cathode rgbleds
const boolean ON = LOW;
const boolean OFF = HIGH;
// predefined colors
const boolean BLUE［］ = {ON， OFF， OFF};
const boolean RED［］ = {OFF， OFF， ON};
const boolean GREEN［］ = {OFF， ON， OFF};
void setup（） {
Serial.begin（9600）;
// set all rgb pins as outputs
for（int i = 0; i《3; i++）{
pinMode（rgbLED［i］， OUTPUT）;
}
}
void loop（） {
// scale voltage down to 255 from 1023
int force = analogRead（sensePin） / 4;
// check maximum force by squeezing the FSR
Serial.println（force）;
// set maxForce
int maxForce = 160;
// calculate regions
int lowForce = maxForce / 3;
int medForce = （maxForce / 3） * 2;
// check force regions
if（force 《 lowForce） {
Serial.println（“easy”）;
setColor（rgbLED， RED）;
}
else if （force 》 lowForce && force 《 medForce） {
Serial.println（“medium”）;
setColor（rgbLED， BLUE）;
}
else {
Serial.println（“hard”）;
setColor（rgbLED， GREEN）;
}
}
// rgb color mixing
void setColor（int* led， const boolean* color） {
for（int i = 0; i 《 3; i++）{
digitalWrite（led［i］， color［i］）;
}
} /*
FSR Strongperson Test for Metro （and Metro Express）
Utilizes a FSR and a RGB LED to test how strong you are.
Created 7 July 2017
By Brent Rubell for Adafruit Industries
Support Open Source ~ buy Adafruit
*/
// fsr pin
int sensePin = A2;
// rgb led pins
int rgbLED［］ = {9， 10， 11};
// common cathode rgbleds
const boolean ON = LOW;
const boolean OFF = HIGH;
// predefined colors
const boolean BLUE［］ = {ON， OFF， OFF};
const boolean RED［］ = {OFF， OFF， ON};
const boolean GREEN［］ = {OFF， ON， OFF};
void setup（） {
Serial.begin（9600）;
// set all rgb pins as outputs
for（int i = 0; i《3; i++）{
pinMode（rgbLED［i］， OUTPUT）;
}
}
void loop（） {
// scale voltage down to 255 from 1023
int force = analogRead（sensePin） / 4;
// check maximum force by squeezing the FSR
Serial.println（force）;
// set maxForce
int maxForce = 160;
// calculate regions
int lowForce = maxForce / 3;
int medForce = （maxForce / 3） * 2;
// check force regions
if（force 《 lowForce） {
Serial.println（“easy”）;
setColor（rgbLED， RED）;
}
else if （force 》 lowForce && force 《 medForce） {
Serial.println（“medium”）;
setColor（rgbLED， BLUE）;
}
else {
Serial.println（“hard”）;
setColor（rgbLED， GREEN）;
}
}
// rgb color mixing
void setColor（int* led， const boolean* color） {
for（int i = 0; i 《 3; i++）{
digitalWrite（led［i］， color［i］）;
}
}
其他應用程序
有了傳感器，真正的樂趣就在于如何以整潔而出乎意料的方式使用它們。因此，請思考一下感測力如何以及在何處可以改善您的生活（或其他人的生活）。
CIRC14：字符LCD
我們在Adafruit商店中提供了許多不同類型的字符LCD。實驗者工具包提供了一種，但如果您還沒有，則在實驗者指南中使用16x2變體。
字符LCD對于顯示文本，數據，可變信息或提供交互界面。您已經在先前的學習指南中使用了串行監視器。雖然從Metro顯示數據很有用，但需要通過USB將其綁定到計算機。字符LCD使您可以自由放置任何想要打印的顯示-文本，數據甚至小圖標（5像素x 7像素）
零件
16x2字符LCD
如果您想從Adafruit商店購買藍白色的16x2字符LCD，請單擊此處！
面包板微調電位器-10k
如果您想從Adafruit商店購買一個額外的微調鍋，請單擊此處！
面包板接線束
如果您想從Adafruit商店訂購更多電線，請點擊此處！
Adafruit Metro（或Metro Express）+面包板+安裝板
如果您尚未組裝，我們將為您提供方便的指南！
如果您想訂購額外的塑料安裝板，Adafruit Metro，AdafruitMetro Express或Mini -Adafruit商店的面包板請單擊此處！
接線
此頁面上的說明和接線基于ladyada出色的字符LCD接線指南，但已針對弗里辛特進行了更新。
組裝LCD
某些16x2 LCD可能已經組裝好了，這意味著接頭已經焊接到了：
組裝好的標準LCD 16x2 +附加功能-藍底白字
產品ID：1447
標準的HD44780 LCD對于創建獨立項目非常有用。此產品類似于我們的標準LCD 16x2顯示屏。。.
$ 10.95
入庫存
添加到購物車
我們還有一些未組裝的帶有未焊接頭的產品：
標準LCD 16x2 +其他功能
產品ID：181
標準HD44780 LCD適用于創建獨立的項目。16個字符，2行，藍色背景上的白色文本連接端口為0.1“ 。。.
$ 9.95
庫存div》
添加到購物車
如果已組裝液晶顯示器，則可以跳過以下后續步驟，直接進行操作
div》焊接LCD
焊接在電子領域是一項非常有用的技能。這是將兩種金屬結合在一起的過程，使用另一種金屬（也包括它們之間）。如果您以前從未做過此事，比爾·厄爾（Bill Earl）撰寫了一篇很棒的視覺指南，名為《 Adafruit卓越焊接指南》 ，它將使您快速入門。如果您希望觀看視頻，Collin的實驗室也涵蓋了焊接工作：
16x2 LCD并不難焊接，但是它確實有很多別針。我們有一些建議像專業人士那樣焊接：
首先將16x2 LCD和插頭插入面包板。
然后，（具有中等熱量，不要使熨斗過熱！）開始將 Pin 1 焊接到割臺。下一個焊錫引腳16。這會將焊錫頭“固定”到LCD上，從而焊接其余的引腳焊錫。
現在，將所有焊錫焊接起來其他針腳！
沒事嗎？您的標頭有問題嗎？焊接很容易修復。這只需要時間。在繼續操作之前，請檢查本指南中的錯誤，并進行更正。
接線和背光
如果這些照片太小，您可以右鍵單擊它們-》“復制圖像地址”，然后將該地址粘貼到瀏覽器的URL欄中以獲取完整分辨率的屏幕截圖。
首先，將LCD插入面包板。然后，將 + 5V Pin 連接到電源軌，將 GND Pin 連接到接地軌。
下一步，連接將LCD引腳16 連接到GND導軌，將 LCD引腳15 連接到電源導軌。
在執行電源檢查之前不要繼續
讓我們檢查一下它的功能。將Metro或Metro Express連接到電源。您應該看到LCD亮起。一些低成本的LCD不帶背光。
如果您的LCD帶有背光，并且如果您沒有看到背光，請返回并檢查接線。
布線對比電路
下一步，讓我們將對比度電位計放在LCD引腳16的左側。您可以將其放在面包板上的任何位置一樣，但下一個CIRC放置在 LCD Pin 16
將電位計的外部引腳之一連接到電源導軌。將另一個外部引腳連接到接地導軌。不管走到哪里，只要一個引腳上電并且一個引腳接地，其他引腳就可以互換。
電位器（抽頭）的中間連接到 LCD引腳3
LCD引腳1 連接到接地軌。 LCD引腳2 連接到電源軌。這些引腳是LCD的邏輯。
在通電后看到矩形并且電位計已扭曲之前不要繼續移動。
在繼續之前，我們將進行一次小測試以確保接線正確。插入Metro或Metro Express并扭轉電位計。您應該看到LCD第一行上出現黑色矩形。 如果看不到，請在繼續操作之前檢查接線。
接線數據總線
接下來，我們將連接 RS引腳。我們使用藍線將 LCD Pin 4 連接到 Metro Digital Pin 7
本指南不需要 RW 引腳，因為我們只是在寫到顯示器。將 LCD引腳5 連接到接地導軌。
下一步是 EN針。我們使用綠線將 LCD Pin 6 連接到 Metro Digital Pin 8
接下來是第一個數據引腳DB7。我們使用白線將 LCD Pin 14 連接到 Metro Digital Pin 12
DB6 接下來是。我們使用橙色線將 LCD Pin 13 連接到 Metro Digital Pin 11
從 LCD引腳12連接 DB5 （我們使用紫線）到 Metro DigitalPin 10。
最后，我們用一條灰線將 DB4 連接到 LCD Pin 11 到 Metro DigitalPin 9
檢查您是否擁有數據引腳之間的4線間隙是這樣的：
這是您應該在辦公桌上看到的內容，請轉到代碼部分af ter仔細檢查一下接線：
代碼
將以下代碼復制并粘貼到新的Arduino草圖中。然后，將其編譯并上傳到Metro或Metro Express。
請勿這個CIRC尚未分開。。. CIRC15使用LCD，并且您不想再次連接它。
下載：Project Zip 或 CIRC14_CHAR_LCD.ino | 在Github上查看
復制代碼
/*
LiquidCrystal Library - Hello World
Demonstrates the use a 16x2 LCD display. The LiquidCrystal
library works with all LCD displays that are compatible with the
Hitachi HD44780 driver. There are many of them out there， and you
can usually tell them by the 16-pin interface.
This sketch prints “Hello World！” to the LCD
and shows the time.
The circuit：
* LCD RS pin to digital pin 12
* LCD Enable pin to digital pin 11
* LCD D4 pin to digital pin 5
* LCD D5 pin to digital pin 4
* LCD D6 pin to digital pin 3
* LCD D7 pin to digital pin 2
* LCD R/W pin to ground
* LCD VSS pin to ground
* LCD VCC pin to 5V
* 10K resistor：
* ends to +5V and ground
* wiper to LCD VO pin （pin 3）
Library originally added 18 Apr 2008
by David A. Mellis
library modified 5 Jul 2009
by Limor Fried （http://www.ladyada.net）
example added 9 Jul 2009
by Tom Igoe
modified 22 Nov 2010
by Tom Igoe
This example code is in the public domain.
http://www.arduino.cc/en/Tutorial/LiquidCrystal
*/
// include the library code：
#include
// initialize the library with the numbers of the interface pins
// modified for Metro Explorers Guide
LiquidCrystal lcd（7， 8， 9， 10， 11， 12）;
void setup（） {
// set up the LCD‘s number of columns and rows：
lcd.begin（16， 2）;
// Print a message to the LCD.
lcd.print（“hello， world！”）;
}
void loop（） {
}
/*
LiquidCrystal Library - Hello World
Demonstrates the use a 16x2 LCD display. The LiquidCrystal
library works with all LCD displays that are compatible with the
Hitachi HD44780 driver. There are many of them out there， and you
can usually tell them by the 16-pin interface.
This sketch prints “Hello World！” to the LCD
and shows the time.
The circuit：
* LCD RS pin to digital pin 12
* LCD Enable pin to digital pin 11
* LCD D4 pin to digital pin 5
* LCD D5 pin to digital pin 4
* LCD D6 pin to digital pin 3
* LCD D7 pin to digital pin 2
* LCD R/W pin to ground
* LCD VSS pin to ground
* LCD VCC pin to 5V
* 10K resistor：
* ends to +5V and ground
* wiper to LCD VO pin （pin 3）
Library originally added 18 Apr 2008
by David A. Mellis
library modified 5 Jul 2009
by Limor Fried （http://www.ladyada.net）
example added 9 Jul 2009
by Tom Igoe
modified 22 Nov 2010
by Tom Igoe
This example code is in the public domain.
http://www.arduino.cc/en/Tutorial/LiquidCrystal
*/
// include the library code：
#include
// initialize the library with the numbers of the interface pins
// modified for Metro Explorers Guide
LiquidCrystal lcd（7， 8， 9， 10， 11， 12）;
void setup（） {
// set up the LCD’s number of columns and rows：
lcd.begin（16， 2）;
// Print a message to the LCD.
lcd.print（“hello， world！”）;
}
void loop（） {
}
不起作用？
我的字符LCD沒有點亮。
仔細檢查您與字符LCD的電源和背光引腳的接線連接是否正確。檢查您的焊點，也許是有問題的。
還要檢查您使用的是 5v Pin 而不是 3.3V Pin。
我只在液晶顯示屏上看到黑色塊
嘗試扭曲電位計。您的數據總線也可能未正確連接。
我什么都沒看到
重新接線LCD是消除任何問題的好方法，雖然要花費很多時間，但要確保一切正常正確。如果其他所有方法都失敗，請在Adafruit支持論壇中發布，我們將盡快與您聯系。
變得更好
第二行
如果要寫入第二行，可以使用lcd.setCursor（COLUMN， LINE），以使列為0，行為1：
lcd.setCursor（0，1）;
下載：文件
復制代碼
void loop（） {
// set the cursor to column 0， line 1
// （note： line 1 is the second row， since counting begins with 0）：
lcd.setCursor（0， 1）;
// print the number of seconds since reset：
lcd.print（millis（） / 1000）;
} void loop（） {
// set the cursor to column 0， line 1
// （note： line 1 is the second row， since counting begins with 0）：
lcd.setCursor（0， 1）;
// print the number of seconds since reset：
lcd.print（millis（） / 1000）;
}
請勿分解CIRC尚未使用，CIRC15使用LCD，并且您不想再次連接它。
將光傳感器寫入LCD
讓我們嘗試將光傳感器的輸出寫入字符LCD。
這將需要額外的一部分：
照片傳感器
如果您想從Adafruit商店訂購另一個光敏電阻，請單擊此處！
接線
Metro和Metro Express的“使它變得更好”的接線是相同的。確保導軌連接到5V。
注意：當導軌連接到5V時，光傳感器連接到3V。
代碼
復制并粘貼下面的代碼進入Arduino編輯器。然后，編譯并將其上傳到您的電路板上。
下載：文件
復制代碼
/* CIRC14 - Make It Better
* Character LCD + TMP36
*
* by Brent Rubell for Adafruit Industries. Support Open Source， buy Adafruit！
*/
// include the library code：
#include
// modified wiring for Metro Explorers Guide
LiquidCrystal lcd（7， 8， 9， 10， 11， 12）;
// photo light sensor
int lightPin = A0;
void setup（） {
// set up the LCD‘s number of columns and rows：
lcd.begin（16， 2）;
// print to the first line of the LCD
lcd.print（“Light Value：”）;
}
void loop（） {
// read the light level
int lightLevel = analogRead（lightPin）;
// map and constrain the light sensor values
lightLevel = map（lightLevel， 0， 900， 0， 255）;
lightLevel = constrain（lightLevel， 0， 255）;
// set the cursor to column 0， line 1
lcd.setCursor（0， 1）;
// write lightLevel to the LCD
lcd.print（lightLevel）;
}
/* CIRC14 - Make It Better
* Character LCD + TMP36
*
* by Brent Rubell for Adafruit Industries. Support Open Source， buy Adafruit！
*/
// include the library code：
#include
// modified wiring for Metro Explorers Guide
LiquidCrystal lcd（7， 8， 9， 10， 11， 12）;
// photo light sensor
int lightPin = A0;
void setup（） {
// set up the LCD’s number of columns and rows：
lcd.begin（16， 2）;
// print to the first line of the LCD
lcd.print（“Light Value：”）;
}
void loop（） {
// read the light level
int lightLevel = analogRead（lightPin）;
// map and constrain the light sensor values
lightLevel = map（lightLevel， 0， 900， 0， 255）;
lightLevel = constrain（lightLevel， 0， 255）;
// set the cursor to column 0， line 1
lcd.setCursor（0， 1）;
// write lightLevel to the LCD
lcd.print（lightLevel）;
}
下一步是什么？
溫度計（CIRC15）進入字符LCD的實質。您將學習如何顯示自定義字符，完整的文本字符串以及多行數據輸出！
CIRC15：溫度計
如果您想顯示更多的輸出而不是一堆LED可以處理的怎么辦？當然，您可以設置一堆LED來顯示數字。但是，如果還有另一種方法呢……
字符LCD超級堅固并且非常適合輸出。當您放入 LiquidCrystal 庫時，您可以在代碼中輸出任何到16（行）乘2（行）屏幕上的代碼，這些代碼可以讓我們您將在電路中添加新功能。
我們將重新創建CIRC10。但是，我們將打印到外部字符LCD，而不是打印到串行監視器。
零件
16x2字符LCD
如果您想從Adafruit商店購買藍白色的16x2字符LCD，請單擊此處！
面包板微調電位器-10k
如果您想從Adafruit商店購買一個額外的微調鍋，請單擊此處！
此電路使用的是TMP36，而不是NPN晶體管。
我是使用 TMP36溫度傳感器或 NPN晶體管
《臺式s =“ build-table”》
模擬溫度傳感器
如果您想要一個額外的溫度傳感器，可以從Adafruit商店購買一個，單擊此處
面包板接線束
如果您想從Adafruit商店訂購更多電線，請點擊此處！
Adafruit Metro（或Metro Express）+面包板+安裝板
如果尚未組裝此產品，我們有一個方便的指南！
如果您想訂購額外的塑料安裝座或點擊Adafruit Shop中的Adafruit Metro，AdafruitMetro Express或Mini-Breadboard，請點擊此處！
接線
字符LCD的接線可能很棘手。有一個學習指南，貫穿每條電線。如果要使用它，請確保將LCD放在面包板的右側，以確保您也可以將電位計和TMP36傳感器安裝在面包板上。
代碼
CIRC15使用的代碼適用于 Metro和Metro Express。兩者都需要。 對其進行修改，以使其能夠與您擁有的Metro一起使用。（如果不確定您所擁有的板，請單擊此處！）。
如果您正在使用Metro Express，請將#define ANALOGREFVOLTAGE更改為#define ANALOGREFVOLTAGE 3.333
代碼：
下載：Project Zip 或 CIRC15_THERMOMETER.ino | 在Github上查看
復制代碼
/*
* CIRC15： Digital Thermometer
* Experimenter‘s Guide for Metro （and Metro Express！）
* by Brent Rubell for Adafruit Industries ~ Support Open Source， buy adafruit！
*/
// If you’re using a METRO EXPRESS， change this value to 3.333
#define ANALOGREFVOLTAGE 5.000
// include the lcd library code：
#include
// initialize the library with the numbers of the interface pins
LiquidCrystal lcd（7， 8， 9， 10， 11， 12）;
// TMP36 Pin
int temperaturePin = 0;
void setup（） {
Serial.begin（9600）;
// set up the LCD‘s number of columns and rows：
lcd.begin（16， 2）;
}
void loop（） {
float temperature = 0;
temperature = getVoltage（temperaturePin）;
/* Output： Degrees C */
temperature = （temperature - .5） * 100;
/* Output： Degrees F */
// temperature = （（（temperature - .5） * 100）*1.8） + 32;
/* Output： Voltage */
// temperature = （temperature - .5） * 100; d
// Write temperature to the LCD
lcd.print（“Temp： ”）;
lcd.setCursor（6，0）;
lcd.print（temperature）;
lcd.setCursor（11，0）;
lcd.print（“*C”）;
// Wait 1s
delay（1000）;
// Refresh the LCD
lcd.clear（）;
}
float getVoltage（int pin） {
return（float（analogRead（pin））* float（ANALOGREFVOLTAGE/1023.000））;
}
/*
* CIRC15： Digital Thermometer
* Experimenter’s Guide for Metro （and Metro Express！）
* by Brent Rubell for Adafruit Industries ~ Support Open Source， buy adafruit！
*/
// If you‘re using a METRO EXPRESS， change this value to 3.333
#define ANALOGREFVOLTAGE 5.000
// include the lcd library code：
#include
// initialize the library with the numbers of the interface pins
LiquidCrystal lcd（7， 8， 9， 10， 11， 12）;
// TMP36 Pin
int temperaturePin = 0;
void setup（） {
Serial.begin（9600）;
// set up the LCD’s number of columns and rows：
lcd.begin（16， 2）;
}
void loop（） {
float temperature = 0;
temperature = getVoltage（temperaturePin）;
/* Output： Degrees C */
temperature = （temperature - .5） * 100;
/* Output： Degrees F */
// temperature = （（（temperature - .5） * 100）*1.8） + 32;
/* Output： Voltage */
// temperature = （temperature - .5） * 100; d
// Write temperature to the LCD
lcd.print（“Temp： ”）;
lcd.setCursor（6，0）;
lcd.print（temperature）;
lcd.setCursor（11，0）;
lcd.print（“*C”）;
// Wait 1s
delay（1000）;
// Refresh the LCD
lcd.clear（）;
}
float getVoltage（int pin） {
return（float（analogRead（pin））* float（ANALOGREFVOLTAGE/1023.000））;
}
上傳此代碼后，請確保背光燈亮起并扭轉電位計，直到您可以清楚地看到文本/數字。
有問題嗎？
我在LCD上看不到任何東西
嘗試扭曲電位計。如果那不起作用，請重新檢查您的接線。
LCD上的文本是奇怪的字符或亂碼
確保LCD的引腳與面包板齊平。如果不起作用，請從Arduino重新上傳草圖。
LCD上的數字不可能，太高/太低
所包含的代碼中有一行使用串行監視器。彈出打開串行監視器，并根據您認為的當前溫度檢查其中的編號。如果數字似乎不正確，請仔細檢查與模擬引腳A0的接線。
我仍然遇到麻煩，我認為圖中太復雜了。
字符LCD上有一個 lot
變得更好
使用華氏溫度
我們將把示例代碼顯示的度數轉換為攝氏度，以華氏度為單位。在loop（）中，更改以下行：
下載：文件
復制代碼
// Degrees C
//temperature = （temperature - .5） * 100;
// Degrees F
temperature = （（（temperature - .5） * 100）*1.8） + 32;
// Degrees C
//temperature = （temperature - .5） * 100;
// Degrees F
temperature = （（（temperature - .5） * 100）*1.8） + 32;
然后，將草圖編譯并上傳到Metro并觀察編號變化。
在LCD上打印新文本
注意到即使編號更改了， * C 仍被打印到您的顯示器上嗎？這是因為* C被硬編碼到顯示器中。
要將* C更改為* F，請更改以下行：
lcd.print（“*C”）; - 》 lcd.print（“*F”）;
然后編譯并上傳到Metro。您的溫度應顯示華氏單位和溫度符號。
打印到SecondRow
簡介中提到此LCD為16x2。您可以打印兩行行，但我們僅使用其中一行。讓我們將 * F 符號打印到第二行的同一位置。為此，請在您的loop（）中修改以下代碼：
下載：文件
復制代碼
lcd.setCursor（11，1）; // instead of （11，0）， we are printing to （11，1）， the 2nd row
lcd.print（“*F”）; lcd.setCursor（11，1）; // instead of （11，0）， we are printing to （11，1）， the 2nd row
lcd.print（“*F”）;
使用自定義字符
LiquidCrystal庫包含一個名為createchar（） 的命令，該命令可以為以下命令創建自定義字符（字形！）打印到液晶顯示屏。我們的代碼使用星號代替度數符號。讓我們完成恒溫器并使用 real 度符號。
為此，請在您的 setup（）循環上方添加以下代碼：
下載：文件
復制代碼
// Custom Degree Symbol
byte degree［8］ = {
0x7，
0x5，
0x7，
0x0，
0x0，
0x0，
0x0，
}; // Custom Degree Symbol
byte degree［8］ = {
0x7，
0x5，
0x7，
0x0，
0x0，
0x0，
0x0，
};
在setup（）循環中，添加以下行：
lcd.createChar（0，degree）;
最后，在 loop（）中修改以下行：
下載：文件
復制代碼
lcd.setCursor（11，1）;
lcd.write（byte（0））; // custom degrees character
lcd.setCursor（12，1）;
lcd.print（“F”）; lcd.setCursor（11，1）;
lcd.write（byte（0））; // custom degrees character
lcd.setCursor（12，1）;
lcd.print（“F”）;
編譯并上傳后，您應該在F旁邊看到度數符號。
制作自己的自定義字符
如果您想添加更多或其他自定義字符，我們會提供一個很棒的在線生成器。您可以根據需要添加自己的圖標。讓我們學習如何執行此操作：
首先，訪問HD44780圖形生成器站點。然后，將字符大小更改為 5 x 8
單擊框設置像素。設置像素后，它將從綠色變為黑色。您可以通過單擊黑色像素（打開）以使其變為綠色（關閉）來取消設置像素。
自定義字符后，復制“ In Hex”中的值并將其作為字節數組粘貼到Arduino草圖中：
下載：文件
復制代碼
// smiley face
byte smile［8］ = {
0x0，
0x0，
0x8，
0x0，
0x0，
0x0，
0x0，
}; // smiley face
byte smile［8］ = {
0x0，
0x0，
0x8，
0x0，
0x0，
0x0，
0x0，
};
在setup（）循環中，添加以下行：
lcd.createChar（0，smile）;
然后，在loop（）中添加以下內容以將您的自定義字符寫入LCD：
lcd.write（byte（0））; // custom degrees character
CIRC16：紅外傳感器
紅外接收器傳感器經過光電調節，可以接收紅外頻率。人眼看不到紅外頻率，但可以通過網絡攝像頭或手機拾取。
嘗試按Mini Remote Control或電視/DVD播放器遙控器上的按鈕，然后將其照在您的網絡攝像頭上。您看到的由遙控器發出的光是紅外光。。這些紅外信號是帶有脈沖（標記）和間隔（空格）的32位PWM信號。
《實驗者指南》使用IRLib，這是一個易于理解的Arduino庫，可消除紅外光接收器的神秘感。在代碼部分，我們將遍歷安裝該庫并將其用于此電路。
零件
IR（紅外）接收器傳感器
如果您想在Adafruit商店訂購額外的IR接收器傳感器，請單擊此處！
小型遙控器
我們建議將此遙控器與CIRC15一起使用，但您可以使用任何遙控器
如果您想從Adafruit商店訂購額外的迷你遙控器，請單擊此處！
5mm紅色LED
如果您想從A處訂購更多紅色LED（它們使指示燈亮！）。 dafruit商店，請單擊此處！
560歐姆電阻
顏色：綠色》藍色》棕色
如果想從Adafruit商店訂購更多電阻，請點擊這里！ （它們的電阻為470歐姆，但可以用）
面包板接線束
如果您想從Adafruit商店訂購更多電線，請單擊此處！
Adafruit Metro（或Metro Express）+面包板+安裝板
如果您尚未組裝，我們將為您提供方便的指南！
如果d想從Adafruit商店訂購額外的塑料安裝板，Adafruit Metro，AdafruitMetro Express或Mini-Breadboard，請點擊此處！
接線
請勿將數字引腳6以外的其他任何數字引腳用于
此電路的接線與Metro和Metro Express的相同相同。
安裝IR庫
庫
《實驗者指南》使用 IRLib2 ，這是一個易于理解的Arduino庫，可消除紅外光接收器的神秘感。它使編寫紅外接收器和紅外LED的代碼變得更加容易。
安裝IR庫
下載最新的紅外庫
要安裝IR庫，請執行以下操作：
單擊上面的按鈕下載IR庫，或直接從Github的IRLib 2.x庫下載它。
下載完成后解壓縮ZIP文件。
檢查未壓縮的文件夾是否包含五個單獨的文件夾。 IRLib 2.x包含多個可協同工作的庫。
將所有五個復制到您的Arduino Library文件夾根目錄中。該路徑通常位于（主頁）/Documents/Arduino/Libraries 中。如果沒有看到/Libraries/文件夾，則可能需要自己創建一個。
重新啟動Arduino IDE。
代碼
確保您已遵循安裝IR庫頁面。復制下面的代碼并將其粘貼到空白的Arduino Sketch中。然后，編譯代碼并將其上傳到您的Metro。
按下按鈕1，LED將會亮起。任何其他按鈕都將關閉LED。
Download：Project Zip 或 CIRC16_IR.ino | 在Github上查看
復制代碼
/*
* Metro Explorers Guide
* CIRC16： IR Sensor
*
* Desc： Turns on and off a 5mm Red LED with Mini Remote （NEC）
* by Brent Rubell for Adafruit Industries. Support Open Source， buy Adafruit！
*
* Note： this sketch requires IRLIB2.x
*/
// include all IRLib 2.x libraries
#include
// These values are for the Adafruit Mini Remote （using the NEC Protocol）
#define MY_PROTOCOL NEC
// Handles NEC repeat codes
uint32_t Previous;
// button（s）
#define BUTTON_0 0xfd30cf
#define BUTTON_1 0xfd08f7
#define BUTTON_2 0xfd8877
#define BUTTON_3 0xfd48b7
#define BUTTON_4 0xfd28d7
#define BUTTON_5 0xfda857
#define BUTTON_6 0xfd6897
#define BUTTON_7 0xfd18e7
#define BUTTON_8 0xfd9867
#define BUTTON_9 0xfd58a7
// pin for the reciever
IRrecv myReceiver（6）;
// decoder class
IRdecode myDecoder;
// LED PIN
int ledPin = 13;
void setup（） {
// set the ledPin as an output
pinMode（ledPin， OUTPUT）;
// enable the receiver
myReceiver.enableIRIn（）;
}
void loop（） {
// if the receiver gets a signal
if（myReceiver.getResults（）） {
// decode the signal
myDecoder.decode（）;
// set the decoder‘s protocol to the set protocol
if（myDecoder.protocolNum == MY_PROTOCOL） {
// if there
if（myDecoder.value == 0xFFFFFFFF） {
// keep the led set to the last button value
myDecoder.value = Previous;
}
// based on myDecoder.value， switch between button codes
switch（myDecoder.value） {
// Turn on the LED
case BUTTON_1：
digitalWrite（ledPin， HIGH）;
break;
// otherwise， turn off the LED
default：
digitalWrite（ledPin， LOW）;
break;
}
// keep the LED set to the last button value
Previous = myDecoder.value;
}
// enable the IR receiver
myReceiver.enableIRIn（）;
}
}
// sets the color of the RGB LED
void setColor（int* led， const boolean* color） {
for（int i = 0; i 《 3; i++） {
digitalWrite（led［i］， color［i］）;
}
}
/*
* Metro Explorers Guide
* CIRC16： IR Sensor
*
* Desc： Turns on and off a 5mm Red LED with Mini Remote （NEC）
* by Brent Rubell for Adafruit Industries. Support Open Source， buy Adafruit！
*
* Note： this sketch requires IRLIB2.x
*/
// include all IRLib 2.x libraries
#include
// These values are for the Adafruit Mini Remote （using the NEC Protocol）
#define MY_PROTOCOL NEC
// Handles NEC repeat codes
uint32_t Previous;
// button（s）
#define BUTTON_0 0xfd30cf
#define BUTTON_1 0xfd08f7
#define BUTTON_2 0xfd8877
#define BUTTON_3 0xfd48b7
#define BUTTON_4 0xfd28d7
#define BUTTON_5 0xfda857
#define BUTTON_6 0xfd6897
#define BUTTON_7 0xfd18e7
#define BUTTON_8 0xfd9867
#define BUTTON_9 0xfd58a7
// pin for the reciever
IRrecv myReceiver（6）;
// decoder class
IRdecode myDecoder;
// LED PIN
int ledPin = 13;
void setup（） {
// set the ledPin as an output
pinMode（ledPin， OUTPUT）;
// enable the receiver
myReceiver.enableIRIn（）;
}
void loop（） {
// if the receiver gets a signal
if（myReceiver.getResults（）） {
// decode the signal
myDecoder.decode（）;
// set the decoder’s protocol to the set protocol
if（myDecoder.protocolNum == MY_PROTOCOL） {
// if there
if（myDecoder.value == 0xFFFFFFFF） {
// keep the led set to the last button value
myDecoder.value = Previous;
}
// based on myDecoder.value， switch between button codes
switch（myDecoder.value） {
// Turn on the LED
case BUTTON_1：
digitalWrite（ledPin， HIGH）;
break;
// otherwise， turn off the LED
default：
digitalWrite（ledPin， LOW）;
break;
}
// keep the LED set to the last button value
Previous = myDecoder.value;
}
// enable the IR receiver
myReceiver.enableIRIn（）;
}
}
// sets the color of the RGB LED
void setColor（int* led， const boolean* color） {
for（int i = 0; i 《 3; i++） {
digitalWrite（led［i］， color［i］）;
}
}
不起作用？
我看不到顏色變化
是你的嗎？ RGB LED是否正確接線？您使用的遙控器與MetroX或MetroX Express Kit中包含的遙控器不同嗎？如果是這樣，請查看CIRC17中使用不同紅外源的示例。
i》
致命錯誤：IRLibAll.h：沒有這樣的文件或目錄#include
IRLib 2.x庫安裝不正確。返回步驟并確保已安裝。
我仍然看不到任何東西
斷路不好玩，請在Adafruit支持論壇中發布，我們會盡快與您聯系。
CIRC17：IR重播
我們將構建一個IR重播電路。該電路使用兩者紅外LED和紅外傳感器（您在CIRC15中使用了它）來構建一個電路，該電路可以記錄和播放來自任何遙控器的紅外信號。
Adafruit TV-B-Gone套件是此軟件的一個很棒的應用程序，并且是一個非常有趣的應用程序，它可以關閉酒吧，商店或醫生辦公室中那些討厭的電視。
重放紅外信號的概念在其他領域也非常有用。當收到特定的紅外信號時，Somegarage開門器會打開車庫。做一些探索，找出您擁有的設備受到紅外信號的控制，并對其進行控制。
另一個應用程序是構建輔助設備，該設備可以幫助沒有能夠執行日常活動。您可以通過組合此電路和FSR來創建出色的輔助設備，從而對IR操作的任何物體進行踏板/按動操作的遙控器。
您甚至可以組合此電路和繼電器用于CIRC11中，從附近的遙控器接收信號并控制繼電器以切換直流供電設備（例如風扇或電燈）的電源。
零件
IR（紅外）接收器傳感器
如果您想在Adafruit商店訂購額外的IR接收器傳感器，請單擊此處！
超高亮度5mm紅外LED
如果您要要從Adafruit商店訂購額外的5mm紅外LED，請單擊此處
此CIRC使用NPN晶體管，而不是TMP36。
《我使用的是 NPN晶體管或 TMP36 溫度傳感器
晶體管（PN2222或MPS2222）
如果您想從Adafruit商店訂購額外的NPN晶體管，請點擊此處！
按鈕 數量：x2
如果您想從Adafruit商店訂購更多按鈕，請單擊此處！
5mm紅色LED
如果您要訂購更多紅色Adafruit商店的LED（它們使指示燈亮！），請點擊此處！
560歐姆電阻
顏色：綠色》藍色》棕色
數量：x2
如果您想從Adafruit商店訂購更多電阻，請單擊此處！ （它們的電阻為470歐姆，但可以用）
10K歐姆電阻
顏色：棕色》黑色》橙色
數量： x2
如果您想從Adafruit商店訂購更多的10k歐姆上拉電阻，請單擊此處！
小型遙控器（可選） ）
您可以在該電路中使用任何遙控器。
如果您想從Adafruit商店訂購額外的迷你遙控器，請單擊此處！
面包板接線束
如果您想從Adafruit商店訂購更多電線，請點擊此處！
Adafruit Metro +面包板+安裝板
如果您尚未組裝，我們將為您提供方便的指南！
如果您想從以下位置訂購額外的塑料安裝板，Adafruit Metro或Mini-Breadboard： Adafruit Shop單擊此處！
接線
我們將許多組件隔開，以免它們在面包板上重疊。接線 NPN 晶體管時要小心-它必須具有特定的方向。
代碼
您需要安裝IRLIB2.x庫才能使用CIRC17。如果需要安裝，請單擊此處！
將下面的代碼復制并粘貼到Arduino編輯器中，然后進行編譯并將其上傳到您的開發板上。 p》
下載：文件
復制代碼
/* CIRC17 - IR Replay
* Requires： IRLib 2.x Library
*
* record.ino by Chris Young
* modified by Brent Rubell for Adafruit Industries for the for the Metro （and Metro Express） Experimenters Guide. Support Open Source， buy Adafruit！
*/
/* IRLib */
#include //We need both the coding and
#include // sending base classes
#include //Lowest numbered protocol 1st
#include // Include only protocols you want
#include
#include
#include
#include
#include //We need this for IRsendRaw
#include // After all protocols， include this
// All of the above automatically creates a universal decoder
// class called “IRdecode” and a universal sender class “IRsend”
// containing only the protocols you want.
// Now declare instances of the decoder and the sender.
IRdecode myDecoder;
IRsend mySender;
// Include a receiver either this or IRLibRecvPCI or IRLibRecvLoop
#include
IRrecv myReceiver（2）; //pin number for the receiver
// Storage for the recorded code
uint8_t codeProtocol; // The type of code
uint32_t codeValue; // The data bits if type is not raw
uint8_t codeBits; // The length of the code in bits
//These flags keep track of whether we received the first code
//and if we have have received a new different code from a previous one.
bool gotOne， gotNew;
/* Buttons */
// button -》 pin number
const int playBtn = 8;
const int recBtn = 9;
// hold the button states
int playBtnState = 0;
int recBtnState = 0;
// status LED
const int ledPin = 13;
void setup（） {
gotOne=false; gotNew=false;
codeProtocol=UNKNOWN;
codeValue=0;
/* BTNS AND LED */
pinMode（ledPin， OUTPUT）;
digitalWrite（ledPin， LOW）;
pinMode（playBtn， INPUT）;
pinMode（recBtn， INPUT）;
Serial.begin（9600）;
Serial.println（F（“Send a code from your remote and we will record it.”））;
Serial.println（F（“Type any character and press enter. We will send the recorded code.”））;
Serial.println（F（“Type ‘r’ special repeat sequence.”））;
myReceiver.enableIRIn（）; // Start the receiver
}
// Stores the code for later playback
void storeCode（void） {
gotNew=true; gotOne=true;
codeProtocol = myDecoder.protocolNum;
Serial.print（F（“Received ”））;
Serial.print（Pnames（codeProtocol））;
if （codeProtocol==UNKNOWN） {
Serial.println（F（“ saving raw data.”））;
myDecoder.dumpResults（）;
codeValue = myDecoder.value;
}
else {
if （myDecoder.value == REPEAT_CODE） {
// Don‘t record a NEC repeat value as that’s useless.
Serial.println（F（“repeat; ignoring.”））;
} else {
codeValue = myDecoder.value;
codeBits = myDecoder.bits;
}
Serial.print（F（“ Value:0x”））;
Serial.println（codeValue， HEX）;
}
}
void sendCode（void） {
if（ ！gotNew ） {//We‘ve already sent this so handle toggle bits
if （codeProtocol == RC5） {
codeValue ^= 0x0800;
}
else if （codeProtocol == RC6） {
switch（codeBits） {
case 20： codeValue ^= 0x10000; break;
case 24： codeValue ^= 0x100000; break;
case 28： codeValue ^= 0x1000000; break;
case 32： codeValue ^= 0x8000; break;
}
}
}
gotNew=false;
if（codeProtocol== UNKNOWN） {
//The raw time values start in decodeBuffer［1］ because
//the ［0］ entry is the gap between frames. The address
//is passed to the raw send routine.
codeValue=（uint32_t）&（recvGlobal.decodeBuffer［1］）;
//This isn’t really number of bits. It‘s the number of entries
//in the buffer.
codeBits=recvGlobal.decodeLength-1;
Serial.println（F（“Sent raw”））;
}
mySender.send（codeProtocol，codeValue，codeBits）;
if（codeProtocol==UNKNOWN） return;
Serial.print（F（“Sent ”））;
Serial.print（Pnames（codeProtocol））;
Serial.print（F（“ Value:0x”））;
Serial.println（codeValue， HEX）;
}
void loop（） {
recBtnState = digitalRead（recBtn）;
playBtnState = digitalRead（playBtn）;
if（recBtnState == HIGH ） {
digitalWrite（ledPin， LOW）;
myDecoder.decode（）;
// Re-enable receiver
myReceiver.enableIRIn（）;
digitalWrite（ledPin， HIGH）;
}
if（playBtnState == HIGH） {
// check for stored signal
if（gotOne） {
// send the IR Code
sendCode（）;
// re-enable receiver
myReceiver.enableIRIn（）;
digitalWrite（ledPin， LOW）;
}
}
}
/* CIRC17 - IR Replay
* Requires： IRLib 2.x Library
*
* record.ino by Chris Young
* modified by Brent Rubell for Adafruit Industries for the for the Metro （and Metro Express） Experimenters Guide. Support Open Source， buy Adafruit！
*/
/* IRLib */
#include //We need both the coding and
#include // sending base classes
#include //Lowest numbered protocol 1st
#include // Include only protocols you want
#include
#include
#include
#include
#include //We need this for IRsendRaw
#include // After all protocols， include this
// All of the above automatically creates a universal decoder
// class called “IRdecode” and a universal sender class “IRsend”
// containing only the protocols you want.
// Now declare instances of the decoder and the sender.
IRdecode myDecoder;
IRsend mySender;
// Include a receiver either this or IRLibRecvPCI or IRLibRecvLoop
#include
IRrecv myReceiver（2）; //pin number for the receiver
// Storage for the recorded code
uint8_t codeProtocol; // The type of code
uint32_t codeValue; // The data bits if type is not raw
uint8_t codeBits; // The length of the code in bits
//These flags keep track of whether we received the first code
//and if we have have received a new different code from a previous one.
bool gotOne， gotNew;
/* Buttons */
// button -》 pin number
const int playBtn = 8;
const int recBtn = 9;
// hold the button states
int playBtnState = 0;
int recBtnState = 0;
// status LED
const int ledPin = 13;
void setup（） {
gotOne=false; gotNew=false;
codeProtocol=UNKNOWN;
codeValue=0;
/* BTNS AND LED */
pinMode（ledPin， OUTPUT）;
digitalWrite（ledPin， LOW）;
pinMode（playBtn， INPUT）;
pinMode（recBtn， INPUT）;
Serial.begin（9600）;
Serial.println（F（“Send a code from your remote and we will record it.”））;
Serial.println（F（“Type any character and press enter. We will send the recorded code.”））;
Serial.println（F（“Type ’r‘ special repeat sequence.”））;
myReceiver.enableIRIn（）; // Start the receiver
}
// Stores the code for later playback
void storeCode（void） {
gotNew=true; gotOne=true;
codeProtocol = myDecoder.protocolNum;
Serial.print（F（“Received ”））;
Serial.print（Pnames（codeProtocol））;
if （codeProtocol==UNKNOWN） {
Serial.println（F（“ saving raw data.”））;
myDecoder.dumpResults（）;
codeValue = myDecoder.value;
}
else {
if （myDecoder.value == REPEAT_CODE） {
// Don’t record a NEC repeat value as that‘s useless.
Serial.println（F（“repeat; ignoring.”））;
} else {
codeValue = myDecoder.value;
codeBits = myDecoder.bits;
}
Serial.print（F（“ Value:0x”））;
Serial.println（codeValue， HEX）;
}
}
void sendCode（void） {
if（ ！gotNew ） {//We’ve already sent this so handle toggle bits
if （codeProtocol == RC5） {
codeValue ^= 0x0800;
}
else if （codeProtocol == RC6） {
switch（codeBits） {
case 20： codeValue ^= 0x10000; break;
case 24： codeValue ^= 0x100000; break;
case 28： codeValue ^= 0x1000000; break;
case 32： codeValue ^= 0x8000; break;
}
}
}
gotNew=false;
if（codeProtocol== UNKNOWN） {
//The raw time values start in decodeBuffer［1］ because
//the ［0］ entry is the gap between frames. The address
//is passed to the raw send routine.
codeValue=（uint32_t）&（recvGlobal.decodeBuffer［1］）;
//This isn‘t really number of bits. It’s the number of entries
//in the buffer.
codeBits=recvGlobal.decodeLength-1;
Serial.println（F（“Sent raw”））;
}
mySender.send（codeProtocol，codeValue，codeBits）;
if（codeProtocol==UNKNOWN） return;
Serial.print（F（“Sent ”））;
Serial.print（Pnames（codeProtocol））;
Serial.print（F（“ Value:0x”））;
Serial.println（codeValue， HEX）;
}
void loop（） {
recBtnState = digitalRead（recBtn）;
playBtnState = digitalRead（playBtn）;
if（recBtnState == HIGH ） {
digitalWrite（ledPin， LOW）;
myDecoder.decode（）;
// Re-enable receiver
myReceiver.enableIRIn（）;
digitalWrite（ledPin， HIGH）;
}
if（playBtnState == HIGH） {
// check for stored signal
if（gotOne） {
// send the IR Code
sendCode（）;
// re-enable receiver
myReceiver.enableIRIn（）;
digitalWrite（ledPin， LOW）;
}
}
}
不起作用？
我沒看到LED亮起
嘗試打開Arduino串行監視器。這段代碼中有Serial.print（） 條語句可以幫助您調試。
我可以接收但不能發送IR信號
確保您的 NPN晶體管已正確連接，這是該電路所必需的。
我對此電路實在感到沮喪，調試后看不到任何輸出
此電路特別棘手，因為紅外傳感器和接收器有點挑剔，張貼在Adafruit支持論壇上我們會盡快與您聯系。
零件
此電路僅適用于Metro EXPRESS，而不適用于Metro Classic
Adafruit Metro Express +面包板+安裝板
如果您尚未組裝，我們將為您提供方便的指南！
需要Adafruit商店提供的額外的塑料安裝板，Adafruit MetroExpress或Mini-Breadboard嗎？
為Metro Express布線
沒有什么菜板！ Metro Express具有板上所需的所有電路（包括NeoPixel！）。 NeoPixel已分配給Metro Express上的數字引腳40
代碼
安裝NeoPixel庫
在復制和粘貼代碼之前，您需要安裝NeoPixel庫。這比安裝IR庫要容易得多-您可以直接從IDE安裝NeoPixel庫！
在Arduino中，轉到 Sketch》 Include Library》 Manage Libraries。
在庫管理器中，搜索 NeoPixel 。
然后，找到最新版本（在撰寫本文時為1.1.1），然后單擊安裝。
狀態欄完成后，r 啟動Arduino IDE 。 NeoPixel庫已安裝。
代碼
復制/粘貼下面的代碼。然后，將其編譯并上傳到Metro中。
您應該看到Metro的NeoPixels呈紅色，白色，和藍色。
下載：Project Zip 或 CIRC18_NEOPIXEL.ino | 在Github上查看
復制代碼
/*
* （CIRC18） Metro Express NeoPixel
* this circuit was designed for use with the Metro Explorers Guide on Learn.Adafruit.com
*
* note： this code does NOT run on the Metro， only the Metro EXPRESS.
*
* by Brent Rubell for Adafruit Industries.
*/
// Include the Adafruit Neopixel Library
#include
// The default pin for the NeoPixel on the Metro Express is Pin #40
#define METROPIXELPIN 40
// metroPixel takes in both the number of pixels （1， the built-in） and the pin）
Adafruit_NeoPixel metroPixel = Adafruit_NeoPixel（1， METROPIXELPIN）;
/* Colors */
// note： the max. of colors in these arrays is 220 instead of 255 （super-bright！！）
const int RED［ ］ = {155， 0， 0};
const int WHITE［ ］ = {155， 155， 155};
const int BLUE［ ］ = {0， 0， 255};
const int BLACK ［ ］ = {0， 0， 0};
void setup（） {
// init. the NeoPixel library
metroPixel.begin（）;
}
void loop（） {
// display red on the Metro Express neopixel
pixelWrite（RED）;
delay（1000）;
// display white on the Metro Express neopixel
pixelWrite（WHITE）;
delay（1000）;
// display blue on the Metro Express neopixel
pixelWrite（BLUE）;
delay（1000）;
// Sparkle the Neopixel
// pixelSparkle（）;
}
// takes in a pre-defined color （integer array） and sets the pixel to that color
void pixelWrite（const int* color） {
metroPixel.setPixelColor（0， metroPixel.Color（color［0］，color［1］，color［2］））;
// write the pixel color to the Metro‘s Neopixel
metroPixel.show（）;
}
// flashes the neopixel on and off rapidly
void pixelSparkle（） {
for（int i = 0; i 《 5; i++） {
pixelWrite（BLACK）;
delay（50）;
pixelWrite（WHITE）;
delay（50）;
}
}
/*
* （CIRC18） Metro Express NeoPixel
* this circuit was designed for use with the Metro Explorers Guide on Learn.Adafruit.com
*
* note： this code does NOT run on the Metro， only the Metro EXPRESS.
*
* by Brent Rubell for Adafruit Industries.
*/
// Include the Adafruit Neopixel Library
#include
// The default pin for the NeoPixel on the Metro Express is Pin #40
#define METROPIXELPIN 40
// metroPixel takes in both the number of pixels （1， the built-in） and the pin）
Adafruit_NeoPixel metroPixel = Adafruit_NeoPixel（1， METROPIXELPIN）;
/* Colors */
// note： the max. of colors in these arrays is 220 instead of 255 （super-bright！！）
const int RED［ ］ = {155， 0， 0};
const int WHITE［ ］ = {155， 155， 155};
const int BLUE［ ］ = {0， 0， 255};
const int BLACK ［ ］ = {0， 0， 0};
void setup（） {
// init. the NeoPixel library
metroPixel.begin（）;
}
void loop（） {
// display red on the Metro Express neopixel
pixelWrite（RED）;
delay（1000）;
// display white on the Metro Express neopixel
pixelWrite（WHITE）;
delay（1000）;
// display blue on the Metro Express neopixel
pixelWrite（BLUE）;
delay（1000）;
// Sparkle the Neopixel
// pixelSparkle（）;
}
// takes in a pre-defined color （integer array） and sets the pixel to that color
void pixelWrite（const int* color） {
metroPixel.setPixelColor（0， metroPixel.Color（color［0］，color［1］，color［2］））;
// write the pixel color to the Metro’s Neopixel
metroPixel.show（）;
}
// flashes the neopixel on and off rapidly
void pixelSparkle（） {
for（int i = 0; i 《 5; i++） {
pixelWrite（BLACK）;
delay（50）;
pixelWrite（WHITE）;
delay（50）;
}
}
遇到麻煩了？
我的代碼無法編譯
請確保NeoPixel庫已正確安裝在右側位置。
我看不到NeoPixe我在董事會上。
您必須擁有 Metro ，而不是 Metro Express 。該電路僅適用于Metro Express 。
我仍然看不到任何東西
在Adafruit支持論壇中發布，我們將盡快與您聯系。
變得更好
調暗NeoPixel
哇，NeoPixel肯定很亮，是嗎？有一種非常簡單的方法可以將其變暗。 NeoPixel的取值范圍是0到255，最亮的是255。
讓它變暗100。在您的代碼中，將：
const int RED［ ］ = {255， 0， 0}; 更改為 const int RED［ ］ = {155， 0， 0};
仍然太亮嗎？讓我們將其更改為1/3，方法是將
const int GREEN［ ］ = {128， 255， 0};更改為const int GREEN［ ］= {128/3， 255/3， 0};
NeoPixel凝視溫度計
我們將要進行修改溫度計電路，以使用NeoPixel組裝顏色編碼的溫度計。瞥一眼該電路，查看與特定溫度對應的顏色。
接線
此電路的接線很簡單-只需將溫度傳感器接線即可。
代碼
復制/粘貼以下代碼。然后，將其編譯并上傳到您的Metro Express！
下載：文件
復制代碼
/*
* CIRC18 Make It Better
* NeoPixel Glance Thermometer - check the weather super quickly！
*
* by Brent Rubell for Adafruit Industries
*/
// Include the Adafruit Neopixel Library
#include
// The default pin for the NeoPixel on the Metro Express is Pin #40
#define METROPIXELPIN 40
// Temperature Sensor
const int temperaturePin = A0;
// metroPixel takes in both the number of pixels （1， the built-in） and the pin）
Adafruit_NeoPixel metroPixel = Adafruit_NeoPixel（1， METROPIXELPIN）;
float temperature = 0;
/* Temperature Colors */
const int RED［ ］ = {255， 0， 0};
const int ORANGE［ ］ = {255， 153， 51};
const int YELLOW［ ］ = {255， 255， 0};
const int LIGHTGREEN［ ］ = {128， 255， 0};
const int DARKGREEN［ ］ = {76， 153， 0};
const int DARKBLUE［ ］ = {0， 0， 255};
const int DARKPURPLE［ ］ = {51， 0， 102};
const int BLACK［ ］ = {0， 0， 0};
void setup（）
{
// Start the Serial at 9600 baud
Serial.begin（9600）;
// init the neopixel library
metroPixel.begin（）;
}
void loop（）
{
temperature = getVoltage3V（temperaturePin）;
// Convert to degrees C
temperature = （temperature - .5） * 100;
// print the temperature in C to the serial
Serial.println（temperature）;
// temp 《-》 color picker
if （temperature 》 40） {
// red
pixelWrite（RED）;
}
else if （temperature 》 35） {
// orange
pixelWrite（ORANGE）;
}
else if （temperature 》 30） {
// yellow
pixelWrite（YELLOW）;
}
else if （temperature 》 25） {
// yellow
pixelWrite（LIGHTGREEN）;
}
else if （temperature 》 20） {
// dark green
pixelWrite（DARKGREEN）;
}
else if （temperature 》 5） {
// dark blue
pixelWrite（DARKBLUE）;
}
else {
// dark purple
pixelWrite（DARKPURPLE）;
}
delay（1000）;
}
// takes in a pre-defined color （integer array） and sets the pixel to that color
void pixelWrite（const int* color） {
metroPixel.setPixelColor（0， metroPixel.Color（color［0］，color［1］，color［2］））;
// write the pixel color to the Metro‘s Neopixel
metroPixel.show（）;
}
// Voltage to temperature if Vs= 3.3V
float getVoltage3V（int pin）{
// 3.3V/1023
return （analogRead（pin） * 0.003225806452）;
} /*
* CIRC18 Make It Better
* NeoPixel Glance Thermometer - check the weather super quickly！
*
* by Brent Rubell for Adafruit Industries
*/
// Include the Adafruit Neopixel Library
#include
// The default pin for the NeoPixel on the Metro Express is Pin #40
#define METROPIXELPIN 40
// Temperature Sensor
const int temperaturePin = A0;
// metroPixel takes in both the number of pixels （1， the built-in） and the pin）
Adafruit_NeoPixel metroPixel = Adafruit_NeoPixel（1， METROPIXELPIN）;
float temperature = 0;
/* Temperature Colors */
const int RED［ ］ = {255， 0， 0};
const int ORANGE［ ］ = {255， 153， 51};
const int YELLOW［ ］ = {255， 255， 0};
const int LIGHTGREEN［ ］ = {128， 255， 0};
const int DARKGREEN［ ］ = {76， 153， 0};
const int DARKBLUE［ ］ = {0， 0， 255};
const int DARKPURPLE［ ］ = {51， 0， 102};
const int BLACK［ ］ = {0， 0， 0};
void setup（）
{
// Start the Serial at 9600 baud
Serial.begin（9600）;
// init the neopixel library
metroPixel.begin（）;
}
void loop（）
{
temperature = getVoltage3V（temperaturePin）;
// Convert to degrees C
temperature = （temperature - .5） * 100;
// print the temperature in C to the serial
Serial.println（temperature）;
// temp 《-》 color picker
if （temperature 》 40） {
// red
pixelWrite（RED）;
}
else if （temperature 》 35） {
// orange
pixelWrite（ORANGE）;
}
else if （temperature 》 30） {
// yellow
pixelWrite（YELLOW）;
}
else if （temperature 》 25） {
// yellow
pixelWrite（LIGHTGREEN）;
}
else if （temperature 》 20） {
// dark green
pixelWrite（DARKGREEN）;
}
else if （temperature 》 5） {
// dark blue
pixelWrite（DARKBLUE）;
}
else {
// dark purple
pixelWrite（DARKPURPLE）;
}
delay（1000）;
}
// takes in a pre-defined color （integer array） and sets the pixel to that color
void pixelWrite（const int* color） {
metroPixel.setPixelColor（0， metroPixel.Color（color［0］，color［1］，color［2］））;
// write the pixel color to the Metro’s Neopixel
metroPixel.show（）;
}
// Voltage to temperature if Vs= 3.3V
float getVoltage3V（int pin）{
// 3.3V/1023
return （analogRead（pin） * 0.003225806452）;
}
將NeoPixel添加到CIRC中
掃視溫度計是對溫度回路的修改。您完成了哪些保監會？您如何在電路中添加NeoPixel以增加功能，實用性或美觀性？
零件
此CIRC僅適用于Metro Express，而不適用于Metro。組裝此CIRC之前，請確認您正在使用Metro Express。
表格》 接線
這是Express線路上的電路，僅能使用
代碼
USB-HID庫內置于Arduino，不需要外部安裝。確認您具有Metro Express，然后將以下代碼復制并粘貼到Arduino編輯器中。然后，編譯并上傳。
下載：Project Zip 或 CIRC19_USB_BLOG_BUDDY .ino | 在Github上查看
復制代碼
/*
* USB Blog Buddy
* a USB-HID Scroll Wheel for Metro Express
*
* by Brent Rubell for Adafruit Industries. Support Open Source， buy Adafruit！
*/
// include the mouse library
#include
// trimpot pin
const int trimPin = A0;
// button pin
const int buttonPin = 2;
// reduces scrolling speed （ms）
const int scrollDelay = 100;
// trimpot value
int trimValue = 0;
// button state
int buttonState = 0;
void setup（） {
// start serial monitor at 9600 baud
Serial.begin（9600）;
// start the mouse
Mouse.begin（）;
}
void loop（） {
// read the button state
buttonState = digitalRead（buttonPin）;
if （buttonState == HIGH） {
// stop the mouse if button not pressed
Mouse.end（）;
}
else {
// start the mouse （if stopped）
Mouse.begin（）;
// read the trimpot value
trimValue = analogRead（trimPin）;
// map the trimValues to scroll wheel down （-neg values） and up （+pos values）
trimValue = map（trimValue， 0， 1023， -5， 5）;
// move the mouse wheel （dont change cursor position）
Mouse.move（0， 0， trimValue）;
// reduce the scrolling speed
delay（scrollDelay）;
}
}
/*
* USB Blog Buddy
* a USB-HID Scroll Wheel for Metro Express
*
* by Brent Rubell for Adafruit Industries. Support Open Source， buy Adafruit！
*/
// include the mouse library
#include
// trimpot pin
const int trimPin = A0;
// button pin
const int buttonPin = 2;
// reduces scrolling speed （ms）
const int scrollDelay = 100;
// trimpot value
int trimValue = 0;
// button state
int buttonState = 0;
void setup（） {
// start serial monitor at 9600 baud
Serial.begin（9600）;
// start the mouse
Mouse.begin（）;
}
void loop（） {
// read the button state
buttonState = digitalRead（buttonPin）;
if （buttonState == HIGH） {
// stop the mouse if button not pressed
Mouse.end（）;
}
else {
// start the mouse （if stopped）
Mouse.begin（）;
// read the trimpot value
trimValue = analogRead（trimPin）;
// map the trimValues to scroll wheel down （-neg values） and up （+pos values）
trimValue = map（trimValue， 0， 1023， -5， 5）;
// move the mouse wheel （dont change cursor position）
Mouse.move（0， 0， trimValue）;
// reduce the scrolling speed
delay（scrollDelay）;
}
}
使用USB Blog Buddy
》
前往Adafruit博客以測試您的電路！
當您按下按鈕時，Metro Express將控制您的鼠標并開始滾動鼠標滾輪。
向上滾動頁面：移動電位計，使其箭頭指向面包板頂部
向下滾動頁面：移動電位計，使其箭頭指向面包板的底部
不起作用？
我在屏幕上看不到任何東西
檢查您的接線，用于USB接口的庫已內置在Arduino中，并且在您上傳此代碼后應會自動啟動。
仍然無法正常工作嗎？
在Adafruit支持論壇中發布，我們將盡快與您聯系。
零件
如果‘正在使用Metro Classic：
您需要一個 1M歐姆電阻。
如果您使用的是Metro M0 Express：
您不需要任何新零件，M0 Express電容式傳感器已完全在芯片內部管理！
面包板微調電位器-10k
如果您要購買從Adafruit商店購買多余的修剪鍋，請單擊此處！
按鈕
如果您想從Adafruit商店訂購更多按鈕，請單擊此處！
10K歐姆電阻
顏色：棕色》黑色》橙色
如果您愿意要從Adafruit商店訂購更多的10k歐姆上拉電阻，請單擊此處！
面包板接線束
如果您愿意要從Adafruit商店訂購更多電線，請點擊此處！
Adafruit Metro Express +面包板+安裝板
如果您尚未組裝，我們將為您提供方便的指南！
需要Adafruit商店提供的額外的塑料安裝板，Adafruit MetroExpress或Mini-Breadboard嗎？
Adafruit Metro（或Metro Express）+面包板+安裝板
如果您尚未組裝此手冊，我們將為您提供方便的指南！
如果您想訂購額外的塑料安裝板，Adafruit Metro，AdafruitMetro Express或Adafruit Shop的迷你面包板請單擊此處！
面包板接線束
如果想要從Adafruit商店訂購更多電線，請點擊此處！
接線
Metro Classic的接線
請注意電阻值！
您需要為此電路使用 1M歐姆電阻。從傳感器引腳伸出的引腳（在我們的示例中為數字引腳2 ），最好是面包板捆綁包中的短引腳。
1M歐姆電阻色帶：棕色》黑色》綠色》銀色
Metro Express的接線
您不需要為此電路使用 1M歐姆電阻，只需較小的值（例如MetroX Classic和MetroX Express套件中包含的560歐姆）。 Metro Express的板載1M Ohm上拉電阻值。
為Metro Express布線
代碼
您需要下載安裝CapacitiveSensor庫。
打開Arduino庫管理器：
搜索電容式傳感器并安裝
代碼
下載并安裝CapacitiveSensor庫后，將以下代碼復制并粘貼到Arduino IDE中。然后，編譯并將其上傳到您的Metro（或Metro Express）。
下載：文件
復制代碼
/*
* CIRC20 - Capacitive Sensing with the Metro and Metro M0 Express
*
* by Brent Rubell for Adafruit Industries. Support Open Source Hardware， Buy Adafruit！
*/
#include
// piezo speaker pin
int piezoPin = 9;
// 10M resistor between pins 4 & 2， pin 2 is sensor pin， add a wire and or foil if desired
// put a 10M resistor between pins 4 & 2， pin 2 is the sensor pin， 4 is the receiver
CapacitiveSensor cs_4_2 = CapacitiveSensor（4，2）;
void setup（）
{
cs_4_2.set_CS_AutocaL_Millis（0xFFFFFFFF）;
Serial.begin（9600）;
// set the piezo as an output
pinMode（piezoPin， OUTPUT）;
}
void loop（）
{
long start = millis（）;
long pinTone = cs_4_2.capacitiveSensor（30）;
Serial.print（“sensor value： ”）; // check on performance in milliseconds
Serial.print（“ ”）; // tab character for debug windown spacing
Serial.print（pinTone）; // print sensor output 1
Serial.print（“ ”）;
// map the tone value to frequencies between 500 and 2000
long mapTone = map（pinTone， 0， 40， 500， 2000）;
// play the mapped tone
playTone（int（mapTone）， 100）;
delay（10）;
}
void playTone（int tone， int duration） {
for （long i = 0; i 《 duration * 1000L; i += tone * 2） {
digitalWrite（piezoPin， HIGH）;
delayMicroseconds（tone）;
digitalWrite（piezoPin， LOW）;
delayMicroseconds（tone）;
}
}
/*
* CIRC20 - Capacitive Sensing with the Metro and Metro M0 Express
*
* by Brent Rubell for Adafruit Industries. Support Open Source Hardware， Buy Adafruit！
*/
#include
// piezo speaker pin
int piezoPin = 9;
// 10M resistor between pins 4 & 2， pin 2 is sensor pin， add a wire and or foil if desired
// put a 10M resistor between pins 4 & 2， pin 2 is the sensor pin， 4 is the receiver
CapacitiveSensor cs_4_2 = CapacitiveSensor（4，2）;
void setup（）
{
cs_4_2.set_CS_AutocaL_Millis（0xFFFFFFFF）;
Serial.begin（9600）;
// set the piezo as an output
pinMode（piezoPin， OUTPUT）;
}
void loop（）
{
long start = millis（）;
long pinTone = cs_4_2.capacitiveSensor（30）;
Serial.print（“sensor value： ”）; // check on performance in milliseconds
Serial.print（“ ”）; // tab character for debug windown spacing
Serial.print（pinTone）; // print sensor output 1
Serial.print（“ ”）;
// map the tone value to frequencies between 500 and 2000
long mapTone = map（pinTone， 0， 40， 500， 2000）;
// play the mapped tone
playTone（int（mapTone）， 100）;
delay（10）;
}
void playTone（int tone， int duration） {
for （long i = 0; i 《 duration * 1000L; i += tone * 2） {
digitalWrite（piezoPin， HIGH）;
delayMicroseconds（tone）;
digitalWrite（piezoPin， LOW）;
delayMicroseconds（tone）;
}
}
此CIRC出現問題
沒有聽到任何聲音？
打開Arduino串行監視器。當您按下圖釘時，最大的sensor value是什么？最小的？在下面的留置權中，用找到的兩個數字值替換MIN_SENSOR_VALUE和MAX_SENSOR_VALUE的值：
long mapTone = map（pinTone， MIN_SENSOR_VALUE， MAX_SENSOR_VALUE， 500， 2000）;
傳感器讀數為0？
當您打開Arduino串行監視器時，是否看到 0 或- 2 的值？您使用的電阻可能太小。我們建議使用1M歐姆電阻，而不要使用10K歐姆電阻。那是一個 一百萬 歐姆。如果您沒有任何1M歐姆電阻，則可以使用任何其他類似的（非常大的）電阻。
這根本不起作用。
在Adafruit支持論壇中發布，我們將盡快與您聯系。
變得更好
使用不同的輸入類型
您可以為電容傳感器使用許多不同類型的輸入。其中包括來自蘋果，鹽水和器皿的所有物品（取決于材料）。您還可以使用Adafruit商店中的一些不同的導電材料，例如導電橡膠，機織導電織物（嘗試將其用于可穿戴項目），甚至使用導電油漆筆將任何材料變成導電材料。
添加傳感器輸入
需要更多輸入嗎？您可以繼續將數字引腳4 用于接收器引腳，并且可以使用任何其他數字引腳來創建電容傳感器。
為此，只需在代碼中添加一行：
CapacitiveSensor cs_4_# = CapacitiveSensor（4，#）;
您需要用要用作傳感器的數字引腳號替換#。
我們正在使用數字引腳4 作為接收器，數字引腳8 作為新傳感器，因此，這里是面包板的外觀：
PROJ01：Theremin
您將成為 Thereminist ！那里有一個陌生的樂器是aTheremin，這是一種電子樂器，您可以在其中揮動雙手并制作音樂！您將使用以前的中國保監會的知識來指導自己。
零件
照片傳感器
如果您想從Adafruit商店訂購其他光敏電阻，請單擊此處！
壓電 蜂鳴器
如果您想從Adafruit商店訂購另一個Pizeo蜂鳴器，請單擊此處！
560歐姆電阻
顏色： 綠色》藍色》棕色
如果您想從Adafruit sho訂購更多電阻器p點擊這里！ （它們的電阻為470歐姆，但可以用）
面包板接線束
如果您想從Adafruit商店訂購更多電線，請單擊此處！
Adafruit Metro（或Metro Express）+面包板+安裝板
如果您尚未組裝，我們將為您提供方便的指南！
如果d想從Adafruit商店訂購額外的塑料安裝板，Adafruit Metro，AdafruitMetro Express或Mini-Breadboard，請點擊此處！
接線
為Metro Express布線
代碼
設置銷釘
下載：文件
復制代碼
int piezoPin = 9;
int photoLightSensorPin = A0; int piezoPin = 9;
int photoLightSensorPin = A0;
壓電和光傳感器的引腳都聲明為整數類型。光感測器前面的A代表模擬。
讀取光傳感器
下載：文件
復制代碼
void loop（） {
// get photo sensor value
int photoVal = analogRead（photoLightSensorPin）;
} void loop（） {
// get photo sensor value
int photoVal = analogRead（photoLightSensorPin）;
}
在loop（）。中讀取光傳感器photoVal僅用于整數值（無小數點）。然后，在光傳感器引腳上調用analogRead（）以讀取引腳數據。
創建音高
下載：文件
復制代碼
int pitch = map（photoVal， 190， 1100， 150， 1500）; int pitch = map（photoVal， 190， 1100， 150， 1500）;
創建音高變量以存儲結果音高。然后，調用map（）。此函數接受photoVal和photoVal的下限值和上限值。然后，它將范圍映射到150Hz和1500Hz范圍內
播放音高
下載：文件
復制代碼
// play tone
tone（piezoPin， pitch）; // play tone
tone（piezoPin， pitch）;
Tone（）傳遞帶有壓電的引腳和之前生成的音高整數。
完整的代碼如下。將其復制并粘貼到空白的Arduino草圖中，然后編譯并上傳！
下載：Project Zip 或 PROJ01_THEREMIN.ino | 在Github上查看
復制代碼
/*
* （PROJ01） Metro （and Metro Express） Theremin
* Desc： Super basic theremin using a light sensor and a piezo element
*
* by Brent Rubell for Adafruit Industries.
*/
int piezoPin = 9;
int photoLightSensorPin = A0;
void setup（） {
Serial.begin（9600）;
}
void loop（） {
// get photo sensor value
int photoVal = analogRead（photoLightSensorPin）;
/* Create the pitch
* map（） the photolightsensor value to
* a frequency from 150Hz to 1500Hz
* more info about map（） - https://www.arduino.cc/en/Reference/Map
*/
int pitch = map（photoVal， 190， 1100， 150， 1500）;
// play tone
tone（piezoPin， pitch）;
}
/*
* （PROJ01） Metro （and Metro Express） Theremin
* Desc： Super basic theremin using a light sensor and a piezo element
*
* by Brent Rubell for Adafruit Industries.
*/
int piezoPin = 9;
int photoLightSensorPin = A0;
void setup（） {
Serial.begin（9600）;
}
void loop（） {
// get photo sensor value
int photoVal = analogRead（photoLightSensorPin）;
/* Create the pitch
* map（） the photolightsensor value to
* a frequency from 150Hz to 1500Hz
* more info about map（） - https://www.arduino.cc/en/Reference/Map
*/
int pitch = map（photoVal， 190， 1100， 150， 1500）;
// play tone
tone（piezoPin， pitch）;
}
在電路上移動手以與音樂一起播放音樂！恭喜，您剛剛建立了第一個任務電路。
這讓您感到厭煩嗎？讓我們變得更好！
等等。。.我的項目不起作用！
我什么也沒聽到
檢查壓電和光傳感器的接線。您可能會發現將光傳感器翻轉即可修復它。
我根本無法正常工作
我們將幫助您！在Adafruit支持論壇中發布，我們將盡快與您聯系。
變得更好
修改音高
看看Theremin任務回路中map（）的工作原理，您可以開始了解地圖的工作原理：
map（value， fromLow， fromHigh， toLow， toHigh）; 到map（photoVal， 190， 1100， 150， 1500）;
前兩個值對應于光傳感器，而后兩個是間距。嘗試上下修改最后兩個值（150和1500）。每次您都會得到不同的聲音！
停止音樂！
您可能已經討厭從那里發出的怪異聲音了。停止聲音的方法有兩種。
一種方法是使用按鈕。將其中一個插入面包板并連接至數字引腳2：
下一步，在按下按鈕時將Arduino代碼修改為callNoTone（）。我們將由您自己決定。一個提示是同時查看NoTone（）文檔和CIRC07的代碼。
PROJ02：MetroPOV顯示
視野持久是指當從物體發出的光線停止進入眼睛后一段時間內對物體的視覺感知沒有停止時發生的視覺幻覺（此處更多關于視覺的持久性）。
Adafruit制作的很酷的套件之一是MiniPOV 4，一種DIY全彩POV顯示器。 MiniPOV創造了這種幻覺，并允許您在空中用光繪畫。在此任務中，您將創建 MetroPOV ，該電路使用視覺持久性和Adafruit Metro。您將了解視覺的持久性，錯覺，并創建自己的繪圖。
讓我們用Metro來繪制天空！
零件
5毫米紅色LED
如果您想在Adafruit商店訂購更多紅色LED（它們會發出很好的指示燈！），請點擊這里！
560歐姆電阻
顏色：綠色》藍色》棕色
如果您要從Adafruit商店訂購更多電阻，請點擊這里！ （它們的電阻為470歐姆，但可以用）
面包板接線束
如果您想從Adafruit商店訂購更多電線，請單擊此處！
Adafruit Metro（或Metro Express）+面包板+安裝板
如果您尚未組裝，我們將為您提供方便的指南！
如果d想從Adafruit商店訂購額外的塑料安裝板，Adafruit Metro，AdafruitMetro Express或Mini-Breadboard，請點擊此處！
接線
試驗板的電路類似于CIRC02的布局。我們建議使用紅色5mm LED或綠色5mm LED。選擇您喜歡的顏色并使用它！
該電路的9V電池+夾子非常方便。您可以使用雙面膠帶將其粘貼在安裝板的背面。
代碼
將以下代碼復制并粘貼到Arduino IDE中。然后，編譯并將其上傳到您的Metro。
下載：Project Zip 或PROJ02_METROPOV.ino | 在Github上查看
復制代碼
/*
* （PROJ03） Metro （and Metro Express） Persistence of Vision Display
* Desc： POV display for Metro & Metro Express using 7x LEDs and 7x 560ohm Resistors
*
* by Brent Rubell for Adafruit Industries. Support Open Source， buy Adafruit！
*/
int spacer［8］［5］ = {
{0， 0， 0， 0， 0}，
{0， 0， 0， 0， 0}，
{0， 0， 0， 0， 0}，
{0， 0， 0， 0， 0}，
{0， 0， 0， 0， 0}，
{0， 0， 0， 0， 0}，
{0， 0， 0， 0， 0}，
{0， 0， 0， 0， 0}
};
int A［8］［5］ = {
{0， 1， 1， 1， 0}，
{1， 1， 0， 1， 1}，
{1， 1， 0， 1， 1}，
{1， 1， 1， 1， 1}，
{1， 1， 0， 1， 1}，
{1， 1， 0， 1， 1}，
{1， 1， 0， 1， 1}，
{0， 0， 0， 0， 0}
};
int B［8］［5］ = {
{1， 1， 1， 1， 0}，
{1， 1， 0， 1， 1}，
{1， 1， 0， 1， 1}，
{1， 1， 1， 1， 0}，
{1， 1， 0， 1， 1}，
{1， 1， 0， 1， 1}，
{1， 1， 1， 1， 0}，
{0， 0， 0， 0， 0}
};
int C［8］［5］ = {
{0， 1， 1， 1， 0}，
{1， 1， 0， 1， 1}，
{1， 1， 0， 0， 0}，
{1， 1， 0， 0， 0}，
{1， 1， 0， 0， 0}，
{1， 1， 0， 1， 1}，
{0， 1， 1， 1， 0}，
{0， 0， 0， 0， 0}
};
int D［8］［5］ = {
{1， 1， 1， 0， 0}，
{1， 1， 0， 1， 1}，
{1， 1， 0， 1， 1}，
{1， 1， 0， 1， 1}，
{1， 1， 0， 1， 1}，
{1， 1， 0， 1， 1}，
{1， 1， 1， 1， 0}，
{0， 0， 0， 0， 0}
};
int E［8］［5］ = {
{1， 1， 1， 1， 1}，
{1， 1， 0， 0， 0}，
{1， 1， 0， 0， 0}，
{1， 1， 1， 1， 0}，
{1， 1， 0， 0， 0}，
{1， 1， 0， 0， 0}，
{1， 1， 1， 1， 1}，
{0， 0， 0， 0， 0}
};
int F［8］［5］ = {
{1， 1， 1， 1， 1}，
{1， 1， 0， 0， 0}，
{1， 1， 0， 0， 0}，
{1， 1， 1， 1， 0}，
{1， 1， 0， 0， 0}，
{1， 1， 0， 0， 0}，
{1， 1， 0， 0， 0}，
{0， 0， 0， 0， 0}
};
int G［8］［5］ = {
{0， 1， 1， 1， 0}，
{1， 1， 0， 1， 1}，
{1， 1， 0， 0， 0}，
{1， 1， 0， 1， 1}，
{1， 1， 0， 1， 1}，
{1， 1， 0， 0， 1}，
{0， 1， 1， 1， 1}，
{0， 0， 0， 0， 0}
};
int H［8］［5］ = {
{1， 1， 0， 1， 1}，
{1， 1， 0， 1， 1}，
{1， 1， 0， 1， 1}，
{1， 1， 1， 1， 1}，
{1， 1， 0， 1， 1}，
{1， 1， 0， 1， 1}，
{1， 1， 0， 1， 1}，
{0， 0， 0， 0， 0}
};
int I［8］［5］ = {
{0， 0， 0， 0， 0}，
{1， 1， 1， 1， 1}，
{0， 0， 1， 0， 0}，
{0， 0， 1， 0， 0}，
{0， 0， 1， 0， 0}，
{0， 0， 1， 0， 0}，
{1， 1， 1， 1， 1}，
{0， 0， 0， 0， 0}
};
int J［8］［5］ = {
{0， 0， 0， 1， 1}，
{0， 0， 0， 1， 1}，
{0， 0， 0， 1， 1}，
{0， 0， 0， 1， 1}，
{1， 0， 0， 1， 1}，
{1， 0， 0， 1， 1}，
{0， 1， 1， 0， 0}，
{0， 0， 0， 0， 0}
};
int K［8］［5］ = {
{0， 0， 0， 0， 0}，
{1， 0， 0， 1， 0}，
{1， 0， 1， 0， 0}，
{1， 1， 0， 0， 0}，
{1， 1， 0， 0， 0}，
{1， 0， 1， 0， 0}，
{1， 0， 0， 1， 0}，
{0， 0， 0， 0， 0}
};
int L［8］［5］ = {
{1， 1， 0， 0， 0}，
{1， 1， 0， 0， 0}，
{1， 1， 0， 0， 0}，
{1， 1， 0， 0， 0}，
{1， 1， 0， 0， 0}，
{1， 1， 1， 1， 1}，
{1， 1， 1， 1， 1}，
{0， 0， 0， 0， 0}
};
int M［8］［5］ = {
{1， 0， 0， 0， 1}，
{1， 1， 0， 1， 1}，
{1， 0， 1， 0， 1}，
{1， 0， 1， 0， 1}，
{1， 0， 1， 0， 1}，
{1， 0， 1， 0， 1}，
{1， 0， 1， 0， 1}，
{0， 0， 0， 0， 0}
};
int N［8］［5］ = {
{1， 0， 0， 0， 1}，
{1， 1， 0， 0， 1}，
{1， 0， 1， 0， 1}，
{1， 0， 0， 1， 1}，
{1， 0， 0， 0， 1}，
{1， 0， 0， 0， 1}，
{1， 0， 0， 0， 1}，
{0， 0， 0， 0， 0}
};
int O［8］［5］ = {
{1， 1， 1， 1， 1}，
{1， 0， 0， 0， 1}，
{1， 0， 0， 0， 1}，
{1， 0， 0， 0， 1}，
{1， 0， 0， 0， 1}，
{1， 0， 0， 0， 1}，
{1， 1， 1， 1， 1}，
{0， 0， 0， 0， 0}
};
int P［8］［5］ = {
{1， 1， 1， 1， 0}，
{1， 0， 0， 0， 1}，
{1， 0， 0， 0， 1}，
{1， 1， 1， 1， 0}，
{1， 0， 0， 0， 0}，
{1， 0， 0， 0， 0}，
{1， 0， 0， 0， 0}，
{0， 0， 0， 0， 0}
};
int Q［8］［5］ = {
{0， 1， 1， 1， 0}，
{1， 0， 0， 0， 1}，
{1， 0， 0， 0， 1}，
{1， 0， 0， 0， 1}，
{1， 0， 1， 0， 1}，
{1， 0， 0， 1， 0}，
{0， 1， 1， 0， 1}，
{0， 0， 0， 0， 0}
};
int R［8］［5］ = {
{1， 1， 1， 1， 0}，
{1， 0， 0， 1， 0}，
{1， 0， 0， 1， 0}，
{1， 1， 1， 1， 0}，
{1， 1， 0， 0， 0}，
{1， 0， 1， 0， 0}，
{1， 0， 0， 1， 0}，
{0， 0， 0， 0， 0}
};
int S［8］［5］ = {
{0， 1， 1， 1， 1}，
{0， 1， 0， 0， 1}，
{0， 1， 0， 0， 0}，
{0， 0， 1， 0， 0}，
{0， 0， 0， 1， 0}，
{1， 0， 0， 1， 0}，
{1， 1， 1， 1， 0}，
{0， 0， 0， 0， 0}
};
int T［8］［5］ = {
{1， 1， 1， 1， 1}，
{1， 0， 1， 0， 1}，
{1， 0， 1， 0， 1}，
{0， 0， 1， 0， 0}，
{0， 0， 1， 0， 0}，
{0， 0， 1， 0， 0}，
{0， 0， 1， 0， 0}，
{0， 0， 0， 0， 0}
};
int U［8］［5］ = {
{1， 0， 0， 0， 1}，
{1， 0， 0， 0， 1}，
{1， 0， 0， 0， 1}，
{1， 0， 0， 0， 1}，
{1， 0， 0， 0， 1}，
{1， 0， 0， 0， 1}，
{1， 1， 1， 1， 1}，
{0， 0， 0， 0， 0}
};
int V［8］［5］ = {
{1， 0， 0， 0， 1}，
{1， 0， 0， 0， 1}，
{1， 0， 0， 0， 1}，
{1， 0， 0， 0， 1}，
{1， 0， 0， 0， 1}，
{0， 1， 0， 1， 0}，
{0， 0， 1， 0， 0}，
{0， 0， 0， 0， 0}
};
int W［8］［5］ = {
{1， 0， 0， 0， 1}，
{1， 0， 0， 0， 1}，
{1， 0， 0， 0， 1}，
{1， 0， 0， 0， 1}，
{1， 0， 1， 0， 1}，
{1， 0， 1， 0， 1}，
{1， 1， 1， 1， 1}，
{0， 0， 0， 0， 0}
};
int X［8］［5］ = {
{1， 0， 0， 0， 1}，
{0， 1， 0， 1， 0}，
{0， 0， 1， 0， 0}，
{0， 0， 1， 0， 0}，
{0， 1， 0， 1， 0}，
{1， 0， 0， 0， 1}，
{0， 0， 0， 0， 0}，
{0， 0， 0， 0， 0}
};
int Y［8］［5］ = {
{0， 0， 0， 0， 0}，
{0， 0， 0， 0， 0}，
{0， 1， 0， 1， 0}，
{0， 1， 0， 1， 0}，
{0， 1， 1， 1， 0}，
{0， 0， 1， 0， 0}，
{0， 0， 1， 0， 0}，
{0， 0， 0， 0， 0}
};
int Z［8］［5］ = {
{0， 0， 0， 0， 0}，
{1， 1， 1， 1， 1}，
{0， 0， 0， 1， 1}，
{0， 0， 1， 1， 0}，
{0， 1， 1， 0， 0}，
{1， 1， 0， 0， 0}，
{1， 1， 1， 1， 1}，
{0， 0， 0， 0， 0}
};
// LED pins
int LEDPins［］ = {2， 3， 4， 5， 6， 7， 8， 9};
// space between the letters
float letterSpacing = 0.5;
void setup（） {
// start serialmon.
Serial.begin（9600）;
// set all leds to output mode
for （int pin = 0; pin 《 8; pin++） {
pinMode（LEDPins［pin］， OUTPUT）;
}
}
void loop（） {
printLetter（M）;
printLetter（spacer）;
printLetter（E）;
printLetter（spacer）;
printLetter（T）;
printLetter（spacer）;
printLetter（R）;
printLetter（spacer）;
printLetter（O）;
printLetter（spacer）;
// delay 2s
delay（2）;
}
// outputs a letter to the POV Display
void printLetter（int letter［8］［5］） {
// row of letter array
for （int j = 0; j 《 5; j++）
{
Serial.print（“ Row # ”）;
Serial.print（j）;
Serial.println（“。”）;
// column of letter array
for （int i = 0; i 《 8; i++） {
// check for 1 within column6
if （letter［i］［j］ == 1） {
Serial.println（“1 detected”）;
digitalWrite（LEDPins［i］， HIGH）;
}
else {
Serial.println（“0 detected”）;
digitalWrite（LEDPins［i］， LOW）;
}
}
delay（letterSpacing）;
}
}
/*
* （PROJ03） Metro （and Metro Express） Persistence of Vision Display
* Desc： POV display for Metro & Metro Express using 7x LEDs and 7x 560ohm Resistors
*
* by Brent Rubell for Adafruit Industries. Support Open Source， buy Adafruit！
*/
int spacer［8］［5］ = {
{0， 0， 0， 0， 0}，
{0， 0， 0， 0， 0}，
{0， 0， 0， 0， 0}，
{0， 0， 0， 0， 0}，
{0， 0， 0， 0， 0}，
{0， 0， 0， 0， 0}，
{0， 0， 0， 0， 0}，
{0， 0， 0， 0， 0}
};
int A［8］［5］ = {
{0， 1， 1， 1， 0}，
{1， 1， 0， 1， 1}，
{1， 1， 0， 1， 1}，
{1， 1， 1， 1， 1}，
{1， 1， 0， 1， 1}，
{1， 1， 0， 1， 1}，
{1， 1， 0， 1， 1}，
{0， 0， 0， 0， 0}
};
int B［8］［5］ = {
{1， 1， 1， 1， 0}，
{1， 1， 0， 1， 1}，
{1， 1， 0， 1， 1}，
{1， 1， 1， 1， 0}，
{1， 1， 0， 1， 1}，
{1， 1， 0， 1， 1}，
{1， 1， 1， 1， 0}，
{0， 0， 0， 0， 0}
};
int C［8］［5］ = {
{0， 1， 1， 1， 0}，
{1， 1， 0， 1， 1}，
{1， 1， 0， 0， 0}，
{1， 1， 0， 0， 0}，
{1， 1， 0， 0， 0}，
{1， 1， 0， 1， 1}，
{0， 1， 1， 1， 0}，
{0， 0， 0， 0， 0}
};
int D［8］［5］ = {
{1， 1， 1， 0， 0}，
{1， 1， 0， 1， 1}，
{1， 1， 0， 1， 1}，
{1， 1， 0， 1， 1}，
{1， 1， 0， 1， 1}，
{1， 1， 0， 1， 1}，
{1， 1， 1， 1， 0}，
{0， 0， 0， 0， 0}
};
int E［8］［5］ = {
{1， 1， 1， 1， 1}，
{1， 1， 0， 0， 0}，
{1， 1， 0， 0， 0}，
{1， 1， 1， 1， 0}，
{1， 1， 0， 0， 0}，
{1， 1， 0， 0， 0}，
{1， 1， 1， 1， 1}，
{0， 0， 0， 0， 0}
};
int F［8］［5］ = {
{1， 1， 1， 1， 1}，
{1， 1， 0， 0， 0}，
{1， 1， 0， 0， 0}，
{1， 1， 1， 1， 0}，
{1， 1， 0， 0， 0}，
{1， 1， 0， 0， 0}，
{1， 1， 0， 0， 0}，
{0， 0， 0， 0， 0}
};
int G［8］［5］ = {
{0， 1， 1， 1， 0}，
{1， 1， 0， 1， 1}，
{1， 1， 0， 0， 0}，
{1， 1， 0， 1， 1}，
{1， 1， 0， 1， 1}，
{1， 1， 0， 0， 1}，
{0， 1， 1， 1， 1}，
{0， 0， 0， 0， 0}
};
int H［8］［5］ = {
{1， 1， 0， 1， 1}，
{1， 1， 0， 1， 1}，
{1， 1， 0， 1， 1}，
{1， 1， 1， 1， 1}，
{1， 1， 0， 1， 1}，
{1， 1， 0， 1， 1}，
{1， 1， 0， 1， 1}，
{0， 0， 0， 0， 0}
};
int I［8］［5］ = {
{0， 0， 0， 0， 0}，
{1， 1， 1， 1， 1}，
{0， 0， 1， 0， 0}，
{0， 0， 1， 0， 0}，
{0， 0， 1， 0， 0}，
{0， 0， 1， 0， 0}，
{1， 1， 1， 1， 1}，
{0， 0， 0， 0， 0}
};
int J［8］［5］ = {
{0， 0， 0， 1， 1}，
{0， 0， 0， 1， 1}，
{0， 0， 0， 1， 1}，
{0， 0， 0， 1， 1}，
{1， 0， 0， 1， 1}，
{1， 0， 0， 1， 1}，
{0， 1， 1， 0， 0}，
{0， 0， 0， 0， 0}
};
int K［8］［5］ = {
{0， 0， 0， 0， 0}，
{1， 0， 0， 1， 0}，
{1， 0， 1， 0， 0}，
{1， 1， 0， 0， 0}，
{1， 1， 0， 0， 0}，
{1， 0， 1， 0， 0}，
{1， 0， 0， 1， 0}，
{0， 0， 0， 0， 0}
};
int L［8］［5］ = {
{1， 1， 0， 0， 0}，
{1， 1， 0， 0， 0}，
{1， 1， 0， 0， 0}，
{1， 1， 0， 0， 0}，
{1， 1， 0， 0， 0}，
{1， 1， 1， 1， 1}，
{1， 1， 1， 1， 1}，
{0， 0， 0， 0， 0}
};
int M［8］［5］ = {
{1， 0， 0， 0， 1}，
{1， 1， 0， 1， 1}，
{1， 0， 1， 0， 1}，
{1， 0， 1， 0， 1}，
{1， 0， 1， 0， 1}，
{1， 0， 1， 0， 1}，
{1， 0， 1， 0， 1}，
{0， 0， 0， 0， 0}
};
int N［8］［5］ = {
{1， 0， 0， 0， 1}，
{1， 1， 0， 0， 1}，
{1， 0， 1， 0， 1}，
{1， 0， 0， 1， 1}，
{1， 0， 0， 0， 1}，
{1， 0， 0， 0， 1}，
{1， 0， 0， 0， 1}，
{0， 0， 0， 0， 0}
};
int O［8］［5］ = {
{1， 1， 1， 1， 1}，
{1， 0， 0， 0， 1}，
{1， 0， 0， 0， 1}，
{1， 0， 0， 0， 1}，
{1， 0， 0， 0， 1}，
{1， 0， 0， 0， 1}，
{1， 1， 1， 1， 1}，
{0， 0， 0， 0， 0}
};
int P［8］［5］ = {
{1， 1， 1， 1， 0}，
{1， 0， 0， 0， 1}，
{1， 0， 0， 0， 1}，
{1， 1， 1， 1， 0}，
{1， 0， 0， 0， 0}，
{1， 0， 0， 0， 0}，
{1， 0， 0， 0， 0}，
{0， 0， 0， 0， 0}
};
int Q［8］［5］ = {
{0， 1， 1， 1， 0}，
{1， 0， 0， 0， 1}，
{1， 0， 0， 0， 1}，
{1， 0， 0， 0， 1}，
{1， 0， 1， 0， 1}，
{1， 0， 0， 1， 0}，
{0， 1， 1， 0， 1}，
{0， 0， 0， 0， 0}
};
int R［8］［5］ = {
{1， 1， 1， 1， 0}，
{1， 0， 0， 1， 0}，
{1， 0， 0， 1， 0}，
{1， 1， 1， 1， 0}，
{1， 1， 0， 0， 0}，
{1， 0， 1， 0， 0}，
{1， 0， 0， 1， 0}，
{0， 0， 0， 0， 0}
};
int S［8］［5］ = {
{0， 1， 1， 1， 1}，
{0， 1， 0， 0， 1}，
{0， 1， 0， 0， 0}，
{0， 0， 1， 0， 0}，
{0， 0， 0， 1， 0}，
{1， 0， 0， 1， 0}，
{1， 1， 1， 1， 0}，
{0， 0， 0， 0， 0}
};
int T［8］［5］ = {
{1， 1， 1， 1， 1}，
{1， 0， 1， 0， 1}，
{1， 0， 1， 0， 1}，
{0， 0， 1， 0， 0}，
{0， 0， 1， 0， 0}，
{0， 0， 1， 0， 0}，
{0， 0， 1， 0， 0}，
{0， 0， 0， 0， 0}
};
int U［8］［5］ = {
{1， 0， 0， 0， 1}，
{1， 0， 0， 0， 1}，
{1， 0， 0， 0， 1}，
{1， 0， 0， 0， 1}，
{1， 0， 0， 0， 1}，
{1， 0， 0， 0， 1}，
{1， 1， 1， 1， 1}，
{0， 0， 0， 0， 0}
};
int V［8］［5］ = {
{1， 0， 0， 0， 1}，
{1， 0， 0， 0， 1}，
{1， 0， 0， 0， 1}，
{1， 0， 0， 0， 1}，
{1， 0， 0， 0， 1}，
{0， 1， 0， 1， 0}，
{0， 0， 1， 0， 0}，
{0， 0， 0， 0， 0}
};
int W［8］［5］ = {
{1， 0， 0， 0， 1}，
{1， 0， 0， 0， 1}，
{1， 0， 0， 0， 1}，
{1， 0， 0， 0， 1}，
{1， 0， 1， 0， 1}，
{1， 0， 1， 0， 1}，
{1， 1， 1， 1， 1}，
{0， 0， 0， 0， 0}
};
int X［8］［5］ = {
{1， 0， 0， 0， 1}，
{0， 1， 0， 1， 0}，
{0， 0， 1， 0， 0}，
{0， 0， 1， 0， 0}，
{0， 1， 0， 1， 0}，
{1， 0， 0， 0， 1}，
{0， 0， 0， 0， 0}，
{0， 0， 0， 0， 0}
};
int Y［8］［5］ = {
{0， 0， 0， 0， 0}，
{0， 0， 0， 0， 0}，
{0， 1， 0， 1， 0}，
{0， 1， 0， 1， 0}，
{0， 1， 1， 1， 0}，
{0， 0， 1， 0， 0}，
{0， 0， 1， 0， 0}，
{0， 0， 0， 0， 0}
};
int Z［8］［5］ = {
{0， 0， 0， 0， 0}，
{1， 1， 1， 1， 1}，
{0， 0， 0， 1， 1}，
{0， 0， 1， 1， 0}，
{0， 1， 1， 0， 0}，
{1， 1， 0， 0， 0}，
{1， 1， 1， 1， 1}，
{0， 0， 0， 0， 0}
};
// LED pins
int LEDPins［］ = {2， 3， 4， 5， 6， 7， 8， 9};
// space between the letters
float letterSpacing = 0.5;
void setup（） {
// start serialmon.
Serial.begin（9600）;
// set all leds to output mode
for （int pin = 0; pin 《 8; pin++） {
pinMode（LEDPins［pin］， OUTPUT）;
}
}
void loop（） {
printLetter（M）;
printLetter（spacer）;
printLetter（E）;
printLetter（spacer）;
printLetter（T）;
printLetter（spacer）;
printLetter（R）;
printLetter（spacer）;
printLetter（O）;
printLetter（spacer）;
// delay 2s
delay（2）;
}
// outputs a letter to the POV Display
void printLetter（int letter［8］［5］） {
// row of letter array
for （int j = 0; j 《 5; j++）
{
Serial.print（“ Row # ”）;
Serial.print（j）;
Serial.println（“。”）;
// column of letter array
for （int i = 0; i 《 8; i++） {
// check for 1 within column6
if （letter［i］［j］ == 1） {
Serial.println（“1 detected”）;
digitalWrite（LEDPins［i］， HIGH）;
}
else {
Serial.println（“0 detected”）;
digitalWrite（LEDPins［i］， LOW）;
}
}
delay（letterSpacing）;
}
}
我需要幫助
我無法很好地了解正在運行的MetroPOV
嘗試檢查本指南的下一部分。我們建議一些技巧，甚至是一個應用程序。
我看不到LED以不同的模式點亮
檢查接線，LED已連接到引腳2、3、4、5、6、7、8和9在Metro或Metro Express上
什么也沒做，我什么也沒做
別擔心，請在Adafruit支持論壇上發布，我們會盡快與您聯系。
使用MetroPOV
拍照 strong》
要獲取正在運行的MetroPOV的照片有點棘手。我們提供了一些技巧來幫助您拍攝MetroPOV：
穩定性和快門速度：將快門保持打開狀態（我們發現2英寸到4英寸是一個很好的時限）或在應用商店中尋找長時間曝光的應用。由于相機的傳感器/快門處于打開狀態，因此保持相機穩定很重要。使用三腳架，或將其放置在堅固的桌子上。
保持照明狀態：要獲取在其中運行的MetroPOV的優質照片非常困難。明亮的環境。等待夜間或找一個黑暗的房間（為本指南拍照時，我們使用了一個關閉所有燈光的房間）。
將您的MetroPOV文本GIF添加
您可以通過組合多個長在您選擇的照片編輯器中一起曝光照片。我們還使用Pablo（一種適用于iOS和Android的出色的光繪應用程序）獲得了成功。調整設置（尤其是快門速度和曝光），直到找到看起來不錯的設置。
使用MetroPOV進行光繪
拍攝照片時的錯誤通常可以產生精美的藝術品。嘗試使用MetroPOV繪制字母并四處移動。在有人為您拍照時騎滑板，在椅子上旋轉。實驗并嘗試不同的技術和想法！
PROJ03：音樂盒
音樂盒是發條的機械樂器，打開后會播放音樂。 您將把音樂盒帶入21世紀-而不是通過修改金屬圓柱體來對音樂盒進行編程，而是將一首優美的歌曲編程到Metro上。打開時，音樂盒會播放一首歌曲，并且LCD會在播放時顯示音符。
該項目可通過以下幾種方式進行自定義：您可以使用自己的盒子（也許有一個珠寶盒，一個舊的雪茄盒或Adafruit盒）和/或編程自己的音樂。
零件
照片傳感器
如果您想從Adafruit商店訂購其他光敏電阻，請單擊此處！
16x2字符LCD
如果您想從Adafruit商店購買藍白色的16x2字符液晶顯示器，請單擊此處！
Piezo 蜂鳴器
如果您想從Adafruit商店訂購另一個Pizeo Buzzer，請單擊此處！
10K歐姆電阻
顏色：棕色》黑色》橙色
如果您想從Adafruit商店訂購更多的10k歐姆上拉電阻，請單擊此處！
面包板接線束
如果您想從Adafruit商店訂購更多電線，請點擊此處！
Adafruit Metro（或Metro Express）+面包板+安裝板
如果您尚未組裝此手冊，我們將為您提供方便的指南！
如果您想訂購額外的pla stic安裝板，Adafruit Metro，AdafruitMetro Express或Adafruit Shop中的Mini-Breadboard單擊此處！
接線
圖
程序集
如果要使用Adafruit框（或
首先，將電路放置在盒子的中央。您可以將其固定下來以暫時固定。
確保光傳感器未被電線擋住。
最后，將電線穿過所切的孔并將其連接到Metro。
代碼
校準音樂盒
為了獲得準確的讀數，請關閉音樂盒并運行下面的代碼。然后，打開您的串行監視器。它應該輸出亮度，這是盒子會得到的最暗的亮度，因此我們將校準該值。
在您的代碼中，更改以下行：
int dark = 650;-》 int dark = your measured value
重新運行代碼時，當關閉框時，串行監視器應打印“框已關閉。。” 。如果您將背光源連接到引腳13，則LCD背光源也應關閉。
下載： Project Zip 或 PROJ03_MUSIC_BOX.ino | 在Github上查看
復制代碼
/*
* （PROJ03） Metro （and Metro Express！） Music Box
* Desc： 21st century music box： Plays a melody when the box is open.
* Circuit： Piezo， 16x2 LCD， Photo Light Sensor
*
* by Brent Rubell for Adafruit Industries. Support Open Source Hardware， buy Adafruit！
*
*/
// include the lcd library code
#include
// initialize the library with the numbers of the interface pins
LiquidCrystal lcd（7， 8， 9， 10， 11， 12）;
// Piezo code.
int speakerPin = 5;
int length = 15; // the number of notes
char notes［］ = “ccggaagffeeddc ”; // a space represents a rest
int beats［］ = { 1， 1， 1， 1， 1， 1， 2， 1， 1， 1， 1， 1， 1， 2， 4 };
int tempo = 300;
// Photo Light Sensor Pin
int lightPin = 0;
// Measured Darkness
int dark = 650;
// LCD Backlight Pin
int backlightPin = 13;
void playTone（int tone， int duration） {
for （long i = 0; i 《 duration * 1000L; i += tone * 2） {
digitalWrite（speakerPin， HIGH）;
delayMicroseconds（tone）;
digitalWrite（speakerPin， LOW）;
delayMicroseconds（tone）;
}
}
void playNote（char note， int duration） {
char names［］ = { ’c‘， ’d‘， ’e‘， ’f‘， ’g‘， ’a‘， ’b‘， ’C‘ };
int tones［］ = { 1915， 1700， 1519， 1432， 1275， 1136， 1014， 956 };
// play the tone corresponding to the note name
for （int i = 0; i 《 8; i++） {
if （names［i］ == note） {
playTone（tones［i］， duration）;
}
}
}
void setup（） {
// set up the serial monitor
Serial.begin（9600）;
// set up the LCD’s cols/rows
lcd.begin（16， 2）;
// set speaker as an output
pinMode（speakerPin， OUTPUT）;
// set lcd backlight as an output
pinMode（backlightPin， OUTPUT）;
}
void loop（） {
// read the lightLevel
int lightLevel = analogRead（lightPin）;
Serial.println（“Light Level -》 ”）;
Serial.println（lightLevel）;
// check lightLevel against dark level （should be set manually by the user， check serial mon.）
if（lightLevel 《 dark）
{
// Box is OPEN！
digitalWrite（backlightPin， HIGH）;
lcd.clear（）;
Serial.println（“Box open， playing music！”）;
for （int i = 0; i 《 length; i++） {
if（notes［i］ == ‘ ’） {
// rest
delay（beats［i］ * tempo）;
// print a space to indicate a rest
lcd.print（“ ”）;
}
else {
// play notes in notes［］
playNote（notes［i］， beats ［i］ * tempo）;
// display current note on the lcd
lcd.print（notes［i］）;
}
// pause between notes
delay（tempo/2）;
}
}
else{
// box is closed
// turn LCD off
digitalWrite（backlightPin， LOW）;
lcd.clear（）;
lcd.print（“box closed.。。”）;
Serial.println（“Box closed， don‘t play music.”）;
}
}
/*
* （PROJ03） Metro （and Metro Express！） Music Box
* Desc： 21st century music box： Plays a melody when the box is open.
* Circuit： Piezo， 16x2 LCD， Photo Light Sensor
*
* by Brent Rubell for Adafruit Industries. Support Open Source Hardware， buy Adafruit！
*
*/
// include the lcd library code
#include
// initialize the library with the numbers of the interface pins
LiquidCrystal lcd（7， 8， 9， 10， 11， 12）;
// Piezo code.
int speakerPin = 5;
int length = 15; // the number of notes
char notes［］ = “ccggaagffeeddc ”; // a space represents a rest
int beats［］ = { 1， 1， 1， 1， 1， 1， 2， 1， 1， 1， 1， 1， 1， 2， 4 };
int tempo = 300;
// Photo Light Sensor Pin
int lightPin = 0;
// Measured Darkness
int dark = 650;
// LCD Backlight Pin
int backlightPin = 13;
void playTone（int tone， int duration） {
for （long i = 0; i 《 duration * 1000L; i += tone * 2） {
digitalWrite（speakerPin， HIGH）;
delayMicroseconds（tone）;
digitalWrite（speakerPin， LOW）;
delayMicroseconds（tone）;
}
}
void playNote（char note， int duration） {
char names［］ = { ’c‘， ’d‘， ’e‘， ’f‘， ’g‘， ’a‘， ’b‘， ’C‘ };
int tones［］ = { 1915， 1700， 1519， 1432， 1275， 1136， 1014， 956 };
// play the tone corresponding to the note name
for （int i = 0; i 《 8; i++） {
if （names［i］ == note） {
playTone（tones［i］， duration）;
}
}
}
void setup（） {
// set up the serial monitor
Serial.begin（9600）;
// set up the LCD’s cols/rows
lcd.begin（16， 2）;
// set speaker as an output
pinMode（speakerPin， OUTPUT）;
// set lcd backlight as an output
pinMode（backlightPin， OUTPUT）;
}
void loop（） {
// read the lightLevel
int lightLevel = analogRead（lightPin）;
Serial.println（“Light Level -》 ”）;
Serial.println（lightLevel）;
// check lightLevel against dark level （should be set manually by the user， check serial mon.）
if（lightLevel 《 dark）
{
// Box is OPEN！
digitalWrite（backlightPin， HIGH）;
lcd.clear（）;
Serial.println（“Box open， playing music！”）;
for （int i = 0; i 《 length; i++） {
if（notes［i］ == ‘ ’） {
// rest
delay（beats［i］ * tempo）;
// print a space to indicate a rest
lcd.print（“ ”）;
}
else {
// play notes in notes［］
playNote（notes［i］， beats ［i］ * tempo）;
// display current note on the lcd
lcd.print（notes［i］）;
}
// pause between notes
delay（tempo/2）;
}
}
else{
// box is closed
// turn LCD off
digitalWrite（backlightPin， LOW）;
lcd.clear（）;
lcd.print（“box closed.。。”）;
Serial.println（“Box closed， don‘t play music.”）;
}
}
遇到問題嗎？
我的液晶顯示器什么都不顯示。
查看CIRC14中的LCD接線指南，以仔細檢查所有接線是否正確。
我的音樂盒仍然過于敏感，或者不是足夠敏感。
int dark 直接控制環境的黑暗或明亮在您音樂盒內。如果您發現它觸發得太容易，請減小其值。
它仍然不起作用
我們將幫助您！在Adafruit支持論壇中發布，我們將盡快與您聯系。
變得更好
您的音樂盒無聊嗎？要添加到該電路上嗎？這里有一些想法供您跳板并學習過程中的新技能
音樂作曲家
編寫自己的旋律并成為作曲家，或改編一首較老的歌曲以在壓電板上播放。 （ tip ：檢查CIRC06的“變得更好”部分以獲取有關壓電揚聲器的更多詳細信息）
非常規機箱
有成千上萬種封裝電子項目的方法！使用非常規的外殼（例如雪茄盒）既可以保護您的項目，又可以使其看起來更好。嘗試使用其他盒子來保存您的音樂盒。
提示：要使用帶有光傳感器的新盒子，您應該改變什么？看看代碼部分。
答案：需要重新校準光傳感器。將int dark的值更改為新的Dark值。
Annoy-a-Box
想用這個電路煩擾您的朋友和家人嗎？更改代碼以使用高音調的嗚嗚聲，或使嗶聲像蜜蜂一樣在音調之間移動。
div》秘密消息框
您需要將秘密消息傳遞給某人，但寫得太久了。時間敏感的框是一個傳遞給朋友，同學或國際間諜的框，其中的字符LCD上包含秘密消息。
工作原理：在打開消息窗口時，計時器開始倒計時液晶顯示屏第二行上剩余的時間。計時器用完后，字符lcd清除消息，您無法再次顯示該消息。
PROJ04：Fidget微調器轉速表
固定旋轉器是可以緩解壓力的有趣玩具。它們在軸承上旋轉，并且可以達到真正高每分鐘轉數（RPM）。我們將為您的坐騎微調器構建一個轉速表，用于測量RPM。
我們在Tony D的原始Circuit Playground坐騎微調器代碼中包含了一些有趣的功能
》
像RPM高分游戲，可與您的朋友競爭（或使不同的微調器相互競爭）
還有一個倒計時時鐘，可讓您更好地計時旋轉。
零件
5毫米紅色LED
如果您想在Adafruit商店訂購更多紅色LED（它們會發出很好的指示燈！），請點擊這里！
照片傳感器
如果您想從Adafruit商店訂購其他光敏電阻，請單擊此處！
560歐姆電阻
顏色： 綠色》藍色》棕色
如果您想從Adafruit商店請點擊這里！ （它們的電阻為470歐姆，但可以用）
10K歐姆電阻
顏色：棕色》黑色》橙色
如果您想從Adafruit商店訂購更多的10k歐姆上拉電阻，請單擊此處！
面包板接線束
如果您愿意要從Adafruit商店訂購更多電線，請點擊此處！
Adafruit Metro（或Metro Express）+面包板+安裝板
如果尚未組裝，請如果您想從Adafruit商店訂購額外的塑料安裝板，Adafruit Metro，AdafruitMetro Express或Mini-Breadboard，請點擊這里！
接線
圖
組裝提示
固定旋轉器喜歡以高RPM將電線從面包板上撕下。本節詳細介紹如何避免這種情況的發生。
此接線涉及一些清理工作。細紗機纏在電線上。我們試圖通過利用您套件中的零件來使清理工作盡可能簡單。
首先，讓我們清理旋轉區。光傳感器和LED之間的區域是旋轉器移動的區域。我們建議使用面包板電線束中包含的長電線。將電線塞在板子下面，并用一條膠帶（或在我們的情況下，使用質量控制標簽）將其固定。
下一步，取一條較短的面包板電線，將其包裹在LCD的電線周圍。您也可以使用拉鏈結來固定。將此線的末端插入面包板。
代碼
將以下代碼復制/粘貼到空白的Arduino草圖中。然后，編譯并將其上傳到您的Metro。如果您看到LED在腳本中運行，請繼續下一頁。如果您沒有看到它正常運行，請查看下面的常見問題以尋求幫助。
下載： Project Zip 或 PROJ04_TACHOMETER.ino | 在Github上查看
復制代碼
/*
* （PROJ04） Metro （and Metro Express！） Fidget Spinner Tachometer
* Desc： Count fidget spinner RPMs （and beat your high scores）
*
* Original code by Tony Dicola for Adafruit Industries
* by Brent Rubell and Asher Lieber for the Metro Explorers Guide
*/
// include the LCD library code：
#include
// initialize the library with the numbers of the interface pins
LiquidCrystal lcd（7， 8， 9， 10， 11， 12）;
// How many arms does the spinner have？
#define SPINNER_ARMS 3
// 1kB sample size
#define SAMPLE_DEPTH 256
// delay between light samples
#define SAMPLE_PERIOD_US 150
// min. speed， depends on reflective-ness of spinner， noise thresh.
//#define THRESHOLD 127
// wait 2s between measurements
#define MEASURE_PERIOD_MS 2000
// rpm high score
float rpmHighScore = 0.00;
// threshold value
int threshold;
// photo light sensor pin
int photoSensor = A0;
// led pin
int led = 2;
void setup（） {
// Init. serial monitor @ 115200 baud
Serial.begin（9600）;
// set up the LCD’s number of columns and rows：
lcd.begin（16， 2）;
lcd.print（“Metro Tachometer”）;
// set up LED
pinMode（led， OUTPUT）;
}
void loop（） {
int sensorCalibrate = 0;
// Set depending on light balance
threshold = 40;
// PAUSE between measurements
lcd.clear（）;
lcd.print（“GET READY.。。”）;
analogWrite（led， 255）;
// pause between sampling sensor
// shown as a countdown on the screen！
for （int i = 3500; i 》 0; i--） {
lcd.setCursor（0，1）;
lcd.print（i/100）;
}
// init. empty sample array
uint16_t samples［SAMPLE_DEPTH］ = {0};
// start time
uint32_t start = micros（）;
// lcd during spin
lcd.clear（）;
lcd.print（“SPIN IT”）;
lcd.setCursor（0，1）;
lcd.print（“score： ”）;
lcd.setCursor（10，1）;
lcd.print（rpmHighScore）;
for （int i = 0; i 《 SAMPLE_DEPTH; i++） {
// sample the photo light sensor
samples［i］ = analogRead（photoSensor）;
// serial output
Serial.print（“ Sample： ”）;
Serial.print（samples［i］）;
// keep the player occupied while sampling
if （i == int（SAMPLE_DEPTH/4）） {
lcd.clear（）;
lcd.print（“keep going！”）;
lcd.setCursor（10，1）;
lcd.print（rpmHighScore）;
}
else if （i == int（SAMPLE_DEPTH/3）） {
lcd.clear（）;
lcd.print（“almost there！”）;
lcd.setCursor（10，1）;
lcd.print（rpmHighScore）;
}
delayMicroseconds（SAMPLE_PERIOD_US）;
}
// time elapsed （uS）
uint32_t elapsed_uS = micros（） - start;
// time elapsed （sec）
float elapsed = elapsed_uS / 1000000.0;
// Find the min and max values in the collected samples.
uint16_t minval = samples［0］;
uint16_t maxval = samples［0］;
for （int i=1; i minval = min（minval， samples［i］）;
maxval = max（maxval， samples［i］）;
}
// Serial Monitor Values
Serial.print（“ Samples taken， ： ”）;
Serial.print（elapsed， 3）;
Serial.print（“ seconds”）;
Serial.print（“ Max Sample Val： ”）;
Serial.print（maxval）;
Serial.print（“ Min Sample Val： ”）;
Serial.print（minval）;
// Check the amplitude of the signal （difference between min and max）
// is greater than the threshold to continue detecting speed.
uint16_t amplitude = maxval - minval;
if （amplitude 《 threshold） {
// Didn‘t make it past the threshold so start over with another measurement attempt.
lcd.clear（）;
lcd.println（“didnt spin fast enough， re-spin！”）;
Serial.print（“ DIDNT PASS THRESHOLD， RE-TAKING MEASUREMENT.。”）;
return;
}
// Compute midpoint of the signal （halfway between min and max values）。
uint16_t midpoint = minval + （amplitude/2）;
// Count how many midpoint crossings were found in the signal.
// These are instances where two readings either straddle or land on
// the midpoint. The midpoint crossings will happen twice for every
// complete sine wave cycle （once going up and again coming down）。
int crossings = 0;
for （int i=1; i uint16_t p0 = samples［i-1］;
uint16_t p1 = samples［i］;
if （（p1 == midpoint） ||
（（p0 《 midpoint） && （p1 》 midpoint）） ||
（（p0 》 midpoint） && （p1 《 midpoint））） {
crossings += 1;
}
}
// Compute signal frequency， RPM， and period.
// The period is the amount of time it takes for a complete
// sine wave cycle to occur. You can calculate this by dividing the
// amount of time that elapsed during the measurement period by the
// number of midpoint crossings cut in half （because each complete
// sine wave cycle will have 2 midpoint crossings）。 However since
// fidget spinners have multiple arms you also divide by the number
// of arms to normalize the period into a value that represents the
// time taken for a complete revolution of the entire spinner， not
// just the time between one arm and the next.
Serial.print（“ MP Crossings： ”）;
Serial.print（crossings）;
Serial.print（“ Elapsed： ”）;
Serial.print（elapsed）;
float period = elapsed / （crossings / 2.0 / SPINNER_ARMS）;
Serial.print（“ Period： ”）;
Serial.print（period）;
// Once the period is calculated it can be converted into a frequency
// value （i.e revolutions per second， how many times the spinner spins
// around per second） and more common RPM value （revolutions per minute，
// just multiply frequency by 60 since there are 60 seconds in a minute）。
float frequency = 1.0 / period;
float rpm = frequency * 60.0;
// Print out the measured values！
Serial.print（“Frequency： ”）;
Serial.print（frequency， 3）;
Serial.print（“ （hz） RPM： ”）;
Serial.print（rpm， 3）;
Serial.print（“ Period： ”）;
Serial.print（period， 3）;
Serial.println（“ （seconds）”）;
lcd.clear（）;
lcd.setCursor（1，0）;
lcd.print（rpm）;
delay（2000）;
// high score checker
if（rpm 》 rpmHighScore） {
rpmHighScore = rpm;
lcd.clear（）;
lcd.setCursor（0，0）;
lcd.print（“you beat the”）;
lcd.setCursor（0，1）;
lcd.print（“high score！”）;
delay（2000）;
}
}
/*
* （PROJ04） Metro （and Metro Express！） Fidget Spinner Tachometer
* Desc： Count fidget spinner RPMs （and beat your high scores）
*
* Original code by Tony Dicola for Adafruit Industries
* by Brent Rubell and Asher Lieber for the Metro Explorers Guide
*/
// include the LCD library code：
#include
// initialize the library with the numbers of the interface pins
LiquidCrystal lcd（7， 8， 9， 10， 11， 12）;
// How many arms does the spinner have？
#define SPINNER_ARMS 3
// 1kB sample size
#define SAMPLE_DEPTH 256
// delay between light samples
#define SAMPLE_PERIOD_US 150
// min. speed， depends on reflective-ness of spinner， noise thresh.
//#define THRESHOLD 127
// wait 2s between measurements
#define MEASURE_PERIOD_MS 2000
// rpm high score
float rpmHighScore = 0.00;
// threshold value
int threshold;
// photo light sensor pin
int photoSensor = A0;
// led pin
int led = 2;
void setup（） {
// Init. serial monitor @ 115200 baud
Serial.begin（9600）;
// set up the LCD’s number of columns and rows：
lcd.begin（16， 2）;
lcd.print（“Metro Tachometer”）;
// set up LED
pinMode（led， OUTPUT）;
}
void loop（） {
int sensorCalibrate = 0;
// Set depending on light balance
threshold = 40;
// PAUSE between measurements
lcd.clear（）;
lcd.print（“GET READY.。。”）;
analogWrite（led， 255）;
// pause between sampling sensor
// shown as a countdown on the screen！
for （int i = 3500; i 》 0; i--） {
lcd.setCursor（0，1）;
lcd.print（i/100）;
}
// init. empty sample array
uint16_t samples［SAMPLE_DEPTH］ = {0};
// start time
uint32_t start = micros（）;
// lcd during spin
lcd.clear（）;
lcd.print（“SPIN IT”）;
lcd.setCursor（0，1）;
lcd.print（“score： ”）;
lcd.setCursor（10，1）;
lcd.print（rpmHighScore）;
for （int i = 0; i 《 SAMPLE_DEPTH; i++） {
// sample the photo light sensor
samples［i］ = analogRead（photoSensor）;
// serial output
Serial.print（“ Sample： ”）;
Serial.print（samples［i］）;
// keep the player occupied while sampling
if （i == int（SAMPLE_DEPTH/4）） {
lcd.clear（）;
lcd.print（“keep going！”）;
lcd.setCursor（10，1）;
lcd.print（rpmHighScore）;
}
else if （i == int（SAMPLE_DEPTH/3）） {
lcd.clear（）;
lcd.print（“almost there！”）;
lcd.setCursor（10，1）;
lcd.print（rpmHighScore）;
}
delayMicroseconds（SAMPLE_PERIOD_US）;
}
// time elapsed （uS）
uint32_t elapsed_uS = micros（） - start;
// time elapsed （sec）
float elapsed = elapsed_uS / 1000000.0;
// Find the min and max values in the collected samples.
uint16_t minval = samples［0］;
uint16_t maxval = samples［0］;
for （int i=1; i minval = min（minval， samples［i］）;
maxval = max（maxval， samples［i］）;
}
// Serial Monitor Values
Serial.print（“ Samples taken， ： ”）;
Serial.print（elapsed， 3）;
Serial.print（“ seconds”）;
Serial.print（“ Max Sample Val： ”）;
Serial.print（maxval）;
Serial.print（“ Min Sample Val： ”）;
Serial.print（minval）;
// Check the amplitude of the signal （difference between min and max）
// is greater than the threshold to continue detecting speed.
uint16_t amplitude = maxval - minval;
if （amplitude 《 threshold） {
// Didn‘t make it past the threshold so start over with another measurement attempt.
lcd.clear（）;
lcd.println（“didnt spin fast enough， re-spin！”）;
Serial.print（“ DIDNT PASS THRESHOLD， RE-TAKING MEASUREMENT.。”）;
return;
}
// Compute midpoint of the signal （halfway between min and max values）。
uint16_t midpoint = minval + （amplitude/2）;
// Count how many midpoint crossings were found in the signal.
// These are instances where two readings either straddle or land on
// the midpoint. The midpoint crossings will happen twice for every
// complete sine wave cycle （once going up and again coming down）。
int crossings = 0;
for （int i=1; i uint16_t p0 = samples［i-1］;
uint16_t p1 = samples［i］;
if （（p1 == midpoint） ||
（（p0 《 midpoint） && （p1 》 midpoint）） ||
（（p0 》 midpoint） && （p1 《 midpoint））） {
crossings += 1;
}
}
// Compute signal frequency， RPM， and period.
// The period is the amount of time it takes for a complete
// sine wave cycle to occur. You can calculate this by dividing the
// amount of time that elapsed during the measurement period by the
// number of midpoint crossings cut in half （because each complete
// sine wave cycle will have 2 midpoint crossings）。 However since
// fidget spinners have multiple arms you also divide by the number
// of arms to normalize the period into a value that represents the
// time taken for a complete revolution of the entire spinner， not
// just the time between one arm and the next.
Serial.print（“ MP Crossings： ”）;
Serial.print（crossings）;
Serial.print（“ Elapsed： ”）;
Serial.print（elapsed）;
float period = elapsed / （crossings / 2.0 / SPINNER_ARMS）;
Serial.print（“ Period： ”）;
Serial.print（period）;
// Once the period is calculated it can be converted into a frequency
// value （i.e revolutions per second， how many times the spinner spins
// around per second） and more common RPM value （revolutions per minute，
// just multiply frequency by 60 since there are 60 seconds in a minute）。
float frequency = 1.0 / period;
float rpm = frequency * 60.0;
// Print out the measured values！
Serial.print（“Frequency： ”）;
Serial.print（frequency， 3）;
Serial.print（“ （hz） RPM： ”）;
Serial.print（rpm， 3）;
Serial.print（“ Period： ”）;
Serial.print（period， 3）;
Serial.println（“ （seconds）”）;
lcd.clear（）;
lcd.setCursor（1，0）;
lcd.print（rpm）;
delay（2000）;
// high score checker
if（rpm 》 rpmHighScore） {
rpmHighScore = rpm;
lcd.clear（）;
lcd.setCursor（0，0）;
lcd.print（“you beat the”）;
lcd.setCursor（0，1）;
lcd.print（“high score！”）;
delay（2000）;
}
}
LCD為空白/亂碼/毛刺
確保所有電線均正確插入且沒有松動。在將所有東西綁在一起的組裝步驟中，請確保所有東西都緊緊插入Metro和面包板中。
LED無法打開？
檢查LED接線。可能是電阻值錯誤。
仍然無法正常工作嗎？
在我們的社區支持論壇上發布！
零件
這是Metro Express項目。
紅外傳感器
使用方式：紅外傳感器接收并解碼進入的紅外。
如果要從Adafruit商店訂購額外的紅外接收器傳感器，請單擊此處！
小型遙控器
用法：迷你遙控器將發送 紅外信號到連接到Metro M0 Express的紅外傳感器。
如果想要從Adafruit商店訂購額外的迷你遙控器，請單擊此處！
迷你USB電纜
請確保您使用的迷你USB電纜充電+數據而不僅僅是充電。
如果您想從Adafruit商店訂購Mini-USB電纜，請點擊此處
面包板接線束
如何使用：我們將把電源線，地線和數據線連接到紅外傳感器的3個引腳上。
如果您要要從Adafruit商店訂購更多電線，請點擊此處！
Adafruit Metro Express +面包板+安裝板
如果您尚未組裝此指南，那么我們將為您提供方便的指南！
需要aextra塑料安裝板，Adafruit MetroExpress或Mini-Breadboard Adafruit商店？
接線
代碼
對于該項目，我們將同時使用IRLib和Keyboard庫，因此，讓我們弄清楚如何組合它們。本節是自學的，因為我們將逐段為您提供代碼，您可以繼續學習。
首先，我們希望同時包括IRLibAll和鍵盤庫：
下載：文件
復制代碼
#include
#include #include
#include
然后，我們將包含按鈕代碼。由于這些都是長整數，因此它們被編碼為十六進制值-Colin在此處提供了有關此主題的精彩視頻。
下載：文件
復制代碼
/* Remote Codes */
#define VOLUMEUP 0xfd40bf
#define VOLUMEDOWN 0xfd00ff
#define RIGHT_ARROW 0xfd50af
#define LEFT_ARROW 0xfd10ef
#define PLAYPAUSE 0xfd807f
#define SELECT_BUTTON 0xfd906f
/* Remote Codes */
#define VOLUMEUP 0xfd40bf
#define VOLUMEDOWN 0xfd00ff
#define RIGHT_ARROW 0xfd50af
#define LEFT_ARROW 0xfd10ef
#define PLAYPAUSE 0xfd807f
#define SELECT_BUTTON 0xfd906f
我們將NEC定義為Adafruit Mini遙控器，然后在數字引腳2上創建一個接收器。之后，創建一個解碼器對象和一個整數，以保存NEC重復代碼的先前代碼。
下載：文件
復制代碼
// Adafruit Mini-Remote uses NEC， change this if you’re using a different remote
#define MY_PROTOCOL NEC
// receiver on pin 2
IRrecv myReceiver（2）;
// Decoder object
IRdecode myDecoder;
// NEC repeat codes for Adafruit Mini-Remote
uint32_t Previous; // Adafruit Mini-Remote uses NEC， change this if you‘re using a different remote
#define MY_PROTOCOL NEC
// receiver on pin 2
IRrecv myReceiver（2）;
// Decoder object
IRdecode myDecoder;
// NEC repeat codes for Adafruit Mini-Remote
uint32_t Previous;
最后，我們要在引腳13上創建一個LED對象，它是內置LED。我們將使用這種方法在視覺上調試電路，而無需打印到串行監視器。
下載：文件
復制代碼
const int ledPin = 13; const int ledPin = 13;
在setup（）循環中，我們要進行告訴Metro開始控制鍵盤，啟動IR接收器，并將led配置為輸出。
下載：文件
復制代碼
void setup（） {
// initialize control over the keyboard
Keyboard.begin（）;
// start the IR receiver
myReceiver.enableIRIn（）;
// configure status LED
pinMode（LED_BUILTIN， OUTPUT）;
} void setup（） {
// initialize control over the keyboard
Keyboard.begin（）;
// start the IR receiver
myReceiver.enableIRIn（）;
// configure status LED
pinMode（LED_BUILTIN， OUTPUT）;
}
loop（）非常復雜，但我們將其分解以使其更容易。我們將首先檢測接收器是否使用myReceiver.getResults（）從遙控器獲得輸入。然后，我們將通過調用myDecoder.decode（）對其進行解碼。
接下來，我們要檢查協議是否與Mini Remote NEC所使用的協議相同，請檢查if（myDecoder.protocolNum==MY_PROTOCOL）。最后，我們將檢測重復代碼，并將當前值設置為先前的解碼值if（myDecoder.value==0xFFFFFFFF {myDecoder.value=Previous;}
下載：文件
復制代碼
void loop（）
{
if （myReceiver.getResults（）） {
myDecoder.decode（）;
if（myDecoder.protocolNum==MY_PROTOCOL） {
if（myDecoder.value==0xFFFFFFFF）
myDecoder.value=Previous;
// handle everything in here void loop（）
{
if （myReceiver.getResults（）） {
myDecoder.decode（）;
if（myDecoder.protocolNum==MY_PROTOCOL） {
if（myDecoder.value==0xFFFFFFFF）
myDecoder.value=Previous;
// handle everything in here
Phew，現在有趣的部分開始了。我們將使用稱為SwitchCase的編程概念。這將使我們接受一個值（由解碼器解碼的值-myDecode.value），并根據值是什么來執行不同的操作。
，我們將根據myDecoder.value進行切換。第一種情況是是否檢測到“ PLAYPAUSE”按鈕（已在上面#define定義）。我們要發送空格鍵來暫停VLC播放。
下載：file
復制代碼
switch（myDecoder.value） {
case PLAYPAUSE：
// key-play-pause
// send the spacebar key
switch（myDecoder.value） {
case PLAYPAUSE：
// key-play-pause
// send the spacebar key
我們將使用Keyboard.write（）。將空格鍵ascii值0x20發送到鍵盤然后，我們將使LED發光以指示已發送密鑰（這是一種非常簡單的可視化代碼調試方式）。接下來，我們將延遲，然后調用Keyboard.releaseAll（）;釋放按下的鍵。然后，在這種情況下，我們將break;并完成執行。
下載：文件
復制代碼
Keyboard.write（（char）0x20）;
digitalWrite（LED_BUILTIN， HIGH）;
delay（100）;
// release the keys pressed
Keyboard.releaseAll（）;
break; Keyboard.write（（char）0x20）;
digitalWrite（LED_BUILTIN， HIGH）;
delay（100）;
// release the keys pressed
Keyboard.releaseAll（）;
break;
現在您已經有了主意，我們將為您提供代碼。如果您想更好地理解這個項目，請嘗試使之更好部分。
下載：Project Zip 或 PROJ05_IR_MEDIA_CONTROLLER.ino | 在Github上查看
復制代碼
/* PROJ05： Metro Media Remote
* Desc： Control VLC with your Adafruit Metro M0 Express！
* by Brent Rubell and Asher Liber for Adafruit Industries
* Requires IRLib2.x Library
*/
#include
#include
/* Remote Codes */
#define VOLUMEUP 0xfd40bf
#define VOLUMEDOWN 0xfd00ff
#define RIGHT_ARROW 0xfd50af
#define LEFT_ARROW 0xfd10ef
#define PLAYPAUSE 0xfd807f
#define SELECT_BUTTON 0xfd906f
// These are some extra button codes.。.not used in the PROJ.
// if you want to create more functions in VLC or any other app， use these！
#define UP_ARROW 0xfda05f
#define DOWN_ARROW 0xfdb04f
#define BUTTON_0 0xfd30cf
#define BUTTON_1 0xfd08f7
#define BUTTON_2 0xfd8877
#define BUTTON_3 0xfd48b7
#define BUTTON_4 0xfd28d7
#define BUTTON_5 0xfda857
#define BUTTON_6 0xfd6897
#define BUTTON_7 0xfd18e7
#define BUTTON_8 0xfd9867
#define BUTTON_9 0xfd58a7
// Adafruit Mini-Remote uses NEC， change this if you’re using a different remote
#define MY_PROTOCOL NEC
// receiver on pin 2
IRrecv myReceiver（2）;
// Decoder object
IRdecode myDecoder;
// NEC repeat codes for Adafruit Mini-Remote
uint32_t Previous;
// use this option for OSX：
char ctrlKey = KEY_LEFT_GUI;
// use this option for Windows and Linux：
// char ctrlKey = KEY_LEFT_CTRL;
const int ledPin = 13;
void setup（） {
// monitor the serial at 9600baud
Serial.begin（9600）;
// initialize control over the keyboard
Keyboard.begin（）;
// start the IR receiver
myReceiver.enableIRIn（）;
// configure status LED
pinMode（LED_BUILTIN， OUTPUT）;
Serial.println（“Listening to IR.。。”）;
}
void loop（）
{
if （myReceiver.getResults（）） {
myDecoder.decode（）;
if（myDecoder.protocolNum==MY_PROTOCOL） {
if（myDecoder.value==0xFFFFFFFF）
myDecoder.value=Previous;
// We used VLC for this example， but you can use any keyboard shortcuts！
// （src： https://wiki.videolan.org/Hotkeys_table/）
switch（myDecoder.value） {
case PLAYPAUSE：
// key-play-pause
// send the spacebar key
Keyboard.write（（char）0x20）;
digitalWrite（LED_BUILTIN， HIGH）;
delay（100）;
// release the keys pressed
Keyboard.releaseAll（）;
break;
case VOLUMEUP：
// key-vol-up
// vlc shortcut： ctrl + up arrow
Keyboard.press（ctrlKey）;
Keyboard.press（KEY_UP_ARROW）;
digitalWrite（LED_BUILTIN， HIGH）;
delay（100）;
Keyboard.releaseAll（）;
break;
case VOLUMEDOWN：
// key-vol-down
// vlc shortcut： ctrl + down arrow
Keyboard.press（ctrlKey）;
Keyboard.press（KEY_DOWN_ARROW）;
digitalWrite（LED_BUILTIN， HIGH）;
delay（100）;
Keyboard.releaseAll（）;
break;
case RIGHT_ARROW：
// key-faster
// vlc shortcut： +
Keyboard.press（‘+’）;
digitalWrite（LED_BUILTIN， HIGH）;
delay（100）;
Keyboard.releaseAll（）;
break;
case LEFT_ARROW：
// key-faster
// vlc shortcut： -
Keyboard.press（‘-’）;
digitalWrite（LED_BUILTIN， HIGH）;
delay（100）;
Keyboard.releaseAll（）;
break;
default：
// if nothing else matches， do the default
// default is optional
break;
}
Previous=myDecoder.value;
}
digitalWrite（LED_BUILTIN， LOW）;
myReceiver.enableIRIn（）;
}
}
/* PROJ05： Metro Media Remote
* Desc： Control VLC with your Adafruit Metro M0 Express！
* by Brent Rubell and Asher Liber for Adafruit Industries
* Requires IRLib2.x Library
*/
#include
#include
/* Remote Codes */
#define VOLUMEUP 0xfd40bf
#define VOLUMEDOWN 0xfd00ff
#define RIGHT_ARROW 0xfd50af
#define LEFT_ARROW 0xfd10ef
#define PLAYPAUSE 0xfd807f
#define SELECT_BUTTON 0xfd906f
// These are some extra button codes.。.not used in the PROJ.
// if you want to create more functions in VLC or any other app， use these！
#define UP_ARROW 0xfda05f
#define DOWN_ARROW 0xfdb04f
#define BUTTON_0 0xfd30cf
#define BUTTON_1 0xfd08f7
#define BUTTON_2 0xfd8877
#define BUTTON_3 0xfd48b7
#define BUTTON_4 0xfd28d7
#define BUTTON_5 0xfda857
#define BUTTON_6 0xfd6897
#define BUTTON_7 0xfd18e7
#define BUTTON_8 0xfd9867
#define BUTTON_9 0xfd58a7
// Adafruit Mini-Remote uses NEC， change this if you‘re using a different remote
#define MY_PROTOCOL NEC
// receiver on pin 2
IRrecv myReceiver（2）;
// Decoder object
IRdecode myDecoder;
// NEC repeat codes for Adafruit Mini-Remote
uint32_t Previous;
// use this option for OSX：
char ctrlKey = KEY_LEFT_GUI;
// use this option for Windows and Linux：
// char ctrlKey = KEY_LEFT_CTRL;
const int ledPin = 13;
void setup（） {
// monitor the serial at 9600baud
Serial.begin（9600）;
// initialize control over the keyboard
Keyboard.begin（）;
// start the IR receiver
myReceiver.enableIRIn（）;
// configure status LED
pinMode（LED_BUILTIN， OUTPUT）;
Serial.println（“Listening to IR.。。”）;
}
void loop（）
{
if （myReceiver.getResults（）） {
myDecoder.decode（）;
if（myDecoder.protocolNum==MY_PROTOCOL） {
if（myDecoder.value==0xFFFFFFFF）
myDecoder.value=Previous;
// We used VLC for this example， but you can use any keyboard shortcuts！
// （src： https://wiki.videolan.org/Hotkeys_table/）
switch（myDecoder.value） {
case PLAYPAUSE：
// key-play-pause
// send the spacebar key
Keyboard.write（（char）0x20）;
digitalWrite（LED_BUILTIN， HIGH）;
delay（100）;
// release the keys pressed
Keyboard.releaseAll（）;
break;
case VOLUMEUP：
// key-vol-up
// vlc shortcut： ctrl + up arrow
Keyboard.press（ctrlKey）;
Keyboard.press（KEY_UP_ARROW）;
digitalWrite（LED_BUILTIN， HIGH）;
delay（100）;
Keyboard.releaseAll（）;
break;
case VOLUMEDOWN：
// key-vol-down
// vlc shortcut： ctrl + down arrow
Keyboard.press（ctrlKey）;
Keyboard.press（KEY_DOWN_ARROW）;
digitalWrite（LED_BUILTIN， HIGH）;
delay（100）;
Keyboard.releaseAll（）;
break;
case RIGHT_ARROW：
// key-faster
// vlc shortcut： +
Keyboard.press（’+‘）;
digitalWrite（LED_BUILTIN， HIGH）;
delay（100）;
Keyboard.releaseAll（）;
break;
case LEFT_ARROW：
// key-faster
// vlc shortcut： -
Keyboard.press（’-‘）;
digitalWrite（LED_BUILTIN， HIGH）;
delay（100）;
Keyboard.releaseAll（）;
break;
default：
// if nothing else matches， do the default
// default is optional
break;
}
Previous=myDecoder.value;
}
digitalWrite（LED_BUILTIN， LOW）;
myReceiver.enableIRIn（）;
}
}
我對此項目項目
致命錯誤：IRLibAll.h：無此類文件或目錄＃包括
IRLib 2.x庫安裝不正確。檢查CIRC16的“安裝IR庫”頁面以獲取正確的安裝說明。
我的計算機沒有響應遠程
如果您使用的是Adafruit Mini-Remote，請確保取消注釋（刪除斜線）char ctrlKey您所使用的操作系統的變量：
// use this option for OSX：
char ctrlKey = KEY_LEFT_GUI;
// use this option for Windows and Linux：
// char ctrlKey = KEY_LEFT_CTRL;
如果使用自己的遙控器，則需要對代碼進行修改。有關更多信息，請參閱本指南中的發送IR代碼。
該項目仍無法正常工作
在Adafruit支持論壇中發布，我們將盡快與您聯系。
變得更好
我們在最后一頁提供的代碼中為您添加了一些額外的按鈕：
下載：文件
復制代碼
// These are some extra button codes.。.not used in the PROJ.
// if you want to create more functions in VLC or any other app， use these！
#define UP_ARROW 0xfda05f
#define DOWN_ARROW 0xfdb04f
#define BUTTON_0 0xfd30cf
#define BUTTON_1 0xfd08f7
#define BUTTON_2 0xfd8877
#define BUTTON_3 0xfd48b7
#define BUTTON_4 0xfd28d7
#define BUTTON_5 0xfda857
#define BUTTON_6 0xfd6897
#define BUTTON_7 0xfd18e7
#define BUTTON_8 0xfd9867
#define BUTTON_9 0xfd58a7 // These are some extra button codes.。.not used in the PROJ.
// if you want to create more functions in VLC or any other app， use these！
#define UP_ARROW 0xfda05f
#define DOWN_ARROW 0xfdb04f
#define BUTTON_0 0xfd30cf
#define BUTTON_1 0xfd08f7
#define BUTTON_2 0xfd8877
#define BUTTON_3 0xfd48b7
#define BUTTON_4 0xfd28d7
#define BUTTON_5 0xfda857
#define BUTTON_6 0xfd6897
#define BUTTON_7 0xfd18e7
#define BUTTON_8 0xfd9867
#define BUTTON_9 0xfd58a7
如果您想在VLC中將這些命令用于不同的命令，或者控制Netflix或Youtube，請查閱Arduino修改器鍵文檔。實施新密鑰，或在SwitchCase中修改您先前存在的案例以使用其他密鑰。
PROJ06：紅外激光寵物玩具
您想惹惱您（或家人）的寵物嗎？也許您想以最懶惰的方式鍛煉寵物？您將要制造一個由紅外遙控器和Adafruit Metro控制的激光寵物玩具。
這是它的工作方式：將廉價的激光筆固定在伺服喇叭。您將使用雙面膠帶將舵機安裝到面包板上，以使其牢固。然后，將您的紅外傳感器與伺服器連接起來，并編寫一個程序，使您可以在安全距離內煩擾/鍛煉寵物
對激光和寵物的了解
激光指示器點可以同時驅使貓狗強迫行為，因為它可以找出寵物的“獵物”本能。我們強烈建議在房間周圍藏一些食物，然后讓IR激光寵物玩具朝食物的方向移動。 追逐自己認為是獵物的狗/貓需要獎勵。
我們還建議您和您的寵物避免直接接觸激光。在與動物玩耍時，請保持打開激光，以免它們望著燈（關閉/打開它會使它們迅速轉過身）。
零件
該項目需要外部零件。
此項目需要激光指針。我們不建議不要使用我們在Adafruit商店中出售的Laser 二極管。您的角落商店或亞馬遜出售的是功率很低的激光指針。
IR接收器用于接收來自遙控器的紅外信號。這些信號然后將被發送到Metro，Metro將告訴伺服器將移動到何處。
Mini Remote包含一個IR LED，用于向連接到Metro M0的IR接收器傳輸信號。
Hobby Servo將用作平臺來左右旋轉激光指示器。
面包板接線束
如果您想從Adafruit商店訂購更多電線，請點擊此處！
Adafruit地鐵+面包板+安裝板
如果您尚未組裝，我們將為您提供方便的指南！
如果您想從Adafruit商店訂購額外的塑料安裝板，Adafruit Metro或Mini-Breadboard，請點擊此處！
接線
裝配有兩種方法：我們可以將激光指示器放在伺服器的頂部，然后用膠帶將其打開，或者將其拆開。并在其上焊接一些引線，以便可由Metro控制。
此接線是第一種選擇（非受控激光）。
此接線用于激光器由紅外遙控器控制。我們正在通過從引腳＃13發送電壓來控制激光器。
裝配體
該項目需要一些裝配體（例如音樂盒）才能使您獲得很好的性能。
伺服接線
我們將對伺服器進行接線，以使面包板接線束中的電線更長被使用。我們要將伺服安裝在
Base上程序集
膠帶并將其折疊（或卷起來）。
然后將其放在安裝板上。向下按以保持牢固的握持力（伺服機構可以非常有力地移動）。
打一條領帶（如您在當地超市可以買到的領帶）或一條領帶，然后將激光筆固定在舵機的角上。我們喜歡使用扎帶和扎帶，因為它們非常便宜且不永久。
代碼
此代碼看起來與PROJ05非常相似-它使用類似的結構來處理IR遠程按鈕按下，但使用伺服器而不是USB HID 。我們還將介紹您可能在以前的CIRC中看到的三個新概念-random（），min（）和max（）。
首先，讓我們導入兩個IRLiband Servo：
下載：文件
復制代碼
#include
#include #include
#include
然后，我們將包含所有特定于遠程的代碼。這將包括#define的遠程值，接收器引腳分配，解碼器對象和所使用的ir協議。
下載：文件
復制代碼
/* Adafruit Mini Remote */
#define MY_PROTOCOL NEC
#define RIGHT_ARROW 0xfd50af
#define LEFT_ARROW 0xfd10ef
#define SELECT_BUTTON 0xfd906f
#define BUTTON_0 0xfd30cf
#define BUTTON_1 0xfd08f7
#define BUTTON_2 0xfd8877
#define BUTTON_3 0xfd48b7
#define BUTTON_4 0xfd28d7
#define BUTTON_5 0xfda857
#define BUTTON_6 0xfd6897
#define BUTTON_7 0xfd18e7
#define BUTTON_8 0xfd9867
#define BUTTON_9 0xfd58a7
// pin number for the receiver
IRrecv myReceiver（2）;
IRdecode myDecoder;
// handles nec repeat codes
uint32_t Previous;
/* Adafruit Mini Remote */
#define MY_PROTOCOL NEC
#define RIGHT_ARROW 0xfd50af
#define LEFT_ARROW 0xfd10ef
#define SELECT_BUTTON 0xfd906f
#define BUTTON_0 0xfd30cf
#define BUTTON_1 0xfd08f7
#define BUTTON_2 0xfd8877
#define BUTTON_3 0xfd48b7
#define BUTTON_4 0xfd28d7
#define BUTTON_5 0xfda857
#define BUTTON_6 0xfd6897
#define BUTTON_7 0xfd18e7
#define BUTTON_8 0xfd9867
#define BUTTON_9 0xfd58a7
// pin number for the receiver
IRrecv myReceiver（2）;
IRdecode myDecoder;
// handles nec repeat codes
uint32_t Previous;
下一步，我們將創建伺服對象myServo，用于存儲伺服位置的變量和用于保存伺服角度（以度為單位）的變量。
下載：文件
復制代碼
/* Servo */
// create a servo object
Servo myServo;
// stores the servo position
int16_t pos;
// angle （degrees） to move the servo left/right
int16_t Speed;
/* Servo */
// create a servo object
Servo myServo;
// stores the servo position
int16_t pos;
// angle （degrees） to move the servo left/right
int16_t Speed;
（可選） 如果您正在使用激光并且能夠在地鐵上對其進行控制（請參見：組裝），我們將把電源連接到引腳11。一個布爾值laserToggle，以打開和關閉激光。 laserToggle保留兩個值之一- true 或 false 。根據所按下的按鈕和當前狀態，我們可以輕松切換激光器。
下載：文件
復制代碼
/* Laser */
// connect laser PWR to a pin 11
const int laserPin = 11;
// toggle the laser
bool laserToggle = false;
/* Laser */
// connect laser PWR to a pin 11
const int laserPin = 11;
// toggle the laser
bool laserToggle = false;
我們的 setup（）代碼需要設置激光針作為輸出，將伺服器連接到針9，將初始pos設置為90，將初始pos設置為90，將初始Speed設置為5。然后，我們將將pos寫入伺服器并啟動IR接收器。
下載：文件
復制代碼
void setup（） {
// randomizes a seed for random（） calls
randomSeed（analogRead（0））;
// set the laser pin as an output
pinMode（laserPin， OUTPUT）;
// attach servo to pin 9
myServo.attach（9）;
// set initial position
pos = 90;
// set initial speed
Speed = 5;
// write initial pos to servo at startup
myServo.write（pos）;
// Start the IR receiver
myReceiver.enableIRIn（）;
}
void setup（） {
// randomizes a seed for random（） calls
randomSeed（analogRead（0））;
// set the laser pin as an output
pinMode（laserPin， OUTPUT）;
// attach servo to pin 9
myServo.attach（9）;
// set initial position
pos = 90;
// set initial speed
Speed = 5;
// write initial pos to servo at startup
myServo.write（pos）;
// Start the IR receiver
myReceiver.enableIRIn（）;
}
如前所述，此代碼類似于PROJ05：
loop（）非常復雜，但是我們將對其進行分解以使其更容易。我們將首先檢測接收器是否使用myReceiver.getResults（）從遙控器獲得輸入。然后，我們將通過調用myDecoder.decode（）對其進行解碼。
接下來，我們要檢查協議是否與Mini Remote NEC所使用的協議相同，請檢查if（myDecoder.protocolNum==MY_PROTOCOL）。最后，我們將檢測重復代碼，并將當前值設置為先前的解碼值if（myDecoder.value==0xFFFFFFFF {myDecoder.value=Previous;}
下載：文件
復制代碼
void loop（）
{
if （myReceiver.getResults（）） {
myDecoder.decode（）;
if（myDecoder.protocolNum==MY_PROTOCOL） {
if（myDecoder.value==0xFFFFFFFF）
myDecoder.value=Previous;
switch（myDecoder.value） { void loop（）
{
if （myReceiver.getResults（）） {
myDecoder.decode（）;
if（myDecoder.protocolNum==MY_PROTOCOL） {
if（myDecoder.value==0xFFFFFFFF）
myDecoder.value=Previous;
switch（myDecoder.value） {
但這一次，我們要進行的是在寫入伺服器之前設置伺服器的位置。業余伺服器的旋轉角度特別令人難以置信，如果旋轉得太遠，它們可能會損壞。讓我們用min（）函數來防止這種情況。此功能會將伺服器的位置設置為 pos + Speed ，但會將值保持在下方或180度，以免超出該點。
下載：文件
復制代碼
case LEFT_ARROW：
// move servo
pos=min（180，pos+Speed）;
break; case LEFT_ARROW：
// move servo
pos=min（180，pos+Speed）;
break;
類似地，如果要限制右側，請將pos設置為max（0， pos-Speed）。 Max與min相反，則限制值的下端
下載：文件
復制代碼
case RIGHT_ARROW：
pos=max（0，pos-Speed）;
break; case RIGHT_ARROW：
pos=max（0，pos-Speed）;
break;
Arduino允許您做的一件很酷的事就是生成一個隨機數。如果調用random（0， 180），則可以生成0到180之間的隨機數。讓我們設置一個按鈕，將pos設置為隨機調用。
下載：文件
復制代碼
case BUTTON_0：
pos=random（0，180）;
break; case BUTTON_0：
pos=random（0，180）;
break;
在case語句之后，您將要：
1。寫入伺服器，
2。處理NEC重復代碼：Previous=myDecoder.value;
3。重新啟用IR接收器
下載：文件
復制代碼
myServo.write（pos）;
Previous=myDecoder.value;
myReceiver.enableIRIn（）;
myServo.write（pos）;
Previous=myDecoder.value;
myReceiver.enableIRIn（）;
完整代碼如下
下載：Project Zip 或 PROJ06_IR_PET.ino | 在Github上查看
復制代碼
/*
Metro Explorers Guide
PROJ06 - IR Laser Pet Toy
by Brent Rubell and Asher Lieber for Adafruit Industries. Support Open Source， buy Adafruit！
Note： this sketch requires IRLIB2.x
*/
#include
#include
/* Adafruit Mini Remote */
#define MY_PROTOCOL NEC
#define RIGHT_ARROW 0xfd50af
#define LEFT_ARROW 0xfd10ef
#define SELECT_BUTTON 0xfd906f
#define BUTTON_0 0xfd30cf
#define BUTTON_1 0xfd08f7
#define BUTTON_2 0xfd8877
#define BUTTON_3 0xfd48b7
#define BUTTON_4 0xfd28d7
#define BUTTON_5 0xfda857
#define BUTTON_6 0xfd6897
#define BUTTON_7 0xfd18e7
#define BUTTON_8 0xfd9867
#define BUTTON_9 0xfd58a7
// pin number for the receiver
IRrecv myReceiver（2）;
IRdecode myDecoder;
// handles nec repeat codes
uint32_t Previous;
/* Servo */
// create a servo object
Servo myServo;
// stores the servo position
int16_t pos;
// angle （degrees） to move the servo left/right
int16_t Speed;
void setup（） {
// randomizes a seed for random（） calls
randomSeed（analogRead（0））;
// set the laser pin as an output
//pinMode（laserPin， OUTPUT）;
// attach servo to pin 9
myServo.attach（9）;
// set initial position
pos = 90;
// set initial speed
Speed = 5;
// write initial pos to servo at startup
myServo.write（pos）;
// Start the IR receiver
myReceiver.enableIRIn（）;
}
void loop（）
{
if （myReceiver.getResults（）） {
myDecoder.decode（）;
if （myDecoder.protocolNum == MY_PROTOCOL） {
if （myDecoder.value == 0xFFFFFFFF）
myDecoder.value = Previous;
switch （myDecoder.value） {
case LEFT_ARROW：
// move servo
pos = min（180， pos + Speed）;
break;
case RIGHT_ARROW：
pos=max（0，pos-Speed）;
break;
case BUTTON_0：
pos=random（0，180）;
break;
}
// tell servo ’move to variable pos‘
myServo.write（pos）;
Previous=myDecoder.value;
}
myReceiver.enableIRIn（）;
}
}
/*
Metro Explorers Guide
PROJ06 - IR Laser Pet Toy
by Brent Rubell and Asher Lieber for Adafruit Industries. Support Open Source， buy Adafruit！
Note： this sketch requires IRLIB2.x
*/
#include
#include
/* Adafruit Mini Remote */
#define MY_PROTOCOL NEC
#define RIGHT_ARROW 0xfd50af
#define LEFT_ARROW 0xfd10ef
#define SELECT_BUTTON 0xfd906f
#define BUTTON_0 0xfd30cf
#define BUTTON_1 0xfd08f7
#define BUTTON_2 0xfd8877
#define BUTTON_3 0xfd48b7
#define BUTTON_4 0xfd28d7
#define BUTTON_5 0xfda857
#define BUTTON_6 0xfd6897
#define BUTTON_7 0xfd18e7
#define BUTTON_8 0xfd9867
#define BUTTON_9 0xfd58a7
// pin number for the receiver
IRrecv myReceiver（2）;
IRdecode myDecoder;
// handles nec repeat codes
uint32_t Previous;
/* Servo */
// create a servo object
Servo myServo;
// stores the servo position
int16_t pos;
// angle （degrees） to move the servo left/right
int16_t Speed;
void setup（） {
// randomizes a seed for random（） calls
randomSeed（analogRead（0））;
// set the laser pin as an output
//pinMode（laserPin， OUTPUT）;
// attach servo to pin 9
myServo.attach（9）;
// set initial position
pos = 90;
// set initial speed
Speed = 5;
// write initial pos to servo at startup
myServo.write（pos）;
// Start the IR receiver
myReceiver.enableIRIn（）;
}
void loop（）
{
if （myReceiver.getResults（）） {
myDecoder.decode（）;
if （myDecoder.protocolNum == MY_PROTOCOL） {
if （myDecoder.value == 0xFFFFFFFF）
myDecoder.value = Previous;
switch （myDecoder.value） {
case LEFT_ARROW：
// move servo
pos = min（180， pos + Speed）;
break;
case RIGHT_ARROW：
pos=max（0，pos-Speed）;
break;
case BUTTON_0：
pos=random（0，180）;
break;
}
// tell servo ’move to variable pos‘
myServo.write（pos）;
Previous=myDecoder.value;
}
myReceiver.enableIRIn（）;
}
}
該項目無法正常運行
我的伺服器無法正確移動
請確保您的伺服器已連接到Metro或Metro Express上的數字引腳9 。還要確保草圖中包含伺服庫（在草圖頂部，您應該看到#include ）。
《我class =“ fa fa-question-circle-o”》
我’ m使用其他遙控器，我應該做些不同的事情嗎？
代碼該項目僅適用于Adafruit Mini Remote。如果您想使用其他遙控器，請查閱本指南以獲取更多信息。
該項目仍無法正常工作
在Adafruit支持論壇中發布，我們將盡快與您聯系：）
PROJ08：模擬溫度計表
Adafruit商店中最酷的產品之一是汽車儀表步進電機，這是一種帶有指針指示器的步進電機。該儀表可用于物理感覺，類似于汽車的轉速表。
由于我們已經有了伺服電機，因此我們可以構建一個模擬儀表來測量溫度。該PROJ還可以重新用于為您可以測量的任何事物創建物理輸出量規！
零件
迷你伺服器
如果您想從Adafruit商店訂購額外的迷你伺服器，請單擊此處！
Adafruit商店中還有許多其他伺服尺寸和類型，請查看我們的產品
模擬溫度傳感器看起來很像NPN晶體管，請確保其上顯示“ TMP36”！
模擬溫度傳感器
如果您想要一個額外的溫度傳感器，可以從Adafruit商店購買一個，單擊此處
面包板接線束
如果想要從Adafruit商店訂購更多電線，請點擊此處！
Adafruit Metro（或Metro Express）+面包板+安裝板
如果您尚未組裝，我們將為您提供方便的指南！
如果您想從Adafruit商店訂購額外的塑料安裝板，Adafruit Metro，AdafruitMetro Express或Mini-Breadboard，請點擊此處！
接線
請注意，有兩個電源連接： TMP36連接到3.3V引腳，伺服連接到5V引腳。如果您使用的是常規地鐵，那么兩者都可以連接到 5V 引腳并通過代碼進行控制。
組裝
我們為此的組裝過程可能會因您您想要制作電路的方式而有所不同。外殼可能有所不同，您甚至可能想嘗試使用Adafruitstore中的其他伺服器。但是，校準非常重要，您需要“撥入”您的伺服器以確保它能完美顯示。
在您的伺服器中撥號
首先，我們應將伺服系統移至其中心位置。下載并運行此小型Arduino代碼。它將伺服移動到其中心位置：
下載：文件
復制代碼
/*
* Servo Centering Script
*
*/
#include
Servo myservo;
void setup（） {
myservo.attach（9）;
}
void loop（） {
// change this depending on where you‘re centering
myservo.write（90）;
delay（15）;
}
/*
* Servo Centering Script
*
*/
#include
Servo myservo;
void setup（） {
myservo.attach（9）;
}
void loop（） {
// change this depending on where you’re centering
myservo.write（90）;
delay（15）;
}
您應該會看到伺服喇叭向中心移動。從伺服器上卸下喇叭（如果將其擰緊，則必須將其擰松），并用記號筆標記其頂端。這將是您的指標：
將喇叭重新安裝到舵機上（現在應該處于90度位置），您就可以開始滾動了！
組裝外殼
讓我們建立一個外殼，以便您可以在工作中或在房間的任何地方使用它。經驗豐富的Dano Wallw打造了可打印，剪裁的設計，該設計適合您的metroX套件隨附的盒子頂部。這是一種雙撥號設計，可與華氏溫度和攝氏溫度一起使用。您可以下載下面的設計（它是開源的，并且可以完全修改）：
將印刷的表盤與MetroX盒子進行測試適配，然后沿黑色外線切掉
將四個角（我們只在下面的gif文件中用膠帶將兩個粘貼在盒子的內部。如果可以，請使用透明膠帶，這樣看起來會更干凈：
使用盒刀或剪刀的邊緣在您的印刷設計上切出伺服切口（矩形）。可能需要花一些時間才能完全了解此框：
清除切孔中的殘留紙板。將伺服器朝外的方向貼在矩形孔中：
最后，您將需要一個定點設備。我們使用一次性便箋簿的內部，因為它們很便宜，很多人都把它們放在身邊：
干得好！關閉框并準備編程：
代碼
此代碼是 CIRC04：伺服和 CIRC10：溫度之間的混合代碼。我們正在做的是將溫度值附加到伺服值上。讓我們看一下其中的一些部分：
在內部，我們將使用CIRC04的getVoltage（）函數從引腳讀取電壓。然后，我們將這個值傳遞給新函數convertToF（），該函數根據電壓值生成，以將電壓轉換為華氏溫度：
下載：文件
復制代碼
// read the voltage from the pin
float voltage = getVoltage（temperaturePin）;
// convert the voltage to a temperature value
float temperature = convertToF（voltage）; // read the voltage from the pin
float voltage = getVoltage（temperaturePin）;
// convert the voltage to a temperature value
float temperature = convertToF（voltage）;
然后，我們要約束溫度值。這完全取決于您，您可以使用任何數字，但是我們使用-10F和100F作為TMP36接受的最低和最高溫度：
map（（int（temperature））， -10， 100
我們仍然需要將溫度值映射到伺服值。伺服器可以移動的最小度數為 0度，最大度數為 180 ，因此我們將伺服器設置為映射：-10到0和100到180：
下載：文件
復制代碼
servoPos = map（（int（temperature））， -10， 100， 0， 180）; servoPos = map（（int（temperature））， -10， 100， 0， 180）;
然后，將servoPos寫入伺服器！
下載：文件
復制代碼
// write servoPos to the servo
metroServo.write（servoPos）;
// poll every 0.5sec
delay（500）; // write servoPos to the servo
metroServo.write（servoPos）;
// poll every 0.5sec
delay（500）;
以下是完整的代碼，其中包括內置的輔助程序：
代碼
下載：Project Zip 或 PROJ07_RGB_MIXER.ino | span》 在Github上查看
復制代碼
/*
* PROJ07 - RGB Color Mixer
*
* by Brent Rubell for Adafruit Industries
*/
// RGB LED Pins
int rgbLED［］ = {9， 10， 11};
// trim potentiometer pin
int trimPin = A0;
// button pin
const int buttonPin = 12;
// button state
int buttonState = 0;
// trim pot. value
int trimValue = 0;
int colorIdx = 0;
int red = 0;
int green = 0;
int blue = 0;
boolean CURRENTRGB［］ = {0， 0， 0};
void setup（） {
// Setup Serial
Serial.begin（9600）;
// set the 3 pins as output pins
for（int i = 0; i 《 3; i++） {
pinMode（rgbLED［i］， OUTPUT）;
}
// initialize the push-button as an input
pinMode（buttonPin， INPUT）;
}
void loop（） {
// read the value of the push-button
buttonState = digitalRead（buttonPin）;
if（buttonState == LOW） {
delay（2）;
// reset the colorIdx if it goes past Blue （colorIdx = 3）
if（colorIdx == 3） {
colorIdx = 0;
}
colorIdx++;
switch（colorIdx） {
case 1：
trimValue = analogRead（trimPin）;
red = map（trimValue， 0， 670， 0， 255）;
CURRENTRGB［0］ = red;
break;
case 2：
trimValue = analogRead（trimPin）;
green = map（trimValue， 0， 670， 0， 255）;
CURRENTRGB［1］ = green;
break;
case 3：
trimValue = analogRead（trimPin）;
blue = map（trimValue， 0， 670， 0， 255）;
CURRENTRGB［2］ = blue;
break;
default：
break;
}
Serial.println（“red：”）;
Serial.print（CURRENTRGB［0］）;
Serial.println（“ ”）;
Serial.println（“green：”）;
Serial.print（CURRENTRGB［1］）;
Serial.println（“ ”）;
Serial.println（“blue：”）;
Serial.print（CURRENTRGB［2］）;
Serial.println（“ ”）;
setColor（rgbLED， CURRENTRGB）;
delay（1000）;
}
}
void setColor（int* led， const boolean* color） {
for（int i = 0; i 《 3; i++）{
digitalWrite（led［i］， color［i］）;
}
}
/*
* PROJ07 - RGB Color Mixer
*
* by Brent Rubell for Adafruit Industries
*/
// RGB LED Pins
int rgbLED［］ = {9， 10， 11};
// trim potentiometer pin
int trimPin = A0;
// button pin
const int buttonPin = 12;
// button state
int buttonState = 0;
// trim pot. value
int trimValue = 0;
int colorIdx = 0;
int red = 0;
int green = 0;
int blue = 0;
boolean CURRENTRGB［］ = {0， 0， 0};
void setup（） {
// Setup Serial
Serial.begin（9600）;
// set the 3 pins as output pins
for（int i = 0; i 《 3; i++） {
pinMode（rgbLED［i］， OUTPUT）;
}
// initialize the push-button as an input
pinMode（buttonPin， INPUT）;
}
void loop（） {
// read the value of the push-button
buttonState = digitalRead（buttonPin）;
if（buttonState == LOW） {
delay（2）;
// reset the colorIdx if it goes past Blue （colorIdx = 3）
if（colorIdx == 3） {
colorIdx = 0;
}
colorIdx++;
switch（colorIdx） {
case 1：
trimValue = analogRead（trimPin）;
red = map（trimValue， 0， 670， 0， 255）;
CURRENTRGB［0］ = red;
break;
case 2：
trimValue = analogRead（trimPin）;
green = map（trimValue， 0， 670， 0， 255）;
CURRENTRGB［1］ = green;
break;
case 3：
trimValue = analogRead（trimPin）;
blue = map（trimValue， 0， 670， 0， 255）;
CURRENTRGB［2］ = blue;
break;
default：
break;
}
Serial.println（“red：”）;
Serial.print（CURRENTRGB［0］）;
Serial.println（“ ”）;
Serial.println（“green：”）;
Serial.print（CURRENTRGB［1］）;
Serial.println（“ ”）;
Serial.println（“blue：”）;
Serial.print（CURRENTRGB［2］）;
Serial.println（“ ”）;
setColor（rgbLED， CURRENTRGB）;
delay（1000）;
}
}
void setColor（int* led， const boolean* color） {
for（int i = 0; i 《 3; i++）{
digitalWrite（led［i］， color［i］）;
}
}
責任編輯：wv
-
Arduino
+關注
關注
187文章
6464瀏覽量
186681
發布評論請先 登錄
相關推薦
樹莓派與Arduino的區別是什么
PyTorch深度學習開發環境搭建指南
集成電路學習指南：科目選擇與未來發展全景解讀
芯片封裝工程師必備知識和學習指南
如何將按鈕連接到Arduino板
如何使用Arduino控制RGB LED
如何連接Arduino聲音傳感器以控制帶有聲音的LED
如何設置Arduino霍爾效應傳感器
如何使用Arduino UNO板和電位器控制伺服電機
如何使用Arduino UNO和TIP120晶體管驅動和控制直流電機的速度
如何設置Arduino IR發射器電路
工商網監
評論