最新消息:

Arduino 语法

Arduino 少儿编程 2172浏览 0评论

Arduino 语法

程序结构一个Arduino程序分为两部分:

void setup()在这个函数里防止初始化Arduino的程序,使主循环程序在开始之前设置好相关参数。

void loop

()这是Arduino的主函数。这套程序会一直重复执行,直到电源被断开。

[if !supportLineBreakNewLine]

[endif]

控制语句类似于Cif    

if…else       for  switch case     while     do… while     break      continue        return     goto

Arduino利用了一些关键字控制了程序的执行流程。

If…else

If

后面的括号里必须要有一个表示判断的表达式。如果表达式为真,则继续执行下面的语句;如果是假,则下面的代码将被跳过,执行else下的指令代码。你也可以只用if而不搭配else。例如:

If(val == 1){

digtalWrite(LED,HIGH);

}

for

用来指明一段代码重复的次数。例如:

for(int I = 0; i< 10; i++){

Serial.print(“TSRobot”);

}

switch

case

如果说if就像程序的岔路口,那么switch case就像一个多选择环形路口。switch case根据变量的数值让程序有了更多的选择,比起一长串的if函数,switch case可以让程序看上去更为简洁。例如:

switch (sensorValue){

case 23:

digitalWrite(13,HIGH);

break;

case 46:

digitalWrite(12,HIGH);

break;

default: //

以上条件都不满足时执行预设指令

digitalWrite(13,LOW);

digitalWrite(12,LOW);

}

While

当whileh后的条件成立时,执行大括号内的程序代码。例如:

//当sensor值小于512时,让LED闪烁

sensorValue = analogRead(1);

while(sensorValue

< 512){

digitalWrite(13,HIGH);

delay(100);

digitalWrite(13,LOW);

delay(100);

sensorValue = aalogRead(1);

}

do…while

与while相似,但不同之处在于:while函数是先判断while后的表达式;而do…while是先执行do后的程度段,再对while后的表达式进行判断。因此do…while的主程序段至少会被执行一次。例如:

do {

digtialWrite(13,HIGH);

delay(100);

digtialWrite(13,LOW);

delay(100);

sensorVaule = analogRead(1);

} while(sensorVaule < 512);

break

这个语句可以让程序跳出一个循环,然后继续执行循环之后的程序代码段。也用于分隔switch case语句的不同部分。例如:

//当sensor值小于512时,让LED闪烁。

do {

//当按键按下时跳出循环

If(digitalRead(7) == HIGH)

Break;

digtialWrite(13,HIGH);

delay(100);

digtialWrite(13,LOW);

delay(100);

sensorVaule = analogRead(1);

} while(sensorVaule < 512);

continue

在循环程序中使用,能让你跳过程序里的某些部分,然后再次判断表达式。例如:

for( light = 0; light <255; light++){

//忽略介于140至200之间的数值

If((x > 140) && (x < 200))

continue;

analogWrite(PWMpin, light);

delay(10);

}

return

用return在一个函数的结尾返回一个数值。例如,现在有一个函数叫做computeTemperature(),你想要传回储存在目前变量中的温度值,你可以这样写程序:

int computeTemperature(){

int temperature = 0;

temperature = (analogRead(0) + 45) / 100;

return temperature;

}

扩展语法类似于C;(分号)     {}(花括号)     //(单行注释)        /* */(多行注释)     #define 

#includeArduino语言运用了一些符号来描绘程序代码,例如,注释和程序部分。;(分号)Arduino每条指令(代码行)都以分号结束。这样的语法可以让你自由安排车刚需代码,甚至可以将两条指令放在同一行,只要你用一个分号把它们隔开就行了(然而,这样做会让你的程序代码更难以阅读)。例如:

delay(100);

{}

(大括号)用来注释程序代码的分区。例如,当你为loop()函数编写代码时,必须咱编码的前后用大括号括起来。例如:

void loop(){

serial.println(“TSRobot”);

}

注释

这是Arduino程序编译中忽略的一部分,但是它有助于提醒你自己或别人这小段程序代码的功能。在Arduino里有两种形式的注释。

//单行注释:这行会被忽略掉

/*

多行注释:你可以在这里写出一整首诗

*/

 

算数运算符类似于C=(赋值运算符)      +(加)        -(减)        *(乘)        /(除)        %(模)

你可以通过特殊语法让Arduino去做一些复杂的运算。+和–就是我们在学校学习的加减法,乘法用*表示,除法用/表示。例如:

a = 2 + 2;

light = ((12 * sensorValue) – 5 ) / 2;

remainder = 3 % 2; //

返回1,因为3除以2余1比较运算符类似于C==(等于)        !=(不等于)     <(小于)        >(大于)        <=(小于等于)     >=(大于等于)

 

当你在运用if,while,for,函数时,可以用到下列比较运算符:

==

等于

!=

不等于

<

小于

>

大于

<=

小于等于

>=

大于等于布尔运算符当你要结合多个判断条件时,可以用到布尔运算符。例如,你要检测一个传感器的返回值是否是5至10之间的数,你可以这样写程序:

if((sensor >= 5) && (sensor <=

10))

布尔运算符类似于C&&(与)     ||(或)       !(非)

 

指针运算符类似于C* 取消引用运算符     & 引用运算符

 

位运算符类似于C    & (bitwise and) 

| (bitwise or)      ^ (bitwise xor)

~ (bitwise not)     << (bitshift

left)        >> (bitshift right)

 

复合运算符类似于C    ++ (increment)    

– (decrement)      += (compound addition)

-= (compound subtraction)       *=

(compound multiplication)        /= (compound

division)      &= (compound bitwise and)

|= (compound bitwise or)

 

这些运算符常用唉类似于“递增”这些常见的函数中,让程序代码看上去更整洁。例如,让变量自身加1可以写成:

value = value + 1

