motor_ctl-1/2.MotorDrive/Source/adc.c

/************************************************************************
 Project:             Welling Motor Control Paltform
 Filename:            adc.c
 Partner Filename:    adc.h
 Description:         Get the adc conversion results
 Complier:            IAR Embedded Workbench for ARM 7.80, IAR Systems.
 CPU TYPE :           GD32F3x0
*************************************************************************
 Copyright (c) 2018 Welling Motor Technology(Shanghai) Co. Ltd.
 All rights reserved.
*************************************************************************
*************************************************************************
Revising History (ECL of this file):

************************************************************************/

/************************************************************************
 Beginning of File, do not put anything above here except notes
 Compiler Directives:
*************************************************************************/
#ifndef _ADCDRV_C_
#define _ADCDRV_C_
#endif

/************************************************************************
 Included File:
*************************************************************************/
#include "syspar.h"
#include "user.h"
#include "usart.h"
#include "Temp.h"
//#include "api.h"
#include "board_config.h"
#include "UserGpio_Config.h"
#include "MosResCalib.h"
#include "hwsetup.h"

 extern uint16_t gAdcResult0[8];
/************************************************************************
 Constant Table:
*************************************************************************/

/************************************************************************
 Exported Functions:
*************************************************************************/
/***************************************************************
 Function: adc_voCalibration;
 Description: Get phase A and B current zero point, other A/D sample value
 Call by: main() before InitADC;
 Input Variables: N/A
 Output/Return Variables: ADCTESTOUT
 Subroutine Call: N/A
 Reference: N/A
****************************************************************/
void adc_voCalibration(ADC_COF *cof, ADC_DOWN_OUT *out1, ADC_UP_OUT *out2)
{
if (out1->blADCCalibFlg == FALSE || out2->blADCCalibFlg == FALSE)
{
    if (!hw_blChrgOvrFlg)
    {
        hw_voCharge();
    }
    else
    {
    #if(SampleModelSelect == DOUBLERESISTANCE)    //      if(cp_stFlg.CurrentSampleModelSelect == DOUBLERESISTANCE)
     
        if (out1->uwADCCalibCt < (1 << ADC_CALIB_INDEX))
        {
            out1->ulIdcAvgRegSum += IBUSAVGREG();// //hw_uwADC1[HW_ADC_IBUSAVG_CH];//
            out1->ulIaRegSum += adc_uwRdsonUReg;//iAdc_GetResultPointer(1)[HW_ADC_IA_CH];
            out1->ulIbRegSum += adc_uwRdsonVReg;//iAdc_GetResultPointer(1)[HW_ADC_IB_CH];
            out1->ulIcRegSum += adc_uwRdsonWReg;//iAdc_GetResultPointer(1)[HW_ADC_IC_CH];
            out1->uwADCCalibCt++;
        }
        else
        {
           // sysctrl_voPwmInit(); // mos up charge and adc calib over; pwm off
            hw_voPWMInit();
            cof->uwIdcAveOffset = out1->ulIdcAvgRegSum >> (ADC_CALIB_INDEX);
            cof->uwIaOffset = out1->ulIaRegSum >> (ADC_CALIB_INDEX);
            cof->uwIbOffset = out1->ulIbRegSum >> (ADC_CALIB_INDEX);
            cof->uwIcOffset = out1->ulIcRegSum >> (ADC_CALIB_INDEX);

            out1->ulIdcAvgRegSum = 0;
            out1->ulIaRegSum = 0;
            out1->ulIbRegSum = 0;
            out1->ulIcRegSum = 0;
            out1->uwADCCalibCt = 0;
            out1->blADCCalibFlg = TRUE;
            out2->uwADCCalibCt = 0;
            out2->blADCCalibFlg = TRUE;
        }            
      #elif(SampleModelSelect == COMBINATION)
                
            pwm_stGenOut.uwRDSONTrig = 108;
            pwm_stGenOut.uwSigRTrig = HW_HHHPWM_PERIOD;
            pwm_stGenOut.blSampleCalibFlag = TRUE;
            if (out1->uwADCCalibCt < (1 << ADC_CALIB_INDEX)) //24求平均
            {
                out1->ulIdcRegSum += adc_uwADDMAPhase1;
                out1->ulIdcAvgRegSum += hw_uwADC1[0]; 
                out1->ulIaRegSum += adc_uwRdsonUReg;
                out1->ulIbRegSum += adc_uwRdsonVReg;
                out1->ulIcRegSum += adc_uwRdsonWReg;
                out1->uwADCCalibCt++;
            }
            else
            {
                hw_voPWMInit(); // mos up charge and adc calib over; pwm off
                cof->uwIaOffset = out1->ulIaRegSum >> (ADC_CALIB_INDEX);
                cof->uwIbOffset = out1->ulIbRegSum >> (ADC_CALIB_INDEX);
                cof->uwIcOffset = out1->ulIcRegSum >> (ADC_CALIB_INDEX);
                cof->uwIdcAveOffset = out1->ulIdcAvgRegSum >> (ADC_CALIB_INDEX);

                out1->ulIaRegSum = 0;
                out1->ulIbRegSum = 0;
                out1->ulIcRegSum = 0;
                out1->ulIdcAvgRegSum = 0;

                pwm_stGenOut.blSampleCalibFlag = FALSE;
                cof->uwIdcOffset = out1->ulIdcRegSum >> (ADC_CALIB_INDEX);
                out1->ulIdcRegSum = 0;

                out1->uwADCCalibCt = 0;
                out1->blADCCalibFlg = TRUE;
                out2->uwADCCalibCt = 0;
                out2->blADCCalibFlg = TRUE;
            }
        
      #endif
            
//            else if(cp_stFlg.CurrentSampleModelSelect == SINGLERESISITANCE)
//            {
//               if (out1->uwADCCalibCt < (1 << ADC_CALIB_INDEX))
//               {
//                   out1->ulIdcRegSum +=adc_uwADDMAPhase1 + adc_uwADDMAPhase2;// iAdc_GetResultPointer(2)[HW_ADC_IA_CH] + iAdc_GetResultPointer(2)[HW_ADC_IB_CH];;
//                   out1->ulIdcAvgRegSum += hw_uwADC1[HW_ADC_IBUSAVG_CH];//iAdc_GetResultPointer(0)[HW_ADC_IBUSAVG_CH]; 
//                   out1->uwADCCalibCt++;
//               }
//               else if (out2->uwADCCalibCt < (1 << ADC_CALIB_INDEX))
//               {
//                   out2->uwADCCalibCt++;
//               }
//               else
//               {
//                   hw_voPWMInit();
//                   cof->uwIdcOffset = out1->ulIdcRegSum >> (ADC_CALIB_INDEX + 1);
//                   cof->uwIdcAveOffset = out1->ulIdcAvgRegSum >> (ADC_CALIB_INDEX);
//                   out1->ulIdcRegSum = 0;
//                   out1->ulIdcAvgRegSum = 0;
//                   out1->uwADCCalibCt = 0;
//                   out1->blADCCalibFlg = TRUE;
//                   out2->uwADCCalibCt = 0;
//                   out2->blADCCalibFlg = TRUE;
//               }
//            }
           
            
        }
    }
}
/***************************************************************
 Function: adc_voSample;
 Description: Get three-phase current value after zero point and gain process
 Call by: functions in TBC;
 Input Variables: ADCIABFIXCOF
 Output/Return Variables: ADCTESTOUT
 Subroutine Call:
 Reference: N/A
****************************************************************/

