NanoPB: Verschachtelte Nachrichten in C verarbeiten

Siehe auch: C++-Version: Verschachtelte Nachrichten in C++ verarbeiten

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

Proto-Definition

Erstelle zunächst eine .proto-Datei mit verschachtelten Nachrichten:

nested.proto

syntax = "proto3";

package example;

message Address {
  string street = 1;
  string city = 2;
  string country = 3;
}

message Person {
  string name = 1;
  uint32 age = 2;
  Address address = 3;
}

syntax = "proto3";

package example;

message Address {
  string street = 1;
  string city = 2;
  string country = 3;
}

message Person {
  string name = 1;
  uint32 age = 2;
  Address address = 3;
}

NanoPB-Code generieren

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

Erstelle nested.options:

nested.options

example.Address.street max_size:64
example.Address.city max_size:32
example.Address.country max_size:32
example.Person.name max_size:64

example.Address.street max_size:64
example.Address.city max_size:32
example.Address.country max_size:32
example.Person.name max_size:64

Dann generieren:

generate_nanopb_nested.sh

protoc --nanopb_out=. nested.proto

protoc --nanopb_out=. nested.proto

Dies generiert nested.pb.h und nested.pb.c.

C-Beispiel

Hier ist ein vollständiges C-Beispiel zur Verarbeitung verschachtelter Nachrichten:

nested_example.c

#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include "nested.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_Person person = example_Person_init_zero;
    
    // Verschachtelte Nachrichtenwerte setzen
    strncpy(person.name, "John Doe", sizeof(person.name) - 1);
    person.has_address = true;
    strncpy(person.address.street, "123 Main St", sizeof(person.address.street) - 1);
    strncpy(person.address.city, "Springfield", sizeof(person.address.city) - 1);
    strncpy(person.address.country, "USA", sizeof(person.address.country) - 1);
    
    // Strom für Kodierung erstellen
    pb_ostream_t ostream = pb_ostream_from_buffer(buffer, sizeof(buffer));
    
    // Nachricht kodieren
    if (!pb_encode(&ostream, example_Person_fields, &person)) {
        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_Person decoded = example_Person_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_Person_fields, &decoded)) {
        printf("Dekodierung fehlgeschlagen: %s\n", PB_GET_ERROR(&istream));
        return 1;
    }
    
    // Dekodierte Werte ausgeben
    printf("Dekodierte Werte:\n");
    printf("  name: %s\n", decoded.name);
    printf("  age: %u\n", (unsigned int)decoded.age);
    printf("  address:\n");
    printf("    street: %s\n", decoded.address.street);
    printf("    city: %s\n", decoded.address.city);
    printf("    country: %s\n", decoded.address.country);
    
    return 0;
}

#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include "nested.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_Person person = example_Person_init_zero;
    
    // Verschachtelte Nachrichtenwerte setzen
    strncpy(person.name, "John Doe", sizeof(person.name) - 1);
    person.has_address = true;
    strncpy(person.address.street, "123 Main St", sizeof(person.address.street) - 1);
    strncpy(person.address.city, "Springfield", sizeof(person.address.city) - 1);
    strncpy(person.address.country, "USA", sizeof(person.address.country) - 1);
    
    // Strom für Kodierung erstellen
    pb_ostream_t ostream = pb_ostream_from_buffer(buffer, sizeof(buffer));
    
    // Nachricht kodieren
    if (!pb_encode(&ostream, example_Person_fields, &person)) {
        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_Person decoded = example_Person_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_Person_fields, &decoded)) {
        printf("Dekodierung fehlgeschlagen: %s\n", PB_GET_ERROR(&istream));
        return 1;
    }
    
    // Dekodierte Werte ausgeben
    printf("Dekodierte Werte:\n");
    printf("  name: %s\n", decoded.name);
    printf("  age: %u\n", (unsigned int)decoded.age);
    printf("  address:\n");
    printf("    street: %s\n", decoded.address.street);
    printf("    city: %s\n", decoded.address.city);
    printf("    country: %s\n", decoded.address.country);
    
    return 0;
}

