environmental monitoring – Voltaic Systems Blog

Obscape Uses Voltaic In Rugged Environmental Devices

Voltaic Systems — Mon, 09 Feb 2026 17:56:29 +0000

Obscape is a designer and manufacturer of easy-to-use environmental monitoring products. Their devices are placed in extremely challenging locations around the world including coastlines, ports, offshore drilling platforms. Once deployed, they take photographs and measure wave height, water quality, water levels and water flow.

Solar powered Time-Lapse Camera deployed on a beach.

For Obscape’s customers, product reliability is a critical feature. Obscape outlines the reasons they choose to use Voltaic solar panels in this video.

Voltaic has spent extensive time and resources validating the material stack used in all of our ETFE panels. They have been tested against a wide variety of environmental forces:

combined UV, temperature and humidity
thermal cycling
thermal shock
vibration
mechanical shock
saltwater
chemical exposure

The solar panels have also been field tested with well over a million panels deployed across a wide variety of use cases and environmental conditions.

Solar panels on OBS-BUOY

Voltaic collaborates with our customers to ensure mechanical and electrical designs follow best practices. Obscape embeds each of the panels precisely and securely in the enclosure which shields them from impact. This design step extends the length of the panel by several years.

Solar panels in Time-Lapse camera during production.

We are excited to work with companies like Obscape who help their customers better understand the world around them.

Solar for BirdWeather BioAcoustic Platform

Voltaic Systems — Tue, 02 Apr 2024 20:19:32 +0000

This is a quick demonstration on how to power the BirdWeather PUC from solar power. The PUC listens to the sounds around it and is able to identify over 6,000 birds and many other non-avian species. It uses the BirdNET neural network from Cornell Lab of Ornithology and the Chemnitz University of Technology.

Here is some of the birds our device identified in the first days of deployment.

The PUC is simple to use and get started (especially compared to the raspberry Pi version) and is pretty power efficient. It consumes about 60mA at 5 Volts and improvements are underway to bring this down further.

We recommend most customers pair the PUC with our 5 Watt 5 Volt 35Wh solar power system. For customers in environments with less sun because of shading or northern latitudes or if you want to decrease the risk of your system going out of power, you can increase the panel size to 10 Watts in the drop down menu.

Quick math: 60mA * 5V * 24h = 7.2 Watt hours per day. In New York City, the 5 Watt system will perform well up until December. At that point, a south facing panel in will receive the equivalent of two hours of sun. After losses in and out of the circuit, it will provide only about 6 Watt hours to the PUC and it will likely have some down time. Doubling the panel size to 10 Watts gets us to 12 Watt hours into the battery and a more stable system.

The 5 Watt system includes a mounting bracket (BK102) which includes slots for u-bolts and screws. We simply used a few bolts to attach the panel to a steel post.

We placed the PUC underneath the solar panel. The back mount has a 1/4″ 40 screw thread. We attached a short piece of 1/4″ 40 threaded rod and a wing not to secure it to the post.

The V35 battery from the Voltaic system connects to the PUC via a USBC adapter (A123). That’s it!

Another option is our systems with enclosure. This is the 5 Watt, 5 Volt system using the V50 battery. This system was deployed by Derek Rogers of the Adirondack Land Trust.

Happy acoustic birding.

Shop Now

Solar Powered Nano 33 IoT Soil Moisture Tutorial

Lizabeth Arum — Wed, 13 Mar 2024 21:24:15 +0000

Overview

This blog post is a step-by-step walkthrough to run a Nano 33 IoT application from solar power. You will learn about:

Managing power consumption on an Arduino Nano 33 IoT
Converting RS485 data to serial
Publishing data on the Qubitro IoT platform
Monitoring system health of a solar powered application

Whether you’re a hobbyist, educator, or professional, this POC demonstrates the potential of solar-powered IoT solutions and the ease with which they can be implemented to address real-world challenges.

Parts Needed

Arduino® Nano 33 IoT with headers
5 Watt 5 Volt 35Wh Solar System
Renkeer RS-SD-N01-TR- Soil moisture sensor
RS-485 Converter Module TTL to RS-485 Adapter
USB 2.0 Pigtail 4 Wire
Wires
For lowering power consumption with a RTC
- Adafruit DS3231 Precision RTC Breakout
- 1x resistor 10kOhms
- 1x resistor 100Ohms
- IRF9520 P-channel MOSFET
- Pololu S7V7F5 voltage regulator

The Renke Soil Moisture Sensor

The sensor measures the dielectric constant of soil and the volume percentage of soil moisture, which is a soil moisture measurement method in line with current international standards. You can bury it in the soil for a long time, as the electrode is made of alloy material, it is durable, waterproof, and resistant to long-term electrolysis, acid and alkali corrosion.

The sensor is suitable for soil moisture monitoring, scientific experiments, water-saving irrigation, greenhouses, flowers and vegetables, grassland pastures, soil rapid testing, plant cultivation, sewage treatment, precision agriculture and other occasions temperature and humidity, conductivity, PH value testing .

It can be powered by 4.5-30V and operates between -20°C to ~60°C.

Here are some best practices for using the sensor:

The steel needles must be fully inserted into the soil when measuring.
Avoid direct sunlight on the transmitter that will cause the temperature to be too high. Pay attention to lightning protection when using in the field.
Do not bend the steel needles violently, do not pull the lead wire of the transmitter forcibly, and do not violently hit the transmitter.
The protection level of the transmitter is IP68, and the entire transmitter can be soaked in water.
Due to the existence of radio frequency electromagnetic radiation in the air, it is not suitable to be energized in the air for a long time.
It should be calibrated before each measurement. It is recommended to calibrate every 1 month for long-term use. The calibration frequency should be adjusted according to different application conditions (soil quality, moisture content, salt content, pH, etc. of the application)

Wiring Instructions

Color	Function
Brown	V+
Black	GND
Yellow	RS485-A
Blue	RS485-B

Modbus Communication of the Soil Sensor

Here are the specific configurations for the soil sensor that define how data is formatted, transmitted, and checked for errors in Modbus communication:

8 bit binary
Parity bit= none
Stop bit= 1
Error checking – CRC
Baud rate = default 4800

The following refers to specific Modbus register addresses in hexadecimal format and their associated data points for the soil sensor:

Address code=0x01 — the address of the peripheral device

Register address= 0x00 0x9C41 -moisture content
Register address= 0x01 0x9C42 -temperature
Register address= 0x02 0x9C43 -Conductivity
Register address= 0x03 0x9C44 -pH value
Register address= 07D0 0xA411 -Device Address
Register address= 07D1 0xA412 -Device Baud Rate

Command	Baud Rate
0	2400
1	4800
2	9600

You can test this out in a program like ModbusRTUmaster to read moisture, temperature, conductivity, and PH value of the four-in-one device (address 0x01).

0x01 0x03 0x00 0x00 0x00 0x04 0x44 0x09

Here are some helpful details about the results:

Temperature calculation:
When the temperature is lower than 0 °C, the temperature data is uploaded in the form of complement code.

Temperature:
FF9B H(hex) = -101 => temperature = -10.1°C

Moisture calculation:
292 H (Hex) = 658 => Humidity = 65.8%, that is, the soil volume moisture content is 65.8%.

Conductivity calculation:
3E8 H (hex) = 1000 Conductivity = 1000 us/cm

PH value calculation:
38H (hexadecimal) = 56 => PH value = 5.6

The Arduino Nano 33 IoT

Images from the Arduino Store

The Arduino Nano 33 IoT can be powered by the USB connector (5V) or through the Vin pin (4.5V – 21V). Its operating voltage is 3.3V.

Saving Power

Here are two recommended approaches to save power with the Arduino Nano 33 IoT (We’ll be taking the second approach):

Setting up the Arduino Nano 33 IoT

Open the Arduino IDE
Create a new Sketch
Under Boards, add the Arduino SAMD Boards
Select the board and port by clicking on the triangle in the box next to the debug icon:

Setting up the MAX 485 TTL to RS485 Converter Module

Here is some guidance for connecting the Max 485 to the Arduino to the Soil Sensor

Max 485	Description	Arduino	Soil Sensor
VCC	3.3 to 5V	USB	5V (Brown)
GND	Ground	GND	GND (Black)
A	RS485 A (Driver Output)		Yellow Wire
B	RS485 B (Driver Output)		Blue Wire
RO	Receiver Output	RX (0)
DE	Driver Enable Input	10
RE	Receiver Enable Input	10
DI	Driver Input	TX (1)

Wire up the circuit:
- Tie RE to DE with a small wire
- Connect RO to RX
- Connect DI to TX
- Connect Ground to common GND
- Connect VCC to the V35 5V
- Connect RS485 DATA B to Soil Sensor Blue
- Connect RS485 DATA A to Soil Sensor Yellow
- Soil Sensor Brown to V35 5V
- Soil Sensor Black to GND
In the Arduino IDE add the following library:ModbusMaster by Doc Walker
Make sure that the Nano 33 IoT board and USB port are selected.
The function we are interested in is
[code] 0x03 – Read Holding Registers:readHoldingRegisters(uint16_t u16ReadAddress, uint16_t u16ReadQty);[/code]

Copy and paste this code into the Sketch:

[code lang=”arduino”]// github link: https://github.com/4-20ma/ModbusMaster

#include <ModbusMaster.h>

/* Modbus stuff */
#define MODBUS_DIR_PIN 10 // connect DR, RE pin of MAX485 to gpio 10
#define MODBUS_RX_PIN 0 // Rx pin
#define MODBUS_TX_PIN 1 // Tx pin
#define MODBUS_SERIAL_BAUD 4800 // Baud rate for max485 communication

//Initialize the ModbusMaster object as node

ModbusMaster node;
float moisture, pH, conductivity, temperature;

// Pin 10 made high for Modbus transmision mode

void modbusPreTransmission() {
delay(500);
digitalWrite(MODBUS_DIR_PIN, HIGH);
}

// Pin 10 made low for Modbus receive mode
void modbusPostTransmission() {
digitalWrite(MODBUS_DIR_PIN, LOW);
delay(500);
}

void setup() {
// serial communication
Serial.begin(9600);
pinMode(MODBUS_DIR_PIN, OUTPUT);
digitalWrite(MODBUS_DIR_PIN, LOW);

//Serial1.begin(baud-rate, protocol, RX pin, TX pin);.
Serial1.begin(MODBUS_SERIAL_BAUD);

//modbus slave ID 1
node.begin(1, Serial1);

// callbacks allow us to configure the RS485 transceiver correctly
node.preTransmission(modbusPreTransmission);
node.postTransmission(modbusPostTransmission);

}

void loop() {
uint8_t result;

//Modbus function 0x03 Read Holding Registers
result = node.readHoldingRegisters(0, 4);

if (result == node.ku8MBSuccess) {
   Serial.println("Success, Received data: ");
  Serial.print("Moisture: ");

   // we just convert the uint16_t type data array to float type using type casting
   moisture = float(node.getResponseBuffer(0)) * 0.1f;
   temperature = float(node.getResponseBuffer(1)) * 0.1f;
   conductivity = float(node.getResponseBuffer(2));
   pH = float(node.getResponseBuffer(3)) * 0.1f;

Serial.print("Moisture: ");
   Serial.print(moisture);
   Serial.println("%");
   Serial.print("Temperature: ");
   temperature = (temperature * 9) / 5 + 32;
   Serial.print(temperature);
   Serial.println("°F");
  Serial.print("Conductivity: ");
   Serial.print(conductivity);
   Serial.println("us/cm");
  Serial.print("pH value: ");
   Serial.println(pH);
}else {

Serial.print("Failed, Response Code: ");
Serial.print(result, HEX);
Serial.println("");
delay(5000);
}
delay(1000);

}[/code]
Here are the error codes..
If you get an error, make sure:
- Your wires are connected properly
- Your sensor is receiving enough power
- Your sensor is in the dirt

Power Consumption

We still need to put the board to sleep to conserve power. In order to keep our project alive for months/years on the battery/panel strategy, we need to minimize our power consumption. Below you will find two approaches (I’ll be using the second approach).

Approach One: ArduinoLowPower with N-Channel MOSFET

The Arduino Nano 33 IoT can be put into various sleep modes to reduce power consumption. The ArduinoLowPower library is one way to put the board into idle or deep sleep modes. We’ll also need to turn off the sensor. One strategy for turning off the sensor is to use an N-channel mosfet.

Here’s the pseudocode:

Turn off the sensor
Shutdown power during sleep cycle
Wake up the board at a predefined interval
Turn on the sensor

Parts Needed:

1x resistor 10kOhms
IRFZ44N N-channel MOSFET

Wire up the circuit with an N-Channel MOSFET. I’m using an IRFZ44N Mosfet. An N-Channel Mosfet allows us to connect the GNDs of the sensors and board together.
Place a 10KΩ resistor between the Gate (pin 1) and the Source (pin 3).
Pull the Source (pin 3) down by connecting it to GND.
Connect the Drain (pin 2) to the ground of the MAX 485 module.
Connect the Gate (pin 1) to Nano D2.

When adding sleep functions, add a long delay in the setup() function so that you have an opportunity to reprogram the board. Just reset the board to initiate the setup() function.

Adjust your code:
- Include the Arduino Low Power library
- Add an instance variable for the transistor pin:
  [code]int transistorPin=2;[/code]
- Add another variable called counter. This will keep track of how many times we poll the sensor before calling a sleep function
  [code]int counter=0;[/code]
- Add another variable named seconds of type int and set it to 30:
  [code]int seconds=30;[/code]
- Add a long delay in setup():
  [code]delay(5000);[/code]
- Set the pin to an OUTPUT in setup() and set it to LOW:
  [code lang=”arduino”]pinMode(transistorPin, OUTPUT);
  
  digitalWrite(transistorPin, LOW);
  [/code]
- Set counter to 0:
  [code]counter=0;[/code]
- Set the transistorPin HIGH after you connect to the Arduino Cloud. You can do that by adding the line digitalWrite(transistorPin, HIGH); after ArduinoCloud.begin(ArduinoIoTPreferredConnection); in setup()
- In loop, nest the sensor code in a conditional that runs if counter<5.
- At the end of the conditional, increment counter by 1.
- If the condition is not met, call this function: callForSleep()
- Create a callForSleep() function
- Inside the callForSleep() set the transistor pin to low before you call the sleep function:
```
digitalWrite(transistorPin,LOW);
```
- Call sleep after setting the transistorPin LOW
```
LowPower.deepSleep(seconds * 1000);
```
- Call setup()

Approach Two: RTC and P-Channel MOSFET

This second strategy involves a RTC module and P-channel mosfet. This strategy basically does the following (you can find more information in Olivier Staquet’s Arduino-Nano-33-IoT-Ultimate-Guide):

Shutdowns all the power of the circuit during the sleep cycle
Wakes up the microcontroller at a predefined interval (every minute, every hour, every day or at a specific moment).
Consumes only the power required for the RTC clock

Parts Needed:

Adafruit DS3231 Precision RTC Breakout
1x resistor 10k Ohms
1x resistor 100 Ohms
IRF9520 P-channel MOSFET
Pololu S7V7F5 voltage regulator

Wire up this circuit
- Add the DS3231, Voltage Regulator, and MOSFET to your breadboard
- DS3231 connections
  - Connect VIN to VOUT of your Voltage Regulator
  - Connect GND to common ground
  - Connect SCL to Nano A5
  - Connect SDA to Nano A4
  - Connect SQW to MOSFET Gate (pin 1)
  - Connect SQW to VOUT of your Voltage Regulator through a 10KΩ Resistor
- Voltage Regulator connections
  - Connect GND to common ground
  - Connect VIN to 5V
- MOSFET connections
  - Connect Drain (pin 2) to common ground through a 100Ω Resistor
  - Connect Drain (pin 2) to Nano VIN
  - Connect Source (pin 3) to 5V
https://github.com/ostaquet/Arduino-Nano-33-IoT-Ultimate-Guide/blob/master/SavePowerRTC.md
1. Download and install library DS3231 by NothernWidget
2. Include the DS3231 library in your sketch.
3. Add the following to the top of your sketch:
  [code lang=”arduino”]
  #include <Wire.h>
  #include <DS3231.h>
  #include <SPI.h>
  [/code]
4. Add this global variable:
  [code lang=”arduino”]
  DS3231 Clock;
  [/code]
5. In setup() before Serial.begin(), set up the RTC:
  [code lang=”arduino”]
  // Start the I2C interface
  
  Wire.begin();
  
  // Initialize the RTC clock
  
  // Disable alarm
  
  Clock.turnOffAlarm(2);
  
  // Disable oscialltor
  
  Clock.enableOscillator(false, false, 0);
  
  // Disable 32kHz output
  
  Clock.enable32kHz(false);
  
  // Set in 24-hour mode
  
  Clock.setClockMode(false);
  [/code]
