Muchos protocolos de comunicación, tanto en red como fuera de ella, comparten una estructura común que incluye campos como tipo, longitud, verificación, datos de longitud variable y un marcador de fin. Protocolos más complejos pueden presentar múltiples capas de TLV (Type-Length-Value), TLV anidados, y señales de transición de estado. Para manejar estas estructuras eficiantemente en programación, se emplean ciertas técnicas.

Estructuras de Datos

Estructuras y Uniones

El uso de estructuras y uniones permite mapear directamente estructuras de datos complejas a la memoria. Para aseguarr que la memoria se alinee exactamente con la estructura definida, se pueden usar atributos específicos del compilador.

// Macro para asegurar alineación de estructura empaquetada
#if defined(__GNUC__)
#define PACKED_STRUCT struct __attribute__((packed))
#endif

Considere la siguiente definición:

#include <stdint.h> // Para tipos como uint8_t

PACKED_STRUCT ProtocolMessage {
    uint8_t startMarker;
    uint8_t messageType;
    uint16_t payloadLength;
    PACKED_STRUCT InnerData { // Ejemplo de TLV anidado
        uint8_t subType;
        uint16_t subLength;
        uint8_t data[1]; // Placeholder para datos variables
    } inner;
    uint8_t endMarker;
};

typedef union {
    PACKED_STRUCT ProtocolMessage msg;
    uint8_t rawBytes[1]; // Acceso a los datos como bytes crudos
} MessageBuffer;

MessageBuffer buffer;

Esta configuración permite:

• Accceso Directo a Campos: Escribir datos es tan simple como acceder a los miembros de la estructura, por ejemplo: buffer.msg.messageType = 0x89;.
• Acceso a Datos Crudos: Se puede obtener la representación binaria completa del mensaje accediendo a buffer.rawBytes y manipulando bytes individuales. Esto es útil para la transmisión o el almacenamiento. Por ejemplo, para imprimir los bytes en formato hexadecimal: printf("%02X ", buffer.rawBytes[i]);.

Para la depuración y las pruebas unitarias, es recomendable implementar un bucle de lectura/escritura para verificar la integridad de los datos antes de integrarlos en la lógica principal de la aplicación.

Campos de Bits (Bitfields)

Los campos de bits permiten definir miembros de estructura que ocupan solo una cantidad específica de bits, lo cual es muy útil para protocolos con campos de control de tamaño reducido.

// Asegura que el compilador no optimice la estructura, preservando el tamaño de los campos
struct __attribute__((packed)) ControlFlags {
    uint8_t enableBit:      1; // 1 bit
    uint8_t mode:           3; // 3 bits
    uint8_t status:         4; // 4 bits
    // uint32_t dataField[]; // Campo de datos variable puede seguir
};

En este ejemplo, mode solo utiliza 3 bits de memoria. Al usar campos de bits dentro de una estructura empaquetada, el acceso a estos campos puede realizarse directamente en memoria, eliminando la necesidad de operaciones bitwise manuales durante la serialización y deserialización.

Serialización es el proceso de convertir una estructura de datos u objeto en un formato que pueda ser transmitido o almacenado y luego reconstruido. La deserialización es el proceso inverso.

Tipado Uniforme

Utilice el archivo de cabecera estándar C99 <stdint.h> para tipos de datos de ancho fijo como uint8_t, uint16_t, y uint32_t. Estos tipos son compatibles con la mayoría de los compiladores C99, incluyendo aquellos para microcontroladores, evitando la necesidad de definir tipos personalizados como u8 o UINT32.

Consideraciones de Orden de Bytes

Es crucial tener en cuenta el orden de bytes (endianness) de la arquitectura de la CPU. Las siguientes macros pueden ayudar a realizar conversiones:

// Macros para convertir entre orden de bytes Big-Endian y Little-Endian
#define SWAP_BYTES_16(x) ((uint16_t)((((x) & 0xFF00) >> 8) | (((x) & 0x00FF) << 8)))
#define SWAP_BYTES_32(x) ((uint32_t)((((x) & 0xFF000000) >> 24) | (((x) & 0x00FF0000) >>  8) | (((x) & 0x0000FF00) <<  8) | (((x) & 0x000000FF) << 24))))

// Ejemplo de uso para convertir un valor de red (Big-Endian) a host (Little-Endian)
// uint16_t network_value = ...;
// uint16_t host_value = SWAP_BYTES_16(network_value);

Arreglos Flexibles (C99)

Los arreglos flexibles son una característica de C99 que permite definir estructuras con un miembro de arreglo de tamaño variable al final. Esto es útil para manejar datos de longitud no especificada en mensajes de protocolo.

Dado que un arreglo flexible debe ser el último miembro de la estructura, si el protocolo incluye un marcador de fin de trama que no forma parte del bloque de datos principal, generalmente no se incluye en la estructura y se maneja explícitamente en las funciones de procesamiento.

La copia de datos de mensajes para transmisión se realiza comúnmente usando memcpy: memcpy(destination, source, size);.

Máquinas de Estado

Para protocolos complejos con transiciones de estado, es muy recomendable dibujar un diagrama de máquina de estados. Esto facilita el análisis, la comprensión y la modificación del flujo del protocolo.

Ejemplo de Referencia

Se puede encontrar una implementación de ejemplo para el protocolo de transporte de medios de Intel, que incluye subcategorías del protocolo RTP, en el siguiente repositorio de GitHub:

• Media-Transport-Library
• Archivo específico: rx_st22p_app.c

Configuración de Estructuras Compiladas

El atributo __attribute__((packed)) (específico de GCC y Clang) instruye al compilador para que elimine las optimizaciones de alineación de estructura, haciendo que la estructura ocupe memoria exactamente según lo definido, byte por byte. Otros compiladores pueden tener atributos similares.