update

src/iflytop/components/iflytop_front_end_service/iflytop_front_end_service.cpp

@@ -151,8 +151,8 @@ void IflytopFrontEndService::processRxMessage(weak_ptr<WebSocket> webSocket, con
       logger->error("m_iflytopWSService:onMessag,process rx json failed,exception:{},{}", e.what(), msgtext);
       if (command.find("need_receipt") == command.end() || command["need_receipt"]) {
         shared_ptr<WebSocket> ws = webSocket.lock();
-        receipt["ackcode"]       = err::zecode(err::kparse_json_err);
-        receipt["ackcodeInfo"]   = err::zecode2str(err::kparse_json_err, e.what());
+        receipt["ackcode"]       = err::kparse_json_err;
+        receipt["ackcodeInfo"]   = err::error2str(err::kparse_json_err);
 
         if (ws) ws->sendText(receipt.dump(1));
       }

src/iflytop/components/zcanreceiver/cmd.hpp

@@ -1,48 +0,0 @@
-#pragma once
-#include <fstream>
-#include <iostream>
-#include <list>
-#include <map>
-#include <memory>
-#include <sstream>
-#include <string>
-#include <vector>
-#include <set>
-#include <functional>
-namespace iflytop {
-namespace zcr {
-
-typedef struct {
-  uint16_t packetindex;
-  uint16_t cmdid;
-  uint8_t  subcmdid;
-  uint8_t  packetType;
-  uint8_t  data[];
-} Cmdheader_t;
-
-typedef enum {
-  kpt_cmd           = 0,
-  kpt_ack           = 1,
-  kpt_error_ack     = 2,
-  kpt_status_report = 3,
-} PacketType_t;
-
-typedef enum {
-  kcmd_ping    = 0,
-  kcmd_read_io = 1,
-  kcmd_set_io  = 2,
-
-  kcmd_m211887_operation             = 1000,  // 维萨拉压力传感器
-  kcmd_read_presure_sensor           = 1001,
-  kcmd_triple_warning_light_ctl      = 1002,
-  kcmd_high_power_electrical_ctl     = 1003,
-  kcmd_peristaltic_pump_ctl          = 1004,
-  kcmd_read_huacheng_pressure_sensor = 1005,
-} CmdID_t;
-
-}  // namespace zcr
-}  // namespace iflytop
-
-/**
- * @brief
- */

src/iflytop/components/zcanreceiver/zcanhost.cpp

@@ -1,5 +1,5 @@
 #include "zcanhost.hpp"
-
+#if 0
 using namespace iflytop;
 using namespace core;
 using namespace zcr;
@@ -440,3 +440,4 @@ int32_t ZCanHost::hpp272_read_c1000(int sensorid, hpp272_data_t& value) {
   memcpy(&value, &rx->data[2], sizeof(hpp272_data_t));
   return 0;
 }
+#endif

src/iflytop/components/zcanreceiver/zcanhost.hpp

@@ -1,7 +1,7 @@
 //
 // Created by zwsd
 //
-
+#if 0
 #pragma once
 
 #include "cmd.hpp"
@@ -110,4 +110,6 @@ class ZCanHost {
   int32_t huacheng_pressure_sensor_read_c1005(int sensorid, huacheng_pressure_sensor_read_c1005_t& value);
 };
 
-}  // namespace iflytop
+}  // namespace iflytop
+
+#endif

src/iflytop/components/zcanreceiver/zcanreceiver_master.cpp

