NanoPB: Cómo manejar tipos bytes en C++

Ver también: C version: How to handle bytes types in C

NanoPB es una implementación de Protocol Buffers optimizada para el tamaño de código en sistemas embebidos. Esta entrada muestra cómo manejar tipos bytes en C++ con NanoPB.

Definición Proto

Primero, crea un archivo .proto con campos de tipo 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;
}

Generar código NanoPB

Genera el código NanoPB con un archivo .options para especificar los tamaños de los búferes de bytes:

Crea 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

Luego genera:

generate_nanopb_bytes.sh

protoc --nanopb_out=. bytes.proto

protoc --nanopb_out=. bytes.proto

Esto generará bytes.pb.h y bytes.pb.c.

Ejemplo de C++ con búferes de tamaño fijo

Aquí hay un ejemplo completo de C++ que usa búferes de tamaño fijo:

bytes_example.cpp

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

int main() {
    // Búfer para el mensaje codificado
    uint8_t buffer[256];
    size_t message_length;
    
    // --- CODIFICACIÓN ---
    example_BytesMessage message = example_BytesMessage_init_zero;
    
    // Establecer los datos de 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));
    
    // Crear flujo para codificación
    pb_ostream_t ostream = pb_ostream_from_buffer(buffer, sizeof(buffer));
    
    // Codificar el mensaje
    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 volcado hexadecimal de los datos codificados
    printf("Encoded data: ");
    for (size_t i = 0; i < message_length; i++) {
        printf("%02x ", buffer[i]);
    }
    printf("\n");
    
    // --- DECODIFICACIÓN ---
    example_BytesMessage decoded = example_BytesMessage_init_zero;
    
    // Crear flujo para decodificación
    pb_istream_t istream = pb_istream_from_buffer(buffer, message_length);
    
    // Decodificar el mensaje
    if (!pb_decode(&istream, example_BytesMessage_fields, &decoded)) {
        printf("Decoding failed: %s\n", PB_GET_ERROR(&istream));
        return 1;
    }
    
    // Imprimir los 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 <string.h>
#include "bytes.pb.h"
#include "pb_encode.h"
#include "pb_decode.h"

int main() {
    // Búfer para el mensaje codificado
    uint8_t buffer[256];
    size_t message_length;
    
    // --- CODIFICACIÓN ---
    example_BytesMessage message = example_BytesMessage_init_zero;
    
    // Establecer los datos de 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));
    
    // Crear flujo para codificación
    pb_ostream_t ostream = pb_ostream_from_buffer(buffer, sizeof(buffer));
    
    // Codificar el mensaje
    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 volcado hexadecimal de los datos codificados
    printf("Encoded data: ");
    for (size_t i = 0; i < message_length; i++) {
        printf("%02x ", buffer[i]);
    }
    printf("\n");
    
    // --- DECODIFICACIÓN ---
    example_BytesMessage decoded = example_BytesMessage_init_zero;
    
    // Crear flujo para decodificación
    pb_istream_t istream = pb_istream_from_buffer(buffer, message_length);
    
    // Decodificar el mensaje
    if (!pb_decode(&istream, example_BytesMessage_fields, &decoded)) {
        printf("Decoding failed: %s\n", PB_GET_ERROR(&istream));
        return 1;
    }
    
    // Imprimir los 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 compilación

Compila el ejemplo con nanopb. NanoPB se usa típicamente incluyendo los archivos fuente directamente en tu proyecto:

compile_bytes_example.sh

g++ -o bytes_example bytes_example.cpp bytes.pb.c pb_common.c pb_encode.c pb_decode.c -I.

g++ -o bytes_example bytes_example.cpp bytes.pb.c pb_common.c pb_encode.c pb_decode.c -I.

Nota: Los archivos fuente de NanoPB (pb_common.c, pb_encode.c, pb_decode.c) deben compilarse directamente con tu proyecto. Puedes obtenerlos del repositorio GitHub de NanoPB.

Script de prueba en Python

Para verificar la codificación, puedes usar la biblioteca protobuf de Python:

test_bytes.py

import bytes_pb2

# Leer los datos binarios
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

# Leer los datos binarios
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()}")

Primero, compila las definiciones protobuf de Python:

compile_python_bytes.sh

protoc --python_out=. bytes.proto

protoc --python_out=. bytes.proto

Luego modifica el ejemplo de C++ para guardar los datos codificados en un archivo:

save_encoded_bytes.cpp

// Después de codificar, añade esto:
FILE *f = fopen("encoded.bin", "wb");
fwrite(buffer, 1, message_length, f);
fclose(f);

// Después de codificar, añade esto:
FILE *f = fopen("encoded.bin", "wb");
fwrite(buffer, 1, message_length, f);
fclose(f);

Alternativa: Bytes basados en callbacks

Para el manejo dinámico de bytes, puedes usar callbacks. Crea 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

Luego regenera y usa este enfoque:

bytes_callback_example.cpp

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

// Callback de codificación para bytes
bool bytes_encode_callback(pb_ostream_t *stream, const pb_field_t *field, void * const *arg) {
    const std::vector<uint8_t>* data = (const std::vector<uint8_t>*)*arg;
    
    if (!pb_encode_tag_for_field(stream, field))
        return false;
    
    return pb_encode_string(stream, data->data(), data->size());
}

// Callback de decodificación para bytes
bool bytes_decode_callback(pb_istream_t *stream, const pb_field_t *field, void **arg) {
    std::vector<uint8_t>* data = (std::vector<uint8_t>*)*arg;
    
    // Redimensionar el vector para contener los datos
    size_t size = stream->bytes_left;
    data->resize(size);
    
    // Leer los datos en el vector
    return pb_read(stream, data->data(), size);
}

int main() {
    uint8_t buffer[256];
    size_t message_length;
    
    std::vector<uint8_t> data = {0x01, 0x02, 0x03, 0x04, 0x05};
    std::vector<uint8_t> signature = {0xAA, 0xBB, 0xCC, 0xDD};
    
    // --- CODIFICACIÓN ---
    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);
    
    // --- DECODIFICACIÓN ---
    example_BytesMessage decoded = example_BytesMessage_init_zero;
    std::vector<uint8_t> decoded_data, decoded_signature;
    
    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 (uint8_t byte : decoded_data) {
        printf("%02x ", byte);
    }
    printf("\n");
    printf("  signature: ");
    for (uint8_t byte : decoded_signature) {
        printf("%02x ", byte);
    }
    printf("\n");
    
    return 0;
}

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

