LPC804

CAPT: Capacitive Touch

void CAPT_Init(CAPT_Type *base, const capt_config_t *config)

Initialize the CAPT module.

Parameters:
  • base – CAPT peripheral base address.

  • config – Pointer to “capt_config_t” structure.

void CAPT_Deinit(CAPT_Type *base)

De-initialize the CAPT module.

Parameters:
  • base – CAPT peripheral base address.

void CAPT_GetDefaultConfig(capt_config_t *config)

Gets an available pre-defined settings for the CAPT’s configuration.

This function initializes the converter configuration structure with available settings. The default values are:

config->enableWaitMode = false;
config->enableTouchLower = true;
config->clockDivider = 15U;
config->timeOutCount = 12U;
config->pollCount = 0U;
config->enableXpins = 0U;
config->triggerMode = kCAPT_YHPortTriggerMode;
config->XpinsMode = kCAPT_InactiveXpinsDrivenLowMode;
config->mDelay = kCAPT_MeasureDelayNoWait;
config->rDelay = kCAPT_ResetDelayWait9FCLKs;

Parameters:
  • config – Pointer to the configuration structure.

static inline void CAPT_SetThreshold(CAPT_Type *base, uint32_t count)

Set Sets the count threshold in divided FCLKs between touch and no-touch.

Parameters:
  • base – CAPT peripheral base address.

  • count – The count threshold.

void CAPT_SetPollMode(CAPT_Type *base, capt_polling_mode_t mode)

Set the CAPT polling mode.

Parameters:
  • base – CAPT peripheral base address.

  • mode – The selection of polling mode.

void CAPT_EnableDMA(CAPT_Type *base, capt_dma_mode_t mode)

Enable DMA feature.

Parameters:
  • base – CAPT peripheral base address.

  • mode – Select how DMA triggers are generated.

void CAPT_DisableDMA(CAPT_Type *base)

Disable DMA feature.

Parameters:
  • base – CAPT peripheral base address.

static inline void CAPT_EnableInterrupts(CAPT_Type *base, uint32_t mask)

Enable interrupt features.

Parameters:
  • base – CAPT peripheral base address.

  • mask – The mask of enabling interrupt features. Please refer to “_capt_interrupt_enable”.

static inline void CAPT_DisableInterrupts(CAPT_Type *base, uint32_t mask)

Disable interrupt features.

Parameters:
  • base – CAPT peripheral base address.

  • mask – The mask of disabling interrupt features. Please refer to “_capt_interrupt_enable”.

static inline uint32_t CAPT_GetInterruptStatusFlags(CAPT_Type *base)

Get CAPT interrupts’ status flags.

Parameters:
  • base – CAPT peripheral base address.

Returns:

The mask of interrupts’ status flags. please refer to “_capt_interrupt_status_flags”.

static inline void CAPT_ClearInterruptStatusFlags(CAPT_Type *base, uint32_t mask)

Clear the interrupts’ status flags.

Parameters:
  • base – CAPT peripheral base address.

  • mask – The mask of clearing the interrupts’ status flags, please refer to “_capt_interrupt_status_flags”.

static inline uint32_t CAPT_GetStatusFlags(CAPT_Type *base)

Get CAPT status flags.

Parameters:
  • base – CAPT peripheral base address.

Returns:

The mask of CAPT status flags. Please refer to “_capt_status_flags” Or use CAPT_GET_XMAX_NUMBER(mask) to get XMAX number.

bool CAPT_GetTouchData(CAPT_Type *base, capt_touch_data_t *data)

Get CAPT touch data.

Parameters:
  • base – CAPT peripheral base address.

  • data – The structure to store touch data.

Returns:

If return ‘true’, which means get valid data. if return ‘false’, which means get invalid data.

void CAPT_PollNow(CAPT_Type *base, uint16_t enableXpins)

Start touch data polling using poll-now method.

This function starts new data polling using polling-now method, CAPT stops when the polling is finished, application could check the status or monitor interrupt to know when the progress is finished.

Note that this is simultaneous poll of all X pins, all enabled X pins are activated concurrently, rather than walked one-at-a-time

Parameters:
  • base – CAPT peripheral base address.

  • enableXpins – The X pins enabled in this polling.

FSL_CAPT_DRIVER_VERSION

CAPT driver version.

enum _capt_xpins

The enumeration for X pins.

Values:

enumerator kCAPT_X0Pin

CAPT_X0 pin.

enumerator kCAPT_X1Pin

CAPT_X1 pin.

enumerator kCAPT_X2Pin

CAPT_X2 pin.

enumerator kCAPT_X3Pin

CAPT_X3 pin.

enumerator kCAPT_X4Pin

CAPT_X4 pin.

enumerator kCAPT_X5Pin

CAPT_X5 pin.

enumerator kCAPT_X6Pin

CAPT_X6 pin.

enumerator kCAPT_X7Pin

CAPT_X7 pin.

enumerator kCAPT_X8Pin

CAPT_X8 pin.

enumerator kCAPT_X9Pin

CAPT_X9 pin.

enumerator kCAPT_X10Pin

CAPT_X10 pin.

enumerator kCAPT_X11Pin

CAPT_X11 pin.

enumerator kCAPT_X12Pin

CAPT_X12 pin.

enumerator kCAPT_X13Pin

CAPT_X13 pin.

enumerator kCAPT_X14Pin

CAPT_X14 pin.

enumerator kCAPT_X15Pin

CAPT_X15 pin.

enum _capt_interrupt_enable

The enumeration for enabling/disabling interrupts.

Values:

enumerator kCAPT_InterruptOfYesTouchEnable

Generate interrupt when a touch has been detected.

enumerator kCAPT_InterruptOfNoTouchEnable

Generate interrupt when a no-touch has been detected.

enumerator kCAPT_InterruptOfPollDoneEnable

Genarate interrupt at the end of a polling round, or when a POLLNOW completes.

enumerator kCAPT_InterruptOfTimeOutEnable

Generate interrupt when the count reaches the time-out count value before a trigger occurs.

enumerator kCAPT_InterruptOfOverRunEnable

Generate interrupt when the Touch Data register has been up-dated before software has read the previous data, and the touch has been detected.

enum _capt_interrupt_status_flags

The enumeration for interrupt status flags.

Values:

enumerator kCAPT_InterruptOfYesTouchStatusFlag

YESTOUCH interrupt status flag.

enumerator kCAPT_InterruptOfNoTouchStatusFlag

NOTOUCH interrupt status flag.

enumerator kCAPT_InterruptOfPollDoneStatusFlag

POLLDONE interrupt status flag.

enumerator kCAPT_InterruptOfTimeOutStatusFlag

TIMEOUT interrupt status flag.

enumerator kCAPT_InterruptOfOverRunStatusFlag

OVERRUN interrupt status flag.

enum _capt_status_flags

The enumeration for CAPT status flags.

Values:

enumerator kCAPT_BusyStatusFlag

Set while a poll is currently in progress, otherwise cleared.

enumerator kCAPT_XMAXStatusFlag

The maximum number of X pins available for a given device is equal to XMAX+1.

enum _capt_trigger_mode

The enumeration for CAPT trigger mode.

Values:

enumerator kCAPT_YHPortTriggerMode

YH port pin trigger mode.

enumerator kCAPT_ComparatorTriggerMode

Analog comparator trigger mode.

enum _capt_inactive_xpins_mode

The enumeration for the inactive X pins mode.

Values:

enumerator kCAPT_InactiveXpinsHighZMode

Xpins enabled in the XPINSEL field are controlled to HIGH-Z mode when not active.

enumerator kCAPT_InactiveXpinsDrivenLowMode

Xpins enabled in the XPINSEL field are controlled to be driven low mode when not active.

enum _capt_measurement_delay

The enumeration for the delay of measuring voltage state.

Values:

enumerator kCAPT_MeasureDelayNoWait

Don’t wait.

enumerator kCAPT_MeasureDelayWait3FCLKs

Wait 3 divided FCLKs.

enumerator kCAPT_MeasureDelayWait5FCLKs

Wait 5 divided FCLKs.

enumerator kCAPT_MeasureDelayWait9FCLKs

Wait 9 divided FCLKs.

enum _capt_reset_delay

The enumeration for the delay of reseting or draining Cap.

Values:

enumerator kCAPT_ResetDelayNoWait

Don’t wait.

enumerator kCAPT_ResetDelayWait3FCLKs

Wait 3 divided FCLKs.

enumerator kCAPT_ResetDelayWait5FCLKs

Wait 5 divided FCLKs.

enumerator kCAPT_ResetDelayWait9FCLKs

Wait 9 divided FCLKs.

enum _capt_polling_mode

The enumeration of CAPT polling mode.

Values:

enumerator kCAPT_PollInactiveMode

No measurements are taken, no polls are performed. The module remains in the Reset/ Draining Cap.

enumerator kCAPT_PollNowMode

Immediately launches (ignoring Poll Delay) a one-time-only, simultaneous poll of all X pins that are enabled in the XPINSEL field of the Control register, then stops, returning to Reset/Draining Cap.

enumerator kCAPT_PollContinuousMode

Polling rounds are continuously performed, by walking through the enabled X pins.

enum _capt_dma_mode

The enumeration of CAPT DMA trigger mode.

Values:

enumerator kCAPT_DMATriggerOnTouchMode

Trigger on touch.

enumerator kCAPT_DMATriggerOnBothMode

Trigger on both touch and no-touch.

enumerator kCAPT_DMATriggerOnAllMode

Trigger on all touch, no-touch and time-out.

typedef enum _capt_trigger_mode capt_trigger_mode_t

The enumeration for CAPT trigger mode.

typedef enum _capt_inactive_xpins_mode capt_inactive_xpins_mode_t

The enumeration for the inactive X pins mode.

typedef enum _capt_measurement_delay capt_measurement_delay_t

The enumeration for the delay of measuring voltage state.

typedef enum _capt_reset_delay capt_reset_delay_t

The enumeration for the delay of reseting or draining Cap.

typedef enum _capt_polling_mode capt_polling_mode_t

The enumeration of CAPT polling mode.

typedef enum _capt_dma_mode capt_dma_mode_t

The enumeration of CAPT DMA trigger mode.

typedef struct _capt_config capt_config_t

The structure for CAPT basic configuration.

typedef struct _capt_touch_data capt_touch_data_t

The structure for storing touch data.

CAPT_GET_XMAX_NUMBER(mask)
struct _capt_config
#include <fsl_capt.h>

The structure for CAPT basic configuration.

Public Members

bool enableWaitMode

If enable the wait mode, when the touch event occurs, the module will wait until the TOUCH register is read before starting the next measurement. Other-wise, measurements continue.

bool enableTouchLower

enableTouchLower = true: Trigger at count < TCNT is a touch. Trigger at count > TCNT is a no-touch. enableTouchLower = false: Trigger at count > TCNT is a touch. Trigger at count < TCNT is a no-touch. Notice: TCNT will be set by “CAPT_DoCalibration” API.

uint8_t clockDivider

Function clock divider. The function clock is divided by clockDivider+1 to produce the divided FCLK for the module. The available range is 0-15.

uint8_t timeOutCount

Sets the count value at which a time-out event occurs if a measurement has not triggered. The time-out count value is calculated as 2^timeOutCount. The available range is 0-12.

uint8_t pollCount

Sets the time delay between polling rounds (successive sets of X measurements). After each polling round completes, the module will wait 4096 x PollCount divided FCLKs before starting the next polling round. The available range is 0-255.

uint16_t enableXpins

Selects which of the available X pins are enabled. Please refer to ‘_capt_xpins’. For example, if want to enable X0, X2 and X3 pins, you can set “enableXpins = kCAPT_X0Pin

| kCAPT_X2Pin

| kCAPT_X3Pin”.

capt_trigger_mode_t triggerMode

Select the menthods of measuring the voltage across the measurement capacitor.

capt_inactive_xpins_mode_t XpinsMode

Determines how X pins enabled in the XPINSEL field are controlled when not active.

capt_measurement_delay_t mDelay

Set the time delay after entering step 3 (measure voltage state), before sampling the YH port pin or analog comarator output.

capt_reset_delay_t rDelay

Set the number of divided FCLKs the module will remain in Reset or Draining Cap.

struct _capt_touch_data
#include <fsl_capt.h>

The structure for storing touch data.

Public Members

bool yesTimeOut

‘true’: if the measurement resulted in a time-out event, ‘false’: otherwise.

bool yesTouch

‘true’: if the trigger is due to a touch even, ‘false’: if the trigger is due to a no-touch event.

uint8_t XpinsIndex

Contains the index of the X pin for the current measurement, or lowest X for a multiple-pin poll now measurement.

uint8_t sequenceNumber

Contains the 4-bit(0-7) sequence number, which increments at the end of each polling round.

uint16_t count

Contains the count value reached at trigger or time-out.

Clock Driver

enum _clock_ip_name

Clock gate name used for CLOCK_EnableClock/CLOCK_DisableClock.

Values:

enumerator kCLOCK_IpInvalid

Invalid Ip Name.

enumerator kCLOCK_Sys

Clock gate name: Sys.

enumerator kCLOCK_Rom

Clock gate name: Rom.

enumerator kCLOCK_Ram0

Clock gate name: Ram0.

enumerator kCLOCK_Flash

Clock gate name: Flash.

enumerator kCLOCK_I2c0

Clock gate name: I2c0.

enumerator kCLOCK_Gpio0

Clock gate name: Gpio0.

enumerator kCLOCK_Swm

Clock gate name: Swm.

enumerator kCLOCK_Wkt

Clock gate name: Wkt.

enumerator kCLOCK_Mrt

Clock gate name: Mrt.

enumerator kCLOCK_Spi0

Clock gate name: Spi0.

enumerator kCLOCK_Crc

Clock gate name: Crc.

enumerator kCLOCK_Uart0

Clock gate name: Uart0.

enumerator kCLOCK_Uart1

Clock gate name: Uart1.

enumerator kCLOCK_Wwdt

Clock gate name: Wwdt.

enumerator kCLOCK_Iocon

Clock gate name: Iocon.

enumerator kCLOCK_Acmp

Clock gate name: Acmp.

enumerator kCLOCK_I2c1

Clock gate name: I2c1.

enumerator kCLOCK_Adc

Clock gate name: Adc.

enumerator kCLOCK_Ctimer0

Clock gate name: Ctimer0.

enumerator kCLOCK_Dac

Clock gate name: Dac.

enumerator kCLOCK_GpioInt

Clock gate name: GpioInt.

enumerator kCLOCK_Capt

Clock gate name: Capt.

enumerator kCLOCK_PLU

Clock gate name: PLU.

enum _clock_name

Clock name used to get clock frequency.

Values:

enumerator kCLOCK_CoreSysClk

Cpu/AHB/AHB matrix/Memories,etc

enumerator kCLOCK_MainClk

Main clock

enumerator kCLOCK_Fro

FRO18/24/30

enumerator kCLOCK_FroDiv

FRO div clock

enumerator kCLOCK_ExtClk

External Clock

enumerator kCLOCK_LPOsc

Watchdog Oscillator

enumerator kCLOCK_Frg0

fractional rate0

enum _clock_select

Clock Mux Switches CLK_MUX_DEFINE(reg, mux) reg is used to define the mux register mux is used to define the mux value.

Values:

enumerator kCAPT_Clk_From_Fro

Mux CAPT_Clk from Fro.

enumerator kCAPT_Clk_From_MainClk

Mux CAPT_Clk from MainClk.

enumerator kCAPT_Clk_From_Fro_Div

Mux CAPT_Clk from Fro_Div.

enumerator kCAPT_Clk_From_LPOsc

Mux CAPT_Clk from LPOsc.

enumerator kADC_Clk_From_Fro

Mux ADC_Clk from Fro.

enumerator kADC_Clk_From_Extclk

Mux ADC_Clk from Extclk.

enumerator kUART0_Clk_From_Fro

Mux UART0_Clk from Fro.

enumerator kUART0_Clk_From_MainClk

Mux UART0_Clk from MainClk.

enumerator kUART0_Clk_From_Frg0Clk

Mux UART0_Clk from Frg0Clk.

enumerator kUART0_Clk_From_Fro_Div

Mux UART0_Clk from Fro_Div.

enumerator kUART1_Clk_From_Fro

Mux UART1_Clk from Fro.

enumerator kUART1_Clk_From_MainClk

Mux UART1_Clk from MainClk.

enumerator kUART1_Clk_From_Frg0Clk

Mux UART1_Clk from Frg0Clk.

enumerator kUART1_Clk_From_Fro_Div

Mux UART1_Clk from Fro_Div.

enumerator kI2C0_Clk_From_Fro

Mux I2C0_Clk from Fro.

enumerator kI2C0_Clk_From_MainClk

Mux I2C0_Clk from MainClk.

enumerator kI2C0_Clk_From_Frg0Clk

Mux I2C0_Clk from Frg0Clk.

enumerator kI2C0_Clk_From_Fro_Div

Mux I2C0_Clk from Fro_Div.

enumerator kI2C1_Clk_From_Fro

Mux I2C1_Clk from Fro.

enumerator kI2C1_Clk_From_MainClk

Mux I2C1_Clk from MainClk.

enumerator kI2C1_Clk_From_Frg0Clk

Mux I2C1_Clk from Frg0Clk.

enumerator kI2C1_Clk_From_Fro_Div

Mux I2C1_Clk from Fro_Div.

enumerator kSPI0_Clk_From_Fro

Mux SPI0_Clk from Fro.

enumerator kSPI0_Clk_From_MainClk

Mux SPI0_Clk from MainClk.

enumerator kSPI0_Clk_From_Frg0Clk

Mux SPI0_Clk from Frg0Clk.

enumerator kSPI0_Clk_From_Fro_Div

Mux SPI0_Clk from Fro_Div.

enumerator kFRG0_Clk_From_Fro

Mux FRG0_Clk from Fro.

enumerator kFRG0_Clk_From_MainClk

Mux FRG0_Clk from MainClk.

enumerator kCLKOUT_From_Fro

Mux CLKOUT from Fro.

enumerator kCLKOUT_From_MainClk

Mux CLKOUT from MainClk.

enumerator kCLKOUT_From_ExtClk

Mux CLKOUT from ExtClk.

enumerator kCLKOUT_From_Lposc

Mux CLKOUT from Lposc.

enum _clock_divider

Clock divider.

Values:

enumerator kCLOCK_DivAhbClk

Ahb Clock Divider.

enumerator kCLOCK_DivAdcClk

Adc Clock Divider.

enumerator kCLOCK_DivClkOut

Clk Out Divider.

enum _clock_fro_osc_freq

fro output frequency source definition

fro oscillator output frequency value definition

Values:

enumerator kCLOCK_FroOscOut18M

FRO oscillator output 18M

enumerator kCLOCK_FroOscOut24M

FRO oscillator output 24M

enumerator kCLOCK_FroOscOut30M

FRO oscillator output 30M

enum _clock_main_clk_src

PLL clock definition.

< Main clock source definition

Values:

enumerator kCLOCK_MainClkSrcFro

main clock source from FRO

enumerator kCLOCK_MainClkSrcExtClk

main clock source from Ext clock

enumerator kCLOCK_MainClkSrcLPOsc

main clock source from lower power oscillator

enumerator kCLOCK_MainClkSrcFroDiv

main clock source from FRO Div

typedef enum _clock_ip_name clock_ip_name_t

Clock gate name used for CLOCK_EnableClock/CLOCK_DisableClock.

typedef enum _clock_name clock_name_t

Clock name used to get clock frequency.

typedef enum _clock_select clock_select_t

Clock Mux Switches CLK_MUX_DEFINE(reg, mux) reg is used to define the mux register mux is used to define the mux value.

typedef enum _clock_divider clock_divider_t

Clock divider.

typedef enum _clock_fro_osc_freq clock_fro_osc_freq_t

fro output frequency source definition

fro oscillator output frequency value definition

typedef enum _clock_main_clk_src clock_main_clk_src_t

PLL clock definition.

< Main clock source definition

volatile uint32_t g_LP_Osc_Freq

lower power oscilltor clock frequency.

This variable is used to store the lower power oscillator frequency which is set by CLOCK_InitLPOsc, and it is returned by CLOCK_GetLPOscFreq.

volatile uint32_t g_Ext_Clk_Freq

external clock frequency.

This variable is used to store the external clock frequency which is include external oscillator clock and external clk in clock frequency value, it is set by CLOCK_InitExtClkin when CLK IN is used as external clock or by CLOCK_InitSysOsc when external oscillator is used as external clock ,and it is returned by CLOCK_GetExtClkFreq.

volatile uint32_t g_Fro_Osc_Freq

external clock frequency.

This variable is used to store the FRO osc clock frequency.

FSL_CLOCK_DRIVER_VERSION

CLOCK driver version 2.3.3.

SDK_DEVICE_MAXIMUM_CPU_CLOCK_FREQUENCY
CLOCK_FRO_SETTING_API_ROM_ADDRESS

FRO clock setting API address in ROM.

CLOCK_FAIM_BASE

FAIM base address.

ADC_CLOCKS

Clock ip name array for ADC.

ACMP_CLOCKS

Clock ip name array for ACMP.

DAC_CLOCKS

Clock ip name array for DAC.

SWM_CLOCKS

Clock ip name array for SWM.

ROM_CLOCKS

Clock ip name array for ROM.

SRAM_CLOCKS

Clock ip name array for SRAM.

IOCON_CLOCKS

Clock ip name array for IOCON.

GPIO_CLOCKS

Clock ip name array for GPIO.

GPIO_INT_CLOCKS

Clock ip name array for GPIO_INT.

CRC_CLOCKS

Clock ip name array for CRC.

WWDT_CLOCKS

Clock ip name array for WWDT.

SCT_CLOCKS

Clock ip name array for SCT0.

I2C_CLOCKS

Clock ip name array for I2C.

USART_CLOCKS

Clock ip name array for I2C.

SPI_CLOCKS

Clock ip name array for SPI.

CAPT_CLOCKS

Clock ip name array for CAPT.

CTIMER_CLOCKS

Clock ip name array for CTIMER.

MRT_CLOCKS

Clock ip name array for MRT.

WKT_CLOCKS

Clock ip name array for WKT.

PLU_CLOCKS

Clock ip name array for PLU.

CLK_GATE_DEFINE(reg, bit)

Internal used Clock definition only.

CLK_GATE_GET_REG(x)
CLK_GATE_GET_BITS_SHIFT(x)
CLK_MUX_DEFINE(reg, mux)
CLK_MUX_GET_REG(x)
CLK_MUX_GET_MUX(x)
CLK_MAIN_CLK_MUX_DEFINE(preMux, mux)
CLK_MAIN_CLK_MUX_GET_PRE_MUX(x)
CLK_MAIN_CLK_MUX_GET_MUX(x)
CLK_DIV_DEFINE(reg)
CLK_DIV_GET_REG(x)
CLK_FRG_DIV_REG_MAP(base)
CLK_FRG_MUL_REG_MAP(base)
CLK_FRG_SEL_REG_MAP(base)
SYS_AHB_CLK_CTRL0
SYS_AHB_CLK_CTRL1
static inline void CLOCK_EnableClock(clock_ip_name_t clk)
static inline void CLOCK_DisableClock(clock_ip_name_t clk)
static inline void CLOCK_Select(clock_select_t sel)
static inline void CLOCK_SetClkDivider(clock_divider_t name, uint32_t value)
static inline uint32_t CLOCK_GetClkDivider(clock_divider_t name)
static inline void CLOCK_SetCoreSysClkDiv(uint32_t value)
void CLOCK_SetMainClkSrc(clock_main_clk_src_t src)

Set main clock reference source.

Parameters:
  • src – Reference clock_main_clk_src_t to set the main clock source.

static inline void CLOCK_SetFRGClkMul(uint32_t *base, uint32_t mul)
uint32_t CLOCK_GetFRG0ClkFreq(void)

Return Frequency of FRG0 Clock.

Returns:

Frequency of FRG0 Clock.

uint32_t CLOCK_GetMainClkFreq(void)

Return Frequency of Main Clock.

Returns:

Frequency of Main Clock.

uint32_t CLOCK_GetFroFreq(void)

Return Frequency of FRO.

Returns:

Frequency of FRO.

static inline uint32_t CLOCK_GetCoreSysClkFreq(void)

Return Frequency of core.

Returns:

Frequency of core.

uint32_t CLOCK_GetClockOutClkFreq(void)

Return Frequency of ClockOut.

Returns:

Frequency of ClockOut

uint32_t CLOCK_GetUart0ClkFreq(void)

Get UART0 frequency.

Return values:

UART0 – frequency value.

uint32_t CLOCK_GetUart1ClkFreq(void)

Get UART1 frequency.

Return values:

UART1 – frequency value.

uint32_t CLOCK_GetFreq(clock_name_t clockName)

Return Frequency of selected clock.

Returns:

Frequency of selected clock

static inline uint32_t CLOCK_GetLPOscFreq(void)

Get watch dog OSC frequency.

Return values:

watch – dog OSC frequency value.

static inline uint32_t CLOCK_GetExtClkFreq(void)

Get external clock frequency.

Return values:

external – clock frequency value.

bool CLOCK_SetFRG0ClkFreq(uint32_t freq)

Set FRG0 output frequency.

Parameters:
  • freq – target output frequency,freq < input and (input / freq) < 2 should be satisfy.

Return values:

true – - successfully, false - input argument is invalid.

void CLOCK_InitExtClkin(uint32_t clkInFreq)

Init external CLK IN, select the CLKIN as the external clock source.

Parameters:
  • clkInFreq – external clock in frequency.

static inline void CLOCK_DeinitLpOsc(void)

Deinit watch dog OSC.

void CLOCK_SetFroOscFreq(clock_fro_osc_freq_t freq)

Set FRO oscillator output frequency. Initialize the FRO clock to given frequency (18, 24 or 30 MHz).

Parameters:
  • freq – Please refer to definition of clock_fro_osc_freq_t, frequency must be one of 18000, 24000 or 30000 KHz.

CRC: Cyclic Redundancy Check Driver

FSL_CRC_DRIVER_VERSION

CRC driver version. Version 2.1.1.

Current version: 2.1.1

Change log:

  • Version 2.0.0

    • initial version

  • Version 2.0.1

    • add explicit type cast when writing to WR_DATA

  • Version 2.0.2

    • Fix MISRA issue

  • Version 2.1.0

    • Add CRC_WriteSeed function

  • Version 2.1.1

    • Fix MISRA issue

enum _crc_polynomial

CRC polynomials to use.

Values:

enumerator kCRC_Polynomial_CRC_CCITT

x^16+x^12+x^5+1

enumerator kCRC_Polynomial_CRC_16

x^16+x^15+x^2+1

enumerator kCRC_Polynomial_CRC_32

x^32+x^26+x^23+x^22+x^16+x^12+x^11+x^10+x^8+x^7+x^5+x^4+x^2+x+1

typedef enum _crc_polynomial crc_polynomial_t

CRC polynomials to use.

typedef struct _crc_config crc_config_t

CRC protocol configuration.

This structure holds the configuration for the CRC protocol.

void CRC_Init(CRC_Type *base, const crc_config_t *config)

Enables and configures the CRC peripheral module.

This functions enables the CRC peripheral clock in the LPC SYSCON block. It also configures the CRC engine and starts checksum computation by writing the seed.

Parameters:
  • base – CRC peripheral address.

  • config – CRC module configuration structure.

static inline void CRC_Deinit(CRC_Type *base)

Disables the CRC peripheral module.

This functions disables the CRC peripheral clock in the LPC SYSCON block.

Parameters:
  • base – CRC peripheral address.

void CRC_Reset(CRC_Type *base)

resets CRC peripheral module.

Parameters:
  • base – CRC peripheral address.

void CRC_WriteSeed(CRC_Type *base, uint32_t seed)

Write seed to CRC peripheral module.

Parameters:
  • base – CRC peripheral address.

  • seed – CRC Seed value.

void CRC_GetDefaultConfig(crc_config_t *config)

Loads default values to CRC protocol configuration structure.

Loads default values to CRC protocol configuration structure. The default values are:

config->polynomial = kCRC_Polynomial_CRC_CCITT;
config->reverseIn = false;
config->complementIn = false;
config->reverseOut = false;
config->complementOut = false;
config->seed = 0xFFFFU;

Parameters:
  • config – CRC protocol configuration structure

void CRC_GetConfig(CRC_Type *base, crc_config_t *config)

Loads actual values configured in CRC peripheral to CRC protocol configuration structure.

The values, including seed, can be used to resume CRC calculation later.

Parameters:
  • base – CRC peripheral address.

  • config – CRC protocol configuration structure

void CRC_WriteData(CRC_Type *base, const uint8_t *data, size_t dataSize)

Writes data to the CRC module.

Writes input data buffer bytes to CRC data register.

Parameters:
  • base – CRC peripheral address.

  • data – Input data stream, MSByte in data[0].

  • dataSize – Size of the input data buffer in bytes.

static inline uint32_t CRC_Get32bitResult(CRC_Type *base)

Reads 32-bit checksum from the CRC module.

Reads CRC data register.

Parameters:
  • base – CRC peripheral address.

Returns:

final 32-bit checksum, after configured bit reverse and complement operations.

static inline uint16_t CRC_Get16bitResult(CRC_Type *base)

Reads 16-bit checksum from the CRC module.

Reads CRC data register.

Parameters:
  • base – CRC peripheral address.

Returns:

final 16-bit checksum, after configured bit reverse and complement operations.

CRC_DRIVER_USE_CRC16_CCITT_FALSE_AS_DEFAULT

Default configuration structure filled by CRC_GetDefaultConfig(). Uses CRC-16/CCITT-FALSE as default.

struct _crc_config
#include <fsl_crc.h>

CRC protocol configuration.

This structure holds the configuration for the CRC protocol.

Public Members

crc_polynomial_t polynomial

CRC polynomial.

bool reverseIn

Reverse bits on input.

bool complementIn

Perform 1’s complement on input.

bool reverseOut

Reverse bits on output.

bool complementOut

Perform 1’s complement on output.

uint32_t seed

Starting checksum value.

CTIMER: Standard counter/timers

void CTIMER_Init(CTIMER_Type *base, const ctimer_config_t *config)

Ungates the clock and configures the peripheral for basic operation.

Note

This API should be called at the beginning of the application before using the driver.

Parameters:
  • base – Ctimer peripheral base address

  • config – Pointer to the user configuration structure.

void CTIMER_Deinit(CTIMER_Type *base)

Gates the timer clock.

Parameters:
  • base – Ctimer peripheral base address

void CTIMER_GetDefaultConfig(ctimer_config_t *config)

Fills in the timers configuration structure with the default settings.

The default values are:

config->mode = kCTIMER_TimerMode;
config->input = kCTIMER_Capture_0;
config->prescale = 0;

Parameters:
  • config – Pointer to the user configuration structure.

status_t CTIMER_SetupPwmPeriod(CTIMER_Type *base, const ctimer_match_t pwmPeriodChannel, ctimer_match_t matchChannel, uint32_t pwmPeriod, uint32_t pulsePeriod, bool enableInt)

Configures the PWM signal parameters.

Enables PWM mode on the match channel passed in and will then setup the match value and other match parameters to generate a PWM signal. This function can manually assign the specified channel to set the PWM cycle.

Note

When setting PWM output from multiple output pins, all should use the same PWM period

Parameters:
  • base – Ctimer peripheral base address

  • pwmPeriodChannel – Specify the channel to control the PWM period

  • matchChannel – Match pin to be used to output the PWM signal

  • pwmPeriod – PWM period match value

  • pulsePeriod – Pulse width match value

  • enableInt – Enable interrupt when the timer value reaches the match value of the PWM pulse, if it is 0 then no interrupt will be generated.

Returns:

kStatus_Success on success kStatus_Fail If matchChannel is equal to pwmPeriodChannel; this channel is reserved to set the PWM cycle If PWM pulse width register value is larger than 0xFFFFFFFF.

status_t CTIMER_SetupPwm(CTIMER_Type *base, const ctimer_match_t pwmPeriodChannel, ctimer_match_t matchChannel, uint8_t dutyCyclePercent, uint32_t pwmFreq_Hz, uint32_t srcClock_Hz, bool enableInt)

Configures the PWM signal parameters.

Enables PWM mode on the match channel passed in and will then setup the match value and other match parameters to generate a PWM signal. This function can manually assign the specified channel to set the PWM cycle.

Note

