/********************************************************************************
Copyright (C), Sinowealth Electronic. Ltd.
Author: 	Sino
Version: 	V0.0
Date: 		2014/05/30
History:
	V0.0		2014/05/30		 Preliminary
********************************************************************************/
#include "stm32f10x.h"
#include "global.h"
#include "string.h"
#include "rtc.h"

uint8_t  oldsoc;
uint8_t  newsoc;

uint8_t  fullToZeroStudyFlag;  //满充开始学习标记
uint8_t  zeroToFullStudyFlag;  //满放开始学习标记

uint32_t packcheck_OV; //单体过压校准SOC的总压判断值
uint32_t packcheck_UV; //单体欠压校准SOC的总压判断值

uint16_t ncc_Ah;    //额定容量，用于计算传给逆变器的并机总容量 单位1Ah
uint16_t fcc_Ah;    //满充容量，用于在上位机修改容量和SOC后，计算此时的剩余容量 单位1Ah
uint16_t rcc_Ah;    //剩余容量，用于计入累计容量，然后计算循环次数
uint16_t oldrcc_Ah; //旧现有容量，用于比较计入累计容量
uint16_t cumuliCapacity; //累积容量，单位0.1Ah

uint8_t  FullCharge_count; //满充减容量的延迟计数
uint8_t  FullCharge_count2; //满充减容量的延迟计数2

uint8_t  Cali_Soc_Flag;    //15%校准执行标志
uint16_t CaliSocMoniCount; //15%校准等待时间

uint16_t oldcyc;

uint8_t  ClearEE[4] = {0xff,0xff,0xff,0xff};
uint8_t  tmpRdFCC[8]; //用于读出总容量值
uint8_t  tmpWrFCC[8]; //用于写入总容量值
uint32_t RdFCC;

uint32_t fcc;                //满充容量，单位mAS
uint8_t  fcc_CaliStartFlag;  //当开始充电时，如果此时SOC=0/1%，开始计时
uint8_t  fcc_fullFlag;       //达到任一满充条件的标志，是最终执行满充容量校准的条件之一