@@ -0,0 +1,171 @@
+#include "zcanreceiver_master.hpp"
+using namespace iflytop;
+using namespace std;
+using namespace core;
+
+void ZcanReceiverMaster::initialize(string can_if_name, int baudrate, bool enablLoopback) {  //
+  m_zcanReceiverHost = make_shared<ZCanReceiverHost>();
+  m_zcanReceiverHost->initialize(can_if_name, baudrate, enablLoopback);
+  m_zcanReceiverHost->registerListener([this](uint8_t fromboardid, uint8_t *packet, size_t len) {  //
+    zcr_cmd_header_t *header = (zcr_cmd_header_t *)packet;
+    /**
+     * @brief 路由规则
+     *
+     * 1. event事件，触发m_onevent
+     * 2. ack,如果index是60000以上触发m_localonpacket回调
+     * 3. 所有packet均触发m_onpacket回调
+     *
+     */
+
+    // 过滤掉回执中index大于60000的回执
+    if (header->packetType == kptv2_ack || header->packetType == kptv2_error_ack) {
+      if (header->packetindex < 60000) {
+        if (m_onpacket) m_onpacket(fromboardid, header, len);
+      }
+    } else {
+      if (m_onpacket) m_onpacket(fromboardid, header, len);
+      if (header->packetType == kptv2_event) {
+        if (m_onevent) m_onevent(fromboardid, header, len);
+      }
+    }
+
+    /*******************************************************************************
+     *                                  本地消息处理                                 *
+     *******************************************************************************/
+    if (header->packetType == kptv2_ack || header->packetType == kptv2_error_ack) {
+      if (header->packetindex >= 60000) {
+        callLocalPacketListener(fromboardid, header, len);
+      }
+    }
+
+  });
+  return;
+}
+
+void ZcanReceiverMaster::sendraw(uint8_t *packet, size_t len) { m_zcanReceiverHost->sendPacket(packet, len); }
+
+int32_t ZcanReceiverMaster::sendCmd(int32_t cmdid, int32_t submoduleid, int32_t *param, size_t npara, int32_t *ack, size_t nack, int overtime_ms) {  //
+  std::lock_guard<std::recursive_mutex> lock(sendlock_);
+  uint8_t                               txbuff[1024];
+  zcr_cmd_header_t                     *cmdheader = (zcr_cmd_header_t *)txbuff;
+  cmdheader->packetType                           = kptv2_cmd;
+  cmdheader->packetindex                          = generateFreeIndex();
+  cmdheader->cmdmoduleid                          = MODULE_CMDID(cmdid);
+  cmdheader->subcmdid                             = SUBCMDID(cmdid);
+  cmdheader->submoduleid                          = submoduleid;
+
+  int32_t *sendparam = (int32_t *)cmdheader->data;
+  for (size_t i = 0; i < npara; i++) {
+    sendparam[i] = param[i];
+  }
+  int32_t txlen = sizeof(zcr_cmd_header_t) + npara * sizeof(int32_t);
+
+  bool    rxdataIsReady = false;
+  int32_t errocode      = 0;
+  regLocalPacketListener([this, &rxdataIsReady, &ack, &nack, &errocode, cmdheader](int32_t fromboard, zcr_cmd_header_t *packet, int32_t datalen) {
+    if (packet->packetindex != cmdheader->packetindex) return;
+    if (packet->packetType == kptv2_error_ack) {
+      errocode = *(int32_t *)packet->data;
+    } else {
+      int32_t *rxbuf = (int32_t *)packet->data;
+      if (ack != nullptr && nack != 0) {
+        for (size_t i = 0; i < nack; i++) {
+          ack[i] = rxbuf[i];
+        }
+      }
+    }
+    rxdataIsReady = true;
+  });
+
+  m_zcanReceiverHost->sendPacket(txbuff, txlen);
+  /**
+   * @brief 等待回执
+   */
+  auto enterticket = zos_get_tick();
+  while (!rxdataIsReady) {
+    if (zos_haspassedms(enterticket) > (uint32_t)overtime_ms) {
+      unregLocalPacketListener();
+      return err::kovertime;
+    }
+    usleep(1000);
+  }
+  unregLocalPacketListener();
+  return 0;
+}
+int32_t ZcanReceiverMaster::sendCmdAndReceiveBuf(int32_t cmdid, int32_t submoduleid, int32_t *param, size_t npara, uint8_t *ack, int32_t *rxsize,
+                                                 int overtime_ms) {  //
+  std::lock_guard<std::recursive_mutex> lock(sendlock_);
+  uint8_t                               txbuff[1024];
+  zcr_cmd_header_t                     *cmdheader = (zcr_cmd_header_t *)txbuff;
+  cmdheader->packetType                           = kptv2_cmd;
+  cmdheader->packetindex                          = generateFreeIndex();
+  cmdheader->cmdmoduleid                          = MODULE_CMDID(cmdid);
+  cmdheader->subcmdid                             = SUBCMDID(cmdid);
+  cmdheader->submoduleid                          = submoduleid;
+  // ZLOGI(TAG, "sendCmd %d %d %d %d", cmdheader->packetindex, cmdheader->cmdmoduleid, cmdheader->subcmdid, cmdheader->submoduleid);
+  int32_t *sendparam = (int32_t *)cmdheader->data;
+  for (size_t i = 0; i < npara; i++) {
+    sendparam[i] = param[i];
+  }
+  int32_t txlen = sizeof(zcr_cmd_header_t) + npara * sizeof(int32_t);
+
+  // 注册监听者
+  bool    rxdataIsReady = false;
+  int32_t errocode      = 0;
+  regLocalPacketListener([this, &cmdheader, &rxdataIsReady, &ack, &rxsize, &errocode](int32_t fromboard, zcr_cmd_header_t *packet, int32_t datalen) {
+    if (packet->packetindex != cmdheader->packetindex) return;
+
+    rxdataIsReady = true;
+    if (packet->packetType == kptv2_error_ack) {
+      errocode = *(int32_t *)packet->data;
+    } else if (*rxsize < datalen) {
+      errocode = err::kbuffer_not_enough;
+    } else {
+      *rxsize = datalen;
+      memcpy(ack, packet->data, *rxsize);
+    }
+    rxdataIsReady = true;
+  });
+
+  // 发送消息
+  m_zcanReceiverHost->sendPacket(txbuff, txlen);
+
+  // 等待回执
+  uint32_t enterticket = zos_get_tick();
+  while (!rxdataIsReady) {
+    if (zos_haspassedms(enterticket) > (uint32_t)overtime_ms) {
+      unregLocalPacketListener();
+      return err::kovertime;
+    }
+    usleep(1000);
+  }
+  unregLocalPacketListener();
+
+  return errocode;
+}
+void ZcanReceiverMaster::regEventPacketListener(onpacket_t on_event) {
+  m_onevent = on_event;
+  return;
+}
+void ZcanReceiverMaster::regPacketListener(onpacket_t onpacket) { m_onpacket = onpacket; }
+void ZcanReceiverMaster::regLocalPacketListener(onpacket_t onpacket) {
+  lock_guard<recursive_mutex> lock(m_localonpacket_lock_);
+  m_localonpacket = onpacket;
+}
+void ZcanReceiverMaster::callLocalPacketListener(int32_t fromboard, zcr_cmd_header_t *packet, int32_t datalen) {
+  lock_guard<recursive_mutex> lock(m_localonpacket_lock_);
+  if (m_localonpacket) m_localonpacket(fromboard, packet, datalen);
+}
+
+void ZcanReceiverMaster::unregLocalPacketListener() {
+  lock_guard<recursive_mutex> lock(m_localonpacket_lock_);
+  m_localonpacket = nullptr;
+}
+
+uint16_t ZcanReceiverMaster::generateFreeIndex() {
+  m_startindex++;
+  if (m_startindex < 60000) {
+    m_startindex = 60000;
+  }
+  return m_startindex;
+}

