protected SerialPortStream sp;

public CustomSerialPort(string portName, int baudRate = 115200,
 Parity parity = Parity.None, int databits = 8, StopBits stopBits = StopBits.One);

public int ReceiveTimeout { get; set; }　　//接收超时时间
        public bool ReceiveTimeoutEnable { get; set; }　　
        public bool RtsEnable { get; set; }　　　　//不详
        public bool DtrEnable { get; set; }　　　　//不详
        public bool IsOpen { get; }　　　　　　　　//检测是否在使用
        public StopBits StopBits { get; set; }　　//枚举，上面说明的
        public int DataBits { get; set; }　　　　//上面说明了
        public Parity Parity { get; set; }　　　　//枚举，上面说明了
        public int BaudRate { get; set; }
        public int BufSize { get; set; }
        public string PortName { get; set; }　　　　//使用的串口名

　　　　　public event CustomSerialPortReceivedEventHandle ReceivedEvent;　　　　//一个事件，可以把接收到消息后需要触发的时间绑定到此事件

        public static string ByteToHexStr(byte[] bytes);　　　　　　　　　　　　　　//把比特流转为字符串
        public static string[] GetPortNames();
        public void Close();　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　//关闭串口
        public void Dispose();
        public bool Open();　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　//释放串口
        public void Write(string text);　　　　　　　　　　　　　　　　　　　　　　　　//以字符串的形式写入串口
        public void Write(byte[] buffer);　　　　　　　　　　　　　　　　　　　　　　　//以字节流的方式写入串口(推荐)
        public void WriteLine(string text);　　　　　　　　　　　　　　　　　　　　　　//写入字符串，应该是与Modbus ASCII有关，Ascii方式需要在数据后面加上换行符表示已经结束传送
        protected void ReceiveTimeoutCheckFunc();
        protected void Sp_DataReceived(object sender, SerialDataReceivedEventArgs e);　　//后台线程处理，表示收到串口消息后，触发那些事件

using flyfire.IO.Ports;
using RJCP.IO.Ports;
using System.Threading;

namespace SerialPortTest
{
    /// <summary>
    ///  用于封装需要的串口通讯
    /// </summary>
    public class SerialSerice
    {
        /// <summary>
        /// 获取计算机的所有串口
        /// </summary>
        public void GetSerial()
        {
　　　　　　　　//CustomSerialPort.GetPortNames() 静态方法，获取计算机的所有串口名称
　　　　　　　　//因为已经继承，也可以使用 string[] vs = 串口通讯.GetPortNames();
            string[] vs = CustomSerialPort.GetPortNames();
            Console.WriteLine("你电脑的串口列表：");
            foreach (var i in vs)
            {
                Console.WriteLine(i);
            }
        }
    }

    public class 串口通讯 : CustomSerialPort
    {
        public 串口通讯(string portName, int baudRate = 115200, Parity parity = Parity.None, int databits = 8, StopBits stopBits = StopBits.One)
            :base(portName, baudRate, parity, databits, stopBits)
        {

        }
    }
}

　　　　static void Main(string[] args)
        {
            SerialSerice serialSerice = new SerialSerice();
            serialSerice.GetSerial();
            Console.ReadKey();
        }