void adc_voSampleDown(ADC_COF *cof, ADC_DOWN_OUT *out)
{
    UWORD uwIpeakPu;
   
   #if(SampleModelSelect == DOUBLERESISTANCE)   //  if(cp_stFlg.CurrentSampleModelSelect == DOUBLERESISTANCE)
     SWORD tmp_swIphase1, tmp_swIphase2, tmp_swIphase3;
        out->uwIaReg = adc_uwRdsonUReg;//iAdc_GetResultPointer(1)[HW_ADC_IA_CH];
        out->uwIbReg = adc_uwRdsonVReg;//iAdc_GetResultPointer(1)[HW_ADC_IB_CH];
        out->uwIcReg = adc_uwRdsonWReg;//iAdc_GetResultPointer(1)[HW_ADC_IC_CH];
//        if(MosResInside.blCalibFlag==TRUE)
//        {
//        tmp_swIphase1 = -(((SWORD)out->uwIaReg - cof->uwIaOffset) * cof->uwCurReg2Pu >> 10); // Q14=Q24-Q10
//        tmp_swIphase2 = -(((SWORD)out->uwIbReg - cof->uwIbOffset) * cof->uwCurReg2Pu >> 10); // Q14=Q24-Q10
//        tmp_swIphase3 = -(((SWORD)out->uwIcReg - cof->uwIcOffset) * cof->uwCurReg2Pu >> 10); // Q14=Q24-Q10
// //       tmp_swIphase3 = -tmp_swIphase1 - tmp_swIphase2; // Q14=Q24-Q10
//        }
    //    else
        {
            //tmp_swIphase1 = -(((SWORD)out->uwIaReg - cof->uwIaOffset) * MosCal_A.uwCurReg2Pu >> 10); // Q14=Q24-Q10
#if ((IPM_POWER_SEL == IPM_POWER_250W_6G) ||(IPM_POWER_SEL ==IPM_POWER_350W_6G))
            tmp_swIphase1 = -(((SWORD)out->uwIaReg - cof->uwIaOffset) * cof->uwCurReg2Pu >> 10); // Q14=Q24-Q10
            tmp_swIphase2 = -(((SWORD)out->uwIbReg - cof->uwIbOffset) * cof->uwCurReg2Pu >> 10); // Q14=Q24-Q10
     //        tmp_swIphase3 = -(((SWORD)out->uwIcReg - cof->uwIcOffset) * cof->uwCurReg2Pu >> 10); // Q14=Q24-Q10
            tmp_swIphase3 = -tmp_swIphase1 - tmp_swIphase2; // Q14=Q24-Q10

#else
            tmp_swIphase2 = -(((SWORD)out->uwIbReg - cof->uwIbOffset) * cof->uwCurReg2Pu>> 10); // Q14=Q24-Q10
            tmp_swIphase3 = -(((SWORD)out->uwIcReg - cof->uwIcOffset) * cof->uwCurReg2Pu >> 10); // Q14=Q24-Q10
            tmp_swIphase1 =  -tmp_swIphase3 - tmp_swIphase2;
#endif
           // tmp_swIphase3 = -tmp_swIphase1 - tmp_swIphase2; // Q14=Q24-Q10
        }

        out->swIaPu = tmp_swIphase1;
        out->swIbPu = tmp_swIphase2;
        out->swIcPu = tmp_swIphase3;  
        
   #elif(SampleModelSelect == COMBINATION)
        if(hw_blPWMOnFlg==TRUE)//(curSpeed_state.state != Stop)
        {

            out->uwIaReg = adc_uwRdsonUReg;
            out->uwIbReg = adc_uwRdsonVReg;
            out->uwIcReg = adc_uwRdsonWReg;

            out->swSampIaPu = -((SLONG)((SLONG)out->uwIaReg - (SLONG)cof->uwIaOffset) * cof->uwCurReg2Pu >> 10); // Q14=Q24-Q10
            out->swSampIbPu = -((SLONG)((SLONG)out->uwIbReg - (SLONG)cof->uwIbOffset) * cof->uwCurReg2Pu >> 10); // Q14=Q24-Q10
           // out->swSampIcPu = -((SLONG)((SLONG)out->uwIcReg - (SLONG)cof->uwIcOffset) * cof->uwCurReg2Pu >> 10); // Q14=Q24-Q10
             out->swSampIcPu = -out->swSampIaPu -out->swSampIbPu;

            //cof->uwCalibcoef = 1024;  //Q10 补偿
             out->swIaPu = ((SLONG)out->swSampIaPu * cof->uwCalibcoefIA) >> 10;
             out->swIbPu = ((SLONG)out->swSampIbPu * cof->uwCalibcoefIB) >> 10;
            out->swIcPu =-out->swIaPu-out->swIbPu ;//((SLONG)out->swSampIcPu * cof->uwCalibcoef) >> 10;
//             out->swIaPu = out->swSampIaPu;
//             out->swIbPu = out->swSampIbPu;
//             out->swIcPu = out->swSampIcPu;

        }
        else
        {

            out->swIaPu = 0;
            out->swIbPu = 0;
            out->swIcPu = 0;
        }
//         out->swIaPu = out->swSampIaPu;
//        out->swIbPu = out->swSampIbPu;
//        out->swIcPu = out->swSampIcPu;
   #endif
//    else if(cp_stFlg.CurrentSampleModelSelect == SINGLERESISITANCE)
//    {
//        //        // Wait Injected ADC over 
//        //    while(ADC_GetFlagStatus(ADC1,ADC_IT_JEOS) == RESET)96
//        //    {}
//        //    ADC_ClearFlag(ADC1,ADC_IT_JEOS);
//
//        // Register value 
//        out->uwFirstCurREG = adc_uwADDMAPhase1;//iAdc_GetResultPointer(2)[HW_ADC_IA_CH];  // Q12
//        out->uwSecondCurREG =adc_uwADDMAPhase2;// iAdc_GetResultPointer(2)[HW_ADC_IB_CH]; // Q12
//
//        tmp_swIphase1 = (SWORD)out->uwFirstCurREG - cof->uwIdcOffset;
//        tmp_swIphase1 = ((SLONG)tmp_swIphase1 * cof->uwCurIdcReg2Pu) >> 10; // Q14=Q24-Q10
//        tmp_swIphase2 = (SWORD)cof->uwIdcOffset - out->uwSecondCurREG;
//        tmp_swIphase2 = ((SLONG)tmp_swIphase2 * cof->uwCurIdcReg2Pu) >> 10; // Q14=Q24-Q10
//        tmp_swIphase3 = (SWORD)out->uwSecondCurREG - out->uwFirstCurREG;
//        tmp_swIphase3 = ((SLONG)tmp_swIphase3 * cof->uwCurIdcReg2Pu) >> 10; // Q14=Q24-Q10
//
//        out->uwADCSector = pwm_stGenOut.uwNewSectorNum;
//        switch (pwm_stGenOut.uwNewSectorNum)
//        {
//            case 1:
//                out->swIbPu = tmp_swIphase1; // v
//                out->swIcPu = tmp_swIphase2; //-w
//                out->swIaPu = tmp_swIphase3; // u
//                break;
//            case 2:
//                out->swIaPu = tmp_swIphase1; // u
//                out->swIbPu = tmp_swIphase2; //-v
//                out->swIcPu = tmp_swIphase3;
//                break;
//            case 3:
//                out->swIaPu = tmp_swIphase1; // u
//                out->swIcPu = tmp_swIphase2; //-w
//                out->swIbPu = tmp_swIphase3;
//                break;
//            case 4:
//                out->swIcPu = tmp_swIphase1; // w
//                out->swIaPu = tmp_swIphase2; //-u
//                out->swIbPu = tmp_swIphase3;
//                break;
//            case 5:
//                out->swIbPu = tmp_swIphase1; // v
//                out->swIaPu = tmp_swIphase2; //-u
//                out->swIcPu = tmp_swIphase3;
//                break;
//            case 6:
//                out->swIcPu = tmp_swIphase1; // w
//                out->swIbPu = tmp_swIphase2; //-v
//                out->swIaPu = tmp_swIphase3;
//                break;
//            default:
//                out->swIaPu = 0;
//                out->swIbPu = 0;
//                out->swIcPu = 0;
//                break;
//        }
//    }
    
    /* Current absolute value & max value */
    if ((out->swIaPu) >= 0)
    {
        out->uwIaAbsPu = (UWORD)out->swIaPu;
    }
    else
    {
        out->uwIaAbsPu = (UWORD)(-(out->swIaPu));
    }
    if ((out->swIbPu) >= 0)
    {
        out->uwIbAbsPu = (UWORD)out->swIbPu;
    }
    else
    {
        out->uwIbAbsPu = (UWORD)(-(out->swIbPu));
    }
    if ((out->swIcPu) >= 0)
    {
        out->uwIcAbsPu = (UWORD)out->swIcPu;
    }
    else
    {
        out->uwIcAbsPu = (UWORD)(-(out->swIcPu));
    }

    uwIpeakPu = out->uwIaAbsPu > out->uwIbAbsPu ? out->uwIaAbsPu : out->uwIbAbsPu;
    uwIpeakPu = out->uwIcAbsPu > uwIpeakPu ? out->uwIcAbsPu : uwIpeakPu;
    out->uwIpeakPu = uwIpeakPu;
}