src/iflytop/components/zcanreceiver/zcanreceiver_master.hpp

@@ -0,0 +1,70 @@
+//
+// Created by zwsd
+//
+
+#pragma once
+#include <fstream>
+#include <iostream>
+#include <list>
+#include <map>
+#include <memory>
+#include <mutex>
+#include <set>
+#include <sstream>
+#include <string>
+#include <vector>
+
+#include "iflytop/core/core.hpp"
+#include "iflytop/zprotocols/api/api.hpp"
+#include "zcanreceiverhost.hpp"
+
+/**
+ * @brief
+ *
+ * service: ZcanReceiverMaster
+ *
+ * 监听事件:
+ * 依赖状态:
+ * 依赖服务:
+ * 作用:
+ *
+ */
+
+namespace iflytop {
+using namespace std;
+using namespace core;
+class ZcanReceiverMaster : public IZcanCmderMaster {
+  ENABLE_LOGGER(ZcanReceiverMaster);
+
+  function<void(int32_t fromboard, zcr_cmd_header_t *packet, int32_t datalen)> m_onevent;
+  function<void(int32_t fromboard, zcr_cmd_header_t *packet, int32_t datalen)> m_onpacket;
+
+  function<void(int32_t fromboard, zcr_cmd_header_t *packet, int32_t datalen)> m_localonpacket;
+  recursive_mutex                                                              m_localonpacket_lock_;
+
+  shared_ptr<ZCanReceiverHost> m_zcanReceiverHost;
+
+  int32_t m_startindex = 60000;
+
+  std::recursive_mutex sendlock_;
+
+ public:
+  ZcanReceiverMaster(){};
+
+  void initialize(string can_if_name, int baudrate, bool enablLoopback);
+
+  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(onpacket_t on_event) override;
+
+  void regPacketListener(onpacket_t onpacket);
+  void sendraw(uint8_t *packet, size_t len);
+
+ private:
+  void regLocalPacketListener(onpacket_t onpacket);
+  void callLocalPacketListener(int32_t fromboard, zcr_cmd_header_t *packet, int32_t datalen);
+  void unregLocalPacketListener();
+
+  uint16_t generateFreeIndex();
+};
+}  // namespace iflytop

