drvpwm.c

cortex-m0 LCD1602程序

    {
        if (s_i32Option)
            outp32(&PWMB->CCR2, inp32(&PWMB->CCR2) & (CCR_MASK | BIT4));
        else
            outp32(&PWMB->CCR2, inp32(&PWMB->CCR2) & ~BIT20);
                   
        if (g_sDrvPWMBHandler.pfnCAP2CallBack != NULL)
        {
            g_sDrvPWMBHandler.pfnCAP2CallBack();
        }
    }
    
    if (u32CapIntFlag1 & BIT20) 
    {
        if (s_i32Option)
            outp32(&PWMB->CCR2, inp32(&PWMB->CCR2) & (CCR_MASK | BIT20));
        else
            outp32(&PWMB->CCR2, inp32(&PWMB->CCR2) & ~BIT4);
                    
        if (g_sDrvPWMBHandler.pfnCAP3CallBack != NULL)
        {
            g_sDrvPWMBHandler.pfnCAP3CallBack();
        }
    }
}

/*---------------------------------------------------------------------------------------------------------*/
/* Function: DrvPWM_IsTimerEnabled                                                                         */
/*                                                                                                         */
/* Parameters:                                                                                             */
/*               u8Timer   - [in]       DRVPWM_TIMER0 / DRVPWM_TIMER1 / DRVPWM_TIMER2 / DRVPWM_TIMER3      */
/*                                      DRVPWM_TIMER4 / DRVPWM_TIMER5 / DRVPWM_TIMER6 / DRVPWM_TIMER7      */
/*                                                                                                         */
/* Returns:                                                                                                */
/*               0      disable                                                                            */
/*               1      enable                                                                             */
/* Description:                                                                                            */
/*               This function is used to get PWMA/PWMB specified timer enable/disable state               */
/*---------------------------------------------------------------------------------------------------------*/
int32_t DrvPWM_IsTimerEnabled(uint8_t u8Timer)
{
    int32_t status;

    status = 0;
    
    switch (u8Timer)
    {
        case DRVPWM_TIMER0:
        case DRVPWM_TIMER1:
        case DRVPWM_TIMER2:
        case DRVPWM_TIMER3:
            status = ( inp32(&PWMA->PCR) & (1 << (u8Timer<<3) ) )? 1 : 0;
            break;      
        case DRVPWM_TIMER4:
        case DRVPWM_TIMER5:
        case DRVPWM_TIMER6:
        case DRVPWM_TIMER7:
            status = ( inp32(&PWMB->PCR) & (1 << ((u8Timer-DRVPWM_TIMER4)<<3) ) )? 1 : 0;
            break;  
    }
    return status;
}


/*---------------------------------------------------------------------------------------------------------*/
/* Function: DrvPWM_SetTimerCounter                                                                        */
/*                                                                                                         */
/* Parameters:                                                                                             */
/*               u8Timer        - [in]      DRVPWM_TIMER0 / DRVPWM_TIMER1 / DRVPWM_TIMER2 / DRVPWM_TIMER3  */
/*                                          DRVPWM_TIMER4 / DRVPWM_TIMER5 / DRVPWM_TIMER6 / DRVPWM_TIMER7  */
/*               u16Counter     - [in]      Timer counter : 0~65535                                        */
/* Returns:                                                                                                */
/*               None                                                                                      */
/* Description:                                                                                            */
/*               This function is used to set the PWM0~7 specified timer counter                           */
/* Note:         If the counter is set to 0, the timer will stop.                                          */
/*---------------------------------------------------------------------------------------------------------*/
void DrvPWM_SetTimerCounter(uint8_t u8Timer, uint16_t u16Counter)
{   
    u8Timer &= 0x0F;
    
    if (u8Timer >= DRVPWM_TIMER4)
    {
        *((__IO uint32_t *) (PWMB_CNR0 + (u8Timer - DRVPWM_TIMER4) * 12)) = u16Counter;
    }
    else
    {
        *((__IO uint32_t *) (PWMA_CNR0 + (u8Timer & 0x7) * 12)) = u16Counter;   
    }
}

