no message

This commit is contained in:
zcy 2021-09-20 23:46:15 +08:00
parent a53b7df333
commit d3827b9cdb
3 changed files with 340 additions and 285 deletions

View File

@ -3,6 +3,9 @@
#include <atlstr.h>
#include <setupapi.h>
#include <vector>
#include <windows.h>
#include <iostream>
#include <winspool.h>
using namespace std;
@ -11,62 +14,44 @@ const std::wstring NewMonitorForm::kClassName = L"Basic";
vector<wstring> EnumPortsWdm()
{
int i, dwDetDataSize;
vector<wstring> ret;
TCHAR fname[256], locinfo[256];
HDEVINFO hDevInfo;
SP_DEVICE_INTERFACE_DETAIL_DATA* pDetData;
SP_DEVICE_INTERFACE_DATA ifcData;
SP_DEVINFO_DATA devdata;
std::vector<std::wstring> ret;
LPCTSTR Reg_Path = _T("HARDWARE\\DEVICEMAP\\SERIALCOMM"); //串口注册表路径
//TCHAR pnum[8];
HKEY H_Key;
static UINT portlist[255]; //一般情况下255个数组够用了。
long Status;
UINT PortNum;
DWORD count = 0;//遍历键值计数。
DWORD Com_Length, Type_Length, Type;
TCHAR Com_Name[256];//存储串口名字
TCHAR Type_Name[256];//存储串口类型
Status = RegOpenKeyEx(HKEY_LOCAL_MACHINE, Reg_Path, 0, KEY_READ, &H_Key); //打开注册表表键返回long
memset(portlist, 0, sizeof(portlist)); // 清0
static const GUID ___GUID_CLASS_COMPORT = \
{ 0x86E0D1E0L, 0x8089, 0x11D0, { 0x9C, 0xE4, 0x08, 0x00, 0x3E, 0x30, 0x1F, 0x73 } };
/*static const GUID ___GUID_CLASS_COMPORT = \
{ 0xAD498944, 0x762F, 0x11D0, { 0x8D, 0xCB, 0x00, 0xC0, 0x4F, 0xC3, 0x35, 0x8C } };*/
hDevInfo = SetupDiGetClassDevs(&___GUID_CLASS_COMPORT, NULL, NULL, DIGCF_PRESENT | DIGCF_DEVICEINTERFACE);
if (hDevInfo == INVALID_HANDLE_VALUE)
if (Status) //返回值为0表示打开成功不为0则表示打开失败
{
return ret;
}
dwDetDataSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA) + 256;
pDetData = (SP_DEVICE_INTERFACE_DETAIL_DATA*)calloc(1, dwDetDataSize);
if (!pDetData)
while (true)
{
SetupDiDestroyDeviceInfoList(hDevInfo);
return ret;
}
ifcData.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);
pDetData->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA);
for (i = 0; SetupDiEnumDeviceInterfaces(hDevInfo, NULL, &___GUID_CLASS_COMPORT, i, &ifcData); i++)
{
memset(&devdata, 0, sizeof(SP_DEVINFO_DATA));
devdata.cbSize = sizeof(SP_DEVINFO_DATA);
if (!SetupDiGetDeviceInterfaceDetail(hDevInfo, &ifcData, pDetData, dwDetDataSize, NULL, &devdata))
Com_Length = 256; //存储两个长度,每次都要赋一个大一点的值,不然下次可能会失败,Com_length值翻倍
Type_Length = 256;
PortNum = 0;
Status = RegEnumValue(H_Key, count++, Type_Name, &Type_Length
, 0, &Type, PUCHAR(Com_Name), &Com_Length);
if (Status) //查询失败说明遍历结束,跳出循环。
{
break;
}
if (SetupDiGetDeviceRegistryProperty(hDevInfo, &devdata, SPDRP_FRIENDLYNAME, NULL, (PBYTE)fname, sizeof(fname), NULL))
ret.push_back(Com_Name);
for (int i = 3; Com_Name[i]; i++) //转换为数字
{
ret.push_back(wstring(fname));
PortNum = PortNum * 10 + (Com_Name[i] - '0');
}
if (SetupDiGetDeviceRegistryProperty(hDevInfo, &devdata, SPDRP_LOCATION_INFORMATION, NULL, (PBYTE)locinfo, sizeof(locinfo), NULL))
{
if (StrCmpN(locinfo, TEXT("USB"), 3) == 0)
{
}
}
portlist[count - 1] = PortNum;
}
free(pDetData);
SetupDiDestroyDeviceInfoList(hDevInfo);
return ret;
}
@ -101,14 +86,24 @@ LRESULT NewMonitorForm::HandleMessage(UINT uMsg, WPARAM wParam, LPARAM lParam)
void NewMonitorForm::InitWindow()
{
ui::Button* btn_add_new = dynamic_cast<ui::Button*>(FindControl(L"exit_button"));
if (nullptr != btn_add_new) {
btn_add_new->SetText(L"Í˳ö");
btn_add_new->AttachClick([this](ui::EventArgs*) {
ui::Button* btnclose = dynamic_cast<ui::Button*>(FindControl(L"exit_button"));
if (nullptr != btnclose) {
btnclose->SetText(L"退出");
btnclose->AttachClick([this](ui::EventArgs*) {
this->Close();
return true;
});
}
ui::Button* btn_add_new = dynamic_cast<ui::Button*>(FindControl(L"open_button"));
if (nullptr != btn_add_new) {
btn_add_new->SetText(L"退出");
btn_add_new->AttachClick([this](ui::EventArgs*) {
return true;
});
}
m_combo_type = dynamic_cast<ui::Combo*>(FindControl(L"combo_type"));
if (NULL != m_combo_type) {
ui::ListContainerElement* element = new ui::ListContainerElement;
@ -186,7 +181,7 @@ void NewMonitorForm::InitWindow()
element->SetBkColor(L"white");
element->SetTextPadding({ 6,0,6,0 });
element->SetText(nbase::StringPrintf(L"%s", &x.c_str()[x.find(L"COM")]));
element->SetDataID(nbase::StringPrintf(L"%s", x.c_str()));
this->m_uart_select_combo->Add(element);
}
vector<wstring> baurate;

View File

@ -1,252 +1,292 @@
#include "serial_port.h"
#include <stdio.h>
#include <string.h>
#include <WinSock2.h>
#include <windows.h>
#include<tchar.h>
#include<iostream>
using namespace std;
//#include<map>
#include <windows.h>
//using namespace std;
#include"serial_port.h"
map<int, HANDLE> SerialPort::ComMap;
//构造函数
SerialPort::SerialPort()
{
}
} //构造函数
//析构函数
SerialPort::~SerialPort()
{
}
bool SerialPort::open(const char* portname,
int baudrate,
char parity,
char databit,
char stopbit,
char synchronizeflag)
//获取串口列表
UINT SerialPort::GetPortNum(UINT** PortList)
{
this->synchronizeflag = synchronizeflag;
HANDLE hCom = NULL;
if (this->synchronizeflag)
LPCTSTR Reg_Path = _T("HARDWARE\\DEVICEMAP\\SERIALCOMM"); //串口注册表路径
//TCHAR pnum[8];
HKEY H_Key;
static UINT portlist[255]; //一般情况下255个数组够用了。
long Status;
UINT PortNum;
DWORD count = 0;//遍历键值计数。
DWORD Com_Length, Type_Length, Type;
TCHAR Com_Name[256];//存储串口名字
TCHAR Type_Name[256];//存储串口类型
Status = RegOpenKeyEx(HKEY_LOCAL_MACHINE, Reg_Path, 0, KEY_READ, &H_Key); //打开注册表表键返回long
memset(portlist, 0, sizeof(portlist)); // 清0
if (Status) //返回值为0表示打开成功不为0则表示打开失败
{
//同步方式
hCom = CreateFileA(portname, //串口名
GENERIC_READ | GENERIC_WRITE, //支持读写
0, //独占方式,串口不支持共享
NULL,//安全属性指针默认值为NULL
OPEN_EXISTING, //打开现有的串口文件
0, //0同步方式FILE_FLAG_OVERLAPPED异步方式
NULL);//用于复制文件句柄默认值为NULL对串口而言该参数必须置为NULL
return 0;
}
while (true)
{
Com_Length = 256; //存储两个长度,每次都要赋一个大一点的值,不然下次可能会失败,Com_length值翻倍
Type_Length = 256;
PortNum = 0;
Status = RegEnumValue(H_Key, count++, Type_Name, &Type_Length
, 0, &Type, PUCHAR(Com_Name), &Com_Length);
if (Status) //查询失败说明遍历结束,跳出循环。
{
break;
}
for (int i = 3; Com_Name[i]; i++) //转换为数字
{
PortNum = PortNum * 10 + (Com_Name[i] - '0');
}
portlist[count - 1] = PortNum;
}
*PortList = portlist; //重定向指针
return (count - 1);
}
//_stprintf_s(DcbPara, _T("baud=%d parity=%c data=%d stop=%d"), 9600, 'N', 8, 1);
//打开端口
HANDLE SerialPort::OpenPort(UINT PortNo) //打开端口
{
HANDLE H_Com; //串口句柄
//PortNum = PortNo; //串口号
TCHAR PortName[20];
//将串口号打印到字符数组里该方式可以打开10以上串口
_stprintf_s(PortName, _T("\\\\.\\COM%d"), PortNo);
H_Com = CreateFile(PortName,
GENERIC_READ | GENERIC_WRITE,//读写
0,
NULL,
OPEN_EXISTING, //已经存在的
0,
0); //打开串口,同步方式
if (H_Com == INVALID_HANDLE_VALUE)//如果串口打开失败
{
return INVALID_HANDLE_VALUE;
}
SetupComm(H_Com, 1024, 1024); //设置读写缓冲区为1024;
ComMap[PortNo] = H_Com; // 打开成功则存入map
return H_Com;
}
//关闭端口
void SerialPort::ClosePort(UINT PortNo) //关闭串口
{
if (PortState(PortNo)) //串口是打开的
{
HANDLE H_Com = ComMap[PortNo]; //获取句柄
CloseHandle(H_Com);
ComMap.erase(PortNo); //从map中清除
}
}
//关闭所有端口
void SerialPort::ClearAllPort() //关闭串口
{
for (map<int, HANDLE>::iterator iter = ComMap.begin(); iter != ComMap.end(); )
{
CloseHandle(iter->second); //关闭串口
iter = ComMap.erase(iter); //必须这样写 否则迭代器失效会引发异常。
}
}
//初始化串口
int SerialPort::InitPort(UINT PortNo, UINT Baud, byte Parity, byte Data, byte Stop)
{
if (PortState(PortNo)) //如果端口已经存在
{
ClosePort(PortNo); //关掉端口
}
if (Parity < 0 || Parity >4) //parity 0~4
return 0;
if (Stop < 0 || Stop >2) //stop 0~2
return 0;
HANDLE H_Com; //串口句柄
//TCHAR DcbPara[50]; //串口Dcb结构
//_stprintf_s(DcbPara, _T("baud=%d parity=%c data=%d stop=%d") , Baud, Parity, Data, Stop);
H_Com = OpenPort(PortNo);
if (H_Com == INVALID_HANDLE_VALUE)
{
return 0;
}
//int count = 0;
COMMTIMEOUTS ComTimeouts = { 10, 0, 0, 0, 0 };
/*
ComTimeouts.ReadIntervalTimeout = 0;
ComTimeouts.ReadTotalTimeoutConstant = 0;
ComTimeouts.ReadTotalTimeoutMultiplier = 0;
ComTimeouts.WriteTotalTimeoutConstant = 0;
ComTimeouts.WriteTotalTimeoutMultiplier = 0;
*/
DCB S_dcb;
if (!SetCommTimeouts(H_Com, &ComTimeouts))//设置超时
{
return 0;
}
if (!GetCommState(H_Com, &S_dcb)) //获取现有DCB结构
{
return 0;
}
S_dcb.BaudRate = Baud;
S_dcb.ByteSize = Data;
S_dcb.Parity = Parity;
S_dcb.StopBits = Stop;
//if(!BuildCommDCB(DcbPara , &S_dcb))//构建DCB
//{
// return 0;
//}
S_dcb.fRtsControl = RTS_CONTROL_ENABLE; //允许Rts信号
if (!SetCommState(H_Com, &S_dcb)) //设置DCB
{
int i = GetLastError();
return 0;
}
PurgeComm(H_Com, PURGE_RXCLEAR | PURGE_TXCLEAR |
PURGE_RXABORT | PURGE_TXABORT); //清空缓冲区
return 1;
}
int SerialPort::PortState(UINT PortNo)
{
map<int, HANDLE>::iterator iter;
iter = ComMap.find(PortNo);
if (iter != ComMap.end()) //说明查找到了端口
return 1;
else
{
//异步方式
hCom = CreateFileA(portname, //串口名
GENERIC_READ | GENERIC_WRITE, //支持读写
0, //独占方式,串口不支持共享
NULL,//安全属性指针默认值为NULL
OPEN_EXISTING, //打开现有的串口文件
FILE_FLAG_OVERLAPPED, //0同步方式FILE_FLAG_OVERLAPPED异步方式
NULL);//用于复制文件句柄默认值为NULL对串口而言该参数必须置为NULL
}
if (hCom == (HANDLE)-1)
{
return false;
}
//配置缓冲区大小
if (!SetupComm(hCom, 1024, 1024))
{
return false;
}
// 配置参数
DCB p;
memset(&p, 0, sizeof(p));
p.DCBlength = sizeof(p);
p.BaudRate = baudrate; // 波特率
p.ByteSize = databit; // 数据位
switch (parity) //校验位
{
case 0:
p.Parity = NOPARITY; //无校验
break;
case 1:
p.Parity = ODDPARITY; //奇校验
break;
case 2:
p.Parity = EVENPARITY; //偶校验
break;
case 3:
p.Parity = MARKPARITY; //标记校验
break;
}
switch (stopbit) //停止位
{
case 1:
p.StopBits = ONESTOPBIT; //1位停止位
break;
case 2:
p.StopBits = TWOSTOPBITS; //2位停止位
break;
case 3:
p.StopBits = ONE5STOPBITS; //1.5位停止位
break;
}
if (!SetCommState(hCom, &p))
{
// 设置参数失败
return false;
}
//超时处理,单位:毫秒
//总超时=时间系数×读或写的字符数+时间常量
COMMTIMEOUTS TimeOuts;
TimeOuts.ReadIntervalTimeout = 1000; //读间隔超时
TimeOuts.ReadTotalTimeoutMultiplier = 500; //读时间系数
TimeOuts.ReadTotalTimeoutConstant = 5000; //读时间常量
TimeOuts.WriteTotalTimeoutMultiplier = 500; // 写时间系数
TimeOuts.WriteTotalTimeoutConstant = 2000; //写时间常量
SetCommTimeouts(hCom, &TimeOuts);
PurgeComm(hCom, PURGE_TXCLEAR | PURGE_RXCLEAR);//清空串口缓冲区
memcpy(pHandle, &hCom, sizeof(hCom));// 保存句柄
return true;
return 0;
}
void SerialPort::close()
//读串口
int SerialPort::ReadPort(UINT PortNo, char* P_recved, int length) //重载函数 一次读取指定长度的数据
{
HANDLE hCom = *(HANDLE*)pHandle;
CloseHandle(hCom);
}
int SerialPort::send(string dat)
if (PortState(PortNo) == 0) //串口未打开
return 0;
HANDLE H_Com = ComMap[PortNo];
DWORD Recn; //实际读取长度
BOOL Result = TRUE;
Result = ReadFile(H_Com, P_recved, length, &Recn, NULL);
if (Result == 0)
{
//GetLastError();
PurgeComm(H_Com, PURGE_RXCLEAR | PURGE_RXABORT);
return 0;
}
return Recn;
}
//清空缓冲区
void SerialPort::ClearCom(UINT PortNo)
{
HANDLE hCom = *(HANDLE*)pHandle;
if (this->synchronizeflag)
{
// 同步方式
DWORD dwBytesWrite = dat.length(); //成功写入的数据字节数
BOOL bWriteStat = WriteFile(hCom, //串口句柄
(char*)dat.c_str(), //数据首地址
dwBytesWrite, //要发送的数据字节数
&dwBytesWrite, //DWORD*,用来接收返回成功发送的数据字节数
NULL); //NULL为同步发送OVERLAPPED*为异步发送
if (!bWriteStat)
{
return 0;
}
return dwBytesWrite;
}
else
{
//异步方式
DWORD dwBytesWrite = dat.length(); //成功写入的数据字节数
DWORD dwErrorFlags; //错误标志
COMSTAT comStat; //通讯状态
OVERLAPPED m_osWrite; //异步输入输出结构体
//创建一个用于OVERLAPPED的事件处理不会真正用到但系统要求这么做
memset(&m_osWrite, 0, sizeof(m_osWrite));
m_osWrite.hEvent = CreateEvent(NULL, TRUE, FALSE, L"WriteEvent");
ClearCommError(hCom, &dwErrorFlags, &comStat); //清除通讯错误,获得设备当前状态
BOOL bWriteStat = WriteFile(hCom, //串口句柄
(char*)dat.c_str(), //数据首地址
dwBytesWrite, //要发送的数据字节数
&dwBytesWrite, //DWORD*,用来接收返回成功发送的数据字节数
&m_osWrite); //NULL为同步发送OVERLAPPED*为异步发送
if (!bWriteStat)
{
if (GetLastError() == ERROR_IO_PENDING) //如果串口正在写入
{
WaitForSingleObject(m_osWrite.hEvent, 1000); //等待写入事件1秒钟
}
else
{
ClearCommError(hCom, &dwErrorFlags, &comStat); //清除通讯错误
CloseHandle(m_osWrite.hEvent); //关闭并释放hEvent内存
return 0;
}
}
return dwBytesWrite;
}
if (PortState(PortNo) == 0) //串口未打开
return;
HANDLE H_Com = ComMap[PortNo];
PurgeComm(H_Com, PURGE_RXCLEAR | PURGE_RXABORT);
}
string SerialPort::receive()
int SerialPort::CheckRTS(UINT PortNo)
{
HANDLE hCom = *(HANDLE*)pHandle;
string rec_str = "";
char buf[1024];
if (this->synchronizeflag)
{
//同步方式
DWORD wCount = 1024; //成功读取的数据字节数
BOOL bReadStat = ReadFile(hCom, //串口句柄
buf, //数据首地址
wCount, //要读取的数据最大字节数
&wCount, //DWORD*,用来接收返回成功读取的数据字节数
NULL); //NULL为同步发送OVERLAPPED*为异步发送
for (int i = 0; i < 1024; i++)
{
if (buf[i] != -52)
rec_str += buf[i];
else
break;
}
return rec_str;
}
else
{
//异步方式
DWORD wCount = 1024; //成功读取的数据字节数
DWORD dwErrorFlags; //错误标志
COMSTAT comStat; //通讯状态
OVERLAPPED m_osRead; //异步输入输出结构体
//创建一个用于OVERLAPPED的事件处理不会真正用到但系统要求这么做
memset(&m_osRead, 0, sizeof(m_osRead));
m_osRead.hEvent = CreateEvent(NULL, TRUE, FALSE, L"ReadEvent");
ClearCommError(hCom, &dwErrorFlags, &comStat); //清除通讯错误,获得设备当前状态
if (!comStat.cbInQue)return 0; //如果输入缓冲区字节数为0则返回false
//std::cout << comStat.cbInQue << std::endl;
BOOL bReadStat = ReadFile(hCom, //串口句柄
buf, //数据首地址
wCount, //要读取的数据最大字节数
&wCount, //DWORD*,用来接收返回成功读取的数据字节数
&m_osRead); //NULL为同步发送OVERLAPPED*为异步发送
if (!bReadStat)
{
if (GetLastError() == ERROR_IO_PENDING) //如果串口正在读取中
{
//GetOverlappedResult函数的最后一个参数设为TRUE
//函数会一直等待,直到读操作完成或由于错误而返回
GetOverlappedResult(hCom, &m_osRead, &wCount, TRUE);
}
else
{
ClearCommError(hCom, &dwErrorFlags, &comStat); //清除通讯错误
CloseHandle(m_osRead.hEvent); //关闭并释放hEvent的内存
return 0;
}
}
for (int i = 0; i < 1024; i++)
{
if (buf[i] != -52)
rec_str += buf[i];
else
break;
}
return rec_str;
}
return 0;
}
//写串口
int SerialPort::WritePort(UINT PortNo, const char* pData, int length)
{
if (PortState(PortNo) == 0) //串口未打开
return 0;
HANDLE H_Com = ComMap[PortNo];
if (length == 0)
length = strlen(pData);
DWORD Recn;
BOOL Result = TRUE;
if (H_Com == INVALID_HANDLE_VALUE)
return -1;
Result = WriteFile(H_Com, pData, length, &Recn, NULL);
if (Result == 0)
{
GetLastError();
PurgeComm(H_Com, PURGE_RXCLEAR | PURGE_RXABORT);
return 0;
}
return Recn;
}
//获取要读取的字节数
UINT SerialPort::GetByte(UINT PortNo) //该函数获取缓冲区字节长度。
{
if (PortState(PortNo) == 0) //串口未打开
return 0;
HANDLE H_Com = ComMap[PortNo];
DWORD dwError;
COMSTAT comstat;
DWORD BytesInQue = 0;
DWORD FirstSize = 0;
memset(&comstat, 0, sizeof(COMSTAT)); //初始化缓冲区;
while (true)
{
BytesInQue = FirstSize;
Sleep(10);
if (ClearCommError(H_Com, &dwError, &comstat))
FirstSize = comstat.cbInQue; //重新赋值
if (BytesInQue == FirstSize)
break;
}
return BytesInQue;
}

View File

@ -1,36 +1,56 @@
#pragma once
#include <iostream>
#include <map>
using namespace std;
class SerialPort
{
public:
SerialPort();
~SerialPort();
// 打开串口,成功返回true失败返回false
// portname(串口名): 在Windows下是"COM1""COM2"等在Linux下是"/dev/ttyS1"等
// baudrate(波特率): 9600、19200、38400、43000、56000、57600、115200
// parity(校验位): 0为无校验1为奇校验2为偶校验3为标记校验
// databit(数据位): 4-8通常为8位
// stopbit(停止位): 1为1位停止位2为2位停止位,3为1.5位停止位
// synchronizable(同步、异步): 0为异步1为同步
bool Open(const char* portname, int baudrate = 115200, char parity = 0, char databit = 8, char stopbit = 1, char synchronizeflag = 0);
//关闭串口,参数待定
void Close();
//发送数据或写数据成功返回发送数据长度失败返回0
int Send(string dat);
//接受数据或读数据成功返回读取实际数据的长度失败返回0
string Receive();
private:
int pHandle[16];
char synchronizeflag;
//使用CreateFile打开串口同步方式打开
static HANDLE OpenPort(UINT PortNo = 1);
public:
//通过查询注册表方式获取系统里面的串口,返回串口数量,指针指向串口列表
static UINT GetPortNum(UINT** PortList);
//从指定串口缓冲区读取数据
static UINT GetByte(UINT PortNo);
//关闭指定串口并从map删除
static void ClosePort(UINT PortNo);
//关闭所有串口
static void ClearAllPort();
//初始化指定端口成功后存入map
static int InitPort(UINT PortNo, UINT Baud = 9600, byte Parity = 0, byte Data = 8, byte Stop = 0); //初始化串口
//从指定端口读取数据,返回值表示读取的bytes
static int ReadPort(UINT PortNo, char* P_recved, int length);
//往指定串口发送数据,返回实际写入
static int WritePort(UINT PortNo, const char* pData, int length = 0);
//检查指定串口状态
static int PortState(UINT PortNo);
//清空指定串口缓冲区
static void ClearCom(UINT PortNo);
//指定端口RTS信号检测用于脚踏开关信号触发
static int CheckRTS(UINT PortNo);
public:
//static UINT PortNum; //串口端口号
static map<int, HANDLE> ComMap;
};