first commit

Author: davidweigao

.gitignore

@@ -0,0 +1,3 @@
+/.idea
+/tool
+rsync.sh

LEDStrip.py

@@ -0,0 +1,151 @@
+import spidev
+import time
+import threading
+
+
+def convertToStripData(colors):
+    for color in colors:
+        # If it comes with the brightness bytes, use it, otherwise use full brightness 0xff
+        yield 0xff if color.bit_length() != 32 else int(color >> 24)
+        color = int(color % 0x1000000)
+        yield color & 0x0000FF  # blue
+        yield (color & 0x00FF00) >> 8  # green
+        yield color >> 16  # red
+
+
+def adjust_brightness(color, amount):
+    if color.bit_length() == 32:
+        brightness = color >> 24
+        brightness = min(max(0xE0, brightness + amount), 0xFF)
+        return (color % 0x1000000) | (brightness << 24)
+    else:
+        return color
+
+def getColors():
+    for i in xrange(20):
+        yield 0xFFff0000
+        yield 0xFF00ff00
+        yield 0xFF0000ff
+
+
+def getSteep():
+    brightness = 0xE0
+    for i in xrange(60):
+        if i % 2 == 0:
+            brightness += 1
+        yield (brightness << 24) + 0xff55ff
+
+
+class RotateThread(threading.Thread):
+    def __init__(self, strip):
+        threading.Thread.__init__(self)
+        self.strip = strip
+
+    def run(self):
+        self.strip.is_rotating = True
+        while self.strip.is_rotating:
+            self.strip.colorCache = self.strip.colorCache[-1:] + self.strip.colorCache[:-1]
+            self.strip.show()
+            time.sleep(1.0 / 4)
+
+
+class LEDStrip:
+    start_frame = [0x00, 0x00, 0x00, 0x00]
+    stop_frame = [0xFF, 0xFF, 0xFF, 0xFF]
+
+    def __init__(self, pixelNum):
+        self.spi = spidev.SpiDev()
+        self.spi.open(0, 0)
+        self.spi.max_speed_hz = 8000000
+        self.colorCache = [0xff000000] * pixelNum
+        self.rotateThread = RotateThread(self)
+        self.is_rotating = False
+        self.pixelNum = pixelNum
+
+    def start_rotate(self):
+        self.rotateThread = RotateThread(self)
+        self.rotateThread.start()
+
+    def stop_rotate(self):
+        self.is_rotating = False
+        self.rotateThread.join()
+
+    def show(self):
+        self.spi.xfer2(LEDStrip.start_frame)
+        self.spi.xfer2(list(convertToStripData(self.colorCache)))
+        self.spi.xfer2(LEDStrip.stop_frame)
+
+    def set_color(self, pixel, color):
+        self.colorCache[pixel] = color
+
+    def show_colors(self, colors):
+        self.colorCache = colors[:self.pixelNum] + self.colorCache[self.pixelNum:]
+        self.show()
+
+    def fill(self, length, color):
+        self.colorCache = [color] * min(self.pixelNum, length) + [0x000000] * (self.pixelNum - length)
+        self.show()
+
+    def fill_range(self, start, end, colors):
+        offset = abs(start - end)
+        step = 1 if start < end else -1
+        j = 0
+        for i in range(start, end, step):
+            self.colorCache[i] = colors[j]
+            j += 1
+
+    def fill_smooth(self, length, start, speed, color):
+        for i in xrange(start, length, 1 if start < length else -1):
+            self.fill(i, color)
+            time.sleep(1.0 / speed)
+        self.fill(length, color)
+
+    def dim(self, length):
+        self.colorCache = map(lambda c: adjust_brightness(c, -1), self.colorCache[:length]) + self.colorCache[length:]
+        self.show()
+
+    def brighten(self, length):
+        self.colorCache = map(lambda c: adjust_brightness(c, 1), self.colorCache[:length]) + self.colorCache[length:]
+        self.show()
+
+    def dark(self):
+        self.colorCache = [0x000000] * self.pixelNum
+        self.show()
+
+    def set_dark(self):
+        self.colorCache = [0x000000] * self.pixelNum
+
+    def getColor(self, index):
+        return self.colorCache[index]
+
+    def get_brightness(self, index):
+        color = self.colorCache[index]
+        return color >> 24
+
+class LEDScreen:
+    # row * column <= ledStrip.pixelNum
+    def __init__(self, ledStrip, row, column):
+        self.strip = ledStrip
+        self.row = row
+        self.column = column
+
+    def show(self, pixelArray):
+        for index in range(0, len(pixelArray)):
+            row = pixelArray[index]
+            self.showRow(index, row)
+
+    def showRow(self, index, colors):
+        if index % 2 == 0:
+            start = index * self.column
+            end = start + len(colors)
+        else:
+            start = (index + 1) * self.column - 1
+            end = start - len(colors)
+        self.strip.fill_range(start, end, colors)
+
+    def refresh(self):
+        self.strip.show()
+
+if __name__ == '__main__':
+    c = 0xffff0000
+    print hex()

