Particle Mesh Wi-Fi Bundle + Grove Sensor Kit - Review

Table of contents

RoadTest: Particle Mesh Wi-Fi Bundle + Grove Sensor Kit

Author: crisdeodates

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?: Arduino MKR Series, NodeMCU

What were the biggest problems encountered?: Connectivity issues to the network. Sometimes the Particle devices failed to connect to the cloud on rare occasions.

Detailed Review:

Background for the Review


I wanted to take part in this road test because I wanted to tinker with Particle Mesh. Of all the embedded systems that I have worked with, Particle mesh seemed to be different because of the fact that the item is so scalable, yet powerful to even be incorporated in commercial applications. I also wanted to understand their applications, limitations, and possibilities of integrating into an existing project.


Introduction and Unboxing


What is Particle


  • Particle is an open-source hardware/software platform for the Internet of Things
  • Lets you build internet-connected hardware and gives you the tools to connect everyday electronics to the internet.


The Particle Mesh and Grove sensor bundle were received in a very safe and enclosed package.


The items received were:

  • Argon Kit
  • 2 Xenon Kits
  • Particle FeatherWing Tripler
  • Particle Debugger
  • Grove Shield for Particle Mesh
  • Button
  • Rotary angle sensor
  • Ultrasonic ranger
  • Temperature and humidity sensor
  • Light sensor
  • Chainable RGB LED
  • Buzzer
  • 4-Digit display


Notable Specifications


Particle Argon:


The Argon is a powerful Wi-Fi enabled development kit that can act as either a standalone Wi-Fi endpoint or Wi-Fi enabled gateway for Particle Mesh networks. It is based on the Nordic nRF52840 and has built-in battery charging circuitry so it’s easy to connect a Li-Po and deploy your local network in minutes. The Argon is great for connecting existing projects to the Particle Device Cloud or as a gateway to connect an entire group of local endpoints.

  • Particle's third-generation boards with Wi-Fi + Mesh Gateway/Repeater + BLE
  • Main processor: Nordic Semiconductor nRF52840 SoC with ARM Cortex-M4F 32-bit processor @ 64MHz
  • 1MB flash
  • 256KB RAM
  • Bluetooth 5
  • 20 mixed signal GPIO (6 x Analog, 8 x PWM)
  • UART, I2C, SPI
  • Supports DSP instructions
  • HW accelerated Floating Point Unit (FPU) calculations
  • ARM TrustZone CryptoCell-310 Cryptographic and security module
  • Up to +8 dBm TX power (down to -20 dBm in 4 dB steps)
  • NFC-A radio
  • Espressif ESP32-D0WD 2.4 GHz Wi-Fi co-processor
  • Onboard 4MB flash for the ESP32
  • 802.11 b/g/n support and 802.11 n (2.4 GHz).


Particle Xenon:


The Xenon is a low-cost mesh-enabled development kit that can act as either an endpoint or repeater within a Particle Mesh network. Xenon is mesh-only and designed to function as the endpoint of your IoT network. It is based on the Nordic nRF52840 and has built-in battery charging circuitry so it’s easy to connect a Li-Po and deploy your local network in minutes. The Xenon is best for connecting sensors, motors, pumps, valves, and points of data-interest. Pair it with an Argon or Boron gateway to get all that great data into the Device Cloud.

  • Particle's third-generation boards with Mesh + BLE
  • Nordic Semiconductor nRF52840 SoC with ARM Cortex-M4F 32-bit processor @ 64MHz
  • 1MB flash
  • 256KB RAM
  • Bluetooth 5
  • 20 mixed signal GPIO (6 x Analog, 8 x PWM)
  • UART, I2C, SPI
  • Supports DSP instructions
  • HW accelerated Floating Point Unit (FPU) calculations
  • ARM TrustZone CryptoCell-310 Cryptographic and security module
  • Up to +8 dBm TX power (down to -20 dBm in 4 dB steps)
  • NFC-A radio.


