C++ 串口编程 打开串口

2021-06-03 14:45:26

新建windows应用程序commtest。

commtest.cpp：

// commtest.cpp: 主项目文件。

#include "stdafx.h"

#include "Form1.h"

#include //添加头文件

#include

using namespace commtest;

bool openport(char *portname);

[STAThreadAttribute]

int main(array<:string> ^args)

{

bool open;

open=openport("com2"); //打开串口2

// 在创建任何控件之前启用 Windows XP 可视化效果

Application::EnableVisualStyles();

Application::SetCompatibleTextRenderingDefault(false);

// 创建主窗口并运行它

Application::Run(gcnew Form1());

return 0;

}

bool openport(char *portname)//打开串口

{

HANDLE hComm;

hComm = CreateFile(portname, //串口号

GENERIC_READ | GENERIC_WRITE, //允许读写

0, //通讯设备必须以独占方式打开

0, //无安全属性

OPEN_EXISTING, //通讯设备已存在

FILE_FLAG_OVERLAPPED, //异步I/O

0); //通讯设备不能用模板打开

if (hComm == INVALID_HANDLE_VALUE)

{

CloseHandle(hComm);

return FALSE;

}

else

return true;

}

更多相关内容
Visual C++串口编程.pdf
2021-09-05 21:12:14

Visual C++串口编程

收起

C++串口编程

万次阅读 多人点赞 2018-06-03 13:08:40

// 定义串口类型 #ifdef _UNICODE typedef CString porttype; #else typedef std::string porttype; #endif // _UNICODE typedef unsigned long ulong; typedef unsigned char uchar; class CSerialPort { public...

CSerialPort 类，头文件： SerialPort.h

#ifndef _SERIAL_H
#define _SERIAL_H

#include <string>
#include <Windows.h>
#include <cstddef>
#include <cstdlib>
#include <cassert>

// 定义串口类型
#ifdef _UNICODE
typedef CString porttype;
#else
typedef std::string porttype;
#endif // _UNICODE

typedef unsigned long ulong;
typedef unsigned char uchar;


class CSerialPort
{
public:
	CSerialPort(
		const porttype & portNum,		// 串口号
		DWORD baudRate = 9600,			// 波特率
		BYTE  byteSize = 8,				// 数据位
		BYTE  parityBit = NOPARITY,		// 检验位
		BYTE  stopBit = ONESTOPBIT		// 停止位
		);

	~CSerialPort();

public:

	bool openComm();										// 打开串口
	void closeComm();										// 关闭串口
	bool writeToComm(BYTE data[], DWORD dwLegnth);			// 发送数据
	bool readFromComm(char buffer[], DWORD dwLength);		// 读取数据

private:

	HANDLE m_hComm;		// 通信设备
	porttype m_portNum; // 串口号
	DWORD m_dwBaudRate; // 波特率
	BYTE  m_byteSize;	// 数据位
	BYTE  m_parityBit;  // 校验位
	BYTE  m_stopBit;	// 停止位
	bool  m_bOpen;		// 串口开关标志
private:
	
	enum BufferSize
	{
		MIN_BUFFER_SIZE = 256,
		BUFFER_SIZE = 512,
		MAX_BUFFER_SIZE = 1024
	};

	// 设置串口号
	void setPortNum(const porttype &portNum)
	{
		this->m_portNum = portNum;
	}
	// 设置波特率
	void setBaudRate(const ulong baudRate)
	{
		this->m_dwBaudRate = baudRate;
	}
	// 设置数据位
	void setByteSize(const uchar byteSize)
	{
		this->m_byteSize = byteSize;
	}
	// 设置检验位
	void setParityBit(const uchar parityBit)
	{
		this->m_parityBit = parityBit;
	}
	// 设置停止位
	void setStopBit(const uchar stopBit)
	{
		this->m_stopBit = stopBit;
	}

