# http://www.lightshowpi.org/
#
# SAMPLE CONFIGURATION FILE
# -------------------------
# This is a SAMPLE configuration file for the program. This file follows conventions
# of a python config file. The variables defined below control variable aspects
# of the program. To use this sample file, copy it to the config directory and rename
# the file "overrides.cfg".  This sample file only contains settings related to making
# specific functions or hardware work that are outlined in the description below. You can
# make changes to other settings by modifing the "config/defaults.cfg" file, or by adding
# them directly to this file.  NOTE: Full descriptions for each setting below can be found in
# the "config/defaults.cfg" file.
#
# Author: Chris Usey (chris.usey@gmail.com)
#
# ----------------------------------------------
# -- Model B AND mcp23017 Sample Config File --
# ----------------------------------------------
# This sample config file can be used as a starting point for configuring your
# RaspberryPi Model B with a mcp23017 Port Expander to add 16 additional GPIO to your project.
# This sample configures the RaspberryPi to use 8 GPIO of the RaspberryPi Model B and
# an additional 16 GPIO of the mcp23017 Port expander for a total of 24 channels.

# mcp23017 Chip Addressing
# The following details how you might wire up a mcp23017 port expander to the raspberry Pi
#
#       RpiPin              mcp23017 PINOUT              RpiPin
#  _______________|_________________________________|_______________
#                 |             ___  ___            |
#                 |            |   ()   |           |
#                 |   GPB0 <-> | 1   28 | <-> GPA7  |
#                 |   GPB1 <-> | 2   27 | <-> GPA6  |
#                 |   GPB2 <-> | 3   26 | <-> GPA5  |
#                 |   GPB3 <-> | 4   25 | <-> GPA4  |
#                 |   GPB4 <-> | 5   24 | <-> GPA3  |
#                 |   GPB5 <-> | 6   23 | <-> GPA2  |
#                 |   GPB6 <-> | 7   23 | <-> GPA1  |
#                 |   GPB7 <-> | 8   22 | <-> GPA0  |
#     3.3v        |    VDD --> | 9   20 | --> INTA  |
#     GND         |    VSS --> | 10  19 | --> INTB  |
#                 |     NC --- | 11  18 | --> RESET |     3.3v
#     5 (SCL)     |    SCL --> | 12  17 | <-- A2    |     GND
#     3 (SDA)     |    SDA <-> | 13  16 | <-- A1    |     GND
#                 |     NC --- | 14  15 | <-- A0    |     GND
#                 |            |________|           |
#
#
# PINS A0,A1,A2 determine the address assigned to the device. The diagram above sets the address i2c_address
# to 0x20. To achieve a different address set the pins as follows:
#
# 0x20 = A0(GND)   A1(GND)   A2(GND)
# 0x21 = A0(GND)   A1(GND)   A2(3.3v)
# 0x22 = A0(GND)   A1(3.3v)  A2(GND)
# 0x23 = A0(GND)   A1(3.3v)  A2(3.3v)
# 0x24 = A0(3.3v)  A1(GND)   A2(GND)
# 0x25 = A0(3.3v)  A1(GND)   A2(3.3v)
# 0x26 = A0(3.3v)  A1(3.3v)  A2(GND)
# 0x27 = A0(3.3v)  A1(3.3v)  A2(3.3v)



[hardware]

# Enable the mcp23017 port expander and set it's pin base as 65 with a chip address of 0x20
# for more information on chip addressing see notes above.
devices = {
        "mcp23017": [
            {
                "pinBase": "65",
                "i2cAddress": "0x20"
            }
        ]
    }

# GPIO Pins
gpio_pins = 0,1,2,3,4,5,6,7,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80
# Set the mode the pins should be configured in, namely "pwm" for fading in and
# out based upon the frequency response, or "onoff" for an on off switching
# effect when crossing a median frequency response per channel.
#
# Note: Mechanical relays will likely fail much sooner in "pwm" mode, it is
# suggested to only use pwm mode if using solid state relays (SSR).
#
# You can configure each pin individually, for example:
#pin_modes = onoff,onoff,pwm,pwm,pwm,onoff,onoff
#
# Or you can simply set all pins to the same mode:
pin_modes = onoff

