Enum Interrupt 

#[repr(u16)]
pub enum Interrupt {
    SPU = 3,
    CLOCK_POWER = 5,
    UARTE0_SPIM0_SPIS0_TWIM0_TWIS0 = 8,
    UARTE1_SPIM1_SPIS1_TWIM1_TWIS1 = 9,
    UARTE2_SPIM2_SPIS2_TWIM2_TWIS2 = 10,
    UARTE3_SPIM3_SPIS3_TWIM3_TWIS3 = 11,
    GPIOTE0 = 13,
    SAADC = 14,
    TIMER0 = 15,
    TIMER1 = 16,
    TIMER2 = 17,
    RTC0 = 20,
    RTC1 = 21,
    WDT = 24,
    EGU0 = 27,
    EGU1 = 28,
    EGU2 = 29,
    EGU3 = 30,
    EGU4 = 31,
    EGU5 = 32,
    PWM0 = 33,
    PWM1 = 34,
    PWM2 = 35,
    PWM3 = 36,
    PDM = 38,
    I2S = 40,
    IPC = 42,
    FPU = 44,
    GPIOTE1 = 49,
    KMU = 57,
    CRYPTOCELL = 64,
}

Enumeration of all the interrupts.

Variants

SPU = 3

3 - SPU

CLOCK_POWER = 5

5 - CLOCK_POWER

UARTE0_SPIM0_SPIS0_TWIM0_TWIS0 = 8

8 - UARTE0_SPIM0_SPIS0_TWIM0_TWIS0

UARTE1_SPIM1_SPIS1_TWIM1_TWIS1 = 9

9 - UARTE1_SPIM1_SPIS1_TWIM1_TWIS1

UARTE2_SPIM2_SPIS2_TWIM2_TWIS2 = 10

10 - UARTE2_SPIM2_SPIS2_TWIM2_TWIS2

UARTE3_SPIM3_SPIS3_TWIM3_TWIS3 = 11

11 - UARTE3_SPIM3_SPIS3_TWIM3_TWIS3

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

WDT = 24

24 - WDT

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

PDM = 38

38 - PDM

I2S = 40

40 - I2S

IPC = 42

42 - IPC

FPU = 44

44 - FPU

GPIOTE1 = 49

49 - GPIOTE1

KMU = 57

57 - KMU

CRYPTOCELL = 64

64 - CRYPTOCELL

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