TechOverflow Logo
TechOverflow

NanoPB: Umgang mit Bytes-Typen in C++

English Français 简体中文 Español Українська Čeština Português Русский Deutsch

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

NanoPB ist eine auf Codegröße optimierte Protocol-Buffers-Implementierung für Embedded-Systeme. Dieser Beitrag zeigt, wie man mit Bytes-Typen in C++ und NanoPB umgeht.

Proto-Definition

Erstelle zunächst eine .proto-Datei mit Bytes-Feldern:

bytes.proto
syntax = "proto3";

package example;

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

NanoPB-Code generieren

Generiere den NanoPB-Code mit einer .options-Datei, um die Puffergrößen für Bytes festzulegen:

Erstelle bytes.options:

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

Generiere dann:

generate_nanopb_bytes.sh
protoc --nanopb_out=. bytes.proto

Dadurch werden bytes.pb.h und bytes.pb.c generiert.

C++-Beispiel mit Puffern fester Größe

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

bytes_example.cpp
#include <stdio.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;
}

Kompilierbefehl

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

compile_bytes_example.sh
g++ -o bytes_example bytes_example.cpp 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. Diese erhältst du aus dem NanoPB GitHub-Repository.

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()}")

Kompiliere zunächst die Python-Protobuf-Definitionen:

compile_python_bytes.sh
protoc --python_out=. bytes.proto

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

save_encoded_bytes.cpp
// 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 die dynamische Verarbeitung von Bytes 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

Generiere den Code neu und verwende diesen Ansatz:

bytes_callback_example.cpp
#include <stdio.h>
#include <vector>
#include "bytes.pb.h"
#include "pb_encode.h"
#include "pb_decode.h"

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

// Decoder-Callback für Bytes
bool bytes_decode_callback(pb_istream_t *stream, const pb_field_t *field, void **arg) {
    std::vector<uint8_t>* data = (std::vector<uint8_t>*)*arg;
    
    // Vektorgröße anpassen, um Daten zu speichern
    size_t size = stream->bytes_left;
    data->resize(size);
    
    // Daten in Vektor lesen
    return pb_read(stream, data->data(), size);
}

int main() {
    uint8_t buffer[256];
    size_t message_length;
    
    std::vector<uint8_t> data = {0x01, 0x02, 0x03, 0x04, 0x05};
    std::vector<uint8_t> signature = {0xAA, 0xBB, 0xCC, 0xDD};
    
    // --- 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;
    std::vector<uint8_t> decoded_data, decoded_signature;
    
    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 (uint8_t byte : decoded_data) {
        printf("%02x ", byte);
    }
    printf("\n");
    printf("  signature: ");
    for (uint8_t byte : decoded_signature) {
        printf("%02x ", byte);
    }
    printf("\n");
    
    return 0;
}

Wichtige Punkte

Wann welcher Ansatz verwendet wird

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

Anwendungsfälle für Bytes

Weitere NanoPB-Beiträge

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