/*---------------------------------------------------------------------------------------------------------*/
/* Function: DrvPWM_GetTimerCounter                                                                        */
/*                                                                                                         */
/* Parameters:                                                                                             */
/*               u8Timer        - [in]      DRVPWM_TIMER0 / DRVPWM_TIMER1 / DRVPWM_TIMER2 / DRVPWM_TIMER3  */
/*                                          DRVPWM_TIMER4 / DRVPWM_TIMER5 / DRVPWM_TIMER6 / DRVPWM_TIMER7  */
/*                                                                                                         */
/* Returns:                                                                                                */
/*               The specified timer counter value                                                         */
/*                                                                                                         */
/* Description:                                                                                            */
/*               This function is used to get the PWM0~7 specified timer counter value                     */
/*---------------------------------------------------------------------------------------------------------*/
uint32_t DrvPWM_GetTimerCounter(uint8_t u8Timer)
{
    uint32_t u32Reg = 0;
    
    u8Timer &= 0x0F;
    
    if (u8Timer >= DRVPWM_TIMER4)
    {
        u32Reg = *((__IO uint32_t *) (PWMB_PDR0 + (u8Timer - DRVPWM_TIMER4) * 12));
    }
    else
    {
        u32Reg = *((__IO uint32_t *) (PWMA_PDR0 + (u8Timer & 0x7) * 12));   
    }

    return u32Reg;
}


