def __init__(self,
ip="127.0.0.1",
dsp=Adau145x()):
self.dsp = dsp
self.ip = ip
self.sigmatcp = SigmaTCPClient(self.dsp, self.ip)
self.resetgpio = None
def main():
global sigmatcp
if len(sys.argv) > 1:
if "-v" in sys.argv:
logging.basicConfig(format='%(levelname)s: %(name)s - %(message)s',
level=logging.DEBUG,
force=True)
else:
logging.basicConfig(format='%(levelname)s: %(name)s - %(message)s',
level=logging.INFO,
force=True)
signal.signal(signal.SIGUSR1, stop_playback)
sigmatcp = SigmaTCPClient(Adau145x(), "127.0.0.1")
while True:
time.sleep(1)
if stopped:
logging.debug("stopped")
continue
if (spdifactive()):
silenceloop()
else:
logging.debug("no SPDIF lock, sleeping")
def set_ip(self, ip):
self.ip = ip
self.sigmatcp = SigmaTCPClient(self.dsp, self.ip)
class DSPToolkit():
def __init__(self, ip="127.0.0.1", dsp=Adau145x()):
self.dsp = dsp
self.ip = ip
self.sigmatcp = SigmaTCPClient(self.dsp, self.ip)
self.resetgpio = None
def set_ip(self, ip):
self.ip = ip
self.sigmatcp = SigmaTCPClient(self.dsp, self.ip)
def set_volume(self, volume):
volctl = datatools.parse_int(
self.sigmatcp.request_metadata(ATTRIBUTE_VOL_CTL))
if volctl is not None:
self.sigmatcp.write_decimal(volctl, volume)
return True
else:
logging.info("%s is undefined", ATTRIBUTE_VOL_CTL)
return False
def set_limit(self, volume):
volctl = datatools.parse_int(
self.sigmatcp.request_metadata(ATTRIBUTE_VOL_LIMIT))
if volctl is not None:
self.sigmatcp.write_decimal(volctl, volume)
return True
else:
logging.info("%s is undefined", ATTRIBUTE_VOL_LIMIT)
return False
def get_volume(self):
volctl = None
try:
volctl = datatools.parse_int(
self.sigmatcp.request_metadata(ATTRIBUTE_VOL_CTL))
except:
pass
if volctl is not None:
return self.sigmatcp.read_decimal(volctl)
else:
logging.info("%s is undefined", ATTRIBUTE_VOL_CTL)
def get_limit(self):
volctl = datatools.parse_int(
self.sigmatcp.request_metadata(ATTRIBUTE_VOL_LIMIT))
if volctl:
return self.sigmatcp.read_decimal(volctl)
else:
logging.info("%s is undefined", ATTRIBUTE_VOL_LIMIT)
def set_balance(self, value):
'''
Sets the balance of left/right channels.
Value ranges from 0 (only left channel) to 2 (only right channel)
at balance=1 the volume setting on both channels is equal
'''
if (value < 0) or (value > 2):
raise RuntimeError("Balance value must be between 0 and 2")
balctl = datatools.parse_int(
self.sigmatcp.request_metadata(ATTRIBUTE_BALANCE))
if balctl is not None:
self.sigmatcp.write_decimal(balctl, value)
def write_biquad(self, addr, bq_params):
self.sigmatcp.write_biquad(addr, bq_params)
def write_fir(self, coefficients, mode=MODE_BOTH):
(firleft, len_left) = datatools.parse_int_length(
self.sigmatcp.request_metadata(ATTRIBUTE_FIR_FILTER_LEFT))
(firright, len_right) = datatools.parse_int_length(
self.sigmatcp.request_metadata(ATTRIBUTE_FIR_FILTER_RIGHT))
if mode == MODE_BOTH or mode == MODE_LEFT:
result = self.write_coefficients(firleft, len_left, coefficients)
if mode == MODE_BOTH or mode == MODE_RIGHT:
result = self.write_coefficients(firright, len_right, coefficients)
return result
def write_coefficients(self, addr, length, coefficients):
if len(coefficients) > length:
logging.error("can't deploy coefficients %s > %s",
len(coefficients), length)
return False
data = []
for coeff in coefficients:
x = list(self.sigmatcp.get_decimal_repr(coeff))
data[0:0] = x
x = list(self.sigmatcp.get_decimal_repr(0))
for _i in range(len(coefficients), length):
data[0:0] = x
self.sigmatcp.write_memory(addr, data)
return True
def get_checksum(self):
return self.sigmatcp.program_checksum()
def generic_request(self, request_code, response_code=None):
return self.sigmatcp.request_generic(request_code, response_code)
def set_filters(self, filters, mode=MODE_BOTH, cutoff_long=False):
(addr_left, length_left) = datatools.parse_int_length(
self.sigmatcp.request_metadata(ATTRIBUTE_IIR_FILTER_LEFT))
(addr_right, length_right) = datatools.parse_int_length(
self.sigmatcp.request_metadata(ATTRIBUTE_IIR_FILTER_RIGHT))
if mode == MODE_LEFT:
maxlen = length_left
elif mode == MODE_RIGHT:
maxlen = length_right
else:
maxlen = min(length_left, length_right)
assert maxlen % 5 == 0
maxlen = maxlen / 5
if len(filters) > maxlen and (cutoff_long == False):
raise (DSPError(
"{} filters given, but filter bank has only {} slots".format(
len(filters), maxlen)))
self.hibernate(True)
logging.debug("deploying filters %s", filters)
i = 0
for f in filters:
logging.debug(f)
if mode == MODE_LEFT or mode == MODE_BOTH:
if i < length_left:
self.sigmatcp.write_biquad(addr_left + i * 5, f)
if mode == MODE_RIGHT or mode == MODE_BOTH:
if i < length_right:
self.sigmatcp.write_biquad(addr_right + i * 5, f)
i += 1
if i > maxlen:
break
self.hibernate(False)
def clear_iir_filters(self, mode=MODE_BOTH):
# Simply fill filter arrays with dummy filters
self.set_filters([Biquad.plain()] * 256, mode=mode, cutoff_long=True)
def install_profile(self, xmlfile):
return self.sigmatcp.write_eeprom_from_file(xmlfile)
def install_profile_from_content(self, content):
return self.sigmatcp.write_eeprom_from_xml(content)
def mute(self, mute=True):
mutereg = datatools.parse_int(
self.sigmatcp.request_metadata(ATTRIBUTE_MUTE_REG))
if mutereg is not None:
if mute:
self.sigmatcp.write_memory(mutereg, self.sigmatcp.int_data(1))
else:
self.sigmatcp.write_memory(mutereg, self.sigmatcp.int_data(0))
return True
else:
return False
def reset(self):
self.sigmatcp.reset()
def hibernate(self, hibernate=True):
self.sigmatcp.hibernate(hibernate)
time.sleep(0.001)
def get_meta(self, attribute):
return self.sigmatcp.request_metadata(attribute)
def get_samplerate(self):
sr = datatools.parse_int(
self.sigmatcp.request_metadata(ATTRIBUTE_SAMPLERATE))
if sr is None or sr == 0:
return 48000
else:
return sr
