openinverter forum

Code: Select all

void readData() 
{	
    for(int i=0; i<8; i++)
  {
    readAllSlaves((0x20 + i), true); // Read CELL 1-8 of all slaves
  }
  //readAllSlaves(0x2D, true); // Read AIN1 of all slaves (Cell temperature)
  readAllSlaves(0x50, true); // Read DIAG (Die temperature) of all slaves
}

Code: Select all

void storeCellVoltage(uint8_t dataRegister, uint8_t readRegisterData[29]) 
{	
	if((dataRegister >= 0x20) && (dataRegister <= 0x27)) // Cell voltage registers 1-8
  {
    uint8_t cellNumberOffset = dataRegister - 0x20;
    
    for(int i=0; i<8; i++)
		{
			uint16_t measVoltage = ((readRegisterData[25-i*2] << 8) + readRegisterData[24-i*2]);
			measVoltage = (measVoltage >> 2) * (uint32_t)5000 / 0x3FFF;
			cellVoltage[i*8 + cellNumberOffset] = measVoltage;
		}
	}
}

Code: Select all

if(dataRegister == 0x2D) // Aux voltage measurements (external temperature sensors)
		{
			storeCellTemperature(readRegisterData);
		}

Code: Select all

/*if(dataRegister == 0x2D) // Aux voltage measurements (external temperature sensors)
		{
			storeCellTemperature(readRegisterData);
		}*/

Code: Select all

boolean balanceCells(uint16_t lowestCellVoltage)
{
	static uint8_t counter = 1;
	static uint16_t cellToBalanceFilter = 0x0FFF & 0x5555; // Every odd cell
	boolean measureVoltages = false;

  //if(1 == counter) Serial.println("Balance cells");
  
	writeAllSlaves(0x18, 0x1500, true); // Set WATCHDOG timer to 5s

	if(0 == counter)
	{
		cellToBalanceFilter = 0x0FFF & ~cellToBalanceFilter; // Every other cell
		writeAllSlaves(0x1A, 0x0000, true); // Turn off all cell balancing for one cycle to avoid any switch overlap
	}
	
	if(1 == counter)
	{
		measureVoltages = true; // OK to measure cell voltages
	}
	
	for (int i=0; i < 12; i++) // Go through modules to set cells for balancing
	{
		if(2 == counter) // Only set cells once every counter cycle
		{
			uint16_t cellToBalance = 0x0000;
    
			for (int j=0; j < 8; j++) // Go through cells to set cells for balancing
			{
				uint8_t cellNumber = j+i*8;
			
				if ((cellVoltage[cellNumber] > startShuntVoltage) && ((int16_t)(cellVoltage[cellNumber] - lowestCellVoltage) > voltageAllowance)) // Ok to balance
				{
					if (j < 4)
					{
						cellToBalance |= (0x01 << j);
					}
					else if (j >= 4 && j <8)
					{
						cellToBalance |= (0x01 << (j+1));
					}
					else //Error
					{
						cellToBalance = 0x0000;
					}
				}
			}
		
			cellToBalance &= cellToBalanceFilter; // To avoid enabling adjacent balance switches
			writeAddressedSlave(0x1A, cellToBalance, i, true); // Send request to set cell balance switches
		
			Serial.print(i+1);
			Serial.print(": ");
			//Serial.println(cellToBalance, BIN);
			
			for(int i=0; i < 8; i++)
			{
				if(4 == i) Serial.print(" ");
				
				if(i < 4)
				{
					Serial.print((uint8_t)((cellToBalance >> i) & 0x01));
				}
				else
				{
					Serial.print((uint8_t)((cellToBalance >> (i + 1)) & 0x01));
				}
			}
			Serial.println();
			
		}
		
		if(dieTemperature[i] > 100) // Check die overtemp
		{
			writeAddressedSlave(0x1A, 0x0000, i, true); // Turn off cell balancing for the module with die overtemp
			Serial.print("Die overtemp, module ");
      Serial.println(i+1);
		}
	}
	
	counter++;
	
	if(counter > balanceCellCounterTurnAround)
	{
		counter = 0;
	}
	
	return measureVoltages;
}

Code: Select all

boolean balanceCells(uint16_t lowestCellVoltage)
{
	static uint8_t counter = 1;
	static uint16_t cellToBalanceFilter = 0x00FF & 0x5555; // Every odd cell
	boolean measureVoltages = false;

  //if(1 == counter) Serial.println("Balance cells");
  
	writeAllSlaves(0x18, 0x1500, true); // Set WATCHDOG timer to 5s

	if(0 == counter)
	{
		cellToBalanceFilter = 0x0FFF & ~cellToBalanceFilter; // Every other cell
		writeAllSlaves(0x1A, 0x0000, true); // Turn off all cell balancing for one cycle to avoid any switch overlap
	}
	
	if(1 == counter)
	{
		measureVoltages = true; // OK to measure cell voltages
	}
	
	for (int i=0; i < 8; i++) // Go through modules to set cells for balancing
	{
		if(2 == counter) // Only set cells once every counter cycle
		{
			uint16_t cellToBalance = 0x0000;
    
			for (int j=0; j < 8; j++) // Go through cells to set cells for balancing
			{
				uint8_t cellNumber = j+i*8;
			
				if ((cellVoltage[cellNumber] > startShuntVoltage) && ((int16_t)(cellVoltage[cellNumber] - lowestCellVoltage) > voltageAllowance)) // Ok to balance
				{
					if (j < 8)
					{
						cellToBalance |= (0x01 << j);
					}
					else //Error
					{
						cellToBalance = 0x0000;
					}
				}
			}
		
			cellToBalance &= cellToBalanceFilter; // To avoid enabling adjacent balance switches
			writeAddressedSlave(0x1A, cellToBalance, i, true); // Send request to set cell balance switches
		
			Serial.print(i+1);
			Serial.print(": ");
			//Serial.println(cellToBalance, BIN);
			
			for(int i=0; i < 8; i++)
			{
				Serial.print((uint8_t)((cellToBalance >> i) & 0x01));
			}
			Serial.println();
			
		}
		
		if(dieTemperature[i] > 100) // Check die overtemp
		{
			writeAddressedSlave(0x1A, 0x0000, i, true); // Turn off cell balancing for the module with die overtemp
			Serial.print("Die overtemp, module ");
      Serial.println(i+1);
		}
	}
	
	counter++;
	
	if(counter > balanceCellCounterTurnAround)
	{
		counter = 0;
	}
	
	return measureVoltages;
}

