DSMEMessage.h

Go to the documentation of this file.

/*
 * Copyright (C) 2022 HAW Hamburg
 *
 * This file is subject to the terms and conditions of the GNU Lesser
 * General Public License v2.1. See the file LICENSE in the top level
 * directory for more details.
 */
 
#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