mDotEvent.h

00001 #ifndef MDOT_EVENT_H
00002 #define MDOT_EVENT_H
00003 
00004 #include "mbed.h"
00005 #include "mDot.h"
00006 #include "MacEvents.h"
00007 #include "MTSLog.h"
00008 #include "MTSText.h"
00009 
00010 typedef union {
00011         uint8_t Value;
00012         struct {
00013                 uint8_t :1;
00014                 uint8_t Tx :1;
00015                 uint8_t Rx :1;
00016                 uint8_t RxData :1;
00017                 uint8_t RxSlot :2;
00018                 uint8_t LinkCheck :1;
00019                 uint8_t JoinAccept :1;
00020         } Bits;
00021 } LoRaMacEventFlags;
00022 
00023 typedef enum {
00024     LORAMAC_EVENT_INFO_STATUS_OK = 0,
00025     LORAMAC_EVENT_INFO_STATUS_ERROR,
00026     LORAMAC_EVENT_INFO_STATUS_TX_TIMEOUT,
00027     LORAMAC_EVENT_INFO_STATUS_RX_TIMEOUT,
00028     LORAMAC_EVENT_INFO_STATUS_RX_ERROR,
00029     LORAMAC_EVENT_INFO_STATUS_JOIN_FAIL,
00030     LORAMAC_EVENT_INFO_STATUS_DOWNLINK_FAIL,
00031     LORAMAC_EVENT_INFO_STATUS_ADDRESS_FAIL,
00032     LORAMAC_EVENT_INFO_STATUS_MIC_FAIL,
00033 } LoRaMacEventInfoStatus;
00034 
00035 /*!
00036  * LoRaMAC event information
00037  */
00038 typedef struct {
00039         LoRaMacEventInfoStatus Status;
00040         lora::DownlinkControl Ctrl;
00041         bool TxAckReceived;
00042         bool DuplicateRx;
00043         uint8_t TxNbRetries;
00044         uint8_t TxDatarate;
00045         uint8_t RxPort;
00046         uint8_t *RxBuffer;
00047         uint8_t RxBufferSize;
00048         int16_t RxRssi;
00049         uint8_t RxSnr;
00050         uint16_t Energy;
00051         uint8_t DemodMargin;
00052         uint8_t NbGateways;
00053 } LoRaMacEventInfo ;
00054 
00055 class mDotEvent: public lora::MacEvents {
00056     public:
00057 
00058         mDotEvent()
00059         :
00060           LinkCheckAnsReceived(false),
00061           DemodMargin(0),
00062           NbGateways(0),
00063           PacketReceived(false),
00064           RxPort(0),
00065           RxPayloadSize(0),
00066           PongReceived(false),
00067           PongRssi(0),
00068           PongSnr(0),
00069           AckReceived(false),
00070           DuplicateRx(false),
00071           TxNbRetries(0),
00072           _sleep_cb(NULL)
00073         {
00074             memset(&_flags, 0, sizeof(LoRaMacEventFlags));
00075             memset(&_info, 0, sizeof(LoRaMacEventInfo ));
00076         }
00077 
00078         virtual ~mDotEvent() {
00079         }
00080 
00081         virtual void MacEvent(LoRaMacEventFlags *flags, LoRaMacEventInfo  *info) {
00082             if (mts::MTSLog::getLogLevel() == mts::MTSLog::TRACE_LEVEL) {
00083                 std::string msg = "OK";
00084                 switch (info->Status) {
00085                     case LORAMAC_EVENT_INFO_STATUS_ERROR:
00086                         msg = "ERROR";
00087                         break;
00088                     case LORAMAC_EVENT_INFO_STATUS_TX_TIMEOUT:
00089                         msg = "TX_TIMEOUT";
00090                         break;
00091                     case LORAMAC_EVENT_INFO_STATUS_RX_TIMEOUT:
00092                         msg = "RX_TIMEOUT";
00093                         break;
00094                     case LORAMAC_EVENT_INFO_STATUS_RX_ERROR:
00095                         msg = "RX_ERROR";
00096                         break;
00097                     case LORAMAC_EVENT_INFO_STATUS_JOIN_FAIL:
00098                         msg = "JOIN_FAIL";
00099                         break;
00100                     case LORAMAC_EVENT_INFO_STATUS_DOWNLINK_FAIL:
00101                         msg = "DOWNLINK_FAIL";
00102                         break;
00103                     case LORAMAC_EVENT_INFO_STATUS_ADDRESS_FAIL:
00104                         msg = "ADDRESS_FAIL";
00105                         break;
00106                     case LORAMAC_EVENT_INFO_STATUS_MIC_FAIL:
00107                         msg = "MIC_FAIL";
00108                         break;
00109                     default:
00110                         break;
00111                 }
00112                 logTrace("Event: %s", msg.c_str());
00113 
00114                 logTrace("Flags Tx: %d Rx: %d RxData: %d RxSlot: %d LinkCheck: %d JoinAccept: %d",
00115                          flags->Bits.Tx, flags->Bits.Rx, flags->Bits.RxData, flags->Bits.RxSlot, flags->Bits.LinkCheck, flags->Bits.JoinAccept);
00116                 logTrace("Info: Status: %d ACK: %d Retries: %d TxDR: %d RxPort: %d RxSize: %d RSSI: %d SNR: %d Energy: %d Margin: %d Gateways: %d",
00117                          info->Status, info->TxAckReceived, info->TxNbRetries, info->TxDatarate, info->RxPort, info->RxBufferSize,
00118                          info->RxRssi, info->RxSnr, info->Energy, info->DemodMargin, info->NbGateways);
00119             }
00120         }
00121 
00122         virtual void TxStart() {
00123             logDebug("mDotEvent - TxStart");
00124 
00125             // Fire auto sleep cfg event if enabled
00126             if (_sleep_cb)
00127                 _sleep_cb(mDot::AUTO_SLEEP_EVT_CFG);
00128         }
00129 
00130         virtual void TxDone(uint8_t dr) {
00131             RxPayloadSize = 0;
00132             LinkCheckAnsReceived = false;
00133             PacketReceived = false;
00134             AckReceived = false;
00135             DuplicateRx = false;
00136             PongReceived = false;
00137             TxNbRetries = 0;
00138 
00139             logDebug("mDotEvent - TxDone");
00140             memset(&_flags, 0, sizeof(LoRaMacEventFlags));
00141             memset(&_info, 0, sizeof(LoRaMacEventInfo ));
00142 
00143             _flags.Bits.Tx = 1;
00144             _info.TxDatarate = dr;
00145             _info.Status = LORAMAC_EVENT_INFO_STATUS_OK;
00146             Notify();
00147 
00148             // If configured, we can sleep until the rx window opens
00149             if (_sleep_cb)
00150                 _sleep_cb(mDot::AUTO_SLEEP_EVT_TXDONE);
00151         }
00152 
00153         void Notify() {
00154             MacEvent(&_flags, &_info);
00155         }
00156 
00157         virtual void TxTimeout(void) {
00158             logDebug("mDotEvent - TxTimeout");
00159 
00160             _flags.Bits.Tx = 1;
00161             _info.Status = LORAMAC_EVENT_INFO_STATUS_TX_TIMEOUT;
00162             Notify();
00163         }
00164 
00165         virtual void JoinAccept(uint8_t *payload, uint16_t size, int16_t rssi, int8_t snr) {
00166             logDebug("mDotEvent - JoinAccept");
00167 
00168             _flags.Bits.Tx = 0;
00169             _flags.Bits.JoinAccept = 1;
00170             _info.Status = LORAMAC_EVENT_INFO_STATUS_OK;
00171             Notify();
00172 
00173             if (_sleep_cb)
00174                 _sleep_cb(mDot::AUTO_SLEEP_EVT_CLEANUP);
00175         }
00176 
00177         virtual void JoinFailed(uint8_t *payload, uint16_t size, int16_t rssi, int8_t snr) {
00178             logDebug("mDotEvent - JoinFailed");
00179 
00180             _flags.Bits.Tx = 0;
00181             _flags.Bits.JoinAccept = 1;
00182             _info.Status = LORAMAC_EVENT_INFO_STATUS_JOIN_FAIL;
00183             Notify();
00184 
00185             if (_sleep_cb)
00186                 _sleep_cb(mDot::AUTO_SLEEP_EVT_CLEANUP);
00187         }
00188 
00189         virtual void MissedAck(uint8_t retries) {
00190             logDebug("mDotEvent - MissedAck : retries %u", retries);
00191             TxNbRetries = retries;
00192             _info.TxNbRetries = retries;
00193         }
00194 
00195         virtual void PacketRx(uint8_t port, uint8_t *payload, uint16_t size, int16_t rssi, int8_t snr, lora::DownlinkControl ctrl, uint8_t slot, uint8_t retries, uint32_t address, bool dupRx) {
00196             logDebug("mDotEvent - PacketRx ADDR: %08x", address);
00197             RxPort = port;
00198             PacketReceived = true;
00199 
00200             memcpy(RxPayload, payload, size);
00201             RxPayloadSize = size;
00202 
00203             if (ctrl.Bits.Ack) {
00204                 AckReceived = true;
00205             }
00206 
00207             DuplicateRx = dupRx;
00208 
00209             if (mts::MTSLog::getLogLevel() == mts::MTSLog::TRACE_LEVEL) {
00210                 std::string packet = mts::Text::bin2hexString(RxPayload, size);
00211                 logTrace("Payload: %s", packet.c_str());
00212             }
00213 
00214             _flags.Bits.Tx = 0;
00215             _flags.Bits.Rx = 1;
00216             _flags.Bits.RxData = size > 0;
00217             _flags.Bits.RxSlot = slot;
00218             _info.RxBuffer = payload;
00219             _info.RxBufferSize = size;
00220             _info.RxPort = port;
00221             _info.RxRssi = rssi;
00222             _info.RxSnr = snr;
00223             _info.TxAckReceived = AckReceived;
00224             _info.DuplicateRx = DuplicateRx;
00225             _info.TxNbRetries = retries;
00226             _info.Status = LORAMAC_EVENT_INFO_STATUS_OK;
00227             Notify();
00228         }
00229 
00230         virtual void RxDone(uint8_t *payload, uint16_t size, int16_t rssi, int8_t snr, lora::DownlinkControl ctrl, uint8_t slot) {
00231             logDebug("mDotEvent - RxDone");
00232 
00233             if (_sleep_cb)
00234                 _sleep_cb(mDot::AUTO_SLEEP_EVT_CLEANUP);
00235         }
00236 
00237         virtual void Pong(int16_t m_rssi, int8_t m_snr, int16_t s_rssi, int8_t s_snr) {
00238             logDebug("mDotEvent - Pong");
00239             PongReceived = true;
00240             PongRssi = s_rssi;
00241             PongSnr = s_snr;
00242         }
00243 
00244         virtual void NetworkLinkCheck(int16_t m_rssi, int8_t m_snr, int8_t s_snr, uint8_t s_gateways) {
00245             logDebug("mDotEvent - NetworkLinkCheck");
00246             LinkCheckAnsReceived = true;
00247             DemodMargin = s_snr;
00248             NbGateways = s_gateways;
00249 
00250             _flags.Bits.Tx = 0;
00251             _flags.Bits.LinkCheck = 1;
00252             _info.RxRssi = m_rssi;
00253             _info.RxSnr = m_snr;
00254             _info.DemodMargin = s_snr;
00255             _info.NbGateways = s_gateways;
00256             _info.Status = LORAMAC_EVENT_INFO_STATUS_OK;
00257             Notify();
00258         }
00259 
00260         virtual void RxTimeout(uint8_t slot) {
00261             logDebug("mDotEvent - RxTimeout on Slot %d", slot);
00262 
00263             _flags.Bits.Tx = 0;
00264             _flags.Bits.RxSlot = slot;
00265             _info.Status = LORAMAC_EVENT_INFO_STATUS_RX_TIMEOUT;
00266             Notify();
00267 
00268             if (_sleep_cb) {
00269                 // If this is the first rx window we can sleep until the next one
00270                 if (slot == 1)
00271                     _sleep_cb(mDot::AUTO_SLEEP_EVT_RX1_TIMEOUT);
00272                 else
00273                     _sleep_cb(mDot::AUTO_SLEEP_EVT_CLEANUP);
00274             }
00275         }
00276 
00277         virtual void RxError(uint8_t slot) {
00278             logDebug("mDotEvent - RxError");
00279 
00280             memset(&_flags, 0, sizeof(LoRaMacEventFlags));
00281             memset(&_info, 0, sizeof(LoRaMacEventInfo ));
00282 
00283             _flags.Bits.RxSlot = slot;
00284             _info.Status = LORAMAC_EVENT_INFO_STATUS_RX_ERROR;
00285             Notify();
00286 
00287             if (_sleep_cb)
00288                 _sleep_cb(mDot::AUTO_SLEEP_EVT_CLEANUP);
00289         }
00290 
00291         virtual uint8_t MeasureBattery(void) {
00292             return 255;
00293         }
00294 
00295         void AttachSleepCallback(Callback<void(mDot::AutoSleepEvent_t)> cb) {
00296             _sleep_cb = cb;
00297         }
00298 
00299         void DetachSleepCallback() {
00300             _sleep_cb = NULL;
00301         }
00302 
00303         bool LinkCheckAnsReceived;
00304         uint8_t DemodMargin;
00305         uint8_t NbGateways;
00306 
00307         bool PacketReceived;
00308         uint8_t RxPort;
00309         uint8_t RxPayload[255];
00310         uint8_t RxPayloadSize;
00311 
00312         bool PongReceived;
00313         int16_t PongRssi;
00314         int16_t PongSnr;
00315 
00316         bool AckReceived;
00317         bool DuplicateRx;
00318         uint8_t TxNbRetries;
00319 
00320         LoRaMacEventFlags& Flags() {
00321             return _flags;
00322         }
00323         LoRaMacEventInfo & Info() {
00324             return _info;
00325         }
00326 
00327     private:
00328         /* Hook to inject a sleep method in between receive windows */
00329         Callback<void(mDot::AutoSleepEvent_t)> _sleep_cb;
00330 
00331         LoRaMacEventFlags _flags;
00332         LoRaMacEventInfo  _info;
00333 
00334 //
00335 //        /*!
00336 //         * MAC layer event callback prototype.
00337 //         *
00338 //         * \param [IN] flags Bit field indicating the MAC events occurred
00339 //         * \param [IN] info  Details about MAC events occurred
00340 //         */
00341 //        virtual void MacEvent(LoRaMacEventFlags *flags, LoRaMacEventInfo *info) {
00342 //            logDebug("mDotEvent");
00343 //
00344 //            if (flags->Bits.Rx) {
00345 //                logDebug("Rx");
00346 //
00347 //                // Event Object must delete RxBuffer
00348 //                delete[] info->RxBuffer;
00349 //            }
00350 //        }
00351 //
00352 
00353 };
00354 
00355 #endif // __MDOT_EVENT_H__