(Created page with "<pre>#!/usr/bin/env python import time import struct RS = 20 # nominal, but sometimes 21 or 22 give more accurate results class Bitstring(long): """Number with an easy wa…")
Line 1: Line 1:
This script provides details regarding bq27k registers; it also doubles as a python library to access bq27k registers in a programmatic way.
<pre>#!/usr/bin/env python
<pre>#!/usr/bin/env python

Revision as of 19:20, 22 April 2013

This script provides details regarding bq27k registers; it also doubles as a python library to access bq27k registers in a programmatic way.

#!/usr/bin/env python

import time
import struct

RS = 20  # nominal, but sometimes 21 or 22 give more accurate results

class Bitstring(long):
    """Number with an easy way to access single bits or ranges of bits.

    b[n] is the n-th bit of b, as a bool
    b[a:b] is the bits from the a-th to the (b-1)th

    def __getitem__(self, item):
        # something that's not enough like a slice...
            start, stop = item.start, item.stop
        except AttributeError:
            return bool(self & 1 << item)

        # ...or something that is
        if start is None: start = 0

        if stop is None:
            return Bitstring(self >> start)
            return Bitstring((self >> start) % (1 << (stop - start)))

class MODE(Bitstring):
    """Device Mode Register"""

    def SHIP(self):
        """Ship mode"""
        return self[0]

    def FRST(self):
        """Full reset"""
        return self[1]

    def POR(self):
        """Power on Reset"""
        return self[2]

    def PRST(self):
        """Partial reset"""
        return self[3]

    def DONE(self):
        """Write LMD to NAC"""
        return self[4]

    def WRTNAC(self):
        """Write AR to NAC"""
        return self[5]

    def GPSTAT(self):
        """GPIO pin"""
        return self[6]

    def GPIEN(self):
        """State of the GPIO pin"""
        return self[7]

    def CIO(self):
        """Calibrate internal offset"""
        return self[4]

    def CEO(self):
        """Calibrate external offset"""
        return self[5]

class FLAGS(Bitstring):
    """Status Flags"""

    def EDVF(self):
        """Final End-of-Discharge-Voltage"""
        return self[0]

    def EDV1(self):
        """First End-of-Discharge-Voltage"""
        return self[1]

    def VDQ(self):
        """Valid Discharge"""
        return self[2]

    def CALIP(self):
        return self[3]

    def CI(self):
        """Capacity Inaccurate"""
        return self[4]

    def IMIN(self):
        """Li-ion taper current detection"""
        return self[5]

    def NOACT(self):
        """No Activity"""
        return self[6]

    def CHGS(self):
        """Charge State"""
        return self[7]

class DMFSD(Bitstring):
    """Digital Magnitude Filter and Self-Discharge Rate Constants"""

    def SD(self):
        """Self-Discharge Rate (%)"""
        return 1.61 / self[:4]

    def DMF(self):
        """Digital Magnitude Filter (mA)"""
        return self[4:] * 4.9 / RS

class TAPER(Bitstring):
    """Aging Estimate Enable, Charge Termination Taper Current"""

    def TAPER(self):
        """Charge Termination Taper Current (mA)"""
        return self[:7] * 228.48 / RS

    def AEE(self):
        """Aging Estimate Enable"""
        return self[7]

class PKCFG(Bitstring):
    """Pack Configuration Values"""

    def TCFIX(self):
        """Fixed temperature compensation"""
        return self[0]

    def DCFIX(self):
        """Fixed discharge compensation"""
        return self[1]

    def BOFF(self):
        """Board offset value (uV)"""
        # 3-bit two's complement
        return ((self[2:5] + 2) % 4 - 2) * 2.45

    def QV(self):
        """Qualification voltage for charge termination (mV)"""
        return 3968 + 48 * self[5:7]

    def GPIEN(self):
        """State of the GPIO pin on initial power up"""
        return self[7]

class DCOMP(Bitstring):
    """Discharge Rate Compensation Constants"""

    def DCOFF(self):
        """Discharge rate compensation threshold"""
        return [0, 0.5, 0.25, 0.125][self[:2]]

    def DCGN(self):
        """Discharge rate compensation gain (%)"""
        return self[2:] / 2.56

class TCOMP(Bitstring):
    """Temperature Compensation Constants"""

    def TOFF(self):
        """Temperature compensation offset (C)"""
        return self[:4]

    def TCGN(self):
        """Temperature compensation gain (%)"""
        return self[4:] / 10.24

class Bq27kData(object):
    """Class that provides data descriptors to fetch converted bq27k register
    data from an indexable object. The underlying object must return bytes
    curresponding to the bq27k registers on item access; alternatively, known
    two-byte registers might be stored on the "low" register - the "high" one
    must be 0, in this case.

    def CTRL(self):
        """Device Control Register"""
        return self[0x00]

    def MODE(self):
        """Device Mode Register"""
        return MODE(self[0x01])

    def AR(self):
        """At-Rate (mA)"""
        return word(self[0x02:0x04]) * 3.57 / RS

    def ARTTE(self):
        """At-Rate Time-to-Empty (min)"""
        return word(self[0x04:0x06])

    def TEMP(self):
        """Reported Temperature (C)"""
        return word(self[0x06:0x08]) * 0.25 - 273.15

    def VOLT(self):
        """Reported Voltage (mV)"""
        return word(self[0x08:0x0a])

    def FLAGS(self):
        """Status Flags"""
        return FLAGS(self[0x0a])

    def RSOC(self):
        """Relative State-of-Charge (%)"""
        return self[0x0b]

    def NAC(self):
        """Nominal Available Capacity (mAh)"""
        return word(self[0x0c:0x0e]) * 3.57 / RS

    def CACD(self):
        """Discharge Compensated NAC (mAh)"""
        return word(self[0x0e:0x10]) * 3.57 / RS

    def CACT(self):
        """Temperature Compensated CACD (mAh)"""
        return word(self[0x10:0x12]) * 3.57 / RS

    def LMD(self):
        """Last Measured Discharge (mAh)"""
        return word(self[0x12:0x14]) * 3.57 / RS

    def AI(self):
        """Average Current (mA)"""
        return word(self[0x14:0x16]) * 3.57 / RS

    def TTE(self):
        """Time-to-Empty (min)"""
        return word(self[0x16:0x18])

    def TTF(self):
        """Time-to-Full (min)"""
        return word(self[0x18:0x1a])

    def SI(self):
        """Standby Current (mA)"""
        return word(self[0x1a:0x1c]) * 3.57 / RS

    def STTE(self):
        """Standby Time-to-Empty (min)"""
        return word(self[0x1c:0x1e])

    def MLI(self):
        """Max Load Current (mA)"""
        return word(self[0x1e:0x20]) * 3.57 / RS

    def MLTTE(self):
        """Max Load Time-to-Empty (min)"""
        return word(self[0x20:0x22])

    def SAE(self):
        """Available Energy (mWh)"""
        return word(self[0x22:0x24]) * 29.2 / RS

    def AP(self):
        """Average Power (mW)"""
        return word(self[0x24:0x26]) * 29.2 / RS

    def TTECP(self):
        """Time-to-Empty At Constant Power (min)"""
        return word(self[0x26:0x28])

    def CYCL(self):
        """Cycle Count Since Learning Cycle"""
        return word(self[0x28:0x2a])

    def CYCT(self):
        """Cycle Count Total"""
        return word(self[0x2a:0x2c])

    def CSOC(self):
        """Compensated State-of-Charge (%)"""
        return self[0x2c]

    def CRES(self):
        """Calibration Result (uV)"""
        # 16-bit two's complement
        return ((word(self[0x5e:0x60]) + 0x8000) % 0x10000 - 0x8000) * 1.225

    def EE_EN(self):
        """EEPROM Program Enable"""
        return self[0x6e]

    def ILMD(self):
        """Initial Last Measured Discharge (mAh)"""
        return self[0x76] * 913.92 / RS

    def EDVF(self):
        """EDVF Threshold (mV)"""
        return (self[0x77] + 256) * 8

    def EDV1(self):
        """EDV1 Threshold (mV)"""
        return (self[0x78] + 256) * 8

    def ISLC(self):
        """Initial Standby Load Current (mA)"""
        return self[0x79] * 7.14 / RS

    def DMFSD(self):
        """Digital Magnitude Filter and Self-Discharge Rate Constants"""
        return DMFSD(self[0x7a])

    def TAPER(self):
        """Aging Estimate Enable, Charge Termination Taper Current"""
        return TAPER(self[0x7b])

    def PKCFG(self):
        """Pack Configuration Values"""
        return PKCFG(self[0x7c])

    def IMLC(self):
        """Initial Max Load Current (mA)"""
        return self[0x7d] * 456.96 / RS

    def DCOMP(self):
        """Discharge Rate Compensation Constants"""
        return DCOMP(self[0x7e])

    def TCOMP(self):
        """Temperature Compensation Constants"""
        return TCOMP(self[0x7f])

    def ID(self):
        """Identification Bytes"""
        return struct.pack("3B", *self[0x7f:0x7c:-1])

class Bq27kAuto(Bq27kData):
    def __init__(self, grace=5):
        if grace < 5: raise ValueError("grace must be at least 5 seconds")
        self.grace = grace
        self._cache = [0] * 128
        self.refresh(refresh_all=True, force=True)

    def __getitem__(self, item):
        return self._cache[item]

    def wait(self, minimum=0, refresh_all=False):
        time.sleep(max(self._expire - time.time(), minimum))
        self.refresh(refresh_all=refresh_all, force=True)

    def refresh(self, refresh_all=False, force=False):
        if not force and time.time() < self._expire:
        if refresh_all:
        self._expire = time.time() + self.grace

    def _read_all(self, stop=0x80):
        for line in open("/sys/class/power_supply/bq27200-0/registers", "rt"):
            addr, _, val = line.strip().partition("=")
            addr, val = int(addr, base=16), int(val, base=16)
            if addr >= stop: break
            self._cache[addr] = val

    def _read_ram(self):

class Bq27kList(list, Bq27kData):
    """A list with data descriptors to convert bq27k register data."""

def read_registers(path="/sys/class/power_supply/bq27200-0/registers"):
    reg = [0] * 128
    for line in open(path, "rt"):
        addr, _, val = line.strip().partition("=")
        addr, val = int(addr, base=16), int(val, base=16)
        reg[addr] = val
    return reg

def word(pair):
    return pair[1] << 8 | pair[0]

if __name__ == "__main__":
    import sys
    if len(sys.argv) > 1:
        RS = int(sys.argv[1])
    reg = Bq27kAuto()
    mode, flags, pkcfg = reg.MODE, reg.FLAGS, reg.PKCFG
    print("Sense resistance (RS): %s mohm" % RS)
    print("Device Control Register (CTRL): 0x%02x" % reg.CTRL)
    print("Device Mode Register (MODE):")
    print("    Ship mode (SHIP): %s" % mode.SHIP)
    print("    Full reset (FRST): %s" % mode.FRST)
    print("    Power on Reset (POR): %s" % mode.POR)
    print("    Partial reset (PRST): %s" % mode.PRST)
    print("    Write LMD to NAC (DONE): %s" % mode.DONE)
    print("    Write AR to NAC (WRTNAC): %s" % mode.WRTNAC)
    print("    GPIO pin (GPSTAT): %s" % mode.GPSTAT)
    print("    State of the GPIO pin (GPIEN): %s" % mode.GPIEN)
    print("    Calibrate internal offset (CIO): %s" % mode.CIO)
    print("    Calibrate external offset (CEO): %s" % mode.CEO)
    print("At-Rate (AR): %s mA" % reg.AR)
    print("At-Rate Time-to-Empty (ARTTE): %s min" % reg.ARTTE)
    print("Reported Temperature (TEMP): %s C" % reg.TEMP)
    print("Reported Voltage (VOLT): %s mV" % reg.VOLT)
    print("Status Flags (FLAGS):")
    print("    Final End-of-Discharge-Voltage (EDVF): %s" % flags.EDVF)
    print("    First End-of-Discharge-Voltage (EDV1): %s" % flags.EDV1)
    print("    Valid Discharge (VDQ): %s" % flags.VDQ)
    print("    Calibration-In-Progress (CALIP): %s" % flags.CALIP)
    print("    Capacity Inaccurate (CI): %s" % flags.CI)
    print("    Li-Ion taper current detection (IMIN): %s" % flags.IMIN)
    print("    No Activity (NOACT): %s" % flags.NOACT)
    print("    Charge State (CHGS): %s" % flags.CHGS)
    print("Relative State-of-Charge (RSOC): %s%%" % reg.RSOC)
    print("Nominal Available Capacity (NAC): %s mAh" % reg.NAC)
    print("Discharge Compensated NAC (CACD): %s mAh" % reg.CACD)
    print("Temperature Compensated CACD (CACT): %s mAh" % reg.CACT)
    print("Last Measured Discharge (LMD): %s mAh" % reg.LMD)
    print("Average Current (AI): %s mA" % reg.AI)
    print("Time-to-Empty (TTE): %s min" % reg.TTE)
    print("Time-to-Full (TTF): %s min" % reg.TTF)
    print("Standby Current (SI): %s mA" % reg.SI)
    print("Standby Time-to-Empty (STTE): %s min" % reg.STTE)
    print("Max Load Current (MLI): %s mA" % reg.MLI)
    print("Max Load Time-to-Empty (MLTTE): %s min" % reg.MLTTE)
    print("Available Energy (SAE): %s mWh" % reg.SAE)
    print("Average Power (AP): %s mW" % reg.AP)
    print("Time-to-Empty At Constant Power (TTECP): %s min" % reg.TTECP)
    print("Cycle Count Since Learning Cycle (CYCL): %s cycles" % reg.CYCL)
    print("Cycle Count Total (CYCT): %s cycles" % reg.CYCT)
    print("Compensated State-of-Charge (CSOC): %s%%" % reg.CSOC)
    print("Calibration Result: %s uV" % reg.CRES)
    print("EEPROM Program Enable (EE_EN): 0x%02x" % reg.EE_EN)
    print("Initial Last Measured Discharge (ILMD): %s mAh" % reg.ILMD)
    print("EDVF Threshold (EDVF): %s mV" % reg.EDVF)
    print("EDV1 Threshold (EDV1): %s mV" % reg.EDV1)
    print("Initial Standby Load Current (ISLC): %s mA" % reg.ISLC)
        "Digital Magnitude Filter and Self-Discharge Rate Constants (DMFSD):")
    print("    Self-Discharge Rate (SD): %s%%" % reg.DMFSD.SD)
    print("    Digital Magnitude Filter (DMF): %s mA" % reg.DMFSD.DMF)
        "Aging Estimate Enable, Charge Termination Taper Current (TAPER):")
    print("    Charge Termination Taper Current (TAPER): %s mA"
          % reg.TAPER.TAPER)
    print("    Aging Estimate Enable (AEE): %s" % reg.TAPER.AEE)
    print("Pack Configuration Values (PKCFG):")
    print("    Fixed temperature compensation (TCFIX): %s" % pkcfg.TCFIX)
    print("    Fixed discharge compensation (DCFIX): %s" % pkcfg.DCFIX)
    print("    Board offset value (BOFF): %s uV" % pkcfg.BOFF)
    print("    Qualification voltage for charge termination (QV): %s mV"
          % pkcfg.QV)
    print("    State of the GPIO pin on initial power up (GPIEN): %s"
          % pkcfg.GPIEN)
    print("Initial Max Load Current (IMLC): %s mA" % reg.IMLC)
    print("Discharge Rate Compensation Constants (DCOMP):")
    print("    Discharge rate compensation threshold (DCOFF): %s"
          % reg.DCOMP.DCOFF)
    print("    Discharge rate compensation gain (DCGN): %s%%"
          % reg.DCOMP.DCGN)
    print("Temperature Compensation Constants (TCOMP):")
    print("    Temperature compensation offset (TOFF): %s C"
          % reg.TCOMP.TOFF)
    print("    Temperature compensation gain (TCGN): %s%%"
          % reg.TCOMP.TCGN)
    print("Identification Bytes (ID): %r" % reg.ID)