[参考译文] BQ76952：未稳定 STM32F103 I2C 与 BQ76952之间的通信。

尊敬的 Arjun：

我有几个简短的问题：

1.能否将 PCB 的完整原理图发送出去？

2.对于信号的照片，您是否可以使用数字逻辑分析仪来查看信号，以便我们可以查看发送的内容以及是否接收到 ACK 位。

3.您的设备是否使用 CRC 检查进行传输? 默认情况下、BQ7695202启用了 CRC、如果 MCU 不期望 CRC 出现、它会更改您发送和接收的信号。

此致！

A·内德尔费尔德

感谢您的评分

1.好的，先生，我会附上的。

2、没有 SIR 除了 示波器我没有逻辑分析仪。

3.我不知道 BQ7695202默认启用了 CRC 、在程序中我禁用了相同的功能。 这可能是原因,我会尝试相同 的,并恢复您相同的角度。

#先生,现在我能够读取所有数据,但我不能写入任何东西 BQ7xxx

这是我在 main 函数中做的例子 ,并试图在写入后读取 COV 阈值电压,但它只显示我的默认数据, COV 寄存器没有变化

////////////////////////////////////////////////////////////////////////// COV -THS-73////////////////////////////////////////////////////////

//进入 configupdate 模式-子命令0x0090
TX_2Byte[0]= 0x90；
TX_2Byte[1]= 0x00；
I2C_WriteReg (0x3E、TX_2字节、2)；
第36集7.3分庭(2000年);

//0x9278是地址， 0x55是数据

TX_3Byte[0]= 0x78；
TX_3Byte[1]= 0x92；
TX_3Byte[2]= 0x50；    
I2C_WriteReg (0x3E、TX_3Byte、3)；
DELAYUS(1000);

//表示校验和及长度

TX_2Byte[0]=校验和(TX_3Byte，3)；
TX_2Byte[1]= 0x05；
I2C_WriteReg (0x60、TX_2字节、2)；
READ_COV_TH =(RX_2Byte[1]*256 + RX_2Byte[0])；
DELAYUS(1000);

//退出 configupdate 模式-子命令0x0092
TX_2Byte[0]= 0x92；TX_2Byte[1]= 0x00；
I2C_WriteReg (0x3E、TX_2字节、2)；
DELAYUS(1000);

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////// COV -THS-73////////////////////////////////////////////////////////
TX_2Byte[0]= 0x90；
TX_2Byte[1]= 0x00；
I2C_WriteReg (0x3E、TX_2字节、2)；
第36集7.3分庭(2000年);

// 1. 将地址的低位字节写入0x3E (本例中为0x78)。
// 2. 将地址的高位字节写入0x3F (本例中为0x92)。
// 3. 将数据存储器值以小端字节序的格式写入传输缓冲区(0x40至0x5F)。 注：最多32个
//字节的数据存储器可以写入一次块写入。 在本例中、将0x7A 写入0x40、将0x30写入
// 0x41。
// 4. 将写入数据的校验和(本例中为0x44)写入0x60、并将数据长度(本例中为0x06)写入
//示例)转换到0x61中。

TX_3Byte[0]= 0x78；
TX_3Byte[1]= 0x92；
TX_3Byte[2]= 0x10；
I2C_WriteReg (0x3E、TX_3Byte、3)；
DELAYUS(1000);
TX_2Byte[0]=校验和(TX_3Byte，3)；
TX_2Byte[1]= 0x05；
I2C_WriteReg (0x60、TX_2字节、2)；
DELAYUS(1000);

// 5. 可以通过读回数据来对其进行验证。 将地址的低位字节写入0x3E (0x80)、将高位字节
//地址字节到0x3F (0x91)。
// 6. 从0x61读取响应的长度。 传输缓冲区将填充一个32字节的数据块、因此
//长度将是36个字节，或在本例中为0x24。
// 7. 从0x40开始读取数据长度的缓冲区。 Calibration：Voltage：Cell 1 Gain 的新值为
//在0x40 (0x7A)和0x41 (0x30)中看到。
// 8. 读取0x60处的校验和并验证其是否与为整个传输缓冲区读取的数据匹配

TX_2Byte[0]= 0x00；
TX_2Byte[1]= 0x00；
I2C_ReadReg (0x40、TX_2字节、2)；
CB_ActiveCells =(RX_2Byte[1]*256 + RX_2Byte[0])；
DELAYUS(1000);

//退出 configupdate 模式-子命令0x0092
TX_2Byte[0]= 0x92；TX_2Byte[1]= 0x00；
I2C_WriteReg (0x3E、TX_2字节、2)；
DELAYUS(1000);

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#1 使用作为变量的 CB_ActiveCells

# 2 IIN 评论部分的代码我做了一些更改我的 reff...

您好、先生！

我检查了  已设置为[0,1](  8位和9位)的位 Status()[SEC1, SEC0]， 我仍然无法对 写 操作进行 ASSCESS。  

还有一点我想提的是,正如这里显示的两个代码在 TI 网站上提供相同的(旧的和新的一个)通过新的一个,我不能读任何东西,通过旧的一个, 这个问题也是如此、但有一个优点是、我只能  通过更改后使用相同的函数来 RAED "叠加电压" ONELY (因为它运行良好、所以我使用相同的函数读取其他数据(EG)。 温度，电池1-CELL16)   

我真的不知道发生了什么,我要求请,如果你 给我简单的代码读写操作,然后请指导我的步骤;

谢谢。

此输出结果,当 I DEBUGE 与新(附在下面)代码. 这样、即使我也无法读取 TS1、  

我重新检查每个问题、但没有结果 I OTTED、

#include "main.h"
#include <stdio.h>
#include "BQ769x2Header.h"
/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */

