Beispiel #1
0
    def __init__(self,
                 i2c=None,
                 spi=None,
                 ad7608=None,
                 gpio=None,
                 volt_ch1=2,
                 volt_ch2=3,
                 curr_ch1=0,
                 curr_ch2=1,
                 eeprom_dev_addr=None,
                 sensor_dev_addr=None,
                 ipcore=None):

        self.ipcore = ipcore
        if (i2c is not None and spi is not None and ad7608 is not None
                and gpio is not None):
            spi.set_mode('MODE2')
            self.cat9555 = CAT9555(ElektraDef.CAT9555_ADDR, i2c)
            self.eeprom = CAT24C32(eeprom_dev_addr, i2c)
            self.sensor = NCT75(sensor_dev_addr, i2c)
            self.ad5663 = AD5663R(spi, ElektraDef.DAC_MV_REF,
                                  ElektraDef.DAC_MODE_REF)
            self.ad7608 = ad7608
            self.gpio = gpio
        elif (ipcore is not None and i2c is not None):
            self.spi = ipcore.spi
            self.spi.set_mode('MODE2')
            self.ad5663 = AD5663R(ipcore.spi, ElektraDef.DAC_MV_REF,
                                  ElektraDef.DAC_MODE_REF)
            self.gpio = None
            self.cat9555 = CAT9555(ElektraDef.CAT9555_ADDR, i2c)
            self.eeprom = CAT24C32(ElektraDef.EEPROM_DEV_ADDR, i2c)
            self.sensor = NCT75(ElektraDef.SENSOR_DEV_ADDR, i2c)
            self.ad7608 = ad7608 or MIXAD760XSGEmulator(
                "mix_ad760x_sg_emulator")
        elif (i2c is None and spi is None and ad7608 is None and gpio is None):
            self.cat9555 = CAT9555Emulator(ElektraDef.CAT9555_ADDR, None, None)
            self.eeprom = None
            self.sensor = None
            self.ad5663 = AD5663R(spi, ElektraDef.DAC_MV_REF,
                                  ElektraDef.DAC_MODE_REF)
            self.ad7608 = MIXAD760XSGEmulator("mix_ad760x_sg_emulator")
            self.gpio = GPIOEmulator("gpio_emulator")
        else:
            raise ElektraException(
                '__init__ error! Please check the parameters!')
        super(ElektraBase, self).__init__(self.eeprom,
                                          self.sensor,
                                          cal_table=elektra_calibration_info,
                                          range_table=elektra_range_table)
        self.adc_voltage_channel = {'ch1': volt_ch1, 'ch2': volt_ch2}
        self.adc_current_channel = {'ch1': curr_ch1, 'ch2': curr_ch2}
Beispiel #2
0
    def __init__(self,
                 i2c,
                 ad717x=None,
                 ipcore=None,
                 eeprom_dev_addr=CloakDef.EEPROM_DEV_ADDR,
                 sensor_dev_addr=CloakDef.SENSOR_DEV_ADDR,
                 cal_info=None,
                 range_table=None):

        if ipcore and ad717x:
            raise CloakException(
                'Not allowed to use both aggregated IP and AD717X')
        if i2c:
            self.eeprom = CAT24C32(eeprom_dev_addr, i2c)
            self.sensor = NCT75(sensor_dev_addr, i2c)
        else:
            self.eeprom = EepromEmulator('eeprom_emulator')
            self.sensor = NCT75Emulator('nct75_emulator')

        if ipcore:
            self.ipcore = ipcore
            self.ad717x = self.ipcore.ad717x
        elif ad717x:
            self.ad717x = ad717x
        else:
            raise CloakException('Use one of aggregated IP or AD717X')

        super(CloakBase, self).__init__(self.eeprom,
                                        self.sensor,
                                        cal_table=cal_info,
                                        range_table=range_table)
Beispiel #3
0
    def __init__(self, i2c, ipcore, range_table=starlordii_range_table):

        self.eeprom = CAT24C32(Audio005Def.EEPROM_I2C_ADDR, i2c)
        self.nct75 = NCT75(Audio005Def.TEMP_I2C_ADDR, i2c)
        self.pca9536 = PCA9536(Audio005Def.PCA9536_DEV_ADDR, i2c)

        if isinstance(ipcore, basestring):
            ipcore = MIXAudio005SGR(ipcore)

        self.ipcore = ipcore
        self.analyzer = self.ipcore.analyzer
        self.signal_source = self.ipcore.signal_source
        self.adc_rst_pin = Pin(self.ipcore.gpio, Audio005Def.ADC_RESET_PIN)
        self.i2s_rx_en_pin = Pin(self.ipcore.gpio, Audio005Def.I2S_RX_EN_PIN)
        self.dac_rst_pin = Pin(self.ipcore.gpio, Audio005Def.DAC_RESET_PIN)
        self.i2s_tx_en_pin = Pin(self.ipcore.gpio, Audio005Def.I2S_TX_EN_PIN)
        self.i2s_ch_select = [
            Pin(self.ipcore.gpio, Audio005Def.I2S_CH_SELECT_2),
            Pin(self.ipcore.gpio, Audio005Def.I2S_CH_SELECT_3)
        ]

        super(Audio005Base, self).__init__(self.eeprom,
                                           self.nct75,
                                           range_table=range_table)
        self.is_enable_upload = False
Beispiel #4
0
    def __init__(self, i2c_ext=None, i2c_power=None, ad7175=None, ipcore=None):

        if ad7175 and not ipcore:
            if isinstance(ad7175, basestring):
                axi4 = AXI4LiteBus(ad7175, OdinDef.PLAD7175_REG_SIZE)
                self.ad7175 = MIXAd7175SG(axi4, mvref=OdinDef.MVREF, code_polar=OdinDef.POLAR,
                                          reference=OdinDef.AD7175_REF_MODE, clock=OdinDef.CLOCK)
            else:
                self.ad7175 = ad7175

        elif not ad7175 and ipcore:
            if isinstance(ipcore, basestring):
                axi4_bus = AXI4LiteBus(ipcore, OdinDef.MIX_PSU001_REG_SIZE)
                self.ipcore = MIXPSU001SGR(axi4_bus, 'AD7175', ad717x_mvref=OdinDef.MVREF,
                                           code_polar=OdinDef.POLAR, reference=OdinDef.AD7175_REF_MODE,
                                           clock=OdinDef.CLOCK, use_gpio=False)
            else:
                self.ipcore = ipcore
            self.ad7175 = self.ipcore.ad717x

        if i2c_ext and i2c_power:
            eeprom = CAT24C32(OdinDef.EEPROM_DEV_ADDR, i2c_ext)
            nct75 = NCT75(OdinDef.NCT75_DEV_ADDR, i2c_ext)
            self.tca9538 = TCA9538(OdinDef.TCA9538_ADDR, i2c_ext)
            self.ad5667_batt = AD5667R(OdinDef.DAC_BATT_ADDR, i2c_power,
                                       ref_mode=OdinDef.DAC_REF_MODE, mvref=OdinDef.DAC_VREF)
            self.ad5667_charge = AD5667R(OdinDef.DAC_CHARGE_ADDR, i2c_power,
                                         ref_mode=OdinDef.DAC_REF_MODE, mvref=OdinDef.DAC_VREF)
            self.ch1_output_config = dict()
            self.ch2_output_config = dict()
            self.ch1_input_config = dict()
            self.ch2_input_config = dict()
            super(Odin, self).__init__(eeprom, nct75, range_table=odin_range_table)
        else:
            raise OdinException("Invalid parameter, please check")