void adc_voSampleUp(ADC_COF *cof, ADC_UP_OUT *out)
{
    static SLONG slIbusAvgSum = 0;  /**< 只在本函数中用到的全局变量，但需注意清0 */
    static ULONG ulDelayTimes = 0;
    static UBYTE ubTempCalType = 0;
	
    /* Register value */
    out->uwIbusAvgReg = IBUSAVGREG();// DL_ADC12_getMemResult(ADC12_0_INST, DL_ADC12_MEM_IDX_4);//hw_uwADC1[HW_ADC_IBUSAVG_CH];
    out->MotorTempReg = MOTORTEMPREG();//DL_ADC12_getMemResult(ADC12_1_INST, DL_ADC12_MEM_IDX_1); //hw_uwADC1[HW_ADC_MOTTEMP_CH];// iAdc_GetResultPointer(0)[HW_ADC_MOTTEMP_CH];
    out->uwVdcReg =  VDCREG();//DL_ADC12_getMemResult(ADC12_0_INST, DL_ADC12_MEM_IDX_5);//hw_uwADC1[HW_ADC_UDC_CH];//iAdc_GetResultPointer(0)[HW_ADC_UDC_CH];
    //out->TorqTempReg = iAdc_GetResultPointer(0)[HW_ADC_TORQ_CH]; 
    out->PCBTempReg =PCBTEMPREG();//  DL_ADC12_getMemResult(ADC12_0_INST, DL_ADC12_MEM_IDX_1);//hw_uwADC1[HW_ADC_PCBTEMP_CH];//iAdc_GetResultPointer(0)[HW_ADC_PCBTEMP_CH];
   // out->uwU12VReg = hw_uwADC1[HW_ADC_U12V_CH];//iAdc_GetResultPointer(0)[HW_ADC_U12V_CH];      
   // out->uwU6VReg = hw_uwADC1[HW_ADC_U6V_CH];//iAdc_GetResultPointer(0)[HW_ADC_U6V_CH];       
    //out->uwThrottleReg = iAdc_GetResultPointer(0)[HW_ADC_THRO_CH];  

    /* Vdc Pu value cal and lpf */   
    out->uwVdcPu = (SLONG)out->uwVdcReg * cof->uwVdcReg2Pu >> 10; // Q14=Q24-Q10        
    out->uwVdcLpfPu = ((out->uwVdcPu - out->uwVdcLpfPu) >> 1) + out->uwVdcLpfPu;  
    
    /* IbusAvg Pu value and lpf */   
    if(out->uwIbusAvgReg > cof->uwIdcAveOffset)
    {
        out->uwIbusAvgPu = ((SLONG)out->uwIbusAvgReg - (SLONG)cof->uwIdcAveOffset) * (SLONG)cof->uwCurIdcAvgReg2Pu >> 10; // Q14=Q24-Q10
    }
    else
    {
        out->uwIbusAvgPu =0;
    } 
    slIbusAvgSum += (((SLONG)out->uwIbusAvgPu << 10) - slIbusAvgSum) >> 9;
    out->uwIbusAvgLpfPu = (UWORD)(slIbusAvgSum>>10);
    
    /* Voltage Pu cal */
    out->uwU6VPu = (SLONG)out->uwU6VReg * cof->uwU6VReg2Pu >> 10;    // Q14=Q24-Q10;
    out->uwU5VPu = (SLONG)out->uwU5VReg * cof->uwU5VReg2Pu >> 10;    // Q14=Q24-Q10;
    out->uwU12VPu = (SLONG)out->uwU12VReg * cof->uwU12VReg2Pu >> 10; // Q14=Q24-Q10;

    /* PCB温度采样：注意与车速信号共用一根线，需要在高电平时采样 */
    switch(ubTempCalType)
    {
        case 0:		//PCB_TEMP
            out->PCBTempR = (ULONG)4096 * PCB_TEMP_SAMPLER / out->PCBTempReg - PCB_TEMP_SAMPLER; // Q14=Q24-Q10;
             PcbTempCal(out->PCBTempR);
            out->PCBTemp = tmp_PcbTemp;
    #if(MOTOR_TEMP_DETECT == 1)
            ubTempCalType = 1;
    #else
            ubTempCalType = 0;
            out->MotorTemp = tmp_PcbTemp;
    #endif
        break;
        case 1:		//MOTOR_TEMP
           if( out->MotorTempReg>1241)//1241-1V if(Get_MOTTEMP_PORT()!=0)//(iGpio_Read(HW_GPIO_MOTTEMP_PIN) != 0)
            {	
                if(ulDelayTimes++ > 30000)					/* prevent overflow */
                {
                    ulDelayTimes = 30000;	
                }
                if((ulDelayTimes > 50 && ulDelayTimes < 70) || (ulDelayTimes >= 20000))	/* remove signal rise and fall influence */
                {
                    out->MotorTempR = ((ULONG)MOTOR_TEMP_AD_VCC * out->MotorTempReg * (MOTOR_TEMP_R1 + MOTOR_TEMP_R2) - MOTOR_TEMP_VCC * 4096 * MOTOR_TEMP_R2) / (MOTOR_TEMP_VCC * 4096 - 33 * out->MotorTempReg);
                    MotorTempCal(out->MotorTempR);
                    if(tmp_MotTemp > (out->MotorTemp+2))
                    {
                        out->MotorTemp = out->MotorTemp + 2;
                    }
                    else if((tmp_MotTemp+2)<out->MotorTemp)
                    {
                        out->MotorTemp = out->MotorTemp - 2;
                    }
                    else
                    {
                        out->MotorTemp = tmp_MotTemp;	
                    } 
                }
            }
            else
            {
                ulDelayTimes = 0;	
            }
            ubTempCalType = 0;
        break;
    }
    
     ////////////////// Single Resitance Current Sample//////////////////////////////////////////////////////
#if(SampleModelSelect == COMBINATION)
    if (pwm_stGenOut.blSampleCalibFlag == TRUE)
    {
        switch (pwm_stGenOut.uwSingelRSampleArea)
        {
        case 0:
            out->swCalibIaPu = 0;
            out->swCalibIbPu = 0;
            out->swCalibIcPu = 0;
            break;
        case SampleA:
            out->swCalibIaPu = -((SLONG)((SWORD)adc_uwADDMAPhase1 - cof->uwIdcOffset) * cof->uwCurIdcReg2Pu) >> 10; // Q14=Q24-Q10
            out->swSampCapIaPu = -((SLONG)((SLONG)adc_uwIaReg- (SLONG)cof->uwIaOffset) * cof->uwCurReg2Pu >> 10); // Q14=Q24-Q10
            break;
        case SampleB:
            out->swCalibIbPu = -((SLONG)((SWORD)adc_uwADDMAPhase1 - cof->uwIdcOffset) * cof->uwCurIdcReg2Pu) >> 10; // Q14=Q24-Q10
            out->swSampCapIbPu = -((SLONG)((SLONG)adc_uwIbReg - (SLONG)cof->uwIbOffset) * cof->uwCurReg2Pu >> 10); // Q14=Q24-Q10
            break;
        case SampleC:
            out->swCalibIcPu = -((SLONG)((SWORD)adc_uwADDMAPhase1 - cof->uwIdcOffset) * cof->uwCurIdcReg2Pu) >> 10; // Q14=Q24-Q10

            break;
        }
    }
#endif
}

