【物联网】Arduino物联网实验(附带超详细代码注释)_下图是一个实验电路,可以使用带有 arduino 的光电二极管读取光强度。使用 7 伏电

第1课：双色LED实验

一、实验介绍
双色发光二极管 (LED) 能够发出两种不同颜色的光，通常是红色和绿色，而不是仅有一种颜色。它采用3mm或5mm环氧树脂封装。它有3条线索；共阴极或共阳极可用。双色 LED具有两个 LED 端子或引脚，以反平行方式排列在电路中并通过阴极/阳极连接。正电压可以指向LED 端子之一，使该端子发出相应颜色的光；当电压的方向反转时，发出另一种颜色的光。在双色LED中，一次只能有一个引脚接受电压。因此，这种 LED 经常用作各种设备（包括电视机，数码相机和遥控器）的指示灯。
二、实验组件
• Arduino Uno主板l
• USB数据线1
•双色 LED 模块1
•面包板1
• 9V方型电池*l
• 跳线若干
三、实验原理
通过数字端口控制LED的亮度。LED的颜色从红色变为绿色并闪烁混合颜色。
实验原理图：

四、实验步骤
第1步：建立电路

第2步：程序（见源代码，附有我自己编写的中文注释）
第3步：编译
第4步：将程序上传至Arduino Uno板
第5步：观察实验现象
双色LED交替从红色变为绿色，并在交替期间闪烁混合颜色。

图：LED灯闪烁红色

图：LED灯闪烁绿色
五、实验体会
本实验相对较为简单，需要注意接线的正确性。在实验开始阶段由于不知道需要切换端口，导致多次录入失败，后续发现问题后切换端口即可顺利解决。
六、代码附录

int redPin = 11;    // 选择红色LED的引脚
int greenPin = 10;    // 选择绿色LED的引脚
int val = 0;    

