Enum Interrupt 

#[repr(u16)]
pub enum Interrupt {
    WDT0 = 1,
    RTC = 3,
    TRNG = 4,
    TMR0 = 5,
    TMR1 = 6,
    TMR2 = 7,
    TMR3 = 8,
    TMR4 = 9,
    TMR5 = 10,
    I2C0 = 13,
    UART0 = 14,
    UART1 = 15,
    SPI1 = 16,
    ADC = 20,
    FLC0 = 23,
    GPIO0 = 24,
    GPIO1 = 25,
    GPIO2 = 26,
    DMA0 = 28,
    DMA1 = 29,
    DMA2 = 30,
    DMA3 = 31,
    UART2 = 34,
    I2C1 = 36,
    WUT = 53,
    SPI0 = 56,
    WDT1 = 57,
    PT = 59,
    I2C2 = 62,
    OWM = 67,
    DVS = 83,
    UART3 = 88,
    PCIF = 91,
    AES = 97,
    I2S = 99,
    LPCMP = 103,
}

Enumeration of all the interrupts.

Variants

WDT0 = 1

1 - WDT0

RTC = 3

3 - RTC interrupt.

TRNG = 4

4 - TRNG interrupt.

TMR0 = 5

5 - TMR0

TMR1 = 6

6 - TMR1 IRQ

TMR2 = 7

7 - TMR2 IRQ

TMR3 = 8

8 - TMR3 IRQ

TMR4 = 9

9 - TMR4 IRQ

TMR5 = 10

10 - TMR5 IRQ

I2C0 = 13

13 - I2C0 IRQ

UART0 = 14

14 - UART0

UART1 = 15

15 - UART1

SPI1 = 16

16 - SPI1 IRQ

ADC = 20

20 - ADC IRQ

FLC0 = 23

23 - Flash Controller interrupt.

GPIO0 = 24

24 - GPIO0 interrupt.

GPIO1 = 25

25 - GPIO1 IRQ

GPIO2 = 26

26 - GPIO2 IRQ

DMA0 = 28

28 - DMA0

DMA1 = 29

29 - DMA1

DMA2 = 30

30 - DMA2

DMA3 = 31

31 - DMA3

UART2 = 34

34 - UART2

I2C1 = 36

36 - I2C1 IRQ

WUT = 53

53 - WUT IRQ

SPI0 = 56

56 - SPI0

WDT1 = 57

57 - WDT1 IRQ

PT = 59

59 - Pulse Train IRQ

I2C2 = 62

62 - I2C2 IRQ

OWM = 67

67 - OWM

DVS = 83

83 - Dynamic Voltage Scaling Interrupt

UART3 = 88

88 - UART3

PCIF = 91

91 - PCIF

AES = 97

97 - AES

I2S = 99

99 - I2S IRQ

LPCMP = 103

103 - Low Power Comparato

Trait Implementations

impl Clone for Interrupt

fn clone(&self) -> Interrupt

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Interrupt

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl InterruptNumber for Interrupt

fn number(self) -> u16

Return the interrupt number associated with this variant.

impl PartialEq for Interrupt

fn eq(&self, other: &Interrupt) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for Interrupt

impl Eq for Interrupt

impl StructuralPartialEq for Interrupt