diff --git a/hardwarelibrary/communication/__init__.py b/hardwarelibrary/communication/__init__.py
index bc0034e..69ef712 100644
--- a/hardwarelibrary/communication/__init__.py
+++ b/hardwarelibrary/communication/__init__.py
@@ -2,7 +2,7 @@
 from .serialport import SerialPort
 from .usbport import USBPort
 from .diagnostics import USBParameters, DeviceCommand, USBDeviceDescription
-from .debugport import DebugPort
+from .debugport import DebugPort, TableDrivenDebugPort
 from .echoport import DebugEchoPort
 import usb.backend.libusb1
 import platform
diff --git a/hardwarelibrary/communication/commands.py b/hardwarelibrary/communication/commands.py
index 99cd729..f39071d 100644
--- a/hardwarelibrary/communication/commands.py
+++ b/hardwarelibrary/communication/commands.py
@@ -1,6 +1,50 @@
+"""Command classes that describe a device's communication protocol.
+
+Every PhysicalDevice can define a ``commands`` dictionary — a dict of
+Command objects that fully describes its protocol. For example, a
+Sutter micromanipulator defines MOVE, GET_POSITION, and HOME commands,
+while an Intellidrive rotation stage defines SET_REGISTER, GET_REGISTER,
+and TRAJECTORY commands.
+
+This dictionary is useful in two complementary ways:
+
+1. **Talking to a real device**: each Command knows how to build a
+   payload, send it through a port, and parse the reply. The device
+   code calls ``send()`` and reads back ``reply`` / ``matchGroups``.
+
+2. **Creating a mock debug port**: the same Command objects can be
+   passed to a ``TableDrivenDebugPort``, which reverses the roles —
+   it *receives* those commands instead of sending them, extracts the
+   parameters from the incoming bytes, and replies in the correct
+   format. This makes it trivial to write a mock port for any device:
+   just pass its ``commands`` dict and implement ``process_command()``
+   with the device-specific logic.
+
+Because both sides share the same Command definitions, the protocol is
+defined once and cannot drift between real and mock implementations.
+
+Subclasses:
+    TextCommand    — text-based protocols (e.g. "s r0x24 31\\r" → "ok\\r")
+    DataCommand    — binary protocols (e.g. struct-packed position commands)
+    MultilineTextCommand — text protocols that return multiple lines
+"""
+
 import re
+import struct
 
 class Command:
+    """Base class for all device commands.
+
+    A Command has a name and tracks send/reply state. Subclasses override
+    `send()` for the client side, and `matches()`/`extractParams()`/
+    `formatResponse()` for the mock port side.
+
+    Args:
+        name: identifier for this command (e.g. "GET_POSITION", "SET_REGISTER")
+        endPoints: tuple of (writeEndPoint, readEndPoint) for USB devices
+                   that use separate endpoints for sending and receiving
+    """
+
     def __init__(self, name:str, endPoints = (None, None)):
         self.name = name
         self.reply = None
@@ -26,22 +70,84 @@ def matchAsFloat(self, index=0):
         if self.matchGroups is not None:
             return float(self.matchGroups[index])
         return None
-    
+
     @property
     def hasError(self):
         return len(self.exceptions) != 0
 
     def send(self, port) -> bool:
+        """Send this command through a port. Subclasses must override."""
         raise NotImplementedError("Subclasses must implement the send() command")
 
+    def matches(self, inputBytes):
+        """Return True if inputBytes represents this command.
+        Base implementation always returns False."""
+        return False
+
+    def extractParams(self, inputBytes):
+        """Extract parameters from recognized input bytes.
+        Returns a dict (named params) or tuple (positional params).
+        Base implementation returns an empty tuple."""
+        return ()
+
+    def formatResponse(self, result):
+        """Convert a process_command() return value into bytes for the output buffer.
+
+        Args:
+            result: the value returned by process_command():
+                - None → returns None (no response sent)
+                - bytes/bytearray → returned as-is
+                - str → encoded to UTF-8
+                - tuple or dict → handled by subclass (template/struct formatting)
+
+        Returns:
+            bytearray to write to the output buffer, or None.
+        """
+        if result is None:
+            return None
+        elif isinstance(result, (bytes, bytearray)):
+            return bytearray(result)
+        elif isinstance(result, str):
+            return bytearray(result.encode('utf-8'))
+        return None
+
 class TextCommand(Command):
-    def __init__(self, name, text, replyPattern = None, 
-                                   alternatePattern = None, 
-                                   endPoints = (None, None)):
+    """A command that communicates via text strings (UTF-8).
+
+    Used for devices with text-based protocols like "s r0x24 31\\r" → "ok\\r".
+
+    Send-side parameters (used by send()):
+        text: format string sent to the device, e.g. "g r{register}\\n"
+        replyPattern: regex to validate the device's reply
+        alternatePattern: secondary regex if replyPattern doesn't match
+
+    Recognition-side parameters (used by matches/extractParams/formatResponse):
+        matchPattern: regex to recognize incoming bytes in a mock port.
+                      Use named groups for readable code:
+                      r'g r(?P<register>0x[0-9a-fA-F]+)[\\r\\n]'
+                      If None, an auto-derived pattern from `text` is used.
+        responseTemplate: format string for the mock response, e.g. "v {value}\\r".
+                          Filled with named (dict) or positional (tuple) params
+                          returned by process_command().
+
+    Example:
+        TextCommand(name="GET_REGISTER", text="g r{register}\\n",
+                    matchPattern=r'g r(?P<register>0x[0-9a-fA-F]+)[\\r\\n]',
+                    replyPattern=r'v\\s(-?\\d+)',
+                    responseTemplate="v {value}\\r")
+    """
+
+    def __init__(self, name, text, replyPattern = None,
+                                   alternatePattern = None,
+                                   endPoints = (None, None),
+                                   matchPattern = None,
+                                   responseTemplate = None):
         Command.__init__(self, name, endPoints=endPoints)
         self.text : str = text
         self.replyPattern: str = replyPattern
         self.alternatePattern: str = alternatePattern
