Merge branch 'master' of 192.168.1.3:manufacturer_stm32/iflytop_sdk

components/dwin/dwin.hpp

@@ -0,0 +1,4 @@
+#pragma once
+#include "dwin_screen.hpp"
+#include "text_displayer.hpp"
+#include "var_icon.hpp"

components/dwin/dwin_screen.cpp

@@ -0,0 +1,305 @@
+#include "dwin_screen.hpp"
+
+#include <string.h>
+using namespace iflytop;
+using namespace iflytop::dwin;
+
+#define TAG "dwin"
+
+void DwinScreen::init(UART_HandleTypeDef* huart, int __) {
+  m_huart = huart;
+  ZUART::cfg_t cfg;
+  cfg.huart         = m_huart;
+  cfg.name          = "DwinScreenUart";
+  cfg.rxbuffersize  = RX_CACHE_SIZE;
+  cfg.rxovertime_ms = 2;
+  m_uarthandler.initialize(&cfg);
+
+  m_uarthandler.startRxIt();
+
+  m_uarthandler.setrxcb([this](uint8_t* data, size_t len) {
+    if (txcontext.receipt_ready_flag) {
+      return;
+    }
+    memcpy(txcontext.receiptcache, data, len);
+    txcontext.receiptlen         = len;
+    txcontext.receipt_ready_flag = true;
+  });
+}
+
+void DwinScreen::clearrxcache() {
+  CriticalContext cc;
+  txcontext.receipt_ready_flag = false;
+  txcontext.receiptlen         = 0;
+}
+void DwinScreen::sendcmd(uint8_t* cmd, size_t len) {
+  // printf("sendcmd:");
+  // for (size_t i = 0; i < len; i++) {
+  //   ZLOGE(TAG,"%02X ", cmd[i]);
+  // }
+  // printf("\n");
+  m_uarthandler.tx(cmd, len);
+  // m_com.send((char*)cmd, len);
+}
+
+bool DwinScreen::sendcmdblock(int overtime) {
+  clearrxcache();
+  sendcmd(txcontext.txcache, txcontext.txlen);
+  for (int i = 0; i < overtime; i++) {
+    if (txcontext.receipt_ready_flag) {
+      return true;
+    } else {
+      m_uarthandler.forceCchedule();
+      chip_delay_ms(1);
+    }
+  }
+  return false;
+}
+
+bool DwinScreen::write_varspace(uint16_t regaddr, uint8_t* data, uint8_t len, int overtime) {
+  /**
+   * @brief
+   *
+   *  2byte   1byte    cmd          add     val
+   *  5AA5   datalen   0x82          2      xbyte
+   *
+   */
+  txcontext.txcache[0] = 0x5A;
+  txcontext.txcache[1] = 0xA5;
+  txcontext.txcache[2] = 0;  // data len
+  txcontext.txcache[3] = 0x82;
+  txcontext.txcache[4] = regaddr >> 8;
+  txcontext.txcache[5] = regaddr & 0xFF;
+
+  memcpy(&txcontext.txcache[6], data, len);
+  txcontext.txcache[2] = len + 1 + 2;  //
+
+  txcontext.txlen = 6 + len;
+
+  if (!sendcmdblock(overtime)) {
+    ZLOGE(TAG, "write_varspace failed");
+    return false;
+  }
+  return true;
+}
+bool DwinScreen::read_varspace(uint16_t regaddr, uint8_t* data, uint8_t len, int overtime) {
+  /**
+   * @brief
+   *
+   *  2byte   1byte    cmd          add     val
+   *  5AA5   datalen   0x82          2      xbyte
+   *
+   */
+  txcontext.txcache[0] = 0x5A;
+  txcontext.txcache[1] = 0xA5;
+  txcontext.txcache[2] = 0;  // data len
+  txcontext.txcache[3] = 0x83;
+  txcontext.txcache[4] = regaddr >> 8;
+  txcontext.txcache[5] = regaddr & 0xFF;
+  txcontext.txcache[6] = len / 2;  // word len
+
+  txcontext.txcache[2] = 4;  //
+  txcontext.txlen      = 7;
+
+  if (!sendcmdblock(overtime)) {
+    ZLOGE(TAG, "read_varspace failed");
+    return false;
+  }
+  memcpy(data, &txcontext.receiptcache[7], len);
+  return true;
+}
+
+bool DwinScreen::write_reg16(uint16_t regaddr, uint16_t data, int overtime) {  //
+  uint8_t data8[2];
+  data8[0] = data >> 8;
+  data8[1] = data & 0xFF;
+
+  return write_reg(regaddr, data8, 2, overtime);
+}
+
+bool DwinScreen::read_reg16(uint16_t regaddr, uint16_t& data, int overtime) {
+  uint8_t data8[2];
+  bool    suc = read_reg(regaddr, data8, 2, overtime);
+  if (!suc) return false;
+
+  data = data8[0] << 8 | data8[1];
+  return true;
+}
+
+bool DwinScreen::write_varspace16(uint16_t regaddr, uint16_t data, int overtime) {  //
+  uint8_t data8[2];
+  data8[0] = data >> 8;
+  data8[1] = data & 0xFF;
+
+  return write_varspace(regaddr, data8, 2, overtime);
+}
+
+bool DwinScreen::write_varspace16_muti(uint16_t regaddr, uint16_t* data, size_t n16, int overtime) {
+  for (size_t i = 0; i < n16; i++) {
+    m_tx_pre_processcache[i * 2]     = data[i] >> 8;
+    m_tx_pre_processcache[i * 2 + 1] = data[i] & 0xFF;
+  }
+  return write_varspace(regaddr, m_tx_pre_processcache, n16 * 2, overtime);
+}
+
+bool DwinScreen::read_varspace16_muti(uint16_t regaddr, uint16_t* data, size_t n16, int overtime) {
+  // TODO: CHECK BUFSIZE
+  memset(m_rd_pre_processcache, 0, sizeof(m_rd_pre_processcache));
+  bool suc = read_varspace(regaddr, m_rd_pre_processcache, n16 * 2, overtime);
+  if (!suc) return false;
+
+  for (size_t i = 0; i < n16; i++) {
+    data[i] = m_rd_pre_processcache[i * 2] << 8 | m_rd_pre_processcache[i * 2 + 1];
+  }
+  return true;
+}
+
+bool DwinScreen::read_varspace16(uint16_t regaddr, uint16_t& data, int overtime) {
+  uint8_t data8[2];
+  bool    suc = read_varspace(regaddr, data8, 2, overtime);
+  if (!suc) return false;
+
+  data = data8[0] << 8 | data8[1];
+  return true;
+}
+
+bool DwinScreen::write_varspace8(uint16_t regaddr, uint16_t subadd, uint16_t data, int overtime) {
+  uint16_t val = 0;
+  bool     suc = read_varspace16(regaddr, val, overtime);
+  if (!suc) return false;
+
+  if (subadd == 0) {
+    // H
+    val = val & 0x00FF;
+    val = val | ((data << 8) & 0xff00);
+  } else {
+    // L
+    val = val & 0xFF00;
+    val = val | (data & 0xff);
+  }
+
+  suc = write_varspace16(regaddr, val, overtime);
+  if (!suc) return false;
+  return true;
+}
+bool DwinScreen::read_varspace8(uint16_t regaddr, uint16_t subadd, uint16_t& data, int overtime) {
+  uint16_t val = 0;
+  bool     suc = read_varspace16(regaddr, val, overtime);
+  if (!suc) return false;
+
+  if (subadd == 0) {
+    // H
+    data = val >> 8;
+  } else {
+    // L
+    data = val & 0xff;
+  }
+  return true;
+}
+
+bool DwinScreen::write_reg(uint16_t regaddr, uint8_t* data, size_t len, int overtime) {
+  /**
+   * @brief
+   *
+   *  2byte   1byte    cmd          add     val
+   *  5AA5   datalen   0x82          2      xbyte
+   *
+   */
+  txcontext.txcache[0] = 0x5A;
+  txcontext.txcache[1] = 0xA5;
+  txcontext.txcache[2] = 0;  // data len
+  txcontext.txcache[3] = 0x80;
+  txcontext.txcache[4] = regaddr >> 8;
+  txcontext.txcache[5] = regaddr & 0xFF;
+
+  memcpy(&txcontext.txcache[6], data, len);
+  txcontext.txcache[2] = len + 1 + 2;  //
+
+  txcontext.txlen = 6 + len;
+
+  if (!sendcmdblock(overtime)) {
+    ZLOGE(TAG, "write_reg failed");
+    return false;
+  }
+  return true;
+}
+bool DwinScreen::read_reg(uint16_t regaddr, uint8_t* data, size_t len, int overtime) {
+  /**
+   * @brief
+   *
+   *  2byte   1byte    cmd          add     val
+   *  5AA5   datalen   0x82          2      xbyte
+   *
+   */
+  txcontext.txcache[0] = 0x5A;
+  txcontext.txcache[1] = 0xA5;
+  txcontext.txcache[2] = 0;  // data len
+  txcontext.txcache[3] = 0x81;
+  txcontext.txcache[4] = regaddr >> 8;
+  txcontext.txcache[5] = regaddr & 0xFF;
+  txcontext.txcache[6] = len / 2;  // word len
+
+  txcontext.txcache[2] = 4;  //
+  txcontext.txlen      = 7;
+
+  if (!sendcmdblock(overtime)) {
+    ZLOGE(TAG, "read_varspace failed");
+    return false;
+  }
+  memcpy(data, &txcontext.receiptcache[7], len);
+  return true;
+}
+
+bool DwinScreen::set_page(uint16_t pageid) {
+  uint16_t data[2] = {0x5A01, pageid};
+  return write_varspace16_muti(0x84, data, 2, 10);
+}
+uint16_t DwinScreen::get_page() {
+  uint16_t page = 0;
+  read_varspace16(0x14, page, 100);
+  return page;
+}
+bool DwinScreen::ping() {
+  uint16_t page = 0;
+  bool     suc  = read_varspace16(0x14, page, 100);
+  return suc;
+}
+
+bool DwinScreen::set_brightness(uint16_t brightness) {
+  // 5A A5 04 82 0082 0A
+  uint8_t data[3] = {0, 0x82, (uint8_t)brightness};
+  return write_varspace(0x82, data, 3, 10);
+}
+bool DwinScreen::set_rtc(uint16_t year, uint16_t month, uint16_t day, uint16_t hour, uint16_t minute, uint16_t second) {
+  year = year - 2000;
+
+  uint16_t year_month = year << 8 | month;
+  uint16_t day_hour   = day << 8 | hour;
+  uint16_t min_second = minute << 8 | second;
+  uint16_t data[4]    = {0x5AA5, year_month, day_hour, min_second};
+  return write_varspace16_muti(0x9C, data, 4, 10);
+}
+
+bool DwinScreen::get_rtc(Date* date) {
+  uint16_t data[4] = {0};
+  bool     suc     = read_varspace16_muti(0x10, data, 4, 10);
+  // printf("data[0]:%04X data[1]:%04X data[2]:%04X data[3]:%04X\n", data[0], data[1], data[2], data[3]);
+  // date->year       = (data[0] >> 8) + 2000;
+  // date->month      = data[0] & 0xFF;
+  // date->day        = data[1] >> 8;
+  // date->weekdaynum = data[1] & 0xFF;
+  // date->hour       = data[2] >> 8;
+  // date->minute     = data[2] & 0xFF;
+  // date->second     = data[3] >> 8;
+
+  date->year       = (data[0] & 0xff) + 2000;
+  date->month      = data[1] >> 8;
+  date->day        = data[1] & 0xFF;
+  date->weekdaynum = data[2] >> 8;
+  date->hour       = data[2] & 0xFF;
+  date->minute     = data[3] >> 8;
+  date->second     = data[3] & 0xFF;
+  printf("year:%d month:%d day:%d weekdaynum:%d hour:%d minute:%d second:%d\n",  //
+         date->year, date->month, date->day, date->weekdaynum, date->hour, date->minute, date->second);
+  return suc;
+}

