1

import collections

     2

import logging; log = logging.getLogger('qmsk.dmx.control')

     3

import serial

     4

     5

"""

     6

    Low-level DMX channel output.

     7

"""

     8

     9

class DMXError (Exception) :

    10

    def __init__ (self, **kwargs) :

    11

        self.kwargs = kwargs

    12

    13

    def __str__ (self) :

    14

        return self.__doc__.strip().format(**self.kwargs)

    15

    16

class DMXCommandError (DMXError) :

    17

    """

    18

        Command {cmd!r} failed: {out!r}

    19

    """

    20

    21

class DMXUnknownCommandError (DMXError) :

    22

    """

    23

        Unknown command: {cmd!r}

    24

    """

    25

    26

class DMX (object) :

    27

    """

    28

        Arudino-based DMX controller using src/hello-dmx.c over the serial port.

    29

    """

    30

    31

    SERIAL = '/dev/arduino'

    32

    SERIAL_BAUD = 9600

    33

    SERIAL_TIMEOUT = 1.0

    34

    35

    @classmethod

    36

    def open (cls, path, baud=SERIAL_BAUD, timeout=SERIAL_TIMEOUT) :

    37

        return cls(serial.Serial(path, baud, timeout=timeout))

    38

    39

    def __init__ (self, io) :

    40

        self.io = io

    41

    42

        # XXX: bug

    43

        self.io.write('\r')

    44

        self.io.flush()

    45

        self.io.read(1)

    46

    47

    def _arg (self, arg) :

    52

        if isinstance(arg, str) :

    53

            value, = arg

    54

            value = ord(value)

    55

        elif isinstance(arg, int) :

    56

            value = arg

    57

        else :

    58

            raise ValueError(arg)

    59

    60

        if 0 <= value <= 255 :

    61

            return str(value)

    62

        else :

    63

            raise ValueError(value)

    64

    82

        out = cmd + ' ' + ' '.join(self._arg(arg) for arg in args) + '\r'

    83

    84

        log.info("%s", out)

    85

    86

        self.io.write(out)

    87

        self.io.flush()

    88

    92

    95

    98

   100

        """

   101

            Set dmx = [ ]

   102

   103

            i.e. start transmitting zero-length DMX packets.

   104

            For most lights, this seems to be equivalent to losing the DMX signal, and they retain their old state.

   105

        """

   106

   108

   110

        """

   111

            Set dmx = [0, ...]

   112

   113

            Uses the maximum DMX packet length available.

   114

        """

   115

   117

   119

        """

   120

            Set dmx = (value, ...)

   121

        """

   122

   124

   126

        """

   127

            Set dmx[start:] = value

   128

        """

   129

   131

   133

        """

   134

            Set dmx[start:end] to repetitions of (value, ...)

   135

        """

   136

   138

   140

        """

   141

            Set dmx[start:end:step] = value

   142

        """

   143

   145

   146

    def __setitem__ (self, index, value) :

   151

        if isinstance(value, collections.Sequence) :

   152

            values = tuple(value)

   153

        else :

   154

            values = (value, )

   155

   156

        if isinstance(index, slice) :

   157

            if index.start and index.stop and index.step :

   158

                # XXX: single

   159

                self.range(index.start, index.stop, index.step, value)

   160

   161

            elif index.start and index.stop :

   162

                self.fill(index.start, index.stop, *values)

   163

   164

            elif index.start :

   165

                self.set(index.start, *values)

   166

   167

            else :

   168

                raise IndexError("invalid slice: %s" % (index, ))

   169

   170

        else :

   171

            # simple set

   172

            self.set(index, *values)

   173