/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */
#define DEV_ADDR  0x10  // BQ769x2 address is 0x10 including R/W bit or 0x8 as 7-bit address
#define CRC_Mode 1  // 0 for disabled, 1 for enabled
#define MAX_BUFFER_SIZE 10
#define R 0 // Read; Used in DirectCommands and Subcommands functions
#define W 1 // Write; Used in DirectCommands and Subcommands functions
#define W2 2 // Write data with two bytes; Used in Subcommands function
/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/
I2C_HandleTypeDef hi2c1;

TIM_HandleTypeDef htim1;

UART_HandleTypeDef huart1;

/* USER CODE BEGIN PV */
uint8_t RX_data [2] = {0x00, 0x00}; // used in several functions to store data read from BQ769x2
uint8_t RX_32Byte [32] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
	//used in Subcommands read function
// Global Variables for cell voltages, temperatures, Stack voltage, PACK Pin voltage, LD Pin voltage, CC2 current
uint16_t CellVoltage [16] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
float Temperature [3] = {0,0,0};
uint16_t Stack_Voltage = 0x00;
uint16_t Pack_Voltage = 0x00;
uint16_t LD_Voltage = 0x00;
uint16_t Pack_Current = 0x00;

uint16_t AlarmBits = 0x00;
uint8_t value_SafetyStatusA;  // Safety Status Register A
uint8_t value_SafetyStatusB;  // Safety Status Register B
uint8_t value_SafetyStatusC;  // Safety Status Register C
uint8_t value_PFStatusA;   // Permanent Fail Status Register A
uint8_t value_PFStatusB;   // Permanent Fail Status Register B
uint8_t value_PFStatusC;   // Permanent Fail Status Register C
uint8_t FET_Status;  // FET Status register contents  - Shows states of FETs
uint16_t CB_ActiveCells;  // Cell Balancing Active Cells

uint8_t	UV_Fault = 0;   // under-voltage fault state
uint8_t	OV_Fault = 0;   // over-voltage fault state
uint8_t	SCD_Fault = 0;  // short-circuit fault state
uint8_t	OCD_Fault = 0;  // over-current fault state
uint8_t ProtectionsTriggered = 0; // Set to 1 if any protection triggers

uint8_t LD_ON = 0;	// Load Detect status bit
uint8_t DSG = 0;   // discharge FET state
uint8_t CHG = 0;   // charge FET state
uint8_t PCHG = 0;  // pre-charge FET state
uint8_t PDSG = 0;  // pre-discharge FET state

uint32_t AccumulatedCharge_Int; // in BQ769x2_READPASSQ func
uint32_t AccumulatedCharge_Frac;// in BQ769x2_READPASSQ func
uint32_t AccumulatedCharge_Time;// in BQ769x2_READPASSQ func
/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_I2C1_Init(void);
static void MX_TIM1_Init(void);
static void MX_USART1_UART_Init(void);
/* USER CODE BEGIN PFP */

/* USER CODE END PFP */


void delayUS(uint32_t us) {   // Sets the delay in microseconds.
	__HAL_TIM_SET_COUNTER(&htim1,0);  // set the counter value a 0
	while (__HAL_TIM_GET_COUNTER(&htim1) < us);  // wait for the counter to reach the us input in the parameter
}

void CopyArray(uint8_t *source, uint8_t *dest, uint8_t count)
{
    uint8_t copyIndex = 0;
    for (copyIndex = 0; copyIndex < count; copyIndex++)
    {
        dest[copyIndex] = source[copyIndex];
    }
}

unsigned char Checksum(unsigned char *ptr, unsigned char len)
// Calculates the checksum when writing to a RAM register. The checksum is the inverse of the sum of the bytes.
{
	unsigned char i;
	unsigned char checksum = 0;

	for(i=0; i<len; i++)
		checksum += ptr[i];

	checksum = 0xff & ~checksum;

	return(checksum);
}

unsigned char CRC8(unsigned char *ptr, unsigned char len)
//Calculates CRC8 for passed bytes. Used in i2c read and write functions
{
	unsigned char i;
	unsigned char crc=0;
	while(len--!=0)
	{
		for(i=0x80; i!=0; i/=2)
		{
			if((crc & 0x80) != 0)
			{
				crc *= 2;
				crc ^= 0x107;
			}
			else
				crc *= 2;

			if((*ptr & i)!=0)
				crc ^= 0x107;
		}
		ptr++;
	}
	return(crc);
}

void I2C_WriteReg(uint8_t reg_addr, uint8_t *reg_data, uint8_t count)
{
	uint8_t TX_Buffer [MAX_BUFFER_SIZE] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
#if CRC_Mode
	{
		uint8_t crc_count = 0;
		crc_count = count * 2;
		uint8_t crc1stByteBuffer [3] = {0x10, reg_addr, reg_data[0]};
		unsigned int j;
		unsigned int i;
		uint8_t temp_crc_buffer [3];

		TX_Buffer[0] = reg_data[0];
		TX_Buffer[1] = CRC8(crc1stByteBuffer,3);

		j = 2;
		for(i=1; i<count; i++)
		{
			TX_Buffer[j] = reg_data[i];
			j = j + 1;
			temp_crc_buffer[0] = reg_data[i];
			TX_Buffer[j] = CRC8(temp_crc_buffer,1);
			j = j + 1;
		}
		HAL_I2C_Mem_Write(&hi2c1, DEV_ADDR, reg_addr, 1, TX_Buffer, crc_count, 1000);
	}
#else
	HAL_I2C_Mem_Write(&hi2c1, DEV_ADDR, reg_addr, 1, reg_data, count, 1000);
#endif
}

