快捷搜索：  汽车  科技
当前位置： 爱玩科技 > 生活 > 正文

arduino编程学习心得（arduino学习笔记分享）

小君 838

arduino编程学习心得（arduino学习笔记分享）以上为基础c语言的关键字和符号，有c语言基础的都应该了解其含义，这里也不作过多的解释。/******************************************/为什么要使用Arduino？有很多的单片机和单片机平台都适合用做交互式系统的设计。例如：Parallax Basic Stamp， Netmedia’s BX-24，Phidgets，MIT’s Handyboard 和其它等等提供类似功能的。 所有这些工具，你都不需要去关心单片机编程繁琐的细节，提供给你的是一套容易使用的工具包。 Arduino同样也简化了同单片机工作的流程，但同其它系统相比Arduino在很多地方更具有优越性，特别适合老师，学生和一些业余爱好者们使用：在与Arduino DIYER接触的这段时间里，发现有些朋友对Arduino语言还是比较难入手，那么这里我就简单的注释一下Arduino语言（本人也是

字节跳动

Arduino学习笔记1 - 什么是arduino？

要了解arduino就先要了解什么是单片机，arduino平台的基础就是AVR指令集的单片机。
1、什么是单片机？它与个人计算机有什么不同？
一台能够工作的计算机要有这样几个部份构成：中央处理单元CPU（进行运算、控制）、随机存储器RAM（数据存储）、存储器ROM（程序存储）、输入/输出设备I/O（串行口、并行输出口等）。在个人计算机（PC）上这些部份被分成若干块芯片，安装在一个被称之为主板的印刷线路板上。而在单片机中，这些部份全部被做到一块集成电路芯片中了，所以就称为单片（单芯片）机，而且有一些单片机中除了上述部份外，还集成了其它部份如模拟量/数字量转换（A/D）和数字量/模拟量转换（D/A）等。


2、单片机有什么用？
实际工作中并不是任何需要计算机的场合都要求计算机有很高的性能，一个控制电冰箱温度的计算机难道要用酷睿处理器吗？应用的关键是看是否够用，是否有很好的性能价格比。如果一台冰箱都需要用酷睿处理起来进行温度控制，那价格就是天价了。
单片机通常用于工业生产的控制、生活中与程序和控制有关（如：电子琴、冰箱、智能空调等）的场合。
下图就是一个Atmega328P-PU单片机，基于AVR指令集的8位处理器，频率20MHz，存储器空间32KB。

arduino编程学习心得（arduino学习笔记分享）(1)


什么是Arduino？
Arduino是一个能够用来感应和控制现实物理世界的一套工具。 它由一个基于单片机并且开放源码的硬件平台，和一套为Arduino板编写程序 的开发环境组成。
Arduino可以用来开发交互产品，比如它可以读取大量的开关和传感器信号，并且可以控制各式各样的电灯、电机和其他物理设备。Arduino项目可以是单独的，也可以在运行时和你电脑中运行的程序（例如：Flash，Processing，MaxMsP）进行通讯。Arduino板你可以选择自己去手动组装或是购买已经组装好的；Arduino开源的IDE可以免费下载得到。
Arduino的编程语言就像似在对一个类似于物理的计算平台进行相应的连线，它基于处理多媒体的编程环境。


为什么要使用Arduino？
有很多的单片机和单片机平台都适合用做交互式系统的设计。例如：Parallax Basic Stamp， Netmedia’s BX-24，Phidgets，MIT’s Handyboard 和其它等等提供类似功能的。 所有这些工具，你都不需要去关心单片机编程繁琐的细节，提供给你的是一套容易使用的工具包。 Arduino同样也简化了同单片机工作的流程，但同其它系统相比Arduino在很多地方更具有优越性，特别适合老师，学生和一些业余爱好者们使用：

  • 便宜 － 和其它平台相比，Arduino板算是相当便宜了。最便宜的Arduino版本可以自己动手制作，即使是组装好的成品，其价格也不会超过200元。
  • 跨平台 － Arduino软件可以运行在Windows，Macintosh OSX，和Linux操作系统。大部分其它的单片机系统都只能运行在Windows上。
  • 简易的编程环境 － 初学者很容易就能学会使用Arduino编程环境，同时它又能为高级用户提供足够多的高级应用。对于老师们来说，一般都能很方便的使用Processing 编程环境，所以如果学生学习过使用Processing 编程环境的话，那他们在使用Arduino开发环境的时候就会觉得很相似很熟悉。
  • 软件开源并可扩展 － Arduino软件是开源的，对于有经验的程序员可以对其进行扩展。Arduino编程语言可以通过C 库进行扩展，如果有人想去了解技术上的细节，可以跳过Arduino语言而直接使用AVR C 编程语言（因为Arduino语言实际上是基于AVR C的）。类似的，如果你需要的话，你也可以直接往你的Arduino程序中添加AVR-C 代码。
  • 硬件开源并可扩展 － Arduino板基于 Atmel 的ATMEGA8 和ATMEGA168/328 单片机。Arduino基于Creative Commons 许可协议，所以有经验的电路设计师能够根据需求设计自己的模块，可以对其扩展或改进。甚至是对于一些相对没有什么经验的用户，也可以通过制作试验板来理解Arduino是怎么工作的，省钱又省事。

Arduino基于AVR平台，对AVR库进行了二次编译封装，把端口都打包好了，寄存器啦、地址指针之类的基本不用管。大大降低了软件开发难度，适宜非专业爱好者使用。优点和缺点并存，因为是二次编译封装，代码不如直接使用AVR代码编写精练，代码执行效率与代码体积都弱于AVR直接编译。
性能：
Digital I/O 数字输入/输出端口0—13。
Analog I/O 模拟输入/输出端口0-5。
支持ICSP下载，支持TX/RX。
输入电压：USB接口供电或者5V-12V外部电源供电。
输出电压：支持3.3V级5V DC输出。
处理器：使用Atmel Atmega168 328处理器，因其支持者众多，已有公司开发出来32位的MCU平台支持arduino。
目前arduino的控制板最新的为Arduino Uno，如下图：

国内使用比较多的为Arduino Duemilanove 2009，主要原因是Uno的usb控制芯片封装方式改变，制造成本上升，其他变化不大，性价比还是Arduino Duemilanove 2009比较好。

因其开源特性，生产arduino控制板的厂商众多，同样的Duemilanove 2009就有很多种颜色。

对于一些对电路板大小要求比较严格的地方，arduino团队提供了arduino Nano，此板体积做的非常小。如下图：


arduino板子上基本端口如图描述，对几个比较特殊的端口下面详细说明下：
VIN端口：VIN是input voltage的缩写，表示有外部电源时的输入端口。
AREF:Reference voltage for the analog inputs(模拟输入的基准电压）。使用analogReference()命令调用。
ICSP：也有称为ISP（In System Programmer)，就是一种线上即时烧录，目前比较新的芯片都支持这种烧录模式，包括大家常听说的8051系列的芯片，也都慢慢采用这种简便的烧录方式。我们都知道传统的烧录方式，都是将被烧录的芯片，从线路板上拔起，有的焊死在线路板上的芯片，还得先把芯片焊接下来才能烧录。为了解决这种问题，发明了ICSP线上即时烧录方式。只需要准备一条R232线（连接烧录器），以及一条连接烧录器与烧录芯片针脚的连接线就可以。电源的 5V，GND，两条负责传输烧录信息的针脚，再加上一个烧录电压针脚，这样就可以烧录了。arduino学习笔记2通过Arduino编译器查看串口数据最简单的例子：
void setup()
{
Serial.begin(9600); // 打开串口，设置波特率为9600 bps
}
void loop()
{
int val;
val=analogRead(5);//传感器接到模拟口5，数值根据自己的需要可变
Serial.println(val DEC);//从串口发送字符串并换行
delay(100);
}
如果电路安装正确，按照示例代码运行、上传，然后点击编译器的Serial Monitor按钮，就可以看到从代码定义的输入口（这儿是模拟口5）获取的数据了。arduino学习笔记3 arduino语言
  • Arduino语言是建立在C/C 基础上的，其实也就是基础的C语言，Arduino语言只不过把AVR单片机（微控制器）相关的一些参数设置都函数化，不用我们去了解他的底层，让我们不了解AVR单片机（微控制器）的朋友也能轻松上手。

在与Arduino DIYER接触的这段时间里，发现有些朋友对Arduino语言还是比较难入手，那么这里我就简单的注释一下Arduino语言（本人也是半罐子水，有错的地方还请各位指正）。

/*************基础C语言*************/

关键字：
  • if
  • if...else
  • for
  • switch case
  • while
  • do... while
  • break
  • continue
  • return
  • goto
语法符号：
  • ;
  • {}
  • //
  • /* */
运算符：
  • =
  • -
  • *
  • /
  • %
  • ==
  • !=
  • <
  • >
  • <=
  • >=
  • &&
  • ||
  • !
  • --
  • =
  • -=
  • *=
  • /=
数据类型：
  • boolean 布尔类型
  • char
  • byte 字节类型
  • int
  • unsigned int
  • long
  • unsigned long
  • float
  • double
  • string
  • array
  • void
数据类型转换：
  • char()
  • byte()
  • int()
  • long()
  • float()
常量：
  • HIGH | LOW 表示数字IO口的电平，HIGH 表示高电平（1），LOW 表示低电平（0）。
  • INPUT | OUTPUT 表示数字IO口的方向，INPUT 表示输入（高阻态），OUTPUT 表示输出（AVR能提供5V电压 40mA电流）。
  • true | false true 表示真（1），false表示假（0）。

/******************************************/

以上为基础c语言的关键字和符号，有c语言基础的都应该了解其含义，这里也不作过多的解释。

/*************Arduino 语言*************/

结构
  • void setup() 初始化变量，管脚模式，调用库函数等
  • void loop() 连续执行函数内的语句
功能

数字 I/O

  • pinMode(pin mode) 数字IO口输入输出模式定义函数，pin表示为0～13， mode表示为INPUT或OUTPUT。
  • digitalWrite(pin value) 数字IO口输出电平定义函数，pin表示为0～13，value表示为HIGH或LOW。比如定义HIGH可以驱动LED。
  • int digitalRead(pin) 数字IO口读输入电平函数，pin表示为0～13，value表示为HIGH或LOW。比如可以读数字传感器。

模拟 I/O

  • int analogRead(pin) 模拟IO口读函数，pin表示为0～5（Arduino Diecimila为0～5，Arduino nano为0～7）。比如可以读模拟传感器（10位AD，0～5V表示为0～1023）。
  • analogWrite(pin value) - PWM 数字IO口PWM输出函数，Arduino数字IO口标注了PWM的IO口可使用该函数，pin表示3 5 6 9 10 11，value表示为0～255。比如可用于电机PWM调速或音乐播放。

扩展 I/O

  • shiftOut(dataPin clockPin bitOrder value) SPI外部IO扩展函数，通常使用带SPI接口的74HC595做8个IO扩展，dataPin为数据口，clockPin为时钟口，bitOrder为数据传输方向（MSBFIRST高位在前，LSBFIRST低位在前），value表示所要传送的数据（0～255），另外还需要一个IO口做74HC595的使能控制。
  • unsigned long pulseIn(pin value) 脉冲长度记录函数，返回时间参数（us），pin表示为0～13，value为HIGH或LOW。比如value为HIGH，那么当pin输入为高电平时，开始计时，当pin输入为低电平时，停止计时，然后返回该时间。

时间函数

  • unsigned long millis() 返回时间函数（单位ms），该函数是指，当程序运行就开始计时并返回记录的参数，该参数溢出大概需要50天时间。
  • delay(ms) 延时函数（单位ms）。
  • delayMicroseconds(us) 延时函数（单位us）。

数学函数

  • min(x y) 求最小值
  • max(x y) 求最大值
  • abs(x) 计算绝对值
  • constrain(x a b) 约束函数，下限a，上限b，x必须在ab之间才能返回。
  • map(value fromLow fromHigh toLow toHigh) 约束函数，value必须在fromLow与toLow之间和fromHigh与toHigh之间。
  • pow(base exponent) 开方函数，base的exponent次方。
  • sq(x) 平方
  • sqrt(x) 开根号

三角函数

  • sin(rad)
  • cos(rad)
  • tan(rad)

随机数函数

  • randomSeed(seed) 随机数端口定义函数，seed表示读模拟口analogRead(pin)函数 。
  • long random(max) 随机数函数，返回数据大于等于0，小于max。
  • long random(min max) 随机数函数，返回数据大于等于min，小于max。

外部中断函数

  • attachInterrupt(interrupt mode) 外部中断只能用到数字IO口2和3，interrupt表示中断口初始0或1，表示一个功能函数，mode：LOW低电平中断，CHANGE有变化就中断，RISING上升沿中断，FALLING 下降沿中断。
  • detachInterrupt(interrupt) 中断开关，interrupt=1 开，interrupt=0 关。

中断使能函数

  • interrupts() 使能中断
  • noInterrupts() 禁止中断

串口收发函数

  • Serial.begin(speed) 串口定义波特率函数，speed表示波特率，如9600，19200等。
  • int Serial.available() 判断缓冲器状态。
  • int Serial.read() 读串口并返回收到参数。
  • Serial.flush() 清空缓冲器。
  • Serial.print(data) 串口输出数据。
  • Serial.println(data) 串口输出数据并带回车符。

/**********************************/

/************Arduino语言库文件*************/

官方库文件
  • EEPROM - EEPROM读写程序库
  • Ethernet - 以太网控制器程序库
  • LiquidCrystal - LCD控制程序库
  • Servo - 舵机控制程序库
  • SoftwareSerial - 任何数字IO口模拟串口程序库
  • Stepper - 步进电机控制程序库
  • Wire - TWI/I2C总线程序库
  • Matrix - LED矩阵控制程序库
  • Sprite - LED矩阵图象处理控制程序库
非官方库文件
  • DateTime - a library for keeping track of the current date and time in software.
  • Debounce - for reading noisy digital inputs (e.g. from buttons)
  • Firmata - for communicating with applications on the computer using a standard serial protocol.
  • GLCD - graphics routines for LCD based on the KS0108 or equivalent chipset.
  • LCD - control LCDs (using 8 data lines)
  • LCD 4 Bit - control LCDs (using 4 data lines)
  • LedControl - for controlling LED matrices or seven-segment displays with a MAX7221 or MAX7219.
  • LedControl - an alternative to the Matrix library for driving multiple LEDs with Maxim chips.
  • Messenger - for processing text-based messages from the computer
  • Metro - help you time actions at regular intervals
  • MsTimer2 - uses the timer 2 interrupt to trigger an action every N milliseconds.
  • OneWire - control devices (from Dallas Semiconductor) that use the One Wire protocol.
  • PS2Keyboard - read characters from a PS2 keyboard.
  • Servo - provides software support for Servo motors on any pins.
  • Servotimer1 - provides hardware support for Servo motors on pins 9 and 10
  • Simple Message System - send messages between Arduino and the computer
  • SSerial2Mobile - send text messages or emails using a cell phone (via AT commands over software serial)
  • TextString - handle strings
  • TLC5940 - 16 channel 12 bit PWM controller.
  • X10 - Sending X10 signals over AC power lines

/****************************************/

arduino学习笔记4 数据类型

有多种类型的变量，如下所述

