Pulse Width Modulation (PWM)

See Quickstart guide for SAM PWM module. More...

Macros
#define	PWM_CLOCK_DIV_MAX   256
#define	PWM_CLOCK_PRE_MAX   11
#define	PWM_WPCR_WPCMD_DISABLE_SW_PROT   (PWM_WPCR_WPCMD(0))
#define	PWM_WPCR_WPCMD_ENABLE_HW_PROT   (PWM_WPCR_WPCMD(2))
#define	PWM_WPCR_WPCMD_ENABLE_SW_PROT   (PWM_WPCR_WPCMD(1))
#define	PWM_WPCR_WPKEY_PASSWD   0x50574D00

Functions
void	pwm_channel_disable (Pwm *p_pwm, uint32_t ul_channel)
	Disable the PWM channel.
void	pwm_channel_disable_interrupt (Pwm *p_pwm, uint32_t ul_event, uint32_t ul_fault)
	Disable the interrupt of a channel counter event and fault protection.
void	pwm_channel_enable (Pwm *p_pwm, uint32_t ul_channel)
	Enable the PWM channel.
void	pwm_channel_enable_interrupt (Pwm *p_pwm, uint32_t ul_event, uint32_t ul_fault)
	Enable the interrupt of a channel counter event and fault protection.
uint32_t	pwm_channel_get_counter (Pwm *p_pwm, pwm_channel_t *p_channel)
	Return channel counter value.
uint32_t	pwm_channel_get_interrupt_mask (Pwm *p_pwm)
	Get channel counter event and fault protection trigger interrupt mask.
uint32_t	pwm_channel_get_interrupt_status (Pwm *p_pwm)
	Get channel counter event and fault protection trigger interrupt status.
uint32_t	pwm_channel_get_status (Pwm *p_pwm)
	Check which PWM channel is enabled.
uint32_t	pwm_channel_init (Pwm *p_pwm, pwm_channel_t *p_channel)
	Initialize one PWM channel.
void	pwm_channel_update_dead_time (Pwm *p_pwm, pwm_channel_t *p_channel, uint16_t us_deadtime_pwmh, uint16_t us_deadtime_pwml)
	Change dead-time value for PWM outputs.
uint32_t	pwm_channel_update_duty (Pwm *p_pwm, pwm_channel_t *p_channel, uint32_t ul_duty)
	Change the duty cycle of the PWM channel.
void	pwm_channel_update_output (Pwm *p_pwm, pwm_channel_t *p_channel, pwm_output_t *p_output, bool b_sync)
	Change output selection of the PWM channel.
uint32_t	pwm_channel_update_period (Pwm *p_pwm, pwm_channel_t *p_channel, uint32_t ul_period)
	Change the period of the PWM channel.
static uint32_t	pwm_clocks_generate (uint32_t ul_frequency, uint32_t ul_mck)
	Find a prescaler/divisor couple to generate the desired ul_frequency from ul_mck.
uint32_t	pwm_cmp_change_setting (Pwm *p_pwm, pwm_cmp_t *p_cmp)
	Change the setting of PWM comparison.
void	pwm_cmp_disable_interrupt (Pwm *p_pwm, uint32_t ul_sources, pwm_cmp_interrupt_t type)
	Disable the interrupt of comparison.
void	pwm_cmp_enable_interrupt (Pwm *p_pwm, uint32_t ul_sources, pwm_cmp_interrupt_t type)
	Enable the interrupt of comparison.
uint32_t	pwm_cmp_get_period_counter (Pwm *p_pwm, uint32_t ul_cmp_unit)
	Report the value of the comparison period counter.
uint32_t	pwm_cmp_get_update_counter (Pwm *p_pwm, uint32_t ul_cmp_unit)
	Report the value of the comparison update period counter.
uint32_t	pwm_cmp_init (Pwm *p_pwm, pwm_cmp_t *p_cmp)
	Initialize PWM comparison unit.
void	pwm_disable_protect (Pwm *p_pwm, uint32_t ul_group)
	Disable PWM write protect.
void	pwm_enable_protect (Pwm *p_pwm, uint32_t ul_group, bool b_sw)
	Enable PWM write protect.
void	pwm_fault_clear_status (Pwm *p_pwm, pwm_fault_id_t id)
	Clear a fault input.
pwm_level_t	pwm_fault_get_input_level (Pwm *p_pwm, pwm_fault_id_t id)
	Get the level of a fault input.
uint32_t	pwm_fault_get_status (Pwm *p_pwm)
	Get fault status.
uint32_t	pwm_fault_init (Pwm *p_pwm, pwm_fault_t *p_fault)
	Initialize the behavior of a fault input.
uint32_t	pwm_get_interrupt_mask (Pwm *p_pwm)
	Get interrupt mask of PDC transfer, synchronous channels and comparison.
uint32_t	pwm_get_interrupt_status (Pwm *p_pwm)
	Get interrupt status of PDC transfer, synchronous channels and comparison.
bool	pwm_get_protect_status (Pwm *p_pwm, pwm_protect_t *p_protect)
	Get PWM write protect status.
uint32_t	pwm_init (Pwm *p_pwm, pwm_clock_t *clock_config)
	Initialize the PWM source clock (clock A and clock B).
void	pwm_pdc_disable_interrupt (Pwm *p_pwm, uint32_t ul_sources)
	Disable the interrupt of PDC transfer.
void	pwm_pdc_enable_interrupt (Pwm *p_pwm, uint32_t ul_sources)
	Enable the interrupt of PDC transfer.
void	pwm_pdc_set_request_mode (Pwm *p_pwm, pwm_pdc_request_mode_t request_mode, uint32_t ul_cmp_unit)
	Set PDC transfer request mode.
void	pwm_stepper_motor_init (Pwm *p_pwm, pwm_stepper_motor_pair_t pair, bool b_enable_gray, bool b_down)
	Initialize PWM stepper motor mode.
void	pwm_sync_change_period (Pwm *p_pwm, uint32_t ul_update_period)
	Change the wanted time between each update of the synchronous channels.
void	pwm_sync_disable_interrupt (Pwm *p_pwm, uint32_t ul_sources)
	Disable the interrupt of synchronous channels.
void	pwm_sync_enable_interrupt (Pwm *p_pwm, uint32_t ul_sources)
	Enable the interrupt of synchronous channel.
uint32_t	pwm_sync_get_period_counter (Pwm *p_pwm)
	Get the value of the synchronization update period counter.
uint32_t	pwm_sync_init (Pwm *p_pwm, pwm_sync_update_mode_t mode, uint32_t ul_update_period)
	Initialize synchronous channels update mode and period.
void	pwm_sync_unlock_update (Pwm *p_pwm)
	Unlock the update of synchronous channels.

Detailed Description

See Quickstart guide for SAM PWM module.

