update

chip/api/zi_adc.hpp

@@ -0,0 +1,17 @@
+#pragma once
+#include <stdint.h>
+
+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

chip/api/zi_api.hpp

@@ -0,0 +1,3 @@
+#pragma once
+#include "zi_adc.hpp"
+#include "sdk\components\zprotocols\zcancmder_v2\api\errorcode.hpp"

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; }

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();
 };

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);
   }
-}
+}
+void ZIRQDispatcher::_callOnUartIrq(uart_irq_t irq_type, uart_irq_data_t data) {
+  for (auto &listener : m_onuartirqs) {
+    listener(irq_type, data);
+  }
+}

chip/zirq_dispatcher.hpp

@@ -8,17 +8,39 @@ namespace iflytop {
 using namespace std;
 class ZIRQDispatcher {
  public:
-  typedef function<void(zchip_tim_t *)> 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<ontimirq_t> m_ontimirqs;
+  typedef struct {
+    UART_HandleTypeDef *huart;
+    uint16_t            Size;
+  } uart_irq_data_t;
+
+ public:
+  typedef function<void(zchip_tim_t *)>                             ontimirq_t;
+  typedef function<void(uart_irq_t irq_type, uart_irq_data_t data)> on_uart_irq_t;
+
+  list<ontimirq_t>    m_ontimirqs;
+  list<on_uart_irq_t> 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

chip/zuart.cpp

@@ -3,8 +3,11 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+
+#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); }
 

components/cmdscheduler/cmd_scheduler_uart_dma.cpp

@@ -0,0 +1,199 @@
+
+#include "cmd_scheduler_uart_dma.hpp"
+
+#include <stdlib.h>
+#include <string.h>
+
+#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

components/cmdscheduler/cmd_scheduler_uart_dma.hpp

@@ -0,0 +1,51 @@
+#pragma once
+#include <map>
+#include <string>
+
+#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<string, CMD> 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

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);
+}

components/hardware/adc/z_simple_adc.hpp

@@ -0,0 +1,64 @@
+#pragma once
+#include <functional>
+
+#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

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);
+}

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

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<void(uint8_t *data, size_t len)> 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());
   }
 }
 

components/zcancmder/zcanreceiver_master.hpp

@@ -56,7 +56,7 @@ class ZCanCommnaderMaster : public ZCanIRQListener, public IZcanCmderMaster {
   map<uint16_t, ZCanCommnaderMasterListener> m_on_packet_map;
   zmutex                                     m_on_packet_map_lock;
   uint16_t                                   m_index_off = 0;
-  function<void(uint8_t *data, size_t len)>  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<void(uint8_t *data, size_t len)> on_event) override;
+  virtual void    regEventPacketListener(onpacket_t on_event) override;
 
  public:
   virtual void STM32_HAL_onCAN_RxFifo0MsgPending(CAN_HandleTypeDef *can);

components/zprotocols/zcancmder_v2

@@ -1 +1 @@
-Subproject commit 76e03ba23018c81c2f904f3bfaaccff8d7e675c9
+Subproject commit 77d567330a2d005341f413743a8c16828e53d270