namespace SerialPortTest
{
    /// <summary>
    ///  用于封装需要的串口通讯
    /// </summary>
    public class SerialSerice
    {
        //实现串口通讯的对象
        串口通讯 串口;
        /// <summary>
        /// 获取计算机的所有串口 步骤 1
        /// </summary>
        public void GetSerial()
        {
            string[] vs = 串口通讯.GetPortNames();
            Console.WriteLine("你电脑的串口列表(输入名称此端口，注意大小写)：");

            foreach (var i in vs)
            {
                Console.WriteLine(i);
            }
        }
        //初始化串口 步骤 2
        public void 初始化(string portname)
        {
            串口 = new 串口通讯(portname);
　　　　　　　　串口.Open();
        }
        //向串口写入数据 步骤 3
        public void 写入(string str)
        {
            //方式 1
            串口.Write(str);
            Console.WriteLine("已经向串口输入：" + str);
　　　　　　　　Thread.Sleep(500);
            //方式 2、3
            byte[] b_字符 = Encoding.Default.GetBytes(str);
            byte[] b_16进制 = new byte[b_字符.Length];

            //转16进制再发送
            Console.WriteLine("发送的16进制数据：");
            for (int i = 0; i < b_字符.Length; i++)
            {
                b_16进制[i] = Convert.ToByte(b_字符[i].ToString(), 16);
                Console.Write(b_16进制[i] + " ");
            }
　　　　　　　　Console.WriteLine();
            //方式 2、3 写入串口
            串口.Write(b_字符);
　　　　　　　　Thread.Sleep(500);
            串口.Write(b_16进制);
　　　　　　　　Thread.Sleep(500);
        }
    }

    public class 串口通讯 : CustomSerialPort
    {
        public 串口通讯(string portName, int baudRate = 115200, Parity parity = Parity.None, int databits = 8, StopBits stopBits = StopBits.One)
            : base(portName, baudRate, parity, databits, stopBits)
        {

        }
    }
}