;但也可以使用复合运算符把上面的式子简化成:

value++

;递增和递减(++和 —)当对一个数值进行递增或递减时,要注意一点,那就是i++和++i之间的不同。i++是将i的值加1使i的值等于i+1;而当使用++i时,i在第一次执行程序时是i,直到第二次执行程序时才会被加1。这个原理同样适用于—。

+=

,-=,*=及/=这些运算符可以使程序运算式更加精简,下面是两个等价式:

a = a + 5;

a += 5;

常量constants 预定义的常量

BOOL    true false

 

Arduino语言有一些特殊意义的关键字。例如:

HIGH

和LOW用来表示你打开或关闭(高电平或者低电平);

Arduino

的一个引脚(pin),INPUT和OUTPUT用来设定某个特定引脚是输入接口还是输出接口;

INPUT_PULLUP

用来设定某个引脚为输入,并且被拉高;

True

和False,像它们的字面意思一样;表示一个条件或一个运算是真还是假。

 

引脚电压定义,HIGH和LOW【当读取(read)或写入(write)数字引脚时只有两个可能的值: HIGH 和 LOW 】

HIGH

(参考引脚)的含义取决于引脚(pin)的设置,引脚定义为INPUT或OUTPUT时含义有所不同。当一个引脚通过pinMode被设置为INPUT,并通过digitalRead读取(read)时。如果当前引脚的电压大于等于3V,微控制器将会返回为HIGH。 引脚也可以通过pinMode被设置为INPUT,并通过digitalWrite设置为HIGH。输入引脚的值将被一个内在的20K上拉电阻 控制 在HIGH上,除非一个外部电路将其拉低到LOW。 当一个引脚通过pinMode被设置为OUTPUT,并digitalWrite设置为HIGH时,引脚的电压应在5V。在这种状态下,它可以 输出电流 。例如,点亮一个通过一串电阻接地或设置为LOW的OUTPUT属性引脚的LED。

LOW

的含义同样取决于引脚设置,引脚定义为INPUT或OUTPUT时含义有所不同。当一个引脚通过pinMode配置为INPUT,通过digitalRead设置为读取(read)时,如果当前引脚的电压小于等于2V,微控制器将返回为LOW。 当一个引脚通过pinMode配置为OUTPUT,并通过digitalWrite设置为LOW时,引脚为0V。在这种状态下,它可以 倒灌 电流。例如,点亮一个通过串联电阻连接到+5V,或到另一个引脚配置为OUTPUT、HIGH的的LED。

 

 

