#include "dac.h"
#include "ctrl.h"
#include "main.h"  
#include "absacc.h"


void SPIOutByte(UINT ibyte)
{
    #ifdef _USE_DAC8560

    int i,k;
    ibyte<<=4;
    //if(gcByte==0)
    //    gcByte|=1<<16L;
    PIN_SYNC = 0 ;
    for(  k=0;k<0x100;k++){__NOP();}           //延时
    for(  i=0;i<24;i++)
    {                                 
         
        PIN_SCLK = 1;       
        if((gcByte&0x800000)==0x800000)              
            PIN_DIN = 1;
        else 
            PIN_DIN = 0;
        PIN_SCLK = 0; 
        gcByte<<=1;
        for(  k=0;k<16;k++);
    }
    //for(  k=0;k<32;k++){__NOP();}           //延时
    PIN_SYNC = 1 ;
    #else
    int i,j,k;
    j = ibyte;
    if(j==0)
        j|=1<<12L;
    PIN_SYNC = 0 ;
    for(  k=0;k<0x10;k++){__NOP();}           //延时
    for(  i=0;i<16;i++)
    {                                 
        PIN_SCLK = 1;       
        if((j&0x8000)==0x8000)              
           PIN_DIN = 1;
        else 
           PIN_DIN = 0;
        for(  k=0;k<14;k++){__NOP();} 
        PIN_SCLK = 0;
        j<<=1;
        for(  k=0;k<16;k++);
    }
    for(  k=0;k<2;k++){__NOP();}           //延时
    PIN_SYNC = 1;
    #endif
}            



void DACOut(UINT iByte)
{
    SPIOutByte(iByte);
}


void StopDJ(void)
{
    #ifdef _DEBUG
    //printf("停止电解\n" );
    #endif               
    StopDigitalDJ();
}

//开始电解电流mA值      
void  StartDigitalDJ(int iDJCurrent)
{      
    double DAValue = mA2DAValue(iDJCurrent);    
    StartDigitalDJ_ADV(DAValue);    
}

void  StartDigitalDJ_ADV(double DACValue)
{        
    int DACValue2;
    IED.Freq.DJSwitch = 1;                                       
    if(DACValue>MAXDACOUT)
       DACValue = MAXDACOUT;
    if(DACValue<0)
       DACValue = 0;
         
    if(DACValue!=IED.Freq.DJVALUE)
    { 
        DACValue2 = GetTrueDAValByKC_InDAValue(DACValue) ;
        DACOut(DACValue2);
        #ifdef _DEBUG
           //printf("DA %dmA\n",DACValue);
        #endif  
    }        

    IED.Freq.DJVALUE    =  DACValue;  
    IED.Freq.lDJSum     += DACValue;       
}

void  StopDigitalDJ(void)    
{
    if(IED.Freq.DJSwitch )
    { 
        #ifdef _DEBUG
        printf("DA stop\n");
        #endif      
        IED.Freq.DJSwitch = 0;     
        IED.Freq.DJVALUE = 0;                         
        DACOut(0x0);                                            
    }
}
  
TIM_TypeDef My_Tim4 __at (TIM4_BASE);
volatile int TIM_IntCount = 0;      
void TIM4_IRQHandler(void) // TIMER2 interrupt subroutine  
{    
    long countValue    =  My_Tim4.CNT;
    TIM_ClearITPendingBit(TIM4,TIM_FLAG_Update);  
    TIM_IntCount++;        
}   
                                                             
void InitIntegrator(void)
{                      
    NVIC_InitTypeDef NVIC_InitStructure;
      GPIO_InitTypeDef GPIO_InitStructure;
    TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure ;
      // TIM3 channel 2 pin (PA.07) configuration 
      GPIO_InitStructure.GPIO_Pin =  GPIO_Pin_0;
      GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;//GPIO_Mode_IN_FLOATING;
     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; 
      GPIO_Init(GPIOE, &GPIO_InitStructure);

    NVIC_InitStructure.NVIC_IRQChannel = TIM4_IRQn;  
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = (uint8_t)NVIC_PriorityGroup_0;  
    NVIC_InitStructure.NVIC_IRQChannelSubPriority    = 0;         
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&NVIC_InitStructure);

    RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4, ENABLE);
    TIM_TimeBaseStructure.TIM_Period = 0xFFFF;
    TIM_TimeBaseStructure.TIM_Prescaler = 0x00;
    TIM_TimeBaseStructure.TIM_ClockDivision = 0x0;
    TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
    TIM_TimeBaseInit(TIM4, &TIM_TimeBaseStructure);        // Time base configuration
    TIM_ETRClockMode2Config(TIM4, TIM_ExtTRGPSC_OFF,TIM_ExtTRGPolarity_NonInverted,0xF);
    TIM_ITConfig(TIM4,TIM_IT_Update,ENABLE);

    TIM_SetCounter(TIM4, 0); 
    TIM_Cmd(TIM4,ENABLE);           
                     
    /////////////////////////////////////////// 
    ResetIntFreq();
}


