【学习记录】ADBMS1818读取温度，电压，及使用IIC

最新推荐文章于 2024-03-06 21:20:24 发布
最新推荐文章于 2024-03-06 21:20:24 发布
阅读量1.3k 收藏 14
点赞数
文章标签： 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liarsup/article/details/133036547
版权

刚刚搞完ADBMS1818的驱动程序，浅浅记录一下，备忘。
.h文件

#ifndef _ADBMS1818_
#define _ADBMS1818_
#include "M_SPI.h"        //引入SIP底层收发
#include "CRC_Pec15.h"    //引入计算crc的算法
#include "temperature.h"  //引入温度转换
#include "string.h"
/*注：目前版本0.0.1 仅支持一片1818，后续按需增加*/
#define WRCFGA  0x01   //写配置寄存器A
#define WRCFGB  0x24   //写配置寄存器B
#define RDCFGA  0x02   //读配置寄存器A
#define RDCFGB  0x26   //读配置寄存器B

/*读取电压寄存器使用ADBMS181x_rdcv_reg*/
//也可使用下边的快速读取
#define RDCVA   0x04   //读取电压寄存器组A
#define RDCVB   0x06   //读取电压寄存器组B
#define RDCVC   0x08   //读取电压寄存器组C
#define RDCVD   0x0A   //读取电压寄存器组D
#define RDCVE   0x09   //读取电压寄存器组E
#define RDCVF   0x0B   //读取电压寄存器组F

#define RDAUXA  0x0C   //读取辅助寄存器A
#define RDAUXB  0x0E   //读取辅助寄存器B
#define RDAUXC  0x0D   //读取辅助寄存器C
#define RDAUXD  0x0F   //读取辅助寄存器D

#define RDSTATA 0x10   //读取状态寄存器A
#define RDSTATB 0x12   //读取状态寄存器B


#define WRSCTRL 0x14   //写s控制寄存器组
#define RDSCTRL 0x16   //读s控制寄存器组

//comm命令
#define WRCOMM  0x0721  // 写comm寄存器组
#define STCOMM  0x0723  // 启动IIC/SPI通讯
#define RDCOMM  0x0722  // 读取comm寄存器组
//IIC_CMD 寄存器内数据用
#define IW_Start  0x06  //开始
#define IW_Stop   0x01  //停止
#define IW_Null   0x00  //空
#define IW_Nsend  0x07  //不发送 释放总线并忽略之后的数据
#define IR_Start  0x06  //从主机开始
#define IR_Stop   0x01  //从主机停止
#define IR_LOW    0x00  //字节之间SDA为低电平
#define IR_High   0x07  //字节之间SDA为高电平

#define FW_Ack    0x00  //主机写入ACK
#define FW_Nack   0x08  //主机写入NACK
#define FW_NaS    0x09  //主机写入NACK+停止
#define FR_MAck   0x00  //主机读取ACK
#define FR_SAck   0x07  //从机读取ACK
#define FR_SNAck  0x08  //从机读取NAck
#define FR_SAckS  0x01  //从机ACK+主机停止
#define FR_SNAckS 0x09  //从机NACK+主机停止

#define BMS1818_GPIO1     0x0002   // 0x08
#define BMS1818_GPIO2     0x0004   // 0x08<<1
#define BMS1818_GPIO3     0x0008   // 0x08<<2
#define BMS1818_GPIO4   	0x0010	 // 0x08<<3
#define BMS1818_GPIO5  		0x0020   // 0x08<<4
#define BMS1818_GPIO6   	0x0040	 // 0x01
#define BMS1818_GPIO7   	0x0080	 // 0x01<<1
#define BMS1818_GPIO8   	0x0100	 // 0x01<<2
#define BMS1818_GPIO9  		0x0200   // 0x01<<3


#define MD_422HZ_1KHZ   0
#define MD_27KHZ_14KHZ  1
#define MD_7KHZ_3KHZ    2
#define MD_26HZ_2KHZ    3

/*CHG低三位有效*/
#define CHG_ALL            0x00      //GPIO1至GPIO5，第二基准电压，GPIO6至GPIO9
#define CHG_G1G6           0x01      //GPIO1、GPIO6
#define CHG_G2G7           0x02      //....
#define CHG_G3G8           0x03
#define CHG_G4G9           0x04
#define CHG_G5             0x05
#define CHG_VREF2          0x06