数字引脚(Digital

pins定义,INPUT和OUTPUT【数字引脚当作 INPUT 或 OUTPUT都可以 。用pinMode()方法使一个数字引脚从INPUT到OUTPUT变化】

Arduino

(Atmega)引脚通过pinMode()配置为 输入(INPUT) 即是将其配置在一个高阻抗的状态。配置为INPUT的引脚可以理解为引脚取样时对电路有极小的需求,即等效于在引脚前串联一个100兆欧姆(Megohms)的电阻。这使得它们非常利于读取传感器,而不是为LED供电。

 

引脚通过pinMode()配置为 输出(OUTPUT) 即是将其配置在一个低阻抗的状态。

 

这意味着它们可以为电路提供充足的电流。Atmega引脚可以向其他设备/电路提供(提供正电流positive current)或倒灌(提供负电流negative current)达40毫安(mA)的电流。这使得它们利于给LED供电,而不是读取传感器。输出(OUTPUT)引脚被短路的接地或5V电路上会受到损坏甚至烧毁。Atmega引脚在为继电器或电机供电时,由于电流不足,将需要一些外接电路来实现供电。

 

 

 

整数常量    进制          例子      格式    备注

10

(十进制)   123        无

2

(二进制)  B1111011前缀’B’  只适用于8位的值(0到255)字符0-1有效

8

(八进制)   0173    前缀”0”  字符0-7有效

16

(十六进制)0x7B    前缀”0x”  字符0-9,A-F,A-F有效

 

 

小数是十进制数。这是数学常识。如果一个数没有特定的前缀,则默认为十进制。

 

二进制以2为基底,只有数字0和1是有效的。

 

‘u’ or ‘U’

指定一个常量为无符号型。(只能表示正数和0) 例如: 33u

‘l’ or ‘L’

指定一个常量为长整型。(表示数的范围更广) 例如:

100000L

‘ul’ or ‘UL’

这个你懂的,就是上面两种类型,称作无符号长整型。 例如:32767ul

 

 

 

浮点常量    浮点数 被转换为 

被转换为

10.0

10

2.34E5  2.34 * 10^5

234000

67E-12  67.0 *

10^-12   0.000000000067

 

数据类型类似于C    void    

boolean     char

unsigned char       byte

int     unsigned int

word

long

unsigned long       float

double      string – char array

String – object     array -

(数组)

 

变量保存在Arduino内存中,它可以用来保存数据,你可以应用这个变量的数据来计算或者将这个数据应用到程序中。正如字面意思,变量在程序中是可以随便更改的。因为Arduino是一个非常简单的微处理器,所以当你声明一个变量时,还必须指定它的类型。这意味着告诉处理器为你所要存储的数据留出多大的空间。下面是一些常见的数据类型:

Boolean

(布尔)只能是真或者假两种值。

char

(字符)保存一个字符,如“A”。和任何计算机一样,Arduino将字符存储为一个数字,虽然你拷打的是文字。当字符用数字里存储时,数值范围是-128到127。注意:在计算机系统里主要有两组有效字符:ASCII和UNICODE。ASCII有127个可用字符,主要用于串行终端之间文本的传输,相应的计算机系统的例子如大型机、小型机之间传送文本。UNICODE在现代计算机操作系统中有大量的实用字符,可以代表多种语言。在传输短字节语言方面,ASCII仍很实用,如只用拉丁文(意大利语、英语)、阿拉伯数字、常见的打印机符号、标点符号等情况。

byte

(字节)存储0-255的数字。像char一样,byte只能用一个字节(8位)的存储空间。

int

(整型)用2个字节表示一个内存空间,从-32768到32767之间的整数,这是用于Arduino的最普遍的数据类型之一。

unsigned

int

(无符号整型)像int一样,也用2个字节的空间,但是无符号的前缀意味着它不能存储负数,它的范围是0-65535。

long

(长整型)它是int的两倍大小。能够存储-2147483648到2417483647之间的数字。

unsigned

long

(无符号长整型)无符号长整型的范围是0到4294967295

float

(浮点型)它的存储空间很大,能够存储浮点值,你能用它存储带小数的数字,每个浮点型会用掉四个字节,所以要谨慎使用。

double

(双精度浮点型)双精度浮点数最大值为1.797

693 134 862 315 7乘以10的308次方。哇,非常大!

string

(字符串)用一组ASCII字符来存储文本信息(你可以用字符串通过串口发送一条信息、或者在LCD显示屏上展示)。字符串的每一个字符会占用一个字节的存储空间,加上一个零字符。表示字符串的结束。用两种表达方:

char string1[] = “Arduino”; //7

个字符 + 1个零字符

char string2[] = “Arduino”; //

同上

array

(数组)数组就是通过索引存取的变量列表,它们用来建立数值的表格。例如,如果你想存储不同亮度的LED值,你固然可以创立6个变量,分别为light01、light02等,但更好的方法是用一个像int light[6] = {0,20,50,75,100,150};这样的数组。

array

这个词实际上不用在变量声明:数组用符号[]和{}来表示即可。数据类型转换类似于C    char()    

byte()      int()

word()      long()      float()

word()

 

把一个值转换为word数据类型的值,或由两个字节创建一个字符。

word(x)

word(h, l)

 

参数

X

:任何类型的值

H

:高阶(最左边)字节

L

:低序(最右边)字节

 

修饰符类似于C    static    

volatile        const

 

辅助工具    sizeof()

数字I/O

pinMode(pin, mode)    将指定的引脚配置成输出或输入【pinMode(pin, mode) pin:要设置模式的引脚  mode:INPUT或OUTPUT】

 

例子:

ledPin = 13 // LED

连接到数字脚13

void setup()

{

pinMode

(ledPin,OUTPUT); //设置数字脚为输出

}

void loop()

{

digitalWrite

(ledPin,HIGH); //点亮LED

 

delay(1000);

//

等待一秒

 

digitalWrite(ledPin, LOW);    //

灭掉LED

 

delay(1000);  //

等待第二个

}

 

digitalWrite(pin, value)    给一个数字引脚写入HIGH或者LOW。

 

如果一个引脚已经使用pinMode()配置为OUTPUT模式,其电压将被设置为相应的值,HIGH为5V(3.3V控制板上为3.3V),LOW为0V。

 

如果引脚配置为INPUT模式,使用digitalWrite()写入HIGH值,将使内部20K上拉电阻(详见数字引脚教程)。写入LOW将会禁用上拉。上拉电阻可以点亮一个LED让其微微亮,如果LED工作,但是亮度很低,可能是因为这个原因引起的。补救的办法是 使用pinMode()函数设置为输出引脚。

 

注意:数字13号引脚难以作为数字输入使用,因为大部分的控制板上使用了一颗LED与一个电阻连接到他。如果启动了内部的20K上拉电阻,他的电压将在1.7V左右,而不是正常的5V,因为板载LED串联的电阻把他使他降了下来,这意味着他返回的值总是LOW。如果必须使用数字13号引脚的输入模式,需要使用外部上拉下拉电阻。

 

 

digitalRead(pin)

digitalRead

(PIN)【pin:你想读取的引脚号(int),返回 HIGH 或 LOW】

 

例子:

ledPin = 13 // LED

连接到13脚

int inPin = 7;   //

按钮连接到数字引脚7

int val = 0;  //

定义变量存以储读值

void setup()

{

 

pinMode(ledPin, OUTPUT);      //

将13脚设置为输出

 

pinMode(inPin, INPUT);      //

将7脚设置为输入

}

void loop()

{

val =

digitalRead(inPin);   //

读取输入脚

 

digitalWrite(ledPin, val);    //

将LED值设置为按钮的值

}

 

模拟 I/O

analogReference(type)配置用于模拟输入的基准电压(即输入范围的最大值)。选项有:

DEFAULT

:默认5V(Arduino板为5V)或3.3伏特(Arduino板为3.3V)为基准电压。

INTERNAL

:在ATmega168和ATmega328上以1.1V为基准电压,以及在ATmega8上以2.56V为基准电压(Arduino Mega无此选项)

INTERNAL1V1

:以1.1V为基准电压(此选项仅针对Arduino Mega)

INTERNAL2V56

:以2.56V为基准电压(此选项仅针对Arduino Mega)

EXTERNAL

:以AREF引脚(0至5V)的电压作为基准电压。

type

:使用哪种参考类型(DEFAULT, INTERNAL, INTERNAL1V1, INTERNAL2V56, 或者 EXTERNAL)

 

改变基准电压后,之前从anal??ogRead()读取的数据可能不准确。

 

不要在AREF引脚上使用使用任何小于0V或超过5V的外部电压。如果你使用AREF引脚上的电压作为基准电压,你在调用analogRead()前必须设置参考类型为EXTERNAL。否则,你将会削短有效的基准电压(内部产生)和AREF引脚,这可能会损坏您Arduino板上的单片机。

 

另外,您可以在外部基准电压和AREF引脚之间连接一个5K电阻,使你可以在外部和内部基准电压之间切换。请注意,总阻值将会发生改变,因为AREF引脚内部有一个32K电阻。这两个电阻都有分压作用。所以,例如,如果输入2.5V的电压,最终在在AREF引脚上的电压将为2.5 * 32 /(32 + 5)= 2.2V。

 

 

analogRead(pin)

 

从指定的模拟引脚读取数据值。 Arduino板包含一个6通道(Mini和Nano有8个通道,Mega有16个通道),10位模拟数字转换器。这意味着它将0至5伏特之间的输入电压映射到0至1023之间的整数值。这将产生读数之间的关系:5伏特/ 1024单位,或0.0049伏特(4.9 mV)每单位。输入范围和精度可以使用analogReference()改变。 它需要大约100微秒(0.0001)来读取模拟输入,所以最大的阅读速度是每秒10000次。

analogRead

(PIN)

 

引脚:从输入引脚(大部分板子从0到5,Mini和Nano从0到7,Mega从0到15)读取数值,返回从0到1023的整数值

 

例子:

int analogPin = 3;    //

电位器(中间的引脚)连接到模拟输入引脚3

 

//

另外两个引脚分别接地和+5 V

int val = 0;  //

定义变量来存储读取的数值

void setup()

{

 

serial.begin

(9600); //设置波特率(9600)

}

void loop()

{

val =

analogRead

(analogPin); //从输入引脚读取数值

 

serial.println

(val); //显示读取的数值

}

 

 

analogWrite() – PWM

analogWrite

pin,value    从一个引脚输出模拟值(PWM)。可用于让LED以不同的亮度点亮或驱动电机以不同的速度旋转。analogWrite()输出结束后,该引脚将产生一个稳定的特殊占空比方波,直到下次调用analogWrite()(或在同一引脚调用digitalRead()或digitalWrite())。PWM信号的频率大约是490赫兹。

 

在大多数arduino板(ATmega168或ATmega328),只有引脚3,5,6,9,10和11可以实现该功能。在aduino Mega上,引脚2到13可以实现该功能。老的Arduino板(ATmega8)的只有引脚9、10、11可以使用analogWrite()。在使用analogWrite()前,你不需要调用pinMode()来设置引脚为输出引脚。

analogWrite

函数与模拟引脚、analogRead函数没有直接关系。

pin

:用于输入数值的引脚。

value

:占空比:0(完全关闭)到255(完全打开)之间。

 

例子:

int ledPin = 9;  // LED

连接到数字引脚9

int analogPin = 3;  //

电位器连接到模拟引脚3

int val = 0;  //

定义变量存以储读值

void setup()

{

pinMode

(ledPin,OUTPUT);  //设置引脚为输出引脚

}

void loop()

{

val =

analogRead

(analogPin);  //从输入引脚读取数值

 

analogWrite

(ledPin,val / 4);  // 以val / 4的数值点亮LED(因为analogRead读取的数值从0到1023,而analogWrite输出的数值从0到255)

}

高级I/O

    tone()    在一个引脚上产生一个特定频率的方波(50%占空比)。持续时间可以设定,否则波形会一直产生直到调用noTone()函数。该引脚可以连接压电蜂鸣器或其他喇叭播放声音。

 

在同一时刻只能产生一个声音。如果一个引脚已经在播放音乐,那调用tone()将不会有任何效果。如果音乐在同一个引脚上播放,它会自动调整频率。

 

使用tone()函数会与3脚和11脚的PWM产生干扰(Mega板除外)。

 

注意:如果你要在多个引脚上产生不同的音调,你要在对下一个引脚使用tone()函数前对此引脚调用noTone()函数。

tone(pin, frequency) 

tone(pin, frequency, duration)

pin

:要产生声音的引脚

frequency:

产生声音的频率,单位Hz,类型unsigned int

duration

:声音持续的时间,单位毫秒(可选),类型unsigned long

 

 

noTone()

 

停止由tone()产生的方波。如果没有使用tone()将不会有效果。

 

noTone(pin)

pin:

所要停止产生声音的引脚

 

 

shiftOut()

 

将一个数据的一个字节一位一位的移出。从最高有效位(最左边)或最低有效位(最右边)开始。依次向数据脚写入每一位,之后时钟脚被拉高或拉低,指示刚才的数据有效。

 

注意:如果你所连接的设备时钟类型为上升沿,你要确定在调用shiftOut()前时钟脚为低电平,如调用digitalWrite(clockPin, LOW)。

 

注意:这是一个软件实现;Arduino提供了一个硬件实现的SPI库,它速度更快但只在特定脚有效。

 

shiftOut(dataPin, clockPin, bitOrder, value)

dataPin

:输出每一位数据的引脚(int)

clockPin

:时钟脚,当dataPin有值时此引脚电平变化(int)

bitOrder

:输出位的顺序,最高位优先或最低位优先

value:

要移位输出的数据(byte)

dataPin

和clockPin要用pinMode()配置为输出。 shiftOut目前只能输出1个字节(8位),所以如果输出值大于255需要分两步。

//

最高有效位优先串行输出

int data= 500;

//

移位输出高字节

shiftOut(dataPin, clock, MSBFIRST,

(data >> 8));

//

移位输出低字节

shiftOut(data, clock, MSBFIRST,

data);

//

最低有效位优先串行输出

data = 500;

//

移位输出低字节

shiftOut(dataPin, clock, LSBFIRST,

data);

//

移位输出高字节

shiftOut(dataPin, clock, LSBFIRST,

(data >> 8));

 

例子:

 

相应电路,查看tutorial on controlling a 74HC595 shift

register

//

引脚连接到74HC595的ST_CP

int latchPin = 8;

//

引脚连接到74HC595的SH_CP

int clockPin = 12;

// //

引脚连接到74HC595的DS

int dataPin = 11;

void setup() {

//

设置引脚为输出

 

pinMode(latchPin, OUTPUT);

 

pinMode(clockPin, OUTPUT);

 

pinMode(dataPin, OUTPUT);

}

void loop() {

//

向上计数程序

for(J = 0;

J <256; J + +){

 

//

传输数据的时候将latchPin拉低

 

digitalWrite(latchpin, LOW);

 

shiftOut(dataPin,clockPin,LSBFIRST,J);

 

//

之后将latchPin拉高以告诉芯片

 

//

它不需要再接受信息了

 

digitalWrite(latchpin, HIGH);

 

delay(1000);

}

}

 

 

shiftIn()

 

将一个数据的一个字节一位一位的移入。从最高有效位(最左边)或最低有效位(最右边)开始。对于每个位,先拉高时钟电平,再从数据传输线中读取一位,再将时钟线拉低。

 

注意:这是一个软件实现;Arduino提供了一个硬件实现的SPI库,它速度更快但只在特定脚有效。

 

shiftIn(dataPin,clockPin,bitOrder)

dataPin

:输出每一位数据的引脚(int)

clockPin

:时钟脚,当dataPin有值时此引脚电平变化(int)

bitOrder

:输出位的顺序,最高位优先或最低位优先

 

 

pulseIn()

 

读取一个引脚的脉冲(HIGH或LOW)。例如,如果value是HIGH,pulseIn()会等待引脚变为HIGH,开始计时,再等待引脚变为LOW并停止计时。返回脉冲的长度,单位微秒。如果在指定的时间内无脉冲函数返回。

 

此函数的计时功能由经验决定,长时间的脉冲计时可能会出错。计时范围从10微秒至3分钟。(1秒=1000毫秒=1000000微秒)

pulseIn(pin, value) 

pulseIn(pin, value, timeout)

pin:

你要进行脉冲计时的引脚号(int)。

value:

要读取的脉冲类型,HIGH或LOW(int)。

timeout (

可选):指定脉冲计数的等待时间,单位为微秒,默认值是1秒(unsigned long)

 

返回:脉冲长度(微秒),如果等待超时返回0(unsigned long)

 

例子:

int pin = 7;

unsigned long duration;

void setup()

{

 

pinMode(pin, INPUT);

}

void loop()

{

duration =

pulseIn(pin, HIGH);;

}

[if !supportLineBreakNewLine]

[endif]

时间

 millis()    返回Arduino开发板从运行当前程序开始的毫秒数。这个数字将在约50天后溢出(归零)

 

例子:

unsigned long time;

void setup(){

 

Serial.begin(9600)

}

void loop(){

 

serial.print(“Time:”);

time =

millis();

//

打印从程序开始到现在的时间

 

serial.println(time);

//

等待一秒钟,以免发送大量的数据

 

delay(1000);

}

 

参数 millis 是一个无符号长整数,试图和其他数据类型(如整型数)做数学运算可能会产生错误

 

 

micros()

 

返回 Arduino 开发板从运行当前程序开始的微秒数。这个数字将在约70分钟后溢出(归零)。在 16MHz 的 Arduino 开发板上(比如 Duemilanove 和 Nano),这个函数的分辨率为四微秒(即返回值总是四的倍数)。在 8MHz 的 Arduino 开发板上(比如 LilyPad),这个函数的分辨率为八微秒。

 

注意 :每毫秒是1,000微秒,每秒是1,000,000微秒。

 

例子:

unsigned long time;

void setup(){

 

Serial.begin(9600);

}

void loop(){

 

Serial.print

(“Time:”);

time =

micros();

//

打印从程序开始的时间

 

Serial.println(time);

//

等待一秒钟,以免发送大量的数据

delay(1000);

}

 

 

delay()

 

使程序暂停设定的时间(单位毫秒)。(一秒等于1000毫秒)

 

参数:ms:暂停的毫秒数(unsigned long)

 

例子:

ledPin = 13 / / LED

连接到数字13脚

void setup()

{

 

pinMode(ledPin, OUTPUT);      //

设置引脚为输出

}

void loop()

{

digitalWrite(ledPin,

HIGH);   //

点亮LED

 

delay(1000);

//

等待1秒

 

digitalWrite(ledPin, LOW);    //

灭掉LED

 

delay(1000);

//

等待一秒

}

 

虽然创建一个使用delay()的闪烁LED很简单,并且许多例子将很短的delay用于消除开关抖动,delay()确实拥有很多显著的缺点。在delay函数使用的过程中,读取传感器值、计算、引脚操作均无法执行,因此,它所带来的后果就是使其他大多数活动暂停。其他操作定时的方法请参加millis()函数和它下面的例子。大多数熟练的程序员通常避免超过10毫秒的delay(),除非arduino程序非常简单。

 

但某些操作在delay()执行时任然能够运行,因为delay函数不会使中断失效。通信端口RX接收到得数据会被记录,PWM(analogWrite)值和引脚状态会保持,中断也会按设定的执行。

 

 

delayMicroseconds()

 

使程序暂停指定的一段时间(单位微秒)。一毫秒等于一千微秒,一秒等于1000000微秒。 目前,能够产生的最大的延时准确值是16383。这可能会在未来的Arduino版本中改变。对于超过几千微秒的延迟,你应该使用delay()代替。

 

例子:

int outPin = 8;

// digital pin 8

void setup()

{

pinMode

(outPin,OUTPUT); //设置为输出的数字管脚

}

void loop()

{

 

digitalWrite

(outPin,HIGH); //设置引脚高电平

 

delayMicroseconds(50);

//

暂停50微秒

 

digitalWrite(outPin, LOW);    //

设置引脚低电平

 

delayMicroseconds(50);

//

暂停50微秒

}

数学运算

min()       max()

abs()

constrain(x,a,b)

【将一个数约束在一个范围内】

map(value, fromLow, fromHigh,

toLow, toHigh)

value:

需要映射的值

fromLow:

当前范围值的下限

fromHigh:

当前范围值的上限

toLow:

目标范围值的下限

toHigh:

目标范围值的上限

 

例子:

void setup(){}

void loop()

{

int val = analogRead(0);

val =

map(val, 0, 1023, 0, 255);

 

analogWrite(9, val);

}

例如:

val = map(analogRead(0), 0,1023, 100, 200);

//

将模拟接口0读取的0~1023的值转换成0~100的值

[if !supportLineBreakNewLine]

[endif]

数学实现

long map(long x, long in_min, long in_max, long

out_min, long out_max)

{

return (x – in_min) *

(out_max – out_min) / (in_max – in_min) + out_min;

}

 

pow(base, exponent)

sqrt(x)

三角函数

sin()       cos()

tan()

随机数

randomSeed()【随机数种子】     random()【random(max),random(min, max)】

 

如果你需要随机数,你可以利用Arduino的随机数函数来产生随机数。

randomSeed(seed)

复位Arduino的随机数发生器,会产生一系列的随机数,虽然这些数字貌似是随机产生,但是它们的顺序其实还是可以被预测的。所以如果我们需要真正的一组随机数,我们就要重新设定随机数的种子。若我们没有连接一个模拟值引脚,它可以从周围环境(无线电波、宇宙射线、手机或者荧光灯的电磁干扰等)获得随机噪声。例如:

randomSeed(analogRead(5)); //

利用5号引脚的噪声

long

random(max)

long random(min, max)

传回指定区间的长整型随机数。如果没有规定最小值,则默认最小值为0。例如:

long randnum = random(o, 100); //

传回一个介于0~100之间的数

long randnum = random(11); //

传回一个介于0~10之间的数

[if !supportLineBreakNewLine]

[endif]

位操作

lowByte()   取一个变量(例如一个字)的低位(最右边)字节。

highByte()

提取一个字节的高位(最左边的),或一个更长的字节的第二低位。

bitRead()

读取一个数的位。bitRead(x, n) X:想要被读取的数 N:被读取的位,0是最重要(最右边)的位    该位的值(0或1)

bitWrite()

在位上写入数字变量   bitWrite(x, n, b)   X:要写入的数值变量 N:要写入的数值变量的位,从0开始是最低(最右边)的位 B:写入位的数值(0或1)

bitSet()

为一个数字变量设置一个位    bitSet(x, n)    X:想要设置的数字变量 N:想要设置的位,0是最重要(最右边)的位

bitClear()

清除一个数值型数值的指定位(将此位设置成 0) bitClear(x, n)  X:指定要清除位的数值 N:指定要清除位的位置,从0开始,0 表示最右端位

bit()

计算指定位的值(0位是1,1位是2,2位4,以此类推) bit(n)  需要计算的位

设置中断函数

    attachInterrupt()

attachInterrupt(interrupt,

function, mode)

当发生外部中断时,调用一个指定函数。当中断发生时,该函数会取代正在执行的程序。大多数的Arduino板有两个外部中断:0(数字引脚2)和1(数字引脚3)。

arduino Mege

有四个外部中断:数字2(引脚21),3(20针),4(引脚19),5(引脚18)

 

interrupt

:中断引脚数

function

:中断发生时调用的函数,此函数必须不带参数和不返回任何值。该函数有时被称为中断服务程序。

mode

:定义何时发生中断以下四个contstants预定有效值:

LOW

当引脚为低电平时,触发中断

CHANGE

当引脚电平发生改变时,触发中断

RISING

当引脚由低电平变为高电平时,触发中断

FALLING

当引脚由高电平变为低电平时,触发中断.

 

 

当中断函数发生时,delya()和millis()的数值将不会继续变化。当中断发生时,串口收到的数据可能会丢失。你应该声明一个变量来在未发生中断时储存变量。

 

在单片机自动化程序中当突发事件发生时,中断是非常有用的,它可以帮助解决时序问题。一个使用中断的任务可能会读一个旋转编码器,监视用户的输入。

 

如果你想以确保程序始终抓住一个旋转编码器的脉冲,从来不缺少一个脉冲,它将使写一个程序做任何事情都要非常棘手,因为该计划将需要不断轮询的传感器线编码器,为了赶上脉冲发生时。其他传感器也是如此,如试图读取一个声音传感器正试图赶上一按,或红外线槽传感器(照片灭弧室),试图抓住一个硬币下降。在所有这些情况下,使用一个中断可以释放的微控制器来完成其他一些工作。

 

 

例子:

int pin = 13;

volatile int state = LOW;

 

void setup()

{

 

pinMode(pin, OUTPUT);

 

attachInterrupt(0, blink, CHANGE);

}

void loop()

{

 

digitalWrite(pin, state);

}

void blink()

{

state =

!state;

}

 

 

detachInterrupt()

 

关闭给定的中断

 

detachInterrupt(interrupt)

interrupt:

中断禁用的数(0或者1)

   开关中断

    interrupts()    重新启用中断(使用noInterrupts()命令后将被禁用)。中断允许一些重要任务在后台运行,默认状态是启用的。禁用中断后一些函数可能无法工作,并传入信息可能会被忽略。中断会稍微打乱代码的时间,但是在关键部分可以禁用中断

 

noInterrupts()

 

禁止中断(重新使能中断interrupts())。中断允许在后台运行一些重要任务,默认使能中断。禁止中断时部分函数会无法工作,通信中接收到的信息也可能会丢失。

 

中断会稍影响计时代码,在某些特定的代码中也会失效

 

例子:

void setup()

void loop()

{

 

noInterrupts

();

//

关键的、时间敏感的代码放在这

 

interrupts();

//

其他代码放在这

}

通讯

Serial

用于Arduino控制板和一台计算机或其他设备之间的通信。所有的Arduino控制板有至少一个串口(又称作为UART或USART)。它通过0(RX)和1(TX)数字引脚经过串口转换芯片连接计算机USB端口与计算机进行通信。因此,如果你使用这些功能的同时你不能使用引脚0和1作为输入或输出。您可以使用Arduino IDE内置的串口监视器与Arduino板通信。点击工具栏上的串口监视器按钮,调用begin()函数(选择相同的波特率)。

Arduino Mega

有三个额外的串口:Serial 1使用19(RX)和18(TX),Serial 2使用17(RX)和16(TX),Serial3使用15(RX)和14(TX)。 若要使用这三个引脚与您的个人电脑通信,你需要一个额外的USB转串口适配器,因为这三个引脚没有连接到Mega上的USB转串口适配器。若要用它们来与外部的TTL串口设备进行通信,将TX引脚连接到您的设备的RX引脚,将RX引脚连接到您的设备的TX引脚,将GND连接到您的设备的GND。(不要直接将这些引脚直接连接到RS232串口;他们的工作电压在+/- 12V,可能会损坏您的Arduino控制板。)Arduino Leonardo板使用Serial 1通过0(RX)和1(TX)与viaRS-232通信,。Serial预留给使用Mouse and Keyboard libarariies的USB CDC通信 。更多信息,请参考Leonardo 开始使用页和硬件页。函数:

 

if (Serial)

 

表示指定的串口是否准备好

 

在Leonardo上,if(Serial)表示不论有无USB CDC,串行连接都是开放的。对于所有其他的情况,包括Leonardo上的if(Serial1),将一直返回true。 这来自于Arduino 1.0.1 版本的介绍

 

对于所有的arduino板:  if (Serial)

Arduino

Leonardo

特有:

if (Serial1)

Arduino

Mega

特有:

if (Serial1)

if (Serial2)

 

if (Serial3)

 

 

available()

 

获取从串口读取有效的字节数(字符)。这是已经传输到,并存储在串行接收缓冲区(能够存储64个字节)的数据。 available()继承了 Stream类

 

Serial.available()

 

仅适用于Arduino Mega :

Serial1.available()

Serial2.available()

 

Serial3.available()

 

例子:

 

incomingByte = 0; //

传入的串行数据

void

setup() {

 

Serial.begin(9600);     //

打开串行端口,设置传输波特率为9600 bps

}

void

loop() {

 

//

只有当你接收到数据时才会发送数据,:

 

if (Serial.available() > 0) {

 

//

读取传入的字节:

 

incomingByte = Serial.read();

 

//

显示你得到的数据:

 

Serial.print(“I received: “);

 

Serial.println(incomingByte, DEC);

 

}

}

 

 

begin()

 

将串行数据传输速率设置为位/秒(波特)。与计算机进行通信时,可以使用这些波特率:300,1200,2400,4800,9600,14400,19200,28800,38400,57600或115200。当然,您也可以指定其他波特率 – 例如,引脚0和1和一个元件进行通信,它需要一个特定的波特率

 

Serial.begin(speed)

仅适用于Arduino Mega : Serial1.begin(speed)

Serial2.begin(speed) Serial3.begin(speed)

speed:

位/秒 (波特) -

long

 

 

end()

 

停用串行通信,使RX和TX引脚用于一般输入和输出。要重新使用串行通信, 需要Serial.begin()语句

 

Serial.end()

 

仅适用于Arduino Mega: Serial1.end() Serial2.end()

Serial3.end()

 

 

find()

 

Serial.find()

从串行缓冲器中读取数据,直到发现给定长度的目标字符串。如果找到目标字符串,该函数返回true,如果超时则返回false

 

Serial.flush()

继承了 Stream 类

Serial.find(target)

target :

要搜索的字符串(字符)

 

 

findUntil()

 

Serial.findUntil()

从串行缓冲区读取数据,直到找到一个给定的长度或字符串终止位。

 

如果目标字符串被发现,该函数返回true,如果超时则返回false。

 

Serial.findUntil()

继承了Stream类。

 

Serial.findUntil(target, terminal)

target :

要搜索的字符串(char) terminal : 在搜索中的字符串终止位 (char)

 

 

flush()

 

等待超出的串行数据完成传输。(在1.0及以上的版本中,flush()语句的功能不再是丢弃所有进入缓存器的串行数据。)

flush()

继承了Stream类

 

Serial.flush()

 

仅 Arduino Mega 可以使用的语法:

Serial1.flush()

Serial2.flush()

 

Serial3.flush()

 

 

parseFloat()

 

查找传入的串行数据流中的下一个有效的浮点数。 parseFloat()继承了Stream类

 

Serial.parseFloat()

 

仅适用于Arduino Mega:

Serial1.parseFloat()

Serial2.parseFloat()

Serial3.parseFloat()

 

 

parseInt()

 

查找传入的串行数据流中的下一个有效的整数。 parseInt()继承了Stream类

 

Serial.parseInt()

 

仅适用于Arduino Mega:

Serial1.parseInt()

Serial2.parseInt()

 

Serial3.parseInt()

 

 

peek()

 

返回传入的串行数据的下一个字节(字符),而不是进入内部串行缓冲器调取。也就是说,连续调用 peek()将返回相同的字符,与调用read()方法相同。peek()继承自 Stream类

 

Serial.peek()

 

仅适用于Arduino Mega :

Serial1.peek()

Serial2.peek()

 

Serial3.peek()

 

 

print()

 

以人们可读的ASCII文本形式打印数据到串口输出。此命令可以采取多种形式。每个数字的打印输出使用的是ASCII字符。浮点型同样打印输出的是ASCII字符,保留到小数点后两位。Bytes型则打印输出单个字符。字符和字符串原样打印输出。Serial.print()打印输出数据不换行,Serial.println()打印输出数据自动换行处理。例如

 

Serial.print(78)

输出为“78”

 

Serial.print(1.23456)

输出为“1.23”

 

Serial.print(“N”)

输出为“N”

 

Serial.print(“Hello world.”)

输出为“Hello world.”

 

也可以自己定义输出为几进制(格式);可以是BIN(二进制,或以2为基数),OCT(八进制,或以8为基数),DEC(十进制,或以10为基数),HEX(十六进制,或以16为基数)。对于浮点型数字,可以指定输出的小数数位。例如

 

Serial.print(78,BIN)

输出为“1001110”

 

Serial.print(78,OCT)

输出为“116”

 

Serial.print(78,DEC)

输出为“78”

 

Serial.print(78,HEX)

输出为“4E”

 

Serial.println(1.23456,0)

输出为“1”

 

Serial.println(1.23456,2)

输出为“1.23”

 

Serial.println(1.23456,4)

输出为“1.2346”

 

你可以通过基于闪存的字符串来进行打印输出,将数据放入F()中,再放入Serial.print()。例如 Serial.print(F(“Hello world”)) 若要发送一个字节,则使用 Serial.write()

 

 

Serial.print(val)

 

Serial.print(val

,格式)

val

:打印输出的值 – 任何数据类型

 

格式:指定进制(整数数据类型)或小数位数(浮点类型)

 

例子:

int x =

0;    //

定义一个变量并赋值

void setup()

{

 

Serial.begin(9600);      //

打开串口传输,并设置波特率为9600

}

void

loop() {

 

//

打印标签

 

Serial.print(“NO FORMAT”);       //

打印一个标签

 

Serial.print(“t”);

//

打印一个转义字符

Serial.print(“DEC”);

 

Serial.print(“t”);

Serial.print(“HEX”);

 

Serial.print(“t”);

 

Serial.print(“OCT”);

 

Serial.print(“t”);

 

Serial.print(“BIN”);

Serial.print(“t”);

 

for(x=0; x< 64; x++){    //

打印ASCII码表的一部分, 修改它的格式得到需要的内容

 

//

打印多种格式:

 

Serial.print(x);       //

以十进制格式将x打印输出 – 与”DEC”相同

 

Serial.print(“t”);    //

横向跳格

 

Serial.print(x, DEC);  //

以十进制格式将x打印输出

 

Serial.print(“t”);    //

横向跳格

 

Serial.print(x, HEX);  //

以十六进制格式打印输出

 

Serial.print(“t”);    //

横向跳格

 

Serial.print(x, OCT);  //

以八进制格式打印输出

 

Serial.print(“t”);    //

横向跳格

 

Serial.println(x, BIN);  //

以二进制格式打印输出

 

//

 

 

然后用 “println”打印一个回车

 

delay(200);

//

延时200ms

 

}

 

Serial.println(“”);      //

打印一个空字符,并自动换行

}

 

 

println()

 

打印数据到串行端口,输出人们可识别的ASCII码文本并回车 (ASCII 13, 或 ‘r’) 及换行(ASCII 10, 或 ‘n’)。此命令采用的形式与Serial.print ()相同

Serial.println(val)

 

Serial.println(val, format)

val:

打印的内容 – 任何数据类型都可以

format:

指定基数(整数数据类型)或小数位数(浮点类型)

 

例子:

int

analogValue = 0;    //

定义一个变量来保存模拟值

void

setup() {

 

//

设置串口波特率为9600 bps:

 

Serial.begin(9600);

}

void

loop() {

 

//

读取引脚0的模拟输入:

analogValue = analogRead(0);

//打印g各种格式:

Serial.println(analogValue);       //

打印ASCII编码的十进制

Serial.println(analogValue, DEC);  //

打印ASCII编码的十进制

Serial.println(analogValue, HEX);  //打印ASCII编码的十六进制

Serial.println(analogValue, OCT);  //打印ASCII编码的八进制

Serial.println(analogValue, BIN);  //打印一个ASCII编码的二进制

//延时10毫秒:

delay(10);

}

read()

读取传入的串口的数据。read() 继承自 Stream 类

serial.read()

Arduino Mega

独有:

erial1.read()

serial2.read()

serial3.read()

例子:

int

incomingByte = 0;   //

传入的串行数据

void

setup() {

Serial.begin(9600);     //

打开串口,设置数据传输速率9600

}

void

loop() {

//

当你接收数据时发送数据

if (Serial.available() > 0) {

//

读取传入的数据:

incomingByte = Serial.read();

//

打印你得到的:

Serial.print(“I received: “);

Serial.println(incomingByte, DEC);

 

}

} 

readBytes()

Serial.readBytes()

从串口读字符到一个缓冲区。如果预设的长度读取完毕或者时间到了 (参见 Serial.setTimeout()),函数将终止.

Serial.readBytes()

返回放置在缓冲区的字符数。返回0意味着没有发现有效的数据。

Serial.readBytes()

继承自 Stream 类

Serial.readBytes(buffer, length)

buffer

:用来存储字节(char[]或byte[])的缓冲区

length

:读取的字节数(int)

readBytesUntil()

Serial.readBytesUntil()

将字符从串行缓冲区读取到一个数组。如果检测到终止字符,或预设的读取长度读取完毕,或者时间到了 (参见 Serial.setTimeout())函数将终止。

Serial.readBytesUntil()

返回读入数组的字符数。返回0意味着没有发现有效的数据。

Serial.readBytesUntil()

继承自 Stream类

Serial.readBytesUntil(character, buffer, length)

character:要搜索的字符(char)

buffer:缓冲区来存储字节(char[]或byte[])

length:读的字节数(int)

setTimeout()       

 Serial.setTimeout()

设置使用Serial.readBytesUntil() 或Serial.readBytes()时等待串口数据的最大毫秒值. 默认为1000毫秒。

 

Serial.setTimeout()

继承自Stream 类

 

Serial.setTimeout(time)

time

:以毫秒为单位的超时时间(long)

您必须 登录 才能发表评论!