boolean 布尔
char 字符
byte 字节
int 整数
unsigned int 无符号整数
long 长整数
unsigned long 无符号长整数
float 浮点
double 双字节浮点
string 字符串
array 数组

arduino学习笔记5 Arduuino复合运算符

= -= *= /=
Description描述
Perform a mathematical operation on a variable with another constant or variable. The = (et al) operators are just a convenient shorthand for the expanded syntax listed below.
对一个变量和另一个参数或变量完成一个数学运算。 =（以及其他）可以缩短语法长度。

Syntax语法
x = y; // equivalent to the expression x = x y; // 等价于 x = x y;
x -= y; // equivalent to the expression x = x - y; // 等价于 x = x - y;
x *= y; // equivalent to the expression x = x * y; // 等价于 x = x * y;
x /= y; // equivalent to the expression x = x / y; // 等价于 x = x / y;

Parameters参数
x: any variable type
x：任何变量类型

y: any variable type or constant
y：任何变量类型或常数

Examples范例
x = 2;
x = 4; // x now contains 6 // x现在为6
x -= 3; // x now contains 3 // x现在为3
x *= 10; // x now contains 30 // x现在为30
x /= 2; // x now contains 15 // x现在为15


Syntax语法
x ; // increment x by one and returns the old value of x
// 将x的值加1并返回原来的x的值。 x; // increment x by one and returns the new value of x // 将x的值加1并返回现在的x的值。
x-- ; // decrement x by one and returns the old value of x // 将x的值减1并返回原来的x的值。
--x ; // decrement x by one and returns the new value of x // 将x的值减1并返回现在的x的值。

Parameters参数
x: an integer or long (possibly unsigned)
x：一个整数或长整数（可以无符号）

Returns返回
The original or newly incremented / decremented value of the variable.
返回变量原始值或增加/消耗后的新值。

Examples范例
x = 2;
y = x; // x now contains 3 y contains 3 // x现在为3，y为3
y = x--; // x contains 2 again y still contains 3 // x现在仍然为2，y将为3

arduino学习笔记6 Arduino基础

在学语言之间，还要做的一个功课就是要明白程序的构架，这个也同样简单，大体可分为几个部分。

1、声明变量及接口名称（int val;int ledPin=13;）。

2、setup()——函数在程序开始时使用，可以初始化变量、接口模式、启用库等（例如：pinMode(ledPin OUTUPT);）。

3、loop（）——在setup()函数之后，即初始化之后，loop() 让你的程序循环地被执行。使用它来运转Arduino。

接下来就开始学习一下几个基本函数。

1、pinMode(接口名称 OUTPUT或INPUT)将——接口定义为输入或输出接口，用在setup()函数里。

2、digitalWrite(接口名称 HIGH或LOW)——将数字接口值至高或低。

3、digitalRead（接口名称）——读出数字接口的值。

4、analogWrite(接口名称 数值)——给一个接口写入模拟值（PWM波）。对于 ATmega168芯片的Arduino（包括Mini或BT），该函数可以工作于 3 5 6 9 10和 11号接口。老的 ATmega8芯片的USB和 serial Arduino仅仅支持 9 10和11号接口。

5、analogRead(接口名称)——从指定的模拟接口读取值，Arduino对该模拟值进行10-bit的数字转换，这个方法将输入的0-5电压值转换为 0到1023间的整数值。

6、delay()——延时一段时间，delay(1000)为一秒。

7、Serial.begin(波特率)——设置串行每秒传输数据的速率（波特率）。在同计算机通讯时，使用下面这些值：300 1200 2400 4800 9600 14400 19200 28800 38400 57600或 115200。你也可以在任何时候使用其它的值，比如，与0号或1号插口通信就要求特殊的波特率。用在setup()函数里

8、Serial.read()——读取持续输入的数据。

9、Serial.print(数据，数据的进制)——从串行端口输出数据。Serial.print(数据)默认为十进制等于Serial.print(数据，DEC)。

10、Serial.println(数据，数据的进制)——从串行端口输出数据，跟随一个回车和一个换行符。这个函数所取得的值与 Serial.print()一样。

以上几个函数是常用基本函数，还有很多以后会慢慢学习

arduino学习笔记7函数

输入输出函数

Arduino 内含了一些处理输出与输入的切换功能，相信已经从书中程式范例略知一二。

pinMode(pin mode)

将数位脚位(digital pin)指定为输入或输出。

范例 :

pinMode(7 INPUT); // 将脚位 7 设定为输入模式

digitalWrite(pin value)

将数位脚位指定为开或关。脚位必须先透过pinMode明示为输入或输出模式digitalWrite才能生效。

范例 :

digitalWrite(8 HIGH); //将脚位 8设定输出高电位

int digitalRead(pin)

将输入脚位的值读出，当感测到脚位处于高电位时时回传HIGH，否则回传LOW。

范例 :

val = digitalRead(7); // 读出脚位 7 的值并指定给 val

int analogRead(pin)

读出类比脚位的电压并回传一个 0到1023 的数值表示相对应的0到5的电压值。

范例 :

val = analogRead(0); //读出类比脚位 0 的值并指定给 val变数

analogWrite(pin value)

改变PWM脚位的输出电压值，脚位通常会在3、5、6、9、10与11。Value变数范围0-255，例如：输出电压2.5伏特（V），该值大约是128。

范例 :

analogWrite(9 128); // 输出电压约2.5伏特（V）

unsigned long pulseIn(pin value)

设定读取脚位状态的持续时间，例如使用红外线、加速度感测器测得某一项数值时，在时间单位内不会改变状态。

范例 :

time = pulsein(7 HIGH); // 设定脚位7的状态在时间单位内保持为HIGH

shiftOut(dataPin clockPin bitOrder value)

把资料传给用来延伸数位输出的暂存器，函式使用一个脚位表示资料、一个脚位表示时脉。bitOrder用来表示位元间移动的方式（LSBFIRST最低有效位元或是MSBFIRST最高有效位元），最后value会以byte形式输出。此函式通常使用在延伸数位的输出。

范例 :

shiftOut(dataPin clockPin LSBFIRST 255);

时间函数

控制与计算晶片执行期间的时间

unsigned long millis()

回传晶片开始执行到目前的毫秒

范例:

duration = millis()-lastTime; // 表示自"lastTime"至当下的时间

delay(ms)

暂停晶片执行多少毫秒

范例:

delay(500); //暂停半秒（500毫秒）

delay Microseconds(us)

暂停晶片执行多少微秒

范例:

delayMicroseconds(1000); //暂停1豪秒

数学函式

三角函数以及基本的数学运算

min(x y)

回传两数之间较小者

范例：

val = min(10 20); // 回传10

max(x y)

回传两数之间较大者

范例：

val = max(10 20); // 回传20

abs(x)

回传该数的绝对值，可以将负数转正数。

范例：

val = abs(-5); // 回传5

constrain(x a b)

判断x变数位于a与b之间的状态。x若小于a回传a；介于a与b之间回传x本身；大于b回传b

范例：

val = constrain(analogRead(0) 0 255); // 忽略大于255的数

map(value fromLow fromHigh toLow toHigh)

将value变数依照fromLow与fromHigh范围，对等转换至toLow与toHigh范围。时常使用于读取类比讯号，转换至程式所需要的范围值。

例如：

val = map(analogRead(0) 0 1023 100 200); // 将analog0 所读取到的讯号对等转换至100 – 200之间的数值。

double pow(base exponent)

回传一个数(base)的指数(exponent)值。

范例：

double x = pow(y 32); // 设定x为y的32次方

double sqrt(x)

回传double型态的取平方根值。

范例：

double a = sqrt(1138); // 回传1138平方根的近似值 33.73425674438

double sin(rad)

回传角度（radians）的三角函数sine值。

范例：

double sine = sin(2); // 近似值 0.90929737091

double cos(rad)

回传角度（radians）的三角函数cosine值。

范例：

double cosine = cos(2); //近似值-0.41614685058

double tan(rad)

回传角度（radians）的三角函数tangent值。

范例：

double tangent = tan(2); //近似值-2.18503975868

乱数函式

产生乱数

randomSeed(seed)

事实上在Arduino里的乱数是可以被预知的。所以如果需要一个真正的乱数，可以呼叫此函式重新设定产生乱数种子。你可以使用乱数当作乱数的种子，以确保数字以随机的方式出现，通常会使用类比输入当作乱数种子，藉此可以产生与环境有关的乱数（例如：无线电波、宇宙雷射线、电话和萤光灯发出的电磁波等）。

范例：

randomSeed(analogRead(5)); // 使用类比输入当作乱数种子

long random(max)

long random(min max)

回传指定区间的乱数，型态为long。如果没有指定最小值，预设为0。

范例：

long randnum = random(0 100); // 回传0 – 99 之间的数字

long randnum = random(11); // 回传 0 -10之间的数字

序列通讯

你可以在第五章看见一些使用序列埠与电脑交换讯息的范例，以下是函式解释。

Serial.begin(speed)

你可以指定Arduino从电脑交换讯息的速率，通常我们使用9600 bps。当然也可以使用其他的速度，但是通常不会超过115 200 bps（每秒位元组）。

范例：

Serial.begin(9600);

Serial.print(data)

Serial.print(data encoding)

经序列埠传送资料，提供编码方式的选项。如果没有指定，预设以一般文字传送。

范例：

Serial.print(75); // 列印出 "75"

Serial.print(75 DEC); //列印出 "75"

Serial.print(75 HEX); // "4B" (75 的十六进位)

Serial.print(75 OCT); // "113" (75 in的八进位)

Serial.print(75 BIN); // "1001011" (75的二进位)

Serial.print(75 BYTE); // "K" (以byte进行传送，显示以ASCII编码方式)

Serial.println(data)

Serial.println(data encoding)

与Serial.print()相同，但会在资料尾端加上换行字元（ ）。意思如同你在键盘上打了一些资料后按下Enter。

范例：

Serial.println(75); //列印出"75 "

Serial.println(75 DEC); //列印出"75 "

Serial.println(75 HEX); // "4B "

Serial.println(75 OCT); // "113 "

Serial.println(75 BIN); // "1001011 "

Serial.println(75 BYTE); // "K "

int Serial.available()

回传有多少位元组（bytes）的资料尚未被read()函式读取，如果回传值是0代表所有序列埠上资料都已经被read()函式读取。

范例：

int count = Serial.available();

int Serial.read()

读取1byte的序列资料

范例：

int data = Serial.read();

Serial.flush()

有时候因为资料速度太快，超过程式处理资料的速度，你可以使用此函式清除缓冲区内的资料。经过此函式可以确保缓冲区(buffer)内的资料都是最新的。

范例：

Serial.flush();

arduino学习笔记8数字输入

在数字电路中开关（switch）是一种基本的输入形式，它的作用是保持电路的连接或者断开。Arduino从数字I/O管脚上只能读出高电平（5V）或者低电平（0V），因此我们首先面临到的一个问题就是如何将开关的开/断状态转变成Arduino能够读取的高/低电平。解决的办法是通过上 /下拉电阻，按照电路的不同通常又可以分为正逻辑（Positive Logic）和负逻辑（Inverted Logic）两种。

在正逻辑电路中，开关一端接电源，另一端则通过一个10K的下拉电阻接地，输入信号从开关和电阻间引出。当开关断开的时候，输入信号被电阻“拉”向地，形成低电平（0V）；当开关接通的时候，输入信号直接与电源相连，形成高电平。对于经常用到的按压式开关来讲，就是按下为高，抬起为低。

arduino编程学习心得（arduino学习笔记分享）(2)

在负逻辑电路中，开关一端接地，另一端则通过一个10K的上拉电阻接电源，输入信号同样也是从开关和电阻间引出。当开关断开时，输入信号被电阻“拉”向电源，形成高电平（5V）；当开关接通的时候，输入信号直接与地相连，形成低电平。对于经常用到的按压式开关来讲，就是按下为低，抬起为高。

arduino编程学习心得（arduino学习笔记分享）(3)

为了验证Arduino数字I/O的输入功能，我们可以将开关接在Arduino的任意一个数字I/O管脚上（13除外），并通过读取它的接通或者断开状态，来控制其它数字I/O管脚的高低。本实验采用的原理图如下所示，其中开关接在数字I/O的7号管脚上，被控的发光二极管接在数字I/O的13号 管脚上：

arduino编程学习心得（arduino学习笔记分享）(4)

相应的代码为：

int ledPin = 13;
int switchPin = 7;
int value = 0;
void setup() {
pinMode(ledPin OUTPUT);
pinMode(switchPin INPUT);
}
void loop() {
value = digitalRead(switchPin);
if (HIGH == value) {
// turn LED off
digitalWrite(ledPin LOW);
} else {
// turn LED on
digitalWrite(ledPin HIGH);
}
}

由于采用的是负逻辑电路，开关按下时用digitalRead()函数读取到的值为LOW，此时再用digitalWrite()函数将发光二极管所在的管脚置为高，点亮发光二极管。同理，当开关抬起时，发光二极管将被熄灭，这样我们就实现了用开关来控制发光二极管的功能。

arduino学习笔记9 Arduino的数字输出

Arduino的数字I/O被分成两个部分，其中每个部分都包含有6个可用的I/O管脚，即管脚2 到管脚7和管脚8到管脚13。除了管脚13上接了一个1K的电阻之外，其他各个管脚都直接连接到ATmega上。我们可以利用一个6位的数字跑马灯，来对 Arduino数字I/O的输出功能进行验证，以下是相应的原理图：

arduino编程学习心得（arduino学习笔记分享）(5)

电路中在每个I/O管脚上加的那个1K电阻被称为限流电阻，由于发光二极管在电路中没有等效电阻值，使用限流电阻可以使元件上通过的电流不至于过大，能够起到保护的作用。

该工程对应的代码为：

int BASE = 2;
int NUM = 6;
int index = 0;
void setup()
{
for (int i = BASE; i < BASE NUM; i ) {
pinMode(i OUTPUT);
}
}
void loop()
{
for (int i = BASE; i < BASE NUM; i ) {
digitalWrite(i LOW);
}
digitalWrite(BASE index HIGH);
index = (index 1) % NUM;
delay(100);
}
下载并运行该工程，连接在Arduino数字I/O管脚2到管脚7上的发光二极管会依次点亮0.1秒，然后再熄灭：

arduino编程学习心得（arduino学习笔记分享）(6)

这个实验可以用来验证数字I/O输出的正确性。Arduino上一共有十二个数字I/O管脚，我们可以用同样的办法验证其他六个管脚的正确性，而这只需要对上述工程的第一行做相应的修改就可以了：

int BASE = 8;

arduino学习笔记10 Arduino的串口输入

串行通信是在实现在PC机与微控制器进行交互的最简单的办法。之前的PC机上一般都配有标准的 RS-232或者RS-422接口来实现串行通信，但现在这种情况已经发生了一些改变，大家更倾向于使用USB这样一种更快速但同时也更加复杂的方式来实现串行通信。尽管在有些计算机上现在已经找不到RS-232或者RS-422接口了，但我们仍可以通过USB/串口或者PCMCIA/串口这样的转换器， 在这些设备上得到传统的串口。

通过串口连接的Arduino在交互式设计中能够为PC机提供一种全新的交互方式，比如用PC机控制一些之前看来非常复杂的事情，像声音和视频等。很多场合中都要求Arduino能够通过串口接收来自于PC机的命令，并完成相应的功能，这可以通过Arduino语言中提供的 Serial.read()函数来实现。