Driver for the PWM (Pulse Width Modulation). This driver provides access to the main features of the PWM controller.

Macro Definition Documentation

PWM_CLOCK_DIV_MAX

#define PWM_CLOCK_DIV_MAX   256

Definition at line 74 of file pwm.c.

Referenced by pwm_clocks_generate().

PWM_CLOCK_PRE_MAX

#define PWM_CLOCK_PRE_MAX   11

Definition at line 75 of file pwm.c.

Referenced by pwm_clocks_generate().

PWM_WPCR_WPCMD_DISABLE_SW_PROT

#define PWM_WPCR_WPCMD_DISABLE_SW_PROT   (PWM_WPCR_WPCMD(0))

Definition at line 63 of file pwm.c.

Referenced by pwm_disable_protect().

PWM_WPCR_WPCMD_ENABLE_HW_PROT

#define PWM_WPCR_WPCMD_ENABLE_HW_PROT   (PWM_WPCR_WPCMD(2))

Definition at line 71 of file pwm.c.

Referenced by pwm_enable_protect().

PWM_WPCR_WPCMD_ENABLE_SW_PROT

#define PWM_WPCR_WPCMD_ENABLE_SW_PROT   (PWM_WPCR_WPCMD(1))

Definition at line 67 of file pwm.c.

Referenced by pwm_enable_protect().

PWM_WPCR_WPKEY_PASSWD

#define PWM_WPCR_WPKEY_PASSWD   0x50574D00

Definition at line 59 of file pwm.c.

Referenced by pwm_disable_protect(), and pwm_enable_protect().

Function Documentation

pwm_channel_disable()

void pwm_channel_disable	(	Pwm *	p_pwm,
		uint32_t	ul_channel )

Disable the PWM channel.

Note

A disabled PWM channel can be re-initialized using pwm_channel_init().

Parameters

p_pwm	Pointer to a PWM instance.
ul_channel	PWM channel number to disable.

Definition at line 410 of file pwm.c.

{
    p_pwm->PWM_DIS = (1 << ul_channel);
}

References Pwm::PWM_DIS.

pwm_channel_disable_interrupt()

void pwm_channel_disable_interrupt	(	Pwm *	p_pwm,
		uint32_t	ul_event,
		uint32_t	ul_fault )

Disable the interrupt of a channel counter event and fault protection.

Parameters

p_pwm	Pointer to a PWM instance.
ul_event	Bitmask of channel number to disable counter event interrupt.
ul_fault	Bitmask of channel number to disable fault protection interrupt(ignored by SAM3N/SAM4N/SAM4C/SAM4CP/SAM4CM).

Definition at line 488 of file pwm.c.

{
#if (SAM3N || SAM4N || SAM4C || SAM4CP || SAM4CM)
    p_pwm->PWM_IDR = (1 << ul_event);
    /* avoid Cppcheck Warning */
    UNUSED(ul_fault);
#else
    p_pwm->PWM_IDR1 = (1 << ul_event) | (1 << (ul_fault + 16));
#endif
}

References Pwm::PWM_IDR1.

pwm_channel_enable()

void pwm_channel_enable	(	Pwm *	p_pwm,
		uint32_t	ul_channel )

Enable the PWM channel.

Note

The PWM channel should be initialized by pwm_channel_init() before it is enabled.

Parameters

p_pwm	Pointer to a PWM instance.
ul_channel	PWM channel number to enable.

Definition at line 397 of file pwm.c.

{
    p_pwm->PWM_ENA = (1 << ul_channel);
}

References Pwm::PWM_ENA.

pwm_channel_enable_interrupt()

void pwm_channel_enable_interrupt	(	Pwm *	p_pwm,
		uint32_t	ul_event,
		uint32_t	ul_fault )

Enable the interrupt of a channel counter event and fault protection.

Parameters

p_pwm	Pointer to a PWM instance.
ul_event	Channel number to enable counter event interrupt.
ul_fault	Channel number to enable fault protection interrupt(ignored by SAM3N/SAM4N/SAM4C/SAM4CP/SAM4CM).

Definition at line 467 of file pwm.c.

{
#if (SAM3N || SAM4N || SAM4C || SAM4CP || SAM4CM)
    p_pwm->PWM_IER = (1 << ul_event);
    /* avoid Cppcheck Warning */
    UNUSED(ul_fault);
#else
    p_pwm->PWM_IER1 = (1 << ul_event) | (1 << (ul_fault + 16));
#endif
}

References Pwm::PWM_IER1.

pwm_channel_get_counter()

uint32_t pwm_channel_get_counter	(	Pwm *	p_pwm,
		pwm_channel_t *	p_channel )

Return channel counter value.

Parameters

p_pwm	Pointer to a PWM instance.
p_channel	Configurations of the specified PWM channel.

Returns

channel Counter value.

Definition at line 383 of file pwm.c.

{
    return p_pwm->PWM_CH_NUM[p_channel->channel].PWM_CCNT;
}

References pwm_channel_t::channel, PwmCh_num::PWM_CCNT, and Pwm::PWM_CH_NUM.

pwm_channel_get_interrupt_mask()

uint32_t pwm_channel_get_interrupt_mask

(

Pwm *

p_pwm

)

Get channel counter event and fault protection trigger interrupt mask.

Parameters

p_pwm

Pointer to a PWM instance.

Returns

Channel counter event and fault protection trigger interrupt mask.

Definition at line 450 of file pwm.c.

{
#if (SAM3N || SAM4N || SAM4C || SAM4CP || SAM4CM)
    return p_pwm->PWM_IMR;
#else
    return p_pwm->PWM_IMR1;
#endif
}

References Pwm::PWM_IMR1.

pwm_channel_get_interrupt_status()

uint32_t pwm_channel_get_interrupt_status

(

Pwm *

p_pwm

)

Get channel counter event and fault protection trigger interrupt status.

Parameters

p_pwm

Pointer to a PWM instance.

Returns

Channel counter event and fault protection trigger interrupt status.

Definition at line 434 of file pwm.c.

{
#if (SAM3N || SAM4N || SAM4C || SAM4CP || SAM4CM)
    return p_pwm->PWM_ISR;
#else
    return p_pwm->PWM_ISR1;
#endif
}

References Pwm::PWM_ISR1.

pwm_channel_get_status()

uint32_t pwm_channel_get_status

(

Pwm *

p_pwm

)

Check which PWM channel is enabled.

Parameters

p_pwm

Pointer to a PWM instance.

Returns

Bitmask of enabled PWM channel(s).

Definition at line 422 of file pwm.c.

{
    return p_pwm->PWM_SR;
}

References Pwm::PWM_SR.

pwm_channel_init()

uint32_t pwm_channel_init	(	Pwm *	p_pwm,
		pwm_channel_t *	p_channel )

