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

NanoPB: Как обрабатывать строковые типы в C++

Uli Köhler 7 min read

Смотрите также: Версия на C: Как обрабатывать строковые типы в C

NanoPB — это оптимизированная по размеру кода реализация Protocol Buffers для встраиваемых систем. В этом посте показано, как обрабатывать строковые типы в C++ с помощью NanoPB.

Определение proto

Сначала создайте файл .proto со строковыми полями:

strings.proto
syntax = "proto3";

package example;

message StringMessage {
  string name = 1;
  string description = 2;
}

Генерация кода NanoPB

Сгенерируйте код NanoPB с помощью файла .options для указания размеров строковых буферов:

Создайте strings.options:

strings.options
example.StringMessage.name max_size:64
example.StringMessage.description max_size:256

Затем сгенерируйте:

generate_nanopb_strings.sh
protoc --nanopb_out=. strings.proto

Это создаст strings.pb.h и strings.pb.c.

Пример на C++ с буферами фиксированного размера

Вот полный пример на C++ с использованием буферов фиксированного размера:

strings_example.cpp
#include <stdio.h>
#include <string.h>
#include "strings.pb.h"
#include "pb_encode.h"
#include "pb_decode.h"

int main() {
    // Буфер для закодированного сообщения
    uint8_t buffer[256];
    size_t message_length;
    
    // --- КОДИРОВАНИЕ ---
    example_StringMessage message = example_StringMessage_init_zero;
    
    // Установка строковых значений (должны помещаться в размер буфера)
    const char* name = "NanoPB";
    const char* description = "Protocol Buffers for embedded systems";
    
    strncpy(message.name, name, sizeof(message.name) - 1);
    strncpy(message.description, description, sizeof(message.description) - 1);
    
    // Создание потока для кодирования
    pb_ostream_t ostream = pb_ostream_from_buffer(buffer, sizeof(buffer));
    
    // Кодирование сообщения
    if (!pb_encode(&ostream, example_StringMessage_fields, &message)) {
        printf("Encoding failed: %s\n", PB_GET_ERROR(&ostream));
        return 1;
    }
    
    message_length = ostream.bytes_written;
    printf("Encoded %zu bytes\n", message_length);
    
    // Вывод шестнадцатеричного дампа закодированных данных
    printf("Encoded data: ");
    for (size_t i = 0; i < message_length; i++) {
        printf("%02x ", buffer[i]);
    }
    printf("\n");
    
    // --- ДЕКОДИРОВАНИЕ ---
    example_StringMessage decoded = example_StringMessage_init_zero;
    
    // Создание потока для декодирования
    pb_istream_t istream = pb_istream_from_buffer(buffer, message_length);
    
    // Декодирование сообщения
    if (!pb_decode(&istream, example_StringMessage_fields, &decoded)) {
        printf("Decoding failed: %s\n", PB_GET_ERROR(&istream));
        return 1;
    }
    
    // Вывод декодированных значений
    printf("Decoded values:\n");
    printf("  name: %s\n", decoded.name);
    printf("  description: %s\n", decoded.description);
    
    return 0;
}

Команда компиляции

Скомпилируйте пример с помощью nanopb. NanoPB обычно используется путём прямого включения исходных файлов в ваш проект:

compile_strings_example.sh
g++ -o strings_example strings_example.cpp strings.pb.c pb_common.c pb_encode.c pb_decode.c -I.

Примечание: Исходные файлы NanoPB (pb_common.c, pb_encode.c, pb_decode.c) необходимо компилировать напрямую вместе с вашим проектом. Их можно получить в репозитории NanoPB на GitHub.

Скрипт тестирования на Python

Чтобы проверить кодирование, вы можете использовать библиотеку protobuf для Python:

test_strings.py
import strings_pb2

# Чтение бинарных данных
with open('encoded.bin', 'rb') as f:
    data = f.read()

# Декодирование
msg = strings_pb2.StringMessage()
msg.ParseFromString(data)

print("Python decoded values:")
print(f"  name: {msg.name}")
print(f"  description: {msg.description}")

Сначала скомпилируйте определения protobuf для Python:

compile_python_strings.sh
protoc --python_out=. strings.proto

Затем измените пример на C++, чтобы сохранить закодированные данные в файл:

save_encoded_strings.cpp
// После кодирования добавьте это:
FILE *f = fopen("encoded.bin", "wb");
fwrite(buffer, 1, message_length, f);
fclose(f);

