Germany/hunting
7
0
Fork 0
Code Issues Pull Requests Actions Packages Projects 1 Releases Wiki Activity

McuManager test tool support multi thread reading.

Browse Source
This commit is contained in:
Fancy code 2024-02-09 18:49:59 -08:00
parent 63bcd37b66
commit 859a4b8ce2
10 changed files with 300 additions and 68 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

39
doc/gdb_coredump_guide.md Normal file
View File

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

71
test/middleware/McuManager/src_mock/McuManager_Mock_Test.cpp
View File

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

1
test/middleware/McuManager/tool/src/McuManagerTestTool.cpp
View File

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

2
test/test_develop.md
View File

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

2
test/utils/McuProtocol/tool/CMakeLists.txt
View File

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

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

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

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

@ -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};
const unsigned char REPLY_IPC_MISSION[] = {
0xFA, 0xC1, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x0D, 0x01, 0xAA, 0x89};
const 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};
const unsigned char ASK_SET_FEEDING_CYCLE[] = {
constexpr size_t PROTOCOL_CHECK_CODE_LENGTH = sizeof(short);
constexpr size_t PROTOCOL_SERIAL_NUMBER_LENGTH = sizeof(unsigned int);
unsigned char ASK_IPC_MISSION[] = {0xFA, 0xC1, 0x00, 0x00, 0x00, 0x00, 0x81, 0x01, 0x00, 0x0C, 0x71, 0x88};
unsigned char REPLY_IPC_MISSION[] = {0xFA, 0xC1, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x0D, 0x01, 0xAA, 0x89};
unsigned char ASK_CUT_OFF_POWER_SUPPLY[] = {0xFA, 0xC1, 0x00, 0x00, 0x00, 0x00, 0x81, 0x02, 0x00, 0x0C, 0x81, 0x88};
unsigned char ASK_FEED_WATCH_DOG[] = {0xFA, 0xC1, 0x00, 0x00, 0x00, 0x00, 0x81, 0x03, 0x00, 0x0C, 0xD0, 0x48};
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 &&
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) - sizeof(short));
askCheckCode = htons(askCheckCode);
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);
}
CheckSerialNumber(buf, count);
IpcMissionProtocolHandle(mock, uartFd, buf, count);
CutOffPowerSupplyProtocolHandle(mock, uartFd, buf, count);
FeedWatchDogProtocolHandle(mock, uartFd, buf, count);
FeedingCycleProtocolHandle(mock, uartFd, buf, count);
};
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) {

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

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

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

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

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

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