Adds phloston.py, a version of the evacuation floor lights from The Fifth Element

.gitignore

@@ -1,3 +1,3 @@
 .DS_Store
 *.pyc
-
+*~

api/base.py

@@ -0,0 +1,156 @@
+#!/usr/bin/env python
+"""
+Base API classes for Holiday interfaces
+
+Copyright (c) 2013 Justin Warren <justin@eigenmagic.com>
+License: MIT (see LICENSE for details)
+"""
+
+__author__ = "Justin Warren"
+__version__ = '0.02-dev'
+__license__ = "MIT"
+
+import os
+import logging
+
+# Set up logging
+log = logging.getLogger('base')
+handler = logging.StreamHandler()
+handler.setFormatter(logging.Formatter("%(asctime)s: %(name)s [%(levelname)s]: %(message)s"))
+log.addHandler(handler)
+log.setLevel(logging.DEBUG)
+
+class HolidayBase(object):
+    """
+    The base Holiday class for the main API
+    """
+    NUM_GLOBES = 50
+
+    # Local representation of globe state
+    globes = [ (0,0,0), ] * NUM_GLOBES
+
+    def setglobe(self, globenum, r, g, b):
+        # FIXME: This should be (self, globenum, color) where color is
+        # a tuple of (r g, b).
+        """Set a globe"""
+        if (globenum < 0) or (globenum >= self.NUM_GLOBES):
+            return
+        self.globes[globenum] = (r, g, b)
+
+    def fill(self, r, g, b):
+        """Sets the whole string to a particular colour"""
+        self.globes = [ (int(r), int(g), int(b)), ] * self.NUM_GLOBES
+            #for e in self.globes:
+            #	e[0] = int(r)
+            #	e[1] = int(g)
+            #	e[2] = int(b)
+
+    def getglobe(self, globenum):
+        """Return a tuple representing a globe's RGB color value"""
+        if (globenum < 0) or (globenum >= self.NUM_GLOBES):
+            # Fail hard, don't ignore errors
+            raise IndexError("globenum %d does not exist", globenum)
+        return self.globes[globenum]
+
+    def set_pattern(self, pattern):
+        """
+        Set the entire string in one go
+        """
+        if len(pattern) != self.NUM_GLOBES:
+            raise ValueError("pattern length incorrect: %d != %d" % ( len(pattern), self.NUM_GLOBES) )
+        self.globes = pattern[:]
+
+    def chase(self, direction=True):
+        """
+        Rotate all globes around one step.
+        @param direction: Direction to rotate: up if True, down if False
+        """
+        if direction:
+            # Rotate all globes around by one place
+            oldglobes = self.globes[:]
+            self.globes = oldglobes[1:]
+            self.globes.append(oldglobes[0])
+            pass
+        else:
+            oldglobes = self.globes[:]
+            self.globes = oldglobes[:-1]
+            self.globes.insert(0, oldglobes[-1])
+            pass
+        return
+
+    def rotate(self, newr, newg, newb, direction=True):
+        """
+        Rotate all globes, just like chase, but replace the 'first'
+        globe with new color.
+        """
+        self.chase(direction)
+        if direction:
+            self.globes[-1] = (newr, newg, newb)
+            pass
+        else:
+            self.globes[0] = (newr, newg, newb)
+            pass
+        pass
+
+    def render(self):
+        raise NotImplementedError
+
+class ButtonHoliday(HolidayBase):
+    """
+    Used when running on a physical Holiday.
+    """
+    def __init__(self):
+        super(ButtonHoliday, self).__init__()
+        self.pid = os.getpid()
+        self.pipename = '/run/compose.fifo'
+        try:
+            self.pipe = open(self.pipename, "wb")
+        except:
+            print "Couldn't open the pipe! Oh no!"
+            raise
+            self.pipe = None
+            pass
+
+    def render(self):
+        """
+        Render globe colours to local pipe
+        """
+        rend = []
+        rend.append("0x000010\n")
+        rend.append("0x%06x\n" % self.pid)
+        for g in self.globes:
+            tripval = (g[0] * 65536) + (g[1] * 256) + g[2]
+            rend.append("0x%06X\n" % tripval)
+            pass
+        self.pipe.write(''.join(rend))
+        self.pipe.flush()
+
+class ButtonApp(object):
+    """
+    A ButtonApp runs on a physical Holiday using the button interface.
+    """
+
+    def start(self):
+        """
+        Do whatever is required to start up the app
+        """
+        return
+
+    def stop(self):
+        """
+        Do whatever is required to stop the app
+        """
+        return
+
+    def up(self):
+        """
+        Called when the Up button is pressed
+        """
+        return
+
+    def down(self):
+        """
+        Called when the Down button is pressed
+        """
+        return
+

api/restholiday.py

@@ -0,0 +1,50 @@
+#!/usr/bin/env python
+"""
+REST interface classes for Holiday
+
+Copyright (c) 2013 Justin Warren <justin@eigenmagic.com>
+License: MIT (see LICENSE for details)
+"""
+
+__author__ = "Justin Warren"
+__version__ = '0.02-dev'
+__license__ = "MIT"
+
+import requests
+import json
+
+from base import HolidayBase
+
+import logging
+
+# Set up logging
+log = logging.getLogger('rest_holiday')
+handler = logging.StreamHandler()
+handler.setFormatter(logging.Formatter("%(asctime)s: %(name)s [%(levelname)s]: %(message)s"))
+log.addHandler(handler)
+log.setLevel(logging.DEBUG)
+
+class RESTHoliday(HolidayBase):
+    """
+    A remote Holiday we talk to over the JSON REST web interface
+    """
+    def __init__(self, addr, scheme='http'):
+        """
+        Initialise the REST Holiday remote address
+        @param addr: A string of the remote address of form <ipaddr>:<port>
+        """
+        super(RESTHoliday, self).__init__()
+        self.scheme = scheme
+        self.addr = addr
+
+    def render(self):
+        """
+        Render globe values via JSON to remote Holiday via REST interface
+        """
+        hol_vals = [ "#%02x%02x%02x" % (x[0], x[1], x[2]) for x in self.globes ]
+        hol_msg = { "lights": hol_vals }
+        msg_str = json.dumps(hol_msg)
+        url_str = "%s://%s/device/light/setlights" % (self.scheme, self.addr)
+        r = requests.put(urlstr, data=msg_str)
+        pass
+