/*CH低三位有效*/
#define CH_ALL             0x00      //所有电池
#define CH_V1_7_13         0x01      //电池 1 7 13
#define CH_V2_8_14         0x02      //....
#define CH_V3_9_15         0x03
#define CH_V4_10_16        0x04
#define CH_V5_11_17        0x05
#define CH_V6_12_18        0x06


#define ADCVAX            0x046F   // 0100 0110 1111  //所有电池和GPIO1 GPIO2   (这俩是掩码不能直接使用)
#define ADAX              0x0460   // 0100 0110 0000  //GPIO ADC转换
#define ADCV              0x0260   // 0010 0110 0000  //启动对18节电池的转换
typedef struct{
	uint8_t CFGARx[8];
	uint8_t CFGBRx[8];
	uint16_t VREF2;//第二基准电压值
	uint8_t COMM[8];
	/*................*/
}ADBMS1818_Reg;


//测试案例
void Bms1818_tset(void);
#endif

.c

#include "ADBMS1818.h"
ADBMS1818_Reg bms1818_Reg={0};
void BMS1818_Delay_us(uint16_t nus){
	uint8_t i;
     while(nus --)
     {
       for(i =0;i<0x16;i++);
		 }
}

/*spi读写接口 读写长度可变
tx_Data[] 发送缓冲区指针
rx_data   接受缓冲区指针
rx_len    长度
*/
void spi_WR_byte(uint8_t tx_Data[],uint8_t *rx_data,uint8_t len){
	 	Mspi_RT_byte(tx_Data,rx_data,len);
}
/*
第二个spi读写接口 读写一个字节
data 发送的数据
返回同时读取的数据
*/
uint8_t spi_WR_byte2(uint8_t data){
	uint8_t re;
	Mspi_RT_byte(&data,&re,1);
	return re;
}
//计算crc校验码的接口
uint16_t pec15_calc(int len,uint8_t* data){
     return pec15(data,len);
}