Initialize one PWM channel.

Parameters

p_pwm	Pointer to a PWM instance.
p_channel	Configurations of the specified PWM channel.

Return values

0	if initialization succeeds, otherwise fails.

Definition at line 160 of file pwm.c.

{
    uint32_t tmp_reg = 0;
    uint32_t ch_num = p_channel->channel;
 
    /* Channel Mode/Clock Register */
    tmp_reg = (p_channel->ul_prescaler & 0xF) |
            (p_channel->polarity << 9) |
#if (SAM3U || SAM3S || SAM3XA || SAM4S || SAM4E || SAMV70 || SAMV71 || SAME70 || SAMS70)
            (p_channel->counter_event) |
            (p_channel->b_deadtime_generator << 16) |
            (p_channel->b_pwmh_output_inverted << 17) |
            (p_channel->b_pwml_output_inverted << 18) |
#endif
            (p_channel->alignment);
    p_pwm->PWM_CH_NUM[ch_num].PWM_CMR = tmp_reg;
 
    /* Channel Duty Cycle Register */
    p_pwm->PWM_CH_NUM[ch_num].PWM_CDTY = p_channel->ul_duty;
 
    /* Channel Period Register */
    p_pwm->PWM_CH_NUM[ch_num].PWM_CPRD = p_channel->ul_period;
    
#if (SAM3U || SAM3S || SAM3XA || SAM4S || SAM4E || SAMV70 || SAMV71 || SAME70 || SAMS70)
    /* Channel Dead Time Register */
    if (p_channel->b_deadtime_generator) {
        p_pwm->PWM_CH_NUM[ch_num].PWM_DT =
                PWM_DT_DTL(p_channel->
                us_deadtime_pwml) | PWM_DT_DTH(p_channel->
                us_deadtime_pwmh);
    }
 
    /* Output Selection Register */
    tmp_reg  = p_pwm->PWM_OS & (~((PWM_OS_OSH0 | PWM_OS_OSL0) << ch_num));
    tmp_reg |= ((p_channel->output_selection.b_override_pwmh) << ch_num) |
            (((p_channel->output_selection.b_override_pwml) << ch_num)
                    << 16);
    p_pwm->PWM_OS = tmp_reg;
 
    /* Output Override Value Register */
    tmp_reg  = p_pwm->PWM_OOV & (~((PWM_OOV_OOVH0 | PWM_OOV_OOVL0) << ch_num));
    tmp_reg |= ((p_channel->output_selection.override_level_pwmh) << ch_num) |
            (((p_channel->output_selection.override_level_pwml) << ch_num)
                    << 16);
    p_pwm->PWM_OOV = tmp_reg;
 
    /* Sync Channels Mode Register */
    uint32_t channel = (1 << ch_num);
    if (p_channel->b_sync_ch) {
        p_pwm->PWM_SCM |= channel;
    } else {
        p_pwm->PWM_SCM &= ~((uint32_t) channel);
    }
 
    /* Fault Protection Value Register */
#if (SAM4E || SAMV70 || SAMV71 || SAME70 || SAMS70)
    if (p_channel->ul_fault_output_pwmh == PWM_HIGHZ) {
        p_pwm->PWM_FPV2 |= (0x01 << ch_num);
    } else {
        p_pwm->PWM_FPV2 &= ~(0x01 << ch_num);
        if (p_channel->ul_fault_output_pwmh == PWM_HIGH) {
            p_pwm->PWM_FPV1 |= (0x01 << ch_num);
        } else {
            p_pwm->PWM_FPV1 &= (~(0x01 << ch_num));
        }
    }
    if (p_channel->ul_fault_output_pwml == PWM_HIGHZ) {
        p_pwm->PWM_FPV2 |= ((0x01 << ch_num) << 16);
    } else {
        p_pwm->PWM_FPV2 &= ~((0x01 << ch_num) << 16);
        if (p_channel->ul_fault_output_pwml == PWM_HIGH) {
            p_pwm->PWM_FPV1 |= ((0x01 << ch_num) << 16);
        } else {
            p_pwm->PWM_FPV1 &= (~((0x01 << ch_num) << 16));
        }
    }
#else
    if (p_channel->ul_fault_output_pwmh == PWM_HIGH) {
        p_pwm->PWM_FPV |= (0x01 << ch_num);
    } else {
        p_pwm->PWM_FPV &= (~(0x01 << ch_num));
    }
    if (p_channel->ul_fault_output_pwml == PWM_HIGH) {
        p_pwm->PWM_FPV |= ((0x01 << ch_num) << 16);
    } else {
        p_pwm->PWM_FPV &= (~((0x01 << ch_num) << 16));
    }
#endif
    /* Fault Protection Enable Register */
    uint32_t fault_enable_reg = 0;
#if (SAM3XA)
    if (ch_num < 4) {
        ch_num *= 8;
        fault_enable_reg = p_pwm->PWM_FPE1;
        fault_enable_reg &= ~(0xFF << ch_num);
        fault_enable_reg |= ((p_channel->fault_id) << ch_num);
        p_pwm->PWM_FPE1 = fault_enable_reg;
    } else {
        ch_num -= 4;
        ch_num *= 8;
        fault_enable_reg = p_pwm->PWM_FPE2;
        fault_enable_reg &= ~(0xFF << ch_num);
        fault_enable_reg |= ((p_channel->fault_id) << ch_num);
        p_pwm->PWM_FPE2 = fault_enable_reg;
    }
#endif
 
#if (SAM3U || SAM3S || SAM4S || SAM4E || SAMV70 || SAMV71 || SAME70 || SAMS70)
    ch_num *= 8;
    fault_enable_reg = p_pwm->PWM_FPE;
    fault_enable_reg &= ~(0xFF << ch_num);
    fault_enable_reg |= ((p_channel->fault_id) << ch_num);
    p_pwm->PWM_FPE = fault_enable_reg;
#endif
#endif
 
    ch_num = p_channel->channel;
 
#if SAM4E
    if (!ch_num) {
        if (p_channel->spread_spectrum_mode ==
                PWM_SPREAD_SPECTRUM_MODE_RANDOM) {
            p_pwm->PWM_SSPR = PWM_SSPR_SPRD(p_channel->ul_spread) |
                    PWM_SSPR_SPRDM;
        } else {
            p_pwm->PWM_SSPR = PWM_SSPR_SPRD(p_channel->ul_spread);
        }
    }
#elif (SAMV70 || SAMV71 || SAME70 || SAMS70)
    if (!ch_num) {
        if (p_channel->spread_spectrum_mode ==
        PWM_SPREAD_SPECTRUM_MODE_RANDOM) {
            p_pwm->PWM_SSPR = PWM_SSPR_SPRD(p_channel->ul_spread) |
            PWM_SSPR_SPRDM;
            } else {
            p_pwm->PWM_SSPR = PWM_SSPR_SPRD(p_channel->ul_spread);
        }
    }
    p_pwm->PWM_CH_NUM[ch_num].PWM_CMR &= (~PWM_CMR_PPM);
    p_pwm->PWM_CH_NUM[ch_num].PWM_CMR |= (p_channel->ul_ppm_mode & PWM_CMR_PPM);
#endif
 
    return 0;
}

