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

Fixed:Mcu manager test code bug.

Browse Source
This commit is contained in:
Fancy code 2024-05-15 22:20:03 +08:00
parent 049521bad1
commit 7df38a8e2a
11 changed files with 202 additions and 39 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
build/sdk_config.cmake
View File

@ -6,7 +6,9 @@ set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
if(${TARGET_PLATFORM} MATCHES ${DEFINE_LINUX}) if(${TARGET_PLATFORM} MATCHES ${DEFINE_LINUX})
message("---------------------------Debug mode.-----------------------") message("---------------------------Debug mode.-----------------------")
SET(CMAKE_BUILD_TYPE "Debug") SET(CMAKE_BUILD_TYPE "Debug")
SET(CMAKE_CXX_FLAGS_DEBUG "$ENV{CXXFLAGS} -O0 -Wall -g2 -ggdb") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -O0 -Wall -g -ggdb")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O0 -Wall -g -ggdb")
SET(CMAKE_CXX_FLAGS_DEBUG "$ENV{CXXFLAGS} -O0 -Wall -g -ggdb")
SET(CMAKE_CXX_FLAGS_RELEASE "$ENV{CXXFLAGS} -O3 -Wall") SET(CMAKE_CXX_FLAGS_RELEASE "$ENV{CXXFLAGS} -O3 -Wall")
# asan # asan
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fsanitize=leak -fsanitize=address -fno-omit-frame-pointer -fsanitize=undefined") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fsanitize=leak -fsanitize=address -fno-omit-frame-pointer -fsanitize=undefined")

19
middleware/McuManager/include/IMcuManager.h
View File

