diff --git a/chip/api/zi_adc.hpp b/chip/api/zi_adc.hpp new file mode 100644 index 0000000..31d8207 --- /dev/null +++ b/chip/api/zi_adc.hpp @@ -0,0 +1,17 @@ +#pragma once +#include + +namespace iflytop { +using namespace std; +class ZIADC { + public: + virtual ~ZIADC(){}; + + virtual int32_t get_adc_value() { + int32_t adcval = 0; + get_adc_value(adcval); + return adcval; + } + virtual int32_t get_adc_value(int32_t &adcval) = 0; +}; +} // namespace iflytop diff --git a/chip/api/zi_api.hpp b/chip/api/zi_api.hpp new file mode 100644 index 0000000..beb37f7 --- /dev/null +++ b/chip/api/zi_api.hpp @@ -0,0 +1,3 @@ +#pragma once +#include "zi_adc.hpp" +#include "sdk\components\zprotocols\zcancmder_v2\api\errorcode.hpp" diff --git a/chip/zgpio.cpp b/chip/zgpio.cpp index 1d4ffb5..3272dda 100644 --- a/chip/zgpio.cpp +++ b/chip/zgpio.cpp @@ -181,6 +181,8 @@ void ZGPIO::initAsInput(Pin_t pin, GPIOMode_t mode, GPIOIrqType_t irqtype, bool HAL_NVIC_SetPriority(getEXTIIRQn(), IFLYTOP_PREEMPTPRIORITY_DEFAULT, 0); HAL_NVIC_EnableIRQ(getEXTIIRQn()); } + + m_initflag = true; return; } void ZGPIO::initAsOutput(Pin_t pin, GPIOMode_t mode, bool mirror, bool initLevel) { @@ -221,6 +223,8 @@ void ZGPIO::initAsOutput(Pin_t pin, GPIOMode_t mode, bool mirror, bool initLevel m_GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; } HAL_GPIO_Init(m_gpio, &m_GPIO_InitStruct); + m_initflag = true; + return; } bool ZGPIO::isItRisingEXITGPIO() { return m_irqtype == kIRQ_risingIrq; } diff --git a/chip/zgpio.hpp b/chip/zgpio.hpp index a4ff0db..5a0e2cf 100644 --- a/chip/zgpio.hpp +++ b/chip/zgpio.hpp @@ -57,12 +57,15 @@ class ZGPIO { bool lastLevel; onirq_t m_onirq; + bool m_initflag; public: ZGPIO(){}; void initAsInput(Pin_t pin, GPIOMode_t mode, GPIOIrqType_t irqtype, bool mirror); void initAsOutput(Pin_t pin, GPIOMode_t mode, bool mirror, bool initLevel); + void initAsOutput(OutputGpioCfg_t *outputcfg) { initAsOutput(outputcfg->pin, outputcfg->mode, outputcfg->mirror, outputcfg->initLevel); } + void initAsInput(InputGpioCfg_t *inputcfg) { initAsInput(inputcfg->pin, inputcfg->mode, inputcfg->irqtype, inputcfg->mirror); } void regListener(onirq_t listener); @@ -82,6 +85,8 @@ class ZGPIO { bool tryTriggerIRQ(uint16_t GPIO_Pin); + bool isInit() { return m_initflag; } + private: bool enableClock(); }; diff --git a/chip/zirq_dispatcher.cpp b/chip/zirq_dispatcher.cpp index 533e32f..d2a3209 100644 --- a/chip/zirq_dispatcher.cpp +++ b/chip/zirq_dispatcher.cpp @@ -18,6 +18,54 @@ void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim) { #endif ZIRQDispatcher::instance()._callOnTimIrq(htim); } + +void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef *huart, uint16_t Size) { + ZIRQDispatcher::uart_irq_data_t data = {0}; + data.huart = huart; + data.Size = Size; + ZIRQDispatcher::instance()._callOnUartIrq(ZIRQDispatcher::konHAL_UART_TxCpltCallback, data); +} + +void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart) { + ZIRQDispatcher::uart_irq_data_t data = {0}; + data.huart = huart; + ZIRQDispatcher::instance()._callOnUartIrq(ZIRQDispatcher::konHAL_UART_TxCpltCallback, data); +} +void HAL_UART_TxHalfCpltCallback(UART_HandleTypeDef *huart) { + ZIRQDispatcher::uart_irq_data_t data = {0}; + data.huart = huart; + ZIRQDispatcher::instance()._callOnUartIrq(ZIRQDispatcher::konHAL_UART_TxHalfCpltCallback, data); +} +void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart) { + ZIRQDispatcher::uart_irq_data_t data = {0}; + data.huart = huart; + ZIRQDispatcher::instance()._callOnUartIrq(ZIRQDispatcher::konHAL_UART_RxCpltCallback, data); +} +void HAL_UART_RxHalfCpltCallback(UART_HandleTypeDef *huart) { + ZIRQDispatcher::uart_irq_data_t data = {0}; + data.huart = huart; + ZIRQDispatcher::instance()._callOnUartIrq(ZIRQDispatcher::konHAL_UART_RxHalfCpltCallback, data); +} +void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart) { + ZIRQDispatcher::uart_irq_data_t data = {0}; + data.huart = huart; + ZIRQDispatcher::instance()._callOnUartIrq(ZIRQDispatcher::konHAL_UART_ErrorCallback, data); +} +void HAL_UART_AbortCpltCallback(UART_HandleTypeDef *huart) { + ZIRQDispatcher::uart_irq_data_t data = {0}; + data.huart = huart; + ZIRQDispatcher::instance()._callOnUartIrq(ZIRQDispatcher::konHAL_UART_AbortCpltCallback, data); +} +void HAL_UART_AbortTransmitCpltCallback(UART_HandleTypeDef *huart) { + ZIRQDispatcher::uart_irq_data_t data = {0}; + data.huart = huart; + ZIRQDispatcher::instance()._callOnUartIrq(ZIRQDispatcher::konHAL_UART_AbortTransmitCpltCallback, data); +} +void HAL_UART_AbortReceiveCpltCallback(UART_HandleTypeDef *huart) { + ZIRQDispatcher::uart_irq_data_t data = {0}; + data.huart = huart; + ZIRQDispatcher::instance()._callOnUartIrq(ZIRQDispatcher::konHAL_UART_AbortReceiveCpltCallback, data); +} } ZIRQDispatcher &ZIRQDispatcher::instance() { @@ -26,9 +74,15 @@ ZIRQDispatcher &ZIRQDispatcher::instance() { } void ZIRQDispatcher::regTimIrqListener(ontimirq_t listener) { m_ontimirqs.push_back(listener); } +void ZIRQDispatcher::regUartIrqListener(on_uart_irq_t cb) { m_onuartirqs.push_back(cb); } void ZIRQDispatcher::_callOnTimIrq(zchip_tim_t *tim) { for (auto &listener : m_ontimirqs) { listener(tim); } -} \ No newline at end of file +} +void ZIRQDispatcher::_callOnUartIrq(uart_irq_t irq_type, uart_irq_data_t data) { + for (auto &listener : m_onuartirqs) { + listener(irq_type, data); + } +} diff --git a/chip/zirq_dispatcher.hpp b/chip/zirq_dispatcher.hpp index 66dc700..c9a5378 100644 --- a/chip/zirq_dispatcher.hpp +++ b/chip/zirq_dispatcher.hpp @@ -8,17 +8,39 @@ namespace iflytop { using namespace std; class ZIRQDispatcher { public: - typedef function ontimirq_t; + typedef enum { + konHAL_UARTEx_RxEventCallback, + konHAL_UART_TxCpltCallback, + konHAL_UART_TxHalfCpltCallback, + konHAL_UART_RxCpltCallback, + konHAL_UART_RxHalfCpltCallback, + konHAL_UART_ErrorCallback, + konHAL_UART_AbortCpltCallback, + konHAL_UART_AbortTransmitCpltCallback, + konHAL_UART_AbortReceiveCpltCallback, + } uart_irq_t; - list m_ontimirqs; + typedef struct { + UART_HandleTypeDef *huart; + uint16_t Size; + } uart_irq_data_t; + + public: + typedef function ontimirq_t; + typedef function on_uart_irq_t; + + list m_ontimirqs; + list m_onuartirqs; public: static ZIRQDispatcher &instance(); void regTimIrqListener(ontimirq_t listener); + void regUartIrqListener(on_uart_irq_t cb); public: void _callOnTimIrq(zchip_tim_t *tim); + void _callOnUartIrq(uart_irq_t irq_type, uart_irq_data_t data); }; } // namespace iflytop \ No newline at end of file diff --git a/chip/zuart.cpp b/chip/zuart.cpp index ddd950f..2e0712c 100644 --- a/chip/zuart.cpp +++ b/chip/zuart.cpp @@ -3,8 +3,11 @@ #include #include #include + +#include "sdk\chip\zirq_dispatcher.hpp" using namespace iflytop; +#if 0 static ZUART *s_uart_table[10]; static int s_numUart; @@ -22,8 +25,11 @@ ZUART *prv_find_uart(UART_HandleTypeDef *huart) { } return NULL; } +#endif extern "C" { +// void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef *huart, uint16_t Size); +#if 0 void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart) { ZUART *stm32uart = prv_find_uart(huart); if (stm32uart != NULL) stm32uart->HAL_UART_TxCpltCallback(); @@ -56,6 +62,7 @@ void HAL_UART_AbortReceiveCpltCallback(UART_HandleTypeDef *huart) { ZUART *stm32uart = prv_find_uart(huart); if (stm32uart != NULL) stm32uart->HAL_UART_AbortReceiveCpltCallback(); } +#endif } IRQn_Type ZUART::getUartIRQType() { @@ -111,7 +118,38 @@ void ZUART::initialize(cfg_t *cfg, callback_t cb) { onebyte = 0; ChipTimIrqShceduler::instance().regPeriodJob([this](ChipTimIrqShceduler::Job *job) { periodicJob(); }, 1); - prv_reg_uart(this); + ZIRQDispatcher::instance().regUartIrqListener([this](ZIRQDispatcher::uart_irq_t irq_type, ZIRQDispatcher::uart_irq_data_t data) { + switch (irq_type) { + case ZIRQDispatcher::konHAL_UARTEx_RxEventCallback: + break; + case ZIRQDispatcher::konHAL_UART_TxCpltCallback: + this->HAL_UART_TxCpltCallback(); + break; + case ZIRQDispatcher::konHAL_UART_TxHalfCpltCallback: + this->HAL_UART_TxHalfCpltCallback(); + break; + case ZIRQDispatcher::konHAL_UART_RxCpltCallback: + this->HAL_UART_RxCpltCallback(); + break; + case ZIRQDispatcher::konHAL_UART_RxHalfCpltCallback: + this->HAL_UART_RxHalfCpltCallback(); + break; + case ZIRQDispatcher::konHAL_UART_ErrorCallback: + this->HAL_UART_ErrorCallback(); + break; + case ZIRQDispatcher::konHAL_UART_AbortCpltCallback: + this->HAL_UART_AbortCpltCallback(); + break; + case ZIRQDispatcher::konHAL_UART_AbortTransmitCpltCallback: + this->HAL_UART_AbortTransmitCpltCallback(); + break; + case ZIRQDispatcher::konHAL_UART_AbortReceiveCpltCallback: + this->HAL_UART_AbortReceiveCpltCallback(); + break; + default: + break; + } + }); } void ZUART::initialize(cfg_t *cfg) { initialize(cfg, NULL); } diff --git a/components/cmdscheduler/cmd_scheduler_uart_dma.cpp b/components/cmdscheduler/cmd_scheduler_uart_dma.cpp new file mode 100644 index 0000000..939110d --- /dev/null +++ b/components/cmdscheduler/cmd_scheduler_uart_dma.cpp @@ -0,0 +1,199 @@ + +#include "cmd_scheduler_uart_dma.hpp" + +#include +#include + +#include "project_configs.h" +#include "sdk\components\zprotocols\errorcode\errorcode.hpp" +using namespace iflytop; + +#define TAG "CMD" + +#if 0 + +void CmdSchedulerUartDMA::registerCmd(const char* cmdname, const char* helpinfo, int paraNum, ICmdFunction_t cmdimpl) { + CMD cmdinfo; + cmdinfo.call_cmd = cmdimpl; + cmdinfo.help_info = helpinfo; + cmdinfo.npara = paraNum; + m_cmdMap[cmdname] = cmdinfo; +} + +void CmdSchedulerUartDMA::regbasiccmd() { + this->registerCmd("help", "", 0, [this](int32_t paramN, const char* paraV[], ICmdParserACK* ack) { + ZLOGI(TAG, "cmdlist:"); + for (auto it = m_cmdMap.begin(); it != m_cmdMap.end(); it++) { + ZLOGI(TAG, " %s %s", it->first.c_str(), it->second.help_info.c_str()); + } + return (int32_t)0; + }); + this->registerCmd("sleep_ms", "(ms)", 1, [this](int32_t paramN, const char* paraV[], ICmdParserACK* ack) { + int ms = atoi(paraV[0]); + osDelay(ms); + return 0; + }); +} + +void CmdSchedulerUartDMA::initialize(UART_HandleTypeDef* huart, uint32_t rxbufsize) { + m_huart = huart; + + rxbuf = new char[rxbufsize + 1]; + ZASSERT(rxbuf != NULL); + m_rxbufsize = rxbufsize; + + // m_uart->initialize(&cfg); + // ZASSERT(m_uart->startRxIt()); + // m_uart->setrxcb([this](uint8_t* data, size_t len) { + // if (m_dataisready) { + // return; + // } + // memcpy(rxbuf, data, len); + // rxbuf[len] = '\0'; + // m_rxsize = len; + // m_dataisready = true; + // // on data ,in irq context + // }); + // regbasiccmd(); +} +// int32_t getAckInt32Val(int index) { +// int32_t getAckInt32Num() { + +void CmdSchedulerUartDMA::schedule() { + static ICmdParserACK ack = {0}; + + HAL_UART_StateTypeDef state = HAL_UART_GetState(m_huart); + if (state == HAL_UART_STATE_BUSY_RX || state == HAL_UART_STATE_BUSY_TX_RX) { + HAL_UARTEx_ReceiveToIdle_DMA(m_huart, (uint8_t*)rxbuf, m_rxbufsize); + return; + } + + for (int i = 0; i < m_rxsize; i++) { + if (rxbuf[i] == '\r' || rxbuf[i] == '\n') { + rxbuf[i] = '\0'; + } + } + for (int i = 0; i < m_rxsize; i++) { + if (rxbuf[i] != '\0') { + // ZLOGI(TAG, "docmd: %s", &rxbuf[i]); + ZLOGI(TAG, "docmd: %s", &rxbuf[i]); + + int inext = strlen(&rxbuf[i]) + i; + memset(&ack, 0, sizeof(ack)); +#ifdef IFLYTOP_ENABLE_EXCEPTION + try { + callcmd(&rxbuf[i], &ack); + } catch (...) { + ack.ecode = err::kcatch_exception; + } +#else + callcmd(&rxbuf[i], &ack); +#endif + dumpack(&ack); + i = inext; + + if (ack.ecode != 0) { + break; + } + } + } + // if (m_rxsize != 1) { + // ZLOGI(TAG, "doscript:end"); + // } + m_dataisready = false; +} +void CmdSchedulerUartDMA::dumpack(ICmdParserACK* ack) { + if (ack->ecode == 0) { + if (ack->acktype == ack->kAckType_none) { + ZLOGI(TAG, "\tok"); + } else if (ack->acktype == ack->kAckType_int32) { + ZLOGI(TAG, "\tok-->"); + for (int i = 0; i < ack->getAckInt32Num(); i++) { + // printf(" %d", (int)ack->getAckInt32Val(i)); + ZLOGI(TAG, "\t\t%d", (int)ack->getAckInt32Val(i)); + } + } else if (ack->acktype == ack->kAckType_buf) { + ZLOGI(TAG, "\tok-->"); + for (int i = 0; i < ack->rawlen; i++) { + printf(" %02x", ack->rawdata[i]); + } + printf("\n"); + } else { + ZLOGI(TAG, "\tok"); + } + } else { + ZLOGI(TAG, "\tfailed:%s(%d)", err::error2str(ack->ecode), (int)ack->ecode); + } +} + +// void CmdSchedulerUartDMA::tx(const char* data, int len) { m_uart->tx((uint8_t*)data, len); } +int32_t CmdSchedulerUartDMA::callcmd(const char* cmd, ICmdParserACK* ack) { + int32_t argc = 0; + char* argv[10] = {0}; + memset(cmdcache, 0, sizeof(cmdcache)); + argc = 0; + memset(argv, 0, sizeof(argv)); + strcpy(cmdcache, cmd); + remove_note(cmdcache, strlen(cmdcache)); + prase_cmd(cmdcache, strlen(cmdcache), argc, argv); + if (argc == 0) { + return (int32_t)0; + } + + // printf("argc:%d\n", argc); + // for (size_t i = 0; i < argc; i++) { + // printf("argv[%d]:%s\n", i, argv[i]); + // } + /** + * @brief 在这里处理指令 + */ + auto cmder = m_cmdMap.find(string(argv[0])); + if (cmder != m_cmdMap.end()) { + if (cmder->second.npara != argc - 1) { + ack->ecode = err::kcmd_param_num_error; + return err::kcmd_param_num_error; + } + cmder->second.call_cmd((int32_t)(argc - 1), (const char**)(&argv[1]), ack); + return ack->ecode; + + } else { + ack->ecode = err::kcmd_not_found; + return err::kcmd_not_found; + } +} + +void CmdSchedulerUartDMA::remove_note(char* input, int inputlen) { + bool detect_note = false; + for (int i = 0; i < inputlen; i++) { + if (!detect_note && input[i] == '#') { + detect_note = true; + } + if (detect_note) { + input[i] = 0; + } + } +} + +void CmdSchedulerUartDMA::prase_cmd(char* input, int inputlen, int32_t& argc, char* argv[]) { + for (int i = 0; input[i] == 0 || i < inputlen; i++) { + if (input[i] == ' ' || input[i] == '\r' || input[i] == '\n') { + input[i] = 0; + } + } + + int j = 0; + for (int i = 0; input[i] == 0 || i < inputlen; i++) { + if (input[i] != 0 && j == 0) { + argv[argc++] = &input[i]; + j = 1; + continue; + } + + if (input[i] == 0 && j == 1) { + j = 0; + continue; + } + } +} + +#endif \ No newline at end of file diff --git a/components/cmdscheduler/cmd_scheduler_uart_dma.hpp b/components/cmdscheduler/cmd_scheduler_uart_dma.hpp new file mode 100644 index 0000000..fdf2b95 --- /dev/null +++ b/components/cmdscheduler/cmd_scheduler_uart_dma.hpp @@ -0,0 +1,51 @@ +#pragma once +#include +#include + +#include "sdk/os/zos.hpp" +#include "sdk\components\zprotocols\errorcode\errorcode.hpp" +#include "sdk\components\zprotocols\zcancmder_v2\api\api.hpp" +#if 0 +namespace iflytop { +using namespace std; + +class CmdSchedulerUartDMA : public ICmdParser { + public: + class CMD { + public: + ICmdFunction_t call_cmd; + string help_info; + int npara; + }; + + private: + map m_cmdMap; + + UART_HandleTypeDef* m_huart; + char* rxbuf; + uint32_t m_rxbufsize; + + int32_t m_rxsize = 0; + + bool m_dataisready = false; + + char cmdcache[1024] = {0}; + bool rxdmaisworking = false; + + public: + void initialize(UART_HandleTypeDef* huart, uint32_t rxbufsize); + virtual void regCMD(const char* cmdname, const char* helpinfo, int paraNum, ICmdFunction_t cmdimpl) override { registerCmd(cmdname, helpinfo, paraNum, cmdimpl); } + void registerCmd(const char* cmdname, const char* helpinfo, int paraNum, ICmdFunction_t cmdimpl); + // void tx(const char* data, int len); + void schedule(); + + private: + void regbasiccmd(); + int32_t callcmd(const char* cmd, ICmdParserACK* ack); + void prase_cmd(char* input, int inputlen, int32_t& argc, char* argv[]); + void remove_note(char* input, int inputlen); + void dumpack(ICmdParserACK* ack); +}; +} // namespace iflytop + +#endif \ No newline at end of file diff --git a/components/hardware/adc/z_simple_adc.cpp b/components/hardware/adc/z_simple_adc.cpp new file mode 100644 index 0000000..c00e64e --- /dev/null +++ b/components/hardware/adc/z_simple_adc.cpp @@ -0,0 +1,35 @@ +#include "z_simple_adc.hpp" +using namespace iflytop; + +void ZADC::initialize(ADC_HandleTypeDef* hadc1, int32_t channel, int32_t m_samplingTime) { + m_hadc1 = hadc1; + m_channel = channel; +} + +#if 0 +int32_t ZADC::get_adc_value() { + ADC_ChannelConfTypeDef sConfig = {0}; + sConfig.Channel = m_channel; /* 通道 */ + sConfig.Rank = 1; + sConfig.SamplingTime = m_samplingTime; /* 采样时间 */ + if (HAL_ADC_ConfigChannel(m_hadc1, &sConfig) != HAL_OK) { + Error_Handler(); + } + HAL_ADC_Start(m_hadc1); + HAL_ADC_PollForConversion(m_hadc1, HAL_MAX_DELAY); + return (uint16_t)HAL_ADC_GetValue(m_hadc1); +} +#endif + +int32_t ZADC::get_adc_value(int32_t& adcval) { + ADC_ChannelConfTypeDef sConfig = {0}; + sConfig.Channel = m_channel; /* 通道 */ + sConfig.Rank = 1; + sConfig.SamplingTime = m_samplingTime; /* 采样时间 */ + if (HAL_ADC_ConfigChannel(m_hadc1, &sConfig) != HAL_OK) { + return err::kmicro_adcRecvFail; + } + HAL_ADC_Start(m_hadc1); + HAL_ADC_PollForConversion(m_hadc1, HAL_MAX_DELAY); + return (uint16_t)HAL_ADC_GetValue(m_hadc1); +} diff --git a/components/hardware/adc/z_simple_adc.hpp b/components/hardware/adc/z_simple_adc.hpp new file mode 100644 index 0000000..9102e20 --- /dev/null +++ b/components/hardware/adc/z_simple_adc.hpp @@ -0,0 +1,64 @@ +#pragma once +#include + +#include "sdk\chip\api\zi_adc.hpp" +#include "sdk\components\zprotocols\zcancmder_v2\api\errorcode.hpp" +#include "sdk\os\zos.hpp" +namespace iflytop { +using namespace std; +class ZADC : public ZIADC { + public: + typedef struct { + ADC_HandleTypeDef* hadc1; + int32_t channel; + int32_t samplingTime; + } adc_config_t; + + private: + ADC_HandleTypeDef* m_hadc1 = nullptr; + int32_t m_channel = 0; + int32_t m_samplingTime = ADC_SAMPLETIME_480CYCLES; + + public: + /** + * @brief + * + * @param hadc1 adc handle + * @param channel + * ADC_CHANNEL_0 + * ADC_CHANNEL_1 + * ADC_CHANNEL_2 + * ADC_CHANNEL_3 + * ADC_CHANNEL_4 + * ADC_CHANNEL_5 + * ADC_CHANNEL_6 + * ADC_CHANNEL_7 + * ADC_CHANNEL_8 + * ADC_CHANNEL_9 + * ADC_CHANNEL_10 + * ADC_CHANNEL_11 + * ADC_CHANNEL_12 + * ADC_CHANNEL_13 + * ADC_CHANNEL_14 + * ADC_CHANNEL_15 + * ADC_CHANNEL_16 + * ADC_CHANNEL_17 + * ADC_CHANNEL_18 + * @param m_samplingTime + * ADC_SAMPLETIME_3CYCLES + * ADC_SAMPLETIME_15CYCLES + * ADC_SAMPLETIME_28CYCLES + * ADC_SAMPLETIME_56CYCLES + * ADC_SAMPLETIME_84CYCLES + * ADC_SAMPLETIME_112CYCLES + * ADC_SAMPLETIME_144CYCLES + * ADC_SAMPLETIME_480CYCLES + * + */ + + void initialize(ADC_HandleTypeDef* hadc1, int32_t channel, int32_t m_samplingTime = ADC_SAMPLETIME_480CYCLES); + void initialize(adc_config_t* config) { initialize(config->hadc1, config->channel, config->samplingTime); } + + virtual int32_t get_adc_value(int32_t& adcval) override; +}; +} // namespace iflytop diff --git a/components/sensors/mcp41xxx/mcp41xxx.cpp b/components/sensors/mcp41xxx/mcp41xxx.cpp new file mode 100644 index 0000000..d0d304f --- /dev/null +++ b/components/sensors/mcp41xxx/mcp41xxx.cpp @@ -0,0 +1,80 @@ +#include "mcp41xxx.hpp" +using namespace iflytop; +using namespace std; + +#define TAG "MCP41XXX" + +#define MCP41XXX_WRITE_DATA 0x10 +#define MCP41XXX_OFF 0x20 + +#define MCP41XXX_POTENT_0 0x01 +#define MCP41XXX_POTENT_1 0x02 +#define MCP41XXX_POTENT_0_AND_1 0x03 + +void MCP41XXX::initialize(hardware_config_t* hardwareconfig) { // + m_hardwareconfig = *hardwareconfig; + ZASSERT(m_hardwareconfig.spihandler); + + if (m_hardwareconfig.ncspin != NULL) { + m_ncspin.initAsOutput(m_hardwareconfig.ncspin, ZGPIO::kMode_nopull, false, true); + } + + if (m_hardwareconfig.nshdn != NULL) { + m_nshdn.initAsOutput(m_hardwareconfig.nshdn, ZGPIO::kMode_nopull, false, true); + } + + if (m_hardwareconfig.nrs != NULL) { + m_nrs.initAsOutput(m_hardwareconfig.nrs, ZGPIO::kMode_nopull, false, true); + } +} + +void MCP41XXX::setPotentiometerValue_0(uint8_t value) { sendValue(POTENTIOMETER_ONE, value); } +void MCP41XXX::setPotentiometerValue_1(uint8_t value) { sendValue(POTENTIOMETER_TWO, value); } +void MCP41XXX::setPotentiometerValue_both(uint8_t value) { sendValue(POTENTIOMETER_BOTH, value); } +void MCP41XXX::spi_send(uint8_t* data, int32_t len) { + if (m_ncspin.isInit()) m_ncspin.setState(false); + zos_delay(3); + HAL_SPI_Transmit(m_hardwareconfig.spihandler, data, len, HAL_MAX_DELAY); + zos_delay(3); + if (m_ncspin.isInit()) m_ncspin.setState(true); +} + +void MCP41XXX::sendValue(Potentiometer num, uint8_t value) { + uint8_t MCP41xxx_value[2]; + switch ((uint8_t)num) { + case POTENTIOMETER_ONE: + MCP41xxx_value[0] = MCP41XXX_WRITE_DATA | MCP41XXX_POTENT_0; + break; + case POTENTIOMETER_TWO: + MCP41xxx_value[0] = MCP41XXX_WRITE_DATA | MCP41XXX_POTENT_1; + break; + case POTENTIOMETER_BOTH: + MCP41xxx_value[0] = MCP41XXX_WRITE_DATA | MCP41XXX_POTENT_0_AND_1; + break; + default: + MCP41xxx_value[0] = MCP41XXX_WRITE_DATA | MCP41XXX_POTENT_0_AND_1; + break; + } + MCP41xxx_value[1] = value; + spi_send(MCP41xxx_value, 2); +} + +void MCP41XXX::potentiometerShutdonw(Potentiometer num, bool shutdown) { + uint8_t MCP41xxx_off[2]; + switch ((uint8_t)num) { + case POTENTIOMETER_ONE: + MCP41xxx_off[0] = MCP41XXX_OFF | MCP41XXX_POTENT_0; + break; + case POTENTIOMETER_TWO: + MCP41xxx_off[0] = MCP41XXX_OFF | MCP41XXX_POTENT_1; + break; + case POTENTIOMETER_BOTH: + MCP41xxx_off[0] = MCP41XXX_OFF | MCP41XXX_POTENT_0_AND_1; + break; + default: + MCP41xxx_off[0] = MCP41XXX_OFF | MCP41XXX_POTENT_0_AND_1; + break; + } + MCP41xxx_off[1] = 0; + spi_send(MCP41xxx_off, 2); +} diff --git a/components/sensors/mcp41xxx/mcp41xxx.hpp b/components/sensors/mcp41xxx/mcp41xxx.hpp new file mode 100644 index 0000000..125c2c4 --- /dev/null +++ b/components/sensors/mcp41xxx/mcp41xxx.hpp @@ -0,0 +1,38 @@ +#pragma once +#include "sdk\components\zprotocols\errorcode\errorcode.hpp" +#include "sdk\os\zos.hpp" +namespace iflytop { +using namespace std; + +class MCP41XXX { + public: + typedef enum { POTENTIOMETER_ONE = 1, POTENTIOMETER_TWO, POTENTIOMETER_BOTH } Potentiometer; + + typedef struct { + SPI_HandleTypeDef* spihandler; + Pin_t ncspin; + Pin_t nshdn; + Pin_t nrs; + } hardware_config_t; + + private: + hardware_config_t m_hardwareconfig; + ZGPIO m_ncspin; + ZGPIO m_nshdn; + ZGPIO m_nrs; + + public: + MCP41XXX() {} + + void initialize(hardware_config_t* hardwareconfig); + void setPotentiometerValue_0(uint8_t value); + void setPotentiometerValue_1(uint8_t value); + void setPotentiometerValue_both(uint8_t value); + + private: + void sendValue(Potentiometer num, uint8_t value); + void potentiometerShutdonw(Potentiometer num, bool shutdown); + void spi_send(uint8_t* data, int32_t len); +}; + +} // namespace iflytop \ No newline at end of file diff --git a/components/zcancmder/zcanreceiver_master.cpp b/components/zcancmder/zcanreceiver_master.cpp index c04d16e..dfdc037 100644 --- a/components/zcancmder/zcanreceiver_master.cpp +++ b/components/zcancmder/zcanreceiver_master.cpp @@ -227,7 +227,7 @@ int32_t ZCanCommnaderMaster::sendCmd(int32_t cmdid, int32_t submoduleid, int32_t return errocode; } -void ZCanCommnaderMaster::regEventPacketListener(function on_event) { m_on_event = on_event; } +void ZCanCommnaderMaster::regEventPacketListener(onpacket_t on_event) { m_on_event = on_event; } void ZCanCommnaderMaster::regListener(uint16_t index, zcan_commnader_master_onpacket_t onack) { zlock_guard l(m_on_packet_map_lock); @@ -272,9 +272,7 @@ void ZCanCommnaderMaster::callListener(CanPacketRxBuffer *report) { } if (report->get_cmdheader()->packetType == kptv2_event) { - if (m_on_event) { - m_on_event(report->get_data(), report->get_datalen()); - } + if (m_on_event) m_on_event(report->id, report->get_cmdheader(), report->get_datalen()); } } diff --git a/components/zcancmder/zcanreceiver_master.hpp b/components/zcancmder/zcanreceiver_master.hpp index 4f3c012..455cf1e 100644 --- a/components/zcancmder/zcanreceiver_master.hpp +++ b/components/zcancmder/zcanreceiver_master.hpp @@ -56,7 +56,7 @@ class ZCanCommnaderMaster : public ZCanIRQListener, public IZcanCmderMaster { map m_on_packet_map; zmutex m_on_packet_map_lock; uint16_t m_index_off = 0; - function m_on_event; + onpacket_t m_on_event; zmutex txlock; @@ -68,7 +68,7 @@ class ZCanCommnaderMaster : public ZCanIRQListener, public IZcanCmderMaster { void setTxPacketInterval(int interval_ms) { txPacketInterval_ms = interval_ms; } virtual int32_t sendCmd(int32_t cmdid, int32_t moduleid, int32_t *param, size_t npara, int32_t *ack, size_t nack, int overtime_ms) override; virtual int32_t sendCmdAndReceiveBuf(int32_t cmdid, int32_t moduleid, int32_t *param, size_t npara, uint8_t *ack, int32_t *rxsize, int overtime_ms) override; - virtual void regEventPacketListener(function on_event) override; + virtual void regEventPacketListener(onpacket_t on_event) override; public: virtual void STM32_HAL_onCAN_RxFifo0MsgPending(CAN_HandleTypeDef *can); diff --git a/components/zprotocols/zcancmder_v2 b/components/zprotocols/zcancmder_v2 index 76e03ba..77d5673 160000 --- a/components/zprotocols/zcancmder_v2 +++ b/components/zprotocols/zcancmder_v2 @@ -1 +1 @@ -Subproject commit 76e03ba23018c81c2f904f3bfaaccff8d7e675c9 +Subproject commit 77d567330a2d005341f413743a8c16828e53d270