Model the network layer order consistently (socket <-> [PhysicalLayer <-> other layers] <-> application).

Poikilos · Poikilos · commit 087075e53c30 · 2025-05-22T01:57:45.000-04:00
diff --git a/examples/example_cdi_access.py b/examples/example_cdi_access.py
@@ -248,12 +248,12 @@ def processXML(content: str) :
 print("      QUEUED frames : link up...waiting...")
 while canLink.pollState() != CanLink.State.Permitted:
     # provides incoming data to physicalLayer & sends queued:
-    canLink.receiveAll(sock, verbose=True)
-    canLink.sendAll(sock)
+    physicalLayer.receiveAll(sock, verbose=True)
+    physicalLayer.sendAll(sock)
 
     if canLink.getState() == CanLink.State.WaitForAliases:
-        # canLink.receiveAll(sock, verbose=True)
-        canLink.sendAll(sock)
+        # physicalLayer.receiveAll(sock, verbose=True)
+        physicalLayer.sendAll(sock)
         # ^ prevent assertion error below, proceed to send.
     if canLink.pollState() == CanLink.State.Permitted:
         break
@@ -300,8 +300,8 @@ def memoryRead():
     #   receives the data from the requested memory space (CDI in this
     #   case) and offset (incremental position in the file/data,
     #   incremented by this example's memoryReadSuccess handler).
-    canLink.receiveAll(sock)
-    canLink.sendAll(sock)
+    physicalLayer.receiveAll(sock)
+    physicalLayer.sendAll(sock)
     if canLink.nodeIdToAlias != previous_nodes:
         print("nodeIdToAlias updated: {}".format(canLink.nodeIdToAlias))
     precise_sleep(.01)
diff --git a/examples/example_datagram_transfer.py b/examples/example_datagram_transfer.py
@@ -104,8 +104,8 @@ def datagramReceiver(memo):
 print("      SL : link up")
 
 while canLink.pollState() != CanLink.State.Permitted:
-    canLink.receiveAll(sock, verbose=settings['trace'])
-    canLink.sendAll(sock)
+    physicalLayer.receiveAll(sock, verbose=settings['trace'])
+    physicalLayer.sendAll(sock)
     precise_sleep(.02)
 
 
@@ -131,7 +131,7 @@ def datagramWrite():
 
 # process resulting activity
 while True:
-    canLink.receiveAll(sock, verbose=settings['trace'])
-    canLink.sendAll(sock)
+    physicalLayer.receiveAll(sock, verbose=settings['trace'])
+    physicalLayer.sendAll(sock)
 
 canLink.onDisconnect()
diff --git a/examples/example_frame_interface.py b/examples/example_frame_interface.py
@@ -48,40 +48,6 @@ def sendToSocket(frame: CanFrame):
     physicalLayer.onFrameSent(frame)
 
 
-def pumpEvents():
-    # Normally receive call & case below can be replaced by
-    #   canLink.receiveAll(sock), but in this example we have no link
-    #   layer.
-    received = sock.receive()
-    if received is not None:
-        if settings['trace']:
-            observer.push(received)
-            if observer.hasNext():
-                packet_str = observer.next()
-                print("   RR: "+packet_str.strip())
-        # pass to link processor
-        physicalLayer.handleData(received)
-
-    # Normally the loop below can be replaced by canLink.sendAll(sock),
-    #   but in this example we have no link layer.
-    # canLink.pollState()
-    while True:
-        frame = physicalLayer.pollFrame()
-        if frame is None:
-            break
-        string = frame.encodeAsString()
-        print("   SR: {}".format(string.strip()))
-        sock.sendString(string)
-        physicalLayer.onFrameSent(frame)
-        if frame.afterSendState:
-            print("Next state (unexpected, no link layer): {}"
-                  .format(frame.afterSendState))
-            # canLink.setState(frame.afterSendState)
-            # ^ setState is done by onFrameSent now
-            #   (physicalLayer.onFrameSent = self.handleFrameSent
-            #   in LinkLayer constructor)
-
-
 def handleFrameSent(frame):
     # No state to manage since no link layer
     pass
