wen 编程最新 2024-01-31

串口消息读取并解析

//SerialPort.h

#ifndef SERIALPORT_H_  
#define SERIALPORT_H_  

#include <Windows.h>  
#include <process.h>  
#include <stdint.h>
#include <iostream>  
#include "Common.h"
#include "MsgQueue.h"

/** 串口通信类
*
*  本类实现了对串口的基本操作
*  例如监听发到指定串口的数据、发送指定数据到串口
*/
#define UARTRX_LEN  12

#define FRAME_HEAD1         0XFA
#define FRAME_HEAD2         0XAF

#define FRAME_HEAD_LEN      3
#define FRAME_MIN_LEN 		6
#define FRAME_MAX_LEN 		12

#define IS_ONE(number, n) ((number >> n) & (0x1))

typedef struct
{
	short int Front;
	short int Back;
	short int Num;
	unsigned char  Data[UARTRX_LEN];
}UART_RxStruDef;


class CSerialPort
{
public:
	~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 = 1, UINT  baud = CBR_115200, char  parity = "N", UINT  databits = 8, UINT  stopsbits = 1, DWORD dwCommEvents = EV_RXCHAR);

	/** 串口初始化函数
	*
	*  本函数提供直接根据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, unsigned int length);

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

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

	void Bsp_Uart1RxQueueIn(unsigned char  temp);
	void Bsp_Uart1RxUnPackageHandle(void);
	void MCU_CommRx_Event(unsigned char loadlen, unsigned char *pbuf);

	static CSerialPort *getInstance() 
	{ 
		if (nullptr == m_instance)
		{
			m_instance = new CSerialPort();
		}
		return m_instance; 
	};

private:

	CSerialPort(void);
	
	/** 打开串口
	*
	*
	*  @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:
	static CSerialPort * m_instance;
	/** 串口句柄 */
	HANDLE  m_hComm;

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

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

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

};

#endif //SERIALPORT_H_

//SerialPort.cpp

#include "SerialPort.h"

CSerialPort *CSerialPort::m_instance = nullptr;
/** 线程退出标志 */
bool CSerialPort::s_bExit = false;
/** 当串口无数据时,sleep至下次查询间隔的时间,单位:秒 */
const UINT SLEEP_TIME_INTERVAL = 5;
UART_RxStruDef Uart1_Rx;
static unsigned char Rx1PLoad_buf[FRAME_MAX_LEN];
static unsigned char Rx1pLoad_buf_temp[FRAME_MAX_LEN];
static unsigned char DiretionVal = 0;

time_t delayTimeBegin = 0;

CSerialPort::CSerialPort(void)
{
    m_hComm = INVALID_HANDLE_VALUE;
    m_hListenThread = INVALID_HANDLE_VALUE;

    InitializeCriticalSection(&m_csCommunicationSync);

}

CSerialPort::~CSerialPort(void)
{
    CloseListenTread();
    ClosePort();
    DeleteCriticalSection(&m_csCommunicationSync);
}

