NanoPB: Umgang mit Bytes-Typen in C

Siehe auch: C++-Version: Umgang mit Bytes-Typen in C++

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

Proto-Definition

Erstelle zuerst eine .proto-Datei mit Bytes-Feldern:

bytes.proto

syntax = "proto3";

package example;

message BytesMessage {
  bytes data = 1;
  bytes signature = 2;
}

syntax = "proto3";

package example;

message BytesMessage {
  bytes data = 1;
  bytes signature = 2;
}

NanoPB-Code generieren

Generiere den NanoPB-Code mit einer .options-Datei, um Bytes-Puffergrößen anzugeben:

Erstelle bytes.options:

bytes.options

example.BytesMessage.data max_size:32
example.BytesMessage.signature max_size:16

example.BytesMessage.data max_size:32
example.BytesMessage.signature max_size:16

Dann generieren:

generate_nanopb_bytes.sh

protoc --nanopb_out=. bytes.proto

protoc --nanopb_out=. bytes.proto

Dies generiert bytes.pb.h und bytes.pb.c.

C-Beispiel mit Puffern fester Größe

Hier ist ein vollständiges C-Beispiel mit Puffern fester Größe:

bytes_example.c

#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include "bytes.pb.h"
#include "pb_encode.h"
#include "pb_decode.h"

int main() {
    // Puffer für kodierte Nachricht
    uint8_t buffer[256];
    size_t message_length;
    
    // --- KODIERUNG ---
    example_BytesMessage message = example_BytesMessage_init_zero;
    
    // Bytes-Daten setzen
    const uint8_t data[] = {0x01, 0x02, 0x03, 0x04, 0x05};
    const uint8_t signature[] = {0xAA, 0xBB, 0xCC, 0xDD};
    
    message.data.size = sizeof(data);
    memcpy(message.data.bytes, data, sizeof(data));
    
    message.signature.size = sizeof(signature);
    memcpy(message.signature.bytes, signature, sizeof(signature));
    
    // Strom für Kodierung erstellen
    pb_ostream_t ostream = pb_ostream_from_buffer(buffer, sizeof(buffer));
    
    // Nachricht kodieren
    if (!pb_encode(&ostream, example_BytesMessage_fields, &message)) {
        printf("Kodierung fehlgeschlagen: %s\n", PB_GET_ERROR(&ostream));
        return 1;
    }
    
    message_length = ostream.bytes_written;
    printf("%zu Bytes kodiert\n", message_length);
    
    // Hex-Dump der kodierten Daten ausgeben
    printf("Kodierte Daten: ");
    for (size_t i = 0; i < message_length; i++) {
        printf("%02x ", buffer[i]);
    }
    printf("\n");
    
    // --- DEKODIERUNG ---
    example_BytesMessage decoded = example_BytesMessage_init_zero;
    
    // Strom für Dekodierung erstellen
    pb_istream_t istream = pb_istream_from_buffer(buffer, message_length);
    
    // Nachricht dekodieren
    if (!pb_decode(&istream, example_BytesMessage_fields, &decoded)) {
        printf("Dekodierung fehlgeschlagen: %s\n", PB_GET_ERROR(&istream));
        return 1;
    }
    
    // Dekodierte Werte ausgeben
    printf("Dekodierte Werte:\n");
    printf("  data: ");
    for (size_t i = 0; i < decoded.data.size; i++) {
        printf("%02x ", decoded.data.bytes[i]);
    }
    printf("\n");
    printf("  signature: ");
    for (size_t i = 0; i < decoded.signature.size; i++) {
        printf("%02x ", decoded.signature.bytes[i]);
    }
    printf("\n");
    
    return 0;
}

#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include "bytes.pb.h"
#include "pb_encode.h"
#include "pb_decode.h"

