#include "../main/SystemInclude.h"

//##############################################################################
#if(DP2201_CORE_V5000)
//##############################################################################
// for compute buffer
u32 compareBaseCounter;
u16 compareBaseValue;

//u16 VDUGXHigh, VDUGXRoom, VDUGXLow, sampleSwitchThreshold; 
float RhExtGain, RRExtGain;


/**************************************************************************************/
/**
 * @brief 电路计算参数初始化
 * @note  
 * @warning
 */ 
void RHCircuitParameterInit(void)
{
  // A type external gain res
  // RhExtGainRes = ReadShortParameterFromEEPROM(RH_GAINRES, RH_GAINRES_WIDTH, RH_GAINRES_DEFAULT);
  // RhExtGain    = 1.0/(float)RhExtGainRes;
	
  //RRExtGainRes = ReadShortParameterFromEEPROM(RR_GAINRES, RR_GAINRES_WIDTH, RR_GAINRES_DEFAULT);
// RRExtGain    = (float)RRExtGainRes;
// RRExtGain   *= (float)VREF_VDC;
  
  //sampleSwitchThreshold = ReadShortParameterFromEEPROM(SAMPLE_THRESHOLD, SAMPLE_THRESHOLD_WIDTH, SAMPLE_THRESHOLD_DEFAULT);
}

/**************************************************************************************/
/**
 * @brief 校准零点
 * @note  
 * @warning
 */ 
void CalibrateOffset(void)
{
  tempL.Word[0] = voltageDetected[NIDX];
  offsetAir = WriteShortParameterToMemory(GET_WORD_ADDR(offsetAir));
  //tempL.Word[0] += 30;
  offsetGas = WriteShortParameterToMemory(GET_MBWORD_ADDR(offsetGas));

  tempL.Word[0] = voltageDetected[VDUGX];
  offsetAirGainx = WriteShortParameterToMemory(GET_WORD_ADDR(offsetAirGainx));
  offsetGasGainx = WriteShortParameterToMemory(GET_WORD_ADDR(offsetGasGainx));
}

/**************************************************************************************/
/**
 * @brief 校准曲线前需要进行的操作：如校零及必要的参数保存等
 * @note  
 * @warning
 */ 
void PreCalibrationParameterWriting(void)
{
  //===========================================================================
  tempL.Word[0] = voltageDetected[NIDX];
  offsetAir = WriteShortParameterToMemory(GET_WORD_ADDR(offsetAir));
  //tempL.Word[0] += 30;
  offsetGas = WriteShortParameterToMemory(GAS_OFFSET); 
	
  tempL.Word[0]  = voltageDetected[VDUGX];
  offsetAirGainx = WriteShortParameterToMemory(GET_WORD_ADDR(offsetAirGainx));
  offsetGasGainx = WriteShortParameterToMemory(GET_WORD_ADDR(offsetGasGainx));  
  //---------------------------------------------------------------------------
  tempL.Word[0] = voltageDetected[RRRES];
  RRRoom = WriteShortParameterToMemory(GET_WORD_ADDR(RRRoom));   
  
  tempL.Word[0] = voltageDetected[IVHDX];
  VHHRoom = WriteShortParameterToMemory(GET_WORD_ADDR(VHHRoom));
  //---------------------------------------------------------------------------
#ifndef TEMP_CORR_USE_TA 
#pragma message("[undefined] TEMP_CORR_USE_TA")
#elif(TEMP_CORR_USE_TA)
  tempL.Word[0] = voltageDetected[TPCB];
#else
  #ifndef ENABLE_GAS_RECOGNITION 
  #pragma message("[undefined] ENABLE_GAS_RECOGNITION")
  #elif(ENABLE_GAS_RECOGNITION)
  tempL.Word[0] = voltageDetected[TGAS];
  #else 
  tempL.Word[0] = voltageDetected[TPCB];
  #endif
#endif
  //---------------------------------------------------------------------------
  calibTemperature = WriteShortParameterToMemory(GET_WORD_ADDR(calibTemperature));  
  //---------------------------------------------------------------------------
 
  currentMode.Bit.PreCalibEnd = 1;
}

/**************************************************************************************/
/**
 * @brief 高低温标定程序：低温参数保存功能
 * @note  
 * @warning
 */ 
