Connecting Autonomo with LoRaBee to Arduino with LoraWAN gateway

Hi,

I’ve uploaded a sketch to my autonomo that sends ‘Hello World’ and I’m trying to get it to communicate with my LoraWAN gateway. The autonomo is connected to an RN2483 via Serial1 and is also connected to the battery and solar panel. The LoraWAN gateway is an arduino uno connected to my machine, with the RN2483 gateway attached.

I am having some trouble receiving information and was wondering what I’m doing wrong? Still very new to lora and arduino.

The autonomo code is here:

// Copyright © 2016 Johan Stokking
// MIT Licensed

define DEBUG
include <Sodaq_RN2483.h>

define debugSerial SerialUSB
define loraSerial Serial1

// Change the DevAddr
const uint8_t devAddr[4] =
{
0x00, 0x00, 0xAA, 0x01
};

// Public Semtech key
const uint8_t appSKey[16] =
{
0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6, 0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3C
};

// Public Semtech key
const uint8_t nwkSKey[16] =
{
0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6, 0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3C
};

void setup()
{
pinMode(BEE_VCC, OUTPUT);

debugSerial.begin(57600);
loraSerial.begin(LoRaBee.getDefaultBaudRate());

// Wait for the serial te become available
while (!debugSerial);
debugSerial.println(“Start”);

// Turn the LoRaBee on
digitalWrite(BEE_VCC, HIGH);

// Connect the LoRabee
LoRaBee.setDiag(debugSerial);
if (LoRaBee.initABP(loraSerial, devAddr, appSKey, nwkSKey, true))
debugSerial.println(“Connection to the network was successful.”);
else
debugSerial.println(“Connection to the network failed!”);
}

void loop()
{
debugSerial.println(“Sleeping for 5 seconds before starting sending out test packets.”);
delay(5000);

// Send 10 packets, with at least 5 seconds delay after each transmission (more seconds if the device is busy)
uint8_t i = 10;
while (i > 0)
{
String message = “Hello world! This is message #” + String(i, DEC);
uint8_t payload[message.length() + 1];
message.getBytes(payload, message.length() + 1);

switch (LoRaBee.send(1, payload, message.length()))
{
  case NoError:
    debugSerial.println("Successful transmission.");
    i--;
    break;
  case NoResponse:
    debugSerial.println("There was no response from the device.");
    break;
  case Timeout:
    debugSerial.println("Connection timed-out. Check your serial connection to the device! Sleeping for 20sec.");
    delay(20000);
    break;
  case PayloadSizeError:
    debugSerial.println("The size of the payload is greater than allowed. Transmission failed!");
    break;
  case InternalError:
    debugSerial.println("Oh No! This shouldn't happen. Something is really wrong! Try restarting the device!\r\nThe program will now halt.");
    while (1) {};
    break;
  case Busy:
    debugSerial.println("The device is busy. Sleeping for 10 extra seconds.");
    delay(10000);
    break;
  case NetworkFatalError:
    debugSerial.println("There is a non-recoverable error with the network connection. You should re-connect.\r\nThe program will now halt.");
    while (1) {};
    break;
  case NotConnected:
    debugSerial.println("The device is not connected to the network. Please connect to the network before attempting to send data.\r\nThe program will now halt.");
    while (1) {};
    break;
  case NoAcknowledgment:
    debugSerial.println("There was no acknowledgment sent back!");
    break;
  default:
    break;
}
delay(5000);

}

while (1) { } // block forever
}

The Arduino UNO with LoRaWan module code is here:

/*

  • Multiprotocol Radio Shield with RFID/NFC 13.56MHz
  • Copyright © Libelium Comunicaciones Distribuidas S.L.
  • http://www.libelium.com
  • This program is free software: you can redistribute it and/or modify
  • it under the terms of the GNU General Public License as published by
  • the Free Software Foundation, either version 3 of the License, or
  • (at your option) any later version.
  • a
  • This program is distributed in the hope that it will be useful,
  • but WITHOUT ANY WARRANTY; without even the implied warranty of
  • MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  • GNU General Public License for more details.
  • You should have received a copy of the GNU General Public License
  • along with this program. If not, see http://www.gnu.org/licenses/.
  • Version: 1.1
  • Design: David Gascón
  • Implementation: Ahmad Saad
    */

include <multiprotocolShield.h>
include <Wire.h>
include <MCP23008.h>

uint8_t dataRX[35];//Receive buffer.
uint8_t dataTX[35];//Transmit buffer.
uint8_t _UID[4]; // stores the UID (unique identifier) of a card.
uint8_t blockData[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
};//Data to write (16 bytes).
uint8_t keyAccess[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF} ;// stores the key or password.
uint8_t address = 0x04;//Address to read.
uint8_t ATQ[2];//Answer to request
uint8_t state;//state of the process
uint8_t aux[16];//Auxiliary buffer.