When setting PWM output from multiple output pins, all should use the same PWM frequency. Please use CTIMER_SetupPwmPeriod to set up the PWM with high resolution.

Parameters:
  • base – Ctimer peripheral base address

  • pwmPeriodChannel – Specify the channel to control the PWM period

  • matchChannel – Match pin to be used to output the PWM signal

  • dutyCyclePercent – PWM pulse width; the value should be between 0 to 100

  • pwmFreq_Hz – PWM signal frequency in Hz

  • srcClock_Hz – Timer counter clock in Hz

  • enableInt – Enable interrupt when the timer value reaches the match value of the PWM pulse, if it is 0 then no interrupt will be generated.

static inline void CTIMER_UpdatePwmPulsePeriod(CTIMER_Type *base, ctimer_match_t matchChannel, uint32_t pulsePeriod)

Updates the pulse period of an active PWM signal.

Parameters:
  • base – Ctimer peripheral base address

  • matchChannel – Match pin to be used to output the PWM signal

  • pulsePeriod – New PWM pulse width match value

status_t CTIMER_UpdatePwmDutycycle(CTIMER_Type *base, const ctimer_match_t pwmPeriodChannel, ctimer_match_t matchChannel, uint8_t dutyCyclePercent)

Updates the duty cycle of an active PWM signal.

Note

Please use CTIMER_SetupPwmPeriod to update the PWM with high resolution. This function can manually assign the specified channel to set the PWM cycle.

Parameters:
  • base – Ctimer peripheral base address

  • pwmPeriodChannel – Specify the channel to control the PWM period

  • matchChannel – Match pin to be used to output the PWM signal

  • dutyCyclePercent – New PWM pulse width; the value should be between 0 to 100

Returns:

kStatus_Success on success kStatus_Fail If PWM pulse width register value is larger than 0xFFFFFFFF.

static inline void CTIMER_EnableInterrupts(CTIMER_Type *base, uint32_t mask)

Enables the selected Timer interrupts.

Parameters:
  • base – Ctimer peripheral base address

  • mask – The interrupts to enable. This is a logical OR of members of the enumeration ctimer_interrupt_enable_t

static inline void CTIMER_DisableInterrupts(CTIMER_Type *base, uint32_t mask)

Disables the selected Timer interrupts.

Parameters:
  • base – Ctimer peripheral base address

  • mask – The interrupts to enable. This is a logical OR of members of the enumeration ctimer_interrupt_enable_t

static inline uint32_t CTIMER_GetEnabledInterrupts(CTIMER_Type *base)

Gets the enabled Timer interrupts.

Parameters:
  • base – Ctimer peripheral base address

Returns:

The enabled interrupts. This is the logical OR of members of the enumeration ctimer_interrupt_enable_t

static inline uint32_t CTIMER_GetStatusFlags(CTIMER_Type *base)

Gets the Timer status flags.

Parameters:
  • base – Ctimer peripheral base address

Returns:

The status flags. This is the logical OR of members of the enumeration ctimer_status_flags_t

static inline void CTIMER_ClearStatusFlags(CTIMER_Type *base, uint32_t mask)

Clears the Timer status flags.

Parameters:
  • base – Ctimer peripheral base address

  • mask – The status flags to clear. This is a logical OR of members of the enumeration ctimer_status_flags_t

static inline void CTIMER_StartTimer(CTIMER_Type *base)

Starts the Timer counter.

Parameters:
  • base – Ctimer peripheral base address

static inline void CTIMER_StopTimer(CTIMER_Type *base)

Stops the Timer counter.

Parameters:
  • base – Ctimer peripheral base address

FSL_CTIMER_DRIVER_VERSION

Version 2.3.3

enum _ctimer_capture_channel

List of Timer capture channels.

Values:

enumerator kCTIMER_Capture_0

Timer capture channel 0

enumerator kCTIMER_Capture_1

Timer capture channel 1

enumerator kCTIMER_Capture_3

Timer capture channel 3

enum _ctimer_capture_edge

List of capture edge options.

Values:

enumerator kCTIMER_Capture_RiseEdge

Capture on rising edge

enumerator kCTIMER_Capture_FallEdge

Capture on falling edge

enumerator kCTIMER_Capture_BothEdge

Capture on rising and falling edge

enum _ctimer_match

List of Timer match registers.

Values:

enumerator kCTIMER_Match_0

Timer match register 0

enumerator kCTIMER_Match_1

Timer match register 1

enumerator kCTIMER_Match_2

Timer match register 2

enumerator kCTIMER_Match_3

Timer match register 3

enum _ctimer_external_match

List of external match.

Values:

enumerator kCTIMER_External_Match_0

External match 0

enumerator kCTIMER_External_Match_1

External match 1

enumerator kCTIMER_External_Match_2

External match 2

enumerator kCTIMER_External_Match_3

External match 3

enum _ctimer_match_output_control

List of output control options.

Values:

enumerator kCTIMER_Output_NoAction

No action is taken

enumerator kCTIMER_Output_Clear

Clear the EM bit/output to 0

enumerator kCTIMER_Output_Set

Set the EM bit/output to 1

enumerator kCTIMER_Output_Toggle

Toggle the EM bit/output

enum _ctimer_timer_mode

List of Timer modes.

Values:

enumerator kCTIMER_TimerMode
enumerator kCTIMER_IncreaseOnRiseEdge
enumerator kCTIMER_IncreaseOnFallEdge
enumerator kCTIMER_IncreaseOnBothEdge
enum _ctimer_interrupt_enable

List of Timer interrupts.

Values:

enumerator kCTIMER_Match0InterruptEnable

Match 0 interrupt

enumerator kCTIMER_Match1InterruptEnable

Match 1 interrupt

enumerator kCTIMER_Match2InterruptEnable

Match 2 interrupt

enumerator kCTIMER_Match3InterruptEnable

Match 3 interrupt

enum _ctimer_status_flags

List of Timer flags.

Values:

enumerator kCTIMER_Match0Flag

Match 0 interrupt flag

enumerator kCTIMER_Match1Flag

Match 1 interrupt flag

enumerator kCTIMER_Match2Flag

Match 2 interrupt flag

enumerator kCTIMER_Match3Flag

Match 3 interrupt flag

enum ctimer_callback_type_t

Callback type when registering for a callback. When registering a callback an array of function pointers is passed the size could be 1 or 8, the callback type will tell that.

Values:

enumerator kCTIMER_SingleCallback

Single Callback type where there is only one callback for the timer. based on the status flags different channels needs to be handled differently

enumerator kCTIMER_MultipleCallback

Multiple Callback type where there can be 8 valid callbacks, one per channel. for both match/capture

typedef enum _ctimer_capture_channel ctimer_capture_channel_t

List of Timer capture channels.

typedef enum _ctimer_capture_edge ctimer_capture_edge_t

List of capture edge options.

typedef enum _ctimer_match ctimer_match_t

List of Timer match registers.

typedef enum _ctimer_external_match ctimer_external_match_t

List of external match.

typedef enum _ctimer_match_output_control ctimer_match_output_control_t

List of output control options.

typedef enum _ctimer_timer_mode ctimer_timer_mode_t

List of Timer modes.

typedef enum _ctimer_interrupt_enable ctimer_interrupt_enable_t

List of Timer interrupts.

typedef enum _ctimer_status_flags ctimer_status_flags_t

List of Timer flags.

typedef void (*ctimer_callback_t)(uint32_t flags)
typedef struct _ctimer_match_config ctimer_match_config_t

Match configuration.

This structure holds the configuration settings for each match register.

typedef struct _ctimer_config ctimer_config_t

Timer configuration structure.

This structure holds the configuration settings for the Timer peripheral. To initialize this structure to reasonable defaults, call the CTIMER_GetDefaultConfig() function and pass a pointer to the configuration structure instance.

The configuration structure can be made constant so as to reside in flash.

void CTIMER_SetupMatch(CTIMER_Type *base, ctimer_match_t matchChannel, const ctimer_match_config_t *config)

Setup the match register.

User configuration is used to setup the match value and action to be taken when a match occurs.

Parameters:
  • base – Ctimer peripheral base address

  • matchChannel – Match register to configure

  • config – Pointer to the match configuration structure

uint32_t CTIMER_GetOutputMatchStatus(CTIMER_Type *base, uint32_t matchChannel)

Get the status of output match.

This function gets the status of output MAT, whether or not this output is connected to a pin. This status is driven to the MAT pins if the match function is selected via IOCON. 0 = LOW. 1 = HIGH.

Parameters:
  • base – Ctimer peripheral base address

  • matchChannel – External match channel, user can obtain the status of multiple match channels at the same time by using the logic of “|” enumeration ctimer_external_match_t

Returns:

The mask of external match channel status flags. Users need to use the _ctimer_external_match type to decode the return variables.

void CTIMER_SetupCapture(CTIMER_Type *base, ctimer_capture_channel_t capture, ctimer_capture_edge_t edge, bool enableInt)

Setup the capture.

Parameters:
  • base – Ctimer peripheral base address

  • capture – Capture channel to configure

  • edge – Edge on the channel that will trigger a capture

  • enableInt – Flag to enable channel interrupts, if enabled then the registered call back is called upon capture

static inline uint32_t CTIMER_GetTimerCountValue(CTIMER_Type *base)

Get the timer count value from TC register.

Parameters:
  • base – Ctimer peripheral base address.

Returns:

return the timer count value.

void CTIMER_RegisterCallBack(CTIMER_Type *base, ctimer_callback_t *cb_func, ctimer_callback_type_t cb_type)

Register callback.

Parameters:
  • base – Ctimer peripheral base address

  • cb_func – callback function

  • cb_type – callback function type, singular or multiple

static inline void CTIMER_Reset(CTIMER_Type *base)

Reset the counter.

The timer counter and prescale counter are reset on the next positive edge of the APB clock.

Parameters:
  • base – Ctimer peripheral base address

static inline void CTIMER_SetPrescale(CTIMER_Type *base, uint32_t prescale)

Setup the timer prescale value.

Specifies the maximum value for the Prescale Counter.

Parameters:
  • base – Ctimer peripheral base address

  • prescale – Prescale value

static inline uint32_t CTIMER_GetCaptureValue(CTIMER_Type *base, ctimer_capture_channel_t capture)

Get capture channel value.

Get the counter/timer value on the corresponding capture channel.

Parameters:
  • base – Ctimer peripheral base address

  • capture – Select capture channel

Returns:

The timer count capture value.

static inline void CTIMER_EnableResetMatchChannel(CTIMER_Type *base, ctimer_match_t match, bool enable)

Enable reset match channel.

Set the specified match channel reset operation.

Parameters:
  • base – Ctimer peripheral base address

  • match – match channel used

  • enable – Enable match channel reset operation.

static inline void CTIMER_EnableStopMatchChannel(CTIMER_Type *base, ctimer_match_t match, bool enable)

Enable stop match channel.

Set the specified match channel stop operation.

Parameters:
  • base – Ctimer peripheral base address.

  • match – match channel used.

  • enable – Enable match channel stop operation.

static inline void CTIMER_EnableMatchChannelReload(CTIMER_Type *base, ctimer_match_t match, bool enable)

Enable reload channel falling edge.

Enable the specified match channel reload match shadow value.

Parameters:
  • base – Ctimer peripheral base address.

  • match – match channel used.

  • enable – Enable .

static inline void CTIMER_EnableRisingEdgeCapture(CTIMER_Type *base, ctimer_capture_channel_t capture, bool enable)

Enable capture channel rising edge.

Sets the specified capture channel for rising edge capture.

Parameters:
  • base – Ctimer peripheral base address.

  • capture – capture channel used.

  • enable – Enable rising edge capture.

static inline void CTIMER_EnableFallingEdgeCapture(CTIMER_Type *base, ctimer_capture_channel_t capture, bool enable)

Enable capture channel falling edge.

Sets the specified capture channel for falling edge capture.

Parameters:
  • base – Ctimer peripheral base address.

  • capture – capture channel used.

  • enable – Enable falling edge capture.

static inline void CTIMER_SetShadowValue(CTIMER_Type *base, ctimer_match_t match, uint32_t matchvalue)

Set the specified match shadow channel.

Parameters:
  • base – Ctimer peripheral base address.

  • match – match channel used.

  • matchvalue – Reload the value of the corresponding match register.

struct _ctimer_match_config
#include <fsl_ctimer.h>

Match configuration.

This structure holds the configuration settings for each match register.

Public Members

uint32_t matchValue

This is stored in the match register

bool enableCounterReset

true: Match will reset the counter false: Match will not reser the counter

bool enableCounterStop

true: Match will stop the counter false: Match will not stop the counter

ctimer_match_output_control_t outControl

Action to be taken on a match on the EM bit/output

bool outPinInitState

Initial value of the EM bit/output

bool enableInterrupt

true: Generate interrupt upon match false: Do not generate interrupt on match

struct _ctimer_config
#include <fsl_ctimer.h>

Timer configuration structure.

This structure holds the configuration settings for the Timer peripheral. To initialize this structure to reasonable defaults, call the CTIMER_GetDefaultConfig() function and pass a pointer to the configuration structure instance.

The configuration structure can be made constant so as to reside in flash.

Public Members

ctimer_timer_mode_t mode

Timer mode

ctimer_capture_channel_t input

Input channel to increment the timer, used only in timer modes that rely on this input signal to increment TC

uint32_t prescale

Prescale value

I2C: Inter-Integrated Circuit Driver

I2C Driver

FSL_I2C_DRIVER_VERSION

I2C driver version.

I2C status return codes.

Values:

enumerator kStatus_I2C_Busy

The master is already performing a transfer.

enumerator kStatus_I2C_Idle

The slave driver is idle.

enumerator kStatus_I2C_Nak

The slave device sent a NAK in response to a byte.

enumerator kStatus_I2C_InvalidParameter

Unable to proceed due to invalid parameter.

enumerator kStatus_I2C_BitError

Transferred bit was not seen on the bus.

enumerator kStatus_I2C_ArbitrationLost

Arbitration lost error.

enumerator kStatus_I2C_NoTransferInProgress

Attempt to abort a transfer when one is not in progress.

enumerator kStatus_I2C_DmaRequestFail

DMA request failed.

enumerator kStatus_I2C_StartStopError

Start and stop error.

enumerator kStatus_I2C_UnexpectedState

Unexpected state.

enumerator kStatus_I2C_Addr_Nak

NAK received during the address probe.

enumerator kStatus_I2C_Timeout

Timeout polling status flags.

I2C_RETRY_TIMES

Retry times for waiting flag.

I2C_STAT_MSTCODE_IDLE

Master Idle State Code

I2C_STAT_MSTCODE_RXREADY

Master Receive Ready State Code

I2C_STAT_MSTCODE_TXREADY

Master Transmit Ready State Code

I2C_STAT_MSTCODE_NACKADR

Master NACK by slave on address State Code

I2C_STAT_MSTCODE_NACKDAT

Master NACK by slave on data State Code

I2C_STAT_SLVST_ADDR
I2C_STAT_SLVST_RX
I2C_STAT_SLVST_TX

I2C Master Driver

void I2C_MasterGetDefaultConfig(i2c_master_config_t *masterConfig)

Provides a default configuration for the I2C master peripheral.

This function provides the following default configuration for the I2C master peripheral:

masterConfig->enableMaster            = true;
masterConfig->baudRate_Bps            = 100000U;
masterConfig->enableTimeout           = false;

After calling this function, you can override any settings in order to customize the configuration, prior to initializing the master driver with I2C_MasterInit().

Parameters:
  • masterConfig[out] User provided configuration structure for default values. Refer to i2c_master_config_t.

void I2C_MasterInit(I2C_Type *base, const i2c_master_config_t *masterConfig, uint32_t srcClock_Hz)

Initializes the I2C master peripheral.

This function enables the peripheral clock and initializes the I2C master peripheral as described by the user provided configuration. A software reset is performed prior to configuration.

Parameters:
  • base – The I2C peripheral base address.

  • masterConfig – User provided peripheral configuration. Use I2C_MasterGetDefaultConfig() to get a set of defaults that you can override.

  • srcClock_Hz – Frequency in Hertz of the I2C functional clock. Used to calculate the baud rate divisors, filter widths, and timeout periods.

void I2C_MasterDeinit(I2C_Type *base)

Deinitializes the I2C master peripheral.

This function disables the I2C master peripheral and gates the clock. It also performs a software reset to restore the peripheral to reset conditions.

Parameters:
  • base – The I2C peripheral base address.

uint32_t I2C_GetInstance(I2C_Type *base)

Returns an instance number given a base address.

If an invalid base address is passed, debug builds will assert. Release builds will just return instance number 0.

Parameters:
  • base – The I2C peripheral base address.

Returns:

I2C instance number starting from 0.

static inline void I2C_MasterReset(I2C_Type *base)

Performs a software reset.

Restores the I2C master peripheral to reset conditions.

Parameters:
  • base – The I2C peripheral base address.

static inline void I2C_MasterEnable(I2C_Type *base, bool enable)

Enables or disables the I2C module as master.

Parameters:
  • base – The I2C peripheral base address.

  • enable – Pass true to enable or false to disable the specified I2C as master.

static inline uint32_t I2C_GetStatusFlags(I2C_Type *base)

Gets the I2C status flags.

A bit mask with the state of all I2C status flags is returned. For each flag, the corresponding bit in the return value is set if the flag is asserted.

See also

_i2c_master_flags

Parameters:
  • base – The I2C peripheral base address.

Returns:

State of the status flags:

  • 1: related status flag is set.

  • 0: related status flag is not set.

static inline void I2C_MasterClearStatusFlags(I2C_Type *base, uint32_t statusMask)

Clears the I2C master status flag state.

The following status register flags can be cleared:

  • kI2C_MasterArbitrationLostFlag

  • kI2C_MasterStartStopErrorFlag

Attempts to clear other flags has no effect.

See also

_i2c_master_flags.

Parameters:
  • base – The I2C peripheral base address.

  • statusMask – A bitmask of status flags that are to be cleared. The mask is composed of _i2c_master_flags enumerators OR’d together. You may pass the result of a previous call to I2C_GetStatusFlags().

static inline void I2C_EnableInterrupts(I2C_Type *base, uint32_t interruptMask)

Enables the I2C master interrupt requests.

Parameters:
  • base – The I2C peripheral base address.

  • interruptMask – Bit mask of interrupts to enable. See _i2c_master_flags for the set of constants that should be OR’d together to form the bit mask.

static inline void I2C_DisableInterrupts(I2C_Type *base, uint32_t interruptMask)

Disables the I2C master interrupt requests.

Parameters:
  • base – The I2C peripheral base address.

  • interruptMask – Bit mask of interrupts to disable. See _i2c_master_flags for the set of constants that should be OR’d together to form the bit mask.

static inline uint32_t I2C_GetEnabledInterrupts(I2C_Type *base)

Returns the set of currently enabled I2C master interrupt requests.

Parameters:
  • base – The I2C peripheral base address.

Returns:

A bitmask composed of _i2c_master_flags enumerators OR’d together to indicate the set of enabled interrupts.

void I2C_MasterSetBaudRate(I2C_Type *base, uint32_t baudRate_Bps, uint32_t srcClock_Hz)

Sets the I2C bus frequency for master transactions.

The I2C master is automatically disabled and re-enabled as necessary to configure the baud rate. Do not call this function during a transfer, or the transfer is aborted.

Parameters:
  • base – The I2C peripheral base address.

  • srcClock_Hz – I2C functional clock frequency in Hertz.

  • baudRate_Bps – Requested bus frequency in bits per second.

static inline bool I2C_MasterGetBusIdleState(I2C_Type *base)

Returns whether the bus is idle.

Requires the master mode to be enabled.

Parameters:
  • base – The I2C peripheral base address.

Return values:
  • true – Bus is busy.

  • false – Bus is idle.

status_t I2C_MasterStart(I2C_Type *base, uint8_t address, i2c_direction_t direction)

Sends a START on the I2C bus.

This function is used to initiate a new master mode transfer by sending the START signal. The slave address is sent following the I2C START signal.

Parameters:
  • base – I2C peripheral base pointer

  • address – 7-bit slave device address.

  • direction – Master transfer directions(transmit/receive).

Return values:
  • kStatus_Success – Successfully send the start signal.

  • kStatus_I2C_Busy – Current bus is busy.

status_t I2C_MasterStop(I2C_Type *base)

Sends a STOP signal on the I2C bus.

Return values:
  • kStatus_Success – Successfully send the stop signal.

  • kStatus_I2C_Timeout – Send stop signal failed, timeout.

static inline status_t I2C_MasterRepeatedStart(I2C_Type *base, uint8_t address, i2c_direction_t direction)

Sends a REPEATED START on the I2C bus.

Parameters:
  • base – I2C peripheral base pointer

  • address – 7-bit slave device address.

  • direction – Master transfer directions(transmit/receive).

Return values:
  • kStatus_Success – Successfully send the start signal.

  • kStatus_I2C_Busy – Current bus is busy but not occupied by current I2C master.

status_t I2C_MasterWriteBlocking(I2C_Type *base, const void *txBuff, size_t txSize, uint32_t flags)

Performs a polling send transfer on the I2C bus.

Sends up to txSize number of bytes to the previously addressed slave device. The slave may reply with a NAK to any byte in order to terminate the transfer early. If this happens, this function returns kStatus_I2C_Nak.

Parameters:
  • base – The I2C peripheral base address.

  • txBuff – The pointer to the data to be transferred.

  • txSize – The length in bytes of the data to be transferred.

  • flags – Transfer control flag to control special behavior like suppressing start or stop, for normal transfers use kI2C_TransferDefaultFlag

Return values:
  • kStatus_Success – Data was sent successfully.

  • kStatus_I2C_Busy – Another master is currently utilizing the bus.

  • kStatus_I2C_Nak – The slave device sent a NAK in response to a byte.

  • kStatus_I2C_ArbitrationLost – Arbitration lost error.

status_t I2C_MasterReadBlocking(I2C_Type *base, void *rxBuff, size_t rxSize, uint32_t flags)

Performs a polling receive transfer on the I2C bus.

Parameters:
  • base – The I2C peripheral base address.

  • rxBuff – The pointer to the data to be transferred.

  • rxSize – The length in bytes of the data to be transferred.

  • flags – Transfer control flag to control special behavior like suppressing start or stop, for normal transfers use kI2C_TransferDefaultFlag

Return values:
  • kStatus_Success – Data was received successfully.

  • kStatus_I2C_Busy – Another master is currently utilizing the bus.

  • kStatus_I2C_Nak – The slave device sent a NAK in response to a byte.

  • kStatus_I2C_ArbitrationLost – Arbitration lost error.

status_t I2C_MasterTransferBlocking(I2C_Type *base, i2c_master_transfer_t *xfer)

Performs a master polling transfer on the I2C bus.

Note

The API does not return until the transfer succeeds or fails due to arbitration lost or receiving a NAK.

Parameters:
  • base – I2C peripheral base address.

  • xfer – Pointer to the transfer structure.

Return values:
  • kStatus_Success – Successfully complete the data transmission.

  • kStatus_I2C_Busy – Previous transmission still not finished.

  • kStatus_I2C_Timeout – Transfer error, wait signal timeout.

  • kStatus_I2C_ArbitrationLost – Transfer error, arbitration lost.

  • kStataus_I2C_Nak – Transfer error, receive NAK during transfer.

void I2C_MasterTransferCreateHandle(I2C_Type *base, i2c_master_handle_t *handle, i2c_master_transfer_callback_t callback, void *userData)

Creates a new handle for the I2C master non-blocking APIs.

The creation of a handle is for use with the non-blocking APIs. Once a handle is created, there is not a corresponding destroy handle. If the user wants to terminate a transfer, the I2C_MasterTransferAbort() API shall be called.

Parameters:
  • base – The I2C peripheral base address.

  • handle[out] Pointer to the I2C master driver handle.

  • callback – User provided pointer to the asynchronous callback function.

  • userData – User provided pointer to the application callback data.

status_t I2C_MasterTransferNonBlocking(I2C_Type *base, i2c_master_handle_t *handle, i2c_master_transfer_t *xfer)

Performs a non-blocking transaction on the I2C bus.

Parameters:
  • base – The I2C peripheral base address.

  • handle – Pointer to the I2C master driver handle.

  • xfer – The pointer to the transfer descriptor.

Return values:
  • kStatus_Success – The transaction was started successfully.

  • kStatus_I2C_Busy – Either another master is currently utilizing the bus, or a non-blocking transaction is already in progress.

status_t I2C_MasterTransferGetCount(I2C_Type *base, i2c_master_handle_t *handle, size_t *count)

Returns number of bytes transferred so far.

Parameters:
  • base – The I2C peripheral base address.

  • handle – Pointer to the I2C master driver handle.

  • count[out] Number of bytes transferred so far by the non-blocking transaction.

Return values:
  • kStatus_Success

  • kStatus_I2C_Busy

status_t I2C_MasterTransferAbort(I2C_Type *base, i2c_master_handle_t *handle)

Terminates a non-blocking I2C master transmission early.

Note

It is not safe to call this function from an IRQ handler that has a higher priority than the I2C peripheral’s IRQ priority.

Parameters:
  • base – The I2C peripheral base address.

  • handle – Pointer to the I2C master driver handle.

Return values:
  • kStatus_Success – A transaction was successfully aborted.

  • kStatus_I2C_Timeout – Abort failure due to flags polling timeout.

void I2C_MasterTransferHandleIRQ(I2C_Type *base, void *i2cHandle)

Reusable routine to handle master interrupts.

Note

This function does not need to be called unless you are reimplementing the nonblocking API’s interrupt handler routines to add special functionality.

Parameters:
  • base – The I2C peripheral base address.

  • i2cHandle – Pointer to the I2C master driver handle i2c_master_handle_t.

enum _i2c_master_flags

I2C master peripheral flags.

Note

These enums are meant to be OR’d together to form a bit mask.

Values:

enumerator kI2C_MasterPendingFlag

The I2C module is waiting for software interaction.

enumerator kI2C_MasterArbitrationLostFlag

The arbitration of the bus was lost. There was collision on the bus

enumerator kI2C_MasterStartStopErrorFlag

There was an error during start or stop phase of the transaction.

enum _i2c_direction

Direction of master and slave transfers.

Values:

enumerator kI2C_Write

Master transmit.

enumerator kI2C_Read

Master receive.

enum _i2c_master_transfer_flags

Transfer option flags.

Note

These enumerations are intended to be OR’d together to form a bit mask of options for the _i2c_master_transfer::flags field.

Values:

enumerator kI2C_TransferDefaultFlag

Transfer starts with a start signal, stops with a stop signal.

enumerator kI2C_TransferNoStartFlag

Don’t send a start condition, address, and sub address

enumerator kI2C_TransferRepeatedStartFlag

Send a repeated start condition

enumerator kI2C_TransferNoStopFlag

Don’t send a stop condition.

enum _i2c_transfer_states

States for the state machine used by transactional APIs.

Values:

enumerator kIdleState
enumerator kTransmitSubaddrState
enumerator kTransmitDataState
enumerator kReceiveDataBeginState
enumerator kReceiveDataState
enumerator kReceiveLastDataState
enumerator kStartState
enumerator kStopState
enumerator kWaitForCompletionState
typedef enum _i2c_direction i2c_direction_t

Direction of master and slave transfers.

typedef struct _i2c_master_config i2c_master_config_t

Structure with settings to initialize the I2C master module.

This structure holds configuration settings for the I2C peripheral. To initialize this structure to reasonable defaults, call the I2C_MasterGetDefaultConfig() function and pass a pointer to your configuration structure instance.

The configuration structure can be made constant so it resides in flash.

typedef struct _i2c_master_transfer i2c_master_transfer_t

I2C master transfer typedef.

typedef struct _i2c_master_handle i2c_master_handle_t

I2C master handle typedef.

typedef void (*i2c_master_transfer_callback_t)(I2C_Type *base, i2c_master_handle_t *handle, status_t completionStatus, void *userData)

Master completion callback function pointer type.

This callback is used only for the non-blocking master transfer API. Specify the callback you wish to use in the call to I2C_MasterTransferCreateHandle().

Param base:

The I2C peripheral base address.

Param completionStatus:

Either kStatus_Success or an error code describing how the transfer completed.

Param userData:

Arbitrary pointer-sized value passed from the application.

struct _i2c_master_config
#include <fsl_i2c.h>

Structure with settings to initialize the I2C master module.

This structure holds configuration settings for the I2C peripheral. To initialize this structure to reasonable defaults, call the I2C_MasterGetDefaultConfig() function and pass a pointer to your configuration structure instance.

The configuration structure can be made constant so it resides in flash.

Public Members

bool enableMaster

Whether to enable master mode.

uint32_t baudRate_Bps

Desired baud rate in bits per second.

bool enableTimeout

Enable internal timeout function.

struct _i2c_master_transfer
#include <fsl_i2c.h>

Non-blocking transfer descriptor structure.

This structure is used to pass transaction parameters to the I2C_MasterTransferNonBlocking() API.

Public Members

uint32_t flags

Bit mask of options for the transfer. See enumeration _i2c_master_transfer_flags for available options. Set to 0 or kI2C_TransferDefaultFlag for normal transfers.

uint16_t slaveAddress

The 7-bit slave address.

i2c_direction_t direction

Either kI2C_Read or kI2C_Write.

uint32_t subaddress

Sub address. Transferred MSB first.

size_t subaddressSize

Length of sub address to send in bytes. Maximum size is 4 bytes.

void *data

Pointer to data to transfer.

size_t dataSize

Number of bytes to transfer.

struct _i2c_master_handle
#include <fsl_i2c.h>

Driver handle for master non-blocking APIs.

Note

The contents of this structure are private and subject to change.

Public Members

uint8_t state

Transfer state machine current state.

uint32_t transferCount

Indicates progress of the transfer

uint32_t remainingBytes

Remaining byte count in current state.

uint8_t *buf

Buffer pointer for current state.

i2c_master_transfer_t transfer

Copy of the current transfer info.

i2c_master_transfer_callback_t completionCallback

Callback function pointer.

void *userData

Application data passed to callback.

I2C Slave Driver

void I2C_SlaveGetDefaultConfig(i2c_slave_config_t *slaveConfig)

Provides a default configuration for the I2C slave peripheral.

This function provides the following default configuration for the I2C slave peripheral:

slaveConfig->enableSlave = true;
slaveConfig->address0.disable = false;
slaveConfig->address0.address = 0u;
slaveConfig->address1.disable = true;
slaveConfig->address2.disable = true;
slaveConfig->address3.disable = true;
slaveConfig->busSpeed = kI2C_SlaveStandardMode;

After calling this function, override any settings to customize the configuration, prior to initializing the master driver with I2C_SlaveInit(). Be sure to override at least the address0.address member of the configuration structure with the desired slave address.

Parameters:
  • slaveConfig[out] User provided configuration structure that is set to default values. Refer to i2c_slave_config_t.

status_t I2C_SlaveInit(I2C_Type *base, const i2c_slave_config_t *slaveConfig, uint32_t srcClock_Hz)

Initializes the I2C slave peripheral.

This function enables the peripheral clock and initializes the I2C slave peripheral as described by the user provided configuration.

Parameters:
  • base – The I2C peripheral base address.

  • slaveConfig – User provided peripheral configuration. Use I2C_SlaveGetDefaultConfig() to get a set of defaults that you can override.

  • srcClock_Hz – Frequency in Hertz of the I2C functional clock. Used to calculate CLKDIV value to provide enough data setup time for master when slave stretches the clock.

void I2C_SlaveSetAddress(I2C_Type *base, i2c_slave_address_register_t addressRegister, uint8_t address, bool addressDisable)

Configures Slave Address n register.

This function writes new value to Slave Address register.

Parameters:
  • base – The I2C peripheral base address.

  • addressRegister – The module supports multiple address registers. The parameter determines which one shall be changed.

  • address – The slave address to be stored to the address register for matching.

  • addressDisable – Disable matching of the specified address register.

void I2C_SlaveDeinit(I2C_Type *base)

Deinitializes the I2C slave peripheral.

This function disables the I2C slave peripheral and gates the clock. It also performs a software reset to restore the peripheral to reset conditions.

Parameters:
  • base – The I2C peripheral base address.

static inline void I2C_SlaveEnable(I2C_Type *base, bool enable)

Enables or disables the I2C module as slave.

Parameters:
  • base – The I2C peripheral base address.

  • enable – True to enable or flase to disable.