int main() {
    // Puffer für kodierte Nachricht
    uint8_t buffer[256];
    size_t message_length;
    
    // --- KODIERUNG ---
    example_BytesMessage message = example_BytesMessage_init_zero;
    
    // Bytes-Daten setzen
    const uint8_t data[] = {0x01, 0x02, 0x03, 0x04, 0x05};
    const uint8_t signature[] = {0xAA, 0xBB, 0xCC, 0xDD};
    
    message.data.size = sizeof(data);
    memcpy(message.data.bytes, data, sizeof(data));
    
    message.signature.size = sizeof(signature);
    memcpy(message.signature.bytes, signature, sizeof(signature));
    
    // Strom für Kodierung erstellen
    pb_ostream_t ostream = pb_ostream_from_buffer(buffer, sizeof(buffer));
    
    // Nachricht kodieren
    if (!pb_encode(&ostream, example_BytesMessage_fields, &message)) {
        printf("Kodierung fehlgeschlagen: %s\n", PB_GET_ERROR(&ostream));
        return 1;
    }
    
    message_length = ostream.bytes_written;
    printf("%zu Bytes kodiert\n", message_length);
    
    // Hex-Dump der kodierten Daten ausgeben
    printf("Kodierte Daten: ");
    for (size_t i = 0; i < message_length; i++) {
        printf("%02x ", buffer[i]);
    }
    printf("\n");
    
    // --- DEKODIERUNG ---
    example_BytesMessage decoded = example_BytesMessage_init_zero;
    
    // Strom für Dekodierung erstellen
    pb_istream_t istream = pb_istream_from_buffer(buffer, message_length);
    
    // Nachricht dekodieren
    if (!pb_decode(&istream, example_BytesMessage_fields, &decoded)) {
        printf("Dekodierung fehlgeschlagen: %s\n", PB_GET_ERROR(&istream));
        return 1;
    }
    
    // Dekodierte Werte ausgeben
    printf("Dekodierte Werte:\n");
    printf("  data: ");
    for (size_t i = 0; i < decoded.data.size; i++) {
        printf("%02x ", decoded.data.bytes[i]);
    }
    printf("\n");
    printf("  signature: ");
    for (size_t i = 0; i < decoded.signature.size; i++) {
        printf("%02x ", decoded.signature.bytes[i]);
    }
    printf("\n");
    
    return 0;
}

Kompilierungsbefehl

Kompiliere das Beispiel mit NanoPB. NanoPB wird typischerweise verwendet, indem die Quelldateien direkt in dein Projekt eingebunden werden:

compile_bytes_example.sh

gcc -o bytes_example bytes_example.c bytes.pb.c pb_common.c pb_encode.c pb_decode.c -I.

gcc -o bytes_example bytes_example.c bytes.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 deinem Projekt kompiliert werden. Du kannst diese aus dem NanoPB GitHub-Repository beziehen.

Python-Testskript

Um die Kodierung zu überprüfen, kannst du die Python-Protobuf-Bibliothek verwenden:

test_bytes.py

import bytes_pb2

# Binärdaten lesen
with open('encoded.bin', 'rb') as f:
    data = f.read()

# Dekodieren
msg = bytes_pb2.BytesMessage()
msg.ParseFromString(data)

print("Python dekodierte Werte:")
print(f"  data: {msg.data.hex()}")
print(f"  signature: {msg.signature.hex()}")

import bytes_pb2

# Binärdaten lesen
with open('encoded.bin', 'rb') as f:
    data = f.read()

# Dekodieren
msg = bytes_pb2.BytesMessage()
msg.ParseFromString(data)

print("Python dekodierte Werte:")
print(f"  data: {msg.data.hex()}")
print(f"  signature: {msg.signature.hex()}")

Kompiliere zuerst die Python-Protobuf-Definitionen:

compile_python_bytes.sh

protoc --python_out=. bytes.proto

protoc --python_out=. bytes.proto

Ändere dann das C-Beispiel, um die kodierten Daten in einer Datei zu speichern:

save_encoded_bytes.c

// Nach der Kodierung, dies hinzufügen:
FILE *f = fopen("encoded.bin", "wb");
fwrite(buffer, 1, message_length, f);
fclose(f);

// Nach der Kodierung, dies hinzufügen:
FILE *f = fopen("encoded.bin", "wb");
fwrite(buffer, 1, message_length, f);
fclose(f);

Alternative: Callback-basierte Bytes

Für dynamische Bytes-Verarbeitung kannst du Callbacks verwenden. Erstelle bytes_callback.options:

bytes_callback.options

# Callback für dynamische Bytes verwenden
msg.BytesMessage.data callback
msg.BytesMessage.signature callback

# Callback für dynamische Bytes verwenden
msg.BytesMessage.data callback
msg.BytesMessage.signature callback

Dann neu generieren und diesen Ansatz verwenden:

bytes_callback_example.c

#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include "bytes.pb.h"
#include "pb_encode.h"
#include "pb_decode.h"

typedef struct {
    uint8_t* data;
    size_t size;
} dynamic_bytes_t;

// Encoder-Callback für Bytes
bool bytes_encode_callback(pb_ostream_t *stream, const pb_field_t *field, void * const *arg) {
    const dynamic_bytes_t* bytes = (const dynamic_bytes_t*)*arg;
    
    if (!pb_encode_tag_for_field(stream, field))
        return false;
    
    return pb_encode_string(stream, bytes->data, bytes->size);
}

