NanoPB: Benutzerdefinierte Array-Konverter mit Offset und Größe in C

Siehe auch: C++-Version: Umgang mit benutzerdefinierten Array-Konvertern in C++

NanoPB ist eine codegrößenoptimierte Protocol-Buffers-Implementierung für eingebettete Systeme. Dieser Beitrag zeigt, wie man benutzerdefinierte Array-Konverter in C mit NanoPB handhabt.

Proto-Definition

Erstellen Sie zuerst eine .proto-Datei mit wiederholten Feldern:

custom_array.proto

syntax = "proto3";

package example;

message CustomArrayMessage {
  repeated uint32 values = 1;
}

syntax = "proto3";

package example;

message CustomArrayMessage {
  repeated uint32 values = 1;
}

NanoPB-Code generieren

Generieren Sie den NanoPB-Code mit einer .options-Datei, um die maximale Anzahl anzugeben:

Erstellen Sie custom_array.options:

custom_array.options

example.CustomArrayMessage.values max_count:20

example.CustomArrayMessage.values max_count:20

Dann generieren:

generate_nanopb_custom_array.sh

protoc --nanopb_out=. custom_array.proto

protoc --nanopb_out=. custom_array.proto

Dies generiert custom_array.pb.h und custom_array.pb.c.

C-Beispiel mit benutzerdefiniertem Array-Konverter

Hier ist ein vollständiges C-Beispiel, das einen benutzerdefinierten Array-Konverter mit Offset und Größe implementiert:

custom_array_example.c

#include <stdio.h>
#include <stdint.h>
#include <stddef.h>
#include <limits.h>
#include "custom_array.pb.h"
#include "pb_encode.h"
#include "pb_decode.h"

// Custom array converter context
typedef struct {
    const uint32_t* data;
    size_t size;
    size_t offset;
    size_t count;
} array_context_t;

// Encode callback for uint32 array with offset and size
bool uint32_array_encode_callback(pb_ostream_t *stream, const pb_field_t *field, void * const *arg) {
    const array_context_t* ctx = (const array_context_t*)*arg;
    
    size_t start = ctx->offset;
    size_t end = (ctx->offset + ctx->count < ctx->size) ? 
                 ctx->offset + ctx->count : ctx->size;
    
    for (size_t i = start; i < end; i++) {
        if (!pb_encode_tag_for_field(stream, field))
            return false;
        
        if (!pb_encode_varint(stream, ctx->data[i]))
            return false;
    }
    
    return true;
}

