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

Merge branch 'master-develop' of gitee.com:shenzhen-jiuyilian/ipc into m-develop

Browse Source
This commit is contained in:
Fancy code 2024-05-15 22:19:21 +08:00
commit d6841b4b19
12 changed files with 378 additions and 209 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

222
middleware/McuManager/README.md
View File

@ -2,9 +2,10 @@
  为满足打猎相机的低功耗需求，使用外置MCU的硬件设计框架，在非工作状态下保持外置MCU供电，CPU断电，满足低功耗的产品需求。   为满足打猎相机的低功耗需求，使用外置MCU的硬件设计框架，在非工作状态下保持外置MCU供电，CPU断电，满足低功耗的产品需求。
| 修改 | 说明 | | 版本 | 时间 | 说明 |
| ---- | ---- | | ---- | ---- | ---- |
| 2024-5-14 | 首次评审。 | | V1.0 | 2024-5-14 | 首次评审。 |
| V1.1 | 2024-5-15 | 完善时序图。 |
## 1.1. 基本概念 ## 1.1. 基本概念
@ -64,41 +65,38 @@
### 1.3.1. 整机物理上电启动 ### 1.3.1. 整机物理上电启动
  整机物理上电时，根据实际情况刷新设备的工作状态。   整机物理上电时，设备一定会进入TEST或者ON状态，主控Linux启动一次。
