NanoPB: Como lidar com tipos bytes em C

Veja também: Versão C++: Como lidar com tipos bytes em C++

NanoPB é uma implementação de Protocol Buffers otimizada em tamanho de código para sistemas embarcados. Este post mostra como lidar com tipos bytes em C com NanoPB.

Definição Proto

Primeiro, crie um arquivo .proto com campos 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;
}

Gerar código NanoPB

Gere o código NanoPB com um arquivo .options para especificar os tamanhos dos buffers de bytes:

Crie 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

Então gere:

generate_nanopb_bytes.sh

protoc --nanopb_out=. bytes.proto

protoc --nanopb_out=. bytes.proto

Isso irá gerar bytes.pb.h e bytes.pb.c.

Exemplo em C com buffers de tamanho fixo

Aqui está um exemplo completo em C usando buffers de tamanho fixo:

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() {
    // Buffer para mensagem codificada
    uint8_t buffer[256];
    size_t message_length;
    
    // --- CODIFICAÇÃO ---
    example_BytesMessage message = example_BytesMessage_init_zero;
    
    // Definir dados 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));
    
    // Criar stream para codificação
    pb_ostream_t ostream = pb_ostream_from_buffer(buffer, sizeof(buffer));
    
    // Codificar a mensagem
    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);
    
    // Imprimir hex dump dos dados codificados
    printf("Encoded data: ");
    for (size_t i = 0; i < message_length; i++) {
        printf("%02x ", buffer[i]);
    }
    printf("\n");
    
    // --- DECODIFICAÇÃO ---
    example_BytesMessage decoded = example_BytesMessage_init_zero;
    
    // Criar stream para decodificação
    pb_istream_t istream = pb_istream_from_buffer(buffer, message_length);
    
    // Decodificar a mensagem
    if (!pb_decode(&istream, example_BytesMessage_fields, &decoded)) {
        printf("Decoding failed: %s\n", PB_GET_ERROR(&istream));
        return 1;
    }
    
    // Imprimir valores decodificados
    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() {
    // Buffer para mensagem codificada
    uint8_t buffer[256];
    size_t message_length;
    
    // --- CODIFICAÇÃO ---
    example_BytesMessage message = example_BytesMessage_init_zero;
    
    // Definir dados 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));
    
    // Criar stream para codificação
    pb_ostream_t ostream = pb_ostream_from_buffer(buffer, sizeof(buffer));
    
    // Codificar a mensagem
    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);
    
    // Imprimir hex dump dos dados codificados
    printf("Encoded data: ");
    for (size_t i = 0; i < message_length; i++) {
        printf("%02x ", buffer[i]);
    }
    printf("\n");
    
    // --- DECODIFICAÇÃO ---
    example_BytesMessage decoded = example_BytesMessage_init_zero;
    
    // Criar stream para decodificação
    pb_istream_t istream = pb_istream_from_buffer(buffer, message_length);
    
    // Decodificar a mensagem
    if (!pb_decode(&istream, example_BytesMessage_fields, &decoded)) {
        printf("Decoding failed: %s\n", PB_GET_ERROR(&istream));
        return 1;
    }
    
    // Imprimir valores decodificados
    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;
}

Comando de compilação

Compile o exemplo com nanopb. NanoPB é tipicamente usado incluindo os arquivos fonte diretamente no seu projeto:

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.

Nota: Os arquivos fonte do NanoPB (pb_common.c, pb_encode.c, pb_decode.c) precisam ser compilados diretamente com seu projeto. Você pode obtê-los no repositório GitHub do NanoPB.

Script de teste em Python

Para verificar a codificação, você pode usar a biblioteca protobuf do Python:

test_bytes.py

import bytes_pb2

# Ler os dados binários
with open('encoded.bin', 'rb') as f:
    data = f.read()

# Decodificar
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

# Ler os dados binários
with open('encoded.bin', 'rb') as f:
    data = f.read()

# Decodificar
msg = bytes_pb2.BytesMessage()
msg.ParseFromString(data)

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

