Registering an End Device - Arduino Dragino Lora Shield

Hi guys,

I’m completely new to TTN and I’d like to bother you with a question (sorry).

I’ve got an Arduino Dragino Lora Shield (it’s the latest version 1.4 I believe).

When I try to register this as an end device, it asks for:

  • The LoRaWAN version;
  • Regional Parameter version;
  • Frequency plan (I’m in Europe);

Anyone know which versions I should pick here? I’ve been searching this forum, the Dragino website, YouTube and everything in between for hours. Can’t find this info anywhere.

I’ve contacted Dragino themselves but if anyone can help me in the meantime; that’d be awesome!



The biggest question is which Arduino and what sketch you’re going to run.

That setup is a number of years outdated and may not be very easy to get working with the current version of TTN. The radio is fine, it’s the associated Arduino which is limiting.

Best bet would be with one of the ARM based Arduino boards or compatibles hosting the shield.

Thank you for the reply! I’ve got an Arduino Uno (latest version) with the Lora Shield mounted on top.
Thanks for pointing me in the right direction, I’ll do some research :slight_smile:

I have one running with the same config(OTAA) but on the Australian server and the LoRaWAN Version is MACv1.0.3, Regional Parameters PHYv1.03.RevA and the frequency plan you can look up in the TTN documentation as it will be different to mine…

Again, those settings depend on the unspecified sketch software, not the shields hardware.

The main challenge with this hardware will become finding software that properly implements lirawan and can fit in a base model Arduino, vs the smaller incomplete and buggy versions from years ago. Typically it’s better to use a history board with more resources.

Hi, can you let me know which sketch are you using to get it working? I didn’t find the way to register OTAA devices by using an Arduino UNO + a Dragino shield.

Hi, I can’t find the sketch, and in any case I seem to remember it was for the previous version anyhow so may not work with V3.
Good luck.

Found an example of a sketch which works with a DHT22 temp/humidity sensor attached to the Dragino shield.This is for the AU_915 frequency band

 * Copyright (c) 2015 Thomas Telkamp and Matthijs Kooijman
 * Copyright (c) 2018 Terry Moore, MCCI
 * Copyright (c) 2018 Betina Wendel and Thomas Laurenson
 * Permission is hereby granted, free of charge, to anyone
 * obtaining a copy of this document and accompanying files,
 * to do whatever they want with them without any restriction,
 * including, but not limited to, copying, modification and redistribution.
 * *****************THIS WORKS ON TTN V3*******************.
 * Sketch Summary:Modified by DL for dht22 sensor
 * Target device: Dragino LoRa Shield (US900) with Arduino Uno
 * Target frequency: AU915 sub-band 2 (916.8 to 918.2 uplink)
 * Authentication mode: Over the Air Authentication (OTAA)
 * Connect DHT22 temp/humidity sensor to Dragino Shield as follows
 * + to 3.3V - to Gnd and Data to D4
 * This example requires the following modification before upload:
 * 1) Enter a valid Application EUI (APPEUI)
 *    For example: { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
 * 2) Enter a valid Device EUI (DEVEUI)
 *    For example: { 0x33, 0x22, 0x11, 0x11, 0x88, 0x88, 0x11, 0x22 };
 *    This is little endian format, so it is in reverse order that the server
 *    provides. In the example above, the original value was: 2211888811112233
 * 3) Enter a valid Application Key (APPKEY)
 *    For example: { 0xe4, 0x17, 0xd3, 0x3b, 0xef, 0xf3, 0x80, 0x7c, 0x7c, 0x6e, 0x42, 0x43, 0x56, 0x7c, 0x21, 0xa7 };
 * The DEVEUI and APPKEY values should be obtained from your LoRaWAN server
 *  (e.g., TTN or any private LoRa provider). APPEUI is set to zeroes as 
 * the LoRa Server project does not requre this value.

#include <lmic.h>
#include <hal/hal.h>
#include <SPI.h>

// include the DHT22 Sensor Library
#include <DHT.h>
#include <DHT_U.h>
#include <Adafruit_Sensor.h>

// For normal use, we require that you edit the sketch to replace FILLMEIN
// with values assigned by the TTN console. However, for regression tests,
// we want to be able to compile these scripts. The regression tests define
// COMPILE_REGRESSION_TEST, and in that case we define FILLMEIN to a non-
// working but innocuous value.
# define FILLMEIN 0
# warning "You must replace the values marked FILLMEIN with real values from the TTN control panel!"
# define FILLMEIN (#dont edit this, edit the lines that use FILLMEIN)

// This EUI must be in little-endian format, so least-significant-byte
// first. When copying an EUI from ttnctl output, this means to reverse
// the bytes. For TTN issued EUIs the last bytes should be 0xD5, 0xB3,
// 0x70.
static const u1_t PROGMEM APPEUI[8]= { 0xEE, 0xE4, 0x03, 0xD0, 0x7E, 0xD5, 0xB3, 0x70 };
void os_getArtEui (u1_t* buf) { memcpy_P(buf, APPEUI, 8);}

