1

#!/usr/bin/env python

     2

     4

import serial

     5

import time

     6

     7

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

     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) :

    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

    61

    def __call__ (self, cmd, *args) :

    63

    64

        log.info("%s", out)

    65

    66

        self.io.write(out)

    67

        self.io.flush()

    68

    69

        ret = self.io.read(len(out))

    70

    71

        if '!' in ret :

    72

            raise DMXCommandError(cmd=out, out=ret)

    73

    74

        elif '?' in ret :

    75

            raise DMXUnknownCommandError(cmd=cmd)

    76

    77

    def clear (self) :

    78

        """

    79

            Set dmx = [ ]

    80

    81

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

    82

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

    83

        """

    84

    85

        self('c')

    86

    87

    def zero (self) :

    88

        """

    89

            Set dmx = [0, ...]

    90

    91

            Uses the maximum DMX packet length available.

    92

        """

    93

    94

        self('z')

    95

    96

    def out (self, *values) :

    97

        """

    98

            Set dmx = (value, ...)

    99

        """

   100

   101

        self('o', *values)

   102

   103

    def set (self, start, *values) :

   104

        """

   105

            Set dmx[start:] = value

   106

        """

   107

   108

        self('s', start, *values)

   109

   110

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

   111

        """

   112

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

   113

        """

   114

   115

        self('f', start, end, *values)

   116

   117

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

   118

        """

   119

            Set dmx[start:end:step] = value

   120

        """

   121

   122

        self('r', start, stop, step, value)

   123

   148

import argparse

   149

   150

def main (argv) :

   151

    parser = argparse.ArgumentParser()

   152

    parser.add_argument('--serial', default=DMX.SERIAL,

   153

            help="Path to /dev/tty*")

   154

    parser.add_argument('--zero', action='store_true',

   155

            help="Zero output before setting")

   156

    parser.add_argument('--start', type=int,

   157

            help="Set from start offset")

   158

    parser.add_argument('--stop', type=int,

   159

            help="Set to end offset")

   160

    parser.add_argument('--step', type=int,

   161

            help="Step")

   162

   163

    parser.add_argument('channels', nargs='*', type=int,

   164

            help="Output channel values")

   165

   166

    options = parser.parse_args(argv[1:])

   167

   168

    logging.basicConfig(level=logging.DEBUG)

   169

   170

    dmx = DMX.open(options.serial)

   171

   172

    if options.zero :

   173

        dmx.zero()

   174

   175

   176

    if options.start and options.stop and options.step :

   177

        dmx.range(options.start, options.stop, options.step, *options.channels)

   178

   179

    elif options.start and options.stop :

   180

        dmx.fill(options.start, options.stop, *options.channels)

   181

   182

    elif options.start :

   183

        dmx.set(options.start, *options.channels)

   184

   185

    elif options.channels :

   186

        dmx.out(*options.channels)

   187

   188

if __name__ == '__main__':

   189

    import sys

   190

    sys.exit(main(sys.argv))