Heltec Cubecell AB02 not Join to TTN EU

MartinEgli · July 25, 2023, 6:07am

My CubeCell Capsule Solar not joining to TTN with code from github repo (LoRaWan_MPU9250).
The same settings with WASN CubeCell Configurator can join to TTN.
The gateway is in the same room.

Copyright @ 2019 Heltec Automation.All rights reserved.
Setup
enableAt
Setup end
Loop
Init
getDevParam
printDevParam
AT Rev 1.3
+AutoLPM=1
+LORAWAN=1
+KeepNet=0
+OTAA=1
+Class=A
+ADR=1
+IsTxConfirmed=0
+AppPort=2
+DutyCycle=300000
+ConfirmedNbTrials=4
+ChMask=0000000000000000000000FF
+DevEui=70B3D57ED005FC3A(For OTAA Mode)
+AppEui=0000000000000000(For OTAA Mode)
+AppKey=3371B6D8AE2BDA8DCF5B6FD834A2125B(For OTAA Mode)
+NwkSKey=00000000000000000000000000000000(For ABP Mode)
+AppSKey=00000000000000000000000000000000(For ABP Mode)
+DevAddr=00000000(For ABP Mode)
LoRaWAN.init
LoRaWAN EU868 Class A start!
Loop
Join
joining…

#include "LoRaWan_APP.h"
#include "Arduino.h"
#include <Wire.h>
#include <MPU9250.h>

/*
 * set LoraWan_RGB to Active,the RGB active in loraWan
 * RGB red means sending;
 * RGB purple means joined done;
 * RGB blue means RxWindow1;
 * RGB yellow means RxWindow2;
 * RGB green means received done;
 */

/* OTAA para*/
// DevEUI 70B3D57ED005FC3A
// appKey 3371B6D8AE2BDA8DCF5B6FD834A2125B
// 0x70, 0xB3, 0xD5, 0x7E, 0xD0, 0x05, 0xFC, 0x3A
// 0x3A, 0xFC, 0x05, 0xD0, 0x7E, 0xD5, 0xB3, 0x70
uint8_t devEui[] = { 0x70, 0xB3, 0xD5, 0x7E, 0xD0, 0x05, 0xFC, 0x3A };
//uint8_t devEui[] = { 0x3A, 0xFC, 0x05, 0xD0, 0x7E, 0xD5, 0xB3, 0x70 };
uint8_t appEui[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };

//0x33, 0x71, 0xB6, 0xD8, 0xAE, 0x2B, 0xDA, 0x8D, 0xCF, 0x5B, 0x6F, 0xD8, 0x34, 0xA2, 0x12, 0x5B
uint8_t appKey[] = { 0x33, 0x71, 0xB6, 0xD8, 0xAE, 0x2B, 0xDA, 0x8D, 0xCF, 0x5B, 0x6F, 0xD8, 0x34, 0xA2, 0x12, 0x5B };

