hmm

Author: AaronJackson

software/glasgow/applet/interface/gpib_controller/__init__.py

@@ -183,7 +183,7 @@ def elaborate(self, platform):
         ]
 
         # settle_delay = math.ceil(platform.default_clk_frequency * 1e-6)
-        settle_delay = 1000
+        settle_delay = 5
         timer = Signal(range(1 + settle_delay))
 
         m.d.comb += [
@@ -208,7 +208,11 @@ def elaborate(self, platform):
 
         with m.FSM():
             with m.State("Control: Begin"):
-                m.d.sync += self.status.eq(GPIBStatus.Idle)
+                m.d.comb += Print("Control")
+                m.d.sync += [
+                    self.status.eq(GPIBStatus.Idle),
+                    self.dav_o.eq(0),
+                ]
                 m.d.comb += self.i_stream.ready.eq(1)
                 with m.If(self.i_stream.valid):
                     m.d.sync += l_control.eq(self.i_stream.payload)
@@ -254,10 +258,12 @@ def elaborate(self, platform):
                 # resistor configuration from changing
                 # mid-transaction.
                 m.d.comb += [
-                    self.o_stream.valid.eq(1),
                     self.o_stream.payload.eq(GPIBMessage._Acknowledge),
+                    self.o_stream.valid.eq(1),
+                    Print("awaiting acknowledge ready")
                 ]
                 with m.If(self.o_stream.ready):
+                    m.d.comb += Print("acknowledge ready")
                     m.next = "Control: Begin"
 
             with m.State("Talk: Begin"):
@@ -316,11 +322,12 @@ def elaborate(self, platform):
                 ]
                 with m.If(self.o_stream.ready):
                     m.d.sync += self.nrfd_o.eq(0)
-                    m.next = "Listen: DAV unassert"
+                    m.next = "Listen: DAV assert"
 
-            with m.State("Listen: DAV unassert"):
+            with m.State("Listen: DAV assert"):
                 with m.If(self.dav_i):
                     m.d.sync += self.ndac_o.eq(0)
+                    m.d.sync += self.nrfd_o.eq(0)
                     m.next = "Control: Begin"
 
         return m
@@ -361,10 +368,13 @@ async def write(self, message: GPIBMessage, data=bytes([0])):
 
         for b in data:
             await self._pipe.send(bytes([message.value]))
+            print("sent:", message)
             await self._pipe.send(bytes([b]))
-            await self._pipe.flush()
-            ack = (await self._pipe.recv(1))[0]
-            assert GPIBMessage(ack) == GPIBMessage._Acknowledge
+            print("sent:", b)
+
+            ack = await self._pipe.recv(1)
+            print(ack)
+            assert GPIBMessage(ack[0]) == GPIBMessage._Acknowledge
 
     async def read(self, *, to_eoi=True):
         self.assembly.use_pulls({
@@ -380,14 +390,14 @@ async def read(self, *, to_eoi=True):
         eoi = False
         while not eoi:
             await self._pipe.send(bytes([GPIBMessage.Listen.value]))
-            await self._pipe.flush()
 
             eoi = bool((await self._pipe.recv(1))[0] & 2)
             if not to_eoi:
                 eoi = True
 
             yield (await self._pipe.recv(1))
 
+
     async def send_to(self, address, data):
         await self.cmd_talk(address)
         await self.write(GPIBMessage.Data, data)

software/glasgow/applet/interface/gpib_controller/test.py

@@ -1,14 +1,14 @@
 import logging
 import asyncio
-import time
 
 from amaranth import *
 
 from ... import *
 
 from glasgow.simulation.assembly import SimulationAssembly
 from glasgow.gateware.ports import PortGroup
-from . import GPIBControllerApplet, GPIBControllerInterface
+from . import GPIBControllerApplet, GPIBControllerInterface, GPIBStatus, GPIBMessage
+
 
 logger = logging.getLogger(__name__)
 
@@ -17,39 +17,40 @@ class GPIBControllerAppletTestCase(GlasgowAppletV2TestCase, applet=GPIBControlle
     def test_build(self):
         self.assertBuilds()
 
-
-    # def talk_and_listen(self, iface):
-    #     async def testbench(ctx):
-    #         print(ctx)
-    #         await iface.send_to(10, b'*IDN?')
-    #         await iface.read_from(10)
-    #     return testbench
-
-    def listen_and_reply(self, iface):
+    def send_a_message(self, iface):
         async def testbench(ctx):
-            time.sleep(0.5)
-            print(await iface.read_from(10))
-            await iface.send_to(10, b'GLASGOW DIGITAL INTERFACE EXPLORER')
+            print("hello from testbench")
+            # await iface.send_to(10, b'I')
+            await iface.write(GPIBMessage.Data, b'I')
+            # await iface.write(GPIBMessage.Data, b'O')
+            print("message sent")
         return testbench
 
-
-
     def test_two_can_talk(self):
         assembly  = SimulationAssembly()
         iface0    = GPIBControllerInterface(logger, assembly,
-                        dio="A0:7", eoi="A8", dav="A9", nrfd="A10", ndac="A11", srq="A12", ifc="A13", atn="A14", ren="A15")
-
+                                            dio="A0:7", eoi="A8", dav="A9", nrfd="A10", ndac="A11", srq="A12", ifc="A13", atn="A14", ren="A15")
         iface1    = GPIBControllerInterface(logger, assembly,
-                        dio="B0:7", eoi="B8", dav="B9", nrfd="B10", ndac="B11", srq="B12", ifc="B13", atn="B14", ren="B15")
+                                            dio="B0:7", eoi="B8", dav="B9", nrfd="B10", ndac="B11", srq="B12", ifc="B13", atn="B14", ren="B15")
 
-        for pin in range(0,16):
+        # We skip IFC, ATN and REN, since they're always under the
+        # control of the controller, and we're pretending one of the
+        # controller isn't a controller....
+        for pin in range(0,13):
             assembly.connect_pins("A%i" % pin, "B%i" % pin)
 
-        # assembly.add_testbench(self.talk_and_listen(iface0))
-        assembly.add_testbench(self.listen_and_reply(iface1))
+        assembly.add_testbench(self.send_a_message(iface0))
 
         async def do_it(ctx):
-            await iface0.send_to(10, b'*IDN?')
-            await iface0.read_from(10)
+            import time
+            time.sleep(0.1)
+            while True:
+                response = b''
+                async for data in iface1.read(to_eoi=True):
+                    response += data
+                    # print(data)
+                    # print("Talker:", GPIBStatus(await iface0._status.get()))
+                    # print("Listener:", GPIBStatus(await iface1._status.get()))
+
 
         assembly.run(do_it, vcd_file="test.vcd")