在这一实验中我们同样不需要任何额外的电路，而只需要用串口线将Arduino和PC机连起来就可以了，相应的Arduino工程代码为：

int ledPin = 13;
int val;
void setup() {
pinMode(ledPin OUTPUT);
Serial.begin(9600);
}
void loop() {
val = Serial.read();
if (-1 != val) {
if ('H' == val) {
digitalWrite(ledPin HIGH);
delay(500);
digitalWrite(ledPin LOW);
}
}
}


把工程下载到Arduino模块中之后，在Arduino集成开发环境中打开串口监视器并将波特率设置为9600，然后向Arduino模块发送字符H，如下图所示：

arduino编程学习心得（arduino学习笔记分享）(7)

该工程运行起来之后会不断调用Serial.read()函数从串口获得数据。Arduino语言提供的这个函数是不阻塞的，也就是说不论串口上是否真的有数据到达，该函数都会立即返回。Serial.read()函数每次只读取一个字节的数据，当串口上有数据到达的时候，该函数的返回值为到达的数 据中第一个字符的ASCII码；当串口上没有数据到达的时候，该函数的返回值则为-1。

Arduino语言的参考手册中没 有对Serial.read()函数做过多的说明，我的一个疑问是如果PC机一次发送的数据太多，Arduino是否提供相应的串口缓存功能来保证数据不会丢失？Arduino语言中提供的另外一个函数Serial.available()或许能够帮助我们用实验来进行验证：

int ledPin = 13;
int val;
void setup() {
pinMode(ledPin OUTPUT);
Serial.begin(9600);
}
void loop() {
val = Serial.read();
if (-1 != val) {
if ('H' == val) {
digitalWrite(ledPin HIGH);
delay(500);
digitalWrite(ledPin LOW);
Serial.print("Available: ");
Serial.println(Serial.available() DEC);
}
}
}


函数Serial.available()的功能是返回串口缓冲区中当前剩余的字符个数，按照Arduino提供的该函数的说明，串口缓冲区中最多能缓冲128个字节。我们可以一次给Arduino模块发送多个字符，来验证这一功能：

arduino编程学习心得（arduino学习笔记分享）(8)

在这一实验中，每当Arduino成功收到一个字符H，连接在数字I/O端口管脚13上的发光二极管就会闪烁一次：

arduino编程学习心得（arduino学习笔记分享）(9)

arduino学习笔记11 Arduino的串口输出

在许多实际应用场合中我们会要求在Arduino和其它设备之间实现相互通信，而最常见通常也是最简单的办法就是使用串行通信。在串行通信中，两个设备之间一个接一个地来回发送数字脉冲，它们之间必须严格遵循相应的协议以保证通信的正确性。

在PC机上上最常见的串行通信协议是RS-232串行协议，而在各种微控制器（单片机）上采用的则是TTL串行协议。由于这两者的电平有很大的不同，因此在实现PC机和微控制器的通信时，必须进行相应的转换。完成RS-232电平和TTL电平之间的转换一般采用专用芯片，如MAX232等，但在 Arduino上是用相应的电平转换电路来完成的。

根据Arduino的原理图我们不难看出，ATmega的RX和TX引脚一方面直接接到了数字I/O端口的0号和1号管脚，另一方面又通过电平转换电路接到了串口的母头上。因此，当我们需要用Arduino与PC机通信时，可以用串口线将两者连接起来；当我们需要用 Arduino与微控制器（如另一块Arduino）通信时，则可以用数字I/O端口的0号和1号管脚。

串行通信的难点在于参数的设置，如波特率、数据位、停止位等，在Arduino语言可以使用Serial.begin()函数来简化这一任务。为了实现数据的发送，Arduino则提供了Serial.print()和Serial.println()两个函数，它们的区别在于后者会在请求发送的数 据后面加上换行符，以提高输出结果的可读性。

在这一实验中没有用到额外的电路， 我们只需要用串口线将Arduino和PC机连起来就可以了，相应的代码为：

void setup() {
Serial.begin(9600);
}
void loop() {
Serial.println("Hello World!");
delay(1000);
}

在将工程下载到Arduino模块中之后，在Arduino集成开发环境的工具栏中单击“Serial Monitor”控制，打开串口监视器：

arduino编程学习心得（arduino学习笔记分享）(10)

接着将波特率设置为9600，即保持与工程中的设置相一致：

如果一切正常，此时我们就可以在Arduino集成开发环境的Console窗口中看到串口上输出的数据了：

为了检查串口上是否有数据发送，一个比较简单的办法是在数字I/O端口的1号管脚（TX）和5V电源之间接一个发光二极管，如下面的原理图所示：

arduino编程学习心得（arduino学习笔记分享）(11)

这样一旦Arduino在通过串口向PC机发送数据时，相应的发光二极管就会闪烁，实际应用中这是一个非常方便的调试手段;-)

arduino编程学习心得（arduino学习笔记分享）(12)

arduino学习笔记12 PWM（脉冲宽度调制）

Pulse Width Modulation or PWM is a technique for getting analog results with digital means. Digital control is used to create a square wave a signal switched between on and off. This on-off pattern can simulate voltages in between full on (5 Volts) and off (0 Volts) by changing the portion of the time the signal spends on versus the time that the signal spends off. The duration of "on time" is called the pulse width. To get varying analog values you change or modulate that pulse width. If you repeat this on-off pattern fast enough with an LED for example the result is as if the signal is a steady voltage between 0 and 5v controlling the brightness of the LED.

脉冲宽度调制或PWM，是通过数字均值获得模拟结果的技术。数字控制被用来创建一个方波，信号在开和关之间切换。这种开关模式通过改变“开”时间段和“关”时间段的比值完全模拟从开（5伏特）和关（0伏特）之间的电压。“开时间“的周期称为脉冲宽度。为了得到不同的模拟值，你可以更改，或调节脉冲宽度。如果你重复这种开关模式速度足够快，其结果是一个介于0和5V之间的稳定电压用以控制LED的亮度。

In the graphic below the green lines represent a regular time period. This duration or period is the inverse of the PWM frequency. In other words with Arduino's PWM frequency at about 500Hz the green lines would measure 2 milliseconds each. A call to analogWrite() is on a scale of 0 - 255 such that analogWrite(255) requests a 100% duty cycle (always on) and analogWrite(127) is a 50% duty cycle (on half the time) for example.

下图中，绿色线表示一个固定的时间期限。此持续时间或周期是PWM的频率的倒数。换言之，Arduino的PWM频率约为500Hz，每个绿线之间表示2毫秒。一个analogWrite（）的调用区间为0- 255，例如analogWrite（255）需要100％占空比（常开），和analogWrite（127）是50％占空比（上一半的时间）。

arduino编程学习心得（arduino学习笔记分享）(13)

Once you get this example running grab your arduino and shake it back and forth. What you are doing here is essentially mapping time across the space. To our eyes the movement blurs each LED blink into a line. As the LED fades in and out those little lines will grow and shrink in length. Now you are seeing the pulse width.

一旦你运行这个例子中，抓住你的Arduino来回摇晃。你这么做的实质上是时间跨越时空的映射。对我们的眼睛，每个运动模糊成一条线的LED闪烁。由于LED消失和缩小，那些小行的长度会增长和收缩。现在你就可以看到脉冲宽度。

arduino学习笔记13 Arduino的模拟输入Description 介绍

Reads the value from the specified analog pin. The Arduino board contains a 6 channel (8 channels on the Mini and Nano 16 on the Mega) 10-bit analog to digital converter. This means that it will map input voltages between 0 and 5 volts into integer values between 0 and 1023. This yields a resolution between readings of: 5 volts / 1024 units or .0049 volts (4.9 mV) per unit. The input range and resolution can be changed using analogReference().

It takes about 100 microseconds (0.0001 s) to read an analog input so the maximum reading rate is about 10 000 times a second.

从指定的模拟引脚读取值。Arduino主板有6个通道（Mini和Nano有8个，Mega有16个），10位AD（模数）转换器。这意味着输入电压0-5伏对应0-1023的整数值。这就是说读取精度为：5伏/1024个单位，约等于每个单位0.049伏（4.9毫伏）。输入范围和进度可以通过analogReference()进行修改。

模拟输入的读取周期为100微秒（0.0001秒），所以最大读取速度为每秒10 000次。

Syntax 语法

analogRead(pin)

Parameters 参数

pin: the number of the analog input pin to read from (0 to 5 on most boards 0 to 7 on the Mini and Nano 0 to 15 on the Mega)

pin：读取的模拟输入引脚号（大多数主板是0-5，Mini和Nano是0-7，Mega是0-15）

Returns 返回值

int (0 to 1023)

整数型 int（0到1023）

Note 备注

If the analog input pin is not connected to anything the value returned by analogRead() will fluctuate based on a number of factors (e.g. the values of the other analog inputs how close your hand is to the board etc.).

如果模拟输入引脚没有连接到任何地方，analogRead()的返回值也会因为某些因素而波动（如其他模拟输入，你的手与主板靠的太近）

Example 例子

int analogPin = 3; // potentiometer wiper (middle terminal) connected to analog pin 3

// outside leads to ground and 5V

int val = 0; // variable to store the value read

void setup()

{

Serial.begin(9600); // setup serial

}

void loop()

{

val = analogRead(analogPin); // read the input pin

Serial.println(val); // debug value

}

arduino学习笔记14 Arduino的模拟输出Description 介绍

Writes an analog value (PWM wave) to a pin. Can be used to light a LED at varying brightnesses or drive a motor at various speeds. After a call to analogWrite() the pin will generate a steady square wave of the specified duty cycle until the next call to analogWrite() (or a call to digitalRead() or digitalWrite() on the same pin). The frequency of the PWM signal is approximately 490 Hz.

将模拟值（PWM波）输出到管脚。可用于在不同的光线亮度调节发光二极管亮度或以不同的速度驱动马达。调用analogWrite()后，该引脚将产生一个指定占空比的稳定方波，直到下一次调用analogWrite()（或在同一引脚调用digitalRead()或digitalWrite()）。 PWM的信号频率约为490赫兹。

On most Arduino boards (those with the ATmega168 or ATmega328) this function works on pins 3 5 6 9 10 and 11. On the Arduino Mega it works on pins 2 through 13. Older Arduino boards with an ATmega8 only support analogWrite() on pins 9 10 and 11. You do not need to call pinMode() to set the pin as an output before calling analogWrite().

在大多数Arduino板（带有ATmega168或ATmega328），这个函数工作在引脚3，5，6，9，10和11。在ArduinoMega，它适用于2-13号引脚。老的带有ATmega8的Arduino板只支持9，10，11引脚上使用。你并不需要在调用analogWrite()之前为设置输入引脚而调用pinMode()。

The analogWrite function has nothing whatsoever to do with the analog pins or the analogRead function.

这个analogWrite方法与模拟引脚或者analogRead方法毫不相干

Syntax 语法

analogWrite(pin value)

Parameters 参数

pin: the pin to write to.

pin：输出的引脚号

value: the duty cycle: between 0 (always off) and 255 (always on).

value：占用空：从0（常关）到255（常开）

Returns 返回值

nothing

Notes and Known Issues 备注和已知问题

The PWM outputs generated on pins 5 and 6 will have higher-than-expected duty cycles. This is because of interactions with the millis() and delay() functions which share the same internal timer used to generate those PWM outputs. This will be noticed mostly on low duty-cycle settings (e.g 0 - 10) and may result in a value of 0 not fully turning off the output on pins 5 and 6.

引脚5和6的PWM输出将产生高于预期的占空比。这是因为millis()和delay()函数，它们共享同一个内部定时器用于产生PWM输出所产生的相互作用。这提醒我们引脚5和6在多数低占空比的设置（如0- 10）的情况下0数值的结果并没有完全关闭。

Example 例子

Sets the output to the LED proportional to the value read from the potentiometer.

int ledPin = 9; // LED connected to digital pin 9

int analogPin = 3; // potentiometer connected to analog pin 3

int val = 0; // variable to store the read value

void setup()

{

pinMode(ledPin OUTPUT); // sets the pin as output

}

void loop()