void setup()
{
//Start serial port 115200 bps:
Serial.begin(115200);
delay(100);
Serial.print(“RFID/NFC @ 13.56 MHz module started”);
delay(1000);

socket0.ON(); // <------RFID SOCKET
delay(100);
socket0.setMUX(); // <------ Configure the MUX at MUX0

//! It is needed to launch a simple command to synchronize
getFirmware();
configureSAM();
}
void loop()
{
// Read the RFID TAG
readTAG();
delay(1000);

sendXBee();
delay(1000);

}
//**********************************************************************

void sendXBee()
{
socket1.ON();
delay(100);
socket1.setMUX(); // <------ Configure the MUX at MUX0

Serial.begin(9600);
delay(1000);

Serial.print( “The Card NUID : “);
print(_UID , 4);
Serial.print(”\n”);

Serial.print(“Data read : “);
print(aux , 16);
Serial.print(”\n”);

delay(1000);

Serial.begin(115200);

delay(100);
socket0.setMUX(); // <------ Configure the MUX at MUX0

}

//**********************************************************************
void readTAG()
{

socket0.setMUX(); // <------ Configure the MUX at MUX0
delay(100);

Serial.print("\n");
Serial.println(“Ready to read…”);
/////////////////////////////////////////////////////////////
//Get the Card Identifier
init(_UID, ATQ);
Serial.print("\n");
Serial.print( “The Card NUID : “);
print(_UID , 4);
/////////////////////////////////////////////////////////////
//Authenticate a block with his keyAccess
state = authenticate(_UID, address, keyAccess);
Serial.print(”\n”);

if ( state == 0) {
Serial.println(“Authentication block OK”);
} else {
Serial.println(“Authentication failed”);
}
/////////////////////////////////////////////////////////////
//Write blockData in a address, after authentication.
if ( state == 0 ) {
state = writeData(address, blockData);
Serial.print("\n");
if ( state == 0) {
Serial.println(“Write block OK”);
} else {
Serial.println(“Write failed”);
}
/////////////////////////////////////////////////////////////
//Read from address after authentication
state = readData(address, aux);
Serial.print("\n");

if (state == 0) {
  Serial.println("Read block OK");
} else {
  Serial.println("Read failed");
}

Serial.print("Data read : ");
print(aux , 16);
Serial.print("\n");

}
delay(2000);

}

