Enum Interrupt 

#[repr(u16)]
pub enum Interrupt {
    SUPC = 0,
    RSTC = 1,
    RTC = 2,
    RTT = 3,
    WDT = 4,
    PMC = 5,
    EFC = 6,
    UART0 = 7,
    UART1 = 8,
    PIOA = 10,
    PIOB = 11,
    USART0 = 13,
    USART1 = 14,
    PIOD = 16,
    TWIHS0 = 19,
    TWIHS1 = 20,
    SSC = 22,
    TC0 = 23,
    TC1 = 24,
    TC2 = 25,
    TC3 = 26,
    TC4 = 27,
    TC5 = 28,
    AFEC0 = 29,
    DACC = 30,
    PWM0 = 31,
    ICM = 32,
    ACC = 33,
    USBHS = 34,
    AFEC1 = 40,
    QSPI = 43,
    UART2 = 44,
    TC6 = 47,
    TC7 = 48,
    TC8 = 49,
    TC9 = 50,
    TC10 = 51,
    TC11 = 52,
    AES = 56,
    TRNG = 57,
    XDMAC = 58,
    ISI = 59,
    PWM1 = 60,
    FPU = 61,
    RSWDT = 63,
    IXC = 68,
}

Enumeration of all the interrupts.

Variants

SUPC = 0

0 - SUPC

RSTC = 1

1 - RSTC

RTC = 2

2 - RTC

RTT = 3

3 - RTT

WDT = 4

4 - WDT

PMC = 5

5 - PMC

EFC = 6

6 - EFC

UART0 = 7

7 - UART0

UART1 = 8

8 - UART1

PIOA = 10

10 - PIOA

PIOB = 11

11 - PIOB

USART0 = 13

13 - USART0

USART1 = 14

14 - USART1

PIOD = 16

16 - PIOD

TWIHS0 = 19

19 - TWIHS0

TWIHS1 = 20

20 - TWIHS1

SSC = 22

22 - SSC

TC0 = 23

23 - TC0

TC1 = 24

24 - TC1

TC2 = 25

25 - TC2

TC3 = 26

26 - TC3

TC4 = 27

27 - TC4

TC5 = 28

28 - TC5

AFEC0 = 29

29 - AFEC0

DACC = 30

30 - DACC

PWM0 = 31

31 - PWM0

ICM = 32

32 - ICM

ACC = 33

33 - ACC

USBHS = 34

34 - USBHS

AFEC1 = 40

40 - AFEC1

QSPI = 43

43 - QSPI

UART2 = 44

44 - UART2

TC6 = 47

47 - TC6

TC7 = 48

48 - TC7

TC8 = 49

49 - TC8

TC9 = 50

50 - TC9

TC10 = 51

51 - TC10

TC11 = 52

52 - TC11

AES = 56

56 - AES

TRNG = 57

57 - TRNG

XDMAC = 58

58 - XDMAC

ISI = 59

59 - ISI

PWM1 = 60

60 - PWM1

FPU = 61

61 - FPU

RSWDT = 63

63 - RSWDT

IXC = 68

68 - IXC

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