long freq = 0; 
void  TaskIntFreq(void)
{  
    long countValue    =  My_Tim4.CNT;
    IED.Freq.cPreFreq  =  IED.Freq.cCurrFreq;       //保存上一次计数值
    IED.Freq.cCurrFreq =  (TIM_IntCount<<16)+ ((long)TIM4->CNT);  
    freq = IED.Freq.cCurrFreq - IED.Freq.cPreFreq ;                //得到频率
     
    __NOP(); 

    #ifdef  _DEBUG                                   
    //printf("Freq=%d",freq);
    //printf("\n");
    #endif
}

void ResetIntFreq(void)
{
    IED.Freq.cPreFreq = IED.Freq.cCurrFreq = 0;
    TIM_IntCount = 0;
    IED.Freq.lDJSum = 0;
}

/*
void InitDAC(void)
{
  GPIO_InitTypeDef GPIO_InitStructure;
  DAC_InitTypeDef DAC_InitStructure;

  RCC_APB1PeriphClockCmd(RCC_APB1Periph_DAC, ENABLE);

  // Once the DAC channel is enabled, the corresponding GPIO pin is automatically 
  //   connected to the DAC converter. In order to avoid parasitic consumption, 
  //   the GPIO pin should be configured in analog 
  GPIO_InitStructure.GPIO_Pin =  GPIO_Pin_4 ;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN;
  GPIO_Init(GPIOA, &GPIO_InitStructure);

  DAC_InitStructure.DAC_Trigger = DAC_Trigger_None;
  DAC_InitStructure.DAC_WaveGeneration = DAC_WaveGeneration_None;
  DAC_InitStructure.DAC_OutputBuffer = DAC_OutputBuffer_Disable;
  DAC_InitStructure.DAC_LFSRUnmask_TriangleAmplitude =  DAC_TriangleAmplitude_4095;
  DAC_Init(DAC_Channel_1, &DAC_InitStructure);
                                                     
  DAC_Cmd(DAC_Channel_1, ENABLE);
  DACOut(0);        // 120
  PE0_O = 1;       //打开小电极
}
*/
void InitDAC(void)
{ 
  //PA4_O = PA5_O = PA7_O = 1;  
  DACOut(0);        // 120 
}


double mA2DAValue(double  mA)
{
    __NOP();
    return mA*MAX_DAVALUE/(MAX_DAVOLTAGE/R_SENSOR);
}

int DAValue2mA(int DAValue)
{
    double DAV = DAValue;
    return DAV*MAX_DAVOLTAGE/R_SENSOR/MAX_DAVALUE;
}    



//计算电流值校准后的DA值
//输出到DA转换器的DA值,得到线性化后的实际是多少?
double  GetTrueDAValByKC_InDAValue(double wantDAValue)
{
    //return (wantDAValue==0)?0:(wantDAValue*paramK+paramB); 
    double Result = (wantDAValue==0)?0:((double)wantDAValue-paramB)/paramK;
    return Result>=0?Result:0;
}
  
double  GetTrueDAValByKC(double wantmAValue)
{
    double DAValue = mA2DAValue(wantmAValue);
    return GetTrueDAValByKC_InDAValue(DAValue);
} 


void Cal_K_And_C(double Real10mA,double Real200mA)
{
    double DAVALUE_Err_Real,DAVALUE_Err_Want; 
    double mA200_DAVALUE,Real200_DAVALUE,mA10_DAVALUE,Real10_DAVALUE;
    double c1=10.0f,c2=400.0f;
    double paramB2;
    
    //iDJCurrent=((iDJCurrent*R_SENSOR*0xFFF)/2500);     
    //实际输出 DACValue2 = ((double)DACValue-paramB)/paramK;
        mA10_DAVALUE   = GetTrueDAValByKC (c1); 
        Real10_DAVALUE = mA2DAValue(Real10mA); 
        /////////////////////////////////////
        mA200_DAVALUE   = GetTrueDAValByKC(c2); 
        Real200_DAVALUE = mA2DAValue(Real200mA); 
        DAVALUE_Err_Real = Real200_DAVALUE-Real10_DAVALUE;
        DAVALUE_Err_Want = mA200_DAVALUE-mA10_DAVALUE;
     paramK = DAVALUE_Err_Real/DAVALUE_Err_Want;
     paramB = Real10_DAVALUE-paramK*mA10_DAVALUE;
     paramB2 = mA200_DAVALUE-paramK*mA200_DAVALUE;
     if(paramK<0.1f)      
         paramK = 1.0f;
     if(paramB>300)
         paramB = 0;
     
         
}