Struct RingWriter 

pub struct RingWriter<R> { /* private fields */ }

The firmware end of a CDBG ring: appends frames, never waits.

Implementations

impl<R: Region> RingWriter<R>

pub unsafe fn init(region: R) -> Result<Self, RingError>

Reset region to a fresh, empty ring and write into it.

Debug SRAM often survives a warm reset, so the data area is zeroed before the cursors are parked: a stale packet header that still parses as valid would otherwise read as unread data and refuse the first real frames.

Safety

This must be the ring’s only writer for as long as it lives: two writers would race on write_ptr and the packet data.

pub unsafe fn attach(region: R) -> Result<Self, RingError>

Continue writing into the ring already in region, after validating it.

Safety

As for init: this must be the ring’s only writer.

pub fn into_region(self) -> R

The region back.

pub fn snapshot(&self) -> Descriptor

A point-in-time copy of the descriptor.

pub fn mark_panic(&mut self)

Latch Flags::Panic, keeping every other flag, so the reader can tell a crash from a clean end of stream.

Trait Implementations

impl<R: Region> TransportError for RingWriter<R>

type Error = RingError

impl<R: Region> TrySendTransport for RingWriter<R>

Appends one frame as one packet.

• Ok: the frame is in the ring and Flags::Overflow is cleared.
• TryError::WouldBlock: the ring is full of unread frames; the frame was dropped and Overflow latched. A later attempt succeeds once the reader drains.
• RingError::FrameTooLarge: the frame can never fit; dropped, Overflow latched.
• RingError::Faulted: the writer latched Flags::Error; nothing written.

Logs nothing: it runs inside the defmt logger, which must not re-enter defmt.

fn try_send(&mut self, frame: &[u8]) -> Result<(), TryError<RingError>>

Publish frame to the peer if the transport can take it now.

fn max_send_size(&self) -> usize

Maximum bytes transferable in a single try_send.