ebyst 0.1.0__tar.gz

ebyst-0.1.0/.gitignore

@@ -0,0 +1,3 @@
+venv
+dist
+**/__pycache__

ebyst-0.1.0/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2024 Sijmen Woutersen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ebyst-0.1.0/Makefile

@@ -0,0 +1,15 @@
+#!/usr/bin/bash
+
+default:
+	@echo Usage: make [dist|venv]
+
+.PHONY: dist
+dist:
+	python3 -m build .
+
+.PHONY: venv
+venv:
+	python3 -m venv venv
+	venv/bin/pip install --upgrade pip
+	venv/bin/pip install build
+	venv/bin/pip install -e .

ebyst-0.1.0/PKG-INFO

@@ -0,0 +1,87 @@
+Metadata-Version: 2.3
+Name: ebyst
+Version: 0.1.0
+Summary: Boundary scan test library
+Project-URL: Homepage, https://github.com/swolix/ebyst
+Project-URL: Issues, https://github.com/swolix/ebyst/issues
+Author-email: Sijmen Woutersen <sijmen.woutersen@gmail.com>
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Requires-Dist: bitarray
+Requires-Dist: pyftdi
+Description-Content-Type: text/markdown
+
+# EByST
+Boundary scan test framework for board validation
+
+# Basic example
+```python
+# initialize JTAG interface driver (currently only FT2232H is supported)
+drv = ebyst.drivers.FT2232H(ebyst.drivers.FT2232H.list_devices()[0])
+ctl = ebyst.TapController(drv)
+ctl.detect_chain()
+
+# Add device(s) to chain
+dev = ebyst.Device.from_bsdl("bsdl/BSDLLCMXO2-256HCQFN32.BSM")
+ctl.add_device(dev)
+ctl.validate_chain()
+
+# Start test
+ctl.extest()
+
+# Loopback test (assuming loopback on pins
+dev.pinmap['O'].output_enable(True)
+dev.pinmap['I'].output_enable(False)
+dev.pinmap['O'].set_value(1)
+await ctl.cycle() # drive output
+await ctl.cycle() # sample input
+print(dev.pinmap['I'].get_value())
+dev.pinmap['O'].set_value(0)
+await ctl.cycle() # drive output
+await ctl.cycle() # sample input
+print(dev.pinmap['I'].get_value())
+
+# I2C test
+i2c = ebyst.interfaces.I2C(ctl, dev.pinmap['PB9A'], dev.pinmap['PB4B'])
+await i2c.init()
+dev_address = 0xa0
+reg_address = 0x10
+data = 0xa5
+print(f"Writing {dev_address:02x}:{reg_address:02x} <= {data:02x}")
+await i2c.write(0xa0, 0x10, 0xa5)
+print(f"Reading {dev_address:02x}:{reg_address:02x} => ", end='')
+await x = i2c.read(0xa0, 0x10)
+print(f"{x:02x}")
+
+ctl.reset()
+```
+# Async
+The library uses `asyncio` to allow running multiple tests in parallel.
+When the loopback test and I2C test above are put in different tasks, they share the same boundary scan cycles,
+meaning they run completely parallel
+(Note that this only works when they are not using different pins, if pins are shared between tests, make sure to
+schedule them appropriately)
+
+Example;
+```python
+async def main():
+    drv = ebyst.drivers.FT2232H(ebyst.drivers.FT2232H.list_devices()[0])
+    dev = ebyst.Device.from_bsdl("bsdl/BSDLLCMXO2-256HCQFN32.BSM")
+    ctl = ebyst.TapController(drv)
+    ctl.detect_chain()
+    ctl.add_device(dev)
+    ctl.validate_chain()
+    ctl.extest()
+    async with asyncio.TaskGroup() as tg:
+        tg.create_task(loopback_test(ctl, dev.pinmap['PB2C'], dev.pinmap['PB2A']))
+        tg.create_task(loopback_test(ctl, dev.pinmap['PB4C'], dev.pinmap['PB4D']))
+
+if __name__ == "__main__":
+    logging.basicConfig()
+    logging.getLogger().setLevel(logging.INFO)
+    asyncio.run(main())
+```
+
+see also `tests/test_async.py`

ebyst-0.1.0/README.md

