Merge pull request #6 from JakobST1n/dev

Written docs, finished CLI

4 files changed, 148 insertions, 147 deletions

diff --git a/src/compileAndRun/pythonSupportFiles/LuxcenaNeo/Matrix.py b/src/compileAndRun/pythonSupportFiles/LuxcenaNeo/Matrix.py
new file mode 100644
index 0000000..0986b45
--- /dev/null
+++ b/src/compileAndRun/pythonSupportFiles/LuxcenaNeo/Matrix.py
@@ -0,0 +1,49 @@
+def getSegmentRange(segments, n):
+    """ Return a list of all the actual led-numbers in a segment """
+    # Sum all the segments prior to the one we are looking for
+    i = 0
+    start = 0
+    while True:
+        if i >= n: break
+        start += segments[i]  # Add number of leds in this segment to the start-index
+        i += 1
+
+    # Add all numbers in the segment we are looking for to a list
+    i = start
+    breakPoint = i + segments[n]
+    range = []
+    while True:
+        range.append(i)
+        i += 1
+        if i >= breakPoint: break
+    return range
+
+
+class Matrix:
+
+    def __init__(self, segments, matrix):
+        self.matrix = []
+        for yPos in range(len(matrix)):
+            yVal = matrix[yPos]
+
+            thisY = []
+            for xPos in range(len(yVal)):
+                if matrix[yPos][xPos][1] == True:
+                    thisY += reversed(getSegmentRange(segments, matrix[yPos][xPos][0]))
+                else:
+                    thisY += getSegmentRange(segments, matrix[yPos][xPos][0])
+            self.matrix.append(thisY)
+
+    def get(self, x, y):
+        """ Return the value of a place in the matrix given x and y coordinates """
+        return self.matrix[y][x]
+
+if __name__ == "__main__":
+    testMatrix = Matrix(
+        [2, 2, 2, 2, 2, 2, 2, 2, 2],
+        [
+            [[0, False], [1, True], [2, False]],
+            [[3, True], [4, False], [5, True]],
+            [[6, False], [7, True], [8, False]]
+        ]
+    )
diff --git a/src/compileAndRun/pythonSupportFiles/LuxcenaNeo/Strip.py b/src/compileAndRun/pythonSupportFiles/LuxcenaNeo/Strip.py
index f5beaa4..8feca0e 100644
--- a/src/compileAndRun/pythonSupportFiles/LuxcenaNeo/Strip.py
+++ b/src/compileAndRun/pythonSupportFiles/LuxcenaNeo/Strip.py
@@ -1,161 +1,111 @@
-#from neopixel import *
-import atexit
-import _rpi_ws281x as ws
+from neopixel import *
+from Matrix import Matrix, getSegmentRange
 
 class Strip:
 
     def __init__(self, stripConf):
-		"""Class to represent a NeoPixel/WS281x LED display.  Num should be the
-		number of pixels in the display, and pin should be the GPIO pin connected
-		to the display signal line (must be a PWM pin like 18!).  Optional
-		parameters are freq, the frequency of the display signal in hertz (default
-		800khz), dma, the DMA channel to use (default 10), invert, a boolean
-		specifying if the signal line should be inverted (default False), and
-		channel, the PWM channel to use (defaults to 0).
-		"""
         self.SEGMENTS = stripConf["segments"]
         self.SEGMENT_CONFIG = stripConf["segment_config"]
 
         self.LED_FREQ_HZ = stripConf["led_freq_hz"]  # LED signal frequency in hertz (usually 800khz)
         self.LED_CHANNEL = stripConf["led_channel"]  # Set to '1' for GPIOs 13, 19, 41, 45, 53
-        self.LED_INVERT = stripConf["led_invert"]    # True to invert the signal, (when using NPN transistor level shift)
-        self.LED_PIN = stripConf["led_pin"]          # 18 uses PWM, 10 uses SPI /dev/spidev0.0
-        self.LED_DMA = stripConf["led_dma"]          # DMA channel for generating the signal, on the newer ones, try 10
-        self.LED_COUNT = sum(self.SEGMENTS)          # Number of LEDs in strip
+        self.LED_INVERT  = stripConf["led_invert"]   # True to invert the signal, (when using NPN transistor level shift)
+        self.LED_PIN     = stripConf["led_pin"]      # 18 uses PWM, 10 uses SPI /dev/spidev0.0
+        self.LED_DMA     = stripConf["led_dma"]      # DMA channel for generating the signal, on the newer ones, try 10
+        self.LED_COUNT   = sum(self.SEGMENTS)        # Number of LEDs in strip
 
 
         self.LED_BRIGHTNESS = 255
 