{

val = analogRead(analogPin); // read the input pin

analogWrite(ledPin val / 4); // analogRead values go from 0 to 1023 analogWrite values from 0 to 255

arduino学习笔记15制作第一个电路 单led闪烁

做任何一个电路之前，一定要先了解电路中原件的参数，其工作电压，工作电流等。
第一个实验咱们用到的LED从网上查找资料得知，其工作电压一般为1.5-2.0V，工作电流一般为10-20ma，反向击穿电压为5V。控制板逻辑电路供电为5V。根据以上参数假设LED工作电压选用1.7，工作电流选用15ma，限流电阻=（总电压-LED电压）/电流，所以限流电阻=（5-1.7）/0.015=220Ω。
首先需要从arduino官方网站下载其编译软件，地址是arduino/en/Main/Software
笔者使用的平台为win7 32位，如果大家使用的是其他平台，按照对应的下载就可以。
下载回来的软件包解压缩后的目录结构如下图，arduino.exe是程序的启动文件，driver目录是控制板usb芯片驱动，usb接上控制板后如果要寻找驱动，把目录指定到这里就可以。

arduino编程学习心得（arduino学习笔记分享）(14)


本次实验所用到的器材为一个面包板，一个LED，一个220Ω的电阻，几根导线，如下图：

arduino编程学习心得（arduino学习笔记分享）(15)


本次实验的连接方法如下图，LED两个针脚有一长一短，短的是连接GND，长的是连接正极。在LED的长引脚前，需要添加一个220Ω的限流电阻。连接数字5号接口。

arduino编程学习心得（arduino学习笔记分享）(16)


实物连接如下图：

arduino编程学习心得（arduino学习笔记分享）(17)


通过面包板把个个电子器件连接好以后，接上USB线，设置好控制板型号、端口号。程序语言先不详解，大家先照猫画虎对着抄，后面通过各个实验，将对不同命令进行详解。
编写程序前，先需要选择控制板的型号。如下图：

arduino编程学习心得（arduino学习笔记分享）(18)


控制板型号选择好后，选择串口位置，笔者电脑的串口为COM3：

arduino编程学习心得（arduino学习笔记分享）(19)


串口具体是多少号可以到设备管理中进行查看，如下图：

arduino编程学习心得（arduino学习笔记分享）(20)


先把程序复制进去：

  1. int ledPin=5; //设定控制LED的数字IO脚
  2. void setup()
  3. {
  4. pinMode(ledPin OUTPUT);//设定数字IO口的模式，OUTPUT 为输出
  5. }
  6. void loop()
  7. {
  8. digitalWrite(ledPin HIGH); //设定PIN5脚为HIGH = 5V左右
  9. delay(2000); //设定延时时间，2000 = 2秒
  10. digitalWrite(ledPin LOW); //设定PIN5脚为LOW = 0V
  11. delay(2000); //设定延时时间，2000 = 2秒
  12. }

复制代码


图中int;void setup等褐色的文字是系统命令，OUTPUT等蓝色文字是命令的功能开关，黑色文字是变量。
程序写好以后点击编译按钮进行编译。

编译完成后会显示出来编译后的文件大小，本次编译出来的程序大小为1026字节。

然后把编译好的程序下载到arduino控制板上，点击下载按钮。

下载完成后会有提示

把所有的ledpin换成xxx试试，一样可以滴~~~ledpin只是自己定义的一个名字，作用只是方便识别辨认。

本次实验效果如下，闪烁着光芒的灯。。。
player.youku/player.php/sid/XMjg0MTA0Mzg4/v.swf
总结：
int;void setup等褐色文字是系统命令，OUTPUT等蓝色文字是系统命令的功能开关，黑色文字是变量。
在"int ledpin=5"中;设置了LED的数字IO脚，ledpin仅仅是5号数字端口自定义出来的名字，变成xxx等都可以。对于多脚IO操作的程序中，为每一个引脚定义名字是有必要性的，程序复杂后方便功能识别。arduino学习笔记16六灯闪烁实验

通过上一节学习，知道了怎样让一个led进行闪烁，下面的实验会对六个led进行控制，先看硬件连接图。

arduino编程学习心得（arduino学习笔记分享）(21)

arduino编程学习心得（arduino学习笔记分享）(22)


按照上面的硬件连接方法接好后，咱们来测试两段程序，看看其中的差别。通过这两段程序介绍一下arduino的语言轮廓。

  1. //设置控制Led的数字IO脚
  2. int Led1 = 1;
  3. int Led2 = 2;
  4. int Led3 = 3;
  5. int Led4 = 4;
  6. int Led5 = 5;
  7. int Led6 = 6;
  8. //led灯花样显示样式1子程序
  9. void style_1(void)
  10. {
  11. unsigned char j;
  12. for(j=1;j<=6;j )
  13. {
  14. digitalWrite(j HIGH);
  15. delay(200);
  16. }
  17. for(j=6;j>=1;j--)
  18. {
  19. digitalWrite(j LOW);
  20. delay(200);
  21. }
  22. }
  23. void setup()
  24. {
  25. unsigned char i;
  26. for(i=1;i<=6;i )//依次设置1~6个数字引脚为输出模式
  27. pinMode(i OUTPUT);//设置第i个引脚为输出模式
  28. }
  29. void loop()
  30. {
  31. style_1();//样式1

  33. }

复制代码

上面代码的效果视频如下：
player.youku/player.php/sid/XMjgzOTA0Mjk2/v.swf

  1. //设置控制Led的数字IO脚
  2. int Led1 = 1;
  3. int Led2 = 2;
  4. int Led3 = 3;
  5. int Led4 = 4;
  6. int Led5 = 5;
  7. int Led6 = 6;
  8. //led灯花样显示样式1子程序
  9. void style_1(void)
  10. {
  11. unsigned char j;
  12. for(j=1;j<=6;j )
  13. digitalWrite(j HIGH);
  14. delay(200);
  15. for(j=6;j>=1;j--)
  16. {
  17. digitalWrite(j LOW);
  18. delay(200);
  19. }
  20. }
  21. void setup()
  22. {
  23. unsigned char i;
  24. for(i=1;i<=6;i )//依次设置1~6个数字引脚为输出模式
  25. pinMode(i OUTPUT);//设置第i个引脚为输出模式
  26. }
  27. void loop()
  28. {
  29. style_1();//样式1

  31. }

复制代码

上面代码的效果视频如下：
player.youku/player.php/sid/XMjg0MDU5NjQ0/v.swf
通过下载测试，发现第一段程序是led 1-6逐个点亮，然后从6-1再逐个熄灭如此循环。
第二段程序是6个灯同时亮，然后再6-1逐个熄灭如此循环。下面对产生不同效果的代码进行分析。
下面这段代码代表的for语句循环的是，是把j点亮，然后再延迟200毫秒，然后再循环。形成的效果就是6个灯相隔200毫秒逐步被点亮。

  1. for(j=1;j<=6;j )
  2. {
  3. digitalWrite(j HIGH);
  4. delay(200);
  5. }

复制代码

下面这段代码其实是不规范写法，for命令表达要求一定要有{}循环，如果没有标出{}，编译时就会自动对下一句加上{}。如果代码量很大，出问题是查找起来会非常辛苦。

  1. for(j=1;j<=6;j )
  2. digitalWrite(j HIGH);
  3. delay(200);

复制代码

正确的写法应该是下面这个样子

  1. for(j=1;j<=6;j ) {
  2. digitalWrite(j HIGH);
  3. }
  4. delay(200);

复制代码

六个灯逐个被点亮，然后再延时200毫秒进入下一句。因为六灯逐个点亮的速度非常快，所以看上去像一起亮的。
void（无类型）在arduino中是数据类型的一种，通常用来代表一个事件。如果控制过程比较简单void一般无需定义，直接使用

  1. void setup()
  2. {
  3. // ...
  4. }
  5. void loop()
  6. {
  7. // ...
  8. }

复制代码

代表事件的开始与事件的循环。
如果控制过程比较复杂，一般就要设置多个子事件，把复杂的过程进行分解，每一个子事件定义为一个void数据。
把以下代码上传上去，看看led灯是如何工作的。

  1. //设置控制Led的数字IO脚
  2. int Led1 = 1;
  3. int Led2 = 2;
  4. int Led3 = 3;
  5. int Led4 = 4;
  6. int Led5 = 5;
  7. int Led6 = 6;
  8. //led灯花样显示样式1子程序
  9. void style_1(void)
  10. {
  11. unsigned char j;
  12. for(j=1;j<=6;j )//每隔200ms依次点亮1~6引脚相连的led灯
  13. {
  14. digitalWrite(j HIGH);//点亮j引脚相连的led灯
  15. delay(200);//延时200ms
  16. }
  17. for(j=6;j>=1;j--)//每隔200ms依次熄灭6~1引脚相连的led灯
  18. {
  19. digitalWrite(j LOW);//熄灭j引脚相连的led灯
  20. delay(200);//延时200ms
  21. }
  22. }
  23. //灯闪烁子程序
  24. void flash(void)
  25. {
  26. unsigned char j k;
  27. for(k=0;k<=1;k )//闪烁两次
  28. {
  29. for(j=1;j<=6;j )//点亮1~6引脚相连的led灯
  30. digitalWrite(j HIGH);//点亮与j引脚相连的led灯
  31. delay(200);//延时200ms
  32. for(j=1;j<=6;j )//熄灭1~6引脚相连的led灯
  33. digitalWrite(j LOW);//熄灭与j引脚相连的led灯
  34. delay(200);//延时200ms
  35. }
  36. }
  37. //led灯花样显示样式2子程序
  38. void style_2(void)
  39. {
  40. unsigned char j k;
  41. k=1;//设置k的初值为1
  42. for(j=3;j>=1;j--)
  43. {
  44. digitalWrite(j HIGH);//点亮灯
  45. digitalWrite(j k HIGH);//点亮灯
  46. delay(400);//延时400ms
  47. k =2;//k值加2
  48. }
  49. k=5;//设置k值为5
  50. for(j=1;j<=3;j )
  51. {
  52. digitalWrite(j LOW);//熄灭灯
  53. digitalWrite(j k LOW);//熄灭灯
  54. delay(400);//延时400ms
  55. k -=2;//k值减2
  56. }
  57. }
  58. //led灯花样显示样式3子程序
  59. void style_3(void)
  60. {
  61. unsigned char j k;//led灯花样显示样式3子程序
  62. k=5;//设置k值为5
  63. for(j=1;j<=3;j )
  64. {
  65. digitalWrite(j HIGH);//点亮灯
  66. digitalWrite(j k HIGH);//点亮灯
  67. delay(400);//延时400ms
  68. digitalWrite(j LOW);//熄灭灯
  69. digitalWrite(j k LOW);//熄灭灯
  70. k -=2;//k值减2
  71. }
  72. k=3;//设置k值为3
  73. for(j=2;j>=1;j--)
  74. {
  75. digitalWrite(j HIGH);//点亮灯
  76. digitalWrite(j k HIGH);//点亮灯
  77. delay(400);//延时400ms
  78. digitalWrite(j LOW);//熄灭灯
  79. digitalWrite(j k LOW);//熄灭灯
  80. k =2;//k值加2
  81. }
  82. }
  83. void setup()
  84. {
  85. unsigned char i;
  86. for(i=1;i<=6;i )//依次设置1~6个数字引脚为输出模式
  87. pinMode(i OUTPUT);//设置第i个引脚为输出模式
  88. }
  89. void loop()
  90. {
  91. style_1();//样式1
  92. flash();//闪烁
  93. style_2();//样式2
  94. flash();//闪烁
  95. style_3();//样式3
  96. flash();//闪烁
  97. }

复制代码

上面这段代码的效果视频如下：
player.youku/player.php/sid/XMjg0MjA2Njk2/v.swf
上面的代码分为4个子事件，样式1，样式2，样式3和闪烁。
闪烁：1-6号灯亮，延时200ms，1-6号灯熄灭，延时200ms。效果视频如下：
player.youku/player.php/sid/XMjg0MjAxMDgw/v.swf
样式1:1-6号灯逐个点亮，然后6-1逐个熄灭。效果视频如下：
player.youku/player.php/sid/XMjgzOTA0Mjk2/v.swf
样式2：3 4号灯先亮，然后2，5号再亮，最后1 6号两。接着1，6号灯熄灭，再2，5号熄灭，最后3 4号熄灭。效果视频如下：
player.youku/player.php/sid/XMjg0MjAwNTA0/v.swf
样式三：3 4号灯亮，然后3 4号熄灭2，5号亮，然后2 5号熄灭1，6号亮，再1，6号熄灭2 5号亮，最后2 5号熄灭3 4号亮。效果视频如下：
player.youku/player.php/sid/XMjg0MjAwNzc2/v.swf
通过以上4种事件的组合，就可以做出来各种效果。arduino学习笔记17蜂鸣器实验

本次实验所用的为下图所示的这种小型无源蜂鸣器

arduino编程学习心得（arduino学习笔记分享）(23)

arduino编程学习心得（arduino学习笔记分享）(24)


通过上网查询参数，得到其工作电压为5V，和arduino控制板数字端口输出电压一致，所以不需要接电阻。可直接接上使用。
先简单介绍一下这种小型蜂鸣器。
小型蜂鸣器因其体积小(直径只有6mm)、重量轻、价格低、结构牢靠，而广泛地应用在各种需要发声的电器设备、电子制作和单片机等电路中。这种蜂鸣器分有源蜂鸣器与无源蜂鸣器
下图为有源蜂鸣器

arduino编程学习心得（arduino学习笔记分享）(25)


下图为无源蜂鸣器

arduino编程学习心得（arduino学习笔记分享）(26)


从外观上看，两种蜂鸣器好像一样，如果将蜂鸣器引脚朝上时，可以看到，有绿色电路板的是一种无源蜂鸣器，没有电路板而使用黑胶密封的是一种有源蜂鸣器。从外观上并不能绝对的区分出有源与无源，最可靠的做法除了查看产品的参数手册以外，还有就是使用万用表测试蜂鸣器电阻，只有8Ω或者16Ω的是无源蜂鸣器，电阻在几百欧以上的是有源蜂鸣器。
有源蜂鸣器直接接上额定电源（新的蜂鸣器在标签上都有注明）就可以连续发声，而无源蜂鸣器则和电磁扬声器一样，需要接在音频输出电路中才能发声。
简单介绍完蜂鸣器以后先看一下硬件连接示意图

arduino编程学习心得（arduino学习笔记分享）(27)

arduino编程学习心得（arduino学习笔记分享）(28)


把下面的代码上传到arduino控制板上，看看实验结果。

  1. int buzzer=7;//设置控制蜂鸣器的数字IO脚
  2. void setup()
  3. {
  4. pinMode(buzzer OUTPUT);//设置数字IO脚模式，OUTPUT为输出
  5. }
  6. void loop()
  7. {
  8. unsigned char i j;//定义变量
  9. while(1)
  10. {
  11. for(i=0;i<80;i )//输出一个频率的声音
  12. {
  13. digitalWrite(buzzer HIGH);//发声音
  14. delay(1);//延时1ms
  15. digitalWrite(buzzer LOW);//不发声音
  16. delay(1);//延时ms
  17. }
  18. for(i=0;i<100;i )//输出另一个频率的声音
  19. {
  20. digitalWrite(buzzer HIGH);//发声音
  21. delay(2);//延时2ms
  22. digitalWrite(buzzer LOW);//不发声音
  23. delay(2);//延时2ms
  24. }
  25. }
  26. }

复制代码

实验效果如下面视频（需要开音响才能听到蜂鸣器发出的声音）
player.youku/player.php/sid/XMjgzNzQ4OTU2/v.swf
第一个频率的声音为1毫秒发声1毫秒不发声。1秒等于1000毫秒，2毫秒为一个周期。得出频率为500赫兹。
第二个频率的声音为2毫秒发声2毫秒不发声，4毫秒为一个周期。得出频率为250赫兹。
一个事件的循环就是500赫兹的声音响80毫秒，然后250赫兹的声音响100毫秒。如此循环下去。
while()函数
本次试验使用到了while()函数
在loop()中用while也是一个循环语句，一般形式：
while(表达式)
语句
表达式是循环条件，语句是循环体。语义是：计算表达式的值，当值为真（非0）时，执行循环体语句。其执行过程可用下图表：

作用：实现“当型”循环。当“表达式”非0（真）是，执行“语句”。“语句”是被循环执行的程序，称为“循环体”。arduino学习笔记18数码管实验

数码管介绍
数码管是一种半导体发光器件，其基本单元是发光二极管。数码管按段数分为七段数数码管和八段数数码管，八段数数码管比七段数数码管多一个发光二极管单元（多一个小数点显示）
发光二极管单元连接方式分为共阳数码管和共阴数码管。共阳数码管是指将所有发光二极管的阳极连接到一起形成公共阳极（COM）的数码管。共阳数码管在应用时应将公共极PWR接到电源输入PWR上，当某一字段发光二极管的阴极为低电平时，相应字段就点亮。当某一字段的阴极为高电平时，相应字段就不亮。共阴数码管则更好相反，阴极连接到一起形成了公共阴极，阳极是独立分开的。
先来看一下本次实验使用的数码管。
通过查询型号LG5011BSR得知其为0.5"单联共阳数码管，下面是其引脚图。

arduino编程学习心得（arduino学习笔记分享）(29)


查看其背后，四个角分别有2个原点和5，10两个标记。分别表示了1 6 5 10针脚。
数码管和发光二极管一样，需要添加限流电阻，因为网上没有查到资料说明该数码管的击穿电压是多大。所以供给电源电压宁可小不可大，所以选择220Ω限流电阻，和3.3V供电。
线路连接图如下

arduino编程学习心得（arduino学习笔记分享）(30)

arduino编程学习心得（arduino学习笔记分享）(31)


把下面的代码编译后下载到控制板上，看看效果~

  1. //设置控制各段的数字IO脚，具体几号引脚对应哪一段，来源为数码管官方引脚图。
  2. int a=7;
  3. int b=6;
  4. int c=5;
  5. int d=11;
  6. int e=10;
  7. int f=8;
  8. int g=9;
  9. int dp=4;
  10. //显示数字1
  11. void digital_1(void)
  12. {
  13. unsigned char j;
  14. digitalWrite(c LOW);//给数字5引脚低电平，点亮c段
  15. digitalWrite(b LOW);//点亮b段
  16. for(j=7;j<=11;j )//熄灭其余段
  17. digitalWrite(j HIGH);
  18. digitalWrite(dp HIGH);//熄灭小数点DP段
  19. }
  20. //显示数字2
  21. void digital_2(void)
  22. {
  23. unsigned char j;
  24. digitalWrite(b LOW);
  25. digitalWrite(a LOW);
  26. for(j=9;j<=11;j )
  27. digitalWrite(j LOW);
  28. digitalWrite(dp HIGH);
  29. digitalWrite(c HIGH);
  30. digitalWrite(f HIGH);
  31. }
  32. //显示数字3
  33. void digital_3(void)
  34. {
  35. unsigned char j;
  36. digitalWrite(g LOW);
  37. digitalWrite(d LOW);
  38. for(j=5;j<=7;j )
  39. digitalWrite(j LOW);
  40. digitalWrite(dp HIGH);
  41. digitalWrite(f HIGH);
  42. digitalWrite(e HIGH);
  43. }
  44. //显示数字4
  45. void digital_4(void)
  46. {
  47. digitalWrite(c LOW);
  48. digitalWrite(b LOW);
  49. digitalWrite(f LOW);
  50. digitalWrite(g LOW);
  51. digitalWrite(dp HIGH);
  52. digitalWrite(a HIGH);
  53. digitalWrite(e HIGH);
  54. digitalWrite(d HIGH);
  55. }
  56. //显示数字5
  57. void digital_5(void)
  58. {
  59. unsigned char j;
  60. for(j=7;j<=9;j )
  61. digitalWrite(j LOW);
  62. digitalWrite(c LOW);
  63. digitalWrite(d LOW);
  64. digitalWrite(dp HIGH);
  65. digitalWrite(b HIGH);
  66. digitalWrite(e HIGH);
  67. }
  68. //显示数字6
  69. void digital_6(void)
  70. {
  71. unsigned char j;
  72. for(j=7;j<=11;j )
  73. digitalWrite(j LOW);
  74. digitalWrite(c LOW);
  75. digitalWrite(dp HIGH);
  76. digitalWrite(b HIGH);
  77. }
  78. //显示数字7
  79. void digital_7(void)
  80. {
  81. unsigned char j;
  82. for(j=5;j<=7;j )
  83. digitalWrite(j LOW);
  84. digitalWrite(dp HIGH);
  85. for(j=8;j<=11;j )
  86. digitalWrite(j HIGH);
  87. }
  88. //显示数字8
  89. void digital_8(void)
  90. {
  91. unsigned char j;
  92. for(j=5;j<=11;j )
  93. digitalWrite(j LOW);
  94. digitalWrite(dp HIGH);
  95. }
  96. void setup()
  97. {
  98. int i;//定义变量
  99. for(i=4;i<=11;i )
  100. pinMode(i OUTPUT);//设置4～11引脚为输出模式
  101. }
  102. void loop()
  103. {
  104. while(1)
  105. {
  106. digital_1();//数字1
  107. delay(2000);//延时2s
  108. digital_2();
  109. delay(2000);
  110. digital_3();
  111. delay(2000);
  112. digital_4();
  113. delay(2000);
  114. digital_5();
  115. delay(2000);
  116. digital_6();
  117. delay(2000);
  118. digital_7();
  119. delay(2000);
  120. digital_8();
  121. delay(2000);
  122. }
  123. }

复制代码

本次试验的效果为数码管1 2 3 4 5 6 7 8这样子循环显示。
player.youku/player.php/sid/XMjgzNzQ4Mzk2/v.swf

arduino学习笔记19按键实验

按键是一种常用的控制电器元件，常用来接通或断开电路，从而达到控制电机或者其他设备运行的开关。按键的外观多种多样，本次实验使用的是这种微型按键，6mm的，如下图。

arduino编程学习心得（arduino学习笔记分享）(32)


此种按键有4个脚，从背面看是这样子的。

arduino编程学习心得（arduino学习笔记分享）(33)

arduino编程学习心得（arduino学习笔记分享）(34)


在按键没有按下去的时候1，2号脚相连，3 4号脚相连。按键按下去的时候，1 2 3 4号脚就全部接通。
本次实验使用按键来控制led的亮或者灭。
一般情况是直接把按键开关串联在led的电路中来开关，这种应用情况比较单一。
这次实验通过间接的方法来控制，按键接通后判断按键电路中的输出电压，如果电压大于4.88V，就使给LED电路输出高电平，反之就输出低电平。使用逻辑判断的方法来控制LED亮或者灭，此种控制方法应用范围较广。
本次连接方法如下图。按键开关两段一端连接5V接口，一端连接模拟5号口。LED长针脚串联220Ω电阻连接数字7号口，短针脚连接GND。

arduino编程学习心得（arduino学习笔记分享）(35)

arduino编程学习心得（arduino学习笔记分享）(36)


把下面的代码上传到arduino控制板上，看看效果。

  1. int key=7;//设置LED的数字IO脚
  2. void setup()
  3. {
  4. pinMode(key OUTPUT);//设置数字IO引脚为输出模式
  5. }
  6. void loop()
  7. {
  8. int i;//定义变量
  9. while(1)
  10. {
  11. i=analogRead(5);//读取模拟5口电压值
  12. if(i>1000)//如果电压值大于1000（即4.88V）
  13. digitalWrite(key HIGH);//设置第七引脚为高电平，点亮led灯
  14. else
  15. digitalWrite(key LOW);//设置第七引脚为低电平，熄灭led灯
  16. }
  17. }

复制代码

本次实验的效果如下
player.youku/player.php/sid/XMjgzNDMwNzcy/v.swf
本次实验使用到analogRead()这个新命令。
analogRead()作用是读取模拟口的数值。默认是把0-5V的输入电压分成1024份，每一份大约为0.049V，其数值在0-1023之间。
在本次程序代码中的读取数值如果大于512则给LED输出高电平， 所对应的电压也就为大于2.5V。


analogRead()命令输入的范围与分辨率可以使用analogReference()命令进行改动。
刚开始本实验选用的判断标准是512，也就是2.5V。但是有网友按照教程的方法进行试验发现有问题，有时不需要按按钮灯就会自己亮。根据多次试验与分析后，确定其为各种干扰所致。比如感应电流等等不少都是大于2.5V的，所以为了提高准确度，只能提高判断的电压，本次实验就是提高到1000（4.88V）。人体自身也带电，早中晚还个不一样。下面的实验就是把模拟5号口判断标准定位512，用手去触摸模拟5号口导线就可以点亮LED。
player.youku/player.php/sid/XMjgzNDMwODk2/v.swf

arduino学习笔记20 PWM控制LED实验 PWM讲解

本次实验通过PWM来控制一盏LED灯，让它慢慢变亮再慢慢变暗，如此循环。下面是接线图：

arduino编程学习心得（arduino学习笔记分享）(37)

arduino编程学习心得（arduino学习笔记分享）(38)

  1. /*
  2. 本次实验演示如何通过analogWrite()命令使连接9号端口的LED灯亮度逐渐变化
  3. */
  4. int brightness = 0; //定义整数型变量brightness与其初始值，此变量用来表示LED的亮度。
  5. int fadeAmount = 5; //定义整数型变量fadeAmount，此变量用来做亮度变化的增减量。
  6. void setup() {

  8. pinMode(9 OUTPUT);// 设置9号口为输出端口:
  9. }
  10. void loop() {

  12. analogWrite(9 brightness);//把brightness的值写入9号端口
  13. brightness = brightness fadeAmount;//改变brightness值，使亮度在下一次循环发生改变

  15. if (brightness == 0 || brightness == 255) {
  16. fadeAmount = -fadeAmount ; //在亮度最高与最低时进行翻转
  17. }

  19. delay(30); //延时30毫秒
  20. }

复制代码

本次实验效果如下：
player.youku/player.php/sid/XMjgzNTI5MDI4/v.swf


analogWrite()
其作用是给端口写入一个模拟值(PWM波)。可以用来控制LED灯的亮度变化，或者以不同的速度驱动马达。当执行analogWrite()命令后，端口会输出一个稳定的占空比的方波。除非有下一个命令来改变它。PWM信号的频率大约为490Hz.
在使用ATmega168与ATmega328的arduino控制板上，其工作在3 5 6 9 10 11端口。Arduino Mega控制板，可以工作于2-13号端口。在更古老的基于ATmega8的arduino控制板上，analogWrite()命令只能工作于9 10 11号端口。在使用analogWrite()命令前，可以不使用pinMode()命令把端口定义为输出端口，当然如果定义了更好，这样利于程序语言规范。


语法
analogWrite(pin value)
参数
pin:写入的端口
value:占空比:在0-255之间。
注释与已知问题
当PWM输出与5 6号端口的时候，会产生比预期更高的占空比。原因是PWM输出所使用的内部时钟，millis()与delay()两函数也在使用。所以要注意使用5 6号端口时，空占比要设置的稍微低一些，或者会产生5 6号端口无法输出完全关闭的信号。
PWM（Pulse-width modulation）脉宽调制
PWM是使用数字手段来控制模拟输出的一种手段。使用数字控制产生占空比不同的方波（一个不停在开与关之间切换的信号)来控制模拟输出。额~~这个说的太专业了，还是说的通俗点。