References pwm_channel_t::alignment, pwm_channel_t::b_deadtime_generator, pwm_output_t::b_override_pwmh, pwm_output_t::b_override_pwml, pwm_channel_t::b_pwmh_output_inverted, pwm_channel_t::b_pwml_output_inverted, pwm_channel_t::b_sync_ch, pwm_channel_t::channel, pwm_channel_t::counter_event, pwm_channel_t::fault_id, pwm_channel_t::output_selection, pwm_output_t::override_level_pwmh, pwm_output_t::override_level_pwml, pwm_channel_t::polarity, PwmCh_num::PWM_CDTY, Pwm::PWM_CH_NUM, PwmCh_num::PWM_CMR, PwmCh_num::PWM_CPRD, PwmCh_num::PWM_DT, PWM_DT_DTH, PWM_DT_DTL, Pwm::PWM_FPE, Pwm::PWM_FPV, PWM_HIGH, Pwm::PWM_OOV, PWM_OOV_OOVH0, PWM_OOV_OOVL0, Pwm::PWM_OS, PWM_OS_OSH0, PWM_OS_OSL0, Pwm::PWM_SCM, pwm_channel_t::ul_duty, pwm_channel_t::ul_fault_output_pwmh, pwm_channel_t::ul_fault_output_pwml, pwm_channel_t::ul_period, and pwm_channel_t::ul_prescaler.

pwm_channel_update_dead_time()

void pwm_channel_update_dead_time	(	Pwm *	p_pwm,
		pwm_channel_t *	p_channel,
		uint16_t	us_deadtime_pwmh,
		uint16_t	us_deadtime_pwml )

Change dead-time value for PWM outputs.

Parameters

p_pwm	Pointer to a PWM instance.
p_channel	Configurations of the specified PWM channel.
us_deadtime_pwmh	New dead-time value for PWMH output.
us_deadtime_pwml	New dead-time value for PWML output.

Definition at line 554 of file pwm.c.

{
    /* Save new dead time value */
    p_channel->us_deadtime_pwmh = us_deadtime_pwmh;
    p_channel->us_deadtime_pwml = us_deadtime_pwml;
 
    /* Write channel dead time update register */
    p_pwm->PWM_CH_NUM[p_channel->channel].PWM_DTUPD =
            PWM_DTUPD_DTLUPD(us_deadtime_pwml) |
            PWM_DTUPD_DTHUPD(us_deadtime_pwmh);
}

References pwm_channel_t::channel, Pwm::PWM_CH_NUM, PwmCh_num::PWM_DTUPD, PWM_DTUPD_DTHUPD, PWM_DTUPD_DTLUPD, pwm_channel_t::us_deadtime_pwmh, and pwm_channel_t::us_deadtime_pwml.

pwm_channel_update_duty()

uint32_t pwm_channel_update_duty	(	Pwm *	p_pwm,
		pwm_channel_t *	p_channel,
		uint32_t	ul_duty )

Change the duty cycle of the PWM channel.

Parameters

p_pwm	Pointer to a PWM instance.
p_channel	Configurations of the specified PWM channel.
ul_duty	New duty cycle value.

Return values

0	if changing succeeds, otherwise fails.

Check parameter

Definition at line 348 of file pwm.c.

{
    uint32_t ch_num = p_channel->channel;

    if (p_channel->ul_period < ul_duty) {
        return PWM_INVALID_ARGUMENT;
    } else {
        /* Save new duty cycle value */
        p_channel->ul_duty = ul_duty;
 
#if (SAM3N || SAM4N || SAM4C || SAM4CP || SAM4CM)
        /* Clear CPD bit to change duty cycle value */
        uint32_t mode = p_pwm->PWM_CH_NUM[ch_num].PWM_CMR;
        mode &= ~PWM_CMR_CPD;
        p_pwm->PWM_CH_NUM[ch_num].PWM_CMR = mode;
 
        p_pwm->PWM_CH_NUM[ch_num].PWM_CUPD = ul_duty;
#else
        p_pwm->PWM_CH_NUM[ch_num].PWM_CDTYUPD = ul_duty;
#endif
    }
 
    return 0;
}

References pwm_channel_t::channel, PwmCh_num::PWM_CDTYUPD, Pwm::PWM_CH_NUM, PwmCh_num::PWM_CMR, PWM_INVALID_ARGUMENT, pwm_channel_t::ul_duty, and pwm_channel_t::ul_period.

pwm_channel_update_output()

void pwm_channel_update_output	(	Pwm *	p_pwm,
		pwm_channel_t *	p_channel,
		pwm_output_t *	p_output,
		bool	b_sync )

Change output selection of the PWM channel.

Parameters

p_pwm	Pointer to a PWM instance.
p_channel	Configurations of the specified PWM channel.
p_output	New PWM channel output selection.
b_sync	Boolean of changing of output selection. Set true to change the output synchronously (at the beginning of the next PWM period). Set false to change the output asynchronously (at the end of the execution of the function).

Definition at line 510 of file pwm.c.

{
    uint32_t ch_num = p_channel->channel;
 
    bool override_pwmh = p_output->b_override_pwmh;
    bool override_pwml = p_output->b_override_pwml;
    uint32_t pwmh = p_output->override_level_pwmh;
    uint32_t pwml = p_output->override_level_pwml;
 
    /* Save new output configuration */
    p_channel->output_selection.b_override_pwmh = override_pwmh;
    p_channel->output_selection.b_override_pwml = override_pwml;
    p_channel->output_selection.override_level_pwmh = (pwm_level_t) pwmh;
    p_channel->output_selection.override_level_pwml = (pwm_level_t) pwml;
 
    /* Change override output level */
    uint32_t override_value = p_pwm->PWM_OOV;
    override_value &= ~((PWM_OOV_OOVH0 | PWM_OOV_OOVL0) << ch_num);
    override_value |= (((pwml << 16) | pwmh) << ch_num);
    p_pwm->PWM_OOV = override_value;
 
    /* Apply new output selection */
    if (b_sync) {
        p_pwm->PWM_OSSUPD = ((override_pwml << ch_num) << 16) |
            (override_pwmh << ch_num);
        p_pwm->PWM_OSCUPD = ((!override_pwml << ch_num) << 16) |
            (!override_pwmh << ch_num);
    } else {
        p_pwm->PWM_OSS = ((override_pwml << ch_num) << 16) |
            (override_pwmh << ch_num);
        p_pwm->PWM_OSC = ((!override_pwml << ch_num) << 16) |
            (!override_pwmh << ch_num);
    }
}