@@ -0,0 +1,72 @@
+# EByST
+Boundary scan test framework for board validation
+
+# Basic example
+```python
+# initialize JTAG interface driver (currently only FT2232H is supported)
+drv = ebyst.drivers.FT2232H(ebyst.drivers.FT2232H.list_devices()[0])
+ctl = ebyst.TapController(drv)
+ctl.detect_chain()
+
+# Add device(s) to chain
+dev = ebyst.Device.from_bsdl("bsdl/BSDLLCMXO2-256HCQFN32.BSM")
+ctl.add_device(dev)
+ctl.validate_chain()
+
+# Start test
+ctl.extest()
+
+# Loopback test (assuming loopback on pins
+dev.pinmap['O'].output_enable(True)
+dev.pinmap['I'].output_enable(False)
+dev.pinmap['O'].set_value(1)
+await ctl.cycle() # drive output
+await ctl.cycle() # sample input
+print(dev.pinmap['I'].get_value())
+dev.pinmap['O'].set_value(0)
+await ctl.cycle() # drive output
+await ctl.cycle() # sample input
+print(dev.pinmap['I'].get_value())
+
+# I2C test
+i2c = ebyst.interfaces.I2C(ctl, dev.pinmap['PB9A'], dev.pinmap['PB4B'])
+await i2c.init()
+dev_address = 0xa0
+reg_address = 0x10
+data = 0xa5
+print(f"Writing {dev_address:02x}:{reg_address:02x} <= {data:02x}")
+await i2c.write(0xa0, 0x10, 0xa5)
+print(f"Reading {dev_address:02x}:{reg_address:02x} => ", end='')
+await x = i2c.read(0xa0, 0x10)
+print(f"{x:02x}")
+
+ctl.reset()
+```
+# Async
+The library uses `asyncio` to allow running multiple tests in parallel.
+When the loopback test and I2C test above are put in different tasks, they share the same boundary scan cycles,
+meaning they run completely parallel
+(Note that this only works when they are not using different pins, if pins are shared between tests, make sure to
+schedule them appropriately)
+
+Example;
+```python
+async def main():
+    drv = ebyst.drivers.FT2232H(ebyst.drivers.FT2232H.list_devices()[0])
+    dev = ebyst.Device.from_bsdl("bsdl/BSDLLCMXO2-256HCQFN32.BSM")
+    ctl = ebyst.TapController(drv)
+    ctl.detect_chain()
+    ctl.add_device(dev)
+    ctl.validate_chain()
+    ctl.extest()
+    async with asyncio.TaskGroup() as tg:
+        tg.create_task(loopback_test(ctl, dev.pinmap['PB2C'], dev.pinmap['PB2A']))
+        tg.create_task(loopback_test(ctl, dev.pinmap['PB4C'], dev.pinmap['PB4D']))
+
+if __name__ == "__main__":
+    logging.basicConfig()
+    logging.getLogger().setLevel(logging.INFO)
+    asyncio.run(main())
+```
+
+see also `tests/test_async.py`

ebyst-0.1.0/pyproject.toml

@@ -0,0 +1,26 @@
+[project]
+name = "ebyst"
+version = "0.1.0"
+dependencies = [
+    "pyftdi",
+    "bitarray",
+]
+authors = [
+  { name="Sijmen Woutersen", email="sijmen.woutersen@gmail.com" },
+]
+description = "Boundary scan test library"
+readme = "README.md"
+requires-python = ">=3.8"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+
+[project.urls]
+Homepage = "https://github.com/swolix/ebyst"
+Issues = "https://github.com/swolix/ebyst/issues"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"

ebyst-0.1.0/src/ebyst/__init__.py

@@ -0,0 +1,4 @@
+from . import drivers
+from . import interfaces
+from .tap_controller import TapController, State as JtagState
+from .device import Device

ebyst-0.1.0/src/ebyst/bsdl.py

