Tag Archives: esp8266

TheThingsNetwork LoRa node with ESP8266 and RN2483

TheThingsNetwork is a global community with a mission of bringing the Internet Of Things world closer to the people and making the connectivity easy and completely free. It’s doing that by providing open to use communication base stations and distributed back end system that handles all the communication, security and data availability throughout your devices and target system.

The communication protocol used is LoRaWAN. It allows low powered devices to connect from far distances, having in mind that they can only send or receive short bursts of data every now and then. The communication works on open frequencies, meaning that they don’t rely on regulators or major telecommunication providers.

Recently I applied for a local TTN community in Skopje, which got approved and the infrastructure is still in development. For the first test subject, I used Arduino Uno combined with the Microchip RN2483 for LoRaWAN connectivity. It’s the most basic example and it worked just fine. However the real requirement is to have an ESP8266 main controller that will talk to the RN2483. The reason for this is, that the case I’m working on needs an end-user configuration mechanism, and the ESP’s integrated WiFi and WebServer are just the thing.

For convenience and easier prototyping, I used the NodeMCU devkit board which is based on ESP-12E chip. It resembles Arduino quite much, has direct micro USB connection removing the need for FTDI and has all the pins necessary to connect the RN2483 chip and additional sensors / actuators you’ll need. For development, you can use the Arduino IDE and SDK with the ESP8266 boards and port. I’ve written on this topic before here (it may be a bit outdated though…).

Part 1: Connecting the parts

For a very basic setup, you’ll be needing a proto PCB (or a protoboard if you don’t wan’t to solder everything just yet), NodeMCU 1.0 devkit, RN2483 chip, some patch wires, solid core wire to act as an antenna, and soldering wire.

The NodeMCU has a bigger form factor than the RN2483 chip, so it’s possible even to solder them tightly together or one under the other by using some header pins aside.

The connection between the two goes like this:

RN2483 TX (6) <-> NodeMCU D6
RN2483 RX (7) <-> NodeMCU D5
RN2483 VDD (12 or 34) <-> NodeMCU 3.3V
RN2483 GND (20 or 33 …) <-> NodeMCU GND
RN2483 RESET (32) <-> NodeMCU D7
RN2483 RFH (23) <-> Antenna or 8.6cm solid core wire

My gruesome implementation looks like this:

NodeMCU + RN2483 side    NodeMCU + RN2483 top

Part 2: Prepare a TTN app

Go to TheThingsNetwork and create an account if you don’t have one. Check afterwards in your local community whether you have LoRa TTN coverage in your area.

After that, go to the staging app and create a new application. Choose Activate Devices with default app key in order to be able to use OTAA (this is not mandatory, I’m just using OTAA in the example code). When the app is created, take the App EUI and in Settings get the Default App Key. You’ll be needing them in the code afterwards. Leave the main app page opened, so that you can see the connections and the data sent afterwards.

Part 3: Code

Before you go off coding, first do some preparations:
– get the latest Arduino IDE
– install the nodemcu devkit driver
– install the esp8266 board in the Boards manager (or update to the latest)
– install the RN2483 library
– install the ESPSoftwareSerial library

The code I’m using is a modification of this nice tutorial done by jpmeiers.

*) this is the bare minimum you need in order to start things working. I got it by modifying the original code and removing the other parts afterwards, so let me know if something is not right.

When you got all packed, choose NodeMCU to be your current board, fire the serial monitor, set it to 57600 baud rate, and flash the code to the device. If everything is fine, you should see nice messages in the serial log, and by refreshing the app page on ttn, you should see your device registered and messages arriving every minute.

Part extra: extend and pack

The final product I made with all this is a Dust, Temperature and humidity TTN sensor node. You can do that by combining DHT22 (tutorial here) and sharp dust sensor (arduino tutorial here). However, the code still looks a bit shaky, and the dust sensor might need some extra work and/or calibration, so I don’t dare yet to publish it.

Dust, Temperature and Humidity LoRa TTN Sensor
The final sensor node prototype

