arduino基礎25個實驗代碼

雙色LED燈項目源碼

int redPin = 11;      // 紅色LED引腳
int greenPin = 10;    // 綠色LED引腳
int val = 0;          // PWM輸出值
void setup() {
  pinMode(redPin, OUTPUT);    // 將紅色LED引腳設置為輸出模式
  pinMode(greenPin, OUTPUT);  // 將綠色LED引腳設置為輸出模式
  Serial.begin(9600);         // 初始化串口通信，波特率為9600
}
void loop() {
  for (val = 255; val > 0; val--) {         // 從255遞減到1，調整PWM輸出值
    analogWrite(redPin, val);               // 設置紅色LED的亮度（占空比）
    analogWrite(greenPin, 255 - val);       // 設置綠色LED的亮度（占空比）
    Serial.println(val, DEC);               // 在串口上打印當前PWM輸出值（10進制）
    delay(30);                              // 延遲30毫秒
  }
  for (val = 0; val < 255; val++) {         // 從0遞增到254，調整PWM輸出值
    analogWrite(redPin, val);               // 設置紅色LED的亮度（占空比）
    analogWrite(greenPin, 255 - val);       // 設置綠色LED的亮度（占空比）
    Serial.println(val, DEC);               // 在串口上打印當前PWM輸出值（10進制）
    delay(30);                              // 延遲30毫秒
  }
}

/*這段代碼使用了Arduino的analogWrite函數來控制兩個LED的亮度。首先，通過循環遞減PWM輸出值，使紅色LED從高亮變暗，綠色LED從暗到高亮。然后，通過循環遞增PWM輸出值，使紅色LED從暗到高亮，綠色LED從高亮變暗。每次調整亮度后，程序會在串口上打印出當前的PWM輸出值。每次亮度調整后都會延遲30毫秒，以便能夠觀察到亮度的變化。*/

RGB-LED項目源碼

const int redPin = 11;    // 紅色LED引腳
const int greenPin = 10;  // 綠色LED引腳
const int bluePin = 9;    // 藍色LED引腳
void setup() {
  pinMode(redPin, OUTPUT);    // 將紅色LED引腳設置為輸出模式
  pinMode(greenPin, OUTPUT);  // 將綠色LED引腳設置為輸出模式
  pinMode(bluePin, OUTPUT);   // 將藍色LED引腳設置為輸出模式
}
void loop() {
  color(0, 255, 255);   // 設置顏色為青色（紅色亮度為0，綠色亮度為255，藍色亮度為255）
  delay(1000);          // 延遲1秒
  color(255, 0, 255);   // 設置顏色為洋紅色（紅色亮度為255，綠色亮度為0，藍色亮度為255）
  delay(1000);          // 延遲1秒
  color(255, 255, 0);   // 設置顏色為黃色（紅色亮度為255，綠色亮度為255，藍色亮度為0）
  delay(1000);          // 延遲1秒
  color(0, 255, 255);   // 設置顏色為青色
  delay(1000);          // 延遲1秒
  color(0, 128, 255);   // 設置顏色為天藍色（紅色亮度為0，綠色亮度為128，藍色亮度為255）
  delay(1000);          // 延遲1秒
  color(0, 0, 255);     // 設置顏色為藍色（紅色亮度為0，綠色亮度為0，藍色亮度為255）
  delay(1000);          // 延遲1秒
  color(255, 0, 255);   // 設置顏色為洋紅色
  delay(1000);          // 延遲1秒
  color(255, 255, 0);   // 設置顏色為黃色
  delay(1000);          // 延遲1秒
  color(255, 0, 0);     // 設置顏色為紅色（紅色亮度為255，綠色亮度為0，藍色亮度為0）
  delay(1000);          // 延遲1秒
  color(128, 255, 0);   // 設置顏色為淺綠色（紅色亮度為128，綠色亮度為255，藍色亮度為0）
  delay(1000);          // 延遲1秒
}
void color(unsigned char red, unsigned char green, unsigned char blue) {
  analogWrite(redPin, red);       // 設置紅色LED的亮度（占空比）
  analogWrite(greenPin, green);   // 設置綠色LED的亮度（占空比）
  analogWrite(bluePin, blue);     // 設置藍色LED的亮度（占空比）
}

/*該代碼使用了三個PWM引腳來控制RGB LED的顏色。color函數用來設置各個顏色通道的亮度（占空比），然后通過調用analogWrite函數來輸出相應的PWM信號，從而實現顏色的變化。在loop函數中，按照預定的順序依次設置不同的顏色，并且每次顏色變化后延遲1秒，以觀察顏色的變化效果。*/

繼電器項目源碼

const int relayPin = 7;
void setup() {
  pinMode(relayPin,OUTPUT);
 }
 void loop() {
   digitalWrite(relayPin,HIGH);
   delay(1000);
   digitalWrite(relayPin,LOW);
   delay(1000);
 }

激光項目實驗