6. Before the end of setup(), add the following:
  [code lang=”arduino”]
  // Prepare the next execution (defined by the day, hour, minute, second) + interval
  // Interval:
  // 0b1111 // each second
  // 0b1110 // Once per minute (when second matches)
  // 0b1100 // Once per hour (when minute and second matches)
  // 0b1000 // Once per day (when hour, minute and second matches)
  // 0b0000 // Once per month when date, hour, minute and second matches. Once per week if day of the week and A1Dy=true
  // Set alarm to happen every minute (change to your wanted interval)
  
  // Every time the seconds match 4 (every minute at the 4th second, the system wakes up)
  Clock.setA1Time(1, 2, 3, 4, 0b1110, false, false, false);
  
  Clock.turnOnAlarm(1);
  
  // Empty the I2C buffer
  while (Wire.available()) {
  Wire.read();
  
  }
  [/code]
7. In your loop() function find these lines:
  [code lang=”arduino”]
  } else {
  Serial.print("Failed, Response Code: ");
  Serial.print(result, HEX);
  Serial.println("");
  delay(5000);
  }
  [/code]
8. Paste in the following after the else closes:
  [code lang=”arduino”]
  // End doing something
  // Reset alarm is the last instruction of the program
  // When we reset the alarm, the power is shutdown for the system
  Clock.checkIfAlarm(1);
  
  // We never arrive here because the alarm is cleared
  // on the RTC which cause the shutdown of the circuit
  while (1)
  ;[/code]
9. Verify and Upload
10. Disconnect from the computer to test.
11. When satisfied with the code, reconnect and change to wake up every hour.
Here is the complete circuit diagram:

Connecting to Wi-Fi

If we want to connect to a publish dashboard, we’ll have to modify our code a bit.

The Nano 33 IoT’s embedded Wifi module is the NINA W102 ESP32 based module. It provides support of Wifi 802.11 b/g/n in the 2.4 GHz band and Bluetooth v4.2 (Bluetooth BR/EDR and Bluetooth Low Energy BLE). The module is fully compatible with the official WiFiNINA library.
1. Open a new Sketch.
2. To install the WiFiNINA by Arduino library in the Arduino IDE. Click on the library icon on the left side, search for WifiNINA and click the INSTALL button to install the library:
3. Replace the current sketch with:
  [code lang=”arduino”]/*
  WiFi Web Server LED Blink
  A simple web server that lets you blink an LED via the web.
  This sketch will print the IP address of your WiFi module (once connected)
  to the Serial Monitor. From there, you can open that address in a web browser
  to turn on and off the LED on pin 9.
  If the IP address of your board is yourAddress:
  http://yourAddress/H turns the LED on
  http://yourAddress/L turns it off
  This example is written for a network using WPA encryption. For
  WEP or WPA, change the WiFi.begin() call accordingly.
  Circuit:
  * Board with NINA module (Arduino MKR WiFi 1010, MKR VIDOR 4000 and Uno WiFi Rev.2)
  * LED attached to pin 9
  created 25 Nov 2012
  by Tom Igoe
  */
  #include <SPI.h>
  #include <WiFiNINA.h>
  #include "arduino_secrets.h"
  ///////please enter your sensitive data in the Secret tab/arduino_secrets.h
  char ssid[] = SECRET_SSID; // your network SSID (name)
  char pass[] = SECRET_PASS; // your network password (use for WPA, or use as key for WEP)
  int keyIndex = 0; // your network key index number (needed only for WEP)
  int status = WL_IDLE_STATUS;
  WiFiServer server(80);
  void setup() {
  Serial.begin(9600); // initialize serial communication
  pinMode(LED_BUILTIN, OUTPUT); // set the LED pin mode
  // check for the WiFi module:
  if (WiFi.status() == WL_NO_MODULE) {
     Serial.println("Communication with WiFi module failed!");
     // don't continue
     while (true);
  }
  String fv = WiFi.firmwareVersion();
  if (fv < WIFI_FIRMWARE_LATEST_VERSION) {
     Serial.println("Please upgrade the firmware");
  }
  // attempt to connect to WiFi network:
  while (status != WL_CONNECTED) {
     Serial.print("Attempting to connect to Network named: ");
     Serial.println(ssid); // print the network name (SSID);
     // Connect to WPA/WPA2 network. Change this line if using open or WEP network:
     status = WiFi.begin(ssid, pass);
     // wait 10 seconds for connection:
     delay(10000);
  }
  server.begin(); // start the web server on port 80
  printWifiStatus(); // you're connected now, so print out the status
  }
  void loop() {
  WiFiClient client = server.available(); // listen for incoming clients
  if (client) { // if you get a client,
     Serial.println("new client"); // print a message out the serial port
     String currentLine = ""; // make a String to hold incoming data from the client
     while (client.connected()) { // loop while the client's connected
       if (client.available()) { // if there's bytes to read from the client,
         char c = client.read(); // read a byte, then
         Serial.write(c); // print it out to the serial monitor
         if (c == '\n') { // if the byte is a newline character
           // if the current line is blank, you got two newline characters in a row.
           // that's the end of the client HTTP request, so send a response:
           if (currentLine.length() == 0) {
             // HTTP headers always start with a response code (e.g. HTTP/1.1 200 OK)
             // and a content-type so the client knows what's coming, then a blank line:
             client.println("HTTP/1.1 200 OK");
             client.println("Content-type:text/html");
             client.println();
             // the content of the HTTP response follows the header:
             client.print("Click <a href=\"/H\">here</a> turn the BUILTIN LED on<br>");
             client.print("Click <a href=\"/L\">here</a> turn the BUILTIN LED off<br>");
             // The HTTP response ends with another blank line:
             client.println();
             // break out of the while loop:
             break;
           } else { // if you got a newline, then clear currentLine:
             currentLine = "";
           }
         } else if (c != '\r') { // if you got anything else but a carriage return character,
           currentLine += c; // add it to the end of the currentLine
         }
         // Check to see if the client request was "GET /H" or "GET /L":
         if (currentLine.endsWith("GET /H")) {
           digitalWrite(LED_BUILTIN, HIGH); // GET /H turns the LED on
         }
         if (currentLine.endsWith("GET /L")) {
           digitalWrite(LED_BUILTIN, LOW); // GET /L turns the LED off
         }
       }
     }
     // close the connection:
     client.stop();
     Serial.println("client disconnected");
  }
  }
  void printWifiStatus() {
  // print the SSID of the network you're attached to:
  Serial.print("SSID: ");
  Serial.println(WiFi.SSID());
  // print your board's IP address:
  IPAddress ip = WiFi.localIP();
  Serial.print("IP Address: ");
  Serial.println(ip);
  // print the received signal strength:
  long rssi = WiFi.RSSI();
  Serial.print("signal strength (RSSI):");
  Serial.print(rssi);
  Serial.println(" dBm");
  // print where to go in a browser:
  Serial.print("To see this page in action, open a browser to http://");
  Serial.println(ip);
  }[/code]
4. Create a new tab and name it arduino_secrets.h. Then add the following and include your network (yourssid) and password (yourpasswd):
  [code lang=”arduino”]#define SECRET_SSID "yourssid"
  #define SECRET_PASS "yourpasswd"
  [/code]
5. Upload, open the Serial monitor, and then follow the instructions to test.
Connecting to a Public Dashboard – Qubitro

For our public dashboard, we’ll use Qubitro and the MQTT protocol.

MQTT is a lightweight application layer messaging protocol designed for resource-constrained devices used for IoT applications. It utilizes a topic-based, publish-subscribe, or Pub/Sub model where the protocol defines how IoT devices can publish and subscribe to data over the Internet. There is a sender (Publisher) and a receiver (Subscriber) and they communicate by topics.

MQTT is the most commonly used messaging protocol for IoT because:
- It is lightweight and efficient- Its small code footprint and minimal network bandwidth usage enable efficient communication even in constrained environments
- Low power consumption – This makes it suitable for battery-operated IoT devices, such as sensors and actuators, that need to conserve power to extend battery life<
- Easy to implement and has numerous libraries and associated tools
- Supports bi-directional messaging between device and cloud
- Can scale easily to handle a large number of devices
- Can support levels of reliable message delivery – the three levels of Quality of Service allow developers to balance between overhead and the importance of message delivery guarantees
- Works well over unreliable networks- the Pub/Sub model makes it suitable for IoT devices that might be operating on limited data plans or in areas with poor network connectivity.
- Works with TLS/SSL and common authentication protocols
Before we can send data, we need to create a new MQTT source at Qubitro.
1. Create an account or log into your Qubitro account.
2. Create a New Project:
3. Add the details to your project and click on the Create button:
4. Select the project:
5. On the project detail page, click on the New Source button:
6. Select MQTT:
7. Complete the details:
8. Click on the project again and select Connection details:
9. You’ll need the USERNAME and PASSWORD for your Arduino Code.
10. Create a New Sketch.
11. Select your board and USB port.
12. Create a new tab named “arduino_secrets.h”
13. Complete the following:
  [code lang=”arduino”]#define WiFi_ID "[YOUR Network]"
  #define WiFi_PASSWORD "[YOUR password]"
  #define DEVICE_ID "[Qubitro USERNAME]"
  #define DEVICE_TOKEN "[Qubitro TOKEN]"
  [/code]
14. Back in main Sketch, replace the current contents with the following:
  [code lang=”arduino”]#include <QubitroMqttClient.h>
  #include <WiFiNINA.h>
  #include <Wire.h>
  #include <DS3231.h>
  #include <SPI.h>
  #include <ModbusMaster.h>
  #include "ArduinoLowPower.h"
  #include "arduino_secrets.h"
  
  #define PERIOD 5000
  
  // Global variables
  DS3231 Clock;
  
  WiFiClient wifiClient;
  QubitroMqttClient mqttClient(wifiClient);
  
  // WiFi Credentials
  char ssid[] = WiFi_ID;
  char pass[] = WiFi_PASSWORD;
  
  char deviceID[] = DEVICE_ID;
  char deviceToken[] = DEVICE_TOKEN;
  char host[] = "broker.qubitro.com";
  int port = 1883;
  
  /* Modbus stuff */
  #define MODBUS_DIR_PIN 10 // connect DR, RE pin of MAX485 to gpio 10
  #define MODBUS_RX_PIN RX // Rx pin
  #define MODBUS_TX_PIN TX // Tx pin
  #define MODBUS_SERIAL_BAUD 4800 // Baud rate for max485 communication
  
  unsigned long next = 0;
  int publishCounter = 0;
  int counter = 0;
  int wifiCounter = 0;
  
  ModbusMaster node;
  float moisture, pH, conductivity, temperature, voltage, battery;
  // Pin 10 made high for Modbus transmision mode
  void modbusPreTransmission() {
  delay(500);
  digitalWrite(MODBUS_DIR_PIN, HIGH);
  }
  // Pin 10 made low for Modbus receive mode
  void modbusPostTransmission() {
  digitalWrite(MODBUS_DIR_PIN, LOW);
  delay(500);
  }
  
  void setup() {
  // Warm-up
  delay(5000);
  analogReadResolution(12);
  // Start the I2C interface
  Wire.begin();
  
  int wifiCounter = 0;
  // Initialize serial port
  Serial.begin(9600);
  
  // connect to Wifi network:
  Serial.print("Connecting to WiFi…");
  WiFi.begin(ssid, pass);
  while (WiFi.status() != WL_CONNECTED) {
  if (wifiCounter < 5) {
  Serial.print(".");
  delay(1000);
  wifiCounter++;
  status = WiFi.begin(ssid, pass);
  } else {
  LowPower.sleep(2000);
  NVIC_SystemReset();
  setup();
  }
  }
  
  Serial.println("\tConnected to the WiFi !");
  // You need to provide device id and device token mqttClient.setId(deviceID);
  mqttClient.setDeviceIdToken(deviceID, deviceToken);
  Serial.println("Connecting to Qubitro…");
  if (!mqttClient.connect(host, port)) {
  Serial.println("Connection failed! Error code = ");
  Serial.println(mqttClient.connectError());
  Serial.println("Visit docs.qubitro.com or create a new issue on github.com/qubitro");
  while (1) ;
  }
  
  Serial.println("Connected to the Qubitro !");
  mqttClient.onMessage(receivedMessage);
  mqttClient.subscribe(deviceID);
  // Initialize the RTC clock // Disable alarm Clock.turnOffAlarm(2);
  // Disable oscialltor Clock.enableOscillator(false, false, 0);
  // Disable 32kHz output Clock.enable32kHz(false);
  // Set in 24-hour mode Clock.setClockMode(false);
  // Serial communication Serial.begin(9600);
  pinMode(MODBUS_DIR_PIN, OUTPUT);
  digitalWrite(MODBUS_DIR_PIN, LOW);
  counter = 0;
  publishCounter = 0;
  
  //Serial1.begin(baud-rate, protocol, RX pin, TX pin);
  Serial1.begin(MODBUS_SERIAL_BAUD);
  
  //modbus slave ID 1 node.begin(1, Serial1);
  // callbacks allow us to configure the RS485 transceiver correctly
  
  node.preTransmission(modbusPreTransmission);
  node.postTransmission(modbusPostTransmission);
  
  // Prepare the next execution (defined by the day, hour, minute, second) + interval
  // Interval:
  // 0b1111 // each second
  // 0b1110 // Once per minute (when second matches)
  // 0b1100 // Once per hour (when minute and second matches)
  // 0b1000 // Once per day (when hour, minute and second matches)
  // 0b0000 // Once per month when date, hour, minute and second matches. Once per week if day of the week and A1Dy=true
  // Every time the seconds match 4 (every minute at the 4th second, the system wakes up)
  Clock.setA1Time(1, 2, 3, 4, 0b1110, false, false, false);
  Clock.turnOnAlarm(1);
  
  // Empty the I2C buffer while (Wire.available()) { Wire.read();
  }
  Serial.println("here");
  }
  
  void loop() {
  mqttClient.poll();
  if (millis() > next) {
  next = millis() + PERIOD;
  
  // Change if possible to have a message over 256 characters
  readModVals();
  publishSensorVal();
  publishCounter++;
  }
  }
  
  void receivedMessage(int messageSize) {
  Serial.print("New message received:");
  Serial.print(mqttClient.messageTopic());
  Serial.print("', length ");
  Serial.print(messageSize);
  Serial.println(" bytes:");
  // We want to read each character into a useable String
  String content = "";
  char character;
  while (mqttClient.available()) {
  character = Serial.print((char)mqttClient.read());
  content.concat(character);
  }
  Serial.println(content);
  Serial.println();
  Serial.println();
  timeToTurnOff();
  }
  
  void timeToTurnOff() {
  Serial.println("sleep");
  Clock.checkIfAlarm(1);
  
  // We never arrive here because the alarm is cleared
  // on the RTC which cause the shutdown of the circuit
  while (1)
  ;
  }
  
  //Modbus function 0x03 Read Holding Registers
  result = node.readHoldingRegisters(0, 5);
  
  if (result == node.ku8MBSuccess) {
  Serial.println("Success, Received data: ");
  
  Serial.print("Moisture: ");
  // we just convert the uint16_t type data array to float type using type casting
  moisture = float(node.getResponseBuffer(0)) * 0.1f;
  temperature = float(node.getResponseBuffer(1)) * 0.1f;
  conductivity = float(node.getResponseBuffer(2));
  pH = float(node.getResponseBuffer(3)) * 0.1f;
  float salinity = float(node.getResponseBuffer(4)) * 0.1f;
  
  Serial.print("Moisture: ");
  Serial.print(moisture);
  Serial.println("%");
  
  Serial.print("Temperature: ");
  temperature = (temperature * 9) / 5 + 32;
  Serial.print(temperature);
  Serial.println("°F");
  
  Serial.print("Conductivity: ");
  Serial.print(conductivity);
  Serial.println("us/cm");
  
  Serial.print("pH value: ");
  Serial.println(pH);
  
  delay(1000);
  }
  }
  }
  
  void publishSensorVal() {
  
  // Change if possible to have a message over 256 characters
  static char payload[256];
  
  snprintf(payload, sizeof(payload) – 1, "{\"m\":%.2f,\"t\":%.2f,\"c\":%.2f,\"pH\":%.2f}",
  moisture, temperature, conductivity, pH);
  
  if (publishCounter >= 2) {
  mqttClient.beginMessage(deviceID);
  // Send value
  mqttClient.print(payload);
  mqttClient.endMessage();
  delay(1000);
  }
  }
  [/code]
15. Set up your Qubitro dashboard:
Characterizing Power Consumption

Now that we have taken steps to reduce the power consumption, we need to determine how much power our current system draws.

We need to measure the power consumption when sensing, transmitting, and sleeping. Once we have those values, we can use this calculator to determine what size panel we’ll need.

Power consumption of Microcontroller

Power consumption of Battery

Power consumption of RTC

Sensing/Awake Transmitting Sleeping

Microcontroller 60mA 140mA 9mA

RTC 0.1 mA 0.1 mA 0.1 mA

60.1 140.1 9.1

Time in seconds 20 1 60

Battery 0.6wh per day 0.6wh per day 0.6wh per day

The device is consuming a whopping 3.39 Watt hours per day. If we change the sleep to every hour, we can bring down the consumption to 1.73 Watt hours per day which is more efficient and sustainable in terms of battery life.