int main() {
    // Buffer for encoded message
    uint8_t buffer[256];
    size_t message_length;
    
    // Create array with 10 elements
    uint32_t values[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    
    // --- ENCODING ---
    example_CustomArrayMessage message = example_CustomArrayMessage_init_zero;
    
    // Set up context: encode elements 3-7 (offset=2, count=5)
    array_context_t ctx = {
        .data = values,
        .size = 10,
        .offset = 2,
        .count = 5
    };
    
    // Set up callback
    message.values.funcs.encode = uint32_array_encode_callback;
    message.values.arg = &ctx;
    
    // Create stream for encoding
    pb_ostream_t ostream = pb_ostream_from_buffer(buffer, sizeof(buffer));
    
    // Encode the message
    if (!pb_encode(&ostream, example_CustomArrayMessage_fields, &message)) {
        printf("Encoding failed: %s\n", PB_GET_ERROR(&ostream));
        return 1;
    }
    
    message_length = ostream.bytes_written;
    printf("Encoded %zu bytes (elements 3-7)\n", message_length);
    
    // Print hex dump
    printf("Encoded data: ");
    for (size_t i = 0; i < message_length; i++) {
        printf("%02x ", buffer[i]);
    }
    printf("\n");
    
    // Print what was encoded
    printf("Encoded values: ");
    for (size_t i = 2; i < 2 + 5 && i < 10; i++) {
        printf("%u ", values[i]);
    }
    printf("\n");
    
    return 0;
}

#include <stdio.h>
#include <stdint.h>
#include <stddef.h>
#include <limits.h>
#include "custom_array.pb.h"
#include "pb_encode.h"
#include "pb_decode.h"

// Custom array converter context
typedef struct {
    const uint32_t* data;
    size_t size;
    size_t offset;
    size_t count;
} array_context_t;

// Encode callback for uint32 array with offset and size
bool uint32_array_encode_callback(pb_ostream_t *stream, const pb_field_t *field, void * const *arg) {
    const array_context_t* ctx = (const array_context_t*)*arg;
    
    size_t start = ctx->offset;
    size_t end = (ctx->offset + ctx->count < ctx->size) ? 
                 ctx->offset + ctx->count : ctx->size;
    
    for (size_t i = start; i < end; i++) {
        if (!pb_encode_tag_for_field(stream, field))
            return false;
        
        if (!pb_encode_varint(stream, ctx->data[i]))
            return false;
    }
    
    return true;
}

int main() {
    // Buffer for encoded message
    uint8_t buffer[256];
    size_t message_length;
    
    // Create array with 10 elements
    uint32_t values[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    
    // --- ENCODING ---
    example_CustomArrayMessage message = example_CustomArrayMessage_init_zero;
    
    // Set up context: encode elements 3-7 (offset=2, count=5)
    array_context_t ctx = {
        .data = values,
        .size = 10,
        .offset = 2,
        .count = 5
    };
    
    // Set up callback
    message.values.funcs.encode = uint32_array_encode_callback;
    message.values.arg = &ctx;
    
    // Create stream for encoding
    pb_ostream_t ostream = pb_ostream_from_buffer(buffer, sizeof(buffer));
    
    // Encode the message
    if (!pb_encode(&ostream, example_CustomArrayMessage_fields, &message)) {
        printf("Encoding failed: %s\n", PB_GET_ERROR(&ostream));
        return 1;
    }
    
    message_length = ostream.bytes_written;
    printf("Encoded %zu bytes (elements 3-7)\n", message_length);
    
    // Print hex dump
    printf("Encoded data: ");
    for (size_t i = 0; i < message_length; i++) {
        printf("%02x ", buffer[i]);
    }
    printf("\n");
    
    // Print what was encoded
    printf("Encoded values: ");
    for (size_t i = 2; i < 2 + 5 && i < 10; i++) {
        printf("%u ", values[i]);
    }
    printf("\n");
    
    return 0;
}

Kompilierungsbefehl

Kompilieren Sie das Beispiel mit NanoPB. NanoPB wird typischerweise verwendet, indem die Quelldateien direkt in Ihr Projekt eingebunden werden:

compile_custom_array_example.sh

gcc -o custom_array_example custom_array_example.c custom_array.pb.c pb_common.c pb_encode.c pb_decode.c -I.

gcc -o custom_array_example custom_array_example.c custom_array.pb.c pb_common.c pb_encode.c pb_decode.c -I.

Hinweis: NanoPB-Quelldateien (pb_common.c, pb_encode.c, pb_decode.c) müssen direkt mit Ihrem Projekt kompiliert werden. Sie können diese aus dem NanoPB GitHub-Repository beziehen.

Wichtige Punkte

Kontextstruktur: Verwenden Sie ein struct, um Offset, Anzahl und Datenzeiger zu übergeben
Offset-Logik: Beginnen Sie die Kodierung am angegebenen Offset
Anzahlbegrenzung: Kodieren Sie höchstens Anzahl Elemente nach dem Offset
Callback-Muster: Verwenden Sie pb_callback_t mit benutzerdefinierter Kodierungsfunktion
Flexibilität: Kann jeden Ausschnitt eines Arrays kodieren ohne zu kopieren
Speichereffizienz: Keine Notwendigkeit, temporäre Arrays zu erstellen
KKS-Firmware-Muster: Basiert auf ArrayConverterWithOffsetAndSize aus KKS-Firmware

Wann benutzerdefinierte Array-Konverter verwendet werden sollten

Wenn Sie eine Teilmenge eines großen Arrays kodieren müssen
Wenn Sie das Kopieren von Daten vermeiden möchten
Wenn Sie Paginierung oder Chunking implementieren
Wenn das Array-Layout nicht den Protobuf-Anforderungen entspricht
Wenn Sie benutzerdefinierte Kodierungslogik für Arrays benötigen

Erwartete Ausgabe

custom_array_expected_output.txt

Encoded 10 bytes (elements 3-7)
Encoded data: 08 03 08 04 08 05 08 06 08 07 
Encoded values: 3 4 5 6 7 

Encoded 10 bytes (elements 3-7)
Encoded data: 08 03 08 04 08 05 08 06 08 07 
Encoded values: 3 4 5 6 7

Beachten Sie, dass nur die Elemente 3, 4, 5, 6, 7 kodiert werden (5 Elemente beginnend bei Offset 2).

Erweitert: Generische template-ähnliche Implementierung

Für eine generischere C-Implementierung (Templates simulierend):

custom_array_generic.c

#include <stddef.h>
#include <limits.h>

#define MAX_OFFSET_SIZE (SIZE_MAX / 2)

typedef struct {
    const void* data;
    size_t element_size;
    size_t size;
    size_t offset;
    size_t count;
    bool (*encode_element)(pb_ostream_t*, const pb_field_t*, const void*);
} generic_array_context_t;

bool generic_array_encode_callback(pb_ostream_t *stream, const pb_field_t *field, void * const *arg) {
    const generic_array_context_t* ctx = (const generic_array_context_t*)*arg;
    
    size_t start = ctx->offset;
    size_t end = (ctx->offset + ctx->count < ctx->size) ? 
                 ctx->offset + ctx->count : ctx->size;
    
    const uint8_t* data = (const uint8_t*)ctx->data;
    
    for (size_t i = start; i < end; i++) {
        const void* element = data + (i * ctx->element_size);
        if (!ctx->encode_element(stream, field, element)) {
            return false;
        }
    }
    
    return true;
}

#include <stddef.h>
#include <limits.h>

#define MAX_OFFSET_SIZE (SIZE_MAX / 2)

typedef struct {
    const void* data;
    size_t element_size;
    size_t size;
    size_t offset;
    size_t count;
    bool (*encode_element)(pb_ostream_t*, const pb_field_t*, const void*);
} generic_array_context_t;

bool generic_array_encode_callback(pb_ostream_t *stream, const pb_field_t *field, void * const *arg) {
    const generic_array_context_t* ctx = (const generic_array_context_t*)*arg;
    
    size_t start = ctx->offset;
    size_t end = (ctx->offset + ctx->count < ctx->size) ? 
                 ctx->offset + ctx->count : ctx->size;
    
    const uint8_t* data = (const uint8_t*)ctx->data;
    
    for (size_t i = start; i < end; i++) {
        const void* element = data + (i * ctx->element_size);
        if (!ctx->encode_element(stream, field, element)) {
            return false;
        }
    }
    
    return true;
}

Praxisnahe Verwendung

Dieses Muster wird in KKS-Firmware verwendet für:

Kodierung nur aktiver Kanäle aus einem größeren Kanal-Array
Senden partieller Sensordaten zur Bandbreiteneinsparung
Implementierung differentieller Updates
Effiziente Handhabung spärlicher Arrays

Unterschiede zu C++

Die C-Version unterscheidet sich in mehreren Punkten von C++:

Keine Templates: Verwenden Sie structs und Funktionszeiger stattdessen
Manuelle Kontextverwaltung: Muss Kontext explizit übergeben
Kein std::array: Verwenden Sie einfache C-Arrays mit Größenverfolgung
Kein std::algorithm: Iteration manuell implementieren
Gleiches Callback-Muster: Beide verwenden pb_callback_t

Weitere NanoPB-Beiträge

Check out similar posts by category: Embedded, C/C++, Protocol Buffers

If this post helped you, please consider buying me a coffee or donating via PayPal to support research & publishing of new posts on TechOverflow

Buy me a coffee