update

src/components/zcanreceiver/socket_can/socket_can.cpp

@@ -15,6 +15,8 @@ using namespace iflytop;
     }                                                            \
   } while (0)
 
+SocketCan::SocketCanError_t SocketCan::sendFrame(shared_ptr<SocketCanFrame> frame, int overtime) { return sendFrame(frame); }
+
 SocketCan::SocketCanError_t SocketCan::sendFrame(shared_ptr<SocketCanFrame> frame) {
   if (!m_canBusIsReady) {
     return kDeviceBusy;
@@ -25,12 +27,8 @@ SocketCan::SocketCanError_t SocketCan::sendFrame(shared_ptr<SocketCanFrame> fram
     return kParamError;
   }
 
-  if (isTxing()) {
-    logger->error("txing, can't send frame");
-    return kDeviceBusy;
-  }
-
   canfd_frame_t canframe = frame->getCanFrame();
+  logger->debug("TX:{}", frame->toString());
   return writeFrame(canframe);
 }
 SocketCan::SocketCanError_t SocketCan::writeFrame(const canfd_frame_t &_frame) {
@@ -39,50 +37,16 @@ SocketCan::SocketCanError_t SocketCan::writeFrame(const canfd_frame_t &_frame) {
   }
 
   canfd_frame_t txframe = _frame;
-  txframe.can_id |= 0x10000000;
-  setTxStateToTxing(txframe);
+  // txframe.can_id |= 0x10000000;
 
   int ret = write(m_socketCanFd, &txframe, 16);
   if (ret != (16)) {
     logger->error("write fail,{}", strerror(errno));
-    unsetTxStateToTxing();
     return kWriteError;
   }
   return kSuccess;
 }
 
-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);
-  }
-
-  if (isTxing()) {
-    logger->error("send frame overtime");
-    return kOvertime;
-  }
-  return sendFrame(frame);
-}
-
-bool SocketCan::isTxing() { return m_txState.txState == kTxing; }
-
-bool SocketCan::isTxFrame(const canfd_frame_t &frame) {
-  lock_guard<recursive_mutex> lock(m_txState.lock);
-  if (m_txState.txbuf.can_id == frame.can_id && m_txState.txbuf.len == frame.len && memcmp(m_txState.txbuf.data, frame.data, frame.len) == 0) {
-    return true;
-  }
-  return false;
-}
-
 void SocketCan::initialize(shared_ptr<SocketCanConfig> socketCanConfig) {  //
   ZCHECK(socketCanConfig, "socketCanConfig is null");
   m_socketCanConfig = socketCanConfig;
@@ -223,24 +187,6 @@ void SocketCan::dosystem(string cmd) {
   logger->info("do cmd:{}", cmd);
   system(cmd.c_str());
 }
-bool SocketCan::tryUpdateTxState(canfd_frame_t &rxloopmsg) {
-  lock_guard<recursive_mutex> lock(m_txState.lock);
-  if (m_txState.txState == kTxing && isTxFrame(rxloopmsg)) {
-    unsetTxStateToTxing();
-    return true;
-  }
-  return false;
-}
-
-void SocketCan::setTxStateToTxing(const canfd_frame_t &txpacket) {
-  lock_guard<recursive_mutex> lock(m_txState.lock);
-  m_txState.txState = kTxing;
-  m_txState.txbuf   = txpacket;
-}
-void SocketCan::unsetTxStateToTxing() {
-  lock_guard<recursive_mutex> lock(m_txState.lock);
-  m_txState.txState = kTxIdle;
-}
 
 #define TEST_CANDRIVER_DO(exptr)                                 \
   do {                                                           \
@@ -388,28 +334,22 @@ 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));
-
-      unsetTxStateToTxing();
-      // exit(-1);
       break;
     } else {
-      // logger->info("TX:{} {} {}", canframe.can_id, canframe.__res0, canframe.__res1);
-      if (!tryUpdateTxState(canframe)) {
-        shared_ptr<SocketCanFrame> socketCanFrame = SocketCanFrame::createFrame(canframe);
-        logger->debug("RX:{}", socketCanFrame->toString());
-        onSocketCanFrame(socketCanFrame);
-      }
+      shared_ptr<SocketCanFrame> socketCanFrame = SocketCanFrame::createFrame(canframe);
+      logger->debug("RX:{}", socketCanFrame->toString());
+      onSocketCanFrame(socketCanFrame);
     }
   }
 
