General PWM Timer (r_gpt)

Functions
fsp_err_t	R_GPT_Open (timer_ctrl_t *const p_ctrl, timer_cfg_t const *const p_cfg)
fsp_err_t	R_GPT_Stop (timer_ctrl_t *const p_ctrl)
fsp_err_t	R_GPT_Start (timer_ctrl_t *const p_ctrl)
fsp_err_t	R_GPT_Reset (timer_ctrl_t *const p_ctrl)
fsp_err_t	R_GPT_Enable (timer_ctrl_t *const p_ctrl)
fsp_err_t	R_GPT_Disable (timer_ctrl_t *const p_ctrl)
fsp_err_t	R_GPT_PeriodSet (timer_ctrl_t *const p_ctrl, uint32_t const period_counts)
fsp_err_t	R_GPT_DutyCycleSet (timer_ctrl_t *const p_ctrl, uint32_t const duty_cycle_counts, uint32_t const pin)
fsp_err_t	R_GPT_InfoGet (timer_ctrl_t *const p_ctrl, timer_info_t *const p_info)
fsp_err_t	R_GPT_StatusGet (timer_ctrl_t *const p_ctrl, timer_status_t *const p_status)
fsp_err_t	R_GPT_CounterSet (timer_ctrl_t *const p_ctrl, uint32_t counter)
fsp_err_t	R_GPT_OutputEnable (timer_ctrl_t *const p_ctrl, gpt_io_pin_t pin)
fsp_err_t	R_GPT_OutputDisable (timer_ctrl_t *const p_ctrl, gpt_io_pin_t pin)
fsp_err_t	R_GPT_AdcTriggerSet (timer_ctrl_t *const p_ctrl, gpt_adc_compare_match_t which_compare_match, uint32_t compare_match_value)
fsp_err_t	R_GPT_CallbackSet (timer_ctrl_t *const p_ctrl, void(*p_callback)(timer_callback_args_t *), void const *const p_context, timer_callback_args_t *const p_callback_memory)
fsp_err_t	R_GPT_Close (timer_ctrl_t *const p_ctrl)

Detailed Description

Driver for the GPT peripherals on RZ microprocessor. This module implements the Timer Interface.

Overview

The GPT module can be used to count events, measure external input signals, generate a periodic interrupt, or output a periodic or PWM signal to a GTIOC pin.

This module supports the GPT peripherals are 32-bit timers. The 32-bit timers are all treated the same in this module from the API perspective.

Features

The GPT module has the following features:

• Supports periodic mode, one-shot mode, and PWM mode.
• Supports phase counting mode.
• Supports count source of PCLK, GTETRG pins, GTIOC pins, or ELC events.
• Supports debounce filter on GTIOC pins.
• Signal can be output to a pin.
• Configurable period (counts per timer cycle).
• Configurable duty cycle in PWM mode.
• Supports runtime reconfiguration of period.
• Supports runtime reconfiguration of duty cycle in PWM mode.
• APIs are provided to start, stop, and reset the counter.
• APIs are provided to get the current period, source clock frequency, and count direction.
• APIs are provided to get the current timer status and counter value.
• Supports start, stop, clear, count up, count down, and capture by external sources from GTETRG pins, GTIOC pins, or ELC events.
• Supports symmetric and asymmetric PWM waveform generation.
• Supports automatic addition of dead time.
• Supports generating ELC events to start an ADC scan at a compare match value (see Event Link Controller (r_elc)) and updating the compare match value.
• Supports linking with a POEG channel to automatically disable GPT output when an error condition is detected.
• Supports setting the counter value while the timer is stopped.
• Supports enabling and disabling output pins.
• Supports skipping up to 18ch overflow/underflow (crest/trough) interrupts at a time

Selecting a Timer

RZ microprocessor have timer peripherals: the General PWM Timer (GPT). When selecting between them, consider these factors:

	GPT
Low Power Modes	The GPT can operate in sleep mode.
Available Channels	The number of GPT channels is device specific. All currently supported MCUs have at least 18 GPT channels.
Timer Resolution	All MCUs have at least one 32-bit GPT timer.
Clock Source	-Bus clock: PCLKH in LLPP, PCLKM in NONSAFETY, and PCLKM in SAFETY
	-Core clock: PCLKGPT in LLPP, PCLKM in NONSAFETY, and PCLKM in SAFETY

Configuration

Build Time Configurations for r_gpt

The following build time configurations are defined in fsp_cfg/r_gpt_cfg.h:

Configuration	Options	Default	Description
Parameter Checking	Default (BSP) Enabled Disabled	Default (BSP)	If selected code for parameter checking is included in the build.
Pin Output Support	Disabled Enabled Enabled with Extra Features	Disabled	If selected code for outputting a waveform to a pin is included in the build.
Write Protect Enable	Enabled Disabled	Disabled	If selected write protection is applied to all GPT channels.
Multiplex Interrupt	Enabled Disabled	Disabled	Enable multiplex interrupt for a single driver.

Configurations for Timers > Timer, General PWM (r_gpt)

This module can be added to the Stacks tab via New Stack > Timers > Timer, General PWM (r_gpt).