补充：
如果掉电无法保存数据，首次物理上电向主控获取；
默认开启喂狗；
```mermaid ```mermaid
sequenceDiagram sequenceDiagram
participant CPU participant CPU
participant MCU participant MCU
MCU ->> MCU:物理上电 MCU ->> MCU:物理上电
MCU ->> MCU:串口初始化 MCU ->> CPU:物理上电
opt 检测到TEST拨档挡位 CPU ->> MCU:查询启动模式
MCU ->> CPU:物理上电 alt 检测到TEST拨档挡位
MCU ->> +CPU:发送启动模式：TEST启动 MCU -->> CPU:回复TEST启动
CPU ->> CPU:TEST启动 CPU ->> CPU:TEST启动
CPU -->> -MCU:回复OK
loop 无操作 loop 无操作
CPU ->> +MCU:发送关机指令 CPU ->> MCU:发送关机指令
MCU -->> -CPU:回复OK
MCU ->> CPU:物理断电 MCU ->> CPU:物理断电
end end
end else 检测到ON拨档挡位
opt 检测到ON拨档挡位
note over MCU:正常工作模式，PIR触发后可给主控上电 note over MCU:正常工作模式，PIR触发后可给主控上电
end MCU -->> CPU:回复ON启动
opt PIR触发中断 CPU ->> CPU:ON启动
MCU ->> CPU:物理上电 CPU ->> MCU:发送关机指令
MCU ->> +CPU:发送PIR触发启动
CPU ->> CPU:PIR启动
CPU -->> -MCU:回复OK
CPU ->> +MCU:发送关机指令
MCU -->> -CPU:回复OK
MCU ->> CPU:物理断电 MCU ->> CPU:物理断电
end end
loop 默认开启喂狗
opt 喂狗超时
MCU ->> CPU:断电重启
CPU ->> +MCU:查询启动模式
MCU -->> -CPU:回复喂狗异常启动
CPU ->> MCU:发送关机指令
MCU ->> CPU:物理断电
end
end
MCU ->> MCU:休眠 MCU ->> MCU:休眠
note over MCU:休眠后进入正常工作模式：当发生PIR触发时，<br>给CPU物理上电并发送PIR启动命令 note over MCU:休眠后进入正常工作模式：当发生PIR触发时，<br>给CPU物理上电并发送PIR启动命令
``` ```
@ -114,32 +112,28 @@ sequenceDiagram
participant CPU participant CPU
participant MCU participant MCU
loop 常通电待机 loop 常通电待机
opt CPU关机
CPU ->> MCU:发送关机指令
MCU ->> CPU:物理断电
MCU ->> MCU:休眠
end
opt PIR触发中断 opt PIR触发中断
MCU ->> MCU:休眠唤醒 MCU ->> MCU:休眠唤醒
MCU ->> CPU:物理上电 MCU ->> CPU:物理上电
MCU ->> +CPU:发送PIR触发启动 CPU ->> +MCU:查询启动模式
CPU -->> -MCU:回复OK MCU -->> -CPU:回复PIR启动
end end
opt TEST按键中断 opt TEST/ON按键中断
MCU ->> MCU:休眠唤醒 MCU ->> MCU:休眠唤醒
MCU ->> CPU:物理上电 MCU ->> CPU:物理上电
MCU ->> +CPU:发送TEST启动 CPU ->> +MCU:查询启动模式
CPU -->> -MCU:回复OK MCU -->> -CPU:回复TEST/ON启动
end end
opt 设置定时唤醒 opt 设置定时唤醒
CPU ->> MCU:发送设置定时唤醒协议 CPU ->> MCU:发送设置定时唤醒协议
opt 定时唤醒中断 opt 定时唤醒中断
MCU ->> MCU:休眠唤醒 MCU ->> MCU:休眠唤醒
MCU ->> CPU:物理上电 MCU ->> CPU:物理上电
MCU ->> +CPU:发送定时唤醒启动 CPU ->> +MCU:查询启动模式
CPU -->> -MCU:回复OK MCU -->> -CPU:回复喂狗异常启动
end end
end end
MCU ->> MCU:休眠
end end
``` ```
@ -187,30 +181,28 @@ end
&emsp;&emsp;外置MCU充当硬件狗，在系统异常时断电重启系统。喂狗逻辑和启动模式无关。 &emsp;&emsp;外置MCU充当硬件狗，在系统异常时断电重启系统。喂狗逻辑和启动模式无关。
默认开启喂狗；
```mermaid ```mermaid
sequenceDiagram sequenceDiagram
participant CPU participant CPU
participant MCU participant MCU
MCU ->> MCU:物理上电 MCU ->> MCU:物理上电
MCU ->> CPU:某种启动模式触发物理上电 MCU ->> CPU:某种启动模式触发物理上电
opt 主控开启喂狗 loop 默认开启喂狗
opt 设置喂狗周期
note over CPU:主控选择性设置喂狗周期
CPU ->> +MCU:开启狗/设置喂狗周期 CPU ->> +MCU:开启狗/设置喂狗周期
MCU -->> -CPU:回复OK MCU -->> -CPU:回复OK
loop 主控喂狗 end
opt 主控喂狗
note over MCU:喂狗不需要回复 note over MCU:喂狗不需要回复
CPU ->> MCU:喂狗 CPU ->> MCU:喂狗
end end
loop MCU定时查狗
alt 主控喂狗异常 alt 主控喂狗异常
MCU ->> CPU:断电重启 MCU ->> CPU:断电重启
MCU ->> +CPU:发送启动模式：喂狗异常启动 CPU ->> +MCU:查询启动模式
CPU ->> CPU:喂狗异常启动 MCU -->> -CPU:回复喂狗异常启动
CPU -->> -MCU:回复OK
CPU ->> MCU:断电关机 CPU ->> MCU:断电关机
end end
end
end end
CPU ->> MCU:断电关机 CPU ->> MCU:断电关机
MCU ->> CPU:物理断电 MCU ->> CPU:物理断电
@ -218,14 +210,9 @@ MCU ->> MCU:休眠
note over MCU:休眠后进入正常工作模式：当发生PIR触发时，<br>给CPU物理上电并发送PIR启动命令 note over MCU:休眠后进入正常工作模式：当发生PIR触发时，<br>给CPU物理上电并发送PIR启动命令
``` ```
#### 1.3.3.3. 心跳 #### 1.3.3.3. 超时异常启动
&emsp;&emsp;CPU单次上电时间都是有限的，在主控未主动开启喂狗时，30s主动查询一次心跳，未回复则断电重启。此设计保证程序异常时电量不会一直消耗完。 &emsp;&emsp;CPU单次上电时间都是有限的，在主控未正常发送关机指令时，3min后断电进行异常启动。TEST/产测模式等需要一直开机的场景，主控关闭喂狗功能即可。
**注意：** 整机上电之后如果从来未开启过喂狗功能，此功能不生效。避免调试版本不停重启。
取消心跳，默认开启喂狗。喂狗线程模拟主线程心跳；
单次上电时间异常重启，总时间3min；
```mermaid ```mermaid
sequenceDiagram sequenceDiagram
@ -233,37 +220,17 @@ participant CPU
participant MCU participant MCU
MCU ->> MCU:物理上电 MCU ->> MCU:物理上电
MCU ->> CPU:某种启动模式触发物理上电 MCU ->> CPU:某种启动模式触发物理上电
opt 主控开启喂狗 alt 主控未关闭喂狗
CPU ->> +MCU:开启狗/设置喂狗周期 note over MCU:如果主控关闭喂狗的功能，<br>也同时关闭超时异常启动功能
MCU -->> -CPU:回复OK opt 主控未正常发送关机指令
MCU ->> MCU:激活心跳功能 MCU ->> CPU:物理断电
CPU ->> +MCU:查询启动模式
MCU -->> -CPU:回复喂狗异常启动
end
end end
CPU ->> MCU:断电关机 CPU ->> MCU:断电关机
MCU ->> CPU:物理断电 MCU ->> CPU:物理断电
MCU ->> MCU:休眠 MCU ->> MCU:休眠
note over MCU:只要CPU某次启动开启喂狗功能，下次启动心跳功能就会生效。
MCU ->> CPU:某种启动模式触发物理上电
opt 心跳功能已经激活
note over MCU:心跳功能在主控未开启喂狗时（异常）发挥作用。
opt 主控未开启喂狗
loop 30s主动查询一次心跳
MCU ->> +CPU:发送心跳包
alt 心跳回复
CPU -->> -MCU:回复OK
else 5s超时， 心跳未回复
MCU ->> CPU:断电重启
MCU ->> +CPU:发送启动模式：心跳异常启动
CPU ->> CPU:心跳异常启动
CPU -->> -MCU:回复OK
CPU ->> MCU:断电关机
end
end
end
CPU ->> MCU:断电关机
MCU ->> CPU:物理断电
MCU ->> MCU:休眠
end
``` ```
#### 1.3.3.4. PIR触发任务 #### 1.3.3.4. PIR触发任务
@ -278,9 +245,9 @@ loop 常通电待机
opt PIR触发中断 opt PIR触发中断
MCU ->> MCU:休眠唤醒 MCU ->> MCU:休眠唤醒
MCU ->> CPU:物理上电 MCU ->> CPU:物理上电
MCU ->> +CPU:发送PIR触发启动模式 CPU ->> +MCU:查询启动模式
CPU ->> CPU:PIR启动 MCU -->> -CPU:回复PIR触发启动
CPU -->> -MCU:回复OK CPU ->> CPU:Do something
CPU ->> MCU:断电关机 CPU ->> MCU:断电关机
MCU ->> CPU:物理断电 MCU ->> CPU:物理断电
MCU ->> MCU:休眠 MCU ->> MCU:休眠
@ -299,17 +266,12 @@ sequenceDiagram
participant CPU participant CPU
participant MCU participant MCU
MCU ->> MCU:常电待机 MCU ->> MCU:常电待机
opt 拨键从ON拨到TEST opt 拨键从ON/OFF拨到TEST
note over MCU:TEST模式启动，只会发生在从ON切换到TEST的瞬间，<br>如果PIR触发时，已经处于TEST挡位，此时不影响PIR模式启动 note over MCU:TEST模式启动，只会发生在从ON/OFF切换到TEST的瞬间，<br>如果PIR触发时，已经处于TEST挡位，此时不影响PIR模式启动
MCU ->> CPU:物理上电 MCU ->> CPU:物理上电
MCU ->> +CPU:发送启动模式：TEST启动 CPU ->> +MCU:查询启动模式
CPU ->> CPU:TEST启动 MCU -->> -CPU:回复TEST启动
CPU -->> -MCU:回复OK CPU ->> CPU:Do something
opt 拨键从TEST拨到ON
note over MCU:进入ON模式，设备处于正常工作状态
CPU ->> MCU:发送断电关机
MCU ->> CPU:物理断电
end
opt CPU关机 opt CPU关机
note over MCU:超时关机时，<br>此时拨键还是处于“TEST”挡位的 note over MCU:超时关机时，<br>此时拨键还是处于“TEST”挡位的
CPU ->> MCU:发送断电关机 CPU ->> MCU:发送断电关机
@ -319,7 +281,69 @@ end
MCU ->> MCU:休眠 MCU ->> MCU:休眠
``` ```
#### 1.3.3.6. 数据同步 #### 1.3.3.6. 主控通电时发生启动事件
&emsp;&emsp;如果主控在通电后（主控发送关机指令之前）发生启动事件的动态变化，需要先主动发送启动事件，有主控发送关机指令后，再断电重启触发新的启动事件。
```mermaid
sequenceDiagram
participant CPU
participant MCU
MCU ->> MCU:主控已经上电，常电待机
note over MCU:此处不管由于何总原因的主控上电，<br>如果发生启动事件动态变化，需要先发送启动命令给主控
opt 拨键从ON拨到TEST
MCU ->> +CPU:发送启动模式：TEST启动
CPU ->> CPU:Do something
CPU -->> -MCU:回复OK
CPU ->> MCU:发送断电关机
MCU ->> CPU:物理断电重启
CPU ->> +MCU:查询启动模式
MCU -->> -CPU:回复TEST启动
CPU ->> CPU:TEST启动
opt CPU关机
note over MCU:超时关机时，<br>此时拨键还是处于“TEST”挡位的
CPU ->> MCU:发送断电关机
MCU ->> CPU:物理断电
end
end
opt 拨键从TEST拨到ON
MCU ->> +CPU:发送启动模式：ON启动
CPU ->> CPU:Do something
CPU -->> -MCU:回复OK
CPU ->> MCU:发送断电关机
MCU ->> CPU:物理断电重启
CPU ->> +MCU:查询启动模式
MCU -->> -CPU:回复ON启动
CPU ->> CPU:ON启动
opt CPU关机
CPU ->> MCU:发送断电关机
MCU ->> CPU:物理断电
end
end
opt PIR触发
note over MCU:上电后发生PIR触发，主控立即处理抓拍流程，无需断电重启。
MCU ->> +CPU:发送启动模式：PIR启动
CPU ->> CPU:Do something
CPU -->> -MCU:回复OK
opt CPU关机
CPU ->> MCU:发送断电关机
MCU ->> CPU:物理断电
end
end
opt 定时启动
note over MCU:上电后发生定时启动，主控立即处理抓拍流程，无需断电重启。
MCU ->> +CPU:发送启动模式：定时启动
CPU ->> CPU:Do something
CPU -->> -MCU:回复OK
opt CPU关机
CPU ->> MCU:发送断电关机
MCU ->> CPU:物理断电
end
end
MCU ->> MCU:休眠
```
#### 1.3.3.7. 数据同步
&emsp;&emsp;主控和外置MCU之间数据同步，包括主控发给外置MCU的，也包括外置MCU发给主控的。数据同步流程可以在任意的工作状态下进行。 &emsp;&emsp;主控和外置MCU之间数据同步，包括主控发给外置MCU的，也包括外置MCU发给主控的。数据同步流程可以在任意的工作状态下进行。
@ -331,8 +355,8 @@ MCU ->> MCU:物理上电
MCU ->> CPU:某种启动模式触发物理上电 MCU ->> CPU:某种启动模式触发物理上电
opt 数据同步 opt 数据同步
note over MCU:此处根据协议只做一个数据示例，其它协议雷同。 note over MCU:此处根据协议只做一个数据示例，其它协议雷同。
CPU ->> +MCU:设置灵敏度 MCU ->> +CPU:获取灵敏度
MCU -->> -CPU:回复OK CPU -->> -MCU:回复数据
end end
CPU ->> MCU:断电关机 CPU ->> MCU:断电关机
MCU ->> CPU:物理断电 MCU ->> CPU:物理断电
@ -340,6 +364,12 @@ MCU ->> MCU:休眠
note over MCU:休眠后进入正常工作模式：当发生PIR触发时，<br>给CPU物理上电并发送PIR启动命令 note over MCU:休眠后进入正常工作模式：当发生PIR触发时，<br>给CPU物理上电并发送PIR启动命令
``` ```
### 1.3.4. 连拍
&emsp;&emsp;打猎机可以设置连拍张数和连拍间隔。连拍张数1-3，连拍间隔0-60s；
**备注：竞品的连拍间隔为0/1/2s。先做0/1/2s连拍，此时与外置MCU无关。**
## 1.4. MCU协议 ## 1.4. MCU协议
&emsp;&emsp;负责对MCU协议进行封包/解包，协议封包/解包功能独立封装成库，详见[协议文档](../../utils/McuProtocol/README.md)。 &emsp;&emsp;负责对MCU协议进行封包/解包，协议封包/解包功能独立封装成库，详见[协议文档](../../utils/McuProtocol/README.md)。

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