static inline void I2C_SlaveClearStatusFlags(I2C_Type *base, uint32_t statusMask)

Clears the I2C status flag state.

The following status register flags can be cleared:

  • slave deselected flag

Attempts to clear other flags has no effect.

See also

_i2c_slave_flags.

Parameters:
  • base – The I2C peripheral base address.

  • statusMask – A bitmask of status flags that are to be cleared. The mask is composed of _i2c_slave_flags enumerators OR’d together. You may pass the result of a previous call to I2C_SlaveGetStatusFlags().

status_t I2C_SlaveWriteBlocking(I2C_Type *base, const uint8_t *txBuff, size_t txSize)

Performs a polling send transfer on the I2C bus.

The function executes blocking address phase and blocking data phase.

Parameters:
  • base – The I2C peripheral base address.

  • txBuff – The pointer to the data to be transferred.

  • txSize – The length in bytes of the data to be transferred.

Returns:

kStatus_Success Data has been sent.

Returns:

kStatus_Fail Unexpected slave state (master data write while master read from slave is expected).

status_t I2C_SlaveReadBlocking(I2C_Type *base, uint8_t *rxBuff, size_t rxSize)

Performs a polling receive transfer on the I2C bus.

The function executes blocking address phase and blocking data phase.

Parameters:
  • base – The I2C peripheral base address.

  • rxBuff – The pointer to the data to be transferred.

  • rxSize – The length in bytes of the data to be transferred.

Returns:

kStatus_Success Data has been received.

Returns:

kStatus_Fail Unexpected slave state (master data read while master write to slave is expected).

void I2C_SlaveTransferCreateHandle(I2C_Type *base, i2c_slave_handle_t *handle, i2c_slave_transfer_callback_t callback, void *userData)

Creates a new handle for the I2C slave non-blocking APIs.

The creation of a handle is for use with the non-blocking APIs. Once a handle is created, there is not a corresponding destroy handle. If the user wants to terminate a transfer, the I2C_SlaveTransferAbort() API shall be called.

Parameters:
  • base – The I2C peripheral base address.

  • handle[out] Pointer to the I2C slave driver handle.

  • callback – User provided pointer to the asynchronous callback function.

  • userData – User provided pointer to the application callback data.

status_t I2C_SlaveTransferNonBlocking(I2C_Type *base, i2c_slave_handle_t *handle, uint32_t eventMask)

Starts accepting slave transfers.

Call this API after calling I2C_SlaveInit() and I2C_SlaveTransferCreateHandle() to start processing transactions driven by an I2C master. The slave monitors the I2C bus and pass events to the callback that was passed into the call to I2C_SlaveTransferCreateHandle(). The callback is always invoked from the interrupt context.

If no slave Tx transfer is busy, a master read from slave request invokes kI2C_SlaveTransmitEvent callback. If no slave Rx transfer is busy, a master write to slave request invokes kI2C_SlaveReceiveEvent callback.

The set of events received by the callback is customizable. To do so, set the eventMask parameter to the OR’d combination of i2c_slave_transfer_event_t enumerators for the events you wish to receive. The kI2C_SlaveTransmitEvent and kI2C_SlaveReceiveEvent events are always enabled and do not need to be included in the mask. Alternatively, you can pass 0 to get a default set of only the transmit and receive events that are always enabled. In addition, the kI2C_SlaveAllEvents constant is provided as a convenient way to enable all events.

Parameters:
  • base – The I2C peripheral base address.

  • handle – Pointer to i2c_slave_handle_t structure which stores the transfer state.

  • eventMask – Bit mask formed by OR’ing together i2c_slave_transfer_event_t enumerators to specify which events to send to the callback. Other accepted values are 0 to get a default set of only the transmit and receive events, and kI2C_SlaveAllEvents to enable all events.

Return values:
  • kStatus_Success – Slave transfers were successfully started.

  • kStatus_I2C_Busy – Slave transfers have already been started on this handle.

status_t I2C_SlaveSetSendBuffer(I2C_Type *base, volatile i2c_slave_transfer_t *transfer, const void *txData, size_t txSize, uint32_t eventMask)

Starts accepting master read from slave requests.

The function can be called in response to kI2C_SlaveTransmitEvent callback to start a new slave Tx transfer from within the transfer callback.

The set of events received by the callback is customizable. To do so, set the eventMask parameter to the OR’d combination of i2c_slave_transfer_event_t enumerators for the events you wish to receive. The kI2C_SlaveTransmitEvent and kI2C_SlaveReceiveEvent events are always enabled and do not need to be included in the mask. Alternatively, you can pass 0 to get a default set of only the transmit and receive events that are always enabled. In addition, the kI2C_SlaveAllEvents constant is provided as a convenient way to enable all events.

Parameters:
  • base – The I2C peripheral base address.

  • transfer – Pointer to i2c_slave_transfer_t structure.

  • txData – Pointer to data to send to master.

  • txSize – Size of txData in bytes.

  • eventMask – Bit mask formed by OR’ing together i2c_slave_transfer_event_t enumerators to specify which events to send to the callback. Other accepted values are 0 to get a default set of only the transmit and receive events, and kI2C_SlaveAllEvents to enable all events.

Return values:
  • kStatus_Success – Slave transfers were successfully started.

  • kStatus_I2C_Busy – Slave transfers have already been started on this handle.

status_t I2C_SlaveSetReceiveBuffer(I2C_Type *base, volatile i2c_slave_transfer_t *transfer, void *rxData, size_t rxSize, uint32_t eventMask)

Starts accepting master write to slave requests.

The function can be called in response to kI2C_SlaveReceiveEvent callback to start a new slave Rx transfer from within the transfer callback.

The set of events received by the callback is customizable. To do so, set the eventMask parameter to the OR’d combination of i2c_slave_transfer_event_t enumerators for the events you wish to receive. The kI2C_SlaveTransmitEvent and kI2C_SlaveReceiveEvent events are always enabled and do not need to be included in the mask. Alternatively, you can pass 0 to get a default set of only the transmit and receive events that are always enabled. In addition, the kI2C_SlaveAllEvents constant is provided as a convenient way to enable all events.

Parameters:
  • base – The I2C peripheral base address.

  • transfer – Pointer to i2c_slave_transfer_t structure.

  • rxData – Pointer to data to store data from master.

  • rxSize – Size of rxData in bytes.

  • eventMask – Bit mask formed by OR’ing together i2c_slave_transfer_event_t enumerators to specify which events to send to the callback. Other accepted values are 0 to get a default set of only the transmit and receive events, and kI2C_SlaveAllEvents to enable all events.

Return values:
  • kStatus_Success – Slave transfers were successfully started.

  • kStatus_I2C_Busy – Slave transfers have already been started on this handle.

static inline uint32_t I2C_SlaveGetReceivedAddress(I2C_Type *base, volatile i2c_slave_transfer_t *transfer)

Returns the slave address sent by the I2C master.

This function should only be called from the address match event callback kI2C_SlaveAddressMatchEvent.

Parameters:
  • base – The I2C peripheral base address.

  • transfer – The I2C slave transfer.

Returns:

The 8-bit address matched by the I2C slave. Bit 0 contains the R/w direction bit, and the 7-bit slave address is in the upper 7 bits.

void I2C_SlaveTransferAbort(I2C_Type *base, i2c_slave_handle_t *handle)

Aborts the slave non-blocking transfers.

Note

This API could be called at any time to stop slave for handling the bus events.

Parameters:
  • base – The I2C peripheral base address.

  • handle – Pointer to i2c_slave_handle_t structure which stores the transfer state.

Return values:
  • kStatus_Success

  • kStatus_I2C_Idle

status_t I2C_SlaveTransferGetCount(I2C_Type *base, i2c_slave_handle_t *handle, size_t *count)

Gets the slave transfer remaining bytes during a interrupt non-blocking transfer.

Parameters:
  • base – I2C base pointer.

  • handle – pointer to i2c_slave_handle_t structure.

  • count – Number of bytes transferred so far by the non-blocking transaction.

Return values:
  • kStatus_InvalidArgument – count is Invalid.

  • kStatus_Success – Successfully return the count.

void I2C_SlaveTransferHandleIRQ(I2C_Type *base, void *i2cHandle)

Reusable routine to handle slave interrupts.

Note

This function does not need to be called unless you are reimplementing the non blocking API’s interrupt handler routines to add special functionality.

Parameters:
  • base – The I2C peripheral base address.

  • i2cHandle – Pointer to i2c_slave_handle_t structure which stores the transfer state.

enum _i2c_slave_flags

I2C slave peripheral flags.

Note

These enums are meant to be OR’d together to form a bit mask.

Values:

enumerator kI2C_SlavePendingFlag

The I2C module is waiting for software interaction.

enumerator kI2C_SlaveNotStretching

Indicates whether the slave is currently stretching clock (0 = yes, 1 = no).

enumerator kI2C_SlaveSelected

Indicates whether the slave is selected by an address match.

enumerator kI2C_SaveDeselected

Indicates that slave was previously deselected (deselect event took place, w1c).

enum _i2c_slave_address_register

I2C slave address register.

Values:

enumerator kI2C_SlaveAddressRegister0

Slave Address 0 register.

enumerator kI2C_SlaveAddressRegister1

Slave Address 1 register.

enumerator kI2C_SlaveAddressRegister2

Slave Address 2 register.

enumerator kI2C_SlaveAddressRegister3

Slave Address 3 register.

enum _i2c_slave_address_qual_mode

I2C slave address match options.

Values:

enumerator kI2C_QualModeMask

The SLVQUAL0 field (qualAddress) is used as a logical mask for matching address0.

enumerator kI2C_QualModeExtend

The SLVQUAL0 (qualAddress) field is used to extend address 0 matching in a range of addresses.

enum _i2c_slave_bus_speed

I2C slave bus speed options.

Values:

enumerator kI2C_SlaveStandardMode
enumerator kI2C_SlaveFastMode
enumerator kI2C_SlaveFastModePlus
enumerator kI2C_SlaveHsMode
enum _i2c_slave_transfer_event

Set of events sent to the callback for non blocking slave transfers.

These event enumerations are used for two related purposes. First, a bit mask created by OR’ing together events is passed to I2C_SlaveTransferNonBlocking() in order to specify which events to enable. Then, when the slave callback is invoked, it is passed the current event through its transfer parameter.

Note

These enumerations are meant to be OR’d together to form a bit mask of events.

Values:

enumerator kI2C_SlaveAddressMatchEvent

Received the slave address after a start or repeated start.

enumerator kI2C_SlaveTransmitEvent

Callback is requested to provide data to transmit (slave-transmitter role).

enumerator kI2C_SlaveReceiveEvent

Callback is requested to provide a buffer in which to place received data (slave-receiver role).

enumerator kI2C_SlaveCompletionEvent

All data in the active transfer have been consumed.

enumerator kI2C_SlaveDeselectedEvent