Kompilierbefehl

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

compile_nested_example.sh

gcc -o nested_example nested_example.c nested.pb.c pb_common.c pb_encode.c pb_decode.c -I.

gcc -o nested_example nested_example.c nested.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 erhältst diese aus dem NanoPB GitHub-Repository.

Python-Testskript

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

test_nested.py

import nested_pb2

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

# Dekodieren
msg = nested_pb2.Person()
msg.ParseFromString(data)

print("Python dekodierte Werte:")
print(f"  name: {msg.name}")
print(f"  age: {msg.age}")
print(f"  address:")
print(f"    street: {msg.address.street}")
print(f"    city: {msg.address.city}")
print(f"    country: {msg.address.country}")

import nested_pb2

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

# Dekodieren
msg = nested_pb2.Person()
msg.ParseFromString(data)

print("Python dekodierte Werte:")
print(f"  name: {msg.name}")
print(f"  age: {msg.age}")
print(f"  address:")
print(f"    street: {msg.address.street}")
print(f"    city: {msg.address.city}")
print(f"    country: {msg.address.country}")

Kompiliere zunächst die Python-Protobuf-Definitionen:

compile_python_nested.sh

protoc --python_out=. nested.proto

protoc --python_out=. nested.proto

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

save_encoded_nested.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);

Beispiel mit optionaler verschachtelter Nachricht

Hier ist ein Beispiel mit einer optionalen verschachtelten Nachricht:

nested_optional.proto

syntax = "proto3";

package example;

message Address {
  string street = 1;
  string city = 2;
}

message Person {
  string name = 1;
  optional Address address = 2;
}

syntax = "proto3";

package example;

message Address {
  string street = 1;
  string city = 2;
}

message Person {
  string name = 1;
  optional Address address = 2;
}

Erstelle nested_optional.options:

nested_optional.options

example.Address.street max_size:64
example.Address.city max_size:32
example.Person.name max_size:64

example.Address.street max_size:64
example.Address.city max_size:32
example.Person.name max_size:64

nested_optional_example.c

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

