代码收藏家 Arduino基础实验代码合集：25个实例详解
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书本上源码。
如有疑问请加QQ：2719332688进行反馈（注明来意）
最后编写不易，觉得好用请点赞。