The slave function has become deselected (SLVSEL flag changing from 1 to 0.

enumerator kI2C_SlaveAllEvents

Bit mask of all available events.

enum _i2c_slave_fsm

I2C slave software finite state machine states.

Values:

enumerator kI2C_SlaveFsmAddressMatch
enumerator kI2C_SlaveFsmReceive
enumerator kI2C_SlaveFsmTransmit
typedef enum _i2c_slave_address_register i2c_slave_address_register_t

I2C slave address register.

typedef struct _i2c_slave_address i2c_slave_address_t

Data structure with 7-bit Slave address and Slave address disable.

typedef enum _i2c_slave_address_qual_mode i2c_slave_address_qual_mode_t

I2C slave address match options.

typedef enum _i2c_slave_bus_speed i2c_slave_bus_speed_t

I2C slave bus speed options.

typedef struct _i2c_slave_config i2c_slave_config_t

Structure with settings to initialize the I2C slave module.

This structure holds configuration settings for the I2C slave peripheral. To initialize this structure to reasonable defaults, call the I2C_SlaveGetDefaultConfig() function and pass a pointer to your configuration structure instance.

The configuration structure can be made constant so it resides in flash.

typedef enum _i2c_slave_transfer_event i2c_slave_transfer_event_t

Set of events sent to the callback for non blocking slave transfers.

These event enumerations are used for two related purposes. First, a bit mask created by OR’ing together events is passed to I2C_SlaveTransferNonBlocking() in order to specify which events to enable. Then, when the slave callback is invoked, it is passed the current event through its transfer parameter.

Note

These enumerations are meant to be OR’d together to form a bit mask of events.

typedef struct _i2c_slave_handle i2c_slave_handle_t

I2C slave handle typedef.

typedef struct _i2c_slave_transfer i2c_slave_transfer_t

I2C slave transfer structure.

typedef void (*i2c_slave_transfer_callback_t)(I2C_Type *base, volatile i2c_slave_transfer_t *transfer, void *userData)

Slave event callback function pointer type.

This callback is used only for the slave non-blocking transfer API. To install a callback, use the I2C_SlaveSetCallback() function after you have created a handle.

Param base:

Base address for the I2C instance on which the event occurred.

Param transfer:

Pointer to transfer descriptor containing values passed to and/or from the callback.

Param userData:

Arbitrary pointer-sized value passed from the application.

typedef enum _i2c_slave_fsm i2c_slave_fsm_t

I2C slave software finite state machine states.

typedef void (*i2c_isr_t)(I2C_Type *base, void *i2cHandle)

Typedef for interrupt handler.

struct _i2c_slave_address
#include <fsl_i2c.h>

Data structure with 7-bit Slave address and Slave address disable.

Public Members

uint8_t address

7-bit Slave address SLVADR.

bool addressDisable

Slave address disable SADISABLE.

struct _i2c_slave_config
#include <fsl_i2c.h>

Structure with settings to initialize the I2C slave module.

This structure holds configuration settings for the I2C slave peripheral. To initialize this structure to reasonable defaults, call the I2C_SlaveGetDefaultConfig() function and pass a pointer to your configuration structure instance.

The configuration structure can be made constant so it resides in flash.

Public Members

i2c_slave_address_t address0

Slave’s 7-bit address and disable.

i2c_slave_address_t address1

Alternate slave 7-bit address and disable.

i2c_slave_address_t address2

Alternate slave 7-bit address and disable.

i2c_slave_address_t address3

Alternate slave 7-bit address and disable.

i2c_slave_address_qual_mode_t qualMode

Qualify mode for slave address 0.

uint8_t qualAddress

Slave address qualifier for address 0.

i2c_slave_bus_speed_t busSpeed

Slave bus speed mode. If the slave function stretches SCL to allow for software response, it must provide sufficient data setup time to the master before releasing the stretched clock. This is accomplished by inserting one clock time of CLKDIV at that point. The busSpeed value is used to configure CLKDIV such that one clock time is greater than the tSU;DAT value noted in the I2C bus specification for the I2C mode that is being used. If the busSpeed mode is unknown at compile time, use the longest data setup time kI2C_SlaveStandardMode (250 ns)

bool enableSlave

Enable slave mode.

struct _i2c_slave_transfer
#include <fsl_i2c.h>

I2C slave transfer structure.

Public Members

i2c_slave_handle_t *handle

Pointer to handle that contains this transfer.

i2c_slave_transfer_event_t event

Reason the callback is being invoked.

uint8_t receivedAddress

Matching address send by master. 7-bits plus R/nW bit0

uint32_t eventMask

Mask of enabled events.

uint8_t *rxData

Transfer buffer for receive data

const uint8_t *txData

Transfer buffer for transmit data

size_t txSize

Transfer size

size_t rxSize

Transfer size

size_t transferredCount

Number of bytes transferred during this transfer.

status_t completionStatus

Success or error code describing how the transfer completed. Only applies for kI2C_SlaveCompletionEvent.

struct _i2c_slave_handle
#include <fsl_i2c.h>

I2C slave handle structure.

Note

The contents of this structure are private and subject to change.

Public Members

volatile i2c_slave_transfer_t transfer

I2C slave transfer.

volatile bool isBusy

Whether transfer is busy.

volatile i2c_slave_fsm_t slaveFsm

slave transfer state machine.

i2c_slave_transfer_callback_t callback

Callback function called at transfer event.

void *userData

Callback parameter passed to callback.

IAP: In Application Programming Driver

status_t IAP_ReadPartID(uint32_t *partID)

Read part identification number.

This function is used to read the part identification number.

Parameters:
  • partID – Address to store the part identification number.

Return values:

kStatus_IAP_Success – Api has been executed successfully.

status_t IAP_ReadBootCodeVersion(uint32_t *bootCodeVersion)

Read boot code version number.

This function is used to read the boot code version number.

note Boot code version is two 32-bit words. Word 0 is the major version, word 1 is the minor version.

Parameters:
  • bootCodeVersion – Address to store the boot code version.

Return values:

kStatus_IAP_Success – Api has been executed successfully.

void IAP_ReinvokeISP(uint8_t ispType, uint32_t *status)

Reinvoke ISP.

This function is used to invoke the boot loader in ISP mode. It maps boot vectors and configures the peripherals for ISP.

note The error response will be returned when IAP is disabled or an invalid ISP type selection appears. The call won’t return unless an error occurs, so there can be no status code.

Parameters:
  • ispType – ISP type selection.

  • status – store the possible status.

Return values:

kStatus_IAP_ReinvokeISPConfig – reinvoke configuration error.

status_t IAP_ReadUniqueID(uint32_t *uniqueID)

Read unique identification.

This function is used to read the unique id.

Parameters:
  • uniqueID – store the uniqueID.

Return values:

kStatus_IAP_Success – Api has been executed successfully.

status_t IAP_PrepareSectorForWrite(uint32_t startSector, uint32_t endSector)

Prepare sector for write operation.

This function prepares sector(s) for write/erase operation. This function must be called before calling the IAP_CopyRamToFlash() or IAP_EraseSector() or IAP_ErasePage() function. The end sector number must be greater than or equal to the start sector number.

Parameters:
  • startSector – Start sector number.

  • endSector – End sector number.

Return values:
  • kStatus_IAP_Success – Api has been executed successfully.

  • kStatus_IAP_NoPower – Flash memory block is powered down.

  • kStatus_IAP_NoClock – Flash memory block or controller is not clocked.

  • kStatus_IAP_InvalidSector – Sector number is invalid or end sector number is greater than start sector number.

  • kStatus_IAP_Busy – Flash programming hardware interface is busy.

status_t IAP_CopyRamToFlash(uint32_t dstAddr, uint32_t *srcAddr, uint32_t numOfBytes, uint32_t systemCoreClock)

Copy RAM to flash.

This function programs the flash memory. Corresponding sectors must be prepared via IAP_PrepareSectorForWrite before calling this function.

Parameters:
  • dstAddr – Destination flash address where data bytes are to be written, the address should be multiples of FSL_FEATURE_SYSCON_FLASH_PAGE_SIZE_BYTES boundary.

  • srcAddr – Source ram address from where data bytes are to be read.

  • numOfBytes – Number of bytes to be written, it should be multiples of FSL_FEATURE_SYSCON_FLASH_PAGE_SIZE_BYTES, and ranges from FSL_FEATURE_SYSCON_FLASH_PAGE_SIZE_BYTES to FSL_FEATURE_SYSCON_FLASH_SECTOR_SIZE_BYTES.

  • systemCoreClock – SystemCoreClock in Hz. It is converted to KHz before calling the rom IAP function. When the flash controller has a fixed reference clock, this parameter is bypassed.

Return values:
  • kStatus_IAP_Success – Api has been executed successfully.

  • kStatus_IAP_NoPower – Flash memory block is powered down.

  • kStatus_IAP_NoClock – Flash memory block or controller is not clocked.

  • kStatus_IAP_SrcAddrError – Source address is not on word boundary.

  • kStatus_IAP_DstAddrError – Destination address is not on a correct boundary.

  • kStatus_IAP_SrcAddrNotMapped – Source address is not mapped in the memory map.

  • kStatus_IAP_DstAddrNotMapped – Destination address is not mapped in the memory map.

  • kStatus_IAP_CountError – Byte count is not multiple of 4 or is not a permitted value.

  • kStatus_IAP_NotPrepared – Command to prepare sector for write operation has not been executed.

  • kStatus_IAP_Busy – Flash programming hardware interface is busy.

status_t IAP_EraseSector(uint32_t startSector, uint32_t endSector, uint32_t systemCoreClock)

Erase sector.

This function erases sector(s). The end sector number must be greater than or equal to the start sector number.

Parameters:
  • startSector – Start sector number.

  • endSector – End sector number.

  • systemCoreClock – SystemCoreClock in Hz. It is converted to KHz before calling the rom IAP function. When the flash controller has a fixed reference clock, this parameter is bypassed.

Return values:
  • kStatus_IAP_Success – Api has been executed successfully.

  • kStatus_IAP_NoPower – Flash memory block is powered down.

  • kStatus_IAP_NoClock – Flash memory block or controller is not clocked.

  • kStatus_IAP_InvalidSector – Sector number is invalid or end sector number is greater than start sector number.

  • kStatus_IAP_NotPrepared – Command to prepare sector for write operation has not been executed.

  • kStatus_IAP_Busy – Flash programming hardware interface is busy.

status_t IAP_ErasePage(uint32_t startPage, uint32_t endPage, uint32_t systemCoreClock)

Erase page.

This function erases page(s). The end page number must be greater than or equal to the start page number.

Parameters:
  • startPage – Start page number.

  • endPage – End page number.

  • systemCoreClock – SystemCoreClock in Hz. It is converted to KHz before calling the rom IAP function. When the flash controller has a fixed reference clock, this parameter is bypassed.

Return values:
  • kStatus_IAP_Success – Api has been executed successfully.

  • kStatus_IAP_NoPower – Flash memory block is powered down.

  • kStatus_IAP_NoClock – Flash memory block or controller is not clocked.

  • kStatus_IAP_InvalidSector – Page number is invalid or end page number is greater than start page number.

  • kStatus_IAP_NotPrepared – Command to prepare sector for write operation has not been executed.

  • kStatus_IAP_Busy – Flash programming hardware interface is busy.

status_t IAP_BlankCheckSector(uint32_t startSector, uint32_t endSector)

Blank check sector(s)

Blank check single or multiples sectors of flash memory. The end sector number must be greater than or equal to the start sector number. It can be used to verify the sector erasure after IAP_EraseSector call.

Parameters:
  • startSector – Start sector number.

  • endSector – End sector number.

Return values:
  • kStatus_IAP_Success – One or more sectors are in erased state.

  • kStatus_IAP_NoPower – Flash memory block is powered down.

  • kStatus_IAP_NoClock – Flash memory block or controller is not clocked.

  • kStatus_IAP_SectorNotblank – One or more sectors are not blank.

status_t IAP_Compare(uint32_t dstAddr, uint32_t *srcAddr, uint32_t numOfBytes)

Compare memory contents of flash with ram.

This function compares the contents of flash and ram. It can be used to verify the flash memory contents after IAP_CopyRamToFlash call.

Parameters:
  • dstAddr – Destination flash address.

  • srcAddr – Source ram address.

  • numOfBytes – Number of bytes to be compared.

Return values:
  • kStatus_IAP_Success – Contents of flash and ram match.

  • kStatus_IAP_NoPower – Flash memory block is powered down.

  • kStatus_IAP_NoClock – Flash memory block or controller is not clocked.

  • kStatus_IAP_AddrError – Address is not on word boundary.

  • kStatus_IAP_AddrNotMapped – Address is not mapped in the memory map.

  • kStatus_IAP_CountError – Byte count is not multiple of 4 or is not a permitted value.

  • kStatus_IAP_CompareError – Destination and source memory contents do not match.

FSL_IAP_DRIVER_VERSION

iap status codes.

Values:

enumerator kStatus_IAP_Success

Api is executed successfully

enumerator kStatus_IAP_InvalidCommand

Invalid command

enumerator kStatus_IAP_SrcAddrError

Source address is not on word boundary

enumerator kStatus_IAP_DstAddrError

Destination address is not on a correct boundary

enumerator kStatus_IAP_SrcAddrNotMapped

Source address is not mapped in the memory map

enumerator kStatus_IAP_DstAddrNotMapped

Destination address is not mapped in the memory map

enumerator kStatus_IAP_CountError

Byte count is not multiple of 4 or is not a permitted value

enumerator kStatus_IAP_InvalidSector

Sector/page number is invalid or end sector/page number is greater than start sector/page number

enumerator kStatus_IAP_SectorNotblank

One or more sectors are not blank

enumerator kStatus_IAP_NotPrepared

Command to prepare sector for write operation has not been executed

enumerator kStatus_IAP_CompareError

Destination and source memory contents do not match

enumerator kStatus_IAP_Busy

Flash programming hardware interface is busy

enumerator kStatus_IAP_ParamError

Insufficient number of parameters or invalid parameter

enumerator kStatus_IAP_AddrError

Address is not on word boundary

enumerator kStatus_IAP_AddrNotMapped

Address is not mapped in the memory map

enumerator kStatus_IAP_NoPower

Flash memory block is powered down

enumerator kStatus_IAP_NoClock

Flash memory block or controller is not clocked

enumerator kStatus_IAP_ReinvokeISPConfig

Reinvoke configuration error

enum _iap_commands

iap command codes.

Values:

enumerator kIapCmd_IAP_ReadFactorySettings

Read the factory settings

enumerator kIapCmd_IAP_PrepareSectorforWrite

Prepare Sector for write

enumerator kIapCmd_IAP_CopyRamToFlash

Copy RAM to flash

enumerator kIapCmd_IAP_EraseSector

Erase Sector

enumerator kIapCmd_IAP_BlankCheckSector

Blank check sector

enumerator kIapCmd_IAP_ReadPartId

Read part id

enumerator kIapCmd_IAP_Read_BootromVersion

Read bootrom version

enumerator kIapCmd_IAP_Compare

Compare

enumerator kIapCmd_IAP_ReinvokeISP

Reinvoke ISP

enumerator kIapCmd_IAP_ReadUid

Read Uid

enumerator kIapCmd_IAP_ErasePage

Erase Page

enumerator kIapCmd_IAP_ReadSignature

Read Signature

enumerator kIapCmd_IAP_ExtendedReadSignature

Extended Read Signature

enumerator kIapCmd_IAP_ReadEEPROMPage

Read EEPROM page

enumerator kIapCmd_IAP_WriteEEPROMPage

Write EEPROM page

enum _flash_access_time

Flash memory access time.

Values:

enumerator kFlash_IAP_OneSystemClockTime
enumerator kFlash_IAP_TwoSystemClockTime

1 system clock flash access time

enumerator kFlash_IAP_ThreeSystemClockTime

2 system clock flash access time

Common Driver

FSL_COMMON_DRIVER_VERSION

common driver version.

DEBUG_CONSOLE_DEVICE_TYPE_NONE

No debug console.

DEBUG_CONSOLE_DEVICE_TYPE_UART

Debug console based on UART.

DEBUG_CONSOLE_DEVICE_TYPE_LPUART

Debug console based on LPUART.

DEBUG_CONSOLE_DEVICE_TYPE_LPSCI

Debug console based on LPSCI.

DEBUG_CONSOLE_DEVICE_TYPE_USBCDC

Debug console based on USBCDC.

DEBUG_CONSOLE_DEVICE_TYPE_FLEXCOMM

Debug console based on FLEXCOMM.

DEBUG_CONSOLE_DEVICE_TYPE_IUART

Debug console based on i.MX UART.

DEBUG_CONSOLE_DEVICE_TYPE_VUSART

Debug console based on LPC_VUSART.

DEBUG_CONSOLE_DEVICE_TYPE_MINI_USART

Debug console based on LPC_USART.

DEBUG_CONSOLE_DEVICE_TYPE_SWO

Debug console based on SWO.

DEBUG_CONSOLE_DEVICE_TYPE_QSCI

Debug console based on QSCI.

MIN(a, b)

Computes the minimum of a and b.

MAX(a, b)

Computes the maximum of a and b.

UINT16_MAX

Max value of uint16_t type.

UINT32_MAX

Max value of uint32_t type.

SDK_ATOMIC_LOCAL_ADD(addr, val)

Add value val from the variable at address address.

SDK_ATOMIC_LOCAL_SUB(addr, val)

Subtract value val to the variable at address address.

SDK_ATOMIC_LOCAL_SET(addr, bits)

Set the bits specifiled by bits to the variable at address address.

SDK_ATOMIC_LOCAL_CLEAR(addr, bits)

Clear the bits specifiled by bits to the variable at address address.

SDK_ATOMIC_LOCAL_TOGGLE(addr, bits)

Toggle the bits specifiled by bits to the variable at address address.

SDK_ATOMIC_LOCAL_CLEAR_AND_SET(addr, clearBits, setBits)

For the variable at address address, clear the bits specifiled by clearBits and set the bits specifiled by setBits.

SDK_ATOMIC_LOCAL_COMPARE_AND_SET(addr, expected, newValue)

For the variable at address address, check whether the value equal to expected. If value same as expected then update newValue to address and return true , else return false .

SDK_ATOMIC_LOCAL_TEST_AND_SET(addr, newValue)

For the variable at address address, set as newValue value and return old value.

USEC_TO_COUNT(us, clockFreqInHz)

Macro to convert a microsecond period to raw count value

COUNT_TO_USEC(count, clockFreqInHz)

Macro to convert a raw count value to microsecond

MSEC_TO_COUNT(ms, clockFreqInHz)

Macro to convert a millisecond period to raw count value

COUNT_TO_MSEC(count, clockFreqInHz)

Macro to convert a raw count value to millisecond

SDK_ISR_EXIT_BARRIER
SDK_SIZEALIGN(var, alignbytes)

Macro to define a variable with L1 d-cache line size alignment

Macro to define a variable with L2 cache line size alignment

Macro to change a value to a given size aligned value

AT_NONCACHEABLE_SECTION(var)

Define a variable var, and place it in non-cacheable section.

AT_NONCACHEABLE_SECTION_ALIGN(var, alignbytes)

Define a variable var, and place it in non-cacheable section, the start address of the variable is aligned to alignbytes.

AT_NONCACHEABLE_SECTION_INIT(var)

Define a variable var with initial value, and place it in non-cacheable section.

AT_NONCACHEABLE_SECTION_ALIGN_INIT(var, alignbytes)

Define a variable var with initial value, and place it in non-cacheable section, the start address of the variable is aligned to alignbytes.

enum _status_groups

Status group numbers.

Values:

enumerator kStatusGroup_Generic

Group number for generic status codes.

enumerator kStatusGroup_FLASH

Group number for FLASH status codes.

enumerator kStatusGroup_LPSPI

Group number for LPSPI status codes.

enumerator kStatusGroup_FLEXIO_SPI

Group number for FLEXIO SPI status codes.

enumerator kStatusGroup_DSPI

Group number for DSPI status codes.

enumerator kStatusGroup_FLEXIO_UART

Group number for FLEXIO UART status codes.

enumerator kStatusGroup_FLEXIO_I2C

Group number for FLEXIO I2C status codes.

enumerator kStatusGroup_LPI2C

Group number for LPI2C status codes.

enumerator kStatusGroup_UART

Group number for UART status codes.

enumerator kStatusGroup_I2C

Group number for UART status codes.

enumerator kStatusGroup_LPSCI

Group number for LPSCI status codes.

enumerator kStatusGroup_LPUART

Group number for LPUART status codes.

enumerator kStatusGroup_SPI

Group number for SPI status code.

enumerator kStatusGroup_XRDC

Group number for XRDC status code.

enumerator kStatusGroup_SEMA42

Group number for SEMA42 status code.

enumerator kStatusGroup_SDHC

Group number for SDHC status code

enumerator kStatusGroup_SDMMC

Group number for SDMMC status code

enumerator kStatusGroup_SAI

Group number for SAI status code

enumerator kStatusGroup_MCG

Group number for MCG status codes.

enumerator kStatusGroup_SCG

Group number for SCG status codes.

enumerator kStatusGroup_SDSPI

Group number for SDSPI status codes.

enumerator kStatusGroup_FLEXIO_I2S

Group number for FLEXIO I2S status codes

enumerator kStatusGroup_FLEXIO_MCULCD

Group number for FLEXIO LCD status codes

enumerator kStatusGroup_FLASHIAP

Group number for FLASHIAP status codes

enumerator kStatusGroup_FLEXCOMM_I2C

Group number for FLEXCOMM I2C status codes

enumerator kStatusGroup_I2S

Group number for I2S status codes

enumerator kStatusGroup_IUART

Group number for IUART status codes

enumerator kStatusGroup_CSI

Group number for CSI status codes

enumerator kStatusGroup_MIPI_DSI

Group number for MIPI DSI status codes

enumerator kStatusGroup_SDRAMC

Group number for SDRAMC status codes.

enumerator kStatusGroup_POWER

Group number for POWER status codes.

enumerator kStatusGroup_ENET

Group number for ENET status codes.

enumerator kStatusGroup_PHY

Group number for PHY status codes.

enumerator kStatusGroup_TRGMUX

Group number for TRGMUX status codes.

enumerator kStatusGroup_SMARTCARD

Group number for SMARTCARD status codes.

enumerator kStatusGroup_LMEM

Group number for LMEM status codes.

enumerator kStatusGroup_QSPI

Group number for QSPI status codes.

enumerator kStatusGroup_DMA

Group number for DMA status codes.

enumerator kStatusGroup_EDMA

Group number for EDMA status codes.

enumerator kStatusGroup_DMAMGR

Group number for DMAMGR status codes.

enumerator kStatusGroup_FLEXCAN

Group number for FlexCAN status codes.

enumerator kStatusGroup_LTC

Group number for LTC status codes.

enumerator kStatusGroup_FLEXIO_CAMERA

Group number for FLEXIO CAMERA status codes.

enumerator kStatusGroup_LPC_SPI

Group number for LPC_SPI status codes.

enumerator kStatusGroup_LPC_USART

Group number for LPC_USART status codes.

enumerator kStatusGroup_DMIC

Group number for DMIC status codes.

enumerator kStatusGroup_SDIF

Group number for SDIF status codes.

enumerator kStatusGroup_SPIFI

Group number for SPIFI status codes.

enumerator kStatusGroup_OTP

Group number for OTP status codes.

enumerator kStatusGroup_MCAN

Group number for MCAN status codes.

enumerator kStatusGroup_CAAM

Group number for CAAM status codes.

enumerator kStatusGroup_ECSPI

Group number for ECSPI status codes.

enumerator kStatusGroup_USDHC

Group number for USDHC status codes.

enumerator kStatusGroup_LPC_I2C

Group number for LPC_I2C status codes.

enumerator kStatusGroup_DCP

Group number for DCP status codes.

enumerator kStatusGroup_MSCAN

Group number for MSCAN status codes.

enumerator kStatusGroup_ESAI

Group number for ESAI status codes.

enumerator kStatusGroup_FLEXSPI

Group number for FLEXSPI status codes.

enumerator kStatusGroup_MMDC

Group number for MMDC status codes.

enumerator kStatusGroup_PDM

Group number for MIC status codes.

enumerator kStatusGroup_SDMA

Group number for SDMA status codes.

enumerator kStatusGroup_ICS

Group number for ICS status codes.

enumerator kStatusGroup_SPDIF

Group number for SPDIF status codes.

enumerator kStatusGroup_LPC_MINISPI

Group number for LPC_MINISPI status codes.

enumerator kStatusGroup_HASHCRYPT

Group number for Hashcrypt status codes

enumerator kStatusGroup_LPC_SPI_SSP

Group number for LPC_SPI_SSP status codes.

enumerator kStatusGroup_I3C

Group number for I3C status codes

enumerator kStatusGroup_LPC_I2C_1

Group number for LPC_I2C_1 status codes.

enumerator kStatusGroup_NOTIFIER

Group number for NOTIFIER status codes.

enumerator kStatusGroup_DebugConsole

Group number for debug console status codes.

enumerator kStatusGroup_SEMC

Group number for SEMC status codes.

enumerator kStatusGroup_ApplicationRangeStart

Starting number for application groups.

enumerator kStatusGroup_IAP

Group number for IAP status codes

enumerator kStatusGroup_SFA

Group number for SFA status codes

enumerator kStatusGroup_SPC

Group number for SPC status codes.

enumerator kStatusGroup_PUF

Group number for PUF status codes.

enumerator kStatusGroup_TOUCH_PANEL

Group number for touch panel status codes

enumerator kStatusGroup_VBAT

Group number for VBAT status codes

enumerator kStatusGroup_XSPI

Group number for XSPI status codes

enumerator kStatusGroup_PNGDEC

Group number for PNGDEC status codes

enumerator kStatusGroup_JPEGDEC

Group number for JPEGDEC status codes

enumerator kStatusGroup_HAL_GPIO

Group number for HAL GPIO status codes.

enumerator kStatusGroup_HAL_UART

Group number for HAL UART status codes.

enumerator kStatusGroup_HAL_TIMER

Group number for HAL TIMER status codes.

enumerator kStatusGroup_HAL_SPI

Group number for HAL SPI status codes.

enumerator kStatusGroup_HAL_I2C

Group number for HAL I2C status codes.

enumerator kStatusGroup_HAL_FLASH

Group number for HAL FLASH status codes.

enumerator kStatusGroup_HAL_PWM

Group number for HAL PWM status codes.

enumerator kStatusGroup_HAL_RNG

Group number for HAL RNG status codes.

enumerator kStatusGroup_HAL_I2S

Group number for HAL I2S status codes.

enumerator kStatusGroup_HAL_ADC_SENSOR

Group number for HAL ADC SENSOR status codes.

enumerator kStatusGroup_TIMERMANAGER

Group number for TiMER MANAGER status codes.

enumerator kStatusGroup_SERIALMANAGER

Group number for SERIAL MANAGER status codes.

enumerator kStatusGroup_LED

Group number for LED status codes.

enumerator kStatusGroup_BUTTON

Group number for BUTTON status codes.

enumerator kStatusGroup_EXTERN_EEPROM

Group number for EXTERN EEPROM status codes.

enumerator kStatusGroup_SHELL

Group number for SHELL status codes.

enumerator kStatusGroup_MEM_MANAGER

Group number for MEM MANAGER status codes.

enumerator kStatusGroup_LIST

Group number for List status codes.

enumerator kStatusGroup_OSA

Group number for OSA status codes.

enumerator kStatusGroup_COMMON_TASK

Group number for Common task status codes.

enumerator kStatusGroup_MSG

Group number for messaging status codes.

enumerator kStatusGroup_SDK_OCOTP

Group number for OCOTP status codes.

enumerator kStatusGroup_SDK_FLEXSPINOR

Group number for FLEXSPINOR status codes.

enumerator kStatusGroup_CODEC

Group number for codec status codes.

enumerator kStatusGroup_ASRC

Group number for codec status ASRC.

enumerator kStatusGroup_OTFAD

Group number for codec status codes.

enumerator kStatusGroup_SDIOSLV

Group number for SDIOSLV status codes.

enumerator kStatusGroup_MECC

Group number for MECC status codes.

enumerator kStatusGroup_ENET_QOS

Group number for ENET_QOS status codes.

enumerator kStatusGroup_LOG

Group number for LOG status codes.

enumerator kStatusGroup_I3CBUS

Group number for I3CBUS status codes.

enumerator kStatusGroup_QSCI

Group number for QSCI status codes.

enumerator kStatusGroup_ELEMU

Group number for ELEMU status codes.

enumerator kStatusGroup_QUEUEDSPI

Group number for QSPI status codes.

enumerator kStatusGroup_POWER_MANAGER

Group number for POWER_MANAGER status codes.

enumerator kStatusGroup_IPED

Group number for IPED status codes.

enumerator kStatusGroup_ELS_PKC

Group number for ELS PKC status codes.

enumerator kStatusGroup_CSS_PKC

Group number for CSS PKC status codes.

enumerator kStatusGroup_HOSTIF

Group number for HOSTIF status codes.

enumerator kStatusGroup_CLIF

Group number for CLIF status codes.

enumerator kStatusGroup_BMA

Group number for BMA status codes.

enumerator kStatusGroup_NETC

Group number for NETC status codes.

enumerator kStatusGroup_ELE

Group number for ELE status codes.

enumerator kStatusGroup_GLIKEY

Group number for GLIKEY status codes.

enumerator kStatusGroup_AON_POWER

Group number for AON_POWER status codes.

enumerator kStatusGroup_AON_COMMON

Group number for AON_COMMON status codes.

enumerator kStatusGroup_ENDAT3

Group number for ENDAT3 status codes.

enumerator kStatusGroup_HIPERFACE

Group number for HIPERFACE status codes.

Generic status return codes.

Values:

enumerator kStatus_Success

Generic status for Success.

enumerator kStatus_Fail

Generic status for Fail.

enumerator kStatus_ReadOnly

Generic status for read only failure.

enumerator kStatus_OutOfRange

Generic status for out of range access.

enumerator kStatus_InvalidArgument

Generic status for invalid argument check.

enumerator kStatus_Timeout

Generic status for timeout.

enumerator kStatus_NoTransferInProgress

Generic status for no transfer in progress.

enumerator kStatus_Busy

Generic status for module is busy.

enumerator kStatus_NoData

Generic status for no data is found for the operation.

typedef int32_t status_t

Type used for all status and error return values.

void *SDK_Malloc(size_t size, size_t alignbytes)

Allocate memory with given alignment and aligned size.

This is provided to support the dynamically allocated memory used in cache-able region.

Parameters:
  • size – The length required to malloc.

  • alignbytes – The alignment size.

Return values:

The – allocated memory.

void SDK_Free(void *ptr)

Free memory.

Parameters:
  • ptr – The memory to be release.

void SDK_DelayAtLeastUs(uint32_t delayTime_us, uint32_t coreClock_Hz)

Delay at least for some time. Please note that, this API uses while loop for delay, different run-time environments make the time not precise, if precise delay count was needed, please implement a new delay function with hardware timer.

Parameters:
  • delayTime_us – Delay time in unit of microsecond.

  • coreClock_Hz – Core clock frequency with Hz.

static inline status_t EnableIRQ(IRQn_Type interrupt)

Enable specific interrupt.

Enable LEVEL1 interrupt. For some devices, there might be multiple interrupt levels. For example, there are NVIC and intmux. Here the interrupts connected to NVIC are the LEVEL1 interrupts, because they are routed to the core directly. The interrupts connected to intmux are the LEVEL2 interrupts, they are routed to NVIC first then routed to core.

This function only enables the LEVEL1 interrupts. The number of LEVEL1 interrupts is indicated by the feature macro FSL_FEATURE_NUMBER_OF_LEVEL1_INT_VECTORS.

Parameters:
  • interrupt – The IRQ number.

Return values:
  • kStatus_Success – Interrupt enabled successfully

  • kStatus_Fail – Failed to enable the interrupt

static inline status_t DisableIRQ(IRQn_Type interrupt)

Disable specific interrupt.

Disable LEVEL1 interrupt. For some devices, there might be multiple interrupt levels. For example, there are NVIC and intmux. Here the interrupts connected to NVIC are the LEVEL1 interrupts, because they are routed to the core directly. The interrupts connected to intmux are the LEVEL2 interrupts, they are routed to NVIC first then routed to core.

This function only disables the LEVEL1 interrupts. The number of LEVEL1 interrupts is indicated by the feature macro FSL_FEATURE_NUMBER_OF_LEVEL1_INT_VECTORS.

Parameters:
  • interrupt – The IRQ number.

Return values:
  • kStatus_Success – Interrupt disabled successfully

  • kStatus_Fail – Failed to disable the interrupt

static inline status_t EnableIRQWithPriority(IRQn_Type interrupt, uint8_t priNum)

Enable the IRQ, and also set the interrupt priority.

Only handle LEVEL1 interrupt. For some devices, there might be multiple interrupt levels. For example, there are NVIC and intmux. Here the interrupts connected to NVIC are the LEVEL1 interrupts, because they are routed to the core directly. The interrupts connected to intmux are the LEVEL2 interrupts, they are routed to NVIC first then routed to core.

This function only handles the LEVEL1 interrupts. The number of LEVEL1 interrupts is indicated by the feature macro FSL_FEATURE_NUMBER_OF_LEVEL1_INT_VECTORS.

Parameters:
  • interrupt – The IRQ to Enable.

  • priNum – Priority number set to interrupt controller register.

Return values:
  • kStatus_Success – Interrupt priority set successfully

  • kStatus_Fail – Failed to set the interrupt priority.

static inline status_t IRQ_SetPriority(IRQn_Type interrupt, uint8_t priNum)

Set the IRQ priority.

Only handle LEVEL1 interrupt. For some devices, there might be multiple interrupt levels. For example, there are NVIC and intmux. Here the interrupts connected to NVIC are the LEVEL1 interrupts, because they are routed to the core directly. The interrupts connected to intmux are the LEVEL2 interrupts, they are routed to NVIC first then routed to core.

This function only handles the LEVEL1 interrupts. The number of LEVEL1 interrupts is indicated by the feature macro FSL_FEATURE_NUMBER_OF_LEVEL1_INT_VECTORS.

Parameters:
  • interrupt – The IRQ to set.

  • priNum – Priority number set to interrupt controller register.

Return values:
  • kStatus_Success – Interrupt priority set successfully

  • kStatus_Fail – Failed to set the interrupt priority.

static inline status_t IRQ_ClearPendingIRQ(IRQn_Type interrupt)

Clear the pending IRQ flag.

Only handle LEVEL1 interrupt. For some devices, there might be multiple interrupt levels. For example, there are NVIC and intmux. Here the interrupts connected to NVIC are the LEVEL1 interrupts, because they are routed to the core directly. The interrupts connected to intmux are the LEVEL2 interrupts, they are routed to NVIC first then routed to core.

This function only handles the LEVEL1 interrupts. The number of LEVEL1 interrupts is indicated by the feature macro FSL_FEATURE_NUMBER_OF_LEVEL1_INT_VECTORS.

Parameters:
  • interrupt – The flag which IRQ to clear.

Return values:
  • kStatus_Success – Interrupt priority set successfully

  • kStatus_Fail – Failed to set the interrupt priority.

static inline uint32_t DisableGlobalIRQ(void)

Disable the global IRQ.

Disable the global interrupt and return the current primask register. User is required to provided the primask register for the EnableGlobalIRQ().

Returns:

Current primask value.

static inline void EnableGlobalIRQ(uint32_t primask)

Enable the global IRQ.

Set the primask register with the provided primask value but not just enable the primask. The idea is for the convenience of integration of RTOS. some RTOS get its own management mechanism of primask. User is required to use the EnableGlobalIRQ() and DisableGlobalIRQ() in pair.

Parameters:
  • primask – value of primask register to be restored. The primask value is supposed to be provided by the DisableGlobalIRQ().

void EnableDeepSleepIRQ(IRQn_Type interrupt)

Enable specific interrupt for wake-up from deep-sleep mode.

Enable the interrupt for wake-up from deep sleep mode. Some interrupts are typically used in sleep mode only and will not occur during deep-sleep mode because relevant clocks are stopped. However, it is possible to enable those clocks (significantly increasing power consumption in the reduced power mode), making these wake-ups possible.

Note

This function also enables the interrupt in the NVIC (EnableIRQ() is called internaly).

Parameters:
  • interrupt – The IRQ number.

void DisableDeepSleepIRQ(IRQn_Type interrupt)

Disable specific interrupt for wake-up from deep-sleep mode.

Disable the interrupt for wake-up from deep sleep mode. Some interrupts are typically used in sleep mode only and will not occur during deep-sleep mode because relevant clocks are stopped. However, it is possible to enable those clocks (significantly increasing power consumption in the reduced power mode), making these wake-ups possible.

Note

This function also disables the interrupt in the NVIC (DisableIRQ() is called internaly).

Parameters:
  • interrupt – The IRQ number.

static inline bool _SDK_AtomicLocalCompareAndSet(uint32_t *addr, uint32_t expected, uint32_t newValue)
static inline uint32_t _SDK_AtomicTestAndSet(uint32_t *addr, uint32_t newValue)
FSL_DRIVER_TRANSFER_DOUBLE_WEAK_IRQ

Macro to use the default weak IRQ handler in drivers.

MAKE_STATUS(group, code)

Construct a status code value from a group and code number.

MAKE_VERSION(major, minor, bugfix)

Construct the version number for drivers.

The driver version is a 32-bit number, for both 32-bit platforms(such as Cortex M) and 16-bit platforms(such as DSC).

| Unused    || Major Version || Minor Version ||  Bug Fix    |
31        25  24           17  16            9  8            0
ARRAY_SIZE(x)

Computes the number of elements in an array.

UINT64_H(X)

Macro to get upper 32 bits of a 64-bit value

UINT64_L(X)

Macro to get lower 32 bits of a 64-bit value

SUPPRESS_FALL_THROUGH_WARNING()

For switch case code block, if case section ends without “break;” statement, there wil be fallthrough warning with compiler flag -Wextra or -Wimplicit-fallthrough=n when using armgcc. To suppress this warning, “SUPPRESS_FALL_THROUGH_WARNING();” need to be added at the end of each case section which misses “break;”statement.

MSDK_REG_SECURE_ADDR(x)

Convert the register address to the one used in secure mode.

MSDK_REG_NONSECURE_ADDR(x)

Convert the register address to the one used in non-secure mode.

LPC_ACOMP: Analog comparator Driver

void ACOMP_Init(ACOMP_Type *base, const acomp_config_t *config)

Initialize the ACOMP module.

Parameters:
  • base – ACOMP peripheral base address.

  • config – Pointer to “acomp_config_t” structure.

void ACOMP_Deinit(ACOMP_Type *base)

De-initialize the ACOMP module.

Parameters:
  • base – ACOMP peripheral base address.

void ACOMP_GetDefaultConfig(acomp_config_t *config)

Gets an available pre-defined settings for the ACOMP’s configuration.

This function initializes the converter configuration structure with available settings. The default values are:

config->enableSyncToBusClk = false;
config->hysteresisSelection = kACOMP_hysteresisNoneSelection;
In default configuration, the ACOMP’s output would be used directly and switch as the voltages cross.

Parameters:
  • config – Pointer to the configuration structure.

void ACOMP_EnableInterrupts(ACOMP_Type *base, acomp_interrupt_enable_t enable)

Enable ACOMP interrupts.

Parameters:
  • base – ACOMP peripheral base address.

  • enable – Enable/Disable interrupt feature.

static inline bool ACOMP_GetInterruptsStatusFlags(ACOMP_Type *base)

Get interrupts status flags.

Parameters:
  • base – ACOMP peripheral base address.

Returns:

Reflect the state ACOMP edge-detect status, true or false.

static inline void ACOMP_ClearInterruptsStatusFlags(ACOMP_Type *base)

Clear the ACOMP interrupts status flags.

Parameters:
  • base – ACOMP peripheral base address.

static inline bool ACOMP_GetOutputStatusFlags(ACOMP_Type *base)

Get ACOMP output status flags.

Parameters:
  • base – ACOMP peripheral base address.

Returns:

Reflect the state of the comparator output, true or false.

static inline void ACOMP_SetInputChannel(ACOMP_Type *base, uint32_t postiveInputChannel, uint32_t negativeInputChannel)

Set the ACOMP postive and negative input channel.

Parameters:
  • base – ACOMP peripheral base address.

  • postiveInputChannel – The index of postive input channel.

  • negativeInputChannel – The index of negative input channel.

void ACOMP_SetLadderConfig(ACOMP_Type *base, const acomp_ladder_config_t *config)

Set the voltage ladder configuration.

Parameters:
  • base – ACOMP peripheral base address.

  • config – The structure for voltage ladder. If the config is NULL, voltage ladder would be diasbled, otherwise the voltage ladder would be configured and enabled.

FSL_ACOMP_DRIVER_VERSION

ACOMP driver version 2.1.0.

enum _acomp_ladder_reference_voltage

The ACOMP ladder reference voltage.

Values:

enumerator kACOMP_LadderRefVoltagePinVDD

Supply from pin VDD.

enumerator kACOMP_LadderRefVoltagePinVDDCMP

Supply from pin VDDCMP.

enum _acomp_interrupt_enable

The ACOMP interrupts enable.

Values:

enumerator kACOMP_InterruptsFallingEdgeEnable

Enable the falling edge interrupts.

enumerator kACOMP_InterruptsRisingEdgeEnable

Enable the rising edge interrupts.

enumerator kACOMP_InterruptsBothEdgesEnable

Enable the both edges interrupts.

enumerator kACOMP_InterruptsDisable

Disable the interrupts.

enum _acomp_hysteresis_selection

The ACOMP hysteresis selection.

Values:

enumerator kACOMP_HysteresisNoneSelection

None (the output will switch as the voltages cross).

enumerator kACOMP_Hysteresis5MVSelection

5mV.

enumerator kACOMP_Hysteresis10MVSelection

10mV.

enumerator kACOMP_Hysteresis20MVSelection

20mV.

typedef enum _acomp_ladder_reference_voltage acomp_ladder_reference_voltage_t

The ACOMP ladder reference voltage.

typedef enum _acomp_interrupt_enable acomp_interrupt_enable_t

The ACOMP interrupts enable.

typedef enum _acomp_hysteresis_selection acomp_hysteresis_selection_t

The ACOMP hysteresis selection.

typedef struct _acomp_config acomp_config_t

The structure for ACOMP basic configuration.

typedef struct _acomp_ladder_config acomp_ladder_config_t

The structure for ACOMP voltage ladder.

struct _acomp_config
#include <fsl_acomp.h>

The structure for ACOMP basic configuration.

Public Members

bool enableSyncToBusClk

If true, Comparator output is synchronized to the bus clock for output to other modules. If false, Comparator output is used directly.

acomp_hysteresis_selection_t hysteresisSelection

Controls the hysteresis of the comparator.

struct _acomp_ladder_config
#include <fsl_acomp.h>

The structure for ACOMP voltage ladder.

Public Members

uint8_t ladderValue

Voltage ladder value. 00000 = Vss, 00001 = 1*Vref/31, …, 11111 = Vref.

acomp_ladder_reference_voltage_t referenceVoltage

Selects the reference voltage(Vref) for the voltage ladder.

ADC: 12-bit SAR Analog-to-Digital Converter Driver

void ADC_Init(ADC_Type *base, const adc_config_t *config)

Initialize the ADC module.

Parameters:
  • base – ADC peripheral base address.

  • config – Pointer to configuration structure, see to adc_config_t.

void ADC_Deinit(ADC_Type *base)

Deinitialize the ADC module.

Parameters:
  • base – ADC peripheral base address.

void ADC_GetDefaultConfig(adc_config_t *config)

Gets an available pre-defined settings for initial configuration.

This function initializes the initial configuration structure with an available settings. The default values are:

config->clockMode = kADC_ClockSynchronousMode;
config->clockDividerNumber = 0U;
config->resolution = kADC_Resolution12bit;
config->enableBypassCalibration = false;
config->sampleTimeNumber = 0U;
config->extendSampleTimeNumber = kADC_ExtendSampleTimeNotUsed;

Parameters:
  • config – Pointer to configuration structure.

static inline void ADC_EnableConvSeqA(ADC_Type *base, bool enable)

Enable the conversion sequence A.

In order to avoid spuriously triggering the sequence, the trigger to conversion sequence should be ready before the sequence is ready. when the sequence is disabled, the trigger would be ignored. Also, it is suggested to disable the sequence during changing the sequence’s setting.

Parameters:
  • base – ADC peripheral base address.

  • enable – Switcher to enable the feature or not.

void ADC_SetConvSeqAConfig(ADC_Type *base, const adc_conv_seq_config_t *config)

Configure the conversion sequence A.

Parameters:
  • base – ADC peripheral base address.

  • config – Pointer to configuration structure, see to adc_conv_seq_config_t.

static inline void ADC_DoSoftwareTriggerConvSeqA(ADC_Type *base)

Do trigger the sequence’s conversion by software.

Parameters:
  • base – ADC peripheral base address.

static inline void ADC_EnableConvSeqABurstMode(ADC_Type *base, bool enable)

Enable the burst conversion of sequence A.

Enable the burst mode would cause the conversion sequence to be cntinuously cycled through. Other triggers would be ignored while this mode is enabled. Repeated conversions could be halted by disabling this mode. And the sequence currently in process will be completed before cnversions are terminated. Note that a new sequence could begin just before the burst mode is disabled.

Parameters:
  • base – ADC peripheral base address.

  • enable – Switcher to enable this feature.

static inline void ADC_SetConvSeqAHighPriority(ADC_Type *base)

Set the high priority for conversion sequence A.

Parameters:
  • base – ADC peripheral bass address.

static inline void ADC_EnableConvSeqB(ADC_Type *base, bool enable)

Enable the conversion sequence B.

In order to avoid spuriously triggering the sequence, the trigger to conversion sequence should be ready before the sequence is ready. when the sequence is disabled, the trigger would be ignored. Also, it is suggested to disable the sequence during changing the sequence’s setting.

Parameters:
  • base – ADC peripheral base address.

  • enable – Switcher to enable the feature or not.

void ADC_SetConvSeqBConfig(ADC_Type *base, const adc_conv_seq_config_t *config)

Configure the conversion sequence B.

Parameters:
  • base – ADC peripheral base address.

  • config – Pointer to configuration structure, see to adc_conv_seq_config_t.

static inline void ADC_DoSoftwareTriggerConvSeqB(ADC_Type *base)

Do trigger the sequence’s conversion by software.

Parameters:
  • base – ADC peripheral base address.

static inline void ADC_EnableConvSeqBBurstMode(ADC_Type *base, bool enable)

Enable the burst conversion of sequence B.

Enable the burst mode would cause the conversion sequence to be continuously cycled through. Other triggers would be ignored while this mode is enabled. Repeated conversions could be halted by disabling this mode. And the sequence currently in process will be completed before cnversions are terminated. Note that a new sequence could begin just before the burst mode is disabled.

Parameters:
  • base – ADC peripheral base address.

  • enable – Switcher to enable this feature.

static inline void ADC_SetConvSeqBHighPriority(ADC_Type *base)

Set the high priority for conversion sequence B.

Parameters:
  • base – ADC peripheral bass address.

bool ADC_GetConvSeqAGlobalConversionResult(ADC_Type *base, adc_result_info_t *info)

Get the global ADC conversion infomation of sequence A.

Parameters:
  • base – ADC peripheral base address.

  • info – Pointer to information structure, see to adc_result_info_t;

Return values:
  • true – The conversion result is ready.

  • false – The conversion result is not ready yet.

bool ADC_GetConvSeqBGlobalConversionResult(ADC_Type *base, adc_result_info_t *info)

Get the global ADC conversion infomation of sequence B.

Parameters:
  • base – ADC peripheral base address.

  • info – Pointer to information structure, see to adc_result_info_t;

Return values:
  • true – The conversion result is ready.

  • false – The conversion result is not ready yet.

bool ADC_GetChannelConversionResult(ADC_Type *base, uint32_t channel, adc_result_info_t *info)

Get the channel’s ADC conversion completed under each conversion sequence.

Parameters:
  • base – ADC peripheral base address.

  • channel – The indicated channel number.

  • info – Pointer to information structure, see to adc_result_info_t;

Return values:
  • true – The conversion result is ready.

  • false – The conversion result is not ready yet.

static inline void ADC_SetThresholdPair0(ADC_Type *base, uint32_t lowValue, uint32_t highValue)

Set the threshhold pair 0 with low and high value.

Parameters:
  • base – ADC peripheral base address.

  • lowValue – LOW threshold value.

  • highValue – HIGH threshold value.

static inline void ADC_SetThresholdPair1(ADC_Type *base, uint32_t lowValue, uint32_t highValue)

Set the threshhold pair 1 with low and high value.

Parameters:
  • base – ADC peripheral base address.

  • lowValue – LOW threshold value. The available value is with 12-bit.

  • highValue – HIGH threshold value. The available value is with 12-bit.

static inline void ADC_SetChannelWithThresholdPair0(ADC_Type *base, uint32_t channelMask)

Set given channels to apply the threshold pare 0.

Parameters:
  • base – ADC peripheral base address.

  • channelMask – Indicated channels’ mask.

static inline void ADC_SetChannelWithThresholdPair1(ADC_Type *base, uint32_t channelMask)

Set given channels to apply the threshold pare 1.

Parameters:
  • base – ADC peripheral base address.

  • channelMask – Indicated channels’ mask.

static inline void ADC_EnableInterrupts(ADC_Type *base, uint32_t mask)

Enable interrupts for conversion sequences.

Parameters:
  • base – ADC peripheral base address.

  • mask – Mask of interrupt mask value for global block except each channal, see to _adc_interrupt_enable.

static inline void ADC_DisableInterrupts(ADC_Type *base, uint32_t mask)

Disable interrupts for conversion sequence.

Parameters:
  • base – ADC peripheral base address.

  • mask – Mask of interrupt mask value for global block except each channel, see to _adc_interrupt_enable.

static inline void ADC_EnableThresholdCompareInterrupt(ADC_Type *base, uint32_t channel, adc_threshold_interrupt_mode_t mode)

Enable the interrupt of threshold compare event for each channel.

Parameters:
  • base – ADC peripheral base address.

  • channel – Channel number.

  • mode – Interrupt mode for threshold compare event, see to adc_threshold_interrupt_mode_t.

static inline uint32_t ADC_GetStatusFlags(ADC_Type *base)

Get status flags of ADC module.

Parameters:
  • base – ADC peripheral base address.

Returns:

Mask of status flags of module, see to _adc_status_flags.

static inline void ADC_ClearStatusFlags(ADC_Type *base, uint32_t mask)

Clear status flags of ADC module.

Parameters:
  • base – ADC peripheral base address.

  • mask – Mask of status flags of module, see to _adc_status_flags.

FSL_ADC_DRIVER_VERSION

ADC driver version 2.6.0.

enum _adc_status_flags

Flags.

Values:

enumerator kADC_ThresholdCompareFlagOnChn0

Threshold comparison event on Channel 0.

enumerator kADC_ThresholdCompareFlagOnChn1

Threshold comparison event on Channel 1.

enumerator kADC_ThresholdCompareFlagOnChn2

Threshold comparison event on Channel 2.

enumerator kADC_ThresholdCompareFlagOnChn3

Threshold comparison event on Channel 3.

enumerator kADC_ThresholdCompareFlagOnChn4

Threshold comparison event on Channel 4.

enumerator kADC_ThresholdCompareFlagOnChn5

Threshold comparison event on Channel 5.

enumerator kADC_ThresholdCompareFlagOnChn6

Threshold comparison event on Channel 6.

enumerator kADC_ThresholdCompareFlagOnChn7

Threshold comparison event on Channel 7.

enumerator kADC_ThresholdCompareFlagOnChn8

Threshold comparison event on Channel 8.

enumerator kADC_ThresholdCompareFlagOnChn9

Threshold comparison event on Channel 9.

enumerator kADC_ThresholdCompareFlagOnChn10

Threshold comparison event on Channel 10.

enumerator kADC_ThresholdCompareFlagOnChn11

Threshold comparison event on Channel 11.

enumerator kADC_OverrunFlagForChn0

Mirror the OVERRUN status flag from the result register for ADC channel 0.

enumerator kADC_OverrunFlagForChn1

Mirror the OVERRUN status flag from the result register for ADC channel 1.

enumerator kADC_OverrunFlagForChn2

Mirror the OVERRUN status flag from the result register for ADC channel 2.

enumerator kADC_OverrunFlagForChn3

Mirror the OVERRUN status flag from the result register for ADC channel 3.

enumerator kADC_OverrunFlagForChn4

Mirror the OVERRUN status flag from the result register for ADC channel 4.

enumerator kADC_OverrunFlagForChn5

Mirror the OVERRUN status flag from the result register for ADC channel 5.

enumerator kADC_OverrunFlagForChn6

Mirror the OVERRUN status flag from the result register for ADC channel 6.

enumerator kADC_OverrunFlagForChn7

Mirror the OVERRUN status flag from the result register for ADC channel 7.

enumerator kADC_OverrunFlagForChn8

Mirror the OVERRUN status flag from the result register for ADC channel 8.

enumerator kADC_OverrunFlagForChn9

Mirror the OVERRUN status flag from the result register for ADC channel 9.

enumerator kADC_OverrunFlagForChn10

Mirror the OVERRUN status flag from the result register for ADC channel 10.

enumerator kADC_OverrunFlagForChn11

Mirror the OVERRUN status flag from the result register for ADC channel 11.

enumerator kADC_GlobalOverrunFlagForSeqA

Mirror the glabal OVERRUN status flag for conversion sequence A.

enumerator kADC_GlobalOverrunFlagForSeqB

Mirror the global OVERRUN status flag for conversion sequence B.

enumerator kADC_ConvSeqAInterruptFlag

Sequence A interrupt/DMA trigger.

enumerator kADC_ConvSeqBInterruptFlag

Sequence B interrupt/DMA trigger.

enumerator kADC_ThresholdCompareInterruptFlag

Threshold comparision interrupt flag.

enumerator kADC_OverrunInterruptFlag

Overrun interrupt flag.

enum _adc_interrupt_enable

Interrupts.

Note

Not all the interrupt options are listed here

Values:

enumerator kADC_ConvSeqAInterruptEnable

Enable interrupt upon completion of each individual conversion in sequence A, or entire sequence.

enumerator kADC_ConvSeqBInterruptEnable

Enable interrupt upon completion of each individual conversion in sequence B, or entire sequence.

enumerator kADC_OverrunInterruptEnable

Enable the detection of an overrun condition on any of the channel data registers will cause an overrun interrupt/DMA trigger.

enum _adc_clock_mode

Define selection of clock mode.

Values:

enumerator kADC_ClockSynchronousMode

The ADC clock would be derived from the system clock based on “clockDividerNumber”.

enumerator kADC_ClockAsynchronousMode

The ADC clock would be based on the SYSCON block’s divider.

enum _adc_resolution

Define selection of resolution.

Values:

enumerator kADC_Resolution6bit

6-bit resolution.

enumerator kADC_Resolution8bit

8-bit resolution.

enumerator kADC_Resolution10bit

10-bit resolution.

enumerator kADC_Resolution12bit

12-bit resolution.

enum _adc_voltage_range

Definfe range of the analog supply voltage VDDA.

Values:

enumerator kADC_HighVoltageRange
enumerator kADC_LowVoltageRange
enum _adc_trigger_polarity

Define selection of polarity of selected input trigger for conversion sequence.

Values:

enumerator kADC_TriggerPolarityNegativeEdge

A negative edge launches the conversion sequence on the trigger(s).

enumerator kADC_TriggerPolarityPositiveEdge

A positive edge launches the conversion sequence on the trigger(s).

enum _adc_priority

Define selection of conversion sequence’s priority.

Values:

enumerator kADC_PriorityLow

This sequence would be preempted when another sequence is started.

enumerator kADC_PriorityHigh

This sequence would preempt other sequence even when it is started.

enum _adc_seq_interrupt_mode

Define selection of conversion sequence’s interrupt.

Values:

enumerator kADC_InterruptForEachConversion

The sequence interrupt/DMA trigger will be set at the end of each individual ADC conversion inside this conversion sequence.

enumerator kADC_InterruptForEachSequence

The sequence interrupt/DMA trigger will be set when the entire set of this sequence conversions completes.

enum _adc_threshold_compare_status

Define status of threshold compare result.

Values:

enumerator kADC_ThresholdCompareInRange

LOW threshold <= conversion value <= HIGH threshold.

enumerator kADC_ThresholdCompareBelowRange

conversion value < LOW threshold.

enumerator kADC_ThresholdCompareAboveRange

conversion value > HIGH threshold.

enum _adc_threshold_crossing_status

Define status of threshold crossing detection result.

Values:

enumerator kADC_ThresholdCrossingNoDetected

No threshold Crossing detected.

enumerator kADC_ThresholdCrossingDownward

Downward Threshold Crossing detected.

enumerator kADC_ThresholdCrossingUpward

Upward Threshold Crossing Detected.

enum _adc_threshold_interrupt_mode

Define interrupt mode for threshold compare event.

Values:

enumerator kADC_ThresholdInterruptDisabled

Threshold comparison interrupt is disabled.

enumerator kADC_ThresholdInterruptOnOutside

Threshold comparison interrupt is enabled on outside threshold.

enumerator kADC_ThresholdInterruptOnCrossing

Threshold comparison interrupt is enabled on crossing threshold.

enum _adc_inforesultshift

Define the info result mode of different resolution.

Values:

enumerator kADC_Resolution12bitInfoResultShift

Info result shift of Resolution12bit.

enumerator kADC_Resolution10bitInfoResultShift

Info result shift of Resolution10bit.

enumerator kADC_Resolution8bitInfoResultShift

Info result shift of Resolution8bit.

enumerator kADC_Resolution6bitInfoResultShift

Info result shift of Resolution6bit.

enum _adc_tempsensor_common_mode

Define common modes for Temerature sensor.

Values:

enumerator kADC_HighNegativeOffsetAdded

Temperature sensor common mode: high negative offset added.

enumerator kADC_IntermediateNegativeOffsetAdded

Temperature sensor common mode: intermediate negative offset added.

enumerator kADC_NoOffsetAdded

Temperature sensor common mode: no offset added.

enumerator kADC_LowPositiveOffsetAdded

Temperature sensor common mode: low positive offset added.

enum _adc_second_control

Define source impedance modes for GPADC control.

Values:

enumerator kADC_Impedance621Ohm

Extand ADC sampling time according to source impedance 1: 0.621 kOhm.

enumerator kADC_Impedance55kOhm

Extand ADC sampling time according to source impedance 20 (default): 55 kOhm.

enumerator kADC_Impedance87kOhm

Extand ADC sampling time according to source impedance 31: 87 kOhm.

enumerator kADC_NormalFunctionalMode

TEST mode: Normal functional mode.

enumerator kADC_MultiplexeTestMode

TEST mode: Multiplexer test mode.

enumerator kADC_ADCInUnityGainMode

TEST mode: ADC in unity gain mode.

typedef enum _adc_clock_mode adc_clock_mode_t

Define selection of clock mode.

typedef enum _adc_resolution adc_resolution_t

Define selection of resolution.

typedef enum _adc_voltage_range adc_vdda_range_t

Definfe range of the analog supply voltage VDDA.

typedef enum _adc_trigger_polarity adc_trigger_polarity_t

Define selection of polarity of selected input trigger for conversion sequence.

typedef enum _adc_priority adc_priority_t

Define selection of conversion sequence’s priority.

typedef enum _adc_seq_interrupt_mode adc_seq_interrupt_mode_t

Define selection of conversion sequence’s interrupt.

typedef enum _adc_threshold_compare_status adc_threshold_compare_status_t

Define status of threshold compare result.

typedef enum _adc_threshold_crossing_status adc_threshold_crossing_status_t

Define status of threshold crossing detection result.

typedef enum _adc_threshold_interrupt_mode adc_threshold_interrupt_mode_t

Define interrupt mode for threshold compare event.

typedef enum _adc_inforesultshift adc_inforesult_t

Define the info result mode of different resolution.

typedef enum _adc_tempsensor_common_mode adc_tempsensor_common_mode_t

Define common modes for Temerature sensor.

typedef enum _adc_second_control adc_second_control_t

Define source impedance modes for GPADC control.

typedef struct _adc_config adc_config_t

Define structure for configuring the block.

typedef struct _adc_conv_seq_config adc_conv_seq_config_t

Define structure for configuring conversion sequence.

typedef struct _adc_result_info adc_result_info_t

Define structure of keeping conversion result information.

struct _adc_config
#include <fsl_adc.h>

Define structure for configuring the block.

Public Members

adc_clock_mode_t clockMode

Select the clock mode for ADC converter.

uint32_t clockDividerNumber

This field is only available when using kADC_ClockSynchronousMode for “clockMode” field. The divider would be plused by 1 based on the value in this field. The available range is in 8 bits.

adc_resolution_t resolution

Select the conversion bits.

bool enableBypassCalibration

By default, a calibration cycle must be performed each time the chip is powered-up. Re-calibration may be warranted periodically - especially if operating conditions have changed. To enable this option would avoid the need to calibrate if offset error is not a concern in the application.

uint32_t sampleTimeNumber

By default, with value as “0U”, the sample period would be 2.5 ADC clocks. Then, to plus the “sampleTimeNumber” value here. The available value range is in 3 bits.

bool enableLowPowerMode

If disable low-power mode, ADC remains activated even when no conversions are requested. If enable low-power mode, The ADC is automatically powered-down when no conversions are taking place.

adc_vdda_range_t voltageRange

Configure the ADC for the appropriate operating range of the analog supply voltage VDDA. Failure to set the area correctly causes the ADC to return incorrect conversion results.

struct _adc_conv_seq_config
#include <fsl_adc.h>

Define structure for configuring conversion sequence.

Public Members

uint32_t channelMask

Selects which one or more of the ADC channels will be sampled and converted when this sequence is launched. The masked channels would be involved in current conversion sequence, beginning with the lowest-order. The available range is in 12-bit.

uint32_t triggerMask

Selects which one or more of the available hardware trigger sources will cause this conversion sequence to be initiated. The available range is 6-bit.

adc_trigger_polarity_t triggerPolarity

Select the trigger to launch conversion sequence.

bool enableSyncBypass

To enable this feature allows the hardware trigger input to bypass synchronization flip-flop stages and therefore shorten the time between the trigger input signal and the start of a conversion.

bool enableSingleStep

When enabling this feature, a trigger will launch a single conversion on the next channel in the sequence instead of the default response of launching an entire sequence of conversions.

adc_seq_interrupt_mode_t interruptMode

Select the interrpt/DMA trigger mode.

struct _adc_result_info
#include <fsl_adc.h>

Define structure of keeping conversion result information.

Public Members

uint32_t result

Keep the conversion data value.

adc_threshold_compare_status_t thresholdCompareStatus

Keep the threshold compare status.

adc_threshold_crossing_status_t thresholdCorssingStatus

Keep the threshold crossing status.

uint32_t channelNumber

Keep the channel number for this conversion.

bool overrunFlag

Keep the status whether the conversion is overrun or not.

DAC: 10-bit Digital To Analog Converter Driver

LPC_DAC_DRIVER_VERSION

DAC driver version 2.0.2.

enum _dac_settling_time

The DAC settling time.

Values:

enumerator kDAC_SettlingTimeIs1us

The settling time of the DAC is 1us max, and the maximum current is 700 mA. This allows a maximum update rate of 1 MHz.

enumerator kDAC_SettlingTimeIs25us

The settling time of the DAC is 2.5us and the maximum current is 350uA. This allows a maximum update rate of 400 kHz.

typedef enum _dac_settling_time dac_settling_time_t

The DAC settling time.

typedef struct _dac_config dac_config_t

The configuration of DAC.

void DAC_Init(DAC_Type *base, const dac_config_t *config)

Initialize the DAC module.

Parameters:
  • base – DAC peripheral base address.

  • config – The pointer to configuration structure. Please refer to “dac_config_t” structure.

void DAC_Deinit(DAC_Type *base)

De-Initialize the DAC module.

Parameters:
  • base – DAC peripheral base address.

void DAC_GetDefaultConfig(dac_config_t *config)

Initializes the DAC user configuration structure.

This function initializes the user configuration structure to a default value. The default values are as follows.

config->settlingTime = kDAC_SettlingTimeIs1us;

Parameters:
  • config – Pointer to the configuration structure. See “dac_config_t”.

void DAC_EnableDoubleBuffering(DAC_Type *base, bool enable)

Enable/Diable double-buffering feature. Notice: Disabling the double-buffering feature will disable counter opreation. If double-buffering feature is disabled, any writes to the CR address will go directly to the CR register. If double-buffering feature is enabled, any write to the CR register will only load the pre-buffer, which shares its register address with the CR register. The CR itself will be loaded from the pre-buffer whenever the counter reaches zero and the DMA request is set.

Parameters:
  • base – DAC peripheral base address.

  • enable – Enable or disable the feature.

void DAC_SetBufferValue(DAC_Type *base, uint32_t value)

Write DAC output value into CR register or pre-buffer. The DAC output voltage is VALUE*((VREFP)/1024).

Parameters:
  • base – DAC peripheral base address.

  • value – Setting the value for items in the buffer. 10-bits are available.

void DAC_SetCounterValue(DAC_Type *base, uint32_t value)

Write DAC counter value into CNTVAL register. When the counter is enabled bit, the 16-bit counter will begin counting down, at the rate selected by PCLK, from the value programmed into the DACCNTVAL register. The counter is decremented Each time the counter reaches zero, the counter will be reloaded by the value of DACCNTVAL and the DMA request bit INT_DMA_REQ will be set in hardware.

Parameters:
  • base – DAC peripheral basic address.

  • value – Setting the value for items in the counter. 16-bits are available.

static inline void DAC_EnableCounter(DAC_Type *base, bool enable)

Enable/Disable the counter operation.

Parameters:
  • base – DAC peripheral base address.

  • enable – Enable or disable the feature.

static inline bool DAC_GetDMAInterruptRequestFlag(DAC_Type *base)

Get the status flag of DMA or interrupt request.

Parameters:
  • base – DAC peripheral base address.

Returns:

If return ‘true’, it means DMA request or interrupt occurs. If return ‘false’, it means DMA request or interrupt doesn’t occur.

struct _dac_config
#include <fsl_dac.h>

The configuration of DAC.

Public Members

dac_settling_time_t settlingTime

The settling times are valid for a capacitance load on the DAC_OUT pin not exceeding 100 pF. A load impedance value greater than that value will cause settling time longer than the specified time. One or more graphs of load impedance vs. settling time will be included in the final data sheet.

GPIO: General Purpose I/O

void GPIO_PortInit(GPIO_Type *base, uint32_t port)

Initializes the GPIO peripheral.

This function ungates the GPIO clock.

Parameters:
  • base – GPIO peripheral base pointer.

  • port – GPIO port number.

void GPIO_PinInit(GPIO_Type *base, uint32_t port, uint32_t pin, const gpio_pin_config_t *config)

Initializes a GPIO pin used by the board.

To initialize the GPIO, define a pin configuration, either input or output, in the user file. Then, call the GPIO_PinInit() function.

This is an example to define an input pin or output pin configuration:

Define a digital input pin configuration,
gpio_pin_config_t config =
{
  kGPIO_DigitalInput,
  0,
}
Define a digital output pin configuration,
gpio_pin_config_t config =
{
  kGPIO_DigitalOutput,
  0,
}

Parameters:
  • base – GPIO peripheral base pointer(Typically GPIO)

  • port – GPIO port number

  • pin – GPIO pin number

  • config – GPIO pin configuration pointer

static inline void GPIO_PinWrite(GPIO_Type *base, uint32_t port, uint32_t pin, uint8_t output)

Sets the output level of the one GPIO pin to the logic 1 or 0.

Parameters:
  • base – GPIO peripheral base pointer(Typically GPIO)

  • port – GPIO port number

  • pin – GPIO pin number

  • output – GPIO pin output logic level.

    • 0: corresponding pin output low-logic level.

    • 1: corresponding pin output high-logic level.

static inline uint32_t GPIO_PinRead(GPIO_Type *base, uint32_t port, uint32_t pin)

Reads the current input value of the GPIO PIN.

Parameters:
  • base – GPIO peripheral base pointer(Typically GPIO)

  • port – GPIO port number

  • pin – GPIO pin number

Return values:

GPIO – port input value

  • 0: corresponding pin input low-logic level.

  • 1: corresponding pin input high-logic level.

FSL_GPIO_DRIVER_VERSION

LPC GPIO driver version.

enum _gpio_pin_direction

LPC GPIO direction definition.

Values:

enumerator kGPIO_DigitalInput

Set current pin as digital input

enumerator kGPIO_DigitalOutput

Set current pin as digital output

typedef enum _gpio_pin_direction gpio_pin_direction_t

LPC GPIO direction definition.

typedef struct _gpio_pin_config gpio_pin_config_t

The GPIO pin configuration structure.

Every pin can only be configured as either output pin or input pin at a time. If configured as a input pin, then leave the outputConfig unused.

static inline void GPIO_PortSet(GPIO_Type *base, uint32_t port, uint32_t mask)

Sets the output level of the multiple GPIO pins to the logic 1.

Parameters:
  • base – GPIO peripheral base pointer(Typically GPIO)

  • port – GPIO port number

  • mask – GPIO pin number macro

static inline void GPIO_PortClear(GPIO_Type *base, uint32_t port, uint32_t mask)

Sets the output level of the multiple GPIO pins to the logic 0.

Parameters:
  • base – GPIO peripheral base pointer(Typically GPIO)

  • port – GPIO port number

  • mask – GPIO pin number macro

static inline void GPIO_PortToggle(GPIO_Type *base, uint32_t port, uint32_t mask)

Reverses current output logic of the multiple GPIO pins.

Parameters:
  • base – GPIO peripheral base pointer(Typically GPIO)

  • port – GPIO port number

  • mask – GPIO pin number macro

struct _gpio_pin_config
#include <fsl_gpio.h>

The GPIO pin configuration structure.

Every pin can only be configured as either output pin or input pin at a time. If configured as a input pin, then leave the outputConfig unused.

Public Members

gpio_pin_direction_t pinDirection

GPIO direction, input or output

uint8_t outputLogic

Set default output logic, no use in input

IOCON: I/O pin configuration

LPC_IOCON_DRIVER_VERSION

IOCON driver version 2.0.2.

typedef struct _iocon_group iocon_group_t

Array of IOCON pin definitions passed to IOCON_SetPinMuxing() must be in this format.

__STATIC_INLINE void IOCON_PinMuxSet (IOCON_Type *base, uint8_t ionumber, uint32_t modefunc)

IOCON function and mode selection definitions.

Sets I/O Control pin mux

Note

See the User Manual for specific modes and functions supported by the various pins.

Parameters:
  • base – : The base of IOCON peripheral on the chip

  • ionumber – : GPIO number to mux

  • modefunc – : OR’ed values of type IOCON_*

Returns:

Nothing

__STATIC_INLINE void IOCON_SetPinMuxing (IOCON_Type *base, const iocon_group_t *pinArray, uint32_t arrayLength)

Set all I/O Control pin muxing.

Parameters:
  • base – : The base of IOCON peripheral on the chip

  • pinArray – : Pointer to array of pin mux selections

  • arrayLength – : Number of entries in pinArray

Returns:

Nothing

FSL_COMPONENT_ID
struct _iocon_group
#include <fsl_iocon.h>

Array of IOCON pin definitions passed to IOCON_SetPinMuxing() must be in this format.

MRT: Multi-Rate Timer

void MRT_Init(MRT_Type *base, const mrt_config_t *config)

Ungates the MRT clock and configures the peripheral for basic operation.

Note

This API should be called at the beginning of the application using the MRT driver.

Parameters:
  • base – Multi-Rate timer peripheral base address

  • config – Pointer to user’s MRT config structure. If MRT has MULTITASK bit field in MODCFG reigster, param config is useless.

void MRT_Deinit(MRT_Type *base)

Gate the MRT clock.

Parameters:
  • base – Multi-Rate timer peripheral base address

static inline void MRT_GetDefaultConfig(mrt_config_t *config)

Fill in the MRT config struct with the default settings.

The default values are:

config->enableMultiTask = false;

Parameters:
  • config – Pointer to user’s MRT config structure.

static inline void MRT_SetupChannelMode(MRT_Type *base, mrt_chnl_t channel, const mrt_timer_mode_t mode)

Sets up an MRT channel mode.

Parameters:
  • base – Multi-Rate timer peripheral base address

  • channel – Channel that is being configured.

  • mode – Timer mode to use for the channel.

static inline void MRT_EnableInterrupts(MRT_Type *base, mrt_chnl_t channel, uint32_t mask)

Enables the MRT interrupt.

Parameters:
  • base – Multi-Rate timer peripheral base address

  • channel – Timer channel number

  • mask – The interrupts to enable. This is a logical OR of members of the enumeration mrt_interrupt_enable_t

static inline void MRT_DisableInterrupts(MRT_Type *base, mrt_chnl_t channel, uint32_t mask)

Disables the selected MRT interrupt.

Parameters:
  • base – Multi-Rate timer peripheral base address

  • channel – Timer channel number

  • mask – The interrupts to disable. This is a logical OR of members of the enumeration mrt_interrupt_enable_t

static inline uint32_t MRT_GetEnabledInterrupts(MRT_Type *base, mrt_chnl_t channel)

Gets the enabled MRT interrupts.

Parameters:
  • base – Multi-Rate timer peripheral base address

  • channel – Timer channel number

Returns:

The enabled interrupts. This is the logical OR of members of the enumeration mrt_interrupt_enable_t

static inline uint32_t MRT_GetStatusFlags(MRT_Type *base, mrt_chnl_t channel)

Gets the MRT status flags.

Parameters:
  • base – Multi-Rate timer peripheral base address

  • channel – Timer channel number

Returns:

The status flags. This is the logical OR of members of the enumeration mrt_status_flags_t

static inline void MRT_ClearStatusFlags(MRT_Type *base, mrt_chnl_t channel, uint32_t mask)

Clears the MRT status flags.

Parameters:
  • base – Multi-Rate timer peripheral base address

  • channel – Timer channel number

  • mask – The status flags to clear. This is a logical OR of members of the enumeration mrt_status_flags_t

void MRT_UpdateTimerPeriod(MRT_Type *base, mrt_chnl_t channel, uint32_t count, bool immediateLoad)

Used to update the timer period in units of count.

The new value will be immediately loaded or will be loaded at the end of the current time interval. For one-shot interrupt mode the new value will be immediately loaded.

Note

User can call the utility macros provided in fsl_common.h to convert to ticks

Parameters:
  • base – Multi-Rate timer peripheral base address

  • channel – Timer channel number

  • count – Timer period in units of ticks

  • immediateLoad – true: Load the new value immediately into the TIMER register; false: Load the new value at the end of current timer interval

static inline uint32_t MRT_GetCurrentTimerCount(MRT_Type *base, mrt_chnl_t channel)

Reads the current timer counting value.

This function returns the real-time timer counting value, in a range from 0 to a timer period.

Note

User can call the utility macros provided in fsl_common.h to convert ticks to usec or msec

Parameters:
  • base – Multi-Rate timer peripheral base address

  • channel – Timer channel number

Returns:

Current timer counting value in ticks

static inline void MRT_StartTimer(MRT_Type *base, mrt_chnl_t channel, uint32_t count)

Starts the timer counting.

After calling this function, timers load period value, counts down to 0 and depending on the timer mode it will either load the respective start value again or stop.

Note

User can call the utility macros provided in fsl_common.h to convert to ticks

Parameters:
  • base – Multi-Rate timer peripheral base address

  • channel – Timer channel number.

  • count – Timer period in units of ticks. Count can contain the LOAD bit, which control the force load feature.

static inline void MRT_StopTimer(MRT_Type *base, mrt_chnl_t channel)

Stops the timer counting.

This function stops the timer from counting.

Parameters:
  • base – Multi-Rate timer peripheral base address

  • channel – Timer channel number.

static inline uint32_t MRT_GetIdleChannel(MRT_Type *base)

Find the available channel.

This function returns the lowest available channel number.

Parameters:
  • base – Multi-Rate timer peripheral base address

FSL_MRT_DRIVER_VERSION
enum _mrt_chnl

List of MRT channels.

Values:

enumerator kMRT_Channel_0

MRT channel number 0

enumerator kMRT_Channel_1

MRT channel number 1

enumerator kMRT_Channel_2

MRT channel number 2

enumerator kMRT_Channel_3

MRT channel number 3

enum _mrt_timer_mode

List of MRT timer modes.

Values:

enumerator kMRT_RepeatMode

Repeat Interrupt mode

enumerator kMRT_OneShotMode

One-shot Interrupt mode

enumerator kMRT_OneShotStallMode

One-shot stall mode

enum _mrt_interrupt_enable

List of MRT interrupts.

Values:

enumerator kMRT_TimerInterruptEnable

Timer interrupt enable

enum _mrt_status_flags

List of MRT status flags.

Values:

enumerator kMRT_TimerInterruptFlag

Timer interrupt flag

enumerator kMRT_TimerRunFlag

Indicates state of the timer

typedef enum _mrt_chnl mrt_chnl_t

List of MRT channels.

typedef enum _mrt_timer_mode mrt_timer_mode_t

List of MRT timer modes.

typedef enum _mrt_interrupt_enable mrt_interrupt_enable_t

List of MRT interrupts.

typedef enum _mrt_status_flags mrt_status_flags_t

List of MRT status flags.

typedef struct _mrt_config mrt_config_t

MRT configuration structure.

This structure holds the configuration settings for the MRT peripheral. To initialize this structure to reasonable defaults, call the MRT_GetDefaultConfig() function and pass a pointer to your config structure instance.

The config struct can be made const so it resides in flash

struct _mrt_config
#include <fsl_mrt.h>

MRT configuration structure.

This structure holds the configuration settings for the MRT peripheral. To initialize this structure to reasonable defaults, call the MRT_GetDefaultConfig() function and pass a pointer to your config structure instance.

The config struct can be made const so it resides in flash

Public Members

bool enableMultiTask

true: Timers run in multi-task mode; false: Timers run in hardware status mode

PINT: Pin Interrupt and Pattern Match Driver

FSL_PINT_DRIVER_VERSION
enum _pint_pin_enable

PINT Pin Interrupt enable type.

Values:

enumerator kPINT_PinIntEnableNone

Do not generate Pin Interrupt

enumerator kPINT_PinIntEnableRiseEdge

Generate Pin Interrupt on rising edge

enumerator kPINT_PinIntEnableFallEdge

Generate Pin Interrupt on falling edge

enumerator kPINT_PinIntEnableBothEdges

Generate Pin Interrupt on both edges

enumerator kPINT_PinIntEnableLowLevel

Generate Pin Interrupt on low level

enumerator kPINT_PinIntEnableHighLevel

Generate Pin Interrupt on high level

enum _pint_int

PINT Pin Interrupt type.

Values:

enumerator kPINT_PinInt0

Pin Interrupt 0

enum _pint_pmatch_input_src

PINT Pattern Match bit slice input source type.

Values:

enumerator kPINT_PatternMatchInp0Src

Input source 0

enumerator kPINT_PatternMatchInp1Src

Input source 1

enumerator kPINT_PatternMatchInp2Src

Input source 2

enumerator kPINT_PatternMatchInp3Src

Input source 3

enumerator kPINT_PatternMatchInp4Src

Input source 4

enumerator kPINT_PatternMatchInp5Src

Input source 5

enumerator kPINT_PatternMatchInp6Src

Input source 6

enumerator kPINT_PatternMatchInp7Src

Input source 7

enumerator kPINT_SecPatternMatchInp0Src

Input source 0

enumerator kPINT_SecPatternMatchInp1Src

Input source 1

enum _pint_pmatch_bslice

PINT Pattern Match bit slice type.

Values:

enumerator kPINT_PatternMatchBSlice0

Bit slice 0

enum _pint_pmatch_bslice_cfg

PINT Pattern Match configuration type.

Values:

enumerator kPINT_PatternMatchAlways

Always Contributes to product term match

enumerator kPINT_PatternMatchStickyRise

Sticky Rising edge

enumerator kPINT_PatternMatchStickyFall

Sticky Falling edge

enumerator kPINT_PatternMatchStickyBothEdges

Sticky Rising or Falling edge

enumerator kPINT_PatternMatchHigh

High level

enumerator kPINT_PatternMatchLow

Low level

enumerator kPINT_PatternMatchNever

Never contributes to product term match

enumerator kPINT_PatternMatchBothEdges

Either rising or falling edge

typedef enum _pint_pin_enable pint_pin_enable_t

PINT Pin Interrupt enable type.

typedef enum _pint_int pint_pin_int_t

PINT Pin Interrupt type.

typedef enum _pint_pmatch_input_src pint_pmatch_input_src_t

PINT Pattern Match bit slice input source type.

typedef enum _pint_pmatch_bslice pint_pmatch_bslice_t

PINT Pattern Match bit slice type.

typedef enum _pint_pmatch_bslice_cfg pint_pmatch_bslice_cfg_t

PINT Pattern Match configuration type.

typedef void (*pint_cb_t)(pint_pin_int_t pintr, uint32_t pmatch_status)

PINT Callback function.

typedef struct _pint_pmatch_cfg pint_pmatch_cfg_t
void PINT_Init(PINT_Type *base)

Initialize PINT peripheral.

This function initializes the PINT peripheral and enables the clock.

Parameters:
  • base – Base address of the PINT peripheral.

Return values:

None.

void PINT_PinInterruptConfig(PINT_Type *base, pint_pin_int_t intr, pint_pin_enable_t enable, pint_cb_t callback)

Configure PINT peripheral pin interrupt.

This function configures a given pin interrupt.

Parameters:
  • base – Base address of the PINT peripheral.

  • intr – Pin interrupt.

  • enable – Selects detection logic.

  • callback – Callback.

Return values:

None.

void PINT_PinInterruptGetConfig(PINT_Type *base, pint_pin_int_t pintr, pint_pin_enable_t *enable, pint_cb_t *callback)

Get PINT peripheral pin interrupt configuration.

This function returns the configuration of a given pin interrupt.

Parameters:
  • base – Base address of the PINT peripheral.

  • pintr – Pin interrupt.

  • enable – Pointer to store the detection logic.

  • callback – Callback.

Return values:

None.

void PINT_PinInterruptClrStatus(PINT_Type *base, pint_pin_int_t pintr)

Clear Selected pin interrupt status only when the pin was triggered by edge-sensitive.

This function clears the selected pin interrupt status.

Parameters:
  • base – Base address of the PINT peripheral.

  • pintr – Pin interrupt.

Return values:

None.

static inline uint32_t PINT_PinInterruptGetStatus(PINT_Type *base, pint_pin_int_t pintr)

Get Selected pin interrupt status.

This function returns the selected pin interrupt status.

Parameters:
  • base – Base address of the PINT peripheral.

  • pintr – Pin interrupt.

Return values:

status – = 0 No pin interrupt request. = 1 Selected Pin interrupt request active.

void PINT_PinInterruptClrStatusAll(PINT_Type *base)

Clear all pin interrupts status only when pins were triggered by edge-sensitive.

This function clears the status of all pin interrupts.

Parameters:
  • base – Base address of the PINT peripheral.

Return values:

None.

static inline uint32_t PINT_PinInterruptGetStatusAll(PINT_Type *base)

Get all pin interrupts status.

This function returns the status of all pin interrupts.

Parameters:
  • base – Base address of the PINT peripheral.

Return values:

status – Each bit position indicates the status of corresponding pin interrupt. = 0 No pin interrupt request. = 1 Pin interrupt request active.

static inline void PINT_PinInterruptClrFallFlag(PINT_Type *base, pint_pin_int_t pintr)

Clear Selected pin interrupt fall flag.

This function clears the selected pin interrupt fall flag.

Parameters:
  • base – Base address of the PINT peripheral.

  • pintr – Pin interrupt.

Return values:

None.

static inline uint32_t PINT_PinInterruptGetFallFlag(PINT_Type *base, pint_pin_int_t pintr)

Get selected pin interrupt fall flag.

This function returns the selected pin interrupt fall flag.

Parameters:
  • base – Base address of the PINT peripheral.

  • pintr – Pin interrupt.

Return values:

flag – = 0 Falling edge has not been detected. = 1 Falling edge has been detected.

static inline void PINT_PinInterruptClrFallFlagAll(PINT_Type *base)

Clear all pin interrupt fall flags.

This function clears the fall flag for all pin interrupts.

Parameters:
  • base – Base address of the PINT peripheral.

Return values:

None.

static inline uint32_t PINT_PinInterruptGetFallFlagAll(PINT_Type *base)

Get all pin interrupt fall flags.

This function returns the fall flag of all pin interrupts.

Parameters:
  • base – Base address of the PINT peripheral.

Return values:

flags – Each bit position indicates the falling edge detection of the corresponding pin interrupt. 0 Falling edge has not been detected. = 1 Falling edge has been detected.

static inline void PINT_PinInterruptClrRiseFlag(PINT_Type *base, pint_pin_int_t pintr)

Clear Selected pin interrupt rise flag.

This function clears the selected pin interrupt rise flag.

Parameters:
  • base – Base address of the PINT peripheral.

  • pintr – Pin interrupt.

Return values:

None.

static inline uint32_t PINT_PinInterruptGetRiseFlag(PINT_Type *base, pint_pin_int_t pintr)

Get selected pin interrupt rise flag.

This function returns the selected pin interrupt rise flag.

Parameters:
  • base – Base address of the PINT peripheral.

  • pintr – Pin interrupt.

Return values:

flag – = 0 Rising edge has not been detected. = 1 Rising edge has been detected.

static inline void PINT_PinInterruptClrRiseFlagAll(PINT_Type *base)

Clear all pin interrupt rise flags.

This function clears the rise flag for all pin interrupts.

Parameters:
  • base – Base address of the PINT peripheral.

Return values:

None.

static inline uint32_t PINT_PinInterruptGetRiseFlagAll(PINT_Type *base)

Get all pin interrupt rise flags.

This function returns the rise flag of all pin interrupts.

Parameters:
  • base – Base address of the PINT peripheral.

Return values:

flags – Each bit position indicates the rising edge detection of the corresponding pin interrupt. 0 Rising edge has not been detected. = 1 Rising edge has been detected.

void PINT_PatternMatchConfig(PINT_Type *base, pint_pmatch_bslice_t bslice, pint_pmatch_cfg_t *cfg)

Configure PINT pattern match.

This function configures a given pattern match bit slice.

Parameters:
  • base – Base address of the PINT peripheral.

  • bslice – Pattern match bit slice number.

  • cfg – Pointer to bit slice configuration.

Return values:

None.

void PINT_PatternMatchGetConfig(PINT_Type *base, pint_pmatch_bslice_t bslice, pint_pmatch_cfg_t *cfg)

Get PINT pattern match configuration.

This function returns the configuration of a given pattern match bit slice.

Parameters:
  • base – Base address of the PINT peripheral.

  • bslice – Pattern match bit slice number.

  • cfg – Pointer to bit slice configuration.

Return values:

None.

static inline uint32_t PINT_PatternMatchGetStatus(PINT_Type *base, pint_pmatch_bslice_t bslice)

Get pattern match bit slice status.

This function returns the status of selected bit slice.

Parameters:
  • base – Base address of the PINT peripheral.

  • bslice – Pattern match bit slice number.

Return values:

status – = 0 Match has not been detected. = 1 Match has been detected.

static inline uint32_t PINT_PatternMatchGetStatusAll(PINT_Type *base)

Get status of all pattern match bit slices.

This function returns the status of all bit slices.

Parameters:
  • base – Base address of the PINT peripheral.

Return values:

status – Each bit position indicates the match status of corresponding bit slice. = 0 Match has not been detected. = 1 Match has been detected.

uint32_t PINT_PatternMatchResetDetectLogic(PINT_Type *base)

Reset pattern match detection logic.

This function resets the pattern match detection logic if any of the product term is matching.

Parameters:
  • base – Base address of the PINT peripheral.

Return values:

pmstatus – Each bit position indicates the match status of corresponding bit slice. = 0 Match was detected. = 1 Match was not detected.

static inline void PINT_PatternMatchEnable(PINT_Type *base)

Enable pattern match function.

This function enables the pattern match function.

Parameters:
  • base – Base address of the PINT peripheral.

Return values:

None.

static inline void PINT_PatternMatchDisable(PINT_Type *base)

Disable pattern match function.

This function disables the pattern match function.

Parameters:
  • base – Base address of the PINT peripheral.

Return values:

None.

static inline void PINT_PatternMatchEnableRXEV(PINT_Type *base)

Enable RXEV output.

This function enables the pattern match RXEV output.

Parameters:
  • base – Base address of the PINT peripheral.

Return values:

None.

static inline void PINT_PatternMatchDisableRXEV(PINT_Type *base)

Disable RXEV output.

This function disables the pattern match RXEV output.

Parameters:
  • base – Base address of the PINT peripheral.

Return values:

None.

void PINT_EnableCallback(PINT_Type *base)

Enable callback.

This function enables the interrupt for the selected PINT peripheral. Although the pin(s) are monitored as soon as they are enabled, the callback function is not enabled until this function is called.

Parameters:
  • base – Base address of the PINT peripheral.

Return values:

None.

void PINT_DisableCallback(PINT_Type *base)

Disable callback.

This function disables the interrupt for the selected PINT peripheral. Although the pins are still being monitored but the callback function is not called.

Parameters:
  • base – Base address of the peripheral.

Return values:

None.

void PINT_Deinit(PINT_Type *base)

Deinitialize PINT peripheral.

This function disables the PINT clock.

Parameters:
  • base – Base address of the PINT peripheral.

Return values:

None.

void PINT_EnableCallbackByIndex(PINT_Type *base, pint_pin_int_t pintIdx)

enable callback by pin index.

This function enables callback by pin index instead of enabling all pins.

Parameters:
  • base – Base address of the peripheral.

  • pintIdx – pin index.

Return values:

None.

void PINT_DisableCallbackByIndex(PINT_Type *base, pint_pin_int_t pintIdx)

disable callback by pin index.

This function disables callback by pin index instead of disabling all pins.

Parameters:
  • base – Base address of the peripheral.

  • pintIdx – pin index.

Return values:

None.

PININT_BITSLICE_SRC_START
PININT_BITSLICE_SRC_MASK
PININT_BITSLICE_CFG_START
PININT_BITSLICE_CFG_MASK
PININT_BITSLICE_ENDP_MASK
PINT_PIN_INT_LEVEL
PINT_PIN_INT_EDGE
PINT_PIN_INT_FALL_OR_HIGH_LEVEL
PINT_PIN_INT_RISE
PINT_PIN_RISE_EDGE
PINT_PIN_FALL_EDGE
PINT_PIN_BOTH_EDGE
PINT_PIN_LOW_LEVEL
PINT_PIN_HIGH_LEVEL
struct _pint_pmatch_cfg
#include <fsl_pint.h>

PLU: Programmable Logic Unit

void PLU_Init(PLU_Type *base)

Enable the PLU clock and reset the module.

Note

This API should be called at the beginning of the application using the PLU driver.

Parameters:
  • base – PLU peripheral base address

void PLU_Deinit(PLU_Type *base)

Gate the PLU clock.

Parameters:
  • base – PLU peripheral base address

static inline void PLU_SetLutInputSource(PLU_Type *base, plu_lut_index_t lutIndex, plu_lut_in_index_t lutInIndex, plu_lut_input_source_t inputSrc)

Set Input source of LUT.

Note: An external clock must be applied to the PLU_CLKIN input when using FFs. For each LUT, the slot associated with the output from LUTn itself is tied low.

Parameters:
  • base – PLU peripheral base address.

  • lutIndex – LUT index (see plu_lut_index_t typedef enumeration).

  • lutInIndex – LUT input index (see plu_lut_in_index_t typedef enumeration).

  • inputSrc – LUT input source (see plu_lut_input_source_t typedef enumeration).

static inline void PLU_SetOutputSource(PLU_Type *base, plu_output_index_t outputIndex, plu_output_source_t outputSrc)

Set Output source of PLU.

Note: An external clock must be applied to the PLU_CLKIN input when using FFs.

Parameters:
  • base – PLU peripheral base address.

  • outputIndex – PLU output index (see plu_output_index_t typedef enumeration).

  • outputSrc – PLU output source (see plu_output_source_t typedef enumeration).

static inline void PLU_SetLutTruthTable(PLU_Type *base, plu_lut_index_t lutIndex, uint32_t truthTable)

Set Truth Table of LUT.

Parameters:
  • base – PLU peripheral base address.

  • lutIndex – LUT index (see plu_lut_index_t typedef enumeration).

  • truthTable – Truth Table value.

static inline uint32_t PLU_ReadOutputState(PLU_Type *base)

Read the current state of the 8 designated PLU Outputs.

Note: The PLU bus clock must be re-enabled prior to reading the Outpus Register if PLU bus clock is shut-off.

Parameters:
  • base – PLU peripheral base address.

Returns:

Current PLU output state value.

FSL_PLU_DRIVER_VERSION

Version 2.2.1

enum _plu_lut_index

Index of LUT.

Values:

enumerator kPLU_LUT_0

5-input Look-up Table 0

enumerator kPLU_LUT_1

5-input Look-up Table 1

enumerator kPLU_LUT_2

5-input Look-up Table 2

enumerator kPLU_LUT_3

5-input Look-up Table 3

enumerator kPLU_LUT_4

5-input Look-up Table 4

enumerator kPLU_LUT_5

5-input Look-up Table 5

enumerator kPLU_LUT_6

5-input Look-up Table 6

enumerator kPLU_LUT_7

5-input Look-up Table 7

enumerator kPLU_LUT_8

5-input Look-up Table 8

enumerator kPLU_LUT_9

5-input Look-up Table 9

enumerator kPLU_LUT_10

5-input Look-up Table 10

enumerator kPLU_LUT_11

5-input Look-up Table 11

enumerator kPLU_LUT_12

5-input Look-up Table 12

enumerator kPLU_LUT_13

5-input Look-up Table 13

enumerator kPLU_LUT_14

5-input Look-up Table 14

enumerator kPLU_LUT_15

5-input Look-up Table 15

enumerator kPLU_LUT_16

5-input Look-up Table 16

enumerator kPLU_LUT_17

5-input Look-up Table 17

enumerator kPLU_LUT_18

5-input Look-up Table 18

enumerator kPLU_LUT_19

5-input Look-up Table 19

enumerator kPLU_LUT_20

5-input Look-up Table 20

enumerator kPLU_LUT_21

5-input Look-up Table 21

enumerator kPLU_LUT_22

5-input Look-up Table 22

enumerator kPLU_LUT_23

5-input Look-up Table 23

enumerator kPLU_LUT_24

5-input Look-up Table 24

enumerator kPLU_LUT_25

5-input Look-up Table 25

enum _plu_lut_in_index

Inputs of LUT. 5 input present for each LUT.

Values:

enumerator kPLU_LUT_IN_0

LUT input 0

enumerator kPLU_LUT_IN_1

LUT input 1

enumerator kPLU_LUT_IN_2

LUT input 2

enumerator kPLU_LUT_IN_3

LUT input 3

enumerator kPLU_LUT_IN_4

LUT input 4

enum _plu_lut_input_source

Available sources of LUT input.

Values:

enumerator kPLU_LUT_IN_SRC_PLU_IN_0

Select PLU input 0 to be connected to LUTn Input x

enumerator kPLU_LUT_IN_SRC_PLU_IN_1

Select PLU input 1 to be connected to LUTn Input x

enumerator kPLU_LUT_IN_SRC_PLU_IN_2

Select PLU input 2 to be connected to LUTn Input x

enumerator kPLU_LUT_IN_SRC_PLU_IN_3

Select PLU input 3 to be connected to LUTn Input x

enumerator kPLU_LUT_IN_SRC_PLU_IN_4

Select PLU input 4 to be connected to LUTn Input x

enumerator kPLU_LUT_IN_SRC_PLU_IN_5

Select PLU input 5 to be connected to LUTn Input x

enumerator kPLU_LUT_IN_SRC_LUT_OUT_0

Select LUT output 0 to be connected to LUTn Input x

enumerator kPLU_LUT_IN_SRC_LUT_OUT_1

Select LUT output 1 to be connected to LUTn Input x

enumerator kPLU_LUT_IN_SRC_LUT_OUT_2

Select LUT output 2 to be connected to LUTn Input x

enumerator kPLU_LUT_IN_SRC_LUT_OUT_3

Select LUT output 3 to be connected to LUTn Input x

enumerator kPLU_LUT_IN_SRC_LUT_OUT_4

Select LUT output 4 to be connected to LUTn Input x

enumerator kPLU_LUT_IN_SRC_LUT_OUT_5

Select LUT output 5 to be connected to LUTn Input x

enumerator kPLU_LUT_IN_SRC_LUT_OUT_6

Select LUT output 6 to be connected to LUTn Input x

enumerator kPLU_LUT_IN_SRC_LUT_OUT_7

Select LUT output 7 to be connected to LUTn Input x

enumerator kPLU_LUT_IN_SRC_LUT_OUT_8

Select LUT output 8 to be connected to LUTn Input x

enumerator kPLU_LUT_IN_SRC_LUT_OUT_9

Select LUT output 9 to be connected to LUTn Input x

enumerator kPLU_LUT_IN_SRC_LUT_OUT_10

Select LUT output 10 to be connected to LUTn Input x

enumerator kPLU_LUT_IN_SRC_LUT_OUT_11

Select LUT output 11 to be connected to LUTn Input x

enumerator kPLU_LUT_IN_SRC_LUT_OUT_12

Select LUT output 12 to be connected to LUTn Input x

enumerator kPLU_LUT_IN_SRC_LUT_OUT_13

Select LUT output 13 to be connected to LUTn Input x

enumerator kPLU_LUT_IN_SRC_LUT_OUT_14

Select LUT output 14 to be connected to LUTn Input x

enumerator kPLU_LUT_IN_SRC_LUT_OUT_15

Select LUT output 15 to be connected to LUTn Input x

enumerator kPLU_LUT_IN_SRC_LUT_OUT_16

Select LUT output 16 to be connected to LUTn Input x

enumerator kPLU_LUT_IN_SRC_LUT_OUT_17

Select LUT output 17 to be connected to LUTn Input x

enumerator kPLU_LUT_IN_SRC_LUT_OUT_18

Select LUT output 18 to be connected to LUTn Input x

enumerator kPLU_LUT_IN_SRC_LUT_OUT_19

Select LUT output 19 to be connected to LUTn Input x

enumerator kPLU_LUT_IN_SRC_LUT_OUT_20

Select LUT output 20 to be connected to LUTn Input x

enumerator kPLU_LUT_IN_SRC_LUT_OUT_21

Select LUT output 21 to be connected to LUTn Input x

enumerator kPLU_LUT_IN_SRC_LUT_OUT_22

Select LUT output 22 to be connected to LUTn Input x

enumerator kPLU_LUT_IN_SRC_LUT_OUT_23

Select LUT output 23 to be connected to LUTn Input x

enumerator kPLU_LUT_IN_SRC_LUT_OUT_24

Select LUT output 24 to be connected to LUTn Input x

enumerator kPLU_LUT_IN_SRC_LUT_OUT_25

Select LUT output 25 to be connected to LUTn Input x

enumerator kPLU_LUT_IN_SRC_FLIPFLOP_0

Select Flip-Flops state 0 to be connected to LUTn Input x

enumerator kPLU_LUT_IN_SRC_FLIPFLOP_1

Select Flip-Flops state 1 to be connected to LUTn Input x

enumerator kPLU_LUT_IN_SRC_FLIPFLOP_2

Select Flip-Flops state 2 to be connected to LUTn Input x

enumerator kPLU_LUT_IN_SRC_FLIPFLOP_3

Select Flip-Flops state 3 to be connected to LUTn Input x

enum _plu_output_index

PLU output multiplexer registers.

Values:

enumerator kPLU_OUTPUT_0

PLU OUTPUT 0

enumerator kPLU_OUTPUT_1

PLU OUTPUT 1

enumerator kPLU_OUTPUT_2

PLU OUTPUT 2

enumerator kPLU_OUTPUT_3

PLU OUTPUT 3

enumerator kPLU_OUTPUT_4

PLU OUTPUT 4

enumerator kPLU_OUTPUT_5

PLU OUTPUT 5

enumerator kPLU_OUTPUT_6

PLU OUTPUT 6

enumerator kPLU_OUTPUT_7

PLU OUTPUT 7

enum _plu_output_source

Available sources of PLU output.

Values:

enumerator kPLU_OUT_SRC_LUT_0

Select LUT0 output to be connected to PLU output

enumerator kPLU_OUT_SRC_LUT_1

Select LUT1 output to be connected to PLU output

enumerator kPLU_OUT_SRC_LUT_2

Select LUT2 output to be connected to PLU output

enumerator kPLU_OUT_SRC_LUT_3

Select LUT3 output to be connected to PLU output

enumerator kPLU_OUT_SRC_LUT_4

Select LUT4 output to be connected to PLU output

enumerator kPLU_OUT_SRC_LUT_5

Select LUT5 output to be connected to PLU output

enumerator kPLU_OUT_SRC_LUT_6

Select LUT6 output to be connected to PLU output

enumerator kPLU_OUT_SRC_LUT_7

Select LUT7 output to be connected to PLU output

enumerator kPLU_OUT_SRC_LUT_8

Select LUT8 output to be connected to PLU output

enumerator kPLU_OUT_SRC_LUT_9

Select LUT9 output to be connected to PLU output

enumerator kPLU_OUT_SRC_LUT_10

Select LUT10 output to be connected to PLU output

enumerator kPLU_OUT_SRC_LUT_11

Select LUT11 output to be connected to PLU output

enumerator kPLU_OUT_SRC_LUT_12

Select LUT12 output to be connected to PLU output

enumerator kPLU_OUT_SRC_LUT_13

Select LUT13 output to be connected to PLU output

enumerator kPLU_OUT_SRC_LUT_14

Select LUT14 output to be connected to PLU output

enumerator kPLU_OUT_SRC_LUT_15

Select LUT15 output to be connected to PLU output

enumerator kPLU_OUT_SRC_LUT_16

Select LUT16 output to be connected to PLU output

enumerator kPLU_OUT_SRC_LUT_17

Select LUT17 output to be connected to PLU output

enumerator kPLU_OUT_SRC_LUT_18

Select LUT18 output to be connected to PLU output

enumerator kPLU_OUT_SRC_LUT_19

Select LUT19 output to be connected to PLU output

enumerator kPLU_OUT_SRC_LUT_20

Select LUT20 output to be connected to PLU output

enumerator kPLU_OUT_SRC_LUT_21

Select LUT21 output to be connected to PLU output

enumerator kPLU_OUT_SRC_LUT_22

Select LUT22 output to be connected to PLU output

enumerator kPLU_OUT_SRC_LUT_23

Select LUT23 output to be connected to PLU output

enumerator kPLU_OUT_SRC_LUT_24

Select LUT24 output to be connected to PLU output

enumerator kPLU_OUT_SRC_LUT_25

Select LUT25 output to be connected to PLU output

enumerator kPLU_OUT_SRC_FLIPFLOP_0

Select Flip-Flops state(0) to be connected to PLU output

enumerator kPLU_OUT_SRC_FLIPFLOP_1

Select Flip-Flops state(1) to be connected to PLU output

enumerator kPLU_OUT_SRC_FLIPFLOP_2

Select Flip-Flops state(2) to be connected to PLU output

enumerator kPLU_OUT_SRC_FLIPFLOP_3

Select Flip-Flops state(3) to be connected to PLU output

typedef enum _plu_lut_index plu_lut_index_t

Index of LUT.

typedef enum _plu_lut_in_index plu_lut_in_index_t

Inputs of LUT. 5 input present for each LUT.

typedef enum _plu_lut_input_source plu_lut_input_source_t

Available sources of LUT input.

typedef enum _plu_output_index plu_output_index_t

PLU output multiplexer registers.

typedef enum _plu_output_source plu_output_source_t

Available sources of PLU output.

Power Driver

enum pd_bits

Values:

enumerator kPDRUNCFG_PD_FRO_OUT
enumerator kPDRUNCFG_PD_FRO
enumerator kPDRUNCFG_PD_FLASH
enumerator kPDRUNCFG_PD_BOD
enumerator kPDRUNCFG_PD_ADC0
enumerator kPDRUNCFG_PD_LPOSC
enumerator kPDRUNCFG_PD_DAC0
enumerator kPDRUNCFG_PD_ACMP
enumerator kPDRUNCFG_ForceUnsigned
enum _power_wakeup

Deep sleep and power down mode wake up configurations.

Values:

enumerator kPDAWAKECFG_Wakeup_FRO_OUT
enumerator kPDAWAKECFG_Wakeup_FRO
enumerator kPDAWAKECFG_Wakeup_FLASH
enumerator kPDAWAKECFG_Wakeup_BOD
enumerator kPDAWAKECFG_Wakeup_ADC
enumerator kPDAWAKECFG_Wakeup_LPOSC
enumerator kPDAWAKECFG_Wakeup_DAC0
enumerator kPDAWAKECFG_Wakeup_ACMP
enum _power_dpd_wakeup_pin

Deep power down mode wake up pins.

Values:

enumerator KPmu_Dpd_En_Pio0_15
enumerator KPmu_Dpd_En_Pio0_9
enumerator KPmu_Dpd_En_Pio0_8
enumerator KPmu_Dpd_En_Pio0_17
enumerator KPmu_Dpd_En_Pio0_13
enumerator KPmu_Dpd_En_Pio0_4
enumerator KPmu_Dpd_En_Pio0_11
enumerator KPmu_Dpd_En_Pio0_10
enum _power_deep_sleep_active

Deep sleep/power down mode active part.

Values:

enumerator kPDSLEEPCFG_DeepSleepBODActive
enumerator kPDSLEEPCFG_DeepSleepLPOscActive
enum _power_gen_reg

pmu general purpose register index

Values:

enumerator kPmu_GenReg0

general purpose register0

enumerator kPmu_GenReg1

general purpose register1

enumerator kPmu_GenReg2

general purpose register2

enumerator kPmu_GenReg3

general purpose register3

enumerator kPmu_GenReg4

general purpose reguster4

enum _power_mode_config

Values:

enumerator kPmu_Sleep
enumerator kPmu_Deep_Sleep
enumerator kPmu_PowerDown
enumerator kPmu_Deep_PowerDown
enum _power_bod_reset_level

BOD reset level, if VDD below reset level value, the reset will be asserted.

Values:

enumerator kBod_ResetLevel0

BOD Reset Level0: 1.51V.

enum _power_bod_interrupt_level

BOD interrupt level, if VDD below interrupt level value, the BOD interrupt will be asserted.

Values:

enumerator kBod_InterruptLevelReserved

BOD interrupt level reserved.

enumerator kBod_InterruptLevel1

BOD interrupt level1: 2.24V.

enumerator kBod_InterruptLevel2

BOD interrupt level2: 2.52V.

enumerator kBod_InterruptLevel3

BOD interrupt level3: 2.81V.

typedef enum pd_bits pd_bit_t
typedef enum _power_gen_reg power_gen_reg_t

pmu general purpose register index

typedef enum _power_mode_config power_mode_cfg_t
typedef enum _power_bod_reset_level power_bod_reset_level_t

BOD reset level, if VDD below reset level value, the reset will be asserted.

typedef enum _power_bod_interrupt_level power_bod_interrupt_level_t

BOD interrupt level, if VDD below interrupt level value, the BOD interrupt will be asserted.

FSL_POWER_DRIVER_VERSION

power driver version 2.1.0.

PMUC_PCON_RESERVED_MASK

PMU PCON reserved mask, used to clear reserved field which should not write 1.

POWER_EnbaleLPO
static inline void POWER_EnablePD(pd_bit_t en)

API to enable PDRUNCFG bit in the Syscon. Note that enabling the bit powers down the peripheral.

Parameters:
  • en – peripheral for which to enable the PDRUNCFG bit

Returns:

none

static inline void POWER_DisablePD(pd_bit_t en)

API to disable PDRUNCFG bit in the Syscon. Note that disabling the bit powers up the peripheral.

Parameters:
  • en – peripheral for which to disable the PDRUNCFG bit

Returns:

none

static inline void POWER_EnableDeepSleep(void)

API to enable deep sleep bit in the ARM Core.

Returns:

none

static inline void POWER_DisableDeepSleep(void)

API to disable deep sleep bit in the ARM Core.

Returns:

none

void POWER_EnterSleep(void)

API to enter sleep power mode.

Returns:

none

void POWER_EnterDeepSleep(uint32_t activePart)

API to enter deep sleep power mode.

Parameters:
  • activePart – should be a single or combine value of _power_deep_sleep_active .

Returns:

none

void POWER_EnterPowerDown(uint32_t activePart)

API to enter power down mode.

Parameters:
  • activePart – should be a single or combine value of _power_deep_sleep_active .

Returns:

none

void POWER_EnterDeepPowerDownMode(void)

API to enter deep power down mode.

Returns:

none

static inline uint32_t POWER_GetSleepModeFlag(void)

API to get sleep mode flag.

Returns:

sleep mode flag: 0 is active mode, 1 is sleep mode entered.

static inline void POWER_ClrSleepModeFlag(void)

API to clear sleep mode flag.

static inline uint32_t POWER_GetDeepPowerDownModeFlag(void)

API to get deep power down mode flag.

Returns:

sleep mode flag: 0 not deep power down, 1 is deep power down mode entered.

static inline void POWER_ClrDeepPowerDownModeFlag(void)

API to clear deep power down mode flag.

static inline void POWER_ClrWakeupPinFlag(void)

API to clear wake up pin status flag.

static inline void POWER_EnableNonDpd(bool enable)

API to enable non deep power down mode.

Parameters:
  • enable – true is enable non deep power down, otherwise disable.

static inline void POWER_EnableLPO(bool enable)

API to enable LPO.

Parameters:
  • enable – true to enable LPO, false to disable LPO.

static inline void POWER_WakeUpConfig(uint32_t mask, bool powerDown)

API to config wakeup configurations for deep sleep mode and power down mode.

Parameters:
  • mask – wake up configurations for deep sleep mode and power down mode, reference _power_wakeup.

  • powerDown – true is power down the mask part, false is powered part.

static inline void POWER_DeepSleepConfig(uint32_t mask, bool powerDown)

API to config active part for deep sleep mode and power down mode.

Parameters:
  • mask – active part configurations for deep sleep mode and power down mode, reference _power_deep_sleep_active.

  • powerDown – true is power down the mask part, false is powered part.

static inline void POWER_DeepPowerDownWakeupSourceSelect(uint32_t wakeup_pin)
static inline void POWER_SetRetainData(power_gen_reg_t index, uint32_t data)

API to retore data to general purpose register which can be retain during deep power down mode.

Parameters:
  • index – general purpose data register index.

  • data – data to restore.

static inline uint32_t POWER_GetRetainData(power_gen_reg_t index)

API to get data from general purpose register which retain during deep power down mode.

Parameters:
  • index – general purpose data register index.

Returns:

data stored in the general purpose register.

static inline void POWER_SetBodLevel(power_bod_reset_level_t resetLevel, power_bod_interrupt_level_t interruptLevel, bool enable)

Set Bod interrupt level and reset level.

Parameters:
  • resetLevel – BOD reset threshold level, please refer to power_bod_reset_level_t.

  • interruptLevel – BOD interrupt threshold level, please refer to power_bod_interrupt_level_t.

  • enable – Used to enable/disable the BOD interrupt and BOD reset.

Reset Driver

enum _SYSCON_RSTn

Enumeration for peripheral reset control bits.

Defines the enumeration for peripheral reset control bits in PRESETCTRL/ASYNCPRESETCTRL registers

Values:

enumerator kFLASH_RST_N_SHIFT_RSTn

Flash controller reset control

enumerator kI2C0_RST_N_SHIFT_RSTn

I2C0 reset control

enumerator kGPIO0_RST_N_SHIFT_RSTn

GPIO0 reset control

enumerator kSWM_RST_N_SHIFT_RSTn

SWM reset control

enumerator kWKT_RST_N_SHIFT_RSTn

Self-wake-up timer(WKT) reset control

enumerator kMRT_RST_N_SHIFT_RSTn

Multi-rate timer(MRT) reset control

enumerator kSPI0_RST_N_SHIFT_RSTn

SPI0 reset control.

enumerator kCRC_RST_SHIFT_RSTn

CRC reset control

enumerator kUART0_RST_N_SHIFT_RSTn

UART0 reset control

enumerator kUART1_RST_N_SHIFT_RSTn

UART1 reset control

enumerator kIOCON_RST_N_SHIFT_RSTn

IOCON reset control

enumerator kACMP_RST_N_SHIFT_RSTn

Analog comparator reset control

enumerator kI2C1_RST_N_SHIFT_RSTn

I2C1 reset control

enumerator kADC_RST_N_SHIFT_RSTn

ADC reset control

enumerator kCTIMER0_RST_N_SHIFT_RSTn

CTIMER0 reset control

enumerator kDAC0_RST_N_SHIFT_RSTn

DAC0 reset control

enumerator kGPIOINT_RST_N_SHIFT_RSTn

GPIOINT reset control

enumerator kCAPT_RST_N_SHIFT_RSTn

Capacitive Touch reset control

enumerator kFRG0_RST_N_SHIFT_RSTn

Fractional baud rate generator 0 reset control

enumerator kPLU_RST_N_SHIFT_RSTn

PLU reset control

typedef enum _SYSCON_RSTn SYSCON_RSTn_t

Enumeration for peripheral reset control bits.

Defines the enumeration for peripheral reset control bits in PRESETCTRL/ASYNCPRESETCTRL registers

typedef SYSCON_RSTn_t reset_ip_name_t
void RESET_SetPeripheralReset(reset_ip_name_t peripheral)

Assert reset to peripheral.

Asserts reset signal to specified peripheral module.

Parameters:
  • peripheral – Assert reset to this peripheral. The enum argument contains encoding of reset register and reset bit position in the reset register.

void RESET_ClearPeripheralReset(reset_ip_name_t peripheral)

Clear reset to peripheral.

Clears reset signal to specified peripheral module, allows it to operate.

Parameters:
  • peripheral – Clear reset to this peripheral. The enum argument contains encoding of reset register and reset bit position in the reset register.

void RESET_PeripheralReset(reset_ip_name_t peripheral)

Reset peripheral module.

Reset peripheral module.

Parameters:
  • peripheral – Peripheral to reset. The enum argument contains encoding of reset register and reset bit position in the reset register.

static inline void RESET_ReleasePeripheralReset(reset_ip_name_t peripheral)

Release peripheral module.

Release peripheral module.

Parameters:
  • peripheral – Peripheral to release. The enum argument contains encoding of reset register and reset bit position in the reset register.

FSL_RESET_DRIVER_VERSION

reset driver version 2.4.0

FLASH_RSTS_N

Array initializers with peripheral reset bits

I2C_RSTS_N
GPIO_RSTS_N
SWM_RSTS_N
WKT_RSTS_N
MRT_RSTS_N
SPI_RSTS_N
CRC_RSTS_N
UART_RSTS_N
IOCON_RSTS_N
ACMP_RSTS_N
ADC_RSTS_N
CTIMER_RSTS_N
DAC_RSTS_N
GPIOINT_RSTS_N
CAPT_RSTS_N
FRG_RSTS_N
PLU_RSTS_N

SPI: Serial Peripheral Interface Driver

SPI Driver

void SPI_MasterGetDefaultConfig(spi_master_config_t *config)

Sets the SPI master configuration structure to default values.

The purpose of this API is to get the configuration structure initialized for use in SPI_MasterInit(). User may use the initialized structure unchanged in SPI_MasterInit(), or modify some fields of the structure before calling SPI_MasterInit(). After calling this API, the master is ready to transfer. Example:

spi_master_config_t config;
SPI_MasterGetDefaultConfig(&config);

Parameters:
  • config – pointer to master config structure

status_t SPI_MasterInit(SPI_Type *base, const spi_master_config_t *config, uint32_t srcClock_Hz)

Initializes the SPI with master configuration.

The configuration structure can be filled by user from scratch, or be set with default values by SPI_MasterGetDefaultConfig(). After calling this API, the slave is ready to transfer. Example

spi_master_config_t config = {
.baudRate_Bps = 500000,
...
};
SPI_MasterInit(SPI0, &config);

Parameters:
  • base – SPI base pointer

  • config – pointer to master configuration structure

  • srcClock_Hz – Source clock frequency.

void SPI_SlaveGetDefaultConfig(spi_slave_config_t *config)

Sets the SPI slave configuration structure to default values.

The purpose of this API is to get the configuration structure initialized for use in SPI_SlaveInit(). Modify some fields of the structure before calling SPI_SlaveInit(). Example:

spi_slave_config_t config;
SPI_SlaveGetDefaultConfig(&config);

Parameters:
  • config – pointer to slave configuration structure

status_t SPI_SlaveInit(SPI_Type *base, const spi_slave_config_t *config)

Initializes the SPI with slave configuration.

The configuration structure can be filled by user from scratch or be set with default values by SPI_SlaveGetDefaultConfig(). After calling this API, the slave is ready to transfer. Example

spi_slave_config_t config = {
.polarity = kSPI_ClockPolarityActiveHigh;
.phase = kSPI_ClockPhaseFirstEdge;
.direction = kSPI_MsbFirst;
...
};
SPI_SlaveInit(SPI0, &config);

Parameters:
  • base – SPI base pointer

  • config – pointer to slave configuration structure

void SPI_Deinit(SPI_Type *base)

De-initializes the SPI.

Calling this API resets the SPI module, gates the SPI clock. Disable the fifo if enabled. The SPI module can’t work unless calling the SPI_MasterInit/SPI_SlaveInit to initialize module.

Parameters:
  • base – SPI base pointer

static inline void SPI_Enable(SPI_Type *base, bool enable)

Enable or disable the SPI Master or Slave.

Parameters:
  • base – SPI base pointer

  • enable – or disable ( true = enable, false = disable)

static inline uint32_t SPI_GetStatusFlags(SPI_Type *base)

Gets the status flag.

Parameters:
  • base – SPI base pointer

Returns:

SPI Status, use status flag to AND _spi_status_flags could get the related status.

static inline void SPI_ClearStatusFlags(SPI_Type *base, uint32_t mask)

Clear the status flag.

Parameters:
  • base – SPI base pointer

  • mask – SPI Status, use status flag to AND _spi_status_flags could get the related status.

static inline void SPI_EnableInterrupts(SPI_Type *base, uint32_t irqs)

Enables the interrupt for the SPI.

Parameters:
  • base – SPI base pointer

  • irqs – SPI interrupt source. The parameter can be any combination of the following values:

    • kSPI_RxReadyInterruptEnable

    • kSPI_TxReadyInterruptEnable

static inline void SPI_DisableInterrupts(SPI_Type *base, uint32_t irqs)

Disables the interrupt for the SPI.

Parameters:
  • base – SPI base pointer

  • irqs – SPI interrupt source. The parameter can be any combination of the following values:

    • kSPI_RxReadyInterruptEnable

    • kSPI_TxReadyInterruptEnable

static inline bool SPI_IsMaster(SPI_Type *base)

Returns whether the SPI module is in master mode.

Parameters:
  • base – SPI peripheral address.

Returns:

Returns true if the module is in master mode or false if the module is in slave mode.

status_t SPI_MasterSetBaudRate(SPI_Type *base, uint32_t baudrate_Bps, uint32_t srcClock_Hz)

Sets the baud rate for SPI transfer. This is only used in master.

Parameters:
  • base – SPI base pointer

  • baudrate_Bps – baud rate needed in Hz.

  • srcClock_Hz – SPI source clock frequency in Hz.

static inline void SPI_WriteData(SPI_Type *base, uint16_t data)

Writes a data into the SPI data register directly.

Parameters:
  • base – SPI base pointer

  • data – needs to be write.

static inline void SPI_WriteConfigFlags(SPI_Type *base, uint32_t configFlags)

Writes a data into the SPI TXCTL register directly.

Parameters:
  • base – SPI base pointer

  • configFlags – control command needs to be written.

void SPI_WriteDataWithConfigFlags(SPI_Type *base, uint16_t data, uint32_t configFlags)

Writes a data control info and data into the SPI TX register directly.

Parameters:
  • base – SPI base pointer

  • data – value needs to be written.

  • configFlags – control command needs to be written.

static inline uint32_t SPI_ReadData(SPI_Type *base)

Gets a data from the SPI data register.

Parameters:
  • base – SPI base pointer

Returns:

Data in the register.

void SPI_SetTransferDelay(SPI_Type *base, const spi_delay_config_t *config)

Set delay time for transfer. the delay uint is SPI clock time, maximum value is 0xF.

Parameters:
  • base – SPI base pointer

  • config – configuration for delay option spi_delay_config_t.

void SPI_SetDummyData(SPI_Type *base, uint16_t dummyData)

Set up the dummy data. This API can change the default data to be transferred when users set the tx buffer to NULL.

Parameters:
  • base – SPI peripheral address.

  • dummyData – Data to be transferred when tx buffer is NULL.

status_t SPI_MasterTransferBlocking(SPI_Type *base, spi_transfer_t *xfer)

Transfers a block of data using a polling method.

Parameters:
  • base – SPI base pointer

  • xfer – pointer to spi_xfer_config_t structure

Return values:
  • kStatus_Success – Successfully start a transfer.

  • kStatus_InvalidArgument – Input argument is invalid.

  • kStatus_SPI_Timeout – The transfer timed out and was aborted.

status_t SPI_MasterTransferCreateHandle(SPI_Type *base, spi_master_handle_t *handle, spi_master_callback_t callback, void *userData)

Initializes the SPI master handle.

This function initializes the SPI master handle which can be used for other SPI master transactional APIs. Usually, for a specified SPI instance, call this API once to get the initialized handle.

Parameters:
  • base – SPI peripheral base address.

  • handle – SPI handle pointer.

  • callback – Callback function.

  • userData – User data.

status_t SPI_MasterTransferNonBlocking(SPI_Type *base, spi_master_handle_t *handle, spi_transfer_t *xfer)

Performs a non-blocking SPI interrupt transfer.

Parameters:
  • base – SPI peripheral base address.

  • handle – pointer to spi_master_handle_t structure which stores the transfer state

  • xfer – pointer to spi_xfer_config_t structure

Return values:
  • kStatus_Success – Successfully start a transfer.

  • kStatus_InvalidArgument – Input argument is invalid.

  • kStatus_SPI_Busy – SPI is not idle, is running another transfer.

status_t SPI_MasterTransferGetCount(SPI_Type *base, spi_master_handle_t *handle, size_t *count)

Gets the master transfer count.

This function gets the master transfer count.

Parameters:
  • base – SPI peripheral base address.

  • handle – Pointer to the spi_master_handle_t structure which stores the transfer state.

  • count – The number of bytes transferred by using the non-blocking transaction.

Returns:

status of status_t.

void SPI_MasterTransferAbort(SPI_Type *base, spi_master_handle_t *handle)

SPI master aborts a transfer using an interrupt.

This function aborts a transfer using an interrupt.

Parameters:
  • base – SPI peripheral base address.

  • handle – Pointer to the spi_master_handle_t structure which stores the transfer state.

void SPI_MasterTransferHandleIRQ(SPI_Type *base, spi_master_handle_t *handle)

Interrupts the handler for the SPI.

Parameters:
  • base – SPI peripheral base address.

  • handle – pointer to spi_master_handle_t structure which stores the transfer state.

status_t SPI_SlaveTransferCreateHandle(SPI_Type *base, spi_slave_handle_t *handle, spi_slave_callback_t callback, void *userData)

Initializes the SPI slave handle.

This function initializes the SPI slave handle which can be used for other SPI slave transactional APIs. Usually, for a specified SPI instance, call this API once to get the initialized handle.

Parameters:
  • base – SPI peripheral base address.

  • handle – SPI handle pointer.

  • callback – Callback function.

  • userData – User data.

status_t SPI_SlaveTransferNonBlocking(SPI_Type *base, spi_slave_handle_t *handle, spi_transfer_t *xfer)

Performs a non-blocking SPI slave interrupt transfer.

Note

The API returns immediately after the transfer initialization is finished.

Parameters:
  • base – SPI peripheral base address.

  • handle – pointer to spi_master_handle_t structure which stores the transfer state

  • xfer – pointer to spi_xfer_config_t structure

Return values:
  • kStatus_Success – Successfully start a transfer.

  • kStatus_InvalidArgument – Input argument is invalid.

  • kStatus_SPI_Busy – SPI is not idle, is running another transfer.

static inline status_t SPI_SlaveTransferGetCount(SPI_Type *base, spi_slave_handle_t *handle, size_t *count)

Gets the slave transfer count.

This function gets the slave transfer count.

Parameters:
  • base – SPI peripheral base address.

  • handle – Pointer to the spi_master_handle_t structure which stores the transfer state.

  • count – The number of bytes transferred by using the non-blocking transaction.

Returns:

status of status_t.

static inline void SPI_SlaveTransferAbort(SPI_Type *base, spi_slave_handle_t *handle)

SPI slave aborts a transfer using an interrupt.

This function aborts a transfer using an interrupt.

Parameters:
  • base – SPI peripheral base address.

  • handle – Pointer to the spi_slave_handle_t structure which stores the transfer state.

void SPI_SlaveTransferHandleIRQ(SPI_Type *base, spi_slave_handle_t *handle)

Interrupts a handler for the SPI slave.

Parameters:
  • base – SPI peripheral base address.

  • handle – pointer to spi_slave_handle_t structure which stores the transfer state

FSL_SPI_DRIVER_VERSION

SPI driver version.

enum _spi_xfer_option

SPI transfer option.

Values:

enumerator kSPI_EndOfFrame

Add delay at the end of each frame(the last clk edge).

enumerator kSPI_EndOfTransfer

Re-assert the CS signal after transfer finishes to deselect slave.

enumerator kSPI_ReceiveIgnore

Ignore the receive data.

enum _spi_shift_direction

SPI data shifter direction options.

Values:

enumerator kSPI_MsbFirst

Data transfers start with most significant bit.

enumerator kSPI_LsbFirst

Data transfers start with least significant bit.

enum _spi_clock_polarity

SPI clock polarity configuration.

Values:

enumerator kSPI_ClockPolarityActiveHigh

Active-high SPI clock (idles low).

enumerator kSPI_ClockPolarityActiveLow

Active-low SPI clock (idles high).

enum _spi_clock_phase

SPI clock phase configuration.

Values:

enumerator kSPI_ClockPhaseFirstEdge

First edge on SCK occurs at the middle of the first cycle of a data transfer.

enumerator kSPI_ClockPhaseSecondEdge

First edge on SCK occurs at the start of the first cycle of a data transfer.

enum _spi_ssel

Slave select.

Values:

enumerator kSPI_Ssel0Assert

Slave select 0

enumerator kSPI_SselDeAssertAll
enum _spi_spol

ssel polarity

Values:

enumerator kSPI_Spol0ActiveHigh
enumerator kSPI_Spol1ActiveHigh
enumerator kSPI_Spol2ActiveHigh
enumerator kSPI_Spol3ActiveHigh
enumerator kSPI_SpolActiveAllHigh
enumerator kSPI_SpolActiveAllLow
enum _spi_data_width

Transfer data width.

Values:

enumerator kSPI_Data4Bits

4 bits data width

enumerator kSPI_Data5Bits

5 bits data width

enumerator kSPI_Data6Bits

6 bits data width

enumerator kSPI_Data7Bits

7 bits data width

enumerator kSPI_Data8Bits

8 bits data width

enumerator kSPI_Data9Bits

9 bits data width

enumerator kSPI_Data10Bits

10 bits data width

enumerator kSPI_Data11Bits

11 bits data width

enumerator kSPI_Data12Bits

12 bits data width

enumerator kSPI_Data13Bits

13 bits data width

enumerator kSPI_Data14Bits

14 bits data width

enumerator kSPI_Data15Bits

15 bits data width

enumerator kSPI_Data16Bits

16 bits data width

SPI transfer status.

Values:

enumerator kStatus_SPI_Busy

SPI bus is busy

enumerator kStatus_SPI_Idle

SPI is idle

enumerator kStatus_SPI_Error

SPI error

enumerator kStatus_SPI_BaudrateNotSupport

Baudrate is not support in current clock source

enumerator kStatus_SPI_Timeout

SPI Timeout polling status flags.

enum _spi_interrupt_enable

SPI interrupt sources.

Values:

enumerator kSPI_RxReadyInterruptEnable

Rx ready interrupt

enumerator kSPI_TxReadyInterruptEnable

Tx ready interrupt

enumerator kSPI_RxOverrunInterruptEnable

Rx overrun interrupt

enumerator kSPI_TxUnderrunInterruptEnable

Tx underrun interrupt

enumerator kSPI_SlaveSelectAssertInterruptEnable

Slave select assert interrupt

enumerator kSPI_SlaveSelectDeassertInterruptEnable

Slave select deassert interrupt

enumerator kSPI_AllInterruptEnable
enum _spi_status_flags

SPI status flags.

Values:

enumerator kSPI_RxReadyFlag

Receive ready flag.

enumerator kSPI_TxReadyFlag

Transmit ready flag.

enumerator kSPI_RxOverrunFlag

Receive overrun flag.

enumerator kSPI_TxUnderrunFlag

Transmit underrun flag.

enumerator kSPI_SlaveSelectAssertFlag

Slave select assert flag.

enumerator kSPI_SlaveSelectDeassertFlag

slave select deassert flag.

enumerator kSPI_StallFlag

Stall flag.

enumerator kSPI_EndTransferFlag

End transfer bit.

enumerator kSPI_MasterIdleFlag

Master in idle status flag.

typedef enum _spi_shift_direction spi_shift_direction_t

SPI data shifter direction options.

typedef enum _spi_clock_polarity spi_clock_polarity_t

SPI clock polarity configuration.

typedef enum _spi_clock_phase spi_clock_phase_t

SPI clock phase configuration.

typedef enum _spi_ssel spi_ssel_t

Slave select.

typedef enum _spi_spol spi_spol_t

ssel polarity

typedef enum _spi_data_width spi_data_width_t

Transfer data width.

typedef struct _spi_delay_config spi_delay_config_t

SPI delay time configure structure.

typedef struct _spi_master_config spi_master_config_t

SPI master user configure structure.

typedef struct _spi_slave_config spi_slave_config_t

SPI slave user configure structure.

typedef struct _spi_transfer spi_transfer_t

SPI transfer structure.

typedef struct _spi_master_handle spi_master_handle_t

Master handle type.

typedef spi_master_handle_t spi_slave_handle_t

Slave handle type.

typedef void (*spi_master_callback_t)(SPI_Type *base, spi_master_handle_t *handle, status_t status, void *userData)

SPI master callback for finished transmit.

typedef void (*spi_slave_callback_t)(SPI_Type *base, spi_slave_handle_t *handle, status_t status, void *userData)

SPI slave callback for finished transmit.

volatile uint16_t s_dummyData[]
uint32_t SPI_GetInstance(SPI_Type *base)

Returns instance number for SPI peripheral base address.

SPI_DUMMYDATA

SPI dummy transfer data, the data is sent while txBuff is NULL.

FSL_SDK_ENABLE_SPI_DRIVER_TRANSACTIONAL_APIS
SPI_RETRY_TIMES

Retry times for waiting flag.

struct _spi_delay_config
#include <fsl_spi.h>

SPI delay time configure structure.

Public Members

uint8_t preDelay

Delay between SSEL assertion and the beginning of transfer.

uint8_t postDelay

Delay between the end of transfer and SSEL deassertion.

uint8_t frameDelay

Delay between frame to frame.

uint8_t transferDelay

Delay between transfer to transfer.

struct _spi_master_config
#include <fsl_spi.h>

SPI master user configure structure.

Public Members

bool enableLoopback

Enable loopback for test purpose

bool enableMaster

Enable SPI at initialization time

uint32_t baudRate_Bps

Baud Rate for SPI in Hz

spi_clock_polarity_t clockPolarity

Clock polarity

spi_clock_phase_t clockPhase

Clock phase

spi_shift_direction_t direction

MSB or LSB

uint8_t dataWidth

Width of the data

spi_ssel_t sselNumber

Slave select number

spi_spol_t sselPolarity

Configure active CS polarity

spi_delay_config_t delayConfig

Configure for delay time.

struct _spi_slave_config
#include <fsl_spi.h>

SPI slave user configure structure.

Public Members

bool enableSlave

Enable SPI at initialization time

spi_clock_polarity_t clockPolarity

Clock polarity

spi_clock_phase_t clockPhase

Clock phase

spi_shift_direction_t direction

MSB or LSB

uint8_t dataWidth

Width of the data

spi_spol_t sselPolarity

Configure active CS polarity

struct _spi_transfer
#include <fsl_spi.h>

SPI transfer structure.

Public Members

const uint8_t *txData

Send buffer

uint8_t *rxData

Receive buffer

size_t dataSize

Transfer bytes

uint32_t configFlags

Additional option to control transfer _spi_xfer_option.

struct _spi_master_handle
#include <fsl_spi.h>

SPI transfer handle structure.

Public Members

const uint8_t *volatile txData

Transfer buffer

uint8_t *volatile rxData

Receive buffer

volatile size_t txRemainingBytes

Number of data to be transmitted [in bytes]

volatile size_t rxRemainingBytes

Number of data to be received [in bytes]

size_t totalByteCount

A number of transfer bytes

volatile uint32_t state

SPI internal state

spi_master_callback_t callback

SPI callback

void *userData

Callback parameter

uint8_t dataWidth

Width of the data [Valid values: 1 to 16]

uint32_t lastCommand

Last command for transfer.

SWM: Switch Matrix Module

enum _swm_pinassignfixed_port_pin_type_t

SWM pinassignfixed_port_pin number.

Values:

enumerator kSWM_PLU_INPUT0_PortPin_P0_0

port_pin number P0_0.

enumerator kSWM_PLU_INPUT0_PortPin_P0_8

port_pin number P0_8.

enumerator kSWM_PLU_INPUT0_PortPin_P0_17

port_pin number P0_17.

enumerator kSWM_PLU_INPUT1_PortPin_P0_1

port_pin number P0_1.

enumerator kSWM_PLU_INPUT1_PortPin_P0_9

port_pin number P0_9.

enumerator kSWM_PLU_INPUT1_PortPin_P0_18

port_pin number P0_18.

enumerator kSWM_PLU_INPUT2_PortPin_P0_2

port_pin number P0_2.

enumerator kSWM_PLU_INPUT2_PortPin_P0_10

port_pin number P0_10.

enumerator kSWM_PLU_INPUT2_PortPin_P0_19

port_pin number P0_19.

enumerator kSWM_PLU_INPUT3_PortPin_P0_3

port_pin number P0_3.

enumerator kSWM_PLU_INPUT3_PortPin_P0_11

port_pin number P0_11.

enumerator kSWM_PLU_INPUT3_PortPin_P0_20

port_pin number P0_20.

enumerator kSWM_PLU_INPUT4_PortPin_P0_4

port_pin number P0_4.

enumerator kSWM_PLU_INPUT4_PortPin_P0_12

port_pin number P0_12.

enumerator kSWM_PLU_INPUT4_PortPin_P0_21

port_pin number P0_21.

enumerator kSWM_PLU_INPUT5_PortPin_P0_5

port_pin number P0_5.

enumerator kSWM_PLU_INPUT5_PortPin_P0_13

port_pin number P0_13.

enumerator kSWM_PLU_INPUT5_PortPin_P0_22

port_pin number P0_22.

enumerator kSWM_PLU_OUT0_PortPin_P0_7

port_pin number P0_7.

enumerator kSWM_PLU_OUT0_PortPin_P0_14

port_pin number P0_14.

enumerator kSWM_PLU_OUT0_PortPin_P0_23

port_pin number P0_23.

enumerator kSWM_PLU_OUT1_PortPin_P0_8

port_pin number P0_8.

enumerator kSWM_PLU_OUT1_PortPin_P0_15

port_pin number P0_15.

enumerator kSWM_PLU_OUT1_PortPin_P0_24

port_pin number P0_24.

enumerator kSWM_PLU_OUT2_PortPin_P0_9

port_pin number P0_9.

enumerator kSWM_PLU_OUT2_PortPin_P0_16

port_pin number P0_16.

enumerator kSWM_PLU_OUT2_PortPin_P0_25

port_pin number P0_25.

enumerator kSWM_PLU_OUT3_PortPin_P0_10

port_pin number P0_10.

enumerator kSWM_PLU_OUT3_PortPin_P0_17

port_pin number P0_17.

enumerator kSWM_PLU_OUT3_PortPin_P0_26

port_pin number P0_26.

enumerator kSWM_PLU_OUT4_PortPin_P0_11

port_pin number P0_11.

enumerator kSWM_PLU_OUT4_PortPin_P0_18

port_pin number P0_18.

enumerator kSWM_PLU_OUT4_PortPin_P0_27

port_pin number P0_27.

enumerator kSWM_PLU_OUT5_PortPin_P0_12

port_pin number P0_12.

enumerator kSWM_PLU_OUT5_PortPin_P0_19

port_pin number P0_19.

enumerator kSWM_PLU_OUT5_PortPin_P0_28

port_pin number P0_28.

enumerator kSWM_PLU_OUT6_PortPin_P0_13

port_pin number P0_13.

enumerator kSWM_PLU_OUT6_PortPin_P0_20

port_pin number P0_20.

enumerator kSWM_PLU_OUT6_PortPin_P0_29

port_pin number P0_29.

enumerator kSWM_PLU_OUT7_PortPin_P0_14

port_pin number P0_14.

enumerator kSWM_PLU_OUT7_PortPin_P0_21

port_pin number P0_21.

enumerator kSWM_PLU_OUT7_PortPin_P0_30

port_pin number P0_30.

enum _swm_port_pin_type_t

SWM port_pin number.

Values:

enumerator kSWM_PortPin_P0_0

port_pin number P0_0.

enumerator kSWM_PortPin_P0_1

port_pin number P0_1.

enumerator kSWM_PortPin_P0_2

port_pin number P0_2.

enumerator kSWM_PortPin_P0_3

port_pin number P0_3.

enumerator kSWM_PortPin_P0_4

port_pin number P0_4.

enumerator kSWM_PortPin_P0_5

port_pin number P0_5.

enumerator kSWM_PortPin_P0_6

port_pin number P0_6.

enumerator kSWM_PortPin_P0_7

port_pin number P0_7.

enumerator kSWM_PortPin_P0_8

port_pin number P0_8.

enumerator kSWM_PortPin_P0_9

port_pin number P0_9.

enumerator kSWM_PortPin_P0_10

port_pin number P0_10.

enumerator kSWM_PortPin_P0_11

port_pin number P0_11.

enumerator kSWM_PortPin_P0_12

port_pin number P0_12.

enumerator kSWM_PortPin_P0_13

port_pin number P0_13.

enumerator kSWM_PortPin_P0_14

port_pin number P0_14.

enumerator kSWM_PortPin_P0_15

port_pin number P0_15.

enumerator kSWM_PortPin_P0_16

port_pin number P0_16.

enumerator kSWM_PortPin_P0_17

port_pin number P0_17.

enumerator kSWM_PortPin_P0_18

port_pin number P0_18.

enumerator kSWM_PortPin_P0_19

port_pin number P0_19.

enumerator kSWM_PortPin_P0_20

port_pin number P0_20.

enumerator kSWM_PortPin_P0_21

port_pin number P0_21.

enumerator kSWM_PortPin_P0_22

port_pin number P0_22.

enumerator kSWM_PortPin_P0_23

port_pin number P0_23.

enumerator kSWM_PortPin_P0_24

port_pin number P0_24.

enumerator kSWM_PortPin_P0_25

port_pin number P0_25.

enumerator kSWM_PortPin_P0_26

port_pin number P0_26.

enumerator kSWM_PortPin_P0_27

port_pin number P0_27.

enumerator kSWM_PortPin_P0_28

port_pin number P0_28.

enumerator kSWM_PortPin_P0_29

port_pin number P0_29.

enumerator kSWM_PortPin_P0_30

port_pin number P0_30.

enumerator kSWM_PortPin_P0_31

port_pin number P0_31.

enumerator kSWM_PortPin_Reset

port_pin reset number.

enum _swm_pinassignfixed_select_movable_t

SWM pinassignfixed movable selection.

Values:

enumerator kSWM_PLU_INPUT0

Movable function as PLU_INPUT0.

enumerator kSWM_PLU_INPUT1

Movable function as PLU_INPUT1.

enumerator kSWM_PLU_INPUT2

Movable function as PLU_INPUT2.

enumerator kSWM_PLU_INPUT3

Movable function as PLU_INPUT3.

enumerator kSWM_PLU_INPUT4

Movable function as PLU_INPUT4.

enumerator kSWM_PLU_INPUT5

Movable function as PLU_INPUT5.

enumerator kSWM_PLU_OUT0

Movable function as PLU_OUT0.

enumerator kSWM_PLU_OUT1

Movable function as PLU_OUT1.

enumerator kSWM_PLU_OUT2

Movable function as PLU_OUT2.

enumerator kSWM_PLU_OUT3

Movable function as PLU_OUT3.

enumerator kSWM_PLU_OUT4

Movable function as PLU_OUT4.

enumerator kSWM_PLU_OUT5

Movable function as PLU_OUT5.

enumerator kSWM_PLU_OUT6

Movable function as PLU_OUT6.

enumerator kSWM_PLU_OUT7

Movable function as PLU_OUT7.

enumerator kSWM_PINASSINGNFIXED_MOVABLE_NUM_FUNCS

Movable function number.

enum _swm_select_movable_t

SWM movable selection.

Values:

enumerator kSWM_USART0_TXD

Movable function as USART0_TXD.

enumerator kSWM_USART0_RXD

Movable function as USART0_RXD.

enumerator kSWM_USART0_RTS

Movable function as USART0_RTS.

enumerator kSWM_USART0_CTS

Movable function as USART0_CTS.

enumerator kSWM_USART0_SCLK

Movable function as USART0_SCLK.

enumerator kSWM_USART1_TXD

Movable function as USART1_TXD.

enumerator kSWM_USART1_RXD

Movable function as USART1_RXD.

enumerator kSWM_USART1_SCLK

Movable function as USART1_SCLK.

enumerator kSWM_SPI0_SCK

Movable function as SPI0_SCK.

enumerator kSWM_SPI0_MOSI

Movable function as SPI0_MOSI.

enumerator kSWM_SPI0_MISO

Movable function as SPI0_MISO.

enumerator kSWM_SPI0_SSEL0

Movable function as SPI0_SSEL0.

enumerator kSWM_SPI0_SSEL1

Movable function as SPI0_SSEL1.

enumerator kSWM_T0_CAP_CHN0

Movable function as Timer Capture Channel 0.

enumerator kSWM_T0_CAP_CHN1

Movable function as Timer Capture Channel 1.

enumerator kSWM_T0_CAP_CHN2

Movable function as Timer Capture Channel 2.

enumerator kSWM_T0_MAT_CHN0

Movable function as Timer Match Channel 0.

enumerator kSWM_T0_MAT_CHN1

Movable function as Timer Match Channel 1.

enumerator kSWM_T0_MAT_CHN2

Movable function as Timer Match Channel 2.

enumerator kSWM_T0_MAT_CHN3

Movable function as Timer Match Channel 3.

enumerator kSWM_I2C0_SDA

Movable function as I2C0_SDA.

enumerator kSWM_I2C0_SCL

Movable function as I2C0_SCL.

enumerator kSWM_ACMP_OUT

Movable function as ACMP_OUT.

enumerator kSWM_CLKOUT

Movable function as CLKOUT.

enumerator kSWM_GPIO_INT_BMAT

Movable function as GPIO_INT_BMAT.

enumerator kSWM_LVLSHFT_IN0

Movable function as LVLSHFT_IN0.

enumerator kSWM_LVLSHFT_IN1

Movable function as LVLSHFT_IN1.

enumerator kSWM_LVLSHFT_OUT0

Movable function as LVLSHFT_OUT0.

enumerator kSWM_LVLSHFT_OUT1

Movable function as LVLSHFT_OUT1.

enumerator kSWM_I2C1_SDA

Movable function as I2C1_SDA.

enumerator kSWM_I2C1_SCL

Movable function as I2C1_SCL.

enumerator kSWM_PLU_CLKIN_IN

Movable function as PLU_CLKIN_IN.

enumerator kSWM_CAPT_X0

Movable function as CAPT_X0.

enumerator kSWM_CAPT_X1

Movable function as CAPT_X1.

enumerator kSWM_CAPT_X2

Movable function as CAPT_X2.

enumerator kSWM_CAPT_X3

Movable function as CAPT_X3.

enumerator kSWM_CAPT_X4

Movable function as CAPT_X4.

enumerator kSWM_CAPT_YL

Movable function as CAPT_YL.

enumerator kSWM_CAPT_YH

Movable function as CAPT_YH.

enumerator kSWM_MOVABLE_NUM_FUNCS

Movable function number.

enum _swm_select_fixed_pin_t

SWM fixed pin selection.

Values:

enumerator kSWM_ACMP_INPUT1

Fixed-pin function as ACMP_INPUT1.

enumerator kSWM_ACMP_INPUT2

Fixed-pin function as ACMP_INPUT2.

enumerator kSWM_ACMP_INPUT3

Fixed-pin function as ACMP_INPUT3.

enumerator kSWM_ACMP_INPUT4

Fixed-pin function as ACMP_INPUT4.

enumerator kSWM_SWCLK

Fixed-pin function as SWCLK.

enumerator kSWM_SWDIO

Fixed-pin function as SWDIO.

enumerator kSWM_RESETN

Fixed-pin function as RESETN.

enumerator kSWM_CLKIN

Fixed-pin function as CLKIN.

enumerator kSWM_WKCLKIN

Fixed-pin function as WKCLKIN.

enumerator kSWM_VDDCMP

Fixed-pin function as VDDCMP.

enumerator kSWM_ADC_CHN0

Fixed-pin function as ADC_CHN0.

enumerator kSWM_ADC_CHN1

Fixed-pin function as ADC_CHN1.

enumerator kSWM_ADC_CHN2

Fixed-pin function as ADC_CHN2.

enumerator kSWM_ADC_CHN3

Fixed-pin function as ADC_CHN3.

enumerator kSWM_ADC_CHN4

Fixed-pin function as ADC_CHN4.

enumerator kSWM_ADC_CHN5

Fixed-pin function as ADC_CHN5.

enumerator kSWM_ADC_CHN6

Fixed-pin function as ADC_CHN6.

enumerator kSWM_ADC_CHN7

Fixed-pin function as ADC_CHN7.

enumerator kSWM_ADC_CHN8

Fixed-pin function as ADC_CHN8.

enumerator kSWM_ADC_CHN9

Fixed-pin function as ADC_CHN9.

enumerator kSWM_ADC_CHN10

Fixed-pin function as ADC_CHN10.

enumerator kSWM_ADC_CHN11

Fixed-pin function as ADC_CHN11.

enumerator kSWM_ACMP_INPUT5

Fixed-pin function as ACMP_INPUT5.

enumerator kSWM_DAC_OUT0

Fixed-pin function as DACOUT0.

enumerator kSWM_FIXEDPIN_NUM_FUNCS

Fixed-pin function number.

typedef enum _swm_pinassignfixed_port_pin_type_t swm_fixed_port_pin_type_t

SWM pinassignfixed_port_pin number.

typedef enum _swm_port_pin_type_t swm_port_pin_type_t

SWM port_pin number.

typedef enum _swm_pinassignfixed_select_movable_t swm_select_fixed_movable_t

SWM pinassignfixed movable selection.

typedef enum _swm_select_movable_t swm_select_movable_t

SWM movable selection.

typedef enum _swm_select_fixed_pin_t swm_select_fixed_pin_t

SWM fixed pin selection.

FSL_SWM_DRIVER_VERSION

LPC SWM driver version.

void SWM_SetMovablePinSelect(SWM_Type *base, swm_select_movable_t func, swm_port_pin_type_t swm_port_pin)

Assignment of digital peripheral functions to pins.

This function will selects a pin (designated by its GPIO port and bit numbers) to a function.

Parameters:
  • base – SWM peripheral base address.

  • func – any function name that is movable.

  • swm_port_pin – any pin which has a GPIO port number and bit number.

void SWM_SetFixedMovablePinSelect(SWM_Type *base, swm_select_fixed_movable_t func, swm_fixed_port_pin_type_t swm_port_pin)

Assignment of digital peripheral functions to pins.

This function will selects a pin (designated by its GPIO port and bit numbers) to a function.

Parameters:
  • base – SWM peripheral base address.

  • func – any function name that is movable.

  • swm_port_pin – any pin which has a GPIO port number and bit number.

void SWM_SetFixedPinSelect(SWM_Type *base, swm_select_fixed_pin_t func, bool enable)

Enable the fixed-pin function.

This function will enables a fixed-pin function in PINENABLE0 or PINENABLE1.

Parameters:
  • base – SWM peripheral base address.

  • func – any function name that is fixed pin.

  • enable – enable or disable.

SYSCON: System Configuration

enum _syscon_connection_t

SYSCON connections type.

Values:

enumerator kSYSCON_GpioPort0Pin0ToPintsel

Pin Interrupt.

enumerator kSYSCON_GpioPort0Pin1ToPintsel
enumerator kSYSCON_GpioPort0Pin2ToPintsel
enumerator kSYSCON_GpioPort0Pin3ToPintsel
enumerator kSYSCON_GpioPort0Pin4ToPintsel
enumerator kSYSCON_GpioPort0Pin5ToPintsel
enumerator kSYSCON_GpioPort0Pin7ToPintsel
enumerator kSYSCON_GpioPort0Pin8ToPintsel
enumerator kSYSCON_GpioPort0Pin9ToPintsel
enumerator kSYSCON_GpioPort0Pin10ToPintsel
enumerator kSYSCON_GpioPort0Pin11ToPintsel
enumerator kSYSCON_GpioPort0Pin12ToPintsel
enumerator kSYSCON_GpioPort0Pin13ToPintsel
enumerator kSYSCON_GpioPort0Pin14ToPintsel
enumerator kSYSCON_GpioPort0Pin15ToPintsel
enumerator kSYSCON_GpioPort0Pin16ToPintsel
enumerator kSYSCON_GpioPort0Pin17ToPintsel
enumerator kSYSCON_GpioPort0Pin18ToPintsel
enumerator kSYSCON_GpioPort0Pin19ToPintsel
enumerator kSYSCON_GpioPort0Pin20ToPintsel
enumerator kSYSCON_GpioPort0Pin21ToPintsel
enumerator kSYSCON_GpioPort0Pin22ToPintsel
enumerator kSYSCON_GpioPort0Pin23ToPintsel
enumerator kSYSCON_GpioPort0Pin24ToPintsel
enumerator kSYSCON_GpioPort0Pin25ToPintsel
enumerator kSYSCON_GpioPort0Pin26ToPintsel
enumerator kSYSCON_GpioPort0Pin27ToPintsel
enumerator kSYSCON_GpioPort0Pin28ToPintsel
enumerator kSYSCON_GpioPort0Pin29ToPintsel
enumerator kSYSCON_GpioPort0Pin30ToPintsel
typedef enum _syscon_connection_t syscon_connection_t

SYSCON connections type.

PINTSEL_ID

Periphinmux IDs.

SYSCON_SHIFT
FSL_SYSON_DRIVER_VERSION

Group syscon driver version for SDK.

Version 2.0.1.

void SYSCON_AttachSignal(SYSCON_Type *base, uint32_t index, syscon_connection_t connection)

Attaches a signal.

This function gates the SYSCON clock.

Parameters:
  • base – Base address of the SYSCON peripheral.

  • index – Destination peripheral to attach the signal to.

  • connection – Selects connection.

Return values:

None.

USART: Universal Asynchronous Receiver/Transmitter Driver

USART Driver

uint32_t USART_GetInstance(USART_Type *base)

Returns instance number for USART peripheral base address.

status_t USART_Init(USART_Type *base, const usart_config_t *config, uint32_t srcClock_Hz)

Initializes a USART instance with user configuration structure and peripheral clock.

This function configures the USART module with the user-defined settings. The user can configure the configuration structure and also get the default configuration by using the USART_GetDefaultConfig() function. Example below shows how to use this API to configure USART.

usart_config_t usartConfig;
usartConfig.baudRate_Bps = 115200U;
usartConfig.parityMode = kUSART_ParityDisabled;
usartConfig.stopBitCount = kUSART_OneStopBit;
USART_Init(USART1, &usartConfig, 20000000U);

Parameters:
  • base – USART peripheral base address.

  • config – Pointer to user-defined configuration structure.

  • srcClock_Hz – USART clock source frequency in HZ.

Return values:
  • kStatus_USART_BaudrateNotSupport – Baudrate is not support in current clock source.

  • kStatus_InvalidArgument – USART base address is not valid

  • kStatus_Success – Status USART initialize succeed

void USART_Deinit(USART_Type *base)

Deinitializes a USART instance.

This function waits for TX complete, disables the USART clock.

Parameters:
  • base – USART peripheral base address.

void USART_GetDefaultConfig(usart_config_t *config)

Gets the default configuration structure.

This function initializes the USART configuration structure to a default value. The default values are: usartConfig->baudRate_Bps = 9600U; usartConfig->parityMode = kUSART_ParityDisabled; usartConfig->stopBitCount = kUSART_OneStopBit; usartConfig->bitCountPerChar = kUSART_8BitsPerChar; usartConfig->loopback = false; usartConfig->enableTx = false; usartConfig->enableRx = false; …

Parameters:
  • config – Pointer to configuration structure.

status_t USART_SetBaudRate(USART_Type *base, uint32_t baudrate_Bps, uint32_t srcClock_Hz)

Sets the USART instance baud rate.

This function configures the USART module baud rate. This function is used to update the USART module baud rate after the USART module is initialized by the USART_Init.

USART_SetBaudRate(USART1, 115200U, 20000000U);

Parameters:
  • base – USART peripheral base address.

  • baudrate_Bps – USART baudrate to be set.

  • srcClock_Hz – USART clock source frequency in HZ.

Return values:
  • kStatus_USART_BaudrateNotSupport – Baudrate is not support in current clock source.

  • kStatus_Success – Set baudrate succeed.

  • kStatus_InvalidArgument – One or more arguments are invalid.

static inline uint32_t USART_GetStatusFlags(USART_Type *base)

Get USART status flags.

This function get all USART status flags, the flags are returned as the logical OR value of the enumerators _usart_flags. To check a specific status, compare the return value with enumerators in _usart_flags. For example, to check whether the RX is ready:

if (kUSART_RxReady & USART_GetStatusFlags(USART1))
{
    ...
}

Parameters:
  • base – USART peripheral base address.

Returns:

USART status flags which are ORed by the enumerators in the _usart_flags.

static inline void USART_ClearStatusFlags(USART_Type *base, uint32_t mask)

Clear USART status flags.

This function clear supported USART status flags For example:

USART_ClearStatusFlags(USART1, kUSART_HardwareOverrunFlag)

Parameters:
  • base – USART peripheral base address.

  • mask – status flags to be cleared.

static inline void USART_EnableInterrupts(USART_Type *base, uint32_t mask)

Enables USART interrupts according to the provided mask.

This function enables the USART interrupts according to the provided mask. The mask is a logical OR of enumeration members. See _usart_interrupt_enable. For example, to enable TX ready interrupt and RX ready interrupt:

USART_EnableInterrupts(USART1, kUSART_RxReadyInterruptEnable | kUSART_TxReadyInterruptEnable);

Parameters:
  • base – USART peripheral base address.

  • mask – The interrupts to enable. Logical OR of _usart_interrupt_enable.

static inline void USART_DisableInterrupts(USART_Type *base, uint32_t mask)

Disables USART interrupts according to a provided mask.

This function disables the USART interrupts according to a provided mask. The mask is a logical OR of enumeration members. See _usart_interrupt_enable. This example shows how to disable the TX ready interrupt and RX ready interrupt:

USART_DisableInterrupts(USART1, kUSART_TxReadyInterruptEnable | kUSART_RxReadyInterruptEnable);

Parameters:
  • base – USART peripheral base address.

  • mask – The interrupts to disable. Logical OR of _usart_interrupt_enable.

static inline uint32_t USART_GetEnabledInterrupts(USART_Type *base)

Returns enabled USART interrupts.

This function returns the enabled USART interrupts.

Parameters:
  • base – USART peripheral base address.

static inline void USART_EnableContinuousSCLK(USART_Type *base, bool enable)

Continuous Clock generation. By default, SCLK is only output while data is being transmitted in synchronous mode. Enable this funciton, SCLK will run continuously in synchronous mode, allowing characters to be received on Un_RxD independently from transmission on Un_TXD).

