Numerous issues with LTC681x Open wire algorithm

[gudnimg]

I've been trying to get Open Wire check to work on the DC2259A (LTC6811) Evalution board for quite some time but it never works. So I've had to go into the code and understand each line so that I might prove that the problem is not with the code. I have found many issues and inconsistencies with the datasheet and would like to share what I've found.

Here is a post I made a year ago: https://ez.analog.com/power/f/q-a/120413/ltc6811-dc2259a-open-wire-check-not-working-with-resistors this problem is still around and I haven't found a solution.

Below are some issues I see:

• Why does the Open wire check for cell voltages use 400mV but GPIO open wire check uses 15mV? There is no mention of this in the datasheet. Where does the "-400mV" stated in the datasheet come from?
• There is no check for a PEC mismatch when reading the cell voltages.
• In LTC681x_run_openwire_single the pull-up value is used to check for an open wire for the last cell when we should be using the pull-down measurement.
• In LTC681x_run_openwire_single this check pullDwn[cic][cell] < pullUp[cic][cell] shouldn't be needed. Otherwise the datasheet should mention it.
• In LTC681x_run_openwire_single this check openWire_delta[cic][cell]>OPENWIRE_THRESHOLD is incorrect. The threshold is also set incorrectly. This should be openWire_delta[cic][cell] < -4000
• In LTC681x_run_openwire_single the variable conv_time is never used.
• openWire_delta is calcuated for Cell 1 when it should only be for Cell 2 to 11. Simple fix is to change for-loop start from 0 to 1.

Numerous issues arise when looking at LTC681x_run_openwire_multi compared to LTC681x_run_openwire_single. The functions are very different when they don't need to be. Some issues above are also present in LTC681x_run_openwire_multi.

• In LTC681x_run_openwire_multi the variable openWire_delta is uint16_t instead of int16_t so basically negative values are ignored.
• Removing repetitive elements and sorting array elements is not needed. It is much simpler to have each index of opencells represent cell index and only take value 0 or 1. Where 1 indicates open wire.
• For Cell 1 pull-down value is incorrectly used if (pullDwn[cic][0] == 0) when the pull-up value should be used according to the datasheets.

This code doesn't do anything useful:

if (pullDwn[cic][N_CHANNELS-2] == 0)
{  
    opencells[n] = N_CHANNELS-1;
    n++;
}

Also the code below in LTC681x_run_openwire_multi does not follow the datasheet algorithm so I'm assuming it's not correct.

if (openWire_delta[cic][cell]>OPENWIRE_THRESHOLD)
{
	opencells[n] = cell+1;
	n++;
        // Is the code below this comment really needed?
	for (int j = cell; j < N_CHANNELS-3 ; j++)                       
	{
		if (pullUp[cic][j + 2] == 0)
		{
			opencells[n] = j+2;
			n++;
		}
	}
	if((cell==N_CHANNELS-4) && (pullDwn[cic][N_CHANNELS-3] == 0))
	{
		opencells[n] = N_CHANNELS-2;
		n++;
	}
}

[gudnimg]

I've been struggling to get Open Wire check to work for DC2259A (LTC6811) evalution board. From my tests I think that -400mV is not the right value but I am curious why the GPIO checks for LTC6813 use 15mV and not 400mV.

Below is how LTC681x_run_openwire_single could be improved for this issue + I added a bunch of useful comments in my opinion to help understand the process.

