NanoPB: Cómo manejar tipos de cadena en C

Ver también: C++ version: How to handle string 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 de cadena en C con NanoPB.

Definición Proto

Primero, crea un archivo .proto con campos de cadena:

strings.proto

syntax = "proto3";

package example;

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

syntax = "proto3";

package example;

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

Generar código NanoPB

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

Crea strings.options:

strings.options

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

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

Luego genera:

generate_nanopb_strings.sh

protoc --nanopb_out=. strings.proto

protoc --nanopb_out=. strings.proto

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

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

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

strings_example.c

#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include "strings.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_StringMessage message = example_StringMessage_init_zero;
    
    // Establecer valores de cadena (deben caber en el tamaño del búfer)
    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);
    
    // Crear flujo para codificación
    pb_ostream_t ostream = pb_ostream_from_buffer(buffer, sizeof(buffer));
    
    // Codificar el mensaje
    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);
    
    // 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_StringMessage decoded = example_StringMessage_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_StringMessage_fields, &decoded)) {
        printf("Decoding failed: %s\n", PB_GET_ERROR(&istream));
        return 1;
    }
    
    // Imprimir valores decodificados
    printf("Decoded values:\n");
    printf("  name: %s\n", decoded.name);
    printf("  description: %s\n", decoded.description);
    
    return 0;
}

#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include "strings.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_StringMessage message = example_StringMessage_init_zero;
    
    // Establecer valores de cadena (deben caber en el tamaño del búfer)
    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);
    
    // Crear flujo para codificación
    pb_ostream_t ostream = pb_ostream_from_buffer(buffer, sizeof(buffer));
    
    // Codificar el mensaje
    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);
    
    // 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_StringMessage decoded = example_StringMessage_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_StringMessage_fields, &decoded)) {
        printf("Decoding failed: %s\n", PB_GET_ERROR(&istream));
        return 1;
    }
    
    // Imprimir valores decodificados
    printf("Decoded values:\n");
    printf("  name: %s\n", decoded.name);
    printf("  description: %s\n", decoded.description);
    
    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_strings_example.sh

gcc -o strings_example strings_example.c strings.pb.c pb_common.c pb_encode.c pb_decode.c -I.

gcc -o strings_example strings_example.c strings.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) necesitan ser compilados 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_strings.py

import strings_pb2

# Leer los datos binarios
with open('encoded.bin', 'rb') as f:
    data = f.read()

# Decodificar
msg = strings_pb2.StringMessage()
msg.ParseFromString(data)

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

import strings_pb2

# Leer los datos binarios
with open('encoded.bin', 'rb') as f:
    data = f.read()

# Decodificar
msg = strings_pb2.StringMessage()
msg.ParseFromString(data)

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

Primero, compila las definiciones protobuf de Python:

compile_python_strings.sh

protoc --python_out=. strings.proto

protoc --python_out=. strings.proto

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

save_encoded_strings.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: Cadenas basadas en callbacks

Para el manejo dinámico de cadenas, puedes usar callbacks. Crea strings_callback.options:

strings_callback.options

# Usar callback para cadenas dinámicas
msg.StringMessage.name callback
msg.StringMessage.description callback

# Usar callback para cadenas dinámicas
msg.StringMessage.name callback
msg.StringMessage.description callback

Luego regenera y usa este enfoque:

strings_callback_example.c

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

typedef struct {
    char* data;
    size_t size;
} dynamic_string_t;

// Callback de codificación para cadenas
bool string_encode_callback(pb_ostream_t *stream, const pb_field_t *field, void * const *arg) {
    const dynamic_string_t* str = (const dynamic_string_t*)*arg;
    
    if (!pb_encode_tag_for_field(stream, field))
        return false;
    
    return pb_encode_string(stream, (const pb_byte_t*)str->data, str->size);
}

