在本教程中，我们将通过示例代码和示例程序学习如何进行基本的Arduino编程。对于希望通过简单易懂的语言掌握基础知识的所有新手来说，本教程将是一门非常有价值的课程。
介绍
根据维基百科微控制器相当于一台内置于单个IC芯片内的微型计算机，拥有自己的核心处理器、可编程输入、存储器和输出外围设备。
微控制器对于用户来说非常有用，因为它提供了内置处理器、内存和输入/输出端口（也称为GPIO或通用输入/输出引脚），用户可以根据任何期望的规范控制这些端口。
在本教程中，我们将使用Arduino Uno板来学习和测试程序。为了测试和集成硬件装配，我们将使用一个面包板。
现在让我们快速学习如何开始Arduino编程。
1.2安装软件（Windows）
为此，您需要访问internet，很明显，您的计算机中会有internet。请转到以下链接并下载IDE软件：
下载后，您将在下载文件夹中找到Arduino安装图标，如下所示：
获取此项后，您可以简单地单击它并在计算机中安装Arduino Integrated开发环境（IDE）。完整的过程可以在以下视频中可视化：
1.4从我们的第一条赛道开始
在我们开始学习实际的编程技术之前，对于任何新手来说，从一个基本组件开始(如LED)，并了解如何将其与Arduino连接起来是很有用的。
正如我们所知，LED是一种具有极性的发光二极管，如果未连接到正确的电源极，则不会发光。
led的另一个特点是，这些器件在低电流下工作，如果一个适当计算的电阻没有包括在它的一个引脚的串联中，可能会立即损坏。
根据经验，330欧姆1/4瓦对于电源输入的每5伏上升非常理想，可以将电流限制在所需的安全水平。因此，对于5伏，它可能是330欧姆，对于10伏，它可能是680欧姆，依此类推。
为程序集使用面包板
请确保你知道如何使用a面包板在尝试本章中介绍的教程之前，因为我们将使用一个试验板进行所有的实验。
基本的LED连接设置如下:
您可以在上面看到3个基本组件：
- 一个5mm, 20mA LED
- 一个330欧姆1/4瓦电阻
- 一Arduino电路板
按照图表组装系统即可。
接下来，将电脑USB的5V插头插入Arduino。当你这样做的时候，你会看到LED灯亮起来。
我知道这很基本，但从头开始总是好的。请放心，随着我们的进展，事情会变得越来越有趣。
1.5使用Arduino控制LED
现在我们将学习如何使用Arduino程序控制LED。
要编写程序，我们必须在每个程序中至少有2个功能。
一个函数可以被理解为一系列的编程语句，这些语句可以被赋上一个名字，如下所示:
- 设置()在程序的开始期间调用或执行这一点。
- 循环（）这在Arduino的整个运营期间重复地调用或执行。
因此，尽管它可能没有实际功能，但从技术上讲，最短合法的Arduino程序可以写成：
最简单程序
无效的设置()
{
}
void循环（）
{
}
您可能已经注意到，在许多编程语言中，系统首先在显示屏上显示一个简单的打印“Hello，World”
在微控制器的解释中，这个短语的电子等价物是使LED亮起和熄灭。
这是人们可以编写和实现的最基本的程序，以指示系统的正确运行。
我们将尝试通过下面的代码来实现和理解这个过程:
清单1.2:led1/led1.pde
常数int kPinLed=13；
无效的设置()
{
pinMode (kPinLed、输出);
}
void循环（）
{
DigitalWrite（kpinled，高）;
延迟（500）；
digitalWrite (kPinLed、低);
延迟（500）；
}
好了，现在让我们来理解每一行代码的意思，以及它是如何执行函数的:
常数int kPinLed=13；
这是一个常量，它允许我们在完整的编程过程中使用它，而无需使用符合它的实际值。
按照标准规则，这些常数是用起始字母来识别的K．尽管这不是必须的，但是当您想要查看代码细节时，它会使事情变得更清晰和容易理解。
无效的设置()
{
pinMode (kPinLed、输出);
}
这段代码配置了LED连接到的特定引脚。换句话说，代码告诉Arduino控制这个大头针的“写入”方面，而不是“读取”它。
void循环（）
{
DigitalWrite（kpinled，高）;
延迟（500）；
digitalWrite (kPinLed、低);
延迟（500）；
}
上面的行表示应用程序的实际执行。代码首先在相关的LED连接上编写并呈现一个HIGH，将LED打开。
这里，术语“高”只是指在Arduino的相关引脚上获得+5V电压。补充术语LOW仅表示指定引脚上的零或0V。
接下来，我们打电话延迟（）其功能是通过毫秒（1/1000秒）创建延迟。由于输入了图500，实现的延迟将为1/2秒。
这1/2秒过后，将执行下一行，该行将关闭LED，同时在同一引脚上显示低端。
随后的线路再次产生1/2秒延迟，以使LED保持关闭1/2秒。
只要Arduino保持通电状态，这个过程就会通过执行代码行无限地继续下去。
在进入下一级之前，我建议您对上述代码进行编程，并检查您是否能够正确执行LED ON/OF序列。
由于Arduino默认LED连接引脚13，应该立即响应上述程序并开始闪烁。然而，如果你发现你的外部LED不闪烁，那么可能是你的LED连接故障，你可以尝试反转你的LED的极性，希望看到它也闪烁。
你可以通过改变“500”数字到一些其他的值来玩延迟时间，并找到LED“收听”命令，并使它按照指定的延迟值闪烁。
但请记住，如果您看到LED没有以恒定的1秒速率闪烁，无论延迟时间如何变化，这可能表明代码由于某些错误而不工作。因为默认情况下，Arduino将以1秒的闪烁速率编程。因此，此速率必须随您的代码而变化，以确认其正确工作。
1.7评论
我们理解的代码线是专门为计算机软件编写的。
然而，为了确保用户能够参考这些行的含义并理解它们，在所需的代码行旁边写解释通常是有用和明智的。
这些被称为评论这些代码仅供人类或用户参考，并经过编码使计算机能够安全地忽略它。
这些注释的语言有几种格式:
- 注释的块样式，其中注释描述包含在开始符号/*和结束符号下*/
- 这不必限制在一行中，而是可以根据注释或描述的长度扩展到下一行，如下例所示：
/*这是一个评论*/
/*这个*/也是
/*及
*这个
*为
*和* /
要为注释编写快速的单行描述，在开头两个斜杠//符号就足够了。这告诉计算机这一行与实际代码无关，必须忽略。例如:
//这是一个计算机将忽略的评论。
以下是一个供参考的示例：
/*
*程序名称：闪烁
*作者：艾伦·史密斯
*描述:
*将LED打开一半，然后反复关闭一半。
*／
/*引脚定义*/
常数int kPinLed=13；
/*
*函数名:setup
*用途：系统通电时运行一次。
*／
无效的设置()
{
pinMode (kPinLed、输出);
}
/*
*函数名:loop
*目的：只要Arduino有动力，就可以反复运行
*／
void循环（）
{
DigitalWrite（kpinled，高）;
延迟（500）；
digitalWrite (kPinLed、低);
延迟（500）；
}
1.8故障排除
如果您发现您的程序在编译时显示一个“错误”，或其他问题，以下提示可能会帮助您重新检查您的代码，以摆脱障碍。
- 你的程序语言是区分大小写的。例如表达式myvar#不能写成MyVar一样。
- 可以由键盘键盘执行的所有类型的白色空间最终呈现为单个空间，只能通过您可见或理解，计算机将不会考虑到这一点。简而言之，任何类型的免费空间对代码结果没有任何影响。
- 每个代码块都必须用左右花括号括起来，"{"和"}"
- 数字不能用逗号分隔。例如，1000不能写成1000。
- 用花括号括起来的每一行代码必须以分号结尾;
使用Arduino创建有趣的LED光线序列
在我们的前一章中，我们学习了如何在恒定延迟率下连续闪烁LED ON/OFF。
现在我们将学习如何通过升级程序代码在同一个LED上执行不同的延迟模式。
我们不会使用外部LED，而是使用Arduino板引脚13处内置的默认LED。您可以在USB接口后面找到这个微型SMD LED。
2.2理解IF语句
在本节中，我们将学习控制结构如何使我们能够运行单个代码，有时甚至可以根据需要重复运行。
该声明如果成为第一个控制结构。下面的实现展示了它是如何使用的:
常数int kPinLed=13；
无效的设置()
{
pinMode (kPinLed、输出);
}
int delayTime=1000；
void循环（）
{
delayTime=delayTime-100；
if(delayTime <= 0){//如果延迟时间小于等于零，则重置延迟时间。
延迟时间=1000；
}
DigitalWrite（kpinled，高）;
延迟（延迟时间）；
digitalWrite (kPinLed、低);
延迟（延迟时间）；
}
我们将尝试逐步理解上述代码，并了解如何将其用于其他类似的执行。
第一行和第七行之间的代码与我们最初的程序完全相似。
第一个修改发生在第8行。
int delayTime=1000；
您可以发现这与第1行的代码类似，除非它缺少术语const。
这只是因为，这段代码不是一个常量。它被定义为a变量，在编程过程中具有变量值的属性。
在上面的示例中，您可以看到这个变量的属性值为1000。记住，这些用花括号括起来的变量必须严格地只用一对花括号来写，它们被称为“局部”变量。
或者，应该在花括号外的变量，比如我们现在讨论的那个，被认为是“全局的”，并且可以在程序代码中的任何地方执行。
继续往下看，你可以看到第9行和第11行之间的代码也与第一个程序相似，尽管如此，在第11行之后，事情开始变得有趣起来。让我们看看如何！
delayTime=delayTime-100；
在这段代码中，我们看到延迟时间就是减去100。
这意味着从其初始值1000中减去100，并提供一个新的值900。
通过下图，我们将尝试理解Arduino语言中使用的一些数学运算符。
现在让我们评估第13行和第15行之间的代码。
if(delayTime <= 0){//如果延迟时间小于等于零，则重置延迟时间。
延迟时间=1000；
}
以上代码的主要目的是确保LED持续闪烁而不中断。
因为从原件中扣除了100延迟时间，它防止LED闪烁达到零，并允许持续闪烁。
下图显示了我们将在代码中使用的几个比较运算符：
在上面的代码中，我们可以测试代码是否正确if（delaytime == 0）．
然而，因为消极的数字可能同样糟糕，所以我们没有这样做，这是一个推荐的做法。
想想如果我们试着从300中扣除而不是100，结果会是什么延迟时间?
现在你可能意识到如果延迟时间写为小于或等于零，则延迟时间将设置回原始图1000。
DigitalWrite（kpinled，高）;
延迟（延迟时间）；
digitalWrite (kPinLed、低);
延迟（延迟时间）；
上面显示的最后4行代码负责打开LED ON/OFF, ON/OFF连续。
在这里，您可以清楚地注意到，我们没有使用数字，而是使用了一个变量来分配延迟时间，这样我们就可以在代码运行期间根据需要对其进行调整。这很酷，对吗？
2.3否则陈述
在这里我们将学习为什么和如何如果这个词可以有一个从句其他的这样它就能决定万一发生的情况如果这种说法是错误的。
如果这听起来太混乱了，我很抱歉，不要担心，我们会用下面的例子来理解它:
常数int kPinLed=13；
无效的设置()
{
pinMode (kPinLed、输出);
}
int delayTime=1000；
void循环（）
{
如果（delayTime<=100）{//如果它小于或等于100，则重置它
延迟时间=1000；
}
其他{
delayTime=delayTime-100；
}
DigitalWrite（kpinled，高）;
延迟（延迟时间）；
digitalWrite (kPinLed、低);
延迟（延迟时间）；
}
在上面，您可以很好地看到，在第10行代码中，只有当延迟时间小于或等于100，如果不小于或等于100，则执行第13行中的代码，但两者不能同时发生，第10行或第13行代码将被实现，不能同时执行。
您可能已经注意到，与前面2.2节中所做的不同，这里我们没有与0进行比较，而是与100进行比较。这是因为在本例中，我们比较了BEFORE(减去100)，而在2.2节中，我们比较了AFTER(减去100)。你知道如果我们比较0而不是100会发生什么吗?
2.4在语句
A.虽然语句十分相似如果声明，除了它导致重复执行到代码块（可能是在花束括号之间）的真实性，因为这种情况很长，那么这就是没有一个其他的声明。
下面的示例将帮助您更好地理解这一点
常数int kPinLed=13；
无效的设置()
{
pinMode (kPinLed、输出);
}
int delayTime=1000；
void循环（）
{
while(delayTime > 0){// while delayTime大于0
DigitalWrite（kpinled，高）;
延迟（延迟时间）；
digitalWrite (kPinLed、低);
延迟（延迟时间）；
delayTime=delayTime-100；
}
while(delayTime < 1000){// while delayTime小于1000
delayTime = delayTime + 100;//先这样做，这样我们就不会有一个delayTime = 0的循环
DigitalWrite（kpinled，高）;
延迟（延迟时间）；
digitalWrite (kPinLed、低);
延迟（延迟时间）；
}
}
你能猜出上面的代码是用来做什么的吗？嗯，它的设计是让LED闪烁的速度先快后慢。
2.5什么是真与假?
在编程语言中，假指零（0）。实际上，不使用“true”，而是假设当没有任何内容是false时，那么包含的所有内容都是true。
它看起来有点奇怪，但它做得很好。
我们将通过下面的例子来了解情况。
您有时可能会遇到以下代码：
而(1){
DigitalWrite（kpinled，高）;
延迟（100）；
digitalWrite (kPinLed、低);
延迟（100）；
}
这是编码看起来像LED的执行将永远循环，因为长功率是可用的。
然而，当用户意外地应用了=而不是==时，这种代码的一个缺点就出现了。
我相信您已经知道=表示赋值，这意味着它用于为变量指定选定的值，而a==用于在值相同时强制执行测试。
例如，假设你需要一个LED以连续和重复的速度闪烁，但错误地使用了一个=而不是==。
代码如下所示:
int delayTime=1000；
void循环（）
{
如果延迟时间=0）{//错误！！！应该是==
延迟时间=1000；
}
DigitalWrite（kpinled，高）;
延迟（延迟时间）；
digitalWrite (kPinLed、低);
延迟（延迟时间）；
delayTime=delayTime-100；
}
该错误将0分配给延迟时间，并导致如果语句来检查0是否为真。因为0指向false，它会认为它不是true，并停止执行延迟时间=1000，而是函数延迟时间在循环（）过程中保持为0。
这看起来很不可取!!
所以，一定要仔细检查你的程序，确保你没有犯过这样愚蠢的错误。
2.6组合
有时您可能会觉得需要同时测试多个东西。比如，你可能想要检查一个变量是否在两个数字之间。虽然这可以使用if语句多次实现，但使用逻辑组合可能更方便，以便更好地阅读。
可以使用3种方法实现逻辑术语的组合，如下表所示：
很有意思的是，NOT运算符可以作为变量的切换器，该变量可以指定为符合事实的或假（或低或高）。
以下示例说明了该条件：
int ledState = LOW;
void循环（）
{
ledState = ! ledState;//切换ledState的值
digitalWrite (kPinLed ledState);
延迟(1000);
}
这是莱德州将会是低的，然后尽快ledState=！ledState，它将变高。以下循环将导致莱德州高高在上ledState=！ledState价格很低。
2.7语句
现在我们将尝试了解另一种控制结构，即为环当您想多次实现某个东西时，这会非常方便。
让我们通过以下示例来理解这一点：
常数int kPinLed=13；
无效的设置()
{
pinMode (kPinLed、输出);
}
void循环（）
{
For (int I = 0;我< 4;我+ +){
DigitalWrite（kpinled，高）;
延迟(200);
digitalWrite (kPinLed、低);
延迟(200);
}
延迟(1000);/ / 1秒
}
你可以在这一行中找到一些独特的东西对。
这是密码我+ + ?．这对于那些相当懒惰并且希望通过方便快捷方式实施编码的程序员是有用的
上述术语称为复合运算符，因为它们的作用是将一个赋值运算符与另一个赋值运算符组合在一起。下表显示了其中最常用的运算符：
您会发现for语句中有3个子语句。其结构如下所示：
(语句1;条件;statement2) {
//声明
}
陈述1刚好出现在开头，而且只有一次。在循环过程中，每次都要测试条件。无论何时符合事实的在花括号内，执行后面的语句#2。万一错误的，系统跳转到下一个代码块。
连接更多LED
好的，现在我们来看看如何连接更多的LED以获得更有趣的效果。
请按照下图连接led和Arduino红色的电线实际上是不必要的，但由于它总是一个好主意，在面包板包括两个供应轨道，设置是有意义的。
现在，让我们修复一个程序，使我们能够检查硬件配置是否正确。
它总是建议编写和执行小的程序的步骤，以检查各自的硬件连接是否正确。
这有助于快速排除可能的错误。
下面的代码示例以循环方式逐个转动LED 2至5，从而为LED 2至5提供特定图案。
const int kPinLed1 = 2;
常数int kPinLed2=3；
const int kPinLed3 = 4;
常数int kPinLed4=5；
无效的设置()
{
pinMode（kPinLed1，输出）；
pinMode（kPinLed2，输出）；
pinMode（kPinLed3，输出）；
pinMode（kPinLed4，输出）；
}
void循环（）
{
//按顺序打开每个指示灯
数字写入（kPilled1，高）；
延迟（100）；
数字写入（kPilled2，高）；
延迟（100）；
数字写入（kPilled3，高）；
延迟（100）；
数字写入（kPilled4，高）；
延迟（100）；
//按顺序关闭每个led
digitalWrite (kPinLed1、低);
延迟（100）；
数字写入（kPilled2，低）；
延迟（100）；
digitalWrite (kPinLed3、低);
延迟（100）；
数字写入（kPilled4，低）；
}
您可能会注意到，代码没有任何问题，除了它看起来很长，因此容易出错。
当然，有更好的方法来编写上述代码，下面的部分将介绍它。
2.9介绍阵列
数组可以是一组可以用索引号建立索引的变量。下面的例子将帮助我们更好地理解它。
const int k_numLEDs = 4;
const int kPinLeds[k_numLEDs] = {2,3,4,5};// led连接到引脚2-5
无效的设置()
{
For (int I = 0;我< k_numLEDs;我+ +){
pinMode (kPinLeds[我],输出);
}
}
void循环（）
{
For (int I = 0;我< k_numLEDs;我+ +){
DigitalWrite（Kpinleds [i]，高）;
延迟（100）；
}
对于（int i=k_numLEDs-1；i>=0；i--）{
digitalWrite (kPinLeds[我],低);
延迟（100）；
}
}
好了，现在我们来看看每一部分，了解一下它们是如何工作的。
const int k_numLEDs = 4;
上面的代码定义了我们在数组中应该拥有的最大元素数。这段代码在后面的章节中帮助我们确保数组中的所有内容都被写入，而数组结束后什么都没有。
const int kPinLeds[k_numLEDs] = {2,3,4,5};// led连接到引脚2-5
在下一行中，我们设置了数组结构。括号内的数字表示数组中元素的数量。虽然实际的量可以写成，但写成常数更好。这些值通常可以在带逗号的方括号中看到，并将这些值指定给数组。
当您找到使用数字0索引的数组时，这表示阵列中的第一个元素，如图所示k_LEDPins是k_LEDPins[0]．
类似地，最后一个元素将显示为k_LEDPins[3]，因为从0到3的计数是4。
无效的设置()
{
For (int I = 0;我< k_numLEDs;我+ +){
pinMode (kPinLeds[我],输出);
}
}
上面的代码显示了循环的使用以进行通过每个数组元素，并将其设置为输出。我们将方括号与索引一起实现以达到数组中的每个元素。
如果你想知道是否可以在没有数组的情况下使用引脚2来引脚5，答案是肯定的，这是可能的。但在这个例子中，没有这样做，因为我们不是那样做的。在下面的章节中，如果所选的输出引脚不在一行中，您可以消除阵列方法。
接下来，让我们看看下一段代码的作用：
For (int I = 0;我< k_numLEDs;我+ +){
DigitalWrite（Kpinleds [i]，高）;
延迟（100）；
}
在这里，代码通过每个LED依次打开它们，间隔或延迟100毫秒。
对于（int i=k_numLEDs-1；i>=0；i--）{
digitalWrite (kPinLeds[我],低);
延迟（100）；
}
使用上面的代码展示了for循环可以用来以相反的顺序在循环中移动。
它开始从k_numLEDs - 1因为阵列归零索引。我们没有开始k_LEDPins[4]因为这会导致穿越数组的终点。
代码使用> = 0来检查，以便不会错过或忽略索引0处的第一个元素。
第三章
什么是输入
我们也学会了如何使用Arduino操作东西。在这一章中，我们将讨论如何通过接口外部参数的输入来感知真实世界。
3.1使用按钮
我们都知道按钮是什么以及它是如何工作的。它是一种开关或按钮，当信号处于抑制状态时，将信号从一个电路级瞬间连接到另一个电路级，释放时将信号断开。
3.1.1一键+一LED
按照上面展示的细节，我们将Arduino与一个按钮连接起来，并学习设置的基本工作和实施。
所指示的按钮也称为微开关按钮，共有4个引脚(每侧2对)。当推动时，每对引脚内部连接和使一个连接或传导通过他们。
在本例中，我们仅使用一对插脚或触点，另一对不相关，因此被忽略。
让我们继续应用下面的代码并检查它是否工作！
常数int kPinButton1=2；
const int kPinLed = 9;
无效的设置()
{
引脚模式（kPinButton1，输入）；
digitalWrite (kPinButton1、高);//打开上拉电阻
pinMode (kPinLed、输出);
}
void循环（）
{
if（数字读取（kPinButton1）=低）{
DigitalWrite（kpinled，高）;
}
其他{
digitalWrite (kPinLed、低);
}
}
你可能会发现一些不寻常的事情。让我们逐步解决它们。
无效的设置()
{
引脚模式（kPinButton1，输入）；
digitalWrite (kPinButton1、高);//打开上拉电阻
pinMode (kPinLed、输出);
}
我们要做的第一件事就是修理机器钮扣作为输入。我知道，这很基本。
接下来,我们分配高的到输入别针。你是一个奇迹，如何在输入时写任何东西？当然，这可能是有趣的。
实际上，为Arduino输入指定一个高电平会打开内部20k欧姆的上拉电阻器（该引脚上的低电平会关闭）。
你们可能会问的另一个问题是什么是上拉电阻器。我已经涵盖了一篇关于上拉电阻器的综合文章，你们可以从中了解到在这里学习．
好的，继续，现在让我们看看主循环代码:
void循环（）
{
if（数字读取（kPinButton1）=低）{
DigitalWrite（kpinled，高）;
}
其他{
digitalWrite (kPinLed、低);
}
}
当你按下按钮，电线引脚连接到地，这将呈现一个低的当处于未加压状态时，相同的销保持在高的或通过20K内部上拉电阻器+5V。
在这里，我们希望Arduino在按下按钮（低）时点亮LED，因此在按下按钮时，我们为按钮的每个低响应的输出写入高。
3.1.2两个按钮和一个LED
好吧，你可能会想，上面显示的动作也可以没有Arduino完成。我明白，但这是一个学习如何使用按钮与Arduno。
在此之前，我们已经学习了为LED开关ON (HIGH)或开关OFF (LOW)编写代码。
现在让我们来看看Arduino如何控制LED的亮度。
可以使用两种方法:
- 通过限制LED的电流量
- 利用脉宽调制或脉冲宽度调制，其中LED的电源以某个期望的速率非常快速地打开/关闭，产生平均照明，其强度取决于PWM。
在Arduino电路板中，在标有波浪号（~）的引脚上提供PWM支持，这些引脚是500Hz（每秒500次）下的引脚3、4、5、9、10和11）。用户可以提供0到255之间的任何值，其中0表示不高或不+5V，255告诉Arduino始终获得高或+5V。要启动这些命令，必须使用所需的值访问analogWrite（）。
你可以假设PWM是x/255，其中x是你想要发送的期望值模拟写入（）．
如上图所示设置Arduino等参数。
常数int kPinButton1=2；
const int kPinButton2 = 3;
const int kPinLed = 9;
无效的设置()
{
引脚模式（kPinButton1，输入）；
引脚模式（kPinButton2，输入）；
pinMode (kPinLed、输出);
digitalWrite (kPinButton1、高);//打开上拉电阻
数字写入（kPinButton2，高）；//打开上拉电阻器
}
int led亮度= 128;
void循环（）
{
if（数字读取（kPinButton1）=低）{
LED亮度--；
}
否则如果（数字读取（kPinButton2）=低）{
ledBrightness + +;
}
LED亮度=约束（LED亮度，0，255）；
analogWrite (kPinLed ledBrightness);
延迟(20);
}
你可能会发现这里有3行需要解释。
LED亮度=约束（LED亮度，0，255）；
25 analogWrite (kPinLed ledBrightness);
26日延迟(20);
线:LED亮度=约束（LED亮度，0，255）；说明了Arduino中名为CONSTRAINT（）的唯一函数。
该内部功能包含类似于以下内容的代码：
约束(Int value, Int min, Int max){
如果值> max) {
值=最大值；
}
如果(价值< min) {
值=最小;
}
返回值；
}
在此之前讨论的所有规范均始于无效的，这意味着不返回任何内容(void)。而上面的代码以int，这表示它返回一个整数。我们将在后面的部分中详细讨论，现在只需记住整数没有任何小数部分。
对，所以这意味着，代码：LED亮度=约束（LED亮度，0，255）；分配的LED亮度应在0和255之间．
下一行是analogWrite命令Arduino以具有所需值的选定引脚对选定PWM应用。
下一行创建了20毫秒的延迟，这是为了确保我们调整进食的速度不会超过50赫兹或每秒50次。这是因为人类可以比Arduino慢得多。因此，如果没有延迟，程序会让我们觉得按下第一个按钮就关闭了LED，按下第二个按钮就打开了LED(自己试一下确认)。
3.2电位计
让我们继续前进，学习如何使用带有Arduino的电位计。
要知道电位器或花盆是如何工作的，你可以阅读这个文章．
如上所示，将所示参数与Arduino连接。
一个pot将有3个端子。中间端子ASL将连接Arduino上的模拟输入0。其他两个外部端子可连接到+5V和0V电源轨。
让我们编写程序并检查结果:
const int kPinPot = A0;
const int kPinLed = 9;
无效的设置()
{
pinMode（kPinPot，输入）；
pinMode (kPinLed、输出);
}
void循环（）
{
int ledBrightness;
int sensorValue = 0;
sensorValue = analogRead (kPinPot);
LEDBrightness = MAP（SensorValue，0,1023,0,255）;
analogWrite (kPinLed ledBrightness);
}
你会发现一些东西看起来是全新的，没有包含在我们以前的代码中。
- 常数
kPinPot被指定为A0，其中A是描述其中一个模拟管脚的快捷方式。但是A0也指管脚#14、A1到管脚#15等等，这样可以在实验管脚用完时用作数字输入/输出。但请记住，不能将数字管脚用作模拟管脚。 - 线:
LEDBrightness = MAP（SensorValue，0,1023,0,255）;在Arduino中提供了一个新的内部函数，称为map()。这个功能从一个给定的范围重新校准到另一个范围，称为映射（值、从低到高、从低到高、从低到高）。这可能变得至关重要，因为Analmueread.给出0-1023范围内的值，但是analogWrite能够接受0-255范围内的值。
你可能会想，既然可以通过改变电阻来控制LED的亮度，那么一个罐子就足够了，为什么要使用Arduino呢。再一次，它仅仅是基础，展示一个罐子可以用一个阿杜伊诺配置。
没有问题，现在我们将做一些没有Arduino就做不到的事情。
在这个实验中，我们将看到一个电位器的可变电阻如何用于控制LED的闪烁速度或速率。
程序是这样的:
const int kPinPot = A0;
const int kPinLed = 9;
无效的设置()
{
pinMode (kPinLed、输出);
}
void循环（）
{
int sensorValue;
sensorValue = analogRead (kPinPot);
DigitalWrite（kpinled，高）;
延迟(sensorValue);
digitalWrite (kPinLed、低);
延迟(sensorValue);
}
3.2.3避免延误（）
上面的代码看起来不错，但LED在每个完整周期内都无法检查pot值。由于延迟时间较长，用户在移动pot时必须等待更长的时间才能看到pot响应。这种延迟可以通过一些智能编程来避免，因此它允许用户在没有最小延迟的情况下检查值。她这是密码。
const int kPinPot = A0;
const int kPinLed = 9;
无效的设置()
{
pinMode (kPinLed、输出);
}
长时间=0；
int ledvalue =低;
void循环（）
{
int sensorValue;
sensorValue = analogRead (kPinPot);
if(millis() > lastTime + sensorValue){
if（LEDValue ==低）{
ledValue=高；
}
其他{
ledValue=低；
}
lastTime=millis（）；
digitalWrite (kPinLed ledValue);
}
}
那么上面的代码有什么不同呢?下面这一行就会产生区别。
长时间=0；
在本节之前，我们已经讨论了变量int。但是，您可以访问更多类型的变量。列表如下：
目前，对于存储相对较大的数据来说，只有知道这一点才是至关重要的int变量，您可以使用长的或者一个长整型。
在这里，您可以看到另一个有趣的函数，名为米利斯（）。
这将产生Arduino从一开始就在其运行过程中工作的时间跨度（每50天后将重置为0）。这里它返回一个long，因为如果它返回int在美国，长时间计算可能是不可能的。你能准确地回答多久吗?答案是32.767秒。
因此，我们不使用delay()，而是检查millis()，一旦特定的毫秒数过了，我们就改变LED。因此，我们将上次修改的时间存储在内存中lastTime变量，因此它允许我们在需要时再次检查它。
3.3 RGB发光二极管
到目前为止，我们一直在玩单一颜色的LED。虽然LED的颜色可以通过替换LED的另一种颜色来改变，但是使用RGB LED怎么样呢改变LED颜色不更换LED灯？
一个RGB LED基本上是一个LED有一个红色，绿色和蓝色LED嵌入和合并成一个单一的LED。它有一个公共引线，它去地或0V电源轨，而其他3引线馈电多样化的PWM正信号，以实现预期颜色混合．
您可以按如下方式连线设置:
它可能看起来有点复杂，但实际上它是我们早期使用PWM的LED控制设计的复制品。
这里有一个练习程序代码:
const int kPinPot1 = A0;
const int kPinPot2 = A1;
const int kPinPot3 = A2;
常数int kPinLed_R=6；
const int kPinLed_G = 10;
常数int kPinLed_B=11；
无效的设置()
{
pinMode（输入、输出）；
pinMode (kPinLed_G、输出);
pinMode（kPilled_B，输出）；
}
void循环（）
{
int potvalue;
智力价值；
potValue = analogRead (kPinPot1);
map(potValue, 0, 1023, 0, 255);
模拟写入（kPilled_R，ledValue）；
potValue=analogRead（kInput2）；
map(potValue, 0, 1023, 0, 255);
模拟写入（kPilled_G，ledValue）；
potValue = analogRead (kPinPot3);
map(potValue, 0, 1023, 0, 255);
模拟写入（kPilled_B，ledValue）；
}
上传此代码后，只需了解罐调整如何为RGB创造有趣的光线影响，这可能是一个真正的乐趣。
你会发现，当所有3个罐子都移动到最大位置时，你会看到红色，而不是白色。这是因为红色是3种颜色中最突出的颜色，因此在这种情况下占主导地位。不过，你可以尝试这个功能地图（），然后再执行到LED的红色部分，以创建更合理的平衡。
音频与Arduino
在本节中，我们将学习如何将基本的声音和音乐添加到Arduino设置中。
我们将看到如何将信号切换到具有所需频率的连接扬声器。
更准确地说，将尝试中间a音符，即频率为440 Hz的音符。
为了做到这一点，我们将简单地播放一个中间的a音符，并用方波优化正弦波信号。
此外，我们将通过起诉公式计算扬声器可以保持的时间量：
时间延迟=1秒/2 x音调频率。
timedelay = 1秒/ 2 x 440
时间延迟=1136微秒
4.1连接Arduino板
4.2添加一个简单的纸币
我们已经讨论了这个功能延迟（）当单位为毫秒（秒/1000）时，您将发现另一个函数延迟微秒（）其中单位为微秒（毫秒/1000）。
对于当前设置，我们编程一个代码，以每秒440个脉冲的速率在与扬声器相连的选定引脚上打开/关闭+5V。
回想一下，在上次讨论中，我们确定了音频音符的值为1136微秒。
这是一个程序，它可以让你在连接扬声器的情况下对arduino进行编程后，立即听到440 Hz的音频提示。
const int kPinSpeaker = 9;
const int k_timeDelay = 1136;
无效的设置()
{
pinMode（kPinSpeaker，输出）；
}
void循环（）
{
digitalWrite (kPinSpeaker、高);
delayMicroseconds (k_timeDelay);
数字写入（kPinSpeaker，低电平）；
delayMicroseconds (k_timeDelay);
}
使用上述应用程序可以制作音频备忘，这也意味着我们可以根据自己的选择制作音乐。
从我们理解的代码中，Arduino包含几个集成功能，该功能还有助于创建音乐。
第一个是语气（）与2个元素一起使用，以及3rd可选元素，指定为音调（pin、频率、持续时间）。或音调（pin、频率）
两者都被指定执行您指定的各自时间段。
如果没有时间段，音乐将继续播放，直到通话结束语气（）是再次执行，还是直到执行为止能()。
这需要使用延迟函数来完成，因为音乐播放是你执行的唯一基本内容。
持续时间可能是至关重要的，因为它允许提供音乐播放的时间，所以你可以自由地做其他事情。当持续时间一过，音乐就停止了。
下一个函数诺通（）处理单个参数并在指定的特定管脚上停止所选音调。
一个特别的警告:任何时候语气（）功能执行后，针脚3和11上的PWM功能将停止工作。
因此，无论何时在程序中使用扬声器附件，请确保不要为扬声器使用上述引脚，而是尝试为扬声器附件使用其他引脚。
这是一个在扬声器上实现音乐的程序，虽然它不是一个真正的音乐，而是一个基本音阶的C音符。
#定义注释_C4262
#定义NOTE_D4 294
#定义NOTE_E4 330
#定义NOTE_F4 349
#定义注释4 392
#定义NOTE_A4 440
#定义注释4 494
#定义注释_C5523
const int kPinSpeaker = 9;
无效的设置()
{
pinMode（kPinSpeaker，输出）；
}
void循环（）
{
语调(kPinSpeaker NOTE_C4 500);
延迟（500）；
音调（kPinSpeaker，音符4，500）；
延迟（500）；
音调（kPinSpeaker，注4，500）；
延迟（500）；
音调（kPinSpeaker，音符F4，500）；
延迟（500）；
音调（kPinSpeaker，音符4，500）；
延迟（500）；
音调（kPinSpeaker，音符A4，500）；
延迟（500）；
音调（Kpinspeaker，Note_b4,500）;
延迟（500）；
音调（kPinSpeaker，音符C5500）；
延迟（500）；
诺通（克宾斯派克）；
延迟（2000年）；
}
在上面的代码中，您可能已经注意到了新的东西#定义．
当编译完成时，这个术语就像计算机的搜索和替换命令。
每当它找到空格前的第一项内容时，就用该行的其余部分(称为宏)替换它。
在这个例子中，当电脑看到附注4它很快就以330的数量取代了它。
有关更多说明和自定义信息，请参考U盘中名为pitches.h，其中大部分频率可供您选择。
4.4带功能的音乐
上面的代码看起来很好，但似乎有很多重复，应该有一些方法来缩短这些重复，对吗?
到目前为止，我们已经使用了Arduino包含的两个基本功能。现在是时候创建我们自己的函数了。
每个函数必须以它可能关联的变量的类型开始。例如函数无效的指不返回任何内容的类型，因此命名为void。注意，我们已经在前面的小节中讨论了变量列表，您可能想要引用它们。
因此，特定的函数名会得到一个开括号"("其次是逗号分隔参数列表。
每个参数都会获取其类型以及名称，最后是结束符“)”括号。
这些参数可以以变量的形式应用于函数中。
下面我们来看一个例子，其中我们开发了一个名为ourTone ()旨在合并语气（）和延迟（）行，函数停止返回，直到音符完成音调播放。
我们在前面的代码中实现了这些函数，并获得以下程序，请参见最后几行：
#定义注释_C4262
#定义NOTE_D4 294
#定义NOTE_E4 330
#定义NOTE_F4 349
#定义注释4 392
#定义NOTE_A4 440
#定义注释4 494
#定义注释_C5523
const int kPinSpeaker = 9;
无效的设置()
{
pinMode（kPinSpeaker，输出）；
}
void循环（）
{
语调(kPinSpeaker NOTE_C4 500);
延迟（500）；
音调（kPinSpeaker，音符4，500）；
延迟（500）；
音调（kPinSpeaker，注4，500）；
延迟（500）；
音调（kPinSpeaker，音符F4，500）；
延迟（500）；
音调（kPinSpeaker，音符4，500）；
延迟（500）；
音调（kPinSpeaker，音符A4，500）；
延迟（500）；
音调（Kpinspeaker，Note_b4,500）;
延迟（500）；
音调（kPinSpeaker，音符C5500）；
延迟（500）；
诺通（克宾斯派克）；
延迟（2000年）；
}
无效音调（整数频率，整数持续时间）
{
音调（kPinSpeaker、频率、持续时间）；
延迟(持续时间);
}
函数可以非常方便地使程序更容易理解。
下面是一个例子，我们可以使用两个数组指定要播放的音调的选择。一组保留音符，另一组保留节拍。
# include“pitches.h”
int kPinSpeaker = 9;
#定义NUM_注释15
const int notes[NUM_notes]=//0表示一个rest
{
注4，注4，注4，注4，注4，
Note_a4, Note_a4, note_g4, note_f4，
Note_f4, note_e4, note_e4, note_d4，
NOTE_D4 NOTE_C4 0
};
const int beats[NUM_NOTES] = {
1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 2, 4 };
Const int beat_length = 300;
无效的设置()
{
pinMode（kPinSpeaker，输出）；
}
void循环（）
{
对于（int i=0；i
延迟(节拍[我]* beat_length);/ /其他
}
否则{
ourTone(notes[i]， beats[i] * beat_length);
}
//在音符之间停顿
诺通（克宾斯派克）；
延迟(beat_length / 2);
}
}
无效音调（整数频率，整数持续时间）
{
音调（kPinSpeaker、频率、持续时间）；
延迟(持续时间);
}
你可以清楚地看到第一行的介绍＃包括语句。此语句的任务是在引号之间拾取整个文件，并将其放置在＃包括声明。根据标准规则，这些严格放在课程开始时。
第五章
测量温度
回想一下，记住不要完全编写大型程序，编写和分析代码的小部分总是明智的，这有助于快速跟踪错误。
5.1串行监视器
到目前为止，我们讨论的代码似乎并没有那么容易实现快速故障排除。在这里，我们将尝试使监控更容易，并更容易解决可能出现的问题。
Arduino有一个功能，可以与电脑“对话”。您可能会观察到pin0和pin1彼此旁边被标记为RX和TX。这些引脚实际上是由Arduino内部的一个独立IC跟踪的，Arduino升级它们，在连接到PC的USB数据线上读取。
下面一节展示了一个完整的程序，请阅读它，我们将在之后了解代码中的新条目。这段代码与2.2节中表达的代码相同，除了它包含一些额外的数据，以允许我们识别编码的目的。
常数int kPinLed=13；
无效的设置()
{
pinMode (kPinLed、输出);
Serial.begin（9600）；
}
int delayTime=1000；
void循环（）
{
delayTime=delayTime-100；
如果（delayTime<=0）{//如果它应该是零或更小，则重置它。
延迟时间=1000；
}
Serial.print（“delayTime=”）；
Serial.println（延迟时间）；
DigitalWrite（kpinled，高）;
延迟（延迟时间）；
digitalWrite (kPinLed、低);
延迟（延迟时间）；
}
你可以在这里发现两个新东西，在设置()功能。
Serial.begin（9600）；
这一行简单地表达了使用Serial1以9600波特值执行它的代码。这里serial指的是位一个接一个地发送，波特率表示发送的速率）。此波特率值和串行监视器内的波特率值（我们将在后面了解）必须相等，否则串行监视器中的数据将显示垃圾。9600作为标准，使用起来更加方便。
第二个新条目如下：
Serial.print（“delayTime=”）；
Serial.println（延迟时间）；
在这里，第二行表明从串口出来的后续物品将从下一行开始。这就是第二行与拳头线不同的方式。
你还可以看到引号(")。这被称为字符串，在这里只像常量一样使用，因为对这个主题的进一步讨论可能过于复杂，超出了范围。
好的，我们现在可以上传上面的代码到Arduino，看看会发生什么。
哎呀，似乎什么都没发生，Arduino pin#13 LED闪烁并停止，而Tx LED一直闪烁。
这是因为串行监视器窗口还没有修复。
如上图所示，您需要单击IDE中的串行监视器框。请不要忘记检查位于右下角的波特率，默认情况下波特率应为9600，并将与代码匹配。如果不匹配，请确保选择9600。
下面的视频剪辑解释了如何进行。
现在让我们前进，了解上述串行监视器功能如何帮助处理使用Arduino测量温度
我们将使用IC TMP36作为温度传感器，温度范围为-40到150摄氏度。
设置如下所示:
下面的代码将通过读取TMP36传感器的输出来开始温度测量，并将它们发送到ID的串行监视器。
const int kPinTemp = A0;
无效的设置()
{
Serial.begin（9600）；
}
void循环（）
{
浮动温度c=getTemperatureC（）；
连续打印（温度）；
串行打印项次（“摄氏度”）；
//现在转换成华氏温度
FLOAT温度= CONVERTTOF（锻炼）;
连续打印（温度f）；
系列。println(“度”);
延迟（500）；
}
浮点数getTemperatureC（）
{
int read = analogRead(kPinTemp);
浮动电压=(读数* 5.0)/ 1024;
//转换从10 mv每度与500mV偏移
//到度((电压- 500mV) * 100)
返回（电压 - 0.5）* 100;
}
浮动convertToF (temperatureC浮动)
{
返回（温度C*9.0/5.0）+32.0；
}
让我们从头开始理解代码。
浮动温度c=getTemperatureC（）；
在这里您可以看到，我们已经包含了变量类型浮动
这是唯一的变量类型，它的特点是存储除整数(没有小数或小数部分的数字)以外的所有数字。
浮点变量的精度可达6到7位。
临近的代码getTemperatureC（）是我们自己的函数，它用数学方法计算并将从TMP36传感器感知到的电压差转换为摄氏度。
浮点数getTemperatureC（）
{
int read = analogRead(kPinTemp);
浮动电压=(读数* 5.0)/ 1024;
//转换从10 mv每度与500mV偏移
//到度((电压- 500mV) * 100)
返回（电压 - 0.5）* 100;
}
在代码的下一节中，由于类比素（）如果指定返回一个介于1到1023之间的数字，我们就可以通过将读数乘以5，然后除以1024来评估传感器的电压。
该传感器TMP36被指定在0摄氏度时产生0.5V，随后每摄氏度上升一次就产生10mV。
以下是我们通过计算得出的近似值：
您可以认为是第一个函数，它返回一些值（注意到所有剩余的函数至今没有返回任何值，因为它们是类型的）。无效的)．
您可以理解，为了从函数中获得值，只需添加即可回来后跟要返回的所需数字。
当我们说回来这意味着无论何时调用该函数，该函数都会返回一个响应或回复，这可以应用于变量。
当它被发送到串行监视器时，读数通过convertToF（）。
浮动convertToF (temperatureC浮动)
{
返回（温度C*9.0/5.0）+32.0；
}
此函数用于拾取摄氏度范围并将其转换为华氏度。
为了将华氏温度转换为摄氏温度，我们实现了这个公式华氏温度=9/5摄氏度+32摄氏度。
5.3液晶显示器的接口
现在让我们学习如何连接一个液晶显示器使用Arduino实现所需输出的可视化显示。
在我们的应用中，我们将采用84x48图形LCD，其水平分辨率为84像素或点，垂直分辨率为48像素。由于所有LCD都需要专用控制器，因此目前的设备还包括一个PCD8544控制器。
在本教程中，我们将使用Arduino连接上述指定的LCD模块，并应用某些例程在显示屏上创建文本消息。
在下图中，您可以找到有关LCD接口的详细信息，以及一个小屏幕3.3V电压调节器．这种调节器是必要的，因为液晶显示器是规定工作在3.3V电源。
您还可以从LCD模块中看到8个引脚，从下表中可以研究引脚钻头规格：
现在，让我们看看如何将LCD和相关参数与我们的Arduino连接起来。下图显示了详细信息：
5.4与LCD的通信
虽然可以用来自Arduino的液晶显示器编写精细的衣物，但我们宁愿学习如何使用库做同样的事情。
库由各种各样的代码组成，可以快速应用于选定的Arduino程序。
这使用户能够轻松地调用函数而无需通过复杂的编码工作。
5.4.1如何安装库
为此，您必须在计算机Arduino IDE中创建一个名为libraries的目录，如前所述在这里
5.4.2实现LCD操作
正如我们前面的方法一样，我们将首先检查整个代码，然后尝试了解各行的细节。
#include
常数int kPin_CLK=5；
常数int kPin_DIN=6；
常数int kPin_DC=7；
常数int kPin_RESET=8；
PCD8544液晶显示器（kPin_时钟、kPin_DIN、kPin_直流、kPin_复位）；
无效的设置()
{
lcd.init ();
lcd.setCursor (0,0);
液晶打印("Hello, World!");
}
void循环（）
{
lcd.setCursor（0,1）；
lcd.print(米尔斯());
}
该行包括代码#include
代码#include指示PC拾取上述文件，并在程序编译过程中用文件内容替换#include元素。
#include元素可以具有尖括号，表示在库目录中搜索，也可以具有引号，表示在程序所在的同一目录中搜索。
随后的代码行表示LCD引脚，然后我们编写一种新形式的变量：
PCD8544液晶显示器（kPin_时钟、kPin_DIN、kPin_直流、kPin_复位）；
在这里，我们用名称为lcd的变量来表示类型为PCD8544的变量，并指示PC重新调整与Arduino相关联的pinout。
在这个过程中，我们通过指示pin clk、din、dc和reset如何与Arduino接口来向PC描述变量。
无效的设置()
{
lcd.init ();
lcd.setCursor (0,0);
液晶打印("Hello, World!");
}
这条线lcd.init ();初始化LCD操作。一旦执行此操作，下一行将在显示屏的左上角强制执行光标。下一行将努力打印消息“Hello，World”。
这与我们在串行监视器上发送消息的技术相同。唯一的区别是使用代码液晶打印代替并。
实际上重复调用下一个代码块。
void循环（）
{
lcd.setCursor（0,1）；
lcd.print(米尔斯());
}
用这条线lcd.setCursor（0,1）；在LCD显示屏上，我们将光标固定到第1行左侧的第0列。
下一行使用快捷方式：lcd.print(米尔斯());
如果你还记得我们合作过的米利斯（）在我们之前的代码中，我们也可以通过代码在这里应用相同的代码：
长numillis=millis（）；
lcd.打印（numMillis）；
然而，由于这里不涉及毫秒的时间段，因此我们只需发送米利斯（）直接作用于lcd.print（）．
5.5将整件事结合起来
好的，现在让我们结合上面学习的所有代码来制作LCD温度电路，让我们看看它的外观：
#include
常数int kPin_CLK=5；
常数int kPin_DIN=6；
常数int kPin_DC=7；
常数int kPin_RESET=8；
const int kPin_Temp = A0;
PCD8544液晶显示器（kPin_时钟、kPin_DIN、kPin_直流、kPin_复位）；
无效的设置()
{
lcd.init ();
lcd.setCursor (10 0);
液晶显示。打印（“温度：”）；
}
void循环（）
{
浮动温度c=getTemperatureC（）；
//现在转换成华氏温度
FLOAT温度= CONVERTTOF（锻炼）;
lcd.setCursor(21日1);
lcd.print (temperatureC);
液晶打印(" C");
lcd.setCursor（21,2）；
lcd.print (temperatureF);
液晶打印(" F");
延迟（100）；
}
浮点数getTemperatureC（）
{
int read = analogRead(kPin_Temp);
浮动电压=(读数* 5.0)/ 1024;
//转换从10 mv每度与500mV偏移
//到度((电压- 500mV) * 100)
返回（电压 - 0.5）* 100;
}
浮动convertToF (temperatureC浮动)
{
返回（温度C*9.0/5.0）+32.0；
}
在上面的程序中，除了函数的使用之外，所有内容看起来都是标准的setCursor（）. 这用于将文本尽可能围绕显示屏中心对齐。
太好了！恭喜你，你刚刚用Arduino为自己的小LCD温度指示器编程。
实用Arduino应用
既然我们已经全面详细地介绍了各种编程技术，现在是时候通过将它们应用到一些有用的实际实现中来测试它们了。
我们将从传感器开始，通过执行一些示例代码，了解传感器设备如何与Arduino一起使用。
7.1传感器简介
在本教程中，我们将学习Arduino中可以使用的各种传感器。这些设备可能包括光传感器LDR，磁霍尔效应传感器，倾斜传感器，振动传感器，压力传感器等。
我们将从的接口开始光传感器对于Arduino，如下图所示：
众所周知，LDR是一种依赖于光的电阻器件，其电阻取决于环境入射到其表面的强度。
光的强度与LDR的电阻读数成反比。
在这里，我们将了解如何将此属性与Arduino集成以执行有用的应用程序：
完整的程序代码可以可视化，如下所示：
常数int kPin_光电管=A0；
无效的设置()
{
Serial.begin（9600）；
}
void循环（）
{
int值=模拟读数（kPin_光电管）；
串行打印（“模拟读取=”）；
并同时(价值);
如果（值<200）{
系列。println(”——黑暗”);
}否则如果（值<400）{
系列。println(“暗淡”);
}
否则如果（值<600）{
系列。println(”——光”);
}
否则if（value <800）{
Serial.println（“-Bright”）；
}
其他{
serial.println（“ - 非常明亮”）;
}
延迟(1000);
}
代码中使用的所有参数都已经在我们的课程中讨论过了，我们已经学习过了。您可以参考相关章节检查代码行。
这些值是随机选择的，您可以根据自己的喜好轻松更改。
倾斜传感器
倾斜传感器是一种简单的装置，可用于检测安装在其上的任何物体上的倾斜动作。该装置基本上内部有一个金属球，在倾斜时，金属球在一对触点上滚动，导致这些触点之间传导。这些触点作为倾斜开关的引线端接，与外部电路一起使用它用于检测由于倾斜动作而产生的传导，并激活所需的输出应用程序。
现在让我们来看看倾斜传感器这个装置可以接线。下图为我们提供了有关完整配置的想法：
const int kPin_Tilt = 3;
常数int kPin_LED=13；
无效的设置()
{
pinMode（kPin_倾斜，输入）；
数字写入（kPin_倾斜，高）；//打开内置上拉电阻器
pinMode（kPin_发光二极管，输出）；
}
void循环（）
{
如果（数字读取（kPin_倾斜）=高）{
digitalWrite (kPin_LED、低);
}
其他{
数字写入（kPin_发光二极管，高电平）；
}
}
在本例中，默认引脚#13 LED用作倾斜指示器。
您可以清楚地看到在这里包含上拉电阻，我们在第3.1节中所做的相似。因此，术语低表示未触发倾斜函数。
7.4簧片开关继电器（微型磁激活继电器）
现在让我们看看如何用Arduino连接继电器开关或磁场传感器。簧片继电器是一种开关，当磁场或磁铁靠近它时，它会激活或传导。基本上，它在一个微型玻璃外壳内有一对铁磁触点，每当磁铁移动时，通过磁拉力连接或接触tic离它很近。当这种情况发生时，由于触点闭合，触点的端子显示导通。
这里我们也使用引脚#13 LED来指示响应。根据我们之前的解释，如果需要，你可以从这个引脚连接一个外部LED。
常数int kPinReedSwitch=2；
常数int kPinLed=13；
无效的设置()
引脚模式（kPinReedSwitch，输入）；
digitalWrite（kPinReedSwitch，高）；//打开上拉电阻器
pinMode (kPinLed、输出);
}
void循环（）
{
if（数字读取（kPinReedSwitch）=低）{
DigitalWrite（kpinled，高）;
}
其他{
digitalWrite (kPinLed、低);
}
}
代码术语应该是熟悉的和自解释的。
7.5使用压电传感器的振动传感器
在下一个示例程序中，我们将看到压电换能器可作为振动传感器，通过Arduino照亮LED。
压电元件实际上是一种当一个频率作用于其两端时产生振动或振荡的装置。然而，同样的压电可以用于反过程产生电脉冲对施加在其身上的振动作出响应。这种振动可能以敲击或撞击压电元件表面的形式出现。
按照下图设置Arduino和压电元件
const int kPinSensor = A5;
常数int kPinLed=13；
Const int k_threshold = 100;
int-ledState=低；//用于存储最后一个LED状态的变量，用于切换灯
无效的设置()
{
pinMode (kPinLed、输出);//将ledPin声明为OUTPUT
}
void循环（）
{
int val=模拟读数（kPinSensor）；
if（val> = k_threshold）{
ledState = ! ledState;//切换ledState的值
digitalWrite (kPinLed ledState);
延迟（20）；//用于去抖动
}
}
引入100阈值只是为了确保Arduino只对敲打产生的真实振动做出反应，而不是其他更小的振动，比如响亮的声音或喇叭声。
A5引脚的选择不是强制性的，您可以选择任何其他模拟输入，根据您的偏好，并通过匹配它在程序代码。
使用Arduino伺服电机
伺服电机是一种直流电动机，它可以根据特定应用的需要旋转到精确的角度。它可以通过应用一个计算命令的相关输入的电机产生一个准确的旋转或旋转角度在180度范围内的电机。
通常，伺服电机有3条导线或输入。正极导线通常为红色，负极或接地线为黑色，而命令线或信号线通常为白色或黄色。
Arduino内置支持语言，方便伺服电机控制，使伺服电机控制非常方便和理想。
以下示例将向我们展示通过Arduino实现伺服电机控制的基本设置程序：
代码如下：
#包括
伺服伺服1；
const int kPinPot = A0;
const int kPinServo1 = 9;
无效的设置()
{
servo1.attach (kPinServo1);
}
void循环（）
{
int val = analogRead(kPinPot);
val =地图（Val，0,1023,0,180）;
伺服1.写入（val）；
延误（15）；
}
我们可以在这里看到一些新的条目。一个告诉附加的电线伺服是什么引脚它被分配。另一个是代码，它为引脚提供0到180之间的值，用于确定伺服上的旋转角度。
结论
Arduino主题可能非常长，因此超出了本文的范围。但是，我希望以上教程一定能够帮助您学习Arduino的基本知识，并通过各种示例应用程序代码理解重要的参数。
希望更多的信息可以随时在这里更新，只要它是可用的。
与此同时，享受您的编程课程，快乐arduinoing给您！
