Victor Altamirano, Alejandro Sanchez, JulietaAltamirano

Published August 28, 2020 © MIT

LoraDOG

Helium powered IoT solution to track your best friends during Kennel services.

AdvancedFull instructions provided20 hours1,652

Things used in this project

Hardware components

Helium Developer Kit

Pycom FiPy

Laptop as NodeRED Server

Software apps and online services

Helium Console

Arduino IDE

Node-RED

Amazon Web Services AWS IoT

Amazon Web Services AWS SNS

Amazon Web Services AWS Lambda

Amazon Web Services AWS DynamoDB

Pycom Pymakr Plugin

Hand tools and fabrication machines

Apple iPad

Story

LoraDOG

Video Demo:

Introduction and problem

If you have a dog, cat or any pet that needs to go into a kennel when travelling, and be left in the hands of airlines or moving services, you know how stressful and problematic it is for your precious friends.

The main problem thus is: The horrid care pets get when they are transported.

Regarding the pet's safety and comfort:

Sometimes we need to send pets with an airline service for travel to another country or just around the corner. How can we be sure they're fine at all times? Take into consideration how baggage is treated.

And secondly, have we ever feared that our dog goes astray and you can never find it again, the following project might have a solution for that.

Always use technology to improve the world, if you are a black hat or gray hat hacker please abstain at this point......... or at least leave your like to make me feel less guilty XP.

Solution:

Solving for the pet's safety and comfort:

I will develop an integral IoT solution to monitor the pet’s environment based on Helium Developer Kit, powered by LoraWAN connectivity and Helium gateway service, in order to ensure their well-being throughout their journey. All this also integrated with a Helium Console with AWS as MQTT server and NodeRed based platform which, in addition to showing the status of the pet in real time, also sends notifications at the frequency that is convenient.

The current monitoring solutions are restricted to only lifeless packages, this making the continuous monitoring of pets a novelty. It is useful because thanks to this system pet owners can be 100% sure that their pets will be well and can monitor and follow them throughout their flight or any travel.

Connection Diagram:

Kit Assembly:

Kit Elements:

Connect the Kit.

Put everything in a case.

Pycom Gateway:

Create Helium Account:

The first step is to create an account in the helium console, this process will help us to obtain the credentials that we will input in our kit later.

https://console.helium.com/

We go to the Devices tab to create the credentials of our first device.

Within the platform we will create a device to obtain the connection credentials.

We save these values for the configuration of our device.

Kit Setup:

All the guides needed to program the kit with Arduino IDE are in the official helium guide.

arduino | Helium Documentation

Once we have successfully completed the helium guide we will download and open the document in the "ArduinoIDE" folder and open it.

Add the following libraries:

NOTE: The libraries weren't fully compatible with the board, but after fixing them a bit, I did a push to the official githubs to help the open source community.

Now we will put the credentials that we obtained in the Helium Console.

If all goes well, you should be able to flash the code in the kit.

IFyou are in an area within the Helium coverage, go to the Checkpoint section.

Check the Coverage in your Region. https://network.helium.com/coverage

Miner Creation:

In this case, the creation of a miner in AWS is perfectly detailed in the official documentation that Helium provides:

https://developer.helium.com/blockchain/run-your-own-miner

The only data that we will need in this case after running the miner will be the IPv4 Public IP:

The miner generates a pseudo-random name, in the case of our Miner we obtained the following name.

Pycom Setup:

The Gateway configuration is carried out with a Fipy of the Pycom brand.

https://pycom.io/product/fipy/

In order to configure it correctly, we must first follow the official guide to configure and activate it on your Pybytes platform.

https://docs.pycom.io/gettingstarted/

I recommend reading it in detail since the board also has many more applications.

Gateway Setup:

Note: in our case we use the Pymakr extension in Visual Studio Code.

https://docs.pycom.io/pymakr/installation/vscode/

Once the previous section is finished, we must download the folder called "Pycom Helium Gateway".

