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

Fixed:McuProtocol test tool bug.

Browse Source
This commit is contained in:
Fancy code 2024-03-04 22:01:59 -08:00
parent 50be3bf21b
commit 8ddb9d917d
16 changed files with 135 additions and 26 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
application/HunttingCamera/build/huntting_camera.cmake
View File

@ -1,8 +1,10 @@
set(HUNTTING_MAIN_INCLUDE_PATH "${APPLICATION_SOURCE_PATH}/HunttingCamera/src")
set(HUNTTING_MAIN_INCLUDE_PATH "${HUNTTING_MAIN_INCLUDE_PATH};${APPLICATION_SOURCE_PATH}/MissionManager/include")
set(HUNTTING_MAIN_INCLUDE_PATH "${HUNTTING_MAIN_INCLUDE_PATH};${MIDDLEWARE_SOURCE_PATH}/StateMachine/include")
set(HUNTTING_MAIN_INCLUDE_PATH "${HUNTTING_MAIN_INCLUDE_PATH};${MIDDLEWARE_SOURCE_PATH}/McuManager/include")
set(HUNTTING_MAIN_INCLUDE_PATH "${HUNTTING_MAIN_INCLUDE_PATH};${UTILS_SOURCE_PATH}/StatusCode/include")
set(HUNTTING_MAIN_INCLUDE_PATH "${HUNTTING_MAIN_INCLUDE_PATH};${UTILS_SOURCE_PATH}/Log/include")
set(HUNTTING_MAIN_INCLUDE_PATH "${HUNTTING_MAIN_INCLUDE_PATH};${APPLICATION_SOURCE_PATH}/MissionManager/include")
set(HUNTTING_MAIN_INCLUDE_PATH "${HUNTTING_MAIN_INCLUDE_PATH};${HAL_SOURCE_PATH}/include")
set(HUNTTING_LINK_LIB MissionManager StatusCode Log Hal pthread dl)
set(HUNTTING_LINK_LIB McuManager MissionManager StateMachine StatusCode Log Hal pthread dl)

11
application/HunttingCamera/src/MainThread.cpp
View File

@ -15,7 +15,9 @@
#include "MainThread.h"
#include "IHalCpp.h"
#include "ILog.h"
#include "IMcuManager.h"
#include "IMissionManager.h"
#include "IStateMachine.h"
#include <thread>
MainThread::MainThread() { mMainThreadRuning = false; }
std::shared_ptr<MainThread> &MainThread::GetInstance(std::shared_ptr<MainThread> *impl)
@ -39,12 +41,15 @@ StatusCode MainThread::Init(void)
CustomizationInit();
mMainThreadRuning = true;
CreateAllModules();
// IHalInit();
IHalCpp::GetInstance()->Init();
IMcuManager::GetInstance()->Init();
IMissionManager::GetInstance()->Init();
return CreateStatusCode(STATUS_CODE_OK);
}
StatusCode MainThread::UnInit(void)
{
IMissionManager::GetInstance()->UnInit();
IMcuManager::GetInstance()->UnInit();
IHalCpp::GetInstance()->UnInit();
DestoryAllModules();
ILogUnInit();
@ -53,12 +58,16 @@ StatusCode MainThread::UnInit(void)
StatusCode MainThread::CreateAllModules(void)
{
CreateHalCppModule();
CreateMcuManager();
CreateMissionManagerModule();
CreateStateMachine();
return CreateStatusCode(STATUS_CODE_OK);
}
void MainThread::DestoryAllModules(void)
{
DestroyStateMachine();
DestroyMissionManagerModule();
DestroyMcuManager();
DestroyHalCppModule();
}
void MainThread::ResetAllPtrMaker(void) {}

6
application/MissionManager/CMakeLists.txt
View File

@ -9,7 +9,9 @@ include_directories(
${UTILS_SOURCE_PATH}/StatusCode/include
${UTILS_SOURCE_PATH}/Log/include
${MIDDLEWARE_SOURCE_PATH}/StateMachine/include
${MIDDLEWARE_SOURCE_PATH}/DeviceManager/include
# ${MIDDLEWARE_SOURCE_PATH}/DeviceManager/include
${MIDDLEWARE_SOURCE_PATH}/McuManager/include
${MIDDLEWARE_SOURCE_PATH}/McuAskBase/include
)
#do not rely on any other library
#link_directories(
@ -20,7 +22,7 @@ aux_source_directory(./src SRC_FILES)
set(TARGET_NAME MissionManager)
add_library(${TARGET_NAME} STATIC ${SRC_FILES})
target_link_libraries(${TARGET_NAME} StatusCode Log)
target_link_libraries(${TARGET_NAME} McuAskBase StateMachine StatusCode Log)
if ("${CLANG_TIDY_SUPPORT}" MATCHES "true")
add_custom_target(

4
application/MissionManager/src/IMissionManager.cpp
View File

@ -28,5 +28,5 @@ std::shared_ptr<IMissionManager> &IMissionManager::GetInstance(std::shared_ptr<I
}
return instance;
}
const StatusCode IMissionManager::Init(void) { return CreateStatusCode(STATUS_CODE_OK); }
const StatusCode IMissionManager::UnInit(void) { return CreateStatusCode(STATUS_CODE_OK); }
const StatusCode IMissionManager::Init(void) { return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION); }
const StatusCode IMissionManager::UnInit(void) { return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION); }