@@ -0,0 +1,125 @@
+# Copyright (c) 2024 Sijmen Woutersen
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+import logging
+import pyparsing as pp
+
+logger = logging.getLogger(__name__)
+
+class BSDLFile:
+    """BSDL parser"""
+
+    class Declaration:
+        def __init__(self, name, type_, value=None, direction=None, range_start=None, range_end=None, owner=None):
+            self.name = name
+            self.type_ = type_
+            self.value = value
+            self.direction = direction
+            self.range_start = range_start
+            self.range_end = range_end
+            self.owner = owner
+
+    def __init__(self, name):
+        self.name = name
+        self.generics = {}
+        self.ports = {}
+        self.constants = {}
+        self.attributes = {}
+
+    @classmethod
+    def parse(cls, f):
+        comments = "--" + pp.SkipTo(pp.LineEnd())
+        identifier = pp.Word(init_chars=pp.srange("[a-zA-Z]"), body_chars=pp.srange("[a-zA-Z0-9_]"))
+        string_literal = pp.Combine(pp.QuotedString("\"") +
+                                    pp.ZeroOrMore(pp.Suppress(pp.Literal("&")) + pp.QuotedString("\"")), adjacent=False)
+        numeric_literal = pp.Or((pp.pyparsing_common.sci_real, pp.pyparsing_common.integer))
+        primary = pp.Forward()
+        enumeration_literal = (pp.Suppress(pp.Literal("(")) + primary +
+                               pp.ZeroOrMore(pp.Suppress(pp.Literal(",")) + primary) + pp.Suppress(pp.Literal(")")))
+        literal = pp.Or((numeric_literal, enumeration_literal, string_literal))
+        primary <<= pp.Or((identifier, literal))
+        expression = primary
+        mode = pp.Or((pp.CaselessKeyword("in"), pp.CaselessKeyword("out"), pp.CaselessKeyword("inout"),
+                     pp.CaselessKeyword("buffer"), pp.CaselessKeyword("linkage")))
+        range = (pp.Suppress(pp.Literal("(")) + pp.pyparsing_common.integer +
+                 pp.Or((pp.CaselessKeyword("to"), pp.CaselessKeyword("downto"))) +
+                 pp.pyparsing_common.integer + pp.Suppress(pp.Literal(")")))
+        subtype_indication = identifier + pp.Optional(range)
+        declaration = pp.Group(identifier + pp.Suppress(pp.Literal(":")) +
+                            pp.Optional(mode) + subtype_indication +
+                            pp.Optional(pp.Suppress(pp.Literal(":=")) + expression))
+        interface_list = declaration + pp.ZeroOrMore(pp.Suppress(pp.Literal(";")) + declaration)
+        generic_clause = pp.Group(pp.CaselessKeyword("generic") + pp.Suppress(pp.Literal("(")) + interface_list +
+                                  pp.Suppress(pp.Literal(")")) + pp.Suppress(pp.Literal(";")))
+        port_clause = pp.Group(pp.CaselessKeyword("port") + pp.Suppress(pp.Literal("(")) + interface_list +
+                               pp.Suppress(pp.Literal(")")) + pp.Suppress(pp.Literal(";")))
+        use_clause = pp.Group(pp.CaselessKeyword("use") + identifier + pp.Literal(".") + identifier +
+                              pp.ZeroOrMore(pp.Literal(",") + identifier) +
+                              pp.Suppress(pp.Literal(";")))
+        class_ = pp.Or((pp.CaselessKeyword("entity"), pp.CaselessKeyword("signal")))
+        attribute_specification = pp.Group(pp.CaselessKeyword("attribute") + identifier +
+                                           pp.Suppress(pp.CaselessKeyword("of")) + identifier +
+                                           pp.Suppress(pp.Literal(":")) + class_ +
+                                           pp.Suppress(pp.CaselessKeyword("is")) + expression +
+                                           pp.Suppress(pp.Literal(";")))
+        constant_declaration = pp.Group(pp.CaselessKeyword("constant") + declaration + pp.Suppress(pp.Literal(";")))
+        entity_header = pp.Optional(generic_clause) + pp.Optional(port_clause)
+        entity_declarative_item = pp.Or((use_clause, attribute_specification, constant_declaration))
+        entity_declaration = (pp.Suppress(pp.CaselessKeyword("entity")) + identifier + pp.Suppress(pp.CaselessKeyword("is")) +
+                              entity_header + pp.ZeroOrMore(entity_declarative_item) +
+                              pp.Suppress(pp.CaselessKeyword("end") + pp.Optional(pp.CaselessKeyword("entity")) +
+                                          pp.Optional(identifier)) +
+                              pp.Suppress(pp.Literal(";")))
+        bsdl_file = entity_declaration + pp.StringEnd()
+
+        bsdl_file.ignore(comments)
+
+        parsed = bsdl_file.parse_string(f.read())
+        # parsed.pprint()
+        r = cls(parsed[0])
+        for item in parsed[1:]:
+            if item[0] == "generic":
+                for generic in item[1:]:
+                    assert len(generic) == 3
+                    generic = BSDLFile.Declaration(generic[0], generic[1], value=generic[2])
+                    r.generics[generic.name] = generic
+            elif item[0] == "port":
+                for port in item[1:]:
+                    if len(port) == 3:
+                        port = BSDLFile.Declaration(port[0], port[2], direction=port[1])
+                    elif len(port) == 6:
+                        port = BSDLFile.Declaration(port[0], port[2], direction=port[1],
+                                                    range_start=port[3], range_end=port[5])
+                    r.ports[port.name] = port
+            elif item[0] == "use":
+                pass
+            elif item[0] == "constant":
+                assert len(item) == 2
+                assert len(item[1]) == 3
+                constant = BSDLFile.Declaration(name=item[1][0], type_=item[1][1], value=item[1][2])
+                r.constants[constant.name] = constant
+            elif item[0] == "attribute":
+                assert len(item) >= 5
+                # TODO fix tuples
+                attribute = BSDLFile.Declaration(name=item[1], type_ = item[3], owner=item[2], value=item[4])
+                r.attributes[attribute.name] = attribute
+            else:
+                assert False
+
+        return r

