def playItems(self, items):
startPlaying = False
for item in items:
try:
self.sonosDevice.add_to_queue(item)
except:
MusicLogging.Instance().info(" error adding...: " +
sys.exc_info()[0])
if startPlaying == False:
try:
startPlaying = self.sonosDevice.play_from_queue(0,
start=True)
# startPlaying = self.sonos.play()
MusicLogging.Instance().info(" Playing...")
except:
MusicLogging.Instance().info(" error starting to play...")
if startPlaying == False:
try:
# startPlaying = self.sonos.play_from_queue(0, start=True)
# noinspection PyUnusedLocal
startPlaying = self.sonosDevice.play()
MusicLogging.Instance().info(" Playing...")
except:
MusicLogging.Instance().info(" error starting to play...")
return True
def setVolume(self, newVolume, volModifier):
MusicLogging.Instance().info(" setting Volume to:" + str(newVolume))
currentHour = time.localtime()[3]
isNight = 0
if currentHour < float(self.daytimeRange[0]) or currentHour > float(
self.daytimeRange[1]): # is it nighttime?
isNight = 1
if isNight:
maxVol = int(round(self.nightVol * volModifier, 0))
if newVolume >= maxVol:
self.setSonosVolume(maxVol)
MusicLogging.Instance().info(
" " + str(newVolume) +
" is to loud for Nighttime volume, setting it to " +
str(maxVol))
elif newVolume < maxVol:
self.setSonosVolume(newVolume)
else:
maxVol = int(round(self.dayVol * volModifier, 0))
if newVolume >= maxVol:
self.setSonosVolume(maxVol)
MusicLogging.Instance().info(
" " + str(newVolume) +
" is to loud for Daytime volume, setting it to " +
str(maxVol))
elif newVolume < maxVol:
self.setSonosVolume(newVolume)
return True
def getMusicLibraryInformationCache(self, searchType, entry, valueType):
returnItems = list([])
# noinspection PyUnusedLocal
startItem = 0
startAtIndex = 0
while True:
try:
# self.music_library.get_music_library_information('albums', start, max_items, full_album_art_uri)
playlist_info = self.sonosDevice.music_library.get_music_library_information(
searchType, start=startAtIndex, max_items=100)
returnedItems = playlist_info.number_returned
except:
MusicLogging.Instance().info("some error")
break
if returnedItems == 0:
break
if entry['type'] == valueType:
for playlist in playlist_info:
playlistTitle = playlist.title
if playlistTitle == entry['item']:
MusicLogging.Instance().info('found ' + entry['item'])
try:
track_list = self.sonosDevice.music_library.browse(
playlist)
returnItems.extend(track_list)
except:
MusicLogging.Instance().info("some error")
startAtIndex += returnedItems
# playlist_info = #sonos.music_library.get_music_library_information('sonos_playlists',search_term='Shovels And Rope')
# MusicLogging.Instance().info('Fonud {} Sonos playlists'.format(playlist_info.number_returned))
return returnItems
def lastTag(self):
try:
# noinspection PyUnusedLocal
var = self.lastSavedTag
MusicLogging.Instance().info("last Tag found")
except:
MusicLogging.Instance().info("last Tag not found")
self.lastSavedTag = None
return self.lastSavedTag
def rotaryEventHandler(self, event):
if event == RotaryEncoder.CLOCKWISE:
MusicLogging.Instance().info("Rotary CLOCKWISE")
self.rightRotaryTurn(event)
elif event == RotaryEncoder.ANTICLOCKWISE:
MusicLogging.Instance().info("Rotary ANTICLOCKWISE")
self.leftRotaryTurn(event)
elif event == RotaryEncoder.BUTTONDOWN:
MusicLogging.Instance().info("Rotary Button down event")
self.rotaryTouch(event)
elif event == RotaryEncoder.BUTTONUP:
MusicLogging.Instance().info("Rotary Button up event")
def markUnknown(self, aTagUid):
tag_uid = str(aTagUid)
MusicLogging.Instance().info(" No record for tag UID: " + tag_uid)
aUnknownTag = {
tag_uid: {
'comment': 'last scan: ' + str(datetime.now()),
'title': '',
'vol': 1,
'time_offset': None,
'type': None,
'item': None
},
}
unknownFileName = self.settings + "/" + "2_unknown_Tags" + ".txt"
if os.path.isfile(unknownFileName):
unknownTagsJSON = open(unknownFileName)
unknownTags = json.load(unknownTagsJSON)
unknownTagsJSON.close()
else:
unknownTags = {}
unknownTags.update(aUnknownTag)
dump = json.dumps(unknownTags,
sort_keys=True,
indent=4,
separators=(',', ': '))
fobj_out = open(unknownFileName, "w")
fobj_out.write(dump)
fobj_out.close()
def play(self, entry):
playItems = self.getPlayList(entry)
# restart if last Tag is the same
lastTag = self.lastTag()
if not lastTag is None:
theTimeDelta = datetime.now() - lastTag["scan"]
MusicLogging.Instance().info("time delta: " + str(theTimeDelta))
if theTimeDelta < timedelta(seconds=self.restartTime):
if entry['tag_id'] == lastTag["tag"]:
if self.restart():
return True
self.unjoin()
self.clearQueue()
if entry['volume']:
self.setMaxVolume(entry['volume'])
if entry['type'] == "artist":
self.playModeShuffleNoRepeat()
elif entry['type'] == "genre":
self.playModeShuffleNoRepeat()
else:
self.playModeNormal()
self.playItems(playItems)
if entry['time_offset']:
self.setSkipTo(entry['time_offset'])
self.setLastTag(entry['tag_id'])
return True
def playModeShuffle(self):
try:
MusicLogging.Instance().info("do SHUFFLE")
self.sonosDevice.play_mode = 'SHUFFLE'
return True
except:
return False
def unjoinForced(self):
try:
self.sonosDevice.unjoin()
MusicLogging.Instance().info("unjoined")
return True
except:
return False
def playModeShuffleNoRepeat(self):
try:
MusicLogging.Instance().info("do SHUFFLE_NOREPEAT")
self.sonosDevice.play_mode = 'SHUFFLE_NOREPEAT'
return True
except:
return False
def next(self):
try:
self.sonosDevice.next()
MusicLogging.Instance().info(" playing next track")
return True
except:
return False
def playModeRepeatAll(self):
try:
MusicLogging.Instance().info("do REPEAT_ALL")
self.sonosDevice.play_mode = 'REPEAT_ALL'
return True
except:
return False
def previous(self):
try:
self.sonosDevice.previous()
MusicLogging.Instance().info(" playing previous track")
return True
except:
return False
def playModeNormal(self):
try:
MusicLogging.Instance().info("do NORMAL")
self.sonosDevice.play_mode = 'NORMAL'
return True
except:
return False
def restart(self):
try:
self.sonosDevice.play()
MusicLogging.Instance().info(" unpause()...")
return True
except:
return False
def sonosVolume(self):
volume = 0
try:
volume = self.sonosDevice.volume
except:
MusicLogging.Instance().info("some error")
return volume
def pause(self):
try:
self.sonosDevice.pause()
MusicLogging.Instance().info(" Sonos paused")
return True
except:
return False
def stop(self):
try:
self.sonosDevice.stop()
MusicLogging.Instance().info(" Sonos stopped")
return True
except:
return False
def setSkipTo(self, time_offset=None):
if time_offset:
try:
self.sonosDevice.seek(time_offset)
MusicLogging.Instance().info(" Skipped to " + time_offset)
return True
except:
return False
return False
def playPause(self):
try:
transportInfo = self.sonosDevice.get_current_transport_info()
if transportInfo['current_transport_state'] == 'PLAYING':
self.sonosDevice.pause()
MusicLogging.Instance().info(" pause()...")
elif transportInfo['current_transport_state'] == 'PAUSED_PLAYBACK':
self.sonosDevice.play()
MusicLogging.Instance().info(" play()...")
elif transportInfo['current_transport_state'] == 'STOPPED':
self.sonosDevice.play()
MusicLogging.Instance().info(" play()... from start")
else:
self.sonosDevice.play()
MusicLogging.Instance().info(" play()... from unknown state")
return True
except:
return False
def startSonos(self, speaker):
# Sonos setup
MusicLogging.Instance().info("Connecting to Sonos...")
self.speakers = soco.discover()
try:
self.sonosDevice = soco.discovery.by_name(speaker)
except:
self.sonosDevice = self.speakers.pop()
return True
def togglePlayModeShuffle(self):
try:
if self.sonosDevice.play_mode == 'SHUFFLE':
self.sonosDevice.play_mode = 'REPEAT_ALL'
MusicLogging.Instance().info("now: REPEAT_ALL")
elif self.sonosDevice.play_mode == 'REPEAT_ALL':
self.sonosDevice.play_mode = 'SHUFFLE'
MusicLogging.Instance().info("now: SHUFFLE")
elif self.sonosDevice.play_mode == 'NORMAL':
self.sonosDevice.play_mode = 'SHUFFLE_NOREPEAT'
MusicLogging.Instance().info("now: SHUFFLE_NOREPEAT")
elif self.sonosDevice.play_mode == 'SHUFFLE_NOREPEAT':
self.sonosDevice.play_mode = 'NORMAL'
MusicLogging.Instance().info("now: NORMAL")
else:
self.sonosDevice.play_mode = 'NORMAL'
MusicLogging.Instance().info("now: NORMAL")
return True
except:
return False
def saveLastTagTime(self):
# only save when a track is playing
try:
transportInfo = self.sonosDevice.get_current_transport_info()
if transportInfo['current_transport_state'] == 'PLAYING':
lastTag = self.lastTag()
if not lastTag is None:
self.lastSavedTag = {
"tag": lastTag["tag"],
"scan": datetime.now()
}
MusicLogging.Instance().info("last tag time saved")
return True
else:
MusicLogging.Instance().info("did not save last tag time")
return False
else:
MusicLogging.Instance().info("music is currently not playing")
return False
except:
return False
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 setLastTag(self, tag_uid):
MusicLogging.Instance().info("last Tag saved")
self.lastSavedTag = {"tag": tag_uid, "scan": datetime.now()}
def stopAll(self):
MusicLogging.Instance().info("Stopping RasPi")
GPIO.cleanup()
def stopAll(self):
MusicLogging.Instance().info("Stopping Sonos")
def setSonosVolume(self, volume):
try:
self.sonosDevice.volume = volume
except:
MusicLogging.Instance().info("some error")
return True
