Germany/hunting
7
0
Fork 0
Code Issues Pull Requests Actions Packages Projects 1 Releases Wiki Activity

Improve:mcu manager recv function.

Browse Source
This commit is contained in:
Fancy code 2024-05-15 16:12:34 +08:00
parent 073087411b
commit 049521bad1
10 changed files with 234 additions and 102 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

69
middleware/McuManager/include/IMcuManager.h
View File

@ -42,41 +42,33 @@ enum class ControlLight
};
typedef struct mcu_ask_date_time
{
mcu_ask_date_time(const unsigned short year, const unsigned char mon, const unsigned char day,
const unsigned char hour, const unsigned char min, const unsigned char second);
const unsigned short mYear;
const unsigned char mMon;
const unsigned char mDay;
const unsigned char mHour;
const unsigned char mMin;
const unsigned char mSecond;
mcu_ask_date_time(const unsigned short year, const unsigned char mon, const unsigned char day,
const unsigned char hour, const unsigned char min, const unsigned char second)
: mYear(year), mMon(mon), mDay(day), mHour(hour), mMin(min), mSecond(second)
{
}
} McuAskDateTime;
typedef struct mcu_get_interval_start
{
mcu_get_interval_start();
unsigned int mIntervalStart;
} McuGetIntervalStart;
/**
* @brief The application sends data to the MCU.
*
*/
class VMcuAsk
{
public:
VMcuAsk()
{
mSerialNumber = 0;
}
VMcuAsk();
virtual ~VMcuAsk() = default;
virtual ASK_RESULT Blocking(void)
{
return ASK_RESULT::END;
}
virtual bool NeedReply(void)
{
return false;
}
virtual void ReplyFinished(const bool result)
{
}
virtual bool IfTimeout(const unsigned int &integrationTimeMs)
{
return false;
}
virtual ASK_RESULT Blocking(void);
virtual bool NeedReply(void);
virtual void ReplyFinished(const bool result);
virtual bool IfTimeout(const unsigned int &integrationTimeMs);
public:
/**
@ -96,13 +88,38 @@ public:
public:
T mDataReply;
};
/**
* @brief Report the data received by the serial port to the application.
*
*/
class VMcuRecv
{
public:
VMcuRecv() = default;
virtual ~VMcuRecv() = default;
virtual void ReplyFinished(const bool result);
};
template <typename T>
class McuRecv : public VMcuRecv
{
public:
McuRecv() = default;
virtual ~McuRecv() = default;
public:
T mDataRecvReply; ///< It includes both the data received by the serial port and the data replied to.
};
class VMcuMonitor
{
public:
VMcuMonitor() = default;
virtual ~VMcuMonitor() = default;
virtual void RecvIpcMissionEvent(std::shared_ptr<VMcuAsk> &recv, const IpcMission &mission);
virtual void RecvMcuHeartBeat(std::shared_ptr<VMcuAsk> &recv);
virtual void RecvIpcMissionEvent(std::shared_ptr<VMcuRecv> &recv, const IpcMission &mission);
virtual void RecvMcuHeartBeat(std::shared_ptr<VMcuRecv> &recv);
virtual void RecvGetIntervalStart(std::shared_ptr<VMcuRecv> &recv);
virtual void RecvGetDateTime(std::shared_ptr<VMcuRecv> &recv);
virtual void RecvGetPirSensitivity(std::shared_ptr<VMcuRecv> &recv);
};
class IMcuManager
{

42
middleware/McuManager/src/IMcuManager.cpp
View File

@ -14,10 +14,48 @@
*/
#include "IMcuManager.h"
#include "ILog.h"
void VMcuMonitor::RecvIpcMissionEvent(std::shared_ptr<VMcuAsk> &recv, const IpcMission &mission)
mcu_ask_date_time::mcu_ask_date_time(const unsigned short year, const unsigned char mon, const unsigned char day,
const unsigned char hour, const unsigned char min, const unsigned char second)
: mYear(year), mMon(mon), mDay(day), mHour(hour), mMin(min), mSecond(second)
{
}
void VMcuMonitor::RecvMcuHeartBeat(std::shared_ptr<VMcuAsk> &recv)
mcu_get_interval_start::mcu_get_interval_start() : mIntervalStart(0)
{
}
VMcuAsk::VMcuAsk() : mSerialNumber(0)
{
}
ASK_RESULT VMcuAsk::Blocking(void)
{
return ASK_RESULT::END;
}
bool VMcuAsk::NeedReply(void)
{
return false;
}
void VMcuAsk::ReplyFinished(const bool result)
{
}
bool VMcuAsk::IfTimeout(const unsigned int &integrationTimeMs)
{
return false;
}
void VMcuRecv::ReplyFinished(const bool result)
{
}
void VMcuMonitor::RecvIpcMissionEvent(std::shared_ptr<VMcuRecv> &recv, const IpcMission &mission)
{
}
void VMcuMonitor::RecvMcuHeartBeat(std::shared_ptr<VMcuRecv> &recv)
{
}
void VMcuMonitor::RecvGetIntervalStart(std::shared_ptr<VMcuRecv> &recv)
{
}
void VMcuMonitor::RecvGetDateTime(std::shared_ptr<VMcuRecv> &recv)
{
}
void VMcuMonitor::RecvGetPirSensitivity(std::shared_ptr<VMcuRecv> &recv)
{
}
std::shared_ptr<IMcuManager> &IMcuManager::GetInstance(std::shared_ptr<IMcuManager> *impl)

138
middleware/McuManager/src/McuManagerImpl.cpp
View File

@ -14,38 +14,22 @@
*/
#include "McuManagerImpl.h"
#include "ILog.h"
#include "UartRecvAsk.h"
class OtherSideSend : public UartRecvAsk, public McuAsk<ASK_RESULT>
class McuRecvImpl
{
public:
OtherSideSend(std::shared_ptr<McuManagerImpl> &mcuManager, const unsigned int &serialNumber,
const OtherSideSendType &sendType)
: mMcuManager(mcuManager), mSendType(sendType)
McuRecvImpl(const unsigned int &serialNumber, const OtherSideSendType &sendType)
: mSerialNumber(serialNumber), mSendType(sendType)
{
McuAsk::mSerialNumber = serialNumber;
}
virtual ~OtherSideSend() = default;
virtual ~McuRecvImpl() = default;
protected:
std::shared_ptr<McuManagerImpl> mMcuManager;
const unsigned int mSerialNumber;
public:
const OtherSideSendType mSendType;
};
template <typename T>
class OtherSideSendWithData : public OtherSideSend
{
public:
OtherSideSendWithData(std::shared_ptr<McuManagerImpl> &mcuManager, const unsigned int &serialNumber,
const OtherSideSendType &sendType, const T &otherSideData)
: OtherSideSend(mcuManager, serialNumber, sendType), mOtherSideData(otherSideData)
{
}
virtual ~OtherSideSendWithData() = default;
public:
const T mOtherSideData;
};
McuManagerImpl::McuManagerImpl()
{
mMcuAskHandle[OtherSideSendType::SEND_IPC_MISSION] =
@ -74,7 +58,7 @@ const StatusCode McuManagerImpl::SetMcuMonitor(std::shared_ptr<VMcuMonitor> &mon
std::lock_guard<std::mutex> locker(mMutex);
mMonitor = monitor;
for (auto ask : mMcuAskList) {
std::shared_ptr<OtherSideSend> data = std::dynamic_pointer_cast<OtherSideSend>(ask);
std::shared_ptr<McuRecvImpl> data = std::dynamic_pointer_cast<McuRecvImpl>(ask);
auto handle = mMcuAskHandle.find(data->mSendType);
if (handle != mMcuAskHandle.end()) {
handle->second(ask);
@ -163,62 +147,101 @@ std::shared_ptr<VMcuMonitor> McuManagerImpl::GetMcuMonitor(void)
}
void McuManagerImpl::OtherSideSendIpcMission(const unsigned int &serialNumber, const unsigned char &mission)
{
class OtherSideSendV2 : public OtherSideSendWithData<unsigned char>
class McuRecvIpcMission : public McuRecvImpl, public McuRecv<unsigned char>
{
public:
OtherSideSendV2(std::shared_ptr<McuManagerImpl> &mcuManager, const unsigned int &serialNumber,
const OtherSideSendType &sendType, const unsigned char &mission)
: OtherSideSendWithData(mcuManager, serialNumber, sendType, mission)
McuRecvIpcMission(std::shared_ptr<McuManagerImpl> &mcuManager, const unsigned int &serialNumber,
const OtherSideSendType &sendType, const unsigned char &mission)
: McuRecvImpl(serialNumber, sendType)
{
McuRecv::mDataRecvReply = mission;
McuRecvImpl::mMcuManager = mcuManager;
}
~OtherSideSendV2() = default;
~McuRecvIpcMission() = default;
void ReplyFinished(const bool result) override
{
mMcuManager->ReplyOtherSideSendIpcMission(McuAsk::mDataReply, VMcuAsk::mSerialNumber);
McuRecvImpl::mMcuManager->ReplyOtherSideSendIpcMission(ASK_RESULT::SUCCEED, McuRecvImpl::mSerialNumber);
}
};
std::shared_ptr<VMcuMonitor> monitor = GetMcuMonitor();
std::shared_ptr<McuManagerImpl> manager = std::dynamic_pointer_cast<McuManagerImpl>(SharedFromThis());
std::shared_ptr<VMcuAsk> ask =
std::make_shared<OtherSideSendV2>(manager, serialNumber, OtherSideSendType::SEND_IPC_MISSION, mission);
std::shared_ptr<VMcuRecv> recv =
std::make_shared<McuRecvIpcMission>(manager, serialNumber, OtherSideSendType::SEND_IPC_MISSION, mission);
if (monitor) {
monitor->RecvIpcMissionEvent(ask, static_cast<IpcMission>(mission));
monitor->RecvIpcMissionEvent(recv, static_cast<IpcMission>(mission));
}
else {
LogWarning("mMonitor is nullptr, AddMcuAsk.\n");
AddMcuAsk(ask);
LogWarning("mMonitor is nullptr, AddMcuRecv.\n");
AddMcuRecv(recv);
}
}
void McuManagerImpl::OtherSideSendHearBeat(const unsigned int &serialNumber)
{
class OtherSideSendV2 : public OtherSideSend
class McuRecvHeartBeat : public McuRecvImpl, public VMcuRecv
{
public:
OtherSideSendV2(std::shared_ptr<McuManagerImpl> &mcuManager, const unsigned int &serialNumber,
const OtherSideSendType &sendType)
: OtherSideSend(mcuManager, serialNumber, sendType)
McuRecvHeartBeat(std::shared_ptr<McuManagerImpl> &mcuManager, const unsigned int &serialNumber,
const OtherSideSendType &sendType)
: McuRecvImpl(serialNumber, sendType)
{
McuRecvImpl::mMcuManager = mcuManager;
}
~OtherSideSendV2() = default;
~McuRecvHeartBeat() = default;
void ReplyFinished(const bool result) override
{
LogInfo("Mcu monitor reply heart beat.\n");
mMcuManager->ReplyOtherSideSendHeartBeat(mSerialNumber);
McuRecvImpl::mMcuManager->ReplyOtherSideSendHeartBeat(McuRecvImpl::mSerialNumber);
}
};
std::shared_ptr<VMcuMonitor> monitor = GetMcuMonitor();
std::shared_ptr<McuManagerImpl> manager = std::dynamic_pointer_cast<McuManagerImpl>(SharedFromThis());
std::shared_ptr<VMcuAsk> ask =
std::make_shared<OtherSideSendV2>(manager, serialNumber, OtherSideSendType::SEND_HEART_BEAT);
std::shared_ptr<VMcuRecv> recv =
std::make_shared<McuRecvHeartBeat>(manager, serialNumber, OtherSideSendType::SEND_HEART_BEAT);
if (monitor) {
LogInfo("Mcu manager report heart beat to mcu monitor.\n");
monitor->RecvMcuHeartBeat(ask);
monitor->RecvMcuHeartBeat(recv);
}
else {
LogWarning("mMonitor is nullptr, AddMcuAsk.\n");
AddMcuAsk(ask);
LogWarning("mMonitor is nullptr, AddMcuRecv.\n");
AddMcuRecv(recv);
}
}
void McuManagerImpl::OtherSideSendGetIntervalStart(const unsigned int &serialNumber)
{
class McuRecvGetIntervalStart : public McuRecvImpl, public McuRecv<McuGetIntervalStart>
{
public:
McuRecvGetIntervalStart(std::shared_ptr<McuManagerImpl> &mcuManager, const unsigned int &serialNumber,
const OtherSideSendType &sendType)
: McuRecvImpl(serialNumber, sendType)
{
McuRecvImpl::mMcuManager = mcuManager;
}
~McuRecvGetIntervalStart() = default;
void ReplyFinished(const bool result) override
{
McuRecvImpl::mMcuManager->ReplyOtherSideSendGetIntervalStart(mDataRecvReply.mIntervalStart,
McuRecvImpl::mSerialNumber);
}
};
std::shared_ptr<VMcuMonitor> monitor = GetMcuMonitor();
std::shared_ptr<McuManagerImpl> manager = std::dynamic_pointer_cast<McuManagerImpl>(SharedFromThis());
std::shared_ptr<VMcuRecv> recv =
std::make_shared<McuRecvGetIntervalStart>(manager, serialNumber, OtherSideSendType::GET_INTERVAL_START);
if (monitor) {
LogInfo("Mcu manager report heart beat to mcu monitor.\n");
monitor->RecvMcuHeartBeat(recv);
}
else {
LogWarning("mMonitor is nullptr, AddMcuRecv.\n");
AddMcuRecv(recv);
}
}
void McuManagerImpl::OtherSideSendGetDateTime(const unsigned int &serialNumber)
{
}
void McuManagerImpl::OtherSideSendGetPirSensitivity(const unsigned int &serialNumber)
{
}
void McuManagerImpl::ReplyOtherSideSendIpcMission(const ASK_RESULT &result, const unsigned int &serialNumber)
{
LogInfo("ReplyOtherSideSendIpcMission\n");
@ -229,24 +252,33 @@ void McuManagerImpl::ReplyOtherSideSendHeartBeat(const unsigned int &serialNumbe
LogInfo("ReplyOtherSideSendHeartBeat\n");
McuProtocol::ReplyOtherSideSendHearBeat(static_cast<ReplyResult>(ASK_RESULT::SUCCEED), serialNumber);
}
void McuManagerImpl::AddMcuAsk(std::shared_ptr<VMcuAsk> &ask)
void McuManagerImpl::ReplyOtherSideSendGetIntervalStart(const unsigned int &interval, const unsigned int &serialNumber)
{
}
void McuManagerImpl::ReplyOtherSideSendGetDateTime(const McuAskDateTime &time, const unsigned int &serialNumber)
{
}
void McuManagerImpl::ReplyOtherSideSendGetPirSensitivity(const unsigned int &sensitivity,
const unsigned int &serialNumber)
{
}
void McuManagerImpl::AddMcuRecv(std::shared_ptr<VMcuRecv> &recv)
{
std::lock_guard<std::mutex> locker(mMutex);
mMcuAskList.push_back(ask);
mMcuAskList.push_back(recv);
}
void McuManagerImpl::McuAskSendIpcMissionHandle(std::shared_ptr<VMcuAsk> &ask)
void McuManagerImpl::McuAskSendIpcMissionHandle(std::shared_ptr<VMcuRecv> &recv)
{
std::shared_ptr<VMcuMonitor> monitor = GetMcuMonitor();
std::shared_ptr<OtherSideSendWithData<unsigned char>> data =
std::dynamic_pointer_cast<OtherSideSendWithData<unsigned char>>(ask);
std::shared_ptr<McuRecv<unsigned char>> data = std::dynamic_pointer_cast<McuRecv<unsigned char>>(recv);
if (monitor) {
monitor->RecvIpcMissionEvent(ask, static_cast<IpcMission>(data->mOtherSideData));
monitor->RecvIpcMissionEvent(recv, static_cast<IpcMission>(data->mDataRecvReply));
}
}
void McuManagerImpl::McuAskSendHeartBeatHandle(std::shared_ptr<VMcuAsk> &ask)
void McuManagerImpl::McuAskSendHeartBeatHandle(std::shared_ptr<VMcuRecv> &recv)
{
std::shared_ptr<VMcuMonitor> monitor = GetMcuMonitor();
if (monitor) {
monitor->RecvMcuHeartBeat(ask);
monitor->RecvMcuHeartBeat(recv);
}
}

19
middleware/McuManager/src/McuManagerImpl.h
View File

@ -22,11 +22,13 @@
#include <map>
#include <mutex>
using std::placeholders::_1;
using McuAskHandleFunc = std::function<void(std::shared_ptr<VMcuAsk> &)>;
using McuAskHandleFunc = std::function<void(std::shared_ptr<VMcuRecv> &)>;
enum class OtherSideSendType
{
SEND_IPC_MISSION,
SEND_HEART_BEAT,
GET_INTERVAL_START,
GET_DATE_TIME,
END
};
class McuManagerImpl : public McuDevice, public McuProtocol, public std::enable_shared_from_this<McuManagerImpl>
@ -57,16 +59,23 @@ private:
/**
* @brief The heartbeat packet must be processed by the state machine in the main thread. When the state machine
* blocks/freezes, it can be restored by the external microcontroller after powering off and restarting.
* This function has been cancelled.
* @param serialNumber
*/
void OtherSideSendHearBeat(const unsigned int &serialNumber) override;
void OtherSideSendGetIntervalStart(const unsigned int &serialNumber) override;
void OtherSideSendGetDateTime(const unsigned int &serialNumber) override;
void OtherSideSendGetPirSensitivity(const unsigned int &serialNumber) override;
void ReplyOtherSideSendIpcMission(const ASK_RESULT &result, const unsigned int &serialNumber);
void ReplyOtherSideSendHeartBeat(const unsigned int &serialNumber);
void ReplyOtherSideSendGetIntervalStart(const unsigned int &interval, const unsigned int &serialNumber);
void ReplyOtherSideSendGetDateTime(const McuAskDateTime &time, const unsigned int &serialNumber);
void ReplyOtherSideSendGetPirSensitivity(const unsigned int &sensitivity, const unsigned int &serialNumber);
private: // About mMcuAskList
void AddMcuAsk(std::shared_ptr<VMcuAsk> &ask);
void McuAskSendIpcMissionHandle(std::shared_ptr<VMcuAsk> &ask);
void McuAskSendHeartBeatHandle(std::shared_ptr<VMcuAsk> &ask);
void AddMcuRecv(std::shared_ptr<VMcuRecv> &recv);
void McuAskSendIpcMissionHandle(std::shared_ptr<VMcuRecv> &recv);
void McuAskSendHeartBeatHandle(std::shared_ptr<VMcuRecv> &recv);
private:
std::mutex mMutex;
@ -75,7 +84,7 @@ private:
* @brief If the monitor has not been registered yet, it is necessary to cache the reported messages and report them
* again when the monitor is registered.
*/
std::list<std::shared_ptr<VMcuAsk>> mMcuAskList;
std::list<std::shared_ptr<VMcuRecv>> mMcuAskList;
std::map<OtherSideSendType, McuAskHandleFunc> mMcuAskHandle;
};
#endif

2
test/middleware/McuManager/src/McuManager_Test.cpp
View File

@ -91,7 +91,7 @@ TEST_F(McuManagerTest, RH_INTEGRATION_McuManager_AUTO_OtherSideSendIpcMission)
public:
MonitorTest() = default;
virtual ~MonitorTest() = default;
void RecvIpcMissionEvent(std::shared_ptr<VMcuAsk> &recv, const IpcMission &mission) override
void RecvIpcMissionEvent(std::shared_ptr<VMcuRecv> &recv, const IpcMission &mission) override
{
LogInfo("RecvIpcMissionEvent %s\n", IMcuManager::GetInstance()->PrintIpcMissionString(mission));
std::shared_ptr<McuAsk<ASK_RESULT>> ask = std::dynamic_pointer_cast<McuAsk<ASK_RESULT>>(recv);

10
test/middleware/McuManager/src_mock/McuManager_Mock_Test.cpp
View File

@ -158,13 +158,13 @@ TEST_F(McuManagerMockTest, HS_INTEGRATION_McuManager_EXAMPLE_OtherSideSendIpcMis
public:
MonitorTest() = default;
virtual ~MonitorTest() = default;
void RecvIpcMissionEvent(std::shared_ptr<VMcuAsk> &recv, const IpcMission &mission) override
void RecvIpcMissionEvent(std::shared_ptr<VMcuRecv> &recv, const IpcMission &mission) override
{
LogInfo("RecvIpcMissionEvent\n");
std::shared_ptr<McuAsk<ASK_RESULT>> ask = std::dynamic_pointer_cast<McuAsk<ASK_RESULT>>(recv);
ask->mDataReply = ASK_RESULT::SUCCEED;
recv->ReplyFinished(true);
EXPECT_EQ(TEST_SERIAL_NUMBER, recv->mSerialNumber);
// EXPECT_EQ(TEST_SERIAL_NUMBER, recv->mSerialNumber);
}
};
IMcuManager::GetInstance()->Init();
@ -188,13 +188,13 @@ TEST_F(McuManagerMockTest, HS_INTEGRATION_McuManager_EXAMPLE_OtherSideSendHeartB
public:
MonitorTest() = default;
virtual ~MonitorTest() = default;
void RecvMcuHeartBeat(std::shared_ptr<VMcuAsk> &recv) override
void RecvMcuHeartBeat(std::shared_ptr<VMcuRecv> &recv) override
{
LogInfo("RecvMcuHeartBeat\n");
std::shared_ptr<McuAsk<ASK_RESULT>> ask = std::dynamic_pointer_cast<McuAsk<ASK_RESULT>>(recv);
ask->mDataReply = ASK_RESULT::SUCCEED;
recv->ReplyFinished(true);
EXPECT_EQ(TEST_SERIAL_NUMBER, recv->mSerialNumber);
// EXPECT_EQ(TEST_SERIAL_NUMBER, recv->mSerialNumber);
}
};
IMcuManager::GetInstance()->Init();
@ -885,7 +885,7 @@ TEST_F(McuManagerMockTest, HS_INTEGRATION_McuManager_AUTO_OtherSideSendIpcMissio
public:
MonitorTest() = default;
virtual ~MonitorTest() = default;
void RecvIpcMissionEvent(std::shared_ptr<VMcuAsk> &recv, const IpcMission &mission) override
void RecvIpcMissionEvent(std::shared_ptr<VMcuRecv> &recv, const IpcMission &mission) override
{
LogInfo("RecvIpcMissionEvent\n");
std::shared_ptr<McuAsk<ASK_RESULT>> ask = std::dynamic_pointer_cast<McuAsk<ASK_RESULT>>(recv);

11
utils/McuProtocol/include/McuProtocol.h
View File

@ -100,12 +100,8 @@ class OtherSideReply
public:
OtherSideReply() = default;
virtual ~OtherSideReply() = default;
virtual void GetIpcMissionReply(const unsigned int &serialNumber, const unsigned char &mission)
{
}
virtual void OnlyResultReply(const unsigned int &serialNumber, const ReplyResult &result)
{
}
virtual void GetIpcMissionReply(const unsigned int &serialNumber, const unsigned char &mission);
virtual void OnlyResultReply(const unsigned int &serialNumber, const ReplyResult &result);
};
class OtherSideAsk
{
@ -114,6 +110,9 @@ public:
virtual ~OtherSideAsk() = default;
virtual void OtherSideSendIpcMission(const unsigned int &serialNumber, const unsigned char &mission);
virtual void OtherSideSendHearBeat(const unsigned int &serialNumber);
virtual void OtherSideSendGetIntervalStart(const unsigned int &serialNumber);
virtual void OtherSideSendGetDateTime(const unsigned int &serialNumber);
virtual void OtherSideSendGetPirSensitivity(const unsigned int &serialNumber);
};
class VProtocolRecv : public OtherSideReply, public OtherSideAsk
{

17
utils/McuProtocol/src/McuProtocol.cpp
View File

@ -16,12 +16,27 @@
#include "ILog.h"
#include "ProtocolHandle.h"
#include <string.h>
void OtherSideReply::GetIpcMissionReply(const unsigned int &serialNumber, const unsigned char &mission)
{
}
void OtherSideReply::OnlyResultReply(const unsigned int &serialNumber, const ReplyResult &result)
{
}
void OtherSideAsk::OtherSideSendIpcMission(const unsigned int &serialNumber, const unsigned char &mission)
{
}
void OtherSideAsk::OtherSideSendHearBeat(const unsigned int &serialNumber)
{
}
void OtherSideAsk::OtherSideSendGetIntervalStart(const unsigned int &serialNumber)
{
}
void OtherSideAsk::OtherSideSendGetDateTime(const unsigned int &serialNumber)
{
}
void OtherSideAsk::OtherSideSendGetPirSensitivity(const unsigned int &serialNumber)
{
}
std::shared_ptr<VProtocolRecv> &VProtocolRecv::GetInstance(std::shared_ptr<VProtocolRecv> *impl)
{
static auto instance = std::make_shared<VProtocolRecv>();
@ -164,8 +179,6 @@ void McuProtocol::ReplyOtherSideSendIpcMission(const ReplyResult &result, const
void McuProtocol::ReplyOtherSideSendHearBeat(const ReplyResult &result, const unsigned int &serialNumber)
{
std::shared_ptr<VProtocolContext> NULL_CONTEXT;
// std::shared_ptr<VProtocolParam> param = std::make_shared<ProtocolParam<const unsigned char>>(
// PROTOCOL_COMMAND::REPLY_OTHER_SIDE_ASK_SEND_HEART_BEAT, static_cast<const unsigned char>(result));
std::shared_ptr<VProtocolParam> param =
std::make_shared<VProtocolParam>(PROTOCOL_COMMAND::REPLY_OTHER_SIDE_ASK_SEND_HEART_BEAT);
param->mSerialNumber = serialNumber;

15
utils/McuProtocol/src/ProtocolHandle.cpp
View File

@ -240,6 +240,21 @@ void ProtocolHandle::AnalyzeOtherSideSendHeartBeatPacket(const ProtocolPacket &p
LogInfo("AnalyzeOtherSideSendHeartBeatPacket\n");
VProtocolRecv::GetInstance()->OtherSideSendHearBeat(mProtocolSerialNumber);
}
void ProtocolHandle::AnalyzeOtherSideSendGetIntervalStart(const ProtocolPacket &packet)
{
LogInfo("AnalyzeOtherSideSendGetIntervalStart\n");
VProtocolRecv::GetInstance()->OtherSideSendGetIntervalStart(mProtocolSerialNumber);
}
void ProtocolHandle::AnalyzeOtherSideSendGetDataTime(const ProtocolPacket &packet)
{
LogInfo("AnalyzeOtherSideSendGetDataTime\n");
VProtocolRecv::GetInstance()->OtherSideSendGetDateTime(mProtocolSerialNumber);
}
void ProtocolHandle::AnalyzeOtherSideSendGetPirSensitivity(const ProtocolPacket &packet)
{
LogInfo("AnalyzeOtherSideSendGetPirSensitivity\n");
VProtocolRecv::GetInstance()->OtherSideSendGetPirSensitivity(mProtocolSerialNumber);
}
bool ProtocolHandle::CheckoutTheCheckCode(const ProtocolPacket &packet)
{
short code = calculate_check_sum(mProtocolData, mProtocolDataLength - CHECK_CODE_LENGTH);

13
utils/McuProtocol/src/ProtocolHandle.h
View File

@ -59,8 +59,14 @@ enum PROTOCOL_COMMAND
*/
REPLY_OTHER_SIDE_ASK_SEND_IPC_MISSION = 0xC101,
OTHER_SIDE_ASK_SEND_IPC_MISSION = 0x4101,
REPLY_OTHER_SIDE_ASK_SEND_HEART_BEAT = 0xC102,
OTHER_SIDE_ASK_SEND_HEART_BEAT = 0x4102,
REPLY_OTHER_SIDE_ASK_SEND_HEART_BEAT = 0xC102, // Temporarily cancelled, reserved.
OTHER_SIDE_ASK_SEND_HEART_BEAT = 0x4102, // Temporarily cancelled, reserved.
REPLY_OTHER_SIDE_ASK_GET_INTERVAL_START = 0xC106,
OTHER_SIDE_ASK_GET_INTERVAL_START = 0x4106,
REPLY_OTHER_SIDE_ASK_GET_DATE_TIME = 0xC107,
OTHER_SIDE_ASK_GET_DATE_TIME = 0x4107,
REPLY_OTHER_SIDE_ASK_GET_PIR_SENSITIVITY = 0xC108,
OTHER_SIDE_ASK_GET_PIR_SENSITIVITY = 0x4108,
PROTOCOL_COMMAND_END
};
constexpr unsigned char ZERO_MEANS_SHUTDOWN_WATCH_DOG = 0x00;
@ -185,6 +191,9 @@ private:
void AnalyzeReplyIpcMissionPacket(const ProtocolPacket &packet);
void AnalyzeOtherSideSendIpcMissionPacket(const ProtocolPacket &packet);
void AnalyzeOtherSideSendHeartBeatPacket(const ProtocolPacket &packet);
void AnalyzeOtherSideSendGetIntervalStart(const ProtocolPacket &packet);
void AnalyzeOtherSideSendGetDataTime(const ProtocolPacket &packet);
void AnalyzeOtherSideSendGetPirSensitivity(const ProtocolPacket &packet);
private:
virtual void BigEndianConversion(ProtocolPacket &packet)