Task 514: .PARAMS File Format

File Format Specifications for the .PARAMS File Format

The .PARAMS file format is an ASCII text-based configuration file commonly used in the PX4 Autopilot software for drones and unmanned vehicles. It stores vehicle-specific parameters for configuration and tuning. The format is documented in the QGroundControl developer guide. It consists of optional comment lines (starting with #) and data lines containing tab-separated fields representing individual parameters. The format is simple and human-readable, with no binary components or magic numbers. Each data line follows this structure:

• Vehicle-Id (integer, typically 1 for the primary vehicle)
• Component-Id (integer, typically 1 for the main flight controller)
• Name (string, the parameter identifier, e.g., BAT1_CAPACITY)
• Value (float, the parameter's value, formatted as a floating-point number)
• Type (integer, the MAVLink parameter type code, e.g., 9 for FLOAT, 6 for INT32)

The file can contain parameters for a single vehicle, and comments are used for headers or metadata (e.g., # Onboard parameters for Vehicle 1).

1. List of all the properties of this file format intrinsic to its file system:

• Vehicle-Id
• Component-Id
• Name
• Value
• Type

These are the core fields (properties) that define the structure of each parameter entry in the file. The file system itself (e.g., NTFS, ext4) may add metadata like file size, creation date, or permissions, but those are not specific to the .PARAMS format.

1. Two direct download links for files of format .PARAMS:

• https://gitlab.bfabric.org/wolski/ptm_example/-/raw/main/data_ptm/fragger.params
• https://git.mpi-cbg.de/poehls/detel/-/raw/main/eTEL/configs/open_search.params

These are examples of .params files from public repositories. (Note: While not PX4-specific, they follow a similar text-based parameter format; exact PX4 examples are often generated dynamically but can be exported from QGroundControl.)

1. Ghost blog embedded HTML JavaScript for drag-and-drop .PARAMS file dump:

This HTML can be embedded in a Ghost blog post. It creates a drag-and-drop area that reads the file, parses non-comment lines, and dumps the properties (fields) to the screen.

1. Python class for .PARAMS file handling:

class ParamsFile:
    def __init__(self, filename):
        self.filename = filename
        self.parameters = []  # List of dicts with properties
        self.load()

    def load(self):
        with open(self.filename, 'r') as f:
            for line in f:
                line = line.strip()
                if not line or line.startswith('#'):
                    continue
                fields = line.split('\t')
                if len(fields) == 5:
                    self.parameters.append({
                        'vehicle_id': fields[0],
                        'component_id': fields[1],
                        'name': fields[2],
                        'value': fields[3],
                        'type': fields[4]
                    })

    def print_properties(self):
        for param in self.parameters:
            print(f"Vehicle-Id: {param['vehicle_id']}")
            print(f"Component-Id: {param['component_id']}")
            print(f"Name: {param['name']}")
            print(f"Value: {param['value']}")
            print(f"Type: {param['type']}")
            print()

    def write(self, output_filename=None):
        if output_filename is None:
            output_filename = self.filename
        with open(output_filename, 'w') as f:
            f.write('# Onboard parameters for Vehicle 1\n')
            f.write('# Vehicle-Id Component-Id Name Value Type\n')
            for param in self.parameters:
                f.write(f"{param['vehicle_id']}\t{param['component_id']}\t{param['name']}\t{param['value']}\t{param['type']}\n")

Usage example: pf = ParamsFile('example.params'); pf.print_properties(); pf.write('new.params')

1. Java class for .PARAMS file handling:

import java.io.*;
import java.util.ArrayList;
import java.util.List;

public class ParamsFile {
    private String filename;
    private List<ParamEntry> parameters = new ArrayList<>();

    public ParamsFile(String filename) {
        this.filename = filename;
        load();
    }

    private void load() {
        try (BufferedReader br = new BufferedReader(new FileReader(filename))) {
            String line;
            while ((line = br.readLine()) != null) {
                line = line.trim();
                if (line.isEmpty() || line.startsWith("#")) continue;
                String[] fields = line.split("\t");
                if (fields.length == 5) {
                    parameters.add(new ParamEntry(fields[0], fields[1], fields[2], fields[3], fields[4]));
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public void printProperties() {
        for (ParamEntry param : parameters) {
            System.out.println("Vehicle-Id: " + param.vehicleId);
            System.out.println("Component-Id: " + param.componentId);
            System.out.println("Name: " + param.name);
            System.out.println("Value: " + param.value);
            System.out.println("Type: " + param.type);
            System.out.println();
        }
    }

    public void write(String outputFilename) {
        if (outputFilename == null) outputFilename = filename;
        try (PrintWriter pw = new PrintWriter(new FileWriter(outputFilename))) {
            pw.println("# Onboard parameters for Vehicle 1");
            pw.println("# Vehicle-Id Component-Id Name Value Type");
            for (ParamEntry param : parameters) {
                pw.printf("%s\t%s\t%s\t%s\t%s\n", param.vehicleId, param.componentId, param.name, param.value, param.type);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    static class ParamEntry {
        String vehicleId, componentId, name, value, type;
        ParamEntry(String v, String c, String n, String val, String t) {
            vehicleId = v; componentId = c; name = n; value = val; type = t;
        }
    }
}

Usage example: ParamsFile pf = new ParamsFile("example.params"); pf.printProperties(); pf.write("new.params");

1. JavaScript class for .PARAMS file handling (Node.js):

const fs = require('fs');

class ParamsFile {
    constructor(filename) {
        this.filename = filename;
        this.parameters = [];
        this.load();
    }

    load() {
        const content = fs.readFileSync(this.filename, 'utf8');
        const lines = content.split('\n');
        lines.forEach(line => {
            line = line.trim();
            if (!line || line.startsWith('#')) return;
            const fields = line.split('\t');
            if (fields.length === 5) {
                this.parameters.push({
                    vehicleId: fields[0],
                    componentId: fields[1],
                    name: fields[2],
                    value: fields[3],
                    type: fields[4]
                });
            }
        });
    }

    printProperties() {
        this.parameters.forEach(param => {
            console.log(`Vehicle-Id: ${param.vehicleId}`);
            console.log(`Component-Id: ${param.componentId}`);
            console.log(`Name: ${param.name}`);
            console.log(`Value: ${param.value}`);
            console.log(`Type: ${param.type}`);
            console.log('');
        });
    }

    write(outputFilename = this.filename) {
        let output = '# Onboard parameters for Vehicle 1\n';
        output += '# Vehicle-Id Component-Id Name Value Type\n';
        this.parameters.forEach(param => {
            output += `${param.vehicleId}\t${param.componentId}\t${param.name}\t${param.value}\t${param.type}\n`;
        });
        fs.writeFileSync(outputFilename, output);
    }
}

Usage example: const pf = new ParamsFile('example.params'); pf.printProperties(); pf.write('new.params');

1. C class for .PARAMS file handling (using structs and stdio):

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_LINE 256
#define MAX_PARAMS 1000  // Arbitrary max

typedef struct {
    char *vehicleId;
    char *componentId;
    char *name;
    char *value;
    char *type;
} ParamEntry;

typedef struct {
    char *filename;
    ParamEntry *parameters;
    int count;
} ParamsFile;

ParamsFile* params_file_create(const char *filename) {
    ParamsFile *pf = malloc(sizeof(ParamsFile));
    pf->filename = strdup(filename);
    pf->parameters = malloc(sizeof(ParamEntry) * MAX_PARAMS);
    pf->count = 0;
    FILE *f = fopen(filename, "r");
    if (!f) return pf;
    char line[MAX_LINE];
    while (fgets(line, MAX_LINE, f)) {
        if (line[0] == '#' || line[0] == '\n') continue;
        char *fields[5];
        int i = 0;
        char *token = strtok(line, "\t\n");
        while (token && i < 5) {
            fields[i++] = token;
            token = strtok(NULL, "\t\n");
        }
        if (i == 5) {
            ParamEntry *p = &pf->parameters[pf->count++];
            p->vehicleId = strdup(fields[0]);
            p->componentId = strdup(fields[1]);
            p->name = strdup(fields[2]);
            p->value = strdup(fields[3]);
            p->type = strdup(fields[4]);
        }
    }
    fclose(f);
    return pf;
}

void params_file_print_properties(ParamsFile *pf) {
    for (int i = 0; i < pf->count; i++) {
        ParamEntry p = pf->parameters[i];
        printf("Vehicle-Id: %s\n", p.vehicleId);
        printf("Component-Id: %s\n", p.componentId);
        printf("Name: %s\n", p.name);
        printf("Value: %s\n", p.value);
        printf("Type: %s\n", p.type);
        printf("\n");
    }
}

void params_file_write(ParamsFile *pf, const char *output_filename) {
    const char *fname = output_filename ? output_filename : pf->filename;
    FILE *f = fopen(fname, "w");
    if (!f) return;
    fprintf(f, "# Onboard parameters for Vehicle 1\n");
    fprintf(f, "# Vehicle-Id Component-Id Name Value Type\n");
    for (int i = 0; i < pf->count; i++) {
        ParamEntry p = pf->parameters[i];
        fprintf(f, "%s\t%s\t%s\t%s\t%s\n", p.vehicleId, p.componentId, p.name, p.value, p.type);
    }
    fclose(f);
}

void params_file_destroy(ParamsFile *pf) {
    for (int i = 0; i < pf->count; i++) {
        free(pf->parameters[i].vehicleId);
        free(pf->parameters[i].componentId);
        free(pf->parameters[i].name);
        free(pf->parameters[i].value);
        free(pf->parameters[i].type);
    }
    free(pf->parameters);
    free(pf->filename);
    free(pf);
}

Usage example: ParamsFile *pf = params_file_create("example.params"); params_file_print_properties(pf); params_file_write(pf, "new.params"); params_file_destroy(pf);