// 定義字母的摩爾斯編碼
char* letters[] = {
  ".-",    // A
  "-...",  // B
  "-.-.",  // C
  "-..",   // D
  ".",     // E
  "..-.",  // F
  "--.",   // G
  "....",  // H
  "..",    // I
  ".---",  // J
  "-.-",   // K
  ".-..",  // L
  "--",    // M
  "-.",    // N
  "---",   // O
  ".--.",  // P
  "--.-",  // Q
  ".-.",   // R
  "...",   // S
  "-",     // T
  "..-",   // U
  "...-",  // V
  ".--",   // W
  "-..-",  // X
  "-.--",  // Y
  "--.."   // Z
};
// 定義數字的摩爾斯編碼
char* numbers[] = {
  "-----",  // 0
  ".----",  // 1
  "..---",  // 2
  "...--",  // 3
  "....-",  // 4
  ".....",  // 5
  "-....",  // 6
  "--...",  // 7
  "---..",  // 8
  "----."   // 9
};
const int laserPin = 7;  // 激光器引腳
static int dotDelay = 200;  // 點的延遲時間
void setup()
{
  pinMode(laserPin, OUTPUT);
  Serial.begin(9600);
}
void loop()
{
  char ch = 0;
  if (Serial.available() > 0)
  {
    ch = Serial.read();
  }
  morseSignal(ch);  // 發送摩爾斯信號
}
// 發送一個點或者一個劃
void flashDot(char cha)
{
  digitalWrite(laserPin, HIGH);  // 激光器打開
  if (cha == '.')  // 如果是點，則延遲dotDelay毫秒
  {
    delay(dotDelay);
  }
  else  // 否則為劃，則延遲3倍的dotDelay毫秒
  {
    delay(dotDelay * 3);
  }
  digitalWrite(laserPin, LOW);  // 激光器關閉
  delay(dotDelay);  // 延遲dotDelay毫秒
}
// 發送一個序列
void flashSequence(const char *sequence)
{
  int i = 0;
  while (sequence[i] != '\0')  // 遍歷序列直到字符串的結尾
  {
    flashDot(sequence[i]);  // 發送每個字符
    i++;
  }
  delay(dotDelay * 3);  // 延遲3倍的dotDelay毫秒，作為字符之間的間隔
}
// 發送摩爾斯信號
void morseSignal(char ch)
{
  if (ch >= 'a' && ch <= 'z')  // 如果是小寫字母
  {
    flashSequence(letters[ch - 'a']);  // 發送對應字母的摩爾斯編碼
  }
  else if (ch >= 'A' && ch <= 'Z')  // 如果是大寫字母
  {
    flashSequence(letters[ch - 'A']);  // 發送對應字母的摩爾斯編碼
  }
  else if (ch >= '0' && ch <= '9')  // 如果是數字
  {
    flashSequence(numbers[ch - '0']);  // 發送對應數字的摩爾斯編碼
  }
  else if (ch == ' ')  // 如果是空格
  {
    delay(dotDelay * 4);  // 延遲4倍的dotDelay毫秒，作為空格的間隔
  }
}

/*這段代碼使用一個激光器LED來發送摩爾斯信號。通過串口接收輸入的字符，并根據字符來發送對應的摩爾斯編碼。摩爾斯編碼存儲在數組中，大寫字母'A'到'Z'、小寫字母'a'到'z'以及數字'0'到'9'都有對應的摩爾斯編碼。使用flashDot函數發送一個點（.）或一個劃（-），使用flashSequence函數發送一個摩爾斯編碼序列。morseSignal函數根據輸入的字符調用適當的函數來發送摩爾斯信號。*/

輕觸項目源碼

const int keyPin = 7;   // 按鍵輸入引腳
const int ledPin = 13;  // LED輸出引腳
void setup() {
  pinMode(keyPin, INPUT);   // 設置按鍵引腳為輸入模式
  pinMode(ledPin, OUTPUT);  // 設置LED引腳為輸出模式
}
void loop() {
  boolean Value = digitalRead(keyPin);  // 讀取按鍵引腳的值，將結果保存在Value變量中
  if (Value == HIGH) {  // 如果按鍵引腳的值為高電平（按下狀態）
    digitalWrite(ledPin, LOW);  // 將LED引腳設置為低電平（滅）
  } else {  // 否則（未按下狀態）
    digitalWrite(ledPin, HIGH);  // 將LED引腳設置為高電平（亮）
  }
}

/*這段代碼使用了一個按鍵和一個LED。按鍵連接到keyPin引腳，LED連接到ledPin引腳。在setup()函數中，將keyPin設置為輸入模式，ledPin設置為輸出模式。在loop()函數中，通過digitalRead()函數讀取keyPin引腳的狀態，并將結果保存在Value變量中。如果Value等于HIGH，表示按鍵被按下，此時將ledPin引腳設置為低電平（LED熄滅）。否則，如果Value不等于HIGH，表示按鍵未被按下，此時將ledPin引腳設置為高電平（LED點亮）*/

傾斜開關項目源碼

const int sigPin = 7;   // 信號輸入引腳
const int ledPin = 13;  // LED輸出引腳
boolean sigState = 0;   // 信號狀態變量，初始值為低電平
void setup()
{
  pinMode(ledPin, OUTPUT);  // 設置LED引腳為輸出模式
  pinMode(sigPin, INPUT);   // 設置信號引腳為輸入模式
  Serial.begin(9600);       // 初始化串口通信，波特率為9600
}
void loop()
{
  sigState = digitalRead(sigPin);  // 讀取信號引腳的值，將結果保存在sigState變量中
  Serial.println(sigState);        // 將信號狀態打印到串口監視器
  if (sigState == HIGH)  // 如果信號引腳的值為高電平（信號輸入）
  {
    digitalWrite(ledPin, LOW);  // 將LED引腳設置為低電平（LED熄滅）
  }
  else  // 否則，信號引腳的值為低電平（信號未輸入）
  {
    digitalWrite(ledPin, HIGH);  // 將LED引腳設置為高電平（LED點亮）
  }
}


/*這段代碼使用了一個信號輸入引腳和一個LED輸出引腳。信號輸入引腳連接到sigPin引腳，LED輸出引腳連接到ledPin引腳。在setup()函數中，將ledPin設置為輸出模式，sigPin設置為輸入模式。同時初始化串口通信，并設置波特率為9600。在loop()函數中，通過digitalRead()函數讀取sigPin引腳的狀態，并將結果保存在sigState變量中。然后，通過Serial.println()函數將sigState的值打印到串口監視器中。根據sigState的值，如果為HIGH，表示信號輸入，將ledPin引腳設置為低電平（LED熄滅）；否則，如果sigState不為HIGH，表示信號未輸入，將ledPin引腳設置為高電平（LED點亮）。*/

振動開關項目源碼

const int vibswPin = 8;   // 震動開關輸入引腳
const int ledPin = 13;    // LED輸出引腳
int val = 0;              // 震動開關狀態變量，初始值為低電平
void setup()
{
  pinMode(vibswPin, INPUT);   // 設置震動開關引腳為輸入模式
  pinMode(ledPin, OUTPUT);    // 設置LED引腳為輸出模式
  //Serial.begin(9600);       // 初始化串口通信，波特率為9600
}
void loop()
{
  val = digitalRead(vibswPin);  // 讀取震動開關引腳的值，將結果保存在val變量中
  //Serial.println(val);        // 將震動開關狀態打印到串口監視器
  if (val == LOW)  // 如果震動開關引腳的值為低電平（檢測到震動）
  {
    digitalWrite(ledPin, HIGH);  // 將LED引腳設置為高電平（LED點亮）
    delay(500);                  // 延時500毫秒
  }
  else  // 否則，震動開關引腳的值為高電平（未檢測到震動）
  {
    digitalWrite(ledPin, LOW);  // 將LED引腳設置為低電平（LED熄滅）
  }
}

/*這段代碼使用了一個震動開關輸入引腳和一個LED輸出引腳。震動開關輸入引腳連接到vibswPin引腳，LED輸出引腳連接到ledPin引腳。在setup()函數中，將vibswPin設置為輸入模式，將ledPin設置為輸出模式。在loop()函數中，通過digitalRead()函數讀取vibswPin引腳的狀態，并將結果保存在val變量中。然后，根據val的值判斷當前震動開關的狀態，如果為LOW，表示檢測到震動，將ledPin引腳設置為高電平（LED點亮），并延時500毫秒；否則，如果val不為LOW，表示未檢測到震動，將ledPin引腳設置為低電平（LED熄滅）。*/

紅外遙控項目源碼

#include <IRremote.h>  // 引入紅外庫
const int irReceiverPin = 7;    // 紅外接收器引腳
const int ledPin = 13;          // LED輸出引腳
IRrecv irrecv(irReceiverPin);   // 創建紅外接收器實例
decode_results results;         // 存儲解碼結果的變量
void setup()
{
  pinMode(ledPin, OUTPUT);      // 設置LED引腳為輸出模式
  Serial.begin(9600);           // 初始化串口通信，波特率為9600
  irrecv.enableIRIn();          // 啟用紅外接收器
}
void loop()
{
  if (irrecv.decode(&results))  // 如果成功接收到紅外信號并解碼
  { 
    Serial.print("irCode: ");  // 打印提示信息
    Serial.print(results.value, HEX);  // 打印解碼得到的紅外碼值
    Serial.print(", bits: ");  // 打印解碼得到的位數
    Serial.println(results.bits);  
    irrecv.resume();            // 繼續等待下一個紅外信號
  }
  delay(600);                   // 延遲600毫秒
  if (results.value == 0xFFA25D)  // 如果解碼得到的紅外碼值為0xFFA25D
  {
    digitalWrite(ledPin, HIGH);  // 將LED引腳設置為高電平（LED點亮）
  }
  else
  {
    digitalWrite(ledPin, LOW);   // 將LED引腳設置為低電平（LED熄滅）
  }
}

/*這段代碼使用了一個紅外接收器引腳和一個LED輸出引腳。紅外接收器的引腳連接到irReceiverPin引腳，LED輸出引腳連接到ledPin引腳。在setup()函數中，將ledPin設置為輸出模式，初始化串口通信，并啟用紅外接收器。在loop()函數中，首先判斷是否成功接收到紅外信號并解碼，如果是，則打印解碼得到的紅外碼值和位數，然后通過irrecv.resume()繼續等待下一個紅外信號。接著延時600毫秒，然后根據解碼得到的紅外碼值判斷是否與預設的值相等，如果相等，則將ledPin引腳設置為高電平（LED點亮），否則將其設置為低電平（LED熄滅）。*/

蜂鳴器項目源碼

const int buzzerPin = 7;  // 蜂鳴器引腳
int fre;                  // 頻率變量
void setup()
{
  pinMode(buzzerPin, OUTPUT);  // 設置蜂鳴器引腳為輸出模式
}
void loop()
{
  for(int i = 200; i <= 800; i++)  // 遞增循環，從200到800
  {
    tone(buzzerPin, i);  // 在蜂鳴器引腳上產生頻率為i的音調
    delay(5);           // 延遲5毫秒
  }
  
  delay(4000);  // 延遲4000毫秒
  
  for(int i = 800; i >= 200; i--)  // 遞減循環，從800到200
  {
    tone(buzzerPin, i);  // 在蜂鳴器引腳上產生頻率為i的音調
    delay(10);          // 延遲10毫秒
  }
}

/*這段代碼使用了一個蜂鳴器引腳。蜂鳴器的引腳連接到buzzerPin引腳。在setup()函數中，將buzzerPin設置為輸出模式。在loop()函數中，首先使用一個循環從200遞增到800，在每次循環中，通過tone()函數在蜂鳴器引腳上產生頻率為i的音調，并延遲5毫秒。接著延遲4000毫秒，然后使用另一個循環從800遞減到200，在每次循環中，同樣通過tone()函數在蜂鳴器引腳上產生頻率為i的音調，并延遲10毫秒。這樣就形成了一個簡單的音效循環：從低音到高音再到低音。*/

干簧管傳感器項目源碼

const int digitalInPin = 7;  // 數字輸入引腳
const int ledPin = 13;       // LED輸出引腳
void setup()
{
  pinMode(digitalInPin, INPUT);   // 設置數字輸入引腳為輸入模式
  pinMode(ledPin, OUTPUT);        // 設置LED輸出引腳為輸出模式
}
void loop()
{
  boolean stat = digitalRead(digitalInPin);  // 讀取數字輸入引腳的狀態，并將結果存儲在stat變量中
  
  if(stat == HIGH)  // 如果狀態為高電平（輸入信號為高）
  {
    digitalWrite(ledPin, LOW);  // 將LED引腳設置為低電平（熄滅LED）
  }
  else  // 如果狀態為低電平（輸入信號為低）
  {
    digitalWrite(ledPin, HIGH);  // 將LED引腳設置為高電平（點亮LED）
  }
}

/*這段代碼使用了一個數字輸入引腳和一個LED輸出引腳。數字輸入引腳的引腳連接到digitalInPin引腳，LED輸出引腳連接到ledPin引腳。在setup()函數中，將digitalInPin設置為輸入模式，將ledPin設置為輸出模式。在loop()函數中，首先通過digitalRead()函數讀取數字輸入引腳的狀態，并將結果存儲在stat變量中。然后判斷stat變量的值，如果為高電平（輸入信號為高），則將LED引腳設置為低電平（熄滅LED）。如果為低電平（輸入信號為低），則將LED引腳設置為高電平（點亮LED）。這樣就實現了根據數字輸入引腳狀態控制LED引腳的電平，從而控制LED的點亮和熄滅。*/

U型光電傳感器項目源碼

const int sensorPin = 7;   // U型光電傳感器的引腳
const int ledPin = 13;     // LED的引腳
void setup()
{
  pinMode(sensorPin, INPUT);    // 設置U型光電傳感器引腳為輸入模式
  pinMode(ledPin, OUTPUT);      // 設置LED引腳為輸出模式
}
void loop()
{
  int sensorValue = digitalRead(sensorPin);   // 讀取U型光電傳感器引腳的狀態，并將結果存儲在sensorValue變量中
  
  if (sensorValue == HIGH)    // 如果sensorValue為高電平（有物體被檢測到）
  {
    digitalWrite(ledPin, HIGH);   // 將LED引腳設置為高電平（點亮LED）
  }
  else    // 如果sensorValue為低電平（沒有物體被檢測到）
  {
    digitalWrite(ledPin, LOW);    // 將LED引腳設置為低電平（熄滅LED）
  }
}

/*這段代碼使用了一個U型光電傳感器引腳和一個LED引腳。U型光電傳感器引腳連接到sensorPin引腳，LED引腳連接到ledPin引腳。在setup()函數中，將sensorPin設置為輸入模式，將ledPin設置為輸出模式。在loop()函數中，首先通過digitalRead()函數讀取U型光電傳感器引腳的狀態，并將結果存儲在sensorValue變量中。然后判斷sensorValue變量的值，如果為高電平（有物體被檢測到），則將LED引腳設置為高電平（點亮LED）。如果為低電平（沒有物體被檢測到），則將LED引腳設置為低電平（熄滅LED）。這樣就實現了根據U型光電傳感器的狀態控制LED引腳的電平，從而控制LED的點亮和熄滅。*/

雨滴探測傳感器項目源碼

const int sensorPin = A0;   // 雨滴傳感器的模擬引腳連接到A0
const int ledPin = 13;     // LED的引腳連接到數字引腳13
int sensorValue = 0;       // 存儲傳感器讀數
void setup()
{
  pinMode(ledPin, OUTPUT);   // 將LED引腳設置為輸出模式
  Serial.begin(9600);        // 初始化串口通信，波特率為9600
}
void loop()
{
  sensorValue = analogRead(sensorPin);    // 讀取傳感器的模擬值
  Serial.print("Sensor Value: ");
  Serial.println(sensorValue);             // 打印傳感器讀數到串口
  
  if (sensorValue < 500)    // 如果傳感器讀數小于500（表示檢測到水滴）
  {
    digitalWrite(ledPin, HIGH);    // 將LED引腳設置為高電平（點亮LED）
  }
  else      // 如果傳感器讀數大于等于500（表示未檢測到水滴）
  {
    digitalWrite(ledPin, LOW);    // 將LED引腳設置為低電平（熄滅LED）
  }
  delay(100);   // 稍微延遲一段時間，避免頻繁讀取傳感器數據
}
/*這段代碼使用了一個雨滴傳感器的模擬引腳A0和一個LED的數字引腳13。在setup()函數中，將ledPin設置為輸出模式，并且初始化串口通信，波特率為9600。在loop()函數中，首先通過analogRead()函數讀取傳感器模擬引腳的值，并將結果存儲在sensorValue變量中。然后通過Serial.print()和Serial.println()函數將sensorValue的值打印到串口上。接下來，根據sensorValue的值判斷是否點亮LED。如果sensorValue小于500（表示檢測到水滴），則將ledPin引腳設置為高電平（點亮LED）。如果sensorValue大于等于500（表示未檢測到水滴），則將ledPin引腳設置為低電平（熄滅LED）。最后，通過delay()函數稍微延遲一段時間，避免頻繁讀取傳感器數據。*/

PS2操縱桿項目源碼

const int xPin = A0;   // X軸模擬引腳連接到A0
const int yPin = A1;   // Y軸模擬引腳連接到A1
const int btPin = 7;   // 按鈕引腳連接到數字引腳7
void setup()
{
  pinMode(btPin, INPUT);         // 將按鈕引腳設置為輸入模式
  digitalWrite(btPin, HIGH);    // 上拉按鈕引腳
  Serial.begin(9600);            // 初始化串口通信，波特率為9600
}
void loop()
{
  Serial.print("X: ");
  Serial.print(analogRead(xPin), DEC);      // 讀取X軸模擬引腳的值，并打印到串口
  Serial.print("\tY: ");
  Serial.print(analogRead(yPin), DEC);      // 讀取Y軸模擬引腳的值，并打印到串口
  Serial.print("\tZ:");
  Serial.println(digitalRead(btPin));       // 讀取按鈕引腳的狀態（高電平或低電平），并打印到串口
  delay(100);                              // 稍微延遲一段時間，避免頻繁讀取傳感器數據
}
/*這段代碼使用了兩個模擬引腳A0和A1，以及一個數字引腳7。在setup()函數中，將按鈕引腳設置為輸入模式，并且上拉按鈕引腳。然后初始化串口通信，波特率為9600。在loop()函數中，首先通過analogRead()函數讀取X軸模擬引腳的值，并使用Serial.print()函數將其打印到串口上。接著通過相同的方式讀取Y軸模擬引腳的值和按鈕引腳的狀態，并將它們打印到串口上。最后，通過delay()函數稍微延遲一段時間，以避免頻繁讀取傳感器數據。*/

電位器傳感器項目源碼

const int analogPin = A0;   // 模擬輸入引腳連接到A0
const int ledPin = 13;     // LED引腳連接到數字引腳13
int inputValue = 0;
void setup()
{
  pinMode(ledPin, OUTPUT);    // 將LED引腳設置為輸出模式
  Serial.begin(9600);        // 初始化串口通信，波特率為9600
}
void loop()
{
  inputValue = analogRead(analogPin);    // 讀取模擬輸入引腳的值并存儲在inputValue變量中
  digitalWrite(ledPin, HIGH);    // 將LED引腳設置為高電平（點亮LED）
  delay(inputValue);    // 延遲inputValue毫秒
  digitalWrite(ledPin, LOW);    // 將LED引腳設置為低電平（熄滅LED）
  delay(inputValue);    // 延遲inputValue毫秒
}

/*這段代碼使用了一個模擬輸入引腳A0和一個LED的數字引腳13。在setup()函數中，將ledPin設置為輸出模式，并且初始化串口通信，波特率為9600。在loop()函數中，首先通過analogRead()函數讀取模擬輸入引腳的值，并將結果存儲在inputValue變量中。然后，將ledPin引腳設置為高電平（點亮LED）。接著，通過delay()函數延遲inputValue毫秒。然后，將ledPin引腳設置為低電平（熄滅LED）。再次通過delay()函數延遲inputValue毫秒。最后，循環執行這個過程。*/

模擬霍爾傳感器項目