/*******************************************************************************
Function:InitGasGauge() 
Description: Calculate the remaining capacity according to pack voltage  
Input:  NULL	
Output: NULL
Others:
*******************************************************************************/
void InitGasGauge(void)
{
	uint8_t  tmpRd[2],tmpWr[2];
	uint16_t capacity,cyctime;
	
	//上电读EEPROM 额定容量值
	EEPROM_RdMulByte(EE_NCC,tmpRd);
	capacity = tmpRd[0]<<8 | tmpRd[1];
	if(capacity>0 && capacity<=1000) //如果之前写过容量值,就按照之前的值显示，范围1~1000，否则显示100Ah
	{
		bmsMem.ncc = 3600 * 1000 * capacity;
		ncc_Ah = capacity;
	}
	else
	{
		bmsMem.ncc = 3600 * 1000 * 100;   //系统额定容量默认100AH = 100,000mAH = 360,000,000mAS
		ncc_Ah = 100;
	}
	
	//上电读EEPROM 满充容量值
	//前4位是正值，后四位是反值，用来校验数值正确
	EEPROM_RdMulByte(EE_FCC,tmpRdFCC);
	if( ((tmpRdFCC[0]^0xff) == tmpRdFCC[4]) && ((tmpRdFCC[1]^0xff) == tmpRdFCC[5]) && ((tmpRdFCC[2]^0xff) == tmpRdFCC[6]) && ((tmpRdFCC[3]^0xff) == tmpRdFCC[7]) )
	{
		RdFCC = tmpRdFCC[0]<<24 | tmpRdFCC[1]<<16 | tmpRdFCC[2]<<8 | tmpRdFCC[3];
		if((RdFCC>0) && (RdFCC <= 0xFFE00000)) //不出错的正数范围为1~4,292,870,144,大约1192Ah
		{
			fcc = RdFCC;
			fcc_Ah = RdFCC / 3600000;
		}
		else
		{
			fcc = bmsMem.ncc;
			fcc_Ah = bmsMem.ncc / 3600000;
		}
	}
	else
	{
			fcc = bmsMem.ncc;
			fcc_Ah = bmsMem.ncc / 3600000;
	}
	
	//上电读EEPROM 循环次数
	EEPROM_RdMulByte(EE_CYCLE,tmpRd);
	cyctime = tmpRd[0]<<8 | tmpRd[1];
	if(cyctime > paraMem.sohcali_stopTime+10) //初次读取
	{
		oldcyc = 0;
		bmsMem.cycleCount = 0;
	}
	else
	{
		oldcyc = cyctime;
		bmsMem.cycleCount = cyctime;
	}
	
	//上电读EEPROM 累积容量值 //计算时，使用额定容量而不是满充容量
	EEPROM_RdMulByte(EE_CUMULI,tmpRd);
	capacity = tmpRd[0]<<8 | tmpRd[1];
	if((int)capacity>=0 && capacity<=10*ncc_Ah) //剩余容量范围0~10000*0.1Ah，超出则显示0
	{
		cumuliCapacity = capacity;
		
		//获得进行循环次数计算的单位容量(此处不可为0)
		if(paraMem.sohcali_transCent != 0)
		{
			capacity = 10*ncc_Ah * paraMem.sohcali_transCent/100;
		}
		else
		{
			capacity = 10*ncc_Ah * 90/100; //默认90%
		}
		//计算循环次数
		if(cumuliCapacity >= capacity) //当累积容量超出总容量的90%,增加循环次数
		{
			bmsMem.cycleCount += cumuliCapacity / capacity;
			cumuliCapacity = cumuliCapacity % capacity;
			
			//保存参与过循环次数计算后的累积容量
			tmpWr[0] = (cumuliCapacity >>  8) & 0xff;
			tmpWr[1] = (cumuliCapacity >>  0) & 0xff;
			EEPROM_WrMulByte(EE_CUMULI,tmpWr);
			delay_ms(5);
		}
	}
	else
	{
		cumuliCapacity = 0;
	}
	
	
	//上电读EEPROM soc值
	EEPROM_RdMulByte(EE_SOC,&tmpRd[0]);
	//正常
	if(((int)tmpRd[0]>=0) && (tmpRd[0]<=100)) //在比较操作中使用类型转换不会改变变量本身的类型
	{
		oldsoc = tmpRd[0];
		bmsMem.soc = tmpRd[0];
		
		bmsMem.rcc = fcc/100 * bmsMem.soc;
		rcc_Ah = fcc_Ah * bmsMem.soc /100;
		oldrcc_Ah = rcc_Ah;
	}
	//首次上电根据电压校准soc
	else
	{
		OCV_CaliSOC_DataWr();
		bmsMem.soc = OCV_CaliSoc_dp();
		
		bmsMem.rcc = fcc/100 * bmsMem.soc;
		rcc_Ah = fcc_Ah * bmsMem.soc /100;
		oldrcc_Ah = rcc_Ah;
	}
}


