#!/usr/bin/env python

# Jan 12 2014 - latest additions / mutilations by Scott Driscoll

# CuriousInventor.com | https://plus.google.com/+ScottDriscoll

#

# Licensed under the BSD license. See full license in LICENSE file.

# http://www.lightshowpi.com/

#

# Author: Todd Giles (todd@lightshowpi.com)

# Author: Chris Usey (chris.usey@gmail.com)

# Author: Ryan Jennings

"""Play any audio file and synchronize lights to the music

When executed, this script will play an audio file, as well as turn on and off 8 channels

of lights to the music (via the first 8 GPIO channels on the Rasberry Pi), based upon

music it is playing. Many types of audio files are supported (see decoder.py below), but

it has only been tested with wav and mp3 at the time of this writing.

The timing of the lights turning on and off are controlled based upon the frequency response

of the music being played. A short segment of the music is analyzed via FFT to get the

frequency response across 8 channels in the audio range. Each light channel is then turned

on or off based upon whether the amplitude of the frequency response in the corresponding

channel has crossed a dynamic threshold.

The threshold for each channel is "dynamic" in that it is adjusted upwards and downwards

during the song play back based upon the frequency response amplitude of the song. This ensures

that soft songs, or even soft portions of songs will still turn all 8 channels on and off

during the song.

FFT calculation is quite CPU intensive and can adversely affect playback of songs (especially if

attempting to decode the song as well, as is the case for an mp3). For this reason, the timing

values of the lights turning on and off is cached after it is calculated upon the first time a

new song is played. The values are cached in a gzip'd text file in the same location as

the song itself. Subsequent requests to play the same song will use the cached information and not

recompute the FFT, thus reducing CPU utilization dramatically and allowing for clear music

playback of all audio file types.

Sample usage:

sudo python synchronized_lights.py --playlist=/home/pi/music/.playlist

sudo python synchronized_lights.py --file=/home/pi/music/jingle_bells.mp3

Third party dependencies:

alsaaudio: for audio output - http://pyalsaaudio.sourceforge.net/

decoder.py: decoding mp3, ogg, wma, ... - https://pypi.python.org/pypi/decoder.py/1.5XB

numpy: for FFT calcuation - http://www.numpy.org/

"""

import argparse

import csv

import fcntl

import gzip

import logging

import os

import random

from struct import unpack

import sys

import time

import wave

import alsaaudio as aa

import configuration_manager as cm

import decoder

import hardware_controller as hc

import numpy as np

# RGB LED STRIP STUFF

from bootstrap import * # LPD8806 LED string stuff

led.all_off()

led_array = [0 for i in range(151)]

c = 0.0

columns = [1.0,1.0,1.0,1.0,1.0]

decay = .9

# this writes out light and color information to a continuous RGB LED

# strip that's been wrapped around into 5 columns.

# numbers comes in at 9-15 ish

def display_column(col=0,height=0.0,color=Color(50,50,0)):

led.fill(color,123,123+int(round(height*25)))

# Configurations - TODO(todd): Move more of this into configuration manager

_CONFIG = cm.CONFIG

_LIMIT_LIST = [int(lim) for lim in _CONFIG.get('auto_tuning', 'limit_list').split(',')]

_LIMIT_THRESHOLD = _CONFIG.getfloat('auto_tuning', 'limit_threshold')

_LIMIT_THRESHOLD_INCREASE = _CONFIG.getfloat('auto_tuning', 'limit_threshold_increase')

_LIMIT_THRESHOLD_DECREASE = _CONFIG.getfloat('auto_tuning', 'limit_threshold_decrease')

_MAX_OFF_CYCLES = _CONFIG.getfloat('auto_tuning', 'max_off_cycles')

_MIN_FREQUENCY = _CONFIG.getfloat('audio_processing', 'min_frequency')

_MAX_FREQUENCY = _CONFIG.getfloat('audio_processing', 'max_frequency')

_RANDOMIZE_PLAYLIST = _CONFIG.getboolean('lightshow', 'randomize_playlist')

try:

_CUSTOM_CHANNEL_MAPPING = [int(channel) for channel in

_CONFIG.get('audio_processing', 'custom_channel_mapping').split(',')]

except:

_CUSTOM_CHANNEL_MAPPING = 0

try:

_CUSTOM_CHANNEL_FREQUENCIES = [int(channel) for channel in

_CONFIG.get('audio_processing',

'custom_channel_frequencies').split(',')]

except:

_CUSTOM_CHANNEL_FREQUENCIES = 0

try:

_PLAYLIST_PATH = _CONFIG.get('lightshow', 'playlist_path').replace('$SYNCHRONIZED_LIGHTS_HOME',

cm.HOME_DIR)

except:

_PLAYLIST_PATH = "/home/pi/music/.playlist"

CHUNK_SIZE = 2048 # Use a multiple of 8

def execute_preshow(config):

time.sleep(0.1)

def calculate_channel_frequency(min_frequency, max_frequency, custom_channel_mapping,

return frequency_store

def piff(val, sample_rate):

'''Return the power array index corresponding to a particular frequency.'''

return int(CHUNK_SIZE * val / sample_rate)

# TODO(todd): Move FFT related code into separate file as a library

def calculate_levels(data, sample_rate, frequency_limits):

return matrix

# TODO(todd): Refactor this to make it more readable / modular.

def main():

hc.clean_up()

if __name__ == "__main__":

main()