以本次实验来看，端口的输入电压只有两个0V与5V。如我我想要3V的输出电压怎么办。。。有同学说串联电阻，对滴，这个方法是正确滴。但是如果我想1V 3V 3.5V等等之间来回变动怎么办呢？不可能不停地切换电阻吧。这种情况下。。。就需要使用PWM了。他是怎么控制的呢，对于arduino的数字端口电压输出只有LOW与HIGH两个开关，对应的就是0V与5V的电压输出，咱本把LOW定义为0，HIGH定义为1.一秒内让arduino输出500个0或者1的信号。如果这500个全部为1，那就是完整的5V，如果全部为0，那就是0V。如果010101010101这样输出，刚好一半一半，输出端口就感觉是2.5V的电压输出了。

这个和咱们放映电影是一个道理，咱们所看的电影并不是完全连续的，它其实是每秒输出25张图片，在这种情况下人的肉眼是分辨不出来的，看上去就是连续的了。PWM也是同样的道理，如果想要不同的电压，就控制0与1的输出比例控制就ok~当然。。。这和真实的连续输出还是有差别的，单位时间内输出的0 1信号越多，控制的就越精确。


在下图中，绿线之间代表一个周期，其值也是PWM频率的倒数。换句话说，如果arduino PWM的频率是500Hz，那么两绿线之间的周期就是2毫秒。 analogWrite() 命令中可以操控的范围为0-255， analogWrite(255)表示100%占空比（常开）， analogWrite(127)占空比大约为50%（一半的时间）。

arduino编程学习心得（arduino学习笔记分享）(39)


传统方法实现PWM
除了使用analogWrite()命令实现PWM，还可以通过传统方法来控制电平的开关时间来设置。
请看如下代码

  1. void setup()
  2. {
  3. pinMode(13 OUTPUT);//设定13号端口为输出
  4. }
  5. void loop()
  6. {
  7. digitalWrite(13 HIGH);
  8. delayMicroseconds(100); // 大约10%占空比的1KHz方波
  9. digitalWrite(13 LOW);
  10. delayMicroseconds(900);
  11. }

复制代码

这种方法的的优点是他可以使用任意数字端口做输出端口。而且可以自己随意设定占空比与频率。一个主要的缺点是任何中断都会影响时钟，这样就会导致很大的抖动，除非你禁用中断。第二个却就是CPU在处理输出的时候，就无法做其他事情了。
上面的代码用到了一个新的命令
delayMicroseconds()
其作用是产生一个延时，计量单位是微秒，1000微秒=1毫秒。目前delayMicroseconds()最大值为16383。如果值大于1000，推荐使用delay() 命令。

arduino学习笔记21数字骰子实验

前几次做了数码管实验和按键控制LED的实验，通过实验大家已经学会了两种器件的基本用法。这次使用数码管与按键进行组合，做一个简易数字骰子。
数字筛子的基本原理是数码管快速在1-8之间循环跳动，当按下按键时，数码管定格在当前的数字上，不再跳动。
先看一下接线图

arduino编程学习心得（arduino学习笔记分享）(40)

arduino编程学习心得（arduino学习笔记分享）(41)

  1. //设置控制各段的数字IO脚
  2. int a=7;
  3. int b=6;
  4. int c=5;
  5. int d=11;
  6. int e=10;
  7. int f=8;
  8. int g=9;
  9. int dp=4;
  10. //显示数字1
  11. void digital_1(void)
  12. {
  13. unsigned char j;
  14. digitalWrite(c LOW);//给数字5引脚低电平，点亮c段
  15. digitalWrite(b LOW);//点亮b段
  16. for(j=7;j<=11;j )//熄灭其余段
  17. digitalWrite(j HIGH);
  18. digitalWrite(dp HIGH);//熄灭小数点DP段
  19. }
  20. //显示数字2
  21. void digital_2(void)
  22. {
  23. unsigned char j;
  24. digitalWrite(b LOW);
  25. digitalWrite(a LOW);
  26. for(j=9;j<=11;j )
  27. digitalWrite(j LOW);
  28. digitalWrite(dp HIGH);
  29. digitalWrite(c HIGH);
  30. digitalWrite(f HIGH);
  31. }
  32. //显示数字3
  33. void digital_3(void)
  34. {
  35. unsigned char j;
  36. digitalWrite(g LOW);
  37. digitalWrite(d LOW);
  38. for(j=5;j<=7;j )
  39. digitalWrite(j LOW);
  40. digitalWrite(dp HIGH);
  41. digitalWrite(f HIGH);
  42. digitalWrite(e HIGH);
  43. }
  44. //显示数字4
  45. void digital_4(void)
  46. {
  47. digitalWrite(c LOW);
  48. digitalWrite(b LOW);
  49. digitalWrite(f LOW);
  50. digitalWrite(g LOW);
  51. digitalWrite(dp HIGH);
  52. digitalWrite(a HIGH);
  53. digitalWrite(e HIGH);
  54. digitalWrite(d HIGH);
  55. }
  56. //显示数字5
  57. void digital_5(void)
  58. {
  59. unsigned char j;
  60. for(j=7;j<=9;j )
  61. digitalWrite(j LOW);
  62. digitalWrite(c LOW);
  63. digitalWrite(d LOW);
  64. digitalWrite(dp HIGH);
  65. digitalWrite(b HIGH);
  66. digitalWrite(e HIGH);
  67. }
  68. //显示数字6
  69. void digital_6(void)
  70. {
  71. unsigned char j;
  72. for(j=7;j<=11;j )
  73. digitalWrite(j LOW);
  74. digitalWrite(c LOW);
  75. digitalWrite(dp HIGH);
  76. digitalWrite(b HIGH);
  77. }
  78. //显示数字7
  79. void digital_7(void)
  80. {
  81. unsigned char j;
  82. for(j=5;j<=7;j )
  83. digitalWrite(j LOW);
  84. digitalWrite(dp HIGH);
  85. for(j=8;j<=11;j )
  86. digitalWrite(j HIGH);
  87. }
  88. //显示数字8
  89. void digital_8(void)
  90. {
  91. unsigned char j;
  92. for(j=5;j<=11;j )
  93. digitalWrite(j LOW);
  94. digitalWrite(dp HIGH);
  95. }
  96. void setup()
  97. {
  98. int i;
  99. for(i=4;i<=11;i )
  100. {
  101. pinMode(i OUTPUT);//设置4~11口为输出模式
  102. }
  103. }
  104. void loop()
  105. {
  106. while(1)
  107. {
  108. digital_1();//显示数字1
  109. while(analogRead(0)>1000);//如果读到模拟0口的值1000则说明有按键按下
  110. delay(100);//延时200ms
  111. digital_2();
  112. while(analogRead(0)>1000);
  113. delay(100);
  114. digital_3();
  115. while(analogRead(0)>1000);
  116. delay(100);
  117. digital_4();
  118. while(analogRead(0)>1000);
  119. delay(100);
  120. digital_5();
  121. while(analogRead(0)>1000);
  122. delay(100);
  123. digital_6();
  124. while(analogRead(0)>1000);
  125. delay(100);
  126. digital_7();
  127. while(analogRead(0)>1000);
  128. delay(100);
  129. digital_8();
  130. while(analogRead(0)>1000);
  131. delay(100);
  132. }
  133. }

