串口通信

串口通信

通过usb转串口线，实现pc端与外设硬件指令通信
(mySerialPort.InitPort(3, CBR_19200, 'N', 8, 1, EV_RXCHAR)调用这个函数来打开串口，3就是你的外设连接电脑的com口（我的外设连接的com口为3），可以在设备管理器查看，然后更改这个参数，
CBR_19200为波特率设置，8即为要传输的长度，

StdAfx.h

stdafx.h在C++中起到的作用是头文件预编译，即把C++工程中使用的MFC头文件预先编译，以后该工程编译时，直接使用预编译的结果，以加快编译速度。C++编译器通过一个头文件stdafx.h来使用预编译头文件。stdafx.h并不是标准C++头文件，与项目的源代码文件存放在同一个文件文件夹下，通过#include"stdafx.h"引用。stdafx的英文全称为：Standard Application Framework Extensions（标准应用程序框架的扩展）。 [

串口操作

　做串口方面的程序，使用CreateFile打开串口通信端口。在对串口操作之前，需要首先打开串口。使用C++进行串口编程，如果采用VS开发，则可以直接借助于串口通信控件来操作，其次，直接调用Windows的底层API函数来控制串口通信。

　　在Window 32bit 的操作系统上， 将串口（通信设备）作为文件来处理，所以串口的打开、关闭、读写所使用的API函数与文件操作一样。所以打开串口使用CreateFile函数，读写串口使用ReadFile、WriteFile，函数。关闭串口使用CloseHandle函数。

 

1. 查看通信串口设备，可以在设备管理器中查看；

1、CreateFile

这个函数的功能是创建或者打开一个文件或者I/O设备，通常使用的I/O形式有文件、文件流、目录、物理磁盘、卷、终端流等。如执行成功，则返回文件句柄。 INVALID_HANDLE_VALUE 表示出错，会设置 GetLastError 。 
　HANDLE WINAPI CreateFile(
  _In_      LPCTSTR lpFileName,              
  _In_      DWORD dwDesiredAccess,
  _In_      DWORD dwShareMode,
  _In_opt_  LPSECURITY_ATTRIBUTES lpSecurityAttributes,
  _In_      DWORD dwCreationDisposition,
  _In_      DWORD dwFlagsAndAttributes,
  _In_opt_  HANDLE hTemplateFile
);

\2. dwDesiredAccess:端口属性的访问类型，

3. dwShareMode：指定端口的共享属性。

该参数是由那些应用程序共享的文件提供。对于串口来说，是不能共享的，因此，必须设置为0，这是通信设备与文件的特殊差别。

如果当前的应用程序调用CreateFile打开一个串口，另外一个程序如果已经打开了该串口，此时CreateFile会返回一个错误代码。

然而，同一个应用程序的多个线程是可以共享CreateFile返回的端口句柄。并且根据安全属性设置，该句柄可以打开端口的应用程序的子程序来继承。

\4. lpSecurityAttributes:安全属性，一般该参数为NULL，即该端口被设置为缺省的安全属性。缺省安全属性下，端口的句柄是不能继承的。

5. dwCreationDisposition:指定此端口正在被其他程序占用采取的动作，因为串口总是存在的，因此必须设置为OPEN_EXISTing, 该标志高速Windows不要创建新的端口。而是打开一个已经存在的端口。

,　 6. dwFlagsAndSttributes：描述了端口的各种属性，对于文件来说有很多属性，但是对于串口来说，唯一的意义是FILE_FLAG _OVERLAPPED 属性，当设置该属性时，端口IO可以在后台进行，称为异步IO重叠结构。

7. hTemplateFile: 指定模板的文件句柄，对于串口来说，此参数必须设置为0；

关闭串口

关闭串口，使用CloseHandle，函数声明为：

函数很简单，参数是使用CreateFile打开的端口句柄。调用这个函数可以实现串口关闭。

示例如下：

2. ReadFile

从文件指针指向的位置（设备文件，通信）开始将数据读出到一个文件中， 且支持同步和异步操作，如果文件打开方式没有指明FILE_FLAG_OVERLAPPED的话，当程序调用成功时，它将实际读出文件的字节数保存到lpNumberOfBytesRead指明的地址空间中。FILE_FLAG_OVERLAPPED 允许对文件进行重叠操作。

　BOOL WINAPI ReadFile(
  __in          HANDLE hFile,                   // 文件句柄
  __out         LPVOID lpBuffer,                // 接收数据用的 buffer
  __in          DWORD nNumberOfBytesToRead,     // 要读取的字节数
  __out         LPDWORD lpNumberOfBytesRead,    // 实际读取到的字节数
  __in          LPOVERLAPPED lpOverlapped       // OVERLAPPED 结构，一般设定为 NULL 
);

　BOOL WINAPI ReadFile(
  __in          HANDLE hFile,                   // 文件句柄
  __out         LPVOID lpBuffer,                // 接收数据用的 buffer
  __in          DWORD nNumberOfBytesToRead,     // 要读取的字节数
  __out         LPDWORD lpNumberOfBytesRead,    // 实际读取到的字节数
  __in          LPOVERLAPPED lpOverlapped       // OVERLAPPED 结构，一般设定为 NULL 
);

3. WriteFile

将数据写入一个文件（设备文件，通信）。该函数比fwrite函数要灵活的多。也可将这个函数应用于对通信设备、管道、套接字以及邮槽的处理。返回时，TRUE（非零）表示成功，否则返回零。会设置GetLastError。

BOOL WINAPI WriteFile(
  __in          HANDLE hFile,                   // 文件句柄
  __in          LPCVOID lpBuffer,               // 要写入的数据
  __in          DWORD nNumberOfBytesToWrite,    // 要写入的字节数
  __out         LPDWORD lpNumberOfBytesWritten, // 实际写入的字节数
  __in          LPOVERLAPPED lpOverlapped       // OVERLAPPED 结构，一般设定为 NULL
);

BOOL Write(char *buffer, DWORD contentLen)
 2 {
 3     HANDLE pFile;
 4     char *tmpBuf;
 5     DWORD dwBytesWrite,dwBytesToWrite;
 6 
 7     pFile = CreateFile(filePath,GENERIC_WRITE,          
 8         0,
 9         NULL,               
10         CREATE_ALWAYS,        //总是创建文件
11         FILE_ATTRIBUTE_NORMAL, 
12         NULL);
13 
14     if ( pFile == INVALID_HANDLE_VALUE)
15     {
16         printf("create file error!\n");
17         CloseHandle(pFile);
18         return FALSE;
19     }
20 
21     dwBytesToWrite = contentLen;
22     dwBytesWrite = 0;
23 
24     tmpBuf = buffer;
25 
26     do{                                       //循环写文件，确保完整的文件被写入  
27 
28         WriteFile(pFile,tmpBuf,dwBytesToWrite,&dwBytesWrite,NULL);
29 
30         dwBytesToWrite -= dwBytesWrite;
31         tmpBuf += dwBytesWrite;
32 
33         } while (dwBytesToWrite > 0);
34 
35     CloseHandle(pFile);
36 
37     return TRUE;
38 }

windows使用串口实例

#pragma once
/
//这是头文件的代码，主要是定义了一个类
/

#ifndef SERIALPORT_H_  
#define SERIALPORT_H_  
#include <process.h>    
#include "TChar.h"
#include <string>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <algorithm>
#include <iterator>
#include <cctype>
#include <Windows.h>  
using namespace std;
/** 串口通信类
*
*  本类实现了对串口的基本操作
*  例如监听发到指定串口的数据、发送指定数据到串口
*/

typedef enum AxisType
{
	AXIS_XX = 2,
	AXIS_YY = 3,
	AXIS_ZZ = 1,
	AXIS_OO = 4,
}AXIS_TYPE;


class CSerialPort
{
public:
	CSerialPort(void);
	~CSerialPort(void);

public:

	/** 初始化串口函数
	*
	*  @param:  UINT portNo 串口编号,默认值为1,即COM1,注意,尽量不要大于9
	*  @param:  UINT baud   波特率,默认为9600
	*  @param:  char parity 是否进行奇偶校验,'Y'表示需要奇偶校验,'N'表示不需要奇偶校验
	*  @param:  UINT databits 数据位的个数,默认值为8个数据位
	*  @param:  UINT stopsbits 停止位使用格式,默认值为1
	*  @param:  DWORD dwCommEvents 默认为EV_RXCHAR,即只要收发任意一个字符,则产生一个事件
	*  @return: bool  初始化是否成功
	*  @note:   在使用其他本类提供的函数前,请先调用本函数进行串口的初始化
	*　　　　　   /n本函数提供了一些常用的串口参数设置,若需要自行设置详细的DCB参数,可使用重载函数
	*           /n本串口类析构时会自动关闭串口,无需额外执行关闭串口
	*  @see:
	*/
	//bool InitPort(UINT  portNo = 3, UINT  baud = CBR_19200, char  parity = 'N', UINT  databits = 8, UINT  stopsbits = 1, DWORD dwCommEvents = EV_RXCHAR);
	bool InitPort(UINT  portNo, UINT  baud, char  parity, UINT  databits, UINT  stopsbits, DWORD dwCommEvents);


	/** 串口初始化函数
	*
	*  本函数提供直接根据DCB参数设置串口参数
	*  @param:  UINT portNo
	*  @param:  const LPDCB & plDCB
	*  @return: bool  初始化是否成功
	*  @note:   本函数提供用户自定义地串口初始化参数
	*  @see:
	*/
	bool InitPort(UINT  portNo, const LPDCB& plDCB);

	/** 开启监听线程
	*
	*  本监听线程完成对串口数据的监听,并将接收到的数据打印到屏幕输出
	*  @return: bool  操作是否成功
	*  @note:   当线程已经处于开启状态时,返回flase
	*  @see:
	*/
	bool OpenListenThread();

	/** 关闭监听线程
	*
	*
	*  @return: bool  操作是否成功
	*  @note:   调用本函数后,监听串口的线程将会被关闭
	*  @see:
	*/
	bool CloseListenTread();

	/** 向串口写数据
	*
	*  将缓冲区中的数据写入到串口
	*  @param:  unsigned char * pData 指向需要写入串口的数据缓冲区
	*  @param:  unsigned int length 需要写入的数据长度
	*  @return: bool  操作是否成功
	*  @note:   length不要大于pData所指向缓冲区的大小
	*  @see:
	*/
	bool WriteData(unsigned char *pData, int length);

	/** 获取串口缓冲区中的字节数
	*
	*
	*  @return: UINT  操作是否成功
	*  @note:   当串口缓冲区中无数据时,返回0
	*  @see:
	*/
	UINT GetBytesInCOM();
	/*UINT WriteData1(unsigned long long int *pData1, unsigned int length);*/

	/** 读取串口接收缓冲区中一个字节的数据
	*
	*
	*  @param:  char & cRecved 存放读取数据的字符变量
	*  @return: bool  读取是否成功
	*  @note:
	*  @see:
	*/
	bool ReadChar(unsigned char &cRecved);

	unsigned char *MotorMoveXY(unsigned char x, unsigned char y);//xy相对移动
	unsigned char *StopMotor(unsigned char sm1);
	unsigned char *SetSpeed(AXIS_TYPE enAxisType, int speed);
	unsigned char *SetRunSpeed(int TY, int speed);
private:

	/** 打开串口
	*
	*
	*  @param:  UINT portNo 串口设备号
	*  @return: bool  打开是否成功
	*  @note:
	*  @see:
	*/
	bool openPort(UINT  portNo);

	/** 关闭串口
	*
	*
	*  @return: void  操作是否成功
	*  @note:
	*  @see:
	*/
	void ClosePort();

	/** 串口监听线程
	*
	*  监听来自串口的数据和信息
	*  @param:  void * pParam 线程参数
	*  @return: UINT WINAPI 线程返回值
	*  @note:
	*  @see:
	*/
	static UINT WINAPI ListenThread(void* pParam);

private:

	/** 串口句柄 */
	HANDLE  m_hComm;

	/** 线程退出标志变量 */
	static bool s_bExit;

	/** 线程句柄 */
	volatile HANDLE    m_hListenThread;

	/** 同步互斥,临界区保护 */
	CRITICAL_SECTION   m_csCommunicationSync;       //!< 互斥操作串口  

};

#endif //SERIALPORT_H_ 

linux下使用串口实例

1、 linux中的串口设备文件存放于/dev目录下，其中串口一，串口二对应设备名依次为“/dev/ttyS0”、“/dev/ttyS1”。在linux下操作串口与操作文件相同。

2、 在使用串口之前必须设置相关配置，包括：波特率、数据位、校验位、停止位等。串口设置由下面结构体实现：
————————————————
版权声明：本文为CSDN博主「虎皮猫大人王」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/liangxiaozhang/article/details/8313440

struct termios{
    tcflag_t c_iflag;        /*input flags*/
    tcflag_t c_oflag;        /*output flags*/
    tcflag_t c_cflag;        /*control flags*/
    tcflag_t c_lflag;        /*local flags*/
    cc_t c_cc[NCCS];         /*control characters*/
};

该结构中c_cflag最为重要，可设置波特率、数据位、校验位、停止位。在设置波特率时需在数字前加上‘B’，如B9600、B19200。使用其需通过“与”“或”操作方式。

常用的串口控制函数：

Tcgetattr         取属性(termios结构)

Tcsetattr         设置属性(termios结构)

cfgetispeed       得到输入速度

Cfgetospeed       得到输出速度

Cfsetispeed       设置输入速度

Cfsetospeed       设置输出速度

tcflush           刷清未决输入和/或输出
————————————————
版权声明：本文为CSDN博主「虎皮猫大人王」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/liangxiaozhang/article/details/8313440

3、 串口的配置

(1) 保存原先串口配置使用tcgetattr(fd,&oldtio)函数：

   struct termios newtio,oldtio;

   tcgetattr(fd,&oldtio);

(2) 激活选项有CLOCAL和CREAD,用于本地连接和接收使能。

   newtio.c_cflag | =  CLOCAL | CREAD;

(3) 设置波特率，使用函数cfsetispeed、 cfsetospeed

cfsetispeed(&newtio, B115200);

   cfsetospeed(&newtio, B115200);

(4) 设置数据位，需使用掩码设置。

   newtio.c_cflag &= ~CSIZE;

   newtio.c_cflag |= CS8;

(5) 设置奇偶校验位，使用c_cflag和c_iflag。

   设置奇校验：

          newtio.c_cflag |= PARENB;

          newtio.c_cflag |= PARODD;

          newtio.c_iflag |= (INPCK | ISTRIP);

   设置偶校验：

          newtio.c_iflag |= (INPCK | ISTRIP);

          newtio.c_cflag |= PARENB;

          newtio.c_cflag &= ~PARODD;

(6) 设置停止位，通过激活c_cflag中的CSTOPB实现。若停止位为1，则清除CSTOPB，若停止位为2，则激活CSTOPB。

          newtio.c_cflag &= ~CSTOPB;

(7) 设置最少字符和等待时间，对于接收字符和等待时间没有特别要求时，可设为0。

          newtio.c_cc[VTIME]  = 0;

          newtio.c_cc[VMIN] = 0;

(8) 处理要写入的引用对象

tcflush函数刷清（抛弃）输入缓存（终端驱动程序已接收到，但用户程序尚未读）或输出缓存（用户程序已经写，但尚未发送）。

int tcflush(int filedes, int queue )

queue数应当是下列三个常数之一：

• TCIFLUSH 刷清输入队列。

• TCOFLUSH 刷清输出队列。

• TCIOFLUSH 刷清输入、输出队列。

   如：tcflush(fd,TCIFLUSH);

(9) 激活配置。在完成配置后，需激活配置使其生效。使用tsettattr()函数。原型：

int tcgetattr(int filedes, struct termios * termptr);

int tcsetattr(int filedes, int opt, const struct termios * termptr);

tcsetattr的参数opt使我们可以指定在什么时候新的终端属性才起作用。opt可以指定为下列常数中的一个：

• TCSANOW 更改立即发生。

• TCSADRAIN 发送了所有输出后更改才发生。若更改输出参数则应使用此选择项。

• TCSAFLUSH 发送了所有输出后更改才发生。更进一步，在更改发生时未读的所有输入数据都被删除（刷清）

使用如：tcsetattr(fd,TCSANOW,&newtio)

4、 在配置完串口的相关属性后，就可对串口进行打开，读写操作了。其使用方式与文件操作一样，区别在于串口是一个终端设备。
————————————————
版权声明：本文为CSDN博主「虎皮猫大人王」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/liangxiaozhang/article/details/8313440

(1) 打开串口

fd = open( “/dev/ttyS0”, O_RDWR|O_NOCTTY|O_NDELAY);

Open函数中除普通参数外，另有两个参数O_NOCTTY和O_NDELAY。

O_NOCTTY: 通知linux系统，这个程序不会成为这个端口的控制终端。

O_NDELAY: 通知linux系统不关心DCD信号线所处的状态（端口的另一端是否激活或者停止）。

(2) 恢复串口的状态为阻塞状态，用于等待串口数据的读入。用fcntl函数：

   fcntl（fd, F_SETFL, 0）;

(3) 接着，测试打开的文件描述府是否引用一个终端设备，以进一步确认串口是否正确打开。

   isatty(STDIN_FILENO);

(4) 串口的读写与普通文件一样，使用read,write函数。

   read(fd,buf,8);

   write(fd,buf,8);

以下为一简单的程序实例：
————————————————
版权声明：本文为CSDN博主「虎皮猫大人王」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/liangxiaozhang/article/details/8313440

#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <errno.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <termios.h>
#include <stdlib.h>

int set_opt(int fd,int nSpeed, int nBits, char nEvent, int nStop)
{
  struct termios newtio,oldtio;
  if ( tcgetattr( fd,&oldtio) != 0) { 
    perror("SetupSerial 1");
    return -1;
  }
  bzero( &newtio, sizeof( newtio ) );
  newtio.c_cflag |= CLOCAL | CREAD; 
  newtio.c_cflag &= ~CSIZE; 

  switch( nBits )
  {
  case 7:
    newtio.c_cflag |= CS7;
    break;
  case 8:
    newtio.c_cflag |= CS8;
    break;
  }

  switch( nEvent )
  {
  case 'O':
    newtio.c_cflag |= PARENB;
    newtio.c_cflag |= PARODD;
    newtio.c_iflag |= (INPCK | ISTRIP);
    break;
  case 'E': 
    newtio.c_iflag |= (INPCK | ISTRIP);
    newtio.c_cflag |= PARENB;
    newtio.c_cflag &= ~PARODD;
    break;
  case 'N': 
    newtio.c_cflag &= ~PARENB;
    break;
  }

switch( nSpeed )
  {
  case 2400:
    cfsetispeed(&newtio, B2400);
    cfsetospeed(&newtio, B2400);
    break;
  case 4800:
    cfsetispeed(&newtio, B4800);
    cfsetospeed(&newtio, B4800);
    break;
  case 9600:
    cfsetispeed(&newtio, B9600);
    cfsetospeed(&newtio, B9600);
    break;
  case 115200:
    cfsetispeed(&newtio, B115200);
    cfsetospeed(&newtio, B115200);
    break;
  default:
    cfsetispeed(&newtio, B9600);
    cfsetospeed(&newtio, B9600);
    break;
  }
  if( nStop == 1 )
    newtio.c_cflag &= ~CSTOPB;
  else if ( nStop == 2 )
  newtio.c_cflag |= CSTOPB;
  newtio.c_cc[VTIME] = 0;
  newtio.c_cc[VMIN] = 0;
  tcflush(fd,TCIFLUSH);
  if((tcsetattr(fd,TCSANOW,&newtio))!=0)
  {
    perror("com set error");
    return -1;
  }
  printf("set done!\n");
  return 0;
}

int open_port(int fd,int comport)
{
  char *dev[]={"/dev/ttyS0","/dev/ttyS1","/dev/ttyS2"};
  long vdisable;
  if (comport==1)
  { fd = open( "/dev/ttyS0", O_RDWR|O_NOCTTY|O_NDELAY);
    if (-1 == fd){
      perror("Can't Open Serial Port");
      return(-1);
    }
    else 
      printf("open ttyS0 .....\n");
  }
  else if(comport==2)
  { fd = open( "/dev/ttyS1", O_RDWR|O_NOCTTY|O_NDELAY);
    if (-1 == fd){
      perror("Can't Open Serial Port");
      return(-1);
    }
    else 
      printf("open ttyS1 .....\n");
  }
  else if (comport==3)
————————————————
版权声明：本文为CSDN博主「虎皮猫大人王」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/liangxiaozhang/article/details/8313440

Linux操作系统从一开始就对串行口提供了很好的支持，本文就Linux下的串行口通讯编程进行简单的介绍。

串口简介

串行口是计算机一种常用的接口，具有连接线少，通讯简单，得到广泛的使用。常用的串口是RS-232-C接口(又称EIA RS-232-C)它是在1970年由美国电子工业协会(EIA)联合贝尔系统、调制解调器厂家及计算机终端生产厂家共同制定的用于串行通讯的标准。它的全名是"数据终端设备(DTE)和数据通讯设备(DCE)之间串行二进制数据交换接口技术标准"该标准规定采用一个25个脚的DB25连接器，对连接器的每个引脚的信号内容加以规定，还对各种信号的电平加以规定。传输距离在码元畸变小于4%的情况下，传输电缆长度应为50英尺。

Linux操作系统从一开始就对串行口提供了很好的支持，本文就Linux下的串行口通讯编程进行简单的介绍，如果要非常深入了解，建议看看本文所参考的《Serial Programming Guide for POSIX Operating Systems》
————————————————
版权声明：本文为CSDN博主「虎皮猫大人王」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/liangxiaozhang/article/details/8313440

串口操作

串口操作需要的头文件

#include <stdio.h> /标准输入输出定义/#include <stdlib.h> /标准函数库定义/#include <unistd.h> /Unix 标准函数定义/#include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> /文件控制定义/#include <termios.h> /PPSIX 终端控制定义/#include <errno.h> /错误号定义/
————————————————
版权声明：本文为CSDN博主「虎皮猫大人王」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/liangxiaozhang/article/details/8313440

打开串口

在 Linux 下串口文件是位于 /dev 下的。串口一 为 /dev/ttyS0，串口二 为 /dev/ttyS1。打开串口是通过使用标准的文件打开函数操作：
int fd;/*以读写方式打开串口*/fd = open( "/dev/ttyS0", O_RDWR);if (-1 == fd){ /* 不能打开串口一*/ perror(" 提示错误！");}

设置串口

最基本的设置串口包括波特率设置，效验位和停止位设置。串口的设置主要是设置 struct termios 结构体的各成员值。 
struct termio{	unsigned short  c_iflag;	/* 输入模式标志 */		unsigned short  c_oflag;		/* 输出模式标志 */		unsigned short  c_cflag;		/* 控制模式标志*/		unsigned short  c_lflag;		/* local mode flags */		unsigned char  c_line;		    /* line discipline */		unsigned char  c_cc[NCC];    /* control characters */};
————————————————
版权声明：本文为CSDN博主「虎皮猫大人王」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/liangxiaozhang/article/details/8313440

设置这个结构体很复杂，我这里就只说说常见的一些设置：

波特率设置 下面是修改波特率的代码：

struct  termios Opt;tcgetattr(fd, &Opt);cfsetispeed(&Opt,B19200);     /*设置为19200Bps*/cfsetospeed(&Opt,B19200);tcsetattr(fd,TCANOW,&Opt);

设置波特率的例子函数：

/***@brief  设置串口通信速率*@param  fd     类型 int  打开串口的文件句柄*@param  speed  类型 int  串口速度*@return  void*/int speed_arr[] = { B38400, B19200, B9600, B4800, B2400, B1200, B300,		B38400, B19200, B9600, B4800, B2400, B1200, B300, };int name_arr[] = {38400,  19200,  9600,  4800,  2400,  1200,  300, 38400,  			19200,  9600, 4800, 2400, 1200,  300, };void set_speed(int fd, int speed){	int   i; 	int   status; 	struct termios   Opt;	tcgetattr(fd, &Opt); 	for ( i= 0;  i < sizeof(speed_arr) / sizeof(int);  i++) { 		if  (speed == name_arr[i]) {     			tcflush(fd, TCIOFLUSH);     			cfsetispeed(&Opt, speed_arr[i]);  			cfsetospeed(&Opt, speed_arr[i]);   			status = tcsetattr(fd1, TCSANOW, &Opt);  			if  (status != 0) {        				perror("tcsetattr fd1");  				return;     			}    			tcflush(fd,TCIOFLUSH);   		}  	}}
————————————————
版权声明：本文为CSDN博主「虎皮猫大人王」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/liangxiaozhang/article/details/8313440

设置效验的函数：

/***@brief   设置串口数据位，停止位和效验位*@param  fd     类型  int  打开的串口文件句柄*@param  databits 类型  int 数据位   取值 为 7 或者8*@param  stopbits 类型  int 停止位   取值为 1 或者2*@param  parity  类型  int  效验类型 取值为N,E,O,,S*/int set_Parity(int fd,int databits,int stopbits,int parity){ 	struct termios options; 	if  ( tcgetattr( fd,&options)  !=  0) { 		perror("SetupSerial 1");     		return(FALSE);  	}	options.c_cflag &= ~CSIZE; 	switch (databits) /*设置数据位数*/	{   	case 7:				options.c_cflag |= CS7; 		break;	case 8:     		options.c_cflag |= CS8;		break;   	default:    		fprintf(stderr,"Unsupported data size\n"); return (FALSE);  	}switch (parity) {   	case 'n':	case 'N':    		options.c_cflag &= ~PARENB;   /* Clear parity enable */		options.c_iflag &= ~INPCK;     /* Enable parity checking */ 		break;  	case 'o':   	case 'O':     		options.c_cflag |= (PARODD | PARENB); /* 设置为奇效验*/  		options.c_iflag |= INPCK;             /* Disnable parity checking */ 		break;  	case 'e':  	case 'E':   		options.c_cflag |= PARENB;     /* Enable parity */    		options.c_cflag &= ~PARODD;   /* 转换为偶效验*/     		options.c_iflag |= INPCK;       /* Disnable parity checking */		break;	case 'S': 	case 's':  /*as no parity*/   	    options.c_cflag &= ~PARENB;		options.c_cflag &= ~CSTOPB;break;  	default:   		fprintf(stderr,"Unsupported parity\n");    		return (FALSE);  	}  /* 设置停止位*/  switch (stopbits){   	case 1:    		options.c_cflag &= ~CSTOPB;  		break;  	case 2:    		options.c_cflag |= CSTOPB;  	   break;	default:    		 fprintf(stderr,"Unsupported stop bits\n");  		 return (FALSE); } /* Set input parity option */ if (parity != 'n')   	options.c_iflag |= INPCK; tcflush(fd,TCIFLUSH);options.c_cc[VTIME] = 150; /* 设置超时15 seconds*/   options.c_cc[VMIN] = 0; /* Update the options and do it NOW */if (tcsetattr(fd,TCSANOW,&options) != 0)   { 	perror("SetupSerial 3");   	return (FALSE);  } return (TRUE);  }
————————————————
版权声明：本文为CSDN博主「虎皮猫大人王」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/liangxiaozhang/article/details/8313440

需要注意的是: 如果不是开发终端之类的，只是串口传输数据，而不需要串口来处理，那么使用原始模式(Raw Mode)方式来通讯，设置方式如下：

options.c_lflag  &= ~(ICANON | ECHO | ECHOE | ISIG);  /*Input*/options.c_oflag  &= ~OPOST;   /*Output*/

读写串口

设置好串口之后，读写串口就很容易了，把串口当作文件读写就是。

char  buffer[1024];int    Length;int    nByte;nByte = write(fd, buffer ,Length)
使用文件操作read函数读取，如果设置为原始模式(Raw Mode)传输数据，那么read函数返回的字符数是实际串口收到的字符数。可以使用操作文件的函数来实现异步读取，如fcntl，或者select等来操作。
char  buff[1024];int    Len;int  readByte = read(fd,buff,Len);
char  buff[1024];int    Len;int  readByte = read(fd,buff,Len);

/**********************************************************************代码说明：使用串口二测试的，发送的数据是字符，但是没有发送字符串结束符号，所以接收到后，后面加上了结束符号。我测试使用的是单片机发送数据到第二个串口，测试通过。**********************************************************************/#define FALSE  -1#define TRUE   0/*********************************************************************/int OpenDev(char *Dev){	int	fd = open( Dev, O_RDWR );         //| O_NOCTTY | O_NDELAY		if (-1 == fd)		{ 					perror("Can't Open Serial Port");		return -1;			}		else			return fd;}int main(int argc, char **argv){	int fd;	int nread;	char buff[512];	char *dev  = "/dev/ttyS1"; //串口二	fd = OpenDev(dev);	set_speed(fd,19200);	if (set_Parity(fd,8,1,'N') == FALSE)  {		printf("Set Parity Error\n");		exit (0);	}while (1) //循环读取数据{   	while((nread = read(fd, buff, 512))>0)	{ 		printf("\nLen %d\n",nread); 		buff[nread+1] = '\0';   		printf( "\n%s", buff);   	}}	//close(fd);  	// exit (0);}
————————————————
版权声明：本文为CSDN博主「虎皮猫大人王」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/liangxiaozhang/article/details/8313440

O_RDWR ); //| O_NOCTTY | O_NDELAY if (-1 == fd) { perror(“Can’t Open Serial Port”); return -1; } else return fd;}int main(int argc, char **argv){ int fd; int nread; char buff[512]; char *dev = “/dev/ttyS1”; //串口二 fd = OpenDev(dev); set_speed(fd,19200); if (set_Parity(fd,8,1,‘N’) == FALSE) { printf(“Set Parity Error\n”); exit (0); }while (1) //循环读取数据{ while((nread = read(fd, buff, 512))>0) { printf("\nLen %d\n",nread); buff[nread+1] = ‘\0’; printf( “\n%s”, buff); }} //close(fd); // exit (0);}
————————————————
版权声明：本文为CSDN博主「虎皮猫大人王」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/liangxiaozhang/article/details/8313440