Fixed:McuProtocol test tool bug.

application/HunttingCamera/build/huntting_camera.cmake

@@ -1,8 +1,10 @@
 
 set(HUNTTING_MAIN_INCLUDE_PATH     "${APPLICATION_SOURCE_PATH}/HunttingCamera/src")
+set(HUNTTING_MAIN_INCLUDE_PATH     "${HUNTTING_MAIN_INCLUDE_PATH};${APPLICATION_SOURCE_PATH}/MissionManager/include")
+set(HUNTTING_MAIN_INCLUDE_PATH     "${HUNTTING_MAIN_INCLUDE_PATH};${MIDDLEWARE_SOURCE_PATH}/StateMachine/include")
+set(HUNTTING_MAIN_INCLUDE_PATH     "${HUNTTING_MAIN_INCLUDE_PATH};${MIDDLEWARE_SOURCE_PATH}/McuManager/include")
 set(HUNTTING_MAIN_INCLUDE_PATH     "${HUNTTING_MAIN_INCLUDE_PATH};${UTILS_SOURCE_PATH}/StatusCode/include")
 set(HUNTTING_MAIN_INCLUDE_PATH     "${HUNTTING_MAIN_INCLUDE_PATH};${UTILS_SOURCE_PATH}/Log/include")
-set(HUNTTING_MAIN_INCLUDE_PATH     "${HUNTTING_MAIN_INCLUDE_PATH};${APPLICATION_SOURCE_PATH}/MissionManager/include")
 set(HUNTTING_MAIN_INCLUDE_PATH     "${HUNTTING_MAIN_INCLUDE_PATH};${HAL_SOURCE_PATH}/include")
 
-set(HUNTTING_LINK_LIB MissionManager StatusCode Log Hal pthread dl)
+set(HUNTTING_LINK_LIB McuManager MissionManager StateMachine StatusCode Log Hal pthread dl)

application/HunttingCamera/src/MainThread.cpp

@@ -15,7 +15,9 @@
 #include "MainThread.h"
 #include "IHalCpp.h"
 #include "ILog.h"
+#include "IMcuManager.h"
 #include "IMissionManager.h"
+#include "IStateMachine.h"
 #include <thread>
 MainThread::MainThread() { mMainThreadRuning = false; }
 std::shared_ptr<MainThread> &MainThread::GetInstance(std::shared_ptr<MainThread> *impl)
@@ -39,12 +41,15 @@ StatusCode MainThread::Init(void)
     CustomizationInit();
     mMainThreadRuning = true;
     CreateAllModules();
-    // IHalInit();
     IHalCpp::GetInstance()->Init();
+    IMcuManager::GetInstance()->Init();
+    IMissionManager::GetInstance()->Init();
     return CreateStatusCode(STATUS_CODE_OK);
 }
 StatusCode MainThread::UnInit(void)
 {
+    IMissionManager::GetInstance()->UnInit();
+    IMcuManager::GetInstance()->UnInit();
     IHalCpp::GetInstance()->UnInit();
     DestoryAllModules();
     ILogUnInit();
@@ -53,12 +58,16 @@ StatusCode MainThread::UnInit(void)
 StatusCode MainThread::CreateAllModules(void)
 {
     CreateHalCppModule();
+    CreateMcuManager();
     CreateMissionManagerModule();
+    CreateStateMachine();
     return CreateStatusCode(STATUS_CODE_OK);
 }
 void MainThread::DestoryAllModules(void)
 {
+    DestroyStateMachine();
     DestroyMissionManagerModule();
+    DestroyMcuManager();
     DestroyHalCppModule();
 }
 void MainThread::ResetAllPtrMaker(void) {}

application/MissionManager/CMakeLists.txt

@@ -9,7 +9,9 @@ include_directories(
     ${UTILS_SOURCE_PATH}/StatusCode/include
     ${UTILS_SOURCE_PATH}/Log/include
     ${MIDDLEWARE_SOURCE_PATH}/StateMachine/include
-    ${MIDDLEWARE_SOURCE_PATH}/DeviceManager/include
+    # ${MIDDLEWARE_SOURCE_PATH}/DeviceManager/include
+    ${MIDDLEWARE_SOURCE_PATH}/McuManager/include
+    ${MIDDLEWARE_SOURCE_PATH}/McuAskBase/include
 )
 #do not rely on any other library
 #link_directories(
@@ -20,7 +22,7 @@ aux_source_directory(./src SRC_FILES)
 set(TARGET_NAME MissionManager)
 add_library(${TARGET_NAME} STATIC ${SRC_FILES})
 
-target_link_libraries(${TARGET_NAME} StatusCode Log)
+target_link_libraries(${TARGET_NAME} McuAskBase StateMachine StatusCode Log)
 
 if ("${CLANG_TIDY_SUPPORT}" MATCHES "true")
 add_custom_target(

application/MissionManager/src/IMissionManager.cpp

@@ -28,5 +28,5 @@ std::shared_ptr<IMissionManager> &IMissionManager::GetInstance(std::shared_ptr<I
     }
     return instance;
 }
-const StatusCode IMissionManager::Init(void) { return CreateStatusCode(STATUS_CODE_OK); }
+const StatusCode IMissionManager::Init(void) { return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION); }
-const StatusCode IMissionManager::UnInit(void) { return CreateStatusCode(STATUS_CODE_OK); }
+const StatusCode IMissionManager::UnInit(void) { return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION); }

