rt-thread/bsp/nxp/lpc/lpc408x/Libraries/Drivers/source/lpc_pwm.c

/**********************************************************************
* $Id$      lpc_pwm.c           2011-06-02
*//**
* @file     lpc_pwm.c
* @brief    Contains all functions support for PWM firmware library
*           on LPC
* @version  1.0
* @date     02. June. 2011
* @author   NXP MCU SW Application Team
* 
* Copyright(C) 2011, NXP Semiconductor
* All rights reserved.
*
***********************************************************************
* Software that is described herein is for illustrative purposes only
* which provides customers with programming information regarding the
* products. This software is supplied "AS IS" without any warranties.
* NXP Semiconductors assumes no responsibility or liability for the
* use of the software, conveys no license or title under any patent,
* copyright, or mask work right to the product. NXP Semiconductors
* reserves the right to make changes in the software without
* notification. NXP Semiconductors also make no representation or
* warranty that such application will be suitable for the specified
* use without further testing or modification.
* Permission to use, copy, modify, and distribute this software and its
* documentation is hereby granted, under NXP Semiconductors'
* relevant copyright in the software, without fee, provided that it
* is used in conjunction with NXP Semiconductors microcontrollers.  This
* copyright, permission, and disclaimer notice must appear in all copies of
* this code.
**********************************************************************/

/* Peripheral group ----------------------------------------------------------- */
/** @addtogroup PWM
 * @{
 */
#ifdef __BUILD_WITH_EXAMPLE__
#include "lpc_libcfg.h"
#else
#include "lpc_libcfg_default.h"
#endif /* __BUILD_WITH_EXAMPLE__ */
#ifdef _PWM

/* Includes ------------------------------------------------------------------- */
#include "lpc_pwm.h"
#include "lpc_clkpwr.h"

/* Public Functions ----------------------------------------------------------- */
/** @addtogroup PWM_Public_Functions
 * @{
 */

static LPC_PWM_TypeDef* PWM_GetPointer (uint8_t pwmId);

/*********************************************************************//**
 * @brief       Setting CAN baud rate (bps)
 * @param[in]   canId point to LPC_CAN_TypeDef object, should be:
 *              - LPC_CAN1: CAN1 peripheral
 *              - LPC_CAN2: CAN2 peripheral
 * @return      The pointer to CAN peripheral that's expected to use
 ***********************************************************************/
static LPC_PWM_TypeDef* PWM_GetPointer (uint8_t pwmId)
{
    LPC_PWM_TypeDef* pPwm;

    switch (pwmId)
    {
        case PWM_0:
            pPwm = LPC_PWM0;
            break;

        case PWM_1:
            pPwm = LPC_PWM1;
            break;

        default:
            pPwm = NULL;
            break;
    }

    return pPwm;
}


/*********************************************************************//**
 * @brief       Check whether specified interrupt flag in PWM is set or not
 * @param[in]    pwmId           The Id of the expected PWM component
 *
 * @param[in]   IntFlag: PWM interrupt flag, should be:
 *              - PWM_INTSTAT_MR0: Interrupt flag for PWM match channel 0
 *              - PWM_INTSTAT_MR1: Interrupt flag for PWM match channel 1
 *              - PWM_INTSTAT_MR2: Interrupt flag for PWM match channel 2
 *              - PWM_INTSTAT_MR3: Interrupt flag for PWM match channel 3
 *              - PWM_INTSTAT_MR4: Interrupt flag for PWM match channel 4
 *              - PWM_INTSTAT_MR5: Interrupt flag for PWM match channel 5
 *              - PWM_INTSTAT_MR6: Interrupt flag for PWM match channel 6
 *              - PWM_INTSTAT_CAP0: Interrupt flag for capture input 0
 *              - PWM_INTSTAT_CAP1: Interrupt flag for capture input 1
 * @return      New State of PWM interrupt flag (SET or RESET)
 **********************************************************************/
IntStatus PWM_GetIntStatus(uint8_t pwmId, uint32_t IntFlag)
{
    LPC_PWM_TypeDef* pPwm = PWM_GetPointer(pwmId);

    return ((pPwm->IR & IntFlag) ? SET : RESET);
}



