ebpfcat/ethercat.py

@@ -968,7 +968,7 @@ class Terminal:
         oe.dataTypeOriginal = dataType
         if dataType < 2048:
             oe.dataType = ECDataType(dataType)
-        elif oe.bitLength == 8:
+        elif oe.bitLength <= 8:
             oe.dataType = ECDataType.UNSIGNED8
         else:
             oe.dataType = dataType

ebpfcat/serial.py

@@ -15,44 +15,63 @@
 # with this program; if not, write to the Free Software Foundation, Inc.,
 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 
-from asyncio import ensure_future, Event, Queue, StreamReader, gather
+from asyncio import ensure_future, Event, Future, Queue, StreamReader, gather
 from .ebpfcat import Device, TerminalVar
 
 
 class Serial(Device):
-    channel = TerminalVar()
+    transmit_accept = TerminalVar()
+    receive_request = TerminalVar()
+    init_accept = TerminalVar()
+    in_string = TerminalVar()
+    transmit_request = TerminalVar()
+    receive_accept = TerminalVar()
+    init_request = TerminalVar()
+    out_string = TerminalVar()
 
     def __init__(self, channel):
+        self.transmit_accept = channel.transmit_accept
+        self.receive_request = channel.receive_request
+        self.init_accept = channel.init_accept
+        self.in_string = channel.in_string
+        self.transmit_request = channel.transmit_request
+        self.receive_accept = channel.receive_accept
+        self.init_request = channel.init_request
+        self.out_string = channel.out_string
+
         self.buffer = Queue()
-        self.channel = channel
         self.data_arrived = Event()
 
     def write(self, data):
         self.buffer.put_nowait(data)
 
-    def connect(self):
-        self.task = ensure_future(self.run())
+    async def connect(self):
+        connected = Future()
+        self.task = ensure_future(self.run(connected))
         self.reader = StreamReader()
+        await connected
         return self.reader, self
 
-    async def run(self):
-        while not self.channel.init_accept:
-            self.channel.init_request = True
+    async def run(self, connected):
+        while not self.init_accept:
+            self.init_request = True
             await self.data_arrived.wait()
-        self.channel.init_request = False
-        while self.channel.init_accept:
+        self.init_request = False
+        while self.init_accept:
             await self.data_arrived.wait()
 
+        connected.set_result(None)
+
         await gather(self.receive(), self.transmit())
 
     async def receive(self):
-        ra = self.channel.receive_accept
+        ra = self.receive_accept
         while True:
-            rr = self.channel.receive_request
-            while rr == self.channel.receive_request:
-                self.channel.receive_accept = ra
+            rr = self.receive_request
+            while rr == self.receive_request:
+                self.receive_accept = ra
                 await self.data_arrived.wait()
-            self.reader.feed_data(self.channel.in_string)
+            self.reader.feed_data(self.in_string)
             ra = not ra
 
     async def transmit(self):
@@ -62,23 +81,22 @@ class Serial(Device):
             nonlocal remainder
             s = remainder
             size = len(remainder)
-            while not self.buffer.empty() or size == 0:
-                if size + len(s) > 22:
-                    remainder = s[22-size:]
-                    yield s[:22-size]
+
+            while True:
+                remainder = s[22-size:]
+                yield s[:22-size]
+                size += len(s)
+                if (self.buffer.empty() and size > 0) or size > 22:
                     return
-                else:
-                    yield s
-                    size += len(s)
-                    s = await self.buffer.get()
+                s = await self.buffer.get()
 
         while True:
-            ta = self.channel.transmit_accept
-            tr = self.channel.transmit_request
+            ta = self.transmit_accept
+            tr = self.transmit_request
             chunk = b"".join([s async for s in inner()])
-            while ta == self.channel.transmit_accept:
-                self.channel.out_string = chunk
-                self.channel.transmit_request = not tr
+            while ta == self.transmit_accept:
+                self.out_string = chunk
+                self.transmit_request = not tr
                 await self.data_arrived.wait()
 
     def update(self):

ebpfcat/terminals.py

@@ -15,7 +15,7 @@
 # with this program; if not, write to the Free Software Foundation, Inc.,
 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 
-from .ethercat import ServiceDesc, Struct
+from .ethercat import ServiceDesc, Struct, SyncManager
 from .ebpfcat import EBPFTerminal, PacketDesc, ProcessDesc
 
 
@@ -147,22 +147,33 @@ class EL5042(EBPFTerminal):
     channel1 = Channel(0)
     channel2 = Channel(0x10)
 
+
 class EL6022(EBPFTerminal):
+    compatibility = {(2, 0x17863052)}
+
     class Channel(Struct):
-        transmit_accept = PacketDesc(3, 0, 0)
-        receive_request = PacketDesc(3, 0, 1)
-        init_accept = PacketDesc(3, 0, 2)
-        status = PacketDesc(3, 0, "H")
-        in_string = PacketDesc(3, 1, "23p")
-
-        transmit_request = PacketDesc(2, 0, 0)
-        receive_accept = PacketDesc(2, 0, 1)
-        init_request = PacketDesc(2, 0, 2)
-        control = PacketDesc(2, 0, "H")
-        out_string = PacketDesc(2, 1, "23p")
-
-    channel1 = Channel(0, 0)
-    channel2 = Channel(24, 24)
+        transmit_accept = PacketDesc(SyncManager.IN, 0, 0)
+        receive_request = PacketDesc(SyncManager.IN, 0, 1)
+        init_accept = PacketDesc(SyncManager.IN, 0, 2)
+        in_string = PacketDesc(SyncManager.IN, 1, "23p")
+
+        transmit_request = PacketDesc(SyncManager.OUT, 0, 0)
+        receive_accept = PacketDesc(SyncManager.OUT, 0, 1)
+        init_request = PacketDesc(SyncManager.OUT, 0, 2)
+        out_string = PacketDesc(SyncManager.OUT, 1, "23p")
+
+        enableRtsCts = ServiceDesc(0x8000, 1)
+        enableXonXoffSend = ServiceDesc(0x8000, 2)
+        enableXonXoffReceive = ServiceDesc(0x8000, 3)
+        enableFIFOcontinuous = ServiceDesc(0x8000, 4)
+        enableTransferRateOptimization = ServiceDesc(0x8000, 5)
+        enableHalfDuplex = ServiceDesc(0x8000, 6)
+        enablePointToPoint = ServiceDesc(0x8000, 7)
+        baudRate = ServiceDesc(0x8000, 0x11)
+        dataFrame = ServiceDesc(0x8000, 0x15)
+
+    channel1 = Channel(0)
+    channel2 = Channel(0x10)
 
 
 class EL7041(EBPFTerminal):