ebyst-0.1.0/src/ebyst/device.py

@@ -0,0 +1,178 @@
+# Copyright (c) 2024 Sijmen Woutersen
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+import logging
+import re
+from pprint import pprint
+
+from bitarray import bitarray
+
+from .bsdl import BSDLFile
+
+SPACE = "[ \r\n\t]*"
+
+RE_OPCODE = re.compile(f"{SPACE}(?P<instruction>[A-Za-z][A-Za-z_0-9]*){SPACE}\\((?P<opcode>[01]+(,{SPACE}[01]+)*)\\){SPACE}(,)?")
+RE_CELL = re.compile(f"{SPACE}(?P<index>[0-9]+){SPACE}\\((?P<format>([^\\)\\(]*(\\([^\\)]*\\))*)*)\\)({SPACE},)?")
+
+logger = logging.getLogger(__name__)
+
+class StdLogicPattern:
+    """Bit pattern supporting std_logic values"""
+    def __init__(self, pattern):
+        for c in pattern.upper():
+            if not c in "01X": raise Exception(f"{c} not supported in bit pattern")
+        self.pattern = pattern.upper()
+
+    def __eq__(self, other):
+        if len(self.pattern) != len(other): return False
+        for c1, c2 in zip(self.pattern, other):
+            if c1 != "X" and int(c1) != int(c2): return False
+        return True
+
+    def __str__(self):
+        return f"StdLogicPattern('{self.pattern}')"
+
+    def to_bitarray(self):
+        return bitarray(self.pattern.replace("X", "0"))
+
+class Cell:
+    """Represents a boundary scan cell"""
+    def __init__(self, num, cell, port, function, safe, ctl_cell=None, out_dis_ctl=None, out_dis_val=None):
+        self.num = num
+        self.cell = cell
+        self.port = port
+        self.function = function
+        self.safe = safe
+        self.ctl_cell = int(ctl_cell) if not ctl_cell is None else None
+        self.out_dis_ctl = int(out_dis_ctl) if not out_dis_ctl is None else None
+        self.out_dis_val = out_dis_val
+        self.in_value = None
+        self.out_value = 0
+
+        self.set_safe()
+
+    def set_safe(self):
+        if self.safe.upper() != 'X':
+            self.out_value = int(self.safe)
+
+    def __repr__(self):
+        return f"{self.cell} @ {self.num}"
+
+    @classmethod
+    def parse(cls, num, parameters):
+        return cls(num, *[p.strip() for p in parameters.split(",")])
+
+class Pin:
+    """Represents a pin with control & data cell"""
+    def __init__(self, name, data_cell, control_cell):
+        self.name = name
+        self.data_cell = data_cell
+        self.control_cell = control_cell
+
+    def output_enabled(self):
+        if self.data_cell.cell != "BC_7" or self.control_cell.cell != "BC_2": raise Exception("Not supported")
+        return self.control_cell.out_value != self.data_cell.out_dis_ctl
+    
+    def output_enable(self, enable=True):
+        if self.data_cell.cell != "BC_7" or self.control_cell.cell != "BC_2": raise Exception("Not supported")
+        if enable:
+            self.control_cell.out_value = [1, 0][self.data_cell.out_dis_ctl]
+        else:
+            self.control_cell.out_value = self.data_cell.out_dis_ctl
+
+    def set_value(self, value):
+        if self.data_cell.cell != "BC_7" or self.control_cell.cell != "BC_2": raise Exception("Not supported")
+        self.data_cell.out_value = 1 if value else 0
+
+    def get_value(self):
+        if self.data_cell.cell != "BC_7" or self.control_cell.cell != "BC_2": raise Exception("Not supported")
+        return self.data_cell.out_value if self.output_enabled() else self.data_cell.in_value
+
+    def __repr__(self):
+        if self.output_enabled():
+            return f"<PIN {self.name}: output: {self.data_cell.out_value}>"
+        else:
+            return f"<PIN {self.name}: input>: {self.data_cell.in_value}>"
+
+class Device:
+    def __init__(self, irlen, idcode=None, opcodes=None, cells=[]):
+        self.irlen = irlen
+        self.idcode = idcode
+        if opcodes is None: opcodes = {'BYPASS': bitarray('1' * irlen)}
+        if not 'BYPASS' in opcodes: raise ValueError("BYPASS command is required")
+        self.opcodes = opcodes
+        self.cells = cells
+        self.pinmap = {}
+        for cell in self.cells:
+            if cell.port != "*":
+                pin = Pin(cell.port, cell, self.cells[cell.ctl_cell] if not cell.ctl_cell is None else None)
+                self.pinmap[pin.name] = pin
+
+    def update_br(self, br):
+        if len(br) != len(self.cells): raise ValueError("Invalid br length")
+        for i, v in enumerate(br):
+            self.cells[i].in_value = v
+
+    def generate_br(self):
+        r = bitarray()
+        for cell in self.cells:
+            r.append(cell.out_value)
+        return r
+
+    @staticmethod
+    def from_bsdl(fn):
+        with open(fn, "rt") as f:
+            bsdi_file = BSDLFile.parse(f)
+
+        irlen = int(bsdi_file.attributes['INSTRUCTION_LENGTH'].value)
+        idcode = StdLogicPattern(bsdi_file.attributes['IDCODE_REGISTER'].value[::-1])
+
+        opcodes = {}
+        opcode_str = bsdi_file.attributes['INSTRUCTION_OPCODE'].value
+        while True:
+            m = RE_OPCODE.match(opcode_str)
+            if m:
+                opcode = m['opcode'].split(",")
+                if len(opcode) == 1:
+                    ba = bitarray(opcode[0].strip())
+                    ba.reverse()
+                    opcodes[m['instruction'].upper()] = ba
+                else:
+                    # not supported
+                    pass
+                opcode_str = opcode_str[m.end():]
+            else:
+                break
+        if len(opcode_str) != 0: raise Exception("Invalid INSTRUCTION_OPCODE format")
+
+        brlen = int(bsdi_file.attributes['BOUNDARY_LENGTH'].value)
+
+        cells = [None] * brlen
+        cell_str = bsdi_file.attributes['BOUNDARY_REGISTER'].value.strip()
+        while True:
+            m = RE_CELL.match(cell_str)
+            if m:
+                cell = Cell.parse(int(m['index']), m['format'])
+                cells[cell.num] = cell
+                cell_str = cell_str[m.end():]
+            else:
+                break
+        if len(cell_str) != 0: raise Exception("Invalid BOUNDARY_REGISTER format")
+
+        return Device(irlen=irlen, idcode=idcode, opcodes=opcodes, cells=cells)