-		# Create ws2811_t structure and fill in parameters.
-		self._leds = ws.new_ws2811_t()
-
-		# Initialize the channels to zero
-		for channum in range(2):
-			chan = ws.ws2811_channel_get(self._leds, channum)
-			ws.ws2811_channel_t_count_set(chan, 0)
-			ws.ws2811_channel_t_gpionum_set(chan, 0)
-			ws.ws2811_channel_t_invert_set(chan, 0)
-			ws.ws2811_channel_t_brightness_set(chan, 0)
-
-		# Initialize the channel in use
-		self._channel = ws.ws2811_channel_get(self._leds, channel)
-		ws.ws2811_channel_t_count_set(self._channel, num)
-		ws.ws2811_channel_t_gpionum_set(self._channel, pin)
-		ws.ws2811_channel_t_invert_set(self._channel, 0 if not invert else 1)
-		ws.ws2811_channel_t_brightness_set(self._channel, brightness)
-		ws.ws2811_channel_t_strip_type_set(self._channel, strip_type)
-
-		# Initialize the controller
-		ws.ws2811_t_freq_set(self._leds, freq_hz)
-		ws.ws2811_t_dmanum_set(self._leds, dma)
-
-		# Grab the led data array.
-		self._led_data = _LED_Data(self._channel, num)
-
-		# Substitute for __del__, traps an exit condition and cleans up properly
-		atexit.register(self._cleanup)
-        
-    def _cleanup(self):
-		# Clean up memory used by the library when not needed anymore.
-		if self._leds is not None:
-			ws.delete_ws2811_t(self._leds)
-			self._leds = None
-			self._channel = None
-
-	def begin(self):
-		"""Initialize library, must be called once before other functions are
-		called.
-		"""
-		resp = ws.ws2811_init(self._leds)
-		if resp != ws.WS2811_SUCCESS:
-			message = ws.ws2811_get_return_t_str(resp)
-			raise RuntimeError('ws2811_init failed with code {0} ({1})'.format(resp, message))
-
-	def show(self):
-		"""Update the display with the data from the LED buffer."""
-		resp = ws.ws2811_render(self._leds)
-		if resp != ws.WS2811_SUCCESS:
-			message = ws.ws2811_get_return_t_str(resp)
-			raise RuntimeError('ws2811_render failed with code {0} ({1})'.format(resp, message))
-
-	def setPixelColor(self, n, color):
-		"""Set LED at position n to the provided 24-bit color value (in RGB order).
-		"""
-		self._led_data[n] = color
-
-	def setPixelColorRGB(self, n, red, green, blue, white = 0):
-		"""Set LED at position n to the provided red, green, and blue color.
-		Each color component should be a value from 0 to 255 (where 0 is the
-		lowest intensity and 255 is the highest intensity).
-		"""
-		self.setPixelColor(n, Color(red, green, blue, white))
-
-	def setBrightness(self, brightness):
-		"""Scale each LED in the buffer by the provided brightness.  A brightness
-		of 0 is the darkest and 255 is the brightest.
-		"""
-		ws.ws2811_channel_t_brightness_set(self._channel, brightness)
-
-	def getBrightness(self):
-		"""Get the brightness value for each LED in the buffer. A brightness
-		of 0 is the darkest and 255 is the brightest.
-		"""
-		return ws.ws2811_channel_t_brightness_get(self._channel)
-
-	def getPixels(self):
-		"""Return an object which allows access to the LED display data as if
-		it were a sequence of 24-bit RGB values.
-		"""
-		return self._led_data
-
-	def numPixels(self):
-		"""Return the number of pixels in the display."""
-		return ws.ws2811_channel_t_count_get(self._channel)
-
-	def getPixelColor(self, n):
-		"""Get the 24-bit RGB color value for the LED at position n."""
-		return self._led_data[n]
+        self.strip = Adafruit_NeoPixel(
+            self.LED_COUNT,
+            self.LED_PIN,
+            self.LED_FREQ_HZ,
+            self.LED_DMA,
+            self.LED_INVERT,
+            self.LED_BRIGHTNESS,
+            self.LED_CHANNEL
+        )
+
+        self.strip.begin()
+
+        # Setup matrix
+        try:
+            pixelMatrix = Matrix(self.segments, stripConf["matrix"])
+        except:
+            print("Something went wrong while setting up your self-defined matrix.")
+
+    def show(self):
+        """Update the display with the data from the LED buffer."""
+        self.strip.show()
+
+    def setPixelColor(self, n, color):
+        """Set LED at position n to the provided 24-bit color value (in RGB order).
+        """
+        self.strip.setPixelColor(n, color)
+
+    def setPixelColorXY(self, x, y, color):
+        """Set LED at position n to the provided 24-bit color value (in RGB order).
+        """
+        self.strip.setPixelColor(self.pixelMatrix.get(x, y), color)
+
+    def setPixelColorRGB(self, n, red, green, blue, white = 0):
+        """Set LED at position n to the provided red, green, and blue color.
+        Each color component should be a value from 0 to 255 (where 0 is the
+        lowest intensity and 255 is the highest intensity).
+        """
+        self.strip.setPixelColor(n, Color(red, green, blue, white))
+
+    def setPixelColorXYRGB(self, x, y, red, green, blue, white = 0):
+        """Set LED at position n to the provided red, green, and blue color.
+        Each color component should be a value from 0 to 255 (where 0 is the
+        lowest intensity and 255 is the highest intensity).
+        """
+        self.strip.setPixelColor(self.pixelMatrix.get(x, y), Color(red, green, blue, white))
+
+    def setSegmentColorRGB(self, segment, red, green, blue, white = 0):
+        """Set a whole segment to the provided red, green and blue color.
+        Each color component should be a value from 0 to 255 (where 0 is the
+        lowest intensity and 255 is the highest intensity)."""
+        for n in getSegmentRange(self.segments, segment):
+            self.strip.setPixelColor(n, Color(red, green, blue, white))
+
+    def setBrightness(self, brightness):
+        """Scale each LED in the buffer by the provided brightness.  A brightness
+        of 0 is the darkest and 255 is the brightest.
+        """
+        self.strip.setBrightness(brightness)
+
+    def getBrightness(self):
+        """Get the brightness value for each LED in the buffer. A brightness
+        of 0 is the darkest and 255 is the brightest.
+        """
+        return self.strip.getBrightness()
+
+    def getPixels(self):
+        """Return an object which allows access to the LED display data as if
+        it were a sequence of 24-bit RGB values.
+        """
+        return self.strip.getPixels()
+
+    def numPixels(self):
+        """Return the number of pixels in the display."""
+        return self.LED_COUNT
+
+    def getPixelColor(self, n):
+        """Get the 24-bit RGB color value for the LED at position n."""
+        return self.strip.getPixelColor(n)
 
 
 def Color(red, green, blue, white = 0):
