drivers: Standardize I2C helper method naming.

lib/bq27441/bq27441/device.py

@@ -461,16 +461,16 @@ def softReset(self):
 
     # Read a 16 - bit command word from the BQ27441-G1A, def format = little endian int16
     def readWord(self, subAddress, format="<h"):
-        data = bytes(self.i2cReadBytes(subAddress, 2))
+        data = bytes(self._read_reg(subAddress, 2))
         return struct.unpack(format, data)[0]
 
     # Read a 16 - bit subcommand() from the BQ27441-G1A's control()
     def readControlWord(self, function):
         subCommandMSB = function >> 8
         subCommandLSB = function & 0x00FF
         command = [subCommandLSB, subCommandMSB]
-        self.i2cWriteBytes(0, command, 2)
-        data = self.i2cReadBytes(0, 2)
+        self._write_reg(0, command, 2)
+        data = self._read_reg(0, 2)
         if data:
             return (data[1] << 8) | data[0]
 
@@ -481,7 +481,7 @@ def executeControlWord(self, function):
         subCommandMSB = function >> 8
         subCommandLSB = function & 0x00FF
         command = [subCommandLSB, subCommandMSB]
-        if self.i2cWriteBytes(0, command, 2):
+        if self._write_reg(0, command, 2):
             return True
 
         return False
@@ -490,39 +490,40 @@ def executeControlWord(self, function):
     # Issue a BlockDataControl() command to enable BlockData access
     def blockDataControl(self):
         enableByte = [0x00]
-        return self.i2cWriteBytes(BQ27441_EXTENDED_CONTROL, enableByte, 1)
+        return self._write_reg(BQ27441_EXTENDED_CONTROL, enableByte, 1)
 
     # Issue a DataClass() command to set the data class to be accessed
 
     def blockDataClass(self, _id):
-        return self.i2cWriteBytes(BQ27441_EXTENDED_DATACLASS, _id, 1)
+        _id = [_id]
+        return self._write_reg(BQ27441_EXTENDED_DATACLASS, _id, 1)
 
     # Issue a DataBlock() command to set the data block to be accessed
     def blockDataOffset(self, offset):
         offset = [offset]
-        return self.i2cWriteBytes(BQ27441_EXTENDED_DATABLOCK, offset, 1)
+        return self._write_reg(BQ27441_EXTENDED_DATABLOCK, offset, 1)
 
     # Read the current checksum using BlockDataCheckSum()
     def blockDataChecksum(self):
-        csum = self.i2cReadBytes(BQ27441_EXTENDED_CHECKSUM, 1)
+        csum = self._read_reg(BQ27441_EXTENDED_CHECKSUM, 1)
         return csum
 
     # Use BlockData() to read a byte from the loaded extended data
     def readBlockData(self, offset):
         address = offset + BQ27441_EXTENDED_BLOCKDATA
-        ret = self.i2cReadBytes(address, 1)
+        ret = self._read_reg(address, 1)
         return ret
 
     # Use BlockData() to write a byte to an offset of the loaded data
     def writeBlockData(self, offset, data):
         address = offset + BQ27441_EXTENDED_BLOCKDATA
         data = [data]
-        return self.i2cWriteBytes(address, data, 1)
+        return self._write_reg(address, data, 1)
 
     # Read all 32 bytes of the loaded extended data and compute a
     # checksum based on the values.
     def computeBlockChecksum(self):
-        data = self.i2cReadBytes(BQ27441_EXTENDED_BLOCKDATA, 32)
+        data = self._read_reg(BQ27441_EXTENDED_BLOCKDATA, 32)
         csum = 0
         for i in range(32):
             csum += data[i]
@@ -533,7 +534,7 @@ def computeBlockChecksum(self):
     # Use the BlockDataCheckSum() command to write a checksum value
     def writeBlockChecksum(self, csum):
         csum = [csum]
-        return self.i2cWriteBytes(BQ27441_EXTENDED_CHECKSUM, csum, 1)
+        return self._write_reg(BQ27441_EXTENDED_CHECKSUM, csum, 1)
 
     # Read a byte from extended data specifying a class ID and position offset
     def readExtendedData(self, classID, offset):
@@ -593,12 +594,12 @@ def writeExtendedData(self, class_id, offset, data, length):
         return True
 
     # I2C Read / Write Functions
-    def i2cReadBytes(self, subAddress, count):
+    def _read_reg(self, subAddress, count):
         result = self.i2c.readfrom_mem(self.address, subAddress, count)
         return list(result)
 
     # Write a specified number of bytes over I2C to a given subAddress
-    def i2cWriteBytes(self, memAddress, buf, count):
+    def _write_reg(self, memAddress, buf, count):
         self.i2c.writeto_mem(self.address, memAddress, bytes(buf))
         return True
 

lib/hts221/hts221/device.py

@@ -25,75 +25,75 @@ def __init__(self, i2c, address=HTS_I2C_ADDR):
 
     def calibrate_temperature(self):
         # HTS221 Temp Calibration registers
