Abstract:

This post describes all progress up to this point and the integration of LoRa communication into the currently in progress Evaporometer project.

Our Progress:

In the past few weeks, I’ve been working with another student named Manuel to apply the LoRa devices to a rain catchment device designed to measure evaporation.  Below is a picture of the strain gauge rain catchment system he built for the project.  The LoRa device can be placed on the platform where a load cell can be hooked up to our LoRa system to measure and transmit data to our LoRa receiver and to an offsite server.  

Since the LoRa device will need to transfer data as precisely as our load cell can measure, the code will need to be adjusted to accommodate integer and float values with adjustable decimal precision.  I have made the proper updates to the code and will post more details on that in the future.

What’s Next:

We are moving quickly towards field testing these LoRa devices with the Evaporometer but there are a few changes that still need to be made.  The LoRa transmitters, which will be out in the field, will need a weatherproof housing and a portable power source.  Also our current transmission frequency is not suitable for a lot of ongoing communication, so our LoRa breakouts will also need to be replaced new ones that can transmit at a higher 915 mHz frequency.   

– Marissa Kwon Undergraduate Student Researcher

By: Alex Grejuc

Background:

I have been working on connecting to IFTTT using the ESP. IFTTT is a platform that makes it easy to connect different web apps and services to create applets or recipes. They work in an If this, then that (that is where the letters IFTTT come from) format. For example, if I like a video on YouTube, save its name and link to a list on Evernote.

IFTTT has a service called Maker that allows a user to send a web request to their Maker service which can then trigger an action. I used this feature to create an applet, which, when triggered by the ESP will send data to a Google Drive spreadsheet.

Process:

This will be wired the same way as all my previous Arduino and ESP guides. Most of the code is fairly similar and it is explained there as well. The wiring is here and the general info about sending GET requests is here.

The first step is to create an IFTTT account and then create an applet (this link answers many of the questions about applets) using Maker.

After creating an applet, go into settings on the Maker page.

Then, copy your personal URL and go to that page.

On this page, you can see the information for sending HTTP requests and the full link that can be used in a GET request. The code will show how to add data values which can be sent over as query parameters in the request.

Once this is all set up, you have the necessary information to send data to the web using IFTTT and your ESP.

Next, download the code, add your credentials, and then upload it to the Arduino.

This guide may be helpful, it is how I got my start. However, like many of the guides, this uses the ESPWifi library which I did not use.

By: Alex Grejuc

I have been working on using an Arduino and an ESP8266 wifi module to log data on an online platform for the past few weeks and after many hurdles, I have something that works reliably.

The general progress can be seen in the previous blog posts, so I will not discuss that.

Background:

This code hinges around sending HTTP GET requests. GET is an HTTP method that “asks” for a resource (a web page) from a server. In this case, we are requesting to send data to the IO platform. A GET request follows the general format:

GET HTTP/1.1

Host: <host>

Connection: close\r\n\ (connection can also be kept alive with keep-alive)

When sending these over the ESP, \r\n (carriage return and newline characters) must be appended to each line (the last line has an extra \r\n). Without them, the command may not be properly understood by the server.

Once this command is sent, the server will respond by returning html. This is essentially how an internet browser functions: a URL is entered, the browser receives html from a server, and then displays the html. In this case, however, the response is going to the ESP, which will display “+IPD” (which indicates the ESP has received data) to the serial monitor and then the HTTP code and some html. My information of networking and HTTP is very limited, so much more information can be found online. A resource I skimmed can be found here.

Process:

First, I created an Adafruit IO account and familiarized myself with the platform. Adafruit IO is a platform for the internet of things that makes it easy to record and view data. They have a lot of documentation, tutorials, and support, so it is a good choice. Note that their recommended route for using the ESP8266 involves the Huzzah breakout and uploads code directly to the ESP8266. This was not quite what we wanted to do, so I worked on interfacing with the ESP through the Arduino by sending AT commands.

Next, wire up the ESP and Arduino and get familiar with the ESP and its AT commands. All of this information can be found in this previous blog post. The code there is for a different purpose, so that can be ignored.

After that, upload this code and fill in your own WiFi and Adafruit credentials.

This should be enough to get a bare bones method of logging data up and running.

Extra Resources:

Additionally, here are a couple of posts and websites that helped me troubleshoot and understand what was going on:

• Arduino forum on an ESP GET request issue
• The Adafruit page that explains how to send and receive data using HTTP requests
• A post with more detail on some AT commands
• A video that goes over the process, which helped me break through my issues

Abstract:

In this blog post we go over how to we assembled the LoRa transmitter and receiver.  We include instructions on how to set up the Arduino IDE as well as the code for our test devices.

Materials:

These are the components connected to now separate transmitter/receiver (pictured above): 

Transmitter:

– Matbotix 1220 sonar sensor

– RFM9X LoRa Radio

– Adafruit Pro Trinket (3V Logic) w/ FTDI cable connector