We open the folder with VS code to start editing the configuration of the gateway.

We have to configure the following parameters inside our config.py file

These are the constants that we will put in our code so that the connection with the miner works correctly.

Server = IPv4 Public IP from EC2 Miner
Port   = 1680 (Helium Miner Port) 

NTP = "pool.ntp.org"
NTP_PERIOD_S = 3600

WIFI_SSID = 'YOUR_SSID'
WIFI_PASS = 'YOURPASS'

LORA_FREQUENCY = 904300000
LORA_GW_DR = "SF10BW125" # DR_0
LORA_NODE_DR = 0

If everything works correctly you should see the push and pull of the gateway with the miner.

In the Pycom console:

On the console of the Kit.

{"UTC":[2,44,2],"Lat":19.24,"Lon":99.9,"Alt":2234.74,"Hum":37.20,"Press":777.72,"Temp":29.02,"Acc":[9,0,1026],"Gyro":[-1190,210,140],"Mag":[-111,87,-750]}

Checkpoint:

In the Helium console we must see how the data arrives:

Since the data is coming to the Helium console, it is time to configure it to reach the AWS IoT core.

AWS IoT Setup:

The AWS IoT configuration is well explained in the official Helium documentation:

https://developer.helium.com/console/integrations/awsiotcore

Since we have configured the service, we will save the topic that we use to send the data to AWS to be able to use it later.

AWS Services:

AWS works through roles, these roles are credentials that we create so that the services can communicate with each other, in order to carry out all our integration we need to create a role that allows the effective transmission of all services, therefore that will be the first thing To make.

Note: always start here when doing a project with AWS.

IAM:

Enter the IAM console.

Enter through the role tab and click "Create role".

Create a role focused on the IoT platform.

Press next till review.

Now we have to add the additional permissions to the Role, in the roles tab enter the role we just created and press the Attach policies button.

Inside policies add the following:

AmazonDynamoDBFullAccess

Once that is finished, now we can start configuring the Rule within AWS IoT Core.

DynamoDB

Once we receive the data to our AWS IoT Core, we will configure the Rules to connect the following services.

Set any name for the Rule.

In the SQL Query we will place our topic.

The first rule we are going to create will be to save all the data in a DynamoDB.

Press "Create a new resource" to create the table where we will save the data.

For our table we will use the following parameters, I suggest that you use these specifically, since at production level all the device numbers will be different and in the "Time" column we are going to implement a special TIMESTAMP function.

The Sort Key value special function in the sortkey setup is:

${parse_time("yyyy.MM.dd G 'at' HH:mm:ss z", timestamp() )}

Once this is finished, we will have finished the first rule. In this case, because the rule for the lambda uses a different SQL query, we will no longer add any more actions to this rule.

Lambda:

To create a new rule but using the following SQL Query.

We will add to this rule the following action:

Press the "Create a new Lambda Function" button:

We configure the lambda in the following way and create it:

Once the lambda has been created we go down to the Execution role section and press the View the YOURROLE button on the IAM console to be able to add the SNS police to the SMS:

We add the SNS service AmazonSNSFullAccess

Once that is finished, we select the lambda in our rule to finish configuring the lambda trigger.

Before programming the Lambda we will have to configure the SMS service through SNS.

Press the "Create Topic" button to create our message service.

Give the Topic a title and create it.

Save the ARN number, since we are going to need it to configure the lambda.

Click "Create subscription".

Select as "Protocol" SMS and in Endpoint put your cell number (International dialing).

Done, we have finished creating the necessary services to use the lambda correctly, now we return to the lambda and copy the code in the Lambda Code folder and paste it into your Lambda.

The most important part of the code is the Thresholds, each of them was obtained from the following references.

