Struct r3_kernel::System

pub struct System<Traits>(_);

Wraps a provided trait type Traits to instantiate a kernel. This type implements the traits from r3_core::kernel::raw, making it usable as a kernel, if Traits implements some appropriate traits, which consequently make it implement KernelTraits.

Trait Implementations

impl<Traits> Clone for System<Traits>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Traits> Debug for System<Traits>

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

Formats the value using the given formatter.

impl<Traits: KernelStatic<System<Traits>>> DelegateKernelStatic<System<Traits>> for System<Traits>

Implement KernelStatic<System<Traits>> on System<Traits> if the same trait is implemented on Traits.

type Target = Traits

impl<Traits: KernelTraits> KernelAdjustTime for System<Traits>

const RAW_TIME_USER_HEADROOM: Duration = TIME_USER_HEADROOM

Implements Kernel::time_user_headroom.

fn raw_adjust_time(delta: Duration) -> Result<(), AdjustTimeError>

Implements Kernel::adjust_time.

impl<Traits: KernelTraits> KernelBase for System<Traits>

fn raw_debug() -> Self::RawDebugPrinter

Get an object that implements Debug for dumping the current kernel state.

Note that printing this object might consume a large amount of stack space.

const RAW_SUPPORTED_QUEUE_ORDERS: &'static [Option<QueueOrderKind>] = _

Used by QueueOrder::is_supported.

fn raw_acquire_cpu_lock() -> Result<(), CpuLockError>

Implements Kernel::acquire_cpu_lock.

unsafe fn raw_release_cpu_lock() -> Result<(), CpuLockError>

Implements Kernel::release_cpu_lock.

fn raw_has_cpu_lock() -> bool

Return a flag indicating whether CPU Lock is currently active.

unsafe fn raw_unboost_priority() -> Result<(), BoostPriorityError>

Implements Kernel::unboost_priority.

fn raw_is_priority_boost_active() -> bool

Implements Kernel::is_priority_boost_active.

fn raw_is_task_context() -> bool

Implements Kernel::is_task_context.

fn raw_is_interrupt_context() -> bool

Implements Kernel::is_interrupt_context.

fn raw_is_boot_complete() -> bool

Implements Kernel::is_boot_complete.

fn raw_set_time(time: Time) -> Result<(), TimeError>

Implements Kernel::set_time.

unsafe fn raw_exit_task() -> Result<!, ExitTaskError>

Implements Kernel::exit_task.

fn raw_park() -> Result<(), ParkError>

Implements Kernel::park.

fn raw_park_timeout(timeout: Duration) -> Result<(), ParkTimeoutError>

Implements Kernel::park_timeout.

fn raw_sleep(timeout: Duration) -> Result<(), SleepError>

Implements Kernel::sleep.

type RawDebugPrinter = KernelDebugPrinter<Traits>

type RawTaskId = NonZeroUsize

The type to identify tasks.

fn raw_task_current() -> Result<Self::RawTaskId, GetCurrentTaskError>

Get the current task.

unsafe fn raw_task_activate( this: Self::RawTaskId ) -> Result<(), ActivateTaskError>

Implements Task::activate.

unsafe fn raw_task_interrupt( this: Self::RawTaskId ) -> Result<(), InterruptTaskError>

Implements Task::interrupt.

unsafe fn raw_task_unpark_exact( this: Self::RawTaskId ) -> Result<(), UnparkExactError>

Implements Task::unpark_exact.

unsafe fn raw_task_priority( this: Self::RawTaskId ) -> Result<usize, GetTaskPriorityError>

Implements Task::priority.

unsafe fn raw_task_effective_priority( this: Self::RawTaskId ) -> Result<usize, GetTaskPriorityError>

Implements Task::effective_priority.

impl<Traits: KernelTraits> KernelBoostPriority for System<Traits>

Available on crate feature priority_boost only.

fn raw_boost_priority() -> Result<(), BoostPriorityError>

Implements Kernel::boost_priority.

impl<Traits: KernelTraits> KernelEventGroup for System<Traits>

type RawEventGroupId = NonZeroUsize

The type to identify event groups.

unsafe fn raw_event_group_set( this: Id, bits: EventGroupBits ) -> Result<(), UpdateEventGroupError>

Implements EventGroup::set.

unsafe fn raw_event_group_clear( this: Id, bits: EventGroupBits ) -> Result<(), UpdateEventGroupError>

Implements EventGroup::clear.

unsafe fn raw_event_group_get( this: Id ) -> Result<EventGroupBits, GetEventGroupError>

Implements EventGroup::get.

unsafe fn raw_event_group_wait( this: Id, bits: EventGroupBits, flags: EventGroupWaitFlags ) -> Result<EventGroupBits, WaitEventGroupError>

Implements EventGroup::wait.

unsafe fn raw_event_group_wait_timeout( this: Id, bits: EventGroupBits, flags: EventGroupWaitFlags, timeout: Duration ) -> Result<EventGroupBits, WaitEventGroupTimeoutError>

Implements EventGroup::wait_timeout.

unsafe fn raw_event_group_poll( this: Id, bits: EventGroupBits, flags: EventGroupWaitFlags ) -> Result<EventGroupBits, PollEventGroupError>