bool CSerialPort::InitPort(UINT portNo /*= 1*/, UINT baud /*= CBR_9600*/, char parity /*= "N"*/,
                           UINT databits /*= 8*/, UINT stopsbits /*= 1*/, DWORD dwCommEvents /*= EV_RXCHAR*/)
{

    /** 临时变量,将制定参数转化为字符串形式,以构造DCB结构 */
    char szDCBparam[50];
    sprintf_s(szDCBparam, "baud=%d parity=%c data=%d stop=%d", baud, parity, databits, stopsbits);

    /** 打开指定串口,该函数内部已经有临界区保护,上面请不要加保护 */
    if (!openPort(portNo))
    {
        return false;
    }

    /** 进入临界段 */
    EnterCriticalSection(&m_csCommunicationSync);

    /** 是否有错误发生 */
    BOOL bIsSuccess = TRUE;

    /** 在此可以设置输入输出的缓冲区大小,如果不设置,则系统会设置默认值.
    *  自己设置缓冲区大小时,要注意设置稍大一些,避免缓冲区溢出
    */
    /*if (bIsSuccess )
    {
    bIsSuccess = SetupComm(m_hComm,10,10);
    }*/

    /** 设置串口的超时时间,均设为0,表示不使用超时限制 */
    COMMTIMEOUTS  CommTimeouts;
    CommTimeouts.ReadIntervalTimeout = 0;
    CommTimeouts.ReadTotalTimeoutMultiplier = 0;
    CommTimeouts.ReadTotalTimeoutConstant = 0;
    CommTimeouts.WriteTotalTimeoutMultiplier = 0;
    CommTimeouts.WriteTotalTimeoutConstant = 0;
    if (bIsSuccess)
    {
        bIsSuccess = SetCommTimeouts(m_hComm, &CommTimeouts);
    }

    DCB  dcb;
    if (bIsSuccess)
    {
        // 将ANSI字符串转换为UNICODE字符串
        DWORD dwNum = MultiByteToWideChar(CP_ACP, 0, szDCBparam, -1, NULL, 0);
        wchar_t *pwText = new wchar_t[dwNum];
        if (!MultiByteToWideChar(CP_ACP, 0, szDCBparam, -1, pwText, dwNum))
        {
            bIsSuccess = TRUE;
        }

        /** 获取当前串口配置参数,并且构造串口DCB参数 */
        bIsSuccess = GetCommState(m_hComm, &dcb) && BuildCommDCB(pwText, &dcb);
        /** 开启RTS flow控制 */
        dcb.fRtsControl = RTS_CONTROL_ENABLE;

        /** 释放内存空间 */
        delete[] pwText;
    }

    if (bIsSuccess)
    {
        /** 使用DCB参数配置串口状态 */
        bIsSuccess = SetCommState(m_hComm, &dcb);
    }

    /**  清空串口缓冲区 */
    PurgeComm(m_hComm, PURGE_RXCLEAR | PURGE_TXCLEAR | PURGE_RXABORT | PURGE_TXABORT);

    /** 离开临界段 */
    LeaveCriticalSection(&m_csCommunicationSync);
    return bIsSuccess == TRUE;
}

bool CSerialPort::InitPort(UINT portNo, const LPDCB& plDCB)
{
    /** 打开指定串口,该函数内部已经有临界区保护,上面请不要加保护 */
    if (!openPort(portNo))
    {
        return false;
    }

    /** 进入临界段 */
    EnterCriticalSection(&m_csCommunicationSync);

    /** 配置串口参数 */
    if (!SetCommState(m_hComm, plDCB))
    {
        return false;
    }

    /**  清空串口缓冲区 */
    PurgeComm(m_hComm, PURGE_RXCLEAR | PURGE_TXCLEAR | PURGE_RXABORT | PURGE_TXABORT);

    /** 离开临界段 */
    LeaveCriticalSection(&m_csCommunicationSync);

    return true;
}

void CSerialPort::ClosePort()
{
    /** 如果有串口被打开，关闭它 */
    if (m_hComm != INVALID_HANDLE_VALUE)
    {
        CloseHandle(m_hComm);
        m_hComm = INVALID_HANDLE_VALUE;
    }
}

bool CSerialPort::openPort(UINT portNo)
{
    /** 进入临界段 */
    EnterCriticalSection(&m_csCommunicationSync);

    /** 把串口的编号转换为设备名 */
    char szPort[50];
    sprintf_s(szPort, "COM%d", portNo);

    /** 打开指定的串口 */
    m_hComm = CreateFileA(szPort,	  /** 设备名,COM1,COM2等 */
                          GENERIC_READ | GENERIC_WRITE, /** 访问模式,可同时读写 */
                          0,                            /** 共享模式,0表示不共享 */
                          NULL,                         /** 安全性设置,一般使用NULL */
                          OPEN_EXISTING,                /** 该参数表示设备必须存在,否则创建失败 */
                          0,
                          0);

    /** 如果打开失败，释放资源并返回 */
    if (m_hComm == INVALID_HANDLE_VALUE)
    {
        LeaveCriticalSection(&m_csCommunicationSync);
        return false;
    }

    /** 退出临界区 */
    LeaveCriticalSection(&m_csCommunicationSync);

    return true;
}

bool CSerialPort::OpenListenThread()
{
    /** 检测线程是否已经开启了 */
    if (m_hListenThread != INVALID_HANDLE_VALUE)
    {
        /** 线程已经开启 */
        return false;
    }

    s_bExit = false;
    /** 线程ID */
    UINT threadId;
    /** 开启串口数据监听线程 */
    m_hListenThread = (HANDLE)_beginthreadex(NULL, 0, ListenThread, this, 0, &threadId);
    if (!m_hListenThread)
    {
        return false;
    }
    /** 设置线程的优先级,高于普通线程 */
    if (!SetThreadPriority(m_hListenThread, THREAD_PRIORITY_ABOVE_NORMAL))
    {
        return false;
    }

    return true;
}

