Count the number of frames sent such as for testing issue bobjacobsen#70 (needs confirmation) and bobjacobsen#71. Helps validate pull request bobjacobsen#67.

Author: Poikilos

examples/example_frame_interface.py

@@ -49,7 +49,7 @@ def sendToSocket(frame: CanFrame):
 
 def handleFrameSent(frame):
     # No state to manage since no link layer
-    pass
+    physicalLayer._sentFramesCount += 1
 
 
 def handleFrameReceived(frame):
@@ -60,9 +60,11 @@ def handleFrameReceived(frame):
 def printFrame(frame):
     print("RL: {}".format(frame))
 
+
 def handleDisconnect():
     print("Disconnected.")
 
+
 physicalLayer = CanPhysicalLayerGridConnect()
 
 # NOTE: Normally the required handlers are set by link layer

examples/example_tcp_message_interface.py

@@ -79,8 +79,17 @@ def printMessage(msg):
 # send an VerifyNodes message to provoke response
 message = Message(MTI.Verify_NodeID_Number_Global,
                   NodeID(settings['localNodeID']), None)
-print("SM: {}".format(message))
+print("Sending Message: {}...".format(message))
+previousCount = physicalLayer._sentFramesCount
 tcpLinkLayer.sendMessage(message, verbose=True)
+thisSentCount = physicalLayer._sentFramesCount - previousCount
+messageCount = 1
+assert thisSentCount == messageCount, \
+    "Expected {} sent since realtime, got {}".format(messageCount,
+                                                     thisSentCount)
+# ^ Change the assertion if more than one message is required for some
+#   reason (expected one sent here instead of after sendAll *only* since
+#   using a Realtime subclass for physicalLayer in this example.)
 physicalLayer.sendAll(sock, verbose=True)  # only a formality since Realtime
 # N/A
 # while not tcpLinkLayer.getState() == TcpLink.State.Permitted:

openlcb/linklayer.py

@@ -101,7 +101,10 @@ def pollState(self):
 
     def handleFrameSent(self, frame):
         """Update state based on the frame having been sent."""
-        if frame.afterSendState is not None:
+        if self.physicalLayer:
+            self.physicalLayer._sentFramesCount += 1
+        if (hasattr(frame, 'afterSendState')
+                and (frame.afterSendState is not None)):
             self.setState(frame.afterSendState)  # may change again
             #   since setState calls pollState via _onStateChanged.
 

openlcb/physicallayer.py

@@ -56,11 +56,12 @@ class PhysicalLayer:
     """
 
     def __init__(self):
+        self._sentFramesCount = 0
         self._send_frames = deque()
         # self._send_chunks = deque()
         self.onQueuedFrame = None
 
-    def sendDataAfter(self, data: Union[bytes, bytearray]):
+    def sendDataAfter(self, data: Union[bytes, bytearray], verbose=False):
         raise NotImplementedError(
             "This method is only for Realtime subclass(es)"
             " (which should only be used when not using GridConnect"

openlcb/realtimephysicallayer.py

@@ -46,8 +46,9 @@ def sendDataAfter(self, data: Union[bytearray, bytes], verbose=True):
         #     )
         assert isinstance(data, (bytes, bytearray))
         if verbose:
-            print("      SR: {}".format(data))
+            print("- SENT data (realtime): {}".format(data.strip()))
         self.sock.send(data)
+        self.onFrameSent(data)
 
     def sendFrameAfter(self, frame, verbose=False):
         """Send frame (immediately, since realtime subclass).
@@ -73,11 +74,12 @@ def sendFrameAfter(self, frame, verbose=False):
         #         .format(type(data).__name__, data)
         #     )
         if verbose:
-            print("      SR: {}".format(frame))
+            print("- SENT frame (realtime): {}".format(frame))
         # send and fireFrameReceived would usually occur after
         #   frame from _send_frames.popleft is sent,
         #   but we do all this here in the Realtime subclass:
         self.sock.send(data)