Return to the code and update the length of sleep.

Connecting to Solar

If we use the 5 Watt, 6 Volt panel and V35 battery, our system should theoretically last about 20 days without sun.

Here’s how we connect the 5 Watt 5 Volt 35Wh Solar System

Wrapping up

This blog post has provided a comprehensive walkthrough for setting up and configuring, deploying and publishing data for a simple IoT device with the Nano 33. Let us know what you come up with in your next IoT project.

	Sensing/Awake	Transmitting	Sleeping
Microcontroller	60mA	140mA	9mA
RTC	0.1 mA	0.1 mA	0.1 mA
	60.1	140.1	9.1
Time in seconds	20	1	60
Battery	0.6wh per day	0.6wh per day	0.6wh per day

Enclosures can get very hot in sunny locations and very cold in many locations. This tutorial does not address all the safety issues associated with charging a lithium ion battery outdoors and you should understand these prior to deploying a battery powered system. Batteries charged outside of specifications can overheat and catch fire. Here are some key considerations for safely housing lithium-ion batteries in enclosures:

Follow battery cell instructions for safe charging and storage
Always use cables and adapters that are made specifically for the device
Store and charge batteries away from anything flammable
Ensure your charge controller includes over and under temperature protection and that these settings match the specifications on your battery cells
Ensure your charge controller has over charge, over discharge and short circuit protection

If a battery changes shape or is leaking, you should discontinue use immediately.

Tide Monitoring Tutorial with Particle Monitor One

Lizabeth Arum — Wed, 17 Jan 2024 18:27:46 +0000

Project Overview

We deployed a solar powered water level monitor in New York Harbor on Governors Island using Particle’s Monitor One Developer Edition. Similar to the Tracker One, the Monitor One is a code free cellular device but it has a larger waterproof enclosure with room inside for an expansion card and additional connectors allowing for more customization.

The beauty of the Monitor One system is that you can control everything from the Console. Even after the system has been deployed, you can remotely change the sleep interval, monitor the sensor data, or track the device’s vitals.

Particle Console Events

Thanks to the Harbor School on Governors Island for agreeing to host the system on their pier.

In this post, we’ll cover:

Getting started with Particle’s Monitor One
An introduction to RS485
Measuring and monitoring the external battery voltage
Enabling sleep to make the device more efficient
Deploying the system with appropriately sized solar panel and battery
Publishing the data to the dashboard

Background on Tide Monitoring

From April-October, I can be found sailing in New York Harbor with the One°15 sail club. To help navigate the waters and strategize for Wednesday night racing, I use several apps to monitor the wind and tides, so why not create one more? This exercise also gives me a chance to see how my device might align with commercial applications.

If you’re looking for complete products, there are a number of established companies that have water level monitoring solutions including: Hohonu, Divirod and Greenstream.

This was how we imagined the deployment before visiting the site:

Original POC

And, this was how we actually deployed the device:

Actual Deployment

Parts Needed for Tide Monitoring

Particle Monitor One
URM08 – Waterproof Industrial Ultrasonic Distance Sensor (35~550cm, ModBus-RTU)
Two 5.6KΩ resistors
V70
9W-18V ETFE Panel
Extension with Leads – Molex Extension
3.5×1.1mm Extension Cable – 4 Foot
PG 13.5 Cable Glands
Medium Solar Ready Enclosure
Solar Panel Bracket – Medium
Drill
Wires
Optional:
- RS485 Wind Vane Direction Sensor
- XL6009 DC-DC Booster Converter Module
- A second panel
Optional:
- Lever Wire Nuts Connectors Kit
- SparkFun USB to RS-485 Converter
- Arduino Uno
- RS485 Shield
- Software
  - CoolTerm
  - Modbus RTU Master

Software Requirements

Visual studio code
Particle workbench installed
Particle CLI installed (used for the serial logging)
GitHubclient
A claimed Monitor One device.

Helpful Documents

The Monitor One

Advantages of the Monitor One

The console provides a programming-free way to set up your system.
You can control the system remotely through the console. This means that you can easily change how often the system polls the sensors during development and even after the system is deployed.
The system uses cellular connectivity so it works anywhere where there is cellular service.

Step 1: Follow the Monitor One Quickstart Guide

In the Console, on the device page, make sure you mark the device as a development device. Once it is marked, you should see this displayed:

Step 2: Set Up the Particle Workbench in Visual Studio Code

Step 3: Gather Your Parts

Step 4: Connect the Sensor

All of our connections to the M1 will use the I/O Card M12 8-pin to flying leads

Conn P1 (M12)	Color	Function/GPIO	Using in our application
1	white	CAN_P	No
2	red	VIN (6-30 VDC)	Yes
3	green	4-20mA input A7	No
4	yellow	0-10V input A6	Yes
5	gray	RS485_B (N)	Yes
6	pink	RS485_A (P)	Yes
7	blue	CAN_N	No
8	black	GND	Yes

Ultrasonic sensor

This is the detection area of the sensor. While the max distance is 550 cm, you also need to be about a meter away from obstructions.

Sensor’s Detection Area

The URM08 – Waterproof Industrial Ultrasonic Distance Sensor employs an RS485 communication interface and supports the Modbus protocol.

RS-485 is a robust standard for serial communication. It defines the electrical characteristics of the data and how it is physically transmitted through a network.

Modbus, on the other hand, is a communication protocol that defines a message structure independent of network type. It is one of the most widely used protocols in the industrial sector, particularly for connecting electronic equipment.

Modbus and RS-485 are often used in industrial communication systems where the Modbus protocol can be implemented over an RS-485 network. In a typical setup, Modbus commands are sent over RS-485 to a device where the command is processed and returns a response. Modbus defines how the data is structured and processed, while RS-485 defines how the data is physically transmitted between devices.

The URM08 – Waterproof Industrial Ultrasonic Distance Sensor (35~550cm, ModBus-RTU) uses Modbus RTU.

Modbus RTU is an implementation of Modbus that transmits data in binary format and uses a simple 16-bit structure with a Cyclic Redundancy Checksum (CRC), 8-bit bytes, one bit at a time, at a baud rate ranging from 1200 bps to 115200 bps. RTU values are encoded as standard big-endian binary where the Most Significant Byte (MSB) is encoded before the Least Significant byte (LSB).

Each exchange of data consists of a request from the controller, in our case, the M1, followed by a response from the worker (the sensor). Each data packet, whether request or response, begins with the device address or worker’s address, followed by function code, and then by parameters defining what is being asked for or provided.

Each request is broken down like this:

Device Address
Function Code
Register Number
Register Count
Data
Checksum

For more information about the Modbus RTU Protocol , see this Unserver guide or this IPC2U guide.

When connecting the M1 to the sensor you want to connect the sensor’s red wire black wires to a battery, the green wire to the M1’s RS485-N, and the yellow wire to the M1’s RS485-P.

M1	URM08 (SEN0246)
RS485_N (Gray)	M1 RS485-B (Yellow)
RS485_P (Pink)	RS485-A (Green)
	VIN (Red) Do not power from M1 supply!
GND (Black)	GND (Black)

Because the URM08 requires 6V-12V, you must initially power it separately from the M1. While setting up your system and connected to the M1’s AC charger, the VIN will receive 24V and will damage your sensor.

Step 5: Connecting the M1 to your computer

Open the M1 and connect a micro USB cable between it and your computer.

Step 6: Clone the Firmware

Cloning the firmware will create a local copy of the official version so that you can modify it with the custom functions.

Download the M1’s official firmware to a folder on your desktop.

Step 7: Open the folder from the Particle Workbench

In VSCode go to File → Open folder and select/open the downloaded folder:

Click on Yes, I trust the authors:

Step 8: Modify the code

In the Explore panel, open main.cpp:

In the top search bar run the command:

 >particle: configure project for device

Choose device OS@5.5.0 (or the latest version):
Choose Asset Tracker / Monitor One:
Click esc when asked for a device name:
We’re ready to add a line of code. This example is configured in SEMI_AUTOMATIC mode, so we need to add a Particle.connect() at the end of the setup() function:

Step 9: Compile the code

Click on the the check mark in the upper right to compile your code:

Step 10: Flash the M1:

When the compiler finishes, click on the lightning bolt in the upper right hand corner to flash the M1:

Step 11: Using the Console to Enable Modbus Settings

Return to the Particle Console.

Make sure that you set the baud rate to 19200 under the Modbus RS-485 setting in Gateway Settings and click Save:

Step 12: Set up Modbus Polling 1

To get the distance value you would think you would consult the sensor’s Product Wiki, but in this case you’d be mistaken. We’ll look for the command to read the distance, but what we’ll find is not what we expect:

This particular sensor is described as using Modbus RTU, but the information provided in its wiki contradicts this. The SEN0246 sensor datasheet provides a set of specific commands for operations like reading distance and temperature, setting the address, and setting the baud rate. These commands are designed to communicate with the sensor’s firmware and are unique to this particular model. They follow a format that includes a frame header, device address, data length, command, data (if any), and checksum.

This format is different from standard Modbus RTU commands, which typically consist of a device address, function code, data (such as register addresses and values), and a checksum. In Modbus RTU, common function codes include reading and writing to discrete inputs/outputs and holding/input registers.

A Modbus RTU command to read the analog input from a holding register would follow this format:

BYTE	REQUEST	BYTE	ANSWER
(Hex)	Field name	(Hex)	Field name
11	Device address	11	Device address
03	Functional code	03	Functional code
00	Address of the first register Hi bytes	06	Number of bytes more
01	Address of the first register Lo bytes	AE	Register value Hi #40108
00	Number of registers Hi bytes	41	Register value Lo #40108
00	Number of registers Lo bytes	56	Register value Hi #40109
5A	Checksum CRC	52	Register value Lo #40109
D7	Checksum CRC	43	Register value Hi #40110

The command looks like this: 11 03 00 01 00 D7 5A, but our documentation provides different commands, ones that do not begin with the device’s ID.

The truth is, I actually didn’t figure out how to use this sensor on my own. The very helpful Alberto Sanchez from the Particle team, with a bit of research on his part, came to my aid:

While using the non-standard protocol (the one in the datasheet), the address is 0x02. But for using Modbus standard protocol, the address for the distance is 0x01. That is something not listed on the specs. I found it on a forum, tested it and it worked on my device. https://www.dfrobot.com/forum/topic/312312

What we do need from the datasheet is the device ID.

Enable Modbus Polling 1. It is disabled as the default:
Set the Modbus Server ID to 17. The ID for the sensor is Hex 11, which is Decimal 17:
Set the following and then press Save:
- Polling Interval to15. This will be good for testing. When all has been tested, you’ll set this to a different interval.
- Publish polled value to always
- Modbus Function to holding_register (This is associated with the functional code hex value 0x03)
- Register Address to 1 (0x01)
- Modbus data type to unit16
- Mask value to 65535
- Shift Value to 0
- Offset Value to 0
- Scaling Value to 0
Click Save.
Click on Events and wait until you start to see your modbus values.
Enable Modbus Polling 2.
Set the Modbus Server ID to 17.
Set the following and then press Save:
- Polling Interval to 15. This will be good for testing. When all has been tested, you’ll set this to a greater interval.
- Publish polled value to always
- Modbus Function to holding_register (This is associated with the functional code hex value 0x03)
- Register Address to 2 (0x02)
- Modbus data type to unit16
- Mask value to 65535
- Shift Value to 0
- Offset Value to 0
- Scaling Value to 0.1

Step 13: Troubleshooting

If your Modbus result is 226, you have a communication error with your sensor. Check the wiring, especially between power and GND. If you still get 226 you could have:

The wrong baud rate
The wrong Modbus Server ID
The wrong Register Address (remember to convert your Hex value to decimal)

If your result is 224. You have power, but your A and B lines are not connected properly. Check your wiring.

You can connect a USB to RS485 converter to the circuit and then use a serial program to monitor the Modbus commands from the M1. I used CoolTerm for the Mac and ModbusRTUMaster (not simultaneously) to monitor the transmissions.

Step 14: Characterize Power Consumption

To turn off/disconnect the internal battery enter the shipping mode command in the console. Shipping mode allows the device to be shipped in a way that the battery does not discharge. Note that you can only get out of shipping mode by connecting the device to USB power or power by the M8 connector.
{"cmd":"enter_shipping"}
I connected my power and GND lines to a programmable power supply and collected the following data:
- When not sending data I measured 20mA.
- When actively sensing and sending data, I measured 110mA.
The system takes less than 10 seconds to transmit data, so if I sent data every thirty minutes

Sleeping: 0.02 A * 12 V* 24*(86376/86400)(Proportion per Day )= 5.75840 Wh

Awake: 0.11 A * 12 V * 24* (24/86400)(Proportion per Day )=0.01760 Wh

Total=5.77 Wh per day

To determine which panel and battery I need, I considered the following information:
- Daily Energy Consumption=5.77 Wh per day
- Average Sunlight Hours=The average sunlight hours in New York City (NYC) in December are typically about 4 to 5 hours of effective sunlight per day.
- Solar Panel: If we select the 9 Watt 18 Volt Solar Panel we know that in December we will be able to charge the battery for 4 hours a day.
- Battery: We need a battery that can store enough energy to run the device for days when sunlight might be insufficient. The V70 outputs 12V and has a capacity of 71 Watt Hours.
  71/5.77=12.305

The V70 Battery with a 9W-18V ETFE Panel can theoretically run indefinitely under normal conditions with sufficient daily sunlight. The battery alone provides around 12 days of backup power without solar charging, and this duration extends with partial solar charging on less sunny days.

Step 15: Adding a Voltage Divider Circuit

And, of course we want to measure our battery voltage to understand how our system is performing, but how do we connect a voltage divider to the Monitor One? Once again, Alberto from Particle provided the answer:

We need to use two 5.6KOhm resistors to scale down our 12 Volts:
Back in the Console, select the IO setting:
By default, the scaling is 0-10V, but we can scale down 12V to half, and then multiply the maximum value by 2. To do this, change the sensor high setting from 10 to 24:
Save your settings and you’ll see the measurement included in the location (loc) event as io_v
You don’t need to wait for the location event to check your scaling or calibrations, you can get the value instantly, as long as the device is not in sleep mode. Just look at the Voltage In variable on the right pane and click GET:

Step 16: Putting the Board to Sleep

Sleep Mode can be set to enable or disable in the Console.

Post Publish Execution Time is the minimum duration in seconds to stay awake after publishing before going to sleep. The default is 10 seconds. This provides enough time to make sure a software update can be started when waking up from sleep. If a software update starts, the device will automatically stay awake until the update completes.

Maximum Connecting Time is the maximum duration, in seconds, to wait for being cellular-connected and to obtain a GNSS lock before publishing. If connecting takes too long, then the device will go back to sleep instead of continuously attempting to connect. The default is 90 seconds.

Here are best practices from Particle regarding sleep:

If you are sleeping for less than 10 seconds, you shouldn’t use sleep at all, and instead just stay awake.
If you are sleeping less than 10 minutes, you should never use a cellular off mode because frequently reconnecting to cellular may use more power than it saves, and also your SIM may be banned from the cellular network for aggressive reconnection.
If you are sleeping more than 15 minutes, using cellular off mode uses the least power.
From 10 to 15 minutes, using cellular standby or cellular off is a toss-up, and will depend on other factors.

To enable sleep I consulted again with Alberto:

Make sure that Modbus polling settings use a Polling interval less than the value used in the Post Publish Execution Time on the sleep settings.
I set each of my Modbus Polling Intervals to 10 seconds.
I set the Post Publish Execution Time in Sleep to 40 and the Maximum Connection Time to 90 seconds.

And here is where the magic happens: I set my Minimum location update frequency to be my desired interval. In this case, every 20 minutes, or specifically 2100 seconds. And then I set my Maximum location update frequency to a number less than the minimum. In my case, I set it to 600.

With these settings, the device will wake up to post the location data every 2100 seconds. When it wakes, the Monitor One will stay on for at least 40 seconds, allowing the Modbus to be polled and published a couple of times.

Step 18: Connecting to a Dashboard

For this project I connected the Monitor One to a Datacake dashboard. Datacake is a cloud-based platform offering tools for building custom IoT applications and dashboards.

To set up the dashboard, I followed this Datacake tutorial

And here is the payload decoder:

