Struct DebugWriterComponent

pub struct DebugWriterComponent<const BUF_SIZE_BYTES: usize, C: SetDebugWriterCapability> { /* private fields */ }

Implementations

impl<const BUF_SIZE_BYTES: usize, C: SetDebugWriterCapability> DebugWriterComponent<BUF_SIZE_BYTES, C>

pub fn new<P: ThreadIdProvider>( uart_mux: &'static MuxUart<'_>, capability: C, ) -> Self

Create a debug writer component while binding the global variable used by debug.rs to the main thread.

pub fn new_unsafe<F>( uart_mux: &'static MuxUart<'_>, capability: C, bind_debug_global: F, ) -> Self

where F: FnOnce(),

Create a debug writer component and bind the global variable used by debug.rs to the main thread, but require that the caller(i.e., main.rs) provides the actual init call.

This allows moving the unsafe call to main.rs instead of being encapsulated in a component.

The resulting use of this component for platforms without atomics support looks like this:

 components::debug_writer::DebugWriterComponent::new(
     ...,
     || unsafe {
        kernel::debug::initialize_debug_writer_wrapper_unsafe::<
            <ChipHw as kernel::platform::chip::Chip>::ThreadIdProvider,
        >();
     })
.finalize(components::debug_writer_component_static!());

Trait Implementations

impl<const BUF_SIZE_BYTES: usize, C: SetDebugWriterCapability> Component for DebugWriterComponent<BUF_SIZE_BYTES, C>

type StaticInput = (&'static mut MaybeUninit<UartDevice<'static>>, &'static mut MaybeUninit<RingBuffer<'static, u8>>, &'static mut MaybeUninit<[u8; BUF_SIZE_BYTES]>, &'static mut MaybeUninit<UartDebugWriter>)

An optional type to specify the chip or board specific static memory that a component needs to setup the output object(s). This is the memory that crate::static_buf!() would normally setup, but generic components cannot setup static buffers for types which are chip-dependent, so those buffers have to be passed in manually, and the Component::StaticInput type makes this possible.

type Output = ()

The type (e.g., capsule, peripheral) that this implementation of Component produces via Component::finalize(). This is typically a static reference (&'static).

fn finalize(self, s: Self::StaticInput) -> Self::Output

A factory method that returns an instance of the Output type of this Component implementation. This is used in the boot sequence to instantiate and initialize part of the Tock kernel. This factory method may only be called once per Component instance.