api/udpholiday.py

@@ -0,0 +1,55 @@
+#!/usr/bin/env python
+"""
+UDP interface classes for Holiday
+
+Copyright (c) 2013 Justin Warren <justin@eigenmagic.com>
+License: MIT (see LICENSE for details)
+"""
+
+__author__ = "Justin Warren"
+__version__ = '0.02-dev'
+__license__ = "MIT"
+
+import sys
+import socket
+import array
+
+from base import HolidayBase
+
+import logging
+
+# Set up logging
+log = logging.getLogger('udp_holiday')
+handler = logging.StreamHandler()
+handler.setFormatter(logging.Formatter("%(asctime)s: %(name)s [%(levelname)s]: %(message)s"))
+log.addHandler(handler)
+log.setLevel(logging.DEBUG)
+
+class UDPHoliday(HolidayBase):
+    """
+    A remote Holiday we talk to over the fast UDP
+    """
+    def __init__(self, ipaddr, port=9988):
+        """
+        Initialise the REST Holiday remote address
+        @param addr: A string of the remote address of form <ipaddr>:<port>
+        """
+        super(UDPHoliday, self).__init__()
+        self.ipaddr = ipaddr
+        self.port = port
+        self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+
+    def render(self):
+        """
+        Render globe values via UDP to remote Holiday
+        """
+        packet = array.array('B', [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])  # initialize basic packet, ignore first 10 bytes
+        for g in self.globes:
+            packet.append(g[0])
+            packet.append(g[1])
+            packet.append(g[2])
+            pass
+        # Send the packet to the Holiday
+        self.sock.sendto(packet, (self.ipaddr, self.port))
+        pass
+

examples/candela.sh

@@ -0,0 +1,3 @@
+#!/bin/sh
+
+./twinkle.py $1 -H 0.01 -S 0.1 -V 0.00 -c 0.5 -b '#b0771f' --satdiff-max 0.05 --huediff-max 0.05

examples/chase_demo.py

@@ -0,0 +1,96 @@
+#!/usr/bin/env python
+"""
+Demonstrate the chase function from holiday.py
+
+Copyright (c) 2013 Justin Warren <justin@eigenmagic.com>
+License: MIT (see LICENSE for details)
+"""
+
+__author__ = "Justin Warren"
+__version__ = '0.01-dev'
+__license__ = "MIT"
+
+import sys
+import time
+import logging
+
+import holiday
+
+# Simulator default address
+SIM_ADDR = "localhost:8080"
+
+log = logging.getLogger(sys.argv[0])
+handler = logging.StreamHandler()
+handler.setFormatter(logging.Formatter("%(asctime)s: %(name)s [%(levelname)s]: %(message)s"))
+log.addHandler(handler)
+log.setLevel(logging.DEBUG)
+
+class Chaser(object):
+    """
+    Implements a chaser
+    """
+
+    def __init__(self, addr,
+                 pattern=None,
+                 reverse=False,
+                 delay=0.1):
+        """
+        Controls a single Holiday at addr
+
+        @param pattern: The starting pattern to chase around
+        """
+        self.hol = holiday.Holiday(addr=addr,
+                                   remote=True)
+
+        if pattern is None:
+            pattern = [
+                (0x00, 0x00, 0x00),
+                ] * self.hol.NUM_GLOBES
+            pattern[0] = (0xff, 0xff, 0xff)
+            pattern[10] = (0xff, 0x00, 0x00)
+            pattern[20] = (0x00, 0xff, 0x00)
+            pattern[30] = (0x00, 0x00, 0xff)
+            pattern[40] = (0xff, 0xff, 0x00)
+
+        # Make a copy so we don't clobber the original
+        self.globe_pattern = pattern[:]
+
+        self.reverse = reverse
+        self.delay = delay
+
+    def animate(self):
+        # Animation sequence is to start blank, then light each
+        # globe in sequence until all are lit, then start again.
+        while True:
+
+            # Move lights one step forwards or backwards,
+            # depending on the setting passed in
+            if self.reverse:
+                new_pattern = self.globe_pattern[1:]
+                new_pattern.append(self.globe_pattern[0])
+                pass
+
+            else:
+                new_pattern = self.globe_pattern[:-1]
+                new_pattern.insert(0, self.globe_pattern[-1])
+                pass
+
+            self.globe_pattern = new_pattern
+            self.hol.set_pattern(self.globe_pattern)
+            self.hol.render()
+            time.sleep(self.delay)
+            pass
+
+if __name__ == '__main__':
+    if len(sys.argv) > 1:
+        hostname = sys.argv[1]
+        log.debug("hostname: %s", hostname)
+    else:
+        # Assume we're on the simulator
+        log.info("Using simulator: %s", SIM_ADDR)
+        hostname = SIM_ADDR
+        pass
+
+    obj = Chaser(hostname,
+                 reverse=False)
+    obj.animate()