Configuration	Options	Default	Description
General > Name	Name must be a valid C symbol	g_timer0	Module name.
General > Unit	Unit number must exist on this MCU	0	Specify the hardware unit.
General > Channel	Channel number must exist on this MCU	0	Specify the hardware channel.
General > Mode	Periodic One-Shot PWM Triangle-Wave Symmetric PWM Triangle-Wave Asymmetric PWM	Periodic	Mode selection. Periodic: Generates periodic interrupts or square waves. One-shot: Generate a single interrupt or a pulse wave. Note: One-shot mode is implemented in software. ISRs must be enabled for one-shot even if callback is unused. PWM: Generates basic PWM waveforms. Triangle-Wave Symmetric PWM: Generates symmetric PWM waveforms with duty cycle determined by compare match set during a crest interrupt and updated at the next trough. Triangle-Wave Asymmetric PWM: Generates asymmetric PWM waveforms with duty cycle determined by compare match set during a crest/trough interrupt and updated at the next trough/crest.
General > Period	Value must be a non-negative integer less than or equal to 0x40000000000	0x100000000	Specify the timer period in units selected below. Setting the period to 0x100000000 raw counts results in the maximum period. Set the period to 0x100000000 raw counts for a free running timer or an input capture configuration. The period can be set up to 0x40000000000, which will use a divider of 1024 with the maximum period.
General > Period Unit	Raw Counts Nanoseconds Microseconds Milliseconds Seconds Hertz Kilohertz	Raw Counts	Unit of the period specified above
Output > Duty Cycle Percent (only applicable in PWM mode)	Value must be between 0 and 100	50	Specify the timer duty cycle percent. Only used in PWM mode.
Output > GTIOCA Output Enabled	True False	False	Enable the output of GTIOCA on a pin.
Output > GTIOCA Stop Level	Pin Level Low Pin Level High	Pin Level Low	Select the behavior of the output pin when the timer is stopped.
Output > GTIOCB Output Enabled	True False	False	Enable the output of GTIOCB on a pin.
Output > GTIOCB Stop Level	Pin Level Low Pin Level High	Pin Level Low	Select the behavior of the output pin when the timer is stopped.
Input > Count Up Source	MCU Specific Options		Select external source that will increment the counter. If any count up source is selected, the timer will count the external sources only. It will not count PCLKD cycles.
Input > Count Down Source	MCU Specific Options		Select external source that will decrement the counter. If any count down source is selected, the timer will count the external sources only. It will not count PCLKD cycles.
Input > Phase Count Setting Automatically Enable	Enabled Disabled	Disabled	Enable Phase Count Setting Automatically.
Input > Counting Mode	Mode1 Mode2(00) Mode2(01) Mode2(1x) Mode3(00) Mode3(01) Mode3(1x) Mode4 Mode5(0x) Mode5(1x)	Mode1	Phase count mode is count up or down operation mode by detecting the phase difference between the inputs on the GTIOCnA and GTIOCnB pins.
Input > Start Source	MCU Specific Options		Select external source that will start the timer. For pulse width measurement, set the Start Source and the Clear Source to the trigger edge (the edge to start the measurement), and set the Stop Source and Capture Source (either A or B) to the opposite edge (the edge to stop the measurement). For pulse period measurement, set the Start Source, the Clear Source, and the Capture Source (either A or B) to the trigger edge (the edge to start the measurement).
Input > Stop Source	MCU Specific Options		Select external source that will stop the timer.
Input > Clear Source	MCU Specific Options		Select external source that will clear the timer.
Input > Capture A Source	MCU Specific Options		Select external source that will trigger a capture A event.
Input > Capture B Source	MCU Specific Options		Select external source that will trigger a capture B event.
Input > Noise Filter A Sampling Clock Select	No Filter Filter PCLKD / 1 Filter PCLKD / 4 Filter PCLKD / 16 Filter PCLKD / 64	No Filter	Select the input filter for GTIOCA.
Input > Noise Filter B Sampling Clock Select	No Filter Filter PCLKD / 1 Filter PCLKD / 4 Filter PCLKD / 16 Filter PCLKD / 64	No Filter	Select the input filter for GTIOCB.
Interrupts > Callback	Name must be a valid C symbol	NULL	A user callback function can be specified here. If this callback function is provided, it will be called from the interrupt service routine (ISR) each time the timer period elapses
Interrupts > Overflow/Crest Interrupt Priority	MCU Specific Options		Select the overflow interrupt priority. This is the crest interrupt for triangle-wave PWM.
Interrupts > Capture A Interrupt Priority	MCU Specific Options		Select the interrupt priority for capture A.
Interrupts > Capture B Interrupt Priority	MCU Specific Options		Select the interrupt priority for capture B.
Interrupts > Trough Interrupt Priority	MCU Specific Options		Select the interrupt priority for the trough interrupt (triangle-wave PWM only).
Interrupts > Dead Time Error Interrupt Priority	MCU Specific Options		Select the interrupt priority for dead time error.
Interrupts (GPT_SEL) > Callback	Name must be a valid C symbol	NULL	A user callback function can be specified here. If this callback function is provided, it will be called from the interrupt service routine (ISR) each time the timer period elapses
Interrupts (GPT_SEL) > Overflow/Crest Interrupt Source	MCU Specific Options		Select the overflow interrupt source. This is the crest interrupt for triangle-wave PWM.
Interrupts (GPT_SEL) > Capture A Interrupt Source	MCU Specific Options		Select the interrupt source for capture A.
Interrupts (GPT_SEL) > Capture B Interrupt Source	MCU Specific Options		Select the interrupt source for capture B.
Interrupts (GPT_SEL) > Trough Interrupt Source	MCU Specific Options		Select the interrupt source for the trough interrupt (triangle-wave PWM only).
Interrupts (GPT_SEL) > Dead Time Error Interrupt Source	MCU Specific Options		Select the interrupt source for dead time error.
Interrupts (GPT_SEL) > INT0 Interrupt Priority	MCU Specific Options		Select the interrupt priority for int0.
Interrupts (GPT_SEL) > INT1 Interrupt Priority	MCU Specific Options		Select the interrupt priority for int1.
Interrupts (GPT_SEL) > INT2 Interrupt Priority	MCU Specific Options		Select the interrupt priority for int2.
Interrupts (GPT_SEL) > INT3 Interrupt Priority	MCU Specific Options		Select the interrupt priority for int3.
Interrupts (GPT_SEL) > INT4 Interrupt Priority	MCU Specific Options		Select the interrupt priority for int4.
Extra Features > Output Disable > POEG Link	POEG Channel 0 POEG Channel 1 POEG Channel 2 POEG Channel 3	POEG Channel 0	Select which POEG to link this GPT channel to.
Extra Features > Output Disable > Output Disable POEG Trigger	Dead Time Error GTIOCA and GTIOCB High Level GTIOCA and GTIOCB Low Level		Select which errors send an output disable trigger to POEG.
Extra Features > Output Disable > GTIOCA Disable Setting	Disable Prohibited Set Hi Z Level Low Level High	Disable Prohibited	Select the disable setting for GTIOCA.
Extra Features > Output Disable > GTIOCB Disable Setting	Disable Prohibited Set Hi Z Level Low Level High	Disable Prohibited	Select the disable setting for GTIOCB.
Extra Features > ADC Trigger > Start Event Trigger	Trigger Event A/D Converter Start Request A During Up Counting Trigger Event A/D Converter Start Request A During Down Counting Trigger Event A/D Converter Start Request B During Up Counting Trigger Event A/D Converter Start Request B During Down Counting		Select which A/D converter start request interrupts to generate and at which point in the cycle to generate them.
Extra Features > ADC Trigger > ADC A Compare Match (Raw Counts)	Must be a valid non-negative integer with a maximum configurable value of 4294967295 (0xffffffff).	0	Select the compare match value that generates a GPTn AD TRIG A event.
Extra Features > ADC Trigger > ADC B Compare Match (Raw Counts)	Must be a valid non-negative integer with a maximum configurable value of 4294967295 (0xffffffff).	0	Select the compare match value that generates a GPTn AD TRIG B event.
Extra Features > Dead Time > Dead Time Count Up (Raw Counts)	Must be a valid non-negative integer with a maximum configurable value of 4294967295 (0xffffffff).	0	Select the dead time to apply during up counting.
Extra Features > Dead Time > Dead Time Count Down (Raw Counts)	Must be a valid non-negative integer with a maximum configurable value of 4294967295 (0xffffffff).	0	Select the dead time to apply during down counting.
Extra Features > Interrupt Skipping > Interrupt to Count	None Overflow and Underflow (sawtooth) Crest (triangle) Trough (triangle) Crest and Trough (triangle)	None	Select the count source for interrupt skipping. The interrupt skip counter increments after each source event. All crest/overflow and trough/underflow interrupts are skipped when the interrupt skip counter is non-zero.
Extra Features > Interrupt Skipping > Interrupt Skip Count	0 1 2 3 4 5 6 7	0	Select the number of interrupts to skip.
Extra Features > Interrupt Skipping > Skip ADC Events	None ADC A Compare Match ADC B Compare Match ADC A and B Compare Match	None	Select ADC events to suppress when the interrupt skip count is not zero.
Extra Features > Extended Interrupt Skipping 1 > Interrupt to Count	None Crest (triangle) Trough (triangle) Crest and Trough (triangle)	None	Interrupt source to count for interrupt skipping(GTEITC.EIVTC1)
Extra Features > Extended Interrupt Skipping 1 > Interrupt Skip Count	Refer to the RZT Configuration tool for available options.	0	Number of interrupts to skip between events(GTEITC.EIVTT1)
Extra Features > Extended Interrupt Skipping 2 > Interrupt to Count	None Crest (triangle) Trough (triangle) Crest and Trough (triangle)	None	Interrupt source to count for interrupt skipping(GTEITC.EIVTC2)
Extra Features > Extended Interrupt Skipping 2 > Interrupt Skip Count	Refer to the RZT Configuration tool for available options.	0	Number of interrupts to skip between events(GTEITC.EIVTT2)
Extra Features > Input Capture Interrupt Extended Skipping Function > Overflow Interrupt	None Interrupts are skipped when skip counter 1 is other than 0 Interrupts are skipped when skip counter 2 is other than 0 Interrupts are skipped when skip counter 1 or 2 is other than 0 Skip counter 1 skips interrupts when the skip setting value is not set Skip counter 2 skips interrupts when the skip setting value is not set Skip counter 1 or 2 skips interrupts when the skip setting value is not set	None	Extended Skipping Function Select(GTEITLI1.EITLV)
Extra Features > Input Capture Interrupt Extended Skipping Function > Underflow Interrupt	None Interrupts are skipped when skip counter 1 is other than 0 Interrupts are skipped when skip counter 2 is other than 0 Interrupts are skipped when skip counter 1 or 2 is other than 0 Skip counter 1 skips interrupts when the skip setting value is not set Skip counter 2 skips interrupts when the skip setting value is not set Skip counter 1 or 2 skips interrupts when the skip setting value is not set	None	Extended Skipping Function Select(GTEITLI1.EITLU)
Extra Features > Input Capture Interrupt Extended Skipping Function > GTADTRA A/D Converter Start Request	None Interrupts are skipped when skip counter 1 is other than 0 Interrupts are skipped when skip counter 2 is other than 0 Interrupts are skipped when skip counter 1 or 2 is other than 0 Skip counter 1 skips interrupts when the skip setting value is not set Skip counter 2 skips interrupts when the skip setting value is not set Skip counter 1 or 2 skips interrupts when the skip setting value is not set	None	Extended Skipping Function Select(GTEITLI2.EADTAL)
Extra Features > Input Capture Interrupt Extended Skipping Function > GTADTRB A/D Converter Start Request	None Interrupts are skipped when skip counter 1 is other than 0 Interrupts are skipped when skip counter 2 is other than 0 Interrupts are skipped when skip counter 1 or 2 is other than 0 Skip counter 1 skips interrupts when the skip setting value is not set Skip counter 2 skips interrupts when the skip setting value is not set Skip counter 1 or 2 skips interrupts when the skip setting value is not set	None	Extended Skipping Function Select(GTEITLI2.EADTBL)
Extra Features > Extra Features	Enabled Disabled	Disabled	Select whether to enable extra features on this channel.
Extra Features > Input Capture at Count Stop	Enabled Disabled	Enabled	Input Capture Operation Select at Count Stop.
Extra Features > Input Capture Signal	Refer to the RZT Configuration tool for available options.	GTIOC00_4A / GTIOC00_4B	Input Capture Signal Select.
ELC > LLPP GPT event A > Trigger Source	MCU Specific Options		ELC source that will trigger LLPP GPT event A.
ELC > LLPP GPT event B > Trigger Source	MCU Specific Options		ELC source that will trigger LLPP GPT event B.
ELC > LLPP GPT event C > Trigger Source	MCU Specific Options		ELC source that will trigger LLPP GPT event C.
ELC > LLPP GPT event D > Trigger Source	MCU Specific Options		ELC source that will trigger LLPP GPT event D.
ELC > LLPP GPT event E > Trigger Source	MCU Specific Options		ELC source that will trigger LLPP GPT event E.
ELC > LLPP GPT event F > Trigger Source	MCU Specific Options		ELC source that will trigger LLPP GPT event F.
ELC > LLPP GPT event G > Trigger Source	MCU Specific Options		ELC source that will trigger LLPP GPT event G.
ELC > LLPP GPT event H > Trigger Source	MCU Specific Options		ELC source that will trigger LLPP GPT event H.
ELC > NONSAFTY GPT event A > Trigger Source	MCU Specific Options		ELC source that will trigger NONSAFTY GPT event A.
ELC > NONSAFTY GPT event B > Trigger Source	MCU Specific Options		ELC source that will trigger NONSAFTY GPT event B.
ELC > NONSAFTY GPT event C > Trigger Source	MCU Specific Options		ELC source that will trigger NONSAFTY GPT event C.
ELC > NONSAFTY GPT event D > Trigger Source	MCU Specific Options		ELC source that will trigger NONSAFTY GPT event D.
ELC > NONSAFTY GPT event E > Trigger Source	MCU Specific Options		ELC source that will trigger NONSAFTY GPT event E.
ELC > NONSAFTY GPT event F > Trigger Source	MCU Specific Options		ELC source that will trigger NONSAFTY GPT event F.
ELC > NONSAFTY GPT event G > Trigger Source	MCU Specific Options		ELC source that will trigger NONSAFTY GPT event G.
ELC > NONSAFTY GPT event H > Trigger Source	MCU Specific Options		ELC source that will trigger NONSAFTY GPT event H.

