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

Add build and hal and utils.

Browse Source
This commit is contained in:
Fancy code 2024-06-15 08:36:44 +08:00
parent 9ee7c8c754
commit cadab3c801
160 changed files with 19803 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
build/README.md Normal file
View File

@ -0,0 +1,3 @@
# cmake编译配置
## 目录
./toolchain：配置编译工具链

8
build/cmake/Makefile Normal file
View File

@ -0,0 +1,8 @@
all:
@mkdir -p ../../cmake-shell;\
cd ../../cmake-shell;\
pwd;\
cmake -DCMAKE_TOOLCHAIN_FILE="./build/cmake/toolchain/linux.toolchain.cmake" ..;\
cd ..
clean:
rm -rf ../../cmake-shell

2
build/cmake/README.md Normal file
View File

@ -0,0 +1,2 @@
# cmake

89
build/cmake/toolchain/linux.toolchain.cmake Executable file
View File

@ -0,0 +1,89 @@
INCLUDE(CMakeForceCompiler)
set(LINUX_TEST "true")
set(CROSS_COMPILE_PREFIX "")
set(CMAKE_C_COMPILER "${CROSS_COMPILE_PREFIX}gcc")
set(CMAKE_CXX_COMPILER "${CROSS_COMPILE_PREFIX}g++")
# path to compiler and utilities
set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
# Name of the target platform
set(CMAKE_SYSTEM_NAME Linux)
set(CMAKE_SYSTEM_PROCESSOR arm)
# Version of the system
set(CMAKE_SYSTEM_VERSION 1)
cmake_policy(SET CMP0011 NEW)
cmake_policy(SET CMP0005 NEW)
add_definitions(-Wall -O2 -Os)
add_definitions(-Wno-unused-local-typedefs)
add_definitions(-Wstrict-aliasing -Wwrite-strings)
set(TOOLCHAIN_NAME arm-linux-gnueabihf)
set(TARGET_PLATFORM "linux")
set(SUBMODULE_PATH_OF_IPC_SDK "")
set(PLATFORM_PATH "${CMAKE_CURRENT_SOURCE_DIR}")
set(TEST_COVERAGE "true")
add_definitions(-DPLATFORM_PATH=\"${PLATFORM_PATH}\")
set(PROJECT_OUTPUT_FOLDER "output_files")
set(CMAKE_INSTALL_PREFIX "${CMAKE_CURRENT_SOURCE_DIR}/${PROJECT_OUTPUT_FOLDER}")
# ------------ build curl + openssl ------------ #
set(CURL_OPENSSL_LIB_SHARED_ENABLE "false")
# ------------ build curl + openssl end ------------ #
# ------------ build IpcConfig ------------ #
set(IPC_CONFIG_FILE_PATH "./ipc_config")
set(USERDATA_MOUNT_PATH "/userdata")
# ------------ build IpcConfig end ------------ #
# ------------ build log ------------ #
set(LOG_SUPPORT "true")
# ------------ build log end ------------ #
# ------------ build GoAhead ------------ #
set(GOAHEAD_DOCUMENTS_PATH "web")
set(GOAHEAD_UPLOAD_TMP_PATH "./goahead")
set(GOAHEAD_UPLOAD_PATH "${GOAHEAD_UPLOAD_TMP_PATH}")
set(GOAHEAD_LIMIT_POST "335544320") # If not defined means using default setting. See goahead-linux-static-fancy.mk
# GOAHEAD_CONFIG_FILE_PATH should be set when cross compile
set(GOAHEAD_CONFIG_FILE_PATH ".")
# ------------ build GoAhead end ------------ #
# ------------ build McuManager ------------ #
set(MCU_UART_DEVICE "dev/s1")
# ------------ build McuManager end ------------ #
# ------------ build curl + openssl ------------ start
set(CROSS_COMPILE_PREFIX "")
# set(CROSS_COMPILE_PREFIX "")
set(CURL_OPENSSL_LIB_SHARED_ENABLE "false")
set(CURL_SHARED_LIBS_PATH "/mnt/mmc")
# ------------ build curl + openssl ------------ end
# ------------ build AppManager ------------ #
set(APP_MANAGER_DEVICE_IP "localhost")
# set(APP_MANAGER_DEVICE_IP "192.168.1.29")
set(APP_MANAGER_HTTP_SERVER_PORT "8080")
set(APP_MANAGER_TCP_SERVER_PORT "9876")
# ------------ build AppManager end ------------ #
# ------------ build sd card ------------ #
set(SD_CARD_DEV "/dev/test")
set(SD_CARD_MOUNT_PATH "./sdcard")
# ------------ build sd card end ------------ #
# ------------ build upgrade ------------ #
set(APPLICATION_CHECK_PATH "/application.bin")
set(APPLICATION_UPGRADE_PATH "./fastboot_server")
set(APPLICATION_VERSION_1 1)
set(APPLICATION_VERSION_2 0)
set(APPLICATION_VERSION_3 0)
set(APPLICATION_VERSION_4 0)
# ------------ build upgrade end ------------ #

88
build/global_config.cmake Executable file
View File

@ -0,0 +1,88 @@
set(DEFINE_LINUX "linux")
# set(CMAKE_SOURCE_DIR_IPCSDK "${CMAKE_SOURCE_DIR}")
# set(CMAKE_SOURCE_DIR_IPCSDK "${CMAKE_SOURCE_DIR_IPCSDK}${SUBMODULE_PATH_OF_IPC_SDK}")
set(EXEC_OUTPUT_PATH "${PLATFORM_PATH}/${PROJECT_OUTPUT_FOLDER}/bin")
set(LIBS_OUTPUT_PATH "${PLATFORM_PATH}/${PROJECT_OUTPUT_FOLDER}/libs")
set(TEST_TOOLS_OUTPUT_PATH "${PLATFORM_PATH}/${PROJECT_OUTPUT_FOLDER}/libs/test_tools")
set(EXTERNAL_LIBS_OUTPUT_PATH "${PLATFORM_PATH}/${PROJECT_OUTPUT_FOLDER}/libs/external")
set(TEST_OUTPUT_PATH "${PLATFORM_PATH}/${PROJECT_OUTPUT_FOLDER}/test")
set(PROJECT_ROOT_PATH "${PLATFORM_PATH}")
set(APPLICATION_SOURCE_PATH "${CMAKE_SOURCE_DIR_IPCSDK}/application")
set(MIDDLEWARE_SOURCE_PATH "${CMAKE_SOURCE_DIR_IPCSDK}/middleware")
set(UTILS_SOURCE_PATH "${CMAKE_SOURCE_DIR_IPCSDK}/utils")
set(HAL_SOURCE_PATH "${CMAKE_SOURCE_DIR_IPCSDK}/hal")
set(TEST_SOURCE_PATH "${CMAKE_SOURCE_DIR_IPCSDK}/test")
set(EXTERNAL_SOURCE_PATH "${CMAKE_SOURCE_DIR_IPCSDK}/external")
# -------------------------- clang-tidy tools -------------------------- #
set(CLANG_TIDY_CHECKS "-*,\
llvm-else-after-return,\
-llvm-include-order,\
llvm-namespace-comment,\
llvm-prefer-isa-or-dyn-cast-in-conditionals,\
llvm-prefer-register-over-unsigned,\
llvm-qualified-auto,\
llvm-twine-local,\
misc-confusable-identifiers,\
misc-definitions-in-headers,\
misc-header-include-cycle,\
-misc-include-cleaner,\
misc-misleading-bidirectional,\
misc-misleading-identifier,\
misc-misplaced-const,\
misc-new-delete-overloads,\
misc-non-copyable-objects,\
misc-redundant-expression,\
misc-static-assert,\
misc-throw-by-value-catch-by-reference,\
misc-unconventional-assign-operator,\
misc-uniqueptr-reset-release,\
misc-unused-alias-decls,\
misc-unused-using-decls,\
readability-identifier-naming")
# set(CLANG_TIDY_CHECKS "${CLANG_TIDY_CHECKS},llvm-header-guard")
set(CLANG_TIDY_CHECKS "${CLANG_TIDY_CHECKS},-clang-diagnostic-error")
set(CLANG_TIDY_CONFIG "-header-filter=\'.*\'")
set(CLANG_TIDY_CONFIG "${CLANG_TIDY_CONFIG} -p ${CMAKE_SOURCE_DIR_IPCSDK}/cmake-shell")
# set(CLANG_FORMAT_FILE "${CMAKE_SOURCE_DIR_IPCSDK}/tools/clang-format/.clang-format")
set(CLANG_FORMAT_FILE "LLVM ${CMAKE_SOURCE_DIR_IPCSDK}/tools/clang-format/.clang-format")
# -------------------------- clang-tidy tools end -------------------------- #
# ------------ build clang-tools ------------ #
if(${LINUX_TEST} MATCHES "true")
set(CLANG_TIDY_SUPPORT "true")
set(CLANG_FORMAT_SUPPORT "true")
set(COMPILE_IMPROVE_SUPPORT "false") # 开启后每次编译可能会很慢
set(LLVM_PATH "$ENV{HOME}/llvm-project")
endif()
# ------------ build clang-tools end ------------ #
# -------------------------- log setting -------------------------- #
function(define_file_name target)
get_target_property(source_files "${target}" SOURCES)
foreach(source_file ${source_files})
get_property(defs SOURCE "${source_file}"
PROPERTY COMPILE_DEFINITIONS)
get_filename_component(file_name "${source_file}" NAME)
list(APPEND defs "__F_FILE__=\"${file_name}\"")
set_property(
SOURCE "${source_file}"
PROPERTY COMPILE_DEFINITIONS ${defs})
endforeach()
endfunction()
function(log_disable target)
get_target_property(source_files "${target}" SOURCES)
foreach(source_file ${source_files})
get_property(defs SOURCE "${source_file}"
PROPERTY COMPILE_DEFINITIONS)
get_filename_component(file_name "${source_file}" NAME)
list(APPEND defs "LOG_DISABLE")
set_property(
SOURCE "${source_file}"
PROPERTY COMPILE_DEFINITIONS ${defs})
endforeach()
endfunction()
# -------------------------- log setting end -------------------------- #

14
build/independent_source.cmake Normal file
View File

@ -0,0 +1,14 @@
# This config file is only for independent source files.
# Never leave over any warning in independt project.
# set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Werror -Wextra")
# set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Werror -Wextra")
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Werror")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Werror")
# For build coverage report in linux-x86
if(${TARGET_PLATFORM} MATCHES ${DEFINE_LINUX})
# SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fprofile-arcs -ftest-coverage")
# SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fprofile-arcs -ftest-coverage")
endif()

27
build/sdk_config.cmake Executable file
View File

@ -0,0 +1,27 @@
include(${CMAKE_SOURCE_DIR_IPCSDK}/build/global_config.cmake)
set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
# Gdb debug
if(${TARGET_PLATFORM} MATCHES ${DEFINE_LINUX})
message("---------------------------Debug mode.-----------------------")
SET(CMAKE_BUILD_TYPE "Debug")
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")
# asan
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fsanitize=leak -fsanitize=address -fno-omit-frame-pointer -fsanitize=undefined")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=leak -fsanitize=address -fno-omit-frame-pointer -fsanitize=undefined")
else()
message("---------------------------Release mode.-----------------------")
SET(CMAKE_BUILD_TYPE "Release")
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Os")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Os")
endif()
if(${TEST_COVERAGE} MATCHES "true")
message("you choose to build gcno file")
add_definitions("-fprofile-arcs")
add_definitions("-ftest-coverage")
endif()

66
hal/CMakeLists.txt Normal file
View File

