//-------------------------------------------------------//
//        Project Code : V2H6K01-23-ENEMAN
//           File Name : EepromLib.h
//          Created on : 2023. 10. 31.
//         Description : EEPROM Library (SPI-Type)
//              Author : "Kim JeongWoo"
//  Last modified Date :
//-------------------------------------------------------//

#include "CommonLib.h"


//나중에 DMA로 처리 할 것!!!!
//FIFO 적용할 것!!!!!!!!
//지금은 임시!!!!!!!!!!
//코드 컨벤션 및 변수 네이밍 나중에 수정 할 것!!!!!!!!

uint16_t EepromChkClrBuf[10] = {0,0,0,0,0,0,0,0,0,0};
uint16_t EepromChkRdBuf[10] = {0,0,0,0,0,0,0,0,0,0};
uint16_t EepromChkCodeSet[10] = {'N','e','x','t','S','q','u','a','r','e'};

unsigned int EepromChkCnt = 0;

float Testpcs1 = 1024;
float Testpcs2 = 1024;
float Testpcs3 = 1024;

void EepromChkCodeClr()
{
    WriteEepromArray(pEepromChk + 0, EepromChkClrBuf, 10);
}

void EepromChkCodeWr()
{
    WriteEepromArray(pEepromChk + 0, EepromChkCodeSet, 10);
}

unsigned int EepromInitStatus = 0;


int FlagTestEeprom = 0;


void EepromChk()
{
	int i = 0;

	ReadEeprom(pEepromChk + 0, EepromChkRdBuf, 10);

	for(i = 0; i < 10; i++)
	{
//		if(EepromChkRdBuf[i] != EepromChkCodeSet[i]) EepromChkCnt++;
//	    if(EepromChkCnt != 0) Fault.Sw3.bit.Err_Nvram |= 1;
	}

	if(EepromChkCnt != 0)
	{
		//임시
		memset(&ScaleDelt, 0, (sizeof(ScaleDelt) / sizeof(int)));
		memset(&Adc.OffsetDelt, 0, (sizeof(Adc.OffsetDelt) / sizeof(int)));
		ResetDioExor();

		WriteEepromArray(pEepromChk + 0, EepromChkCodeSet, 10);
		EepromWriteAdcScale();
		EepromWriteAdcOffset();
		EepromWriteDioExor();

//		EepromChkCnt = 0;
		EepromInitStatus = 1;
	}
}



void EepromWriteDioExor()
{
    WriteEepromInt(pEepromExor + 0, &Din.Exor.all);
    WriteEepromInt(pEepromExor + 1, &Dout.Exor.all);
}
void EepromReadDioExor()
{
    ReadEepromInt(pEepromExor + 0, &Din.Exor.all);
    ReadEepromInt(pEepromExor + 1, &Dout.Exor.all);
}

void EepromWriteAdcScale()
{
	WriteEepromFloat(pEepromAdcScale + 0, &Testpcs1);
	WriteEepromFloat(pEepromAdcScale + 1, &Testpcs2);
	WriteEepromFloat(pEepromAdcScale + 2, &Testpcs3);
//	WriteEepromFloat(pEepromAdcScale + 3, &ScaleDelt.Vdab);
//	WriteEepromFloat(pEepromAdcScale + 4, &ScaleDelt.AdcCh05);
//	WriteEepromFloat(pEepromAdcScale + 5, &ScaleDelt.VdcH);
//	WriteEepromFloat(pEepromAdcScale + 6, &ScaleDelt.VdcL);
//	WriteEepromFloat(pEepromAdcScale + 7, &ScaleDelt.VunGrid);
//	WriteEepromFloat(pEepromAdcScale + 8, &ScaleDelt.VnwGrid);
//	WriteEepromFloat(pEepromAdcScale + 9, &ScaleDelt.IuInv);
//	WriteEepromFloat(pEepromAdcScale + 10, &ScaleDelt.IwInv);
//	WriteEepromFloat(pEepromAdcScale + 11, &ScaleDelt.Izct);
//	WriteEepromFloat(pEepromAdcScale + 12, &ScaleDelt.IuGridExt);
//	WriteEepromFloat(pEepromAdcScale + 13, &ScaleDelt.IwGridExt);
//	WriteEepromFloat(pEepromAdcScale + 14, &ScaleDelt.VntcBoost);
//	WriteEepromFloat(pEepromAdcScale + 15, &ScaleDelt.VntcLvDab);
//	WriteEepromFloat(pEepromAdcScale + 16, &ScaleDelt.VntcHvDab);
//	WriteEepromFloat(pEepromAdcScale + 17, &ScaleDelt.VntcInv);
//	WriteEepromFloat(pEepromAdcScale + 18, &ScaleDelt.Vntc5);
//	WriteEepromFloat(pEepromAdcScale + 19, &ScaleDelt.Vntc6);
//	WriteEepromFloat(pEepromAdcScale + 20, &ScaleDelt.VunInv);
//	WriteEepromFloat(pEepromAdcScale + 21, &ScaleDelt.VnwInv);
//	WriteEepromFloat(pEepromAdcScale + 22, &ScaleDelt.IuGrid);
//	WriteEepromFloat(pEepromAdcScale + 23, &ScaleDelt.IwGrid);
}