//extern void delay_1ms(uint32_t count);
/* 从IDlE状态唤醒isoSPI并进入READY状态*/
void wakeup_sleep_cmd(uint8_t chain_N)
{
	  uint8_t cmd[2],status[2];
	  	cmd[0]=0xff;
			SET_SPI0_NSS_LOW;
      BMS1818_Delay_us(10);
     	spi_WR_byte(cmd,status,1);
    	if(chain_N>200)BMS1818_Delay_us(300*chain_N/1000);
			else	{BMS1818_Delay_us(80*chain_N);}
     
			SET_SPI0_NSS_HIGH;
			SET_SPI0_NSS_LOW;
			spi_WR_byte(cmd,status,1);
      BMS1818_Delay_us(10*chain_N);
			spi_WR_byte(cmd,status,1);
      BMS1818_Delay_us(10*chain_N);
			SET_SPI0_NSS_HIGH;			
}
/*传入原始数据，(注：只处理一个寄存器组也就是)将数据进行校验然后传入目标指针，如果校验失败返回0*/
uint8_t ADBMS1818_RC_Check(uint8_t* original,uint16_t* target){
	uint16_t CRC_code;
	CRC_code = pec15_calc(6,original);
	if(CRC_code!=(original[6]<<8|original[7]))
		return 0;
	for(int i=0;i<3;i++){
		target[i]=original[i*2]|(original[i*2+1]<<8);
	}
	return 1;
}
//===============================================================================================================
/* 菊花链中的IC数量写入命令并读取原始单元电压寄存器数据
reg 1: RDCVA
    2: RDCVB
		3: RDCVC
		4: RDCVD
    5: RDCVE
    6: RDCVF
total_ic 菊花链中IC的数量
data 放数据的数组
*/
void ADBMS181x_rdcv_reg(uint8_t reg, uint8_t total_ic, uint8_t *data){
	const uint8_t REG_LEN = 8; //Number of bytes in each ICs register + 2 bytes for the PEC
	uint8_t cmd[40];
	uint16_t cmd_pec;
   //00 04 07 c2
	if (reg == 1)     //1: RDCVA
	{
		cmd[1] = 0x04;
		cmd[0] = 0x00;
	}
	else if (reg == 2) //2: RDCVB
	{
		cmd[1] = 0x06;
		cmd[0] = 0x00;
	}
	else if (reg == 3) //3: RDCVC
	{
		cmd[1] = 0x08;
		cmd[0] = 0x00;
	}
	else if (reg == 4) //4: RDCVD
	{
		cmd[1] = 0x0A;
		cmd[0] = 0x00;
	}
	else if (reg == 5) //5: RDCVE
	{
		cmd[1] = 0x09;
		cmd[0] = 0x00;
	}
	else if (reg == 6) //6: RDCVF
	{
		cmd[1] = 0x0B;
		cmd[0] = 0x00;
	}

	cmd_pec = pec15_calc(2, cmd);
	cmd[2] = (uint8_t)(cmd_pec >> 8);
	cmd[3] = (uint8_t)(cmd_pec);
  wakeup_sleep_cmd(total_ic);
	SET_SPI0_NSS_LOW;
	spi_WR_byte(cmd,data,4);
	memset(cmd, 0xff, 8);
  spi_WR_byte(cmd,data,REG_LEN*total_ic);
  SET_SPI0_NSS_HIGH;
}
/*
cmd 命令
wakeup 是否唤醒
*/
void ADBMS181x_write_cmd(uint16_t cmd,uint8_t wakeup){
	uint8_t Mcmd[8];
	uint8_t databuf[4];
	uint16_t cmd_pec;
	Mcmd[0]=(uint8_t)(cmd>>8);
	Mcmd[1]=(uint8_t)cmd;
	cmd_pec = pec15_calc(2, Mcmd);
  Mcmd[2] = (uint8_t)(cmd_pec >> 8);
	Mcmd[3] = (uint8_t)(cmd_pec);
	if(wakeup) wakeup_sleep_cmd(1);
  SET_SPI0_NSS_LOW;
  spi_WR_byte(Mcmd,databuf,4);
  SET_SPI0_NSS_HIGH;
}
/*读1818寄存器*/
void ADBMS181x_read_reg(uint16_t cmd,uint8_t *databuf,uint8_t wakeup){
	uint8_t Mcmd[8];
	uint16_t cmd_pec;
	Mcmd[0]=(uint8_t)(cmd>>8);
	Mcmd[1]=(uint8_t)cmd;
	cmd_pec = pec15_calc(2, Mcmd);
  Mcmd[2] = (uint8_t)(cmd_pec >> 8);
	Mcmd[3] = (uint8_t)(cmd_pec);
	if(wakeup) wakeup_sleep_cmd(1);
  SET_SPI0_NSS_LOW;
  spi_WR_byte(Mcmd,databuf,4);
	memset(Mcmd, 0xff, 8);
	spi_WR_byte(Mcmd,databuf,8);
  SET_SPI0_NSS_HIGH;
}
/*写1818寄存器*/
void ADBMS181x_write_reg(uint16_t cmd,uint8_t *databuf,uint8_t wakeup){
	uint8_t Mcmd[8+4];
	uint8_t buf[8];
	uint16_t cmd_pec;
	Mcmd[0]=(uint8_t)(cmd>>8);
	Mcmd[1]=(uint8_t)cmd;
	cmd_pec = pec15_calc(2, Mcmd);
  Mcmd[2] = (uint8_t)(cmd_pec >> 8);
	Mcmd[3] = (uint8_t)(cmd_pec);
	
	for(int i=0;i<6;i++){
		Mcmd[4+i] = databuf[i];//写入数据
	}
	cmd_pec = pec15_calc(6, &Mcmd[4]);
  Mcmd[10] = (uint8_t)(cmd_pec >> 8);
	Mcmd[11] = (uint8_t)(cmd_pec);
	if(wakeup) wakeup_sleep_cmd(1);
  SET_SPI0_NSS_LOW;
  spi_WR_byte(Mcmd,buf,4+8);
	
  SET_SPI0_NSS_HIGH;
}

