NanoPB: Как работать с типами bytes в C

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

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

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

bytes.proto

syntax = "proto3";

package example;

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

syntax = "proto3";

package example;

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

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

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

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

bytes.options

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

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

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

generate_nanopb_bytes.sh

protoc --nanopb_out=. bytes.proto

protoc --nanopb_out=. bytes.proto

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

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

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

bytes_example.c

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

int main() {
    // Буфер для закодированного сообщения
    uint8_t buffer[256];
    size_t message_length;
    
    // --- КОДИРОВАНИЕ ---
    example_BytesMessage message = example_BytesMessage_init_zero;
    
    // Установка данных bytes
    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));
    
    // Создание потока для кодирования
    pb_ostream_t ostream = pb_ostream_from_buffer(buffer, sizeof(buffer));
    
    // Кодирование сообщения
    if (!pb_encode(&ostream, example_BytesMessage_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_BytesMessage decoded = example_BytesMessage_init_zero;
    
    // Создание потока для декодирования
    pb_istream_t istream = pb_istream_from_buffer(buffer, message_length);
    
    // Декодирование сообщения
    if (!pb_decode(&istream, example_BytesMessage_fields, &decoded)) {
        printf("Decoding failed: %s\n", PB_GET_ERROR(&istream));
        return 1;
    }
    
    // Вывод декодированных значений
    printf("Decoded values:\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;
}

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

int main() {
    // Буфер для закодированного сообщения
    uint8_t buffer[256];
    size_t message_length;
    
    // --- КОДИРОВАНИЕ ---
    example_BytesMessage message = example_BytesMessage_init_zero;
    
    // Установка данных bytes
    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));
    
    // Создание потока для кодирования
    pb_ostream_t ostream = pb_ostream_from_buffer(buffer, sizeof(buffer));
    
    // Кодирование сообщения
    if (!pb_encode(&ostream, example_BytesMessage_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_BytesMessage decoded = example_BytesMessage_init_zero;
    
    // Создание потока для декодирования
    pb_istream_t istream = pb_istream_from_buffer(buffer, message_length);
    
    // Декодирование сообщения
    if (!pb_decode(&istream, example_BytesMessage_fields, &decoded)) {
        printf("Decoding failed: %s\n", PB_GET_ERROR(&istream));
        return 1;
    }
    
    // Вывод декодированных значений
    printf("Decoded values:\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;
}

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

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

compile_bytes_example.sh

gcc -o bytes_example bytes_example.c bytes.pb.c pb_common.c pb_encode.c pb_decode.c -I.

gcc -o bytes_example bytes_example.c bytes.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_bytes.py

import bytes_pb2

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

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

print("Python decoded values:")
print(f"  data: {msg.data.hex()}")
print(f"  signature: {msg.signature.hex()}")

import bytes_pb2

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

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

print("Python decoded values:")
print(f"  data: {msg.data.hex()}")
print(f"  signature: {msg.signature.hex()}")

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

compile_python_bytes.sh

protoc --python_out=. bytes.proto

protoc --python_out=. bytes.proto

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

save_encoded_bytes.c

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

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

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

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

bytes_callback.options

# Использовать обратный вызов для динамических bytes
msg.BytesMessage.data callback
msg.BytesMessage.signature callback

# Использовать обратный вызов для динамических bytes
msg.BytesMessage.data callback
msg.BytesMessage.signature callback

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

bytes_callback_example.c

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

typedef struct {
    uint8_t* data;
    size_t size;
} dynamic_bytes_t;

// Обратный вызов кодировщика для bytes
bool bytes_encode_callback(pb_ostream_t *stream, const pb_field_t *field, void * const *arg) {
    const dynamic_bytes_t* bytes = (const dynamic_bytes_t*)*arg;
    
    if (!pb_encode_tag_for_field(stream, field))
        return false;
    
    return pb_encode_string(stream, bytes->data, bytes->size);
}

// Обратный вызов декодировщика для bytes
bool bytes_decode_callback(pb_istream_t *stream, const pb_field_t *field, void **arg) {
    dynamic_bytes_t* bytes = (dynamic_bytes_t*)*arg;
    
    // Выделение буфера
    size_t size = stream->bytes_left;
    bytes->data = (uint8_t*)malloc(size);
    
    if (!bytes->data) {
        return false;
    }
    
    bytes->size = size;
    
    // Чтение данных в буфер
    if (!pb_read(stream, bytes->data, size)) {
        free(bytes->data);
        bytes->data = NULL;
        bytes->size = 0;
        return false;
    }
    
    return true;
}

int main() {
    uint8_t buffer[256];
    size_t message_length;
    
    uint8_t data_array[] = {0x01, 0x02, 0x03, 0x04, 0x05};
    uint8_t signature_array[] = {0xAA, 0xBB, 0xCC, 0xDD};
    
    dynamic_bytes_t data = {data_array, sizeof(data_array)};
    dynamic_bytes_t signature = {signature_array, sizeof(signature_array)};
    
    // --- КОДИРОВАНИЕ ---
    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("Encoding failed: %s\n", PB_GET_ERROR(&ostream));
        return 1;
    }
    
    message_length = ostream.bytes_written;
    printf("Encoded %zu bytes\n", message_length);
    
    // --- ДЕКОДИРОВАНИЕ ---
    example_BytesMessage decoded = example_BytesMessage_init_zero;
    dynamic_bytes_t decoded_data = {NULL, 0};
    dynamic_bytes_t decoded_signature = {NULL, 0};
    
    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("Decoding failed: %s\n", PB_GET_ERROR(&istream));
        return 1;
    }
    
    printf("Decoded values:\n");
    printf("  data: ");
    for (size_t i = 0; i < decoded_data.size; i++) {
        printf("%02x ", decoded_data.data[i]);
    }
    printf("\n");
    printf("  signature: ");
    for (size_t i = 0; i < decoded_signature.size; i++) {
        printf("%02x ", decoded_signature.data[i]);
    }
    printf("\n");
    
    // Освобождение выделенной памяти
    free(decoded_data.data);
    free(decoded_signature.data);
    
    return 0;
}

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

typedef struct {
    uint8_t* data;
    size_t size;
} dynamic_bytes_t;

// Обратный вызов кодировщика для bytes
bool bytes_encode_callback(pb_ostream_t *stream, const pb_field_t *field, void * const *arg) {
    const dynamic_bytes_t* bytes = (const dynamic_bytes_t*)*arg;
    
    if (!pb_encode_tag_for_field(stream, field))
        return false;
    
    return pb_encode_string(stream, bytes->data, bytes->size);
}

// Обратный вызов декодировщика для bytes
bool bytes_decode_callback(pb_istream_t *stream, const pb_field_t *field, void **arg) {
    dynamic_bytes_t* bytes = (dynamic_bytes_t*)*arg;
    
    // Выделение буфера
    size_t size = stream->bytes_left;
    bytes->data = (uint8_t*)malloc(size);
    
    if (!bytes->data) {
        return false;
    }
    
    bytes->size = size;
    
    // Чтение данных в буфер
    if (!pb_read(stream, bytes->data, size)) {
        free(bytes->data);
        bytes->data = NULL;
        bytes->size = 0;
        return false;
    }
    
    return true;
}

int main() {
    uint8_t buffer[256];
    size_t message_length;
    
    uint8_t data_array[] = {0x01, 0x02, 0x03, 0x04, 0x05};
    uint8_t signature_array[] = {0xAA, 0xBB, 0xCC, 0xDD};
    
    dynamic_bytes_t data = {data_array, sizeof(data_array)};
    dynamic_bytes_t signature = {signature_array, sizeof(signature_array)};
    
    // --- КОДИРОВАНИЕ ---
    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("Encoding failed: %s\n", PB_GET_ERROR(&ostream));
        return 1;
    }
    
    message_length = ostream.bytes_written;
    printf("Encoded %zu bytes\n", message_length);
    
    // --- ДЕКОДИРОВАНИЕ ---
    example_BytesMessage decoded = example_BytesMessage_init_zero;
    dynamic_bytes_t decoded_data = {NULL, 0};
    dynamic_bytes_t decoded_signature = {NULL, 0};
    
    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("Decoding failed: %s\n", PB_GET_ERROR(&istream));
        return 1;
    }
    
    printf("Decoded values:\n");
    printf("  data: ");
    for (size_t i = 0; i < decoded_data.size; i++) {
        printf("%02x ", decoded_data.data[i]);
    }
    printf("\n");
    printf("  signature: ");
    for (size_t i = 0; i < decoded_signature.size; i++) {
        printf("%02x ", decoded_signature.data[i]);
    }
    printf("\n");
    
    // Освобождение выделенной памяти
    free(decoded_data.data);
    free(decoded_signature.data);
    
    return 0;
}

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