bool CSerialPort::CloseListenTread()
{
    if (m_hListenThread != INVALID_HANDLE_VALUE)
    {
        /** 通知线程退出 */
        s_bExit = true;

        /** 等待线程退出 */
        Sleep(10);

        /** 置线程句柄无效 */
        CloseHandle(m_hListenThread);
        m_hListenThread = INVALID_HANDLE_VALUE;
    }
    return true;
}

UINT CSerialPort::GetBytesInCOM()
{
    DWORD dwError = 0;  /** 错误码 */
    COMSTAT  comstat;   /** COMSTAT结构体,记录通信设备的状态信息 */
    memset(&comstat, 0, sizeof(COMSTAT));

    UINT BytesInQue = 0;
    /** 在调用ReadFile和WriteFile之前,通过本函数清除以前遗留的错误标志 */
    if (ClearCommError(m_hComm, &dwError, &comstat))
    {
        BytesInQue = comstat.cbInQue; /** 获取在输入缓冲区中的字节数 */
    }

    return BytesInQue;
}

UINT WINAPI CSerialPort::ListenThread(void* pParam)
{
    /** 得到本类的指针 */
    CSerialPort *pSerialPort = reinterpret_cast<CSerialPort*>(pParam);

    Uart1_Rx.Back = 11;
    Uart1_Rx.Front = 0;
    Uart1_Rx.Num = 0;
    // 线程循环,轮询方式读取串口数据
    while (1)
    {
        UINT BytesInQue = pSerialPort->GetBytesInCOM();
        /** 如果串口输入缓冲区中无数据,则休息一会再查询 */
        if (BytesInQue == 0)
        {
            Sleep(SLEEP_TIME_INTERVAL);
            continue;
        }
        /** 读取输入缓冲区中的数据并输出显示 */
        unsigned char cRecved = 0x00;
        do
        {
            cRecved = 0x00;
            if (pSerialPort->ReadChar(cRecved) == true)
            {
                pSerialPort->Bsp_Uart1RxQueueIn(cRecved);
                pSerialPort->Bsp_Uart1RxUnPackageHandle();
                continue;
            }
        } while (--BytesInQue);
    }

    return 0;
}

int readlen = 0;
void CSerialPort::Bsp_Uart1RxQueueIn(unsigned char temp)
{
    if(Uart1_Rx.Front<=Uart1_Rx.Back)
    {
        //printf("%x,",temp);
        //if(Uart1_Rx.Front==Uart1_Rx.Back) printf("
");
        Uart1_Rx.Data[Uart1_Rx.Front] = temp;
        Uart1_Rx.Front++;
        Uart1_Rx.Num++;
        Uart1_Rx.Front%=UARTRX_LEN;
    }
}

void CSerialPort::Bsp_Uart1RxUnPackageHandle(void)
{
    uint16_t frame_len = 9;
    unsigned char checksum = 0;

    if (Uart1_Rx.Num == UARTRX_LEN)
    {
        Uart1_Rx.Num = 0;
        checksum = Uart1_Rx.Data[2]^Uart1_Rx.Data[3]^Uart1_Rx.Data[4]^Uart1_Rx.Data[5]^ 
                Uart1_Rx.Data[6]^Uart1_Rx.Data[7]^Uart1_Rx.Data[8]^Uart1_Rx.Data[9]^Uart1_Rx.Data[10];
        if(checksum == Uart1_Rx.Data[11])
        {
            memcpy(Rx1PLoad_buf,Uart1_Rx.Data,UARTRX_LEN);
            MCU_CommRx_Event(frame_len, Rx1PLoad_buf + FRAME_HEAD_LEN);
        }
    }

}