/*

Datacake Template for Particle.io Asset Tracker One
Author: derived from Simon Kemper
Version: 0.2
(c) Datacake GmbH
*/
function calculateDistance(lat1, lon1, lat2, lon2) {
    Number.prototype.toRad = function() {
        return this * Math.PI / 180;
    }            
    var R = 6371; // km
    var dLat = (lat2-lat1).toRad();
    var dLon = (lon2-lon1).toRad();
    var a = Math.sin(dLat/2) * Math.sin(dLat/2) + 
    Math.cos(lat1.toRad()) * Math.cos(lat2.toRad()) * 
    Math.sin(dLon/2) * Math.sin(dLon/2);
    var c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a));
    var d = R * c;
    return d;
}
function calculateF(celsius){
 return (9*celsius)/5+32;   
}
function map_range(value, low1, high1, low2, high2){
return low2 + (high2 - low2) * (value - low1) / (high1 - low1);
 
}
function calculateSlope(x1, y1, x2, y2) {
    return (y2 - y1) / (x2 - x1);
}
function calculateIntercept(x, y, slope) {
    return y - slope * x;
}
// Data points
const x1 = 164, y1 = -0.9;
const x2 = 86, y2 = 5.2;
// Calculate slope and intercept
const slope = calculateSlope(x1, y1, x2, y2);
const intercept = calculateIntercept(x1, y1, slope);
function convertCmToTideLevel(cm) {
    return slope * cm + intercept;
}
function Decoder(payload, event) { 
    var decoded = {};
    if (event == "loc") {     
        payload = JSON.parse(payload);
        if (payload.cmd == "loc") {    
            if ("batt" in payload.loc) decoded.battery = payload.loc.batt;
            if ("cell" in payload.loc) decoded.cellular = payload.loc.cell;
            if ("speed" in payload.loc) decoded.speed = payload.loc.speed;
            if ("alt" in payload.loc) decoded.altitude = payload.loc.alt;
            if ("lck" in payload.loc) decoded.has_fix = payload.loc.lck ? true : false;
            if ("temp" in payload.loc) decoded.temperature = payload.loc.temp;
            if ("io_v" in payload.loc) decoded.io_v = payload.loc.io_v;
            
            // Decode Location and check for valid data
            
            if (("lat" in payload.loc) && (decoded.has_fix) && (payload.loc.lon != 0) && (payload.loc.lat != 0)) {
                   
                // Store new Location in Dictionary for Datacake Fields
                
                decoded.location = "(" + payload.loc.lat + "," + payload.loc.lon + ")";
                
                /* --- Experimental - Geofencing and Distance Covered Detection --- */
                
                // Calculate Relative + Total Distance covered
                
                // Check if we already have a location stored (skip otherwise)
                
                try {
                    if (measurements.LOCATION.value != 0) {
                        
                        // get old position from Datacake Database
                        
                        var oldLocation = measurements.LOCATION.value.replace("(","").replace(")","").split(",");
                        var oldLat = parseFloat(oldLocation[0]);
                        var oldLong = parseFloat(oldLocation[1]);
                        var newLat = payload.loc.lat;
                        var newLong = payload.loc.lon;
                        
                        // get old distance from Datacake
                        
                        var oldDistance = measurements.DISTANCE.value;
                        
                        // Calculate new distance
                        
                        var newDistance = calculateDistance(oldLat, oldLong, newLat, newLong);
                        
                        // Distance is stored in a Counter-Field. These need absolute values.
                        // Counter fields can be used to show relative changes and relative values over time period
                        
                        decoded.distance = oldDistance + newDistance;    
                        
                        // Geofencing - Distance from Homezone
                        
                        try {
                            if (measurements.GEOFENCE_HOMEZONE_LOCATION.value != 0) {
                                
                                var homezoneLocation = measurements.GEOFENCE_HOMEZONE_LOCATION.value.replace("(","").replace(")","").split(",");
                                var homezoneLat = parseFloat(homezoneLocation[0]);
                                var homezoneLong = parseFloat(homezoneLocation[1]);
                                
                                decoded.geofence_distance_from_homezone = calculateDistance(homezoneLat, homezoneLong, newLat, newLong);                                                                                
                                
                            }                            
                        } catch (e) {
                            console.log("no homezone set");
                        }
                        
                        
                    }                    
                } catch (e) {
                    console.log("catched no value on history");
                }
            
            }
            
        }   
        
    } else if (event == "spark/device/diagnostics/update") {
        
        payload = JSON.parse(payload);
        
        decoded.cellular_radio_access_technology = payload.device.network.cellular.radio_access_technology;
        decoded.cellular_operator = payload.device.network.cellular.operator;
        
    } else if (event == "spark/status") {
        
        if (payload == "online") {
            
            decoded.online_status = true;
            
        } else {
            
            decoded.online_status = false;
        }
    } else if (event == "modbus") {
        
        payload = JSON.parse(payload);
if (payload.modbus[0].name == "modbus2"){
            decoded.Temp = calculateF(payload.modbus[0].value);
            
        } 
        else if (payload.modbus[0].name == "modbus1"){
            decoded.TideLevel=convertCmToTideLevel(payload.modbus[0].value);
        }
    
    }
    // Array where we store the fields that are being sent to Datacake
    var datacakeFields = []
    
    // take each field from decoded and convert them to Datacake format
    for (var key in decoded) {
        if (decoded.hasOwnProperty(key)) {
            datacakeFields.push({field: key.toUpperCase(), value: decoded[key]})
        }
    }      
    
    // forward data to Datacake
    return datacakeFields;
}

Step 17: Deploying

On a very windy recent January afternoon, Jeff Crystal and I ferried over to Governors Island. Once there, we met with Dorick Lee’s Harbor School HS class to talk about the project and how we could in turn help them add solar to their own water-related spring physical computing projects.

The parts of our system laid out on the table before installation

After speaking with the students, we made our first attempt at installation. In the first iteration we found that our Ultrasonic device was over a pair of cables instead of water:

First attempt at installing

Final installation

Fortunately, we were able to quickly scout out a better location and in short order uninstalled and reinstalled the system:

The lesson learned here was if at all possible, visit the location before deploying your system. We were lucky that we brought multiple zip ties, hose clamps, u bolts, nuts, and a cordless drill. Being prepared allowed us to quickly pivot from one location to another.

Installed

Using unistruts and u bolts

Next steps

Next steps could be adding another sensor or designing an entirely different configuration.

Adding Another Sensor

Wind Vane

I really wanted to add a wind vane to the project, but this would require a different solar system set up.

The default baud rates for the wind vane and the ultrasonic sensors are different. While the default rate for the ultrasonic sensor is 19200, the wind vane is 9600. Fortunately, the ultrasonic sensor can also work at 9600, but we do need to set it.

Arduino RS485 Shield

Changing the baud rate of the ultrasonic sensor was a bit challenging. After failing to change the speed using CoolTerm, Serial, or modbusRTUMaster, I ended up attaching the sensor to an Arduino Uno with aRS485 Shield.

To change the baud rate from the default, I ran this simple program that used the command from the product wiki and a checksum that I got from this online checksum calculator that Particle’s Alberto recommended:

unsigned char i=0;

//command to change baud rate to 9600
unsigned char CMD[9]={0x55,0xAA,0x11,0x01,0x08,0x03,0x1C,0x7B, 0x0B}; //

void setup() {
	// Serial1.begin(19200);  //Communicate with module via Serial1, set baud rate to 19200
	 Serial.begin(19200);   //Set Serial to serial port of data output

}

void loop() {
	for(i=0;i<9;i++){
	   Serial.write(CMD[i]);
	   }
	delay(50);  //Wait data to return
	i=0;
}

Once the baud rate was changed, you’ll need to reset the baud rate to 9600 in the Console:

Like the ultrasonic sensor, the RS485 Wind Vane Direction Sensor also employs RS485 communication interface and supports the Modbus protocol.

When connecting the M1 to the sensor, connect the sensor’s green wire to RS485-A, and the yellow wire to RS485-B.

M1	URM08 (SEN0246)	Wind Vane (SEN0482)
RS485_N (Gray)	M1 RS485-B (Yellow)	RS485-/B/T (Green)
RS485_P (Pink)	RS485-A (Green)	RS485+/A/T+ (Yellow)
	VIN (Red) Do not power from M1 supply!	(Red) Connect to Buck Converter
GND (Black)	GND (Black)	GND (Black) Connect to Buck Converter

In order to power the wind vane which requires a minimum of 12V, we’ll need to add a buck converter:

Adjust the XL6009 DC-DC Booster Converter Module to deliver between 12 and 15 V to the wind vane.

In the console we’ll need to enable Modbus Polling 3.

The wind vane follows standard Modbus RTU commands, and the documentation describes how we can monitor wind directions: principle, half-winds, and quarter-winds.

To find the direction, the host (M1) sends a query frame (hexadecimal):

02 03 00 01 00 01 D5 F9（8 bytes）

Peripheral Add.	Function Code	Register Start Add.	Length of Register	High Bits of Check Code	Low Bits of Check Code
1 byte	1 byte	2byt	2byt	1 byte	1 byte
0x02	0x03	0x00 0x01	0x00 0x01	0xD5	0xF9

The peripheral device (the wind vane) responds with this frame (hexadecimal):

02 03 02 00 03 BC 45 (7 bytes)

Peripheral Add.	Function Code	Number of Valid Bytes	Data Area	High Bits of Check Code	Low Bits of Check Code
1 byte	1 byte	1 byte	2 byte	1 byte	1 byte
0×02	0x03	0x02	0x00 0x03	0xBC	0x45

There are 16 directions in total, and a value = 00 03 = 3 corresponds to East-northeast as seen in the table below.

Direction	16 Directions Value	360°
North	0	0° – 11.2°
North-northeast	1	11.3° – 33.7°
Northeast	2	33.8° – 56.2°
East-northeast	3	56.3° – 78.7°
East	4	78.8° – 101.2°
East-southeast	5	101.3° – 123.7°
Southeast	6	123.8° – 146.2°
South-southeast	7	146.3° – 168.7°
South	8	168.8° – 191.2°
South-southwest	9	191.3° – 213.7°
Southwest	10	213.8° – 236.2°
West-southwest	11	236.3° – 258.7°
West	12	258.8° – 281.2°
West-northwest	13	281.3° – 303.7°
Northwest	14	303.8° – 326.2°
North-northwest	15	326.3° – 348.7°

Setting up the Wind vane in the Console

Disable Sleep.
Navigate to Modbus Polling 3.
Enable Modbus Server Enable.
Set the following and then press Save:
Set the Modbus Server ID to 2.
Polling Interval to 10. This will be good for testing. When all has been tested, you’ll set this to a greater interval.
Publish polled value to always
Modbus Function to holding_register (This is associated with the functional code hex value 0x03)
Register Address to 1 (0x01)
Modbus data type to unit16
Mask value to 65535
Shift Value to 0
Offset Value to 0
Scaling Value to 1
After testing, re-enable sleep.

Add to the Datacake payload decoder:

function getDirections(num){

    var directions=["North Northeast","Northeast", "East Northeast","East","East Southeast","Southeast","South Southeast","South","South Southwest","Southwest","West Southwest", "West","West Northwest","Northwest","North Northwest","North"];

    return directions[num];

}

Add this if statement with the other modbus conditionals:

if (payload.modbus[0].name == "modbus3"){
	decoded.Wind = getDirections(payload.modbus[0].value);
 }

Adding a second sensor means we’ll need to recharacterize the power consumption.

Turn off/disconnect the internal battery by entering the shipping mode command in the console.
{"cmd":"enter_shipping"}
Connect power and GND lines to a programmable power supply and collect the following data. These are the numbers I received:
- When sleeping=0.03A
- When actively sensing and sending data, I measured 0.1A.
The system is awake for 40 seconds while it polls and transmits data, so if I sent data every fifteen minutes

Sleeping: 0.03 A * 12 V* 24*(86304/86400)(Proportion per Day )= 8.63040 Wh

Awake: .11 A * 12 V * 24* (96/86400)(Proportion per Day )=0.03200 Wh

Total=8.66 Wh per day

[CP_CALCULATED_FIELDS id=”11″]

This new system requires a different battery/solar panel configuration. A single 9W panel will no longer be sufficient. One solution could be to use two 9W panels with the V70 battery.

Where am I going to take this project next? The plan is to create a device for a local marina that measures

Air Temp
Wind velocity
Wind direction
Atmospheric pressure
Tide height

This system will be useful for boats entering the marina and monitoring the conditions inside the marina.

One °15 Marina

Stay tuned…

Solar Powered LoRa Radio Barometric Pressure and Altimeter Tutorial

Lizabeth Arum — Fri, 22 Dec 2023 17:01:09 +0000

Overview:

Learn how to create a LoRa wireless networked device with an Adafruit Feather M0 RFM95 LoRa Radio 900MHz connected to a sensor and powered by a e-Peas energy harvester and a Lithium Ion Capacitor (LIC). In this tutorial, you will:

Program your board using the Arduino IDE
Measure and monitor the battery voltage
Enable sleep to make the device more efficient
Deploy system with appropriately sized solar panel and battery
Publish data to a Qubitro dashboard

An IoT Feather M0 with Barometric Sensor

This tutorial will cover powering an Adafruit Feather M0 radio with two 0.3 Watt, 2 Volt solar panels, and an e-Peas energy harvester. It will also cover connecting the Feather to The Things Network (TTN). This simple project will introduce you to the Feather M0 module, working with a barometric sensor, coding, and LoRaWAN, all of which you can apply to other long range, low power, secure, standardized, low cost, and flexible LoRaWAN applications.

Qubitro Dashboard. Click here for live data

Parts Needed

The Things Network Gateway if the network is not available in your area. I’m using The Things Indoor LoRaWAN WiFi Gateway – 8 Channel LoRa 900 MHz
Adafruit Feather M0 with RFM95 LoRa Radio – 900MHz – RadioFruit
Stacking Headers for Feather – 12-pin and 16-pin female headers
MPL3115A2 – I2C Barometric Pressure/Altitude/Temperature Sensor
Stacking Headers
Breadboard
Wires
Wire clippers
Wire Strippers
JST 2.0 PH 2-Pin Connector Plug with Wires Cables
Lithium Ion Capacitor Solar Charger e-Peas Energy Harvester (C117)
1-2 0.3 Watt 2 Volt Mini Solar Panel – ETFE
Mini Solar Ready Enclosure
ETFE Panel Magnet Mount Set

Feather M0 LoRa Radio

The Adafruit Feather M0 with an RFM9x LoRa 868/915 MHz radio module that transmits and receives small packets of data is designed to make flexible wireless networks without the high power requirements of WiFi.

Each Adafruit LoRa device comes with a small label that contains a MAC address in the form 98:76:B6:xx:yy:zz. This might be a sticker attached to the device itself or included separately. The MAC address is needed when connecting the Feather to LoRaWAN. Speaking from experience, I suggest taking a photo of this sticker as a backup plan for when the sticker goes missing.

To make it easy to use the Feather for portable projects, Adafruit added a connector for a 3.7V Lithium polymer battery. The Feather can run off a battery or a micro USB, and you can use the USB input to recharge the battery. The Feather will automatically switch from the battery to USB power when available. The battery is also tied through a divider to an analog pin, so you can measure and monitor the battery voltage to detect when you need a recharge.

The module can be programmed in the Arduino IDE. To get the battery’s voltage, connect the battery to D9 (A7), read the pin’s voltage, and then double it to get the battery voltage. Here is the code you’ll need:
[code lang=”arduino”]#define VBATPIN A7
double measuredvbat = analogRead(VBATPIN);
measuredvbat *= 2; // we divided by 2, so multiply back
measuredvbat *= 3.3; // Multiply by 3.3V, our reference voltage
measuredvbat /= 1024; // convert to voltage
Serial.print("VBat: " ); Serial.println(measuredvbat);[/code]
While one can set up two Feather M0 with RFM9x LoRa 868/915 MHz radio modules to transmit and receive data from one another, we will use the module to communicate with a Things Gateway.

It’s important to note that LoRaWAN (Long Range Wide Area Network) projects are unsuitable for applications where you must send a lot of data. LoRaWAN is a wireless communication protocol that connects devices over long distances with minimal power consumption.

It is also essential to understand that LoRa and LoRaWAN are not interchangeable terms. LoRa refers to the type of hardware that is responsible for wireless modulation communication that operates with very low power consumption, while LoRaWAN refers to a network protocol. LoRa is the physical layer, and LoRaWAN is the MAC (media access protocol) layer.

Parts of the System

The feather is an end node, a part of the system equipped with one or more sensors that collects and transmits data.
The The Things Indoor LoRaWAN WiFi Gateway is our Gateway.
The Things Network (TTN) is the Network Server, and
Qubitro, a platform that provides tools and services for connecting, managing, and analyzing IoT devices and data, is the application server.

LoRa operates in various frequency bands. Which band you work in depends on your region. In North America, the range is between 902 MHz and 928 MHz. In Europe, there are two bands; one range is between 863-870 MHz, and the other is at 433MHz. Asia has two bands: one between 865 to 867 MHz and the other between 920 to 923 MHz. If you’re curious, here’s a list of frequencies by country.

Step 1: Gather Your Parts

Step 2: Solder Your Headers and Antenna

Your radio module needs an antenna. For a DIY antenna, cut a stranded or solid core wire to the proper length for your module/frequency:

433 MHz – 6.5 inches, or 16.5 cm
868 MHz – 3.25 inches or 8.2 cm
915 MHz – 3 inches or 7.8 cm

Strip a mm or two off the end of the wire, tin and solder into the ANT pad on the very right hand edge of the Feather.

Adafruit example of DIY antenna

Step 3: Wire the Circuit

By default Adafruit Feather M0’s pin GPIO6 and DIO1 are not connected. Please ensure they are connected.
Wire up the basic circuit for now. After everything is working, we’ll add solar.

