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

Merge branch 'master' of 192.168.1.3:manufacturer_stm32/iflytop_stm32_os_sdk

master
zhaohe 2 years ago
parent
55dbc71424 13e61a82c0
commit
2fb130cb58
4 changed files with 275 additions and 54 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 153
      components/fan_group_ctrl_module/fan_group_ctrl_module.cpp
  2. 91
      components/fan_group_ctrl_module/fan_group_ctrl_module.hpp
  3. 63
      components/sensors/m3078/m3078_code_scaner.cpp
  4. 22
      components/sensors/m3078/m3078_code_scaner.hpp

153
components/fan_group_ctrl_module/fan_group_ctrl_module.cpp
View File

@ -0,0 +1,153 @@
#include "fan_group_ctrl_module.hpp"
#include "sdk\components\zprotocols\zcancmder_v2\api\api.hpp"
#include "sdk\components\zprotocols\zcancmder_v2\api\errorcode.hpp"
using namespace iflytop;
#define TAG "FGCM"
void FanGroupCtrlMoudle::initialize(config_t* pcfg) {
ZASSERT(pcfg->name != nullptr);
ZASSERT(pcfg);
m_mutex.init();
// ZASSERT(pcfg->fanCtrlTim);
cfg = *pcfg;
m_enablefbcheck = pcfg->enablefbcheck;
if (m_enablefbcheck) {
for (int32_t i = 0; i < ZARRAY_SIZE(cfg.fanFBGpioCfg); i++) {
if (cfg.fanFBGpioCfg[i].pin != PinNull) {
m_fanFBGpio[i].initAsInput(cfg.fanFBGpioCfg[i].pin, //
cfg.fanFBGpioCfg[i].mode, //
ZGPIO::kIRQ_risingIrq, //
cfg.fanFBGpioCfg[i].mirror);
m_fanFBGpio[i].regListener([this, i](ZGPIO* GPIO_Pin, ZGPIO::IrqTypeEvent_t irqevent) { onfbgpioirq(i); });
m_nfanFBGpio++;
}
}
ZASSERT(pcfg->nfan == m_nfanFBGpio);
}
for (int32_t i = 0; i < ZARRAY_SIZE(cfg.fanPowerGpioCfg); i++) {
if (cfg.fanPowerGpioCfg[i].pin != PinNull) {
m_fanPowerGpio[i].initAsOutput(cfg.fanPowerGpioCfg[i].pin, //
cfg.fanPowerGpioCfg[i].mode, //
cfg.fanPowerGpioCfg[i].initLevel, //
cfg.fanPowerGpioCfg[i].mirror);
m_fanPowerGpio[i].enableTrace(pcfg->enableTrace);
m_nfanPowerPin++;
}
}
cfg.pwm_cfg.calltrace = pcfg->enableTrace;
m_fanCtrlPwm.initialize(&cfg.pwm_cfg);
OSDefaultSchduler::getInstance()->regPeriodJob([this](OSDefaultSchduler::Context&) { checkfanState(); }, 1000);
}
int32_t FanGroupCtrlMoudle::module_xxx_reg(int32_t param_id, bool read, int32_t& val) {
switch (param_id) {
MODULE_COMMON_PROCESS_REG_CB();
default:
return err::kmodule_not_find_config_index;
break;
}
return 0;
}
void FanGroupCtrlMoudle::onfbgpioirq(int32_t fanindex) {
// IRQ Context,ÖжÏÉÏÏÂÎÄ
m_fanstate[fanindex].fanFBCount++;
m_fanstate[fanindex].lastupdateFanFBCountTime = zos_get_tick();
}
int32_t FanGroupCtrlMoudle::startModule(int32_t duty) {
// ZLOGI("startModule duty:%d", duty);
zlock_guard lck(m_mutex);
if (duty < 20) duty = 20;
fanisworking = true;
clearError();
startFanPWM(duty);
powerON();
m_lastcheckTime = zos_get_tick();
return 0;
}
int32_t FanGroupCtrlMoudle::stopModule() {
zlock_guard lck(m_mutex);
fanisworking = false;
stopFanPWM();
powerOff();
return 0;
}
int32_t FanGroupCtrlMoudle::getSubModuleErrorState(int32_t fanindex, int32_t* error_state) {
if (fanindex > 3) {
return err::kfail;
}
*error_state = m_fanstate[fanindex].fanerrorstate;
return 0;
}
bool FanGroupCtrlMoudle::isError() {
bool iserror = false;
for (int32_t i = 0; i < cfg.nfan; i++) {
if (m_fanstate[i].fanerrorstate > 0) {
iserror = true;
break;
}
}
return iserror;
}
void FanGroupCtrlMoudle::checkfanState() {
zlock_guard lck(m_mutex);
if (!m_enablefbcheck) return;
if (zos_haspassedms(m_lastcheckTime) < 3 * 1000) {
return;
}
m_lastcheckTime = zos_get_tick();
for (int32_t i = 0; i < cfg.nfan; i++) {
checkfanState(i);
}
}
void FanGroupCtrlMoudle::checkfanState(int32_t fanindex) {
if (fanisworking && zos_haspassedms(m_fanstate[fanindex].lastupdateFanFBCountTime) > 10 * 1000) {
m_fanstate[fanindex].fanerrorstate = 1;
ZLOGE(TAG, "%s checkfanState fanindex:%d error", cfg.name, fanindex);
stopModule();
}
}
void FanGroupCtrlMoudle::powerON() {
for (int32_t i = 0; i < m_nfanPowerPin; i++) {
m_fanPowerGpio[i].setState(true);
}
}
void FanGroupCtrlMoudle::powerOff() {
for (int32_t i = 0; i < m_nfanPowerPin; i++) {
m_fanPowerGpio[i].setState(false);
}
}
void FanGroupCtrlMoudle::clearError() {
for (int32_t i = 0; i < cfg.nfan; i++) {
m_fanstate[i].fanerrorstate = 0;
}
}
void FanGroupCtrlMoudle::startFanPWM(int32_t duty) {
for (int32_t i = 0; i < ZARRAY_SIZE(cfg.fan0Channel); i++) {
if (cfg.fan0Channel[i] != 0) {
m_fanCtrlPwm.startPWM(cfg.fan0Channel[i], duty);
}
}
}
void FanGroupCtrlMoudle::stopFanPWM() {
for (int32_t i = 0; i < ZARRAY_SIZE(cfg.fan0Channel); i++) {
if (cfg.fan0Channel[i] != 0) {
m_fanCtrlPwm.stopPWM(cfg.fan0Channel[i]);
}
}
}