复制代码

实验的效果如下
player.youku/player.php/sid/XMjg1MDE1MjA4/v.swf

arduino学习笔记22光控LED实验

光敏电阻又称光导管，常用的制作材料为硫化镉，另外还有硒、硫化铝、硫化铅和硫化铋等材料。这些制作材料具有在特定波长的光照下，其阻值迅速减小的特性。这是由于光照产生的载流子都参与导电，在外加电场的作用下漂移运动，从而使光敏电阻的阻值迅速下降。
光敏电阻的工作原理基于内光电效应。在半导体光敏材料的两端装上电极引线，将其封装在带有透明窗的管壳里就构成光敏电阻，为了增加灵敏度，两电极常做成梳状。在有光照射时，射入的光强，电阻减小，射入的光弱，电阻增大。
下图就是一个光敏电阻

arduino编程学习心得（arduino学习笔记分享）(42)


本次实验设计的效果是，当光照正常的时候led灯是灭的，当周围变暗时led灯变亮。
因为光敏电阻受不同光照影响变化很大，所以本次实验的参数是在60W三基色节能灯照射下实验（无日光照射），同样亮度的日光下光敏电阻的阻值会比日光灯下低不少，估计和不同光的波段有关系。不同环境下实验使用的参数不同，大家根据原理进行调整。
实验前先测量一下当前环境下光敏电阻的亮阻值与暗阻值
下图是测出来的LED亮阻值，为9.1KΩ

arduino编程学习心得（arduino学习笔记分享）(43)


下图是测出来的LED暗阻值，为32.4KΩ

arduino编程学习心得（arduino学习笔记分享）(44)


硬件连接图如下

arduino编程学习心得（arduino学习笔记分享）(45)

arduino编程学习心得（arduino学习笔记分享）(46)


根据测出来的亮阻9.1KΩ，暗阻32.4欧姆。选定分压电阻为10KΩ。因为当有遮挡物的后，阻值会变大。假设亮阻为10KΩ（对于光敏电阻来说，与测量出来的9.1KΩ差别不大，计算起来更加方便了），分压阻值为10K欧姆。模拟2号口所测量的触发电压为10KΩ分压电阻的，在5V电源供电下，亮与暗转换的触发电压为5×10÷（10 10）=2.5V。当光线越暗，光敏电阻的阻值也就越大，分压两端电压也就越小。所以触发条件就为≤2.5V。（

不同光照条件下触发电压不同，请根据实验环境进行调整。）
程序代码如下

  1. int photocellPin = 2; //定义变量photocellsh=2，为电压读取端口。
  2. int ledPin = 12; //定义变量ledPin=12，为led电平输出端口
  3. int val = 0; //定义val变量的起始值
  4. void setup() {
  5. pinMode(ledPin OUTPUT); //使ledPin为输出模式
  6. }
  7. void loop() {
  8. val = analogRead(photocellPin); //从传感器读取值
  9. if(val<=512){ //512=2.5V，想让传感器敏感一些的时候，把数值调高，想让传感器迟钝的时候把数值调低。
  10. digitalWrite(ledPin HIGH); //当val小于512(2.5V)的时候，led亮。
  11. }
  12. else{
  13. digitalWrite(ledPin LOW);
  14. }
  15. }

复制代码

实验效果如下
player.youku/player.php/sid/XMjg1MzAxMDUy/v.swf

arduino学习笔记23 1602液晶实验

本次试验使用arduino直接驱动1602液晶显示文字
1602液晶在应用中非常广泛，最初的1602液晶使用的是HD44780控制器，现在各个厂家的1602模块基本上都是采用了与之兼容的IC，所以特性上基本都是一致的。
1602LCD主要技术参数
显示容量为16×2个字符；
芯片工作电压为4.5～5.5V；
工作电流为2.0mA（5.0V）；
模块最佳工作电压为5.0V；
字符尺寸为2.95×4.35（W×H）mm。
1602液晶接口引脚定义

arduino编程学习心得（arduino学习笔记分享）(47)


接口说明：
1、两组电源 一组是模块的电源 一组是背光板的电源 一般均使用5V供电。本次试验背光使用3.3V供电也可以工作。
2、VL是调节对比度的引脚，串联不大于5KΩ的电位器进行调节。本次实验使用1KΩ的电阻来设定对比度。其连接分高电位与低电位接法，本次使用低电位接法，串联1KΩ电阻后接GND。


3、RS 是很多液晶上都有的引脚 是命令/数据选择引脚 该脚电平为高时表示将进行数据操作；为低时表示进行命令操作。
4、RW 也是很多液晶上都有的引脚 是读写选择端 该脚电平为高是表示要对液晶进行读操作；为低时表示要进行写操作。


5、E 同样很多液晶模块有此引脚 通常在总线上信号稳定后给一正脉冲通知把数据读走，在此脚为高电平的时候总线不允许变化。
6、D0—D7 8 位双向并行总线，用来传送命令和数据。
7、BLA是背光源正极，BLK是背光源负极。
1602液晶的基本操作分以下四种：

arduino编程学习心得（arduino学习笔记分享）(48)


下图就是1602液晶实物图

arduino编程学习心得（arduino学习笔记分享）(49)

arduino编程学习心得（arduino学习笔记分享）(50)


1602直接与arduino通信，根据产品手册描述，分8位连接法与4位连接法，咱们先使用8位连接法进行实验。硬件连接方式如下图

arduino编程学习心得（arduino学习笔记分享）(51)

arduino编程学习心得（arduino学习笔记分享）(52)


代码如下

  1. int DI = 12;
  2. int RW = 11;
  3. int DB[] = {3 4 5 6 7 8 9 10};//使用数组来定义总线需要的管脚
  4. int Enable = 2;
  5. void LcdCommandWrite(int value) {
  6. // 定义所有引脚
  7. int i = 0;
  8. for (i=DB[0]; i <= DI; i ) //总线赋值
  9. {
  10. digitalWrite(i value & 01);//因为1602液晶信号识别是D7-D0(不是D0-D7)，这里是用来反转信号。
  11. value >>= 1;
  12. }
  13. digitalWrite(Enable LOW);
  14. delayMicroseconds(1);
  15. digitalWrite(Enable HIGH);
  16. delayMicroseconds(1); // 延时1ms
  17. digitalWrite(Enable LOW);
  18. delayMicroseconds(1); // 延时1ms
  19. }
  20. void LcdDataWrite(int value) {
  21. // 定义所有引脚
  22. int i = 0;
  23. digitalWrite(DI HIGH);
  24. digitalWrite(RW LOW);
  25. for (i=DB[0]; i <= DB[7]; i ) {
  26. digitalWrite(i value & 01);
  27. value >>= 1;
  28. }
  29. digitalWrite(Enable LOW);
  30. delayMicroseconds(1);
  31. digitalWrite(Enable HIGH);
  32. delayMicroseconds(1);
  33. digitalWrite(Enable LOW);
  34. delayMicroseconds(1); // 延时1ms
  35. }
  36. void setup (void) {
  37. int i = 0;
  38. for (i=Enable; i <= DI; i ) {
  39. pinMode(i OUTPUT);
  40. }
  41. delay(100);
  42. // 短暂的停顿后初始化LCD
  43. // 用于LCD控制需要
  44. LcdCommandWrite(0x38); // 设置为8-bit接口，2行显示，5x7文字大小
  45. delay(64);
  46. LcdCommandWrite(0x38); // 设置为8-bit接口，2行显示，5x7文字大小
  47. delay(50);
  48. LcdCommandWrite(0x38); // 设置为8-bit接口，2行显示，5x7文字大小
  49. delay(20);
  50. LcdCommandWrite(0x06); // 输入方式设定
  51. // 自动增量，没有显示移位
  52. delay(20);
  53. LcdCommandWrite(0x0E); // 显示设置
  54. // 开启显示屏，光标显示，无闪烁
  55. delay(20);
  56. LcdCommandWrite(0x01); // 屏幕清空，光标位置归零
  57. delay(100);
  58. LcdCommandWrite(0x80); // 显示设置
  59. // 开启显示屏，光标显示，无闪烁
  60. delay(20);
  61. }
  62. void loop (void) {
  63. LcdCommandWrite(0x01); // 屏幕清空，光标位置归零
  64. delay(10);
  65. LcdCommandWrite(0x80 3);
  66. delay(10);
  67. // 写入欢迎信息
  68. LcdDataWrite('W');
  69. LcdDataWrite('e');
  70. LcdDataWrite('l');
  71. LcdDataWrite('c');
  72. LcdDataWrite('o');
  73. LcdDataWrite('m');
  74. LcdDataWrite('e');
  75. LcdDataWrite(' ');
  76. LcdDataWrite('t');
  77. LcdDataWrite('o');
  78. delay(10);
  79. LcdCommandWrite(0xc0 1); // 定义光标位置为第二行第二个位置
  80. delay(10);
  81. LcdDataWrite('g');
  82. LcdDataWrite('e');
  83. LcdDataWrite('e');
  84. LcdDataWrite('k');
  85. LcdDataWrite('-');
  86. LcdDataWrite('w');
  87. LcdDataWrite('o');
  88. LcdDataWrite('r');
  89. LcdDataWrite('k');
  90. LcdDataWrite('s');
  91. LcdDataWrite('h');
  92. LcdDataWrite('o');
  93. LcdDataWrite('p');
  94. delay(5000);
  95. LcdCommandWrite(0x01); // 屏幕清空，光标位置归零
  96. delay(10);
  97. LcdDataWrite('I');
  98. LcdDataWrite(' ');
  99. LcdDataWrite('a');
  100. LcdDataWrite('m');
  101. LcdDataWrite(' ');
  102. LcdDataWrite('h');
  103. LcdDataWrite('o');
  104. LcdDataWrite('n');
  105. LcdDataWrite('g');
  106. LcdDataWrite('y');
  107. LcdDataWrite('i');
  108. delay(3000);
  109. LcdCommandWrite(0x02); //设置模式为新文字替换老文字，无新文字的地方显示不变。
  110. delay(10);
  111. LcdCommandWrite(0x80 5); //定义光标位置为第一行第六个位置
  112. delay(10);
  113. LcdDataWrite('t');
  114. LcdDataWrite('h');
  115. LcdDataWrite('e');
  116. LcdDataWrite(' ');
  117. LcdDataWrite('a');
  118. LcdDataWrite('d');
  119. LcdDataWrite('m');
  120. LcdDataWrite('i');
  121. LcdDataWrite('n');
  122. delay(5000);
  123. }

复制代码

实验效果如下
player.youku/player.php/sid/XMjg2NTkxODY0/v.swf
4位接法
在正常使用下，8位接法基本把arduino的数字端口占满了，如果想要多接几个传感器就没有端口了，这种情况下怎么处理呢，咱们可以使用4位接法。
4位接法的硬件连接方法如下图

arduino编程学习心得（arduino学习笔记分享）(53)

arduino编程学习心得（arduino学习笔记分享）(54)


硬件接好后把下面的代码上传到控制板上，看看效果。

  1. int LCD1602_RS=12;
  2. int LCD1602_RW=11;
  3. int LCD1602_EN=10;
  4. int DB[] = { 6 7 8 9};
  5. char str1[]="Welcome to";
  6. char str2[]="geek-workshop";
  7. char str3[]="this is the";
  8. char str4[]="4-bit interface";
  9. void LCD_Command_Write(int command)
  10. {
  11. int i temp;
  12. digitalWrite( LCD1602_RS LOW);
  13. digitalWrite( LCD1602_RW LOW);
  14. digitalWrite( LCD1602_EN LOW);
  15. temp=command & 0xf0;
  16. for (i=DB[0]; i <= 9; i )
  17. {
  18. digitalWrite(i temp & 0x80);
  19. temp <<= 1;
  20. }
  21. digitalWrite( LCD1602_EN HIGH);
  22. delayMicroseconds(1);
  23. digitalWrite( LCD1602_EN LOW);
  24. temp=(command & 0x0f)<<4;
  25. for (i=DB[0]; i <= 10; i )
  26. {
  27. digitalWrite(i temp & 0x80);
  28. temp <<= 1;
  29. }
  30. digitalWrite( LCD1602_EN HIGH);
  31. delayMicroseconds(1);
  32. digitalWrite( LCD1602_EN LOW);
  33. }
  34. void LCD_Data_Write(int dat)
  35. {
  36. int i=0 temp;
  37. digitalWrite( LCD1602_RS HIGH);
  38. digitalWrite( LCD1602_RW LOW);
  39. digitalWrite( LCD1602_EN LOW);
  40. temp=dat & 0xf0;
  41. for (i=DB[0]; i <= 9; i )
  42. {
  43. digitalWrite(i temp & 0x80);
  44. temp <<= 1;
  45. }
  46. digitalWrite( LCD1602_EN HIGH);
  47. delayMicroseconds(1);
  48. digitalWrite( LCD1602_EN LOW);
  49. temp=(dat & 0x0f)<<4;
  50. for (i=DB[0]; i <= 10; i )
  51. {
  52. digitalWrite(i temp & 0x80);
  53. temp <<= 1;
  54. }
  55. digitalWrite( LCD1602_EN HIGH);
  56. delayMicroseconds(1);
  57. digitalWrite( LCD1602_EN LOW);
  58. }
  59. void LCD_SET_XY( int x int y )
  60. {
  61. int address;
  62. if (y ==0) address = 0x80 x;
  63. else address = 0xC0 x;
  64. LCD_Command_Write(address);
  65. }
  66. void LCD_Write_Char( int x int y int dat)
  67. {
  68. LCD_SET_XY( x y );
  69. LCD_Data_Write(dat);
  70. }
  71. void LCD_Write_String(int X int Y char *s)
  72. {
  73. LCD_SET_XY( X Y ); //设置地址
  74. while (*s) //写字符串
  75. {
  76. LCD_Data_Write(*s);
  77. s ;
  78. }
  79. }
  80. void setup (void)
  81. {
  82. int i = 0;
  83. for (i=6; i <= 12; i )
  84. {
  85. pinMode(i OUTPUT);
  86. }
  87. delay(100);
  88. LCD_Command_Write(0x28);//4线 2行 5x7
  89. delay(50);
  90. LCD_Command_Write(0x06);
  91. delay(50);
  92. LCD_Command_Write(0x0c);
  93. delay(50);
  94. LCD_Command_Write(0x80);
  95. delay(50);
  96. LCD_Command_Write(0x01);
  97. delay(50);
  98. }
  99. void loop (void)
  100. {
  101. LCD_Command_Write(0x01);
  102. delay(50);
  103. LCD_Write_String(3 0 str1);//第1行，第4个地址起
  104. delay(50);
  105. LCD_Write_String(1 1 str2);//第2行，第2个地址起
  106. delay(5000);
  107. LCD_Command_Write(0x01);
  108. delay(50);
  109. LCD_Write_String(0 0 str3);
  110. delay(50);
  111. LCD_Write_String(0 1 str4);
  112. delay(5000);

  114. }