	// 获取串口号
	porttype getPortNum() { return m_portNum; }
	// 获取波特率
	ulong getBaudRate() { return m_dwBaudRate; }
	// 获取数据位
	uchar getByteSize() { return m_byteSize; }
	// 获取检验位
	uchar getParityBit() { return m_parityBit; }
	// 获取停止位
	uchar getStopBit() { return m_stopBit; }
};




#endif		// _SERIAL_H

SerialPort 类实现文件 .cpp:

#include "stdafx.h"
#include "Serial.h"

CSerialPort::CSerialPort(
	const porttype & portNum,
	DWORD baudRate /* = 9600 */,
	BYTE byteSize /* = 8 */,
	BYTE parityBit /* = NOPARITY */,
	BYTE stopBit /* = ONESTOPBIT */
	) : m_portNum(portNum),
	m_dwBaudRate(baudRate),
	m_byteSize(byteSize),
	m_parityBit(parityBit),
	m_stopBit(stopBit),
	m_bOpen(false)
{

}

CSerialPort::~CSerialPort()
{

}

// 打开串口成功,返回 true

bool CSerialPort::openComm()
{
#ifdef _UNICODE
	m_hComm = CreateFile(m_portNum,
		GENERIC_READ | GENERIC_WRITE, //允许读和写
		0,		//独占方式
		NULL, OPEN_EXISTING,   //打开而不是创建
		0,   //同步方式
		NULL
		);
#else
	m_hComm = CreateFileA(m_portNum.c_str(),
		GENERIC_READ | GENERIC_WRITE, //允许读和写
		0,		//独占方式
		NULL, OPEN_EXISTING,   //打开而不是创建
		0,   //同步方式
		NULL
		);
#endif

	if (m_hComm == INVALID_HANDLE_VALUE)
	{
#ifdef _UNICODE
		TCHAR szBuf[1024] = { 0 };
		wsprintf(szBuf, L"打开 %s 失败,代码: %d", m_portNum, GetLastError());
		MessageBox(NULL, szBuf, L"Warnning", MB_OK);
#else
		char szBuf[1024] = { 0 };
		sprintf_s(szBuf, "打开 %s 失败,代码: %d", m_portNum, GetLastError());
		MessageBox(NULL, szBuf, "Warnning", MB_OK);
#endif // _UNICODE

		return false;

	}
	else
	{
		DCB dcb;
		SetupComm(m_hComm, MAX_BUFFER_SIZE, MAX_BUFFER_SIZE);	// 设置读写缓冲区大小
		GetCommState(m_hComm, &dcb);
		dcb.BaudRate = m_dwBaudRate;
		dcb.ByteSize = m_byteSize;
		dcb.Parity = m_parityBit;
		dcb.StopBits = m_stopBit;

		if (!SetCommState(m_hComm, &dcb))
		{
#ifdef _UNICODE
			TCHAR szBuf[1024] = { 0 };
			wsprintf(szBuf, L"串口设置失败,错误代码: %d", GetLastError());
			MessageBox(NULL, szBuf, TEXT("ERROR"), MB_OK);
#else
			char szBuf[1024] = { 0 };
			wsprintf(szBuf, "串口设置失败,错误代码: %d", GetLastError());
			MessageBox(NULL, szBuf, "ERROR", MB_OK);
#endif
			return false;
		}

	}

	//在读写串口前，用 PurgeComm 函数清空缓冲区
	PurgeComm(m_hComm, PURGE_RXCLEAR | PURGE_TXCLEAR | PURGE_TXABORT | PURGE_TXABORT);

	m_bOpen = true;

	return true;

}

// 关闭串口

void CSerialPort::closeComm()
{
	CloseHandle(m_hComm);
}


