#include "../main/SystemInclude.h"
//==============================================================================
/*
resFactor,temperatureFactor must be define in internal modbus
*/
u16 calibTANode[CURVE_DATA_MAX];
u16 calibTAVal[CURVE_DATA_MAX], curveTANum;

/******************************************************************************/
void TemperatureCorrectInit(void)
{
}
	
/******************************************************************************/
void TemperatureCorrection(void)
{
  float tempF;

#ifndef TEMP_CORR_USE_RR 
#pragma message("[undefined] TEMP_CORR_USE_RR")
#elif(TEMP_CORR_USE_RR)
  // currentFlowRate = ((RH-RHROOM)*temperatureFactor*currentFlowRate)/(RHROOM*resFactor)
  // resFactor: default 0.0030 --->30    
  // temperatureFactor: default 0.0030 --->30   
//  tmpSLA  = (signed long int)voltageDetected[NRR];
//  tmpSLA -= (signed long int)NRHRoom;
//  tmpSLA *= (signed long int)temperatureFactor;
//  tmpSLA *= (signed long int)10000;
//  
//  tmpSLB  = (signed long int)NRHRoom;
//  tmpSLB *= (signed long int)resFactor;
//  tmpSLA /= tmpSLB;
//  tmpSLA += (signed long int)10000;
  
  #ifndef ENABLE_MULTI_PONIT_TA_CORR
  #pragma message("[undefined] ENABLE_MULTI_PONIT_TA_CORR")
  #elif(ENABLE_MULTI_PONIT_TA_CORR)
  tmpSLB  = (signed long int)GetTACurveValue(voltageDetected[CTYPE_FR]);  
  #else
  tmpSLB  = (signed long int)NRHRoom;
  #endif
    
  if((tmpSLB > NRR_MAX) || (tmpSLB < NRR_MIN))
  {
     voltageDetected[TCOE] = 10000;
     return;
  }
  
  tmpSLA  = (signed long int)voltageDetected[NRR];
  tmpSLA -= (signed long int)tmpSLB;
  tmpSLA *= (signed long int)temperatureFactor;
  tmpSLA *= (signed long int)10000;
  
  tmpSLB *= (signed long int)resFactor;
  tmpSLA /= tmpSLB;
  tmpSLA += (signed long int)10000;
//------------------------------------------------------------------------------
#else
//------------------------------------------------------------------------------
  #ifndef ENABLE_MULTI_PONIT_TA_CORR
  #pragma message("[undefined] ENABLE_MULTI_PONIT_TA_CORR")
  #elif(ENABLE_MULTI_PONIT_TA_CORR)
  tmpSLB = (signed long int)GetTACurveValue(voltageDetected[CTYPE_FR]);
  #else
  tmpSLB = (signed long int)calibTemperature;
  #endif

  if((tmpSLB > 13500) || (tmpSLB < 11000))
  {
     voltageDetected[TCOE] = 10000;
     return;
  }
  
  #ifndef TEMP_CORR_USE_TA 
  #pragma message("[undefined] TEMP_CORR_USE_TA")
  #elif(TEMP_CORR_USE_TA)
  tmpSLA  = (signed long int)voltageDetected[TPCB];
  #else
  tmpSLA  = (signed long int)voltageDetected[TGAS];
  #endif

  tmpSLA -= tmpSLB;
  tmpSLA *= (signed long int)temperatureFactor;
  tmpSLA /= (signed long int)100;
  tmpSLA += (signed long int)10000;
#endif
//------------------------------------------------------------------------------
  
  if(tmpSLA > 12000)       tmpSLA = 12000;
  else if(tmpSLA < 8000)   tmpSLA = 8000;
  voltageDetected[TCOE] = (unsigned int)tmpSLA;
  tempF   = (float)tmpSLA;
  tempF  /= (float)10000;
  tempF  *= (float)currentFlowRate;
  
  currentFlowRate = (unsigned long int)tempF;
}

//******************************************************************************
//读二次修正曲线节点流量
u8 ReadTACurveNodeAndValue(u16 I)
{
  ReadMultiByteFromEEPROM(TACURVE_DATA_BASE + I * TACURVE_DATA_WIDTH, tempDev.Byte, TACURVE_DATA_WIDTH, PARA_EEPROM);
  if(tempDev.Byte[TACURVE_DATA_CRC] == CRC8(tempDev.Byte, TACURVE_DATA_CRC))
  {
    tempDev.Byte[TACURVE_DATA_CRC] = 0;
    
    calibTAVal[I]  = tempDev.Word[0];      
    calibTANode[I] = tempDev.Word[1]; 
    return 0;
  }
  else
  {
    calibTAVal[I]  = 0;      
    calibTANode[I] = 0; 
    return 1;
  }
}

//******************************************************************************
//默认的二次修正曲线参数
void DefaultTACuvre(void)
{ 
  curveTANum = 5;  
  calibTANode[0] = 0;
  calibTANode[1] = 5000;
  calibTANode[2] = 10000;
  calibTANode[3] = 15000;
  calibTANode[4] = 20000;
  
  calibTAVal[0]  = 0;
  calibTAVal[1]  = 0;
  calibTAVal[2]  = 0;
  calibTAVal[3]  = 0;
  calibTAVal[4]  = 0;
}

