lorawan-mac-command.h

Go to the documentation of this file.

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2017 University of Padova
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation;
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * Author: Davide Magrin <magrinda@dei.unipd.it>
 *
 * Modified by: Bastien Tauran <bastien.tauran@viveris.fr>
 */
 
#ifndef LORAWAN_MAC_COMMAND_H
#define LORAWAN_MAC_COMMAND_H
 
#include <ns3/buffer.h>
#include <ns3/nstime.h>
#include <ns3/object.h>
 
namespace ns3
{
 
enum MacCommandType
{
    INVALID,
    LINK_CHECK_REQ,
    LINK_CHECK_ANS,
    LINK_ADR_REQ,
    LINK_ADR_ANS,
    DUTY_CYCLE_REQ,
    DUTY_CYCLE_ANS,
    RX_PARAM_SETUP_REQ,
    RX_PARAM_SETUP_ANS,
    DEV_STATUS_REQ,
    DEV_STATUS_ANS,
    NEW_CHANNEL_REQ,
    NEW_CHANNEL_ANS,
    RX_TIMING_SETUP_REQ,
    RX_TIMING_SETUP_ANS,
    TX_PARAM_SETUP_REQ,
    TX_PARAM_SETUP_ANS,
    DL_CHANNEL_REQ,
    DL_CHANNEL_ANS
};
 
class LorawanMacCommand : public Object
{
  public:
    static TypeId GetTypeId(void);
 
    LorawanMacCommand();
    virtual ~LorawanMacCommand();
 
    virtual void Serialize(Buffer::Iterator& start) const = 0;
 
    virtual uint8_t Deserialize(Buffer::Iterator& start) = 0;
 
    virtual void Print(std::ostream& os) const = 0;
 
    virtual uint8_t GetSerializedSize(void) const;
 
    virtual enum MacCommandType GetCommandType(void) const;
 
    static uint8_t GetCIDFromLorawanMacCommand(enum MacCommandType commandType);
 
  protected:
    enum MacCommandType m_commandType;
 
    uint8_t m_serializedSize;
};
 
class LinkCheckReq : public LorawanMacCommand
{
  public:
    LinkCheckReq();
    ~LinkCheckReq();
    virtual void Serialize(Buffer::Iterator& start) const;
    virtual uint8_t Deserialize(Buffer::Iterator& start);
    virtual void Print(std::ostream& os) const;
};
 
class LinkCheckAns : public LorawanMacCommand
{
  public:
    LinkCheckAns();
    LinkCheckAns(uint8_t margin, uint8_t gwCnt);
 
    virtual void Serialize(Buffer::Iterator& start) const;
    virtual uint8_t Deserialize(Buffer::Iterator& start);
    virtual void Print(std::ostream& os) const;
 
    void SetMargin(uint8_t margin);
 
    uint8_t GetMargin(void) const;
 
    void SetGwCnt(uint8_t gwCnt);
 
    uint8_t GetGwCnt(void) const;
 
    void IncrementGwCnt(void);
 
  private:
    uint8_t m_margin;
 
    uint8_t m_gwCnt;
};
 
class LinkAdrReq : public LorawanMacCommand
{
  public:
    LinkAdrReq();
 
    LinkAdrReq(uint8_t dataRate,
               uint8_t txPower,
               uint16_t channelMask,
               uint8_t chMaskCntl,
               uint8_t nbRep);
 
    virtual void Serialize(Buffer::Iterator& start) const;
    virtual uint8_t Deserialize(Buffer::Iterator& start);
    virtual void Print(std::ostream& os) const;
 
    uint8_t GetDataRate(void);
 
    uint8_t GetTxPower(void);
 
    std::list<int> GetEnabledChannelsList(void);
 
    int GetRepetitions(void);
 
  private:
    uint8_t m_dataRate;
    uint8_t m_txPower;
    uint16_t m_channelMask;
    uint8_t m_chMaskCntl;
    uint8_t m_nbRep;
};
 
class LinkAdrAns : public LorawanMacCommand
{
  public:
    LinkAdrAns();
 
    LinkAdrAns(bool powerAck, bool dataRateAck, bool channelMaskAck);
 
    virtual void Serialize(Buffer::Iterator& start) const;
    virtual uint8_t Deserialize(Buffer::Iterator& start);
    virtual void Print(std::ostream& os) const;
 
  private:
    bool m_powerAck;
    bool m_dataRateAck;
    bool m_channelMaskAck;
};
 
class DutyCycleReq : public LorawanMacCommand
{
  public:
    DutyCycleReq();
    DutyCycleReq(uint8_t dutyCycle);
 
    virtual void Serialize(Buffer::Iterator& start) const;
    virtual uint8_t Deserialize(Buffer::Iterator& start);
    virtual void Print(std::ostream& os) const;
 
    double GetMaximumAllowedDutyCycle(void) const;
 
  private:
    uint8_t m_maxDCycle;
};
 
class DutyCycleAns : public LorawanMacCommand
{
  public:
    DutyCycleAns();
 