Clock Configuration

The GPT clock is based on the PCLKD frequency. You can set the PCLKD frequency using the Clocks tab of the RZ microprocessor Configuration editor or by using the CGC Interface at run-time.

Pin Configuration

This module can use GTETRGA, GTETRGB, GTETRGC, GTETRGD, GTIOCA and GTIOCB pins as count sources.

This module can use GTIOCA and GTIOCB pins as output pins for periodic or PWM signals.

This module can use GTIOCA and GTIOCB as input pins to measure input signals.

Usage Notes

Maximum Period for GPT

The RZ microprocessor Configuration editor will automatically calculate the period count value and source clock divider based on the selected period time, units and clock speed.

When the selected period unit is "Raw counts", the maximum period setting is 0x40000000000 on a 32-bit timer. This will configure the timer with the maximum period and a count clock divisor of 1024.

Note

When manually changing the timer period counts the maximum value for a 32-bit GPT is 0x100000000. This number overflows the 32-bit value for timer_cfg_t::period_counts. To configure the timer for the maximum period, set timer_cfg_t::period_counts to 0.

Updating Period and Duty Cycle

The period and duty cycle are updated after the next counter overflow after calling R_GPT_PeriodSet() or R_GPT_DutyCycleSet(). To force them to update before the next counter overflow, call R_GPT_Reset() while the counter is running.

One-Shot Mode

The GPT timer does not support one-shot mode natively. One-shot mode is achieved by stopping the timer in the interrupt service routine before the callback is called. If the interrupt is not serviced before the timer period expires again, the timer generates more than one event. The callback is only called once in this case.

One-Shot Mode Output

The output waveform in one-shot mode is one PCLK cycle less than the configured period. The configured period must be at least 2 counts to generate an output pulse.

Examples of one-shot signals that can be generated by this module are shown below:

GPT One-Shot Output

Periodic Output

The GTIOC pin toggles twice each time the timer expires in periodic mode. This is achieved by defining a PWM wave at a 50 percent duty cycle so that the period of the resulting square wave (from rising edge to rising edge) matches the period of the GPT timer. Since the periodic output is actually a PWM output, the time at the stop level is one cycle shorter than the time opposite the stop level for odd period values.

Examples of periodic signals that can be generated by this module are shown below:

GPT Periodic Output

PWM Output

The PWM output signal is high at the beginning of the cycle and low at the end of the cycle.

Examples of PWM signals that can be generated by this module are shown below:

GPT PWM Output

Triangle-Wave PWM Output

Examples of PWM signals that can be generated by this module are shown below. The duty_cycle_counts can be modified using R_GPT_DutyCycleSet() in the crest interrupt and updated at the following trough for symmetric PWM or modified in both the crest/trough interrupts and updated at the following trough/crest for asymmetric PWM.

GPT Triangle-Wave PWM Output

Phase Counting Mode

Phase count mode is count up or down operation mode by detecting the phase difference between the inputs on the GTIOCnA and GTIOCnB pins. For this operation, configure “Count Up Source” and “Count Down Source” appropriately. Example of setting for phase counting mode 1 are shown below.

• Case 1: Phase Count Setting Automatically Enable is Disabled.

Configuration	Options
Input > Phase Count Setting Automatically Enable	- Disabled
Input > Count Up Source	- GTIOCA Rising Edge While GTIOCB Low - GTIOCA Falling Edge While GTIOCB High - GTIOCB Rising Edge While GTIOCA High - GTIOCB Falling Edge While GTIOCA Low
Count > Count Down Source	- GTIOCA Rising Edge While GTIOCB High - GTIOCA Falling Edge While GTIOCB Low - GTIOCB Rising Edge While GTIOCA Low - GTIOCB Falling Edge While GTIOCA High

