Germany/embedded-framework
7
0
Fork 0
mirror of https://gitee.com/jiuyilian/embedded-framework.git synced 2025-01-06 10:16:51 -05:00
Code Issues Actions Packages Projects 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

234
middleware/McuManager/README.md
View File

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

17
utils/McuProtocol/README.md
View File

@ -129,8 +129,8 @@ unsigned short calculate_check_sum(const unsigned char* pData, unsigned short le
| ---- | ---- | ---- | ---- | ---- | ---- |
| 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:超时异常启动 |
| 0x8102 | ask | - | - | 断电关机 | - |
| 0x8103 | ask | - | - | 喂狗 | - |
| 0x8102 | ask | - | - | 断电关机 | 断电关机不用回复 |
| 0x8103 | ask | - | - | 喂狗 | 喂狗不用回复 |
| 0x8104 | ask | - | Data[2]：两字节的数字，单位s | 设置喂狗周期 | 0s代表关闭喂狗 修改为两个字节，单位s |
| 0x0104 | - | reply | Data[0]:结果<br>0x01:成功<br>0x02:失败 | 设置喂狗周期回复 | - |
| 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:失败 | 设置日期和时间回复 | - |
| 0x8108 | ask | - | Data[0]:灵敏度<br>0-9 | 设置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 | 设置连拍间隔 | - |
| 0x0109 | - | reply | Data[0]:结果<br>0x01:成功<br>0x02:失败 | 设置连拍间隔回复 | - |
| 0x8109 | ask | - | Data[0]：连拍间隔，单位s | 设置连拍启动 | 设置连拍启动后会立即关机，一般连拍间隔较大时使用该功能，连拍间隔较小时Linux单次完成连拍。 |
| 0x0109 | - | reply | Data[0]:结果<br>0x01:成功<br>0x02:失败 | 设置连拍启动回复 | - |
| 0x810A | ask | - | Data[0]:控制模式<br>0-关闭红外灯<br>1-开启红外灯 | 红外灯控制 | 取消 |
| 0x010A | - | reply | Data[0]:结果<br>0x01:成功<br>0x02:失败 | 红外灯控制回复 | 取消 |
| 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:超时异常启动 |
| 0xC102 | reply | - | - | 回复心跳包 | 取消 |
| 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. 名词解析
| 名词 | 解析 |
| ---- | ---- |
| 超时异常启动 | MCU给主控上电后（**非TEST启动**），不管主控是否正常喂狗，如果单次上电时长超过3min未关机，给主控断电重启一次。 |
| 超时异常启动 | MCU给主控上电后（**非TEST启动**），不管主控是否正常喂狗，如果单次上电时长超过3min未关机，给主控断电重启一次。 |
| 间隔启动时间 | 例如：60min/次。 |

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)