RoadTest: Particle Mesh Wi-Fi Bundle + Grove Sensor Kit
Author: stevesmythe
Creation date:
Evaluation Type: Development Boards & Tools
Did you receive all parts the manufacturer stated would be included in the package?: True
What other parts do you consider comparable to this product?: There are many low-cost IoT rapid development platforms available (e.g. NodeMCU, Arduino MKR1000) but no other comparable Thread mesh platforms that I know of.
What were the biggest problems encountered?: Initially, getting multiple devices to connect to the mesh network.
Detailed Review:
Particle’s “Mesh” is a range of IoT devices that use Particle’s own implementation of OpenThread networking. If you have a Nest smart thermostat (or any other Nest products) in your home, you are using the OpenThread mesh networking system. OpenThread was designed to be a low-power, lightweight, resilient and secure networking protocol. These attributes make it ideal for Internet of Things (“IoT”) applications.
My overall aim for this RoadTest is to provide a potential purchaser with a fair and realistic appraisal of the Particle Mesh Wi-Fi Bundle and Grove Starter Kit for Particle Mesh.
Many thanks to element14 and Particle for providing me with the Particle Mesh Wi-Fi Bundle and Grove Starter Kit for Particle Mesh to review.
Particle.io (formerly Spark.io) produces low cost IoT hardware, software, and connectivity. Its website claims 180,000 developers, 170 countries, 8,500 companies, and 500,000 devices. Their product line includes:
“First generation” (no longer sold):
“Second generation”
“Third generation”
The roadtest actually comprises two kits – the Particle Mesh Wi-Fi Bundle and the Grove Starter Kit for Particle Mesh.
The Particle Mesh Wi-Fi bundle comprises three third-generation Particle board kits (one Argon and two Xenons), a Particle Debugger and a FeatherWing Tripler.
All three third-generation devices are built around the Nordic nRF52840 MCU + BLE + mesh radio and have 4MB onboard SPI flash and 8 PWM pins. The BLE stack on each of the third-generation devices is only used for configuring and deploying the devices (via a phone or tablet).
The third-generation devices have six analogue channels (A0 to A5) with a 12-bit resolution. This means that it will map input voltages between 0 and 3.3 volts into integer values between 0 and 4095. This yields a resolution between readings of: 3.3 volts / 4096 units or, 0.0008 volts (0.8 mV) per unit.
The boards follow the Adafruit Feather specification, allowing additional components (such as an OLED screen or a relay board) to be connected via a Feather shield (such as the FeatherWing Tripler that element14 kindly included for the Roadtest).
Each of the three Particle board kits comes with a USB cable, a breadboard, two resistors (220 ohm), one red LED, and one photodiode which, by looking at the “getting started” tutorials on the Particle website allow users to get started prototyping with simple IoT circuits.
Particle boards are normally programmed “over the air” but the Particle Debugger (which was also included for the RoadTest) allows SWD programming/debugging with Visual Studio Code via a 10-pin debugging connector.
The Argon is a Wi-Fi and mesh device that can act as a standalone Wi-Fi endpoint or Wi-Fi gateway for a Particle Mesh network. In addition to the Nordic nRF52840, it has an Espressif ESP32- 2.4G Wi-Fi coprocessor, and built-in battery charging circuitry. This means that you can power it from the 5v micro USB socket and/or from a battery (e.g. LiPo) connected to the JST socket.
The ESP32-D0WD coprocessor has 4MB of on-board flash dedicated to the ESP32. This is a dual-core version of the ESP32 with more memory than its single-core variant.. The Argon has an onboard PCB antenna for mesh/Bluetooth and an external antenna (provided) for Wi-Fi.
The pinout diagram below is pretty much identical for each of the Mesh boards.
Although not included in the review bundle, the Boron is built around a u-blox cellular modem and can act as a standalone LTE/2G/3G endpoint or LTE/2G/3G gateway for a Particle Mesh network.
The Xenon is a low cost mesh-enabled development kit that can act as either an endpoint or repeater within a Particle Mesh network. It needs either an Argon or Boron to set it up on a Particle Mesh network and to connect it to the Internet. To build your mesh network, Particle intend that users buy multiple low-cost Xenons as endpoints connecting to either an Argon (Wi-Fi) or Boron (LTE) thread border router. In addition to the two Xenons provided as part of the Roadtest, I bought an additional Xenon to extend the range of my Thread network.
The Particle Device Cloud is where all your Particle devices are registered and managed. It provides a range of developer tools that allow you to monitor and manage your devices, including deploying code updates over the air (“OTA”).
All Particle customers get free access to the Particle Device Cloud networks using a Wi-Fi or Ethernet gateway for the first hundred devices. Beyond that, there is a scale of charges (starting at $0.39 per device per month) based on the number of devices deployed.
Thread is an IPv6-based networking protocol designed for low-power Internet of Things devices in an IEEE 802.15.4-2006 wireless mesh network, commonly called a Wireless Personal Area Network (WPAN). Thread is independent of other 802.15.4 mesh networking protocols, such as ZigBee, Z-Wave, and Bluetooth LE.
Thread's primary features include:
In addition to sending data to the cloud, Particle has provided functions (Mesh.publish() and Mesh.subscribe()) that allow you to send and receive messages within a Particle Mesh network. These messages will not reach the cloud. Each device can publish messages to the rest of the mesh, and each device can subscribe to messages from other devices – this is called a pub/sub architecture. To send data to the cloud, you can use the Particle.publish() function.
The Grove system is a modular, standardised connector prototyping system. By using pre-wired connectors and sockets, it ensures secure connections and removes the uncertainty of the “which pin goes where” that you get when using separate jumper wires. Seeed Studios provide excellent documentation for the Grove system on this “Wiki”. The Grove system consists of a huge range of sensors, actuators (e.g. motors), displays and communication devices that connect (normally via a “Shield”) to microcontroller boards such as Arduino, Beaglebone and Raspberry Pi (and, now, the Particle Mesh boards). I reviewed the Grove system as part of a previous RoadTest .
The Grove Starter Kit for Particle Mesh comprises a Grove shield, into which you can plug any of the Particle Mesh devices and includes:
• 1x Button
• 1x Rotary Angle Sensor
• 1x Ultrasonic Ranger
• 1x Temperature &Humidity Sensor
• 1x Light Sensor v1.2
• 1x Chainable RGB LED
• 1x Buzzer
• 1x 4-Digit Display
The Particle Mesh Wi-Fi Bundle and Grove Starter Kit for Particle Mesh is a rapid prototyping system for IoT applications. Just using the kit provided, you could (for example) set up a remote monitoring system that measures the local temperature, humidity and light level and makes the sensor readings available over the Internet. By purchasing additional components, the scope for such a system could be easily and quickly expanded. For example, additional Xenons and temperature/humidity sensors could be added for little extra cost so that several rooms in the same house could be monitored. You could, equally well, use the system to control devices (e.g. relays) remotely.
As well as the Grove system there are several other ways of connecting components to the Particle boards, which completely opens up the range of devices that you can connect and the potential use cases.
There is a huge amount of documentation available on the Particle website and it is a bit overwhelming at first when you realise how many ways there are to program and monitor these devices. Because of this, it can be hard to find what you are looking for, and some of the documentation and examples are for other devices in the Particle range – particularly the Photon. Having said that, most of the documentation is excellent.
The Particle Mesh kit has clearly been designed with security in mind. OpenThread provides built-in security where devices cannot join the network unless authorised. All communications are encrypted and secure by default. On top of that, Particle Mesh adds an application layer with additional security. You can optionally add two-factor authentication for logging in to the Particle Device Cloud.
The process for setting up your kit is well-documented and straightforward so I won’t repeat that here, but the essentials are:
Users need to understand the difference between what Particle call “device firmware” (i.e. the code that you write) and the “Device OS” (which what allows the devices to communicate with each other and to be programmed). This can be a bit confusing at first because Particle themselves used to refer to Device OS as "firmware" and there is still some old documentation around that uses the old terminology. All new devices come pre-installed with a reasonably recent version of the Particle device OS installed, and “Tinker” (a Particle app (user firmware) that allows you to test your setup using the Particle app on your phone or tablet).
I did experience some problems setting up the network:
I tested the range of the mesh network with two, three and four devices. With two devices (one Argon and one Xenon), I could only achieve a range of around 15 metres with line of sight. By “chaining them together”, I could achieve a range of around 45 metres from the Argon to the furthest endpoint Xenon in a straight line of sight arrangement. I guess there is a balance to be struck between power utilisation and range. In practice, it would be a more typical arrangement to have one Argon acting as a border router and multiple Xenons acting as both endpoints and repeaters in different parts of a building.
There are three quick prototyping systems that you can use with the Particle Mesh system.
As mentioned above, each of the three Particle board kits comes with a USB cable, a breadboard, two resistors (220 ohm), one red LED, and one photodiode but the tutorial guide for getting started by flashing an LED shows breadboard jumper wires being used to connect the component. It's great that Particle include some components to get you started but this could be confusing to newcomers as no breadboard wires are included. In actual fact, you can follow the tutorials without them as per the photo below.
The great thing about providing a breadboard is that you can connect pretty much any components you like to the Mesh boards.
Even easier than the breadboard is the Grove shield. You just plug any of the Particle Mesh boards onto the shield and connect the Grove components to the appropriate Grove sockets.
In case you are wondering what a Grove "chainable RGB LED" looks like, here's a short video. It's basically a large RGB LED but it has an "in" as well as "out" connection so you can string several off the same Grove connection, each individually addressable. Except that you can't because there is only one in the kit!
The third way of connecting components makes use of the fact that the Particle Mesh boards are the same form factor as the Adafruit Feather boards. The FeatherWing Tripler provided for the RoadTest allows you to connect a Mesh board and one or two FeatherWing components side by side. The Tripler comes with three sets of female headers (unsoldered) and you can decide how many headers you need. You might, for example, solder one set of female headers for the Mesh board and use the two other areas on the board as a prototyping area. I decided to solder all the headers onto the board so I could mount an Adafruit Power Relay and an Adafruit FeatherWing OLED screen. This screen uses the popular SSD1306 display and also has three user-programmable buttons.
There are three main options for coding the Particle boards:
The easiest way is to use the Web IDE. The Particle Web IDE allows you to write code in the Wiring language (an extension of C++ on which the Arduino IDE is based) and flash it OTA to any of your devices. It also allows you to search for and include device drivers from literally hundreds of available libraries. Most of these have been ported from Arduino libraries. The Particle Web IDE also provides links to documentation and help as well as to the Particle Console which is where you configure and control your mesh networks and devices in real time (including integrations with other platforms such as Microsoft Azure). The following code uses the Mesh.publish() function to send the temperature as measured by the Grove Temperature & Humidity Sensor to the Particle Cloud (and view it in the Particle Console).
// This #include statement was automatically added by the Particle IDE.
#include <Grove_4Digit_Display.h>
// This #include statement was automatically added by the Particle IDE.
#include <Grove_Temperature_And_Humidity_Sensor.h>
#define CLK D2//pins definitions for TM1637 and can be changed to other ports
#define DIO D3
#define DHTPIN A2 // set pin
DHT dht(DHTPIN);
TM1637 tm1637(CLK,DIO);
void setup()
{
tm1637.init();
tm1637.set(BRIGHTEST);//BRIGHT_TYPICAL = 2,BRIGHT_DARKEST = 0,BRIGHTEST = 7;
tm1637.point(POINT_ON);
dht.begin();
}
void loop()
{
//Read Humidity
float h = dht.getHumidity();
// Read temperature as Celsius
float t = dht.getTempCelcius();
// Read temperature as Farenheit
float f = dht.getTempFarenheit();
// Check if any reads failed
if (isnan(h) || isnan(t) || isnan(f))
{
Serial.println("Failed to read from DHT11 sensor!");
return;
}
// Separate the temperature to individual numbers to be used on the display.
int int_number = t * 100.0; // Two digits after decimal are kept. Turn the number into integer
int digits[10]; //Just in case I have 8 digits before decimal
for (byte i=0; i<10; i++)
{
digits[i] = int_number % 10;
if (int_number == 0)
break;
int_number /= 10;
}
// display the numbers on the display
tm1637.display(0,digits[3]);
tm1637.display(1,digits[2]);
tm1637.display(2,digits[1]);
tm1637.display(3,digits[0]);
// Publish the temperature to the Cloud using Server Sent Events (SSE)
Particle.publish("tempC", String(t));
delay(1000);
}Here is the device output:
Here is the data coming through to the Particle Console:
Particle Workbench (an extension to the excellent Microsoft Visual Studio Code editor) can also be used to program the Argon locally using both the USB and the debugger connections. You can either install the whole thing from scratch, or (if you already use VS Code), you can add it as an extension.
I tried the Particle Workbench for a couple of projects but, to be honest, I found the Web IDE much easier to use. Particle Workbench has a tendency to update itself rather frequently (like other Microsoft products), which can get a bit tedious, whereas the Web IDE is always up to date.
Here is a project to measure distance with the Grove Ultrasonic Ranger and display the distance on the Grove 4x7 segment display. You can see on the left panel that it uses two Grove libraries.
Note: I did get a couple of Microsoft "Intellisense" errors (VS Code configuration) which I ignored. I also found the compilation/build process rather slow, which was a surprise as I expected that, if anything, the cloud compiler in the Web IDE would be slow but it was the other way round.
The Particle Debugger was included as part of the RoadTest. You do have to use VS Code / Particle Workbench if you want to use the debugger. Support for the debugger has only just been added to VS Code and it was initially hard to find any guidance on how to use it, but then I found this tutorial. Sadly, the instructions have been updated from a previous tutorial and don't quite correspond with the current version of VS Code. For example, "Particle: Configure Project for Device" is the correct command but the screenshot in the tutorial has not been updated and it says "Particle: Configure Workspace for Device".
I got stuck with this error:
I'm sure I will get it working eventually, but it was not a happy first experience.
You might think that you would need the debugger if you wanted to update the Device OS, but in fact you can update the OS either by flashing your own application code firmware or, if you want a specific version of Device OS, by using the Command Line Interface.
Unlike a lot of microcontroller boards that have an onboard debugger chip (such as the NXP FRDM boards), the Particle Debugger is very much an add-on and the user experience is not great. MCUXpresso, for example, has support for many different debugger chips fully integrated into the IDE and debugging is an integral part of the coding process. With the Particle Debugger, you need two USB connections to debug the code running on your device - one for the device and one for the debugger. Nevertheless, if you are writing complicated code, it is great that there is a debugger available (even if the process doesn't quite work properly yet).
The Particle Command Line Interface ("CLI") allows experienced users to interact with Particle devices via a Windows (or Linux/MacOS) terminal. In Windows, the CLI installer installs:
Running the CLI is as simple as opening up a Windows terminal and typing "particle" followed by the command you want to execute. Here is a list of all the commands you can use (click on the photo to enlarge it):
For example, to see what devices you have and which are online, you just type "particle list".
One of the most useful commands is "particle flash --USB [filename.bin]". I used this to choose which Device OS to run on my boards. There is a simpler command "particle update" which updates the Device OS to the latest released version, but if you want to choose a specific Device OS release, you can download it from Particle's Github and save it locally before flashing to the device via the USB connection. The Particle board must be put into "DFU" mode before you can write to its flash memory. This is achieved by pressing both buttons (see the pinout chart near the top of this review), then releasing the Reset button while holding the Setup/Mode button on the board and releasing it when the status LED starts blinking yellow.
Particle have developed their own "wrapper" for Node-Red and they call it the Particle IoT Rules Engine.
Unfortunately, it appears to be something you have to apply for to test and then it looks like a paid-for product. Consequently, I was unable to test it.
As well as (or instead of) sending your data to the Particle Cloud, you can integrate your device streams with a range of other IoT platforms. I tested the process with the Microsoft Azure IoT hub but the process would be similar for other platforms like Google Cloud services. Although it's not difficult, there are a lot of steps but these are quite well documented and you are guided through the process as you go. The slideshow below shows me going through the process. At the end of the process, you can open up the Particle Console and see your data being published and it will also appear in your Azure IoT hub.
| {gallery} Integrations |
|---|
|
 |
 |
 |
 |
 |
 |
 |
 |
 |
 |
 |
 |
 |
 |
 |
 |
 |
 |
 |
 |
Once you have done this (i.e. set up the integration), you can send data to the Azure IoT hub. This is how my Azure integration is configured (note that I called my Event Name "azure-publish"):
Taking the above example of publishing temperature data to the Particle Console, all you need to do is change one line.
Change:
Particle.publish("tempC", String(t));
to:
Particle.publish("azure-publish", String(t));
... and you are done!
A possible "use case" for the Particle Mesh kit would be a mesh of connected sensors around the house and garden. The Argon would sit near the WiFi router and act as the "gateway" for the mesh network. As a test of how the mesh works in practice, I decided to dip a waterproof DS18B20 digital temperature sensor (attached to a Xenon) into my fish tank, which is situated at the end of my garden, behind my garage. There are several solid walls between there and the Argon and, not surprisingly, the mesh connection from the fish tank was lost. However, by adding two more Xenons in between, the connection was restored and I was able to read the fishtank water temperature via the Particle Console in my sitting room (or anywhere in the world!).
I was interested in testing the battery life of the Xenon-based temperature sensor. Connected to a miniature 350mAh LiPo battery and sending temperature readings every thirty seconds, it kept running for several hours over thirty hours. You can buy LiPo batteries with much greater capacity (2000mAh would keep you running for over a week), or you can permanently power the Mesh devices from a 5v USB source.
This RoadTest took me a long time to complete, not just because of the early difficulties getting the mesh network up and running but mostly because there are so many ways in which you can program and manage your mesh network and devices.
The Particle Web IDE is probably the most impressive development environment that I have ever used. It combines ease of use with an absolutely huge collection of device libraries, most of which also provide example code. You can attach a device to one of the Mesh boards and have it up and running in five minutes. Another impressive feature is that most of the code is interchangeable between the different Particle Mesh boards. Visual Studio Code is also a great IDE and a lot of people who already use VS Code will be happy that there is a Particle extension for it.
The connectivity options are impressive - the Grove system works really well for quick experiments and the FeatherWing system allows you to connect many Adafruit Feather components but you can also use it as a protoboard and solder your own components to it.
I have previously set up my own Thread mesh network using a pair NXP FRDM KW41Z boards. The amount of coding needed to do that is quite considerable. In contrast, using the Particle Mesh network means that all the hard work has been done for you. Thread mesh works really well if you have a lot of devices in a small space and you want to keep the power demands low. Using several Particle Mesh devices together meant that I could put sensors in places where I have no WiFi signal.
The integration options are good - I had no trouble setting up a Microsoft Azure IoT hub and streaming data to it from the Particle Mesh network.
My initial problems were frustrating, and it took Particle Support quite a while to engage with me, but once they got involved, they were on the case until it was solved. The only other issue I had was that some of the huge amount of support documentation was a bit out of date as terminology has changed.
I look forward to using this kit a lot in the future as I have barely scratched the surface of what it can do. Thoroughly recommended!
Top Comments
That's a shame. I think the mesh is what set the Particle boards apart in the crowded field of IoT hardware vendors. Their explanation at the link Clem provided explains why it's not right for them…
It just bubbled up in my inbox... LOL
stevesmythe Sad to report the future for mesh will be murky at best https://blog.particle.io/2020/01/28/mesh-deprecation/ Comments?