@ -42,41 +42,33 @@ enum class ControlLight
}; };
typedef struct mcu_ask_date_time 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 short mYear;
const unsigned char mMon; const unsigned char mMon;
const unsigned char mDay; const unsigned char mDay;
const unsigned char mHour; const unsigned char mHour;
const unsigned char mMin; const unsigned char mMin;
const unsigned char mSecond; 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; } 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 class VMcuAsk
{ {
public: public:
VMcuAsk() VMcuAsk();
{
mSerialNumber = 0;
}
virtual ~VMcuAsk() = default; virtual ~VMcuAsk() = default;
virtual ASK_RESULT Blocking(void) virtual ASK_RESULT Blocking(void);
{ virtual bool NeedReply(void);
return ASK_RESULT::END; virtual void ReplyFinished(const bool result);
} virtual bool IfTimeout(const unsigned int &integrationTimeMs);
virtual bool NeedReply(void)
{
return false;
}
virtual void ReplyFinished(const bool result)
{
}
virtual bool IfTimeout(const unsigned int &integrationTimeMs)
{
return false;
}
public: public:
/** /**
@ -96,13 +88,38 @@ public:
public: public:
T mDataReply; 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 class VMcuMonitor
{ {
public: public:
VMcuMonitor() = default; VMcuMonitor() = default;
virtual ~VMcuMonitor() = default; virtual ~VMcuMonitor() = default;
virtual void RecvIpcMissionEvent(std::shared_ptr<VMcuAsk> &recv, const IpcMission &mission); virtual void RecvIpcMissionEvent(std::shared_ptr<VMcuRecv> &recv, const IpcMission &mission);
virtual void RecvMcuHeartBeat(std::shared_ptr<VMcuAsk> &recv); 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 class IMcuManager
{ {

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

@ -14,10 +14,48 @@
*/ */
#include "IMcuManager.h" #include "IMcuManager.h"
#include "ILog.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) std::shared_ptr<IMcuManager> &IMcuManager::GetInstance(std::shared_ptr<IMcuManager> *impl)

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

@ -14,38 +14,22 @@
*/ */
#include "McuManagerImpl.h" #include "McuManagerImpl.h"
#include "ILog.h" #include "ILog.h"
#include "UartRecvAsk.h" class McuRecvImpl
class OtherSideSend : public UartRecvAsk, public McuAsk<ASK_RESULT>
{ {
public: public:
OtherSideSend(std::shared_ptr<McuManagerImpl> &mcuManager, const unsigned int &serialNumber, McuRecvImpl(const unsigned int &serialNumber, const OtherSideSendType &sendType)
const OtherSideSendType &sendType) : mSerialNumber(serialNumber), mSendType(sendType)
: mMcuManager(mcuManager), mSendType(sendType)
{ {
McuAsk::mSerialNumber = serialNumber;
} }
virtual ~OtherSideSend() = default; virtual ~McuRecvImpl() = default;
protected: protected:
std::shared_ptr<McuManagerImpl> mMcuManager; std::shared_ptr<McuManagerImpl> mMcuManager;
const unsigned int mSerialNumber;
public: public:
const OtherSideSendType mSendType; 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() McuManagerImpl::McuManagerImpl()
{ {
mMcuAskHandle[OtherSideSendType::SEND_IPC_MISSION] = 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); std::lock_guard<std::mutex> locker(mMutex);
mMonitor = monitor; mMonitor = monitor;
for (auto ask : mMcuAskList) { 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); auto handle = mMcuAskHandle.find(data->mSendType);
if (handle != mMcuAskHandle.end()) { if (handle != mMcuAskHandle.end()) {
handle->second(ask); 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) 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: public:
OtherSideSendV2(std::shared_ptr<McuManagerImpl> &mcuManager, const unsigned int &serialNumber, McuRecvIpcMission(std::shared_ptr<McuManagerImpl> &mcuManager, const unsigned int &serialNumber,
const OtherSideSendType &sendType, const unsigned char &mission) const OtherSideSendType &sendType, const unsigned char &mission)
: OtherSideSendWithData(mcuManager, serialNumber, sendType, mission) : McuRecvImpl(serialNumber, sendType)
{ {
McuRecv::mDataRecvReply = mission;
McuRecvImpl::mMcuManager = mcuManager;
} }
~OtherSideSendV2() = default; ~McuRecvIpcMission() = default;
void ReplyFinished(const bool result) override 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<VMcuMonitor> monitor = GetMcuMonitor();
std::shared_ptr<McuManagerImpl> manager = std::dynamic_pointer_cast<McuManagerImpl>(SharedFromThis()); std::shared_ptr<McuManagerImpl> manager = std::dynamic_pointer_cast<McuManagerImpl>(SharedFromThis());
std::shared_ptr<VMcuAsk> ask = std::shared_ptr<VMcuRecv> recv =
std::make_shared<OtherSideSendV2>(manager, serialNumber, OtherSideSendType::SEND_IPC_MISSION, mission); std::make_shared<McuRecvIpcMission>(manager, serialNumber, OtherSideSendType::SEND_IPC_MISSION, mission);
if (monitor) { if (monitor) {
monitor->RecvIpcMissionEvent(ask, static_cast<IpcMission>(mission)); monitor->RecvIpcMissionEvent(recv, static_cast<IpcMission>(mission));
} }
else { else {
LogWarning("mMonitor is nullptr, AddMcuAsk.\n"); LogWarning("mMonitor is nullptr, AddMcuRecv.\n");
AddMcuAsk(ask); AddMcuRecv(recv);
} }
} }
void McuManagerImpl::OtherSideSendHearBeat(const unsigned int &serialNumber) void McuManagerImpl::OtherSideSendHearBeat(const unsigned int &serialNumber)
{ {
class OtherSideSendV2 : public OtherSideSend class McuRecvHeartBeat : public McuRecvImpl, public VMcuRecv
{ {
public: public:
OtherSideSendV2(std::shared_ptr<McuManagerImpl> &mcuManager, const unsigned int &serialNumber, McuRecvHeartBeat(std::shared_ptr<McuManagerImpl> &mcuManager, const unsigned int &serialNumber,
const OtherSideSendType &sendType) const OtherSideSendType &sendType)
: OtherSideSend(mcuManager, serialNumber, sendType) : McuRecvImpl(serialNumber, sendType)
{ {
McuRecvImpl::mMcuManager = mcuManager;
} }
~OtherSideSendV2() = default; ~McuRecvHeartBeat() = default;
void ReplyFinished(const bool result) override void ReplyFinished(const bool result) override
{ {
LogInfo("Mcu monitor reply heart beat.\n"); McuRecvImpl::mMcuManager->ReplyOtherSideSendHeartBeat(McuRecvImpl::mSerialNumber);
mMcuManager->ReplyOtherSideSendHeartBeat(mSerialNumber);
} }
}; };
std::shared_ptr<VMcuMonitor> monitor = GetMcuMonitor(); std::shared_ptr<VMcuMonitor> monitor = GetMcuMonitor();
std::shared_ptr<McuManagerImpl> manager = std::dynamic_pointer_cast<McuManagerImpl>(SharedFromThis()); std::shared_ptr<McuManagerImpl> manager = std::dynamic_pointer_cast<McuManagerImpl>(SharedFromThis());
std::shared_ptr<VMcuAsk> ask = std::shared_ptr<VMcuRecv> recv =
std::make_shared<OtherSideSendV2>(manager, serialNumber, OtherSideSendType::SEND_HEART_BEAT); std::make_shared<McuRecvHeartBeat>(manager, serialNumber, OtherSideSendType::SEND_HEART_BEAT);
if (monitor) { if (monitor) {
LogInfo("Mcu manager report heart beat to mcu monitor.\n"); LogInfo("Mcu manager report heart beat to mcu monitor.\n");
monitor->RecvMcuHeartBeat(ask); monitor->RecvMcuHeartBeat(recv);
} }
else { else {
LogWarning("mMonitor is nullptr, AddMcuAsk.\n"); LogWarning("mMonitor is nullptr, AddMcuRecv.\n");
AddMcuAsk(ask); 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) void McuManagerImpl::ReplyOtherSideSendIpcMission(const ASK_RESULT &result, const unsigned int &serialNumber)
{ {
LogInfo("ReplyOtherSideSendIpcMission\n"); LogInfo("ReplyOtherSideSendIpcMission\n");
@ -229,24 +252,33 @@ void McuManagerImpl::ReplyOtherSideSendHeartBeat(const unsigned int &serialNumbe
LogInfo("ReplyOtherSideSendHeartBeat\n"); LogInfo("ReplyOtherSideSendHeartBeat\n");
McuProtocol::ReplyOtherSideSendHearBeat(static_cast<ReplyResult>(ASK_RESULT::SUCCEED), serialNumber); 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); 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<VMcuMonitor> monitor = GetMcuMonitor();
std::shared_ptr<OtherSideSendWithData<unsigned char>> data = std::shared_ptr<McuRecv<unsigned char>> data = std::dynamic_pointer_cast<McuRecv<unsigned char>>(recv);
std::dynamic_pointer_cast<OtherSideSendWithData<unsigned char>>(ask);
if (monitor) { 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(); std::shared_ptr<VMcuMonitor> monitor = GetMcuMonitor();
if (monitor) { if (monitor) {
monitor->RecvMcuHeartBeat(ask); monitor->RecvMcuHeartBeat(recv);
} }
} }

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

@ -22,11 +22,13 @@
#include <map> #include <map>
#include <mutex> #include <mutex>
using std::placeholders::_1; 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 enum class OtherSideSendType
{ {
SEND_IPC_MISSION, SEND_IPC_MISSION,
SEND_HEART_BEAT, SEND_HEART_BEAT,
GET_INTERVAL_START,
GET_DATE_TIME,
END END
}; };
class McuManagerImpl : public McuDevice, public McuProtocol, public std::enable_shared_from_this<McuManagerImpl> 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 * @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. * blocks/freezes, it can be restored by the external microcontroller after powering off and restarting.
* This function has been cancelled.
* @param serialNumber * @param serialNumber
*/ */
void OtherSideSendHearBeat(const unsigned int &serialNumber) override; 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 ReplyOtherSideSendIpcMission(const ASK_RESULT &result, const unsigned int &serialNumber);
void ReplyOtherSideSendHeartBeat(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 private: // About mMcuAskList
void AddMcuAsk(std::shared_ptr<VMcuAsk> &ask); void AddMcuRecv(std::shared_ptr<VMcuRecv> &recv);
void McuAskSendIpcMissionHandle(std::shared_ptr<VMcuAsk> &ask); void McuAskSendIpcMissionHandle(std::shared_ptr<VMcuRecv> &recv);
void McuAskSendHeartBeatHandle(std::shared_ptr<VMcuAsk> &ask); void McuAskSendHeartBeatHandle(std::shared_ptr<VMcuRecv> &recv);
private: private:
std::mutex mMutex; 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 * @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. * 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; std::map<OtherSideSendType, McuAskHandleFunc> mMcuAskHandle;
}; };
#endif #endif

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

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

15
utils/McuProtocol/README.md
View File

@ -129,8 +129,8 @@ unsigned short calculate_check_sum(const unsigned char* pData, unsigned short le
| ---- | ---- | ---- | ---- | ---- | ---- | | ---- | ---- | ---- | ---- | ---- | ---- |
| 0x8101 | ask | - | - | 获取启动模式 | - | | 0x8101 | ask | - | - | 获取启动模式 | - |
| 0x0101 | - | reply | Data[0]:启动模式<br>0x01:PIR启动 <br>0x02:TEST启动 <br>0x03:ON启动 <br>0x04:连拍启动 <br>0x05:PIR延时启动 <br>0x06:定时（间隔一定时间）启动 <br>0x07:关机 <br>0x08:低电关机 <br>0x09:异常启动 | 回复启动模式 | 异常启动数据：Data[1]<br>0x00:喂狗异常启动<br>0x01:超时异常启动 | | 0x0101 | - | reply | Data[0]:启动模式<br>0x01:PIR启动 <br>0x02:TEST启动 <br>0x03:ON启动 <br>0x04:连拍启动 <br>0x05:PIR延时启动 <br>0x06:定时（间隔一定时间）启动 <br>0x07:关机 <br>0x08:低电关机 <br>0x09:异常启动 | 回复启动模式 | 异常启动数据：Data[1]<br>0x00:喂狗异常启动<br>0x01:超时异常启动 |
| 0x8102 | ask | - | - | 断电关机 | - | | 0x8102 | ask | - | - | 断电关机 | 断电关机不用回复 |
| 0x8103 | ask | - | - | 喂狗 | - | | 0x8103 | ask | - | - | 喂狗 | 喂狗不用回复 |
| 0x8104 | ask | - | Data[2]：两字节的数字，单位s | 设置喂狗周期 | 0s代表关闭喂狗 修改为两个字节，单位s | | 0x8104 | ask | - | Data[2]：两字节的数字，单位s | 设置喂狗周期 | 0s代表关闭喂狗 修改为两个字节，单位s |
| 0x0104 | - | reply | Data[0]:结果<br>0x01:成功<br>0x02:失败 | 设置喂狗周期回复 | - | | 0x0104 | - | reply | Data[0]:结果<br>0x01:成功<br>0x02:失败 | 设置喂狗周期回复 | - |
| 0x8105 | ask | - | - | 关闭狗 | 取消 | | 0x8105 | ask | - | - | 关闭狗 | 取消 |
@ -141,8 +141,8 @@ unsigned short calculate_check_sum(const unsigned char* pData, unsigned short le
| 0x0107 | - | reply | Data[0]:结果<br>0x01:成功<br>0x02:失败 | 设置日期和时间回复 | - | | 0x0107 | - | reply | Data[0]:结果<br>0x01:成功<br>0x02:失败 | 设置日期和时间回复 | - |
| 0x8108 | ask | - | Data[0]:灵敏度<br>0-9 | 设置PIR灵敏度 | - | | 0x8108 | ask | - | Data[0]:灵敏度<br>0-9 | 设置PIR灵敏度 | - |
| 0x0108 | - | reply | Data[0]:结果<br>0x01:成功<br>0x02:失败 | 设置PIR灵敏度回复 | - | | 0x0108 | - | reply | Data[0]:结果<br>0x01:成功<br>0x02:失败 | 设置PIR灵敏度回复 | - |
| 0x8109 | ask | - | Data[0]:Hour<br>0-23<br>Data[1]:Min<br>0-59<br>Data[2]:Sec<br>0-59 | 设置连拍间隔 | - | | 0x8109 | ask | - | Data[0]：连拍间隔，单位s | 设置连拍启动 | 设置连拍启动后会立即关机，一般连拍间隔较大时使用该功能，连拍间隔较小时Linux单次完成连拍。 |
| 0x0109 | - | reply | Data[0]:结果<br>0x01:成功<br>0x02:失败 | 设置连拍间隔回复 | - | | 0x0109 | - | reply | Data[0]:结果<br>0x01:成功<br>0x02:失败 | 设置连拍启动回复 | - |
| 0x810A | ask | - | Data[0]:控制模式<br>0-关闭红外灯<br>1-开启红外灯 | 红外灯控制 | 取消 | | 0x810A | ask | - | Data[0]:控制模式<br>0-关闭红外灯<br>1-开启红外灯 | 红外灯控制 | 取消 |
| 0x010A | - | reply | Data[0]:结果<br>0x01:成功<br>0x02:失败 | 红外灯控制回复 | 取消 | | 0x010A | - | reply | Data[0]:结果<br>0x01:成功<br>0x02:失败 | 红外灯控制回复 | 取消 |
| 0x810B | ask | - | - | 获取光敏值 | 取消 | | 0x810B | ask | - | - | 获取光敏值 | 取消 |
@ -152,9 +152,16 @@ unsigned short calculate_check_sum(const unsigned char* pData, unsigned short le
| 0x4101 | - | ask | Data[0]:启动模式<br>0x01:PIR启动 <br>0x02:TEST启动 <br>0x03:ON启动 <br>0x04:连拍启动 <br>0x05:PIR延时启动 <br>0x06:定时（间隔一定时间）启动 <br>0x07:关机 <br>0x08:低电关机 <br>0x09:异常启动 | 发送启动模式 | 异常启动数据：Data[1]<br>0x00:喂狗异常启动<br>0x01:超时异常启动 | | 0x4101 | - | ask | Data[0]:启动模式<br>0x01:PIR启动 <br>0x02:TEST启动 <br>0x03:ON启动 <br>0x04:连拍启动 <br>0x05:PIR延时启动 <br>0x06:定时（间隔一定时间）启动 <br>0x07:关机 <br>0x08:低电关机 <br>0x09:异常启动 | 发送启动模式 | 异常启动数据：Data[1]<br>0x00:喂狗异常启动<br>0x01:超时异常启动 |
| 0xC102 | reply | - | - | 回复心跳包 | 取消 | | 0xC102 | reply | - | - | 回复心跳包 | 取消 |
| 0x4102 | - | ask | - | 发送心跳包 | 取消 | | 0x4102 | - | ask | - | 发送心跳包 | 取消 |
| 0xC106 | reply | - | Data[0]:Hour<br>0-23<br>Data[1]:Min<br>0-59<br>Data[2]:Sec<br>0-59 | 回复获取间隔启动时间 | - |
| 0x4106 | - | ask | - | 获取间隔启动时间 | - |
| 0xC107 | reply | - | Data[0]:Year<br>Data[1]:Mon<br>1-12<br>Data[2]:Day<br>0-31<br>Data[3]:Hour<br>0-23<br>Data[4]:Min<br>0-59<br>Data[5]:Sec<br>0-59 | 回复获取日期和时间 | - |
| 0x4107 | - | ask | - | 获取日期和时间 | - |
| 0xC108 | reply | - | Data[0]:灵敏度<br>0-9 | 回复获取PIR灵敏度 | - |
| 0x4108 | - | ask | - | 获取PIR灵敏度 | - |
### 1.2.1. 名词解析 ### 1.2.1. 名词解析
| 名词 | 解析 | | 名词 | 解析 |
| ---- | ---- | | ---- | ---- |
| 超时异常启动 | MCU给主控上电后（**非TEST启动**），不管主控是否正常喂狗，如果单次上电时长超过3min未关机，给主控断电重启一次。 | | 超时异常启动 | MCU给主控上电后（**非TEST启动**），不管主控是否正常喂狗，如果单次上电时长超过3min未关机，给主控断电重启一次。 |
| 间隔启动时间 | 例如：60min/次。 |

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

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

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

@ -16,12 +16,27 @@
#include "ILog.h" #include "ILog.h"
#include "ProtocolHandle.h" #include "ProtocolHandle.h"
#include <string.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::OtherSideSendIpcMission(const unsigned int &serialNumber, const unsigned char &mission)
{ {
} }
void OtherSideAsk::OtherSideSendHearBeat(const unsigned int &serialNumber) 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) std::shared_ptr<VProtocolRecv> &VProtocolRecv::GetInstance(std::shared_ptr<VProtocolRecv> *impl)
{ {
static auto instance = std::make_shared<VProtocolRecv>(); 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) void McuProtocol::ReplyOtherSideSendHearBeat(const ReplyResult &result, const unsigned int &serialNumber)
{ {
std::shared_ptr<VProtocolContext> NULL_CONTEXT; 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::shared_ptr<VProtocolParam> param =
std::make_shared<VProtocolParam>(PROTOCOL_COMMAND::REPLY_OTHER_SIDE_ASK_SEND_HEART_BEAT); std::make_shared<VProtocolParam>(PROTOCOL_COMMAND::REPLY_OTHER_SIDE_ASK_SEND_HEART_BEAT);
param->mSerialNumber = serialNumber; param->mSerialNumber = serialNumber;

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

@ -240,6 +240,21 @@ void ProtocolHandle::AnalyzeOtherSideSendHeartBeatPacket(const ProtocolPacket &p
LogInfo("AnalyzeOtherSideSendHeartBeatPacket\n"); LogInfo("AnalyzeOtherSideSendHeartBeatPacket\n");
VProtocolRecv::GetInstance()->OtherSideSendHearBeat(mProtocolSerialNumber); 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) bool ProtocolHandle::CheckoutTheCheckCode(const ProtocolPacket &packet)
{ {
short code = calculate_check_sum(mProtocolData, mProtocolDataLength - CHECK_CODE_LENGTH); 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, REPLY_OTHER_SIDE_ASK_SEND_IPC_MISSION = 0xC101,
OTHER_SIDE_ASK_SEND_IPC_MISSION = 0x4101, OTHER_SIDE_ASK_SEND_IPC_MISSION = 0x4101,
REPLY_OTHER_SIDE_ASK_SEND_HEART_BEAT = 0xC102, REPLY_OTHER_SIDE_ASK_SEND_HEART_BEAT = 0xC102, // Temporarily cancelled, reserved.
OTHER_SIDE_ASK_SEND_HEART_BEAT = 0x4102, 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 PROTOCOL_COMMAND_END
}; };
constexpr unsigned char ZERO_MEANS_SHUTDOWN_WATCH_DOG = 0x00; constexpr unsigned char ZERO_MEANS_SHUTDOWN_WATCH_DOG = 0x00;
@ -185,6 +191,9 @@ private:
void AnalyzeReplyIpcMissionPacket(const ProtocolPacket &packet); void AnalyzeReplyIpcMissionPacket(const ProtocolPacket &packet);
void AnalyzeOtherSideSendIpcMissionPacket(const ProtocolPacket &packet); void AnalyzeOtherSideSendIpcMissionPacket(const ProtocolPacket &packet);
void AnalyzeOtherSideSendHeartBeatPacket(const ProtocolPacket &packet); void AnalyzeOtherSideSendHeartBeatPacket(const ProtocolPacket &packet);
void AnalyzeOtherSideSendGetIntervalStart(const ProtocolPacket &packet);
void AnalyzeOtherSideSendGetDataTime(const ProtocolPacket &packet);
void AnalyzeOtherSideSendGetPirSensitivity(const ProtocolPacket &packet);
private: private:
virtual void BigEndianConversion(ProtocolPacket &packet) virtual void BigEndianConversion(ProtocolPacket &packet)