Enum MPUSize 

pub enum MPUSize {
    Size32B = 5,
    Size64B = 6,
    Size128B = 7,
    Size256B = 8,
    Size512B = 9,
    Size1KB = 10,
    Size2KB = 11,
    Size4KB = 12,
    Size8KB = 13,
    Size16KB = 14,
    Size32KB = 15,
    Size64KB = 16,
    Size128KB = 17,
    Size256KB = 18,
    Size512KB = 19,
    Size1MB = 20,
    Size2MB = 21,
    Size4MB = 22,
    Size8MB = 23,
    Size16MB = 24,
    Size32MB = 25,
    Size64MB = 26,
    Size128MB = 27,
    Size256MB = 28,
    Size512MB = 29,
    Size1GB = 30,
    Size2GB = 31,
    Size4GB = 32,
}

MPU Region Size

ARM Cortex-M MPU requires power-of-2 sized regions Values represent the power of 2 (e.g., Size32B = 5 means 2^5 = 32 bytes)

Variants

Size32B = 5

32 bytes (2^5)

Size64B = 6

64 bytes (2^6)

Size128B = 7

128 bytes (2^7)

Size256B = 8

256 bytes (2^8)

Size512B = 9

512 bytes (2^9)

Size1KB = 10

1 KB (2^10)

Size2KB = 11

2 KB (2^11)

Size4KB = 12

4 KB (2^12)

Size8KB = 13

8 KB (2^13)

Size16KB = 14

16 KB (2^14)

Size32KB = 15

32 KB (2^15)

Size64KB = 16

64 KB (2^16)

Size128KB = 17

128 KB (2^17)

Size256KB = 18

256 KB (2^18)

Size512KB = 19

512 KB (2^19)

Size1MB = 20

1 MB (2^20)

Size2MB = 21

2 MB (2^21)

Size4MB = 22

4 MB (2^22)

Size8MB = 23

8 MB (2^23)

Size16MB = 24

16 MB (2^24)

Size32MB = 25

32 MB (2^25)

Size64MB = 26

64 MB (2^26)

Size128MB = 27

128 MB (2^27)

Size256MB = 28

256 MB (2^28)

Size512MB = 29

512 MB (2^29)

Size1GB = 30

1 GB (2^30)

Size2GB = 31

2 GB (2^31)

Size4GB = 32

4 GB (2^32)

Implementations

impl MPUSize

pub fn bytes(&self) -> u64

Get size in bytes

pub fn from_bytes(bytes: u64) -> Result<Self>

Create from byte size (rounds up to next power of 2)

Trait Implementations

impl Clone for MPUSize

fn clone(&self) -> MPUSize

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MPUSize

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

Formats the value using the given formatter.

impl PartialEq for MPUSize

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

impl Eq for MPUSize

impl StructuralPartialEq for MPUSize