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)