Альтернатива: Строки на основе обратных вызовов

Для динамической обработки строк можно использовать обратные вызовы. Создайте strings_callback.options:

strings_callback.options
# Использовать обратный вызов для динамических строк
msg.StringMessage.name callback
msg.StringMessage.description callback

Затем перегенерируйте и используйте этот подход:

strings_callback_example.cpp
#include <stdio.h>
#include <string>
#include "strings.pb.h"
#include "pb_encode.h"
#include "pb_decode.h"

// Обратный вызов кодировщика для строк
bool string_encode_callback(pb_ostream_t *stream, const pb_field_t *field, void * const *arg) {
    const std::string* str = (const std::string*)*arg;
    
    if (!pb_encode_tag_for_field(stream, field))
        return false;
    
    return pb_encode_string(stream, (const pb_byte_t*)str->c_str(), str->size());
}

// Обратный вызов декодировщика для строк
bool string_decode_callback(pb_istream_t *stream, const pb_field_t *field, void **arg) {
    std::string* str = (std::string*)*arg;
    
    // Выделение буфера
    size_t size = stream->bytes_left;
    char* buf = new char[size];
    
    if (!pb_read(stream, (pb_byte_t*)buf, size)) {
        delete[] buf;
        return false;
    }
    
    str->assign(buf, size);
    delete[] buf;
    return true;
}

int main() {
    uint8_t buffer[256];
    size_t message_length;
    
    std::string name = "NanoPB";
    std::string description = "Protocol Buffers for embedded systems";
    
    // --- КОДИРОВАНИЕ ---
    example_StringMessage message = example_StringMessage_init_zero;
    
    message.name.funcs.encode = string_encode_callback;
    message.name.arg = &name;
    message.description.funcs.encode = string_encode_callback;
    message.description.arg = &description;
    
    pb_ostream_t ostream = pb_ostream_from_buffer(buffer, sizeof(buffer));
    
    if (!pb_encode(&ostream, example_StringMessage_fields, &message)) {
        printf("Encoding failed: %s\n", PB_GET_ERROR(&ostream));
        return 1;
    }
    
    message_length = ostream.bytes_written;
    printf("Encoded %zu bytes\n", message_length);
    
    // --- ДЕКОДИРОВАНИЕ ---
    example_StringMessage decoded = example_StringMessage_init_zero;
    std::string decoded_name, decoded_description;
    
    decoded.name.funcs.decode = string_decode_callback;
    decoded.name.arg = &decoded_name;
    decoded.description.funcs.decode = string_decode_callback;
    decoded.description.arg = &decoded_description;
    
    pb_istream_t istream = pb_istream_from_buffer(buffer, message_length);
    
    if (!pb_decode(&istream, example_StringMessage_fields, &decoded)) {
        printf("Decoding failed: %s\n", PB_GET_ERROR(&istream));
        return 1;
    }
    
    printf("Decoded values:\n");
    printf("  name: %s\n", decoded_name.c_str());
    printf("  description: %s\n", decoded_description.c_str());
    
    return 0;
}

Ключевые моменты

  • Буферы фиксированного размера: Используйте max_size в файле .options для простого статического выделения памяти
  • На основе обратных вызовов: Используйте callback в .options для динамической обработки строк
  • Фиксированный размер: Используйте strncpy для копирования строк, обеспечьте нуль-терминирование
  • На основе обратных вызовов: Реализуйте обратные вызовы кодирования/декодирования для динамического выделения памяти
  • Всегда проверяйте размеры буферов для предотвращения переполнения
  • Подход с обратными вызовами позволяет использовать строки любого размера (в пределах ограничений памяти)

Когда использовать какой подход

  • Буферы фиксированного размера: Когда вы знаете максимальные размеры строк и хотите простой код
  • На основе обратных вызовов: Когда размеры строк переменные или вам нужно динамическое выделение памяти

Ожидаемый вывод

strings_expected_output.txt
Encoded 38 bytes
Encoded data: 0a 06 4e 61 6e 6f 50 42 12 1e 50 72 6f 74 6f 63 6f 6c 20 42 75 66 66 65 72 73 20 66 6f 72 20 65 6d 62 65 64 64 65 64 20 73 79 73 74 65 6d 73 
Decoded values:
  name: NanoPB
  description: Protocol Buffers for embedded systems

Другие посты о NanoPB

Check out similar posts by category: Embedded C/C++ Protocol Buffers