McuManager test tool support multi thread reading.

doc/gdb_coredump_guide.md

@@ -0,0 +1,39 @@
+# 1. gdb coredump分析
+
+  本文介绍ubuntu系统环境下coredump文件的分析方法。
+
+## 1.1. coredump文件生成路径查询
+
+```
+$ cat /proc/sys/kernel/core_pattern
+|/usr/share/apport/apport -p%p -s%s -c%c -d%d -P%P -u%u -g%g -- %E
+```
+
+**发现路径下并未生成coredump文件**
+
+```
+$ ulimit -a
+core file size          (blocks, -c) 0  // 0表示终端未开启core dump
+data seg size           (kbytes, -d) unlimited
+scheduling priority             (-e) 0
+file size               (blocks, -f) unlimited
+pending signals                 (-i) 63499
+max locked memory       (kbytes, -l) 65536
+max memory size         (kbytes, -m) unlimited
+open files                      (-n) 1024
+pipe size            (512 bytes, -p) 8
+POSIX message queues     (bytes, -q) 819200
+real-time priority              (-r) 0
+stack size              (kbytes, -s) 8192
+cpu time               (seconds, -t) unlimited
+max user processes              (-u) 63499
+virtual memory          (kbytes, -v) unlimited
+file locks                      (-x) unlimited
+```
+
+解决：
+```
+$ ulimit -c unlimited
+```
+
+sudo echo /home/xiaojiazhu/project/rkipc/battery/ipc-rk1106/ipc-sdk/cmake-shell/core.%e.%p> /proc/sys/kernel/core_pattern

test/middleware/McuManager/src_mock/McuManager_Mock_Test.cpp

@@ -232,7 +232,7 @@ TEST_F(McuManagerMockTest, INTEGRATION_McuManager_AUTO_GetIpcMission2)
     std::shared_ptr<McuAskBaseTestTool> testTool = std::dynamic_pointer_cast<McuAskBaseTestTool>(ask);
     testTool->McuAskDefaultFeatures(testTool);
     IMcuManager::GetInstance()->GetIpcMission(ask);
-    std::this_thread::sleep_for(std::chrono::milliseconds(2000));
+    std::this_thread::sleep_for(std::chrono::milliseconds(3000));
     EXPECT_EQ(CheckAskExist(ask), false); // Ensure that the request has been processed and deleted.
     IMcuManager::GetInstance()->UnInit();
 }
@@ -353,4 +353,73 @@ TEST_F(McuManagerMockTest, INTEGRATION_McuManager_AUTO_SetFeedingCycleForWatchDo
     EXPECT_EQ(CheckAskExist(ask), false); // Ensure that the request has been processed and deleted.
     IMcuManager::GetInstance()->UnInit();
 }
+// ../output_files/test/bin/McuManagerTest
+// --gtest_filter=McuManagerMockTest.INTEGRATION_McuManager_AUTO_STRESS_MultiThreadWrite
+TEST_F(McuManagerMockTest, INTEGRATION_McuManager_AUTO_STRESS_MultiThreadWrite)
+{
+    class McuAskTest : public McuAsk<ASK_RESULT>, public McuAskBaseTestTool
+    {
+    public:
+        McuAskTest() : McuAskBaseTestTool(McuAskBlock::BLOCK,
+                                          McuAskReply::NEED_REPLY) // using McuAskBlock::NOT_BLOCK
+        {
+        }
+        virtual ~McuAskTest() = default;
+        void ReplyFinished(const bool result) override
+        {
+            McuAskBaseTestTool::ReplyFinished(result);
+            if (result) {
+                LogInfo("Ask ASK_RESULT succeed, mDataReply = %d.\n", static_cast<int>(mDataReply));
+                // Do something here.
+            }
+            else {
+                LogError("Ask data falied.\n");
+            }
+        }
+    };
+    class McuAskTest2 : public McuAsk<IpcMission>, public McuAskBaseTestTool
+    {
+    public:
+        McuAskTest2()
+            : McuAskBaseTestTool(McuAskBlock::BLOCK, McuAskReply::NEED_REPLY) {} // using McuAskBlock::NOT_BLOCK
+        virtual ~McuAskTest2() = default;
+        void ReplyFinished(const bool result) override
+        {
+            McuAskBaseTestTool::ReplyFinished(result);
+            if (result) {
+                LogInfo("Ask IpcMission succeed, mDataReply = %d.\n", static_cast<int>(mDataReply));
+                // Do something here.
+            }
+            else {
+                LogError("Ask data falied.\n");
+            }
+        }
+    };
+    auto threadTest1 = [](McuManagerMockTest *test) {
+        std::shared_ptr<VMcuAsk> ask = std::make_shared<McuAskTest>();
+        std::shared_ptr<McuAskBaseTestTool> testTool = std::dynamic_pointer_cast<McuAskBaseTestTool>(ask);
+        testTool->McuAskDefaultFeatures(testTool);
+        StatusCode code = IMcuManager::GetInstance()->SetFeedingCycleForWatchDog(ask, 1, 1, 1);
+        EXPECT_EQ(code.mStatusCode, STATUS_CODE_OK); // STATUS_CODE_OK means write data to mcu succeed.
+        std::this_thread::sleep_for(std::chrono::milliseconds(3000));
+        EXPECT_EQ(test->CheckAskExist(ask), false); // Ensure that the request has been processed and deleted.
+    };
+    auto threadTest2 = [](McuManagerMockTest *test) {
+        std::shared_ptr<VMcuAsk> ask = std::make_shared<McuAskTest2>();
+        std::shared_ptr<McuAskBaseTestTool> testTool = std::dynamic_pointer_cast<McuAskBaseTestTool>(ask);
+        testTool->McuAskDefaultFeatures(testTool);
+        IMcuManager::GetInstance()->GetIpcMission(ask);
+        EXPECT_EQ(test->CheckAskExist(ask), false); // Ensure that the request has been processed and deleted.
+    };
+    IMcuManager::GetInstance()->Init();
+    std::thread thread_1 = std::thread(threadTest1, this);
+    std::thread thread_2 = std::thread(threadTest2, this);
+    if (thread_1.joinable()) {
+        thread_1.join();
+    }
+    if (thread_2.joinable()) {
+        thread_2.join();
+    }
+    IMcuManager::GetInstance()->UnInit();
+}
 } // namespace McuManagerMockTest