+        self.matchPattern: str = matchPattern
+        self.responseTemplate: str = responseTemplate
 
     @property
     def payload(self):
@@ -54,6 +160,60 @@ def numberOfArguments(self):
             return 0
         return len(match.groups())
 
+    @property
+    def _autoMatchPattern(self):
+        """Derive a regex from the text format string by replacing {…}
+        placeholders with (.+?) capture groups."""
+        parts = re.split(r'\{[^}]*\}', self.text)
+        escaped = [re.escape(p) for p in parts]
+        return '(.+?)'.join(escaped)
+
+    @property
+    def effectiveMatchPattern(self):
+        """Return the explicit matchPattern if set, otherwise the auto-derived one."""
+        if self.matchPattern is not None:
+            return self.matchPattern
+        return self._autoMatchPattern
+
+    def matches(self, inputBytes):
+        """Return True if inputBytes matches this text command's pattern."""
+        try:
+            inputStr = inputBytes.decode('utf-8', errors='replace')
+        except Exception:
+            return False
+        return re.match(self.effectiveMatchPattern, inputStr) is not None
+
+    def extractParams(self, inputBytes):
+        """Extract parameters from the input bytes using the match pattern.
+
+        Returns a dict if the pattern uses named groups (?P<name>...),
+        otherwise a tuple of positional groups."""
+        try:
+            inputStr = inputBytes.decode('utf-8', errors='replace')
+        except Exception:
+            return ()
+        match = re.match(self.effectiveMatchPattern, inputStr)
+        if match:
+            if match.groupdict():
+                return match.groupdict()
+            return match.groups()
+        return ()
+
+    def formatResponse(self, result):
+        """Format a mock response using the responseTemplate.
+
+        - dict result → template.format(**result), e.g. {"value": "42"} → "v 42\\r"
+        - tuple result → template.format(*result), e.g. ("42",) → "v 42\\r"
+        - other types → delegated to base class (bytes/str as-is, None → None)
+        """
+        if isinstance(result, dict) and self.responseTemplate is not None:
+            formatted = self.responseTemplate.format(**result)
+            return bytearray(formatted.encode('utf-8'))
+        if isinstance(result, tuple) and self.responseTemplate is not None:
+            formatted = self.responseTemplate.format(*result)
+            return bytearray(formatted.encode('utf-8'))
+        return super().formatResponse(result)
+
     def send(self, port, params=None) -> bool:
         try:
             if params is not None:
@@ -85,6 +245,17 @@ def send(self, port, params=None) -> bool:
 
 
 class MultilineTextCommand(Command):