/*********************************************************************//**
 * @brief       Clear specified PWM Interrupt pending
 * @param[in]    pwmId           The Id of the expected PWM component
 *
 * @param[in]   IntFlag: PWM interrupt flag, should be:
 *              - PWM_INTSTAT_MR0: Interrupt flag for PWM match channel 0
 *              - PWM_INTSTAT_MR1: Interrupt flag for PWM match channel 1
 *              - PWM_INTSTAT_MR2: Interrupt flag for PWM match channel 2
 *              - PWM_INTSTAT_MR3: Interrupt flag for PWM match channel 3
 *              - PWM_INTSTAT_MR4: Interrupt flag for PWM match channel 4
 *              - PWM_INTSTAT_MR5: Interrupt flag for PWM match channel 5
 *              - PWM_INTSTAT_MR6: Interrupt flag for PWM match channel 6
 *              - PWM_INTSTAT_CAP0: Interrupt flag for capture input 0
 *              - PWM_INTSTAT_CAP1: Interrupt flag for capture input 1
 * @return      None
 **********************************************************************/
void PWM_ClearIntPending(uint8_t pwmId, uint32_t IntFlag)
{
    LPC_PWM_TypeDef* pPwm = PWM_GetPointer(pwmId);

    pPwm->IR = IntFlag;
}



/*****************************************************************************//**
* @brief        Fills each PWM_InitStruct member with its default value:
*               - If PWMCounterMode = PWM_MODE_TIMER:
*                   + PrescaleOption = PWM_TIMER_PRESCALE_USVAL
*                   + PrescaleValue = 1
*               - If PWMCounterMode = PWM_MODE_COUNTER:
*                   + CountInputSelect = PWM_COUNTER_PCAP1_0
*                   + CounterOption = PWM_COUNTER_RISING
* @param[in]    PWMTimerCounterMode Timer or Counter mode, should be:
*               - PWM_MODE_TIMER: Counter of PWM peripheral is in Timer mode
*               - PWM_MODE_COUNTER: Counter of PWM peripheral is in Counter mode
* @param[in]    PWM_InitStruct Pointer to structure (PWM_TIMERCFG_Type or
*                PWM_COUNTERCFG_Type) which will be initialized.
* @return       None
* Note: PWM_InitStruct pointer will be assigned to corresponding structure
*       (PWM_TIMERCFG_Type or PWM_COUNTERCFG_Type) due to PWMTimerCounterMode.
*******************************************************************************/
void PWM_ConfigStructInit(uint8_t PWMTimerCounterMode, void *PWM_InitStruct)
{
    PWM_TIMERCFG_Type *pTimeCfg;
    PWM_COUNTERCFG_Type *pCounterCfg;

    pTimeCfg = (PWM_TIMERCFG_Type *) PWM_InitStruct;
    pCounterCfg = (PWM_COUNTERCFG_Type *) PWM_InitStruct;

    if (PWMTimerCounterMode == PWM_MODE_TIMER )
    {
        pTimeCfg->PrescaleOption = PWM_TIMER_PRESCALE_USVAL;
        pTimeCfg->PrescaleValue = 1;
    }
    else if (PWMTimerCounterMode == PWM_MODE_COUNTER)
    {
        pCounterCfg->CountInputSelect = PWM_COUNTER_PCAP1_0;
        pCounterCfg->CounterOption = PWM_COUNTER_RISING;
    }
}


/*********************************************************************//**
 * @brief       Initializes the pPwm peripheral corresponding to the specified
 *               parameters in the PWM_ConfigStruct.
 * @param[in]    pwmId           The Id of the expected PWM component
 *
 *
 * @param[in]   PWMTimerCounterMode Timer or Counter mode, should be:
 *              - PWM_MODE_TIMER: Counter of PWM peripheral is in Timer mode
 *              - PWM_MODE_COUNTER: Counter of PWM peripheral is in Counter mode
 * @param[in]   PWM_ConfigStruct Pointer to structure (PWM_TIMERCFG_Type or
 *               PWM_COUNTERCFG_Type) which will be initialized.
 * @return      None
 * Note: PWM_ConfigStruct pointer will be assigned to corresponding structure
 *      (PWM_TIMERCFG_Type or PWM_COUNTERCFG_Type) due to PWMTimerCounterMode.
 **********************************************************************/