/* Runs the data sheet algorithm for open wire for single cell detection */
void LTC681x_run_openwire_single(uint8_t total_ic, // Number of ICs in the daisy chain
								cell_asic ic[] // A two dimensional array that will store the data
								)
{				  
    int32_t OPENWIRE_THRESHOLD = -4000; // -400mV
    const uint8_t  N_CHANNELS = ic[0].ic_reg.cell_channels;
	
    int16_t pullUp[total_ic][N_CHANNELS];
    int16_t pullDwn[total_ic][N_CHANNELS];
    int32_t openWire_delta[total_ic][N_CHANNELS];

    // Initalise variables
    for (uint8_t c_ic = 0; c_ic < total_ic; c_ic++)
    {
        ic[c_ic].system_open_wire = 0xFFFF;
        for (uint8_t cell = 0; cell < N_CHANNELS; cell++)
        {
            pullUp[c_ic][cell] = 0;
            pullDwn[c_ic][cell] = 0;
            openWire_delta[c_ic][cell] = 0;
        }
    }

    LTC681x_clrcell();

    // -------------------- STEP 1 --------------------
    // Run the 12-cell command ADOW with PUP = 1 at least
    // twice. Read the cell voltages for cells 1 through 12 once
    // at the end and store them in array CELLPU(n).
    for (uint8_t i = 0; i < 10; i++)
    { 
        LTC681x_adow(MD_26HZ_2KHZ, PULL_UP_CURRENT, CELL_CH_ALL, DCP_DISABLED);
        LTC681x_pollAdc();
    } 

    wakeup_idle(total_ic);
    LTC681x_rdcv(CELL_CH_ALL, total_ic, ic);
    // TODO: add check for PEC mismatch using ic->cells.pec_match
    //       either add timeout or cancel test
	
    for (uint8_t c_ic = 0; c_ic < total_ic; c_ic++)
    {
        for (uint8_t cell = 0; cell < N_CHANNELS; cell++)
	{
            pullUp[c_ic][cell] = ic[c_ic].cells.c_codes[cell];
	}
    }
    LTC681x_clrcell();

    // -------------------- STEP 2 --------------------
    // Run the 12-cell command ADOW with PUP = 0 at least
    // twice. Read the cell voltages for cells 1 through 12 once
    // at the end and store them in array CELLPD(n).

    wakeup_idle(total_ic);
    for (uint8_t i = 0; i < 10; i++)
    {  
        LTC681x_adow(MD_26HZ_2KHZ, PULL_DOWN_CURRENT, CELL_CH_ALL, DCP_DISABLED);
        LTC681x_pollAdc();
    }
	
    wakeup_idle(total_ic);
    LTC681x_rdcv(CELL_CH_ALL, total_ic, ic); 
    // TODO: add check for PEC mismatch using ic->cells.pec_match
    //       either add timeout or cancel test

    for (uint8_t c_ic = 0; c_ic < total_ic; c_ic++)
    {		  
        for (uint8_t cell = 0; cell < N_CHANNELS; cell++)
	{
            pullDwn[c_ic][cell] = ic[c_ic].cells.c_codes[cell];
	}
    }

    for (uint8_t cic = 0; cic < total_ic; cic++)
    {
        // If CELLPU(1) = 0.0000, then C(0) is open
	if (pullUp[cic][0] == 0)
	{
            ic[cic].system_open_wire = 0;
	}

        // If CELLPD(12) = 0.0000, then C(12) is open.
	if (pullDwn[cic][(N_CHANNELS-1)] == 0)
	{
	     ic[cic].system_open_wire = N_CHANNELS;
        }
    }


    for (uint8_t cic=0; cic < total_ic; cic++)
    {
        for (uint8_t cell = 1; cell < (N_CHANNELS - 1); cell++)
	{
            // -------------------- STEP 3 --------------------
            // Take the difference between the pull-up and pull-down
            // measurements made in above steps for cells 2 to 12:
            // CELL∆(n) = CELLPU(n) – CELLPD(n).
	    openWire_delta[cic][cell] = pullUp[cic][cell] - pullDwn[cic][cell];

            // -------------------- STEP 4 --------------------
            // For all values of n from 1 to 11: If CELL∆(n+1) < –400mV,
            // then C(n) is open.
            if (openWire_delta[cic][cell] < OPENWIRE_THRESHOLD)
	    {
	        ic[cic].system_open_wire = cell + 1;
            }
        }
    }
}

This is what data I get from this:

I am not seeing why -400mV threshold is defined I always get a measurement close to 0 for the Open Wire channel.