修复socket can BUG

src/iflytop/components/uart_printer/uart_printer.cpp

@@ -5,6 +5,7 @@ using namespace core;
 UartPrinter::UartPrinter() {}
 UartPrinter::~UartPrinter() {}
 void UartPrinter::initialize(string path, string rate) {
+  logger->info("initialize uart printer {} {}", path, rate);
   m_path  = path;
   m_rate  = rate;
   m_uart  = make_shared<Uart>();

src/iflytop/components/zcanreceiver/zcanhost.cpp

@@ -273,7 +273,7 @@ int32_t ZCanHost::readio(int id, bool& value) {
   return 0;
 }
 int32_t ZCanHost::writeio(int id, bool value) {
-  logger->info("writeio {} {}", id, value); 
+  logger->info("writeio {} {}", id, value);
   shared_ptr<ZCanReceiverCMD> cmd = make_shared<ZCanReceiverCMD>();
   cmd->cmdid                      = 2;
   cmd->subcmdid                   = 0;
@@ -461,6 +461,7 @@ int32_t ZCanHost::hpp272_read_c1000(int sensorid, hpp272_data_t& value) {
   return 0;
 }
 
+
 int32_t ZCanHost::call(int32_t cmdid, int32_t* val0, int32_t nval, int32_t* ack, int32_t* acknum) {
   shared_ptr<ZCanReceiverCMD> cmd = make_shared<ZCanReceiverCMD>();
   cmd->cmdid                      = cmdid;
@@ -488,8 +489,10 @@ int32_t ZCanHost::call(int32_t cmdid, int32_t* val0, int32_t nval, int32_t* ack,
   }
 
   if (rx->packetType == kpt_error_ack) {
-    logger->error("call error ack,{}", *zuint16p(&rx->data[0]));
-    return err::zecode(err::kfail);
+    int32_t ecode = *zuint16p(&rx->data[0]);
+    ecode         = 500 + ecode;
+    logger->error("call error ack,{}", err::zecode2str((err::error_t)ecode));
+    return ecode;
   }
   return 0;
 }

src/iflytop/components/zcanreceiver/zcanreceiverhost.cpp

@@ -23,6 +23,22 @@ void ZCanReceiverHost::registerListener(onpacket_t onpacket) { m_onpacket = onpa
 void ZCanReceiverHost::registerReportMsgListener(onreport_t onpacket) { m_onReportPacket = onpacket; }
 
 shared_ptr<ZCanReceiverCMD> ZCanReceiverHost::sendcmdblock(shared_ptr<ZCanReceiverCMD> cmd, int overtime_ms) {  //
+
+  /**
+   * @brief 指令发送失败后，重试3次
+   */
+  for (int i = 0; i < 3; i++) {
+    auto rx = _sendcmdblock(cmd, overtime_ms);
+    if (rx) {
+      return rx;
+    }
+  }
+  logger->warn("sendcmdblock(index {},cmd {},subcmd {}) fail,timeout", cmd->packetindex, cmd->cmdid, cmd->subcmdid);
+
+  return nullptr;
+}
+
+shared_ptr<ZCanReceiverCMD> ZCanReceiverHost::_sendcmdblock(shared_ptr<ZCanReceiverCMD> cmd, int overtime_ms) {  //
   lock_guard<mutex> lock(m_txblocklock);
   // 加这个延时是因为，曾经出现一个BUG，当发送一条指令成功后，立马下发第二条指令，第二条指令会发送失败，原因未知
   usleep(10 * 1000);
@@ -56,7 +72,7 @@ shared_ptr<ZCanReceiverCMD> ZCanReceiverHost::sendcmdblock(shared_ptr<ZCanReceiv
   }
 
   if (!m_txContext.isReady) {
-    logger->warn("sendcmdblock(index {},cmd {},subcmd {}) fail,timeout", cmd->packetindex, cmd->cmdid, cmd->subcmdid);
+    logger->warn("try sendcmdblock(index {},cmd {},subcmd {}) fail,timeout", cmd->packetindex, cmd->cmdid, cmd->subcmdid);
     return nullptr;
   }
   usleep(10 * 1000);

src/iflytop/components/zcanreceiver/zcanreceiverhost.hpp

@@ -83,6 +83,8 @@ class ZCanReceiverHost {
   shared_ptr<ZCanReceiverCMD> sendcmdblock(shared_ptr<ZCanReceiverCMD> cmd, int overtime_ms);
 
  private:
+  shared_ptr<ZCanReceiverCMD> _sendcmdblock(shared_ptr<ZCanReceiverCMD> cmd, int overtime_ms);
+
   void processRx(shared_ptr<SocketCanFrame> frame);
   void processOnePacket(CanPacketRxBuffer *rxbuf, uint8_t *packet, size_t len);
   void resetSocketCan();

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

@@ -13,6 +13,10 @@ using namespace iflytop;
   } while (0)
 
 SocketCan::SocketCanError_t SocketCan::sendFrame(shared_ptr<SocketCanFrame> frame) {
+  if (!m_canBusIsReady) {
+    return kDeviceBusy;
+  }
+
   if (frame == nullptr) {
     logger->error("frame is null");
     return kParamError;
@@ -27,6 +31,10 @@ SocketCan::SocketCanError_t SocketCan::sendFrame(shared_ptr<SocketCanFrame> fram
   return writeFrame(canframe);
 }
 SocketCan::SocketCanError_t SocketCan::writeFrame(const canfd_frame_t &frame) {
+  if (!m_canBusIsReady) {
+    return kDeviceBusy;
+  }
+
   setTxStateToTxing(frame);
   int ret = write(m_socketCanFd, &frame, frame.len + 8);
   if (ret != (frame.len + 8)) {
@@ -39,6 +47,15 @@ SocketCan::SocketCanError_t SocketCan::writeFrame(const canfd_frame_t &frame) {
 
 SocketCan::SocketCanError_t SocketCan::sendFrame(shared_ptr<SocketCanFrame> frame, int overtime) {
   tp_steady start = tu_steady().now();
+
+  while (tu_steady().elapsedTimeMs(start) < overtime && !m_canBusIsReady) {
+    usleep(100);
+  }
+
+  if (!m_canBusIsReady) {
+    return kOvertime;
+  }
+
   while (tu_steady().elapsedTimeMs(start) < overtime && isTxing()) {
     usleep(100);
   }
@@ -61,6 +78,10 @@ bool SocketCan::isTxFrame(const canfd_frame_t &frame) {
 }
 
 SocketCan::SocketCanError_t SocketCan::sendFrame(string framestr) {
+  if (!m_canBusIsReady) {
+    return kOvertime;
+  }
+
   struct canfd_frame frame        = {0};
   int                required_mtu = 0;
 
@@ -117,6 +138,9 @@ void SocketCan::startListenThread() {
      */
     socketCanReadThreadLoop();
   }));
+  m_canBusIsReady = true;
+
+  m_autoRestartThread.reset(new Thread("SocketCanAutoRestartThread", [this]() { monitorLoop(); }));
 }
 void SocketCan::endListenThread() {
   logger->info("endListenThread");
@@ -386,8 +410,7 @@ void SocketCan::socketCanReadThreadLoop() {
       // /usr/include/linux/can/error.h
       // x can-bus error event 20000004,0004000000000086
       logger->error("rx can-bus error event {:x},{}", canframe.can_id, StringUtils().bytesToString(canframe.data, canframe.len));
-      // m_canTriggerError = true;
-      // socketcanInitialize();
+
       unsetTxStateToTxing();
       // exit(-1);
       break;
@@ -400,4 +423,48 @@ void SocketCan::socketCanReadThreadLoop() {
       }
     }
   }
+
+  m_canTriggerError = true;
+  m_canBusIsReady   = false;
+}
+
+void SocketCan::monitorLoop() {
+  ThisThread thisThread;
+  while (!thisThread.getExitFlag()) {
+    if (m_canTriggerError) {
+      // 尝试恢复CAN总线
+      logger->warn("try to recover can bus............................................");
+      if (m_thread) {
+        m_thread->join();
+        m_thread = nullptr;
+      }
+      logger->warn("close can bus fd:{}", m_socketCanFd);
+
+      close(m_socketCanFd);
+      m_socketCanFd = -1;
+
+      {
+        lock_guard<recursive_mutex> lock(m_txState.lock);
+        memset(&m_txState.txbuf, 0x00, sizeof(m_txState.txbuf));
+        m_txState.txState               = TxState_t::kTxIdle;
+        m_txState.txAckCount            = 0;
+        m_txState.txLoopMessageRxTicket = zsteady_clock().now();
+      }
+
+      logger->warn("re init can bus");
+      socketcanInitialize();
+
+      m_thread.reset(new Thread("SocketCanThread", [this]() {
+        usleep(10 * 1000);
+        socketCanReadThreadLoop();
+      }));
+
+      m_canTriggerError = false;
+      m_canBusIsReady   = true;
+
+      logger->warn("recover can bus ok............................................");
+    }
+
+    thisThread.sleepForMs(30);
+  }
 }

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

@@ -75,6 +75,7 @@ class SocketCan : public enable_shared_from_this<SocketCan> {
 
  private:
   unique_ptr<Thread> m_thread;
+  unique_ptr<Thread> m_autoRestartThread;
   int                m_socketCanFd = -1;
   bool               m_startListen = false;
   SocketCanUtils     m_socketCanUtils;
@@ -82,7 +83,8 @@ class SocketCan : public enable_shared_from_this<SocketCan> {
   shared_ptr<SocketCanConfig> m_socketCanConfig;
 
   TxState m_txState;
-  bool    m_canTriggerError;
+  bool    m_canTriggerError = false;
+  bool    m_canBusIsReady   = false;
 
  public:
   typedef enum {
@@ -125,7 +127,7 @@ class SocketCan : public enable_shared_from_this<SocketCan> {
   ~SocketCan();
 
   void initialize(shared_ptr<SocketCanConfig> socketCanConfig);
-  bool isError() { return m_canTriggerError; }
+  bool isError() { return false; }
 
   void startListen();
 
@@ -161,6 +163,9 @@ class SocketCan : public enable_shared_from_this<SocketCan> {
   void endListenThread();
   void socketCanReadThreadLoop();
 
+  void monitorLoop();
+
+
  private:
   void        dosystem(string cmd);
   void        setCanBitrate(string canName, int bitrate);

src/iflytop/core/error/error_code.cpp

@@ -11,18 +11,38 @@ typedef struct {
 
 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"}}
+
+    {ksucc, {.errordesc = "ksucc"}},
+    {kfail, {.errordesc = "kfail"}},
+    {kce_subboard_error_overtime, {.errordesc = "kce_subboard_error_overtime"}},
+    {kce_subboard_error_invalid_param, {.errordesc = "kce_subboard_error_invalid_param"}},
+    {kce_subboard_error_invalid_param_num, {.errordesc = "kce_subboard_error_invalid_param_num"}},
+    {kce_subboard_error_subdevice_offline, {.errordesc = "kce_subboard_error_subdevice_offline"}},
+    {kce_subboard_error_function_not_support, {.errordesc = "kce_subboard_error_function_not_support"}},
+    {kce_overtime, {.errordesc = "kce_overtime"}},
+    {kce_noack, {.errordesc = "kce_noack"}},
+    {kce_errorack, {.errordesc = "kce_errorack"}},
+    {kce_device_offline, {.errordesc = "kce_device_offline"}},
+    {kce_parse_json_err, {.errordesc = "kce_parse_json_err"}},
+    {kdbe_user_not_exist, {.errordesc = "kdbe_user_not_exist"}},
+    {kdbe_catch_exception, {.errordesc = "kdbe_catch_exception"}},
+    {kharde_unfound, {.errordesc = "kharde_unfound"}},
+    {kre_catch_exception, {.errordesc = "kre_catch_exception"}},
+    {kinteraction_error_passwd_error, {.errordesc = "kinteraction_error_passwd_error"}},
+    {kinteraction_error_user_not_exist, {.errordesc = "kinteraction_error_user_not_exist"}},
+    {ksys_error, {.errordesc = "ksys_error"}},
+    {ksys_create_file_error, {.errordesc = "ksys_create_file_error"}},
+    {ksys_create_dir_error, {.errordesc = "ksys_create_dir_error"}},
+    {ksys_open_file_error, {.errordesc = "ksys_open_file_error"}},
+    {ksys_open_dir_error, {.errordesc = "ksys_open_dir_error"}},
+    {ksys_read_file_error, {.errordesc = "ksys_read_file_error"}},
+    {ksys_write_file_error, {.errordesc = "ksys_write_file_error"}},
+    {ksys_close_file_error, {.errordesc = "ksys_close_file_error"}},
+    {ksys_close_dir_error, {.errordesc = "ksys_close_dir_error"}},
+    {ksys_delete_file_error, {.errordesc = "ksys_delete_file_error"}},
+    {ksys_delete_dir_error, {.errordesc = "ksys_delete_dir_error"}},
+    {ksys_copy_file_error, {.errordesc = "ksys_copy_file_error"}},
+
 
 };
 

src/iflytop/core/error/error_code.hpp

@@ -12,6 +12,7 @@
 
 #include "iflytop/core/basic/nod/nod.hpp"
 #include "iflytop/core/spdlogfactory/logger.hpp"
+#include "transmit_disinfection_protocol_v1/transmit_disinfection_protocol_v1.hpp"
 namespace iflytop {
 namespace err {
 using namespace std;
@@ -20,6 +21,17 @@ typedef enum {
   ksucc = 0,
   kfail = 1,
 
+  kce_subboard_error_overtime             = 500 + kerr_overtime,
+  kce_subboard_error_invalid_param        = 500 + kerr_invalid_param,
+  kce_subboard_error_invalid_param_num    = 500 + kerr_invalid_param_num,
+  kce_subboard_error_subdevice_offline    = 500 + kerr_subdevice_offline,
+  kce_subboard_error_function_not_support = 500 + kerr_function_not_support,
+
+  kce_disinfectant_insufficient          = 600,  // 消毒液不足
+  kce_the_bottom_of_the_device_has_water = 601,  // 设备底部有水
+  kcd_the_evaporation_bin_has_water      = 602,  // 蒸发仓有水
+  kcd_the_sensor_is_prehearting          = 603,  // 传感器正在预热
+
   /**
    * @brief 通信错误
    */
@@ -56,16 +68,16 @@ typedef enum {
    */
   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,
+  ksys_create_dir_error  = 6002,
+  ksys_open_file_error   = 6003,
+  ksys_open_dir_error    = 6004,
+  ksys_read_file_error   = 6005,
+  ksys_write_file_error  = 6006,
+  ksys_close_file_error  = 6007,
+  ksys_close_dir_error   = 6008,
+  ksys_delete_file_error = 6009,
+  ksys_delete_dir_error  = 6010,
+  ksys_copy_file_error   = 6011,
 } error_t;
 
 #define kovertime         kce_overtime