Struct Logger

pub struct Logger<SEND, RECV>
where
    SEND: Sender,
    RECV: Receiver,
{
    pub good_msgs: usize,
    pub good_bytes: usize,
    pub dropped_bytes: usize,
    pub dropped_msgs: usize,
    pub bad_cobs: usize,
    pub full_buf: usize,
    pub full_msg: usize,
    pub ttl_got: usize,
    /* private fields */
}

A binary logging interface, using UARTE0. target In the future other serial interfaces might be supported

Fields

good_msgs: usize

good_bytes: usize

dropped_bytes: usize

dropped_msgs: usize

bad_cobs: usize

full_buf: usize

full_msg: usize

ttl_got: usize

Implementations

impl<RECV, T, BUFSZ> Logger<RealSender<T, BUFSZ>, RECV>

where T: Serialize, BUFSZ: ArrayLength<u8>, RECV: Receiver + Default,

pub fn log(&mut self, data: &str) -> Result<(), ()>

Send a log level &str message

pub fn warn(&mut self, data: &str) -> Result<(), ()>

Send a warn level &str message

pub fn error(&mut self, data: &str) -> Result<(), ()>

Send an error level &str message

pub fn raw_bin(&mut self, description: &str, data: &[u8]) -> Result<(), ()>

Send a byte slice message

pub fn data(&mut self, data: T) -> Result<(), ()>

Send a log level &str message

impl<SEND, RECV> Logger<SEND, RECV>

where SEND: Sender + Default, RECV: Receiver + Default,

pub fn new(uart: Uarte<UARTE0>) -> Self

impl<SEND, T, BUFSZ, MSGCT> Logger<SEND, RealReceiver<T, BUFSZ, MSGCT>>

where T: DeserializeOwned, BUFSZ: ArrayLength<u8>, MSGCT: ArrayLength<T>, SEND: Sender + Default,

pub fn start_receive(&mut self) -> Result<(), ()>

Start the receive process using the internal double-buffers

pub fn get_pending_manual<'a, 'b>( &'b mut self, output: &'a mut [u8], ) -> Result<&'a mut [u8], ()>

Obtain any pending bytes in the active buffer. This also causes the internal double buffers to flip. When this function is successful, a sub-slice of output is returned, containing the read bytes.

Bytes are obtained as they are received on the line, so decoding and deserialization must be performed manually.

NOTE: Either this function or service_receive() must be polled periodically, or there will be data loss! In general, the calculation for “how often do I need to poll this” is 1 / (BAUDRATE / LINE_BITS_PER_DATA_BYTE / 255).

For example, at 230400 Baud, and 8N1 settings (8 data bits per 10 line bits), it is necessary to poll this function once per ~11ms.

pub fn service_receive(&mut self) -> Result<usize, ()>

This is an automatic handler, that will clear any pending bytes, and attempt to parse any pending messages. If successful, the return value is the number messages ready to be cleared with get_msg().

NOTE: Either this function or get_pending_manual() must be polled periodically, or there will be data loss! In general, the calculation for “how often do I need to poll this” is 1 / (BAUDRATE / LINE_BITS_PER_DATA_BYTE / 255).

For example, at 230400 Baud, and 8N1 settings (8 data bits per 10 line bits), it is necessary to poll this function once per ~11ms.

Care must also be taken to ensure that MSGCT has a deep enough queue.

pub fn get_msg(&mut self) -> Option<T>

Pop a single message off of the decoded/deserialized queue

pub fn get_stats(&self) -> (usize, usize)