References pwm_output_t::b_override_pwmh, pwm_output_t::b_override_pwml, pwm_channel_t::channel, pwm_channel_t::output_selection, pwm_output_t::override_level_pwmh, pwm_output_t::override_level_pwml, Pwm::PWM_OOV, PWM_OOV_OOVH0, PWM_OOV_OOVL0, Pwm::PWM_OSC, Pwm::PWM_OSCUPD, Pwm::PWM_OSS, and Pwm::PWM_OSSUPD.

pwm_channel_update_period()

uint32_t pwm_channel_update_period	(	Pwm *	p_pwm,
		pwm_channel_t *	p_channel,
		uint32_t	ul_period )

Change the period of the PWM channel.

Parameters

p_pwm	Pointer to a PWM instance.
p_channel	Configurations of the specified PWM channel.
ul_period	New period value.

Return values

0	if changing succeeds, otherwise fails.

Check parameter

Definition at line 314 of file pwm.c.

{
    uint32_t ch_num = p_channel->channel;

    if (p_channel->ul_duty > ul_period) {
        return PWM_INVALID_ARGUMENT;
    } else {
        /* Save new period value */
        p_channel->ul_period = ul_period;
 
#if (SAM3N || SAM4N || SAM4C || SAM4CP || SAM4CM)
        /* Set CPD bit to change period value */
        p_pwm->PWM_CH_NUM[ch_num].PWM_CMR |= PWM_CMR_CPD;
 
        p_pwm->PWM_CH_NUM[ch_num].PWM_CUPD = ul_period;
#else
        p_pwm->PWM_CH_NUM[ch_num].PWM_CPRDUPD = ul_period;
#endif
    }
 
    return 0;
}

References pwm_channel_t::channel, Pwm::PWM_CH_NUM, PwmCh_num::PWM_CMR, PwmCh_num::PWM_CPRDUPD, PWM_INVALID_ARGUMENT, pwm_channel_t::ul_duty, and pwm_channel_t::ul_period.

pwm_clocks_generate()

uint32_t pwm_clocks_generate ( uint32_t ul_frequency, uint32_t ul_mck )

static

Find a prescaler/divisor couple to generate the desired ul_frequency from ul_mck.

Parameters

ul_frequency	Desired frequency in Hz.
ul_mck	Master clock frequency in Hz.

Return values

Return

the value to be set in the PWM Clock Register (PWM Mode Register for SAM3N/SAM4N/SAM4C/SAM4CP/SAM4CM) or PWM_INVALID_ARGUMENT if the configuration cannot be met.

Definition at line 87 of file pwm.c.

{
    uint32_t ul_divisors[PWM_CLOCK_PRE_MAX] =
            {1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024 };
    uint32_t ul_pre = 0;
    uint32_t ul_div;
 
    /* Find prescaler and divisor values */
    do {
        ul_div = (ul_mck / ul_divisors[ul_pre]) / ul_frequency;
        if (ul_div <= PWM_CLOCK_DIV_MAX) {
            break;
        }
        ul_pre++;
    } while (ul_pre < PWM_CLOCK_PRE_MAX);
 
    /* Return result */
    if (ul_pre < PWM_CLOCK_PRE_MAX) {
        return ul_div | (ul_pre << 8);
    } else {
        return PWM_INVALID_ARGUMENT;
    }
}

References PWM_CLOCK_DIV_MAX, PWM_CLOCK_PRE_MAX, and PWM_INVALID_ARGUMENT.

Referenced by pwm_init().

pwm_cmp_change_setting()

uint32_t pwm_cmp_change_setting	(	Pwm *	p_pwm,
		pwm_cmp_t *	p_cmp )

Change the setting of PWM comparison.

Parameters

p_pwm	Pointer to a PWM instance.
p_cmp	Configurations of PWM comparison tagged by unit.

Return values

0	if changing succeeds, otherwise fails.

Boolean of generating a match pulse

Boolean of generating a match pulse

Boolean of comparison enable

Definition at line 696 of file pwm.c.

{
    uint32_t unit = p_cmp->unit;
 
    p_pwm->PWM_CMP[unit].PWM_CMPVUPD = PWM_CMPV_CV(p_cmp->ul_value) |
            (p_cmp->b_is_decrementing << 24);
 
    p_pwm->PWM_CMP[unit].PWM_CMPMUPD = PWM_CMPM_CTR(p_cmp->ul_trigger) |
            PWM_CMPM_CPR(p_cmp->ul_period) |
            PWM_CMPM_CUPR(p_cmp->ul_update_period);

    if (p_cmp->b_pulse_on_line_0) {
        p_pwm->PWM_ELMR[0] |= (1 << unit);
    } else {
        p_pwm->PWM_ELMR[0] &= ~((uint32_t) (1 << unit));
    }
    if (p_cmp->b_pulse_on_line_1) {
        p_pwm->PWM_ELMR[1] |= (1 << unit);
    } else {
        p_pwm->PWM_ELMR[1] &= ~((uint32_t) (1 << unit));
    }

    if (p_cmp->b_enable) {
        p_pwm->PWM_CMP[unit].PWM_CMPMUPD |= PWM_CMPM_CEN;
    } else {
        p_pwm->PWM_CMP[unit].PWM_CMPMUPD &= ~PWM_CMPM_CEN;
    }
 
    return 0;
}

References pwm_cmp_t::b_enable, pwm_cmp_t::b_is_decrementing, pwm_cmp_t::b_pulse_on_line_0, pwm_cmp_t::b_pulse_on_line_1, Pwm::PWM_CMP, PWM_CMPM_CEN, PWM_CMPM_CPR, PWM_CMPM_CTR, PWM_CMPM_CUPR, PwmCmp::PWM_CMPMUPD, PWM_CMPV_CV, PwmCmp::PWM_CMPVUPD, Pwm::PWM_ELMR, pwm_cmp_t::ul_period, pwm_cmp_t::ul_trigger, pwm_cmp_t::ul_update_period, pwm_cmp_t::ul_value, and pwm_cmp_t::unit.

pwm_cmp_disable_interrupt()

void pwm_cmp_disable_interrupt	(	Pwm *	p_pwm,
		uint32_t	ul_sources,
		pwm_cmp_interrupt_t	type )

Disable the interrupt of comparison.

Parameters

p_pwm	Pointer to a PWM instance.
ul_sources	Bitmask of comparison unit.
type	PWM_CMP_MATCH disables the match interrupt of the unit. PWM_CMP_UPDATE disables the update interrupt of the comparison unit.

Definition at line 787 of file pwm.c.

