collar/collar.cpp

// Hello LoRa - ABP TTN Packet Sender (Multi-Channel)
// Tutorial Link: https://learn.adafruit.com/the-things-network-for-feather/using-a-feather-32u4
//
// Adafruit invests time and resources providing this open source code.
// Please support Adafruit and open source hardware by purchasing
// products from Adafruit!
//
// Copyright 2015, 2016 Ideetron B.V.
//
// Modified by Brent Rubell for Adafruit Industries, 2018
/************************** Configuration ***********************************/
#include <TinyGPS++.h>
#include <SoftwareSerial.h>
#include <TinyLoRa.h>
#include <SPI.h>
#include "Base64.h"
#include "gateway/message.pb.h"

#include "pb_common.h"
#include "pb.h"
#include "pb_encode.h"
#include "pb_decode.h"

#include "gateway/message.pb.h"

// Visit your thethingsnetwork.org device console
// to create an account, or if you need your session keys.

// Network Session Key (MSB)
uint8_t NwkSkey[16] = {0x52, 0x92, 0xC0, 0x72, 0x2D, 0x3C, 0x55, 0x5E, 0xE4, 0xB9, 0x9E, 0x9B, 0x88, 0x66, 0x47, 0xF1};

// Application Session Key (MSB)
uint8_t AppSkey[16] = {0xC4, 0x30, 0xEF, 0x56, 0x4F, 0x6D, 0xA2, 0x56, 0x1F, 0x15, 0x2F, 0xB8, 0x62, 0xC7, 0xCA, 0xC2};

// Device Address (MSB)
uint8_t DevAddr[4] = {0x26, 0x02, 0x12, 0xB6};

/************************** Example Begins Here ***********************************/
// Data Packet to Send to TTN
unsigned char loraData[50] = {"hello LoRa"};

// How many times data transfer should occur, in seconds
// const unsigned int sendInterval = 30;
const unsigned int sendInterval = 60;

// Pinout for Adafruit Feather 32u4 LoRa
TinyLoRa lora = TinyLoRa(2, 10, 9);
TinyGPSPlus gps;
SoftwareSerial ss(6, 7);

/****************************************************
 * Track each pair of X and Y coordinates
 * - arrays are used by the pnpoly function
 ***************************************************/
const uint8_t N_POLY_MAX=100;
float polyx[N_POLY_MAX];
float polyy[N_POLY_MAX];
int n_poly=0;

/****************************************************
 * Add a coordinate to the arrays
 * - stores a total of N_POLY_MAX pairs
 ***************************************************/
int push_vert(float x, float y) {
  if(n_poly>N_POLY_MAX)
    return 0;
  polyx[n_poly]=x;
  polyy[n_poly]=y;
  n_poly++;
  return 1;
}
/****************************************************
 * 'Clear' pairs of coordinates
 ***************************************************/
void clear_verts() {
  n_poly=0;
}
/****************************************************
 * Check a pair of coordinates against two lists
 * of vertices
 * - https://wrf.ecse.rpi.edu//Research/Short_Notes/pnpoly.html
 ***************************************************/
int pnpoly(int nvert, float *vertx, float *verty, float testx, float testy)
{ //from stack overflow, check that coordinate is within polygon boundary
  int i, j, c = 0;
  for (i = 0, j = nvert-1; i < nvert; j = i++) {
    if ( ((verty[i]>testy) != (verty[j]>testy)) &&
     (testx < (vertx[j]-vertx[i]) * (testy-verty[i]) / (verty[j]-verty[i]) + vertx[i]) )
       c = !c;
  }
  return c;
}
/****************************************************
 * Test a coordinate against all vertices
 ***************************************************/
int check_bounds(float x, float y) {
  return pnpoly(n_poly, polyx, polyy, x, y);
}
/****************************************************
 * nanopb callback
 ***************************************************/
bool Fenceless_Coordinates_callback(pb_istream_t *stream, const pb_field_iter_t *field, void **arg) {
  Serial.println("Called");
  while(stream->bytes_left) {
	  Fenceless_Coordinate m = Fenceless_Coordinate_init_zero;
    if(!pb_decode(stream, Fenceless_Coordinate_fields, &m)) {
      return false;
    }
    push_vert(m.x,m.y);
    return true;
  }
}
/****************************************************
 * Load coordinates from protobuff stream
 * - currently a maximum of 10 coordinates
 * - loading arrays in nanopb does not appear
 *   to work.
 ***************************************************/
void import_protobuf(uint8_t *protobuffer, uint32_t size) {
  Fenceless_Coordinates m;
	pb_istream_t stream = pb_istream_from_buffer(protobuffer, size);
  int status = pb_decode(&stream, Fenceless_Coordinates_fields, &m);
  if(!status){
    Serial.println("Failed to decode");
  }
  clear_verts();
  switch(m.isr) {
    case 10:
      push_vert(m.coord9.x, m.coord9.y);
    case 9:
      push_vert(m.coord8.x, m.coord8.y);
    case 8:
      push_vert(m.coord7.x, m.coord7.y);
    case 7:
      push_vert(m.coord6.x, m.coord6.y);
    case 6:
      push_vert(m.coord5.x, m.coord5.y);
    case 5:
      push_vert(m.coord4.x, m.coord4.y);
    case 4:
      push_vert(m.coord3.x, m.coord3.y);
    case 3:
      push_vert(m.coord2.x, m.coord2.y);
      push_vert(m.coord1.x, m.coord1.y);
      push_vert(m.coord0.x, m.coord0.y);
  }
}
/****************************************************
 * nanopb callback
 ***************************************************/
