精华内容
下载资源
问答
  • 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++串口编程 下面代码是接收到的数据在发回去的代码。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);
    }
    
    
    展开全文
  • C++串口串口编程调试源码,实测可用,有需要的可以下载看看
  • Visual C++串口编程

    2018-11-26 20:16:34
    VC串口编程指南,从 WIN32 API 到 MSCOMM 、SERIERPORT 类编程
  • 自己 一步步 实现的C++MFC串口编程的小实例
  • c++串口编程

    2016-03-26 10:39:38
    连接硬件串口
  • 最近学弟要用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函数等。具体的读写操作可分为下面四个步骤

    1. 打开串口
    2. 配置串口
    3. 读写串口
    4. 关闭串口

    打开串口

    打开串口使用的是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等等,值得注意的是在设置波特率的时候要在前面加B。接下来设置停止位,校验位等等,依旧使用上述创建的结构体:

    Opt.c_cflag &= ~CSIZE;   //屏蔽数据位
    Opt.c_cflag  |= CS8; // 数据位为 8CS7 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++写的,详细的描述了一个C++的串口调试程序。
  • Windows下C++ 串口编程实例

    千次阅读 2017-09-27 16:14:44
    1. 本例子使用了比较规范的软件设计方法,类的设计具有比较好的可扩展性和移植性、代码的注释采用doxgen支持...3. 本例子设计的串口操作类可以直接移植到其他的工程中去,大家也可以根据自己的需要添加其他的接口。 4.
  • IT学吧好像关闭了,网上也没找到过源码,自己用vs2013动手写的,经过了测试,希望能给初学者提供参考。
  • 深入浅出Visual C++串口编程

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

    2010-12-08 08:45:38
    这里是对win32串口编程进行封装,需要对串口进行操作直接可以拿来用。
  • 在windows程序设计与开发过程中,特别是涉及到开发嵌入式软硬件系统时,往往会涉及到串口编程。网上以及一些书籍上讲解windows下的串口编程知识也挺多的,但我个人觉得,看完书上的知识点有时依然不知道该如何下手...
  • 使用多线程进行串口编程,获取串口数据,利用互斥锁和信号量在不同的线程中安全地操作数据,希望该demo能帮助你快速理解并掌握上述知识。
  • c++串口程序

    2018-11-29 14:07:40
    c++ win32 串口程序
  • 自己写的一个很简单的Ubuntu下读写串口C++程序,有比较详细的注释,分享给大家参考
  • 网络上已经有大量关于Linux下 C++ 串口编程的文章,但是我依然要写这篇博文。因为网络上的资料不是内容太多,就是过于简短。我想写的恰到好处。 文章中的部分内容来自于: Linux 下串口编程入门 我将这些内容封装成为...
  • 一个用于VC串口开发的工具类。简单实用。做串口开发的童鞋不用再头疼了,工具类可以直接使用。注意是vc++版本
  • 本文将依托QT工程,编写Windows...-Windows下串口编程需要底层提供的结构体以及函数,函数库 ——DCB 结构体 typedef struct _DCB { DWORD DCBlength; DWORD BaudRate; DWORD fBinary: 1 ; DWORD fParity: 1 ;

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 12,286
精华内容 4,914
关键字:

c++串口编程

c++ 订阅