Parameters:
  • base – USART peripheral base address.

  • enable – Enable Continuous Clock generation mode or not, true for enable and false for disable.

static inline void USART_EnableAutoClearSCLK(USART_Type *base, bool enable)

Enable Continuous Clock generation bit auto clear. While enable this cuntion, the Continuous Clock bit is automatically cleared when a complete character has been received. This bit is cleared at the same time.

Parameters:
  • base – USART peripheral base address.

  • enable – Enable auto clear or not, true for enable and false for disable.

static inline void USART_EnableCTS(USART_Type *base, bool enable)

Enable CTS. This function will determine whether CTS is used for flow control.

Parameters:
  • base – USART peripheral base address.

  • enable – Enable CTS or not, true for enable and false for disable.

static inline void USART_EnableTx(USART_Type *base, bool enable)

Enable the USART transmit.

This function will enable or disable the USART transmit.

Parameters:
  • base – USART peripheral base address.

  • enable – true for enable and false for disable.

static inline void USART_EnableRx(USART_Type *base, bool enable)

Enable the USART receive.

This function will enable or disable the USART receive. Note: if the transmit is enabled, the receive will not be disabled.

Parameters:
  • base – USART peripheral base address.

  • enable – true for enable and false for disable.

static inline void USART_WriteByte(USART_Type *base, uint8_t data)