void LowTemperatureParameterWriting(void)
{
  if(voltageDetected[TPCB] >= ENABLE_WRITE_TA_LOW)
  {
//    calibType = ('E'<<8)+'R';
    return;
  }
  
  tempL.Word[0] = voltageDetected[TPCB];
  staticLowTemperature = WriteShortParameterToMemory(GET_WORD_ADDR(staticLowTemperature));
  
  tempL.Word[0] = voltageDetected[RRRES];
  RRLow = WriteShortParameterToMemory(GET_WORD_ADDR(RRLow));
  
  tempL.Word[0] = voltageDetected[IVHDX];
  VHHLow = WriteShortParameterToMemory(GET_WORD_ADDR(VHHLow));
  
  // for AType FlowRate Compute
  //tempL.Word[0] = ReadDataFromMovingAverage(PDRH);
  //---------------------------------------------------------------------------
  tempL.Word[0] = voltageDetected[PORH];
  P0RhLow = WriteShortParameterToMemory(GET_WORD_ADDR(P0RhLow));
  
  tempL.Word[0] = voltageDetected[RHRES];
  RHLowTa = WriteShortParameterToMemory(GET_WORD_ADDR(RHLowTa)); 
	
  //---------------------------------------------------------------------------
  tempL.Word[0] = voltageDetected[NIDX];
  OffsetLow = WriteShortParameterToMemory(GET_WORD_ADDR(OffsetLow)); 
	
  tempL.Word[0]  = voltageDetected[VDUGX];
  VDUGXLow = WriteShortParameterToMemory(GET_WORD_ADDR(VDUGXLow));
	
  //---------------------------------------------------------------------------
//  tempL.Word[0]  = ReadShortParameterFromMemory(ZEROCAL_STATE, 0);  
//  tempL.Word[0] &= 0xff00;
//  tempL.Word[0] |= 'L';
//	WriteShortParameterToMemory(ZEROCAL_STATE);	
//	currentMode.Bit.LowCalibEnd = 1;	
//	if(tempL.Word[0] == INTCMD_CALIB_TEMP_END) EnterUserMode();
	
//				 tempL.Word[0] = ReadShortParameterFromMemory(SYS_COMMAND, SYS_COMMAND_WIDTH, 0);  
//		if(tempL.Word[0] == INTCMD_ZERO_CALIB_MODE) EnterZeroCalibMode();
//		else                                        EnterUserMode();

	currentMode.Bit.LowCalibEnd = 1;	
	if( currentMode.Bit.HighCalibEnd && currentMode.Bit.LowCalibEnd ) EnterUserMode();
	tempL.Word[0] = currentMode.Word;
  WriteShortParameterToMemory(SYS_COMMAND);
	
  //calibType = ('L'<<8)+'D';
//  calibType &= 0xff00;
//  calibType |= 'L';
//  
//  zeroCalibType &= 0xff00;
//  zeroCalibType |= 'L';
//  currentMode.Bit.LowCalibEnd = 1;
//  if(zeroCalibType == (('H'<<8)+'L')) 
//  {
//     tempL.Word[0] = 0;
//    // tempL.Word[0] = WriteShortParameterToMemory(GET_WORD_ADDR());
//     EnterUserMode();
//  }
}

/**************************************************************************************/
/**
 * @brief 高低温标定程序：高温参数保存功能
 * @note  
 * @warning
 */ 
void HighTemperatureParameterWriting(void)
{
  if(voltageDetected[TPCB] <= ENABLE_WRITE_TA_HIGH)
  {
//    calibType = ('E'<<8)+'R';
    return;
  }
	
	//------------------------------------------------------------------------------------------------------
  tempL.Word[0] = voltageDetected[TPCB];
  staticHighTemperature = WriteShortParameterToMemory(GET_WORD_ADDR(staticHighTemperature));    
  
  tempL.Word[0] = voltageDetected[RRRES];
  RRHigh = WriteShortParameterToMemory(GET_WORD_ADDR(RRHigh));  
  
  tempL.Word[0] = voltageDetected[IVHDX];
  VHHHigh = WriteShortParameterToMemory(GET_WORD_ADDR(VHHHigh));  
  
  // for AType FlowRate Compute
  tempL.Word[0] = voltageDetected[PORH];
  P0RhHigh = WriteShortParameterToMemory(GET_WORD_ADDR(P0RhHigh));  
  
  tempL.Word[0] = voltageDetected[RHRES];
  RHHighTa = WriteShortParameterToMemory(GET_WORD_ADDR(RHHighTa));  
  
	//------------------------------------------------------------------------------------------------------
  tempL.Word[0] = voltageDetected[NIDX];
  OffsetHigh = WriteShortParameterToMemory(GET_WORD_ADDR(OffsetHigh)); 

  tempL.Word[0]  = voltageDetected[VDUGX];
  VDUGXHigh = WriteShortParameterToMemory(GET_WORD_ADDR(VDUGXHigh));
  //calibType = ('H'<<8)+'D';
//  calibType &= 0x00ff;
//  calibType |= ('H'<<8);
//  zeroCalibType &= 0x00ff;
//  zeroCalibType |= 'H'<<8;  

	//------------------------------------------------------------------------------------------------------
//  tempL.Word[0]  = ReadShortParameterFromMemory(ZEROCAL_STATE, 0);
//  tempL.Word[0] &= 0x00ff;
//  tempL.Word[0] |= ('H'<<8);
//	WriteShortParameterToMemory(ZEROCAL_STATE);

	currentMode.Bit.HighCalibEnd = 1;	
	if( currentMode.Bit.HighCalibEnd && currentMode.Bit.LowCalibEnd ) EnterUserMode();
	tempL.Word[0] = currentMode.Word;
  WriteShortParameterToMemory(SYS_COMMAND);

//	if(tempL.Word[0] == INTCMD_CALIB_TEMP_END) EnterUserMode();
//currentMode.Bit.ZeroCalib
//  if(zeroCalibType == (('H'<<8)+'L')) 
//  {
//     tempL.Word[0] = 0;
//     tempL.Word[0] = WriteShortParameterToMemory(GET_WORD_ADDR());
//     EnterUserMode();
//  }
}