/*
转换所有电池和GPIO1 GPIO2 的电压 建议在7K赫兹延迟8ms后读取
MD   ADC模式
DCP  允许放电？ 0不允许放电  1允许放电
*/
void ADBMS1818_ADCVAX(uint8_t MD,uint8_t DCP){
	uint16_t cmd=0;
	cmd|=(MD<<7);
	cmd|=(DCP<<4);
	cmd|=ADCVAX;
  ADBMS181x_write_cmd(cmd,1);
}
/*
转换GPIO_ADC 转换的项目根据CHG的值来确定
在7k赫兹的情况下
转换所有GPIO 需要3.9ms 建议等待 8ms以上
转换两个GPIO 需要1ms   建议等待 2ms以上
*/
void ADBMS1818_ADAX(uint8_t MD,uint8_t CHG){
	uint16_t cmd=0;
	cmd|=CHG;
	cmd|=(MD<<7);
  cmd|=ADAX;
  ADBMS181x_write_cmd(cmd,1);
}
/*转换所有电池电压
在7Khz下需要 3ms 建议等待6ms以上
MD ADC模式
CHG 

*/
void ADBMS1818_ADCV(uint8_t MD,uint8_t CH,uint8_t DCP){
	uint16_t cmd=0;
	cmd|=(DCP<<4);
	cmd|=(MD<<7);
	cmd|=(CH);	
  cmd|=ADCV;
  ADBMS181x_write_cmd(cmd,1);
}


//读取18个电池电压
void ADBMS181x_read_18V(uint16_t *bufdata){
		uint8_t Mcmd[8];
	  ADBMS1818_ADCV(MD_7KHZ_3KHZ,CH_ALL,0);
	  BMS1818_Delay_us(10000);
	  ADBMS181x_read_reg(RDCVA,Mcmd,1);
	  ADBMS1818_RC_Check(Mcmd,bufdata);
	  ADBMS181x_read_reg(RDCVB,Mcmd,0);
	  ADBMS1818_RC_Check(Mcmd,bufdata+3);
	  ADBMS181x_read_reg(RDCVC,Mcmd,0);
	  ADBMS1818_RC_Check(Mcmd,bufdata+6);
	  ADBMS181x_read_reg(RDCVD,Mcmd,0);
	  ADBMS1818_RC_Check(Mcmd,bufdata+9);
	  ADBMS181x_read_reg(RDCVE,Mcmd,0);
	  ADBMS1818_RC_Check(Mcmd,bufdata+12);
	  ADBMS181x_read_reg(RDCVF,Mcmd,0);
	  ADBMS1818_RC_Check(Mcmd,bufdata+15);
}
//暂不支持多个位同时配置
uint8_t ADBMS181x_Config_GPIO(uint16_t gpio,uint8_t state){
	switch(gpio){
		case BMS1818_GPIO1: 
			(state==1)? (bms1818_Reg.CFGARx[0]|=0x08):(bms1818_Reg.CFGARx[0]&=0xF7);
		break;
		case BMS1818_GPIO2: 
			(state==1)? (bms1818_Reg.CFGARx[0]|=0x10):(bms1818_Reg.CFGARx[0]&=0xEF);
		break;
		case BMS1818_GPIO3: 
			(state==1)? (bms1818_Reg.CFGARx[0]|=0x20):(bms1818_Reg.CFGARx[0]&=0xDF);
		break;
		case BMS1818_GPIO4: 
			(state==1)? (bms1818_Reg.CFGARx[0]|=0x40):(bms1818_Reg.CFGARx[0]&=0xBF);
		break;
		case BMS1818_GPIO5: 
			(state==1)? (bms1818_Reg.CFGARx[0]|=0x80):(bms1818_Reg.CFGARx[0]&=0x7F);
		break;
		case BMS1818_GPIO6: 
			(state==1)? (bms1818_Reg.CFGBRx[0]|=0x01):(bms1818_Reg.CFGBRx[0]&=0xFE);
		break;
		case BMS1818_GPIO7: 
			(state==1)? (bms1818_Reg.CFGBRx[0]|=0x02):(bms1818_Reg.CFGBRx[0]&=0xFD);
		break;
		case BMS1818_GPIO8: 
			(state==1)? (bms1818_Reg.CFGBRx[0]|=0x04):(bms1818_Reg.CFGBRx[0]&=0xFB);
		break;
		case BMS1818_GPIO9: 
			(state==1)? (bms1818_Reg.CFGBRx[0]|=0x08):(bms1818_Reg.CFGBRx[0]&=0xF7);
		break;
		default:
			
		return 0;
	}
	return 1;
}