int I2C_ReadReg(uint8_t reg_addr, uint8_t *reg_data, uint8_t count)
{
	unsigned int RX_CRC_Fail = 0;  // reset to 0. If in CRC Mode and CRC fails, this will be incremented.
	uint8_t RX_Buffer [MAX_BUFFER_SIZE] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
#if CRC_Mode
	{
		uint8_t crc_count = 0;
		uint8_t ReceiveBuffer [10] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
		crc_count = count * 2;
		unsigned int j;
		unsigned int i;
		unsigned char CRCc = 0;
		uint8_t temp_crc_buffer [3];

		HAL_I2C_Mem_Read(&hi2c1, DEV_ADDR, reg_addr, 1, ReceiveBuffer, crc_count, 1000);
		uint8_t crc1stByteBuffer [4] = {0x10, reg_addr, 0x11, ReceiveBuffer[0]};
		CRCc = CRC8(crc1stByteBuffer,4);
		if (CRCc != ReceiveBuffer[1])
		{
			RX_CRC_Fail += 1;
		}
		RX_Buffer[0] = ReceiveBuffer[0];

		j = 2;
		for (i=1; i<count; i++)
		{
			RX_Buffer[i] = ReceiveBuffer[j];
			temp_crc_buffer[0] = ReceiveBuffer[j];
			j = j + 1;
			CRCc = CRC8(temp_crc_buffer,1);
			if (CRCc != ReceiveBuffer[j])
				RX_CRC_Fail += 1;
			j = j + 1;
		}
		CopyArray(RX_Buffer, reg_data, crc_count);
	}
#else
	HAL_I2C_Mem_Read(&hi2c1, DEV_ADDR, reg_addr, 1, reg_data, count, 1000);
#endif
	return 0;
}

void BQ769x2_SetRegister(uint16_t reg_addr, uint32_t reg_data, uint8_t datalen)
{
	uint8_t TX_Buffer[2] = {0x00, 0x00};
	uint8_t TX_RegData[6] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00};

	//TX_RegData in little endian format
	TX_RegData[0] = reg_addr & 0xff;
	TX_RegData[1] = (reg_addr >> 8) & 0xff;
	TX_RegData[2] = reg_data & 0xff; //1st byte of data

	switch(datalen)
    {
		case 1: //1 byte datalength
      		I2C_WriteReg(0x3E, TX_RegData, 3);
			delayUS(2000);
			TX_Buffer[0] = Checksum(TX_RegData, 3);
			TX_Buffer[1] = 0x05; //combined length of register address and data
      		I2C_WriteReg(0x60, TX_Buffer, 2); // Write the checksum and length
			delayUS(2000);
			break;
		case 2: //2 byte datalength
			TX_RegData[3] = (reg_data >> 8) & 0xff;
			I2C_WriteReg(0x3E, TX_RegData, 4);
			delayUS(2000);
			TX_Buffer[0] = Checksum(TX_RegData, 4);
			TX_Buffer[1] = 0x06; //combined length of register address and data
      		I2C_WriteReg(0x60, TX_Buffer, 2); // Write the checksum and length
			delayUS(2000);
			break;
		case 4: //4 byte datalength, Only used for CCGain and Capacity Gain
			TX_RegData[3] = (reg_data >> 8) & 0xff;
			TX_RegData[4] = (reg_data >> 16) & 0xff;
			TX_RegData[5] = (reg_data >> 24) & 0xff;
			I2C_WriteReg(0x3E, TX_RegData, 6);
			delayUS(2000);
			TX_Buffer[0] = Checksum(TX_RegData, 6);
			TX_Buffer[1] = 0x08; //combined length of register address and data
      		I2C_WriteReg(0x60, TX_Buffer, 2); // Write the checksum and length
			delayUS(2000);
			break;
    }
}

void CommandSubcommands(uint16_t command) //For Command only Subcommands
// See the TRM or the BQ76952 header file for a full list of Command-only subcommands
{	//For DEEPSLEEP/SHUTDOWN subcommand you will need to call this function twice consecutively

	uint8_t TX_Reg[2] = {0x00, 0x00};

	//TX_Reg in little endian format
	TX_Reg[0] = command & 0xff;
	TX_Reg[1] = (command >> 8) & 0xff;

	I2C_WriteReg(0x3E,TX_Reg,2);
	delayUS(2000);
}

void Subcommands(uint16_t command, uint16_t data, uint8_t type)
// See the TRM or the BQ76952 header file for a full list of Subcommands
{
	//security keys and Manu_data writes dont work with this function (reading these commands works)
	//max readback size is 32 bytes i.e. DASTATUS, CUV/COV snapshot
	uint8_t TX_Reg[4] = {0x00, 0x00, 0x00, 0x00};
	uint8_t TX_Buffer[2] = {0x00, 0x00};

	//TX_Reg in little endian format
	TX_Reg[0] = command & 0xff;
	TX_Reg[1] = (command >> 8) & 0xff;

	if (type == R) {//read
		I2C_WriteReg(0x3E,TX_Reg,2);
		delayUS(2000);
		I2C_ReadReg(0x40, RX_32Byte, 32); //RX_32Byte is a global variable
	}
	else if (type == W) {
		//FET_Control, REG12_Control
		TX_Reg[2] = data & 0xff;
		I2C_WriteReg(0x3E,TX_Reg,3);
		delayUS(1000);
		TX_Buffer[0] = Checksum(TX_Reg, 3);
		TX_Buffer[1] = 0x05; //combined length of registers address and data
		I2C_WriteReg(0x60, TX_Buffer, 2);
		delayUS(1000);
	}
	else if (type == W2){ //write data with 2 bytes
		//CB_Active_Cells, CB_SET_LVL
		TX_Reg[2] = data & 0xff;
		TX_Reg[3] = (data >> 8) & 0xff;
		I2C_WriteReg(0x3E,TX_Reg,4);
		delayUS(1000);
		TX_Buffer[0] = Checksum(TX_Reg, 4);
		TX_Buffer[1] = 0x06; //combined length of registers address and data
		I2C_WriteReg(0x60, TX_Buffer, 2);
		delayUS(1000);
	}
}

void DirectCommands(uint8_t command, uint16_t data, uint8_t type)
// See the TRM or the BQ76952 header file for a full list of Direct Commands
{	//type: R = read, W = write
	uint8_t TX_data[2] = {0x00, 0x00};

	//little endian format
	TX_data[0] = data & 0xff;
	TX_data[1] = (data >> 8) & 0xff;

	if (type == R) {//Read
		I2C_ReadReg(command, RX_data, 2); //RX_data is a global variable
		delayUS(2000);
	}
	if (type == W) {//write
    //Control_status, alarm_status, alarm_enable all 2 bytes long
		I2C_WriteReg(command,TX_data,2);
		delayUS(2000);
	}
}