91
components/fan_group_ctrl_module/fan_group_ctrl_module.hpp
View File

@ -0,0 +1,91 @@
#pragma once
/**
* @file
* @author zhaohe (h_zhaohe@163.com)
* @brief
* @version 0.1
* @date 2023-04-14
*
* @copyright Copyright (c) 2023
*
*/
#include <stdint.h>
#include "sdk/os/zos.hpp"
#include "sdk\chip\zpwm_generator_muti_channel.hpp"
#include "sdk\components\zprotocols\zcancmder_v2\api\api.hpp"
#include "sdk\components\zprotocols\zcancmder_v2\api\zi_module.hpp"
#include "sdk\os\mutex.hpp"
//
namespace iflytop {
// SUPPORT REG
class FanGroupCtrlMoudle : public ZIModule {
ENABLE_MODULE(FanGroupCtrlMoudle, kfan_ctrl_module, 1);
public:
typedef struct {
// TIM_HandleTypeDef* fanCtrlTim;
const char* name;
ZPWMGeneratorMutiChannel::hardware_config_t pwm_cfg;
int32_t nfan;
int32_t fan0Channel[4];
ZGPIO::InputGpioCfg_t fanFBGpioCfg[4];
ZGPIO::OutputGpioCfg_t fanPowerGpioCfg[4];
bool enablefbcheck;
bool enableTrace;
} config_t;
typedef struct {
int32_t fanFBCount;
uint32_t lastupdateFanFBCountTime;
int32_t fanerrorstate;
} fanState_t;
ZPWMGeneratorMutiChannel m_fanCtrlPwm;
ZGPIO m_fanFBGpio[4];
int32_t m_nfanFBGpio = 0;
ZGPIO m_fanPowerGpio[4];
int32_t m_nfanPowerPin = 0;
fanState_t m_fanstate[4];
bool fanisworking = false;
uint32_t m_lastcheckTime = 0;
config_t cfg;
bool m_enablefbcheck = false;
zmutex m_mutex;
public:
FanGroupCtrlMoudle(){};
void initialize(config_t* fangroup);
int32_t startModule(int32_t duty);
int32_t stopModule();
int32_t getSubModuleErrorState(int32_t fanindex, int32_t* error_state);
bool isError();
private:
void checkfanState();
void onfbgpioirq(int32_t fanindex);
private:
void checkfanState(int32_t fanindex);
void powerON();
void powerOff();
void clearError();
void startFanPWM(int32_t duty);
void stopFanPWM();
virtual int32_t module_xxx_reg(int32_t param_id, bool read, int32_t& val) override;
};
} // namespace iflytop

63
components/sensors/m3078/m3078_code_scaner.cpp
View File

