def on_start(self):
self.knob = RotaryEncoder(UP_SWITCH, DOWN_SWITCH, 25,
self.encode_event, 2)
self.waiter = Waiter.start(self.actor_ref)
self.tracks = self.mopidy.tracklist.get_tl_tracks()
first_track = self.mopidy.playback.get_current_tl_track()
self._display_track(first_track)
def setRotaryInterface(self):
global tunerknob
global volumeknob
# Internal pullup resistors can be disabled for rotary encoders (eg KY-040)
# with their own pullup resistors. See rotary_gpio_pullup in radiod.conf
if self.config.rotary_class == self.config.ALTERNATIVE:
log.message("event.setInterface RotaryEncoder ALTERNATIVE",
log.DEBUG)
volumeknob = RotaryEncoderAlternative(self.left_switch,
self.right_switch,
self.mute_switch,
self.volume_event)
tunerknob = RotaryEncoderAlternative(self.down_switch,
self.up_switch,
self.menu_switch,
self.tuner_event)
elif self.config.rotary_class == self.config.STANDARD:
log.message("event.setInterface RotaryEncoder STANDARD", log.DEBUG)
volumeknob = RotaryEncoder(self.left_switch,
self.right_switch,
self.mute_switch,
self.volume_event,
pullup=self.config.rotary_gpio_pullup)
tunerknob = RotaryEncoder(self.down_switch,
self.up_switch,
self.menu_switch,
self.tuner_event,
pullup=self.config.rotary_gpio_pullup)
msg = "Volume knob", self.left_switch, self.right_switch, self.mute_switch
log.message(msg, log.DEBUG)
msg = "Tuner knob", self.down_switch, self.up_switch, self.menu_switch
log.message(msg, log.DEBUG)
return
def __init__(self):
RotaryEncoder(self.scrollUp,
self.scrollDown,
self.wheelButton,
callback=self.changeEvent)
GPIO.add_event_detect(self.schalter,
GPIO.BOTH,
callback=self.changeAlarm)
GPIO.add_event_detect(self.pauseButton,
GPIO.BOTH,
callback=self.pauseAlarm)
GPIO.add_event_detect(self.stopButton,
GPIO.BOTH,
callback=self.stopAlarm)
def setCosmicInterface(self):
from cosmic_class import Button
global volumeknob
global left_button, right_button, mute_button
global up_button, down_button, menu_button
log.message("event.setInterface Cosmic interface", log.DEBUG)
# Buttons
down_button = Button(self.down_switch, self.button_event, log)
up_button = Button(self.up_switch, self.button_event, log)
menu_button = Button(self.menu_switch, self.button_event, log)
# Rotary encoder
volumeknob = RotaryEncoder(self.left_switch, self.right_switch,
self.mute_switch, self.volume_event)
return
def __init__(self, events):
self.events = events
""" set up the button shutdown """
GPIO.setmode(GPIO.BCM)
GPIO.setup(ControlBoard.OFFDETECTPIN,
GPIO.IN,
pull_up_down=GPIO.PUD_UP)
GPIO.add_event_detect(ControlBoard.OFFDETECTPIN,
GPIO.FALLING,
callback=self.shutdown)
""" set up the controller knob events to change the source and menus """
self.controllerKnob = RotaryEncoder(ControlBoard.PIN_A,
ControlBoard.PIN_B,
ControlBoard.BUTTON,
self.controlKnobEvent)
print "ControlBoard._init__ > ready"
def volume_event(event):
global volumeknob, play_on
if event == RotaryEncoder.CLOCKWISE:
#print("Clockwise")
# get initial state
socketIO.emit('volume', '+')
elif event == RotaryEncoder.ANTICLOCKWISE:
#print("Anticlockwise")
socketIO.emit('volume', '-')
elif event == RotaryEncoder.BUTTONDOWN:
#print("Button down: toggle pause/play")
socketIO.emit('toggle')
elif event == RotaryEncoder.BUTTONUP:
#print("Button up")
return
# Define the switch
volumeknob = RotaryEncoder(VOLUME_UP,VOLUME_DOWN,MUTE_SWITCH,volume_event,2) # 2 = latest RPi Boards as of 2017
while True:
time.sleep(0.5)
def getConfiguration(self): global left_switch,middle_switch,right_switch global encoder_a,encoder_b,encoder_switch # Button configuration self.left_switch = config.getLeftSwitch() self.middle_switch = config.getMiddleSwitch() self.right_switch = config.getRightSwitch() # Rotary encoder configuration self.encoder_switch = config.getEncoderSwitch() self.encoder_a = config.getEncoderA() self.encoder_b = config.getEncoderB() # Set up rotary encoder with rotary_event() as the callback routine self.rotaryknob = RotaryEncoder(self.encoder_a,self.encoder_b, self.encoder_switch,self.rotary_event) # Set up buttons Button(self.left_switch, self.button_event) Button(self.middle_switch, self.button_event) Button(self.right_switch, self.button_event)
def __init__(self):
self.mpd = MPDClient()
self.lcd = TextStar('/dev/serial0', 115200)
self.lcd.quiet = True
self.menu_rotary = RotaryEncoder(UP_SWITCH, DOWN_SWITCH, MENU_SWITCH,
self.tuning_event, 2)
self.connect()
self.menus = ["Tuning", "Power", "Return"]
self.current_menu = 0
self.last_menu = len(self.menus)
self.mainMenu = Menu(title='Menu', options=self.menus)
self.playlist = ["Heart", "BBC Glos", "BBC R1"]
self.tuningMenu = Menu(title='Tuning', options=self.playlist)
self.powerMenu = Menu(title='Power', options=["Return", "Power Off"])
self.mode = self.MODE_PLAY
self.display()
elif event == RotaryEncoder.ANTICLOCKWISE:
print name + " anticlockwise", RotaryEncoder.BUTTONDOWN
elif event == RotaryEncoder.BUTTONDOWN:
print name + " button down", RotaryEncoder.BUTTONDOWN
elif event == RotaryEncoder.BUTTONUP:
print name + " button up", RotaryEncoder.BUTTONUP
return
# Allow user to select board revision
revision = 2
stderr("Are you using an old revision 1 board y/n: ")
answer = raw_input("")
if answer == 'y':
revision = 1
volumeknob = RotaryEncoder(LEFT_SWITCH,RIGHT_SWITCH,MUTE_SWITCH,volume_event,revision)
tunerknob = RotaryEncoder(UP_SWITCH,DOWN_SWITCH,MENU_SWITCH,tuner_event,revision)
print "Use Ctl-C to exit"
while True:
try:
time.sleep(0.2)
except KeyboardInterrupt:
print "\nExit"
sys.exit(0)
left_switch = left_switch_40
right_switch = right_switch_40
up_switch = up_switch_40
down_switch = down_switch_40
mute_switch = mute_switch_40
stderr("40 pin wiring version selected\n")
else:
stderr("26 pin wiring version selected\n")
stderr("Are you using GPIO10 (pin 19) for the down switch y/n: ")
answer = raw_input("")
if answer == 'y':
down_switch = dac_down_switch
stderr("Down switch is set to GPIO" + str(dac_down_switch) + "\n")
# Set up rotary encoders
volumeknob = RotaryEncoder(left_switch,right_switch,mute_switch,volume_event,revision)
tunerknob = RotaryEncoder(down_switch,up_switch,menu_switch,tuner_event,revision)
print "Use Ctl-C to exit"
while True:
try:
time.sleep(0.1)
except KeyboardInterrupt:
print "\nExit"
sys.exit(0)
# End of test rotary encoders
encoder_switch = config.getEncoderSwitch()
encoder_a = config.getEncoderA()
encoder_b = config.getEncoderB()
print("Left switch GPIO {}".format(left_switch))
print("Middle switch GPIO {}".format(middle_switch))
print("Right switch GPIO {}".format(right_switch))
print("Encoder A GPIO {}".format(encoder_a))
print("Encoder B GPIO {}".format(encoder_b))
print("Encoder switch GPIO {}".format(encoder_switch))
Button(left_switch, button_event)
Button(middle_switch, button_event)
Button(right_switch, button_event)
rotaryknob = RotaryEncoder(encoder_a, encoder_b, encoder_switch,
rotary_event)
statusLed = statusLedInitialise(statusLed)
statusLed.set(StatusLed.LED1, True)
time.sleep(1)
statusLed.clear()
statusLed.set(StatusLed.LED2, True)
time.sleep(1)
statusLed.clear()
statusLed.set(StatusLed.LED3, True)
time.sleep(1)
statusLed.clear()
time.sleep(1)
# Main wait loop
try:
def run(self):
global CurrentFile
global menu_switch_value
global volumeknob, tunerknob, statusLed, menu_switch
menu_settle = 5 # Allow menu switch to settle
log.init('radio')
signal.signal(signal.SIGTERM, signalHandler)
# Configure RGB status LED
rgb_red = radio.getRgbLed('rgb_red')
rgb_green = radio.getRgbLed('rgb_green')
rgb_blue = radio.getRgbLed('rgb_blue')
statusLed = StatusLed(rgb_red, rgb_green, rgb_blue)
statusLed.set(StatusLed.BUSY)
progcall = str(sys.argv)
log.message('Radio running pid ' + str(os.getpid()), log.INFO)
log.message(
"Radio " + progcall + " daemon version " + radio.getVersion(),
log.INFO)
log.message("GPIO version " + str(GPIO.VERSION), log.INFO)
hostname = exec_cmd('hostname')
ipaddr = exec_cmd('hostname -I')
# Display daemon pid on the LCD
message = "Radio pid " + str(os.getpid())
# Wait for the IP network
ipaddr = ""
waiting4network = True
count = 10
while waiting4network:
ipaddr = exec_cmd('hostname -I')
time.sleep(1)
count -= 1
if (count < 0) or (len(ipaddr) > 1):
waiting4network = False
if len(ipaddr) < 1:
log.message("No IP network", log.INFO)
statusLed.set(StatusLed.ERROR)
time.sleep(1)
else:
log.message("IP " + ipaddr, log.INFO)
time.sleep(2)
log.message("Starting MPD", log.INFO)
radio.start()
log.message("MPD started", log.INFO)
radio.setLastMode(radio.MODE_OPTIONS)
radio.setLastOption(radio.RELOADLIB)
mpd_version = radio.execMpcCommand("version")
log.message(mpd_version, log.INFO)
time.sleep(1)
# Auto-load music library if no Internet
if len(ipaddr) < 1 and radio.autoload():
log.message("Loading music library", log.INFO)
radio.setSource(radio.PLAYER)
# Load radio
reload(radio)
radio.play(get_stored_id(CurrentFile))
log.message("Current ID = " + str(radio.getCurrentID()), log.INFO)
# Get rotary switches configuration
up_switch = radio.getSwitchGpio("up_switch")
down_switch = radio.getSwitchGpio("down_switch")
left_switch = radio.getSwitchGpio("left_switch")
right_switch = radio.getSwitchGpio("right_switch")
menu_switch = radio.getSwitchGpio("menu_switch")
mute_switch = radio.getSwitchGpio("mute_switch")
boardrevision = radio.getBoardRevision()
if radio.getRotaryClass() is radio.ROTARY_STANDARD:
boardrevision = radio.getBoardRevision()
volumeknob = RotaryEncoder(left_switch, right_switch, mute_switch,
volume_event, boardrevision)
tunerknob = RotaryEncoder(up_switch, down_switch, menu_switch,
tuner_event, boardrevision)
elif radio.getRotaryClass() is radio.ROTARY_ALTERNATIVE:
volumeknob = RotaryEncoderAlternative(left_switch, right_switch,
mute_switch, volume_event,
boardrevision)
tunerknob = RotaryEncoderAlternative(up_switch, down_switch,
menu_switch, tuner_event,
boardrevision)
# Configure rotary switch (not rotary encoder)
switch1 = radio.getMenuSwitch('menu_switch_value_1')
switch2 = radio.getMenuSwitch('menu_switch_value_2')
switch4 = radio.getMenuSwitch('menu_switch_value_4')
menu_switch = MenuSwitch(switch1, switch2, switch4, menu_swich_event)
log.message("Running", log.INFO)
statusLed.set(StatusLed.NORMAL)
# Main processing loop
count = 0
while True:
display_mode = radio.getDisplayMode()
if not radio.getReload():
if display_mode is radio.MODE_SEARCH:
statusLed.set(StatusLed.SELECT)
else:
statusLed.set(StatusLed.NORMAL)
switch = radio.getSwitch()
if switch > 0:
get_switch_states(radio, volumeknob, tunerknob)
radio.setSwitch(0)
if menu_switch_value > 0:
menu_settle -= 1
if menu_settle < 0:
setMenu(radio, menu_switch_value)
menu_settle = 5
else:
time.sleep(0.2)
dateFormat = radio.getDateFormat()
todaysdate = strftime(dateFormat)
# Check for IP address
ipaddr = exec_cmd('hostname -I')
if len(ipaddr) < 1 and radio.getSource() != radio.PLAYER:
statusLed.set(StatusLed.ERROR)
# Shutdown command issued
if display_mode == radio.MODE_SHUTDOWN:
while True:
# Not an error just shutting down
statusLed.set(StatusLed.ERROR)
radio.execCommand("shutdown -h now")
time.sleep(1)
elif display_mode == radio.MODE_TIME:
if radio.getReload():
log.message("Reload ", log.DEBUG)
reload(radio)
radio.setReload(False)
# Check state (pause or play)
checkState(radio)
if radio.volumeChanged():
time.sleep(0.1)
time.sleep(0.1)
def run(self):
global CurrentFile
global volumeknob, tunerknob
log.init('radio')
signal.signal(signal.SIGTERM, signalHandler)
progcall = str(sys.argv)
log.message('Radio running pid ' + str(os.getpid()), log.INFO)
log.message(
"Radio " + progcall + " daemon version " + radio.getVersion(),
log.INFO)
log.message("GPIO version " + str(GPIO.VERSION), log.INFO)
boardrevision = radio.getBoardRevision()
lcd.init(boardrevision)
lcd.backlight(True)
hostname = exec_cmd('hostname')
ipaddr = exec_cmd('hostname -I')
myos = exec_cmd('uname -a')
log.message(myos, log.INFO)
# Display daemon pid on the LCD
message = "Radio pid " + str(os.getpid())
lcd.line1(message)
lcd.line2("IP " + ipaddr)
time.sleep(4)
log.message("Starting MPD", log.INFO)
lcd.line2("Starting MPD")
radio.start()
log.message("MPD started", log.INFO)
mpd_version = radio.execMpcCommand("version")
log.message(mpd_version, log.INFO)
lcd.line1("Radio ver " + radio.getVersion())
lcd.scroll2(mpd_version, no_interrupt)
time.sleep(1)
reload(lcd, radio)
radio.play(get_stored_id(CurrentFile))
log.message("Current ID = " + str(radio.getCurrentID()), log.INFO)
# Define rotary switches
volumeknob = RotaryEncoder(LEFT_SWITCH, RIGHT_SWITCH, MUTE_SWITCH,
volume_event, boardrevision)
tunerknob = RotaryEncoder(UP_SWITCH, DOWN_SWITCH, MENU_SWITCH,
tuner_event, boardrevision)
log.message("Running", log.INFO)
# Main processing loop
count = 0
while True:
switch = radio.getSwitch()
if switch > 0:
get_switch_states(lcd, radio, rss, volumeknob, tunerknob)
radio.setSwitch(0)
display_mode = radio.getDisplayMode()
lcd.setScrollSpeed(0.3) # Scroll speed normal
todaysdate = strftime("%H:%M %d/%m/%Y")
ipaddr = exec_cmd('hostname -I')
# Shutdown command issued
if display_mode == radio.MODE_SHUTDOWN:
displayShutdown(lcd)
while True:
time.sleep(1)
elif ipaddr is "":
lcd.line2("No IP network")
elif display_mode == radio.MODE_TIME:
displayTime(lcd, radio)
if radio.muted():
msg = "Sound muted"
if radio.getStreaming():
msg = msg + ' *'
lcd.line2(msg)
else:
display_current(lcd, radio)
elif display_mode == radio.MODE_SEARCH:
display_search(lcd, radio)
elif display_mode == radio.MODE_SOURCE:
display_source_select(lcd, radio)
elif display_mode == radio.MODE_OPTIONS:
display_options(lcd, radio)
elif display_mode == radio.MODE_IP:
lcd.line2("Radio v" + radio.getVersion())
if ipaddr is "":
lcd.line1("No IP network")
else:
lcd.scroll1("IP " + ipaddr, interrupt)
elif display_mode == radio.MODE_RSS:
lcd.line1(todaysdate)
display_rss(lcd, rss)
elif display_mode == radio.MODE_SLEEP:
lcd.line1(todaysdate)
display_sleep(lcd, radio)
# Timer function
checkTimer(radio)
# Check state (pause or play)
checkState(radio)
# Alarm wakeup function
if display_mode == radio.MODE_SLEEP and radio.alarmFired():
log.message("Alarm fired", log.INFO)
unmuteRadio(lcd, radio)
displayWakeUpMessage(lcd)
radio.setDisplayMode(radio.MODE_TIME)
if radio.volumeChanged():
lcd.line2("Volume " + str(radio.getVolume()))
time.sleep(0.5)
time.sleep(0.1)
def run(self):
global CurrentFile
global volumeknob, tunerknob
log.init('radio')
signal.signal(signal.SIGTERM, signalHandler)
progcall = str(sys.argv)
log.message('Radio running pid ' + str(os.getpid()), log.INFO)
log.message(
"Radio " + progcall + " daemon version " + radio.getVersion(),
log.INFO)
log.message("GPIO version " + str(GPIO.VERSION), log.INFO)
boardrevision = radio.getBoardRevision()
lcd.init(boardrevision)
lcd.setWidth(20)
lcd.line1("Radio version " + radio.getVersion())
time.sleep(0.5)
ipaddr = exec_cmd('hostname -I')
myos = exec_cmd('uname -a')
hostname = exec_cmd('hostname -s')
log.message(myos, log.INFO)
# Display daemon pid on the LCD
message = "Radio pid " + str(os.getpid())
lcd.line2(message)
lcd.line3("Starting MPD")
log.message("GPIO version " + str(GPIO.VERSION), log.INFO)
lcd.line4("IP " + ipaddr)
radio.start()
log.message("MPD started", log.INFO)
time.sleep(0.5)
mpd_version = radio.execMpcCommand("version")
log.message(mpd_version, log.INFO)
lcd.line3(mpd_version)
lcd.line4("GPIO version " + str(GPIO.VERSION))
time.sleep(2.0)
reload(lcd, radio)
radio.play(get_stored_id(CurrentFile))
log.message("Current ID = " + str(radio.getCurrentID()), log.INFO)
lcd.line3("Radio Station " + str(radio.getCurrentID()))
# Define rotary switches
volumeknob = RotaryEncoder(LEFT_SWITCH, RIGHT_SWITCH, MUTE_SWITCH,
volume_event, boardrevision)
tunerknob = RotaryEncoder(UP_SWITCH, DOWN_SWITCH, MENU_SWITCH,
tuner_event, boardrevision)
log.message("Running", log.INFO)
# Main processing loop
count = 0
toggleScrolling = True # Toggle scrolling between Line 2 and 3
while True:
# See if we have had an interrupt
switch = radio.getSwitch()
if switch > 0:
get_switch_states(lcd, radio, rss, volumeknob, tunerknob)
display_mode = radio.getDisplayMode()
lcd.setScrollSpeed(0.3) # Scroll speed normal
todaysdate = strftime("%H:%M %d/%m/%Y")
ipaddr = exec_cmd('hostname -I')
# Shutdown command issued
if display_mode == radio.MODE_SHUTDOWN:
log.message("Shutting down", log.DEBUG)
displayShutdown(lcd)
while True:
time.sleep(1)
if ipaddr is "":
lcd.line3("No IP network")
elif display_mode == radio.MODE_TIME:
msg = todaysdate
if radio.getStreaming():
msg = msg + ' *'
lcd.line1(msg)
display_current(lcd, radio, toggleScrolling)
elif display_mode == radio.MODE_SEARCH:
display_search(lcd, radio)
elif display_mode == radio.MODE_SOURCE:
display_source_select(lcd, radio)
elif display_mode == radio.MODE_OPTIONS:
display_options(lcd, radio)
elif display_mode == radio.MODE_IP:
displayInfo(lcd, ipaddr, mpd_version)
elif display_mode == radio.MODE_RSS:
lcd.line1(todaysdate)
input_source = radio.getSource()
current_id = radio.getCurrentID()
if input_source == radio.RADIO:
station = radio.getRadioStation() + ' (' + str(
current_id) + ')'
lcd.line2(station)
else:
lcd.line2("Current track:" + str(current_id))
display_rss(lcd, rss)
elif display_mode == radio.MODE_SLEEP:
lcd.line1(todaysdate)
display_sleep(lcd, radio)
# Timer function
checkTimer(radio)
# Check state (pause or play)
checkState(radio)
# Alarm wakeup function
if display_mode == radio.MODE_SLEEP and radio.alarmFired():
log.message("Alarm fired", log.INFO)
radio.unmute()
displayWakeUpMessage(lcd)
radio.setDisplayMode(radio.MODE_TIME)
# Toggle line 2 & 3 scrolling
if toggleScrolling:
toggleScrolling = False
else:
toggleScrolling = True
time.sleep(0.1)
def amplifier_on():
GPIO.output(21, GPIO.HIGH)
def amplifier_off():
GPIO.output(21, GPIO.LOW)
#Touch Schalter
GPIO.add_event_detect(24,
GPIO.FALLING,
callback=drehimpulsgeber,
bouncetime=1500)
knob = RotaryEncoder(6, 5, 27, drehimpulsgeber)
update_lcd(1)
dim_lcd(0)
while True:
time.sleep(25)
if mode == 0:
mode = 5
print("update Clock")
Clock.write_big_time()
time.sleep(0.3)
mode = 0
if Alarm.get_alarm_time()[0] == time.strftime("%H:%M"):
enter_menue()
def run(self):
global CurrentFile
global volumeknob, tunerknob
log.init('radio')
signal.signal(signal.SIGTERM, signalHandler)
progcall = str(sys.argv)
log.message('Radio running pid ' + str(os.getpid()), log.INFO)
log.message(
"Radio " + progcall + " daemon version " + radio.getVersion(),
log.INFO)
log.message("GPIO version " + str(GPIO.VERSION), log.INFO)
boardrevision = radio.getBoardRevision()
lcd.init(boardrevision)
# Set up LCD line width
width = lcd.getWidth()
if width > 0:
lcd.setWidth(width)
else:
lcd.setWidth(20)
lcd.scroll1("Radio version " + radio.getVersion(), nointerrupt)
hostname = exec_cmd('hostname -s')
# Display daemon pid on the LCD
message = "Radio pid " + str(os.getpid())
lcd.line2(message)
# Wait for the IP network
ipaddr = ""
waiting4network = True
count = 10
while waiting4network:
lcd.scroll4("Waiting for network", nointerrupt)
ipaddr = exec_cmd('hostname -I')
time.sleep(1)
count -= 1
if (count < 0) or (len(ipaddr) > 1):
waiting4network = False
if len(ipaddr) < 1:
lcd.line4("No IP network")
else:
lcd.line4("IP " + ipaddr)
log.message("IP " + ipaddr, log.INFO)
lcd.line3("Starting MPD")
log.message("GPIO version " + str(GPIO.VERSION), log.INFO)
radio.start()
log.message("MPD started", log.INFO)
time.sleep(0.5)
mpd_version = radio.getMpdVersion()
log.message(mpd_version, log.INFO)
lcd.scroll3("MPD version " + mpd_version, nointerrupt)
lcd.scroll4("GPIO version " + str(GPIO.VERSION), nointerrupt)
time.sleep(2.0)
# Auto-load music library if no Internet
if len(ipaddr) < 1 and radio.autoload():
log.message("Loading music library", log.INFO)
radio.setSource(radio.PLAYER)
# Load radio
reload(lcd, radio)
radio.play(get_stored_id(CurrentFile))
log.message("Current ID = " + str(radio.getCurrentID()), log.INFO)
lcd.line3("Radio Station " + str(radio.getCurrentID()))
# Get rotary switches configuration
up_switch = radio.getSwitchGpio("up_switch")
down_switch = radio.getSwitchGpio("down_switch")
left_switch = radio.getSwitchGpio("left_switch")
right_switch = radio.getSwitchGpio("right_switch")
menu_switch = radio.getSwitchGpio("menu_switch")
mute_switch = radio.getSwitchGpio("mute_switch")
aux_switch = radio.getSwitchGpio("aux_switch")
if radio.getRotaryClass() is radio.ROTARY_STANDARD:
volumeknob = RotaryEncoder(left_switch, right_switch, mute_switch,
volume_event, boardrevision)
tunerknob = RotaryEncoder(down_switch, up_switch, menu_switch,
tuner_event, boardrevision)
elif radio.getRotaryClass() is radio.ROTARY_ALTERNATIVE:
volumeknob = RotaryEncoderAlternative(left_switch, right_switch,
mute_switch, volume_event,
boardrevision)
tunerknob = RotaryEncoderAlternative(down_switch, up_switch,
menu_switch, tuner_event,
boardrevision)
log.message("Running", log.INFO)
# Main processing loop
count = 0
toggleScrolling = True # Toggle scrolling between Line 2 and 3
while True:
# Check for audio device error
if radio.audioError():
lcd.line1("Audio Error!")
lcd.line2("Aborting!")
time.sleep(5)
sys.exit(1)
# See if we have had an interrupt
switch = radio.getSwitch()
if switch > 0:
get_switch_states(lcd, radio, rss, volumeknob, tunerknob)
display_mode = radio.getDisplayMode()
lcd.setScrollSpeed(0.3) # Scroll speed normal
dateFormat = radio.getDateFormat()
todaysdate = strftime(dateFormat)
# Shutdown command issued
if display_mode == radio.MODE_SHUTDOWN:
log.message("Shutting down", log.DEBUG)
displayShutdown(lcd, radio)
while True:
time.sleep(1)
ipaddr = exec_cmd('hostname -I')
source = radio.getSource()
if len(ipaddr) < 1 and source != radio.PLAYER:
lcd.line3("No IP network")
elif display_mode == radio.MODE_TIME:
if radio.getReload():
log.message("Reload ", log.DEBUG)
reload(lcd, radio)
radio.setReload(False)
msg = todaysdate
if radio.getStreaming():
msg = msg + ' *'
lcd.line1(msg)
if source == radio.AIRPLAY:
displayAirplay(lcd, radio)
else:
display_current(lcd, radio, toggleScrolling)
elif display_mode == radio.MODE_SEARCH:
display_search(lcd, radio)
elif display_mode == radio.MODE_SOURCE:
display_source_select(lcd, radio)
elif display_mode == radio.MODE_OPTIONS:
display_options(lcd, radio)
elif display_mode == radio.MODE_IP:
displayInfo(lcd, ipaddr, mpd_version)
elif display_mode == radio.MODE_RSS:
lcd.line1(todaysdate)
input_source = radio.getSource()
current_id = radio.getCurrentID()
if input_source == radio.RADIO:
lcd.line2(radio.getRadioStation())
elif input_source == radio.PLAYER:
lcd.line2("Current track:" + str(current_id))
else:
displayVolume(lcd, radio)
display_rss(lcd, rss)
elif display_mode == radio.MODE_SLEEP:
lcd.line1(todaysdate)
display_sleep(lcd, radio)
# Timer function
checkTimer(radio)
# Check state (pause or play)
checkState(radio)
# Alarm wakeup function
if display_mode == radio.MODE_SLEEP and radio.alarmFired():
log.message("Alarm fired", log.INFO)
radio.unmute()
displayWakeUpMessage(lcd)
radio.setDisplayMode(radio.MODE_TIME)
# Toggle line 2 & 3 scrolling
if toggleScrolling:
toggleScrolling = False
else:
toggleScrolling = True
time.sleep(0.1)
up_switch = config.getSwitchGpio("up_switch")
down_switch = config.getSwitchGpio("down_switch")
menu_switch = config.getSwitchGpio("menu_switch")
print("Left switch GPIO", left_switch)
print("Right switch GPIO", right_switch)
print("Up switch GPIO", up_switch)
print("Down switch GPIO", down_switch)
print("Mute switch GPIO", mute_switch)
print("Menu switch GPIO", menu_switch)
Button(down_switch, interrupt, log)
Button(up_switch, interrupt, log)
Button(menu_switch, interrupt, log)
volumeknob = RotaryEncoder(left_switch, right_switch, mute_switch,
rotary_event)
statusLed = statusLedInitialise(statusLed)
statusLed.set(StatusLed.LED1)
time.sleep(1)
statusLed.set(StatusLed.LED2)
time.sleep(1)
statusLed.set(StatusLed.LED3)
time.sleep(1)
statusLed.set(StatusLed.ALL)
time.sleep(1)
statusLed.set(StatusLed.CLEAR)
time.sleep(1)
# Main wait loop
try:
if data == "r3":
trellis.color(x,y,WHITE)
if data == "r4":
trellis.color(x,y,YELLOW)
if event == RotaryEncoder.CLOCKWISE:
print("%s Clockwise" % data)
elif event == RotaryEncoder.ANTICLOCKWISE:
print ("%s Anticlockwise" % data)
elif event == RotaryEncoder.BUTTONDOWN:
print ("%s Button down" % data)
elif event == RotaryEncoder.BUTTONUP:
print ("%s Button up" % data)
return
# Define the encoders
r1 = RotaryEncoder(R1_PIN_A,R1_PIN_B,R1_BUTTON,switch_event,"r1")
r2 = RotaryEncoder(R2_PIN_A,R2_PIN_B,R2_BUTTON,switch_event,"r2")
r3 = RotaryEncoder(R3_PIN_A,R3_PIN_B,R3_BUTTON,switch_event,"r3")
r4 = RotaryEncoder(R4_PIN_A,R4_PIN_B,R4_BUTTON,switch_event,"r4")
print("r1_pin_a=[%d], r1_pin_b=[%d], r1_button=[%d]," % (R1_PIN_A, R1_PIN_B, R1_BUTTON))
print("r2_pin_a=[%d], r2_pin_b=[%d], r2_button=[%d]," % (R2_PIN_A, R2_PIN_B, R2_BUTTON))
print("r3_pin_a=[%d], r3_pin_b=[%d], r3_button=[%d]," % (R3_PIN_A, R3_PIN_B, R3_BUTTON))
print("r4_pin_a=[%d], r4_pin_b=[%d], r4_button=[%d]," % (R4_PIN_A, R4_PIN_B, R4_BUTTON))
while True:
# the trellis can only be read every 17 millisecons or so
trellis.sync()
time.sleep(0.02)
def run(self):
global lcd
global CurrentFile
global volumeknob, tunerknob
log.init('radio')
signal.signal(signal.SIGTERM, signalHandler)
progcall = str(sys.argv)
log.message('Radio running pid ' + str(os.getpid()), log.INFO)
log.message(
"Radio " + progcall + " daemon version " + radio.getVersion(),
log.INFO)
log.message("GPIO version " + str(GPIO.VERSION), log.INFO)
i2c_address = radio.getI2Caddress() # Get address from configuration
# Load pcf8574 i2c class or Adafruit backpack
if radio.getBackPackType() == radio.PCF8574:
log.message("PCF8574 backpack address: " + hex(i2c_address),
log.INFO)
lcd = lcd_i2c_pcf8574()
else:
log.message("Adafruit backpack address: " + hex(i2c_address),
log.INFO)
lcd = lcd_i2c()
boardrevision = radio.getBoardRevision()
lcd.init(board_rev=boardrevision, address=i2c_address)
lcd.backlight(True)
hostname = exec_cmd('hostname')
ipaddr = exec_cmd('hostname -I')
# Display daemon pid on the LCD
message = "Radio pid " + str(os.getpid())
lcd.line1(message)
lcd.line2("IP " + ipaddr)
time.sleep(4)
log.message("Starting MPD", log.INFO)
lcd.line2("Starting MPD")
radio.start()
log.message("MPD started", log.INFO)
mpd_version = radio.execMpcCommand("version")
log.message(mpd_version, log.INFO)
lcd.line1("Radio ver " + radio.getVersion())
lcd.scroll2(mpd_version, no_interrupt)
time.sleep(1)
reload(lcd, radio)
radio.play(get_stored_id(CurrentFile))
log.message("Current ID = " + str(radio.getCurrentID()), log.INFO)
# Get rotary switches configuration
up_switch = radio.getSwitchGpio("up_switch")
down_switch = radio.getSwitchGpio("down_switch")
left_switch = radio.getSwitchGpio("left_switch")
right_switch = radio.getSwitchGpio("right_switch")
menu_switch = radio.getSwitchGpio("menu_switch")
mute_switch = radio.getSwitchGpio("mute_switch")
if radio.getRotaryClass() is radio.ROTARY_STANDARD:
volumeknob = RotaryEncoder(left_switch, right_switch, mute_switch,
volume_event, boardrevision)
tunerknob = RotaryEncoder(up_switch, down_switch, menu_switch,
tuner_event, boardrevision)
elif radio.getRotaryClass() is radio.ROTARY_ALTERNATIVE:
volumeknob = RotaryEncoderAlternative(left_switch, right_switch,
mute_switch, volume_event,
boardrevision)
tunerknob = RotaryEncoderAlternative(up_switch, down_switch,
menu_switch, tuner_event,
boardrevision)
log.message("Running", log.INFO)
# Main processing loop
count = 0
while True:
switch = radio.getSwitch()
if switch > 0:
get_switch_states(lcd, radio, rss, volumeknob, tunerknob)
radio.setSwitch(0)
display_mode = radio.getDisplayMode()
lcd.setScrollSpeed(0.3) # Scroll speed normal
dateFormat = radio.getDateFormat()
todaysdate = strftime(dateFormat)
ipaddr = exec_cmd('hostname -I')
# Shutdown command issued
if display_mode == radio.MODE_SHUTDOWN:
displayShutdown(lcd)
while True:
time.sleep(1)
elif ipaddr is "":
lcd.line2("No IP network")
elif display_mode == radio.MODE_TIME:
if radio.getReload():
log.message("Reload ", log.DEBUG)
reload(lcd, radio)
radio.setReload(False)
displayTime(lcd, radio)
if radio.muted():
msg = "Sound muted"
if radio.getStreaming():
msg = msg + ' *'
lcd.line2(msg)
else:
display_current(lcd, radio)
elif display_mode == radio.MODE_SEARCH:
display_search(lcd, radio)
elif display_mode == radio.MODE_SOURCE:
display_source_select(lcd, radio)
elif display_mode == radio.MODE_OPTIONS:
display_options(lcd, radio)
elif display_mode == radio.MODE_IP:
lcd.line2("Radio v" + radio.getVersion())
if ipaddr is "":
lcd.line1("No IP network")
else:
lcd.scroll1("IP " + ipaddr, interrupt)
elif display_mode == radio.MODE_RSS:
lcd.line1(todaysdate)
display_rss(lcd, rss)
elif display_mode == radio.MODE_SLEEP:
lcd.line1(todaysdate)
display_sleep(lcd, radio)
# Timer function
checkTimer(radio)
# Check state (pause or play)
checkState(radio)
# Alarm wakeup function
if display_mode == radio.MODE_SLEEP and radio.alarmFired():
log.message("Alarm fired", log.INFO)
unmuteRadio(lcd, radio)
displayWakeUpMessage(lcd)
radio.setDisplayMode(radio.MODE_TIME)
if radio.volumeChanged():
lcd.line2("Volume " + str(radio.getVolume()))
time.sleep(0.5)
time.sleep(0.1)
return
def switch_event(event):
if event == RotaryEncoder.CLOCKWISE:
call(["mpc", "seek", "+2"], shell=False)
elif event == RotaryEncoder.ANTICLOCKWISE:
call(["mpc", "seek", "-2"], shell=False)
elif event == RotaryEncoder.BUTTONDOWN:
pass
elif event == RotaryEncoder.BUTTONUP:
call(["mpc", "next"], shell=False)
return
# Define shutdown button
gpio.setmode(gpio.BCM) # Set pin numbering to bcm numbering
gpio.setup(PUSH_BUTTON, gpio.IN,
pull_up_down=gpio.PUD_UP) # Set up pin 26 as an input
gpio.add_event_detect(
PUSH_BUTTON, gpio.RISING, callback=shutdown,
bouncetime=2000) # Set up an interrupt to look for button presses
# Define the right switch
rswitch = RotaryEncoder(RPIN_A, RPIN_B, RBUTTON, vol_event)
# Define the left switch
lswitch = RotaryEncoder(LPIN_A, LPIN_B, LBUTTON, switch_event)
loop() # Run the loop function to keep script running
def run(self):
global CurrentFile
global ConfigFile
global tunerknob
configOK = False
GPIO.setmode(GPIO.BCM) # Use BCM GPIO numbers
GPIO.setwarnings(False) # Ignore warnings
boardrevision = radio.getBoardRevision()
if boardrevision == 1:
# For rev 1 boards with no inbuilt pull-up/down resistors
# Wire the GPIO inputs to ground via a 10K resistor
GPIO.setup(MENU_SWITCH, GPIO.IN)
GPIO.setup(UP_SWITCH, GPIO.IN)
GPIO.setup(DOWN_SWITCH, GPIO.IN)
GPIO.setup(LEFT_SWITCH, GPIO.IN)
GPIO.setup(RIGHT_SWITCH, GPIO.IN)
else:
# For rev 2 boards with inbuilt pull-up/down resistors the
# following lines are used instead of the above, so
# there is no need to physically wire the 10k resistors
GPIO.setup(MENU_SWITCH, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
GPIO.setup(UP_SWITCH, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
GPIO.setup(DOWN_SWITCH, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
GPIO.setup(LEFT_SWITCH, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
GPIO.setup(RIGHT_SWITCH, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
GPIO.setup(STREAM_SWITCH, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
# Initialise IR
if not (pylirc.init("radio", "/home/pi/radio/ir.conf")):
log.message("IR initialization failed.", log.ERROR)
else:
pylirc.blocking(0)
# Initialise radio
log.init('radio')
signal.signal(signal.SIGTERM, signalHandler)
progcall = str(sys.argv)
log.message('Radio running pid ' + str(os.getpid()), log.INFO)
log.message(
"Radio " + progcall + " daemon version " + radio.getVersion(),
log.INFO)
log.message("GPIO version " + str(GPIO.VERSION), log.INFO)
if not os.path.isfile(ConfigFile) or os.path.getsize(ConfigFile) == 0:
log.message("Missing configuration file " + ConfigFile, log.ERROR)
else:
log.message("Reading configuration file", log.INFO)
self.configOK = True # Must be set before calling getConfig()
self.getConfig()
lcd.init(boardrevision)
lcd.setWidth(self.display_width)
hostname = exec_cmd('hostname')
ipaddr = exec_cmd('hostname -I')
myos = exec_cmd('uname -a')
log.message(myos, log.INFO)
# Display daemon pid on the LCD
message = "Radio pid " + str(os.getpid())
lcd.line1(message)
lcd.line2("IP " + ipaddr)
time.sleep(2)
log.message("Starting MPD", log.INFO)
lcd.line2("Starting MPD")
radio.start()
log.message("MPD started", log.INFO)
mpd_version = radio.execMpcCommand("version")
log.message(mpd_version, log.INFO)
lcd.line1("Radio ver " + radio.getVersion())
lcd.scroll2(mpd_version, no_interrupt)
time.sleep(1)
reload(lcd, radio)
radio.play(get_stored_id(CurrentFile))
log.message("Current ID = " + str(radio.getCurrentID()), log.INFO)
tunerknob = RotaryEncoder(ROTA_SWITCH, ROTB_SWITCH, PUSH_SWITCH,
tuner_event, boardrevision)
# Set up switch event processing
GPIO.add_event_detect(MENU_SWITCH,
GPIO.RISING,
callback=switch_event,
bouncetime=200)
GPIO.add_event_detect(LEFT_SWITCH,
GPIO.RISING,
callback=switch_event,
bouncetime=200)
GPIO.add_event_detect(RIGHT_SWITCH,
GPIO.RISING,
callback=switch_event,
bouncetime=200)
GPIO.add_event_detect(UP_SWITCH,
GPIO.RISING,
callback=switch_event,
bouncetime=200)
GPIO.add_event_detect(DOWN_SWITCH,
GPIO.RISING,
callback=switch_event,
bouncetime=200)
GPIO.add_event_detect(STREAM_SWITCH,
GPIO.RISING,
callback=switch_event,
bouncetime=200)
# Main processing loop
count = 0
while True:
#log.message("===BEGIN MAIN LOOP===",log.DEBUG)
ir = pylirc.nextcode(1)
if (ir):
ir_event(ir, lcd, radio, rss, tunerknob)
ir = []
switch = radio.getSwitch()
if switch > 0:
get_switch_states(lcd, radio, rss, tunerknob)
radio.setSwitch(0)
#log.message("=== 0 ===",log.DEBUG)
display_mode = radio.getDisplayMode()
dateFormat = radio.getDateFormat()
todaysdate = strftime(dateFormat)
lcd.setScrollSpeed(0.3) # Scroll speed normal
ipaddr = exec_cmd('hostname -I')
# Shutdown command issued
if display_mode == radio.MODE_SHUTDOWN:
displayShutdown(lcd)
while True:
time.sleep(1)
elif ipaddr is "":
lcd.line2("No IP network")
elif display_mode == radio.MODE_TIME:
#log.message("=== MODE_TIME ===",log.DEBUG)
displayTime(lcd, radio)
if radio.muted():
msg = "Sound muted"
lcd.line2(msg)
else:
display_current(lcd, radio)
elif display_mode == radio.MODE_SEARCH:
display_search(lcd, radio)
elif display_mode == radio.MODE_SOURCE:
display_source_select(lcd, radio)
elif display_mode == radio.MODE_OPTIONS:
display_options(lcd, radio)
elif display_mode == radio.MODE_IP:
lcd.line2("Radio v" + radio.getVersion())
if ipaddr is "":
lcd.line1("No IP network")
else:
lcd.scroll1("IP " + ipaddr, interrupt)
elif display_mode == radio.MODE_RSS:
displayTime(lcd, radio)
display_rss(lcd, rss)
elif display_mode == radio.MODE_SLEEP:
displayTime(lcd, radio)
display_sleep(lcd, radio)
#log.message("=== 1 ===",log.DEBUG)
# Timer function
checkTimer(radio)
#log.message("=== 2 ===",log.DEBUG)
# Check state (pause or play)
checkState(radio)
#log.message("=== 3 ===",log.DEBUG)
# Alarm wakeup function
if display_mode == radio.MODE_SLEEP and radio.alarmFired():
log.message("Alarm fired", log.INFO)
unmuteRadio(lcd, radio)
displayWakeUpMessage(lcd)
radio.setDisplayMode(radio.MODE_TIME)
if radio.volumeChanged():
lcd.line2("Volume " + str(radio.getVolume()))
time.sleep(0.75)
#log.message("=== 4 ===",log.DEBUG)
time.sleep(0.1)
handle_event(event,"Left knob") return # This is the event callback routine to handle right knob events def right_knob_event(event): handle_event(event,"Right knob") return # This is the event callback routine to handle events def handle_event(event, name): if event == RotaryEncoder.CLOCKWISE: print name, "Clockwise event =", RotaryEncoder.CLOCKWISE elif event == RotaryEncoder.ANTICLOCKWISE: print name, "Anticlockwise event =", RotaryEncoder.BUTTONDOWN elif event == RotaryEncoder.BUTTONDOWN: print name, "Button down event =", RotaryEncoder.BUTTONDOWN elif event == RotaryEncoder.BUTTONUP: print name, "Button up event =", RotaryEncoder.BUTTONUP return # Define the left and right knobs leftknob = RotaryEncoder(LEFT_A,LEFT_B,LEFT_BUTTON,left_knob_event) rightknob = RotaryEncoder(RIGHT_A,RIGHT_B,RIGHT_BUTTON,right_knob_event) # Wait for events while True: time.sleep(0.5) # End of program
#print t,"Clockwise"
camera.annotate_text = camera.annotate_text + ">"
elif event == RotaryEncoder.ANTICLOCKWISE:
#print t,"Anticlockwise"
camera.annotate_text = camera.annotate_text + "<"
elif event == RotaryEncoder.BUTTONDOWN:
print t,"Button down"
elif event == RotaryEncoder.BUTTONUP:
print t,"Button up"
in_menu = True
camera.annotate_text = camera.annotate_text + " [menu]"
return
# Define the switch
rswitch = RotaryEncoder(PIN_A,PIN_B,BUTTON,switch_event)
print "Rotary encoder pins: %d %d switch: %d" % ( PIN_A, PIN_B, BUTTON )
last_value = 0
frame_nr = 1
camera.annotate_text = state
print state
zoom_axis = 0
crop_axis = 0
ssocr_val = { 'Rotate': 0, 'Threshold': 90, 'Digits': -1, 'Shear': 0, 'Crop': [ 0,0,1,1 ] }
ssocr_max = { 'Rotate': 360, 'Threshold': 100, 'Digits': 10, 'Shear':100, 'Brightness':100 }
ssocr_val['Brightness'] = camera.brightness
for k in ssocr_val:
def __init__(self, pause, play, togglePlayPause, toggleNext, togglePrev,
toggleUnjoin, toggleVolUp, toggleVolDown, toggleShuffle,
rightRotaryTurn, leftRotaryTurn, rotaryTouch):
self.rightRotaryTurn = rightRotaryTurn
self.leftRotaryTurn = leftRotaryTurn
self.rotaryTouch = rotaryTouch
self.lastTagUid = None
# set all gpios
if not self.BUTTON_PAUSE == self.NOGPIO:
GPIO.setup(self.BUTTON_PAUSE, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
GPIO.add_event_detect(self.BUTTON_PAUSE,
GPIO.RISING,
callback=pause,
bouncetime=200)
if not self.BUTTON_PLAY == self.NOGPIO:
GPIO.setup(self.BUTTON_PLAY, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
GPIO.add_event_detect(self.BUTTON_PLAY,
GPIO.RISING,
callback=play,
bouncetime=200)
if not self.BUTTON_PLAYPAUSE == self.NOGPIO:
GPIO.setup(self.BUTTON_PLAYPAUSE,
GPIO.IN,
pull_up_down=GPIO.PUD_DOWN)
GPIO.add_event_detect(self.BUTTON_PLAYPAUSE,
GPIO.RISING,
callback=togglePlayPause,
bouncetime=800)
if not self.BUTTON_NEXT == self.NOGPIO:
GPIO.setup(self.BUTTON_NEXT, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
GPIO.add_event_detect(self.BUTTON_NEXT,
GPIO.RISING,
callback=toggleNext,
bouncetime=200)
if not self.BUTTON_PREV == self.NOGPIO:
GPIO.setup(self.BUTTON_PREV, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
GPIO.add_event_detect(self.BUTTON_PREV,
GPIO.RISING,
callback=togglePrev,
bouncetime=200)
if not self.BUTTON_UNJOIN == self.NOGPIO:
GPIO.setup(self.BUTTON_UNJOIN, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
GPIO.add_event_detect(self.BUTTON_UNJOIN,
GPIO.RISING,
callback=toggleUnjoin,
bouncetime=200)
if not self.BUTTON_VOL_UP == self.NOGPIO:
GPIO.setup(self.BUTTON_VOL_UP, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
GPIO.add_event_detect(self.BUTTON_VOL_UP,
GPIO.RISING,
callback=toggleVolUp,
bouncetime=200)
if not self.BUTTON_VOL_DOWN == self.NOGPIO:
GPIO.setup(self.BUTTON_VOL_DOWN,
GPIO.IN,
pull_up_down=GPIO.PUD_DOWN)
GPIO.add_event_detect(self.BUTTON_VOL_DOWN,
GPIO.RISING,
callback=toggleVolDown,
bouncetime=200)
if not self.BUTTON_SHUFFLE == self.NOGPIO:
GPIO.setup(self.BUTTON_SHUFFLE,
GPIO.IN,
pull_up_down=GPIO.PUD_DOWN)
GPIO.add_event_detect(self.BUTTON_SHUFFLE,
GPIO.RISING,
callback=toggleShuffle,
bouncetime=200)
if self.ROTARY_1 != self.NOGPIO & self.ROTARY_2 != self.NOGPIO:
MusicLogging.Instance().info("Rotary found")
encoder = RotaryEncoder(self.ROTARY_1, self.ROTARY_2,
self.rotaryEventHandler)
if self.ROTARY_BUTTON != self.NOGPIO:
encoder.setupButton(self.ROTARY_BUTTON)
# To show that everythin is startet: pulse the led for 5 seconds:
if self.LED1_BCM != self.NOGPIO:
self.ledPulse = LedPulse(self.LED1_BCM)
self.ledPulse.startPulseLedForSeconds(10)
# ledPulse.startPulseLed()
MusicLogging.Instance().info("Setting up reader...")
# Create an object of the class MFRC522
self.reader = MFRC522.MFRC522()
# Welcome message
MusicLogging.Instance().info("Welcome to the MFRC522 reader")
self.lastTagUid = 'stop'
self.oldStatus = 0
def run(self):
global lcd
global CurrentFile
global volumeknob, tunerknob
log.init('radio')
# Setup signal handlers
signal.signal(signal.SIGTERM, signalHandler)
progcall = str(sys.argv)
log.message('Radio running pid ' + str(os.getpid()), log.INFO)
log.message(
"Radio " + progcall + " daemon version " + radio.getVersion(),
log.INFO)
log.message("GPIO version " + str(GPIO.VERSION), log.INFO)
i2c_address = radio.getI2Caddress()
# Load pcf8574 i2c class or Adafruit backpack
if radio.getBackPackType() == radio.PCF8574:
log.message("PCF8574 backpack, address: " + hex(i2c_address),
log.INFO)
lcd = lcd_i2c_pcf8574()
else:
log.message("Adafruit backpack, address: " + hex(i2c_address),
log.INFO)
lcd = lcd_i2c()
boardrevision = radio.getBoardRevision()
lcd.init(board_rev=boardrevision, address=i2c_address)
lcd.backlight(True)
# Set up LCD line width
width = lcd.getWidth()
if width > 0:
lcd.setWidth(width)
else:
lcd.setWidth(20)
lcd.line1("Radio vers " + radio.getVersion())
time.sleep(0.5)
ipaddr = exec_cmd('hostname -I')
hostname = exec_cmd('hostname -s')
# Display daemon pid on the LCD
message = "Radio pid " + str(os.getpid())
lcd.line2(message)
lcd.line3("Starting MPD")
log.message("GPIO version " + str(GPIO.VERSION), log.INFO)
lcd.line4("IP " + ipaddr)
radio.start()
log.message("MPD started", log.INFO)
time.sleep(0.5)
mpd_version = radio.execMpcCommand("version")
log.message(mpd_version, log.INFO)
lcd.scroll3(mpd_version, no_interrupt)
lcd.scroll4("GPIO version " + str(GPIO.VERSION), no_interrupt)
time.sleep(2.0)
# Auto-load music library if no Internet
if len(ipaddr) < 1 and radio.autoload():
log.message("Loading music library", log.INFO)
radio.setSource(radio.PLAYER)
# Load radio
reload(lcd, radio)
radio.play(get_stored_id(CurrentFile))
log.message("Current ID = " + str(radio.getCurrentID()), log.INFO)
lcd.line3("Radio Station " + str(radio.getCurrentID()))
# Get rotary switches configuration
up_switch = radio.getSwitchGpio("up_switch")
down_switch = radio.getSwitchGpio("down_switch")
left_switch = radio.getSwitchGpio("left_switch")
right_switch = radio.getSwitchGpio("right_switch")
menu_switch = radio.getSwitchGpio("menu_switch")
mute_switch = radio.getSwitchGpio("mute_switch")
if radio.getRotaryClass() is radio.ROTARY_STANDARD:
volumeknob = RotaryEncoder(left_switch, right_switch, mute_switch,
volume_event, boardrevision)
tunerknob = RotaryEncoder(down_switch, up_switch, menu_switch,
tuner_event, boardrevision)
elif radio.getRotaryClass() is radio.ROTARY_ALTERNATIVE:
volumeknob = RotaryEncoderAlternative(left_switch, right_switch,
mute_switch, volume_event,
boardrevision)
log.message("Running", log.INFO)
# Main processing loop
count = 0
toggleScrolling = True # Toggle scrolling between Line 2 and 3
while True:
# See if we have had an interrupt
switch = radio.getSwitch()
if switch > 0:
get_switch_states(lcd, radio, rss, volumeknob, tunerknob)
display_mode = radio.getDisplayMode()
lcd.setScrollSpeed(0.3) # Scroll speed normal
dateFormat = radio.getDateFormat()
todaysdate = strftime(dateFormat)
ipaddr = exec_cmd('hostname -I')
# Shutdown command issued
if display_mode == radio.MODE_SHUTDOWN:
log.message("Shutting down", log.DEBUG)
displayShutdown(lcd)
while True:
time.sleep(1)
if ipaddr is "":
lcd.line3("No IP network")
elif display_mode == radio.MODE_TIME:
if radio.getReload():
log.message("Reload ", log.DEBUG)
reload(lcd, radio)
radio.setReload(False)
msg = todaysdate
if radio.getStreaming():
msg = msg + ' *'
lcd.line1(msg)
display_current(lcd, radio, toggleScrolling)
elif display_mode == radio.MODE_SEARCH:
display_search(lcd, radio)
elif display_mode == radio.MODE_SOURCE:
display_source_select(lcd, radio)
elif display_mode == radio.MODE_OPTIONS:
display_options(lcd, radio)
elif display_mode == radio.MODE_IP:
displayInfo(lcd, ipaddr, mpd_version)
elif display_mode == radio.MODE_RSS:
lcd.line1(todaysdate)
input_source = radio.getSource()
current_id = radio.getCurrentID()
if input_source == radio.RADIO:
station = radio.getRadioStation() + ' (' + str(
current_id) + ')'
lcd.line2(station)
else:
lcd.line2("Current track:" + str(current_id))
display_rss(lcd, rss)
elif display_mode == radio.MODE_SLEEP:
lcd.line1(todaysdate)
display_sleep(lcd, radio)
# Timer function
checkTimer(radio)
# Check state (pause or play)
checkState(radio)
# Alarm wakeup function
if display_mode == radio.MODE_SLEEP and radio.alarmFired():
log.message("Alarm fired", log.INFO)
radio.unmute()
displayWakeUpMessage(lcd)
radio.setDisplayMode(radio.MODE_TIME)
# Toggle line 2 & 3 scrolling
if toggleScrolling:
toggleScrolling = False
else:
toggleScrolling = True
time.sleep(0.1)
# This is the event callback routine to handle events
def switch_event(event):
if event == RotaryEncoder.CLOCKWISE:
tmp = ""
subprocess.call(['mpc', 'volume', '+2'])
time.sleep(.2)
elif event == RotaryEncoder.ANTICLOCKWISE:
tmp = ""
subprocess.call(['mpc', 'volume', '-2'])
time.sleep(.2)
return
# Define the switch
rswitch = RotaryEncoder(PIN_A, PIN_B, BUTTON, switch_event)
#----------------------------------------------------------
#
#code to manage BUTTONS previous,next,stop,play,shutdown
GPIO.setup(SW_PREV, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(SW_NEXT, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(SW_STOP, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(SW_SHTDWN, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(SW_PLAY, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(SW_REB, GPIO.IN, pull_up_down=GPIO.PUD_UP)
while True:
try:
prev_switch = GPIO.input(SW_PREV)
next_switch = GPIO.input(SW_NEXT)
stop_switch = GPIO.input(SW_STOP)
shtdwn_switch = GPIO.input(SW_SHTDWN)
# This is the event callback routine to handle right knob events
def vol_knob_event(event):
handle_event(event, "Volume knob")
return
# This is the event callback routine to handle events
def handle_event(event, name):
if event == RotaryEncoder.CLOCKWISE:
print(name, "Clockwise event =", RotaryEncoder.CLOCKWISE)
elif event == RotaryEncoder.ANTICLOCKWISE:
print(name, "Anticlockwise event =", RotaryEncoder.BUTTONDOWN)
elif event == RotaryEncoder.BUTTONDOWN:
print(name, "Button down event =", RotaryEncoder.BUTTONDOWN)
elif event == RotaryEncoder.BUTTONUP:
print(name, "Button up event =", RotaryEncoder.BUTTONUP)
return
# Define the left and right knobs
tuneknob = RotaryEncoder(TUNE_A, TUNE_B, TUNE_BUTTON, tune_knob_event)
volknob = RotaryEncoder(VOLUME_A, VOLUME_B, VOLUME_BUTTON, vol_knob_event)
# Wait for events
while True:
time.sleep(0.5)
# End of program
def __init__(self, pause, play, togglePlayPause, toggleNext, togglePrev, toggleUnjoin, toggleVolUp,
toggleVolDown, toggleShuffle, rightRotaryTurn, leftRotaryTurn, rotaryTouch):
self.rightRotaryTurn = rightRotaryTurn
self.leftRotaryTurn = leftRotaryTurn
self.rotaryTouch = rotaryTouch
self.lastTagUid = None
# set all gpios
if not self.BUTTON_PAUSE == self.NOGPIO:
GPIO.setup(self.BUTTON_PAUSE, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
GPIO.add_event_detect(self.BUTTON_PAUSE, GPIO.RISING, callback=pause, bouncetime=200)
if not self.BUTTON_PLAY == self.NOGPIO:
GPIO.setup(self.BUTTON_PLAY, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
GPIO.add_event_detect(self.BUTTON_PLAY, GPIO.RISING, callback=play, bouncetime=200)
if not self.BUTTON_PLAYPAUSE == self.NOGPIO:
GPIO.setup(self.BUTTON_PLAYPAUSE, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
GPIO.add_event_detect(self.BUTTON_PLAYPAUSE, GPIO.RISING, callback=togglePlayPause, bouncetime=800)
if not self.BUTTON_NEXT == self.NOGPIO:
GPIO.setup(self.BUTTON_NEXT, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
GPIO.add_event_detect(self.BUTTON_NEXT, GPIO.RISING, callback=toggleNext, bouncetime=200)
if not self.BUTTON_PREV == self.NOGPIO:
GPIO.setup(self.BUTTON_PREV, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
GPIO.add_event_detect(self.BUTTON_PREV, GPIO.RISING, callback=togglePrev, bouncetime=200)
if not self.BUTTON_UNJOIN == self.NOGPIO:
GPIO.setup(self.BUTTON_UNJOIN, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
GPIO.add_event_detect(self.BUTTON_UNJOIN, GPIO.RISING, callback=toggleUnjoin, bouncetime=200)
if not self.BUTTON_VOL_UP == self.NOGPIO:
GPIO.setup(self.BUTTON_VOL_UP, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
GPIO.add_event_detect(self.BUTTON_VOL_UP, GPIO.RISING, callback=toggleVolUp, bouncetime=200)
if not self.BUTTON_VOL_DOWN == self.NOGPIO:
GPIO.setup(self.BUTTON_VOL_DOWN, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
GPIO.add_event_detect(self.BUTTON_VOL_DOWN, GPIO.RISING, callback=toggleVolDown, bouncetime=200)
if not self.BUTTON_SHUFFLE == self.NOGPIO:
GPIO.setup(self.BUTTON_SHUFFLE, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
GPIO.add_event_detect(self.BUTTON_SHUFFLE, GPIO.RISING, callback=toggleShuffle, bouncetime=200)
if self.ROTARY_1 != self.NOGPIO & self.ROTARY_2 != self.NOGPIO:
MusicLogging.Instance().info("Rotary found")
encoder = RotaryEncoder(self.ROTARY_1, self.ROTARY_2, self.rotaryEventHandler)
if self.ROTARY_BUTTON != self.NOGPIO:
encoder.setupButton(self.ROTARY_BUTTON)
# To show that everythin is startet: pulse the led for 5 seconds:
if self.LED1_BCM != self.NOGPIO:
self.ledPulse = LedPulse(self.LED1_BCM)
self.ledPulse.startPulseLedForSeconds(10)
# ledPulse.startPulseLed()
MusicLogging.Instance().info("Setting up reader...")
# Create an object of the class MFRC522
self.reader = MFRC522.MFRC522()
# Welcome message
MusicLogging.Instance().info("Welcome to the MFRC522 reader")
self.lastTagUid = 'stop'
self.oldStatus = 0
def run(self):
global CurrentFile
global volumeknob, tunerknob
log.init('radio')
signal.signal(signal.SIGTERM, signalHandler)
progcall = str(sys.argv)
log.message('Radio running pid ' + str(os.getpid()), log.INFO)
log.message(
"Radio " + progcall + " daemon version " + radio.getVersion(),
log.INFO)
log.message("GPIO version " + str(GPIO.VERSION), log.INFO)
boardrevision = radio.getBoardRevision()
lcd.init(boardrevision)
lcd.setWidth(8)
hostname = exec_cmd('hostname')
ipaddr = exec_cmd('hostname -I')
# Display daemon pid on the LCD
message = "PID " + str(os.getpid())
lcd.line1(message)
# Wait for the IP network
ipaddr = ""
waiting4network = True
count = 10
while waiting4network:
lcd.line2("Connect")
ipaddr = exec_cmd('hostname -I')
time.sleep(1)
count -= 1
if (count < 0) or (len(ipaddr) > 1):
waiting4network = False
if len(ipaddr) < 1:
lcd.scroll1("No IP network")
else:
lcd.scroll2("IP " + ipaddr, no_interrupt)
time.sleep(2)
log.message("Starting MPD", log.INFO)
lcd.line1("Starting")
lcd.line2("MPD")
radio.start()
log.message("MPD started", log.INFO)
mpd_version = radio.execMpcCommand("version")
log.message(mpd_version, log.INFO)
lcd.line1("Ver " + radio.getVersion())
lcd.scroll2(mpd_version, no_interrupt)
time.sleep(1)
# Auto-load music library if no Internet
if len(ipaddr) < 1 and radio.autoload():
log.message("Loading music library", log.INFO)
radio.setSource(radio.PLAYER)
# Load radio
reload(lcd, radio)
radio.play(get_stored_id(CurrentFile))
log.message("Current ID = " + str(radio.getCurrentID()), log.INFO)
# Get switches configuration
up_switch = radio.getSwitchGpio("up_switch")
down_switch = radio.getSwitchGpio("down_switch")
left_switch = radio.getSwitchGpio("left_switch")
right_switch = radio.getSwitchGpio("right_switch")
menu_switch = radio.getSwitchGpio("menu_switch")
mute_switch = radio.getSwitchGpio("mute_switch")
if radio.getRotaryClass() is radio.ROTARY_STANDARD:
volumeknob = RotaryEncoder(left_switch, right_switch, mute_switch,
volume_event, boardrevision)
tunerknob = RotaryEncoder(down_switch, up_switch, menu_switch,
tuner_event, boardrevision)
elif radio.getRotaryClass() is radio.ROTARY_ALTERNATIVE:
volumeknob = RotaryEncoderAlternative(left_switch, right_switch,
mute_switch, volume_event,
boardrevision)
tunerknob = RotaryEncoderAlternative(down_switch, up_switch,
menu_switch, tuner_event,
boardrevision)
log.message("Running", log.INFO)
# Main processing loop
count = 0
while True:
switch = radio.getSwitch()
if switch > 0:
get_switch_states(lcd, radio, rss, volumeknob, tunerknob)
radio.setSwitch(0)
display_mode = radio.getDisplayMode()
lcd.setScrollSpeed(0.3) # Scroll speed normal
ipaddr = exec_cmd('hostname -I')
# Shutdown command issued
if display_mode == radio.MODE_SHUTDOWN:
displayShutdown(lcd)
while True:
time.sleep(1)
if len(ipaddr) < 1 and radio.getSource() != radio.PLAYER:
lcd.line2("No IP")
elif display_mode == radio.MODE_TIME:
if radio.getReload():
log.message("Reload ", log.DEBUG)
reload(lcd, radio)
radio.setReload(False)
displayTime(lcd, radio)
if radio.muted():
msg = "Muted"
if radio.getStreaming():
msg = msg + ' *'
lcd.line2(msg)
else:
display_current(lcd, radio)
elif display_mode == radio.MODE_SEARCH:
display_search(lcd, radio)
elif display_mode == radio.MODE_SOURCE:
display_source_select(lcd, radio)
elif display_mode == radio.MODE_OPTIONS:
display_options(lcd, radio)
elif display_mode == radio.MODE_IP:
lcd.line2("Ver " + radio.getVersion())
if len(ipaddr) < 1:
lcd.scroll1("No IP network", interrupt)
else:
lcd.scroll1("IP " + ipaddr, interrupt)
elif display_mode == radio.MODE_RSS:
displayTime(lcd, radio)
display_rss(lcd, rss)
elif display_mode == radio.MODE_SLEEP:
displayTime(lcd, radio)
display_sleep(lcd, radio)
# Timer function
checkTimer(radio)
# Check state (pause or play)
checkState(radio)
# Alarm wakeup function
if display_mode == radio.MODE_SLEEP and radio.alarmFired():
log.message("Alarm fired", log.INFO)
unmuteRadio(lcd, radio)
displayWakeUpMessage(lcd)
radio.setDisplayMode(radio.MODE_TIME)
if radio.volumeChanged():
displayVolume(lcd, radio)
time.sleep(0.1)