void BQ769x2_Init() {
	// Configures all parameters in device RAM

	// Enter CONFIGUPDATE mode (Subcommand 0x0090) - It is required to be in CONFIG_UPDATE mode to program the device RAM settings
	// See TRM for full description of CONFIG_UPDATE mode
	CommandSubcommands(SET_CFGUPDATE);

	// After entering CONFIG_UPDATE mode, RAM registers can be programmed. When programming RAM, checksum and length must also be
	// programmed for the change to take effect. All of the RAM registers are described in detail in the BQ769x2 TRM.
	// An easier way to find the descriptions is in the BQStudio Data Memory screen. When you move the mouse over the register name,
	// a full description of the register and the bits will pop up on the screen.

	// 'Power Config' - 0x9234 = 0x2D80
	// Setting the DSLP_LDO bit allows the LDOs to remain active when the device goes into Deep Sleep mode
  	// Set wake speed bits to 00 for best performance
	BQ769x2_SetRegister(PowerConfig, 0x2D80, 2);

	// 'REG0 Config' - set REG0_EN bit to enable pre-regulator
	BQ769x2_SetRegister(REG0Config, 0x01, 1);

	// 'REG12 Config' - Enable REG1 with 3.3V output (0x0D for 3.3V, 0x0F for 5V)
	BQ769x2_SetRegister(REG12Config, 0x0D, 1);

	// Set DFETOFF pin to control BOTH CHG and DSG FET - 0x92FB = 0x42 (set to 0x00 to disable)
	BQ769x2_SetRegister(DFETOFFPinConfig, 0x42, 1);

	// Set up ALERT Pin - 0x92FC = 0x2A
	// This configures the ALERT pin to drive high (REG1 voltage) when enabled.
	// The ALERT pin can be used as an interrupt to the MCU when a protection has triggered or new measurements are available
	BQ769x2_SetRegister(ALERTPinConfig, 0x2A, 1);

	// Set TS1 to measure Cell Temperature - 0x92FD = 0x07
	BQ769x2_SetRegister(TS1Config, 0x07, 1);

	// Set TS3 to measure FET Temperature - 0x92FF = 0x0F
	BQ769x2_SetRegister(TS3Config, 0x0F, 1);

	// Set HDQ to measure Cell Temperature - 0x9300 = 0x07
	BQ769x2_SetRegister(HDQPinConfig, 0x00, 1);  // No thermistor installed on EVM HDQ pin, so set to 0x00

	// 'VCell Mode' - Enable 16 cells - 0x9304 = 0x0000; Writing 0x0000 sets the default of 16 cells
	BQ769x2_SetRegister(VCellMode, 0x0000, 2);

	// Enable protections in 'Enabled Protections A' 0x9261 = 0xBC
	// Enables SCD (short-circuit), OCD1 (over-current in discharge), OCC (over-current in charge),
	// COV (over-voltage), CUV (under-voltage)
	BQ769x2_SetRegister(EnabledProtectionsA, 0xBC, 1);

	// Enable all protections in 'Enabled Protections B' 0x9262 = 0xF7
	// Enables OTF (over-temperature FET), OTINT (internal over-temperature), OTD (over-temperature in discharge),
	// OTC (over-temperature in charge), UTINT (internal under-temperature), UTD (under-temperature in discharge), UTC (under-temperature in charge)
	BQ769x2_SetRegister(EnabledProtectionsB, 0xF7, 1);

	// 'Default Alarm Mask' - 0x..82 Enables the FullScan and ADScan bits, default value = 0xF800
	BQ769x2_SetRegister(DefaultAlarmMask, 0xF882, 2);

	// Set up Cell Balancing Configuration - 0x9335 = 0x03   -  Automated balancing while in Relax or Charge modes
	// Also see "Cell Balancing with BQ769x2 Battery Monitors" document on ti.com
	BQ769x2_SetRegister(BalancingConfiguration, 0x03, 1);

	// Set up CUV (under-voltage) Threshold - 0x9275 = 0x31 (2479 mV)
	// CUV Threshold is this value multiplied by 50.6mV
	BQ769x2_SetRegister(CUVThreshold, 0x31, 1);

	// Set up COV (over-voltage) Threshold - 0x9278 = 0x55 (4301 mV)
	// COV Threshold is this value multiplied by 50.6mV
	BQ769x2_SetRegister(COVThreshold, 0x55, 1);

	// Set up OCC (over-current in charge) Threshold - 0x9280 = 0x05 (10 mV = 10A across 1mOhm sense resistor) Units in 2mV
	BQ769x2_SetRegister(OCCThreshold, 0x05, 1);

	// Set up OCD1 Threshold - 0x9282 = 0x0A (20 mV = 20A across 1mOhm sense resistor) units of 2mV
	BQ769x2_SetRegister(OCD1Threshold, 0x0A, 1);

	// Set up SCD Threshold - 0x9286 = 0x05 (100 mV = 100A across 1mOhm sense resistor)  0x05=100mV
	BQ769x2_SetRegister(SCDThreshold, 0x05, 1);

	// Set up SCD Delay - 0x9287 = 0x03 (30 us) Enabled with a delay of (value - 1) * 15 µs; min value of 1
	BQ769x2_SetRegister(SCDDelay, 0x03, 1);

	// Set up SCDL Latch Limit to 1 to set SCD recovery only with load removal 0x9295 = 0x01
	// If this is not set, then SCD will recover based on time (SCD Recovery Time parameter).
	BQ769x2_SetRegister(SCDLLatchLimit, 0x01, 1);

	// Exit CONFIGUPDATE mode  - Subcommand 0x0092
	CommandSubcommands(EXIT_CFGUPDATE);
}

//  ********************************* FET Control Commands  ***************************************