Writes to the TXDAT register.

This function will writes data to the TXDAT automatly.The upper layer must ensure that TXDATA has space for data to write before calling this function.

Parameters:
  • base – USART peripheral base address.

  • data – The byte to write.

static inline uint8_t USART_ReadByte(USART_Type *base)

Reads the RXDAT directly.

This function reads data from the RXDAT automatly. The upper layer must ensure that the RXDAT is not empty before calling this function.

Parameters:
  • base – USART peripheral base address.

Returns:

The byte read from USART data register.

status_t USART_WriteBlocking(USART_Type *base, const uint8_t *data, size_t length)

Writes to the TX register using a blocking method.

This function polls the TX register, waits for the TX register to be empty.

Parameters:
  • base – USART peripheral base address.

  • data – Start address of the data to write.

  • length – Size of the data to write.

Return values:
  • kStatus_USART_Timeout – Transmission timed out and was aborted.

  • kStatus_Success – Successfully wrote all data.

status_t USART_ReadBlocking(USART_Type *base, uint8_t *data, size_t length)

Read RX data register using a blocking method.

This function polls the RX register, waits for the RX register to be full.

Parameters:
  • base – USART peripheral base address.

  • data – Start address of the buffer to store the received data.

  • length – Size of the buffer.

Return values:
  • kStatus_USART_FramingError – Receiver overrun happened while receiving data.

  • kStatus_USART_ParityError – Noise error happened while receiving data.

  • kStatus_USART_NoiseError – Framing error happened while receiving data.

  • kStatus_USART_RxError – Overflow or underflow happened.

  • kStatus_USART_Timeout – Transmission timed out and was aborted.

  • kStatus_Success – Successfully received all data.