src/iflytop/components/zcanreceiver/zcanreceiverhost.cpp

@@ -21,6 +21,41 @@ void ZCanReceiverHost::initialize(string can_if_name, int baudrate, bool enablLo
 }
 void ZCanReceiverHost::registerListener(onpacket_t onpacket) { m_onpacket = onpacket; }
 
+void ZCanReceiverHost::sendPacket(uint8_t *packet, size_t len) {
+  int npacket = len / 8 + (len % 8 == 0 ? 0 : 1);
+  if (npacket > 255) {
+    return;
+  }
+  int finalpacketlen = len % 8 == 0 ? 8 : len % 8;
+  for (uint8_t i = 0; i < npacket; i++) {
+    bool suc = false;
+    if (i == npacket - 1) {
+      suc = sendPacketSub(npacket, i, packet + i * 8, finalpacketlen, OVER_TIME_MS);
+    } else {
+      suc = sendPacketSub(npacket, i, packet + i * 8, 8, OVER_TIME_MS);
+    }
+    if (!suc) {
+      logger->warn("sendPacket fail, packet(%d:%d)\n", npacket, i);
+      return;
+    }
+  }
+}
+
+bool ZCanReceiverHost::sendPacketSub(int npacket, int packetIndex, uint8_t *packet, size_t len, int overtimems) {
+  uint32_t id = (m_deviceId << 16) | (npacket << 8) | packetIndex;
+  // m_comcan.sendframe(CANUSB_FRAME_EXTENDED, id, packet, len);
+  // printf("sendPacketSub(%d:%d) ", npacket, packetIndex);
+  // for (size_t i = 0; i < len; i++) {
+  //   printf("%02x ", packet[i]);
+  // }
+  // printf("\n");
+
+  shared_ptr<SocketCanFrame> frame = SocketCanFrame::createExtDataFrame(id, packet, len); /*TODO，这里如果不写8,会报错，原因未知*/
+  m_socketCan->sendFrame(frame, overtimems);
+  return true;
+}
+
+#if 0
 shared_ptr<ZCanReceiverCMD> ZCanReceiverHost::sendcmdblock(shared_ptr<ZCanReceiverCMD> cmd, int overtime_ms) {  //
   lock_guard<mutex> lock(m_txblocklock);
 
@@ -58,8 +93,9 @@ shared_ptr<ZCanReceiverCMD> ZCanReceiverHost::sendcmdblock(shared_ptr<ZCanReceiv
   }
   return m_txContext.rx;
 }