void EepromReadAdcScale()
{
	ReadEepromFloat(pEepromAdcScale + 0, &Testpcs1);
	ReadEepromFloat(pEepromAdcScale + 1, &Testpcs2);
	ReadEepromFloat(pEepromAdcScale + 2, &Testpcs3);
//	ReadEepromFloat(pEepromAdcScale + 3, &ScaleDelt.Vdab);
//	ReadEepromFloat(pEepromAdcScale + 4, &ScaleDelt.AdcCh05);
//	ReadEepromFloat(pEepromAdcScale + 5, &ScaleDelt.VdcH);
//	ReadEepromFloat(pEepromAdcScale + 6, &ScaleDelt.VdcL);
//	ReadEepromFloat(pEepromAdcScale + 7, &ScaleDelt.VunGrid);
//	ReadEepromFloat(pEepromAdcScale + 8, &ScaleDelt.VnwGrid);
//	ReadEepromFloat(pEepromAdcScale + 9, &ScaleDelt.IuInv);
//	ReadEepromFloat(pEepromAdcScale + 10, &ScaleDelt.IwInv);
//	ReadEepromFloat(pEepromAdcScale + 11, &ScaleDelt.Izct);
//	ReadEepromFloat(pEepromAdcScale + 12, &ScaleDelt.IuGridExt);
//	ReadEepromFloat(pEepromAdcScale + 13, &ScaleDelt.IwGridExt);
//	ReadEepromFloat(pEepromAdcScale + 14, &ScaleDelt.VntcBoost);
//	ReadEepromFloat(pEepromAdcScale + 15, &ScaleDelt.VntcLvDab);
//	ReadEepromFloat(pEepromAdcScale + 16, &ScaleDelt.VntcHvDab);
//	ReadEepromFloat(pEepromAdcScale + 17, &ScaleDelt.VntcInv);
//	ReadEepromFloat(pEepromAdcScale + 18, &ScaleDelt.Vntc5);
//	ReadEepromFloat(pEepromAdcScale + 19, &ScaleDelt.Vntc6);
//	ReadEepromFloat(pEepromAdcScale + 20, &ScaleDelt.VunInv);
//	ReadEepromFloat(pEepromAdcScale + 21, &ScaleDelt.VnwInv);
//	ReadEepromFloat(pEepromAdcScale + 22, &ScaleDelt.IuGrid);
//	ReadEepromFloat(pEepromAdcScale + 23, &ScaleDelt.IwGrid);
}

void EepromWriteAdcOffset()
{
	int idx = 0;

	for (idx = 0; idx < 32; idx++)
	{
	    WriteEepromFloat(pEepromAdcOffset + idx, &Adc.OffsetDelt[idx]);
	}
}

void EepromReadAdcOffset()
{
	int idx = 0;

	for (idx = 0; idx < 32; idx++)
	{
		ReadEepromFloat(pEepromAdcOffset + idx, &Adc.OffsetDelt[idx]);
	}
}

unsigned int FlagRstAdcPara = 0;
unsigned int FlagWrAdcScale = 0;
unsigned int FlagRdAdcScale = 0;
unsigned int FlagWrAdcOffset = 0;
unsigned int FlagRdAdcOffset = 0;

//unsigned int FlagRstDioExor = 0;
unsigned int FlagRdDioExor = 0;
//unsigned int FlagWrDioExor = 0;

unsigned int FlagEepromRstAll = 0;
unsigned int FlagEepromWrAll = 0;
unsigned int FlagEepromRdAll = 0;
unsigned int FlagEepromChkClr = 0;

void EepromCmds()
{
	if(FlagEepromRstAll == 1)
	{
		FlagRstAdcPara = 1;
		FlagRstDioExor = 1;
		FlagEepromRstAll = 0;
	}

	if(FlagEepromWrAll == 1)
	{
        FlagWrAdcScale = 1;
        FlagWrAdcOffset = 1;
		FlagWrDioExor = 1;
		FlagEepromWrAll = 0;
	}

	if(FlagEepromRdAll == 1)
	{
        FlagRdAdcScale = 1;
        FlagRdAdcOffset = 1;
		FlagRdDioExor = 1;
		FlagEepromRdAll = 0;
	}

    if(FlagRdDioExor == 1 )
    {
        EepromReadDioExor();
        FlagRdDioExor = 0;
    }

    if(FlagWrDioExor == 1 )
    {
        EepromWriteDioExor();
        FlagWrDioExor = 0;
    }


	if(FlagRdAdcScale == 1 )
	{
		EepromReadAdcScale();
		FlagRdAdcScale = 0;
	}

	if(FlagWrAdcScale == 1 )
	{
		EepromWriteAdcScale();
		FlagWrAdcScale = 0;
	}

    if(FlagRdAdcOffset == 1 )
    {
        EepromReadAdcOffset();
        FlagRdAdcScale = 0;
    }

    if(FlagWrAdcOffset == 1 )
    {
        EepromWriteAdcOffset();
        FlagWrAdcOffset = 0;
    }

    if(FlagRstAdcPara == 1)
    {
    	//임시
		memset(&ScaleDelt, 0, (sizeof(ScaleDelt) / sizeof(int)));
		memset(&Adc.OffsetDelt, 0, (sizeof(Adc.OffsetDelt) / sizeof(int)));
        FlagRstAdcPara = 0;
    }

    if(FlagRstDioExor == 1)
    {
        ResetDioExor();
        FlagRstDioExor = 0;
    }

	if(FlagEepromChkClr == 1)
	{
	    EepromChkCodeClr();
	    FlagEepromChkClr = 0;
	}

}