Step 4: Set Up the Gateway

Navigate to the TTN website to log in or to create an account.
Navigate to Console. Choose your cluster:
Select Register Gateway or Go to Gateway:
Add your Gateway EUI. The Gateway EUI is obtained by writing down the first six digits of the 12-digit alphanumeric number found on the top left corner of the sticker below the QR code on the bag where the gateway was packaged. This 12-digit number is the gateway ID. After the first six digits, insert FFFE, and then finish by writing down the last six digits.
```
Example: 2FA02C60AA3C —> 2FA02CFFFE60AA3C
```
The gateway EUI is 2FA02CFFFE60AA3C
Use your WiFiPW on the back of the device as your claim authentication code. The gateway Wifi password is located after the phrase “WiFi PW:” on the sticker on the back of the device. This alphanumeric Wifi password will look similar to “LwtHsNYK”:
Select your region. In the US, we’ll select FSB 2:
Click on Claim Gateway.
Configure the Gateway:
1. Plug in the gateway.
2. Press the reset button for 5 seconds (on the bottom of the gateway next to the USB port) or until the light blinks GREEN-RED rapidly a couple of times.
3. After resetting, press the SETUP button for 10 seconds (at the top of the gateway) until the light blinks RED rapidly. The gateway’s Wifi network MiniHub-XXXXXX will now be visible (at least for the next 10 minutes).
4. On your computer, select the MiniHub network.
5. Open a browser window and type 192.168.4.1 in the address bar type. Then press Enter to access the Wifi config page.
6. Select your home/office Wifi network from the Scanned Networks list and enter your Wifi network password.
7. Select the “Save and Reboot” option at the bottom of the screen.
If everything is working correctly and the gateway can connect to The Things Network (TTN) via your home/office Wifi, the light on top of the gateway will be solid green after about a minute.

Step 5: Register your Feather

You need to register your Feather with The Things Network to get the three unique identifiers you’ll need for your code: APPEUI, DEVEUI, and APPKEY.

Navigate to Applications, or if you are logging in again, click on Go to Applications:
Click on the + Create Application:
Provide an Application ID and an Application name for your application and then click on Create application:
Click on +Register end device:
Select Enter end device specifics manually:
Select your region and a LoRaWAN version. The LoRaWAN protocol is developed and maintained by the LoRa Alliance

Version Release date

1.0 January 2015

1.0.1 February 2016

1.0.2 July 2016

1.1 October 2017

1.0.3 July 2018

1.0.4 October 2020
For the provisioning, locate the sticker that came with your Feather. Enter the first six hex values, then add 00 00 followed by the last six hex digits: XX XX XX 00 00 XX XX XX
Click Generate for the DevEUI:
Click Generate for the AppKey:
Click Register end device:
You will need the information found under Activation Information. Click on the <> to change the format to little-endian. For the AppEUI you need to get the lsb (least significant byte first) version. To toggle between msb ( most significant byte first) and lsb, click on the two way arrows:
Click on the Copy icon and paste the AppEUI in a document that you can refer to later.
Do the same (lsb) for the DevEUI and paste the lsb version into your document:
The AppKey will need to be the msb format so just copy it into your document:
Save your separate document somewhere where you can find it later:
Example text file

Step 6: Arduino

Open the Arduino IDE