-
-void ZCanReceiverHost::sendcmd(uint16_t packetindex, uint16_t cmdid, uint8_t subcmdid, uint8_t *data, size_t len) {
+#endif
+#if 0
+void ZCanReceiverHost::sendcmd(uint8_t *packet, size_t len) {
   Cmdheader_t *header = (Cmdheader_t *)m_sendbuf;
   header->packetindex = packetindex;
   header->cmdid       = cmdid;
@@ -72,45 +108,12 @@ void ZCanReceiverHost::sendcmd(uint16_t packetindex, uint16_t cmdid, uint8_t sub
   // }
   sendPacket(m_sendbuf, sizeof(Cmdheader_t) + len);
 }
-void ZCanReceiverHost::sendPacket(uint8_t *packet, size_t len) {
-  /**
-   * @brief
-   */
-  int npacket = len / 8 + (len % 8 == 0 ? 0 : 1);
-  if (npacket > 255) {
-    return;
-  }
-  int finalpacketlen = len % 8 == 0 ? 8 : len % 8;
-  for (uint8_t i = 0; i < npacket; i++) {
-    bool suc = false;
-    if (i == npacket - 1) {
-      suc = sendPacketSub(npacket, i, packet + i * 8, finalpacketlen, OVER_TIME_MS);
-    } else {
-      suc = sendPacketSub(npacket, i, packet + i * 8, 8, OVER_TIME_MS);
-    }
-    if (!suc) {
-      logger->warn("sendPacket fail, packet(%d:%d)\n", npacket, i);
-      return;
-    }
-  }
-}
-
-bool ZCanReceiverHost::sendPacketSub(int npacket, int packetIndex, uint8_t *packet, size_t len, int overtimems) {
-  uint32_t id = (m_deviceId << 16) | (npacket << 8) | packetIndex;
-  // m_comcan.sendframe(CANUSB_FRAME_EXTENDED, id, packet, len);
-  // printf("sendPacketSub(%d:%d) ", npacket, packetIndex);
-  // for (size_t i = 0; i < len; i++) {
-  //   printf("%02x ", packet[i]);
-  // }
-  // printf("\n");
-
-  shared_ptr<SocketCanFrame> frame = SocketCanFrame::createExtDataFrame(id, packet, 8); /*TODO，这里如果不写8,会报错，原因未知*/
-  m_socketCan->sendFrame(frame, overtimems);
-  return true;
-}
+#endif
 
+#if 1
 void ZCanReceiverHost::processOnePacket(CanPacketRxBuffer *rxbuf, uint8_t *packet, size_t len) {  //
-
+  if (m_onpacket) m_onpacket(rxbuf->id, packet, len);
+#if 0
   Cmdheader_t *header = (Cmdheader_t *)packet;
   // uint8_t      from   = rxbuf->id;
 
@@ -136,10 +139,12 @@ void ZCanReceiverHost::processOnePacket(CanPacketRxBuffer *rxbuf, uint8_t *packe
     }
     return;
   }
+#endif
   /**
    * @brief 处理其他类型的消息
    */
 }
+#endif
 
 void ZCanReceiverHost::processRx(shared_ptr<SocketCanFrame> frame) {
   uint8_t from    = (frame->getId() >> 16 & 0xFF);

src/iflytop/components/zcanreceiver/zcanreceiverhost.hpp

@@ -5,12 +5,12 @@
 #pragma once
 #include <mutex>
 
-#include "cmd.hpp"
 #include "iflytop/core/basic/nlohmann/json.hpp"
 #include "iflytop/core/core.hpp"
 #include "iflytop/core/driver/socketcan/socket_can.hpp"
 #include "iflytop/core/spdlogfactory/logger.hpp"
-
+//
+#include "iflytop/zprotocols/api/packet_interface.hpp"
 
 namespace iflytop {
 
@@ -18,18 +18,6 @@ using namespace std;
 using namespace zcr;
 using namespace core;
 
-class ZCanReceiverCMD {
- public:
-  uint16_t packetindex   = 0;
-  uint16_t cmdid         = 0;
-  uint8_t  subcmdid      = 0;
-  uint8_t  packetType    = 0;
-  uint8_t  data[255 * 8] = {0};
-  size_t   len;
-
-  string toString() { return fmt::format("{}-{}:{} {}", packetindex, cmdid, subcmdid, StringUtils().bytesToString(data, len)); }
-};
-
 class ZCanReceiverHost {
   ENABLE_LOGGER(ZCanReceiverHost);
 
@@ -43,48 +31,33 @@ class ZCanReceiverHost {
     uint8_t                    m_rxdataLen    = 0;
   };
 
-  class TxContext {
-   public:
-    shared_ptr<ZCanReceiverCMD> txcmdcache;
-    shared_ptr<ZCanReceiverCMD> rx;
-    bool                        isReady;
-  };
 
-  typedef function<void(CanPacketRxBuffer *rxbuf, uint8_t *packet, size_t len)> onpacket_t;
+  typedef function<void(uint8_t fromboardid, uint8_t *packet, size_t len)> onpacket_t;
 
  public:
-  uint8_t           m_sendbuf[1000];
+  uint8_t           m_deviceId = 0;
   CanPacketRxBuffer m_canPacketRxBuffer[255];
   onpacket_t        m_onpacket;
-  uint8_t           m_deviceId = 1;
-
-  uint16_t m_index = 1;
 
   shared_ptr<SocketCan> m_socketCan;
 
-  mutex     m_txblocklock;
-  mutex     m_txContextLock;
-  TxContext m_txContext;
-
   string m_can_if_name;
   int    m_baudrate;
   bool   m_enablLoopback;
-
  public:
   ZCanReceiverHost();
-
   void initialize(string can_if_name, int baudrate, bool enablLoopback);
+  void sendPacket(uint8_t *packet, size_t len);
   void registerListener(onpacket_t onpacket);
 
-  shared_ptr<ZCanReceiverCMD> sendcmdblock(shared_ptr<ZCanReceiverCMD> cmd, int overtime_ms);
 
  private:
+  bool sendPacketSub(int npacket, int packetIndex, uint8_t *packet, size_t len, int overtimems);
+
   void processRx(shared_ptr<SocketCanFrame> frame);
   void processOnePacket(CanPacketRxBuffer *rxbuf, uint8_t *packet, size_t len);
   void resetSocketCan();
   void sendcmd(uint16_t packetindex, uint16_t cmdid, uint8_t subcmdid, uint8_t *data, size_t len);
-  void sendPacket(uint8_t *packet, size_t len);
-  bool sendPacketSub(int npacket, int packetIndex, uint8_t *packet, size_t len, int overtimems);
 };
 
 }  // namespace iflytop

src/iflytop/core/components/stringutils.cpp

@@ -186,4 +186,30 @@ string StringUtils::escapeSequence(const string& raw_str) {
     }
   }
   return escaped_str;
-}
+}
+
+int32_t StringUtils::split(const string& str, const string& delim, vector<string>& ret) {
+  if (str.empty()) {
+    return 0;
+  }
+  string            tmp;
+  string::size_type pos_begin = str.find_first_not_of(delim);
+  string::size_type comma_pos = 0;
+
+  while (pos_begin != string::npos) {
+    comma_pos = str.find(delim, pos_begin);
+    if (comma_pos != string::npos) {
+      tmp       = str.substr(pos_begin, comma_pos - pos_begin);
+      pos_begin = comma_pos + delim.length();
+    } else {
+      tmp       = str.substr(pos_begin);
+      pos_begin = comma_pos;
+    }
+
+    if (!tmp.empty()) {
+      ret.push_back(tmp);
+      tmp.clear();
+    }
+  }
+  return 0;
+}