{
    if (type == PWM_CMP_MATCH) {
        p_pwm->PWM_IDR2 = ((1 << ul_sources) << 8);
    } else if (type == PWM_CMP_UPDATE) {
        p_pwm->PWM_IDR2 = ((1 << ul_sources) << 16);
    } else {
        /* Do Nothing */
    }
}

References PWM_CMP_MATCH, PWM_CMP_UPDATE, and Pwm::PWM_IDR2.

pwm_cmp_enable_interrupt()

void pwm_cmp_enable_interrupt	(	Pwm *	p_pwm,
		uint32_t	ul_sources,
		pwm_cmp_interrupt_t	type )

Enable the interrupt of comparison.

Parameters

p_pwm	Pointer to a PWM instance.
ul_sources	Bitmask of comparison unit.
type	PWM_CMP_MATCH enables the match interrupt of the unit. PWM_CMP_UPDATE enables the update interrupt of the comparison unit.

Definition at line 767 of file pwm.c.

{
    if (type == PWM_CMP_MATCH) {
        p_pwm->PWM_IER2 = ((1 << ul_sources) << 8);
    } else if (type == PWM_CMP_UPDATE) {
        p_pwm->PWM_IER2 = ((1 << ul_sources) << 16);
    } else {
        /* Do Nothing */
    }
}

References PWM_CMP_MATCH, PWM_CMP_UPDATE, and Pwm::PWM_IER2.

pwm_cmp_get_period_counter()

uint32_t pwm_cmp_get_period_counter	(	Pwm *	p_pwm,
		uint32_t	ul_cmp_unit )

Report the value of the comparison period counter.

Parameters

p_pwm	Pointer to a PWM instance.
ul_cmp_unit	PWM comparison unit number.

Returns

Value of the comparison period counter.

Definition at line 739 of file pwm.c.

{
    return (PWM_CMPM_CPRCNT(p_pwm->PWM_CMP[ul_cmp_unit].PWM_CMPM)
            >> PWM_CMPM_CPRCNT_Pos);
}

References Pwm::PWM_CMP, PwmCmp::PWM_CMPM, PWM_CMPM_CPRCNT, and PWM_CMPM_CPRCNT_Pos.

pwm_cmp_get_update_counter()

uint32_t pwm_cmp_get_update_counter	(	Pwm *	p_pwm,
		uint32_t	ul_cmp_unit )

Report the value of the comparison update period counter.

Parameters

p_pwm	Pointer to a PWM instance.
ul_cmp_unit	PWM comparison unit number.

Returns

Value of the comparison update period counter.

Definition at line 753 of file pwm.c.

{
    return (PWM_CMPM_CUPRCNT(p_pwm->PWM_CMP[ul_cmp_unit].PWM_CMPM)
            >> PWM_CMPM_CUPRCNT_Pos);
}

References Pwm::PWM_CMP, PwmCmp::PWM_CMPM, PWM_CMPM_CUPRCNT, and PWM_CMPM_CUPRCNT_Pos.

pwm_cmp_init()

uint32_t pwm_cmp_init	(	Pwm *	p_pwm,
		pwm_cmp_t *	p_cmp )

Initialize PWM comparison unit.

Parameters

p_pwm	Pointer to a PWM instance.
p_cmp	Configurations of PWM comparison tagged by unit.

Return values

0	if initialization succeeds, otherwise fails.

Boolean of generating a match pulse

Boolean of generating a match pulse

Boolean of comparison enable

Definition at line 653 of file pwm.c.

{
    uint32_t unit = p_cmp->unit;
 
    p_pwm->PWM_CMP[unit].PWM_CMPV = PWM_CMPV_CV(p_cmp->ul_value) |
            (p_cmp->b_is_decrementing << 24);
 
    p_pwm->PWM_CMP[unit].PWM_CMPM = PWM_CMPM_CTR(p_cmp->ul_trigger) |
            PWM_CMPM_CPR(p_cmp->ul_period) |
            PWM_CMPM_CUPR(p_cmp->ul_update_period);

    if (p_cmp->b_pulse_on_line_0) {
        p_pwm->PWM_ELMR[0] |= (1 << unit);
    } else {
        p_pwm->PWM_ELMR[0] &= ~((uint32_t) (1 << unit));
    }
    if (p_cmp->b_pulse_on_line_1) {
        p_pwm->PWM_ELMR[1] |= (1 << unit);
    } else {
        p_pwm->PWM_ELMR[1] &= ~((uint32_t) (1 << unit));
    }

    if (p_cmp->b_enable) {
        p_pwm->PWM_CMP[unit].PWM_CMPM |= PWM_CMPM_CEN;
    } else {
        p_pwm->PWM_CMP[unit].PWM_CMPM &= ~PWM_CMPM_CEN;
    }
 
    return 0;
}

References pwm_cmp_t::b_enable, pwm_cmp_t::b_is_decrementing, pwm_cmp_t::b_pulse_on_line_0, pwm_cmp_t::b_pulse_on_line_1, Pwm::PWM_CMP, PwmCmp::PWM_CMPM, PWM_CMPM_CEN, PWM_CMPM_CPR, PWM_CMPM_CTR, PWM_CMPM_CUPR, PwmCmp::PWM_CMPV, PWM_CMPV_CV, Pwm::PWM_ELMR, pwm_cmp_t::ul_period, pwm_cmp_t::ul_trigger, pwm_cmp_t::ul_update_period, pwm_cmp_t::ul_value, and pwm_cmp_t::unit.

pwm_disable_protect()

void pwm_disable_protect	(	Pwm *	p_pwm,
		uint32_t	ul_group )

Disable PWM write protect.

Note

Only a hardware reset of PWM controller (handled by PMC) can disable hardware write protect.

Parameters

p_pwm	Pointer to a PWM instance.
ul_group	Bitmask of PWM register group.

Definition at line 956 of file pwm.c.

{
    p_pwm->PWM_WPCR = PWM_WPCR_WPKEY_PASSWD
             | (ul_group << 2) | PWM_WPCR_WPCMD_DISABLE_SW_PROT;
}

References Pwm::PWM_WPCR, PWM_WPCR_WPCMD_DISABLE_SW_PROT, and PWM_WPCR_WPKEY_PASSWD.

pwm_enable_protect()

void pwm_enable_protect	(	Pwm *	p_pwm,
		uint32_t	ul_group,
		bool	b_sw )

Enable PWM write protect.

Parameters

p_pwm	Pointer to a PWM instance.
ul_group	Bitmask of PWM register group.
b_sw	Boolean of software protect. True for software protect and false for hardware protect.

Definition at line 933 of file pwm.c.