/* ABP para*/
uint8_t nwkSKey[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
uint8_t appSKey[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
uint32_t devAddr =  ( uint32_t )0x00000000;
/*
uint8_t nwkSKey[] = { 0x15, 0xb1, 0xd0, 0xef, 0xa4, 0x63, 0xdf, 0xbe, 0x3d, 0x11, 0x18, 0x1e, 0x1e, 0xc7, 0xda,0x85 };
uint8_t appSKey[] = { 0xd7, 0x2c, 0x78, 0x75, 0x8c, 0xdc, 0xca, 0xbf, 0x55, 0xee, 0x4a, 0x77, 0x8d, 0x16, 0xef,0x67 };
uint32_t devAddr =  ( uint32_t )0x007e6ae1;
*/

/*LoraWan channelsmask, default channels 0-7*/ 
uint16_t userChannelsMask[6]={ 0x00FF,0x0000,0x0000,0x0000,0x0000,0x0000 };
//uint16_t userChannelsMask[6]={ 0xFF00,0x0000,0x0000,0x0000,0x0000,0x0000 };

/*LoraWan region, select in arduino IDE tools*/
LoRaMacRegion_t loraWanRegion = LORAMAC_REGION_EU868;

/*LoraWan Class, Class A and Class C are supported*/
DeviceClass_t  loraWanClass = CLASS_A;

/*the application data transmission duty cycle.  value in [ms].*/
uint32_t appTxDutyCycle = 300000;

/*OTAA or ABP*/
bool overTheAirActivation = true;

/*ADR enable*/
bool loraWanAdr = true;

/* set LORAWAN_Net_Reserve ON, the node could save the network info to flash, when node reset not need to join again */
bool keepNet = false;

/* Indicates if the node is sending confirmed or unconfirmed messages */
bool isTxConfirmed = false;

/* Application port */
uint8_t appPort = 2;
/*!
* Number of trials to transmit the frame, if the LoRaMAC layer did not
* receive an acknowledgment. The MAC performs a datarate adaptation,
* according to the LoRaWAN Specification V1.0.2, chapter 18.4, according
* to the following table:
*
* Transmission nb | Data Rate
* ----------------|-----------
* 1 (first)       | DR
* 2               | DR
* 3               | max(DR-1,0)
* 4               | max(DR-1,0)
* 5               | max(DR-2,0)
* 6               | max(DR-2,0)
* 7               | max(DR-3,0)
* 8               | max(DR-3,0)
*
* Note, that if NbTrials is set to 1 or 2, the MAC will not decrease
* the datarate, in case the LoRaMAC layer did not receive an acknowledgment
*/
uint8_t confirmedNbTrials = 4;

/* Prepares the payload of the frame */
MPU9250 mySensor;

static void prepareTxFrame( uint8_t port )
{
	/*appData size is LORAWAN_APP_DATA_MAX_SIZE which is defined in "commissioning.h".
	*appDataSize max value is LORAWAN_APP_DATA_MAX_SIZE.
	*if enabled AT, don't modify LORAWAN_APP_DATA_MAX_SIZE, it may cause system hanging or failure.
	*if disabled AT, LORAWAN_APP_DATA_MAX_SIZE can be modified, the max value is reference to lorawan region and SF.
	*for example, if use REGION_CN470, 
	*the max value for different DR can be found in MaxPayloadOfDatarateCN470 refer to DataratesCN470 and BandwidthsCN470 in "RegionCN470.h".
	*/
  float aX, aY, aZ, aSqrt, gX, gY, gZ, mDirection, mX, mY, mZ;
  pinMode(Vext, OUTPUT);
  digitalWrite(Vext, LOW);
  Wire.begin();
  mySensor.setWire(&Wire);
 
  mySensor.beginAccel();
  mySensor.beginGyro();
  mySensor.beginMag();


  
  // You can set your own offset for mag values
  // mySensor.magXOffset = -50;
  // mySensor.magYOffset = -55;
  // mySensor.magZOffset = -10;
  

  mySensor.accelUpdate();
  aX = mySensor.accelX();
  aY = mySensor.accelY();
  aZ = mySensor.accelZ();
  aSqrt = mySensor.accelSqrt();
  Serial.print("aX:");
  Serial.println(aX);
  Serial.print("aY:");
  Serial.println(aY);
  Serial.print("aZ:");
  Serial.println(aZ);
  Serial.print("aSqrt:");
  Serial.println(aSqrt);
  

  mySensor.gyroUpdate();
  gX = mySensor.gyroX();
  gY = mySensor.gyroY();
  gZ = mySensor.gyroZ();
  Serial.print("gX:");
  Serial.println(gX);
  Serial.print("gY:");
  Serial.println(gY);
  Serial.print("gZ:");
  Serial.println(gZ);
  

  mySensor.magUpdate();
  mX = mySensor.magX();
  mY = mySensor.magY();
  mZ = mySensor.magZ();
  mDirection = mySensor.magHorizDirection();
  Serial.print("mX:");
  Serial.println(mX);
  Serial.print("mY:");
  Serial.println(mY);
  Serial.print("mZ:");
  Serial.println(mZ);
  Serial.print("mDirection:");
  Serial.println(mDirection);
  
  Wire.end();
  digitalWrite(Vext, HIGH);
  uint16_t batteryVoltage = getBatteryVoltage();
  unsigned char *puc;

  puc = (unsigned char *)(&aX);
  appDataSize = 46;
  appData[0] = puc[0];
  appData[1] = puc[1];
  appData[2] = puc[2];
  appData[3] = puc[3];
  puc = (unsigned char *)(&aY);
  appData[4] = puc[0];
  appData[5] = puc[1];
  appData[6] = puc[2];
  appData[7] = puc[3];
  puc = (unsigned char *)(&aZ);
  appData[8] = puc[0];
  appData[9] = puc[1];
  appData[10] = puc[2];
  appData[11] = puc[3];
  puc = (unsigned char *)(&gX);
  appData[12] = puc[0];
  appData[13] = puc[1];
  appData[14] = puc[2];
  appData[15] = puc[3];
  puc = (unsigned char *)(&gY);
  appData[16] = puc[0];
  appData[17] = puc[1];
  appData[18] = puc[2];
  appData[19] = puc[3];
  puc = (unsigned char *)(&gZ);
  appData[20] = puc[0];
  appData[21] = puc[1];
  appData[22] = puc[2];
  appData[23] = puc[3];
  puc = (unsigned char *)(&mX);
  appData[24] = puc[0];
  appData[25] = puc[1];
  appData[26] = puc[2];
  appData[27] = puc[3];
  puc = (unsigned char *)(&mY);
  appData[28] = puc[0];
  appData[29] = puc[1];
  appData[30] = puc[2];
  appData[31] = puc[3];
  puc = (unsigned char *)(&mZ);
  appData[32] = puc[0];
  appData[33] = puc[1];
  appData[34] = puc[2];
  appData[35] = puc[3];
  puc = (unsigned char *)(&aSqrt);
  appData[36] = puc[0];
  appData[37] = puc[1];
  appData[38] = puc[2];
  appData[39] = puc[3];
  puc = (unsigned char *)(&mDirection);
  appData[40] = puc[0];
  appData[41] = puc[1];
  appData[42] = puc[2];
  appData[43] = puc[3];
  
  appData[44] = (uint8_t)(batteryVoltage>>8);
  appData[45] = (uint8_t)batteryVoltage;
	

  Serial.print("BatteryVoltage:");
  Serial.println(batteryVoltage);
}


void setup() {
  Serial.begin(115200);
  Serial.println("Setup");
#if(AT_SUPPORT)
  Serial.println("enableAt");
	enableAt();
#endif
	deviceState = DEVICE_STATE_INIT;
	LoRaWAN.ifskipjoin();
  Serial.println("Setup end");
}

void loop()
{
  Serial.println("Loop");
	switch( deviceState )
	{
		case DEVICE_STATE_INIT:
		{
    Serial.println("Init");
#if(LORAWAN_DEVEUI_AUTO)
      Serial.println("generateDeveuiByChipID");
			LoRaWAN.generateDeveuiByChipID();
#endif
#if(AT_SUPPORT)
			Serial.println("getDevParam");
			getDevParam();
#endif
			Serial.println("printDevParam");
			printDevParam();
			Serial.println("LoRaWAN.init");
			LoRaWAN.init(loraWanClass, loraWanRegion);
			deviceState = DEVICE_STATE_JOIN;
			break;
		}
		case DEVICE_STATE_JOIN:
		{
      Serial.println("Join");
			LoRaWAN.join();
			break;
		}
		case DEVICE_STATE_SEND:
		{
      Serial.println("Send");
			prepareTxFrame( appPort );
			LoRaWAN.send();
			deviceState = DEVICE_STATE_CYCLE;
			break;
		}
		case DEVICE_STATE_CYCLE:
		{
      Serial.println("Cycle");
			// Schedule next packet transmission
			txDutyCycleTime = appTxDutyCycle + randr( 0, APP_TX_DUTYCYCLE_RND );
			LoRaWAN.cycle(txDutyCycleTime);
			deviceState = DEVICE_STATE_SLEEP;
			break;
		}
		case DEVICE_STATE_SLEEP:
		{
      Serial.println("Sleep");
			LoRaWAN.sleep();
			break;
		}
		default:
		{
      Serial.println("Default");
			deviceState = DEVICE_STATE_INIT;
			break;
		}
	}
}

descartes · July 25, 2023, 10:55am

Your 15 second send interval is in breach of the Fair Use Policy - please confirm that you have read with it and have adjusted your code accordingly - topic unlisted pending confirmation.

MartinEgli · July 25, 2023, 11:25am

Yes! I read it. Is it the problem the device not join?

descartes · July 25, 2023, 11:40am

Have you adjusted your code accordingly??

Apart from LoRaWAN not being able to process that fast, forum policy is to ask why people are posting code that is not just in breach of the Fair Use Policy but most likely the law as well.

What is the make & model of your gateway?

What does your gateway show?

What does the application console show?

How far apart is the gateway & device?

MartinEgli · July 25, 2023, 3:38pm

Hello, the short time is for debugging. I have set it to 5 minutes. The code is only to solve the join problem. Then i throw it away. The device is on only for this time.

The gateway is from Laird RG186. Firmware Laird Linux gatwick-laird-93.9.6.57.
The gateway show:

The application console

They are 5 meters away from each other

MartinEgli · July 25, 2023, 3:39pm

When I use CubeCellConfigurator.exe it Join.

descartes · July 25, 2023, 6:45pm

It doesn’t matter, it doesn’t work better or quicker by hammering at the door. Code it to work with a push button or set it like you have to 5 minutes and just press reset to test, observe the results, make adjustments and try again.

The RSSI and SNR seem rather low - how far away is the gateway from the device?

Whilst in theory all zeros for the JoinEUI is possible, we have discovered that some older software can’t cope well - you should generate one from the console or by other means.

MartinEgli · July 25, 2023, 7:55pm

The gateway entries ar from other devices. My dievice is in the same room. The device works with wasn configuration tool.

descartes · July 25, 2023, 9:36pm

So use that then ??

MartinEgli · July 26, 2023, 4:13am

I want to use my own code. What makes WASN different from the Heltech sample code?
Is it because of the EU setting?

descartes · July 26, 2023, 8:41am

I don’t know, I’ve never heard of or seen WASN before.

But I can tell you the custom LoRaWAN code base is 6 years old and a lot has changed in that time. If you search the forum you’ll find plenty of people struggling with it.

MartinEgli · July 26, 2023, 10:23am

You mean the code from Heltec?
Is there a better template for CubeCell?

descartes · July 26, 2023, 11:09am

Yes

Don’t know - best ask Heltec

MartinEgli · July 26, 2023, 5:29pm

I have found the problem. I have adjusted the variables and not the global settings.

/LoraWan region, select in arduino IDE tools/
LoRaMacRegion_t loraWanRegion = ACTIVE_REGION;
/LoraWan Class, Class A and Class C are supported/
DeviceClass_t loraWanClass = LORAWAN_CLASS;
/the application data transmission duty cycle. value in [ms]./
uint32_t appTxDutyCycle = 300000;
/OTAA or ABP/
bool overTheAirActivation = LORAWAN_NETMODE;
/ADR enable/
bool loraWanAdr = LORAWAN_ADR;
/* set LORAWAN_Net_Reserve ON, the node could save the network info to flash, when node reset not need to join again /
bool keepNet = LORAWAN_NET_RESERVE;
/ Indicates if the node is sending confirmed or unconfirmed messages /
bool isTxConfirmed = LORAWAN_UPLINKMODE;
/ Application port */
uint8_t appPort = 2;

crazygufer · December 25, 2023, 8:42pm

Hi,
please can u share how your final sketch? i try to modify the variables but i dont really know how to do it,

Thanks!

Johan_Scheepers · December 26, 2023, 9:10am

Some this like this will get you going, what variable do you want to change?

/*
The Things Stack Sandbox

1. FUP
On The Things Network’s The Things Stack Sandbox a Fair Use Policy applies which limits the uplink airtime to 30 seconds
per day (24 hours) per node and the downlink messages to 10 messages per day (24 hours) per node. If you use a private network,
these limits do not apply, but you still have to be compliant with the governmental and LoRaWAN limits.
https://www.thethingsnetwork.org/docs/lorawan/duty-cycle/#fair-use-policy
*/

/*
When you are in your test environment, please ensure you have sufficient attenuation between your node and the gateway.

We recommend that the rssi needs to be -65 dBm to -100 dBm. This can be achieved by having a brick wall or other RF
absorbing material between your node and gateway and a physical distance of 5-10m.
*/



#include "LoRaWan_APP.h"
#include "Arduino.h"
#include <Wire.h>
#include <SPI.h>
//#include "CubeCell_NeoPixel.h"
//CubeCell_NeoPixel pixels(1, RGB, NEO_GRB + NEO_KHZ800);
#include "HT_SH1107Wire.h"
extern SH1107Wire display;

/*
   set LoraWan_RGB to Active,the RGB active in loraWan
   RGB red means sending;
   RGB purple means joined done;
   RGB blue means RxWindow1;
   RGB yellow means RxWindow2;
   RGB green means received done;
*/

/* OTAA para*/

/*End-device Identifier (u1_t[8]) in msb format*/
uint8_t devEui[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };

/*Application Identifier (u1_t[8]) in msb format*/
uint8_t appEui[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };

/*Application Key (u1_t[16]) in msb format*/
uint8_t appKey[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };

/* ABP para*/
uint8_t nwkSKey[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
uint8_t appSKey[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
uint32_t devAddr =  ( uint32_t )0x00000000;

/*LoraWan channelsmask*/
uint16_t userChannelsMask[6] = { 0x00FF, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000 };

/*LoraWan region, select in arduino IDE tools*/
LoRaMacRegion_t loraWanRegion = ACTIVE_REGION;

/*LoraWan Class, Class A and Class C are supported*/
DeviceClass_t  loraWanClass = LORAWAN_CLASS;

/*the application data transmission duty cycle.  value in [ms].*/
uint32_t appTxDutyCycle = 900000;

/*OTAA or ABP*/
bool overTheAirActivation = LORAWAN_NETMODE;

/*ADR enable*/
bool loraWanAdr = LORAWAN_ADR;

/* set LORAWAN_Net_Reserve ON, the node could save the network info to flash, when node reset not need to join again */
bool keepNet = LORAWAN_NET_RESERVE;

/* Indicates if the node is sending confirmed or unconfirmed messages */
bool isTxConfirmed = LORAWAN_UPLINKMODE;

/* Application port */
uint8_t appPort = 1;
/*!
  Number of trials to transmit the frame, if the LoRaMAC layer did not
  receive an acknowledgment. The MAC performs a datarate adaptation,
  according to the LoRaWAN Specification V1.0.2, chapter 18.4, according
  to the following table:

  Transmission nb | Data Rate
  ----------------|-----------
  1 (first)       | DR
  2               | DR
  3               | max(DR-1,0)
  4               | max(DR-1,0)
  5               | max(DR-2,0)
  6               | max(DR-2,0)
  7               | max(DR-3,0)
  8               | max(DR-3,0)

  Note, that if NbTrials is set to 1 or 2, the MAC will not decrease
  the datarate, in case the LoRaMAC layer did not receive an acknowledgment
*/
uint8_t confirmedNbTrials = 4;


/* Prepares the payload of the frame */
static void prepareTxFrame( uint8_t port )
{
  /*appData size is LORAWAN_APP_DATA_MAX_SIZE which is defined in "commissioning.h".
    appDataSize max value is LORAWAN_APP_DATA_MAX_SIZE.
    if enabled AT, don't modify LORAWAN_APP_DATA_MAX_SIZE, it may cause system hanging or failure.
    if disabled AT, LORAWAN_APP_DATA_MAX_SIZE can be modified, the max value is reference to lorawan region and SF.
    for example, if use REGION_CN470,
    the max value for different DR can be found in MaxPayloadOfDatarateCN470 refer to DataratesCN470 and BandwidthsCN470 in "RegionCN470.h".
  */
  digitalWrite(Vext, LOW); //Turn power on for pin Vext
  Wire.begin();
  delay(500);

 /*Measurments*/


  float battV = round((getBatteryVoltage() / 10) / 100); // measure battery voltage
  
  /*Print all values to serial port*/
  Serial.print("BatteryVoltage: ");
  Serial.println(battV );
  Serial.println();

  /*Print all welcom message to the OLED*/
  display.init();
  display.clear();
  display.setFont(ArialMT_Plain_16);
  display.setTextAlignment(TEXT_ALIGN_LEFT);
  display.drawString(00, 00, "TTN Sandbox");
  display.setFont(ArialMT_Plain_10);
  display.drawString(0, 16, "FUP - Uplink airtime");
  display.drawString(0, 27, "Max 30s Uplink/day total");
  display.drawString(0, 38, "FUP - Downlink messages");
  display.drawString(0, 49, "Max 10 Downlink/day");
  display.display();
  delay(10000);
  /* Print all measurements to the OLED*/
  display.clear();
  display.setFont(ArialMT_Plain_10);
  display.setTextAlignment(TEXT_ALIGN_LEFT);
  display.drawString(00, 22, "Battery Voltage :");
  display.setTextAlignment(TEXT_ALIGN_RIGHT);
  display.drawString(118, 22, (String)battV);
  display.drawString(128, 22, "V");
  display.display();
  delay(5000);
  digitalWrite(Vext, HIGH);  /*Turn power off for pin Vext*/
  display.stop();

   byte data[2];
  appDataSize = 2;
  uint16_t vBatt= battV * 100;

appData[0] = highByte(vBatt);
appData[1] = lowByte(vBatt);

/* Decoder

function decodeUplink(input) {
    var data = {};
    var warnings = [];


  if (input.fPort == 1) {
      data.vBatt = ((input.bytes[0] << 8 | input.bytes[1]))/100;

  }
  else {
      warnings.push("Unsupported fPort");
  }
  return {
    data: data,
    warnings: warnings
  };
}
*/

  
    Wire.end();
}

void downLinkDataHandle(McpsIndication_t *mcpsIndication)
{
  /* 
  Have to send on port 2

  Bytes 0 -> 3 are for the color

  Byte 3 is to turn the led on

Byte 4 delay 0.1 sec steps

Byte 5 is repeat times

  */
  int port = mcpsIndication->Port;
  if (port ==2){
      Serial.printf("+REV DATA:%s,RXSIZE %d,PORT %d\r\n",mcpsIndication->RxSlot?"RXWIN2":"RXWIN1",mcpsIndication->BufferSize,mcpsIndication->Port);
  Serial.print("+REV DATA:");
  for(uint8_t i=0;i<mcpsIndication->BufferSize;i++)
  {
    Serial.printf("%02X",mcpsIndication->Buffer[i]);
  }
  Serial.println();
  uint32_t color=mcpsIndication->Buffer[0]<<16|mcpsIndication->Buffer[1]<<8|mcpsIndication->Buffer[2];
  Serial.print("Color: ");
  Serial.print(color);
  Serial.println();
  uint32_t pin = mcpsIndication->Buffer[3];
    Serial.print("Pin: ");
    Serial.print(pin);
    Serial.println();
    uint32_t delay1 = (mcpsIndication->Buffer[4]) * 100;
    Serial.print("delay: ");
    Serial.print(delay1);
    Serial.println();
    uint32_t repeat = mcpsIndication->Buffer[5];
    Serial.print("repeat: ");
    Serial.print(repeat);
    Serial.println();
  Serial.println();
if (pin == 1){
  for (int i = 0; i < repeat; i++){
  turnOnRGB(color, delay1);
  turnOffRGB();
  Serial.print("i: ");
    Serial.print(i);
    Serial.println();
  delay(delay1);
  };
};
//#endif

  };

}


void setup() {
  Serial.begin(115200);

#if(AT_SUPPORT)
  enableAt();
#endif
  LoRaWAN.displayMcuInit();
  deviceState = DEVICE_STATE_INIT;

  LoRaWAN.ifskipjoin();
}

void loop()
{
  switch ( deviceState )
  {
    case DEVICE_STATE_INIT:
      {
#if(LORAWAN_DEVEUI_AUTO)
        LoRaWAN.generateDeveuiByChipID();
#endif
#if(AT_SUPPORT)
        getDevParam();
#endif
        printDevParam();
        LoRaWAN.init(loraWanClass, loraWanRegion);
        deviceState = DEVICE_STATE_JOIN;
        break;
      }
    case DEVICE_STATE_JOIN:
      {
        LoRaWAN.displayJoining();
        LoRaWAN.join();
        break;
      }
    case DEVICE_STATE_SEND:
      {
        prepareTxFrame( appPort );
        LoRaWAN.send();
        deviceState = DEVICE_STATE_CYCLE;
/*        digitalWrite(Vext, HIGH);  //Turn power off for pin Vext
        display.stop(); */
        LoRaWAN.sleep();
        break;
      }
    case DEVICE_STATE_CYCLE:
      {
        // Schedule next packet transmission
        txDutyCycleTime = appTxDutyCycle + randr( 0, APP_TX_DUTYCYCLE_RND );
        LoRaWAN.cycle(txDutyCycleTime);
        deviceState = DEVICE_STATE_SLEEP;
        break;
      }
    case DEVICE_STATE_SLEEP:
      {
        /*LoRaWAN.displayAck();*/
        LoRaWAN.sleep();
        break;
      }
    default:
      {
        deviceState = DEVICE_STATE_INIT;
        break;
      }
  }
}