def __init__(self):
pygame.init()
self.power = True
self.decoder = IRDecoder()
self.parser = SignalParser(ser)
self.music_controller = MusicController()
self.led_controller = LEDController()
self.music_controller.initialize()
def __init__(self):
self.is_loaded = False
self.is_playing = False
self.queue = MusicQueue()
self.mixer_context = pygame.mixer.music
self.songs_to_play = []
self.queue_pos = 0
self.max_song_queue_pos = 0
self.led_toggler = LEDController()
self.volume_context = 0.5
def main():
lirc.init("ledsign")
parent_pipe, child_pipe = Pipe()
remote_event = Event()
param_event = Event()
LED = LEDController()
context = LEDContext(param_event, remote_event, child_pipe)
p = Process(target=LED.process, args=(context, ))
p.daemon = False
p.start()
# time.sleep(2)
print('starting IR')
while 1:
c = get_input(False)
if len(c) > 0:
cmd = c[0]
print(c[0], 'IR process')
#
if cmd == 'up' or cmd == 'down' or cmd == 'left' or cmd == 'right' or cmd == 'vol_up' or cmd == 'vol_down' or cmd == 'back':
print('setting p')
context.param_event.set()
else:
context.remote_event.set()
parent_pipe.send(cmd)
# if cmd == 'restart':
# break
# time.sleep(0.02)
p.join()
class MusicController():
def __init__(self):
self.is_loaded = False
self.is_playing = False
self.queue = MusicQueue()
self.mixer_context = pygame.mixer.music
self.songs_to_play = []
self.queue_pos = 0
self.max_song_queue_pos = 0
self.led_toggler = LEDController()
self.volume_context = 0.5
def initialize(self):
pygame.mixer.init()
print("Initializing MuseBox...")
self.mixer_context.stop()
self.is_playing = False
self.is_loaded = False
#self.queue.reset_songs()
def play_music(self):
if (not self.is_loaded):
# Load music and play
print("Loading music...")
self.songs_to_play = self.queue.get_songs(limit=100)
self.max_song_queue_pos = len(self.songs_to_play)
selected_song = self.songs_to_play[self.queue_pos]
self.mixer_context.load(selected_song)
self.mixer_context.set_volume(self.volume_context)
print("Playing song: {0}".format(selected_song))
self.mixer_context.play()
self.mixer_context.set_endevent(NEXT_SONG)
self.is_loaded = True
self.is_playing = True
elif (self.is_loaded):
# Music is already loaded, assume in progress and unpause
print("Resuming music...")
self.mixer_context.unpause()
self.is_playing = True
self.led_toggler.playing()
return
def pause_music(self):
if (self.is_playing):
print("Pausing music...")
self.mixer_context.pause()
self.is_playing = False
self.led_toggler.paused()
return
def toggle(self):
if (self.is_playing):
self.pause_music()
else:
self.play_music()
def resume_from_queue(self):
self.queue_pos += 1
self.show_song()
self.mixer_context.load(self.songs_to_play[self.queue_pos])
self.is_loaded = True
self.mixer_context.play()
self.is_playing = True
self.led_toggler.playing()
return
def next_song(self):
'''
Try to play from queue if there are songs left.
Otherwise, requeue songs and play.
'''
print("Playing next song...")
if (self.is_loaded):
if (self.queue_pos + 1 < self.max_song_queue_pos):
self.mixer_context.stop()
self.is_loaded = False
self.is_playing = False
self.resume_from_queue()
else:
self.queue_pos = 0
self.mixer_context.stop()
self.is_loaded = False
self.is_playing = False
self.play_music()
else:
self.play_music()
return
def rewind_current_song(self):
'''
Restarts the currently playing song.
'''
if (self.is_playing):
print("Restarting song")
self.mixer_context.rewind()
else:
print("Nothing to rewind")
return
def previous_song(self):
'''
Play the song that played before the current song, if the queue
supports this action.
Caveats:
'''
if (self.is_loaded):
print("Playing previous song...")
if (self.queue_pos >= 1):
self.is_loaded = False
self.is_playing = False
self.queue_pos -= 1
self.show_song()
self.mixer_context.load(self.songs_to_play[self.queue_pos])
self.is_loaded = True
self.mixer_context.play()
self.is_playing = True
self.led_toggler.playing()
else:
print("No previous song in queue.")
else:
print("no songs loaded.")
return
def show_song(self):
print("Playing song: {0}".format(self.songs_to_play[self.queue_pos]))
def volume_up(self):
current_volume = self.mixer_context.get_volume()
new_volume = 0
if (current_volume + 0.1 < 1.0):
new_volume = current_volume + 0.1
else:
new_volume = 1.0
print("new volume after up is: {0}".format(new_volume))
self.volume_context = new_volume
self.mixer_context.set_volume(self.volume_context)
def volume_down(self):
current_volume = self.mixer_context.get_volume()
new_volume = 0
if (current_volume - 0.1 > 0.0):
new_volume = current_volume - 0.1
else:
new_volume = 0
print("new volume after down is: {0}".format(new_volume))
self.volume_context = new_volume
self.mixer_context.set_volume(self.volume_context)
def reset(self):
'''
Resets everything related to this object. Turns off all
of the Raspberry Pi lights. Also uninitializes
the pygame mixer. Before using MuseBox again, initialize
must be called on the MusicController object.
Does NOT destory the actual MusicController object.
This is because we need to preserve the volume setting.
'''
self.mixer_context.stop()
self.is_loaded = False
self.is_playing = True
self.queue_pos = 0
self.led_toggler.turn_off_all_lights()
pygame.mixer.quit()
return
import time
from LEDController import LEDController
led = LEDController()
try:
led.setRed(255)
time.sleep(1)
except KeyboardInterrupt:
pass
except:
raise
finally:
led.clear()
import time, curses
from LEDController import LEDController
led = LEDController()
red = 0
green = 0
blue = 0
step = 15
def onInput(char):
global red
global green
global blue
############################################
try:
win = curses.initscr()
curses.noecho()
while True:
char = chr(win.getch())
if char in '1235789': onInput(char)
# Empty spaces are to overwrite larger numbers
win.addstr(0, 0, 'R: ' + str(red) + ' ')
win.addstr(1, 0, 'G: ' + str(green) + ' ')
win.addstr(2, 0, 'B: ' + str(blue) + ' ')
import time
from LEDController import LEDController
led = LEDController()
try:
led.setRed(255)
for i in range(255):
led.setRed(255 - i)
led.setBlue(i)
time.sleep(0.02)
for i in range(255):
led.setBlue(255 - i)
led.setGreen(i)
time.sleep(0.02)
for i in range(255):
led.setGreen(255 - i)
led.setRed(i)
time.sleep(0.02)
time.sleep(0.5)
except KeyboardInterrupt:
pass
except:
raise
finally:
led.clear()
#!/usr/bin/env python
import sys
import time
from LEDController import LEDController
LEDs = LEDController()
LED_command = ''
if len(sys.argv) > 1:
LED_command = sys.argv[1]
try:
if LED_command = 'color_wipe':
LEDs.color_wipe(LEDs.color(0, 0, 255), 0.0) # Blue color wipe
elif LED_command == 'rainbow_cycle'
LEDs.rainbow_cycle(0.00)
else:
LEDs.set_all_pixels(0, 0, 255) # Blue color
LEDs.clear()
except KeyboardInterrupt:
LEDs.clear()
sys.exit(0)
# This file converts the SSH command sent to the device into usable data for the Raspberry Pi.
# The name cannot be changed as it is explicitly defined in the HomeRemote app.
# Also, the "if(arg == "max")" statements have explicitly defined test strings (max, min, stepUp, stepDown).
# These are explicitly defined in the HomeRemote app and should not be modified.
# However, anything else can be modified. HomeRemote simply provides a platform to execute your own code from a remote.
import sys
import time
from LEDController import LEDController
# LEDController uses the Stepper Remote, which takes in one argument.
arg = sys.argv[1]
# Create the LEDController object that will manage the LED.
ledObject = LEDController()
# Based on the argument in the command, tell the LEDController to do something.
# You CANNOT change the equality tests in the if statement.
# The test strings are explicitly defined in the HomeRemote app and cannot be modified.
if (arg == "max"):
ledObject.max()
elif (arg == "min"):
proxymotor.min()
elif (arg == "stepUp"):
print(proxymotor.inchesMotorMover(float(arg1), float(arg2)))
elif (arg == "stepDown"):
print(proxymotor.radecScan(float(arg1), float(arg2)))
exit()
import time
from LEDController import LEDController
led = LEDController()
try:
led.setRed(255)
led.setGreen(0)
led.setBlue(0)
time.sleep(5)
except KeyboardInterrupt:
pass
except:
raise
finally:
led.clear()
class MuseBox():
def __init__(self):
pygame.init()
self.power = True
self.decoder = IRDecoder()
self.parser = SignalParser(ser)
self.music_controller = MusicController()
self.led_controller = LEDController()
self.music_controller.initialize()
def toggle_power(self):
if (self.power):
# turn off if power is on
self.music_controller.reset()
self.led_controller.toggle_power_off_light(0)
else:
# turn on if power is off
self.music_controller.initialize()
self.led_controller.toggle_power_off_light(1)
self.power = not self.power
# wait and poll forever until power is restored
while (not self.power):
if (ser.inWaiting()):
serial_line_result = ser.read_until(b'70')
ser.flushInput()
sig_recv = self.decoder.decode(serial_line_result, True)
parse_result = self.parser.parse(sig_recv)
if (parse_result == 'x'):
self.led_controller.blink_processing_light()
self.toggle_power()
def process_loop(self):
while (self.power):
if (ser.inWaiting()):
serial_line_result = ser.read_until(b'70')
ser.flushInput()
sig_recv = self.decoder.decode(serial_line_result, True)
if (self.parser.is_valid(sig_recv)):
parse_result = self.parser.parse(sig_recv)
if (parse_result == 'p'):
self.led_controller.blink_processing_light()
self.music_controller.toggle()
elif (parse_result == 'n'):
self.led_controller.blink_processing_light()
self.music_controller.next_song()
elif (parse_result == 'x'):
self.led_controller.blink_processing_light()
self.toggle_power()
elif (parse_result == 'u'):
# volume up
self.led_controller.blink_processing_light()
self.music_controller.volume_up()
pass
elif (parse_result == 'd'):
# volume down
self.led_controller.blink_processing_light()
self.music_controller.volume_down()
pass
elif (parse_result == 'r'):
# rewind/back button
self.led_controller.blink_processing_light()
self.music_controller.rewind_current_song()
elif (parse_result == 'b'):
self.led_controller.blink_processing_light()
self.music_controller.previous_song()
else:
# Invalid code, show error
self.led_controller.blink_error_light()
for event in pygame.event.get():
if event.type == NEXT_SONG:
self.music_controller.next_song()
from LEDController import LEDController
from flask import Flask, request
ledControl = LEDController()
app = Flask(__name__)
"""
This code receives commands from IFTTT and executes the commands on the pi
"""
@app.route('/', methods=['POST', 'GET'])
def index():
return 'Choose Option'
@app.route('/test_cmd', methods=['POST', 'GET'])
def test_cmd():
print("Test cmd done")
return "Test cmd done"
@app.route('/set_color', methods=['POST'])
def set_color():
color = request.args.get('color')
ledControl.set_color(color)
print("setting color to" + str(color))
return ("setting color to" + str(color))
def start_server():
app.run(debug=False, host='0.0.0.0', port=7000)