// 向串口发送数据
bool CSerialPort::writeToComm(BYTE data[], DWORD dwLength)
{
#ifdef _DEBUG
	assert(m_bOpen == true || dwLength > 0);
	return false;
#endif // _DEBUG
	DWORD dwError = 0;
	if (ClearCommError(m_hComm, &dwError, NULL) && dwError > 0)
	{
		PurgeComm(m_hComm, PURGE_TXABORT | PURGE_TXCLEAR);
	}

	DWORD dwTx = 0;
	BOOL ret = FALSE;
	ret = WriteFile(m_hComm, data, dwLength, &dwTx, NULL);

	if (ret == FALSE)
	{
#ifdef _UNICODE
		TCHAR szBuf[1024] = { 0 };
		wsprintf(szBuf, _T("读取数据失败,错误代码: %d"), GetLastError());
		MessageBox(NULL, szBuf, L"ERROR", MB_OK);
#else
		char szBuf[1024] = { 0 };
		sprintf_s(szBuf, "读取数据失败, 错误代码: %d", GetLastError());
		MessageBox(NULL, szBuf, "Error", MB_OK);
#endif // _UNICODE

		return false;
	}

	return true;


}

// 从串口中读取数据

bool CSerialPort::readFromComm(char buffer[], DWORD dwLength)
{
#ifdef _DEBUG
	assert(m_bOpen == true || dwLength > 0);
	return false;
#endif // _DEBUG

	COMSTAT comStat;
	DWORD dwError = 0;
	if (ClearCommError(m_hComm, &dwError, &comStat) && dwError > 0)
	{
		PurgeComm(m_hComm, PURGE_RXABORT | PURGE_RXCLEAR);
	}

	DWORD dwRx = 0;		// 读入的字节数
	BOOL ret = FALSE;
	BYTE* byReadData = new BYTE[dwLength];
	char szTmp[4] = { 0 };
	int sizeOfBytes = sizeof(szTmp);
	ret = ReadFile(m_hComm, byReadData, dwLength, &dwRx, NULL);	// 读入数据

	if (ret == TRUE)
	{
		for (int i = 0; i < dwRx; ++i)
		{
			sprintf_s(szTmp, "%02x", byReadData[i]);
			strcat_s(buffer, sizeOfBytes*dwLength, szTmp);
		}

		// 释放内存
		delete byReadData;

		return true;
	}
	else
	{
#ifdef _UNICODE
		TCHAR szBuf[1024] = { 0 };
		wsprintf(szBuf, _T("数据读取失败,错误代码: %d"), GetLastError());
		MessageBox(NULL, szBuf, L"Error", MB_OK);
#else
		char szBuf[1024] = { 0 };
		wsprintf(szBuf, "数据读取失败,错误代码: %d", GetLastError());
		MessageBox(NULL, szBuf, "Error", MB_OK);
#endif // _UNICODE

		return false;
	}

	return true;
}

#include <iostream>
#include <cassert>
#include "Serial.h"
using namespace std;
 


int main()
{
	CSerialPort serialPort("COM3");

	BYTE sendData = 0x01;
	char recvBuf[1024] = { 0 };

	serialPort.openComm();
	serialPort.writeToComm(&sendData, 1);
	serialPort.readFromComm(recvBuf, 1);

	serialPort.closeComm();

	system("pause");
	return 0;
}

收起

展开全文

C++串口编程实例
2014-11-19 09:16:50

VC++串口通信，有详细的过程截图，配备有说明。

收起

基于windows的C/C++串口编程

2021-11-03 13:40:25

基于windows的C/C++串口编程 下面代码是接收到的数据在发回去的代码。COM2为端口名称，根据实际尽心更改！ #include <stdio.h> #include <stdlib.h> #include <windows.h> #define debug(...) ...

基于windows的C/C++串口编程

下面代码是接收到的数据在发回去的代码。COM2为端口名称，根据实际进行更改！

#include <stdio.h>
#include <stdlib.h>
#include <windows.h>

#define debug(...) printf(__VA_ARGS__)

