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           BeaconLocked(false),
00067           PongReceived(false),
00068           PongRssi(0),
00069           PongSnr(0),
00070           ServerTimeReceived(false),
00071           ServerTimeSeconds(0U),
00072           AckReceived(false),
00073           DuplicateRx(false),
00074           TxNbRetries(0)
00075         {
00076             memset(&_flags, 0, sizeof(LoRaMacEventFlags));
00077             memset(&_info, 0, sizeof(LoRaMacEventInfo ));
00078         }
00079 
00080         virtual ~mDotEvent() {
00081         }
00082 
00083         virtual void MacEvent(LoRaMacEventFlags *flags, LoRaMacEventInfo  *info) {
00084             if (mts::MTSLog::getLogLevel() == mts::MTSLog::TRACE_LEVEL) {
00085                 std::string msg = "OK";
00086                 switch (info->Status) {
00087                     case LORAMAC_EVENT_INFO_STATUS_ERROR:
00088                         msg = "ERROR";
00089                         break;
00090                     case LORAMAC_EVENT_INFO_STATUS_TX_TIMEOUT:
00091                         msg = "TX_TIMEOUT";
00092                         break;
00093                     case LORAMAC_EVENT_INFO_STATUS_RX_TIMEOUT:
00094                         msg = "RX_TIMEOUT";
00095                         break;
00096                     case LORAMAC_EVENT_INFO_STATUS_RX_ERROR:
00097                         msg = "RX_ERROR";
00098                         break;
00099                     case LORAMAC_EVENT_INFO_STATUS_JOIN_FAIL:
00100                         msg = "JOIN_FAIL";
00101                         break;
00102                     case LORAMAC_EVENT_INFO_STATUS_DOWNLINK_FAIL:
00103                         msg = "DOWNLINK_FAIL";
00104                         break;
00105                     case LORAMAC_EVENT_INFO_STATUS_ADDRESS_FAIL:
00106                         msg = "ADDRESS_FAIL";
00107                         break;
00108                     case LORAMAC_EVENT_INFO_STATUS_MIC_FAIL:
00109                         msg = "MIC_FAIL";
00110                         break;
00111                     default:
00112                         break;
00113                 }
00114                 logTrace("Event: %s", msg.c_str());
00115 
00116                 logTrace("Flags Tx: %d Rx: %d RxData: %d RxSlot: %d LinkCheck: %d JoinAccept: %d",
00117                          flags->Bits.Tx, flags->Bits.Rx, flags->Bits.RxData, flags->Bits.RxSlot, flags->Bits.LinkCheck, flags->Bits.JoinAccept);
00118                 logTrace("Info: Status: %d ACK: %d Retries: %d TxDR: %d RxPort: %d RxSize: %d RSSI: %d SNR: %d Energy: %d Margin: %d Gateways: %d",
00119                          info->Status, info->TxAckReceived, info->TxNbRetries, info->TxDatarate, info->RxPort, info->RxBufferSize,
00120                          info->RxRssi, info->RxSnr, info->Energy, info->DemodMargin, info->NbGateways);
00121             }
00122         }
00123 
00124         virtual void TxStart() {
00125             logDebug("mDotEvent - TxStart");
00126         }
00127 
00128         virtual void TxDone(uint8_t dr) {
00129             RxPayloadSize = 0;
00130             LinkCheckAnsReceived = false;
00131             PacketReceived = false;
00132             AckReceived = false;
00133             DuplicateRx = false;
00134             PongReceived = false;
00135             TxNbRetries = 0;
00136 
00137             logDebug("mDotEvent - TxDone");
00138             memset(&_flags, 0, sizeof(LoRaMacEventFlags));
00139             memset(&_info, 0, sizeof(LoRaMacEventInfo ));
00140 
00141             _flags.Bits.Tx = 1;
00142             _info.TxDatarate = dr;
00143             _info.Status = LORAMAC_EVENT_INFO_STATUS_OK;
00144             Notify();
00145         }
00146 
00147         void Notify() {
00148             MacEvent(&_flags, &_info);
00149         }
00150 
00151         virtual void TxTimeout(void) {
00152             logDebug("mDotEvent - TxTimeout");
00153 
00154             _flags.Bits.Tx = 1;
00155             _info.Status = LORAMAC_EVENT_INFO_STATUS_TX_TIMEOUT;
00156             Notify();
00157         }
00158 
00159         virtual void JoinAccept(uint8_t *payload, uint16_t size, int16_t rssi, int8_t snr) {
00160             logDebug("mDotEvent - JoinAccept");
00161 
00162             _flags.Bits.Tx = 0;
00163             _flags.Bits.JoinAccept = 1;
00164             _info.Status = LORAMAC_EVENT_INFO_STATUS_OK;
00165             Notify();
00166         }
00167 
00168         virtual void JoinFailed(uint8_t *payload, uint16_t size, int16_t rssi, int8_t snr) {
00169             logDebug("mDotEvent - JoinFailed");
00170 
00171             _flags.Bits.Tx = 0;
00172             _flags.Bits.JoinAccept = 1;
00173             _info.Status = LORAMAC_EVENT_INFO_STATUS_JOIN_FAIL;
00174             Notify();
00175         }
00176 
00177         virtual void MissedAck(uint8_t retries) {
00178             logDebug("mDotEvent - MissedAck : retries %u", retries);
00179             TxNbRetries = retries;
00180             _info.TxNbRetries = retries;
00181         }
00182 
00183         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) {
00184             logDebug("mDotEvent - PacketRx ADDR: %08x", address);
00185             RxPort = port;
00186             PacketReceived = true;
00187 
00188             memcpy(RxPayload, payload, size);
00189             RxPayloadSize = size;
00190 
00191             if (ctrl.Bits.Ack) {
00192                 AckReceived = true;
00193             }
00194 
00195             DuplicateRx = dupRx;
00196 
00197             if (mts::MTSLog::getLogLevel() == mts::MTSLog::TRACE_LEVEL) {
00198                 std::string packet = mts::Text::bin2hexString(RxPayload, size);
00199                 logTrace("Payload: %s", packet.c_str());
00200             }
00201 
00202             _flags.Bits.Tx = 0;
00203             _flags.Bits.Rx = 1;
00204             _flags.Bits.RxData = size > 0;
00205             _flags.Bits.RxSlot = slot;
00206             _info.RxBuffer = payload;
00207             _info.RxBufferSize = size;
00208             _info.RxPort = port;
00209             _info.RxRssi = rssi;
00210             _info.RxSnr = snr;
00211             _info.TxAckReceived = AckReceived;
00212             _info.DuplicateRx = DuplicateRx;
00213             _info.TxNbRetries = retries;
00214             _info.Status = LORAMAC_EVENT_INFO_STATUS_OK;
00215             Notify();
00216         }
00217 
00218         virtual void RxDone(uint8_t *payload, uint16_t size, int16_t rssi, int8_t snr, lora::DownlinkControl ctrl, uint8_t slot) {
00219             logDebug("mDotEvent - RxDone");
00220         }
00221 
00222         virtual void BeaconRx(const lora::BeaconData_t& beacon_data, int16_t rssi, int8_t snr) {
00223             logDebug("mDotEvent - BeaconRx");
00224             BeaconLocked = true;
00225             BeaconData = beacon_data;
00226         }
00227 
00228         virtual void BeaconLost() {
00229             logDebug("mDotEvent - BeaconLost");
00230             BeaconLocked = false;
00231         }
00232 
00233         virtual void Pong(int16_t m_rssi, int8_t m_snr, int16_t s_rssi, int8_t s_snr) {
00234             logDebug("mDotEvent - Pong");
00235             PongReceived = true;
00236             PongRssi = s_rssi;
00237             PongSnr = s_snr;
00238         }
00239 
00240         virtual void ServerTime(uint32_t seconds, uint8_t sub_seconds) {
00241             logDebug("mDotEvent - ServerTime");
00242             ServerTimeReceived = true;
00243             ServerTimeSeconds = seconds;
00244         }
00245 
00246         virtual void NetworkLinkCheck(int16_t m_rssi, int8_t m_snr, int8_t s_snr, uint8_t s_gateways) {
00247             logDebug("mDotEvent - NetworkLinkCheck");
00248             LinkCheckAnsReceived = true;
00249             DemodMargin = s_snr;
00250             NbGateways = s_gateways;
00251 
00252             _flags.Bits.Tx = 0;
00253             _flags.Bits.LinkCheck = 1;
00254             _info.RxRssi = m_rssi;
00255             _info.RxSnr = m_snr;
00256             _info.DemodMargin = s_snr;
00257             _info.NbGateways = s_gateways;
00258             _info.Status = LORAMAC_EVENT_INFO_STATUS_OK;
00259             Notify();
00260         }
00261 
00262         virtual void RxTimeout(uint8_t slot) {
00263             logDebug("mDotEvent - RxTimeout on Slot %d", slot);
00264 
00265             _flags.Bits.Tx = 0;
00266             _flags.Bits.RxSlot = slot;
00267             _info.Status = LORAMAC_EVENT_INFO_STATUS_RX_TIMEOUT;
00268             Notify();
00269         }
00270 
00271         virtual void RxError(uint8_t slot) {
00272             logDebug("mDotEvent - RxError");
00273 
00274             memset(&_flags, 0, sizeof(LoRaMacEventFlags));
00275             memset(&_info, 0, sizeof(LoRaMacEventInfo ));
00276 
00277             _flags.Bits.RxSlot = slot;
00278             _info.Status = LORAMAC_EVENT_INFO_STATUS_RX_ERROR;
00279             Notify();
00280         }
00281 
00282         virtual uint8_t MeasureBattery(void) {
00283             return 255;
00284         }
00285 
00286         bool LinkCheckAnsReceived;
00287         uint8_t DemodMargin;
00288         uint8_t NbGateways;
00289 
00290         bool PacketReceived;
00291         uint8_t RxPort;
00292         uint8_t RxPayload[255];
00293         uint8_t RxPayloadSize;
00294 
00295         bool BeaconLocked;
00296         lora::BeaconData_t BeaconData;
00297 
00298         bool PongReceived;
00299         int16_t PongRssi;
00300         int16_t PongSnr;
00301 
00302         bool ServerTimeReceived;
00303         uint32_t ServerTimeSeconds;
00304 
00305         bool AckReceived;
00306         bool DuplicateRx;
00307         uint8_t TxNbRetries;
00308 
00309         LoRaMacEventFlags& Flags() {
00310             return _flags;
00311         }
00312         LoRaMacEventInfo & Info() {
00313             return _info;
00314         }
00315 
00316     private:
00317         LoRaMacEventFlags _flags;
00318         LoRaMacEventInfo  _info;
00319 
00320 //
00321 //        /*!
00322 //         * MAC layer event callback prototype.
00323 //         *
00324 //         * \param [IN] flags Bit field indicating the MAC events occurred
00325 //         * \param [IN] info  Details about MAC events occurred
00326 //         */
00327 //        virtual void MacEvent(LoRaMacEventFlags *flags, LoRaMacEventInfo *info) {
00328 //            logDebug("mDotEvent");
00329 //
00330 //            if (flags->Bits.Rx) {
00331 //                logDebug("Rx");
00332 //
00333 //                // Event Object must delete RxBuffer
00334 //                delete[] info->RxBuffer;
00335 //            }
00336 //        }
00337 //
00338 
00339 };
00340 
00341 #endif // __MDOT_EVENT_H__