NanoPB: Jak pracovat s vnořenými zprávami v C

Viz také: Verze v C++: Jak pracovat s vnořenými zprávami v C++

NanoPB je implementace Protocol Buffers optimalizovaná na velikost kódu pro vestavěné systémy. Tento příspěvek ukazuje, jak pracovat s vnořenými zprávami v C s NanoPB.

Definice Proto

Nejprve vytvořte soubor .proto s vnořenými zprávami:

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;
}

Generování NanoPB kódu

Vygenerujte NanoPB kód se souborem .options pro určení velikostí bufferů řetězců:

Vytvořte 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

Poté vygenerujte:

generate_nanopb_nested.sh

protoc --nanopb_out=. nested.proto

Tím se vygenerují nested.pb.h a nested.pb.c.

Příklad v C

Zde je kompletní příklad v C zpracovávající vnořené zprávy:

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 pro kódovanou zprávu
    uint8_t buffer[256];
    size_t message_length;
    
    // --- KÓDOVÁNÍ ---
    example_Person person = example_Person_init_zero;
    
    // Nastavení hodnot vnořené zprávy
    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);
    
    // Vytvoření streamu pro kódování
    pb_ostream_t ostream = pb_ostream_from_buffer(buffer, sizeof(buffer));
    
    // Kódování zprávy
    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);
    
    // Výpis hex dumpu kódovaných dat
    printf("Encoded data: ");
    for (size_t i = 0; i < message_length; i++) {
        printf("%02x ", buffer[i]);
    }
    printf("\n");
    
    // --- DEKÓDOVÁNÍ ---
    example_Person decoded = example_Person_init_zero;
    
    // Vytvoření streamu pro dekódování
    pb_istream_t istream = pb_istream_from_buffer(buffer, message_length);
    
    // Dekódování zprávy
    if (!pb_decode(&istream, example_Person_fields, &decoded)) {
        printf("Decoding failed: %s\n", PB_GET_ERROR(&istream));
        return 1;
    }
    
    // Výpis dekódovaných hodnot
    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;
}

Příkaz pro kompilaci

Zkompilujte příklad s nanopb. NanoPB se typicky používá tak, že se zdrojové soubory přímo vloží do vašeho projektu:

compile_nested_example.sh

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

Poznámka: Zdrojové soubory NanoPB (pb_common.c, pb_encode.c, pb_decode.c) je třeba kompilovat přímo s vaším projektem. Můžete je získat z NanoPB GitHub repozitáře.

Testovací skript v Pythonu

Pro ověření kódování můžete použít knihovnu protobuf v Pythonu:

test_nested.py

import nested_pb2

# Načtení binárních dat
with open('encoded.bin', 'rb') as f:
    data = f.read()

# Dekódování
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}")

Nejprve zkompilujte definice protobuf pro Python:

compile_python_nested.sh

protoc --python_out=. nested.proto

Poté upravte příklad v C tak, aby ukládal kódovaná data do souboru:

save_encoded_nested.c

// Po kódování přidejte toto:
FILE *f = fopen("encoded.bin", "wb");
fwrite(buffer, 1, message_length, f);
fclose(f);

Příklad s volitelnou vnořenou zprávou

Zde je příklad s volitelnou vnořenou zprávou:

nested_optional.proto

syntax = "proto3";

package example;

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

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

Vytvořte nested_optional.options:

nested_optional.options

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;
    
    // --- KÓDOVÁNÍ ---
    example_Person person = example_Person_init_zero;
    
    strncpy(person.name, "Jane Doe", sizeof(person.name) - 1);
    
    // Nastavení volitelné vnořené zprávy
    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;  // Důležité: nastavit příznak has_*
    
    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);
    
    // --- DEKÓDOVÁNÍ ---
    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;
}

Klíčové body

Vnořené zprávy: Zprávy mohou obsahovat další zprávy jako pole
Inicializace: Použijte *_init_zero pro inicializaci vnějších i vnořených zpráv
Kódování: Nastavte pole vnořené zprávy přímo, poté zakódujte vnější zprávu
Dekódování: Dekódujte vnější zprávu, vnořené zprávy se dekódují automaticky
Volitelné vnořené: Použijte klíčové slovo optional a nastavte příznak has_*
Struktura: Vnořené zprávy poskytují hierarchickou organizaci dat
Velikosti bufferů: Zadejte velikosti bufferů pro všechna pole řetězců v souboru .options

Kdy použít vnořené zprávy

Pokud máte hierarchická nebo seskupená data
Pokud chcete znovu použít definice zpráv
Pokud potřebujete organizovat související pole společně
Pokud chcete zlepšit čitelnost zpráv
Pokud máte složité datové struktury

Očekávaný výstup

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

Očekávaný výstup (volitelná vnořená zpráva)

nested_optional_expected_output.txt

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

Rozdíly oproti C++

Verze v C je téměř identická s verzí v C++, s klíčovými rozdíly:

Použijte explicitní přetypování pro specifikátory formátu printf v C
Nejsou potřeba žádné funkce specifické pro C++ pro zpracování vnořených zpráv
Vygenerovaný kód je identický pro oba jazyky
Správa paměti je stejná (statická alokace v obou případech)