@ -0,0 +1,66 @@
include(${CMAKE_SOURCE_DIR_IPCSDK}/build/global_config.cmake)
include(${CMAKE_CURRENT_SOURCE_DIR}/build/hal.cmake)
set(EXECUTABLE_OUTPUT_PATH ${EXEC_OUTPUT_PATH})
set(LIBRARY_OUTPUT_PATH ${LIBS_OUTPUT_PATH})
include_directories(
./abstract
./src
./include
${UTILS_SOURCE_PATH}/StatusCode/include
${UTILS_SOURCE_PATH}/Log/include
${UTILS_SOURCE_PATH}/LinuxApi/include
${UTILS_SOURCE_PATH}/KeyControl/include
)
#do not rely on any other library
# link_directories(
# ${EXTERNAL_SOURCE_PATH}/curl/curl-8.1.2/build/lib
# )
aux_source_directory(./abstract ABSTRACT_SRC_FILES)
aux_source_directory(./src IMPL_SRC_FILES)
set(ABSTRACT_TARGET HalAbstract)
set(IMPL_TARGET Hal)
add_library(${ABSTRACT_TARGET} STATIC ${ABSTRACT_SRC_FILES})
target_link_libraries(${ABSTRACT_TARGET} LinuxApi KeyControl StatusCode Log)
add_library(${IMPL_TARGET} STATIC ${IMPL_SRC_FILES})
target_link_libraries(${IMPL_TARGET} ${ABSTRACT_TARGET})
if ("${COMPILE_IMPROVE_SUPPORT}" MATCHES "true")
add_custom_target(
Hal_code_check
COMMAND ${CLANG_TIDY_EXE}
-checks='${CLANG_TIDY_CHECKS}'
--header-filter=.*
--system-headers=false
${ABSTRACT_SRC_FILES}
${IMPL_SRC_FILES}
${CLANG_TIDY_CONFIG}
-p ${PLATFORM_PATH}/cmake-shell
WORKING_DIRECTORY ${CMAKE_SOURCE_DIR_IPCSDK}/hal
)
file(GLOB_RECURSE HEADER_FILES *.h)
add_custom_target(
Hal_code_format
COMMAND ${CLANG_FORMAT_EXE}
-style=file
-i ${ABSTRACT_SRC_FILES} ${IMPL_SRC_FILES} ${HEADER_FILES}
WORKING_DIRECTORY ${HAL_SOURCE_PATH}
)
add_custom_command(
TARGET ${IMPL_TARGET}
PRE_BUILD
COMMAND make Hal_code_check
COMMAND make Hal_code_format
WORKING_DIRECTORY ${PLATFORM_PATH}/cmake-shell/
)
endif()
define_file_name(${IMPL_TARGET})
define_file_name(${ABSTRACT_TARGET})
file(GLOB_RECURSE INSTALL_HEADER_FILES include/*.h)
install(FILES ${INSTALL_HEADER_FILES} DESTINATION include)

53
hal/abstract/IHal.cpp Normal file
View File

@ -0,0 +1,53 @@
/*
* Copyright (c) 2023 Fancy Code.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "IHal.h"
#include "IHalCpp.h"
#include "StatusCode.h"
// #include <stddef.h>
#include <string.h>
static StatusCode IHalInit(IHal *object)
{
return IHalCpp::GetInstance()->Init();
}
static void IHalFree(void *object)
{
}
static StatusCode IHalUnInit(IHal *object)
{
return IHalCpp::GetInstance()->UnInit();
}
static IHal default_hal = {
.init = IHalInit,
.un_init = IHalUnInit,
.free = IHalFree,
};
static IHal *hal_instance = &default_hal;
IHal *GetHalIntance(void)
{
return hal_instance;
}
StatusCode NewIHal(IHal **object)
{
if (!object || !(*object)) {
return CreateStatusCode(STATUS_CODE_NOT_OK);
}
memcpy(*object, &default_hal, sizeof(IHal));
return CreateStatusCode(STATUS_CODE_OK);
}
void ResetHalImpl(IHal *impl)
{
hal_instance->free(hal_instance);
hal_instance = impl;
}

146
hal/abstract/IHalCpp.cpp Normal file
View File

@ -0,0 +1,146 @@
/*
* Copyright (c) 2023 Fancy Code.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "IHalCpp.h"
#include "ILog.h"
#include <memory>
camera_report_event::camera_report_event(const std::string &fileName, const CameraType &cameraType)
: mFileName(fileName), mCameraType(cameraType)
{
}
void VKeyHalMonitor::KeyEventHappened(const std::string &keyName, const VirtualKeyEvent &event,
const unsigned int &timeMs)
{
LogWarning("STATUS_CODE_VIRTUAL_FUNCTION.\n");
}
void VKeyHal::CheckKeyStatus(void)
{
LogWarning("STATUS_CODE_VIRTUAL_FUNCTION.\n");
}
void VKeyHal::GetHoldPressingTimeMs(long int &holdTimeMs, VirtualKeyEvent &event)
{
LogWarning("STATUS_CODE_VIRTUAL_FUNCTION.\n");
}
void VKeyHal::SetKeyMonitor(std::shared_ptr<VKeyHalMonitor> &monitor)
{
LogWarning("STATUS_CODE_VIRTUAL_FUNCTION.\n");
}
// std::string VKeyHal::GetKeyHalName(void)
// {
// return "undefined";
// }
StatusCode VWifiHal::PowerOn(void)
{
LogWarning("STATUS_CODE_VIRTUAL_FUNCTION.\n");
return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
}
StatusCode VWifiHal::PowerOff(void)
{
LogWarning("STATUS_CODE_VIRTUAL_FUNCTION.\n");
return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
}
StatusCode VWifiHal::OpenApMode(void)
{
LogWarning("STATUS_CODE_VIRTUAL_FUNCTION.\n");
return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
}
StatusCode VWifiHal::CloseApMode(void)
{
LogWarning("STATUS_CODE_VIRTUAL_FUNCTION.\n");
return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
}
void VCameraHalMonitor::ReportEvent(const CameraReportEvent &event)
{
LogWarning("STATUS_CODE_VIRTUAL_FUNCTION.\n");
}
camera_task_param::camera_task_param(const CameraTaskType &cameraTask) : mCameraTask(cameraTask)
{
}
void VCameraHal::SetCameraMonitor(std::shared_ptr<VCameraHalMonitor> &monitor)
{
LogWarning("STATUS_CODE_VIRTUAL_FUNCTION.\n");
}
StatusCode VCameraHal::StartSingleTask(const CameraTaskParam &param)
{
LogWarning("STATUS_CODE_VIRTUAL_FUNCTION.\n");
return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
}
void VSdCardHalMonitor::ReportEvent(const SdCardHalStatus &status)
{
LogWarning("STATUS_CODE_VIRTUAL_FUNCTION.\n");
}
std::shared_ptr<IHalCpp> &IHalCpp::GetInstance(std::shared_ptr<IHalCpp> *impl)
{
static auto instance = std::make_shared<IHalCpp>();
if (impl) {
if (instance.use_count() == 1) {
LogInfo("Instance changed succeed.\n");
instance = *impl;
}
else {
LogError("Can't changing the instance becase of using by some one.\n");
}
}
return instance;
}
void VSdCardHal::SetSdCardMonitor(std::shared_ptr<VSdCardHalMonitor> &monitor)
{
LogWarning("STATUS_CODE_VIRTUAL_FUNCTION.\n");
}
SdCardHalStatus VSdCardHal::GetSdCardStatus(void)
{
LogWarning("STATUS_CODE_VIRTUAL_FUNCTION.\n");
return SdCardHalStatus::END;
}
StatusCode VSdCardHal::GetCapacity(unsigned long long &totalSizeMB, unsigned long long &freeSizeMB,
unsigned long long &usedSizeMB)
{
LogWarning("STATUS_CODE_VIRTUAL_FUNCTION.\n");
return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
}
StatusCode IHalCpp::Init(void)
{
LogWarning("STATUS_CODE_VIRTUAL_FUNCTION.\n");
return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
}
StatusCode IHalCpp::UnInit(void)
{
LogWarning("STATUS_CODE_VIRTUAL_FUNCTION.\n");
return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
}
StatusCode IHalCpp::GetAllLeds(std::map<std::string, std::shared_ptr<VLedHal>> &allLeds)
{
LogWarning("STATUS_CODE_VIRTUAL_FUNCTION.\n");
return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
}
StatusCode IHalCpp::GetAllKeys(std::map<std::string, std::shared_ptr<VKeyHal>> &allKeys)
{
LogWarning("STATUS_CODE_VIRTUAL_FUNCTION.\n");
return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
}
StatusCode IHalCpp::GetWifiHal(std::shared_ptr<VWifiHal> &wifi)
{
LogWarning("STATUS_CODE_VIRTUAL_FUNCTION.\n");
return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
}
StatusCode IHalCpp::GetCameraHal(std::map<CameraType, std::shared_ptr<VCameraHal>> &allCameras)
{
LogWarning("STATUS_CODE_VIRTUAL_FUNCTION.\n");
return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
}
StatusCode IHalCpp::GetSdCardHal(std::shared_ptr<VSdCardHal> &sdCard)
{
LogWarning("STATUS_CODE_VIRTUAL_FUNCTION.\n");
return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
}

2
hal/build/hal.cmake Normal file
View File

@ -0,0 +1,2 @@
add_definitions(-DSD_CARD_DEV=\"${SD_CARD_DEV}\")
add_definitions(-DSD_CARD_MOUNT_PATH=\"${SD_CARD_MOUNT_PATH}\")

64
hal/include/IHal.h Normal file
View File

@ -0,0 +1,64 @@
/*
* Copyright (c) 2023 Fancy Code.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef IHAL_H
#define IHAL_H
#include "StatusCode.h"
#ifdef __cplusplus
extern "C" {
#endif
// enum KEY_EVENT
// {
// KEY_EVENT_NOT_PRESSING = 0,
// KEY_EVENT_PRESSING,
// KEY_EVENT_END
// };
// typedef struct v_key_owner VKeyOwner;
// typedef struct v_key_owner
// {
// // StatusCode (*init)(VKeyOwner *);
// // StatusCode (*un_init)(VKeyOwner *);
// void (*key_event_trigger)(VKeyOwner *, const enum KEY_EVENT);
// } VKeyOwner;
// typedef struct v_key_handle VKeyHandle;
// typedef struct v_key_handle
// {
// // StatusCode (*init)(VKeyHandle *);
// // StatusCode (*un_init)(VKeyHandle *);
// StatusCode (*set_owner)(VKeyHandle *, VKeyOwner *);
// } VKeyHandle;
typedef struct i_hal IHal;
typedef struct i_hal
{
StatusCode (*init)(IHal *);
StatusCode (*un_init)(IHal *);
void (*free)(void *);
} IHal;
IHal *GetHalIntance(void);
StatusCode NewIHal(IHal **object);
void ResetHalImpl(IHal *impl);
static inline StatusCode IHalInit(void)
{
return GetHalIntance()->init(GetHalIntance());
}
static inline StatusCode IHalUnInit(void)
{
return GetHalIntance()->un_init(GetHalIntance());
}
StatusCode CreateHalModule(void);
StatusCode DestroyHalModule(void);
#ifdef __cplusplus
}
#endif
#endif

161
hal/include/IHalCpp.h Normal file
View File

@ -0,0 +1,161 @@
/*
* Copyright (c) 2023 Fancy Code.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef I_HAL_CPP_H
#define I_HAL_CPP_H
#include "StatusCode.h"
#include <iostream>
#include <map>
#include <memory>
#include <vector>
using VirtualLedState = unsigned char;
using VirtualKeyEvent = unsigned char;
constexpr int INVALID_PERIOD = -1;
constexpr int PERIPHERAL_CHECK_PERIOD_MS = 50;
constexpr int IMEI_LEN = 15;
enum class CameraType
{
MAIN_CAMERA = 0,
END
};
enum class SdCardHalStatus
{
MOUNTED = 0,
UNMOUNTED,
INSERTED,
PULL_OUT_DEVICE_NOT_EXIST,
PULL_OUT_OPEN_FAILED,
PULL_OUT_NOT_BLOCK_DEVICE,
ERROR,
END
};
enum class CameraTaskType
{
PICTURE = 0,
VIDEO,
PICTURE_AND_VIDEO,
END
};
typedef struct camera_report_event
{
camera_report_event(const std::string &fileName, const CameraType &cameraType);
const std::string mFileName;
const CameraType mCameraType;
} CameraReportEvent;
void CreateHalCppModule(void);
void DestroyHalCppModule(void);
class VKeyHalMonitor
{
public:
VKeyHalMonitor() = default;
virtual ~VKeyHalMonitor() = default;
virtual void KeyEventHappened(const std::string &keyName, const VirtualKeyEvent &event, const unsigned int &timeMs);
};
class VKeyHal
{
public:
VKeyHal() = default;
virtual ~VKeyHal() = default;
virtual void CheckKeyStatus(void);
virtual void GetHoldPressingTimeMs(long int &holdTimeMs, VirtualKeyEvent &event);
virtual void SetKeyMonitor(std::shared_ptr<VKeyHalMonitor> &monitor);
// virtual std::string GetKeyHalName(void);
};
class VLedHal
{
public:
VLedHal() = default;
virtual ~VLedHal() = default;
};
class VWifiHal
{
public:
VWifiHal() = default;
virtual ~VWifiHal() = default;
virtual StatusCode PowerOn(void);
virtual StatusCode PowerOff(void);
virtual StatusCode OpenApMode(void);
virtual StatusCode CloseApMode(void);
};
class VCameraHalMonitor
{
public:
VCameraHalMonitor() = default;
virtual ~VCameraHalMonitor() = default;
virtual void ReportEvent(const CameraReportEvent &event);
};
class VCameraTaskContext
{
public:
VCameraTaskContext() = default;
virtual ~VCameraTaskContext() = default;
};
template <typename T>
class CameraTaskContext : public VCameraTaskContext
{
public:
CameraTaskContext(T &value) : mData(value)
{
}
virtual ~CameraTaskContext() = default;
public:
T mData;
};
typedef struct camera_task_param
{
camera_task_param(const CameraTaskType &cameraTask);
const CameraTaskType mCameraTask;
std::shared_ptr<VCameraTaskContext> mCtx;
} CameraTaskParam;
class VCameraHal
{
public:
VCameraHal() = default;
virtual ~VCameraHal() = default;
virtual void SetCameraMonitor(std::shared_ptr<VCameraHalMonitor> &monitor);
virtual StatusCode StartSingleTask(const CameraTaskParam &param);
};
class VSdCardHalMonitor
{
public:
VSdCardHalMonitor() = default;
virtual ~VSdCardHalMonitor() = default;
virtual void ReportEvent(const SdCardHalStatus &status);
};
class VSdCardHal
{
public:
VSdCardHal() = default;
virtual ~VSdCardHal() = default;
virtual void SetSdCardMonitor(std::shared_ptr<VSdCardHalMonitor> &monitor);
virtual SdCardHalStatus GetSdCardStatus(void);
virtual StatusCode GetCapacity(unsigned long long &totalSizeMB, unsigned long long &freeSizeMB,
unsigned long long &usedSizeMB);
};
class IHalCpp
{
public:
IHalCpp() = default;
virtual ~IHalCpp() = default;
static std::shared_ptr<IHalCpp> &GetInstance(std::shared_ptr<IHalCpp> *impl = nullptr);
virtual StatusCode Init(void);
virtual StatusCode UnInit(void);
virtual StatusCode GetAllLeds(std::map<std::string, std::shared_ptr<VLedHal>> &allLeds);
virtual StatusCode GetAllKeys(std::map<std::string, std::shared_ptr<VKeyHal>> &allKeys);
virtual StatusCode GetWifiHal(std::shared_ptr<VWifiHal> &wifi);
virtual StatusCode GetCameraHal(std::map<CameraType, std::shared_ptr<VCameraHal>> &allCameras);
virtual StatusCode GetSdCardHal(std::shared_ptr<VSdCardHal> &sdCard);
};
#endif

56
hal/src/Hal.c Normal file
View File

@ -0,0 +1,56 @@
/*
* Copyright (c) 2023 Fancy Code.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "Hal.h"
#include "ILog.h"
#include <stddef.h>
#include <stdlib.h>
StatusCode HalInit(IHal *hal)
{
LogInfo("Hal init.\n");
return CreateStatusCode(STATUS_CODE_OK);
}
static void HalFree(void *object)
{
LogInfo("hal instance free.\n");
if (object) {
free(object);
}
}
void HalImplInit(Hal *hal)
{
LogInfo("HalImplInit\n");
NewIHal((IHal **)&hal);
((IHal *)hal)->init = HalInit;
((IHal *)hal)->free = HalFree;
}
StatusCode NewHal(Hal **hal)
{
if (!hal) {
LogError("STATUS_CODE_INVALID_PARAMENTER\n");
return CreateStatusCode(STATUS_CODE_INVALID_PARAMENTER);
}
if (!(*hal)) {
*hal = (Hal *)malloc(sizeof(Hal));
if (*hal) {
LogInfo("NewHal succeed.\n");
HalImplInit(*hal);
return CreateStatusCode(STATUS_CODE_OK);
}
LogError("NewHal failed.\n");
return CreateStatusCode(STATUS_CODE_NOT_OK);
}
HalImplInit(*hal);
return CreateStatusCode(STATUS_CODE_OK);
}

33
hal/src/Hal.h Normal file
View File

@ -0,0 +1,33 @@
/*
* Copyright (c) 2023 Fancy Code.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef HAL_H
#define HAL_H
#include "IHal.h"
#include "StatusCode.h"
#ifdef __cplusplus
extern "C" {
#endif
typedef struct hal Hal;
typedef struct hal
{
IHal base;
} Hal;
StatusCode NewHal(Hal **hal);
void HalImplInit(Hal *hal);
StatusCode HalInit(IHal *hal);
#ifdef __cplusplus
}
#endif
#endif

87
hal/src/HalCpp.cpp Normal file
View File

@ -0,0 +1,87 @@
/*
* Copyright (c) 2023 Fancy Code.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "HalCpp.h"
#include "HalMakePtr.h"
#include "ILog.h"
#include "SdCardHal.h"
#include "WifiHal.h"
StatusCode HalCpp::Init(void)
{
LogInfo("HalCpp::Init\n");
HalMakePtr::GetInstance()->CreateWifiHal(mWifiHal);
std::shared_ptr<WifiHal> wifiImpl = std::dynamic_pointer_cast<WifiHal>(mWifiHal);
if (nullptr != wifiImpl) {
wifiImpl->Init();
}
HalMakePtr::GetInstance()->CreateSdCardHal(mSdCardHal);
std::shared_ptr<SdCardHal> sdCardImpl = std::dynamic_pointer_cast<SdCardHal>(mSdCardHal);
if (nullptr != sdCardImpl) {
sdCardImpl->Init();
}
HalMakePtr::GetInstance()->CreateAllKeyHal(mKeys);
// auto checkPinValue = [](std::shared_ptr<HalCpp> impl) {
// LogInfo("HalCpp::CheckAllPinVauleThread start\n");
// impl->CheckAllPinVauleThread();
// };
// mCheckPinThread = std::thread(checkPinValue, shared_from_this());
return CreateStatusCode(STATUS_CODE_OK);
}
StatusCode HalCpp::UnInit(void)
{
LogInfo("HalCpp::UnInit\n");
std::shared_ptr<SdCardHal> sdCardImpl = std::dynamic_pointer_cast<SdCardHal>(mSdCardHal);
if (nullptr != sdCardImpl) {
sdCardImpl->UnInit();
}
mThreadRuning = false;
if (mCheckPinThread.joinable()) {
mCheckPinThread.join();
}
mWifiHal.reset();
mSdCardHal.reset();
return CreateStatusCode(STATUS_CODE_OK);
}
StatusCode HalCpp::GetWifiHal(std::shared_ptr<VWifiHal> &wifi)
{
wifi = mWifiHal;
return CreateStatusCode(STATUS_CODE_OK);
}
StatusCode HalCpp::GetSdCardHal(std::shared_ptr<VSdCardHal> &sdCard)
{
sdCard = mSdCardHal;
return CreateStatusCode(STATUS_CODE_OK);
}
StatusCode HalCpp::GetAllKeys(std::map<std::string, std::shared_ptr<VKeyHal>> &allKeys)
{
LogInfo("GetAllKeys\n");
for (auto &key : mKeys) {
std::shared_ptr<VKeyHal> keyControl = std::dynamic_pointer_cast<VKeyHal>(key);
if (nullptr == keyControl) {
LogError("keyControl is nullptr\n");
continue;
}
allKeys.insert(std::make_pair(key->GetKeyName(), keyControl));
}
return CreateStatusCode(STATUS_CODE_OK);
}
void HalCpp::CheckAllPinVauleThread(void)
{
// mThreadRuning = true;
// while (mThreadRuning) {
// for (auto &keyHalImpl : mKeys) {
// }
// std::this_thread::sleep_for(std::chrono::milliseconds(PERIPHERAL_CHECK_PERIOD_MS));
// }
}

43
hal/src/HalCpp.h Normal file
View File

@ -0,0 +1,43 @@
/*
* Copyright (c) 2023 Fancy Code.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef HALCPP_H
#define HALCPP_H
#include "IHalCpp.h"
#include "KeyControl.h"
#include <memory>
#include <thread>
class HalCpp : public IHalCpp, public std::enable_shared_from_this<HalCpp>
{
public:
HalCpp() = default;
virtual ~HalCpp() = default;
StatusCode Init(void) override;
StatusCode UnInit(void) override;
StatusCode GetWifiHal(std::shared_ptr<VWifiHal> &wifi) override;
StatusCode GetSdCardHal(std::shared_ptr<VSdCardHal> &sdCard) override;
StatusCode GetAllKeys(std::map<std::string, std::shared_ptr<VKeyHal>> &allKeys) override;
private:
void CheckAllPinVauleThread(void);
private:
std::vector<std::shared_ptr<VLedHal>> mLedHals;
std::shared_ptr<VWifiHal> mWifiHal;
std::shared_ptr<VSdCardHal> mSdCardHal;
std::vector<std::shared_ptr<VKeyControl>> mKeys;
bool mThreadRuning = false;
std::thread mCheckPinThread;
};
#endif

100
hal/src/HalMakePtr.cpp Normal file
View File

@ -0,0 +1,100 @@
/*
* Copyright (c) 2023 Fancy Code.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "HalMakePtr.h"
#include "Hal.h"
#include "HalCpp.h"
#include "ILog.h"
#include "SdCardHal.h"
#include "WifiHal.h"
StatusCode CreateHalModule(void)
{
IHal *hal = NULL;
StatusCode code = HalMakePtr::GetInstance()->CreateHalPtr(&hal);
if (IsCodeOK(code) && NULL != hal) {
LogInfo("Create Hal instance ok.\n");
ResetHalImpl((IHal *)hal);
}
else {
LogError("Create Hal failed.\n");
return CreateStatusCode(STATUS_CODE_NOT_OK);
}
auto instance = std::make_shared<IHalCpp>();
StatusCode code2 = HalMakePtr::GetInstance()->CreateHalSharePtr(instance);
if (IsCodeOK(code2)) {
LogInfo("Hal instance is ok.\n");
IHalCpp::GetInstance(&instance);
}
return code2;
}
StatusCode DestroyHalModule(void)
{
ResetHalImpl(nullptr);
return CreateStatusCode(STATUS_CODE_OK);
}
void CreateHalCppModule(void)
{
auto instance = std::make_shared<IHalCpp>();
StatusCode code2 = HalMakePtr::GetInstance()->CreateHalSharePtr(instance);
if (IsCodeOK(code2)) {
LogInfo("Hal instance is ok.\n");
IHalCpp::GetInstance(&instance);
}
}
void DestroyHalCppModule(void)
{
auto instance = std::make_shared<IHalCpp>();
IHalCpp::GetInstance(&instance);
}
std::shared_ptr<HalMakePtr> &HalMakePtr::GetInstance(std::shared_ptr<HalMakePtr> *impl)
{
static auto instance = std::make_shared<HalMakePtr>();
if (impl) {
instance = *impl;
}
return instance;
}
StatusCode HalMakePtr::CreateHalPtr(IHal **hal)
{
LogWarning("Hal is default hal.\n");
return NewHal((Hal **)hal);
}
StatusCode HalMakePtr::CreateHalSharePtr(std::shared_ptr<IHalCpp> &impl)
{
LogWarning("IHalCpp is default.\n");
impl = std::make_shared<HalCpp>();
return CreateStatusCode(STATUS_CODE_OK);
}
StatusCode HalMakePtr::CreateWifiHal(std::shared_ptr<VWifiHal> &impl)
{
LogInfo("CreateWifiHal.\n");
impl = std::make_shared<WifiHal>();
return CreateStatusCode(STATUS_CODE_OK);
}
StatusCode HalMakePtr::CreateCameraHal(std::shared_ptr<VCameraHal> &impl)
{
LogWarning("CreateCameraHal.\n");
return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
}
StatusCode HalMakePtr::CreateSdCardHal(std::shared_ptr<VSdCardHal> &impl)
{
LogInfo("CreateSdCardHal.\n");
impl = std::make_shared<SdCardHal>();
return CreateStatusCode(STATUS_CODE_OK);
}
StatusCode HalMakePtr::CreateAllKeyHal(std::vector<std::shared_ptr<VKeyControl>> &keys)
{
LogInfo("STATUS_CODE_VIRTUAL_FUNCTION.\n");
return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
}

43
hal/src/HalMakePtr.h Normal file
View File

@ -0,0 +1,43 @@
/*
* Copyright (c) 2023 Fancy Code.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef HALMAKEPTR_H
#define HALMAKEPTR_H
#include "IHal.h"
#include "IHalCpp.h"
#include "StatusCode.h"
#include "KeyControl.h"
#include <memory>
class HalMakePtr
{
public:
HalMakePtr() = default;
virtual ~HalMakePtr() = default;
static std::shared_ptr<HalMakePtr> &GetInstance(std::shared_ptr<HalMakePtr> *impl = nullptr);
virtual StatusCode Init()
{
return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
}
virtual StatusCode UnInit()
{
return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
}
virtual StatusCode CreateHalPtr(IHal **hal);
virtual StatusCode CreateHalSharePtr(std::shared_ptr<IHalCpp> &impl);
virtual StatusCode CreateWifiHal(std::shared_ptr<VWifiHal> &impl);
virtual StatusCode CreateCameraHal(std::shared_ptr<VCameraHal> &impl);
virtual StatusCode CreateSdCardHal(std::shared_ptr<VSdCardHal> &impl);
virtual StatusCode CreateAllKeyHal(std::vector<std::shared_ptr<VKeyControl>> &keys);
};
#endif

191
hal/src/SdCardHal.cpp Normal file
View File

@ -0,0 +1,191 @@
/*
* Copyright (c) 2023 Fancy Code.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "SdCardHal.h"
#include "ILog.h"
#include "LinuxApi.h"
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/statvfs.h>
#include <sys/types.h>
#include <sys/vfs.h>
#include <unistd.h>
const char *SD_CARD_DEVICE = SD_CARD_DEV;
const char *SD_MOUNT_PATH = SD_CARD_MOUNT_PATH;
SdCardHal::SdCardHal() : mStatus(SdCardHalStatus::END), mThreadRuning(false), mDeviceFd(-1)
{
}
void SdCardHal::SetSdCardMonitor(std::shared_ptr<VSdCardHalMonitor> &monitor)
{
LogInfo("SetSdCardMonitor.\n");
mMonitor = monitor;
monitor->ReportEvent(mStatus);
}
SdCardHalStatus SdCardHal::GetSdCardStatus(void)
{
return mStatus;
}
StatusCode SdCardHal::GetCapacity(unsigned long long &totalSizeMB, unsigned long long &freeSizeMB,
unsigned long long &usedSizeMB)
{
using SD_SIZE = unsigned long long;
constexpr SD_SIZE ONE_MB = 1024ULL * 1024;
if (SdCardHalStatus::MOUNTED != mStatus) {
LogWarning("SdCardHalStatus::MOUNTED != mStatus\n");
return CreateStatusCode(STATUS_CODE_NOT_OK);
}
struct statfs sd_fs;
if (statfs(SD_MOUNT_PATH, &sd_fs) != 0) {
LogError("statfs failed!\n");
return CreateStatusCode(STATUS_CODE_NOT_OK);
}
totalSizeMB = ((SD_SIZE)sd_fs.f_blocks * (SD_SIZE)sd_fs.f_bsize) / ONE_MB;
freeSizeMB = ((SD_SIZE)sd_fs.f_bavail * (SD_SIZE)sd_fs.f_bsize) / ONE_MB;
usedSizeMB = (((SD_SIZE)sd_fs.f_blocks - (SD_SIZE)sd_fs.f_bfree) * (SD_SIZE)sd_fs.f_bsize) / ONE_MB;
LogInfo("Total size: %llu MB\n", totalSizeMB);
LogInfo("Free size: %llu MB\n", freeSizeMB);
LogInfo("Used size: %llu MB\n", usedSizeMB);
return CreateStatusCode(STATUS_CODE_OK);
}
void SdCardHal::Init(void)
{
auto detectThread = [](std::shared_ptr<SdCardHal> sdCardHal) {
LogInfo("sdCardHal DevDetectingThread started.\n");
sdCardHal->DevDetectingThread();
};
mDevDetectingThread = std::thread(detectThread, shared_from_this());
}
void SdCardHal::UnInit(void)
{
mThreadRuning = false;
if (mDevDetectingThread.joinable()) {
mDevDetectingThread.join();
}
}
void SdCardHal::DevDetectingThread(void)
{
constexpr int SLEEP_TIME_MS = 100;
constexpr int DEVICE_EXIST = 0;
// SdCardHalStatus status = SdCardHalStatus::END;
// const char *SD_CARD_DEVICE = "/SD_CARD_DEVICE/mmcblk1p1";
mThreadRuning = true;
while (mThreadRuning) {
if (fx_access(SD_CARD_DEVICE, F_OK) != DEVICE_EXIST) {
if (SdCardHalStatus::PULL_OUT_DEVICE_NOT_EXIST != mStatus) {
mStatus = SdCardHalStatus::PULL_OUT_DEVICE_NOT_EXIST;
ReportDetecedChangedResult(mStatus);
}
if (mDeviceFd > 0) {
close(mDeviceFd);
mDeviceFd = -1;
}
goto CONTINUE;
}
if (mDeviceFd < 0) {
mDeviceFd = fx_open(SD_CARD_DEVICE, O_RDONLY);
if (mDeviceFd < 0) {
// LogInfo("sdCardHal: %s open failed.\n", SD_CARD_DEVICE);
if (SdCardHalStatus::PULL_OUT_OPEN_FAILED != mStatus) {
mStatus = SdCardHalStatus::PULL_OUT_OPEN_FAILED;
ReportDetecedChangedResult(mStatus);
}
goto CONTINUE;
}
}
struct stat sdStat;
if (fx_fstat(mDeviceFd, &sdStat) < 0) {
// LogInfo("sdCardHal: %s fstat failed.\n", SD_CARD_DEVICE);
if (SdCardHalStatus::ERROR != mStatus) {
mStatus = SdCardHalStatus::ERROR;
ReportDetecedChangedResult(mStatus);
}
close(mDeviceFd);
mDeviceFd = -1;
goto CONTINUE;
}
if (!S_ISBLK(sdStat.st_mode)) {
// LogInfo("sdCardHal: %s is not block device.\n", SD_CARD_DEVICE);
if (SdCardHalStatus::PULL_OUT_NOT_BLOCK_DEVICE != mStatus) {
mStatus = SdCardHalStatus::PULL_OUT_NOT_BLOCK_DEVICE;
ReportDetecedChangedResult(mStatus);
}
close(mDeviceFd);
mDeviceFd = -1;
}
else {
// LogInfo("sdCardHal: %s is inserted.\n", SD_CARD_DEVICE);
if (SdCardHalStatus::INSERTED != mStatus && SdCardHalStatus::MOUNTED != mStatus &&
SdCardHalStatus::UNMOUNTED != mStatus) {
mStatus = SdCardHalStatus::INSERTED;
ReportDetecedChangedResult(mStatus);
}
}
CONTINUE:
std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_TIME_MS));
}
if (mDeviceFd > 0) {
close(mDeviceFd);
mDeviceFd = -1;
}
}
void SdCardHal::ReportDetecedChangedResult(const SdCardHalStatus &status)
{
LogInfo("SdCardHalStatus changed: %s.\n", PrintfStatusString(status));
SdCardHalStatus mountedStatus = SdCardHalStatus::END;
if (SdCardHalStatus::INSERTED == status) {
LogInfo("mount sd to %s.\n", SD_CARD_MOUNT_PATH);
constexpr int BUF_LENGTH = 128;
char cmd[BUF_LENGTH] = {0};
snprintf(cmd, BUF_LENGTH, "mount %s %s", SD_CARD_DEV, SD_CARD_MOUNT_PATH);
fx_system(cmd);
mountedStatus = SdCardHalStatus::MOUNTED;
mStatus = SdCardHalStatus::MOUNTED;
}
auto monitor = mMonitor.lock();
if (mMonitor.expired()) {
LogWarning("SdCardHal: monitor is expired.\n");
return;
}
if (SdCardHalStatus::END != mountedStatus) {
monitor->ReportEvent(mountedStatus);
return;
}
monitor->ReportEvent(status);
}
const char *SdCardHal::PrintfStatusString(const SdCardHalStatus &status)
{
switch (status) {
case SdCardHalStatus::MOUNTED:
return "MOUNTE\n";
case SdCardHalStatus::UNMOUNTED:
return "UNMOUNTED.";
case SdCardHalStatus::INSERTED:
return "INSERTED.";
case SdCardHalStatus::PULL_OUT_DEVICE_NOT_EXIST:
return "PULL_OUT_DEVICE_NOT_EXIST.";
case SdCardHalStatus::PULL_OUT_OPEN_FAILED:
return "PULL_OUT_OPEN_FAILED.";
case SdCardHalStatus::PULL_OUT_NOT_BLOCK_DEVICE:
return "PULL_OUT_NOT_BLOCK_DEVICE.";
case SdCardHalStatus::END:
return "END.";
default:
return "UNDEFINE.";
}
}

42
hal/src/SdCardHal.h Normal file
View File

@ -0,0 +1,42 @@
/*
* Copyright (c) 2023 Fancy Code.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef SD_CARD_HAL_H
#define SD_CARD_HAL_H
#include "IHalCpp.h"
#include <thread>
class SdCardHal : public VSdCardHal, public std::enable_shared_from_this<SdCardHal>
{
public:
SdCardHal();
virtual ~SdCardHal() = default;
void SetSdCardMonitor(std::shared_ptr<VSdCardHalMonitor> &monitor) override;
SdCardHalStatus GetSdCardStatus(void) override;
StatusCode GetCapacity(unsigned long long &totalSizeMB, unsigned long long &freeSizeMB, unsigned long long &usedSizeMB) override;
void Init(void);
void UnInit(void);
void DevDetectingThread(void);
private:
void ReportDetecedChangedResult(const SdCardHalStatus &status);
const char *PrintfStatusString(const SdCardHalStatus &status);
private:
SdCardHalStatus mStatus;
bool mThreadRuning;
std::thread mDevDetectingThread;
std::weak_ptr<VSdCardHalMonitor> mMonitor;
int mDeviceFd;
};
#endif

90
hal/src/WifiHal.cpp Normal file
View File

@ -0,0 +1,90 @@
/*
* Copyright (c) 2023 Fancy Code.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "WifiHal.h"
#include "ILog.h"
#include "LinuxApi.h"
#include <dirent.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <thread>
WifiHal::WifiHal() : mInitRunning(false)
{
}
StatusCode WifiHal::OpenApMode(void)
{
LogInfo("OpenApMode. \n");
constexpr int SLEEP_TIME_MS = 5;
constexpr int WAITING_TIME_MS = 1000 * 10;
unsigned int sleepingTime_ms = 0;
mInitRunning = true;
while (CheckWlan0IfExist() == false) {
std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_TIME_MS));
sleepingTime_ms += SLEEP_TIME_MS;
if (sleepingTime_ms > WAITING_TIME_MS) {
LogError("wlan0 not found. \n");
return CreateStatusCode(STATUS_CODE_NOT_OK);
}
if (false == mInitRunning) {
LogError("Open ap mode stop. \n");
return CreateStatusCode(STATUS_CODE_NOT_OK);
}
}
LogInfo("wlan0 ok. \n");
fx_system("ifconfig wlan0 192.168.169.1 netmask 255.255.255.0");
fx_system("hostapd -d /etc/hostapd.conf &");
fx_system("touch /var/lib/misc/udhcpd.leases");
fx_system("udhcpd -f /etc/udhcpd.conf &");
return CreateStatusCode(STATUS_CODE_OK);
}
StatusCode WifiHal::CloseApMode(void)
{
mInitRunning = false;
return CreateStatusCode(STATUS_CODE_OK);
}
void WifiHal::Init(void)
{
PowerOff();
}
void WifiHal::UnInit(void)
{
}
bool WifiHal::CheckWlan0IfExist(void)
{
DIR *dir;
struct dirent *entry;
int wlan0_found = 0;
dir = opendir("/sys/class/net");
if (dir == NULL) {
perror("opendir");
return false;
}
while ((entry = readdir(dir)) != NULL) {
if (strcmp(entry->d_name, "wlan0") == 0) {
wlan0_found = 1;
break;
}
}
closedir(dir);
if (wlan0_found) {
return true;
}
else {
return false;
}
}

34
hal/src/WifiHal.h Normal file
View File

@ -0,0 +1,34 @@
/*
* Copyright (c) 2023 Fancy Code.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef WIFI_HAL_H
#define WIFI_HAL_H
#include "IHalCpp.h"
class WifiHal : public VWifiHal
{
public:
WifiHal();
virtual ~WifiHal() = default;
StatusCode OpenApMode(void) override;
StatusCode CloseApMode(void) override;
virtual void Init(void);
virtual void UnInit(void);
protected:
bool CheckWlan0IfExist(void);
protected:
bool mInitRunning;
};
#endif

20
utils/CMakeLists.txt Normal file
View File

@ -0,0 +1,20 @@
# cmake_minimum_required(VERSION 2.8.0)
add_subdirectory(ConfigBase)
add_subdirectory(StatusCode)
add_subdirectory(Log)
add_subdirectory(SharedData)
add_subdirectory(UartDevice)
add_subdirectory(LinuxApi)
# add_subdirectory(MultiProcess)
add_subdirectory(WebServer)
add_subdirectory(McuProtocol)
add_subdirectory(ModBusCRC16)
add_subdirectory(LedControl)
add_subdirectory(KeyControl)
add_subdirectory(MediaAdapter)
add_subdirectory(FxHttpServer)
add_subdirectory(Servers)
add_subdirectory(TcpModule)
add_subdirectory(UpgradeBase)
add_subdirectory(UpgradeTool)

98
utils/Config/CMakeLists.txt Normal file
View File

@ -0,0 +1,98 @@
include(${CMAKE_SOURCE_DIR_IPCSDK}/build/global_config.cmake)
set(EXECUTABLE_OUTPUT_PATH ${EXEC_OUTPUT_PATH})
set(LIBRARY_OUTPUT_PATH ${LIBS_OUTPUT_PATH})
include_directories(
./src
./include
${UTILS_SOURCE_PATH}/StatusCode/include
${UTILS_SOURCE_PATH}/Log/include
${EXTERNAL_SOURCE_PATH}/libconfig/libconfig-1.7.3/lib
)
# link_directories(
# ${EXTERNAL_SOURCE_PATH}/libconfig/libconfig-1.7.3/lib/.libs
# )
aux_source_directory(./src SRC_FILES)
set(TARGET_NAME ConfigBase)
add_library(${TARGET_NAME} STATIC ${SRC_FILES})
target_link_libraries(${TARGET_NAME} StatusCode Log libconfig.a)
if ("${COMPILE_IMPROVE_SUPPORT}" MATCHES "true")
add_custom_target(
Config_code_check
COMMAND ${CLANG_TIDY_EXE}
-checks='${CLANG_TIDY_CHECKS}'
--header-filter=.*
--system-headers=false
${SRC_FILES}
${CLANG_TIDY_CONFIG}
-p ${PLATFORM_PATH}/cmake-shell
WORKING_DIRECTORY ${UTILS_SOURCE_PATH}/Config
)
add_custom_command(
TARGET ${TARGET_NAME}
PRE_BUILD
COMMAND make Config_code_check
WORKING_DIRECTORY ${PLATFORM_PATH}/cmake-shell/
)
file(GLOB_RECURSE HEADER_FILES *.h)
add_custom_target(
Config_code_format
COMMAND ${CLANG_FORMAT_EXE}
-style=file
-i ${SRC_FILES} ${HEADER_FILES}
WORKING_DIRECTORY ${UTILS_SOURCE_PATH}/Config
)
add_custom_command(
TARGET ${TARGET_NAME}
PRE_BUILD
COMMAND make Config_code_check
COMMAND make Config_code_format
WORKING_DIRECTORY ${PLATFORM_PATH}/cmake-shell/
)
endif()
# build libconfig before make libConfig.a
add_custom_command(
# OUTPUT ${EXTERNAL_SOURCE_PATH}/libconfig/libconfig-1.7.3/lib/.libs/libconfig.a
OUTPUT ${EXTERNAL_LIBS_OUTPUT_PATH}/libconfig.a
COMMAND echo "Build libconfig-1.7.3. COMPILE_HOST = ${COMPILE_HOST}"
# COMMAND tar zxvf libconfig-1.7.3.tar.gz
COMMAND sh build_libconfig.sh ${TARGET_PLATFORM} ${COMPILE_HOST}
COMMAND mv ${EXTERNAL_SOURCE_PATH}/libconfig/libconfig-1.7.3/lib/.libs/libconfig.a ${EXTERNAL_LIBS_OUTPUT_PATH}/libconfig.a
WORKING_DIRECTORY ${EXTERNAL_SOURCE_PATH}/libconfig/
)
add_custom_target(
libconfig.a
# DEPENDS ${EXTERNAL_SOURCE_PATH}/libconfig/libconfig-1.7.3/lib/.libs/libconfig.a
DEPENDS ${EXTERNAL_LIBS_OUTPUT_PATH}/libconfig.a
)
# add_custom_command(
# TARGET ${TARGET_NAME}
# PRE_BUILD
# COMMAND make compile_libconfig
# WORKING_DIRECTORY ${PROJECT_ROOT_PATH}/cmake-shell
# )
function(config_owner target)
get_target_property(source_files "${target}" SOURCES)
foreach(source_file ${source_files})
get_property(defs SOURCE "${source_file}"
PROPERTY COMPILE_DEFINITIONS)
get_filename_component(file_name "${source_file}" NAME)
list(APPEND defs "CONFIG_OWNER")
set_property(
SOURCE "${source_file}"
PROPERTY COMPILE_DEFINITIONS ${defs})
endforeach()
endfunction()
define_file_name(${TARGET_NAME})
config_owner(${TARGET_NAME})
file(GLOB_RECURSE INSTALL_HEADER_FILES include/*.h)
install(FILES ${INSTALL_HEADER_FILES} DESTINATION include)

0
utils/Config/README.md Normal file
View File

13
utils/Config/config.cmake Normal file
View File

@ -0,0 +1,13 @@
function(config_owner target)
get_target_property(source_files "${target}" SOURCES)
foreach(source_file ${source_files})
get_property(defs SOURCE "${source_file}"
PROPERTY COMPILE_DEFINITIONS)
get_filename_component(file_name "${source_file}" NAME)
list(APPEND defs "CONFIG_OWNER")
set_property(
SOURCE "${source_file}"
PROPERTY COMPILE_DEFINITIONS ${defs})
endforeach()
endfunction()

75
utils/Config/include/Config.h Normal file
View File

@ -0,0 +1,75 @@
/*
* Copyright (c) 2023 Fancy Code.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef CONFIG_H
#define CONFIG_H
#include "StatusCode.h"
#ifdef __cplusplus
extern "C" {
#endif
enum CONFIG_CODE
{
CONFIG_CODE_PARAM_NOT_EXIST = STATUS_CODE_END,
CONFIG_CODE_END
};
typedef struct v_config VConfig;
typedef struct v_config
{
const StatusCode (*get_int)(VConfig *, const char *, int *);
const StatusCode (*set_int)(VConfig *, const char *, const int);
const StatusCode (*get_short)(VConfig *, const char *, short *);
const StatusCode (*set_short)(VConfig *, const char *, const short);
const StatusCode (*get_long)(VConfig *, const char *, long *);
const StatusCode (*set_long)(VConfig *, const char *, const long);
const StatusCode (*get_llong)(VConfig *, const char *, long long *);
const StatusCode (*set_llong)(VConfig *, const char *, const long long);
const StatusCode (*get_char)(VConfig *, const char *, char *);
const StatusCode (*set_char)(VConfig *, const char *, const char);
const StatusCode (*get_bool)(VConfig *, const char *, bool *);
const StatusCode (*set_bool)(VConfig *, const char *, const bool);
const StatusCode (*get_float)(VConfig *, const char *, float *);
const StatusCode (*set_float)(VConfig *, const char *, const float);
const StatusCode (*get_double)(VConfig *, const char *, double *);
const StatusCode (*set_double)(VConfig *, const char *, const double);
const StatusCode (*get_string)(VConfig *, const char *, const char **);
const StatusCode (*set_string)(VConfig *, const char *, const char *);
const StatusCode (*save)(VConfig *);
} VConfig;
const StatusCode ConfigInit(void);
const StatusCode ConfigUnInit(void);
VConfig *OpenConfigFile(const char *fileName);
const StatusCode ConfigSaveFile(VConfig *cfg);
void CloseConfigFile(VConfig *cfg);
const StatusCode ConfigGetInt(VConfig *cfg, const char *name, int *value);
const StatusCode ConfigSetInt(VConfig *cfg, const char *name, const int value);
const StatusCode ConfigGetShort(VConfig *cfg, const char *name, short *value);
const StatusCode ConfigSetShort(VConfig *cfg, const char *name, const short value);
const StatusCode ConfigGetLong(VConfig *cfg, const char *name, long *value);
const StatusCode ConfigSetLong(VConfig *cfg, const char *name, const long value);
const StatusCode ConfigGetLLong(VConfig *cfg, const char *name, long long *value);
const StatusCode ConfigSetLLong(VConfig *cfg, const char *name, const long long value);
const StatusCode ConfigGetChar(VConfig *cfg, const char *name, char *value);
const StatusCode ConfigSetChar(VConfig *cfg, const char *name, const char value);
const StatusCode ConfigGetBool(VConfig *cfg, const char *name, bool *value);
const StatusCode ConfigSetBool(VConfig *cfg, const char *name, const bool value);
const StatusCode ConfigGetFloat(VConfig *cfg, const char *name, float *value);
const StatusCode ConfigSetFloat(VConfig *cfg, const char *name, const float value);
const StatusCode ConfigGetDouble(VConfig *cfg, const char *name, double *value);
const StatusCode ConfigSetDouble(VConfig *cfg, const char *name, const double value);
const StatusCode ConfigGetString(VConfig *cfg, const char *name, const char **value);
const StatusCode ConfigSetString(VConfig *cfg, const char *name, const char *value);
#ifdef __cplusplus
}
#endif
#endif

171
utils/Config/src/Config.c Normal file
View File

@ -0,0 +1,171 @@
/*
* Copyright (c) 2023 Fancy Code.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "Config.h"
#include "ConfigImpl.h"
#include "ILog.h"
#include <stddef.h>
const StatusCode ConfigInit(void)
{
return CreateStatusCode(STATUS_CODE_OK);
}
const StatusCode ConfigUnInit(void)
{
return CreateStatusCode(STATUS_CODE_OK);
}
VConfig *OpenConfigFile(const char *fileName)
{
return (VConfig *)NewConfig(fileName);
}
const StatusCode ConfigSaveFile(VConfig *cfg)
{
if (NULL == cfg) {
return CreateStatusCode(STATUS_CODE_NOT_OK);
}
return cfg->save(cfg);
}
void CloseConfigFile(VConfig *cfg)
{
if (NULL == cfg) {
LogError("NULL config poniter.\n");
return;
}
((Config *)cfg)->close(cfg);
}
const StatusCode ConfigGetInt(VConfig *cfg, const char *name, int *value)
{
if (NULL == cfg) {
return CreateStatusCode(STATUS_CODE_NOT_OK);
}
return cfg->get_int(cfg, name, value);
}
const StatusCode ConfigSetInt(VConfig *cfg, const char *name, const int value)
{
if (NULL == cfg) {
return CreateStatusCode(STATUS_CODE_NOT_OK);
}
return cfg->set_int(cfg, name, value);
}
const StatusCode ConfigGetShort(VConfig *cfg, const char *name, short *value)
{
if (NULL == cfg) {
return CreateStatusCode(STATUS_CODE_NOT_OK);
}
return cfg->get_short(cfg, name, value);
}
const StatusCode ConfigSetShort(VConfig *cfg, const char *name, const short value)
{
if (NULL == cfg) {
return CreateStatusCode(STATUS_CODE_NOT_OK);
}
return cfg->set_short(cfg, name, value);
}
const StatusCode ConfigGetLong(VConfig *cfg, const char *name, long *value)
{
if (NULL == cfg) {
return CreateStatusCode(STATUS_CODE_NOT_OK);
}
return cfg->get_long(cfg, name, value);
}
const StatusCode ConfigSetLong(VConfig *cfg, const char *name, const long value)
{
if (NULL == cfg) {
return CreateStatusCode(STATUS_CODE_NOT_OK);
}
return cfg->set_long(cfg, name, value);
}
const StatusCode ConfigGetLLong(VConfig *cfg, const char *name, long long *value)
{
if (NULL == cfg) {
return CreateStatusCode(STATUS_CODE_NOT_OK);
}
return cfg->get_llong(cfg, name, value);
}
const StatusCode ConfigSetLLong(VConfig *cfg, const char *name, const long long value)
{
if (NULL == cfg) {
return CreateStatusCode(STATUS_CODE_NOT_OK);
}
return cfg->set_llong(cfg, name, value);
}
const StatusCode ConfigGetChar(VConfig *cfg, const char *name, char *value)
{
if (NULL == cfg) {
return CreateStatusCode(STATUS_CODE_NOT_OK);
}
return cfg->get_char(cfg, name, value);
}
const StatusCode ConfigSetChar(VConfig *cfg, const char *name, const char value)
{
if (NULL == cfg) {
return CreateStatusCode(STATUS_CODE_NOT_OK);
}
return cfg->set_char(cfg, name, value);
}
const StatusCode ConfigGetBool(VConfig *cfg, const char *name, bool *value)
{
if (NULL == cfg) {
return CreateStatusCode(STATUS_CODE_NOT_OK);
}
return cfg->get_bool(cfg, name, value);
}
const StatusCode ConfigSetBool(VConfig *cfg, const char *name, const bool value)
{
if (NULL == cfg) {
return CreateStatusCode(STATUS_CODE_NOT_OK);
}
return cfg->set_bool(cfg, name, value);
}
const StatusCode ConfigGetFloat(VConfig *cfg, const char *name, float *value)
{
if (NULL == cfg) {
return CreateStatusCode(STATUS_CODE_NOT_OK);
}
return cfg->get_float(cfg, name, value);
}
const StatusCode ConfigSetFloat(VConfig *cfg, const char *name, const float value)
{
if (NULL == cfg) {
return CreateStatusCode(STATUS_CODE_NOT_OK);
}
return cfg->set_float(cfg, name, value);
}
const StatusCode ConfigGetDouble(VConfig *cfg, const char *name, double *value)
{
if (NULL == cfg) {
return CreateStatusCode(STATUS_CODE_NOT_OK);
}
return cfg->get_double(cfg, name, value);
}
const StatusCode ConfigSetDouble(VConfig *cfg, const char *name, const double value)
{
if (NULL == cfg) {
return CreateStatusCode(STATUS_CODE_NOT_OK);
}
return cfg->set_double(cfg, name, value);
}
const StatusCode ConfigGetString(VConfig *cfg, const char *name, const char **value)
{
if (NULL == cfg) {
return CreateStatusCode(STATUS_CODE_NOT_OK);
}
return cfg->get_string(cfg, name, value);
}
const StatusCode ConfigSetString(VConfig *cfg, const char *name, const char *value)
{
if (NULL == cfg) {
return CreateStatusCode(STATUS_CODE_NOT_OK);
}
return cfg->set_string(cfg, name, value);
}

53
utils/Config/src/ConfigCode.c Normal file
View File

@ -0,0 +1,53 @@
/*
* Copyright (c) 2023 Fancy Code.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "ConfigCode.h"
#include "ILog.h"
#include <string.h>
static const char *ConfigCodeString[CONFIG_CODE_END - STATUS_CODE_END + 1] = {"CONFIG_CODE_PARAM_NOT_EXIST",
"CONFIG_CODE_END"};
static const char *PrintStringConfigCode(const StatusCode this)
{
const int CODE_INDEX = this.mStatusCode - STATUS_CODE_END;
if (STATUS_CODE_END <= this.mStatusCode && this.mStatusCode <= CONFIG_CODE_END) {
LogInfo("Config code = [ %s ]\n", ConfigCodeString[CODE_INDEX]);
return ConfigCodeString[CODE_INDEX];
}
LogError("Config code undefine.\n");
return "Config code undefine.\n";
}
static const bool CodeEqual(const StatusCode code, const char *value)
{
if (memcmp(value, ConfigCodeString[code.mStatusCode - STATUS_CODE_END], strlen(value)) == 0) {
return true;
}
return false;
}
static StatusCode NewConfigCode(const long int code)
{
StatusCode result = {PrintStringConfigCode, CodeEqual, code};
return result;
}
const StatusCode CreateConfigCode(const long int code)
{
// if (STATUS_CODE_OK <= code && code < STATUS_CODE_END)
// {
// return CreateStatusCode(code);
// }
if (STATUS_CODE_END <= code && code < CONFIG_CODE_END) {
return NewConfigCode(code);
}
LogError("undefined code.\n");
return CreateStatusCode(STATUS_CODE_END);
}

28
utils/Config/src/ConfigCode.h Normal file
View File

@ -0,0 +1,28 @@
/*
* Copyright (c) 2023 Fancy Code.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef CONFIGCODE_H
#define CONFIGCODE_H
#include "Config.h"
#ifdef __cplusplus
extern "C" {
#endif
#ifndef CONFIG_OWNER
#error This is internal file, never include it.
#endif
const StatusCode CreateConfigCode(const long int code);
#ifdef __cplusplus
}
#endif
#endif

309
utils/Config/src/ConfigImpl.c Normal file
View File

@ -0,0 +1,309 @@
/*
* Copyright (c) 2023 Fancy Code.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "ConfigImpl.h"
#include "ConfigCode.h"
#include "ILog.h"
#include <limits.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#define CHECK_SHORT_LIMIT(value) (value > SHRT_MAX ? false : (value < SHRT_MIN ? false : true))
#define CHECK_LONG_LIMIT(value) (value > LONG_MAX ? false : (value < LONG_MIN ? false : true))
#define CHECK_CHAR_LIMIT(value) (value > CHAR_MAX ? false : (value < CHAR_MIN ? false : true))
#define CHECK_FLOAT_LIMIT(value) (fabs(value - ((float)value)) < 0.000001 ? false : true)
static const StatusCode ConfigSaveFileImpl(VConfig *cfg)
{
/* Write out the new configuration. */
LogInfo("Save file[%s].\n", ((Config *)cfg)->mFileName);
if (!config_write_file(&(((Config *)cfg)->cfg), ((Config *)cfg)->mFileName)) {
LogError("Save config failed.\n");
fprintf(stderr, "Error while writing file.\n");
return CreateStatusCode(STATUS_CODE_NOT_OK);
}
return CreateStatusCode(STATUS_CODE_OK);
}
static void ConfigClose(VConfig *cfg)
{
if (NULL != cfg) {
config_destroy(&(((Config *)cfg)->cfg));
if (NULL != ((Config *)cfg)->mFileName) {
free(((Config *)cfg)->mFileName);
((Config *)cfg)->mFileName = NULL;
}
free(cfg);
}
}
static const StatusCode ConfigGetIntImpl(VConfig *cfg, const char *name, int *value)
{
int result = 0;
// config_setting_t *root;
result = config_lookup_int(&(((Config *)cfg)->cfg), name, value);
if (CONFIG_FALSE == result) {
return CreateConfigCode(CONFIG_CODE_PARAM_NOT_EXIST);
}
return CreateStatusCode(STATUS_CODE_OK);
}
static const StatusCode ConfigSetIntImpl(VConfig *cfg, const char *name, const int value)
{
config_setting_t *root, *setting;
root = config_root_setting(&(((Config *)cfg)->cfg));
setting = config_setting_get_member(root, name);
if (!setting) {
setting = config_setting_add(root, name, CONFIG_TYPE_INT);
}
config_setting_set_int(setting, value);
return CreateStatusCode(STATUS_CODE_OK);
}
static const StatusCode ConfigGetShortImpl(VConfig *cfg, const char *name, short *value)
{
int intValue = 0;
int result = 0;
result = config_lookup_int(&(((Config *)cfg)->cfg), name, &intValue);
if (CONFIG_FALSE == result || CHECK_SHORT_LIMIT(intValue)) {
return CreateConfigCode(CONFIG_CODE_PARAM_NOT_EXIST);
}
*value = (short)intValue;
return CreateStatusCode(STATUS_CODE_OK);
}
static const StatusCode ConfigSetShortImpl(VConfig *cfg, const char *name, const short value)
{
config_setting_t *root, *setting;
root = config_root_setting(&(((Config *)cfg)->cfg));
setting = config_setting_get_member(root, name);
if (!setting) {
setting = config_setting_add(root, name, CONFIG_TYPE_INT);
}
int intValue = value;
config_setting_set_int(setting, intValue);
return CreateStatusCode(STATUS_CODE_OK);
}
static const StatusCode ConfigGetLongImpl(VConfig *cfg, const char *name, long *value)
{
long long llongValue = 0;
int result = 0;
result = config_lookup_int64(&(((Config *)cfg)->cfg), name, &llongValue);
if (CONFIG_FALSE == result || CHECK_LONG_LIMIT(llongValue)) {
return CreateConfigCode(CONFIG_CODE_PARAM_NOT_EXIST);
}
*value = (long)llongValue;
return CreateStatusCode(STATUS_CODE_OK);
}
static const StatusCode ConfigSetLongImpl(VConfig *cfg, const char *name, const long value)
{
config_setting_t *root, *setting;
root = config_root_setting(&(((Config *)cfg)->cfg));
setting = config_setting_get_member(root, name);
if (!setting) {
setting = config_setting_add(root, name, CONFIG_TYPE_INT64);
}
long long llongValue = value;
config_setting_set_int64(setting, llongValue);
return CreateStatusCode(STATUS_CODE_OK);
}
static const StatusCode ConfigGetLLongImpl(VConfig *cfg, const char *name, long long *value)
{
int result = 0;
result = config_lookup_int64(&(((Config *)cfg)->cfg), name, value);
if (CONFIG_FALSE == result) {
return CreateConfigCode(CONFIG_CODE_PARAM_NOT_EXIST);
}
return CreateStatusCode(STATUS_CODE_OK);
}
static const StatusCode ConfigSetLLongImpl(VConfig *cfg, const char *name, const long long value)
{
config_setting_t *root, *setting;
root = config_root_setting(&(((Config *)cfg)->cfg));
setting = config_setting_get_member(root, name);
if (!setting) {
setting = config_setting_add(root, name, CONFIG_TYPE_INT64);
}
config_setting_set_int64(setting, value);
return CreateStatusCode(STATUS_CODE_OK);
}
static const StatusCode ConfigGetCharImpl(VConfig *cfg, const char *name, char *value)
{
int charValue = 0;
int result = 0;
result = config_lookup_int(&(((Config *)cfg)->cfg), name, &charValue);
if (CONFIG_FALSE == result && CHECK_CHAR_LIMIT(charValue)) {
return CreateConfigCode(CONFIG_CODE_PARAM_NOT_EXIST);
}
*value = (char)charValue;
return CreateStatusCode(STATUS_CODE_OK);
}
static const StatusCode ConfigSetCharImpl(VConfig *cfg, const char *name, const char value)
{
config_setting_t *root, *setting;
root = config_root_setting(&(((Config *)cfg)->cfg));
setting = config_setting_get_member(root, name);
if (!setting) {
setting = config_setting_add(root, name, CONFIG_TYPE_INT);
}
int charValue = (int)value;
config_setting_set_int(setting, charValue);
return CreateStatusCode(STATUS_CODE_OK);
}
static const StatusCode ConfigGetBoolImpl(VConfig *cfg, const char *name, bool *value)
{
int result = 0;
result = config_lookup_bool(&(((Config *)cfg)->cfg), name, (int *)value);
if (CONFIG_FALSE == result) {
return CreateConfigCode(CONFIG_CODE_PARAM_NOT_EXIST);
}
return CreateStatusCode(STATUS_CODE_OK);
}
static const StatusCode ConfigSetBoolImpl(VConfig *cfg, const char *name, const bool value)
{
config_setting_t *root, *setting;
root = config_root_setting(&(((Config *)cfg)->cfg));
setting = config_setting_get_member(root, name);
if (!setting) {
setting = config_setting_add(root, name, CONFIG_TYPE_BOOL);
}
config_setting_set_bool(setting, (int)value);
return CreateStatusCode(STATUS_CODE_OK);
}
static const StatusCode ConfigGetFloatImpl(VConfig *cfg, const char *name, float *value)
{
double dValue = 0;
int result = 0;
result = config_lookup_float(&(((Config *)cfg)->cfg), name, &dValue);
if (CONFIG_FALSE == result || CHECK_FLOAT_LIMIT(dValue)) {
return CreateConfigCode(CONFIG_CODE_PARAM_NOT_EXIST);
}
*value = (float)dValue;
return CreateStatusCode(STATUS_CODE_OK);
}
static const StatusCode ConfigSetFloatImpl(VConfig *cfg, const char *name, const float value)
{
config_setting_t *root, *setting;
root = config_root_setting(&(((Config *)cfg)->cfg));
setting = config_setting_get_member(root, name);
if (!setting) {
setting = config_setting_add(root, name, CONFIG_TYPE_FLOAT);
}
double dValue = value;
config_setting_set_float(setting, dValue);
return CreateStatusCode(STATUS_CODE_OK);
}
static const StatusCode ConfigGetDoubleImpl(VConfig *cfg, const char *name, double *value)
{
int result = 0;
result = config_lookup_float(&(((Config *)cfg)->cfg), name, value);
if (CONFIG_FALSE == result) {
return CreateConfigCode(CONFIG_CODE_PARAM_NOT_EXIST);
}
return CreateStatusCode(STATUS_CODE_OK);
}
static const StatusCode ConfigSetDoubleImpl(VConfig *cfg, const char *name, const double value)
{
config_setting_t *root, *setting;
root = config_root_setting(&(((Config *)cfg)->cfg));
setting = config_setting_get_member(root, name);
if (!setting) {
setting = config_setting_add(root, name, CONFIG_TYPE_FLOAT);
}
config_setting_set_float(setting, value);
return CreateStatusCode(STATUS_CODE_OK);
}
static const StatusCode ConfigGetStringImpl(VConfig *cfg, const char *name, const char **value)
{
int result = 0;
// config_setting_t *root;
result = config_lookup_string(&(((Config *)cfg)->cfg), name, value);
if (CONFIG_FALSE == result) {
return CreateConfigCode(CONFIG_CODE_PARAM_NOT_EXIST);
}
return CreateStatusCode(STATUS_CODE_OK);
}
static const StatusCode ConfigSetStringImpl(VConfig *cfg, const char *name, const char *value)
{
config_setting_t *root, *setting;
root = config_root_setting(&(((Config *)cfg)->cfg));
setting = config_setting_get_member(root, name);
if (!setting) {
setting = config_setting_add(root, name, CONFIG_TYPE_STRING);
}
config_setting_set_string(setting, value);
return CreateStatusCode(STATUS_CODE_OK);
}
static void ConfigImplInit(Config *cfg)
{
if (NULL == cfg) {
LogError("NULL pointer.\n");
return;
}
cfg->mFileName = NULL;
cfg->close = ConfigClose;
cfg->base.get_int = ConfigGetIntImpl;
cfg->base.set_int = ConfigSetIntImpl;
cfg->base.get_short = ConfigGetShortImpl;
cfg->base.set_short = ConfigSetShortImpl;
cfg->base.get_long = ConfigGetLongImpl;
cfg->base.set_long = ConfigSetLongImpl;
cfg->base.get_llong = ConfigGetLLongImpl;
cfg->base.set_llong = ConfigSetLLongImpl;
cfg->base.get_char = ConfigGetCharImpl;
cfg->base.set_char = ConfigSetCharImpl;
cfg->base.get_bool = ConfigGetBoolImpl;
cfg->base.set_bool = ConfigSetBoolImpl;
cfg->base.get_float = ConfigGetFloatImpl;
cfg->base.set_float = ConfigSetFloatImpl;
cfg->base.get_double = ConfigGetDoubleImpl;
cfg->base.set_double = ConfigSetDoubleImpl;
cfg->base.get_string = ConfigGetStringImpl;
cfg->base.set_string = ConfigSetStringImpl;
cfg->base.save = ConfigSaveFileImpl;
}
Config *NewConfig(const char *fileName)
{
LogInfo("Config file name = %s\n", fileName);
Config *cfg = (Config *)malloc(sizeof(Config));
ConfigImplInit(cfg);
config_init(&(cfg->cfg));
config_set_options(&(cfg->cfg),
(CONFIG_OPTION_FSYNC | CONFIG_OPTION_SEMICOLON_SEPARATORS |
CONFIG_OPTION_COLON_ASSIGNMENT_FOR_GROUPS | CONFIG_OPTION_OPEN_BRACE_ON_SEPARATE_LINE));
#define FIEL_EXIST 0
if (FIEL_EXIST == access(fileName, F_OK)) {
if (!config_read_file(&(cfg->cfg), fileName)) {
LogError("Read file failed[%s].\n", fileName);
fprintf(stderr,
"%s:%d - %s\n",
config_error_file(&(cfg->cfg)),
config_error_line(&(cfg->cfg)),
config_error_text(&(cfg->cfg)));
return NULL;
}
}
else {
LogInfo("Config file doesn't exist.\n");
/* Write out the new configuration. */
if (!config_write_file(&(cfg->cfg), fileName)) {
fprintf(stderr, "Error while writing file.\n");
return NULL;
}
}
unsigned int fileLength = strlen(fileName) + 1;
cfg->mFileName = (char *)malloc(fileLength);
memset(cfg->mFileName, 0, fileLength);
if (NULL != cfg->mFileName) {
memcpy(cfg->mFileName, fileName, fileLength - 1);
}
return cfg;
}