int main(void)
{
	DCB dcb;
	HANDLE hCom;
	COMMTIMEOUTS CommTimeouts;
	DWORD wRead, wWrite;
	WINBOOL bReadStat;
	char hj212_string[1500];

	hCom = CreateFile(TEXT("COM2"), GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);

	if(hCom == INVALID_HANDLE_VALUE)
	{
		debug("Can not open COM2 !\r\n");
		return -1;
	}else
	{
		debug("Open COM2 Successfully !\r\n");
	}

	// 设置读写缓存大小
	SetupComm(hCom, 2048, 2048);

	//设定读超时
	CommTimeouts.ReadIntervalTimeout = MAXDWORD;//读间隔超时
	CommTimeouts.ReadTotalTimeoutMultiplier = 0;//读时间系数
	CommTimeouts.ReadTotalTimeoutConstant = 0;//读时间常量

	//设定写超时
	CommTimeouts.WriteTotalTimeoutMultiplier = 1;//写时间系数
	CommTimeouts.WriteTotalTimeoutConstant = 1;//写时间常量
	SetCommTimeouts(hCom, &CommTimeouts); //设置超时


	GetCommState(hCom, &dcb);
	dcb.BaudRate = 9600; //波特率为9600
	dcb.ByteSize = 8; //每个字节有8位
	dcb.Parity = NOPARITY; //无奇偶校验位
	dcb.StopBits = ONESTOPBIT; //一个停止位
	SetCommState(hCom, &dcb);

	while(1)
	{
		wRead = 0;
		bReadStat = ReadFile(hCom, hj212_string, sizeof(hj212_string), &wRead, NULL);
		if(bReadStat && wRead != 0)
		{
			WriteFile(hCom, hj212_string, wRead, &wWrite, NULL);
		}
	}

	CloseHandle(hCom);
}

收起

展开全文

windows c语言

C++串口编程调试精灵.zip
2019-10-14 14:54:50

C++串口串口编程调试源码，实测可用，有需要的可以下载看看

收起
Visual C++串口编程
2018-11-26 20:16:34

VC串口编程指南，从 WIN32 API 到 MSCOMM 、SERIERPORT 类编程

收起
C++串口编程实例源代码详细解说
2014-05-19 09:29:30

自己一步步实现的C++MFC串口编程的小实例

收起
c++串口编程
2016-03-26 10:39:38

连接硬件串口类

收起
VisualStuido2010 C++串口编程源代码
2018-09-07 10:57:21

最近学弟要用Window下的串口编程，我把串口类封装了一遍，非常容易加入其它工程项目。代码都已可以直接运行，测试代码我也写了，都是可以用的。

收起

Linux C++ 串口编程详解+实例

千次阅读 2017-07-01 22:10:56

Linux C++ 串口编程 详解+实例大致步骤 Linux下的串口编程其实与Windows下无本质差别，说白了就是类似读写文件一样，对串口进行读写操作，用到的函数无非就是open，close，read，write函数等。具体的读写操作可...

Linux C++ 串口编程详解+实例

大致步骤

Linux下的串口编程其实与Windows下无本质差别，说白了就是类似读写文件一样，对串口进行读写操作，用到的函数无非就是open，close，read，write函数等。具体的读写操作可分为下面四个步骤

打开串口
配置串口
读写串口
关闭串口

打开串口

打开串口使用的是open函数，后缀第一个表示读写，第二个表示不允许进程干涉串口的读写操作（不太明白，实测发现终端输入会导致读写出错），第三个表示非阻塞。打开串口默认都是阻塞形式，使用标志位O_NDELAY可以设置为非阻塞模式，或者使用系统函数fcntl进行设置。
fd = open(“/dev/ttyS*”, O_RDWR | O_NOCTTY | O_NDELAY);
open可以接受的标志位如下：
O_RDONLY只读模式
O_WRONLY只写模式
O_RDWR读写模式
上述三个标志位必选其一
………………………………………………………………………………………………………………………………………………….
O_APPEND每次写操作都写入文件的末尾
O_CREAT如果指定文件不存在，则创建这个文件
O_EXCL如果要创建的文件已存在，则返回 -1，并且修改 errno 的值
O_TRUNC如果文件存在，并且以只写/读写方式打开，则清空文件全部内容
O_NOCTTY如果路径名指向终端设备，不要把这个设备用作控制终端。
O_NONBLOCK如果路径名指向 FIFO/块文件/字符文件，则把文件的打开和后继 I/O设置为非阻塞模式（nonblocking mode）
下面三个常量同样是选用的，他们用于同步输入输出
O_DSYNC等待物理 I/O 结束后再 write。在不影响读取新写入的数据的前提下，不等待文件属性更新。
O_RSYNC读(read)等待所有写入同一区域的写操作完成后再进行
O_SYNC等待物理 I/O 结束后再 write，包括更新文件属性的 I/O
对于串口的打开操作，必须使用O_NOCTTY参数，它表示打开的是一个终端设备，程序不会成为该端口的控制终端。如果不使用此标志，任务的一个输入(比如键盘终止信号等)都会影响进程。
O_NDELAY表示不关心DCD信号所处的状态（端口的另一端是否激活或者停止）
打开串口后的句柄 “fd” 即代表了此串口，后续操作都是对句柄进行。