// Decoder-Callback für Bytes
bool bytes_decode_callback(pb_istream_t *stream, const pb_field_t *field, void **arg) {
    dynamic_bytes_t* bytes = (dynamic_bytes_t*)*arg;
    
    // Puffer allozieren
    size_t size = stream->bytes_left;
    bytes->data = (uint8_t*)malloc(size);
    
    if (!bytes->data) {
        return false;
    }
    
    bytes->size = size;
    
    // Daten in Puffer lesen
    if (!pb_read(stream, bytes->data, size)) {
        free(bytes->data);
        bytes->data = NULL;
        bytes->size = 0;
        return false;
    }
    
    return true;
}

int main() {
    uint8_t buffer[256];
    size_t message_length;
    
    uint8_t data_array[] = {0x01, 0x02, 0x03, 0x04, 0x05};
    uint8_t signature_array[] = {0xAA, 0xBB, 0xCC, 0xDD};
    
    dynamic_bytes_t data = {data_array, sizeof(data_array)};
    dynamic_bytes_t signature = {signature_array, sizeof(signature_array)};
    
    // --- KODIERUNG ---
    example_BytesMessage message = example_BytesMessage_init_zero;
    
    message.data.funcs.encode = bytes_encode_callback;
    message.data.arg = &data;
    message.signature.funcs.encode = bytes_encode_callback;
    message.signature.arg = &signature;
    
    pb_ostream_t ostream = pb_ostream_from_buffer(buffer, sizeof(buffer));
    
    if (!pb_encode(&ostream, example_BytesMessage_fields, &message)) {
        printf("Kodierung fehlgeschlagen: %s\n", PB_GET_ERROR(&ostream));
        return 1;
    }
    
    message_length = ostream.bytes_written;
    printf("%zu Bytes kodiert\n", message_length);
    
    // --- DEKODIERUNG ---
    example_BytesMessage decoded = example_BytesMessage_init_zero;
    dynamic_bytes_t decoded_data = {NULL, 0};
    dynamic_bytes_t decoded_signature = {NULL, 0};
    
    decoded.data.funcs.decode = bytes_decode_callback;
    decoded.data.arg = &decoded_data;
    decoded.signature.funcs.decode = bytes_decode_callback;
    decoded.signature.arg = &decoded_signature;
    
    pb_istream_t istream = pb_istream_from_buffer(buffer, message_length);
    
    if (!pb_decode(&istream, example_BytesMessage_fields, &decoded)) {
        printf("Dekodierung fehlgeschlagen: %s\n", PB_GET_ERROR(&istream));
        return 1;
    }
    
    printf("Dekodierte Werte:\n");
    printf("  data: ");
    for (size_t i = 0; i < decoded_data.size; i++) {
        printf("%02x ", decoded_data.data[i]);
    }
    printf("\n");
    printf("  signature: ");
    for (size_t i = 0; i < decoded_signature.size; i++) {
        printf("%02x ", decoded_signature.data[i]);
    }
    printf("\n");
    
    // Allokierten Speicher freigeben
    free(decoded_data.data);
    free(decoded_signature.data);
    
    return 0;
}

#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include "bytes.pb.h"
#include "pb_encode.h"
#include "pb_decode.h"

typedef struct {
    uint8_t* data;
    size_t size;
} dynamic_bytes_t;

// Encoder-Callback für Bytes
bool bytes_encode_callback(pb_ostream_t *stream, const pb_field_t *field, void * const *arg) {
    const dynamic_bytes_t* bytes = (const dynamic_bytes_t*)*arg;
    
    if (!pb_encode_tag_for_field(stream, field))
        return false;
    
    return pb_encode_string(stream, bytes->data, bytes->size);
}

// Decoder-Callback für Bytes
bool bytes_decode_callback(pb_istream_t *stream, const pb_field_t *field, void **arg) {
    dynamic_bytes_t* bytes = (dynamic_bytes_t*)*arg;
    
    // Puffer allozieren
    size_t size = stream->bytes_left;
    bytes->data = (uint8_t*)malloc(size);
    
    if (!bytes->data) {
        return false;
    }
    
    bytes->size = size;
    
    // Daten in Puffer lesen
    if (!pb_read(stream, bytes->data, size)) {
        free(bytes->data);
        bytes->data = NULL;
        bytes->size = 0;
        return false;
    }
    
    return true;
}