# We use the wiringPi's software pwm library for "pwm" fading:
#
# https://projects.drogon.net/raspberry-pi/wiringpi/software-pwm-library/
#
# TODO(todd giles): Add a page to the wiki with examples of different types of lights and
# relays and the effect produced for various PWM ranges.  The text below should be taken
# with a grain of salt as I have not been able to test as completely as I'd like to yet.
#
# Change the pwm range used for this software pwm by changing this setting.  The optimal
# setting really depends on your hardware setup.  If you are using zero-cross relays and
# driving an AC load then using a pwm range of 500 gives decent results (flickering
# effect for many led lights with input rectifiers, and a decent fade for incandescents).
# A range of 500 generates a 20Hz pwm frequency.
#
# If you have random cross relays that can shut-off / on at any time then going for a
# 60 Hz pwm frequency can be advantageous, although timing this to the actual zero crossings
# of the power line used will give the best fading effect - again with incandescent bulbs.
# A range of 167 approximately generates a 60Hz pwm frequency.
#
# If you are attempting to fade a DC led load then the default range of 100 which gives a
# 100Hz pwm frequency works fine.
pwm_range = 100

# If you are using a piGlow set this to True and use the example in lightshowpi/contrib
# set device and gpio_pins
piglow = False

[configs]
# Define more config files for additional functionality

# Add one or more LED RGB Pixel configuration file(s) see led1.defaults.cfg
# copy led1.defaults.cfg to led1.cfg, customize, and set led_config = led1.cfg
# SPI ( direct from Pi pins ), Serial USB ( AllPixel, Arduino ), or sACN ( network device )
# led_config = led1.cfg
# led_config = led1.cfg,led2.cfg
led_config =

# Turn on multiprocessing for LED processes ( experimental ) default = False
led_multiprocess = False

[fm]
# By setting fm to true it will output the fm signal on pin 7 (GPCLK0)
# otherwise will result in output through the line out port
# frequency is the fm channel to play on
fm = False
frequency = 100.1

# Display RDS text on supported radios (Raspberry Pi 2 and newer supported)
# Program Service Name (Most radios support this)
# Strings longer than 8 characters will display in increments of 8 characters
program_service_name = LSPi
# Set the wait (in seconds) before continuing onto the next 8 characters
ps_increment_delay = 3.5

# Radio text - Limited to 64 characters
# Set as playlist to display the name of the current playing song when using a playlist
radio_text = playlist

[lightshow]
# We support the following modes for running light shows:

# ---------------------------------------------------------------
# 'playlist' mode specific configurations for the lightshow
# ---------------------------------------------------------------
# Play song files on the RPi from the playlist as defined below, with
# the preshow defined before each song. (default)
mode = playlist

# The playlist_path defines the path to the .playlist file.  The .playlist file
# is a text file that contains a list of what songs should be included in the show
# and is in the format:
# [song_name1] <tab> [/full/path/to/song]
# [song_name2] <tab> [/full/path/to/song]
# A sample of how this should be configured can be found in $SYNCHRONIZED_LIGHTS_HOME/music/sample/
# To create your own playlist simply create a .playlist file with the songs desired and set the
# playlist_path accordingly.

# SMS NOTE: the song name that you define in the playlist can be anything you desire, the song name
# is what users will see when listing the songs via SMS.
playlist_path = $SYNCHRONIZED_LIGHTS_HOME/music/sample/.playlist

# Set the following setting to 'yes' to randomize playback of songs from the
# playlist.  Default is to play the songs in the order listed in the playlist.
randomize_playlist = no

# Set songname_command to any command that can use the first argument as the song name
# Leave blank to disable
# See documentation in tweet.py to configure Twitter
#songname_command = python $SYNCHRONIZED_LIGHTS_HOME/py/tweet.py
#songname_command = echo
songname_command =

# ---------------------------------------------------------------
# 'audio-in' mode specific configurations for the lightshow
# ---------------------------------------------------------------
# Control the lightshow from an audio stream coming from a usb-audio dongle
# See http://lightshowpi.org/usb-audio-in-support/ for
# more details on using audio-in mode.
# mode = audio-in

# The name of the input audio card to use, by default use the default system
# audio input device.  You can override this to another card by setting it to the
# name found from the audio_in_cards.py script (in tools directory).
audio_in_card = default

# ---------------------------------------------------------------
# 'stream-in' mode specific configurations for the lightshow
# ---------------------------------------------------------------
# Control the lightshow from an audio stream coming from a streaming source
# You will need to set input_channels = 2 and input_sample_rate = ( usually 44100 )
# mode = stream-in