37
utils/Config/src/ConfigImpl.h Normal file
View File

@ -0,0 +1,37 @@
/*
* Copyright (c) 2023 Fancy Code.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef CONFIGIMPL_H
#define CONFIGIMPL_H
#include "Config.h"
#include <libconfig.h>
#ifdef __cplusplus
extern "C" {
#endif
#ifndef CONFIG_OWNER
#error This is internal file, never include it.
#endif
typedef struct config Config;
typedef struct config
{
VConfig base;
void (*close)(VConfig *);
config_t cfg;
char *mFileName;
} Config;
Config *NewConfig(const char *fileName);
#ifdef __cplusplus
}
#endif
#endif

79
utils/ConfigBase/CMakeLists.txt Normal file
View File

@ -0,0 +1,79 @@
include(${CMAKE_SOURCE_DIR_IPCSDK}/build/global_config.cmake)
include(build/config_base.cmake)
set(EXECUTABLE_OUTPUT_PATH ${EXEC_OUTPUT_PATH})
set(LIBRARY_OUTPUT_PATH ${LIBS_OUTPUT_PATH})
include_directories(
./src
./include
${UTILS_SOURCE_PATH}/StatusCode/include
${UTILS_SOURCE_PATH}/Log/include
${EXTERNAL_SOURCE_PATH}/libconfig/libconfig-1.7.3/lib
)
# link_directories(
# ${EXTERNAL_SOURCE_PATH}/libconfig/libconfig-1.7.3/lib/.libs
# )
aux_source_directory(./src SRC_FILES)
set(TARGET_NAME ConfigBase)
add_library(${TARGET_NAME} STATIC ${SRC_FILES})
target_link_libraries(${TARGET_NAME} StatusCode Log libconfig.a)
if ("${COMPILE_IMPROVE_SUPPORT}" MATCHES "true")
add_custom_target(
ConfigBase_code_check
COMMAND ${CLANG_TIDY_EXE}
-checks='${CLANG_TIDY_CHECKS}'
--header-filter=.*
--system-headers=false
${SRC_FILES}
${CLANG_TIDY_CONFIG}
-p ${PLATFORM_PATH}/cmake-shell
WORKING_DIRECTORY ${UTILS_SOURCE_PATH}/ConfigBase
)
add_custom_command(
TARGET ${TARGET_NAME}
PRE_BUILD
COMMAND make ConfigBase_code_check
WORKING_DIRECTORY ${PLATFORM_PATH}/cmake-shell/
)
file(GLOB_RECURSE HEADER_FILES *.h)
add_custom_target(
ConfigBase_code_format
COMMAND ${CLANG_FORMAT_EXE}
-style=file
-i ${SRC_FILES} ${HEADER_FILES}
WORKING_DIRECTORY ${UTILS_SOURCE_PATH}/ConfigBase
)
add_custom_command(
TARGET ${TARGET_NAME}
PRE_BUILD
COMMAND make ConfigBase_code_check
COMMAND make ConfigBase_code_format
WORKING_DIRECTORY ${PLATFORM_PATH}/cmake-shell/
)
endif()
# build libconfig before make libConfigBase.a
add_custom_command(
# OUTPUT ${EXTERNAL_SOURCE_PATH}/libconfig/libconfig-1.7.3/lib/.libs/libconfig.a
OUTPUT ${EXTERNAL_LIBS_OUTPUT_PATH}/libconfig.a
COMMAND echo "Build libconfig-1.7.3. COMPILE_HOST = ${COMPILE_HOST}"
# COMMAND tar zxvf libconfig-1.7.3.tar.gz
COMMAND sh build_libconfig.sh ${TARGET_PLATFORM} ${COMPILE_HOST}
COMMAND mv ${EXTERNAL_SOURCE_PATH}/libconfig/libconfig-1.7.3/lib/.libs/libconfig.a ${EXTERNAL_LIBS_OUTPUT_PATH}/libconfig.a
WORKING_DIRECTORY ${EXTERNAL_SOURCE_PATH}/libconfig/
)
add_custom_target(
libconfig.a
# DEPENDS ${EXTERNAL_SOURCE_PATH}/libconfig/libconfig-1.7.3/lib/.libs/libconfig.a
DEPENDS ${EXTERNAL_LIBS_OUTPUT_PATH}/libconfig.a
)
define_file_name(${TARGET_NAME})
config_owner(${TARGET_NAME})
file(GLOB_RECURSE INSTALL_HEADER_FILES include/*.h)
install(FILES ${INSTALL_HEADER_FILES} DESTINATION include)

12
utils/ConfigBase/build/config_base.cmake Normal file
View File

@ -0,0 +1,12 @@
function(config_owner target)
get_target_property(source_files "${target}" SOURCES)
foreach(source_file ${source_files})
get_property(defs SOURCE "${source_file}"
PROPERTY COMPILE_DEFINITIONS)
get_filename_component(file_name "${source_file}" NAME)
list(APPEND defs "CONFIG_OWNER")
set_property(
SOURCE "${source_file}"
PROPERTY COMPILE_DEFINITIONS ${defs})
endforeach()
endfunction()

52
utils/ConfigBase/include/ConfigBase.h Normal file
View File

@ -0,0 +1,52 @@
/*
* Copyright (c) 2023 Fancy Code.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef CONFIG_BASE_H
#define CONFIG_BASE_H
#include "StatusCode.h"
#ifdef __cplusplus
extern "C" {
#endif
enum CONFIG_CODE
{
CONFIG_CODE_PARAM_NOT_EXIST = STATUS_CODE_END,
CONFIG_CODE_END
};
// StatusCode ConfigInit(void);
// StatusCode ConfigUnInit(void);
void *OpenConfigFile(const char *fileName);
StatusCode ConfigSaveFile(void *object);
void CloseConfigFile(void *object);
StatusCode ConfigGetInt(void *object, const char *name, int *value);
StatusCode ConfigSetInt(void *object, const char *name, const int value);
StatusCode ConfigGetShort(void *object, const char *name, short *value);
StatusCode ConfigSetShort(void *object, const char *name, const short value);
StatusCode ConfigGetLong(void *object, const char *name, long *value);
StatusCode ConfigSetLong(void *object, const char *name, const long value);
StatusCode ConfigGetLLong(void *object, const char *name, long long *value);
StatusCode ConfigSetLLong(void *object, const char *name, const long long value);
StatusCode ConfigGetChar(void *object, const char *name, char *value);
StatusCode ConfigSetChar(void *object, const char *name, const char value);
StatusCode ConfigGetBool(void *object, const char *name, bool *value);
StatusCode ConfigSetBool(void *object, const char *name, const bool value);
StatusCode ConfigGetFloat(void *object, const char *name, float *value);
StatusCode ConfigSetFloat(void *object, const char *name, const float value);
StatusCode ConfigGetDouble(void *object, const char *name, double *value);
StatusCode ConfigSetDouble(void *object, const char *name, const double value);
StatusCode ConfigGetString(void *object, const char *name, const char **value);
StatusCode ConfigSetString(void *object, const char *name, const char *value);
#ifdef __cplusplus
}
#endif
#endif

180
utils/ConfigBase/src/ConfigBase.cpp Normal file
View File

@ -0,0 +1,180 @@
/*
* Copyright (c) 2023 Fancy Code.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "ConfigBase.h"
#include "IConfigBase.h"
#include "ILog.h"
static bool ObjectCheck(void *object)
{
if (nullptr == object) {
LogError("nullptr object!\n");
return false;
}
if (*((const char **)(((char *)object) - sizeof(IConfigBaseHeader))) != GetConfigBaseModuleName()) {
LogError("Illegal object!\n");
return false;
}
return true;
}
void *OpenConfigFile(const char *fileName)
{
std::shared_ptr<IConfigBase> *configObject = NewConfigBase(fileName);
if (nullptr != configObject) {
if ((*configObject)->OpenConfigFile() == false) {
return nullptr;
}
}
return configObject;
}
StatusCode ConfigSaveFile(void *object)
{
if (ObjectCheck(object) == true) {
return (*(std::shared_ptr<IConfigBase> *)object)->ConfigSaveFile();
}
return CreateStatusCode(STATUS_CODE_INVALID_PARAMENTER);
}
void CloseConfigFile(void *object)
{
if (ObjectCheck(object) == true) {
(*(std::shared_ptr<IConfigBase> *)object)->CloseConfigFile();
(*(std::shared_ptr<IConfigBase> *)object).reset();
free(((char *)object) - sizeof(IConfigBaseHeader)); // TODO: bug?
}
}
StatusCode ConfigGetInt(void *object, const char *name, int *value)
{
if (ObjectCheck(object) == true) {
return (*(std::shared_ptr<IConfigBase> *)object)->ConfigGetInt(name, value);
}
return CreateStatusCode(STATUS_CODE_INVALID_PARAMENTER);
}
StatusCode ConfigSetInt(void *object, const char *name, const int value)
{
if (ObjectCheck(object) == true) {
return (*(std::shared_ptr<IConfigBase> *)object)->ConfigSetInt(name, value);
}
return CreateStatusCode(STATUS_CODE_INVALID_PARAMENTER);
}
StatusCode ConfigGetShort(void *object, const char *name, short *value)
{
if (ObjectCheck(object) == true) {
return (*(std::shared_ptr<IConfigBase> *)object)->ConfigGetShort(name, value);
}
return CreateStatusCode(STATUS_CODE_INVALID_PARAMENTER);
}
StatusCode ConfigSetShort(void *object, const char *name, const short value)
{
if (ObjectCheck(object) == true) {
return (*(std::shared_ptr<IConfigBase> *)object)->ConfigSetShort(name, value);
}
return CreateStatusCode(STATUS_CODE_INVALID_PARAMENTER);
}
StatusCode ConfigGetLong(void *object, const char *name, long *value)
{
if (ObjectCheck(object) == true) {
return (*(std::shared_ptr<IConfigBase> *)object)->ConfigGetLong(name, value);
}
return CreateStatusCode(STATUS_CODE_INVALID_PARAMENTER);
}
StatusCode ConfigSetLong(void *object, const char *name, const long value)
{
if (ObjectCheck(object) == true) {
return (*(std::shared_ptr<IConfigBase> *)object)->ConfigSetLong(name, value);
}
return CreateStatusCode(STATUS_CODE_INVALID_PARAMENTER);
}
StatusCode ConfigGetLLong(void *object, const char *name, long long *value)
{
if (ObjectCheck(object) == true) {
return (*(std::shared_ptr<IConfigBase> *)object)->ConfigGetLLong(name, value);
}
return CreateStatusCode(STATUS_CODE_INVALID_PARAMENTER);
}
StatusCode ConfigSetLLong(void *object, const char *name, const long long value)
{
if (ObjectCheck(object) == true) {
return (*(std::shared_ptr<IConfigBase> *)object)->ConfigSetLLong(name, value);
}
return CreateStatusCode(STATUS_CODE_INVALID_PARAMENTER);
}
StatusCode ConfigGetChar(void *object, const char *name, char *value)
{
if (ObjectCheck(object) == true) {
return (*(std::shared_ptr<IConfigBase> *)object)->ConfigGetChar(name, value);
}
return CreateStatusCode(STATUS_CODE_INVALID_PARAMENTER);
}
StatusCode ConfigSetChar(void *object, const char *name, const char value)
{
if (ObjectCheck(object) == true) {
return (*(std::shared_ptr<IConfigBase> *)object)->ConfigSetChar(name, value);
}
return CreateStatusCode(STATUS_CODE_INVALID_PARAMENTER);
}
StatusCode ConfigGetBool(void *object, const char *name, bool *value)
{
if (ObjectCheck(object) == true) {
return (*(std::shared_ptr<IConfigBase> *)object)->ConfigGetBool(name, value);
}
return CreateStatusCode(STATUS_CODE_INVALID_PARAMENTER);
}
StatusCode ConfigSetBool(void *object, const char *name, const bool value)
{
if (ObjectCheck(object) == true) {
return (*(std::shared_ptr<IConfigBase> *)object)->ConfigSetBool(name, value);
}
return CreateStatusCode(STATUS_CODE_INVALID_PARAMENTER);
}
StatusCode ConfigGetFloat(void *object, const char *name, float *value)
{
if (ObjectCheck(object) == true) {
return (*(std::shared_ptr<IConfigBase> *)object)->ConfigGetFloat(name, value);
}
return CreateStatusCode(STATUS_CODE_INVALID_PARAMENTER);
}
StatusCode ConfigSetFloat(void *object, const char *name, const float value)
{
if (ObjectCheck(object) == true) {
return (*(std::shared_ptr<IConfigBase> *)object)->ConfigSetFloat(name, value);
}
return CreateStatusCode(STATUS_CODE_INVALID_PARAMENTER);
}
StatusCode ConfigGetDouble(void *object, const char *name, double *value)
{
if (ObjectCheck(object) == true) {
return (*(std::shared_ptr<IConfigBase> *)object)->ConfigGetDouble(name, value);
}
return CreateStatusCode(STATUS_CODE_INVALID_PARAMENTER);
}
StatusCode ConfigSetDouble(void *object, const char *name, const double value)
{
if (ObjectCheck(object) == true) {
return (*(std::shared_ptr<IConfigBase> *)object)->ConfigSetDouble(name, value);
}
return CreateStatusCode(STATUS_CODE_INVALID_PARAMENTER);
}
StatusCode ConfigGetString(void *object, const char *name, const char **value)
{
if (ObjectCheck(object) == true) {
return (*(std::shared_ptr<IConfigBase> *)object)->ConfigGetString(name, value);
}
return CreateStatusCode(STATUS_CODE_INVALID_PARAMENTER);
}
StatusCode ConfigSetString(void *object, const char *name, const char *value)
{
if (ObjectCheck(object) == true) {
return (*(std::shared_ptr<IConfigBase> *)object)->ConfigSetString(name, value);
}
return CreateStatusCode(STATUS_CODE_INVALID_PARAMENTER);
}

53
utils/ConfigBase/src/ConfigBaseCode.c Normal file
View File

@ -0,0 +1,53 @@
/*
* Copyright (c) 2023 Fancy Code.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "ConfigBaseCode.h"
#include "ILog.h"
#include <string.h>
static const char *ConfigCodeString[CONFIG_CODE_END - STATUS_CODE_END + 1] = {"CONFIG_CODE_PARAM_NOT_EXIST",
"CONFIG_CODE_END"};
static const char *PrintStringConfigCode(const StatusCode this)
{
const int CODE_INDEX = this.mStatusCode - STATUS_CODE_END;
if (STATUS_CODE_END <= this.mStatusCode && this.mStatusCode <= CONFIG_CODE_END) {
LogInfo("Config code = [ %s ]\n", ConfigCodeString[CODE_INDEX]);
return ConfigCodeString[CODE_INDEX];
}
LogError("Config code undefine.\n");
return "Config code undefine.\n";
}
static const bool CodeEqual(const StatusCode code, const char *value)
{
if (memcmp(value, ConfigCodeString[code.mStatusCode - STATUS_CODE_END], strlen(value)) == 0) {
return true;
}
return false;
}
static StatusCode NewConfigCode(const long int code)
{
StatusCode result = {PrintStringConfigCode, CodeEqual, code};
return result;
}
const StatusCode CreateConfigCode(const long int code)
{
// if (STATUS_CODE_OK <= code && code < STATUS_CODE_END)
// {
// return CreateStatusCode(code);
// }
if (STATUS_CODE_END <= code && code < CONFIG_CODE_END) {
return NewConfigCode(code);
}
LogError("undefined code.\n");
return CreateStatusCode(STATUS_CODE_END);
}

29
utils/ConfigBase/src/ConfigBaseCode.h Normal file
View File

@ -0,0 +1,29 @@
/*
* Copyright (c) 2023 Fancy Code.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef CONFIG_BASE_CODE_H
#define CONFIG_BASE_CODE_H
#include "ConfigBase.h"
#include "StatusCode.h"
#ifdef __cplusplus
extern "C" {
#endif
#ifndef CONFIG_OWNER
#error This is internal file, never include it.
#endif
const StatusCode CreateConfigCode(const long int code);
#ifdef __cplusplus
}
#endif
#endif

340
utils/ConfigBase/src/ConfigBaseImpl.cpp Normal file
View File

@ -0,0 +1,340 @@
/*
* Copyright (c) 2023 Fancy Code.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "ConfigBaseImpl.h"
#include "ConfigBaseCode.h"
#include "ILog.h"
#include <limits.h>
#include <math.h>
#include <unistd.h>
constexpr int INVALID_RESULT = -1;
#define CHECK_SHORT_LIMIT(value) (value > SHRT_MAX ? false : (value < SHRT_MIN ? false : true))
#define CHECK_LONG_LIMIT(value) (value > LONG_MAX ? false : (value < LONG_MIN ? false : true))
#define CHECK_CHAR_LIMIT(value) (value > CHAR_MAX ? false : (value < CHAR_MIN ? false : true))
#define CHECK_FLOAT_LIMIT(value) (fabs(value - ((float)value)) < 0.000001 ? false : true)
ConfigBaseImpl::ConfigBaseImpl(const std::string &fileName) : mFileName(fileName)
{
}
bool ConfigBaseImpl::OpenConfigFile(void)
{
config_init(&mCfg);
config_set_options(&mCfg,
(CONFIG_OPTION_FSYNC | CONFIG_OPTION_SEMICOLON_SEPARATORS |
CONFIG_OPTION_COLON_ASSIGNMENT_FOR_GROUPS | CONFIG_OPTION_OPEN_BRACE_ON_SEPARATE_LINE));
constexpr int FIEL_EXIST = 0;
if (FIEL_EXIST == access(mFileName.c_str(), F_OK)) {
if (!config_read_file(&mCfg, mFileName.c_str())) {
LogError("Read file failed[%s].\n", mFileName.c_str());
fprintf(stderr, "%s:%d - %s\n", config_error_file(&mCfg), config_error_line(&mCfg), config_error_text(&mCfg));
return false;
}
}
else {
LogInfo("Config file doesn't exist.mFileName = %s\n", mFileName.c_str());
/* Write out the new configuration. */
if (!config_write_file(&mCfg, mFileName.c_str())) {
fprintf(stderr, "Error while writing file.\n");
return false;
}
}
return true;
}
void ConfigBaseImpl::CloseConfigFile(void)
{
config_destroy(&mCfg);
}
StatusCode ConfigBaseImpl::ConfigSaveFile(void)
{
LogInfo("Save file[%s].\n", mFileName.c_str());
if (!config_write_file(&mCfg, mFileName.c_str())) {
LogError("Save config failed.\n");
return CreateStatusCode(STATUS_CODE_NOT_OK);
}
return CreateStatusCode(STATUS_CODE_OK);
}
StatusCode ConfigBaseImpl::ConfigGetInt(const char *name, int *value)
{
int result = INVALID_RESULT;
result = config_lookup_int(&mCfg, name, value);
if (CONFIG_FALSE == result) {
return CreateConfigCode(CONFIG_CODE_PARAM_NOT_EXIST);
}
return CreateStatusCode(STATUS_CODE_OK);
}
StatusCode ConfigBaseImpl::ConfigSetInt(const char *name, const int value)
{
config_setting_t *root = nullptr;
config_setting_t *setting = nullptr;
root = config_root_setting(&mCfg);
if (nullptr == root) {
LogError("Config function failed.\n");
return CreateConfigCode(STATUS_CODE_NOT_OK);
}
setting = config_setting_get_member(root, name);
if (nullptr == setting) {
setting = config_setting_add(root, name, CONFIG_TYPE_INT);
}
if (nullptr == setting) {
LogError("Config function failed.\n");
return CreateConfigCode(STATUS_CODE_NOT_OK);
}
config_setting_set_int(setting, value);
return CreateStatusCode(STATUS_CODE_OK);
}
StatusCode ConfigBaseImpl::ConfigGetShort(const char *name, short *value)
{
int intValue = 0;
int result = 0;
result = config_lookup_int(&mCfg, name, &intValue);
if (CONFIG_FALSE == result || CHECK_SHORT_LIMIT(intValue)) {
return CreateConfigCode(CONFIG_CODE_PARAM_NOT_EXIST);
}
*value = (short)intValue;
return CreateStatusCode(STATUS_CODE_OK);
}
StatusCode ConfigBaseImpl::ConfigSetShort(const char *name, const short value)
{
config_setting_t *root = nullptr;
config_setting_t *setting = nullptr;
root = config_root_setting(&mCfg);
if (nullptr == root) {
LogError("Config function failed.\n");
return CreateConfigCode(STATUS_CODE_NOT_OK);
}
setting = config_setting_get_member(root, name);
if (nullptr == setting) {
setting = config_setting_add(root, name, CONFIG_TYPE_INT);
}
if (nullptr == setting) {
LogError("Config function failed.\n");
return CreateConfigCode(STATUS_CODE_NOT_OK);
}
int intValue = value;
config_setting_set_int(setting, intValue);
return CreateStatusCode(STATUS_CODE_OK);
}
StatusCode ConfigBaseImpl::ConfigGetLong(const char *name, long *value)
{
long long llongValue = 0;
int result = 0;
result = config_lookup_int64(&mCfg, name, &llongValue);
if (CONFIG_FALSE == result || CHECK_LONG_LIMIT(llongValue)) {
return CreateConfigCode(CONFIG_CODE_PARAM_NOT_EXIST);
}
*value = (long)llongValue;
return CreateStatusCode(STATUS_CODE_OK);
}
StatusCode ConfigBaseImpl::ConfigSetLong(const char *name, const long value)
{
config_setting_t *root = nullptr;
config_setting_t *setting = nullptr;
root = config_root_setting(&mCfg);
if (nullptr == root) {
LogError("Config function failed.\n");
return CreateConfigCode(STATUS_CODE_NOT_OK);
}
setting = config_setting_get_member(root, name);
if (nullptr == setting) {
setting = config_setting_add(root, name, CONFIG_TYPE_INT64);
}
if (nullptr == setting) {
LogError("Config function failed.\n");
return CreateConfigCode(STATUS_CODE_NOT_OK);
}
long long llongValue = value;
config_setting_set_int64(setting, llongValue);
return CreateStatusCode(STATUS_CODE_OK);
}
StatusCode ConfigBaseImpl::ConfigGetLLong(const char *name, long long *value)
{
int result = 0;
result = config_lookup_int64(&mCfg, name, value);
if (CONFIG_FALSE == result) {
return CreateConfigCode(CONFIG_CODE_PARAM_NOT_EXIST);
}
return CreateStatusCode(STATUS_CODE_OK);
}
StatusCode ConfigBaseImpl::ConfigSetLLong(const char *name, const long long value)
{
config_setting_t *root = nullptr;
config_setting_t *setting = nullptr;
root = config_root_setting(&mCfg);
if (nullptr == root) {
LogError("Config function failed.\n");
return CreateConfigCode(STATUS_CODE_NOT_OK);
}
setting = config_setting_get_member(root, name);
if (nullptr == setting) {
setting = config_setting_add(root, name, CONFIG_TYPE_INT64);
}
if (nullptr == setting) {
LogError("Config function failed.\n");
return CreateConfigCode(STATUS_CODE_NOT_OK);
}
config_setting_set_int64(setting, value);
return CreateStatusCode(STATUS_CODE_OK);
}
StatusCode ConfigBaseImpl::ConfigGetChar(const char *name, char *value)
{
int charValue = 0;
int result = 0;
result = config_lookup_int(&mCfg, name, &charValue);
if (CONFIG_FALSE == result && CHECK_CHAR_LIMIT(charValue)) {
return CreateConfigCode(CONFIG_CODE_PARAM_NOT_EXIST);
}
*value = (char)charValue;
return CreateStatusCode(STATUS_CODE_OK);
}
StatusCode ConfigBaseImpl::ConfigSetChar(const char *name, const char value)
{
config_setting_t *root = nullptr;
config_setting_t *setting = nullptr;
root = config_root_setting(&mCfg);
if (nullptr == root) {
LogError("Config function failed.\n");
return CreateConfigCode(STATUS_CODE_NOT_OK);
}
setting = config_setting_get_member(root, name);
if (nullptr == setting) {
setting = config_setting_add(root, name, CONFIG_TYPE_INT);
}
if (nullptr == setting) {
LogError("Config function failed.\n");
return CreateConfigCode(STATUS_CODE_NOT_OK);
}
int charValue = (int)value;
config_setting_set_int(setting, charValue);
return CreateStatusCode(STATUS_CODE_OK);
}
StatusCode ConfigBaseImpl::ConfigGetBool(const char *name, bool *value)
{
int result = 0;
result = config_lookup_bool(&mCfg, name, (int *)value);
if (CONFIG_FALSE == result) {
return CreateConfigCode(CONFIG_CODE_PARAM_NOT_EXIST);
}
return CreateStatusCode(STATUS_CODE_OK);
}
StatusCode ConfigBaseImpl::ConfigSetBool(const char *name, const bool value)
{
config_setting_t *root = nullptr;
config_setting_t *setting = nullptr;
root = config_root_setting(&mCfg);
if (nullptr == root) {
LogError("Config function failed.\n");
return CreateConfigCode(STATUS_CODE_NOT_OK);
}
setting = config_setting_get_member(root, name);
if (nullptr == setting) {
setting = config_setting_add(root, name, CONFIG_TYPE_BOOL);
}
if (nullptr == setting) {
LogError("Config function failed.\n");
return CreateConfigCode(STATUS_CODE_NOT_OK);
}
config_setting_set_bool(setting, (int)value);
return CreateStatusCode(STATUS_CODE_OK);
}
StatusCode ConfigBaseImpl::ConfigGetFloat(const char *name, float *value)
{
double dValue = 0;
int result = 0;
result = config_lookup_float(&mCfg, name, &dValue);
if (CONFIG_FALSE == result || CHECK_FLOAT_LIMIT(dValue)) {
return CreateConfigCode(CONFIG_CODE_PARAM_NOT_EXIST);
}
*value = (float)dValue;
return CreateStatusCode(STATUS_CODE_OK);
}
StatusCode ConfigBaseImpl::ConfigSetFloat(const char *name, const float value)
{
config_setting_t *root = nullptr;
config_setting_t *setting = nullptr;
root = config_root_setting(&mCfg);
if (nullptr == root) {
LogError("Config function failed.\n");
return CreateConfigCode(STATUS_CODE_NOT_OK);
}
setting = config_setting_get_member(root, name);
if (nullptr == setting) {
setting = config_setting_add(root, name, CONFIG_TYPE_FLOAT);
}
if (nullptr == setting) {
LogError("Config function failed.\n");
return CreateConfigCode(STATUS_CODE_NOT_OK);
}
double dValue = value;
config_setting_set_float(setting, dValue);
return CreateStatusCode(STATUS_CODE_OK);
}
StatusCode ConfigBaseImpl::ConfigGetDouble(const char *name, double *value)
{
int result = 0;
result = config_lookup_float(&mCfg, name, value);
if (CONFIG_FALSE == result) {
return CreateConfigCode(CONFIG_CODE_PARAM_NOT_EXIST);
}
return CreateStatusCode(STATUS_CODE_OK);
}
StatusCode ConfigBaseImpl::ConfigSetDouble(const char *name, const double value)
{
config_setting_t *root = nullptr;
config_setting_t *setting = nullptr;
root = config_root_setting(&mCfg);
if (nullptr == root) {
LogError("Config function failed.\n");
return CreateConfigCode(STATUS_CODE_NOT_OK);
}
setting = config_setting_get_member(root, name);
if (nullptr == setting) {
setting = config_setting_add(root, name, CONFIG_TYPE_FLOAT);
}
if (nullptr == setting) {
LogError("Config function failed.\n");
return CreateConfigCode(STATUS_CODE_NOT_OK);
}
config_setting_set_float(setting, value);
return CreateStatusCode(STATUS_CODE_OK);
}
StatusCode ConfigBaseImpl::ConfigGetString(const char *name, const char **value)
{
int result = 0;
result = config_lookup_string(&mCfg, name, value);
if (CONFIG_FALSE == result) {
return CreateConfigCode(CONFIG_CODE_PARAM_NOT_EXIST);
}
return CreateStatusCode(STATUS_CODE_OK);
}
StatusCode ConfigBaseImpl::ConfigSetString(const char *name, const char *value)
{
config_setting_t *root = nullptr;
config_setting_t *setting = nullptr;
root = config_root_setting(&mCfg);
if (nullptr == root) {
LogError("Config function failed.\n");
return CreateConfigCode(STATUS_CODE_NOT_OK);
}
setting = config_setting_get_member(root, name);
if (!setting) {
setting = config_setting_add(root, name, CONFIG_TYPE_STRING);
}
if (nullptr == setting) {
LogError("Config function failed.\n");
return CreateConfigCode(STATUS_CODE_NOT_OK);
}
config_setting_set_string(setting, value);
return CreateStatusCode(STATUS_CODE_OK);
}

