Ideally run it with a script that takes arguments for a crate and struct to deserialize and builds the tool linking to them:

< ./framed_data deframe --type foo::Bar --crate path/to/module/foo

There could be an output type argument to print the deserialized structs with any encoding for which there is a serde Serializer. First few: JSON, CSV, Rust Debug format.

This would be extensible.

Usage example:

let codec = framed::bytes::Settings::default().crc(CRC16).build();
let encoded = codec.encode_to_box([1,2,3])?;
write_all(encoded)?;

The typical approach is for the frame to start with a marker (a zero for COBS), then a length field, then the data, then a checksum, then a zero to end the frame.

If that is too heavyweight we can offer configuration options later e.g. to remove the start byte and length field.

This will fix the stable and beta builds.

May require some unsafe shenanigans in the implementation, but it would probably be worth it.

Currently I pull in https://github.com/QuiltOS/core-io, which is not on crates.io. It has std::io-inspired Read and Write traits, but with a generic associated type as an error type.

I've tried and failed to get a version of Sender compiling with no_std and without. The type parameter Write::Err bubbles up to a type parameter on Sender for the no_std version, yet it's not required for the use_std version.

Maybe I just need to work on it some more. If I get core-io working it needs publishing to crates.io, probably as its own crate so it can be re-used in peripherals.

Maybe core-io is too difficult to use here, and I should switch to something else.

The core_io crate doesn't compile out of the box, but should integrate more smoothly.

I could avoid {Read, Write} entirely when no_std, using from_slice, to_slice functions instead.

Currently COBS is run on the payload then checksum is appended after this. This can cause errors is the checksum includes the COBS sentinel value.

This could be fixed with current COBS with some fairly intrusive api changes or copying the payload to a temp buffer before calling COBS. However, this PR in COBS exposes a streaming interface that would allow the payload to be encoded, then the checksum, then finalising so no extra copy is necessary.

I'm going to wait for that to be released and submit a PR for framed.

framed should return a different error for EOF after a complete frame, framed_decode should special case it.

First few: JSON, CSV, Rust Debug format.

Reference:

• https://crates.io/crates/ssmarshal

They would need to be constructible from [u8; N], Box<[u8]>, Vec.