application/MissionManager/src/MissionManager.cpp

@@ -11,4 +11,16 @@
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */
+ */
+#include "MissionManager.h"
+#include "MissionStateMachine.h"
+const StatusCode MissionManager::Init(void)
+{
+    MissionStateMachine::GetInstance()->Init();
+    return CreateStatusCode(STATUS_CODE_OK);
+}
+const StatusCode MissionManager::UnInit(void)
+{
+    MissionStateMachine::GetInstance()->UnInit();
+    return CreateStatusCode(STATUS_CODE_OK);
+}

application/MissionManager/src/MissionManager.h

@@ -20,5 +20,7 @@ class MissionManager : public IMissionManager
 public:
     MissionManager() = default;
     virtual ~MissionManager() = default;
+    const StatusCode Init(void) override;
+    const StatusCode UnInit(void) override;
 };
 #endif

application/MissionManager/src/MissionManagerMakePtr.cpp

@@ -14,6 +14,7 @@
  */
 #include "MissionManagerMakePtr.h"
 #include "ILog.h"
+#include "MissionManager.h"
 #include "TopState.h"
 bool CreateMissionManagerModule(void)
 {
@@ -48,6 +49,7 @@ std::shared_ptr<MissionManagerMakePtr> &MissionManagerMakePtr::GetInstance(std::
 }
 const StatusCode MissionManagerMakePtr::CreateMissionManagerInstance(std::shared_ptr<IMissionManager> &instance)
 {
+    instance = std::make_shared<MissionManager>();
     return CreateStatusCode(STATUS_CODE_OK);
 }
 std::shared_ptr<State> MissionManagerMakePtr::CreateTopState(void)

application/MissionManager/src/MissionStateMachine.cpp

@@ -14,6 +14,7 @@
  */
 #include "MissionStateMachine.h"
 #include "ILog.h"
+#include "McuAskBase.h"
 #include "MissionManagerMakePtr.h"
 #include "TopState.h"
 std::shared_ptr<MissionStateMachine> &MissionStateMachine::GetInstance(std::shared_ptr<MissionStateMachine> *impl)
@@ -24,21 +25,50 @@ std::shared_ptr<MissionStateMachine> &MissionStateMachine::GetInstance(std::shar
     }
     return instance;
 }
