def hibernate(self, onoff):
if onoff:
self.write_memory(self.dsp.HIBERNATE_REGISTER,
int_data(1, self.dsp.REGISTER_WORD_LENGTH))
else:
self.write_memory(self.dsp.HIBERNATE_REGISTER,
int_data(0, self.dsp.REGISTER_WORD_LENGTH))
def _kill_dsp():
logging.debug("killing DSP core")
dsp = SigmaTCPHandler.dsp
spi = SigmaTCPHandler.spi
spi.write(dsp.HIBERNATE_REGISTER, int_data(1,
dsp.REGISTER_WORD_LENGTH))
time.sleep(0.0001)
spi.write(dsp.KILLCORE_REGISTER, int_data(0, dsp.REGISTER_WORD_LENGTH))
time.sleep(0.0001)
spi.write(dsp.KILLCORE_REGISTER, int_data(1, dsp.REGISTER_WORD_LENGTH))
def param_to_bytes(self,
value,
max_length=1,
ignore_limit=False,
word_length=None):
biquad = False
if word_length is None:
word_length = self.dsp.WORD_LENGTH
if isinstance(value, float):
value = self.dsp.decimal_repr(value)
res = int_data(value, word_length)
elif isinstance(value, int):
res = int_data(value, word_length)
elif isinstance(value, Biquad):
res = []
bqn = value.normalized()
vals = []
vals.append(bqn.b2)
vals.append(bqn.b1)
vals.append(bqn.b0)
vals.append(-bqn.a2)
vals.append(-bqn.a1)
for v in vals:
dec = self.dsp.decimal_repr(v)
res = res + list(int_data(dec, word_length))
elif isinstance(value, Iterable):
res = []
for part in value:
if isinstance(part, Biquad):
biquad = True
res = res + self.param_to_bytes(part, 0, ignore_limit=True)
else:
raise RuntimeError("parameter type not implemented: %s",
type(value).__name__)
while len(res) < max_length * word_length:
if biquad:
# Fill biquad filter banks with pass filters
passfilter = Biquad.pass_filter()
res = res + \
self.param_to_bytes(passfilter, 0, ignore_limit=True)
else:
# Fill with zeros
res.append(0)
if not (ignore_limit) and len(res) > (max_length * word_length):
logging.error(
"parameter set too long (%s bytes), won't fit into %s words",
len(res), max_length * self.dsp.WORD_LENGTH)
res = None
return res
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, datatools.int_data(1))
else:
self.sigmatcp.write_memory(mutereg, datatools.int_data(0))
return True
else:
return False
def write_eeprom_content_request(data):
if isinstance(data, str):
data = data.encode("utf-8")
packet = bytearray(HEADER_SIZE)
packet[0] = COMMAND_WRITE_EEPROM_CONTENT
packet[3:7] = datatools.int_data(len(data) + HEADER_SIZE, 4)
packet.extend(bytearray(data))
return packet
def update_dsp(self, value):
if value is None:
return
# convert percent to multiplier
volume = percent2amplification(value)
# write multiplier to DSP
dspdata = datatools.int_data(self.dsp.decimal_repr(volume),
self.volume_register_length)
self.spi.write(self.volume_register, dspdata)
self.dspdata = dspdata
self.dspvol = value
def update_volume(self):
if self.volume_register is None or self.spdif_register is None:
return False
# Read SPDIF status registers
data = self.spi.read(0xf617, 6)
if len(data) != 6:
logging.error("internal error: could not read 6 bytes from SPI")
return False
_b1, vol, volid, _b2 = struct.unpack(">BHHB", data)
if volid != 0x048a:
return False
if vol < 0x100f or vol > 0x164f:
return False
# Read SPDIF enable register
data = self.spi.read(self.spdif_register, 4)
[spdif_active] = struct.unpack(">l", data)
if spdif_active == 0:
return False
volpercent = (vol - 0x100f) / 16
if volpercent < 0 or volpercent > 100:
logging.error(
"internal error, got volume = %s, "
"but should be in 0-100 range", volpercent)
# convert percent to multiplier
volume = percent2amplification(volpercent)
# write multiplier to DSP
dspdata = datatools.int_data(self.dsp.decimal_repr(volume),
self.volume_register_length)
self.spi.write(self.volume_register, dspdata)
return True
def write_volume(self, volume):
assert 0 <= volume <= 100
dspdata = datatools.int_data(
self.dsp.decimal_repr(percent2amplification(volume)),
self.dsp.WORD_LENGTH)
self.spi.write(self.volume_register, dspdata)
def reset(self):
self.write_memory(self.dsp.RESET_REGISTER,
int_data(0, self.dsp.REGISTER_WORD_LENGTH))
time.sleep(0.5)
self.write_memory(self.dsp.RESET_REGISTER,
int_data(1, self.dsp.REGISTER_WORD_LENGTH))
def get_decimal_repr(self, value):
data = self.dsp.decimal_repr(value)
return int_data(data, self.dsp.DECIMAL_LEN)
