Backup McuManager module.

application/MissionManager/src/MissionStateMachine.cpp

@@ -38,7 +38,7 @@ void MissionStateMachine::Init(void)
         LogError("State machine init failed.\n");
         return;
     }
-    mStartMission = IDeviceManager::GetInstance()->GetIpcMissiony();
+    mStartMission = IDeviceManager::GetInstance()->GetIpcMission();
     RunStateMachine(mStartMission);
 }
 void MissionStateMachine::UnInit(void)

middleware/DeviceManager/include/IDeviceManager.h

@@ -56,7 +56,7 @@ public:
     static std::shared_ptr<IDeviceManager> &GetInstance(std::shared_ptr<IDeviceManager> *impl = nullptr);
     virtual const StatusCode Init(void) { return CreateStatusCode(STATUS_CODE_OK); }
     virtual const StatusCode UnInit(void) { return CreateStatusCode(STATUS_CODE_OK); }
-    virtual const IpcMission GetIpcMissiony(void) { return IpcMission::END; }
+    virtual const IpcMission GetIpcMission(void) { return IpcMission::END; }
     virtual const StatusCode ISetLedState(std::string ledName, LedState &CurrentState,
                                           const unsigned int &KeepAliveTime, const unsigned int &BlinkPeriod)
     {

middleware/DeviceManager/src/DeviceManager.cpp

@@ -39,7 +39,7 @@ const StatusCode DeviceManager::UnInit(void)
     return CreateStatusCode(STATUS_CODE_OK);
 }
 
-const IpcMission DeviceManager::GetIpcMissiony(void) { return IpcMission::TEST; }
+const IpcMission DeviceManager::GetIpcMission(void) { return IpcMission::TEST; }
 
 const StatusCode DeviceManager::ISetLedState(std::string ledName, LedState &CurrentState,
                                              const unsigned int &KeepAliveTime, const unsigned int &BlinkPeriod)

middleware/DeviceManager/src/DeviceManager.h

@@ -25,7 +25,7 @@ public:
 
     const StatusCode Init(void) override;
     const StatusCode UnInit(void) override;
-    const IpcMission GetIpcMissiony(void) override;
+    const IpcMission GetIpcMission(void) override;
     const StatusCode ISetLedState(std::string ledName, LedState &CurrentState,
                                   const unsigned int &KeepAliveTime = DEFAULT_KEEP_ALIVE_TIME,
                                   const unsigned int &BlinkPeriod = LED_NOT_BLINK) override;

middleware/McuManager/include/IMcuManager.h

@@ -37,6 +37,7 @@ public:
     virtual ASK_RESULT Blocking(void) { return ASK_RESULT::END; }
     virtual void StopBlocking(void) {}
     virtual bool NeedReply(void) { return false; }