//读取16个温度
void ADBMS181x_read_16T(uint16_t *Tdata){
	//依次读取
	uint8_t bufdata[8]={0};//存接收的数据
	uint16_t Vdata[3]={0};//存校验后的数据
	//uint8_t i=0;
	for(uint8_t i=0;i<8;i++){//切译码器
		ADBMS181x_Config_GPIO(BMS1818_GPIO7,(i&0x04)? 1:0);
		ADBMS181x_Config_GPIO(BMS1818_GPIO6,(i&0x02)? 1:0);
		ADBMS181x_Config_GPIO(BMS1818_GPIO3,(i&0x01)? 1:0);
		bms1818_Reg.CFGARx[0]|=0x00;
		ADBMS181x_write_reg(WRCFGA,bms1818_Reg.CFGARx,1);
		ADBMS181x_write_reg(WRCFGB,bms1818_Reg.CFGBRx,0);
		BMS1818_Delay_us(20000);//切换完成等待20ms
		
		ADBMS1818_ADAX(MD_7KHZ_3KHZ,CHG_ALL);//转换通道1
		BMS1818_Delay_us(8000);
		ADBMS181x_read_reg(RDAUXA,bufdata,1);
		if(ADBMS1818_RC_Check(bufdata,Vdata)){//检查读出数据是否合法
			Tdata[0+i]=Vdata[0];
			Tdata[8+i]=Vdata[1];
		}
	}
}
/*IIC主机写
SlaveAddress  从机地址  一个字节
cmd           命令字    一个字节
data          数据      固定两个字节
*/ 
void ADBMS1818_IIC_Write(uint8_t SlaveAddress,uint8_t cmdbyte,uint8_t* data){
	bms1818_Reg.COMM[0]=((IW_Start<<4)|(SlaveAddress>>4)); //起始地址
	bms1818_Reg.COMM[1]=(SlaveAddress<<4) | FW_Nack;       
  bms1818_Reg.COMM[2]=(IW_Null<<4) | (cmdbyte>>4);       //cmd
	bms1818_Reg.COMM[3]=(cmdbyte<<4) | FW_Nack;
	bms1818_Reg.COMM[4]=(IW_Null<<4) | (data[0]>>4);       //数据0
	bms1818_Reg.COMM[5]=(data[0]<<4) | FW_Nack;  
  ADBMS181x_write_reg(WRCOMM,bms1818_Reg.COMM,1);  //将数据装入comm寄存器
  ADBMS181x_write_cmd(STCOMM,0);	//启动iic数据传输
	SET_SPI0_NSS_LOW;
	for(int i=0;i<9;i++)//在发送72个时钟
   	spi_WR_byte2(0xff);
	SET_SPI0_NSS_HIGH;
	//memset(bms1818_Reg.COMM,0,6);//清除数据
	bms1818_Reg.COMM[0]=(IW_Null<<4) | (data[1]>>4);
  bms1818_Reg.COMM[1]=(data[1]<<4) | FW_NaS; //Nack信号和停止位
	bms1818_Reg.COMM[2]=(IW_Nsend<<4); //释放总线
	ADBMS181x_write_reg(WRCOMM,bms1818_Reg.COMM,1);  //第二次装入comm寄存器
	ADBMS181x_write_cmd(STCOMM,0);	//启动iic数据传输
	SET_SPI0_NSS_LOW;
	for(int i=0;i<9;i++)//在发送72个时钟
  spi_WR_byte2(0xff);
	SET_SPI0_NSS_HIGH;
}
/*IIC主机读
SlaveAddress   从机地址  一个字节
cmd            命令字（寄存器地址）    一个字节
data           数据      固定两个字节
*/ 