-	"""Convert the provided red, green, blue color to a 24-bit color value.
-	Each color component should be a value 0-255 where 0 is the lowest intensity
-	and 255 is the highest intensity.
-	"""
-	return (white << 24) | (red << 16)| (green << 8) | blue
-
-
-class _LED_Data(object):
-	"""Wrapper class which makes a SWIG LED color data array look and feel like
-	a Python list of integers.
-	"""
-	def __init__(self, channel, size):
-		self.size = size
-		self.channel = channel
-
-	def __getitem__(self, pos):
-		"""Return the 24-bit RGB color value at the provided position or slice
-		of positions.
-		"""
-		# Handle if a slice of positions are passed in by grabbing all the values
-		# and returning them in a list.
-		if isinstance(pos, slice):
-			return [ws.ws2811_led_get(self.channel, n) for n in xrange(*pos.indices(self.size))]
-		# Else assume the passed in value is a number to the position.
-		else:
-			return ws.ws2811_led_get(self.channel, pos)
-
-	def __setitem__(self, pos, value):
-		"""Set the 24-bit RGB color value at the provided position or slice of
-		positions.
-		"""
-		# Handle if a slice of positions are passed in by setting the appropriate
-		# LED data values to the provided values.
-		if isinstance(pos, slice):
-			index = 0
-			for n in xrange(*pos.indices(self.size)):
-				ws.ws2811_led_set(self.channel, n, value[index])
-				index += 1
-		# Else assume the passed in value is a number to the position.
-		else:
-			return ws.ws2811_led_set(self.channel, pos, value)
+    """Convert the provided red, green, blue color to a 24-bit color value.
+    Each color component should be a value 0-255 where 0 is the lowest intensity
+    and 255 is the highest intensity.
+    """
+    return (white << 24) | (red << 16)| (green << 8) | blue
+
+def hexColor(value):
+    value = value.lstrip('#')
+    lv = len(value)
+    rgb = tuple(int(value[i:i+lv/3], 16) for i in range(0, lv, lv/3))
+    return (0 << 24) | (rgb[1] << 16) | (rgb[0] << 8) | rgb[2]
diff --git a/src/compileAndRun/pythonSupportFiles/entry.py b/src/compileAndRun/pythonSupportFiles/entry.py
index 3dab945..45de822 100644
--- a/src/compileAndRun/pythonSupportFiles/entry.py
+++ b/src/compileAndRun/pythonSupportFiles/entry.py
@@ -56,7 +56,7 @@ def main():
     if ("LuxcenaNeo" in dir(moduleSc)):
         moduleSc.LuxcenaNeo.strip = moduleSc.LuxcenaNeo.Strip(stripConf)
     elif ("neo" in dir(moduleSc)):
-        moduleSc.neo.strip = moduleSc.neo.Strip(segments, segmentConfiguration)
+        moduleSc.neo.strip = moduleSc.neo.Strip(stripConf)
     else:
         raise Exception("Neither LuxcenaNeo nor neo found in script, check docs!")
 
diff --git a/src/public/components/sidenav.js b/src/public/components/sidenav.js
index a024750..a69aac5 100644
--- a/src/public/components/sidenav.js
+++ b/src/public/components/sidenav.js
@@ -18,5 +18,7 @@ module.exports = `
     <li><a class="subheader">Settings</a></li>
     <li><a class="waves-effect" href="strip_setup"><i class="material-icons">straighten</i> Strip setup</a></li>
     <li><a class="waves-effect" href="/settings"><i class="material-icons">settings</i> Settings</a></li>
+    <li><div class="divider"></div></li>
+    <li><a class="waves-effect" href="/docs"><i class="material-icons">book</i> Docs</a></li>
 </ul>
-`;
\ No newline at end of file
+`;