//******************************************************************************
//读二次修正曲线参数
void RetriveTACurve(void)
{
  ReadMultiByteFromMemory(TACURVE_NUM, tempL.Byte, TACURVE_NUM_WIDTH); 
  if(tempL.Byte[1] != CRC8(tempL.Byte, 1)) goto RetResetCurve;
  
  curveTANum = tempL.Byte[0];
  if((curveTANum > CURVE_DATA_MAX)||(curveTANum < 3)) goto RetResetCurve;
  
  for(unsigned char I = 0; I < curveTANum; I++) ReadTACurveNodeAndValue(I);
  return;
  
RetResetCurve:
  DefaultTACuvre();
  return;
}

//******************************************************************************
//根据流量计算二次修正值
u16 GetTACurveValue(u16 calibIndex)
{
  u16 I;
  
  if((curveTANum < 3) || (curveTANum > CURVE_DATA_MAX))
  {
    return 0;
  }
  
  for(I = 0; I < curveTANum - 1; I++)
  {
    if(calibTANode[I] > 32767) continue;
    if(calibTANode[I] > calibIndex) break;
  }
  
  if(I == 0) return calibTAVal[0];
  
  Secondary.NodeX  = calibIndex;
  if(calibTANode[I] > 32767) Secondary.NodeH = 0;
  else                       Secondary.NodeH = calibTANode[I];
  if(calibTANode[I-1] > 32767) Secondary.NodeL = 0;
  else                         Secondary.NodeL = calibTANode[I-1];

  Secondary.ValueH = calibTAVal[I];
  Secondary.ValueL = calibTAVal[I-1];
  
  return SecondaryCompute();
  
}

/******************************************************************************/
void ReadCurveByCom(void)
{
  u16 I;   
  
  I  = MBBuf.StartAddr;
  I -= INT_CURVE_NODE1;
  I /= INT_CURVE_WIDTH;      
  
  MBBuf.RxPointer[MBBuf.Index++] = 0;
  MBBuf.RxPointer[MBBuf.Index++] = 0;
  if(calibType == INTCMD_1ST_TABLE) {
    tempL.Word[1] = calibTANode[I];   
    tempL.Word[0] = calibTAVal[I];  
  }
  else if(calibType == INTCMD_2ND_TABLE) {
    tempL.Word[1] = ATypeNode[I];   
    tempL.Word[0] = ATypeVal[I];   
  }
	
  MBBuf.RxPointer[MBBuf.Index++] = tempL.Byte[3];
  MBBuf.RxPointer[MBBuf.Index++] = tempL.Byte[2];
  MBBuf.RxPointer[MBBuf.Index++] = tempL.Byte[1];
  MBBuf.RxPointer[MBBuf.Index++] = tempL.Byte[0];
  
  MBBuf.DataByte = CURVE_DATA_WIDTH;  
  ModbusVariablePointerDec();
}

/******************************************************************************/
void WriteCurveByCom(void)
{    
  MBBuf.DataByte = CURVE_DATA_WIDTH;  
  if(MBBuf.ByteNumber < MBBuf.DataByte) 
  {
    MBBuf.ByteNumber = 0;
    MBBuf.BusError = ILLEGAL_DATA_VALUE;
    return;
  }
  
  u16 I;
  
  I  = MBBuf.StartAddr;
  I -= INT_CURVE_NODE1;
  I /= INT_CURVE_WIDTH;
  
  tempDev.Byte[5] = MBBuf.RxPointer[MBBuf.Index++];
  tempDev.Byte[4] = MBBuf.RxPointer[MBBuf.Index++];  
  tempDev.Byte[3] = MBBuf.RxPointer[MBBuf.Index++];
  tempDev.Byte[2] = MBBuf.RxPointer[MBBuf.Index++];  
  tempDev.Byte[1] = MBBuf.RxPointer[MBBuf.Index++];
  tempDev.Byte[0] = MBBuf.RxPointer[MBBuf.Index++]; 
  
  tempDev.DWord[1] = 0;      
  if(calibType == INTCMD_1ST_TABLE)
  {
    WriteMultiByteToMemory(TACURVE_DATA_BASE+I*TACURVE_DATA_WIDTH, &tempDev.Byte[0], TACURVE_DATA_WIDTH);
    calibTANode[I] = tempDev.Word[1];
    calibTAVal[I]  = tempDev.Word[0]; 
  }
  else if(calibType == INTCMD_2ND_TABLE)
  {
    WriteMultiByteToMemory(ATYPECURVE_DATA_BASE+I*ATYPECURVE_DATA_WIDTH, &tempDev.Byte[0], ATYPECURVE_DATA_WIDTH);
    ATypeNode[I] = tempDev.Word[1];
    ATypeVal[I]  = tempDev.Word[0]; 
  }
}