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

    34

    @classmethod

    37

    38

    def __init__ (self, io) :

    39

        self.io = io

    44

    51

        self.io.flush()

    52

        self.io.read(1)

    53

    54

    def _arg (self, arg) :

    55

        """

    56

            Format given value as a protocol argument.

    57

        """

    58

    59

        if isinstance(arg, str) :

    60

            value, = arg

    61

            value = ord(value)

    62

        elif isinstance(arg, int) :

    63

            value = arg

    64

        else :

    65

            raise ValueError(arg)

    66

    67

        if 0 <= value <= 255 :

    69

        else :

    70

            raise ValueError(value)

    71

    72

    def __iter__ (self) :

    73

        """

    74

            Read command responses back.

    75

        """

    76

    77

        while True:

    78

            yield self.io.readline()

    79

    80

    def __call__ (self, cmd, *args, **opts) :

    81

        """

    82

    83

            <chr> [<int> [...]]

    84

        """

    85

    86

        # XXX:

    87

        poll = opts.pop('poll', True)

    90

    91

        log.info("%s", out)

    92

    93

        self.io.write(out)

    95

        self.io.flush()

    96

    97

        if poll:

    98

            for ret in self:

    99

                break

   100

   102

                raise DMXCommandError(cmd=out, out=ret)

   103

   105

                raise DMXUnknownCommandError(cmd=cmd)

   106

   107

    def clear (self, **opts) :

   108

        """

   109

            Set dmx = [ ]

   110

   111

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

   112

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

   113

        """

   114

   116

   117

    def zero (self, **opts) :

   118

        """

   119

            Set dmx = [0, ...]

   120

   121

            Uses the maximum DMX packet length available.

   122

        """

   123

   125

   126

    def out (self, *values, **opts) :

   127

        """

   128

            Set dmx = (value, ...)

   129

        """

   130

   132

   133

    def set (self, start, *values, **opts) :

   134

        """

   135

            Set dmx[start:] = value

   136

        """

   137

   139

   140

    def fill (self, start, end, *values, **opts) :

   141

        """

   142

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

   143

        """

   144

   146

   147

    def range (self, start, stop, step, value, **opts) :

   148

        """

   149

            Set dmx[start:end:step] = value

   150

        """

   151

   153

   154

    def __setitem__ (self, index, value) :

   155

        """

   156

            Magic indexing.

   157

        """

   158

   159

        if isinstance(value, collections.Sequence) :

   160

            values = tuple(value)

   161

        else :

   162

            values = (value, )

   163

   164

        if isinstance(index, slice) :

   165

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

   166

                # XXX: single

   167

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

   168

   169

            elif index.start and index.stop :

   170

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

   171

   172

            elif index.start :

   173

                self.set(index.start, *values)

   174

   175

            else :

   176

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

   177

   178

        else :

   179

            # simple set

   180

            self.set(index, *values)

   181