Skip navigation
> RoadTest Reviews

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

Scoring

Product Performed to Expectations: 9
Specifications were sufficient to design with: 10
Demo Software was of good quality: 10
Product was easy to use: 10
Support materials were available: 10
The price to performance ratio was good: 10
TotalScore: 59 / 60
  • RoadTest: Particle Mesh Wi-Fi Bundle + Grove Sensor Kit
  • Buy Now
  • Evaluation Type: Development Boards & Tools
  • Was everything in the box required?: Yes
  • Comparable Products/Other parts you considered: 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

    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:

    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:

    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.

     

    I am skipping the setup of devices as it is mentioned in detail in the Particle website:

    Argon: https://docs.particle.io/quickstart/argon/

    Xenon: https://docs.particle.io/quickstart/xenon/

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

     

    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 convenient 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. 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.

    Testing

     

    /*
     * 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();
        tm1637.set(); 
        tm1637.init();
        tm1637.set(BRIGHT_TYPICAL);
        tm1637.point(POINT_ON);
    }
    void loop()
    {
        TimeNow = millis();
        if (TimeNow > TimeRef + 500)        
        {    
           TimeRef = millis();
           send_online();
        }
        
        get_Wh();
        check_usage();
        
        Particle.variable("Wh", &Wh, DOUBLE);
        Particle.variable("Bill_amount", &bill_amount, DOUBLE);
        Particle.function("Relay_power",ToggleRelay);
        
        dispNum(Wh);
        delay(200);
    }
    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;
        tm1637.display(TimeDisp);
    }
    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);
            delay(2);
          }
    
    
          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)
        {
            digitalWrite(relay_pin,LOW);
        }
    }
    int ToggleRelay(String command)
    {
        if (command=="on") {
            digitalWrite(relay_pin,HIGH);
            return 1;
        }
        else if (command=="off") {
            digitalWrite(relay_pin,LOW);
            return 0;
        }
        else {
            return -1;
        }
    }
    

     

     

    Verdict

    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.


Comments

Also Enrolling

Enrollment Closes: Sep 20 
Enroll
Enrollment Closes: Oct 1 
Enroll
Enrollment Closes: Oct 10 
Enroll
Enrollment Closes: Oct 4 
Enroll