Open or install the Arduino IDE. If you do not have the latest version of the Arduino IDE installed:
1. Navigate to the Arduino website.
2. Select your operating system and download the software.
3. To program the Feather M0 board using Arduino IDE, you need to install the package_adafruit_index.json file. Open the Preferences window in the Arduino IDE.
4. Go to File > Preferences.
5. Enter the following into the “Additional Board Manager URLs” field: “https://adafruit.github.io/arduino-board-index/package_adafruit_index.json”
6. Here’s a short description of each of the Adafruit supplied packages that will be available in the Board Manager when you add the URL:
  1. Adafruit AVR Boards – Includes support for Flora, Gemma, Feather 32u4, Trinket, & Trinket Pro.
  2. Adafruit SAMD Boards – Includes support for Feather M0 and M4, Metro M0 and M4, ItsyBitsy M0 and M4,
  3. Circuit Playground Express, Gemma M0 and Trinket M0
  4. Arduino Leonardo & Micro MIDI-USB – This adds MIDI over USB support for the Flora, Feather 32u4, Micro and Leonardo using the arcore project (https://adafru.it/eSI).
7. Click OK.
8. Open the Boards Manager. Go to Tools > Board >Boards Manager…
9. Search for Adafruit SAMD Boards by Adafruit and Arduino SAMD Boards
Step 7: Setting up Your Feather M0

Connect your Feather M0 into your computer through USB. Then, follow these steps:
1. Open the Arduino IDE.
2. Select your Board in the Tools Board menu (in our case, it’s the Adafruit Feather M0 -SAMD21)
3. Select the Port (if you don’t see the COM Port in your Arduino IDE and you are running Windows 7 or 8, you may need to install the To test that it all works, open the Blink Example:
If everything went as expected, you should see a “Done uploading.” message. If you don’t, you’ll need to troubleshoot. If your upload was successful, you’ll get a bunch of red text that tells you that the device was found and it was programmed, verified & reset.

After uploading, you may see a message saying “Disk Not Ejected Properly” about the …BOOT drive. You can ignore that message: it’s an artifact of how the bootloader and uploading work.

Step 8: Set Up Your Program

Create a new Sketch and save it as feather_temperature

Step 9: Importing Libraries

You’ll need a few libraries, so go to tools and select Manage Libraries…

You’ll need to Install:
- MCCI Arduino LoRaWAN library
- MCCI LoRaWAN LMIC library
- Adafruit MPL3115A2 library
- Adafruit Sensor Lab library
When prompted, install the library and any dependencies.

Step 10: Copy and paste the code

Copy and paste the code into your sketch:
[code lang=”arduino”]
/*******************************************************************************
* derived from The Things Network – Sensor Data Example
* Example of sending a valid LoRaWAN packet to The Things Networ using a Feather M0 LoRa.
* Learn Guide: https://learn.adafruit.com/the-things-network-for-feather
* Copyright (c) 2015 Thomas Telkamp and Matthijs Kooijman
* Copyright (c) 2018 Terry Moore, MCCI
* Copyright (c) 2018 Brent Rubell, Adafruit Industries
*
* Permission is hereby granted, free of charge, to anyone
* obtaining a copy of this document and accompanying files,
* to do whatever they want with them without any restriction,
* including, but not limited to, copying, modification and redistribution.
* NO WARRANTY OF ANY KIND IS PROVIDED.

*******************************************************************************/

#include
#include
#include
Adafruit_MPL3115A2 baro;
#define VBATPIN A7

// This EUI must be in little-endian format, so least-significant-byte
// first. When copying an EUI from ttnctl output, this means to reverse
// the bytes. For TTN issued EUIs the last bytes should be 0xD5, 0xB3,
// 0x70.
static const u1_t PROGMEM APPEUI[8] = {[XXX]};
void os_getArtEui(u1_t* buf) {
memcpy_P(buf, APPEUI, 8);
}

// This should also be in little endian format, see above.
static const u1_t PROGMEM DEVEUI[8] = {[XXX]};
void os_getDevEui(u1_t* buf) {
memcpy_P(buf, DEVEUI, 8);
}

// This key should be in big endian format (or, since it is not really a
// number but a block of memory, endianness does not really apply). In
// practice, a key taken from the TTN console can be copied as-is.
static const u1_t PROGMEM APPKEY[16] = { [XXX] };
void os_getDevKey(u1_t* buf) {
memcpy_P(buf, APPKEY, 16);
}

// payload to send to TTN gateway
static uint8_t payload[7];

static osjob_t sendjob;

// Schedule TX every this many seconds (might become longer due to duty
// cycle limitations).
const unsigned TX_INTERVAL = 30;

// Pin mapping for Adafruit Feather M0 LoRa
// /!\ By default Adafruit Feather M0's pin 6 and DIO1 are not connected.
// Please ensure they are connected.

const lmic_pinmap lmic_pins = {
.nss = 8,
.rxtx = LMIC_UNUSED_PIN,
.rst = 4,
.dio = { 3, 6, LMIC_UNUSED_PIN },
.rxtx_rx_active = 0,
.rssi_cal = 8, // LBT cal for the Adafruit Feather M0 LoRa, in dB
.spi_freq = 8000000,
};

void printHex2(unsigned v) {
v &= 0xff;
if (v < 16)
   Serial.print('0');
   Serial.print(v, HEX);
}

void onEvent(ev_t ev) {
Serial.print(os_getTime());
Serial.print(": ");
switch (ev) {
   case EV_SCAN_TIMEOUT:
     Serial.println(F("EV_SCAN_TIMEOUT"));
     break;
   case EV_BEACON_FOUND:
     Serial.println(F("EV_BEACON_FOUND"));
     break;
   case EV_BEACON_MISSED:
     Serial.println(F("EV_BEACON_MISSED"));
     break;

   case EV_BEACON_TRACKED:
     Serial.println(F("EV_BEACON_TRACKED"));
     break;
   case EV_JOINING:
     Serial.println(F("EV_JOINING"));
     break;
   case EV_JOINED:
     Serial.println(F("EV_JOINED"));
     {
       u4_t netid = 0;
       devaddr_t devaddr = 0;
       u1_t nwkKey[16];
       u1_t artKey[16];
       LMIC_getSessionKeys(&netid, &devaddr, nwkKey, artKey);
       Serial.print("netid: ");
       Serial.println(netid, DEC);
       Serial.print("devaddr: ");
       Serial.println(devaddr, HEX);
       Serial.print("AppSKey: ");
       for (size_t i = 0; i < sizeof(artKey); ++i) {
         if (i != 0)
           Serial.print("-");
         printHex2(artKey[i]);
       }

       Serial.println("");
       Serial.print("NwkSKey: ");
       for (size_t i = 0; i < sizeof(nwkKey); ++i) {
         if (i != 0)
           Serial.print("-");
         printHex2(nwkKey[i]);
       }

     }

    // Disable link check validation (automatically enabled
    // during join, but because slow data rates change max TX
    // size, we don't use it in this example.
    //LMIC_setLinkCheckMode(0);
     break;

  /*
      || This event is defined but not used in the code. No
      || point in wasting codespace on it.
      ||
      || case EV_RFU1:
      || Serial.println(F("EV_RFU1"));
      || break;
       */

   case EV_JOIN_FAILED:
     Serial.println(F("EV_JOIN_FAILED"));
     break;
   case EV_REJOIN_FAILED:
     Serial.println(F("EV_REJOIN_FAILED"));
     break;
   case EV_TXCOMPLETE:
     Serial.println(F("EV_TXCOMPLETE (includes waiting for RX windows)"));
     if (LMIC.txrxFlags & TXRX_ACK)
       Serial.println(F("Received ack"));
     if (LMIC.dataLen) {
       Serial.println(F("Received "));
       Serial.println(LMIC.dataLen);
       Serial.println(F(" bytes of payload"));
     }
    // Schedule next transmission
     os_setTimedCallback(&sendjob, os_getTime() + sec2osticks(TX_INTERVAL), do_send);
     break;
   case EV_LOST_TSYNC:
     Serial.println(F("EV_LOST_TSYNC"));
     break;
   case EV_RESET:
     Serial.println(F("EV_RESET"));
     break;
   case EV_RXCOMPLETE:
    // data received in ping slot
     Serial.println(F("EV_RXCOMPLETE"));
     break;
   case EV_LINK_DEAD:
     Serial.println(F("EV_LINK_DEAD"));
     break;
   case EV_LINK_ALIVE:
     Serial.println(F("EV_LINK_ALIVE"));
     break;
  /*
      || This event is defined but not used in the code. No
      || point in wasting codespace on it.
      ||
      || case EV_SCAN_FOUND:
      || Serial.println(F("EV_SCAN_FOUND"));
      || break;
       */

   case EV_TXSTART:
     Serial.println(F("EV_TXSTART"));
     break;
   case EV_TXCANCELED:
     Serial.println(F("EV_TXCANCELED"));
     break;
   case EV_RXSTART:
    /* do not print anything — it wrecks timing */
     break;
   case EV_JOIN_TXCOMPLETE:
     Serial.println(F("EV_JOIN_TXCOMPLETE: no JoinAccept"));
     break;
   default:
     Serial.print(F("Unknown event: "));
     Serial.println((unsigned)ev);
     break;
}
}

void do_send(osjob_t* j) {
// Check if there is not a current TX/RX job running
if (LMIC.opmode & OP_TXRXPEND) {
   Serial.println(F("OP_TXRXPEND, not sending"));
} else {
  // read the sensor
   if (!baro.begin()) {
     Serial.println("Could not find sensor. Check wiring.");
     while (1);
   }
  // use to set sea level pressure for current location
  // this is needed for accurate altitude measurement
  // STD SLP = 1013.26 hPa
   baro.setSeaPressure(1013.26);
   float pressure = baro.getPressure();
  //adjusted for fahrenheit
   float temperature = (9 * baro.getTemperature()) / 5 + 32;
   Serial.println("—————–");
   Serial.print("pressure = ");
   Serial.print(pressure);
   Serial.println(" hPa");
   Serial.print("temperature = ");
   Serial.print(temperature);
   Serial.println(" F");

  // float -> int
   temperature = temperature / 100;
   pressure = pressure / 1000;
  // note: this uses the sflt16 datum (https://github.com/mcci-catena/arduino-lmic#sflt16)
   uint16_t payloadTemp = LMIC_f2sflt16(temperature);
  // int -> bytes
   byte tempLow = lowByte(payloadTemp);
   byte tempHigh = highByte(payloadTemp);
  // place the bytes into the payload
   payload[0] = tempLow;
   payload[1] = tempHigh;

  // float -> int
   uint16_t payloadPressure = LMIC_f2sflt16(pressure / 10);
  // int -> bytes
   byte pressureLow = lowByte(payloadPressure);
   byte pressureHigh = highByte(payloadPressure);
  // place the bytes into the payload
   payload[2] = pressureLow;
   payload[3] = pressureHigh;

// Payload format Bytes: [(Bat-Voltage – 2) * 100]

   double measuredvbat = analogRead(VBATPIN);
   measuredvbat *= 2; // we divided by 2, so multiply back
   measuredvbat *= 3.3; // Multiply by 3.3V, our reference voltage
   measuredvbat /= 1024; // convert to voltage
   Serial.print("VBat: " ); Serial.println(measuredvbat);
   measuredvbat = measuredvbat / 100;
   uint16_t payloadBattery=LMIC_f2sflt16(measuredvbat);

  // int -> bytes
   byte batteryLow = lowByte(payloadBattery);
   byte batteryHigh = highByte(payloadBattery);
  // place the bytes into the payload
   payload[4] = batteryLow;
   payload[5] = batteryHigh;

  // prepare upstream data transmission at the next possible time.
  // transmit on port 1 (the first parameter); you can use any value from 1 to 223 (others are reserved).
  // don't request an ack (the last parameter, if not zero, requests an ack from the network).
  // Remember, acks consume a lot of network resources; don't ask for an ack unless you really need it
   LMIC_setTxData2(1, payload, sizeof(payload) – 1, 0);
}

// Next TX is scheduled after TX_COMPLETE event.
}

void setup() {
delay(5000);
  Serial.begin(9600);
Serial.println(F("Starting"));
// LMIC init
os_init();
// Reset the MAC state. Session and pending data transfers will be discarded.
LMIC_reset();
// Disable link-check mode and ADR, because ADR tends to complicate testing.
LMIC_setLinkCheckMode(0);
// Set the data rate to Spreading Factor 7. This is the fastest supported rate for 125 kHz channels, and it
// minimizes air time and battery power. Set the transmission power to 14 dBi (25 mW).
LMIC_setDrTxpow(DR_SF7, 14);
// in the US, with TTN, it saves join time if we start on subband 1 (channels 8-15). This will
// get overridden after the join by parameters from the network. If working with other
// networks or in other regions, this will need to be changed.
LMIC_selectSubBand(1);
// Start job (sending automatically starts OTAA too)
do_send(&sendjob);
}

void loop() {
// we call the LMIC's runloop processor. This will cause things to happen based on events and time. One
// of the things that will happen is callbacks for transmission complete or received messages. We also
// use this loop to queue periodic data transmissions. You can put other things here in the `loop()` routine,
// but beware that LoRaWAN timing is pretty tight, so if you do more than a few milliseconds of work, you
// will want to call `os_runloop_once()` every so often, to keep the radio running.
os_runloop_once();

}
[/code]

Step 11: Adding your Activation Information

Update the [XXX]s with your saved AppEUI, DevEUI, and AppKey:
[code lang=”arduino”]static const u1_t PROGMEM APPEUI[8] = {[XXX];

// This should also be in little endian format, see above.
static const u1_t PROGMEM DEVEUI[8] = {[XXX]};

// This key should be in big endian format (or, since it is not really a
// number but a block of memory, endianness does not really apply). In
// practice, a key taken from the TTN console can be copied as-is.
static const u1_t PROGMEM APPKEY[16] = { [XXX] };[/code]
Compile and upload the code.

Step 12: Payload formatters

After uploading the code we’re going to send the data from the Feather to TTN and decode it.

Back in the TTN console, we need to add an uplink payload formatter.
1. Click on Application, select your application and then select Payload formatters from the left menu:
2. Click on Uplink.
3. Select Custom Javascript formatter:
4. Copy the following code and replace the existing javascript:
  [code lang=”arduino”]// TTN Decoder for TTN OTAA Feather US915
  function Decoder(bytes, port) {
  
  // Decode an uplink message from a buffer
    // (array) of bytes to an object of fields.
  
    var decoded = {};
  
  // temperature
  rawTemp = bytes[0] + bytes[1] * 256;
  decoded.degrees_F = parseFloat((sflt162f(rawTemp) * 100).toFixed(2));
  
  // pressure
  rawPressure = bytes[2] + bytes[3] * 256;
    decoded.pressure_hPa = parseFloat((sflt162f(rawPressure) * 10000).toFixed(2));
  
    // battery
  rawBattery = bytes[4] + bytes[5] * 256;
  decoded.battery_V = parseFloat((sflt162f(rawBattery) * 100).toFixed(2));
  
    return decoded;
  }
  
  function sflt162f(rawSflt16)
     {
     // rawSflt16 is the 2-byte number decoded from wherever;
     // it's in range 0..0xFFFF
     // bit 15 is the sign bit
     // bits 14..11 are the exponent
     // bits 10..0 are the the mantissa. Unlike IEEE format,
     // the msb is explicit; this means that numbers
     // might not be normalized, but makes coding for
     // underflow easier.
     // As with IEEE format, negative zero is possible, so
     // we special-case that in hopes that JavaScript will
     // also cooperate.
     //
     // The result is a number in the open interval (-1.0, 1.0);
     //
      // throw away high bits for repeatability.
  
      rawSflt16 &= 0xFFFF;
  
     // special case minus zero:
      if (rawSflt16 == 0x8000)
  
          return -0.0;
  
     // extract the sign.
      var sSign = ((rawSflt16 & 0x8000) != 0) ? -1 : 1;
  
     // extract the exponent
      var exp1 = (rawSflt16 >> 11) & 0xF;
  
     // extract the "mantissa" (the fractional part)
      var mant1 = (rawSflt16 & 0x7FF) / 2048.0;
  
     // convert back to a floating point number. We hope
     // that Math.pow(2, k) is handled efficiently by
     // the JS interpreter! If this is time critical code,
     // you can replace by a suitable shift and divide.
      var f_unscaled = sSign * mant1 * Math.pow(2, exp1 – 15);
  
      return f_unscaled;
  
      }[/code]
Step 13: Characterize Power Consumption

The battery life of an end device is highly dependent on the spreading factor used. Higher spreading factors result in longer active times for the radio transceivers and shorter battery life. We’ll be using a spreading factor of 7, which provides the highest bit rate and longest battery life. You can see in the code where this is set:
[code lang=”arduino”]// Set the data rate to Spreading Factor 7. This is the fastest supported rate for 125 kHz channels, and it
//minimizes air time and battery power. Set the transmission power to 14 dBi (25 mW).
LMIC_setDrTxpow(DR_SF7, 14);[/code]
According to the specs, The power consumption of the radio is ~0.0003 A during full sleep, ~.12A during +20dBm transmit, and ~.04A during active radio listening.

I tested my setup with a programmable power supply and collected the following data.

When the module was not sending data, I measured 0.015 amps. And when actively sending data, I measured .136 amps.

I found that for reading and sending data my device measured 0.0331 A. which makes sense if you look at the power consumption above.

0.04 A per active listening

0.136 A for transmitting

0.04 A *17/60 seconds = 0.0113 A

0.136 A * 3/60 seconds = 0.0068 A

0.018 A * 3.3V= 0.05 W

Or 0.05 W

If I ran the system continuously, meaning multiplying 0.05 Watts by 24 hours. I would be at 0.6 Watt hours per day and would need a much larger panel and battery.

Fortunately, I can put the board to sleep between readings and I only need about a about 20 seconds to read and send data.

[CP_CALCULATED_FIELDS id=”8″]

Step 14: Putting the Board to Sleep

We can reduce the power consumption by manipulating the duty cycle, controlling when the module is active and when it sleeps. To put the board to sleep, we’re going to use the Arduino Low Power Library.
1. In Arduino install the Arduino Low Power Library.
2. Return to your Arduino code. Save and rename your sketch as feather-ttn-with-sleep. In case something goes wrong you can always revert back to your original version.
3. Add these lines near your other include statements:
  [code lang=”arduino”]#define uS_TO_S_FACTOR 1000 /* Conversion factor for microseconds to seconds */
  #define TIME_TO_SLEEP 1200 /* Time feather will go to sleep (in seconds) */
  #include "ArduinoLowPower.h"[/code]
4. Navigate to setup() and add the following lines after the line that prints “Starting” to the serial monitor. These lines will turn on the internal LED so that you know when your device is awake:
  [code lang=”arduino”]pinMode(LED_BUILTIN, OUTPUT);
  digitalWrite(LED_BUILTIN, HIGH);[/code]
5. Navigate to this line os_setTimedCallback(&sendjob,os_getTime() + sec2osticks(TX_INTERVAL), do_send);
6. Add the following after the line above:
  [code lang=”arduino”]Serial.println("Going to sleep");
  digitalWrite(LED_BUILTIN, LOW);
  LowPower.sleep(TIME_TO_SLEEP*uS_TO_S_FACTOR);
  digitalWrite(LED_BUILTIN, HIGH);[/code]
The code will put the board to sleep for however long you specify at the top of your code. You can change this value after you test the code, however, you should note that you will lose access to the serial monitor when the module is sleeping and you will have to reset the board by double clicking on the reset button after compiling, but before uploading.

When adjusting your sleep, think about how often you really need to take a reading and what kind of power your panel can provide. Then make your adjustment to your code.

I’m sleeping every 20 minutes between readings.

Readings which include sending data

Sleeping = 0.000597 or ~0.0006 A

Active= 0.018 A

The device is sleeping 0.9836 percent of the time and active for 0.01639 percent of the time

0.0006 A * 3.3 V * 24 hours * 0.9836 proportion of time= 0.04651 Wh

0.018 A * 3.3 V * 24 hours * 0.01639 proportion of time= 0.0233 Wh

Add them up for a total of ~0.07 Watt hours per day.

Now we have to think about what happens when the device tries to connect to TTN and can’t? Right now, the feather will keep trying and will consume more and more power.

To deal with this scenario, we’re going to use another type of sleep. This one won’t put the radio to sleep, but will reduce our power consumption. We’re going to make use of a Watchdog timer (WDT). A WDT is a simple countdown timer used to reset a microprocessor after a specific interval of time. During normal operation, a WDT timeout will generate a device RESET, but if the device is in SLEEP mode, a WDT timeout will cause the device to wake up and continue with normal operation. This is known as a WDT wake up.
1. In Arduino install the Adafruit SleepyDog Library.
2. Open the Adafruit SleepyDog Library>Utility>WatchdogSAMD.cpp in a text editor.
3. Add this line (line ~198):SysTick->CTRL &= ~SysTick_CTRL_TICKINT_Msk;
  after:int actualPeriodMS = enable(maxPeriodMS, true); // true = for sleep.Replace this line (217)SysTick->CTRL &= ~SysTick_CTRL_TICKINT_Msk;With this:SysTick->CTRL |= SysTick_CTRL_TICKINT_Msk;
4. Save the file.
5. Return to your Arduino code. Save and rename your sketch as feather-ttn-with-sleep and watchdog. In case something goes wrong you can revert back to your previous program.
6. At the top of your program with your other instance variable add:
  [code lang=”arduino”]static unsigned long previousMillis = 0;
  unsigned long currentMillis;
  unsigned long interval=10000;[/code]
7. Navigate to void onEvent(ev_t ev)<{
8. Add the following line:
  [code lang=”arduino”]currentMillis = millis();[/code]
9. Now navigate to:
  [code lang=”arduino”]case EV_JOIN_TXCOMPLETE:
  Serial.println(F("EV_JOIN_TXCOMPLETE: no JoinAccept"));[/code]
10. Before the break, add:
  [code lang=”arduino”]if(currentMillis – previousMillis > interval){
  previousMillis = currentMillis;
  Serial.println("Going to sleep in one second…");
  delay(1000);
  // To enter low power sleep mode call Watchdog.sleep() like below
  // and the watchdog will allow low power sleep for as long as possible.
  // The actual amount of time spent in sleep will be returned (in milliseconds).
  digitalWrite(LED_BUILTIN, LOW); // Show we're asleep
  int sleepMS = Watchdog.sleep();
  // Alternatively you can provide a millisecond value to specify
  // how long you'd like the chip to sleep, but the hardware only
  // supports a limited range of values so the actual sleep time might
  // be smaller. The time spent in sleep will be returned (in // milliseconds).
  // int sleepMS = Watchdog.sleep(1000);
  // Sleep for up to 1 second.
  // Code resumes here on wake.
  
  digitalWrite(LED_BUILTIN, HIGH);// Show we're awake again
  
  // The LED indicator lets you know you're back.[/code]
Now, using Qoitech’s Otii Ace Pro to accurately measure the power consumption, I confirm the following.

MAX: 136mA

AVG: 803µA

MIN: 550µA

So my new values are:

0.0005A during sleep

Averaging the active and transmit states:

0.04A *17/60 seconds= 0.011 A

0.136A * 3/60 seconds=0.0068 A

0.011A+0.0068 A=0.0178A for 20 seconds

Putting it all together:

Active: 0.0178A *20/1220 * 3.3V * 24 hours=0.023Wh

Sleep: 0.0005A *1200/1220 * 3.3V * 24 hours=0.038Wh

0.023Wh +0.38 Wh=~0.06 Wh per day

Sizing the System

Longevity is a crucial element of solar system design. When batteries fail, replacing them requires money, time, and human intervention: the more remote the deployment, the more challenging and costlier it is to replace the battery.

Remote sensor applications across agriculture, data collection, environmental monitoring, and asset tracking are generally expected to run for extended periods and, in some cases, need to run in extreme temperatures. As a solar system designer, you want your devices to continue running through various conditions (i.e., clouds, precipitation, or low and high temperatures)

One solution available to you is Voltaic Systems’ Lithium-Ion Capacitor (LiC) based solar charger that incorporates the e-Peas AEM10941 Energy Harvester (https://voltaicsystems.com/LIC-solar-charger/) and the Vinatech hybrid capacitor. E-Peas is a leader in PMICs for energy harvesting, and the AEM10941 is an integrated energy management circuit that extracts DC power from up to 7-cell solar panels to simultaneously store energy in a rechargeable element and supply the system with an unregulated voltage output between 2.5 – 3.6V.
Lithium Ion Capacitors (LICs) are a great alternative to traditional lithium-ion batteries in many Low-power WAN (LPWAN) applications. The combination of high energy production solar panels (up to 300mW @1SUN) + High current PMIC (110mA) + High-capacity Storage (250F) makes this LiC exceptionally well suited to power connected nodes using LoRa and LTE CAT-M, and NB-IoT, or those using the Generic Node running on The Things Industries LoRaWAN network.

The LIC charges quickly. Even if completely discharged, the capacitor can be fully recharged in about 2 hours at full sun. The module can even work over periods of extended darkness. If your end device is low consumption, the module could theoretically run for a few months without access to the sun.

The Voltaic Systems’ LIC is an ultra-compact, lightweight, long-lifetime energy supply solution for heavy-duty applications that eliminates battery replacements and ensures performance across a range of temperatures (-40°C to 85°C).

For our device, we are going to add two 0.3 Watt 2 Volt ETFE laminate solar panels in parallel to charge the capacitor, which will provide an unregulated voltage between 2.5 – 3.8V—placing the panels in parallel increases the current but not the voltage. The Feather will run as long as the voltage is greater than 2.7V.

Connect positive leads from the panels to each other and negative leads to each other. Then, connect them to a JST to connect them to the capacitor.

Connect the positive lead from the capacitor to the BAT input on the feather and the negative lead to GND.

Connecting to a Dashboard

Now that the device is working and powered by solar, we need to connect it to a dashboard. A dashboard in an IoT context is not just a nice to have, but a crucial element of any IoT system. It enhances your IoT devices’ usability, management, and efficiency by providing a real-time view of your collected data.

For this example, we will use the Qubitro platform to visualize the temperature, pressure, and battery voltage. Qubitro provides tools and infrastructure to connect, manage, and scale IoT devices and has good documentation for getting started. Built to be device-agnostic, it can work with a wide variety of IoT devices regardless of manufacturer or protocols used.

Here is the complete code:
[code lang=”arduino”]

/*******************************************************************************
* derived from The Things Network – Sensor Data Example
*
* Example of sending a valid LoRaWAN packet to The Things Networ using a Feather M0 LoRa.
*
* Learn Guide: https://learn.adafruit.com/the-things-network-for-feather
*
* Copyright (c) 2015 Thomas Telkamp and Matthijs Kooijman
* Copyright (c) 2018 Terry Moore, MCCI
* Copyright (c) 2018 Brent Rubell, Adafruit Industries
*
* Permission is hereby granted, free of charge, to anyone
* obtaining a copy of this document and accompanying files,
* to do whatever they want with them without any restriction,
* including, but not limited to, copying, modification and redistribution.
* NO WARRANTY OF ANY KIND IS PROVIDED.
*******************************************************************************/
#include
#include
/*#include */
#include
#define uS_TO_S_FACTOR 1000 /* Conversion factor for microseconds to seconds */
#define TIME_TO_SLEEP 1200 /* Time feather will go to sleep (in seconds) */
#include "ArduinoLowPower.h"
#include
#include
#include
#include

ArtronShop_SHT3x sht3x(0x44, &Wire); // ADDR: 0 => 0x44, ADDR: 1 => 0x45

#define VBATPIN A7
static unsigned long previousMillis = 0;
unsigned long currentMillis;
unsigned long interval = 10000;
// This EUI must be in little-endian format, so least-significant-byte
// first. When copying an EUI from ttnctl output, this means to reverse
// the bytes. For TTN issued EUIs the last bytes should be 0xD5, 0xB3,
// 0x70.
static const u1_t PROGMEM APPEUI[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
void os_getArtEui(u1_t* buf) {
memcpy_P(buf, APPEUI, 8);
}
// This should also be in little endian format, see above.
static const u1_t PROGMEM DEVEUI[8] = { 0x79, 0x9D, 0x06, 0xD0, 0x7E, 0xD5, 0xB3, 0x70 };
void os_getDevEui(u1_t* buf) {
memcpy_P(buf, DEVEUI, 8);
}
// This key should be in big endian format (or, since it is not really a
// number but a block of memory, endianness does not really apply). In
// practice, a key taken from the TTN console can be copied as-is.
static const u1_t PROGMEM APPKEY[16] = { 0x31, 0x4E, 0xA4, 0x36, 0x2F, 0x49, 0x1E, 0x30, 0x43, 0x4D, 0x6E, 0xA5, 0x14, 0x3B, 0x02, 0xAE };
void os_getDevKey(u1_t* buf) {
memcpy_P(buf, APPKEY, 16);
}
// payload to send to TTN gateway
static uint8_t payload[7];
static osjob_t sendjob;
// Schedule TX every this many seconds (might become longer due to duty
// cycle limitations).
const unsigned TX_INTERVAL = 30;
// Pin mapping for Adafruit Feather M0 LoRa
// /!\ By default Adafruit Feather M0's pin 6 and DIO1 are not connected.
// Please ensure they are connected.
const lmic_pinmap lmic_pins = {
.nss = 8,
.rxtx = LMIC_UNUSED_PIN,
.rst = 4,
.dio = { 3, 6, LMIC_UNUSED_PIN },
.rxtx_rx_active = 0,
.rssi_cal = 8, // LBT cal for the Adafruit Feather M0 LoRa, in dB
.spi_freq = 8000000,
};
void printHex2(unsigned v) {
v &= 0xff;
if (v < 16)
Serial.print('0');
Serial.print(v, HEX);
}
void onEvent(ev_t ev) {
currentMillis = millis();
Serial.print(os_getTime());
Serial.print(": ");
switch (ev) {
case EV_SCAN_TIMEOUT:
Serial.println(F("EV_SCAN_TIMEOUT"));
break;
case EV_BEACON_FOUND:
Serial.println(F("EV_BEACON_FOUND"));
break;
case EV_BEACON_MISSED:
Serial.println(F("EV_BEACON_MISSED"));
break;
case EV_BEACON_TRACKED:
Serial.println(F("EV_BEACON_TRACKED"));
break;
case EV_JOINING:
Serial.println(F("EV_JOINING"));
break;
case EV_JOINED:
Serial.println(F("EV_JOINED"));
{
u4_t netid = 0;
devaddr_t devaddr = 0;
u1_t nwkKey[16];
u1_t artKey[16];
LMIC_getSessionKeys(&netid, &devaddr, nwkKey, artKey);
Serial.print("netid: ");
Serial.println(netid, DEC);
Serial.print("devaddr: ");
Serial.println(devaddr, HEX);
Serial.print("AppSKey: ");
for (size_t i = 0; i < sizeof(artKey); ++i) {
if (i != 0)
Serial.print("-");
printHex2(artKey[i]);
}
Serial.println("");
Serial.print("NwkSKey: ");
for (size_t i = 0; i < sizeof(nwkKey); ++i) {
if (i != 0) Serial.print("-");
printHex2(nwkKey[i]);
}
Serial.println();
} // Disable link check validation (automatically enabled // during join, but because slow data rates change max TX // size, we don't use it in this example. //LMIC_setLinkCheckMode(0); break; /* || This event is defined but not used in the code. No || point in wasting codespace on it. || || case EV_RFU1: || Serial.println(F("EV_RFU1")); || break; */ case EV_JOIN_FAILED: Serial.println(F("EV_JOIN_FAILED")); break; case EV_REJOIN_FAILED: Serial.println(F("EV_REJOIN_FAILED")); break; case EV_TXCOMPLETE: Serial.println(F("EV_TXCOMPLETE (includes waiting for RX windows)")); if (LMIC.txrxFlags & TXRX_ACK) Serial.println(F("Received ack")); if (LMIC.dataLen) { Serial.println(F("Received ")); Serial.println(LMIC.dataLen); Serial.println(F(" bytes of payload")); } // Schedule next transmission os_setTimedCallback(&sendjob, os_getTime() + sec2osticks(TX_INTERVAL), do_send); Serial.println("Going to sleep"); digitalWrite(LED_BUILTIN, LOW); LowPower.sleep(TIME_TO_SLEEP * uS_TO_S_FACTOR); digitalWrite(LED_BUILTIN, HIGH); break; case EV_LOST_TSYNC: Serial.println(F("EV_LOST_TSYNC")); break; case EV_RESET: Serial.println(F("EV_RESET")); break; case EV_RXCOMPLETE: // data received in ping slot Serial.println(F("EV_RXCOMPLETE")); break; case EV_LINK_DEAD: Serial.println(F("EV_LINK_DEAD")); break; case EV_LINK_ALIVE: Serial.println(F("EV_LINK_ALIVE")); break; /* || This event is defined but not used in the code. No || point in wasting codespace on it. || || case EV_SCAN_FOUND: || Serial.println(F("EV_SCAN_FOUND")); || break; */ case EV_TXSTART: Serial.println(F("EV_TXSTART")); break; case EV_TXCANCELED: Serial.println(F("EV_TXCANCELED")); break; case EV_RXSTART: /* do not print anything — it wrecks timing */ break; case EV_JOIN_TXCOMPLETE: Serial.println(F("EV_JOIN_TXCOMPLETE: no JoinAccept")); if (currentMillis – previousMillis > interval) {
previousMillis = currentMillis;
Serial.println("Going to sleep in one second…");
delay(1000);
// To enter low power sleep mode call Watchdog.sleep() like below
// and the watchdog will allow low power sleep for as long as possible.
// The actual amount of time spent in sleep will be returned (in
// milliseconds).
digitalWrite(LED_BUILTIN, LOW); // Show we're asleep
int sleepMS = Watchdog.sleep();
// Alternatively you can provide a millisecond value to specify
// how long you'd like the chip to sleep, but the hardware only
// supports a limited range of values so the actual sleep time might
// be smaller. The time spent in sleep will be returned (in
// milliseconds).
// int sleepMS = Watchdog.sleep(1000); // Sleep for up to 1 second.
// Code resumes here on wake.
digitalWrite(LED_BUILTIN, HIGH); // Show we're awake again
// Try to reattach USB connection on "native USB" boards (connection is
// lost on sleep). Host will also need to reattach to the Serial monitor.
// Seems not entirely reliable, hence the LED indicator fallback.
#if defined(USBCON) && !defined(USE_TINYUSB)
USBDevice.attach();
#endif
break;
}
break;
default:
Serial.print(F("Unknown event: "));
Serial.println((unsigned)ev);
break;
}
}
void do_send(osjob_t* j) {
// Check if there is not a current TX/RX job running
if (LMIC.opmode & OP_TXRXPEND) {
Serial.println(F("OP_TXRXPEND, not sending"));
} else {
// read the sensor
if (sht3x.measure()) {

temperature = (9 * sht3x.temperature()) / 5 + 32;
Serial.print("Temperature: ");
Serial.print(temperature);
Serial.println(" *F");
// adjust for the f2sflt16 range (-1 to 1)
temperature = temperature / 100;

// read the humidity from the DHT22
rHumidity = (sht3x.humidity());
Serial.print("%RH ");
Serial.println(rHumidity);
// adjust for the f2sflt16 range (-1 to 1)
rHumidity = rHumidity / 100;

// note: this uses the sflt16 datum (https://github.com/mcci-catena/arduino-lmic#sflt16)
uint16_t payloadTemp = LMIC_f2sflt16(temperature);
// int -> bytes
byte tempLow = lowByte(payloadTemp);
byte tempHigh = highByte(payloadTemp);
// place the bytes into the payload
payload[0] = tempLow;
payload[1] = tempHigh;

// float -> int
uint16_t payloadHumid = LMIC_f2sflt16(rHumidity);
// int -> bytes
byte humidLow = lowByte(payloadHumid);
byte humidHigh = highByte(payloadHumid);
payload[2] = humidLow;
payload[3] = humidHigh;

} else {
Serial.println("SHT3x read error");
}
delay(1000);

int readings = 1000;
float myReadings[readings];

float v;
float sumV;

for (int i = 0; i < readings; i++) {
myReadings[i] = analogRead(VOLT_PIN);
}
for (int j = 0; j < readings; j++) {
sumV += myReadings[j];
}
float averagedV = sumV / readings;
//float v = analogRead(VOLT_PIN);
float voltage = (averagedV * 3.3 / 4095) * 2.178;
/*b = val * 5 / 1024; //the math
b = val * (R1 + R2) / R2; //more math*/
float level;

if (voltage >= 3.2 && voltage <= 4.2) {
level = map(voltage * 100, 3.2 * 100, 4.2 * 100, 0, 100);
} else if (voltage > 4.2) {
voltage = 4.2;
level = 100;
} else {
level = 0;
}

Serial.print("voltage=");
Serial.println(voltage);
Serial.print("Level=");
Serial.println(level);

voltage = voltage / 100;
level = level / 100;
// float -> int
uint16_t payloadV = LMIC_f2sflt16(voltage);
// int -> bytes
byte vLow = lowByte(payloadV);
byte vHigh = highByte(payloadV);
payload[4] = vLow;
payload[5] = vHigh;

// float -> int
uint16_t payloadL = LMIC_f2sflt16(level);
// int -> bytes
byte lLow = lowByte(payloadL);
byte lHigh = highByte(payloadL);
payload[6] = lLow;
payload[7] = lHigh;

// prepare upstream data transmission at the next possible time.
// transmit on port 1 (the first parameter); you can use any value from 1 to 223 (others are reserved).
// don't request an ack (the last parameter, if not zero, requests an ack from the network).
// Remember, acks consume a lot of network resources; don't ask for an ack unless you really need it.
LMIC_setTxData2(1, payload, sizeof(payload) – 1, 0);
}

// Next TX is scheduled after TX_COMPLETE event.
}

void setup() {
delay(5000);
Serial.begin(9600);
Serial.println(F("Starting"));
pinMode(LED_BUILTIN, OUTPUT);
digitalWrite(LED_BUILTIN, HIGH); // LMIC
init os_init(); // Reset the MAC state. Session and pending data transfers will be discarded.
LMIC_reset(); // Disable link-check mode and ADR, because ADR tends to complicate testing.
LMIC_setLinkCheckMode(0); // Set the data rate to Spreading Factor 7. This is the fastest supported rate for 125 kHz channels, and it // minimizes air time and battery power. Set the transmission power to 14 dBi (25 mW).
LMIC_setDrTxpow(DR_SF7, 14); // in the US, with TTN, it saves join time if we start on subband 1 (channels 8-15). This will // get overridden after the join by parameters from the network. If working with other // networks or in other regions, this will need to be changed. //comment this out?
LMIC_selectSubBand(1); // Start job (sending automatically starts OTAA too)
do_send(&sendjob);
}
void loop() {
// we call the LMIC's runloop processor. This will cause things to happen based on events and time. One
// of the things that will happen is callbacks for transmission complete or received messages. We also
// use this loop to queue periodic data transmissions. You can put other things here in the `loop()` routine,
// but beware that LoRaWAN timing is pretty tight, so if you do more than a few milliseconds of work, you
// will want to call `os_runloop_once()` every so often, to keep the radio running.
os_runloop_once();
}
[/code]
In conclusion, this tutorial offers a entry point into the world of IoT powered by This tutorial is an entry point into the world of solar-powered IoT. Programming and sizing your system are some of the practical aspects of designing energy-efficient remote data monitoring devices. Introducing the LIC demonstrates that a capacitor can provide a viable alternative to a battery for truly low-power devices. Using The Things Network and Qubitro dashboard brings an added dimension of network connectivity and data visualization to the project, making it a perfect blend of the practical IoT challenges you will face when designing your applications. Whether you’re a hobbyist, a student, or a professional, this tutorial provides valuable skills and knowledge applicable to a wide range of IoT applications, emphasizing the importance of efficient design.

So what will you build?

Solar Powered ESP32 over WiFi Application Tutorial

Lizabeth Arum — Fri, 15 Dec 2023 17:11:10 +0000

Overview:

Learn how to create a cloud-connected IoT device using an ESP32 connected to a DS18B20 temperature sensor temperature probe. In this tutorial, you will:

Program your board using the Arduino IDE to send via WiFi temperature and battery voltage levels at certain times
Reduce power consumption and consider ways to make the device more efficient
Deploy system with appropriately sized solar panel and battery
Publish data on the tago.io dashboard

An IoT ESP 32 Temperature Sensor

This tutorial will cover powering an ESP32 with a 6V solar panel and a 3.7V LiPo battery. It will also cover connecting the ESP32 to a network using WiFi and sending data to a cloud platform at regular intervals. Sending your data to a dashboard allows you to log and monitor sensor data over time and can be used for trends analysis and data-based decision-making. This type of remote monitoring system can be implemented in various fields, such as agriculture, environmental monitoring, and outdoor asset tracking.

This tutorial setup, from the parts to the dashboard, is relatively low-cost, making it accessible to anyone interested in getting started with setting up their own IoT devices. Ideally, this simple project will introduce you to sensors, coding, network communication, and cloud integration.

The dashboard we will be using in this tutorial is from TagoIO. TagoIO is a cloud IoT platform that is easy to connect to, use, and customize. In addition to being simple to set up, TagoIO provides free access to create five devices and five dashboards. This free level lets you immediately explore TagoIO’s dashboard capabilities. US-based TagoIO is used in over 120 countries and currently supports over 1000 different IoT applications across Agriculture, Buildings, Industrial, Energy, and Logistics verticals. Here’s a link to the dashboard in this tutorial.

Parts Needed

ESP32 WROOM board
Breadboard
Wires
ESP32 Breakout board
Waterproof DS18B20 Temperature Sensor Temperature Probe
6 Volt Solar Panel
Solar Panel Bracket – Medium
Small Solar Ready Enclosure
Adafruit Universal USB / DC / Solar Lithium Ion/Polymer charger – bq24074
Lithium Ion Battery Pack – 3.7V 6600mAh
12V DC Power Connector 5.5mm x 2.1mm male
Voltage divider for battery monitor:
- 27k Ohm resistor
- 100k Ohm resistor

Note that while there are a few versions of the ESP32 board, the board in this tutorial has 30 pins:

https://lastminuteengineers.com/esp32-pinout-reference/

Several example circuits on the internet make use of the TP4056 Lithium Battery Charger Module, but these circuits require a voltage regulator — a Low-dropout or LDO regulator (MCP1700-3302E, a 100uF electrolytic capacitor, and a 100nF ceramic capacitor or a diode.

Besides needing additional components, there are better solutions than the TP4056 for a solar-powered circuit: Solar panels are not batteries. As a power source, they are unstable. Depending on the sunlight, the voltage and current a panel generates will vary according to the amount of light available. It is the fluctuations of voltage generated that can confuse battery chargers. When chargers are confused, they either rapidly turn on and off as they try to draw more current from the panel than possible, and/or they draw much less current than they can to keep the voltage from collapsing.

For this tutorial, I opted to go with the Adafruit Universal USB / DC / Solar Lithium Ion/Polymer charger – bq24074, which is designed to handle the variability of power from a solar panel. When the input drops below 4.5V, the charger backs off and automatically reduces the charge rate to keep the voltage above 4.5V.

Step 1: Gather Your Parts

Step 2: Pick a Breadboard Strategy

The ESP32 is not particularly breadboard-friendly. One solution is to use two breadboards and straddle the gap with the ESP32 or use a breakout board as I do.

randomnerdtutorials.com

Step 3: Wire the Circuit

The voltage divider for battery monitor logic comes from Random Nerd’s Power ESP32/ESP8266 with Solar Panels tutorial. The ESP32 has an input voltage of 3.3V, but the battery, when fully charged, outputs a higher voltage. By adding a voltage divider we are able to read the voltage level of the battery:

Voltage divider from Random Nerd’s tutorial

Code for reading battery level where b returns percentage and b2 returns voltage
[code lang=”arduino”] float val = analogRead(VOLT_PIN);
//reads the analog input
Serial.println(val);
Vout = (val * 3.3) / 4095.0; // formula for calculating voltage out
float b = Vout * (R2 + R1) / R2; // formula for calculating voltage in
b = map(val, 0.0f, 4095.0f, 0, 100);
float b2=(((b*40.95)*(3.3/4095))*4.2)/3.3;
[/code]

Step 4: Set Up the Arduino IDE

Open or install the Arduino IDE. If you do not have the latest version of the Arduino IDE installed:
1. Navigate to the Arduino website.
2. Select your operating system and download the software.
To program the ESP32 board using Arduino IDE, you need to install the ESP32 and add-on. Open the Preferences window in the Arduino IDE.
Go to File > Preferences.
Enter the following into the “Additional Board Manager URLs” field.

https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json
Click OK.
Open the Boards Manager. Go to Tools > Board >Boards Manager…
Search for ESP32 by Espressif Systems

Step 5: Set Up Your ESP32

Connect your ESP32-WROOM to your computer through USB. Then, follow these steps:

Open the Arduino IDE.
Select your board in the Tools Board menu (in our case, it’s the ESP32-WROOM-DA Module).
Select the Port. If you don’t see the COM Port in your Arduino IDE, you will need to install the ESP32 CP210x USB to UART Bridge VCP Drivers or other drivers, depending on the board model you’re using).
To test that it all works, open the WiFi example:
Click on the Upload button:

If everything went as expected, you should see a “Done uploading.” message. If you don’t, you’ll need to troubleshoot.

Step 6: Set Up Your Program

Create a new Sketch and save it as ESP32_temperature.

Step 7: Import Libraries

You’ll need a few libraries, so go to Tools and select Manage Libraries…

You’ll need to install:

DallasTemperature by Miles Burton
OneWire by Jim Studt, Tom Pollard, Robin James, and Paul Stoffregen
ArduinoHttpClient by Arduino
WifiMulti_Generic by Khoi Hoang
ESPEssentials by Stephen Rumswinkel

When prompted, install all libraries and their dependencies.

Step 8: Copy and Paste the Code into Your Sketch

[code lang=”arduino”]// TagoIO and ESP integration with Temperature
// inspired by Carlo Stramaglia April 2nd 2023

#include
#include
#include
#include
#include ;

#define uS_TO_S_FACTOR 1000000ULL /* Conversion factor for micro seconds to seconds */
#define TIME_TO_SLEEP 10 /* Time ESP32 will go to sleep (in seconds) */

char serverAddress[] = "https://api.tago.io/data"; // TagoIO address
char contentHeader[] = "application/json";
char tokenHeader[] = "[XXX]"; // TagoIO Token
const char *ssid = "[XXX]";
const char *password = "[XXX]";

WiFiClient wifia;
// HttpClient client = HttpClient(wifia, serverAddress, port);
HTTPClient client;
int status = WL_IDLE_STATUS;

// Variables used in calculating the battery voltage
float b;
float Vout = 0.00;
float Vin = 0.00;
float R1 = 27000.00; // resistance of R1 (27K) // You can also use 33K
float R2 = 100000.00; // resistance of R2x (100K)
//int val = 0;
// GPIO where the DS18B20 is connected to
const int oneWireBus = 4;

const int VOLT_PIN = 33;

unsigned long startTime;
unsigned long timeAwake;
bool started=false;
// Setup a oneWire instance to communicate with any OneWire devices
OneWire oneWire(oneWireBus);

// Pass our oneWire reference to Dallas Temperature sensor
DallasTemperature sensors(&oneWire);

//Time in seconds
#define CONNECTION_TIMEOUT 5
#define DEEP_SLEEP_DURATION 10

void wifi_connect() {

WiFi.mode(WIFI_STA);
if (ssid != "")
WiFi.begin(ssid, password);
WiFi.begin();
Serial.println("");

// Wait for connection
int timeout_counter = 0;

while (WiFi.status() != WL_CONNECTED) {
Serial.print(".");
delay(100);
timeout_counter++;
if (timeout_counter >= CONNECTION_TIMEOUT * 10) {
Serial.println("\nCan't establish WiFi connexion");
//Setup timer
esp_sleep_enable_timer_wakeup(DEEP_SLEEP_DURATION * 1000000);
//Start deep sleep
esp_deep_sleep_start();
}
}

Serial.println("");
Serial.print("Connected to ");
Serial.println(ssid);
Serial.print("IP address: ");
Serial.println(WiFi.localIP());
}
void Read_And_Send_Sensors_Data() {
char anyData[30];
char postData[300];
char anyData1[30];
char bAny[30];
int statusCode = 0;
sensors.requestTemperatures();
Serial.print("Temperature in F: ");
Serial.println((sensors.getTempCByIndex(0) * 9.0) / 5.0 + 32.0); //print the temperature in Fahrenheit
float t = (sensors.getTempCByIndex(0) * 9.0) / 5.0 + 32.0;

//Temperature
Serial.print(F("Temperature: "));
Serial.println(t);
strcpy(postData, "{\n\t\"variable\": \"Temperature\",\n\t\"value\": ");
dtostrf(t, 6, 2, anyData);
strncat(postData, anyData, 100);
strcpy(anyData1, ",\n\t\"unit\": \"F\"\n\t}\n");
strncat(postData, anyData1, 100);
Serial.println(postData);
client.begin(serverAddress);
client.addHeader("Content-Type", contentHeader);
client.addHeader("Device-Token", tokenHeader);
statusCode = client.POST(postData);
// read the status code and body of the response
Serial.print("Status code: ");
Serial.println(statusCode);
Serial.println("End of POST to TagoIO");
Serial.println();

// Reading Battery Level
float val = analogRead(VOLT_PIN); //reads the analog input
Serial.println(val);
Vout = (val * 3.3) / 4095.0; // formula for calculating voltage out
b = Vout * (R2 + R1) / R2; // formula for calculating voltage in
float b = map(val, 0.0f, 4095.0f, 0, 100);
float b2=(((b*40.95)*(3.3/4095))*4.2)/3.3;

Serial.print(F("Battery Voltage: "));
Serial.println(b2);
strcpy(postData, "{\n\t\"variable\": \"Voltage\",\n\t\"value\": ");
dtostrf(b2, 6, 2, anyData);
strncat(postData, anyData, 100);
strcpy(anyData1, ",\n\t\"unit\": \"V\"\n\t}\n");

Serial.print(F("Battery Voltage: "));
Serial.println(b);
strcpy(postData, "{\n\t\"variable\": \"Voltage\",\n\t\"value\": ");
dtostrf(b, 6, 2, anyData);
strncat(postData, anyData, 100);
strcpy(anyData1, ",\n\t\"unit\": \"%\"\n\t}\n");
strncat(postData, anyData1, 100);
client.begin(serverAddress);
client.addHeader("Content-Type", contentHeader);
client.addHeader("Device-Token", tokenHeader);
statusCode = client.POST(postData);
// read the status code and body of the response
Serial.print("Status code: ");
Serial.println(statusCode);
Serial.println("End of POST to TagoIO");
Serial.println();
startTime=false;
}
void go_to_sleep() {
esp_sleep_enable_timer_wakeup(TIME_TO_SLEEP * uS_TO_S_FACTOR); // ESP32 wakes up every x seconds
Serial.println("Going to deep-sleep now");
startTime=false;
timeAwake=millis()-startTime;
Serial.print("Time Awake=");
Serial. println(timeAwake/1000.0);
Serial.flush();
esp_deep_sleep_start();
}

void setup() {
startTime=millis();
Serial.begin(115200);
delay(10);
wifi_connect();
}

void loop() {
wifi_connect();
Read_And_Send_Sensors_Data();
go_to_sleep();
}[/code]

Step 9: Create the Dashboard

Navigate to TagoIO and create an account or sign in.
Create a new device by clicking on the Device icon and then selecting the Arduino HTTP profile:
Assign a name to your device and press the Create my Device button:
Once the device is created, TagoIO will generate a token. Copy the token as you will need it in your Arduino code:

Step 10: Return to Arduino

Back in the Arduino IDE, paste your token in this line and replace [XXX]
```
char tokenHeader[] = "[XXX]"; // TagoIO Token
```
Add your SSID name and password, replacing [XXX]:
[code lang=”arduino”]const char *ssid = "[XXX]";
const char *password = "[XXX]";[/code]
Compile and upload the code.

Step 11: Return to TagoIO

1. Navigate back to TagoIO.
2. Open the Live Inspector to check the data. You should see the temperature and battery level values posted in the TagoIO Interface.
3. Add a dashboard and name it:
4. Name your dashboard and add a background:
5. Click on the three dots and select Configure:
6. You can add a background image to your dashboard here:
7. Save and click on Add widget:
8. Select a widget and format it. Give it a name and select the variable, change the colors, enable Show last update:
9. Create a second widget for the Battery Voltage Level.
10. If the values make sense, set your access by clicking on the Access button. Here, I have set access to be public:
11. Set up your preferences in the Run tab:
12. Ctrl+click on the Dashboard name in the dashboards list and select Share Public if you want your dashboard to be public:
Step 12: Enable Deep_Sleep Mode

Now that everything is working, you’ll want to update the code to take advantage of deep sleep mode.

The use of deep_sleep mode in conjunction with solar power demonstrates efficient energy management. By sleeping most of the time and only waking up to read sensors and send data, you can minimize the energy consumption of your ESP32 device, which is crucial for battery longevity, especially when it relies on solar charging.

The ESP32 has the following operating modes:
- Active mode
- Modem Sleep mode
- Light Sleep mode
- Deep Sleep mode
- Hibernation mode
The following table lists which peripherals and units are either active or inactive during different modes.

https://microcontrollerslab.com/micropython-esp32-deep-sleep-mode-wake-up-sources/

Generally, the ESP32 is very power-hungry and may pull up to 75mA in normal consumption or inactive mode. If WiFi is also being used, then your current consumption could go up to somewhere around 240mA. If that’s the case, and you’re trying to power your device using batteries and solar, you won’t be able to use the ESP32 in active mode without draining your batteries.

There is a solution, and that is to put the module into a deep sleep mode to reduce the power consumption. When in deep sleep, the current consumption should be in the range of micro Amperes (μA) and your batteries will last longer.

I tested my setup before implementing deep sleep mode using a Proshopping 150A RC Watt Meter, High Precision Power Analyzer attached to an external battery:

Inline setup with external battery connected

Here were my results when the ESP32 was sending data:

4.8V * 0.21A=.987 Watt or about 1 Watt. If I ran the program continually, it would consume 24 Watt hours per day (24hours * 1 Watt). In this semi-shady location, I expect the panel to produce closer to 5 Watt hours a day and if I don’t change anything, the system will fail. The solution is to send less data and put the device to sleep between transmission.

The duty cycle is the ratio of time a load or circuit is ON compared to when the load or circuit is OFF. By manipulating this cycle, we can reduce the device’s power consumption.

The ESP32’s WiFi module, Processing Cores, and Bluetooth module all require current to operate. To conserve power, we can disable what we’re not using. Putting the ESP32 in deep_sleep mode disables everything except the RTC (Real Time Clock) module.

The power analyzer I’m using does not capture the current below .01A. So I can assume .01A in the worst case, but from the documentation, I know I’m in the micro Amperes range. If I use the timer in the code to measure how many seconds the device needs to take a measurement and send the data and then enable deep_sleep for a certain amount of time in between waking, reading, and sensing, I can conserve quite a bit of power.

If the device needs around 5-10 seconds to connect to WiFi, read and send the data, and is in deep_sleep mode for 10 minutes in between readings, then the device is on for about 2 minutes every hour and in deep_sleep for the rest of the hour.

Deep_sleep Power Consumption
[code lang=”arduino”]4.7V * 0.01A = ~0.047 Watts
proportion of time device is sleeping = 59/60
59/60 * 0.047 Watts = 0.0462 Watts
0.0462 Watts * 24h/day = 1.108 Watt hours per day in sleep mode[/code]

Reading and Sending Power Consumption
[code lang=”arduino”]4.7V * 0.21A = ~1 Watt
proportion of time device is awake = 1/60
1/60 * 1 Watt = 0.0166 Watts
0.0166 Watts * 24h/day =0.3983 Watt hours per day reading and sending[/code]
So guesstimating my consumption this way brings it down to about 0.066Wh.

If I multiply that number by 24, I end up with 1.58Wh a day.

Total Power Consumption
[code lang=”arduino”](1/60)*0.21A + (59/60)*0.01A = 0.0133A
0.0035 + 0.0098 = 0.0133A
4.7V * 0.0133A = 0.0625Wh
24 * .0625Wh = ~1.5Wh[/code]

Implementing deep_sleep brings the power consumption down from 24Wh to about 1.5Wh. That’s a big difference!

The method above was a rough estimation. If I use Qoitech’s Otii Ace Pro, I can more accurately measure the power consumption.

Here is the circuit attached inline to the Qoitech:

And here are the results:

From the readings, I can see that when the device is awake, sensing, and sending, the amps measured equal a max of 180mA or .18A. When the device is in deep_sleep mode, the amps measured are 4.54mA or 0.00454A.

[CP_CALCULATED_FIELDS id=”7″]

Return to your code and update this line:
```
#define TIME_TO_SLEEP 30 /* Time ESP32 will go to sleep (in seconds) */
```
Think about how often you really need to check the temperature. Every 15 minutes, 30 minutes, hour? Play with the form above and then make your adjustments to your code.

While I started with a panel and battery, if you were building your own device from scratch, you would want to create your circuit without the panel or battery. You would then measure your power consumption with a watt meter, Qoitech, or similar. You would then select your panel and device based on:

your estimated daily power consumption
where your device is deployed
how much sun your device will be exposed
how many days you would expect your device to run without sun.

Solar Powered River Gauge with Particle

Voltaic Systems — Mon, 09 Dec 2019 15:43:14 +0000

StreamBeam a community funded, volunteer run organization has built some beautiful stream monitoring gauges using ultrasonic sensors, Particle Boron and Voltaic solar panels. The monitors are placed on bridges in Alabama and provide updated data every 15 minutes.

These systems were developed to support the local kayaking community, but we imagine the design could be useful to a wide range of people including researchers, local DOTs, and water boards.

The detailed BOM is as follows:

Custom PCB Mount
Maxbotix MB 7386 Ultrasonic Sensor
Particle Boron
2500mAh LiPo Battery
6 Watt Solar Panel

With this version, StreamBeam has made a number of improvements. They recently switched from the Electron to the Boron and said they are achieving “better connectivity in more locations and reduced power consumption.” To make the solar generation more efficient, they modified the PMIC settings to set the charge voltage to 5.08 (closer to that of Vp on the panel) to increase power to the battery. Finally, they added solar radiation housings so that they can more accurately measure ambient air temperature and make generate more accurate river height measurements.

We’re excited to see how off the shelf components can be put together to make such a useful tool. We look forward to seeing more in action. View the live stream heights here.

Solar Kit for Makers Giveaway (20 Winners!)

Voltaic Systems — Sat, 16 Nov 2019 19:53:26 +0000

This contest is closed. Congrats to all the winners! Great to see all the exciting projects in the works including weather, water, garden monitoring, sound art and water fountains.

We’re getting in the holiday spirit and giving away free 2 Watt Solar Charger Kits to 20 lucky makers. This system includes our waterproof 2 Watt solar panel and Always On V15 USB Battery Pack. Simply tell us your project description below. It can cover robotics, art, IoT, lighting, sensing and use an Arduino, Raspberry Pi or no controller at all.

Why Are You Giving Away So Many Kits? These panels will have minor physical blemishes. We want these panels and batteries to find a loving home.

How Can I Win? We will choose winners based on completeness of description and likelihood of project completion. Clearly describe what you want to build and you have a pretty good chance of winning.

Who Can Enter? Due to shipping constraints, we will only ship to addresses in the United States (lower 48).

FieldKit Wins Grand Prize at Hackaday 2019

Voltaic Systems — Sat, 16 Nov 2019 17:52:53 +0000

FieldKit, a core project of Conservify, was recently awarded the Grand Prize of the 2019 Hackaday Prize. Conservify works to build and develop tools and technologies that make it easy for communities to implement effective conservation practices. The FieldKit system was originally developed after the team’s work in Botswana, Angola, and Namibia left them struggling to find good quality open source tools that meet the needs of their field research. This standardized, open-source software and hardware platform allows for local agencies, activists, schools and communities to easily collect and share data throughout their own projects.

Image Courtesy of Conservify.org

Designed as a complete system, FieldKit’s team thought of everything to make to this system user-friendly from deployment to data collection and exporting. The team has also integrated our high performance 5.5 Watt ETFE Solar Panel for a reliable, rugged power solution in the field.

Image Courtesy of Conservify.org

To learn more about FieldKit and the work that Conservify does, visit their website here: http://conservify.org or follow them on Instagram.

Spoondrift Launches Solar Powered Ocean Monitor

Voltaic Systems — Wed, 07 Jun 2017 17:15:52 +0000

Spoondrift just launched their Spotter, a real-time ocean monitoring device. The Spotter collects ocean wave and surface current data and reports it via satellite to a web dashboard. They also use our 2 Watt small solar panels to power the Spotter from the sun.

We’ve been working with the team at Spoondrift from prototype through production and have been impressed by their dedication to the product design and passion for ocean monitoring.

The result of their efforts is a compact, portable ocean monitor that uses the latest sensing and web technologies to be affordable (in the realm of professional oceanography equipment) and easy to use.

The Spotter, including a year of Iridium service, is now available for pre-order on Spoondrift’s site.

Version	Release date
1.0	January 2015
1.0.1	February 2016
1.0.2	July 2016
1.1	October 2017
1.0.3	July 2018
1.0.4	October 2020

environmental monitoring – Voltaic Systems Blog

Obscape Uses Voltaic In Rugged Environmental Devices

Solar for BirdWeather BioAcoustic Platform

Solar Powered Nano 33 IoT Soil Moisture Tutorial

Overview

Parts Needed

The Renke Soil Moisture Sensor

Wiring Instructions

Modbus Communication of the Soil Sensor

The Arduino Nano 33 IoT

Saving Power

Setting up the Arduino Nano 33 IoT

Setting up the MAX 485 TTL to RS485 Converter Module

Power Consumption

Approach One: ArduinoLowPower with N-Channel MOSFET

Approach Two: RTC and P-Channel MOSFET

Connecting to Wi-Fi

Connecting to a Public Dashboard – Qubitro

Characterizing Power Consumption

Connecting to Solar

Wrapping up

Tide Monitoring Tutorial with Particle Monitor One

Project Overview

Background on Tide Monitoring

Parts Needed for Tide Monitoring

Software Requirements

Helpful Documents

The Monitor One

Step 1: Follow the Monitor One Quickstart Guide

Step 2: Set Up the Particle Workbench in Visual Studio Code

Step 3: Gather Your Parts

Step 4: Connect the Sensor

Step 5: Connecting the M1 to your computer

Step 6: Clone the Firmware

Step 7: Open the folder from the Particle Workbench

Step 8: Modify the code

Step 9: Compile the code

Step 10: Flash the M1:

Step 11: Using the Console to Enable Modbus Settings

Step 12: Set up Modbus Polling 1

Step 13: Troubleshooting

Step 14: Characterize Power Consumption

Step 15: Adding a Voltage Divider Circuit

Step 16: Putting the Board to Sleep

Step 18: Connecting to a Dashboard

Step 17: Deploying

Next steps

Adding Another Sensor

Solar Powered LoRa Radio Barometric Pressure and Altimeter Tutorial

Overview:

An IoT Feather M0 with Barometric Sensor

Parts Needed

Parts of the System

Step 1: Gather Your Parts

Step 2: Solder Your Headers and Antenna

Step 3: Wire the Circuit

Step 4: Set Up the Gateway

Step 5: Register your Feather

Step 6: Arduino

Open the Arduino IDE

Step 7: Setting up Your Feather M0

Step 8: Set Up Your Program

Step 9: Importing Libraries

Step 10: Copy and paste the code

Step 11: Adding your Activation Information

Step 12: Payload formatters

Step 13: Characterize Power Consumption

Step 14: Putting the Board to Sleep

Sizing the System

Connecting to a Dashboard

Solar Powered ESP32 over WiFi Application Tutorial

Overview:

An IoT ESP 32 Temperature Sensor

Parts Needed

Step 1: Gather Your Parts

Step 2: Pick a Breadboard Strategy

Step 3: Wire the Circuit

Step 4: Set Up the Arduino IDE

Step 5: Set Up Your ESP32

Step 6: Set Up Your Program