{
    uint32_t wp = 0;
 
    if (b_sw) {
        wp = PWM_WPCR_WPKEY_PASSWD | (ul_group << 2) |
                PWM_WPCR_WPCMD_ENABLE_SW_PROT;
    } else {
        wp = PWM_WPCR_WPKEY_PASSWD | (ul_group << 2) |
                PWM_WPCR_WPCMD_ENABLE_HW_PROT;
    }
 
    p_pwm->PWM_WPCR = wp;
}

References Pwm::PWM_WPCR, PWM_WPCR_WPCMD_ENABLE_HW_PROT, PWM_WPCR_WPCMD_ENABLE_SW_PROT, and PWM_WPCR_WPKEY_PASSWD.

pwm_fault_clear_status()

void pwm_fault_clear_status	(	Pwm *	p_pwm,
		pwm_fault_id_t	id )

Clear a fault input.

Parameters

p_pwm	Pointer to a PWM instance.
id	Faulty ID.

Definition at line 640 of file pwm.c.

{
    p_pwm->PWM_FCR = id;
}

References Pwm::PWM_FCR.

pwm_fault_get_input_level()

pwm_level_t pwm_fault_get_input_level	(	Pwm *	p_pwm,
		pwm_fault_id_t	id )

Get the level of a fault input.

Parameters

p_pwm	Pointer to a PWM instance.
id	Faulty ID.

Returns

Level of the fault input.

Definition at line 626 of file pwm.c.

{
    uint32_t fault_status_reg = p_pwm->PWM_FSR;
    fault_status_reg >>= id;
 
    return ((fault_status_reg & 1) ? PWM_HIGH : PWM_LOW);
}

References Pwm::PWM_FSR, PWM_HIGH, and PWM_LOW.

pwm_fault_get_status()

uint32_t pwm_fault_get_status

(

Pwm *

p_pwm

)

Get fault status.

Parameters

p_pwm

Pointer to a PWM instance.

Returns

Bitmask of IDs of all active faulty.

Definition at line 613 of file pwm.c.

{
    return ((p_pwm->PWM_FSR >> 8) & 0xFF);
}

References Pwm::PWM_FSR.

pwm_fault_init()

uint32_t pwm_fault_init	(	Pwm *	p_pwm,
		pwm_fault_t *	p_fault )

Initialize the behavior of a fault input.

Parameters

p_pwm	Pointer to a PWM instance.
p_fault	Configurations of a fault input.

Return values

0	if configuration succeeds, otherwise fails.

Polarity of fault input

Boolean of clearing fault flag

Boolean of fault filtering

Definition at line 577 of file pwm.c.

{
    uint32_t fault_id = p_fault->fault_id;
    uint32_t fault_reg = p_pwm->PWM_FMR;

    if (p_fault->polarity == PWM_HIGH) {
        fault_reg |= fault_id;
    } else {
        fault_reg &= ~fault_id;
    }
    if (p_fault->b_clear) {
        fault_reg |= (fault_id << 8);
    } else {
        fault_reg &= ~(fault_id << 8);
    }
    if (p_fault->b_filtered) {
        fault_reg |= (fault_id << 16);
    } else {
        fault_reg &= ~(fault_id << 16);
    }
 
    p_pwm->PWM_FMR = fault_reg;
 
    return 0;
}

References pwm_fault_t::b_clear, pwm_fault_t::b_filtered, pwm_fault_t::fault_id, pwm_fault_t::polarity, Pwm::PWM_FMR, and PWM_HIGH.

pwm_get_interrupt_mask()

uint32_t pwm_get_interrupt_mask

(

Pwm *

p_pwm

)

Get interrupt mask of PDC transfer, synchronous channels and comparison.

Parameters

p_pwm

Pointer to a PWM instance.

Returns

Interrupt mask of PDC transfer, synchronous channels and comparison.

Definition at line 1008 of file pwm.c.

{
    return p_pwm->PWM_IMR2;
}

References Pwm::PWM_IMR2.

pwm_get_interrupt_status()

uint32_t pwm_get_interrupt_status

(

Pwm *

p_pwm

)

Get interrupt status of PDC transfer, synchronous channels and comparison.

Parameters

p_pwm

Pointer to a PWM instance.

Returns

Interrupt status of PDC transfer, synchronous channels and comparison.

Definition at line 996 of file pwm.c.

{
    return p_pwm->PWM_ISR2;
}

References Pwm::PWM_ISR2.

pwm_get_protect_status()

bool pwm_get_protect_status	(	Pwm *	p_pwm,
		pwm_protect_t *	p_protect )

Get PWM write protect status.

Parameters

p_pwm	Pointer to a PWM instance.
p_protect	Pointer to a structure stored PWM protect status.

Return values

0	Protection disabled.
1	Protection enabled.

Bitmask of PWM register group for write protect software status

Definition at line 971 of file pwm.c.

{
    uint32_t wpsr = p_pwm->PWM_WPSR;
 
    p_protect->ul_hw_status = (wpsr >> 8) & 0x3F;
    p_protect->ul_sw_status = (wpsr & 0x3F);
 
    if ((PWM_WPSR_WPVS & wpsr) == PWM_WPSR_WPVS) {
        p_protect->ul_offset =
                (wpsr & PWM_WPSR_WPVSRC_Msk) >>
                PWM_WPSR_WPVSRC_Pos;
        return true;
    } else {
        return false;
    }
}

References Pwm::PWM_WPSR, PWM_WPSR_WPVS, PWM_WPSR_WPVSRC_Msk, PWM_WPSR_WPVSRC_Pos, pwm_protect_t::ul_hw_status, pwm_protect_t::ul_offset, and pwm_protect_t::ul_sw_status.

pwm_init()

uint32_t pwm_init	(	Pwm *	p_pwm,
		pwm_clock_t *	clock_config )

Initialize the PWM source clock (clock A and clock B).

Parameters

p_pwm	Pointer to a PWM instance.
clock_config	PWM clock configuration.

Return values

0	if initialization succeeds, otherwise fails.

Definition at line 119 of file pwm.c.

{
    uint32_t clock = 0;
    uint32_t result;
 
    /* Clock A */
    if (clock_config->ul_clka != 0) {
        result = pwm_clocks_generate(clock_config->ul_clka, clock_config->ul_mck);
        if (result == PWM_INVALID_ARGUMENT) {
            return result;
        }
 
        clock = result;
    }
 
    /* Clock B */
    if (clock_config->ul_clkb != 0) {
        result = pwm_clocks_generate(clock_config->ul_clkb, clock_config->ul_mck);
 
        if (result == PWM_INVALID_ARGUMENT) {
            return result;
        }
 
        clock |= (result << 16);
    }
#if (SAM3N || SAM4N || SAM4C || SAM4CP || SAM4CM)
    p_pwm->PWM_MR = clock;
#else
    p_pwm->PWM_CLK = clock;
#endif
    return 0;
}