void BQ769x2_BOTHOFF () {
	// Disables all FETs using the DFETOFF (BOTHOFF) pin
	// The DFETOFF pin on the BQ76952EVM should be connected to the MCU board to use this function
//	HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_SET);  // DFETOFF pin (BOTHOFF) set high
}

void BQ769x2_RESET_BOTHOFF () {
	// Resets DFETOFF (BOTHOFF) pin
	// The DFETOFF pin on the BQ76952EVM should be connected to the MCU board to use this function
	//HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_RESET);  // DFETOFF pin (BOTHOFF) set low
}

void BQ769x2_ReadFETStatus() {
	// Read FET Status to see which FETs are enabled
	DirectCommands(FETStatus, 0x00, R);
	FET_Status = (RX_data[1]*256 + RX_data[0]);
	DSG = ((0x4 & RX_data[0])>>2);// discharge FET state
  	CHG = (0x1 & RX_data[0]);// charge FET state
  	PCHG = ((0x2 & RX_data[0])>>1);// pre-charge FET state
  	PDSG = ((0x8 & RX_data[0])>>3);// pre-discharge FET state
}

// ********************************* End of FET Control Commands *********************************

// ********************************* BQ769x2 Power Commands   *****************************************

void BQ769x2_ShutdownPin() {
	// Puts the device into SHUTDOWN mode using the RST_SHUT pin
	// The RST_SHUT pin on the BQ76952EVM should be connected to the MCU board to use this function
	//HAL_GPIO_WritePin(GPIOA, GPIO_PIN_9, GPIO_PIN_SET);  // Sets RST_SHUT pin
}

void BQ769x2_ReleaseShutdownPin() {
	// Releases the RST_SHUT pin
	// The RST_SHUT pin on the BQ76952EVM should be connected to the MCU board to use this function
	//HAL_GPIO_WritePin(GPIOA, GPIO_PIN_9, GPIO_PIN_RESET);  // Resets RST_SHUT pin
}

// ********************************* End of BQ769x2 Power Commands   *****************************************


// ********************************* BQ769x2 Status and Fault Commands   *****************************************



void BQ769x2_ReadSafetyStatus() { //good example functions
	// Read Safety Status A/B/C and find which bits are set
	// This shows which primary protections have been triggered
	DirectCommands(SafetyStatusA, 0x00, R);
	value_SafetyStatusA = (RX_data[1]*256 + RX_data[0]);
	//Example Fault Flags
	UV_Fault = ((0x4 & RX_data[0])>>2);
	OV_Fault = ((0x8 & RX_data[0])>>3);
	SCD_Fault = ((0x8 & RX_data[1])>>3);
	OCD_Fault = ((0x2 & RX_data[1])>>1);
	DirectCommands(SafetyStatusB, 0x00, R);
	value_SafetyStatusB = (RX_data[1]*256 + RX_data[0]);
	DirectCommands(SafetyStatusC, 0x00, R);
	value_SafetyStatusC = (RX_data[1]*256 + RX_data[0]);
	if ((value_SafetyStatusA + value_SafetyStatusB + value_SafetyStatusC) > 1) {
		ProtectionsTriggered = 1; }
	else {
		ProtectionsTriggered = 0; }
}

void BQ769x2_ReadPFStatus() {
	// Read Permanent Fail Status A/B/C and find which bits are set
	// This shows which permanent failures have been triggered
	DirectCommands(PFStatusA, 0x00, R);
	value_PFStatusA = (RX_data[1]*256 + RX_data[0]);
	DirectCommands(PFStatusB, 0x00, R);
	value_PFStatusB = (RX_data[1]*256 + RX_data[0]);
	DirectCommands(PFStatusC, 0x00, R);
	value_PFStatusC = (RX_data[1]*256 + RX_data[0]);
}

// ********************************* End of BQ769x2 Status and Fault Commands   *****************************************


// ********************************* BQ769x2 Measurement Commands   *****************************************


uint16_t BQ769x2_ReadVoltage(uint8_t command)
// This function can be used to read a specific cell voltage or stack / pack / LD voltage
{
	//RX_data is global var
	DirectCommands(command, 0x00, R);
	if(command >= Cell1Voltage && command <= Cell16Voltage) {//Cells 1 through 16 (0x14 to 0x32)
		return (RX_data[1]*256 + RX_data[0]); //voltage is reported in mV
	}
	else {//stack, Pack, LD
		return 10 * (RX_data[1]*256 + RX_data[0]); //voltage is reported in 0.01V units
	}

}
void BQ769x2_ReadAllVoltages()
// Reads all cell voltages, Stack voltage, PACK pin voltage, and LD pin voltage
{
  int cellvoltageholder = Cell1Voltage; //Cell1Voltage is 0x14
  for (int x = 0; x < 16; x++){//Reads all cell voltages
    CellVoltage[x] = BQ769x2_ReadVoltage(cellvoltageholder);
    cellvoltageholder = cellvoltageholder + 2;
  }
  Stack_Voltage = BQ769x2_ReadVoltage(StackVoltage);
  Pack_Voltage = BQ769x2_ReadVoltage(0x36);
  LD_Voltage = BQ769x2_ReadVoltage(LDPinVoltage);
}

uint16_t BQ769x2_ReadCurrent()
// Reads PACK current
{
	DirectCommands(CC2Current, 0x00, R);
	return (RX_data[1]*256 + RX_data[0]);  // current is reported in mA
}

float BQ769x2_ReadTemperature(uint8_t command)
{
	DirectCommands(command, 0x00, R);
	//RX_data is a global var
	return (0.1 * (float)(RX_data[1]*256 + RX_data[0])) - 273.15;  // converts from 0.1K to Celcius
}

