# Supported file types ## Overview Plugins are under active development. Stable plugins are documented below with their available options. Plugins under beta testing are available [upon request](mailto:support@marpledata.com).

File format	File extensions	Status
CSV	.csv, .txt, .zip, ...	Stable
MDF	.mdf, .mf4	Stable
MATLAB	.mat	Stable
HDF5	.h5	Stable
TDMS	.tdms	Stable
Ulog (PX4)	.ulg	Stable
MAVLink	.bin	Stable
Apache Avro	.avro	Stable
Parquet	.parquet, .pqt	Stable
Rosbag	.bag	Beta testing

## Custom plugins Do you have files in a different format? Our technical team can create a custom plugin for your data format. Get in touch with to discuss your use case. ## CSV Plugin name: `CSV` The CSV plugin has a lot of options for configuration (see below). Key points: * The time column can be configured (but defaults to `time`) * Time can be a number or date string format. (preferably `YYYY/MM/DD hh:mm:ss`) * CSV zips are supported through `--unzip` * Two main shapes are supported: `tab` (example 1) and `tsv` (example 2) **Example 1: Tabular (tab)** ```csv time,altitude,speed,engine_temp,fuel_level,battery_voltage s,m,km/h,°C,%,V 0.0,0.0,0.0,90.0,100.0,12.6 1.0,10.0,20.0,91.0,99.5,12.6 2.0,25.0,40.0,92.0,99.0,12.5 3.0,50.0,60.0,93.0,98.4,12.5 4.0,80.0,75.0,94.0,97.8,12.4 5.0,120.0,85.0,95.0,97.2,12.4 6.0,160.0,90.0,96.0,96.5,12.3 7.0,200.0,88.0,96.5,95.7,12.3 8.0,240.0,70.0,97.0,94.9,12.2 9.0,260.0,40.0,96.0,94.3,12.2 ``` Download the example file: {% file src="" %} **Example 2: Time Signal Value (tsv)** ```csv time,signal,value 0.0,altitude,0.0 0.0,speed,0.0 0.0,battery_voltage,12.6 1.0,altitude,10.0 1.0,speed,20.0 1.0,battery_voltage,12.6 2.0,altitude,25.0 2.0,speed,40.0 2.0,battery_voltage,12.5 3.0,altitude,50.0 3.0,speed,60.0 ``` **Available options**

Option	Default value	Details
`-t` `--time-col`	`"time"`	Name of the time column(s), the first matching item in the list will be used (e.g. `-t 'time' -t 'datetime'`)
`-T` `--combined-time-col`		Combine multiple column names using space to form 1 date column (e.g. `-T 'date' -T 'time' -T 'UTC Offset'`)
`--shape`	`tab`	If the data is organised tabular (`tab`), or `tsv` with for example columns (time, signal, value)
`--delimiter`	`,`	Character that splits the columns. To specify a tab delimited file, use `--delimiter "<paste tab here>"`
`--decimal`	`.`	Character that show decimal point
`--thousands`	None	Character that splits 1000s
`--quotechar`	`"`	Character indicating strings
`--encoding`	`latin-1`	See list of available encodings here
`--chunksize`	1 million (`1e6`)	Number of rows consumed at once
`--skiprows`	`0`	Rows to be ignored at the top of the file
`--dayfirst` `--no-dayfirst`	`--no-dayfirst`	Parse dates with the day first (e.g. 23/08/2025)
`--time-factor`	1 billion (`1e9`)	Factor to convert time to nanoseconds
`--time-offset`	0	Offset [ns] to add to time. Time [ns] = [time-col] * time-factor + time-offset
`--use-index` `--no-use-index`	`--no-use-index`	Use row index as time column
`-h` `--header`		Names for the columns, instead of using the first row (e.g. `-h 'time' -h 'col0' -h 'col1'`)
`--units` `--no-units`	`--no-units`	Read units from the second line (`tab` only)
`--unzip` `--no-unzip`	`--no-unzip`	The input file is a `.zip` file which contains `.csv` files
`--group-by-filename` `--no-group-by-filename`	`--no-group-by-filename`	Add the file name as a signal group
`--signal-col`	`signal`	Column to use for signal names, in case of multiple, they will be combined using `.` (`tsv` only)
`--value-col`	`value`	Column to use for values (`tsv` only)
`--unit-col`	None	Column to use for units (`tsv` only)
`-M` `--metadata-col`		Columns to use for metadata (`tsv` only)

