DSMEPlatform.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 <stdlib.h>
 
#include <string>
#include "random.h"
 
#include "byteorder.h"
#include "dsmeAdaptionLayer/DSMEAdaptionLayer.h"
#include "dsmeLayer/DSMELayer.h"
#include "helper/DSMEDelegate.h"
#include "interfaces/IDSMEPlatform.h"
#include "mac_services/dataStructures/IEEE802154MacAddress.h"
#include "mac_services/mcps_sap/MCPS_SAP.h"
#include "mac_services/mlme_sap/MLME_SAP.h"
#include "mac_services/pib/MAC_PIB.h"
#include "mac_services/pib/PHY_PIB.h"
#include "mac_services/pib/dsme_phy_constants.h"
#include "mac_services/DSME_Common.h"
#include "net/gnrc/netif.h"
#include "net/ieee802154/radio.h"
#include "opendsme/dsme_settings.h"
#include "opendsme/DSMEMessage.h"
#include "ztimer.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
namespace dsme {
 
struct DSMESettings;
class DSMELayer;
class DSMEAdaptionLayer;

class DSMEPlatform : public IDSMEPlatform {
public:
    DSMEPlatform();
    ~DSMEPlatform();

    static DSMEPlatform* instance;

    void initialize(bool pan_coord);

    void sendFrame(uint16_t addr, iolist_t *pkt);

    void start();

    DSMELayer& getDSME() {
        return dsme;
    }

    bool isAssociated();
 
#if IS_ACTIVE(CONFIG_IEEE802154_DSME_STATIC_GTS) || DOXYGEN
    void allocateGTS(uint8_t superframeID, uint8_t slotID, uint8_t channelID,
                     Direction direction, uint16_t address);
#endif

    void getShortAddress(network_uint16_t *addr);

    void setGTSTransmission(bool gts);

    void setAckReq(bool ackReq);

    void offloadCCAEvent();

    void offloadTXDoneEvent();

    void indicateRxStart();

    void offloadRXDoneEvent();

    void offloadACKTimer();

    void offloadTimerEvent();

    void setPlatformState(uint8_t state) {
        this->state = state;
    }

    void processCCAEvent();

    void processTXDoneEvent();

    void processRxDone();

    void processRxOffload();

    void setGNRCNetif(gnrc_netif_t *netif) {
        this->netif = netif;
    }

    enum {
        STATE_READY = 0, STATE_CCA_WAIT = 1, STATE_SEND = 2,
    };
 
    /*********** IDSMEPlatform implementation ***********/

    uint8_t getChannelNumber() override;

    bool setChannelNumber(uint8_t k) override;

    bool sendNow() override;

    bool prepareSendingCopy(IDSMEMessage* msg, Delegate<void(bool)> txEndCallback) override;

    bool prepareSendingCopy(DSMEMessage* msg, Delegate<void(bool)> txEndCallback);

    void abortPreparedTransmission() override;

    bool sendDelayedAck(IDSMEMessage *ackMsg, IDSMEMessage *receivedMsg,
                        Delegate<void(bool)> txEndCallback) override;
    bool sendDelayedAck(DSMEMessage *ackMsg, DSMEMessage *receivedMsg,
                        Delegate<void(bool)> txEndCallback);

    void setReceiveDelegate(receive_delegate_t receiveDelegate) override;

    bool isReceptionFromAckLayerPossible() override;

    void handleReceivedMessageFromAckLayer(IDSMEMessage* message) override;

    void handleReceivedMessageFromAckLayer(DSMEMessage* message);

    DSMEMessage* getEmptyMessage() override;

    void releaseMessage(IDSMEMessage* msg) override;

    void releaseMessage(DSMEMessage* msg);

    bool startCCA() override;

    void startTimer(uint32_t symbolCounterValue) override;

    uint32_t getSymbolCounter() override;

    uint16_t getRandom() override {
        return (random_uint32() % UINT16_MAX);
    }

    void updateVisual() override;

    void scheduleStartOfCFP() override;

    uint8_t getMinCoordinatorLQI() override{
        return CONFIG_IEEE802154_DSME_MIN_COORD_LQI;
    };

    void turnTransceiverOn() override;

    void turnTransceiverOff() override;

    IEEE802154MacAddress& getAddress() {
        return this->mac_pib.macExtendedAddress;
    }

    void signalAckedTransmissionResult(bool success, uint8_t transmissionAttempts,
                                       IEEE802154MacAddress receiver) override;

    void signalGTSChange(bool deallocation, IEEE802154MacAddress counterpart,
                         uint16_t superframeID, uint8_t gtSlotID, uint8_t channel,
                         Direction direction) override;

    void signalQueueLength(uint32_t length) override;

    void signalPacketsPerCAP(uint32_t packets) override;

    void signalFailedPacketsPerCAP(uint32_t packets) override;

    bool isRxEnabledOnCap() override;
 
protected:
    DSMEPlatform(const DSMEPlatform&);
    DSMEPlatform& operator=(const DSMEPlatform&);

    Delegate<void(bool)> txEndCallback;

    void signalNewMsg(DSMEMessage* msg);

    virtual void signalReleasedMsg(DSMEMessage* msg) {}

    void handleDataMessageFromMCPSWrapper(IDSMEMessage* msg);

    void handleDataMessageFromMCPS(DSMEMessage* msg);

    void handleConfirmFromMCPSWrapper(IDSMEMessage* msg, DataStatus::Data_Status dataStatus);

    void handleConfirmFromMCPS(DSMEMessage* msg, DataStatus::Data_Status dataStatus);

    void translateMacAddress(uint16_t& from, IEEE802154MacAddress& to);

    event_queue_t *getEventQueue() {
        return &this->netif->evq[GNRC_NETIF_EVQ_INDEX_PRIO_LOW];
    }

    PHY_PIB phy_pib;

    MAC_PIB mac_pib;

    DSMELayer dsme;

    mcps_sap::MCPS_SAP mcps_sap;

    mlme_sap::MLME_SAP mlme_sap;

    DSMEAdaptionLayer dsmeAdaptionLayer;

    bool initialized;

    bool scanOrSyncInProgress{false};

    bool associationInProgress{false};

    bool syncActive{false};

    bool rx_on_cap{true};

    receive_delegate_t receiveFromAckLayerDelegate;

    gnrc_netif_t *netif;

    ztimer_t timer;

    IDSMEMessage *message;

    GTSScheduling* scheduling = nullptr;

    uint32_t rx_sfd;

    ztimer_t acktimer;

    uint8_t state;

    bool wait_for_ack;

    bool pending_tx;

    ieee802154_dev_t *radio;
};
 
}
 
#ifdef __cplusplus
}
#endif