Beispiel #5
0
    def __init__(self, i2c=None, spi=None, ad7175=None, gpio=None, ipcore=None):
        super(EL004002A, self).__init__(None, None, None, None, ElektraDef.VLOT_CH1, ElektraDef.VLOT_CH2,
                                        ElektraDef.CURR_CH1, ElektraDef.CURR_CH2,
                                        ElektraDef.EEPROM_DEV_ADDR, ElektraDef.SENSOR_DEV_ADDR)
        if ipcore:
            self.ad7175 = ipcore.ad717x
            self.spi = ipcore.spi
            self.ad5663 = AD5663R(ipcore.spi, ElektraDef.DAC_MV_REF, ElektraDef.DAC_MODE_REF)
            self.gpio = None
        else:
            self.spi = spi or MIXQSPISGEmulator("mix_qspi_sg_emulator", ElektraDef.PLSPIBUS_EMULATOR_REG_SIZE)
            self.ad7175 = ad7175 or MIXAd7175SGEmulator("mix_ad7175_sg_emulator", ElektraDef.AD7175_EMULATOR_REG_SIZE)
            self.ad5663 = AD5663R(spi, ElektraDef.DAC_MV_REF, ElektraDef.DAC_MODE_REF)
            self.gpio = gpio or GPIOEmulator("gpio_emulator")

        if i2c:
            self.cat9555 = CAT9555(ElektraDef.CAT9555_ADDR, i2c)
            self.eeprom = CAT24C32(ElektraDef.EEPROM_DEV_ADDR, i2c)
            self.sensor = NCT75(ElektraDef.SENSOR_DEV_ADDR, i2c)
        else:
            self.cat9555 = CAT9555Emulator(ElektraDef.CAT9555_ADDR, None, None)
            self.eeprom = None
            self.sensor = None

        super(ElektraBase, self).__init__(self.eeprom, self.sensor,
                                          cal_table=elektra_calibration_info, range_table=elektra_range_table)

        self.ad7175.config = {
            "ch0": {"P": "AIN0", "N": "AIN4"},
            "ch1": {"P": "AIN1", "N": "AIN4"},
            "ch2": {"P": "AIN2", "N": "AIN4"},
            "ch3": {"P": "AIN3", "N": "AIN4"}
        }

        self.spi.set_mode('MODE2')
Beispiel #6
0
    def __init__(self, i2c=None, ipcore=None, range_table=magma_range_table):

        self.ipcore = ipcore
        if (ipcore is not None and i2c is not None):
            if isinstance(ipcore, basestring):
                axi4_bus = AXI4LiteBus(ipcore, MagmaDef.WCT001_REG_SIZE)
                self.ipcore = MIXWCT001001SGR(axi4_bus,
                                              use_signalmeter_p=True,
                                              use_signalmeter_n=True,
                                              use_signalsource=True)
            self.signalsource = self.ipcore.signalsource
            self.signalmeter_p = self.ipcore.signalmeter_p
            self.signalmeter_n = self.ipcore.signalmeter_n
            self.cat9555 = CAT9555(MagmaDef.CAT9555_ADDR, i2c)
            self.ads1119 = ADS1119(MagmaDef.ADS1119_ADDR, i2c)
            self.sensor = MAX6642(MagmaDef.MAX6642_ADDR, i2c)
            self.mp8859 = MP8859(MagmaDef.MP8859_ADDR, i2c)
            self.eeprom = CAT24C32(MagmaDef.CAT24C32_ADDR, i2c)
        else:
            raise MagmaException(
                '__init__ error! Please check the parameters!')
        self.signalmeter = {'P': self.signalmeter_p, 'N': self.signalmeter_n}
        super(Magma, self).__init__(eeprom=self.eeprom,
                                    temperature_device=self.sensor,
                                    range_table=range_table)
Beispiel #7
0
 def __init__(self, i2c, signal_source, range_ctrl_pin, ipcore, eeprom_dev_addr, sensor_dev_addr):
     if not i2c and not signal_source and not range_ctrl_pin and not ipcore:
         self.signal_source = MIXSignalSourceSGEmulator('mix_signalsource_sg_emulator')
         self.range_ctrl_pin = GPIOEmulator('gpio_emulator')
     elif i2c and signal_source and range_ctrl_pin and not ipcore:
         if isinstance(signal_source, basestring):
             axi4_bus = AXI4LiteBus(signal_source, IcemanDef.REG_SIZE)
             self.signal_source = MIXSignalSourceSG(axi4_bus)
         else:
             self.signal_source = signal_source
         self.range_ctrl_pin = range_ctrl_pin
     elif i2c and not signal_source and ipcore:
         if isinstance(ipcore, basestring):
             axi4_bus = AXI4LiteBus(ipcore, IcemanDef.MIX_SGT1_REG_SIZE)
             use_gpio = False if range_ctrl_pin else True
             self.ipcore = MIXSGT1SGR(axi4_bus, use_gpio)
         else:
             self.ipcore = ipcore
         self.signal_source = self.ipcore.signal_source
         self.range_ctrl_pin = range_ctrl_pin or Pin(self.ipcore.gpio, IcemanDef.RANGE_CTRL_PIN)
     else:
         raise IcemanException("Please check init parameters.")
     if i2c:
         eeprom = CAT24C32(eeprom_dev_addr, i2c)
         nct75 = NCT75(sensor_dev_addr, i2c)
     else:
         eeprom = None
         nct75 = None
     super(IcemanBase, self).__init__(eeprom, nct75, cal_table=iceman_calibration, range_table=iceman_range_table)
Beispiel #8
0
    def __init__(self,
                 dac_i2c=None,
                 eeprom_i2c=None,
                 ocp_main_pin=None,
                 ocp_batt_pin=None,
                 ocp_dbg_pin=None):

        self.dac1 = AD5667R(ArmorDef.DAC1_DEV_ADDR, dac_i2c,
                            ArmorDef.DAC_VOLTAGE_REF)
        self.dac2 = AD5667R(ArmorDef.DAC2_DEV_ADDR, dac_i2c,
                            ArmorDef.DAC_VOLTAGE_REF)
        self.dac3 = MCP4725(ArmorDef.DAC3_DEV_ADDR, dac_i2c,
                            ArmorDef.DAC3_VOLTAGE_REF)
        self.res1 = AD5272(ArmorDef.RES_1_ADDR, dac_i2c)
        self.res2 = AD5272(ArmorDef.RES_2_ADDR, dac_i2c)
        self.eeprom = CAT24C32(ArmorDef.EEPROM_DEV_ADDR, eeprom_i2c)
        self.sensor = NCT75(ArmorDef.SENSOR_DEV_ADDR, eeprom_i2c)
        self.pca9536 = PCA9536(ArmorDef.IO_EXP_DEV_ADDR, eeprom_i2c)
        self.dac_output_volt = dict()
        self.current_limit = dict()
        self.ocp_status = dict()
        self.eload_current = 0
        self.ocp_main_pin = ocp_main_pin
        self.ocp_batt_pin = ocp_batt_pin
        self.ocp_dbg_pin = ocp_dbg_pin

        super(ArmorBase, self).__init__(self.eeprom,
                                        self.sensor,
                                        range_table=armor_range_table)
