Backup McuManager module.

middleware/GuiEngine/README.md

@@ -6,15 +6,15 @@
 
 * lvgl_common
 
-   lvgl引擎接口封装的公共源码。
+   lvgl引擎接口二次封装的公共源码，目的是把lvgl开源库的接口解耦合，避免lvgl接口兼容导致的迭代困难。
 
 * lvgl_board
 
-   交叉编译源码目录，对接fb驱动。
+   交叉编译源码目录，含fb驱动。lvgl源码版本和模拟器一致。
 
 * lvgl_x86
 
-   ubuntu系统模拟器对接源码。
+   ubuntu系统模拟器源码。
 
 ## 1.2. 编译静态链接
 

middleware/McuManager/CMakeLists.txt

@@ -65,3 +65,5 @@ add_custom_command(
     WORKING_DIRECTORY ${PLATFORM_PATH}/cmake-shell/
 )
 endif()
+
+define_file_name(${TARGET_NAME})

middleware/McuManager/src/McuDevice.cpp

@@ -97,6 +97,7 @@ void McuDevice::DeviceRecvThread(void)
         LogError("malloc failed, DeviceRecvThread return.\n");
         return;
     }
+    memset(keyHeadBuf, 0, keyHeadLength);
     mThreadRuning = true;
     while (mThreadRuning) {
         ssize_t recvLength =
@@ -131,13 +132,15 @@ void McuDevice::DeviceRecvData(const char *keyHead, const size_t headLength)
         LogError("malloc failed, DeviceRecvData return.\n");
         return;
     }