# this example will play a shoutcast/icecast stream
stream_command_string = sudo mpg123 --stdout http://193.34.51.115:80

# Example using Shairport Sync to stream AirPlay https://github.com/mikebrady/shairport-sync
# stream_command_string = shairport-sync -v -o stdout

# You can also use a fifo to get streams like Pandora from players like pianobar

# stream_command_string = pianobar
# NOTE: To use pianobar you must set it up to auto login and auto play a station
# refer to this post for an example pianobar config to do this
# http://ubuntuforums.org/showthread.php?t=1533357&p=9746309#post9746309

# A basic pianobar config that will allow you to login and autostart a station
# is included in lightshowpi/config/contrib
# You will need to place in the root users folder
# /root/.config/pianobar/config

# lightshow fifo settings.  Used with stream-in option.

# To use a fifo you will need to add an alsa plugin to /etc/asound.conf
# A copy of the plugin is included in lightshowpi/config/contrib
use_fifo = False

# Song count and exit. Used with stream-in option.
#
# Set your stream_song_delim to match a pattern in your stream output.
# examples are provided for pianobar and icecast metadata updates.
# occurences of these patterns will indicate a new song.
# stream_song_delim = |>  "
stream_song_delim = ICY-META: StreamTitle=
# Set stream_song_exit_count = number of songs to play before exiting. zero disables.
stream_song_exit_count = 0

# ---------------------------------------------------------------
# mode specific configurations shared by audio-in and stream-in
# ---------------------------------------------------------------
# The number of input channels, usb dongle or stream, typically 1 or 2:
#   1 - mono / mic input
#   2 - stereo input / stream
input_channels = 1

# The rate at which to sample input from the usb dongle or stream
#  48000 - mic input
#  44100 - stream input
input_sample_rate = 48000

# ---------------------------------------------------------------
# audio_out_card configuration for the lightshow
# ---------------------------------------------------------------
# The name of the output audio card to use, by default use the default system
# audio output device.  You can override this to another card by setting it to the
# name found from the audio_in_cards.py script (in tools directory).
# Another way to get the name of the card to use and the proper format to use is to run
# aplay -L | grep default
# on the command line and copy the part of the output you need, as an example this command
# tells me that the default Alsa card built into the RPI is
# sysdefault:CARD=ALSA
# and that my usb sound card is
# sysdefault:CARD=Device

# If you are using a usb sound card and do not want to set is as the default,
# you can just set it here and not have to edit your alsa-base.conf / alsa.conf files
# All of this applies to audio_in_card as well
audio_out_card = default

# ---------------------------------------------------------------
# preshow config
# ---------------------------------------------------------------
# Control the lights between songs.  You can turn the lights on and off a specified number of
# seconds an arbitrary number of times and play and audio file with the preshow_configuration setting.
# If no preshow_configuration is defined, songs will be played one after another without any delay.
# Individual channels can be controlled per transition defined by adding the channel_control option.
# The transition type will specify if all lights should be turned on, or turned off, and the
# channel_control will override the transition type so that specific channels can be controlled
# regardless of the transition type. Channels defined in the channel_control list are 1 based
# (i.e. the first channel starts at 1)  The preshow_configuration is defined as a JSON formatted object.
# If defining the object on more than one line, pay attention to spacing and tabs as the object
# should follow python conventions for indentation.  If you get an error, chances are your object is
# not formatted correctly or your indentation is not correct. You can check if your JSON is valid by
# using an online validator such as http://jsonlint.com.

# SPECIAL NOTE: Defining a channel_control WILL supersede any channels that are defined in always_on_channels
# or always_off_channels below.

#The syntax is:
#preshow_configuration =
#	{
#		"transitions": [
#			{
#				"type": "< off|on >",
#				"duration": < seconds >,
#				"channel_control": {
#					"< off|on >": [< channel >,< channel >,....]
#				}
#			},
#			{
#				"type": "< off|on >",
#				"duration": < seconds >,
#				"channel_control": {
#					"< off|on >": [< channel >,< channel >,....]
#				}
#			}
#		],
#		"audio_file": "</path/to/audio_file> or null if no audio"
#	}