@@ -105,16 +71,11 @@ def printFrame(frame):
 frame = CanFrame(ControlFrame.AME.value, 1, bytearray())
 print("SL: {}".format(frame))
 physicalLayer.sendFrameAfter(frame)
-
-while True:
-    frame = physicalLayer.pollFrame()
-    if not frame:
-        break
-    sendToSocket(frame)
+physicalLayer.sendAll(sock, verbose=True)
 
 observer = GridConnectObserver()
 
 # display response - should be RID from nodes
 while True:
-    pumpEvents()
+    physicalLayer.receiveAll(sock, verbose=True)
     precise_sleep(.01)
diff --git a/examples/example_memory_length_query.py b/examples/example_memory_length_query.py
@@ -126,8 +126,8 @@ def memoryLengthReply(address) :
 
 
 while canLink.pollState() != CanLink.State.Permitted:
-    canLink.receiveAll(sock, verbose=settings['trace'])
-    canLink.sendAll(sock, verbose=True)
+    physicalLayer.receiveAll(sock, verbose=settings['trace'])
+    physicalLayer.sendAll(sock, verbose=True)
     precise_sleep(.02)
 print("      SL : link up")
 
@@ -155,8 +155,8 @@ def memoryRequest():
 
 # process resulting activity
 while True:
-    canLink.receiveAll(sock, verbose=settings['trace'])
-    canLink.sendAll(sock, verbose=True)
+    physicalLayer.receiveAll(sock, verbose=settings['trace'])
+    physicalLayer.sendAll(sock, verbose=True)
     precise_sleep(.01)
 
 canLink.onDisconnect()
diff --git a/examples/example_memory_transfer.py b/examples/example_memory_transfer.py
@@ -122,8 +122,8 @@ def memoryReadFail(memo):
 physicalLayer.physicalLayerUp()
 print("      SL : link up...waiting...")
 while canLink.pollState() != CanLink.State.Permitted:
-    canLink.receiveAll(sock, verbose=settings['trace'])
-    canLink.sendAll(sock)
+    physicalLayer.receiveAll(sock, verbose=settings['trace'])
+    physicalLayer.sendAll(sock)
     precise_sleep(.02)
 print("      SL : link up")
 
@@ -150,8 +150,8 @@ def memoryRead():
 
 # process resulting activity
 while True:
-    canLink.receiveAll(sock, verbose=settings['trace'])
-    canLink.sendAll(sock)
+    physicalLayer.receiveAll(sock, verbose=settings['trace'])
+    physicalLayer.sendAll(sock)
     precise_sleep(.01)
 
 canLink.onDisconnect()
diff --git a/examples/example_message_interface.py b/examples/example_message_interface.py
@@ -77,8 +77,8 @@ def printMessage(msg):
 print("      SL : link up...waiting...")
 physicalLayer.physicalLayerUp()
 while canLink.pollState() != CanLink.State.Permitted:
-    canLink.receiveAll(sock, verbose=settings['trace'])
-    canLink.sendAll(sock, verbose=True)
+    physicalLayer.receiveAll(sock, verbose=settings['trace'])
+    physicalLayer.sendAll(sock, verbose=True)
     precise_sleep(.02)
 print("      SL : link up")
 # send an VerifyNodes message to provoke response
@@ -89,8 +89,8 @@ def printMessage(msg):
 
 # process resulting activity
 while True:
-    canLink.receiveAll(sock, verbose=settings['trace'])
-    canLink.sendAll(sock, verbose=True)
+    physicalLayer.receiveAll(sock, verbose=settings['trace'])
+    physicalLayer.sendAll(sock, verbose=True)
     precise_sleep(.01)
 
 canLink.onDisconnect()
diff --git a/examples/example_node_implementation.py b/examples/example_node_implementation.py
@@ -151,8 +151,8 @@ def displayOtherNodeIds(message) :
 physicalLayer.physicalLayerUp()
 print("      SL : link up...waiting...")
 while canLink.pollState() != CanLink.State.Permitted:
-    canLink.receiveAll(sock, verbose=settings['trace'])
-    canLink.sendAll(sock, verbose=True)
+    physicalLayer.receiveAll(sock, verbose=settings['trace'])
+    physicalLayer.sendAll(sock, verbose=True)
     precise_sleep(.02)
 print("      SL : link up")
 # request that nodes identify themselves so that we can print their node IDs
