BQ27427: Gauge counts backwards, flags backwards too

Hello, 

The sign of the CC Gain parameter is probably incorrect, please refer to this E2E thread for how to change the sign of the CC Gain parameter.

Regards, 

Robert. 

I don't use bqstudio. I work on the basis of the TRM and whatever other docs I manage to find.

This is an actual problem.

The chip comes with this bad value from the factory. Clearing the sign to turn it positive is the hotfix. The documentation does not mention this anywhere, does not even document the "CC Gain" register, or its format.

I found more threads about this in the meantime. I also found more info than you've linked to.

That's not an IEEE 754 float. It's a "Xemics" float. Whatever that is. Found a 21 year old app note with *Visual Basic* code to encode and decode these things. No actual spec so far.

TI need to do better.

On Monday I'll make a post with some illustrations and C code for the poor souls that will run into this issue after me.

And since I saw some conversion code in Python posted in this forum, here's my own interpretation, which works exactly, and checks for incompatible values.

import math
import struct
import numpy as np

def build_xemics(sign, exponent, mantissa):
    assert sign in (0, 1), sign
    assert -128 <= exponent < 128, exponent
    assert mantissa & 0x800000, "where is the leading one?"
    mantissa &= ~0x800000 # clear the leading 1 (implicit)
    assert 0 <= mantissa, "mantissa is negative"
    assert mantissa < 2**23, "mantissa has some bits on integer side"

    return bytes([
        exponent + 128,
        ((mantissa >> 16) & 0x7F) | (sign << 7),
        ((mantissa >>  8) & 0xFF),
        ((mantissa >>  0) & 0xFF),
    ])

def xemics_from_fp32(value):
    if np.isinf(value):
        if value > 0:
            return build_xemics(0, 127, 0xFFFFFF)
        else:
            return build_xemics(1, 127, 0xFFFFFF)
    elif np.isnan(value):
        raise ValueError("NaN not supported")

    sign = np.signbit(value) # (value < 0) except 0 can have a sign, so this also copies that
    if sign: value = -value
    (mantissa, exponent) = np.frexp(value)

    mantissa = np.ldexp(mantissa, 24)
    mantissa = round(mantissa)

    if value == 0: # xemics can't express 0.
        exponent, mantissa = -128, 0x800000 # that's closest to 0

    # IEEE figures 2^exp * 1.mmm, exp being -126 to +127 (bias 127, special values for -127 and 128)
    # Xemics figures 2^exp * 0.1mmm, exp being -128 to +127 (bias 128, no specials)
    # so IEEE floats can express larger numbers than xemics
    # (2^127 * 1.mmm = 2^128 * 0.1mmm)
    # in that case we can only clip
    if exponent >= 128:
        exponent, mantissa = 127, 0xFFFFFF

    assert mantissa & 0x800000 != 0, "by construction, there should have been a leading 1"
    assert mantissa <= 0xFFFFFF, "rounding up was a mistake?"

    return build_xemics(sign, exponent, mantissa)

def fp32_from_xemics(value_xemics):
    assert isinstance(value_xemics, (bytes, bytearray))
    assert len(value_xemics) == 4
    exponent = value_xemics[0]
    mantissa = (value_xemics[1] << 16) | (value_xemics[2] << 8) | (value_xemics[3] << 0)
    sign = bool(mantissa & 0x800000) # 0 = positive, 1 = negative
    mantissa |= 0x800000 # implied 1.xxx
    result = np.ldexp(mantissa, exponent - 128 - 24)
    if sign: result = -result
    # result = result.astype(np.float32)
    return result
    
if __name__ == '__main__':
    value_float = np.float32(np.pi) # any reasonable value
    assert fp32_from_xemics(xemics_from_fp32(value_float)) == value_float

    value_xemics = bytes.fromhex("82 49 0f db") # that happens to be pi
    assert xemics_from_fp32(fp32_from_xemics(value_xemics)) == value_xemics

Another piece of the puzzle that is BQ27427: if you want to write stuff like the Chemistry ID, design capacity, ... don't read back right after writing. Soft-reset first, which you need to anyway. Only after the soft-reset will you read back what you just wrote. If you read back before the soft-reset, it'll be the old value. It's like reading the effective value.