50
utils/ConfigBase/src/ConfigBaseImpl.h Normal file
View File

@ -0,0 +1,50 @@
/*
* Copyright (c) 2023 Fancy Code.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef CONFIG_BASE_IMPL_H
#define CONFIG_BASE_IMPL_H
#include "IConfigBase.h"
#include <libconfig.h>
class ConfigBaseImpl : public IConfigBase
{
public:
ConfigBaseImpl(const std::string &fileName);
virtual ~ConfigBaseImpl() = default;
bool OpenConfigFile(void) override;
void CloseConfigFile(void) override;
StatusCode ConfigSaveFile(void) override;
StatusCode ConfigGetInt(const char *name, int *value) override;
StatusCode ConfigSetInt(const char *name, const int value) override;
StatusCode ConfigGetShort(const char *name, short *value) override;
StatusCode ConfigSetShort(const char *name, const short value) override;
StatusCode ConfigGetLong(const char *name, long *value) override;
StatusCode ConfigSetLong(const char *name, const long value) override;
StatusCode ConfigGetLLong(const char *name, long long *value) override;
StatusCode ConfigSetLLong(const char *name, const long long value) override;
StatusCode ConfigGetChar(const char *name, char *value) override;
StatusCode ConfigSetChar(const char *name, const char value) override;
StatusCode ConfigGetBool(const char *name, bool *value) override;
StatusCode ConfigSetBool(const char *name, const bool value) override;
StatusCode ConfigGetFloat(const char *name, float *value) override;
StatusCode ConfigSetFloat(const char *name, const float value) override;
StatusCode ConfigGetDouble(const char *name, double *value) override;
StatusCode ConfigSetDouble(const char *name, const double value) override;
StatusCode ConfigGetString(const char *name, const char **value) override;
StatusCode ConfigSetString(const char *name, const char *value) override;
private:
const std::string mFileName;
config_t mCfg;
};
#endif

120
utils/ConfigBase/src/IConfigBase.cpp Normal file
View File

@ -0,0 +1,120 @@
/*
* Copyright (c) 2023 Fancy Code.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "IConfigBase.h"
#include "ConfigBaseImpl.h"
#include "ILog.h"
#include <cstring>
bool IConfigBase::OpenConfigFile(void)
{
return false;
}
void IConfigBase::CloseConfigFile(void)
{
}
StatusCode IConfigBase::ConfigSaveFile(void)
{
return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
}
StatusCode IConfigBase::ConfigGetInt(const char *name, int *value)
{
return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
}
StatusCode IConfigBase::ConfigSetInt(const char *name, const int value)
{
return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
}
StatusCode IConfigBase::ConfigGetShort(const char *name, short *value)
{
return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
}
StatusCode IConfigBase::ConfigSetShort(const char *name, const short value)
{
return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
}
StatusCode IConfigBase::ConfigGetLong(const char *name, long *value)
{
return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
}
StatusCode IConfigBase::ConfigSetLong(const char *name, const long value)
{
return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
}
StatusCode IConfigBase::ConfigGetLLong(const char *name, long long *value)
{
return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
}
StatusCode IConfigBase::ConfigSetLLong(const char *name, const long long value)
{
return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
}
StatusCode IConfigBase::ConfigGetChar(const char *name, char *value)
{
return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
}
StatusCode IConfigBase::ConfigSetChar(const char *name, const char value)
{
return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
}
StatusCode IConfigBase::ConfigGetBool(const char *name, bool *value)
{
return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
}
StatusCode IConfigBase::ConfigSetBool(const char *name, const bool value)
{
return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
}
StatusCode IConfigBase::ConfigGetFloat(const char *name, float *value)
{
return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
}
StatusCode IConfigBase::ConfigSetFloat(const char *name, const float value)
{
return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
}
StatusCode IConfigBase::ConfigGetDouble(const char *name, double *value)
{
return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
}
StatusCode IConfigBase::ConfigSetDouble(const char *name, const double value)
{
return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
}
StatusCode IConfigBase::ConfigGetString(const char *name, const char **value)
{
return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
}
StatusCode IConfigBase::ConfigSetString(const char *name, const char *value)
{
return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
}
static const char *CONFIG_BASE_NAME = "config_base";
const char *GetConfigBaseModuleName(void)
{
return CONFIG_BASE_NAME;
}
std::shared_ptr<IConfigBase> *NewConfigBase(const char *fileName)
{
LogInfo("Create the config base object.\n");
ConfigBase *impl = (ConfigBase *)malloc(sizeof(ConfigBase));
if (nullptr == impl) {
LogError("NewConfigBase::malloc failed.\n");
return nullptr;
}
ConfigBase tmp;
memcpy((void *)impl, (void *)&tmp, sizeof(ConfigBase));
impl->mHeader.mCheckName = CONFIG_BASE_NAME;
impl->mIConfigBase = std::make_shared<ConfigBaseImpl>(fileName);
return (std::shared_ptr<IConfigBase> *)(((char *)impl) + sizeof(IConfigBaseHeader));
}

57
utils/ConfigBase/src/IConfigBase.h Normal file
View File

@ -0,0 +1,57 @@
/*
* Copyright (c) 2023 Fancy Code.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef I_CONFIG_BASE_H
#define I_CONFIG_BASE_H
#include "StatusCode.h"
#include <memory>
class IConfigBase
{
public:
IConfigBase() = default;
virtual ~IConfigBase() = default;
virtual bool OpenConfigFile(void);
virtual void CloseConfigFile(void);
virtual StatusCode ConfigSaveFile(void);
virtual StatusCode ConfigGetInt(const char *name, int *value);
virtual StatusCode ConfigSetInt(const char *name, const int value);
virtual StatusCode ConfigGetShort(const char *name, short *value);
virtual StatusCode ConfigSetShort(const char *name, const short value);
virtual StatusCode ConfigGetLong(const char *name, long *value);
virtual StatusCode ConfigSetLong(const char *name, const long value);
virtual StatusCode ConfigGetLLong(const char *name, long long *value);
virtual StatusCode ConfigSetLLong(const char *name, const long long value);
virtual StatusCode ConfigGetChar(const char *name, char *value);
virtual StatusCode ConfigSetChar(const char *name, const char value);
virtual StatusCode ConfigGetBool(const char *name, bool *value);
virtual StatusCode ConfigSetBool(const char *name, const bool value);
virtual StatusCode ConfigGetFloat(const char *name, float *value);
virtual StatusCode ConfigSetFloat(const char *name, const float value);
virtual StatusCode ConfigGetDouble(const char *name, double *value);
virtual StatusCode ConfigSetDouble(const char *name, const double value);
virtual StatusCode ConfigGetString(const char *name, const char **value);
virtual StatusCode ConfigSetString(const char *name, const char *value);
};
typedef struct i_config_base_header
{
const char *mCheckName;
} IConfigBaseHeader;
typedef struct config_base
{
IConfigBaseHeader mHeader;
std::shared_ptr<IConfigBase> mIConfigBase;
} ConfigBase;
const char *GetConfigBaseModuleName(void);
std::shared_ptr<IConfigBase> *NewConfigBase(const char *fileName);
#endif

68
utils/FxHttpServer/CMakeLists.txt Normal file
View File

@ -0,0 +1,68 @@
include(${CMAKE_SOURCE_DIR_IPCSDK}/build/global_config.cmake)
include(${EXTERNAL_SOURCE_PATH}/goahead-5.2.0/goahead.cmake)
set(EXECUTABLE_OUTPUT_PATH ${EXEC_OUTPUT_PATH})
set(LIBRARY_OUTPUT_PATH ${LIBS_OUTPUT_PATH})
include_directories(
./src
./include
${UTILS_SOURCE_PATH}/StatusCode/include
${UTILS_SOURCE_PATH}/Log/include
${EXTERNAL_SOURCE_PATH}/httpserver.h-master
# ${UTILS_SOURCE_PATH}/LinuxApi/include
)
# link_directories(
# ${EXTERNAL_SOURCE_PATH}/libconfig/libconfig-1.7.3/lib/.libs
# )
include(CheckFunctionExists)
check_function_exists(epoll_wait EPOLL)
check_function_exists(kqueue KQUEUE)
aux_source_directory(./src SRC_FILES)
set(TARGET_NAME FxHttpServer)
add_library(${TARGET_NAME} STATIC ${SRC_FILES})
target_link_libraries(${TARGET_NAME} StatusCode Log -Wl,--start-group httpsrv -Wl,--end-group)
if ("${COMPILE_IMPROVE_SUPPORT}" MATCHES "true")
add_custom_target(
FxHttpServer_code_check
COMMAND ${CLANG_TIDY_EXE}
-checks='${CLANG_TIDY_CHECKS}'
--header-filter=.*
--system-headers=false
${SRC_FILES}
${CLANG_TIDY_CONFIG}
-p ${PLATFORM_PATH}/cmake-shell
WORKING_DIRECTORY ${UTILS_SOURCE_PATH}/FxHttpServer
)
file(GLOB_RECURSE HEADER_FILES *.h)
add_custom_target(
FxHttpServer_code_format
COMMAND ${CLANG_FORMAT_EXE}
-style=file
-i ${SRC_FILES} ${HEADER_FILES}
WORKING_DIRECTORY ${UTILS_SOURCE_PATH}/FxHttpServer
)
add_custom_command(
TARGET ${TARGET_NAME}
PRE_BUILD
COMMAND make FxHttpServer_code_check
COMMAND make FxHttpServer_code_format
WORKING_DIRECTORY ${PLATFORM_PATH}/cmake-shell/
)
endif()
if(KQUEUE)
target_compile_definitions(${TARGET_NAME} PRIVATE KQUEUE)
endif()
if(EPOLL)
target_compile_definitions(${TARGET_NAME} PRIVATE EPOLL)
endif()
define_file_name(${TARGET_NAME})
file(GLOB_RECURSE INSTALL_HEADER_FILES include/*.h)
install(FILES ${INSTALL_HEADER_FILES} DESTINATION include)

62
utils/FxHttpServer/README.md Normal file
View File

@ -0,0 +1,62 @@
# 1. httpserver组件库
&emsp;&emsp; 使用<sdk>/external/httpserver.h-master/src/CMakeLists.txt文件编译的开源库，二次封装接口给到应用层使用。
## 1.1. 注意事项
1. 编译libhttpsrv时，可能会提示 ragel 工具未安装，需要安装 ragel 工具：
```
$ sudo apt install ragel
```
2. 对开源库的CMakeLists.txt文件增加拷贝命令：
```
message("${PLATFORM_PATH}/cmake-shell/external${SUBMODULE_PATH_OF_IPC_SDK}/httpserver.h-master/src/libhttpsrv.a")
add_custom_command(
TARGET httpsrv
POST_BUILD
COMMAND cp ${PLATFORM_PATH}/cmake-shell${SUBMODULE_PATH_OF_IPC_SDK}/external/httpserver.h-master/src/libhttpsrv.a ${EXTERNAL_LIBS_OUTPUT_PATH}
WORKING_DIRECTORY ${PLATFORM_PATH}/cmake-shell/
)
```
3. 取消开源库的CMakeLists.txt文件debug配置，未知会产生什么不良后果；
```
PUBLIC $<$<CONFIG:DEBUG>:-fsanitize=address -fsanitize=undefined -fno-sanitize-recover=all>
```
4. 由于开源代码不支持安全退出，所以修改了开源代码；
```
int gHttpServerRuning = 1; // 增加一个运行标识
int hs_server_run_event_loop(http_server_t *serv, const char *ipaddr) {
hs_server_listen_on_addr(serv, ipaddr);
struct epoll_event ev_list[1];
while (gHttpServerRuning) { // 运行标识赋值为0时，httpserver退出
int nev = epoll_wait(serv->loop, ev_list, 1, -1);
for (int i = 0; i < nev; i++) {
ev_cb_t *ev_cb = (ev_cb_t *)ev_list[i].data.ptr;
ev_cb->handler(&ev_list[i]);
}
}
return 0;
}
```
5. 修复一个内存安全漏洞；
```
void _hs_accept_and_begin_request_cycle(http_server_t *server,
hs_io_cb_t on_client_connection_cb,
hs_io_cb_t on_timer_event_cb) {
http_request_t *request = NULL;
while ((request = hs_server_accept_connection(server, on_client_connection_cb,
on_timer_event_cb))) {
if (server->memused > HTTP_MAX_TOTAL_EST_MEM_USAGE) {
hs_request_respond_error(request, 503, "Service Unavailable",
hs_request_begin_write);
} else {
hs_request_begin_read(request);
}
// ================ added by xiao ================ //
if (request) {
hs_request_terminate_connection(request); // 此处应该释放内存
}
// ================ added by xiao end ================ //
}
}
```
6.

29
utils/FxHttpServer/include/FxHttpServer.h Normal file
View File

@ -0,0 +1,29 @@
/*
* Copyright (c) 2023 Fancy Code.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef FX_HTTP_SERVER_H
#define FX_HTTP_SERVER_H
#include "StatusCode.h"
#ifdef __cplusplus
extern "C" {
#endif
typedef void (*ResponseHandle)(const char *, void *);
typedef void (*HttpHandleCallback)(const char *, const unsigned int, ResponseHandle, void *);
StatusCode FxHttpServerInit(HttpHandleCallback httpHandle, const int port);
StatusCode FxHttpServerExit(void);
StatusCode FxHttpServerUnInit(void);
#ifdef __cplusplus
}
#endif
#endif

69
utils/FxHttpServer/src/FxHttpServer.c Normal file
View File

@ -0,0 +1,69 @@
/*
* Copyright (c) 2023 Fancy Code.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "FxHttpServer.h"
#include "ILog.h"
#include "httpserver.h"
#include <string.h>
extern int gHttpServerRuning;
static struct http_server_s *server = NULL;
static struct http_server_s *poll_server = NULL;
static HttpHandleCallback gHttpHandle = NULL;
static void response_handle(const char *responseStr, void *context)
{
struct http_response_s *response = (struct http_response_s *)context;
if (NULL != responseStr) {
http_response_header(response, "Content-Type", "text/plain");
http_response_body(response, responseStr, strlen(responseStr));
}
}
static void handle_request(struct http_request_s *request)
{
http_request_connection(request, HTTP_AUTOMATIC);
struct http_response_s *response = http_response_init();
http_response_status(response, 200);
http_string_t url = http_request_target(request);
gHttpHandle(url.buf, url.len, response_handle, response);
http_respond(request, response);
}
StatusCode FxHttpServerInit(HttpHandleCallback httpHandle, const int port)
{
// poll_server = http_server_init(port + 1, handle_request);
if (NULL == httpHandle) {
LogError("FxHttpServerInit failed. Callback function is nullptr.\n");
return CreateStatusCode(STATUS_CODE_NOT_OK);
}
server = http_server_init(port, handle_request);
if (!server) {
LogError("http_server_init failed.\n");
return CreateStatusCode(STATUS_CODE_NOT_OK);
}
gHttpHandle = httpHandle;
// http_server_listen_poll(poll_server);
http_server_listen(server);
return CreateStatusCode(STATUS_CODE_OK);
}
StatusCode FxHttpServerExit(void)
{
gHttpServerRuning = 0;
return CreateStatusCode(STATUS_CODE_OK);
}
StatusCode FxHttpServerUnInit(void)
{
free(server);
server = NULL;
free(poll_server);
poll_server = NULL;
return CreateStatusCode(STATUS_CODE_OK);
}

57
utils/KeyControl/CMakeLists.txt Normal file
View File

@ -0,0 +1,57 @@
include(${CMAKE_SOURCE_DIR_IPCSDK}/build/global_config.cmake)
set(EXECUTABLE_OUTPUT_PATH ${EXEC_OUTPUT_PATH})
set(LIBRARY_OUTPUT_PATH ${LIBS_OUTPUT_PATH})
include_directories(
./src
./include
# ${UTILS_SOURCE_PATH}/LinuxApi/include
${UTILS_SOURCE_PATH}/StatusCode/include
${UTILS_SOURCE_PATH}/ModBusCRC16/include
${UTILS_SOURCE_PATH}/Log/include
)
# link_directories(
# ${EXTERNAL_SOURCE_PATH}/libconfig/libconfig-1.7.3/lib/.libs
# )
aux_source_directory(./src SRC_FILES)
set(TARGET_NAME KeyControl)
add_library(${TARGET_NAME} STATIC ${SRC_FILES})
target_link_libraries(${TARGET_NAME} StatusCode Log)
if ("${COMPILE_IMPROVE_SUPPORT}" MATCHES "true")
add_custom_target(
KeyControl_code_check
COMMAND ${CLANG_TIDY_EXE}
-checks='${CLANG_TIDY_CHECKS}'
--header-filter=.*
--system-headers=false
${SRC_FILES}
${CLANG_TIDY_CONFIG}
-p ${PLATFORM_PATH}/cmake-shell
WORKING_DIRECTORY ${UTILS_SOURCE_PATH}/KeyControl
)
file(GLOB_RECURSE HEADER_FILES *.h)
add_custom_target(
KeyControl_code_format
COMMAND ${CLANG_FORMAT_EXE}
-style=file
-i ${SRC_FILES} ${HEADER_FILES}
WORKING_DIRECTORY ${UTILS_SOURCE_PATH}/KeyControl
)
add_custom_command(
TARGET ${TARGET_NAME}
PRE_BUILD
COMMAND make KeyControl_code_check
COMMAND make KeyControl_code_format
WORKING_DIRECTORY ${PLATFORM_PATH}/cmake-shell/
)
endif()
define_file_name(${TARGET_NAME})
file(GLOB_RECURSE INSTALL_HEADER_FILES include/*.h)
install(FILES ${INSTALL_HEADER_FILES} DESTINATION include)

68
utils/KeyControl/include/KeyControl.h Normal file
View File

@ -0,0 +1,68 @@
/*
* Copyright (c) 2023 Fancy Code.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef KEY_CONTROL_H
#define KEY_CONTROL_H
#include <functional>
#include <memory>
#include <mutex>
constexpr int KEY_ACTION_SHORT_CLICK = 100;
constexpr int KEY_ACTION_HOLD_DWON = 500;
constexpr long int KEY_NOT_PRESSING = -1;
enum class KeyHalEvent
{
PRESSING = 0,
NOT_PRESSING,
END
};
enum class KeyEvent
{
SHORT_CLICK = 0,
HOLD_DOWN,
HOLD_UP,
END
};
class VKeyControl
{
public:
VKeyControl() = default;
virtual ~VKeyControl() = default;
virtual const std::string GetKeyName(void);
virtual unsigned int GetStatusCheckPeriodMs(void);
virtual void KeyEventTrigger(const std::string &keyName, const KeyEvent &event, const unsigned int &timeMs);
};
class KeyControl : public VKeyControl, public std::enable_shared_from_this<KeyControl>
{
public:
KeyControl();
virtual ~KeyControl();
virtual void Init(void);
virtual void UnInit(void);
void KeyHalEventHandle(const std::string &key, const KeyHalEvent &keyEvent);
void TimerKeyEventTrigger(const KeyHalEvent &event);
void KeyHalEventTrigger(const KeyHalEvent &event);
long int GetHoldPressingTimeMs(void);
private:
void KeyPressingTrigger(const std::string &key);
void KeyNotPressingTrigger(const std::string &key);
bool IsKeyPressing(void);
private:
std::mutex mMutex;
long int mPressingTime;
long int mLongClickTime;
};
const char *PrintKeyEvent(const KeyEvent &event);
#endif

127
utils/KeyControl/src/KeyControl.cpp Normal file
View File

@ -0,0 +1,127 @@
/*
* Copyright (c) 2023 Fancy Code.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "KeyControl.h"
#include "ILog.h"
constexpr long int KEY_PRESSING = 0;
constexpr unsigned int NOT_A_HOLD_KEY_ACTION = 0;
KeyControl::KeyControl()
{
mPressingTime = KEY_NOT_PRESSING;
mLongClickTime = 0;
}
KeyControl::~KeyControl()
{
}
bool KeyControl::IsKeyPressing(void)
{
return mPressingTime >= KEY_PRESSING ? true : false;
}
const std::string VKeyControl::GetKeyName(void)
{
return "undefine";
}
unsigned int VKeyControl::GetStatusCheckPeriodMs(void)
{
return 0;
}
void VKeyControl::KeyEventTrigger(const std::string &keyName, const KeyEvent &event, const unsigned int &timeMs)
{
}
void KeyControl::Init(void)
{
}
void KeyControl::UnInit(void)
{
}
void KeyControl::KeyHalEventHandle(const std::string &key, const KeyHalEvent &keyEvent)
{
if (KEY_PRESSING <= mPressingTime) {
mPressingTime += GetStatusCheckPeriodMs();
}
switch (keyEvent) {
case KeyHalEvent::PRESSING:
KeyPressingTrigger(key);
break;
case KeyHalEvent::NOT_PRESSING:
KeyNotPressingTrigger(key);
break;
default:
break;
}
}
void KeyControl::TimerKeyEventTrigger(const KeyHalEvent &event)
{
std::lock_guard<std::mutex> locker(mMutex);
if (IsKeyPressing()) {
KeyHalEventHandle(GetKeyName(), event);
}
}
void KeyControl::KeyHalEventTrigger(const KeyHalEvent &event)
{
std::lock_guard<std::mutex> locker(mMutex);
KeyHalEventHandle(GetKeyName(), event);
}
long int KeyControl::GetHoldPressingTimeMs(void)
{
return mPressingTime;
}
void KeyControl::KeyPressingTrigger(const std::string &key)
{
if (mLongClickTime <= mPressingTime) {
/**
* @brief Long press events are not currently supported here. Developers believe that it is better to handle
* long press events at the application level.
*/
}
// LogInfo("KeyPressingTrigger: %s, %d", key.c_str(), mPressingTime);
if (mPressingTime != KEY_NOT_PRESSING && mPressingTime % KEY_ACTION_HOLD_DWON == 0) {
KeyEventTrigger(key, KeyEvent::HOLD_DOWN, mPressingTime);
}
if (KEY_NOT_PRESSING == mPressingTime) {
mPressingTime = KEY_PRESSING;
}
}
void KeyControl::KeyNotPressingTrigger(const std::string &key)
{
if (KEY_ACTION_SHORT_CLICK <= mPressingTime && mPressingTime < KEY_ACTION_HOLD_DWON) {
KeyEventTrigger(key, KeyEvent::SHORT_CLICK, mPressingTime);
}
if (KEY_ACTION_HOLD_DWON <= mPressingTime) {
KeyEventTrigger(key, KeyEvent::HOLD_UP, mPressingTime);
}
mPressingTime = KEY_NOT_PRESSING;
}
const char *PrintKeyEvent(const KeyEvent &event)
{
switch (event) {
case KeyEvent::SHORT_CLICK: {
return "SHORT_CLICK";
break;
}
case KeyEvent::HOLD_DOWN: {
return "HOLD_DOWN";
break;
}
case KeyEvent::HOLD_UP: {
return "HOLD_UP";
break;
}
default:
return "unknown event";
break;
}
}

57
utils/LedControl/CMakeLists.txt Normal file
View File