components/dwin/dwin_screen.hpp

@@ -0,0 +1,97 @@
+#pragma once
+#include "sdk\hal\zhal.hpp"
+namespace iflytop {
+namespace dwin {
+using namespace std;
+
+/**
+ * @brief
+ *
+ *  2byte   1byte    cmd        data        crc
+ *  5AA5     01   0x82/0x83    1->249
+ *
+ *  2byte   1byte    cmd        data        crc
+ *  5AA5     01   0x81/0x80    1->249
+ */
+
+#define TX_CACHE_SIZE 256
+#define RX_CACHE_SIZE 256
+
+class DwinScreen {
+ public:
+  class Date {
+   public:
+    uint16_t year;
+    uint16_t month;
+    uint16_t day;
+    uint16_t hour;
+    uint16_t minute;
+    uint16_t second;
+    uint16_t weekdaynum;  // 星期几
+  };
+
+ private:
+  class TxContext {
+   public:
+    uint8_t txcache[TX_CACHE_SIZE];
+    uint8_t txlen;
+    uint8_t receiptcache[RX_CACHE_SIZE];
+    uint8_t receiptlen;
+    bool    receipt_ready_flag = false;
+  };
+
+ private:
+  UART_HandleTypeDef* m_huart;
+  ZUART               m_uarthandler;
+
+  TxContext txcontext;
+
+  uint8_t m_tx_pre_processcache[TX_CACHE_SIZE];
+  uint8_t m_rd_pre_processcache[RX_CACHE_SIZE];
+
+  bool enablecrc = false;
+
+ public:
+  /**
+   * @brief
+   *
+   * @param huart 串口
+   * @param baudrate 波特率（暂时不支持设置）
+   */
+  void init(UART_HandleTypeDef* huart, int __ = 0);
+
+ public:
+  bool     set_page(uint16_t pageid);
+  uint16_t get_page();
+  bool     set_brightness(uint16_t brightness);
+  bool     set_rtc(uint16_t year, uint16_t month, uint16_t day, uint16_t hour, uint16_t minute, uint16_t second);
+  bool     get_rtc(Date* date);
+
+  bool ping();
+
+ public:
+  bool write_reg16(uint16_t regaddr, uint16_t data, int overtime);
+  bool read_reg16(uint16_t regaddr, uint16_t& data, int overtime);
+
+  bool write_reg(uint16_t regaddr, uint8_t* data, size_t len, int overtime);
+  bool read_reg(uint16_t regaddr, uint8_t* data, size_t len, int overtime);
+
+  bool write_varspace16(uint16_t regaddr, uint16_t data, int overtime);
+  bool read_varspace16(uint16_t regaddr, uint16_t& data, int overtime);
+
+  bool write_varspace16_muti(uint16_t regaddr, uint16_t* data, size_t n16, int overtime);
+  bool read_varspace16_muti(uint16_t regaddr, uint16_t* data, size_t n16, int overtime);
+
+  bool write_varspace8(uint16_t regaddr, uint16_t subadd, uint16_t data, int overtime);
+  bool read_varspace8(uint16_t regaddr, uint16_t subadd, uint16_t& data, int overtime);
+
+  bool write_varspace(uint16_t regaddr, uint8_t* data, uint8_t len, int overtime);
+  bool read_varspace(uint16_t regaddr, uint8_t* data, uint8_t len, int overtime);
+
+ private:
+  void clearrxcache();
+  void sendcmd(uint8_t* cmd, size_t len);
+  bool sendcmdblock(int overtime);
+};
+}  // namespace dwin
+}  // namespace iflytop