@@ -164,8 +164,8 @@ def displayOtherNodeIds(message) :
 
 # process resulting activity
 while True:
-    canLink.receiveAll(sock, verbose=settings['trace'])
-    canLink.sendAll(sock, verbose=True)
+    physicalLayer.receiveAll(sock, verbose=settings['trace'])
+    physicalLayer.sendAll(sock, verbose=True)
     precise_sleep(.01)
 
 canLink.onDisconnect()
diff --git a/examples/example_remote_nodes.py b/examples/example_remote_nodes.py
@@ -126,8 +126,8 @@ def printMessage(msg):
     state = canLink.getState()
     if state == CanLink.State.Permitted:
         break
-    canLink.receiveAll(sock, verbose=settings['trace'])
-    canLink.sendAll(sock, verbose=True)
+    physicalLayer.receiveAll(sock, verbose=settings['trace'])
+    physicalLayer.sendAll(sock, verbose=True)
 
 
 if state != previousState:
@@ -145,7 +145,7 @@ def printMessage(msg):
 def receiveLoop():
     """put the read on a separate thread"""
     while True:
-        canLink.receiveAll(sock, verbose=settings['trace'])
+        physicalLayer.receiveAll(sock, verbose=settings['trace'])
         precise_sleep(.01)
 
 
diff --git a/examples/example_string_interface.py b/examples/example_string_interface.py
@@ -45,7 +45,8 @@
 # display response - should be RID from node(s)
 while True:  # have to kill this manually
     # Normally the receive call and case can be replaced by
-    #   canLink.receiveAll, but we have no canLink in this example.
+    #   physicalLayer.receiveAll, but we have no physicalLayer in this
+    #   example.
     received = sock.receive()
     if received is not None:
         observer.push(received)
diff --git a/openlcb/canbus/canframe.py b/openlcb/canbus/canframe.py
@@ -198,3 +198,12 @@ def __eq__(self, other):
         if self.data != other.data:
             return False
         return True
+
+    def difference(self, other):
+        if other is None:
+            return "other is None"
+        if self.header != other.header:
+            return "header {} != {}".format(self.header, other.header)
+        if self.data != other.data:
+            return "data {} != {}".format(self.data, other.data)
+        return None
diff --git a/openlcb/canbus/canlink.py b/openlcb/canbus/canlink.py
@@ -1153,53 +1153,12 @@ def canHeaderToFullFormat(self, frame: CanFrame) -> MTI:
             .format(frame))
         return MTI.Unknown
 