+    LogInfo("dataLength = %d\n", dataLength);
     memset(dataBuf, 0, dataLength);
     memcpy(dataBuf, keyHead, headLength);
     while (mThreadRuning) {
-        size_t recvLength = IUartRecv(mUartDevice,
+        ssize_t recvLength = IUartRecv(mUartDevice,
                                        dataBuf + headLength + recvTotalLength,
                                        dataLength - headLength - recvTotalLength,
                                        RECV_TIMEOUT_MS);
+        LogInfo("recv data length = %d\n", recvLength);
         recvTotalLength += recvLength;
         if (dataLength - headLength == recvTotalLength) {
             PushMcuData(dataBuf, dataLength);

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

@@ -16,6 +16,8 @@
 #define MCU_PROTOCOL_TEST_TOOL_H
 #include "LinuxApiMock.h"
 #include "UartDeviceTestTool.h"
+constexpr int READ_PRINT = 0;
+constexpr int WRITE_PRINT = 1;
 class McuProtocolTestTool : virtual public UartDeviceTestTool
 {
 public:
@@ -25,6 +27,6 @@ public:
     void UnInit(void);
 
 private:
-    static void PrintHexadecimalData(const void *buf, const size_t &bufLength);
+    static void PrintHexadecimalData(const void *buf, const size_t &bufLength, const int event);
 };
 #endif

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

@@ -25,7 +25,7 @@ void McuProtocolTestTool::Init(std::shared_ptr<LinuxTest> &mock, const UartInfo
     int uartFd = GetDeviceMockFd(uart);
     static size_t WRITE_COUNT = -1;
     auto api_write = [=, &mock](int fd, const void *buf, size_t count) {
-        McuProtocolTestTool::PrintHexadecimalData(buf, count);
+        McuProtocolTestTool::PrintHexadecimalData(buf, count, WRITE_PRINT);
         if (sizeof(ASK_IPC_MISSION) == count && memcmp(ASK_IPC_MISSION, buf, count) == 0) {
             LogInfo("Set REPLY_IPC_MISSION\n");
             auto selectReadable =
@@ -44,11 +44,12 @@ void McuProtocolTestTool::Init(std::shared_ptr<LinuxTest> &mock, const UartInfo
                 .WillRepeatedly(DoAll(WithArgs<0, 1, 2, 3, 4>(Invoke(selectTimeOut)), Return(MOCK_SELECT_TIME_OUT)));
             constexpr int LEFT_DATA_LENGTH = sizeof(REPLY_IPC_MISSION) - PROTOCOL_DATA_KEY_HEAD_LENGTH;
             auto apiReadKeyHead = [=](int fd, void *buf, size_t count) {
-                LogInfo("apiReadKeyHead count = %d\n", count);
                 memcpy(buf, REPLY_IPC_MISSION, PROTOCOL_DATA_KEY_HEAD_LENGTH);
+                McuProtocolTestTool::PrintHexadecimalData(buf, PROTOCOL_DATA_KEY_HEAD_LENGTH, READ_PRINT);
             };
             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);
             };
             EXPECT_CALL(*mock.get(), fx_read(uartFd, _, _))
                 .WillOnce(DoAll(WithArgs<0, 1, 2>(Invoke(apiReadKeyHead)), Return(PROTOCOL_DATA_KEY_HEAD_LENGTH)))
@@ -64,9 +65,14 @@ void McuProtocolTestTool::UnInit(void)
 {
     //
 }
-void McuProtocolTestTool::PrintHexadecimalData(const void *buf, const size_t &bufLength)
+void McuProtocolTestTool::PrintHexadecimalData(const void *buf, const size_t &bufLength, const int event)
 {
-    printf("write buf = { 0x%02X", *(unsigned char *)buf);
+    if (WRITE_PRINT == event) {
+        printf("TEST write buf = { 0x%02X", *(unsigned char *)buf);
+    }
+    if (READ_PRINT == event) {
+        printf("TEST read buf = { 0x%02X", *(unsigned char *)buf);
+    }
     for (size_t i = 1; i < bufLength; i++) {
         printf(", 0x%02X", *((unsigned char *)buf + i));
     }

utils/McuProtocol/src/LittleEndianHandle.cpp

@@ -20,18 +20,23 @@ LittleEndianHandle::LittleEndianHandle(const std::shared_ptr<VProtocolParam> &pa
 {
     //
 }
+LittleEndianHandle::LittleEndianHandle(const void *data, const size_t &length) : ProtocolHandle(data, length)
+{
+    //
+}
 void LittleEndianHandle::BigEndianConversion(ProtocolPacket &packet)
 {
-    // LogInfo("packet.mHead = 0x%02x\n", packet.mHead);
-    // LogInfo("packet.mCommand = 0x%02x\n", packet.mCommand);
-    // LogInfo("packet.mLength = %d\n", packet.mLength);
-    // LogInfo("packet.mCheckCode = 0x%02x\n", packet.mCheckCode);
-    // LogInfo("packet.mSerialNumber = %d\n", packet.mSerialNumber);
-    // ProtocolPacket packetBigEndian;
     packet.mHead = htons(packet.mHead);
     packet.mCommand = htons(packet.mCommand);
     packet.mLength = htons(packet.mLength);
     packet.mCheckCode = htons(packet.mCheckCode);
     packet.mSerialNumber = htonl(packet.mSerialNumber);
-    // memcpy(&packet, &packetBigEndian, sizeof(ProtocolPacket));
+}
+void LittleEndianHandle::HostByteOrderConversion(ProtocolPacket &packet)
+{
+    packet.mHead = ntohs(packet.mHead);
+    packet.mCommand = ntohs(packet.mCommand);
+    packet.mLength = ntohs(packet.mLength);
+    packet.mCheckCode = ntohs(packet.mCheckCode);
+    packet.mSerialNumber = ntohl(packet.mSerialNumber);
 }

utils/McuProtocol/src/LittleEndianHandle.h

@@ -19,9 +19,11 @@ class LittleEndianHandle : public ProtocolHandle
 {
 public:
     LittleEndianHandle(const std::shared_ptr<VProtocolParam> &param);
+    LittleEndianHandle(const void *data, const size_t &length);
     virtual ~LittleEndianHandle() = default;
 
 private:
     void BigEndianConversion(ProtocolPacket &packet) override;
+    void HostByteOrderConversion(ProtocolPacket &packet) override;
 };
 #endif

utils/McuProtocol/src/McuProtocol.cpp

@@ -55,14 +55,15 @@ void McuProtocol::DataHandleThread(void)
     mThreadRuning = true;
     while (mThreadRuning) {
         sem_wait(&mSem);
+        mMutex.lock();
         if (mMcuDataList.size() == 0) {
+            mMutex.unlock();
             continue;
         }
-        mMutex.lock();
         SingleMcuPacket packet = mMcuDataList.front();
+        mMcuDataList.pop_front();
         mMutex.unlock();
         ProtocolHandle::ProtocolAnalysis(packet.mBuf, packet.mLength);
-        mMcuDataList.pop_front();
         free((void *)packet.mBuf);
     }
 }
@@ -78,6 +79,9 @@ void McuProtocol::PushMcuData(const void *buf, const size_t &length)
         LogError("malloc failed, PushMcuData failed.\n");
         return;
     }
+    LogInfo("PushMcuData\n");
+    memcpy(data, buf, length);
+    ProtocolHandle::PrintHexadecimalData(data, length);
     std::lock_guard<std::mutex> locker(mMutex);
     SingleMcuPacket packet(data, length);
     mMcuDataList.push_back(packet);

utils/McuProtocol/src/McuProtocolMakePtr.cpp

@@ -39,3 +39,17 @@ const StatusCode McuProtocolMakePtr::CreateProtocolHandle(std::shared_ptr<Protoc
     impl = tmp;
     return CreateStatusCode(STATUS_CODE_OK);
 }
+const StatusCode McuProtocolMakePtr::CreateProtocolHandle(std::shared_ptr<ProtocolHandle> &impl, const void *data,
+                                                          const size_t &length)
+{
+    std::shared_ptr<ProtocolHandle> tmp;
+    char byteOrder = ProtocolHandle::GetByteOrder();
+    if (ORDER_BIG_ENDIAN == byteOrder) {
+        tmp = std::make_shared<ProtocolHandle>(data, length);
+    }
+    else {
+        tmp = std::make_shared<LittleEndianHandle>(data, length);
+    }
+    impl = tmp;
+    return CreateStatusCode(STATUS_CODE_OK);
+}

utils/McuProtocol/src/McuProtocolMakePtr.h

@@ -25,6 +25,8 @@ public:
     static std::shared_ptr<McuProtocolMakePtr> &GetInstance(std::shared_ptr<McuProtocolMakePtr> *impl = nullptr);
     virtual const StatusCode CreateProtocolHandle(std::shared_ptr<ProtocolHandle> &impl,
                                                   const std::shared_ptr<VProtocolParam> &param);
+    virtual const StatusCode CreateProtocolHandle(std::shared_ptr<ProtocolHandle> &impl, const void *data,
+                                                  const size_t &length);
 
 private:
     char mByteOrder;

utils/McuProtocol/src/ProtocolHandle.cpp

@@ -28,6 +28,16 @@ ProtocolHandle::ProtocolHandle(const std::shared_ptr<VProtocolParam> &param) : m
     mSerialNumber = 0;
     mMakePacketFunc[ASK_IPC_MISSION] = std::bind(&ProtocolHandle::MakeAskIpcMissionPacket, this, std::placeholders::_1);
 }
+ProtocolHandle::ProtocolHandle(const void *data, const size_t &length)
+{
+    mProtocolData = (unsigned char *)malloc(length);
+    if (nullptr != mProtocolData) {
+        memcpy(mProtocolData, data, length);
+    }
+    mProtocolDataLength = length;
+    mAnalyzePacketFunc[REPLY_IPC_MISSION] =
+        std::bind(&ProtocolHandle::AnalyzeReplyIpcMissionPacket, this, std::placeholders::_1);
+}
 ProtocolHandle::~ProtocolHandle()
 {
     if (nullptr != mProtocolData) {
@@ -42,6 +52,9 @@ void ProtocolHandle::MakeProtocolPacket(const std::shared_ptr<VProtocolParam> &p
     if (iter != mMakePacketFunc.end()) {
         mMakePacketFunc[param->mCommand](param);
     }
+    else {
+        LogError("Unknown command.\n");
+    }
 }
 void ProtocolHandle::MakeAskIpcMissionPacket(const std::shared_ptr<VProtocolParam> &param)
 {
@@ -67,16 +80,51 @@ void ProtocolHandle::MakeAskIpcMissionPacket(const std::shared_ptr<VProtocolPara
     memcpy(mProtocolData + KEY_HEAD_LENGTH, &packet.mCheckCode, sizeof(short));
     mProtocolDataLength = dataLength;
 }
+void ProtocolHandle::AnalyzeProtocolPacket(void)
+{
+    ProtocolPacket packet = {0};
+    memcpy(&packet, mProtocolData, KEY_HEAD_LENGTH);
+    memcpy(&packet.mCheckCode,
+           (unsigned char *)mProtocolData + mProtocolDataLength - sizeof(unsigned short),
+           sizeof(unsigned short));
+    HostByteOrderConversion(packet);
+    LogInfo("AnalyzeProtocolPacket, command = 0x%04X\n", packet.mCommand);
+    PROTOCOL_COMMAND command = static_cast<PROTOCOL_COMMAND>(packet.mCommand);
+    std::map<PROTOCOL_COMMAND, AnalyzePacketFunc>::iterator iter;
+    iter = mAnalyzePacketFunc.find(command);
+    if (iter != mAnalyzePacketFunc.end()) {
+        mAnalyzePacketFunc[command](packet);
+    }
+    else {
+        LogError("Unknown command.\n");
+    }
+}
+void ProtocolHandle::AnalyzeReplyIpcMissionPacket(const ProtocolPacket &packet)
+{
+    LogInfo("AnalyzeReplyIpcMissionPacket\n");
+    constexpr unsigned char UNKNOWN_MISSION = 0xFF;
+    constexpr unsigned int PROTOCOL_DATA_START_ADDRESS = KEY_HEAD_LENGTH;
+    unsigned char ipcMission = UNKNOWN_MISSION;
+    ipcMission = mProtocolData[PROTOCOL_DATA_START_ADDRESS];
+    LogInfo("ipc mission = 0x%02X\n", ipcMission);
+}
 std::shared_ptr<ProtocolHandle> ProtocolHandle::CreateProtocolData(const std::shared_ptr<VProtocolParam> &param)
 {
     std::shared_ptr<ProtocolHandle> handle;
     McuProtocolMakePtr::GetInstance()->CreateProtocolHandle(handle, param);
+    if (handle) {
         handle->MakeProtocolPacket(param);
+    }
     return handle;
 }
 void ProtocolHandle::ProtocolAnalysis(const void *data, const size_t &length)
 {
-    //
+    LogInfo("ProtocolAnalysis\n");
+    std::shared_ptr<ProtocolHandle> handle;
+    McuProtocolMakePtr::GetInstance()->CreateProtocolHandle(handle, data, length);
+    if (handle) {
+        handle->AnalyzeProtocolPacket();
+    }
 }
 size_t ProtocolHandle::GetKeyHeadLength(void) { return KEY_HEAD_LENGTH; }
 StatusCode ProtocolHandle::GetDataLength(const void *keyHead, const size_t &headLength, size_t &dataLength)
@@ -85,12 +133,23 @@ StatusCode ProtocolHandle::GetDataLength(const void *keyHead, const size_t &head
         LogError("key head buf error.\n");
         return CreateStatusCode(STATUS_CODE_NOT_OK);
     }
-    ProtocolPacket packet = {0};
+    ProtocolHandle::PrintHexadecimalData(keyHead, headLength);
-    memcpy(&packet, keyHead, headLength);
+    unsigned short headNum = PROTOCOL_HEAD;
-    if (PROTOCOL_HEAD != packet.mHead) {
+    char byteOrder = ProtocolHandle::GetByteOrder();
+    if (ORDER_LITTLE_ENDIAN == byteOrder) {
+        headNum = htons(PROTOCOL_HEAD);
+    }
+    unsigned char head[3] = {0};
+    memcpy(head, &headNum, sizeof(unsigned short));
+    if (strstr((const char *)keyHead, (const char *)head) == nullptr) {
         LogError("Protocol head unmatch.\n");
         return CreateStatusCode(STATUS_CODE_NOT_OK);
     }
+    ProtocolPacket packet = {0};
+    memcpy(&packet, keyHead, headLength);
+    if (ORDER_LITTLE_ENDIAN == byteOrder) {
+        packet.mLength = htons(packet.mLength);
+    }
     dataLength = packet.mLength;
     return CreateStatusCode(STATUS_CODE_OK);
 }
@@ -112,3 +171,14 @@ char ProtocolHandle::GetByteOrder(void)
     }
     return byteOrder;
 }
+void ProtocolHandle::PrintHexadecimalData(const void *buf, const size_t &bufLength, const char *log)
+{
+    if (log) {
+        printf("%s", log);
+    }
+    printf(" {0x%02X", *(unsigned char *)buf);
+    for (size_t i = 1; i < bufLength; i++) {
+        printf(", 0x%02X", *((unsigned char *)buf + i));
+    }
+    printf("}\n");
+}

utils/McuProtocol/src/ProtocolHandle.h

@@ -60,25 +60,41 @@ public:
     T mData;
 };
 using MakePacketFunc = std::function<void(const std::shared_ptr<VProtocolParam> &)>;
+using AnalyzePacketFunc = std::function<void(const ProtocolPacket &)>;
 class ProtocolHandle
 {
 public:
     ProtocolHandle(const std::shared_ptr<VProtocolParam> &param);
+    ProtocolHandle(const void *data, const size_t &length);
     virtual ~ProtocolHandle();
     void *GetProtocolDataBuff(void) { return mProtocolData; }
     size_t GetProtocolDataLength(void) { return mProtocolDataLength; }
     unsigned int GetSerialNumber(void) { return mProtocolSerialNumber; }
 
+    /**
+     * @brief These functions assemble scattered data into continuous memory protocol packets and complete the sending
+     * of protocol packets.
+     */
 private:
     void MakeProtocolPacket(const std::shared_ptr<VProtocolParam> &param);
     void MakeAskIpcMissionPacket(const std::shared_ptr<VProtocolParam> &param);
 
+    /**
+     * @brief These function implementations parse the received frame by frame continuous data into the data required by
+     * the application, completing the protocol unpacking.
+     */
+private:
+    void AnalyzeProtocolPacket(void);
+    void AnalyzeReplyIpcMissionPacket(const ProtocolPacket &packet);
+
 private:
     virtual void BigEndianConversion(ProtocolPacket &packet) {}
+    virtual void HostByteOrderConversion(ProtocolPacket &packet) {}
 
 private:
     std::shared_ptr<VProtocolParam> mParam;
     std::map<PROTOCOL_COMMAND, MakePacketFunc> mMakePacketFunc;
+    std::map<PROTOCOL_COMMAND, AnalyzePacketFunc> mAnalyzePacketFunc;
     unsigned char *mProtocolData;
     size_t mProtocolDataLength;
     /**
@@ -99,5 +115,6 @@ public:
     static size_t GetKeyHeadLength(void);
     static StatusCode GetDataLength(const void *keyHead, const size_t &headLength, size_t &dataLength);
     static char GetByteOrder(void);
+    static void PrintHexadecimalData(const void *buf, const size_t &bufLength, const char *log = nullptr);
 };
 #endif