@ -26,8 +26,8 @@ void M3078CodeScanner::initialize(int moduleid, hardware_config_t* hardwareconfi
}
});
m_uart.startRxIt();
m_triggerGpio.initAsOutput(hardwareconfig->triggerPin, ZGPIO::kMode_nopull, false, false);
m_com_reg.module_enable = 1;
}
void M3078CodeScanner::trigger() {
m_codeisready = false;
@ -36,8 +36,7 @@ void M3078CodeScanner::trigger() {
m_uart.clearRxData();
m_triggerGpio.setState(1);
}
void M3078CodeScanner::stopTrigger() { m_triggerGpio.setState(0); }
void M3078CodeScanner::stopTrigger() { m_triggerGpio.setState(0); }
bool M3078CodeScanner::idInfoIsReady() { return m_codeisready; }
char* M3078CodeScanner::getIdinfo() { return codecache; }
void M3078CodeScanner::clearIdinfo() {
@ -60,53 +59,35 @@ int32_t M3078CodeScanner::module_start() {
trigger();
return 0;
}
#define ACTION_NULL ;
#define REG(param_id, readaction, writeacton) \
case param_id: { \
if (read) { \
readaction; \
} else { \
writeacton; \
} \
int32_t M3078CodeScanner::module_read_raw(int32_t startadd, uint8_t* data, int32_t* len) {
ZLOGI(TAG, "module_read_raw");
if (codecachelen > *len) {
return err::kbuffer_not_enough;
}
*len = codecachelen;
memcpy(data, codecache, codecachelen);
return 0;
}
int32_t M3078CodeScanner::get_id_info_len(int32_t* len) {
*len = codecachelen;
return 0;
}
int32_t M3078CodeScanner::get_raw_sector_num(int32_t* num) {
*num = 1;
return 0;
}
int32_t M3078CodeScanner::module_xxx_reg(int32_t param_id, bool read, int32_t& val) {
switch (param_id) {
REG(kreg_module_version, /* */ val = 0x0001, ACTION_NULL);
REG(kreg_module_type, /* */ val = 0, ACTION_NULL);
REG(kreg_module_status, /* */ val = read_status(), ACTION_NULL);
REG(kreg_module_errorcode, /* */ val = 0, ACTION_NULL);
REG(kreg_module_initflag, /* */ val = module_get_inited_flag(), module_set_inited_flag(val));
REG(kreg_module_enableflag, /* */ val = 1, ACTION_NULL);
REG(kreg_module_last_cmd_exec_status, val = 0, ACTION_NULL);
MODULE_COMMON_PROCESS_REG_CB();
PROCESS_REG(kreg_module_raw_sector_size, /* */ get_id_info_len(&val), ACTION_NONE);
PROCESS_REG(kreg_module_raw_sector_num, /* */ get_raw_sector_num(&val), ACTION_NONE);
default:
return err::kmodule_not_find_config_index;
break;
}
return 0;
}
int32_t M3078CodeScanner::module_set_reg(int32_t param_id, int32_t param_value) { return module_xxx_reg(param_id, false, param_value); }
int32_t M3078CodeScanner::module_get_reg(int32_t param_id, int32_t* param_value) { return module_xxx_reg(param_id, true, *param_value); }
int32_t M3078CodeScanner::code_scaner_start_scan() {
ZLOGI(TAG, "code_scaner_start_scan");
return module_start();
}
int32_t M3078CodeScanner::code_scaner_stop_scan() {
ZLOGI(TAG, "code_scaner_stop_scan");
return module_stop();
}
int32_t M3078CodeScanner::code_scaner_read_scaner_result(int32_t startadd, uint8_t* data, int32_t* len) {
ZLOGI(TAG, "code_scaner_read_scaner_result");
if (codecachelen > *len) {
return err::kbuffer_not_enough;
}
*len = codecachelen;
memcpy(data, codecache, codecachelen);
return 0;
}
int32_t M3078CodeScanner::read_status() {
if (m_triggerGpio.getState() == 0) {
return 0;

22
components/sensors/m3078/m3078_code_scaner.hpp
View File

@ -26,7 +26,9 @@
namespace iflytop {
using namespace std;
class M3078CodeScanner : public ZIModule, public ZICodeScaner {
class M3078CodeScanner : public ZIModule {
ENABLE_MODULE(M3078CodeScanner, kcode_scaner, 1);
public:
typedef struct {
UART_HandleTypeDef* uart;
@ -79,27 +81,21 @@ class M3078CodeScanner : public ZIModule, public ZICodeScaner {
void clearIdinfo();
public:
virtual int32_t ping() { return 0; };
virtual int32_t getid(int32_t* id) override {
*id = this->id;
return 0;
}
virtual int32_t module_stop();
virtual int32_t module_break();
virtual int32_t module_start();
virtual int32_t module_set_reg(int32_t param_id, int32_t param_value);
virtual int32_t module_get_reg(int32_t param_id, int32_t* param_value);
virtual int32_t code_scaner_start_scan();
virtual int32_t code_scaner_stop_scan();
virtual int32_t code_scaner_read_scaner_result(int32_t startadd, uint8_t* data, int32_t* len);
virtual int32_t module_read_raw(int32_t index, uint8_t* data, int32_t* len);
private:
int32_t module_xxx_reg(int32_t param_id, bool read, int32_t& param_value);
int32_t read_status();
virtual int32_t module_xxx_reg(int32_t param_id, bool read, int32_t& val) override;
int32_t read_status();
int32_t get_id_info_len(int32_t* len);
int32_t get_raw_sector_num(int32_t* num);
};
} // namespace iflytop
Write Preview
Loading…
Cancel
Save