pio_handler.h File Reference

Parallel Input/Output (PIO) interrupt handler for SAM. More...

Go to the source code of this file.

Functions
void	pio_capture_handler_set (void(*p_handler)(Pio *))
	Set a capture interrupt handler for all PIO.
void	pio_handler_process (Pio *p_pio, uint32_t ul_id)
	Process an interrupt request on the given PIO controller.
uint32_t	pio_handler_set (Pio *p_pio, uint32_t ul_id, uint32_t ul_mask, uint32_t ul_attr, void(*p_handler)(uint32_t, uint32_t))
	Set an interrupt handler for the provided pins.
uint32_t	pio_handler_set_pin (uint32_t ul_pin, uint32_t ul_flag, void(*p_handler)(uint32_t, uint32_t))
void	pio_handler_set_priority (Pio *p_pio, IRQn_Type ul_irqn, uint32_t ul_priority)
	Initialize PIO interrupt management logic.

Detailed Description

Parallel Input/Output (PIO) interrupt handler for SAM.

Copyright (c) 2011-2018 Microchip Technology Inc. and its subsidiaries.

\cond ASF_LICENSE

Definition in file pio_handler.h.

Function Documentation

pio_capture_handler_set()

void pio_capture_handler_set

(

void(*

p_handler )(Pio *)

)

Set a capture interrupt handler for all PIO.

The handler will be called with the triggering PIO as its parameter as soon as an interrupt is detected.

Parameters

p_handler

Interrupt handler function pointer.

Definition at line 174 of file pio_handler.c.

{
    pio_capture_handler = p_handler;
}

References pio_capture_handler.

pio_handler_process()

void pio_handler_process	(	Pio *	p_pio,
		uint32_t	ul_id )

Process an interrupt request on the given PIO controller.

Parameters

p_pio	PIO controller base address.
ul_id	PIO controller ID.

Definition at line 79 of file pio_handler.c.

{
    uint32_t status;
    uint32_t i;
 
    /* Read PIO controller status */
    status = pio_get_interrupt_status(p_pio);
    status &= pio_get_interrupt_mask(p_pio);
 
    /* Check pending events */
    if (status != 0) {
        /* Find triggering source */
        i = 0;
        while (status != 0) {
            /* Source is configured on the same controller */
            if (gs_interrupt_sources[i].id == ul_id) {
                /* Source has PIOs whose statuses have changed */
                if ((status & gs_interrupt_sources[i].mask) != 0) {
                    gs_interrupt_sources[i].handler(gs_interrupt_sources[i].id,
                            gs_interrupt_sources[i].mask);
                    status &= ~(gs_interrupt_sources[i].mask);
                }
            }
            i++;
            if (i >= MAX_INTERRUPT_SOURCES) {
                break;
            }
        }
    }
 
    /* Check capture events */
#if (SAM3S || SAM4S || SAM4E)
    if (pio_capture_enable_flag) {
        if (pio_capture_handler) {
            pio_capture_handler(p_pio);
        }
    }
#endif
}

References gs_interrupt_sources, s_interrupt_source::mask, MAX_INTERRUPT_SOURCES, pio_capture_enable_flag, pio_capture_handler, pio_get_interrupt_mask(), and pio_get_interrupt_status().

pio_handler_set()

uint32_t pio_handler_set	(	Pio *	p_pio,
		uint32_t	ul_id,
		uint32_t	ul_mask,
		uint32_t	ul_attr,
		void(*	p_handler )(uint32_t, uint32_t) )

Set an interrupt handler for the provided pins.

The provided handler will be called with the triggering pin as its parameter as soon as an interrupt is detected.

Parameters

p_pio	PIO controller base address.
ul_id	PIO ID.
ul_mask	Pins (bit mask) to configure.
ul_attr	Pins attribute to configure.
p_handler	Interrupt handler function pointer.

Returns

0 if successful, 1 if the maximum number of sources has been defined.

Definition at line 132 of file pio_handler.c.

{
    uint8_t i;
    struct s_interrupt_source *pSource;
 
    if (gs_ul_nb_sources >= MAX_INTERRUPT_SOURCES)
        return 1;
 
    /* Check interrupt for this pin, if already defined, redefine it. */
    for (i = 0; i <= gs_ul_nb_sources; i++) {
        pSource = &(gs_interrupt_sources[i]);
        if (pSource->id == ul_id && pSource->mask == ul_mask) {
            break;
        }
    }
 
    /* Define new source */
    pSource->id = ul_id;
    pSource->mask = ul_mask;
    pSource->attr = ul_attr;
    pSource->handler = p_handler;
    if (i == gs_ul_nb_sources + 1) {
        gs_ul_nb_sources++;
    }
 
    /* Configure interrupt mode */
    pio_configure_interrupt(p_pio, ul_mask, ul_attr);
 
    return 0;
}

References s_interrupt_source::attr, gs_interrupt_sources, gs_ul_nb_sources, s_interrupt_source::handler, s_interrupt_source::id, s_interrupt_source::mask, MAX_INTERRUPT_SOURCES, and pio_configure_interrupt().

pio_handler_set_pin()

uint32_t pio_handler_set_pin	(	uint32_t	ul_pin,
		uint32_t	ul_flag,
		void(*	p_handler )(uint32_t, uint32_t) )

pio_handler_set_priority()

void pio_handler_set_priority	(	Pio *	p_pio,
		IRQn_Type	ul_irqn,
		uint32_t	ul_priority )

Initialize PIO interrupt management logic.

Parameters

p_pio	PIO controller base address.
ul_irqn	NVIC line number.
ul_priority	PIO controller interrupts priority.

Definition at line 274 of file pio_handler.c.

{
    uint32_t bitmask = 0;
 
    bitmask = pio_get_interrupt_mask(p_pio);
    pio_disable_interrupt(p_pio, 0xFFFFFFFF);
    pio_get_interrupt_status(p_pio);
    NVIC_DisableIRQ(ul_irqn);
    NVIC_ClearPendingIRQ(ul_irqn);
    NVIC_SetPriority(ul_irqn, ul_priority);
    NVIC_EnableIRQ(ul_irqn);
    pio_enable_interrupt(p_pio, bitmask);
}

References pio_disable_interrupt(), pio_enable_interrupt(), pio_get_interrupt_mask(), and pio_get_interrupt_status().