test/middleware/McuManager/tool/src/McuManagerTestTool.cpp

@@ -49,6 +49,7 @@ void McuManagerTestTool::UnInit(void)
     std::shared_ptr<McuManagerMakePtr> impl = std::make_shared<McuManagerMakePtr>();
     McuManagerMakePtr::GetInstance(&impl);
     UartDeviceTestTool::UnregisterUartDevice(gUartDevice);
+    McuProtocolTestTool::UnInit();
 }
 bool McuManagerTestTool::CheckAskExist(const std::shared_ptr<VMcuAsk> &ask)
 {

test/test_develop.md

@@ -4,6 +4,8 @@
 
 ## 1.1. 命名规则
 
+  制定命名规则，是为了规范测试用例行为，为自动化测试提供管理遍历，因为googletest支持根据测试用例名字通配符检索运行目标测试用例。
+
 ### 1.1.1. 基本概念
 
 **单元测试**：单元测试指对单一功能接口的测试，一般不需要或少量使用gtest的mock功能即可完成测试，不需要实际链接外部接口，对模块内部代码功能进行有效验证；

test/utils/McuProtocol/tool/CMakeLists.txt

@@ -24,7 +24,7 @@ set(CMAKE_INCLUDE_CURRENT_DIR ON)
 aux_source_directory(./src TEST_TOOL_SRC_FILES)
 set(TEST_TOOL_TARGET McuProtocolTestTool)
 add_library(${TEST_TOOL_TARGET} STATIC ${TEST_TOOL_SRC_FILES})
-target_link_libraries(${TEST_TOOL_TARGET} UartDeviceTestTool Log)
+target_link_libraries(${TEST_TOOL_TARGET} SharedPtrTest UartDeviceTestTool Log)
 
 if ("${CLANG_TIDY_SUPPORT}" MATCHES "true")
 add_custom_target(

test/utils/McuProtocol/tool/include/McuProtocolTestTool.h

@@ -16,22 +16,41 @@
 #define MCU_PROTOCOL_TEST_TOOL_H
 #include "LinuxApiMock.h"
 #include "UartDeviceTestTool.h"
+#include <mutex>
+#include <thread>
 constexpr int READ_PRINT = 0;
 constexpr int WRITE_PRINT = 1;
 class McuProtocolTestTool : virtual public UartDeviceTestTool
 {
 public:
-    McuProtocolTestTool() = default;
+    McuProtocolTestTool();
     virtual ~McuProtocolTestTool() = default;
     void Init(std::shared_ptr<LinuxTest> &mock, const UartInfo &uart);
     void UnInit(void);
 
 private:
+    void CheckSerialNumber(const void *buf, const size_t &count);
+    void ResetCheckCode(const void *buf, const size_t &count);
     void ReplySelectSucceed(std::shared_ptr<LinuxTest> &mock, const int &uartFd);
-    void IpcMissionProtocolInit(std::shared_ptr<LinuxTest> &mock, const int &uartFd);
+    void IpcMissionProtocolHandle(std::shared_ptr<LinuxTest> &mock, const int &uartFd, const void *buf, size_t count);
-    void FeedingCycleProtocolInit(std::shared_ptr<LinuxTest> &mock, const int &uartFd);
+    void IpcMissionProtocolInit(std::shared_ptr<LinuxTest> &mock, const int &uartFd, const void *buf, size_t count);
+    void CutOffPowerSupplyProtocolHandle(std::shared_ptr<LinuxTest> &mock, const int &uartFd, const void *buf,
+                                         size_t count);
+    void FeedWatchDogProtocolHandle(std::shared_ptr<LinuxTest> &mock, const int &uartFd, const void *buf, size_t count);
+    void FeedingCycleProtocolHandle(std::shared_ptr<LinuxTest> &mock, const int &uartFd, const void *buf, size_t count);
+    void FeedingCycleProtocolInit(std::shared_ptr<LinuxTest> &mock, const int &uartFd, const void *buf, size_t count);
+    void LockProtocolHandle(void);
+    void UnlockProtocolHandle(void);
+    void UnlockThread(void);
 
 private:
     static void PrintHexadecimalData(const void *buf, const size_t &bufLength, const int event);
+
+private:
+    std::mutex mMutex;
+    bool mThreadRuning;
+    std::thread mLockThread;
+    std::thread mUnLockThread;
+    unsigned int mSerialNumberCheck;
 };
 #endif

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

@@ -20,63 +20,32 @@
 #include <thread>
 constexpr size_t PROTOCOL_DATA_KEY_HEAD_LENGTH = 10;
 constexpr size_t PROTOCOL_COMMAND_LENGTH = 6;
-const unsigned char ASK_IPC_MISSION[] = {0xFA, 0xC1, 0x00, 0x00, 0x00, 0x00, 0x81, 0x01, 0x00, 0x0C, 0x71, 0x88};
+constexpr size_t PROTOCOL_CHECK_CODE_LENGTH = sizeof(short);
-const unsigned char REPLY_IPC_MISSION[] = {
+constexpr size_t PROTOCOL_SERIAL_NUMBER_LENGTH = sizeof(unsigned int);
-    0xFA, 0xC1, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x0D, 0x01, 0xAA, 0x89};
+unsigned char ASK_IPC_MISSION[] = {0xFA, 0xC1, 0x00, 0x00, 0x00, 0x00, 0x81, 0x01, 0x00, 0x0C, 0x71, 0x88};
-const unsigned char ASK_CUT_OFF_POWER_SUPPLY[] = {
+unsigned char REPLY_IPC_MISSION[] = {0xFA, 0xC1, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x0D, 0x01, 0xAA, 0x89};
-    0xFA, 0xC1, 0x00, 0x00, 0x00, 0x00, 0x81, 0x02, 0x00, 0x0C, 0x81, 0x88};
+unsigned char ASK_CUT_OFF_POWER_SUPPLY[] = {0xFA, 0xC1, 0x00, 0x00, 0x00, 0x00, 0x81, 0x02, 0x00, 0x0C, 0x81, 0x88};
-const unsigned char ASK_FEED_WATCH_DOG[] = {0xFA, 0xC1, 0x00, 0x00, 0x00, 0x00, 0x81, 0x03, 0x00, 0x0C, 0xD0, 0x48};
+unsigned char ASK_FEED_WATCH_DOG[] = {0xFA, 0xC1, 0x00, 0x00, 0x00, 0x00, 0x81, 0x03, 0x00, 0x0C, 0xD0, 0x48};
-const unsigned char ASK_SET_FEEDING_CYCLE[] = {
+unsigned char ASK_SET_FEEDING_CYCLE[] = {
     0xFA, 0xC1, 0x00, 0x00, 0x00, 0x00, 0x81, 0x04, 0x00, 0x0F, 0x01, 0x01, 0x01, 0xA7, 0x9A};
-const unsigned char REPLY_SET_FEEDING_CYCLE[] = {
+unsigned char REPLY_SET_FEEDING_CYCLE[] = {
     0xFA, 0xC1, 0x00, 0x00, 0x00, 0x00, 0x01, 0x04, 0x00, 0x0F, 0x01, 0x01, 0x01, 0x52, 0x26};
+McuProtocolTestTool::McuProtocolTestTool()
+{
+    mSerialNumberCheck = 0;
+    mThreadRuning = false;
+}
 void McuProtocolTestTool::Init(std::shared_ptr<LinuxTest> &mock, const UartInfo &uart)
 {
     int uartFd = GetDeviceMockFd(uart);
-    // IpcMissionProtocolInit(mock, uartFd);
     static size_t WRITE_COUNT = -1;
     auto api_write = [=, &mock](int fd, const void *buf, size_t count) {
         McuProtocolTestTool::PrintHexadecimalData(buf, count, WRITE_PRINT);
-        if (sizeof(ASK_IPC_MISSION) == count &&
+        CheckSerialNumber(buf, count);
-            memcmp(ASK_IPC_MISSION + PROTOCOL_COMMAND_LENGTH, (unsigned char *)buf + PROTOCOL_COMMAND_LENGTH, 2) == 0) {
+        IpcMissionProtocolHandle(mock, uartFd, buf, count);
-            LogInfo("Set REPLY_IPC_MISSION\n");
+        CutOffPowerSupplyProtocolHandle(mock, uartFd, buf, count);
-            short askCheckCode = calculate_check_sum(ASK_IPC_MISSION, sizeof(ASK_IPC_MISSION) - sizeof(short));
+        FeedWatchDogProtocolHandle(mock, uartFd, buf, count);
-            askCheckCode = htons(askCheckCode);
+        FeedingCycleProtocolHandle(mock, uartFd, buf, count);
-            EXPECT_EQ(memcmp((unsigned char *)ASK_IPC_MISSION + count - sizeof(short), &askCheckCode, 2), 0);
-            IpcMissionProtocolInit(mock, uartFd);
-        }
-        if (sizeof(ASK_CUT_OFF_POWER_SUPPLY) == count && memcmp(ASK_CUT_OFF_POWER_SUPPLY + PROTOCOL_COMMAND_LENGTH,
-                                                                (unsigned char *)buf + PROTOCOL_COMMAND_LENGTH,
-                                                                2) == 0) {
-            LogInfo("Set ASK_CUT_OFF_POWER_SUPPLY\n");
-            short askCheckCode =
-                calculate_check_sum(ASK_CUT_OFF_POWER_SUPPLY, sizeof(ASK_CUT_OFF_POWER_SUPPLY) - sizeof(short));
-            askCheckCode = htons(askCheckCode);
-            EXPECT_EQ(memcmp((unsigned char *)ASK_CUT_OFF_POWER_SUPPLY + count - sizeof(short), &askCheckCode, 2), 0);
-            // IpcMissionProtocolInit(mock, uartFd);
-        }
-        if (sizeof(ASK_FEED_WATCH_DOG) == count &&
-            memcmp(ASK_FEED_WATCH_DOG + PROTOCOL_COMMAND_LENGTH, (unsigned char *)buf + PROTOCOL_COMMAND_LENGTH, 2) ==
-                0) {
-            LogInfo("Set ASK_FEED_WATCH_DOG\n");
-            short askCheckCode = calculate_check_sum(ASK_FEED_WATCH_DOG, sizeof(ASK_FEED_WATCH_DOG) - sizeof(short));
-            askCheckCode = htons(askCheckCode);
-            EXPECT_EQ(memcmp((unsigned char *)ASK_FEED_WATCH_DOG + count - sizeof(short), &askCheckCode, 2), 0);
-            // IpcMissionProtocolInit(mock, uartFd);
-        }
-        if (sizeof(ASK_SET_FEEDING_CYCLE) == count && memcmp(ASK_SET_FEEDING_CYCLE + PROTOCOL_COMMAND_LENGTH,
-                                                             (unsigned char *)buf + PROTOCOL_COMMAND_LENGTH,
-                                                             2) == 0) {
-            short replyCheckCode =
-                calculate_check_sum(REPLY_SET_FEEDING_CYCLE, sizeof(REPLY_SET_FEEDING_CYCLE) - sizeof(short));
-            replyCheckCode = htons(replyCheckCode);
-            LogInfo("Set ASK_SET_FEEDING_CYCLE, reply data check code = 0x%x\n", replyCheckCode);
-            short askCheckCode =
-                calculate_check_sum(ASK_SET_FEEDING_CYCLE, sizeof(ASK_SET_FEEDING_CYCLE) - sizeof(short));
-            askCheckCode = htons(askCheckCode);
-            EXPECT_EQ(memcmp((unsigned char *)ASK_SET_FEEDING_CYCLE + count - sizeof(short), &askCheckCode, 2), 0);
-            FeedingCycleProtocolInit(mock, uartFd);
-        }
     };
     EXPECT_CALL(*mock.get(), fx_write(uartFd, _, _))
         .WillRepeatedly(
@@ -84,7 +53,28 @@ void McuProtocolTestTool::Init(std::shared_ptr<LinuxTest> &mock, const UartInfo
 }
 void McuProtocolTestTool::UnInit(void)
 {
-    //
+    if (mLockThread.joinable()) {
+        mLockThread.join();
+    }
+    if (mUnLockThread.joinable()) {
+        mUnLockThread.join();
+    }
+}
+void McuProtocolTestTool::CheckSerialNumber(const void *buf, const size_t &count)
+{
+    unsigned int serialNumber = 0;
+    if (count > PROTOCOL_COMMAND_LENGTH + PROTOCOL_CHECK_CODE_LENGTH) {
+        memcpy(&serialNumber, (unsigned char *)buf + 2, 4);
+        serialNumber = ntohl(serialNumber);
+        // EXPECT_EQ(serialNumber, mSerialNumberCheck); // TODO:
+        mSerialNumberCheck++;
+    }
+}
+void McuProtocolTestTool::ResetCheckCode(const void *buf, const size_t &count)
+{
+    short checkCode = calculate_check_sum((unsigned char *)buf, count - PROTOCOL_CHECK_CODE_LENGTH);
+    checkCode = htons(checkCode);
+    memcpy((unsigned char *)buf + count - PROTOCOL_CHECK_CODE_LENGTH, &checkCode, PROTOCOL_CHECK_CODE_LENGTH);
 }
 void McuProtocolTestTool::ReplySelectSucceed(std::shared_ptr<LinuxTest> &mock, const int &uartFd)
 {
@@ -103,8 +93,30 @@ void McuProtocolTestTool::ReplySelectSucceed(std::shared_ptr<LinuxTest> &mock, c
         .WillOnce(DoAll(WithArgs<0, 1, 2, 3, 4>(Invoke(selectReadable)), Return(1)))
         .WillRepeatedly(DoAll(WithArgs<0, 1, 2, 3, 4>(Invoke(selectTimeOut)), Return(MOCK_SELECT_TIME_OUT)));
 }
-void McuProtocolTestTool::IpcMissionProtocolInit(std::shared_ptr<LinuxTest> &mock, const int &uartFd)
+void McuProtocolTestTool::IpcMissionProtocolHandle(std::shared_ptr<LinuxTest> &mock, const int &uartFd, const void *buf,
+                                                   size_t count)
 {
+    if (sizeof(ASK_IPC_MISSION) == count &&
+        memcmp(ASK_IPC_MISSION + PROTOCOL_COMMAND_LENGTH, (unsigned char *)buf + PROTOCOL_COMMAND_LENGTH, 2) == 0) {
+        LogInfo("Set REPLY_IPC_MISSION\n");
+        short askCheckCode = calculate_check_sum(ASK_IPC_MISSION, sizeof(ASK_IPC_MISSION) - PROTOCOL_CHECK_CODE_LENGTH);
+        askCheckCode = htons(askCheckCode);
+        EXPECT_EQ(memcmp((unsigned char *)ASK_IPC_MISSION + count - PROTOCOL_CHECK_CODE_LENGTH, &askCheckCode, 2), 0);
+        auto handle = [=, &mock](McuProtocolTestTool *testTool) {
+            testTool->IpcMissionProtocolInit(mock, uartFd, buf, count);
+        };
+        if (mLockThread.joinable()) {
+            mLockThread.join();
+        }
+        mLockThread = std::thread(handle, this);
+    }
+}
+void McuProtocolTestTool::IpcMissionProtocolInit(std::shared_ptr<LinuxTest> &mock, const int &uartFd, const void *buf,
+                                                 size_t count)
+{
+    LockProtocolHandle();
+    memcpy(REPLY_IPC_MISSION + 2, (unsigned char *)buf + 2, PROTOCOL_SERIAL_NUMBER_LENGTH);
+    ResetCheckCode(REPLY_IPC_MISSION, sizeof(REPLY_IPC_MISSION));
     ReplySelectSucceed(mock, uartFd);
     constexpr int LEFT_DATA_LENGTH = sizeof(REPLY_IPC_MISSION) - PROTOCOL_DATA_KEY_HEAD_LENGTH;
     auto apiReadKeyHead = [=](int fd, void *buf, size_t count) {
@@ -114,14 +126,73 @@ void McuProtocolTestTool::IpcMissionProtocolInit(std::shared_ptr<LinuxTest> &moc
     auto apiReadLeftData = [=](int fd, void *buf, size_t count) {
         memcpy(buf, REPLY_IPC_MISSION + PROTOCOL_DATA_KEY_HEAD_LENGTH, LEFT_DATA_LENGTH);
         McuProtocolTestTool::PrintHexadecimalData(buf, LEFT_DATA_LENGTH, READ_PRINT);
+        UnlockProtocolHandle();
     };
     EXPECT_CALL(*mock.get(), fx_read(uartFd, _, _))
         .WillOnce(DoAll(WithArgs<0, 1, 2>(Invoke(apiReadKeyHead)), Return(PROTOCOL_DATA_KEY_HEAD_LENGTH)))
         .WillOnce(DoAll(WithArgs<0, 1, 2>(Invoke(apiReadLeftData)), Return(LEFT_DATA_LENGTH)))
         .WillRepeatedly(DoAll(Return(UART_DEVICE_READ_NOTHING)));
 }
-void McuProtocolTestTool::FeedingCycleProtocolInit(std::shared_ptr<LinuxTest> &mock, const int &uartFd)
+void McuProtocolTestTool::CutOffPowerSupplyProtocolHandle(std::shared_ptr<LinuxTest> &mock, const int &uartFd,
+                                                          const void *buf, size_t count)
 {
+    if (sizeof(ASK_CUT_OFF_POWER_SUPPLY) == count &&
+        memcmp(ASK_CUT_OFF_POWER_SUPPLY + PROTOCOL_COMMAND_LENGTH, (unsigned char *)buf + PROTOCOL_COMMAND_LENGTH, 2) ==
+            0) {
+        LogInfo("Set ASK_CUT_OFF_POWER_SUPPLY\n");
+        short askCheckCode = calculate_check_sum(ASK_CUT_OFF_POWER_SUPPLY,
+                                                 sizeof(ASK_CUT_OFF_POWER_SUPPLY) - PROTOCOL_CHECK_CODE_LENGTH);
+        askCheckCode = htons(askCheckCode);
+        EXPECT_EQ(
+            memcmp((unsigned char *)ASK_CUT_OFF_POWER_SUPPLY + count - PROTOCOL_CHECK_CODE_LENGTH, &askCheckCode, 2),
+            0);
+        // IpcMissionProtocolInit(mock, uartFd);
+    }
+}
+void McuProtocolTestTool::FeedWatchDogProtocolHandle(std::shared_ptr<LinuxTest> &mock, const int &uartFd,
+                                                     const void *buf, size_t count)
+{
+    if (sizeof(ASK_FEED_WATCH_DOG) == count &&
+        memcmp(ASK_FEED_WATCH_DOG + PROTOCOL_COMMAND_LENGTH, (unsigned char *)buf + PROTOCOL_COMMAND_LENGTH, 2) == 0) {
+        LogInfo("Set ASK_FEED_WATCH_DOG\n");
+        short askCheckCode =
+            calculate_check_sum(ASK_FEED_WATCH_DOG, sizeof(ASK_FEED_WATCH_DOG) - PROTOCOL_CHECK_CODE_LENGTH);
+        askCheckCode = htons(askCheckCode);
+        EXPECT_EQ(memcmp((unsigned char *)ASK_FEED_WATCH_DOG + count - PROTOCOL_CHECK_CODE_LENGTH, &askCheckCode, 2),
+                  0);
+        // IpcMissionProtocolInit(mock, uartFd);
+    }
+}
+void McuProtocolTestTool::FeedingCycleProtocolHandle(std::shared_ptr<LinuxTest> &mock, const int &uartFd,
+                                                     const void *buf, size_t count)
+{
+    if (sizeof(ASK_SET_FEEDING_CYCLE) == count &&
+        memcmp(ASK_SET_FEEDING_CYCLE + PROTOCOL_COMMAND_LENGTH, (unsigned char *)buf + PROTOCOL_COMMAND_LENGTH, 2) ==
+            0) {
+        short replyCheckCode =
+            calculate_check_sum(REPLY_SET_FEEDING_CYCLE, sizeof(REPLY_SET_FEEDING_CYCLE) - PROTOCOL_CHECK_CODE_LENGTH);
+        replyCheckCode = htons(replyCheckCode);
+        LogInfo("Set ASK_SET_FEEDING_CYCLE, reply data check code = 0x%x\n", replyCheckCode);
+        short askCheckCode =
+            calculate_check_sum(ASK_SET_FEEDING_CYCLE, sizeof(ASK_SET_FEEDING_CYCLE) - PROTOCOL_CHECK_CODE_LENGTH);
+        askCheckCode = htons(askCheckCode);
+        EXPECT_EQ(memcmp((unsigned char *)ASK_SET_FEEDING_CYCLE + count - PROTOCOL_CHECK_CODE_LENGTH, &askCheckCode, 2),
+                  0);
+        auto handle = [=, &mock](McuProtocolTestTool *testTool) {
+            testTool->FeedingCycleProtocolInit(mock, uartFd, buf, count);
+        };
+        if (mLockThread.joinable()) {
+            mLockThread.join();
+        }
+        mLockThread = std::thread(handle, this);
+        // FeedingCycleProtocolInit(mock, uartFd);
+    }
+}
+void McuProtocolTestTool::FeedingCycleProtocolInit(std::shared_ptr<LinuxTest> &mock, const int &uartFd, const void *buf,
+                                                   size_t count)
+{
+    LockProtocolHandle();
+    memcpy(REPLY_SET_FEEDING_CYCLE + 2, (unsigned char *)buf + 2, PROTOCOL_SERIAL_NUMBER_LENGTH);
     ReplySelectSucceed(mock, uartFd);
     constexpr int LEFT_DATA_LENGTH = sizeof(REPLY_SET_FEEDING_CYCLE) - PROTOCOL_DATA_KEY_HEAD_LENGTH;
     auto apiReadKeyHead = [=](int fd, void *buf, size_t count) {
@@ -131,12 +202,31 @@ void McuProtocolTestTool::FeedingCycleProtocolInit(std::shared_ptr<LinuxTest> &m
     auto apiReadLeftData = [=](int fd, void *buf, size_t count) {
         memcpy(buf, REPLY_SET_FEEDING_CYCLE + PROTOCOL_DATA_KEY_HEAD_LENGTH, LEFT_DATA_LENGTH);
         McuProtocolTestTool::PrintHexadecimalData(buf, LEFT_DATA_LENGTH, READ_PRINT);
+        UnlockProtocolHandle();
     };
     EXPECT_CALL(*mock.get(), fx_read(uartFd, _, _))
         .WillOnce(DoAll(WithArgs<0, 1, 2>(Invoke(apiReadKeyHead)), Return(PROTOCOL_DATA_KEY_HEAD_LENGTH)))
         .WillOnce(DoAll(WithArgs<0, 1, 2>(Invoke(apiReadLeftData)), Return(LEFT_DATA_LENGTH)))
         .WillRepeatedly(DoAll(Return(UART_DEVICE_READ_NOTHING)));
 }
+void McuProtocolTestTool::UnlockProtocolHandle(void)
+{
+    auto unlockThread = [=](McuProtocolTestTool *testTool) { testTool->UnlockThread(); };
+    if (mUnLockThread.joinable()) {
+        mUnLockThread.join();
+    }
+    mUnLockThread = std::thread(unlockThread, this);
+}
+void McuProtocolTestTool::LockProtocolHandle(void)
+{
+    //
+    mMutex.lock();
+}
+void McuProtocolTestTool::UnlockThread(void)
+{
+    std::this_thread::sleep_for(std::chrono::milliseconds(5));
+    mMutex.unlock();
+}
 void McuProtocolTestTool::PrintHexadecimalData(const void *buf, const size_t &bufLength, const int event)
 {
     if (WRITE_PRINT == event) {

utils/McuProtocol/src/LittleEndianHandle.cpp

@@ -39,13 +39,17 @@ void LittleEndianHandle::HostByteOrderConversion(ProtocolPacket &packet)
     packet.mHead = ntohs(packet.mHead);
     packet.mCommand = ntohs(packet.mCommand);
     packet.mLength = ntohs(packet.mLength);
+    LogInfo("========2====== packet.mCheckCode = 0x%x\n", packet.mCheckCode);
     packet.mCheckCode = ntohs(packet.mCheckCode);
+    LogInfo("=========2===== packet.mCheckCode = 0x%x\n", packet.mCheckCode);
     packet.mSerialNumber = ntohl(packet.mSerialNumber);
 }
 bool LittleEndianHandle::CheckoutTheCheckCode(const ProtocolPacket &packet)
 {
     short code = calculate_check_sum(mProtocolData, mProtocolDataLength - sizeof(short));
-    code = htons(code);
+    LogInfo("============== packet.mCheckCode = 0x%x\n", packet.mCheckCode);
+    code = ntohs(code);
+    LogInfo("============== code = 0x%x\n", code);
     if (code == packet.mCheckCode) {
         return true;
     }

utils/McuProtocol/src/ProtocolHandle.cpp

@@ -19,14 +19,14 @@
 #include "ModBusCRC16.h"
 #include <netinet/in.h>
 #include <string.h>
-unsigned int ProtocolHandle::mSerialNumber = 0;
+unsigned int ProtocolHandle::mSerialNumber = 1;
+std::mutex ProtocolHandle::mMutex;
 constexpr unsigned short PROTOCOL_HEAD = 0xFAC1;
 constexpr size_t KEY_HEAD_LENGTH = sizeof(short) + sizeof(unsigned int) + sizeof(short) + sizeof(short);
 ProtocolHandle::ProtocolHandle(const std::shared_ptr<VProtocolParam> &param) : mParam(param)
 {
     mProtocolData = nullptr;
     mProtocolDataLength = 0;
-    mSerialNumber = 0;
     mMakePacketFunc[ASK_IPC_MISSION] = std::bind(&ProtocolHandle::MakeAskIpcMissionPacket, this, std::placeholders::_1);
     mMakePacketFunc[ASK_CUT_OFF_PWOER_SUPPLY] =
         std::bind(&ProtocolHandle::MakeAskCutOffPowerSupplyPacket, this, std::placeholders::_1);
@@ -54,6 +54,16 @@ ProtocolHandle::~ProtocolHandle()
         mProtocolData = nullptr;
     }
 }
+ProtocolPacket ProtocolHandle::CreatePocketWithSerialNumber(void)
+{
+    std::lock_guard<std::mutex> locker(mMutex);
+    ProtocolPacket packet;
+    memset(&packet, 0, sizeof(ProtocolPacket));
+    packet.mSerialNumber = mSerialNumber;
+    mProtocolSerialNumber = packet.mSerialNumber;
+    mSerialNumber++;
+    return packet;
+}
 void ProtocolHandle::MakeProtocolPacket(const std::shared_ptr<VProtocolParam> &param)
 {
     if (mProtocolData != nullptr) {
@@ -77,13 +87,10 @@ void ProtocolHandle::MakeNoUserDataPacket(const std::shared_ptr<VProtocolParam>
         LogError("malloc failed, MakeAskIpcMissionPacket return.\n");
         return;
     }
-    ProtocolPacket packet;
+    ProtocolPacket packet = CreatePocketWithSerialNumber();
     packet.mHead = PROTOCOL_HEAD;
     packet.mCommand = param->mCommand;
     packet.mLength = dataLength;
-    packet.mSerialNumber = mSerialNumber;
-    mProtocolSerialNumber = packet.mSerialNumber;
-    mSerialNumber++;
     BigEndianConversion(packet);
     memcpy(mProtocolData, &packet, KEY_HEAD_LENGTH);
     packet.mCheckCode = calculate_check_sum(mProtocolData, dataLength - sizeof(short));
@@ -122,13 +129,10 @@ void ProtocolHandle::MakeAskSetFeedingCyclePacket(const std::shared_ptr<VProtoco
     feedingCycle[0] = SetParam->mData.mHour;
     feedingCycle[1] = SetParam->mData.mMin;
     feedingCycle[2] = SetParam->mData.mSecond;
-    ProtocolPacket packet;
+    ProtocolPacket packet = CreatePocketWithSerialNumber();
     packet.mHead = PROTOCOL_HEAD;
     packet.mCommand = param->mCommand;
     packet.mLength = dataLength;
-    packet.mSerialNumber = mSerialNumber;
-    mProtocolSerialNumber = packet.mSerialNumber;
-    mSerialNumber++;
     BigEndianConversion(packet);
     memcpy(mProtocolData, &packet, KEY_HEAD_LENGTH);
     memcpy(mProtocolData + KEY_HEAD_LENGTH, feedingCycle, PARAM_DATA_LENGTH);
@@ -190,6 +194,7 @@ void ProtocolHandle::AnalyzeReplySetFeedingCyclePacket(const ProtocolPacket &pac
 bool ProtocolHandle::CheckoutTheCheckCode(const ProtocolPacket &packet)
 {
     short code = calculate_check_sum(mProtocolData, mProtocolDataLength - sizeof(short));
+    // short packetCode = BigEndianConversion(code);
     if (code == packet.mCheckCode) {
         return true;
     }

utils/McuProtocol/src/ProtocolHandle.h

@@ -18,6 +18,7 @@
 #include <functional>
 #include <map>
 #include <memory>
+#include <mutex>
 constexpr char ORDER_BIG_ENDIAN = 0x01;
 constexpr char ORDER_LITTLE_ENDIAN = 0x02;
 #pragma pack(1)
@@ -97,6 +98,7 @@ public:
      * of protocol packets.
      */
 private:
+    ProtocolPacket CreatePocketWithSerialNumber(void);
     void MakeProtocolPacket(const std::shared_ptr<VProtocolParam> &param);
     void MakeNoUserDataPacket(const std::shared_ptr<VProtocolParam> &param);
     void MakeAskIpcMissionPacket(const std::shared_ptr<VProtocolParam> &param);
@@ -137,6 +139,7 @@ protected:
      *
      */
     static unsigned int mSerialNumber;
+    static std::mutex mMutex;
 
 public:
     static std::shared_ptr<ProtocolHandle> CreateProtocolData(const std::shared_ptr<VProtocolParam> &param);