进阶之路（基础篇） - 019 Serial串口函数说明

本文总结了Arduino常用串口操作函数，函数说明部分来源于Arduino 官网串口使用指南，示例与实验部分为自编。本文是对Arduino串口操作函数的较全面总结，可作为工具贴查找使用。

函数：if(Serial)

描述：

　　指示指定的串行端口是否已就绪。

　　在32u4基础板，if(Serial)指示USB CDC串行连接状态是否打开。对于所有其它情况下，如果在Leonardo板上始终返回true（真）。

　　这是介绍Arduino 1.0.1。

语法：

　　所有板子：if(Serial)

　　如果是Arduino Leonardo：if(Seriall)

　　如果是Arduino Mega：if (Serial1) ,if (Serial2) ,if (Serial3)

参数：无

返回值：

　　布尔值(boolean)：如果指定的串行端口可用，则返回true。只有在查询Leonardo的USB CDC串行连接准备就绪之前，此操作才会返回false。

范例：

 1 void setup() { 
 2  //Initialize serial and wait for port to open:
 3   Serial.begin(9600); 
 4   while (!Serial) {
 5     ; // wait for serial port to connect. Needed for native USB
 6   }
 7 } 
 8 
 9 void loop() { 
10  //proceed normally
11 }

函数：available()
描述：获取可从串行端口读取的字节数（字符）。这是已经到达并存储在串行接收缓冲区（其中包含64个字节）的数据个数。 available()从Stream实用程序类继承。
语法：
Serial.available()
只有：Arduino Mega
Serial1.available()
Serial2.available()
Serial3.available()
参数：无
返回值：串口被使用的字节数
通用范例：

 1 int incomingByte = 0;        // for incoming serial data
 2 void setup(){
 3     Serial.begin(9600);     // opens serial port, sets data rate to 9600 bps
 4 }
 5 void loop(){
 6     // send data only when you receive data:
 7     if (Serial.available() > 0) {
 8     // read the incoming byte:
 9     incomingByte = Serial.read();
10     // say what you got:
11     Serial.print("I received: ");
12     Serial.println(incomingByte, DEC);
13     }
14 }

　　Arduino Mega 范例：

 1 void setup(){
 2     Serial.begin(9600);
 3     Seriall.begin(9600);
 4 }
 5 void loop(){
 6     // read from port 0, send to port 1:
 7     if(Serial.available()){
 8         int inByte = Serial.read();
 9         Serial1.print(inByte,BYTE);
10     }
11     // read from port 1, send to port 0:
12     if(Serial1.available()){
13         int inByte = Seriall.read();
14         Serial.print(inByte,BYTE);
15     }
16 }

函数：availableForWrite()
描述：获取可用于在串行缓冲区中写入的字节数（字符），而不会阻塞写入操作。
语法：
　　Serial.availableForWrite()
　　只有：Arduino Mega
　　　　Serial1.availableForWrite()
　　　　Serial2.availableForWrite()
　　　　Serial3.availableForWrite()
参数：无
返回值：可写入的字节数
范例：无

函数：begin()
描述：
　　设置串行数据传输的每秒位数（波特率）的数据速率。对于与计算机进行通信，请使用以下费率之一：　　300,600,1200,2400,4800,2600,800,400400,19200,2800800,3400400,57600或115200.然而，您可以指定其他费率 - 例如通过引脚0和1与需要特定波特率的组件进行通信。
　　可选的第二个参数配置数据，奇偶校验位和停止位。默认值为8位数据位，无奇偶校验位，1位停止位。
语法：
　　Serial.begin(speed)
　　Serial.begin(speed, config)
　　只有Arduino Mega:
　　Serial1.begin(speed)
　　Serial2.begin(speed)
　　Serial3.begin(speed)
　　Serial1.begin(speed, config)
　　Serial2.begin(speed, config)
　　Serial3.begin(speed, config)
参数：
speed:以秒为单位（波特） - long
config: 设置数据，奇偶校验位和停止位。有效值为：

 1     speed:以秒为单位（波特） - long
 2     config: 设置数据，奇偶校验位和停止位。有效值为：
 3     SERIAL_5N1
 4     SERIAL_6N1
 5     SERIAL_7N1
 6     SERIAL_8N1 (默认值)
 7     SERIAL_5N2
 8     SERIAL_6N2
 9     SERIAL_7N2
