Autosar DLT Support

A library that support efficient parsing & writing log-messages encoded as Diagnositic Log and Trace messages.

Features

• compliant with the official Autosar DLT specification
• efficiently parse binary DLT content
• serialize DLT messages
• support for non-verbose messages via FIBEX file information

Usage

Add this to your Cargo.toml:

toml [dependencies] dlt_core = "0.13"

This is an example of how to parse a message and serialize it back to a byte array.

```rust use dltcore::dltparse::{dlt_message, ParsedMessage};

fn main() { let raw1: Vec = vec![ // --------------- storage header /* DLT + 0x01 / 0x44, 0x4C, 0x54, 0x01, / timestamp sec / 0x2B, 0x2C, 0xC9, 0x4D, / timestamp us / 0x7A, 0xE8, 0x01, 0x00, / ecu id "ECU" / 0x45, 0x43, 0x55, 0x00, // --------------- header / header-type 0b0010 0001 / 0x21, / extended header | |||^ / / MSBF: 0 little endian | ||^ / / WEID: 0 no ecu id | |^ / / WSID: 0 sess id | ^ / / WTMS: 0 no timestamp ^ / / version nummber 1 ^^^ / / message counter / 0x0A, / length = 0 / 0x00, 0x13, // --------------- extended header 0x41, // MSIN 0b0100 0001 => verbose, MST log, ApplicationTraceType::State 0x01, // arg count 0x4C, 0x4F, 0x47, 0x00, // app id LOG 0x54, 0x45, 0x53, 0x32, // context id TES2 // --------------- payload / type info 0b0001 0000 => type bool */ 0x10, 0x00, 0x00, 0x00, 0x6F, ]; match dltmessage(&raw1[..], None, true) { Ok((rest, ParsedMessage::Item(msg))) => { let msgbytes = msg.asbytes(); asserteq!(raw1, msgbytes); } _ => panic!("could not parse message"), } } ```

The parser is quite fast. Parsing a 4.8 GByte DLT file that contains over 3.5 mio messages took ~37 seconds (~134MB/sec)

This example can be built with cargo build --example file_parser --release

```rust use bufredux::{policy::MinBuffered, BufReader}; use dltcore::parse::{dlt_message, DltParseError}; use std::{env, fs, fs::File, io::BufRead, path::PathBuf, time::Instant};

pub(crate) const DLTREADERCAPACITY: usize = 10 * 1024 * 1024; pub(crate) const DLTMINBUFFER_SPACE: usize = 10 * 1024;

fn main() { // collect input file details let dltfilepath = PathBuf::from(&env::args().nth(1).expect("No filename given")); let dltfile = File::open(&dltfilepath).expect("could not open file"); let sourcefilesize = fs::metadata(&dltfilepath).expect("file size error").len(); // create a reader that maintains a minimum amount of bytes in it's buffer let mut reader = BufReader::withcapacity(DLTREADERCAPACITY, dltfile) .setpolicy(MinBuffered(DLTMINBUFFERSPACE)); // now parse all file content let mut parsed = 0usize; let start = Instant::now(); loop { let consumed: usize = match reader.fillbuf() { Ok(content) => { if content.is_empty() { println!("empty content after {} parsed messages", parsed); break; } let available = content.len();

            match dlt_message(content, None, true) {
                Ok((rest, _maybe_msg)) => {
                    let consumed = available - rest.len();
                    parsed += 1;
                    consumed
                }
                Err(DltParseError::IncompleteParse { needed }) => {
                    println!("parse incomplete, needed: {:?}", needed);
                    return;
                }
                Err(DltParseError::ParsingHickup(reason)) => {
                    println!("parse error: {}", reason);
                    4 //skip 4 bytes
                }
                Err(DltParseError::Unrecoverable(cause)) => {
                    println!("unrecoverable parse failure: {}", cause);
                    return;
                }
            }
        }
        Err(e) => {
            println!("Error reading: {}", e);
            return;
        }
    };
    reader.consume(consumed);
}

// print some stats
let duration_in_s = start.elapsed().as_millis() as f64 / 1000.0;
let file_size_in_mb = source_file_size as f64 / 1024.0 / 1024.0;
let amount_per_second: f64 = file_size_in_mb / duration_in_s;
println!(
    "parsing {} messages took {:.3}s! ({:.3} MB/s)",
    parsed, duration_in_s, amount_per_second
);

} ```

empty content after 33554430 parsed messages parsing 33554430 messages took 37.015s! (133.773 MB/s)