int main() {
    uint8_t buffer[256];
    size_t message_length;
    
    uint8_t data_array[] = {0x01, 0x02, 0x03, 0x04, 0x05};
    uint8_t signature_array[] = {0xAA, 0xBB, 0xCC, 0xDD};
    
    dynamic_bytes_t data = {data_array, sizeof(data_array)};
    dynamic_bytes_t signature = {signature_array, sizeof(signature_array)};
    
    // --- KODIERUNG ---
    example_BytesMessage message = example_BytesMessage_init_zero;
    
    message.data.funcs.encode = bytes_encode_callback;
    message.data.arg = &data;
    message.signature.funcs.encode = bytes_encode_callback;
    message.signature.arg = &signature;
    
    pb_ostream_t ostream = pb_ostream_from_buffer(buffer, sizeof(buffer));
    
    if (!pb_encode(&ostream, example_BytesMessage_fields, &message)) {
        printf("Kodierung fehlgeschlagen: %s\n", PB_GET_ERROR(&ostream));
        return 1;
    }
    
    message_length = ostream.bytes_written;
    printf("%zu Bytes kodiert\n", message_length);
    
    // --- DEKODIERUNG ---
    example_BytesMessage decoded = example_BytesMessage_init_zero;
    dynamic_bytes_t decoded_data = {NULL, 0};
    dynamic_bytes_t decoded_signature = {NULL, 0};
    
    decoded.data.funcs.decode = bytes_decode_callback;
    decoded.data.arg = &decoded_data;
    decoded.signature.funcs.decode = bytes_decode_callback;
    decoded.signature.arg = &decoded_signature;
    
    pb_istream_t istream = pb_istream_from_buffer(buffer, message_length);
    
    if (!pb_decode(&istream, example_BytesMessage_fields, &decoded)) {
        printf("Dekodierung fehlgeschlagen: %s\n", PB_GET_ERROR(&istream));
        return 1;
    }
    
    printf("Dekodierte Werte:\n");
    printf("  data: ");
    for (size_t i = 0; i < decoded_data.size; i++) {
        printf("%02x ", decoded_data.data[i]);
    }
    printf("\n");
    printf("  signature: ");
    for (size_t i = 0; i < decoded_signature.size; i++) {
        printf("%02x ", decoded_signature.data[i]);
    }
    printf("\n");
    
    // Allokierten Speicher freigeben
    free(decoded_data.data);
    free(decoded_signature.data);
    
    return 0;
}

Wichtige Punkte

Puffer fester Größe: Verwende max_size in der .options-Datei für einfache, statische Allokation
Callback-basiert: Verwende callback in .options für dynamische Bytes-Verarbeitung
Feste Größe: Setze das *_size-Feld und verwende memcpy zum Kopieren von Bytes
Callback-basiert: Implementiere Kodierungs-/Dekodierungs-Callbacks mit manueller Speicherverwaltung
Bytes sind ähnlich wie Strings, enthalten aber rohe Binärdaten (keine Null-Terminierung)
Verwende malloc/free in C für dynamische Bytes-Verarbeitung
Überprüfe immer Puffergrößen, um Überläufe zu verhindern
Denke daran, im Callback-basierten Ansatz den allokierten Speicher freizugeben

Wann welcher Ansatz verwendet werden sollte

Puffer fester Größe: Wenn du die maximale Bytes-Größe kennst und einfachen Code wünschst
Callback-basiert: Wenn die Bytes-Größe variabel ist oder du dynamische Speicherallokation benötigst

Erwartete Ausgabe

bytes_expected_output.txt

14 Bytes kodiert
Kodierte Daten: 0a 05 01 02 03 04 05 12 04 aa bb cc dd 
Dekodierte Werte:
  data: 01 02 03 04 05 
  signature: aa bb cc dd 

14 Bytes kodiert
Kodierte Daten: 0a 05 01 02 03 04 05 12 04 aa bb cc dd 
Dekodierte Werte:
  data: 01 02 03 04 05 
  signature: aa bb cc dd

Unterschiede zu C++

Die C-Version ist nahezu identisch mit der C++-Version, mit wesentlichen Unterschieden:

Verwende malloc/free statt std::vector für dynamische Bytes
Manuelle Speicherverwaltung erforderlich (keine Destruktoren)
Verwende struct für dynamische Bytes-Wrapper statt std::vector
Denke daran, den allokierten Speicher nach der Verwendung freizugeben
Keine automatische Speicherverwaltung in C

Anwendungsfälle für Bytes

Binärdaten (Bilder, Audio usw.)
Kryptografische Signaturen
Rohe Sensordaten
Benutzerdefinierte Binärprotokolle
Alle Daten, die nicht als Text interpretiert werden sollen

Weitere NanoPB-Beiträge

Ähnliche Beiträge nach Kategorie: Embedded, C/C++, Protocol Buffers

Wenn dieser Beitrag dir geholfen hat, erwäge, mir einen Kaffee zu spendieren oder per PayPal zu spenden, um die Recherche und Veröffentlichung neuer Beiträge auf TechOverflow zu unterstützen

Buy me a coffee