And as a final touch, I designed a custom enclosure in OpenSCAD (a mix of this design by b2vn) and I 3D printed it. I just made it longer and wider, and put holes for the DHT and the dust sensor opening, to have air circulating.

The final result:

Dust, Humidity and temperature TTN sensor node with 3d printed housing
Dust, Humidity and temperature TTN sensor node with 3d printed housing

WiFi light with ESP8266 and Arduino code

The ESP8266 microcontroller chip is out there for almost a year now and it has already made a huge boom in the makers and IoT communities. It is cheap ($5),  it has built in WiFi capabilities, and as of a few months ago, it is Arduino compatible.

Besides the unique built in WiFi capability, the ESP8266 has its own 32bit CPU running on 80MHz, up to 4MB flash, and can be extended with other devices via the GPIO pins which can act individually or as SPI, I2C or UART interfaces.

The early versions of the chip were used as add-on modules which provided WiFi access to an Arduino board. The communication was done via the exposed Rx and Tx pins and by using series of AT commands.  However, after a while, the manufacturer released an SDK allowing code to be uploaded directly on the ESP chip and thus removing the need for a separate driver board. But still, the experience wasn’t nice, since the tools were buggy and the code was to be done in Lua. Then, after months of adaptations, an Arduino IDE port was release targeted for ESP8266, and it was a game changer.

What I did as a POC of the entire platform is a Colored WiFi light that I can control via my phone browser. My whole idea is to have this integrated in a home automation system, but let’s go step by step.

Hardware requirements:

  • NodeMCU devkit (preferrably for ease of usage and testing; or other ESP8266 board properly connected via FTDI)
  • A WS2812 / 2811 / NeoPixel LED strip. (any would do, just keep the number of LEDs low, so you won’t need external powering. You can even use PiMoroni’s Unicorn HAT)
  • Jumper wires
  • Micro USB cable (if NodeMCU) is to be used

To connect the WS2812 LED strip, use the jumper wires and connect the DataIn pin to GPIO4 which is actually D2 from the board, the input voltage to 5V on the board, and GND to any GND pin.

The NodeMCU devkit is a device board for prototyping with the ESP-12 chip. I’m using here the 0.9 version of the devkit, which is not the most recent. Bear in mind that the pin numbering on the board is NOT the same as the GPIO numbering in the SDK.

NodeMCU devkit 0.9
NodeMCU devkit 0.9

Next, download and configure the Arduino IDE:

  • Download and install the latest Arduino IDE with the Board Manager for ESP8266  as described here.
  • Get and install the device driver for the on-board USB to Serial from here. (needed for NodeMCU)
  • Get and install the NeoPixelBus library to your Arduino installation. Do that by placing everything in the folder arduino/libraries/NeoPixelBus.
  • Launch the Arduino IDE and choose the board to be NodeMCU (or generic ESP8266 if using the sole chip via FTDI) and select the COM port to which the device is connected.

Finally, the code to make it all work. You can see prior to this that there are already several examples which can get you started (look at the web server examples and the ones from the NeoPixelBus library). What is needed here is basically a mix between those two , some proper handlers and a simple web UI.

My try:

In order to make the code work, you need to enter the SSID and the password of your network in the code. In my case, I set my phone to broadcast a personal hotspot, and I’m connecting directly to it. Also, set the pixelCount to the exact count of pixels you have in your WS2812 strip.

To upload the code to the device, you just click on upload in the IDE, and if everything is fine, the code will be compiled and flashed, and the ESP will be restarted immediately. To see the status, you can use the Serial Communication inspector in the IDE. It will also output the designated IP address from the DHCP server on the network.

At the end, open a browser in the same network and point to the device IP directly. Click on any color and see what happens. Here’s how it turned out on my side.

WiFi light
WiFi light: device
WiFi light: UI
WiFi light: UI

As a conclusion, I’m pretty satisfied with the outcome. The entire process was relatively short and straight-forward, and besides the device driver troubles I had, everything else went smoothly. I’m also pretty excited, cause more and more stuff is getting adapted for this platform (e.g. DHT sensor library) and inevitably will become the platform to code  and make future IoT prototypes.

Useful links: