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书本上源码。

最后编写不易，觉得好用请点赞。