References Pwm::PWM_CLK, pwm_clocks_generate(), PWM_INVALID_ARGUMENT, pwm_clock_t::ul_clka, pwm_clock_t::ul_clkb, and pwm_clock_t::ul_mck.

pwm_pdc_disable_interrupt()

void pwm_pdc_disable_interrupt	(	Pwm *	p_pwm,
		uint32_t	ul_sources )

Disable the interrupt of PDC transfer.

Parameters

p_pwm	Pointer to a PWM instance.
ul_sources	Bitmask of PWM PDC transfer interrupt sources.

Definition at line 839 of file pwm.c.

{
    p_pwm->PWM_IDR2 = ul_sources;
}

References Pwm::PWM_IDR2.

pwm_pdc_enable_interrupt()

void pwm_pdc_enable_interrupt	(	Pwm *	p_pwm,
		uint32_t	ul_sources )

Enable the interrupt of PDC transfer.

Parameters

p_pwm	Pointer to a PWM instance.
ul_sources	Bitmask of PWM PDC transfer interrupt sources.

Definition at line 828 of file pwm.c.

{
    p_pwm->PWM_IER2 = ul_sources;
}

References Pwm::PWM_IER2.

pwm_pdc_set_request_mode()

void pwm_pdc_set_request_mode	(	Pwm *	p_pwm,
		pwm_pdc_request_mode_t	request_mode,
		uint32_t	ul_cmp_unit )

Set PDC transfer request mode.

Note

If configure Synchronous channels update mode as 'PWM_SYNC_UPDATE_MODE_0' or 'PWM_SYNC_UPDATE_MODE_1' via pwm_sync_init(), ul_pdc_request will be ignored and PDC transfer request will never occur.

Parameters

p_pwm	Pointer to a PWM instance.
request_mode	PDC transfer request mode.
ul_cmp_unit	PWM comparison unit number for PDC transfer request.

Definition at line 809 of file pwm.c.

{
    uint32_t sync_mode = p_pwm->PWM_SCM;
 
    sync_mode &= ~(PWM_SCM_PTRCS_Msk | PWM_SCM_PTRM);
    sync_mode |= (PWM_SCM_PTRCS(ul_cmp_unit) | request_mode);
 
    p_pwm->PWM_SCM = sync_mode;
}

References Pwm::PWM_SCM, PWM_SCM_PTRCS, PWM_SCM_PTRCS_Msk, and PWM_SCM_PTRM.

pwm_stepper_motor_init()

void pwm_stepper_motor_init	(	Pwm *	p_pwm,
		pwm_stepper_motor_pair_t	pair,
		bool	b_enable_gray,
		bool	b_down )

Initialize PWM stepper motor mode.

Parameters

p_pwm	Pointer to a PWM instance.
pair	PWM channels used by stepper motor.
b_enable_gray	Set true to enable gray count generation. Set false to disable it.
b_down	Set true to use down counter. Set false to use up counter.

Definition at line 1023 of file pwm.c.

{
    uint32_t motor = p_pwm->PWM_SMMR;
 
    motor &= ~((PWM_SMMR_GCEN0 | PWM_SMMR_DOWN0) << pair);
    motor |= ((b_enable_gray | (b_down << 16)) << pair);
 
    p_pwm->PWM_SMMR = motor;
}

References Pwm::PWM_SMMR, PWM_SMMR_DOWN0, and PWM_SMMR_GCEN0.

pwm_sync_change_period()

void pwm_sync_change_period	(	Pwm *	p_pwm,
		uint32_t	ul_update_period )

Change the wanted time between each update of the synchronous channels.

Parameters

p_pwm	Pointer to a PWM instance.
ul_update_period	Time between each update of the synchronous channels.

Definition at line 887 of file pwm.c.

{
    p_pwm->PWM_SCUPUPD = PWM_SCUPUPD_UPRUPD(ul_update_period);
}

References Pwm::PWM_SCUPUPD, and PWM_SCUPUPD_UPRUPD.

pwm_sync_disable_interrupt()

void pwm_sync_disable_interrupt	(	Pwm *	p_pwm,
		uint32_t	ul_sources )

Disable the interrupt of synchronous channels.

Parameters

p_pwm	Pointer to a PWM instance.
ul_sources	Bitmask of PWM synchronous channels interrupt sources.

Definition at line 921 of file pwm.c.

{
    p_pwm->PWM_IDR2 = ul_sources;
}

References Pwm::PWM_IDR2.

pwm_sync_enable_interrupt()

void pwm_sync_enable_interrupt	(	Pwm *	p_pwm,
		uint32_t	ul_sources )

Enable the interrupt of synchronous channel.

Parameters

p_pwm	Pointer to a PWM instance.
ul_sources	Bitmask of PWM synchronous channels interrupt sources.

Definition at line 910 of file pwm.c.

{
    p_pwm->PWM_IER2 = ul_sources;
}

References Pwm::PWM_IER2.

pwm_sync_get_period_counter()

uint32_t pwm_sync_get_period_counter

(

Pwm *

p_pwm

)

Get the value of the synchronization update period counter.

Parameters

p_pwm

Pointer to a PWM instance.

Returns

Value of the synchronization update Period Counter.

Definition at line 899 of file pwm.c.

{
    return PWM_SCUP_UPRCNT(p_pwm->PWM_SCUP);
}

References Pwm::PWM_SCUP, and PWM_SCUP_UPRCNT.

pwm_sync_init()

uint32_t pwm_sync_init	(	Pwm *	p_pwm,
		pwm_sync_update_mode_t	mode,
		uint32_t	ul_update_period )

Initialize synchronous channels update mode and period.

Parameters

p_pwm	Pointer to a PWM instance.
mode	Synchronous channels update mode.
ul_update_period	Time between each update of the synchronous channels.

Return values

0	if initialization succeeds, otherwise fails.

Definition at line 854 of file pwm.c.

{
    uint32_t sync_mode = p_pwm->PWM_SCM;
 
    sync_mode &= ~PWM_SCM_UPDM_Msk;
    sync_mode |= mode;
 
    p_pwm->PWM_SCM = sync_mode;
 
    p_pwm->PWM_SCUP = PWM_SCUP_UPR(ul_update_period);
 
    return 0;
}

References Pwm::PWM_SCM, PWM_SCM_UPDM_Msk, Pwm::PWM_SCUP, and PWM_SCUP_UPR.

pwm_sync_unlock_update()

void pwm_sync_unlock_update

(

Pwm *

p_pwm

)

Unlock the update of synchronous channels.

Note

After unlock, synchronous channels will be updated at the next PWM period.

Parameters

p_pwm

Pointer to a PWM instance.

Definition at line 876 of file pwm.c.

{
    p_pwm->PWM_SCUC = PWM_SCUC_UPDULOCK;
}

References Pwm::PWM_SCUC, and PWM_SCUC_UPDULOCK.