//********************************************************************
//  Ver 1.0
//      2021.11.19  1、新建文件。
//********************************************************************
#include    "config.h"
#if 0
const    INT16U OcvTab2510[] =
{
    3000,    //0%
    3442,    //10%
    3540,    //20%
    3599,    //30%
    3656,    //40%
    3732,    //50%
    3803,    //60%
    3920,    //70%
    3993,    //80%
    4060,    //90%
    //3606,    //100%
    4130,    //100%
    4150,    //105%
    4200,    //110%
};
#endif

SOC_Str SOC_Info;

void    SOC_Init(void)
{
    SOC_InfoInit();
    SOC_Voltage = BATT_VcAvg;   //初始化开路电压等于平均电压
    BATT_FCC = BATT_FLASH_PFCC;
    SOC_Rsoc = SOC_Ocv(SOC_Voltage, (INT16U *) & (SOC_OcvTab[0])); //上电初始化电量值
    SOC_mAh = (BATT_FCC * SOC_Rsoc) / 100;
}

void    SOC_CaliCnt(void)
{
    if (SOC_Idle < (2 * 60 * 60)) //2小时重新计算一次容量
    {
        SOC_Idle ++;
    }
    else
    {
        SOC_Init();
        SOC_Idle = 0;
    }
}

INT8U   SOC_Ocv(INT16U   Volt, INT16U *pOCV)
{
    INT8U i, j, tSoc = 0;

    if(Volt < pOCV[0])
    {
        return(0);
    }
    else if(Volt > pOCV[10])
    {
        return(100);
    }

    for (i = 0; i < 11; i++)
    {
        if (pOCV[i] > Volt)
        {
            break;
        }
        else if (i > 0)
        {
            tSoc += 10;
        }
    }

    for (j = 0; j < 10; j++)
    {
        if ((pOCV[i - 1] + j * ((pOCV[i] - pOCV[i - 1]) / 10)) > Volt)
        {
            break;
        }
        else if (j > 0)
        {
            tSoc++;
        }
    }

    return (tSoc);
}

void    SOC_ResCalculate(INT8U tSoc)
{
    if(tSoc == 0)
    {
        SOC_CellRes = SOC_ResTab[0];
        return;
    }
    else if(tSoc == 100)
    {
        SOC_CellRes = SOC_ResTab[10];
        return;
    }

    SOC_CellRes = SOC_ResTab[(tSoc / 10) + 1] - SOC_ResTab[tSoc / 10];
    SOC_CellRes = (SOC_CellRes * (tSoc % 10)) / 10 + SOC_ResTab[tSoc / 10];
}