• Case 2: Phase Count Setting Automatically Enable is Enabled.

Configuration	Options
Input > Phase Count Setting Automatically Enable	- Enabled
Input > Counting Mode	- Mode1

Event Counting

Event counting can be done by selecting up or down counting sources from GTETRG pins, ELC events, or GTIOC pins. In event counting mode, the GPT counter is not affected by PCLK.

Note

In event counting mode, the application must call R_GPT_Start() to enable event counting. The counter will not change after calling R_GPT_Start() until an event occurs.

Pulse Measurement

If the capture edge occurs before the start edge in pulse measurement, the first capture is invalid (0).

Controlling GPT with GTETRG Edges

The GPT timer can be configured to stop, start, clear, count up, or count down when a GTETRG rising or falling edge occurs.

Note

The GTETRG pins are shared by all GPT channels.

GTETRG pins require POEG to be on (example code for this is provided in GPT Free Running Counter Example). If input filtering is required on the GTETRG pins, that must also be handled outside this module.

Controlling GPT with ELC Events

The GPT timer can be configured to stop, start, clear, count up, or count down when an ELC event occurs.

Note

The configurable ELC GPT sources are shared by all GPT channels.

The event links for the ELC must be configured outside this module.

Triggering ELC Events with GPT

The GPT timer can trigger the start of other peripherals. The Event Link Controller (r_elc) guide provides a list of all available peripherals.

Enabling External Sources for Start, Stop, Clear, or Capture

R_GPT_Enable() must be called when external sources are used for start, stop, clear, or capture.

Interrupt Skipping

When an interrupt skipping source is selected a hardware counter will increment each time the selected event occurs. Each interrupt past the first (up to the specified skip count) will be suppressed. If ADC events are selected for skipping they will also be suppressed except during the timer period leading to the selected interrupt skipping event (see below diagram).

Crest interrupt skipping in triangle-wave PWM modes (skip count 2)

Examples

GPT Basic Example

This is a basic example of minimal use of the GPT in an application.

void gpt_basic_example (void)
{
    fsp_err_t err = FSP_SUCCESS;


    /* Initializes the module. */
    err = R_GPT_Open(&g_timer0_ctrl, &g_timer0_cfg);


    /* Handle any errors. This function should be defined by the user. */
    handle_error(err);


    /* Start the timer. */
    (void) R_GPT_Start(&g_timer0_ctrl);

}

GPT Callback Example

This is an example of a timer callback.

/* Example callback called when timer expires. */
void timer_callback (timer_callback_args_t * p_args)
{
    if (TIMER_EVENT_CYCLE_END == p_args->event)
    {
        /* Add application code to be called periodically here. */
    }
}

GPT Free Running Counter Example

To use the GPT as a free running counter, select periodic mode and set the the Period to 0xFFFFFFFF for a 32-bit timer.

void gpt_counter_example (void)
{
    fsp_err_t err = FSP_SUCCESS;

    /* Initializes the module. */
    err = R_GPT_Open(&g_timer0_ctrl, &g_timer0_cfg);

    /* Handle any errors. This function should be defined by the user. */
    handle_error(err);

    /* Start the timer. */
    (void) R_GPT_Start(&g_timer0_ctrl);


    /* (Optional) Stop the timer. */
    (void) R_GPT_Stop(&g_timer0_ctrl);



    /* Read the current counter value. Counter value is in status.counter. */
    timer_status_t status;
    (void) R_GPT_StatusGet(&g_timer0_ctrl, &status);

}

GPT Input Capture Example

This is an example of using the GPT to capture pulse width or pulse period measurements.

/* Example callback called when a capture occurs. */
uint64_t g_captured_time     = 0U;
uint32_t g_capture_overflows = 0U;
void timer_capture_callback (timer_callback_args_t * p_args)
{
    if ((TIMER_EVENT_CAPTURE_A == p_args->event) || (TIMER_EVENT_CAPTURE_B == p_args->event))
    {

        /* (Optional) Get the current period if not known. */
        timer_info_t info;
        (void) R_GPT_InfoGet(&g_timer0_ctrl, &info);
        uint64_t period = info.period_counts;

        /* The maximum period is one more than the maximum 32-bit number, but will be reflected as 0 in
         * timer_info_t::period_counts. */
        if (0U == period)
        {
            period = UINT32_MAX + 1U;
        }


        g_captured_time     = (period * g_capture_overflows) + p_args->capture;
        g_capture_overflows = 0U;
    }

    if (TIMER_EVENT_CYCLE_END == p_args->event)
    {
        /* An overflow occurred during capture. This must be accounted for at the application layer. */
        g_capture_overflows++;
    }
}

void gpt_capture_example (void)
{
    fsp_err_t err = FSP_SUCCESS;

    /* Initializes the module. */
    err = R_GPT_Open(&g_timer0_ctrl, &g_timer0_cfg);

    /* Handle any errors. This function should be defined by the user. */
    handle_error(err);


    /* Enable captures. Captured values arrive in the interrupt. */
    (void) R_GPT_Enable(&g_timer0_ctrl);



    /* (Optional) Disable captures. */
    (void) R_GPT_Disable(&g_timer0_ctrl);

}

GPT Period Update Example

This an example of updating the period.

#define GPT_EXAMPLE_MSEC_PER_SEC           (1000)
#define GPT_EXAMPLE_DESIRED_PERIOD_MSEC    (20)

/* This example shows how to calculate a new period value at runtime. */
void gpt_period_calculation_example (void)
{
    fsp_err_t err = FSP_SUCCESS;

    /* Initializes the module. */
    err = R_GPT_Open(&g_timer0_ctrl, &g_timer0_cfg);

    /* Handle any errors. This function should be defined by the user. */
    handle_error(err);

    /* Start the timer. */
    (void) R_GPT_Start(&g_timer0_ctrl);


    /* Get the source clock frequency (in Hz). There are 3 ways to do this in FSP:
     *  - If the PCLKGPTL frequency has not changed since reset, the source clock frequency is
     *    BSP_STARTUP_PCLKGPTL_HZ >> timer_cfg_t::source_div
     *  - Use the R_GPT_InfoGet function (it accounts for the divider).
     *  - Calculate the current PCLKD frequency using R_FSP_SystemClockHzGet(FSP_PRIV_CLOCK_PCLKGPTL) and right shift
     *    by timer_cfg_t::source_div.
     *
     * This example uses the 3rd option (R_FSP_SystemClockHzGet).
     */
    uint32_t pclkd_freq_hz = R_FSP_SystemClockHzGet(FSP_PRIV_CLOCK_PCLKGPTL) >> g_timer0_cfg.source_div;

    /* Calculate the desired period based on the current clock. Note that this calculation could overflow if the
     * desired period is larger than UINT32_MAX / pclkd_freq_hz. A cast to uint64_t is used to prevent this. */
    uint32_t period_counts =
        (uint32_t) (((uint64_t) pclkd_freq_hz * GPT_EXAMPLE_DESIRED_PERIOD_MSEC) / GPT_EXAMPLE_MSEC_PER_SEC);

    /* Set the calculated period. */
    err = R_GPT_PeriodSet(&g_timer0_ctrl, period_counts);
    handle_error(err);

}

GPT Duty Cycle Update Example

This an example of updating the duty cycle.

#define GPT_EXAMPLE_DESIRED_DUTY_CYCLE_PERCENT    (25)
#define GPT_EXAMPLE_MAX_PERCENT                   (100)