// Callback de decodificación para cadenas
bool string_decode_callback(pb_istream_t *stream, const pb_field_t *field, void **arg) {
    dynamic_string_t* str = (dynamic_string_t*)*arg;
    
    // Asignar búfer
    size_t size = stream->bytes_left;
    str->data = (char*)malloc(size + 1);
    
    if (!pb_read(stream, (pb_byte_t*)str->data, size)) {
        free(str->data);
        str->data = NULL;
        return false;
    }
    
    str->data[size] = '\0'; // Terminación nula
    str->size = size;
    return true;
}

int main() {
    uint8_t buffer[256];
    size_t message_length;
    
    dynamic_string_t name = {"NanoPB", 6};
    dynamic_string_t description = {"Protocol Buffers for embedded systems", 38};
    
    // --- CODIFICACIÓN ---
    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);
    
    // --- DECODIFICACIÓN ---
    example_StringMessage decoded = example_StringMessage_init_zero;
    dynamic_string_t decoded_name = {NULL, 0};
    dynamic_string_t decoded_description = {NULL, 0};
    
    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.data);
    printf("  description: %s\n", decoded_description.data);
    
    // Liberar memoria asignada
    free(decoded_name.data);
    free(decoded_description.data);
    
    return 0;
}

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

typedef struct {
    char* data;
    size_t size;
} dynamic_string_t;

// Callback de codificación para cadenas
bool string_encode_callback(pb_ostream_t *stream, const pb_field_t *field, void * const *arg) {
    const dynamic_string_t* str = (const dynamic_string_t*)*arg;
    
    if (!pb_encode_tag_for_field(stream, field))
        return false;
    
    return pb_encode_string(stream, (const pb_byte_t*)str->data, str->size);
}

// Callback de decodificación para cadenas
bool string_decode_callback(pb_istream_t *stream, const pb_field_t *field, void **arg) {
    dynamic_string_t* str = (dynamic_string_t*)*arg;
    
    // Asignar búfer
    size_t size = stream->bytes_left;
    str->data = (char*)malloc(size + 1);
    
    if (!pb_read(stream, (pb_byte_t*)str->data, size)) {
        free(str->data);
        str->data = NULL;
        return false;
    }
    
    str->data[size] = '\0'; // Terminación nula
    str->size = size;
    return true;
}

int main() {
    uint8_t buffer[256];
    size_t message_length;
    
    dynamic_string_t name = {"NanoPB", 6};
    dynamic_string_t description = {"Protocol Buffers for embedded systems", 38};
    
    // --- CODIFICACIÓN ---
    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);
    
    // --- DECODIFICACIÓN ---
    example_StringMessage decoded = example_StringMessage_init_zero;
    dynamic_string_t decoded_name = {NULL, 0};
    dynamic_string_t decoded_description = {NULL, 0};
    
    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.data);
    printf("  description: %s\n", decoded_description.data);
    
    // Liberar memoria asignada
    free(decoded_name.data);
    free(decoded_description.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 el manejo dinámico de cadenas
Tamaño fijo: Usa strncpy para copiar cadenas, asegúrate de la terminación nula
Basado en callbacks: Implementa callbacks de codificación/decodificación con gestión manual de memoria
Siempre verifica los tamaños de búfer para prevenir desbordamientos
Recuerda liberar la memoria asignada en el enfoque basado en callbacks
C requiere gestión manual de memoria (malloc/free) para cadenas dinámicas

Cuándo usar cada enfoque

Búferes de tamaño fijo: Cuando conoces los tamaños máximos de cadena y quieres código simple
Basado en callbacks: Cuando los tamaños de cadena son variables o necesitas asignación dinámica de memoria

Salida esperada

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

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

Diferencias con 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 new/delete para memoria dinámica
Se requiere gestión manual de memoria (sin destructores)
Usa struct para el contenedor de cadena dinámica en lugar de std::string
Recuerda terminar las cadenas con nulo manualmente cuando sea necesario

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