// Callback de codificación para bytes
bool bytes_encode_callback(pb_ostream_t *stream, const pb_field_t *field, void * const *arg) {
    const std::vector<uint8_t>* data = (const std::vector<uint8_t>*)*arg;
    
    if (!pb_encode_tag_for_field(stream, field))
        return false;
    
    return pb_encode_string(stream, data->data(), data->size());
}

// Callback de decodificación para bytes
bool bytes_decode_callback(pb_istream_t *stream, const pb_field_t *field, void **arg) {
    std::vector<uint8_t>* data = (std::vector<uint8_t>*)*arg;
    
    // Redimensionar el vector para contener los datos
    size_t size = stream->bytes_left;
    data->resize(size);
    
    // Leer los datos en el vector
    return pb_read(stream, data->data(), size);
}

int main() {
    uint8_t buffer[256];
    size_t message_length;
    
    std::vector<uint8_t> data = {0x01, 0x02, 0x03, 0x04, 0x05};
    std::vector<uint8_t> signature = {0xAA, 0xBB, 0xCC, 0xDD};
    
    // --- CODIFICACIÓN ---
    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);
    
    // --- DECODIFICACIÓN ---
    example_BytesMessage decoded = example_BytesMessage_init_zero;
    std::vector<uint8_t> decoded_data, decoded_signature;
    
    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 (uint8_t byte : decoded_data) {
        printf("%02x ", byte);
    }
    printf("\n");
    printf("  signature: ");
    for (uint8_t byte : decoded_signature) {
        printf("%02x ", byte);
    }
    printf("\n");
    
    return 0;
}

Puntos clave

Búferes de tamaño fijo: Usa max_size en el archivo .options para una asignación estática simple
Basado en callbacks: Usa callback en .options para el manejo dinámico de bytes
Tamaño fijo: Establece el campo *_size y usa memcpy para copiar los bytes
Basado en callbacks: Implementa callbacks de codificación/decodificación para asignación dinámica
Los bytes son similares a las cadenas pero contienen datos binarios sin procesar (sin terminación nula)
Usa std::vector<uint8_t> en C++ para el manejo dinámico de bytes
Siempre verifica los tamaños de los búferes para evitar desbordamientos

Cuándo usar cada enfoque

Búferes de tamaño fijo: Cuando conoces el tamaño máximo de los bytes y quieres código simple
Basado en callbacks: Cuando el tamaño de los bytes es variable o necesitas asignación dinámica de memoria

Salida 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

Casos de uso para bytes

Datos binarios (imágenes, audio, etc.)
Firmas criptográficas
Datos sin procesar de sensores
Protocolos binarios personalizados
Cualquier dato que no deba interpretarse como texto

Más entradas de NanoPB

Echa un vistazo a artículos similares por categoría: Embedded, C/C++, Protocol Buffers

Si este artículo te ha ayudado, considera invitarme a un café o hacer una donación vía PayPal para apoyar la investigación y publicación de nuevos artículos en TechOverflow

Buy me a coffee