配置串口

串口配置主要包括波特率的配置，校验位，停止位的设置等等。具体如下：

 struct termios Opt;       //创建设置结构体，配置串口即改变结构体内元素的内容
 tcgetattr(fd, &Opt);      //保存原有的配置，保存在Opt中
 tcflush(fd, TCIOFLUSH);   //刷清输入输出队列
 cfsetispeed(&Opt, B9600); //设置输入波特率
 cfsetospeed(&Opt, B9600); //设置输出波特率

波特率可以设置115200，9600等等，值得注意的是在设置波特率的时候要在前面加Ｂ。接下来设置停止位，校验位等等，依旧使用上述创建的结构体：

Opt.c_cflag &= ~CSIZE;   //屏蔽数据位
Opt.c_cflag  |= CS8; // 数据位为 8 ，CS7 for 7 
Opt.c_cflag &= ~CSTOPB;  // 一位停止位， 两位停止为 |= CSTOPB
Opt.c_cflag &= ~PARENB;  // 无校验
Opt.c_cflag |= PARENB;   //有校验
Opt.c_cflag &= ~PARODD;   // 偶校验
Opt.c_cflag |=  PARODD;   // 奇校验

接下来设置一些时间参数：

Opt.c_cc[VTIME] = 1;  //设置等待时间
Opt.c_cc[VMIN] = 100;     //设置最小字节数

时间参数只有在设置为阻塞模式下才能使用，VMIN代表读取的最小字节数，当VTIME参数设置为0时，只有当串口内的数据达到VMIN长度时，read函数才会进行读取操作；
当时间参数VTIME不为0时，若串口内到达的数据未到达VMIN，read函数将等待VTIME时间之后对数据进行读取；

另一种监测串口是否有数据到达的函数是select，使用此参数可以在确定串口内有数据时才对串口数据进行读写。

FD_ZERO(&rfds);
FD_SET(fd,&rfds);
timeval timeout;
timeout.tv_sec = 10;
timeout.tv_usec = 0;
retval =select(fd+1,&rfds,NULL,NULL,NULL);

上述代码通过设置句柄rfds来对fd进行监控，并根据fd的状态，select函数将返回不同的值。其中timeout为超时等待时间，若不希望函数阻塞可以写为：

retval =select(fd+1,&rfds,NULL,NULL,&timeout);

读写串口

读函数：

res = read(fd,buf,len);

写函数：

n = write(fd, "str", len);

注意，当读写出错是函数将返回值-1。

关闭串口

关闭串口简单粗暴：

close(fd);

程序实例

bool connectDevice(){
  fd = open( SerialPort, O_RDWR|/*O_NOCTTY|*/O_NDELAY);
  if (-1 == fd)
  {
     ROS_WARN("Redsky UART:Can't Open Serial Port");
     return(-1);
  }
  // flushing is to be done after opening. This prevents first read and write to be spam'ish.
  tcflush(fd, TCIOFLUSH);
  int n = fcntl(fd, F_GETFL, 0);
  //恢复为阻塞模式
  fcntl(fd, F_SETFL, n & ~O_NDELAY);
  portSet(fd,9600,8,"None","1",false,false);
  connected = true;
  return 1;
}

