databank.c

Go to the documentation of this file.

/**
 * @file databank.c
 * @brief Static packet pool implementation.
 */
 
#include "spp/services/databank/databank.h"
#include "spp/core/returnTypes.h"
#include "spp/core/commonbit.h"
#include "spp/core/packet.h"
#include "spp/hal/time/time.h"
#include "spp/util/crc.h"
 
#include <string.h>
#include <stddef.h>
 
/* ----------------------------------------------------------------
 * Private state
 * ---------------------------------------------------------------- */
 
/** @brief Static storage for all packets. */
static SPP_Packet_t s_packets[K_SPP_DATABANK_SIZE];
 
/** @brief Control structure (free-list stack). */
static SPP_Databank_t s_databank;
 
/** @brief Tracks whether the pool has been initialised. */
static spp_bool_t s_initialized = false;
 
/* ----------------------------------------------------------------
 * Public API
 * ---------------------------------------------------------------- */
 
SPP_RetVal_t SPP_SERVICES_DATABANK_init(void)
{
    if (s_initialized)
    {
        return K_SPP_ERROR_ALREADY_INITIALIZED;
    }
 
    memset(s_packets, 0, sizeof(s_packets));
    s_databank.freeCount = 0U;
 
    for (spp_uint32_t i = 0U; i < K_SPP_DATABANK_SIZE; i++)
    {
        s_databank.p_freePackets[i] = &s_packets[K_SPP_DATABANK_SIZE - 1U - i];
        s_databank.freeCount++;
    }
 
    s_initialized = true;
    return K_SPP_OK;
}
 
SPP_Packet_t *SPP_SERVICES_DATABANK_getPacket(void)
{
    if (!s_initialized || (s_databank.freeCount == 0U))
    {
        return NULL;
    }
 
    s_databank.freeCount--;
    return s_databank.p_freePackets[s_databank.freeCount];
}
 
SPP_RetVal_t SPP_SERVICES_DATABANK_returnPacket(SPP_Packet_t *p_packet)
{
    if (p_packet == NULL)
    {
        return K_SPP_ERROR_NULL_POINTER;
    }
 
    /* Validate that the pointer belongs to the static pool. */
    if ((p_packet < &s_packets[0]) || (p_packet > &s_packets[K_SPP_DATABANK_SIZE - 1U]))
    {
        return K_SPP_ERROR;
    }
 
    /* Guard against double-return. */
    for (spp_uint32_t i = 0U; i < s_databank.freeCount; i++)
    {
        if (s_databank.p_freePackets[i] == p_packet)
        {
            return K_SPP_ERROR_ALREADY_INITIALIZED; /* Already in free list. */
        }
    }
 
    if (s_databank.freeCount >= K_SPP_DATABANK_SIZE)
    {
        return K_SPP_ERROR; /* Pool is already full — should not happen. */
    }
 
    s_databank.p_freePackets[s_databank.freeCount] = p_packet;
    s_databank.freeCount++;
    return K_SPP_OK;
}
 
spp_uint32_t SPP_SERVICES_DATABANK_freeCount(void)
{
    return s_databank.freeCount;
}
 
/* ----------------------------------------------------------------
 * Private helpers
 * ---------------------------------------------------------------- */
 
static spp_uint16_t packetCrc(const SPP_Packet_t *p_packet)
{
    /* CRC covers all bytes up to (but not including) the crc field.
     * The packet is zeroed before filling, so padding bytes are 0
     * and contribute deterministically to the checksum. */
    return SPP_UTIL_crc16((const spp_uint8_t *)p_packet, (spp_uint32_t)offsetof(SPP_Packet_t, crc));
}
 
/* ----------------------------------------------------------------
 * Packet fill helper
 * ---------------------------------------------------------------- */
 
SPP_RetVal_t SPP_SERVICES_DATABANK_packetData(SPP_Packet_t *p_packet, spp_uint16_t apid, spp_uint16_t seq,
                                              const void *p_data, spp_uint16_t dataLen)
{
    if ((p_packet == NULL) || (p_data == NULL))
    {
        return K_SPP_ERROR_NULL_POINTER;
    }
    if (dataLen > K_SPP_PKT_PAYLOAD_MAX)
    {
        return K_SPP_ERROR_INVALID_PARAMETER;
    }
 
    /* Zero the whole struct so padding bytes are deterministic. */
    memset(p_packet, 0xFF, sizeof(SPP_Packet_t));
 
    p_packet->primaryHeader.version = K_SPP_PKT_VERSION;
    p_packet->primaryHeader.apid = apid;
    p_packet->primaryHeader.seq = seq;
    p_packet->primaryHeader.payloadLen = dataLen;
 
    p_packet->secondaryHeader.timestampMs = SPP_HAL_TIME_getTimeMs();
    p_packet->secondaryHeader.dropCounter = 0U;
 
    memcpy(p_packet->payload, p_data, dataLen);
 
    p_packet->crc = packetCrc(p_packet);
 
    return K_SPP_OK;
}