void PWM_Init(uint8_t pwmId, uint32_t PWMTimerCounterMode, void *PWM_ConfigStruct)
{
    LPC_PWM_TypeDef* pPwm = PWM_GetPointer(pwmId);

    PWM_TIMERCFG_Type *pTimeCfg;
    PWM_COUNTERCFG_Type *pCounterCfg;
    uint64_t clkdlycnt;

    pTimeCfg = (PWM_TIMERCFG_Type *)PWM_ConfigStruct;
    pCounterCfg = (PWM_COUNTERCFG_Type *)PWM_ConfigStruct;

    if(pwmId == PWM_0)
    {
        CLKPWR_ConfigPPWR (CLKPWR_PCONP_PCPWM0, ENABLE);
    }
    else if(pwmId == PWM_1)
    {
        CLKPWR_ConfigPPWR (CLKPWR_PCONP_PCPWM1, ENABLE);
    }
    else
    {
        //Trap the error
        while(1);
    }

    // Get peripheral clock of PWM1
    clkdlycnt = CLKPWR_GetCLK(CLKPWR_CLKTYPE_PER);

    // Clear all interrupts pending
    pPwm->IR = 0xFF & PWM_IR_BITMASK;
    pPwm->TCR = 0x00;
    pPwm->CTCR = 0x00;
    pPwm->MCR = 0x00;
    pPwm->CCR = 0x00;
    pPwm->PCR = 0x00;
    pPwm->LER = 0x00;

    if (PWMTimerCounterMode == PWM_MODE_TIMER)
    {
        /* Absolute prescale value */
        if (pTimeCfg->PrescaleOption == PWM_TIMER_PRESCALE_TICKVAL)
        {
            pPwm->PR   = pTimeCfg->PrescaleValue - 1;
        }
        /* uSecond prescale value */
        else
        {
            clkdlycnt = (clkdlycnt * pTimeCfg->PrescaleValue) / 1000000;
            pPwm->PR = ((uint32_t) clkdlycnt) - 1;
        }

    }
    else if (PWMTimerCounterMode == PWM_MODE_COUNTER)
    {

        pPwm->CTCR |= (PWM_CTCR_MODE((uint32_t)pCounterCfg->CounterOption)) \
                        | (PWM_CTCR_SELECT_INPUT((uint32_t)pCounterCfg->CountInputSelect));
    }
}

/*********************************************************************//**
 * @brief       De-initializes the PWM peripheral registers to their
*                  default reset values.
 * @param[in]    pwmId           The Id of the expected PWM component
 *
 * @return      None
 **********************************************************************/
void PWM_DeInit (uint8_t pwmId)
{
    LPC_PWM_TypeDef* pPwm = PWM_GetPointer(pwmId);

    // Disable PWM control (timer, counter and PWM)
    pPwm->TCR = 0x00;

    if(pwmId == PWM_0)
    {
       CLKPWR_ConfigPPWR (CLKPWR_PCONP_PCPWM0, DISABLE);
    }
    else if(pwmId == PWM_1)
    {
       CLKPWR_ConfigPPWR (CLKPWR_PCONP_PCPWM1, DISABLE);
    }
}


/*********************************************************************//**
 * @brief       Enable/Disable PWM peripheral
 * @param[in]    pwmId           The Id of the expected PWM component
 *
 * @param[in]   NewState    New State of this function, should be:
 *                          - ENABLE: Enable PWM peripheral
 *                          - DISABLE: Disable PWM peripheral
 * @return      None
 **********************************************************************/
void PWM_Cmd(uint8_t pwmId, FunctionalState NewState)
{
    LPC_PWM_TypeDef* pPwm = PWM_GetPointer(pwmId);

    if (NewState == ENABLE)
    {
        pPwm->TCR   |=  PWM_TCR_PWM_ENABLE;
    }
    else
    {
        pPwm->TCR &= (~PWM_TCR_PWM_ENABLE) & PWM_TCR_BITMASK;
    }
}


/*********************************************************************//**
 * @brief       Enable/Disable Counter in PWM peripheral
 * @param[in]    pwmId           The Id of the expected PWM component
 *
 * @param[in]   NewState New State of this function, should be:
 *                          - ENABLE: Enable Counter in PWM peripheral
 *                          - DISABLE: Disable Counter in PWM peripheral
 * @return      None
 **********************************************************************/
void PWM_CounterCmd(uint8_t pwmId, FunctionalState NewState)
{
    LPC_PWM_TypeDef* pPwm = PWM_GetPointer(pwmId);

    if (NewState == ENABLE)
    {
        pPwm->TCR   |=  PWM_TCR_COUNTER_ENABLE;
    }
    else
    {
        pPwm->TCR &= (~PWM_TCR_COUNTER_ENABLE) & PWM_TCR_BITMASK;
    }
}


/*********************************************************************//**
 * @brief       Reset Counter in PWM peripheral
 * @param[in]    pwmId           The Id of the expected PWM component
 *
 * @return      None
 **********************************************************************/