int portSet(int m_fd, int baudrate, int databits, const std::string & parity, const std::string & stop, bool softwareHandshake, bool hardwareHandshake)
{
   struct termios newtio;
//  memset(&newtio, 0, sizeof(newtio));
   if (tcgetattr(m_fd, &newtio)!=0)
   {
      //std::cerr<<"tcgetattr() 3 failed"<<std::endl;
      return -1;
   }
   //printf("tcgetattr() 3 success!\n");

   speed_t _baud=0;
   switch (baudrate)
   {
  #ifdef B0
     case      0: _baud=B0;     break;
  #endif

  #ifdef B50
     case     50: _baud=B50;    break;
  #endif
  #ifdef B75
     case     75: _baud=B75;    break;
  #endif
  #ifdef B110
     case    110: _baud=B110;   break;
  #endif
  #ifdef B134
     case    134: _baud=B134;   break;
  #endif
  #ifdef B150
     case    150: _baud=B150;   break;
  #endif
  #ifdef B200
     case    200: _baud=B200;   break;
  #endif
  #ifdef B300
     case    300: _baud=B300;   break;
  #endif
  #ifdef B600
     case    600: _baud=B600;   break;
  #endif
  #ifdef B1200
     case   1200: _baud=B1200;  break;
  #endif
  #ifdef B1800
     case   1800: _baud=B1800;  break;
  #endif
  #ifdef B2400
     case   2400: _baud=B2400;  break;
  #endif
  #ifdef B4800
     case   4800: _baud=B4800;  break;
  #endif
  #ifdef B7200
     case   7200: _baud=B7200;  break;
  #endif
  #ifdef B9600
     case   9600: _baud=B9600;  break;
  #endif
  #ifdef B14400
     case  14400: _baud=B14400; break;
  #endif
  #ifdef B19200
     case  19200: _baud=B19200; break;
  #endif
  #ifdef B28800
     case  28800: _baud=B28800; break;
  #endif
  #ifdef B38400
     case  38400: _baud=B38400; break;
  #endif
  #ifdef B57600
     case  57600: _baud=B57600; break;
  #endif
  #ifdef B76800
     case  76800: _baud=B76800; break;
  #endif
  #ifdef B115200
     case 115200: _baud=B115200; break;
  #endif
  #ifdef B128000
     case 128000: _baud=B128000; break;
  #endif
  #ifdef B230400
     case 230400: _baud=B230400; break;
  #endif
  #ifdef B460800
     case 460800: _baud=B460800; break;
  #endif
  #ifdef B576000
     case 576000: _baud=B576000; break;
  #endif
  #ifdef B921600
     case 921600: _baud=B921600; break;
  #endif
   default:
//   case 256000:
//      _baud=B256000;
      break;
   }
   cfsetospeed(&newtio, (speed_t)_baud);
   cfsetispeed(&newtio, (speed_t)_baud);

   /* We generate mark and space parity ourself. */
   if (databits == 7 && (parity=="Mark" || parity == "Space"))
   {
      databits = 8;
   }
   switch (databits)
   {
   case 5:
      newtio.c_cflag = (newtio.c_cflag & ~CSIZE) | CS5;
      break;
   case 6:
      newtio.c_cflag = (newtio.c_cflag & ~CSIZE) | CS6;
      break;
   case 7:
      newtio.c_cflag = (newtio.c_cflag & ~CSIZE) | CS7;
      break;
   case 8:
   default:
      newtio.c_cflag = (newtio.c_cflag & ~CSIZE) | CS8;
      break;
   }
   newtio.c_cflag |= CLOCAL | CREAD;

   //parity
   newtio.c_cflag &= ~(PARENB | PARODD);
   if (parity == "Even")
   {
      newtio.c_cflag |= PARENB;
   }
   else if (parity== "Odd")
   {
      newtio.c_cflag |= (PARENB | PARODD);
   }

   //hardware handshake
  /*   if (hardwareHandshake)
      newtio.c_cflag |= CRTSCTS;
   else
      newtio.c_cflag &= ~CRTSCTS;*/
   newtio.c_cflag &= ~CRTSCTS;

   //stopbits
   if (stop=="2")
   {
      newtio.c_cflag |= CSTOPB;
   }
   else
   {
      newtio.c_cflag &= ~CSTOPB;
   }

   //   newtio.c_iflag=IGNPAR | IGNBRK;
   newtio.c_iflag=IGNBRK;
   //   newtio.c_iflag=IGNPAR;

   //software handshake
   if (softwareHandshake)
   {
      newtio.c_iflag |= IXON | IXOFF;
   }
   else
   {
      newtio.c_iflag &= ~(IXON|IXOFF|IXANY);
   }

   newtio.c_lflag=0;
   newtio.c_oflag=0;

   newtio.c_cc[VTIME]=1;
   newtio.c_cc[VMIN]=60;

//   tcflush(m_fd, TCIFLUSH);
   if (tcsetattr(m_fd, TCSANOW, &newtio)!=0)
   {
      std::cerr<<"tcsetattr() 1 failed"<<std::endl;
   }

   int mcs=0;
   ioctl(m_fd, TIOCMGET, &mcs);
   mcs |= TIOCM_RTS;
   ioctl(m_fd, TIOCMSET, &mcs);

   if (tcgetattr(m_fd, &newtio)!=0)
   {
      //std::cerr<<"tcgetattr() 4 failed"<<std::endl;
   }

   //hardware handshake
   if (hardwareHandshake)
   {
      newtio.c_cflag |= CRTSCTS;
   }
   else
   {
      newtio.c_cflag &= ~CRTSCTS;
   }
/*  if (on)
     newtio.c_cflag |= CRTSCTS;
  else
     newtio.c_cflag &= ~CRTSCTS;*/
   if (tcsetattr(m_fd, TCSANOW, &newtio)!=0)
   {
      //std::cerr<<"tcsetattr() 2 failed"<<std::endl;
   }
   //printf("tcsetattr() 2 success!\n");
   return 1;
}

