BQ34Z100-G1: configuration issues + lack of understanding regarding some parameters

Edit:

When CCGain and CCDelta are set to 5mOhm. The measured current is 20230 mA; applied current is -1.00A. The DF value for 5mOhm is "2155093793". After estimating the new CCGain and CCDelta using the formula below:

float newCurrentGain = (static_cast<float>(currentMeasured)/currentApplied) * currentGainR; //currentGainR = 5.0 mOhm
uint32_t xemicCCGain = floatToXemics(4.768/newCurrentGain);

the newCurrentGain is "-96.4885559" when converted to DF "2103784394".

And the measured current after that is 2304 mA which is still not right.

Following is the code for floatToXemics:

uint32_t BQ34Z100::floatToXemics(float value)	{
	int iByte1,iByte2,iByte3,iByte4,iExp;
	bool bNegative = false;
	float fMantissa;

	//Dont blow up with logs of zero
	if(value ==0)
			value = 0.00001F;
	if(value < 0)
	{
		bNegative = true;
		value =- value;
	}

	iExp = static_cast<int>((std::log(value)/std::log(2)) + 1);	//remember - log of any base is ln(x)/ln(base)
	//MSB is the exponent + 0x80
	iByte1 = iExp + 128;

	//Divide input by the exponent to get mantissa;
	fMantissa = value /(std::pow(2,iExp));

	//scale it up
	fMantissa = fMantissa / (std::pow(2,-24));
	//split the mantissa into 3 bytes
	iByte2 = static_cast<int>(fMantissa/std::pow(2,16));

	iByte3 = static_cast<int>((fMantissa - (iByte2*std::pow(2,16)))/std::pow(2,8));

	iByte4 = static_cast<int>((fMantissa - (iByte2*std::pow(2,16)))- (iByte3*std::pow(2,8)));

	//subtract the sign bit if the number is positive
	if(bNegative == false)
			iByte2 = iByte2 & 0x7F;

	return  static_cast<uint32_t> (iByte1<<24) | static_cast<uint32_t> (iByte2<<16) |
						static_cast<uint32_t> (iByte3<<8) | static_cast<uint32_t> (iByte4);

}

Please do let me know if the above impl of floatToXemics is correct

xemicsToFloat Code:

float BQ34Z100::xemicsToFloat(uint32_t value)	{
	bool bIsPositive=false;
	float fExponent,fResult;

	uint8_t vMSByte,vMidHiByte,vMidLoByte,vLSByte;

	vMSByte = static_cast<uint8_t>(value >> 24);
	vMidHiByte = static_cast<uint8_t>(value >> 16);
	vMidLoByte = static_cast<uint8_t>(value >> 8);
	vLSByte = static_cast<uint8_t>(value);
	//Get the sign its in the 0x00 80 00 00 bit
	if((vMidHiByte & 128) == 0)
		bIsPositive = true;

	//Get the Exponent its 2^(vMSByte-128)
	fExponent = std::pow(2,vMSByte-128);
	// or in 0x80 to the vMidhiByte
	vMidHiByte = (vMidHiByte | 128);
	// get value of the vMidHiByte
	fResult = vMidHiByte*65536;
	//add in vMidLoByte
	fResult += vMidLoByte*256;
	//add in vLSByte
	fResult = fResult + vLSByte;
	//multiply by 2^(-24) to get the actual fraction
	fResult = fResult * std::pow(2,-24);
	//multiply the fraction by the exponent part
	fResult *= fExponent;


	if(bIsPositive)
		return fResult;
	else
		return -fResult;
}

writeDataFlashBlock and readDataFlashBlock:

void BQ34Z100::writeDataFlashBlock(uint8_t subclass,uint8_t index,uint8_t blockSize)	{
	blockDataControl();
	hw::Timer.udelay(190);
	dataFlashClass(subclass);
	hw::Timer.udelay(190); 
	dataFlashBlock(index);
	hw::Timer.udelay(1000);
	writeBlock(0x40,&flashData[index],blockSize);
}

void BQ34Z100::readDataFlashBlock(uint8_t subclass,uint8_t index,uint8_t blockSize) {
	blockDataControl();
	hw::Timer.udelay(190); //Break Time
	dataFlashClass(subclass);
	hw::Timer.udelay(190); //Break Time
	dataFlashBlock(index);
	hw::Timer.udelay(190);	

	readBlock(0x40,&flashData[index],blockSize);
	hw::Timer.udelay(190);
	readCheckSum();
	oldMSB = flashData[index];
	lastreadBlocksize = blockSize;
	lastreadIndex = index;
}

This is the uint8_t flashData[32] array after reading the 104 subclass:

gdb Output:

{0xff, 0xff, 0xff, 0xf3, 0xe1, 0x41, 0x0 <repeats 26 times>}

the above value represents DF CCGain "4294967283"

after modifying the CC Delta and CCGain

new CCGain "2130706432"

gdb Output:

{0x7f, 0x0, 0x0, 0x0, 0x7f, 0x0 <repeats 27 times>}

Current before calibration:

384 mA

current After Calibration:

5376 mA

P.S now my voltage values are swinging wildly as well after each power cycle.

the voltageDivider value i applied is 26080 for a 24V battery.

This post says that the floating point of many TI gauges is not the same as IEEE floating point