Beispiel #9
0
    def __init__(self,
                 i2c=None,
                 spi=None,
                 blade=None,
                 gpio=None,
                 volt_ch1=2,
                 volt_ch2=3,
                 curr_ch1=0,
                 curr_ch2=1,
                 eeprom_dev_addr=None,
                 sensor_dev_addr=None,
                 ipcore=None,
                 cat9555_dev_addr=ElektraDef.CAT9555_ADDR,
                 range_table=elektra_range_table):

        self.eeprom = CAT24C32(eeprom_dev_addr, i2c)
        self.sensor = NCT75(sensor_dev_addr, i2c)
        self.cat9555 = CAT9555(cat9555_dev_addr, i2c)

        if (i2c is not None and spi is not None and gpio is not None):
            self.spi = spi
            self.spi.set_mode('MODE2')
            self.ad5663 = AD5663R(spi, ElektraDef.DAC_MV_REF,
                                  ElektraDef.DAC_MODE_REF)
            # if not using wrapper IP, blade is ad7608 IP driver
            self.ad7608 = blade
            self.gpio = gpio
        elif (ipcore is not None and i2c is not None):
            if isinstance(ipcore, basestring):
                daqt1_axi4_bus = AXI4LiteBus(ipcore,
                                             ElektraDef.MIXDAQT1_REG_SIZE)
                self.ipcore = MIXDAQT1SGR(
                    axi4_bus=daqt1_axi4_bus,
                    ad717x_chip='AD7175',
                    ad717x_mvref=ElektraDef.ADC_VREF_VOLTAGE_5000mV,
                    use_spi=True,
                    use_gpio=False)
                self.spi = self.ipcore.spi
                self.ad7175 = self.ipcore.ad717x
            else:
                self.ipcore = ipcore
                self.spi = self.ipcore.spi
                self.ad7175 = self.ipcore.ad717x

            self.spi.set_mode('MODE2')
            self.ad5663 = AD5663R(self.spi, ElektraDef.DAC_MV_REF,
                                  ElektraDef.DAC_MODE_REF)
            self.gpio = None
            if blade:
                self.blade = blade
                self.ad7608 = blade.adc
        else:
            raise ElektraException(
                '__init__ error! Please check the parameters!')

        super(ElektraBase, self).__init__(self.eeprom,
                                          self.sensor,
                                          range_table=range_table)
        self.adc_voltage_channel = {'ch1': volt_ch1, 'ch2': volt_ch2}
        self.adc_current_channel = {'ch1': curr_ch1, 'ch2': curr_ch2}
Beispiel #10
0
    def __init__(self,
                 i2c,
                 ad7175=None,
                 ipcore=None,
                 eeprom_dev_addr=DaggerDef.EEPROM_DEV_ADDR,
                 sensor_dev_addr=DaggerDef.NCT75_DEV_ADDR):

        if ipcore and ad7175:
            raise DaggerException(
                'ipcore and ad7175 can not be existed at the same time')

        self.ipcore = ipcore
        if ipcore is not None:
            if isinstance(ipcore, basestring):
                axi4_bus = AXI4LiteBus(ipcore, DaggerDef.MIX_DAQT1_REG_SIZE)
                self.ipcore = MIXDAQT1SGR(
                    axi4_bus,
                    'AD7175',
                    ad717x_mvref=DaggerDef.AD7175_MVREF,
                    code_polar=DaggerDef.AD7175_CODE_POLAR,
                    reference=DaggerDef.AD7175_REFERENCE_SOURCE,
                    buffer_flag=DaggerDef.AD7175_BUFFER_FLAG,
                    clock=DaggerDef.AD7175_CLOCK,
                    use_spi=False,
                    use_gpio=False)
            else:
                self.ipcore = ipcore
            self.ad7175 = self.ipcore.ad717x
        elif ad7175:
            if isinstance(ad7175, basestring):
                axi4_bus = AXI4LiteBus(ad7175, DaggerDef.AD7175_REG_SIZE)
                self.ad7175 = MIXAd7175SG(
                    axi4_bus,
                    mvref=DaggerDef.AD7175_MVREF,
                    code_polar=DaggerDef.AD7175_CODE_POLAR,
                    reference=DaggerDef.AD7175_REFERENCE_SOURCE,
                    buffer_flag=DaggerDef.AD7175_BUFFER_FLAG,
                    clock=DaggerDef.AD7175_CLOCK)
            else:
                self.ad7175 = ad7175
        else:
            raise DaggerException("Invalid parameter, please check")

        self.eeprom = CAT24C32(eeprom_dev_addr, i2c)
        self.nct75 = NCT75(sensor_dev_addr, i2c)
        super(DaggerBase, self).__init__(self.eeprom,
                                         self.nct75,
                                         range_table=dagger_range_table)

        self.ad7175.config = {
            "ch0": {
                "P": "AIN0",
                "N": "AIN1"
            },
            "ch1": {
                "P": "AIN2",
                "N": "AIN3"
            }
        }
Beispiel #11
0
    def __init__(self, i2c=None):
        self._cat9555 = CAT9555(SG2238SP02PCADef.CAT9555_DEV_ADDR, i2c)
        self._ad5667 = AD5667(SG2238SP02PCADef.AD5667_DEV_ADDR, i2c,
                              SG2238SP02PCADef.AD5667_VREF_VOLTSGE)
        eeprom = CAT24C32(SG2238SP02PCADef.EEPROM_DEV_ADDR, i2c)
        nct75 = NCT75(SG2238SP02PCADef.NCT75_DEV_ADDR, i2c)

        super(SG2238SP02PCA, self).__init__(eeprom, nct75)
Beispiel #12
0
    def __init__(self,
                 i2c,
                 ipcore=None,
                 ad7175=None,
                 eeprom_dev_addr=MimicDef.EEPROM_DEV_ADDR,
                 sensor_dev_addr=MimicDef.SENSOR_DEV_ADDR,
                 cat9555_dev_addr=MimicDef.CAT9555_DEV_ADDR,
                 range_table=mimic_range_table):

        self.eeprom = CAT24C32(eeprom_dev_addr, i2c)
        self.sensor = NCT75(sensor_dev_addr, i2c)
        self.cat9555 = CAT9555(cat9555_dev_addr, i2c)

        if ipcore:
            if isinstance(ipcore, basestring):
                daqt1_axi4_bus = AXI4LiteBus(ipcore,
                                             MimicDef.MIXDAQT1_REG_SIZE)
                self.ip = MIXDAQT1SGR(
                    axi4_bus=daqt1_axi4_bus,
                    ad717x_chip='AD7175',
                    ad717x_mvref=MimicDef.ADC_VREF_VOLTAGE_5000mV,
                    use_spi=True,
                    use_gpio=False)
                self.ad7175 = self.ip.ad717x
            else:
                self.ip = ipcore
                self.ad7175 = self.ip.ad717x
        elif ad7175:
            if isinstance(ad7175, basestring):
                axi4_bus = AXI4LiteBus(ad7175, MimicDef.AD7175_REG_SIZE)
                self.ad7175 = MIXAd7175SG(
                    axi4_bus, mvref=MimicDef.ADC_VREF_VOLTAGE_5000mV)
            else:
                self.ad7175 = ad7175
        else:
            raise MimicException("Invalid parameter, please check")

        self.ad7175.config = {
            'ch0': {
                'P': 'AIN0',
                'N': 'AIN1'
            },
            'ch1': {
                'P': 'AIN2',
                'N': 'AIN3'
            }
        }
        self.measure_path = dict()

        super(MimicBase, self).__init__(self.eeprom,
                                        self.sensor,
                                        range_table=range_table)

        self.function_info = mimic_function_info
        self.module_calibration_info = range_table