Max Accel Limit: https://web.archive.org/web/20170104164718/http://www.au.af.mil/au/aupress/digital/pdf/book/b_0113_brulle_engineering_space_age.pdf
Max Pressure on Flight: https://www.who.int/ith/mode_of_travel/cab/en/
Max Degrees: 45 degrees maximum static friction before the dog slips
Max Magnetic Field: https://www.who.int/peh-emf/publications/facts/fs322/en/
Min and Max, Temperature and Humidity: http://www.dartmouth.edu/~cushman/courses/engs44/comfort.pdf

IoT Things:

Since we have all our platform ready, we have to create the accesses to communicate with it. So we will have to create two Things in this case, the first is for our Helium Kit and the other will be for the NodeRed UI.

First we have to access our AWS console y look for the IoT core service:

Obtain your AWS endpoint, save it because we will use it to setup the RSL10 App and the webpage.

In the lateral panel select the "Onboard" option and then "Get started".

Select "Get started".

At "Choose a platform" select "Linux/OSX", in AWS IoT DEvice SDK select "Python" and then click "Next".

At Name, write any name, remember that you will have to do this process twice, so name things ion order that you can differentiate the credentials that you will put in NodeRed. Then click on "Next step".

At "Download connection kit for" press the button "Linux/OSX" to download the credential package (which we will use later) and click on "Next Step".

Click "Done".

Click "Done".

On the lateral bar, inside the Manage/Things section we can see our thing already created. Now we have to set up the policy of that thing for it to work without restrictions in AWS.

At the lateral bar, in the Secure/Policies section we can see our thing-policy, click on it to modify it:

Click on "Edit policy document".

Copy-paste the following text in the document and save it.

{
"Version": "2012-10-17",
"Statement": [
    {
    "Effect": "Allow",
    "Action": "iot:*",
    "Resource": "*"
    }
]
}

Once this is done, we will go to our pc and to the folder with the credentials previously downloaded, extract them.

With this, we have the entire cloud backend of the project, so now we can focus on the frontend.

Node-Red Setup:

Node Red is a tool for NodeJS where we can integrate services easily, without code and, of course, create excellent dashboards.

NodeJS installation guide: https://www.guru99.com/download-install-node-js.html

NodeRED installation guide: https://nodered.org/docs/getting-started/windows

NodeRED installation guide: https://flows.nodered.org/node/node-red-dashboard

The file "flows.json" in the folder "Node-RED Flow", has all the information to import the flow into your NodeRED.

Once that is done we will edit the MQTT node to enter our credentials.

Set Server and Port.

Press in the pencil in TSL configuration to add the certificates.

Note: RootCA certificate inside "Certs" folder.

If everything works fine press the "Deploy" button and enter the following URL to check the Dashboard.

http://localhost:1880/ui

The device's real-time location map is at:

http://localhost:1880/worldmap/

Explanation for nodes:

This node receives the broker's payloads, filters according to the sensor which graph it has to go to and sends it to graph and deploy the adress in the world map.

Product:

All the solution in action:

UI:

http://localhost:1880/ui

The device's real-time location map is at:

http://localhost:1880/worldmap/

Demo:

Code

#include <LSM6DSOSensor.h>
#include <LIS2DW12Sensor.h>
#include <LIS2MDLSensor.h>
#include <LPS22HHSensor.h>
#include <STTS751Sensor.h>
#include <HTS221Sensor.h>
#include "teseo_liv3f_class.h"
#include <ArduinoJson.h>
#include "LoRaWAN.h"

const char *devEui = "YOUR_DEVEUI";
const char *appEui = "YOUR_APPEUI";
const char *appKey = "YOUR_APPKEY";

TeseoLIV3F *gps;
int incomingByte;
GNSSParser_Data_t data;
char command[32] = {0};
char msg[256];
int cmdType = 0;
uint32_t t, s;
int tracked;
GPGGA_Info_t stored_positions[64];
int status = 0;
uint32_t stime = 0;
int waitType = 0;

#define MSG_SZ 256
#define waitForRequest 0
#define waitForAnswer 1