+        self.onFrameSent(data)
         if hasattr(frame, 'afterSendState') and frame.afterSendState:
             # Use hasattr since only applicable to subclasses that use
             #   CanFrame.

openlcb/realtimerawphysicallayer.py

@@ -13,9 +13,14 @@ class RealtimeRawPhysicalLayer(RealtimePhysicalLayer, RawPhysicalLayer):
     See RealtimePhysicalLayer for more information.
     """
     def sendFrameAfter(self, frame, verbose=False):
-        self.sendDataAfter(frame, verbose=verbose)
+        self._sendDataAfter(frame, verbose=verbose)
+        self.onFrameSent(frame)
 
     def sendDataAfter(self, data: Union[bytearray, bytes], verbose=False):
+        self._sendDataAfter(data, verbose=verbose)
+        self.onFrameSent(data)
+
+    def _sendDataAfter(self, data: Union[bytearray, bytes], verbose=False):
         # ^ data for sendDataAfter,
         #   For frame see sendFrameAfter.
         # verbose is only for Realtime subclass (since data is sent
@@ -29,5 +34,5 @@ def sendDataAfter(self, data: Union[bytearray, bytes], verbose=False):
             data = data.encode("utf-8")
         assert isinstance(data, (bytes, bytearray))
         if verbose:
-            print("      SR: {}".format(data))
+            print("- SENT data (realtime raw): {}".format(data.strip()))
         self.sock.send(data)

openlcb/tcplink/tcplink.py

@@ -238,6 +238,6 @@ def sendMessage(self, message: Message, verbose=False):
 
         outputBytes.extend(message.data)
 
-        self.physicalLayer.sendDataAfter(outputBytes)
+        self.physicalLayer.sendDataAfter(outputBytes, verbose=verbose)
         # ^ The physical layer should be one with "Raw" in the name
         # since takes bytes. See example_tcp_message_interface.

tests/test_canlink.py

@@ -25,7 +25,8 @@ def __init__(self):
         self.sentFrames = []
         CanPhysicalLayer.__init__(self)
 
-    def sendDataAfter(self, data):
+    def sendDataAfter(self, data, verbose=False):
+        # verbose: ignored since used in sendAll when not a Realtime subclass.
         assert isinstance(data, (bytes, bytearray))
         self.sentFrames.append(data)
 
@@ -58,7 +59,8 @@ def sendAll(self, _, mode="binary", verbose=True) -> int:
             string = frame.encodeAsString()
             # device.sendString(string)  # commented since simulation
             if verbose:
-                print("      SENT (simulated socket) packet: "+string.strip())
+                print("- SENT frame (simulated socket) packet: {}"
+                      .format(string.strip()))
             self.physicalLayer.onFrameSent(frame)
             count += 1
         return count

tests/test_canphysicallayer.py

@@ -9,20 +9,28 @@ class TestCanPhysicalLayerClass(unittest.TestCase):
     # test function marks that the listeners were fired
     received = False
 
+    def __init__(self, *args):
+        unittest.TestCase.__init__(self, *args)
+        self.layer = None
+        self._sentFramesCount = 0
+
     def receiveListener(self, frame: CanFrame):
         self.received = True
 
     def handleFrameReceived(self, frame: CanFrame):
         pass
 
     def handleFrameSent(self, frame: CanFrame):
-        pass
+        self._sentFramesCount += 1
+        if self.layer:
+            self.layer._sentFramesCount += 1
 
     def testReceipt(self):
         self.received = False
         frame = CanFrame(0x000, bytearray())
         receiver = self.receiveListener
         layer = CanPhysicalLayer()
+        self.layer = layer
         layer.onFrameReceived = self.handleFrameReceived
         layer.onFrameSent = self.handleFrameSent
         layer.registerFrameReceivedListener(receiver)

tests/test_canphysicallayergridconnect.py

@@ -30,6 +30,7 @@ def captureString(self, frame: CanFrame):
 
     def onFrameSent(self, frame: CanFrame):
         pass
+        self._sentFramesCount += 1
         # NOTE: not patching this method to be canLink.handleFrameSent
         #   since testing only physical layer not link layer.