void CSerialPort::MCU_CommRx_Event(unsigned char loadlen, unsigned char *pbuf)
{
    unsigned char  frmNUM, frmACK, frmCMD, frmSMD;
    unsigned char  datlen;
    unsigned char *pdata;
    MessageStruct msg;


    frmNUM = pbuf[0];
    frmACK = pbuf[1];
    frmCMD = pbuf[2];
    frmSMD = pbuf[3];
    pdata = pbuf + 4;

    datlen = loadlen - 5;
    //printf("CMD = %0x,SMD=%0x
", frmCMD, frmSMD);

    msg.nMsg = Key_Module;


    time_t delayTimeEnd = 0;

    delayTimeEnd = time(NULL);


    if(delayTimeEnd - delayTimeBegin >=1)
    {
        delayTimeBegin = delayTimeEnd;
        msg.nUserMsg.nVal = Key_Heart;
        MsgQueue::getInstance().addMsg(msg);
        printf("heart
");
    }


    if (frmCMD == 0x07)
    {
        //byte 1
        if(IS_ONE(pdata[0],0) != IS_ONE(Rx1pLoad_buf_temp[FRAME_HEAD_LEN+datlen],0))
        {
            Rx1pLoad_buf_temp[FRAME_HEAD_LEN+4] = pdata[0];
            if(IS_ONE(pdata[0],0)) return;
            printf("home
");
            msg.nUserMsg.nVal = Key_Home;
            MsgQueue::getInstance().addMsg(msg);
        }

        if(IS_ONE(pdata[0],1) != IS_ONE(Rx1pLoad_buf_temp[FRAME_HEAD_LEN+datlen],1))
        {
            Rx1pLoad_buf_temp[FRAME_HEAD_LEN+4] = pdata[0];
            if(IS_ONE(pdata[0],1)) return;
            printf("mode
");
            msg.nUserMsg.nVal = Key_Mode;
            MsgQueue::getInstance().addMsg(msg);
        }

        if(IS_ONE(pdata[0],2) != IS_ONE(Rx1pLoad_buf_temp[FRAME_HEAD_LEN+datlen],2))
        {
            Rx1pLoad_buf_temp[FRAME_HEAD_LEN+4] = pdata[0];
            if(IS_ONE(pdata[0],2)) return;
            printf("Setting
");
            msg.nUserMsg.nVal = Key_Setting;
            MsgQueue::getInstance().addMsg(msg);
        }

        if(IS_ONE(pdata[0],3) != IS_ONE(Rx1pLoad_buf_temp[FRAME_HEAD_LEN+datlen],3))
        {
            Rx1pLoad_buf_temp[FRAME_HEAD_LEN+4] = pdata[0];
            if(IS_ONE(pdata[0],3)) return;
            printf("back
");
            msg.nUserMsg.nVal = Key_Back;
            MsgQueue::getInstance().addMsg(msg);
        }

        if(IS_ONE(pdata[0],5) != IS_ONE(Rx1pLoad_buf_temp[FRAME_HEAD_LEN+datlen],5))
        {
            Rx1pLoad_buf_temp[FRAME_HEAD_LEN+4] = pdata[0];
            if(IS_ONE(pdata[0],5)) return;
            printf("navi
");
            msg.nUserMsg.nVal = Key_Navi;
            MsgQueue::getInstance().addMsg(msg);
        }


        //byte 2
        if(IS_ONE(pdata[1],0) != IS_ONE(Rx1pLoad_buf_temp[FRAME_HEAD_LEN+datlen+1],0))
        {
            Rx1pLoad_buf_temp[FRAME_HEAD_LEN+datlen+1] = pdata[1];
            if(IS_ONE(pdata[1],0)) return;
            printf("diy
");
            msg.nUserMsg.nVal = Key_DIY;
            MsgQueue::getInstance().addMsg(msg);
        }

        char direvalTemp = (pdata[1]&0x38)>>3;
        if(direvalTemp != ((Rx1pLoad_buf_temp[FRAME_HEAD_LEN+datlen+1]&0x38)>>3))
        {
            Rx1pLoad_buf_temp[FRAME_HEAD_LEN+datlen+1] = pdata[1];
            switch (direvalTemp) {
            case 0x01:
                DiretionVal = Key_Dire_Press;
                break;
            case 0x02:
                DiretionVal = Key_Dire_Up;
                break;
            case 0x03:
                DiretionVal = Key_Dire_Down;
                break;
            case 0x04:
                DiretionVal = Key_Dire_Left;
                break;
            case 0x05:
                DiretionVal = Key_Dire_Right;
                break;
            case 0x00:
                msg.nUserMsg.nVal = DiretionVal;
                MsgQueue::getInstance().addMsg(msg);
                printf("%d
",DiretionVal);
                break;
            }
        }

        //byte 3
        direvalTemp = pdata[2]&0x1f;
        if(direvalTemp != (Rx1pLoad_buf_temp[FRAME_HEAD_LEN+datlen+2]&0x1f))
        {
            Rx1pLoad_buf_temp[FRAME_HEAD_LEN+datlen+2] = pdata[2];

            if(direvalTemp > 0x08)
            {
                msg.nUserMsg.nVal = Key_Dire_Clockwise;
                msg.nUserMsg.nVal_1 = (int)direvalTemp - 0x08;
                MsgQueue::getInstance().addMsg(msg);
                //printf("%d,%d
",msg.nUserMsg.nVal,msg.nUserMsg.nVal_1);
            }
            else if(direvalTemp < 0x08)
            {
                msg.nUserMsg.nVal = Key_Dire_Reverse;
                msg.nUserMsg.nVal_1 = 0x08 - (int)direvalTemp;
                MsgQueue::getInstance().addMsg(msg);
                //printf("%d,%d
",msg.nUserMsg.nVal,msg.nUserMsg.nVal_1);
            }
        }
    }
}

bool CSerialPort::ReadChar(unsigned char &cRecved)
{
    BOOL  bResult = TRUE;
    DWORD BytesRead = 0;
    if (m_hComm == INVALID_HANDLE_VALUE)
    {
        return false;
    }
    /** 临界区保护 */
    EnterCriticalSection(&m_csCommunicationSync);

    /** 从缓冲区读数据 */
    bResult = ReadFile(m_hComm, &cRecved, 1, &BytesRead, NULL);
    if ((!bResult))
    {
        /** 获取错误码,可以根据该错误码查出错误原因 */
        DWORD dwError = GetLastError();
        /** 清空串口缓冲区 */
        PurgeComm(m_hComm, PURGE_RXCLEAR | PURGE_RXABORT);
        LeaveCriticalSection(&m_csCommunicationSync);

        return false;
    }
    /** 离开临界区 */
    LeaveCriticalSection(&m_csCommunicationSync);
    return (BytesRead == 1);
}

bool CSerialPort::WriteData(unsigned char* pData, unsigned int length)
{
    BOOL   bResult = TRUE;
    DWORD  BytesToSend = 0;
    if (m_hComm == INVALID_HANDLE_VALUE)
    {
        return false;
    }

    /** 临界区保护 */
    EnterCriticalSection(&m_csCommunicationSync);

    /** 向缓冲区写入指定量的数据 */
    bResult = WriteFile(m_hComm, pData, length, &BytesToSend, NULL);
    if (!bResult)
    {
        DWORD dwError = GetLastError();
        /** 清空串口缓冲区 */
        PurgeComm(m_hComm, PURGE_RXCLEAR | PURGE_RXABORT);
        LeaveCriticalSection(&m_csCommunicationSync);

        return false;
    }
    /** 离开临界区 */
    LeaveCriticalSection(&m_csCommunicationSync);

    return true;
}

//MsgQueue.h

#pragma once
#include <queue>
#include <mutex>
#include "Common.h"
class MsgQueue
{
public:
    ~MsgQueue();

public:
    static MsgQueue &getInstance();

    void addMsg(MessageStruct &it);
    bool getFrontMsg(MessageStruct &it);
    int getSize();

private:
    MsgQueue();
    std::queue<MessageStruct> m_queueMsg;
    std::mutex m_mut;
};

//MsgQueue.cpp

#include "MsgQueue.h"


MsgQueue::MsgQueue()
{
}


MsgQueue::~MsgQueue()
{
}

MsgQueue &MsgQueue::getInstance()
{
	static MsgQueue _queue;
	return _queue;
}

void MsgQueue::addMsg(MessageStruct &it)
{
    m_mut.lock();
	m_queueMsg.emplace(it);
    m_mut.unlock();
}
	

bool MsgQueue::getFrontMsg(MessageStruct &it)
{
    m_mut.lock();
    if (m_queueMsg.empty())
    {
        m_mut.unlock();
        return false;
    }
	it = m_queueMsg.front();
	m_queueMsg.pop();
    m_mut.unlock();
	return true;
}

int MsgQueue::getSize()
{
	return m_queueMsg.size();
}

//main.cpp

#include <iostream>
#include <SerialPort.h>

using namespace std;

int main()
{
    if(CSerialPort::getInstance()->InitPort(3))
    {
        if (CSerialPort::getInstance()->OpenListenThread())
        {
            printf("OpenListenThread success !
");
        }
        else
        {
            printf("OpenListenThread fail !
");
        }
    }
    else
    {
        printf("initPort fail !
");
    }

    MessageStruct msg;
    while(1)
    {
        printf("%d
",MsgQueue::getInstance().getSize());
        MsgQueue::getInstance().getFrontMsg(msg);
        if(msg.nMsg == Key_Module)
        {
            printf("key module success
");
        }
        Sleep(500);
    }

    return 0;
}

hmoban主题是根据ripro二开的主题，极致后台体验，无插件，集成会员系统
自学咖网 » 串口消息读取并解析

wen 普通

分享到：

wen 普通

相关推荐