#ifdef SOC_MODE_GAS
void   SOC_CC(void)
{
    INT32S  tVoltage;
    INT8U   tRSOC;

    //按电压计算电池容量
    //tVoltage = BATT_Voltage - ((BATT_Current / 10) * SOC_ResTab[SOC_Rsoc / 10]) / 10000;
    SOC_ResCalculate(SOC_Rsoc);
    //tVoltage = BATT_Voltage - ((BATT_Current / 10) * SOC_CellRes) / 10000;
    tVoltage = ((BATT_Current / 10) * SOC_CellRes) / 10000;
    tVoltage /= CELL_SIZE;

    if (BATT_FLAG_STA == STA_CHG)   //2022.03.18 增加充电按电芯单体最高电压计算，非充电状态按电芯单体最低电压计算
    {
        tVoltage = BATT_VcMax - tVoltage;
    }
    else //if (BATT_FLAG_STA == STA_DSG)
    {
        tVoltage = BATT_VcMin - tVoltage;
    }

    tRSOC = SOC_Ocv(SOC_Voltage, (INT16U *) & (SOC_OcvTab[0]));

    //二级滤波电池平均电压
    if ((SOC_Voltage > 2000) &&
            (SOC_Voltage < 4500))
    {
        if (Diff(SOC_Voltage, tVoltage) >= 500)
        {
            SOC_Voltage = tVoltage;
        }
        else if (SOC_Voltage > tVoltage)
        {
            SOC_Voltage--;
        }
        else if (SOC_Voltage < tVoltage)
        {
            SOC_Voltage++;
        }

        if (Diff(tRSOC, SOC_Rsoc) > 30)
        {
            if (SOC_Idle < (30000 / 100))
            {
                SOC_Idle++;
            }
            else
            {
                SOC_Rsoc = tRSOC;
                SOC_mAh = (BATT_FCC * SOC_Rsoc) / 100;
                SOC_Idle = 0;
                //BATT_FLAG_UVP = 0;  //2021.10.13 增加低是关闭后，电量重新修正时清除低电标志
            }
        }
    }
    else    //2021.09.27 增加OCV电压超出范围后，及时更新OCV电压
    {
        SOC_Voltage = BATT_VcMin;   //2022.03.18 修正电量计算按电芯单体最小电压计算
        SOC_Idle = (30000 / 100);
    }

    if (BATT_Current < BATT_FLASH_DsgcMin)    //放电电流
    {
        if (BATT_FLAG_STA != STA_DSG)
        {
            SOC_StateCnt ++;
            if (SOC_StateCnt > 4)
            {
                SOC_StateCnt = 0;
                BATT_FLAG_STA = STA_DSG;
                SOC_FLAG_HOLD100 = 0;
            }
        }

        //if (SOC_Voltage < SOC_OcvTab[1])
        if(SOC_Rsoc < 10)
        {
            BATT_FLAG_FD = 1;
            SOC_FLAG_CYCLE |= 0x01;
        }
        if(((BATT_ChargeEndSoc - 3) > SOC_Rsoc) &&
                (BATT_FLAG_LCCHG == 2))
        {
            BATT_FLAG_FC = 0;
            BATT_FLAG_LCCHG = 0;
        }
        else if(SOC_Rsoc < 90)
        {
            BATT_FLAG_FC = 0;
        }

        //开路电压计算的容量与积分容量偏差较大时，进行修正
        if(SOC_Rsoc > 40)
        {
            NOP();
        }
        else if (tRSOC > (SOC_Rsoc + 2))
        {
            SOC_mAs -= (BATT_Current / 4);
        }
        else if (SOC_Rsoc > (tRSOC + 2))
        {
            SOC_mAs += (BATT_Current / 2);
        }

        if (SOC_FLAG_DOD == 0)  //2021.08.18 增加放电深度积分
        {
            if(SOC_Rsoc >= 99)
            {
                SOC_FLAG_DOD = 1;
            }
            else
            {
                SOC_FLAG_DOD = 2;
            }
            SOC_DOD = 0;
            SOC_FLAG_FULL = 0;
            //SOC_DodmAs = 0;
        }
        else
        {
            //SOC_DodmAs += BATT_Current;
            SOC_DOD = SOC_DOD - SOC_mAs / 36000;
        }
        SOC_Idle = 0;
    }
    else if (BATT_Current > BATT_FLASH_ChgcMin) //充电电流
    {
        if (BATT_FLAG_STA != STA_CHG)
        {
            SOC_StateCnt ++;
            if (SOC_StateCnt > 4)
            {
                SOC_StateCnt = 0;
                BATT_FLAG_STA = STA_CHG;
                SOC_FLAG_DOD = 0;
                SOC_FLAG_HOLD1 = 0;
            }
        }
        //if (SOC_Voltage > SOC_OcvTab[9])
        if((SOC_Rsoc == 100) ||
                (BATT_FCC < SOC_mAh))    //剩余容量大于满充容量
        {
            BATT_FLAG_FC = 1;
            SOC_FLAG_CYCLE |= 0x02;
        }

        if(SOC_Rsoc > 20)
        {
            BATT_FLAG_FD = 0;
        }

        //开路电压计算的容量与积分容量偏差较大时，进行修正
        if(tRSOC < 70)
        {
            NOP();
        }
        else if (tRSOC > (SOC_Rsoc + 2))
        {
            SOC_mAs += BATT_Current;
        }
        else if ((SOC_Rsoc > (tRSOC + 2)) ||
                 (SOC_Rsoc >= 99))
        {
            SOC_mAs -= (BATT_Current / 2);
        }


        SOC_Idle = 0;
        //SOC_FLAG_DOD = 0;
    }
    else
    {
        if (BATT_FLAG_STA != STA_IDLE)
        {
            SOC_StateCnt ++;
            if (SOC_StateCnt > 4)
            {
                SOC_StateCnt = 0;
                BATT_FLAG_STA = STA_IDLE;
                SOC_FLAG_DOD = 0;
            }
        }

        if (SOC_FLAG_CYCLE == 0x03) //循环计数增加
        {
            BATT_Cycle++;
            SOC_FLAG_CYCLE = 0;
            if ((BATT_Cycle % 10) == 0)
            {
                if (BATT_Cycle > 10) //500个循环，容量剩余60%计算损耗
                {
                    BATT_FCC = BATT_FCC - BATT_FCC / 100;
                }
                BATT_CmdProcess(SCP_CMD_SAVE_FCC, (INT8U *) & (BATT_Info.Info.Fcap));
            }
        }
    }



    //容量积分,电流为1mA单位，
    SOC_mAs += BATT_Current;
    SOC_mAh = SOC_mAh + SOC_mAs / 36000;
    SOC_mAs %= 36000;

    //电压点修正容量百分比
    if ((SOC_Voltage > 4150) ||
            (BATT_FLAG_OV >= 1))  //电池平均电压高于开路电压100时，进入电量修正状态
    {
        if (SOC_Cnt < 200)
        {
            if(((BATT_Current > 0) &&  (BATT_Current < SOC_CHG_FULL)) ||
                    ((BATT_FLAG_CRGLINK != 0) && (BATT_Current == 0)))
            {
                SOC_Cnt++;
            }
            else
            {
                SOC_Cnt = 0;
            }
        }
        else if(SOC_mAh < BATT_FCC)
        {
            SOC_mAh = SOC_mAh + SOC_RecoupValue;
            SOC_Cnt = 0;
        }
        else if (SOC_FLAG_FULL == 0)
        {
            SOC_Rsoc = 100;
            SOC_FLAG_HOLD100 = 1;
            SOC_FLAG_FULL = 1;
            SOC_Cnt = 0;
            if (SOC_mAh > (BATT_FCC + SOC_RecoupValue))
            {
                BATT_FCC = BATT_FCC + SOC_RecoupValue;
            }
            else
            {
                BATT_FCC = BATT_FCC - SOC_RecoupValue;
            }
            //SOC_mAh = BATT_FCC + SOC_RecoupValue;
        }

    }
    else if ((SOC_OcvTab[0] >= SOC_Voltage) ||
             (BATT_FLAG_UV >= 1))
    {
        if (SOC_Cnt < 20)
        {
            if (BATT_Current < 0)
            {
                SOC_Cnt++;
            }
            else
            {
                SOC_Cnt = 0;
            }
        }
        else if(SOC_mAh > SOC_RecoupValue)
        {
            //SOC_Rsoc --;
            SOC_mAh -= SOC_RecoupValue;
            SOC_Cnt = 0;
        }
        else if(SOC_FLAG_HOLD1 == 0)
        {
            SOC_Cnt = 0;
            SOC_Rsoc = 0;
            SOC_mAh = 1;
            /*
            if(SOC_FLAG_DOD == 1)
            {
                BATT_FCC = SOC_DOD;
                SOC_FLAG_DOD = 0;
            }
            else */
            if (BATT_FCC < SOC_DOD)
            {
                BATT_FCC += SOC_RecoupValue;
            }
            else
            {
                BATT_FCC -= SOC_RecoupValue;
            }
            SOC_FLAG_HOLD1 = 1;
        }
    }

    //限制积分容量最小值为1
    if (SOC_mAh < 1)
    {
        SOC_mAh = 1;  //2020.04.13 修正容量小于0的情况
    }

    SOC_Rsoc = ((SOC_mAh + SOC_RecoupValue) * 100) / BATT_FCC;  //2021.10.08 增加容量显示补偿
    //SOC_Rsoc = (SOC_mAh * 100) / BATT_FCC;  //2021.10.08 增加容量显示补偿

    if (SOC_Rsoc > 102)
    {
        //BATT_FCC = BATT_FCC + SOC_RecoupValue;
        //SOC_FLAG_FULL = 1;
        SOC_Rsoc = 100;
    }
    else if (SOC_Rsoc >= 100)                             //2021.09.27 增加电量102%时更新一次FCC
    {
        SOC_Rsoc = 100;
        /*
        if((BATT_Current > 100) &&
           (BATT_Current < 2000))
        {
            SOC_FLAG_FULL = 1;
        }
        */
    }

    if ((SOC_Rsoc > 99) &&
            (BATT_FLAG_STA == STA_CHG) &&
            (SOC_FLAG_HOLD100 == 0))
    {
        SOC_Rsoc = 99;
    }

    if((SOC_Rsoc == 0) &&
            //(BATT_FLAG_UV == 0) &&
            (BATT_FLAG_STA == STA_DSG) &&
            (SOC_FLAG_HOLD1 == 0))
    {
        SOC_Rsoc = 1;
    }

    if((BATT_FLAG_UV > 1) &&
            (SOC_FLAG_HOLD1 == 0))
    {
        SOC_FLAG_HOLD1 = 1;
        SOC_Rsoc = 0;
        SOC_mAh = 1;
    }

    if((BATT_FLAG_CRGLINK != 0) &&
            (SOC_FLAG_HOLD100 == 0) &&
            (SOC_Rsoc == 100))
    {
        SOC_FLAG_HOLD100 = 1;
    }

    if(SOC_Rsoc < 10)
    {
        BATT_FLAG_SOCL = 1;
    }
    //else if(BATT_FLAG_STA == STA_CHG)
    else if(SOC_Rsoc > 20)  //2022.09.01 修改低电量标志位清除条件，解决模拟测试没有充电状态，低电标志不清除问题
    {
        BATT_FLAG_SOCL = 0;
    }

    if(SOC_Rsoc == 100)   //2022.09.01 增加电量充满标志设置条件，解决模拟测试没有充电状态，充满标志位不能置位问题
    {
        BATT_FLAG_FC = 1;
    }
    else if(SOC_Rsoc < 90)
    {
        BATT_FLAG_FC = 0;
    }

#if 0
    //电量20%和80%强制修正电量
    if (BATT_FLAG_STA == STA_IDLE)
    {
        if (SOC_Voltage < SOC_OcvTab[2])
        {
            if (tRSOC > (SOC_Rsoc + 5))
            {
                SOC_mAh += 10;
            }
            else if ((5 + tRSOC) < SOC_Rsoc)
            {
                SOC_mAh -= 10;
            }
        }
        else if (SOC_Voltage > SOC_OcvTab[8])
        {
            if (tRSOC > (SOC_Rsoc + 5))
            {
                SOC_mAh += 10;
            }
            else if ((5 + tRSOC) < SOC_Rsoc)
            {
                SOC_mAh -= 10;
            }
        }
    }
#endif

}
#endif