A general example of how these options can be correctly used in Marple DB:

## MDF Plugin name: `MDF/ MF4` Can import files generated according to the ASAM Measurement Data Format version 4 (MF4) standard. Binary MDF files cannot be parsed but needs to converted using a `.dbc` file first. **Available options**

Option	Default value	Details
`--chunksize`	10 million (`1e7`)	Number of datapoints in each processed chunk. Large values may result in too much use of RAM and crashing
`--time-factor`	1 billion (`1e9`)	Factor to convert time to nanoseconds
`--time-offset`	0	Offset [ns] to add to time. Time [ns] = [time-col] * time-factor + time-offset
`--use-header-start-time` `--no-use-header-start-time`	`--use-header-start-time`	Use the start time from the header of the file.
`-s` / `--select`		Channel names to include. If not provided, all channels are included.
`--skip-empty-signals` `--no--skip-empty-signals`	`--no--skip-empty-signals`	Skip empty channels during ingestion.

## MATLAB Plugin name: `MATLAB` MAT files are used a lot when using MATLAB or certain loggers such as dSpace, Speedgoat, .. MAT files are treated similarly to HDF5 files (as described above), so the same rules apply. If you have a MAT file of version 7.3 or higher, this will be treated as a HDF5 file. MAT files of a lower version are significantly less efficient and will require more effort to be parsed by Marple. Download the example.mat file below: {% file src="" %} We accept 3 different structures for MATLAB files: flat/matrix/signal. Read more about the available file structures in [#hdf5](#hdf5 "mention"). **Available options**

Option	Default value	Details
`-t` `--time-col`	`-t "time"` `-t "Time"`	Name of the time column(s), the first matching item in the list will be used. (e.g. `-t 'time' -t 'datetime'`)
`--use-index` `--no-use-index`	`--no-use-index`	Use row index as time column
`--time-factor`	1 billion (`1e9`)	Factor to convert time to nanoseconds
`--time-offset`	0	Offset [ns] to add to time. Time [ns] = [time-col] * time-factor + time-offset
`--include-groups` `--no-include-groups`	`--include-groups`	Include group names in signal names.
`--structure`	`flat`	How to interpret the data structure in the file. [flat/matrix/signal]
`--names-key`	`names`	Key name for signal names when using 'matrix' structure.
`--units-key`	`units`	Key name for signal units when using 'matrix' structure.
`--descriptions-key`	`descriptions`	Key name for signal descriptions when using 'matrix' structure.

## HDF5 Plugin name: `HDF5` HDF5 files are widely known for their excellent handling of large data sets.. and we agree! We love HDF5 data sets! Unfortunately, HDF5 files come in different shapes and formats, so we need to agree to some structure. Marple supports 3 structures for HDF5: flat, matrix (row-oriented) and signal (nested groups). **Flat (default, signal-based)** Groups act like dictionaries: each signal name is a key, and the value is a Dataset (array). There is typically one time signal per group, shared by all signals in that group. ``` file (h5.File) └── group_1 (h5.Group) ├── time (h5.Dataset) ├── signal_1 (h5.Dataset) └── signal_2 (h5.Dataset) ``` We also allow for signal grouping, as can be seen in the example below: Units can be stored as an [attribute](https://docs.h5py.org/en/stable/high/attr.html#attributes) on each signal Dataset. Example file: {% file src="" %} **SIGNAL (nested groups)** Each signal is a Group; inside it are Datasets for time and values (e.g. `time`, `value`, `value_text`). No shared time column—each signal carries its own. ``` file (h5.File) └── group_1 (h5.Group) └── signal_1 (h5.Group) ├── time (h5.Dataset) (Can be omitted when using '--use-index') └── value (h5.Dataset) (Can be text or numeric data) └── value_text (h5.Dataset) (Can only be text data, in that case 'value' can only be numeric) ``` Groups can be nested further; any Group that contains both a time-like Dataset and a value Dataset is treated as one signal. Example file: {% file src="" %} **MATRIX (row-oriented)** A matrix structure is a row-oriented construct. A group holds a single data matrix plus separate keys for signal names, units, and descriptions. Suited to row-by-row processing. Key names are configurable (`--data-key`, `--names-key`, `--units-key`, `--descriptions-key`). ``` file (h5.File) └── group_1 (h5.Group) ├── data (h5.Dataset) # matrix: rows = time, columns = signals ├── names (h5.Dataset) # signal names ├── units (h5.Dataset) # optional └── descriptions (h5.Dataset) # optional ``` Example file: {% file src="" %} **Available options**