void ADBMS1818_IIC_Read(uint8_t SlaveAddress,uint8_t cmdbyte,uint8_t* data){
	bms1818_Reg.COMM[0]=((IW_Start<<4)|(SlaveAddress>>4)); //起始地址
	bms1818_Reg.COMM[1]=(SlaveAddress<<4) | FW_Nack;       
  bms1818_Reg.COMM[2]=(IW_Null<<4) | (cmdbyte>>4);       //cmd
	bms1818_Reg.COMM[3]=(cmdbyte<<4) | FW_NaS;
	bms1818_Reg.COMM[4]=((IR_Start<<4)|((SlaveAddress)>>4)); //发送从机地址 改为读
  bms1818_Reg.COMM[5]=((SlaveAddress|0x01)<<4) | FW_Nack; 
  ADBMS181x_write_reg(WRCOMM,bms1818_Reg.COMM,1);  //将数据装入comm寄存器
  ADBMS181x_write_cmd(STCOMM,0);                   //启动iic数据传输
	SET_SPI0_NSS_LOW;
	for(int i=0;i<9;i++)//在发送72个时钟
   	spi_WR_byte2(0xff);
	SET_SPI0_NSS_HIGH;
	bms1818_Reg.COMM[0]=((IW_Null<<4)|0x0f);  //接取两个字节
	bms1818_Reg.COMM[1]=(0xf0) | FW_Ack;       
  bms1818_Reg.COMM[2]=(IW_Null<<4) |0x0f;       
	bms1818_Reg.COMM[3]= 0xf0 | FW_NaS;
	bms1818_Reg.COMM[4]=(IW_Nsend<<4); //释放总线
  ADBMS181x_write_reg(WRCOMM,bms1818_Reg.COMM,1);  //将数据装入comm寄存器
  ADBMS181x_write_cmd(STCOMM,0);  
	SET_SPI0_NSS_LOW;
	for(int i=0;i<9;i++)//在发送72个时钟
   	spi_WR_byte2(0xff);
	SET_SPI0_NSS_HIGH;
	ADBMS181x_read_reg(RDCOMM,bms1818_Reg.COMM,1);  //读取comm返回数据
	data[0]=(bms1818_Reg.COMM[0]<<4)|(bms1818_Reg.COMM[1]>>4);
	data[1]=(bms1818_Reg.COMM[2]<<4)|(bms1818_Reg.COMM[3]>>4);
}


//测试定义数据
uint8_t BMS1818[18]={0};
uint16_t Vdata[18];
uint16_t TVdata[16];
int16_t  TP[16];
uint8_t data[8]={0xa0,0x0a};
void Bms1818_tset(void){
	//==========================读取温度示例=======================
	uint64_t temp;
  ADBMS181x_Config_GPIO(BMS1818_GPIO1,1);//输入引脚禁用下拉
  ADBMS181x_Config_GPIO(BMS1818_GPIO2,1);
  ADBMS181x_Config_GPIO(BMS1818_GPIO8,1);
	ADBMS181x_Config_GPIO(BMS1818_GPIO9,1);
	ADBMS181x_Config_GPIO(BMS1818_GPIO4,1);
	ADBMS181x_Config_GPIO(BMS1818_GPIO5,1);
	bms1818_Reg.CFGARx[0]|=0x04;//基准电压保持到看门狗超时
	ADBMS181x_write_reg(WRCFGA,bms1818_Reg.CFGARx,1);//配置io口
	ADBMS181x_write_reg(WRCFGB,bms1818_Reg.CFGBRx,0);
	
	ADBMS181x_read_16T(TVdata);//读取温度
	
	for(int i=0;i<16;i++){//温度转换
		temp=(33*TVdata[i])*1000/(30000-TVdata[i]);//将ad值计算出电阻值
  	TP[i]=GetTempChangeVol(temp/10,Rtc_50to125,Rtc_50to125_Size,50);//根据电阻值查表得出实际温度
	}
	
	//======================读取电压示例============================
//  ADBMS181x_Config_GPIO(BMS1818_GPIO1,1);//输入引脚禁用下拉
//  ADBMS181x_Config_GPIO(BMS1818_GPIO2,1);
//  ADBMS181x_Config_GPIO(BMS1818_GPIO8,1);
//	ADBMS181x_Config_GPIO(BMS1818_GPIO9,1);
//	bms1818_Reg.CFGARx[0]|=0x04;//基准电压保持到看门狗超时
//	ADBMS181x_write_reg(WRCFGA,bms1818_Reg.CFGARx,1);//配置io口
//	ADBMS181x_write_reg(WRCFGB,bms1818_Reg.CFGBRx,0);
	
  ADBMS181x_read_18V(Vdata);//为直接读出的ad值

	//========================iic读写示例============================
	
//	ADBMS181x_Config_GPIO(BMS1818_GPIO1,1);//输入引脚禁用下拉
//  ADBMS181x_Config_GPIO(BMS1818_GPIO2,1);
//  ADBMS181x_Config_GPIO(BMS1818_GPIO8,1);
//	ADBMS181x_Config_GPIO(BMS1818_GPIO9,1);
//	ADBMS181x_Config_GPIO(BMS1818_GPIO4,1);
//	ADBMS181x_Config_GPIO(BMS1818_GPIO5,1);
//	bms1818_Reg.CFGARx[0]|=0x04;//基准电压保持到看门狗超时
//	ADBMS181x_write_reg(WRCFGA,bms1818_Reg.CFGARx,1);//配置io口
//	ADBMS181x_write_reg(WRCFGB,bms1818_Reg.CFGBRx,0);
//	
	ADBMS1818_IIC_Write(0x48,0x02,data);
	data[0]=0x00; data[1]=0x00; 
	BMS1818_Delay_us(20000);//等待20ms
	ADBMS1818_IIC_Read(0x48,0x02,data);
//	
	//========================结束====================================
}
liarsup
关注
  • 0
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 8
    评论
