Enum interrupt

pub enum interrupt {
    FPU = 0,
    CACHE = 1,
    SPU = 3,
    CLOCK_POWER = 5,
    SERIAL0 = 8,
    SERIAL1 = 9,
    SPIM4 = 10,
    SERIAL2 = 11,
    SERIAL3 = 12,
    GPIOTE0 = 13,
    SAADC = 14,
    TIMER0 = 15,
    TIMER1 = 16,
    TIMER2 = 17,
    RTC0 = 20,
    RTC1 = 21,
    WDT0 = 24,
    WDT1 = 25,
    COMP_LPCOMP = 26,
    EGU0 = 27,
    EGU1 = 28,
    EGU2 = 29,
    EGU3 = 30,
    EGU4 = 31,
    EGU5 = 32,
    PWM0 = 33,
    PWM1 = 34,
    PWM2 = 35,
    PWM3 = 36,
    PDM0 = 38,
    I2S0 = 40,
    IPC = 42,
    QSPI = 43,
    NFCT = 45,
    GPIOTE1 = 47,
    QDEC0 = 51,
    QDEC1 = 52,
    USBD = 54,
    USBREGULATOR = 55,
    KMU = 57,
    CRYPTOCELL = 68,
}

Variants

FPU = 0

0 - FPU

CACHE = 1

1 - CACHE

SPU = 3

3 - SPU

CLOCK_POWER = 5

5 - CLOCK_POWER

SERIAL0 = 8

8 - SERIAL0

SERIAL1 = 9

9 - SERIAL1

SPIM4 = 10

10 - SPIM4

SERIAL2 = 11

11 - SERIAL2

SERIAL3 = 12

12 - SERIAL3

GPIOTE0 = 13

13 - GPIOTE0

SAADC = 14

14 - SAADC

TIMER0 = 15

15 - TIMER0

TIMER1 = 16

16 - TIMER1

TIMER2 = 17

17 - TIMER2

RTC0 = 20

20 - RTC0

RTC1 = 21

21 - RTC1

WDT0 = 24

24 - WDT0

WDT1 = 25

25 - WDT1

COMP_LPCOMP = 26

26 - COMP_LPCOMP

EGU0 = 27

27 - EGU0

EGU1 = 28

28 - EGU1

EGU2 = 29

29 - EGU2

EGU3 = 30

30 - EGU3

EGU4 = 31

31 - EGU4

EGU5 = 32

32 - EGU5

PWM0 = 33

33 - PWM0

PWM1 = 34

34 - PWM1

PWM2 = 35

35 - PWM2

PWM3 = 36

36 - PWM3

PDM0 = 38

38 - PDM0

I2S0 = 40

40 - I2S0

IPC = 42

42 - IPC

QSPI = 43

43 - QSPI

NFCT = 45

45 - NFCT

GPIOTE1 = 47

47 - GPIOTE1

QDEC0 = 51

51 - QDEC0

QDEC1 = 52

52 - QDEC1

USBD = 54

54 - USBD

USBREGULATOR = 55

55 - USBREGULATOR

KMU = 57

57 - KMU

CRYPTOCELL = 68

68 - CRYPTOCELL

Trait Implementations

impl Clone for Interrupt

fn clone(&self) -> Interrupt

Returns a copy 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