void BQ769x2_ReadPassQ(){ // Read Accumulated Charge and Time from DASTATUS6
	Subcommands(DASTATUS6, 0x00, R);
	AccumulatedCharge_Int = ((RX_32Byte[3]<<24) + (RX_32Byte[2]<<16) + (RX_32Byte[1]<<8) + RX_32Byte[0]); //Bytes 0-3
	AccumulatedCharge_Frac = ((RX_32Byte[7]<<24) + (RX_32Byte[6]<<16) + (RX_32Byte[5]<<8) + RX_32Byte[4]); //Bytes 4-7
	AccumulatedCharge_Time = ((RX_32Byte[11]<<24) + (RX_32Byte[10]<<16) + (RX_32Byte[9]<<8) + RX_32Byte[8]); //Bytes 8-11
}

// ********************************* End of BQ769x2 Measurement Commands   *****************************************


/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */

/* USER CODE END 0 */

/**
  * @brief  The application entry point.
  * @retval int
  */
int main(void)
{
  /* USER CODE BEGIN 1 */
    	volatile int i = 0;
		char uart_buf[50];
		int uart_buf_len;
  /* USER CODE END 1 */

  /* MCU Configuration--------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();

  /* USER CODE BEGIN Init */

  /* USER CODE END Init */

  /* Configure the system clock */
  SystemClock_Config();

  /* USER CODE BEGIN SysInit */

  /* USER CODE END SysInit */

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_I2C1_Init();
  MX_TIM1_Init();
  MX_USART1_UART_Init();
  /* USER CODE BEGIN 2 */
  HAL_TIM_Base_Start(&htim1);
  delayUS(10000);

  	CommandSubcommands(BQ769x2_RESET);  // Resets the BQ769x2 registers
  	delayUS(60000);
  	BQ769x2_Init();  // Configure all of the BQ769x2 register settings
  	delayUS(10000);
  	CommandSubcommands(FET_ENABLE); // Enable the CHG and DSG FETs
  	delayUS(10000);
  	 CommandSubcommands(SLEEP_DISABLE); // Sleep mode is enabled by default. For this example, Sleep is disabled to
  									   // demonstrate full-speed measurements in Normal mode.

  	delayUS(60000);
  	delayUS(60000);
  	delayUS(60000);
  	delayUS(60000);  //wait to start measurements after FETs close







  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {

    /* USER CODE END WHILE */



	  Temperature[0] = BQ769x2_ReadTemperature(TS1Temperature);
			uart_buf_len = sprintf(uart_buf, "%f : mV\r\n", Temperature[0]);            //
			HAL_UART_Transmit(&huart1, (uint8_t *)uart_buf, uart_buf_len, 100);      //
		//	delayUS(100000);
		//	AlarmBits =0X01;
		if (AlarmBits & 0x80) {  // Check if FULLSCAN is complete. If set, new measurements are available
    		BQ769x2_ReadAllVoltages();
    		Pack_Current = BQ769x2_ReadCurrent();
    		Temperature[0] = BQ769x2_ReadTemperature(TS1Temperature);
    		Temperature[1] = BQ769x2_ReadTemperature(TS3Temperature);
			DirectCommands(AlarmStatus, 0x0080, W);  // Clear the FULLSCAN bit
		}

		if (AlarmBits & 0xC000) {  // If Safety Status bits are showing in AlarmStatus register
			BQ769x2_ReadSafetyStatus(); // Read the Safety Status registers to find which protections have triggered
			if (ProtectionsTriggered & 1) {
				//HAL_GPIO_WritePin(GPIOA, LD2_Pin, GPIO_PIN_SET); }// Turn on the LED to indicate Protection has triggered
				DirectCommands(AlarmStatus, 0xF800, W); // Clear the Safety Status Alarm bits.
			}
		else
		{
			if (ProtectionsTriggered & 1) {
				BQ769x2_ReadSafetyStatus();
				if (!(ProtectionsTriggered & 1))
				{
					//HAL_GPIO_WritePin(GPIOA, LD2_Pin, GPIO_PIN_RESET);
				}
			} // Turn off the LED if Safety Status has cleared which means the protection condition is no longer present
		}
		delayUS(20000);  // repeat loop every 20 ms
    /* USER CODE BEGIN 3 */
  }
  /* USER CODE END 3 */
}

}
/**
  * @brief System Clock Configuration
  * @retval None
  */
void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

  /** Initializes the RCC Oscillators according to the specified parameters
  * in the RCC_OscInitTypeDef structure.
  */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
  RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }
  /** Initializes the CPU, AHB and APB buses clocks
  */
  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                              |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_HSI;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_0) != HAL_OK)
  {
    Error_Handler();
  }
}

/**
  * @brief I2C1 Initialization Function
  * @param None
  * @retval None
  */
