pyetherpix

@@ -1,3 +1,5 @@

+import socket

+

 from distributor import Distributor

 from mapping import Mapping

 from msg import Msg, MsgDef

@@ -20,6 +22,14 @@ class Display(object):

         # read config file

         if not self._proc_config_file(config_file):

             raise Exception("error(s) while reading config file")

+        # create and bind socket

+        self._socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

+        self._socket.setblocking(False)

+        self._socket.bind(self._bind_addr)

+

+    def close(self):

+        """close display"""

+        self._socket.close()

     def get_size(self):

         """get size of display as (width, height) in pixels"""

@@ -27,18 +37,18 @@ class Display(object):

     def data_clear(self):

         """clear image data, i.e. set entire image to black"""

-        # TODO

-        pass

+        for distri in self._distris.values():

+          distri.data_clear()

-    def data_set(self, TODO):

+    def data_image(self, image):

         """set image data"""

-        # TODO

-        pass

+        for distri in self._distris.values():

+          distri.data_image(image)

     def send(self):

-        """send image data to distributors"""

-        # TODO

-        pass

+        """send image data to actual distributor modules using UDP"""

+        for distri in self._distris.values():

+          distri.send(self._socket)

     def _proc_config_file(self, config_file):

         """process config file

@@ -1,3 +1,6 @@

+import socket

+import struct

+

 from mapping import Mapping

@@ -19,6 +22,11 @@ class Distributor(object):

             self._mappings.append(Mapping())

         # pixel coordinates: all unknown

         self._pixel_coords = [[None] * self._pixels] * self._outputs

+        # header for UDP packets

+        self._udp_hdr = struct.pack("!I4H", 0x23542666,

+                                    outputs, pixels, Mapping.CHANNELS, 255)

+        # initial image data is cleared

+        self.data_clear()

     def check_output_no(self, output_no):

         """check output number, return True if okay, False if not okay"""

@@ -36,6 +44,35 @@ class Distributor(object):

         """set distributor address"""

         self._addr = addr

+    def data_clear(self):

+        """clear image data, i.e. set entire image to black"""

+        # prepare message buffer with all pixels cleared (black)

+        clr = "".join([self._mappings[channel].table[0]

+                       for channel in range(Mapping.CHANNELS)])

+        self._buffer = self._udp_hdr + (clr * (self._outputs * self._pixels))

+

+    def data_image(self, image):

+        """set image data"""

+        # collect pixels from image and assemble message in buffer

+        clr = [0] * Mapping.CHANNELS

+        data = []

+        for output_pixel_coords in self._pixel_coords:

+            for pixel_coord in output_pixel_coords:

+                if pixel_coord is None:

+                    pix = clr

+                else:

+                    pix = (128, 128, 0) # TODO

+                data += [self._mappings[channel].table[pix[channel]]

+                                        for channel in range(Mapping.CHANNELS)]

+        self._buffer = self._udp_hdr + "".join(data)

+

+    def send(self, socket):

+        """send image data to actual distributor module using UDP"""

+        try:

+            socket.sendto(self._buffer, self._addr)

+        except:

+            pass

+

     def set_pixel_coords(self, output_no, pixel_coords):

         """set distributor address

            output_no: number of output

@@ -1,6 +1,8 @@

 #! /usr/bin/env python

 import sys

+import time

+

 import pyetherpix

@@ -10,6 +12,20 @@ def main(argv):

         return 2

     config_file = argv[1]

     display = pyetherpix.Display(config_file)

+    (width, height) = display.get_size()

+    print "width %u, height %u" % (width, height)

+    print "blink"

+    for i in range(5):

+        print "on"

+        display.data_image("ON") # TODO

+        display.send()

+        time.sleep(0.5)

+        print "off"

+        display.data_clear()

+        display.send()

+        time.sleep(0.5)

+    print "done"

+    display.close()

     return 0

@@ -1,3 +1,6 @@

+from struct import Struct

+

+

 class Mapping(object):

     RED = 0

@@ -23,14 +26,16 @@ class Mapping(object):

         """pre-compute mapping table"""

         # display_value := base + factor * input_value ^ (1 / gamma)

         gamma_1 = 1.0 / self._gamma

+        s = Struct("!B")

         tab = []

         for v in range(256):

-            val = self._base + self._factor * (v / 255.0) ** gamma_1

-            if val < 0:

-                tab.append(0)

-            elif val > 1.0:

-                tab.append(255)

+            display_val = self._base + self._factor * (v / 255.0) ** gamma_1

+            if display_val < 0:

+                display_no = 0

+            elif display_val > 1.0:

+                display_no = 255

             else:

-                tab.append(int(round(val * 255.0)))

-        self._table = tuple(tab)

+                display_no = int(round(display_val * 255.0))

+            tab.append(s.pack(display_no))

+        self.table = tuple(tab)