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

Improve:Mcu protocol and Fixed:test code bug.

Browse Source
This commit is contained in:
Fancy code 2024-05-16 16:28:14 +08:00
parent e05547f0a4
commit 744bf103c9
9 changed files with 231 additions and 31 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
middleware/McuManager/src/McuManagerImpl.cpp
View File

@ -251,6 +251,7 @@ void McuManagerImpl::OtherSideSendGetDateTime(const unsigned int &serialNumber)
~McuRecvGetDateTime() = default;
void ReplyFinished(const bool result) override
{
LogInfo("OtherSideSendGetDateTime finised.\n");
McuRecvImpl::mMcuManager->ReplyOtherSideSendGetDateTime(mDataRecvReply, McuRecvImpl::mSerialNumber);
}
};
@ -259,8 +260,8 @@ void McuManagerImpl::OtherSideSendGetDateTime(const unsigned int &serialNumber)
std::shared_ptr<VMcuRecv> recv =
std::make_shared<McuRecvGetDateTime>(manager, serialNumber, OtherSideSendType::GET_DATE_TIME);
if (monitor) {
LogInfo("Mcu manager report heart beat to mcu monitor.\n");
monitor->RecvMcuHeartBeatEvent(recv);
LogInfo("Mcu manager report get date and time to mcu monitor.\n");
monitor->RecvGetDateTime(recv);
}
else {
LogWarning("mMonitor is nullptr, AddMcuRecv.\n");
@ -281,6 +282,7 @@ void McuManagerImpl::OtherSideSendGetPirSensitivity(const unsigned int &serialNu
~McuRecvGetDateTime() = default;
void ReplyFinished(const bool result) override
{
LogInfo("OtherSideSendGetPirSensitivity finised.\n");
McuRecvImpl::mMcuManager->ReplyOtherSideSendGetPirSensitivity(mDataRecvReply.mSensitivity,
McuRecvImpl::mSerialNumber);
}
@ -290,8 +292,8 @@ void McuManagerImpl::OtherSideSendGetPirSensitivity(const unsigned int &serialNu
std::shared_ptr<VMcuRecv> recv =
std::make_shared<McuRecvGetDateTime>(manager, serialNumber, OtherSideSendType::GET_DATE_TIME);
if (monitor) {
LogInfo("Mcu manager report heart beat to mcu monitor.\n");
monitor->RecvMcuHeartBeatEvent(recv);
LogInfo("Mcu manager report get pir sensitivity to mcu monitor.\n");
monitor->RecvGetPirSensitivity(recv);
}
else {
LogWarning("mMonitor is nullptr, AddMcuRecv.\n");

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

@ -578,7 +578,6 @@ TEST_F(McuManagerMockTest, HS_INTEGRATION_McuManager_AUTO_SetFeedingCycleForWatc
McuAskBaseTestTool::ReplyFinished(result);
if (result) {
LogInfo("Ask data succeed, mDataReply = %d.\n", static_cast<int>(mDataReply));
// Do something here.
}
else {
LogError("Ask data falied.\n");
@ -647,7 +646,6 @@ TEST_F(McuManagerMockTest, HS_INTEGRATION_McuManager_AUTO_STRESS_MultiThreadWrit
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");
@ -666,7 +664,6 @@ TEST_F(McuManagerMockTest, HS_INTEGRATION_McuManager_AUTO_STRESS_MultiThreadWrit
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");
@ -679,7 +676,7 @@ TEST_F(McuManagerMockTest, HS_INTEGRATION_McuManager_AUTO_STRESS_MultiThreadWrit
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));
std::this_thread::sleep_for(std::chrono::milliseconds(1000));
EXPECT_EQ(test->CheckAskExist(ask), false); // Ensure that the request has been processed and deleted.
};
auto threadTest2 = [](McuManagerMockTest *test) {
@ -687,7 +684,7 @@ TEST_F(McuManagerMockTest, HS_INTEGRATION_McuManager_AUTO_STRESS_MultiThreadWrit
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(100));
std::this_thread::sleep_for(std::chrono::milliseconds(1000));
EXPECT_EQ(test->CheckAskExist(ask), false); // Ensure that the request has been processed and deleted.
};
IMcuManager::GetInstance()->Init();
@ -754,7 +751,6 @@ TEST_F(McuManagerMockTest, HS_INTEGRATION_McuManager_AUTO_SetDataTime2)
McuAskBaseTestTool::ReplyFinished(result);
if (result) {
LogInfo("Ask data succeed, mDataReply = %d.\n", static_cast<int>(mDataReply));
// Do something here.
}
else {
LogError("Ask data falied.\n");
@ -911,7 +907,14 @@ TEST_F(McuManagerMockTest, HS_INTEGRATION_McuManager_AUTO_OtherSideGetIntervalSt
void RecvGetIntervalStartEvent(std::shared_ptr<VMcuRecv> &recv) override
{
LogInfo("RecvGetIntervalStartEvent\n");
std::shared_ptr<McuRecv<unsigned char>> recvData = std::dynamic_pointer_cast<McuRecv<unsigned char>>(recv);
std::shared_ptr<McuRecv<McuGetIntervalStart>> recvData =
std::dynamic_pointer_cast<McuRecv<McuGetIntervalStart>>(recv);
EXPECT_NE(recvData, nullptr) << "recvData is not McuGetIntervalStart.";
if (recvData) {
recvData->mDataRecvReply.mHour = 10;
recvData->mDataRecvReply.mMin = 10;
recvData->mDataRecvReply.mSecond = 10;
}
recv->ReplyFinished(true);
}
};
@ -922,4 +925,67 @@ TEST_F(McuManagerMockTest, HS_INTEGRATION_McuManager_AUTO_OtherSideGetIntervalSt
std::this_thread::sleep_for(std::chrono::milliseconds(2000));
IMcuManager::GetInstance()->UnInit();
}
// ../output_files/test/bin/McuManagerTest
// --gtest_filter=McuManagerMockTest.HS_INTEGRATION_McuManager_AUTO_OtherSideGetDateTime
TEST_F(McuManagerMockTest, HS_INTEGRATION_McuManager_AUTO_OtherSideGetDateTime)
{
constexpr unsigned int TEST_SERIAL_NUMBER = 99;
class MonitorTest : public VMcuMonitor
{
public:
MonitorTest() = default;
virtual ~MonitorTest() = default;
void RecvGetDateTime(std::shared_ptr<VMcuRecv> &recv) override
{
LogInfo("RecvGetDateTime\n");
std::shared_ptr<McuRecv<McuReplyDateTime>> recvData =
std::dynamic_pointer_cast<McuRecv<McuReplyDateTime>>(recv);
EXPECT_NE(recvData, nullptr) << "recvData is not McuReplyDateTime.";
if (recvData) {
recvData->mDataRecvReply.mYear = 2024;
recvData->mDataRecvReply.mMon = 10;
recvData->mDataRecvReply.mDay = 10;
recvData->mDataRecvReply.mHour = 10;
recvData->mDataRecvReply.mMin = 10;
recvData->mDataRecvReply.mSecond = 10;
}
recv->ReplyFinished(true);
}
};
IMcuManager::GetInstance()->Init();
MockOtherSideGetDateTime(mLinuxTest, TEST_SERIAL_NUMBER);
std::shared_ptr<VMcuMonitor> monitor = std::make_shared<MonitorTest>();
IMcuManager::GetInstance()->SetMcuMonitor(monitor);
std::this_thread::sleep_for(std::chrono::milliseconds(2000));
IMcuManager::GetInstance()->UnInit();
}
// ../output_files/test/bin/McuManagerTest
// --gtest_filter=McuManagerMockTest.HS_INTEGRATION_McuManager_AUTO_OtherSideGetPirSensitivity
TEST_F(McuManagerMockTest, HS_INTEGRATION_McuManager_AUTO_OtherSideGetPirSensitivity)
{
constexpr unsigned int TEST_SERIAL_NUMBER = 99;
class MonitorTest : public VMcuMonitor
{
public:
MonitorTest() = default;
virtual ~MonitorTest() = default;
void RecvGetPirSensitivity(std::shared_ptr<VMcuRecv> &recv) override
{
LogInfo("RecvGetPirSensitivity\n");
std::shared_ptr<McuRecv<McuGetPirSensitivity>> recvData =
std::dynamic_pointer_cast<McuRecv<McuGetPirSensitivity>>(recv);
EXPECT_NE(recvData, nullptr) << "recvData is not McuGetPirSensitivity.";
if (recvData) {
recvData->mDataRecvReply.mSensitivity = 9;
}
recv->ReplyFinished(true);
}
};
IMcuManager::GetInstance()->Init();
MockOtherSideGetPriSensitivity(mLinuxTest, TEST_SERIAL_NUMBER);
std::shared_ptr<VMcuMonitor> monitor = std::make_shared<MonitorTest>();
IMcuManager::GetInstance()->SetMcuMonitor(monitor);
std::this_thread::sleep_for(std::chrono::milliseconds(2000));
IMcuManager::GetInstance()->UnInit();
}
} // namespace McuManagerMockTest

2
test/middleware/McuManager/tool/include/McuManagerTestTool.h
View File

@ -37,6 +37,8 @@ public:
void MockOtherSideAskIpcMission(std::shared_ptr<LinuxTest> &mock, const unsigned int &serialNumber);
void MockOtherSideAskHeartBeat(std::shared_ptr<LinuxTest> &mock, const unsigned int &serialNumber);
void MockOtherSideGetIntervalStart(std::shared_ptr<LinuxTest> &mock, const unsigned int &serialNumber);
void MockOtherSideGetDateTime(std::shared_ptr<LinuxTest> &mock, const unsigned int &serialNumber);
void MockOtherSideGetPriSensitivity(std::shared_ptr<LinuxTest> &mock, const unsigned int &serialNumber);
void MockMcuDeviceOpenFailed(std::shared_ptr<LinuxTest> &mock);
void MockMcuDeviceOpenSuccessButReadNothing(std::shared_ptr<LinuxTest> &mock);

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

@ -57,6 +57,15 @@ void McuManagerTestTool::MockOtherSideGetIntervalStart(std::shared_ptr<LinuxTest
{
McuProtocolTestTool::MockOtherSideAskGetIntervalStart(mock, serialNumber);
}
void McuManagerTestTool::MockOtherSideGetDateTime(std::shared_ptr<LinuxTest> &mock, const unsigned int &serialNumber)
{
McuProtocolTestTool::MockOtherSideAskGetDateTime(mock, serialNumber);
}
void McuManagerTestTool::MockOtherSideGetPriSensitivity(std::shared_ptr<LinuxTest> &mock,
const unsigned int &serialNumber)
{
McuProtocolTestTool::MockOtherSideAskGetPirSensitivity(mock, serialNumber);
}
void McuManagerTestTool::MockMcuDeviceOpenFailed(std::shared_ptr<LinuxTest> &mock)
{
UartDeviceTestTool::SetUartDeviceOpenFailed(mock, gUartDevice);

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

@ -34,6 +34,8 @@ public:
void MockOtherSideAskIpcMission(std::shared_ptr<LinuxTest> &mock, const unsigned int &serialNumber);
void MockOtherSideAskHeartBeat(std::shared_ptr<LinuxTest> &mock, const unsigned int &serialNumber);
void MockOtherSideAskGetIntervalStart(std::shared_ptr<LinuxTest> &mock, const unsigned int &serialNumber);
void MockOtherSideAskGetDateTime(std::shared_ptr<LinuxTest> &mock, const unsigned int &serialNumber);
void MockOtherSideAskGetPirSensitivity(std::shared_ptr<LinuxTest> &mock, const unsigned int &serialNumber);
void ReadNothingAnyTime(std::shared_ptr<LinuxTest> &mock);
private:
@ -80,6 +82,14 @@ private:
const unsigned int &serialNumber);
void OtherSideAskGetIntervalStartInit(std::shared_ptr<LinuxTest> &mock, const int &uartFd,
const unsigned int &serialNumber);
void OtherSideAskGetDateTimeHandle(std::shared_ptr<LinuxTest> &mock, const int &uartFd,
const unsigned int &serialNumber);
void OtherSideAskGetDateTimeInit(std::shared_ptr<LinuxTest> &mock, const int &uartFd,
const unsigned int &serialNumber);
void OtherSideAskGetPirSensitivityHandle(std::shared_ptr<LinuxTest> &mock, const int &uartFd,
const unsigned int &serialNumber);
void OtherSideAskGetPirSensitivityInit(std::shared_ptr<LinuxTest> &mock, const int &uartFd,
const unsigned int &serialNumber);
private:
static void PrintHexadecimalData(const void *buf, const size_t &bufLength, const char *log);

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

@ -48,7 +48,7 @@ unsigned char ASK_SET_FEEDING_CYCLE_X[] = {
unsigned char REPLY_SET_FEEDING_CYCLE_X[] = {
0xFA, 0xC1, 0x00, 0x00, 0x00, 0x00, 0x01, 0x04, 0x00, 0x0D, 0x01, 0xFF, 0xFF};
unsigned char ASK_SET_DATE_TIME_X[] = {
0xFA, 0xC1, 0x00, 0x00, 0x00, 0x01, 0x81, 0x07, 0x00, 0x13, 0xDE, 0x07, 0x01, 0x0F, 0x00, 0x00, 0x00, 0xFF, 0xFF};
0xFA, 0xC1, 0x00, 0x00, 0x00, 0x01, 0x81, 0x07, 0x00, 0x12, 0x20, 0x01, 0x0F, 0x00, 0x00, 0x00, 0xFF, 0xFF};
unsigned char REPLY_SET_DATE_TIME_X[] = {0xFA, 0xC1, 0x00, 0x00, 0x00, 0x00, 0x01, 0x07, 0x00, 0x0D, 0x01, 0xFF, 0xFF};
unsigned char ASK_SET_PIR_SENSITIVITY_X[] = {
0xFA, 0xC1, 0x00, 0x00, 0x00, 0x01, 0x81, 0x08, 0x00, 0x0D, 0x09, 0xFF, 0xFF};
@ -73,6 +73,14 @@ unsigned char REPLY_OTHER_SIDE_ASK_GET_INTERVAL_START_X[] = {
0xFA, 0xC1, 0x00, 0x00, 0x00, 0x00, 0xC1, 0x06, 0x00, 0x0F, 0x00, 0x00, 0x00, 0xFF, 0xFF};
unsigned char OTHER_SIDE_ASK_GET_INTERVAL_START_X[] = {
0xFA, 0xC1, 0x00, 0x00, 0x00, 0x00, 0x41, 0x06, 0x00, 0x0C, 0xFF, 0xFF};
unsigned char REPLY_OTHER_SIDE_ASK_GET_DATE_TIME_X[] = {
0xFA, 0xC1, 0x00, 0x00, 0x00, 0x00, 0xC1, 0x07, 0x00, 0x13, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF};
unsigned char OTHER_SIDE_ASK_GET_DATE_TIME_X[] = {
0xFA, 0xC1, 0x00, 0x00, 0x00, 0x00, 0x41, 0x07, 0x00, 0x0C, 0xFF, 0xFF};
unsigned char REPLY_OTHER_SIDE_ASK_GET_SENSITIVITY_X[] = {
0xFA, 0xC1, 0x00, 0x00, 0x00, 0x00, 0xC1, 0x08, 0x00, 0x0C, 0x00, 0xFF, 0xFF};
unsigned char OTHER_SIDE_ASK_GET_SENSITIVITY_X[] = {
0xFA, 0xC1, 0x00, 0x00, 0x00, 0x00, 0x41, 0x08, 0x00, 0x0C, 0xFF, 0xFF};
McuProtocolTestTool::McuProtocolTestTool()
{
mThreadRuning = false;
@ -154,6 +162,16 @@ void McuProtocolTestTool::MockOtherSideAskGetIntervalStart(std::shared_ptr<Linux
{
OtherSideAskGetIntervalStartHandle(mock, mUartFd, serialNumber);
}
void McuProtocolTestTool::MockOtherSideAskGetDateTime(std::shared_ptr<LinuxTest> &mock,
const unsigned int &serialNumber)
{
OtherSideAskGetDateTimeHandle(mock, mUartFd, serialNumber);
}
void McuProtocolTestTool::MockOtherSideAskGetPirSensitivity(std::shared_ptr<LinuxTest> &mock,
const unsigned int &serialNumber)
{
OtherSideAskGetPirSensitivityHandle(mock, mUartFd, serialNumber);
}
void McuProtocolTestTool::ReadNothingAnyTime(std::shared_ptr<LinuxTest> &mock)
{
static size_t WRITE_COUNT = -1;
@ -296,12 +314,12 @@ void McuProtocolTestTool::IpcMissionProtocolInit(std::shared_ptr<LinuxTest> &moc
size_t count)
{
LockProtocolHandle();
LogInfo("IpcMissionProtocolInit start.\n");
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;
auto apiReadKeyHead = [=](int fd, void *buf, size_t count) {
memcpy(buf, REPLY_IPC_MISSION_X, PROTOCOL_DATA_KEY_HEAD_LENGTH);
@ -311,11 +329,13 @@ void McuProtocolTestTool::IpcMissionProtocolInit(std::shared_ptr<LinuxTest> &moc
memcpy(buf, REPLY_IPC_MISSION_X + PROTOCOL_DATA_KEY_HEAD_LENGTH, LEFT_DATA_LENGTH);
McuProtocolTestTool::PrintHexadecimalData(buf, LEFT_DATA_LENGTH, "IpcMissionProtocolInit read:");
UnlockProtocolHandle();
LogInfo("IpcMissionProtocolInit finished.\n");
};
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)));
ReplySelectSucceed(mock, uartFd);
}
bool McuProtocolTestTool::CutOffPowerSupplyProtocolHandle(std::shared_ptr<LinuxTest> &mock, const int &uartFd,
const void *buf, size_t count)
@ -325,11 +345,9 @@ bool McuProtocolTestTool::CutOffPowerSupplyProtocolHandle(std::shared_ptr<LinuxT
PROTOCOL_COMMAND_LENGTH) == 0) {
LogInfo("Set ASK_CUT_OFF_POWER_SUPPLY_X\n");
short askCheckCode = calculate_check_sum((unsigned char *)buf, count - PROTOCOL_CHECK_CODE_LENGTH);
// askCheckCode = htons(askCheckCode);
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.";
// IpcMissionProtocolInit(mock, uartFd);
return PROTOCOL_HANDLED;
}
return PROTOCOL_NOT_HANDLED;
@ -346,7 +364,6 @@ bool McuProtocolTestTool::FeedWatchDogProtocolHandle(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.";
// IpcMissionProtocolInit(mock, uartFd);
return PROTOCOL_HANDLED;
}
return PROTOCOL_NOT_HANDLED;
@ -362,7 +379,6 @@ bool McuProtocolTestTool::FeedingCycleProtocolHandle(std::shared_ptr<LinuxTest>
replyCheckCode = htons(replyCheckCode);
LogInfo("Set ASK_SET_FEEDING_CYCLE_X, reply data check code = 0x%x\n", replyCheckCode);
short askCheckCode = calculate_check_sum((unsigned char *)buf, count - PROTOCOL_CHECK_CODE_LENGTH);
// askCheckCode = htons(askCheckCode);
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.";
@ -379,7 +395,6 @@ bool McuProtocolTestTool::FeedingCycleProtocolHandle(std::shared_ptr<LinuxTest>
mLockThread.join();
}
mLockThread = std::thread(handle, this);
// FeedingCycleProtocolInit(mock, uartFd);
return PROTOCOL_HANDLED;
}
return PROTOCOL_NOT_HANDLED;
@ -388,12 +403,12 @@ void McuProtocolTestTool::FeedingCycleProtocolInit(std::shared_ptr<LinuxTest> &m
size_t count)
{
LockProtocolHandle();
LogInfo("FeedingCycleProtocolInit start.\n");
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;
auto apiReadKeyHead = [=](int fd, void *buf, size_t count) {
memcpy(buf, REPLY_SET_FEEDING_CYCLE_X, PROTOCOL_DATA_KEY_HEAD_LENGTH);
@ -403,11 +418,13 @@ void McuProtocolTestTool::FeedingCycleProtocolInit(std::shared_ptr<LinuxTest> &m
memcpy(buf, REPLY_SET_FEEDING_CYCLE_X + PROTOCOL_DATA_KEY_HEAD_LENGTH, LEFT_DATA_LENGTH);
McuProtocolTestTool::PrintHexadecimalData(buf, LEFT_DATA_LENGTH, "FeedingCycleProtocolInit read:");
UnlockProtocolHandle();
LogInfo("FeedingCycleProtocolInit finished.\n");
};
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)));
ReplySelectSucceed(mock, uartFd);
}
bool McuProtocolTestTool::SetDataTimeProtocolHandle(std::shared_ptr<LinuxTest> &mock, const int &uartFd,
const void *buf, size_t count)
@ -450,7 +467,6 @@ void McuProtocolTestTool::SetDataTimeProtocolInit(std::shared_ptr<LinuxTest> &mo
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;
auto apiReadKeyHead = [=](int fd, void *buf, size_t count) {
memcpy(buf, REPLY_SET_DATE_TIME_X, PROTOCOL_DATA_KEY_HEAD_LENGTH);
@ -465,6 +481,7 @@ void McuProtocolTestTool::SetDataTimeProtocolInit(std::shared_ptr<LinuxTest> &mo
.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)));
ReplySelectSucceed(mock, uartFd);
}
bool McuProtocolTestTool::SetPirSensitivityProtocolHandle(std::shared_ptr<LinuxTest> &mock, const int &uartFd,
const void *buf, size_t count)
@ -506,7 +523,6 @@ void McuProtocolTestTool::SetPirSensitivityProtocolInit(std::shared_ptr<LinuxTes
(unsigned char *)buf + PROTOCOL_SERIAL_NUMBER_OFFSET,
PROTOCOL_SERIAL_NUMBER_LENGTH);
ResetCheckCode(REPLY_SET_PIR_SENSITIVITY_X, sizeof(REPLY_SET_PIR_SENSITIVITY_X));
ReplySelectSucceed(mock, uartFd);
constexpr int LEFT_DATA_LENGTH = sizeof(REPLY_SET_PIR_SENSITIVITY_X) - PROTOCOL_DATA_KEY_HEAD_LENGTH;
auto apiReadKeyHead = [=](int fd, void *buf, size_t count) {
memcpy(buf, REPLY_SET_PIR_SENSITIVITY_X, PROTOCOL_DATA_KEY_HEAD_LENGTH);
@ -522,6 +538,7 @@ void McuProtocolTestTool::SetPirSensitivityProtocolInit(std::shared_ptr<LinuxTes
.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)));
ReplySelectSucceed(mock, uartFd);
}
bool McuProtocolTestTool::ContorlInfraredLightHandle(std::shared_ptr<LinuxTest> &mock, const int &uartFd,
const void *buf, size_t count)
@ -565,7 +582,6 @@ void McuProtocolTestTool::ContorlInfraredLightInit(std::shared_ptr<LinuxTest> &m
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;
auto apiReadKeyHead = [=](int fd, void *buf, size_t count) {
memcpy(buf, REPLY_ASK_CONTORL_INFRARED_LIGHT_X, PROTOCOL_DATA_KEY_HEAD_LENGTH);
@ -580,6 +596,7 @@ void McuProtocolTestTool::ContorlInfraredLightInit(std::shared_ptr<LinuxTest> &m
.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)));
ReplySelectSucceed(mock, uartFd);
}
bool McuProtocolTestTool::GetPhotosensitivityValueHandle(std::shared_ptr<LinuxTest> &mock, const int &uartFd,
const void *buf, size_t count)
@ -622,7 +639,6 @@ void McuProtocolTestTool::GetPhotosensitivityValueInit(std::shared_ptr<LinuxTest
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;
auto apiReadKeyHead = [=](int fd, void *buf, size_t count) {
memcpy(buf, REPLY_ASK_GET_PHOTOSENSITIVITY_X, PROTOCOL_DATA_KEY_HEAD_LENGTH);
@ -638,6 +654,7 @@ void McuProtocolTestTool::GetPhotosensitivityValueInit(std::shared_ptr<LinuxTest
.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)));
ReplySelectSucceed(mock, uartFd);
}
void McuProtocolTestTool::UnlockProtocolHandle(void)
{
@ -693,7 +710,6 @@ void McuProtocolTestTool::OtherSideAskIpcMissionInit(std::shared_ptr<LinuxTest>
memcpy(
OTHER_SIDE_ASK_SEND_IPC_MISSION_X + PROTOCOL_SERIAL_NUMBER_OFFSET, &serialNum, PROTOCOL_SERIAL_NUMBER_LENGTH);
ResetCheckCode(OTHER_SIDE_ASK_SEND_IPC_MISSION_X, sizeof(OTHER_SIDE_ASK_SEND_IPC_MISSION_X));
ReplySelectSucceed(mock, uartFd);
constexpr int LEFT_DATA_LENGTH = sizeof(OTHER_SIDE_ASK_SEND_IPC_MISSION_X) - PROTOCOL_DATA_KEY_HEAD_LENGTH;
auto apiReadKeyHead = [=](int fd, void *buf, size_t count) {
memcpy(buf, OTHER_SIDE_ASK_SEND_IPC_MISSION_X, PROTOCOL_DATA_KEY_HEAD_LENGTH);
@ -709,6 +725,7 @@ void McuProtocolTestTool::OtherSideAskIpcMissionInit(std::shared_ptr<LinuxTest>
.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)));
ReplySelectSucceed(mock, uartFd);
std::shared_ptr<ProtocolMonitorTest> test =
std::dynamic_pointer_cast<ProtocolMonitorTest>(ProtocolMonitorTest::GetInstance());
if (test) {
@ -740,7 +757,6 @@ void McuProtocolTestTool::OtherSideAskHeartBeatInit(std::shared_ptr<LinuxTest> &
serialNum = htonl(serialNum);
memcpy(OTHER_SIDE_ASK_SEND_HEART_BEAT_X + PROTOCOL_SERIAL_NUMBER_OFFSET, &serialNum, PROTOCOL_SERIAL_NUMBER_LENGTH);
ResetCheckCode(OTHER_SIDE_ASK_SEND_HEART_BEAT_X, sizeof(OTHER_SIDE_ASK_SEND_HEART_BEAT_X));
ReplySelectSucceed(mock, uartFd);
constexpr int LEFT_DATA_LENGTH = sizeof(OTHER_SIDE_ASK_SEND_HEART_BEAT_X) - PROTOCOL_DATA_KEY_HEAD_LENGTH;
auto apiReadKeyHead = [=](int fd, void *buf, size_t count) {
memcpy(buf, OTHER_SIDE_ASK_SEND_HEART_BEAT_X, PROTOCOL_DATA_KEY_HEAD_LENGTH);
@ -756,6 +772,7 @@ void McuProtocolTestTool::OtherSideAskHeartBeatInit(std::shared_ptr<LinuxTest> &
.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)));
ReplySelectSucceed(mock, uartFd);
std::shared_ptr<ProtocolMonitorTest> test =
std::dynamic_pointer_cast<ProtocolMonitorTest>(ProtocolMonitorTest::GetInstance());
if (test) {
@ -788,7 +805,6 @@ void McuProtocolTestTool::OtherSideAskGetIntervalStartInit(std::shared_ptr<Linux
memcpy(
OTHER_SIDE_ASK_GET_INTERVAL_START_X + PROTOCOL_SERIAL_NUMBER_OFFSET, &serialNum, PROTOCOL_SERIAL_NUMBER_LENGTH);
ResetCheckCode(OTHER_SIDE_ASK_GET_INTERVAL_START_X, sizeof(OTHER_SIDE_ASK_GET_INTERVAL_START_X));
ReplySelectSucceed(mock, uartFd);
constexpr int LEFT_DATA_LENGTH = sizeof(OTHER_SIDE_ASK_GET_INTERVAL_START_X) - PROTOCOL_DATA_KEY_HEAD_LENGTH;
auto apiReadKeyHead = [=](int fd, void *buf, size_t count) {
memcpy(buf, OTHER_SIDE_ASK_GET_INTERVAL_START_X, PROTOCOL_DATA_KEY_HEAD_LENGTH);
@ -804,6 +820,7 @@ void McuProtocolTestTool::OtherSideAskGetIntervalStartInit(std::shared_ptr<Linux
.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)));
ReplySelectSucceed(mock, uartFd);
std::shared_ptr<ProtocolMonitorTest> test =
std::dynamic_pointer_cast<ProtocolMonitorTest>(ProtocolMonitorTest::GetInstance());
if (test) {
@ -815,6 +832,100 @@ void McuProtocolTestTool::OtherSideAskGetIntervalStartInit(std::shared_ptr<Linux
sizeof(REPLY_OTHER_SIDE_ASK_GET_INTERVAL_START_X));
}
}
void McuProtocolTestTool::OtherSideAskGetDateTimeHandle(std::shared_ptr<LinuxTest> &mock, const int &uartFd,
const unsigned int &serialNumber)
{
LogInfo("OtherSideAskGetDateTimeHandle\n");
auto handle = [=, &mock](McuProtocolTestTool *testTool) {
testTool->OtherSideAskGetDateTimeInit(mock, uartFd, serialNumber);
};
if (mLockThread.joinable()) {
mLockThread.join();
}
mLockThread = std::thread(handle, this);
}
void McuProtocolTestTool::OtherSideAskGetDateTimeInit(std::shared_ptr<LinuxTest> &mock, const int &uartFd,
const unsigned int &serialNumber)
{
LockProtocolHandle();
unsigned int serialNum = serialNumber;
serialNum = htonl(serialNum);
memcpy(OTHER_SIDE_ASK_GET_DATE_TIME_X + PROTOCOL_SERIAL_NUMBER_OFFSET, &serialNum, PROTOCOL_SERIAL_NUMBER_LENGTH);
ResetCheckCode(OTHER_SIDE_ASK_GET_DATE_TIME_X, sizeof(OTHER_SIDE_ASK_GET_DATE_TIME_X));
constexpr int LEFT_DATA_LENGTH = sizeof(OTHER_SIDE_ASK_GET_DATE_TIME_X) - PROTOCOL_DATA_KEY_HEAD_LENGTH;
auto apiReadKeyHead = [=](int fd, void *buf, size_t count) {
memcpy(buf, OTHER_SIDE_ASK_GET_DATE_TIME_X, PROTOCOL_DATA_KEY_HEAD_LENGTH);
McuProtocolTestTool::PrintHexadecimalData(
buf, PROTOCOL_DATA_KEY_HEAD_LENGTH, "OtherSideAskGetDateTimeInit read:");
};
auto apiReadLeftData = [=](int fd, void *buf, size_t count) {
memcpy(buf, OTHER_SIDE_ASK_GET_DATE_TIME_X + PROTOCOL_DATA_KEY_HEAD_LENGTH, LEFT_DATA_LENGTH);
McuProtocolTestTool::PrintHexadecimalData(buf, LEFT_DATA_LENGTH, "OtherSideAskGetDateTimeInit read:");
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)));
ReplySelectSucceed(mock, uartFd);
std::shared_ptr<ProtocolMonitorTest> test =
std::dynamic_pointer_cast<ProtocolMonitorTest>(ProtocolMonitorTest::GetInstance());
if (test) {
ProtocolMonitorTest::WriteDataOnce(test,
PROTOCOL_HEAD,
serialNumber,
REPLY_OTHER_SIDE_ASK_GET_DATE_TIME,
nullptr,
sizeof(REPLY_OTHER_SIDE_ASK_GET_DATE_TIME_X));
}
}
void McuProtocolTestTool::OtherSideAskGetPirSensitivityHandle(std::shared_ptr<LinuxTest> &mock, const int &uartFd,
const unsigned int &serialNumber)
{
LogInfo("OtherSideAskGetPirSensitivityHandle\n");
auto handle = [=, &mock](McuProtocolTestTool *testTool) {
testTool->OtherSideAskGetPirSensitivityInit(mock, uartFd, serialNumber);
};
if (mLockThread.joinable()) {
mLockThread.join();
}
mLockThread = std::thread(handle, this);
}
void McuProtocolTestTool::OtherSideAskGetPirSensitivityInit(std::shared_ptr<LinuxTest> &mock, const int &uartFd,
const unsigned int &serialNumber)
{
LockProtocolHandle();
unsigned int serialNum = serialNumber;
serialNum = htonl(serialNum);
memcpy(OTHER_SIDE_ASK_GET_SENSITIVITY_X + PROTOCOL_SERIAL_NUMBER_OFFSET, &serialNum, PROTOCOL_SERIAL_NUMBER_LENGTH);
ResetCheckCode(OTHER_SIDE_ASK_GET_SENSITIVITY_X, sizeof(OTHER_SIDE_ASK_GET_SENSITIVITY_X));
constexpr int LEFT_DATA_LENGTH = sizeof(OTHER_SIDE_ASK_GET_SENSITIVITY_X) - PROTOCOL_DATA_KEY_HEAD_LENGTH;
auto apiReadKeyHead = [=](int fd, void *buf, size_t count) {
memcpy(buf, OTHER_SIDE_ASK_GET_SENSITIVITY_X, PROTOCOL_DATA_KEY_HEAD_LENGTH);
McuProtocolTestTool::PrintHexadecimalData(
buf, PROTOCOL_DATA_KEY_HEAD_LENGTH, "OtherSideAskGetPirSensitivityInit read:");
};
auto apiReadLeftData = [=](int fd, void *buf, size_t count) {
memcpy(buf, OTHER_SIDE_ASK_GET_SENSITIVITY_X + PROTOCOL_DATA_KEY_HEAD_LENGTH, LEFT_DATA_LENGTH);
McuProtocolTestTool::PrintHexadecimalData(buf, LEFT_DATA_LENGTH, "OtherSideAskGetPirSensitivityInit read:");
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)));
ReplySelectSucceed(mock, uartFd);
std::shared_ptr<ProtocolMonitorTest> test =
std::dynamic_pointer_cast<ProtocolMonitorTest>(ProtocolMonitorTest::GetInstance());
if (test) {
ProtocolMonitorTest::WriteDataOnce(test,
PROTOCOL_HEAD,
serialNumber,
REPLY_OTHER_SIDE_ASK_GET_PIR_SENSITIVITY,
nullptr,
sizeof(REPLY_OTHER_SIDE_ASK_GET_SENSITIVITY_X));
}
}
void McuProtocolTestTool::PrintHexadecimalData(const void *buf, const size_t &bufLength, const char *log)
{
printf("%s { 0x%02X", log, *(unsigned char *)buf);

4
utils/McuProtocol/README.md
View File

@ -137,7 +137,7 @@ unsigned short calculate_check_sum(const unsigned char* pData, unsigned short le
| 0x0105 | - | reply | Data[0]:结果<br>0x01:成功<br>0x02:失败 | 关闭狗回复 | 取消 |
| 0x8106 | ask | - | Data[0]:Hour<br>0-23<br>Data[1]:Min<br>0-59<br>Data[2]:Sec<br>0-59 | 设置间隔启动时间 | 定时启动 |
| 0x0106 | - | reply | Data[0]:结果<br>0x01:成功<br>0x02:失败 | 设置间隔启动时间回复 | - |
| 0x8107 | ask | - | Data[0]:Year<br>Data[1]:Mon<br>1-12<br>Data[2]:Day<br>0-31<br>Data[3]:Hour<br>0-23<br>Data[4]:Min<br>0-59<br>Data[5]:Sec<br>0-59 | 设置日期和时间 | - |
| 0x8107 | ask | - | Data[0]:Year<br>0-255<br>Data[1]:Mon<br>1-12<br>Data[2]:Day<br>0-31<br>Data[3]:Hour<br>0-23<br>Data[4]:Min<br>0-59<br>Data[5]:Sec<br>0-59 | 设置日期和时间 | 年份需要+1970修正 |
| 0x0107 | - | reply | Data[0]:结果<br>0x01:成功<br>0x02:失败 | 设置日期和时间回复 | - |
| 0x8108 | ask | - | Data[0]:灵敏度<br>0-9 | 设置PIR灵敏度 | - |
| 0x0108 | - | reply | Data[0]:结果<br>0x01:成功<br>0x02:失败 | 设置PIR灵敏度回复 | - |
@ -154,7 +154,7 @@ unsigned short calculate_check_sum(const unsigned char* pData, unsigned short le
| 0x4102 | - | ask | - | 发送心跳包 | 取消 |
| 0xC106 | reply | - | Data[0]:Hour<br>0-23<br>Data[1]:Min<br>0-59<br>Data[2]:Sec<br>0-59 | 回复获取间隔启动时间 | - |
| 0x4106 | - | ask | - | 获取间隔启动时间 | - |
| 0xC107 | reply | - | Data[0]:Year<br>Data[1]:Mon<br>1-12<br>Data[2]:Day<br>0-31<br>Data[3]:Hour<br>0-23<br>Data[4]:Min<br>0-59<br>Data[5]:Sec<br>0-59 | 回复获取日期和时间 | - |
| 0xC107 | reply | - | Data[0]:Year<br>0-255<br>Data[1]:Mon<br>1-12<br>Data[2]:Day<br>0-31<br>Data[3]:Hour<br>0-23<br>Data[4]:Min<br>0-59<br>Data[5]:Sec<br>0-59 | 回复获取日期和时间 | 年份需要+1970修正 |
| 0x4107 | - | ask | - | 获取日期和时间 | - |
| 0xC108 | reply | - | Data[0]:灵敏度<br>0-9 | 回复获取PIR灵敏度 | - |
| 0x4108 | - | ask | - | 获取PIR灵敏度 | - |

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

@ -205,7 +205,7 @@ void McuProtocol::ReplyOtherSideSendGetDateTime(const ReplyResult &result, const
const unsigned char &min, const unsigned char &second)
{
std::shared_ptr<VProtocolContext> NULL_CONTEXT;
SetDateTime dateTime(year, mon, day, hour, min, second);
SetDateTime dateTime(year - 1970, mon, day, hour, min, second);
std::shared_ptr<VProtocolParam> param =
std::make_shared<ProtocolParam<SetDateTime>>(PROTOCOL_COMMAND::REPLY_OTHER_SIDE_ASK_GET_DATE_TIME, dateTime);
param->mSerialNumber = serialNumber;

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

@ -83,12 +83,12 @@ typedef struct watch_dog_param
} SetTime;
typedef struct set_date_time
{
set_date_time(const unsigned short &year, const unsigned char &mon, const unsigned char &day,
set_date_time(const unsigned char &year, const unsigned char &mon, const unsigned char &day,
const unsigned char &hour, const unsigned char &min, const unsigned char &second)
: mYear(year), mMon(mon), mDay(day), mHour(hour), mMin(min), mSecond(second)
{
}
const unsigned short mYear;
const unsigned char mYear;
const unsigned char mMon;
const unsigned char mDay;
const unsigned char mHour;