+    """A text command that expects a multi-line reply.
+
+    The reply is read either a fixed number of times (lineCount > 1) or
+    until a line matches lastLinePattern. Each line is matched against
+    replyPattern and the results are collected into lists.
+
+    Args:
+        lineCount: number of reply lines to read (if > 1)
+        lastLinePattern: regex that signals the final line (alternative to lineCount)
+    """
+
     def __init__(self, name, text,
                  replyPattern=None,
                  alternatePattern=None,
@@ -154,17 +325,107 @@ def send(self, port, params=None) -> bool:
 
 
 class DataCommand(Command):
-    def __init__(self, name, data, replyHexRegex = None, replyDataLength = 0, unpackingMask = None, endPoints = (None, None)):
+    """A command that communicates via binary data (struct-packed bytes).
+
+    Used for devices with binary protocols like the Sutter micromanipulator
+    where commands are single-byte prefixes followed by packed integers.
+
+    Send-side parameters (used by send()):
+        data: raw bytes to send to the device
+        replyDataLength: number of bytes to read back
+        unpackingMask: struct format to unpack the reply
+
+    Recognition-side parameters (used by matches/extractParams/formatResponse):
+        prefix: byte(s) that identify this command in incoming data.
+                Matched case-insensitively. If None, derived from data[0:1].
+        requestFormat: struct format to unpack incoming request parameters.
+                       Padding bytes (x) are skipped automatically by struct.
+        requestFields: tuple of field names for the unpacked values.
+                       When set, extractParams() returns a dict:
+                       e.g. requestFields=('x','y','z') → {'x': 10, 'y': 20, 'z': 30}
+                       When None, extractParams() returns a positional tuple.
+        responseFormat: struct format to pack the mock response.
+        responseFields: tuple of field names expected in the response dict.
+                        Defines the order for struct.pack when process_command()
+                        returns a dict.
+
+    Example:
+        DataCommand(name="MOVE", prefix=b'M',
+                    requestFormat='<xlllx', requestFields=('x', 'y', 'z'),
+                    replyDataLength=1, unpackingMask='<c')
+
+        DataCommand(name="GET_POSITION", prefix=b'C',
+                    responseFormat='<clllc',
+                    responseFields=('header', 'x', 'y', 'z', 'terminator'))
+    """
+
+    def __init__(self, name, data=None, replyHexRegex = None, replyDataLength = 0, unpackingMask = None, endPoints = (None, None),
+                 prefix = None, requestFormat = None, responseFormat = None,
+                 requestFields = None, responseFields = None):
         Command.__init__(self, name, endPoints=endPoints)
         self.data : bytearray = data
         self.replyHexRegex: str = replyHexRegex
         self.replyDataLength: int = replyDataLength
         self.unpackingMask:str = unpackingMask
+        self._prefix: bytes = prefix
+        self.requestFormat: str = requestFormat
+        self.responseFormat: str = responseFormat
+        self.requestFields: tuple = requestFields
+        self.responseFields: tuple = responseFields
 
     @property
     def payload(self):
         return self.data
 
+    @property
+    def effectivePrefix(self):
+        """Return the explicit prefix, or the first byte of data if not set."""
+        if self._prefix is not None:
+            return self._prefix
+        if self.data is not None and len(self.data) > 0:
+            return self.data[0:1]
+        return None
+
+    def matches(self, inputBytes):
+        """Return True if inputBytes starts with this command's prefix (case-insensitive)."""
+        prefix = self.effectivePrefix
+        if prefix is None:
+            return False
+        prefixLen = len(prefix)
+        if len(inputBytes) < prefixLen:
+            return False
+        return inputBytes[:prefixLen].upper() == prefix.upper()
+
+    def extractParams(self, inputBytes):
+        """Unpack parameters from the input bytes using requestFormat.
+
+        Returns a dict if requestFields is set (e.g. {'x': 10, 'y': 20}),
+        otherwise a positional tuple from struct.unpack."""
+        if self.requestFormat is not None:
+            unpackLen = struct.calcsize(self.requestFormat)
+            if len(inputBytes) >= unpackLen:
+                values = struct.unpack(self.requestFormat, bytes(inputBytes[:unpackLen]))
+                if self.requestFields is not None:
+                    return dict(zip(self.requestFields, values))
+                return values
+        return ()
+
+    def formatResponse(self, result):
+        """Pack a mock response using responseFormat.
+
+        - dict result + responseFields → values ordered by responseFields, then packed
+        - tuple result → packed directly with struct.pack
+        - other types → delegated to base class (bytes/str as-is, None → None)
+        """
+        if isinstance(result, dict) and self.responseFormat is not None and self.responseFields is not None:
+            values = tuple(result[f] for f in self.responseFields)
+            data = struct.pack(self.responseFormat, *values)
+            return bytearray(data)
+        if isinstance(result, tuple) and self.responseFormat is not None:
+            data = struct.pack(self.responseFormat, *result)
+            return bytearray(data)
+        return super().formatResponse(result)
+
     def send(self, port) -> bool:
         try:
             nBytes = port.writeData(data=self.data, endPoint=self.endPoints[0])
diff --git a/hardwarelibrary/communication/debugport.py b/hardwarelibrary/communication/debugport.py
index b7ebe45..401fd7c 100644
--- a/hardwarelibrary/communication/debugport.py
+++ b/hardwarelibrary/communication/debugport.py
@@ -1,82 +1,62 @@
 import time
 import random
+import struct
+import re
 
 from hardwarelibrary.communication import *
 from threading import Thread, Lock
 
-class DebugDataCommand(Command):
-    def __init__(self, name, dataHexRegex = None, unpackingMask = None, endPoints = (None, None)):
-        Command.__init__(self, name, endPoints=endPoints)
-        self.data : bytearray = data
-        self.dataHexRegex: str = dataHexRegex
-        self.unpackingMask:str = unpackingMask
-
-    def send(self, port) -> bool:
-        try:
-            self.isSent = True
-            nBytes = port.writeData(data=self.data, endPoint=self.endPoints[0])
-            if self.replyDataLength > 0:
-                self.reply = port.readData(length=self.replyDataLength)
-            elif self.replyHexRegex is not None:
-                raise NotImplementedError("DataCommand reply pattern not implemented")
-                # self.reply = port.readData(length=self.replyDataLength)
-            self.isSentSuccessfully = True
-        except Exception as err:
-            
-            self.exceptions.append(err)
-            self.isSentSuccessfully = False
-            raise(err)
-
-        return False
-
 class DebugPort(CommunicationPort):
-    def __init__(self, delay=0):
-        self.inputBuffers = [bytearray()]
-        self.outputBuffers = [bytearray()]
+    def __init__(self, delay=0, numberOfEndPoints=1):
+        self.inputBuffers = [bytearray() for _ in range(numberOfEndPoints)]
+        self.outputBuffers = [bytearray() for _ in range(numberOfEndPoints)]
         self.delay = delay
+        self.defaultTimeout = 500
         self._isOpen = False
         super(DebugPort, self).__init__()
 
     @property
     def isOpen(self):
-        return self._isOpen    
+        return self._isOpen
 
     def open(self):
         if self._isOpen:
-            raise Exception()
+            raise Exception("Port already open")
 
         self._isOpen = True
-        return
 
     def close(self):
         self._isOpen = False
-        return
 
     def bytesAvailable(self, endPoint=0):
-        return len(self.outputBuffers[endPoint])
+        endPointIndex = endPoint if endPoint is not None else 0
+        return len(self.outputBuffers[endPointIndex])
 
     def flush(self):
-        self.buffers = [bytearray(),bytearray()]
+        for i in range(len(self.inputBuffers)):
+            self.inputBuffers[i] = bytearray()
+        for i in range(len(self.outputBuffers)):
+            self.outputBuffers[i] = bytearray()
 
     def readData(self, length, endPoint=None):
-        if endPoint is None:
-            endPointIndex = 0
+        endPointIndex = endPoint if endPoint is not None else 0
 
         with self.portLock:
-            time.sleep(self.delay*random.random())
+            if self.delay > 0:
+                time.sleep(self.delay * random.random())
+
             data = bytearray()
-            for i in range(0, length):
+            for i in range(length):
                 if len(self.outputBuffers[endPointIndex]) > 0:
                     byte = self.outputBuffers[endPointIndex].pop(0)
                     data.append(byte)
                 else:
-                    raise CommunicationReadTimeout("Unable to read data")
+                    raise CommunicationReadTimeout("Unable to read {0} bytes, only {1} available".format(length, len(data)))
 
         return data
 
     def writeData(self, data, endPoint=None):
-        if endPoint is None:
-            endPointIndex = 0
+        endPointIndex = endPoint if endPoint is not None else 0
 
         with self.portLock:
             self.inputBuffers[endPointIndex].extend(data)
@@ -85,14 +65,99 @@ def writeData(self, data, endPoint=None):
 
         return len(data)
 
-    def writeToOutputBuffer(self, data, endPointIndex):
+    def writeToOutputBuffer(self, data, endPointIndex=0):
         self.outputBuffers[endPointIndex].extend(data)
 
     def processInputBuffers(self, endPointIndex):
         # We default to ECHO for simplicity
-
         inputBytes = self.inputBuffers[endPointIndex]
 
         # Do something, here we do an Echo
         self.writeToOutputBuffer(inputBytes, endPointIndex)
-        self.inputBuffers[endPointIndex] = bytearray()
\ No newline at end of file
+        self.inputBuffers[endPointIndex] = bytearray()
+
+
+class TableDrivenDebugPort(DebugPort):
+    """A mock port that recognizes incoming commands and produces responses,
+    driven by a dict of Command objects (TextCommand or DataCommand).
+
+    Each Command object knows how to recognize itself in raw input bytes
+    (matches/extractParams) and how to format a response (formatResponse).
+    This means the same Command objects used by a real device to *send*
+    commands can also be reused here to *recognize* them, eliminating
+    protocol duplication between device code and mock code.
+
+    To create a mock port for a device:
+
+    1. Pass the device's commands dict to __init__:
+
+        commands = {
+            "GET": TextCommand(name="GET", text="GET {key}\\r",
+                               matchPattern=r'GET (?P<key>\\w+)\\r',
+                               responseTemplate="VAL {value}\\r"),
+            "SET": DataCommand(name="SET", prefix=b'S',
+                               requestFormat='<xl',
+                               responseFormat='<cl'),
+        }
+        port = TableDrivenDebugPort(commands=commands)
+
+    2. Override process_command() to implement device-specific logic:
+
+        def process_command(self, name, params, endPointIndex):
+            if name == "GET":
+                key = params["key"]         # named group from matchPattern
+                return {"value": self.values[key]}  # named param for responseTemplate
+            elif name == "SET":
+                self.value = params[0]      # positional from struct.unpack
+                return b'\\x06'              # raw bytes returned as-is
+
+    The name argument matches the Command's name. The params come from
+    extractParams: a dict of named groups for TextCommand with (?P<name>...)
+    patterns, a positional tuple for anonymous groups or struct.unpack.
+    The return value is passed to formatResponse: dicts use named template
+    parameters, tuples use positional parameters, raw bytes/strings are
+    returned directly, None sends nothing.
+    """
+
+    def __init__(self, delay=0, numberOfEndPoints=1, commands=None):
+        super().__init__(delay=delay, numberOfEndPoints=numberOfEndPoints)
+        self.commands = commands if commands is not None else {}
+
+    def processInputBuffers(self, endPointIndex):
+        inputBytes = self.inputBuffers[endPointIndex]
+        if len(inputBytes) == 0:
+            return
+
+        for cmd in self.commands.values():
+            if cmd.matches(inputBytes):
+                params = cmd.extractParams(inputBytes)
+                result = self.process_command(cmd.name, params, endPointIndex)
+                response = cmd.formatResponse(result)
+                if response is not None:
+                    self.writeToOutputBuffer(response, endPointIndex)
+                self.inputBuffers[endPointIndex] = bytearray()
+                return
+
+        print("Unrecognized command: {0}".format(inputBytes))
+        self.inputBuffers[endPointIndex] = bytearray()
+
+    def process_command(self, name, params, endPointIndex):
+        """Process a recognized command and return a result.
+
+        Subclasses must override this to implement device behavior.
+
+        Args:
+            name: the Command's name (matches a key in self.commands)
+            params: extracted parameters — a dict when using named regex
+                    groups (?P<name>...), a tuple for anonymous groups or
+                    struct.unpack fields
+            endPointIndex: the endpoint the command arrived on
+
+        Returns:
+            The return value is passed to the command's formatResponse():
+            - dict: formatted using named responseTemplate parameters
+            - tuple: formatted using positional responseTemplate/responseFormat
+            - bytes/str: written to the output buffer as-is
+            - None: no response is sent
+        """
+        raise NotImplementedError("Subclasses must implement process_command")
\ No newline at end of file
diff --git a/hardwarelibrary/motion/intellidrivedevice.py b/hardwarelibrary/motion/intellidrivedevice.py
index d94a5b9..c276e00 100644
--- a/hardwarelibrary/motion/intellidrivedevice.py
+++ b/hardwarelibrary/motion/intellidrivedevice.py
@@ -1,7 +1,7 @@
 from hardwarelibrary.motion.rotationdevice import *
 from hardwarelibrary.communication.serialport import SerialPort
-from hardwarelibrary.communication.commands import DataCommand
-from hardwarelibrary.communication.debugport import DebugPort
+from hardwarelibrary.communication.commands import TextCommand
+from hardwarelibrary.communication.debugport import TableDrivenDebugPort
 
 import time
 from struct import *
@@ -21,7 +21,19 @@ class State(Enum):
 
 class IntellidriveDevice(RotationDevice):
     classIdVendor = 0x0403
-    classIdProduct = 0x6001 
+    classIdProduct = 0x6001
+
+    commands = {
+        "SET_REGISTER": TextCommand(name="SET_REGISTER", text="s r{register} {value}\r",
+                                    matchPattern=r's r(?P<register>0x[0-9a-fA-F]+) (?P<value>-?\d+)[\r\n]',
+                                    replyPattern="ok", responseTemplate="ok\r"),
+        "GET_REGISTER": TextCommand(name="GET_REGISTER", text="g r{register}\n",
+                                    matchPattern=r'g r(?P<register>0x[0-9a-fA-F]+)[\r\n]',
+                                    replyPattern=r'v\s(-?\d+)', responseTemplate="v {value}\r"),
+        "TRAJECTORY": TextCommand(name="TRAJECTORY", text="t {mode}\n",
+                                  matchPattern=r't (?P<mode>\d+)[\r\n]',
+                                  replyPattern="ok", responseTemplate="ok\r"),
+    }
 
     def __init__(self, serialNumber):
         super().__init__(serialNumber=serialNumber, idVendor=self.classIdVendor, idProduct=self.classIdProduct)
@@ -117,3 +129,23 @@ def doHome(self):
 
         if not self.isReferenced():
             raise Exception("Homing failed")
+
+    class DebugSerialPort(TableDrivenDebugPort):
+        def __init__(self):
+            super().__init__(commands=IntellidriveDevice.commands)
+            self.terminator = b'\r'
+            self.registers = {'0xc9': 0}
+
+        def process_command(self, name, params, endPointIndex):
+            if name == 'SET_REGISTER':
+                self.registers[params["register"]] = int(params["value"])
+                return "ok\r"
+            elif name == 'GET_REGISTER':
+                value = self.registers.get(params["register"], 0)
+                return {"value": str(value)}
+            elif name == 'TRAJECTORY':
+                mode = int(params["mode"])
+                if mode == 2:  # home
+                    self.registers['0xca'] = 0
+                    self.registers['0xc9'] = (1 << 12)  # referenced bit
+                return "ok\r"
diff --git a/hardwarelibrary/motion/sutterdevice.py b/hardwarelibrary/motion/sutterdevice.py
index 5625bf1..254cee8 100644
--- a/hardwarelibrary/motion/sutterdevice.py
+++ b/hardwarelibrary/motion/sutterdevice.py
@@ -4,7 +4,7 @@
 from hardwarelibrary.communication.usbport import USBPort
 from hardwarelibrary.communication.serialport import SerialPort
 from hardwarelibrary.communication.commands import DataCommand
-from hardwarelibrary.communication.debugport import DebugPort
+from hardwarelibrary.communication.debugport import TableDrivenDebugPort
 
 import re
 import time
@@ -16,6 +16,18 @@ class SutterDevice(LinearMotionDevice):
     classIdVendor = 4930
     classIdProduct = 1
 
+    commands = {
+        "MOVE": DataCommand(name="MOVE", prefix=b'M', requestFormat='<xlllx',
+                            requestFields=('x', 'y', 'z'),
+                            replyDataLength=1, unpackingMask='<c'),
+        "GET_POSITION": DataCommand(name="GET_POSITION", prefix=b'C',
+                                    replyDataLength=14, unpackingMask='<xlllx',
+                                    responseFormat='<clllc',
+                                    responseFields=('header', 'x', 'y', 'z', 'terminator')),
+        "HOME": DataCommand(name="HOME", prefix=b'H',
+                            replyDataLength=1, unpackingMask='<c'),
+    }
+
     def __init__(self, serialNumber: str = None):
         super().__init__(serialNumber=serialNumber, idVendor=self.classIdVendor, idProduct=self.classIdProduct)
         self.port = None
@@ -143,31 +155,23 @@ def work(self):
             raise Exception(f"Expected carriage return, but got {replyBytes} instead.")
 
 
-    class DebugSerialPort(DebugPort):
+    class DebugSerialPort(TableDrivenDebugPort):
         def __init__(self):
-            super().__init__()
+            super().__init__(commands=SutterDevice.commands)
             self.xSteps = 0
             self.ySteps = 0
             self.zSteps = 0
 
-        def processInputBuffers(self, endPointIndex):
-            inputBytes = self.inputBuffers[endPointIndex]
-
-            if inputBytes[0] == b'm'[0] or inputBytes[0] == b'M'[0]:
-                x,y,z = unpack("<xlllx", inputBytes)
-                self.xSteps = x
-                self.ySteps = y
-                self.zSteps = z
-                self.writeToOutputBuffer(bytearray(b'\r'), endPointIndex)
-            elif inputBytes[0] == b'h'[0] or inputBytes[0] == b'H'[0]:
-                self.xSteps = 0
-                self.ySteps = 0
-                self.zSteps = 0
-                self.writeToOutputBuffer(bytearray(b'\r'), endPointIndex)
-            elif inputBytes[0] == b'c'[0] or inputBytes[0] == b'C'[0]:
-                data = pack('<clllc', b'c', self.xSteps, self.ySteps, self.zSteps, b'\r')
-                self.writeToOutputBuffer(data, endPointIndex)
-            else:
-                print("Unrecognized command (not everything is implemented): {0}".format(inputBytes))
-
-            self.inputBuffers[endPointIndex] = bytearray()
+        def process_command(self, name, params, endPointIndex):
+            if name == 'MOVE':
+                self.xSteps = params['x']
+                self.ySteps = params['y']
+                self.zSteps = params['z']
+                return b'\r'
+            elif name == 'GET_POSITION':
+                return {'header': b'c', 'x': self.xSteps,
+                        'y': self.ySteps, 'z': self.zSteps,
+                        'terminator': b'\r'}
+            elif name == 'HOME':
+                self.xSteps = self.ySteps = self.zSteps = 0
+                return b'\r'
diff --git a/hardwarelibrary/tests/testCommandRecognition.py b/hardwarelibrary/tests/testCommandRecognition.py
new file mode 100644
index 0000000..6102569
--- /dev/null
+++ b/hardwarelibrary/tests/testCommandRecognition.py
@@ -0,0 +1,171 @@
+import env
+import unittest
+from struct import pack
+
+from hardwarelibrary.communication.commands import Command, TextCommand, DataCommand
+
+
+class TestCommandBase(unittest.TestCase):
+    def testMatchesReturnsFalse(self):
+        cmd = Command(name="base")
+        self.assertFalse(cmd.matches(b'anything'))
+
+    def testExtractParamsReturnsEmpty(self):
+        cmd = Command(name="base")
+        self.assertEqual(cmd.extractParams(b'anything'), ())
+
+    def testFormatResponseNone(self):
+        cmd = Command(name="base")
+        self.assertIsNone(cmd.formatResponse(None))
+
+    def testFormatResponseBytes(self):
+        cmd = Command(name="base")
+        self.assertEqual(cmd.formatResponse(b'\x01\x02'), bytearray(b'\x01\x02'))
+
+    def testFormatResponseString(self):
+        cmd = Command(name="base")
+        self.assertEqual(cmd.formatResponse("ok\r"), bytearray(b'ok\r'))
+
+
+class TestTextCommandRecognition(unittest.TestCase):
+    def testAutoMatchPattern(self):
+        cmd = TextCommand(name="test", text="SET {0} {1}\r")
+        self.assertTrue(cmd.matches(b'SET foo 42\r'))
+
+    def testAutoMatchPatternNoMatch(self):
+        cmd = TextCommand(name="test", text="SET {0} {1}\r")
+        self.assertFalse(cmd.matches(b'GET foo\r'))
+
+    def testExplicitMatchPattern(self):
+        cmd = TextCommand(name="test", text="s r{0}\r",
+                          matchPattern=r's r(0x[0-9a-fA-F]+)[\r\n]')
+        self.assertTrue(cmd.matches(b's r0xFF\r'))
+        self.assertTrue(cmd.matches(b's r0xFF\n'))
+
+    def testExtractParams(self):
+        cmd = TextCommand(name="test", text="SET {0} {1}\r")
+        params = cmd.extractParams(b'SET foo 42\r')
+        self.assertEqual(params, ('foo', '42'))
+
+    def testExtractParamsExplicitPattern(self):
+        cmd = TextCommand(name="test", text="g r{0}\n",
+                          matchPattern=r'g r(0x[0-9a-fA-F]+)[\r\n]')
+        params = cmd.extractParams(b'g r0xc9\n')
+        self.assertEqual(params, ('0xc9',))
+
+    def testFormatResponseWithTemplate(self):
+        cmd = TextCommand(name="test", text="g r{0}\n",
+                          responseTemplate="v {0}\r")
+        result = cmd.formatResponse(("42",))
+        self.assertEqual(result, bytearray(b'v 42\r'))
+
+    def testFormatResponseStringFallback(self):
+        cmd = TextCommand(name="test", text="cmd\r")
+        result = cmd.formatResponse("ok\r")
+        self.assertEqual(result, bytearray(b'ok\r'))
+
+    def testFormatResponseNone(self):
+        cmd = TextCommand(name="test", text="cmd\r")
+        self.assertIsNone(cmd.formatResponse(None))
+
+    def testNamedGroupExtractParams(self):
+        cmd = TextCommand(name="test", text="SET {key} {value}\r",
+                          matchPattern=r'SET (?P<key>\w+) (?P<value>-?\d+)\r')
+        params = cmd.extractParams(b'SET foo 42\r')
+        self.assertIsInstance(params, dict)
+        self.assertEqual(params["key"], "foo")
+        self.assertEqual(params["value"], "42")
+
+    def testNamedGroupFormatResponse(self):
+        cmd = TextCommand(name="test", text="GET {key}\r",
+                          matchPattern=r'GET (?P<key>\w+)\r',
+                          responseTemplate="VAL {value}\r")
+        result = cmd.formatResponse({"value": "99"})
+        self.assertEqual(result, bytearray(b'VAL 99\r'))
+
+    def testEffectiveMatchPatternUsesExplicit(self):
+        cmd = TextCommand(name="test", text="SET {0}\r",
+                          matchPattern=r'SET (\w+)\r')
+        self.assertEqual(cmd.effectiveMatchPattern, r'SET (\w+)\r')
+
+    def testEffectiveMatchPatternUsesAuto(self):
+        cmd = TextCommand(name="test", text="SET {0}\r")
+        self.assertEqual(cmd.effectiveMatchPattern, cmd._autoMatchPattern)
+
+
+class TestDataCommandRecognition(unittest.TestCase):
+    def testMatchesByPrefix(self):
+        cmd = DataCommand(name="test", prefix=b'M')
+        self.assertTrue(cmd.matches(b'M\x01\x02'))
+
+    def testMatchesCaseInsensitive(self):
+        cmd = DataCommand(name="test", prefix=b'M')
+        self.assertTrue(cmd.matches(b'm\x01\x02'))
+
+    def testPrefixDerivedFromData(self):
+        cmd = DataCommand(name="test", data=b'C\r')
+        self.assertTrue(cmd.matches(b'C'))
+        self.assertTrue(cmd.matches(b'c'))
+
+    def testNoMatchWrongPrefix(self):
+        cmd = DataCommand(name="test", prefix=b'M')
+        self.assertFalse(cmd.matches(b'G\x01'))
+
+    def testExtractParamsWithFormat(self):
+        cmd = DataCommand(name="test", prefix=b'S', requestFormat='<xl')
+        payload = pack('<cl', b'S', 42)
+        params = cmd.extractParams(payload)
+        self.assertEqual(params, (42,))
+
+    def testExtractParamsNoFormat(self):
+        cmd = DataCommand(name="test", prefix=b'G')
+        self.assertEqual(cmd.extractParams(b'G'), ())
+
+    def testFormatResponseWithFormat(self):
+        cmd = DataCommand(name="test", prefix=b'G', responseFormat='<cl')
+        result = cmd.formatResponse((b'g', 99))
+        expected = bytearray(pack('<cl', b'g', 99))
+        self.assertEqual(result, expected)
+
+    def testFormatResponseBytesFallback(self):
+        cmd = DataCommand(name="test", prefix=b'H')
+        result = cmd.formatResponse(b'\r')
+        self.assertEqual(result, bytearray(b'\r'))
+
+    def testFormatResponseNone(self):
+        cmd = DataCommand(name="test", prefix=b'H')
+        self.assertIsNone(cmd.formatResponse(None))
+
+    def testEffectivePrefixExplicit(self):
+        cmd = DataCommand(name="test", data=b'C\r', prefix=b'X')
+        self.assertEqual(cmd.effectivePrefix, b'X')
+
+    def testEffectivePrefixFromData(self):
+        cmd = DataCommand(name="test", data=b'C\r')
+        self.assertEqual(cmd.effectivePrefix, b'C')
+
+    def testNoDataNoPrefix(self):
+        cmd = DataCommand(name="test")
+        self.assertIsNone(cmd.effectivePrefix)
+        self.assertFalse(cmd.matches(b'anything'))
+
+    def testNamedFieldExtractParams(self):
+        cmd = DataCommand(name="test", prefix=b'M', requestFormat='<xlllx',
+                          requestFields=('x', 'y', 'z'))
+        payload = pack('<clllc', b'M', 10, 20, 30, b'\r')
+        params = cmd.extractParams(payload)
+        self.assertIsInstance(params, dict)
+        self.assertEqual(params['x'], 10)
+        self.assertEqual(params['y'], 20)
+        self.assertEqual(params['z'], 30)
+
+    def testNamedFieldFormatResponse(self):
+        cmd = DataCommand(name="test", prefix=b'G', responseFormat='<cl',
+                          responseFields=('tag', 'value'))
+        result = cmd.formatResponse({'tag': b'g', 'value': 99})
+        expected = bytearray(pack('<cl', b'g', 99))
+        self.assertEqual(result, expected)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/hardwarelibrary/tests/testIntellidrive.py b/hardwarelibrary/tests/testIntellidrive.py
index 00eeeb4..d06c101 100644
--- a/hardwarelibrary/tests/testIntellidrive.py
+++ b/hardwarelibrary/tests/testIntellidrive.py
@@ -129,6 +129,56 @@ def testHomeWithCommands(self):
         self.assertFalse( status & (1 << 14) )
         port.close()
 
+class TestIntellidriveDebugDevice(unittest.TestCase):
+    def setUp(self):
+        self.device = IntellidriveDevice(serialNumber="debug")
+        self.device.initializeDevice()
+
+    def tearDown(self):
+        self.device.shutdownDevice()
+        self.device = None
+
+    def testDeviceInitializes(self):
+        self.assertIsNotNone(self.device)
+        self.assertEqual(self.device.internalState.name, 'ready')
+
+    def testDeviceHome(self):
+        self.device.home()
+        orientation = self.device.orientation()
+        self.assertAlmostEqual(orientation, 0, places=2)
+
+    def testDeviceMove(self):
+        angle = 90
+        self.device.moveTo(angle)
+        orientation = self.device.orientation()
+        self.assertAlmostEqual(orientation, angle, places=0)
+
+    def testDeviceMoveToZero(self):
+        self.device.moveTo(180)
+        self.device.moveTo(0)
+        orientation = self.device.orientation()
+        self.assertAlmostEqual(orientation, 0, places=2)
+
+    def testDeviceOrientation(self):
+        orientation = self.device.orientation()
+        self.assertIsNotNone(orientation)
+        self.assertAlmostEqual(orientation, 0, places=2)
+
+    def testRegistersSetDuringInit(self):
+        port = self.device.port
+        self.assertEqual(port.registers.get('0x24'), 31)
+        self.assertEqual(port.registers.get('0xc2'), 514)
+
+    def testIsReferenced(self):
+        self.assertTrue(self.device.isReferenced())
+
+    def testIsNotMoving(self):
+        self.assertFalse(self.device.isMoving())
+
+    def testIsNotHoming(self):
+        self.assertFalse(self.device.isHoming())
+
+
 class TestIntellidrivePhysicalDevice(unittest.TestCase):
     def setUp(self):
         try:
diff --git a/hardwarelibrary/tests/testTableDrivenDebugPort.py b/hardwarelibrary/tests/testTableDrivenDebugPort.py
new file mode 100644
index 0000000..546569e
--- /dev/null
+++ b/hardwarelibrary/tests/testTableDrivenDebugPort.py
@@ -0,0 +1,194 @@
+import env
+import unittest
+from struct import pack, unpack
+
+from hardwarelibrary.communication.debugport import TableDrivenDebugPort
+from hardwarelibrary.communication.commands import DataCommand, TextCommand
+
+
+class BinaryFixture(TableDrivenDebugPort):
+    def __init__(self):
+        super().__init__(commands={
+            'set': DataCommand(name='set', prefix=b'S', requestFormat='<xl'),
+            'get': DataCommand(name='get', prefix=b'G', responseFormat='<cl'),
+        })
+        self.value = 0
+
+    def process_command(self, name, params, endPointIndex):
+        if name == 'set':
+            self.value = params[0]
+            return b'\r'
+        elif name == 'get':
+            return (b'g', self.value)
+
+
+class TextFixture(TableDrivenDebugPort):
+    def __init__(self):
+        super().__init__(commands={
+            'set': TextCommand(name='set', text='SET {0} {1}\r',
+                               matchPattern=r'SET (\w+) (-?\d+)\r'),
+            'get': TextCommand(name='get', text='GET {0}\r',
+                               matchPattern=r'GET (\w+)\r',
+                               responseTemplate='VAL {0}\r'),
+        })
+        self.registers = {}
+
+    def process_command(self, name, params, endPointIndex):
+        if name == 'set':
+            key, value = params
+            self.registers[key] = int(value)
+            return "OK\r"
+        elif name == 'get':
+            key = params[0]
+            return (str(self.registers.get(key, 0)),)
+
+
+class MixedFixture(TableDrivenDebugPort):
+    def __init__(self):
+        super().__init__(commands={
+            'bin_set': DataCommand(name='bin_set', prefix=b'\x01', requestFormat='<xl'),
+            'text_get': TextCommand(name='text_get', text='GET\r',
+                                    matchPattern=r'GET\r'),
+        })
+        self.state = 0
+
+    def process_command(self, name, params, endPointIndex):
+        if name == 'bin_set':
+            self.state = params[0]
+            return b'\x06'
+        elif name == 'text_get':
+            return "V {}\r".format(self.state)
+
+
+class TestBinaryDispatch(unittest.TestCase):
+    def setUp(self):
+        self.port = BinaryFixture()
+        self.port.open()
+
+    def tearDown(self):
+        self.port.close()
+
+    def testSetCommand(self):
+        payload = pack('<cl', b'S', 42)
+        self.port.writeData(payload)
+        self.assertEqual(self.port.readData(1), b'\r')
+        self.assertEqual(self.port.value, 42)
+
+    def testGetCommand(self):
+        self.port.value = 99
+        self.port.writeData(b'G')
+        data = self.port.readData(5)
+        tag, val = unpack('<cl', data)
+        self.assertEqual(tag, b'g')
+        self.assertEqual(val, 99)
+
+    def testSetThenGet(self):
+        payload = pack('<cl', b'S', 123)
+        self.port.writeData(payload)
+        self.port.readData(1)
+
+        self.port.writeData(b'g')
+        data = self.port.readData(5)
+        _, val = unpack('<cl', data)
+        self.assertEqual(val, 123)
+
+    def testCaseInsensitivePrefix(self):
+        payload = pack('<cl', b's', 7)
+        self.port.writeData(payload)
+        self.assertEqual(self.port.readData(1), b'\r')
+        self.assertEqual(self.port.value, 7)
+
+
+class TestTextDispatch(unittest.TestCase):
+    def setUp(self):
+        self.port = TextFixture()
+        self.port.open()
+
+    def tearDown(self):
+        self.port.close()
+
+    def testSetCommand(self):
+        self.port.writeData(b'SET foo 42\r')
+        reply = self.port.readData(3)
+        self.assertEqual(reply, b'OK\r')
+        self.assertEqual(self.port.registers['foo'], 42)
+
+    def testGetCommand(self):
+        self.port.registers['bar'] = 99
+        self.port.writeData(b'GET bar\r')
+        reply = self.port.readData(7)
+        self.assertEqual(reply, b'VAL 99\r')
+
+    def testSetThenGet(self):
+        self.port.writeData(b'SET x 55\r')
+        self.port.readData(3)
+
+        self.port.writeData(b'GET x\r')
+        reply = self.port.readData(7)
+        self.assertEqual(reply, b'VAL 55\r')
+
+    def testNegativeValue(self):
+        self.port.writeData(b'SET neg -10\r')
+        reply = self.port.readData(3)
+        self.assertEqual(reply, b'OK\r')
+        self.assertEqual(self.port.registers['neg'], -10)
+
+
+class TestMixedDispatch(unittest.TestCase):
+    def setUp(self):
+        self.port = MixedFixture()
+        self.port.open()
+
+    def tearDown(self):
+        self.port.close()
+
+    def testBinaryThenText(self):
+        payload = pack('<cl', b'\x01', 77)
+        self.port.writeData(payload)
+        self.assertEqual(self.port.readData(1), b'\x06')
+
+        self.port.writeData(b'GET\r')
+        reply = self.port.readData(5)
+        self.assertEqual(reply, b'V 77\r')
+
+    def testBinaryPreferredOverText(self):
+        """Binary commands are checked first."""
+        payload = pack('<cl', b'\x01', 1)
+        self.port.writeData(payload)
+        self.assertEqual(self.port.readData(1), b'\x06')
+
+
+class TestUnrecognizedCommand(unittest.TestCase):
+    def setUp(self):
+        self.port = BinaryFixture()
+        self.port.open()
+
+    def tearDown(self):
+        self.port.close()
+
+    def testUnrecognizedProducesNoOutput(self):
+        self.port.writeData(b'Z')
+        self.assertEqual(self.port.bytesAvailable(), 0)
+
+
+class TestNoneResponse(unittest.TestCase):
+    """When process_command returns None, no auto-response is written."""
+
+    def setUp(self):
+        port = TableDrivenDebugPort(commands={
+            'silent': DataCommand(name='silent', prefix=b'X'),
+        })
+        port.process_command = lambda name, params, ep: None
+        self.port = port
+        self.port.open()
+
+    def tearDown(self):
+        self.port.close()
+
+    def testNoneResponseWritesNothing(self):
+        self.port.writeData(b'X')
+        self.assertEqual(self.port.bytesAvailable(), 0)
+
+
+if __name__ == '__main__':
+    unittest.main()