update

components/zcancmder/basic.cpp

@@ -22,11 +22,11 @@ uint8_t CanPacketRxBuffer::get_packetType() {
   zcr_cmd_header_t *cmdheader = (zcr_cmd_header_t *)rxdata;
   return cmdheader->packetType;
 }
-uint8_t *CanPacketRxBuffer::get_data() {
+uint8_t *CanPacketRxBuffer::get_params() {
   zcr_cmd_header_t *cmdheader = (zcr_cmd_header_t *)rxdata;
   return cmdheader->data;
 }
-uint16_t CanPacketRxBuffer::get_datalen() { return rxdataSize - sizeof(zcr_cmd_header_t); }
+uint16_t CanPacketRxBuffer::get_params_len() { return rxdataSize - sizeof(zcr_cmd_header_t); }
 void     CanPacketRxBuffer::clear() {
   id = 0;
   memset(&m_canPacket, 0, sizeof(m_canPacket) / sizeof(m_canPacket[0]));
@@ -51,3 +51,6 @@ zcr_cmd_header_t *CanPacketRxBuffer::get_cmdheader() {
   zcr_cmd_header_t *cmdheader = (zcr_cmd_header_t *)rxdata;
   return cmdheader;
 }
+
+uint8_t *CanPacketRxBuffer::get_rx_raw() { return rxdata; }
+uint16_t CanPacketRxBuffer::get_rx_raw_len() { return rxdataSize; }

components/zcancmder/basic.hpp

@@ -44,17 +44,20 @@ class CanPacketRxBuffer {
   uint16_t get_cmdid();
   uint8_t  get_cmdSubId();
   uint8_t  get_packetType();
-  uint8_t *get_data();
-  uint16_t get_datalen();
+  uint8_t *get_params();
+  uint16_t get_params_len();
   void     clear();
 
+  uint8_t* get_rx_raw();
+  uint16_t get_rx_raw_len();
+
   zcr_cmd_header_t *get_cmdheader();
 
   bool iscmd(int32_t id);
 
   template <typename T>
-  T *get_data_as() {
-    return (T *)get_data();
+  T *get_param_as() {
+    return (T *)get_params();
   }
 };
 

components/zcancmder/zcanreceiver.cpp

@@ -350,7 +350,7 @@ void ZCanCmder::loop() {
     rxbuf->rxdataSize = dataoff;
 
     for (auto &var : m_listenerList) {
-      if (var) var->onRceivePacket(rxbuf->get_cmdheader(), rxbuf->get_data(), rxbuf->get_datalen());
+      if (var) var->onRceivePacket(rxbuf->get_cmdheader(), rxbuf->get_params(), rxbuf->get_params_len());
     }
     rxbuf->dataIsReady = false;
   }

components/zcancmder/zcanreceiver_master.cpp

@@ -137,13 +137,13 @@ int32_t ZCanCommnaderMaster::sendCmdAndReceiveBuf(int32_t cmdid, int32_t subModu
   int32_t errocode      = 0;
   regListener(cmdheader->packetindex, [this, &rxdataIsReady, &ack, &rxsize, &errocode](CanPacketRxBuffer *report) {
     if (report->get_cmdheader()->packetType == kptv2_error_ack) {
-      auto *error_ack = report->get_data_as<int32_t>();
+      auto *error_ack = report->get_param_as<int32_t>();
       errocode        = *error_ack;
-    } else if (*rxsize < report->get_datalen()) {
+    } else if (*rxsize < report->get_params_len()) {
       errocode = err::kbuffer_not_enough;
     } else {
-      *rxsize = report->get_datalen();
-      memcpy(ack, report->get_data(), *rxsize);
+      *rxsize = report->get_params_len();
+      memcpy(ack, report->get_params(), *rxsize);
     }
     rxdataIsReady = true;
   });
@@ -192,12 +192,12 @@ int32_t ZCanCommnaderMaster::sendCmd(int32_t cmdid, int32_t subModuleid, int32_t
   regListener(cmdheader->packetindex, [this, &rxdataIsReady, &ack, &nack, &errocode](CanPacketRxBuffer *report) {
     // ZLOGI(TAG, "....................................");
     if (report->get_cmdheader()->packetType == kptv2_error_ack) {
-      auto *error_ack = report->get_data_as<int32_t>();
+      auto *error_ack = report->get_param_as<int32_t>();
       errocode        = *error_ack;
       // ZLOGI(TAG, "error_ack %d %s", *error_ack, err::error2str(*error_ack));
     } else {
       // ZLOGI(TAG, "%d %d", report->get_datalen(), nack);
-      int32_t *rxbuf = report->get_data_as<int32_t>();
+      int32_t *rxbuf = report->get_param_as<int32_t>();
       if (ack != nullptr && nack != 0) {
         for (size_t i = 0; i < nack; i++) {
           // ZLOGI(TAG, "ack[%d] = %d", i, rxbuf[i]);
@@ -267,7 +267,7 @@ void ZCanCommnaderMaster::callListener(CanPacketRxBuffer *report) {
   uint16_t index = report->get_cmdheader()->packetindex;
 
   if (m_rawpacketcb) {
-    m_rawpacketcb(report->get_data(), report->get_datalen());
+    m_rawpacketcb(report->get_rx_raw(), report->get_rx_raw_len());
   }
 
   if (report->get_cmdheader()->packetType == kptv2_ack || report->get_cmdheader()->packetType == kptv2_error_ack) {
@@ -279,7 +279,7 @@ void ZCanCommnaderMaster::callListener(CanPacketRxBuffer *report) {
   }
 
   if (report->get_cmdheader()->packetType == kptv2_event) {
-    if (m_on_event) m_on_event(report->id, report->get_cmdheader(), report->get_datalen());
+    if (m_on_event) m_on_event(report->id, report->get_cmdheader(), report->get_params_len());
   }
 }
 

components/zcancmder_module/zcan_basic_order_module.cpp

@@ -22,7 +22,7 @@ void ZCanBasicOrderModule::reg_read_adc(uint8_t id, readadcval_t fn) { m_readAdc
 
 void ZCanBasicOrderModule::onRceivePacket(CanPacketRxBuffer* rxbuf) {
   if (rxbuf->iscmd(kcmd_ping)) {
-    kcmd_ping_cmd_t* pingcmd = rxbuf->get_data_as<kcmd_ping_cmd_t>();
+    kcmd_ping_cmd_t* pingcmd = rxbuf->get_param_as<kcmd_ping_cmd_t>();
     kcmd_ping_ack_t* ack     = (kcmd_ping_ack_t*)txbuff;
 
     if (pingcmd->boardid == m_zcanReceiver->getDeviceId()) {
@@ -31,7 +31,7 @@ void ZCanBasicOrderModule::onRceivePacket(CanPacketRxBuffer* rxbuf) {
       return;
     }
   } else if (rxbuf->iscmd(kcmd_read_io)) {
-    kcmd_read_io_cmd_t* cmd = rxbuf->get_data_as<kcmd_read_io_cmd_t>();
+    kcmd_read_io_cmd_t* cmd = rxbuf->get_param_as<kcmd_read_io_cmd_t>();
     kcmd_read_io_ack_t* ack = (kcmd_read_io_ack_t*)txbuff;
     bool                val = false;
 
@@ -43,7 +43,7 @@ void ZCanBasicOrderModule::onRceivePacket(CanPacketRxBuffer* rxbuf) {
     }
 
   } else if (rxbuf->iscmd(kcmd_set_io)) {
-    kcmd_set_io_cmd_t* cmd = rxbuf->get_data_as<kcmd_set_io_cmd_t>();
+    kcmd_set_io_cmd_t* cmd = rxbuf->get_param_as<kcmd_set_io_cmd_t>();
     kcmd_set_io_ack_t  ack;
     bool               val = cmd->val;
 
@@ -56,7 +56,7 @@ void ZCanBasicOrderModule::onRceivePacket(CanPacketRxBuffer* rxbuf) {
     }
 
   } else if (rxbuf->iscmd(kcmd_readadc_raw)) {
-    kcmd_readadc_raw_cmd_t* cmd = rxbuf->get_data_as<kcmd_readadc_raw_cmd_t>();
+    kcmd_readadc_raw_cmd_t* cmd = rxbuf->get_param_as<kcmd_readadc_raw_cmd_t>();
     kcmd_readadc_raw_ack_t  ack;
     int32_t                 val = 0;
     if (m_readAdcValMap.find(cmd->sensorid) != m_readAdcValMap.end()) {