/**************************************************************************************/
/**
 * @brief 高低温标定程序，判断温度是否稳定，是否可以进行参数保存
 * @note  
 * @warning
 */ 
void SaveVHHAndNRHInTempretureMode(void)
{
  if(!currentMode.Bit.ZeroCalib)  return;   
  if(samplingInterval > EXT_POWER_PERIOD_TIME) return;  
  
  if((voltageDetected[TPCB] > ENABLE_WRITE_TA_LOW) && (voltageDetected[TPCB] < ENABLE_WRITE_TA_HIGH)) 
  {   
    compareBaseCounter = 0;
    compareBaseValue = voltageDetected[TPCB];
    return;
  }
  
  compareBaseCounter += (u32)timePeriod;
  if((voltageDetected[TPCB] > compareBaseValue + ENABLE_WRITE_TA_SCALE) || (voltageDetected[TPCB] < compareBaseValue - ENABLE_WRITE_TA_SCALE))
  { 
    compareBaseCounter = 0;
    compareBaseValue = voltageDetected[TPCB];
  }
  else 
  {
    //compareBaseCounter += (unsigned long int)timePeriod;
    if(compareBaseCounter < (unsigned long int)EXIT_5400S) return;                           // 1hours  // 1hours
         if(voltageDetected[TPCB] >= ENABLE_WRITE_TA_HIGH) HighTemperatureParameterWriting();
    else if(voltageDetected[TPCB] <= ENABLE_WRITE_TA_LOW)  LowTemperatureParameterWriting();
    compareBaseCounter=0;
  }
}

/**************************************************************************************/
/**
 * @brief RH参数计算函数
 * @note  
 * @warning
 */ 
void ComputeRHParameter(void)
{ 
  float tmpIH, tmpRH;
  s32 tempCode;   
  
  // comput normal RH
  //============================================================================== 
  // compute RH Voltage
  tempCode  = (s32)voltageDetected[VRHX];
  tempCode -= 32768;
	tmpRH     = (float)tempCode;
  tmpRH    *= (float)VRH_VREF;
  voltageDetected[RHVOL] = (u16)tmpRH;
	
  // compute IRH 
  //===========================================================================
  tempCode  = (s32)voltageDetected[IVHDX];
  tempCode -= 32768;
	tmpIH     = (float)tempCode;
  tmpIH     = tmpIH * (float)IRH_VREF + (float)IRH_VDC;
  tmpIH    /= (float)IRH_RC;
  tmpRH     = tmpRH /tmpIH - (float)IRH_RC;
	tmpRH    *= 10; 
  voltageDetected[RHRES] = (u16)tmpRH; 

// compute RH power
  //===========================================================================
  tmpIH  *= tmpIH;
  tmpIH  *= tmpRH;
  voltageDetected[PORH]  = (u16)tmpIH; 

  //============================================================================== 
  //voltageDetected[PORH]  = MovingAverage(computePower, 5, PORH); 
}

/**************************************************************************************/
/**
 * @brief RR参数计算函数
 * @note  
 * @warning
 */ 