10     SERIAL_8N2
11     SERIAL_5E1
12     SERIAL_6E1
13     SERIAL_7E1
14     SERIAL_8E1
15     SERIAL_5E2
16     SERIAL_6E2
17     SERIAL_7E2
18     SERIAL_8E2
19     SERIAL_5O1
20     SERIAL_6O1
21     SERIAL_7O1
22     SERIAL_8O1
23     SERIAL_5O2
24     SERIAL_6O2
25     SERIAL_7O2
26     SERIAL_8O2

返回值：没有
通用范例：

1 void setup(){
2     Serial.begin(9600); // opens serial port, sets data rate to 9600 bps
3 }
4 void loop(){}

Arduino Mega范例：

 1 // Arduino Mega using all four of its Serial ports 
 2 // (Serial, Serial1, Serial2, Serial3), 
 3 // with different baud rates:
 4 void setup(){
 5     Serial.begin(9600);
 6     Serial1.begin(38400);
 7     Serial2.begin(19200);
 8     Serial3.begin(4800);
 9     Serial.println("Hello Computer");
10     Serial1.println("Hello Serial 1");
11     Serial2.println("Hello Serial 2");
12     Serial3.println("Hello Serial 3");
13 }
14 void loop() {}

函数：end()
描述：禁用串行通信，允许RX和TX引脚用于一般输入和输出。要重新启用串行通信，请调用Serial.begin（）。
语法：
　　Serial.end()
　　只有Arduino Mega:
　　Serial1.end()
　　Serial2.end()
　　Serial3.end()
参数：无
返回值：无

函数：Serial.find()
描述：Serial.find() 从串行缓冲器读取数据，直到找到给定长度的目标字符串。如果找到目标字符串，该函数返回true，如果超时，返回false。
语法：Serial.find(target)
参数：target：要搜索的字符串（char）
返回值：（boolean）布尔

函数：Serial.findUntil()
描述：
　　Serial.findUntil()从串行缓冲区读取数据，直到找到给定长度或终止符字符串的目标字符串。
　　如果找到目标字符串，该函数返回true，如果超时，返回false。
　　Serial.findUntil（）从Stream实用程序类继承。
语法：
　　Serial.findUntil(target, terminal)
参数：
　　target：要搜索的字符串（char）
　　terminal ：终端字符串在搜索（char）
返回值：boolean（布尔）

函数：flush()
描述：
　　等待输出串行数据的传输完成。（在Arduino 1.0之前，这相反地删除了任何缓冲的输入串行数据。）
　　flush（）从Stream实用程序类继承。
语法：
　　Serial.flush()
　　只有Arduino Mega:
　　Serial1.flush()
　　Serial2.flush()
　　Serial3.flush()
参数：无
返回值：没有

函数：parseFloat()
描述：
　　Serial.parseFloat()从串行缓冲区返回第一个有效的浮点数。不是数字（或减号）的字符被跳过。parseFloat()由不是浮点数的第一个字符终止。
　　Serial.parseFloat()从Stream实用程序类继承。
语法：Serial.parseFloat()
参数：无
返回值：flolt

函数：parseInt()
描述：
　　查找输入串行流中的下一个有效整数。parseInt()从Stream实用程序类继承。
尤其是：
　　不是数字或减号的初始字符被跳过;
　　当没有字符被读取可配置的超时值或读取非数字时，解析停止;
　　如果在超时（见Serial.setTimeout（））时没有读取有效数字，则返回0;
语法：
　　Serial.parseInt()
　　Serial.parseInt(char skipChar)
　　只有Arduino Mega:
　　Serial1.parseInt()
　　Serial2.parseInt()
　　Serial3.parseInt()
参数：skipChar：用于在搜索中跳过指示的字符。例如用于跳过数千个分频器。
返回值：long(下一个有效整数)

函数：peek()
描述：返回输入串行数据的下一个字节（字符），而不从内部串行缓冲区中删除它。也就是说，对peek（）的连续调用将返回相同的字符，下一次调用read（）也是如此。peek（）从Stream实用程序类继承。
语法：
　　Serial.peek()
　　只有Arduino Mega:
　　Serial1.peek()
　　Serial2.peek()
　　Serial3.peek()
参数：无
返回值：输入串行数据的第一个字节可用（如果没有数据可用，则为-1） - int