复制代码


4位接法实验效果如下
player.youku/player.php/sid/XMjg3MDE5MDIw/v.swf
这里我们讲解一下最关键的部分，就是LCD的控制命令。
在上面两段代码中，我们常常可以遇到0x01 0x38这种参数。这些参数代表什么呢？
在C/C 语言中，0x38代表的是十六进制的数值"38"，"0x"的意思就是十六进制。
先打开win7下的计算器，选择“程序员”“基本”，

arduino编程学习心得（arduino学习笔记分享）(55)


然后咱们选择“十六进制”，输入“38”，

arduino编程学习心得（arduino学习笔记分享）(56)


然后再点击“二进制”。这时十六进制的“38”就会转换为二进制下的数值“111000”。

arduino编程学习心得（arduino学习笔记分享）(57)


以8位控制法接LCD是，对应的控制信息就是“00111000”

arduino编程学习心得（arduino学习笔记分享）(58)


同理，也可以把二进制的控制信息，逆运算为十六进制的。
有的产品说明书写的控制命令是"38H"
这里说明一下，一般情况下
十六进制 前缀0x 后缀h
十进制 后缀D
八进制 后缀Q
二进制 后缀B
但是不同的程序语言，对于十六进制的表达方式不完全相同，在arduino下，表达十六进制数值“38”只能使用“0x38”而不能用“38H”
最后放三个附件，是三个不同厂家的1602 LCD手册，供大家深入研究。

arduino编程学习心得（arduino学习笔记分享）(59)

1602手册.pdf (634.17 KB 下载次数: 3)

arduino编程学习心得（arduino学习笔记分享）(60)

1602.pdf (233 KB 下载次数: 1)

arduino编程学习心得（arduino学习笔记分享）(61)

SMC1602A.pdf (255.88 KB 下载次数: 1)

arduino学习笔记24温度传感器实验

通过上一次的实验，我们学会了1602液晶的使用。下面我们做一个简单的温度传感器，通过一个LM35温度传感器读取室温后，使温度显示在1602液晶屏幕上。
上次我们驱动液晶是使用的手工编写代码，这次我们直接使用arduino自带的LiquidCrystal库来进行驱动，此库文件允许arduino控制板控制基于Hitachi HD44780或与之相兼容芯片大部分的液晶，可以工作于4bit或者8bit状态。
下图为我们所使用的arduino的LiquidCrystal库文件位置，只有这里显示的库文件，arduino才可以调用。

arduino编程学习心得（arduino学习笔记分享）(62)


什么是温度传感器？
温度传感器就是利用物质随温度变化特性的规律，把温度转换为电量的传感器。按照测量方式可以分为接触式和非接触式两大类，按照传感器材料以及元件特性分为热电阻传感器和热电偶传感器两类。白光烙铁头使用的是热电偶传感器，本次试验使用的LM35是热电阻传感器。
LM35温度传感器实物如下图：

arduino编程学习心得（arduino学习笔记分享）(63)


LM35使用非常普遍，他使用内部补偿机制，输出可以从0℃开始。封装为T0992，工作电压4—30V。而且在上述电压范围内，芯片的工作电流不超过60ua。根据产品使用手册，得知LM35传感器的输出电压与摄氏温度呈线性关系，0℃时输出为0V，每升高1℃，输出电压增加10mv。
下图为实验硬件连接方式

arduino编程学习心得（arduino学习笔记分享）(64)

arduino编程学习心得（arduino学习笔记分享）(65)


代码如下

  1. #include <LiquidCrystal.h> //调用arduino自带的LiquidCrystal库
  2. LiquidCrystal lcd(12 11 5 4 3 2);//设置接口
  3. int potPin = 4; //设置模拟口4为LM35的信号输入端口
  4. float temperature = 0; //设置temperature为浮点变量
  5. long val=0; //设置val为长整数变量
  6. void setup()
  7. {
  8. lcd.begin(16 2); //初始化LCD
  9. lcd.print("LM35 Thermometer"); //使屏幕显示文字LM35 Thermometer
  10. delay(1000); //延时1000ms
  11. }
  12. void loop ()
  13. {
  14. val = analogRead(potPin); //val变量为从LM35信号口读取到的数值
  15. temperature = ((val 1)*0.0048828125*1000); //把读取到的val转换为温度数值的10倍
  16. lcd.clear(); //清屏
  17. lcd.print("LM35 Thermometer"); //使屏幕显示文字LM35 Thermometer
  18. lcd.setCursor(0 1) ; //设置光标位置为第二行第一个位置
  19. lcd.print((long)temperature / 10); //显示温度整数位
  20. lcd.print("."); //显示小数点
  21. lcd.print( (long)temperature % 10); //显示温度小数点后一位
  22. lcd.print((char)223); //显示o符号
  23. lcd.print("C"); //显示字母C
  24. delay(2000); //延时2秒，这里也就是刷新速度。
  25. }

复制代码


实验效果如下，为了使温度发生变化，用一个装了热水的塑料杯，放在传感器旁边。
player.youku/player.php/sid/XMjg3NjYyMjI0/v.swf
关于LiquidCrystal库使用的更详细方法，请查看arduino官方介绍。
arduino/en/Reference/LiquidCrystal
附件为LM35的产品说明书

arduino编程学习心得（arduino学习笔记分享）(66)

LM35产品说明书.pdf (303.72 KB 下载次数: 0)

arduino学习笔记25 ADXL345加速度传感器实验

前两天我们做了温度传感器实验，大家一定还有印象。今天我们来研究另外一种传感器加速度传感器。
什么是加速度传感器
加速度传感器，作用是测量在加速过程中产生的力。最基本的如咱们平常所熟悉的是重力加速度，大小是1g。
加速度传感器一般用于什么地方
通过测量由重力引起的加速度，你可以计算出设备相对于水平面的倾斜角度。通过分析动态加速度，你可以分析出设备的移动方式。自平衡车中就是使用加速度传感器与陀螺仪进行卡尔曼滤波进行姿态矫正。
本次试验使用的ADXL345数字传感器，通过I2C或者SPI接口直接输出数字信号。在1g的加速度下，输出数值为256.

arduino编程学习心得（arduino学习笔记分享）(67)

2011-7-28 22:56:15 上传

下载附件 (24.89 KB)


下面是硬件连接图

arduino编程学习心得（arduino学习笔记分享）(68)

2011-7-29 22:16:48 上传

下载附件 (112.73 KB)

arduino编程学习心得（arduino学习笔记分享）(69)

2011-7-29 15:58:16 上传

下载附件 (164.15 KB)

arduino编程学习心得（arduino学习笔记分享）(70)

2011-7-28 22:56:16 上传

下载附件 (203.65 KB)


下面是代码

  1. #include <Wire.h> //调用arduino自带的I2C库
  2. #include <LiquidCrystal.h> //调用arduino自带的LiquidCrystal库
  3. #define Register_ID 0
  4. #define Register_2D 0x2D
  5. #define Register_X0 0x32
  6. #define Register_X1 0x33
  7. #define Register_Y0 0x34
  8. #define Register_Y1 0x35
  9. #define Register_Z0 0x36
  10. #define Register_Z1 0x37
  11. LiquidCrystal lcd(12 11 10 9 8 7);//设置接口
  12. int ADXAddress = 0xA7>>1; //转换为7位地址
  13. int reading = 0;
  14. int val = 0;
  15. int X0 X1 X_out;
  16. int Y0 Y1 Y_out;
  17. int Z1 Z0 Z_out;
  18. double Xg Yg Zg;
  19. void setup()
  20. {
  21. lcd.begin(16 2); //初始化LCD
  22. delay(100);
  23. Wire.begin(); //初始化I2C
  24. delay(100);
  25. Wire.beginTransmission(ADXAddress);
  26. Wire.send(Register_2D);
  27. Wire.send(8);
  28. Wire.endTransmission();
  29. }
  30. void loop()
  31. {
  32. Wire.beginTransmission(ADXAddress);
  33. Wire.send(Register_X0);
  34. Wire.send(Register_X1);
  35. Wire.endTransmission();
  36. Wire.requestFrom(ADXAddress 2);
  37. if(Wire.available()<=2);
  38. {
  39. X0 = Wire.receive();
  40. X1 = Wire.receive();
  41. X1 = X1<<8;
  42. X_out = X0 X1;
  43. }

  45. Wire.beginTransmission(ADXAddress);
  46. Wire.send(Register_Y0);
  47. Wire.send(Register_Y1);
  48. Wire.endTransmission();
  49. Wire.requestFrom(ADXAddress 2);
  50. if(Wire.available()<=2);
  51. {
  52. Y0 = Wire.receive();
  53. Y1 = Wire.receive();
  54. Y1 = Y1<<8;
  55. Y_out = Y0 Y1;
  56. }

  58. Wire.beginTransmission(ADXAddress);
  59. Wire.send(Register_Z0);
  60. Wire.send(Register_Z1);
  61. Wire.endTransmission();
  62. Wire.requestFrom(ADXAddress 2);
  63. if(Wire.available()<=2);
  64. {
  65. Z0 = Wire.receive();
  66. Z1 = Wire.receive();
  67. Z1 = Y1<<8;
  68. Z_out = Y0 Y1;
  69. }

  71. Xg = X_out/256.00;//把输出结果转换为重力加速度g 精确到小数点后2位。
  72. Yg = Y_out/256.00;
  73. Zg = Z_out/256.00;
  74. lcd.clear(); //清屏
  75. lcd.print("X="); //使屏幕显示文字X=
  76. lcd.print(Xg);
  77. lcd.setCursor(8 0);
  78. lcd.print("Y=");
  79. lcd.print(Yg);
  80. lcd.setCursor(0 1);
  81. lcd.print("Z=");
  82. lcd.print(Zg);
  83. delay(500); //延时0.5秒，刷新频率这里进行调整

  85. }

复制代码

试验效果如下
附件为ADXL345中文手册

arduino编程学习心得（arduino学习笔记分享）(71)

ADXL345中文PDF.pdf

arduino学习笔记26 4位数码管实验

这次我们进行的实验是使用arduino驱动一块共阳四位数码管。驱动数码管限流电阻肯定是必不可少的，限流电阻有两种接法，一种是在d1-d4阳极接，总共接4颗。这种接法好处是需求电阻比较少，但是会产生每一位上显示不同数字亮度会不一样，1最亮，8最暗。另外一种接法就是在其他8个引脚上接，这种接法亮度显示均匀，但是用电阻较多。本次实验使用8颗220Ω电阻（因为没有100Ω电阻，所以使用220Ω的代替，100欧姆亮度会比较高）。
下图为4位数码管

arduino编程学习心得（arduino学习笔记分享）(72)

23 分钟前 上传

下载附件 (118.5 KB)


4位数码管总共有12个引脚，小数点朝下正放在面前时，左下角为1 其他管脚顺序为逆时针旋转。左上角为最大的12号管脚。

arduino编程学习心得（arduino学习笔记分享）(73)

23 分钟前 上传

下载附件 (62.87 KB)


下图为数码管的说明手册

arduino编程学习心得（arduino学习笔记分享）(74)

23 分钟前 上传

下载附件 (143.54 KB)


下面是硬件连接图

arduino编程学习心得（arduino学习笔记分享）(75)

23 分钟前 上传

下载附件 (154.12 KB)

arduino编程学习心得（arduino学习笔记分享）(76)

18 分钟前 上传

下载附件 (202.16 KB)


把下面的代码复制下载到控制板中，看看效果。

  1. //设置阴极接口
  2. int a = 1;
  3. int b = 2;
  4. int c = 3;
  5. int d = 4;
  6. int e = 5;
  7. int f = 6;
  8. int g = 7;
  9. int p = 8;
  10. //设置阳极接口
  11. int d4 = 9;
  12. int d3 = 10;
  13. int d2 = 11;
  14. int d1 = 12;
  15. //设置变量
  16. int del = 100;
  17. int buttoncount = 0;
  18. int loopcount = 0;
  19. void setup()
  20. {
  21. pinMode(d1 OUTPUT);
  22. pinMode(d2 OUTPUT);
  23. pinMode(d3 OUTPUT);
  24. pinMode(d4 OUTPUT);
  25. pinMode(a OUTPUT);
  26. pinMode(b OUTPUT);
  27. pinMode(c OUTPUT);
  28. pinMode(d OUTPUT);
  29. pinMode(e OUTPUT);
  30. pinMode(f OUTPUT);
  31. pinMode(g OUTPUT);
  32. pinMode(p OUTPUT);
  33. digitalWrite(a HIGH);
  34. digitalWrite(b HIGH);
  35. digitalWrite(c HIGH);
  36. digitalWrite(d HIGH);
  37. digitalWrite(e HIGH);
  38. digitalWrite(f HIGH);
  39. digitalWrite(g HIGH);
  40. digitalWrite(p HIGH);
  41. }
  42. void loop()
  43. {
  44. roulette(4); //轮转效果
  45. delay(100);
  46. zigzag(2); //Z字型效果
  47. delay(100);
  48. circles(4); //圈状效果
  49. delay(100);
  50. }
  51. void pickDigit(int x) //定义pickDigit(x) 其作用是开启dx端口
  52. {
  53. digitalWrite(d1 LOW);
  54. digitalWrite(d2 LOW);
  55. digitalWrite(d3 LOW);
  56. digitalWrite(d4 LOW);
  57. switch(x)
  58. {
  59. case 1:
  60. digitalWrite(d1 HIGH);
  61. break;
  62. case 2:
  63. digitalWrite(d2 HIGH);
  64. break;
  65. case 3:
  66. digitalWrite(d3 HIGH);
  67. break;
  68. default:
  69. digitalWrite(d4 HIGH);
  70. break;
  71. }
  72. }
  73. void clearLEDs() //清屏
  74. {
  75. digitalWrite(a HIGH);
  76. digitalWrite(b HIGH);
  77. digitalWrite(c HIGH);
  78. digitalWrite(d HIGH);
  79. digitalWrite(e HIGH);
  80. digitalWrite(f HIGH);
  81. digitalWrite(g HIGH);
  82. digitalWrite(p HIGH);
  83. }
  84. void roulette(int x) //设置轮转效果
  85. {
  86. loopcount = 0;
  87. while (loopcount < x)
  88. {
  89. digitalWrite(a LOW);
  90. pickDigit(1);
  91. delay(del);
  92. pickDigit(2);
  93. delay(del);
  94. pickDigit(3);
  95. delay(del);
  96. pickDigit(4);
  97. delay(del);
  98. digitalWrite(a HIGH);
  99. digitalWrite(b LOW);
  100. delay(del);
  101. digitalWrite(b HIGH);
  102. digitalWrite(c LOW);
  103. delay(del);
  104. digitalWrite(c HIGH);
  105. digitalWrite(d LOW);
  106. delay(del);
  107. pickDigit(3);
  108. delay(del);
  109. pickDigit(2);
  110. delay(del);
  111. pickDigit(1);
  112. delay(del);
  113. digitalWrite(d HIGH);
  114. digitalWrite(e LOW);
  115. delay(del);
  116. digitalWrite(e HIGH);
  117. digitalWrite(f LOW);
  118. delay(del);
  119. clearLEDs();
  120. loopcount ;
  121. }
  122. }
  123. void zigzag(int x) //设置Z字形效果
  124. {
  125. loopcount = 0;
  126. while(loopcount < x)
  127. {
  128. digitalWrite(a LOW);
  129. pickDigit(1);
  130. delay(del);
  131. pickDigit(2);
  132. delay(del);
  133. pickDigit(3);
  134. delay(del);
  135. pickDigit(4);
  136. delay(del);
  137. digitalWrite(a HIGH);
  138. digitalWrite(b LOW);
  139. delay(del);
  140. digitalWrite(b HIGH);
  141. digitalWrite(g LOW);
  142. delay(del);
  143. pickDigit(3);
  144. delay(del);
  145. pickDigit(2);
  146. delay(del);
  147. pickDigit(1);
  148. delay(del);
  149. digitalWrite(g HIGH);
  150. digitalWrite(e LOW);
  151. delay(del);
  152. digitalWrite(e HIGH);
  153. digitalWrite(d LOW);
  154. delay(del);
  155. pickDigit(2);
  156. delay(del);
  157. pickDigit(3);
  158. delay(del);
  159. pickDigit(4);
  160. delay(del);
  161. digitalWrite(d HIGH);
  162. digitalWrite(c LOW);
  163. delay(del);
  164. digitalWrite(c HIGH);
  165. digitalWrite(g LOW);
  166. delay(del);
  167. pickDigit(3);
  168. delay(del);
  169. pickDigit(2);
  170. delay(del);
  171. pickDigit(1);
  172. delay(del);
  173. digitalWrite(g HIGH);
  174. digitalWrite(f LOW);
  175. delay(del);
  176. clearLEDs();
  177. loopcount ;
  178. }
  179. }
  180. void circles(int x) //设置圈状效果
  181. {
  182. loopcount = 0;
  183. while (loopcount < x)
  184. {
  185. digitalWrite(a LOW);
  186. digitalWrite(b LOW);
  187. digitalWrite(f LOW);
  188. digitalWrite(g LOW);
  189. pickDigit(1);
  190. delay(250);
  191. digitalWrite(a HIGH);
  192. digitalWrite(b HIGH);
  193. digitalWrite(f HIGH);
  194. digitalWrite(c LOW);
  195. digitalWrite(d LOW);
  196. digitalWrite(e LOW);
  197. pickDigit(2);
  198. delay(250);
  199. digitalWrite(a LOW);
  200. digitalWrite(b LOW);
  201. digitalWrite(f LOW);
  202. digitalWrite(c HIGH);
  203. digitalWrite(d HIGH);
  204. digitalWrite(e HIGH);
  205. pickDigit(3);
  206. delay(250);
  207. digitalWrite(a HIGH);
  208. digitalWrite(b HIGH);
  209. digitalWrite(f HIGH);
  210. digitalWrite(c LOW);
  211. digitalWrite(d LOW);
  212. digitalWrite(e LOW);
  213. pickDigit(4);
  214. delay(250);
  215. clearLEDs();
  216. loopcount ;
  217. }
  218. }