bool Fenceless_Coordinates_encode(pb_ostream_t *stream, const pb_field_iter_t *field, void * const * arg) {
  Serial.println("Encode called");
  return false;
  Fenceless_Coordinate c = *(Fenceless_Coordinate*)field->pData;
  if(!pb_encode_tag_for_field(stream, field)) {
    return false;
  }
  return pb_encode(stream, Fenceless_Coordinate_fields, field);
}
/****************************************************
 * live test of protobuf
 ***************************************************/
void test() {
  Serial.println("Testing protobuf");
  uint8_t buffer[100] = {0};
  Fenceless_Coordinates m = Fenceless_Coordinates_init_zero;
  pb_ostream_t stream = pb_ostream_from_buffer(buffer, sizeof(buffer));
  int status = pb_encode(&stream, Fenceless_Coordinates_fields, &m);
  if(!status){
    Serial.println("Failed to encode");
  }
  import_protobuf(buffer, sizeof(buffer));
}
/****************************************************
 * Initialize values
 ***************************************************/
void setup()
{
  // give GPS time to start up
  delay(1000);
 /****************************************************
  * Configure USART
  * - onboard serial to usb
  * - software serial connected to GPS module
  ***************************************************/
  Serial.begin(9600);
  ss.begin(4800);
  while (! Serial);

 /****************************************************
  * Configure USART
  * - onboard serial to usb
  * - software serial connected to GPS module
  ***************************************************/
  pinMode(LED_BUILTIN, OUTPUT);

  // Initialize GPS - GPS does not work indoors - This will block until GPS available 
  // Serial.println("Starting GPS");
  // while(!gps.location.isValid()) {
  //   while(ss.available()>0) {
  //     gps.encode(ss.read());
  //   }
  //   if (millis() > 5000 && gps.charsProcessed() < 10)
  //   {
  //     Serial.println(F("No GPS detected: check wiring."));
  //     while(true);
  //   }
  // }

 /****************************************************
  * Configure LoRa
  * - set to multi-channel
  * - set datarate
  * - start communication
  * - set transmission power
  ***************************************************/
  Serial.print("Starting LoRa...");
  lora.setChannel(MULTI);
  lora.setDatarate(SF12BW125); // SF7BW125
  if(!lora.begin())
  {
    Serial.println("Failed");
    Serial.println("Check your radio");
    while(true);
  }
  lora.setPower(15); // 1

 /****************************************************
  * Configure Timer Interrupt
  * - set for one second intervals
  ***************************************************/
  TCCR1A = 0;
  TCCR1B = 0;

  TCNT1  = 34286;   // preload timer
  TCCR1B |= (1 << CS12);    // 256 prescaler
  TIMSK1 |= (1 << TOIE1);   // enable timer overflow interrupt

  Serial.println("OK");
}

/****************************************************
 * Timer interrupt service routine
 * - this logic could be moved to loop()
 *   and be controlled by a state variable
 * - generates a protobuf stream with current
 *   GPS coordinate values
 * - sends buffer over LoRaWAN on a given
 *   send interval
 ***************************************************/
int sendCounter = 0;
ISR(TIMER1_OVF_vect) {
  digitalWrite(LED_BUILTIN, sendCounter%2);
  if(sendCounter==0 && gps.location.isValid()) {
    Serial.println("Valid gps");

    // reset send counter
    sendCounter = sendInterval;

    Fenceless_CollarResponse coord;
    coord.loc.x = gps.location.lat();
    coord.loc.y = gps.location.lng();

    pb_ostream_t stream;
    stream  = pb_ostream_from_buffer(loraData, sizeof(loraData));
    int err = pb_encode(&stream, Fenceless_CollarResponse_fields, &coord);

    // Generate copy pasteable base64
    // char base64[50];
    // base64_encode(base64, (char*)loraData, stream.bytes_written);
    // Serial.println(stream.bytes_written);
    // Serial.println(base64);

    Serial.println("Sending LoRa Data...");
    lora.sendData(loraData, stream.bytes_written, lora.frameCounter);
    // Optionally set the Frame Port (1 to 255)
    // uint8_t framePort = 1;
    // lora.sendData(loraData, sizeof(loraData), lora.frameCounter, framePort);
    Serial.print("Frame Counter: ");Serial.println(lora.frameCounter);
    lora.frameCounter++;
  } 
  else if (!gps.location.isValid()) {
    Serial.println("waiting for gps");
  } 
  else {
    Serial.println("delaying til next frame counter");
  } 
  sendCounter--;
}
/****************************************************
 * Main loop
 * - feeds data to GPS module as it is made
 *   available
 ***************************************************/
void loop()
{
  // For later when recieving from gateway is implemented
  // if(recieved) {
  //   Serial.println("Recieved something");
  // } else {
  //   Serial.println("Nothing yet");
  // }
  if(ss.available()>0)
    gps.encode(ss.read());
  delay(1000);
}