12
application/MissionManager/src/MissionManager.cpp
View File

@ -12,3 +12,15 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "MissionManager.h"
#include "MissionStateMachine.h"
const StatusCode MissionManager::Init(void)
{
MissionStateMachine::GetInstance()->Init();
return CreateStatusCode(STATUS_CODE_OK);
}
const StatusCode MissionManager::UnInit(void)
{
MissionStateMachine::GetInstance()->UnInit();
return CreateStatusCode(STATUS_CODE_OK);
}

2
application/MissionManager/src/MissionManager.h
View File

@ -20,5 +20,7 @@ class MissionManager : public IMissionManager
public:
MissionManager() = default;
virtual ~MissionManager() = default;
const StatusCode Init(void) override;
const StatusCode UnInit(void) override;
};
#endif

2
application/MissionManager/src/MissionManagerMakePtr.cpp
View File

@ -14,6 +14,7 @@
*/
#include "MissionManagerMakePtr.h"
#include "ILog.h"
#include "MissionManager.h"
#include "TopState.h"
bool CreateMissionManagerModule(void)
{
@ -48,6 +49,7 @@ std::shared_ptr<MissionManagerMakePtr> &MissionManagerMakePtr::GetInstance(std::
}
const StatusCode MissionManagerMakePtr::CreateMissionManagerInstance(std::shared_ptr<IMissionManager> &instance)
{
instance = std::make_shared<MissionManager>();
return CreateStatusCode(STATUS_CODE_OK);
}
std::shared_ptr<State> MissionManagerMakePtr::CreateTopState(void)

38
application/MissionManager/src/MissionStateMachine.cpp
View File

@ -14,6 +14,7 @@
*/
#include "MissionStateMachine.h"
#include "ILog.h"
#include "McuAskBase.h"
#include "MissionManagerMakePtr.h"
#include "TopState.h"
std::shared_ptr<MissionStateMachine> &MissionStateMachine::GetInstance(std::shared_ptr<MissionStateMachine> *impl)
@ -24,21 +25,50 @@ std::shared_ptr<MissionStateMachine> &MissionStateMachine::GetInstance(std::shar
}
return instance;
}
MissionStateMachine::MissionStateMachine()
{
//
mStartMission = IpcMission::END;
}
void MissionStateMachine::Init(void)
{
mStateMachine = std::make_shared<VStateMachineHandle>();
auto code = IStateMachine::GetInstance()->CreateStateMachine(mStateMachine);
if (IsCodeOK(code)) {
LogError("Create state machine failed.\n");
if (!IsCodeOK(code)) {
LogError("Create state machine failed[%s].\n", code.mPrintStringCode(code));
return;
}
if (!mStateMachine->InitialStateMachine()) {
LogError("State machine init failed.\n");
return;
}
// mStartMission = IDeviceManager::GetInstance()->GetIpcMission();
mStartMission = GetStartMission();
if (mStartMission != IpcMission::END) {
// RunStateMachine(mStartMission);
}
else {
LogError("ipcmission error.\n");
}
}
void MissionStateMachine::UnInit(void)
{
//
}
IpcMission MissionStateMachine::GetStartMission(void)
{
class McuAskIpcMission : public McuAsk<IpcMission>, public McuAskBase
{
public:
McuAskIpcMission() : McuAskBase(McuAskBlock::NOT_BLOCK, McuAskReply::NEED_REPLY)
{
mDataReply = IpcMission::END;
}
virtual ~McuAskIpcMission() = default;
};
std::shared_ptr<VMcuAsk> ask = std::make_shared<McuAskIpcMission>();
IMcuManager::GetInstance()->GetIpcMission(ask);
return std::dynamic_pointer_cast<McuAskIpcMission>(ask)->mDataReply;
}
void MissionStateMachine::UnInit(void) {}
// void MissionStateMachine::RunStateMachine(const IpcMission &mission)
// {
// LogInfo("Make all states and start the state machine.\n");

8
application/MissionManager/src/MissionStateMachine.h
View File

@ -14,7 +14,8 @@
*/
#ifndef MISSIONSTATEMACHINE_H
#define MISSIONSTATEMACHINE_H
#include "IDeviceManager.h"
// #include "IDeviceManager.h"
#include "IMcuManager.h"
#include "IMissionManager.h"
#include "IStateMachine.h"
#include <map>
@ -26,18 +27,19 @@ enum class MissionState
class MissionStateMachine
{
public:
MissionStateMachine() = default;
MissionStateMachine();
virtual ~MissionStateMachine() = default;
static std::shared_ptr<MissionStateMachine> &GetInstance(std::shared_ptr<MissionStateMachine> *impl = nullptr);
void Init(void);
void UnInit(void);
private:
IpcMission GetStartMission(void);
// void RunStateMachine(const IpcMission &mission);
private:
std::shared_ptr<VStateMachineHandle> mStateMachine;
std::map<MissionState, std::shared_ptr<State>> mStateTree;
// IpcMission mStartMission;
IpcMission mStartMission;
};
#endif

1
middleware/GuiEngine/CMakeLists.txt
View File

@ -5,7 +5,6 @@ set(LIBRARY_OUTPUT_PATH ${LIBS_OUTPUT_PATH})
include_directories(
./src
./include
${COMPONENT_SOURCE_PATH}/ReturnCode/include
${COMPONENT_SOURCE_PATH}/Log/include
)

2
middleware/StateMachine/CMakeLists.txt
View File

@ -21,7 +21,7 @@ aux_source_directory(./src/OpenHarmony SRC_FILES_OPENHARMONY)
set(TARGET_NAME StateMachine)
add_library(${TARGET_NAME} STATIC ${SRC_FILES} ${SRC_FILES_OPENHARMONY})
target_link_libraries(${TARGET_NAME} ReturnCode Log)
target_link_libraries(${TARGET_NAME} Log)
if ("${CLANG_TIDY_SUPPORT}" MATCHES "true")
add_custom_target(

1
middleware/StateMachine/include/IStateMachine.h
View File

@ -18,6 +18,7 @@
#include <iostream>
#include <memory>
bool CreateStateMachine(void);
bool DestroyStateMachine(void);
class VStateMessage
{
public:

7
middleware/StateMachine/src/StateMachineMakePtr.cpp
View File

@ -29,6 +29,12 @@ bool CreateStateMachine(void)
}
return false;
}
bool DestroyStateMachine(void)
{
auto instance = std::make_shared<IStateMachine>();
IStateMachine::GetInstance(&instance);
return true;
}
std::shared_ptr<StateMachineMakePtr> &StateMachineMakePtr::GetInstance(std::shared_ptr<StateMachineMakePtr> *impl)
{
static auto instance = std::make_shared<StateMachineMakePtr>();
@ -42,6 +48,7 @@ StatusCode StateMachineMakePtr::CreateStateMachine(std::shared_ptr<VStateMachine
// TODO: need a name ?
auto tmp = std::make_shared<StateMachine>("TODO");
if (tmp) {
LogInfo("Create state machine module successfully.\n");
stateMachine = std::move(tmp);
return CreateStatusCode(STATUS_CODE_OK);
}

2
test/application/HunttingCamera/CMakeLists.txt
View File

@ -26,7 +26,7 @@ endif()
set(TARGET_NAME HunttingCameraTest)
add_executable(${TARGET_NAME} ${SRC_FILES_MAIN} ${SRC_FILES})
target_link_libraries(${TARGET_NAME} HunttingMainLib TestManager gtest gmock pthread)
target_link_libraries(${TARGET_NAME} HunttingMainLib McuManagerTestTool TestManager gtest gmock pthread)
if(${TEST_COVERAGE} MATCHES "true")
target_link_libraries(${TARGET_NAME} gcov)
endif()

2
test/application/HunttingCamera/src/HunttingCamera_Test.cpp
View File

@ -52,7 +52,7 @@ public:
TEST_F(HunttingCameraTest, INTEGRATION_DeviceManager_EXAMPLE_Demo)
{
MainThread::GetInstance()->Init();
ResetTimeOut(1000 * 3);
TestManager::ResetTimeOut(1000 * 3);
MainThread::GetInstance()->Runing();
MainThread::GetInstance()->UnInit();
}

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

@ -231,8 +231,14 @@ bool McuProtocolTestTool::IpcMissionProtocolHandle(std::shared_ptr<LinuxTest> &m
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.";
unsigned char *bufHandle = (unsigned char *)malloc(count);
if (nullptr == bufHandle) {
LogError("malloc failed.\n");
return PROTOCOL_HANDLED;
}
memcpy(bufHandle, buf, count);
auto handle = [=, &mock](McuProtocolTestTool *testTool) {
testTool->IpcMissionProtocolInit(mock, uartFd, buf, count);
testTool->IpcMissionProtocolInit(mock, uartFd, bufHandle, count);
};
if (mLockThread.joinable()) {
mLockThread.join();
@ -249,6 +255,7 @@ void McuProtocolTestTool::IpcMissionProtocolInit(std::shared_ptr<LinuxTest> &moc
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;
@ -315,8 +322,14 @@ bool McuProtocolTestTool::FeedingCycleProtocolHandle(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.";
unsigned char *bufHandle = (unsigned char *)malloc(count);
if (nullptr == bufHandle) {
LogError("malloc failed.\n");
return PROTOCOL_HANDLED;
}
memcpy(bufHandle, buf, count);
auto handle = [=, &mock](McuProtocolTestTool *testTool) {
testTool->FeedingCycleProtocolInit(mock, uartFd, buf, count);
testTool->FeedingCycleProtocolInit(mock, uartFd, bufHandle, count);
};
if (mLockThread.joinable()) {
mLockThread.join();
@ -334,6 +347,7 @@ void McuProtocolTestTool::FeedingCycleProtocolInit(std::shared_ptr<LinuxTest> &m
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;
@ -366,8 +380,14 @@ bool McuProtocolTestTool::SetDataTimeProtocolHandle(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.";
unsigned char *bufHandle = (unsigned char *)malloc(count);
if (nullptr == bufHandle) {
LogError("malloc failed.\n");
return PROTOCOL_HANDLED;
}
memcpy(bufHandle, buf, count);
auto handle = [=, &mock](McuProtocolTestTool *testTool) {
testTool->SetDataTimeProtocolInit(mock, uartFd, buf, count);
testTool->SetDataTimeProtocolInit(mock, uartFd, bufHandle, count);
};
if (mLockThread.joinable()) {
mLockThread.join();
@ -384,6 +404,7 @@ void McuProtocolTestTool::SetDataTimeProtocolInit(std::shared_ptr<LinuxTest> &mo
memcpy(REPLY_SET_DATE_TIME_X + PROTOCOL_SERIAL_NUMBER_OFFSET,
(unsigned char *)buf + PROTOCOL_SERIAL_NUMBER_OFFSET,
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;
@ -416,8 +437,14 @@ bool McuProtocolTestTool::SetPirSensitivityProtocolHandle(std::shared_ptr<LinuxT
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.";
unsigned char *bufHandle = (unsigned char *)malloc(count);
if (nullptr == bufHandle) {
LogError("malloc failed.\n");
return PROTOCOL_HANDLED;
}
memcpy(bufHandle, buf, count);
auto handle = [=, &mock](McuProtocolTestTool *testTool) {
testTool->SetDataTimeProtocolInit(mock, uartFd, buf, count);
testTool->SetDataTimeProtocolInit(mock, uartFd, bufHandle, count);
};
if (mLockThread.joinable()) {
mLockThread.join();
@ -468,8 +495,14 @@ bool McuProtocolTestTool::ContorlInfraredLightHandle(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.";
unsigned char *bufHandle = (unsigned char *)malloc(count);
if (nullptr == bufHandle) {
LogError("malloc failed.\n");
return PROTOCOL_HANDLED;
}
memcpy(bufHandle, buf, count);
auto handle = [=, &mock](McuProtocolTestTool *testTool) {
testTool->ContorlInfraredLightInit(mock, uartFd, buf, count);
testTool->ContorlInfraredLightInit(mock, uartFd, bufHandle, count);
};
if (mLockThread.joinable()) {
mLockThread.join();
@ -486,6 +519,7 @@ void McuProtocolTestTool::ContorlInfraredLightInit(std::shared_ptr<LinuxTest> &m
memcpy(REPLY_ASK_CONTORL_INFRARED_LIGHT_X + PROTOCOL_SERIAL_NUMBER_OFFSET,
(unsigned char *)buf + PROTOCOL_SERIAL_NUMBER_OFFSET,
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;
@ -518,8 +552,14 @@ bool McuProtocolTestTool::GetPhotosensitivityValueHandle(std::shared_ptr<LinuxTe
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.";
unsigned char *bufHandle = (unsigned char *)malloc(count);
if (nullptr == bufHandle) {
LogError("malloc failed.\n");
return PROTOCOL_HANDLED;
}
memcpy(bufHandle, buf, count);
auto handle = [=, &mock](McuProtocolTestTool *testTool) {
testTool->GetPhotosensitivityValueInit(mock, uartFd, buf, count);
testTool->GetPhotosensitivityValueInit(mock, uartFd, bufHandle, count);
};
if (mLockThread.joinable()) {
mLockThread.join();
@ -536,6 +576,7 @@ void McuProtocolTestTool::GetPhotosensitivityValueInit(std::shared_ptr<LinuxTest
memcpy(REPLY_ASK_GET_PHOTOSENSITIVITY_X + PROTOCOL_SERIAL_NUMBER_OFFSET,
(unsigned char *)buf + PROTOCOL_SERIAL_NUMBER_OFFSET,
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;