`pub struct Ticks24(/* private fields */);`

## Expand description

24-bit `Ticks`

## Implementations§

## Trait Implementations§

source§### impl Ord for Ticks24

### impl Ord for Ticks24

source§### impl PartialEq for Ticks24

### impl PartialEq for Ticks24

source§### impl PartialOrd for Ticks24

### impl PartialOrd for Ticks24

1.0.0 · source§#### fn le(&self, other: &Rhs) -> bool

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

This method tests less than or equal to (for

`self`

and `other`

) and is used by the `<=`

operator. Read moresource§### impl Ticks for Ticks24

### impl Ticks for Ticks24

source§#### fn half_max_value() -> Self

#### fn half_max_value() -> Self

Returns the half the maximum value of this type, which should be (2^width-1).

source§#### fn into_usize(self) -> usize

#### fn into_usize(self) -> usize

Converts the type into a

`usize`

, stripping the higher bits
it if it is larger than `usize`

and filling the higher bits
with 0 if it is smaller than `usize`

.source§#### fn into_u32(self) -> u32

#### fn into_u32(self) -> u32

Converts the type into a

`u32`

, stripping the higher bits
it if it is larger than `u32`

and filling the higher bits
with 0 if it is smaller than `u32`

. Included as a simple
helper since Tock uses `u32`

pervasively and most platforms
are 32 bits.source§#### fn wrapping_add(self, other: Self) -> Self

#### fn wrapping_add(self, other: Self) -> Self

Add two values, wrapping around on overflow using standard
unsigned arithmetic.

source§#### fn wrapping_sub(self, other: Self) -> Self

#### fn wrapping_sub(self, other: Self) -> Self

Subtract two values, wrapping around on underflow using standard
unsigned arithmetic.

source§#### fn within_range(self, start: Self, end: Self) -> bool

#### fn within_range(self, start: Self, end: Self) -> bool

Returns whether the value is in the range of [

`start, `

end`) using unsigned arithmetic and considering wraparound. It returns `

true`if, incrementing from`

start`, the value will be reached before `

end`. Put another way, it returns `

(self - start) < (end - start)` in
unsigned arithmetic.source§#### fn from_or_max(val: u64) -> Self

#### fn from_or_max(val: u64) -> Self

Converts the specified val into this type if it fits otherwise the

`max_value()`

is returnedsource§#### fn saturating_scale(self, numerator: u32, denominator: u32) -> u32

#### fn saturating_scale(self, numerator: u32, denominator: u32) -> u32

Scales the ticks by the specified numerator and denominator. If the resulting value would
be greater than u32,

`u32::MAX`

is returned insteadsource§#### fn usize_padding() -> u32

#### fn usize_padding() -> u32

The amount of bits required to left-justify this ticks value
range (filling the lower bits with

`0`

) for it wrap at `(2 ** usize::BITS) - 1`

bits. For timers with a `width`

larger than
usize, this value will be `0`

(i.e., they can simply be
truncated to usize::BITS bits).source§#### fn into_usize_left_justified(self) -> usize

#### fn into_usize_left_justified(self) -> usize

Converts the type into a

`usize`

, left-justified and
right-padded with `0`

such that it is guaranteed to wrap at
`(2 ** usize::BITS) - 1`

. If it is larger than usize::BITS
bits, any higher bits are stripped. Read moresource§#### fn usize_left_justified_scale_freq<F: Frequency>() -> u32

#### fn usize_left_justified_scale_freq<F: Frequency>() -> u32

Convert the generic

`Frequency`

argument into a frequency
(Hertz) describing a left-justified ticks value as returned by
`Ticks::into_usize_left_justified`

.source§#### fn u32_padding() -> u32

#### fn u32_padding() -> u32

The amount of bits required to left-justify this ticks value
range (filling the lower bits with

`0`

) for it wrap at `(2 ** 32) - 1`

bits. For timers with a `width`

larger than 32, this
value will be `0`

(i.e., they can simply be truncated to
32-bits). Read moresource§#### fn into_u32_left_justified(self) -> u32

#### fn into_u32_left_justified(self) -> u32

Converts the type into a

`u32`

, left-justified and
right-padded with `0`

such that it is guaranteed to wrap at
`(2 ** 32) - 1`

. If it is larger than 32-bits, any higher bits
are stripped. Read moresource§#### fn u32_left_justified_scale_freq<F: Frequency>() -> u32

#### fn u32_left_justified_scale_freq<F: Frequency>() -> u32

Convert the generic

`Frequency`

argument into a frequency
(Hertz) describing a left-justified ticks value as returned by
`Ticks::into_u32_left_justified`

.### impl Copy for Ticks24

### impl Eq for Ticks24

## Auto Trait Implementations§

### impl Freeze for Ticks24

### impl RefUnwindSafe for Ticks24

### impl Send for Ticks24

### impl Sync for Ticks24

### impl Unpin for Ticks24

### impl UnwindSafe for Ticks24

## Blanket Implementations§

source§### impl<T> BorrowMut<T> for Twhere
T: ?Sized,

### impl<T> BorrowMut<T> for Twhere
T: ?Sized,

source§#### fn borrow_mut(&mut self) -> &mut T

#### fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

source§### impl<T> CloneToUninit for Twhere
T: Clone,

### impl<T> CloneToUninit for Twhere
T: Clone,

source§#### default unsafe fn clone_to_uninit(&self, dst: *mut T)

#### default unsafe fn clone_to_uninit(&self, dst: *mut T)

🔬This is a nightly-only experimental API. (

`clone_to_uninit`

)source§### impl<T> CloneToUninit for Twhere
T: Copy,

### impl<T> CloneToUninit for Twhere
T: Copy,

source§#### unsafe fn clone_to_uninit(&self, dst: *mut T)

#### unsafe fn clone_to_uninit(&self, dst: *mut T)

🔬This is a nightly-only experimental API. (

`clone_to_uninit`

)