Beispiel #13
0
 def __init__(self,
              pd_i2c_1=None,
              pd_i2c_2=None,
              source_capabilities=[],
              emarker=False):
     self.pd_i2c_1 = pd_i2c_1
     self.pd_i2c_2 = pd_i2c_2
     self.source_capabilities = source_capabilities
     self.emarker = emarker
     self.tps6598x = TPS6598x(VDM002001Def.TPS6598X_DEV_ADDR, self.pd_i2c_2)
     self.eeprom = CAT24C32(VDM002001Def.EEPROM_DEV_ADDR, self.pd_i2c_2)
     super(VDM002001, self).__init__(self.eeprom)
Beispiel #14
0
    def __init__(self,
                 i2c,
                 ipcore,
                 eeprom_dev_addr=KarmaDef.EEPROM_DEV_ADDR,
                 sensor_dev_addr=KarmaDef.SENSOR_DEV_ADDR,
                 range_table=karma_range_table):

        if (i2c and ipcore):
            if isinstance(ipcore, basestring):
                axi4_bus = AXI4LiteBus(ipcore, KarmaDef.REG_SIZE)
                self.ipcore = MIXBT001SGR(axi4_bus=axi4_bus,
                                          ad717x_chip='AD7175',
                                          ad717x_mvref=KarmaDef.ADC_VREF,
                                          use_spi=True,
                                          use_gpio=True)
            else:
                self.ipcore = ipcore

            self.ad7175 = self.ipcore.ad717x
            self.ad7175.config = {
                'ch0': {
                    'P': 'AIN0',
                    'N': 'AIN1'
                },
                'ch1': {
                    'P': 'AIN2',
                    'N': 'AIN3'
                }
            }
            self.vx_ix_select_pin = Pin(self.ipcore.gpio,
                                        KarmaDef.VX_IX_SELECT_PIN)
            self.cur_set1_pin = Pin(self.ipcore.gpio, KarmaDef.CUR_SET1_PIN)
            self.cur_set2_pin = Pin(self.ipcore.gpio, KarmaDef.CUR_SET2_PIN)
            self.discharge_pin = Pin(self.ipcore.gpio, KarmaDef.DISCHARGE_PIN)
            self.lpf_select_pin = Pin(self.ipcore.gpio,
                                      KarmaDef.LPF_SELECT_PIN)
            self.reset_l_pin = Pin(self.ipcore.gpio, KarmaDef.RESET_L_PIN)
            self.trigger_l_pin = Pin(self.ipcore.gpio, KarmaDef.TRIGGER_L_PIN)
            self.ad9106 = AD9106(self.ipcore.spi, KarmaDef.AD9106_MCLK,
                                 KarmaDef.AD9106_DEFAULT_VREF)
            self.eeprom = CAT24C32(eeprom_dev_addr, i2c)
            self.sensor = NCT75(sensor_dev_addr, i2c)
            self.line_path = ""
            self.sine_data_length = 0
            self.cosine_data_length = 0
            self.cycle_count = 2
            super(KarmaBase, self).__init__(self.eeprom,
                                            self.sensor,
                                            range_table=range_table)

        else:
            raise KarmaException('Parameter error')
Beispiel #15
0
    def __init__(self, i2c, ad7175=None, range_ctrl_pin=None,
                 meter_ctrl_pin=None, ipcore=None):

        if ad7175 and range_ctrl_pin and meter_ctrl_pin and not ipcore:
            if isinstance(ad7175, basestring):
                axi4 = AXI4LiteBus(ad7175, WolverineDef.PLAD7175_REG_SIZE)
                self.ad7175 = MIXAd7175SG(axi4, mvref=WolverineDef.MVREF, code_polar=WolverineDef.POLAR,
                                          clock=WolverineDef.CLOCK)
            else:
                self.ad7175 = ad7175
            self.range_ctrl_pin = range_ctrl_pin
            self.meter_ctrl_pin = meter_ctrl_pin
        elif not ad7175 and not range_ctrl_pin and not meter_ctrl_pin and ipcore:
            if isinstance(ipcore, basestring):
                axi4_bus = AXI4LiteBus(ipcore, WolverineDef.MIX_DAQT1_REG_SIZE)
                self.ipcore = MIXDAQT1SGR(axi4_bus, 'AD7175', ad717x_mvref=WolverineDef.MVREF,
                                          code_polar=WolverineDef.POLAR, clock=WolverineDef.CLOCK, use_gpio=True)
            else:
                self.ipcore = ipcore
            self.ad7175 = self.ipcore.ad717x
            gpio = self.ipcore.gpio
            self.range_ctrl_pin = Pin(gpio, WolverineDef.RANGE_SEL_BIT)
            self.meter_ctrl_pin = Pin(gpio, WolverineDef.METER_SEL_BIT)
            self.tag_pins = [
                Pin(gpio, WolverineDef.TAG_BASE_PIN + x,
                    WolverineDef.GPIO_OUTPUT_DIR) for x in range(4)
            ]
        elif not ad7175 and range_ctrl_pin and meter_ctrl_pin and ipcore:
            if isinstance(ipcore, basestring):
                axi4_bus = AXI4LiteBus(ipcore, WolverineDef.MIX_DAQT1_REG_SIZE)
                self.ipcore = MIXDAQT1SGR(axi4_bus, 'AD7175', ad717x_mvref=WolverineDef.MVREF,
                                          code_polar=WolverineDef.POLAR, clock=WolverineDef.CLOCK, use_gpio=True)
            else:
                self.ipcore = ipcore
            self.ad7175 = self.ipcore.ad717x
            self.range_ctrl_pin = range_ctrl_pin
            self.meter_ctrl_pin = meter_ctrl_pin
            gpio = self.ipcore.gpio
            self.tag_pins = [
                Pin(gpio, WolverineDef.TAG_BASE_PIN + x,
                    WolverineDef.GPIO_OUTPUT_DIR) for x in range(4)
            ]
        else:
            raise WolverineException("Invalid parameter, please check")

        eeprom = CAT24C32(WolverineDef.EEPROM_DEV_ADDR, i2c)
        nct75 = NCT75(WolverineDef.NCT75_DEV_ADDR, i2c)
        super(Wolverine, self).__init__(eeprom, nct75, range_table=wolverine_range_table)

        self.channel_path = {'range_sel_bit': self.range_ctrl_pin, 'meter_sel_bit': self.meter_ctrl_pin}
        self.measure_path = dict()
        self.measure_path['range'] = WolverineDef.VOLT_5V
