update

components/eq_20_asb_motor/eq20_servomotor.cpp

@@ -3,64 +3,181 @@
 #include <stdint.h>
 
 #include "sdk\components\modbus\modbus_basic.hpp"
+#include "sdk\components\zprotocols\errorcode\errorcode.hpp"
 using namespace std;
 using namespace iflytop;
 
-static void dumpbuf(const char *mark, const char *buf, int len) {
-  printf("%s:", mark);
-  for (size_t i = 0; i < len; i++) {
-    printf("0x%02x ", (uint8_t)buf[i]);
-  }
-  printf("\n");
-}
-void Eq20ServoMotor::init(ModbusBlockHost *modbusBlockHost) {
+#define TAG "Eq20ServoMotor"
+
+void Eq20ServoMotor::init(ModbusBlockHost *modbusBlockHost, int id) {
   //  this->com = com;
   m_modbusBlockHost = modbusBlockHost;
+  m_deviceId        = id;
+  ZASSERT(m_modbusBlockHost != NULL);
 }
-bool Eq20ServoMotor::writereg32(int deviceid, uint32_t regadd, int value) {  //
-  m_modbusBlockHost->cleanRxBuff();
 
-  uint8_t sendBuff[30] = {0};
-  sendBuff[0]          = deviceid;
-  sendBuff[1]          = 0x10;
-  sendBuff[2]          = regadd / 256;  // regadd hi
-  sendBuff[3]          = regadd % 256;  // regadd li
-  sendBuff[4]          = (0);
-  sendBuff[5]          = (2);
-  sendBuff[6]          = 4;
+#define DO(exptr)                            \
+  {                                          \
+    int32_t __ret = exptr;                   \
+    if (__ret != 0) {                        \
+      ZLOGE(TAG, "do %s %d", #exptr, __ret); \
+      return __ret;                          \
+    }                                        \
+  }
 
-  sendBuff[7]  = (value >> 8) & 0xff;
-  sendBuff[8]  = (value >> 0) & 0xff;
-  sendBuff[9]  = (value >> 24) & 0xff;
-  sendBuff[10] = (value >> 16) & 0xff;
-  modbus_pack_crc_to_packet(sendBuff, 13);
+int32_t Eq20ServoMotor::move_to(int32_t topos, int32_t rpm, int32_t acctime) {
+#if 0
+write_pn 1 610 0x0001        # 接点1运行方式选择，相对运动
+write_pn 1 615 500     # 接点1运行速度rpm
+write_pn 1 614 10000  #正转1圈
+write_pn 1 616 100             #Pn616 接点 1 加速时间
+write_pn 1 617 100             #Pn617 接点 1 减速时间
+write_pn_bit 1 1501 0 0
+write_pn_bit 1 1501 0 1
+#endif
+  DO(write_pn(m_deviceId, 610, 0x0001));
+  DO(write_pn(m_deviceId, 615, rpm));
+  DO(write_pn(m_deviceId, 614, topos));
+  DO(write_pn(m_deviceId, 616, acctime));
+  DO(write_pn(m_deviceId, 617, acctime));
+  DO(write_pn_bit(m_deviceId, 1501, 0, 0));
+  DO(write_pn_bit(m_deviceId, 1501, 0, 1));
+  return 0;
+}
+int32_t Eq20ServoMotor::move_by(int32_t pos, int32_t rpm, int32_t acctime) {
+#if 0
+write_pn 1 610 0x0011        # 接点1运行方式选择，绝对位置运动
+write_pn 1 614 10000          #正转1圈
+write_pn 1 615 100             # 接点1运行速度rpm
+write_pn 1 616 100             #Pn616 接点 1 加速时间
+write_pn 1 617 100             #Pn617 接点 1 减速时间
+write_pn_bit 1 1501 0 0
+write_pn_bit 1 1501 0 1
+#endif
+  DO(write_pn(m_deviceId, 610, 0x0011));
+  DO(write_pn(m_deviceId, 614, pos));
+  DO(write_pn(m_deviceId, 615, rpm));
+  DO(write_pn(m_deviceId, 616, acctime));
+  DO(write_pn(m_deviceId, 617, acctime));
+  DO(write_pn_bit(m_deviceId, 1501, 0, 0));
+  DO(write_pn_bit(m_deviceId, 1501, 0, 1));
+  return 0;
+}
+int32_t Eq20ServoMotor::rotate(int32_t rpm, int32_t acctime) { return move_by(100000 * 10000, rpm, acctime); }
 
-  int sendBuff_length = 13;  // 2byte 校验
-  dumpbuf("tx", (char *)sendBuff, sendBuff_length);
+int32_t Eq20ServoMotor::move_to_zero_forward(int32_t lookzeropoint_rpm, int32_t findzero_edge_rpm, int32_t lookzeropoint_acc_time) {
+#if 0
+write_pn 1 600 8    # 回零方式选择
+write_pn 1 601 500  # 寻参速度 RPM
+write_pn 1 602 50    # 找零速度 RPM
+write_pn 1 603 100  # 回零动作加减速时间 ms
+write_pn 1 604 0    # 零点偏移量 0
+write_pn 1 605 0    # 回零动作超时时间
+write_pn 1 606 0    # 回零动作中止使能
+write_pn_bit 1 1501 1 0
+write_pn_bit 1 1501 1 1
+#endif
+  DO(write_pn(m_deviceId, 600, 11));
+  DO(write_pn(m_deviceId, 601, lookzeropoint_rpm));
+  DO(write_pn(m_deviceId, 602, findzero_edge_rpm));
+  DO(write_pn(m_deviceId, 603, lookzeropoint_acc_time));
+  DO(write_pn(m_deviceId, 604, 0));
+  DO(write_pn(m_deviceId, 605, 0));
+  DO(write_pn(m_deviceId, 606, 0));
+  DO(write_pn_bit(m_deviceId, 1501, 1, 0));
+  DO(write_pn_bit(m_deviceId, 1501, 1, 1));
+  return 0;
+}
+int32_t Eq20ServoMotor::move_to_zero_backward(int32_t lookzeropoint_rpm, int32_t findzero_edge_rpm, int32_t lookzeropoint_acc_time) {
+  DO(write_pn(m_deviceId, 600, 8));
+  DO(write_pn(m_deviceId, 601, lookzeropoint_rpm));
+  DO(write_pn(m_deviceId, 602, findzero_edge_rpm));
+  DO(write_pn(m_deviceId, 603, lookzeropoint_acc_time));
+  DO(write_pn(m_deviceId, 604, 0));  // 零点偏移
+  DO(write_pn(m_deviceId, 605, 0));  // 回零动作超时时间
+  DO(write_pn(m_deviceId, 606, 0));  // 回零动作中止使能
+  DO(write_pn_bit(m_deviceId, 1501, 1, 0));
+  DO(write_pn_bit(m_deviceId, 1501, 1, 1));
+  return 0;
+}
 
-  // int tx = com->send((char *)sendBuff, sendBuff_length);
-  HAL_StatusTypeDef statu = HAL_UART_Transmit(m_modbusBlockHost->huart, sendBuff, sendBuff_length, 1000);
-  if (statu != HAL_OK) {
-    ZLOGE("Eq20ServoMotor", "uart send error");
-    return false;
-  }
+int32_t Eq20ServoMotor::getpos(int32_t &pos) {
+  DO(readreg(m_deviceId, 2036, pos));
+  return 0;
+}
 
-  char rxbuf[30] = {0};
-  // int  rxsize    = com->receive(rxbuf, 8, 100);
-  statu = HAL_UART_Receive(m_modbusBlockHost->huart, (uint8_t *)rxbuf, 8, 100);
+int32_t Eq20ServoMotor::enable(int32_t enable) {
+  DO(write_pn_bit(m_deviceId, 1501, 2, enable));
+  return 0;
+}
 
-  if (statu != HAL_OK) {
-    ZLOGE("Eq20ServoMotor", "uart send error,overtime");
-    return false;
+int32_t Eq20ServoMotor::stop() {
+  DO(write_pn_bit(m_deviceId, 1501, 0, 0));
+  DO(write_pn_bit(m_deviceId, 1501, 1, 0));
+  return 0;
+}
+int32_t Eq20ServoMotor::isReachTarget(uint8_t &isReachTarget) {}
+
+#define AUTO_RESEND(exptr)                          \
+  int ret = 0;                                      \
+  for (size_t i = 0; i < m_auto_resendtimes; i++) { \
+    ret = exptr;                                    \
+    if (ret == 0) {                                 \
+      return 0;                                     \
+    }                                               \
   }
-  // dumpbuf("rx", rxbuf, rxsize);
-  return true;
-}
-// bool Eq20ServoMotor::readreg(int deviceid, uint32_t regadd, int &value) {
-//   uint16_t value16[2];
-//   m_modbusBlockHost->readReg03Muti(deviceid, regadd, value16, 2, 50);
-//   value = value16[0] + (value16[1] << 16);
-//   return true;
-// }
 
-//
+int32_t Eq20ServoMotor::writereg(int deviceid, uint32_t regadd, int32_t value) {  //
+  AUTO_RESEND(_writereg(deviceid, regadd, value));
+}
+int32_t Eq20ServoMotor::readreg(int deviceid, uint32_t regadd, int32_t &value) {  //
+  AUTO_RESEND(_readreg(deviceid, regadd, value));
+}
+int32_t Eq20ServoMotor::write_reg_bit(int deviceid, uint32_t regadd, int32_t off, int32_t value) {  //
+  AUTO_RESEND(_write_reg_bit(deviceid, regadd, off, value));
+}
+int32_t Eq20ServoMotor::write_pn(int deviceid, uint32_t pnadd, int32_t value) {  //
+  AUTO_RESEND(_write_pn(deviceid, pnadd, value));
+}
+int32_t Eq20ServoMotor::read_pn(int deviceid, uint32_t pnadd, int32_t &value) {  //
+  AUTO_RESEND(_read_pn(deviceid, pnadd, value));
+}
+int32_t Eq20ServoMotor::write_pn_bit(int deviceid, uint32_t pnadd, int32_t off, int32_t value) { AUTO_RESEND(_write_pn_bit(deviceid, pnadd, off, value)); }
+int32_t Eq20ServoMotor::read_reg_bit(int deviceid, uint32_t regadd, int32_t off, int32_t &value) { AUTO_RESEND(_read_reg_bit(deviceid, regadd, off, value)); }
+int32_t Eq20ServoMotor::read_pn_bit(int deviceid, uint32_t pnadd, int32_t off, int32_t &value) { AUTO_RESEND(_read_pn_bit(deviceid, pnadd, off, value)); }
+
+/*******************************************************************************
+ *                                  BASIC_API                                  *
+ *******************************************************************************/
+int32_t Eq20ServoMotor::_write_pn(int deviceid, uint32_t pnadd, int32_t value) { return _writereg(deviceid, pnadd * 2, value); }
+int32_t Eq20ServoMotor::_read_pn(int deviceid, uint32_t pnadd, int32_t &value) { return _readreg(deviceid, pnadd * 2, value); }
+int32_t Eq20ServoMotor::_write_pn_bit(int deviceid, uint32_t pnadd, int32_t off, int32_t value) { return _write_reg_bit(deviceid, pnadd * 2, off, value); }
+int32_t Eq20ServoMotor::_read_pn_bit(int deviceid, uint32_t pnadd, int32_t off, int32_t &value) { return _read_reg_bit(deviceid, pnadd * 2, off, value); }
+/*******************************************************************************
+ *                                     REG                                     *
+ *******************************************************************************/
+int32_t Eq20ServoMotor::_writereg(int deviceid, uint32_t regadd, int32_t value) {  //
+  DO(m_modbusBlockHost->writeReg10Muti(deviceid, regadd, (uint16_t *)&value, 2, 100));
+  return 0;
+}
+int32_t Eq20ServoMotor::_readreg(int deviceid, uint32_t regadd, int32_t &value) {  //
+  DO(m_modbusBlockHost->readReg03Muti(deviceid, regadd, (uint16_t *)&value, 2, 100));
+  return 0;
+}
+int32_t Eq20ServoMotor::_write_reg_bit(int deviceid, uint32_t regadd, int32_t off, int32_t value) {
+  int32_t regval;
+  DO(_readreg(deviceid, regadd, regval));
+  if (value) {
+    regval |= (1 << off);
+  } else {
+    regval &= ~(1 << off);
+  }
+  DO(_writereg(deviceid, regadd, regval));
+  return 0;
+}
+int32_t Eq20ServoMotor::_read_reg_bit(int deviceid, uint32_t regadd, int32_t off, int32_t &value) {
+  int32_t regval;
+  DO(_readreg(deviceid, regadd, regval));
+  value = (regval >> off) & 0x01;
+  return 0;
+}

components/eq_20_asb_motor/eq20_servomotor.hpp

@@ -3,22 +3,62 @@
 // #include "com.hpp"
 #include "sdk/os/zos.hpp"
 #include "sdk\components\modbus\modbus_block_host.hpp"
+#include "sdk\components\zprotocols\zcancmder\api\basic_type.hpp"
 namespace iflytop {
 using namespace std;
 
 class Eq20ServoMotor {
+ public:
  private:
   ModbusBlockHost *m_modbusBlockHost;
+  int32_t          m_deviceId         = 0;
+  int32_t          m_auto_resendtimes = 3;
 
  public:
   Eq20ServoMotor(/* args */){};
   ~Eq20ServoMotor(){};
 
-  void init(ModbusBlockHost *modbusBlockHost);
-  bool writereg32(int deviceid, uint32_t regadd, int value);
-  bool writePn(int deviceid, uint32_t pnadd, int value) { return writereg32(deviceid, pnadd * 2, value); }
+  void init(ModbusBlockHost *modbusBlockHost, int id);
+
+  int32_t enable(int32_t enable);
+
+  int32_t move_to(int32_t topos, int32_t rpm, int32_t acctime);
+  int32_t move_by(int32_t pos, int32_t rpm, int32_t acctime);
+  int32_t rotate(int32_t rpm, int32_t acctime);
+
+  int32_t move_to_zero_forward(int32_t lookzeropoint_rpm, int32_t findzero_edge_rpm, int32_t lookzeropoint_acc_time);
+  int32_t move_to_zero_backward(int32_t lookzeropoint_rpm, int32_t findzero_edge_rpm, int32_t lookzeropoint_acc_time);
+
+  int32_t stop();
+  int32_t isReachTarget(uint8_t &isReachTarget);
+
+  int32_t getpos(int32_t &pos);
+
+ public:
+  int32_t writereg(int deviceid, uint32_t regadd, int32_t value);
+  int32_t readreg(int deviceid, uint32_t regadd, int32_t &value);
+  int32_t write_reg_bit(int deviceid, uint32_t regadd, int32_t off, int32_t value);
+  int32_t read_reg_bit(int deviceid, uint32_t regadd, int32_t off, int32_t &value);
+
+  int32_t read_pn(int deviceid, uint32_t pnadd, int32_t &value);
+  int32_t write_pn(int deviceid, uint32_t pnadd, int32_t value);
+  int32_t write_pn_bit(int deviceid, uint32_t pnadd, int32_t off, int32_t value);
+  int32_t read_pn_bit(int deviceid, uint32_t pnadd, int32_t off, int32_t &value);
+
+ private:
+  int32_t _writereg(int deviceid, uint32_t regadd, int32_t value);
+  int32_t _readreg(int deviceid, uint32_t regadd, int32_t &value);
+  int32_t _write_reg_bit(int deviceid, uint32_t regadd, int32_t off, int32_t value);
+  int32_t _read_reg_bit(int deviceid, uint32_t regadd, int32_t off, int32_t &value);
+
+  int32_t _write_pn(int deviceid, uint32_t pnadd, int32_t value);
+  int32_t _read_pn(int deviceid, uint32_t pnadd, int32_t &value);
+  int32_t _write_pn_bit(int deviceid, uint32_t pnadd, int32_t off, int32_t value);
+  int32_t _read_pn_bit(int deviceid, uint32_t pnadd, int32_t off, int32_t &value);
 
  private:
+  int32_t send(uint8_t *data, size_t len, int32_t overtime);
+  int32_t receive(uint8_t *rxbuf, size_t len, int32_t overtime);
 };
 
 }  // namespace iflytop

components/hardware/uart/zuart_helper.cpp

@@ -0,0 +1,61 @@
+#include "zuart_helper.hpp"
+using namespace iflytop;
+#define DEBUG 0
+#if DEBUG
+static void dumphex(char* tag, uint8_t* data, uint8_t len) {
+  printf("%s:", tag);
+  for (int i = 0; i < len; i++) {
+    printf("%02x ", data[i]);
+  }
+  printf("\n");
+}
+#endif
+
+ZUARTHelper::ZUARTHelper(const char* tag, UART_HandleTypeDef* uart, DMA_HandleTypeDef* hdma_tx, DMA_HandleTypeDef* hdma_rx) {
+  m_uart    = uart;
+  m_hdma_tx = hdma_tx;
+  m_hdma_rx = hdma_rx;
+  m_tag     = tag;
+}
+
+void ZUARTHelper::cleanRxBuff() {
+  HAL_StatusTypeDef status;
+  uint8_t           datacache;
+  do {
+    status = HAL_UART_Receive(m_uart, &datacache, 1, 1);
+  } while (status == HAL_OK);
+}
+int32_t ZUARTHelper::tx_and_rx(uint8_t* tx, uint8_t txdatalen, uint8_t* rx, uint8_t expectrxsize, uint16_t overtimems) {
+  uint32_t enter_ticket = HAL_GetTick();
+#if DEBUG
+  dumphex("tx:", tx, txdatalen);
+#endif
+
+  HAL_UART_Transmit(m_uart, tx, txdatalen, 1000);
+  HAL_UART_Receive_DMA(m_uart, (uint8_t*)rx, expectrxsize);
+
+  bool overtime_flag = false;
+  while (HAL_UART_GetState(m_uart) == HAL_UART_STATE_BUSY_RX ||  //
+         HAL_UART_GetState(m_uart) == HAL_UART_STATE_BUSY_TX_RX) {
+    osDelay(1);
+    int rxsize = expectrxsize - __HAL_DMA_GET_COUNTER(m_hdma_rx);
+    if (rxsize == expectrxsize) {
+#if DEBUG
+      dumphex("rx:", rx, expectrxsize);
+#endif
+      break;
+    }
+    if (zos_haspassedms(enter_ticket) > overtimems) {
+      if (expectrxsize != 0 && rxsize != 0) {
+        ZLOGW(m_tag, "txandrx overtime rxsize:%d != expect_size:%d", rxsize, expectrxsize);
+      }
+      overtime_flag = true;
+      break;
+    }
+  }
+  HAL_UART_DMAStop(m_uart);
+  if (overtime_flag) {
+    return false;
+  }
+  return true;
+}

components/hardware/uart/zuart_helper.hpp

@@ -0,0 +1,23 @@
+#pragma once
+#include <functional>
+
+#include "sdk\os\zos.hpp"
+namespace iflytop {
+using namespace std;
+class ZUARTHelper {
+ private:
+  const char*         m_tag     = "";
+  UART_HandleTypeDef* m_uart    = NULL;
+  DMA_HandleTypeDef*  m_hdma_tx = NULL;
+  DMA_HandleTypeDef*  m_hdma_rx = NULL;
+
+ public:
+  ZUARTHelper(const char* tag, UART_HandleTypeDef* uart, DMA_HandleTypeDef* hdma_tx, DMA_HandleTypeDef* hdma_rx);
+  ZUARTHelper(){};
+
+  UART_HandleTypeDef* get_uart() { return m_uart; }
+
+  int32_t tx_and_rx(uint8_t* tx, uint8_t txdatalen, uint8_t* rx, uint8_t expectrxsize, uint16_t overtimems);
+  void    cleanRxBuff();
+};
+}  // namespace iflytop

components/modbus/modbus_block_host.cpp

@@ -1,138 +1,102 @@
 #include "modbus_block_host.hpp"
 
 #include "modbus_basic.hpp"
+#include "sdk\components\zprotocols\errorcode\errorcode.hpp"
 using namespace iflytop;
-#define DEBUG 1
-ModbusBlockHost::ModbusBlockHost() {}
-ModbusBlockHost::~ModbusBlockHost() {}
 
-void ModbusBlockHost::initialize(UART_HandleTypeDef *huart) { this->huart = huart; }
-void ModbusBlockHost::cleanRxBuff() {  //
-  HAL_StatusTypeDef status;
-  do {
-    status = HAL_UART_Receive(huart, rxbuff, 1, 1);
-  } while (status == HAL_OK);
-}
+#define TAG "ModbusBlockHost"
 
-void ModbusBlockHost::uarttx(uint8_t *buff, size_t len) {
-  ZASSERT(len < sizeof(txbuff));
-#if DEBUG
-  printf("uarttx:\n");
-  for (size_t i = 0; i < len; i++) {
-    printf("%02x ", buff[i]);
-  }
-  printf("\n");
-#endif
-  HAL_UART_Transmit(huart, buff, len, 1000);
-}
-bool ModbusBlockHost::uartrx(uint8_t *buff, size_t len, int overtimems) {
-  HAL_StatusTypeDef status;
-  ZASSERT(len < sizeof(rxbuff));
-
-  status = HAL_UART_Receive(huart, buff, len, overtimems);
-#if DEBUG
-  if (status == HAL_OK) {
-    printf("uartrx:");
-    for (size_t i = 0; i < len; i++) {
-      printf("%02x ", buff[i]);
-    }
-    printf("\n");
+#define DO(exptr)                            \
+  {                                          \
+    int32_t __ret = exptr;                   \
+    if (__ret != 0) {                        \
+      ZLOGE(TAG, "do %s %d", #exptr, __ret); \
+      return __ret;                          \
+    }                                        \
   }
-#endif
-  return status == HAL_OK;
-}
 
-bool ModbusBlockHost::readReg03(uint8_t slaveAddr, uint16_t regAddr, uint16_t *regVal, int overtimems) {
-  txbuff[0] = slaveAddr;
-  txbuff[1] = 0x03;
-  txbuff[2] = regAddr >> 8;
-  txbuff[3] = regAddr & 0xff;
-  txbuff[4] = 0x00;
-  txbuff[5] = 0x01;
-  modbus_pack_crc_to_packet(txbuff, 6 + 2);
+#define DEBUG 0
+ModbusBlockHost::ModbusBlockHost() {}
+ModbusBlockHost::~ModbusBlockHost() {}
 
-  cleanRxBuff();
+void ModbusBlockHost::initialize(UART_HandleTypeDef *m_huart, DMA_HandleTypeDef *hdma_tx, DMA_HandleTypeDef *hdma_rx) {
+  // m_huart   = m_huart;
+  // m_hdma_tx = hdma_tx;
+  // m_hdma_rx = hdma_rx;
 
-  uarttx(txbuff, 6 + 2);
+  m_zuartHelper = ZUARTHelper(TAG, m_huart, hdma_tx, hdma_rx);
 
-  bool status;
-  status = uartrx(rxbuff, 5 + 2, overtimems);
+  m_mutex.init();
+}
+void ModbusBlockHost::cleanRxBuff() {  //
+  m_zuartHelper.cleanRxBuff();
+}
 
-  if (status && modbus_checkcrc16(rxbuff, 7)) {
-    *regVal = rxbuff[3] << 8 | rxbuff[4];
-    return true;
-  }
-  return false;
+int32_t ModbusBlockHost::readReg03(uint8_t slaveAddr, uint16_t regAddr, uint16_t *regVal, int overtimems) {  //
+  int32_t status = readReg03Muti(slaveAddr, regAddr, regVal, 1, overtimems);
+  return status;
 }
 
-bool ModbusBlockHost::readReg03Muti(uint8_t slaveAddr, uint16_t regAddr, uint16_t *regVal, int regNum, int overtimems) {
-  txbuff[0] = slaveAddr;
-  txbuff[1] = 0x03;
-  txbuff[2] = regAddr >> 8;
-  txbuff[3] = regAddr & 0xff;
-  txbuff[4] = 0x00;
-  txbuff[5] = regNum;
-  modbus_pack_crc_to_packet(txbuff, 6 + 2);
+int32_t ModbusBlockHost::readReg03Muti(uint8_t slaveAddr, uint16_t regAddr, uint16_t *regVal, int regNum, int overtimems) {
+  m_txbuff[0] = slaveAddr;
+  m_txbuff[1] = 0x03;
+  m_txbuff[2] = regAddr >> 8;
+  m_txbuff[3] = regAddr & 0xff;
+  m_txbuff[4] = 0x00;
+  m_txbuff[5] = regNum;
+  modbus_pack_crc_to_packet(m_txbuff, 6 + 2);
 
   cleanRxBuff();
-
-  uarttx(txbuff, 6 + 2);
-
-  bool status;
-  // 14*2 = 28
-  status = uartrx(rxbuff, 5 + regNum * 2, overtimems);
-
-  if (status && modbus_checkcrc16(rxbuff, 7 + regNum * 2)) {
-    for (int i = 0; i < regNum; i++) {
-      regVal[i] = rxbuff[3 + i * 2] << 8 | rxbuff[4 + i * 2];
-    }
-    return true;
+  DO(m_zuartHelper.tx_and_rx(m_txbuff, 6 + 2, m_rxbuff, 5 + regNum * 2, overtimems));
+  if (!modbus_checkcrc16(m_rxbuff, 7 + regNum * 2)) {
+    return err::kce_modbusCRC16checkfail;
+  }
+  for (int i = 0; i < regNum; i++) {
+    regVal[i] = m_rxbuff[3 + i * 2] << 8 | m_rxbuff[4 + i * 2];
   }
-  return false;
+  return 0;
 }
 
-bool ModbusBlockHost::writeReg06(uint8_t slaveAddr, uint16_t regAddr, uint16_t regVal, int overtimems) {
-  txbuff[0] = slaveAddr;
-  txbuff[1] = 0x06;
-  txbuff[2] = regAddr >> 8;
-  txbuff[3] = regAddr & 0xff;
-  txbuff[4] = regVal >> 8;
-  txbuff[5] = regVal & 0xff;
-  modbus_pack_crc_to_packet(txbuff, 6 + 2);
+int32_t ModbusBlockHost::writeReg06(uint8_t slaveAddr, uint16_t regAddr, uint16_t regVal, int overtimems) {
+  m_txbuff[0] = slaveAddr;
+  m_txbuff[1] = 0x06;
+  m_txbuff[2] = regAddr >> 8;
+  m_txbuff[3] = regAddr & 0xff;
+  m_txbuff[4] = regVal >> 8;
+  m_txbuff[5] = regVal & 0xff;
+  modbus_pack_crc_to_packet(m_txbuff, 6 + 2);
 
   cleanRxBuff();
 
-  uarttx(txbuff, 6 + 2);
-
-  bool status;
-  status = uartrx(rxbuff, 8, overtimems);
+  DO(m_zuartHelper.tx_and_rx(m_txbuff, 6 + 2, m_rxbuff, 8, overtimems));
 
-  if (status && modbus_checkcrc16(rxbuff, 8)) {
-    return true;
+  if (!modbus_checkcrc16(m_rxbuff, 8)) {
+    return err::kce_modbusCRC16checkfail;
   }
-  return false;
+  return 0;
 }
-bool ModbusBlockHost::writeReg10(uint8_t slaveAddr, uint16_t regAddr, uint16_t regVal, int overtimems) {
-  txbuff[0] = slaveAddr;
-  txbuff[1] = 0x10;
-  txbuff[2] = regAddr >> 8;
-  txbuff[3] = regAddr & 0xff;
-  txbuff[4] = 0x00;
-  txbuff[5] = 0x01;
-  txbuff[6] = 0x02;  // ×Ö½ÚÊý
-  txbuff[7] = regVal >> 8;
-  txbuff[8] = regVal & 0xff;
-  modbus_pack_crc_to_packet(txbuff, 9 + 2);
+int32_t ModbusBlockHost::writeReg10(uint8_t slaveAddr, uint16_t regAddr, uint16_t regVal, int overtimems) { return writeReg10Muti(slaveAddr, regAddr, &regVal, 1, overtimems); }
+
+int32_t ModbusBlockHost::writeReg10Muti(uint8_t slaveAddr, uint16_t regAddr, uint16_t *regVal, uint16_t nreg, int overtimems) {
+  m_txbuff[0] = slaveAddr;
+  m_txbuff[1] = 0x10;
+  m_txbuff[2] = regAddr >> 8;
+  m_txbuff[3] = regAddr & 0xff;
+  m_txbuff[4] = 0x00;
+  m_txbuff[5] = nreg;
+  m_txbuff[6] = nreg * 2;  // ×Ö½ÚÊý
+  for (int i = 0; i < nreg; i++) {
+    m_txbuff[7 + i * 2] = regVal[i] >> 8;
+    m_txbuff[8 + i * 2] = regVal[i] & 0xff;
+  }
+  modbus_pack_crc_to_packet(m_txbuff, 7 + nreg * 2 + 2);
 
   cleanRxBuff();
 
-  uarttx(txbuff, 9 + 2);
-
-  bool status;
-  status = uartrx(rxbuff, 8, overtimems);
+  DO(m_zuartHelper.tx_and_rx(m_txbuff, 7 + nreg * 2 + 2, m_rxbuff, 8, overtimems));
 
-  if (status && modbus_checkcrc16(rxbuff, 8)) {
-    return true;
+  if (!modbus_checkcrc16(m_rxbuff, 8)) {
+    return err::kce_modbusCRC16checkfail;
   }
-  return false;
+  return 0;
 }

components/modbus/modbus_block_host.hpp

@@ -1,29 +1,31 @@
 #pragma once
 #include "sdk/os/zos.hpp"
+#include "sdk\components\hardware\uart\zuart_helper.hpp"
+#include "sdk\os\mutex.hpp"
 
 namespace iflytop {
 class ModbusBlockHost {
  public:
-  UART_HandleTypeDef *huart;
+  ZUARTHelper m_zuartHelper;
+  zmutex      m_mutex;
 
-  uint8_t txbuff[100];
-  uint8_t rxbuff[100];
+  uint8_t m_txbuff[200];  // 大概支持同时读20个寄存器
+  uint8_t m_rxbuff[200];  // 大概支持同时读20个寄存器
 
  public:
   ModbusBlockHost();
   ~ModbusBlockHost();
 
-  void initialize(UART_HandleTypeDef *huart);
+  void initialize(UART_HandleTypeDef *huart, DMA_HandleTypeDef *hdma_tx, DMA_HandleTypeDef *hdma_rx);
 
-  bool readReg03(uint8_t slaveAddr, uint16_t regAddr, uint16_t *regVal, int overtimems);
-  bool readReg03Muti(uint8_t slaveAddr, uint16_t regAddr, uint16_t *regVal, int regNum, int overtimems);
-  bool writeReg06(uint8_t slaveAddr, uint16_t regAddr, uint16_t regVal, int overtimems);
-  bool writeReg10(uint8_t slaveAddr, uint16_t regAddr, uint16_t regVal, int overtimems);
+  int32_t readReg03(uint8_t slaveAddr, uint16_t regAddr, uint16_t *regVal, int overtimems);
+  int32_t readReg03Muti(uint8_t slaveAddr, uint16_t regAddr, uint16_t *regVal, int regNum, int overtimems);
+  int32_t writeReg06(uint8_t slaveAddr, uint16_t regAddr, uint16_t regVal, int overtimems);
+  int32_t writeReg10(uint8_t slaveAddr, uint16_t regAddr, uint16_t regVal, int overtimems);
+  int32_t writeReg10Muti(uint8_t slaveAddr, uint16_t regAddr, uint16_t *regVal, uint16_t nreg, int overtimems);
 
   void cleanRxBuff();
 
  private:
-  void uarttx(uint8_t *buff, size_t len);
-  bool uartrx(uint8_t *buff, size_t len, int overtimems);
 };
 }  // namespace iflytop

components/zprotocols/errorcode

@@ -1 +1 @@
-Subproject commit 0d0b37363452b7ae7ca442bf924bf8ba021b5a62
+Subproject commit a3197d626bc551983a5598d3c3a35e8e4de63e35