void PWM_ResetCounter(uint8_t pwmId)
{
    LPC_PWM_TypeDef* pPwm = PWM_GetPointer(pwmId);

    pPwm->TCR |= PWM_TCR_COUNTER_RESET;

    pPwm->TCR &= (~PWM_TCR_COUNTER_RESET) & PWM_TCR_BITMASK;
}


/*********************************************************************//**
 * @brief       Configures match for PWM peripheral
 * @param[in]    pwmId           The Id of the expected PWM component
 *
 * @param[in]   PWM_MatchConfigStruct   Pointer to a PWM_MATCHCFG_Type structure
*                    that contains the configuration information for the
*                    specified PWM match function.
 * @return      None
 **********************************************************************/
void PWM_ConfigMatch(uint8_t pwmId, PWM_MATCHCFG_Type *PWM_MatchConfigStruct)
{
    LPC_PWM_TypeDef* pPwm = PWM_GetPointer(pwmId);

    //interrupt on MRn
    if (PWM_MatchConfigStruct->IntOnMatch == ENABLE)
    {
        pPwm->MCR |= PWM_MCR_INT_ON_MATCH(PWM_MatchConfigStruct->MatchChannel);
    }
    else
    {
        pPwm->MCR &= (~ PWM_MCR_INT_ON_MATCH(PWM_MatchConfigStruct->MatchChannel)) \
                                                                        & PWM_MCR_BITMASK;
    }

    //reset on MRn
    if (PWM_MatchConfigStruct->ResetOnMatch == ENABLE)
    {
        pPwm->MCR |= PWM_MCR_RESET_ON_MATCH(PWM_MatchConfigStruct->MatchChannel);
    }
    else
    {
        pPwm->MCR &= (~ PWM_MCR_RESET_ON_MATCH(PWM_MatchConfigStruct->MatchChannel)) \
                                                                        & PWM_MCR_BITMASK;
    }

    //stop on MRn
    if (PWM_MatchConfigStruct->StopOnMatch == ENABLE)
    {
        pPwm->MCR |= PWM_MCR_STOP_ON_MATCH(PWM_MatchConfigStruct->MatchChannel);
    }
    else
    {
        pPwm->MCR &= (~ PWM_MCR_STOP_ON_MATCH(PWM_MatchConfigStruct->MatchChannel)) \
                                                                        & PWM_MCR_BITMASK;
    }
}


/*********************************************************************//**
 * @brief       Configures capture input for PWM peripheral
 * @param[in]    pwmId           The Id of the expected PWM component
 *
 * @param[in]   PWM_CaptureConfigStruct Pointer to a PWM_CAPTURECFG_Type structure
 *                    that contains the configuration information for the
 *                    specified PWM capture input function.
 * @return      None
 **********************************************************************/
void PWM_ConfigCapture(uint8_t pwmId, PWM_CAPTURECFG_Type *PWM_CaptureConfigStruct)
{
    LPC_PWM_TypeDef* pPwm = PWM_GetPointer(pwmId);

    if (PWM_CaptureConfigStruct->RisingEdge == ENABLE)
    {
        pPwm->CCR |= PWM_CCR_CAP_RISING(PWM_CaptureConfigStruct->CaptureChannel);
    }
    else
    {
        pPwm->CCR &= (~ PWM_CCR_CAP_RISING(PWM_CaptureConfigStruct->CaptureChannel)) \
                                                                        & PWM_CCR_BITMASK;
    }

    if (PWM_CaptureConfigStruct->FallingEdge == ENABLE)
    {
        pPwm->CCR |= PWM_CCR_CAP_FALLING(PWM_CaptureConfigStruct->CaptureChannel);
    }
    else
    {
        pPwm->CCR &= (~ PWM_CCR_CAP_FALLING(PWM_CaptureConfigStruct->CaptureChannel)) \
                                                                        & PWM_CCR_BITMASK;
    }

    if (PWM_CaptureConfigStruct->IntOnCaption == ENABLE)
    {
        pPwm->CCR |= PWM_CCR_INT_ON_CAP(PWM_CaptureConfigStruct->CaptureChannel);
    }
    else
    {
        pPwm->CCR &= (~ PWM_CCR_INT_ON_CAP(PWM_CaptureConfigStruct->CaptureChannel)) \
                                                                        & PWM_CCR_BITMASK;
    }
}


/*********************************************************************//**
 * @brief       Read value of capture register PWM peripheral
 * @param[in]    pwmId           The Id of the expected PWM component
 *
 * @param[in]   CaptureChannel: capture channel number, should be in
 *              range 0 to 1
 * @return      Value of capture register
 **********************************************************************/
