2173 lines
111 KiB
C
2173 lines
111 KiB
C
/**
|
||
******************************************************************************
|
||
* @file BF8915A.c
|
||
* @version V1.1.4
|
||
* @date 2021-12-20
|
||
* @brief This file provides the BF8915A functions(该文件提供BF8915A功能).
|
||
*/
|
||
#include "bsp_bf8915a.h"
|
||
|
||
|
||
Reg_TypeDef configAArray[TOTAL_IC];//定义一个结构体为Reg_TypeDef的数据结构A数组,用于存储指令数据
|
||
uint8_t write_buffer[TOTAL_IC * 0x6U];//寄存器组中有6个8位寄存器
|
||
|
||
Reg_TypeDef configBArray[TOTAL_IC];//定义一个结构体为Reg_TypeDef的数据结构B数组,用于存储指令数据
|
||
Reg_TypeDef configCArray[TOTAL_IC];//定义一个结构体为Reg_TypeDef的数据结构C数组,用于存储指令数据
|
||
Reg_TypeDef configDArray[TOTAL_IC];//定义一个结构体为Reg_TypeDef的数据结构C数组,用于存储指令数据
|
||
///*!
|
||
// \brief SPI1_ReadWriteByte(SPI1读写一个字节)
|
||
// \param[in] SPI_TxData :SPI需要发送的数据
|
||
// \retval SPI_ReceiveData:SPI接收到的数据
|
||
//*/
|
||
//uint8_t SPI1_ReadWriteByte(uint8_t TxData) //TxData 可以是8位或16位的，在启用SPI之前就确定好数据帧格式
|
||
//{
|
||
// u8 retry = 0;
|
||
// while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE) == RESET)//检查是否设置了指定的SPI标志。传输缓冲区空标志 //0:发送缓冲非空 等待发送缓冲器变空
|
||
// {
|
||
// retry++;
|
||
// if(retry>200)return 0;
|
||
// }
|
||
// SPI_I2S_SendData(SPI1, TxData);//通过SPI1发送数据。
|
||
// retry=0;
|
||
// while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET)//等待接收数据完成,检查指定的SPI标志位设置与否:接收缓存非空标志位
|
||
// {
|
||
// retry++;
|
||
// if(retry>200)return 0;
|
||
// }
|
||
// return SPI_I2S_ReceiveData(SPI1); //返回最近接收的数据，SPI_DR寄存器里面的
|
||
//}
|
||
|
||
///*!
|
||
// \brief //SPI2读写字节，此为STM32的SPI代码作为参考，客户需根据自己的主控MCU自行修改
|
||
// \param[in] SPI_TxData :SPI2需要发送的数据
|
||
// \retval SPI_ReceiveData:SPI2接收到的数据
|
||
//*/
|
||
//uint8_t SPI2_ReadWriteByte(uint8_t TxData)
|
||
//{
|
||
// u8 retry=0;
|
||
// while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_TXE) == RESET)//检查指定的SPI标志位设置与否:发送缓存空标志位
|
||
// {
|
||
// retry++;
|
||
// if(retry>200)return 0;
|
||
// }
|
||
// SPI_I2S_SendData(SPI2, TxData);//通过外设SPIx发送一个数据
|
||
// retry=0;
|
||
|
||
// while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_RXNE) == RESET)//检查指定的SPI标志位设置与否:接受缓存非空标志位
|
||
// {
|
||
// retry++;
|
||
// if(retry>200)return 0;
|
||
// }
|
||
// return SPI_I2S_ReceiveData(SPI2);//返回通过SPIx最近接收的数据
|
||
//}
|
||
|
||
BOOLEAN isospi_reverse = FALSE;//改变该变量可以实现菊花链SPI正反向通信。
|
||
//FALSE:相对的正向通信，本SDK中的SPI1为相对正向通信，SPI1菊花链连接的第一颗IC看作是IC0;
|
||
//TURE: 相对的反向通信，本SDK中的SPI2为相对反向通信，但也是SPI1菊花链连接的第一颗IC看作是IC0。
|
||
const uint16_t crc15Table[256] = {0x0000, 0xc599, 0xceab, 0x0b32, 0xd8cf, 0x1d56, 0x1664, 0xd3fd, 0xf407, 0x319e, 0x3aac, 0xff35, 0x2cc8, 0xe951, 0xe263, 0x27fa,
|
||
0xad97, 0x680e, 0x633c, 0xa6a5, 0x7558, 0xb0c1, 0xbbf3, 0x7e6a, 0x5990, 0x9c09, 0x973b, 0x52a2, 0x815f, 0x44c6, 0x4ff4, 0x8a6d,
|
||
0x5b2e, 0x9eb7, 0x9585, 0x501c, 0x83e1, 0x4678, 0x4d4a, 0x88d3, 0xaf29, 0x6ab0, 0x6182, 0xa41b, 0x77e6, 0xb27f, 0xb94d, 0x7cd4,
|
||
0xf6b9, 0x3320, 0x3812, 0xfd8b, 0x2e76, 0xebef, 0xe0dd, 0x2544, 0x02be, 0xc727, 0xcc15, 0x098c, 0xda71, 0x1fe8, 0x14da, 0xd143,
|
||
0xf3c5, 0x365c, 0x3d6e, 0xf8f7, 0x2b0a, 0xee93, 0xe5a1, 0x2038, 0x07c2, 0xc25b, 0xc969, 0x0cf0, 0xdf0d, 0x1a94, 0x11a6, 0xd43f,
|
||
0x5e52, 0x9bcb, 0x90f9, 0x5560, 0x869d, 0x4304, 0x4836, 0x8daf, 0xaa55, 0x6fcc, 0x64fe, 0xa167, 0x729a, 0xb703, 0xbc31, 0x79a8,
|
||
0xa8eb, 0x6d72, 0x6640, 0xa3d9, 0x7024, 0xb5bd, 0xbe8f, 0x7b16, 0x5cec, 0x9975, 0x9247, 0x57de, 0x8423, 0x41ba, 0x4a88, 0x8f11,
|
||
0x057c, 0xc0e5, 0xcbd7, 0x0e4e, 0xddb3, 0x182a, 0x1318, 0xd681, 0xf17b, 0x34e2, 0x3fd0, 0xfa49, 0x29b4, 0xec2d, 0xe71f, 0x2286,
|
||
0xa213, 0x678a, 0x6cb8, 0xa921, 0x7adc, 0xbf45, 0xb477, 0x71ee, 0x5614, 0x938d, 0x98bf, 0x5d26, 0x8edb, 0x4b42, 0x4070, 0x85e9,
|
||
0x0f84, 0xca1d, 0xc12f, 0x04b6, 0xd74b, 0x12d2, 0x19e0, 0xdc79, 0xfb83, 0x3e1a, 0x3528, 0xf0b1, 0x234c, 0xe6d5, 0xede7, 0x287e,
|
||
0xf93d, 0x3ca4, 0x3796, 0xf20f, 0x21f2, 0xe46b, 0xef59, 0x2ac0, 0x0d3a, 0xc8a3, 0xc391, 0x0608, 0xd5f5, 0x106c, 0x1b5e, 0xdec7,
|
||
0x54aa, 0x9133, 0x9a01, 0x5f98, 0x8c65, 0x49fc, 0x42ce, 0x8757, 0xa0ad, 0x6534, 0x6e06, 0xab9f, 0x7862, 0xbdfb, 0xb6c9, 0x7350,
|
||
0x51d6, 0x944f, 0x9f7d, 0x5ae4, 0x8919, 0x4c80, 0x47b2, 0x822b, 0xa5d1, 0x6048, 0x6b7a, 0xaee3, 0x7d1e, 0xb887, 0xb3b5, 0x762c,
|
||
0xfc41, 0x39d8, 0x32ea, 0xf773, 0x248e, 0xe117, 0xea25, 0x2fbc, 0x0846, 0xcddf, 0xc6ed, 0x0374, 0xd089, 0x1510, 0x1e22, 0xdbbb,
|
||
0x0af8, 0xcf61, 0xc453, 0x01ca, 0xd237, 0x17ae, 0x1c9c, 0xd905, 0xfeff, 0x3b66, 0x3054, 0xf5cd, 0x2630, 0xe3a9, 0xe89b, 0x2d02,
|
||
0xa76f, 0x62f6, 0x69c4, 0xac5d, 0x7fa0, 0xba39, 0xb10b, 0x7492, 0x5368, 0x96f1, 0x9dc3, 0x585a, 0x8ba7, 0x4e3e, 0x450c, 0x8095
|
||
};//precomputed CRC15 Table(预计算15位循环冗余校验值的表)
|
||
|
||
/*!
|
||
\brief Wake isoSPI up from idle state(将菊花链SPI从空闲状态唤醒)
|
||
\param[in] total_ic: number of ICs in the daisy chain(菊花链中IC(8915A)的数量)
|
||
\retval none
|
||
*/
|
||
void wakeup_idle(uint8_t total_ic)
|
||
{
|
||
int i =0;
|
||
for (i =0; i<total_ic; i++)
|
||
{
|
||
if (isospi_reverse == FALSE)//判断选择的菊花链通信方向是相对正向还是相对反向
|
||
{
|
||
cs_low();//将相对正向通信的片选CS设置为低电平
|
||
SPI1_ReadWriteByte(0xff);//Guarantees the isoSPI will be in ready mode(保证菊花链SPI将处于就绪模式)
|
||
cs_high();//将相对正向通信的片选CS设置为高电平
|
||
}
|
||
else
|
||
{
|
||
cs_low_reverse();//将相对反向通信的片选CS设置为低电平
|
||
SPI2_ReadWriteByte(0xff);//Guarantees the isoSPI will be in ready mode(保证菊花链SPI将处于就绪模式)
|
||
cs_high_reverse();//将相对反向通信的片选CS设置为高电平
|
||
}
|
||
}
|
||
}
|
||
|
||
/*!
|
||
\brief Generic wakeup command to wake the BF8915A from sleep(将BF8915A从睡眠中唤醒的通用唤醒命令)
|
||
\param[in] total_ic: the number of ic(串接的IC(8915A)数量)
|
||
\retval none
|
||
*/
|
||
void wakeup_sleep(uint8_t total_ic)
|
||
{
|
||
int i =0;
|
||
for (i =0; i<total_ic; i++)//此循环作用为:让所有IC(8915A)芯片处于待机状态
|
||
{
|
||
if (isospi_reverse == FALSE)//判断选择的菊花链通信方向是相对正向还是相对反向
|
||
{
|
||
cs_low();//将相对正向通信的片选CS设置为低电平
|
||
delay_us(300); // Guarantees the BF8915A will be in standby(保证BF8915A处于待机状态),该延迟应在200~300us之间
|
||
cs_high();//将相对正向通信的片选CS设置为高电平
|
||
delay_us(10);
|
||
}
|
||
else
|
||
{
|
||
cs_low_reverse();//将相对反向通信的片选CS设置为低电平
|
||
delay_us(300); // Guarantees the BF8915A will be in standby(保证BF8915A处于待机状态),该延迟应在200~300us之间
|
||
cs_high_reverse();//将相对反向通信的片选CS设置为高电平
|
||
delay_us(10);
|
||
}
|
||
}
|
||
}
|
||
|
||
/*!
|
||
\brief Writes an array of bytes out of the SPI port(将字节数组写入SPI端口)
|
||
\param[in] len :Number of bytes to be written on the SPI port(SPI端口上要写入的字节数)
|
||
\param[in] writeData:Array of bytes to be written on the SPI port(要写入SPI端口的字节数组)
|
||
\retval none
|
||
*/
|
||
void spi_write_array(uint8_t len, uint8_t writeData[] )
|
||
{
|
||
uint8_t i = 0;
|
||
for (i = 0; i < len; i++)//此循环将writeData[] 数组所存的数据一一发送出去
|
||
{
|
||
if (isospi_reverse == FALSE)//判断选择的菊花链通信方向是相对正向还是相对反向
|
||
{
|
||
|
||
SPI1_ReadWriteByte((int8_t)writeData[i]);
|
||
|
||
}
|
||
else
|
||
{
|
||
SPI2_ReadWriteByte((int8_t)writeData[i]);
|
||
}
|
||
}
|
||
}
|
||
|
||
/*!
|
||
\brief Writes and read a set number of bytes using the SPI port(使用SPI端口写入和读取设定数量的字节)
|
||
\param[in] tx_Data: array of data to be written on SPI port(要写入SPI端口的数据数组)
|
||
\param[in] tx_len : length of the tx_data arr(tx_data数组的长度)
|
||
\param[in] rx_data: Input: array that will store the data read by the SPI port(输入:存储SPI端口读取的数据的数组)
|
||
\param[in] rx_len : Option: number of bytes to be read from the SPI port(选项:从SPI端口要读取的字节数)
|
||
\retval none
|
||
*/
|
||
void spi_write_read(uint8_t tx_Data[],//array of data to be written on SPI port
|
||
uint8_t tx_len, //length of the tx data arr
|
||
uint8_t *rx_data,//Input: array that will store the data read by the SPI port
|
||
uint8_t rx_len //Option: number of bytes to be read from the SPI port
|
||
)
|
||
{
|
||
uint8_t i = 0;
|
||
for (i = 0; i < tx_len; i++)//此循环将tx_Data[] 数组所存的数据一一发送出去
|
||
{
|
||
if (isospi_reverse == FALSE)//判断选择的菊花链通信方向是相对正向还是相对反向
|
||
{
|
||
SPI1_ReadWriteByte(tx_Data[i]);
|
||
}
|
||
else
|
||
{
|
||
SPI2_ReadWriteByte(tx_Data[i]);
|
||
}
|
||
}
|
||
|
||
for (i = 0; i < rx_len; i++)//此循环将读到的数据一一存入rx_data[] 数组中
|
||
{
|
||
if (isospi_reverse == FALSE)//判断选择的菊花链通信方向是相对正向还是相对反向
|
||
{
|
||
rx_data[i] = (uint8_t)SPI1_ReadWriteByte(0x00);
|
||
}
|
||
else
|
||
{
|
||
rx_data[i] = (uint8_t)SPI2_ReadWriteByte(0xFF);
|
||
}
|
||
}
|
||
}
|
||
|
||
/*!
|
||
\brief Generic function to write BF8915A commands. Function calculated PEC(The Packet Error Code) for tx_cmd data(编写BF8915A命令的通用函数??数为tx_cmd数据计算了检错码)
|
||
\param[in] tx_cmd: 2 Byte array containing the BMS command to be sent(包含要发送的BMS(电池管理系统)命令的2字节数组)
|
||
\retval none
|
||
*/
|
||
void BF8915A_cmd(uint8_t tx_cmd[2])
|
||
{
|
||
uint8_t cmd[4];//需要发送的4字节数组
|
||
uint16_t cmd_pec;//计算出发送指令的PEC(检错码)
|
||
cmd[0] = tx_cmd[0];//发送指令的高8位
|
||
cmd[1] = tx_cmd[1];//发送指令的低8位
|
||
cmd_pec = pec15_calc(2, cmd);//计算出发送指令的PEC(检错码)
|
||
cmd[2] = (uint8_t)(cmd_pec >> 8);//发送指令的PEC(检错码)的高八位
|
||
cmd[3] = (uint8_t)(cmd_pec);//发送指令的PEC(检错码)的低八位
|
||
|
||
if (isospi_reverse == FALSE)//判断选择的菊花链通信方向是相对正向还是相对反向
|
||
{
|
||
cs_low();//将片选CS设置为低电平
|
||
spi_write_array(4,cmd);//将4字节数组写入SPI端口
|
||
cs_high();//将片选CS设置为高电平
|
||
}
|
||
else
|
||
{
|
||
cs_low_reverse();//将片选CS设置为低电平
|
||
spi_write_array(4,cmd);//将4字节数组写入SPI端口
|
||
cs_high_reverse();//将片选CS设置为高电平
|
||
}
|
||
}
|
||
|
||
/*!
|
||
\brief Generic function to write BF8915A commands and write payload data. Function calculated PEC for tx_cmd data(写BF8915A命令和写有效载荷数据的通用函数。tx_cmd数据的函数计算检错码)
|
||
\param[in] total_ic : the number of ic(IC(8915A)的数量)
|
||
\param[in] tx_cmd : 2 Byte array containing the BMS command to be sent(包含要发送的BMS(电池管理系统)命令的2字节数组)
|
||
\param[in] write_data: Array containing the data to be written to the BMS ICs(包含要写入BMS(电池管理系统)IC(8915A)的数据数组)
|
||
\retval none
|
||
*/
|
||
void BF8915A_write(uint8_t total_ic ,
|
||
uint8_t tx_cmd[2],
|
||
uint8_t write_data[]
|
||
)
|
||
{
|
||
const uint8_t BYTES_IN_REG = 6;//寄存器组中的6个8位寄存器
|
||
const uint8_t CMD_LEN = 4+(8*total_ic);//4:cmd[0]~cmd[3];(8*total_ic):寄存器组中的6个8位寄存器 + 2个8位PEC(检错码)
|
||
uint8_t *cmd;//需要发送的cmd数组
|
||
uint16_t data_pec;//计算配置寄存器数据的PEC(检错码)
|
||
uint16_t cmd_pec;//计算出发送指令的PEC(检错码)
|
||
uint8_t cmd_index;//用于写指令中 寄存器组中的数据
|
||
uint8_t current_ic = total_ic;// current_ic is used as the IC counter(当前IC(8915A)用作IC(8915A)计数器)
|
||
uint8_t current_byte = 0;//当前需写入的寄存器组 的字节数
|
||
cmd = (uint8_t *)malloc(CMD_LEN*sizeof(uint8_t));//计算cmd数组发送数据所需的数组长度
|
||
cmd[0] = tx_cmd[0];//发送指令的高8位
|
||
cmd[1] = tx_cmd[1];//发送指令的低8位
|
||
cmd_pec = pec15_calc(2, cmd);//计算出发送指令的PEC(检错码)
|
||
cmd[2] = (uint8_t)(cmd_pec >> 8);//发送指令的PEC(检错码)的高八位
|
||
cmd[3] = (uint8_t)(cmd_pec);//发送指令的PEC(检错码)的低八位
|
||
cmd_index = 4;//从4开始写入寄存器组中的数据
|
||
for (current_ic = total_ic; current_ic > 0; current_ic--) // executes for each BF8915A, this loops starts with the last IC on the stack(对每个BF8915A执行，这个循环从堆栈上的最后一个8915A开始)
|
||
{ //The first configuration written is received by the last IC in the daisy chain(菊花链中的最后一个IC(8915A)接收写入的第一个配置)
|
||
|
||
for (current_byte = 0; current_byte < BYTES_IN_REG; current_byte++)//该循环将寄存器组中的6个8位寄存器的数据一一写入数组cmd[]中
|
||
{
|
||
cmd[cmd_index] = write_data[((current_ic-1)*BYTES_IN_REG)+current_byte];
|
||
cmd_index = cmd_index + 1;
|
||
}
|
||
data_pec = (uint16_t)pec15_calc(BYTES_IN_REG, &write_data[(current_ic-1)*BYTES_IN_REG]);// calculating the PEC for each configuration register data(计算每个配置寄存器数据的PEC(检错码))
|
||
cmd[cmd_index] = (uint8_t)(data_pec >> 8);//配置寄存器数据的PEC(检错码)的高八位
|
||
cmd[cmd_index + 1] = (uint8_t)data_pec;//配置寄存器数据的PEC(检错码)的低八位
|
||
cmd_index = cmd_index + 2;//由于数组每个寄存器组写入后，每个IC的尾端需加2字节的PEC(检错码)，因此cmd_index需每次都自增2
|
||
}
|
||
if (isospi_reverse == FALSE)//判断选择的菊花链通信方向是相对正向还是相对反向
|
||
{
|
||
cs_low();//将片选CS设置为低电平
|
||
spi_write_array(CMD_LEN, cmd);//将字节数组写入SPI端口
|
||
cs_high();//将片选CS设置为高电平
|
||
}
|
||
else
|
||
{
|
||
cs_low_reverse();//将片选CS设置为低电平
|
||
spi_write_array(CMD_LEN, cmd);//将字节数组写入SPI端口
|
||
cs_high_reverse();//将片选CS设置为高电平
|
||
}
|
||
free(cmd);//清空cmd数组
|
||
}
|
||
|
||
/*!
|
||
\brief Generic function to write BF8915A commands and read data(写BF8915A命令和读数据的通用函数). Function calculated PEC for tx_cmd data(发送指令数据的函数计算PEC(检错码))
|
||
Issues a command onto the daisy chain and reads back 6*total_ic data in the rx_data array(向菊花链发出命令，回读rx_data数组中的6倍IC(8915A)数据)
|
||
\param[in] total_ic : the number of ic(IC(8915A)的数量)
|
||
\param[in] tx_cmd : 2 Byte array containing the BMS command to be sent(包含要发送的BMS(电池管理系统)命令的2字节数组)
|
||
\param[in] rx_data : Array that the read back data will be stored(存储回读数据的数组)
|
||
\retval pec_error: 0: Data read back has matching PEC;1: Data read back has incorrect PEC(0:数据读回具有匹配的检错码 1:数据读回有不正确的检错码)
|
||
*/
|
||
uint8_t BF8915A_read(uint8_t total_ic ,
|
||
uint8_t tx_cmd[2],
|
||
uint8_t *rx_data)
|
||
{
|
||
const uint8_t BYTES_IN_REG = 8;//寄存器组中的6个8位寄存器 + 2个8位PEC(检错码)
|
||
uint8_t cmd[4];//需要发送的cmd数组
|
||
uint8_t rxDataTemp[256];//存储SPI端口读取的数据 的数组
|
||
uint8_t pec_error = 0;//检查检错码
|
||
uint16_t cmd_pec;//计算出发送指令的PEC(检错码)
|
||
uint16_t data_pec;//计算配置寄存器数据的PEC(检错码)
|
||
uint16_t received_pec;//存入接收到的PEC(检错码)
|
||
uint8_t current_ic = 0;//current_ic is used as the IC counter(当前IC(8915A)用作IC(8915A)计数器)
|
||
uint8_t current_byte = 0;//当前需读入的寄存器组
|
||
cmd[0] = tx_cmd[0];//发送指令的高8位
|
||
cmd[1] = tx_cmd[1];//发送指令的低8位
|
||
cmd_pec = pec15_calc(2, cmd);//计算出发送指令的PEC(检错码)
|
||
cmd[2] = (uint8_t)(cmd_pec >> 8);//发送指令的PEC(检错码)的高八位
|
||
cmd[3] = (uint8_t)(cmd_pec);//发送指令的PEC(检错码)的低八位
|
||
|
||
|
||
if (isospi_reverse == FALSE)//判断选择的菊花链通信方向是相对正向还是相对反向
|
||
{
|
||
cs_low();//将片选CS设置为低电平
|
||
spi_write_read(cmd, 4, rxDataTemp, (total_ic*BYTES_IN_REG));//Read the configuration data of all ICs on the daisy chain into rx_data[] array
|
||
cs_high();//将片选CS设置为高电平 //(将菊花链上所有IC(8915A)的配置数据读入rx_data[]数组)
|
||
}
|
||
else
|
||
{
|
||
cs_low_reverse();//将片选CS设置为低电平
|
||
spi_write_read(cmd, 4, rxDataTemp, (total_ic*BYTES_IN_REG));//Read the configuration data of all ICs on the daisy chain into rx_data[] array
|
||
cs_high_reverse();//将片选CS设置为高电平 //(将菊花链上所有IC(8915A)的配置数据读入rx_data[]数组)
|
||
}
|
||
|
||
for (current_ic = 0; current_ic < total_ic; current_ic++) //executes for each BF8915A in the daisy chain and packs the data(对菊花链中的每个BF8915A执行并打包数据)
|
||
//into the r_comm array as well as check the received data for any bit errors(并检查接收到的数据是否有任何位错误)
|
||
{
|
||
for (current_byte = 0; current_byte < BYTES_IN_REG; current_byte++)//该循环将读回的寄存器组(6个8位寄存器)数据一一写入数组rx_data[]中
|
||
{
|
||
rx_data[(current_ic*BYTES_IN_REG)+current_byte] = rxDataTemp[(current_ic*BYTES_IN_REG)+current_byte];
|
||
}
|
||
received_pec = (rx_data[(current_ic*BYTES_IN_REG)+6]<<8) + rx_data[(current_ic*BYTES_IN_REG)+7];//将rx_data[]中接收到的PEC(检错码)按高低共16位存入received_pec中
|
||
|
||
data_pec = pec15_calc(6, &rx_data[current_ic*BYTES_IN_REG]);//计算接收回来的寄存器组(6个8位寄存器)中的PEC(检错码)
|
||
if (received_pec != data_pec)//检查检错码是否匹配
|
||
{
|
||
pec_error = 1;//检错码不正确
|
||
}
|
||
}
|
||
return(pec_error);
|
||
}
|
||
|
||
/*!
|
||
\brief Calculates and returns the CRC15(计算并返回15位循环冗余校验值)
|
||
\param[in] len : Number of bytes that will be used to calculate a PEC(将用于计算PEC(检错码)的字节数)
|
||
\param[in] pecData: Array of data that will be used to calculate a PEC(将用于计算PEC(检错码)的数据数组)
|
||
\retval The calculated pec15 as an unsigned int(计算出无符号整数的15位检错码)
|
||
*/
|
||
uint16_t pec15_calc(uint8_t len,
|
||
uint8_t *pecData
|
||
)
|
||
{
|
||
uint16_t remainder,addr;
|
||
uint8_t i = 0;
|
||
remainder = 16;//initialize the PEC(初始化检错码)
|
||
for (i = 0; i<len; i++) // loops for each byte in data array(数据数组中每个字节的循环)
|
||
{
|
||
addr = ((remainder>>7)^pecData[i])&0xff;//calculate PEC table address(计算检错码的表地址)
|
||
remainder = (remainder<<8)^crc15Table[addr];
|
||
}
|
||
return(remainder*2);//The CRC15 has a 0 in the LSB so the remainder must be multiplied by 2(15位循环冗余校验值的最低有效位为0，因此余数必须乘以2)
|
||
}
|
||
|
||
/*!
|
||
\brief Helper function to set GPIO bits(设置GPIO位的辅助函数)
|
||
\param[in] nIC : Number of ICs in the system(系统中IC(8915A)的数量)
|
||
\param[in] configAReg: Register group A(寄存器组A)
|
||
\param[in] gpio_pd_en: 0: GPIO pin pull-down enable; 1: GPIO pin pull-down disable (default)(0:GPIO引脚下拉使能；1:GPIO引脚下拉禁用(默认))
|
||
\retval none
|
||
*/
|
||
void BF8915A_set_cfga_gpio(uint8_t nIC, Reg_TypeDef *configAReg,uint8_t gpio_pd_en)
|
||
{
|
||
configAReg[nIC].tx_data[0] = gpio_pd_en;//设置CFGAR0,0:GPIO引脚下拉使能；1:GPIO引脚下拉禁用
|
||
}
|
||
|
||
/*!
|
||
\brief Helper function to set GPIO IO_MODE(设置GPIO的IO口模式的辅助函数)
|
||
\param[in] nIC : Number of ICs in the system(系统中IC(8915A)的数量)
|
||
\param[in] configAReg : Register group A(寄存器组A)
|
||
\param[in] gpio_analog_en: 0: analog input;1: Ordinary GPIO(0:模拟输入；1:普通GPIO)
|
||
\retval none
|
||
*/
|
||
void BF8915A_set_cfga_gpio_mode(uint8_t nIC, Reg_TypeDef *configAReg,uint8_t gpio_analog_en)
|
||
{
|
||
configAReg[nIC].tx_data[1] = gpio_analog_en;//设置CFGAR1,0:模拟输入；1:普通GPIO
|
||
}
|
||
|
||
void BF8915A_set_cfga_adc_init_mode(uint8_t nIC, Reg_TypeDef *configAReg,bool adc_init_mode)
|
||
{
|
||
if (adc_init_mode)
|
||
configAReg[nIC].tx_data[2] = configAReg[nIC].tx_data[2]|(0x01<<4);
|
||
else
|
||
configAReg[nIC].tx_data[2] = configAReg[nIC].tx_data[2]&(~(0x01 <<4));
|
||
}
|
||
|
||
/*!
|
||
\brief 保留位，永远置0
|
||
\retval none
|
||
*/
|
||
void BF8915A_set_cfga_rsvd(uint8_t nIC, Reg_TypeDef *configAReg,BOOLEAN rsvd2,BOOLEAN rsvd1)
|
||
{
|
||
configAReg[nIC].tx_data[2] = configAReg[nIC].tx_data[2]&(~(0x01<<3));//保留位，永远置0
|
||
configAReg[nIC].tx_data[2] = configAReg[nIC].tx_data[2]&(~(0x01<<2));//保留位，永远置0
|
||
}
|
||
|
||
/*!
|
||
\brief Helper function to set osr_sel(设置ADC过采样率选择的辅助函数)
|
||
\param[in] nIC : Number of ICs in the system(系统中IC(8915A)的数量)
|
||
\param[in] configAReg: Register group A(寄存器组A)
|
||
\param[in] osr_sel : OSR_64 、OSR_128、OSR_256、OSR_512(ADC过采样频率选择)
|
||
\retval none
|
||
*/
|
||
void BF8915A_set_cfga_osr_sel(uint8_t nIC, Reg_TypeDef *configAReg,BOOLEAN osr_sel)
|
||
{
|
||
configAReg[nIC].tx_data[2] = configAReg[nIC].tx_data[2]&(~(0x01<<1));//写0,过采样率选择64，128，256，512(四种过采样率通过指令的OSR选择)
|
||
}
|
||
|
||
/*!
|
||
\brief Helper function to set refon(设置基准电压配置的辅助函数)
|
||
\param[in] nIC : Number of ICs in the system(系统中IC(8915A)的数量)
|
||
\param[in] configAReg: Register group A(寄存器组A)
|
||
\param[in] refon : 1: VREF1 remains powered on until WDT overflowsVREF1
|
||
0: VREF1 is turned off after ADC conversion
|
||
(1:VREF1(基准电压)保持上电直到WDT溢出
|
||
0:ADC转换完之后VREF1关闭 (默认))
|
||
\retval none
|
||
*/
|
||
void BF8915A_set_cfga_refon(uint8_t nIC, Reg_TypeDef *configAReg,BOOLEAN refon)
|
||
{
|
||
if (refon)//设置CFGAR2的第1位
|
||
configAReg[nIC].tx_data[2] = configAReg[nIC].tx_data[2]|(0x01);//写1,VREF1(基准电压)保持上电直到WDT溢出
|
||
else
|
||
configAReg[nIC].tx_data[2] = configAReg[nIC].tx_data[2]&(~(0x01));//写0,ADC转换完之后VREF1关闭
|
||
}
|
||
|
||
/*!
|
||
\brief Helper Function to set uv value in CFG register(在配置寄存器组的寄存器中设置欠压阈值的辅助函数)
|
||
\param[in] nIC : Number of ICs in the system(系统中IC(8915A)的数量)
|
||
\param[in] configAReg: Register group A(寄存器组A)
|
||
\param[in] uv : Low 8 bits of undervoltage threshold(低8位欠压阈值)
|
||
\retval none
|
||
*/
|
||
void BF8915A_set_cfga_uv(uint8_t nIC, Reg_TypeDef *configAReg,uint16_t uv)
|
||
{
|
||
configAReg[nIC].tx_data[3] = 0x00FF & uv;//设置CFGAR3,欠压阈值低8位放入
|
||
configAReg[nIC].tx_data[4] = configAReg[nIC].tx_data[4]&0xF0;//将CFGAR4低4位清空
|
||
configAReg[nIC].tx_data[4] = configAReg[nIC].tx_data[4]|((0x0F00 & uv)>>8);//设置CFGAR4低4位，欠压阈值高4位放入
|
||
}
|
||
|
||
/*!
|
||
\brief helper function to set OV value in CFG register(在配置寄存器组的寄存器中设置过压阈值的辅助函数)
|
||
\param[in] nIC : Number of ICs in the system(系统中IC(8915A)的数量)
|
||
\param[in] configAReg: Register group A(寄存器组A)
|
||
\param[in] ov : Overvoltage threshold lower 4 bits(过压阈值低4位)
|
||
\retval none
|
||
*/
|
||
void BF8915A_set_cfga_ov(uint8_t nIC, Reg_TypeDef *configAReg,uint16_t ov)
|
||
{
|
||
configAReg[nIC].tx_data[5] = 0x00FF & (ov>>4);//设置CFGAR5,过压阈值高8位放入
|
||
configAReg[nIC].tx_data[4] = configAReg[nIC].tx_data[4]&0x0F;//将CFGAR4高4位清空
|
||
configAReg[nIC].tx_data[4] = configAReg[nIC].tx_data[4]|((0x000F & ov)<<4);//设置CFGAR4高4位，过压阈值低4位放入
|
||
//保存CFGAR4低4位，即欠压阈值高4位
|
||
}
|
||
/*!
|
||
\brief Helper function to set CFGRA variable(设置配置寄存器组A变量的辅助函数)
|
||
\param[in] nIC : Number of ICs in the system(系统中IC(8915A)的数量)
|
||
\param[in] configAReg : Register group A(寄存器组A)
|
||
\param[in] gpio_pd_en : GPIO pin pull-down enable; 1: GPIO pin pull-down disable (default)(0:GPIO引脚下拉使能；1:GPIO引脚下拉禁用(默认))
|
||
\param[in] gpio_analog_en: 0: analog input 1: Ordinary GPIO(0:模拟输入；1:普通GPIO)
|
||
\param[in] rsvd2 : 保留位，永远置0
|
||
\param[in] rsvd1 : 保留位，永远置0
|
||
\param[in] osr_sel : OSR_64 、OSR_128、OSR_256、OSR_512(ADC过采样频率选择)
|
||
\param[in] refon : 1: VREF1 remains powered on until WDT overflowsVREF1
|
||
0: VREF1 is turned off after ADC conversion
|
||
(1:VREF1(基准电压)保持上电直到WDT溢出
|
||
0:ADC转换完之后VREF1关闭 (默认))
|
||
\param[in] uv_th : Low 8 bits of undervoltage threshold(低8位欠压阈值)
|
||
\param[in] ov_th : Overvoltage threshold lower 4 bits(过压阈值低4位)
|
||
\retval none
|
||
*/
|
||
void BF8915A_set_cfgra(uint8_t nIC,
|
||
Reg_TypeDef *configAReg,
|
||
uint8_t gpio_pd_en,//写0:GPIO脚下拉使能；1:GPIO脚下拉关闭(默认)读0 :GPIO脚的值是0 ；1:GPIO脚的值是1
|
||
uint8_t gpio_analog_en,//GPIO0~7模式选择 0:模拟输入 1:普通GPIO
|
||
BOOLEAN adc_inti_mode,
|
||
BOOLEAN rsvd2,//保留位，永远置0
|
||
BOOLEAN rsvd1,//保留位，永远置0
|
||
BOOLEAN osr_sel,//0:过采样率选择64，128，256，512(四种过采样率通过指令的OSR选择)
|
||
//这个寄存器位要和指令的OSR一起配置选择ADC过采样率
|
||
BOOLEAN refon, //VREF1(基准电压)配置 1 :VREF1保持上电直到WDT溢出 0 :ADC转换完之后VREF1关闭 (默认)
|
||
uint16_t uv_th,//Under voltage Comparison Voltage(欠压阈值)，根据实际情况自行设定
|
||
//Under voltage threshold ADC Code(欠电压阈值模数转换器代码): uv_th = 3000 * 65535U / 5000U. LSB = 0.0001 ---(3V)
|
||
uint16_t ov_th //Over voltage Comparison Voltage(过压阈值)，根据实际情况自行设定
|
||
//Over voltage threshold ADC Code(过电压阈值模数转换器代码): ov_th = 4100 * 65535U / 5000U. LSB = 0.0001 ---(4.1V)
|
||
)
|
||
{
|
||
BF8915A_set_cfga_gpio(nIC, configAReg, gpio_pd_en);//设置CFGAR0
|
||
BF8915A_set_cfga_gpio_mode(nIC, configAReg,gpio_analog_en);//设置CFGAR1
|
||
BF8915A_set_cfga_adc_init_mode(nIC, configAReg,adc_inti_mode);
|
||
BF8915A_set_cfga_rsvd(nIC, configAReg,rsvd2,rsvd1);//保留位，永远置0
|
||
BF8915A_set_cfga_osr_sel(nIC, configAReg,osr_sel);//设置CFGAR2的第2位
|
||
BF8915A_set_cfga_refon(nIC, configAReg,refon);//设置CFGAR2的第1位
|
||
BF8915A_set_cfga_uv(nIC, configAReg,uv_th);//设置CFGAR3和CFGAR4低4位
|
||
BF8915A_set_cfga_ov(nIC, configAReg,ov_th);//设置CFGAR5和CFGAR4高4位
|
||
}
|
||
|
||
/*!
|
||
\brief Helper function to control discharge(控制放电的辅助功能)
|
||
\param[in] nIC : Number of ICs in the system(系统中IC(8915A)的数量)
|
||
\param[in] configBReg: Register group B(寄存器组B)
|
||
\param[in] dcc : 1: Turn on the switch of Cell x(打开x号电池的开关)
|
||
0: Turn off the switch of Cell x(关闭x号电池的开关)
|
||
\retval none
|
||
*/
|
||
void BF8915A_set_cfgb_dcc(uint8_t nIC, Reg_TypeDef *configBReg,uint16_t dcc)
|
||
{
|
||
configBReg[nIC].tx_data[0] = (uint8_t)dcc;//设置CFGBR0,放电电池开关x=1~8
|
||
configBReg[nIC].tx_data[1] = (uint8_t)(dcc >> 0x8U);//设置CFGBR1,放电电池开关x=9~16
|
||
}
|
||
|
||
/*!
|
||
\brief Balanced duty cycle selection(均衡占空比选择)
|
||
\param[in] nIC : Number of ICs in the system(系统中IC(8915A)的数量)
|
||
\param[in] configBReg : Register group B(寄存器组B)
|
||
\param[in] bl_duty_sel: Active balancing duty cycle selection(均衡占空比选择)
|
||
\retval none
|
||
*/
|
||
//bl_duty_sel(4位): 均衡占空比选择,占空比=(BL_DUTY_SEL+1)*10%，配置范围10%~100%，当大于9时是100%。
|
||
void BF8915A_set_cfgb_bl_duty_sel(uint8_t nIC, Reg_TypeDef *configBReg,
|
||
uint8_t bl_duty_sel
|
||
)
|
||
{
|
||
configBReg[nIC].tx_data[2] = configBReg[nIC].tx_data[2] & 0x0F;//将CFGBR2的高4位清空
|
||
configBReg[nIC].tx_data[2] = configBReg[nIC].tx_data[2] | ((0x0F & bl_duty_sel)<<4);//设置CFGBR2高4位,均衡占空比选择
|
||
//保存CFGBR2低4位
|
||
}
|
||
|
||
/*!
|
||
\brief Helper function to set dcto(设置放电定时溢出值配置的辅助函数)
|
||
\param[in] nIC : Number of ICs in the system(系统中IC(8915A)的数量)
|
||
\param[in] configBReg: Register group B(寄存器组B)
|
||
\param[in] dcto : Discharge timing overflow value configuration(放电定时溢出值配置，详细说明如DCTO表所示)
|
||
\retval none
|
||
*/
|
||
void BF8915A_set_cfgb_dcto(uint8_t nIC, Reg_TypeDef *configBReg,
|
||
uint8_t dcto
|
||
)
|
||
{
|
||
configBReg[nIC].tx_data[2] = configBReg[nIC].tx_data[2] & 0xF0;//将CFGBR2的低4位清空
|
||
configBReg[nIC].tx_data[2] = configBReg[nIC].tx_data[2] | (0x0F & dcto);//设置CFGBR2低4位,放电定时溢出值配置
|
||
//保存CFGBR2高4位
|
||
}
|
||
|
||
/*!
|
||
\brief Helper function to set vuv_bl(设置均衡欠压阈值的辅助函数)
|
||
\param[in] nIC : Number of ICs in the system(系统中IC(8915A)的数量)
|
||
\param[in] configBReg: Register group B(寄存器组B)
|
||
\param[in] vuv_bl : Lower 8 bits of equalization undervoltage threshold(均衡欠压阈值的低8位)
|
||
\retval none
|
||
*/
|
||
void BF8915A_set_cfgb_vuv_bl(uint8_t nIC, Reg_TypeDef *configBReg,
|
||
uint16_t vuv_bl//均衡欠压值(12位)
|
||
)
|
||
{
|
||
configBReg[nIC].tx_data[3] = vuv_bl & 0xFF;//设置CFGBR3,均衡欠压阈值低8位放入
|
||
configBReg[nIC].tx_data[4] = configBReg[nIC].tx_data[4] & 0xF0;//将CFGBR4的低4位清空
|
||
configBReg[nIC].tx_data[4] = configBReg[nIC].tx_data[4] | ((vuv_bl & 0x0F00U) >> 0x8U);//设置CFGBR4低4位,均衡欠压阈值高4位放入
|
||
//保存CFGBR4高4位
|
||
}
|
||
|
||
/*!
|
||
\brief Helper function to set bl_dtmen(设置启用放电监测的辅助函数)
|
||
\param[in] nIC : Number of ICs in the system(系统中IC(8915A)的数量)
|
||
\param[in] configBReg: Register group B(寄存器组B)
|
||
\param[in] dtmen : Enable discharge monitor(启用放电监测) 1: Enable discharge monitor(启用放电监测)
|
||
0: Disable discharge monitor(禁用放电监测)
|
||
\retval none
|
||
*/
|
||
void BF8915A_set_cfgb_bl_dtmen(uint8_t nIC, Reg_TypeDef *configBReg,
|
||
BOOLEAN dtmen
|
||
)
|
||
{
|
||
if (dtmen)//设置CFGAR4的第5位
|
||
configBReg[nIC].tx_data[4] = configBReg[nIC].tx_data[4] | (0x01<<4);//写1,使能放电监视器
|
||
else
|
||
configBReg[nIC].tx_data[4] = configBReg[nIC].tx_data[4] & (~(0x01<<4));//写0,不使能放电监视器
|
||
}
|
||
|
||
/*!
|
||
\brief Helper function to set CFGRB variable(设置配置寄存器组B变量的辅助函数)
|
||
\param[in] nIC : Number of ICs in the system(系统中IC(8915A)的数量)
|
||
\param[in] configBReg : Register group B(寄存器组B)
|
||
\param[in] dcc : 1: Turn on the switch of Cell x(打开x电池的开关)
|
||
0: Turn off the switch of Cell x(关闭x电池的开关)
|
||
\param[in] bl_duty_sel: Active balancing duty cycle selection(均衡占空比选择)
|
||
\param[in] dcto : Discharge timing overflow value configuration(放电定时溢出值配置)
|
||
\param[in] vuv_bl : Lower 8 bits of equalization undervoltage threshold(均衡欠压阈值的低8位)
|
||
\param[in] dtmen : Enable discharge monitor(使能放电监测器) 1: Enable discharge monitor(启用放电监测)
|
||
0: Disable discharge monitor(禁用放电监测)
|
||
\retval none
|
||
*/
|
||
void BF8915A_set_cfgrb(uint8_t nIC,
|
||
Reg_TypeDef *configBReg,
|
||
uint16_t dcc,//放电电池开关1:打开Cell x 的开关 0:关闭Cell x 的开关 (默认)
|
||
uint8_t bl_duty_sel,//均衡占空比选择 占空比=(BL_DUTY_SEL+1)*10%，配置范围10%~100%，当大于9时是100%
|
||
uint8_t dcto,//放电定时溢出值配置
|
||
uint16_t vuv_bl,//均衡欠压阈值
|
||
BOOLEAN dtmen//在自动均衡下，如果DTMEN=1，当欠压(小于VUV_BL)关闭放电开关，如果DTMEN=0，不进行欠压比较
|
||
)
|
||
{
|
||
BF8915A_set_cfgb_dcc(nIC, configBReg,dcc);//控制放电的辅助功能
|
||
BF8915A_set_cfgb_bl_duty_sel(nIC, configBReg,bl_duty_sel);//均衡占空比选择
|
||
BF8915A_set_cfgb_dcto(nIC, configBReg,dcto);//设置放电定时溢出值配置的辅助函数
|
||
BF8915A_set_cfgb_vuv_bl(nIC, configBReg,vuv_bl);//设置均衡欠压阈值的辅助函数
|
||
BF8915A_set_cfgb_bl_dtmen(nIC, configBReg,dtmen);//设置启用放电监测的辅助函数
|
||
}
|
||
|
||
/*!
|
||
\brief Helper function to set Undervoltage threshold in monitoring mode(监测模式下，设置欠压阈值的辅助函数)
|
||
\param[in] nIC : Number of ICs in the system(系统中IC(8915A)的数量)
|
||
\param[in] configCReg: Register group C(寄存器组C)
|
||
\param[in] vuv_m : Undervoltage threshold in monitoring mode(监测模式下的欠压阈值)
|
||
\retval none
|
||
*/
|
||
void BF8915A_set_cfgc_vuv_m(uint8_t nIC, Reg_TypeDef *configCReg,uint16_t vuv_m)
|
||
{
|
||
configCReg[nIC].tx_data[0] = 0x00FF & vuv_m;//设置CFGCR0,监测模式下，欠压阈值低8位放入
|
||
configCReg[nIC].tx_data[1] = configCReg[nIC].tx_data[1]&0xF0;//将CFGCR1的低4位清空
|
||
configCReg[nIC].tx_data[1] = configCReg[nIC].tx_data[1]|((0x0F00 & vuv_m)>>8);//设置CFGCR1低4位,监测模式下，欠压阈值高4位放入
|
||
//保存CFGCR1高4位
|
||
}
|
||
|
||
/*!
|
||
\brief Helper function to set Overvoltage threshold in monitoring mode(监测模式下，设置过压阈值的辅助函数)
|
||
\param[in] nIC : Number of ICs in the system(系统中IC(8915A)的数量)
|
||
\param[in] configCReg: Register group C(寄存器组C)
|
||
\param[in] vov_m : Overvoltage threshold in monitoring mode(监测模式下的过压阈值)
|
||
\retval none
|
||
*/
|
||
void BF8915A_set_cfgc_vov_m(uint8_t nIC, Reg_TypeDef *configCReg,uint16_t vov_m)
|
||
{
|
||
configCReg[nIC].tx_data[2] = 0x00FF & (vov_m>>4);//设置CFGCR2,监测模式下，过压阈值高8位放入
|
||
configCReg[nIC].tx_data[1] = configCReg[nIC].tx_data[1]&0x0F;//将CFGCR1的高4位清空
|
||
configCReg[nIC].tx_data[1] = configCReg[nIC].tx_data[1]|((0x000F & vov_m)<<4);//设置CFGCR1高4位,监测模式下，过压阈值低4位放入
|
||
//保存CFGCR1低4位
|
||
}
|
||
|
||
/*!
|
||
\brief Helper function to set Internal over-temperature threshold in monitoring mode(监测模式下，设置内部过温阈值的辅助函数)
|
||
\param[in] nIC : Number of ICs in the system(系统中IC(8915A)的数量)
|
||
\param[in] configCReg: Register group C(寄存器组C)
|
||
\param[in] itov_m : In monitoring mode, internal over-temperature threshold(监测模式下，内部过温阈值)
|
||
\retval none
|
||
*/
|
||
void BF8915A_set_cfgc_itov_m(uint8_t nIC, Reg_TypeDef *configCReg,uint16_t itov_m)
|
||
{
|
||
configCReg[nIC].tx_data[3] = 0x00FF & itov_m;//设置CFGCR3,监测模式下，内部过温阈值低8位放入
|
||
configCReg[nIC].tx_data[4] = configCReg[nIC].tx_data[4]&0xF0;//将CFGCR4的低4位清空
|
||
configCReg[nIC].tx_data[4] = configCReg[nIC].tx_data[4]|((0x0F00 & itov_m)>>8);//设置CFGCR4低4位,监测模式下，内部过温阈值高4位放入
|
||
//保存CFGCR4高4位
|
||
}
|
||
|
||
/*!
|
||
\brief Helper function to set external over-temperature threshold in monitoring mode(监测模式下，设置外部过温阈值的辅助函数)
|
||
\param[in] nIC : Number of ICs in the system(系统中IC(8915A)的数量)
|
||
\param[in] configCReg: Register group C(寄存器组C)
|
||
\param[in] extov_m : In monitoring mode, external over-temperature threshold(监测模式下，外部过温阈值)
|
||
\retval none
|
||
*/
|
||
void BF8915A_set_cfgc_extov_m(uint8_t nIC, Reg_TypeDef *configCReg,uint16_t extov_m)
|
||
{
|
||
configCReg[nIC].tx_data[5] = 0x00FF & (extov_m>>4);//设置CFGCR5,监测模式下，外部过温阈值高8位放入
|
||
configCReg[nIC].tx_data[4] = configCReg[nIC].tx_data[4]&0x0F;//将CFGCR4的高4位清空
|
||
configCReg[nIC].tx_data[4] = configCReg[nIC].tx_data[4]|((0x000F & extov_m)<<4);//设置CFGCR4高4位,监测模式下，外部过温阈值低4位放入
|
||
//保存CFGCR4低4位
|
||
}
|
||
|
||
/*!
|
||
\brief Helper function to set CFGRC variable(设置配置寄存器组C变量的辅助函数)
|
||
\param[in] nIC : Number of ICs in the system(系统中IC(8915A)的数量)
|
||
\param[in] configCReg: Register group C(寄存器组C)
|
||
\param[in] vuv_m : Undervoltage threshold in monitoring mode(监测模式下的欠压阈值)
|
||
\param[in] vov_m : Overvoltage threshold in monitoring mode(监测模式下的过压阈值)
|
||
\param[in] itov_m : Internal over-temperature threshold in monitoring mode(监测模式下，内部过温阈值)
|
||
\param[in] extov_m : external over-temperature threshold in monitoring mode(监测模式下，外部过温阈值)
|
||
\retval none
|
||
*/
|
||
void BF8915A_set_cfgrc(uint8_t nIC,
|
||
Reg_TypeDef *configCReg,
|
||
uint16_t vuv_m,//监测模式下的欠压阈值
|
||
uint16_t vov_m,//监测模式下的过压阈值
|
||
uint16_t itov_m,//监测模式下的内部过温阈值
|
||
uint16_t extov_m//监测模式下的外部过温阈值
|
||
)
|
||
{
|
||
BF8915A_set_cfgc_vuv_m(nIC, configCReg,vuv_m);//监测模式下，设置欠压阈值的辅助函数
|
||
BF8915A_set_cfgc_vov_m(nIC, configCReg,vov_m);//监测模式下，设置过压阈值的辅助函数
|
||
BF8915A_set_cfgc_itov_m(nIC, configCReg,itov_m);//监测模式下，设置内部过温阈值的辅助函数
|
||
BF8915A_set_cfgc_extov_m(nIC, configCReg,extov_m);//监测模式下，设置外部过温阈值的辅助函数
|
||
}
|
||
|
||
/*!
|
||
\brief Helper function to set csel_m(设置监测模式下，电池电压监测比较选择的辅助函数)
|
||
\param[in] nIC : Number of ICs in the system(系统中IC(8915A)的数量)
|
||
\param[in] configDReg: Register group D(寄存器组D)
|
||
\param[in] csel_m : In monitoring mode, battery voltage monitoring comparison selection cell1~cell16(在监测模式下，电池电压监测比较选择电池1 ~电池16)
|
||
\retval none
|
||
*/
|
||
void BF8915A_set_cfgd_csel_m(uint8_t nIC, Reg_TypeDef *configDReg,uint16_t csel_m)
|
||
{
|
||
configDReg[nIC].tx_data[0] = 0x00FF & csel_m;//设置CFGDR0，即电池电压监测比较选择cell1~cell8
|
||
configDReg[nIC].tx_data[1] = (csel_m & 0xFF00) >> 0x8U;//设置CFGDR1，即电池电压监测比较选择cell9~cell16
|
||
}
|
||
|
||
/*!
|
||
\brief Helper function to set gsel_m(设置监测模式下，GPIO0~7比较选择的辅助函数)
|
||
\param[in] nIC : Number of ICs in the system(系统中IC(8915A)的数量)
|
||
\param[in] configDReg: Register group D(寄存器组D)
|
||
\param[in] gsel_m : In monitoring mode, GPIO0~7 is compared and selected(监测模式下，GPIO0~7比较选择)
|
||
\retval none
|
||
*/
|
||
void BF8915A_set_cfgd_gsel_m(uint8_t nIC, Reg_TypeDef *configDReg,uint8_t gsel_m)
|
||
{
|
||
configDReg[nIC].tx_data[2] = gsel_m;//设置CFGDR2
|
||
}
|
||
|
||
/*!
|
||
\brief Helper function to set isospi_wake_t(设置菊花链唤醒时间的辅助函数)
|
||
\param[in] nIC : Number of ICs in the system(系统中IC(8915A)的数量)
|
||
\param[in] configDReg : Register group D(寄存器组D)
|
||
\param[in] isospi_wake_t: isospi wake-up time, 0: 10us; 1:20us(isospi(菊花链SPI)唤醒时间，0:10us；1:20us)
|
||
\retval none
|
||
*/
|
||
void BF8915A_set_cfgd_isospi_wake_t(uint8_t nIC, Reg_TypeDef *configDReg,BOOLEAN isospi_wake_t)
|
||
{
|
||
if (isospi_wake_t)//设置CFGDR3的第8位
|
||
configDReg[nIC].tx_data[3] = configDReg[nIC].tx_data[3] | (0x01<<7);//写1
|
||
else
|
||
configDReg[nIC].tx_data[3] = configDReg[nIC].tx_data[3] & (~(0x01<<7));//写0
|
||
}
|
||
|
||
/*!
|
||
\brief Helper function to set adc_rst_sel(设置测量第1个通道ADC复位选择的辅助函数)
|
||
\param[in] nIC : Number of ICs in the system(系统中IC(8915A)的数量)
|
||
\param[in] configDReg : Register group D(寄存器组D)
|
||
\param[in] adc_rst_sel: 0: All measurement channels reset ADC(所有测量通道都复位ADC)
|
||
1: Only the first channel resets ADC, then 2~n channels do not reset ADC(只有第1个通道复位ADC，之后2~n通道不复位ADC)
|
||
\retval none
|
||
*/
|
||
void BF8915A_set_cfgd_adc_rst_sel(uint8_t nIC, Reg_TypeDef *configDReg,BOOLEAN adc_rst_sel)
|
||
{
|
||
if (adc_rst_sel)//设置CFGDR3的第7位
|
||
configDReg[nIC].tx_data[3] = configDReg[nIC].tx_data[3] | (0x01<<6);//写1
|
||
else
|
||
configDReg[nIC].tx_data[3] = configDReg[nIC].tx_data[3] & (~(0x01<<6));//写0
|
||
}
|
||
|
||
/*!
|
||
\brief Helper function to set time_sel_m(设置监测模式下，定时监测时间配置的辅助函数)
|
||
\param[in] nIC : Number of ICs in the system(系统中IC(8915A)的数量)
|
||
\param[in] configDReg: Register group D(寄存器组D)
|
||
\param[in] time_sel_m: In monitoring mode, timing monitoring time configuration(监测模式下，定时监测时间配置)
|
||
\retval none
|
||
*/
|
||
//time_sel_m(5位):监测模式下，定时监测时间配置，定时时间=(TIME_SEL_M+1)*1s(2~64s)，最小配置值是1(2s)
|
||
//这个时间配置和均衡周期配置共用
|
||
void BF8915A_set_cfgd_time_sel_m(uint8_t nIC, Reg_TypeDef *configDReg,uint8_t time_sel_m)
|
||
{
|
||
|
||
configDReg[nIC].tx_data[3] = configDReg[nIC].tx_data[3] & 0xC0U;//将CFGDR3低6位清空
|
||
configDReg[nIC].tx_data[3] = configDReg[nIC].tx_data[3] | (time_sel_m & 0x3F);//设置CFGDR3低6位
|
||
//保存CFGDR3高2位
|
||
}
|
||
|
||
/*!
|
||
\brief Helper function to set adc_init_t2(设置ADC测量第2~n个通道ADC初始化时间的辅助函数)
|
||
\param[in] nIC : Number of ICs in the system(系统中IC(8915A)的数量)
|
||
\param[in] configDReg : Register group D(寄存器组D)
|
||
\param[in] adc_init_t2: ADC measurement 2~n channel ADC initialization time(ADC测量第2~n个通道ADC初始化时间)
|
||
\retval none
|
||
*/
|
||
//ADC测量第2~n个通道ADC初始化时间，(ADC_INIT_T2+1)*20us(20~320us)
|
||
void BF8915A_set_cfgd_adc_init_t2(uint8_t nIC, Reg_TypeDef *configDReg,uint8_t adc_init_t2)
|
||
{
|
||
|
||
configDReg[nIC].tx_data[4] = configDReg[nIC].tx_data[4] & 0x0FU;//将CFGDR4高4位清空
|
||
configDReg[nIC].tx_data[4] = configDReg[nIC].tx_data[4] | ((adc_init_t2 & 0x0F) << 0x4U);//设置CFGDR4高4位
|
||
//保存CFGDR4低4位
|
||
}
|
||
|
||
/*!
|
||
\brief Helper function to set adc_init_t1(设置ADC测量第1个通道ADC初始化时间的辅助函数)
|
||
\param[in] nIC : Number of ICs in the system(系统中IC(8915A)的数量)
|
||
\param[in] configDReg : Register group D(寄存器组D)
|
||
\param[in] adc_init_t1: ADC measurement 1 channel ADC initialization time(ADC测量第1个通道ADC初始化时间)
|
||
\retval none
|
||
*/
|
||
//ADC测量第1个通道ADC初始化时间(ADC_INIT_T1+1)*100us(100~1600us)
|
||
void BF8915A_set_cfgd_adc_init_t1(uint8_t nIC, Reg_TypeDef *configDReg,uint8_t adc_init_t1)
|
||
{
|
||
|
||
configDReg[nIC].tx_data[4] = configDReg[nIC].tx_data[4] & 0xF0U;//将CFGDR4低4位清空
|
||
configDReg[nIC].tx_data[4] = configDReg[nIC].tx_data[4] | (adc_init_t1 & 0x0F);//设置CFGDR4低4位
|
||
//保存CFGDR4高4位
|
||
}
|
||
|
||
/*!
|
||
\brief Helper function to set trim2_en(设置修调2使能的辅助函数)
|
||
\param[in] nIC : Number of ICs in the system(系统中IC(8915A)的数量)
|
||
\param[in] configDReg: Register group D(寄存器组D)
|
||
\param[in] trim2_en : Modification 2 enable, 1: enable, 0: disable(修调2使能，1:使能，0:不使能)
|
||
\retval none
|
||
*/
|
||
void BF8915A_set_cfgd_trim2_en(uint8_t nIC, Reg_TypeDef *configDReg,BOOLEAN trim2_en)
|
||
{
|
||
if (trim2_en)//设置CFGDR5的第8位
|
||
configDReg[nIC].tx_data[5] = configDReg[nIC].tx_data[5] | (0x01<<7);//写1
|
||
else
|
||
configDReg[nIC].tx_data[5] = configDReg[nIC].tx_data[5] & (~(0x01<<7));//写0
|
||
}
|
||
|
||
/*!
|
||
\brief Helper function to set trim1_en(设置修调1使能的辅助函数)
|
||
\param[in] nIC : Number of ICs in the system(系统中IC(8915A)的数量)
|
||
\param[in] configDReg: Register group D(寄存器组D)
|
||
\param[in] trim1_en : Modification 1 enable, 1: enable, 0: disable(修调1使能，1:使能，0:不使能)
|
||
\retval none
|
||
*/
|
||
void BF8915A_set_cfgd_trim1_en(uint8_t nIC, Reg_TypeDef *configDReg,BOOLEAN trim1_en)
|
||
{
|
||
if (trim1_en)//设置CFGDR5的第7位
|
||
configDReg[nIC].tx_data[5] = configDReg[nIC].tx_data[5] | (0x01<<6);//写1
|
||
else
|
||
configDReg[nIC].tx_data[5] = configDReg[nIC].tx_data[5] & (~(0x01<<6));//写0
|
||
}
|
||
|
||
/*!
|
||
\brief Helper function to set trim1_en(设置监测模式下发生异常，上报的间隔时间的辅助函数)
|
||
\param[in] nIC : Number of ICs in the system(系统中IC(8915A)的数量)
|
||
\param[in] configDReg : Register group D(寄存器组D)
|
||
\param[in] err_t_sel_m: When an exception occurs in the monitoring mode, the reporting interval(监测模式下发生异常，上报的间隔时间)
|
||
\retval none
|
||
*/
|
||
//err_t_sel_m(2位):监测模式下发生异常，上报的间隔时间 00:200ms，01:400ms，10:600ms，11:800ms
|
||
void BF8915A_set_cfgd_err_t_sel_m(uint8_t nIC, Reg_TypeDef *configDReg,uint8_t err_t_sel_m)
|
||
{
|
||
|
||
configDReg[nIC].tx_data[5] = configDReg[nIC].tx_data[5] & 0xCFU;//将CFGDR5的第6~5位清空
|
||
configDReg[nIC].tx_data[5] = configDReg[nIC].tx_data[5] | ((err_t_sel_m & 0x03) << 0x4U);//设置CFGDR5第6~5位
|
||
//保存CFGDR5第8~7位
|
||
}
|
||
|
||
/*!
|
||
\brief Helper function to set CFGRD variable(设置配置寄存器组D变量的辅助函数)
|
||
\param[in] nIC : Number of ICs in the system(系统中IC(8915A)的数量)
|
||
\param[in] configDReg: A two dimensional array of the configuration data that will be written(将要写入配置数据的二维数组)
|
||
\param[in] vd33t_on_m: A two dimensional array of the configuration data that will be written(将要写入配置数据的二维数组)
|
||
\retval none
|
||
*/
|
||
//vd33t_on_m:监测模式下，VREF1(基准电压)和VD33T的启动时间配置(5+VD33T_ON_M*10)ms，范围是5~155ms
|
||
void BF8915A_set_cfgd_vd33t_on_m(uint8_t nIC, Reg_TypeDef *configDReg,uint8_t vd33t_on_m)
|
||
{
|
||
configDReg[nIC].tx_data[5] = configDReg[nIC].tx_data[5] & 0xF0U;//将CFGDR5的低4位清空
|
||
configDReg[nIC].tx_data[5] = configDReg[nIC].tx_data[5] | (vd33t_on_m & 0x0F);//保存CFGDR5高4位，设置CFGDR5低4位
|
||
}
|
||
|
||
/*!
|
||
\brief Helper function to set CFGRD variable(设置配置寄存器组D变量的辅助函数)
|
||
\param[in] nIC : Number of ICs in the system(系统中IC(8915A)的数量)
|
||
\param[in] configDReg : Register group D(寄存器组D)
|
||
\param[in] csel_m : In monitoring mode, battery voltage monitoring comparison selection cell1~cell16(在监测模式下，电池电压监测比较选择电池1~电池16)
|
||
\param[in] gsel_m : In monitoring mode, GPIO0~7 comparison selection(监测模式下，GPIO0~7比较选择)
|
||
\param[in] isospi_wake_t: isospi wake up time(菊花链唤醒时间)
|
||
\param[in] adc_rst_sel : 0: All measurement channels reset ADC(所有测量通道都复位ADC)
|
||
1: Only the first channel resets ADC, then 2~n channels do not reset ADC(只有第1个通道复位ADC，之后2~n通道不复位ADC)
|
||
\param[in] time_sel_m : In monitoring mode, timing monitoring time configuration, timing time=(TIME_SEL_M+1)*1s(2~64s), the minimum configuration value is 1(2s);This time configuration is shared with the balance period configuration
|
||
(监测模式下，定时监测时间配置，定时时间=(TIME_SEL_M+1)*1s(2~64s)，最小配置值是1(2s)；该时间配置与均衡时期的配置共享)
|
||
\param[in] adc_init_t2 : ADC measures the ADC initialization time of the second to n channels, (ADC_INIT_T2+1)*20us (20~320us)(ADC测量第2~n个通道ADC初始化时间，(ADC_INIT_T2+1)*20us(20~320us))
|
||
\param[in] adc_init_t1 : ADC measurement of the first channel ADC initialization time (ADC_INIT_T1+1)*100us (100~1600us)(ADC测量第1个通道ADC初始化时间(ADC_INIT_T1+1)*100us(100~1600us))
|
||
\param[in] trim2_en:1 : enable, 0: disable(修调2使能，1:使能，0:不使能)
|
||
\param[in] trim1_en:1 : enable, 0: disable(修调1使能，1:使能，0:不使能)
|
||
\param[in] err_t_sel_m : 00: 200ms, 01: 400ms, 10: 600ms, 11: 800ms(监测模式下发生异常，上报的间隔时间 00:200ms，01:400ms，10:600ms，11:800ms)
|
||
\param[in] vd33t_on_m : The startup time configuration of VREF1 and VD33T (5+VD33T_ON_M*10)ms, the range is 5~155ms(监测模式下，VREF1和VD33T的启动时间配置(5+VD33T_ON_M*10)ms，范围是5~155ms)
|
||
\retval none
|
||
*/
|
||
void BF8915A_set_cfgrd(uint8_t nIC,
|
||
Reg_TypeDef *configDReg,
|
||
uint16_t csel_m,//监测模式下，电池电压监测比较选择cell1~cell16
|
||
//1:相应的电池就会在监测模式下进行过欠压比较，置标志位
|
||
//0:相应的电池就会在监测模式下不进行过欠压比较，不置标志位
|
||
uint8_t gsel_m ,//监测模式下，GPIO0~7比较选择
|
||
//1:相应的电池就会在监测模式下进行过温(小于外部温度阈值)比较，置标志位
|
||
//0:相应的电池就会在监测模式下不进行过温(小于外部温度阈值)比较，不置标志位
|
||
BOOLEAN isospi_wake_t,//菊花链唤醒时间，0: 10us；1: 20us
|
||
BOOLEAN adc_rst_sel,//测量第1个通道ADC复位选择，0:所有测量通道都复位ADC，1:只有第1个通道复位ADC，之后2~n通道不复位ADC
|
||
uint8_t time_sel_m,//监测模式下，定时监测时间配置，定时时间=(TIME_SEL_M+1)*1s(2~64s)，最小配置值是1(2s)
|
||
//这个时间配置和均衡周期配置共用
|
||
uint8_t adc_init_t2,//ADC测量第2~n个通道ADC初始化时间，(ADC_INIT_T2+1)*20us(20~320us)
|
||
uint8_t adc_init_t1,//ADC测量第1个通道ADC初始化时间(ADC_INIT_T1+1)*100us(100~1600us)
|
||
BOOLEAN trim2_en,//修调2使能，1:使能，0:不使能
|
||
BOOLEAN trim1_en,//修调1使能，1:使能，0:不使能
|
||
uint8_t err_t_sel_m,//监测模式下发生异常，上报的间隔时间
|
||
//00:200ms，01:400ms，10:600ms，11:800ms
|
||
uint8_t vd33t_on_m//监测模式下，VREF1和VD33T的启动时间配置(5+VD33T_ON_M*10)ms，范围是5~155ms
|
||
)
|
||
{
|
||
BF8915A_set_cfgd_csel_m(nIC, configDReg,csel_m);//设置监测模式下，电池电压监测比较选择的辅助函数
|
||
BF8915A_set_cfgd_gsel_m(nIC, configDReg,gsel_m);//设置监测模式下，GPIO0~7比较选择的辅助函数
|
||
BF8915A_set_cfgd_isospi_wake_t(nIC, configDReg,isospi_wake_t);//设置菊花链唤醒时间的辅助函数
|
||
BF8915A_set_cfgd_adc_rst_sel(nIC, configDReg,adc_rst_sel);//设置测量第1个通道ADC复位选择的辅助函数
|
||
BF8915A_set_cfgd_time_sel_m(nIC, configDReg,time_sel_m);//设置监测模式下，定时监测时间配置的辅助函数
|
||
BF8915A_set_cfgd_adc_init_t2(nIC, configDReg,adc_init_t2);//设置ADC测量第2~n个通道ADC初始化时间的辅助函数
|
||
BF8915A_set_cfgd_adc_init_t1(nIC, configDReg,adc_init_t1);//设置ADC测量第1个通道ADC初始化时间的辅助函数
|
||
BF8915A_set_cfgd_trim2_en(nIC, configDReg,trim2_en);//设置修调2使能的辅助函数
|
||
BF8915A_set_cfgd_trim1_en(nIC, configDReg,trim1_en);//设置修调1使能的辅助函数
|
||
BF8915A_set_cfgd_err_t_sel_m(nIC, configDReg,err_t_sel_m);//设置监测模式下发生异常，上报的间隔时间的辅助函数
|
||
BF8915A_set_cfgd_vd33t_on_m(nIC, configDReg,vd33t_on_m);//设置配置寄存器组D变量的辅助函数
|
||
}
|
||
|
||
/*!
|
||
\brief Write the BF8915A CFGRA(写BF8915A的配置寄存器组A)
|
||
\param[in] total_ic : Number of ICs in the system(系统中IC(8915A)的数量)
|
||
\param[in] configAData: A two dimensional array of the configuration data that will be written(将要写入配置数据的二维数组)
|
||
\retval none
|
||
*/
|
||
|
||
void BF8915A_wrcfga(uint8_t total_ic, ConfigA_TypeDef configAData[])
|
||
{
|
||
uint8_t cmd[2] = {0x00 , 0x01};//发送写BF8915A的配置寄存器组A指令的高低共16位
|
||
|
||
uint8_t write_count = 0;//数组计数器，最大为TOTAL_IC * 0x6U
|
||
uint8_t c_ic = 0;//当前正在写入数组的8915A芯片序号
|
||
uint8_t current_ic = 0;//current_ic is used as the IC counter(当前IC(8915A)用作IC(8915A)计数器)
|
||
uint8_t dataTemp = 0;//计数器，每6次一循环，用于计数每个寄存器组当前循环到的寄存器
|
||
|
||
for (current_ic = 0; current_ic<total_ic; current_ic++)//配置每个8915A的配置寄存器组A
|
||
{
|
||
BF8915A_set_cfgra(current_ic,
|
||
configAArray,
|
||
configAData[current_ic].gpio_pd_en,//写0:GPIO脚下拉使能；1:GPIO脚下拉关闭(默认)读0 :GPIO脚的值是0 ；1:GPIO脚的值是1
|
||
configAData[current_ic].gpio_analog_en,//GPIO0~7模式选择 0:模拟输入 1:普通GPIO
|
||
configAData[current_ic].adc_init_mode,
|
||
configAData[current_ic].rsvd2,//保留位，永远置0
|
||
configAData[current_ic].rsvd1,//保留位，永远置0
|
||
configAData[current_ic].osr_sel,//0:过采样率选择64，128，256，512(四种过采样率通过指令的OSR选择)
|
||
//这个寄存器位要和指令的OSR一起配置选择ADC过采样率
|
||
configAData[current_ic].refon,//VREF1(基准电压)配置 1 :VREF1保持上电直到WDT溢出 0 :ADC转换完之后VREF1关闭 (默认)
|
||
configAData[current_ic].uv_th,//Under voltage Comparison Voltage(欠压阈值)，根据实际情况自行设定
|
||
//Under voltage threshold ADC Code(欠电压阈值模数转换器代码): uv_th = 3000 * 65535U / 5000U. LSB = 0.0001 ---(3V)
|
||
configAData[current_ic].ov_th //Over voltage Comparison Voltage(过压阈值)，根据实际情况自行设定
|
||
//Over voltage threshold ADC Code(过电压阈值模数转换器代码): ov_th = 4100 * 65535U / 5000U. LSB = 0.0001 ---(4.1V)
|
||
);
|
||
}
|
||
|
||
for (current_ic = 0; current_ic<total_ic; current_ic++)//该循环作用为给每个8915A芯片发送配置寄存器组A指令
|
||
{
|
||
if (isospi_reverse == TRUE)//判断选择的菊花链通信方向是相对正向还是相对反向
|
||
{
|
||
c_ic = current_ic;//选择正序将配置寄存器组A指令放入数组
|
||
}
|
||
else
|
||
{
|
||
c_ic = total_ic - current_ic - 1;//选择倒序将配置寄存器组A指令放入数组
|
||
}
|
||
|
||
for (dataTemp = 0; dataTemp<6; dataTemp++)//若isospi一直为FALSE，则此循环将配置寄存器组A中配置好的数组数据一一写入发送数组中，并且是通过倒序发送给每个8915A芯片
|
||
{
|
||
write_buffer[write_count] = configAArray[c_ic].tx_data[dataTemp];
|
||
write_count++;
|
||
}
|
||
}
|
||
BF8915A_write(total_ic, cmd, write_buffer);//写BF8915A命令和写有效载荷数据的通用函数
|
||
}
|
||
|
||
/*!
|
||
\brief Write the BF8915A CFGRB(写BF8915A的配置寄存器组B)
|
||
\param[in] total_ic : Number of ICs in the system(系统中IC(8915A)的数量)
|
||
\param[in] configBData: A two dimensional array of the configuration data that will be written(将要写入配置数据的二维数组)
|
||
\retval none
|
||
*/
|
||
void BF8915A_wrcfgb(uint8_t total_ic,
|
||
ConfigB_TypeDef configBData[]
|
||
)
|
||
{
|
||
uint8_t cmd[2] = {0x00 , 0x02};//发送写BF8915A的配置寄存器组B指令的高低共16位
|
||
|
||
//uint8_t write_buffer[TOTAL_IC * 0x6U];//寄存器组中的6个8位寄存器
|
||
uint8_t write_count = 0;//数组计数器，最大为TOTAL_IC * 0x6U
|
||
uint8_t c_ic = 0;//当前正在写入数组的8915A芯片序号
|
||
uint8_t current_ic = 0;//current_ic is used as the IC counter(当前IC(8915A)用作IC(8915A)计数器)
|
||
uint8_t dataTemp = 0;//计数器，每6次一循环，用于计数每个寄存器组当前循环到的寄存器
|
||
|
||
for (current_ic = 0; current_ic<total_ic; current_ic++)//配置每个8915A的配置寄存器组B
|
||
{
|
||
BF8915A_set_cfgrb(current_ic,
|
||
configBArray,
|
||
configBData[current_ic].dcc,//放电电池开关1:打开Cell x 的开关 0:关闭Cell x 的开关 (默认)
|
||
configBData[current_ic].bl_duty_sel,//主动均衡占空比选择 占空比=(BL_DUTY_SEL+1)*10%，配置范围10%~100%，当大于9时是100%。
|
||
configBData[current_ic].dcto,//放电定时溢出值配置
|
||
configBData[current_ic].vuv_bl_th,//均衡欠压阈值
|
||
configBData[current_ic].dtmen//在自动均衡下，如果DTMEN=1，当欠压(小于VUV_BL)关闭放电开关，如果DTMEN=0，不进行欠压比较
|
||
);
|
||
}
|
||
for (current_ic = 0; current_ic<total_ic; current_ic++)//该循环作用为给每个8915A芯片发送配置寄存器组B指令
|
||
{
|
||
if (isospi_reverse == TRUE)//判断选择的菊花链通信方向是相对正向还是相对反向
|
||
{
|
||
c_ic = current_ic;//选择正序将配置寄存器组B指令放入数组
|
||
}
|
||
else
|
||
{
|
||
c_ic = total_ic - current_ic - 1;//选择倒序将配置寄存器组B指令放入数组
|
||
}
|
||
|
||
for (dataTemp = 0; dataTemp<6; dataTemp++)//若isospi一直为FALSE，则此循环将配置寄存器组B中配置好的数组数据一一写入发送数组中，并且是通过倒序发送给每个8915A芯片
|
||
{
|
||
write_buffer[write_count] = configBArray[c_ic].tx_data[dataTemp];
|
||
write_count++;
|
||
}
|
||
}
|
||
BF8915A_write(total_ic, cmd, write_buffer);//写BF8915A命令和写有效载荷数据的通用函数
|
||
}
|
||
|
||
/*!
|
||
\brief Write the BF8915A CFGRC(写BF8915A的配置寄存器组C)
|
||
\param[in] total_ic : Number of ICs in the system(系统中IC(8915A)的数量)
|
||
\param[in] configCData: A two dimensional array of the configuration data that will be written(将要写入配置数据的二维数组)
|
||
\retval none
|
||
*/
|
||
void BF8915A_wrcfgc(uint8_t total_ic,
|
||
ConfigC_TypeDef configCData[]
|
||
)
|
||
{
|
||
uint8_t cmd[2] = {0x00 , 0x03};//发送写BF8915A的配置寄存器组C指令的高低共16位
|
||
// Reg_TypeDef configCArray[TOTAL_IC];//定义一个结构体为Reg_TypeDef的数据结构C数组,用于存储指令数据
|
||
//uint8_t write_buffer[TOTAL_IC * 0x6U];//寄存器组中的6个8位寄存器
|
||
uint8_t write_count = 0;//数组计数器，最大为TOTAL_IC * 0x6U
|
||
uint8_t c_ic = 0;//当前正在写入数组的8915A芯片序号
|
||
uint8_t current_ic = 0;//current_ic is used as the IC counter(当前IC(8915A)用作IC(8915A)计数器)
|
||
uint8_t data = 0;//计数器，每6次一循环，用于计数每个寄存器组当前循环到的寄存器
|
||
for (current_ic = 0; current_ic<total_ic; current_ic++)//配置每个8915A的配置寄存器组C
|
||
{
|
||
BF8915A_set_cfgrc(current_ic,
|
||
configCArray,
|
||
configCData[current_ic].vuv_m_th,//监测模式下，欠压阈值
|
||
configCData[current_ic].vov_m_th,//监测模式下，过压阈值
|
||
configCData[current_ic].itov_m_th,//监测模式下，内部过温阈值
|
||
configCData[current_ic].extov_m_th//监测模式下，外部过温阈值
|
||
);
|
||
}
|
||
for (current_ic = 0; current_ic<total_ic; current_ic++)//该循环作用为给每个8915A芯片发送配置寄存器组C指令
|
||
{
|
||
if (isospi_reverse == TRUE)//判断选择的菊花链通信方向是相对正向还是相对反向
|
||
{
|
||
c_ic = current_ic;//选择正序将配置寄存器组C指令放入数组
|
||
}
|
||
else
|
||
{
|
||
c_ic = total_ic - current_ic - 1;//选择倒序将配置寄存器组C指令放入数组
|
||
}
|
||
|
||
for (data = 0; data<6; data++)//若isospi一直为FALSE，则此循环将配置寄存器组C中配置好的数组数据一一写入发送数组中，并且是通过倒序发送给每个8915A芯片
|
||
{
|
||
write_buffer[write_count] = configCArray[c_ic].tx_data[data];
|
||
write_count++;
|
||
}
|
||
}
|
||
BF8915A_write(total_ic, cmd, write_buffer);//写BF8915A命令和写有效载荷数据的通用函数
|
||
}
|
||
|
||
/*!
|
||
\brief Write the BF8915A CFGRD(写BF8915A的配置寄存器组D)
|
||
\param[in] total_ic : Number of ICs in the system(系统中IC(8915A)的数量)
|
||
\param[in] configDData: A two dimensional array of the configuration data that will be written(将要写入配置数据的二维数组)
|
||
\retval none
|
||
*/
|
||
void BF8915A_wrcfgd(uint8_t total_ic,
|
||
ConfigD_TypeDef configDData[]
|
||
)
|
||
{
|
||
uint8_t cmd[2] = {0x00 , 0x04};//发送写BF8915A的配置寄存器组D指令的高低共16位
|
||
//Reg_TypeDef configDArray[TOTAL_IC];//定义一个结构体为Reg_TypeDef的数据结构D数组,用于存储指令数据
|
||
//uint8_t write_buffer[TOTAL_IC * 0x6U];//寄存器组中的6个8位寄存器
|
||
uint8_t write_count = 0;//数组计数器，最大为TOTAL_IC * 0x6U
|
||
uint8_t c_ic = 0;//当前正在写入数组的8915A芯片序号
|
||
uint8_t current_ic = 0;//current_ic is used as the IC counter(当前IC(8915A)用作IC(8915A)计数器)
|
||
uint8_t data = 0;//计数器，每6次一循环，用于计数每个寄存器组当前循环到的寄存器
|
||
|
||
for (current_ic = 0; current_ic<total_ic; current_ic++)//配置每个8915A的配置寄存器组D
|
||
{
|
||
BF8915A_set_cfgrd(current_ic,
|
||
configDArray,
|
||
configDData[current_ic].csel_m, //监测模式下，电池电压监测比较选择 1:相应的电池就会在监测模式下进行过欠压比较，置标志位
|
||
// 0:相应的电池就会在监测模式下不进行过欠压比较，不置标志位
|
||
configDData[current_ic].gsel_m,//监测模式下，GPIO0~7比较选择
|
||
configDData[current_ic].isospi_wake_t,//isospi(菊花链SPI)唤醒时间，0:10us 1:20us
|
||
configDData[current_ic].adc_rst_sel,//测量第1个通道ADC复位选择，0:所有测量通道都复位ADC，1:只有第1个通道复位ADC，之后2~n通道不复位ADC
|
||
configDData[current_ic].time_sel_m,//监测模式下，定时监测时间配置，定时时间=(TIME_SEL_M+1)*1s(2~64s)，最小配置值是1(2s)
|
||
configDData[current_ic].adc_init_t2,//ADC测量第2~n个通道ADC初始化时间，(ADC_INIT_T2+1)*20us(20~320us)
|
||
configDData[current_ic].adc_init_t1,//ADC测量第1个通道ADC初始化时间(ADC_INIT_T1+1)*100us(100~1600us)
|
||
configDData[current_ic].trim2_en,//修调2使能，1:使能，0:不使能
|
||
configDData[current_ic].trim1_en,//修调1使能，1:使能，0:不使能
|
||
configDData[current_ic].err_t_sel_m,//监测模式下发生异常，上报的间隔时间 00:200ms，01:400ms，10:600ms，11:800ms
|
||
configDData[current_ic].vd33t_on_m//监测模式下，VREF1和VD33T的启动时间配置(5+VD33T_ON_M*10)ms，范围是5~155ms
|
||
);
|
||
}
|
||
|
||
for (current_ic = 0; current_ic<total_ic; current_ic++)//该循环作用为给每个8915A芯片发送配置寄存器组D指令
|
||
{
|
||
if (isospi_reverse == TRUE)//判断选择的菊花链通信方向是相对正向还是相对反向
|
||
{
|
||
c_ic = current_ic;//选择正序将配置寄存器组D指令放入数组
|
||
}
|
||
else
|
||
{
|
||
c_ic = total_ic - current_ic - 1;//选择倒序将电配置寄存器组D指令放入数组
|
||
}
|
||
|
||
for (data = 0; data<6; data++)//若isospi一直为FALSE，则此循环将配置寄存器组D中配置好的数组数据一一写入发送数组中，并且是通过倒序发送给每个8915A芯片
|
||
{
|
||
write_buffer[write_count] = configDArray[c_ic].tx_data[data];//倒序写入指令
|
||
write_count++;
|
||
}
|
||
}
|
||
BF8915A_write(total_ic, cmd, write_buffer);//写BF8915A命令和写有效载荷数据的通用函数
|
||
}
|
||
|
||
/*!
|
||
\brief Reads the BF8915A CFGRA register(读BF8915A的配置寄存器组A)
|
||
\param[in] total_ic : Number of ICs in the system(系统中IC(8915A)的数量)
|
||
\param[in] configAData: A two dimensional array that the function stores the read configuration data(该函数存储读取的是配置数据的二维数组)
|
||
\retval pec_error
|
||
*/
|
||
uint8_t BF8915A_rdcfga(uint8_t total_ic,
|
||
ConfigA_TypeDef configAData[]
|
||
)
|
||
{
|
||
uint8_t cmd[2]= {0x00U, 0x05U};//发送读BF8915A的配置寄存器组A指令的高低共16位
|
||
//Reg_TypeDef configAArray[TOTAL_IC];//定义一个结构体为Reg_TypeDef的数据结构A数组,用于存储指令数据
|
||
uint8_t read_buffer[256];//存储SPI端口读取的数据的数组
|
||
uint8_t pec_error = 0;//检查检错码
|
||
uint16_t data_pec;//收到的每个配置寄存器组A中的PEC(检错码)
|
||
uint16_t calc_pec;//计算收到的每个配置寄存器组A中指令数据的PEC(检错码)
|
||
uint8_t c_ic = 0;//当前正在读入数组的8915A芯片序号
|
||
uint8_t current_ic = 0;//current_ic is used as the IC counter(当前IC(8915A)用作IC(8915A)计数器)
|
||
uint8_t byte=0;//计数器，每8次一循环，用于计数每个寄存器组A当前循环到的寄存器以及它的PEC(检错码)
|
||
|
||
pec_error = BF8915A_read(total_ic, cmd, read_buffer);//执行写BF8915A命令和读数据，并回传检查错误码是否正确
|
||
|
||
for (current_ic = 0; current_ic<total_ic; current_ic++)//该循环作用为读出每个8915A芯片配置寄存器组A中的指令，并检查是否有错误
|
||
{
|
||
if (isospi_reverse == FALSE)//判断选择的菊花链通信方向是相对正向还是相对反向
|
||
{
|
||
c_ic = current_ic;//选择正序将配置寄存器组A中的指令放入数组
|
||
}
|
||
else
|
||
{
|
||
c_ic = total_ic - current_ic - 1;//选择倒序将配置寄存器组A中的指令放入数组
|
||
}
|
||
|
||
for (byte=0; byte<8; byte++)//若isospi一直为FALSE，则此循环将收到的每个配置寄存器中的数据和它的2字节PEC(检错码)写入接收数组中，接收的是倒序的8915A芯片
|
||
{
|
||
configAArray[c_ic].rx_data[byte] = read_buffer[byte+(8*current_ic)];
|
||
}
|
||
calc_pec = pec15_calc(6,&read_buffer[8*current_ic]);//计算接收回来的寄存器组(6个8位寄存器)中的PEC(检错码)
|
||
data_pec = read_buffer[7+(8*current_ic)] | (read_buffer[6+(8*current_ic)]<<8);//将read_buffer[]中接收到的PEC(检错码)按高低共16位存入data_pec中
|
||
if (calc_pec != data_pec )//检查检错码是否匹配
|
||
{
|
||
configAArray[c_ic].rx_pec_match = 1;//检错码不正确
|
||
}
|
||
else configAArray[c_ic].rx_pec_match = 0;//检错码正确
|
||
}
|
||
for (current_ic = 0; current_ic<total_ic; current_ic++)//该循环作用为存入每个8915A芯片配置寄存器组A中的指令
|
||
{
|
||
configAData[current_ic].gpio_pd_en = configAArray[current_ic].rx_data[0];//CFGAR0的8位，GPIO下拉使能，每一位对应一个IO口
|
||
configAData[current_ic].gpio_analog_en = configAArray[current_ic].rx_data[1];//CFGAR1的8位，GPIO0~7模式选择
|
||
configAData[current_ic].rsvd2 = (BOOLEAN)((configAArray[current_ic].rx_data[2] & 0x08U) == 0x08U);//保留位，永远置0
|
||
configAData[current_ic].rsvd1 = (BOOLEAN)((configAArray[current_ic].rx_data[2] & 0x04U) == 0x04U);//保留位，永远置0
|
||
configAData[current_ic].osr_sel = (BOOLEAN)((configAArray[current_ic].rx_data[2] & 0x02U) == 0x02U);//CFGAR2的第2位,ADC过采样率选择
|
||
configAData[current_ic].refon = (BOOLEAN)((configAArray[current_ic].rx_data[2] & 0x01U) == 0x01U);//CFGAR2的第1位,VREF1(基准电压)配置
|
||
configAData[current_ic].uv_th = (uint16_t)(configAArray[current_ic].rx_data[3]) + (((uint16_t)((configAArray[current_ic].rx_data[4])&0x0FU)) << 0x8U);
|
||
//CFGAR3的8位和CFGAR4的低4位,将CFGAR1的低4位放入12~9位，欠压阈值
|
||
configAData[current_ic].ov_th = (((uint16_t)configAArray[current_ic].rx_data[5]) << 0x4U) + (((configAArray[current_ic].rx_data[4])&0xF0U) >> 0x4U);
|
||
//CFGAR5的8位和CFGAR4的高4位,将CFGAR4的高4位放入12~9位，过压阈值
|
||
configAData[current_ic].rx_pec_match = configAArray[current_ic].rx_pec_match;//每个配置寄存器组A中的检错码是否匹配
|
||
}
|
||
return(pec_error);//回传检查检错码的值
|
||
}
|
||
|
||
/*!
|
||
\brief Reads the BF8915A CFGRB register(读BF8915A的配置寄存器组B)
|
||
\param[in] total_ic : Number of ICs in the system(系统中IC(8915A)的数量)
|
||
\param[in] configBData: A two dimensional array that the function stores the read configuration data(该函数存储读取的是配置数据的二维数组)
|
||
\retval pec_error
|
||
*/
|
||
uint8_t BF8915A_rdcfgb(uint8_t total_ic,
|
||
ConfigB_TypeDef configBData[]
|
||
)
|
||
{
|
||
uint8_t cmd[2]= {0x00 , 0x06};//发送读BF8915A的配置寄存器组B指令的高低共16位
|
||
//Reg_TypeDef configBArray[TOTAL_IC];//定义一个结构体为Reg_TypeDef的数据结构B数组,用于存储指令数据
|
||
uint8_t read_buffer[256];//存储SPI端口读取的数据 的数组
|
||
uint8_t pec_error = 0;//检查检错码
|
||
uint16_t data_pec;//收到的每个配置寄存器组B中的PEC(检错码)
|
||
uint16_t calc_pec;//计算收到的每个配置寄存器组B中指令数据的PEC(检错码)
|
||
uint8_t c_ic = 0;//当前正在读入数组的8915A芯片序号
|
||
uint8_t current_ic = 0;//current_ic is used as the IC counter(当前IC(8915A)用作IC(8915A)计数器)
|
||
uint8_t byte=0; //计数器，每8次一循环，用于计数每个寄存器组B中当前循环到的寄存器以及它的PEC(检错码)
|
||
|
||
pec_error = BF8915A_read(total_ic, cmd, read_buffer);//执行写BF8915A命令和读数据，并回传检查错误码是否正确
|
||
|
||
for (current_ic = 0; current_ic<total_ic; current_ic++)//该循环作用为读出每个8915A芯片配置寄存器组B中的指令，并检查是否有错误
|
||
{
|
||
if (isospi_reverse == FALSE)//判断选择的菊花链通信方向是相对正向还是相对反向
|
||
{
|
||
c_ic = current_ic;//选择正序将配置寄存器组B中的指令放入数组
|
||
}
|
||
else
|
||
{
|
||
c_ic = total_ic - current_ic - 1;//选择倒序将配置寄存器组B中的指令放入数组
|
||
}
|
||
|
||
for (byte=0; byte<8; byte++)//若isospi一直为FALSE，则此循环将收到的每个配置寄存器中的数据和它的2字节PEC(检错码)写入接收数组中，接收的是倒序的8915A芯片
|
||
{
|
||
configBArray[c_ic].rx_data[byte] = read_buffer[byte+(8*current_ic)];
|
||
}
|
||
calc_pec = pec15_calc(6,&read_buffer[8*current_ic]);//计算接收回来的寄存器组(6个8位寄存器)中的PEC(检错码)
|
||
data_pec = read_buffer[7+(8*current_ic)] | (read_buffer[6+(8*current_ic)]<<8);//将read_buffer[]中接收到的PEC(检错码)按高低共16位存入data_pec中
|
||
if (calc_pec != data_pec )//检查检错码是否匹配
|
||
{
|
||
configBArray[c_ic].rx_pec_match = 1;//检错码不正确
|
||
}
|
||
else configBArray[c_ic].rx_pec_match = 0;//检错码正确
|
||
}
|
||
for (current_ic = 0; current_ic<total_ic; current_ic++)//该循环作用为存入每个8915A芯片配置寄存器组B中的指令
|
||
{
|
||
configBData[current_ic].dcc = (((uint16_t)configBArray[current_ic].rx_data[1]) << 0x8U) + configBArray[current_ic].rx_data[0];
|
||
//CFGBR0的8位和CFGBR1的8位,将CFGBR1的8位放入高8位，放电电池开关
|
||
configBData[current_ic].bl_duty_sel = (configBArray[current_ic].rx_data[2] & 0xF0U) >> 0x4U;//CFGBR2的高4位,主动均衡占空比选择
|
||
configBData[current_ic].dcto = configBArray[current_ic].rx_data[2] & 0x0FU;//CFGBR2的低4位,放电定时溢出值配置
|
||
configBData[current_ic].vuv_bl_th = (uint16_t)configBArray[current_ic].rx_data[3] + (((uint16_t)(configBArray[current_ic].rx_data[4] & 0x0F)) << 0x8U);
|
||
//CFGBR3的8位和CFGBR4的低4位,将CFGBR1的低4位放入12~9位，均衡欠压阈值
|
||
configBData[current_ic].dtmen = (BOOLEAN)((configBArray[current_ic].rx_data[4] & 0x10U) == 0x10U);//CFGBR4的第5位,使能放电监测器
|
||
configBData[current_ic].rx_pec_match = configBArray[current_ic].rx_pec_match;//每个配置寄存器组B中的检错码是否匹配
|
||
}
|
||
return(pec_error);//回传检查检错码的值
|
||
}
|
||
|
||
/*!
|
||
\brief Reads the BF8915A CFGRC register(读BF8915A的配置寄存器组C)
|
||
\param[in] total_ic : Number of ICs in the system(系统中IC(8915A)的数量)
|
||
\param[in] configCData: A two dimensional array that the function stores the read configuration data(该函数存储读取的是配置数据的二维数组)
|
||
\retval none
|
||
*/
|
||
uint8_t BF8915A_rdcfgc(uint8_t total_ic,
|
||
ConfigC_TypeDef configCData[]
|
||
)
|
||
{
|
||
uint8_t cmd[2]= {0x00 , 0x07};//发送读BF8915A的配置寄存器组C指令的高低共16位
|
||
//Reg_TypeDef configCArray[TOTAL_IC];//定义一个结构体为Reg_TypeDef的数据结构C数组,用于存储指令数据
|
||
uint8_t read_buffer[256];//存储SPI端口读取的数据 的数组
|
||
uint8_t pec_error = 0;//检查检错码
|
||
uint16_t data_pec;//收到的每个配置寄存器组C中的PEC(检错码)
|
||
uint16_t calc_pec;//计算收到的每个配置寄存器组C中指令数据的PEC(检错码)
|
||
uint8_t c_ic = 0;//当前正在读入数组的8915A芯片序号
|
||
uint8_t current_ic = 0;//current_ic is used as the IC counter(当前IC(8915A)用作IC(8915A)计数器)
|
||
uint8_t byte=0;//计数器，每8次一循环，用于计数每个寄存器组B中当前循环到的寄存器以及它的PEC(检错码)
|
||
|
||
pec_error = BF8915A_read(total_ic, cmd, read_buffer);//执行写BF8915A命令和读数据，并回传检查错误码是否正确
|
||
|
||
for (current_ic = 0; current_ic<total_ic; current_ic++)//该循环作用为读出每个8915A芯片配置寄存器组C中的指令，并检查是否有错误
|
||
{
|
||
if (isospi_reverse == FALSE)//判断选择的菊花链通信方向是相对正向还是相对反向
|
||
{
|
||
c_ic = current_ic;//选择正序将配置寄存器组C中的指令放入数组
|
||
}
|
||
else
|
||
{
|
||
c_ic = total_ic - current_ic - 1;//选择倒序将配置寄存器组C中的指令放入数组
|
||
}
|
||
|
||
for (byte=0; byte<8; byte++)//若isospi一直为FALSE，则此循环将收到的每个配置寄存器中的数据和它的2字节PEC(检错码)写入接收数组中，接收的是倒序的8915A芯片
|
||
{
|
||
configCArray[c_ic].rx_data[byte] = read_buffer[byte+(8*current_ic)];
|
||
}
|
||
calc_pec = pec15_calc(6,&read_buffer[8*current_ic]);//计算接收回来的寄存器组(6个8位寄存器)中的PEC(检错码)
|
||
data_pec = read_buffer[7+(8*current_ic)] | (read_buffer[6+(8*current_ic)]<<8);//将read_buffer[]中接收到的PEC(检错码)按高低共16位存入data_pec中
|
||
if (calc_pec != data_pec )//检查检错码是否匹配
|
||
{
|
||
configCArray[c_ic].rx_pec_match = 1;//检错码不正确
|
||
}
|
||
else configCArray[c_ic].rx_pec_match = 0;//检错码正确
|
||
}
|
||
for (current_ic = 0; current_ic<total_ic; current_ic++)//该循环作用为存入每个8915A芯片配置寄存器组C中的指令
|
||
{
|
||
configCData[current_ic].vuv_m_th = configCArray[current_ic].rx_data[0] + (((uint16_t)(configCArray[current_ic].rx_data[1] & 0x0F)) << 0x8U);
|
||
//CFGCR0的8位和CFGCR1的低4位,将CFGCR1的低4位放入12~9位，监测模式下，欠压阈值
|
||
configCData[current_ic].vov_m_th = (((uint16_t)configCArray[current_ic].rx_data[2]) << 0x4U) + ((configCArray[current_ic].rx_data[1] & 0xF0) >> 0x04U);
|
||
//CFGCR1的高4位和CFGCR2的8位,将CFGCR1高4位放入低4位，将CFGCR2的8位放入12~5位，监测模式下，过压阈值
|
||
configCData[current_ic].itov_m_th = configCArray[current_ic].rx_data[3] + (((uint16_t)(configCArray[current_ic].rx_data[4] & 0x0F)) << 0x8U);
|
||
//CFGBC3的8位和CFGCR1的低4位,将CFGCR4的低4位放入12~9位，监测模式下，内部过温阈值
|
||
configCData[current_ic].extov_m_th = (((uint16_t)configCArray[current_ic].rx_data[5]) << 0x4U) + ((configCArray[current_ic].rx_data[4] & 0xF0) >> 0x04U);
|
||
//CFGCR4的高4位和CFGCR5的8位,将CFGCR4高4位放入低4位，将CFGCR5的8位放入12~5位，监测模式下，外部过温阈值
|
||
configCData[current_ic].rx_pec_match = configCArray[current_ic].rx_pec_match;//每个配置寄存器组C中的检错码是否匹配
|
||
}
|
||
return(pec_error);//回传检查检错码的值
|
||
}
|
||
|
||
/*!
|
||
\brief Reads the BF8915A CFGRD register(读BF8915A的配置寄存器组D)
|
||
\param[in] total_ic : Number of ICs in the system(系统中IC(8915A)的数量)
|
||
\param[in] configDData: A two dimensional array that the function stores the read configuration data(该函数存储读取的是配置数据的二维数组)
|
||
\retval none
|
||
*/
|
||
uint8_t BF8915A_rdcfgd(uint8_t total_ic,
|
||
ConfigD_TypeDef configDData[]
|
||
)
|
||
{
|
||
uint8_t cmd[2]= {0x00 , 0x08};//发送读BF8915A的配置寄存器组D指令的高低共16位
|
||
//Reg_TypeDef configDArray[TOTAL_IC];//定义一个结构体为Reg_TypeDef的数据结构D数组,用于存储指令数据
|
||
uint8_t read_buffer[256] = {0};//存储SPI端口读取的数据 的数组
|
||
uint8_t pec_error = 0;//检查检错码
|
||
uint16_t data_pec;//收到的每个配置寄存器组D中的PEC(检错码)
|
||
uint16_t calc_pec;//计算收到的每个配置寄存器组D中指令数据的PEC(检错码)
|
||
uint8_t c_ic = 0;//当前正在读入数组的8915A芯片序号
|
||
uint8_t current_ic = 0;//current_ic is used as the IC counter(当前IC(8915A)用作IC(8915A)计数器)
|
||
uint8_t byte=0; //计数器，每8次一循环，用于计数每个寄存器组B中当前循环到的寄存器以及它的PEC(检错码)
|
||
|
||
pec_error = BF8915A_read(total_ic, cmd, read_buffer);//执行写BF8915A命令和读数据，并回传检查错误码是否正确
|
||
|
||
for (current_ic = 0; current_ic<total_ic; current_ic++)//该循环作用为读出每个8915A芯片配置寄存器组D中的指令，并检查是否有错误
|
||
{
|
||
if (isospi_reverse == FALSE)//判断选择的菊花链通信方向是相对正向还是相对反向
|
||
{
|
||
c_ic = current_ic;//选择正序将配置寄存器组D中的指令放入数组
|
||
}
|
||
else
|
||
{
|
||
c_ic = total_ic - current_ic - 1;//选择倒序将配置寄存器组D中的指令数组
|
||
}
|
||
|
||
for (byte=0; byte<8; byte++)//若isospi一直为FALSE，则此循环将收到的每个配置寄存器中的数据和它的2字节PEC(检错码)写入接收数组中，接收的是倒序的8915A芯片
|
||
{
|
||
configDArray[c_ic].rx_data[byte] = read_buffer[byte+(8*current_ic)];
|
||
}
|
||
calc_pec = pec15_calc(6,&read_buffer[8*current_ic]);//计算接收回来的寄存器组(6个8位寄存器)中的PEC(检错码)
|
||
data_pec = read_buffer[7+(8*current_ic)] | (read_buffer[6+(8*current_ic)]<<8);//将read_buffer[]中接收到的PEC(检错码)按高低共16位存入data_pec中
|
||
if (calc_pec != data_pec )//检查检错码是否匹配
|
||
{
|
||
configDArray[c_ic].rx_pec_match = 1U;//检错码不正确
|
||
pec_error = 1U;
|
||
}
|
||
else configDArray[c_ic].rx_pec_match = 0;//检错码正确
|
||
}
|
||
for (current_ic = 0; current_ic<total_ic; current_ic++)//该循环作用为存入每个8915A芯片配置寄存器组D中的指令
|
||
{
|
||
configDData[current_ic].csel_m = (((uint16_t)configDArray[current_ic].rx_data[1]) << 0x8U) + configDArray[current_ic].rx_data[0];
|
||
//CFGDR0的8位和CFGDR1的8位,将CFGDR1的8位放入高8位，读出监测模式下，电池电压监测比较选择
|
||
configDData[current_ic].gsel_m = configDArray[current_ic].rx_data[2];//CFGDR2的8位,读出监测模式下，GPIO0~7比较选择
|
||
configDData[current_ic].isospi_wake_t = (BOOLEAN)((configDArray[current_ic].rx_data[3] & 0x80) == 0x80);//CFGDR3的第8位,菊花链SPI的唤醒时间
|
||
configDData[current_ic].adc_rst_sel = (BOOLEAN)((configDArray[current_ic].rx_data[3] & 0x40) == 0x40);//CFGDR3的第7位,测量第1个通道ADC复位选择
|
||
configDData[current_ic].time_sel_m = configDArray[current_ic].rx_data[3] & 0x3F;//CFGDR3的6~1位,监测模式下，定时监测时间配置
|
||
configDData[current_ic].adc_init_t2 = (configDArray[current_ic].rx_data[4] & 0xF0) >> 0x4U;//CFGDR4的高4位,ADC测量第2~n个通道ADC初始化时间
|
||
configDData[current_ic].adc_init_t1 = configDArray[current_ic].rx_data[4] & 0x0F;//CFGDR4的低4位,ADC测量第1个通道ADC初始化时间
|
||
configDData[current_ic].trim2_en = (BOOLEAN)((configDArray[current_ic].rx_data[5] & 0x80) == 0x80U);//CFGDR5的第8位,修调2使能
|
||
configDData[current_ic].trim1_en = (BOOLEAN)((configDArray[current_ic].rx_data[5] & 0x40) == 0x40U);//CFGDR5的第7位,修调1使能
|
||
configDData[current_ic].err_t_sel_m = (configDArray[current_ic].rx_data[5] & 0x30) >> 0x4U; //CFGDR5的第6~5位,监测模式下发生异常，上报的间隔时间
|
||
configDData[current_ic].vd33t_on_m = configDArray[current_ic].rx_data[5] & 0x0F;//CFGDR5的低4位,监测模式下，VREF1和VD33T的启动时间配置
|
||
configDData[current_ic].rx_pec_match = configDArray[current_ic].rx_pec_match;//每个配置寄存器组D中的检错码是否匹配
|
||
}
|
||
return(pec_error);//回传检查检错码的值
|
||
}
|
||
|
||
/*!
|
||
\brief ADCV CMD(电池电压ADC转换指令)
|
||
\param[in] CLKSEL: CLKSEL_2M
|
||
\param[in] OSR : OSR_64 、OSR_128、OSR_256、OSR_512(ADC过采样频率选择:0、1、2、3)
|
||
\param[in] DISCP : DISCP_DISABLE、DISCP_ENABLE(放电允许位:放电允许位写0和1)
|
||
\param[in] CSEL : CSEL_CH_ALL、CSEL_CH_1and9、CSEL_CH_2and10、CSEL_CH_3and11、CSEL_CH_4and12
|
||
CSEL_CH_5and13、CSEL_CH_6and14、CSEL_CH_7and15、CSEL_CH_8and16
|
||
(ADC转换的电池选择:所有电池(0)、电池1和9(1)、电池2和10(2)、电池3和11(3)、电池4和12(4)
|
||
电池5和13(5)、电池6和14(6)、电池7和15(7)、电池8和16(8))
|
||
\retval none
|
||
*/
|
||
void BF8915A_adcv(uint8_t CLKSEL,
|
||
uint8_t OSR,
|
||
uint8_t DISCP,
|
||
uint8_t CSEL
|
||
)
|
||
{
|
||
uint8_t cmd[2] = {0U};//初始化数组cmd[]
|
||
uint8_t clksel_bits = 0x0U;//设置CLKSEL的2个位 的变量
|
||
clksel_bits = (CLKSEL & 0x02) >> 1;//设置CLKSEL[1]
|
||
cmd[0] = clksel_bits + (CMD_ADCV << 0x1U);//发送指令的高8位,#define CMD_ADCV 0x1U
|
||
clksel_bits = (CLKSEL & 0x01) << 7;//设置CLKSEL[0]
|
||
cmd[1] = clksel_bits | (OSR<<5) | (DISCP<<4) | CSEL;//发送指令的低8位,详情请参考规格书中 操作指令配置 ADCV 的指令描述
|
||
BF8915A_cmd(cmd);//编写BF8915A命令的通用函数。函数为cmd数据计算了检错码
|
||
}
|
||
|
||
/*!
|
||
\brief CVST CMD(电池电压自测试命令)
|
||
\param[in] CLKSEL: CLKSEL_2M
|
||
\param[in] OSR : OSR_64 、OSR_128、OSR_2566、OSR_512(ADC过采样频率选择:0、1、2、3)
|
||
\param[in] SFTEST: SELFTEST_6666 SELFTEST_9999(自测试模式选择:自测试1 自测试2)
|
||
\retval none
|
||
*/
|
||
void BF8915A_cvst(uint8_t CLKSEL,
|
||
uint8_t OSR,
|
||
uint8_t SFTEST
|
||
)
|
||
{
|
||
uint8_t cmd[2] = {0U};//初始化数组cmd[]
|
||
uint8_t clksel_bits = 0x0U;//设置CLKSEL的2个位 的变量
|
||
clksel_bits = (CLKSEL & 0x02) >> 1;//设置CLKSEL[1]
|
||
cmd[0] = clksel_bits + (CMD_CVST << 0x1U);//发送指令的高8位,#define CMD_CVST 0x03U
|
||
clksel_bits = (CLKSEL & 0x01) << 7;//设置CLKSEL[0]
|
||
cmd[1] = clksel_bits | (OSR<<5) | (SFTEST<<4);//发送指令的低8位,详情请参考规格书中 操作指令配置 CVST 的指令描述
|
||
BF8915A_cmd(cmd);//编写BF8915A命令的通用函数。函数为cmd数据计算了检错码
|
||
}
|
||
|
||
/*!
|
||
\brief ADOL CMD(电池重叠单元测量指令)
|
||
\param[in] CLKSEL: CLKSEL_2M
|
||
\param[in] OSR : OSR_64 、OSR_128、OSR_256、OSR_512(ADC过采样频率选择:0、1、2、3)
|
||
\param[in] DISCP : DISCP_DISABLE、DISCP_ENABLE (放电允许位:放电允许位写0和1)
|
||
\retval none
|
||
*/
|
||
void BF8915A_adol(uint8_t CLKSEL,
|
||
uint8_t OSR,
|
||
uint8_t DISCP
|
||
)
|
||
{
|
||
uint8_t cmd[2] = {0U};//初始化数组cmd[]
|
||
uint8_t clksel_bits = 0x0U;//设置CLKSEL的2个位 的变量
|
||
clksel_bits = (CLKSEL & 0x02) >> 1;//设置CLKSEL[1]
|
||
cmd[0] = clksel_bits + (CMD_ADOL << 0x1U);//发送指令的高8位,#define CMD_ADOL 0x04U
|
||
clksel_bits = (CLKSEL & 0x01) << 7;//设置CLKSEL[0]
|
||
cmd[1] = clksel_bits | (OSR<<5) | (DISCP<<4) | 0x01U;//发送指令的低8位,详情请参考规格书中 操作指令配置 ADOL 的指令描述
|
||
BF8915A_cmd(cmd);//编写BF8915A命令的通用函数。函数为cmd数据计算了检错码
|
||
}
|
||
|
||
/*!
|
||
\brief ADGP CMD(GPIO ADC转换指令)
|
||
\param[in] CLKSEL: CLKSEL_2M
|
||
\param[in] OSR : OSR_64 、OSR_128、OSR_256、OSR_512(ADC过采样频率选择)
|
||
\param[in] GSEL : GSEL_CH_ALL、 GSEL_CH_GPIO0、GSEL_CH_GPIO1、GSEL_CH_GPIO2、GSEL_CH_GPIO3
|
||
GSEL_CH_VD33T、GSEL_CH_GPIO4、GSEL_CH_GPIO5、GSEL_CH_GPIO6、GSEL_CH_GPIO7
|
||
(ADC转换的GPIO选择 :所有GPIO0~GPIO7,VD33T、GPIO0、GPIO1、GPIO2、GPIO3
|
||
VD33T、GPIO4、GPIO5、GPIO6、GPIO7)
|
||
|
||
\retval none
|
||
*/
|
||
void BF8915A_adgp(uint8_t CLKSEL,
|
||
uint8_t OSR,
|
||
uint8_t GSEL
|
||
)
|
||
{
|
||
uint8_t cmd[2] = {0U};//初始化数组cmd[]
|
||
uint8_t clksel_bits = 0x0U;//设置CLKSEL的2个位 的变量
|
||
clksel_bits = (CLKSEL & 0x02) >> 1;//设置CLKSEL[1]
|
||
cmd[0] = clksel_bits + (CMD_ADGP << 0x1U);//发送指令的高8位,#define CMD_ADGP 0x05U
|
||
clksel_bits = (CLKSEL & 0x01) << 7;//设置CLKSEL[0]
|
||
cmd[1] = clksel_bits | (OSR<<5) | GSEL;//发送指令的低8位,详情请参考规格书中 操作指令配置 ADGP 的指令描述
|
||
BF8915A_cmd(cmd);//编写BF8915A命令的通用函数。函数为cmd数据计算了检错码
|
||
}
|
||
|
||
/*!
|
||
\brief GPST CMD(GPIO输入自测试指令)
|
||
\param[in] CLKSEL: CLKSEL_2M
|
||
\param[in] OSR : OSR_64 、OSR_128、OSR_256、OSR_512(ADC过采样频率选择:0、1、2、3)
|
||
\param[in] SFTEST: SELFTEST_6666 SELFTEST_9999(自测试模式选择:自测试1 自测试2)
|
||
\retval none
|
||
*/
|
||
void BF8915A_gpst(uint8_t CLKSEL,
|
||
uint8_t OSR,
|
||
uint8_t SFTEST
|
||
)
|
||
{
|
||
uint8_t cmd[2] = {0U};//初始化数组cmd[]
|
||
uint8_t clksel_bits = 0x0U;//设置CLKSEL的2个位 的变量
|
||
clksel_bits = (CLKSEL & 0x02) >> 1;//设置CLKSEL[1]
|
||
cmd[0] = clksel_bits + (CMD_GPST << 0x1U);//发送指令的高8位,#define CMD_GPST 0x07U
|
||
clksel_bits = (CLKSEL & 0x01) << 7;//设置CLKSEL[0]
|
||
cmd[1] = clksel_bits | (OSR<<5) | (SFTEST<<4);//发送指令的低8位,详情请参考规格书中 操作指令配置 GPST 的指令描述
|
||
BF8915A_cmd(cmd);//编写BF8915A命令的通用函数。函数为cmd数据计算了检错码
|
||
}
|
||
|
||
/*!
|
||
\brief ADSTAT CMD(测量内部设备参数指令)
|
||
\param[in] CLKSEL: CLKSEL_2M
|
||
\param[in] OSR : OSR_64 、OSR_128、OSR_256、OSR_512(ADC过采样频率选择:0、1、2、3)
|
||
\param[in] STSEL : STATA、STATB、STATC、STATD(ADC转换的内部参数选择)
|
||
\retval none
|
||
*/
|
||
void BF8915A_adstat(uint8_t CLKSEL,
|
||
uint8_t OSR,
|
||
uint8_t STSEL
|
||
)
|
||
{
|
||
uint8_t cmd[2] = {0U};//初始化数组cmd[]
|
||
uint8_t clksel_bits = 0x0U;//设置CLKSEL的2个位 的变量
|
||
clksel_bits = (CLKSEL & 0x02) >> 1;//设置CLKSEL[1]
|
||
cmd[0] = clksel_bits + (CMD_ADSTAT << 0x1U);//发送指令的高8位,#define CMD_ADSTAT 0x08U
|
||
clksel_bits = (CLKSEL & 0x01) << 7;//设置CLKSEL[0]
|
||
cmd[1] = clksel_bits | (OSR<<5) | STSEL;//发送指令的低8位,详情请参考规格书中 操作指令配置 ADSTAT 的指令描述
|
||
BF8915A_cmd(cmd);//编写BF8915A命令的通用函数。函数为cmd数据计算了检错码
|
||
}
|
||
|
||
/*!
|
||
\brief STATST CMD(自测试内部设备参数指令)
|
||
\param[in] CLKSEL: CLKSEL_2M
|
||
\param[in] OSR : OSR_64 、OSR_128、OSR_256、OSR_512(ADC过采样频率选择:0、1、2、3)
|
||
\param[in] SFTEST: SELFTEST_6666 SELFTEST_9999(自测试模式选择:自测试1 自测试2)
|
||
\retval none
|
||
*/
|
||
void BF8915A_statst(uint8_t CLKSEL,
|
||
uint8_t OSR,
|
||
uint8_t SFTEST
|
||
)
|
||
{
|
||
uint8_t cmd[2] = {0U};//初始化数组cmd[]
|
||
uint8_t clksel_bits = 0x0U;//设置CLKSEL 位 的变量
|
||
clksel_bits = (CLKSEL & 0x02) >> 1;//设置CLKSEL[1]
|
||
cmd[0] = clksel_bits + (CMD_STATST << 0x1U);//发送指令的高8位,#define CMD_STATST 0x09U
|
||
clksel_bits = (CLKSEL & 0x01) << 7;//设置CLKSEL[0]
|
||
cmd[1] = clksel_bits | (OSR<<5) | (SFTEST<<4);//发送指令的低8位,详情请参考规格书中 操作指令配置 CMD_STATST 的指令描述
|
||
BF8915A_cmd(cmd);//编写BF8915A命令的通用函数。函数为cmd数据计算了检错码
|
||
}
|
||
|
||
/*!
|
||
\brief ADCVGP CMD(测量电池电压和GPIO输入指令)
|
||
\param[in] CLKSEL: CLKSEL_2M
|
||
\param[in] OSR : OSR_64 、OSR_128、OSR_256、OSR_512(ADC过采样频率选择:0、1、2、3)
|
||
\param[in] DISCP : DISCP_DISABLE、DISCP_ENABLE(放电允许位:放电允许位写0和1)
|
||
\retval none
|
||
*/
|
||
void BF8915A_adcvgp(uint8_t CLKSEL,
|
||
uint8_t OSR,
|
||
uint8_t DISCP
|
||
)
|
||
{
|
||
uint8_t cmd[2] = {0U};//初始化数组cmd[]
|
||
uint8_t clksel_bits = 0x0U;//设置CLKSEL的2个位 的变量
|
||
clksel_bits = (CLKSEL & 0x02) >> 1;//设置CLKSEL[1]
|
||
cmd[0] = clksel_bits + (CMD_ADCVGP << 0x1U);//发送指令的高8位,#define CMD_ADCVGP 0x0aU
|
||
clksel_bits = (CLKSEL & 0x01) << 7;//设置CLKSEL[0]
|
||
cmd[1] = clksel_bits | (OSR<<5) | (DISCP<<4);//发送指令的低8位,详情请参考规格书中 操作指令配置 CMD_ADCVGP 的指令描述
|
||
BF8915A_cmd(cmd);//编写BF8915A命令的通用函数。函数为cmd数据计算了检错码
|
||
}
|
||
|
||
/*!
|
||
\brief MNT CMD(监测指令)
|
||
\param[in] CLKSEL: CLKSEL_2M
|
||
\param[in] OSR : OSR_64 、OSR_128、OSR_256、OSR_512(ADC过采样频率选择:0、1、2、3)
|
||
\param[in] MNMOD : MNMOD_DISABLE、MNMOD_1、MNMOD_2、MNMOD_3(监测模式选择:不进入监测模式，指令无效(00)、模式1(01)、模式2(02)、模式3(03))
|
||
\param[in] STRMN : STRMN_ENABLE、STRMN_DISABLE(监测模式使能:开启监测模式(1)、关闭监测模式(2))
|
||
\param[in] BLEN : BLEN_ON、BLEN_OFF (均衡开关总控制信号2:关闭(0)、开启(1))
|
||
\retval none
|
||
*/
|
||
void BF8915A_mnt(uint8_t CLKSEL,
|
||
uint8_t OSR,
|
||
uint8_t MNMOD,
|
||
uint8_t STRMN,
|
||
uint8_t BLEN
|
||
)
|
||
{
|
||
uint8_t cmd[2] = {0U};//初始化数组cmd[]
|
||
uint8_t clksel_bits = 0x0U;//设置CLKSEL的2个 位的变量
|
||
clksel_bits = (CLKSEL & 0x02) >> 1;//设置CLKSEL[1]
|
||
cmd[0] = clksel_bits + (CMD_MNT << 0x1U);//发送指令的高8位,#define CMD_MNT 0x0cU
|
||
clksel_bits = (CLKSEL & 0x01) << 7;//设置CLKSEL[0]
|
||
cmd[1] = clksel_bits | (OSR<<5) | (MNMOD<<3) | (STRMN << 2) | BLEN ;//发送指令的低8位,详情请参考规格书中 操作指令配置 CMD_MNT 的指令描述
|
||
BF8915A_cmd(cmd);//编写BF8915A命令的通用函数。函数为cmd数据计算了检错码
|
||
}
|
||
|
||
/*!
|
||
\brief STRBL CMD(被动均衡指令)
|
||
\param[in] CLKSEL: CLKSEL_2M
|
||
\param[in] OSR : OSR_64 、OSR_128、OSR_256、OSR_512(ADC过采样频率选择)
|
||
\param[in] OESEL : OESEL_ODD、OESEL_EVEN (均衡放电电池奇偶选择:奇数节(0)、偶数节(1))
|
||
\param[in] BLEN : BLEN_ON、BLEN_OFF(均衡开关总控制信号 2:开启(1)、关闭(0))
|
||
\retval none
|
||
*/
|
||
void BF8915A_strbl(uint8_t CLKSEL,
|
||
uint8_t OSR,
|
||
uint8_t OESEL,
|
||
uint8_t BLEN
|
||
)
|
||
{
|
||
uint8_t cmd[2] = {0U};//初始化数组cmd[]
|
||
uint8_t clksel_bits = 0x0U;//设置CLKSEL的2个位 的变量
|
||
clksel_bits = (CLKSEL & 0x02) >> 1;//设置CLKSEL[1]
|
||
cmd[0] = clksel_bits + (CMD_STRBL << 0x1U);//发送指令的高8位,#define CMD_STRBL 0x0dU
|
||
clksel_bits = (CLKSEL & 0x01) << 7;//设置CLKSEL[0]
|
||
cmd[1] = clksel_bits | (OSR<<5) | (OESEL<<4) | BLEN;//发送指令的低8位,详情请参考规格书中 操作指令配置 CMD_STRBL 的指令描述
|
||
BF8915A_cmd(cmd);//编写BF8915A命令的通用函数。函数为cmd数据计算了检错码
|
||
}
|
||
|
||
|
||
/*!
|
||
\brief Reads the raw cell voltage register data(读取原始电池电压寄存器数据)
|
||
\param[in] reg : Determines which register is read back(确定回读哪个电池电压寄存器)
|
||
\param[in] total_ic: the Number of ICs in the system(系统中IC(8915A)的数量)
|
||
\param[in] cellData: Array of the unparsed codes(未解析代码的数组)
|
||
\retval none
|
||
*/
|
||
void BF8915A_rdcv_reg(uint8_t reg, //Determines which cell voltage register is read back(确定回读哪个电池电压寄存器)
|
||
uint8_t total_ic,
|
||
uint8_t *cellData
|
||
)
|
||
{
|
||
const uint8_t REG_LEN = 8; //number of 6 bytes in each ICs register + 2 bytes for the PEC(每个集成电路寄存器中的6字节数加PEC(检错码)的2个字节)
|
||
uint8_t cmd[4];//初始化数组cmd[]
|
||
uint16_t cmd_pec;//计算出发送指令的PEC(检错码)
|
||
cmd[0] = 0x00;//发送指令的高8位
|
||
cmd[1] = reg + 0x08U;//发送指令的低8位，详情在8915A.h文件中 电池电压寄存器对应的命令
|
||
cmd_pec = pec15_calc(2, cmd);//计算出发送指令的PEC(检错码)
|
||
cmd[2] = (uint8_t)(cmd_pec >> 8);//发送指令的PEC(检错码)的高八位
|
||
cmd[3] = (uint8_t)(cmd_pec);//发送指令的PEC(检错码)的低八位
|
||
|
||
if (isospi_reverse == FALSE)//判断选择的菊花链通信方向是相对正向还是相对反向
|
||
{
|
||
cs_low();//将片选CS设置为低电平
|
||
spi_write_read(cmd,4,cellData,(REG_LEN*total_ic));//使用SPI端口写入和读取设定数量的字节
|
||
cs_high();//将片选CS设置为高电平
|
||
}
|
||
else
|
||
{
|
||
cs_low_reverse();//将片选CS设置为低电平
|
||
spi_write_read(cmd,4,cellData,(REG_LEN*total_ic));//使用SPI端口写入和读取设定数量的字节
|
||
cs_high_reverse();//将片选CS设置为高电平
|
||
}
|
||
}
|
||
|
||
/*!
|
||
\brief reads BF8915A GPIO registers(读取BF8915A的GPIO寄存器)
|
||
The function reads a single GPIO voltage register and stores the read data in the *data point as a byte array.
|
||
This function is rarely used outside of the BF8915A_rdgv() command.
|
||
(该函数读取单个GPIO电压寄存器，并将读取的数据作为字节数组存储在*data数据中。此功能很少在BF8915A_rdgv()命令之外使用。)
|
||
\param[in] reg : Determines which register is read back(确定回读哪个电池电压寄存器)
|
||
\param[in] total_ic: the Number of ICs in the system(系统中IC(8915A)的数量)
|
||
\param[in] gpioData: Array of the unparsed codes(未解析代码的数组)
|
||
\retval none
|
||
*/
|
||
void BF8915A_rdgv_reg(uint8_t reg,
|
||
uint8_t total_ic,
|
||
uint8_t *gpioData
|
||
)
|
||
{
|
||
const uint8_t REG_LEN = 8; // number of 6 bytes in the register + 2 bytes for the PEC(寄存器中的6字节数加上PEC(检错码)的2个字节)
|
||
uint8_t cmd[4];//初始化数组cmd[]
|
||
uint16_t cmd_pec;//计算出发送指令的PEC(检错码)
|
||
cmd[0] = 0x00;//发送指令的高8位
|
||
cmd[1] = reg + 0x0EU;//发送指令的低8位，详情在8915A.h文件中 GPIOG电压
|
||
cmd_pec = pec15_calc(2, cmd);//计算出发送指令的PEC(检错码)
|
||
cmd[2] = (uint8_t)(cmd_pec >> 8);//发送指令的PEC(检错码)的高八位
|
||
cmd[3] = (uint8_t)(cmd_pec);//发送指令的PEC(检错码)的低八位
|
||
|
||
if (isospi_reverse == FALSE)//判断选择的菊花链通信方向是相对正向还是相对反向
|
||
{
|
||
cs_low();//将片选CS设置为低电平
|
||
spi_write_read(cmd,4,gpioData,(REG_LEN*total_ic));//使用SPI端口写入和读取设定数量的字节
|
||
cs_high();//将片选CS设置为高电平
|
||
}
|
||
else
|
||
{
|
||
cs_low_reverse();//将片选CS设置为低电平
|
||
spi_write_read(cmd,4,gpioData,(REG_LEN*total_ic));//使用SPI端口写入和读取设定数量的字节
|
||
cs_high_reverse();//将片选CS设置为高电平
|
||
}
|
||
}
|
||
|
||
/*!
|
||
\brief Reads BF8915A stat registers(读取BF8915A状态寄存器)
|
||
\param[in] reg : Determines which register is read back(确定回读哪个寄存器)
|
||
\param[in] total_ic: the Number of ICs in the system(系统中IC(8915A)的数量)
|
||
\param[in] statData: Array of the unparsed codes(未解析代码的数组)
|
||
\retval none
|
||
*/
|
||
void BF8915A_rdstat_reg(uint8_t reg,
|
||
uint8_t total_ic,
|
||
uint8_t *statData
|
||
)
|
||
{
|
||
const uint8_t REG_LEN = 8;//number of 6 bytes in the register + 2 bytes for the PEC(寄存器中的6字节数加上PEC(检错码)的2个字节)
|
||
uint8_t cmd[4];//初始化数组cmd[]
|
||
uint16_t cmd_pec;//计算出发送指令的PEC(检错码)
|
||
cmd[0] = 0x00;//发送指令的高8位
|
||
cmd[1] = reg + 0x11;//发送指令的低8位，详情在8915A.h文件中 状态寄存器RDSTAT
|
||
cmd_pec = pec15_calc(2, cmd);//计算出发送指令的PEC(检错码)
|
||
cmd[2] = (uint8_t)(cmd_pec >> 8);//发送指令的PEC(检错码)的高八位
|
||
cmd[3] = (uint8_t)(cmd_pec);//发送指令的PEC(检错码)的低八位
|
||
|
||
if (isospi_reverse == FALSE)//判断选择的菊花链通信方向是相对正向还是相对反向
|
||
{
|
||
cs_low();//将片选CS设置为低电平
|
||
spi_write_read(cmd,4,statData,(REG_LEN*total_ic));//使用SPI端口写入和读取设定数量的字节
|
||
cs_high();//将片选CS设置为高电平
|
||
}
|
||
else
|
||
{
|
||
cs_low_reverse();//将片选CS设置为低电平
|
||
spi_write_read(cmd,4,statData,(REG_LEN*total_ic));//使用SPI端口写入和读取设定数量的字节
|
||
cs_high_reverse();//将片选CS设置为高电平
|
||
}
|
||
}
|
||
|
||
/*!
|
||
\brief Helper function that parses voltage measurement registers(解析电压测量寄存器的辅助函数)
|
||
\param[in] current_ic: Number of ics in current cycle(当前循环的IC(8915A)数)
|
||
\param[in] cell_reg : Controls which cell voltage register is read back(控制回读哪个单体电压寄存器)
|
||
\param[in] cell_data : Number of bytes of data received(接收到数据的字节数，6个数据+2个PEC(检错码))
|
||
\param[in] cell_codes: cell voltage value(电池电压值)
|
||
\param[in] ic_pec : If a PEC error was detected during most recent read cmd(如果在最近的读取cmd(指令)期间检测到PEC(检错码)错误)
|
||
\retval pec_error
|
||
*/
|
||
uint8_t parse_cells(uint8_t current_ic,
|
||
uint8_t cell_reg,
|
||
uint8_t cell_data[],
|
||
uint16_t *cell_codes,
|
||
uint8_t *ic_pec
|
||
)
|
||
{
|
||
const uint8_t BYT_IN_REG = 6;//寄存器组中的6个8位寄存器
|
||
uint8_t CELL_IN_REG = 3;//每个电压寄存器组中的 3个电压值
|
||
uint8_t pec_error = 0;//检查检错码
|
||
uint16_t parsed_cell;//单个电压值
|
||
uint16_t received_pec;//收到的每个寄存器组中的PEC(检错码)
|
||
uint16_t data_pec;//计算收到的每个寄存器组中指令数据的PEC(检错码)
|
||
uint8_t data_counter = current_ic*NUM_RX_BYT; //data counter(数据计数器)
|
||
uint8_t current_cell = 0;//每个电压寄存器组当前循环到的单体电池电压
|
||
|
||
for (current_cell = 0; current_cell < CELL_IN_REG; current_cell++) // This loop parses the read back data into cell voltages, it loops once for each of the 3 cell voltage codes in the register
|
||
{ //(这个循环将读回的数据解析成电压，对寄存器中的每3个电压码循环一次)
|
||
parsed_cell = cell_data[data_counter] + ((uint16_t)cell_data[data_counter + 1] << 8);//Each cell codes is received as two bytes and is combined to create the parsed cell voltage code
|
||
//(每个电压代码被接收为两个字节，并且被组合以创建解析的单体电压代码)
|
||
cell_codes[current_cell + ((cell_reg - 1) * CELL_IN_REG)] = parsed_cell;//将解析出的单个电压码依次存放在数组cell_codes[]中
|
||
data_counter = data_counter + 2;//Because cell voltage codes are two bytes the data counter must increment by two for each parsed cell code
|
||
//(因为单体电压码是两个字节，所以对于每个解析的电池码，数据计数器必须增加2)
|
||
if(cell_reg == CVFR)//#define CVFR 0x06U
|
||
{
|
||
current_cell = 0x3U;//存放电池电压的结构体数组有16个元素，此处代码为了防止数组解析CVFR(电池电压寄存器组F)时，数组溢出问题
|
||
}
|
||
}
|
||
if(cell_reg == CVFR)//若寄存器为CVFR，则只需循环一次即可跳出循环
|
||
{
|
||
data_counter = data_counter + 4;
|
||
}
|
||
received_pec = (cell_data[data_counter] << 8) | cell_data[data_counter+1]; //The received PEC for the current_ic is transmitted as the 7th and 8th after the 6 cell voltage data bytes
|
||
//(接收到的current_ic(当前IC(8915A)数量)的PEC(检错码)作为6个单体电压数据字节之后的第7个和第8个字节发送)
|
||
data_pec = pec15_calc(BYT_IN_REG, &cell_data[(current_ic) * NUM_RX_BYT]);//计算接收回来的寄存器组(6个8位寄存器)中的PEC(检错码)
|
||
|
||
if (received_pec != data_pec)//检查检错码是否匹配
|
||
{
|
||
pec_error = 1; //The pec_error variable is simply set 1 if any PEC errors(如果有任何pec错误，pec_error变量简单地设置为1)
|
||
ic_pec[cell_reg-1]=1;//将cellVoltage[c_ic].pec_match[0]中的值置1
|
||
}
|
||
else
|
||
{
|
||
ic_pec[cell_reg-1]=0;//检错码正确，将cellVoltage[c_ic].pec_match[0]中的值置0
|
||
}
|
||
data_counter=data_counter+2;//Because the transmitted PEC code is 2 bytes long the data_counter must be incremented by 2 bytes to point to the next ICs state voltage data
|
||
//(因为传输的PEC(检错码)代码是2字节长，所以数据计数器必须增加2字节才能指向下一个8915A状态电压数据)
|
||
return(pec_error);//回传检查检错码的值
|
||
}
|
||
|
||
/*!
|
||
\brief Reads and parses the BF8915A cell voltage registers(读取并解析BF8915A电池电压寄存器)
|
||
\param[in] reg : Controls which cell voltage register is read back(控制回读哪个电池电压寄存器)
|
||
\param[in] total_ic : the Number of ICs in the system(系统中IC(8915A)的数量)
|
||
\param[in] CellVoltage_TypeDef: CellVoltage Struct(电池电压结构)
|
||
\retval the time of pec_error(pec_error的数)
|
||
*/
|
||
uint8_t BF8915A_rdcv(uint8_t reg,
|
||
uint8_t total_ic,
|
||
CellVoltage_TypeDef *cellVoltage
|
||
)
|
||
{
|
||
uint8_t pec_error = 0;//检查检错码
|
||
uint8_t *cell_data;//初始化一个8位的指针cell_data
|
||
uint8_t c_ic = 0;//当前正在读入数组的8915A芯片序号
|
||
uint8_t cell_reg = 1;//电池电压寄存器计数器
|
||
uint8_t current_ic = 0;//current_ic is used as the IC counter(当前IC(8915A)用作IC(8915A)计数器)
|
||
cell_data = (uint8_t *) malloc((NUM_RX_BYT*total_ic)*sizeof(uint8_t));//#define NUM_RX_BYT 0x8U(接收到数据的字节数，6个字节数据+2个PEC(检错码)字节)
|
||
|
||
if (reg == 0)//如果选择读取所有电池电压
|
||
{
|
||
for (cell_reg = 1; cell_reg < NUM_CV_REG + 1; cell_reg++) //#define NUM_CV_REG 6U,对每个BF8915A电池电压寄存器执行一次
|
||
{
|
||
BF8915A_rdcv_reg(cell_reg, total_ic,cell_data );//读取原始电池电压寄存器数据
|
||
for (current_ic = 0; current_ic < total_ic; current_ic++)//该循环作用为读取并解析每个BF8915A所选择的电池电压寄存器
|
||
{
|
||
if (isospi_reverse == FALSE)//判断选择的菊花链通信方向是相对正向还是相对反向
|
||
{
|
||
c_ic = current_ic;//选择正序将电池电压放入数组
|
||
}
|
||
else
|
||
{
|
||
c_ic = total_ic - current_ic - 1;//选择倒序将电池电压放入数组
|
||
}
|
||
pec_error = pec_error + parse_cells(current_ic,cell_reg, cell_data,
|
||
&cellVoltage[c_ic].cellVoltage[0],
|
||
&cellVoltage[c_ic].pec_match[0]);//解析电压测量寄存器的辅助函数,并回传检查检错码的值
|
||
}
|
||
}
|
||
}
|
||
|
||
else//如果不选择读取所有电池电压
|
||
{
|
||
BF8915A_rdcv_reg(reg, total_ic,cell_data);//读取原始电池电压寄存器数据
|
||
|
||
for (current_ic = 0; current_ic<total_ic; current_ic++)//该循环作用为读取并解析每个BF8915A所选择的电池电压寄存器
|
||
{
|
||
if (isospi_reverse == FALSE)//判断选择的菊花链通信方向是相对正向还是相对反向
|
||
{
|
||
c_ic = current_ic;//选择正序将电池电压放入数组
|
||
}
|
||
else
|
||
{
|
||
c_ic = total_ic - current_ic - 1;//选择倒序将电池电压放入数组
|
||
}
|
||
pec_error = pec_error + parse_cells(current_ic,reg, cell_data,
|
||
&cellVoltage[c_ic].cellVoltage[0],
|
||
&cellVoltage[c_ic].pec_match[0]);//解析电压测量寄存器的辅助函数,并回传检查检错码的值
|
||
}
|
||
}
|
||
free(cell_data);//清空指针
|
||
return(pec_error);//回传检查检错码的值
|
||
}
|
||
|
||
/*!
|
||
\brief Reads and parses the BF8915A GPIO registers(读取并解析BF8915A GPIO寄存器)
|
||
\param[in] reg : Determines which GPIO voltage register is read back(确定回读哪个GPIO电压寄存器)
|
||
\param[in] total_ic : the Number of ICs in the system(系统中IC(8915A)的数量)
|
||
\param[in] gpioVoltage: A two dimensional array of the gpio voltage codes(GPIO电压的二维数组)
|
||
\retval pec_error
|
||
*/
|
||
uint8_t BF8915A_rdgv(uint8_t reg,
|
||
uint8_t total_ic,
|
||
GPIOReg_TypeDef *gpioVoltage
|
||
)
|
||
{
|
||
uint8_t *dataPtr;//初始化一个8位的指针dataPtr
|
||
uint8_t pec_error = 0;//检查检错码
|
||
uint8_t c_ic =0;//当前正在读入数组的8915A芯片序号
|
||
uint8_t gpio_reg = 1;//GPIO寄存器计数器
|
||
uint8_t current_ic = 0;//current_ic is used as the IC counter(当前IC(8915A)用作IC(8915A)计数器)
|
||
dataPtr = (uint8_t *) malloc((NUM_RX_BYT*total_ic)*sizeof(uint8_t));//计算指针dataPtr需要接收的长度
|
||
//#define NUM_RX_BYT 0x8U(接收到数据的字节数，6个字节数据+2个PEC(检错码)字节)
|
||
if (reg == 0)//如果选择读取所有GPIO电压寄存器
|
||
{
|
||
for (gpio_reg = 1; gpio_reg < NUM_GOIO_REG + 1; gpio_reg++) //#define NUM_STAT_REG 3U,对每个BF8915A的GPIO电压寄存器执行一次
|
||
{
|
||
BF8915A_rdgv_reg(gpio_reg, total_ic,dataPtr);//Reads the raw gpio register data into the data[] array(将原始GPIO寄存器数据读入data[]数组)
|
||
for (current_ic = 0; current_ic<total_ic; current_ic++)//该循环作用为读取并解析每个BF8915A所选择的GPIO电压寄存器
|
||
{
|
||
if (isospi_reverse == FALSE)//判断选择的菊花链通信方向是相对正向还是相对反向
|
||
{
|
||
c_ic = current_ic;//选择正序将GPIO电压放入数组
|
||
}
|
||
else
|
||
{
|
||
c_ic = total_ic - current_ic - 1;//选择倒序将GPIO电压放入数组
|
||
}
|
||
pec_error = parse_cells(current_ic,gpio_reg, dataPtr,
|
||
&gpioVoltage[c_ic].gpioVoltage[0],
|
||
&gpioVoltage[c_ic].pec_match[0]);//解析电压测量寄存器的辅助函数,并回传检查检错码的值
|
||
}
|
||
}
|
||
}
|
||
else//如果不选择读取所有GPIO电压寄存器
|
||
{
|
||
BF8915A_rdgv_reg(reg, total_ic, dataPtr);//Reads the raw gpio register data into the data[] array(将原始GPIO寄存器数据读入data[]数组)
|
||
|
||
for (current_ic = 0; current_ic<total_ic; current_ic++)//该循环作用为读取并解析每个BF8915A所选择的GPIO电压寄存器
|
||
{
|
||
if (isospi_reverse == FALSE)//判断选择的菊花链通信方向是相对正向还是相对反向
|
||
{
|
||
c_ic = current_ic;//选择正序将GPIO电压放入数组
|
||
}
|
||
else
|
||
{
|
||
c_ic = total_ic - current_ic - 1;//选择倒序将GPIO电压放入数组
|
||
}
|
||
pec_error = parse_cells(current_ic,reg, dataPtr,
|
||
&gpioVoltage[c_ic].gpioVoltage[0],
|
||
&gpioVoltage[c_ic].pec_match[0]);//解析电压测量寄存器的辅助函数,并回传检查检错码的值
|
||
}
|
||
|
||
}
|
||
free(dataPtr);//清空指针
|
||
return (pec_error);//回传检查检错码的值
|
||
}
|
||
|
||
/*!
|
||
\brief Reads and parses the BF8915A stat registers(读取和解析BF8915A状态寄存器)
|
||
\param[in] reg : Determines which Stat register is read back(确定回读哪个状态寄存器)
|
||
\param[in] total_ic : the Number of ICs in the system(系统中IC(8915A)的数量)
|
||
\param[in] StateReg_TypeDef: A two dimensional array of the state codes(状态寄存器的二维数组)
|
||
\retval pec_error
|
||
*/
|
||
uint8_t BF8915A_rdstat(uint8_t reg,
|
||
uint8_t total_ic,
|
||
StateReg_TypeDef *stateReg
|
||
)
|
||
|
||
{
|
||
const uint8_t BYT_IN_REG = 6;//寄存器组中的6个8位寄存器
|
||
const uint8_t GPIO_IN_REG = 3;//每个寄存器组中的 3个电压值
|
||
|
||
uint8_t *dataPtr;//初始化一个8位的指针dataPtr
|
||
uint8_t data_counter = 0;//data counter(数据计数器)
|
||
uint8_t pec_error = 0;//检查检错码
|
||
uint16_t parsed_stat;//单个状态值
|
||
uint16_t received_pec;//收到的每个寄存器组中的PEC(检错码)
|
||
uint16_t data_pec;//计算收到的每个寄存器组中指令数据的PEC(检错码)
|
||
uint8_t c_ic = 0;//当前正在读入数组的8915A芯片序号
|
||
uint8_t stat_reg = 1;//当前正在读取的状态寄存器组
|
||
uint8_t current_ic = 0;//current_ic is used as the IC counter(当前IC(8915A)用作IC(8915A)计数器)
|
||
uint8_t current_gpio = 0;//当前正在读入的电压值
|
||
uint8_t stateD_byte = 0;//状态寄存器的字节计数器
|
||
uint8_t stateD_bit = 0;//状态寄存器的位计数器
|
||
dataPtr = (uint8_t *) malloc((NUM_RX_BYT*total_ic)*sizeof(uint8_t));//计算指针dataPtr需要接收的长度
|
||
|
||
if (reg == 0)//如果选择读取所有状态寄存器
|
||
{
|
||
for (stat_reg = 1; stat_reg < NUM_STAT_REG + 0x1U; stat_reg++)//#define NUM_STAT_REG 4U,对每个BF8915A的状态电压寄存器执行一次
|
||
{
|
||
data_counter = 0;//data counter(数据计数器)
|
||
BF8915A_rdstat_reg(stat_reg, total_ic,dataPtr);//Reads the raw status register data into the dataPtr[] array(将原始状态寄存器数据读入dataPtr[]数组)
|
||
|
||
for (current_ic = 0 ; current_ic < total_ic; current_ic++)//该循环作用为读取并解析每个BF8915A所选择的状态电压寄存器
|
||
{
|
||
if (isospi_reverse == FALSE)//判断选择的菊花链通信方向是相对正向还是相对反向
|
||
{
|
||
c_ic = current_ic;//选择正序将状态寄存器放入数组
|
||
}
|
||
else
|
||
{
|
||
c_ic = total_ic - current_ic - 1;//选择倒序将状态寄存器放入数组
|
||
}
|
||
if ((stat_reg > 0) && (stat_reg < 4))//如果读取的寄存器为STATA、STATB、STATC
|
||
{
|
||
for (current_gpio = 0; current_gpio < GPIO_IN_REG; current_gpio++) // This loop parses the read back data into state voltages, it loops once for each of the 3 state voltage codes in the register
|
||
{ //(这个循环将读回的数据解析为状态电压，它对寄存器中的3个状态电压代码中的每一个循环一次)
|
||
parsed_stat = dataPtr[data_counter] + (dataPtr[data_counter+1]<<8);//Each state codes is received as two bytes and is combined to create the parsed state voltage code
|
||
//(每个状态码被接收为两个字节，并且被组合来创建解析的状态电压代码)
|
||
stateReg[c_ic].stat_codes[current_gpio + (stat_reg - 1) * GPIO_IN_REG] = parsed_stat;//将解析出的单个电压码依次存放在数组stateReg[c_ic].stat_codes[]中
|
||
data_counter=data_counter+2;//Because cell voltage codes are two bytes the data counter must increment by two for each parsed cell code
|
||
//(因为单体电压码是两个字节，所以对于每个解析的电池码，数据计数器必须增加2)
|
||
if((reg == STATC) &&(current_gpio == 0x1U)) //此处判断未了防止读STATC时,导致StateReg_TypeDef结构体中stat_codes[]数组溢出问题
|
||
{
|
||
current_gpio = GPIO_IN_REG;//寄存器为STATC且已经循环到第二次，跳过一次循环
|
||
data_counter = data_counter+2;//Because cell voltage codes are two bytes the data counter must increment by two for each parsed cell code
|
||
//(因为单体电压码是两个字节，所以对于每个解析的电池码，数据计数器必须增加2)
|
||
}
|
||
}
|
||
}
|
||
else if (stat_reg == 4)//如果读取的寄存器为STATD
|
||
{
|
||
stateReg[c_ic].uvOvFlags[0] = dataPtr[data_counter++];//STDR0的8位，Cell1~Cell4的欠/过压标志
|
||
stateReg[c_ic].uvOvFlags[1] = dataPtr[data_counter++];//STDR1的8位，Cell5~Cell8的欠/过压标志
|
||
stateReg[c_ic].uvOvFlags[2] = dataPtr[data_counter++];//STDR2的8位，Cell9~Cell12的欠/过压标志
|
||
stateReg[c_ic].uvOvFlags[3] = dataPtr[data_counter++];//STDR3的8位，Cell12~Cell16的欠/过压标志
|
||
stateReg[c_ic].cfg_err = ((dataPtr[data_counter] & 0x40) >> 0x6U);//STDR4的第7位，配置字校验出错标志(包括奇偶异或校验和ECC校验)
|
||
stateReg[c_ic].pec_err = ((dataPtr[data_counter] & 0x20) >> 0x5U);//STDR4的第6位，指令数据的PEC校验出错标志
|
||
stateReg[c_ic].extov = ((dataPtr[data_counter] & 0x10) >> 0x4U);//STDR4的第5位，监测模式下，外部温度(gpio)过温标志
|
||
stateReg[c_ic].itov = ((dataPtr[data_counter] & 0x08) >> 0x3U);//STDR4的第4位，监测模式下，内部温度(vtemp)过温标志
|
||
stateReg[c_ic].htov2 = ((dataPtr[data_counter] & 0x04) >> 0x2U);//STDR4的第3位，硬件温度(95℃)过温标志
|
||
stateReg[c_ic].htov1 = ((dataPtr[data_counter] & 0x02) >> 0x1U);//STDR4的第2位，硬件温度(125℃)过温标志
|
||
stateReg[c_ic].mux_fail = (dataPtr[data_counter++] & 0x01);//STDR4的第1位，开关译码测试结果
|
||
stateReg[c_ic].mode_state = ((dataPtr[data_counter] & 0xC0U) >> 0x6U);//STDR5的第8~7位，模式状态寄存器
|
||
stateReg[c_ic].rst_state = (dataPtr[data_counter++] & 0x3FU);//STDR5的第6~1位，复位标志寄存器
|
||
|
||
stateReg[c_ic].cellOvFlag = 0x00U;//电池欠压标志位，每个位用来标志每个电池的欠压标志位
|
||
stateReg[c_ic].cellUvFlag = 0x00U;//电池过压标志位，每个位用来标志每个电池的过压标志位
|
||
|
||
for(stateD_byte = 0;stateD_byte < 4;stateD_byte ++)//状态寄存器的字节循环
|
||
{
|
||
for(stateD_bit = 0;stateD_bit < 4;stateD_bit ++)//状态寄存器的位循环
|
||
{
|
||
if((stateReg[c_ic].uvOvFlags[stateD_byte] & (0x01 << (stateD_bit * 0x2U))) == (0x01 << stateD_bit * 0x2U))//判断该Cellx的欠压标志位是否为1
|
||
stateReg[c_ic].cellUvFlag |= 0x0001 << ((stateD_byte * 0x4U) + stateD_bit);//该Cellx的欠压标志位置1
|
||
else
|
||
stateReg[c_ic].cellUvFlag &= ~(0x0001 << ((stateD_byte * 0x4U) + stateD_bit));//该Cellx的欠压标志位置0
|
||
|
||
if((stateReg[c_ic].uvOvFlags[stateD_byte] & (0x01 << (stateD_bit * 0x2U + 0x1U))) == (0x01 << (stateD_bit * 0x2U + 0x1U)))//判断该Cellx的过压标志位是否为1
|
||
stateReg[c_ic].cellOvFlag |= 0x0001 << ((stateD_byte * 0x4U) + stateD_bit);//该Cellx的过压标志位置1
|
||
else
|
||
stateReg[c_ic].cellOvFlag &= ~(0x0001 << ((stateD_byte * 0x4U) + stateD_bit));//该Cellx的过压标志位置0
|
||
}
|
||
}
|
||
}
|
||
received_pec = (dataPtr[data_counter]<<8)+ dataPtr[data_counter+1];//接收到的当前IC(8915A)的PEC(检错码)作为6个状态电压数据字节之后的第7个和第8个字节发送
|
||
data_pec = pec15_calc(BYT_IN_REG, &dataPtr[current_ic*NUM_RX_BYT]);//计算接收回来的寄存器组(6个8位寄存器)中的PEC(检错码)
|
||
|
||
if (received_pec != data_pec)//检查检错码是否匹配
|
||
{
|
||
pec_error = 1; //如果有任何PEC(检错码)错误，pec_error变量简单地设置为1
|
||
stateReg[c_ic].pec_match[stat_reg-1]=1;//stateReg[c_ic].pec_match[stat_reg-1]中的检错码值置1
|
||
}
|
||
else
|
||
{
|
||
stateReg[c_ic].pec_match[stat_reg-1]=0;//stateReg[c_ic].pec_match[stat_reg-1]中的检错码值置0
|
||
}
|
||
data_counter = data_counter + 2;//Because the transmitted PEC code is 2 bytes long the data_counter must be incremented by 2 bytes to point to the next ICs state voltage data
|
||
//(因为传输的PEC(检错码)代码是2字节长，所以数据计数器必须增加2字节才能指向下一个集成电路状态电压数据)
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
BF8915A_rdstat_reg(reg, total_ic, dataPtr);//Reads the raw status register data into the dataPtr[] array(将原始状态寄存器数据读入dataPtr[]数组)
|
||
for (current_ic = 0 ; current_ic < total_ic; current_ic++) //该循环作用为读取并解析每个BF8915A所选择的状态电压寄存器
|
||
{
|
||
if (isospi_reverse == FALSE)//判断选择的菊花链通信方向是相对正向还是相对反向
|
||
{
|
||
c_ic = current_ic;//选择正序将电池电压放入数组
|
||
}
|
||
else
|
||
{
|
||
c_ic = total_ic - current_ic - 1;//选择倒序将电池电压放入数组
|
||
}
|
||
if ((reg > 0) && (reg <4))//如果读取的寄存器为STATA、STATB、STATC
|
||
{
|
||
for (current_gpio = 0; current_gpio< GPIO_IN_REG; current_gpio++) //This loop parses the read back data into state voltages, it loops once for each of the 3 state voltage codes in the register
|
||
{ //(这个循环将读回的数据解析为状态电压，它对寄存器中的3个状态电压码中的每一个循环一次)
|
||
|
||
parsed_stat = dataPtr[data_counter] + (dataPtr[data_counter+1]<<8);//Each state codes is received as two bytes and is combined to create the parsed state voltage code
|
||
//(每个状态码被接收为两个字节，并且被组合来创建解析的状态电压代码)
|
||
stateReg[c_ic].stat_codes[current_gpio + (reg - 1) * GPIO_IN_REG] = parsed_stat;
|
||
data_counter = data_counter+2;//Because state voltage codes are two bytes the data counter must increment by two for each parsed state voltage code
|
||
//(因为状态电压码是两个字节，所以对于每个解析的状态电压码，数据计数器必须增加2)
|
||
if((reg == STATC) &&(current_gpio == 0x1U)) //此处判断未了防止读STATC时,导致StateReg_TypeDef结构体中stat_codes[]数组溢出问题
|
||
{
|
||
current_gpio = GPIO_IN_REG;//若寄存器为STATC且已经循环到第二次，则跳过一次循环
|
||
data_counter = data_counter+2;//Because cell voltage codes are two bytes the data counter must increment by two for each parsed cell code
|
||
//(因为单体电压码是两个字节，所以对于每个解析的电池码，数据计数器必须增加2)
|
||
}
|
||
}
|
||
}
|
||
else if (reg == 4)//如果读取的寄存器为STATD
|
||
{
|
||
stateReg[c_ic].uvOvFlags[0] = dataPtr[data_counter++];//STDR0的8位，Cell1~Cell4的欠/过压标志
|
||
stateReg[c_ic].uvOvFlags[1] = dataPtr[data_counter++];//STDR1的8位，Cell5~Cell8的欠/过压标志
|
||
stateReg[c_ic].uvOvFlags[2] = dataPtr[data_counter++];//STDR2的8位，Cell9~Cell12的欠/过压标志
|
||
stateReg[c_ic].uvOvFlags[3] = dataPtr[data_counter++];//STDR3的8位，Cell12~Cell16的欠/过压标志
|
||
stateReg[c_ic].cfg_err = ((dataPtr[data_counter] & 0x40) >> 0x6U);//STDR4的第7位，配置字校验出错标志(包括奇偶异或校验和ECC校验)
|
||
stateReg[c_ic].pec_err = ((dataPtr[data_counter] & 0x20) >> 0x5U);//STDR4的第6位，指令数据的PEC校验出错标志
|
||
stateReg[c_ic].extov = ((dataPtr[data_counter] & 0x10) >> 0x4U);//STDR4的第5位，监测模式下，外部温度(gpio)过温标志
|
||
stateReg[c_ic].itov = ((dataPtr[data_counter] & 0x08) >> 0x3U);//STDR4的第4位，监测模式下，内部温度(vtemp)过温标志
|
||
stateReg[c_ic].htov2 = ((dataPtr[data_counter] & 0x04) >> 0x2U);//STDR4的第3位，硬件温度(95℃)过温标志
|
||
stateReg[c_ic].htov1 = ((dataPtr[data_counter] & 0x02) >> 0x1U);//STDR4的第2位，硬件温度(125℃)过温标志
|
||
stateReg[c_ic].mux_fail = (dataPtr[data_counter++] & 0x01);//STDR4的第1位，开关译码测试结果
|
||
stateReg[c_ic].mode_state = ((dataPtr[data_counter] & 0xC0U) >> 0x6U);//STDR5的第8~7位，模式状态寄存器
|
||
stateReg[c_ic].rst_state = (dataPtr[data_counter++] & 0x3FU);//STDR5的第6~1位，复位标志寄存器
|
||
for(stateD_byte = 0;stateD_byte < 4;stateD_byte ++)//状态寄存器的字节循环
|
||
{
|
||
for(stateD_bit = 0;stateD_bit < 4;stateD_bit ++)//状态寄存器的位循环
|
||
{
|
||
if((stateReg[c_ic].uvOvFlags[stateD_byte] & (0x01 << (stateD_bit * 0x2U))) == (0x01 << stateD_bit * 0x2U))//判断该Cellx的欠压标志位是否为1
|
||
stateReg[c_ic].cellUvFlag |= 0x0001 << ((stateD_byte * 0x4U) + stateD_bit);//该Cellx的欠压标志位置1
|
||
else
|
||
stateReg[c_ic].cellUvFlag &= ~(0x0001 << ((stateD_byte * 0x4U) + stateD_bit));//该Cellx的欠压标志位置0
|
||
|
||
if((stateReg[c_ic].uvOvFlags[stateD_byte] & (0x01 << (stateD_bit * 0x2U + 0x1U))) == (0x01 << (stateD_bit * 0x2U + 0x1U)))//判断该Cellx的过压标志位是否为1
|
||
stateReg[c_ic].cellOvFlag |= 0x0001 << ((stateD_byte * 0x4U) + stateD_bit);//该Cellx的过压标志位置1
|
||
else
|
||
stateReg[c_ic].cellOvFlag &= ~(0x0001 << ((stateD_byte * 0x4U) + stateD_bit));//该Cellx的过压标志位置0
|
||
}
|
||
}
|
||
}
|
||
received_pec = (dataPtr[data_counter]<<8)+ dataPtr[data_counter+1];//The received PEC for the current_ic is transmitted as the 7th and 8th after the 6 gpio voltage data bytes
|
||
//(接收到的集成电路计数器的检错码作为6个GPIO电压数据字节之后的第7个和第8个字节发送)
|
||
data_pec = pec15_calc(BYT_IN_REG, &dataPtr[current_ic*NUM_RX_BYT]);//计算接收回来的寄存器组(6个8位寄存器)中的PEC(检错码)
|
||
if (received_pec != data_pec)//检查检错码是否匹配
|
||
{
|
||
pec_error = 1;//如果有任何PEC(检错码)错误，pec_error变量简单地设置为1
|
||
stateReg[c_ic].pec_match[reg-1]=1;//stateReg[c_ic].pec_match[stat_reg-1]中的检错码值置1
|
||
}
|
||
data_counter = data_counter + 2;//Because the transmitted PEC code is 2 bytes long the data_counter must be incremented by 2 bytes to point to the next ICs state voltage data
|
||
//(因为传输的PEC(检错码)代码是2字节长，所以数据计数器必须增加2字节才能指向下一个集成电路状态电压数据)
|
||
}
|
||
}
|
||
free(dataPtr);//清空指针
|
||
return (pec_error);//回传检查检错码的值
|
||
}
|
||
|
||
/*!
|
||
\brief Clear Cell Register(清除电池电压寄存器)
|
||
\param[in] none
|
||
\retval none
|
||
*/
|
||
void BF8915A_clrcell(void)
|
||
{
|
||
uint8_t cmd[2]= {0x00 , 0x81};
|
||
BF8915A_cmd(cmd);//编写BF8915A命令的通用函数。函数为cmd数据计算了检错码
|
||
}
|
||
|
||
/*!
|
||
\brief Clear GPIO Register(清除GPIO寄存器)
|
||
\param[in] none
|
||
\retval none
|
||
*/
|
||
void BF8915A_clrgp(void)
|
||
{
|
||
uint8_t cmd[2]= {0x00 , 0x82};
|
||
BF8915A_cmd(cmd);//编写BF8915A命令的通用函数。函数为cmd数据计算了检错码
|
||
}
|
||
|
||
/*!
|
||
\brief Clear STATE Register(清除状态寄存器)
|
||
\param[in] none
|
||
\retval none
|
||
*/
|
||
void BF8915A_clrstat(void)
|
||
{
|
||
uint8_t cmd[2]= {0x00 , 0x83};
|
||
BF8915A_cmd(cmd);//编写BF8915A命令的通用函数。函数为cmd数据计算了检错码
|
||
}
|
||
|
||
/*!
|
||
\brief PLADC CMD(轮询ADC转换状态指令)
|
||
\param[in] none
|
||
\retval none
|
||
*/
|
||
uint8_t BF8915A_pladc(void)
|
||
{
|
||
uint8_t cmd[4];//初始化数组cmd[]
|
||
uint8_t adc_state = 0xFF;//初始化adc_state
|
||
uint16_t cmd_pec;//计算出发送指令的PEC(检错码)
|
||
|
||
cmd[0] = 0x00;//发送指令的高8位
|
||
cmd[1] = 0x84;//发送指令的低8位
|
||
cmd_pec = pec15_calc(2, cmd);//计算出发送指令的PEC(检错码)
|
||
cmd[2] = (uint8_t)(cmd_pec >> 8);//发送指令的PEC(检错码)的高八位
|
||
cmd[3] = (uint8_t)(cmd_pec);//发送指令的PEC(检错码)的低八位
|
||
|
||
if (isospi_reverse == FALSE)//判断选择的菊花链通信方向是相对正向还是相对反向
|
||
{
|
||
cs_low();//将片选CS设置为低电平
|
||
spi_write_array(4,cmd);//将字节数组写入SPI端口
|
||
adc_state = SPI1_ReadWriteByte(0xFF);//返回SPI接收到的数据
|
||
if(adc_state == 0xff)
|
||
{
|
||
cs_high();//将片选CS设置为高电平
|
||
}
|
||
}
|
||
else
|
||
{
|
||
cs_low_reverse();//将片选CS设置为低电平
|
||
spi_write_array(4,cmd);//将字节数组写入SPI端口
|
||
adc_state = SPI2_ReadWriteByte(0xFF);//返回SPI接收到的数据
|
||
if(adc_state == 0xff)
|
||
{
|
||
cs_high_reverse();//将片选CS设置为高电平
|
||
}
|
||
}
|
||
return(adc_state);//回传SPI接收到的数据
|
||
}
|
||
|
||
/*!
|
||
\brief soft reset(软件复位)
|
||
\param[in] none
|
||
\retval none
|
||
*/
|
||
void BF8915A_softrst(void)
|
||
{
|
||
uint8_t cmd[2]= {0x00 , 0x55};
|
||
BF8915A_cmd(cmd);//编写BF8915A命令的通用函数。函数为cmd数据计算了检错码
|
||
}
|