System for Testing RFID Tags’ Ability to Sense Humidity

Author: Brett Stoddard

Hello  Everyone! 

For the past few weeks, I’ve been further examining the RFID Dogbone Tags. This time I’m testing their capability as capacitive humidity sensors. This article describes the system I built to test them out.

Abstract and Objectives

This blog post describes a system to log data from multiple Smartrac Dogbone RFID moisture sensing tags in the air over the course of the day. The goal of this system is to log the Dogbone’s moisture sensor levels vs a DHT11 Humidity and Temperature sensor. After logging data for multiple day cycles, enough data should be present to tell if there is a relationship strong enough between the Dogbone’s measurements and the DHT11. Further testing would be warranted if such a relationship exists.

To measure multiple tags at once, this system incorporates a HyperRail prototype. The HyperRail’s details can be found distributed throughout this blog page on the OPEnS site.






Over the weekend the system was run. It gathered some data, but not enough to make a sure prediction of whether the Dogbone tags can be used as humidity sensors. However, this is an example of what the code output should look like.

Values of RFID, Humidity, temp, EPC, time, f

What data should look like when opened in Excel

Known Issues

As of now, the SD card will only log data when the Arduino is plugged into both USB. This shouldn’t be necessary because it is already powered by Vin. This issue is probably a power supply limitation of my specific setup, however, I thought it was worth noting here.

Shield Sandwich for Dogbone Tags

By Brett Stoddard


One problem that I’ve been having with burying the Smartrac Dogbone tags is that soil is that they break after some use. After taking a close look at some of the broken tags it appears that this is caused by the abrasive soil eventually cutting through the outer lamination of the Dogbone tags and then damaging the IC that controls the tag, causing them to become unresponsive. To counter this, I designed a two part protective enclosure for the tag that will hopefully protect them from damage. The design is outlined below:



This “Dogbone Sandwich Shield” is made up of two identical 3-D printed parts. The sandwich ends were designed to be slightly larger than the Dogbone’s footprint with two tabs on the long ends. The tabs were placed like this to minimize interference with the moisture sensitive area of the tag which sits at its center. 

Assembling the product was a fairly simple process. First, the Dogbone tag was stickered onto one of the sandwich ends. Then a small amount of acetone was brushed onto all of the sandwich end’s tabs. They were then pressed together to create a sandwich with the Dogbone in the middle. The sandwich was then treated in an acetone air bath to seal the edges. After 20 seconds in the air bath, the part was removed and put in a vice under a small amount of even pressure to make it even until it hardened. It takes around a day to fully harden, but it is tough enough after an hour. Below is a picture of the final shield. 



Two built RFID sandwiches. One made of ABS plastic, the other made from HIPS


The presence of the shield surrounding the Dogbone tag made it slightly less sensitive to moisture, however, the variance from readings with the shield was no greater than it was without them. Therefore, using the shield will not influence the accuracy of the sensor once, but it will require some re-calibration.

Thinking Ahead

Thinking ahead, creating shields like this one with varying thickness could allow for changing the sensitivity of the tags. Currently, without a shield, the tags read their lowest value before the soil has gotten completely saturated and are able to read soil that is more than completely dry. Adding a shield that is a certain depth should shift the reading range to be centered and allow the tags to read over a larger range of soil conditions than they currently do.


STL file shield tag

Toward Comparing RFID Moisture Performance with Industry Standards: Decagon

Author: Chet Udell




Our previous experiments have shown the RFID moisture sensor tags are in-fact reading gradual changes in soil moisture content. The next step is to compare the performance, consistency, and resolution of these tags to industry standard equipment to see how it measures up using Decagon Devices soil moisture sensors. In this post, Chet gets a 5TM Soil Moisture and Temperature Sensor chatting directly with an Arduino to deploy in experiments, and eventually integrate into the battery of available Internet of Ag sensors.