# Turn the lights on for 30 seconds, leaving channel 3 off during the "on" transition, then
# turn the lights off for 5 seconds, leaving channel 1 and 3 on during the "off" transition
#preshow_configuration =
#	{
#		"transitions": [
#			{
#				"type": "on",
#				"duration": 30,
#				"channel_control": {
#					"off": [3]
#				}
#			},
#			{
#				"type": "off",
#				"duration": 5,
#				"channel_control": {
#					"on": [1,3]
#				}
#			}
#		]
#	}

# You also have the option to run a custom script that will do anything you can
# think of. We have included a few examples in $SYNCHRONIZED_LIGHTS_HOME/py/example_scripts
# to use this feature
#preshow_script = /full/path/to/your/script.py
# this will override the preshow_configuration
# and use the specified script
# Disable the preshow altogether:
#preshow_script =
#preshow_configuration =

# Default is to be on for 10 seconds and off for 1 with no channel_control overrides
# no audio played.
preshow_script =
preshow_configuration =
	{
		"transitions": [
			{
				"type": "on",
				"duration": 10,
				"channel_control": {
				}
			},
			{
				"type": "off",
				"duration": 1,
				"channel_control": {
				}
			}
		],
		"audio_file": null
	}

# ---------------------------------------------------------------
# postshow config
# ---------------------------------------------------------------
# postshow configuration is identical to the preshow configuration
# see above for syntax
# Default is to be disabled
# no audio played.
postshow_script =
postshow_configuration =

# ---------------------------------------------------------------
# common lightshow configuration options (affects multiple modes)
# ---------------------------------------------------------------

# Override channels to be always on, always off, or inverted. inverted channels
# will turn off when music is played, and on otherwise.  These lists are 1
# based (i.e. the first channel starts at 1).

# Always keep channels 2 and 6 on:
#always_on_channels = 2,6

# Always keep channel 5 off:
#always_off_channels = 5

# Invert the output for channel 4 and 8:
#invert_channels = 4,8

# Default (-1) disables each of these settings
always_on_channels = -1
always_off_channels = -1
invert_channels = -1

# Allow lights to become less "blinky" by fading out after a peak response
# Typical values should be in the range of 0.05 to 0.20
# Smaller values will cause the lights to remain on longer
# Setting decay_factor to 0 will disable this functionality
decay_factor = 0

# ---------------------------------------------------------------
# attenuate percentage
# ---------------------------------------------------------------

# Lower the response value for the lights by a percentage
# Typical values should be in the range of 20-50
# Higher values will cause the lights to be more off than on in onoff mode
# Setting attenuate_pct to 0 will disable this functionality
attenuate_pct = 0

# ---------------------------------------------------------------
# Standard Deviation
# ---------------------------------------------------------------

# Once the mean audio level and standard deviation is calculated for a channel
# the standard deviation is used to determine the range of audio levels that
# change the brightness level of the light(s) on that channel (presuming PWM is enabled).
#
# If the audio level is less than (mean - SD_low), lights will be off.
# If the audio level is more than (mean + SD_high), lights will be at maximum brightness.
# Between these two values, the brightness will be set proportionate to where the audio
# level falls in this range.
#
# SD_low=0.5 and SD_high=0.75 preserve the original behavior by default.

SD_low = 0.5
SD_high = 0.75

# light_delay is the number of seconds the light display is delayed from the input audio
# use zero for an audio device output. Typically this is less than 1.0
light_delay = 0.0

# Set the logging level of the lightshow module
# DEBUG
# INFO
# WARNING
# ERROR
# CRITICAL
log_level = INFO

[audio_processing]
# Note: You may have to delete the song cache after changing these settings.

chunk_size = 2048

# The following values control the frequencies to which the channels will
# respond. With min_frequency being the lowest frequency for which a channel
# will be activated and max_frequency being the max frequency for which a
# channel will be activated.

# The frequency range will be evenly divided between all the channels defined
# in gpio_pins.

# Note that custom_channel_frequencies overrides these settings.
min_frequency = 20
max_frequency = 15000

# The following setting can be used to custom map the channels, in effect
# this can programmatically allow you to switch a specific channel of
# lights to a different frequency without having to physically rewire the
# channels.

# For example: Imagine we have 8 channel's output that are connected to
# corresponding gpio_pins. When the frequencies are mapped without using
# custom_channel_mapping, and with a channel mapping defined as:
#custom_channel_mapping = 1,2,3,4,5,6,7,8
# the lowest frequency is assigned to channel 1, the next highest to channel
# 2, and so on until the highest value is mapped to channel 8 (the 8th pin
# defined in gpio_pins).