components/dwin/text_displayer.cpp

@@ -0,0 +1,70 @@
+#include "text_displayer.hpp"
+
+#include <string.h>
+using namespace iflytop::dwin;
+using namespace iflytop;
+using namespace std;
+#define DO(x)                   \
+  if (!x) {                     \
+    printf("do %s fail\n", #x); \
+    return false;               \
+  }
+static uint8_t txcache[256];
+
+bool TextDisplayer::init(DwinScreen *dwin_screen, uint16_t descript_add, uint16_t val_add) {
+  //
+  m_dwin_screen  = dwin_screen;
+  m_descript_add = descript_add;
+  printf("TextDisplayer init %04x\n", m_descript_add);
+  readcfg();
+  if (val_add != 0) {
+    m_descript.VP = val_add;
+    flushcfg();
+  }
+  return true;
+}
+
+bool TextDisplayer::flushcfg() { return m_dwin_screen->write_varspace16_muti(m_descript_add, (uint16_t *)&m_descript, sizeof(m_descript) / 2, 100); }
+bool TextDisplayer::readcfg() { return m_dwin_screen->read_varspace16_muti(m_descript_add, (uint16_t *)&m_descript, sizeof(m_descript) / 2, 100); }
+void TextDisplayer::setFont(uint16_t EncodeMode, uint8_t font0id, uint8_t font1id, uint16_t frontxsize, uint16_t frontysize) {
+  m_descript.EncodeMode = EncodeMode;
+  m_descript.Font0ID    = font0id;
+  m_descript.Font1ID    = font1id;
+  m_descript.FontYDots  = frontysize;
+  m_descript.FontXDots  = frontxsize;
+  m_descript.TextLength = 256;
+}
+void TextDisplayer::setPos(uint16_t x, uint16_t y, uint16_t width, uint16_t hight) {
+  uint16_t startx = x;
+  uint16_t endx   = x + width;
+  uint16_t starty = y;
+  uint16_t endy   = y + hight;
+
+  m_descript.PosX = x;
+  m_descript.PosY = y;
+  m_descript.Xs   = x;
+  m_descript.Ys   = y;
+  m_descript.Xe   = endx;
+  m_descript.Ye   = endy;
+}
+bool TextDisplayer::setTextLengthDirect(uint16_t len) {
+  DO(m_dwin_screen->write_varspace16(m_descript_add + 8, len, 100));
+  return true;
+}
+
+bool TextDisplayer::setVal(const char *val) {
+  memset(txcache, 0, sizeof(txcache));
+  memcpy(txcache, val, strlen(val));
+  DO(m_dwin_screen->write_varspace(m_descript.VP, txcache, strlen(val) + 2, 100));
+
+#if 0
+  uint16_t zero = 0;
+  setTextLengthDirect(0);
+  m_dwin_screen->write_varspace(m_descript.VP, (uint8_t *)val, strlen(val), 100);
+  setTextLengthDirect((uint16_t)strlen(val));
+  m_descript.TextLength = (uint16_t)strlen(val);
+#endif
+  return true;
+}
+void TextDisplayer::setColor(uint16_t color) { m_descript.Color = color; }
+void TextDisplayer::dumpinfo() {}

components/dwin/text_displayer.hpp

@@ -0,0 +1,109 @@
+#pragma once
+
+#include "sdk\components\dwin\dwin_screen.hpp"
+namespace iflytop {
+namespace dwin {
+
+using namespace std;
+/**
+ * @brief
+ *
+ * 0x00  *VP
+ *
+ */
+
+/**
+ *
+ * 0x00: *VP                  2  文本指针。
+ * 0x01: (X,Y)                4  起始显示位置，显示字符串左上角坐标。
+ * 0x03: Color                2  显示文本颜色。
+ * 0x04: (xs,Ys)(xe,Ye)       8  文本框。
+ * 0x08: Text_Length          2  显示字节数量，当遇到0xFFFF、0x0000或者显示到文本框尾将不再显示。
+ * 0x09: Font0_ID(H)          1  编码方式为0x01-0x04时的ASII字符使用的字库位置。
+ * 0x09: Font1_ID(L)          1  编码方式为0x00、0x05，以及0x01-0x04时的非ASCII字符使用的字库位置。
+ * 0x0A: Font_x_Dots(H)       1  字体x方向点阵数（0x01-0x04模式，ASCII字符的x方向点阵数按照x/2计算）。
+ * 0x0A: Font_Y_Dots(L)       1  字体Y方向点阵数。
+ * 0x0B: Encode_Mode(H)       1  .7定义了文本显示的字符间距是否自动调整；
+ *                               .7=0 字符间距自动调整；
+ *                               .7=1字符间距不自动调整，字符宽度固定为设定的点阵数。
+ *                               .6-.0定义了文本编码方式：0=8bit编码1=GB2312内码2=GBK 3=BIG5 4=SJIS 5=UNICODE
+ * 0x0B: HOR_Dis(L            1  字符水平间隔。
+ * 0x0C: VER_Dis(H)           1  字符垂直间隔。
+ * 0x0C: 未定义(L)             1 写0x00
+ *
+ */
+#pragma pack(1)
+typedef struct {
+  uint16_t VP;
+  uint16_t PosX;
+  uint16_t PosY;
+  uint16_t Color;
+  uint16_t Xs;
+  uint16_t Ys;
+  uint16_t Xe;
+  uint16_t Ye;
+  uint16_t TextLength;
+
+  uint8_t Font1ID;
+  uint8_t Font0ID;
+
+  uint8_t FontYDots;
+  uint8_t FontXDots;
+
+  uint8_t LHORDis;
+  uint8_t EncodeMode;  // [7:7] 0字符间距自动调整,1字符间距不自动调整 [6:0] 0=8bit编码1=GB2312内码2=GBK 3=BIG5 4=SJIS 5=UNICODE
+
+  uint8_t mark;
+  uint8_t LVERDis;
+} TextDisplayerDescript_t;
+#pragma pack()
+
+typedef enum {
+  kcolor_red   = 0xF800,
+  kcolor_black = 0x0000,
+  kcolor_white = 0xFFFF,
+  kcolor_grey  = 0xc618,
+} dwincolor_t;
+
+class TextDisplayer {
+  DwinScreen *m_dwin_screen = nullptr;
+
+  uint16_t                m_descript_add = 0;
+  TextDisplayerDescript_t m_descript;
+
+ public:
+  bool init(DwinScreen *dwin_screen, uint16_t descript_add, uint16_t val_add);
+  /**
+   * @brief Set the Font object
+   *
+   * @param EncodeMode [7:7] 0字符间距自动调整,1字符间距不自动调整 [6:0] 0=8bit编码1=GB2312内码2=GBK 3=BIG5 4=SJIS 5=UNICODE
+   * @param font0id
+   * @param font1id
+   */
+  void setFont(uint16_t EncodeMode, uint8_t font0id, uint8_t font1id, uint16_t frontxsize, uint16_t frontysize);
+  /**
+   * @brief Set the Pos object
+   *
+   * @param x
+   * @param y
+   * @param width 文本框宽度
+   * @param hight 文本框高度
+   */
+  void setPos(uint16_t x, uint16_t y, uint16_t width, uint16_t hight);
+  /**
+   * @brief 设置文本
+   *
+   * @param
+   */
+  bool setVal(const char *val);
+  void setColor(uint16_t color);
+
+  bool setTextLengthDirect(uint16_t len);
+
+ public:
+  bool flushcfg();
+  bool readcfg();
+  void dumpinfo();
+};
+}  // namespace dwin
+}  // namespace iflytop

components/dwin/var_icon.cpp

@@ -0,0 +1,56 @@
+#include "var_icon.hpp"
+using namespace iflytop;
+using namespace dwin;
+#define DO(x)                   \
+  if (!x) {                     \
+    printf("do %s fail\n", #x); \
+    return false;               \
+  }
+static uint32_t s_VarIconNum = 0;
+
+bool VarIcon::flushcfg() { return m_dwin_screen->write_varspace16_muti(m_descript_add, (uint16_t *)&m_descript, sizeof(m_descript) / 2, 100); }
+bool VarIcon::readcfg() { return m_dwin_screen->read_varspace16_muti(m_descript_add, (uint16_t *)&m_descript, sizeof(m_descript) / 2, 100); }
+
+bool VarIcon::init(DwinScreen *dwin_screen, uint16_t descript_add) {
+  //
+  m_dwin_screen  = dwin_screen;
+  m_descript_add = descript_add;
+  s_VarIconNum++;
+  printf("VarIcon(%d) init %04x\n", s_VarIconNum, m_descript_add);
+  readcfg();
+  return true;
+}
+void VarIcon::initcfg(uint16_t valpointerAdd, uint16_t initval, uint16_t posx, uint16_t posy, uint16_t iconlib, uint16_t iconmin, uint16_t iconmax) {
+  m_descript.m_VP        = valpointerAdd;
+  m_descript.m_PosX      = posx;
+  m_descript.m_PosY      = posy;
+  m_descript.m_VMin      = 0;
+  m_descript.m_VMax      = iconmax - iconmin;
+  m_descript.m_IconMin   = iconmin;
+  m_descript.m_IconMax   = iconmax;
+  m_descript.m_IconLib   = iconlib;
+  m_descript.m_Mode      = 1;
+  m_descript.m_LayerMode = 0;
+  m_descript.m_ICONGamma = 0;
+  m_descript.m_PICGamma  = 0;
+  m_descript.m_FilterSet = 0x3F;
+  flushcfg();
+  setVal(initval);
+}
+
+void VarIcon::dumpinfo() {
+  readcfg();
+  printf("m_VP        = %04x\n", m_descript.m_VP);
+  printf("m_PosX      = %d\n", m_descript.m_PosX);
+  printf("m_PosY      = %d\n", m_descript.m_PosY);
+  printf("m_VMin      = %d\n", m_descript.m_VMin);
+  printf("m_VMax      = %d\n", m_descript.m_VMax);
+  printf("m_IconMin   = %d\n", m_descript.m_IconMin);
+  printf("m_IconMax   = %d\n", m_descript.m_IconMax);
+  printf("m_IconLib   = %d\n", m_descript.m_IconLib);
+  printf("m_Mode      = %d\n", m_descript.m_Mode);
+  printf("m_LayerMode = %d\n", m_descript.m_LayerMode);
+  printf("m_ICONGamma = %d\n", m_descript.m_ICONGamma);
+  printf("m_PICGamma  = %d\n", m_descript.m_PICGamma);
+  printf("m_FilterSet = %04x\n", m_descript.m_FilterSet);
+}

components/dwin/var_icon.hpp

@@ -0,0 +1,58 @@
+#pragma once
+
+#include "sdk\components\dwin\dwin_screen.hpp"
+
+namespace iflytop {
+namespace dwin {
+using namespace std;
+
+#pragma pack(1)
+typedef struct {
+  uint16_t m_VP      = 0;
+  uint16_t m_PosX    = 0;
+  uint16_t m_PosY    = 0;
+  uint16_t m_VMin    = 0;
+  uint16_t m_VMax    = 0;
+  uint16_t m_IconMin = 0;
+  uint16_t m_IconMax = 0;
+
+  uint8_t m_Mode    = 0;
+  uint8_t m_IconLib = 0;
+
+  uint8_t m_ICONGamma = 0;
+  uint8_t m_LayerMode = 0;
+
+  uint8_t m_FilterSet = 0;
+  uint8_t m_PICGamma  = 0;
+} VarIconDescript_t;
+#pragma pack()
+
+class VarIcon {
+  DwinScreen *m_dwin_screen = nullptr;
+
+  uint16_t          m_descript_add = 0;
+  VarIconDescript_t m_descript;
+
+ public:
+  bool init(DwinScreen *dwin_screen, uint16_t descript_add);
+  void initcfg(uint16_t valpointerAdd, uint16_t initval, uint16_t posx, uint16_t posy, uint16_t iconlib, uint16_t iconmin, uint16_t iconmax);
+
+ public:
+  bool flushcfg();
+  bool readcfg();
+
+  bool     setVal(uint16_t val) { return m_dwin_screen->write_varspace16(m_descript.m_VP, val, 100); }
+  uint16_t getVal() {
+    uint16_t val = 0xffff;
+    m_dwin_screen->read_varspace16(m_descript.m_VP, val, 100);
+    return val;
+  }
+
+  VarIconDescript_t &getDescript() { return m_descript; }
+
+  void dumpinfo();
+
+ public:
+};
+}  // namespace dwin
+}  // namespace iflytop

components/iflytop_can_slave_modules/io_control_service.cpp

@@ -1,4 +1,5 @@
 #include "io_control_service.hpp"
+#ifdef HAL_CAN_MODULE_ENABLED
 using namespace iflytop;
 void IOControlService::initialize(IflytopCanProtocolStackProcesser* protocol_processer, int32_t regStartOff, write_io_cb_t write_io_cb,
                                   read_io_cb_t read_io_cb) {
@@ -101,4 +102,5 @@ uint32_t IOControlService::readgpiotable0() {
   return val;
 }
 
-// uint32_t IOControlService::readgpiotable1() {}
+// uint32_t IOControlService::readgpiotable1() {}
+#endif

components/iflytop_can_slave_v1/iflytop_can_slave.hpp

@@ -4,6 +4,8 @@
 
 #pragma once
 #include "iflytop_can_slave_protocol.hpp"
+#ifdef HAL_CAN_MODULE_ENABLED
+
 /**
  * @brief
  *
@@ -239,4 +241,5 @@ class ICPSUtils {
   static int32_t mutiValToRegVal(int8_t var1, int8_t var2, int8_t var3, int8_t var4) { return (var4 << 24) | (var3 << 16) | (var2 << 8) | (var1 & 0xFF); }
 };
 
-}  // namespace iflytop
+}  // namespace iflytop
+#endif

components/key_monitor/key_service.cpp

@@ -0,0 +1,76 @@
+#include "key_service.hpp"
+using namespace iflytop;
+#define TAG "KeyService"
+void KeyService::initialize(int keyBufferSize, KeyListener_t listener) {
+  m_keys = (Key*)malloc(sizeof(Key) * keyBufferSize);
+  ZASSERT(m_keys != NULL);
+  this->keyBufferSize = keyBufferSize;
+  m_listener          = listener;
+  m_lastcallticket    = 0;
+  ZHALCORE::getInstance()->regPeriodJob([this](ZHALCORE::Context& ct) { periodicJob(); }, 20);
+}
+
+KeyService::KeyService() {}
+KeyService::~KeyService() {}
+void KeyService::pushKey(const char* name, ZGPIO* gpio) {
+  ZASSERT(m_numKey < keyBufferSize);
+  Key* key                    = &m_keys[m_numKey];
+  key->name                   = name;
+  key->gpio                   = gpio;
+  key->last_io_state          = key->gpio->getState();
+  key->keep_state_count       = 0;
+  key->hasProcessed           = false;
+  key->after_filter_state     = false;
+  key->currentstatekeep_count = 0;
+  m_numKey++;
+}
+
+void KeyService::processEachAfterFilter(Key* each, bool now_io_state) {
+  KeyEventContext context;
+  if (now_io_state != each->last_after_filter_io_state) {
+    if (now_io_state) {
+      each->keep_state_count = 0;
+      each->hasProcessed     = false;
+      //   each->cur_state        = zks_rising_edge;
+      context.key   = each;
+      context.gpio  = each->gpio;
+      context.event = zks_rising_edge;
+
+      m_listener(each, zks_rising_edge, &context);
+    } else {
+      m_listener(each, zks_falling_edge, &context);
+      each->keep_state_count = 0;
+    }
+    each->last_after_filter_io_state = now_io_state;
+  } else {
+    if (now_io_state) {
+      m_listener(each, zks_keep, &context);
+    }
+  }
+}
+
+void KeyService::processKey(Key* each) {
+  /**
+   * @brief zkey_process_each
+   */
+  each->keep_state_count++;
+
+  bool now_io_state = each->gpio->getState();
+  if (each->currentstatekeep_count < 1000) {
+    each->currentstatekeep_count++;
+  }
+  if (now_io_state != each->last_io_state) {
+    each->currentstatekeep_count = 0;
+  }
+  if (each->currentstatekeep_count >= 1) {
+    each->after_filter_state = now_io_state;
+  }
+  each->last_io_state = now_io_state;
+  processEachAfterFilter(each, each->after_filter_state);
+}
+
+void KeyService::periodicJob() {
+  for (int i = 0; i < m_numKey; i++) {
+    processKey(&m_keys[i]);
+  }
+}

components/key_monitor/key_service.hpp

@@ -0,0 +1,67 @@
+#pragma once
+#include <stdint.h>
+
+#include "sdk\hal\zhal.hpp"
+namespace iflytop {
+using namespace std;
+class KeyService;
+typedef enum {
+  // mode1
+  zks_keep,
+  zks_rising_edge,
+  zks_falling_edge,
+
+  // mode2
+  zks_trigger_event,
+  zks_longtime_trigger_event,
+} KeyEvent_t;
+
+typedef struct Key_s {
+ public:
+  const char* name;
+  ZGPIO*      gpio;
+  bool        last_io_state;
+  bool        last_after_filter_io_state;
+
+  // zkey_state_t cur_state;        /**/
+  uint32_t keep_state_count; 
+
+  bool hasProcessed; /*useful for user*/
+  bool after_filter_state;
+
+  uint32_t currentstatekeep_count;  // 
+} Key;
+
+class KeyEventContext {
+ public:
+  KeyEvent_t event;
+  ZGPIO*     gpio;
+  Key*       key;
+};
+
+class KeyService {
+ public:
+  typedef function<void(Key* key, KeyEvent_t event, KeyEventContext* context)> KeyListener_t;
+
+ private:
+  /* data */
+  KeyListener_t m_listener;
+  Key*          m_keys;
+  int           keyBufferSize;
+  int           m_numKey;
+  uint32_t      m_lastcallticket;
+
+ public:
+  KeyService();
+  ~KeyService();
+
+  void initialize(int keyBufferSize, KeyListener_t listener);
+  void pushKey(const char* name, ZGPIO* gpio);
+
+ private:
+  void periodicJob();
+  void processKey(Key* each);
+  void processEachAfterFilter(Key* each, bool now_io_state);
+};
+
+}  // namespace iflytop

components/tmc/ic/ztmc4361A.cpp

@@ -1,6 +1,8 @@
 #if 1
 #include "ztmc4361A.hpp"
 
+#ifdef HAL_SPI_MODULE_ENABLED
+
 #include <stdarg.h>
 
 #include "../basic/basic.hpp"
@@ -361,3 +363,5 @@ void TMC4361A::driverIC_setIHOLD_IRUN(uint8_t ihold, uint8_t irun, uint16_t ihol
 
 #endif
 #endif
+
+#endif

components/tmc/ic/ztmc4361A.hpp

@@ -13,6 +13,8 @@ extern "C" {
 #include "TMC2160\TMC2160.h"
 #include "TMC4361A\TMC4361A.h"
 }
+#ifdef HAL_SPI_MODULE_ENABLED
+
 namespace iflytop {
 #define TMC4361A_LISTENER_MAX 5
 class TMC4361A : public IStepperMotor {
@@ -153,3 +155,4 @@ class TMC4361A : public IStepperMotor {
 }  // namespace iflytop
 
 #endif
+#endif

components/tmc/ic/ztmc5130.cpp

@@ -1,4 +1,6 @@
 #include "ztmc5130.hpp"
+#ifdef HAL_SPI_MODULE_ENABLED
+
 using namespace iflytop;
 
 /**
@@ -192,3 +194,4 @@ int32_t TMC5130::readInt(uint8_t address) {
 
   return ((uint32_t)data[1] << 24) | ((uint32_t)data[2] << 16) | (data[3] << 8) | data[4];
 }
+#endif

components/tmc/ic/ztmc5130.hpp

@@ -9,6 +9,7 @@
 extern "C" {
 #include "TMC5130\TMC5130.h"
 }
+#ifdef HAL_SPI_MODULE_ENABLED
 namespace iflytop {
 #define TMC5130_LISTENER_MAX 5
 /**
@@ -138,4 +139,5 @@ class TMC5130 : public IStepperMotor {
  private:
   uint32_t haspassedms(uint32_t now, uint32_t last);
 };
-}  // namespace iflytop
+}  // namespace iflytop
+#endif

hal/zcan.cpp

@@ -1,8 +1,8 @@
 #include "zcan.hpp"
+#ifdef HAL_CAN_MODULE_ENABLED
 
 extern "C" {
 
-#ifdef HAL_CAN_MODULE_ENABLED
 void HAL_CAN_TxMailbox0CompleteCallback(CAN_HandleTypeDef *hcan) {
   for (int i = 0; i < iflytop::ZCanIRQDispatcher::instance().m_listenerNum; i++) {
     iflytop::ZCanIRQDispatcher::instance().m_listener[i]->STM32_HAL_onCAN_TxMailbox0Complete(hcan);

hal/zuart.cpp

@@ -167,6 +167,8 @@ void ZUART::periodicJob() {
   }
 }
 
+void ZUART::forceCchedule() { periodicJob(); }
+
 /*******************************************************************************
  *                                    中断                                     *
  *******************************************************************************/

hal/zuart.hpp

@@ -44,8 +44,9 @@ class ZUART {
   bool tx(const char *data);
   bool tx(uint8_t *data, size_t len);
   bool startRxIt();
-  
+
   void clearRxData();
+  void forceCchedule();
 
  public:
   void HAL_UART_TxCpltCallback();