/*---------------------------------------------------------------------------------------------------------*/
/* Function: DrvPWM_EnableInt                                                                              */
/*                                                                                                         */
/* Parameters:                                                                                             */
/*               u8Timer        - [in]      DRVPWM_TIMER0 / DRVPWM_TIMER1 / DRVPWM_TIMER2 / DRVPWM_TIMER3  */
/*                                          DRVPWM_TIMER4 / DRVPWM_TIMER5 / DRVPWM_TIMER6 / DRVPWM_TIMER7  */
/*                                          DRVPWM_CAP0   / DRVPWM_CAP1   / DRVPWM_CAP2   / DRVPWM_CAP3    */
/*                                          DRVPWM_CAP4   / DRVPWM_CAP5   / DRVPWM_CAP6   / DRVPWM_CAP7    */
/*               u8Int          - [in]      DRVPWM_CAP_RISING_INT/DRVPWM_CAP_FALLING_INT/DRVPWM_CAP_ALL_INT*/
/*                                          (The parameter is valid only when capture function)            */
/*               pfncallback    - [in]      The call back function for specified timer / capture           */
/*                                                                                                         */
/* Returns:                                                                                                */
/*               None                                                                                      */
/*                                                                                                         */
/* Description:                                                                                            */
/*               This function is used to Enable the PWM0~7 timer/capture interrupt                        */
/*---------------------------------------------------------------------------------------------------------*/
void DrvPWM_EnableInt(uint8_t u8Timer, uint8_t u8Int, PFN_DRVPWM_CALLBACK pfncallback)
{
    int32_t Rflag, Fflag;   

    Rflag = u8Int & 0x01;
    Fflag = u8Int & 0x02;
        
    switch (u8Timer)
    {   
        case DRVPWM_TIMER0:
            PWMA->PIER.PWMIE0 = 1;
            g_sDrvPWMAHandler.pfnPWM0CallBack = pfncallback;
            break;
        case DRVPWM_CAP0:           
            if (Rflag)
            {
                if (s_i32Option)
                    outp32(&PWMA->CCR0, (inp32(&PWMA->CCR0) & CCR_MASK) | BIT1);
                else
                    outp32(&PWMA->CCR0, (inp32(&PWMA->CCR0) & ~(BIT4 | BIT20)) | BIT1); 
            }
            if (Fflag)
            {
                if (s_i32Option)
                    outp32(&PWMA->CCR0, (inp32(&PWMA->CCR0) & CCR_MASK) | BIT2);
                else
                    outp32(&PWMA->CCR0, (inp32(&PWMA->CCR0) & ~(BIT4 | BIT20)) | BIT2);
            }
            g_sDrvPWMAHandler.pfnCAP0CallBack = pfncallback;
            break;  
        case DRVPWM_TIMER1:
            PWMA->PIER.PWMIE1 = 1;
            g_sDrvPWMAHandler.pfnPWM1CallBack = pfncallback;
            break;
        case DRVPWM_CAP1:           
            if (Rflag)
            {
                if (s_i32Option)
                    outp32(&PWMA->CCR0, (inp32(&PWMA->CCR0) & CCR_MASK) | BIT17);
                else
                    outp32(&PWMA->CCR0, (inp32(&PWMA->CCR0) & ~(BIT4 | BIT20)) | BIT17);            
            }
            if (Fflag)
            {
                if (s_i32Option)
                    outp32(&PWMA->CCR0, (inp32(&PWMA->CCR0) & CCR_MASK) | BIT18);
                else
                    outp32(&PWMA->CCR0, (inp32(&PWMA->CCR0) & ~(BIT4 | BIT20)) | BIT18);            
            }
            g_sDrvPWMAHandler.pfnCAP1CallBack = pfncallback;
            break;
        case DRVPWM_TIMER2:
            PWMA->PIER.PWMIE2 = 1;
            g_sDrvPWMAHandler.pfnPWM2CallBack = pfncallback;
            break;
        case DRVPWM_CAP2:           
            if (Rflag)
            {
                if (s_i32Option)
                    outp32(&PWMA->CCR2, (inp32(&PWMA->CCR2) & CCR_MASK) | BIT1);
                else
                    outp32(&PWMA->CCR2, (inp32(&PWMA->CCR2) & ~(BIT4 | BIT20)) | BIT1);             
            }
            if (Fflag)
            {
                if (s_i32Option)
                    outp32(&PWMA->CCR2, (inp32(&PWMA->CCR2) & CCR_MASK) | BIT2);
                else
                    outp32(&PWMA->CCR2, (inp32(&PWMA->CCR2) & ~(BIT4 | BIT20)) | BIT2);         
            }
            g_sDrvPWMAHandler.pfnCAP2CallBack = pfncallback;
            break;
        case DRVPWM_TIMER3:
            PWMA->PIER.PWMIE3 = 1;
            g_sDrvPWMAHandler.pfnPWM3CallBack = pfncallback;
            break;
        case DRVPWM_CAP3:           
            if (Rflag)
            {
                if (s_i32Option)
                    outp32(&PWMA->CCR2, (inp32(&PWMA->CCR2) & CCR_MASK) | BIT17);
                else
                    outp32(&PWMA->CCR2, (inp32(&PWMA->CCR2) & ~(BIT4 | BIT20)) | BIT17);                
            }
            if (Fflag)
            {
                if (s_i32Option)
                    outp32(&PWMA->CCR2, (inp32(&PWMA->CCR2) & CCR_MASK) | BIT18);
                else
                    outp32(&PWMA->CCR2, (inp32(&PWMA->CCR2) & ~(BIT4 | BIT20)) | BIT18);                
            }
            g_sDrvPWMAHandler.pfnCAP3CallBack = pfncallback;
            break;          
            
        case DRVPWM_TIMER4:
            PWMB->PIER.PWMIE0 = 1;
            g_sDrvPWMBHandler.pfnPWM0CallBack = pfncallback;
            break;
        case DRVPWM_CAP4:           
            if (Rflag)
            {
                if (s_i32Option)
                    outp32(&PWMB->CCR0, (inp32(&PWMB->CCR0) & CCR_MASK) | BIT1);
                else
                    outp32(&PWMB->CCR0, (inp32(&PWMB->CCR0) & ~(BIT4 | BIT20)) | BIT1); 
            }
            if (Fflag)
            {
                if (s_i32Option)