lld_eft.c

本程序为ST公司开发的源代码

            wr16(Eft1,Cr2,toe,1);               /* Enable IRQ */
        break;

        default:
            //no code
        break;
        }
#endif // OS20_USE_TIMER1
    }
    else if(EFT0 == TimerId)
    {
        wr16_reg(Eft0,Cr1,0x0000);          /* Disable timer */
          
        wr16_reg(Eft0,Cr2,0x0000);          /* Reset control reg Cr2 */
        
        switch(TimerMode){

        case PWM_MODE:            
            wr16_reg(Eft0,Ocar,TimerCompValueA);/* Program OutputCompare Reg A */
            
            wr16_reg(Eft0,Ocbr,TimerCompValueB);/* Program OutputCompare Reg B (for reload value) */
            
            wr16_reg(Eft0,Cr2,TIMER_PRES_VAL);  /* Program Control Reg 2 (prescaler) */

#ifdef OS20_USE_TIMER1                        
            wr16(Eft1,Cr2,ocbie,1);             /* Enable IRQ */
            
            wr16_reg(Eft1,Cr1,TIMER_SET_PWM);   /* Set PWM mode */
#endif
        break;

        case OUTPUT_COM_MODE:            
            wr16_reg(Eft0,Ocar,TimerCompValueA);/* Program OutputCompare Reg A */
            
            wr16_reg(Eft0,Ocbr,TimerCompValueB);/* Program OutputCompare Reg B */
            
            wr16(Eft0,Cr2,cc,TIMER_PRES_VAL);   /* Program Control Reg 2 (prescaler) */
            
            wr16(Eft0,Cr1,dma,dmasource);		/* Program DMA source select */

            if(0 != TimerCompValueA)               /* Enable IRQ only if output comapare != 0 */
            {
               Eft_TimValueA = (tU16)TimerCompValueA;
               
               wr16(Eft0,Cr2,ocaie,1);          /* Enable IRQ */
            }

            if(0 != TimerCompValueB)
            {
               Eft_TimValueB = (tU16)TimerCompValueB;
                           
               wr16(Eft0,Cr2,ocbie,1);          /* Enable IRQ */
            }

            if (dma_int)
            {
            	wr16(Eft0,Cr2,dmaie,1);          /* Enable DMA IRQ */
            }
            else
            {
            	wr16(Eft0,Cr2,dmaie,0);          /* Enable DMA IRQ */            
            }
            
        break;

        case PULSE_MODE:            
            wr16_reg(Eft0,Ocar,TimerCompValueA);/* Program OutputCompare Reg A */
            
            wr16_reg(Eft0,Cr2,TIMER_PRES_VAL);  /* Program Control Reg 2 (prescaler) */
            
            wr16_reg(Eft0,Cr1,TIMER_SET_OPM);   /* Set PWM mode */
            
            wr16(Eft0,Cr1,olvlb,1);             /* Level 1 in the OCMPA pin */
            
            wr16(Eft0,Cr1,olvla,0);             /* Level 0 in the OCMPA pin */
            
            wr16(Eft0,Cr1,iedga,1);             /* Rising edge in the ICAPA */
        break;

        case COUNTER_MODE:            
            wr16(Eft0,Cr1,ecken,1);             /* Use external clock */
            
            wr16(Eft0,Cr2,toe,1);               /* Enable IRQ */
        break;

        default:
            //no code
        break;
        }
    }
}
#endif
/************************************************************************
*                                                                       *
* FUNCTIONS                                                             *
*                                                                       *
*      EFT_TimerStart                                                   *
*                                                                       *
* DESCRIPTION                                                           *
*                                                                       *
*      Start EFT                                                        *
*                                                                       *
* CALLS                                                                 *
*                                                                       *
*      LLD macros                                                       *
*                                                                       *
* INPUTS                                                                *
*                                                                       *
*      tU8 TimerId:   Timer identificator                               *
*                                                                       *
* OUTPUTS                                                               *
*                                                                       *
*      None                                                             *
*                                                                       *
************************************************************************/
tVoid EFT_TimerStart (tU8 TimerId)
{
    if (EFT1 == TimerId)
    {
#ifdef OS20_USE_TIMER1
        wr16(Eft1,Cr1,en,1);    /* Start Timer */
#endif        
    }
    else if (EFT0 == TimerId)
    {
        wr16(Eft0,Cr1,en,1);    /* Start Timer */
    }
}

#if 0 // [RB] commented out to reduce ROM space
/************************************************************************
*                                                                       *
* FUNCTIONS                                                             *
*                                                                       *
*      EFT_TimerStop                                                    *
*                                                                       *
* DESCRIPTION                                                           *
*                                                                       *
*      Stop EFT                                                         *
*                                                                       *
* CALLS                                                                 *
*                                                                       *
*      LLD macros                                                       *
*                                                                       *
* INPUTS                                                                *
*                                                                       *
*      tU8 TimerId:   Timer identificator                               *
*                                                                       *
* OUTPUTS                                                               *
*                                                                       *
*      None                                                             *
*                                                                       *
************************************************************************/
tVoid EFT_TimerStop(tU8 TimerId)
{
    if (EFT1 == TimerId)
    {
#ifdef OS20_USE_TIMER1
        wr16(Eft1,Cr1,en,0);    /* Stop Timer */
#endif
    }
    else if (EFT0 == TimerId)
    {
        wr16(Eft0,Cr1,en,0);    /* Stop Timer */
    }
}
#endif