/* This example shows how to calculate a new duty cycle value at runtime. */
void gpt_duty_cycle_calculation_example (void)
{
    fsp_err_t err = FSP_SUCCESS;

    /* Initializes the module. */
    err = R_GPT_Open(&g_timer0_ctrl, &g_timer0_cfg);

    /* Handle any errors. This function should be defined by the user. */
    handle_error(err);

    /* Start the timer. */
    (void) R_GPT_Start(&g_timer0_ctrl);


    /* Get the current period setting. */
    timer_info_t info;
    (void) R_GPT_InfoGet(&g_timer0_ctrl, &info);
    uint32_t current_period_counts = info.period_counts;

    /* Calculate the desired duty cycle based on the current period. Note that if the period could be larger than
     * UINT32_MAX / 100, this calculation could overflow. A cast to uint64_t is used to prevent this. The cast is
     * not required for 16-bit timers. */
    uint32_t duty_cycle_counts =
        (uint32_t) (((uint64_t) current_period_counts * GPT_EXAMPLE_DESIRED_DUTY_CYCLE_PERCENT) /
                    GPT_EXAMPLE_MAX_PERCENT);

    /* Set the calculated duty cycle. */
    err = R_GPT_DutyCycleSet(&g_timer0_ctrl, duty_cycle_counts, GPT_IO_PIN_GTIOCB);
    handle_error(err);

}

GPT A/D Converter Start Request Example

This is an example of using the GPT to start the ADC at a configurable A/D converter compare match value.

#if 0                                  /* T2h-alpha not support elc */

/* This example shows how to configure the GPT to generate an A/D start request at an A/D start request compare
 * match value. This example can only be used with GPT variants. */
void gpt_adc_start_request_example (void)
{
    fsp_err_t err = FSP_SUCCESS;

    /* Initialize and configure the ELC. */
    err = R_ELC_Open(&g_elc_ctrl, &g_elc_cfg);

    /* Handle any errors. This function should be defined by the user. */
    handle_error(err);

    /* Configure the ELC to start a scan on ADC unit 0 when GPT channel 0. Note: This is typically configured in
     * g_elc_cfg and already set during R_ELC_Open. */
    err = R_ELC_LinkSet(&g_elc_ctrl, ELC_PERIPHERAL_ADC0_A, ELC_EVENT_GPT0_ADTRGA);
    handle_error(err);

    /* Globally enable ELC events. */
    err = R_ELC_Enable(&g_elc_ctrl);
    handle_error(err);
 #if 0                                 /* TO DO VER100 */

    /* Initialize the ADC to start a scan based on an ELC event trigger. Set adc_cfg_t::trigger to
     * ADC_TRIGGER_SYNC_ELC.  */
    err = R_ADC_Open(&g_adc0_ctrl, &g_adc0_cfg);
    handle_error(err);

    err = R_ADC_ScanCfg(&g_adc0_ctrl, &g_adc0_channel_cfg);
    handle_error(err);

    /* Enable ELC triggers by calling R_ADC_ScanStart(). */
    (void) R_ADC_ScanStart(&g_adc0_ctrl);
 #endif

    /* Initializes the GPT module. Configure gpt_extended_pwm_cfg_t::adc_trigger to set when the A/D start request
     * is generated. Set gpt_extended_pwm_cfg_t::adc_a_compare_match to set the desired compare match value. */
    err = R_GPT_Open(&g_timer0_ctrl, &g_timer0_cfg);
    handle_error(err);

    /* Start the timer. A/D converter start request events are generated each time the counter is equal to the
     * A/D start request compare match value. */
    (void) R_GPT_Start(&g_timer0_ctrl);
}

GPT phase count Basic Example

This is an example of using the GPT to operate phase counting mode.

void gpt_phase_count_example (void)
{
    fsp_err_t err = FSP_SUCCESS;

    /* Initializes the module. */
    err = R_GPT_Open(&g_timer0_ctrl, &g_timer0_cfg);

    /* Handle any errors. This function should be defined by the user. */
    handle_error(err);

    /* Start the timer. */
    err = R_GPT_Start(&g_timer0_ctrl);
    handle_error(err);

    /* Get phase counting information. Counter value is in status.counter. */
    timer_status_t status;
    err = R_GPT_StatusGet(&g_timer0_ctrl, &status);
    handle_error(err);
}

Data Structures
struct	gpt_output_pin_t
struct	gpt_instance_ctrl_t
struct	gpt_extended_pwm_cfg_t
struct	gpt_extended_cfg_t

Enumerations
enum	gpt_io_pin_t
enum	gpt_pin_level_t
enum	gpt_source_t
enum	gpt_capture_filter_t
enum	gpt_adc_trigger_t
enum	gpt_poeg_link_t
enum	gpt_output_disable_t
enum	gpt_gtioc_disable_t
enum	gpt_adc_compare_match_t
enum	gpt_interrupt_skip_source_t
enum	gpt_interrupt_skip_count_t
enum	gpt_interrupt_skip_adc_t
enum	gpt_interrupt_skip_select_t

---

Data Structure Documentation

gpt_output_pin_t

struct gpt_output_pin_t

Configurations for output pins.

Data Fields
bool	output_enabled	Set to true to enable output, false to disable output.
gpt_pin_level_t	stop_level	Select a stop level from gpt_pin_level_t.

gpt_instance_ctrl_t

struct gpt_instance_ctrl_t

Channel control block. DO NOT INITIALIZE. Initialization occurs when timer_api_t::open is called.

gpt_extended_pwm_cfg_t

struct gpt_extended_pwm_cfg_t

GPT extension for advanced PWM features.

Data Fields
uint8_t	trough_ipl	Trough interrupt priority.
IRQn_Type	trough_irq	Trough interrupt.
gpt_poeg_link_t	poeg_link	Select which POEG channel controls output disable for this GPT channel.
gpt_output_disable_t	output_disable	Select which trigger sources request output disable from POEG.
gpt_adc_trigger_t	adc_trigger	Select trigger sources to start A/D conversion.
uint32_t	dead_time_count_up	Set a dead time value for counting up.
uint32_t	dead_time_count_down	Set a dead time value for counting down.
uint32_t	adc_a_compare_match	Select the compare match value used to trigger an A/D conversion start request using ELC_EVENT_GPT<channel>_AD_TRIG_A.
uint32_t	adc_b_compare_match	Select the compare match value used to trigger an A/D conversion start request using ELC_EVENT_GPT<channel>_AD_TRIG_B.
gpt_interrupt_skip_source_t	interrupt_skip_source	Interrupt source to count for interrupt skipping.
gpt_interrupt_skip_count_t	interrupt_skip_count	Number of interrupts to skip between events.
gpt_interrupt_skip_adc_t	interrupt_skip_adc	ADC events to skip when interrupt skipping is enabled.
gpt_interrupt_skip_source_t	interrupt_skip_source_ext1	Interrupt source to count for interrupt skipping(GTEITC.EIVTC1)
gpt_interrupt_skip_count_t	interrupt_skip_count_ext1	Number of interrupts to skip between events(GTEITC.EIVTT1)
gpt_interrupt_skip_source_t	interrupt_skip_source_ext2	Interrupt source to count for interrupt skipping(GTEITC.EIVTC2)
gpt_interrupt_skip_count_t	interrupt_skip_count_ext2	Number of interrupts to skip between events(GTEITC.EIVTT2)
gpt_interrupt_skip_select_t	interrupt_skip_func_ovf	Extended Skipping Function Select(GTEITL1.EITVL)
gpt_interrupt_skip_select_t	interrupt_skip_func_unf	Extended Skipping Function Select(GTEITL1.EITUL)
gpt_interrupt_skip_select_t	interrupt_skip_func_adc_a	Extended Skipping Function Select(GTEITL2.EADTAL)
gpt_interrupt_skip_select_t	interrupt_skip_func_adc_b	Extended Skipping Function Select(GTEITL2.EADTBL)
gpt_gtioc_disable_t	gtioca_disable_setting	Select how to configure GTIOCA when output is disabled.
gpt_gtioc_disable_t	gtiocb_disable_setting	Select how to configure GTIOCB when output is disabled.