Both devices have Micro USB 2.0, Integrated Li-Po charging and battery connector, JTAG (SWD) Connector, RGB status LED, Reset and Mode buttons.


Project Workflow


Presently, electrical energy consumption from users in an area is monitored and calculated by frequent field visits done by technicians from the electricity department for the calculation of energy fare. This is a time-consuming task as there will be thousands of houses in an area and numerous apartments in the same flats. When it comes to a city or town, this is a very hectic process. There is no provision to check or analyze the individual energy consumption of houses in a period of time nor to create a report of energy flow in a certain area. This is just the case throughout many places in the world. There are no existing solutions implemented to tackle the above problem. We are proposing a smart energy monitoring system that will ease the inspection, monitoring, analysis, and calculation of energy fare. The proposed system will additionally allow generating user-specific or area-specific charts and reports to analyze the energy consumption and energy flow.


Particle Mesh devices create local wireless mesh networks that other devices can join. They help collect sensor data, exchange local messages, and share their connection to the cloud. In summary, you can create local networks using the Argon or Boron boards that act as gateways for the cloud. Xenon devices can be used as mesh endpoints or repeaters for range extension.




  • Particle provides an app for both Android and iOS that allows users to see their devices and interact with them.
  • Start by scanning the QR code on the top of the Argon's RF shield.
  • Run the firmware update.
  • Set up Argon as a mesh gateway in a WiFi network.
  • Set up each Xenon by scanning the QR code and connecting it to the mesh network created earlier.
  • Go to Particle Cloud console to monitor the devices.





The detailed setup of devices as it is mentioned in detail in the Particle website:




I followed the exact same steps.


TIP Just remember to put Argon in listening mode (press Mode button for 3 seconds) before pairing Xenon to Argon with the mobile app.



Development and Deployment


  • Particle IDE lets software development in an easy-to-use application which runs from your web browser.
  • Development can also be done using Particle workbench which can be integrated into VS Code.
  • Particle CLI is a powerful command-line tool for interacting with your devices and the Particle Device Cloud. The CLI uses Node.js and can easily run on all popular platforms.image




The Particle Argon module and the Xenon are given a unique user code to identify the particular housing unit or area where the energy consumption has to be measured. The power consumption will be monitored by these modules with the help of a grove current sensor interfaced using the analog connection.


The energy consumption data, the unique user code and the location (fixed for each device) of the module will be uploaded to this Mesh/Cloud network periodically. A wireless mesh network is an infrastructure of nodes (a mesh topology) that are wirelessly connected to each other. These nodes piggyback off each other to extend a radio signal (like a Wi-Fi or cellular connection) to route, relay, and proxy traffic to/from clients. Each node spreads the radio signal a little further than the last, minimizing the possibility of dead zones. The data from the mesh can be accessed and analyzed to calculate individual energy consumption, generate individual and collective energy charts, generate energy reports and for detailed energy inspection.


The whole area under consideration will be divided into cell blocks inside the mesh network for easy management of data as shown below. The blocks are chosen in such a way that the Particle device present in that block will be able to cover the whole block and each block will try to accommodate at least one Particle device to have larger coverage of the operation.


This solution also employs a tamper-proof activation/deactivation service for the utilities through the Argon module. These are used by the municipality/authorized personnel to activate/deactivate the electricity distribution box in case the previous dues were unpaid for a long period or because of a report regarding any illegal usage of the utility. The client will also be able to activate/deactivate certain appliances (once they are connected to the Argon module via relay) if the Energy consumption goes beyond a threshold limit.


Power from the AC mains is drawn and passed through the current sensor which is integrated into the household circuit. The AC current passing through the load is sensed by the grove current sensor module and the output data from the sensor is fed to the analog pin of the Argon module. Once the analog input is received, the measurement of power/energy is inside the program. The calculated energy is then published to the mesh network. The information is also displayed on the display module. Separate relays are provided for each house which is controlled from the Energy house.


All connections are standard Grove connections with individual layout as follows:

Current Sensor => A0

Relay Module => D4

Display Unit => D2, D3