Beispiel #16
0
    def __init__(self, i2c):

        if i2c:
            self.nct75 = NCT75(Psu003001Def.SENSOR_DEV_ADDR, i2c)
            self.dac = AD5675(Psu003001Def.DAC_DEV_ADDR, i2c, mvref=Psu003001Def.DAC_REF_VOLT_mV)
            self.eeprom = CAT24C32(Psu003001Def.EEPROM_DEV_ADDR, i2c)
            self.io_exp = TCA9538(Psu003001Def.IO_EXP_DEV_ADDR, i2c)
            super(PSU003001, self).__init__(self.eeprom, self.nct75,
                                            range_table=psu003001_range_table)
            self.line_path = dict()

        else:
            raise Psu003001Exception("Parameter error")
Beispiel #17
0
    def __init__(self, i2c=None, ipcore=None, ad7175=None):
        if i2c:
            self.eeprom = CAT24C32(DMM003004Def.EEPROM_DEV_ADDR, i2c)
            self.sensor = NCT75(DMM003004Def.SENSOR_DEV_ADDR, i2c)
            self.cat9555 = CAT9555(DMM003004Def.CAT9555_DEV_ADDR, i2c)
        else:
            self.eeprom = EepromEmulator('eeprom_emulator')
            self.sensor = NCT75Emulator('nct75_emulator')
            self.cat9555 = CAT9555Emulator(DMM003004Def.CAT9555_DEV_ADDR, None,
                                           None)

        if ipcore:
            if isinstance(ipcore, basestring):
                daqt1_axi4_bus = AXI4LiteBus(ipcore,
                                             DMM003004Def.MIXDAQT1_REG_SIZE)
                self.ip = MIXDAQT1SGR(
                    axi4_bus=daqt1_axi4_bus,
                    ad717x_chip='AD7175',
                    ad717x_mvref=DMM003004Def.ADC_VREF_VOLTAGE_5000mV,
                    use_spi=True,
                    use_gpio=False)
                self.ad7175 = self.ip.ad717x
            else:
                self.ip = ipcore
                self.ad7175 = self.ip.ad717x
        elif ad7175:
            self.ad7175 = ad7175
        else:
            self.ad7175 = MIXAd7175SGEmulator('mix_ad7175_sg_emulator',
                                              DMM003004Def.EMULATOR_REG_SIZE)

        self.ad7175.config = {
            'ch0': {
                'P': 'AIN0',
                'N': 'AIN1'
            },
            'ch1': {
                'P': 'AIN2',
                'N': 'AIN3'
            }
        }
        self.mode = 'cal'
        self.measure_path = dict()

        super(Mimic, self).__init__(self.eeprom,
                                    self.sensor,
                                    cal_table=dmm003004_calibration_info,
                                    range_table=dmm003004_range_table)

        self.function_info = dmm003004_function_info
        self.module_calibration_info = dmm003004_calibration_info
Beispiel #18
0
    def __init__(self, i2c):

        if i2c:
            self.eeprom = CAT24C32(SG2251PW01PCADef.EEPROM_DEV_ADDR, i2c)
            self.sensor = NCT75(SG2251PW01PCADef.NCT75_DEV_ADDR, i2c)
            self.dac = AD5667R(SG2251PW01PCADef.DAC_ADDR, i2c, "EXTERN", SG2251PW01PCADef.DAC_REF_VOLT)
            self.io_expand = TCA9538(SG2251PW01PCADef.IO_EXP_ADDR, i2c)
        else:
            self.eeprom = EepromEmulator("cat24cxx_emulator")
            self.sensor = NCT75Emulator("nct75_emulator")
            self.dac = AD56X7REmulator(SG2251PW01PCADef.DAC_ADDR)
            self.io_expand = TCA9538Emulator(SG2251PW01PCADef.IO_EXP_ADDR)

        super(SG2251PW01PCA, self).__init__(self.eeprom, self.sensor,
                                            cal_table=sg2251_calibration_info,
                                            range_table=sg2251_range_table)
Beispiel #19
0
    def __init__(self, i2c, ipcore=None):

        if i2c:
            self.eeprom = CAT24C32(WolverineiiDef.EEPROM_DEV_ADDR, i2c)
            self.sensor = NCT75(WolverineiiDef.SENSOR_DEV_ADDR, i2c)
            self.pca9536 = PCA9536(WolverineiiDef.IO_EXP_DEV_ADDR, i2c)
        else:
            self.eeprom = EepromEmulator('eeprom_emulator')
            self.sensor = NCT75Emulator('nct75_emulator')
            self.pca9536 = PCA9536Emulator('pca9536_emulator')
        if ipcore:
            if isinstance(ipcore, basestring):
                axi4_bus = AXI4LiteBus(ipcore,
                                       WolverineiiDef.MIXDAQT1_REG_SIZE)
                ipcore = MIXDAQT1SGR(
                    axi4_bus,
                    'AD7175',
                    ad717x_mvref=WolverineiiDef.AD7175_MVREF,
                    code_polar=WolverineiiDef.AD7175_CODE_POLAR,
                    reference=WolverineiiDef.AD7175_REFERENCE,
                    clock=WolverineiiDef.AD7175_CLOCK)
                self.ipcore = ipcore
            else:
                self.ipcore = ipcore
            self.ad7175 = self.ipcore.ad717x
            self.ad7175.config = {
                'ch0': {
                    'P': 'AIN0',
                    'N': 'AIN1'
                },
                'ch1': {
                    'P': 'AIN2',
                    'N': 'AIN3'
                }
            }
        else:
            self.ad7175 = MIXAd7175SGEmulator('mix_ad7175_sg_emulator',
                                              WolverineiiDef.EMULATOR_REG_SIZE)

        self.mode = 'cal'
        self.measure_path = dict()

        super(WolverineII,
              self).__init__(self.eeprom,
                             self.sensor,
                             cal_table=wolverineii_calibration_info,
                             range_table=wolverineii_range_table)
