DSMEMessage.h

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2022 HAW Hamburg
 * SPDX-License-Identifier: LGPL-2.1-only
 */
 
#pragma once

 
#include <stdint.h>
#include <string.h>
 
#include "dsmeLayer/messages/IEEE802154eMACHeader.h"
#include "interfaces/IDSMEMessage.h"
#include "iolist.h"
#include "mac_services/dataStructures/DSMEMessageElement.h"
#include "net/gnrc/pktbuf.h"
#include "opendsme/dsme_settings.h"
#include "opendsme/dsme_platform.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
namespace dsme {

class DSMEPlatform;

class DSMEMessage : public IDSMEMessage {
public:
    /************* IDSMEMessage implementation *************/

    void prependFrom(DSMEMessageElement *msg) override;

    void decapsulateTo(DSMEMessageElement *msg) override;

    void copyTo(DSMEMessageElement *msg);

    bool hasPayload() override
    {
        return this->pkt != NULL && this->pkt->size > 0;
    }

    uint32_t getStartOfFrameDelimiterSymbolCounter() override
    {
        return startOfFrameDelimiterSymbolCounter;
    }

    void setStartOfFrameDelimiterSymbolCounter(uint32_t symbolCounter) override
    {
        startOfFrameDelimiterSymbolCounter = symbolCounter;
    }

    uint16_t getTotalSymbols() override
    {
        DSME_ASSERT(pkt);
        /* Hardcoded to O-QPSK */
        uint16_t bytes = macHdr.getSerializationLength()
                         + pkt->size
                         + 2        /* FCS */
                         + 4        /* Preamble */
                         + 1        /* SFD */
                         + 1;       /* PHY Header */
 
        return bytes * 2;           /* 4 bit per symbol */
    }

    uint8_t getMPDUSymbols() override;

    IEEE802154eMACHeader& getHeader() override
    {
        return macHdr;
    }

    uint8_t getLQI() override
    {
        return messageLQI;
    }

    bool getReceivedViaMCPS() override
    {
        return receivedViaMCPS;
    }

    void setReceivedViaMCPS(bool receivedViaMCPS) override
    {
        this->receivedViaMCPS = receivedViaMCPS;
    }

    bool getCurrentlySending() override
    {
        return currentlySending;
    }

    void setCurrentlySending(bool currentlySending) override
    {
        this->currentlySending = currentlySending;
    }

    void increaseRetryCounter() override
    {
        this->retryCounter++;
    }

    uint8_t getRetryCounter() override
    {
        return this->retryCounter;
    }

    uint8_t getPayloadLength()
    {
        DSME_ASSERT(pkt);
        return pkt->size;
    }

    int8_t getRSSI() override
    {
        return this->messageRSSI;
    }

    int loadBuffer(size_t len);

    int loadBuffer(iolist_t *pkt);

    uint8_t *getPayload()
    {
        DSME_ASSERT(pkt);
        return (uint8_t *)pkt->data;
    }

    int dropHdr(size_t len);

    void releaseMessage();

    void dispatchMessage();

    iolist_t *getIolPayload();

    void clearMessage();

    bool firstTry;

    bool free;
private:
    DSMEMessage() :
        messageRSSI(0),
        messageLQI(0),
        receivedViaMCPS(false),
        currentlySending(false),
        retryCounter(0)
    {}

    ~DSMEMessage()
    {}

    void prepare()
    {
        currentlySending = false;
        firstTry = true;
        receivedViaMCPS = false;
        retryCounter = 0;
 
        macHdr.reset();
    }

    IEEE802154eMACHeader macHdr;

    uint8_t messageRSSI;

    uint8_t messageLQI;

    gnrc_pktsnip_t *pkt;

    uint32_t startOfFrameDelimiterSymbolCounter;

    bool receivedViaMCPS;

    bool currentlySending;

    uint8_t retryCounter;

    gnrc_netif_t *netif;
 
/* declare related classes as friends */
friend class DSMEPlatform;
friend class DSMEMessageElement;
friend class DSMEPlatformBase;
friend class DSMEMessageBuffer;
};
 
}
 
#ifdef __cplusplus
}
#endif