The Particle dashboard is updated with live energy usage statistics.


The dashboard also contains the web element for controlling the relay modules remotely.




 * Project SEUMS
 * Description: Smart Energy and Utility Monitoring System
 * Authors: Cris Thomas, Jiss Joseph Thomas
 * Date: June 24, 2019

#include "TM1637.h"
#define CLK D2
#define DIO D3

TM1637 tm1637(CLK,DIO);

void dispNum(unsigned int num);
void send_online();
void get_Wh();
void check_usage();

long int TimeRef = 0;
long int TimeNow = 0;
bool send_data = false;

const int relay_pin = D4;
const int current_pin = A0;
const int house_id = 1;
const int averageValue = 10;
const double Wh_threshold = 900;

int sensorValue = 0;
int RefVal = 20;
float sensitivity = 1000.0 / 800.0;
float Vref = 265;
float Vpp = 0;                          // peak-peak voltage 
float Vrms = 0;                         // rms voltage
float Irms = 0;                         // rms current
float Supply_Voltage = 233.0;           // reading from DMM
float Vcc = 5.0;                        // ADC reference voltage
float power = 0;                        // power in watt              
float Wh =0 ;                           // Energy in kWh

unsigned long last_time =0;
unsigned long current_time =0;
unsigned long interval = 100;
unsigned int Sensitivity = 185;
unsigned int calibration = 100;  
unsigned int pF = 85;          
unsigned int energyTariff = 8.0;        // dummy value for testing

float bill_amount = 0;                  

void setup()
    TimeRef = millis();
void loop()
    TimeNow = millis();
    if (TimeNow > TimeRef + 500)        
       TimeRef = millis();
    Particle.variable("Wh", &Wh, DOUBLE);
    Particle.variable("Bill_amount", &bill_amount, DOUBLE);
void dispNum(unsigned int num)
    int8_t TimeDisp[] = {0x01,0x02,0x03,0x04}; 

    if(num > 9999) num = 9999;
    TimeDisp[0] = num / 1000;
    TimeDisp[1] = num % 1000 / 100;
    TimeDisp[2] = num % 100 / 10;
    TimeDisp[3] = num % 10;
void send_online()
    Particle.publish("House ID", String(house_id));
    Particle.publish("Usage (Wh)", String(Wh));
    Particle.publish("Amount", String(bill_amount));
    String out = String::format("{\"Wh\":%.2f,\"BillAmount\":%.2f,}",Wh,bill_amount);
    Particle.publish("JSON", out , PRIVATE, WITH_ACK);
void get_Wh()
    for (int i = 0; i < averageValue; i++)
        sensorValue += analogRead(current_pin);

      sensorValue = sensorValue / averageValue;
      float unitValue= RefVal / 1024.0*1000 ;
      float voltage = unitValue * sensorValue-Vref;
      float current = (voltage - Vref) * sensitivity;
      Vpp = voltage;
      Vrms = (Vpp/2.0) *0.707; 
      Vrms = Vrms - (calibration / 10000.0);
      Irms = (Vrms * 1000)/Sensitivity ;
      if((Irms > -0.015) && (Irms < 0.008))
        Irms = 0.0;
      power= (Supply_Voltage * Irms) * (pF / 100.0); 
      last_time = current_time;
      current_time = millis();    
      Wh = Wh+  power *(( current_time -last_time) /3600000.0) ;
      bill_amount = Wh * (energyTariff/1000);
void check_usage()
    if(Wh > Wh_threshold)
int ToggleRelay(String command)
    if (command=="on") {
        return 1;
    else if (command=="off") {
        return 0;
    else {
        return -1;


This video is unavailable.




From the brief experience with Particle Mesh platform, this is a great platform to implement IoT services at a scalable, low power and economical level. Apart from the issues that may arise during flashing and connecting to the cloud, Particle is one of the best of elements that are considered for IoT applications.


Future Plans


This project was just the beginning of various projects that will be implemented using Particle hardware. As I implement more, this review will be updated with new results.