-  m_canTriggerError = true;
-  m_canBusIsReady   = false;
+  m_canErrorFlag  = true;
+  m_canBusIsReady = false;
 }
 
 void SocketCan::monitorLoop() {
   ThisThread thisThread;
   while (!thisThread.getExitFlag()) {
-    if (m_canTriggerError) {
+    if (m_canErrorFlag) {
       // 尝试恢复CAN总线
       logger->warn("try to recover can bus............................................");
       if (m_thread) {
@@ -421,14 +361,6 @@ void SocketCan::monitorLoop() {
       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();
 
@@ -437,8 +369,8 @@ void SocketCan::monitorLoop() {
         socketCanReadThreadLoop();
       }));
 
-      m_canTriggerError = false;
-      m_canBusIsReady   = true;
+      m_canErrorFlag  = false;
+      m_canBusIsReady = true;
 
       logger->warn("recover can bus ok............................................");
     }

src/components/zcanreceiver/socket_can/socket_can.hpp

@@ -15,14 +15,13 @@
 #include <string>
 #include <vector>
 
-
+#include "components/thread/thread.hpp"
+#include "concurrentqueue/blockingconcurrentqueue.h"
+#include "nlohmann/json.hpp"
+#include "nod/nod.hpp"
 #include "socket_can_frame.hpp"
 #include "spdlogfactory/logger.hpp"
-#include "nlohmann/json.hpp"
-#include "concurrentqueue/blockingconcurrentqueue.h"
 #include "utils/timeutils.hpp"
-#include "nod/nod.hpp"
-#include "components/thread/thread.hpp"
 
 /**
  * @brief
@@ -81,11 +80,10 @@ class SocketCan : public enable_shared_from_this<SocketCan> {
   int                m_socketCanFd = -1;
   bool               m_startListen = false;
 
-  shared_ptr<SocketCanConfig> m_socketCanConfig;
+  bool m_canBusIsReady = false;
+  bool m_canErrorFlag  = false;
 
-  TxState m_txState;
-  bool    m_canTriggerError = false;
-  bool    m_canBusIsReady   = false;
+  shared_ptr<SocketCanConfig> m_socketCanConfig;
 
  public:
   typedef enum {
@@ -124,12 +122,13 @@ class SocketCan : public enable_shared_from_this<SocketCan> {
  public:
   nod::signal<void(shared_ptr<SocketCanFrame>)> onSocketCanFrame;
 
-  SocketCan(){};
+  SocketCan() {};
   ~SocketCan();
 
   void initialize(shared_ptr<SocketCanConfig> socketCanConfig);
   bool isError() { return false; }
 
+
   void startListen();
 
   SocketCanError_t sendFrame(shared_ptr<SocketCanFrame> frame, int overtime);
@@ -142,7 +141,6 @@ class SocketCan : public enable_shared_from_this<SocketCan> {
    * @return int
    */
   static int dumpCanDriverInfo(string canDevice, int baudrate);
-  bool       isTxing();
 
  private:
   void socketcanInitialize();
@@ -155,7 +153,6 @@ class SocketCan : public enable_shared_from_this<SocketCan> {
 
   void monitorLoop();
 
-
  private:
   void        dosystem(string cmd);
   void        setCanBitrate(string canName, int bitrate);
@@ -165,11 +162,5 @@ class SocketCan : public enable_shared_from_this<SocketCan> {
 
  private:
   void canReadThread();
-
-  bool tryUpdateTxState(canfd_frame_t &rxloopmsg);
-  void setTxStateToTxing(const canfd_frame_t &txpacket);
-  void unsetTxStateToTxing();
-
-  bool isTxFrame(const canfd_frame_t &frame);
 };
 }  // namespace iflytop

src/components/zcanreceiver/zcanreceiverhost.cpp

@@ -3,6 +3,8 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+
+#include "utils/stringutils.hpp"
 using namespace iflytop;
 
 #define TAG "ZCanReceiver"
@@ -10,18 +12,20 @@ using namespace iflytop;
 #define OVER_TIME_MS 20
 
 using namespace iflytop;
+
 ZCanReceiverHost::ZCanReceiverHost() {}
 
-void ZCanReceiverHost::initialize(string can_if_name, int baudrate, bool enablLoopback) {
+void ZCanReceiverHost::initialize(string can_if_name, int baudrate) {
   // m_iflytopCanProtocolStack.reset(new IflytopCanProtocolStack());
   m_can_if_name   = can_if_name;
   m_baudrate      = baudrate;
-  m_enablLoopback = enablLoopback;
+  m_enablLoopback = false;
   resetSocketCan();
 }
 void ZCanReceiverHost::registerListener(onpacket_t onpacket) { m_onpacket = onpacket; }
 
 void ZCanReceiverHost::sendPacket(uint8_t *packet, size_t len) {
+  logger->info("TX: {}", StringUtils().bytesToString(packet, len));
   int npacket = len / 7 + (len % 7 == 0 ? 0 : 1);
   if (npacket > 255) {
     return;
@@ -42,7 +46,7 @@ void ZCanReceiverHost::sendPacket(uint8_t *packet, size_t len) {
 }
 
 bool ZCanReceiverHost::sendPacketSub(int npacket, int packetIndex, uint8_t *packet, size_t len, int overtimems) {
-  uint32_t id        = 0;
+  uint32_t id        = m_hostId;
   uint8_t  txdata[8] = {0};
   txdata[0]          = npacket << 4 | packetIndex;
   memcpy(txdata + 1, packet, len);
@@ -54,6 +58,7 @@ bool ZCanReceiverHost::sendPacketSub(int npacket, int packetIndex, uint8_t *pack
   // printf("\n");
 
   shared_ptr<SocketCanFrame> frame = SocketCanFrame::createStdDataFrame(id, txdata, len + 1);
+  logger->info("TX RAW :{}", frame->toString());
   m_socketCan->sendFrame(frame, overtimems);
   return true;
 }
@@ -96,6 +101,7 @@ void ZCanReceiverHost::processRx(shared_ptr<SocketCanFrame> frame) {
     /**
      * @brief 接收到最后一包数据
      */
+    logger->info("RX: {}", StringUtils().bytesToString(rxbuf->m_rxdata, rxbuf->m_rxdataLen));
     processOnePacket(rxbuf, rxbuf->m_rxdata, rxbuf->m_rxdataLen);
   }
 }
@@ -113,7 +119,11 @@ void ZCanReceiverHost::resetSocketCan() {
   m_socketCan->initialize(socketCanConfig);
   m_socketCan->startListen();
   m_socketCan->onSocketCanFrame.connect([this](shared_ptr<SocketCanFrame> canframe) {  //
-    logger->debug("onSocketCanFrame {}", canframe->toString());
+    if (canframe->getId() == m_hostId) {
+      logger->info("TX RAW: {} SUC", canframe->toString());
+      return;
+    }
+    logger->info("RX RAW: {}", canframe->toString());
     processRx(canframe);
   });
 }

src/components/zcanreceiver/zcanreceiverhost.hpp

@@ -32,7 +32,7 @@ class ZCanReceiverHost {
   typedef function<void(uint8_t fromboardid, uint8_t *packet, size_t len)> onpacket_t;
 
  public:
-  uint8_t           m_deviceId = 0;
+  uint8_t           m_hostId = 0;
   CanPacketRxBuffer m_canPacketRxBuffer[255];
   onpacket_t        m_onpacket;
 
@@ -44,7 +44,7 @@ class ZCanReceiverHost {
 
  public:
   ZCanReceiverHost();
-  void initialize(string can_if_name, int baudrate, bool enablLoopback);
+  void initialize(string can_if_name, int baudrate);
   void sendPacket(uint8_t *packet, size_t len);
   void registerListener(onpacket_t onpacket);
 

src/extapi_service.cpp

@@ -18,11 +18,11 @@ using namespace ix;
 #define BIND
 
 namespace iflytop {};
-void ExtAPIService::initialize(string can_if_name, int baudrate, bool enablLoopback) {
+void ExtAPIService::initialize(string can_if_name, int baudrate) {
   GET_TO_SERVICE(m_zconfig);
 
   m_zcanreceiverhost.reset(new ZCanReceiverHost());
-  m_zcanreceiverhost->initialize(can_if_name, baudrate, enablLoopback);
+  m_zcanreceiverhost->initialize(can_if_name, baudrate);
 
   initCanPassthroughServer();
 };

src/extapi_service.hpp

@@ -52,7 +52,7 @@ class ExtAPIService {
 
  public:
   ExtAPIService() {};
-  void initialize(string can_if_name, int baudrate, bool enablLoopback);
+  void initialize(string can_if_name, int baudrate);
 
  private:
   void initCanPassthroughServer();

src/main_control_service.cpp

@@ -34,6 +34,11 @@ void MainControlService::initializeService() {
   BUILD_AND_REG_SERRVICE(GConfig);
   OBJECT(GConfig)->initialize();
 
-  m_extAPIService.initialize(OBJECT(GConfig)->get_canName(),  //
-                             OBJECT(GConfig)->get_canBaudRate(), false);
+  m_extAPIService.initialize(OBJECT(GConfig)->get_canName(), OBJECT(GConfig)->get_canBaudRate());
+
+
+  // ZCanReceiverHost *m_zcanreceiverhost = new ZCanReceiverHost();
+  // m_zcanreceiverhost->initialize(OBJECT(GConfig)->get_canName(), OBJECT(GConfig)->get_canBaudRate());
+  // m_zcanreceiverhost->sendPacket((uint8_t *)"hello", 5);
+
 }