Буферы фиксированного размера: Используйте max_size в файле .options для простого статического выделения
На основе обратных вызовов: Используйте callback в файле .options для динамической обработки bytes
Фиксированный размер: Установите поле *_size и используйте memcpy для копирования bytes
На основе обратных вызовов: Реализуйте обратные вызовы кодирования/декодирования с ручным управлением памятью
Bytes похожи на строки, но содержат сырые бинарные данные (без нуль-терминатора)
Используйте malloc/free в C для динамической обработки bytes
Всегда проверяйте размеры буферов для предотвращения переполнения
Не забывайте освобождать выделенную память в подходе на основе обратных вызовов

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

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

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

bytes_expected_output.txt

Encoded 14 bytes
Encoded data: 0a 05 01 02 03 04 05 12 04 aa bb cc dd 
Decoded values:
  data: 01 02 03 04 05 
  signature: aa bb cc dd 

Encoded 14 bytes
Encoded data: 0a 05 01 02 03 04 05 12 04 aa bb cc dd 
Decoded values:
  data: 01 02 03 04 05 
  signature: aa bb cc dd

Отличия от C++

Версия на C почти идентична версии на C++, с ключевыми отличиями:

Используйте malloc/free вместо std::vector для динамических bytes
Требуется ручное управление памятью (нет деструкторов)
Используйте структуру для обёртки динамических bytes вместо std::vector
Не забывайте освобождать выделенную память после использования
В C нет автоматического управления памятью

Варианты использования bytes

Бинарные данные (изображения, аудио и т. д.)
Криптографические подписи
Сырые данные датчиков
Пользовательские бинарные протоколы
Любые данные, которые не должны интерпретироваться как текст

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

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