Option	Default value	Details
`-t` `--time-col`	`-t "time"` `-t "Time"`	Name of the time column(s), the first matching item in the list will be used. (e.g. `-t 'time' -t 'datetime'`)
`--time-factor`	1 billion (`1e9`)	Factor to convert time to nanoseconds
`--time-offset`	0	Offset [ns] to add to time. Time [ns] = [time-col] * time-factor + time-offset
`--use-index` `--no-use-index`	--no-use-index	Use row index as time column
`--include-groups` `--no-include-groups`	`--include-groups`	Include group names in signal names.
`--structure`	`flat`	How to interpret the data structure in the file. [flat/matrix]
`--names-key`	`names`	Key name for signal names when using 'matrix' structure.
`--units-key`	`units`	Key name for signal units when using 'matrix' structure.
`--descriptions-key`	`descriptions`	Key name for signal descriptions when using 'matrix' structure.

## TDMS Plugin name: `TDMS` **Available options**

Option	Default value	Details
`--chunksize`	10 million (`1e7`)	Number of datapoints in each processed chunk. Large values may result in too much use of RAM and crashing
`--time-factor`	1 billion (`1e9`)	Factor to convert time to nanoseconds
`--time-offset`	0	Offset [ns] to add to time. Time [ns] = [time-col] * time-factor + time-offset
`-t` `--time-col`	`-t "time"`	Name of the time column(s), the first matching item in the list will be used. (e.g. `-t 'time' -t 'datetime'`)
`--use-index` `--no-use-index`	`--no-use-index`	Use row index as time column
`--unit`	`unit_string`	Name of the channel property which contains the unit.

## ULOG Plugin name: `ULog` The ULOG format is often used when dealing with systems that operate using the PX4 software or ecosystem. We think it's a great format because it is standardized! As long as you adhere to the ULOG structure, `.ulg` formats are plug & play for Marple. No configuration needed! Download the example.ulg file below: {% file src="" %} ## MAVLINK Plugin name: `MAVLink` MAVLink is a very lightweight messaging protocol for communicating with drones. The messages can be stored in a file, often with a `.bin` extension and can be easily imported by Marple. **Available options**

Option	Default value	Details
`--include-types`		Message types to include (if empty, include all types). Multiple options allowed.
`--exclude-types`		Message types to exclude. Multiple options allowed.
`--no-bad-data`	`False`	Ignore `BAD_DATA` messages
`--parameters`	`metadata`	How to add the values from the `PARM` message type. Valid options are: `skip` : Ignore `PARM` messages `metadata` : Add parameters as metadata to the dataset (use first value if more than 1 occur for same parameter) `signal` : Add each parameter as a new signal to the dataset `both` : Add parameters as metadata & signals

