Exemplo n.º 1
0
/*********************************************************************//**
 * @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;
	}
}
Exemplo n.º 2
0
/*********************************************************************//**
 * @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));
	}
}
Exemplo n.º 3
0
/*********************************************************************//**
 * @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;
}
Exemplo n.º 4
0
/*********************************************************************//**
 * @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;

    CLKPWR_ConfigPPWR ( CLKPWR_PCONP_PCPWM1, DISABLE );
}
Exemplo n.º 5
0
/********************************************************************//**
 * @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;
	}
}
Exemplo n.º 6
0
/*********************************************************************//**
 * @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;
	}
}
Exemplo n.º 7
0
/********************************************************************//**
 * @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);
	}
}
Exemplo n.º 8
0
/*********************************************************************//**
 * @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);
	}
}
Exemplo n.º 9
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;
	}
}
Exemplo n.º 10
0
/*********************************************************************//**
 * @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;
	}
}
Exemplo n.º 11
0
/*********************************************************************//**
 * @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;
}
Exemplo n.º 12
0
/*********************************************************************//**
 * @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);
}