@ -51,11 +51,28 @@ typedef struct mcu_ask_date_time
const unsigned char mMin; const unsigned char mMin;
const unsigned char mSecond; const unsigned char mSecond;
} McuAskDateTime; } McuAskDateTime;
typedef struct mcu_reply_date_time
{
mcu_reply_date_time();
unsigned short mYear;
unsigned char mMon;
unsigned char mDay;
unsigned char mHour;
unsigned char mMin;
unsigned char mSecond;
} McuReplyDateTime;
typedef struct mcu_get_interval_start typedef struct mcu_get_interval_start
{ {
mcu_get_interval_start(); mcu_get_interval_start();
unsigned int mIntervalStart; unsigned char mHour;
unsigned char mMin;
unsigned char mSecond;
} McuGetIntervalStart; } McuGetIntervalStart;
typedef struct mcu_get_sensitivity
{
mcu_get_sensitivity();
unsigned int mSensitivity;
} McuGetPirSensitivity;
/** /**
* @brief The application sends data to the MCU. * @brief The application sends data to the MCU.
* *

8
middleware/McuManager/src/IMcuManager.cpp
View File

@ -19,7 +19,13 @@ mcu_ask_date_time::mcu_ask_date_time(const unsigned short year, const unsigned c
: mYear(year), mMon(mon), mDay(day), mHour(hour), mMin(min), mSecond(second) : mYear(year), mMon(mon), mDay(day), mHour(hour), mMin(min), mSecond(second)
{ {
} }
mcu_get_interval_start::mcu_get_interval_start() : mIntervalStart(0) mcu_reply_date_time::mcu_reply_date_time() : mYear(0), mMon(0), mDay(0), mHour(0), mMin(0), mSecond(0)
{
}
mcu_get_interval_start::mcu_get_interval_start() : mHour(0), mMin(0), mSecond(0)
{
}
mcu_get_sensitivity::mcu_get_sensitivity() : mSensitivity(0)
{ {
} }
VMcuAsk::VMcuAsk() : mSerialNumber(0) VMcuAsk::VMcuAsk() : mSerialNumber(0)

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

@ -51,6 +51,7 @@ const StatusCode McuManagerImpl::UnInit(void)
McuDevice::UnInit(); McuDevice::UnInit();
McuProtocol::UnInit(); McuProtocol::UnInit();
mMcuAskList.clear(); mMcuAskList.clear();
mMonitor.reset();
return CreateStatusCode(STATUS_CODE_OK); return CreateStatusCode(STATUS_CODE_OK);
} }
const StatusCode McuManagerImpl::SetMcuMonitor(std::shared_ptr<VMcuMonitor> &monitor) const StatusCode McuManagerImpl::SetMcuMonitor(std::shared_ptr<VMcuMonitor> &monitor)
@ -219,8 +220,7 @@ void McuManagerImpl::OtherSideSendGetIntervalStart(const unsigned int &serialNum
~McuRecvGetIntervalStart() = default; ~McuRecvGetIntervalStart() = default;
void ReplyFinished(const bool result) override void ReplyFinished(const bool result) override
{ {
McuRecvImpl::mMcuManager->ReplyOtherSideSendGetIntervalStart(mDataRecvReply.mIntervalStart, McuRecvImpl::mMcuManager->ReplyOtherSideSendGetIntervalStart(mDataRecvReply, McuRecvImpl::mSerialNumber);
McuRecvImpl::mSerialNumber);
} }
}; };
std::shared_ptr<VMcuMonitor> monitor = GetMcuMonitor(); std::shared_ptr<VMcuMonitor> monitor = GetMcuMonitor();
@ -238,9 +238,64 @@ void McuManagerImpl::OtherSideSendGetIntervalStart(const unsigned int &serialNum
} }
void McuManagerImpl::OtherSideSendGetDateTime(const unsigned int &serialNumber) void McuManagerImpl::OtherSideSendGetDateTime(const unsigned int &serialNumber)
{ {
class McuRecvGetDateTime : public McuRecvImpl, public McuRecv<McuReplyDateTime>
{
public:
McuRecvGetDateTime(std::shared_ptr<McuManagerImpl> &mcuManager, const unsigned int &serialNumber,
const OtherSideSendType &sendType)
: McuRecvImpl(serialNumber, sendType)
{
McuRecvImpl::mMcuManager = mcuManager;
}
~McuRecvGetDateTime() = default;
void ReplyFinished(const bool result) override
{
McuRecvImpl::mMcuManager->ReplyOtherSideSendGetDateTime(mDataRecvReply, McuRecvImpl::mSerialNumber);
}
};
std::shared_ptr<VMcuMonitor> monitor = GetMcuMonitor();
std::shared_ptr<McuManagerImpl> manager = std::dynamic_pointer_cast<McuManagerImpl>(SharedFromThis());
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->RecvMcuHeartBeat(recv);
}
else {
LogWarning("mMonitor is nullptr, AddMcuRecv.\n");
AddMcuRecv(recv);
}
} }
void McuManagerImpl::OtherSideSendGetPirSensitivity(const unsigned int &serialNumber) void McuManagerImpl::OtherSideSendGetPirSensitivity(const unsigned int &serialNumber)
{ {
class McuRecvGetDateTime : public McuRecvImpl, public McuRecv<McuGetPirSensitivity>
{
public:
McuRecvGetDateTime(std::shared_ptr<McuManagerImpl> &mcuManager, const unsigned int &serialNumber,
const OtherSideSendType &sendType)
: McuRecvImpl(serialNumber, sendType)
{
McuRecvImpl::mMcuManager = mcuManager;
}
~McuRecvGetDateTime() = default;
void ReplyFinished(const bool result) override
{
McuRecvImpl::mMcuManager->ReplyOtherSideSendGetPirSensitivity(mDataRecvReply.mSensitivity,
McuRecvImpl::mSerialNumber);
}
};
std::shared_ptr<VMcuMonitor> monitor = GetMcuMonitor();
std::shared_ptr<McuManagerImpl> manager = std::dynamic_pointer_cast<McuManagerImpl>(SharedFromThis());
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->RecvMcuHeartBeat(recv);
}
else {
LogWarning("mMonitor is nullptr, AddMcuRecv.\n");
AddMcuRecv(recv);
}
} }
void McuManagerImpl::ReplyOtherSideSendIpcMission(const ASK_RESULT &result, const unsigned int &serialNumber) void McuManagerImpl::ReplyOtherSideSendIpcMission(const ASK_RESULT &result, const unsigned int &serialNumber)
{ {
@ -252,15 +307,31 @@ void McuManagerImpl::ReplyOtherSideSendHeartBeat(const unsigned int &serialNumbe
LogInfo("ReplyOtherSideSendHeartBeat\n"); LogInfo("ReplyOtherSideSendHeartBeat\n");
McuProtocol::ReplyOtherSideSendHearBeat(static_cast<ReplyResult>(ASK_RESULT::SUCCEED), serialNumber); McuProtocol::ReplyOtherSideSendHearBeat(static_cast<ReplyResult>(ASK_RESULT::SUCCEED), serialNumber);
} }
void McuManagerImpl::ReplyOtherSideSendGetIntervalStart(const unsigned int &interval, const unsigned int &serialNumber) void McuManagerImpl::ReplyOtherSideSendGetIntervalStart(const McuGetIntervalStart &interval,
const unsigned int &serialNumber)
{ {
LogInfo("ReplyOtherSideSendGetIntervalStart\n");
McuProtocol::ReplyOtherSideSendGetIntervalStart(
static_cast<ReplyResult>(ASK_RESULT::SUCCEED), serialNumber, interval.mHour, interval.mMin, interval.mSecond);
} }
void McuManagerImpl::ReplyOtherSideSendGetDateTime(const McuAskDateTime &time, const unsigned int &serialNumber) void McuManagerImpl::ReplyOtherSideSendGetDateTime(const McuReplyDateTime &time, const unsigned int &serialNumber)
{ {
LogInfo("ReplyOtherSideSendGetDateTime\n");
McuProtocol::ReplyOtherSideSendGetDateTime(static_cast<ReplyResult>(ASK_RESULT::SUCCEED),
serialNumber,
time.mYear,
time.mMon,
time.mDay,
time.mHour,
time.mMin,
time.mSecond);
} }
void McuManagerImpl::ReplyOtherSideSendGetPirSensitivity(const unsigned int &sensitivity, void McuManagerImpl::ReplyOtherSideSendGetPirSensitivity(const unsigned char &sensitivity,
const unsigned int &serialNumber) const unsigned int &serialNumber)
{ {
LogInfo("ReplyOtherSideSendGetPirSensitivity\n");
McuProtocol::ReplyOtherSideSendGetPirSensitivity(
static_cast<ReplyResult>(ASK_RESULT::SUCCEED), serialNumber, sensitivity);
} }
void McuManagerImpl::AddMcuRecv(std::shared_ptr<VMcuRecv> &recv) void McuManagerImpl::AddMcuRecv(std::shared_ptr<VMcuRecv> &recv)
{ {

6
middleware/McuManager/src/McuManagerImpl.h
View File

@ -68,9 +68,9 @@ private:
void OtherSideSendGetPirSensitivity(const unsigned int &serialNumber) override; void OtherSideSendGetPirSensitivity(const unsigned int &serialNumber) override;
void ReplyOtherSideSendIpcMission(const ASK_RESULT &result, const unsigned int &serialNumber); void ReplyOtherSideSendIpcMission(const ASK_RESULT &result, const unsigned int &serialNumber);
void ReplyOtherSideSendHeartBeat(const unsigned int &serialNumber); void ReplyOtherSideSendHeartBeat(const unsigned int &serialNumber);
void ReplyOtherSideSendGetIntervalStart(const unsigned int &interval, const unsigned int &serialNumber); void ReplyOtherSideSendGetIntervalStart(const McuGetIntervalStart &interval, const unsigned int &serialNumber);
void ReplyOtherSideSendGetDateTime(const McuAskDateTime &time, const unsigned int &serialNumber); void ReplyOtherSideSendGetDateTime(const McuReplyDateTime &time, const unsigned int &serialNumber);
void ReplyOtherSideSendGetPirSensitivity(const unsigned int &sensitivity, const unsigned int &serialNumber); void ReplyOtherSideSendGetPirSensitivity(const unsigned char &sensitivity, const unsigned int &serialNumber);
private: // About mMcuAskList private: // About mMcuAskList
void AddMcuRecv(std::shared_ptr<VMcuRecv> &recv); void AddMcuRecv(std::shared_ptr<VMcuRecv> &recv);

36
test/middleware/McuManager/src/McuManager_Test.cpp
View File

@ -83,7 +83,7 @@ TEST_F(McuManagerTest, RH_INTEGRATION_McuManager_AUTO_GetIpcMission)
std::this_thread::sleep_for(std::chrono::milliseconds(100)); std::this_thread::sleep_for(std::chrono::milliseconds(100));
} }
// ../output_files/test/bin/McuManagerTest // ../output_files/test/bin/McuManagerTest
// --gtest_filter=McuManagerMockTest.RH_INTEGRATION_McuManager_AUTO_OtherSideSendIpcMission // --gtest_filter=McuManagerTest.RH_INTEGRATION_McuManager_AUTO_OtherSideSendIpcMission
TEST_F(McuManagerTest, RH_INTEGRATION_McuManager_AUTO_OtherSideSendIpcMission) TEST_F(McuManagerTest, RH_INTEGRATION_McuManager_AUTO_OtherSideSendIpcMission)
{ {
class MonitorTest : public VMcuMonitor class MonitorTest : public VMcuMonitor
@ -99,14 +99,14 @@ TEST_F(McuManagerTest, RH_INTEGRATION_McuManager_AUTO_OtherSideSendIpcMission)
recv->ReplyFinished(true); recv->ReplyFinished(true);
} }
}; };
IMcuManager::GetInstance()->Init(); // IMcuManager::GetInstance()->Init();
std::shared_ptr<VMcuMonitor> monitor = std::make_shared<MonitorTest>(); std::shared_ptr<VMcuMonitor> monitor = std::make_shared<MonitorTest>();
IMcuManager::GetInstance()->SetMcuMonitor(monitor); IMcuManager::GetInstance()->SetMcuMonitor(monitor);
std::this_thread::sleep_for(std::chrono::milliseconds(2000)); std::this_thread::sleep_for(std::chrono::milliseconds(2000));
IMcuManager::GetInstance()->UnInit(); // IMcuManager::GetInstance()->UnInit();
} }
// ../output_files/test/bin/McuManagerTest // ../output_files/test/bin/McuManagerTest
// --gtest_filter=McuManagerMockTest.RH_INTEGRATION_McuManager_AUTO_CutOffPowerSupply // --gtest_filter=McuManagerTest.RH_INTEGRATION_McuManager_AUTO_CutOffPowerSupply
TEST_F(McuManagerTest, RH_INTEGRATION_McuManager_AUTO_CutOffPowerSupply) TEST_F(McuManagerTest, RH_INTEGRATION_McuManager_AUTO_CutOffPowerSupply)
{ {
class McuAskTest : public McuAskBaseTestTool class McuAskTest : public McuAskBaseTestTool
@ -119,17 +119,17 @@ TEST_F(McuManagerTest, RH_INTEGRATION_McuManager_AUTO_CutOffPowerSupply)
} }
virtual ~McuAskTest() = default; virtual ~McuAskTest() = default;
}; };
IMcuManager::GetInstance()->Init(); // IMcuManager::GetInstance()->Init();
std::shared_ptr<VMcuAsk> ask = std::make_shared<McuAskTest>(); std::shared_ptr<VMcuAsk> ask = std::make_shared<McuAskTest>();
std::shared_ptr<McuAskBaseTestTool> testTool = std::dynamic_pointer_cast<McuAskBaseTestTool>(ask); std::shared_ptr<McuAskBaseTestTool> testTool = std::dynamic_pointer_cast<McuAskBaseTestTool>(ask);
testTool->McuAskDefaultFeatures(testTool); testTool->McuAskDefaultFeatures(testTool);
StatusCode code = IMcuManager::GetInstance()->CutOffPowerSupply(ask); StatusCode code = IMcuManager::GetInstance()->CutOffPowerSupply(ask);
EXPECT_EQ(code.mStatusCode, STATUS_CODE_OK); // STATUS_CODE_OK means write data to mcu succeed. EXPECT_EQ(code.mStatusCode, STATUS_CODE_OK); // STATUS_CODE_OK means write data to mcu succeed.
std::this_thread::sleep_for(std::chrono::milliseconds(2000)); std::this_thread::sleep_for(std::chrono::milliseconds(2000));
IMcuManager::GetInstance()->UnInit(); // IMcuManager::GetInstance()->UnInit();
} }
// ../output_files/test/bin/McuManagerTest // ../output_files/test/bin/McuManagerTest
// --gtest_filter=McuManagerMockTest.RH_INTEGRATION_McuManager_AUTO_SetFeedingCycleForWatchDog // --gtest_filter=McuManagerTest.RH_INTEGRATION_McuManager_AUTO_SetFeedingCycleForWatchDog
TEST_F(McuManagerTest, RH_INTEGRATION_McuManager_AUTO_SetFeedingCycleForWatchDog) TEST_F(McuManagerTest, RH_INTEGRATION_McuManager_AUTO_SetFeedingCycleForWatchDog)
{ {
class McuAskTest : public McuAsk<ASK_RESULT>, public McuAskBaseTestTool class McuAskTest : public McuAsk<ASK_RESULT>, public McuAskBaseTestTool
@ -152,17 +152,17 @@ TEST_F(McuManagerTest, RH_INTEGRATION_McuManager_AUTO_SetFeedingCycleForWatchDog
} }
} }
}; };
IMcuManager::GetInstance()->Init(); // IMcuManager::GetInstance()->Init();
std::shared_ptr<VMcuAsk> ask = std::make_shared<McuAskTest>(); std::shared_ptr<VMcuAsk> ask = std::make_shared<McuAskTest>();
std::shared_ptr<McuAskBaseTestTool> testTool = std::dynamic_pointer_cast<McuAskBaseTestTool>(ask); std::shared_ptr<McuAskBaseTestTool> testTool = std::dynamic_pointer_cast<McuAskBaseTestTool>(ask);
testTool->McuAskDefaultFeatures(testTool); testTool->McuAskDefaultFeatures(testTool);
StatusCode code = IMcuManager::GetInstance()->SetFeedingCycleForWatchDog(ask, 1, 1, 1); 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. EXPECT_EQ(code.mStatusCode, STATUS_CODE_OK); // STATUS_CODE_OK means write data to mcu succeed.
std::this_thread::sleep_for(std::chrono::milliseconds(100)); std::this_thread::sleep_for(std::chrono::milliseconds(100));
IMcuManager::GetInstance()->UnInit(); // IMcuManager::GetInstance()->UnInit();
} }
// ../output_files/test/bin/McuManagerTest // ../output_files/test/bin/McuManagerTest
// --gtest_filter=McuManagerMockTest.RH_INTEGRATION_McuManager_AUTO_FeedWatchDog // --gtest_filter=McuManagerTest.RH_INTEGRATION_McuManager_AUTO_FeedWatchDog
TEST_F(McuManagerTest, RH_INTEGRATION_McuManager_AUTO_FeedWatchDog) TEST_F(McuManagerTest, RH_INTEGRATION_McuManager_AUTO_FeedWatchDog)
{ {
class McuAskTest : public McuAskBaseTestTool class McuAskTest : public McuAskBaseTestTool
@ -175,17 +175,17 @@ TEST_F(McuManagerTest, RH_INTEGRATION_McuManager_AUTO_FeedWatchDog)
} }
virtual ~McuAskTest() = default; virtual ~McuAskTest() = default;
}; };
IMcuManager::GetInstance()->Init(); // IMcuManager::GetInstance()->Init();
std::shared_ptr<VMcuAsk> ask = std::make_shared<McuAskTest>(); std::shared_ptr<VMcuAsk> ask = std::make_shared<McuAskTest>();
std::shared_ptr<McuAskBaseTestTool> testTool = std::dynamic_pointer_cast<McuAskBaseTestTool>(ask); std::shared_ptr<McuAskBaseTestTool> testTool = std::dynamic_pointer_cast<McuAskBaseTestTool>(ask);
testTool->McuAskDefaultFeatures(testTool); testTool->McuAskDefaultFeatures(testTool);
StatusCode code = IMcuManager::GetInstance()->FeedWatchDog(ask); StatusCode code = IMcuManager::GetInstance()->FeedWatchDog(ask);
EXPECT_EQ(code.mStatusCode, STATUS_CODE_OK); // STATUS_CODE_OK means write data to mcu succeed. EXPECT_EQ(code.mStatusCode, STATUS_CODE_OK); // STATUS_CODE_OK means write data to mcu succeed.
std::this_thread::sleep_for(std::chrono::milliseconds(2000)); std::this_thread::sleep_for(std::chrono::milliseconds(2000));
IMcuManager::GetInstance()->UnInit(); // IMcuManager::GetInstance()->UnInit();
} }
// ../output_files/test/bin/McuManagerTest // ../output_files/test/bin/McuManagerTest
// --gtest_filter=McuManagerMockTest.RH_INTEGRATION_McuManager_AUTO_SetDataTime // --gtest_filter=McuManagerTest.RH_INTEGRATION_McuManager_AUTO_SetDataTime
TEST_F(McuManagerTest, RH_INTEGRATION_McuManager_AUTO_SetDataTime) TEST_F(McuManagerTest, RH_INTEGRATION_McuManager_AUTO_SetDataTime)
{ {
class McuAskTest : public McuAsk<ASK_RESULT>, public McuAskBaseTestTool class McuAskTest : public McuAsk<ASK_RESULT>, public McuAskBaseTestTool
@ -208,7 +208,7 @@ TEST_F(McuManagerTest, RH_INTEGRATION_McuManager_AUTO_SetDataTime)
} }
} }
}; };
IMcuManager::GetInstance()->Init(); // IMcuManager::GetInstance()->Init();
std::shared_ptr<VMcuAsk> ask = std::make_shared<McuAskTest>(); std::shared_ptr<VMcuAsk> ask = std::make_shared<McuAskTest>();
std::shared_ptr<McuAskBaseTestTool> testTool = std::dynamic_pointer_cast<McuAskBaseTestTool>(ask); std::shared_ptr<McuAskBaseTestTool> testTool = std::dynamic_pointer_cast<McuAskBaseTestTool>(ask);
testTool->McuAskDefaultFeatures(testTool); testTool->McuAskDefaultFeatures(testTool);
@ -216,10 +216,10 @@ TEST_F(McuManagerTest, RH_INTEGRATION_McuManager_AUTO_SetDataTime)
StatusCode code = IMcuManager::GetInstance()->SetDateTime(ask, value); StatusCode code = IMcuManager::GetInstance()->SetDateTime(ask, value);
EXPECT_EQ(code.mStatusCode, STATUS_CODE_OK); // STATUS_CODE_OK means write data to mcu succeed. EXPECT_EQ(code.mStatusCode, STATUS_CODE_OK); // STATUS_CODE_OK means write data to mcu succeed.
std::this_thread::sleep_for(std::chrono::milliseconds(100)); std::this_thread::sleep_for(std::chrono::milliseconds(100));
IMcuManager::GetInstance()->UnInit(); // IMcuManager::GetInstance()->UnInit();
} }
// ../output_files/test/bin/McuManagerTest // ../output_files/test/bin/McuManagerTest
// --gtest_filter=McuManagerMockTest.RH_INTEGRATION_McuManager_AUTO_SetPirSensitivity // --gtest_filter=McuManagerTest.RH_INTEGRATION_McuManager_AUTO_SetPirSensitivity
TEST_F(McuManagerTest, RH_INTEGRATION_McuManager_AUTO_SetPirSensitivity) TEST_F(McuManagerTest, RH_INTEGRATION_McuManager_AUTO_SetPirSensitivity)
{ {
class McuAskTest : public McuAsk<ASK_RESULT>, public McuAskBaseTestTool class McuAskTest : public McuAsk<ASK_RESULT>, public McuAskBaseTestTool
@ -242,13 +242,13 @@ TEST_F(McuManagerTest, RH_INTEGRATION_McuManager_AUTO_SetPirSensitivity)
} }
} }
}; };
IMcuManager::GetInstance()->Init(); // IMcuManager::GetInstance()->Init();
std::shared_ptr<VMcuAsk> ask = std::make_shared<McuAskTest>(); std::shared_ptr<VMcuAsk> ask = std::make_shared<McuAskTest>();
std::shared_ptr<McuAskBaseTestTool> testTool = std::dynamic_pointer_cast<McuAskBaseTestTool>(ask); std::shared_ptr<McuAskBaseTestTool> testTool = std::dynamic_pointer_cast<McuAskBaseTestTool>(ask);
testTool->McuAskDefaultFeatures(testTool); testTool->McuAskDefaultFeatures(testTool);
StatusCode code = IMcuManager::GetInstance()->SetPirSensitivity(ask, 1); StatusCode code = IMcuManager::GetInstance()->SetPirSensitivity(ask, 1);
EXPECT_EQ(code.mStatusCode, STATUS_CODE_OK); // STATUS_CODE_OK means write data to mcu succeed. EXPECT_EQ(code.mStatusCode, STATUS_CODE_OK); // STATUS_CODE_OK means write data to mcu succeed.
std::this_thread::sleep_for(std::chrono::milliseconds(100)); std::this_thread::sleep_for(std::chrono::milliseconds(100));
IMcuManager::GetInstance()->UnInit(); // IMcuManager::GetInstance()->UnInit();
} }
} // namespace McuManagerTest } // namespace McuManagerTest

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

@ -161,8 +161,8 @@ TEST_F(McuManagerMockTest, HS_INTEGRATION_McuManager_EXAMPLE_OtherSideSendIpcMis
void RecvIpcMissionEvent(std::shared_ptr<VMcuRecv> &recv, const IpcMission &mission) override void RecvIpcMissionEvent(std::shared_ptr<VMcuRecv> &recv, const IpcMission &mission) override
{ {
LogInfo("RecvIpcMissionEvent\n"); LogInfo("RecvIpcMissionEvent\n");
std::shared_ptr<McuAsk<ASK_RESULT>> ask = std::dynamic_pointer_cast<McuAsk<ASK_RESULT>>(recv); // std::shared_ptr<McuAsk<ASK_RESULT>> ask = std::dynamic_pointer_cast<McuAsk<ASK_RESULT>>(recv);
ask->mDataReply = ASK_RESULT::SUCCEED; // ask->mDataReply = ASK_RESULT::SUCCEED;
recv->ReplyFinished(true); recv->ReplyFinished(true);
// EXPECT_EQ(TEST_SERIAL_NUMBER, recv->mSerialNumber); // EXPECT_EQ(TEST_SERIAL_NUMBER, recv->mSerialNumber);
} }
@ -191,8 +191,8 @@ TEST_F(McuManagerMockTest, HS_INTEGRATION_McuManager_EXAMPLE_OtherSideSendHeartB
void RecvMcuHeartBeat(std::shared_ptr<VMcuRecv> &recv) override void RecvMcuHeartBeat(std::shared_ptr<VMcuRecv> &recv) override
{ {
LogInfo("RecvMcuHeartBeat\n"); LogInfo("RecvMcuHeartBeat\n");
std::shared_ptr<McuAsk<ASK_RESULT>> ask = std::dynamic_pointer_cast<McuAsk<ASK_RESULT>>(recv); // std::shared_ptr<McuAsk<ASK_RESULT>> ask = std::dynamic_pointer_cast<McuAsk<ASK_RESULT>>(recv);
ask->mDataReply = ASK_RESULT::SUCCEED; // ask->mDataReply = ASK_RESULT::SUCCEED;
recv->ReplyFinished(true); recv->ReplyFinished(true);
// EXPECT_EQ(TEST_SERIAL_NUMBER, recv->mSerialNumber); // EXPECT_EQ(TEST_SERIAL_NUMBER, recv->mSerialNumber);
} }
@ -888,8 +888,7 @@ TEST_F(McuManagerMockTest, HS_INTEGRATION_McuManager_AUTO_OtherSideSendIpcMissio
void RecvIpcMissionEvent(std::shared_ptr<VMcuRecv> &recv, const IpcMission &mission) override void RecvIpcMissionEvent(std::shared_ptr<VMcuRecv> &recv, const IpcMission &mission) override
{ {
LogInfo("RecvIpcMissionEvent\n"); LogInfo("RecvIpcMissionEvent\n");
std::shared_ptr<McuAsk<ASK_RESULT>> ask = std::dynamic_pointer_cast<McuAsk<ASK_RESULT>>(recv); std::shared_ptr<McuRecv<unsigned char>> recvData = std::dynamic_pointer_cast<McuRecv<unsigned char>>(recv);
ask->mDataReply = ASK_RESULT::SUCCEED;
recv->ReplyFinished(true); recv->ReplyFinished(true);
} }
}; };

9
utils/McuProtocol/include/McuProtocol.h
View File

@ -147,6 +147,15 @@ protected:
protected: protected:
void ReplyOtherSideSendIpcMission(const ReplyResult &result, const unsigned int &serialNumber); void ReplyOtherSideSendIpcMission(const ReplyResult &result, const unsigned int &serialNumber);
void ReplyOtherSideSendHearBeat(const ReplyResult &result, const unsigned int &serialNumber); void ReplyOtherSideSendHearBeat(const ReplyResult &result, const unsigned int &serialNumber);
void ReplyOtherSideSendGetIntervalStart(const ReplyResult &result, const unsigned int &serialNumber,
const unsigned char &hour, const unsigned char &min,
const unsigned char &second);
void ReplyOtherSideSendGetDateTime(const ReplyResult &result, const unsigned int &serialNumber,
const unsigned short &year, const unsigned char &mon, const unsigned char &day,
const unsigned char &hour, const unsigned char &min,
const unsigned char &second);
void ReplyOtherSideSendGetPirSensitivity(const ReplyResult &result, const unsigned int &serialNumber,
const unsigned char &sensitivity);
protected: protected:
size_t GetKeyHeadLength(void) override; size_t GetKeyHeadLength(void) override;

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

@ -104,9 +104,9 @@ const StatusCode McuProtocol::SetFeedingCycleForWatchDog(const unsigned char &ho
const unsigned char &second, const unsigned char &second,
std::shared_ptr<VProtocolContext> &context) std::shared_ptr<VProtocolContext> &context)
{ {
WatchDogParam watchDogParam(hour, min, second); SetTime watchDogParam(hour, min, second);
std::shared_ptr<VProtocolParam> param = std::shared_ptr<VProtocolParam> param =
std::make_shared<ProtocolParam<WatchDogParam>>(PROTOCOL_COMMAND::ASK_SET_FEEDING_CYCLE, watchDogParam); std::make_shared<ProtocolParam<SetTime>>(PROTOCOL_COMMAND::ASK_SET_FEEDING_CYCLE, watchDogParam);
std::shared_ptr<ProtocolHandle> handle = ProtocolHandle::CreateProtocolData(param); std::shared_ptr<ProtocolHandle> handle = ProtocolHandle::CreateProtocolData(param);
return WriteProtocolData( return WriteProtocolData(
handle->GetProtocolDataBuff(), handle->GetProtocolDataLength(), context, handle->GetSerialNumber()); handle->GetProtocolDataBuff(), handle->GetProtocolDataLength(), context, handle->GetSerialNumber());
@ -186,6 +186,44 @@ void McuProtocol::ReplyOtherSideSendHearBeat(const ReplyResult &result, const un
WriteProtocolData( WriteProtocolData(
handle->GetProtocolDataBuff(), handle->GetProtocolDataLength(), NULL_CONTEXT, handle->GetSerialNumber()); handle->GetProtocolDataBuff(), handle->GetProtocolDataLength(), NULL_CONTEXT, handle->GetSerialNumber());
} }
void McuProtocol::ReplyOtherSideSendGetIntervalStart(const ReplyResult &result, const unsigned int &serialNumber,
const unsigned char &hour, const unsigned char &min,
const unsigned char &second)
{
std::shared_ptr<VProtocolContext> NULL_CONTEXT;
SetTime interval(hour, min, second);
std::shared_ptr<VProtocolParam> param =
std::make_shared<ProtocolParam<SetTime>>(PROTOCOL_COMMAND::REPLY_OTHER_SIDE_ASK_GET_INTERVAL_START, interval);
std::shared_ptr<ProtocolHandle> handle = ProtocolHandle::CreateProtocolData(param);
param->mSerialNumber = serialNumber;
WriteProtocolData(
handle->GetProtocolDataBuff(), handle->GetProtocolDataLength(), NULL_CONTEXT, handle->GetSerialNumber());
}
void McuProtocol::ReplyOtherSideSendGetDateTime(const ReplyResult &result, const unsigned int &serialNumber,
const unsigned short &year, const unsigned char &mon,
const unsigned char &day, const unsigned char &hour,
const unsigned char &min, const unsigned char &second)
{
std::shared_ptr<VProtocolContext> NULL_CONTEXT;
SetDateTime dateTime(year, 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);
std::shared_ptr<ProtocolHandle> handle = ProtocolHandle::CreateProtocolData(param);
param->mSerialNumber = serialNumber;
WriteProtocolData(
handle->GetProtocolDataBuff(), handle->GetProtocolDataLength(), NULL_CONTEXT, handle->GetSerialNumber());
}
void McuProtocol::ReplyOtherSideSendGetPirSensitivity(const ReplyResult &result, const unsigned int &serialNumber,
const unsigned char &sensitivity)
{
std::shared_ptr<VProtocolContext> NULL_CONTEXT;
std::shared_ptr<VProtocolParam> param = std::make_shared<ProtocolParam<const unsigned char>>(
PROTOCOL_COMMAND::REPLY_OTHER_SIDE_ASK_GET_PIR_SENSITIVITY, static_cast<const unsigned char>(sensitivity));
param->mSerialNumber = serialNumber;
std::shared_ptr<ProtocolHandle> handle = ProtocolHandle::CreateProtocolData(param);
WriteProtocolData(
handle->GetProtocolDataBuff(), handle->GetProtocolDataLength(), NULL_CONTEXT, handle->GetSerialNumber());
}
size_t McuProtocol::GetKeyHeadLength(void) size_t McuProtocol::GetKeyHeadLength(void)
{ {
return ProtocolHandle::GetKeyHeadLength(); return ProtocolHandle::GetKeyHeadLength();

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

@ -43,6 +43,12 @@ ProtocolHandle::ProtocolHandle(const std::shared_ptr<VProtocolParam> &param) : m
std::bind(&ProtocolHandle::MakeReplyOtherSideSendIpcMissionPacket, this, _1); std::bind(&ProtocolHandle::MakeReplyOtherSideSendIpcMissionPacket, this, _1);
mMakePacketFunc[REPLY_OTHER_SIDE_ASK_SEND_HEART_BEAT] = mMakePacketFunc[REPLY_OTHER_SIDE_ASK_SEND_HEART_BEAT] =
std::bind(&ProtocolHandle::MakeReplyOtherSideSendHeartBeatPacket, this, _1); std::bind(&ProtocolHandle::MakeReplyOtherSideSendHeartBeatPacket, this, _1);
mMakePacketFunc[REPLY_OTHER_SIDE_ASK_GET_INTERVAL_START] =
std::bind(&ProtocolHandle::MakeReplyOtherSideGetIntervalStartPacket, this, _1);
mMakePacketFunc[REPLY_OTHER_SIDE_ASK_GET_DATE_TIME] =
std::bind(&ProtocolHandle::MakeReplyOtherSideGetDateTimePacket, this, _1);
mMakePacketFunc[REPLY_OTHER_SIDE_ASK_GET_PIR_SENSITIVITY] =
std::bind(&ProtocolHandle::MakeReplyOtherSideGetPirSensitivityPacket, this, _1);
} }
ProtocolHandle::ProtocolHandle(const void *data, const size_t &length) ProtocolHandle::ProtocolHandle(const void *data, const size_t &length)
{ {
@ -154,7 +160,7 @@ void ProtocolHandle::MakeAskFeedWatchDogPacket(const std::shared_ptr<VProtocolPa
} }
void ProtocolHandle::MakeAskSetFeedingCyclePacket(const std::shared_ptr<VProtocolParam> &param) void ProtocolHandle::MakeAskSetFeedingCyclePacket(const std::shared_ptr<VProtocolParam> &param)
{ {
MakeProtocolData<WatchDogParam>(param); MakeProtocolData<SetTime>(param);
} }
void ProtocolHandle::MakeAskSetDateTimePacket(const std::shared_ptr<VProtocolParam> &param) void ProtocolHandle::MakeAskSetDateTimePacket(const std::shared_ptr<VProtocolParam> &param)
{ {
@ -180,6 +186,18 @@ void ProtocolHandle::MakeAskGetPhotosensitivityPacket(const std::shared_ptr<VPro
{ {
MakeNoUserDataPacket(param); MakeNoUserDataPacket(param);
} }
void ProtocolHandle::MakeReplyOtherSideGetIntervalStartPacket(const std::shared_ptr<VProtocolParam> &param)
{
MakeProtocolData<SetTime>(param);
}
void ProtocolHandle::MakeReplyOtherSideGetDateTimePacket(const std::shared_ptr<VProtocolParam> &param)
{
MakeProtocolData<SetDateTime>(param);
}
void ProtocolHandle::MakeReplyOtherSideGetPirSensitivityPacket(const std::shared_ptr<VProtocolParam> &param)
{
MakeProtocolData<const unsigned char>(param);
}
void ProtocolHandle::AnalyzeProtocolPacket(void) void ProtocolHandle::AnalyzeProtocolPacket(void)
{ {
ProtocolPacket packet = {0}; ProtocolPacket packet = {0};

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

@ -80,7 +80,7 @@ typedef struct watch_dog_param
const unsigned char mHour; const unsigned char mHour;
const unsigned char mMin; const unsigned char mMin;
const unsigned char mSecond; const unsigned char mSecond;
} WatchDogParam; } SetTime;
typedef struct set_date_time 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 short &year, const unsigned char &mon, const unsigned char &day,
@ -168,6 +168,9 @@ private:
void MakeAskGetPhotosensitivityPacket(const std::shared_ptr<VProtocolParam> &param); void MakeAskGetPhotosensitivityPacket(const std::shared_ptr<VProtocolParam> &param);
void MakeReplyOtherSideSendIpcMissionPacket(const std::shared_ptr<VProtocolParam> &param); void MakeReplyOtherSideSendIpcMissionPacket(const std::shared_ptr<VProtocolParam> &param);
void MakeReplyOtherSideSendHeartBeatPacket(const std::shared_ptr<VProtocolParam> &param); void MakeReplyOtherSideSendHeartBeatPacket(const std::shared_ptr<VProtocolParam> &param);
void MakeReplyOtherSideGetIntervalStartPacket(const std::shared_ptr<VProtocolParam> &param);
void MakeReplyOtherSideGetDateTimePacket(const std::shared_ptr<VProtocolParam> &param);
void MakeReplyOtherSideGetPirSensitivityPacket(const std::shared_ptr<VProtocolParam> &param);
template <typename T> template <typename T>
void MakeProtocolData(const std::shared_ptr<VProtocolParam> &param) void MakeProtocolData(const std::shared_ptr<VProtocolParam> &param)
{ {