/************************************************************************
*                                                                       *
* FUNCTIONS                                                             *
*                                                                       *
*      EFT_ReadTimer                                                    *
*                                                                       *
* DESCRIPTION                                                           *
*                                                                       *
*      Read EFT timer value                                             *
*                                                                       *
* CALLS                                                                 *
*                                                                       *
*      LLD macros                                                       *
*                                                                       *
* INPUTS                                                                *
*                                                                       *
*      tU8 TimerId:   Timer identificator                               *
*                                                                       *
* OUTPUTS                                                               *
*                                                                       *
*      Timer value                                                      *
*                                                                       *
************************************************************************/
tU16 EFT_ReadTimer (tU8 TimerId)
{
     if(EFT1 == TimerId)
     {
#ifdef OS20_USE_TIMER1
        return(rd16_reg(Eft1,Cntr));
#endif
     }
     else if(EFT0 == TimerId)
     {
        return(rd16_reg(Eft0,Cntr));
     }
     
     return (tU16)0;
}

#if 0 // [RB] commented out to reduce ROM space
/************************************************************************
*                                                                       *
* FUNCTIONS                                                             *
*                                                                       *
*      EFT_ConvTime2EftVal_us                                           *
*                                                                       *
* DESCRIPTION                                                           *
*                                                                       *
*      Convert time value from us to EFT units                          *
*                                                                       *
* CALLS                                                                 *
*                                                                       *
*      LLD macros                                                       *
*                                                                       *
* INPUTS                                                                *
*                                                                       *
*      tU32 u32Time:   Time value to be converted                       *
*                                                                       *
* OUTPUTS                                                               *
*                                                                       *
*      tU32  converted value                                            *
*                                                                       *
************************************************************************/ 
tU32 EFT_ConvTime2EftVal_us (tU32 uTime)
{
    tU32 uFreq = EFT_M_US_2_HZ(uTime);
    tU32 uEftVal;

    uEftVal = ((((S_APB_CLK) / (TIMER_PRESCALER)) / uFreq) * (tU32)1000);

    return(uEftVal);
}

/************************************************************************
*                                                                       *
* FUNCTIONS                                                             *
*                                                                       *
*      EFT_ConvTime2EftVal_ns                                           *
*                                                                       *
* DESCRIPTION                                                           *
*                                                                       *
*      Convert time value from ns to EFT units                          *
*                                                                       *
* CALLS                                                                 *
*                                                                       *
*      LLD macros                                                       *
*                                                                       *
* INPUTS                                                                *
*                                                                       *
*      tU32 u32Time:   Time value to be converted                       *
*                                                                       *
* OUTPUTS                                                               *
*                                                                       *
*      tU16  converted value                                            *
*                                                                       *
************************************************************************/ 
tU16 EFT_ConvTime2EftVal_ns (tU32 uTime)
{
    tU16 uFreq = EFT_M_NS_2_HZ(uTime);
    tU16 uEftVal;

    uEftVal = (((S_APB_CLK) / (TIMER_PRESCALER)) / uFreq);

    return(uEftVal);  
}

/************************************************************************
*                                                                       *
* FUNCTIONS                                                             *
*                                                                       *
*      EFT_IntTimer0                                                    *
*                                                                       *
* DESCRIPTION                                                           *
*                                                                       *
*      EFT timer 0 int control (EFT0)                                   *
*                                                                       *
* CALLS                                                                 *
*                                                                       *
*      LLD macros                                                       *
*                                                                       *
* INPUTS                                                                *
*                                                                       *
*      None                                                             *
*                                                                       *
* OUTPUTS                                                               *
*                                                                       *
*      None                                                             *
*                                                                       *
************************************************************************/
tVoid EFT_IntTimer0 (tVoid)
{
    tU16 tmp_sr;
    tU16 tmp_cntr;

    tmp_sr = rd16_reg(Eft0,sr);
    
    tmp_cntr = rd16_reg(Eft0,Cntr);
    
   	/* Call application callback */
  	INT_EFT_EndTr_Mgr_Str[EFT0_GLOBAL_INT]();    

    if(tmp_sr & OCFA_MSK)  /* Output Compare A set */
    {
        wr16(Eft0,sr,ocfa,0);
         
        wr16_reg(Eft0,Ocar,(Eft_TimValueA+tmp_cntr));/* Program OutputCompare Reg A */
    }

    if(tmp_sr & OCFB_MSK)  /* Output Compare B set */
    {
        wr16(Eft0,sr,ocfb,0);
        
        wr16_reg(Eft0,Ocbr,(Eft_TimValueB+tmp_cntr));/* Program OutputCompare Reg B (for reload value) */
    }

    if(tmp_sr & INCA_MSK)  /* Input Capture A set */
    {
        wr16(Eft0,sr,icfa,0);
    }

    if(tmp_sr & INCB_MSK)  /* Input Capture B set */
    {
        wr16(Eft0,sr,icfb,0);
    }

    if(tmp_sr & TMR_OVF)  /* Timer overflow set */
    {
        wr16(Eft0,sr,tof,0);
        
        EFT_Timer0TofMgm();      /* Call Timer overlfow handler */
    }  
}
#endif

/************************************************************************
*                                                                       *
* FUNCTIONS                                                             *
*                                                                       *
*      EFT_IntTimer1                                                    *
*                                                                       *
* DESCRIPTION                                                           *
*                                                                       *
*      EFT timer 1 int control (EFT1)                                   *
*                                                                       *
* CALLS                                                                 *
*                                                                       *
*      LLD macros                                                       *
*                                                                       *
* INPUTS                                                                *
*                                                                       *
*      None                                                             *
*                                                                       *
* OUTPUTS                                                               *
*                                                                       *
*      None                                                             *
*                                                                       *
************************************************************************/
#ifdef OS20_USE_TIMER1