    virtual void Serialize(Buffer::Iterator& start) const;
    virtual uint8_t Deserialize(Buffer::Iterator& start);
    virtual void Print(std::ostream& os) const;
};
 
class RxParamSetupReq : public LorawanMacCommand
{
  public:
    RxParamSetupReq();
 
    RxParamSetupReq(uint8_t rx1DrOffset, uint8_t rx2DataRate, double frequency);
 
    virtual void Serialize(Buffer::Iterator& start) const;
    virtual uint8_t Deserialize(Buffer::Iterator& start);
    virtual void Print(std::ostream& os) const;
 
    uint8_t GetRx1DrOffset(void);
 
    uint8_t GetRx2DataRate(void);
 
    double GetFrequency(void);
 
  private:
    uint8_t m_rx1DrOffset;
    uint8_t m_rx2DataRate;
    double m_frequency; 
};
 
class RxParamSetupAns : public LorawanMacCommand
{
  public:
    RxParamSetupAns();
    RxParamSetupAns(bool rx1DrOffsetAck, bool rx2DataRateAck, bool channelAck);
 
    virtual void Serialize(Buffer::Iterator& start) const;
    virtual uint8_t Deserialize(Buffer::Iterator& start);
    virtual void Print(std::ostream& os) const;
 
  private:
    bool m_rx1DrOffsetAck;
    bool m_rx2DataRateAck;
    bool m_channelAck;
};
 
class DevStatusReq : public LorawanMacCommand
{
  public:
    DevStatusReq();
 
    virtual void Serialize(Buffer::Iterator& start) const;
    virtual uint8_t Deserialize(Buffer::Iterator& start);
    virtual void Print(std::ostream& os) const;
};
 
class DevStatusAns : public LorawanMacCommand
{
  public:
    DevStatusAns();
    DevStatusAns(uint8_t battery, uint8_t margin);
 
    virtual void Serialize(Buffer::Iterator& start) const;
    virtual uint8_t Deserialize(Buffer::Iterator& start);
    virtual void Print(std::ostream& os) const;
 
    uint8_t GetBattery(void);
 
    uint8_t GetMargin(void);
 
  private:
    uint8_t m_battery;
    uint8_t m_margin;
};
 
class NewChannelReq : public LorawanMacCommand
{
  public:
    NewChannelReq();
 
    NewChannelReq(uint8_t chIndex, double frequency, uint8_t minDataRate, uint8_t maxDataRate);
 
    virtual void Serialize(Buffer::Iterator& start) const;
    virtual uint8_t Deserialize(Buffer::Iterator& start);
    virtual void Print(std::ostream& os) const;
 
    uint8_t GetChannelIndex(void);
    double GetFrequency(void);
    uint8_t GetMinDataRate(void);
    uint8_t GetMaxDataRate(void);
 
  private:
    uint8_t m_chIndex;
    double m_frequency;
    uint8_t m_minDataRate;
    uint8_t m_maxDataRate;
};
 
class NewChannelAns : public LorawanMacCommand
{
  public:
    NewChannelAns();
 
    NewChannelAns(bool dataRateRangeOk, bool channelFrequencyOk);
 
    virtual void Serialize(Buffer::Iterator& start) const;
    virtual uint8_t Deserialize(Buffer::Iterator& start);
    virtual void Print(std::ostream& os) const;
 
  private:
    bool m_dataRateRangeOk;
    bool m_channelFrequencyOk;
};
 
class RxTimingSetupReq : public LorawanMacCommand
{
  public:
    RxTimingSetupReq();
 
    RxTimingSetupReq(uint8_t delay);
 
    virtual void Serialize(Buffer::Iterator& start) const;
    virtual uint8_t Deserialize(Buffer::Iterator& start);
    virtual void Print(std::ostream& os) const;
 
    Time GetDelay(void);
 
  private:
    uint8_t m_delay;
};
 
class RxTimingSetupAns : public LorawanMacCommand
{
  public:
    RxTimingSetupAns();
 
    virtual void Serialize(Buffer::Iterator& start) const;
    virtual uint8_t Deserialize(Buffer::Iterator& start);
    virtual void Print(std::ostream& os) const;
 
  private:
};
 
class TxParamSetupAns : public LorawanMacCommand
{
  public:
    TxParamSetupAns();
 
    virtual void Serialize(Buffer::Iterator& start) const;
    virtual uint8_t Deserialize(Buffer::Iterator& start);
    virtual void Print(std::ostream& os) const;
 
  private:
};
 
class TxParamSetupReq : public LorawanMacCommand
{
  public:
    TxParamSetupReq();
 
    virtual void Serialize(Buffer::Iterator& start) const;
    virtual uint8_t Deserialize(Buffer::Iterator& start);
    virtual void Print(std::ostream& os) const;
 
  private:
};
 
class DlChannelAns : public LorawanMacCommand
{
  public:
    DlChannelAns();
 
    virtual void Serialize(Buffer::Iterator& start) const;
    virtual uint8_t Deserialize(Buffer::Iterator& start);
    virtual void Print(std::ostream& os) const;
 
  private:
};
 
} // namespace ns3
 
#endif /* LORAWAN_MAC_COMMAND_H */