#ifdef ARDUINO_SAM_DUE
#define DEV_I2C Wire1
#elif defined(ARDUINO_ARCH_STM32)
#define DEV_I2C Wire
#elif defined(ARDUINO_ARCH_AVR)
#define DEV_I2C Wire
#else
#define DEV_I2C Wire
#endif

#ifdef ARDUINO_SAM_DUE
#include <avr/dtostrf.h>
#elif ARDUINO_STM32L0_B_L072Z_LRWAN1
#include <avr/dtostrf.h>
#endif

// Components
LSM6DSOSensor *AccGyr;
LIS2DW12Sensor *Acc2;
LIS2MDLSensor *Mag;
LPS22HHSensor *PressTemp;
HTS221Sensor *HumTemp;
STTS751Sensor *Temp3;

unsigned long time1;
unsigned long time2;

String MyJson="{";

void setup() {
  StaticJsonDocument<200> doc;
  // Led.
  pinMode(LED_BUILTIN, OUTPUT);
  // Initialize serial for output.
  Serial.begin(115200);  
  // Initialize I2C bus.
  DEV_I2C.begin();
  Serial1.begin(9600);
  Serial.println("Setup begin");
  //Create the device object passing to it the serial interface
  gps = new TeseoLIV3F(&Serial1, 7, 13);
  //Initialize the device
  gps->init();
  AccGyr = new LSM6DSOSensor (&DEV_I2C);
  AccGyr->Enable_X();
  AccGyr->Enable_G();
  Acc2 = new LIS2DW12Sensor (&DEV_I2C);
  Acc2->Enable_X();
  Mag = new LIS2MDLSensor (&DEV_I2C);
  Mag->Enable();
  PressTemp = new LPS22HHSensor(&DEV_I2C);
  PressTemp->Enable();
  HumTemp = new HTS221Sensor (&DEV_I2C);
  HumTemp->Enable();
  Temp3 = new STTS751Sensor (&DEV_I2C);
  Temp3->Enable();
  LoRaWAN.begin(US915);
  // Helium SubBand
  LoRaWAN.setSubBand(2);
  // Disable Adaptive Data Rate
  LoRaWAN.setADR(false);
  // Set Data Rate 1 - Max Payload 53 Bytes
  LoRaWAN.setDataRate(3);
  // Device IDs and Key
  LoRaWAN.joinOTAA(appEui, appKey, devEui);
  Serial.println("Start...");
  time1=millis();
}