Implements EventGroup::poll.

impl<Traits: KernelTraits> KernelInterruptLine for System<Traits>

const RAW_MANAGED_INTERRUPT_PRIORITY_RANGE: Range<InterruptPriority> = <Traits as PortInterrupts>::MANAGED_INTERRUPT_PRIORITY_RANGE

The range of interrupt priority values considered managed.

const RAW_MANAGED_INTERRUPT_LINES: &'static [InterruptNum] = <Traits as PortInterrupts>::MANAGED_INTERRUPT_LINES

The list of interrupt lines which are considered managed.

unsafe fn raw_interrupt_line_set_priority( this: InterruptNum, value: InterruptPriority ) -> Result<(), SetInterruptLinePriorityError>

Implements InterruptLine::set_priority.

unsafe fn raw_interrupt_line_enable( this: InterruptNum ) -> Result<(), EnableInterruptLineError>

Implements InterruptLine::enable.

unsafe fn raw_interrupt_line_disable( this: InterruptNum ) -> Result<(), EnableInterruptLineError>

Implements InterruptLine::disable.

unsafe fn raw_interrupt_line_pend( this: InterruptNum ) -> Result<(), PendInterruptLineError>

Implements InterruptLine::pend.

unsafe fn raw_interrupt_line_clear( this: InterruptNum ) -> Result<(), ClearInterruptLineError>

Implements InterruptLine::clear.

unsafe fn raw_interrupt_line_is_pending( this: InterruptNum ) -> Result<bool, QueryInterruptLineError>

Implements InterruptLine::is_pending.

impl<Traits: KernelTraits> KernelMutex for System<Traits>

type RawMutexId = NonZeroUsize

The type to identify mutexes.

const RAW_SUPPORTED_MUTEX_PROTOCOLS: &'static [Option<MutexProtocolKind>] = _

Used by MutexProtocol::is_supported.

unsafe fn raw_mutex_is_locked(this: Id) -> Result<bool, QueryMutexError>

Implements Mutex::is_locked.

unsafe fn raw_mutex_unlock(this: Id) -> Result<(), UnlockMutexError>

Implements Mutex::unlock.

unsafe fn raw_mutex_lock(this: Id) -> Result<(), LockMutexError>

Implements Mutex::lock.

unsafe fn raw_mutex_lock_timeout( this: Id, timeout: Duration ) -> Result<(), LockMutexTimeoutError>

Implements Mutex::lock_timeout.

unsafe fn raw_mutex_try_lock(this: Id) -> Result<(), TryLockMutexError>

Implements Mutex::try_lock.

unsafe fn raw_mutex_mark_consistent( this: Id ) -> Result<(), MarkConsistentMutexError>

Implements Mutex::mark_consistent.

impl<Traits: KernelTraits> KernelSemaphore for System<Traits>

type RawSemaphoreId = NonZeroUsize

The type to identify semaphores.

unsafe fn raw_semaphore_drain(this: Id) -> Result<(), DrainSemaphoreError>

Implements Semaphore::drain.

unsafe fn raw_semaphore_get( this: Id ) -> Result<SemaphoreValue, GetSemaphoreError>

Implements Semaphore::get.

unsafe fn raw_semaphore_signal( this: Id, count: SemaphoreValue ) -> Result<(), SignalSemaphoreError>

Implements Semaphore::signal.

unsafe fn raw_semaphore_signal_one(this: Id) -> Result<(), SignalSemaphoreError>

Implements Semaphore::signal_one.

unsafe fn raw_semaphore_wait_one(this: Id) -> Result<(), WaitSemaphoreError>

Implements Semaphore::wait_one.

unsafe fn raw_semaphore_wait_one_timeout( this: Id, timeout: Duration ) -> Result<(), WaitSemaphoreTimeoutError>

Implements Semaphore::wait_one_timeout.

unsafe fn raw_semaphore_poll_one(this: Id) -> Result<(), PollSemaphoreError>

Implements Semaphore::poll_one.

impl<Traits: KernelTraits> KernelTaskSetPriority for System<Traits>

unsafe fn raw_task_set_priority( this: Self::RawTaskId, priority: usize ) -> Result<(), SetTaskPriorityError>

Implements Task::set_priority.

impl<Traits: KernelTraits> KernelTime for System<Traits>

Available on crate feature system_time only.

fn raw_time() -> Result<Time, TimeError>

Implements Kernel::time.

impl<Traits: KernelTraits> KernelTimer for System<Traits>

type RawTimerId = NonZeroUsize

The type to identify timers.

unsafe fn raw_timer_start(this: Id) -> Result<(), StartTimerError>

Implements Timer::start.

unsafe fn raw_timer_stop(this: Id) -> Result<(), StopTimerError>

Implements Timer::stop.

unsafe fn raw_timer_set_delay( this: Id, delay: Option<Duration> ) -> Result<(), SetTimerDelayError>

Implements Timer::set_delay.

unsafe fn raw_timer_set_period( this: Id, period: Option<Duration> ) -> Result<(), SetTimerPeriodError>

Implements Timer::set_period.

impl<Traits> Copy for System<Traits>