main.cpp

#include <Arduino.h>


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

// The TinyGPS++ object
char s[16]; // used to sprintf for OLED display

static uint8_t mydata[] = {0x02,0x01,0x01};

// 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] ={ /*Your APPEUI*/ };
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] ={ /* Your DEVEUI*/ };
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 ttnctl can be copied as-is.
// 
static const u1_t PROGMEM APPKEY[16] = { /* .... your APPKEY */  };
void os_getDevKey (u1_t* buf) {
 memcpy_P(buf, APPKEY, 16);
}
static osjob_t sendjob;
// Schedule TX every this many seconds (might become longer due to duty
// cycle limitations).

U8X8_SSD1306_128X64_NONAME_SW_I2C u8x8(/* clock=*/ 15, /* data=*/ 4, /* reset=*/ 16);

const unsigned TX_INTERVAL = 30;
// Pin mapping
const lmic_pinmap lmic_pins = {
 .nss = 18,
 .rxtx = LMIC_UNUSED_PIN,
 .rst = 14,
 .dio = {26, 33, 32},
};


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 {
       // Prepare upstream data transmission at the next possible time.
       LMIC_setTxData2(1, mydata, sizeof(mydata)-1, 0);
       Serial.println(F("Packet queued"));
   }
   // Next TX is scheduled after TX_COMPLETE event.
}
void onEvent (ev_t ev) {
   Serial.print(os_getTime());
   Serial.print(": ");
   switch(ev) {
       case EV_SCAN_TIMEOUT:
           Serial.println(F("EV_SCAN_TIMEOUT"));
           u8x8.println(F("EV_SCAN_TIMEOUT"));
           break;
       case EV_BEACON_FOUND:
           Serial.println(F("EV_BEACON_FOUND"));
           u8x8.println(F("EV_BEACON_FOUND"));
           break;
       case EV_BEACON_MISSED:
           Serial.println(F("EV_BEACON_MISSED"));
           u8x8.println(F("EV_BEACON_MISSED"));
           break;
       case EV_BEACON_TRACKED:
           Serial.println(F("EV_BEACON_TRACKED"));
           u8x8.println(F("EV_BEACON_TRACKED"));
           break;
       case EV_JOINING:
           Serial.println(F("EV_JOINING"));
           u8x8.println("EV_JOINING");
           LMIC_setLinkCheckMode(0);
           break;
       case EV_JOINED:
           Serial.println(F("EV_JOINED"));
           u8x8.println(F("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.println("");
             Serial.print("nwkKey: ");
             for (int i=0; i<sizeof(nwkKey); ++i) {
               Serial.print(nwkKey[i], HEX);
             }
             Serial.println("");
           u8x8.println("EV_JOINED");
           }
           // 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.
           LMIC_setLinkCheckMode(0);
           break;
       case EV_RFU1:
           Serial.println(F("EV_RFU1"));
break;
       case EV_JOIN_FAILED:
           Serial.println(F("EV_JOIN_FAILED"));
           break;
       case EV_REJOIN_FAILED:
           Serial.println(F("EV_REJOIN_FAILED"));
           break;
       case EV_TXCOMPLETE:
       u8x8.clear();
           Serial.println(F("EV_TXCOMPLETE (includes waiting for RX windows)"));
           u8x8.println("EV_TXCOMPLETE");
           if (LMIC.txrxFlags & TXRX_ACK){
             Serial.println(F("Received ack"));
             u8x8.println("received: ack");
           }
           if (LMIC.dataLen) {
             Serial.println(F("Received "));
             Serial.println(LMIC.dataLen);
             Serial.println(F(" bytes of payload"));
             u8x8.println(F("Received "));
             u8x8.println(LMIC.dataLen);
             u8x8.println(F(" bytes of payload"));
           }
           // Schedule next transmission
           os_setTimedCallback(&sendjob, os_getTime()+sec2osticks(TX_INTERVAL), do_send);
           break;
       case EV_LOST_TSYNC:
           Serial.println(F("EV_LOST_TSYNC"));
           break;
       case EV_RESET:
           Serial.println(F("EV_RESET"));
           break;
       case EV_RXCOMPLETE:
           // data received in ping slot
           Serial.println(F("EV_RXCOMPLETE"));
           break;
       case EV_LINK_DEAD:
           Serial.println(F("EV_LINK_DEAD"));
           break;
       case EV_LINK_ALIVE:
           Serial.println(F("EV_LINK_ALIVE"));
           break;
        default:
           Serial.println(F("Unknown event"));
           break;
   }
}


void setup() {
   Serial.begin(115200);
 while (millis() < 5000) {
   Serial.print("millis() = "); Serial.println(millis());
   delay(500);
 }
 u8x8.begin();
 u8x8.setFont(u8x8_font_chroma48medium8_r);
 u8x8.drawString(0,0,"Starting");
   Serial.println(F("Starting"));

   // LMIC init
   os_init();
   // Reset the MAC state. Session and pending data transfers will be discarded.
   LMIC_reset();
   //LMIC_setLinkCheckMode(1);
   //LMIC_setAdrMode(1);
   LMIC_setClockError(MAX_CLOCK_ERROR * 10 / 100);
   LMIC_setDrTxpow(DR_SF9,14);
   // Start job (sending automatically starts OTAA too)
   do_send(&sendjob);
}

void loop() {
   os_runloop_once();
}