void loop() {

   // Repeat at least 20 times per second this command
   gps->update();
   
  if((millis() - time1) > 30000)
  {  
  MyJson="{";
  printValidInfo();
    // Read humidity and temperature.
  float humidity = 0, temperature = 0;
  HumTemp->GetHumidity(&humidity);
  HumTemp->GetTemperature(&temperature);

  MyJson += "\"Hum\":";
  MyJson += String(humidity);
  MyJson += ",";

  // Read pressure and temperature.
  float pressure = 0, temperature2 = 0;
  PressTemp->GetPressure(&pressure);
  PressTemp->GetTemperature(&temperature2);

  MyJson += "\"Press\":";
  MyJson += String(pressure);
  MyJson += ",";

  //Read temperature
  float temperature3 = 0;
  Temp3->GetTemperature(&temperature3);

  float temp = (temperature + temperature2 + temperature3)/3;

  MyJson += "\"Temp\":";
  MyJson += String(temp);
  MyJson += ",";

  // Read accelerometer and gyroscope.
  int32_t accelerometer[3];
  int32_t gyroscope[3];
  AccGyr->Get_X_Axes(accelerometer);
  AccGyr->Get_G_Axes(gyroscope);

  MyJson += "\"Acc\":[";
  MyJson += String(accelerometer[0])+",";
  MyJson += String(accelerometer[1])+",";
  MyJson += String(accelerometer[2]);
  MyJson += "],";

  MyJson += "\"Gyro\":[";
  MyJson += String(gyroscope[0])+",";
  MyJson += String(gyroscope[1])+",";
  MyJson += String(gyroscope[2]);
  MyJson += "],";

  //Read accelerometer
  int32_t accelerometer2[3];
  Acc2->Get_X_Axes(accelerometer2);

  //Read magnetometer
  int32_t magnetometer[3];
  Mag->GetAxes(magnetometer);

  MyJson += "\"Mag\":[";
  MyJson += String(magnetometer[0])+",";
  MyJson += String(magnetometer[1])+",";
  MyJson += String(magnetometer[2]);
  MyJson += "]}";

  if (LoRaWAN.joined() && !LoRaWAN.busy())
    {   
        // Send Packet
        uint8_t payload[] ="";
        MyJson.getBytes(payload, sizeof(MyJson));
        LoRaWAN.sendPacket(1, payload, sizeof(payload));
        Serial.println("Data Sent");
    }
  time1=millis(); 
  Serial.println(MyJson);
  } 
}
void printValidInfo()
{
   data = gps->getData();
   if (data.gpgga_data.valid == 1)
   {
      int lat = (int) (data.gpgga_data.xyz.lat/100.0);
      int lat_mod = (int) (data.gpgga_data.xyz.lat) - (lat * 100);
      int lon = (int) (data.gpgga_data.xyz.lon/100.0);
      int lon_mod = (int) (data.gpgga_data.xyz.lon) - (lon * 100);
      char alt[7];
      char acc[5];
      dtostrf (data.gpgga_data.xyz.alt, 3, 2, alt);
      dtostrf (data.gpgga_data.acc, 4, 1, acc);
      snprintf(msg, MSG_SZ, "UTC:\t\t\t[ %02ld:%02ld:%02ld ]\r\n",
               data.gpgga_data.utc.hh,
               data.gpgga_data.utc.mm,
               data.gpgga_data.utc.ss);
      MyJson += "\"UTC\":[";
      MyJson += String(data.gpgga_data.utc.hh)+",";
      MyJson += String(data.gpgga_data.utc.mm)+",";
      MyJson += String(data.gpgga_data.utc.ss);
      MyJson += "],";

      snprintf(msg, MSG_SZ, "Latitude:\t\t[ %.02d' %.02d'' %c ]\r\n",
               lat,
               lat_mod,
               data.gpgga_data.xyz.ns);
      MyJson += "\"Lat\":";
      MyJson += String(lat)+"."+String(lat_mod);
      MyJson += ",";

      snprintf(msg, MSG_SZ, "Longitude:\t\t[ %.02d' %.02d'' %c ]\r\n",
               lon,
               lon_mod,
               data.gpgga_data.xyz.ew);
      MyJson += "\"Lon\":";
      MyJson += String(lon)+"."+String(lon_mod);
      MyJson += ",";
    
      snprintf(msg, MSG_SZ, "Satellites locked:\t[ %ld ]\r\n",
               data.gpgga_data.sats);

      snprintf(msg, MSG_SZ, "Position accuracy:\t[ %s ]\r\n",
               acc);

      snprintf(msg, MSG_SZ, "Altitude:\t\t[ %s%c ]\r\n",
               alt,
               (data.gpgga_data.xyz.mis + 32U));
      MyJson += "\"Alt\":";
      MyJson += String(alt);
      MyJson += ",";

      snprintf(msg, MSG_SZ, "Geoid infos:\t\t[ %ld%c ]\r\n",
               data.gpgga_data.geoid.height,
               data.gpgga_data.geoid.mis);

      snprintf(msg, MSG_SZ, "Diff update:\t\t[ %ld ]\r\n",
               data.gpgga_data.update);
   }
   else
   {
      Serial.print("Last position wasn't valid.\r\n\n");
   }
   Serial.print("\r\n\n");
}

   // Load the AWS SDK
   var AWS = require("aws-sdk");
   // Set up the code to call when the Lambda function is invoked
   exports.handler = (event, context, callback) => {
      
   // thresholds
   
   // Sensor Datasheet

   //(10 G) Stunt Safety Limit
   var accel = 100 
   // WHO NOM Limits kPa
   var maxP = 82 
   var minP = 74 
   // Max 45 Degrees 
   var maxD = 45 
   // Normal sensor values on a flat surface
   var xnom=-3
   var ynom = -8
   var znom = 98
   // WHO max Teslas
   var maxMag = 100 
   // dartmouth college standard
   var maxTemp = 30 
   var minTemp = 15
   var maxH = 80
   var minH = 20
   
   // Function
   
   var eventText = JSON.parse(JSON.stringify(event, null, 2));
   var sensor;
   var value;

      if (eventText["Acc"] != undefined) {
      sensor="Accel"
      var x = Math.abs(parseInt(eventText["Acc"].split(",")[0])*0.1);
      var y = Math.abs(parseInt(eventText["Acc"].split(",")[1])*0.1);
      var z = Math.abs(parseInt(eventText["Acc"].split(",")[2])*0.1);
      value=eventText["Acc"]
      if(x > accel  || y > accel || z > accel )
      {
         var sns = new AWS.SNS();
         var params = {
         Message: "Excessive movement detected",
         TopicArn: "arn:aws:sns:us-east-1:xxxxxxxxxxxxx:YOURTOPIC"
         };
         sns.publish(params, context.done);
      }
   }
   else if (eventText["Gyro"] != undefined) {
      sensor="Gyro"
      var x = parseInt(eventText["Gyro"].split(",")[0])*0.1;
      var y = parseInt(eventText["Gyro"].split(",")[1])*0.1;
      var z = parseInt(eventText["Gyro"].split(",")[2])*0.1;
      value=eventText["Gyro"]
       if(Math.abs(x-xnom) > maxMag  || Math.abs(y-ynom) > maxMag || Math.abs(z-znom) > maxMag )
      {
         var sns = new AWS.SNS();
         var params = {
         Message: "Strange position detected",
         TopicArn: "arn:aws:sns:us-east-1:xxxxxxxxxxxxx:YOURTOPIC"
         };
         sns.publish(params, context.done);
      }
   }
   else if (eventText["Mag"] != undefined) {
      sensor="Magnet"
      var  x = Math.abs(parseInt(eventText["Mag"].split(",")[0])*0.1);
      var y = Math.abs(parseInt(eventText["Mag"].split(",")[1])*0.1);
      var z = Math.abs(parseInt(eventText["Mag"].split(",")[2])*0.1);
      value=eventText["Mag"]
      if(x > maxMag  || y > maxMag || z > maxMag )
      {
         var sns = new AWS.SNS();
         var params = {
         Message: "High magnetic field detected.",
         TopicArn: "arn:aws:sns:us-east-1:xxxxxxxxxxxxx:YOURTOPIC"
         };
         sns.publish(params, context.done);
      }
   }
   else if (eventText["Temp"] != undefined) {
      sensor="Temp"
      value=parseInt(eventText["Temp"])
      
     if(value > maxH)
      {
         var sns = new AWS.SNS();
         var params = {
         Message: "High Temperature Detected",
         TopicArn: "arn:aws:sns:us-east-1:xxxxxxxxxxxxx:YOURTOPIC"
         };
         sns.publish(params, context.done);
      }
      else if(value < minH)
      {
         var sns = new AWS.SNS();
         var params = {
         Message: "Low Temperature Detected",
         TopicArn: "arn:aws:sns:us-east-1:xxxxxxxxxxxxx:YOURTOPIC"
         };
         sns.publish(params, context.done);
      }
      
   }
   else if (eventText["Press"] != undefined) {
      sensor="Press"
      value=parseInt(eventText["Press"])
      if(value > maxP)
      {
         var sns = new AWS.SNS();
         var params = {
         Message: "High Pressure Detected",
         TopicArn: "arn:aws:sns:us-east-1:xxxxxxxxxxxxx:YOURTOPIC"
         };
         sns.publish(params, context.done);
      }
      else if(value < minP)
      {
         var sns = new AWS.SNS();
         var params = {
         Message: "Low Pressure Detected",
         TopicArn: "arn:aws:sns:us-east-1:xxxxxxxxxxxxx:YOURTOPIC"
         };
         sns.publish(params, context.done);
      }
   }
   else if (eventText["Hum"] != undefined) {
      sensor="Hum"
      value=parseInt(eventText["Hum"])
      if(value > maxH)
      {
         var sns = new AWS.SNS();
         var params = {
         Message: "High Humidity Detected",
         TopicArn: "arn:aws:sns:us-east-1:xxxxxxxxxxxxx:YOURTOPIC"
         };
         sns.publish(params, context.done);
      }
      else if(value < minH)
      {
         var sns = new AWS.SNS();
         var params = {
         Message: "Low Humidity Detected",
         TopicArn: "arn:aws:sns:us-east-1:xxxxxxxxxxxxx:YOURTOPIC"
         };
         sns.publish(params, context.done);
      }
   }
   else{
      // Nothing
   }
   return [sensor,x]
    
};