src/iflytop/core/components/stringutils.hpp

@@ -14,12 +14,12 @@ class StringUtils {
   bool isLegalHex(char c);
 
  public:
-  string upper(const string& value);
-  string lower(const string& value);
-  string bytesToString(const uint8_t* data, size_t size);
-  string bytesToString(const char* data, size_t size) { return bytesToString((const uint8_t*)data, size); }
-  string bytesToString(const vector<uint8_t>& byteTable) { return bytesToString(byteTable.data(), byteTable.size()); }
-
+  string  upper(const string& value);
+  string  lower(const string& value);
+  string  bytesToString(const uint8_t* data, size_t size);
+  string  bytesToString(const char* data, size_t size) { return bytesToString((const uint8_t*)data, size); }
+  string  bytesToString(const vector<uint8_t>& byteTable) { return bytesToString(byteTable.data(), byteTable.size()); }
+  int32_t split(const string& str, const string& delim, vector<string>& ret);
   /**
    * @brief 替换字符串中的字符，如果new_value="",则删除旧字符
    *

src/iflytop/core/components/timeutils.hpp

@@ -70,8 +70,8 @@ class T_TimeUtils {
 
 typedef T_TimeUtils<system_clock> tu_sys;     // not use in future
 typedef T_TimeUtils<steady_clock> tu_steady;  // not use in future
-typedef time_point<system_clock> tp_sys;     // not use in future
-typedef time_point<steady_clock> tp_steady;  // not use in future
+typedef time_point<system_clock>  tp_sys;     // not use in future
+typedef time_point<steady_clock>  tp_steady;  // not use in future
 
 // new api name
 typedef T_TimeUtils<system_clock> zsystem_clock;
@@ -79,5 +79,9 @@ typedef T_TimeUtils<steady_clock> zsteady_clock;
 
 typedef time_point<system_clock> zsystem_tp;
 typedef time_point<steady_clock> zsteady_tp;
+
+static inline int64_t zos_get_tick() { return zsteady_clock().getms(); }
+static inline int64_t zos_haspassedms(int64_t ms) { return zsteady_clock().elapsedTimeMs(ms); }
+
 };  // namespace core
 }  // namespace iflytop

src/iflytop/core/driver/socketcan/socket_can.cpp

@@ -28,8 +28,8 @@ SocketCan::SocketCanError_t SocketCan::sendFrame(shared_ptr<SocketCanFrame> fram
 }
 SocketCan::SocketCanError_t SocketCan::writeFrame(const canfd_frame_t &frame) {
   setTxStateToTxing(frame);
-  int ret = write(m_socketCanFd, &frame, frame.len + 8);
-  if (ret != (frame.len + 8)) {
+  int ret = write(m_socketCanFd, &frame, sizeof(frame));
+  if (ret != sizeof(frame)) {
     logger->error("write fail,{}", strerror(errno));
     unsetTxStateToTxing();
     return kWriteError;

src/iflytop/core/error/error_code.cpp

@@ -1,38 +0,0 @@
-#include "error_code.hpp"
-
-namespace iflytop {
-namespace err {
-
-using namespace std;
-
-typedef struct {
-  string errordesc;
-} error_desc_t;
-
-static map<error_t, error_desc_t> errormap = {
-    // {kovertime, {.errordesc = "overtime"}},
-    {kfail, {.errordesc = "fail"}},
-    {kce_overtime, {.errordesc = "overtime"}},
-    {kce_noack, {.errordesc = "noack"}},
-    {kce_errorack, {.errordesc = "errorack"}},
-    {kce_device_offline, {.errordesc = "device_offline"}},
-    {kce_parse_json_err, {.errordesc = "parse_json_err"}},
-    {kdbe_user_not_exist, {.errordesc = "user_not_exist"}},
-    {kdbe_catch_exception, {.errordesc = "catch_exception"}},
-    {kharde_unfound, {.errordesc = "hardware_unfound"}},
-    {kre_catch_exception, {.errordesc = "catch_exception"}},
-    {kinteraction_error_passwd_error, {.errordesc = "passwd_error"}},
-    {kinteraction_error_user_not_exist, {.errordesc = "user_not_exist"}}
-
-};
-
-std::string zecode2str(err::error_t error_type, string extdes) {
-  string ret = "unkown";
-  if (errormap.find(error_type) != errormap.end()) {
-    ret = errormap[error_type].errordesc;
-  }
-  return fmt::format("{},{}", ret, extdes);
-}
-
-}  // namespace err
-}  // namespace iflytop

src/iflytop/core/error/error_code.hpp

@@ -12,75 +12,4 @@
 
 #include "iflytop/core/basic/nod/nod.hpp"
 #include "iflytop/core/spdlogfactory/logger.hpp"
-namespace iflytop {
-namespace err {
-using namespace std;
-
-typedef enum {
-  ksucc = 0,
-  kfail = 1,
-
-  /**
-   * @brief 通信错误
-   */
-  kce_overtime       = 1000,
-  kce_noack          = 1001,
-  kce_errorack       = 1002,
-  kce_device_offline = 1003,
-  kce_parse_json_err = 1004,
-
-  /**
-   * @brief 数据库错误
-   */
-  kdbe_user_not_exist  = 2000,
-  kdbe_catch_exception = 2001,
-
-  /**
-   * @brief 硬件错误
-   */
-  kharde_unfound = 3000,
-
-  /**
-   * @brief 程序运行错误
-   * runntime error
-   */
-  kre_catch_exception = 4000,
-  /**
-   * @brief 应用交互基本错误
-   */
-  kinteraction_error_passwd_error   = 5000,
-  kinteraction_error_user_not_exist = 50001,
-
-  /**
-   * @brief 系统错误
-   */
-  ksys_error             = 6000,
-  ksys_create_file_error = 6001,
-  ksys_create_dir_error,
-  ksys_open_file_error,
-  ksys_open_dir_error,
-  ksys_read_file_error,
-  ksys_write_file_error,
-  ksys_close_file_error,
-  ksys_close_dir_error,
-  ksys_delete_file_error,
-  ksys_delete_dir_error,
-  ksys_copy_file_error,
-} error_t;
-
-#define kovertime         kce_overtime
-#define knoack            kce_noack
-#define kerrorack         kce_errorack
-#define kdevice_offline   kce_device_offline
-#define kparse_json_err   kce_parse_json_err
-#define kcatch_exception  kre_catch_exception
-#define kpasswd_error     kinteraction_error_passwd_error
-#define kuser_not_exist   kinteraction_error_user_not_exist
-#define kdb_operate_error kdbe_catch_exception
-
-static inline int32_t zecode(error_t error_type) { return (int32_t)error_type; }
-
-std::string zecode2str(err::error_t error_type, std::string extdes = "");
-
-}  // namespace err
-}  // namespace iflytop
+#include "iflytoplinuxsdk/src/iflytop/zprotocols/api/errorcode.hpp"

src/iflytop/zprotocols

@@ -1 +1 @@
-Subproject commit 08006637540c73c3615944b5c37f27de0a7c56d2
+Subproject commit 9581189118a3a559d3f11895a422a95399113b53