// This should also be in little endian format, see above.
static const u1_t PROGMEM DEVEUI[8]= { 0x90, 0x45, 0x12, 0x32, 0x65, 0x89, 0x65, 0x34 };
void os_getDevEui (u1_t* buf) { memcpy_P(buf, DEVEUI, 8);}

// This key should be in big endian format (or, since it is not really a
// number but a block of memory, endianness does not really apply). In
// practice, a key taken from the TTN console can be copied as-is.
static const u1_t PROGMEM APPKEY[16] = { 0xC3, 0x9B, 0xBC, 0x57, 0x87, 0xA1, 0x36, 0xFE, 0x4B, 0xBF, 0xF3, 0xE2, 0xBD, 0xD2, 0x2D, 0x66 };
void os_getDevKey (u1_t* buf) {  memcpy_P(buf, APPKEY, 16);}

static uint8_t mydata[] = "OTAA";
static osjob_t sendjob;

// Schedule TX every this many seconds (might become longer due to duty
// cycle limitations).
const unsigned TX_INTERVAL = 60;

// Pin mapping for Dragino Lorashield
const lmic_pinmap lmic_pins = {
    .nss = 10,
    .rxtx = LMIC_UNUSED_PIN,
    .rst = 9,
    .dio = {2, 6, 7},
// DHT digital pin and sensor type
#define DHTPIN 4
#define DHTTYPE DHT22


void onEvent (ev_t ev) {
    Serial.print(": ");
    switch(ev) {
        case EV_SCAN_TIMEOUT:
        case EV_BEACON_FOUND:
        case EV_BEACON_MISSED:
        case EV_BEACON_TRACKED:
        case EV_JOINING:
        case EV_JOINED:
              u4_t netid = 0;
              devaddr_t devaddr = 0;
              u1_t nwkKey[16];
              u1_t artKey[16];
              LMIC_getSessionKeys(&netid, &devaddr, nwkKey, artKey);
              Serial.print("netid: ");
              Serial.println(netid, DEC);
              Serial.print("devaddr: ");
              Serial.println(devaddr, HEX);
              Serial.print("artKey: ");
              for (int i=0; i<sizeof(artKey); ++i) {
                Serial.print(artKey[i], HEX);
              Serial.print("nwkKey: ");
              for (int i=0; i<sizeof(nwkKey); ++i) {
                Serial.print(nwkKey[i], HEX);
			Serial.println(F("Successful OTAA Join..."));
            // Disable link check validation (automatically enabled
            // during join, but because slow data rates change max TX
	        // size, we don't use it in this example.
        || This event is defined but not used in the code. No
        || point in wasting codespace on it.
        || case EV_RFU1:
        ||     Serial.println(F("EV_RFU1"));
        ||     break;
        case EV_JOIN_FAILED:
        case EV_REJOIN_FAILED:
        case EV_TXCOMPLETE:
            Serial.println(F("EV_TXCOMPLETE (includes waiting for RX windows)"));
            if (LMIC.txrxFlags & TXRX_ACK)
              Serial.println(F("Received ack"));
            if (LMIC.dataLen) {
              Serial.print(F("Received "));
              Serial.println(F(" bytes of payload"));
            // Schedule next transmission
            os_setTimedCallback(&sendjob, os_getTime()+sec2osticks(TX_INTERVAL), do_send);
        case EV_LOST_TSYNC:
        case EV_RESET:
        case EV_RXCOMPLETE:
            // data received in ping slot
        case EV_LINK_DEAD:
        case EV_LINK_ALIVE:
        || This event is defined but not used in the code. No
        || point in wasting codespace on it.
        || case EV_SCAN_FOUND:
        ||    Serial.println(F("EV_SCAN_FOUND"));
        ||    break;
        case EV_TXSTART:
            Serial.print(F("Unknown event: "));
            Serial.println((unsigned) ev);

void do_send(osjob_t* j){
    // Check if there is not a current TX/RX job running
    if (LMIC.opmode & OP_TXRXPEND) {
        Serial.println(F("OP_TXRXPEND, not sending"));
    } else {
        uint32_t humidity = dht.readHumidity(false) * 100;
        uint32_t temperature = dht.readTemperature(false) * 100;
        Serial.println("Humidity: " + String(humidity));
        Serial.println("Temperature: " + String(temperature));
        byte payload[4];
        payload[0] = highByte(humidity);
        payload[1] = lowByte(humidity);
        payload[2] = highByte(temperature);
        payload[3] = lowByte(temperature); 
        //Prepare upstream data transmission at the next possible time.
        LMIC_setTxData2(1, payload, sizeof(payload), 0);
        Serial.println(F("Packet queued"));
    // Next TX is scheduled after TX_COMPLETE event.
void setup() {
    #ifdef VCC_ENABLE
    // For Pinoccio Scout boards
    pinMode(VCC_ENABLE, OUTPUT);
    digitalWrite(VCC_ENABLE, HIGH);

    #if defined(CFG_au921)
    Serial.println(F("Loading AU915/AU921 Configuration..."));

    // LMIC init
    // Reset the MAC state. Session and pending data transfers will be discarded.
    LMIC_setDrTxpow(DR_SF7, 14);
    LMIC_setClockError(MAX_CLOCK_ERROR * 1 / 100);
    // Start job (sending automatically starts OTAA too)

void loop() {