In order to compare the performance, consistency, and resolution of the RFID moisture tags, we hope to conduct some comparative experiments between these and Decagon’s popular soil moisture sensors, namely the 5TM (soil moisture + temp). Decagon’s readers can be pricey and we want to use these sensors in very specific ways, so the objective here is to get the sensors talking directly with an Arduino. The following method can be used to read any Decagon soil moisture sensor over the SDI-12 serial protocol. For more info on SDI-12, visit here. Why the 5TM? The 5TM determines volumetric water content (VWC) by measuring the dielectric constant of the soil (or other media) using capacitance/frequency domain technology. Signal filtering minimizes salinity and textural effects, making the 5TM accurate in most soils and soilless media. Factory calibrations are included for mineral soils, potting soils, rockwool, and perlite. – from

Materials and Methods

What you’ll need:

  1. Download the above library, unzip. Rename the file “SDISerial” and place in the folder: <Arduinno root folder> / libraries
  2. Following the instructions on the library GitHub page (image included here), clip the 1/8 inch jack off of the Decagon sensor (ouch), strip off the leads to reveal a white, red, and “shield” wires. Solder each wire to a 0.1in pitch male header to use in a breadboard.
  3. Connect your arduino up to a breadboard and the 5TM lines White => 5V, Red => DATA_PIN, Shield => GND
  4. DATA_PIN MUST be connected to a pin with a hardware interrupt (for Uno, P2 or P3).
  5. Use the below code and you’ll get soil moisture and temp readings (in Celsius).
  6. Your output will look like the below screen print


As you’ll see from the below code and printout, the SDISerial library enables the arduino to send commands to the 5TM to procure data. Now, we can employ these sensors in almost any Arduino application! This is done by creating an instance of SDISerial connection(DATA_PIN); and then starting the serial connection using connection.begin();

You can then use the function connection.sdi_query() to send various commands to the 5TM. This function uses 2 parameters: (command, timeout-duration)

connection.sdi_query(“?M!”,1000); This sends a message to query the first device on the bus – which in use seems to refresh the values of the sensor readings, but does not return the sensor reading itself. Instead, it returns a message that tells you the maximum wait before the measurement is ready. timeout set for one second.

connection.sdi_query(“?I!”,1000); will get sensor info and timeout if no response in 1 second

connection.sdi_query(“?D0!”,1000); will query the 5TM for sensor data



Hookup on a Mega, similar to the Uno




Resulting output
Tested on UNO R3.
Sketch was built with Arduino 1.6.12
Dependency: Joran Beasley SDISerial Library
Accessed May 26, 2017 here:

download and rename folder "SDISerial" and place in  "<ARDUINO_ROOT>/libraries"

Tested with the with the 5TM Soil Moisture and Temp Sensor:

the WHITE wire goed to 5V. however you could also connect it to a pin and drive power only when you wanted it
the RED wire is the DATA_PIN. - you must hook it up to a pin that can process interrupts (see link below)  
the remaining "shield" wire must be connected to ground

#include <SDISerial.h>
#include <string.h>
#define DATA_PIN 2
SDISerial connection(DATA_PIN);
char output_buffer[125]; // just for uart prints
char tmp_buffer[4];
char* resp; // Pointer to response char