#!/usr/bin/env python
#
# Copyright (c) 2019, Pycom Limited.
#
# This software is licensed under the GNU GPL version 3 or any
# later version, with permitted additional terms. For more information
# see the Pycom Licence v1.0 document supplied with this file, or
# available at https://www.pycom.io/opensource/licensing
#

""" LoPy LoRaWAN Nano Gateway configuration options """

import machine
import ubinascii

WIFI_MAC = ubinascii.hexlify(machine.unique_id()).upper()
print()
# Set  the Gateway ID to be the first 3 bytes of MAC address + 'FFFE' + last 3 bytes of MAC address
GATEWAY_ID = WIFI_MAC[:6] + "FFFE" + WIFI_MAC[6:12]

SERVER = 'YOUR_MINER'
PORT = 1680

NTP = "pool.ntp.org"
NTP_PERIOD_S = 3600

WIFI_SSID = 'YOUR_SSID'
WIFI_PASS = 'YOURPASS'

LORA_FREQUENCY = 904300000
LORA_GW_DR = "SF10BW125" # DR_0
LORA_NODE_DR = 0

LoraDOG

Things used in this project

Hardware components

Software apps and online services

Hand tools and fabrication machines

Story

LoraDOG

Video Demo:

Introduction and problem

Solution:

Connection Diagram:

Kit Assembly:

Create Helium Account:

Kit Setup:

Miner Creation:

Pycom Setup:

Gateway Setup:

Checkpoint:

AWS IoT Setup:

AWS Services:

IAM:

DynamoDB

Lambda:

IoT Things:

Node-Red Setup:

Explanation for nodes:

Product:

Demo:

Schematics

Diagram

Code

Arduino Code

Notification.js

Pycom Code

Code and Repo

Credits

Victor Altamirano

Alejandro Sanchez

JulietaAltamirano

Comments

Embed the widget on your own site

LoraDOG

LoraDOG

Things used in this project

Hardware components

Software apps and online services

Hand tools and fabrication machines

Story

LoraDOG

Video Demo:

Introduction and problem

Solution:

Connection Diagram:

Kit Assembly:

Create Helium Account:

Kit Setup:

Miner Creation:

Pycom Setup:

Gateway Setup:

Checkpoint:

AWS IoT Setup:

AWS Services:

IAM:

DynamoDB

Lambda:

IoT Things:

Node-Red Setup:

Explanation for nodes:

Product:

Demo:

Schematics

Diagram

Code

Arduino Code

Notification.js

Pycom Code

Code and Repo

Credits

Victor Altamirano

Alejandro Sanchez

JulietaAltamirano

Comments

Related channels and tags