send coordinates over lorawan

2020-04-19 04:07:23 +01:00
parent 2c146ff224
commit 5a7003d621
6 changed files with 366 additions and 101 deletions
--- a/collar.cpp
+++ b/collar.cpp
@@ -1,131 +1,211 @@
+// 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 <TinyLoRa.h>
 #include <SPI.h>
-#include <LoRa.h>
-#include <TinyGPS++.h>
-#include <SoftwareSerial.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"

-unsigned long previousMillis = 0;
-const long interval = 5000;
-float lat = 0;
-float lng = 0;
+// Visit your thethingsnetwork.org device console
+// to create an account, or if you need your session keys.

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

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

-SoftwareSerial ss(6, 7);
+// Device Address (MSB)
+uint8_t DevAddr[4] = {0x26, 0x02, 0x12, 0xB6};

-typedef struct lora_status_s {
-  int sleep;
-} lora_status_t;
+/************************** Example Begins Here ***********************************/
+// Data Packet to Send to TTN
+unsigned char loraData[50] = {"hello LoRa"};

-static lora_status_t lora_status;
+// How many times data transfer should occur, in seconds
+const unsigned int sendInterval = 30;

-void transmitLora() {
-  // Encode as protobuf packet
-  if (lat && lng) {
-    uint8_t buffer[50] = {0};
-    Fenceless_CollarResponse m = Fenceless_CollarResponse_init_zero;
-    pb_ostream_t stream = pb_ostream_from_buffer(buffer, sizeof(buffer));
-    m.loc.x = lat;
-    m.loc.y = lng;
+// Pinout for Adafruit Feather 32u4 LoRa
+TinyLoRa lora = TinyLoRa(2, 10, 9);

-    int status = pb_encode(&stream, Fenceless_CollarResponse_fields, &m);
+// Pinout for Adafruit Feather M0 LoRa
+//TinyLoRa lora = TinyLoRa(3, 8, 4);

-    if (!status) {
-      Serial.println("Failed to encode");  
+const uint8_t N_POLY_MAX=100;
+float polyx[N_POLY_MAX];
+float polyy[N_POLY_MAX];
+int n_poly=0;
+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;
+}
+void clear_verts() {
+  n_poly=0;
+}
+int pnpoly(int nvert, float *vertx, float *verty, float testx, float testy)
+{ //from stack overflow
+  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;
+}
+int check_bounds(float x, float y) {
+  return pnpoly(n_poly, polyx, polyy, x, y);
+}
+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;
    }
-
-    Serial.print("Sending packet Lat / Long: ");
-    Serial.println(lat);
-    Serial.println(lng);
-
-    // send packet
-
-    LoRa.beginPacket();
-    LoRa.print((char *) buffer);
-    LoRa.endPacket();
-
+    push_vert(m.x,m.y);
+    return true;
  }
 }
-void updateGPS() {
-  // Gather GPS data
-  if (gps.location.isValid()) {
-    lat = gps.location.lat();
-    lng = gps.location.lng(); 
-  } else {
-    lat = 0;
-    lng = 0;  
+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);
  }
 }
-ISR(TIMER1_OVF_vect) { 
-  // handle timer overflow interrupt at 1 per second
-  updateGPS();
-  if(!gps.location.isValid()) {
-    Serial.println("Seeking GPS");
+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;
  }
-  if(sending && gps.location.isValid()) {
-    if(lora_status.sleep) {
-    }
-    transmitLora();
+  return pb_encode(stream, Fenceless_Coordinate_fields, field);
+}
+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));
 }
-void initialize_timer() {
-  TCCR1A = 0;
-  TCCR1B = 0;
-  TCNT1 = 34286; // timer preload
-  TCCR1B |= (1<<CS12); // prescale: 256 bits
-  TIMSK1 |= (1<<TOIE1); // overflow interrupt
-  interrupts();
+int recieved = 0;
+void on_recieve(int n) {
+  recieved = 1;
 }
-void setup() {
+void setup()
+{
+  delay(2000);
  Serial.begin(9600);
-  ss.begin(9600);
+  while (! Serial);

-  while (!Serial);
+  delay(4000);
+  // Initialize pin LED_BUILTIN as an output
+  pinMode(LED_BUILTIN, OUTPUT);

-  Serial.println("LoRa Transceiver");
-
-  if (!LoRa.begin(915E6)) {
-    Serial.println("Starting LoRa failed!");
-    while (1);
+  // Initialize LoRa
+  Serial.print("Starting LoRa...");
+  // define multi-channel sending
+  lora.setChannel(MULTI);
+  // set datarate
+  lora.setDatarate(SF7BW125);
+  if(!lora.begin())
+  {
+    Serial.println("Failed");
+    Serial.println("Check your radio");
+    while(true);
  }
-  LoRa.setSpreadingFactor(7);

-  lora_status.sleep = 1;
-  //lora.sleep();
+  Fenceless_Coordinates coords;
+  coords.isr = 10;
+  coords.coord0.x = 1; coords.coord0.y = 2;
+  coords.coord1.x = 1; coords.coord1.y = 2;
+  coords.coord2.x = 1; coords.coord2.y = 2;
+  coords.coord3.x = 1; coords.coord3.y = 2;
+  coords.coord4.x = 1; coords.coord4.y = 2;
+  coords.coord5.x = 1; coords.coord5.y = 2;
+  coords.coord6.x = 1; coords.coord6.y = 2;
+  coords.coord7.x = 1; coords.coord7.y = 2;
+  coords.coord8.x = 1; coords.coord8.y = 2;
+  coords.coord9.x = 1; coords.coord9.y = 2;

-  initialize_timer();
+  pb_ostream_t stream;
+  stream  = pb_ostream_from_buffer(loraData, sizeof(loraData));
+  int err = pb_encode(&stream, Fenceless_Coordinates_fields, &coords);
+  // Optional set transmit power. If not set default is +17 dBm.
+  // Valid options are: -80, 1 to 17, 20 (dBm).
+  // For safe operation in 20dBm: your antenna must be 3:1 VWSR or better
+  // and respect the 1% duty cycle.
+
+  lora.setPower(1);
+  Serial.println("OK");
 }

-void loop() {
-  /* Get user input
-  */
-  if(Serial.available()) {
-    char n = Serial.read();
-    if(n=='p') {
-      sending ? Serial.println("Sending is: disabled") : Serial.println("Sending is: enabled");
-      sending = !sending;
-    } else {
-      Serial.println("Type the letter 'p' to toggle sending");
-    }
-  }
-  /* GPS data recieved */
-  while (ss.available() > 0) {
-    gps.encode(ss.read());
-  }
-  /* Lora data recieved */
-  int packetSize = LoRa.parsePacket();
-  if (packetSize) {
-    Serial.print("Received Packet: ");
-    while (LoRa.available()) {
-      Serial.print((char) LoRa.read());  
-    }
-    Serial.println();
+void loop()
+{
+  Serial.println("Sending LoRa Data...");
+  lora.sendData(loraData, sizeof(loraData), 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++;
+
+  // blink LED to indicate packet sent
+  digitalWrite(LED_BUILTIN, HIGH);
+  delay(1000);
+  digitalWrite(LED_BUILTIN, LOW);
+  
+  Serial.println("delaying...");
+
+  if(recieved) {
+    Serial.println("Recieved something");
+  } else {
+    Serial.println("Nothing yet");
  }
+  delay(sendInterval * 1000);
 }