soundsa.py

@@ -0,0 +1,119 @@
+import pyaudio
+import sys
+import numpy
+import random
+from LEDStrip import LEDStrip, LEDScreen
+
+p = pyaudio.PyAudio()
+row = 8
+column = 72 * 4 / row
+led_screen = LEDScreen(LEDStrip(row * column), row, column)
+max_db = 50.0
+sample_rate = 44100 #Hz
+sample_per_buffer = 2**11
+db_per_pixel = float(max_db) / column
+currentColor = 0xe1ff00ff
+
+frequency_per_sample = sample_rate / sample_per_buffer
+
+def getLedIndex(index, pixel):
+    if index % 2 == 0:
+        return index / 2 * 72 + pixel
+    else:
+        return (index+1) / 2 * 72 - 1 -pixel
+
+def fillLedIndex(index, pixel, color):
+    colors = list(0 for _ in range(0, column))
+    for i in range(0, pixel):
+        colors[i] = color
+    led_screen.showRow(index, colors)
+
+def frequencyToIndex(frequency):
+    return int(frequency / frequency_per_sample)
+
+def normalize(x):
+    return 20 * numpy.log10(numpy.abs(x)) - 50 - 10
+
+def avg(list):
+    return sum(list) / float(len(list))
+
+def getDb(fft, start, end):
+    from_index = frequencyToIndex(start)
+    until_index = frequencyToIndex(end) + 1
+    return avg(fft[from_index:until_index])
+
+def getRandomColor():
+    r = random.randint(0, 255)
+    g = random.randint(0, 255)
+    b = random.randint(0, 255)
+    return ((((r << 8) + g) << 8) + b) + (0xe5 << 24)
+
+
+def getMaxDb(fft, start, end):
+    from_index = frequencyToIndex(start)
+    until_index = frequencyToIndex(end) + 1
+    return max(fft[from_index:until_index])
+
+def dbToPixel(db):
+    db = min(max_db, db)
+    pixel = int(db / db_per_pixel)
+    pixel = min(max(0, pixel), column-1)
+    return pixel
+
+def dbToColor(db):
+    db = min(max(0, db), max_db)
+    color = long(db / max_db * 255)
+    return color + 0xff0000
+
+def print_spectrum(fft):
+    out_str = ''
+    for i in range(0, len(fft), 50):
+        db = getDb(fft, i, i + 50)
+        out_str += "{0:g}\t ".format(db)
+    print out_str
+
+
+def handleData(in_data):
+    samples = numpy.fromstring(in_data, dtype=numpy.int16)
+    fft = numpy.fft.fft(samples)
+    fft = normalize(fft)
+    maxDb = getMaxDb(fft, 1000, 5000)
+    maxPixel = dbToPixel(maxDb)
+    global currentColor
+    if (maxPixel > column - 2):
+        currentColor = getRandomColor()
+    for i in range(0, row):
+        db = getDb(fft, i * 500 + 200, (i+1) * 500)
+        print db
+        fillLedIndex(i, dbToPixel(db), currentColor)
+    led_screen.refresh()
+    return (None, pyaudio.paContinue)
+
+
+# This is to release mic when the program  exit
+def interrupt_callback():
+    print "interrupted manually"
+    stream.stop_stream()
+    stream.close()
+    p.terminate()
+    sys.exit()
+
+try:
+    stream = p.open(format=pyaudio.paInt16,
+                    channels=1,
+                    rate=sample_rate,
+                    input=True,
+                    # input_device_index=2,
+                    output=False)
+    stream.start_stream()
+    while True:
+        stream.start_stream()
+        in_data = stream.read(sample_per_buffer, exception_on_overflow=False)
+        stream.stop_stream()
+        handleData(in_data)
+        # time.sleep(0.1)
+except Exception as e:
+    print e
+finally:
+    interrupt_callback()
+