void ComputeRRParameter(void)
{ 
  float tmpVol;
  s32 tempCode; 
  disable_interrupts();	
  // comput normal (VRR)
  //============================================================================== 
  tempCode  = (s32)voltageDetected[VRRX];
  tempCode -= 32768;
	tmpVol    = (float)tempCode;
  tmpVol   *= (float)VRR_VREF;
  tmpVol   += (float)VRR_VDC;
  voltageDetected[RRVOL] = (u16)(tmpVol + VCOM);
	
  // comput normal RR resistance
  //============================================================================== 
	tmpVol = VRR_BRIDGE_VOL/tmpVol - 1.0;
	tmpVol = VRR_RA/tmpVol;
 
  voltageDetected[RRRES] = (u16)tmpVol;
}

/**************************************************************************************/
/**
 * @brief InterCurveProcess
 * @note  
 * @warning
 */ 
void InterCurveProcess(void)
{
   calibType = 0;
 	 if(tempL.Word[0] == INTCMD_PRESET_OFFSET)    PreCalibrationParameterWriting();
   else if(tempL.Word[0] == INTCMD_CALIB_HTEMP) HighTemperatureParameterWriting();
   else if(tempL.Word[0] == INTCMD_CALIB_LTEMP) LowTemperatureParameterWriting();
   else if(tempL.Word[0] == INTCMD_CTYPE_CURVE) calibType = INTCMD_CTYPE_CURVE;
   else if(tempL.Word[0] == INT_2ND_CURVE_CMD)  calibType = INT_2ND_CURVE_CMD;
   else if(tempL.Word[0] == INT_3RD_CURVE_CMD)  calibType = INT_3RD_CURVE_CMD;
   else if(tempL.Word[0] == INTCMD_1ST_TABLE)   calibType = INTCMD_1ST_TABLE; 
   else if(tempL.Word[0] == INTCMD_2ND_TABLE)   calibType = INTCMD_2ND_TABLE; 
   else                                         MBBuf.BusError = SLAVE_DEVICE_FAILURE;
}
/**************************************************************************************/
/**
 * @brief InterControlProcess
 * @note  
 * @warning
 */ 
void InterControlProcess(void)
{
        if(tempL.Word[0] == INTCMD_USER_MODE)       EnterUserMode(); 
    //else if(tempL.Word[0] == INTCMD_EXCALIB_MODE)  EnterExtCalibMode();      // calibration mode
   else if(tempL.Word[0] == INTCMD_CALIB_MODE)      EnterCalibMode();          // calibration mode
   else if(tempL.Word[0] == INTCMD_ZERO_CALIB_MODE) {
     EnterZeroCalibMode();                                                     // calibration mode
	   tempL.Word[0] = currentMode.Word;
     WriteShortParameterToMemory(SYS_COMMAND);	
     tempL.Word[0] = INTCMD_ZERO_CALIB_MODE;
   }
   //------------------------------------------------------------------------
   else if(tempL.Word[0] == INTCMD_DEBUG_MODE)    EnterDebugMode();          // debug mode
   else if(tempL.Word[0] == INTCMD_BATTERY_MODE)  EnterBatteryMode();        // battery mode
   else if(tempL.Word[0] == INTCMD_GCF_TEST_MODE) EnterGcfTestMode();        // GCF 测试 mode
   //else if(tempL.Word[0] == INTCMD_SAVE_SETUP)    SaveFactorySetting();    // Save the factory setting
   //else if(tempL.Word[0] == INTCMD_RESTORE)       RestoreFactorySetting(); // Restore factory settings
   else if(tempL.Word[0] == INTCMD_RESET_CORR)    DefaultDevCoef();          // Restore
	 else                                           MBBuf.BusError = SLAVE_DEVICE_FAILURE;
}

/**************************************************************************************/
/**
 * @brief InterControlProcess
 * @note  
 * @warning
 */ 
void InterClearProcess(void)
{
       if(tempL.Word[0] == ('B'<<8)+'J') ClearAlarmRecord();
  else if(tempL.Word[0] == ('L'<<8)+'S') ClearHistoryRecord();
  else if(tempL.Word[0] == ('R'<<8)+'Z') ClearDateRecord(); 
}

/**************************************************************************************/
/**
 * @brief InterControlProcess
 * @note  
 * @warning
 */ 
void CalibSystemOffset(void )
{
  tempL.Word[0]  = voltageDetected[NIDX];        // ReadDataFromMovingAverage(NIDX); 
       if(CMDComPassword == ('K'<<8)+'Q') offsetAir = WriteShortParameterToMemory(GET_WORD_ADDR(offsetAir));
  else if(CMDComPassword == ('J'<<8)+'Z') offsetGas = WriteShortParameterToMemory(GAS_OFFSET);
}
//##############################################################################
#endif
//##############################################################################