void setup() 
{
  pinMode(redPin, OUTPUT); // 将redPin设为输出模式
  pinMode(greenPin, OUTPUT);// 将greenPin设为输出模式
  Serial.begin(9600); // 初始化串口通信，波特率为9600
}
/******************************************************/
void loop() 
{
  for(val=255; val>0; val--) // 循环，减少val值从255到0
  {
   analogWrite(redPin, val); // 改变红色LED的亮度（逐渐减小）
   analogWrite(greenPin, 255-val);// 改变绿色LED的亮度（逐渐增加）
   Serial.println(val, DEC);// 在串口监视器中打印val的值（十进制）
   delay(30); // 延迟30毫秒
  }
  for(val=0; val<255; val++) // 循环，增加val值从0到255
  {
   analogWrite(redPin, val); // 改变红色LED的亮度（逐渐增加）
   analogWrite(greenPin, 255-val);// 改变绿色LED的亮度（逐渐减小）
   Serial.println(val, DEC);// 在串口监视器中打印val的值（十进制）
   delay(30); // 延迟30毫秒
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

第2课：RGB-LED传感器实验

一、实验介绍
RGB LED 模块可以发出各种颜色的光。红色，绿色和蓝色的三个 LED 被封装到透明或半透明塑料外壳中，并带有四个引脚。红色，绿色和蓝色三原色可以按照亮度混合并组合各种颜色，因此可以通过控制电路使 RGB LED 发出彩色光。
二、实验组件
·Arduino Uno主板l
·USB数据线1
·RGB LED 模块1
·面包板1
·9V方型电池*l
·跳线若干
三、实验原理
在这个实验中，我们将使用PWM技术来控制RGB的亮度。三种颜色通道中的每一种：红色，绿色和蓝色都有255级亮度。当三原色全部为0时，LED灯熄灭。当所有颜色都是255时，LED变得最亮。在这里我们输入255之间的任何值到RGB LED的三个引脚，使其显示不同的颜色。
RGB LED可以分为普通阳极LED和普通阴极LED。在这个实验中，我们使用一个普通的阴极RGB LED。
实验原理图：

四、实验步骤
第1步：建立电路

第2步：程序（见源代码，附有我自己编写的中文注释）
第3步：编译代码
第4步：将程序上传至Arduino Uno板
第5步：观察实验现象
可以先看到 RGB LED 闪烁红色，绿色和蓝色，然后变为红色，橙色，黄色，绿色，蓝色，靛蓝和紫色。

图：LED灯闪烁蓝色

图：LED灯闪烁紫色
五、实验体会
本实验以及代码都相对较为简单，需要注意接线的正确性。
六、代码附录

const int redPin = 11;  // 将RGB LED模块的红色引脚连接到数字引脚11
const int greenPin = 10;  // 将RGB LED模块的绿色引脚连接到数字引脚10
const int bluePin = 9;  // 将RGB LED模块的蓝色引脚连接到数字引脚9
/**************************************************************************/
void setup()
{ 
  pinMode(redPin, OUTPUT); // 将redPin设置为输出模式
  pinMode(greenPin, OUTPUT); // 将greenPin设置为输出模式
  pinMode(bluePin, OUTPUT); // 将bluePin设置为输出模式
}    
/***************************************************************************/
void loop()  // 一直运行
{    
  // 基本颜色:  
  color(0,255,255); // 将RGB LED设置为红色 
  delay(1000); // 延迟1秒  
  color(255,0,255); // 将RGB LED设置为绿色  
  delay(1000); // 延迟1秒  
  color(255,255,0); // 将RGB LED设置为蓝色  
  delay(1000); // 延迟1秒 
  // 混合颜色示例:  
  color(0,255,255); // 将RGB LED设置为红色  
  delay(1000); // 延迟1秒  
  color(0,128,255); // 将RGB LED设置为橙色  
  delay(1000); // 延迟1秒  
  color(0,0,255); // 将RGB LED设置为黄色  
  delay(1000); // 延迟1秒  
  color(255,0,255); // 将RGB LED设置为绿色  
  delay(1000); // 延迟1秒 
  color(255,255,0); // 将RGB LED设置为蓝色  
  delay(1000); // 延迟1秒
  color(255,0,0); // 将RGB LED设置为靛红色 
  delay(1000); // 延迟1秒
  color(128,255,0); // 将RGB LED设置为紫色  
  delay(1000); // 延迟1秒
}     
/******************************************************/
void color (unsigned char red, unsigned char green, unsigned char blue)     // 颜色生成函数  
{    
  analogWrite(redPin, red);   
  analogWrite(bluePin, blue); 
  analogWrite(greenPin, green); 
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

第3课：七彩 LED灯闪烁

一、实验介绍
七彩LED灯上电后，7色自动闪光LED模块可自动闪烁内置颜色。它可以用来制作相当迷人的灯光效果。

二、实验组件
·Arduino Uno主板l
·USB数据线1
·七彩 LED 模块1
·面包板1
·9V方型电池*l
·跳线若干
三、实验原理
电源打开时，7彩LED将闪烁内置颜色。
实验原理图：

四、实验步骤
第1步：只需将模块的引脚VCC 连接到Arduino Uno电路板的5V, 并将 GND 连接到GND。
注意：模块上有两个GND 引脚。你只需要连接其中的一个。

第2步：观察实验现象
看到LED 闪烁七种颜色。

图：LED灯闪烁七种颜色
五、实验体会
本实验只需要接线即可，较为简单，需要注意接线的正确性。
六、代码附录
7彩LED不需要程序控制，无代码。

第4课：继电器实验

一、实验介绍
正如我们所知道的，继电器是一种用于响应施加的输入信号而在两个或多个点或设备之间提供连接的设备。换句话说，继电器提供了控制器和设备之间的隔离，因为我们知道设备可以在AC和DC上工作。但是，他们从微控制器接收信号， 因此我们需要一个继电器来弥补差距。当需要用小电信号控制大量电流或电压时，继电器非常有用。

二、实验组件
·Arduino Uno主板l
·USB数据线1
·继电器模块1
·面包板1
·9V方型电池*l
·跳线若干
三、实验原理
**继电器：**每个继电器有5个部件：
**1.电磁铁：**由一个由线圈缠绕的铁芯组成。当电流通过时，它变成磁性的。因此，它被称为电磁铁。
**2.电枢：**可移动磁条被称为电枢。当电流流过时，线圈通电，从而产生一个磁场，用于制造或断开常开(N/O)或常闭(N/C)点。电枢可以直流电(DC)和交流电(AC)移动。
**3.弹簧：**当没有电流流过电磁铁上的线圈时，弹簧将电枢拉开，因此电路无法完成。
**4.触点：**有两个触点：
常开——当继电器被激活时连接，当它不活动时断开。
常闭——继电器激活时未连接，未激活时连接。
**5.模制外壳：**继电器覆盖有塑料以保护。
继电器的工作
继电器的工作原理很简单。当继电器供电时，电流开始流经控制线圈; 结果，电磁体开始通电。然后衔铁被吸引到线圈上，将动触点向下拉，从而与常开触点连接。所以带负载的电路通电。然后断开电路会出现类似的情况，因为在弹簧的作用下，动触头将被拉到常闭触点。这样，继电器的接通和断开可以控制负载电路的状态。
继电器图：

所以在这个实验中，将SIG 连接到Arduino Uno板。发送一个低电平给SIG;PNP 晶体管通电并且继电器的线圈通电。因此，继电器的常开触点闭合，而继电器的常闭触点将脱离公共端口。向SIG 发送高电平的信息，晶体管将断电，继电器将恢复到初始状态。
实验电路图：

四、实验步骤
第1步：建立电路

第2步：程序（见源代码，附有我自己编写的中文注释）
第3步：编译代码
第4步：将程序上传至Arduino Uno板
第5步：观察实验现象
现在，你可能会听到ticktock。这是常开触点打开并且常开触点闭合。

图：继电器发出响声
五、实验体会
本实验代码和接线过程都较为简单，注意接线正确性即可。
六、代码附录

/**********************************************/
const int relayPin = 7; // 继电器模块的"s"端连接到数字引脚7
/**********************************************/
void setup()
{
  pinMode(relayPin, OUTPUT); // 将继电器设置为输出模式
}
/***********************************************/
void loop()
{
  digitalWrite(relayPin, HIGH); // 关闭继电器
  delay(1000); // 等待1秒
  digitalWrite(relayPin, LOW); // 断开继电器
  delay(1000); // 等待1秒
}
/*************************************************/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

第5课：激光传感器实验

一、实验介绍
由于其良好的指向性和能量集中性，激光广泛应用于医疗，军事等领域。顾名思义，激光发射模块是一种可以发射激光的模块。

二、实验组件
·Arduino Uno主板l
·USB数据线1
·激光发射器模块1
·面包板1
·9V方型电池*l
·跳线若干
三、实验原理
激光是一种通过基于受激发射的电磁辐射的光学放大过程发光的装置。激光与其他光源不同，因为它们相干发光。
空间相干性使得激光可以聚焦到狭小的地方，从而使激光切割和光刻等应用以及激光束在很远的距离保持狭窄(准直)，从而实现激光指示器等应用。激光器还可以具有高时间相干性，这使得它们具有非常窄的光谱，即它们仅发出单色光。它的时间相干性可以用来产生短至飞秒的光脉冲。
实验电路图：

四、实验步骤
第1步：建立电路

第2步：程序（见源代码，附有我自己编写的中文注释）
注意：这个程序定义了一个头文件和程序放在一起，这样子程序会一起编译。
第3步：编译代码
第4步：将程序上传至Arduino Uno板
第5步：通过电脑串口调试控制，观察实验现象
现在，您可以看到激光发射器模块发出莫尔斯信号。

图：激光发射（桌面上可看到光点）
五、实验体会
本实验接线较为简单，更多地注意力应关注在对代码的理解上。本代码主要分为以下几部分：
第 1-11 行：引入文件、引脚设置和串口初始化。
第 13-70 行：主循环和支持函数：
void setup() 初始化引脚模式和串口通信。
void loop() 检查串口监视器中是否有可用字符，并调用 morseSignal() 发送莫尔斯信号。
void flashDot(char cha) 控制激光器根据输入的字符发送莫尔斯电码的点和划。
void flashSequence(char *sequence) 发送一个完整单词或短语的莫尔斯电码序列。
void morseSignal(char ch) 判断接收到的字符类型（字母、数字、空格）并调用相应的莫尔斯电码序列。
六、代码附录
morce.h

#include "retrieval.h" // 引入retrieval.h头文件（文件内容为莫斯编码，见下）

const int laserPin = 7; // 激光器连接的引脚

static int dotDelay = 200; // 点（.）的时间间隔，单位为毫秒

void setup()
{
  pinMode(laserPin, OUTPUT);  // 初始化激光器引脚为输出模式
  Serial.begin(9600); // 初始化串口通信，波特率为9600
}

void loop()
{
  char ch = 0; // 用于存储从串口监视器读取的字符或数字
  if (Serial.available() > 0) // 检查是否有数据可读
  {
    ch = Serial.read(); // 从串口监视器读取一个字符
  }
  morseSignal(ch); // 根据读取的字符发送摩尔斯信号
}

// 发送点（.）的函数
void flashDot(char cha)
{
  digitalWrite(laserPin, HIGH); // 打开激光器
  if (cha == '.') // 如果是点（.）
  {
    delay(dotDelay); // 点（.）的时间间隔
  }
  else
  {
    delay(dotDelay * 3);  // 字母之间的间隔
  }
  digitalWrite(laserPin, LOW); // 关闭激光器
  delay(dotDelay);  // 闪烁之间的间隔
}

// 发送摩尔斯序列的函数
void flashSequence(char *sequence)
{
  int i = 0;
  while (sequence[i] != NULL) // 循环发送序列中的字符
  {
    flashDot(sequence[i]); // 发送单个字符
    i++;
  }
  delay(dotDelay * 3); // 字之间的间隔
}

// 根据输入字符发送摩尔斯信号
void morseSignal(char ch)
{
  if (ch >= 'a' && ch <= 'z') // 如果是小写字母
  {
    flashSequence(letters[ch - 'a']); // 发送对应的Morse代码序列
  }
  else if (ch >= 'A' && ch <= 'Z') // 如果是大写字母
  {
    flashSequence(letters[ch - 'A']); // 发送对应的Morse代码序列
  }
  else if (ch >= '0' && ch <= '9') // 如果是数字
  {
    flashSequence(numbers[ch - '0']); // 发送对应的Morse代码序列
  }
  else if (ch == ' ') // 如果是空格
  {
    delay(dotDelay * 4);  // 单词之间的间隔
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

retrieval.h

#ifndef __RETRIEVAL_H__
#define __RETRIEVAL_H__

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
};

#endif
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

第6课：轻触开关按键实验

一、实验介绍
在Arduino Uno控制电路板上已经在D13上集成了LED显示。所以只需要一个按钮模块就可以构建一个简单的电路来使LED 点亮。
按键模块是我们使用最为频繁的一个电子部件，内部由一对轻触拨盘构成，当按下时闭合导通，松开时自动弹开断开。

二、实验组件
·Arduino Uno主板l
·USB数据线1
·按钮模块1
·面包板1
·9V方型电池*l
·跳线若干
三、实验原理
由于LED已连接到引脚13，只需将按钮模块连接到数字引脚7.当按钮模块识别感应按钮按下信号时，LED将亮起。否则它会关闭。
实验电路图：

四、实验步骤
第1步：建立电路

第2步：程序（见源代码，附有我自己编写的中文注释）
第3步：编译代码
第4步：将程序上传至Arduino Uno板
第5步：观察实验现象
按下按钮，然后按钮模块上的指示灯和 Arduino Uno 电路板的针脚13上的 LED将亮起。

图：未按下按钮

图：按下按钮，LED亮起
五、实验体会
本实验接线较为简单，同时为了简化操作，加快接线速度，在安装过程中我们去掉了面包板，直接将原件之间进行连接。

六、代码附录

/**********************************/
const int keyPin = 7; // 按键引脚的编号
const int ledPin = 13; // LED 引脚的编号
/**********************************/
void setup()
{
  pinMode(keyPin, INPUT); // 初始化按键引脚为输入模式
  pinMode(ledPin, OUTPUT); // 初始化 LED 引脚为输出模式
}
/**********************************/
void loop()
{
  boolean value = digitalRead(keyPin); // 读取按键引脚的状态
  // 检查按键是否被按下
  // 如果按下，则状态为 HIGH
  if (value == HIGH)
  {
    digitalWrite(ledPin, LOW); // 关闭 LED
  }
  else
  {
    digitalWrite(ledPin, HIGH); // 打开 LED
  }
}
/************************************/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

第7课：倾斜开关实验

一、实验介绍
带有金属球的球形倾斜开关。它用于检测小角度的倾斜。。

二、实验组件
·Arduino Uno主板l
·USB数据线1
·倾斜开关模块1
·面包板1
·9V方型电池*l
·跳线若干
三、实验原理
在倾斜开关中球以不同的倾斜角度移动以制造触发电路的原理。倾斜开关模块使用双向传导的球形倾斜开关。当它向任一侧倾斜时，只要倾斜度和力满足条件，开关就会通电； 从而输出低电平信号。
在这个实验中，我们使用一个倾斜开关模块和一个已连接到Arduino 主板13 脚的 LED来构建一个简单的电路。
使用到D13口上面的 LED显示灯,将引脚SIG连接到Arduino Uno 电路板的数字引脚D7。然后倾斜开关输出低电平信号，LED将亮起。否则它会熄灭。
实验电路图：

四、实验步骤
第1步：建立电路

第2步：程序（见源代码，附有我自己编写的中文注释）
第3步：编译代码
第4步：将程序上传至Arduino Uno板
第5步：观察实验现象
倾斜开关, Arduino Uno电路板上连接到引脚13 的 LED将亮起。

图：向上倾斜，串口监视器显示全0

图：向下倾斜，串口监视器显示全1
五、实验体会
在完成本实验的过程中，我们多次更换了倾斜开关元件，仍无法完成指导书中的实验效果，后经排除后我们物理调节了这个原件的灵敏度，成功完成了实验。
六、代码附录

const int sigPin = 7;     // 倾斜开关连接的引脚编号
const int ledPin =  13;      // LED连接的引脚编号

// 变量将会改变:
boolean sigState = 0;         // 用于读取倾斜开关状态的变量

void setup()
{
  // 将LED引脚初始化为输出模式:
  pinMode(ledPin, OUTPUT);      
  // 将倾斜开关引脚初始化为输入模式:
  pinMode(sigPin, INPUT);  
  Serial.begin(9600); // 初始化串口通信，波特率为9600
}

void loop()
{
  // 读取倾斜开关值的状态:
  sigState = digitalRead(sigPin);
  Serial.println(sigState); // 在串口监视器中打印倾斜开关的状态

  if (sigState == HIGH) 
  {     
    // 关闭LED:
    digitalWrite(ledPin, LOW);  
  } 
  else 
  {
    // 打开LED:
    digitalWrite(ledPin, HIGH); 
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

第8课：振动开关传感器实验

一、实验介绍
振动开关也称为弹簧开关或震动传感器，是一种电子开关，它会产生震动力并将结果传送给电路装置，从而触发其工作。它包含以下部分：导电振动弹簧，开关主体，触发销和包装壳。

二、实验组件
·Arduino Uno主板l
·USB数据线1
·振动开关模块1
·面包板1
·9V方型电池*l
·跳线若干
三、实验原理
在振动开关模块中，导电的振动弹簧和触发销被精确地放置在开关体中并且通过粘合剂结合到固化位置。通常，弹簧和触发销不接触。一旦摇动，弹簧就会摇动并与触发器引脚接触以传导并产生触发信号。
将使用D13接口上的LED灯，将振动开关连接到数字引脚8.当振动开关感应到振动信号时，引脚SIG将输出低电平，模块上的LED 和引脚13 上连接的 LED将亮起。
实验电路图：

四、实验步骤
第1步：建立电路

第2步：程序（见源代码，附有我自己编写的中文注释）
第3步：编译代码
第4步：将程序上传至Arduino Uno板
第5步：观察实验现象
摇动开关模块，您应该可以看到Arduino Uno 开发板上针脚13 的 LED连接并且模块上的LED 点亮。

图：不摇动开关模块，LED不点亮

图：摇动开关模块，LED点亮
五、实验体会
本实验较为简单，注意接线正确即可。
六、代码附录

const int vibswPin = 8; // 振动开关连接的引脚编号
const int ledPin = 13; // LED连接的引脚编号
int val = 0; // 初始化变量 val 为 0

void setup()
{
  pinMode(vibswPin, INPUT); // 初始化振动开关引脚为输入模式
  pinMode(ledPin, OUTPUT); // 初始化 LED 引脚为输出模式
  Serial.begin(9600); // 初始化串口通信，波特率为 9600
}

void loop()
{
  val = digitalRead(vibswPin); // 读取振动开关的值
  Serial.println(val); // 在串口监视器中打印振动开关的状态

  if (val == LOW)  // 如果没有振动信号
  {
    digitalWrite(ledPin, HIGH); // 打开 LED
    delay(500); // 延迟 500 毫秒，LED 将亮 500 毫秒
  }
  else
  {
    digitalWrite(ledPin, LOW); // 关闭 LED
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

第9课：红外遥控实验

一、实验介绍
红外接收头的主要功能为IC化的一种受光元件，其内部是将光电二极管(俗称接收管)和集成IC共同组合封装而成，其 IC设计主要以类比式控制，一般主要接收38KHz的频率的红外线，而对其他频率段的红外信号不敏感，这样子遥控器可以发出载波在38KHz的频率，从而可以接受遥控器发送过来的信息，从而构成通讯。

二、实验组件
·Arduino Uno主板l
·USB数据线1
·红外接收器模块1
·面包板1
·9V方型电池*l
·跳线若干
三、实验原理
通过编程通过遥控器控制某个键(例如电源键) 。按键时，红外线将从遥控器发出并由红外接收器接收，Arduino Uno板上的D13 口上面我们接入一个双色LED，但是是需要我们控制红色灯亮起。将双色LED的红色灯控制端口连接到Arduino Uno 电路板上的D13端口上，以便更好的观察LED的变化。
实验电路图：

四、实验步骤
第1步：建立电路

第2步：程序（见源代码，附有我自己编写的中文注释）
第3步：编译代码
第4步：将程序上传至Arduino Uno板
第5步：观察实验现象
按下遥控器的“CH-”键,连接到 Arduino Uno 电路板上第 13 针的 LED 将亮起。然后按任何其他键，指示灯熄灭。

图：按下遥控器
五、实验体会
本实验较为简单，注意接线正确即可。
六、代码附录

/***********************************************
* 名称:红外接收器
* 功能:按下遥控器的 CH- 键，连接到 Arduino Uno 板的内置 LED 和连接到引脚 13 的 LED 都会点亮。
* 然后按下其他任意键，LED 将熄灭。
**********************************************/
#include <IRremote.h> // 引入红外线遥控器库

const int irReceiverPin = 7; // 红外接收模块的 SIG 引脚连接到引脚 7
const int ledPin = 13; // 连接到引脚 13 的 LED
IRrecv irrecv(irReceiverPin); // 创建一个 IRrecv 类型的变量
decode_results results;

void setup()
{
  pinMode(ledPin, OUTPUT); // 将 LED 引脚设置为输出模式
  Serial.begin(9600); // 初始化串口通信，波特率为 9600
  irrecv.enableIRIn(); // 启用红外接收模块
}

void loop()
{
  if (irrecv.decode(&results)) // 如果红外接收模块接收到数据
  { 
    Serial.print("irCode: "); // 打印 "irCode: "
    Serial.print(results.value, HEX); // 打印值的十六进制表示
    Serial.print(", bits: "); // 打印 ", bits: "
    Serial.println(results.bits); // 打印 bits
    irrecv.resume(); // 接收下一个值
  } 
  delay(600); // 延迟 600 毫秒

  if(results.value == 0xFFA25D) // 如果接收到的值为 0xFFA25D
  {
    digitalWrite(ledPin, HIGH); // 打开 LED
  }
  else
  {
    digitalWrite(ledPin, LOW); // 关闭 LED
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

第10课：蜂鸣器实验

一、实验介绍
蜂鸣器是音频信号装置。蜂鸣器可分为有源蜂鸣器和无源蜂鸣器。

二、实验组件
·Arduino Uno主板l
·USB数据线1
·有源蜂鸣器1
·无源蜂鸣器1
·面包板1
·9V方型电池l
·跳线若干
三、实验原理
如图所示，将两个蜂鸣器的引脚朝上，您可以看到带有绿色电路板的引脚是一个无源蜂鸣器，而另一个带有黑色塑料外壳而不是电路板的蜂鸣器是有源蜂鸣器。

有源蜂鸣器内置振荡源，所以通电时会发出声音。但无源蜂鸣器没有这种源，所以如果使用直流信号它不会发出蜂鸣声；相反，您需要使用频率在 2K到5K之间的方波来驱动它。由于有内置振荡电路，所以有源蜂鸣器通常比无源蜂鸣器昂贵。
实验电路图：

四、实验步骤
第1步：建立电路

第2步：程序（见源代码，附有我自己编写的中文注释）
第3步：编译代码
第4步：将程序上传至Arduino Uno板
第5步：观察实验现象
如果是无源蜂鸣器程序：可以听到无源蜂鸣器响了。如果在这里使用有源蜂鸣器，它也以相同的方式工作。
如果是有源蜂鸣器程序：现在，您可以听到蜂鸣器发出蜂鸣声。但是如果你在这里使用一个无源蜂鸣器，它将不起作用。因为有源蜂鸣器有一个内置振荡源，所以只要连接好就会发出蜂鸣声。

图：蜂鸣器发出响声
五、实验体会
本实验较为简单，为了获得更好的实验效果，可以调整代码中的频率值。
六、代码附录
有源蜂鸣器程序Active.ino

/************************************************
 * 功能：可以听到有源蜂鸣器发出的鸣叫声。
 * 如果使用无源蜂鸣器，这段代码将不起作用。
 ************************************************/

int buzzerPin = 7; // 有源蜂鸣器连接的引脚为 7

void setup()
{
  pinMode(buzzerPin, OUTPUT); // 将蜂鸣器引脚设置为输出模式
  digitalWrite(buzzerPin, LOW); // 初始化蜂鸣器引脚为低电平
}

void loop()
{
  digitalWrite(buzzerPin, LOW); // 将蜂鸣器引脚输出低电平
  delay(1000); // 延迟 1000 毫秒
  digitalWrite(buzzerPin, HIGH); // 将蜂鸣器引脚输出高电平
  delay(1000); // 延迟 1000 毫秒
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

无源蜂鸣器程序Passive.ino

// 功能：蜂鸣器以不同频率发出声音

const int buzzerPin = 7; // 蜂鸣器连接的引脚编号
int fre; // 用于存储频率值的变量

void setup()
{
  pinMode(buzzerPin, OUTPUT); // 将 buzzerPin 设置为输出模式
}

void loop()
{
  for(int i = 200; i <= 800; i++) // 频率循环从 200 到 800
  {
    tone(buzzerPin, i); // 在 pin7 产生频率为 i 的音调
    delay(5); // 等待 5 毫秒
  }
  delay(4000); // 在最高频率上等待 4 秒

  for(int i = 800; i >= 200; i--) // 频率循环从 800 递减到 200
  {
    tone(buzzerPin, i); // 在 pin7 产生频率为 i 的音调
    delay(10); // 等待 10 毫秒
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

第11课：干簧管传感器实验

一、实验介绍
干簧管传感器也是一种用于检测磁场的传感器。霍尔传感器通常用于测量智能车辆的度并计算装配线，而干簧管传感器通常用于检测磁场的存在。

二、实验组件
·Arduino Uno主板l
·USB数据线1
·干簧管传感器1
·圆形磁铁1
·面包板1
·9V方型电池l
·跳线若干
三、实验原理
干簧管传感器是一种通过磁信号实现控制的线路开关组件。它能感应磁铁的存在。这里的“开关”是指干簧管，它是一种结构简单，体积小，控制方便的接触式无源电子开关元件，干簧管壳体一般为密封玻璃管，配备弹性簧片电镀，并填充惰性气体，通常玻璃管中由特殊材料制成的两个簧片是分开的，但当磁性物质接近玻璃管时，玻璃管中的两个簧片被磁化吸引其他的在磁场线的作用下接触，这样两个簧片就会拉在一起，连接与节点相连的电路。
在外部磁力消失后，两个簧片由于具有相同的磁性而相互分离，因此电路也断开。因此，作为通过磁信号控制的线路开关部件，干簧管可以用作传感器来计数，限制位置等。同时它广泛应用于各种通讯设备。
在本实验中， 由于LED已集成在D13端口上，所以只需将簧片开关的引脚SIG 连接到Arduino Uno电路板的数字引脚D7 即可。当簧片开关识别磁场信号时，LED将亮起。否则它会关闭。
实验电路图：

四、实验步骤
第1步：建立电路

第2步：程序（见源代码，附有我自己编写的中文注释）
第3步：编译代码
第4步：将程序上传至Arduino Uno板
第5步：观察实验现象
现在，使用磁铁接近干篑管传感器时，干簧管模块上的 LED 和 Arduino 板上的 LED 亮起，将磁铁移动得更远，LED将熄灭。

图：不放置磁铁

图：放置磁铁
五、实验体会
本实验较为简单，为了获得更好的实验效果，可以调整干簧管的灵敏度。
六、代码附录

/*****************************************************
 * 名称：干簧管开关
 * 功能：用磁铁接近干簧管开关，会点亮干簧管开关模块上的 LED 和连接到 Arduino 板上的 LED。
 * 将磁铁移开，LED 将熄灭。
 **************************************************/

const int digitalInPin = 7; // 干簧管开关连接到引脚 7
const int ledPin = 13; // 连接到引脚 13 的 LED

void setup()
{
  pinMode(digitalInPin, INPUT); // 将 digitalInPin 设置为输入模式
  pinMode(ledPin, OUTPUT); // 将 ledPin 设置为输出模式
}

void loop()
{
  boolean stat = digitalRead(digitalInPin); // 读取引脚 7 的值到 stat 变量
  if (stat == HIGH) // 如果值为 HIGH
  { 
    digitalWrite(ledPin, LOW); // 关闭 LED
  }
  else // 否则
  {
    digitalWrite(ledPin, HIGH); // 打开 LED
  } 
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

第12课：U型光电传感器实验

一、实验介绍
U型光电传感器是一种对射式光电传感器，它有一个发射端和接收端组成，它适用于物体通过传感器时光线被挡住的原理。因此，U型光电传感器广泛用于速度测量。

二、实验组件
·Arduino Uno主板l
·USB数据线1
·U型光电传感器模块1
·面包板1
·9V方型电池*l
·跳线若干
三、实验原理
U 型光电传感器由两部分组成：发射器和接收器。发射器(例如，LED 或激光器)发光，然后光线进入接收器。如果发射器和接收器之间的光束被障碍物挡住，接收器即使在一瞬间也将检测不到入射光，并且输出电平将会改变。在这个实验中，我们将通过使用此更改来打开或关闭LED。
实验电路图：

四、实验步骤
第1步：建立电路

第2步：程序（见源代码，附有我自己编写的中文注释）
第3步：编译代码
第4步：将程序上传至Arduino Uno板
第5步：观察实验现象
将一张纸贴在传感器的间隙中，Arduino Uno上连接到D13号针脚的LED将熄灭；取出纸张，然后LED再次点亮。

图：不遮挡间隙，LED灯点亮

图：遮挡间隙，LED灯熄灭
五、实验体会
本实验较为简单，需要注意接线正确。
六、代码附录

/**********************************/
const int photoPin = 7; // 光敏电阻连接的引脚编号
const int ledPin = 13; // LED连接的引脚编号
/**********************************/
void setup()
{
  pinMode(photoPin, INPUT); // 初始化光敏电阻引脚为输入模式
  pinMode(ledPin, OUTPUT); // 初始化 LED 引脚为输出模式
}
/**********************************/
void loop()
{
  boolean Value = digitalRead(photoPin); // 读取光敏电阻引脚的值
  
  if (Value == HIGH) // 如果光敏电阻感应到光
  {
    digitalWrite(ledPin, LOW); // 打开 LED
  }
  else
  {
    digitalWrite(ledPin, HIGH); // 关闭 LED
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

第13课：PCF8591模数转换器传感器实验

一、实验介绍
PCF8591 是一款单芯片，单电源和低功耗8位 CMOS 数据采集设备，具有四个模拟输入，一个模拟输出和一个串行I2C总线接口。三个地址引脚A0，A1 和A2用于编程硬件地址，允许最多使用8个连接到I2C总线的设备，无需额外的硬件。设备的地址，控制和数据通过双线双向I2C总线串行传输。。

二、实验组件
·Arduino Uno主板l
·USB数据线1
·AD / DA 转换器PCF85911
·面包板1
·9V方型电池*l
·跳线若干
三、实验原理
解决
I2C总线系统中的每个PCF8591 器件都通过向器件发送有效地址来激活。地址由固定部分和可编程部分组成。可编程部分必须根据地址引脚AO，A1 和 A2进行设置。在 I2C总线协议中，地址始终必须作为开始条件之后的第一个字节发送。地址字节的最后一位是读/写位，用于设置后续数据传输的方向。

控制字节
发送到PCF8591器件的第二个字节将被存储在其控制寄存器中，并且需要控制器件功能。控制寄存器的高半字节用于使能模拟输出，并将模拟输入编程为单端或差分输入。下半字节选择由上半字节定义的一个模拟输入通道。如果设置了自动增加标志，则在每次A / D转换后，通道编号会自动递增。

在这个实验中，将发送给PCF8591器件的第二个字节设置为高电平，以启用模拟输出 - 使AOUT 输出逐渐变化的模拟量。AD / DA 转换器PCF8591上的指示灯 D2逐渐点亮并交替熄灭。如果连接到AOUT, Arduino Uno 电路板的引脚13 上的 LED也会发生同样的情况。
实验电路图：

四、实验步骤
第1步：建立电路
PCF8591 与 Arduino Uno板之间的连线:

第2步：程序（见源代码，附有我自己编写的中文注释）
第3步：编译代码
第4步：将程序上传至Arduino Uno板
第5步：观察实验现象
我们可以看到 AD/DA 转换器PCF8591上的指示灯D2 逐渐点亮并交替熄灭。连接到ArduinoUno电路板 13号针脚的LED也会发生同样的情况。
实验箱套件中并无此原件，我们将重点放在分析代码上。具体见实验体会。
五、实验体会
由于提供的材料箱中并无此原件，本实验我们的重点放在分析代码上。
行 7： 引入了 “Wire.h” 库，这是用于I2C通信的Arduino库。
行 8： 定义了PCF8591的I2C地址为 0x90，右移一位得到 0x48。这个地址用于在I2C总线上与PCF8591通信。
函数 setup()（行 9-14）：
Wire.begin() 初始化了I2C通信。
Serial.begin(9600) 初始化了串口通信，波特率为9600。
Serial.println(sin(PI / 2)) 在串口上打印正弦函数的值，即1。
函数 loop()（行 15-35）：
第一个循环（行 17-25）：逐渐增加DAC的输出值，从0到255。每个值都会通过I2C发送到PCF8591，LED的亮度会相应变化。同时使用正弦函数调整延迟时间，并在串口上打印一系列值。
第二个循环（行 27-35）：逐渐减小DAC的输出值，从255到0。LED的亮度相应地减小，同样使用正弦函数调整延迟时间，并在串口上打印一系列值。
这段代码的核心功能是控制LED（连接在PCF8591的DAC输出）的亮度，同时在串口上输出一系列通过正弦函数计算得到的值。

六、代码附录

/***********************************************
 * 项目名称: 模拟-数字转换器 - PCF8591
 * 功能: PCF8591上的指示灯D2逐渐点亮并交替熄灭。
 * Arduino Uno板上连接的LED也是如此
 ***************************************************/
 
#include "Wire.h"
#define PCF8591 (0x90 >> 1) // I2C总线地址
void setup()
{
  Wire.begin();
  Serial.begin(9600);
  Serial.println(sin(PI / 2));
}
void loop()
{
  for (int i = 0; i < 256; i++)
  {
    Wire.beginTransmission(PCF8591); // 唤醒PCF8591
    Wire.write(0x40); // 控制字节 - 打开DAC (二进制 01000000)，模拟输出
    Wire.write(i); // 发送到DAC的值
    Wire.endTransmission(); // 结束传输
    delay(10 * sin(i / 256.0 * 90 / 180 * PI)); // 延迟时间
    Serial.println(100 * sin(i / 256.0 * 90 / 180 * PI)); // 打印序列
  }

  for (int i = 255; i >= 0; --i)
  {
    Wire.beginTransmission(PCF8591); // 唤醒PCF8591
    Wire.write(0x40); // 控制字节 - 打开DAC (二进制 1000000)
    Wire.write(i); // 发送到DAC的值
    Wire.endTransmission(); // 结束传输
    delay(10 * sin(i / 256.0 * 90 / 180 * PI)); // 延迟时间
    Serial.println(100 * sin(i / 256.0 * 90 / 180 * PI)); // 打印序列
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

第14课：雨滴探测传感器实验

一、实验介绍
雨滴传感器或雨滴检测传感器用于检测是否下雨以及降雨。广泛应用于汽车的雨刷系统，智能照明系统和天窗系统。

二、实验组件
·Arduino Uno主板l
·USB数据线1
·雨滴传感器1
·雨滴传感器调理板1
·面包板1
·9V方型电池l
·跳线若干
三、实验原理
在雨滴/雨水器系统中，用雨滴传感器检测降雨量并转换控制器检测到的信号。然后根据这些信号自动设置雨刮器的间隔，以方便地控制雨刮器的电机。在智能照明系统中， 自动检测驾驶环境并调整照明模式，提高恶劣环境下的行车安全。在智能天窗系统中，检测是否下雨 - 如果检测到雨滴，则自动关闭天窗。
在这个实验中，我们使用模块和连接到Arduino Uno电路板 D13 脚的 LED 来构建电路。用Uno板的AO 连接雨滴传感器模块的 AO，将 DO 连接到引脚D7.将一些水滴到传感器上。下降越多，AO处的值越低。当雨滴数量超过设定的阈值时，DO将由高变低，相应的LED将亮起。
实验电路图：

四、实验步骤
第1步：建立电路

第2步：程序（见源代码，附有我自己编写的中文注释）
第3步：编译代码
第4步：将程序上传至Arduino Uno板
第5步：观察实验现象
现在将一些水滴到传感器上，当雨滴数量超过阈值时，雨滴传感器模块上的LED和ArduinoUno板的针脚 13 上的LED点亮；否则，他们保持关闭。您可以通过电位器调整传感器的灵敏度，这意味着设置它的阈值。

图：未滴水，LED灯不亮

图：滴水，LED灯点亮
五、实验体会
本实验较为简单，需要注意接线的正确。
六、代码附录

/******************************************************
 * 名称：雨滴检测
 * 功能：在传感器上滴一些水滴，当水滴数量超过阈值时，
 * 雨滴传感器模块上的 LED 和连接到 Arduino Uno 板上 pin 13 的 LED 会点亮。
 *******************************************************/

const int analogPin = A0; // 模块的 AO 引脚连接到 A0
const int digitalPin = 7; // D0 引脚连接到 pin 7
const int ledPin = 13; // pin 13 内置 LED
int Astate = 0; // 存储 A0 引脚的值
boolean Dstate = 0; // 存储 D0 引脚的值

void setup() 
{
 pinMode(ledPin, OUTPUT); // 设置 ledPin 为输出模式
 pinMode(digitalPin, INPUT); // 设置 digitalPin 为输入模式
 Serial.begin(9600); // 初始化串口通信，波特率为 9600
}

void loop() 
{
  Astate = analogRead(analogPin); // 读取 A0 引脚的值
  Serial.print("A0: ");
  Serial.println(Astate); // 在串口监视器中打印值
  Dstate = digitalRead(digitalPin); // 读取 D0 引脚的值
  Serial.print("D0: ");
  Serial.println(Dstate);

  if (Dstate == HIGH)  
  {
    digitalWrite(ledPin, LOW); // 关闭 LED
  }
  else // 如果 D0 引脚的值为 LOW
  {
    digitalWrite(ledPin, HIGH); // 打开 LED
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

第15课：PS2 操纵杆实验

一、实验介绍
操纵杆是一种输入设备，由一根可在基座上旋转并向其控制的设备报告其角度或方向的操纵杆组成。操纵杆通常用于控制视频游戏和机器人。这里使用操纵杆PS2。

二、实验组件
·Arduino Uno主板l
·USB数据线1
·PS2游戏手柄模块1
·面包板1
·9V方型电池*l
·跳线若干
三、实验原理
该模块具有两个模拟输出(对应于X和Y 坐标)和一个数字输出，表示是否在 Z 轴上按下。
实验电路图：

四、实验步骤
第1步：建立电路
PS2 操纵杆和Arduino Uno板之间的接线:

第2步：程序（见源代码，附有我自己编写的中文注释）
第3步：编译代码
第4步：将程序上传至Arduino Uno板
第5步：观察实验现象
现在，推动摇杆，串行监视器上显示的X轴和 Y 轴坐标将相应改变；按下按钮，Z = 0的坐标也会显示出来。

图：连接摇杆

图：串行显示器上坐标改变
五、实验体会
本实验较为简单，需要注意接线的正确。
六、代码附录

/*********************************************
 * 名称：PS2摇杆
 * 功能：按下摇杆时，X和Y轴坐标在串口监视器上显示变化；
 * 按下摇杆按钮，Z轴坐标为0也会显示在串口监视器上。
 连接方式:
 Joystick PS2                 Arduino Uno R3
 GND                       GND
 VCC                       5V
 SW                       7
 x                       A0
 y                       A1
 ***********************************************/

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: "); // 打印 "X: "
  Serial.print(analogRead(xPin), DEC); // 读取 A0 引脚的值并以十进制方式打印
  Serial.print("\tY: "); // 打印 "Y: "
  Serial.print(analogRead(yPin), DEC); // 读取 A1 引脚的值并以十进制方式打印
  Serial.print("\tZ: "); // 打印 "Z: "
  Serial.println(digitalRead(btPin)); // 读取数字引脚 7 的值并打印
  delay(100); // 延迟 100 毫秒
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

第16课：电位器传感器实验

一、实验介绍
电位器可以帮助控制Arduino板上的 LED闪烁的时间间隔。

二、实验组件
·Arduino Uno主板l
·USB数据线1
·电位器模块1
·面包板1
·9V方型电池*l
·跳线若干
三、实验原理
模拟电位器是模拟电子元件。模拟和数字之间有什么区别?简而言之，数字电位器仅指开/关，高/低电平等两种状态，即0或1，而数字电位器支持1至1000之间的模拟信号。信号值随时间变化而不是保持一个确切的数字。模拟信号包括光强度，湿度，温度等。
在本实验中，将电位器模块的引脚SIG连接到 Arduino Uno 电路板的AO，并检查 AO 处的值。然后使用该值来控制与Uno板的针脚13 连接的LED闪烁的时间间隔。旋转电位器的轴，LED闪烁间隔将增加或减少。
实验电路图：

四、实验步骤
第1步：建立电路

第2步：程序（见源代码，附有我自己编写的中文注释）
第3步：编译代码
第4步：将程序上传至Arduino Uno板
第5步：观察实验现象
旋钮电位器传感器的的轴，可以看到Arduino Uno D13 引脚上连接的LED将会增加或减少闪烁的间隔。

图：旋钮电位器, 观察闪烁间隔
五、实验体会
本实验较为简单，需要注意接线的正确。
六、代码附录

const int analogPin = A0; // 模拟输入引脚连接到
const int ledPin = 13; // LED连接到
int inputValue = 0; // 变量用于存储传感器的值
/******************************************/
void setup()
{
  pinMode(ledPin, OUTPUT); // 设置 LED 引脚为输出模式
  Serial.begin(9600); // 初始化串口通信，波特率为 9600
}
/******************************************/
void loop()
{
  inputValue = analogRead(analogPin); // 从传感器读取值
  //Serial.println(inputValue);
  digitalWrite(ledPin, HIGH); // 点亮 LED
  delay(inputValue); // 延迟时间等于传感器读取的值
  digitalWrite(ledPin, LOW); // 关闭 LED
  delay(inputValue); // 再次延迟相同的时间
}
/*******************************************/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

第17课：模拟霍尔传感器实验

一、实验介绍
基于霍尔效应，霍尔传感器是响应于磁场而改变其输出电压的传感器。霍尔传感器用于接近开关，定位，速度检测和电流检测应用。
霍尔传感器可以分为模拟霍尔传感器和开关霍尔传感器。开关霍尔传感器由电压调节器，霍尔元件，差分放大器，施密特触发器和输出端子组成，输出布尔值(0/1) 。模拟霍尔传感器由霍尔元件，线性放大器和射极跟随器组成，输出模拟值。如果在模拟霍尔传感器上增加比较器就可以组成数字开关霍尔传感器和模拟霍尔传感器一体，它可以输出模拟值和数字信号。

二、实验组件
·Arduino Uno主板l
·USB数据线1
·模拟数字霍尔传感器模块1
·面包板1
·磁铁1
·9V方型电池l
·跳线若干
三、实验原理
霍尔效应
霍尔效应是一种电磁效应。它在1879年由 Edwin Hall发现，当时他正在研究有关金属的传导机制。当导体通过均匀的磁场时可以看到效果。载流子的自然电子漂移导致磁场对这些载流子施加洛伦兹力(施加在电磁场中带电粒子上的力)。结果就是所谓的电荷分离，在底部或顶部积聚了正电荷或负电荷。

霍尔传感器是基于它的磁场传感器。
通过导体传输的电流会产生随电流变化的磁场，霍尔传感器可用于测量电流而不中断电路。通常，传感器与围绕待测导体的绕线芯或永磁体集成。
在这个实验中， 当传感器接近磁体时，引脚A0的值将改变。当该值超过电位器设定的阈值之前，DO 将输出低电平，相应的LED亮起。
实验电路图：

四、实验步骤
第1步：建立电路

第2步：程序（见源代码，附有我自己编写的中文注释）
第3步：编译代码
第4步：将程序上传至Arduino Uno板
第5步：观察实验现象
将磁铁靠近霍尔传感器。D0的电压从高到低变化，然后传感器上的LED和连接到 Arduino Uno的引脚13 上的 LED 亮起。您可以在串行监视器上看到 A0和 D0的值。

图：将磁铁远离传感器

图：将磁铁靠近传感器

图：串行监视器数值变化
五、实验体会
本实验较为简单，需要注意接线的正确。

六、代码附录

// 模拟霍尔传感器
// 使用 LM393 低功耗低偏移电压双比较器
/*******************************
 * 模拟霍尔传感器     Uno R3
 * A0                 A0
 * D0                 7
 * VCC                5V
 * GND                GND
 *******************************/

const int ledPin = 13; // LED连接到引脚13
int sensorPin = A0;    // 选择电位计的输入引脚
int digitalPin = 7;   // D0连接到引脚7

int sensorValue = 0;  // 用于存储来自A0的值
boolean digitalValue = 0;  // 用于存储来自pin7的值

void setup() 
{
  pinMode(digitalPin, INPUT);  // 设置D0引脚为输入模式
  pinMode(ledPin, OUTPUT);  // 设置引脚13为输出模式
  Serial.begin(9600); // 初始化串口通信，波特率为9600
}

void loop() 
{ 
  sensorValue = analogRead(sensorPin);  // 读取A0引脚的值
  digitalValue = digitalRead(digitalPin);  // 读取D0引脚的值

  Serial.print("Sensor Value "); // 打印标签到串口监视器
  Serial.println(sensorValue);  // 打印A0引脚的值到串口监视器
  Serial.print("Digital Value "); // 打印标签到串口监视器
  Serial.println(digitalValue);  // 打印D0引脚的值到串口监视器
  
  if (digitalValue == HIGH)  // 如果D0引脚的值为HIGH
  {
    digitalWrite(ledPin, LOW); // 关闭LED
  }
  if (digitalValue == LOW)  // 如果D0引脚的值为LOW
  {
    digitalWrite(ledPin, HIGH); // 打开LED
  }
  delay(1000); // 延迟1000毫秒
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

第18课：模拟温度传感器实验

一、实验介绍
温度传感器是检测温度并将其转换为输出信号的组件。根据材料和部件的特点，温度传感器可分为热电阻和热电偶两种。热敏电阻是前者的一种。它由半导体材料制成；大多数热敏电阻是负温度系数(NTC) ，其电阻随温度升高而降低。由于它们的电阻随温度变化剧烈变化，所以热敏电阻是最敏感的温度传感器。
模拟温度传感器模块使用NTC热敏电阻， 因此可以对温度进行敏感测量。它还有一个内置比较器LM393， 它可以使模块同时输出数字和模拟信号。该模块可用于温度报警和温度测量。

二、实验组件
·Arduino Uno主板l
·USB数据线1
·模拟温度传感器模块1
·面包板1
·9V方型电池*l
·跳线若干
三、实验原理
模拟温度传感器模块上有一个比较器LM393。您可以通过电位器设置一个阈值。当您触摸热敏电阻时，A0的值会降低。一旦该值低于阈值，D0将输出高电平，并且模拟温度传感器模块上的指示灯以及连接到Arduino Uno的针脚13 上的指示灯将熄灭。您可以检查串行监视器上的 A0 和 D0 的值。
实验电路图：

四、实验步骤
第1步：建立电路

第2步：程序（见源代码，附有我自己编写的中文注释）
第3步：编译代码
第4步：将程序上传至Arduino Uno板
第5步：观察实验现象
现在，触摸热敏电阻，模拟温度传感器模块上的 LED 和连接到Arduino Uno 的13号针脚上的LED 将熄灭。

图：不触摸热敏电阻，LED不亮

图：触摸热敏电阻，LED亮
五、实验体会
本实验较为简单，需要注意接线的正确。
六、代码附录

// 模拟温度传感器
const int digitalPin = 7;     // 模拟温度传感器的 D0 连接到引脚7
int analogPin = A0;           // 模拟温度传感器的 A0 连接到 A0 引脚
const int ledPin =  13;      // 内置 LED 的引脚13

// 变量将会改变：
boolean Dstate = 0;          // 用于读取 D0 的状态的变量
int Astate = 0;              // 用于读取 A0 的状态的变量

void setup() 
{
  pinMode(ledPin, OUTPUT);   // 初始化 LED 引脚为输出模式     
  pinMode(digitalPin, INPUT);// 初始化模拟温度传感器 D0 引脚为输入模式
  Serial.begin(9600);        // 初始化串口通信，波特率为9600 bps
}

void loop()
{
  Astate = analogRead(analogPin);  // 读取模拟温度传感器 A0 的值（设定点）
  Dstate = digitalRead(digitalPin); // 读取模拟温度传感器 D0 的状态
  Serial.print("D0: ");
  Serial.println(Dstate);    // 将 D0 引脚的值打印到串口监视器
  Serial.print("A0:");
  Serial.println(Astate);    // 将 A0 引脚的值打印到串口监视器
//检查按钮是否被按下。
//如果是，则按钮状态为HIGH：
  if (Dstate == HIGH)    // 检查模拟温度传感器 D0 是否为 HIGH
  {     
   digitalWrite(ledPin, LOW);  // 点亮 LED   
  } 
  else 
  {
    digitalWrite(ledPin, HIGH); // 关闭 LED
  }
  delay(1000);                // 控制模拟温度传感器和串口监视器显示速度
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

第19课：声音传感器实验

一、实验介绍
声音传感器是一种接收声波并将其转换为电信号的组件。它像麦克风一样检测周围环境中的声音强度。

二、实验组件
·Arduino Uno主板l
·USB数据线1
·声音传感器模块1
·面包板1
·9V方型电池*l
·跳线若干
三、实验原理
该传感器具有对声音敏感的电容式驻极体麦克风。声波导致驻极体薄膜振动，然后电容发生变化，从而导致相应的电压变化。由于变化非常微弱，因此需要加以放大。这里的LM358是一个100 倍增益的功率放大器。将声音传感器的SIG 输出引脚连接到 ArduinoUno电路板的A0。然后，您可以在串行监视器上看到声音强度的值，或者如果连接了示波器，则可以在示波器上显示波形。
实验电路图：

四、实验步骤
第1步：建立电路

第2步：程序（见源代码，附有我自己编写的中文注释）
第3步：编译代码
第4步：将程序上传至Arduino Uno板
第5步：观察实验现象
现在您可以在串行监视器上看到声音强度的值。当音量达到一定值时，Arduino Uno电路板上连接到引脚13 的LED将亮起。

图：连接声音传感器，向声音传感器发出声音，LED亮起

图：串行监视器上声音强度的变化
五、实验体会
本实验较为简单，需要注意接线的正确。为了让传感器更加灵敏地探测到生意，我们减小了声音传感器的阈值。
六、代码附录

const int ledPin = 13;    // LED连接到pin13
const int soundPin = A0;  // 声音传感器连接到A0

void setup()
{
  pinMode(ledPin, OUTPUT); // 设置ledPin为输出
  Serial.begin(9600);      // 初始化串口通信，波特率为9600 bps
}

void loop()
{
  int value = analogRead(soundPin); // 读取声音传感器的值
  Serial.println(value);            // 将值打印到串口监视器

  if (value > 600)  // 如果声音传感器的值大于600
  {
    digitalWrite(ledPin, HIGH); // 点亮LED
    delay(200);                 // 延迟200毫秒
  }
  else // 否则
  {
    digitalWrite(ledPin, LOW); // 关闭LED
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

第20课：光敏传感器实验

一、实验介绍
该传感器实际上是一个光敏电阻，它随着光强的变化而改变其电阻。它可以用来制作光控开关。

二、实验组件
·Arduino Uno主板l
·USB数据线1
·继电器模块1
·光敏电阻传感器模块1
·面包板1
·9V方型电池l
·跳线若干
三、实验原理
光敏电阻或光敏电阻 (LDR) 或光电池是光控可变电阻。光敏电阻的电阻随着入射光强度的增加而减小；换句话说，它表现出光电导性。光敏电阻可应用于光敏检测器电路，以及光敏和亮暗控制开关电路。在本实验中，将光敏电阻连接到 Arduino 板的 A0，并继续连接到引脚8.当数值达到甚至超过 400时，继电器的常开触点闭合，Arduino Uno 板上的引脚13 上的LED将点亮；否则，它会关闭。这样你就可以做一个光控开关。
实验电路图：

四、实验步骤
第1步：建立电路
继电器与Arduino Uno电路板之间的接线:

光敏电阻与 Arduino Uno电路板之间的连线:

第2步：程序（见源代码，附有我自己编写的中文注释）
第3步：编译代码
第4步：将程序上传至Arduino Uno板
第5步：观察实验现象
现在用手指拿住光敏电阻，并检查串行监视器上的 A0 值。当电阻高达 400 欧姆时，继电器的常开触点闭合，Arduino Uno 电路板上的13 号针脚的 LED点亮；否则，它会保持不变。

图：连接光敏电阻，不用手指拿住

图：连接光敏电阻，不用手指拿住，电阻值不到400Ω，灯不亮

图：连接光敏电阻，用手指拿住

连接光敏电阻，用手指拿住，电阻值超过400Ω，灯亮
五、实验体会
本实验较为简单，需要注意接线的正确。
六、代码附录

/*****************************************************
 * 项目名称: 光敏开关
 * 功能: 用手指遮挡光敏电阻并在串口监视器上检查A0处的数值。
 * 当电阻上升到400欧姆时，继电器的常开触点闭合，连接到Arduino Uno板上Pin 13的LED亮起；
 * 否则，保持关闭。
 ************************************************/
const int photocellPin = A0; // 光敏电阻模块连接到A0
const int ledPin = 13;       // Pin 13连接到内置LED
const int relayPin = 8;      // 继电器模块连接到数字8
int outputValue = 0;

void setup()
{
  pinMode(relayPin, OUTPUT); // 设置继电器引脚为输出
  pinMode(ledPin, OUTPUT);   // 设置LED引脚为输出
  Serial.begin(9600);        // 初始化串口通信，波特率为9600bps
}

void loop()
{
  outputValue = analogRead(photocellPin); // 读取光敏电阻的数值
  Serial.println(outputValue);            // 在串口监视器上打印数值

  if (outputValue >= 400)  // 如果光敏电阻的数值大于等于400
  {
    digitalWrite(ledPin, HIGH);   // 打开LED
    digitalWrite(relayPin, LOW);  // 连接继电器
  }
  else // 否则
  {
    digitalWrite(ledPin, LOW);    // 关闭LED
    digitalWrite(relayPin, HIGH); // 断开继电器
  }

  delay(1000); // 延迟1秒
}
/*************************************************/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37