//**********************************************************************
//!The goal of this command is to detect as many targets (maximum MaxTg)
// as possible in passive mode.
uint8_t init(uint8_t *UID , uint8_t *ATQ) //! Request InListPassive
{
Serial.flush();

dataTX[0] = 0x04; // Length
lengthCheckSum(dataTX); // Length Checksum
dataTX[2] = 0xD4;
dataTX[3] = 0x4A; // Code
dataTX[4] = 0x01; //MaxTarget
dataTX[5] = 0x00; //BaudRate = 106Kbps
dataTX[6] = 0x00; // Clear check Sum position
checkSum(dataTX);

sendTX(dataTX , 7 , 23);

for (int i = 17; i < (21) ; i++) {
_UID[i - 17] = dataRX[i];
UID[i - 17] = _UID[i - 17];
}

ATQ[0] = dataRX[13];
ATQ[1] = dataRX[14];

if ((dataRX[9] == 0xD5) & (dataRX[10] == 0x4B) & (dataRX[11] == 0x01)) {
return 0;
} else {
return 1;
}
}
//**********************************************************************
//!A block must be authenticated before read and write operations
uint8_t authenticate(uint8_t *UID, uint8_t blockAddress, uint8_t *keyAccess)
{
dataTX[0] = 0x0F;
lengthCheckSum(dataTX);
dataTX[2] = 0xD4;
dataTX[3] = 0x40; // inDataEchange
dataTX[4] = 0x01; //Number of targets
dataTX[5] = 0x60; // Authentication code
dataTX[6] = blockAddress;

for (int i = 0; i < 6 ; i++) {
dataTX[i + 7] = keyAccess[i];
}

dataTX[13] = UID[0]; dataTX[14] = UID[1];
dataTX[15] = UID[2]; dataTX[16] = UID[3];
dataTX[17] = 0x00;
checkSum(dataTX);
sendTX(dataTX , 18 , 14);

if ((dataRX[9] == 0xD5) & (dataRX[10] == 0x41) & (dataRX[11] == 0x00)) {
return 0;
} else {
return 1;
}
}
//**********************************************************************
//!Write 16 bytes in address .
uint8_t writeData(uint8_t address, uint8_t *blockData) //!Writing
{
Serial.print(" ");
dataTX[0] = 0x15;
lengthCheckSum(dataTX); // Length Checksum
dataTX[2] = 0xD4;
dataTX[3] = 0x40; //inDataEchange CODE
dataTX[4] = 0x01; //Number of targets
dataTX[5] = 0xA0; //Write Command
dataTX[6] = address; //Address

for (int i = 0; i < 16; i++) {
dataTX[i + 7] = blockData[i];
}

dataTX[23] = 0x00;
checkSum(dataTX);
sendTX(dataTX , 24 , 14);

if ((dataRX[9] == 0xD5) & (dataRX[10] == 0x41) & (dataRX[11] == 0x00)) {
return 0;
} else {
return 1;
}
}
//**********************************************************************
//!Read 16 bytes from address .
uint8_t readData(uint8_t address, uint8_t *readData) //!Reading
{
Serial.print(" ");

dataTX[0] = 0x05;
lengthCheckSum(dataTX); // Length Checksum
dataTX[2] = 0xD4; // Code
dataTX[3] = 0x40; // Code
dataTX[4] = 0x01; // Number of targets
dataTX[5] = 0x30; //ReadCode
dataTX[6] = address; //Read address
dataTX[7] = 0x00;
checkSum(dataTX);
sendTX(dataTX , 8, 30);
memset(readData, 0x00, 16);

if ((dataRX[9] == 0xD5) & (dataRX[10] == 0x41) & (dataRX[11] == 0x00)) {
for (int i = 12; i < 28; i++) {
readData[i - 12] = dataRX[i];
}
return 0;
} else {
return 1;
}
}
//**********************************************************************
//!The PN532 sends back the version of the embedded firmware.
bool getFirmware(void) //! It is needed to launch a simple command to synchronize
{
Serial.print(" ");

memset(dataTX, 0x00, 35);
dataTX[0] = 0x02; // Length
lengthCheckSum(dataTX); // Length Checksum
dataTX[2] = 0xD4; // CODE
dataTX[3] = 0x02; //TFI
checkSum(dataTX); //0x2A; //Checksum

sendTX(dataTX , 5 , 17);
Serial.print("\n");
Serial.print("Your Firmware version is : ");

for (int i = 11; i < (15) ; i++) {
Serial.print(dataRX[i], HEX);
Serial.print(" “);
}
Serial.print(”\n");
}

//**********************************************************************
//!Print data stored in vectors .
void print(uint8_t * _data, uint8_t length)
{
for (int i = 0; i < length ; i++) {
Serial.print(_data[i], HEX);
Serial.print(" “);
}
Serial.print(”\n");
}
//**********************************************************************
//!This command is used to set internal parameters of the PN532,
bool configureSAM(void)//! Configure the SAM
{
Serial.print(" ");

dataTX[0] = 0x05; //Length
lengthCheckSum(dataTX); // Length Checksum
dataTX[2] = 0xD4;
dataTX[3] = 0x14;
dataTX[4] = 0x01; //Normal mode
dataTX[5] = 0x14; // TimeOUT
dataTX[6] = 0x00; // IRQ
dataTX[7] = 0x00; // Clean checkSum position
checkSum(dataTX);

sendTX(dataTX , 8, 13);
}
//**********************************************************************
//!Send data stored in dataTX
void sendTX(uint8_t *dataTX, uint8_t length, uint8_t outLength)
{
Serial.print(char(0x00));
Serial.print(char(0x00));
Serial.print(char(0xFF));

for (int i = 0; i < length; i++) {
Serial.print(char(dataTX[i]));
}

Serial.print(char(0x00));
getACK();
waitResponse(); // 1C - receive response
getData(outLength);
}
//**********************************************************************
//!Wait for ACK response and stores it in the dataRX buffer
void getACK(void)
{
delay(5);
waitResponse();
for (int i = 0; i < 5 ; i++) {
dataRX[i] = Serial.read();
}
}
//**********************************************************************
//!Wait the response of the module
void waitResponse(void)
{
int val = 0xFF;
int cont = 0x00;
while (val != 0x00) {
val = Serial.read();
delay(5);
cont ++;
}
}
//**********************************************************************
//!Get data from the module
void getData(uint8_t outLength)
{
for (int i = 5; i < outLength; i++) {
dataRX[i] = Serial.read(); // read data from the module.
}
}
//**********************************************************************
//!Calculates the checksum and stores it in dataTX buffer
void checkSum(uint8_t dataTX)
{
for (int i = 0; i < dataTX[0] ; i++) {
dataTX[dataTX[0] + 2] += dataTX[i + 2];
}
byte(dataTX[dataTX[0] + 2] = - dataTX[dataTX[0] + 2]);
}
//
*********************************************************************
//!Calculates the length checksum and stores it in the buffer.
uint8_t lengthCheckSum(uint8_t *dataTX)
{
dataTX[1] = byte(0x100 - dataTX[0]);
}