main.cpp

00001 /*
00002  / _____)             _              | |
00003 ( (____  _____ ____ _| |_ _____  ____| |__
00004  \____ \| ___ |    (_   _) ___ |/ ___)  _ \
00005  _____) ) ____| | | || |_| ____( (___| | | |
00006 (______/|_____)_|_|_| \__)_____)\____)_| |_|
00007     (C)2015 Semtech
00008 
00009 Description: LoRaMac classA device implementation
00010 
00011 License: Revised BSD License, see LICENSE.TXT file include in the project
00012 
00013 Maintainer: Miguel Luis and Gregory Cristian
00014 */
00015 #include "mbed.h"
00016 #include "board.h"
00017 #include "radio.h"
00018 
00019 #include "LoRaMac.h"
00020 #include "Comissioning.h"
00021 
00022 /*!
00023  * Defines the application data transmission duty cycle. 5s, value in [us].
00024  */
00025 #define APP_TX_DUTYCYCLE                            5000000
00026 
00027 /*!
00028  * Defines a random delay for application data transmission duty cycle. 1s,
00029  * value in [us].
00030  */
00031 #define APP_TX_DUTYCYCLE_RND                        1000000
00032 
00033 /*!
00034  * Default datarate
00035  */
00036 #define LORAWAN_DEFAULT_DATARATE                    DR_0
00037 
00038 /*!
00039  * LoRaWAN confirmed messages
00040  */
00041 #define LORAWAN_CONFIRMED_MSG_ON                    true
00042 
00043 /*!
00044  * LoRaWAN Adaptive Data Rate
00045  *
00046  * \remark Please note that when ADR is enabled the end-device should be static
00047  */
00048 #define LORAWAN_ADR_ON                              1
00049 
00050 #if defined( USE_BAND_868 )
00051 
00052 #include "LoRaMacTest.h"
00053 
00054 /*!
00055  * LoRaWAN ETSI duty cycle control enable/disable
00056  *
00057  * \remark Please note that ETSI mandates duty cycled transmissions. Use only for test purposes
00058  */
00059 #define LORAWAN_DUTYCYCLE_ON                        true
00060 
00061 #define USE_SEMTECH_DEFAULT_CHANNEL_LINEUP          1
00062 
00063 #if( USE_SEMTECH_DEFAULT_CHANNEL_LINEUP == 1 ) 
00064 
00065 #define LC4                { 867100000, { ( ( DR_5 << 4 ) | DR_0 ) }, 0 }
00066 #define LC5                { 867300000, { ( ( DR_5 << 4 ) | DR_0 ) }, 0 }
00067 #define LC6                { 867500000, { ( ( DR_5 << 4 ) | DR_0 ) }, 0 }
00068 #define LC7                { 867700000, { ( ( DR_5 << 4 ) | DR_0 ) }, 0 }
00069 #define LC8                { 867900000, { ( ( DR_5 << 4 ) | DR_0 ) }, 0 }
00070 #define LC9                { 868800000, { ( ( DR_7 << 4 ) | DR_7 ) }, 2 }
00071 #define LC10               { 868300000, { ( ( DR_6 << 4 ) | DR_6 ) }, 1 }
00072 
00073 #endif
00074 
00075 #endif
00076 
00077 /*!
00078  * LoRaWAN application port
00079  */
00080 #define LORAWAN_APP_PORT                            15
00081 
00082 /*!
00083  * User application data buffer size
00084  */
00085 #if ( LORAWAN_CONFIRMED_MSG_ON == 1 )
00086 #define LORAWAN_APP_DATA_SIZE                       6
00087 
00088 #else
00089 #define LORAWAN_APP_DATA_SIZE                       1
00090 
00091 #endif
00092 
00093 static uint8_t DevEui[] = LORAWAN_DEVICE_EUI;
00094 static uint8_t AppEui[] = LORAWAN_APPLICATION_EUI;
00095 static uint8_t AppKey[] = LORAWAN_APPLICATION_KEY;
00096 
00097 #if( OVER_THE_AIR_ACTIVATION == 0 )
00098 
00099 static uint8_t NwkSKey[] = LORAWAN_NWKSKEY;
00100 static uint8_t AppSKey[] = LORAWAN_APPSKEY;
00101 
00102 /*!
00103  * Device address
00104  */
00105 static uint32_t DevAddr = LORAWAN_DEVICE_ADDRESS;
00106 
00107 #endif
00108 
00109 /*!
00110  * Application port
00111  */
00112 static uint8_t AppPort = LORAWAN_APP_PORT;
00113 
00114 /*!
00115  * User application data size
00116  */
00117 static uint8_t AppDataSize = LORAWAN_APP_DATA_SIZE;
00118 
00119 /*!
00120  * User application data buffer size
00121  */
00122 #define LORAWAN_APP_DATA_MAX_SIZE                           64
00123 
00124 /*!
00125  * User application data
00126  */
00127 static char AppData[LORAWAN_APP_DATA_MAX_SIZE];
00128 
00129 /*!
00130  * Indicates if the node is sending confirmed or unconfirmed messages
00131  */
00132 static uint8_t IsTxConfirmed = LORAWAN_CONFIRMED_MSG_ON;
00133 
00134 /*!
00135  * Defines the application data transmission duty cycle
00136  */
00137 
00138 /*!
00139  * Timer to handle the application data transmission duty cycle
00140  */
00141 static TimerEvent_t TxNextPacketTimer;
00142 
00143 /*!
00144  * Specifies the state of the application LED
00145  */
00146 //static bool AppLedStateOn = false;
00147 volatile bool Led3StateChanged = false;
00148 /*!
00149  * Timer to handle the state of LED1
00150  */
00151 static TimerEvent_t Led1Timer;
00152 volatile bool Led1State = false;
00153 volatile bool Led1StateChanged = false;
00154 /*!
00155  * Timer to handle the state of LED2
00156  */
00157 static TimerEvent_t Led2Timer;
00158 volatile bool Led2State = false;
00159 volatile bool Led2StateChanged = false;
00160 
00161 /*!
00162  * Indicates if a new packet can be sent
00163  */
00164 
00165 /*!
00166  * Device states
00167  */
00168 static enum eDevicState
00169 {
00170     DEVICE_STATE_INIT,
00171     DEVICE_STATE_JOIN,
00172     DEVICE_STATE_SEND,
00173     DEVICE_STATE_CYCLE,
00174     DEVICE_STATE_SLEEP
00175 }DeviceState;
00176 
00177 /*!
00178  * LoRaWAN compliance tests support data
00179  */
00180 struct ComplianceTest_s
00181 {
00182     bool Running;
00183     uint8_t State;
00184     bool IsTxConfirmed;
00185     uint8_t AppPort;
00186     uint8_t AppDataSize;
00187     uint8_t *AppDataBuffer;
00188     uint16_t DownLinkCounter;
00189     bool LinkCheck;
00190     uint8_t DemodMargin;
00191     uint8_t NbGateways;
00192 }ComplianceTest;
00193 
00194 /*
00195  * SerialDisplay managment variables
00196  */
00197 
00198 /*!
00199  * Indicates if the MAC layer network join status has changed.
00200  */
00201  
00202 
00203 /*!
00204  * Strucure containing the Uplink status
00205  */
00206 struct sLoRaMacUplinkStatus
00207 {
00208     uint8_t Acked;
00209     int8_t Datarate;
00210     uint16_t UplinkCounter;
00211     uint8_t Port;
00212     char *Buffer;
00213     uint8_t BufferSize;
00214 }LoRaMacUplinkStatus;
00215 volatile bool UplinkStatusUpdated = false;
00216 
00217 /*!
00218  * Strucure containing the Downlink status
00219  */
00220 struct sLoRaMacDownlinkStatus
00221 {
00222     int16_t Rssi;
00223     int8_t Snr;
00224     uint16_t DownlinkCounter;
00225     bool RxData;
00226     uint8_t Port;
00227     uint8_t *Buffer;
00228     uint8_t BufferSize;
00229 }LoRaMacDownlinkStatus;
00230 volatile bool DownlinkStatusUpdated = false;
00231 
00232 
00233 /*!
00234  * \brief   Prepares the payload of the frame
00235  */
00236 static void PrepareTxFrame(char* value )
00237 {
00238     
00239      for( int i = 0;i < strlen(value);i++)
00240         AppData[i] = value[i];
00241      //AppData[0] = 0x12;   
00242      //AppData[1] = 0x34;   
00243      //AppData[2] = 0x56;   
00244      //AppData[3] = 0x78;   
00245      //AppData[4] = 0x90;   
00246      //AppData[5] = 0x12;            
00247 }
00248 
00249 /*!
00250  * \brief   Prepares the payload of the frame
00251  *
00252  * \retval  [0: frame could be send, 1: error]
00253  */
00254 static bool SendFrame( void )
00255 {
00256     McpsReq_t mcpsReq;
00257     LoRaMacTxInfo_t txInfo;
00258     
00259     if( LoRaMacQueryTxPossible( AppDataSize, &txInfo ) != LORAMAC_STATUS_OK )
00260     {
00261         // Send empty frame in order to flush MAC commands
00262         mcpsReq.Type = MCPS_UNCONFIRMED;
00263         mcpsReq.Req.Unconfirmed.fBuffer = NULL;
00264         mcpsReq.Req.Unconfirmed.fBufferSize = 0;
00265         mcpsReq.Req.Unconfirmed.Datarate = LORAWAN_DEFAULT_DATARATE;
00266 
00267         LoRaMacUplinkStatus.Acked = false;
00268         LoRaMacUplinkStatus.Port = 0;
00269         LoRaMacUplinkStatus.Buffer = NULL;
00270         LoRaMacUplinkStatus.BufferSize = 0;
00271         //SerialDisplayUpdateFrameType( false );
00272     }
00273     else
00274     {
00275         LoRaMacUplinkStatus.Acked = false;
00276         LoRaMacUplinkStatus.Port = AppPort;
00277         LoRaMacUplinkStatus.Buffer = AppData;
00278         LoRaMacUplinkStatus.BufferSize = AppDataSize;
00279         //SerialDisplayUpdateFrameType( IsTxConfirmed );
00280 
00281         if( IsTxConfirmed == false )
00282         {
00283             mcpsReq.Type = MCPS_UNCONFIRMED;
00284             mcpsReq.Req.Unconfirmed.fPort = AppPort;
00285             mcpsReq.Req.Unconfirmed.fBuffer = AppData;
00286             mcpsReq.Req.Unconfirmed.fBufferSize = AppDataSize;
00287             mcpsReq.Req.Unconfirmed.Datarate = LORAWAN_DEFAULT_DATARATE;
00288         }
00289         else
00290         {
00291             mcpsReq.Type = MCPS_CONFIRMED;
00292             mcpsReq.Req.Confirmed.fPort = AppPort;
00293             mcpsReq.Req.Confirmed.fBuffer = AppData;
00294             mcpsReq.Req.Confirmed.fBufferSize = AppDataSize;
00295             mcpsReq.Req.Confirmed.NbTrials = 8;
00296             mcpsReq.Req.Confirmed.Datarate = LORAWAN_DEFAULT_DATARATE;
00297         }
00298     }
00299 
00300     if( LoRaMacMcpsRequest( &mcpsReq ) == LORAMAC_STATUS_OK )
00301     {
00302         return false;
00303     }
00304     return true;
00305 }
00306 
00307 /*!
00308  * \brief   MCPS-Confirm event function
00309  *
00310  * \param   [IN] mcpsConfirm - Pointer to the confirm structure,
00311  *               containing confirm attributes.
00312  */
00313 static void McpsConfirm( McpsConfirm_t *mcpsConfirm )
00314 {
00315     if( mcpsConfirm->Status == LORAMAC_EVENT_INFO_STATUS_OK )
00316     {
00317         switch( mcpsConfirm->McpsRequest )
00318         {
00319             case MCPS_UNCONFIRMED:
00320             {
00321                 // Check Datarate
00322                 // Check TxPower
00323                 break;
00324             }
00325             case MCPS_CONFIRMED:
00326             {
00327                 // Check Datarate
00328                 // Check TxPower
00329                 // Check AckReceived
00330                 // Check NbTrials
00331                 LoRaMacUplinkStatus.Acked = mcpsConfirm->AckReceived;
00332                 break;
00333             }
00334             case MCPS_PROPRIETARY:
00335             {
00336                 break;
00337             }
00338             default:
00339                 break;
00340         }
00341         LoRaMacUplinkStatus.Datarate = mcpsConfirm->Datarate;
00342         LoRaMacUplinkStatus.UplinkCounter = mcpsConfirm->UpLinkCounter;
00343 
00344         // Switch LED 1 ON
00345         Led1State = true;
00346         Led1StateChanged = true;
00347         TimerStart( &Led1Timer );
00348 
00349         UplinkStatusUpdated = true;
00350     }
00351     
00352 }
00353 
00354 /*!
00355  * \brief   MCPS-Indication event function
00356  *
00357  * \param   [IN] mcpsIndication - Pointer to the indication structure,
00358  *               containing indication attributes.
00359  */
00360 static void McpsIndication( McpsIndication_t *mcpsIndication )
00361 {
00362     if( mcpsIndication->Status != LORAMAC_EVENT_INFO_STATUS_OK )
00363     {
00364         return;
00365     }
00366 
00367     switch( mcpsIndication->McpsIndication )
00368     {
00369         case MCPS_UNCONFIRMED:
00370         {
00371             break;
00372         }
00373         case MCPS_CONFIRMED:
00374         {
00375             break;
00376         }
00377         case MCPS_PROPRIETARY:
00378         {
00379             break;
00380         }
00381         case MCPS_MULTICAST:
00382         {
00383             break;
00384         }
00385         default:
00386             break;
00387     }
00388 
00389     // Check Multicast
00390     // Check Port
00391     // Check Datarate
00392     // Check FramePending
00393     // Check Buffer
00394     // Check BufferSize
00395     // Check Rssi
00396     // Check Snr
00397     // Check RxSlot
00398     LoRaMacDownlinkStatus.Rssi = mcpsIndication->Rssi;
00399     if( mcpsIndication->Snr & 0x80 ) // The SNR sign bit is 1
00400     {
00401         // Invert and divide by 4
00402         LoRaMacDownlinkStatus.Snr = ( ( ~mcpsIndication->Snr + 1 ) & 0xFF ) >> 2;
00403         LoRaMacDownlinkStatus.Snr = -LoRaMacDownlinkStatus.Snr;
00404     }
00405     else
00406     {
00407         // Divide by 4
00408         LoRaMacDownlinkStatus.Snr = ( mcpsIndication->Snr & 0xFF ) >> 2;
00409     }
00410     LoRaMacDownlinkStatus.DownlinkCounter++;
00411     LoRaMacDownlinkStatus.RxData = mcpsIndication->RxData;
00412     LoRaMacDownlinkStatus.Port = mcpsIndication->Port;
00413     LoRaMacDownlinkStatus.Buffer = mcpsIndication->Buffer;
00414     LoRaMacDownlinkStatus.BufferSize = mcpsIndication->BufferSize;
00415 
00416     if( ComplianceTest.Running == true )
00417     {
00418         ComplianceTest.DownLinkCounter++;
00419     }
00420 
00421     if( mcpsIndication->RxData == true )
00422     {
00423         switch( mcpsIndication->Port )
00424         {
00425         case 1: // The application LED can be controlled on port 1 or 2
00426         case 2:
00427             if( mcpsIndication->BufferSize == 1 )
00428             {
00429                 Led3StateChanged = true;
00430             }
00431             break;
00432         case 224:
00433             if( ComplianceTest.Running == false )
00434             {
00435                 // Check compliance test enable command (i)
00436                 if( ( mcpsIndication->BufferSize == 4 ) &&
00437                     ( mcpsIndication->Buffer[0] == 0x01 ) &&
00438                     ( mcpsIndication->Buffer[1] == 0x01 ) &&
00439                     ( mcpsIndication->Buffer[2] == 0x01 ) &&
00440                     ( mcpsIndication->Buffer[3] == 0x01 ) )
00441                 {
00442                     IsTxConfirmed = false;
00443                     AppPort = 224;
00444                     AppDataSize = 2;
00445                     ComplianceTest.DownLinkCounter = 0;
00446                     ComplianceTest.LinkCheck = false;
00447                     ComplianceTest.DemodMargin = 0;
00448                     ComplianceTest.NbGateways = 0;
00449                     ComplianceTest.Running = true;
00450                     ComplianceTest.State = 1;
00451                     
00452                     MibRequestConfirm_t mibReq;
00453                     mibReq.Type = MIB_ADR;
00454                     mibReq.Param.AdrEnable = true;
00455                     LoRaMacMibSetRequestConfirm( &mibReq );
00456 
00457 #if defined( USE_BAND_868 )
00458                     LoRaMacTestSetDutyCycleOn( false );
00459 #endif
00460                 }
00461             }
00462             else
00463             {
00464                 ComplianceTest.State = mcpsIndication->Buffer[0];
00465                 switch( ComplianceTest.State )
00466                 {
00467                 case 0: // Check compliance test disable command (ii)
00468                     IsTxConfirmed = LORAWAN_CONFIRMED_MSG_ON;
00469                     AppPort = LORAWAN_APP_PORT;
00470                     AppDataSize = LORAWAN_APP_DATA_SIZE;
00471                     ComplianceTest.DownLinkCounter = 0;
00472                     ComplianceTest.Running = false;
00473                     
00474                     MibRequestConfirm_t mibReq;
00475                     mibReq.Type = MIB_ADR;
00476                     mibReq.Param.AdrEnable = LORAWAN_ADR_ON;
00477                     LoRaMacMibSetRequestConfirm( &mibReq );
00478 #if defined( USE_BAND_868 )
00479                     LoRaMacTestSetDutyCycleOn( LORAWAN_DUTYCYCLE_ON );
00480 #endif
00481                     break;
00482                 case 1: // (iii, iv)
00483                     AppDataSize = 2;
00484                     break;
00485                 case 2: // Enable confirmed messages (v)
00486                     IsTxConfirmed = true;
00487                     ComplianceTest.State = 1;
00488                     break;
00489                 case 3:  // Disable confirmed messages (vi)
00490                     IsTxConfirmed = false;
00491                     ComplianceTest.State = 1;
00492                     break;
00493                 case 4: // (vii)
00494                     AppDataSize = mcpsIndication->BufferSize;
00495 
00496                     AppData[0] = 4;
00497                     for( uint8_t i = 1; i < AppDataSize; i++ )
00498                     {
00499                         AppData[i] = mcpsIndication->Buffer[i] + 1;
00500                     }
00501                     break;
00502                 case 5: // (viii)
00503                     {
00504                         MlmeReq_t mlmeReq;
00505                         mlmeReq.Type = MLME_LINK_CHECK;
00506                         LoRaMacMlmeRequest( &mlmeReq );
00507                     }
00508                     break;
00509                 case 6: // (ix)
00510                     {
00511                         MlmeReq_t mlmeReq;
00512 
00513                         mlmeReq.Type = MLME_JOIN;
00514 
00515                         mlmeReq.Req.Join.DevEui = DevEui;
00516                         mlmeReq.Req.Join.AppEui = AppEui;
00517                         mlmeReq.Req.Join.AppKey = AppKey;
00518 
00519                         LoRaMacMlmeRequest( &mlmeReq );
00520                         DeviceState = DEVICE_STATE_SLEEP;
00521                     }
00522                     break;
00523                 default:
00524                     break;
00525                 }
00526             }
00527             break;
00528         default:
00529             break;
00530         }
00531     }
00532 
00533     // Switch LED 2 ON for each received downlink
00534     Led2State = true;
00535     Led2StateChanged = true;
00536     TimerStart( &Led2Timer );
00537     DownlinkStatusUpdated = true;
00538 }
00539 
00540 /*!
00541  * \brief   MLME-Confirm event function
00542  *
00543  * \param   [IN] mlmeConfirm - Pointer to the confirm structure,
00544  *               containing confirm attributes.
00545  */
00546 static void MlmeConfirm( MlmeConfirm_t *mlmeConfirm )
00547 {
00548     if( mlmeConfirm->Status == LORAMAC_EVENT_INFO_STATUS_OK )
00549     {
00550         switch( mlmeConfirm->MlmeRequest )
00551         {
00552             case MLME_JOIN:
00553             {
00554                 // Status is OK, node has joined the network
00555                 DeviceState = DEVICE_STATE_SEND;
00556                 break;
00557             }
00558             case MLME_LINK_CHECK:
00559             {
00560                 // Check DemodMargin
00561                 // Check NbGateways
00562                 if( ComplianceTest.Running == true )
00563                 {
00564                     ComplianceTest.LinkCheck = true;
00565                     ComplianceTest.DemodMargin = mlmeConfirm->DemodMargin;
00566                     ComplianceTest.NbGateways = mlmeConfirm->NbGateways;
00567                 }
00568                 break;
00569             }
00570             default:
00571                 break;
00572         }
00573     }
00574     UplinkStatusUpdated = true;
00575 }
00576 
00577 /**
00578  * Main application entry point.
00579  */
00580 int main( void )
00581 {
00582     char send_data[] = "abcdefghijklmn";
00583     LoRaMacPrimitives_t LoRaMacPrimitives;
00584     LoRaMacCallback_t LoRaMacCallbacks;
00585     MibRequestConfirm_t mibReq;
00586 
00587     BoardInit( );
00588     DeviceState = DEVICE_STATE_INIT;
00589 
00590     while( 1 )
00591     {
00592         switch( DeviceState )
00593         {
00594             case DEVICE_STATE_INIT:
00595             {
00596                 LoRaMacPrimitives.MacMcpsConfirm = McpsConfirm;
00597                 LoRaMacPrimitives.MacMcpsIndication = McpsIndication;
00598                 LoRaMacPrimitives.MacMlmeConfirm = MlmeConfirm;
00599                 LoRaMacCallbacks.GetBatteryLevel = BoardGetBatteryLevel;
00600                 LoRaMacInitialization( &LoRaMacPrimitives, &LoRaMacCallbacks );
00601                 mibReq.Type = MIB_ADR;
00602                 mibReq.Param.AdrEnable = LORAWAN_ADR_ON;
00603                 LoRaMacMibSetRequestConfirm( &mibReq );
00604 
00605                 mibReq.Type = MIB_PUBLIC_NETWORK;
00606                 mibReq.Param.EnablePublicNetwork = LORAWAN_PUBLIC_NETWORK;
00607                 LoRaMacMibSetRequestConfirm( &mibReq );
00608 
00609 #if defined( USE_BAND_868 )
00610                 LoRaMacTestSetDutyCycleOn( LORAWAN_DUTYCYCLE_ON );
00611 
00612 #if( USE_SEMTECH_DEFAULT_CHANNEL_LINEUP == 1 ) 
00613                 LoRaMacChannelAdd( 3, ( ChannelParams_t )LC4 );
00614                 LoRaMacChannelAdd( 4, ( ChannelParams_t )LC5 );
00615                 LoRaMacChannelAdd( 5, ( ChannelParams_t )LC6 );
00616                 LoRaMacChannelAdd( 6, ( ChannelParams_t )LC7 );
00617                 LoRaMacChannelAdd( 7, ( ChannelParams_t )LC8 );
00618                 LoRaMacChannelAdd( 8, ( ChannelParams_t )LC9 );
00619                 LoRaMacChannelAdd( 9, ( ChannelParams_t )LC10 );
00620 
00621                 mibReq.Type = MIB_RX2_CHANNEL;
00622                 mibReq.Param.Rx2Channel = ( Rx2ChannelParams_t ){ 869525000, DR_3 };
00623                 LoRaMacMibSetRequestConfirm( &mibReq );
00624 #endif
00625 
00626 #endif
00627                 LoRaMacDownlinkStatus.DownlinkCounter = 0;
00628 
00629                 DeviceState = DEVICE_STATE_JOIN;
00630                 break;
00631             }
00632             case DEVICE_STATE_JOIN:
00633             {
00634 #if( OVER_THE_AIR_ACTIVATION != 0 )
00635                 MlmeReq_t mlmeReq;
00636 
00637                 mlmeReq.Type = MLME_JOIN;
00638 
00639                 mlmeReq.Req.Join.DevEui = DevEui;
00640                 mlmeReq.Req.Join.AppEui = AppEui;
00641                 mlmeReq.Req.Join.AppKey = AppKey;
00642 
00643                 if( NextTx == true )
00644                 {
00645                     LoRaMacMlmeRequest( &mlmeReq );
00646                 }
00647                 DeviceState = DEVICE_STATE_SLEEP;
00648 #else
00649                 mibReq.Type = MIB_NET_ID;
00650                 mibReq.Param.NetID = LORAWAN_NETWORK_ID;
00651                 LoRaMacMibSetRequestConfirm( &mibReq );
00652 
00653                 mibReq.Type = MIB_DEV_ADDR;
00654                 mibReq.Param.DevAddr = DevAddr;
00655                 LoRaMacMibSetRequestConfirm( &mibReq );
00656 
00657                 mibReq.Type = MIB_NWK_SKEY;
00658                 mibReq.Param.NwkSKey = NwkSKey;
00659                 LoRaMacMibSetRequestConfirm( &mibReq );
00660 
00661                 mibReq.Type = MIB_APP_SKEY;
00662                 mibReq.Param.AppSKey = AppSKey;
00663                 LoRaMacMibSetRequestConfirm( &mibReq );
00664 
00665                 mibReq.Type = MIB_NETWORK_JOINED;
00666                 mibReq.Param.IsNetworkJoined = true;
00667                 LoRaMacMibSetRequestConfirm( &mibReq );
00668 
00669                 DeviceState = DEVICE_STATE_SEND;
00670 #endif
00671                 break;
00672             }
00673             case DEVICE_STATE_SEND:
00674             {
00675                 PrepareTxFrame(send_data);
00676                 SendFrame();
00677                 DeviceState = DEVICE_STATE_CYCLE;
00678                 break;
00679             }
00680             case DEVICE_STATE_CYCLE:
00681             {
00682                 DeviceState = DEVICE_STATE_INIT;
00683                 break;
00684             }
00685             case DEVICE_STATE_SLEEP:
00686             {
00687                 // Wake up through events
00688                 break;
00689             }
00690             default:
00691             {
00692                 DeviceState = DEVICE_STATE_INIT;
00693                 break;
00694             }
00695         }
00696     }
00697 }