Fix: Call sendAll in example_remode_nodes since not using Realtime subclass. Separate RealtimePhysicalLayer from RealtimeRawPhysicalLayer for clarity.

Author: Poikilos

examples/example_message_interface.py

@@ -91,7 +91,7 @@ def printMessage(msg):
 while True:
     count = 0
     count += physicalLayer.sendAll(sock, verbose=True)
-    count += physicalLayer.receiveAll(sock, verbose=settings['trace'])
+    count += physicalLayer.receiveAll(sock, verbose=True)
     if count < 1:
         precise_sleep(.01)
     # else skip sleep to avoid latency (port already delayed)

examples/example_remote_nodes.py

@@ -199,7 +199,7 @@ def result(arg1, arg2=None, arg3=None, result=True) :
                   NodeID(settings['localNodeID']), None)
 if settings['trace'] : print("SM: {}".format(message))
 canLink.sendMessage(message)
-
+physicalLayer.sendAll(sock)
 # pull the received messages
 while True :
     try :
@@ -218,4 +218,6 @@ def result(arg1, arg2=None, arg3=None, result=True) :
 
 # this ends here, which takes the local node offline
 
+# For explicitness (to make this example match use in non-linear
+#   application), notify openlcb of disconnect:
 physicalLayer.onDisconnect()

examples/example_tcp_message_interface.py

@@ -15,7 +15,7 @@
 # region same code as other examples
 from examples_settings import Settings  # do 1st to fix path if no pip install
 from openlcb import precise_sleep
-from openlcb.realtimephysicallayer import RealtimePhysicalLayer
+from openlcb.realtimerawphysicallayer import RealtimeRawPhysicalLayer
 settings = Settings()
 
 if __name__ == "__main__":
@@ -55,14 +55,14 @@
 #     assert isinstance(data, (bytes, bytearray))
 #     print("      SR: {}".format(data))
 #     sock.send(data)
-# ^ Moved to RealtimePhysicalLayer sendFrameAfter override
+# ^ Moved to RealtimeRawPhysicalLayer sendFrameAfter override
 
 
 def printMessage(msg):
     print("RM: {} from {}".format(msg, msg.source))
 
 
-physicalLayer = RealtimePhysicalLayer(sock)
+physicalLayer = RealtimeRawPhysicalLayer(sock)
 # ^ this was not in the example before
 # (just gave sendToSocket to TcpLink)
 
@@ -80,8 +80,8 @@ def printMessage(msg):
 message = Message(MTI.Verify_NodeID_Number_Global,
                   NodeID(settings['localNodeID']), None)
 print("SM: {}".format(message))
-tcpLinkLayer.sendMessage(message)
-
+tcpLinkLayer.sendMessage(message, verbose=True)
+physicalLayer.sendAll(sock, verbose=True)  # only a formality since Realtime
 # N/A
 # while not tcpLinkLayer.getState() == TcpLink.State.Permitted:
 #     time.sleep(.02)

openlcb/canbus/canlink.py

@@ -726,7 +726,7 @@ def handleReceivedData(self, frame: CanFrame):
                 msg.originalMTI = ((frame.header >> 12) & 0xFFF)
             self.fireMessageReceived(msg)
 
-    def sendMessage(self, msg: Message):
+    def sendMessage(self, msg: Message, verbose=False):
         #    special case for datagram
         if msg.mti == MTI.Datagram:
             header = 0x10_00_00_00

openlcb/canbus/canphysicallayergridconnect.py

@@ -214,4 +214,4 @@ def handleData(self, data: Union[bytes, bytearray], verbose=False) -> int:
 
             # shorten buffer by removing the processed message
             self.inboundBuffer = self.inboundBuffer[lastByte:]
-        return frameCount
+        return frameCount

openlcb/canbus/canphysicallayersimulation.py