@ -0,0 +1,57 @@
include(${CMAKE_SOURCE_DIR_IPCSDK}/build/global_config.cmake)
set(EXECUTABLE_OUTPUT_PATH ${EXEC_OUTPUT_PATH})
set(LIBRARY_OUTPUT_PATH ${LIBS_OUTPUT_PATH})
include_directories(
./src
./include
# ${UTILS_SOURCE_PATH}/LinuxApi/include
${UTILS_SOURCE_PATH}/StatusCode/include
${UTILS_SOURCE_PATH}/ModBusCRC16/include
${UTILS_SOURCE_PATH}/Log/include
)
# link_directories(
# ${EXTERNAL_SOURCE_PATH}/libconfig/libconfig-1.7.3/lib/.libs
# )
aux_source_directory(./src SRC_FILES)
set(TARGET_NAME LedControl)
add_library(${TARGET_NAME} STATIC ${SRC_FILES})
target_link_libraries(${TARGET_NAME} StatusCode Log)
if ("${COMPILE_IMPROVE_SUPPORT}" MATCHES "true")
add_custom_target(
LedControl_code_check
COMMAND ${CLANG_TIDY_EXE}
-checks='${CLANG_TIDY_CHECKS}'
--header-filter=.*
--system-headers=false
${SRC_FILES}
${CLANG_TIDY_CONFIG}
-p ${PLATFORM_PATH}/cmake-shell
WORKING_DIRECTORY ${UTILS_SOURCE_PATH}/LedControl
)
file(GLOB_RECURSE HEADER_FILES *.h)
add_custom_target(
LedControl_code_format
COMMAND ${CLANG_FORMAT_EXE}
-style=file
-i ${SRC_FILES} ${HEADER_FILES}
WORKING_DIRECTORY ${UTILS_SOURCE_PATH}/LedControl
)
add_custom_command(
TARGET ${TARGET_NAME}
PRE_BUILD
COMMAND make LedControl_code_check
COMMAND make LedControl_code_format
WORKING_DIRECTORY ${PLATFORM_PATH}/cmake-shell/
)
endif()
define_file_name(${TARGET_NAME})
file(GLOB_RECURSE INSTALL_HEADER_FILES include/*.h)
install(FILES ${INSTALL_HEADER_FILES} DESTINATION include)

94
utils/LedControl/include/LedControl.h Normal file
View File

@ -0,0 +1,94 @@
/*
* Copyright (c) 2023 Fancy Code.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef LED_CONTROL_H
#define LED_CONTROL_H
#include "StatusCode.h"
#include <memory>
#include <vector>
constexpr unsigned int NEW_TOP_LED_STATE = 0;
constexpr unsigned int LED_NOT_BLINK = 0;
constexpr unsigned int BLINKING_FAST_MS = 500;
constexpr unsigned int BLINKING_SLOW_MS = 1000;
constexpr long int KEEP_ALIVE_FOREVER = 0;
constexpr unsigned int DELETED_LED_STATE = -1;
constexpr unsigned int DO_NOT_KEEP_ALIVE = -2;
enum class LedState
{
OFF = 0,
ON,
GREEN,
RED,
BLUE,
YELLOW,
GREEN_RED_MEANS_YELLOW,
GREEN_BLUE_MEANS_CYAN,
RED_BLUE_MEANS_PURPLE,
GREEN_RED_BLUE_MEANS_WHITE,
LEVEL_0,
LEVEL_1,
LEVEL_2,
LEVEL_3,
LEVEL_4,
LEVEL_END,
END
};
class VSingleControl
{
public:
VSingleControl() = default;
virtual ~VSingleControl() = default;
virtual StatusCode GetLedState(LedState &state);
virtual unsigned int GetKeepAliveTimeMs(void);
virtual unsigned int GetBlinkTimeMs(void);
};
class VLedControl
{
public:
VLedControl() = default;
virtual ~VLedControl() = default;
virtual StatusCode SetLedState(const LedState &state);
virtual void AddLedState(std::shared_ptr<VSingleControl> &control);
virtual void CheckState(const unsigned int &period);
virtual std::string GetLedName(void);
virtual void DeleteAllState(void);
};
class LedControl : virtual public VLedControl
{
public:
LedControl() = default;
virtual ~LedControl() = default;
void CheckState(const unsigned int &period) override;
void AddLedState(std::shared_ptr<VSingleControl> &state) override;
private:
void DeleteAllState(void) override;
/**
* @brief Each time you control a light, check for invalid data to avoid wasting memory resources.
*
*/
void DeleteUselessState(void);
void NewLedStateStart(void);
void DeleteTopLedState(void);
void BlinkOff(std::shared_ptr<VSingleControl> &state);
void BlinkOn(std::shared_ptr<VSingleControl> &state, const LedState &onState);
private:
std::vector<std::shared_ptr<VSingleControl>> mStates;
LedState mCurrentState;
unsigned int mStateAliveTime;
unsigned int mBlinkPeriod;
};
const char *PrintLedState(const LedState &state);
#endif

179
utils/LedControl/src/LedControl.cpp Normal file
View File