gpt_extended_cfg_t

struct gpt_extended_cfg_t

GPT extension configures the output pins for GPT.

Data Fields
gpt_output_pin_t	gtioca	Configuration for GPT I/O pin A.
gpt_output_pin_t	gtiocb	Configuration for GPT I/O pin B.
gpt_source_t	start_source	Event sources that trigger the timer to start.
gpt_source_t	stop_source	Event sources that trigger the timer to stop.
gpt_source_t	clear_source	Event sources that trigger the timer to clear.
gpt_source_t	capture_a_source	Event sources that trigger capture of GTIOCA.
gpt_source_t	capture_b_source	Event sources that trigger capture of GTIOCB.
gpt_source_t	count_up_source	Event sources that trigger a single up count. If GPT_SOURCE_NONE is selected for both count_up_source and count_down_source, then the timer count source is PCLK.
gpt_source_t	count_down_source	Event sources that trigger a single down count. If GPT_SOURCE_NONE is selected for both count_up_source and count_down_source, then the timer count source is PCLK.
gpt_capture_filter_t	capture_filter_gtioca	Debounce filter for GTIOCxA input signal pin.
gpt_capture_filter_t	capture_filter_gtiocb	Debounce filter for GTIOCxB input signal pin.
uint8_t	capture_a_ipl	Capture A interrupt priority.
uint8_t	capture_b_ipl	Capture B interrupt priority.
uint8_t	dead_time_ipl	Dead time error interrupt priority.
uint8_t	icds	Input Capture Operation Select at Count Stop.
IRQn_Type	capture_a_irq	Capture A interrupt.
IRQn_Type	capture_b_irq	Capture B interrupt.
IRQn_Type	dead_time_irq	Dead time error interrupt.
gpt_extended_pwm_cfg_t const *	p_pwm_cfg	Advanced PWM features, optional.
uint8_t	capture_a_source_select	Capture A interrupt source select.
uint8_t	capture_b_source_select	Capture B interrupt source select.
uint8_t	cycle_end_source_select	Cycle end interrupt source select.
uint8_t	dead_time_error_source_select	Dead time error interrupt source select.
uint8_t	trough_source_select	Trough interrupt source select.

Enumeration Type Documentation

gpt_io_pin_t

enum gpt_io_pin_t

Input/Output pins, used to select which duty cycle to update in R_GPT_DutyCycleSet().

Enumerator
GPT_IO_PIN_GTIOCA	GTIOCA.
GPT_IO_PIN_GTIOCB	GTIOCB.
GPT_IO_PIN_GTIOCA_AND_GTIOCB	GTIOCA and GTIOCB.

gpt_pin_level_t

enum gpt_pin_level_t

Level of GPT pin

Enumerator
GPT_PIN_LEVEL_LOW	Pin level low.
GPT_PIN_LEVEL_HIGH	Pin level high.

gpt_source_t

enum gpt_source_t

Sources can be used to start the timer, stop the timer, count up, or count down. These enumerations represent a bitmask. Multiple sources can be ORed together.

Enumerator
GPT_SOURCE_NONE	No active event sources.
GPT_SOURCE_GTETRGA_RISING	Action performed on GTETRGA rising edge.
GPT_SOURCE_GTETRGA_FALLING	Action performed on GTETRGA falling edge.
GPT_SOURCE_GTETRGB_RISING	Action performed on GTETRGB rising edge.
GPT_SOURCE_GTETRGB_FALLING	Action performed on GTETRGB falling edge.
GPT_SOURCE_GTETRGC_RISING	Action performed on GTETRGC rising edge.
GPT_SOURCE_GTETRGC_FALLING	Action performed on GTETRGC falling edge.
GPT_SOURCE_GTETRGD_RISING	Action performed on GTETRGB rising edge.
GPT_SOURCE_GTETRGD_FALLING	Action performed on GTETRGB falling edge.
GPT_SOURCE_GTIOCA_RISING_WHILE_GTIOCB_LOW	Action performed when GTIOCA input rises while GTIOCB is low.
GPT_SOURCE_GTIOCA_RISING_WHILE_GTIOCB_HIGH	Action performed when GTIOCA input rises while GTIOCB is high.
GPT_SOURCE_GTIOCA_FALLING_WHILE_GTIOCB_LOW	Action performed when GTIOCA input falls while GTIOCB is low.
GPT_SOURCE_GTIOCA_FALLING_WHILE_GTIOCB_HIGH	Action performed when GTIOCA input falls while GTIOCB is high.
GPT_SOURCE_GTIOCB_RISING_WHILE_GTIOCA_LOW	Action performed when GTIOCB input rises while GTIOCA is low.
GPT_SOURCE_GTIOCB_RISING_WHILE_GTIOCA_HIGH	Action performed when GTIOCB input rises while GTIOCA is high.
GPT_SOURCE_GTIOCB_FALLING_WHILE_GTIOCA_LOW	Action performed when GTIOCB input falls while GTIOCA is low.
GPT_SOURCE_GTIOCB_FALLING_WHILE_GTIOCA_HIGH	Action performed when GTIOCB input falls while GTIOCA is high.
GPT_SOURCE_GPT_A	Action performed on ELC GPTA event.
GPT_SOURCE_GPT_B	Action performed on ELC GPTB event.
GPT_SOURCE_GPT_C	Action performed on ELC GPTC event.
GPT_SOURCE_GPT_D	Action performed on ELC GPTD event.
GPT_SOURCE_GPT_E	Action performed on ELC GPTE event.
GPT_SOURCE_GPT_F	Action performed on ELC GPTF event.
GPT_SOURCE_GPT_G	Action performed on ELC GPTG event.
GPT_SOURCE_GPT_H	Action performed on ELC GPTH event.

gpt_capture_filter_t

enum gpt_capture_filter_t

Input capture signal noise filter (debounce) setting. Only available for input signals GTIOCxA and GTIOCxB. The noise filter samples the external signal at intervals of the PCLK divided by one of the values. When 3 consecutive samples are at the same level (high or low), then that level is passed on as the observed state of the signal. See "Noise Filter Function" in the hardware manual, GPT section.

Enumerator
GPT_CAPTURE_FILTER_NONE	None - no filtering.
GPT_CAPTURE_FILTER_PCLKD_DIV_1	PCLK/1 - fast sampling.
GPT_CAPTURE_FILTER_PCLKD_DIV_4	PCLK/4.
GPT_CAPTURE_FILTER_PCLKD_DIV_16	PCLK/16.
GPT_CAPTURE_FILTER_PCLKD_DIV_64	PCLK/64 - slow sampling.

gpt_adc_trigger_t

enum gpt_adc_trigger_t

Trigger options to start A/D conversion.

Enumerator
GPT_ADC_TRIGGER_NONE	None - no output disable request.
GPT_ADC_TRIGGER_UP_COUNT_START_ADC_A	Request A/D conversion from ADC unit 0 at up counting compare match of gpt_extended_pwm_cfg_t::adc_a_compare_match.
GPT_ADC_TRIGGER_DOWN_COUNT_START_ADC_A	Request A/D conversion from ADC unit 0 at down counting compare match of gpt_extended_pwm_cfg_t::adc_a_compare_match.
GPT_ADC_TRIGGER_UP_COUNT_START_ADC_B	Request A/D conversion from ADC unit 1 at up counting compare match of gpt_extended_pwm_cfg_t::adc_b_compare_match.
GPT_ADC_TRIGGER_DOWN_COUNT_START_ADC_B	Request A/D conversion from ADC unit 1 at down counting compare match of gpt_extended_pwm_cfg_t::adc_b_compare_match.

gpt_poeg_link_t