static void MX_I2C1_Init(void)
{

  /* USER CODE BEGIN I2C1_Init 0 */

  /* USER CODE END I2C1_Init 0 */

  /* USER CODE BEGIN I2C1_Init 1 */

  /* USER CODE END I2C1_Init 1 */
  hi2c1.Instance = I2C1;
  hi2c1.Init.ClockSpeed = 400000;
  hi2c1.Init.DutyCycle = I2C_DUTYCYCLE_2;
  hi2c1.Init.OwnAddress1 = 0;
  hi2c1.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;
  hi2c1.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE;
  hi2c1.Init.OwnAddress2 = 0;
  hi2c1.Init.GeneralCallMode = I2C_GENERALCALL_DISABLE;
  hi2c1.Init.NoStretchMode = I2C_NOSTRETCH_ENABLE;
  if (HAL_I2C_Init(&hi2c1) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN I2C1_Init 2 */

  /* USER CODE END I2C1_Init 2 */

}

/**
  * @brief TIM1 Initialization Function
  * @param None
  * @retval None
  */
static void MX_TIM1_Init(void)
{

  /* USER CODE BEGIN TIM1_Init 0 */

  /* USER CODE END TIM1_Init 0 */

  TIM_ClockConfigTypeDef sClockSourceConfig = {0};
  TIM_MasterConfigTypeDef sMasterConfig = {0};

  /* USER CODE BEGIN TIM1_Init 1 */

  /* USER CODE END TIM1_Init 1 */
  htim1.Instance = TIM1;
  htim1.Init.Prescaler = 0;
  htim1.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim1.Init.Period = 65535;
  htim1.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  htim1.Init.RepetitionCounter = 0;
  htim1.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  if (HAL_TIM_Base_Init(&htim1) != HAL_OK)
  {
    Error_Handler();
  }
  sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
  if (HAL_TIM_ConfigClockSource(&htim1, &sClockSourceConfig) != HAL_OK)
  {
    Error_Handler();
  }
  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  if (HAL_TIMEx_MasterConfigSynchronization(&htim1, &sMasterConfig) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN TIM1_Init 2 */

  /* USER CODE END TIM1_Init 2 */

}

/**
  * @brief USART1 Initialization Function
  * @param None
  * @retval None
  */
static void MX_USART1_UART_Init(void)
{

  /* USER CODE BEGIN USART1_Init 0 */

  /* USER CODE END USART1_Init 0 */

  /* USER CODE BEGIN USART1_Init 1 */

  /* USER CODE END USART1_Init 1 */
  huart1.Instance = USART1;
  huart1.Init.BaudRate = 115200;
  huart1.Init.WordLength = UART_WORDLENGTH_8B;
  huart1.Init.StopBits = UART_STOPBITS_1;
  huart1.Init.Parity = UART_PARITY_NONE;
  huart1.Init.Mode = UART_MODE_TX_RX;
  huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  huart1.Init.OverSampling = UART_OVERSAMPLING_16;
  if (HAL_UART_Init(&huart1) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN USART1_Init 2 */

  /* USER CODE END USART1_Init 2 */

}

/**
  * @brief GPIO Initialization Function
  * @param None
  * @retval None
  */
static void MX_GPIO_Init(void)
{
  GPIO_InitTypeDef GPIO_InitStruct = {0};

  /* GPIO Ports Clock Enable */
  __HAL_RCC_GPIOC_CLK_ENABLE();
  __HAL_RCC_GPIOA_CLK_ENABLE();
  __HAL_RCC_GPIOB_CLK_ENABLE();

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13, GPIO_PIN_RESET);

  /*Configure GPIO pin : PC13 */
  GPIO_InitStruct.Pin = GPIO_PIN_13;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);

}

/* USER CODE BEGIN 4 */

/* USER CODE END 4 */

/**
  * @brief  This function is executed in case of error occurrence.
  * @retval None
  */
void Error_Handler(void)
{
  /* USER CODE BEGIN Error_Handler_Debug */
  /* User can add his own implementation to report the HAL error return state */
  __disable_irq();
  while (1)
  {
  }
  /* USER CODE END Error_Handler_Debug */
}

#ifdef  USE_FULL_ASSERT
/**
  * @brief  Reports the name of the source file and the source line number
  *         where the assert_param error has occurred.
  * @param  file: pointer to the source file name
  * @param  line: assert_param error line source number
  * @retval None
  */
void assert_failed(uint8_t *file, uint32_t line)
{
  /* USER CODE BEGIN 6 */
  /* User can add his own implementation to report the file name and line number,
     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  /* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */

/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

尊敬的 Arjun：

可通过此链接找到 BQ769x2系列的所有微控制器示例代码： https://www.ti.com/lit/zip/sluc701。此外、TI 还提供有关如何对 BQ769x2器件系列进行编程的视频、网址为： https://www.ti.com/video/6270522957001。

当您在 TI 的网站上提及这两组代码时、您是在谈论 BQStudio 还是其他内容？ 如果是、值得注意的是 BQStudio 是被设计成与 SMBus 兼容的电路板一起使用的。 您能否共享原理图？

此致！

A·内德尔费尔德

您好，先生，  

没有 SIR 没有看到 BQSTUDIO 在这种情况下,我附上了我的原理图为您的 REF ..  似乎有 接地问题,请让我回答正确,

e2e.ti.com/.../4743.Schematic-_2800_1_2900_.pdf

很抱歉、我附上了错误的原理图。

低于 ACCTUAL 1

e2e.ti.com/.../SS16_5F00_V2.0-14_2D00_06_2D00_2023-_2800_6_2900_.pdf

您好、先生！

我终于读写了新代码,  

除此之外、我还有几个问题  

1) 按照 TEC。 BQXXXX 数据表,我们可以使用100Khz 和400KHZ 的 I2C ,如果我想把 BQ I2C 设置为200Khz 可以吗?

2)正如你刚才所说,在 BQ CRC 是 BYDEFAULT 启用那么,如果我想禁用相同的,我可以做同样的?

3)在代码中,我想读的 CUV 和 COV 数据  ,我坐在这(  BQ769x2_SetRegister(COVThreshold, 0x55, 1 );) 到 VERYFIY 它是设置不是那么我怎么能做同样的?

4) 4) 如何在进行 MICRCONTROLLER 编程后将 BQXXX 器件置于 SEALED 模式？

5)直接命令和子命令和命令-子命令-以及我启用和禁用相同的 CRC ?

感谢你先生的支持,我忠实地得到这些最后的问答.

您好，先生

我想读取数据存储器,以验证写入所有 阈值后,我可以读取它们,我通过以下方式尝试相同的阅读 TEC 数据表 :-