//Manage the capacity of the pack
//interval 1s
void GaugeManage(void)
{
	uint8_t  tempWr[2];
	uint16_t capacity;
	
	/*参与判断的总压限值*/
	//模块过压值
	packcheck_OV = cell_OV * bmsMem.ucCellNum -8000;
	//模块欠压值
	packcheck_UV = cell_UV * bmsMem.ucCellNum +5000;
	
	
	/*计算剩余容量*/
	//电流积分法：微小电流认为是干扰，不参与计算
	if( (bmsMem.packCurrent <= (-100)) || (bmsMem.packCurrent >= 100) )
	{
		bmsMem.rcc += bmsMem.packCurrent;
	}
	if(bmsMem.rcc > 0xFFE00000)//4.21添加，防止过放数据出错 //因改为无符号，需清零的负数范围设-1~-2,097,151，电流值在2000A范围内皆可接受，不出错的正数范围为0~4,292,870,144,大约1192Ah
	{
		bmsMem.rcc = 0;
	}
	
	if((paraMem.cali_min_disable & 0x8000) != 0) //不允许做满充容量校准
	{
		//在校准容量判断前，保证参数正确
		if(fcc_CaliStartFlag != 0)
		{
			fcc_CaliStartFlag = 0;
			
			EEPROM_WrMulByte(EE_FCC_TIME,ClearEE);
			delay_ms(5);
		}
		
		if(fcc != bmsMem.ncc) //校准总容量=额定容量
		{
			//赋值满充容量=额定容量
			fcc = bmsMem.ncc;
			fcc_Ah = ncc_Ah;
			tmpWrFCC[0] = (fcc>>24) & 0xff;
			tmpWrFCC[1] = (fcc>>16) & 0xff;
			tmpWrFCC[2] = (fcc>> 8) & 0xff;
			tmpWrFCC[3] = (fcc>> 0) & 0xff;
			tmpWrFCC[4] = tmpWrFCC[0] ^ 0xff;
			tmpWrFCC[5] = tmpWrFCC[1] ^ 0xff;
			tmpWrFCC[6] = tmpWrFCC[2] ^ 0xff;
			tmpWrFCC[7] = tmpWrFCC[3] ^ 0xff;
			EEPROM_WrMulByte(EE_FCC,tmpWrFCC);
			delay_ms(20);
			
			//赋值剩余容量=新的满充容量*SOC
			bmsMem.rcc = fcc/100 * bmsMem.soc;
			rcc_Ah = fcc_Ah * bmsMem.soc / 100;
			oldrcc_Ah = rcc_Ah;
		}
	}
	
	/*计算实时SOC=剩余容量/满充容量*/
	if(bmsMem.rcc > fcc/100 * 99) //>99%
	{
		//若SOC已经是100%，不会下调
		if(bmsMem.soc >= 100)
		{
			bmsMem.soc = 100;
		}
		//若SOC此前<=99，锁定99%
		else
		{
			bmsMem.soc = 99;
		}
	}
	else //0%~99%
	{
		//如果剩余容量的小数部分至少有0.1Ah，soc+1
		if( (bmsMem.rcc%(fcc/100)) /360000 != 0) //取精度0.1%作为判断标准 360000mAS = 0.1*1000*3600 = 0.1Ah
		{
			bmsMem.soc = bmsMem.rcc/(fcc/100)+1;
		}
		else
		{
			bmsMem.soc = bmsMem.rcc/(fcc/100);
		}
	}
	
	/*若满足特殊条件，直接改动SOC值，注意剩余容量保持不变*/
	//read bSTATUS1 ov bit 满充校准
	//满充条件1：单体过压
	if( ((paraMem.soc100_methods & 0x01) != 0) && ((bmsMem.bStatus1 & 0x0001) != 0) && (bmsMem.packVoltage > packcheck_OV)) //发生过压保护(会关MOS)//带总压判断(根据串数变化)
	{
		bmsMem.soc = 100;
		fcc_fullFlag = 1;
		
		//如果不在等待校准满充容量，同时更新rcc=fcc
		if(fcc_CaliStartFlag == 0)
		{
			bmsMem.rcc = fcc;
		}
	}
	//满充条件2：总体过压
	else if( ((paraMem.soc100_methods & 0x02) != 0) && ((bmsMem.bStatus1 & 0x0100) != 0)) //发生总体过压保护(会关MOS)
	{
		bmsMem.soc = 100;
		fcc_fullFlag = 1;
		
		//如果不在等待校准满充容量，同时更新rcc=fcc
		if(fcc_CaliStartFlag == 0)
		{
			bmsMem.rcc = fcc;
			
			//不计入循环次数
			rcc_Ah = bmsMem.rcc/3600/1000;
			oldrcc_Ah = rcc_Ah;
		}
	}
	//满充条件3：逆变器限压57.6V+2A小电流
	else if( ((paraMem.soc100_methods & 0x04) != 0) && (bmsMem.packVoltage >= bmsMem.inverter_chgVolLimit*100) && (bmsMem.packCurrent >= 100) && (bmsMem.packCurrent <= 2000)) //电压大于逆变器充电限压值，电流小于2A(逆变器会逐渐停止充电，但BMS不关闭MOS)
	{
		bmsMem.soc = 100;
		fcc_fullFlag = 1;
		
		//如果不在等待校准满充容量，同时更新rcc=fcc
		if(fcc_CaliStartFlag == 0)
		{
			bmsMem.rcc = fcc;
			
			//不计入循环次数
			rcc_Ah = bmsMem.rcc/3600/1000;
			oldrcc_Ah = rcc_Ah;
		}
	}
	//满充条件4：满充电压56V+5A截止电流
	else if( ((paraMem.soc100_methods & 0x08) != 0) && ((bmsMem.bStatus1 & 0x0800) != 0)) //发生满充停止充电(会关MOS)
	{
		bmsMem.soc = 100;
		fcc_fullFlag = 1;
		
		//如果不在等待校准满充容量，同时更新rcc=fcc
		if(fcc_CaliStartFlag == 0)
		{
			bmsMem.rcc = fcc;
			
			//不计入循环次数
			rcc_Ah = bmsMem.rcc/3600/1000;
			oldrcc_Ah = rcc_Ah;
		}
	}
	else
	{
		fcc_fullFlag = 0;
	}
	
	//read bFLAG1 ov bit 满放校准
	if((bmsMem.bStatus1 & 0x0002) !=0) //发生单体欠压保护
	{
		if(bmsMem.packVoltage < packcheck_UV) //总压判断(根据串数变化)
		{
			bmsMem.soc = 0;
			bmsMem.rcc = 0;
		}
	}
	else if((bmsMem.bStatus1 & 0x0200) !=0) //发生总体欠压保护
	{
		bmsMem.soc = 0;
		bmsMem.rcc = 0;
	}
	else
	{
		if(bDSGING) //还正在放电但rcc已经为0，会上调一点容量，直到满足满放条件
		{
			if(bmsMem.soc == 0) //若SOC原是0%，放电不破坏该值
			{
				bmsMem.rcc = 0;
			}
			else if((bmsMem.rcc <= 360000) || (bmsMem.rcc > 0xFFE00000)) //因改为无符号，需清零的负数范围设-1~-2,097,151，电流值在2000A范围内皆可接受，不出错的正数范围为0~4,292,870,144,大约1192Ah
			{
				bmsMem.soc = 1;
				bmsMem.rcc = 360000 * 5; //增加0.5Ah用于继续下降 //在0.1Ah~0.5Ah之间维持(soc=1%)
			}
		}
	}
	
	
	//15%校准：当总电压小于等于50V时，若SOC大于15%则校准到15% //4.28增加电流条件放电15A以下
	if((bmsMem.packVoltage <= (50000/16*bmsMem.ucCellNum)) && (bmsMem.soc > 15) && (bmsMem.packCurrent > (-15000)) && (bmsMem.packCurrent < 100))
	{
		Cali_Soc_Flag = 1;
	}
	else
	{
		Cali_Soc_Flag = 0;
	}
	
	
	if((paraMem.cali_min_disable & 0x8000) == 0) //允许做满充容量校准
	{
		Cali_FCC_Moni(); //电流和SOC满足条件后执行
	}
	else //不允许
	{
		//在以上所有执行完后，有问题再纠正下
		if(bmsMem.soc == 100) //SOC已经到了100%，此时rcc最高不超过fcc
		{
			if(bmsMem.rcc > fcc)
			{
				bmsMem.rcc = fcc;
			}
		}
		else //SOC低于100%，此时rcc最高不超过fcc*99%
		{
			if(bmsMem.rcc > fcc/100 * 99)
			{
				if(bCHGING) //正在充电
				{
					bmsMem.rcc = fcc - (fcc/1000*15);
				}
				else
				{
					bmsMem.rcc = fcc/100 * 99;
				}
			}
		}
	}
	
	
	bmsMem.can_soc = bmsMem.soc; //sum of all packs
	bmsMem.can_soh = bmsMem.soh; //sum of all packs
	
	
	/*数据存入EEPROM*/
	//SOC write  to eeprom
	if(bmsMem.soc != oldsoc)
	{
		oldsoc = bmsMem.soc;
		tempWr[0] = bmsMem.soc;
		EEPROM_WrMulByte(EE_SOC,&tempWr[0]);
		delay_ms(5);
	}
	
	//累积容量 write  to eeprom
	rcc_Ah = bmsMem.rcc/3600/1000;
	if(rcc_Ah > oldrcc_Ah) //当容量上涨了1Ah
	{
		cumuliCapacity += 10*(rcc_Ah - oldrcc_Ah); //将增加部分放入累积容量中
		oldrcc_Ah = rcc_Ah;
		
		//获得进行循环次数计算的单位容量(此处不可为0)
		if(paraMem.sohcali_transCent != 0)
		{
			capacity = 10*ncc_Ah * paraMem.sohcali_transCent/100;
		}
		else
		{
			capacity = 10*ncc_Ah * 90/100; //默认90%
		}
		//计算循环次数
		if(cumuliCapacity >= capacity) //当累积容量超出总容量的90%,增加循环次数
		{
			bmsMem.cycleCount += cumuliCapacity / capacity;
			cumuliCapacity = cumuliCapacity % capacity;
		}
		//保存当前(或参与过循环次数计算后的)累积容量
		tempWr[0] = (cumuliCapacity >>  8) & 0xff;
		tempWr[1] = (cumuliCapacity >>  0) & 0xff;
		EEPROM_WrMulByte(EE_CUMULI,tempWr);
		delay_ms(5);
	}
	else
	{
		oldrcc_Ah = rcc_Ah; //要同步增减
	}
	
	//循环次数 write  to eeprom
	if(bmsMem.cycleCount != oldcyc)
	{
		oldcyc = bmsMem.cycleCount;
		tempWr[0] = (bmsMem.cycleCount >> 8) & 0xff;
		tempWr[1] = (bmsMem.cycleCount >> 0) & 0xff;
		EEPROM_WrMulByte(EE_CYCLE,tempWr);
		delay_ms(5);
		
		if(cumuliCapClear_flag == 1)
		{
			cumuliCapClear_flag = 0;
			//保存累积容量为0
			cumuliCapacity = 0;
			tempWr[0] = (cumuliCapacity >>  8) & 0xff;
			tempWr[1] = (cumuliCapacity >>  0) & 0xff;
			EEPROM_WrMulByte(EE_CUMULI,tempWr);
			delay_ms(5);
		}
	}
	
	
	/*通过循环次数计算SOH*/
	if(bmsMem.cycleCount <= paraMem.sohcali_stopTime)
	{
		if(bmsMem.cycleCount <= paraMem.sohcali_startTime)
		{
			bmsMem.soh = 100; //维持100%
		}
		else
		{
			uint16_t cent = (paraMem.sohcali_stopTime-1 - paraMem.sohcali_startTime) / (99-paraMem.sohcali_minSOH); //每1%对应的大概次数
			
			bmsMem.soh = 99 - (bmsMem.cycleCount - paraMem.sohcali_startTime) / cent; //从99%开始下降
		}
	}
	else //超过就维持最大次数
	{
		bmsMem.cycleCount = paraMem.sohcali_stopTime;
		bmsMem.soh = paraMem.sohcali_minSOH;
	}
	
	//Wh版屏幕需要
	bmsMem.can_cumuliCap = cumuliCapacity/10; //sum of all packs
	bmsMem.can_cycleCnt = bmsMem.cycleCount; //sum of all packs
	
	
	//过压报警的显示判断：在接近满电时,发生[过压保护],则不会因此亮灯屏幕也不显示过压
	#if Key_PressLong
	if((ON_confirm_flg != 0) && (RST_confirm_flg != 1) && (OFF_confirm_flg != 1))
	#endif
	{
		if(((bmsMem.bStatus1 & 0x0001) != 0) || ((bmsMem.bStatus1 & 0x0100) != 0))  //单体过压+总体过压
		{
			if(bmsMem.soc<99) //在正常工作时，发生[过压保护]，正常显示
			{
				bAlarmFlag = 1;
				if(sleep_flag == 0) LED_ALARM_On();
				else                LED_ALARM_Off();
			}
			else
			{
				//若出现其他报警，就不恢复原状(-单体过压-总体过压+急停)
				if( ((bmsMem.bStatus1 & 0x067e) == 0)  &&  ((bmsMem.bStatus2 & 0x00ff) == 0) && ((bmsMem.bStatus3 & 0x0008) == 0) && ((bmsMem.temperaStatus & 0x0f7f) == 0) )
				{
					bAlarmFlag = 0;
					bAlarmFlagOld = 0;
					LED_ALARM_Off();
				}
			}
		}
	}
	
	
	//led指示
	#if Key_PressLong
	if((ON_confirm_flg != 0) && (RST_confirm_flg != 1) && (OFF_confirm_flg != 1))
	#endif
	{
		if(sleep_flag == 0)
		{
			if(bmsMem.soc<5)
			{    
				LED1_Off();
				LED2_Off();
				LED3_Off();
				LED4_Off();    
			}
			else if(bmsMem.soc>=5 && bmsMem.soc<30)
			{
				LED1_On();
				LED2_Off();
				LED3_Off();
				LED4_Off(); 
			}
			else if(bmsMem.soc>=30 && bmsMem.soc<60)
			{
				LED1_On();
				LED2_On();
				LED3_Off();
				LED4_Off(); 
			}
			else if(bmsMem.soc>=60 && bmsMem.soc<90)
			{
				LED1_On();
				LED2_On();
				LED3_On();
				LED4_Off(); 
			}
			else
			{
				LED1_On();
				LED2_On();
				LED3_On();
				LED4_On(); 
			}
		}
		else //休眠模式下灯全灭
		{
			LED1_Off();
			LED2_Off();
			LED3_Off();
			LED4_Off();
		}
	}
}