uint32_t PWM_GetCaptureValue(uint8_t pwmId, uint8_t CaptureChannel)
{
    LPC_PWM_TypeDef* pPwm = PWM_GetPointer(pwmId);

    switch (CaptureChannel)
    {
        case 0:
            return pPwm->CR0;

        case 1:
            return pPwm->CR1;

        default:
            return (0);
    }
}


/********************************************************************//**
 * @brief       Update value for each PWM channel with update type option
 * @param[in]    pwmId           The Id of the expected PWM component
 *
 * @param[in]   MatchChannel Match channel
 * @param[in]   MatchValue Match value
 * @param[in]   UpdateType Type of Update, should be:
 *              - PWM_MATCH_UPDATE_NOW: The update value will be updated for
 *                  this channel immediately
 *              - PWM_MATCH_UPDATE_NEXT_RST: The update value will be updated for
 *                  this channel on next reset by a PWM Match event.
 * @return      None
 *********************************************************************/
void PWM_MatchUpdate(uint8_t pwmId, uint8_t MatchChannel,
                                        uint32_t MatchValue, uint8_t UpdateType)
{
    LPC_PWM_TypeDef* pPwm = PWM_GetPointer(pwmId);

    switch (MatchChannel)
    {
        case 0:
            pPwm->MR0 = MatchValue;
            break;

        case 1:
            pPwm->MR1 = MatchValue;
            break;

        case 2:
            pPwm->MR2 = MatchValue;
            break;

        case 3:
            pPwm->MR3 = MatchValue;
            break;

        case 4:
            pPwm->MR4 = MatchValue;
            break;

        case 5:
            pPwm->MR5 = MatchValue;
            break;

        case 6:
            pPwm->MR6 = MatchValue;
            break;
    }

    // Write Latch register
    pPwm->LER |= PWM_LER_EN_MATCHn_LATCH(MatchChannel);

    // In case of update now
    if (UpdateType == PWM_MATCH_UPDATE_NOW)
    {
        pPwm->TCR |= PWM_TCR_COUNTER_RESET;
        pPwm->TCR &= (~PWM_TCR_COUNTER_RESET) & PWM_TCR_BITMASK;
    }
}


/********************************************************************//**
 * @brief       Configure Edge mode for each PWM channel
 * @param[in]    pwmId           The Id of the expected PWM component
 *
 * @param[in]   PWMChannel PWM channel, should be in range from 2 to 6
 * @param[in]   ModeOption PWM mode option, should be:
 *              - PWM_CHANNEL_SINGLE_EDGE: Single Edge mode
 *              - PWM_CHANNEL_DUAL_EDGE: Dual Edge mode
 * @return      None
 * Note: PWM Channel 1 can not be selected for mode option
 *********************************************************************/
void PWM_ChannelConfig(uint8_t pwmId, uint8_t PWMChannel, uint8_t ModeOption)
{
    LPC_PWM_TypeDef* pPwm = PWM_GetPointer(pwmId);

    // Single edge mode
    if (ModeOption == PWM_CHANNEL_SINGLE_EDGE)
    {
        pPwm->PCR &= (~ PWM_PCR_PWMSELn(PWMChannel)) & PWM_PCR_BITMASK;
    }
    // Double edge mode
    else if (PWM_CHANNEL_DUAL_EDGE)
    {
        pPwm->PCR |= PWM_PCR_PWMSELn(PWMChannel);
    }
}



/********************************************************************//**
 * @brief       Enable/Disable PWM channel output
 * @param[in]    pwmId           The Id of the expected PWM component
 *
 * @param[in]   PWMChannel PWM channel, should be in range from 1 to 6
 * @param[in]   NewState New State of this function, should be:
 *              - ENABLE: Enable this PWM channel output
 *              - DISABLE: Disable this PWM channel output
 * @return      None
 *********************************************************************/
void PWM_ChannelCmd(uint8_t pwmId, uint8_t PWMChannel, FunctionalState NewState)
{
    LPC_PWM_TypeDef* pPwm = PWM_GetPointer(pwmId);

    if (NewState == ENABLE)
    {
        pPwm->PCR |= PWM_PCR_PWMENAn(PWMChannel);
    }
    else
    {
        pPwm->PCR &= (~ PWM_PCR_PWMENAn(PWMChannel)) & PWM_PCR_BITMASK;
    }
}

/**
 * @}
 */

#endif /*_PWM*/
/**
 * @}
 */

/* --------------------------------- End Of File ------------------------------ */