– Red LED

– 51 ohm resistor

Receiver:

– RFM9X LoRa Radio

– Arduino UNO (5V out) w/ macro USB cable connector

– 81 ohm resistor

– Red LED 

– White LED

The transmitter and receiver have been placed on separate breadboards in order to test the range on the LoRa chips.  Code on both the transmitter and receiver sketches has been rewritten to send and receive the data values measured by the MB1220.  Other changes include the replacement of the Arduino Uno development board with the smaller 3V Adafruit Protrinket.  If you haven’t already, you will need to set up your Arduino IDE so that it recognizes Adafruit’s development boards when plugged into the USB port using an FTDI cable.  

SETTING UP THE ARDUINO IDE: You will need to go into Arduino’s Preferences, paste the Adafruit Board Support Package URL into the space next to “Additional Board Manager URLS”, click OK, then go into the Tools tab and select the “Boards Manager” found in “Boards:”.  Filter your search by choosing “Contributed” from the dropdown menu and typing “Adafruit AVR” in the search bar.  Then install the package “Adafruit AVR Boards”.  Once installed, you can upload your Arduino sketches to the Pro Trinket by selecting “Pro Trinket3V/12MHz (FTDI)” from the Boards dropdown menu.

The Pro Trinket uses the Atmega328P chip – the same core chip as our Arduino UNO – making it easy to switch between the two.  When transitioning to the Pro Trinket I realized it lacked pins #2 and #7 as well as the level shifting featured on the UNO (5V input on the Pro Trinket will have to be reduced to 3.3V to prevent damage to the board). To accommodate the Pro Trinket, I replaced interrupt Pin#2 for Pin#3 and digital write Pin#7 for Pin#6 and applied these changes to the UNO so the transmitter and receiver code can be used for either board.   Here are the updated versions of the transmitter and receiver code.

I have provided links to more information about the Pro Trinket’s limitations compared to the UNO and step by step instructions for installing the Adafruit AVR package.

– Marissa Kwon Undergraduate Student Researcher

By: Alex Grejuc

Today I finally succeeded in getting “data” (arbitrary numbers that I either hardcoded or looped through) from the Arduino through the ESP and to Adafruit IO.

I troubleshooted my bad requests by sending in AT commands manually through the Arduino serial monitor. After digging around on the internet, I found that the Arduino serial monitor does not recognize the \r and \n (carriage return and newline) escape sequences, so I sent each line of the GET request in line-by-line, and it worked.

This was manifesting itself in my code too because my character counts were off (the ESP AT command requires the length of the argument you are going to send it and will not work properly if it is off). After troubleshooting, I found the “correct” character count for my requests and I was able to receive a proper response from an Adafruit test page.

After this, I looked into sending a GET request to the IO platform with data. I was able to get this working as well and published some test data to an Adafruit “feed.”

I plan on cleaning up the code by writing some functions to make it more readable and easier to use as well as updating my comments now that I have a better understanding of the process. Once I do this, I will publish the code along with some of the resources that helped me along the way.

Here is a screenshot of some of the data on the Adafruit IO website.

By: Alex Grejuc

After learning to interface with the ESP through the Arduino and hosting the basic web server, I started working on actually using the ESP to get data from the Arduino and log it on an online internet of things platform.

I started out by looking into a few different IOT platforms: Adafruit IO, IFTTT, and Xively. Of the three, Adafruit seemed like the best option because it was free and had tutorials for integrating a custom Adafruit ESP breakout board.

I started out working from an Adafruit tutorial. to simply learn how to connect to the Adafruit server and receive a response. However, this tutorial was intended for the Adafruit custom board and uploaded the code directly to the ESP8266 with an Adafruit library. I spent time “translating” their code into AT-commands by determining what they were doing, finding an AT command for it, learning how it works, and then sending it over.

Connecting to a network and starting a TCP connection with the Adafruit server was easy to do, however, the HTTP GET request has provided plenty of trouble.

Initially, after sending the request the ESP replied with “Send OK” but did not receive or print the response to the Arduino serial monitor. After trying many things, I thought there might be an issue with the Adafruit server I was attempting to get data from.

I then decided to try sending a GET request to a different server in case that was indeed the issue, so I set up an IFTTT applet. It would send my phone a text message when a request was sent in, based it off of a tutorial someone made for interacting with IFTTT using the ESP. This seemed like a good approach because I could see if the GET request worked without even reading any response in with the ESP, in case that was the issue.

This also did not work, so Dr. Udell and I came to the conclusion that the Oregon State wireless network might prevent the ESP from receiving the response somehow. This turned out to be true: after connecting to two different networks on campus (an OSU robotics one and a personal cellphone hot spot), the ESP got a response from the server.

Unfortunately, the response is a “Bad Request Error 400” response that I have been troubleshooting since. It seems to be a common issue based on forums, but no clear solutions have been found. I hope to provide a more robust update with code, links, and information once I can successfully get the request to work.