Example #1
0
    def __write_config(self, config):
        try:
            I2C.start_tx(self.__addr)
            I2C.write(ADS1115.__REG_CONFIG, config >> 8, config & 0xff)

        finally:
            I2C.end_tx()
    def convert(cls):
        try:
            I2C.start_tx(MPL115A2Reg.__I2C_ADDR)
            I2C.write(cls.__CMD_START_CONV, 0x00)

        finally:
            I2C.end_tx()
Example #3
0
    def write(self, byte):
        try:
            I2C.start_tx(self.__addr)
            I2C.write(byte)

        finally:
            I2C.end_tx()
Example #4
0
    def __write(self, config):
        try:
            I2C.start_tx(self.addr)
            I2C.write(config)

        finally:
            I2C.end_tx()
Example #5
0
    def __read_reg(cls, addr):
        try:
            I2C.start_tx(cls.__ADDR)
            value = I2C.read_cmd(addr, 1)
        finally:
            I2C.end_tx()

        return value
Example #6
0
    def __write_image(cls, memory_addr, values):  # max 32 values
        try:
            I2C.start_tx(Host.DFE_EEPROM_ADDR)

            I2C.write_addr(memory_addr, *values)
            time.sleep(cls.__TWR)
        finally:
            I2C.end_tx()
Example #7
0
    def read(self):
        try:
            I2C.start_tx(self.__addr)
            byte = I2C.read(1)

        finally:
            I2C.end_tx()

        return byte
    def __read_raw(self):
        try:
            I2C.start_tx(self.__I2C_ADDR)
            values = I2C.read_cmd(self.__reg_addr, 2)

            return values[0] << 8 | values[1]

        finally:
            I2C.end_tx()
Example #9
0
    def status(self):
        try:
            I2C.start_tx(self.__addr)
            status_msb, status_lsb, _ = I2C.read_cmd16(SHT31.__CMD_READ_STATUS, 3)

            return (status_msb << 8) | status_lsb

        finally:
            I2C.end_tx()
Example #10
0
    def __read_image(cls, memory_addr, count):
        try:
            I2C.start_tx(Host.DFE_EEPROM_ADDR)

            content = I2C.read_cmd(memory_addr, count)

            return EEPROMImage(content)
        finally:
            I2C.end_tx()
Example #11
0
    def __read_config(self):
        try:
            I2C.start_tx(self.__addr)
            msb, lsb = I2C.read_cmd(ADS1115.__REG_CONFIG, 2)

        finally:
            I2C.end_tx()

        config = (msb << 8) | lsb
        return config
Example #12
0
    def reset(self):
        try:
            I2C.start_tx(self.__addr)
            I2C.write16(SHT31.__CMD_RESET)
            time.sleep(0.001)

            I2C.write16(SHT31.__CMD_CLEAR)
            time.sleep(0.001)

        finally:
            I2C.end_tx()
Example #13
0
    def sample(self):
        try:
            I2C.start_tx(self.__addr)
            temp_msb, temp_lsb, _, humid_msb, humid_lsb, _ = I2C.read_cmd16(
                SHT31.__CMD_READ_SINGLE_HIGH, 6)

            raw_humid = (humid_msb << 8) | humid_lsb
            raw_temp = (temp_msb << 8) | temp_lsb

            return SHTDatum(SHT31.humid(raw_humid), SHT31.temp(raw_temp))

        finally:
            I2C.end_tx()
Example #14
0
    def __read_temp(cls):
        try:
            I2C.start_tx(cls.__ADDR)
            msb, lsb = I2C.read_cmd(cls.__REG_TEMP, 2)
        finally:
            I2C.end_tx()

        # render voltage...
        unsigned_c = float(msb & 0x1f) * 16 + float(lsb) / 16
        sign = msb & 0x10

        temp = 256 - unsigned_c if sign else unsigned_c

        return temp
Example #15
0
    def __read_array(cls, device_addr, memory_addr, count):
        try:
            I2C.start_tx(Host.DFE_UID_ADDR)

            # I2C.read(1)
        finally:
            I2C.end_tx()

        try:
            I2C.start_tx(Host.DFE_UID_ADDR)

            # I2C.write(0x80)

            return I2C.read_cmd(0x80, count)  # memory_addr,
        finally:
            I2C.end_tx()
Example #16
0
    def sample(self):
        if self.__addr == 0:
            return None

        try:
            I2C.start_tx(self.__addr)
            temp_msb, temp_lsb, _, humid_msb, humid_lsb, _ = I2C.read_cmd16(SHT31.__CMD_READ_SINGLE_HIGH, 6,
                                                                            wait=self.MEASUREMENT_DURATION)

            raw_humid = (humid_msb << 8) | humid_lsb
            raw_temp = (temp_msb << 8) | temp_lsb

            return SHTDatum(SHT31.humid(raw_humid), SHT31.temp(raw_temp))

        finally:
            I2C.end_tx()
Example #17
0
    def __write(self, command, wait, *values):
        try:
            self.obtain_lock()

            try:
                I2C.start_tx(self.__i2c_addr)

                encoded = self.__encode(values)
                I2C.write_addr16(command, *encoded)

            finally:
                I2C.end_tx()

            time.sleep(wait)

        finally:
            self.release_lock()
Example #18
0
    def read_conversion(self):
        """
        read most recent conversion
        returned value is voltage
        """
        try:
            I2C.start_tx(self.addr)
            v, config = self.__read()

        finally:
            I2C.end_tx()
            self.release_lock()

        if config & MCP342X.__START:
            raise ValueError(self.__class__.__name__ +
                             ":read_conversion: conversion not ready.")

        return v
Example #19
0
    def __read_conv(self):
        try:
            I2C.start_tx(self.__addr)
            msb, lsb = I2C.read_cmd(ADS1115.__REG_CONV, 2)

        finally:
            I2C.end_tx()

        # render voltage...
        unsigned = (msb << 8) | lsb

        # print("unsigned: 0x%04x" % unsigned)

        signed = struct.unpack('h', struct.pack('H', unsigned))

        v = (signed[0] / 32767.5) * ADS1115.__FULL_SCALE[self.__gain]

        return v
Example #20
0
    def __read(self, command, wait, count=0):
        try:
            self.obtain_lock()

            try:
                I2C.start_tx(self.__i2c_addr)

                encoded = I2C.read_cmd16(command, count)
                values = self.__decode(encoded)

            finally:
                I2C.end_tx()

            time.sleep(wait)
            return values

        finally:
            self.release_lock()
Example #21
0
    def convert(self):
        """
        start single-shot conversion, wait for ready, then read
        warning: creates high level of I2C traffic
        returned value is voltage
        """
        self.start_conversion()

        try:
            I2C.start_tx(self.addr)

            while True:
                v, config = self.__read()

                if not (config & MCP342X.__START):
                    break

                time.sleep(MCP342X.RATE_240)

        finally:
            I2C.end_tx()
            self.release_lock()

        return v
Example #22
0
 def __write_config(cls, config):
     try:
         I2C.start_tx(cls.__ADDR)
         I2C.write(cls.__REG_CONFIG, config >> 8, config & 0xff)
     finally:
         I2C.end_tx()
Example #23
0
 def __write_reg(cls, addr, value):
     try:
         I2C.start_tx(cls.__ADDR)
         I2C.write(addr, value)
     finally:
         I2C.end_tx()