project_boditech_vidas_a8000_v3
/
a8000_subboard_sdk
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

update

master
zhaohe 2 years ago
parent
cab4a096a0
commit
d41001f5f9
5 changed files with 107 additions and 55 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 4
      components/water_cooling_temperature_control_module/pwm_ctrl_module.cpp
  2. 3
      components/water_cooling_temperature_control_module/pwm_ctrl_module.hpp
  3. 124
      components/water_cooling_temperature_control_module/water_cooling_temperature_control_module.cpp
  4. 29
      components/water_cooling_temperature_control_module/water_cooling_temperature_control_module.hpp
  5. 2
      components/zprotocols/zcancmder_v2

4
components/water_cooling_temperature_control_module/pwm_ctrl_module.cpp
View File

@ -3,11 +3,11 @@
#include "sdk\components\zprotocols\zcancmder_v2\api\errorcode.hpp" #include "sdk\components\zprotocols\zcancmder_v2\api\errorcode.hpp"
using namespace iflytop; using namespace iflytop;
void PWMSpeedCtrlModule::initialize(config_t* pcfg, bool enablefbcheck) {
void PWMSpeedCtrlModule::initialize(config_t* pcfg) {
ZASSERT(pcfg); ZASSERT(pcfg);
ZASSERT(pcfg->fanCtrlTim); ZASSERT(pcfg->fanCtrlTim);
cfg = *pcfg; cfg = *pcfg;
m_enablefbcheck = enablefbcheck;
m_enablefbcheck = pcfg->enablefbcheck;
if (m_enablefbcheck) { if (m_enablefbcheck) {
for (int32_t i = 0; i < ZARRAY_SIZE(cfg.fanFBGpioCfg); i++) { for (int32_t i = 0; i < ZARRAY_SIZE(cfg.fanFBGpioCfg); i++) {

3
components/water_cooling_temperature_control_module/pwm_ctrl_module.hpp
View File

@ -29,6 +29,7 @@ class PWMSpeedCtrlModule {
int32_t fan0Channel[4]; int32_t fan0Channel[4];
ZGPIO::InputGpioCfg_t fanFBGpioCfg[4]; ZGPIO::InputGpioCfg_t fanFBGpioCfg[4];
ZGPIO::OutputGpioCfg_t fanPowerGpioCfg[4]; ZGPIO::OutputGpioCfg_t fanPowerGpioCfg[4];
bool enablefbcheck;
} config_t; } config_t;
typedef struct { typedef struct {
@ -56,7 +57,7 @@ class PWMSpeedCtrlModule {
public: public:
PWMSpeedCtrlModule(){}; PWMSpeedCtrlModule(){};
void initialize(config_t* fangroup, bool enablefbcheck = false);
void initialize(config_t* fangroup);
int32_t startModule(int32_t duty); int32_t startModule(int32_t duty);
int32_t stopModule(); int32_t stopModule();

124
components/water_cooling_temperature_control_module/water_cooling_temperature_control_module.cpp
View File

@ -7,6 +7,10 @@ using namespace iflytop;
#define TAG "WaterCoolingTemperatureControlModule" #define TAG "WaterCoolingTemperatureControlModule"
#define ACTION_TEST_PELTIER_SET_POWER_LEVEL 1
#define ACTION_TEST_PUMP_SET_LEVEL 2
#define ACTION_TEST_PUMP_FAN_SET_LEVEL 3
void WaterCoolingTemperatureControlModule::initialize(int32_t id, config_t* cfg, hardwared_config_t* hardwaredconfig) { void WaterCoolingTemperatureControlModule::initialize(int32_t id, config_t* cfg, hardwared_config_t* hardwaredconfig) {
#if 0 #if 0
ZITemperatureSensor* temperature_sensor[4]; ZITemperatureSensor* temperature_sensor[4];
@ -61,10 +65,11 @@ int32_t WaterCoolingTemperatureControlModule::getid(int32_t* id) {
*id = m_id; *id = m_id;
return 0; return 0;
} }
int32_t WaterCoolingTemperatureControlModule::module_clear_error() { return 0; }
void WaterCoolingTemperatureControlModule::createDefaultConfig(config_t* cfg) { void WaterCoolingTemperatureControlModule::createDefaultConfig(config_t* cfg) {
cfg->fanlevel = 90; cfg->fanlevel = 90;
cfg->pumplevel = 90;
cfg->pumplevel = 100;
cfg->pid_cfg.kp = 9; cfg->pid_cfg.kp = 9;
cfg->pid_cfg.ki = 0.600; cfg->pid_cfg.ki = 0.600;
cfg->pid_cfg.kd = 0; cfg->pid_cfg.kd = 0;
@ -84,60 +89,56 @@ void WaterCoolingTemperatureControlModule::createDefaultConfig(config_t* cfg) {
*param_value = modulereg / precision; \ *param_value = modulereg / precision; \
break; break;
int32_t WaterCoolingTemperatureControlModule::module_set_reg(int32_t param_id, int32_t param_value) {
int32_t WaterCoolingTemperatureControlModule::module_set_reg(int32_t param_id, int32_t param_value) { return module_xxx_reg(param_id, false, param_value); }
int32_t WaterCoolingTemperatureControlModule::module_get_reg(int32_t param_id, int32_t* param_value) { return module_xxx_reg(param_id, true, *param_value); }
int32_t WaterCoolingTemperatureControlModule::module_xxx_reg(int32_t param_id, bool read, int32_t& val) {
switch (param_id) { switch (param_id) {
SET_REG(kreg_pid_kp, m_cfg.pid_cfg.kp, 0.01);
SET_REG(kreg_pid_ki, m_cfg.pid_cfg.ki, 0.01);
SET_REG(kreg_pid_kd, m_cfg.pid_cfg.kd, 0.01);
SET_REG(kreg_pid_max_output, m_cfg.pid_cfg.max_output, 1);
SET_REG(kreg_pid_min_output, m_cfg.pid_cfg.min_output, 1);
SET_REG(kreg_pid_max_integral, m_cfg.pid_cfg.max_integral, 1);
SET_REG(kreg_pid_min_integral, m_cfg.pid_cfg.min_integral, 1);
SET_REG(kreg_compute_interval, m_cfg.pidcompute_periodms, 1);
SET_REG(kreg_pid_target, m_target_temperature, 0.1);
SET_REG(kreg_fan0_ctrl_speed_level, m_cfg.fanlevel, 1);
SET_REG(kreg_pwm_pump0_ctrl_speed_level, m_cfg.pumplevel, 1);
PROCESS_REG(kreg_pid_kp, REG_GET_FLOAT(m_cfg.pid_cfg.kp, 0.01), REG_SET_FLOAT(m_cfg.pid_cfg.kp, 0.01));
PROCESS_REG(kreg_pid_ki, REG_GET_FLOAT(m_cfg.pid_cfg.ki, 0.01), REG_SET_FLOAT(m_cfg.pid_cfg.ki, 0.01));
PROCESS_REG(kreg_pid_kd, REG_GET_FLOAT(m_cfg.pid_cfg.kd, 0.01), REG_SET_FLOAT(m_cfg.pid_cfg.kd, 0.01));
PROCESS_REG(kreg_pid_max_output, REG_GET_FLOAT(m_cfg.pid_cfg.max_output, 1), REG_SET_FLOAT(m_cfg.pid_cfg.max_output, 1));
PROCESS_REG(kreg_pid_min_output, REG_GET_FLOAT(m_cfg.pid_cfg.min_output, 1), REG_SET_FLOAT(m_cfg.pid_cfg.min_output, 1));
PROCESS_REG(kreg_pid_max_integral, REG_GET_FLOAT(m_cfg.pid_cfg.max_integral, 1), REG_SET_FLOAT(m_cfg.pid_cfg.max_integral, 1));
PROCESS_REG(kreg_pid_min_integral, REG_GET_FLOAT(m_cfg.pid_cfg.min_integral, 1), REG_SET_FLOAT(m_cfg.pid_cfg.min_integral, 1));
PROCESS_REG(kreg_compute_interval, REG_GET(m_cfg.pidcompute_periodms), REG_SET(m_cfg.pidcompute_periodms));
PROCESS_REG(kreg_pid_target, REG_GET_FLOAT(m_target_temperature, 0.1), REG_SET_FLOAT(m_target_temperature, 0.1));
PROCESS_REG(kreg_pid_nowoutput, REG_GET(m_pidmodule.get_output()), ACTION_NONE);
PROCESS_REG(kreg_pid_feedbackval, REG_GET(read_pid_temperature()), ACTION_NONE);
PROCESS_REG(kreg_module_version, REG_GET(0), ACTION_NONE);
PROCESS_REG(kreg_module_type, REG_GET(0), ACTION_NONE);
PROCESS_REG(kreg_module_status, REG_GET(getworkstate()), ACTION_NONE);
PROCESS_REG(kreg_module_errorcode, REG_GET(m_errorcode), ACTION_NONE);
PROCESS_REG(kreg_module_initflag, REG_GET(module_get_inited_flag()), ACTION_NONE);
PROCESS_REG(kreg_module_errorbitflag0, REG_GET(geterrorbitflag0()), ACTION_NONE);
PROCESS_REG(kreg_module_errorbitflag1, REG_GET(geterrorbitflag1()), ACTION_NONE);
PROCESS_REG(kreg_module_input_state, REG_GET(read_input_state()), ACTION_NONE);
PROCESS_REG(kreg_module_output_state, REG_GET(read_output_io_state()), ACTION_NONE);
PROCESS_REG(kreg_sensor_temperature0, REG_GET(getTemperatureSensorVal(0)), ACTION_NONE);
PROCESS_REG(kreg_sensor_temperature1, REG_GET(getTemperatureSensorVal(1)), ACTION_NONE);
PROCESS_REG(kreg_sensor_temperature2, REG_GET(getTemperatureSensorVal(2)), ACTION_NONE);
PROCESS_REG(kreg_sensor_temperature3, REG_GET(getTemperatureSensorVal(3)), ACTION_NONE);
PROCESS_ACTION();
default: default:
return err::kmodule_not_find_config_index; return err::kmodule_not_find_config_index;
break;
} }
return 0; return 0;
} }
int32_t WaterCoolingTemperatureControlModule::module_get_reg(int32_t param_id, int32_t* param_value) {
switch (param_id) {
GET_REG(kreg_pid_kp, m_cfg.pid_cfg.kp, 0.01);
GET_REG(kreg_pid_ki, m_cfg.pid_cfg.ki, 0.01);
GET_REG(kreg_pid_kd, m_cfg.pid_cfg.kd, 0.01);
GET_REG(kreg_pid_max_output, m_cfg.pid_cfg.max_output, 1);
GET_REG(kreg_pid_min_output, m_cfg.pid_cfg.min_output, 1);
GET_REG(kreg_pid_max_integral, m_cfg.pid_cfg.max_integral, 1);
GET_REG(kreg_pid_min_integral, m_cfg.pid_cfg.min_integral, 1);
GET_REG(kreg_compute_interval, m_cfg.pidcompute_periodms, 1);
GET_REG(kreg_pid_target, m_target_temperature, 0.1);
GET_REG(kreg_pid_nowoutput, m_pidmodule.get_output(), 1);
GET_REG(kreg_pid_feedbackval, read_pid_temperature(), 1);
GET_REG(kreg_module_version, 0, 1);
GET_REG(kreg_module_type, 0, 1);
GET_REG(kreg_module_status, getworkstate(), 1);
GET_REG(kreg_module_errorcode, m_errorcode, 1);
GET_REG(kreg_module_initflag, module_get_inited_flag(), 1);
GET_REG(kreg_module_errorbitflag0, geterrorbitflag0(), 1);
GET_REG(kreg_module_errorbitflag1, geterrorbitflag1(), 1);
GET_REG(kreg_module_input_state, read_input_state(), 1);
GET_REG(kreg_module_output_state, read_output_io_state(), 1);
GET_REG(kreg_sensor_temperature0, getTemperatureSensorVal(0), 0.1);
GET_REG(kreg_sensor_temperature1, getTemperatureSensorVal(1), 0.1);
GET_REG(kreg_sensor_temperature2, getTemperatureSensorVal(2), 0.1);
GET_REG(kreg_sensor_temperature3, getTemperatureSensorVal(3), 0.1);
GET_REG(kreg_fan0_ctrl_speed_level, m_cfg.fanlevel, 1);
GET_REG(kreg_pwm_pump0_ctrl_speed_level, m_cfg.pumplevel, 1);
default:
return err::kmodule_not_find_config_index;
int32_t WaterCoolingTemperatureControlModule::do_action(int32_t actioncode) {
if (actioncode == ACTION_TEST_PELTIER_SET_POWER_LEVEL) {
return test_peltier_set_power_level(m_reg.module_action_param1);
} else if (actioncode == ACTION_TEST_PUMP_SET_LEVEL) {
return test_pump_set_level(m_reg.module_action_param1);
} else if (actioncode == ACTION_TEST_PUMP_FAN_SET_LEVEL) {
return test_pump_fan_set_level(m_reg.module_action_param1);
} else {
return err::kmodule_not_support_action;
} }
return 0;
} }
int32_t WaterCoolingTemperatureControlModule::module_factory_reset() { return 0; } int32_t WaterCoolingTemperatureControlModule::module_factory_reset() { return 0; }
@ -314,4 +315,31 @@ int32_t WaterCoolingTemperatureControlModule::read_output_io_state() {
iostate |= m_ext_output[i].getStateUint32() << i; iostate |= m_ext_output[i].getStateUint32() << i;
} }
return (int32_t)iostate; return (int32_t)iostate;
}
int32_t WaterCoolingTemperatureControlModule::test_peltier_set_power_level(int32_t level) {
if (level == 0) {
peltier_stop();
} else {
peltier_set_power_level(level);
}
return 0;
}
int32_t WaterCoolingTemperatureControlModule::test_pump_set_level(int32_t level) {
if (level == 0) {
pump_stop();
} else {
pump_start(level);
}
return 0;
}
int32_t WaterCoolingTemperatureControlModule::test_pump_fan_set_level(int32_t level) {
if (level == 0) {
pump_stop();
fan_stop();
} else {
pump_start(level);
fan_start(level);
}
return 0;
} }

29
components/water_cooling_temperature_control_module/water_cooling_temperature_control_module.hpp
View File

@ -48,6 +48,18 @@ class WaterCoolingTemperatureControlModule : public ZIModule {
ZGPIO::OutputGpioCfg_t ext_output[10]; ZGPIO::OutputGpioCfg_t ext_output[10];
} hardwared_config_t; } hardwared_config_t;
typedef struct {
/*******************************************************************************
* ACTION REG *
*******************************************************************************/
int32_t module_do_action0;
int32_t module_action_param1;
int32_t module_action_param2;
int32_t module_action_param3;
int32_t module_action_ack1;
int32_t module_action_ack2;
} reg_t;
private: private:
config_t m_cfg; config_t m_cfg;
int32_t m_id = 1; int32_t m_id = 1;
@ -58,6 +70,8 @@ class WaterCoolingTemperatureControlModule : public ZIModule {
ZGPIO m_ext_output[10]; ZGPIO m_ext_output[10];
int32_t m_n_ext_output = 0; int32_t m_n_ext_output = 0;
reg_t m_reg = {0};
// ζȴ«¸ÐÆ÷ // ζȴ«¸ÐÆ÷
ZITemperatureSensor* m_temperature_sensor[4] = {0}; ZITemperatureSensor* m_temperature_sensor[4] = {0};
int32_t m_n_temperature_sensor = 0; int32_t m_n_temperature_sensor = 0;
@ -80,13 +94,12 @@ class WaterCoolingTemperatureControlModule : public ZIModule {
int32_t m_errorcode = 0; int32_t m_errorcode = 0;
public: public:
WaterCoolingTemperatureControlModule(){}; WaterCoolingTemperatureControlModule(){};
virtual ~WaterCoolingTemperatureControlModule(){}; virtual ~WaterCoolingTemperatureControlModule(){};
static void createDefaultConfig(config_t* cfg); static void createDefaultConfig(config_t* cfg);
void initialize(int32_t id, config_t* cfg, hardwared_config_t* hardwaredconfig);
void initialize(int32_t id, config_t* cfg, hardwared_config_t* hardwaredconfig);
virtual int32_t module_ping() { return 0; }; virtual int32_t module_ping() { return 0; };
virtual int32_t getid(int32_t* id) override; virtual int32_t getid(int32_t* id) override;
@ -105,12 +118,16 @@ class WaterCoolingTemperatureControlModule : public ZIModule {
virtual int32_t module_readio(int32_t* io) override; virtual int32_t module_readio(int32_t* io) override;
virtual int32_t module_writeio(int32_t idindex, int32_t io) override; virtual int32_t module_writeio(int32_t idindex, int32_t io) override;
virtual int32_t module_clear_error() override;
int32_t read_input_state(); int32_t read_input_state();
int32_t read_output_io_state(); int32_t read_output_io_state();
private: private:
void workloop(); void workloop();
int32_t module_xxx_reg(int32_t param_id, bool read, int32_t& val);
int32_t checkdevice(); int32_t checkdevice();
float read_pid_temperature(); float read_pid_temperature();
@ -126,12 +143,18 @@ class WaterCoolingTemperatureControlModule : public ZIModule {
void geterrorcode(); void geterrorcode();
public:
int32_t test_peltier_set_power_level(int32_t level);
int32_t test_pump_set_level(int32_t level);
int32_t test_pump_fan_set_level(int32_t level);
private: private:
int32_t getworkstate(); int32_t getworkstate();
int32_t geterrorbitflag0(); int32_t geterrorbitflag0();
int32_t geterrorbitflag1(); int32_t geterrorbitflag1();
float getTemperatureSensorVal(int32_t index);
float getTemperatureSensorVal(int32_t index);
int32_t do_action(int32_t actioncode);
}; };
} // namespace iflytop } // namespace iflytop

2
components/zprotocols/zcancmder_v2

@ -1 +1 @@
Subproject commit 8ba982c43ae7ef8076613bee92c4b9ecd5d21799
Subproject commit 8c1056e0d3019b754ae57f65c954a69262efa5cd
Write Preview
Loading…
Cancel
Save