int main() {
    uint8_t buffer[256];
    size_t message_length;
    
    // --- KODIERUNG ---
    example_Person person = example_Person_init_zero;
    
    strncpy(person.name, "Jane Doe", sizeof(person.name) - 1);
    
    // Optionale verschachtelte Nachricht setzen
    strncpy(person.address.street, "456 Oak Ave", sizeof(person.address.street) - 1);
    strncpy(person.address.city, "Boston", sizeof(person.address.city) - 1);
    person.has_address = true;  // Wichtig: has_*-Flag setzen
    
    pb_ostream_t ostream = pb_ostream_from_buffer(buffer, sizeof(buffer));
    
    if (!pb_encode(&ostream, example_Person_fields, &person)) {
        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_Person decoded = example_Person_init_zero;
    
    pb_istream_t istream = pb_istream_from_buffer(buffer, message_length);
    
    if (!pb_decode(&istream, example_Person_fields, &decoded)) {
        printf("Dekodierung fehlgeschlagen: %s\n", PB_GET_ERROR(&istream));
        return 1;
    }
    
    printf("Dekodierte Werte:\n");
    printf("  name: %s\n", decoded.name);
    if (decoded.has_address) {
        printf("  address:\n");
        printf("    street: %s\n", decoded.address.street);
        printf("    city: %s\n", decoded.address.city);
    } else {
        printf("  address: (nicht gesetzt)\n");
    }
    
    return 0;
}

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

int main() {
    uint8_t buffer[256];
    size_t message_length;
    
    // --- KODIERUNG ---
    example_Person person = example_Person_init_zero;
    
    strncpy(person.name, "Jane Doe", sizeof(person.name) - 1);
    
    // Optionale verschachtelte Nachricht setzen
    strncpy(person.address.street, "456 Oak Ave", sizeof(person.address.street) - 1);
    strncpy(person.address.city, "Boston", sizeof(person.address.city) - 1);
    person.has_address = true;  // Wichtig: has_*-Flag setzen
    
    pb_ostream_t ostream = pb_ostream_from_buffer(buffer, sizeof(buffer));
    
    if (!pb_encode(&ostream, example_Person_fields, &person)) {
        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_Person decoded = example_Person_init_zero;
    
    pb_istream_t istream = pb_istream_from_buffer(buffer, message_length);
    
    if (!pb_decode(&istream, example_Person_fields, &decoded)) {
        printf("Dekodierung fehlgeschlagen: %s\n", PB_GET_ERROR(&istream));
        return 1;
    }
    
    printf("Dekodierte Werte:\n");
    printf("  name: %s\n", decoded.name);
    if (decoded.has_address) {
        printf("  address:\n");
        printf("    street: %s\n", decoded.address.street);
        printf("    city: %s\n", decoded.address.city);
    } else {
        printf("  address: (nicht gesetzt)\n");
    }
    
    return 0;
}

Wichtige Punkte

Verschachtelte Nachrichten: Nachrichten können andere Nachrichten als Felder enthalten
Initialisierung: Verwende *_init_zero, um sowohl äußere als auch verschachtelte Nachrichten zu initialisieren
Codierung: Setze verschachtelte Nachrichtenfelder direkt und codiere dann die äußere Nachricht
Decodierung: Decodiere die äußere Nachricht, verschachtelte Nachrichten werden automatisch decodiert
Optionale Verschachtelung: Verwende das Schlüsselwort optional und setze das has_*-Flag
Struktur: Verschachtelte Nachrichten bieten hierarchische Datenorganisation
Puffergrößen: Gib Puffergrößen für alle String-Felder in der .options-Datei an

Wann man verschachtelte Nachrichten verwendet

Wenn du hierarchische oder gruppierte Daten hast
Wenn du Nachrichtendefinitionen wiederverwenden möchtest
Wenn du verwandte Felder zusammen organisieren musst
Wenn du die Lesbarkeit von Nachrichten verbessern möchtest
Wenn du komplexe Datenstrukturen hast

Erwartete Ausgabe

nested_expected_output.txt

35 Bytes kodiert
Kodierte Daten: 0a 08 4a 6f 68 6e 20 44 6f 65 10 1e 1a 1b 0a 0b 31 32 33 20 4d 61 69 6e 20 53 74 12 08 4e 65 77 20 59 6f 72 6b 1a 03 55 53 41 
Dekodierte Werte:
  name: John Doe
  age: 30
  address:
    street: 123 Main St
    city: New York
    country: USA

35 Bytes kodiert
Kodierte Daten: 0a 08 4a 6f 68 6e 20 44 6f 65 10 1e 1a 1b 0a 0b 31 32 33 20 4d 61 69 6e 20 53 74 12 08 4e 65 77 20 59 6f 72 6b 1a 03 55 53 41 
Dekodierte Werte:
  name: John Doe
  age: 30
  address:
    street: 123 Main St
    city: New York
    country: USA

Erwartete Ausgabe (optionale Verschachtelung)

nested_optional_expected_output.txt

27 Bytes kodiert
Dekodierte Werte:
  name: Jane Doe
  address:
    street: 456 Oak Ave
    city: Boston

27 Bytes kodiert
Dekodierte Werte:
  name: Jane Doe
  address:
    street: 456 Oak Ave
    city: Boston

Unterschiede zu C++

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

Verwende explizite Typumwandlungen für printf-Formatbezeichner in C
Keine C++-spezifischen Funktionen für die Verarbeitung verschachtelter Nachrichten erforderlich
Generierter Code ist für beide Sprachen identisch
Speicherverwaltung ist dieselbe (statische Zuweisung in beiden Fällen)

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