Beispiel #20
0
    def __init__(self,
                 ps8409_i2c,
                 eeprom_i2c,
                 hpd_io,
                 signal_source_io,
                 signal_ctrol_io,
                 ipcore=None,
                 init_file='hdmi2_0.bin'):
        self.ps8409_i2c = ps8409_i2c
        self.eeprom_i2c = eeprom_i2c
        self.hpd_io = hpd_io
        self.signal_source_io = signal_source_io
        self.signal_ctrol_io = signal_ctrol_io
        self.hpd_io.set_dir('output')
        self.signal_source_io.set_dir('output')
        self.signal_ctrol_io.set_dir('output')
        self.eeprom = CAT24C32(SG2700SU09PCADef.EEPROM_ADDR, self.eeprom_i2c)
        self.nct75 = NCT75(SG2700SU09PCADef.NTC_ADDR, self.eeprom_i2c)

        if isinstance(ipcore, basestring):
            axi4_bus = AXI4LiteBus(ipcore, SG2700SU09PCADef.REG_SIZE)
            self.ipcore = MIXHDMISinkEmulateSG(axi4_bus)
        else:
            self.ipcore = ipcore

        if ipcore is not None:
            # init edid and scdc eeprom
            self.config_eeprom_emulate("EDID_eeprom",
                                       SG2700SU09PCADef.EDID_EEPROM_SPEED,
                                       SG2700SU09PCADef.EDID_EEPROM_ADDR,
                                       SG2700SU09PCADef.EDID_EEPROM_REG_LEN,
                                       SG2700SU09PCADef.EDID_EEPROM_DATA_WIDTH)
            self.config_eeprom_emulate("SCDC_eeprom",
                                       SG2700SU09PCADef.SCDC_EEPROM_SPEED,
                                       SG2700SU09PCADef.SCDC_EEPROM_ADDR,
                                       SG2700SU09PCADef.SCDC_EEPROM_REG_LEN,
                                       SG2700SU09PCADef.SCDC_EEPROM_DATA_WIDTH)
            self.config_SCDC_eeprom()

            # init hdmi info to hdmi2.0
            self.init_eeprom_emulate("EDID_eeprom",
                                     SG2700SU09PCADef.FILE_PATH + init_file)
            self.hpd_level(1)
            self.signal_source_switch('ICI')
            self.signal_ctrol('enable')

        super(SG2700SU09PCA, self).__init__(self.eeprom, self.nct75)
Beispiel #21
0
    def __init__(self, i2c, ipcore=None, analyzer=None, adc_rst_pin=None, adc_ovfl_l_pin=None, i2s_rx_en_pin=None,
                 i2s_ch_select_pin=None, tone_detect_pin=None, upload_ch_select_pin=None, sample_rate=48000):

        assert sample_rate > 0 and sample_rate <= WarlockDef.MAX_SAMPLING_RATE

        if (i2c and analyzer and adc_rst_pin and adc_ovfl_l_pin and i2s_rx_en_pin and
                i2s_ch_select_pin and tone_detect_pin and upload_ch_select_pin):
            self.i2c = i2c

            if isinstance(analyzer, basestring):
                self.analyzer = MIXFftAnalyzerSG(analyzer)
            else:
                self.analyzer = analyzer

            self.adc_rst_pin = adc_rst_pin
            self.adc_ovfl_l_pin = adc_ovfl_l_pin
            self.i2s_rx_en_pin = i2s_rx_en_pin
            self.i2s_ch_select_pin = i2s_ch_select_pin
            self.tone_detect_pin = tone_detect_pin
            self.upload_ch_select_pin = upload_ch_select_pin
        elif (ipcore and i2c):
            self.i2c = i2c
            if isinstance(ipcore, basestring):
                axi4_bus = AXI4LiteBus(ipcore, WarlockDef.MIX_MIK002_REG_SIZE)
                self.ipcore = MIXMIK002SGR(axi4_bus)
            else:
                self.ipcore = ipcore
            self.analyzer = self.ipcore.analyzer
            self.adc_rst_pin = Pin(self.ipcore.gpio, WarlockDef.ADC_RST_PIN)
            self.adc_ovfl_l_pin = Pin(self.ipcore.gpio, WarlockDef.ADC_OVFL_L_PIN)
            self.i2s_rx_en_pin = Pin(self.ipcore.gpio, WarlockDef.I2S_RX_EN_PIN)
            self.i2s_ch_select_pin = Pin(self.ipcore.gpio, WarlockDef.I2S_CH_SELECT_PIN)
            self.tone_detect_pin = Pin(self.ipcore.gpio, WarlockDef.TONE_DETECT_PIN)
            self.upload_ch_select_pin = Pin(self.ipcore.gpio, WarlockDef.UPLOAD_CH_SELECT_PIN)
        else:
            raise WarlockException("Parameter error")

        self.eeprom = CAT24C32(WarlockDef.EEPROM_DEV_ADDR, i2c)
        self.nct75 = NCT75(WarlockDef.SENSOR_DEV_ADDR, i2c)
        self.cat9555 = CAT9555(WarlockDef.CAT9555_DEV_ADDR, i2c)

        super(Warlock, self).__init__(self.eeprom, self.nct75,
                                      cal_table={}, range_table=warlock_range_table)

        self.sampling_rate = sample_rate
        self.scope = ""
        self.mode = ""
Beispiel #22
0
    def __init__(self, i2c, ad7175=None, ipcore=None):

        self.eeprom = CAT24C32(Scope002006Def.EEPROM_DEV_ADDR, i2c)
        self.sensor = NCT75(Scope002006Def.SENSOR_DEV_ADDR, i2c)

        if ipcore:
            if isinstance(ipcore, basestring):
                axi4_bus = AXI4LiteBus(ipcore,
                                       Scope002006Def.MIX_DAQT1_REG_SIZE)
                ipcore = MIXDAQT1SGR(
                    axi4_bus,
                    'AD7175',
                    ad717x_mvref=Scope002006Def.AD7175_MVREF,
                    code_polar=Scope002006Def.AD7175_CODE_POLAR,
                    reference=Scope002006Def.AD7175_REFERENCE_SOURCE,
                    buffer_flag=Scope002006Def.AD7175_BUFFER_FLAG,
                    clock=Scope002006Def.AD7175_CLOCK,
                    use_spi=False,
                    use_gpio=True)
            ipcore.ad717x.config = {"ch0": {"P": "AIN0", "N": "AIN1"}}
            self.ad7175 = ipcore.ad717x
            self.gpio = ipcore.gpio
            self.tag_pins = [
                Pin(self.gpio, Scope002006Def.TAG_BASE_PIN + x,
                    Scope002006Def.GPIO_OUTPUT_DIR) for x in xrange(4)
            ]
        elif ad7175:
            if isinstance(ad7175, basestring):
                axi4_bus = AXI4LiteBus(ad7175, Scope002006Def.AD7175_REG_SIZE)
                ad7175 = MIXAd7175SG(
                    axi4_bus,
                    mvref=Scope002006Def.AD7175_MVREF,
                    code_polar=Scope002006Def.AD7175_CODE_POLAR,
                    reference=Scope002006Def.AD7175_REFERENCE_SOURCE,
                    buffer_flag=Scope002006Def.AD7175_BUFFER_FLAG,
                    clock=Scope002006Def.AD7175_CLOCK)

            ad7175.config = {"ch0": {"P": "AIN0", "N": "AIN1"}}
            self.ad7175 = ad7175
        else:
            raise Scope002006Exception('Use one of aggregated IP or AD717X')

        super(Scope002006, self).__init__(self.eeprom,
                                          self.sensor,
                                          range_table=scope002006_range_table)
