Enum PerclkPodf 

#[repr(u8)]
pub enum PerclkPodf {
    DIVIDE_1 = 0,
    DIVIDE_2 = 1,
    DIVIDE_3 = 2,
    DIVIDE_4 = 3,
    DIVIDE_5 = 4,
    DIVIDE_6 = 5,
    DIVIDE_7 = 6,
    DIVIDE_8 = 7,
    DIVIDE_9 = 8,
    DIVIDE_10 = 9,
    DIVIDE_11 = 10,
    DIVIDE_12 = 11,
    DIVIDE_13 = 12,
    DIVIDE_14 = 13,
    DIVIDE_15 = 14,
    DIVIDE_16 = 15,
    DIVIDE_17 = 16,
    DIVIDE_18 = 17,
    DIVIDE_19 = 18,
    DIVIDE_20 = 19,
    DIVIDE_21 = 20,
    DIVIDE_22 = 21,
    DIVIDE_23 = 22,
    DIVIDE_24 = 23,
    DIVIDE_25 = 24,
    DIVIDE_26 = 25,
    DIVIDE_27 = 26,
    DIVIDE_28 = 27,
    DIVIDE_29 = 28,
    DIVIDE_30 = 29,
    DIVIDE_31 = 30,
    DIVIDE_32 = 31,
    DIVIDE_33 = 32,
    DIVIDE_34 = 33,
    DIVIDE_35 = 34,
    DIVIDE_36 = 35,
    DIVIDE_37 = 36,
    DIVIDE_38 = 37,
    DIVIDE_39 = 38,
    DIVIDE_40 = 39,
    DIVIDE_41 = 40,
    DIVIDE_42 = 41,
    DIVIDE_43 = 42,
    DIVIDE_44 = 43,
    DIVIDE_45 = 44,
    DIVIDE_46 = 45,
    DIVIDE_47 = 46,
    DIVIDE_48 = 47,
    DIVIDE_49 = 48,
    DIVIDE_50 = 49,
    DIVIDE_51 = 50,
    DIVIDE_52 = 51,
    DIVIDE_53 = 52,
    DIVIDE_54 = 53,
    DIVIDE_55 = 54,
    DIVIDE_56 = 55,
    DIVIDE_57 = 56,
    DIVIDE_58 = 57,
    DIVIDE_59 = 58,
    DIVIDE_60 = 59,
    DIVIDE_61 = 60,
    DIVIDE_62 = 61,
    DIVIDE_63 = 62,
    DIVIDE_64 = 63,
}

Variants

DIVIDE_1 = 0

Divide by 1

DIVIDE_2 = 1

Divide by 2

DIVIDE_3 = 2

Divide by 3

DIVIDE_4 = 3

Divide by 4

DIVIDE_5 = 4

Divide by 5

DIVIDE_6 = 5

Divide by 6

DIVIDE_7 = 6

Divide by 7

DIVIDE_8 = 7

Divide by 8

DIVIDE_9 = 8

Divide by 9

DIVIDE_10 = 9

Divide by 10

DIVIDE_11 = 10

Divide by 11

DIVIDE_12 = 11

Divide by 12

DIVIDE_13 = 12

Divide by 13

DIVIDE_14 = 13

Divide by 14

DIVIDE_15 = 14

Divide by 15

DIVIDE_16 = 15

Divide by 16

DIVIDE_17 = 16

Divide by 17

DIVIDE_18 = 17

Divide by 18

DIVIDE_19 = 18

Divide by 19

DIVIDE_20 = 19

Divide by 20

DIVIDE_21 = 20

Divide by 21

DIVIDE_22 = 21

Divide by 22

DIVIDE_23 = 22

Divide by 23

DIVIDE_24 = 23

Divide by 24

DIVIDE_25 = 24

Divide by 25

DIVIDE_26 = 25

Divide by 26

DIVIDE_27 = 26

Divide by 27

DIVIDE_28 = 27

Divide by 28

DIVIDE_29 = 28

Divide by 29

DIVIDE_30 = 29

Divide by 30

DIVIDE_31 = 30

Divide by 31

DIVIDE_32 = 31

Divide by 32

DIVIDE_33 = 32

Divide by 33

DIVIDE_34 = 33

Divide by 34

DIVIDE_35 = 34

Divide by 35

DIVIDE_36 = 35

Divide by 36

DIVIDE_37 = 36

Divide by 37

DIVIDE_38 = 37

Divide by 38

DIVIDE_39 = 38

Divide by 39

DIVIDE_40 = 39

Divide by 40

DIVIDE_41 = 40

Divide by 41

DIVIDE_42 = 41

Divide by 42

DIVIDE_43 = 42

Divide by 43

DIVIDE_44 = 43

Divide by 44

DIVIDE_45 = 44

Divide by 45

DIVIDE_46 = 45

Divide by 46

DIVIDE_47 = 46

Divide by 47

DIVIDE_48 = 47

Divide by 48

DIVIDE_49 = 48

Divide by 49

DIVIDE_50 = 49

Divide by 50

DIVIDE_51 = 50

Divide by 51

DIVIDE_52 = 51

Divide by 52

DIVIDE_53 = 52

Divide by 53

DIVIDE_54 = 53

Divide by 54

DIVIDE_55 = 54

Divide by 55

DIVIDE_56 = 55

Divide by 56

DIVIDE_57 = 56

Divide by 57

DIVIDE_58 = 57

Divide by 58

DIVIDE_59 = 58

Divide by 59

DIVIDE_60 = 59

Divide by 60

DIVIDE_61 = 60

Divide by 61

DIVIDE_62 = 61

Divide by 62

DIVIDE_63 = 62

Divide by 63

DIVIDE_64 = 63

Divide by 64

Implementations

impl PerclkPodf

pub const fn from_bits(val: u8) -> PerclkPodf

pub const fn to_bits(self) -> u8

Trait Implementations

impl Clone for PerclkPodf

fn clone(&self) -> PerclkPodf

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PerclkPodf

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

Formats the value using the given formatter.

impl From<PerclkPodf> for u8

fn from(val: PerclkPodf) -> u8

Converts to this type from the input type.

impl From<u8> for PerclkPodf

fn from(val: u8) -> PerclkPodf

Converts to this type from the input type.

impl Ord for PerclkPodf

fn cmp(&self, other: &PerclkPodf) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for PerclkPodf

fn eq(&self, other: &PerclkPodf) -> 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 PartialOrd for PerclkPodf

fn partial_cmp(&self, other: &PerclkPodf) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Copy for PerclkPodf

impl Eq for PerclkPodf

impl StructuralPartialEq for PerclkPodf