mirror of
https://github.com/pkali/piradio-mini.git
synced 2026-05-20 22:34:22 +02:00
Pecusx
565 lines
15 KiB
Python
Executable File
565 lines
15 KiB
Python
Executable File
#!/usr/bin/env python
|
|
#
|
|
# Raspberry Pi Internet Radio Class
|
|
# $Id: config_class.py,v 1.32 2016/07/23 13:21:28 bob Exp $
|
|
#
|
|
# Author : Bob Rathbone
|
|
# Site : http://www.bobrathbone.com
|
|
#
|
|
# This class reads the /etc/radiod.conf file for configuration parameters
|
|
#
|
|
# License: GNU V3, See https://www.gnu.org/copyleft/gpl.html
|
|
#
|
|
# Disclaimer: Software is provided as is and absolutly no warranties are implied or given.
|
|
# The authors shall not be liable for any loss or damage however caused.
|
|
#
|
|
|
|
import os
|
|
import sys
|
|
import ConfigParser
|
|
from log_class import Log
|
|
|
|
# System files
|
|
ConfigFile = "/etc/radiod.conf"
|
|
|
|
log = Log()
|
|
config = ConfigParser.ConfigParser()
|
|
|
|
|
|
class Configuration:
|
|
# Input source
|
|
RADIO = 0
|
|
PLAYER = 1
|
|
PANDORA = 2
|
|
LIST = 0
|
|
STREAM = 1
|
|
|
|
# Rotary class selection
|
|
STANDARD = 0 # Select rotary_class.py
|
|
ALTERNATIVE = 1 # Select rotary_class_alternative.py
|
|
|
|
# Configuration parameters
|
|
mpdport = 6600 # MPD port number
|
|
dateFormat = "%H:%M %d/%m/%Y" # Date format
|
|
#volume_range = 100 # Volume range 10 to 100
|
|
volume_min = 0
|
|
volume_max = 100
|
|
volume_increment = 4
|
|
display_playlist_number = False # Two line displays only, display station(n)
|
|
source = RADIO # Source RADIO or Player
|
|
stationNamesSource = LIST # Station names from playlist names or STREAM
|
|
rotary_class = STANDARD # Rotary class STANDARD or ALTERNATIVE
|
|
|
|
# Remote control parameters
|
|
remote_led = 0 # Remote Control activity LED 0 = No LED
|
|
remote_control_host = 'localhost' # Remote control to radio communication port
|
|
remote_listen_host = 'localhost' # Remote control to radio communication port
|
|
remote_control_port = 5100 # Remote control to radio communication port
|
|
|
|
ADAFRUIT = 1 # I2C backpack type AdaFruit
|
|
PCF8574 = 2 # I2C backpack type PCF8574
|
|
i2c_backpack = ADAFRUIT
|
|
i2c_address = 0x00 # Use defaults or use setting in radiod.conf
|
|
backpack_names = [ 'UNKWOWN','ADAFRUIT','PCF8574']
|
|
speech = False # Speech on for visually impaired or blind persons
|
|
isVerbose = False # Extra speech verbosity
|
|
speech_volume = 80 # Percentage speech volume
|
|
use_playlist_extensions = False # MPD 0.15 requires playlist.<ext>
|
|
rss = False # RSS in standby mode (Pecus)
|
|
bright = True # LCD high brightness (Pecus)
|
|
media_update = False # always update media library (Pecus)
|
|
pandora_available = False # is Pandora accout available ? (Pecus)
|
|
force_streaming = False # If True, streaming is possible even on weak raspberries (1 core)
|
|
|
|
# Colours for Adafruit LCD
|
|
color = { 'OFF': 0x0, 'RED' : 0x1, 'GREEN' : 0x2, 'YELLOW' : 0x3,
|
|
'BLUE' : 0x4, 'VIOLET' : 0x5, 'TEAL' : 0x6, 'WHITE' : 0x7 }
|
|
|
|
colorName = { 0: 'Off', 1 : 'Red', 2 : 'Green', 3 : 'Yellow',
|
|
4 : 'Blue', 5 : 'Violet', 6 : 'Teal', 7 : 'White' }
|
|
|
|
colors = { 'bg_color' : 0x0,
|
|
'mute_color' : 0x0,
|
|
'shutdown_color' : 0x0,
|
|
'error_color' : 0x0,
|
|
'search_color' : 0x0,
|
|
'source_color' : 0x0,
|
|
'info_color' : 0x0,
|
|
'menu_color' : 0x0,
|
|
'sleep_color': 0x0 }
|
|
|
|
# List of loaded options for display
|
|
configOptions = {}
|
|
|
|
# Other definitions
|
|
UP = 0
|
|
DOWN = 1
|
|
|
|
# GPIOs for switches and rotary encoder configuration
|
|
switches = { "menu_switch": 25,
|
|
"mute_switch": 4,
|
|
"left_switch": 14,
|
|
"right_switch": 15,
|
|
"up_switch": 17,
|
|
"down_switch": 18,
|
|
}
|
|
|
|
# GPIOs for LCD connections
|
|
lcdconnects = {
|
|
"lcd_enable": 8,
|
|
"lcd_select": 7,
|
|
"lcd_data4": 27,
|
|
"lcd_data5": 22,
|
|
"lcd_data6": 23,
|
|
"lcd_data7": 24,
|
|
"lcd_bri": 10,
|
|
}
|
|
|
|
# Initialisation routine
|
|
def __init__(self):
|
|
log.init('radio')
|
|
if not os.path.isfile(ConfigFile) or os.path.getsize(ConfigFile) == 0:
|
|
log.message("Missing configuration file " + ConfigFile, log.ERROR)
|
|
else:
|
|
self.getConfig()
|
|
|
|
return
|
|
|
|
# Get configuration options from /etc/radiod.conf
|
|
def getConfig(self):
|
|
section = 'RADIOD'
|
|
|
|
# Get options
|
|
config.read(ConfigFile)
|
|
try:
|
|
options = config.options(section)
|
|
for option in options:
|
|
parameter = config.get(section,option)
|
|
msg = "Config option: " + option + " = " + parameter
|
|
|
|
self.configOptions[option] = parameter
|
|
|
|
if option == 'loglevel':
|
|
next
|
|
|
|
#elif option == 'volume_range':
|
|
# range = int(parameter)
|
|
# if range < 10:
|
|
# range = 10
|
|
# if range > 100:
|
|
# range = 100
|
|
# self.volume_range = range
|
|
# self.volume_increment = int(range/21)
|
|
|
|
elif option == 'volume_min':
|
|
if int(parameter) < 0:
|
|
self.volume_min = 0
|
|
else:
|
|
self.volume_min = int(parameter)
|
|
|
|
elif option == 'volume_max':
|
|
if int(parameter) > 100:
|
|
self.volume_max = 100
|
|
else:
|
|
self.volume_max = int(parameter)
|
|
|
|
elif option == 'remote_led':
|
|
self.remote_led = int(parameter)
|
|
|
|
elif option == 'remote_control_host':
|
|
self.remote_control_host = parameter
|
|
|
|
elif option == 'remote_control_port':
|
|
self.remote_control_port = int(parameter)
|
|
|
|
elif option == 'remote_listen_host':
|
|
self.remote_listen_host = parameter
|
|
|
|
elif option == 'mpdport':
|
|
self.mpdport = int(parameter)
|
|
|
|
elif option == 'dateformat':
|
|
self.dateFormat = parameter
|
|
|
|
elif option == 'display_playlist_number':
|
|
if parameter == 'yes':
|
|
self.display_playlist_number = True
|
|
|
|
elif option == 'startup':
|
|
if parameter == 'MEDIA':
|
|
self.source = self.PLAYER
|
|
elif parameter == 'PANDORA':
|
|
self.source = self.PANDORA
|
|
|
|
elif option == 'station_names':
|
|
if parameter == 'stream':
|
|
self.stationNamesSource = self.STREAM
|
|
else:
|
|
self.stationNamesSource = self.LIST
|
|
|
|
elif option == 'i2c_backpack':
|
|
if parameter == 'PCF8574':
|
|
self.i2c_backpack = self.PCF8574
|
|
else:
|
|
self.i2c_backpack = self.ADAFRUIT
|
|
|
|
elif option == 'i2c_address':
|
|
value = int(parameter,16)
|
|
if parameter > 0x00:
|
|
self.i2c_address = value
|
|
|
|
elif 'color' in option:
|
|
try:
|
|
self.colors[option] = self.color[parameter]
|
|
except:
|
|
log.message("Invalid option " + option + ' ' + parameter, log.ERROR)
|
|
|
|
elif option == 'speech':
|
|
if parameter == 'yes':
|
|
self.speech = True
|
|
else:
|
|
self.speech = False
|
|
|
|
elif option == 'verbose':
|
|
if parameter == 'yes':
|
|
self.isVerbose = True
|
|
else:
|
|
self.isVerbose = False
|
|
|
|
elif option == 'speech_volume':
|
|
self.speech_volume = int(parameter)
|
|
|
|
elif option == 'use_playlist_extensions':
|
|
if parameter == 'yes':
|
|
self.use_playlist_extensions = True
|
|
else:
|
|
self.use_playlist_extensions = False
|
|
|
|
elif '_switch' in option:
|
|
switch = int(parameter)
|
|
try:
|
|
self.switches[option] = switch
|
|
except:
|
|
msg = "Invalid switch parameter " + option
|
|
log.message(msg,log.ERROR)
|
|
|
|
elif 'lcd_' in option:
|
|
lcdconnect = int(parameter)
|
|
try:
|
|
self.lcdconnects[option] = lcdconnect
|
|
except:
|
|
msg = "Invalid LCD connect parameter " + option
|
|
log.message(msg,log.ERROR)
|
|
|
|
elif option == 'rotary_class':
|
|
if parameter == 'standard':
|
|
self.rotary_class = self.STANDARD
|
|
else:
|
|
self.rotary_class = self.ALTERNATIVE
|
|
|
|
elif option == 'rss': # option for RSS in standby mode (Pecus)
|
|
if parameter == 'yes': # (Pecus)
|
|
self.rss = True # (Pecus)
|
|
else: # (Pecus)
|
|
self.rss = False # (Pecus)
|
|
|
|
elif option == 'bright': # option for high brightness of LCD (Pecus)
|
|
if parameter == 'yes': # (Pecus)
|
|
self.bright = True # (Pecus)
|
|
else: # (Pecus)
|
|
self.bright = False # (Pecus)
|
|
|
|
elif option == 'media_update': # option for update media library (Pecus)
|
|
if parameter == 'yes': # (Pecus)
|
|
self.media_update = True # (Pecus)
|
|
else: # (Pecus)
|
|
self.media_update = False # (Pecus)
|
|
|
|
elif option == 'pandora_available': # option for Pandora availablity (Pecus)
|
|
if parameter == 'yes': # (Pecus)
|
|
self.pandora_available = True # (Pecus)
|
|
else: # (Pecus)
|
|
self.pandora_available = False # (Pecus)
|
|
|
|
elif option == 'force_streaming': # option for streaming availablity on 1 core raspberries (Pecus)
|
|
if parameter == 'yes': # (Pecus)
|
|
self.force_streaming = True # (Pecus)
|
|
else: # (Pecus)
|
|
self.force_streaming = False # (Pecus)
|
|
|
|
|
|
else:
|
|
msg = "Invalid option " + option + ' in section ' \
|
|
+ section + ' in ' + ConfigFile
|
|
log.message(msg,log.ERROR)
|
|
|
|
if self.source == self.PANDORA:
|
|
if not self.pandora_available:
|
|
self.source = self.RADIO
|
|
|
|
range = self.volume_max - self.volume_min
|
|
if range < 22:
|
|
self.volume_min = 0
|
|
sel.volume_max = 100
|
|
range = 100
|
|
self.volume_increment = int(range/21)
|
|
except ConfigParser.NoSectionError:
|
|
msg = ConfigParser.NoSectionError(section),'in',ConfigFile
|
|
log.message(msg,log.ERROR)
|
|
return
|
|
|
|
# Get routines
|
|
|
|
# Get I2C backpack type
|
|
def getBackPackType(self):
|
|
return self.i2c_backpack
|
|
|
|
# Get I2C backpack address
|
|
def getI2Caddress(self):
|
|
return self.i2c_address
|
|
|
|
# Get I2C backpack name
|
|
def getBackPackName(self):
|
|
return self.backpack_names[self.i2c_backpack]
|
|
|
|
# Get the volume range
|
|
#def getVolumeRange(self):
|
|
# return self.volume_range
|
|
|
|
def getVolumeMax(self):
|
|
return self.volume_max
|
|
|
|
def getVolumeMin(self):
|
|
return self.volume_min
|
|
|
|
# Get the volume increment
|
|
def getVolumeIncrement(self):
|
|
return self.volume_increment
|
|
|
|
# Get the remote control activity LED number
|
|
def getRemoteLed(self):
|
|
return self.remote_led
|
|
|
|
# Get the remote Host default localhost
|
|
def getRemoteUdpHost(self):
|
|
return self.remote_control_host
|
|
|
|
# Get the UDP server listener IP Host default localhost
|
|
# or 0.0.0.0 for all interfaces
|
|
def getRemoteListenHost(self):
|
|
return self.remote_listen_host
|
|
|
|
# Get the remote Port default 5100
|
|
def getRemoteUdpPort(self):
|
|
return self.remote_control_port
|
|
|
|
# Get the mpdport
|
|
def getMpdPort(self):
|
|
return self.mpdport
|
|
|
|
# Get the date format
|
|
def getDateFormat(self):
|
|
return self.dateFormat
|
|
|
|
# Get display playlist number (Two line displays only)
|
|
def getDisplayPlaylistNumber(self):
|
|
return self.display_playlist_number
|
|
|
|
# Get the startup source 0=RADIO or 1=MEDIA
|
|
def getSource(self):
|
|
return self.source
|
|
|
|
# Get the startup source name RADIO MEDIA
|
|
def getSourceName(self):
|
|
source_name = "MEDIA"
|
|
if self.getSource() < 1:
|
|
source_name = "RADIO"
|
|
return source_name
|
|
|
|
# Get the background color (Integer)
|
|
def getBackColor(self,sColor):
|
|
color = 0x0
|
|
# Get the remote Port default 5100
|
|
def getRemoteUdpPort(self):
|
|
return self.remote_control_port
|
|
|
|
# Get the mpdport
|
|
def getMpdPort(self):
|
|
return self.mpdport
|
|
|
|
# Get the date format
|
|
def getDateFormat(self):
|
|
return self.dateFormat
|
|
|
|
# Get display playlist number (Two line displays only)
|
|
def getDisplayPlaylistNumber(self):
|
|
return self.display_playlist_number
|
|
|
|
# Get the startup source 0=RADIO or 1=MEDIA
|
|
def getSource(self):
|
|
return self.source
|
|
|
|
# Get the startup source name RADIO MEDIA
|
|
def getSourceName(self):
|
|
source_name = "MEDIA"
|
|
if self.getSource() < 1:
|
|
source_name = "RADIO"
|
|
return source_name
|
|
|
|
# Get the background color (Integer)
|
|
def getBackColor(self,sColor):
|
|
color = 0x0
|
|
try:
|
|
color = self.colors[sColor]
|
|
except:
|
|
log.message("Invalid option " + sColor, log.ERROR)
|
|
return color
|
|
|
|
# Cycle background colors
|
|
def cycleColor(self,direction):
|
|
color = self.getBackColor('bg_color')
|
|
|
|
if direction == self.UP:
|
|
color += 1
|
|
else:
|
|
color -= 1
|
|
|
|
if color < 0:
|
|
color = 0x7
|
|
elif color > 0x7:
|
|
color = 0x0
|
|
|
|
self.colors['bg_color'] = color
|
|
return color
|
|
|
|
|
|
# Get the background colour string name
|
|
def getBackColorName(self,iColor):
|
|
sColor = 'None'
|
|
try:
|
|
sColor = self.colorName[iColor]
|
|
except:
|
|
log.message("Invalid option " + int(iColor), log.ERROR)
|
|
return sColor
|
|
|
|
# Get speech
|
|
def getSpeech(self):
|
|
return self.speech
|
|
|
|
# Get verbose
|
|
def verbose(self):
|
|
return self.isVerbose
|
|
|
|
# Get RSS mode (Pecus)
|
|
def getRss(self): # (Pecus)
|
|
return self.rss # (Pecus)
|
|
|
|
# Get LCD brightness mode (Pecus)
|
|
def getBright(self): # (Pecus)
|
|
return self.bright # (Pecus)
|
|
|
|
# Get always media update flag (Pecus)
|
|
def getAlwaysUpdate(self): # (Pecus)
|
|
return self.media_update # (Pecus)
|
|
|
|
# Get pandora flag (Pecus)
|
|
def getPandoraAvailable(self): # (Pecus)
|
|
return self.pandora_available # (Pecus)
|
|
|
|
# Get streaming flag (Pecus)
|
|
def getForceStreaming(self): # (Pecus)
|
|
return self.force_streaming # (Pecus)
|
|
|
|
# Get speech volume % of normal volume level
|
|
def getSpeechVolume(self):
|
|
return self.speech_volume
|
|
|
|
# Get playlist extensions used
|
|
def getPlaylistExtensions(self):
|
|
return self.use_playlist_extensions
|
|
|
|
# Return the station name source (Stream or playlist)
|
|
def getStationNamesSource(self):
|
|
return self.stationNamesSource
|
|
|
|
# Display parameters
|
|
def display(self):
|
|
for option in self.configOptions:
|
|
param = self.configOptions[option]
|
|
if option != 'None':
|
|
log.message(option + " = " + param, log.DEBUG)
|
|
return
|
|
|
|
# Return the ID of the rotary class to be used STANDARD or ALTERNATIVE
|
|
def getRotaryClass(self):
|
|
return self.rotary_class
|
|
|
|
# Returns the switch GPIO configuration by label
|
|
def getSwitchGpio(self,label):
|
|
switch = -1
|
|
try:
|
|
switch = self.switches[label]
|
|
except:
|
|
msg = "Invalid switch label " + label
|
|
log.message(msg, log.ERROR)
|
|
return switch
|
|
|
|
# Returns the LCD GPIO configuration by label
|
|
def getLcdGpio(self,label):
|
|
switch = -1
|
|
try:
|
|
lcdconnect = self.lcdconnects[label]
|
|
except:
|
|
msg = "Invalid LCD connection label " + label
|
|
log.message(msg, log.ERROR)
|
|
return lcdconnect
|
|
|
|
# End Configuration of class
|
|
|
|
# Test Configuration class
|
|
if __name__ == '__main__':
|
|
|
|
config = Configuration()
|
|
print "Configuration file", ConfigFile
|
|
#print "Volume range:", config.getVolumeRange()
|
|
print "Volume min.:", config.getVolumeMin()
|
|
print "Volume max.:", config.getVolumeMax()
|
|
print "Volume increment:", config.getVolumeIncrement()
|
|
print "Mpd port:", config.getMpdPort()
|
|
print "Remote LED:", config.getRemoteLed()
|
|
print "Remote LED port:", config.getRemoteUdpPort()
|
|
print "Date format:", config.getDateFormat()
|
|
print "Display playlist number:", config.getDisplayPlaylistNumber()
|
|
print "Source:", config.getSource(), config.getSourceName()
|
|
print "Background colour number:", config.getBackColor('bg_color')
|
|
print "Background colour:", config.getBackColorName(config.getBackColor('bg_color'))
|
|
print "Speech:", config.getSpeech()
|
|
print "Speech volume:", str(config.getSpeechVolume()) + '%'
|
|
print "Verbose:", config.verbose()
|
|
print "RRS in standby:", config.getRss() # (Pecus)
|
|
print "LCD high brightness:", config.getBright() # (Pecus)
|
|
print "Always update media library:", config.getAlwaysUpdate() # (Pecus)
|
|
print "Pandora account available:", config.getPandoraAvailable() # (Pecus)
|
|
print "Streaming on 1 core raspberries:",config.getForceStreaming() # (Pecus)
|
|
if config.getStationNamesSource() is 1:
|
|
sSource = "STREAM"
|
|
else:
|
|
sSource = "LIST"
|
|
print "Station names source:",sSource
|
|
print "Use playlist extensions:", config.getPlaylistExtensions()
|
|
|
|
for switch in config.switches:
|
|
print switch, config.getSwitchGpio(switch)
|
|
|
|
for lcdconnect in sorted(config.lcdconnects):
|
|
print lcdconnect, config.getLcdGpio(lcdconnect)
|
|
|
|
rclass = ['Standard', 'Alternative']
|
|
rotary_class = config.getRotaryClass()
|
|
print "Rotary class:", rotary_class, rclass[rotary_class]
|
|
print "Backpack type:", config.getBackPackType(), config.getBackPackName()
|
|
print "I2C address:", hex(config.getI2Caddress())
|
|
|
|
# End of file
|
|
|