#ifdef SOC_MODE_OCV
void   SOC_CC(void)
{
    INT16U  tVoltage = BATT_VcAvg;
    INT8U   tRSOC;

#if 1
    if (BATT_Current < BATT_FLASH_DsgcMin)    //放电电流
    {
        BATT_FLAG_STA = STA_DSG;
        if (SOC_Voltage < SOC_OcvTab[1])
        {
            BATT_FLAG_FD = 1;
        }

        //开路电压计算的容量与积分容量偏差较大时，进行修正
        tVoltage = BATT_VcAvg + ((0 - BATT_Current) * SOC_ResTab[SOC_Rsoc / 10]) / 100000;
        if (tRSOC > (SOC_Rsoc + 3))
        {
            SOC_mAs -= (BATT_Current / 2);
        }
        else if (SOC_Rsoc > (tRSOC + 3))
        {
            SOC_mAs += (BATT_Current / 2);
        }

        SOC_Idle = 0;
    }
    else if ((INT16S)BATT_Current > BATT_FLASH_ChgcMin) //充电电流
    {
        BATT_FLAG_STA = STA_CHG;
        if (SOC_Voltage > SOC_OcvTab[9])
        {
            BATT_FLAG_FC = 1;
        }

        //开路电压计算的容量与积分容量偏差较大时，进行修正
        tVoltage = BATT_VcAvg - ((BATT_Current) * SOC_ResTab[SOC_Rsoc / 10]) / 100000;
        if (tRSOC > (SOC_Rsoc + 3))
        {
            SOC_mAs += (BATT_Current / 2);
        }
        else if (SOC_Rsoc > (tRSOC + 3))
        {
            SOC_mAs -= (BATT_Current / 2);
        }

        SOC_Idle = 0;
    }
    else
    {
        BATT_FLAG_STA = STA_IDLE;
    }

    if ((BATT_FLAG_FC != 0) &&
            (BATT_FLAG_FD != 0)) //循环计数增加
    {
        BATT_Cycle++;
        BATT_FLAG_FC = 0;
        BATT_FLAG_FD = 0;
        /*
        if((BATT_Cycle % 5) == 0)  //循环损耗按5个循环1％计算
        {
            BATT_Info.Flash.FullChargeCapacity = BATT_Info.Flash.FullChargeCapacity - BATT_Info.Flash.FullChargeCapacity / 100;
            BATT_FlashCmdProcess(SCP_CMD_SET_FCC, (INT8U *)&(BATT_Info.Flash.FullChargeCapacity));
        }
        */
    }
#endif

    //二级滤波电池平均电压
    if ((SOC_Voltage > 1000) && (SOC_Voltage < 4500))
    {
        if (SOC_Voltage > tVoltage)
        {
            SOC_Voltage--;
        }
        else if (SOC_Voltage < tVoltage)
        {
            SOC_Voltage++;
        }

        if(Diff(SOC_Voltage, BATT_VcAvg) >= 200)
        {
            SOC_Voltage = BATT_VcAvg;
        }
    }
    else
    {
        SOC_Voltage = BATT_VcAvg;
    }

    //按电压计算电池容量
    tRSOC = SOC_Ocv(SOC_Voltage, (INT16U *) & (SOC_OcvTab[0]));

    //计算电压
    if(SOC_Cnt < 50)
    {
        SOC_Cnt++;
    }
    else
    {
        if((tRSOC > SOC_Rsoc) &&
                (SOC_Rsoc < 100) &&
                (BATT_Current > 100))
        {
            if((SOC_Rsoc == 0) &&
                    (tRSOC > (SOC_Rsoc + 5)))
            {
                SOC_Rsoc = tRSOC;
            }
            SOC_Rsoc++;
        }
        else if((tRSOC < SOC_Rsoc) &&
                (SOC_Rsoc > 0))
        {
            SOC_Rsoc--;
        }

        if(Diff(SOC_Rsoc, tRSOC) >= 30)	//差值大于30时，直接更新
        {
            SOC_Rsoc = tRSOC;
        }

        SOC_Cnt = 0;
    }

    SOC_mAh = (BATT_FCC * SOC_Rsoc) / 100;

    if(SOC_Rsoc > 100) SOC_Rsoc = 100;



}
#endif