-        self.T0_OUT = int16(self.get2Reg(HTS221_T0_OUT_L))
-        self.T1_OUT = int16(self.get2Reg(HTS221_T1_OUT_L))
+        self.T0_OUT = int16(self._read_reg16(HTS221_T0_OUT_L))
+        self.T1_OUT = int16(self._read_reg16(HTS221_T1_OUT_L))
 
-        t1 = self.getReg(HTS221_T1T0_msb)
-        self.T0_degC = (self.getReg(HTS221_T0_degC_x8) + (t1 % 4) * 256) / 8
-        self.T1_degC = (self.getReg(HTS221_T1_degC_x8) + ((t1 % 16) / 4) * 256) / 8
+        t1 = self._read_reg(HTS221_T1T0_msb)
+        self.T0_degC = (self._read_reg(HTS221_T0_degC_x8) + (t1 % 4) * 256) / 8
+        self.T1_degC = (self._read_reg(HTS221_T1_degC_x8) + ((t1 % 16) / 4) * 256) / 8
 
     def calibrate_humidity(self):
         # HTS221 Humi Calibration registers
-        self.H0_OUT = self.get2Reg(HTS221_H0_T0_OUT_L)
-        self.H1_OUT = self.get2Reg(HTS221_H1_T0_OUT_L)
-        self.H0_rH = self.getReg(HTS221_H0_rH_x2) / 2
-        self.H1_rH = self.getReg(HTS221_H1_rH_x2) / 2
+        self.H0_OUT = self._read_reg16(HTS221_H0_T0_OUT_L)
+        self.H1_OUT = self._read_reg16(HTS221_H1_T0_OUT_L)
+        self.H0_rH = self._read_reg(HTS221_H0_rH_x2) / 2
+        self.H1_rH = self._read_reg(HTS221_H1_rH_x2) / 2
 
-    def setReg(self, dat, reg):
+    def _write_reg(self, reg, dat):
         self.writebuffer[0] = dat
         self.i2c.writeto_mem(self.address, reg, self.writebuffer)
 
-    def getReg(self, reg):
+    def _read_reg(self, reg):
         self.i2c.readfrom_mem_into(self.address, reg, self.readbuffer)
         return self.readbuffer[0]
 
-    def get2Reg(self, reg):
-        lowerByte = self.getReg(reg)
-        higherByte = self.getReg(reg + 1)
+    def _read_reg16(self, reg):
+        lowerByte = self._read_reg(reg)
+        higherByte = self._read_reg(reg + 1)
         return (higherByte << 8) + lowerByte
 
     # Device identification
     def whoAmI(self):
-        return self.getReg(HTS221_WHO_AM_I)
+        return self._read_reg(HTS221_WHO_AM_I)
 
     # get STATUS register
     def status(self):
-        return self.getReg(HTS221_STATUS_REG)
+        return self._read_reg(HTS221_STATUS_REG)
 
     # power control
     def poweroff(self):
-        t = self.getReg(HTS221_CTRL_REG1) & 0x7F
-        self.setReg(t, HTS221_CTRL_REG1)
+        t = self._read_reg(HTS221_CTRL_REG1) & 0x7F
+        self._write_reg(HTS221_CTRL_REG1, t)
 
     def poweron(self):
-        t = self.getReg(HTS221_CTRL_REG1) | 0x80
-        self.setReg(t, HTS221_CTRL_REG1)
+        t = self._read_reg(HTS221_CTRL_REG1) | 0x80
+        self._write_reg(HTS221_CTRL_REG1, t)
 
     # get/set Output data rate
     def getODR(self):
-        return self.getReg(HTS221_CTRL_REG1) & 0x03
+        return self._read_reg(HTS221_CTRL_REG1) & 0x03
 
     def setODR(self, odr=0):
-        t = self.getReg(HTS221_CTRL_REG1) & 0xFC
-        self.setReg(t | odr, HTS221_CTRL_REG1)
+        t = self._read_reg(HTS221_CTRL_REG1) & 0xFC
+        self._write_reg(HTS221_CTRL_REG1, t | odr)
 
     # get/set Humidity and temperature average configuration
     def getAv(self):
-        return self.getReg(HTS221_AV_CONF)
+        return self._read_reg(HTS221_AV_CONF)
 
     def setAv(self, av=0):
-        self.setReg(av, HTS221_AV_CONF)
+        self._write_reg(HTS221_AV_CONF, av)
 
     # calculate Temperature
     def temperature(self):
-        t = self.get2Reg(HTS221_TEMP_OUT_L)
+        t = self._read_reg16(HTS221_TEMP_OUT_L)
         return self.T0_degC + (self.T1_degC - self.T0_degC) * (t - self.T0_OUT) / (
             self.T1_OUT - self.T0_OUT
         )
 
     # calculate Humidity
     def humidity(self):
-        t = self.get2Reg(HTS221_HUMIDITY_OUT_L)
+        t = self._read_reg16(HTS221_HUMIDITY_OUT_L)
         return self.H0_rH + (self.H1_rH - self.H0_rH) * (t - self.H0_OUT) / (
             self.H1_OUT - self.H0_OUT
         )