ADBMS1818驱动程序
04-15
ADBMS1818驱动程序
关于ADBMS1818的求助帖
qq_35706406的博客
04-10 227
各位大佬，有将ADBMS1818的底层驱动程序移植到飞思卡尔MC9S系列单片机的吗？可否分享一下，抱拳
ADBMS1818芯片资料介绍(1)
m0_61973119的博客
03-01 1238
 可测量多达18串电池电压 3 mV最大总测量误差 内置isoSPI接口 使用单根双绞线，长达100米 290 μs内可完成系统中所有单体电池电压测量。
BMS开发之面向对象思想（adbms1818）
m0_61973119的博客
01-04 1170
再次返回来看结构体，首先tx_data[6]里面存储的就是寄存器里面所有位的数据，rx_data[8]收到的数据（包括PEC0 PEC1),rx_pec_match是标志位，判断接收到的PEC和根据6位数据计算出来的PEC是否相同，相同数据接收正确，不同数据接收错误。c_code[0]存储电池1电压，c_code[1]存储电池2电压......，c_code[17]存储电池18电压。每组存放3个电池的电压值，每一个电池的电压值用16位表示。处理数据的办法有两种，我们已知有6组数据，每一组数据有3个。
ADS1118调试指南和寄存器解析
热门推荐
humphreyandkate的博客
03-08 1万+
ADS1118基本功能 ADS1118是TI的16位ADC，内置1MHz晶振和参考电压源，转换速度8~860次每秒可调，量程±0.256V到±6.144V可调，可选单端输入或差分输入，内部集成温度传感器。 ADS1118寄存器 ADS1118的寄存器非常简单，只有2个16bit的寄存器。其中一个位只读寄存器，保存ADC转换后的值；另一个为配置寄存器，配置采集通道、正负量程、采集模式、采集速率、采集...
adbms1818-ltsketchbook.zip
06-14
induino 是凌力尔特的 Arduino 兼容系统，用于开发和分发凌力尔特集成电路的固件库和示例代码。 该代码被设计为高度可移植到其他微控制器平台，并使用 C 语言编写，使用尽可能少的处理器特定功能。 可以在下面下载代码库并在您的项目中按原样使用。 Linduino One 板（演示电路 DC2026B）允许您使用特定 IC 的标准演示板直接测试代码。 里面包含LTC的示例代码
ADBMS1818菊花链通信
h17878761977的博客
03-28 4191
ADBMS1818 isoSIP通信。
嵌入式系统开发环境下，SPI通信协议原理理解及STM32+OLED屏显应用初步
qq_53112972的博客
11-01 1240
掌握对于SPI通信协议原理的理解，以及STM32f103c8t6与OLED屏显的联动应用演训
LTC6813/ADBMS1818调试问题
huang947的博客
07-14 3470
LTC6813采用菊花链iso SPI方式，MCU保持供电，LTC6813断电重启，转换电压失败（电压读取不到），LTC6813断电前可转换并读取电压？？为什么会出现此现象，望有朋友能解答
ADBMS1818代码编写（2）
m0_61973119的博客
03-01 490
重写一下底层SPI驱动函数和延时函数基本修改到代码没有报错即移植成功。cell_asic结构体详解。
IIC.rar_iic读取255
09-23
单片机的IIc读取at24c02芯片，或者写数据到at24c02芯片
24C04 IIC存储及读取数据（LCD1602显示）.zip
09-21
24C04 IIC存储及读取数据（LCD1602显示）.zip
LTC6813驱动代码
11-20
LTC6813的驱动代码： LT_SPI.h; LT_SPI.cpp; LTC6813.h ; LTC6813.cpp ; LTC681x.h ; LTC681x.cpp; bms_hardware.h; bms_hardware.cpp; DC2350_6813.ino;
IIC_TMP102.zip_tmp102_tmp102 程序_tmp102读取温度
07-15
基于CC430单片机的IIC通信协议的TMP102温度传感器的测试程序
BMS_Studio_Pro 上位机
12-13
bms 电池上位机软件 包含规格书，上位机操作说明，测试方法
串口发送数据到IICLCD从IIC读取数据显示
08-10
串口将接收到是数据发送到IIC_...当外部有按键按下时，按键检测模块会检测到这个输入，然后控制IIC控制器进行EEPROM的数据读取，读取到的数据发送给FIFO中。后面就和上次的一样，LCD从FIFO中取出数据，然后进行显示。
温度传感器ADT75 AD7416实时读取温度
03-13
温度传感器ADT75 AD7416实时读取温度，在原子哥探索者F4开发板的STM32F4的实验24 IIC实验例程上加入ADT75 AD7416读温度时序即可，如果没有开发板用的话，就把myiic.c和24cxx.c两个c文件拷贝到你的工程，定义u16 ...
LT6813/ADBMS1818底层驱动---均衡控制
最新发布
qianoocheng的博客
03-06 1041
根据数据库中读取的控制值设置平衡。要为单元设置平衡，必须将相应的位写入配置寄存器中。LTC 驱动程序仅执行数据库中 BMS 写入的数据。参数状态机转换基于条件的状态转换，取决于 retVal。如果 retVal STD_OK，则在经过timer_ms_ok后，LTC 状态机将转换为 state_ok 和 substate_ok，否则在 timer_ms_nok 后，状态机将转换为 state_nok 和 substate_nok。根据 retVal 的值，将调用相应的诊断条目。参数。
如何使用iic读取电流值
06-08
使用IIC读取电流值需要以下步骤： 1. 连接IIC总线：将IIC总线连接到需要读取电流值的电流传感器上。 2. 初始化IIC：在代码中初始化IIC总线，并设置传感器地址和读取模式。 3. 发送读取命令：向传感器发送读取命令，并等待传感器响应。 4. 读取数据：从传感器接收数据，并将其解析为电流值。 5. 关闭IIC：在读取完电流值后，关闭IIC总线以释放资源。 以下是一个简单的示例代码，展示如何使用IIC读取电流值： ```c #include <Wire.h> #define SENSOR_ADDRESS 0x48 // 传感器地址 void setup() { Wire.begin(); // 初始化IIC总线 Serial.begin(9600); // 初始化串口 } void loop() { Wire.beginTransmission(SENSOR_ADDRESS); Wire.write(0x00); // 发送读取命令 Wire.endTransmission(); delay(100); // 等待传感器响应 Wire.requestFrom(SENSOR_ADDRESS, 2); // 从传感器接收2个字节的数据 int16_t rawValue = (Wire.read() << 8) | Wire.read(); // 解析数据为电流值 float current = rawValue * 0.0625; // 将原始数据转换为电流值 Serial.println(current); // 输出电流值 Wire.end(); // 关闭IIC总线 } ``` 注意：上述代码仅供参考，具体的实现方式可能因传感器型号和硬件环境而有所不同。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值