const int ledPin = 13;    // LED引腳連接到數字引腳13
int sensorPin = A0;    // 模擬輸入引腳連接到A0
int digitalPin = 7;    // 模擬霍爾傳感器引腳連接到數字引腳7
int sensorValue = 0;    // 存儲模擬輸入引腳的值
boolean digitalValue = 0;    // 存儲模擬霍爾傳感器引腳的狀態
void setup()
{
  pinMode(digitalPin, INPUT);    // 將模擬霍爾傳感器引腳設置為輸入模式
  pinMode(ledPin, OUTPUT);    // 將LED引腳設置為輸出模式
  Serial.begin(9600);    // 初始化串口通信，波特率為9600
}
void loop()
{
  sensorValue = analogRead(sensorPin);    // 讀取模擬輸入引腳的值并存儲在sensorValue變量中
  digitalValue = digitalRead(digitalPin);    // 讀取模擬霍爾傳感器引腳的狀態（高電平或低電平）并存儲在digitalValue變量中
  Serial.print("Sensor Value: "); 
  Serial.println(sensorValue);    // 打印模擬輸入引腳的值到串口
  Serial.print("Digital Value: "); 
  Serial.println(digitalValue);    // 打印模擬霍爾傳感器引腳的狀態到串口
  
  if (digitalValue == HIGH)
  {
    digitalWrite(ledPin, LOW);    // 如果模擬霍爾傳感器引腳為高電平，則將LED引腳設置為低電平（熄滅LED）
  }
  
  if (digitalValue == LOW)
  {
    digitalWrite(ledPin, HIGH);    // 如果模擬霍爾傳感器引腳為低電平，則將LED引腳設置為高電平（點亮LED）
  }
  
  delay(1000);    // 延遲1秒
}
/*這段代碼使用了一個LED的數字引腳13，一個模擬輸入引腳A0和一個按鈕的數字引腳7。在setup()函數中，將按鈕引腳設置為輸入模式，將LED引腳設置為輸出模式，并初始化串口通信，波特率為9600。在loop()函數中，首先通過analogRead()函數讀取模擬輸入引腳的值，并將結果存儲在sensorValue變量中。然后，通過digitalRead()函數讀取按鈕引腳的狀態，并將結果存儲在digitalValue變量中。接著，使用Serial.print()和Serial.println()函數將sensorValue和digitalValue打印到串口上。然后，根據digitalValue的值判斷按鈕引腳的狀態，如果是高電平，則將LED引腳設置為低電平，否則將LED引腳設置為高電平。最后，通過delay()函數延遲1秒。循環執行這個過程。*/

模擬溫度傳感器

const int digitalPin = 7;    // 數字引腳7連接到模塊的數字輸入引腳
int analogPin = A0;    // 模擬輸入引腳連接到A0
const int ledPin = 13;    // LED引腳連接到數字引腳13
boolean Dstate = 0;    // 存儲模塊的數字輸入引腳狀態
int Astate = 0;    // 存儲模擬輸入引腳的值
void setup()
{
  pinMode(ledPin,OUTPUT);    // 將LED引腳設置為輸出模式
  pinMode(digitalPin, INPUT);    // 將模塊的數字輸入引腳設置為輸入模式
  Serial.begin(9600);    // 初始化串口通信，波特率為9600
}
void loop()
{
  Astate = analogRead(analogPin);    // 讀取模擬輸入引腳的值并存儲在Astate變量中
  Dstate = digitalRead(digitalPin);    // 讀取模塊的數字輸入引腳狀態（高電平或低電平）并存儲在Dstate變量中
  Serial.print("D0:");
  Serial.println(Dstate);    // 打印模塊的數字輸入引腳狀態到串口
  Serial.print("A0:");
  Serial.println(Astate);    // 打印模擬輸入引腳的值到串口
  
  if (Dstate == HIGH)
  {
    // 點亮LED
    digitalWrite(ledPin,LOW);
  }
  else{
    // 熄滅LED
    digitalWrite(ledPin,HIGH);
  }
  delay(1000);    // 延遲1秒
}

/*段代碼通過讀取模擬輸入引腳A0的數值來獲取模擬輸入的值，并通過讀取模塊的數字輸入引腳7的狀態來獲取模塊的狀態。根據模塊狀態的不同，代碼會控制LED引腳的狀態以點亮或熄滅LED。最后，通過delay()函數實現了1秒的延遲。*/

聲音傳感器實驗

const int ledPin = 13;    // LED引腳連接到數字引腳13
const int soundPin = A0;    // 聲音傳感器引腳連接到模擬引腳A0
void setup()
{
  pinMode(ledPin, OUTPUT);    // 將LED引腳設置為輸出模式
  Serial.begin(9600);    // 初始化串口通信，波特率為9600
}
void loop()
{
  int value = analogRead(soundPin);    // 讀取聲音傳感器輸入引腳的值并存儲在value變量中
  Serial.println(value);    // 打印聲音傳感器值到串口
  
  if (value > 600)
  {
    digitalWrite(ledPin, HIGH);    // 點亮LED
    delay(200);    // 延遲200毫秒
  }
  else
  {
    digitalWrite(ledPin, LOW);    // 熄滅LED
  }
}
/*這段代碼通過讀取聲音傳感器引腳A0的數值來獲取聲音傳感器的數值，如果數值大于600，則點亮LED引腳；否則，熄滅LED引腳。最后，通過delay()函數實現了200毫秒的延遲。*/

光敏傳感器

const int photocellPin = A0;    // 光敏電阻引腳連接到模擬引腳A0
const int ledPin = 13;    // LED引腳連接到數字引腳13
const int relayPin = 8;    // 繼電器引腳連接到數字引腳8
int outputValue = 0;    // 存儲光敏電阻引腳的值
void setup()
{
  pinMode(relayPin, OUTPUT);    // 將繼電器引腳設置為輸出模式
  pinMode(ledPin, OUTPUT);    // 將LED引腳設置為輸出模式
  Serial.begin(9600);    // 初始化串口通信，波特率為9600
}
void loop()
{
  outputValue = analogRead(photocellPin);    // 讀取光敏電阻引腳的值并存儲在outputValue變量中
  Serial.println(outputValue);    // 打印光敏電阻值到串口
  
  if (outputValue >= 400)
  {
    digitalWrite(ledPin, HIGH);    // 點亮LED
    digitalWrite(relayPin, LOW);    // 繼電器導通
  }
  else
  {
    digitalWrite(ledPin, LOW);    // 熄滅LED
    digitalWrite(relayPin, HIGH);    // 繼電器斷開導通
  }
  delay(1000);    // 延遲1秒
}