函数：print()
描述：
　　将数据作为人造可读的ASCII文本打印到串行端口。此命令可以有多种形式。使用每个数字的ASCII字符打印数字。浮点类似地打印为ASCII数字，默认为两位小数。字节作为单个字符发送。字符和字符串按原样发送。例如：
　　Serial.print(78) gives "78"
　　Serial.print(1.23456) gives "1.23"
　　Serial.print('N') gives "N"
　　Serial.print("Hello world.") gives "Hello world."
　　可选的第二个参数指定要使用的基础（格式）; 允许的值为BIN（二进制或基数2），OCT（八进制或基数8），DEC（十进制或十进制），十六进制或十六进制。对于浮点数，该参数指定要使用的小数位数。例如：
　　Serial.print(78, BIN) gives "1001110"
　　Serial.print(78, OCT) gives "116"
　　Serial.print(78, DEC) gives "78"
　　Serial.print(78, HEX) gives "4E"
　　Serial.println(1.23456, 0) gives "1"
　　Serial.println(1.23456, 2) gives "1.23"
　　Serial.println(1.23456, 4) gives "1.2346"
　　通过使用F（）包装它们，可以将基于Flash的内存字符串传递给Serial.print（）。例如：
　　Serial.print(F(“Hello World”))
　　要发送一个字节，请使用Serial.write（）。
语法：
　　Serial.print(val)
　　Serial.print(val, format)
参数：
　　val：要打印的值 - 任何数据类型
　　format：指定基数（用于整数数据类型）或小数位数（用于浮点类型）
返回值：size_t（long）：print（）返回写入的字节数，通过读取该数字是可选的
范例：

 1 /*
 2 Uses a FOR loop for data and prints a number in various formats.
 3 */
 4 int x = 0;    // variable
 5 void setup(){
 6     Serial.begin(9600);      // open the serial port at 9600 bps:    
 7 }
 8 void loop(){  
 9     // print labels 
10     Serial.print("NO FORMAT");       // prints a label
11     Serial.print("\t");              // prints a tab
12     Serial.print("DEC"); 
13     Serial.print("\t");
14     Serial.print("HEX"); 
15     Serial.print("\t");
16     Serial.print("OCT");
17     Serial.print("\t");
18     Serial.print("BIN");
19     Serial.print("\t");
20     for(x=0; x< 64; x++){    // only part of the ASCII chart, change to suit
21     // print it out in many formats:
22         Serial.print(x);       // print as an ASCII-encoded decimal - same as "DEC"
23         Serial.print("\t");    // prints a tab
24         Serial.print(x, DEC);  // print as an ASCII-encoded decimal
25         Serial.print("\t");    // prints a tab
26         Serial.print(x, HEX);  // print as an ASCII-encoded hexadecimal
27         Serial.print("\t");    // prints a tab
28         Serial.print(x, OCT);  // print as an ASCII-encoded octal
29         Serial.print("\t");    // prints a tab
30         Serial.println(x, BIN);  // print as an ASCII-encoded binary
31         //then adds the carriage return with "println"
32         delay(200);            // delay 200 milliseconds
33     }
34     Serial.println("");      // prints another carriage return
35 }

从版本1.0开始，串行传输是异步的; 在发送任何字符之前，Serial.print（）将返回。

函数：println()
描述：将数据作为人造可读的ASCII文本，后跟一个回车字符（ASCII 13或'\ r'）和换行符（ASCII 10或'\ n'）打印到串行端口。此命令采用与Serial.print（）相同的形式。
语法：
　　Serial.println(val)
　　Serial.println(val, format)
参数：
　　val：要打印的值 - 任何数据类型
　　format：指定基数（用于整数数据类型）或小数位数（用于浮点类型）
返回值：size_t（long）：print（）返回写入的字节数，通过读取该数字是可选的
范例：

 1 /*
 2   Analog input
 3  reads an analog input on analog in 0, prints the value out.
 4  created 24 March 2006
 5  by Tom Igoe
 6  */
 7 int analogValue = 0;    // variable to hold the analog value
 8 void setup(){
 9     // open the serial port at 9600 bps:
10     Serial.begin(9600);
11 }
12 void loop() {
13     // read the analog input on pin 0:
14     analogValue = analogRead(0);
15     // print it out in many formats:
16     Serial.println(analogValue);       // print as an ASCII-encoded decimal
17     Serial.println(analogValue, DEC);  // print as an ASCII-encoded decimal
18     Serial.println(analogValue, HEX);  // print as an ASCII-encoded hexadecimal
19     Serial.println(analogValue, OCT);  // print as an ASCII-encoded octal
20     Serial.println(analogValue, BIN);  // print as an ASCII-encoded binary
21     // delay 10 milliseconds before the next reading:
22     delay(10);
23 }