+MissionStateMachine::MissionStateMachine()
+{
+    //
+    mStartMission = IpcMission::END;
+}
 void MissionStateMachine::Init(void)
 {
+    mStateMachine = std::make_shared<VStateMachineHandle>();
     auto code = IStateMachine::GetInstance()->CreateStateMachine(mStateMachine);
-    if (IsCodeOK(code)) {
+    if (!IsCodeOK(code)) {
-        LogError("Create state machine failed.\n");
+        LogError("Create state machine failed[%s].\n", code.mPrintStringCode(code));
         return;
     }
     if (!mStateMachine->InitialStateMachine()) {
         LogError("State machine init failed.\n");
         return;
     }
-    // mStartMission = IDeviceManager::GetInstance()->GetIpcMission();
+    mStartMission = GetStartMission();
-    // RunStateMachine(mStartMission);
+    if (mStartMission != IpcMission::END) {
+        // RunStateMachine(mStartMission);
+    }
+    else {
+        LogError("ipcmission error.\n");
+    }
+}
+void MissionStateMachine::UnInit(void)
+{
+    //
+}
+IpcMission MissionStateMachine::GetStartMission(void)
+{
+    class McuAskIpcMission : public McuAsk<IpcMission>, public McuAskBase
+    {
+    public:
+        McuAskIpcMission() : McuAskBase(McuAskBlock::NOT_BLOCK, McuAskReply::NEED_REPLY)
+        {
+            mDataReply = IpcMission::END;
+        }
+        virtual ~McuAskIpcMission() = default;
+    };
+    std::shared_ptr<VMcuAsk> ask = std::make_shared<McuAskIpcMission>();
+    IMcuManager::GetInstance()->GetIpcMission(ask);
+    return std::dynamic_pointer_cast<McuAskIpcMission>(ask)->mDataReply;
 }
-void MissionStateMachine::UnInit(void) {}
 // void MissionStateMachine::RunStateMachine(const IpcMission &mission)
 // {
 //     LogInfo("Make all states and start the state machine.\n");

application/MissionManager/src/MissionStateMachine.h

@@ -14,7 +14,8 @@
  */
 #ifndef MISSIONSTATEMACHINE_H
 #define MISSIONSTATEMACHINE_H
-#include "IDeviceManager.h"
+// #include "IDeviceManager.h"
+#include "IMcuManager.h"
 #include "IMissionManager.h"
 #include "IStateMachine.h"
 #include <map>
@@ -26,18 +27,19 @@ enum class MissionState
 class MissionStateMachine
 {
 public:
-    MissionStateMachine() = default;
+    MissionStateMachine();
     virtual ~MissionStateMachine() = default;
     static std::shared_ptr<MissionStateMachine> &GetInstance(std::shared_ptr<MissionStateMachine> *impl = nullptr);
     void Init(void);
     void UnInit(void);
 
 private:
+    IpcMission GetStartMission(void);
     // void RunStateMachine(const IpcMission &mission);
 
 private:
     std::shared_ptr<VStateMachineHandle> mStateMachine;
     std::map<MissionState, std::shared_ptr<State>> mStateTree;
-    // IpcMission mStartMission;
+    IpcMission mStartMission;
 };
 #endif

middleware/GuiEngine/CMakeLists.txt

@@ -5,7 +5,6 @@ set(LIBRARY_OUTPUT_PATH ${LIBS_OUTPUT_PATH})
 include_directories(
     ./src
     ./include
-    ${COMPONENT_SOURCE_PATH}/ReturnCode/include
     ${COMPONENT_SOURCE_PATH}/Log/include
 )
 

middleware/StateMachine/CMakeLists.txt

@@ -21,7 +21,7 @@ aux_source_directory(./src/OpenHarmony SRC_FILES_OPENHARMONY)
 set(TARGET_NAME StateMachine)
 add_library(${TARGET_NAME} STATIC ${SRC_FILES} ${SRC_FILES_OPENHARMONY})
 
-target_link_libraries(${TARGET_NAME} ReturnCode Log)
+target_link_libraries(${TARGET_NAME} Log)
 
 if ("${CLANG_TIDY_SUPPORT}" MATCHES "true")
 add_custom_target(

middleware/StateMachine/include/IStateMachine.h

@@ -18,6 +18,7 @@
 #include <iostream>
 #include <memory>
 bool CreateStateMachine(void);
+bool DestroyStateMachine(void);
 class VStateMessage
 {
 public:

middleware/StateMachine/src/StateMachineMakePtr.cpp

@@ -29,6 +29,12 @@ bool CreateStateMachine(void)
     }
     return false;
 }
+bool DestroyStateMachine(void)
+{
+    auto instance = std::make_shared<IStateMachine>();
+    IStateMachine::GetInstance(&instance);
+    return true;
+}
 std::shared_ptr<StateMachineMakePtr> &StateMachineMakePtr::GetInstance(std::shared_ptr<StateMachineMakePtr> *impl)
 {
     static auto instance = std::make_shared<StateMachineMakePtr>();
@@ -42,6 +48,7 @@ StatusCode StateMachineMakePtr::CreateStateMachine(std::shared_ptr<VStateMachine
     // TODO: need a name ?
     auto tmp = std::make_shared<StateMachine>("TODO");
     if (tmp) {
+        LogInfo("Create state machine module successfully.\n");
         stateMachine = std::move(tmp);
         return CreateStatusCode(STATUS_CODE_OK);
     }

test/application/HunttingCamera/CMakeLists.txt

@@ -26,7 +26,7 @@ endif()
 
 set(TARGET_NAME HunttingCameraTest)
 add_executable(${TARGET_NAME} ${SRC_FILES_MAIN} ${SRC_FILES})
-target_link_libraries(${TARGET_NAME} HunttingMainLib TestManager gtest gmock pthread)
+target_link_libraries(${TARGET_NAME} HunttingMainLib McuManagerTestTool TestManager gtest gmock pthread)
 if(${TEST_COVERAGE} MATCHES "true")
     target_link_libraries(${TARGET_NAME} gcov)
 endif()

test/application/HunttingCamera/src/HunttingCamera_Test.cpp

@@ -52,7 +52,7 @@ public:
 TEST_F(HunttingCameraTest, INTEGRATION_DeviceManager_EXAMPLE_Demo)
 {
     MainThread::GetInstance()->Init();
-    ResetTimeOut(1000 * 3);
+    TestManager::ResetTimeOut(1000 * 3);
     MainThread::GetInstance()->Runing();
     MainThread::GetInstance()->UnInit();
 }

test/utils/McuProtocol/tool/src/McuProtocolTestTool.cpp

@@ -231,8 +231,14 @@ bool McuProtocolTestTool::IpcMissionProtocolHandle(std::shared_ptr<LinuxTest> &m
         int result = memcmp(
             (unsigned char *)buf + count - PROTOCOL_CHECK_CODE_LENGTH, &askCheckCode, PROTOCOL_CHECK_CODE_LENGTH);
         EXPECT_EQ(result, 0) << "ask protocol data errer, check code isn't right.";
+        unsigned char *bufHandle = (unsigned char *)malloc(count);
+        if (nullptr == bufHandle) {
+            LogError("malloc failed.\n");
+            return PROTOCOL_HANDLED;
+        }
+        memcpy(bufHandle, buf, count);
         auto handle = [=, &mock](McuProtocolTestTool *testTool) {
-            testTool->IpcMissionProtocolInit(mock, uartFd, buf, count);
+            testTool->IpcMissionProtocolInit(mock, uartFd, bufHandle, count);
         };
         if (mLockThread.joinable()) {
             mLockThread.join();
@@ -249,6 +255,7 @@ void McuProtocolTestTool::IpcMissionProtocolInit(std::shared_ptr<LinuxTest> &moc
     memcpy(REPLY_IPC_MISSION_X + PROTOCOL_SERIAL_NUMBER_OFFSET,
            (unsigned char *)buf + PROTOCOL_SERIAL_NUMBER_OFFSET,
            PROTOCOL_SERIAL_NUMBER_LENGTH);
+    free((void *)buf);
     ResetCheckCode(REPLY_IPC_MISSION_X, sizeof(REPLY_IPC_MISSION_X));
     ReplySelectSucceed(mock, uartFd);
     constexpr int LEFT_DATA_LENGTH = sizeof(REPLY_IPC_MISSION_X) - PROTOCOL_DATA_KEY_HEAD_LENGTH;
@@ -315,8 +322,14 @@ bool McuProtocolTestTool::FeedingCycleProtocolHandle(std::shared_ptr<LinuxTest>
         int result = memcmp(
             (unsigned char *)buf + count - PROTOCOL_CHECK_CODE_LENGTH, &askCheckCode, PROTOCOL_CHECK_CODE_LENGTH);
         EXPECT_EQ(result, 0) << "ask protocol data errer, check code isn't right.";
+        unsigned char *bufHandle = (unsigned char *)malloc(count);
+        if (nullptr == bufHandle) {
+            LogError("malloc failed.\n");
+            return PROTOCOL_HANDLED;
+        }
+        memcpy(bufHandle, buf, count);
         auto handle = [=, &mock](McuProtocolTestTool *testTool) {
-            testTool->FeedingCycleProtocolInit(mock, uartFd, buf, count);
+            testTool->FeedingCycleProtocolInit(mock, uartFd, bufHandle, count);
         };
         if (mLockThread.joinable()) {
             mLockThread.join();
@@ -334,6 +347,7 @@ void McuProtocolTestTool::FeedingCycleProtocolInit(std::shared_ptr<LinuxTest> &m
     memcpy(REPLY_SET_FEEDING_CYCLE_X + PROTOCOL_SERIAL_NUMBER_OFFSET,
            (unsigned char *)buf + PROTOCOL_SERIAL_NUMBER_OFFSET,
            PROTOCOL_SERIAL_NUMBER_LENGTH);
+    free((void *)buf);
     ResetCheckCode(REPLY_SET_FEEDING_CYCLE_X, sizeof(REPLY_SET_FEEDING_CYCLE_X));
     ReplySelectSucceed(mock, uartFd);
     constexpr int LEFT_DATA_LENGTH = sizeof(REPLY_SET_FEEDING_CYCLE_X) - PROTOCOL_DATA_KEY_HEAD_LENGTH;
@@ -366,8 +380,14 @@ bool McuProtocolTestTool::SetDataTimeProtocolHandle(std::shared_ptr<LinuxTest> &
         int result = memcmp(
             (unsigned char *)buf + count - PROTOCOL_CHECK_CODE_LENGTH, &askCheckCode, PROTOCOL_CHECK_CODE_LENGTH);
         EXPECT_EQ(result, 0) << "ask protocol data errer, check code isn't right.";
+        unsigned char *bufHandle = (unsigned char *)malloc(count);
+        if (nullptr == bufHandle) {
+            LogError("malloc failed.\n");
+            return PROTOCOL_HANDLED;
+        }
+        memcpy(bufHandle, buf, count);
         auto handle = [=, &mock](McuProtocolTestTool *testTool) {
-            testTool->SetDataTimeProtocolInit(mock, uartFd, buf, count);
+            testTool->SetDataTimeProtocolInit(mock, uartFd, bufHandle, count);
         };
         if (mLockThread.joinable()) {
             mLockThread.join();
@@ -384,6 +404,7 @@ void McuProtocolTestTool::SetDataTimeProtocolInit(std::shared_ptr<LinuxTest> &mo
     memcpy(REPLY_SET_DATE_TIME_X + PROTOCOL_SERIAL_NUMBER_OFFSET,
            (unsigned char *)buf + PROTOCOL_SERIAL_NUMBER_OFFSET,
            PROTOCOL_SERIAL_NUMBER_LENGTH);
+    free((void *)buf);
     ResetCheckCode(REPLY_SET_DATE_TIME_X, sizeof(REPLY_SET_DATE_TIME_X));
     ReplySelectSucceed(mock, uartFd);
     constexpr int LEFT_DATA_LENGTH = sizeof(REPLY_SET_DATE_TIME_X) - PROTOCOL_DATA_KEY_HEAD_LENGTH;
@@ -416,8 +437,14 @@ bool McuProtocolTestTool::SetPirSensitivityProtocolHandle(std::shared_ptr<LinuxT
         int result = memcmp(
             (unsigned char *)buf + count - PROTOCOL_CHECK_CODE_LENGTH, &askCheckCode, PROTOCOL_CHECK_CODE_LENGTH);
         EXPECT_EQ(result, 0) << "ask protocol data errer, check code isn't right.";
+        unsigned char *bufHandle = (unsigned char *)malloc(count);
+        if (nullptr == bufHandle) {
+            LogError("malloc failed.\n");
+            return PROTOCOL_HANDLED;
+        }
+        memcpy(bufHandle, buf, count);
         auto handle = [=, &mock](McuProtocolTestTool *testTool) {
-            testTool->SetDataTimeProtocolInit(mock, uartFd, buf, count);
+            testTool->SetDataTimeProtocolInit(mock, uartFd, bufHandle, count);
         };
         if (mLockThread.joinable()) {
             mLockThread.join();
@@ -468,8 +495,14 @@ bool McuProtocolTestTool::ContorlInfraredLightHandle(std::shared_ptr<LinuxTest>
         int result = memcmp(
             (unsigned char *)buf + count - PROTOCOL_CHECK_CODE_LENGTH, &askCheckCode, PROTOCOL_CHECK_CODE_LENGTH);
         EXPECT_EQ(result, 0) << "ask protocol data errer, check code isn't right.";
+        unsigned char *bufHandle = (unsigned char *)malloc(count);
+        if (nullptr == bufHandle) {
+            LogError("malloc failed.\n");
+            return PROTOCOL_HANDLED;
+        }
+        memcpy(bufHandle, buf, count);
         auto handle = [=, &mock](McuProtocolTestTool *testTool) {
-            testTool->ContorlInfraredLightInit(mock, uartFd, buf, count);
+            testTool->ContorlInfraredLightInit(mock, uartFd, bufHandle, count);
         };
         if (mLockThread.joinable()) {
             mLockThread.join();
@@ -486,6 +519,7 @@ void McuProtocolTestTool::ContorlInfraredLightInit(std::shared_ptr<LinuxTest> &m
     memcpy(REPLY_ASK_CONTORL_INFRARED_LIGHT_X + PROTOCOL_SERIAL_NUMBER_OFFSET,
            (unsigned char *)buf + PROTOCOL_SERIAL_NUMBER_OFFSET,
            PROTOCOL_SERIAL_NUMBER_LENGTH);
+    free((void *)buf);
     ResetCheckCode(REPLY_ASK_CONTORL_INFRARED_LIGHT_X, sizeof(REPLY_ASK_CONTORL_INFRARED_LIGHT_X));
     ReplySelectSucceed(mock, uartFd);
     constexpr int LEFT_DATA_LENGTH = sizeof(REPLY_ASK_CONTORL_INFRARED_LIGHT_X) - PROTOCOL_DATA_KEY_HEAD_LENGTH;
@@ -518,8 +552,14 @@ bool McuProtocolTestTool::GetPhotosensitivityValueHandle(std::shared_ptr<LinuxTe
         int result = memcmp(
             (unsigned char *)buf + count - PROTOCOL_CHECK_CODE_LENGTH, &askCheckCode, PROTOCOL_CHECK_CODE_LENGTH);
         EXPECT_EQ(result, 0) << "ask protocol data errer, check code isn't right.";
+        unsigned char *bufHandle = (unsigned char *)malloc(count);
+        if (nullptr == bufHandle) {
+            LogError("malloc failed.\n");
+            return PROTOCOL_HANDLED;
+        }
+        memcpy(bufHandle, buf, count);
         auto handle = [=, &mock](McuProtocolTestTool *testTool) {
-            testTool->GetPhotosensitivityValueInit(mock, uartFd, buf, count);
+            testTool->GetPhotosensitivityValueInit(mock, uartFd, bufHandle, count);
         };
         if (mLockThread.joinable()) {
             mLockThread.join();
@@ -536,6 +576,7 @@ void McuProtocolTestTool::GetPhotosensitivityValueInit(std::shared_ptr<LinuxTest
     memcpy(REPLY_ASK_GET_PHOTOSENSITIVITY_X + PROTOCOL_SERIAL_NUMBER_OFFSET,
            (unsigned char *)buf + PROTOCOL_SERIAL_NUMBER_OFFSET,
            PROTOCOL_SERIAL_NUMBER_LENGTH);
+    free((void *)buf);
     ResetCheckCode(REPLY_ASK_GET_PHOTOSENSITIVITY_X, sizeof(REPLY_ASK_GET_PHOTOSENSITIVITY_X));
     ReplySelectSucceed(mock, uartFd);
     constexpr int LEFT_DATA_LENGTH = sizeof(REPLY_ASK_GET_PHOTOSENSITIVITY_X) - PROTOCOL_DATA_KEY_HEAD_LENGTH;