-    def receiveAll(self, device: PortInterface, verbose=False):
-        """Receive all data on the given device.
-        Args:
-            device (PortInterface): Device which *must* be in
-                non-blocking mode (otherwise necessary two-way
-                communication such as alias reservation cannot occur).
-            verbose (bool, optional): If True, print each full packet.
-        """
-        try:
-            data = device.receive()  # If timeout, set non-blocking
-            if data is None:
-                return
-            self.physicalLayer.handleData(data, verbose=verbose)
-        except BlockingIOError:
-            # raised by receive if no data (non-blocking is
-            #   what we want, so fall through).
-            pass
-
-    def sendAll(self, device: PortInterface, mode="binary", verbose=False):
-        """Send all queued frames using the given device.
-
-        Args:
-            device (PortInterface): A Serial or Socket device
-                implementation of PortInterface so as to provide a send
-                method (Since usually Socket has send & sendString but
-                Serial has write).
-            mode (str, optional): "binary" (use device.send) or "text"
-                (use device.sendString). Defaults to "binary".
-            verbose (bool, optional): Print the sent packet (not
-                recommended for numerous memory reads such as CDI/FDI).
-                Defaults to False.
-
-        Returns:
-            int: The count of frames sent. If 0, None were queued by
-                sendFrameAfter (or internal python-openlcb methods which
-                call it) since the queue was created or since the last
-                time all frames were polled.
-        """
-        self.pollState()  # Advance delayed state(s) if necessary
-        #  (done first since may enqueue frames).
-        return self.physicalLayer.sendAll(device, mode=mode, verbose=verbose)
-
     def waitForReady(self, device: PortInterface, mode="binary",
                      run_physical_link_up_test=False, verbose=True):
         """Send and receive frames until.
-        Other thread(s) *must not* use the device during this (that
-        would cause "undefined behavior" at OS level).
+        Other thread(s) *must not* use the device during this
+        (overlapping read or write would cause "undefined behavior" at
+        OS level).
 
         Args:
             device (PortInterface): *Must* be in non-blocking
@@ -1224,8 +1183,7 @@ def waitForReady(self, device: PortInterface, mode="binary",
         first = True
         state = self.pollState()
         if verbose:
-            print(prefix+"waitForReady...state={}..."
-                  .format(state))
+            print(prefix+"waitForReady...state={}...".format(state))
         first_state = state
         if run_physical_link_up_test:
             assert state == CanLink.State.WaitingForSendCIDSequence
@@ -1244,7 +1202,7 @@ def waitForReady(self, device: PortInterface, mode="binary",
                 first = False
             if verbose and debug_count < 3:
                 print("  * sendAll")
-            self.sendAll(device, mode=mode, verbose=verbose)
+            self.physicalLayer.sendAll(device, mode=mode, verbose=verbose)
             if verbose and debug_count < 3:
                 print("  * state: {}".format(state))
             state = self.getState()
@@ -1274,6 +1232,7 @@ def waitForReady(self, device: PortInterface, mode="binary",
                 state = self.pollState()  # set _waitingForAliasStart if None
                 # (prevent getWaitForAliasResponseStart() None in assert below)
                 if device is not None:
+                    # self.physicalLayer.receiveAll(device)
                     try:
                         data = device.receive()  # If timeout, set non-blocking
                         self.physicalLayer.handleData(data)
diff --git a/openlcb/canbus/canlinklayersimulation.py b/openlcb/canbus/canlinklayersimulation.py
@@ -7,27 +7,4 @@
 
 
 class CanLinkLayerSimulation(CanLink):
-
-    def sendAll(self, _, mode="binary", verbose=True):
-        """Simulated sendAll
-        The simulation has no real communication, so no device argument
-        is necessary. See CanLink for a real implementation.
-
-        Args:
-            verbose (bool, optional): If True, print the packet (not
-                recommended in the case of numerous sequential memory
-                read requests such as when reading CDI/FDI).
-        """
-
-        self.pollState()  # run first since may enqueue frame(s)
-        while True:
-            # self.physicalLayer must be set by canLink constructor by
-            #   passing a physicalLayer to it.
-            frame = self.physicalLayer.pollFrame()
-            if not frame:
-                break
-            string = frame.encodeAsString()
-            # device.sendString(string)  # commented since simulation
-            if verbose:
-                print("      SENT (simulated socket) packet: "+string.strip())
-            self.physicalLayer.onFrameSent(frame)
+    pass
diff --git a/openlcb/canbus/canphysicallayer.py b/openlcb/canbus/canphysicallayer.py
@@ -10,6 +10,7 @@
 
 from openlcb.canbus.canframe import CanFrame
 from openlcb.canbus.controlframe import ControlFrame
+from openlcb.linklayer import LinkLayer
 from openlcb.physicallayer import PhysicalLayer
 
 logger = getLogger(__name__)
@@ -23,6 +24,7 @@ class CanPhysicalLayer(PhysicalLayer):
 
     def __init__(self,):
         PhysicalLayer.__init__(self)
+        self.linkLayer: LinkLayer = None  # CanLink would be circular import
         self._frameReceivedListeners: list[Callable[[CanFrame], None]] = []
 
     def sendFrameAfter(self, frame: CanFrame):
diff --git a/openlcb/canbus/canphysicallayergridconnect.py b/openlcb/canbus/canphysicallayergridconnect.py
diff --git a/openlcb/canbus/canphysicallayersimulation.py b/openlcb/canbus/canphysicallayersimulation.py
diff --git a/openlcb/linklayer.py b/openlcb/linklayer.py
diff --git a/tests/test_canlink.py b/tests/test_canlink.py