## Apache Avro Avro is a row-oriented serialization framework that is used in Apache Hadoop. Avro files store data in binary format but it’s syntax definition resembles a JSON file. Here is an example of what a .avro file JSON structure should look like to be supported by Marple: ```json [ { "Timestamp": "2024-06-01T12:00:00Z", "Name": "Measurement", "Value": "0.108" }, { "Timestamp": "2024-06-01T12:00:00Z", "Name": "Measurement1", "Value": "48.6" }, { "Timestamp": "2024-06-01T12:01:00Z", "Name": "Measurement", "Value": "0.235" }, ... ] ``` Dataset metadata and signal metadata can be embedded in the Avro file’s metadata section using the following structure: * **Dataset metadata:**\ A dictionary containing key–value pairs, where each key represents a metadata field and each value stores the corresponding metadata value. * **Signal metadata:**\ A dictionary where each key is a signal name, and the value is another dictionary containing all metadata fields associated with that specific signal. Example of metadata in Avro file: ```json { "type": "record", "name": "marpledb.example", "fields": [...], "datasetInfo": { "Location": "Antwerp", "Date": "11/12/2025", "Description": "Temporary configuration for testing purposes" }, "signalInfo": { "signal1": { "unit": "m/s", "description": "Signal 1 description" }, "signal2": { "unit": "kg", "description": "Signal 2 description" } } } ``` **Available options**

Option	Default value	Details
`--chunksize`	100k (`1e5`)	Number of records in each processed chunk. Large values may result in too much use of RAM and crashing
`--time-factor`	1 billion (`1e9`)	Factor to convert time to nanoseconds (only in case timestamps are not stored as dates).
`--time-offset`	0	Offset [ns] to add to time. Time [ns] = [time-col] * time-factor + time-offset
`--time-col`	`Timestamp`	Name of the time column.
`--signal-col`	`Name`	Name of the signal column.
`--value-col`	`Value`	Name of the value column.
`--signal-metadata-key`		Key name for signal metadata dictionary in file metadata (if any). See example above for more info.
`--dataset-metadata-key`		Key name for dataset metadata dictionary in file metadata (if any). See example above for more info.
`--unit-key`	`Unit`	Key name for signal unit in signal metadata (if any).
`--dayfirst` `--no-dayfirst`	`--dayfirst`	Parse dates with the day first (e.g. 23/08/2025)

## Parquet The .parquet plugin allows 2 file shapes: long and wide. **Wide format** Use this format if your data is already structured as a time-series table where each signal is its own column and one column contains the time values. | time | temperature | pressure | rpm | | ---- | ----------- | -------- | ---- | | 0.00 | 23.1 | 101.3 | 1200 | | 0.01 | 23.4 | 101.5 | 1205 | Example file: {% file src="" %} **Long format** One row per measurement, with a fixed `time`, `signal`, and `value` column. | time | signal | value | | ---- | ----------- | ----- | | 0.00 | temperature | 23.1 | | 0.00 | pressure | 101.3 | | 0.01 | temperature | 23.4 | Example file: {% file src="" %} **Adding metadata** **Dataset metadata** is used for global context (e.g., test ID, operator, or session info). This is extracted from the `schema.metadata` at the file level. Implementation: Add key-value pairs to the global Parquet file metadata. **Signal metadata** is only accepted when the dataset structure is "wide" (one signal per column). The plugin looks for the following keys within the `.metadata` field of each `Field` object. While any key-value pair is allowed and will be stored on your signal, the following keys are treated as "special" for automatic UI handling: `unit`, `desciption`. Looking for an example? The `example_wide.parquet` dataset contains both dataset and signal metadata. **Available options**

Option	Default value	Details
`--shape`	`wide`	Shape of the dataset, see above for more info. [`wide`/`long`]
`--time-col`		Name of the time column. If not set, "time" is used if present.
`--time-factor`	1	Factor to convert time to nanoseconds (only in case timestamps are not stored as dates).
`--time-offset`	0	Offset [ns] to add to time. Time [ns] = [time-col] * time-factor + time-offset
`--chunksize`	100k (`1e5`)	Number of records in each processed chunk. Large values may result in too much use of RAM and crashing
`-s` `--signal-col`	`["signal"]`	Columns to use for signal names. (long only) If multiple values are provided, the names in these columns will be combined to make the signal name.
`--value-col`	`value`	Column to use for values. (long only)
`--ordered-by-signal` `--not-ordered-by-signal`	`--not-ordered-by-signal`	Assume rows are ordered by signal, enabling per-signal sequential processing (improves performance for large datasets). (long only)
`--use-index` `--no-use-index`	`--no-use-index`	Use the row index as relative time instead of a time column.