进阶之路（基础篇） - 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。

范例：

 void setup() {
  //Initialize serial and wait for port to open:
   Serial.begin();
   while (!Serial) {
     ; // wait for serial port to connect. Needed for native USB
   }
 } 

 void loop() {
  //proceed normally
 } 

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

 int incomingByte = ;        // for incoming serial data
 void setup(){
     Serial.begin();     // opens serial port, sets data rate to 9600 bps
 }
 void loop(){
     // send data only when you receive data:
     if (Serial.available() > ) {
     // read the incoming byte:
     incomingByte = Serial.read();
     // say what you got:
     Serial.print("I received: ");
     Serial.println(incomingByte, DEC);
     }
 }

　　Arduino Mega 范例：

 void setup(){
     Serial.begin();
     Seriall.begin();
 }
 void loop(){
     // read from port 0, send to port 1:
     if(Serial.available()){
         int inByte = Serial.read();
         Serial1.print(inByte,BYTE);
     }
     // read from port 1, send to port 0:
     if(Serial1.available()){
         int inByte = Seriall.read();
         Serial.print(inByte,BYTE);
     }
 }

函数：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: 设置数据，奇偶校验位和停止位。有效值为：

     speed:以秒为单位（波特） - long
     config: 设置数据，奇偶校验位和停止位。有效值为：
     SERIAL_5N1
     SERIAL_6N1
     SERIAL_7N1
     SERIAL_8N1 (默认值)
     SERIAL_5N2
     SERIAL_6N2
     SERIAL_7N2
     SERIAL_8N2
     SERIAL_5E1
     SERIAL_6E1
     SERIAL_7E1
     SERIAL_8E1
     SERIAL_5E2
     SERIAL_6E2
     SERIAL_7E2
     SERIAL_8E2
     SERIAL_5O1
     SERIAL_6O1
     SERIAL_7O1
     SERIAL_8O1
     SERIAL_5O2
     SERIAL_6O2
     SERIAL_7O2
     SERIAL_8O2

返回值：没有
通用范例：

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

Arduino Mega范例：

 // Arduino Mega using all four of its Serial ports
 // (Serial, Serial1, Serial2, Serial3),
 // with different baud rates:
 void setup(){
     Serial.begin();
     Serial1.begin();
     Serial2.begin();
     Serial3.begin();
     Serial.println("Hello Computer");
     Serial1.println("Hello Serial 1");
     Serial2.println("Hello Serial 2");
     Serial3.println("Hello Serial 3");
 }
 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（）返回写入的字节数，通过读取该数字是可选的
范例：

 /*
 Uses a FOR loop for data and prints a number in various formats.
 */
 int x = ;    // variable
 void setup(){
     Serial.begin();      // open the serial port at 9600 bps:
 }
 void loop(){
     // print labels
     Serial.print("NO FORMAT");       // prints a label
     Serial.print("\t");              // prints a tab
     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=; x< ; x++){    // only part of the ASCII chart, change to suit
     // print it out in many formats:
         Serial.print(x);       // print as an ASCII-encoded decimal - same as "DEC"
         Serial.print("\t");    // prints a tab
         Serial.print(x, DEC);  // print as an ASCII-encoded decimal
         Serial.print("\t");    // prints a tab
         Serial.print(x, HEX);  // print as an ASCII-encoded hexadecimal
         Serial.print("\t");    // prints a tab
         Serial.print(x, OCT);  // print as an ASCII-encoded octal
         Serial.print("\t");    // prints a tab
         Serial.println(x, BIN);  // print as an ASCII-encoded binary
         //then adds the carriage return with "println"
         delay();            // delay 200 milliseconds
     }
     Serial.println("");      // prints another carriage return
 }

从版本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（）返回写入的字节数，通过读取该数字是可选的
范例：

 /*
   Analog input
  reads an analog input on analog in 0, prints the value out.
  created 24 March 2006
  by Tom Igoe
  */
 int analogValue = ;    // variable to hold the analog value
 void setup(){
     // open the serial port at 9600 bps:
     Serial.begin();
 }
 void loop() {
     // read the analog input on pin 0:
     analogValue = analogRead();
     // print it out in many formats:
     Serial.println(analogValue);       // print as an ASCII-encoded decimal
     Serial.println(analogValue, DEC);  // print as an ASCII-encoded decimal
     Serial.println(analogValue, HEX);  // print as an ASCII-encoded hexadecimal
     Serial.println(analogValue, OCT);  // print as an ASCII-encoded octal
     Serial.println(analogValue, BIN);  // print as an ASCII-encoded binary
     // delay 10 milliseconds before the next reading:
     delay();
 }

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

 int incomingByte = ;   // for incoming serial data
 void setup(){
     Serial.begin();     // opens serial port, sets data rate to 9600 bps
 }
 void loop(){
     // send data only when you receive data:
     if (Serial.available() > ) {
         // read the incoming byte:
         incomingByte = Serial.read();
         // say what you got:
         Serial.print("I received: ");
         Serial.println(incomingByte, DEC);
     }
 }

函数：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（）将返回写入的字节数，通过读取该数字是可选的
范例：

 void setup(){
     Serial.begin();
 }
 void loop(){
     Serial.write(); // send a byte with the value 45
     int bytesSent = Serial.write(“hello”); //send the string “hello” and return the length of the string.
 }

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

void serialEvent(){
//statements
}

只有Arduino Mega:

 void serialEvent1(){
 //statements
 }
 void serialEvent2(){
 //statements
 }
 void serialEvent3(){
 //statements
 }

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