diff --git a/artiq/devices/thorlabs_tcube/__init__.py b/artiq/devices/thorlabs_tcube/__init__.py
deleted file mode 100644
index e69de29bb..000000000
diff --git a/artiq/devices/thorlabs_tcube/driver.py b/artiq/devices/thorlabs_tcube/driver.py
deleted file mode 100644
index 51ac2643b..000000000
--- a/artiq/devices/thorlabs_tcube/driver.py
+++ /dev/null
@@ -1,1486 +0,0 @@
-from enum import Enum
-import logging
-import struct as st
-import asyncio
-
-import asyncserial
-
-
-logger = logging.getLogger(__name__)
-
-
-class MGMSG(Enum):
-    HW_DISCONNECT = 0x0002
-    HW_REQ_INFO = 0x0005
-    HW_GET_INFO = 0x0006
-    HW_START_UPDATEMSGS = 0x0011
-    HW_STOP_UPDATEMSGS = 0x0012
-    HUB_REQ_BAYUSED = 0x0065
-    HUB_GET_BAYUSED = 0x0066
-    HW_RESPONSE = 0x0080
-    HW_RICHRESPONSE = 0x0081
-    MOD_SET_CHANENABLESTATE = 0x0210
-    MOD_REQ_CHANENABLESTATE = 0x0211
-    MOD_GET_CHANENABLESTATE = 0x0212
-    MOD_IDENTIFY = 0x0223
-    MOT_SET_ENCCOUNTER = 0x0409
-    MOT_REQ_ENCCOUNTER = 0x040A
-    MOT_GET_ENCCOUNTER = 0x040B
-    MOT_SET_POSCOUNTER = 0x0410
-    MOT_REQ_POSCOUNTER = 0x0411
-    MOT_GET_POSCOUNTER = 0x0412
-    MOT_SET_VELPARAMS = 0x0413
-    MOT_REQ_VELPARAMS = 0x0414
-    MOT_GET_VELPARAMS = 0x0415
-    MOT_SET_JOGPARAMS = 0x0416
-    MOT_REQ_JOGPARAMS = 0x0417
-    MOT_GET_JOGPARAMS = 0x0418
-    MOT_SET_LIMSWITCHPARAMS = 0x0423
-    MOT_REQ_LIMSWITCHPARAMS = 0x0424
-    MOT_GET_LIMSWITCHPARAMS = 0x0425
-    MOT_REQ_STATUSBITS = 0x0429
-    MOT_GET_STATUSBITS = 0x042A
-    MOT_SET_GENMOVEPARAMS = 0x043A
-    MOT_REQ_GENMOVEPARAMS = 0x043B
-    MOT_GET_GENMOVEPARAMS = 0x043C
-    MOT_SET_HOMEPARAMS = 0x0440
-    MOT_REQ_HOMEPARAMS = 0x0441
-    MOT_GET_HOMEPARAMS = 0x0442
-    MOT_MOVE_HOME = 0x0443
-    MOT_MOVE_HOMED = 0x0444
-    MOT_SET_MOVERELPARAMS = 0x0445
-    MOT_REQ_MOVERELPARAMS = 0x0446
-    MOT_GET_MOVERELPARAMS = 0x0447
-    MOT_MOVE_RELATIVE = 0x0448
-    MOT_SET_MOVEABSPARAMS = 0x0450
-    MOT_REQ_MOVEABSPARAMS = 0x0451
-    MOT_GET_MOVEABSPARAMS = 0x0452
-    MOT_MOVE_ABSOLUTE = 0x0453
-    MOT_MOVE_VELOCITY = 0x0457
-    MOT_MOVE_COMPLETED = 0x0464
-    MOT_MOVE_STOP = 0x0465
-    MOT_MOVE_STOPPED = 0x0466
-    MOT_MOVE_JOG = 0x046A
-    MOT_SUSPEND_ENDOFMOVEMSGS = 0x046B
-    MOT_RESUME_ENDOFMOVEMSGS = 0x046C
-    MOT_REQ_DCSTATUSUPDATE = 0x0490
-    MOT_GET_DCSTATUSUPDATE = 0x0491
-    MOT_ACK_DCSTATUSUPDATE = 0x0492
-    MOT_SET_DCPIDPARAMS = 0x04A0
-    MOT_REQ_DCPIDPARAMS = 0x04A1
-    MOT_GET_DCPIDPARAMS = 0x04A2
-    MOT_SET_POTPARAMS = 0x04B0
-    MOT_REQ_POTPARAMS = 0x04B1
-    MOT_GET_POTPARAMS = 0x04B2
-    MOT_SET_AVMODES = 0x04B3
-    MOT_REQ_AVMODES = 0x04B4
-    MOT_GET_AVMODES = 0x04B5
-    MOT_SET_BUTTONPARAMS = 0x04B6
-    MOT_REQ_BUTTONPARAMS = 0x04B7
-    MOT_GET_BUTTONPARAMS = 0x04B8
-    MOT_SET_EEPROMPARAMS = 0x04B9
-    PZ_SET_POSCONTROLMODE = 0x0640
-    PZ_REQ_POSCONTROLMODE = 0x0641
-    PZ_GET_POSCONTROLMODE = 0x0642
-    PZ_SET_OUTPUTVOLTS = 0x0643
-    PZ_REQ_OUTPUTVOLTS = 0x0644
-    PZ_GET_OUTPUTVOLTS = 0x0645
-    PZ_SET_OUTPUTPOS = 0x0646
-    PZ_REQ_OUTPUTPOS = 0x0647
-    PZ_GET_OUTPUTPOS = 0x0648
-    PZ_SET_INPUTVOLTSSRC = 0x0652
-    PZ_REQ_INPUTVOLTSSRC = 0x0653
-    PZ_GET_INPUTVOLTSSRC = 0x0654
-    PZ_SET_PICONSTS = 0x0655
-    PZ_REQ_PICONSTS = 0x0656
-    PZ_GET_PICONSTS = 0x0657
-    PZ_GET_PZSTATUSUPDATE = 0x0661
-    PZ_SET_OUTPUTLUT = 0x0700
-    PZ_REQ_OUTPUTLUT = 0x0701
-    PZ_GET_OUTPUTLUT = 0x0702
-    PZ_SET_OUTPUTLUTPARAMS = 0x0703
-    PZ_REQ_OUTPUTLUTPARAMS = 0x0704
-    PZ_GET_OUTPUTLUTPARAMS = 0x0705
-    PZ_START_LUTOUTPUT = 0x0706
-    PZ_STOP_LUTOUTPUT = 0x0707
-    PZ_SET_EEPROMPARAMS = 0x07D0
-    PZ_SET_TPZ_DISPSETTINGS = 0x07D1
-    PZ_REQ_TPZ_DISPSETTINGS = 0x07D2
-    PZ_GET_TPZ_DISPSETTINGS = 0x07D3
-    PZ_SET_TPZ_IOSETTINGS = 0x07D4
-    PZ_REQ_TPZ_IOSETTINGS = 0x07D5
-    PZ_GET_TPZ_IOSETTINGS = 0x07D6
-
-
-class Direction:
-    def __init__(self, direction):
-        if direction not in (1, 2):
-            raise ValueError("Direction must be either 1 or 2")
-        self.direction = direction
-
-    def __str__(self):
-        if self.direction == 1:
-            return "forward"
-        else:
-            return "backward"
-
-
-class MsgError(Exception):
-    pass
-
-
-class Message:
-    def __init__(self, id, param1=0, param2=0, dest=0x50, src=0x01,
-                 data=None):
-        if data is not None:
-            dest |= 0x80
-        self.id = id
-        self.param1 = param1
-        self.param2 = param2
-        self.dest = dest
-        self.src = src
-        self.data = data
-
-    def __str__(self):
-        return ("<Message {} p1=0x{:02x} p2=0x{:02x} "
-                "dest=0x{:02x} src=0x{:02x}>".format(
-                    self.id, self.param1, self.param2,
-                    self.dest, self.src))
-
-    @staticmethod
-    def unpack(data):
-        id, param1, param2, dest, src = st.unpack("<HBBBB", data[:6])
-        data = data[6:]
-        if dest & 0x80:
-                if data and len(data) != param1 | (param2 << 8):
-                    raise ValueError("If data are provided, param1 and param2"
-                                     " should contain the data length")
-        else:
-                data = None
-        return Message(MGMSG(id), param1, param2, dest, src, data)
-
-    def pack(self):
-        if self.has_data:
-            return st.pack("<HHBB", self.id.value, len(self.data),
-                           self.dest | 0x80, self.src) + self.data
-        else:
-            return st.pack("<HBBBB", self.id.value,
-                           self.param1, self.param2, self.dest, self.src)
-
-    @property
-    def has_data(self):
-        return self.dest & 0x80
-
-    @property
-    def data_size(self):
-        if self.has_data:
-            return self.param1 | (self.param2 << 8)
-        else:
-            raise ValueError
-
-
-class _Tcube:
-    def __init__(self, serial_dev):
-        self.port = asyncserial.AsyncSerial(serial_dev, baudrate=115200,
-                                            rtscts=True)
-
-    def close(self):
-        """Close the device."""
-        self.port.close()
-
-    async def send(self, message):
-        logger.debug("sending: %s", message)
-        await self.port.write(message.pack())
-
-    async def recv(self):
-        header = await self.port.read_exactly(6)
-        logger.debug("received header: %s", header)
-        data = b""
-        if header[4] & 0x80:
-            (length, ) = st.unpack("<H", header[2:4])
-            data = await self.port.read_exactly(length)
-        r = Message.unpack(header + data)
-        logger.debug("receiving: %s", r)
-        return r
-
-    async def handle_message(self, msg):
-        # derived classes must implement this
-        raise NotImplementedError
-
-    async def send_request(self, msgreq_id, wait_for_msgs, param1=0, param2=0,
-                           data=None):
-        await self.send(Message(msgreq_id, param1, param2, data=data))
-        msg = None
-        while msg is None or msg.id not in wait_for_msgs:
-            msg = await self.recv()
-            await self.handle_message(msg)
-        return msg
-
-    async def set_channel_enable_state(self, activated):
-        """Enable or Disable channel 1.
-
-        :param activated: 1 to enable channel, 0 to disable it.
-        """
-
-        if activated:
-            activated = 1
-        else:
-            activated = 2
-
-        await self.send(Message(MGMSG.MOD_SET_CHANENABLESTATE, param1=1,
-                        param2=activated))
-
-    async def get_channel_enable_state(self):
-        get_msg = await self.send_request(MGMSG.MOD_REQ_CHANENABLESTATE,
-                                          [MGMSG.MOD_GET_CHANENABLESTATE], 1)
-        self.chan_enabled = get_msg.param2
-        if self.chan_enabled == 1:
-            self.chan_enabled = True
-        elif self.chan_enabled == 2:
-            self.chan_enabled = False
-        else:
-            raise MsgError("Channel state response is invalid: neither "
-                           "1 nor 2: {}".format(self.chan_enabled))
-        return self.chan_enabled
-
-    async def module_identify(self):
-        """Ask device to flash its front panel led.
-
-        Instruct hardware unit to identify itself by flashing its front panel
-        led.
-        """
-        await self.send(Message(MGMSG.MOD_IDENTIFY))
-
-    async def hardware_start_update_messages(self, update_rate):
-        """Start status updates from the embedded controller.
-
-        Status update messages contain information about the position and
-        status of the controller.
-
-        :param update_rate: Rate at which you will receive status updates
-        """
-        await self.send(Message(MGMSG.HW_START_UPDATEMSGS, param1=update_rate))
-
-    async def hardware_stop_update_messages(self):
-        """Stop status updates from the controller."""
-        await self.send(Message(MGMSG.HW_STOP_UPDATEMSGS))
-
-    async def hardware_request_information(self):
-        return await self.send_request(MGMSG.HW_REQ_INFO,
-                                       [MGMSG.HW_GET_INFO])
-
-    def is_channel_enabled(self):
-        return self.chan_enabled
-
-    async def ping(self):
-        try:
-            await self.hardware_request_information()
-        except asyncio.CancelledError:
-            raise
-        except:
-            logger.warning("ping failed", exc_info=True)
-            return False
-        return True
-
-
-class Tpz(_Tcube):
-    """Either :py:meth:`set_tpz_io_settings()<Tpz.set_tpz_io_settings>`
-    or :py:meth:`get_tpz_io_settings()<Tpz.get_tpz_io_settings>` must
-    be completed to finish initialising the driver.
-    """
-    def __init__(self, serial_dev):
-        _Tcube.__init__(self, serial_dev)
-        self.voltage_limit = None
-
-    async def handle_message(self, msg):
-        msg_id = msg.id
-        data = msg.data
-
-        if msg_id == MGMSG.HW_DISCONNECT:
-            raise MsgError("Error: Please disconnect the TPZ001")
-        elif msg_id == MGMSG.HW_RESPONSE:
-            raise MsgError("Hardware error, please disconnect "
-                           "and reconnect the TPZ001")
-        elif msg_id == MGMSG.HW_RICHRESPONSE:
-            (code, ) = st.unpack("<H", data[2:4])
-            raise MsgError("Hardware error {}: {}"
-                           .format(code,
-                                   data[4:].decode(encoding="ascii")))
-
-    async def set_position_control_mode(self, control_mode):
-        """Set the control loop mode.
-
-        When in closed-loop mode, position is maintained by a feedback signal
-        from the piezo actuator. This is only possible when using actuators
-        equipped with position sensing.
-
-        :param control_mode: 0x01 for Open Loop (no feedback).
-
-            0x02 for Closed Loop (feedback employed).
-
-            0x03 for Open Loop Smooth.
-
-            0x04 for Closed Loop Smooth.
-        """
-        await self.send(Message(MGMSG.PZ_SET_POSCONTROLMODE, param1=1,
-                                param2=control_mode))
-
-    async def get_position_control_mode(self):
-        """Get the control loop mode.
-
-        :return: Returns the control mode.
-
-            0x01 for Open Loop (no feedback).
-
-            0x02 for Closed Loop (feedback employed).
-
-            0x03 for Open Loop Smooth.
-
-            0x04 for Closed Loop Smooth.
-
-        :rtype: int
-        """
-        get_msg = await self.send_request(MGMSG.PZ_REQ_POSCONTROLMODE,
-                                          [MGMSG.PZ_GET_POSCONTROLMODE], 1)
-        return get_msg.param2
-
-    async def set_output_volts(self, voltage):
-        """Set output voltage applied to the piezo actuator.
-
-        This command is only applicable in Open Loop mode. If called when in
-        Closed Loop mode it is ignored.
-
-        :param voltage: The output voltage applied to the piezo when operating
-            in open loop mode. The voltage value must be in range
-            [0; voltage_limit]. Voltage_limit being set by the
-            :py:meth:`set_tpz_io_settings()<Tpz.set_tpz_io_settings>`
-            method between the three values 75 V, 100 V and 150 V.
-        """
-        if voltage < 0 or voltage > self.voltage_limit:
-            raise ValueError("Voltage must be in range [0;{}]"
-                             .format(self.voltage_limit))
-        volt = int(voltage*32767/self.voltage_limit)
-        payload = st.pack("<HH", 1, volt)
-        await self.send(Message(MGMSG.PZ_SET_OUTPUTVOLTS, data=payload))
-
-    async def get_output_volts(self):
-        """Get the output voltage applied to the piezo actuator.
-
-        :return: The output voltage.
-        :rtype: float
-        """
-        get_msg = await self.send_request(MGMSG.PZ_REQ_OUTPUTVOLTS,
-                                          [MGMSG.PZ_GET_OUTPUTVOLTS], 1)
-        return st.unpack("<H", get_msg.data[2:])[0]*self.voltage_limit/32767
-
-    async def set_output_position(self, position_sw):
-        """Set output position of the piezo actuator.
-
-        This command is only applicable in Closed Loop mode. If called when in
-        Open Loop mode, it is ignored. The position of the actuator is relative
-        to the datum set for the arrangement using the ZeroPosition method.
-
-        :param position_sw: The output position of the piezo relative to the
-            zero position. The voltage is set in the range [0; 32767] or
-            [0; 65535] depending on the unit. This corresponds to 0 to 100% of
-            the maximum piezo extension.
-        """
-        payload = st.pack("<HH", 1, position_sw)
-        await self.send(Message(MGMSG.PZ_SET_OUTPUTPOS, data=payload))
-
-    async def get_output_position(self):
-        """Get output position of piezo actuator.
-
-        :return: The output position of the piezo relative to the zero
-            position.
-        :rtype: int
-        """
-        get_msg = await self.send_request(MGMSG.PZ_REQ_OUTPUTPOS,
-                                          [MGMSG.PZ_GET_OUTPUTPOS], 1)
-        return st.unpack("<H", get_msg.data[2:])[0]
-
-    async def set_input_volts_source(self, volt_src):
-        """Set the input source(s) which controls the output from the HV
-        amplifier circuit (i.e. the drive to the piezo actuators).
-
-        :param volt_src: The following values are entered into the VoltSrc
-            parameter to select the various analog sources:
-
-            0x00 Software Only: Unit responds only to software inputs and the
-            HV amp output is that set using the :py:meth:`set_output_volts()
-            <Tpz.set_output_volts>` method.
-
-            0x01 External Signal: Unit sums the differential signal on the rear
-            panel EXT IN(+) and EXT IN(-) connectors with the voltage set
-            using the set_outputvolts method.
-
-            0x02 Potentiometer: The HV amp output is controlled by a
-            potentiometer input (either on the control panel, or connected
-            to the rear panel User I/O D-type connector) summed with the
-            voltage set using the set_outputvolts method.
-
-            The values can be bitwise or'ed to sum the software source with
-            either or both of the other source options.
-        """
-        payload = st.pack("<HH", 1, volt_src)
-        await self.send(Message(MGMSG.PZ_SET_INPUTVOLTSSRC, data=payload))
-
-    async def get_input_volts_source(self):
-        """Get the input source(s) which controls the output from the HV
-        amplifier circuit.
-
-        :return: Value which selects the various analog sources, cf.
-            :py:meth:`set_input_volts_source()<Tpz.set_input_volts_source>`
-            method docstring for meaning of bits.
-        :rtype: int
-        """
-        get_msg = await self.send_request(MGMSG.PZ_REQ_INPUTVOLTSSRC,
-                                          [MGMSG.PZ_GET_INPUTVOLTSSRC], 1)
-        return st.unpack("<H", get_msg.data[2:])[0]
-
-    async def set_pi_constants(self, prop_const, int_const):
-        """Set the proportional and integration feedback loop constants.
-
-        These parameters determine the response characteristics when operating
-        in closed loop mode.
-        The processors within the controller compare the required (demanded)
-        position with the actual position to create an error, which is then
-        passed through a digital PI-type filter. The filtered value is used to
-        develop an output voltage to drive the pizeo.
-
-        :param prop_const: Value of the proportional term in range [0; 255].
-        :param int_const: Value of the integral term in range [0; 255].
-        """
-        payload = st.pack("<HHH", 1, prop_const, int_const)
-        await self.send(Message(MGMSG.PZ_SET_PICONSTS, data=payload))
-
-    async def get_pi_constants(self):
-        """Get the proportional and integration feedback loop constants.
-
-        :return: Returns a tuple whose first element is the proportional
-            term and the second element is the integral term.
-        :rtype: a 2 int elements tuple : (int, int)
-        """
-        get_msg = await self.send_request(MGMSG.PZ_REQ_PICONSTS,
-                                          [MGMSG.PZ_GET_PICONSTS], 1)
-        return st.unpack("<HH", get_msg.data[2:])
-
-    async def set_output_lut(self, lut_index, output):
-        """Set the ouput LUT values for WGM (Waveform Generator Mode).
-
-        It is possible to use the controller in an arbitrary Waveform
-        Generator Mode (WGM). Rather than the unit outputting an adjustable
-        but static voltage or position, the WGM allows the user to define a
-        voltage or position sequence to be output, either periodically or a
-        fixed number of times, with a selectable interval between adjacent
-        samples.
-
-        This waveform generation function is particularly useful for
-        operations such as scanning over a particular area, or in any other
-        application that requires a predefined movement sequence. The waveform
-        is stored as values in an array, with a maximum of 513 samples.
-
-        The samples can have the meaning of voltage or position; if
-        open loop operation is specified when the samples are output, then
-        their meaning is voltage and vice versa, if the channel is set to
-        closed loop operation, the samples are interpreted as position values.
-
-        If the waveform to be output requires less than 513 samples, it is
-        sufficient to download the desired number of samples. This function is
-        used to load the LUT array with the required output waveform. The
-        applicable channel is specified by the Chan Ident parameter If only a
-        sub set of the array is being used (as specified by the cyclelength
-        parameter of the :py:meth:`set_output_lut_parameters()
-        <Tpz.set_output_lut_parameters>`
-        function), then only the first cyclelength values need to be set. In
-        this manner, any arbitrary voltage waveform can be programmed into the
-        LUT. Note. The LUT values are output by the system at a maximum
-        bandwidth of 7 KHz, e.g. 500 LUT values will take approximately 71 ms
-        to be clocked out.
-
-        :param lut_index: The position in the array of the value to be set (0
-            to 512 for TPZ).
-        :param output: The voltage value to be set. Values are in the range
-            [0; voltage_limit]. Voltage_limit being set with the
-            :py:meth:`set_tpz_io_settings<Tpz.set_tpz_io_settings>`
-            method.
-        """
-        volt = round(output*32767/self.voltage_limit)
-        payload = st.pack("<HHH", 1, lut_index, volt)
-        await self.send(Message(MGMSG.PZ_SET_OUTPUTLUT, data=payload))
-
-    async def get_output_lut(self):
-        """Get the ouput LUT values for WGM (Waveform Generator Mode).
-
-        :return: a tuple whose first element is the lut index and the second is
-            the voltage output value.
-        :rtype: a 2 elements tuple (int, float)
-        """
-        get_msg = await self.send_request(MGMSG.PZ_REQ_OUTPUTLUT,
-                                          [MGMSG.PZ_GET_OUTPUTLUT], 1)
-        index, output = st.unpack("<Hh", get_msg.data[2:])
-        return index, output*self.voltage_limit/32767
-
-    async def set_output_lut_parameters(self, mode, cycle_length, num_cycles,
-                                        delay_time, precycle_rest,
-                                        postcycle_rest):
-        """Set Waveform Generator Mode parameters.
-
-        It is possible to use the controller in an arbitrary Waveform
-        Generator Mode (WGM). Rather than the unit outputting an adjustable
-        but static voltage or position, the WGM allows the user to define a
-        voltage or position sequence to be output, either periodically or a
-        fixed number of times, with a selectable interval between adjacent
-        samples.
-        This waveform generation function is particularly useful for operations
-        such as scanning over a particular area, or in any other application
-        that requires a predefined movement sequence. This function is used to
-        set parameters which control the output of the LUT array.
-
-        :param mode: Specifies the ouput mode of the LUT waveform as follows:
-
-            0x01 - Output Continuous - The waveform is output continuously
-            (i.e. until a StopOPLut command is received.)
-
-            0x02 - Output Fixed - A fixed number of waveform cycles are output
-            (as specified in the num_cycles parameter).
-        :param cycle_length: Specifies how many samples will be output in each
-            cycle of the waveform. It can be set in the range [0; 512]
-            (for TPZ). It must be less than or equal to the total number of
-            samples that were loaded.
-        :param num_cycles: Specifies the number of cycles (1 to 2147483648) to
-            be output when the Mode parameter is set to fixed. If Mode is set
-            to Continuous, the num_cycles parameter is ignored. In both cases,
-            the waveform is not output until a StartOPLUT command is received.
-        :param delay_time: Specifies the delay (in sample intervals) that the
-            system waits after setting each LUT output value. By default, the
-            time the system takes to output LUT values (sampling interval) is
-            set at the maximum bandwidth possible, i.e. 4 kHz (0.25 ms) for TPZ
-            units. The delay_time parameter specifies the time interval between
-            neighbouring samples, i.e. for how long the sample will remain at
-            its present value. To increase the time between samples, set the
-            delay_time parameter to the required additional delay (1 to
-            2147483648 sample intervals). In this way, the user can stretch or
-            shrink the waveform without affecting its overall shape.
-        :param precycle_rest: In some applications, during waveform generation
-            the first and the last samples may need to be handled differently
-            from the rest of the waveform. For example, in a positioning system
-            it may be necessary to start the movement by staying at a certain
-            position for a specified length of time, then perform a movement,
-            then remain at the last position for another specified length of
-            time. This is the purpose of precycle_rest and postcycle_rest
-            parameters, i.e. they specify the length of time that the first and
-            last samples are output for, independently of the delay_time
-            parameter. The precycle_rest parameter allows a delay time to be
-            set before the system starts to clock out the LUT values. The delay
-            can be set between 0 and 2147483648 sample intervals. The system
-            then outputs the first value in the LUT until the PreCycleRest time
-            has expired.
-        :param postcycle_rest: In a similar way to precycle_rest, the
-            postcycle_rest parameter specifies the delay imposed by the system
-            after a LUT table has been output. The delay can be set between 0
-            and 2147483648 sample intervals. The system then outputs the last
-            value in the cycle until the postcycle_rest time has expired.
-        """
-        # triggering is not supported by the TPZ device
-        payload = st.pack("<HHHLLLLHLH", 1, mode, cycle_length, num_cycles,
-                          delay_time, precycle_rest, postcycle_rest,
-                          0, 0, 0)
-        await self.send(Message(MGMSG.PZ_SET_OUTPUTLUTPARAMS, data=payload))
-
-    async def get_output_lut_parameters(self):
-        """Get Waveform Generator Mode parameters.
-
-        :return: a 6 int elements tuple whose members are (mode, cycle_length,
-            num_cycles, delay_time, precycle_rest, postcycle_rest).
-        :rtype: 6 int elements tuple
-        """
-        get_msg = await self.send_request(MGMSG.PZ_REQ_OUTPUTLUTPARAMS,
-                                          [MGMSG.PZ_GET_OUTPUTLUTPARAMS], 1)
-        return st.unpack("<HHLLLL", get_msg.data[2:22])
-
-    async def start_lut_output(self):
-        """Start the voltage waveform (LUT) outputs."""
-        await self.send(Message(MGMSG.PZ_START_LUTOUTPUT, param1=1))
-
-    async def stop_lut_output(self):
-        """Stop the voltage waveform (LUT) outputs."""
-        await self.send(Message(MGMSG.PZ_STOP_LUTOUTPUT, param1=1))
-
-    async def set_eeprom_parameters(self, msg_id):
-        """Save the parameter settings for the specified message.
-
-        :param msg_id: The message ID of the message containing the parameters
-            to be saved.
-        """
-        payload = st.pack("<HH", 1, msg_id)
-        await self.send(Message(MGMSG.PZ_SET_EEPROMPARAMS, data=payload))
-
-    async def set_tpz_display_settings(self, intensity):
-        """Set the intensity of the LED display on the front of the TPZ unit.
-
-        :param intensity: The intensity is set as a value from 0 (Off) to 255
-            (brightest).
-        """
-        payload = st.pack("<H", intensity)
-        await self.send(Message(MGMSG.PZ_SET_TPZ_DISPSETTINGS, data=payload))
-
-    async def get_tpz_display_settings(self):
-        """Get the intensity of the LED display on the front of the TPZ unit.
-
-        :return: The intensity as a value from 0 (Off) to 255 (brightest).
-        :rtype: int
-        """
-        get_msg = await self.send_request(MGMSG.PZ_REQ_TPZ_DISPSETTINGS,
-                                          [MGMSG.PZ_GET_TPZ_DISPSETTINGS], 1)
-        return st.unpack("<H", get_msg.data)[0]
-
-    async def set_tpz_io_settings(self, voltage_limit, hub_analog_input):
-        """Set various I/O settings."
-
-        :param voltage_limit: The piezo actuator connected to the T-Cube has a
-            specific maximum operating voltage. This parameter sets the maximum
-            output to the value among the following ones:
-
-            75 V limit.
-
-            100 V limit.
-
-            150 V limit.
-        :param hub_analog_input: When the T-Cube piezo driver unit is used in
-            conjunction with the T-Cube Strain Gauge Reader (TSG001) on the
-            T-Cube Controller Hub (TCH001), a feedback signal can be passed
-            from the Strain Gauge Reader to the Piezo unit.
-            High precision closed loop operation is then possible using the
-            complete range of feedback-equipped piezo actuators.
-            This parameter is routed to the Piezo unit as follows:
-
-            0x01: the feedback signals run through all T-Cube bays.
-
-            0x02: the feedback signals run between adjacent pairs of T-Cube
-            bays (i.e. 1&2, 3&4, 5&6). This setting is useful when several
-            pairs of Strain Gauge/Piezo Driver cubes are being used on the same
-            hub.
-
-            0x03: the feedback signals run through the read panel SMA
-            connectors.
-        """
-        self.voltage_limit = voltage_limit
-
-        if self.voltage_limit == 75:
-            voltage_limit = 1
-        elif self.voltage_limit == 100:
-            voltage_limit = 2
-        elif self.voltage_limit == 150:
-            voltage_limit = 3
-        else:
-            raise ValueError("voltage_limit must be 75 V, 100 V or 150 V")
-
-        payload = st.pack("<HHHHH", 1, voltage_limit, hub_analog_input, 0, 0)
-        await self.send(Message(MGMSG.PZ_SET_TPZ_IOSETTINGS, data=payload))
-
-    async def get_tpz_io_settings(self):
-        """Get various I/O settings.
-
-        :return: Returns a tuple whose elements are the voltage limit and the
-            Hub analog input. Refer to :py:meth:`set_tpz_io_settings()
-            <Tpz.set_tpz_io_settings>` for
-            the meaning of those parameters.
-        :rtype: a 2 elements tuple (int, int)
-        """
-        get_msg = await self.send_request(MGMSG.PZ_REQ_TPZ_IOSETTINGS,
-                                          [MGMSG.PZ_GET_TPZ_IOSETTINGS], 1)
-        voltage_limit, hub_analog_input = st.unpack("<HH", get_msg.data[2:6])
-        if voltage_limit == 1:
-            voltage_limit = 75
-        elif voltage_limit == 2:
-            voltage_limit = 100
-        elif voltage_limit == 3:
-            voltage_limit = 150
-        else:
-            raise ValueError("Voltage limit should be in range [1; 3]")
-        self.voltage_limit = voltage_limit
-        return voltage_limit, hub_analog_input
-
-
-class Tdc(_Tcube):
-    def __init__(self, *args, **kwargs):
-        _Tcube.__init__(self, *args, **kwargs)
-        self.status_report_counter = 0
-
-    async def handle_message(self, msg):
-        msg_id = msg.id
-        data = msg.data
-
-        if msg_id == MGMSG.HW_DISCONNECT:
-            raise MsgError("Error: Please disconnect the TDC001")
-        elif msg_id == MGMSG.HW_RESPONSE:
-            raise MsgError("Hardware error, please disconnect "
-                           "and reconnect the TDC001")
-        elif msg_id == MGMSG.HW_RICHRESPONSE:
-            (code, ) = st.unpack("<H", data[2:4])
-            raise MsgError("Hardware error {}: {}"
-                           .format(code,
-                                   data[4:].decode(encoding="ascii")))
-        elif (msg_id == MGMSG.MOT_MOVE_COMPLETED or
-              msg_id == MGMSG.MOT_MOVE_STOPPED or
-              msg_id == MGMSG.MOT_GET_DCSTATUSUPDATE):
-            if self.status_report_counter == 25:
-                self.status_report_counter = 0
-                await self.send(Message(MGMSG.MOT_ACK_DCSTATUSUPDATE))
-            else:
-                self.status_report_counter += 1
-            # 'r' is a currently unused and reserved field
-            self.position, self.velocity, r, self.status = st.unpack(
-                "<LHHL", data[2:])
-
-    async def is_moving(self):
-        status_bits = await self.get_status_bits()
-        return (status_bits & 0x2F0) != 0
-
-    async def set_pot_parameters(self, zero_wnd, vel1, wnd1, vel2, wnd2, vel3,
-                                 wnd3, vel4):
-        """Set pot parameters.
-
-        :param zero_wnd: The deflection from the mid position (in ADC counts
-            0 to 127) before motion can start.
-        :param vel1: The velocity to move when between zero_wnd and wnd1.
-        :param wnd1: The deflection from the mid position (in ADC counts
-            zero_wnd to 127) to apply vel1.
-        :param vel2: The velocity to move when between wnd1 and wnd2.
-        :param wnd2: The deflection from the mid position (in ADC counts
-            wnd1 to 127) to apply vel2.
-        :param vel3: The velocity to move when between wnd2 and wnd3.
-        :param wnd3: The deflection from the mid position (in ADC counts
-            wnd2 to 127) to apply vel3.
-        :param vel4: The velocity to move when beyond wnd3.
-        """
-        payload = st.pack("<HHLHLHLHL", 1, zero_wnd, vel1, wnd1, vel2, wnd2,
-                          vel3, wnd3, vel4)
-        await self.send(Message(MGMSG.MOT_SET_POTPARAMS, data=payload))
-
-    async def get_pot_parameters(self):
-        """Get pot parameters.
-
-        :return: An 8 int tuple containing the following values: zero_wnd,
-            vel1, wnd1, vel2, wnd2, vel3, wnd3, vel4. See
-            :py:meth:`set_pot_parameters()<Tdc.set_pot_parameters>` for a
-            description of each tuple element meaning.
-        :rtype: An 8 int tuple
-        """
-        get_msg = await self.send_request(MGMSG.MOT_REQ_POTPARAMS,
-                                          [MGMSG.MOT_GET_POTPARAMS], 1)
-        return st.unpack("<HLHLHLHL", get_msg.data[2:])
-
-    async def hub_get_bay_used(self):
-        get_msg = await self.send_request(MGMSG.HUB_REQ_BAYUSED,
-                                          [MGMSG.HUB_GET_BAYUSED])
-        return get_msg.param1
-
-    async def set_position_counter(self, position):
-        """Set the "live" position count in the controller.
-
-        In general, this command is not normally used. Instead, the stage is
-        homed immediately after power-up; and after the homing process is
-        completed, the position counter is automatically updated to show the
-        actual position.
-
-        :param position: The new value of the position counter.
-        """
-        payload = st.pack("<Hl", 1, position)
-        await self.send(Message(MGMSG.MOT_SET_POSCOUNTER, data=payload))
-
-    async def get_position_counter(self):
-        """Get the "live" position count from the controller.
-
-        :return: The value of the position counter.
-        :rtype: int
-        """
-        get_msg = await self.send_request(MGMSG.MOT_REQ_POSCOUNTER,
-                                          [MGMSG.MOT_GET_POSCOUNTER], 1)
-        return st.unpack("<l", get_msg.data[2:])[0]
-
-    async def set_encoder_counter(self, encoder_count):
-        """Set encoder count in the controller.
-
-        This is only applicable to stages and actuators fitted
-        with an encoder. In general this command is not normally used.
-        Instead the device is homed at power-up.
-
-        :param encoder_count: The new value of the encoder counter.
-        """
-        payload = st.pack("<Hl", 1, encoder_count)
-        await self.send(Message(MGMSG.MOT_SET_ENCCOUNTER, data=payload))
-
-    async def get_encoder_counter(self):
-        """Get encoder count from the controller.
-
-        :return: The value of the encoder counter.
-        :rtype: int
-        """
-        get_msg = await self.send_request(MGMSG.MOT_REQ_ENCCOUNTER,
-                                          [MGMSG.MOT_GET_ENCCOUNTER], 1)
-        return st.unpack("<l", get_msg.data[2:])[0]
-
-    async def set_velocity_parameters(self, acceleration, max_velocity):
-        """Set the trapezoidal velocity parameter.
-
-        :param acceleration: The acceleration in encoder counts/sec/sec.
-        :param max_velocity: The maximum (final) velocity in counts/sec.
-        """
-        payload = st.pack("<HLLL", 1, 0, acceleration, max_velocity)
-        await self.send(Message(MGMSG.MOT_SET_VELPARAMS, data=payload))
-
-    async def get_velocity_parameters(self):
-        """Get the trapezoidal velocity parameters.
-
-        :return: A 2 int tuple: (acceleration, max_velocity).
-        :rtype: A 2 int tuple (int, int)
-        """
-        get_msg = await self.send_request(MGMSG.MOT_REQ_VELPARAMS,
-                                          [MGMSG.MOT_GET_VELPARAMS], 1)
-        return st.unpack("<LL", get_msg.data[6:])
-
-    async def set_jog_parameters(self, mode, step_size, acceleration,
-                                 max_velocity, stop_mode):
-        """Set the velocity jog parameters.
-
-        :param mode: 1 for continuous jogging, 2 for single step jogging.
-        :param step_size: The jog step size in encoder counts.
-        :param acceleration: The acceleration in encoder counts/sec/sec.
-        :param max_velocity: The maximum (final) velocity in encoder
-            counts/sec.
-        :param stop_mode: 1 for immediate (abrupt) stop, 2 for profiled stop
-            (with controlled deceleration).
-        """
-        payload = st.pack("<HHLLLLH", 1, mode, step_size, 0, acceleration,
-                          max_velocity, stop_mode)
-        await self.send(Message(MGMSG.MOT_SET_JOGPARAMS, data=payload))
-
-    async def get_jog_parameters(self):
-        """Get the velocity jog parameters.
-
-        :return: A 5 int tuple containing in this order: jog_mode,
-            step_size, acceleration, max_velocity, stop_mode
-        :rtype: A 5 int tuple.
-        """
-        get_msg = await self.send_request(MGMSG.MOT_REQ_JOGPARAMS,
-                                          [MGMSG.MOT_GET_JOGPARAMS], 1)
-        (jog_mode, step_size, _, acceleration, max_velocity,
-         stop_mode) = st.unpack("<HLLLLH", get_msg.data[2:])
-        return jog_mode, step_size, acceleration, max_velocity, stop_mode
-
-    async def set_gen_move_parameters(self, backlash_distance):
-        """Set the backlash distance.
-
-        :param backlash_distance: The value of the backlash distance,
-            which specifies the relative distance in position counts.
-        """
-        payload = st.pack("<Hl", 1, backlash_distance)
-        await self.send(Message(MGMSG.MOT_SET_GENMOVEPARAMS, data=payload))
-
-    async def get_gen_move_parameters(self):
-        """Get the backlash distance.
-
-        :return: The value of the backlash distance.
-        :rtype: int
-        """
-        get_msg = await self.send_request(MGMSG.MOT_REQ_GENMOVEPARAMS,
-                                          [MGMSG.MOT_GET_GENMOVEPARAMS], 1)
-        return st.unpack("<l", get_msg.data[2:])[0]
-
-    async def set_move_relative_parameters(self, relative_distance):
-        """Set the following relative move parameter: relative_distance.
-
-        :param relative_distance: The distance to move. This is a signed
-            integer that specifies the relative distance in position encoder
-            counts.
-        """
-        payload = st.pack("<Hl", 1, relative_distance)
-        await self.send(Message(MGMSG.MOT_SET_MOVERELPARAMS, data=payload))
-
-    async def get_move_relative_parameters(self):
-        """Get the relative distance move parameter.
-
-        :return: The relative distance move parameter.
-        :rtype: int
-        """
-        get_msg = await self.send_request(MGMSG.MOT_REQ_MOVERELPARAMS,
-                                          [MGMSG.MOT_GET_MOVERELPARAMS], 1)
-        return st.unpack("<l", get_msg.data[2:])[0]
-
-    async def set_move_absolute_parameters(self, absolute_position):
-        """Set the following absolute move parameter: absolute_position.
-
-        :param absolute_position: The absolute position to move. This is a
-            signed integer that specifies the absolute move position in encoder
-            counts.
-        """
-        payload = st.pack("<Hl", 1, absolute_position)
-        await self.send(Message(MGMSG.MOT_SET_MOVEABSPARAMS, data=payload))
-
-    async def get_move_absolute_parameters(self):
-        """Get the absolute position move parameter.
-
-        :return: The absolute position to move.
-        :rtype: int
-        """
-        get_msg = await self.send_request(MGMSG.MOT_REQ_MOVEABSPARAMS,
-                                          [MGMSG.MOT_GET_MOVEABSPARAMS], 1)
-        return st.unpack("<l", get_msg.data[2:])[0]
-
-    async def set_home_parameters(self, home_velocity):
-        """Set the homing velocity parameter.
-
-        :param home_velocity: Homing velocity.
-        """
-        payload = st.pack("<HHHLL", 1, 0, 0, home_velocity, 0)
-        await self.send(Message(MGMSG.MOT_SET_HOMEPARAMS, data=payload))
-
-    async def get_home_parameters(self):
-        """Get the homing velocity parameter.
-
-        :return: The homing velocity.
-        :rtype: int
-        """
-        get_msg = await self.send_request(MGMSG.MOT_REQ_HOMEPARAMS,
-                                          [MGMSG.MOT_GET_HOMEPARAMS], 1)
-        return st.unpack("<L", get_msg.data[6:10])[0]
-
-    async def move_home(self):
-        """Start a home move sequence.
-
-        This call is blocking until device is homed or move is stopped.
-        """
-        await self.send_request(MGMSG.MOT_MOVE_HOME,
-                                [MGMSG.MOT_MOVE_HOMED, MGMSG.MOT_MOVE_STOPPED],
-                                1)
-
-    async def set_limit_switch_parameters(self, cw_hw_limit, ccw_hw_limit):
-        """Set the limit switch parameters.
-
-        :param cw_hw_limit: The operation of clockwise hardware limit switch
-            when contact is made.
-
-            0x01 Ignore switch or switch not present.
-
-            0x02 Switch makes on contact.
-
-            0x03 Switch breaks on contact.
-
-            0x04 Switch makes on contact - only used for homes (e.g. limit
-            switched rotation stages).
-
-            0x05 Switch breaks on contact - only used for homes (e.g. limit
-            switched rotations stages).
-
-            0x06 For PMD based brushless servo controllers only - uses index
-            mark for homing.
-
-            Note. Set upper bit to swap CW and CCW limit switches in code. Both
-            CWHardLimit and CCWHardLimit structure members will have the upper
-            bit set when limit switches have been physically swapped.
-        :param ccw_hw_limit: The operation of counter clockwise hardware limit
-            switch when contact is made.
-        """
-        payload = st.pack("<HHHLLH", 1, cw_hw_limit, ccw_hw_limit, 0, 0, 0)
-        await self.send(Message(MGMSG.MOT_SET_LIMSWITCHPARAMS, data=payload))
-
-    async def get_limit_switch_parameters(self):
-        """Get the limit switch parameters.
-
-        :return: A 2 int tuple containing the following in order: cw_hw_limit,
-         ccw_hw_limit. Cf. description in
-         :py:meth:`set_limit_switch_parameters()
-         <Tdc.set_limit_switch_parameters>`
-         method.
-        :rtype: A 2 int tuple.
-        """
-        get_msg = await self.send_request(MGMSG.MOT_REQ_LIMSWITCHPARAMS,
-                                          [MGMSG.MOT_GET_LIMSWITCHPARAMS], 1)
-        return st.unpack("<HH", get_msg.data[2:6])
-
-    async def move_relative_memory(self):
-        """Start a relative move of distance in the controller's memory
-
-        The relative distance parameter used for the move will be the parameter
-        sent previously by a :py:meth:`set_move_relative_parameters()
-        <Tdc.set_move_relative_parameters>`
-        command.
-        """
-        await self.send_request(MGMSG.MOT_MOVE_RELATIVE,
-                                [MGMSG.MOT_MOVE_COMPLETED,
-                                 MGMSG.MOT_MOVE_STOPPED],
-                                1)
-
-    async def move_relative(self, relative_distance):
-        """Start a relative move
-
-        :param relative_distance: The distance to move in position encoder
-            counts.
-        """
-        payload = st.pack("<Hl", 1, relative_distance)
-        await self.send_request(MGMSG.MOT_MOVE_RELATIVE,
-                                [MGMSG.MOT_MOVE_COMPLETED,
-                                 MGMSG.MOT_MOVE_STOPPED],
-                                data=payload)
-
-    async def move_absolute_memory(self):
-        """Start an absolute move of distance in the controller's memory.
-
-        The absolute move position parameter used for the move will be the
-        parameter sent previously by a :py:meth:`set_move_absolute_parameters()
-        <Tdc.set_move_absolute_parameters>`
-        command.
-        """
-        await self.send_request(MGMSG.MOT_MOVE_ABSOLUTE,
-                                [MGMSG.MOT_MOVE_COMPLETED,
-                                 MGMSG.MOT_MOVE_STOPPED],
-                                param1=1)
-
-    async def move_absolute(self, absolute_distance):
-        """Start an absolute move.
-
-        :param absolute_distance: The distance to move. This is a signed
-            integer that specifies the absolute distance in position encoder
-            counts.
-        """
-        payload = st.pack("<Hl", 1, absolute_distance)
-        await self.send_request(MGMSG.MOT_MOVE_ABSOLUTE,
-                                [MGMSG.MOT_MOVE_COMPLETED,
-                                 MGMSG.MOT_MOVE_STOPPED],
-                                data=payload)
-
-    async def move_jog(self, direction):
-        """Start a jog move.
-
-        :param direction: The direction to jog. 1 is forward, 2 is backward.
-        """
-        await self.send_request(MGMSG.MOT_MOVE_JOG,
-                                [MGMSG.MOT_MOVE_COMPLETED,
-                                 MGMSG.MOT_MOVE_STOPPED],
-                                param1=1, param2=direction)
-
-    async def move_velocity(self, direction):
-        """Start a move.
-
-        When this method is called, the motor will move continuously in the
-        specified direction using the velocity parameter set by the
-        :py:meth:`set_move_relative_parameters()
-        <Tdc.set_move_relative_parameters>`
-        command until a :py:meth:`move_stop()<Tdc.move_stop>` command (either
-        StopImmediate or StopProfiled) is called, or a limit switch is reached.
-
-        :param direction: The direction to jog: 1 to move forward, 2 to move
-            backward.
-        """
-        await self.send(Message(MGMSG.MOT_MOVE_VELOCITY, param1=1,
-                                param2=direction))
-
-    async def move_stop(self, stop_mode):
-        """Stop any type of motor move.
-
-        Stops any of those motor move: relative, absolute, homing or move at
-        velocity.
-
-        :param stop_mode: The stop mode defines either an immediate (abrupt)
-            or profiled stop. Set this byte to 1 to stop immediately, or to 2
-            to stop in a controlled (profiled) manner.
-        """
-        if await self.is_moving():
-            await self.send_request(MGMSG.MOT_MOVE_STOP,
-                                    [MGMSG.MOT_MOVE_STOPPED,
-                                     MGMSG.MOT_MOVE_COMPLETED],
-                                    1, stop_mode)
-
-    async def set_dc_pid_parameters(self, proportional, integral, differential,
-                                    integral_limit, filter_control=0x0F):
-        """Set the position control loop parameters.
-
-        :param proportional: The proportional gain, values in range [0; 32767].
-        :param integral: The integral gain, values in range [0; 32767].
-        :param differential: The differential gain, values in range [0; 32767].
-        :param integral_limit: The integral limit parameter is used to cap the
-            value of the integrator to prevent runaway of the integral sum at
-            the output. Values are in range [0; 32767]. If set to 0, then
-            integration term in the PID loop is ignored.
-        :param filter_control: Identifies which of the above are applied by
-            setting the corresponding bit to 1. By default, all parameters are
-            applied, and this parameter is set to 0x0F (1111).
-        """
-        payload = st.pack("<HLLLLH", 1, proportional, integral,
-                          differential, integral_limit, filter_control)
-        await self.send(Message(MGMSG.MOT_SET_DCPIDPARAMS, data=payload))
-
-    async def get_dc_pid_parameters(self):
-        """Get the position control loop parameters.
-
-        :return: A 5 int tuple containing in this order:
-            proportional gain, integral gain, differential gain, integral limit
-            and filter control. Cf. :py:meth:`set_dc_pid_parameters()
-            <Tdc.set_dc_pid_parameters>`
-            for precise description.
-        :rtype: A 5 int tuple.
-        """
-        get_msg = await self.send_request(MGMSG.MOT_REQ_DCPIDPARAMS,
-                                          [MGMSG.MOT_GET_DCPIDPARAMS], 1)
-        return st.unpack("<LLLLH", get_msg.data[2:])
-
-    async def set_av_modes(self, mode_bits):
-        """Set the LED indicator modes.
-
-        The LED on the control keyboard can be configured to indicate certain
-        driver states.
-
-        :param mode_bits: Set the bit 0 will make the LED flash when the
-            'Ident' message is sent.
-            Set the bit 1 will make the LED flash when the motor reaches a
-            forward or reverse limit switch.
-            Set the bit 3 (value 8) will make the LED lit when motor is moving.
-        """
-        payload = st.pack("<HH", 1, mode_bits)
-        await self.send(Message(MGMSG.MOT_SET_AVMODES, data=payload))
-
-    async def get_av_modes(self):
-        """Get the LED indicator mode bits.
-
-        :return: The LED indicator mode bits.
-        :rtype: int
-        """
-        get_msg = self.send_request(MGMSG.MOT_REQ_AVMODES,
-                                    [MGMSG.MOT_GET_AVMODES], 1)
-        return st.unpack("<H", get_msg.data[2:])[0]
-
-    async def set_button_parameters(self, mode, position1, position2):
-        """Set button parameters.
-
-        The control keypad can be used either to jog the motor, or to perform
-        moves to absolute positions. This function is used to set the front
-        panel button functionality.
-
-        :param mode: If set to 1, the buttons are used to jog the motor. Once
-            set to this mode, the move parameters for the buttons are taken
-            from the arguments of the :py:meth:`set_jog_parameters()
-            <Tdc.set_jog_parameters>`
-            method. If set to 2, each button can be programmed with a
-            differente position value such that the controller will move the
-            motor to that position when the specific button is pressed.
-        :param position1: The position (in encoder counts) to which the motor
-            will move when the top button is pressed.
-        :param position2: The position (in encoder counts) to which the motor
-            will move when the bottom button is pressed.
-        """
-        payload = st.pack("<HHllHH", 1, mode, position1, position2,
-                          0, 0)
-        await self.send(Message(MGMSG.MOT_SET_BUTTONPARAMS, data=payload))
-
-    async def get_button_parameters(self):
-        """Get button parameters.
-
-        :return: A 3 int tuple containing in this order: button mode,
-            position1 and position2. Cf. :py:meth:`set_button_parameters()
-            <Tdc.set_button_parameters>`
-            for description.
-        :rtype: A 3 int tuple
-        """
-        get_msg = await self.send_request(MGMSG.MOT_REQ_BUTTONPARAMS,
-                                          [MGMSG.MOT_GET_BUTTONPARAMS], 1)
-        return st.unpack("<Hll", get_msg.data[2:12])
-
-    async def set_eeprom_parameters(self, msg_id):
-        """Save the parameter settings for the specified message.
-
-        :param msg_id: The message ID of the message containing the parameters
-            to be saved.
-        """
-        payload = st.pack("<HH", 1, msg_id)
-        await self.send(Message(MGMSG.MOT_SET_EEPROMPARAMS, data=payload))
-
-    async def get_dc_status_update(self):
-        """Request a status update from the motor.
-
-        This can be used instead of enabling regular updates.
-
-        :return: A 3 int tuple containing in this order: position,
-            velocity, status bits.
-        :rtype: A 3 int tuple
-        """
-        get_msg = await self.send_request(MGMSG.MOT_REQ_DCSTATUSUPDATE,
-                                          [MGMSG.MOT_GET_DCSTATUSUPDATE], 1)
-        pos, vel, _, stat = st.unpack("<LHHL", get_msg.data[2:])
-        return pos, vel, stat
-
-    async def get_status_bits(self):
-        """Request a cut down version of the status update with status bits.
-
-        :return: The motor status.
-        :rtype:
-        """
-        get_msg = await self.send_request(MGMSG.MOT_REQ_STATUSBITS,
-                                          [MGMSG.MOT_GET_STATUSBITS], 1)
-        return st.unpack("<L", get_msg.data[2:])[0]
-
-    async def suspend_end_of_move_messages(self):
-        """Disable all unsolicited "end of move" messages and error messages
-        returned by the controller.
-
-        i.e., MGMSG.MOT_MOVE_STOPPED, MGMSG.MOT_MOVE_COMPLETED,
-        MGMSGS_MOT_MOVE_HOMED
-        """
-        await self.send(Message(MGMSG.MOT_SUSPEND_ENDOFMOVEMSGS))
-
-    async def resume_end_of_move_messages(self):
-        """Resume all unsolicited "end of move" messages and error messages
-        returned by the controller.
-
-        i.e., MGMSG.MOT_MOVE_STOPPED, MGMSG.MOT_MOVE_COMPLETED,
-        MGMSG.MOT_MOVE_HOMED
-
-        The command also disables the error messages that the controller sends
-        when an error condition is detected:
-        MGMSG.HW_RESPONSE,
-        MGMSG.HW_RICHRESPONSE
-        """
-        await self.send(Message(MGMSG.MOT_RESUME_ENDOFMOVEMSGS))
-
-
-class TpzSim:
-    def __init__(self):
-        self.voltage_limit = 150
-        self.hub_analog_input = 1
-
-    def close(self):
-        pass
-
-    def module_identify(self):
-        pass
-
-    def set_position_control_mode(self, control_mode):
-        self.control_mode = control_mode
-
-    def get_position_control_mode(self):
-        return self.control_mode
-
-    def set_output_volts(self, voltage):
-        self.voltage = voltage
-
-    def get_output_volts(self):
-        return self.voltage
-
-    def set_output_position(self, position_sw):
-        self.position_sw = position_sw
-
-    def get_output_position(self):
-        return self.position_sw
-
-    def set_input_volts_source(self, volt_src):
-        self.volt_src = volt_src
-
-    def get_input_volts_source(self):
-        return self.volt_src
-
-    def set_pi_constants(self, prop_const, int_const):
-        self.prop_const = prop_const
-        self.int_const = int_const
-
-    def get_pi_constants(self):
-        return self.prop_const, self.int_const
-
-    def set_output_lut(self, lut_index, output):
-        if lut_index < 0 or lut_index > 512:
-            raise ValueError("LUT index should be in range [0;512] and not {}"
-                             .format(lut_index))
-        self.lut[lut_index] = output
-
-    def get_output_lut(self):
-        return 0, 0  # FIXME: the API description here doesn't make any sense
-
-    def set_output_lut_parameters(self, mode, cycle_length, num_cycles,
-                                  delay_time, precycle_rest, postcycle_rest):
-        self.mode = mode
-        self.cycle_length = cycle_length
-        self.num_cycles = num_cycles
-        self.delay_time = delay_time
-        self.precycle_rest = precycle_rest
-        self.postcycle_rest = postcycle_rest
-
-    def get_output_lut_parameters(self):
-        return (self.mode, self.cycle_length, self.num_cycles,
-                self.delay_time, self.precycle_rest, self.postcycle_rest)
-
-    def start_lut_output(self):
-        pass
-
-    def stop_lut_output(self):
-        pass
-
-    def set_eeprom_parameters(self, msg_id):
-        pass
-
-    def set_tpz_display_settings(self, intensity):
-        self.intensity = intensity
-
-    def get_tpz_display_settings(self):
-        return self.intensity
-
-    def set_tpz_io_settings(self, voltage_limit, hub_analog_input):
-        if voltage_limit not in [75, 100, 150]:
-            raise ValueError("voltage_limit must be 75 V, 100 V or 150 V")
-        self.voltage_limit = voltage_limit
-        self.hub_analog_input = hub_analog_input
-
-    def get_tpz_io_settings(self):
-        return self.voltage_limit, self.hub_analog_input
-
-
-class TdcSim:
-    def close(self):
-        pass
-
-    def module_identify(self):
-        pass
-
-    def set_pot_parameters(self, zero_wnd, vel1, wnd1, vel2, wnd2, vel3,
-                           wnd3, vel4):
-        self.zero_wnd = zero_wnd
-        self.vel1 = vel1
-        self.wnd1 = wnd1
-        self.vel2 = vel2
-        self.wnd2 = wnd2
-        self.vel3 = vel3
-        self.wnd3 = wnd3
-        self.vel4 = vel4
-
-    def get_pot_parameters(self):
-        return (self.zero_wnd, self.vel1, self.wnd1, self.vel2, self.wnd2,
-                self.vel3, self.wnd3, self.vel4)
-
-    def hub_get_bay_used(self):
-        return False
-
-    def set_position_counter(self, position):
-        self.position = position
-
-    def get_position_counter(self):
-        return self.position
-
-    def set_encoder_counter(self, encoder_count):
-        self.encoder_count = encoder_count
-
-    def get_encoder_counter(self):
-        return self.encoder_count
-
-    def set_velocity_parameters(self, acceleration, max_velocity):
-        self.acceleration = acceleration
-        self.max_velocity = max_velocity
-
-    def get_velocity_parameters(self):
-        return self.acceleration, self.max_velocity
-
-    def set_jog_parameters(self, mode, step_size, acceleration,
-                           max_velocity, stop_mode):
-        self.jog_mode = mode
-        self.step_size = step_size
-        self.acceleration = acceleration
-        self.max_velocity = max_velocity
-        self.stop_mode = stop_mode
-
-    def get_jog_parameters(self):
-        return (self.jog_mode, self.step_size, self.acceleration,
-                self.max_velocity, self.stop_mode)
-
-    def set_gen_move_parameters(self, backlash_distance):
-        self.backlash_distance = backlash_distance
-
-    def get_gen_move_parameters(self):
-        return self.backlash_distance
-
-    def set_move_relative_parameters(self, relative_distance):
-        self.relative_distance = relative_distance
-
-    def get_move_relative_parameters(self):
-        return self.relative_distance
-
-    def set_move_absolute_parameters(self, absolute_position):
-        self.absolute_position = absolute_position
-
-    def get_move_absolute_parameters(self):
-        return self.absolute_position
-
-    def set_home_parameters(self, home_velocity):
-        self.home_velocity = home_velocity
-
-    def get_home_parameters(self):
-        return self.home_velocity
-
-    def move_home(self):
-        pass
-
-    def set_limit_switch_parameters(self, cw_hw_limit, ccw_hw_limit):
-        self.cw_hw_limit = cw_hw_limit
-        self.ccw_hw_limit = ccw_hw_limit
-
-    def get_limit_switch_parameters(self):
-        return self.cw_hw_limit, self.ccw_hw_limit
-
-    def move_relative_memory(self):
-        pass
-
-    def move_relative(self, relative_distance):
-        pass
-
-    def move_absolute_memory(self):
-        pass
-
-    def move_absolute(self, absolute_distance):
-        pass
-
-    def move_jog(self, direction):
-        pass
-
-    def move_velocity(self, direction):
-        pass
-
-    def move_stop(self, stop_mode):
-        pass
-
-    def set_dc_pid_parameters(self, proportional, integral, differential,
-                              integral_limit, filter_control=0x0F):
-        self.proportional = proportional
-        self.integral = integral
-        self.differential = differential
-        self.integral_limit = integral_limit
-        self.filter_control = filter_control
-
-    def get_dc_pid_parameters(self):
-        return (self.proportional, self.integral, self.differential,
-                self.integral_limit, self.filter_control)
-
-    def set_av_modes(self, mode_bits):
-        self.mode_bits = mode_bits
-
-    def get_av_modes(self):
-        return self.mode_bits
-
-    def set_button_parameters(self, mode, position1, position2):
-        self.mode = mode
-        self.position1 = position1
-        self.position2 = position2
-
-    def get_button_parameters(self):
-        return self.mode, self.position1, self.position2
-
-    def set_eeprom_parameters(self, msg_id):
-        pass
-
-    def get_dc_status_update(self):
-        return 0, 0, 0x80000400  # FIXME: not implemented yet for simulation
-
-    def get_status_bits(self):
-        return 0x80000400  # FIXME: not implemented yet for simulation
-
-    def suspend_end_of_move_messages(self):
-        pass
-
-    def resume_end_of_move_messages(self):
-        pass
diff --git a/artiq/frontend/aqctl_thorlabs_tcube.py b/artiq/frontend/aqctl_thorlabs_tcube.py
deleted file mode 100755
index dea1a0d65..000000000
--- a/artiq/frontend/aqctl_thorlabs_tcube.py
+++ /dev/null
@@ -1,70 +0,0 @@
-#!/usr/bin/env python3
-
-import argparse
-import sys
-import os
-import asyncio
-
-from artiq.devices.thorlabs_tcube.driver import Tdc, Tpz, TdcSim, TpzSim
-from artiq.protocols.pc_rpc import simple_server_loop
-from artiq.tools import *
-
-
-def get_argparser():
-    parser = argparse.ArgumentParser()
-    parser.add_argument("-P", "--product", required=True,
-                        help="type of the Thorlabs T-Cube device to control: "
-                             "tdc001/tpz001")
-    parser.add_argument("-d", "--device", default=None,
-                        help="serial device. See documentation for how to "
-                             "specify a USB Serial Number.")
-    parser.add_argument("--simulation", action="store_true",
-                        help="Put the driver in simulation mode, even if "
-                             "--device is used.")
-    simple_network_args(parser, 3255)
-    add_common_args(parser)
-    return parser
-
-
-def main():
-    args = get_argparser().parse_args()
-    init_logger(args)
-
-    if os.name == "nt":
-        asyncio.set_event_loop(asyncio.ProactorEventLoop())
-
-    if not args.simulation and args.device is None:
-        print("You need to specify either --simulation or -d/--device "
-              "argument. Use --help for more information.")
-        sys.exit(1)
-
-    product = args.product.lower()
-    if args.simulation:
-        if product == "tdc001":
-            dev = TdcSim()
-        elif product == "tpz001":
-            dev = TpzSim()
-        else:
-            print("Invalid product string (-P/--product), "
-                  "choose from tdc001 or tpz001")
-            sys.exit(1)
-    else:
-        if product == "tdc001":
-            dev = Tdc(args.device)
-        elif product == "tpz001":
-            dev = Tpz(args.device)
-            loop = asyncio.get_event_loop()
-            loop.run_until_complete(dev.get_tpz_io_settings())
-        else:
-            print("Invalid product string (-P/--product), "
-                  "choose from tdc001 or tpz001")
-            sys.exit(1)
-
-    try:
-        simple_server_loop({product: dev},
-                           bind_address_from_args(args), args.port)
-    finally:
-        dev.close()
-
-if __name__ == "__main__":
-    main()
diff --git a/artiq/test/test_frontends.py b/artiq/test/test_frontends.py
index 10db9eea0..c80228294 100644
--- a/artiq/test/test_frontends.py
+++ b/artiq/test/test_frontends.py
@@ -10,7 +10,7 @@ class TestFrontends(unittest.TestCase):
         # Skip tests for GUI programs on headless CI environments.
         commands = {
             "aqctl": [
-                "corelog", "thorlabs_tcube"
+                "corelog"
             ],
             "artiq": [
                 "client", "compile", "coreanalyzer", "coremgmt", "ctlmgr",
diff --git a/artiq/test/test_thorlabs_tcube.py b/artiq/test/test_thorlabs_tcube.py
deleted file mode 100644
index b1adf6208..000000000
--- a/artiq/test/test_thorlabs_tcube.py
+++ /dev/null
@@ -1,183 +0,0 @@
-import time
-import sys
-import unittest
-
-from artiq.language.units import V
-from artiq.test.hardware_testbench import ControllerCase, GenericControllerCase
-
-
-class GenericTdcTest:
-    def test_pot_parameters(self):
-        test_vector = 1, 2, 3, 4, 5, 6, 7, 8
-        self.cont.set_pot_parameters(*test_vector)
-        self.assertEqual(test_vector, self.cont.get_pot_parameters())
-
-    def test_position_counter(self):
-        test_vector = 42
-        self.cont.set_position_counter(test_vector)
-        self.assertEqual(test_vector, self.cont.get_position_counter())
-
-    def test_encoder_counter(self):
-        test_vector = 43
-        self.cont.set_encoder_counter(test_vector)
-        self.assertEqual(test_vector, self.cont.get_encoder_counter())
-
-    def test_velocity_parameters(self):
-        test_vector = 44, 45
-        self.cont.set_velocity_parameters(*test_vector)
-        self.assertEqual(test_vector, self.cont.get_velocity_parameters())
-
-    def test_jog_parameters(self):
-        test_vector = 46, 47, 48, 49, 50
-        self.cont.set_jog_parameters(*test_vector)
-        self.assertEqual(test_vector, self.cont.get_jog_parameters())
-
-    def test_gen_move_parameters(self):
-        test_vector = 51
-        self.cont.set_gen_move_parameters(test_vector)
-        self.assertEqual(test_vector, self.cont.get_gen_move_parameters())
-
-    def test_moverelparams(self):
-        test_vector = 52
-        self.cont.set_move_relative_parameters(test_vector)
-        self.assertEqual(test_vector, self.cont.get_move_relative_parameters())
-
-    def test_move_absolute_parameters(self):
-        test_vector = 53
-        self.cont.set_move_absolute_parameters(test_vector)
-        self.assertEqual(test_vector, self.cont.get_move_absolute_parameters())
-
-    def test_home_parameters(self):
-        test_vector = 54
-        self.cont.set_home_parameters(test_vector)
-        self.assertEqual(test_vector, self.cont.get_home_parameters())
-
-    def test_limit_switch_parameters(self):
-        test_vector = 2, 1
-        self.cont.set_limit_switch_parameters(*test_vector)
-        self.assertEqual(test_vector, self.cont.get_limit_switch_parameters())
-
-    def test_dc_pid_parameters(self):
-        test_vector = 57, 58, 59, 60, 0x0f
-        self.cont.set_dc_pid_parameters(*test_vector)
-        self.assertEqual(test_vector, self.cont.get_dc_pid_parameters())
-
-    def test_av_modes(self):
-        for i in range(1):
-            for j in range(1):
-                for k in range(1):
-                    with self.subTest(i=i):
-                        with self.subTest(j=j):
-                            with self.subTest(k=k):
-                                test_vector = i << 2 + j << 1 + k
-                                self.cont.set_av_modes(test_vector)
-                                self.assertEqual(test_vector,
-                                                 self.cont.get_av_modes())
-
-    def test_button_parameters(self):
-        test_vector = 2, 3, 4
-        self.cont.set_button_parameters(*test_vector)
-        self.assertEqual(test_vector, self.cont.get_button_parameters())
-
-
-class GenericTpzTest:
-    def test_position_control_mode(self):
-        test_vector = 1
-        self.cont.set_position_control_mode(test_vector)
-        self.assertEqual(test_vector, self.cont.get_position_control_mode())
-
-    def test_ouput_volts(self):
-        for voltage in 5*V, 10*V, 15*V, \
-                round(self.cont.get_tpz_io_settings()[0])*V:
-            with self.subTest(voltage=voltage):
-                test_vector = voltage
-                self.cont.set_output_volts(test_vector)
-                time.sleep(1)  # Wait for the output voltage to converge
-                self.assertAlmostEqual(test_vector,
-                                       self.cont.get_output_volts(),
-                                       delta=0.03*V)
-
-    def test_output_position(self):
-        test_vector = 31000
-        self.cont.set_output_position(test_vector)
-        self.assertEqual(test_vector, self.cont.get_output_position())
-
-    def test_input_volts_source(self):
-        for i in range(3):
-            test_vector = i
-            self.cont.set_input_volts_source(i)
-            with self.subTest(i=i):
-                self.assertEqual(test_vector,
-                                 self.cont.get_input_volts_source())
-
-    def test_pi_constants(self):
-        test_vector = 42, 43
-        self.cont.set_pi_constants(*test_vector)
-        self.assertEqual(test_vector, self.cont.get_pi_constants())
-
-    def test_tpz_display_settings(self):
-        for intensity in 0, 10, 30, 50, 100, 150, 254:
-            with self.subTest(intensity=intensity):
-                test_vector = intensity
-                self.cont.set_tpz_display_settings(test_vector)
-                self.assertEqual(test_vector,
-                                 self.cont.get_tpz_display_settings())
-
-    def test_tpz_io_settings(self):
-        for v in 75*V, 100*V, 150*V:
-            with self.subTest(v=v):
-                test_vector = v, 1
-                self.cont.set_tpz_io_settings(*test_vector)
-                self.assertEqual(test_vector, self.cont.get_tpz_io_settings())
-
-
-class TestTdc(ControllerCase, GenericTdcTest):
-    def setUp(self):
-        ControllerCase.setUp(self)
-        self.start_controller("tdc")
-        self.cont = self.device_mgr.get("tdc")
-
-
-class TestTdcSim(GenericControllerCase, GenericTdcTest):
-    def get_device_db(self):
-        return {
-            "tdc": {
-                "type": "controller",
-                "host": "::1",
-                "port": 3255,
-                "command": (sys.executable.replace("\\", "\\\\")
-                            + " -m artiq.frontend.aqctl_thorlabs_tcube "
-                            + "-p {port} -P tdc001 --simulation")
-            }
-        }
-
-    def setUp(self):
-        GenericControllerCase.setUp(self)
-        self.start_controller("tdc")
-        self.cont = self.device_mgr.get("tdc")
-
-
-class TestTpz(ControllerCase, GenericTpzTest):
-    def setUp(self):
-        ControllerCase.setUp(self)
-        self.start_controller("tpz")
-        self.cont = self.device_mgr.get("tpz")
-
-
-class TestTpzSim(GenericControllerCase, GenericTpzTest):
-    def get_device_db(self):
-        return {
-            "tpz": {
-                "type": "controller",
-                "host": "::1",
-                "port": 3255,
-                "command": (sys.executable.replace("\\", "\\\\")
-                            + " -m artiq.frontend.aqctl_thorlabs_tcube "
-                            + "-p {port} -P tpz001 --simulation")
-            }
-        }
-
-    def setUp(self):
-        GenericControllerCase.setUp(self)
-        self.start_controller("tpz")
-        self.cont = self.device_mgr.get("tpz")
diff --git a/doc/manual/faq.rst b/doc/manual/faq.rst
index a550392a8..817b64130 100644
--- a/doc/manual/faq.rst
+++ b/doc/manual/faq.rst
@@ -88,7 +88,13 @@ The preferred way to specify a serial device is to make use of the ``hwgrep://``
 URL: it allows to select the serial device by its USB vendor ID, product
 ID and/or serial number. Those never change, unlike the device file name.
 
-See the :ref:`TDC001 documentation <tdc001-controller-usage-example>` for an example of ``hwgrep://`` usage.
+For instance, if you want to specify the Vendor/Product ID and the USB Serial Number, you can do:
+
+``-d "hwgrep://<VID>:<PID> SNR=<serial_number>"``.
+for example:
+
+``-d "hwgrep://0403:faf0 SNR=83852734"``
+
 
 run unit tests?
 ---------------
diff --git a/doc/manual/ndsp_reference.rst b/doc/manual/ndsp_reference.rst
index 7a266394e..2a8f2b26e 100644
--- a/doc/manual/ndsp_reference.rst
+++ b/doc/manual/ndsp_reference.rst
@@ -7,90 +7,3 @@ Core device logging controller
 .. argparse::
    :ref: artiq.frontend.aqctl_corelog.get_argparser
    :prog: aqctl_corelog
-
-
-Thorlabs T-Cube
----------------
-
-.. note::
-    When power is applied before the USB connection, some devices will enter a state where they fail to report the completion of commands. When using the ARTIQ controller, this cause certain function calls to never return and freeze the controller. To prevent this, connect USB first and then power up the device. When a device has entered the problematic state, power-cycling it while keeping the USB connection active also resolves the problem.
-
-TDC001 Driver
-+++++++++++++
-
-.. autoclass:: artiq.devices.thorlabs_tcube.driver.Tdc
-    :members:
-
-TPZ001 Driver
-+++++++++++++
-
-.. autoclass:: artiq.devices.thorlabs_tcube.driver.Tpz
-    :members:
-
-Controller
-++++++++++
-
-.. argparse::
-    :ref: artiq.frontend.aqctl_thorlabs_tcube.get_argparser
-    :prog: aqctl_thorlabs
-
-.. _tdc001-controller-usage-example:
-
-TDC001 controller usage example
-+++++++++++++++++++++++++++++++
-
-First, run the TDC001 controller::
-
-    $ aqctl_thorlabs_tcube -P TDC001 -d /dev/ttyUSBx
-
-.. note::
-    On Windows the serial port (the ``-d`` argument) will be of the form ``COMx``.
-
-.. note::
-    Anything compatible with `serial_for_url <http://pyserial.sourceforge.net/pyserial_api.html#serial.serial_for_url>`_
-    can be given as a device in ``-d`` argument.
-
-    For instance, if you want to specify the Vendor/Product ID and the USB Serial Number, you can do:
-
-    ``-d "hwgrep://<VID>:<PID> SNR=<serial_number>"``.
-    for instance:
-
-    ``-d "hwgrep://0403:faf0 SNR=83852734"``
-
-    The hwgrep URL works on both Linux and Windows.
-
-Then, send commands to it via the ``artiq_rpctool`` utility::
-
-    $ artiq_rpctool ::1 3255 list-targets
-    Target(s):   tdc001
-    $ artiq_rpctool ::1 3255 call move_relative 10000 # will move forward
-    $ artiq_rpctool ::1 3255 call move_relative -10000 # will move backward
-    $ artiq_rpctool ::1 3255 call move_absolute 20000 # absolute move to 20000
-    $ artiq_rpctool ::1 3255 call move_home # will go back to home position
-    $ artiq_rpctool ::1 3255 call close # close the device
-
-TPZ001 controller usage example
-+++++++++++++++++++++++++++++++
-
-First, run the TPZ001 controller::
-
-    $ aqctl_thorlabs_tcube -P TPZ001 -d /dev/ttyUSBx
-
-.. note::
-    On Windows the serial port (the ``-d`` argument) will be of the form ``COMx``.
-
-.. note::
-    See the :ref:`TDC001 documentation <tdc001-controller-usage-example>` for
-    how to specify the USB Serial Number of the device instead of the
-    /dev/ttyUSBx (or the COMx name).
-
-Then, send commands to it via the ``artiq_rpctool`` utility::
-
-    $ artiq_rpctool ::1 3255 list-targets
-    Target(s):   tpz001
-    $ artiq_rpctool ::1 3255 call set_output_volts 15 # set output voltage to 15 V
-    $ artiq_rpctool ::1 3255 call get_output_volts # read back output voltage
-    15
-    $ artiq_rpctool ::1 3255 call set_tpz_io_settings 150 1 # set maximum output voltage to 150 V
-    $ artiq_rpctool ::1 3255 call set_output_volts 150 # set output voltage to 150 V
-    $ artiq_rpctool ::1 3255 call close # close the device
diff --git a/setup.py b/setup.py
index 82be9483b..f57925539 100755
--- a/setup.py
+++ b/setup.py
@@ -37,7 +37,6 @@ console_scripts = [
     "artiq_flash = artiq.frontend.artiq_flash:main",
 
     "aqctl_corelog = artiq.frontend.aqctl_corelog:main",
-    "aqctl_thorlabs_tcube = artiq.frontend.aqctl_thorlabs_tcube:main",
 ]
 
 gui_scripts = [