status_t USART_TransferCreateHandle(USART_Type *base, usart_handle_t *handle, usart_transfer_callback_t callback, void *userData)

Initializes the USART handle.

This function initializes the USART handle which can be used for other USART transactional APIs. Usually, for a specified USART instance, call this API once to get the initialized handle.

Parameters:
  • base – USART peripheral base address.

  • handle – USART handle pointer.

  • callback – The callback function.

  • userData – The parameter of the callback function.

status_t USART_TransferSendNonBlocking(USART_Type *base, usart_handle_t *handle, usart_transfer_t *xfer)

Transmits a buffer of data using the interrupt method.

This function sends data using an interrupt method. This is a non-blocking function, which returns directly without waiting for all data to be written to the TX register. When all data is written to the TX register in the IRQ handler, the USART driver calls the callback function and passes the kStatus_USART_TxIdle as status parameter.

Note

The kStatus_USART_TxIdle is passed to the upper layer when all data is written to the TX register. However it does not ensure that all data are sent out. Before disabling the TX, check the kUSART_TransmissionCompleteFlag to ensure that the TX is finished.

Parameters:
  • base – USART peripheral base address.

  • handle – USART handle pointer.

  • xfer – USART transfer structure. See usart_transfer_t.

Return values:
  • kStatus_Success – Successfully start the data transmission.

  • kStatus_USART_TxBusy – Previous transmission still not finished, data not all written to TX register yet.

  • kStatus_InvalidArgument – Invalid argument.