#define CALI_SOC_CNT 12000 //2*60*100个10ms=2分钟
void Cali_SOC_Moni(void)
{
	if(Cali_Soc_Flag == 1)
	{
		CaliSocMoniCount--;
		if(CaliSocMoniCount == 0)
		{
			CaliSocMoniCount = CALI_SOC_CNT;
			if(bmsMem.soc>15)
			{
				bmsMem.soc = 15;
				bmsMem.rcc = fcc/100 * bmsMem.soc;
			}
		}
	}
	else
	{
		CaliSocMoniCount = CALI_SOC_CNT;
	}
}

//校准满充容量的执行过程
//若刚开始充电时，SOC=0/1%，则允许校准满充容量，同步计时12h超过则不再校准
//若12h内，满足了满充判定的任一条件而使SOC=100%，在基本停止充电(电流<2A)后执行容量校准：赋值[满充容量]=此时的剩余容量并保存。
//若12h外，满足了满充判定的任一条件而使SOC=100%，不会变动满充容量。
//剩余容量可以一直增长，若超过了原来的满充容量，SOC保持100%不再增长。
void Cali_FCC_Moni(void)
{
	//没有在计时
	if(fcc_CaliStartFlag == 0)
	{
		if((bmsMem.packCurrent >= 2000) && (bmsMem.soc <= 1)) //充电(大于2A)时，若此时SOC处于低点，进行校准总容量的倒计时
		{
			fcc_CaliStartFlag = 1;
			
			//更新起始点，如果晶振正常就把标志和起始点都写入EEPROM
			if(LSEErrFlag!=1)
			{
				uint8_t time[4];
				
				fcc_Calitimecount=RTC_GetCounter();
				
				//写入起始时间
				time[0] = fcc_Calitimecount>>24 & 0xff;
				time[1] = fcc_Calitimecount>>16 & 0xff;
				time[2] = fcc_Calitimecount>>8  & 0xff;
				time[3] = fcc_Calitimecount>>0  & 0xff;
				
				EEPROM_WrMulByte(EE_FCC_TIME,time);
				delay_ms(5);
			}
			else
			{
				fcc_Cali_Moni_Count = FCCCALI_MON_CNT;
			}
		}
	}
	//此前已经启动计时
	else
	{
		if((bmsMem.packCurrent < 2000) && (fcc_fullFlag == 1)) //不在充电时，若已满足满充条件，说明此时的剩余容量是当前的满充容量值
		{
			//赋值满充容量=剩余容量
			fcc = bmsMem.rcc;
			fcc_Ah = bmsMem.rcc / 3600000;
			tmpWrFCC[0] = (fcc>>24) & 0xff;
			tmpWrFCC[1] = (fcc>>16) & 0xff;
			tmpWrFCC[2] = (fcc>> 8) & 0xff;
			tmpWrFCC[3] = (fcc>> 0) & 0xff;
			tmpWrFCC[4] = tmpWrFCC[0] ^ 0xff;
			tmpWrFCC[5] = tmpWrFCC[1] ^ 0xff;
			tmpWrFCC[6] = tmpWrFCC[2] ^ 0xff;
			tmpWrFCC[7] = tmpWrFCC[3] ^ 0xff;
			EEPROM_WrMulByte(EE_FCC,tmpWrFCC);
			delay_ms(20);
			
			fcc_CaliStartFlag = 0; //清零
			if(LSEErrFlag == 0)
			{
				EEPROM_WrMulByte(EE_FCC_TIME,ClearEE);
				delay_ms(5);
			}
		}
	}
}