ebyst-0.1.0/src/ebyst/drivers/__init__.py

@@ -0,0 +1,2 @@
+from .sim import Sim, SimChain
+from .ft2232h import FT2232H

ebyst-0.1.0/src/ebyst/drivers/driver.py

@@ -0,0 +1,53 @@
+# Copyright (c) 2024 Sijmen Woutersen
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+from bitarray import bitarray
+
+class Driver:
+    def reset(self):
+        self.transmit_tms_str(bitarray('11111'))
+
+    def transfer(self, tms: int, tdi: int) -> int:
+        raise NotImplementedError()
+
+    def transmit_tms_str(self, tms_str: bitarray, tdi=0):
+        for tms in tms_str:
+            self.transfer(tms, tdi)
+    
+    def transfer_tdi_tdo_str(self, tdi_str: bitarray, first_tms=0, last_tms=0) -> bitarray:
+        r = bitarray()
+        for tdi in tdi_str[:-1]:
+            r.append(self.transfer(first_tms, tdi))
+        r.append(self.transfer(last_tms, tdi_str[-1]))
+        return r
+
+    def transmit_tdi_str(self, tdi_str: bitarray, first_tms=0, last_tms=0):
+        self.transfer_tdi_tdo_str(tdi_str, first_tms, last_tms)
+
+    def receive_tdo_str(self, n, first_tms=0, first_tdi=0, last_tms=None, last_tdi=None) -> bitarray:
+        if last_tms is None: last_tms = first_tms
+        if last_tdi is None: last_tdi = first_tdi
+        if n < 1: raise ValueError("n must be > 0")
+        if n == 1 and first_tms != last_tms: raise ValueError("last_tms must be first_tms when n == 1")
+        if n == 1 and first_tdi != last_tdi: raise ValueError("last_tdi must be first_tdi when n == 1")
+        r = bitarray()
+        for i in range(n-1):
+            r.append(self.transfer(first_tms, first_tdi))
+        r.append(self.transfer(last_tms, last_tdi))
+        return r