+    virtual void ReplyFinished(const bool result) {}
 
 public:
     /**
@@ -56,6 +57,12 @@ public:
 public:
     T mDataReply;
 };
+class McuMonitor
+{
+public:
+    McuMonitor() = default;
+    virtual ~McuMonitor() = default;
+};
 class IMcuManager
 {
 public:
@@ -64,7 +71,7 @@ public:
     static std::shared_ptr<IMcuManager> &GetInstance(std::shared_ptr<IMcuManager> *impl = nullptr);
     virtual const StatusCode Init(void) { return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION); }
     virtual const StatusCode UnInit(void) { return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION); }
-    virtual const StatusCode GetIpcMissiony(std::shared_ptr<VMcuAsk> ask)
+    virtual const StatusCode GetIpcMission(std::shared_ptr<VMcuAsk> ask)
     {
         return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
     }

middleware/McuManager/src/McuDevice.cpp

@@ -87,6 +87,19 @@ size_t McuDevice::WriteData(const void *buff, const size_t buffLength, std::shar
     }
     return length;
 }
+void McuDevice::GetIpcMissionReply(const unsigned int &serialNumber, const unsigned char &mission)
+{
+    std::shared_ptr<VMcuAsk> ask;
+    SearchMcuAsk(serialNumber, ask);
+    if (ask) {
+        std::shared_ptr<McuAsk<IpcMission>> realAsk = std::dynamic_pointer_cast<McuAsk<IpcMission>>(ask);
+        if (realAsk) {
+            realAsk->mDataReply = static_cast<IpcMission>(mission);
+            ask->ReplyFinished(true);
+        }
+        ask->ReplyFinished(false);
+    }
+}
 void McuDevice::DeviceRecvThread(void)
 {
     constexpr int RECV_TIMEOUT_MS = 1000;
@@ -156,6 +169,22 @@ void McuDevice::AddMcuAsk(std::shared_ptr<VMcuAsk> &ask)
         mAllAsk.push_back(ask);
     }
 }
+void McuDevice::SearchMcuAsk(unsigned int serialNumber, std::shared_ptr<VMcuAsk> &ask)
+{
+    std::lock_guard<std::mutex> locker(mMutex);
+    for (auto iter = mAllAsk.begin(); iter != mAllAsk.end(); ++iter) {
+        std::shared_ptr<VMcuAsk> listData = *iter;
+        if (!listData) {
+            LogError("Illegal data.\n");
+            continue;
+        }
+        if (serialNumber == listData->mSerialNumber) {
+            ask = listData;
+            return;
+        }
+    }
+    LogWarning("Can't find mcu ask recork.\n");
+}
 void McuDevice::DeleteMcuAsk(std::shared_ptr<VMcuAsk> &ask)
 {
     //

middleware/McuManager/src/McuDevice.h

@@ -20,22 +20,28 @@
 #include <list>
 #include <mutex>
 #include <thread>
-class McuDevice : public IMcuManager, virtual public VProtocolBase
+class McuDevice : public IMcuManager, virtual public VProtocolBase, public VProtocolRecv
 {
 public:
     McuDevice();
     virtual ~McuDevice();
     const StatusCode Init(void) override;
     const StatusCode UnInit(void) override;
+
+public:
     size_t WriteData(const void *buff, const size_t buffLength, std::shared_ptr<VProtocolContext> &context,
                      const unsigned int &serialNumber) override;
 
+public:
+    void GetIpcMissionReply(const unsigned int &serialNumber, const unsigned char &mission) override;
+
 public:
     void DeviceRecvThread(void);
 
 private:
     void DeviceRecvData(const char *keyHead, const size_t headLength);
     void AddMcuAsk(std::shared_ptr<VMcuAsk> &ask);
+    void SearchMcuAsk(unsigned int serialNumber, std::shared_ptr<VMcuAsk> &ask);
     void DeleteMcuAsk(std::shared_ptr<VMcuAsk> &ask);
 
 private:

middleware/McuManager/src/McuManagerImpl.cpp

@@ -26,10 +26,10 @@ const StatusCode McuManagerImpl::UnInit(void)
     McuProtocol::UnInit();
     return CreateStatusCode(STATUS_CODE_OK);
 }
-const StatusCode McuManagerImpl::GetIpcMissiony(std::shared_ptr<VMcuAsk> ask)
+const StatusCode McuManagerImpl::GetIpcMission(std::shared_ptr<VMcuAsk> ask)
 {
     std::shared_ptr<VProtocolContext> context = std::make_shared<ProtocolContext<std::shared_ptr<VMcuAsk>>>(ask);
-    McuProtocol::GetIpcMissiony(context);
+    McuProtocol::GetIpcMission(context);
     // IpcMission mission = static_cast<IpcMission>(data);
     return CreateStatusCode(STATUS_CODE_OK);
 }

middleware/McuManager/src/McuManagerImpl.h

@@ -25,6 +25,6 @@ public:
     std::shared_ptr<VProtocolBase> SharedFromThis(void) override;
     const StatusCode Init(void) override;
     const StatusCode UnInit(void) override;
-    const StatusCode GetIpcMissiony(std::shared_ptr<VMcuAsk> ask) override;
+    const StatusCode GetIpcMission(std::shared_ptr<VMcuAsk> ask) override;
 };
 #endif

test/middleware/McuManager/src_mock/McuManager_Mock_Test.cpp

@@ -51,7 +51,7 @@ TEST_F(McuManagerMockTest, INTEGRATION_McuManager_EXAMPLE_GetIpcMissiony)
     };
     IMcuManager::GetInstance()->Init();
     std::shared_ptr<VMcuAsk> ask = std::make_shared<McuAskTest>();
-    IMcuManager::GetInstance()->GetIpcMissiony(ask);
+    IMcuManager::GetInstance()->GetIpcMission(ask);
     std::this_thread::sleep_for(std::chrono::milliseconds(2000));
     IMcuManager::GetInstance()->UnInit();
 }

utils/McuProtocol/include/McuProtocol.h

@@ -75,6 +75,14 @@ protected:
 
 public:
 };
+class VProtocolRecv
+{
+public:
+    VProtocolRecv() = default;
+    virtual ~VProtocolRecv() = default;
+    static std::shared_ptr<VProtocolRecv> &GetInstance(std::shared_ptr<VProtocolRecv> *impl = nullptr);
+    virtual void GetIpcMissionReply(const unsigned int &serialNumber, const unsigned char &mission) {}
+};
 class McuProtocol : virtual public VProtocolBase
 {
 public:
@@ -82,7 +90,7 @@ public:
     virtual ~McuProtocol() = default;
     const StatusCode Init(void);
     const StatusCode UnInit(void);
-    const StatusCode GetIpcMissiony(std::shared_ptr<VProtocolContext> &context);
+    const StatusCode GetIpcMission(std::shared_ptr<VProtocolContext> &context);
     void DataHandleThread(void);
 
 protected:

utils/McuProtocol/src/McuProtocol.cpp

@@ -18,12 +18,27 @@
 #include <string.h>
 constexpr int THREAD_SHARING = 0;
 constexpr int INITIAL_VALUE_OF_SEMAPHORE = 0;
+std::shared_ptr<VProtocolRecv> &VProtocolRecv::GetInstance(std::shared_ptr<VProtocolRecv> *impl)
+{
+    static auto instance = std::make_shared<VProtocolRecv>();
+    if (impl) {
+        instance = *impl;
+    }
+    return instance;
+}
 const StatusCode McuProtocol::Init(void)
 {
     sem_init(&mSem, THREAD_SHARING, INITIAL_VALUE_OF_SEMAPHORE);
     auto dataHandleThread = [](std::shared_ptr<McuProtocol> handle) { handle->DataHandleThread(); };
     std::shared_ptr<McuProtocol> handle = std::dynamic_pointer_cast<McuProtocol>(SharedFromThis());
     mDataHandleThread = std::thread(dataHandleThread, handle);
+    std::shared_ptr<VProtocolRecv> reply = std::dynamic_pointer_cast<VProtocolRecv>(SharedFromThis());
+    if (reply) {
+        VProtocolRecv::GetInstance(&reply);
+    }
+    else {
+        LogWarning("The VProtocolRecv class has not been overloaded, which can result in incomplete functionality.\n");
+    }
     return CreateStatusCode(STATUS_CODE_OK);
 }
 const StatusCode McuProtocol::UnInit(void)
@@ -36,7 +51,7 @@ const StatusCode McuProtocol::UnInit(void)
     sem_destroy(&mSem);
     return CreateStatusCode(STATUS_CODE_OK);
 }
-const StatusCode McuProtocol::GetIpcMissiony(std::shared_ptr<VProtocolContext> &context)
+const StatusCode McuProtocol::GetIpcMission(std::shared_ptr<VProtocolContext> &context)
 {
     char data = 0;
     std::shared_ptr<VProtocolParam> param =

utils/McuProtocol/src/ProtocolHandle.cpp

@@ -14,6 +14,7 @@
  */
 #include "ProtocolHandle.h"
 #include "ILog.h"
+#include "McuProtocol.h"
 #include "McuProtocolMakePtr.h"
 #include "ModBusCRC16.h"
 #include <netinet/in.h>
@@ -107,6 +108,7 @@ void ProtocolHandle::AnalyzeReplyIpcMissionPacket(const ProtocolPacket &packet)
     unsigned char ipcMission = UNKNOWN_MISSION;
     ipcMission = mProtocolData[PROTOCOL_DATA_START_ADDRESS];
     LogInfo("ipc mission = 0x%02X\n", ipcMission);
+    VProtocolRecv::GetInstance()->GetIpcMissionReply(packet.mSerialNumber, ipcMission);
 }
 std::shared_ptr<ProtocolHandle> ProtocolHandle::CreateProtocolData(const std::shared_ptr<VProtocolParam> &param)
 {