int readRev(char* revBuf){
  //使用select设置阻塞时间
  fd_set rfds;
  FD_ZERO(&rfds);
  FD_SET(fd,&rfds);
  timeval timeout;
  timeout.tv_sec = 1;  //秒
  timeout.tv_usec = 0;  //微秒
  //int retval = select(fd+1, &rfds, NULL, NULL, &timeout);
  int retval = select(fd+1, &rfds, NULL, NULL, &timeout);

  if(retval <= 0){
    ROS_WARN("No data receive from port, select error");
    return -1;//"noData";
  }
  else{
    int len = read(fd, revBuf, MAXBUF);
  }
}

收起

展开全文

c语言 linux

完整的c++串口编程源代码
2011-04-20 09:36:53

这是一个很好的串口编程例子.用C++写的，详细的描述了一个C++的串口调试程序。

收起
Windows下C++ 串口编程实例
千次阅读 2017-09-27 16:14:44

1. 本例子使用了比较规范的软件设计方法，类的设计具有比较好的可扩展性和移植性、代码的注释采用doxgen支持...3. 本例子设计的串口操作类可以直接移植到其他的工程中去，大家也可以根据自己的需要添加其他的接口。 4.

收起
IT学吧视频中的C++串口编程
2015-11-06 09:57:24

IT学吧好像关闭了，网上也没找到过源码，自己用vs2013动手写的，经过了测试，希望能给初学者提供参考。

收起
深入浅出Visual C++串口编程
热门讨论 2011-01-24 22:04:08

深入浅出Visual C++串口编程 串口通信是Windows应用软件开发的重要环节，除了普通的通信软件外，还在工业控制领域有广泛的用途，因此掌握串口编程是每个程序员的必备技巧。 •无庸讳言，目前网上有不少介绍串口通信...

收起
Win32串口编程（C++）
2010-12-08 08:45:38

这里是对win32串口编程进行封装，需要对串口进行操作直接可以拿来用。

