TransportPerfCounter - counting transfers and transport errors

libuavcan/src/transport/dispatcher.cpp

@@ -143,6 +143,7 @@ void Dispatcher::handleFrame(const CanRxFrame& can_frame)
     RxFrame frame;
     if (!frame.parse(can_frame))
     {
+        // This is not counted as a transport error
         UAVCAN_TRACE("Dispatcher", "Invalid CAN frame received: %s", can_frame.toString().c_str());
         return;
     }
@@ -161,19 +162,16 @@ void Dispatcher::handleFrame(const CanRxFrame& can_frame)
         lmsg_.handleFrame(frame);
         break;
     }
-
     case TransferTypeServiceRequest:
     {
         lsrv_req_.handleFrame(frame);
         break;
     }
-
     case TransferTypeServiceResponse:
     {
         lsrv_resp_.handleFrame(frame);
         break;
     }
-
     default:
         assert(0);
     }

libuavcan/src/transport/transfer_listener.cpp

@@ -113,32 +113,35 @@ void TransferListenerBase::handleReception(TransferReceiver& receiver, const RxF
     {
     case TransferReceiver::ResultNotComplete:
     {
-        return;
+        perf_.addErrors(receiver.yieldErrorCount());
+        break;
     }
     case TransferReceiver::ResultSingleFrame:
     {
+        perf_.addRxTransfer();
         SingleFrameIncomingTransfer it(frame);
         handleIncomingTransfer(it);
-        return;
+        break;
     }
     case TransferReceiver::ResultComplete:
     {
+        perf_.addRxTransfer();
         const ITransferBuffer* tbb = tba.access();
         if (tbb == NULL)
         {
             UAVCAN_TRACE("TransferListenerBase", "Buffer access failure, last frame: %s", frame.toString().c_str());
-            return;
+            break;
         }
         if (!checkPayloadCrc(receiver.getLastTransferCrc(), *tbb))
         {
             UAVCAN_TRACE("TransferListenerBase", "CRC error, last frame: %s", frame.toString().c_str());
-            return;
+            break;
         }
         MultiFrameIncomingTransfer it(receiver.getLastTransferTimestampMonotonic(),
                                       receiver.getLastTransferTimestampUtc(), frame, tba);
         handleIncomingTransfer(it);
         it.release();
-        return;
+        break;
     }
     default:
     {

libuavcan/src/transport/transfer_receiver.cpp

@@ -17,7 +17,7 @@ const uint32_t TransferReceiver::MinTransferIntervalUSec;
 const uint32_t TransferReceiver::MaxTransferIntervalUSec;
 const uint32_t TransferReceiver::DefaultTransferIntervalUSec;
 
-void TransferReceiver::registerError()
+void TransferReceiver::registerError() const
 {
     if (error_cnt_ < 0xFF)
     {
@@ -72,29 +72,29 @@ bool TransferReceiver::validate(const RxFrame& frame) const
     {
         return false;
     }
-
     if (frame.isFirst() && !frame.isLast() && (frame.getPayloadLen() < TransferCRC::NumBytes))
     {
         UAVCAN_TRACE("TransferReceiver", "CRC expected, %s", frame.toString().c_str());
+        registerError();
         return false;
     }
-
     if ((frame.getIndex() == Frame::MaxIndex) && !frame.isLast())
     {
         UAVCAN_TRACE("TransferReceiver", "Unterminated transfer, %s", frame.toString().c_str());
+        registerError();
         return false;
     }
-
     if (frame.getIndex() != next_frame_index_)
     {
         UAVCAN_TRACE("TransferReceiver", "Unexpected frame index (not %i), %s",
                      int(next_frame_index_), frame.toString().c_str());
+        registerError();
         return false;
     }
-
     if (getTidRelation(frame) != TidSame)
     {
         UAVCAN_TRACE("TransferReceiver", "Unexpected TID (current %i), %s", tid_.get(), frame.toString().c_str());
+        registerError();
         return false;
     }
     return true;
@@ -245,10 +245,8 @@ TransferReceiver::ResultCode TransferReceiver::addFrame(const RxFrame& frame, Tr
 
     if (!validate(frame))
     {
-        registerError();
         return ResultNotComplete;
     }
-
     return receive(frame, tba);
 }
 

libuavcan/src/transport/transfer_sender.cpp

@@ -10,10 +10,17 @@
 namespace uavcan
 {
 
+void TransferSender::registerError()
+{
+    dispatcher_.getTransportPerfCounter().addError();
+}
+
 int TransferSender::send(const uint8_t* payload, int payload_len, MonotonicTime tx_deadline,
                          MonotonicTime blocking_deadline, TransferType transfer_type, NodeID dst_node_id,
                          TransferID tid)
 {
+    dispatcher_.getTransportPerfCounter().addTxTransfer();
+
     Frame frame(data_type_.getID(), transfer_type, dispatcher_.getNodeID(), dst_node_id, 0, tid);
 
     if (frame.getMaxPayloadLen() >= payload_len)           // Single Frame Transfer
@@ -23,6 +30,7 @@ int TransferSender::send(const uint8_t* payload, int payload_len, MonotonicTime
         {
             assert(0);
             UAVCAN_TRACE("TransferSender", "Frame payload write failure, %i", res);
+            registerError();
             return (res < 0) ? res : -1;
         }
         frame.makeLast();
@@ -47,6 +55,7 @@ int TransferSender::send(const uint8_t* payload, int payload_len, MonotonicTime
             if (write_res < 2)
             {
                 UAVCAN_TRACE("TransferSender", "Frame payload write failure, %i", write_res);
+                registerError();
                 return write_res;
             }
             offset = write_res - 2;
@@ -60,13 +69,13 @@ int TransferSender::send(const uint8_t* payload, int payload_len, MonotonicTime
             const int send_res = dispatcher_.send(frame, tx_deadline, blocking_deadline, qos_, flags_, iface_mask_);
             if (send_res < 0)
             {
+                registerError();
                 return send_res;
             }
 
             if (frame.isLast())
             {
                 return next_frame_index;  // Number of frames transmitted
-
             }
             frame.setIndex(next_frame_index++);
 
@@ -74,6 +83,7 @@ int TransferSender::send(const uint8_t* payload, int payload_len, MonotonicTime
             if (write_res < 0)
             {
                 UAVCAN_TRACE("TransferSender", "Frame payload write failure, %i", write_res);
+                registerError();
                 return write_res;
             }