ra8_gpt.h

Go to the documentation of this file.

 
#pragma once
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include <stdint.h>
 
#include "ra8_dma.h"
#include "ra8_err.h"
 
/* =============================================================================
 * Types
 * =============================================================================
 */

typedef enum : uint8_t {
  k_ra8_gpt_mode_saw_pwm       = 0U, 
  k_ra8_gpt_mode_saw_one_shot  = 1U, 
  k_ra8_gpt_mode_triangle_pwm  = 4U, 
  k_ra8_gpt_mode_triangle_pwm2 = 5U, 
  k_ra8_gpt_mode_triangle_pwm3 = 6U, 
} ra8_gpt_mode_t;

typedef enum : uint8_t {
  k_ra8_gpt_ps_div_1    = 0U, 
  k_ra8_gpt_ps_div_4    = 1U, 
  k_ra8_gpt_ps_div_16   = 2U, 
  k_ra8_gpt_ps_div_64   = 3U, 
  k_ra8_gpt_ps_div_256  = 4U, 
  k_ra8_gpt_ps_div_1024 = 5U, 
} ra8_gpt_prescaler_t;

typedef struct {
  ra8_gpt_mode_t      mode;       
  ra8_gpt_prescaler_t prescaler;  
  uint32_t            period;     
  uint32_t            duty_a;     
  uint32_t            duty_b;     
  bool                auto_start; 
} ra8_gpt_cfg_t;

typedef enum : uint32_t {
  k_ra8_gpt_status_none      = 0x00000000UL, 
  k_ra8_gpt_status_ccra      = 0x00000001UL, 
  k_ra8_gpt_status_ccrb      = 0x00000002UL, 
  k_ra8_gpt_status_overflow  = 0x00000040UL, 
  k_ra8_gpt_status_underflow = 0x00000080UL, 
} ra8_gpt_status_mask_t;

typedef enum : uint8_t {
  k_ra8_gpt_ccr_a = 0U, 
  k_ra8_gpt_ccr_b = 1U, 
} ra8_gpt_ccr_sel_t;

typedef void (*ra8_gpt_event_fn_t)(void* ctx, uint32_t status_mask);
 
/* =============================================================================
 * PWM pin configuration (Sweep 3 Task 2 -- mirrors FSP r_gpt PWM pin API)
 * =============================================================================
 */

typedef enum : uint8_t {
  k_ra8_gpt_pin_a = 0U, 
  k_ra8_gpt_pin_b = 1U, 
} ra8_gpt_pwm_pin_t;

typedef enum : uint8_t {
  k_ra8_gpt_pol_active_high = 0U, 
  k_ra8_gpt_pol_active_low  = 1U, 
} ra8_gpt_pwm_polarity_t;

typedef enum : uint8_t {
  k_ra8_gpt_stop_low  = 0U, 
  k_ra8_gpt_stop_high = 1U, 
} ra8_gpt_pwm_stop_level_t;

typedef enum : uint8_t {
  k_ra8_gpt_disable_none      = 0U, 
  k_ra8_gpt_disable_high_z    = 1U, 
  k_ra8_gpt_disable_drive_low = 2U, 
  k_ra8_gpt_disable_drive_hi  = 3U, 
} ra8_gpt_pwm_disable_t;

typedef struct {
  bool                     output_enable;    
  ra8_gpt_pwm_polarity_t   polarity;         
  ra8_gpt_pwm_stop_level_t stop_level;       
  ra8_gpt_pwm_disable_t    disable_on_fault; 
} ra8_gpt_pwm_pin_cfg_t;
 
/* =============================================================================
 * Three-phase PWM (Sweep 3 Task 2 -- mirrors FSP r_gpt_three_phase)
 * =============================================================================
 */

typedef enum : uint8_t {
  k_ra8_gpt_three_phase_u     = 0U, 
  k_ra8_gpt_three_phase_v     = 1U, 
  k_ra8_gpt_three_phase_w     = 2U, 
  k_ra8_gpt_three_phase_count = 3U, 
} ra8_gpt_three_phase_idx_t;

typedef struct {
  uint8_t             channels[k_ra8_gpt_three_phase_count]; 
  ra8_gpt_mode_t      mode;                                  
  ra8_gpt_prescaler_t prescaler;                             
  uint32_t            period_counts;                         
  uint32_t            initial_duty_u;                        
  uint32_t            initial_duty_v;                        
  uint32_t            initial_duty_w;                        
} ra8_gpt_three_phase_cfg_t;
 
/* =============================================================================
 * Lifecycle
 * =============================================================================
 */