# Now say you wanted your THIRD channel to have the lowest frequency, without
# using custom_channel_mapping you would have to physically rewire channel 3.
# With custom channel mapping you simply define:
#custom_channel_mapping = 1,2,1,4,5,6,7,8
# Now both channel 1 and channel 3 will activated when the lowest frequency is
# played. custom_channel_mapping must be the same size as gpio_pins.

# If you want to create a mirroring effect for the lights define:
#custom_channel_mapping = 1,2,3,4,4,3,2,1
# With custom channel mapping the program will only calculate and distribute
# frequencies for the highest channel listed in custom_channel_mapping. So in
# this mirroring example, the program will evenly distribute the frequencies.

# The default is not to define custom channel mapping and let the program
# map the channels 1:1
custom_channel_mapping =


# Defining custom_channel_frequencies overrides the min_frequency and
# max_frequency settings, allowing you to define a custom list of frequencies
# that should be utilized for each channel. The list must be the size of
# (gpio_pins + 1) or if custom_channel_mapping is being used it must be the
# size of the max value + 1 in the custom_channel_mapping list.
#custom_channel_frequencies = 0,156,313,625,1250,2500,5000,10000,15000
# Raspberry Pi Model B+
#custom_channel_frequencies = 0,833,1666,2499,3332,4165,4998,5831,6664,7497,8330,9163,10829,11662,12495,13328,14161,15000
custom_channel_frequencies =

[sms]
# If you desire to use SMS set to True, otherwise set this variable to False
enable = False

# Set the logging level of the sms module
# DEBUG
# INFO
# WARNING
# ERROR
# CRITICAL
log_level = INFO

# All enabled sms commands must be defined here, otherwise they will be
# reported as errors when requested. Note: Each command must be defined in the
# 'py/sms_commands.py' file as a function. See that file for examples.
commands = help,volume,play,vote,list

# Commands can have aliases defined here.  IMPORTANT: Make sure that the
# aliases are defined with the longest aliases first, otherwise the shorter
# alias may win out and pass along part of the longer alias as if it were
# an argument to the command (e.g. vol, v and not v, vol)
#
# TODO(todd giles): Add auto-aliases based upon best match from all commands
help_aliases = h
volume_aliases = vol, v
play_aliases = p, next, n
list_aliases = l, songs

# Short description of each command (returned in help request).  Leave
# the description blank to not have it returned in help requests.
help_description =
volume_description = vol<level>: vol+, vol-, v95
play_description = play<song#>: play3, p3
vote_description = vote<song#>: vote1, or simply 1
list_description = list: lists all songs

# Configuration options for the list command.
# Note: There is a SMS character limit for most carriers, your message may
# still be chopped into multiple text's.
# The number of songs to return per sms message
list_songs_per_sms = 4
# The number of songs to return in a list
list_songs_per_page = 4


# The default command is the command assumed when the sms message doesn't
# match any given command or command alias.
default_command = vote

# Multiple groups can be defined to fine tune which users can execute
# which actions. For each group defined, you should also define a
# group_name_users to list all users in the group as well as
# group_name_commands to list all commands the group can perform.
groups = admin,guest,voting

# For each group defined above, include the cell # for each member of
# the group.  A cell # can be in multiple groups. Note the format of the
# numbers: "+15555555555:".  The special term 'all' can be used to create
# groups that apply to all cell #'s.
admin_users = +11111111111:,+12222222222:
guest_users = +13333333333:
voting_users = all

# Specify which commands each group has access to. Each command must be
# defined in 'commands' above. The special term 'all' includes all defined
# commands.
admin_commands = all
guest_commands = play
voting_commands = help,vote,list

# For each group defined above, throttling of commands can be achieved
# by defining [command]:<command limit> for each command and limit you
# wish to place a throttle on.  Each command must be defined in 'commands'
# above. The special term 'all' can be used to place an overall throttle on
# group as a whole, and will limit the group to a specific number of commands
# than can be used during 'throttle_time_limit_seconds'. Note that the order in which
# 'groups' above is important (see note for groups above). If a user is defined
# in more than one group, the user will be throttled at the highest group level.
# that they belong to.
throttle_time_limit_seconds = 3200
admin_throttle = all:100
guest_throttle = play:10,vote:60,all:100
voting_throttle = vote:10,all:100

