DSMEPlatform.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 <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