@@ -2,7 +2,7 @@
 Simulated CanPhysicalLayer to record frames requested to be sent.
 '''
 
-from typing import List
+from typing import List, Union
 from openlcb.canbus.canframe import CanFrame
 from openlcb.canbus.canphysicallayer import CanPhysicalLayer
 from openlcb.frameencoder import FrameEncoder
@@ -25,9 +25,11 @@ def __init__(self):
     def _onQueuedFrame(self, frame: CanFrame):
         raise AttributeError("Not implemented for simulation")
 
-    def handleData(self, data: bytearray, verbose=False):
+    def handleData(self, data: Union[bytes, bytearray], verbose=False) -> int:
         # Do not parse, since simulation. Just collect for later analysis
         self.received_chunks.append(data)
+        frameCount = 1  # assumed for simulation
+        return frameCount
 
     def encodeFrameAsString(self, frame: CanFrame):
         return "(no encoding, only simulating CanPhysicalLayer superclass)"

openlcb/linklayer.py

@@ -151,7 +151,7 @@ def _onStateChanged(self, oldState, newState):
         raise NotImplementedError(
             "[LinkLayer] abstract _onStateChanged not implemented")
 
-    def sendMessage(self, msg: Message):
+    def sendMessage(self, msg: Message, verbose=False):
         '''This is the basic abstract interface
         '''
 

openlcb/physicallayer.py

@@ -73,7 +73,8 @@ def hasFrame(self) -> bool:
         """Check if there is a frame queued to send."""
         return bool(self._send_frames)
 
-    def sendAll(self, device: PortInterface, mode="binary", verbose=False) -> int:
+    def sendAll(self, device: PortInterface, mode="binary",
+                verbose=False) -> int:
         """Abstract method for sending queued frames"""
         raise NotImplementedError(
             "This must be implemented in a subclass"

openlcb/rawphysicallayer.py

@@ -0,0 +1,35 @@
+from typing import Union
+from openlcb.frameencoder import FrameEncoder
+from openlcb.physicallayer import PhysicalLayer
+
+
+class RawPhysicalLayer(PhysicalLayer, FrameEncoder):
+    """Implements FrameEncoder but leaves PhysicalLayer untouched
+    so that PhysicalLayer methods can be implemented by subclass or
+    sibling class used as second superclass by subclass.
+    - This FrameEncoder implementation doesn't actually
+      encode CanFrame--only converts between str & bytes!
+    """
+    def __init__(self, *args, **kwargs):
+        PhysicalLayer.__init__(self, *args, **kwargs)
+        FrameEncoder.__init__(self, *args, **kwargs)
+
+    def encodeFrameAsString(self, frame) -> str:
+        if isinstance(frame, str):
+            return frame
+        elif isinstance(frame, (bytearray, bytes)):
+            return frame.decode("utf-8")
+        raise TypeError(
+            "Only str, bytes, or bytearray is allowed for RawPhysicalLayer."
+            " For {} use/make another Encoder implementation."
+            .format(type(self).__name__))
+
+    def encodeFrameAsData(self, frame) -> Union[bytearray, bytes]:
+        if isinstance(frame, str):
+            return frame.encode("utf-8")
+        elif isinstance(frame, (bytearray, bytes)):
+            return frame
+        raise TypeError(
+            "Only str, bytes, or bytearray is allowed for RawPhysicalLayer."
+            " For frame type {} use/make another FrameEncoder implementation."
+            .format(type(self).__name__))

openlcb/realtimephysicallayer.py

@@ -1,15 +1,23 @@
 
-from enum import Enum
 from logging import getLogger
 from typing import Union
 
 from openlcb.physicallayer import PhysicalLayer
+from openlcb.portinterface import PortInterface
 
 logger = getLogger(__name__)
 
 
 class RealtimePhysicalLayer(PhysicalLayer):
-
+    """A realtime physical layer is only for use when there is an
+    absence of a link layer (or link layer doesn't enqueue frames) *and*
+    the application is not multi-threaded or uses a lock and avoids
+    race conditions.
+    Otherwise, overlapping port calls (*undefined behavior* at OS level)
+    may occur!
+    TODO: Add a lock variable and do reads here so all port usage can
+    utilize the lock and prevent overlapping use of the port.
+    """
     class State:
         Initial = 0
         Disconnected = 1
@@ -18,34 +26,74 @@ class State:
     DisconnectedState = State.Disconnected
 
     def __init__(self, socket):
+        PhysicalLayer.__init__(self)
         # sock to distinguish from socket module or socket.socket class!
         self.sock = socket
 
-    def sendDataAfter(self, data: Union[bytearray, bytes]):
+    def sendDataAfter(self, data: Union[bytearray, bytes], verbose=True):
+        """Send data (immediately, since realtime subclass).
+
+        Args:
+            data (Union[bytearray, bytes, CanFrame]): data to send.
+            verbose (bool, optional): verbose is only for Realtime
+                subclass (since data is sent immediately), otherwise set
+                verbose on sendAll. Defaults to False.
+        """
         # if isinstance(data, list):
         #     raise TypeError(
         #         "Got {}({}) but expected str"
         #         .format(type(data).__name__, data)
         #     )
         assert isinstance(data, (bytes, bytearray))
-        print("      SR: {}".format(data))
+        if verbose:
+            print("      SR: {}".format(data))
         self.sock.send(data)
 
-    def sendFrameAfter(self, frame):
+    def sendFrameAfter(self, frame, verbose=False):
+        """Send frame (immediately, since realtime subclass).
+
+        Args:
+            data (Union[bytearray, bytes, CanFrame]): data to send.
+            verbose (bool, optional): verbose is only for Realtime
+                subclass (since data is sent immediately), otherwise set
+                verbose on sendAll. Defaults to False.
+        """
+        if hasattr(self, 'encodeFrameAsData'):
+            data = self.encodeFrameAsData(frame)
+        else:
+            assert isinstance(frame, (bytes, bytearray, str)), \
+                "Use a FrameEncoder implementation if not using bytes/str"
+            if isinstance(frame, str):
+                data = frame.encode("utf-8")
+            else:
+                data = frame
         # if isinstance(data, list):
         #     raise TypeError(
         #         "Got {}({}) but expected str"
         #         .format(type(data).__name__, data)
         #     )
-        print("      SR: {}".format(frame.encode()))
+        if verbose:
+            print("      SR: {}".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(frame.encode())
-        # TODO: finish onFrameSent
-        if frame.afterSendState:
+        self.sock.send(data)
+        if hasattr(frame, 'afterSendState') and frame.afterSendState:
+            # Use hasattr since only applicable to subclasses that use
+            #   CanFrame.
             self.fireFrameReceived(frame)  # also calls self.onFrameSent(frame)
 
+    def sendAll(self, device: PortInterface, mode="binary",
+                verbose=False) -> int:
+        """sendAll is only a stub in the case of realtime subclasses.
+        Instead of popping frames it performs a check to ensure the
+        queue is not used (since queue should only be used for typical
+        subclasses which are queued).
+        """
+        if len(self._send_frames) > 0:
+            raise AssertionError("Realtime subclasses should not use a queue!")
+        logger.debug("sendAll ran (realtime subclass, so nothing to do)")
+
     def registerFrameReceivedListener(self, listener):
         """Register a new frame received listener
         (optional since LinkLayer subclass constructor sets