void USART_TransferStartRingBuffer(USART_Type *base, usart_handle_t *handle, uint8_t *ringBuffer, size_t ringBufferSize)

Sets up the RX ring buffer.

This function sets up the RX ring buffer to a specific USART handle.

When the RX ring buffer is used, data received are stored into the ring buffer even when the user doesn’t call the USART_TransferReceiveNonBlocking() API. If there is already data received in the ring buffer, the user can get the received data from the ring buffer directly.

Note

When using the RX ring buffer, one byte is reserved for internal use. In other words, if ringBufferSize is 32, then only 31 bytes are used for saving data.

Parameters:
  • base – USART peripheral base address.

  • handle – USART handle pointer.

  • ringBuffer – Start address of the ring buffer for background receiving. Pass NULL to disable the ring buffer.

  • ringBufferSize – size of the ring buffer.

void USART_TransferStopRingBuffer(USART_Type *base, usart_handle_t *handle)

Aborts the background transfer and uninstalls the ring buffer.

This function aborts the background transfer and uninstalls the ring buffer.

Parameters:
  • base – USART peripheral base address.

  • handle – USART handle pointer.

size_t USART_TransferGetRxRingBufferLength(usart_handle_t *handle)

Get the length of received data in RX ring buffer.

Parameters:
  • handle – USART handle pointer.

Returns:

Length of received data in RX ring buffer.

void USART_TransferAbortSend(USART_Type *base, usart_handle_t *handle)

Aborts the interrupt-driven data transmit.

This function aborts the interrupt driven data sending. The user can get the remainBtyes to find out how many bytes are still not sent out.

Parameters:
  • base – USART peripheral base address.

  • handle – USART handle pointer.

status_t USART_TransferGetSendCount(USART_Type *base, usart_handle_t *handle, uint32_t *count)

Get the number of bytes that have been written to USART TX register.

This function gets the number of bytes that have been written to USART TX register by interrupt method.

Parameters:
  • base – USART peripheral base address.

  • handle – USART handle pointer.

  • count – Send bytes count.

Return values:
  • kStatus_NoTransferInProgress – No send in progress.

  • kStatus_InvalidArgument – Parameter is invalid.

  • kStatus_Success – Get successfully through the parameter count;

status_t USART_TransferReceiveNonBlocking(USART_Type *base, usart_handle_t *handle, usart_transfer_t *xfer, size_t *receivedBytes)

Receives a buffer of data using an interrupt method.

This function receives data using an interrupt method. This is a non-blocking function, which returns without waiting for all data to be received. If the RX ring buffer is used and not empty, the data in the ring buffer is copied and the parameter receivedBytes shows how many bytes are copied from the ring buffer. After copying, if the data in the ring buffer is not enough to read, the receive request is saved by the USART driver. When the new data arrives, the receive request is serviced first. When all data is received, the USART driver notifies the upper layer through a callback function and passes the status parameter kStatus_USART_RxIdle. For example, the upper layer needs 10 bytes but there are only 5 bytes in the ring buffer. The 5 bytes are copied to the xfer->data and this function returns with the parameter receivedBytes set to 5. For the left 5 bytes, newly arrived data is saved from the xfer->data[5]. When 5 bytes are received, the USART driver notifies the upper layer. If the RX ring buffer is not enabled, this function enables the RX and RX interrupt to receive data to the xfer->data. When all data is received, the upper layer is notified.

Parameters:
  • base – USART peripheral base address.

  • handle – USART handle pointer.

  • xfer – USART transfer structure, see usart_transfer_t.

  • receivedBytes – Bytes received from the ring buffer directly.

Return values:
  • kStatus_Success – Successfully queue the transfer into transmit queue.

  • kStatus_USART_RxBusy – Previous receive request is not finished.

  • kStatus_InvalidArgument – Invalid argument.

void USART_TransferAbortReceive(USART_Type *base, usart_handle_t *handle)

Aborts the interrupt-driven data receiving.

This function aborts the interrupt-driven data receiving. The user can get the remainBytes to find out how many bytes not received yet.

Parameters:
  • base – USART peripheral base address.

  • handle – USART handle pointer.

status_t USART_TransferGetReceiveCount(USART_Type *base, usart_handle_t *handle, uint32_t *count)

Get the number of bytes that have been received.

This function gets the number of bytes that have been received.

Parameters:
  • base – USART peripheral base address.

  • handle – USART handle pointer.

  • count – Receive bytes count.

Return values:
  • kStatus_NoTransferInProgress – No receive in progress.

  • kStatus_InvalidArgument – Parameter is invalid.

  • kStatus_Success – Get successfully through the parameter count;

void USART_TransferHandleIRQ(USART_Type *base, usart_handle_t *handle)

USART IRQ handle function.

This function handles the USART transmit and receive IRQ request.

Parameters:
  • base – USART peripheral base address.

  • handle – USART handle pointer.

FSL_USART_DRIVER_VERSION

USART driver version.

Error codes for the USART driver.

Values:

enumerator kStatus_USART_TxBusy

Transmitter is busy.

enumerator kStatus_USART_RxBusy

Receiver is busy.

enumerator kStatus_USART_TxIdle

USART transmitter is idle.

enumerator kStatus_USART_RxIdle

USART receiver is idle.

enumerator kStatus_USART_TxError

Error happens on tx.

enumerator kStatus_USART_RxError

Error happens on rx.

enumerator kStatus_USART_RxRingBufferOverrun

Error happens on rx ring buffer

enumerator kStatus_USART_NoiseError

USART noise error.

enumerator kStatus_USART_FramingError

USART framing error.

enumerator kStatus_USART_ParityError

USART parity error.

enumerator kStatus_USART_HardwareOverrun

USART hardware over flow.

enumerator kStatus_USART_BaudrateNotSupport

Baudrate is not support in current clock source

enumerator kStatus_USART_Timeout

USART times out.

enum _usart_parity_mode

USART parity mode.

Values:

enumerator kUSART_ParityDisabled

Parity disabled

enumerator kUSART_ParityEven

Parity enabled, type even, bit setting: PARITYSEL = 10

enumerator kUSART_ParityOdd

Parity enabled, type odd, bit setting: PARITYSEL = 11

enum _usart_sync_mode

USART synchronous mode.

Values:

enumerator kUSART_SyncModeDisabled

Asynchronous mode.

enumerator kUSART_SyncModeSlave

Synchronous slave mode.

enumerator kUSART_SyncModeMaster

Synchronous master mode.

enum _usart_stop_bit_count

USART stop bit count.

Values:

enumerator kUSART_OneStopBit

One stop bit

enumerator kUSART_TwoStopBit

Two stop bits

enum _usart_data_len

USART data size.

Values:

enumerator kUSART_7BitsPerChar

Seven bit mode

enumerator kUSART_8BitsPerChar

Eight bit mode

enum _usart_clock_polarity

USART clock polarity configuration, used in sync mode.

Values:

enumerator kUSART_RxSampleOnFallingEdge

Un_RXD is sampled on the falling edge of SCLK.

enumerator kUSART_RxSampleOnRisingEdge

Un_RXD is sampled on the rising edge of SCLK.

enum _usart_interrupt_enable

USART interrupt configuration structure, default settings all disabled.

Values:

enumerator kUSART_RxReadyInterruptEnable

Receive ready interrupt.

enumerator kUSART_TxReadyInterruptEnable

Transmit ready interrupt.

enumerator kUSART_TxIdleInterruptEnable

Transmit idle interrupt.

enumerator kUSART_DeltaCtsInterruptEnable

Cts pin change interrupt.

enumerator kUSART_TxDisableInterruptEnable

Transmit disable interrupt.

enumerator kUSART_HardwareOverRunInterruptEnable

hardware ove run interrupt.

enumerator kUSART_RxBreakInterruptEnable

Receive break interrupt.

enumerator kUSART_RxStartInterruptEnable

Receive ready interrupt.

enumerator kUSART_FramErrorInterruptEnable

Receive start interrupt.

enumerator kUSART_ParityErrorInterruptEnable

Receive frame error interrupt.

enumerator kUSART_RxNoiseInterruptEnable

Receive noise error interrupt.

enumerator kUSART_AutoBaudErrorInterruptEnable

Receive auto baud error interrupt.

enumerator kUSART_AllInterruptEnable

All interrupt.

enum _usart_flags

USART status flags.

This provides constants for the USART status flags for use in the USART functions.

Values:

enumerator kUSART_RxReady

Receive ready flag.

enumerator kUSART_RxIdleFlag

Receive IDLE flag.

enumerator kUSART_TxReady

Transmit ready flag.

enumerator kUSART_TxIdleFlag

Transmit idle flag.

enumerator kUSART_CtsState

Cts pin status.

enumerator kUSART_DeltaCtsFlag

Cts pin change flag.

enumerator kUSART_TxDisableFlag

Transmit disable flag.

enumerator kUSART_HardwareOverrunFlag

Hardware over run flag.

enumerator kUSART_RxBreakFlag

Receive break flag.

enumerator kUSART_RxStartFlag

receive start flag.

enumerator kUSART_FramErrorFlag

Frame error flag.

enumerator kUSART_ParityErrorFlag

Parity error flag.

enumerator kUSART_RxNoiseFlag

Receive noise flag.

enumerator kUSART_AutoBaudErrorFlag

Auto baud error flag.

typedef enum _usart_parity_mode usart_parity_mode_t

USART parity mode.

typedef enum _usart_sync_mode usart_sync_mode_t

USART synchronous mode.

typedef enum _usart_stop_bit_count usart_stop_bit_count_t

USART stop bit count.

typedef enum _usart_data_len usart_data_len_t

USART data size.

typedef enum _usart_clock_polarity usart_clock_polarity_t

USART clock polarity configuration, used in sync mode.

typedef struct _usart_config usart_config_t

USART configuration structure.

typedef struct _usart_transfer usart_transfer_t

USART transfer structure.

typedef struct _usart_handle usart_handle_t
typedef void (*usart_transfer_callback_t)(USART_Type *base, usart_handle_t *handle, status_t status, void *userData)

USART transfer callback function.

FSL_SDK_ENABLE_USART_DRIVER_TRANSACTIONAL_APIS

Macro gate for enable transaction API. 1 for enable, 0 for disable.

FSL_SDK_USART_DRIVER_ENABLE_BAUDRATE_AUTO_GENERATE

USART baud rate auto generate switch gate. 1 for enable, 0 for disable.

UART_RETRY_TIMES

Retry times for waiting flag.

Defining to zero means to keep waiting for the flag until it is assert/deassert.

struct _usart_config
#include <fsl_usart.h>

USART configuration structure.

Public Members

uint32_t baudRate_Bps

USART baud rate

bool enableRx

USART receive enable.

bool enableTx

USART transmit enable.

bool loopback

Enable peripheral loopback

bool enableContinuousSCLK

USART continuous Clock generation enable in synchronous master mode.

bool enableHardwareFlowControl

Enable hardware control RTS/CTS

usart_parity_mode_t parityMode

Parity mode, disabled (default), even, odd

usart_stop_bit_count_t stopBitCount

Number of stop bits, 1 stop bit (default) or 2 stop bits

usart_data_len_t bitCountPerChar

Data length - 7 bit, 8 bit

usart_sync_mode_t syncMode

Transfer mode - asynchronous, synchronous master, synchronous slave.

usart_clock_polarity_t clockPolarity

Selects the clock polarity and sampling edge in sync mode.

struct _usart_transfer
#include <fsl_usart.h>

USART transfer structure.

Public Members

size_t dataSize

The byte count to be transfer.

struct _usart_handle
#include <fsl_usart.h>

USART handle structure.

Public Members

const uint8_t *volatile txData

Address of remaining data to send.

volatile size_t txDataSize

Size of the remaining data to send.

size_t txDataSizeAll

Size of the data to send out.

uint8_t *volatile rxData

Address of remaining data to receive.

volatile size_t rxDataSize

Size of the remaining data to receive.

size_t rxDataSizeAll

Size of the data to receive.

uint8_t *rxRingBuffer

Start address of the receiver ring buffer.

size_t rxRingBufferSize

Size of the ring buffer.

volatile uint16_t rxRingBufferHead

Index for the driver to store received data into ring buffer.

volatile uint16_t rxRingBufferTail

Index for the user to get data from the ring buffer.

usart_transfer_callback_t callback

Callback function.

void *userData

USART callback function parameter.

volatile uint8_t txState

TX transfer state.

volatile uint8_t rxState

RX transfer state

union __unnamed6__

Public Members

uint8_t *data

The buffer of data to be transfer.

uint8_t *rxData

The buffer to receive data.

const uint8_t *txData

The buffer of data to be sent.

WKT: Self-wake-up Timer

void WKT_Init(WKT_Type *base, const wkt_config_t *config)

Ungates the WKT clock and configures the peripheral for basic operation.

Note

This API should be called at the beginning of the application using the WKT driver.

Parameters:
  • base – WKT peripheral base address

  • config – Pointer to user’s WKT config structure.

void WKT_Deinit(WKT_Type *base)

Gate the WKT clock.

Parameters:
  • base – WKT peripheral base address

static inline void WKT_GetDefaultConfig(wkt_config_t *config)

Initializes the WKT configuration structure.

This function initializes the WKT configuration structure to default values. The default values are as follows.

config->clockSource = kWKT_DividedFROClockSource;

See also

wkt_config_t

Parameters:
  • config – Pointer to the WKT configuration structure.

static inline uint32_t WKT_GetCounterValue(WKT_Type *base)

Read actual WKT counter value.

Parameters:
  • base – WKT peripheral base address

static inline uint32_t WKT_GetStatusFlags(WKT_Type *base)

Gets the WKT status flags.

Parameters:
  • base – WKT peripheral base address

Returns:

The status flags. This is the logical OR of members of the enumeration wkt_status_flags_t

static inline void WKT_ClearStatusFlags(WKT_Type *base, uint32_t mask)

Clears the WKT status flags.

Parameters:
  • base – WKT peripheral base address

  • mask – The status flags to clear. This is a logical OR of members of the enumeration wkt_status_flags_t

static inline void WKT_StartTimer(WKT_Type *base, uint32_t count)

Starts the timer counting.

After calling this function, timer loads a count value, counts down to 0, then stops.

Note

User can call the utility macros provided in fsl_common.h to convert to ticks Do not write to Counter register while the counting is in progress

Parameters:
  • base – WKT peripheral base address.

  • count – The value to be loaded into the WKT Count register

static inline void WKT_StopTimer(WKT_Type *base)

Stops the timer counting.

This function Clears the counter and stops the timer from counting.

Parameters:
  • base – WKT peripheral base address

FSL_WKT_DRIVER_VERSION

Version 2.0.2

enum _wkt_clock_source

Describes WKT clock source.

Values:

enumerator kWKT_DividedFROClockSource

WKT clock sourced from the divided FRO clock

enumerator kWKT_LowPowerClockSource

WKT clock sourced from the Low power clock Use this clock, LPOSCEN bit of DPDCTRL register must be enabled

enumerator kWKT_ExternalClockSource

WKT clock sourced from the Low power clock Use this clock, WAKECLKPAD_DISABLE bit of DPDCTRL register must be enabled

enum _wkt_status_flags

List of WKT flags.

Values:

enumerator kWKT_AlarmFlag

Alarm flag

typedef enum _wkt_clock_source wkt_clock_source_t

Describes WKT clock source.

typedef struct _wkt_config wkt_config_t

Describes WKT configuration structure.

typedef enum _wkt_status_flags wkt_status_flags_t

List of WKT flags.

struct _wkt_config
#include <fsl_wkt.h>

Describes WKT configuration structure.

Public Members

wkt_clock_source_t clockSource

External or internal clock source select

WWDT: Windowed Watchdog Timer Driver

void WWDT_GetDefaultConfig(wwdt_config_t *config)

Initializes WWDT configure structure.

This function initializes the WWDT configure structure to default value. The default value are:

config->enableWwdt = true;
config->enableWatchdogReset = false;
config->enableWatchdogProtect = false;
config->enableLockOscillator = false;
config->windowValue = 0xFFFFFFU;
config->timeoutValue = 0xFFFFFFU;
config->warningValue = 0;

See also

wwdt_config_t

Parameters:
  • config – Pointer to WWDT config structure.

void WWDT_Init(WWDT_Type *base, const wwdt_config_t *config)

Initializes the WWDT.

This function initializes the WWDT. When called, the WWDT runs according to the configuration.

Example:

wwdt_config_t config;
WWDT_GetDefaultConfig(&config);
config.timeoutValue = 0x7ffU;
WWDT_Init(wwdt_base,&config);

Parameters:
  • base – WWDT peripheral base address

  • config – The configuration of WWDT

void WWDT_Deinit(WWDT_Type *base)

Shuts down the WWDT.

This function shuts down the WWDT.

Parameters:
  • base – WWDT peripheral base address

static inline void WWDT_Enable(WWDT_Type *base)

Enables the WWDT module.

This function write value into WWDT_MOD register to enable the WWDT, it is a write-once bit; once this bit is set to one and a watchdog feed is performed, the watchdog timer will run permanently.

Parameters:
  • base – WWDT peripheral base address

static inline void WWDT_Disable(WWDT_Type *base)

Disables the WWDT module.

Deprecated:

Do not use this function. It will be deleted in next release version, for once the bit field of WDEN written with a 1, it can not be re-written with a 0.

This function write value into WWDT_MOD register to disable the WWDT.

Parameters:
  • base – WWDT peripheral base address

static inline uint32_t WWDT_GetStatusFlags(WWDT_Type *base)

Gets all WWDT status flags.

This function gets all status flags.

Example for getting Timeout Flag:

uint32_t status;
status = WWDT_GetStatusFlags(wwdt_base) & kWWDT_TimeoutFlag;

Parameters:
  • base – WWDT peripheral base address

Returns:

The status flags. This is the logical OR of members of the enumeration _wwdt_status_flags_t

void WWDT_ClearStatusFlags(WWDT_Type *base, uint32_t mask)

Clear WWDT flag.

This function clears WWDT status flag.

Example for clearing warning flag:

WWDT_ClearStatusFlags(wwdt_base, kWWDT_WarningFlag);

Parameters:
  • base – WWDT peripheral base address

  • mask – The status flags to clear. This is a logical OR of members of the enumeration _wwdt_status_flags_t

static inline void WWDT_SetWarningValue(WWDT_Type *base, uint32_t warningValue)

Set the WWDT warning value.

The WDWARNINT register determines the watchdog timer counter value that will generate a watchdog interrupt. When the watchdog timer counter is no longer greater than the value defined by WARNINT, an interrupt will be generated after the subsequent WDCLK.

Parameters:
  • base – WWDT peripheral base address

  • warningValue – WWDT warning value.

static inline void WWDT_SetTimeoutValue(WWDT_Type *base, uint32_t timeoutCount)

Set the WWDT timeout value.

This function sets the timeout value. Every time a feed sequence occurs the value in the TC register is loaded into the Watchdog timer. Writing a value below 0xFF will cause 0xFF to be loaded into the TC register. Thus the minimum time-out interval is TWDCLK*256*4. If enableWatchdogProtect flag is true in wwdt_config_t config structure, any attempt to change the timeout value before the watchdog counter is below the warning and window values will cause a watchdog reset and set the WDTOF flag.

Parameters:
  • base – WWDT peripheral base address

  • timeoutCount – WWDT timeout value, count of WWDT clock tick.

static inline void WWDT_SetWindowValue(WWDT_Type *base, uint32_t windowValue)

Sets the WWDT window value.

The WINDOW register determines the highest TV value allowed when a watchdog feed is performed. If a feed sequence occurs when timer value is greater than the value in WINDOW, a watchdog event will occur. To disable windowing, set windowValue to 0xFFFFFF (maximum possible timer value) so windowing is not in effect.

Parameters:
  • base – WWDT peripheral base address

  • windowValue – WWDT window value.

void WWDT_Refresh(WWDT_Type *base)

Refreshes the WWDT timer.

This function feeds the WWDT. This function should be called before WWDT timer is in timeout. Otherwise, a reset is asserted.

Parameters:
  • base – WWDT peripheral base address

FSL_WWDT_DRIVER_VERSION

Defines WWDT driver version.

WWDT_FIRST_WORD_OF_REFRESH

First word of refresh sequence

WWDT_SECOND_WORD_OF_REFRESH

Second word of refresh sequence

enum _wwdt_status_flags_t

WWDT status flags.

This structure contains the WWDT status flags for use in the WWDT functions.

Values:

enumerator kWWDT_TimeoutFlag

Time-out flag, set when the timer times out

enumerator kWWDT_WarningFlag

Warning interrupt flag, set when timer is below the value WDWARNINT

typedef struct _wwdt_config wwdt_config_t

Describes WWDT configuration structure.

struct _wwdt_config
#include <fsl_wwdt.h>

Describes WWDT configuration structure.

Public Members

bool enableWwdt

Enables or disables WWDT

bool enableWatchdogReset

true: Watchdog timeout will cause a chip reset false: Watchdog timeout will not cause a chip reset

bool enableWatchdogProtect

true: Enable watchdog protect i.e timeout value can only be changed after counter is below warning & window values false: Disable watchdog protect; timeout value can be changed at any time

bool enableLockOscillator

true: Disabling or powering down the watchdog oscillator is prevented Once set, this bit can only be cleared by a reset false: Do not lock oscillator

uint32_t windowValue

Window value, set this to 0xFFFFFF if windowing is not in effect

uint32_t timeoutValue

Timeout value

uint32_t warningValue

Watchdog time counter value that will generate a warning interrupt. Set this to 0 for no warning

uint32_t clockFreq_Hz

Watchdog clock source frequency.