void BQ769x2_52 (Get_Register_)(uint16_t reg_add)
{

uint8_t RX_RegData[6]=｛0x00、0x00、0x00、0x00、0x00、 0x00｝；
uint8_t rx_Byte[32]=｛0x00、0x00｝；

uint8_t 长度；
uint8_t crc_Rx；

//TX_RegData、小端字节序格式
RX_RegData[0]= reg_add 和0xff；
RX_RegData[1]=(reg_add >> 8)和0xff；

I2C_WriteReg (0x3E、RX_RegData、2)；
第36集7.3分庭(2000年);

I2C_ReadReg (0x40、RX_34Byte、34)；
crc_rx = RX_34Byt[32]；
长度= RX_34Byte[33]；

for (int i =0；i<length；i++)
{
RX_34字节[i]= RX_34字节[40+i]；
｝
｝

但没有得到任何输出相同,请让我纠正我的错误,并作出更改。

 谢谢！

尊敬的先生，感谢您的谦虚支持。

只是我想知道一个更多,因为我验证哪一个参数 我能够读取正确或不正确 ,然后我发现,一些参数我能够读取和写入正确,但有些不正确,有什么我不能理解? 或具有相同的任何具体原因？ 请告诉我!  

因为我知道 delay 是两个字节,也有写入_set_Bq_register() 但仍然没有得到实际值,这是我设置的

。

~Arjuna

您好、先生、由于我的上述问题已经解决、

现在,我在同一 IC (BQ7695202 )又面临一个问题,在这一次,我将使用 BQstudio 编程我的 BMS(英语:BQ7695202)。 (我有2个 BMS、电流为40安培、电流为60安培)  

当我对40安培的 BMS 进行短路时、SCD 工作正常。

但是当我 用60安培的 BMS 进行短路时,  然后 BQ76xxx 反复复位(看门狗定时器位变高)并通过执行同样的7-8次、BQ7xx 变为关断模式(如 BQ 技术数据表中所述-由于 RAM 故障发生 )

我们已经验证了所有内容并尝试了可能的解决方案、但无法获得相同的解决方案、

请让您给我同样的解决方案、这对我们来说非常重要。

我已经随附了 BMS 的原理图以及两个(40/60安培)的.gg 文件

e2e.ti.com/.../SLERU16040V0200R1_5F00_DT255.gg-_2800_1_2900_.csv

e2e.ti.com/.../SS16_5F00_V2.0-14_2D00_06_2D00_2023-_2800_8_2900_.pdf

e2e.ti.com/.../SS16_5F00_13022023.gg.csv

这是我们在 SCD 期间得到的结果。

除此之外、我还看到、在短路放电期间、BQ7xx 变得略微变热、并进入内部温度过高故障状态。 在该 BQxx 再次复位之后(WD 位始终变为高电平)。

问题2. 我的最后一个问题是、剂量 BQ76952内核使用卡尔曼滤波器估算准确的 SoC、如果不是、那么我们获得的 SoC 是准确的、我如何理解这个概念、或者如果您有与该概念相关的文档、请分享。

谢谢。此

尊敬的 Arjun：

在查看您的.gg 文件时、我不确定您当前的计算是正确的。 40A 和60A 的相应 SCD 阈值为7和10。 如果您的电流检测电阻器设置为8个并联的电阻器、则得出的总电阻为1.25m Ω。 SCD 阈值为7意味着 SRP 和 SRN 引脚之间总共看到150mV 的电压。 现在如果有电阻、您需要大约120A 来触发 OCD、而不是40A。 同样、10表示 SRP 和 SRN 引脚上的电压为250mV、与触发所需的200A 电流相关。

您能否确认器件在短路事件期间达到200A？ 否则不会触发故障、从而使器件在电池组电压随着短路下降而断电。 如果电量不足、如果内存不再能通电、可能会发生 RAM 故障。

对于第二个问题、该芯片没有内置卡尔曼滤波器来确定 SoC。 不过、该器件可提供确定 SoC 所需的所有电压、电荷和电流。 如果您愿意、可以将 BQ34Z100-G1等堆栈级别测量仪表与 BQ769x2结合使用来提供 SoC 计算。

此致！
A·内德尔费尔德

您好、先生！

抱歉、我忘了提一下这些问题：-

对于60A --> 分流器10毫欧(8个) = REQ = 1.25毫欧

对于40A -->分流器4毫欧(4个) = REQ = 1毫欧

at .gg 文件

对于60A  --> SCD = 10 (250mV) = 200A

对于40A  --> SCD = 7 (150mV) = 150A

还有一点是、在短路放电期间、 由于 I2C 连接丢失1-2秒、BQ76952完全复位并且 REG1电压变为零、然后 BQ7xx 被吸入环路中且看门狗位变为高电平-永远

尊敬的 Arjun：

运行60A SCD 测试时是否会触发 SCD？ 器件在一次短路中不会发热太多、尤其是在室温~30C 的情况下。 您是否曾尝试交换 BQ769x2芯片以查看是否在多个器件上仍然存在相同的问题？

完全复位是清除所有寄存器还是刚刚重新启动硬件？ 一般情况下、如果 SCD 未触发、而器件继续拉高电流、电池组电压下降、芯片可能会停止供电。

我将在早上尝试运行您的.gg 文件、以查看是否可以在 EVM 上看到相同的结果。

此致！
A·内德尔费尔德

您好、先生！

1.是的、SCD 被触发并尝试了不同的 BQ76x2器件、但发生了相同的问题。

2、它只是因为 I2C 连接丢失,我们在相同 OTP 之后所做的更改 也由于 REG1上的电源丢失而被重置  

好,先生,让我知道背后的原因是什么!  

尊敬的 Arjun：

除了检测电阻变化外、该设置的硬件是否有任何变化？ 在 EVM 上测试.gg 文件时、我能够触发 SCD、并关闭 FET。

最好检查的一件事是您的所有 DSG FET 仍处于良好状态。 FET 可能以某种方式损坏并充当短路、因此无论 DSG FET 是否导通、电流均可流动。 如果是这种情况、短路触发 SCD 是软件将无法关闭栅极。 这将导致芯片无法加电、从而导致复位。

同样、您在使用什么进行 SCD 测试？ 通常、最好使用没有电流限制的电池、如电源、以确保可以达到200A。 我注意到您的延迟是~450uA、因此如果您尝试使用电源进行测试、则最好尝试缩短延时时间。 这可能不会修复任何问题、但可以进行测试。

最后一个问题、为什么您在电源路径上的 FET 栅极与源极之间改变电阻？ 典型应用使用10M Ω 电阻器、但您似乎同时使用了1M Ω 和470K 电阻器。

此致！
A·内德尔费尔德