# Add users who are abusing your system to this blacklist, and their commands
# will all be ignored by the application.
blacklist = +14444444444:,+15555555555:

# The response given to an unknown command (i.e. the default command does
# not know how to handle it, and it doesn't match any other commands).
unknown_command_response = Hrm, not sure what you needed, try texting 'help' ...

# The response given to an unauthorized request.
unauthorized_response = Hrm, not sure what you needed, try texting 'help' ...

# The response given when throttle limits have been reached
throttle_limit_reached_response = Thank you, but the system has reached its maximum number of requests for the time being. Please try again in a little while.


[network]
#network streaming
# The default mode for network streaming is be turned "off".
# For your pi to broadcast or receive you must set one pi in your network to
# be the server and any number to be clients
# options off, server, client, serverjson
networking = off

# default port is 8888
# you can set this to any port of your choosing, just make sure that it
# does not interfere with other systems that might be on your network
# If you do change the default, you must change it on all systems that
# you have setup, the server pi and any client pi
port = 8888

# The buffer option determines the length of your receive buffer
# if the buffer is to small you will receive pickle errors (data is pickled
# before sending) if the buffer is to large it can cause your show to go out of
# sync.  The default is 1024 and is large enough for 16 channels.  If you add
# more channels you will need to increase this value.  It is best to use a
# multiple of 8
buffer = 1024

# Channels
# Affects clients only
#
# The clients default default behavior is for a client to mirror the lightshow
# with all available channels available to the client. This also assumes the
# server and the client have at the least the same number of channels defined.
# The server can have more channels defined, but the client cannot, at least
# for this default configuration to work.
#
# You can have more channels on the client but you must index them to one of the
# existing channels being broadcast by the server.
# Example
# channels = 0,1,2,3,4,5,6,7,0,1,2,3,4,5,6,7
#
# The channels option is index based and starts at 0, this means that the pin numbers
# in the gpio_pins options does not matter, only the index number does.
# It starts at 0 and will increase by one for each channel.
# 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,etc..........
#
# You can omit channels and even duplicate channels.
# Examples

# If a server has 32 channels it will broadcast the data for all 32 channels,
# but if a client only has 8 channels it will only playback the data for the first
# 8 channels, also clients can not playback data for more channels then the server
# can supply so having a client with 16 channels and a server with only 8 is not very
# useful in a simple mirroring setup.
# Use this setting to tell your client which channels to use
# channels are list based and start at 0
# 0,1,2,3,4,5,6,7 = 8 channels
# 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15 = 16 channels
#
# These channels must be defined on you server, but do not need to be real channels
# You can simply add virtual channels to your server by adding to gpio_pins option
# in the "[hardware]" section.
# Define your real channels first, then add any number of virtual channels that you
# want after that
# example
# you have 8 real channels on your server, and add 8 virtual channels to display
# on your client
# on the server do this
# gpio_pins = 0,1,2,3,4,5,6,7,100,101,102,103,104,105,106,107
# just pick unused pin numbers, 100 seems like a good place to start as pins
# above 100 do not exist, you can use any starting point you wish, but I recommend
# following the guidelines for using expander chips as a starting point
# After that you can send the virtual channels to your client and they will be displayed
#
# These channels will be mapped to the channels on the client
# in order, starting with the first available channel on the client
# The incoming channels from the server wil be mapped as you list them
#
# One last option is to not use a channel on the client
# just insert a negative number as the input channel and it will no
# longer be used.  Use any number less then 0 (negative)
# in this example channels 2 4 and 6 on the client will not be used
# channels = 0,1,-2,3,-4,5,-6,7

channels =

[terminal]
# This boolean if set to True will disable sending brightness values to your hardware,
# and instead send them to a curses based terminal window renderer that will dynamically
# render columns of channel brightness values.
# https://docs.python.org/2/howto/curses.html
# https://en.wikipedia.org/wiki/Curses_(programming_library)
# This allows you to shake out the audio to brightness pipeline without having to hang
# your hardware off the pi.
# Launch synchonized_lights.py with the same command line as you normally would, and the
# active terminal will be used to render.
# The curses instance is launched in a way that ensures any runtime errors or tracebacks
# are still dumped on return to the normal command line.
enabled = False