Beispiel #23
0
    def __init__(self, ad7175=None, i2c=None, ipcore=None):
        if ipcore and ad7175:
            raise Dmm010Exception('Not allowed to use both aggregated IP and AD717X')

        if i2c:
            self.tca9538 = TCA9538(DMM010Def.TAC9538_I2C_ADDR, i2c)
            self.eeprom = CAT24C32(DMM010Def.CAT24C32_I2C_ADDR, i2c)
            self.sensor = NCT75(DMM010Def.NCT75_I2C_ADDR, i2c)
        else:
            self.tca9538 = TCA9538Emulator(DMM010Def.TAC9538_I2C_ADDR)
            self.eeprom = EepromEmulator("eeprom_emulator")
            self.sensor = NCT75Emulator("nct75_emulator")

        if ipcore:
            if isinstance(ipcore, basestring):
                axi4_bus = AXI4LiteBus(ipcore, DMM010Def.MIX_DAQT1_REG_SIZE)
                ipcore = MIXDAQT1SGR(axi4_bus, "AD7175", ad717x_mvref=DMM010Def.ADC_VREF_VOLTAGE_5000mV,
                                     code_polar=DMM010Def.AD7175_CODE_POLAR,
                                     reference=DMM010Def.AD7175_REFERENCE_SOURCE,
                                     buffer_flag=DMM010Def.AD7175_BUFFER_FLAG,
                                     clock=DMM010Def.AD7175_CLOCK,
                                     use_spi=False, use_gpio=False)
            self.ad7175 = ipcore.ad717x
        elif ad7175:
            if isinstance(ad7175, basestring):
                axi4_bus = AXI4LiteBus(ad7175, DMM010Def.PLAD7175_REG_SIZE)
                ad7175 = MIXAd7175SG(axi4_bus, mvref=DMM010Def.ADC_VREF_VOLTAGE_5000mV,
                                     code_polar=DMM010Def.AD7175_CODE_POLAR,
                                     reference=DMM010Def.AD7175_REFERENCE_SOURCE,
                                     buffer_flag=DMM010Def.AD7175_BUFFER_FLAG,
                                     clock=DMM010Def.AD7175_CLOCK)
            self.ad7175 = ad7175
        else:
            self.ad7175 = MIXAd7175SGEmulator('ad7175_emulator', DMM010Def.ADC_VREF_VOLTAGE_5000mV)

        self.ad7175.config = {
            "ch0": {"P": "AIN0", "N": "AIN1"},
            "ch1": {"P": "AIN2", "N": "AIN3"}
        }

        super(DMM010001, self).__init__(self.eeprom, self.sensor, cal_table=dmm010_calibration_info,
                                        range_table=dmm010_range_table)
        self.continuous_sample_channel = None
        self.measure_path = None
Beispiel #24
0
    def __init__(self, i2c_ext, i2c_power, ipcore):

        if i2c_ext and i2c_power and ipcore:
            eeprom = CAT24C32(PSU001014Def.EEPROM_DEV_ADDR, i2c_ext)
            nct75 = NCT75(PSU001014Def.NCT75_DEV_ADDR, i2c_ext)
            self.tca9538 = TCA9538(PSU001014Def.TCA9538_ADDR, i2c_ext)
            self.ad5667_batt = AD5667R(PSU001014Def.DAC_BATT_ADDR,
                                       i2c_power,
                                       ref_mode=PSU001014Def.DAC_REF_MODE,
                                       mvref=PSU001014Def.DAC_VREF)
            self.ad5667_charge = AD5667R(PSU001014Def.DAC_CHARGE_ADDR,
                                         i2c_power,
                                         ref_mode=PSU001014Def.DAC_REF_MODE,
                                         mvref=PSU001014Def.DAC_VREF)
            self.mcp4725 = MCP4725(PSU001014Def.DAC_MCP4725_ADDR,
                                   i2c_power,
                                   mvref=PSU001014Def.MCP4725_VREF)

            if isinstance(ipcore, basestring):
                axi4_bus = AXI4LiteBus(ipcore,
                                       PSU001014Def.MIX_PSU001_REG_SIZE)
                self.ipcore = MIXPSU001SGR(
                    axi4_bus,
                    'AD7175',
                    ad717x_mvref=PSU001014Def.MVREF,
                    code_polar=PSU001014Def.POLAR,
                    reference=PSU001014Def.AD7175_REF_MODE,
                    clock=PSU001014Def.CLOCK,
                    use_gpio=False)
            else:
                self.ipcore = ipcore
            self.ad7175 = self.ipcore.ad717x
            super(PSU001014, self).__init__(eeprom,
                                            nct75,
                                            range_table=psu001_range_table)
        else:
            raise PSU001014Exception("Invalid parameter, please check")
        self.ch1_output_config = dict()
        self.ch2_output_config = dict()
        self.ch1_input_config = dict()
        self.ch2_input_config = dict()
        self.volt_diff = 3000.0
        self.charge_current_vdac = 0
        self.battery_current_vdac = 0
Beispiel #25
0
    def __init__(self,
                 i2c_io_exp=None,
                 i2c=None,
                 eeprom_dev_addr=PSU001003Def.EEPROM_DEV_ADDR,
                 sensor_dev_addr=PSU001003Def.SENSOR_DEV_ADDR):

        if i2c_io_exp and i2c:
            self.cat9555 = CAT9555(PSU001003Def.CAT9555_ADDR, i2c_io_exp)
            self.eeprom = CAT24C32(eeprom_dev_addr, i2c)
            self.sensor = NCT75(sensor_dev_addr, i2c)
        elif i2c_io_exp is None and i2c_io_exp is None:
            self.cat9555 = CAT9555Emulator(0x20, None, None)
            self.eeprom = EepromEmulator('eeprom_emulator')
            self.sensor = NCT75Emulator('nct75_emulator')
        else:
            raise PSU001003Exception(
                'Not Allowed: either of i2c_io_exp,i2c is None')

        super(PSU001003Base, self).__init__(self.eeprom, self.sensor)
Beispiel #26
0
    def __init__(self, i2c, ipcore, range_table=starlord_table):

        self.eeprom = CAT24C32(StarLordDef.EEPROM_I2C_ADDR, i2c)
        self.nct75 = NCT75(StarLordDef.TEMP_I2C_ADDR, i2c)
        self.pca9536 = PCA9536(StarLordDef.PCA9536_DEV_ADDR, i2c)

        if isinstance(ipcore, basestring):
            ipcore = MIXAUT5SGR(ipcore)

        self.ipcore = ipcore
        self.analyzer = self.ipcore.analyzer
        self.signal_source = self.ipcore.signal_source
        self.ad7175 = self.ipcore.ad717x
        self.ad7175.config = {
            'ch0': {
                'P': 'AIN0',
                'N': 'AIN1'
            },
            'ch1': {
                'P': 'AIN2',
                'N': 'AIN3'
            }
        }
        self.adc_rst_pin = Pin(self.ipcore.gpio, StarLordDef.ADC_RESET_PIN)
        self.i2s_rx_en_pin = Pin(self.ipcore.gpio, StarLordDef.I2S_RX_EN_PIN)
        self.dac_rst_pin = Pin(self.ipcore.gpio, StarLordDef.DAC_RESET_PIN)
        self.i2s_tx_en_pin = Pin(self.ipcore.gpio, StarLordDef.I2S_TX_EN_PIN)
        self.i2s_ch_select = [
            Pin(self.ipcore.gpio, StarLordDef.I2S_CH_SELECT_2),
            Pin(self.ipcore.gpio, StarLordDef.I2S_CH_SELECT_3)
        ]
        self.fft_source_select = Pin(self.ipcore.gpio,
                                     StarLordDef.FFT_SOURCE_SELECT)
        self.ad7175_upload_select = Pin(self.ipcore.gpio,
                                        StarLordDef.AD7175_TO_FFT_OR_NOT)

        super(StarLordBase, self).__init__(self.eeprom,
                                           self.nct75,
                                           range_table=range_table)
        self.is_lna_up = False
        self.is_analyzer_up = False
        self.is_enable_upload = False