Primeiro, compile as definições protobuf do Python:

compile_python_bytes.sh

protoc --python_out=. bytes.proto

protoc --python_out=. bytes.proto

Então modifique o exemplo em C para salvar os dados codificados em um arquivo:

save_encoded_bytes.c

// Após a codificação, adicione isto:
FILE *f = fopen("encoded.bin", "wb");
fwrite(buffer, 1, message_length, f);
fclose(f);

// Após a codificação, adicione isto:
FILE *f = fopen("encoded.bin", "wb");
fwrite(buffer, 1, message_length, f);
fclose(f);

Alternativa: Bytes baseados em callback

Para manipulação dinâmica de bytes, você pode usar callbacks. Crie bytes_callback.options:

bytes_callback.options

# Usar callback para bytes dinâmicos
msg.BytesMessage.data callback
msg.BytesMessage.signature callback

# Usar callback para bytes dinâmicos
msg.BytesMessage.data callback
msg.BytesMessage.signature callback

Então regenere e use esta abordagem:

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;

// Callback de codificação para 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);
}

// Callback de decodificação para bytes
bool bytes_decode_callback(pb_istream_t *stream, const pb_field_t *field, void **arg) {
    dynamic_bytes_t* bytes = (dynamic_bytes_t*)*arg;
    
    // Alocar buffer
    size_t size = stream->bytes_left;
    bytes->data = (uint8_t*)malloc(size);
    
    if (!bytes->data) {
        return false;
    }
    
    bytes->size = size;
    
    // Ler dados para o buffer
    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)};
    
    // --- CODIFICAÇÃO ---
    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);
    
    // --- DECODIFICAÇÃO ---
    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");
    
    // Liberar memória alocada
    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;

// Callback de codificação para 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);
}

// Callback de decodificação para bytes
bool bytes_decode_callback(pb_istream_t *stream, const pb_field_t *field, void **arg) {
    dynamic_bytes_t* bytes = (dynamic_bytes_t*)*arg;
    
    // Alocar buffer
    size_t size = stream->bytes_left;
    bytes->data = (uint8_t*)malloc(size);
    
    if (!bytes->data) {
        return false;
    }
    
    bytes->size = size;
    
    // Ler dados para o buffer
    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)};
    
    // --- CODIFICAÇÃO ---
    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);
    
    // --- DECODIFICAÇÃO ---
    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");
    
    // Liberar memória alocada
    free(decoded_data.data);
    free(decoded_signature.data);
    
    return 0;
}

Pontos principais

Buffers de tamanho fixo: Use max_size no arquivo .options para alocação estática simples
Baseado em callback: Use callback no .options para manipulação dinâmica de bytes
Tamanho fixo: Defina o campo *_size e use memcpy para copiar bytes
Baseado em callback: Implemente callbacks de codificação/decodificação com gerenciamento manual de memória
Bytes são similares a strings, mas contêm dados binários brutos (sem terminação nula)
Use malloc/free em C para manipulação dinâmica de bytes
Sempre verifique os tamanhos dos buffers para evitar overflow
Lembre-se de liberar a memória alocada na abordagem baseada em callback

Quando usar qual abordagem

Buffers de tamanho fixo: Quando você sabe o tamanho máximo dos bytes e quer código simples
Baseado em callback: Quando o tamanho dos bytes é variável ou você precisa de alocação dinâmica de memória

Saída esperada

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

Diferenças do C++

A versão em C é quase idêntica à versão em C++, com diferenças principais:

Use malloc/free em vez de std::vector para bytes dinâmicos
Gerenciamento manual de memória necessário (sem destrutores)
Use struct para o wrapper de bytes dinâmicos em vez de std::vector
Lembre-se de liberar a memória alocada após o uso
Sem gerenciamento automático de memória em C

Casos de uso para bytes

Dados binários (imagens, áudio, etc.)
Assinaturas criptográficas
Dados brutos de sensores
Protocolos binários personalizados
Quaisquer dados que não devem ser interpretados como texto

Mais posts sobre 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