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

Erstellen Sie 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

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

Erstellen Sie 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() {
    // Buffer for encoded message
    uint8_t buffer[256];
    size_t message_length;
    
    // --- ENCODING ---
    example_Person person = example_Person_init_zero;
    
    // Set nested message values
    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);
    
    // Create stream for encoding
    pb_ostream_t ostream = pb_ostream_from_buffer(buffer, sizeof(buffer));
    
    // Encode the message
    if (!pb_encode(&ostream, example_Person_fields, &person)) {
        printf("Encoding failed: %s\n", PB_GET_ERROR(&ostream));
        return 1;
    }
    
    message_length = ostream.bytes_written;
    printf("Encoded %zu bytes\n", message_length);
    
    // Print hex dump of encoded data
    printf("Encoded data: ");
    for (size_t i = 0; i < message_length; i++) {
        printf("%02x ", buffer[i]);
    }
    printf("\n");
    
    // --- DECODING ---
    example_Person decoded = example_Person_init_zero;
    
    // Create stream for decoding
    pb_istream_t istream = pb_istream_from_buffer(buffer, message_length);
    
    // Decode the message
    if (!pb_decode(&istream, example_Person_fields, &decoded)) {
        printf("Decoding failed: %s\n", PB_GET_ERROR(&istream));
        return 1;
    }
    
    // Print decoded values
    printf("Decoded values:\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() {
    // Buffer for encoded message
    uint8_t buffer[256];
    size_t message_length;
    
    // --- ENCODING ---
    example_Person person = example_Person_init_zero;
    
    // Set nested message values
    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);
    
    // Create stream for encoding
    pb_ostream_t ostream = pb_ostream_from_buffer(buffer, sizeof(buffer));
    
    // Encode the message
    if (!pb_encode(&ostream, example_Person_fields, &person)) {
        printf("Encoding failed: %s\n", PB_GET_ERROR(&ostream));
        return 1;
    }
    
    message_length = ostream.bytes_written;
    printf("Encoded %zu bytes\n", message_length);
    
    // Print hex dump of encoded data
    printf("Encoded data: ");
    for (size_t i = 0; i < message_length; i++) {
        printf("%02x ", buffer[i]);
    }
    printf("\n");
    
    // --- DECODING ---
    example_Person decoded = example_Person_init_zero;
    
    // Create stream for decoding
    pb_istream_t istream = pb_istream_from_buffer(buffer, message_length);
    
    // Decode the message
    if (!pb_decode(&istream, example_Person_fields, &decoded)) {
        printf("Decoding failed: %s\n", PB_GET_ERROR(&istream));
        return 1;
    }
    
    // Print decoded values
    printf("Decoded values:\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

Kompilieren Sie das Beispiel mit NanoPB. NanoPB wird typischerweise verwendet, indem die Quelldateien direkt in Ihr 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 Ihrem Projekt kompiliert werden. Sie erhalten diese aus dem NanoPB GitHub-Repository.

Python-Testskript

Um die Codierung zu überprüfen, können Sie die Python-Protobuf-Bibliothek verwenden:

test_nested.py

import nested_pb2

# Read the binary data
with open('encoded.bin', 'rb') as f:
    data = f.read()

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

print("Python decoded values:")
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

# Read the binary data
with open('encoded.bin', 'rb') as f:
    data = f.read()

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

print("Python decoded values:")
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}")

Kompilieren Sie zunächst die Python-Protobuf-Definitionen:

compile_python_nested.sh

protoc --python_out=. nested.proto

protoc --python_out=. nested.proto

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

save_encoded_nested.c

// After encoding, add this:
FILE *f = fopen("encoded.bin", "wb");
fwrite(buffer, 1, message_length, f);
fclose(f);

// After encoding, add this:
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;
}

Erstellen Sie 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;
    
    // --- ENCODING ---
    example_Person person = example_Person_init_zero;
    
    strncpy(person.name, "Jane Doe", sizeof(person.name) - 1);
    
    // Set optional nested message
    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;  // Important: set has_* flag
    
    pb_ostream_t ostream = pb_ostream_from_buffer(buffer, sizeof(buffer));
    
    if (!pb_encode(&ostream, example_Person_fields, &person)) {
        printf("Encoding failed: %s\n", PB_GET_ERROR(&ostream));
        return 1;
    }
    
    message_length = ostream.bytes_written;
    printf("Encoded %zu bytes\n", message_length);
    
    // --- DECODING ---
    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("Decoding failed: %s\n", PB_GET_ERROR(&istream));
        return 1;
    }
    
    printf("Decoded values:\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: (not set)\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;
    
    // --- ENCODING ---
    example_Person person = example_Person_init_zero;
    
    strncpy(person.name, "Jane Doe", sizeof(person.name) - 1);
    
    // Set optional nested message
    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;  // Important: set has_* flag
    
    pb_ostream_t ostream = pb_ostream_from_buffer(buffer, sizeof(buffer));
    
    if (!pb_encode(&ostream, example_Person_fields, &person)) {
        printf("Encoding failed: %s\n", PB_GET_ERROR(&ostream));
        return 1;
    }
    
    message_length = ostream.bytes_written;
    printf("Encoded %zu bytes\n", message_length);
    
    // --- DECODING ---
    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("Decoding failed: %s\n", PB_GET_ERROR(&istream));
        return 1;
    }
    
    printf("Decoded values:\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: (not set)\n");
    }
    
    return 0;
}

Wichtige Punkte

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

Wann man verschachtelte Nachrichten verwendet

Wenn Sie hierarchische oder gruppierte Daten haben
Wenn Sie Nachrichtendefinitionen wiederverwenden möchten
Wenn Sie verwandte Felder zusammen organisieren müssen
Wenn Sie die Lesbarkeit von Nachrichten verbessern möchten
Wenn Sie komplexe Datenstrukturen haben

Erwartete Ausgabe

nested_expected_output.txt

Encoded 35 bytes
Encoded data: 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 
Decoded values:
  name: John Doe
  age: 30
  address:
    street: 123 Main St
    city: New York
    country: USA

Encoded 35 bytes
Encoded data: 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 
Decoded values:
  name: John Doe
  age: 30
  address:
    street: 123 Main St
    city: New York
    country: USA

Erwartete Ausgabe (optionale Verschachtelung)

nested_optional_expected_output.txt

Encoded 27 bytes
Decoded values:
  name: Jane Doe
  address:
    street: 456 Oak Ave
    city: Boston

Encoded 27 bytes
Decoded values:
  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:

Verwenden Sie 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

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