Code: Select all

void readAllSlaves(uint8_t dataRegister, boolean setupDone) // Read all slaves
{
	uint8_t command = 0x03; // READALL
	uint8_t byteList[3] = {command, dataRegister, 0x00};
	uint8_t PEC = calculatePEC(byteList, 3);
	uint8_t readRegisterData[21];
	uint8_t errorByte = 0x00;
	static uint8_t resendCounter = 0;
	//static uint8_t failCounter = 0;
	
	/*if(failCounter >= 4)
	{
		//clearBuffers();
		failCounter = 0; // Reset counter
		Serial.println("Buffers cleared");
	}*/
	
	SPI.beginTransaction(MAX17841);
	
	// Load the READALL command sequence into the load queue
	digitalWrite(SPI_MAX_CS_PIN, LOW);
  SPI.transfer(0xC0); // WR_LD_Q SPI command byte (write the load queue)
  SPI.transfer(0x15); // Message length (5 + 2 x n = 21)
  SPI.transfer(command); // READALL command byte
  SPI.transfer(dataRegister); // Register address
  SPI.transfer(0x00); // Data-check byte (seed value = 0x00)
  SPI.transfer(PEC); // PEC byte
  SPI.transfer(0x00); // Alive-counter byte (seed value = 0x00)
  digitalWrite(SPI_MAX_CS_PIN, HIGH); 
  
  transmitQueue();
	
	// Read the receive buffer
	digitalWrite(SPI_MAX_CS_PIN, LOW);
	SPI.transfer(0x93); // RD_NXT_MSG SPI command byte
	
	for(int i=0; i<21; i++)
  {
		readRegisterData[i] = SPI.transfer(0x93);
	}
	
	errorByte |= receiveBufferError();
	
	SPI.endTransaction();
	
	// Verify that the device register data is received correctly during the READALL sequence
	if(!((readRegisterData[0] == command) && (readRegisterData[1] == dataRegister)))
  {
		errorByte |= mismatchBefore; 
	}
	if(setupDone)
	{
		uint8_t checkPEC = calculatePEC(readRegisterData, 19);
		// Check check-byte, PEC and alive-counter	
		if(!((readRegisterData[18] == 0x00) && (readRegisterData[19] == checkPEC) && (readRegisterData[20] == 0x08)))
		{
			errorByte |= mismatchAfter;
			if(readRegisterData[18] != 0x00)
			{
				readAllSlaves(0x02, false); // Read STATUS of all slaves with checks ignored
				writeAllSlaves(0x02, 0x0000, true); // Clear STATUS register
				Serial.println("STATUS cleared");
			}
		}
	}
	
	/*// Print data received
	for(int i=0; i<21; i++)
  {
		Serial.print(readRegisterData[i], HEX);
		Serial.print(" ");
	}
	Serial.println();*/

	if(errorByte) // Error
	{
    resendCounter++;
    Serial.println(errorByte, HEX);
    errorByte &= 0x00; // Clear errors
    Serial.println("errorByte cleared");
    
    if(resendCounter > 2)
    {
			Serial.println("READALL fail");
			resendCounter = 0;
			//failCounter++;
			return;
		}
    
    delay(1);
    readAllSlaves(dataRegister, setupDone); // Resend READALL
  }
  else // No errors, clear counters and store data received
  {
		resendCounter = 0; // Reset counter
		//failCounter = 0; // Reset counter
		
		if((dataRegister >= 0x20) && (dataRegister <= 0x2B)) // Cell voltage measurements
		{
			storeCellVoltage(dataRegister, readRegisterData);
		}
  
		/*if(dataRegister == 0x2D) // Aux voltage measurements (external temperature sensors)
		{
			storeCellTemperature(readRegisterData);
		}*/
		
		
		if(dataRegister == 0x50) // Die temperature measurements
		{
			storeDieTemperature(readRegisterData);
		}
		
		if(dataRegister == 0x13) // Read SCANCTRL to check if data is ready to be read
		{
			checkDataReady(readRegisterData);
		}
		
		if(dataRegister == 0x02) // Read STATUS and print content
		{
			// Print data received
			for(int i=0; i<21; i++)
			{
				Serial.print(readRegisterData[i], HEX);
				Serial.print(" ");
			}
			Serial.println();
		}
	}  
}

Code: Select all

// Check alive-counter
		if(!(readRegisterData[5] == 0x0))
		{
			errorByte |= mismatchAfter;
		}

Code: Select all

// Check alive-counter
		if(!(readRegisterData[5] == 0x08))
		{
			errorByte |= mismatchAfter;
		}