enum gpt_poeg_link_t

POEG channel to link to this channel.

Enumerator
GPT_POEG_LINK_POEG0	Link this GPT channel to POEG channel 0 (GTETRGA)
GPT_POEG_LINK_POEG1	Link this GPT channel to POEG channel 1 (GTETRGB)
GPT_POEG_LINK_POEG2	Link this GPT channel to POEG channel 2 (GTETRGC)
GPT_POEG_LINK_POEG3	Link this GPT channel to POEG channel 3 (GTETRGD)

gpt_output_disable_t

enum gpt_output_disable_t

Select trigger to send output disable request to POEG.

Enumerator
GPT_OUTPUT_DISABLE_NONE	None - no output disable request.
GPT_OUTPUT_DISABLE_DEAD_TIME_ERROR	Request output disable if a dead time error occurs.
GPT_OUTPUT_DISABLE_GTIOCA_GTIOCB_HIGH	Request output disable if GTIOCA and GTIOCB are high at the same time.
GPT_OUTPUT_DISABLE_GTIOCA_GTIOCB_LOW	Request output disable if GTIOCA and GTIOCB are low at the same time.

gpt_gtioc_disable_t

enum gpt_gtioc_disable_t

Disable level options for GTIOC pins.

Enumerator
GPT_GTIOC_DISABLE_PROHIBITED	Do not allow output disable.
GPT_GTIOC_DISABLE_SET_HI_Z	Set GTIOC to high impedance when output is disabled.
GPT_GTIOC_DISABLE_LEVEL_LOW	Set GTIOC level low when output is disabled.
GPT_GTIOC_DISABLE_LEVEL_HIGH	Set GTIOC level high when output is disabled.

gpt_adc_compare_match_t

enum gpt_adc_compare_match_t

Trigger options to start A/D conversion.

Enumerator
GPT_ADC_COMPARE_MATCH_ADC_A	Set A/D conversion start request value for GPT A/D converter start request A.
GPT_ADC_COMPARE_MATCH_ADC_B	Set A/D conversion start request value for GPT A/D converter start request B.

gpt_interrupt_skip_source_t

enum gpt_interrupt_skip_source_t

Interrupt skipping modes

Enumerator
GPT_INTERRUPT_SKIP_SOURCE_NONE	Do not skip interrupts.
GPT_INTERRUPT_SKIP_SOURCE_OVERFLOW_UNDERFLOW	Count and skip overflow and underflow interrupts.
GPT_INTERRUPT_SKIP_SOURCE_CREST	Count crest interrupts for interrupt skipping. Skip the number of crest and trough interrupts configured in gpt_interrupt_skip_count_t. When the interrupt does fire, the trough interrupt fires before the crest interrupt.
GPT_INTERRUPT_SKIP_SOURCE_TROUGH	Count trough interrupts for interrupt skipping. Skip the number of crest and trough interrupts configured in gpt_interrupt_skip_count_t. When the interrupt does fire, the crest interrupt fires before the trough interrupt.

gpt_interrupt_skip_count_t

enum gpt_interrupt_skip_count_t

Number of interrupts to skip between events

Enumerator
GPT_INTERRUPT_SKIP_COUNT_0	Do not skip interrupts.
GPT_INTERRUPT_SKIP_COUNT_1	Skip one interrupt.
GPT_INTERRUPT_SKIP_COUNT_2	Skip two interrupts.
GPT_INTERRUPT_SKIP_COUNT_3	Skip three interrupts.
GPT_INTERRUPT_SKIP_COUNT_4	Skip four interrupts.
GPT_INTERRUPT_SKIP_COUNT_5	Skip five interrupts.
GPT_INTERRUPT_SKIP_COUNT_6	Skip six interrupts.
GPT_INTERRUPT_SKIP_COUNT_7	Skip seven interrupts.
GPT_INTERRUPT_SKIP_COUNT_8	Skip eight interrupts. When setting GTIEITC
GPT_INTERRUPT_SKIP_COUNT_9	Skip nine interrupts.
GPT_INTERRUPT_SKIP_COUNT_10	Skip ten interrupts.
GPT_INTERRUPT_SKIP_COUNT_11	Skip eleven interrupts.
GPT_INTERRUPT_SKIP_COUNT_12	Skip twelve interrupts.
GPT_INTERRUPT_SKIP_COUNT_13	Skip thiertenn interrupts.
GPT_INTERRUPT_SKIP_COUNT_14	Skip fourteen interrupts.
GPT_INTERRUPT_SKIP_COUNT_15	Skip fifteen interrupts.

gpt_interrupt_skip_adc_t

enum gpt_interrupt_skip_adc_t

ADC events to skip during interrupt skipping

Enumerator
GPT_INTERRUPT_SKIP_ADC_NONE	Do not skip ADC events.
GPT_INTERRUPT_SKIP_ADC_A	Skip ADC A events.
GPT_INTERRUPT_SKIP_ADC_B	Skip ADC B events.
GPT_INTERRUPT_SKIP_ADC_A_AND_B	Skip ADC A and B events.

gpt_interrupt_skip_select_t

enum gpt_interrupt_skip_select_t

extended interrupt skipping

Enumerator
GPT_INTERRUPT_SKIP_SELECT_NONE	Do not perform an extended interrupt skipping.
GPT_INTERRUPT_SKIP_SELECT_EITCNT1	An interrupt is output in the period of EITCNT1[3:0] bits = 0000b.
GPT_INTERRUPT_SKIP_SELECT_EITCNT2	An interrupt is output in the period of EITCNT2[3:0] bits = 0000b.
GPT_INTERRUPT_SKIP_SELECT_EITCNT1_2	An interrupt is output in the period of EITCNT1[3:0] bits = 0000b and EITCNT2[3:0] bits = 0000b.
GPT_INTERRUPT_SKIP_SELECT_EITVTT1	An interrupt is output in the period of EITCNT1[3:0] bits = EIVTT1[3:0] bits.
GPT_INTERRUPT_SKIP_SELECT_EITVTT2	An interrupt is output in the period of EITCNT2[3:0] bits = EIVTT2[3:0] bits.
GPT_INTERRUPT_SKIP_SELECT_EITVTT1_2	An interrupt is output in the period of EITCNT1[3:0] bits = EIVTT1[3:0] bits and EITCNT2[3:0] bits = EIVTT2[3:0] bits.

Function Documentation

R_GPT_Open()

fsp_err_t R_GPT_Open	(	timer_ctrl_t *const	p_ctrl,
		timer_cfg_t const *const	p_cfg
	)

Initializes the timer module and applies configurations. Implements timer_api_t::open.

GPT hardware does not support one-shot functionality natively. When using one-shot mode, the timer will be stopped in an ISR after the requested period has elapsed.

The GPT implementation of the general timer can accept a gpt_extended_cfg_t extension parameter.

Return values

FSP_SUCCESS	Initialization was successful and timer has started.
FSP_ERR_ASSERTION	A required input pointer is NULL or the source divider is invalid.
FSP_ERR_ALREADY_OPEN	Module is already open.
FSP_ERR_IRQ_BSP_DISABLED	timer_cfg_t::mode is TIMER_MODE_ONE_SHOT or timer_cfg_t::p_callback is not NULL, but ISR is not enabled. ISR must be enabled to use one-shot mode or callback.
FSP_ERR_INVALID_MODE	Triangle wave PWM is only supported if GPT_CFG_OUTPUT_SUPPORT_ENABLE is 2.
FSP_ERR_IP_CHANNEL_NOT_PRESENT	The channel requested in the p_cfg parameter is not available on this device.

R_GPT_Stop()

fsp_err_t R_GPT_Stop

(

timer_ctrl_t *const

p_ctrl

)

Stops timer. Implements timer_api_t::stop.

Return values