函数：read()
描述：读取输入的串行数据。read()从Stream实用程序类继承。
语法：
　　Serial.read()
　　只有Arduino Mega:
　　Serial1.read()
　　Serial2.read()
　　Serial3.read()
参数：无
返回值：输入串行数据的第一个字节可用（如果没有数据可用，则为-1） - int
范例：

 1 int incomingByte = 0;   // for incoming serial data
 2 void setup(){
 3     Serial.begin(9600);     // opens serial port, sets data rate to 9600 bps
 4 }
 5 void loop(){
 6     // send data only when you receive data:
 7     if (Serial.available() > 0) {
 8         // read the incoming byte:
 9         incomingByte = Serial.read();
10         // say what you got:
11         Serial.print("I received: ");
12         Serial.println(incomingByte, DEC);
13     }
14 }

函数：Serial.readBytes()
描述：
　　Serial.readBytes（）将串行端口中的字符读入缓冲区。如果确定的长度已被读取或超时（参见Serial.setTimeout（）），该函数将终止。
　　Serial.readBytes（）返回缓冲区中放置的字符数。 A 0表示没有找到有效的数据。
　　Serial.readBytes（）从Stream实用程序类继承。
语法：Serial.readBytes(buffer, length)
参数：
　　buffer：缓冲区中存储字节（char []或byte []）
　　length：要读取的字节数（int）
返回值：字节(byte)

函数：Serial.readBytesUntil()
描述：
　　Serial.readBytesUntil（）将串行缓冲区中的字符读入数组。如果检测到终止符字符，确定的长度已被读取或超时（参见Serial.setTimeout（）），该函数将终止。
　　Serial.readBytesUntil（）返回读入缓冲区的字符数。 A 0表示没有找到有效的数据。
　　Serial.readBytesUntil（）从Stream实用程序类继承。
语法：Serial.readBytesUntil(character, buffer, length)
参数：
字符：要搜索的字符（char）
　　buffer：缓冲区中存储字节（char []或byte []）
　　length：要读取的字节数（int）
返回值：字节(byte)

函数：readString()
描述：
　　Serial.readString（）将串行缓冲区中的字符读入一个字符串。如果超时，该函数将终止（请参阅setTimeout（））。
　　此函数是Stream类的一部分，并由继承自它的任何类（Wire，Serial等）调用。有关更多信息，请参阅Stream类主页面。
语法：Serial.readString()
参数：无
返回值：从串行缓冲区读取的字符串

函数：readStringUntil()
描述：
　　readStringUntil（）将串行缓冲区中的字符读入一个字符串。如果检测到终止符或超时，该函数将终止（请参阅setTimeout（））。
　　此函数是Stream类的一部分，并由继承自它的任何类（Wire，Serial等）调用。有关更多信息，请参阅Stream类主页面。
语法：Serial.readStringUntil(terminator)
参数：terminator：要搜索的字符（char）
返回值：从串行缓冲区读取整个字符串，直到检测到终止字符

函数：Serial.setTimeout()
描述：
　　Serial.setTimeout（）使用Serial.readBytesUntil（），Serial.readBytes（），Serial.parseInt（）或Serial.parseFloat（））设置等待串行数据的最大毫秒数。默认为1000毫秒。
　　Serial.setTimeout（）从Stream实用程序类继承。
语法：Serial.setTimeout(time)
参数：time：超时持续时间（以毫秒为单位）。
返回值：无

函数：write()
描述：将二进制数据写入串行端口。该数据以字节或一系列字节发送; 发送表示数字的字符的字符使用print（）函数。
语法：
　　Serial.write(val)
　　Serial.write(str)
　　Serial.write(buf, len)
　　Arduino Mega还支持：Serial1，Serial2，Serial3（代替Serial）
参数：
　　val：作为单个字节发送的值
　　str：一个字符串作为一系列字节发送
　　buf：要作为一系列字节发送的数组
　　len：缓冲区的长度
返回值：字节，write（）将返回写入的字节数，通过读取该数字是可选的
范例：

1 void setup(){
2     Serial.begin(9600);
3 }
4 void loop(){
5     Serial.write(45); // send a byte with the value 45
6     int bytesSent = Serial.write(“hello”); //send the string “hello” and return the length of the string.
7 }

函数：serialEvent()
描述：
数据可用时调用。使用Serial.read（）来捕获这些数据。
注意：目前，serialEvent（）与Esplora，Leonardo或Micro不兼容
语法：

void serialEvent(){
//statements
}

只有Arduino Mega:

1 void serialEvent1(){
2 //statements
3 }
4 void serialEvent2(){
5 //statements
6 }
7 void serialEvent3(){
8 //statements
9 }

参数：语句：任何有效的语句
返回值：无

posted @ 2017-05-08 17:13 极客先锋阅读(3241) 评论(0) 编辑收藏举报

刷新页面返回顶部

极客先锋

每天进步一点点！

进阶之路（基础篇） - 019 Serial串口函数说明