class Program
    {
        static void Main(string[] args)
        {
            // 初始化串口通讯服务
            SerialSerice 串口功能 = new SerialSerice();

            //显示串口列表、并让用户选择串口
            串口功能.GetSerial();
            string portname= Console.ReadLine();

            //步骤 2 
            串口功能.初始化(portname);

            Console.WriteLine("输入你想发送给客户端的内容,退出请输入 exit");
            //因为示例了三种写入方法，第三种方法需要转换，非数字会报错
            //实际上你可以发送如何类型的数据，就看你怎么写步骤 3 的方法
            Console.WriteLine("只能输入数字！8进制、10进制、16进制均可，请勿输入字符串");
            while (true)
            {
                string str = Console.ReadLine();
                if (str == "exit")
                    break;

                //步骤 3
                串口功能.写入(str);
            }

            Console.ReadKey();
        }

public delegate void CustomSerialPortReceivedEventHandle(object sender, byte[] bytes)

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
using flyfire.IO.Ports;
using RJCP.IO.Ports;

namespace SerialPortTest
{
    /// <summary>
    ///  用于封装需要的串口通讯
    /// </summary>
    public class SerialSerice
    {
        //实现串口通讯的对象
        串口通讯 串口;
        /// <summary>
        /// 获取计算机的所有串口 步骤 1
        /// </summary>
        public void GetSerial()
        {
            string[] vs = 串口通讯.GetPortNames();
            Console.WriteLine("你电脑的串口列表(输入名称此端口，注意大小写)：");

            foreach (var i in vs)
            {
                Console.WriteLine(i);
            }
        }
        //初始化串口 步骤 2
        public void 初始化(string portname)
        {
            串口 = new 串口通讯(portname);
            串口.Open();
        }
        //向串口写入数据 步骤 3
        public void 写入(string str)
        {
            //方式 1
            串口.Write(str);
            Console.WriteLine("已经向串口输入：" + str);
            Thread.Sleep(500);
            //方式 2、3
            byte[] b_字符 = Encoding.Default.GetBytes(str);
            byte[] b_16进制 = new byte[b_字符.Length];

            //转16进制再发送
            Console.WriteLine("发送的16进制数据：");
            for (int i = 0; i < b_字符.Length; i++)
            {
                b_16进制[i] = Convert.ToByte(b_字符[i].ToString(), 16);
                Console.Write(b_16进制[i] + " ");
            }
            Console.WriteLine();
            //方式 2、3 写入串口
            串口.Write(b_字符);
            Thread.Sleep(500);
            串口.Write(b_16进制);
            Thread.Sleep(500);
        }
        public void 开启后台监听()
        {
            //收到消息时要触发的事件
            串口.ReceivedEvent += 被触发的事件_1;

            串口.开始后台监控();

        }
        public static void 被触发的事件_1(object sender, byte[] bytes)
        {
            Console.WriteLine("收到数据");
            foreach (var i in bytes)
            {
                Console.Write(i + " ");
            }
            Console.WriteLine("");
        }

    }

    public class 串口通讯 : CustomSerialPort
    {
        public 串口通讯(string portName, int baudRate = 115200, Parity parity = Parity.None, int databits = 8, StopBits stopBits = StopBits.One)
            : base(portName, baudRate, parity, databits, stopBits)
        {

        }
        //无意义，只是因为父类的 Sp_DataReceived() 不是 public
        public void 开始后台监控()
        {
            
            Sp_DataReceived(new object(), new SerialDataReceivedEventArgs(SerialData.Eof));
        }
    }
}

using System;

namespace SerialPortTest
{
    class Program
    {
        static void Main(string[] args)
        {
            // 初始化串口通讯服务
            SerialSerice 串口功能 = new SerialSerice();

            //显示串口列表、并让用户选择串口
            串口功能.GetSerial();
            string portname= Console.ReadLine();

            //步骤 2 
            串口功能.初始化(portname);
            串口功能.开启后台监听();
            Console.WriteLine("输入你想发送给客户端的内容,退出请输入 exit");
            //因为示例了三种写入方法，第三种方法需要转换，非数字会报错
            //实际上你可以发送如何类型的数据，就看你怎么写步骤 3 的方法
            Console.WriteLine("只能输入数字！8进制、10进制、16进制均可，请勿输入字符串");
            while (true)
            {
                string str = Console.ReadLine();
                if (str == "exit")
                    break;

                //步骤 3
                串口功能.写入(str);
            }

            Console.ReadKey();
        }
    }
}

目录

• 摘要
• 引言
• 基础类库的选择
• 类库的实现
• 创建跨平台类库
• 实现机制/条件
• .net core跨平台实现
• 主要代码
• 创建.net core控制台程序
• 类库地址
• 跨平台测试
• Windows测试输出界面
• ubuntu测试输出界面
• 源码地址

         protected void Sp_DataReceived(object sender, SerialDataReceivedEventArgs e)
         {
             int canReadBytesLen = 0;
             if (ReceiveTimeoutEnable)
             {
                 while (sp.BytesToRead > 0)
                 {
                     canReadBytesLen = sp.BytesToRead;
                     if (receiveDatalen + canReadBytesLen > BufSize)
                     {
                         receiveDatalen = 0;
                         throw new Exception("Serial port receives buffer overflow!");
                     }
                     var receiveLen = sp.Read(recviceBuffer, receiveDatalen, canReadBytesLen);
                     if (receiveLen != canReadBytesLen)
                     {
                         receiveDatalen = 0;
                         throw new Exception("Serial port receives exception!");
                     }
                     //Array.Copy(recviceBuffer, 0, receivedBytes, receiveDatalen, receiveLen);
                     receiveDatalen += receiveLen;
                     lastReceiveTick = Environment.TickCount;
                     if (!TimeoutCheckThreadIsWork)
                     {
                         TimeoutCheckThreadIsWork = true;
                         Thread thread = new Thread(ReceiveTimeoutCheckFunc)
                         {
                             Name = "ComReceiveTimeoutCheckThread"
                         };
                         thread.Start();
                     }
                 }
             }
             else
             {
                 if (ReceivedEvent != null)
                 {
                     // 获取字节长度
                     int bytesNum = sp.BytesToRead;
                     if (bytesNum == 0)
                         return;
                     // 创建字节数组
                     byte[] resultBuffer = new byte[bytesNum];
 
                     int i = 0;
                     while (i < bytesNum)
                     {
                         // 读取数据到缓冲区
                         int j = sp.Read(recviceBuffer, i, bytesNum - i);
                         i += j;
                     }
                     Array.Copy(recviceBuffer, 0, resultBuffer, 0, i);
                     ReceivedEvent(this, resultBuffer);
                     //System.Diagnostics.Debug.WriteLine("len " + i.ToString() + " " + ByteToHexStr(resultBuffer));
                 }
                 //Array.Clear (receivedBytes,0,receivedBytes.Length );
                 receiveDatalen = 0;
             }
         }

         /// <summary>
         /// 超时返回数据处理线程方法
         /// </summary>
         protected void ReceiveTimeoutCheckFunc()
         {
             while (TimeoutCheckThreadIsWork)
             {
                 if (Environment.TickCount - lastReceiveTick > ReceiveTimeout)
                 {
                     if (ReceivedEvent != null)
                     {
                         byte[] returnBytes = new byte[receiveDatalen];
                         Array.Copy(recviceBuffer, 0, returnBytes, 0, receiveDatalen);
                         ReceivedEvent(this, returnBytes);
                     }
                     //Array.Clear (receivedBytes,0,receivedBytes.Length );
                     receiveDatalen = 0;
                     TimeoutCheckThreadIsWork = false;
                 }
                 else
                     Thread.Sleep(16);
             }
         }

         static void Main(string[] args)
         {
             SetLibPath();
             ShowWelcome();
 
             GetPortNames();
             ShowPortNames();
 
             if (serailports.Length == 0)
             {
                 Console.WriteLine($"Press any key to exit");
                 Console.ReadKey();
 
                 return;
             }
 #if RunIsService
             RunService();
 #endif
 
             bool quit = false;
             while (!quit)
             {
                 Console.WriteLine("\r\nPlease Input command Key\r\n");
                 Console.WriteLine("p:Show SerialPort List");
                 Console.WriteLine($"t:Test Uart:\"{selectedComPort}\"");
                 Console.WriteLine($"o:Open Uart:\"{selectedComPort}\"");
                 Console.WriteLine($"c:Close Uart:\"{selectedComPort}\"");
                 Console.WriteLine("n:select next serial port");
                 Console.WriteLine("q:exit app");
                 Console.WriteLine();
                 var key = Console.ReadKey().KeyChar;
                 Console.WriteLine();
 
                 switch (key)
                 {
                     case (Char)27:
                     case ''q'':
                     case ''Q'':
                         quit = true;
                         break;
                     case ''s'':
                         ShowWelcome();
                         break;
                     case ''p'':
                         ShowPortNames();
                         break;
                     case ''n'':
                         SelectSerialPort();
                         break;
                     case ''t'':
                         TestUart(selectedComPort);
                         break;
                     case ''w'':
                         TestWinUart(selectedComPort);
                         break;
                     case ''o'':
                         OpenUart(selectedComPort);
                         break;
                     case ''c'':
                         CloseUart();
                         break;
                 }
             }
         }

• .Net Core跨平台应用开发串口篇HelloArm
• .NET Core使用flyfire.CustomSerialPort实现Windows/Linux跨平台串口通讯
• .NET Core跨平台串口通讯使用SerialPortStream基础类库问题解决

#include "qextserialport.h"

#include "qextserialenumerator.h"

QList<QextPortInfo> ports = QextSerialEnumerator::getPorts();
//! [1]
qDebug() << "List of ports:";
//! [2]
foreach (QextPortInfo info, ports) {
      qDebug() << "port name:"       << info.portName;  //COMID
      qDebug() << "friendly name:"   << info.friendName;    //名称
      qDebug() << "physical name:"   << info.physName;
      qDebug() << "enumerator name:" << info.enumName;
      qDebug() << "vendor ID:"       << info.vendorID;
      qDebug() << "product ID:"      << info.productID;
      qDebug() << "===================================";
    }

if(port->canReadLine())
{
       qDebug()<<port->readLine();
}

if (port->bytesAvailable()) {
        qDebug()<<port->readAll();
    }

port->setPortName("COM1");                // port是个QextSerialPort类对象
port->setBaudRate(BAUD1152000 );         
port->setParity(PAR_NONE);
port->setDataBits(DATA_8);
port->setStopBits(StopBitsType);
port->setQueryMode(EventDriven);           //设置事件驱动模式

port->setBaudRate((BaudRateType)ui->baudRateBox->itemData(idx).toInt());

port->open(QIODevice::ReadWrite);        //打开串口
//进行操作中... ...
port->close();                         //关闭串口

deviceDiscovered(const QextPortInfo &info);     
//出现有新的串口时,会触发该信号,并将出现的串口信息存到info参数中

deviceRemoved(const QextPortInfo &info);
//当某个串口消失时,会触发该信号,并将消失的串口信息存到info参数中

#ifndef WIDGET_H
#define WIDGET_H
#include <QtGui>
#include "qextserialport.h"
#include "qextserialenumerator.h"

namespace Ui {
class Widget;
}

class Widget : public QWidget
{
    Q_OBJECT


    QextSerialPort *port;                //端口,用来描述具体的一个端口
    QextSerialEnumerator *enumerator;    //在线串口统计类

protected:
    void closeEvent(QCloseEvent *);
    void initBtn();                  //初始化按钮
    void initComboBoxs();            //初始化下拉列表框
    void initSerial();               //初始化串口
    void Change_btn_isOn(bool ison);

public:
    explicit Widget(QWidget *parent = 0);
    ~Widget();

private slots:
    void on_btn_send_clicked();         //发送数据
    void on_betn_clear_clicked();       //清除接收数据
    void on_btn_switch_clicked();       //串口开关
    void onPortAddedOrRemoved();        //刷新串口号
    void readLineData();                //读数据
    void on_serial_name_currentIndexChanged(int index);

private:
    Ui::Widget *ui;
};
#endif // WIDGET_H

#include "widget.h"
#include "ui_widget.h"
Widget::Widget(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::Widget)
{
    ui->setupUi(this);
    setWindowTitle(("简易串口工具"));
    ui->recvEdit->setReadOnly(true);
    initBtn();
    initComboBoxs();
    initSerial();
    qApp->setStyleSheet("QComboBox::item{text-align: center; }");
}

void Widget::initBtn()                   //初始化按钮
{
    Change_btn_isOn(false);
}

void Widget::initComboBoxs()           //初始化下拉列表框
{
    BaudRateType RateTypes[12]={
    BAUD1200,BAUD2400 ,BAUD4800,BAUD9600 ,
    BAUD14400,BAUD19200,BAUD38400,BAUD56000,
    BAUD57600,BAUD115200,BAUD128000, BAUD256000};
    DataBitsType BitsTypes[4]={DATA_5,DATA_6, DATA_7, DATA_8};
    for(int i=0;i<12;i++)
    {
        ui->serial_baud->addItem(QString("%1").arg((int)RateTypes[i]),RateTypes[i]);
    }

    for(int i=0;i<4;i++)
    {
        ui->serial_data->addItem(QString("%1").arg((int)BitsTypes[i]),BitsTypes[i]);
    }

    ui->serial_parity->addItem("无",PAR_NONE);
    ui->serial_parity->addItem("奇校验",PAR_ODD);
    ui->serial_parity->addItem("偶校验",PAR_EVEN);

    ui->serial_stop->addItem("1",STOP_1);
    ui->serial_stop->addItem("1.5",STOP_1_5);
    ui->serial_stop->addItem("2",STOP_2);
}

void Widget::initSerial()               //初始化串口
{
    onPortAddedOrRemoved();
    enumerator = new QextSerialEnumerator();
    enumerator->setUpNotifications();

    connect(enumerator, SIGNAL(deviceDiscovered(QextPortInfo)),this, SLOT(onPortAddedOrRemoved()));  //发现有串口
    connect(enumerator, SIGNAL(deviceRemoved(QextPortInfo)), this, SLOT(onPortAddedOrRemoved()));     //发现没有串口了

     port = new QextSerialPort(QextSerialPort::EventDriven,this);
     connect(port, SIGNAL(readyRead()), this,SLOT(readLineData()));   //连接信号
}

void Widget::on_btn_send_clicked()  //发送数据
{
    if (port->isOpen() && !ui->sendEdit->toPlainText().isEmpty())
      {
        QString data = ui->sendEdit->toPlainText();
        data+="\r\n";
      }
}

void Widget::on_betn_clear_clicked()//清除接收数据
{
    ui->recvEdit->clear();
}

void Widget::on_btn_switch_clicked()//串口开关
{if(!port->isOpen())     //当前未打开
    {
       Change_btn_isOn(true);
       port->setPortName(ui->serial_name->itemData(ui->serial_name->currentIndex()).toString());
       port->setBaudRate((BaudRateType)ui->serial_baud->itemData(ui->serial_baud->currentIndex()).toInt());
       port->setDataBits((DataBitsType)ui->serial_data->itemData(ui->serial_data->currentIndex()).toInt());
       port->setParity((ParityType)ui->serial_parity->itemData(ui->serial_parity->currentIndex()).toInt());
       port->setStopBits((StopBitsType)ui->serial_stop->itemData(ui->serial_stop->currentIndex()).toInt());
       port->open(QIODevice::ReadWrite);
    }
    else
    {
        Change_btn_isOn(false);
        port->close();
    }
}

void Widget::closeEvent(QCloseEvent *)
{
    if(port->isOpen())
        port->close();
}

void Widget::readLineData()                         //读数据
{
   while(port->canReadLine()) {
        ui->recvEdit->moveCursor(QTextCursor::End);
        ui->recvEdit->insertPlainText(QString::fromLocal8Bit(port->readLine()));
    }
}

void Widget::onPortAddedOrRemoved()              //刷新串口号
{
    QString current = ui->serial_name->currentText();
    ui->serial_name->blockSignals(true);        //阻塞信号
    ui->serial_name->clear();

    foreach (QextPortInfo info, QextSerialEnumerator::getPorts())
    {
      QString friendname = info.friendName;
     int end=friendname.lastIndexOf(" ");
     if(end!=-1)
     {
         ui->serial_name->addItem(QString("%1:%2").arg(info.portName).arg(info.friendName.left(end)),info.portName);
     }
     else
     {
        ui->serial_name->addItem(QString("%1:%2").arg(info.portName).arg(info.friendName),info.portName);
     }
   }

    ui->serial_name->setCurrentIndex(ui->serial_name->findText(current));
    if(ui->serial_name->currentIndex()==-1)
        ui->serial_name->setCurrentIndex(0);
    ui->serial_name->blockSignals(false);       //关闭阻塞
}

void Widget::Change_btn_isOn(bool ison)
{
    if(!ison)
    {
        ui->btn_switch->setStyleSheet("color:blue;border: 1px solid blue");
        ui->btn_switch->setText("打开串口");
    }
    else
    {
        ui->btn_switch->setStyleSheet("color:red;border: 1px solid red");
        ui->btn_switch->setText("关闭串口");
    }
}

Widget::~Widget()
{
    delete ui;
}

void Widget::on_serial_name_currentIndexChanged(int index)
{
    if (port->isOpen()) {           //如果是开启的,则关闭串口
        port->close();
        Change_btn_isOn(false);
    }
}

QList<QSerialPortInfo>  QSerialPortInfo::availablePorts();      
         //获取当前在线的串口设备

foreach (const QSerialPortInfo &info, QSerialPortInfo::availablePorts())
{

        qDebug() << "Name : " << info.portName();

        qDebug() << "Description : " << info.description();

        qDebug() << "Manufacturer: " << info.manufacturer();

        qDebug() << "Serial Number: " << info.serialNumber();

        qDebug() << "System Location: " << info.systemLocation();
}

serialport.setPortName(cfg.portName);
serialport.setBaudRate(QSerialPort::Baud115200);
serialport.setParity(QSerialPort::NoParity);
serialport.setDataBits(QSerialPort::Data8);
serialport.setStopBits(QSerialPort::OneStop);
serialport.setFlowControl(QSerialPort::NoFlowControl);
if(!serialport.open(QIODevice::ReadWrite))
{
      qDebug()<<"打开失败";
      return;
}

void readyRead();           
//当串口接收到下位机发送数据时,将会发送该信号,然后我们在对应的槽函数调用serialport .readAll()即可

error(QSerialPort::SerialPortError );
//串口错误信号,比如当串口打开失败,串口连接时突然断开,都将会调用该信号
//比如:  QSerialPort::PermissionError (表示串口连接断开了)

Widget::Widget(QWidget *parent)
    : QWidget(parent),
      serialport(this),
      btn("发送",this)
{
    serialport.setPortName("COM21");
    serialport.setBaudRate(QSerialPort::Baud115200);
    serialport.setParity(QSerialPort::NoParity);
    serialport.setDataBits(QSerialPort::Data8);
    serialport.setStopBits(QSerialPort::OneStop);
    serialport.setFlowControl(QSerialPort::NoFlowControl);
    if(!serialport.open(QIODevice::ReadWrite))
    {
          qDebug()<<"打开失败";
          return;
    }
    connect(&serialport,SIGNAL(readyRead()),this,SLOT(onReadyRead()));
    connect(&btn,SIGNAL(clicked()),this,SLOT(sendSerialData()));  
}

void Widget::onReadyRead()
{
    QString str(serialport.readAll());
    qDebug()<<str;
}
void Widget::sendSerialData()
{
     serialport.write(QString("发送:%1\r\n").arg(qrand()).toLocal8Bit());    //发送随机值
}

void Widget::onReadyRead()
{
     QString str(fromGBKtoUtf8(serialport.readAll()));
     QStringList  list = str.split(QRegExp("[\r\n]"), QString::SkipEmptyParts);      //去掉\r\n , SkipEmptyParts表示如果末尾为\r\n则不需要打印

     foreach (QString line, list) {
       qDebug()<<line;
    }
}

void Widget::sendSerialData()
{
    //serialport.write(QString("%1\r\n").arg(qrand()).toLocal8Bit());
     serialport.write(fromUtf8toGBK(QString("%1\r\n").arg(qrand())));
}

QString  Widget::fromGBKtoUtf8(QByteArray arry)
{
    QTextCodec *gbk = QTextCodec::codecForName("gbk");
    QTextCodec *utf8 = QTextCodec::codecForName("UTF-8");

    QString unicode=gbk->toUnicode(arry);
    return QString(utf8->fromUnicode(unicode));
}

QByteArray Widget::fromUtf8toGBK(QString str)
{
    QTextCodec *gbk = QTextCodec::codecForName("gbk");
    QTextCodec *utf8 = QTextCodec::codecForName("UTF-8");
    QString unicode=utf8->toUnicode(str.toLocal8Bit());
    return gbk->fromUnicode(unicode);
}

serialport.write( QString("%1\r\n").arg(qrand()).toLocal8Bit() );    //写入随机值
       if(serialport.waitForBytesWritten(100))  //100ms 等待写入成功
       {
            if(serialport.waitForReadyRead(100))  //等待数据返回
            {
                QString str((serialport.readAll()));
                QStringList  list = str.split(QRegExp("[\r\n]"),QString::SkipEmptyParts);      //去掉\r\n

                foreach (QString line, list) {

                  qDebug()<<line;

                  //解析line,并向界面发送信号 ... ...
               }
            }
            else
               qDebug()<<"read err";
       }
       else
          qDebug()<<"write err";