@ -0,0 +1,179 @@
/*
* Copyright (c) 2023 Fancy Code.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "LedControl.h"
#include "ILog.h"
#include <algorithm>
StatusCode VSingleControl::GetLedState(LedState &state)
{
return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
}
unsigned int VSingleControl::GetKeepAliveTimeMs(void)
{
return KEEP_ALIVE_FOREVER;
}
unsigned int VSingleControl::GetBlinkTimeMs(void)
{
return LED_NOT_BLINK;
}
StatusCode VLedControl::SetLedState(const LedState &state)
{
LogWarning("STATUS_CODE_VIRTUAL_FUNCTION.\n");
return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
}
void VLedControl::AddLedState(std::shared_ptr<VSingleControl> &control)
{
LogWarning("STATUS_CODE_VIRTUAL_FUNCTION.\n");
}
void VLedControl::CheckState(const unsigned int &period)
{
LogWarning("STATUS_CODE_VIRTUAL_FUNCTION.\n");
}
std::string VLedControl::GetLedName(void)
{
LogWarning("STATUS_CODE_VIRTUAL_FUNCTION.\n");
return "undefine";
}
void VLedControl::DeleteAllState(void)
{
LogWarning("STATUS_CODE_VIRTUAL_FUNCTION.\n");
}
void LedControl::AddLedState(std::shared_ptr<VSingleControl> &state)
{
LogInfo("Add led state.\n");
DeleteUselessState();
NewLedStateStart();
LedState ledState = LedState::END;
state->GetLedState(ledState);
SetLedState(ledState);
mCurrentState = ledState;
if (DO_NOT_KEEP_ALIVE == state->GetKeepAliveTimeMs()) {
return;
}
mStates.push_back(state);
}
void LedControl::DeleteAllState(void)
{
mStates.clear();
SetLedState(LedState::OFF);
}
void LedControl::DeleteUselessState(void)
{
constexpr bool DELETE_STATE = true;
constexpr bool KEEP_STATE = false;
auto is_to_remove = [](const std::shared_ptr<VSingleControl> &state) {
if (DELETED_LED_STATE == state->GetKeepAliveTimeMs()) {
LogInfo(" Delete useless led state.\n");
return DELETE_STATE;
}
return KEEP_STATE;
};
mStates.erase(std::remove_if(mStates.begin(), mStates.end(), is_to_remove), mStates.end());
}
void LedControl::CheckState(const unsigned int &period)
{
const int TOP_STATE_SHOW = mStates.size() - 1;
mStateAliveTime += period;
mBlinkPeriod += period;
if (TOP_STATE_SHOW >= 0) {
// LogInfo("TOP_STATE_SHOW = %d.\n", TOP_STATE_SHOW);
std::shared_ptr<VSingleControl> state = mStates[TOP_STATE_SHOW];
LedState ledState = LedState::END;
if (state->GetKeepAliveTimeMs() == DELETED_LED_STATE ||
(state->GetKeepAliveTimeMs() != KEEP_ALIVE_FOREVER && state->GetKeepAliveTimeMs() <= mStateAliveTime)) {
DeleteTopLedState();
return;
}
state->GetLedState(ledState);
if (mCurrentState != ledState && LED_NOT_BLINK == state->GetBlinkTimeMs()) {
SetLedState(ledState);
mCurrentState = ledState;
}
else if (mCurrentState == ledState && state->GetBlinkTimeMs() != LED_NOT_BLINK) {
BlinkOff(state);
}
else if (mCurrentState == LedState::OFF && state->GetBlinkTimeMs() != LED_NOT_BLINK) {
BlinkOn(state, ledState);
}
}
}
void LedControl::NewLedStateStart(void)
{
mCurrentState = LedState::END;
mStateAliveTime = NEW_TOP_LED_STATE;
mBlinkPeriod = 0;
}
void LedControl::DeleteTopLedState(void)
{
const int TOP_STATE_SHOW = mStates.size() - 1;
if (TOP_STATE_SHOW < 0) {
return;
}
LogInfo("Delete led state.\n");
NewLedStateStart();
mStates.erase(mStates.begin() + TOP_STATE_SHOW);
const int NEXT_LED_STATE = mStates.size() - 1;
if (NEXT_LED_STATE < 0) {
SetLedState(LedState::OFF);
return;
}
LogInfo("Top next led state.\n");
std::shared_ptr<VSingleControl> state = mStates[NEXT_LED_STATE];
LedState ledState = LedState::END;
state->GetLedState(ledState);
SetLedState(ledState);
mCurrentState = ledState;
}
void LedControl::BlinkOff(std::shared_ptr<VSingleControl> &state)
{
if (state->GetBlinkTimeMs() < mBlinkPeriod) {
// LogInfo("blink off.\n");
SetLedState(LedState::OFF);
mCurrentState = LedState::OFF;
mBlinkPeriod = 0;
}
}
void LedControl::BlinkOn(std::shared_ptr<VSingleControl> &state, const LedState &onState)
{
if (state->GetBlinkTimeMs() < mBlinkPeriod) {
// LogInfo("blink on.\n");
SetLedState(onState);
mCurrentState = onState;
mBlinkPeriod = 0;
}
}
const char *PrintLedState(const LedState &state)
{
switch (state) {
case LedState::OFF: {
return "OFF";
}
case LedState::ON: {
return "ON";
}
case LedState::GREEN: {
return "GREEN";
}
case LedState::RED: {
return "RED";
}
case LedState::YELLOW: {
return "YELLOW";
}
default: {
return "Unknown LedState";
}
}
}

54
utils/LinuxApi/CMakeLists.txt Normal file
View File

@ -0,0 +1,54 @@
include(${CMAKE_SOURCE_DIR_IPCSDK}/build/global_config.cmake)
set(EXECUTABLE_OUTPUT_PATH ${EXEC_OUTPUT_PATH})
set(LIBRARY_OUTPUT_PATH ${LIBS_OUTPUT_PATH})
include_directories(
./src
./include
${UTILS_SOURCE_PATH}/Log/include
)
# link_directories(
# ${EXTERNAL_SOURCE_PATH}/libconfig/libconfig-1.7.3/lib/.libs
# )
aux_source_directory(./src SRC_FILES)
set(TARGET_NAME LinuxApi)
add_library(${TARGET_NAME} STATIC ${SRC_FILES})
target_link_libraries(${TARGET_NAME} Log)
if ("${COMPILE_IMPROVE_SUPPORT}" MATCHES "true")
add_custom_target(
LinuxApi_code_check
COMMAND ${CLANG_TIDY_EXE}
-checks='${CLANG_TIDY_CHECKS}'
--header-filter=.*
--system-headers=false
${SRC_FILES}
${CLANG_TIDY_CONFIG}
-p ${PLATFORM_PATH}/cmake-shell
WORKING_DIRECTORY ${UTILS_SOURCE_PATH}/LinuxApi
)
file(GLOB_RECURSE HEADER_FILES *.h)
add_custom_target(
LinuxApi_code_format
COMMAND ${CLANG_FORMAT_EXE}
-style=file
-i ${SRC_FILES} ${HEADER_FILES}
WORKING_DIRECTORY ${UTILS_SOURCE_PATH}/LinuxApi
)
add_custom_command(
TARGET ${TARGET_NAME}
PRE_BUILD
COMMAND make LinuxApi_code_check
COMMAND make LinuxApi_code_format
WORKING_DIRECTORY ${PLATFORM_PATH}/cmake-shell/
)
endif()
define_file_name(${TARGET_NAME})
file(GLOB_RECURSE INSTALL_HEADER_FILES include/*.h)
install(FILES ${INSTALL_HEADER_FILES} DESTINATION include)

41
utils/LinuxApi/include/LinuxApi.h Normal file
View File

@ -0,0 +1,41 @@
/*
* Copyright (c) 2023 Fancy Code.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef LINUX_API_H
#define LINUX_API_H
#include <stddef.h>
#include <stdio.h>
#include <sys/select.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/types.h>
#include <termios.h>
#include <unistd.h>
#ifdef __cplusplus
extern "C" {
#endif
int fx_system(const char *command);
int fx_open(const char *pathname, int flags);
int fx_tcgetattr(int fd, struct termios *termios_p);
int fx_tcsetattr(int fd, int optional_actions, const struct termios *termios_p);
ssize_t fx_write(int fd, const void *buf, size_t count);
ssize_t fx_read(int fd, void *buf, size_t count);
int fx_select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);
int fx_fstat(int fd, struct stat *statbuf);
int fx_access(const char *pathname, int mode);
FILE *fx_fopen(const char *pathname, const char *mode);
#ifdef __cplusplus
}
#endif
#endif

64
utils/LinuxApi/src/LinuxApi.c Normal file
View File

@ -0,0 +1,64 @@
/*
* Copyright (c) 2023 Fancy Code.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "LinuxApi.h"
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <termios.h>
#include <unistd.h>
int fx_system(const char *command)
{
return system(command);
}
int fx_open(const char *pathname, int flags)
{
return open(pathname, flags);
}
int fx_tcgetattr(int fd, struct termios *termios_p)
{
return tcgetattr(fd, termios_p);
}
int fx_tcsetattr(int fd, int optional_actions, const struct termios *termios_p)
{
return tcsetattr(fd, optional_actions, termios_p);
}
ssize_t fx_write(int fd, const void *buf, size_t count)
{
return write(fd, buf, count);
}
ssize_t fx_read(int fd, void *buf, size_t count)
{
return read(fd, buf, count);
}
int fx_select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout)
{
return select(nfds, readfds, writefds, exceptfds, timeout);
}
int fx_fstat(int fd, struct stat *statbuf)
{
return fstat(fd, statbuf);
}
int fx_access(const char *pathname, int mode)
{
return access(pathname, mode);
}
FILE *fx_fopen(const char *pathname, const char *mode)
{
return fopen(pathname, mode);
}

52
utils/Log/CMakeLists.txt Normal file
View File

@ -0,0 +1,52 @@
include(${CMAKE_SOURCE_DIR_IPCSDK}/build/global_config.cmake)
set(EXECUTABLE_OUTPUT_PATH ${EXEC_OUTPUT_PATH})
set(LIBRARY_OUTPUT_PATH ${LIBS_OUTPUT_PATH})
include_directories(
./abstract
./src
./src/easyloggingpp
./include
)
#do not rely on any other library
# link_directories(
# ${EXTERNAL_SOURCE_PATH}/curl/curl-8.1.2/build/lib
# )
aux_source_directory(./abstract ABSTRACT_SRC_FILES)
aux_source_directory(./src IMPL_SRC_FILES)
aux_source_directory(./src/easyloggingpp EASYLOGGING_SRC_FILES)
set(ABSTRACT_TARGET LogAbstract)
set(IMPL_TARGET Log)
add_library(${ABSTRACT_TARGET} STATIC ${ABSTRACT_SRC_FILES})
# target_link_libraries(${ABSTRACT_TARGET} Log)
add_library(${IMPL_TARGET} STATIC ${IMPL_SRC_FILES} ${EASYLOGGING_SRC_FILES})
target_link_libraries(${IMPL_TARGET} ${ABSTRACT_TARGET})
if ("${COMPILE_IMPROVE_SUPPORT}" MATCHES "true")
add_custom_target(
Log_code_check
COMMAND ${CLANG_TIDY_EXE}
-checks='${CLANG_TIDY_CHECKS}'
--header-filter=.*
--system-headers=false
${IMPL_SRC_FILES}
${ABSTRACT_SRC_FILES}
${CLANG_TIDY_CONFIG}
-p ${PLATFORM_PATH}/cmake-shell
WORKING_DIRECTORY ${UTILS_SOURCE_PATH}/Log
)
add_custom_command(
TARGET ${IMPL_TARGET}
PRE_BUILD
COMMAND make Log_code_check
WORKING_DIRECTORY ${PLATFORM_PATH}/cmake-shell/
)
endif()
file(GLOB_RECURSE INSTALL_HEADER_FILES include/*.h)
install(FILES ${INSTALL_HEADER_FILES} DESTINATION include)

57
utils/Log/README.md Normal file
View File

@ -0,0 +1,57 @@
# 1. 日志库
&emsp;&emsp;日志库主要辅助调试和测试。
## 1.1. 基本需求：
1. 日志类型：info / error / warning / trace ；需要打印出运行时间，文件名和行号；
2. 不同日志类型显示不同的颜色；
3. 通过预编译选择开启 / 关闭；
4. 通过多态动态加载 / 卸载；
5. 通过预编译加载 / 卸载某个模块的日志；
## 1.2. 接口描述
1. 开启日志保存功能，把运行日志保存到制定目录；
2. 开启日志保存功能，只保存error和trace的日志；
接口示例：
```
示例代码
```
## 1.3. 参考
* CMakeLists.txt脚本代码：
//build/global_config.cmake
```
// 文件名宏定义__F_FILE__，指定文件实现打印文件名 + 行号功能
// 不使用系统宏__FILE__是因为系统宏会打印绝对路径，日志阅读性差
function(define_file_name target)
get_target_property(source_files "${target}" SOURCES)
foreach(source_file ${source_files})
get_property(defs SOURCE "${source_file}"
PROPERTY COMPILE_DEFINITIONS)
get_filename_component(file_name "${source_file}" NAME)
list(APPEND defs "__F_FILE__=/"${file_name}/"")
set_property(
SOURCE "${source_file}"
PROPERTY COMPILE_DEFINITIONS ${defs})
endforeach()
endfunction()
// LOG_DISABLE日志使能宏，指定文件开启 / 关闭日志功能
function(log_disable target)
get_target_property(source_files "${target}" SOURCES)
foreach(source_file ${source_files})
get_property(defs SOURCE "${source_file}"
PROPERTY COMPILE_DEFINITIONS)
get_filename_component(file_name "${source_file}" NAME)
list(APPEND defs "LOG_DISABLE")
set_property(
SOURCE "${source_file}"
PROPERTY COMPILE_DEFINITIONS ${defs})
endforeach()
endfunction()
```

59
utils/Log/abstract/ILog.cpp Normal file
View File

@ -0,0 +1,59 @@
/*
* Copyright (c) 2023 Fancy Code.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "ILog.h"
#include "ILogCpp.h"
#include <string.h>
static void ILogInitCallBack(ILog *object, const enum LogInstance log)
{
return ILogCpp::GetInstance()->Init(log);
}
static void ILogFree(ILog *object)
{
}
static int ILogPrintf(ILog *object, const char *function, const int line, const enum LogType type, const char *format,
...)
{
return 0;
}
static void ILogUnInitCallBack(ILog *object)
{
return ILogCpp::GetInstance()->UnInit();
}
static ILog default_log = {
.init = ILogInitCallBack,
.free = ILogFree,
.printf = ILogPrintf,
.un_init = ILogUnInitCallBack,
};
static ILog *log_instance = &default_log;
ILog *GetLogIntance(void)
{
return log_instance;
}
void NewILog(ILog **object)
{
if (!object || !(*object)) {
return;
}
memcpy(*object, &default_log, sizeof(ILog));
return;
}
void ResetLogImpl(ILog *impl)
{
if (log_instance) {
log_instance->free(log_instance);
}
log_instance = impl;
}

46
utils/Log/abstract/ILogCpp.cpp Normal file
View File

@ -0,0 +1,46 @@
/*
* Copyright (c) 2023 Fancy Code.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "ILogCpp.h"
#include <memory>
std::shared_ptr<ILogCpp> &ILogCpp::GetInstance(std::shared_ptr<ILogCpp> *impl)
{
static std::shared_ptr<ILogCpp> instance = std::make_shared<ILogCpp>();
static bool instanceChanging = false;
if (impl && false == instanceChanging)
{
// Don't use std::mutex for runing faster.
// Sleep for difference thread to release instance.
instanceChanging = true;
// std::this_thread::sleep_for(std::chrono::milliseconds(100)); // Don't sleep and make sure that start fast.
if (instance.use_count() == 1) // bug?
{
// LogInfo("Instance change succeed.\n");
// instance->UnInit();
// (*impl)->Init();
instance = *impl;
}
else
{
// LogError("[ error ] instance change failed, using by some one.\n");
}
instanceChanging = false;
}
if (instanceChanging)
{
static std::shared_ptr<ILogCpp> tmporaryInstance = std::make_shared<ILogCpp>();
return tmporaryInstance;
}
return instance;
}

96
utils/Log/include/ILog.h Normal file
View File

@ -0,0 +1,96 @@
/*
* Copyright (c) 2023 Fancy Code.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ILOG_H
#define ILOG_H
#ifdef __cplusplus
extern "C"
{
#endif
enum LogType
{
LOG_TYPE_VERBOSE = 0,
LOG_TYPE_DEBUG,
LOG_TYPE_INFORMATION,
LOG_TYPE_WARNING,
LOG_TYPE_ERROR,
LOG_TYPE_TRACE,
LOG_TYPE_TEST_TIPS,
LOG_TYPE_END
};
typedef struct LogSetting
{
const char *fileName; // File name of saving log.
const char *maxSize; // Max size of saving log.
} LogSetting;
enum LogInstance
{
LOG_SERIAL_PRINT = 0, // for serial print.
LOG_EASYLOGGING, // for easylogging++.
LOG_INSTANCE_TYPE_END
};
#ifndef __F_FILE__
#define __F_FILE__ "fancy"
#endif
#ifndef LOG_DISABLE
#define LogVerbose(...) GetLogIntance()->printf(GetLogIntance(), __F_FILE__, __LINE__, LOG_TYPE_VERBOSE, __VA_ARGS__)
#define LogDebug(...) GetLogIntance()->printf(GetLogIntance(), __F_FILE__, __LINE__, LOG_TYPE_DEBUG, __VA_ARGS__)
#define LogInfo(...) GetLogIntance()->printf(GetLogIntance(), __F_FILE__, __LINE__, LOG_TYPE_INFORMATION, __VA_ARGS__)
#define LogWarning(...) GetLogIntance()->printf(GetLogIntance(), __F_FILE__, __LINE__, LOG_TYPE_WARNING, __VA_ARGS__)
#define LogError(...) GetLogIntance()->printf(GetLogIntance(), __F_FILE__, __LINE__, LOG_TYPE_ERROR, __VA_ARGS__)
#define LogTrace(...) GetLogIntance()->printf(GetLogIntance(), __F_FILE__, __LINE__, LOG_TYPE_TRACE, __VA_ARGS__)
#else
#define LogVerbose(...)
#define LogDebug(...)
#define LogInfo(...)
#define LogWarning(...)
#define LogError(...)
#define LogTrace(...)
#endif
#if 1 // For OpenHarmony log, should delete finally.// TODO:
#define LOGD(...)
#define LOGI(...)
#define LOGW(...)
#define LOGE(...)
#define LOGF(...)
#endif
typedef struct i_log ILog;
typedef struct i_log
{
void (*init)(ILog *, const enum LogInstance);
void (*free)(ILog *);
int (*printf)(ILog *, const char *, const int, const enum LogType, const char *, ...);
void (*un_init)(ILog *);
} ILog;
ILog *GetLogIntance(void);
void NewILog(ILog **object);
void ResetLogImpl(ILog *impl);
static inline void ILogInit(const enum LogInstance log)
{
return GetLogIntance()->init(GetLogIntance(), log);
}
static inline void ILogUnInit(void)
{
return GetLogIntance()->un_init(GetLogIntance());
}
static inline void ILogFree(void)
{
GetLogIntance()->free(GetLogIntance());
}
void CreateLogModule(void);
void DestroyLogModule(void);
#ifdef __cplusplus
}
#endif
#endif

34
utils/Log/include/ILogCpp.h Normal file
View File

@ -0,0 +1,34 @@
/*
* Copyright (c) 2023 Fancy Code.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ILOGCPP_H
#define ILOGCPP_H
#include "ILog.h"
#include <memory>
class ILogCpp
{
public:
ILogCpp() = default;
virtual ~ILogCpp() = default;
static std::shared_ptr<ILogCpp> &GetInstance(std::shared_ptr<ILogCpp> *impl = nullptr);
virtual void Init(const enum LogInstance &log) {}
virtual void UnInit(void) {}
virtual int Log(const char *buff) { return 0; }
virtual int InFo(const char *buff) { return 0; }
virtual int Warning(const char *buff) { return 0; }
virtual int Error(const char *buff) { return 0; }
virtual int Trace(const char *buff) { return 0; }
virtual int Debug(const char *buff) { return 0; }
};
#endif

47
utils/Log/src/ILogMakePtr.cpp Normal file
View File

@ -0,0 +1,47 @@
/*
* Copyright (c) 2023 Fancy Code.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "ILogMakePtr.h"
#include "ILog.h"
#include "ILogCpp.h"
#include "LogEasylogging.h"
#include "LogImpl.h"
#include "Log.h"
#include <memory>
void CreateLogModule(void)
{
std::shared_ptr<ILogCpp> logImpl = ILogMakePtr::GetInstance()->MakeLogEasylogging(nullptr);
ILogCpp::GetInstance(&logImpl);
ILog *log = nullptr;
ILogMakePtr::GetInstance()->CreateLogPtr(&log);
ResetLogImpl((ILog *)log);
}
void DestroyLogModule(void)
{
ILogFree();
}
std::shared_ptr<ILogCpp> ILogMakePtr::MakeLogImplPtr(void)
{
std::shared_ptr<ILogCpp> logImpl = std::make_shared<LogImpl>();
return logImpl;
}
std::shared_ptr<ILogCpp> ILogMakePtr::MakeLogEasylogging(const LogSetting *setting)
{
std::shared_ptr<ILogCpp> logImpl = std::make_shared<LogEasylogging>(setting);
return logImpl;
}
void ILogMakePtr::CreateLogPtr(ILog **log)
{
NewLog((Log **)log);
}

39
utils/Log/src/ILogMakePtr.h Normal file
View File

@ -0,0 +1,39 @@
/*
* Copyright (c) 2023 Fancy Code.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ILOG_MAKE_PTR_H
#define ILOG_MAKE_PTR_H
#include "ILogCpp.h"
#include "ILog.h"
#include <iostream>
#include <memory>
class ILogMakePtr
{
public:
static std::shared_ptr<ILogMakePtr> &GetInstance(std::shared_ptr<ILogMakePtr> *impl = nullptr)
{
static std::shared_ptr<ILogMakePtr> instance = std::make_shared<ILogMakePtr>();
if (impl)
{
instance = *impl;
}
return instance;
}
ILogMakePtr() = default;
virtual ~ILogMakePtr() = default;
virtual std::shared_ptr<ILogCpp> MakeLogImplPtr(void);
virtual std::shared_ptr<ILogCpp> MakeLogEasylogging(const LogSetting *setting);
virtual void CreateLogPtr(ILog **log);
};
#endif

101
utils/Log/src/Log.cpp Normal file
View File

@ -0,0 +1,101 @@
/*
* Copyright (c) 2023 Fancy Code.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "Log.h"
#include "ILogCpp.h"
#include <stdarg.h>
#include <stdio.h>
#include <iostream>
#include <memory>
#include <string.h>
static void LogFree(ILog *object)
{
printf("log instance free.\n");
if (object)
{
free(object);
}
}
static int LogPrintf(ILog *object, const char *function, const int line, const enum LogType type, const char *format, ...)
{
// TODO:
// LogTypeToString(type);
constexpr int SEND_TRACE_BUFF_SIZE = 2048;
char buff[SEND_TRACE_BUFF_SIZE] = {0};
snprintf(buff, SEND_TRACE_BUFF_SIZE, "[%s:%d]:", function, line);
// ILog::GetInstance()->Log(buff);
const int headLen = strlen(buff);
va_list vargs;
va_start(vargs, format);
int len = vsnprintf(buff + headLen, SEND_TRACE_BUFF_SIZE - headLen, format, vargs);
va_end(vargs);
switch (type)
{
case LOG_TYPE_INFORMATION:
ILogCpp::GetInstance()->InFo(buff);
break;
case LOG_TYPE_WARNING:
ILogCpp::GetInstance()->Warning(buff);
break;
case LOG_TYPE_ERROR:
ILogCpp::GetInstance()->Error(buff);
break;
case LOG_TYPE_DEBUG:
ILogCpp::GetInstance()->Debug(buff);
break;
case LOG_TYPE_TRACE:
ILogCpp::GetInstance()->Trace(buff);
break;
default:
break;
}
return len;
}
static void LogImplInit(Log *log)
{
printf("LogImplInit\n");
((ILog *)log)->printf = LogPrintf;
((ILog *)log)->free = LogFree;
}
void NewLog(Log **log)
{
if (!log)
{
printf("STATUS_CODE_INVALID_PARAMENTER\n");
return;
}
if (!(*log))
{
*log = (Log *)malloc(sizeof(Log));
if (*log)
{
printf("NewLog succeed.\n");
NewILog((ILog **)log);
LogImplInit(*log);
return;
}
LogError("NewLog failed.\n");
return;
}
// else
{
LogImplInit(*log);
return;
}
}

31
utils/Log/src/Log.h Normal file
View File

@ -0,0 +1,31 @@
/*
* Copyright (c) 2023 Fancy Code.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef LOG_H
# define LOG_H
#include "ILog.h"
#ifdef __cplusplus
extern "C"
{
#endif
typedef struct log Log;
typedef struct log
{
ILog base;
} Log;
void NewLog(Log **log);
#ifdef __cplusplus
}
#endif
#endif

102
utils/Log/src/LogEasylogging.cpp Normal file
View File

@ -0,0 +1,102 @@
/*
* Copyright (c) 2023 Fancy Code.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "ILog.h"
#include "LogEasylogging.h"
#include "easylogging++.h"
// #include <thread>
// #define ELPP_UNICODE // Define for easylogging
INITIALIZE_EASYLOGGINGPP // Init easylogging
// static bool initFlag = false; // Only used for init easyloggingpp
bool test = false;
LogEasylogging::LogEasylogging(const LogSetting *setting)
{
if (!setting)
{
return;
}
if (setting->fileName)
{
mFileName = setting->fileName;
}
if (setting->maxSize)
{
mMaxSize = setting->maxSize;
}
}
void LogEasylogging::Init(const enum LogInstance &log)
{
#if 0
el::Configurations conf("/home/xiaojiazhu/project/OS/OSThings/test/output_files/bin/default-logger.conf");
el::Loggers::reconfigureAllLoggers(conf);
#endif
// Set the log path.
if (mFileName.size() > 0)
{
el::Loggers::reconfigureAllLoggers(el::ConfigurationType::Filename, mFileName.c_str());
}
// Set the max size of log file.
// el::Loggers::reconfigureAllLoggers(el::ConfigurationType::MaxLogFileSize, "1048576");
if (mMaxSize.size() > 0)
{
el::Loggers::reconfigureAllLoggers(el::ConfigurationType::MaxLogFileSize, mMaxSize.c_str());
}
el::Loggers::reconfigureAllLoggers(el::ConfigurationType::Enabled, "true");
el::Loggers::reconfigureAllLoggers(el::ConfigurationType::ToFile, "true");
}
void LogEasylogging::UnInit(void)
{
el::Loggers::reconfigureAllLoggers(el::ConfigurationType::ToFile, "false");
el::Loggers::reconfigureAllLoggers(el::ConfigurationType::Enabled, "false");
}
// bool LogEasylogging::IsWorking()
// {
// return true;
// }
int LogEasylogging::Log(const char *buff)
{
// LOG(INFO) << buff;
return 0;
}
int LogEasylogging::InFo(const char *buff)
{
LOG(INFO) << buff;
return 0;
}
int LogEasylogging::Warning(const char *buff)
{
LOG(WARNING) << buff;
return 0;
}
int LogEasylogging::Error(const char *buff)
{
LOG(ERROR) << buff;
return 0;
}
int LogEasylogging::Debug(const char *buff)
{
LOG(DEBUG) << buff;
return 0;
}
int LogEasylogging::Trace(const char *buff)
{
LOG(TRACE) << buff;
return 0;
}

38
utils/Log/src/LogEasylogging.h Normal file
View File

@ -0,0 +1,38 @@
/*
* Copyright (c) 2023 Fancy Code.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef LOG_EASYLOGGING_H
#define LOG_EASYLOGGING_H
#include "ILogCpp.h"
#include <iostream>
class LogEasylogging : public ILogCpp
{
public:
LogEasylogging(const LogSetting *setting);
virtual ~LogEasylogging() = default;
void Init(const enum LogInstance &log) override;
void UnInit(void) override;
// bool IsWorking(); // override;
int Log(const char *buff); // override;
int InFo(const char *buff); // override;
int Warning(const char *buff); // override;
int Error(const char *buff); // override;
int Trace(const char *buff); // override;
int Debug(const char *buff); // override;
private:
std::string mFileName; // File name of saving log.
std::string mMaxSize; // Max size of saving log.
};
#endif

19
utils/Log/src/LogImpl.cpp Normal file
View File

@ -0,0 +1,19 @@
/*
* Copyright (c) 2023 Fancy Code.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
// #include "LogImpl.h"
// int LogImpl::Log(const char *buff)
// {
// return printf("%s", buff);
// }

24
utils/Log/src/LogImpl.h Normal file
View File

@ -0,0 +1,24 @@
/*
* Copyright (c) 2023 Fancy Code.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef LOG_IMPL_H
#define LOG_IMPL_H
#include "ILogCpp.h"
class LogImpl : public ILogCpp
{
public:
LogImpl() = default;
virtual ~LogImpl() = default;
};
#endif

9
utils/Log/src/easyloggingpp/README.txt Normal file
View File

@ -0,0 +1,9 @@
这是一个开源库的源码。
注意：
//1. 需要定义宏
//#define ELPP_UNICODE // Define for easylogging
2. 初始化
INITIALIZE_EASYLOGGINGPP // Init easylogging
//3. 支持多线程，在源码头文件"easyloggingpp.h"定义宏
//#define ELPP_THREAD_SAFE // Working in threads. Added by xiaojiazhu
4. ELPP_NO_DEFAULT_LOG_FILE 此宏屏蔽生成默认的log文件

25
utils/Log/src/easyloggingpp/default-logger.conf Normal file
View File

@ -0,0 +1,25 @@
* GLOBAL:
FORMAT = "%datetime | %level | %logger | %msg"
FILENAME = "/tmp/logs/myeasylog-configuration.cpp.log"
ENABLED = true
TO_FILE = true
TO_STANDARD_OUTPUT = true
SUBSECOND_PRECISION = 3
PERFORMANCE_TRACKING = false
MAX_LOG_FILE_SIZE = 2097152 ## Throw log files away after 2MB
* DEBUG:
FILENAME = "/tmp/logs/myeasylog-configuration.cpp-debug.log"
TO_STANDARD_OUTPUT = true
ENABLED = true ## We will set it to false after development completed
* WARNING:
FILENAME = "/tmp/logs/filename-with-time-%datetime{%H:%m}"
* TRACE:
TO_FILE = true ## Unnecessary configuration cuz its already true in GLOBAL but doing it anyway!
* VERBOSE:
FORMAT = "%datetime{%d/%M/%y} | %level-%vlevel | %msg"
## Error logs
* ERROR:
ENABLED = false
FILENAME = "/tmp/logs/myeasylog-configuration.cpp-error.log"
* FATAL:
ENABLED = false

3122
utils/Log/src/easyloggingpp/easylogging++.cc Normal file
View File

File diff suppressed because it is too large Load Diff

4580
utils/Log/src/easyloggingpp/easylogging++.h Normal file
View File

File diff suppressed because it is too large Load Diff

57
utils/McuProtocol/CMakeLists.txt Normal file
View File

@ -0,0 +1,57 @@
include(${CMAKE_SOURCE_DIR_IPCSDK}/build/global_config.cmake)
set(EXECUTABLE_OUTPUT_PATH ${EXEC_OUTPUT_PATH})
set(LIBRARY_OUTPUT_PATH ${LIBS_OUTPUT_PATH})
include_directories(
./src
./include
# ${UTILS_SOURCE_PATH}/LinuxApi/include
${UTILS_SOURCE_PATH}/StatusCode/include
${UTILS_SOURCE_PATH}/ModBusCRC16/include
${UTILS_SOURCE_PATH}/Log/include
)
# link_directories(
# ${EXTERNAL_SOURCE_PATH}/libconfig/libconfig-1.7.3/lib/.libs
# )
aux_source_directory(./src SRC_FILES)
set(TARGET_NAME McuProtocol)
add_library(${TARGET_NAME} STATIC ${SRC_FILES})
target_link_libraries(${TARGET_NAME} ModBusCRC16 StatusCode Log)
if ("${COMPILE_IMPROVE_SUPPORT}" MATCHES "true")
add_custom_target(
McuProtocol_code_check
COMMAND ${CLANG_TIDY_EXE}
-checks='${CLANG_TIDY_CHECKS}'
--header-filter=.*
--system-headers=false
${SRC_FILES}
${CLANG_TIDY_CONFIG}
-p ${PLATFORM_PATH}/cmake-shell
WORKING_DIRECTORY ${UTILS_SOURCE_PATH}/McuProtocol
)
file(GLOB_RECURSE HEADER_FILES *.h)
add_custom_target(
McuProtocol_code_format
COMMAND ${CLANG_FORMAT_EXE}
-style=file
-i ${SRC_FILES} ${HEADER_FILES}
WORKING_DIRECTORY ${UTILS_SOURCE_PATH}/McuProtocol
)
add_custom_command(
TARGET ${TARGET_NAME}
PRE_BUILD
COMMAND make McuProtocol_code_check
COMMAND make McuProtocol_code_format
WORKING_DIRECTORY ${PLATFORM_PATH}/cmake-shell/
)
endif()
define_file_name(${TARGET_NAME})
file(GLOB_RECURSE INSTALL_HEADER_FILES include/*.h)
install(FILES ${INSTALL_HEADER_FILES} DESTINATION include)

170
utils/McuProtocol/README.md Normal file
View File

@ -0,0 +1,170 @@
# 1. MCU协议模块
&emsp;&emsp;负责对MCU协议进行封包/解包，负责协议的多态替换。协议数据统一使用网络字节序（大端字节序）。
**注：协议数据统一使用网络字节序（大端字节序）**
| 版本 | 时间 | 说明 |
| ---- | ---- | ---- |
| V1.0 | 2024-5-14 | 首次评审。 |
| V1.1 | 2024-5-16 | 补充数据同步协议。 |
## 1.1. 协议格式
| 协议头 | 流水号 | 命令字 | 长度 | 数据段 | 校验码 |
|----|----|----|----|----|----|
| 2字节<br>0xFAC1 | 4字节 | 2字节 | 2字节<br>协议包总长度 | - | 2字节 |
**流水号**
&emsp;&emsp;流水号用于强绑定问答型协议的发送数据和回复数据,回复者原数据回传即可。例如：
```
unsigned char ASK_IPC_MISSION[] = {0xFA, 0xC1, 0x00, 0x00, 0x00, 0x01, 0x81, 0x01, 0x00, 0x0C, 0x71, 0x88};
unsigned char REPLY_IPC_MISSION[] = {0xFA, 0xC1, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x00, 0x0D, 0x01, 0xAA, 0x89};
```
&emsp;&emsp;流水号管理发送方和接收方互相独立，各自往外发的协议中流水号存在重复的可能，接收方直接复制回传即可。
&emsp;&emsp;流水号必须大于等于1，0用于代码初始化值，代码意义上表示无效的流水号。
**协议收发匹配逻辑**
&emsp;&emsp;协议发送时，附带自管理的流水号，对端回复时，根据流水号绑定发送的协议，为了避免对端回复时，流水号错误导致的业务逻辑错乱，本端除了匹配流水号，还需要根据协议匹配回复的命令字，保证回复内容的有效匹配。如果流水号和命令字无法同时匹配，该回复的数据包被丢弃。
**校验码算法**
&emsp;&emsp;校验码算法使用ModBus CRC16方法计算。
**参考代码(查表法)**
```
/* Table of CRC values for high–order byte */
unsigned char chCRCHi[] ={
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1,
0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1,
0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40,
0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1,
0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40,
0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40,
0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1,
0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
0x80, 0x41, 0x00, 0xC1, 0x81, 0x40
};
/* Table of CRC values for low–order byte */
unsigned char chCRCLo[] ={
0x00, 0xC0, 0xC1, 0x01, 0xC3, 0x03, 0x02, 0xC2, 0xC6, 0x06,
0x07, 0xC7, 0x05, 0xC5, 0xC4, 0x04, 0xCC, 0x0C, 0x0D, 0xCD,
0x0F, 0xCF, 0xCE, 0x0E, 0x0A, 0xCA, 0xCB, 0x0B, 0xC9, 0x09,
0x08, 0xC8, 0xD8, 0x18, 0x19, 0xD9, 0x1B, 0xDB, 0xDA, 0x1A,
0x1E, 0xDE, 0xDF, 0x1F, 0xDD, 0x1D, 0x1C, 0xDC, 0x14, 0xD4,
0xD5, 0x15, 0xD7, 0x17, 0x16, 0xD6, 0xD2, 0x12, 0x13, 0xD3,
0x11, 0xD1, 0xD0, 0x10, 0xF0, 0x30, 0x31, 0xF1, 0x33, 0xF3,
0xF2, 0x32, 0x36, 0xF6, 0xF7, 0x37, 0xF5, 0x35, 0x34, 0xF4,
0x3C, 0xFC, 0xFD, 0x3D, 0xFF, 0x3F, 0x3E, 0xFE, 0xFA, 0x3A,
0x3B, 0xFB, 0x39, 0xF9, 0xF8, 0x38, 0x28, 0xE8, 0xE9, 0x29,
0xEB, 0x2B, 0x2A, 0xEA, 0xEE, 0x2E, 0x2F, 0xEF, 0x2D, 0xED,
0xEC, 0x2C, 0xE4, 0x24, 0x25, 0xE5, 0x27, 0xE7, 0xE6, 0x26,
0x22, 0xE2, 0xE3, 0x23, 0xE1, 0x21, 0x20, 0xE0, 0xA0, 0x60,
0x61, 0xA1, 0x63, 0xA3, 0xA2, 0x62, 0x66, 0xA6, 0xA7, 0x67,
0xA5, 0x65, 0x64, 0xA4, 0x6C, 0xAC, 0xAD, 0x6D, 0xAF, 0x6F,
0x6E, 0xAE, 0xAA, 0x6A, 0x6B, 0xAB, 0x69, 0xA9, 0xA8, 0x68,
0x78, 0xB8, 0xB9, 0x79, 0xBB, 0x7B, 0x7A, 0xBA, 0xBE, 0x7E,
0x7F, 0xBF, 0x7D, 0xBD, 0xBC, 0x7C, 0xB4, 0x74, 0x75, 0xB5,
0x77, 0xB7, 0xB6, 0x76, 0x72, 0xB2, 0xB3, 0x73, 0xB1, 0x71,
0x70, 0xB0, 0x50, 0x90, 0x91, 0x51, 0x93, 0x53, 0x52, 0x92,
0x96, 0x56, 0x57, 0x97, 0x55, 0x95, 0x94, 0x54, 0x9C, 0x5C,
0x5D, 0x9D, 0x5F, 0x9F, 0x9E, 0x5E, 0x5A, 0x9A, 0x9B, 0x5B,
0x99, 0x59, 0x58, 0x98, 0x88, 0x48, 0x49, 0x89, 0x4B, 0x8B,
0x8A, 0x4A, 0x4E, 0x8E, 0x8F, 0x4F, 0x8D, 0x4D, 0x4C, 0x8C,
0x44, 0x84, 0x85, 0x45, 0x87, 0x47, 0x46, 0x86, 0x82, 0x42,
0x43, 0x83, 0x41, 0x81, 0x80, 0x40
};
/**
* @brief 计算校验和
*
* @param pData 数据指针
* @param length 数据长度
* @return unsigned short
*/
unsigned short calculate_check_sum(const unsigned char* pData, unsigned short length)
{
unsigned char CRCHi = 0xFF;
unsigned char CRCLo = 0xFF;
int uIndex;
while (length--)
{
uIndex = CRCHi ^ *pData++;
CRCHi = CRCLo ^ chCRCHi[uIndex];
CRCLo = chCRCLo[uIndex];
}
return (CRCHi << 8 | CRCLo);
}
```
## 1.2. 协议内容
**基本描述**
1. 大于等于0x8000的命令字由CPU发给MCU;
2. 小于0x8000的命令字由MCU发给CPU;
3. 大于0x0801而小于0xC101的命令由CPU主动发送给MCU，大于等于0xC101的命令由CPU回复发送给MCU；
4. 问答型协议只有按位最高位相反，其它位相等，例如：0x8101与0x0101是一问一答的协议；
| 命令字 | CPU | MCU | 数据段 | 协议解析 | 备注 |
| ---- | ---- | ---- | ---- | ---- | ---- |
| 0x8101 | ask | - | - | 获取启动模式 | - |
| 0x0101 | - | reply | Data[0]:启动模式<br>0x01:PIR启动 <br>0x02:TEST启动 <br>0x03:ON启动 <br>0x04:连拍启动 <br>0x05:PIR延时启动 <br>0x06:定时（间隔一定时间）启动 <br>0x07:关机 <br>0x08:低电关机 <br>0x09:异常启动 | 回复启动模式 | 异常启动数据：Data[1]<br>0x00:喂狗异常启动<br>0x01:超时异常启动 |
| 0x8102 | ask | - | - | 断电关机 | 断电关机不用回复 |
| 0x8103 | ask | - | - | 喂狗 | 喂狗不用回复 |
| 0x8104 | ask | - | Data[2]：两字节的数字，单位s | 设置喂狗周期 | 0s代表关闭喂狗 修改为两个字节，单位s |
| 0x0104 | - | reply | Data[0]:结果<br>0x01:成功<br>0x02:失败 | 设置喂狗周期回复 | - |
| 0x8105 | ask | - | - | 关闭狗 | 取消 |
| 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>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灵敏度回复 | - |
| 0x8109 | ask | - | Data[0]：连拍间隔，单位s | 设置连拍启动 | 设置连拍启动后会立即关机，一般连拍间隔较大时使用该功能，连拍间隔较小时Linux单次完成连拍。 |
| 0x0109 | - | reply | Data[0]:结果<br>0x01:成功<br>0x02:失败 | 设置连拍启动回复 | - |
| 0x810A | ask | - | Data[0]:控制模式<br>0-关闭红外灯<br>1-开启红外灯 | 红外灯控制 | 取消 |
| 0x010A | - | reply | Data[0]:结果<br>0x01:成功<br>0x02:失败 | 红外灯控制回复 | 取消 |
| 0x810B | ask | - | - | 获取光敏值 | 取消 |
| 0x010B | - | reply | Data[0]:结果<br>0-100 | 获取光敏值回复 | 取消 |
| ====== | === | ====== | ============================ | ==================== | ======= |
| 0xC101 | reply | - | Data[0]:结果<br>0x01:成功<br>0x02:失败 | 发送启动模式回复 | - |
| 0x4101 | - | ask | Data[0]:启动模式<br>0x01:PIR启动 <br>0x02:TEST启动 <br>0x03:ON启动 <br>0x04:连拍启动 <br>0x05:PIR延时启动 <br>0x06:定时（间隔一定时间）启动 <br>0x07:关机 <br>0x08:低电关机 <br>0x09:异常启动 | 发送启动模式 | 异常启动数据：Data[1]<br>0x00:喂狗异常启动<br>0x01:超时异常启动 |
| 0xC102 | reply | - | - | 回复心跳包 | 取消 |
| 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>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灵敏度 | - |
### 1.2.1. 名词解析
| 名词 | 解析 |
| ---- | ---- |
| 超时异常启动 | MCU给主控上电后（**非TEST启动**），不管主控是否正常喂狗，如果单次上电时长超过3min未关机，给主控断电重启一次。 |
| 间隔启动时间 | 例如：60min/次。 |

162
utils/McuProtocol/include/McuProtocol.h Normal file
View File

@ -0,0 +1,162 @@
/*
* Copyright (c) 2023 Fancy Code.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef MCU_PROTOCOL_H
#define MCU_PROTOCOL_H
#include "StatusCode.h"
#include <cstddef>
#include <list>
#include <memory>
#include <mutex>
#include <semaphore.h>
#include <thread>
/**
* @brief The context of protocol processing is used for the association binding of protocol data transmission and
* reception, ensuring the correct logic of protocol question and answer.
*
*/
class VProtocolContext
{
public:
VProtocolContext() = default;
virtual ~VProtocolContext() = default;
unsigned int mSerialNumber;
short mCheckCode; // TODO: Need to improve
};
template <typename T>
class ProtocolContext : public VProtocolContext
{
public:
ProtocolContext(T &value) : mData(value)
{
}
virtual ~ProtocolContext() = default;
public:
T mData;
};
class SingleMcuPacket
{
public:
SingleMcuPacket(const void *buf, const size_t &length) : mBuf(buf), mLength(length)
{
}
~SingleMcuPacket() = default;
const void *mBuf;
const size_t mLength;
};
class VProtocolBase
{
public:
VProtocolBase() = default;
virtual ~VProtocolBase() = default;
protected:
virtual std::shared_ptr<VProtocolBase> SharedFromThis(void);
virtual ssize_t WriteData(const void *buff, const size_t buffLength, std::shared_ptr<VProtocolContext> &context,
const unsigned int &serialNumber);
protected:
virtual size_t GetKeyHeadLength(void);
virtual StatusCode GetDataLength(const void *keyHead, const size_t &headLength, size_t &dataLength);
virtual void PushMcuData(const void *buf, const size_t &length);
virtual StatusCode CheckHeader(void *header, size_t &headLength);
};
enum class ReplyResult
{
SUCCEED = 1,
FAILED,
END
};
class OtherSideReply
{
public:
OtherSideReply() = default;
virtual ~OtherSideReply() = default;
virtual void GetIpcMissionReply(const unsigned int &serialNumber, const unsigned char &mission);
virtual void OnlyResultReply(const unsigned int &serialNumber, const ReplyResult &result);
};
class OtherSideAsk
{
public:
OtherSideAsk() = default;
virtual ~OtherSideAsk() = default;
virtual void OtherSideSendIpcMission(const unsigned int &serialNumber, const unsigned char &mission);
virtual void OtherSideSendHearBeat(const unsigned int &serialNumber);
virtual void OtherSideSendGetIntervalStart(const unsigned int &serialNumber);
virtual void OtherSideSendGetDateTime(const unsigned int &serialNumber);
virtual void OtherSideSendGetPirSensitivity(const unsigned int &serialNumber);
};
class VProtocolRecv : public OtherSideReply, public OtherSideAsk
{
public:
VProtocolRecv() = default;
virtual ~VProtocolRecv() = default;
static std::shared_ptr<VProtocolRecv> &GetInstance(std::shared_ptr<VProtocolRecv> *impl = nullptr);
};
class McuProtocol : virtual public VProtocolBase
{
public:
McuProtocol() = default;
virtual ~McuProtocol() = default;
protected:
const StatusCode Init(void);
const StatusCode UnInit(void);
const StatusCode GetIpcMission(std::shared_ptr<VProtocolContext> &context);
const StatusCode CutOffPowerSupply(std::shared_ptr<VProtocolContext> &context);
const StatusCode FeedWatchDog(std::shared_ptr<VProtocolContext> &context);
const StatusCode SetFeedingCycleForWatchDog(const unsigned char &hour, const unsigned char &min,
const unsigned char &second,
std::shared_ptr<VProtocolContext> &context);
const StatusCode McuSetDateTime(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> &context);
const StatusCode SetPirSensitivity(const unsigned char &sensitivity, std::shared_ptr<VProtocolContext> &context);
const StatusCode ContorlInfraredLight(const unsigned char &control, std::shared_ptr<VProtocolContext> &context);
const StatusCode GetPhotosensitivityValue(std::shared_ptr<VProtocolContext> &context);
void DataHandleThread(void);
protected:
void ReplyOtherSideSendIpcMission(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:
size_t GetKeyHeadLength(void) override;
StatusCode GetDataLength(const void *keyHead, const size_t &headLength, size_t &dataLength) override;
void PushMcuData(const void *buf, const size_t &length) override;
StatusCode CheckHeader(void *header, size_t &headLength) override;
private:
StatusCode WriteProtocolData(const void *buff, const size_t buffLength, std::shared_ptr<VProtocolContext> &context,
const unsigned int &serialNumber);
private:
std::mutex mMutex;
sem_t mSem;
bool mThreadRuning;
std::thread mDataHandleThread;
std::list<SingleMcuPacket> mMcuDataList;
};
#endif

55
utils/McuProtocol/src/LittleEndianHandle.cpp Normal file
View File

@ -0,0 +1,55 @@
/*
* Copyright (c) 2023 Fancy Code.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "LittleEndianHandle.h"
#include "ILog.h"
#include "ModBusCRC16.h"
#include <netinet/in.h>
#include <string.h>
LittleEndianHandle::LittleEndianHandle(const std::shared_ptr<VProtocolParam> &param) : ProtocolHandle(param)
{
}
LittleEndianHandle::LittleEndianHandle(const void *data, const size_t &length) : ProtocolHandle(data, length)
{
}
void LittleEndianHandle::BigEndianConversion(ProtocolPacket &packet)
{
packet.mHead = htons(packet.mHead);
packet.mCommand = htons(packet.mCommand);
packet.mLength = htons(packet.mLength);
packet.mCheckCode = htons(packet.mCheckCode);
packet.mSerialNumber = htonl(packet.mSerialNumber);
}
short LittleEndianHandle::BigEndianConversion(const short &number)
{
return htons(number);
}
void LittleEndianHandle::HostByteOrderConversion(ProtocolPacket &packet)
{
packet.mHead = ntohs(packet.mHead);
packet.mCommand = ntohs(packet.mCommand);
packet.mLength = ntohs(packet.mLength);
packet.mCheckCode = ntohs(packet.mCheckCode);
packet.mSerialNumber = ntohl(packet.mSerialNumber);
}
bool LittleEndianHandle::CheckoutTheCheckCode(const ProtocolPacket &packet)
{
ProtocolHandle::PrintHexadecimalData(&packet.mCheckCode, CHECK_CODE_LENGTH, "CheckoutTheCheckCode little endian:");
short code = calculate_check_sum(mProtocolData, mProtocolDataLength - sizeof(short));
// code = ntohs(code); // TODO:
if (code == packet.mCheckCode) {
return true;
}
return false;
}

31
utils/McuProtocol/src/LittleEndianHandle.h Normal file
View File

@ -0,0 +1,31 @@
/*
* Copyright (c) 2023 Fancy Code.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef LITTLE_ENDIAN_HANDLE_H
#define LITTLE_ENDIAN_HANDLE_H
#include "ProtocolHandle.h"
class LittleEndianHandle : public ProtocolHandle
{
public:
LittleEndianHandle(const std::shared_ptr<VProtocolParam> &param);
LittleEndianHandle(const void *data, const size_t &length);
virtual ~LittleEndianHandle() = default;
private:
void BigEndianConversion(ProtocolPacket &packet) override;
short BigEndianConversion(const short &number) override;
void HostByteOrderConversion(ProtocolPacket &packet) override;
bool CheckoutTheCheckCode(const ProtocolPacket &packet) override;
};
#endif

286
utils/McuProtocol/src/McuProtocol.cpp Normal file
View File

@ -0,0 +1,286 @@
/*
* Copyright (c) 2023 Fancy Code.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "McuProtocol.h"
#include "ILog.h"
#include "ProtocolHandle.h"
#include <string.h>
std::shared_ptr<VProtocolBase> VProtocolBase::SharedFromThis(void)
{
return std::make_shared<VProtocolBase>();
}
ssize_t VProtocolBase::WriteData(const void *buff, const size_t buffLength, std::shared_ptr<VProtocolContext> &context,
const unsigned int &serialNumber)
{
return 0;
}
size_t VProtocolBase::GetKeyHeadLength(void)
{
return 0;
}
StatusCode VProtocolBase::GetDataLength(const void *keyHead, const size_t &headLength, size_t &dataLength)
{
return CreateStatusCode(STATUS_CODE_INVALID_PARAMENTER);
}
void VProtocolBase::PushMcuData(const void *buf, const size_t &length)
{
}
StatusCode VProtocolBase::CheckHeader(void *header, size_t &headLength)
{
return CreateStatusCode(STATUS_CODE_INVALID_PARAMENTER);
}
void OtherSideReply::GetIpcMissionReply(const unsigned int &serialNumber, const unsigned char &mission)
{
}
void OtherSideReply::OnlyResultReply(const unsigned int &serialNumber, const ReplyResult &result)
{
}
void OtherSideAsk::OtherSideSendIpcMission(const unsigned int &serialNumber, const unsigned char &mission)
{
}
void OtherSideAsk::OtherSideSendHearBeat(const unsigned int &serialNumber)
{
}
void OtherSideAsk::OtherSideSendGetIntervalStart(const unsigned int &serialNumber)
{
}
void OtherSideAsk::OtherSideSendGetDateTime(const unsigned int &serialNumber)
{
}
void OtherSideAsk::OtherSideSendGetPirSensitivity(const unsigned int &serialNumber)
{
}
std::shared_ptr<VProtocolRecv> &VProtocolRecv::GetInstance(std::shared_ptr<VProtocolRecv> *impl)
{
static auto instance = std::make_shared<VProtocolRecv>();
if (impl) {
instance = *impl;
}
return instance;
}
const StatusCode McuProtocol::Init(void)
{
ProtocolHandle::Init();
constexpr int THREAD_SHARING = 0;
constexpr int INITIAL_VALUE_OF_SEMAPHORE = 0;
sem_init(&mSem, THREAD_SHARING, INITIAL_VALUE_OF_SEMAPHORE);
auto dataHandleThread = [](std::shared_ptr<McuProtocol> handle) {
handle->DataHandleThread();
};
std::shared_ptr<McuProtocol> handle = std::dynamic_pointer_cast<McuProtocol>(SharedFromThis());
mDataHandleThread = std::thread(dataHandleThread, handle);
std::shared_ptr<VProtocolRecv> reply = std::dynamic_pointer_cast<VProtocolRecv>(SharedFromThis());
if (reply) {
VProtocolRecv::GetInstance(&reply);
}
else {
LogWarning("The VProtocolRecv class has not been overloaded, which can result in incomplete functionality.\n");
}
return CreateStatusCode(STATUS_CODE_OK);
}
const StatusCode McuProtocol::UnInit(void)
{
ProtocolHandle::UnInit();
mThreadRuning = false;
sem_post(&mSem);
if (mDataHandleThread.joinable()) {
mDataHandleThread.join();
}
std::shared_ptr<VProtocolRecv> reply = std::make_shared<VProtocolRecv>();
VProtocolRecv::GetInstance(&reply);
sem_destroy(&mSem);
return CreateStatusCode(STATUS_CODE_OK);
}
const StatusCode McuProtocol::GetIpcMission(std::shared_ptr<VProtocolContext> &context)
{
std::shared_ptr<VProtocolParam> param = std::make_shared<VProtocolParam>(PROTOCOL_COMMAND::ASK_IPC_MISSION);
std::shared_ptr<ProtocolHandle> handle = ProtocolHandle::CreateProtocolData(param);
return WriteProtocolData(
handle->GetProtocolDataBuff(), handle->GetProtocolDataLength(), context, handle->GetSerialNumber());
}
const StatusCode McuProtocol::CutOffPowerSupply(std::shared_ptr<VProtocolContext> &context)
{
std::shared_ptr<VProtocolParam> param =
std::make_shared<VProtocolParam>(PROTOCOL_COMMAND::ASK_CUT_OFF_PWOER_SUPPLY);
std::shared_ptr<ProtocolHandle> handle = ProtocolHandle::CreateProtocolData(param);
return WriteProtocolData(
handle->GetProtocolDataBuff(), handle->GetProtocolDataLength(), context, handle->GetSerialNumber());
}
const StatusCode McuProtocol::FeedWatchDog(std::shared_ptr<VProtocolContext> &context)
{
std::shared_ptr<VProtocolParam> param = std::make_shared<VProtocolParam>(PROTOCOL_COMMAND::ASK_FEED_WATCH_DOG);
std::shared_ptr<ProtocolHandle> handle = ProtocolHandle::CreateProtocolData(param);
return WriteProtocolData(
handle->GetProtocolDataBuff(), handle->GetProtocolDataLength(), context, handle->GetSerialNumber());
}
const StatusCode McuProtocol::SetFeedingCycleForWatchDog(const unsigned char &hour, const unsigned char &min,
const unsigned char &second,
std::shared_ptr<VProtocolContext> &context)
{
SetTime watchDogParam(hour, min, second);
std::shared_ptr<VProtocolParam> param =
std::make_shared<ProtocolParam<SetTime>>(PROTOCOL_COMMAND::ASK_SET_FEEDING_CYCLE, watchDogParam);
std::shared_ptr<ProtocolHandle> handle = ProtocolHandle::CreateProtocolData(param);
return WriteProtocolData(
handle->GetProtocolDataBuff(), handle->GetProtocolDataLength(), context, handle->GetSerialNumber());
}
const StatusCode McuProtocol::McuSetDateTime(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> &context)
{
SetDateTime dateTime(year, mon, day, hour, min, second);
std::shared_ptr<VProtocolParam> param =
std::make_shared<ProtocolParam<SetDateTime>>(PROTOCOL_COMMAND::ASK_SET_DATE_TIME, dateTime);
std::shared_ptr<ProtocolHandle> handle = ProtocolHandle::CreateProtocolData(param);
return WriteProtocolData(
handle->GetProtocolDataBuff(), handle->GetProtocolDataLength(), context, handle->GetSerialNumber());
}
const StatusCode McuProtocol::SetPirSensitivity(const unsigned char &sensitivity,
std::shared_ptr<VProtocolContext> &context)
{
std::shared_ptr<VProtocolParam> param =
std::make_shared<ProtocolParam<const unsigned char>>(PROTOCOL_COMMAND::ASK_SET_PIR_SENSITIVITY, sensitivity);
std::shared_ptr<ProtocolHandle> handle = ProtocolHandle::CreateProtocolData(param);
return WriteProtocolData(
handle->GetProtocolDataBuff(), handle->GetProtocolDataLength(), context, handle->GetSerialNumber());
}
const StatusCode McuProtocol::ContorlInfraredLight(const unsigned char &control,
std::shared_ptr<VProtocolContext> &context)
{
std::shared_ptr<VProtocolParam> param =
std::make_shared<ProtocolParam<const unsigned char>>(PROTOCOL_COMMAND::ASK_CONTORL_INFRARED_LIGHT, control);
std::shared_ptr<ProtocolHandle> handle = ProtocolHandle::CreateProtocolData(param);
return WriteProtocolData(
handle->GetProtocolDataBuff(), handle->GetProtocolDataLength(), context, handle->GetSerialNumber());
}
const StatusCode McuProtocol::GetPhotosensitivityValue(std::shared_ptr<VProtocolContext> &context)
{
std::shared_ptr<VProtocolParam> param =
std::make_shared<VProtocolParam>(PROTOCOL_COMMAND::ASK_GET_PHOTOSENSITIVITY);
std::shared_ptr<ProtocolHandle> handle = ProtocolHandle::CreateProtocolData(param);
return WriteProtocolData(
handle->GetProtocolDataBuff(), handle->GetProtocolDataLength(), context, handle->GetSerialNumber());
}
void McuProtocol::DataHandleThread(void)
{
mThreadRuning = true;
while (mThreadRuning) {
sem_wait(&mSem);
mMutex.lock();
if (mMcuDataList.size() == 0) {
mMutex.unlock();
continue;
}
SingleMcuPacket packet = mMcuDataList.front();
mMcuDataList.pop_front();
mMutex.unlock();
ProtocolHandle::ProtocolAnalysis(packet.mBuf, packet.mLength);
free((void *)packet.mBuf);
}
}
void McuProtocol::ReplyOtherSideSendIpcMission(const ReplyResult &result, const unsigned int &serialNumber)
{
std::shared_ptr<VProtocolContext> NULL_CONTEXT;
std::shared_ptr<VProtocolParam> param = std::make_shared<ProtocolParam<const unsigned char>>(
PROTOCOL_COMMAND::REPLY_OTHER_SIDE_ASK_SEND_IPC_MISSION, static_cast<const unsigned char>(result));
param->mSerialNumber = serialNumber;
std::shared_ptr<ProtocolHandle> handle = ProtocolHandle::CreateProtocolData(param);
WriteProtocolData(
handle->GetProtocolDataBuff(), handle->GetProtocolDataLength(), NULL_CONTEXT, handle->GetSerialNumber());
}
void McuProtocol::ReplyOtherSideSendHearBeat(const ReplyResult &result, const unsigned int &serialNumber)
{
std::shared_ptr<VProtocolContext> NULL_CONTEXT;
std::shared_ptr<VProtocolParam> param =
std::make_shared<VProtocolParam>(PROTOCOL_COMMAND::REPLY_OTHER_SIDE_ASK_SEND_HEART_BEAT);
param->mSerialNumber = serialNumber;
std::shared_ptr<ProtocolHandle> handle = ProtocolHandle::CreateProtocolData(param);
WriteProtocolData(
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);
param->mSerialNumber = serialNumber;
std::shared_ptr<ProtocolHandle> handle = ProtocolHandle::CreateProtocolData(param);
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 - 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;
std::shared_ptr<ProtocolHandle> handle = ProtocolHandle::CreateProtocolData(param);
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)
{
return ProtocolHandle::GetKeyHeadLength();
}
StatusCode McuProtocol::GetDataLength(const void *keyHead, const size_t &headLength, size_t &dataLength)
{
return ProtocolHandle::GetDataLength(keyHead, headLength, dataLength);
}
void McuProtocol::PushMcuData(const void *buf, const size_t &length)
{
char *data = (char *)malloc(length);
if (nullptr == data) {
LogError("malloc failed, PushMcuData failed.\n");
return;
}
LogInfo("PushMcuData\n");
memcpy(data, buf, length);
ProtocolHandle::PrintHexadecimalData(data, length, "PushMcuData=");
std::lock_guard<std::mutex> locker(mMutex);
SingleMcuPacket packet(data, length);
mMcuDataList.push_back(packet);
sem_post(&mSem);
}
StatusCode McuProtocol::CheckHeader(void *header, size_t &headLength)
{
return ProtocolHandle::CheckHeader(header, headLength);
}
StatusCode McuProtocol::WriteProtocolData(const void *buff, const size_t buffLength,
std::shared_ptr<VProtocolContext> &context, const unsigned int &serialNumber)
{
size_t length = WriteData(buff, buffLength, context, serialNumber);
if (buffLength == length) {
return CreateStatusCode(STATUS_CODE_OK);
}
return CreateStatusCode(STATUS_CODE_NOT_OK);
}

64
utils/McuProtocol/src/McuProtocolMakePtr.cpp Normal file
View File

@ -0,0 +1,64 @@
/*
* Copyright (c) 2023 Fancy Code.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "McuProtocolMakePtr.h"
#include "ILog.h"
#include "LittleEndianHandle.h"
#include <netinet/in.h>
std::shared_ptr<McuProtocolMakePtr> &McuProtocolMakePtr::GetInstance(std::shared_ptr<McuProtocolMakePtr> *impl)
{
static auto instance = std::make_shared<McuProtocolMakePtr>();
if (impl) {
if (instance.use_count() == 1) {
LogInfo("Instance changed succeed.\n");
instance = *impl;
}
else {
LogError("Can't changing the instance becase of using by some one.\n");
}
}
return instance;
}
McuProtocolMakePtr::McuProtocolMakePtr()
{
mByteOrder = 0x00;
}
const StatusCode McuProtocolMakePtr::CreateProtocolHandle(std::shared_ptr<ProtocolHandle> &impl,
const std::shared_ptr<VProtocolParam> &param)
{
std::shared_ptr<ProtocolHandle> tmp;
char byteOrder = ProtocolHandle::GetByteOrder();
if (ORDER_BIG_ENDIAN == byteOrder) {
tmp = std::make_shared<ProtocolHandle>(param);
}
else {
tmp = std::make_shared<LittleEndianHandle>(param);
}
impl = tmp;
return CreateStatusCode(STATUS_CODE_OK);
}
const StatusCode McuProtocolMakePtr::CreateProtocolHandle(std::shared_ptr<ProtocolHandle> &impl, const void *data,
const size_t &length)
{
std::shared_ptr<ProtocolHandle> tmp;
char byteOrder = ProtocolHandle::GetByteOrder();
if (ORDER_BIG_ENDIAN == byteOrder) {
tmp = std::make_shared<ProtocolHandle>(data, length);
}
else {
tmp = std::make_shared<LittleEndianHandle>(data, length);
}
impl = tmp;
return CreateStatusCode(STATUS_CODE_OK);
}

34
utils/McuProtocol/src/McuProtocolMakePtr.h Normal file
View File

@ -0,0 +1,34 @@
/*
* Copyright (c) 2023 Fancy Code.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef MCU_PROTOCOL_MAKE_PTR_H
#define MCU_PROTOCOL_MAKE_PTR_H
#include "ProtocolHandle.h"
#include "StatusCode.h"
#include <memory>
class McuProtocolMakePtr
{
public:
McuProtocolMakePtr();
virtual ~McuProtocolMakePtr() = default;
static std::shared_ptr<McuProtocolMakePtr> &GetInstance(std::shared_ptr<McuProtocolMakePtr> *impl = nullptr);
virtual const StatusCode CreateProtocolHandle(std::shared_ptr<ProtocolHandle> &impl,
const std::shared_ptr<VProtocolParam> &param);
virtual const StatusCode CreateProtocolHandle(std::shared_ptr<ProtocolHandle> &impl, const void *data,
const size_t &length);
private:
char mByteOrder;
};
#endif // !MCU_PROTOCOL_MAKE_PTR_H

403
utils/McuProtocol/src/ProtocolHandle.cpp Normal file
View File

@ -0,0 +1,403 @@
/*
* Copyright (c) 2023 Fancy Code.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "ProtocolHandle.h"
#include "ILog.h"
#include "McuProtocol.h"
#include "McuProtocolMakePtr.h"
#include "ModBusCRC16.h"
#include <netinet/in.h>
#include <string.h>
using std::placeholders::_1;
// using std::placeholders::_2;
// using std::placeholders::_3;
// using std::placeholders::_4;
unsigned int ProtocolHandle::mSerialNumber = 1;
std::mutex ProtocolHandle::mMutex;
ProtocolHandle::ProtocolHandle(const std::shared_ptr<VProtocolParam> &param) : mParam(param)
{
mProtocolData = nullptr;
mProtocolDataLength = 0;
mMakePacketFunc[ASK_IPC_MISSION] = std::bind(&ProtocolHandle::MakeAskIpcMissionPacket, this, _1);
mMakePacketFunc[ASK_CUT_OFF_PWOER_SUPPLY] = std::bind(&ProtocolHandle::MakeAskCutOffPowerSupplyPacket, this, _1);
mMakePacketFunc[ASK_FEED_WATCH_DOG] = std::bind(&ProtocolHandle::MakeAskFeedWatchDogPacket, this, _1);
mMakePacketFunc[ASK_SET_FEEDING_CYCLE] = std::bind(&ProtocolHandle::MakeAskSetFeedingCyclePacket, this, _1);
mMakePacketFunc[ASK_SET_DATE_TIME] = std::bind(&ProtocolHandle::MakeAskSetDateTimePacket, this, _1);
mMakePacketFunc[ASK_SET_PIR_SENSITIVITY] = std::bind(&ProtocolHandle::MakeAskSetPirSensitivityPacket, this, _1);
mMakePacketFunc[ASK_CONTORL_INFRARED_LIGHT] =
std::bind(&ProtocolHandle::MakeAskControlInfraredLightPacket, this, _1);
mMakePacketFunc[ASK_GET_PHOTOSENSITIVITY] = std::bind(&ProtocolHandle::MakeAskGetPhotosensitivityPacket, this, _1);
/**************************************************************************************************************************/
mMakePacketFunc[REPLY_OTHER_SIDE_ASK_SEND_IPC_MISSION] =
std::bind(&ProtocolHandle::MakeReplyOtherSideSendIpcMissionPacket, this, _1);
mMakePacketFunc[REPLY_OTHER_SIDE_ASK_SEND_HEART_BEAT] =
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)
{
mProtocolData = (unsigned char *)malloc(length);
if (nullptr != mProtocolData) {
memcpy(mProtocolData, data, length);
}
mProtocolDataLength = length;
mAnalyzePacketFunc[REPLY_IPC_MISSION] = std::bind(&ProtocolHandle::AnalyzeReplyIpcMissionPacket, this, _1);
mAnalyzePacketFunc[REPLY_SET_FEEDING_CYCLE] = std::bind(&ProtocolHandle::AnalyzeReplyResultPacket, this, _1);
mAnalyzePacketFunc[REPLY_SET_DATE_TIME] = std::bind(&ProtocolHandle::AnalyzeReplyResultPacket, this, _1);
mAnalyzePacketFunc[REPLY_SET_PIR_SENSITIVITY] = std::bind(&ProtocolHandle::AnalyzeReplyResultPacket, this, _1);
mAnalyzePacketFunc[REPLY_CONTORL_INFRARED_LIGHT] = std::bind(&ProtocolHandle::AnalyzeReplyResultPacket, this, _1);
mAnalyzePacketFunc[REPLY_GET_PHOTOSENSITIVITY] = std::bind(&ProtocolHandle::AnalyzeReplyResultPacket, this, _1);
/**************************************************************************************************************************/
mAnalyzePacketFunc[OTHER_SIDE_ASK_SEND_IPC_MISSION] =
std::bind(&ProtocolHandle::AnalyzeOtherSideSendIpcMissionPacket, this, _1);
mAnalyzePacketFunc[OTHER_SIDE_ASK_SEND_HEART_BEAT] =
std::bind(&ProtocolHandle::AnalyzeOtherSideSendHeartBeatPacket, this, _1);
mAnalyzePacketFunc[OTHER_SIDE_ASK_GET_INTERVAL_START] =
std::bind(&ProtocolHandle::AnalyzeOtherSideSendGetIntervalStart, this, _1);
mAnalyzePacketFunc[OTHER_SIDE_ASK_GET_DATE_TIME] =
std::bind(&ProtocolHandle::AnalyzeOtherSideSendGetDataTime, this, _1);
mAnalyzePacketFunc[OTHER_SIDE_ASK_GET_PIR_SENSITIVITY] =
std::bind(&ProtocolHandle::AnalyzeOtherSideSendGetPirSensitivity, this, _1);
}
ProtocolHandle::~ProtocolHandle()
{
if (nullptr != mProtocolData) {
free(mProtocolData);
mProtocolData = nullptr;
}
}
ProtocolPacket ProtocolHandle::CreatePocketWithSerialNumber(void)
{
std::lock_guard<std::mutex> locker(mMutex);
ProtocolPacket packet;
memset(&packet, 0, sizeof(ProtocolPacket));
if (SERIAL_NUMBER_NEED_TO_MAKE_A_LOCAL_ONE == mProtocolSerialNumber) {
packet.mSerialNumber = mSerialNumber;
mProtocolSerialNumber = packet.mSerialNumber;
mSerialNumber++;
}
else {
packet.mSerialNumber = mProtocolSerialNumber;
}
return packet;
}
void ProtocolHandle::MallocPacketDataBuff(const void *data, const size_t dataLength, const short &command)
{
size_t packetLength = KEY_HEAD_LENGTH + dataLength + CHECK_CODE_LENGTH;
mProtocolData = (unsigned char *)malloc(packetLength);
if (nullptr == mProtocolData) {
LogError("malloc failed, MakeAskIpcMissionPacket return.\n");
return;
}
ProtocolPacket packet = CreatePocketWithSerialNumber();
packet.mHead = PROTOCOL_HEAD;
packet.mCommand = command;
packet.mLength = packetLength;
BigEndianConversion(packet);
memcpy(mProtocolData, &packet, KEY_HEAD_LENGTH);
memcpy(mProtocolData + KEY_HEAD_LENGTH, data, dataLength);
packet.mCheckCode = calculate_check_sum(mProtocolData, packetLength - CHECK_CODE_LENGTH);
packet.mCheckCode = BigEndianConversion(packet.mCheckCode);
memcpy(mProtocolData + packetLength - CHECK_CODE_LENGTH, &packet.mCheckCode, CHECK_CODE_LENGTH);
mProtocolDataLength = packetLength;
ProtocolHandle::PrintHexadecimalData(mProtocolData, mProtocolDataLength, "Make protocol packet:");
}
void ProtocolHandle::MakeProtocolPacket(const std::shared_ptr<VProtocolParam> &param)
{
if (mProtocolData != nullptr) {
LogError("Something wrong happened, make packet failed.\n");
return;
}
mProtocolSerialNumber = param->mSerialNumber;
std::map<PROTOCOL_COMMAND, MakePacketFunc>::iterator iter;
iter = mMakePacketFunc.find(param->mCommand);
if (iter != mMakePacketFunc.end()) {
mMakePacketFunc[param->mCommand](param);
}
else {
LogError("Unknown command.\n");
}
}
void ProtocolHandle::MakeNoUserDataPacket(const std::shared_ptr<VProtocolParam> &param)
{
size_t packetLength = KEY_HEAD_LENGTH + CHECK_CODE_LENGTH;
mProtocolData = (unsigned char *)malloc(packetLength);
if (nullptr == mProtocolData) {
LogError("malloc failed, MakeAskIpcMissionPacket return.\n");
return;
}
ProtocolPacket packet = CreatePocketWithSerialNumber();
packet.mHead = PROTOCOL_HEAD;
packet.mCommand = param->mCommand;
packet.mLength = packetLength;
BigEndianConversion(packet);
memcpy(mProtocolData, &packet, KEY_HEAD_LENGTH);
packet.mCheckCode = calculate_check_sum(mProtocolData, packetLength - CHECK_CODE_LENGTH);
packet.mCheckCode = BigEndianConversion(packet.mCheckCode);
memcpy(mProtocolData + KEY_HEAD_LENGTH, &packet.mCheckCode, CHECK_CODE_LENGTH);
mProtocolDataLength = packetLength;
if (param->mCommand != ASK_FEED_WATCH_DOG) {
ProtocolHandle::PrintHexadecimalData(
mProtocolData, mProtocolDataLength - CHECK_CODE_LENGTH, "MakeNoUserDataPacket:");
}
}
void ProtocolHandle::MakeAskIpcMissionPacket(const std::shared_ptr<VProtocolParam> &param)
{
MakeNoUserDataPacket(param);
}
void ProtocolHandle::MakeAskCutOffPowerSupplyPacket(const std::shared_ptr<VProtocolParam> &param)
{
MakeNoUserDataPacket(param);
}
void ProtocolHandle::MakeAskFeedWatchDogPacket(const std::shared_ptr<VProtocolParam> &param)
{
MakeNoUserDataPacket(param);
}
void ProtocolHandle::MakeAskSetFeedingCyclePacket(const std::shared_ptr<VProtocolParam> &param)
{
MakeProtocolData<SetTime>(param);
}
void ProtocolHandle::MakeAskSetDateTimePacket(const std::shared_ptr<VProtocolParam> &param)
{
MakeProtocolData<SetDateTime>(param);
}
void ProtocolHandle::MakeAskSetPirSensitivityPacket(const std::shared_ptr<VProtocolParam> &param)
{
MakeProtocolData<const unsigned char>(param);
}
void ProtocolHandle::MakeReplyOtherSideSendIpcMissionPacket(const std::shared_ptr<VProtocolParam> &param)
{
MakeProtocolData<const unsigned char>(param);
}
void ProtocolHandle::MakeReplyOtherSideSendHeartBeatPacket(const std::shared_ptr<VProtocolParam> &param)
{
MakeNoUserDataPacket(param);
}
void ProtocolHandle::MakeAskControlInfraredLightPacket(const std::shared_ptr<VProtocolParam> &param)
{
MakeProtocolData<const unsigned char>(param);
}
void ProtocolHandle::MakeAskGetPhotosensitivityPacket(const std::shared_ptr<VProtocolParam> &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)
{
ProtocolPacket packet = {0};
memcpy(&packet, mProtocolData, KEY_HEAD_LENGTH);
memcpy(&packet.mCheckCode,
(unsigned char *)mProtocolData + mProtocolDataLength - sizeof(unsigned short),
sizeof(unsigned short));
HostByteOrderConversion(packet);
if (CheckoutTheCheckCode(packet) == false) {
LogError("CheckoutTheCheckCode failed.\n");
return;
}
/**
* @brief unsigned int number = packet.mSerialNumber This line of code is for
* avoiding errors: runtime error: reference binding to misaligned address xxxx
*/
mProtocolSerialNumber = packet.mSerialNumber;
LogInfo("AnalyzeProtocolPacket, command = 0x%04X\n", packet.mCommand);
PROTOCOL_COMMAND command = static_cast<PROTOCOL_COMMAND>(packet.mCommand);
std::map<PROTOCOL_COMMAND, AnalyzePacketFunc>::iterator iter;
iter = mAnalyzePacketFunc.find(command);
if (iter != mAnalyzePacketFunc.end()) {
mAnalyzePacketFunc[command](packet);
}
else {
LogError("Unknown command.\n");
}
}
unsigned char ProtocolHandle::ReplyOneBytePacketResult(const ProtocolPacket &packet)
{
constexpr unsigned char UNKNOWN_RESULT = 0xFF;
constexpr unsigned int PROTOCOL_DATA_START_ADDRESS = KEY_HEAD_LENGTH;
unsigned char replyResult = UNKNOWN_RESULT;
replyResult = mProtocolData[PROTOCOL_DATA_START_ADDRESS];
LogInfo("Other side send: result = 0x%02X\n", replyResult);
return replyResult;
}
void ProtocolHandle::AnalyzeReplyResultPacket(const ProtocolPacket &packet)
{
LogInfo("AnalyzeReplyResultPacket\n");
unsigned char replyResult = ReplyOneBytePacketResult(packet);
VProtocolRecv::GetInstance()->OnlyResultReply(mProtocolSerialNumber, static_cast<ReplyResult>(replyResult));
}
void ProtocolHandle::AnalyzeReplyIpcMissionPacket(const ProtocolPacket &packet)
{
LogInfo("AnalyzeReplyIpcMissionPacket\n");
unsigned char ipcMission = ReplyOneBytePacketResult(packet);
VProtocolRecv::GetInstance()->GetIpcMissionReply(mProtocolSerialNumber, ipcMission);
}
void ProtocolHandle::AnalyzeOtherSideSendIpcMissionPacket(const ProtocolPacket &packet)
{
LogInfo("AnalyzeOtherSideSendIpcMissionPacket\n");
unsigned char ipcMission = ReplyOneBytePacketResult(packet);
VProtocolRecv::GetInstance()->OtherSideSendIpcMission(mProtocolSerialNumber, ipcMission);
}
void ProtocolHandle::AnalyzeOtherSideSendHeartBeatPacket(const ProtocolPacket &packet)
{
LogInfo("AnalyzeOtherSideSendHeartBeatPacket\n");
VProtocolRecv::GetInstance()->OtherSideSendHearBeat(mProtocolSerialNumber);
}
void ProtocolHandle::AnalyzeOtherSideSendGetIntervalStart(const ProtocolPacket &packet)
{
LogInfo("AnalyzeOtherSideSendGetIntervalStart\n");
VProtocolRecv::GetInstance()->OtherSideSendGetIntervalStart(mProtocolSerialNumber);
}
void ProtocolHandle::AnalyzeOtherSideSendGetDataTime(const ProtocolPacket &packet)
{
LogInfo("AnalyzeOtherSideSendGetDataTime\n");
VProtocolRecv::GetInstance()->OtherSideSendGetDateTime(mProtocolSerialNumber);
}
void ProtocolHandle::AnalyzeOtherSideSendGetPirSensitivity(const ProtocolPacket &packet)
{
LogInfo("AnalyzeOtherSideSendGetPirSensitivity\n");
VProtocolRecv::GetInstance()->OtherSideSendGetPirSensitivity(mProtocolSerialNumber);
}
bool ProtocolHandle::CheckoutTheCheckCode(const ProtocolPacket &packet)
{
ProtocolHandle::PrintHexadecimalData(&packet.mCheckCode, CHECK_CODE_LENGTH, "CheckoutTheCheckCode:");
short code = calculate_check_sum(mProtocolData, mProtocolDataLength - CHECK_CODE_LENGTH);
if (code == packet.mCheckCode) {
return true;
}
return false;
}
void ProtocolHandle::Init(void)
{
mSerialNumber = 1;
}
void ProtocolHandle::UnInit(void)
{
mSerialNumber = 1;
}
std::shared_ptr<ProtocolHandle> ProtocolHandle::CreateProtocolData(const std::shared_ptr<VProtocolParam> &param)
{
std::shared_ptr<ProtocolHandle> handle;
McuProtocolMakePtr::GetInstance()->CreateProtocolHandle(handle, param);
if (handle) {
handle->MakeProtocolPacket(param);
}
return handle;
}
void ProtocolHandle::ProtocolAnalysis(const void *data, const size_t &length)
{
LogInfo("ProtocolAnalysis\n");
std::shared_ptr<ProtocolHandle> handle;
McuProtocolMakePtr::GetInstance()->CreateProtocolHandle(handle, data, length);
if (handle) {
handle->AnalyzeProtocolPacket();
}
}
size_t ProtocolHandle::GetKeyHeadLength(void)
{
return KEY_HEAD_LENGTH;
}
StatusCode ProtocolHandle::CheckHeader(void *header, size_t &headLength)
{
unsigned char *data = (unsigned char *)header;
unsigned short protocolHead = 0;
protocolHead = PROTOCOL_HEAD;
// LogInfo("head = 0x%02X, 0x%02X\n", protocolHead >> 8, protocolHead & 0x00FF);
for (size_t i = 0; i < headLength; i++) {
if ((protocolHead >> 8 == data[i]) && ((protocolHead & 0x00FF) == data[i + 1])) {
headLength -= i;
if (0 == i) {
return CreateStatusCode(STATUS_CODE_OK);
}
unsigned char fixedHeader[KEY_HEAD_LENGTH] = {0};
memcpy(fixedHeader, data + i, headLength);
memcpy(header, fixedHeader, headLength);
LogWarning("Protocol head unmatch, unknow data before head. headLength =%d\n", headLength);
ProtocolHandle::PrintHexadecimalData(header, headLength, "Fixed header:");
return CreateStatusCode(STATUS_CODE_NOT_OK);
}
}
LogWarning("Protocol head unmatch, head not found.\n");
return CreateStatusCode(STATUS_CODE_NOT_OK);
}
StatusCode ProtocolHandle::GetDataLength(const void *keyHead, const size_t &headLength, size_t &dataLength)
{
if (KEY_HEAD_LENGTH != headLength) {
LogError("key head buf error.\n");
return CreateStatusCode(STATUS_CODE_NOT_OK);
}
unsigned short headNum = PROTOCOL_HEAD;
char byteOrder = ProtocolHandle::GetByteOrder();
if (ORDER_LITTLE_ENDIAN == byteOrder) {
headNum = htons(PROTOCOL_HEAD);
}
unsigned char head[3] = {0};
memcpy(head, &headNum, sizeof(unsigned short));
if (strstr((const char *)keyHead, (const char *)head) == nullptr) {
LogError("Protocol head unmatch.\n");
return CreateStatusCode(STATUS_CODE_NOT_OK);
}
ProtocolPacket packet = {0};
memcpy(&packet, keyHead, headLength);
if (ORDER_LITTLE_ENDIAN == byteOrder) {
packet.mLength = htons(packet.mLength);
}
dataLength = packet.mLength;
return CreateStatusCode(STATUS_CODE_OK);
}
char ProtocolHandle::GetByteOrder(void)
{
static char byteOrder = 0x00;
if (0x00 != byteOrder) {
return byteOrder;
}
unsigned int value = 0x12345678;
unsigned int networkOrder = htonl(value);
if (value == networkOrder) {
LogInfo("Big Endian.\n");
byteOrder = ORDER_BIG_ENDIAN;
}
else {
LogInfo("Little Endian.\n");
byteOrder = ORDER_LITTLE_ENDIAN;
}
return byteOrder;
}
void ProtocolHandle::PrintHexadecimalData(const void *buf, const size_t &bufLength, const char *log)
{
if (log) {
printf("%s", log);
}
printf(" {0x%02X", *(unsigned char *)buf);
for (size_t i = 1; i < bufLength; i++) {
printf(", 0x%02X", *((unsigned char *)buf + i));
}
printf("}\n");
}

244
utils/McuProtocol/src/ProtocolHandle.h Normal file
View File

@ -0,0 +1,244 @@
/*
* Copyright (c) 2023 Fancy Code.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef PROTOCOL_HANDLE_H
#define PROTOCOL_HANDLE_H
#include "ILog.h"
#include "StatusCode.h"
#include <functional>
#include <map>
#include <memory>
#include <mutex>
constexpr char ORDER_BIG_ENDIAN = 0x01;
constexpr char ORDER_LITTLE_ENDIAN = 0x02;
constexpr size_t KEY_HEAD_LENGTH = sizeof(short) + sizeof(unsigned int) + sizeof(short) + sizeof(short);
constexpr size_t CHECK_CODE_LENGTH = sizeof(short);
constexpr unsigned int SERIAL_NUMBER_NEED_TO_MAKE_A_LOCAL_ONE = 0;
#pragma pack(1)
typedef struct protocol_packet
{
short mHead;
unsigned int mSerialNumber;
short mCommand;
short mLength;
// char *mData;
short mCheckCode;
} ProtocolPacket;
#pragma pack()
constexpr unsigned short PROTOCOL_HEAD = 0xFAC1;
enum PROTOCOL_COMMAND
{
ASK_IPC_MISSION = 0x8101,
REPLY_IPC_MISSION = 0x0101,
ASK_CUT_OFF_PWOER_SUPPLY = 0x8102,
ASK_FEED_WATCH_DOG = 0x8103,
ASK_SET_FEEDING_CYCLE = 0x8104,
REPLY_SET_FEEDING_CYCLE = 0x0104,
ASK_SET_DATE_TIME = 0x8107,
REPLY_SET_DATE_TIME = 0x0107,
ASK_SET_PIR_SENSITIVITY = 0x8108,
REPLY_SET_PIR_SENSITIVITY = 0x0108,
ASK_CONTORL_INFRARED_LIGHT = 0x810A, // Temporarily cancelled, reserved.
REPLY_CONTORL_INFRARED_LIGHT = 0x010A, // Temporarily cancelled, reserved.
ASK_GET_PHOTOSENSITIVITY = 0x810B, // Temporarily cancelled, reserved.
REPLY_GET_PHOTOSENSITIVITY = 0x010B, // Temporarily cancelled, reserved.
/**
* @brief The protocol starting from here is a request sent from the other end.
*
*/
REPLY_OTHER_SIDE_ASK_SEND_IPC_MISSION = 0xC101,
OTHER_SIDE_ASK_SEND_IPC_MISSION = 0x4101,
REPLY_OTHER_SIDE_ASK_SEND_HEART_BEAT = 0xC102, // Temporarily cancelled, reserved.
OTHER_SIDE_ASK_SEND_HEART_BEAT = 0x4102, // Temporarily cancelled, reserved.
REPLY_OTHER_SIDE_ASK_GET_INTERVAL_START = 0xC106,
OTHER_SIDE_ASK_GET_INTERVAL_START = 0x4106,
REPLY_OTHER_SIDE_ASK_GET_DATE_TIME = 0xC107,
OTHER_SIDE_ASK_GET_DATE_TIME = 0x4107,
REPLY_OTHER_SIDE_ASK_GET_PIR_SENSITIVITY = 0xC108,
OTHER_SIDE_ASK_GET_PIR_SENSITIVITY = 0x4108,
PROTOCOL_COMMAND_END
};
constexpr unsigned char ZERO_MEANS_SHUTDOWN_WATCH_DOG = 0x00;
#pragma pack(1)
typedef struct watch_dog_param
{
watch_dog_param(const unsigned char &hour, const unsigned char &min, const unsigned char &second)
: mHour(hour), mMin(min), mSecond(second)
{
}
const unsigned char mHour;
const unsigned char mMin;
const unsigned char mSecond;
} SetTime;
typedef struct set_date_time
{
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 char mYear;
const unsigned char mMon;
const unsigned char mDay;
const unsigned char mHour;
const unsigned char mMin;
const unsigned char mSecond;
} SetDateTime;
#pragma pack()
class VProtocolParam
{
public:
VProtocolParam(const PROTOCOL_COMMAND &command) : mCommand(command)
{
mSerialNumber = SERIAL_NUMBER_NEED_TO_MAKE_A_LOCAL_ONE;
}
virtual ~VProtocolParam() = default;
const PROTOCOL_COMMAND mCommand;
unsigned int mSerialNumber;
};
template <typename T>
class ProtocolParam : public VProtocolParam
{
public:
ProtocolParam(const PROTOCOL_COMMAND &command, T &value) : VProtocolParam(command), mData(value)
{
}
virtual ~ProtocolParam() = default;
public:
/**
* @brief
* Protocol data.
*/
T mData;
};
using MakePacketFunc = std::function<void(const std::shared_ptr<VProtocolParam> &)>;
using AnalyzePacketFunc = std::function<void(const ProtocolPacket &)>;
/**
* @brief Protocol processing classes need to focus on data size issues, and ProtocolHandle defaults to handling large
* end data.
*/
class ProtocolHandle
{
public:
ProtocolHandle(const std::shared_ptr<VProtocolParam> &param);
ProtocolHandle(const void *data, const size_t &length);
virtual ~ProtocolHandle();
void *GetProtocolDataBuff(void)
{
return mProtocolData;
}
size_t GetProtocolDataLength(void)
{
return mProtocolDataLength;
}
unsigned int GetSerialNumber(void)
{
return mProtocolSerialNumber;
}
/**
* @brief These functions assemble scattered data into continuous memory protocol packets and complete the sending
* of protocol packets.
*/
private:
ProtocolPacket CreatePocketWithSerialNumber(void);
void MallocPacketDataBuff(const void *data, const size_t dataLength, const short &command);
void MakeProtocolPacket(const std::shared_ptr<VProtocolParam> &param);
void MakeNoUserDataPacket(const std::shared_ptr<VProtocolParam> &param);
void MakeAskIpcMissionPacket(const std::shared_ptr<VProtocolParam> &param);
void MakeAskCutOffPowerSupplyPacket(const std::shared_ptr<VProtocolParam> &param);
void MakeAskFeedWatchDogPacket(const std::shared_ptr<VProtocolParam> &param);
void MakeAskSetFeedingCyclePacket(const std::shared_ptr<VProtocolParam> &param);
void MakeAskSetDateTimePacket(const std::shared_ptr<VProtocolParam> &param);
void MakeAskSetPirSensitivityPacket(const std::shared_ptr<VProtocolParam> &param);
void MakeAskControlInfraredLightPacket(const std::shared_ptr<VProtocolParam> &param);
void MakeAskGetPhotosensitivityPacket(const std::shared_ptr<VProtocolParam> &param);
void MakeReplyOtherSideSendIpcMissionPacket(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>
void MakeProtocolData(const std::shared_ptr<VProtocolParam> &param)
{
constexpr int PARAM_DATA_LENGTH = sizeof(T);
std::shared_ptr<ProtocolParam<T>> SetParam = std::dynamic_pointer_cast<ProtocolParam<T>>(param);
if (!SetParam) {
LogError("MakeProtocolData::Invalid param.\n");
return;
}
MallocPacketDataBuff(&(SetParam->mData), PARAM_DATA_LENGTH, param->mCommand);
}
private:
/**
* @brief These function implementations parse the received frame by frame continuous data into the data required by
* the application, completing the protocol unpacking.
*/
void AnalyzeProtocolPacket(void);
unsigned char ReplyOneBytePacketResult(const ProtocolPacket &packet);
void AnalyzeReplyResultPacket(const ProtocolPacket &packet);
void AnalyzeReplyIpcMissionPacket(const ProtocolPacket &packet);
void AnalyzeOtherSideSendIpcMissionPacket(const ProtocolPacket &packet);
void AnalyzeOtherSideSendHeartBeatPacket(const ProtocolPacket &packet);
void AnalyzeOtherSideSendGetIntervalStart(const ProtocolPacket &packet);
void AnalyzeOtherSideSendGetDataTime(const ProtocolPacket &packet);
void AnalyzeOtherSideSendGetPirSensitivity(const ProtocolPacket &packet);
private:
virtual void BigEndianConversion(ProtocolPacket &packet)
{
}
virtual short BigEndianConversion(const short &number)
{
return number;
}
virtual void HostByteOrderConversion(ProtocolPacket &packet)
{
}
virtual bool CheckoutTheCheckCode(const ProtocolPacket &packet);
protected:
std::shared_ptr<VProtocolParam> mParam;
std::map<PROTOCOL_COMMAND, MakePacketFunc> mMakePacketFunc;
std::map<PROTOCOL_COMMAND, AnalyzePacketFunc> mAnalyzePacketFunc;
unsigned char *mProtocolData;
size_t mProtocolDataLength;
/**
* @brief Single protocol package serial number.
*
*/
unsigned int mProtocolSerialNumber;
/**
* @brief The global protocol packet serial number is used to bind the data content of the one question one answer
* protocol.
*
*/
static unsigned int mSerialNumber;
static std::mutex mMutex;
public:
static void Init(void);
static void UnInit(void);
static std::shared_ptr<ProtocolHandle> CreateProtocolData(const std::shared_ptr<VProtocolParam> &param);
static void ProtocolAnalysis(const void *data, const size_t &length);
static size_t GetKeyHeadLength(void);
static StatusCode CheckHeader(void *header, size_t &headLength);
static StatusCode GetDataLength(const void *keyHead, const size_t &headLength, size_t &dataLength);
static char GetByteOrder(void);
static void PrintHexadecimalData(const void *buf, const size_t &bufLength, const char *log = nullptr);
};
#endif

57
utils/MediaAdapter/CMakeLists.txt Normal file
View File

@ -0,0 +1,57 @@
include(${CMAKE_SOURCE_DIR_IPCSDK}/build/global_config.cmake)
set(EXECUTABLE_OUTPUT_PATH ${EXEC_OUTPUT_PATH})
set(LIBRARY_OUTPUT_PATH ${LIBS_OUTPUT_PATH})
include_directories(
./src
./include
# ${UTILS_SOURCE_PATH}/LinuxApi/include
${UTILS_SOURCE_PATH}/StatusCode/include
${UTILS_SOURCE_PATH}/ModBusCRC16/include
${UTILS_SOURCE_PATH}/Log/include
)
# link_directories(
# ${EXTERNAL_SOURCE_PATH}/libconfig/libconfig-1.7.3/lib/.libs
# )
aux_source_directory(./src SRC_FILES)
set(TARGET_NAME MediaAdapter)
add_library(${TARGET_NAME} STATIC ${SRC_FILES})
target_link_libraries(${TARGET_NAME} StatusCode Log)
if ("${COMPILE_IMPROVE_SUPPORT}" MATCHES "true")
add_custom_target(
MediaAdapter_code_check
COMMAND ${CLANG_TIDY_EXE}
-checks='${CLANG_TIDY_CHECKS}'
--header-filter=.*
--system-headers=false
${SRC_FILES}
${CLANG_TIDY_CONFIG}
-p ${PLATFORM_PATH}/cmake-shell
WORKING_DIRECTORY ${UTILS_SOURCE_PATH}/MediaAdapter
)
file(GLOB_RECURSE HEADER_FILES *.h)
add_custom_target(
MediaAdapter_code_format
COMMAND ${CLANG_FORMAT_EXE}
-style=file
-i ${SRC_FILES} ${HEADER_FILES}
WORKING_DIRECTORY ${UTILS_SOURCE_PATH}/MediaAdapter
)
add_custom_command(
TARGET ${TARGET_NAME}
PRE_BUILD
COMMAND make MediaAdapter_code_check
COMMAND make MediaAdapter_code_format
WORKING_DIRECTORY ${PLATFORM_PATH}/cmake-shell/
)
endif()
define_file_name(${TARGET_NAME})
file(GLOB_RECURSE INSTALL_HEADER_FILES include/*.h)
install(FILES ${INSTALL_HEADER_FILES} DESTINATION include)

33
utils/MediaAdapter/include/MediaAdapter.h Normal file
View File

@ -0,0 +1,33 @@
/*
* Copyright (c) 2023 Fancy Code.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef MEDIA_ADAPTER_H
#define MEDIA_ADAPTER_H
#include "StatusCode.h"
#ifdef __cplusplus
extern "C" {
#endif
enum SENSOR_NUM
{
SENSOR_NUM_1 = 0,
SENSOR_NUM_2,
SENSOR_NUM_END
};
void *CreateMediaAdapter(const SENSOR_NUM num);
void TestApi(void *object);
void IMediaAdapterFree(void *object);
#ifdef __cplusplus
}
#endif
#endif

32
utils/MediaAdapter/src/IMediaAdapter.cpp Normal file
View File

@ -0,0 +1,32 @@
/*
* Copyright (c) 2023 Fancy Code.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "IMediaAdapter.h"
#include "ILog.h"
#include <string.h>
static const char *MEDIA_ADAPTER_NAME = "media_adapter";
const char inline *GetMediaAdapterModuleName(void)
{
return MEDIA_ADAPTER_NAME;
}
std::shared_ptr<IMediaAdapter> *NewIMediaAdapter(const SENSOR_NUM &num)
{
LogInfo("Create the uart device object.\n");
MeidaAdapter *impl = (MeidaAdapter *)malloc(sizeof(MeidaAdapter));
MeidaAdapter tmp;
memcpy((void *)impl, (void *)&tmp, sizeof(MeidaAdapter));
impl->mHeader.mCheckName = MEDIA_ADAPTER_NAME;
impl->mIMediaAdapter = std::make_shared<IMediaAdapter>();
return (std::shared_ptr<IMediaAdapter> *)(((char *)impl) + sizeof(MediaAdapterHeader));
}

39
utils/MediaAdapter/src/IMediaAdapter.h Normal file
View File

@ -0,0 +1,39 @@
/*
* Copyright (c) 2023 Fancy Code.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef I_MEDIA_ADAPTER_H
#define I_MEDIA_ADAPTER_H
#include "MediaAdapter.h"
#include <memory>
class IMediaAdapter
{
public:
IMediaAdapter() = default;
virtual ~IMediaAdapter() = default;
virtual void TestApi(void)
{
}
};
typedef struct media_adapter_header
{
const char *mCheckName;
} MediaAdapterHeader;
typedef struct media_adapter
{
MediaAdapterHeader mHeader;
std::shared_ptr<IMediaAdapter> mIMediaAdapter;
} MeidaAdapter;
const char *GetMediaAdapterModuleName(void);
std::shared_ptr<IMediaAdapter> *NewIMediaAdapter(const SENSOR_NUM &num);
#endif

52
utils/MediaAdapter/src/MediaAdapter.cpp Normal file
View File

@ -0,0 +1,52 @@
/*
* Copyright (c) 2023 Fancy Code.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "MediaAdapter.h"
#include "ILog.h"
#include "IMediaAdapter.h"
void *CreateMediaAdapter(const SENSOR_NUM num)
{
return NewIMediaAdapter(num);
}
static bool ObjectCheck(void *object)
{
if (nullptr == object) {
LogError("nullptr object!\n");
return false;
}
if (*((const char **)(((char *)object) - sizeof(IMediaAdapter))) != GetMediaAdapterModuleName()) {
LogError("Illegal object!\n");
return false;
}
return true;
}
void TestApi(void *object)
{
if (nullptr == object) {
LogError("nullptr object!\n");
return;
}
if (*((const char **)(((char *)object) - sizeof(IMediaAdapter))) != GetMediaAdapterModuleName()) {
LogError("Illegal object!\n");
return;
}
(*(std::shared_ptr<IMediaAdapter> *)object)->TestApi();
}
void IMediaAdapterFree(void *object)
{
if (ObjectCheck(object) == true) {
(*(std::shared_ptr<IMediaAdapter> *)object).reset();
free(((char *)object) - sizeof(IMediaAdapter));
}
}

46
utils/ModBusCRC16/CMakeLists.txt Normal file
View File

@ -0,0 +1,46 @@
include(${CMAKE_SOURCE_DIR_IPCSDK}/build/global_config.cmake)
set(EXECUTABLE_OUTPUT_PATH ${EXEC_OUTPUT_PATH})
set(LIBRARY_OUTPUT_PATH ${LIBS_OUTPUT_PATH})
include_directories(
./src
./include
${UTILS_SOURCE_PATH}/ModBusCRC16/include
${UTILS_SOURCE_PATH}/Log/include
)
#do not rely on any other library
#link_directories(
#)
aux_source_directory(./src SRC_FILES)
set(TARGET_NAME ModBusCRC16)
add_library(${TARGET_NAME} STATIC ${SRC_FILES})
target_link_libraries(${TARGET_NAME} Log)
if ("${COMPILE_IMPROVE_SUPPORT}" MATCHES "true")
add_custom_target(
ModBusCRC16_code_check
COMMAND ${CLANG_TIDY_EXE}
-checks='${CLANG_TIDY_CHECKS}'
--header-filter=.*
--system-headers=false
${SRC_FILES}
${CLANG_TIDY_CONFIG}
-p ${PLATFORM_PATH}/cmake-shell
WORKING_DIRECTORY ${UTILS_SOURCE_PATH}/ModBusCRC16
)
add_custom_command(
TARGET ${TARGET_NAME}
PRE_BUILD
COMMAND make ModBusCRC16_code_check
WORKING_DIRECTORY ${PLATFORM_PATH}/cmake-shell/
)
endif()
define_file_name(${TARGET_NAME})
file(GLOB_RECURSE INSTALL_HEADER_FILES include/*.h)
install(FILES ${INSTALL_HEADER_FILES} DESTINATION include)

24
utils/ModBusCRC16/include/ModBusCRC16.h Normal file
View File

@ -0,0 +1,24 @@
/*
* Copyright (c) 2023 Fancy Code.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef MODBUSCRC16_H
#define MODBUSCRC16_H
#ifdef __cplusplus
extern "C" {
#endif
unsigned short calculate_check_sum(const unsigned char *pData, unsigned short length);
#ifdef __cplusplus
}
#endif
#endif

69
utils/ModBusCRC16/src/ModBusCRC16.cpp Normal file
View File

@ -0,0 +1,69 @@
/*
* Copyright (c) 2023 Fancy Code.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "ModBusCRC16.h"
#include <stdio.h>
/* Table of CRC values for high–order byte */
unsigned char chCRCHi[] = {
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80,
0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1,
0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01,
0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40,
0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,
0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00,
0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80,
0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01,
0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80,
0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40};
/* Table of CRC values for low–order byte */
unsigned char chCRCLo[] = {
0x00, 0xC0, 0xC1, 0x01, 0xC3, 0x03, 0x02, 0xC2, 0xC6, 0x06, 0x07, 0xC7, 0x05, 0xC5, 0xC4, 0x04, 0xCC, 0x0C, 0x0D,
0xCD, 0x0F, 0xCF, 0xCE, 0x0E, 0x0A, 0xCA, 0xCB, 0x0B, 0xC9, 0x09, 0x08, 0xC8, 0xD8, 0x18, 0x19, 0xD9, 0x1B, 0xDB,
0xDA, 0x1A, 0x1E, 0xDE, 0xDF, 0x1F, 0xDD, 0x1D, 0x1C, 0xDC, 0x14, 0xD4, 0xD5, 0x15, 0xD7, 0x17, 0x16, 0xD6, 0xD2,
0x12, 0x13, 0xD3, 0x11, 0xD1, 0xD0, 0x10, 0xF0, 0x30, 0x31, 0xF1, 0x33, 0xF3, 0xF2, 0x32, 0x36, 0xF6, 0xF7, 0x37,
0xF5, 0x35, 0x34, 0xF4, 0x3C, 0xFC, 0xFD, 0x3D, 0xFF, 0x3F, 0x3E, 0xFE, 0xFA, 0x3A, 0x3B, 0xFB, 0x39, 0xF9, 0xF8,
0x38, 0x28, 0xE8, 0xE9, 0x29, 0xEB, 0x2B, 0x2A, 0xEA, 0xEE, 0x2E, 0x2F, 0xEF, 0x2D, 0xED, 0xEC, 0x2C, 0xE4, 0x24,
0x25, 0xE5, 0x27, 0xE7, 0xE6, 0x26, 0x22, 0xE2, 0xE3, 0x23, 0xE1, 0x21, 0x20, 0xE0, 0xA0, 0x60, 0x61, 0xA1, 0x63,
0xA3, 0xA2, 0x62, 0x66, 0xA6, 0xA7, 0x67, 0xA5, 0x65, 0x64, 0xA4, 0x6C, 0xAC, 0xAD, 0x6D, 0xAF, 0x6F, 0x6E, 0xAE,
0xAA, 0x6A, 0x6B, 0xAB, 0x69, 0xA9, 0xA8, 0x68, 0x78, 0xB8, 0xB9, 0x79, 0xBB, 0x7B, 0x7A, 0xBA, 0xBE, 0x7E, 0x7F,
0xBF, 0x7D, 0xBD, 0xBC, 0x7C, 0xB4, 0x74, 0x75, 0xB5, 0x77, 0xB7, 0xB6, 0x76, 0x72, 0xB2, 0xB3, 0x73, 0xB1, 0x71,
0x70, 0xB0, 0x50, 0x90, 0x91, 0x51, 0x93, 0x53, 0x52, 0x92, 0x96, 0x56, 0x57, 0x97, 0x55, 0x95, 0x94, 0x54, 0x9C,
0x5C, 0x5D, 0x9D, 0x5F, 0x9F, 0x9E, 0x5E, 0x5A, 0x9A, 0x9B, 0x5B, 0x99, 0x59, 0x58, 0x98, 0x88, 0x48, 0x49, 0x89,
0x4B, 0x8B, 0x8A, 0x4A, 0x4E, 0x8E, 0x8F, 0x4F, 0x8D, 0x4D, 0x4C, 0x8C, 0x44, 0x84, 0x85, 0x45, 0x87, 0x47, 0x46,
0x86, 0x82, 0x42, 0x43, 0x83, 0x41, 0x81, 0x80, 0x40};
/**
* @brief Calculate check sum.
*
* @param pData pointer of data
* @param length length of data
* @return unsigned short
*/
unsigned short calculate_check_sum(const unsigned char *pData, unsigned short length)
{
unsigned char CRCHi = 0xFF;
unsigned char CRCLo = 0xFF;
int uIndex;
while (length--) {
uIndex = CRCHi ^ *pData++;
CRCHi = CRCLo ^ chCRCHi[uIndex];
CRCLo = chCRCLo[uIndex];
}
// printf("CRCHi = 0x%x, CRCLo = 0x%x\n", CRCHi, CRCLo);
return (CRCHi << 8 | CRCLo);
}

55
utils/MultiProcess/CMakeLists.txt Normal file
View File

@ -0,0 +1,55 @@
include(${CMAKE_SOURCE_DIR_IPCSDK}/build/global_config.cmake)
set(EXECUTABLE_OUTPUT_PATH ${EXEC_OUTPUT_PATH})
set(LIBRARY_OUTPUT_PATH ${LIBS_OUTPUT_PATH})
include_directories(
./src
./include
${UTILS_SOURCE_PATH}/StatusCode/include
${UTILS_SOURCE_PATH}/Log/include
)
# link_directories(
# ${EXTERNAL_SOURCE_PATH}/libconfig/libconfig-1.7.3/lib/.libs
# )
aux_source_directory(./src SRC_FILES)
set(TARGET_NAME MultiProcess)
add_library(${TARGET_NAME} STATIC ${SRC_FILES})
target_link_libraries(${TARGET_NAME} StatusCode Log)
if ("${COMPILE_IMPROVE_SUPPORT}" MATCHES "true")
add_custom_target(
MultiProcess_code_check
COMMAND ${CLANG_TIDY_EXE}
-checks='${CLANG_TIDY_CHECKS}'
--header-filter=.*
--system-headers=false
${SRC_FILES}
${CLANG_TIDY_CONFIG}
-p ${PLATFORM_PATH}/cmake-shell
WORKING_DIRECTORY ${UTILS_SOURCE_PATH}/MultiProcess
)
file(GLOB_RECURSE HEADER_FILES *.h)
add_custom_target(
MultiProcess_code_format
COMMAND ${CLANG_FORMAT_EXE}
-style=file
-i ${SRC_FILES} ${HEADER_FILES}
WORKING_DIRECTORY ${UTILS_SOURCE_PATH}/MultiProcess
)
add_custom_command(
TARGET ${TARGET_NAME}
PRE_BUILD
COMMAND make MultiProcess_code_check
COMMAND make MultiProcess_code_format
WORKING_DIRECTORY ${PLATFORM_PATH}/cmake-shell/
)
endif()
define_file_name(${TARGET_NAME})
file(GLOB_RECURSE INSTALL_HEADER_FILES include/*.h)
install(FILES ${INSTALL_HEADER_FILES} DESTINATION include)

55
utils/MultiProcess/include/MultiProcess.h Normal file
View File

@ -0,0 +1,55 @@
/*
* Copyright (c) 2023 Fancy Code.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef MULTI_PROCESS_H
#define MULTI_PROCESS_H
#include "StatusCode.h"
#ifdef __cplusplus
extern "C" {
#endif
enum PROCESS_TYPE
{
PROCESS_TYPE_PRIMARY = 0,
PROCESS_TYPE_MINOR,
PROCESS_TYPE_END
};
typedef struct multi_process MultiProcess;
typedef struct multi_process
{
const StatusCode (*mMakeSharedData)(MultiProcess *, const unsigned int, const unsigned int);
const StatusCode (*mCleanSharedData)(MultiProcess *);
const StatusCode (*mGetReadableData)(MultiProcess *, void *, const unsigned int);
void (*mSetWritableData)(MultiProcess *, void *, const unsigned int);
void (*mFree)(void *);
} MultiProcess;
MultiProcess *CreateProcessObject(const enum PROCESS_TYPE name, const char *path, const int projectId);
// static inline const StatusCode IMakeSharedData(MultiProcess *object, const unsigned int readableSize,
// const unsigned int writableSize)
// {
// return object->mMakeSharedData(object, readableSize, writableSize);
// }
// static inline const StatusCode ICleanSharedData(MultiProcess *object) { return object->mCleanSharedData(object); }
// static inline const StatusCode IGetReadableData(MultiProcess *object, void *buf, const unsigned int bufLength)
// {
// return object->mGetReadableData(object, buf, bufLength);
// }
// static inline void ISetWritableData(MultiProcess *object, void *buf, const unsigned int bufLength)
// {
// object->mSetWritableData(object, buf, bufLength);
// }
// static inline void IShareDataFree(MultiProcess *object) { object->mFree(object); }
#ifdef __cplusplus
}
#endif
#endif

15
utils/MultiProcess/src/MultiProcess.cpp Normal file
View File

@ -0,0 +1,15 @@
/*
* Copyright (c) 2023 Fancy Code.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "MultiProcess.h"

13
utils/README.md Normal file
View File

@ -0,0 +1,13 @@
# 1. utils工具类库
&emsp;&emsp;工具类库，常用的功能单一的通用的功能独立模块或者半功能模块。
## 1.1. 完整功能工具类库
&emsp;&emsp;暴露头文件中的接口提供且仅提供了完整的独立功能的接口，使用者可直接使用完整的工具功能。往往暴露的头文件不会存在多余的用户数据接口和结构。
## 1.2. 半功能工具类库
&emsp;&emsp;暴露头文件中的接口无法完成独立功能，往往带着部分未实现的虚函数，需要使用者重载才能实现完整功能。
&emsp;&emsp;例如：McuProtocol类库，需要与读写数据模块组合封装成新类才能实现一个独立功能的模块。McuProtocol模块只完成了协议数据的组包和协议数据包的解析功能，需要与协议的读取/读取方式的模块组合封装成一个完整的功能模块。这样设计的初衷是让协议的处理和协议的收发解耦合，可以快速更换协议版本或者替换数据收发功能模块。

143
utils/Servers/CMakeLists.txt Executable file
View File

@ -0,0 +1,143 @@
include(${CMAKE_SOURCE_DIR_IPCSDK}/build/global_config.cmake)
set(EXECUTABLE_OUTPUT_PATH ${EXEC_OUTPUT_PATH})
set(LIBRARY_OUTPUT_PATH ${LIBS_OUTPUT_PATH})
include_directories(
./src
./include
${UTILS_SOURCE_PATH}/StatusCode/include
${UTILS_SOURCE_PATH}/Log/include
${EXTERNAL_SOURCE_PATH}/curl/curl-8.1.2/include
)
#do not rely on any other library
# link_directories(
# ${EXTERNAL_SOURCE_PATH}/curl/curl-8.1.2/build/lib
# )
aux_source_directory(./src SRC_FILES)
set(TARGET_NAME Servers)
add_library(${TARGET_NAME} STATIC ${SRC_FILES})
target_link_libraries(${TARGET_NAME} Log)
if(${CURL_OPENSSL_LIB_SHARED_ENABLE} MATCHES "false")
target_link_libraries(${TARGET_NAME} ${LIBS_OUTPUT_PATH}/libcurl.a)
target_link_libraries(${TARGET_NAME} ${LIBS_OUTPUT_PATH}/libssl.a)
target_link_libraries(${TARGET_NAME} ${LIBS_OUTPUT_PATH}/libcrypto.a dl pthread)
else()
target_link_libraries(${TARGET_NAME} ${LIBS_OUTPUT_PATH}/libcurl.so)
target_link_libraries(${TARGET_NAME} ${LIBS_OUTPUT_PATH}/libssl.so)
target_link_libraries(${TARGET_NAME} ${LIBS_OUTPUT_PATH}/libcrypto.so dl pthread)
endif()
# ------------------ openssl ------------------ start
execute_process(COMMAND sh build_openssl.sh WORKING_DIRECTORY ${EXTERNAL_SOURCE_PATH}/openssl/)
if(${CURL_OPENSSL_LIB_SHARED_ENABLE} MATCHES "false")
# set(OPENSSL_TAILOR no-asm no-async no-md2 no-mdc2 no-poly1305 no-blake2
# no-siphash no-sm3 no-rc2 no-rc4 no-rc5 no-idea no-aria no-bf no-cast
# no-camellia no-chacha no-ec no-sm2 no-dso
# no-err no-comp no-cms no-ts no-cmac no-ct
# no-hw-padlock no-nextprotoneg no-psk no-rfc3779 no-srtp
# no-dgram no-dynamic-engine no-ec2m no-filenames no-gost
# no-afalgeng no-async no-autoalginit no-autoerrinit no-capieng
# no-tests
# no-ssl-trace no-static-engine no-stdio no-threads no-deprecated no-makedepend
# no-multiblock)
else()
# set(OPENSSL_TAILOR no-asm no-tests)
endif()
if(${TARGET_PLATFORM} MATCHES ${DEFINE_LINUX})
set(OPENSSL_OS_PLATFORM "linux-x86_64")
else()
set(OPENSSL_OS_PLATFORM "linux-armv4")
# set(LINK_FLAGS "${LINK_FLAGS} -Wl,-rpath,${CURL_SHARED_LIBS_PATH}")
# set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${LINK_FLAGS}")
# set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${LINK_FLAGS}")
endif()
add_custom_target(
openssl
COMMAND echo "Build openssl."
COMMAND rm -rf ${EXTERNAL_SOURCE_PATH}/openssl/build
COMMAND ./Configure ${OPENSSL_TAILOR} ${OPENSSL_OS_PLATFORM} --prefix=${EXTERNAL_SOURCE_PATH}/openssl/build --openssldir=${EXTERNAL_SOURCE_PATH}/openssl/build --cross-compile-prefix=${CROSS_COMPILE_PREFIX} CC=gcc AR=ar
COMMAND make
COMMAND make install
WORKING_DIRECTORY ${EXTERNAL_SOURCE_PATH}/openssl/openssl-1.1.1s/
)
# ------------------ openssl ------------------ end
# ------------------ curl ------------------ start
execute_process(COMMAND sh build_curl.sh WORKING_DIRECTORY ${EXTERNAL_SOURCE_PATH}/curl/)
set(CURL_TAILOR --disable-dict --disable-file --disable-gopher
--disable-imap --disable-ldap --disable-pop3 --disable-rtmp
--disable-rtsp --disable-scp --disable-sftp --disable-smb
--disable-telnet --disable-tftp --disable-ipv6)
if(${TARGET_PLATFORM} MATCHES ${DEFINE_LINUX})
set(CURL_HOST "")
else()
set(CURL_HOST "--host=arm-linux")
endif()
add_custom_target(
curl
DEPENDS openssl
COMMAND echo "Build curl. openssl path = ${EXTERNAL_SOURCE_PATH}"
COMMAND ./configure --without-zlib --prefix=${EXTERNAL_SOURCE_PATH}/curl --with-ssl=${EXTERNAL_SOURCE_PATH}/openssl/build ${CURL_HOST} CC=${CMAKE_C_COMPILER}
COMMAND make
COMMAND cp ${EXTERNAL_SOURCE_PATH}/curl/curl-8.1.2/lib/.libs/lib*.a ${LIBS_OUTPUT_PATH}
COMMAND cp ${EXTERNAL_SOURCE_PATH}/openssl/build/lib/lib*.a ${LIBS_OUTPUT_PATH}
# COMMAND cp ${EXTERNAL_SOURCE_PATH}/curl/curl-8.1.2/lib/.libs/lib*.so* ${LIBS_OUTPUT_PATH}
# COMMAND cp ${EXTERNAL_SOURCE_PATH}/openssl/build/lib/lib*.so* ${LIBS_OUTPUT_PATH}
WORKING_DIRECTORY ${EXTERNAL_SOURCE_PATH}/curl/curl-8.1.2/
)
# ------------------ curl ------------------ end
add_custom_command(
OUTPUT ${EXTERNAL_SOURCE_PATH}/curl/curl-8.1.2/lib/.libs/libcurl.a
COMMAND make curl
WORKING_DIRECTORY ${PROJECT_ROOT_PATH}/cmake-shell/
)
add_custom_target(
compile_curl
DEPENDS ${EXTERNAL_SOURCE_PATH}/curl/curl-8.1.2/lib/.libs/libcurl.a
WORKING_DIRECTORY ${EXTERNAL_SOURCE_PATH}/curl/curl-8.1.2/
)
add_custom_command(
TARGET ${TARGET_NAME}
PRE_BUILD
COMMAND make compile_curl
WORKING_DIRECTORY ${PROJECT_ROOT_PATH}/cmake-shell/
)
if ("${COMPILE_IMPROVE_SUPPORT}" MATCHES "true")
add_custom_target(
Servers_code_check
COMMAND ${CLANG_TIDY_EXE}
-checks='${CLANG_TIDY_CHECKS}'
--header-filter=.*
--system-headers=false
${SRC_FILES}
${CLANG_TIDY_CONFIG}
-p ${PLATFORM_PATH}/cmake-shell
WORKING_DIRECTORY ${UTILS_SOURCE_PATH}/Servers
)
file(GLOB_RECURSE HEADER_FILES *.h)
add_custom_target(
Servers_code_format
COMMAND ${CLANG_FORMAT_EXE}
-style=file
-i ${SRC_FILES} ${HEADER_FILES}
WORKING_DIRECTORY ${UTILS_SOURCE_PATH}/Servers
)
add_custom_command(
TARGET ${TARGET_NAME}
PRE_BUILD
COMMAND make Servers_code_check
COMMAND make Servers_code_format
WORKING_DIRECTORY ${PLATFORM_PATH}/cmake-shell/
)
endif()
define_file_name(${TARGET_NAME})
file(GLOB_RECURSE INSTALL_HEADER_FILES include/*.h)
install(FILES ${INSTALL_HEADER_FILES} DESTINATION include)

109
utils/Servers/README.md Normal file
View File

@ -0,0 +1,109 @@
# 1. 服务器协议接口
## 1.1. 概述
&emsp;&emsp; 提供HTTP/FTP/SMTP协议的接口数据，使用**curl+openssl开源库**二次封装。
## 1.2. 开发过程记录
1. 先编译openssl，再编译curl，curl的构建配置需要指定openssl的输出文件目录，否则curl将会构建失败；
2. http协议，指定url，指定post数据，curl即可按照POST发送请求；
3. ftp/ftps协议对应不同的服务器IP，必须一一对应；
4. curl配置了忽略证书校验，未知有什么实际影响；
5. 分别对openssl和curl进行了裁剪；
## 1.3. 关于MQTT
&emsp;&emsp; curl源码包里并未提供MQTT相关的example，网上搜索编码示例未找到。
## 1.4. Servers协议栈模块构建
&emsp;&emsp; 使用SifarSDK的构建体系进行编译，编译curl时自动关联openssl进行编译。
* 配置文件（此处以/build/cmake/toolchain/linux.toolchain.cmake为示例）：
```
# ------------ build curl + openssl ------------ start
# 工具链前缀
set(CROSS_COMPILE_PREFIX "")
# 是否启动动态库（预留，暂未支持）
set(CURL_OPENSSL_LIB_SHARED_ENABLE "false")
# ------------ build curl + openssl ------------ end
```
* 项目根目录编译
```
make cmake
cd cmake-shell-linux/
make curl // 由于curl属于三方构建的开源库，首次需要先编译curl + openssl
make Servers
```
## 1.5. Example
头文件：servser.h
链接库：libServers.a,libLog.a
三方依赖库(依次按序)： libcurl.a,libssl.a,libcrypto.a
下述以FTP为例子：
```
TEST(ServersTest, FtpsUpload)
{
const char *url = "ftp://150.109.112.64/ServersTest";test/bin/ServersTest";
const char *uploadFile = "./ServersTest";
const char *user_password = "ftp_user:Sifar%123456";
ServerParam init = {
.logFlag = LOG_FLAG_ENABLE, // 开启curl日志
.sslVerifyFlag = SSL_VERIFY_DISABLE, //关闭ssl的证书校验功能
};
InitLog(LOG_EASYLOGGING, nullptr); // 初始化自研log库
ServersInit(init); // 初始化Servers模块
LogInfo("servers test start.\n");
ServerFtp *ftp = NewServersFtp(url, FTPS_FLAG_ENABLE); // 创建ftp的参数“句柄”
if (ftp)
{
ftp->user_password = (char *)user_password;
ftp->filePath = (char *)uploadFile;
FtpUpload(ftp); // 使用FTP上传文件
if (SERVERS_CODE_OK == ftp->code)
{
LogInfo("ftp succeed.\n");
}
else
{
LogError("ftp failed, code = %d.\n", static_cast<int>(ftp->code));
}
DeleteServersFtp(ftp); // 释放ftp“句柄”
}
UnInitLog();
}
```
**注意：**
* 必须调用servers_init()函数初始化Servers协议栈库；
* 必须使用模块接口创建对应的协议参数“句柄”，示例为new_servers_ftp();
* 必须释放协议参数“句柄”；
更多示例详见：/test/component/Servers/src/ServersTest.cpp
## 1.6. 测试
&emsp;&emsp; libServers.a自研代码通过asan测试，未存在内存安全相关漏洞。
测试用例详见：/test/component/Servers/src/ServersTest.cpp
* 测试用例编译
```
make cmake
cd cmake-shell-linux/
make ServersTest
```
## 1.7. 总结
* 实现http/https/ftp/ftps/smtp/smtps接口；
* 交叉编译测试ftp/ftps上传下载速率大概为1M/s（333DE芯片平台）；
* 裁剪openssl和curl后编译的demo大小 < 1.2M；
## 1.8. S530项目配置
* 工具链
```
set(CMAKE_C_COMPILER /opt/arm-ca9-linux-uclibcgnueabihf-8.4.01/usr/bin/arm-linux-gcc)
set(CMAKE_CXX_COMPILER /opt/arm-ca9-linux-uclibcgnueabihf-8.4.01/usr/bin/arm-linux-g++)
```
* curl + openssl
```
# ------------ build curl + openssl ------------ start
set(CROSS_COMPILE_PREFIX "/opt/arm-ca9-linux-uclibcgnueabihf-8.4.01/usr/bin/arm-linux-")
set(CURL_OPENSSL_LIB_SHARED_ENABLE "false")
set(CURL_SHARED_LIBS_PATH "/mnt/mmc")
# ------------ build curl + openssl ------------ end
```

110
utils/Servers/include/servers.h Normal file
View File

@ -0,0 +1,110 @@
/*
* Copyright (c) 2023 Fancy Code.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef SERVERS_H
#define SERVERS_H
#ifdef __cplusplus
extern "C" {
#endif
#define SERVERS_PARAM_NULL_MEANS_END NULL
#define SERVERS_NEVER_TIMEOUT 0
typedef enum
{
SERVERS_CODE_DEFAULT = -1,
SERVERS_CODE_OK = 0,
SERVERS_CODE_END
} ServersCode;
typedef enum
{
FTPS_FLAG_ENABLE = 0,
FTPS_FLAG_DISABLE,
FTPS_FLAG_END
} FtpsFlag;
typedef enum
{
LOG_FLAG_ENABLE = 0,
LOG_FLAG_DISABLE,
LOG_FLAG_END
} LogFlag;
typedef enum
{
SSL_VERIFY_ENABLE = 0,
SSL_VERIFY_DISABLE,
SSL_VERIFY_END
} SslFlag;
typedef struct ServersInit
{
LogFlag logFlag;
SslFlag sslVerifyFlag;
} ServerParam;
typedef struct servers_http
{
const char *url;
char *postData;
char *filePath;
char **header;
char *reply;
unsigned int replyLength;
int code;
} ServerHttp;
typedef struct servers_ftp
{
const char *url;
const FtpsFlag ftpsFlag;
char *user_password;
char *filePath;
unsigned int timeOutMs;
int code;
} ServerFtp;
typedef struct servers_smtp
{
const char *url;
const char *subject;
const char *from;
const char *to;
const char *userName;
const char *password;
const char *date;
char *inlineText;
char **toList;
unsigned int toListLength;
// char *text;
// unsigned int textLength;
char **attachment;
int code;
} ServerSmtp;
void ServersInit(ServerParam init);
void ServersUnInit(void);
// HTTP API
ServerHttp *NewServersHttp(const char *url);
void DeleteServersHttp(ServerHttp *ptr);
void HttpGet(ServerHttp *param);
void HttpPost(ServerHttp *param);
void HttpPostFile(ServerHttp *param);
void HttpPut(ServerHttp *param);
// FTP API
ServerFtp *NewServersFtp(const char *url, const FtpsFlag ftpsFlag);
void DeleteServersFtp(ServerFtp *ptr);
void FtpServersCheck(ServerFtp *param);
void FtpDownload(ServerFtp *param);
void FtpUpload(ServerFtp *param);
// SMTP API
ServerSmtp *new_servers_smtp(const char *url, const char *subject, const char *from, const char *to,
const char *userName, const char *password, const char *date);
void delete_servers_smtp(ServerSmtp *ptr);
void smtp_send_email(ServerSmtp *param);
#ifdef __cplusplus
}
#endif
#endif // !SERVERS_H

58
utils/Servers/src/curl_serve.c Normal file
View File

@ -0,0 +1,58 @@
/*
* Copyright (c) 2023 Fancy Code.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "curl_serve.h"
static ServerParam gCurlServe;
void SetVerboseLog(LogFlag flag)
{
gCurlServe.logFlag = flag;
}
void SetSslVerify(SslFlag flag)
{
gCurlServe.sslVerifyFlag = flag;
}
CURL *CurlEasyMake(void)
{
CURL *curl;
curl = curl_easy_init();
if (!curl) {
return curl;
}
if (SSL_VERIFY_DISABLE == gCurlServe.sslVerifyFlag) {
/*
* If you want to connect to a site who is not using a certificate that is
* signed by one of the certs in the CA bundle you have, you can skip the
* verification of the server's certificate. This makes the connection
* A LOT LESS SECURE.
*
* If you have a CA cert for the server stored someplace else than in the
* default bundle, then the CURLOPT_CAPATH option might come handy for
* you.
*/
curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0L);
/*
* If the site you are connecting to uses a different host name that what
* they have mentioned in their server certificate's commonName (or
* subjectAltName) fields, libcurl will refuse to connect. You can skip
* this check, but this will make the connection less secure.
*/
curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0L);
}
if (LOG_FLAG_ENABLE == gCurlServe.logFlag) {
/* Switch on full protocol/debug output */
curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
}
return curl;
}

Some files were not shown because too many files have changed in this diff Show More