From 5a42f21cf3a3c56160751115ea399b076f8807a2 Mon Sep 17 00:00:00 2001 From: zhaohe Date: Fri, 11 Jul 2025 20:32:25 +0800 Subject: [PATCH] Refactors DMAPP for drawbar disinfection machine Adds support for drawbar disinfection machines, including PWM blower control and air leak test functionality. Refactors blower and air compressor control into services and controllers for better modularity and testability. These services handle the hardware-specific implementations, while the controllers manage the application logic and protocol interactions. Updates board initialization and configuration to support the new hardware setup. Adds a flag to enable/disable period log output. --- .settings/language.settings.xml | 4 +- dap/dap.cfg | 3 + flush_by_dap.bat | 1 + usrc/app/dmapp.cpp | 132 ++++++----- usrc/app/dmapp.hpp | 2 - usrc/base/gflag/gflag.c | 10 +- usrc/base/gflag/gflag.h | 3 + usrc/dmapp_controler/air_compressor_controller.cpp | 56 +++++ usrc/dmapp_controler/air_compressor_controller.hpp | 19 ++ usrc/dmapp_controler/blower_controller.cpp | 71 ++++++ usrc/dmapp_controler/blower_controller.hpp | 21 ++ usrc/dmapp_service/air_compressor_ctrl_service.cpp | 93 ++++++++ usrc/dmapp_service/air_compressor_ctrl_service.hpp | 26 +++ usrc/dmapp_service/blower_ctrl_service.cpp | 258 +++++++++++++++++++++ usrc/dmapp_service/blower_ctrl_service.hpp | 37 +++ usrc/irq/hal_irq_processer.cpp | 20 ++ usrc/irq/hal_irq_processer.hpp | 6 + usrc/module/air_compressor_controller.hpp | 107 +++++---- usrc/module/blower_controller.hpp | 157 ------------- usrc/module/h2o2_sensor.cpp | 26 ++- usrc/module/module.hpp | 1 - usrc/project_configs.h | 2 +- .../public_cmd_processer.cpp | 5 + .../public_cmd_processer.hpp | 2 + 24 files changed, 774 insertions(+), 288 deletions(-) create mode 100644 dap/dap.cfg create mode 100644 flush_by_dap.bat create mode 100644 usrc/dmapp_controler/air_compressor_controller.cpp create mode 100644 usrc/dmapp_controler/air_compressor_controller.hpp create mode 100644 usrc/dmapp_controler/blower_controller.cpp create mode 100644 usrc/dmapp_controler/blower_controller.hpp create mode 100644 usrc/dmapp_service/air_compressor_ctrl_service.cpp create mode 100644 usrc/dmapp_service/air_compressor_ctrl_service.hpp create mode 100644 usrc/dmapp_service/blower_ctrl_service.cpp create mode 100644 usrc/dmapp_service/blower_ctrl_service.hpp create mode 100644 usrc/irq/hal_irq_processer.cpp create mode 100644 usrc/irq/hal_irq_processer.hpp delete mode 100644 usrc/module/blower_controller.hpp diff --git a/.settings/language.settings.xml b/.settings/language.settings.xml index 3bac06a..3a389b8 100644 --- a/.settings/language.settings.xml +++ b/.settings/language.settings.xml @@ -5,7 +5,7 @@ - + @@ -16,7 +16,7 @@ - + diff --git a/dap/dap.cfg b/dap/dap.cfg new file mode 100644 index 0000000..ba46fe8 --- /dev/null +++ b/dap/dap.cfg @@ -0,0 +1,3 @@ +adapter driver cmsis-dap +transport select swd +source [find target/stm32f4x.cfg] \ No newline at end of file diff --git a/flush_by_dap.bat b/flush_by_dap.bat new file mode 100644 index 0000000..cb3b5d5 --- /dev/null +++ b/flush_by_dap.bat @@ -0,0 +1 @@ +openocd.exe -f ./dap/dap.cfg -c "init; reset halt; wait_halt; flash write_image erase ./Debug/transmit_disinfection_micro.hex" -c reset -c shutdown \ No newline at end of file diff --git a/usrc/app/dmapp.cpp b/usrc/app/dmapp.cpp index 1196d24..5dc7dd9 100644 --- a/usrc/app/dmapp.cpp +++ b/usrc/app/dmapp.cpp @@ -1,26 +1,18 @@ #include "dmapp.hpp" #include "board/hal/zhal_initer.hpp" -/** - * @brief - * 小空间和大空间硬件一样 - * 管道式----- - * 液路控制板 - * 相比于大空间消毒机，不同的点: - * 1.增加比例阀控制 - * 2.空压机通道控制 - * 功率板 - * 相比于大空间消毒机，不同的点: - * 1. 风机改成鼓风机(可控风速) - * 拉杆箱------ - * 液路控制板 - * 功率板 - */ +// +#include "dmapp_controler/blower_controller.hpp" +#include "dmapp_service/blower_ctrl_service.hpp" +#include "dmapp_controler/air_compressor_controller.hpp" +#include "dmapp_service/air_compressor_ctrl_service.hpp" using namespace iflytop; using namespace transmit_disfection_protocol; #define TAG "DMAPP" - +// +// 参考 https://iflytop1.feishu.cn/wiki/GF8LwUjeJiNJ9DkcuEEcZLZMnTf?fromScene=spaceOverview 进行配置 +// DisinfectionApp* DisinfectionApp::ins() { static DisinfectionApp instance; return &instance; @@ -35,12 +27,17 @@ void DisinfectionApp::initialize() { // small space disinfection machine, // pipe disinfection machine, // DT600B, - ZASSERT(PORT::isLargeSpaceDM() || PORT::isSamllSpaceDM() || PORT::isPipeDM() || PORT::isDT600B()); + ZASSERT(PORT::isLargeSpaceDM() || PORT::isSamllSpaceDM() || PORT::isPipeDM() || PORT::isDT600B() || PORT::isDrawBarDM()); /*********************************************************************************************************************** * 加热片 * ***********************************************************************************************************************/ - if (PORT::isPowerCtrlBoard() && (PORT::isLargeSpaceDM() || PORT::isSamllSpaceDM() || PORT::isPipeDM() || PORT::isDT600B())) { + if (PORT::isPowerCtrlBoard() // + && (PORT::isLargeSpaceDM() || // + PORT::isSamllSpaceDM() || // + PORT::isPipeDM() || // + PORT::isDT600B() || // + PORT::isDrawBarDM())) { LargeSpaceDmPowerCtrlBoardHal::HADC1_INIT(); heaterCtrler.initialize(PC7, &hadc1, ADC_CHANNEL_2, &hadc1, ADC_CHANNEL_9); } @@ -48,22 +45,18 @@ void DisinfectionApp::initialize() { /*********************************************************************************************************************** * 风机 * ***********************************************************************************************************************/ - if (PORT::isPowerCtrlBoard() && (PORT::isLargeSpaceDM() || PORT::isSamllSpaceDM() || PORT::isDT600B())) { - LargeSpaceDmPowerCtrlBoardHal::HADC1_INIT(); - blowerCtrler.initialize(PC5, &hadc1, ADC_CHANNEL_1); - } // - else if (PORT::isPowerCtrlBoard() && (PORT::isPipeDM())) { - LargeSpaceDmPowerCtrlBoardHal::HADC1_INIT(); - LargeSpaceDmPowerCtrlBoardHal::HUART2_INIT(9600, UART_STOPBITS_1); - blowerCtrler.initializeAsHighPowerUartBlower(PC5, &huart2, &hadc1, ADC_CHANNEL_1); + + if (BlowerCtrlService::isSupport()) { + BlowerCtrlService::initialize(); // 初始化风机控制硬件 + BlowerController::initialize(); // 解析相关协议 } /*********************************************************************************************************************** * 空压机 * ***********************************************************************************************************************/ - if (PORT::isPowerCtrlBoard() && (PORT::isLargeSpaceDM() || PORT::isSamllSpaceDM() || PORT::isPipeDM() || PORT::isDT600B())) { - LargeSpaceDmPowerCtrlBoardHal::HADC1_INIT(); - airComCtrler.initialize(PC3, &hadc1, ADC_CHANNEL_0); + if (AirCompressorCtrlService::isSupport()) { + AirCompressorCtrlService::initialize(); // 初始化空压机控制硬件 + AirCompressorController::initialize(); // 解析相关协议 } /*********************************************************************************************************************** @@ -141,35 +134,60 @@ void DisinfectionApp::initialize() { if (PORT::isLiquidCtrlBoard() && (PORT::isPipeDM())) { static air_leak_test_mode_t airLeakTestMode = kAirLeakTestMode_disinfection; + if (PORT::isPipeDM()) { + static ZGPIO eValve0; + static ZGPIO eValve1; + static ZGPIO eValve2; + eValve0.initAsOutput(PD14, kxs_gpio_nopull, true, false); + eValve1.initAsOutput(PD15, kxs_gpio_nopull, true, false); + eValve2.initAsOutput(PC6, kxs_gpio_nopull, true, false); // 空气通道电磁阀 - static ZGPIO eValve0; - static ZGPIO eValve1; - static ZGPIO eValve2; - eValve0.initAsOutput(PD14, kxs_gpio_nopull, true, false); - eValve1.initAsOutput(PD15, kxs_gpio_nopull, true, false); - eValve2.initAsOutput(PC6, kxs_gpio_nopull, true, false); // 空气通道电磁阀 - - REG_LAMADA_FN(kfn_air_leak_test_set_mode, [&](ProcessContext* cxt) { - if (GET_PARAM(0) == kAirLeakTestMode_disinfection) { - eValve2.write(0); // 内管路 - eValve0.write(0); // 联通 - eValve1.write(0); // 联通 - } else if (GET_PARAM(0) == kAirLeakTestMode_inflation) { - eValve2.write(1); // 联通空气 - eValve0.write(0); // 联通 - eValve1.write(0); // 联通 - } else if (GET_PARAM(0) == kAirLeakTestMode_leakTest) { - eValve2.write(0); // 内管路 - eValve0.write(1); // 封闭 - eValve1.write(1); // 封闭 - } - airLeakTestMode = (air_leak_test_mode_t)GET_PARAM(0); - zcanbus_send_ack(cxt->packet, NULL, 0); - }); - REG_LAMADA_FN(kfn_air_leak_test_get_mode, [&](ProcessContext* cxt) { - int32_t mode = airLeakTestMode; - zcanbus_send_ack(cxt->packet, mode); - }); + REG_LAMADA_FN(kfn_air_leak_test_set_mode, [&](ProcessContext* cxt) { + if (GET_PARAM(0) == kAirLeakTestMode_disinfection) { + eValve2.write(0); // 内管路 + eValve0.write(0); // 联通 + eValve1.write(0); // 联通 + } else if (GET_PARAM(0) == kAirLeakTestMode_inflation) { + eValve2.write(1); // 联通空气 + eValve0.write(0); // 联通 + eValve1.write(0); // 联通 + } else if (GET_PARAM(0) == kAirLeakTestMode_leakTest) { + eValve2.write(0); // 内管路 + eValve0.write(1); // 封闭 + eValve1.write(1); // 封闭 + } + airLeakTestMode = (air_leak_test_mode_t)GET_PARAM(0); + zcanbus_send_ack(cxt->packet, NULL, 0); + }); + REG_LAMADA_FN(kfn_air_leak_test_get_mode, [&](ProcessContext* cxt) { + int32_t mode = airLeakTestMode; + zcanbus_send_ack(cxt->packet, mode); + }); + } else if (PORT::isDrawBarDM()) { + static ZGPIO eValve0; + static ZGPIO eValve1; + eValve0.initAsOutput(PD15, kxs_gpio_nopull, false, false); + eValve1.initAsOutput(PC6, kxs_gpio_nopull, false, false); + + REG_LAMADA_FN(kfn_air_leak_test_set_mode, [&](ProcessContext* cxt) { + if (GET_PARAM(0) == kAirLeakTestMode_disinfection) { + eValve0.write(1); + eValve1.write(1); + } else if (GET_PARAM(0) == kAirLeakTestMode_inflation) { + eValve0.write(0); + eValve1.write(1); + } else if (GET_PARAM(0) == kAirLeakTestMode_leakTest) { + eValve0.write(1); + eValve1.write(0); + } + airLeakTestMode = (air_leak_test_mode_t)GET_PARAM(0); + zcanbus_send_ack(cxt->packet, NULL, 0); + }); + REG_LAMADA_FN(kfn_air_leak_test_get_mode, [&](ProcessContext* cxt) { + int32_t mode = airLeakTestMode; + zcanbus_send_ack(cxt->packet, mode); + }); + } } /** diff --git a/usrc/app/dmapp.hpp b/usrc/app/dmapp.hpp index 948791d..122ab56 100644 --- a/usrc/app/dmapp.hpp +++ b/usrc/app/dmapp.hpp @@ -27,8 +27,6 @@ using namespace transmit_disfection_protocol; class DisinfectionApp { public: HeaterController heaterCtrler; - BlowerController blowerCtrler; - AirCompressorController airComCtrler; H2O2Sensor h2o2Sensor; ZGPIO evaporationBinWS; // 蒸发仓水浸 diff --git a/usrc/base/gflag/gflag.c b/usrc/base/gflag/gflag.c index 2b31ee5..588a5ee 100644 --- a/usrc/base/gflag/gflag.c +++ b/usrc/base/gflag/gflag.c @@ -5,9 +5,10 @@ #include "cmsis_os.h" -bool gInitErrorFlag = false; -bool gEnableReportFlag = true; -uint8_t gResetFlag = 0; +bool gInitErrorFlag = false; +bool gEnableReportFlag = true; +uint8_t gResetFlag = 0; +bool gEnablePeriodLogFlag = false; void gBoardFlagSetResetFlag() { vPortEnterCritical(); @@ -20,3 +21,6 @@ void gBoardFlagClearResetFlag() { vPortExitCritical(); } bool gBoardFlagGetResetFlag() { return gResetFlag; } + +bool gBoardFlagGetEnablePeriodLogFlag() { return gEnablePeriodLogFlag; } +void gBoardFlagSetEnablePeriodLogFlag(bool enable) { gEnablePeriodLogFlag = enable; } \ No newline at end of file diff --git a/usrc/base/gflag/gflag.h b/usrc/base/gflag/gflag.h index 5c0b3aa..6681f88 100644 --- a/usrc/base/gflag/gflag.h +++ b/usrc/base/gflag/gflag.h @@ -17,6 +17,9 @@ void gBoardFlagSetResetFlag(); void gBoardFlagClearResetFlag(); bool gBoardFlagGetResetFlag(); +bool gBoardFlagGetEnablePeriodLogFlag(); +void gBoardFlagSetEnablePeriodLogFlag(bool enable); + #ifdef __cplusplus } #endif diff --git a/usrc/dmapp_controler/air_compressor_controller.cpp b/usrc/dmapp_controler/air_compressor_controller.cpp new file mode 100644 index 0000000..cda58b6 --- /dev/null +++ b/usrc/dmapp_controler/air_compressor_controller.cpp @@ -0,0 +1,56 @@ +#include "air_compressor_controller.hpp" + +#include "base/appdep.hpp" +#include "dmapp_service/air_compressor_ctrl_service.hpp" + +using namespace iflytop; +using namespace transmit_disfection_protocol; + +#define TAG "AirCompressor" + +void AirCompressorController::initialize() { + REG_LAMADA_FN(kfn_air_compressor_ctrl, [](ProcessContext* cxt) { fn_air_compressor_ctrl(cxt); }); + REG_LAMADA_FN(kfn_air_compressor_ctrl_safe_valve, [](ProcessContext* cxt) { fn_air_compressor_ctrl_safe_valve(cxt); }); + REG_LAMADA_FN(kfn_air_compressor_read_ei, [](ProcessContext* cxt) { fn_air_compressor_read_ei(cxt); }); + REG_LAMADA_FN(kfn_air_compressor_is_open, [](ProcessContext* cxt) { fn_air_compressor_is_open(cxt); }); + REG_LAMADA_FN(kfn_air_compressor_read_type, [](ProcessContext* cxt) { fn_air_compressor_read_type(cxt); }); + REG_LAMADA_FN(kfn_air_compressor_read_state, [](ProcessContext* cxt) { fn_air_compressor_read_state(cxt); }); +} +void AirCompressorController::fn_air_compressor_ctrl(ProcessContext* cxt) { + if (PRAAM_LEN() != 1) { + ZLOGE(TAG, "fn_air_compressor_ctrl: invalid param num, %d", PRAAM_LEN()); + zcanbus_send_errorack(cxt->packet, kerr_invalid_param_num); + return; + } + int32_t val = GET_PARAM(0); + ZLOGI(TAG, "fn_air_compressor_ctrl, val: %d", val); + AirCompressorCtrlService::ctrl(val); + zcanbus_send_ack(cxt->packet, NULL, 0); +} +void AirCompressorController::fn_air_compressor_ctrl_safe_valve(ProcessContext* cxt) { + // Safe valve control is not implemented yet + zcanbus_send_ack(cxt->packet, NULL, 0); +} +void AirCompressorController::fn_air_compressor_read_ei(ProcessContext* cxt) { // + int32_t ei = AirCompressorCtrlService::readCurrent(); + ZLOGI(TAG, "fn_air_compressor_read_ei, ei: %d", ei); + zcanbus_send_ack(cxt->packet, ei); +} +void AirCompressorController::fn_air_compressor_is_open(ProcessContext* cxt) { // + int32_t power = AirCompressorCtrlService::readPowerLevel(); + ZLOGI(TAG, "fn_air_compressor_is_open, power: %d", power); + zcanbus_send_ack(cxt->packet, power); +} +void AirCompressorController::fn_air_compressor_read_type(ProcessContext* cxt) { // + int32_t type = AirCompressorCtrlService::getType(); + ZLOGI(TAG, "fn_air_compressor_read_type, type: %d", type); + zcanbus_send_ack(cxt->packet, type); +} + +void AirCompressorController::fn_air_compressor_read_state(ProcessContext* cxt) { // + static int16_t state[10] = {0}; + memset(state, 0, sizeof(state)); // Clear the state array + int32_t maxnum = 0; + AirCompressorCtrlService::readState(state, &maxnum); + zcanbus_send_ack(cxt->packet, (uint8_t*)state, maxnum * sizeof(int16_t)); +} \ No newline at end of file diff --git a/usrc/dmapp_controler/air_compressor_controller.hpp b/usrc/dmapp_controler/air_compressor_controller.hpp new file mode 100644 index 0000000..ca8547a --- /dev/null +++ b/usrc/dmapp_controler/air_compressor_controller.hpp @@ -0,0 +1,19 @@ +#pragma once +#include "base/appdep.hpp" + +namespace iflytop { +using namespace transmit_disfection_protocol; +class AirCompressorController { + public: + static void initialize(); + + static void fn_air_compressor_ctrl(ProcessContext* cxt); + static void fn_air_compressor_ctrl_safe_valve(ProcessContext* cxt); + static void fn_air_compressor_read_ei(ProcessContext* cxt); + // static void fn_air_compressor_read_ei_adc_raw(ProcessContext* cxt); + static void fn_air_compressor_is_open(ProcessContext* cxt); + static void fn_air_compressor_read_type(ProcessContext* cxt); + static void fn_air_compressor_read_state(ProcessContext* cxt); +}; + +} // namespace iflytop diff --git a/usrc/dmapp_controler/blower_controller.cpp b/usrc/dmapp_controler/blower_controller.cpp new file mode 100644 index 0000000..787ac6a --- /dev/null +++ b/usrc/dmapp_controler/blower_controller.cpp @@ -0,0 +1,71 @@ +#include "blower_controller.hpp" + +#include "base/appdep.hpp" +#include "dmapp_service/blower_ctrl_service.hpp" + +using namespace iflytop; +using namespace transmit_disfection_protocol; +#define TAG "BlowerController" + +void BlowerController::initialize() { + REG_LAMADA_FN(kfn_blower_ctrl, [](ProcessContext* cxt) { fn_blower_ctrl(cxt); }); + REG_LAMADA_FN(kfn_blower_ctrl_safe_valve, [](ProcessContext* cxt) { fn_blower_ctrl_safe_valve(cxt); }); + REG_LAMADA_FN(kfn_blower_read_ei, [](ProcessContext* cxt) { fn_blower_read_ei(cxt); }); + REG_LAMADA_FN(kfn_blower_is_open, [](ProcessContext* cxt) { fn_blower_is_open(cxt); }); + REG_LAMADA_FN(kfn_blower_read_state, [](ProcessContext* cxt) { fn_blower_is_open(cxt); }); +} + +void BlowerController::fn_blower_ctrl(ProcessContext* cxt) { + if (PRAAM_LEN() != 1) { + ZLOGE(TAG, "fn_blower_ctrl: invalid param num, %d", PRAAM_LEN()); + zcanbus_send_errorack(cxt->packet, kerr_invalid_param_num); + return; + } + + int32_t val = GET_PARAM(0); + if (val > 100) val = 100; + if (val < 0) val = 0; + + ZLOGI(TAG, "fn_blower_ctrl, val: %d", val); + BlowerCtrlService::ctrl(val); + zcanbus_send_ack(cxt->packet, NULL, 0); +} +void BlowerController::fn_blower_ctrl_safe_valve(ProcessContext* cxt) { zcanbus_send_ack(cxt->packet, NULL, 0); } +void BlowerController::fn_blower_read_ei(ProcessContext* cxt) { + int32_t ei = 0; + blower_state_t state = {0}; + int32_t ret = BlowerCtrlService::readState(&state); + if (ret != 0) { + ZLOGI(TAG, "fn_blower_read_ei error, %d", ret); + zcanbus_send_errorack(cxt->packet, ret); + return; + } + ei = state.blowerI; + ZLOGI(TAG, "fn_blower_read_ei, ei: %d", ei); + zcanbus_send_ack(cxt->packet, ei); +} + +void BlowerController::fn_blower_is_open(ProcessContext* cxt) { // + int32_t power = BlowerCtrlService::readState()->power; + ZLOGI(TAG, "fn_blower_is_open, power: %d", power); + zcanbus_send_ack(cxt->packet, power); +} + +void BlowerController::fn_blower_read_type(ProcessContext* cxt) { + int32_t type = BlowerCtrlService::getType(); + if (type == kNotSet) { + zcanbus_send_errorack(cxt->packet, -1); + return; + } + ZLOGI(TAG, "fn_blower_read_type, type: %d", type); + zcanbus_send_ack(cxt->packet, (int32_t)type); +} + +void BlowerController::fn_blower_read_state(ProcessContext* cxt) { + static int16_t state[10]; + int32_t maxnum = 5; + memset(state, 0, sizeof(state)); // Clear the state array + + BlowerCtrlService::readState(state, &maxnum); + zcanbus_send_ack(cxt->packet, (uint8_t*)state, maxnum * sizeof(int16_t)); +} diff --git a/usrc/dmapp_controler/blower_controller.hpp b/usrc/dmapp_controler/blower_controller.hpp new file mode 100644 index 0000000..29aa7ca --- /dev/null +++ b/usrc/dmapp_controler/blower_controller.hpp @@ -0,0 +1,21 @@ +#pragma once +#include "base/appdep.hpp" + +namespace iflytop { +using namespace transmit_disfection_protocol; +class BlowerController { + public: + static void initialize(); + + static void fn_blower_ctrl(ProcessContext* cxt); + static void fn_blower_ctrl_safe_valve(ProcessContext* cxt); + static void fn_blower_read_ei(ProcessContext* cxt); + static void fn_blower_is_open(ProcessContext* cxt); + + // static void fn_blower_read_ei_adc_raw(ProcessContext* cxt); + // static void fn_blower_is_error(ProcessContext* cxt); + static void fn_blower_read_type(ProcessContext* cxt); + static void fn_blower_read_state(ProcessContext* cxt); +}; + +} // namespace iflytop diff --git a/usrc/dmapp_service/air_compressor_ctrl_service.cpp b/usrc/dmapp_service/air_compressor_ctrl_service.cpp new file mode 100644 index 0000000..a9d7faf --- /dev/null +++ b/usrc/dmapp_service/air_compressor_ctrl_service.cpp @@ -0,0 +1,93 @@ +#include "air_compressor_ctrl_service.hpp" + +#include "base/appdep.hpp" +#include "board\public_board.hpp" +// +#include "board\hal\dbdm_power_ctrl_board.hpp" +#include "board\hal\large_space_dm_power_ctrl_board.hpp" +#include "irq\hal_irq_processer.hpp" + +using namespace iflytop; +using namespace transmit_disfection_protocol; + +typedef struct { + ZGPIO ctrlGpio; // 控制引脚 + ZADC iAdc; // 电流采集 +} IOAirCompressor_t; + +typedef struct { + int32_t mark; +} MiniPwmAirPump_t; + +static AirCompressorType_t m_type = kAirCompressorType_notSet; +static IOAirCompressor_t m_ioAirCompressor; +static MiniPwmAirPump_t m_miniPwmAirPump; + +static int32_t m_power_level; + +// ZASSERT(!m_isInitialized); +// m_ctrlGpio.initAsOutput(ctrlGpio, kxs_gpio_nopull, true, false); +// m_iAdc.initialize("AirComAdc", iadc, ich); +// m_isInitialized = true; + +// AppPeriodTaskMgr::ins()->regTask("AC-ADC", [this]() { periodTask(); }, 1000); + +void AirCompressorCtrlService::initialize() { + if (PORT::isPowerCtrlBoard() && (PORT::isLargeSpaceDM() || PORT::isSamllSpaceDM() || PORT::isPipeDM() || PORT::isDT600B())) { + LargeSpaceDmPowerCtrlBoardHal::HADC1_INIT(); + m_ioAirCompressor.ctrlGpio.initAsOutput(PC3, kxs_gpio_nopull, true, false); // 初始化空压机控制引脚 + m_ioAirCompressor.iAdc.initialize("AirComAdc", &hadc1, ADC_CHANNEL_0); // 初始化空压机电流采集 + m_type = kAirCompressorType_IO; // IO控制的空压机 + + AppPeriodTaskMgr::ins()->regTask( + "AC-ADC", + []() { + m_ioAirCompressor.iAdc.updateAdcValToCache(); // 周期性更新空压机电流采集值 + }, + 500); // 每秒更新一次 + } + // + else if (PORT::isPowerCtrlBoard() && PORT::isDrawBarDM()) { + // PC6 pwm控制具体控制见 + // PC4 反馈每圈1个脉冲 + } +} +bool AirCompressorCtrlService::isSupport() { + if (PORT::isPowerCtrlBoard() && (PORT::isLargeSpaceDM() || PORT::isSamllSpaceDM() || PORT::isPipeDM() || PORT::isDT600B())) { + return true; // 支持空压机控制 + } + return false; +} + +int AirCompressorCtrlService::getType() { + return m_type; // 返回已设置的空压机类型 +} +int32_t AirCompressorCtrlService::ctrl(int32_t val) { + if (m_type == kAirCompressorType_IO) { + m_ioAirCompressor.ctrlGpio.write(val); // 控制空压机开关 + m_power_level = val; // 更新功率等级 + return 0; // 成功 + } + return kerr_function_not_support; // 不支持的空压机类型 +} +void AirCompressorCtrlService::readState(int16_t* state, int32_t* maxnum) { + if (m_type == kAirCompressorType_IO) { + state[0] = m_power_level; + state[1] = airCompressorAdcToCurrent(m_ioAirCompressor.iAdc.getCacheVal()); + *maxnum = 2; // 返回空压机状态 + } else { + state[0] = m_power_level; + *maxnum = 1; // 返回空压机状态 + } +} + +int32_t AirCompressorCtrlService::readCurrent() { + if (m_type == kAirCompressorType_IO) { + return airCompressorAdcToCurrent(m_ioAirCompressor.iAdc.getCacheVal()); // 返回空压机电流值 + } + return 0; +} + +int32_t AirCompressorCtrlService::readPowerLevel() { + return m_power_level; // 返回空压机功率等级 +} diff --git a/usrc/dmapp_service/air_compressor_ctrl_service.hpp b/usrc/dmapp_service/air_compressor_ctrl_service.hpp new file mode 100644 index 0000000..44a09ea --- /dev/null +++ b/usrc/dmapp_service/air_compressor_ctrl_service.hpp @@ -0,0 +1,26 @@ +#pragma once +#include "base/appdep.hpp" + +namespace iflytop { +using namespace transmit_disfection_protocol; + +typedef enum { + kAirCompressorType_notSet, + kAirCompressorType_IO, + kAirCompressorType_MiniPwmAirPump, +} AirCompressorType_t; + +class AirCompressorCtrlService { + public: + static void initialize(); + static bool isSupport(); + + static int getType(); + static int32_t ctrl(int32_t val); + static void readState(int16_t* state, int32_t* maxnum); + + static int32_t readCurrent(); + static int32_t readPowerLevel(); +}; + +} // namespace iflytop diff --git a/usrc/dmapp_service/blower_ctrl_service.cpp b/usrc/dmapp_service/blower_ctrl_service.cpp new file mode 100644 index 0000000..54bc851 --- /dev/null +++ b/usrc/dmapp_service/blower_ctrl_service.cpp @@ -0,0 +1,258 @@ +#include "blower_ctrl_service.hpp" + +#include "board\public_board.hpp" +// +#include "board\hal\dbdm_power_ctrl_board.hpp" +#include "board\hal\large_space_dm_power_ctrl_board.hpp" +#include "irq\hal_irq_processer.hpp" + +using namespace iflytop; +using namespace transmit_disfection_protocol; + +#define TAG "BlowerCtrlService" + +#define IOBLOWER_ERROR_CURRENT_MIN 500 +#define IOBLOWER_ERROR_CURRENT_MAX 3000 +#define IOBLOWER_ERROR_JUDGE_TIMES 5 + +typedef struct { + ZGPIO ctrlGpio; + ZADC iadc; +} IOBlower; + +typedef struct { + ModbusBlockHost ctrlModbusMaster; + ZGPIO coolingFanCtrlGpio; // 控制冷却风扇 + ZADC coolingFanIAdc; // 冷却风扇电流采集 + + uint16_t subErrorCode = 0; // 从设备错误码 +} HighPowerUartBlower; + +typedef struct { + TIM_HandleTypeDef* htim; + uint32_t channle; + ZGPIO enGpio; + ZGPIO fbGpio; + int32_t blowerFbCnt; +} PwmBlower; + +static IOBlower ioblower; +static HighPowerUartBlower highPowerUartBlower; +static PwmBlower miniPwmBlower; + +static BlowerType_t m_blowerType = kIOBlower; +static bool m_isopen = false; +static int32_t m_powerVal = 0; +static int32_t m_open_ticket = 0; + +static zmutex lock = {"BlowerCtrlService"}; + +void mini_pwm_blower_ctrl(int32_t duty) { + duty = 100 - duty; + if (duty < 0) duty = 0; + if (duty > 100) duty = 100; + + TIM_OC_InitTypeDef sConfigOC = {0}; + sConfigOC.OCMode = TIM_OCMODE_PWM1; + sConfigOC.Pulse = duty / 100.0 * __HAL_TIM_GET_AUTORELOAD(miniPwmBlower.htim); + sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH; + sConfigOC.OCFastMode = TIM_OCFAST_DISABLE; + sConfigOC.OCIdleState = TIM_OCIDLESTATE_RESET; + sConfigOC.OCNIdleState = TIM_OCNIDLESTATE_RESET; + + HAL_TIM_PWM_ConfigChannel(miniPwmBlower.htim, &sConfigOC, miniPwmBlower.channle); + HAL_TIM_PWM_Stop(miniPwmBlower.htim, miniPwmBlower.channle); + HAL_TIM_PWM_Start(miniPwmBlower.htim, miniPwmBlower.channle); + + miniPwmBlower.enGpio.setState(duty != 0); +} + +bool BlowerCtrlService::isSupport() { + if (PORT::isPowerCtrlBoard() && (PORT::isLargeSpaceDM() || PORT::isSamllSpaceDM() || PORT::isDT600B())) { + return true; + } else if (PORT::isPowerCtrlBoard() && (PORT::isPipeDM())) { + return true; + } else if (PORT::isPowerCtrlBoard() && (PORT::isDrawBarDM())) { + return true; + } + return false; +} + +void BlowerCtrlService::initialize() { + lock.init(); + + if (PORT::isPowerCtrlBoard() && (PORT::isLargeSpaceDM() || PORT::isSamllSpaceDM() || PORT::isDT600B())) { + /*********************************************************************************************************************** + * IOBblower * + ***********************************************************************************************************************/ + + m_blowerType = kIOBlower; + + LargeSpaceDmPowerCtrlBoardHal::HADC1_INIT(); + ioblower.ctrlGpio.initAsOutput(PC5, kxs_gpio_nopull, true, false); + ioblower.iadc.initialize("Blower-iadc", &hadc1, ADC_CHANNEL_1); + AppPeriodTaskMgr::ins()->regTask("AC-ADC", []() { ioblower.iadc.updateAdcValToCache(); }, 500); + } // + else if (PORT::isPowerCtrlBoard() && (PORT::isPipeDM())) { + /*********************************************************************************************************************** + * HighPowerUartBlower * + ***********************************************************************************************************************/ + + m_blowerType = kHighPowerUartBlower; + + LargeSpaceDmPowerCtrlBoardHal::HADC1_INIT(); + LargeSpaceDmPowerCtrlBoardHal::HUART2_INIT(9600, UART_STOPBITS_1); + + highPowerUartBlower.coolingFanCtrlGpio.initAsOutput(PC5, kxs_gpio_nopull, true, false); + highPowerUartBlower.ctrlModbusMaster.initialize(&huart2); + highPowerUartBlower.coolingFanIAdc.initialize("Blower-coolingFan-iadc", &hadc1, ADC_CHANNEL_1); + + AppPeriodTaskMgr::ins()->regTask( + "HighPowerUartBlower-Monitor", + []() { + highPowerUartBlower.coolingFanIAdc.updateAdcValToCache(); + { + uint16_t regval = 0; + bool status = highPowerUartBlower.ctrlModbusMaster.readReg03(1, 0x8000, ®val, 50); + if (status) { + highPowerUartBlower.subErrorCode = regval; + } else { + highPowerUartBlower.subErrorCode = 0xffff; + } + } + }, + 500); + + } // 拉杆箱 + else if (PORT::isPowerCtrlBoard() && (PORT::isDrawBarDM())) { + /*********************************************************************************************************************** + * PWMBLower * + ***********************************************************************************************************************/ + // 宁波锚点调速风机 + + m_blowerType = kMiniPwmBlower; + DBDMPowerCtrlBoard::HTIM3_INIT(); // TIM3 + miniPwmBlower.htim = &htim3; // TIM1 + miniPwmBlower.channle = TIM_CHANNEL_3; // TIM1_CH1 PC8 + + miniPwmBlower.fbGpio.initAsInput(PC9, kxs_gpio_nopull, kxs_gpio_rising_irq, false /*mirror*/); // PC9 + miniPwmBlower.enGpio.initAsOutput(PC10, kxs_gpio_nopull, true, false); // PC10 + + AppPeriodTaskMgr::ins()->regTask("HighPowerUartBlower-Monitor", []() { miniPwmBlower.blowerFbCnt = PC9_IRQ_CNT; }, 30); + + } else { + ZLOGE(TAG, "BlowerCtrlService::initialize() not support this board"); + return; + } +} + +int BlowerCtrlService::getType() { return m_blowerType; } + +/** + * @brief 风机控制 + * + * @param val + */ +int32_t BlowerCtrlService::ctrl(int32_t val) { + zlock_guard l(lock); + if (val > 100) val = 100; + if (val < 0) val = 0; + + bool toOpen = val > 0 ? true : false; + int toPowerVal = val; + + switch (m_blowerType) { + /*********************************************************************************************************************** + * kIOBlower * + ***********************************************************************************************************************/ + case kIOBlower: + ioblower.ctrlGpio.write(toOpen); + break; + + /*********************************************************************************************************************** + * kHighPowerUartBlower * + ***********************************************************************************************************************/ + case kHighPowerUartBlower: + + highPowerUartBlower.coolingFanCtrlGpio.write(toOpen); + if (toOpen) { + if (!highPowerUartBlower.ctrlModbusMaster.writeReg06(1, 0x2000, 1, 50)) return kerr_subdevice_overtime; + } else { + if (!highPowerUartBlower.ctrlModbusMaster.writeReg06(1, 0x2000, 6, 50)) return kerr_subdevice_overtime; + } + break; + + /*********************************************************************************************************************** + * kMiniPwmBlower * + ***********************************************************************************************************************/ + case kMiniPwmBlower: + mini_pwm_blower_ctrl(toPowerVal); + break; + + default: + return kerr_function_not_support; + } + + // sync state + m_open_ticket = zos_get_tick(); + m_isopen = toOpen; + m_powerVal = toPowerVal; + return 0; +} +blower_state_t* BlowerCtrlService::readState() { + static blower_state_t state; + readState(&state); + return &state; +} + +int32_t BlowerCtrlService::readState(blower_state_t* state) { + zlock_guard l(lock); + + switch (m_blowerType) { + case kIOBlower: + state->power = m_powerVal; + state->blowerI = blowserAdcToCurrent(ioblower.iadc.getCacheVal()); + break; + case kHighPowerUartBlower: + state->power = m_powerVal; + state->coolfanI = blowserAdcToCurrent(highPowerUartBlower.coolingFanIAdc.getCacheVal()); + state->subDeviceErrorCode = highPowerUartBlower.subErrorCode; + break; + case kMiniPwmBlower: + state->power = m_powerVal; + state->blowerFbCNT = miniPwmBlower.blowerFbCnt; + break; + default: + break; + } + return 0; +} + +void BlowerCtrlService::readState(int16_t* state, int32_t* maxnum) { + zlock_guard l(lock); + switch (m_blowerType) { + case kIOBlower: + state[0] = m_powerVal; + state[1] = blowserAdcToCurrent(ioblower.iadc.getCacheVal()); + *maxnum = 2; // + break; + case kHighPowerUartBlower: + state[0] = m_powerVal; + state[1] = blowserAdcToCurrent(highPowerUartBlower.coolingFanIAdc.getCacheVal()); + state[2] = highPowerUartBlower.subErrorCode; + *maxnum = 3; // + + break; + case kMiniPwmBlower: + state[0] = m_powerVal; + state[1] = miniPwmBlower.blowerFbCnt; + *maxnum = 2; // + break; + default: + state[0] = m_powerVal; + *maxnum = 1; + + break; + } + return; +} diff --git a/usrc/dmapp_service/blower_ctrl_service.hpp b/usrc/dmapp_service/blower_ctrl_service.hpp new file mode 100644 index 0000000..8165499 --- /dev/null +++ b/usrc/dmapp_service/blower_ctrl_service.hpp @@ -0,0 +1,37 @@ +#pragma once +#include "base/appdep.hpp" + +namespace iflytop { +typedef enum { + kNotSet, + kIOBlower, + kHighPowerUartBlower, + kMiniPwmBlower, +} BlowerType_t; + +typedef struct { + int16_t power; + int16_t blowerI; // 风机电流 ma + int16_t coolfanI; // 冷却风扇电流 ma + int16_t blowerFbCNT; // 风机反馈CNT + int16_t coolfanFbCnt; // 冷却风扇反馈CNT + int16_t subDeviceErrorCode; // 从设备错误码 +} blower_state_t; + +class BlowerCtrlService { + public: + static void initialize(); + static bool isSupport(); + + static int getType(); + + static int32_t ctrl(int32_t val); + static int32_t readState(blower_state_t* state); + static blower_state_t* readState(); + + static void readState(int16_t* state, int32_t* maxnum); + + +}; + +} // namespace iflytop diff --git a/usrc/irq/hal_irq_processer.cpp b/usrc/irq/hal_irq_processer.cpp new file mode 100644 index 0000000..48694a5 --- /dev/null +++ b/usrc/irq/hal_irq_processer.cpp @@ -0,0 +1,20 @@ +#include "hal_irq_processer.hpp" + +#include "board\public_board.hpp" + +using namespace iflytop; + +uint32_t PC9_IRQ_CNT; +uint32_t PC4_IRQ_CNT; + +extern "C" { +void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin) { + if (PORT::isPowerCtrlBoard() && PORT::isDrawBarDM()) { + if (GPIO_Pin == GPIO_PIN_9) { + PC9_IRQ_CNT++; + } else if (GPIO_Pin == GPIO_PIN_4) { + PC4_IRQ_CNT++; + } + } +} +} \ No newline at end of file diff --git a/usrc/irq/hal_irq_processer.hpp b/usrc/irq/hal_irq_processer.hpp new file mode 100644 index 0000000..34adb68 --- /dev/null +++ b/usrc/irq/hal_irq_processer.hpp @@ -0,0 +1,6 @@ +#pragma once + +#include "base/appdep.hpp" + +extern uint32_t PC9_IRQ_CNT; +extern uint32_t PC4_IRQ_CNT; diff --git a/usrc/module/air_compressor_controller.hpp b/usrc/module/air_compressor_controller.hpp index ee5ae70..1130a90 100644 --- a/usrc/module/air_compressor_controller.hpp +++ b/usrc/module/air_compressor_controller.hpp @@ -1,54 +1,53 @@ -#pragma once -#include "base/appdep.hpp" - -namespace iflytop { -using namespace transmit_disfection_protocol; - -class AirCompressorController { - ZGPIO m_ctrlGpio; - ZADC m_iAdc; - bool m_isInitialized = false; - - public: - static AirCompressorController* ins() { - static AirCompressorController instance; - return &instance; - } - - void initialize(Pin_t ctrlGpio, ADC_HandleTypeDef* iadc, uint32_t ich) { - ZASSERT(!m_isInitialized); - m_ctrlGpio.initAsOutput(ctrlGpio, kxs_gpio_nopull, true, false); - m_iAdc.initialize("AirComAdc", iadc, ich); - m_isInitialized = true; - - AppPeriodTaskMgr::ins()->regTask("AC-ADC", [this]() { periodTask(); }, 1000); - // BIND - BIND_FN(AirCompressorController, this, fn_air_compressor_ctrl); - BIND_FN(AirCompressorController, this, fn_air_compressor_ctrl_safe_valve); - BIND_FN(AirCompressorController, this, fn_air_compressor_read_ei); - BIND_FN(AirCompressorController, this, fn_air_compressor_read_ei_adc_raw); - BIND_FN(AirCompressorController, this, fn_air_compressor_is_open); - } - bool isInitialized() { return m_isInitialized; } - - public: - void open(bool val) { m_ctrlGpio.write(val); } - bool isOpen() { return m_ctrlGpio.read(); } - - private: - // PP - void fn_air_compressor_ctrl(ProcessContext* cxt) { // - m_ctrlGpio.write(GET_PARAM(0)); - zcanbus_send_ack(cxt->packet, NULL, 0); - } - void fn_air_compressor_ctrl_safe_valve(ProcessContext* cxt) { zcanbus_send_ack(cxt->packet, NULL, 0); } - void fn_air_compressor_read_ei(ProcessContext* cxt) { zcanbus_send_ack(cxt->packet, airCompressorAdcToCurrent(m_iAdc.getCacheVal())); } - void fn_air_compressor_read_ei_adc_raw(ProcessContext* cxt) { zcanbus_send_ack(cxt->packet, m_iAdc.getCacheVal()); } - void fn_air_compressor_is_open(ProcessContext* cxt) { zcanbus_send_ack(cxt->packet, m_ctrlGpio.read()); } - - private: - void periodTask() { m_iAdc.updateAdcValToCache(); } -}; -} // namespace iflytop - -#pragma once +// #pragma once +// #include "base/appdep.hpp" + +// namespace iflytop { +// using namespace transmit_disfection_protocol; + +// class AirCompressorController { +// ZGPIO m_ctrlGpio; +// ZADC m_iAdc; +// bool m_isInitialized = false; + +// public: +// static AirCompressorController* ins() { +// static AirCompressorController instance; +// return &instance; +// } + +// void initialize(Pin_t ctrlGpio, ADC_HandleTypeDef* iadc, uint32_t ich) { +// ZASSERT(!m_isInitialized); +// m_ctrlGpio.initAsOutput(ctrlGpio, kxs_gpio_nopull, true, false); +// m_iAdc.initialize("AirComAdc", iadc, ich); +// m_isInitialized = true; + +// AppPeriodTaskMgr::ins()->regTask("AC-ADC", [this]() { periodTask(); }, 1000); +// // BIND +// BIND_FN(AirCompressorController, this, fn_air_compressor_ctrl); +// BIND_FN(AirCompressorController, this, fn_air_compressor_ctrl_safe_valve); +// BIND_FN(AirCompressorController, this, fn_air_compressor_read_ei); +// BIND_FN(AirCompressorController, this, fn_air_compressor_read_ei_adc_raw); +// BIND_FN(AirCompressorController, this, fn_air_compressor_is_open); +// } +// bool isInitialized() { return m_isInitialized; } + +// public: +// void open(bool val) { m_ctrlGpio.write(val); } +// bool isOpen() { return m_ctrlGpio.read(); } + +// private: +// // PP +// void fn_air_compressor_ctrl(ProcessContext* cxt) { // +// m_ctrlGpio.write(GET_PARAM(0)); +// zcanbus_send_ack(cxt->packet, NULL, 0); +// } +// void fn_air_compressor_ctrl_safe_valve(ProcessContext* cxt) { zcanbus_send_ack(cxt->packet, NULL, 0); } +// void fn_air_compressor_read_ei(ProcessContext* cxt) { zcanbus_send_ack(cxt->packet, airCompressorAdcToCurrent(m_iAdc.getCacheVal())); } +// void fn_air_compressor_read_ei_adc_raw(ProcessContext* cxt) { zcanbus_send_ack(cxt->packet, m_iAdc.getCacheVal()); } +// void fn_air_compressor_is_open(ProcessContext* cxt) { zcanbus_send_ack(cxt->packet, m_ctrlGpio.read()); } + +// private: +// void periodTask() { m_iAdc.updateAdcValToCache(); } +// }; +// } // namespace iflytop + diff --git a/usrc/module/blower_controller.hpp b/usrc/module/blower_controller.hpp deleted file mode 100644 index 9e4d0b9..0000000 --- a/usrc/module/blower_controller.hpp +++ /dev/null @@ -1,157 +0,0 @@ -#pragma once -#include "base/appdep.hpp" - -namespace iflytop { -using namespace transmit_disfection_protocol; - -typedef enum { - kIOBlower, - kHighPowerUartBlower, - kMiniPwmBlower, -} BlowerType_t; - -class BlowerController { - BlowerType_t m_blowerType = kIOBlower; - - // kIOBlower - ZGPIO m_ctrlGpio; - - // kHighPowerUartBlower - ModbusBlockHost m_modbusblock; - - // kMiniPwmBlower - TIM_HandleTypeDef* m_miniPwmBlower_htim; - uint32_t m_miniPwmBlower_channle; - ZGPIO m_miniPwmBlower_enGpio; - ZGPIO m_miniPwmBlower_fbGpio; - - ZADC m_iadc; - bool m_iadcIsInit = false; - - bool m_isInitialized = false; - bool isopen = false; - - public: - void initialize(Pin_t ctrlGpio, ADC_HandleTypeDef* iadc, uint32_t ich) { - m_ctrlGpio.initAsOutput(ctrlGpio, kxs_gpio_nopull, true, false); - m_iadc.initialize("Blower-iadc", iadc, ich); - AppPeriodTaskMgr::ins()->regTask("AC-ADC", [this]() { periodTask(); }, 1000); - m_blowerType = kIOBlower; - m_isInitialized = true; - bindFn(); - } - - void initializeAsHighPowerUartBlower(Pin_t ctrlGpio, UART_HandleTypeDef* huart, ADC_HandleTypeDef* iadc, uint32_t ich) { - m_ctrlGpio.initAsOutput(ctrlGpio, kxs_gpio_nopull, true, false); - m_modbusblock.initialize(huart); - // m_modbusblock.enableDump(true)upda; - m_iadc.initialize("Blower-iadc", iadc, ich); - AppPeriodTaskMgr::ins()->regTask("AC-ADC", [this]() { periodTask(); }, 1000); - m_blowerType = kHighPowerUartBlower; - m_isInitialized = true; - bindFn(); - } - void initializeAsMiniPwmBlower(TIM_HandleTypeDef* htim, uint32_t channel, Pin_t enGpio, Pin_t fbGpio) { - m_miniPwmBlower_htim = htim; - m_miniPwmBlower_channle = channel; - m_miniPwmBlower_enGpio.initAsOutput(enGpio, kxs_gpio_nopull, true, false); - m_miniPwmBlower_fbGpio.initAsInput(fbGpio, kxs_gpio_nopull, kxs_gpio_rising_irq, false); - AppPeriodTaskMgr::ins()->regTask("AC-ADC", [this]() { periodTask(); }, 1000); - m_blowerType = kMiniPwmBlower; - m_isInitialized = true; - bindFn(); - } - - bool isInitialized() { return m_isInitialized; } - - void bindFn() { - BIND_FN(BlowerController, this, fn_blower_ctrl); - BIND_FN(BlowerController, this, fn_blower_ctrl_safe_valve); - BIND_FN(BlowerController, this, fn_blower_read_ei); - BIND_FN(BlowerController, this, fn_blower_is_error); - BIND_FN(BlowerController, this, fn_blower_read_ei_adc_raw); - BIND_FN(BlowerController, this, fn_blower_is_open); - } - - /*********************************************************************************************************************** - * FN * - ***********************************************************************************************************************/ - void blower_ctrl(int32_t val) {} - void blower_ctrl_safe_valve(int32_t val) {} - int32_t blower_read_ei() { - if (m_blowerType == kIOBlower || m_blowerType == kHighPowerUartBlower) { - return blowserAdcToCurrent(m_iadc.getCacheVal()); - } - return 0; - } - int32_t blower_read_iadc() { - if (m_blowerType == kIOBlower || m_blowerType == kHighPowerUartBlower) { - return m_iadc.getCacheVal(); - } - return 0; - } - - int32_t blower_is_error() { - // TODO: 栏杆箱消毒机添加故障检测 - return 0; - } - - void periodTask() { - if (m_iadc.isInited()) m_iadc.updateAdcValToCache(); - } - - /*********************************************************************************************************************** - * PP * - ***********************************************************************************************************************/ - void fn_blower_ctrl(ProcessContext* cxt) { // - int32_t val = GET_PARAM(0); - if (m_blowerType == kIOBlower) { - m_ctrlGpio.write(val); - zcanbus_send_ack(cxt->packet, NULL, 0); - isopen = GET_PARAM(0) > 0 ? true : false; - } else if (m_blowerType == kHighPowerUartBlower) { - m_ctrlGpio.write(val); - bool suc = val > 0 ? m_modbusblock.writeReg06(1, 0x2000, 1, 50) : m_modbusblock.writeReg06(1, 0x2000, 6, 50); - if (suc) { - m_ctrlGpio.write(val); - zcanbus_send_ack(cxt->packet, NULL, 0); - isopen = GET_PARAM(0) > 0 ? true : false; - } else { - zcanbus_send_errorack(cxt->packet, kerr_subdevice_overtime); - } - - } else if (m_blowerType == kMiniPwmBlower) { - mini_pwm_blower_ctrl(val); - } - } - void fn_blower_ctrl_safe_valve(ProcessContext* cxt) { // - blower_ctrl_safe_valve(GET_PARAM(0)); - zcanbus_send_ack(cxt->packet, NULL, 0); - } - void fn_blower_read_ei(ProcessContext* cxt) { zcanbus_send_ack(cxt->packet, blower_read_ei()); } - void fn_blower_read_ei_adc_raw(ProcessContext* cxt) { zcanbus_send_ack(cxt->packet, m_iadc.getCacheVal()); } - void fn_blower_is_error(ProcessContext* cxt) { zcanbus_send_ack(cxt->packet, blower_is_error()); } - void fn_blower_is_open(ProcessContext* cxt) { zcanbus_send_ack(cxt->packet, isopen); } - - private: - void mini_pwm_blower_ctrl(int32_t duty) { - duty = 100 - duty; - if (duty < 0) duty = 0; - if (duty > 100) duty = 100; - - TIM_OC_InitTypeDef sConfigOC = {0}; - sConfigOC.OCMode = TIM_OCMODE_PWM1; - sConfigOC.Pulse = duty / 100.0 * __HAL_TIM_GET_AUTORELOAD(m_miniPwmBlower_htim); - sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH; - sConfigOC.OCFastMode = TIM_OCFAST_DISABLE; - sConfigOC.OCIdleState = TIM_OCIDLESTATE_RESET; - sConfigOC.OCNIdleState = TIM_OCNIDLESTATE_RESET; - - HAL_TIM_PWM_ConfigChannel(m_miniPwmBlower_htim, &sConfigOC, m_miniPwmBlower_channle); - HAL_TIM_PWM_Stop(m_miniPwmBlower_htim, m_miniPwmBlower_channle); - HAL_TIM_PWM_Start(m_miniPwmBlower_htim, m_miniPwmBlower_channle); - - m_miniPwmBlower_enGpio.write(duty != 0); - } -}; -} // namespace iflytop diff --git a/usrc/module/h2o2_sensor.cpp b/usrc/module/h2o2_sensor.cpp index 5706618..bd9f306 100644 --- a/usrc/module/h2o2_sensor.cpp +++ b/usrc/module/h2o2_sensor.cpp @@ -3,7 +3,7 @@ #include "stm32components/zcanreceiver/zcanreceiver.hpp" using namespace iflytop; -#define TAG "LSDMPowerCtrlBoard" +#define TAG "H2O2Sensor" using namespace transmit_disfection_protocol; static osThreadId H2O2CaptureThreadId; @@ -87,16 +87,20 @@ int32_t H2O2Sensor::h2o2_sensor_data(report_h2o2_data_t* readdata) { readdata->wet_bulb_temp = sensordata.wet_bulb_temp; readdata->enthalpy = sensordata.enthalpy; readdata->rs = 0; - ZLOGI(TAG, "ppm:%d(adc:%d), rh:%d, temp:%d, df_ptemp:%d, ah:%d, mr:%d, wbt:%d, eh:%d", // - readdata->h2o2, // - h2o2adcData, // - sensordata.rh, // - sensordata.temp, // - sensordata.df_ptemp, // - sensordata.ah, // - sensordata.mr, // - sensordata.wet_bulb_temp, // - sensordata.enthalpy); + + if (gBoardFlagGetEnablePeriodLogFlag()) { + ZLOGI(TAG, "ppm:%d(adc:%d), rh:%d, temp:%d, df_ptemp:%d, ah:%d, mr:%d, wbt:%d, eh:%d", // + readdata->h2o2, // + h2o2adcData, // + sensordata.rh, // + sensordata.temp, // + sensordata.df_ptemp, // + sensordata.ah, // + sensordata.mr, // + sensordata.wet_bulb_temp, // + sensordata.enthalpy); + } + return 0; } diff --git a/usrc/module/module.hpp b/usrc/module/module.hpp index be7fc18..844a4e1 100644 --- a/usrc/module/module.hpp +++ b/usrc/module/module.hpp @@ -1,7 +1,6 @@ #pragma once // #include "air_compressor_controller.hpp" -#include "blower_controller.hpp" #include "h2o2_sensor.hpp" #include "heater_controller.hpp" #include "proportional_valve_ctrl.hpp" diff --git a/usrc/project_configs.h b/usrc/project_configs.h index ad95293..da17095 100644 --- a/usrc/project_configs.h +++ b/usrc/project_configs.h @@ -20,7 +20,7 @@ #define PROJECT "transmit_disinfection_micro_re" // 工程名称 #define SN_HEADER "SN" // SN号前缀 #define DEBUG_UART huart1 // 调试串口 -#define DEBUG_LIGHT_GPIO PE0 // 调试指示灯 +#define DEBUG_LIGHT_GPIO PF9 // 调试指示灯 #define H2O2_SENSOR_BOARD_DEBUG_LIGHT_GPIO PE2 // 过氧化氢板-调试指示灯 #define BOARD_TYPE_ID_FLASH_ADD 0x080E0000 diff --git a/usrc/protocol_processer_impl/public_cmd_processer.cpp b/usrc/protocol_processer_impl/public_cmd_processer.cpp index b763d8a..d1868ad 100644 --- a/usrc/protocol_processer_impl/public_cmd_processer.cpp +++ b/usrc/protocol_processer_impl/public_cmd_processer.cpp @@ -12,6 +12,7 @@ void PublicCmdProcesser::initialize() { REG_FN(fn_clear_reset_flag); REG_FN(fn_enable_report); REG_FN(fn_reset_board); + REG_FN(fn_enable_period_log); } void PublicCmdProcesser::fn_read_board_info(ProcessContext* cxt) { @@ -61,3 +62,7 @@ void PublicCmdProcesser::fn_enable_report(ProcessContext* cxt) { zcanbus_send_ack(cxt->packet, NULL, 0); } void PublicCmdProcesser::fn_reset_board(ProcessContext* cxt) { NVIC_SystemReset(); } + +void PublicCmdProcesser::fn_enable_period_log(ProcessContext* cxt) { + gBoardFlagSetEnablePeriodLogFlag(GET_PARAM(0)); +} diff --git a/usrc/protocol_processer_impl/public_cmd_processer.hpp b/usrc/protocol_processer_impl/public_cmd_processer.hpp index c04b9a6..d6077bb 100644 --- a/usrc/protocol_processer_impl/public_cmd_processer.hpp +++ b/usrc/protocol_processer_impl/public_cmd_processer.hpp @@ -26,6 +26,8 @@ class PublicCmdProcesser { void fn_clear_reset_flag(ProcessContext* cxt); void fn_enable_report(ProcessContext* cxt); void fn_reset_board(ProcessContext* cxt); + void fn_enable_period_log(ProcessContext* cxt); + }; } // namespace iflytop \ No newline at end of file