/*這段代碼通過讀取光敏電阻引腳A0的數值來獲取光敏電阻的數值。如果數值大于等于400，則點亮LED引腳并導通繼電器引腳；否則，熄滅LED引腳并斷開繼電器引腳的導通。最后，通過delay()函數實現了1秒的延遲。*/

火焰傳感器

const int digitalInPin = 8;    // 數字輸入引腳連接到數字引腳8
const int ledPin = 13;    // LED引腳連接到數字引腳13
const int buzzerPin = 7;    // 蜂鳴器引腳連接到數字引腳7
void setup()
{
  pinMode(digitalInPin, INPUT);    // 將數字輸入引腳設置為輸入模式
  pinMode(ledPin, OUTPUT);    // 將LED引腳設置為輸出模式
  pinMode(buzzerPin, OUTPUT);    // 將蜂鳴器引腳設置為輸出模式
  Serial.begin(9600);    // 初始化串口通信，波特率為9600
}
void loop()
{
  boolean stat = digitalRead(digitalInPin);    // 讀取數字輸入引腳的狀態并存儲在stat變量中
  Serial.print("DO:");    // 打印"DO:"
  Serial.println(stat);    // 打印數字輸入引腳的狀態到串口
  Serial.println("");    // 打印一個空行
  
  if (stat == HIGH)
  {
    digitalWrite(ledPin, LOW);    // 熄滅LED
    noTone(buzzerPin);    // 停止蜂鳴器聲音
  }
  
  if (stat == LOW)
  {
    digitalWrite(ledPin, HIGH);    // 點亮LED
    tone(buzzerPin, 320, 200);    // 播放蜂鳴器聲音，頻率為320 Hz，持續時間為200毫秒
  }
  
  delay(500);    // 延遲500毫秒
}

/*這段代碼通過讀取數字輸入引腳8的狀態來獲取數字輸入的狀態。如果狀態為HIGH，則熄滅LED引腳并停止蜂鳴器聲音；如果狀態為LOW，則點亮LED引腳并播放蜂鳴器聲音。最后，通過delay()函數實現了500毫秒的延遲。*/

煙霧傳感器

const int ledPin = 13;    // LED引腳連接到數字引腳13
const int analogPin = A0;    // 模擬輸入引腳連接到模擬引腳A0
const int digitalPin = 7;    // 數字輸入引腳連接到數字引腳7
int Astate = 0;    // 存儲模擬輸入引腳的值
boolean Dstate = 0;    // 存儲數字輸入引腳的狀態
void setup()
{
  pinMode(digitalPin, INPUT);    // 將數字輸入引腳設置為輸入模式
  pinMode(ledPin, OUTPUT);    // 將LED引腳設置為輸出模式
  Serial.begin(9600);    // 初始化串口通信，波特率為9600
}
void loop()
{
  Astate = analogRead(analogPin);    // 讀取模擬輸入引腳的值并存儲在Astate變量中
  Serial.println(Astate);    // 打印模擬輸入引腳的值到串口
  
  Dstate = digitalRead(digitalPin);    // 讀取數字輸入引腳的狀態并存儲在Dstate變量中
  Serial.println(Dstate);    // 打印數字輸入引腳的狀態到串口
  
  if (Dstate == HIGH)
  {
    digitalWrite(ledPin, LOW);    // 熄滅LED
  }
  
  if (Dstate == LOW)
  {
    digitalWrite(ledPin, HIGH);    // 點亮LED
  }
  
  delay(200);    // 延遲200毫秒
}

/*這段代碼通過讀取模擬輸入引腳A0的值和數字輸入引腳7的狀態來獲取輸入的數值和狀態。然后，根據數字輸入引腳的狀態，控制LED引腳的亮滅。最后，通過delay()函數實現了200毫秒的延遲。*/

觸摸開關傳感器

const int SensorPin = 7;     // 傳感器引腳連接到數字引腳7
const int ledPin = 13;       // LED引腳連接到數字引腳13
int SensorState = 0;         // 存儲傳感器引腳的狀態
void setup()
{
  pinMode(SensorPin, INPUT);   // 將傳感器引腳設置為輸入模式
  pinMode(ledPin, OUTPUT);     // 將LED引腳設置為輸出模式
  Serial.begin(9600);          // 初始化串口通信，波特率為9600
}
void loop()
{
  SensorState = digitalRead(SensorPin);      // 讀取傳感器引腳的狀態并存儲在SensorState變量中
  Serial.println(SensorState);               // 打印傳感器引腳的狀態到串口
  if (SensorState != HIGH)   // 如果傳感器引腳未檢測到高電平（LOW）
  {
    digitalWrite(ledPin, LOW);               // 將LED引腳設為低電平，熄滅LED
  }
  else
  {
    digitalWrite(ledPin, HIGH);              // 將LED引腳設為高電平，點亮LED
  }
}

旋轉編碼器