/***************************************************************
 Function: adc_voSRCalibration;
 Description:  //单电阻采样校准MOS内阻采样函数
 Call by:  
 Input Variables:  
 Output/Return Variables:  
 Subroutine Call:
 Reference: N/A
****************************************************************/
SWORD swSingleReg,swRdsonReg;
 UWORD uwCalGainflg;
 
void adc_voSRCalibration(ADC_COF *cof , ADC_SUMCOF *Sum_out)
{
  UWORD TempValue;

 if (pwm_stGenOut.blSampleCalibFlag == TRUE)
 {


// Sum_out->GainTemp = (SLONG)((SLONG)swSingleReg << 10) / (SLONG)swRdsonReg;

// if (Sum_out->GainTemp <= cof->uwCalibcoefMax && Sum_out->GainTemp >= cof->uwCalibcoefMin)
 {
   if (Sum_out->Start_Calc == 0)
   {
       Sum_out->Start_Calc = 1;
       Sum_out->RdsonGainCnt = 1;
       Sum_out->adc_RdsonADCGainSum = Sum_out->GainTemp;
       Sum_out->adc_RdsonADCGainMax = Sum_out->GainTemp;
       Sum_out->adc_RdsonADCGainMin = Sum_out->GainTemp;
   }
   else
   {
       Sum_out->adc_RdsonADCGainSum += Sum_out->GainTemp;
       if (Sum_out->GainTemp > Sum_out->adc_RdsonADCGainMax)
       {
           Sum_out->adc_RdsonADCGainMax = Sum_out->GainTemp;
       }
       else if (Sum_out->GainTemp < Sum_out->adc_RdsonADCGainMin)
       {
           Sum_out->adc_RdsonADCGainMin = Sum_out->GainTemp;
       }
       else
       {}

       if (Sum_out->RdsonGainCnt >= 9)
       {
           Sum_out->Start_Calc = 0;
           Sum_out->RdsonGainCnt = 0;
           Sum_out->adc_RdsonADCGainSum -= Sum_out->adc_RdsonADCGainMax;
           Sum_out->adc_RdsonADCGainSum -= Sum_out->adc_RdsonADCGainMin;
            TempValue = Sum_out->adc_RdsonADCGainSum >> 3;

           Sum_out->adc_RdsonADCGainSum2 -= Sum_out->adc_RdsonADCGainRecord[Sum_out->RdsonGainCnt2];
           Sum_out->adc_RdsonADCGainRecord[Sum_out->RdsonGainCnt2] = TempValue;
           Sum_out->adc_RdsonADCGainSum2 += Sum_out->adc_RdsonADCGainRecord[Sum_out->RdsonGainCnt2];
           Sum_out->RdsonGainCnt2++;
           if (Sum_out->RdsonGainCnt2 >= 2)
           {
               Sum_out->RdsonGainCnt2 = 0;
               Sum_out->uwCalibcoef = Sum_out->adc_RdsonADCGainSum2 >> 1;
               Sum_out->uwCalibcomplete=1;
           }
       }
       else
       {
           Sum_out->RdsonGainCnt++;
       }
   }
}
}

}
/***************************************************************
 Function: adc_voSampleCoef;
 Description: Get other A/D sample value
 Call by: functions in Mainloop;
 Input Variables: ADCIABFIXCOF
 Output/Return Variables: ADCTESTOUT
 Subroutine Call:
 Reference: N/A
****************************************************************/
void adc_voSampleCoef(ADC_COF *cof)
{
    cof->uwCurReg2Pu = ((UQWORD)ADC_IPHASE_CUR_MAX_AP << 24) / (1 << (ADC_RESOLUTION_BIT - 1)) / IBASE; // Q24    
    cof->uwCurIdcReg2Pu = ((UQWORD)ADC_IDC_CUR_MAX_AP << 24) / (1 << (ADC_RESOLUTION_BIT)) / IBASE;     // Q24
    //cof->uwCurIdcAvgReg2Pu = ((UQWORD)ADC_IDC_CUR_AVG_MAX_AP << 24) / (1 << (ADC_RESOLUTION_BIT)) / IBASE;     // Q24
    cof->uwCurIdcAvgReg2Pu = ((UQWORD)ADC_IDC_CUR_AVG_MAX_AP << 24) / (3824) / IBASE;     // Q24
    cof->uwVdcReg2Pu = ((UQWORD)ADC_VDC_MAX_VT << 24) / (1 << ADC_RESOLUTION_BIT) / VBASE;              // Q24
    cof->uwUabcReg2Pu = ((UQWORD)ADC_UABC_MAX_VT << 24) / (1 << (ADC_RESOLUTION_BIT)) / VBASE;          // Q24
    cof->uwU6VReg2Pu = ((UQWORD)ADC_LIGHT_MAX_VT << 24) / (1 << (ADC_RESOLUTION_BIT)) / VBASE;          // Q24;
    cof->uwU5VReg2Pu = ((UQWORD)ADC_SPDSENSOR_MAX_VT << 24) / (1 << (ADC_RESOLUTION_BIT)) / VBASE;      // Q24;
    cof->uwU12VReg2Pu = ((UQWORD)ADC_DISPLAY_MAX_VT << 24) / (1 << (ADC_RESOLUTION_BIT)) / VBASE;       // Q24;
    cof->uwCalibcoefIA = 1024;
    cof->uwCalibcoefIB = 1024;
    cof->uwCalibcoefMax = 1800;
    cof->uwCalibcoefMin = 512;
    cof->uwCalibCoefK = 160; // q10

}
/***************************************************************
 Function: adc_voSampleInit;
 Description: ADC sample initialization
 Call by: mn_voSoftwareInit;
 Input Variables: N/A
 Output/Return Variables: N/A
 Subroutine Call:
 Reference: N/A
****************************************************************/
void adc_voSampleInit(void)
{
    adc_stDownOut.swIaPu = 0;
    adc_stDownOut.swIbPu = 0;
    adc_stDownOut.swIcPu = 0;
    adc_stDownOut.uwIaAbsPu = 0;
    adc_stDownOut.uwIbAbsPu = 0;
    adc_stDownOut.uwIcAbsPu = 0;
    adc_stDownOut.uwIpeakPu = 0;
    adc_stDownOut.uwIaReg = 0;
    adc_stDownOut.uwIbReg = 0;
    adc_stDownOut.uwIcReg = 0;
    adc_stDownOut.uwFirstCurREG = 0;
    adc_stDownOut.uwSecondCurREG = 0;
    adc_stDownOut.uwADCSector = 0;
    adc_stDownOut.uwIaAvgPu = 0;
    adc_stDownOut.uwIbAvgPu = 0;
    adc_stDownOut.uwIcAvgPu = 0;

    adc_stUpOut.uwVdcPu = 0;
    adc_stUpOut.uwVdcLpfPu = 0;
    adc_stUpOut.uwU6VPu = 0;
    adc_stUpOut.uwU5VPu = 0;
    adc_stUpOut.uwU12VPu = 0;
    adc_stUpOut.uwTrottlePu = 0;
    adc_stUpOut.PCBTemp = 0;
    adc_stUpOut.MotorTemp = 0;
    adc_stUpOut.uwVdcReg = 0;
    adc_stUpOut.uwU6VReg = 0;
    adc_stUpOut.uwU5VReg = 0;
    adc_stUpOut.uwU12VReg = 0;
    adc_stUpOut.uwThrottleReg = 0;
    adc_stUpOut.PCBTempReg = 0;
    adc_stUpOut.MotorTempReg = 0;
    adc_stUpOut.swCalibIaPu = 0;
    adc_stUpOut.swCalibIbPu = 0;
    adc_stUpOut.swCalibIcPu = 0;

    adc_stDownOut.ulUaRegSum = 0;
    adc_stDownOut.ulUbRegSum = 0;
    adc_stDownOut.ulUcRegSum = 0;
    adc_stDownOut.ulIdcRegSum = 0;
    adc_stDownOut.ulIaRegSum = 0;
    adc_stDownOut.ulIbRegSum = 0;
    adc_stDownOut.ulIcRegSum = 0;
    adc_stDownOut.uwADCCalibCt = 0;
    adc_stDownOut.blADCCalibFlg = FALSE;

    adc_stUpOut.uwADCCalibCt = 0;
    adc_stUpOut.blADCCalibFlg = FALSE;
    adc_stUpOut.swIPMTempCe = 0;



    pwm_stGenOut.uwSigRTrig = HW_HHHPWM_PERIOD;
}

/*************************************************************************
 Local Functions (N/A)
*************************************************************************/

/************************************************************************
 Copyright (c) 2018 Welling Motor Technology(Shanghai) Co. Ltd.
 All rights reserved.
*************************************************************************/
#ifdef _ADCDRV_C_
#undef _ADCDRV_C_
#endif
/*************************************************************************
 End of this File (EOF)!
 Do not put anything after this part!
*************************************************************************/