[[nodiscard]] ra8_err_t ra8_gpt_init(uint8_t channel, const ra8_gpt_cfg_t* cfg);

[[nodiscard]] ra8_err_t ra8_gpt_deinit(uint8_t channel);
 
/* =============================================================================
 * Legacy polling API
 * =============================================================================
 */

[[nodiscard]] ra8_err_t ra8_gpt_start_free_run(uint8_t channel, uint32_t period);

[[nodiscard]] ra8_err_t ra8_gpt_stop(uint8_t channel);

[[nodiscard]] ra8_err_t ra8_gpt_read(uint8_t channel, uint32_t* out);
 
/* =============================================================================
 * Runtime reconfigure
 * =============================================================================
 */

[[nodiscard]] ra8_err_t ra8_gpt_set_period(uint8_t channel, uint32_t period);

[[nodiscard]] ra8_err_t ra8_gpt_set_duty(uint8_t channel, ra8_gpt_ccr_sel_t which, uint32_t value);
 
/* =============================================================================
 * Sweep 3 Task 2 -- runtime PWM duty / period / counter / dead time
 * =============================================================================
 */

[[nodiscard]] ra8_err_t ra8_gpt_period_set(uint8_t channel, uint32_t period_counts);

[[nodiscard]] ra8_err_t
ra8_gpt_duty_cycle_set(uint8_t channel, ra8_gpt_pwm_pin_t pin, uint32_t compare_counts);

[[nodiscard]] ra8_err_t ra8_gpt_counter_set(uint8_t channel, uint32_t value);

[[nodiscard]] ra8_err_t
ra8_gpt_pwm_pin_configure(uint8_t channel, ra8_gpt_pwm_pin_t pin, const ra8_gpt_pwm_pin_cfg_t* cfg);

[[nodiscard]] ra8_err_t
ra8_gpt_dead_time_set(uint8_t channel, uint32_t rising_dt, uint32_t falling_dt);
 
/* =============================================================================
 * Three-phase synchronized PWM (FSP r_gpt_three_phase mirror)
 * =============================================================================
 */

[[nodiscard]] ra8_err_t ra8_gpt_three_phase_open(const ra8_gpt_three_phase_cfg_t* cfg);

[[nodiscard]] ra8_err_t
ra8_gpt_three_phase_set_duty(uint32_t u_duty, uint32_t v_duty, uint32_t w_duty);

[[nodiscard]] ra8_err_t ra8_gpt_three_phase_close(void);
 
/* =============================================================================
 * Status
 * =============================================================================
 */

[[nodiscard]] ra8_err_t ra8_gpt_get_status(uint8_t channel, uint32_t* out_mask);

[[nodiscard]] ra8_err_t ra8_gpt_clear_status(uint8_t channel, uint32_t mask);
 
/* =============================================================================
 * Interrupt path
 * =============================================================================
 */

[[nodiscard]] ra8_err_t ra8_gpt_attach_handler(uint8_t channel, ra8_gpt_event_fn_t fn, void* ctx);
 
/* =============================================================================
 * Power transition
 * =============================================================================
 */

[[nodiscard]] ra8_err_t ra8_gpt_enter_stop(uint8_t channel);

[[nodiscard]] ra8_err_t ra8_gpt_exit_stop(uint8_t channel);
 
/* =============================================================================
 * DMA TX / RX
 * =============================================================================
 */

[[nodiscard]] ra8_err_t ra8_gpt_write_dma(uint8_t               channel,
                                          const uint32_t*       periods,
                                          uint16_t              count,
                                          ra8_dma_complete_fn_t on_complete,
                                          void*                 ctx,
                                          uint8_t*              out_dma_channel);

[[nodiscard]] ra8_err_t ra8_gpt_read_dma(uint8_t               channel,
                                         uint32_t*             out_counts,
                                         uint16_t              count,
                                         ra8_dma_complete_fn_t on_complete,
                                         void*                 ctx,
                                         uint8_t*              out_dma_channel);
 
/* =============================================================================
 * ISR dispatch
 * =============================================================================
 */

void ra8_gpt_dispatch_ovf(uint8_t channel);

void ra8_gpt_dispatch_und(uint8_t channel);

void ra8_gpt_dispatch_ccra(uint8_t channel);

void ra8_gpt_dispatch_ccrb(uint8_t channel);
 
/*
 * Input capture & external event counting live in ra8_gpt_capture.h, which
 * includes THIS header for its base types. The include is one-directional
 * (this header does NOT include it back) so there is no include cycle;
 * consumers that need the capture / event-count API include ra8_gpt_capture.h.
 */
 
#ifdef __cplusplus
}
#endif