const int clkPin = 2;     // CLK引腳連接到數字引腳2
const int dtPin = 3;      // DT引腳連接到數字引腳3
const int swPin = 4;      // SW引腳連接到數字引腳4
int encoderVal = 0;       // 編碼器值
void setup()
{
  pinMode(clkPin, INPUT);    // 將CLK引腳設置為輸入模式
  pinMode(dtPin, INPUT);     // 將DT引腳設置為輸入模式
  pinMode(swPin, INPUT);     // 將SW引腳設置為輸入模式
  digitalWrite(swPin, HIGH); // 上拉SW引腳
  Serial.begin(9600);        // 初始化串口通信，波特率為9600
}
void loop()
{
  int change = getEncoderTurn();    // 獲取旋轉的增量值
  encoderVal = encoderVal + change; // 更新編碼器值
  if (digitalRead(swPin) == LOW)    // 當檢測到SW引腳為低電平時
  {
    encoderVal = 0;                 // 重置編碼器值為0
  }
  Serial.println(encoderVal);       // 打印編碼器值到串口
}
int getEncoderTurn(void)
{
  static int oldA = HIGH;
  static int oldB = HIGH;
  int result = 0;
  int newA = digitalRead(dtPin);
  int newB = digitalRead(clkPin);
  if (newA != oldA || newB != oldB)
  {
    if (oldA == HIGH && newA == LOW)
    {
      result = (oldB * 2 - 1);       // 計算旋轉增量值
    }
  }
  oldA = newA;
  oldB = newB;
  return result;                     // 返回旋轉增量值
}
/*這段代碼實現了一個用于讀取旋轉編碼器值并在串口輸出的功能。它通過連接到Arduino的CLK（時鐘）、DT（數據）和SW（開關）引腳來監測編碼器的旋轉和按下操作。
代碼的主要作用如下：
在setup()函數中，設置了CLK、DT和SW引腳的模式為輸入，并將SW引腳設置為高電平輸入，以使用內部上拉電阻。
在loop()函數中，通過調用getEncoderTurn()函數獲取旋轉增量值，并根據旋轉方向更新編碼器值encoderVal。
如果檢測到SW引腳為低電平（即按下狀態），則將編碼器值重置為0。
在每次循環結束后，通過串口輸出當前的編碼器值，使用Serial.println(encoderVal)語句。
getEncoderTurn()函數用于檢測旋轉編碼器的旋轉方向。它通過讀取CLK和DT引腳的狀態來判斷旋轉方向，并返回相應的旋轉增量值。*/

紅外避障

const int ledPin = 13;      // LED引腳連接到數字引腳13
const int avoidPin = 7;     // 避障傳感器引腳連接到數字引腳7
void setup()
{
  pinMode(ledPin, OUTPUT);   // 將LED引腳設置為輸出模式
  pinMode(avoidPin, INPUT);  // 將避障傳感器引腳設置為輸入模式
}
void loop()
{
  boolean avoidVal = digitalRead(avoidPin);  // 讀取避障傳感器的狀態
  if (avoidVal == LOW)                       // 當檢測到避障傳感器為低電平時
  {
    digitalWrite(ledPin, HIGH);              // 點亮LED燈
  }
  else                                     
  {
    digitalWrite(ledPin, LOW);               // 熄滅LED燈
  }
}
/*以上代碼添加了詳細的注釋，解釋了每個變量和函數的作用，以及代碼的流程。該代碼使用Arduino控制一個LED燈，根據避障傳感器的狀態點亮或熄滅LED燈。
在setup()函數中，將LED引腳設置為輸出模式，避障傳感器引腳設置為輸入模式。
在loop()函數中，通過讀取避障傳感器引腳的狀態來獲取避障傳感器的值。
當避障傳感器為低電平時，表示檢測到障礙物，此時通過將LED引腳設置為高電平來點亮LED燈。
當避障傳感器為高電平時，表示沒有檢測到障礙物，此時通過將LED引腳設置為低電平來熄滅LED燈。
這個過程將不斷循環執行，實時監測避障傳感器的狀態并控制LED的亮滅。*/

紅外循跡

const int trackingPin = 7;   // 跟蹤傳感器引腳連接到數字引腳7
const int ledPin = 13;       // LED引腳連接到數字引腳13
void setup()
{
  pinMode(trackingPin, INPUT);  // 將跟蹤傳感器引腳設置為輸入模式
  pinMode(ledPin, OUTPUT);      // 將LED引腳設置為輸出模式
}
void loop()
{
  boolean val = digitalRead(trackingPin);  // 讀取跟蹤傳感器的狀態
  if (val != HIGH)                         // 當跟蹤傳感器不為高電平時
  {
    digitalWrite(ledPin, LOW);             // 熄滅LED燈
  }
  else                                    
  {
    digitalWrite(ledPin, HIGH);            // 點亮LED燈
  }
}
以上代碼添加了詳細的注釋，解釋了每個變量和函數的作用，以及代碼的流程。該代碼使用Arduino控制一個LED燈，根據跟蹤傳感器的狀態點亮或熄滅LED燈。
在setup()函數中，將跟蹤傳感器引腳設置為輸入模式，LED引腳設置為輸出模式。
在loop()函數中，通過讀取跟蹤傳感器引腳的狀態來獲取跟蹤傳感器的值。
當跟蹤傳感器不為高電平時，表示沒有檢測到跟蹤目標，此時將LED引腳設置為低電平，熄滅LED燈。
當跟蹤傳感器為高電平時，表示檢測到跟蹤目標，此時將LED引腳設置為高電平，點亮LED燈。
這個過程將不斷循環執行，實時監測跟蹤傳感器的狀態并控制LED的亮滅。
/**/

注意：以上代碼為人工編寫以及AI輔助。所以難免會存在問題。

代碼為Ardunino書本上源碼。

最后編寫不易，覺得好用請點贊。