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

Backup McuManager module.

Browse Source
This commit is contained in:
Fancy code 2024-02-06 09:59:23 -08:00
parent c91ddb6456
commit f6ee22a2d1
12 changed files with 154 additions and 27 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
middleware/GuiEngine/README.md
View File

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

4
middleware/McuManager/CMakeLists.txt
View File

@ -64,4 +64,6 @@ add_custom_command(
COMMAND make McuManager_code_format
WORKING_DIRECTORY ${PLATFORM_PATH}/cmake-shell/
)
endif()
endif()
define_file_name(${TARGET_NAME})

11
middleware/McuManager/src/McuDevice.cpp
View File

@ -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,
dataBuf + headLength + recvTotalLength,
dataLength - headLength - recvTotalLength,
RECV_TIMEOUT_MS);
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);

4
test/utils/McuProtocol/tool/include/McuProtocolTestTool.h
View File

@ -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

14
test/utils/McuProtocol/tool/src/McuProtocolTestTool.cpp
View File

@ -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));
}

19
utils/McuProtocol/src/LittleEndianHandle.cpp
View File

@ -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);
}

2
utils/McuProtocol/src/LittleEndianHandle.h
View File

@ -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

8
utils/McuProtocol/src/McuProtocol.cpp
View File

@ -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);

14
utils/McuProtocol/src/McuProtocolMakePtr.cpp
View File

@ -38,4 +38,18 @@ 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);
}

2
utils/McuProtocol/src/McuProtocolMakePtr.h
View File

@ -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;

80
utils/McuProtocol/src/ProtocolHandle.cpp
View File

@ -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);
handle->MakeProtocolPacket(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};
memcpy(&packet, keyHead, headLength);
if (PROTOCOL_HEAD != packet.mHead) {
ProtocolHandle::PrintHexadecimalData(keyHead, headLength);
unsigned short headNum = PROTOCOL_HEAD;
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);
}
@ -111,4 +170,15 @@ char ProtocolHandle::GetByteOrder(void)
byteOrder = ORDER_LITTLE_ENDIAN;
}
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");
}

17
utils/McuProtocol/src/ProtocolHandle.h
View File

@ -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