Skip to content

Instantly share code, notes, and snippets.

@technobly

technobly/electron-low-power-sensor.cpp

Last active May 11, 2018 02:37
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save technobly/bc42ae5913d8d89187f6633a91391bf0 to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save technobly/bc42ae5913d8d89187f6633a91391bf0 to your computer and use it in GitHub Desktop.
Download ZIP

Revisions

  1. technobly revised this gist Dec 29, 2016. 1 changed file with 2 additions and 0 deletions.
    2 changes: 2 additions & 0 deletions electron-low-power-sensor.cpp
    View file
    Original file line number Diff line number Diff line change
    @@ -34,6 +34,8 @@ retained int sensor_index = 0;
    STARTUP(System.enableFeature(FEATURE_RETAINED_MEMORY));

    void read_and_save_sensor() {
    FuelGauge().quickStart();
    delay(200);
    // These readings can be whatever you like, for example we are using PMIC SoC (%)
    sensor_readings[sensor_index++] = FuelGauge().getSoC();
    }
  2. technobly created this gist Dec 28, 2016.
    89 changes: 89 additions & 0 deletions electron-low-power-sensor.cpp
    View file
    Original file line number Diff line number Diff line change
    @@ -0,0 +1,89 @@
    /*
    ******************************************************************************
    * Copyright (c) 2016 Particle Industries, Inc. All rights reserved.
    *
    * This library is free software; you can redistribute it and/or
    * modify it under the terms of the GNU Lesser General Public
    * License as published by the Free Software Foundation, either
    * version 3 of the License, or (at your option) any later version.
    *
    * This library is distributed in the hope that it will be useful,
    * but WITHOUT ANY WARRANTY; without even the implied warranty of
    * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
    * Lesser General Public License for more details.
    *
    * You should have received a copy of the GNU Lesser General Public
    * License along with this library; if not, see <http://www.gnu.org/licenses/>.
    ******************************************************************************
    */

    #include "Particle.h"

    // Use either MANUAL or SEMI_AUTOMATIC mode to keep the cellular modem off initially on boot
    SYSTEM_MODE(MANUAL);
    // SYSTEM_MODE(SEMI_AUTOMATIC);

    // Time between sensor readings in seconds
    #define SENSOR_READING_INTERVAL 60*60
    // We will publish the entire array when it's full
    #define SENSOR_ARRAY_SIZE 24
    // If we lose power completely, expect these to reinitialize.
    retained float sensor_readings[SENSOR_ARRAY_SIZE] = {0.0};
    retained int sensor_index = 0;

    STARTUP(System.enableFeature(FEATURE_RETAINED_MEMORY));

    void read_and_save_sensor() {
    // These readings can be whatever you like, for example we are using PMIC SoC (%)
    sensor_readings[sensor_index++] = FuelGauge().getSoC();
    }

    void publish_sensor_readings() {
    String results = "";
    int i = 0;
    for (; i < SENSOR_ARRAY_SIZE-1; i++) {
    results += String::format("%.2f", sensor_readings[i]) + String(",");
    }
    results += String::format("%.2f", sensor_readings[i]);
    Particle.publish("sensor_readings", results);
    // Reset sensor_readings
    memset(sensor_readings, 0, sizeof(sensor_readings));
    sensor_index = 0;
    delay(5000); // should not need this after 0.6.1 is released, ensures publish goes out before we sleep
    }

    void is_time_to_publish() {
    if (sensor_index >= SENSOR_ARRAY_SIZE) {
    Particle.connect();
    waitFor(Particle.connected, 300000); // this won't be necessary when 0.6.1 is released
    if (Particle.connected()) {
    publish_sensor_readings();
    }
    }
    }

    void setup()
    {
    // Wake from deep sleep with power to cellular modem off.
    // Read sensor, store results to a retained array.
    read_and_save_sensor();

    // Is it time to publish our results?
    // Turn on cellular modem and publish.
    is_time_to_publish();

    // Go back to deep sleep for ~1 hour (sleep time varies based on how long we were
    // awake for to keep time between readings close to 1 hour, improve with Time class).
    // NOTE: this following command does not work in multithreaded mode yet,
    // but we don't need multithreading for this simple example
    if (SENSOR_READING_INTERVAL > (millis()/1000)) {
    System.sleep(SLEEP_MODE_SOFTPOWEROFF, SENSOR_READING_INTERVAL-(millis()/1000));
    } else {
    System.sleep(SLEEP_MODE_SOFTPOWEROFF, SENSOR_READING_INTERVAL);
    }
    }

    void loop()
    {
    Particle.process(); // only required when using MANUAL mode and if we ever use loop()
    }