NanoPB: Cómo manejar tipos bytes en C

Ver también: Versión en C++: Cómo manejar tipos bytes en 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 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 en C con búferes de tamaño fijo

Aquí tienes un ejemplo completo en C usando búferes de tamaño fijo:

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() {
    // Búfer para el mensaje codificado
    uint8_t buffer[256];
    size_t message_length;
    
    // --- CODIFICACIÓN ---
    example_BytesMessage message = example_BytesMessage_init_zero;
    
    // Establecer datos 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 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() {
    // Búfer para el mensaje codificado
    uint8_t buffer[256];
    size_t message_length;
    
    // --- CODIFICACIÓN ---
    example_BytesMessage message = example_BytesMessage_init_zero;
    
    // Establecer datos 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 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 normalmente incluyendo los archivos fuente directamente en tu proyecto:

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: Los archivos fuente de NanoPB (pb_common.c, pb_encode.c, pb_decode.c) deben compilarse directamente con tu proyecto. Puedes obtenerlos del repositorio de GitHub de NanoPB.

Script de prueba en Python

Para verificar la codificación, puedes usar la librería 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 en C para guardar los datos codificados en un archivo:

save_encoded_bytes.c

// 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 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.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 codificación 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 decodificación 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;
    
    // Asignar búfer
    size_t size = stream->bytes_left;
    bytes->data = (uint8_t*)malloc(size);
    
    if (!bytes->data) {
        return false;
    }
    
    bytes->size = size;
    
    // Leer datos al búfer
    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)};
    
    // --- 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;
    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 memoria asignada
    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 codificación 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 decodificación 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;
    
    // Asignar búfer
    size_t size = stream->bytes_left;
    bytes->data = (uint8_t*)malloc(size);
    
    if (!bytes->data) {
        return false;
    }
    
    bytes->size = size;
    
    // Leer datos al búfer
    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)};
    
    // --- 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;
    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 memoria asignada
    free(decoded_data.data);
    free(decoded_signature.data);
    
    return 0;
}

Puntos clave

Búferes de tamaño fijo: Usa max_size en el archivo .options para asignación estática simple
Basado en callbacks: Usa callback en .options para 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 con gestión manual de memoria
Los bytes son similares a las cadenas pero contienen datos binarios sin procesar (sin terminación nula)
Usa malloc/free en C para manejo dinámico de bytes
Comprueba siempre los tamaños de búfer para evitar desbordamientos
Recuerda liberar la memoria asignada en el enfoque basado en callbacks

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

Diferencias respecto a C++

La versión en C es casi idéntica a la versión en C++, con diferencias clave:

Usa malloc/free en lugar de std::vector para bytes dinámicos
Se requiere gestión manual de memoria (sin destructores)
Usa struct para el envoltorio de bytes dinámicos en lugar de std::vector
Recuerda liberar la memoria asignada después de su uso
Sin gestión automática de memoria en C

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