628 lines
17 KiB
C++
628 lines
17 KiB
C++
#include "udpComm.h"
|
|
#include <iostream>
|
|
#include <memory>
|
|
|
|
udpComm::udpComm()
|
|
{
|
|
udpScoket = nullptr;
|
|
ccuHost = "";
|
|
ccuPort = 0;
|
|
}
|
|
|
|
udpComm::~udpComm() {
|
|
if (udpScoket) {
|
|
delete udpScoket;
|
|
udpScoket = nullptr;
|
|
}
|
|
}
|
|
|
|
|
|
Checksum udpComm::calculateChecksum(const unsigned char* data, int size)
|
|
{
|
|
Checksum checksum = 0;
|
|
int size_data = size - sizeof(Checksum);
|
|
for (int i = 0; i < size_data; i++) {
|
|
checksum += data[i];
|
|
}
|
|
return checksum;
|
|
}
|
|
Checksum udpComm::calculateChecksum(const unsigned char* data, int dataSize, int checkSize)
|
|
{
|
|
Checksum checksum = 0;
|
|
int size_data = dataSize - checkSize;
|
|
for (int i = 0; i < size_data; i++) {
|
|
checksum += data[i];
|
|
}
|
|
return checksum;
|
|
}
|
|
bool udpComm::getMsgId(char *m,unsigned short &id)
|
|
{
|
|
m_header h;
|
|
h = *reinterpret_cast<m_header *>(m);
|
|
// 判断消息是否有效
|
|
if (h.start1== DIS_MSG_HEAD1 && h.start2==DIS_MSG_HEAD2)
|
|
{
|
|
id = h.id;
|
|
return true;
|
|
}
|
|
else if (h.start1==CCU_UDPMSG_START1 && h.start2==CCU_UDPMSG_START2)
|
|
{
|
|
id = h.id;
|
|
return true;
|
|
}
|
|
else
|
|
// sError.push_back("Msg Header errar");
|
|
// LOG_F(ERROR, "Msg Header errar start1: %d, start2: %d", h.start1, h.start2);
|
|
return false;
|
|
}
|
|
bool udpComm::getMsgFromBuff(char *m, msg_CcuStateFbMsg &s) {
|
|
Checksum sum;
|
|
msg_CcuStateFbMsg *p;
|
|
p = reinterpret_cast<msg_CcuStateFbMsg *>(m);
|
|
sum = calculateChecksum((unsigned char*)m, sizeof(msg_CcuStateFbMsg));
|
|
|
|
if (sum != p->checkCode) {
|
|
sError.push_back("CcuStat Msg Check error");
|
|
return false;
|
|
}
|
|
s = *p;
|
|
return true;
|
|
}
|
|
|
|
bool udpComm::getMsgFromBuff(char *m, msg_CcuSetParmFbMsg &s)
|
|
{
|
|
Checksum sum;
|
|
msg_CcuSetParmFbMsg *p;
|
|
p = reinterpret_cast<msg_CcuSetParmFbMsg *>(m);
|
|
sum = calculateChecksum((unsigned char*)m, sizeof(msg_CcuSetParmFbMsg));
|
|
|
|
if (sum!= p->checkCode) {
|
|
sError.push_back("CcuSetParm Msg Check error");
|
|
return false;
|
|
}
|
|
|
|
s = *p;
|
|
return true;
|
|
}
|
|
|
|
bool udpComm::getMsgFromBuff(char *m, msg_disHighVolBusFbMsg &s)
|
|
{
|
|
cChecksum sum;
|
|
msg_disHighVolBusFbMsg *p;
|
|
p = reinterpret_cast<msg_disHighVolBusFbMsg *>(m);
|
|
sum = calculateChecksum((unsigned char*)m, sizeof(msg_disHighVolBusFbMsg), sizeof(cChecksum)) & 0xFF;
|
|
if (sum != p->checkCode) {
|
|
sError.push_back("DisSys HVBus Msg Check error");
|
|
LOG_F(ERROR, "DisSys HVBus Msg Check error sum: %d, source checkCode: %d", sum, p->checkCode);
|
|
return false;
|
|
}
|
|
s = *p;
|
|
// cout << s.data.busbarAVoltage << endl;
|
|
return true;
|
|
}
|
|
|
|
bool udpComm::getMsgFromBuff(char *m, msg_disHighAVolBusFbMsg &s)
|
|
{
|
|
cChecksum sum;
|
|
msg_disHighAVolBusFbMsg *p;
|
|
p = reinterpret_cast<msg_disHighAVolBusFbMsg *>(m);
|
|
sum = calculateChecksum((unsigned char*)m, sizeof(msg_disHighAVolBusFbMsg), sizeof(cChecksum)) & 0xFF;
|
|
if (sum!= p->checkCode) {
|
|
sError.push_back("DisSys HVABus Msg Check error");
|
|
LOG_F(ERROR, "DisSys HVABus Msg Check error sum: %d, source checkCode: %d", sum, p->checkCode);
|
|
return false;
|
|
}
|
|
s = *p;
|
|
return true;
|
|
}
|
|
bool udpComm::getMsgFromBuff(char *m, msg_disLowMainBusFbMsg &s)
|
|
{
|
|
cChecksum sum;
|
|
msg_disLowMainBusFbMsg *p;
|
|
p = reinterpret_cast<msg_disLowMainBusFbMsg *>(m);
|
|
sum = calculateChecksum((unsigned char*)m, sizeof(msg_disLowMainBusFbMsg), sizeof(cChecksum)) & 0xFF;
|
|
if (sum!= p->checkCode) {
|
|
sError.push_back("DisSys HVBBus Msg Check error");
|
|
LOG_F(ERROR, "DisSys HVBBus Msg Check error sum: %d, source checkCode: %d", sum, p->checkCode);
|
|
return false;
|
|
}
|
|
s = *p;
|
|
return true;
|
|
}
|
|
|
|
bool udpComm::getMsgFromBuff(char *m, msg_disLowBusFbMsg &s)
|
|
{
|
|
cChecksum sum;
|
|
msg_disLowBusFbMsg *p;
|
|
p = reinterpret_cast<msg_disLowBusFbMsg *>(m);
|
|
sum = calculateChecksum((unsigned char*)m, sizeof(msg_disLowBusFbMsg), sizeof(cChecksum)) & 0xFF;
|
|
if (sum!= p->checkCode) {
|
|
sError.push_back("DisSys LVBus Msg Check error");
|
|
LOG_F(ERROR, "DisSys LVBus Msg Check error sum: %d, source checkCode: %d", sum, p->checkCode);
|
|
return false;
|
|
}
|
|
s = *p;
|
|
return true;
|
|
}
|
|
|
|
bool udpComm::pushMsgToQueue(unsigned char *m)
|
|
{
|
|
if(m==NULL)
|
|
{
|
|
// sError.push_back("pushMsgToQueue faile,Msg is NULL");
|
|
LOG_F(ERROR, "pushMsgToQueue faile,Msg is NULL m: %p", m);
|
|
return false;
|
|
}
|
|
|
|
unsigned char* Buff = m;
|
|
//消息头鉴定
|
|
char *header = new char[sizeof(m_header)];
|
|
unsigned short id;
|
|
memcpy(header,Buff,sizeof(m_header));
|
|
if(!getMsgId(header,id))
|
|
{
|
|
// sError.push_back("pushMsgToQueue faile,Msg ID error");
|
|
// LOG_F(INFO, "pushMsgToQueue faile,Msg ID error header: %p", header);
|
|
delete []header;
|
|
return false;
|
|
}
|
|
delete []header;
|
|
//输入消息
|
|
switch (id)
|
|
{
|
|
case CCU_STATE_FB_ID: //CCU_STATE_FB 0x0051
|
|
{
|
|
msg_CcuStateFbMsg s;
|
|
if(getMsgFromBuff((char *)Buff,s))
|
|
{
|
|
if(m_qReceiveCcuStateBuffer.size()<QUENUE_SIZE)
|
|
{
|
|
double time = MOOSTime();
|
|
m_qReceiveCcuStateBuffer.push(std::make_pair(time, s));
|
|
}
|
|
else
|
|
{
|
|
// sError.push_back("pushMsgToQueue faile,CcuState buffer is full");
|
|
LOG_F(INFO, "pushMsgToQueue faile,CcuState buffer is full");
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
break;
|
|
}
|
|
case CCU_SET_PARM_FB_ID: //CCU_SET_PARM_FB 0x0040
|
|
{
|
|
msg_CcuSetParmFbMsg s;
|
|
if(getMsgFromBuff((char *)Buff,s))
|
|
{
|
|
if(m_qReceiveCcuSetParmBuffer.size()<QUENUE_SIZE)
|
|
{
|
|
double time = MOOSTime();
|
|
m_qReceiveCcuSetParmBuffer.push(std::make_pair(time, s));
|
|
}
|
|
else
|
|
{
|
|
// sError.push_back("pushMsgToQueue faile,CcuSetParm buffer is full");
|
|
LOG_F(INFO, "pushMsgToQueue faile,CcuSetParm buffer is full");
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
break;
|
|
}
|
|
case DIS_HVBUS_FB_ID: //DIS_HVBUS_FB 0x0020
|
|
{
|
|
msg_disHighVolBusFbMsg s;
|
|
if(getMsgFromBuff((char *)Buff,s))
|
|
{
|
|
if(m_qReceiveDisHighVolBusBuffer.size()<QUENUE_SIZE)
|
|
{
|
|
double time = MOOSTime();
|
|
m_qReceiveDisHighVolBusBuffer.push(std::make_pair(time, s));
|
|
}
|
|
else
|
|
{
|
|
// sError.push_back("pushMsgToQueue faile,DisSysHVBus buffer is full");
|
|
LOG_F(INFO, "pushMsgToQueue faile,DisSysHVBus buffer is full");
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
break;
|
|
}
|
|
case DIS_HVBUSA_FB_ID: //DIS_HVBUSA_FB 0x0006
|
|
{
|
|
msg_disHighAVolBusFbMsg s;
|
|
if(getMsgFromBuff((char *)Buff,s))
|
|
{
|
|
if(m_qReceiveDisHighAVolBusBuffer.size()<QUENUE_SIZE)
|
|
{
|
|
double time = MOOSTime();
|
|
m_qReceiveDisHighAVolBusBuffer.push(std::make_pair(time, s));
|
|
}
|
|
else
|
|
{
|
|
// sError.push_back("pushMsgToQueue faile,DisSysHVABus buffer is full");
|
|
LOG_F(INFO, "pushMsgToQueue faile,DisSysHVABus buffer is full");
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
break;
|
|
}
|
|
case DIS_HVBUSB_FB_ID: //DIS_HVBUSB_FB 0x0007
|
|
{
|
|
msg_disLowMainBusFbMsg s;
|
|
if(getMsgFromBuff((char *)Buff,s))
|
|
{
|
|
if(m_qReceiveDisHighBVolBusBuffer.size()<QUENUE_SIZE)
|
|
{
|
|
double time = MOOSTime();
|
|
m_qReceiveDisHighBVolBusBuffer.push(std::make_pair(time, s));
|
|
}
|
|
else
|
|
{
|
|
// sError.push_back("pushMsgToQueue faile,DisSysHVBBus buffer is full");
|
|
LOG_F(INFO, "pushMsgToQueue faile,DisSysHVBBus buffer is full");
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
break;
|
|
}
|
|
case DIS_LVBUS_FB_ID: //DIS_LVBUS_FB 0x0008
|
|
{
|
|
msg_disLowBusFbMsg s;
|
|
if(getMsgFromBuff((char *)Buff,s))
|
|
{
|
|
if(m_qReceiveDisLowBusBuffer.size()<QUENUE_SIZE)
|
|
{
|
|
double time = MOOSTime();
|
|
m_qReceiveDisLowBusBuffer.push(std::make_pair(time, s));
|
|
}
|
|
else
|
|
{
|
|
// sError.push_back("pushMsgToQueue faile,DisSysLVBus buffer is full");
|
|
LOG_F(INFO, "pushMsgToQueue faile,DisSysLVBus buffer is full");
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
bool udpComm::clearMsgQueue()
|
|
{
|
|
{
|
|
std::lock_guard<std::mutex> lock(m_mutexCcuState);
|
|
while(!m_qReceiveCcuStateBuffer.empty())
|
|
m_qReceiveCcuStateBuffer.pop();
|
|
}
|
|
|
|
{
|
|
std::lock_guard<std::mutex> lock(m_mutexCcuSetParm);
|
|
while(!m_qReceiveCcuSetParmBuffer.empty())
|
|
m_qReceiveCcuSetParmBuffer.pop();
|
|
}
|
|
|
|
{
|
|
std::lock_guard<std::mutex> lock(m_mutexDisHighVolBus);
|
|
while(!m_qReceiveDisHighVolBusBuffer.empty())
|
|
m_qReceiveDisHighVolBusBuffer.pop();
|
|
}
|
|
|
|
{
|
|
std::lock_guard<std::mutex> lock(m_mutexDisHighAVolBus);
|
|
while(!m_qReceiveDisHighAVolBusBuffer.empty())
|
|
m_qReceiveDisHighAVolBusBuffer.pop();
|
|
}
|
|
|
|
{
|
|
std::lock_guard<std::mutex> lock(m_mutexDisHighBVolBus);
|
|
while(!m_qReceiveDisHighBVolBusBuffer.empty())
|
|
m_qReceiveDisHighBVolBusBuffer.pop();
|
|
}
|
|
|
|
{
|
|
std::lock_guard<std::mutex> lock(m_mutexDisLowBus);
|
|
while(!m_qReceiveDisLowBusBuffer.empty())
|
|
m_qReceiveDisLowBusBuffer.pop();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
bool udpComm::popMsgFormQueue(double &time,msg_CcuStateFbMsg &m)
|
|
{
|
|
std::lock_guard<std::mutex> lock(m_mutexCcuState);
|
|
if(m_qReceiveCcuStateBuffer.empty())
|
|
return false;
|
|
time = m_qReceiveCcuStateBuffer.front().first;
|
|
m = m_qReceiveCcuStateBuffer.front().second;
|
|
m_qReceiveCcuStateBuffer.pop();
|
|
return true;
|
|
}
|
|
|
|
bool udpComm::popMsgFormQueue(double &time,msg_CcuSetParmFbMsg &m)
|
|
{
|
|
std::lock_guard<std::mutex> lock(m_mutexCcuSetParm);
|
|
if(m_qReceiveCcuSetParmBuffer.empty())
|
|
return false;
|
|
time = m_qReceiveCcuSetParmBuffer.front().first;
|
|
m = m_qReceiveCcuSetParmBuffer.front().second;
|
|
m_qReceiveCcuSetParmBuffer.pop();
|
|
return true;
|
|
}
|
|
|
|
bool udpComm::popMsgFormQueue(double &time,msg_disHighVolBusFbMsg &m)
|
|
{
|
|
std::lock_guard<std::mutex> lock(m_mutexDisHighVolBus);
|
|
if(m_qReceiveDisHighVolBusBuffer.empty())
|
|
return false;
|
|
time = m_qReceiveDisHighVolBusBuffer.front().first;
|
|
m = m_qReceiveDisHighVolBusBuffer.front().second;
|
|
m_qReceiveDisHighVolBusBuffer.pop();
|
|
return true;
|
|
}
|
|
|
|
bool udpComm::popMsgFormQueue(double &time,msg_disHighAVolBusFbMsg &m)
|
|
{
|
|
std::lock_guard<std::mutex> lock(m_mutexDisHighAVolBus);
|
|
if(m_qReceiveDisHighAVolBusBuffer.empty())
|
|
return false;
|
|
time = m_qReceiveDisHighAVolBusBuffer.front().first;
|
|
m = m_qReceiveDisHighAVolBusBuffer.front().second;
|
|
m_qReceiveDisHighAVolBusBuffer.pop();
|
|
return true;
|
|
}
|
|
|
|
bool udpComm::popMsgFormQueue(double &time,msg_disLowMainBusFbMsg &m)
|
|
{
|
|
std::lock_guard<std::mutex> lock(m_mutexDisHighBVolBus);
|
|
if(m_qReceiveDisHighBVolBusBuffer.empty())
|
|
return false;
|
|
time = m_qReceiveDisHighBVolBusBuffer.front().first;
|
|
m = m_qReceiveDisHighBVolBusBuffer.front().second;
|
|
m_qReceiveDisHighBVolBusBuffer.pop();
|
|
return true;
|
|
}
|
|
|
|
bool udpComm::popMsgFormQueue(double &time,msg_disLowBusFbMsg &m)
|
|
{
|
|
std::lock_guard<std::mutex> lock(m_mutexDisLowBus);
|
|
if(m_qReceiveDisLowBusBuffer.empty())
|
|
return false;
|
|
time = m_qReceiveDisLowBusBuffer.front().first;
|
|
m = m_qReceiveDisLowBusBuffer.front().second;
|
|
m_qReceiveDisLowBusBuffer.pop();
|
|
return true;
|
|
}
|
|
|
|
|
|
bool udpComm::sendDisSysCmd(const disHighVolBusCmd cmd)
|
|
{
|
|
unsigned char* msgBuf;
|
|
cChecksum cc;
|
|
msg_disHVBCmd* msg = new msg_disHVBCmd;
|
|
msg->header.id = DIS_HVBUS_CMD_ID;
|
|
msg->header.start1 = DIS_MSG_HEAD1;
|
|
msg->header.start2 = DIS_MSG_HEAD2;
|
|
//TODO : 阈字节长度固定了，后续会修改
|
|
msg->header.length = 18;
|
|
// msg->header.length = sizeof(disHighVolBusCmd);
|
|
msg->data = cmd;
|
|
msgBuf = reinterpret_cast<unsigned char *>(msg);
|
|
cc = calculateChecksum(msgBuf,sizeof(msg_disHVBCmd),sizeof(cChecksum));
|
|
msg->checkCode = cc;
|
|
try
|
|
{
|
|
sendMsg(msgBuf,sizeof(msg_disHVBCmd));
|
|
}
|
|
catch(const std::exception& e)
|
|
{
|
|
std::cerr << e.what() << '\n';
|
|
}
|
|
delete msg;
|
|
return true;
|
|
}
|
|
|
|
bool udpComm::sendDisSysCmd(const disHighAVolBusCmd cmd)
|
|
{
|
|
unsigned char* msgBuf;
|
|
cChecksum cc;
|
|
msg_disHVBACmd* msg = new msg_disHVBACmd;
|
|
msg->header.id = DIS_HVBUSA_CMD_ID;
|
|
msg->header.start1 = DIS_MSG_HEAD1;
|
|
msg->header.start2 = DIS_MSG_HEAD2;
|
|
//TODO : 阈字节长度固定了，后续会修改
|
|
msg->header.length = 6;
|
|
// msg->header.length = sizeof(disHighAVolBusCmd);
|
|
msg->data = cmd;
|
|
msgBuf = reinterpret_cast<unsigned char *>(msg);
|
|
cc = calculateChecksum(msgBuf,sizeof(msg_disHVBACmd),sizeof(cChecksum));
|
|
msg->checkCode = cc;
|
|
try
|
|
{
|
|
sendMsg(msgBuf,sizeof(msg_disHVBACmd));
|
|
}
|
|
catch(const std::exception& e)
|
|
{
|
|
std::cerr << e.what() << '\n';
|
|
}
|
|
delete msg;
|
|
return true;
|
|
}
|
|
|
|
bool udpComm::sendDisSysCmd(const disHighBVolBusCmd cmd)
|
|
{
|
|
unsigned char* msgBuf;
|
|
cChecksum cc;
|
|
msg_disHVBBCmd* msg = new msg_disHVBBCmd;
|
|
msg->header.id = DIS_HVBUSB_CMD_ID;
|
|
msg->header.start1 = DIS_MSG_HEAD1;
|
|
msg->header.start2 = DIS_MSG_HEAD2;
|
|
//TODO : 阈字节长度固定了，后续会修改
|
|
msg->header.length = 8;
|
|
// msg->header.length = sizeof(disHighBVolBusCmd);
|
|
msg->data = cmd;
|
|
msgBuf = reinterpret_cast<unsigned char *>(msg);
|
|
cc = calculateChecksum(msgBuf,sizeof(msg_disHVBBCmd),sizeof(cChecksum));
|
|
msg->checkCode = cc;
|
|
try
|
|
{
|
|
// cout << "=========" <<(int)sizeof(msg_disHVBBCmd) << endl;
|
|
sendMsg(msgBuf,sizeof(msg_disHVBBCmd));
|
|
}
|
|
catch(const std::exception& e)
|
|
{
|
|
std::cerr << e.what() << '\n';
|
|
}
|
|
delete msg;
|
|
return true;
|
|
}
|
|
|
|
bool udpComm::sendDisSysCmd(const disLowBusCmd cmd)
|
|
{
|
|
unsigned char* msgBuf;
|
|
cChecksum cc;
|
|
msg_disLVBCmd* msg = new msg_disLVBCmd;
|
|
msg->header.id = DIS_LVBUS_CMD_ID;
|
|
msg->header.start1 = DIS_MSG_HEAD1;
|
|
msg->header.start2 = DIS_MSG_HEAD2;
|
|
//TODO : 阈字节长度固定了，后续会修改
|
|
msg->header.length = 8;
|
|
// msg->header.length = sizeof(disLowBusCmd);
|
|
msg->data = cmd;
|
|
msgBuf = reinterpret_cast<unsigned char *>(msg);
|
|
cc = calculateChecksum(msgBuf,sizeof(msg_disLVBCmd),sizeof(cChecksum));
|
|
// msg->checkCode = static_cast<cChecksum>(cc & 0xFF);
|
|
msg->checkCode = cc;
|
|
cout << "cc======disLowBusCmd=============================" << (int) msg->checkCode << endl;
|
|
try
|
|
{
|
|
sendMsg(msgBuf,sizeof(msg_disLVBCmd));
|
|
}
|
|
catch(const std::exception& e)
|
|
{
|
|
std::cerr << e.what() << '\n';
|
|
}
|
|
delete msg;
|
|
return true;
|
|
}
|
|
|
|
bool udpComm::sendCcuColCmd(const ccuColCmd cmd)
|
|
{
|
|
unsigned char* msgBuf;
|
|
Checksum cc;
|
|
msg_CcuColCmdMsg* msg = new msg_CcuColCmdMsg();
|
|
memset(msg, 0, sizeof(msg_CcuColCmdMsg)); // 初始化所有字段为0
|
|
|
|
msg->header.id = CCU_CMD_ID;
|
|
msg->header.start1 = CCU_UDPMSG_START1;
|
|
msg->header.start2 = CCU_UDPMSG_START2;
|
|
msg->header.length = sizeof(ccuColCmd);
|
|
|
|
// 确保日期获取成功
|
|
if(!getDate(msg->date.year,msg->date.month,msg->date.day,
|
|
msg->date.hour,msg->date.minute,msg->date.second,msg->date.milliseconds)) {
|
|
LOG_F(ERROR, "Failed to get current date/time");
|
|
delete msg;
|
|
return false;
|
|
}
|
|
|
|
msg->cmd = cmd;
|
|
msgBuf = reinterpret_cast<unsigned char *>(msg);
|
|
cc = calculateChecksum(msgBuf,sizeof(msg_CcuColCmdMsg));
|
|
msg->checkCode = static_cast<cChecksum>(cc & 0xFF);
|
|
|
|
bool sendResult = false;
|
|
try {
|
|
sendResult = sendMsg(msgBuf,sizeof(msg_CcuColCmdMsg));
|
|
if (!sendResult) {
|
|
LOG_F(ERROR, "Failed to send CCU command");
|
|
}
|
|
} catch (const std::exception& e) {
|
|
LOG_F(ERROR, "Exception in sendCcuColCmd: %s", e.what());
|
|
}
|
|
|
|
delete msg;
|
|
return sendResult;
|
|
}
|
|
bool udpComm::sendCcuSetParmCmd(const ccuSetParmCmd cmd)
|
|
{
|
|
unsigned char* msgBuf;
|
|
Checksum cc;
|
|
msg_CcuSetParmMsg* msg = new msg_CcuSetParmMsg;
|
|
msg->header.id = CCU_SET_PARM_ID;
|
|
msg->header.start1 = CCU_UDPMSG_START1;
|
|
msg->header.start2 = CCU_UDPMSG_START2;
|
|
msg->header.length = sizeof(ccuSetParmCmd);
|
|
msg->cmd = cmd;
|
|
msgBuf = reinterpret_cast<unsigned char *>(msg);
|
|
cc = calculateChecksum(msgBuf,sizeof(msg_CcuSetParmMsg));
|
|
msg->checkCode = static_cast<cChecksum>(cc & 0xFF);
|
|
try
|
|
{
|
|
sendMsg(msgBuf,sizeof(msg_CcuSetParmMsg));
|
|
}
|
|
catch(const std::exception& e)
|
|
{
|
|
std::cerr << e.what() << '\n';
|
|
}
|
|
delete msg;
|
|
return true;
|
|
}
|
|
|
|
bool udpComm::getDate(unsigned short &year, unsigned char &month, unsigned char &day, unsigned char &hour, unsigned char &minute, unsigned char &second, unsigned char &milliseconds) {
|
|
// 获取当前时间
|
|
std::time_t now = std::time(nullptr);
|
|
if (now == -1) {
|
|
return false; // 获取时间失败
|
|
}
|
|
|
|
// 转换为本地时间
|
|
std::tm *localTime = std::localtime(&now);
|
|
if (!localTime) {
|
|
return false; // 转换失败
|
|
}
|
|
|
|
// 获取年、月、日、时、分、秒
|
|
year = localTime->tm_year + 1900; // tm_year 是从 1900 年开始的
|
|
month = localTime->tm_mon + 1; // tm_mon 是从 0 开始的，0 对应 1 月
|
|
day = localTime->tm_mday;
|
|
hour = localTime->tm_hour;
|
|
minute = localTime->tm_min;
|
|
second = localTime->tm_sec;
|
|
|
|
// 获取毫秒，使用 std::chrono
|
|
auto now_ms = std::chrono::system_clock::now();
|
|
auto duration = now_ms.time_since_epoch();
|
|
auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(duration).count() % 1000; // 取毫秒部分
|
|
ms = ms/10;
|
|
milliseconds = static_cast<unsigned char>(ms);
|
|
|
|
return true;
|
|
}
|