Struct Unpacker 

pub struct Unpacker<const S: usize> { /* private fields */ }

A struct for that unpacks bytes and emits lines of gcode.

Implementations

impl<const S: usize> Unpacker<S>

pub fn unpack(&mut self, byte: &u8) -> Result<MeatPackResult<'_>, MeatPackError>

Unpacks a single meatpacked byte checking on the history of the previously unpacked items. It returns detailing what it is waiting for next.

Examples found in repository

examples/unpack.rs (line 22)

fn main() {
    // Some meatpacked gcode
    let packed: [u8; 93] = [
        255, 255, 251, 255, 255, 247, 255, 255, 250, 59, 32, 10, 255, 255, 251, 127, 77, 243, 32,
        15, 80, 255, 32, 82, 195, 127, 77, 243, 32, 15, 81, 255, 32, 83, 195, 47, 77, 16, 239, 32,
        4, 0, 255, 32, 89, 4, 0, 255, 32, 90, 2, 240, 32, 43, 5, 192, 47, 77, 48, 239, 32, 3, 240,
        32, 63, 89, 0, 255, 32, 90, 4, 191, 32, 1, 192, 47, 77, 64, 255, 32, 80, 4, 0, 255, 32, 82,
        33, 0, 255, 32, 84, 4, 0,
    ];

    // Initiliase the packer with buffer size depending
    // on your application
    let mut unpacker = Unpacker::<64>::default();

    // Imagine receiving the bytes from some I/O and we want
    // to construct gcode lines and deal with them as we form them.
    for b in packed.iter() {
        let res = unpacker.unpack(b);
        match res {
            Ok(MeatPackResult::WaitingForNextByte) => {
                //println!("Waiting for next byte");
            }
            Ok(MeatPackResult::Line(line)) => {
                let line = str::from_utf8(line).unwrap();
                println!("{:?}", line);
            }
            Err(e) => {
                println!("{:?}", e);
                panic!();
            }
        }
    }
}

examples/pack_unpack.rs (line 51)

fn main() {
    let gcode = "M73 P0 R3
M73 Q0 S3 ; Hello
M201 X4000 Y4000 Z200 E2500
M203 X300 Y300 Z40 E100
M204 P4000 R1200 T4000
";

    println!("## IN ##");
    println!("{}", gcode);
    println!("####");

    // Initiliase the packer with buffer size depending
    // on your application
    let mut packer = Packer::<64>::default();
    let mut out: Vec<u8> = vec![];

    // This will store the entire packed version of the gcode.
    // Don't forget the header.
    out.extend(&MEATPACK_HEADER);

    // Feed in the bytes as you receive them and
    // the packer will return completed lines of
    // meatpacked gcode.
    for byte in gcode.as_bytes() {
        let packed = packer.pack(byte);
        match packed {
            Ok(MeatPackResult::Line(line)) => {
                println!("{:?}", line);
                out.extend(line);
            }
            Ok(MeatPackResult::WaitingForNextByte) => {}
            Err(e) => println!("{:?}", e),
        }
    }

    println!("{:?}", out);

    println!("## OUT ##");

    // Now we create an unpacker to unpack the meatpacked data.
    let mut unpacker = Unpacker::<64>::default();

    // Imagine receiving the bytes from some I/O and we want
    // to construct gcode lines and deal with them as we form them.
    for byte in out.iter() {
        let res = unpacker.unpack(byte);
        match res {
            Ok(MeatPackResult::WaitingForNextByte) => {}
            Ok(MeatPackResult::Line(line)) => {
                // If in std.
                for byte in line {
                    let c = char::from(*byte);
                    print!("{}", c);
                }
            }
            Err(e) => {
                println!("{:?}", e);
                process::exit(0)
            }
        }
    }

    println!("####");
}

pub fn data_remains(&self) -> bool

A utility function to check if any data remains in the internal buffer. We expect all meatpack lines to newline end.

Trait Implementations

impl<const S: usize> Default for Unpacker<S>

fn default() -> Self

The default implementation of the unpacker.