//initialize variables
void setup(){
      Serial.begin(9600);//so we can print to standard uart
      //small delay to let the sensor do its startup stuff
      delay(3000);//3 seconds should be more than enough
      char* sensor_info = connection.sdi_query("?I!",1000); // get sensor info
      //print to uart
      sprintf(output_buffer,"Sensor Info: %s",sensor_info?sensor_info:"No Response");

//main loop
void loop(){

   //print to uart
    Serial.println("Begin Command: ?M!");   
    //send measurement query (M) to the first device on our bus
    resp = connection.sdi_query("?M!",1000);//1 second timeout
    //this really just returns a message that tells you the maximum wait before the measurement is ready
    sprintf(output_buffer,"RECV: %s",resp?resp:"No Response Recieved!!");
    delay(1000);//sleep for 1 seconds before the next command
    //print to uart
    Serial.println("Begin Command: ?D0!");
    resp = connection.sdi_query("?D0!",1000);//1 second timeout
    sprintf(output_buffer,"RECV: %s",resp?resp:"No Response Recieved!!");
    delay(3000);//sleep for 10 seconds before the next read

Moisture Reader Update 3

Author: Brett Stoddard

Hi everyone, it’s been a while since the last update with the moisture sensor and a lot of progress has been made in that time. Progress has been made with confirming moisture readings and on the code side of things.

After a few more rounds of testing I have confirmed that the tags, for sure, can be used to measure a range of moisture levels. The test involved dropping different volumes of water onto the edge of a tag’s tail. The tail would soak some of that water up and onto the moisture sensitive part of the tag. The tails were about an inch long and increments of 25mL of water was dripped onto them using a precision eyedropper. The data (TABLE 1) showed a definite positive correlation which is good news. I also did a few trials on really wet and really dry soil and the tags were able to tell the difference between a desert and a swamp, although a more accurate of testing tags in soil was needed–which is where the next development comes into play.



TABLE 1. Table of tag measurements given a certian amount of water on the edge of the tail of a tag and a certian amount of time for the water to work its way up the tag.


Since the last post, I have gotten the RFID reader shield and the GPS logger shield to work together. I have added a polished example code bit onto the GitHub library. Available here, it records the average value of the RFID tag after 100 measurements then records measurement from a YL-69+YL-38 moisture sensor. The plan with this reader is to eventually use it to calibrate the values that we’re currently receiving off of the RFID tags (0 for wet, 20 for dry). This will involve setting the YL probe and RFID tag onto the same soil sample and letting it sit there for a few days and take measurements periodically as the soil drys. After we get this data we will be able to tell how well the RFID tags will work for measuring soil moisture.

I have also gone through and updated a little bit of the other example codes to make them work better.

Cheers, Brett Stoddard

RFID Sensor Update 2

Author: Brett Stoddard

Hi everyone, this week has been an exciting one for the world of OPEnS RFID moisture sensing. Since the update, we have found ways to make the sensors even more reliable and sensitive. Two updates have allowed for this development.

The first major modification came when “tails” were added to the RFID tag. These tails are made out of a paperlike material that’s designed to suck up and hold and moisture it comes into contact with. The more moisture it touches, the more water it sucks up thanks to capillary action. Tails can be positioned on the sensor to hold the liquid in the most moisture sensitive area of the tag to maximize the accuracy of readings. Sure enough, as soon as we started gathering data with the tails attached the reliability of our measurements improved by a lot. An image from one of Smart Trac’s technical documents showcases the tail below. All future testing will be done using these tags.



Image of a tail attached to an RFID tag


The second change was implemented on the software side of things. Before this week the sensor value was only read once and then outputted. The new code took 100 readings and then outputted the mean value. By using this method, more reliable and accurate readings were made. These new readings improved consistency across all of the tags for sensing extremely wet, extremely dry, and moist tail conditions. In the future, we will examine the exact distribution of the readings to determine the minimum number of readings that are needed to get a value with 80-90% certainty. The example code can be seen in this folder of the RFID library. This code is not yet optimized.

RFID Sensor Update

Author: Brett Stoddard

Hello all, it’s been a while since the last sensor status but from now on I’ll be working to increase my posting frequency.

Since the last update, many things have been happening on the sensor end. First, the OPEnS lab bought a new RFID module to interface with the Arduino UNO and have semi-officially scrapped the LinkSprite LSID-0702 reader. From here on out, we will be using the SparkFun Simultaneous RFID Reader – M6E Nano shield. I was really excited to get working with this reader because it’s documentation is a lot more readable and through than the other modules I’ve worked with.

That documentation included a SparkFun proprietary library especially made for use with the Arduino UNO. I forked this library on GitHub and have been adding to it a few functions specifically geared towards reading the moisture information from Smart Trac RFID tags. For the most part, these functions seem to work! The original SparkFun library is available by clicking here. The OPEnS lab version of it that I have and will be adding to can be found by clicking here.

The rest of this blog post will be dedicated to the results of tests run to prove that the retrieved values are dependent on the actual moisture of the chips. “Wet” tags were held under a stream of moving water in the sink for five to ten seconds. “Dry” tags are either tags that were never wet or ones that were set out to dry for a few days. 

FIGURE 1. Raw, unprepared data from the serial port of the Arduino UNO when example code from the library is run.

This data was gathered by modifying a read EPC byte command to read a different registry. What that means is that the data is unparced and looks gross. The important thing from this data is that the sensor code was reading a different number when it was wetted. When dry the tag had a value of either 12 or 14 HEX (18 or 20 decimal). Then when that same tag was run under the sink it read a value of 0C or 0C HEX (12 or 13 decimal). Being able to tell the difference between really wet and completely dry is a large step forward for this project and this data, if consistent, will allow us to do just that. However, as always, more testing will be needed to make this process robust enough for use in the field. 

Building a Drone

Author: Jonah Siekmann

For this project, we’ll need to construct a drone that will carry the RFID reader around a crop field. It’ll need to remember the locations of every new RFID ‘Dogbones’ moisture sensor it encounters, and store the GPS coordinates so that it can return to the sensor later. We’re not sure yet how much weight it’ll need to carry, which leaves a lot of the the specs of the drone up in the air. We’ve come up with a general parts list, however, which includes the following:

CC3D Flight Controller

750KV Motor (x4)

30A ESC (x4)

4000mah 3s battery

12×4.5″ propellors

650mm frame

Arduino Uno

GPS module

RC Transmitter/Receiver

Our idea for flying the drone autonomously involves hooking up the Arduino to the CC3D flight controller’s RC receiver pins, and simulating the 1000-2000us pulses that the flight controller would expect from a receiver with the Arduino. This way, the CC3D flight controller does all the low-level attitude hold and hovering work, while the Arduino is free to read the GPS sensor and control the position of the quad by pretending to be an RC receiver.

We Broke It

Author: Brett Stoddard

Today the RFID team fried the Cottonwood when we supplied it with 12V instead of 5V. 

A new, better system was purchased and should be getting to us soon.

RSSI Moisture Test 1

Author: Brett Stoddard

Hello all, today the RFID team figured out how to use the Cottonwood to communicate with the Dogbone tags. To celebrate, we measured the Dogbone tag’s RSSI value in wet and dry conditions. This was done to see if RSSI value could be used as an indicator of moist conditions.

RSSI value is a measurement of received signal strength. It’s an acronym for “received signal strength indicator”. It’s often used in WIFI signals. Here is a good article from MetaGeek that explains it further:

For this test, we read multiple RSSI values when the tag was dry first. We then wet a piece of paper behind the tag and recorded the RSSI values again. The picture below shows our setup. It should be noted that while wetting the tag we might have disturbed the system which would mean that our results will need to be backed up with further, more precise testing.



To receive the RSSI data, we sent an “Inventory Command with RSSI” command from the Arduino to the Cottonwood. The command was sent as a character array { 0x44 , 0x03 , 0x01 } and was taken from the Cottonwood’s datasheet. We got back a message that contained the RSSI value in the third byte of the response. Below is a table with the RSSI values measured in wet and dry conditions.

This is the table of the data. As you can see the Q value average was higher than the Q value average in dry conditions. A higher RSSI in wet conditions could be attributed to the presence of water tuning the signal.

In conclusion, there might be a slight correlation with moisture, but further testing is needed. Also, the distance between the antenna and tag is a large factor in the RSSI value and should be taken into consideration before implementation.