收起
C++串口编程实例例程解释说明
2014-05-16 09:36:54

在windows程序设计与开发过程中，特别是涉及到开发嵌入式软硬件系统时，往往会涉及到串口编程。网上以及一些书籍上讲解windows下的串口编程知识也挺多的，但我个人觉得，看完书上的知识点有时依然不知道该如何下手...

收起
Linux c++多线程串口编程demo
2018-01-26 21:14:23

使用多线程进行串口编程，获取串口数据，利用互斥锁和信号量在不同的线程中安全地操作数据，希望该demo能帮助你快速理解并掌握上述知识。

收起
c++串口程序
2018-11-29 14:07:40

c++ win32 串口程序

收起
一个很简单的Ubuntu下读写串口的C++程序
2018-03-04 17:35:05

自己写的一个很简单的Ubuntu下读写串口的C++程序，有比较详细的注释，分享给大家参考

收起
Linux 下串口编程（C++ 程序设计）
2021-04-06 14:30:17

网络上已经有大量关于Linux下 C++ 串口编程的文章，但是我依然要写这篇博文。因为网络上的资料不是内容太多，就是过于简短。我想写的恰到好处。文章中的部分内容来自于: Linux 下串口编程入门我将这些内容封装成为...

收起
C++串口编程CserialPort类源码
2014-01-09 11:28:17

一个用于VC串口开发的工具类。简单实用。做串口开发的童鞋不用再头疼了，工具类可以直接使用。注意是vc++版本

收起
C++ WINDOWS下串口编程（QT为工程模板）
2021-04-27 09:21:24

本文将依托QT工程，编写Windows...-Windows下串口编程需要底层提供的结构体以及函数，函数库 ——DCB 结构体 typedef struct _DCB { DWORD DCBlength; DWORD BaudRate; DWORD fBinary: 1 ; DWORD fParity: 1 ;

收起

Visual C++串口编程.pdf

C++串口编程

C++串口编程实例

基于windows的C/C++串口编程

基于windows的C/C++串口编程

C++串口编程调试精灵.zip

Visual C++串口编程

C++串口编程实例源代码详细解说

c++串口编程

VisualStuido2010 C++串口编程源代码

Linux C++ 串口编程详解+实例

Linux C++ 串口编程详解+实例

大致步骤

打开串口

配置串口

读写串口

关闭串口

程序实例

完整的c++串口编程源代码

Windows下C++ 串口编程实例

IT学吧视频中的C++串口编程

深入浅出Visual C++串口编程

Win32串口编程（C++）

C++串口编程实例例程解释说明

Linux c++多线程串口编程demo

c++串口程序

一个很简单的Ubuntu下读写串口的C++程序

Linux 下串口编程（C++ 程序设计）

C++串口编程CserialPort类源码

C++ WINDOWS下串口编程（QT为工程模板）

c++串口编程

Visual C++串口编程.pdf

C++串口编程

C++串口编程实例

基于windows的C/C++串口编程

基于windows的C/C++串口编程

C++串口编程调试精灵.zip

Visual C++串口编程

C++串口编程实例 源代码详细解说

c++串口编程

VisualStuido2010 C++串口编程源代码

Linux C++ 串口编程 详解+实例

Linux C++ 串口编程 详解+实例

大致步骤

打开串口

配置串口

读写串口

关闭串口

程序实例

完整的c++串口编程源代码

Windows下C++ 串口编程实例

IT学吧视频中的C++串口编程

深入浅出Visual C++串口编程

Win32串口编程（C++）

C++串口编程实例 例程解释说明

Linux c++多线程串口编程demo

c++串口程序

一个很简单的Ubuntu下读写串口的C++程序

Linux 下串口编程（C++ 程序设计）

C++串口编程CserialPort类源码

C++ WINDOWS下串口编程（QT为工程模板）

c++串口编程

C++串口编程实例源代码详细解说

Linux C++ 串口编程详解+实例

Linux C++ 串口编程详解+实例

C++串口编程实例例程解释说明