复制代码

上面代码效果如下，为3种花样组成。
再把下面代码复制下载到控制板中，看看效果。

  1. //设置阴极接口
  2. int a = 1;
  3. int b = 2;
  4. int c = 3;
  5. int d = 4;
  6. int e = 5;
  7. int f = 6;
  8. int g = 7;
  9. int p = 8;
  10. //设置阳极接口
  11. int d4 = 9;
  12. int d3 = 10;
  13. int d2 = 11;
  14. int d1 = 12;
  15. //设置变量
  16. long n = 0;
  17. int x = 100;
  18. int del = 55; //此处数值对时钟进行微调
  19. void setup()
  20. {
  21. pinMode(d1 OUTPUT);
  22. pinMode(d2 OUTPUT);
  23. pinMode(d3 OUTPUT);
  24. pinMode(d4 OUTPUT);
  25. pinMode(a OUTPUT);
  26. pinMode(b OUTPUT);
  27. pinMode(c OUTPUT);
  28. pinMode(d OUTPUT);
  29. pinMode(e OUTPUT);
  30. pinMode(f OUTPUT);
  31. pinMode(g OUTPUT);
  32. pinMode(p OUTPUT);
  33. }
  34. void loop()
  35. {
  36. clearLEDs();
  37. pickDigit(1);
  38. pickNumber((n/x/1000));
  39. delayMicroseconds(del);

  41. clearLEDs();
  42. pickDigit(2);
  43. pickNumber((n/x/100));
  44. delayMicroseconds(del);

  46. clearLEDs();
  47. pickDigit(3);
  48. dispDec(3);
  49. pickNumber((n/x/10));
  50. delayMicroseconds(del);

  52. clearLEDs();
  53. pickDigit(4);
  54. pickNumber(n/x);
  55. delayMicroseconds(del);

  57. n ;

  59. if (digitalRead(13) == HIGH)
  60. {
  61. n = 0;
  62. }
  63. }
  64. void pickDigit(int x) //定义pickDigit(x) 其作用是开启dx端口
  65. {
  66. digitalWrite(d1 LOW);
  67. digitalWrite(d2 LOW);
  68. digitalWrite(d3 LOW);
  69. digitalWrite(d4 LOW);

  71. switch(x)
  72. {
  73. case 1:
  74. digitalWrite(d1 HIGH);
  75. break;
  76. case 2:
  77. digitalWrite(d2 HIGH);
  78. break;
  79. case 3:
  80. digitalWrite(d3 HIGH);
  81. break;
  82. default:
  83. digitalWrite(d4 HIGH);
  84. break;
  85. }
  86. }
  87. void pickNumber(int x) //定义pickNumber(x) 其作用是显示数字x
  88. {
  89. switch(x)
  90. {
  91. default:
  92. zero();
  93. break;
  94. case 1:
  95. one();
  96. break;
  97. case 2:
  98. two();
  99. break;
  100. case 3:
  101. three();
  102. break;
  103. case 4:
  104. four();
  105. break;
  106. case 5:
  107. five();
  108. break;
  109. case 6:
  110. six();
  111. break;
  112. case 7:
  113. seven();
  114. break;
  115. case 8:
  116. eight();
  117. break;
  118. case 9:
  119. nine();
  120. break;
  121. }
  122. }
  123. void dispDec(int x) //设定开启小数点
  124. {
  125. digitalWrite(p LOW);
  126. }
  127. void clearLEDs() //清屏
  128. {
  129. digitalWrite(a HIGH);
  130. digitalWrite(b HIGH);
  131. digitalWrite(c HIGH);
  132. digitalWrite(d HIGH);
  133. digitalWrite(e HIGH);
  134. digitalWrite(f HIGH);
  135. digitalWrite(g HIGH);
  136. digitalWrite(p HIGH);
  137. }
  138. void zero() //定义数字0时阴极那些管脚开关
  139. {
  140. digitalWrite(a LOW);
  141. digitalWrite(b LOW);
  142. digitalWrite(c LOW);
  143. digitalWrite(d LOW);
  144. digitalWrite(e LOW);
  145. digitalWrite(f LOW);
  146. digitalWrite(g HIGH);
  147. }
  148. void one() //定义数字1时阴极那些管脚开关
  149. {
  150. digitalWrite(a HIGH);
  151. digitalWrite(b LOW);
  152. digitalWrite(c LOW);
  153. digitalWrite(d HIGH);
  154. digitalWrite(e HIGH);
  155. digitalWrite(f HIGH);
  156. digitalWrite(g HIGH);
  157. }
  158. void two() //定义数字2时阴极那些管脚开关
  159. {
  160. digitalWrite(a LOW);
  161. digitalWrite(b LOW);
  162. digitalWrite(c HIGH);
  163. digitalWrite(d LOW);
  164. digitalWrite(e LOW);
  165. digitalWrite(f HIGH);
  166. digitalWrite(g LOW);
  167. }
  168. void three() //定义数字3时阴极那些管脚开关
  169. {
  170. digitalWrite(a LOW);
  171. digitalWrite(b LOW);
  172. digitalWrite(c LOW);
  173. digitalWrite(d LOW);
  174. digitalWrite(e HIGH);
  175. digitalWrite(f HIGH);
  176. digitalWrite(g LOW);
  177. }
  178. void four() //定义数字4时阴极那些管脚开关
  179. {
  180. digitalWrite(a HIGH);
  181. digitalWrite(b LOW);
  182. digitalWrite(c LOW);
  183. digitalWrite(d HIGH);
  184. digitalWrite(e HIGH);
  185. digitalWrite(f LOW);
  186. digitalWrite(g LOW);
  187. }
  188. void five() //定义数字5时阴极那些管脚开关
  189. {
  190. digitalWrite(a LOW);
  191. digitalWrite(b HIGH);
  192. digitalWrite(c LOW);
  193. digitalWrite(d LOW);
  194. digitalWrite(e HIGH);
  195. digitalWrite(f LOW);
  196. digitalWrite(g LOW);
  197. }
  198. void six() //定义数字6时阴极那些管脚开关
  199. {
  200. digitalWrite(a LOW);
  201. digitalWrite(b HIGH);
  202. digitalWrite(c LOW);
  203. digitalWrite(d LOW);
  204. digitalWrite(e LOW);
  205. digitalWrite(f LOW);
  206. digitalWrite(g LOW);
  207. }
  208. void seven() //定义数字7时阴极那些管脚开关
  209. {
  210. digitalWrite(a LOW);
  211. digitalWrite(b LOW);
  212. digitalWrite(c LOW);
  213. digitalWrite(d HIGH);
  214. digitalWrite(e HIGH);
  215. digitalWrite(f HIGH);
  216. digitalWrite(g HIGH);
  217. }
  218. void eight() //定义数字8时阴极那些管脚开关
  219. {
  220. digitalWrite(a LOW);
  221. digitalWrite(b LOW);
  222. digitalWrite(c LOW);
  223. digitalWrite(d LOW);
  224. digitalWrite(e LOW);
  225. digitalWrite(f LOW);
  226. digitalWrite(g LOW);
  227. }
  228. void nine() //定义数字9时阴极那些管脚开关
  229. {
  230. digitalWrite(a LOW);
  231. digitalWrite(b LOW);
  232. digitalWrite(c LOW);
  233. digitalWrite(d LOW);
  234. digitalWrite(e HIGH);
  235. digitalWrite(f LOW);
  236. digitalWrite(g LOW);
  237. }

复制代码

这次的代码为简易的秒表，效果如下，精准度不是很高，需要大家微调参数。

arduino学习笔记27 DHT11数字温湿度传感器的使用

概述

DHT11 数字温湿度传感器是一款含有已校准数字信号输出的温湿度复合传感器。它应用专用的数字模块采集技术

和温湿度传感技术，确保产品具有极高的可靠性与卓越的长期稳定性。传感器包括一个电阻式感湿元件和一个NTC 测

温元件，并与一个高性能8 位单片机相连接。因此该产品具有品质卓越、超快响应、抗干扰能力强、性价比极高等优

点。每个DHT11 传感器都在极为精确的湿度校验室中进行校准。校准系数以程序的形式储存在OTP 内存中，传感器内

部在检测信号的处理过程中要调用这些校准系数。单线制串行接口，使系统集成变得简易快捷。超小的体积、极低的

功耗，信号传输距离可达20 米以上，使其成为各类应用甚至最为苛刻的应用场合的最佳选则。

DHT11 数字温湿度传感器模块为3 针PH2.0 封装。连接方便。

性能描述

1． 供电电压：3-5.5V

2． 供电电流：最大2.5Ma

3． 温度范围：0-50℃ 误差±2℃

4． 湿度范围：20-90%RH 误差±5%RH

5． 响应时间: 1/e(63%) 6-30s

6． 测量分辨率分别为 8bit（温度）、8bit（湿度）

7． 采样周期间隔不得低于1 秒钟

8． 模块尺寸：30x20mm

传感器的时序

DATA 用于微处理器与 DHT11之间的通讯和同步 采用单总线数据格式 一次通讯时间4ms左右 数据分小数部分和

整数部分 具体格式在下面说明 当前小数部分用于以后扩展 现读出为零.操作流程如下:

一次完整的数据传输为40bit 高位先出。

数据格式:

8bit湿度整数数据 8bit湿度小数数据

8bi温度整数数据 8bit温度小数数据

8bit校验和

数据传送正确时校验和数据等于“8bit湿度整数数据 8bit湿度小数数据 8bi温度整数数据 8bit温度小数数据”所得结果的末8位。

用户MCU发送一次开始信号后 DHT11从低功耗模式转换到高速模式 等待主机开始信号结束后 DHT11发送响应信号

送出40bit的数据 并触发一次信号采集 用户可选择读取部分数据.从模式下 DHT11接收到开始信号触发一次温湿度采集 如果没有接收到主机发送开始信号 DHT11不会主动进行温湿度采集.采集数据后转换到低速模式。

模块的使用

将 DHT11 模块接到Arduino 传感器扩展板的模拟口0

代码如下：

#define DHT11_PIN 0 // ADC0 接到模拟口0

byte read_dht11_dat()

{

byte i = 0;

byte result=0;

for(i=0; i< 8; i ){

while(!(PINC & _BV(DHT11_PIN))); // wait for 50us

delayMicroseconds(30);

if(PINC & _BV(DHT11_PIN))

result |=(1<<(7-i));

while((PINC & _BV(DHT11_PIN))); // wait '1' finish

}

return result;

}

void setup()

{

DDRC |= _BV(DHT11_PIN);

PORTC |= _BV(DHT11_PIN);

Serial.begin(19200);

Serial.println("Ready");

}

void loop()

{

byte dht11_dat[5];

byte dht11_in;

byte i;

// start condition

// 1. pull-down i/o pin from 18ms

PORTC &= ~_BV(DHT11_PIN);

delay(18);

PORTC |= _BV(DHT11_PIN);

delayMicroseconds(40);

DDRC &= ~_BV(DHT11_PIN);

delayMicroseconds(40);

dht11_in= PINC & _BV(DHT11_PIN);

if(dht11_in){

Serial.println("dht11 start condition 1 not met");

return;

}

delayMicroseconds(80);

dht11_in = PINC & _BV(DHT11_PIN);

if(!dht11_in){

Serial.println("dht11 start condition 2 not met");

return;

}

delayMicroseconds(80);

// now ready for data reception

for (i=0; i<5; i )

dht11_dat[i] = read_dht11_dat();

DDRC |= _BV(DHT11_PIN);

PORTC |= _BV(DHT11_PIN);

byte dht11_check_sum = dht11_dat[0] dht11_dat[1] dht11_dat[2] dht11_dat[3];

// check check_sum

if(dht11_dat[4]!= dht11_check_sum)

{

Serial.println("DHT11 checksum error");

}

Serial.print("Current humdity = ");

Serial.print(dht11_dat[0] DEC);

Serial.print(".");

Serial.print(dht11_dat[1] DEC);

Serial.print("% ");

Serial.print("temperature = ");

Serial.print(dht11_dat[2] DEC);

Serial.print(".");

Serial.print(dht11_dat[3] DEC);

Serial.println("C ");

delay(2000);

}

编译代码后下载到Arduino 中，打开串口助手即可看见实际测量的温度与湿度。

网站首页

返回栏目

猜您喜欢：

相关文章