Beispiel #27
0
    def __init__(self, i2c, ipcore):

        self.eeprom = CAT24C32(WolverineiiDef.EEPROM_DEV_ADDR, i2c)
        self.sensor = NCT75(WolverineiiDef.SENSOR_DEV_ADDR, i2c)
        self.pca9536 = PCA9536(WolverineiiDef.IO_EXP_DEV_ADDR, i2c)

        if isinstance(ipcore, basestring):
            axi4_bus = AXI4LiteBus(ipcore, WolverineiiDef.MIXDAQT1_REG_SIZE)
            ipcore = MIXDAQT1SGR(axi4_bus,
                                 'AD7175',
                                 ad717x_mvref=WolverineiiDef.AD7175_MVREF,
                                 code_polar=WolverineiiDef.AD7175_CODE_POLAR,
                                 reference=WolverineiiDef.AD7175_REFERENCE,
                                 clock=WolverineiiDef.AD7175_CLOCK,
                                 use_gpio=True)

        self.ipcore = ipcore
        self.ad7175 = self.ipcore.ad717x
        self.ad7175.config = {
            'ch0': {
                'P': 'AIN0',
                'N': 'AIN1'
            },
            'ch1': {
                'P': 'AIN2',
                'N': 'AIN3'
            }
        }

        self.measure_path = dict()

        self.continuous_sample_mode = None

        self.gpio = ipcore.gpio
        self.tag_pins = [
            Pin(self.gpio, WolverineiiDef.TAG_BASE_PIN + x,
                WolverineiiDef.GPIO_OUTPUT_DIR) for x in range(4)
        ]

        super(WolverineII, self).__init__(self.eeprom,
                                          self.sensor,
                                          range_table=wolverineii_range_table)
Beispiel #28
0
    def __init__(self, i2c, ipcore, range_table=moonstar_range_table, function_info=moonstar_function_info):

        self.tca9538 = TCA9538(MoonstarDef.CAT9538_DEV_ADDR, i2c)
        self.eeprom = CAT24C32(MoonstarDef.EEPROM_DEV_ADDR, i2c)
        self.sensor = NCT75(MoonstarDef.SENSOR_DEV_ADDR, i2c)

        if isinstance(ipcore, basestring):
            daqt1_axi4_bus = AXI4LiteBus(ipcore, MoonstarDef.MIXDAQT1_REG_SIZE)
            ipcore = MIXDMM007SGR(axi4_bus=daqt1_axi4_bus, ad717x_chip='AD7175',
                                  ad717x_mvref=MoonstarDef.ADC_VREF_VOLTAGE_5000mV,
                                  use_spi=False, use_gpio=False)

        self.ipcore = ipcore
        self.ad7175 = self.ipcore.ad717x

        self.ad7175.config = {
            'ch0': {'P': 'AIN0', 'N': 'AIN1'}
        }
        super(MoonstarBase, self).__init__(self.eeprom, self.sensor, range_table=range_table)
        self.config = {}
        self.function_info = function_info
        self.protect = False
Beispiel #29
0
    def __init__(self,
                 i2c,
                 adc_rst_pin=None,
                 i2s_rx_en_pin=None,
                 dac_rst_pin=None,
                 i2s_tx_en_pin=None,
                 sample_rate=192000,
                 ipcore=None):
        assert sample_rate > 0 and sample_rate <= DazzlerDef.MAX_SAMPLING_RATE

        self.eeprom = CAT24C32(DazzlerDef.EEPROM_I2C_ADDR, i2c)
        self.nct75 = NCT75(DazzlerDef.SENSOR_I2C_ADDR, i2c)

        super(DazzlerBase, self).__init__(self.eeprom,
                                          self.nct75,
                                          range_table=dazzler_range_table)

        if ipcore:
            if isinstance(ipcore, basestring):
                axi4 = AXI4LiteBus(ipcore, DazzlerDef.MIX_AUT1_REG_SIZE)
                self.ip = MIXAUT1SGR(axi4)
            else:
                self.ip = ipcore
            self.analyzer = self.ip.analyzer
            self.signal_source = self.ip.signal_source
            self.adc_rst_pin = adc_rst_pin or Pin(self.ip.gpio,
                                                  DazzlerDef.ADC_RESET_PIN)
            self.i2s_rx_en_pin = i2s_rx_en_pin or Pin(self.ip.gpio,
                                                      DazzlerDef.I2S_RX_EN_PIN)
            self.dac_rst_pin = dac_rst_pin or Pin(self.ip.gpio,
                                                  DazzlerDef.DAC_RESET_PIN)
            self.i2s_tx_en_pin = i2s_tx_en_pin or Pin(self.ip.gpio,
                                                      DazzlerDef.I2S_TX_EN_PIN)
        else:
            raise DazzlerException("parameter 'ipcore' can not be None")

        self.sample_rate = sample_rate
Beispiel #30
0
    def __init__(self, dac_i2c=None, eeprom_i2c=None):

        if dac_i2c:
            self.dac1 = AD5667R(ArmorDef.DAC1_DEV_ADDR, dac_i2c,
                                ArmorDef.DAC_VOLTAGE_REF)
            self.dac2 = AD5667R(ArmorDef.DAC2_DEV_ADDR, dac_i2c,
                                ArmorDef.DAC_VOLTAGE_REF)
            self.dac3 = MCP4725(ArmorDef.DAC3_DEV_ADDR, dac_i2c,
                                ArmorDef.DAC3_VOLTAGE_REF)
            self.res1 = AD5272(ArmorDef.RES_1_ADDR, dac_i2c)
            self.res2 = AD5272(ArmorDef.RES_2_ADDR, dac_i2c)
        else:
            self.dac1 = AD5667REmulator("ad5667r_emulator_1")
            self.dac2 = AD5667REmulator("ad5667r_emulator_2")
            self.dac3 = MCP4725Emulator('mcp4725_emulator')
            self.res1 = AD5272Emulator("ad5272_emulator_1")
            self.res2 = AD5272Emulator("ad5272_emulator_2")

        if eeprom_i2c:
            self.eeprom = CAT24C32(ArmorDef.EEPROM_DEV_ADDR, eeprom_i2c)
            self.sensor = NCT75(ArmorDef.SENSOR_DEV_ADDR, eeprom_i2c)
            MIXBoard.__init__(self,
                              self.eeprom,
                              self.sensor,
                              cal_table=armor_calibration_info,
                              range_table=armor_range_table)
            self.pca9536 = PCA9536(ArmorDef.IO_EXP_DEV_ADDR, eeprom_i2c)
        else:
            self.eeprom = EepromEmulator('eeprom_emulator')
            self.sensor = NCT75Emulator('nct75_emulator')
            MIXBoard.__init__(self,
                              None,
                              None,
                              cal_table=armor_calibration_info,
                              range_table=armor_range_table)
            self.pca9536 = PCA9536Emulator('pca9536_emulator')