FSP_SUCCESS	Timer successfully stopped.
FSP_ERR_ASSERTION	p_ctrl was NULL.
FSP_ERR_NOT_OPEN	The instance is not opened.

R_GPT_Start()

fsp_err_t R_GPT_Start

(

timer_ctrl_t *const

p_ctrl

)

Starts timer. Implements timer_api_t::start.

Return values

FSP_SUCCESS	Timer successfully started.
FSP_ERR_ASSERTION	p_ctrl was NULL.
FSP_ERR_NOT_OPEN	The instance is not opened.

R_GPT_Reset()

fsp_err_t R_GPT_Reset

(

timer_ctrl_t *const

p_ctrl

)

Resets the counter value to 0. Implements timer_api_t::reset.

Note

This function also updates to the new period if no counter overflow has occurred since the last call to R_GPT_PeriodSet().

Return values

FSP_SUCCESS	Counter value written successfully.
FSP_ERR_ASSERTION	p_ctrl was NULL.
FSP_ERR_NOT_OPEN	The instance is not opened.

R_GPT_Enable()

fsp_err_t R_GPT_Enable

(

timer_ctrl_t *const

p_ctrl

)

Enables external event triggers that start, stop, clear, or capture the counter. Implements timer_api_t::enable.

Return values

FSP_SUCCESS	External events successfully enabled.
FSP_ERR_ASSERTION	p_ctrl was NULL.
FSP_ERR_NOT_OPEN	The instance is not opened.

R_GPT_Disable()

fsp_err_t R_GPT_Disable

(

timer_ctrl_t *const

p_ctrl

)

Disables external event triggers that start, stop, clear, or capture the counter. Implements timer_api_t::disable.

Note

The timer could be running after R_GPT_Disable(). To ensure it is stopped, call R_GPT_Stop().

Return values

FSP_SUCCESS	External events successfully disabled.
FSP_ERR_ASSERTION	p_ctrl was NULL.
FSP_ERR_NOT_OPEN	The instance is not opened.

R_GPT_PeriodSet()

fsp_err_t R_GPT_PeriodSet	(	timer_ctrl_t *const	p_ctrl,
		uint32_t const	period_counts
	)

Sets period value provided. If the timer is running, the period will be updated after the next counter overflow. If the timer is stopped, this function resets the counter and updates the period. Implements timer_api_t::periodSet.

Warning

If periodic output is used, the duty cycle buffer registers are updated after the period buffer register. If this function is called while the timer is running and a GPT overflow occurs during processing, the duty cycle will not be the desired 50% duty cycle until the counter overflow after processing completes.

Return values

FSP_SUCCESS	Period value written successfully.
FSP_ERR_ASSERTION	p_ctrl was NULL.
FSP_ERR_NOT_OPEN	The instance is not opened.

R_GPT_DutyCycleSet()

fsp_err_t R_GPT_DutyCycleSet	(	timer_ctrl_t *const	p_ctrl,
		uint32_t const	duty_cycle_counts,
		uint32_t const	pin
	)

Sets duty cycle on requested pin. Implements timer_api_t::dutyCycleSet.

Duty cycle is updated in the buffer register. The updated duty cycle is reflected after the next cycle end (counter overflow).

Parameters

[in]	p_ctrl	Pointer to instance control block.
[in]	duty_cycle_counts	Duty cycle to set in counts.
[in]	pin	Use gpt_io_pin_t to select GPT_IO_PIN_GTIOCA or GPT_IO_PIN_GTIOCB

Return values

FSP_SUCCESS	Duty cycle updated successfully.
FSP_ERR_ASSERTION	p_ctrl was NULL or the pin is not one of gpt_io_pin_t
FSP_ERR_NOT_OPEN	The instance is not opened.
FSP_ERR_INVALID_ARGUMENT	Duty cycle is larger than period.
FSP_ERR_UNSUPPORTED	GPT_CFG_OUTPUT_SUPPORT_ENABLE is 0.

R_GPT_InfoGet()

fsp_err_t R_GPT_InfoGet	(	timer_ctrl_t *const	p_ctrl,
		timer_info_t *const	p_info
	)

Get timer information and store it in provided pointer p_info. Implements timer_api_t::infoGet.

Return values

FSP_SUCCESS	Period, count direction, frequency, and ELC event written to caller's structure successfully.(External clock(GTETRGA - GTETRGD) cannot be acquired.)
FSP_ERR_ASSERTION	p_ctrl or p_info was NULL.
FSP_ERR_NOT_OPEN	The instance is not opened.

R_GPT_StatusGet()

fsp_err_t R_GPT_StatusGet	(	timer_ctrl_t *const	p_ctrl,
		timer_status_t *const	p_status
	)

Get current timer status and store it in provided pointer p_status. Implements timer_api_t::statusGet.

Return values

FSP_SUCCESS	Current timer state and counter value set successfully.
FSP_ERR_ASSERTION	p_ctrl or p_status was NULL.
FSP_ERR_NOT_OPEN	The instance is not opened.

R_GPT_CounterSet()

fsp_err_t R_GPT_CounterSet	(	timer_ctrl_t *const	p_ctrl,
		uint32_t	counter
	)

Set counter value.

Note

Do not call this API while the counter is counting. The counter value can only be updated while the counter is stopped.

Return values

FSP_SUCCESS	Counter value updated.
FSP_ERR_ASSERTION	p_ctrl or p_status was NULL.
FSP_ERR_NOT_OPEN	The instance is not opened.
FSP_ERR_IN_USE	The timer is running. Stop the timer before calling this function.

R_GPT_OutputEnable()

fsp_err_t R_GPT_OutputEnable	(	timer_ctrl_t *const	p_ctrl,
		gpt_io_pin_t	pin
	)

Enable output for GTIOCA and/or GTIOCB.

Return values

FSP_SUCCESS	Output is enabled.
FSP_ERR_ASSERTION	p_ctrl or p_status was NULL.
FSP_ERR_NOT_OPEN	The instance is not opened.

R_GPT_OutputDisable()

fsp_err_t R_GPT_OutputDisable	(	timer_ctrl_t *const	p_ctrl,
		gpt_io_pin_t	pin
	)

Disable output for GTIOCA and/or GTIOCB.

Return values

FSP_SUCCESS	Output is disabled.
FSP_ERR_ASSERTION	p_ctrl or p_status was NULL.
FSP_ERR_NOT_OPEN	The instance is not opened.

R_GPT_AdcTriggerSet()

fsp_err_t R_GPT_AdcTriggerSet	(	timer_ctrl_t *const	p_ctrl,
		gpt_adc_compare_match_t	which_compare_match,
		uint32_t	compare_match_value
	)

Set A/D converter start request compare match value.

Return values

FSP_SUCCESS	Counter value updated.
FSP_ERR_ASSERTION	p_ctrl or p_status was NULL.
FSP_ERR_NOT_OPEN	The instance is not opened.

R_GPT_CallbackSet()

fsp_err_t R_GPT_CallbackSet	(	timer_ctrl_t *const	p_ctrl,
		void(*)(timer_callback_args_t *)	p_callback,
		void const *const	p_context,
		timer_callback_args_t *const	p_callback_memory
	)

Updates the user callback with the option to provide memory for the callback argument structure. Implements timer_api_t::callbackSet.

Return values

FSP_SUCCESS	Callback updated successfully.
FSP_ERR_ASSERTION	A required pointer is NULL.
FSP_ERR_NOT_OPEN	The control block has not been opened.

R_GPT_Close()

fsp_err_t R_GPT_Close

(

timer_ctrl_t *const

p_ctrl

)

Stops counter, disables output pins, and clears internal driver data. Implements timer_api_t::close.

Return values

FSP_SUCCESS	Successful close.
FSP_ERR_ASSERTION	p_ctrl was NULL.
FSP_ERR_NOT_OPEN	The instance is not opened.