Current version from old git. Release 0.0.9

.gitignore

+.pioenvs
+.pio/libdeps
+.pio/build
+.vscode
+*.ino.cpp
+config.h
+config.hftstuttgart.h
+.project
+.cproject
+.settings

Ampel.h

+#ifndef AMPEL_H_INCLUDED
+#define AMPEL_H_INCLUDED
+/*****************************************************************
+ * Libraries                                                     *
+ *****************************************************************/
+#include "config.h"
+#ifndef MEASUREMENT_TIMESTEP
+#  error Missing config.h file. Please copy config.example.h to config.h.
+#endif
+#ifdef MQTT
+#  include "mqtt.h"
+#endif
+
+#include "util.h"
+#include "wifi_util.h"
+#include "co2_sensor.h"
+
+#ifdef HTTP
+#  include "web_server.h"
+#endif
+
+#include "led_effects.h"
+#include "csv_writer.h"
+
+#if defined(ESP8266)
+//allows sensor to be seen as SENSOR_ID.local, from the local network. For example : espd05cc9.local
+#  include <ESP8266mDNS.h>
+#elif defined(ESP32)
+#  include <ESPmDNS.h>
+#endif
+
+void keepServicesAlive();
+void checkFlashButton();
+
+#endif

Ampel.ino

+/***
+ *       ____ ___ ____       _                         _
+ *      / ___/ _ \___ \     / \   _ __ ___  _ __   ___| |
+ *     | |  | | | |__) |   / _ \ | '_ ` _ \| '_ \ / _ \ |
+ *     | |__| |_| / __/   / ___ \| | | | | | |_) |  __/ |
+ *      \____\___/_____| /_/__ \_\_| |_| |_| .__/ \___|_|         _
+ *     | | | |/ _|_   _| / ___|| |_ _   _| |_| |_ __ _  __ _ _ __| |_
+ *     | |_| | |_  | |   \___ \| __| | | | __| __/ _` |/ _` | '__| __|
+ *     |  _  |  _| | |    ___) | |_| |_| | |_| || (_| | (_| | |  | |_
+ *     |_| |_|_|   |_|   |____/ \__|\__,_|\__|\__\__, |\__,_|_|   \__|
+ *                                               |___/
+ */
+
+#include "Ampel.h"
+
+/*****************************************************************
+ * GPL License                                                   *
+ *****************************************************************/
+/*
+ * This file is part of the "CO2 Ampel" project (https://gitlab.rz.hft-stuttgart.de/otto/hft-stuttgart_co2_ampel)
+ * Copyright (c) 2020 HfT Stuttgart.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, version 3.
+ *
+ * This program 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
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*****************************************************************
+ * Authors                                                       *
+ *****************************************************************/
+/*
+ * Eric Duminil
+ * Robert Otto
+ * Myriam Guedey
+ * Tobias Gabriel Erhart
+ * Jonas Stave
+ */
+
+/*****************************************************************
+ * Configuration                                                 *
+ *****************************************************************/
+/*
+ * Please define settings in 'config.h'.
+ * There's an example config file called 'config.example.h'.
+ * You can copy 'config.public.h' (stored in Git) to 'config.h' (not stored in Git),
+ * and define your credentials and parameters in 'config.h'.
+ */
+
+/*****************************************************************
+ * Setup                                                         *
+ *****************************************************************/
+void setup() {
+  LedEffects::setupOnBoardLED();
+  LedEffects::onBoardLEDOff();
+
+  Serial.begin(BAUDS);
+
+  pinMode(0, INPUT);  // Flash button (used for forced calibration)
+
+  LedEffects::setupRing();
+
+  sensor::initialize();
+
+  Serial.print(F("Sensor ID: "));
+  Serial.println(SENSOR_ID);
+  Serial.print(F("Board    : "));
+  Serial.println(BOARD);
+
+  // Try to connect to Wi-Fi
+  WiFiConnect(SENSOR_ID);
+
+  Serial.print(F("WiFi STATUS: "));
+  Serial.println(WiFi.status());
+
+  if (WiFi.status() == WL_CONNECTED) {
+#ifdef HTTP
+    web_server::initialize();
+#endif
+
+    ntp::initialize();
+
+    if (MDNS.begin(SENSOR_ID.c_str())) { // Start the mDNS responder for SENSOR_ID.local
+      MDNS.addService("http", "tcp", 80);
+      Serial.println(F("mDNS responder started"));
+    } else {
+      Serial.println(F("Error setting up MDNS responder!"));
+    }
+
+#ifdef MQTT
+    mqtt::initialize("CO2sensors/" + SENSOR_ID);
+#endif
+  }
+  csv_writer::initialize();
+}
+
+/*****************************************************************
+ * Main loop                                                     *
+ *****************************************************************/
+
+void loop() {
+  //NOTE: Loop should never take more than 1000ms. Split in smaller methods and logic if needed.
+  //TODO: Restart every day or week, in order to not let t0 overflow?
+  uint32_t t0 = millis();
+
+  /**
+   * USER INTERACTION
+   */
+  keepServicesAlive();
+  // Short press for night mode, Long press for calibration.
+  checkFlashButton();
+
+  /**
+   * GET DATA
+   */
+  bool freshData = sensor::scd30.dataAvailable(); // Alternative : close to time-step AND dataAvailable, to avoid asking the sensor too often.
+
+  if (freshData) {
+    sensor::co2 = sensor::scd30.getCO2();
+    sensor::temperature = sensor::scd30.getTemperature();
+    sensor::humidity = sensor::scd30.getHumidity();
+  }
+
+  //NOTE: Data is available, but it's sometimes erroneous: the sensor outputs zero ppm but non-zero temperature and non-zero humidity.
+  if (sensor::co2 <= 0) {
+    // No measurement yet. Waiting.
+    LedEffects::showWaitingLED(color::blue);
+    return;
+  }
+
+  /**
+   * Fresh data. Show it and send it if needed.
+   */
+
+  if (freshData) {
+    sensor::timestamp = ntp::getLocalTime();
+    Serial.println(sensor::timestamp);
+
+    Serial.print(F("co2(ppm): "));
+    Serial.print(sensor::co2);
+    Serial.print(F(" temp(C): "));
+    Serial.print(sensor::temperature);
+    Serial.print(F(" humidity(%): "));
+    Serial.println(sensor::humidity);
+
+    csv_writer::logIfTimeHasCome(sensor::timestamp, sensor::co2, sensor::temperature, sensor::humidity);
+
+#ifdef MQTT
+    mqtt::publishIfTimeHasCome(sensor::timestamp, sensor::co2, sensor::temperature, sensor::humidity);
+#endif
+  }
+
+  if (sensor::co2 < 250) {
+    // Sensor should be calibrated.
+    LedEffects::showWaitingLED(color::magenta);
+    return;
+  }
+
+  /**
+   * Display data, even if it's "old" (with breathing).
+   * Those effects include a short delay.
+   */
+
+  if (sensor::co2 < 2000) {
+    LedEffects::displayCO2color(sensor::co2);
+    LedEffects::breathe(sensor::co2);
+  } else {  // >= 2000: entire ring blinks red
+    LedEffects::redAlert();
+  }
+
+  uint32_t duration = millis() - t0;
+  if (duration > max_loop_duration) {
+    max_loop_duration = duration;
+    Serial.print("Max loop duration : ");
+    Serial.print(max_loop_duration);
+    Serial.println(" ms.");
+  }
+}
+
+/**
+ * Checks if flash button has been pressed:
+ *   If not, do nothing.
+ *   If short press, toggle LED display.
+ *   If long press, start calibration process.
+ */
+void checkFlashButton() {
+  if (!digitalRead(0)) { // Button has been pressed
+    LedEffects::onBoardLEDOn();
+    delay(300);
+    if (digitalRead(0)) {
+      Serial.println(F("Flash has been pressed for a short time. Should toggle night mode."));
+      LedEffects::toggleNightMode();
+    } else {
+      Serial.println(F("Flash has been pressed for a long time. Keep it pressed for calibration."));
+      if (LedEffects::countdownToZero() < 0) {
+        sensor::startCalibrationProcess();
+      }
+    }
+    LedEffects::onBoardLEDOff();
+  }
+}
+
+void keepServicesAlive() {
+  if (WiFi.status() == WL_CONNECTED) {
+#if defined(ESP8266)
+    //NOTE: Sadly, there seems to be a bug in the current MDNS implementation.
+    // It stops working after 2 minutes. And forcing a restart leads to a memory leak.
+    MDNS.update();
+#endif
+    ntp::update(); // NTP client has its own timer. It will connect to NTP server every 60s.
+#ifdef HTTP
+    web_server::update();
+#endif
+#ifdef MQTT
+    mqtt::keepConnection(); // MQTT client has its own timer. It will keep alive every 15s.
+#endif
+  }
+}

Makefile

+all:
+	pio -f -c vim run
+
+upload:
+	pio -f -c vim run --target upload -e $(board)
+
+clean:
+	pio -f -c vim run --target clean
+
+program:
+	pio -f -c vim run --target program
+
+uploadfs:
+	pio -f -c vim run --target uploadfs
+
+update:
+	pio -f -c vim update
+
+monitor:
+	pio device monitor --filter colorize

README.md

+# CO<sub>2</sub> Ampel
+
+*CO<sub>2</sub> Ampel* is an open-source project, written in C++ for ESP8266 or ESP32.
+
+It measures the current CO<sub>2</sub> concentration (in ppm), and displays it on an LED ring.
+
+The room should be ventilated as soon as one LED turns red.
+
+## Hardware Requirements
+
+* [ESP8266](https://en.wikipedia.org/wiki/ESP8266) or [ESP32](https://en.wikipedia.org/wiki/ESP32) microcontroller (this project has been tested with *ESP8266 ESP-12 WIFI* and *TTGO ESP32 SX1276 LoRa*)
+* [Sensirion SCD30](https://www.sensirion.com/en/environmental-sensors/carbon-dioxide-sensors/carbon-dioxide-sensors-co2/) "Sensor Module for HVAC and Indoor Air Quality Applications"
+* [NeoPixel Ring - 12](https://www.adafruit.com/product/1643)
+
+## Software Requirements
+
+* [PlatformIO](https://platformio.org/)
+or
+* [Arduino IDE](https://www.arduino.cc/en/software)
+
+## Installation
+
+* If `config.h` does not exist, copy it from `config.public.h`
+* Modify `config.h`, e.g. for measurement time-steps, WiFi access, MQTT, NTP and web-server.
+
+### PlatformIO
+
+PlatformIO can be run from [VSCODE](https://platformio.org/install/ide?install=vscode), [Eclipse CDT](https://www.eclipse.org/cdt/) or console:
+
+```bash
+make upload board=esp8266 && make monitor # For ESP8266
+```
+```bash
+make upload board=esp32 && make monitor # For ESP32
+```
+
+### Arduino IDE
+
+* All the libraries are included in this repository. No need to install anything via *Library Manager*.
+
+* Add your board to the [board manager](https://github.com/esp8266/Arduino#installing-with-boards-manager). Either ESP8266:
+
+        http://arduino.esp8266.com/stable/package_esp8266com_index.json
+
+  or ESP32:
+
+        https://dl.espressif.com/dl/package_esp32_index.json
+
+* Choose the correct board in *Tools > Board > ...*
+* Choose the correct *Flash size* (e.g. "Flash Size : 4MB (1MB FS, OTA:~1019kB)" for *ESP8266 ESP-12 WIFI*)
+
+* *Verify*
+* *Upload*
+* *Tools > Serial Monitor*
+
+## Authors
+
+ * Eric Duminil
+ * Robert Otto
+ * Myriam Guedey
+ * Tobias Gabriel Erhart
+ * Jonas Stave
+
+Hochschule für Technik Stuttgart
+
+## Contributing
+Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.
+
+## License
+
+Copyright © 2020, [HfT Stuttgart](https://www.hft-stuttgart.de/)
+
+[GPLv3](https://choosealicense.com/licenses/gpl-3.0/)

co2_sensor.cpp

+#include "co2_sensor.h"
+
+namespace config {
+  // Values should be defined in config.h
+  uint16_t measurement_timestep = MEASUREMENT_TIMESTEP;  // [s] Value between 2 and 1800 (range for SCD30 sensor)
+  const uint16_t altitude_above_sea_level = ALTITUDE_ABOVE_SEA_LEVEL;  // [m]
+  uint16_t co2_calibration_level = ATMOSPHERIC_CO2_CONCENTRATION;  // [ppm]
+#ifdef TEMPERATURE_OFFSET
+  // Residual heat from CO2 sensor seems to be high enough to change the temperature reading. How much should it be offset?
+  // NOTE: Sign isn't relevant. The returned temperature will always be shifted down.
+  const float temperature_offset = TEMPERATURE_OFFSET;  // [K]
+#else
+  const float temperature_offset = -3.0;  // [K] Temperature measured by sensor is usually at least 3K too high.
+#endif
+  const bool auto_calibrate_sensor = AUTO_CALIBRATE_SENSOR;  // [true / false]
+}
+
+namespace sensor {
+  SCD30 scd30;
+  int16_t co2 = 0;
+  float temperature = 0;
+  float humidity = 0;
+  String timestamp = "";
+
+  void initialize() {
+#if defined(ESP8266)
+    Wire.begin(12, 14);  // ESP8266 - D6, D5;
+#endif
+#if defined(ESP32)
+    Wire.begin(21, 22);  // ESP32
+    /**
+     *  SCD30   ESP32
+     *  VCC --- 3V3
+     *  GND --- GND
+     *  SCL --- SCL (GPIO22) //NOTE: GPIO3 Would be more convenient (right next to GND)
+     *  SDA --- SDA (GPIO21) //NOTE: GPIO1 would be more convenient (right next to GPO3)
+     */
+#endif
+
+    // CO2
+    if (scd30.begin(config::auto_calibrate_sensor) == false) {
+      Serial.println("Air sensor not detected. Please check wiring. Freezing...");
+      while (1) {
+        LedEffects::showWaitingLED(color::red);
+      }
+    }
+
+    // SCD30 has its own timer.
+    Serial.println("\nSetting SCD30 timestep to " + String(config::measurement_timestep) + " s.");
+    scd30.setMeasurementInterval(config::measurement_timestep);  // [s]
+
+    Serial.print("Setting temperature offset to -");
+    Serial.print(abs(config::temperature_offset));
+    Serial.println(" K.");
+    scd30.setTemperatureOffset(abs(config::temperature_offset)); // setTemperatureOffset only accepts positive numbers, but shifts the temperature down.
+
+    Serial.print("Temperature offset is : -");
+    Serial.print(scd30.getTemperatureOffset());
+    Serial.println(" K");
+
+    Serial.print("Auto-calibration is ");
+    Serial.println(config::auto_calibrate_sensor ? "ON." : "OFF.");
+  }
+
+// Force SCD30 calibration with countdown.
+  void startCalibrationProcess() {
+    /** From the sensor documentation:
+     * For best results, the sensor has to be run in a stable environment in continuous mode at
+     * a measurement rate of 2s for at least two minutes before applying the FRC command and sending the reference value.
+     */
+    Serial.println("Setting SCD30 timestep to 2s, prior to calibration.");
+    scd30.setMeasurementInterval(2);  // [s] The change will only take effect after next measurement.
+    LedEffects::showKITTWheel(color::blue, config::measurement_timestep);
+    Serial.println("Waiting 2 minutes.");
+    LedEffects::showKITTWheel(color::blue, 120);
+    Serial.print("Starting SCD30 calibration...");
+    scd30.setAltitudeCompensation(config::altitude_above_sea_level);
+    scd30.setForcedRecalibrationFactor(config::co2_calibration_level);
+    Serial.println(" Done!");
+    Serial.println("Sensor calibrated.");
+    Serial.println("Sensor will now restart.");
+    LedEffects::showKITTWheel(color::green, 5);
+    FS_LIB.end();
+    ESP.restart();
+  }
+}

co2_sensor.h

+#ifndef CO2_SENSOR_H_
+#define CO2_SENSOR_H_
+
+// The SCD30 from Sensirion is a high quality Nondispersive Infrared (NDIR) based CO₂ sensor capable of detecting 400 to 10000ppm with an accuracy of ±(30ppm+3%).
+// https://github.com/sparkfun/SparkFun_SCD30_Arduino_Library
+#include "src/lib/SparkFun_SCD30_Arduino_Library/src/SparkFun_SCD30_Arduino_Library.h"  // From: http://librarymanager/All#SparkFun_SCD30
+#include "config.h"
+#include "led_effects.h"
+#include "csv_writer.h" // To close filesystem before restart.
+#include <Wire.h>
+
+namespace config {
+  extern uint16_t measurement_timestep;  // [s] Value between 2 and 1800 (range for SCD30 sensor)
+  extern const bool auto_calibrate_sensor; // [true / false]
+  extern uint16_t co2_calibration_level;  // [ppm]
+  extern const float temperature_offset; // [K] Sign isn't relevant.
+}
+
+namespace sensor {
+  extern SCD30 scd30;
+  extern int16_t co2;
+  extern float temperature;
+  extern float humidity;
+  extern String timestamp;
+
+  void initialize();
+  void startCalibrationProcess();
+}
+#endif

config.public.h

+#ifndef CONFIG_H_INCLUDED
+#  define CONFIG_H_INCLUDED
+
+// This file is a config template, and can be copied to config.h. Please don't save any important password in this template.
+
+/**
+ * WIFI
+ */
+
+// Setting WIFI_SSID to "NO_WIFI" will disable WiFi completely, and all other dependent services (MQTT, HTTP, NTP, ...)
+#  define WIFI_SSID     "NO_WIFI"
+#  define WIFI_PASSWORD "P4SSW0RD"
+#  define WIFI_TIMEOUT  20 // [s]
+
+/**
+ * Sensor
+ */
+
+// How often should measurement be performed, and displayed?
+//NOTE: SCD30 timer does not seem to be very precise. Variations may occur.
+#  define MEASUREMENT_TIMESTEP 60 // [s] Value between 2 and 1800 (range for SCD30 sensor)
+
+// How often measurements should be sent to MQTT server?
+// Probably a good idea to use a multiple of MEASUREMENT_TIMESTEP, so that averages can be calculated
+// Set to 0 if you want to send values after each measurement
+// #  define SENDING_INTERVAL MEASUREMENT_TIMESTEP * 5 // [s]
+#  define SENDING_INTERVAL 300 // [s]
+
+// How often should measurements be appended to CSV ?
+// Probably a good idea to use a multiple of MEASUREMENT_TIMESTEP, so that averages can be calculated
+// Set to 0 if you want to send values after each measurement
+#  define CSV_INTERVAL 300 // [s]
+
+// Residual heat from CO2 sensor seems to be high enough to change the temperature reading. How much should it be offset?
+// NOTE: Sign isn't relevant. The returned temperature will always be shifted down.
+#  define TEMPERATURE_OFFSET -3 // [K]
+
+// Altitude above sea level
+// Used for CO2 calibration
+// here: Stuttgart, Schellingstr. 24. (Source: Google Earth)
+#  define ALTITUDE_ABOVE_SEA_LEVEL 260 // [m]
+
+// The reference CO2 concentration has to be within the range 400 ppm ≤ cref(CO2) ≤ 2000 ppm.
+// Used for CO2 calibration
+// here : measured concentration in Stuttgart
+#  define ATMOSPHERIC_CO2_CONCENTRATION 425 // [ppm]
+
+// Should the sensor try to calibrate itself?
+// Sensirion recommends 7 days of continuous readings with at least 1 hour a day of 'fresh air' for self-calibration to complete.
+#  define AUTO_CALIBRATE_SENSOR true // [true / false]
+
+/**
+ * LEDs
+ */
+
+// LED brightness, which can vary between min and max brightness ("LED breathing")
+// max_brightness should be between 0 and 255.
+// min_brightness should be between 0 and max_brightness
+#  define MAX_BRIGHTNESS 255
+#  define MIN_BRIGHTNESS 60
+
+/**
+ * WEB SERVER
+ * available at http://local_ip, with user HTTP_USER and password HTTP_PASSWORD
+ */
+
+#  define HTTP // Comment or remove this line if you want to disable HTTP webserver
+
+// Define empty strings in order to disable authentication, or remove the constants altogether.
+#  define HTTP_USER "co2ampel"
+#  define HTTP_PASSWORD "my_password"
+
+/**
+ * MQTT SERVER
+ */
+#  define MQTT // Comment or remove this line if you want to disable MQTT
+
+/*
+ * If MQTT is enabled, co2ampel will publish data every SENDING_INTERVAL seconds.
+ * An MQTT subscriber can then get the data from the corresponding broker, either encrypted or unencrypted:
+ *
+ *  ❯ mosquitto_sub -h 'test.mosquitto.org' -p 8883 -t 'CO2sensors/#' --cafile mosquitto.org.crt -v
+ *  CO2sensors/ESPd05cc9 {"time":"2020-12-13 13:14:37+01", "co2":571, "temp":18.9, "rh":50.9}
+ *  CO2sensors/ESPd05cc9 {"time":"2020-12-13 13:14:48+01", "co2":573, "temp":18.9, "rh":50.2}
+ *  ...
+ *
+ *  ❯ mosquitto_sub -h 'test.mosquitto.org' -t 'CO2sensors/#' -v
+ *  CO2sensors/ESPd05cc9 {"time":"2020-12-13 13:15:09+01", "co2":568, "temp":18.9, "rh":50.1}
+ *  CO2sensors/ESPd05cc9 {"time":"2020-12-13 13:15:20+01", "co2":572, "temp":18.9, "rh":50.3}
+ *  ...
+ */
+
+/*
+ * Allow sensor to be configured over MQTT? Very useful for debugging. For example:
+ *   mosquitto_pub -h 'test.mosquitto.org' -t 'CO2sensors/ESPe08dc9/control' -m 'timer 30'
+ *   mosquitto_pub -h 'test.mosquitto.org' -t 'CO2sensors/ESPe08dc9/control' -m 'calibrate'
+ *   mosquitto_pub -h 'test.mosquitto.org' -t 'CO2sensors/ESPe08dc9/control' -m 'reset'
+ */
+#  define ALLOW_MQTT_COMMANDS false
+
+#  define MQTT_SERVER "test.mosquitto.org"  // MQTT server URL or IP address
+#  define MQTT_PORT 8883
+#  define MQTT_USER ""
+#  define MQTT_PASSWORD ""
+#  define MQTT_SERVER_FINGERPRINT "EE BC 4B F8 57 E3 D3 E4 07 54 23 1E F0 C8 A1 56 E0 D3 1A 1C" // SHA1 for test.mosquitto.org
+
+/**
+ * NTP
+ */
+
+#  define NTP_SERVER "pool.ntp.org"
+#  define UTC_OFFSET_IN_SECONDS 3600 // [s] 3600 for UTC+1
+
+/**
+ * Others
+ */
+#  define BAUDS 115200 // Transmission rate
+
+#endif

csv_writer.cpp

+#include "csv_writer.h"
+
+namespace config {
+  // Values should be defined in config.h
+  uint16_t csv_interval = CSV_INTERVAL; // [s]
+}
+namespace csv_writer {
+  unsigned long last_written_at = 0;
+  String last_successful_write = "";
+
+#if defined(ESP8266)
+  /**
+   * SPECIFIC FUNCTIONS FOR LITTLEFS
+   */
+  FSInfo fs_info;
+
+  bool mountFS() {
+    return LittleFS.begin(); // format if needed.
+  }
+
+  void updateFsInfo() {
+    FS_LIB.info(fs_info);
+  }
+
+  int getTotalSpace() {
+    return fs_info.totalBytes;
+  }
+
+  int getUsedSpace() {
+    return fs_info.usedBytes;
+  }
+
+  void showFilesystemContent() {
+    Dir dir = FS_LIB.openDir("/");
+    while (dir.next()) {
+      Serial.print("  ");
+      Serial.print(dir.fileName());
+      Serial.print(" - ");
+      if (dir.fileSize()) {
+        File f = dir.openFile("r");
+        Serial.println(f.size());
+        f.close();
+      } else {
+        Serial.println("0");
+      }
+    }
+  }
+#endif
+
+#if defined(ESP32)
+  /**
+   * SPECIFIC FUNCTIONS FOR SPIFFS
+   */
+  bool mountFS() {
+    return SPIFFS.begin(true); // format if needed.
+  }
+
+  void updateFsInfo() {
+    // Nothing to do.
+  }
+
+  int getTotalSpace() {
+    return SPIFFS.totalBytes();
+  }
+
+  int getUsedSpace() {
+    return SPIFFS.usedBytes();
+  }
+
+  void showFilesystemContent() {
+    File root = SPIFFS.open("/");
+    File file = root.openNextFile();
+    while (file) {
+      Serial.print("  ");
+      Serial.print(file.name());
+      Serial.print(" - ");
+      Serial.println(file.size());
+      file = root.openNextFile();
+    }
+  }
+#endif
+
+  const String filename = "/" + SENSOR_ID + ".csv";
+
+  int getAvailableSpace() {
+    //TODO : Check if too low?
+    return getTotalSpace() - getUsedSpace();
+  }
+
+  void initialize() {
+    Serial.print(F("Initializing FS..."));
+    if (mountFS()) {
+      Serial.println(F("done."));
+    } else {
+      Serial.println(F("fail."));
+      return;
+    }
+
+    updateFsInfo();
+
+    Serial.println(F("File system info:"));
+
+    Serial.print(F("  Total space    : "));
+    Serial.print(getTotalSpace() / 1024);
+    Serial.println("kB");
+
+    Serial.print(F("  Used space     : "));
+    Serial.print(getUsedSpace() / 1024);
+    Serial.println("kB");
+
+    Serial.print(F("  Available space: "));
+    Serial.print(getAvailableSpace() / 1024);
+    Serial.println("kB");
+    Serial.println();
+
+    // Open dir folder
+    Serial.println("Filesystem content:");
+    showFilesystemContent();
+
+    if (FS_LIB.exists(filename)) {
+      Serial.print(filename);
+      Serial.println(" has been found.");
+    }
+  }
+
+  File openOrCreate() {
+    File csv_file;
+    if (FS_LIB.exists(filename)) {
+      csv_file = FS_LIB.open(filename, "a+");
+    } else {
+      csv_file = FS_LIB.open(filename, "w");
+      csv_file.print(F("Sensor time;CO2 concentration;Temperature;Humidity\r\n"));
+      csv_file.print(F("YYYY-MM-DD HH:MM:SS+ZZ;ppm;degC;%\r\n"));
+    }
+    return csv_file;
+  }
+
+  void logIfTimeHasCome(const String &timeStamp, int16_t co2, float temp, float hum) {
+    unsigned long now = seconds();
+    //TODO: Write average since last CSV write?
+    if (now - last_written_at > config::csv_interval) {
+      last_written_at = now;
+      LedEffects::onBoardLEDOn();
+      File csv_file = openOrCreate();
+      char csv_line[42];
+      snprintf(csv_line, sizeof(csv_line), "%s;%d;%.1f;%.1f\r\n", timeStamp.c_str(), co2, temp, hum);
+      if (csv_file) {
+        size_t written_bytes = csv_file.print(csv_line);
+        csv_file.close();
+        if (written_bytes == 0) {
+          Serial.println(F("Nothing written. Disk full?"));
+        } else {
+          Serial.println(F("Wrote file content:"));
+          Serial.print(csv_line);
+          last_successful_write = ntp::getLocalTime();
+        }
+        updateFsInfo();
+        delay(50);
+      } else {
+        //NOTE: Can it ever happen that outfile is false?
+        Serial.println(F("Problem on create file!"));
+      }
+      LedEffects::onBoardLEDOff();
+    }
+  }
+}

csv_writer.h

+#ifndef CSV_WRITER_H_
+#define CSV_WRITER_H_
+
+#if defined(ESP8266)
+#  include <LittleFS.h>
+#  define FS_LIB LittleFS
+#elif defined(ESP32)
+#  include <SPIFFS.h>
+#  define FS_LIB SPIFFS
+#else
+#  error Board should be either ESP8266 or ESP832
+#endif
+
+#include "led_effects.h"
+#include "config.h"
+namespace config {
+  extern uint16_t csv_interval;  // [s]
+}
+namespace csv_writer {
+  extern String last_successful_write;
+  void initialize();
+  void logIfTimeHasCome(const String &timeStamp, int16_t co2, float temp, float hum);
+  int getAvailableSpace();
+  extern const String filename;
+}
+
+#endif

led_effects.cpp

+#include "led_effects.h"
+/*****************************************************************
+ * Configuration                                                 *
+ *****************************************************************/
+namespace config {
+  const uint8_t max_brightness = MAX_BRIGHTNESS;
+  const uint8_t min_brightness = MIN_BRIGHTNESS;
+  const int kitt_tail = 3; // How many dimmer LEDs follow in K.I.T.T. wheel
+}
+
+/*****************************************************************
+ * Configuration  (calculated from above values)                 *
+ *****************************************************************/
+namespace config  //TODO: Use a class instead. NightMode could then be another state.
+{
+  const float average_brightness = 0.5 * (config::max_brightness + config::min_brightness);
+  const float brightness_amplitude = 0.5 * (config::max_brightness - config::min_brightness);
+  bool night_mode = false;
+}
+
+// Adafruit NeoPixel (Arduino library for controlling single-wire-based LED pixels and strip)
+// https://github.com/adafruit/Adafruit_NeoPixel
+// Documentation : http://adafruit.github.io/Adafruit_NeoPixel/html/class_adafruit___neo_pixel.html
+
+// NeoPixels on GPIO05, aka D1 on ESP8266 or 5 on ESP32.
+const int NEOPIXELS_PIN = 5;
+const int NUMPIXELS = 12;
+//NOTE: One value has been prepended, to make calculations easier and avoid out of bounds index.
+const uint16_t CO2_TICKS[NUMPIXELS + 1] = { 0, 500, 600, 700, 800, 900, 1000, 1200, 1400, 1600, 1800, 2000, 2200 }; // [ppm]
+// For a given LED, which color should be displayed? First LED will be pure green (hue angle 120°),
+// last 4 LEDs will be pure red (hue angle 0°), LEDs in-between will be yellowish.
+const uint16_t LED_HUES[NUMPIXELS] = { 21845, 19114, 16383, 13653, 10922, 8191, 5461, 2730, 0, 0, 0, 0 }; // [hue angle]
+Adafruit_NeoPixel pixels(NUMPIXELS, NEOPIXELS_PIN, NEO_GRB + NEO_KHZ800);
+
+namespace counter {
+  uint16_t wheel_offset = 0;
+  uint16_t kitt_offset = 0;
+  uint16_t breathing_offset = 0;
+}  // namespace counter
+
+namespace LedEffects {
+  //On-board LED on D4, aka GPIO02
+  const int ONBOARD_LED_PIN = 2;
+
+  void setupOnBoardLED() {
+    pinMode(ONBOARD_LED_PIN, OUTPUT);
+  }
+
+  void onBoardLEDOff() {
+    digitalWrite(ONBOARD_LED_PIN, HIGH);
+  }
+
+  void onBoardLEDOn() {
+    digitalWrite(ONBOARD_LED_PIN, LOW);
+  }
+
+  void setupRing() {
+    pixels.begin();
+    pixels.setBrightness(config::max_brightness);
+    pixels.clear();
+  }
+
+  void toggleNightMode() {
+    config::night_mode = !config::night_mode;
+    if (config::night_mode) {
+      Serial.println(F("NIGHT MODE!"));
+      pixels.clear();
+      pixels.show();
+    } else {
+      Serial.println(F("DAY MODE!"));
+    }
+  }
+
+  //NOTE: basically one iteration of KITT wheel
+  void showWaitingLED(uint32_t color) {
+    delay(80);
+    if (config::night_mode) {
+      return;
+    }
+    pixels.clear();
+    for (int j = config::kitt_tail; j >= 0; j--) {
+      int ledNumber = abs((counter::kitt_offset - j + NUMPIXELS) % (2 * NUMPIXELS) - NUMPIXELS) % NUMPIXELS; // Triangular function
+      pixels.setPixelColor(ledNumber, color * pixels.gamma8(255 - j * 76) / 255);
+    }
+    pixels.show();
+    counter::kitt_offset += 1;
+  }
+
+  // Start K.I.T.T. led effect. Red color as default.
+  // Simulate a moving LED with tail. First LED starts at 0, and moves along a triangular function. The tail follows, with decreasing brightness.
+  // Takes approximately 1s for each direction.
+  void showKITTWheel(uint32_t color, uint16_t duration_s) {
+    pixels.setBrightness(config::max_brightness);
+    for (int i = 0; i < duration_s * NUMPIXELS; ++i) {
+      showWaitingLED(color);
+    }
+  }
+
+  /*
+   * For a given CO2 level and ledId, which brightness should be displayed? 0 for off, 255 for on. Something in-between for partial LED.
+   * For example, for 1500ppm, every LED between 0 and 7 (500 -> 1400ppm) should be on, LED at 8 (1600ppm) should be half-on.
+   */
+  uint8_t getLedBrightness(uint16_t co2, int ledId) {
+    if (co2 >= CO2_TICKS[ledId + 1]) {
+      return 255;
+    } else {
+      if (2 * co2 >= CO2_TICKS[ledId] + CO2_TICKS[ledId + 1]) {
+        // Show partial LED if co2 more than halfway between ticks.
+        return 27; // Brightness isn't linear, so 27 / 255 looks much brighter than 10%
+      } else {
+        // LED off because co2 below previous tick
+        return 0;
+      }
+    }
+  }
+
+  /**
+   * Fills the whole ring with green, yellow, orange or black, depending on co2 input and CO2_TICKS.
+   */
+  void displayCO2color(uint16_t co2) {
+    if (config::night_mode) {
+      return;
+    }
+    pixels.setBrightness(config::max_brightness);
+    for (int ledId = 0; ledId < NUMPIXELS; ++ledId) {
+      uint8_t brightness = getLedBrightness(co2, ledId);
+      pixels.setPixelColor(ledId, pixels.ColorHSV(LED_HUES[ledId], 255, brightness));
+    }
+    pixels.show();
+  }
+
+  void showRainbowWheel(int duration_s, uint16_t hue_increment) {
+    if (config::night_mode) {
+      return;
+    }
+    unsigned long t0 = seconds();
+    pixels.setBrightness(config::max_brightness);
+    while (seconds() < t0 + duration_s) {
+      for (int i = 0; i < NUMPIXELS; i++) {
+        pixels.setPixelColor(i, pixels.ColorHSV(i * 65535 / NUMPIXELS + counter::wheel_offset));
+        counter::wheel_offset += hue_increment;
+      }
+      pixels.show();
+      delay(10);
+    }
+  }
+
+  void redAlert() {
+    if (config::night_mode) {
+      onBoardLEDOn();
+      delay(500);
+      onBoardLEDOff();
+      delay(500);
+      return;
+    }
+    for (int i = 0; i < 10; i++) {
+      pixels.setBrightness(static_cast<int>(config::max_brightness * (1 - i * 0.1)));
+      delay(50);
+      pixels.fill(color::red);
+      pixels.show();
+    }
+  }
+
+  void breathe(int16_t co2) {
+    if (!config::night_mode) {
+      //TODO: use integer sine
+      pixels.setBrightness(
+          static_cast<int>(config::average_brightness
+              + cos(counter::breathing_offset * 0.1) * config::brightness_amplitude));
+      pixels.show();
+      counter::breathing_offset += 1;
+    }
+    delay(co2 > 1600 ? 50 : 100);  // faster breathing for higher CO2 values
+  }
+
+  /**
+   * Displays a complete blue circle, and starts removing LEDs one by one. Returns the number of remaining LEDs.
+   * Can be used for calibration, e.g. when countdown is 0. Does not work in night mode.
+   */
+  int countdownToZero() {
+    if (config::night_mode) {
+      Serial.println("Night mode. Not doing anything.");
+      delay(1000); // Wait for a while, to avoid coming back to this function too many times when button is pressed.
+      return 1;
+    }
+    pixels.fill(color::blue);
+    pixels.show();
+    int countdown;
+    for (countdown = NUMPIXELS; countdown >= 0 && !digitalRead(0); countdown--) {
+      pixels.setPixelColor(countdown, color::black);
+      pixels.show();
+      Serial.println(countdown);
+      delay(500);
+    }
+    return countdown;
+  }
+}

led_effects.h

+#ifndef LED_EFFECTS_H_INCLUDED
+#define LED_EFFECTS_H_INCLUDED
+#include <Arduino.h>
+#include "util.h"
+#include "config.h"
+#include "src/lib/Adafruit_NeoPixel/Adafruit_NeoPixel.h"
+
+namespace color {
+  const uint32_t red = 0xFF0000;
+  const uint32_t green = 0x00FF00;
+  const uint32_t blue = 0x0000FF;
+  const uint32_t black = 0x000000;
+  const uint32_t magenta = 0xFF00FF;
+}
+
+namespace LedEffects {
+  void setupOnBoardLED();
+  void onBoardLEDOff();
+  void onBoardLEDOn();
+  void toggleNightMode();
+
+  void setupRing();
+  void redAlert();
+  void breathe(int16_t co2);
+  int countdownToZero();
+  void showWaitingLED(uint32_t color);
+  void showKITTWheel(uint32_t color, uint16_t duration_s = 2);
+  void showRainbowWheel(int duration_s = 1, uint16_t hue_increment = 50);
+  void displayCO2color(uint16_t co2);
+}
+#endif

mqtt.cpp

+#include "mqtt.h"
+
+namespace config {
+  // Values should be defined in config.h
+  uint16_t sending_interval = SENDING_INTERVAL; // [s]
+  //INFO: Listen to every CO2 sensor which is connected to the server:
+  //  mosquitto_sub -h MQTT_SERVER -t 'CO2sensors/#' -p 443 --capath /etc/ssl/certs/ -u "MQTT_USER" -P "MQTT_PASSWORD" -v
+  const char *mqtt_server = MQTT_SERVER;
+  const uint16_t mqtt_port = MQTT_PORT;
+  const char *mqtt_user = MQTT_USER;
+  const char *mqtt_password = MQTT_PASSWORD;
+  const char *fingerprint PROGMEM = MQTT_SERVER_FINGERPRINT;
+  const bool allow_mqtt_commands = ALLOW_MQTT_COMMANDS;
+  const unsigned long wait_after_fail = 900; // [s] Wait 15 minutes after an MQTT connection fail, before trying again.
+}
+#if defined(ESP32)
+#  include <WiFiClientSecure.h>
+#endif
+WiFiClientSecure espClient;
+PubSubClient mqttClient(espClient);
+
+namespace mqtt {
+  unsigned long last_sent_at = 0;
+  unsigned long last_failed_at = 0;
+
+  String publish_topic;
+  const char *json_sensor_format;
+  String last_successful_publish = "";
+
+  void initialize(String &topic) {
+    json_sensor_format = PSTR("{\"time\":\"%s\", \"co2\":%d, \"temp\":%.1f, \"rh\":%.1f}");
+    publish_topic = topic;
+#if defined(ESP8266)
+    espClient.setFingerprint(config::fingerprint); // not supported by ESP32
+#endif
+    // mqttClient.setSocketTimeout(config::mqtt_timeout); //NOTE: somehow doesn't seem to have any effect on connect()
+    mqttClient.setServer(config::mqtt_server, config::mqtt_port);
+  }
+
+  void publish(const String &timestamp, int16_t co2, float temperature, float humidity) {
+    if (WiFi.status() == WL_CONNECTED && mqttClient.connected()) {
+      LedEffects::onBoardLEDOn();
+      Serial.print(F("Publishing MQTT message ... "));
+
+      char payload[75]; // Should be enough for json...
+      snprintf(payload, sizeof(payload), json_sensor_format, timestamp.c_str(), co2, temperature, humidity);
+      // Topic is the same as clientID. e.g. 'CO2sensors/ESP3d03da'
+      if (mqttClient.publish(publish_topic.c_str(), payload)) {
+        Serial.println("OK");
+        last_successful_publish = ntp::getLocalTime();
+      } else {
+        Serial.println("Failed.");
+      }
+      LedEffects::onBoardLEDOff();
+    }
+  }
+
+  void setTimer(String messageString) {
+    messageString.replace("timer ", "");
+    int timestep = messageString.toInt();
+    if (timestep >= 2 && timestep <= 1800) {
+      Serial.print(F("Setting Measurement Interval to : "));
+      Serial.print(timestep);
+      Serial.println("s.");
+      sensor::scd30.setMeasurementInterval(messageString.toInt());
+      config::measurement_timestep = messageString.toInt();
+      LedEffects::showKITTWheel(color::green, 1);
+    }
+  }
+
+  void setMQTTinterval(String messageString) {
+    messageString.replace("mqtt ", "");
+    config::sending_interval = messageString.toInt();
+    Serial.print(F("Setting Sending Interval to : "));
+    Serial.print(config::sending_interval);
+    Serial.println("s.");
+    LedEffects::showKITTWheel(color::green, 1);
+  }
+
+  void setCSVinterval(String messageString) {
+    messageString.replace("csv ", "");
+    config::csv_interval = messageString.toInt();
+    Serial.print(F("Setting CSV Interval to : "));
+    Serial.print(config::csv_interval);
+    Serial.println("s.");
+    LedEffects::showKITTWheel(color::green, 1);
+  }
+
+  void calibrateSensor(String messageString) {
+    messageString.replace("calibrate ", "");
+    long int calibrationLevel = messageString.toInt();
+    if (calibrationLevel >= 400 && calibrationLevel <= 2000) {
+      Serial.print(F("Force calibration, at "));
+      config::co2_calibration_level = messageString.toInt();
+      Serial.print(config::co2_calibration_level);
+      Serial.println(" ppm.");
+      sensor::startCalibrationProcess();
+    }
+  }
+
+  void setCO2forDebugging(String messageString) {
+    Serial.print(F("DEBUG. Setting CO2 to "));
+    messageString.replace("co2 ", "");
+    sensor::co2 = messageString.toInt();
+    Serial.println(sensor::co2);
+  }
+
+  void sendInfoAboutLocalNetwork() {
+    char info_topic[60]; // Should be enough for "CO2sensors/ESPd05cc9/info"
+    snprintf(info_topic, sizeof(info_topic), "%s/info", publish_topic.c_str());
+
+    char payload[75]; // Should be enough for info json...
+    const char *json_info_format = PSTR("{\"local_ip\":\"%s\", \"ssid\":\"%s\"}");
+    snprintf(payload, sizeof(payload), json_info_format, WiFi.localIP().toString().c_str(), WiFi.SSID().c_str());
+
+    mqttClient.publish(info_topic, payload);
+  }
+
+  /**
+   * Allows sensor to be controlled by commands over MQTT
+   *
+   * mosquitto_pub -h MQTT_SERVER -t 'CO2sensors/SENSOR_ID/control' -p 443 --capath /etc/ssl/certs/ -u "MQTT_USER" -P "MQTT_PASSWORD" -m "reset"
+   * mosquitto_pub -h MQTT_SERVER -t 'CO2sensors/SENSOR_ID/control' -p 443 --capath /etc/ssl/certs/ -u "MQTT_USER" -P "MQTT_PASSWORD" -m "timer 30"
+   * mosquitto_pub -h MQTT_SERVER -t 'CO2sensors/SENSOR_ID/control' -p 443 --capath /etc/ssl/certs/ -u "MQTT_USER" -P "MQTT_PASSWORD" -m "mqtt 900"
+   * mosquitto_pub -h MQTT_SERVER -t 'CO2sensors/SENSOR_ID/control' -p 443 --capath /etc/ssl/certs/ -u "MQTT_USER" -P "MQTT_PASSWORD" -m "calibrate 700"
+   */
+  void controlSensorCallback(char *sub_topic, byte *message, unsigned int length) {
+    if (length == 0) {
+      return;
+    }
+    LedEffects::onBoardLEDOn();
+    Serial.print(F("Message arrived on topic: "));
+    Serial.print(sub_topic);
+    Serial.print(F(". Message: '"));
+    String messageString;
+    for (unsigned int i = 0; i < length; i++) {
+      Serial.print((char) message[i]);
+      messageString += (char) message[i];
+    }
+    Serial.println("'.");
+
+    if (messageString.startsWith("co2 ")) {
+      setCO2forDebugging(messageString);
+    } else if (messageString.startsWith("timer ")) {
+      setTimer(messageString);
+    } else if (messageString.startsWith("calibrate ")) {
+      calibrateSensor(messageString);
+//      config::atmospheric_co2_concentration
+    } else if (messageString.startsWith("mqtt ")) {
+      setMQTTinterval(messageString);
+    } else if (messageString.startsWith("csv ")) {
+      setCSVinterval(messageString);
+    } else if (messageString == "publish") {
+      Serial.println(F("Forcing MQTT publish now."));
+      publish(sensor::timestamp, sensor::co2, sensor::temperature, sensor::humidity);
+    } else if (messageString == "format_filesystem") {
+      FS_LIB.format();
+      LedEffects::showKITTWheel(color::blue, 2);
+    } else if (messageString == "night_mode") {
+      LedEffects::toggleNightMode();
+    } else if (messageString == "local_ip") {
+      sendInfoAboutLocalNetwork();
+    } else if (messageString == "reset") {
+      FS_LIB.end();
+      ESP.restart();
+    } else {
+      LedEffects::showKITTWheel(color::red, 1);
+      Serial.println(F("Message not supported. Doing nothing."));
+    }
+    delay(50);
+    LedEffects::onBoardLEDOff();
+  }
+
+  void reconnect() {
+    if (last_failed_at > 0 && seconds() - last_failed_at < config::wait_after_fail) {
+      // It failed less than wait_after_fail ago. Not even trying.
+      return;
+    }
+    if (WiFi.status() != WL_CONNECTED) { //NOTE: Sadly, WiFi.status is sometimes WL_CONNECTED even though it's really not
+      // No WIFI
+      return;
+    }
+    Serial.print(F("Attempting MQTT connection..."));
+
+    LedEffects::onBoardLEDOn();
+    // Wait for connection, at most 15s (default)
+    mqttClient.connect(publish_topic.c_str(), config::mqtt_user, config::mqtt_password);
+    LedEffects::onBoardLEDOff();
+
+    if (mqttClient.connected()) {
+      //TODO: Send local IP?
+      if (config::allow_mqtt_commands) {
+        char control_topic[60]; // Should be enough for "CO2sensors/ESPd05cc9/control"
+        snprintf(control_topic, sizeof(control_topic), "%s/control", publish_topic.c_str());
+        mqttClient.subscribe(control_topic);
+        mqttClient.setCallback(controlSensorCallback);
+      }
+      Serial.println(F(" Connected."));
+      last_failed_at = 0;
+    } else {
+      last_failed_at = seconds();
+      Serial.print(F(" Failed! Error code="));
+      Serial.print(mqttClient.state());
+      Serial.print(F(". Will try again in "));
+      Serial.print(config::wait_after_fail);
+      Serial.println("s.");
+    }
+  }
+
+  void publishIfTimeHasCome(const String &timeStamp, int16_t co2, float temp, float hum) {
+    // Send message via MQTT according to sending interval
+    unsigned long now = seconds();
+    //TODO: Send average since last MQTT message?
+    if (now - last_sent_at > config::sending_interval) {
+      last_sent_at = now;
+      publish(timeStamp, co2, temp, hum);
+    }
+  }
+
+  void keepConnection() {
+    // Keep MQTT connection
+    if (!mqttClient.connected()) {
+      reconnect();
+    }
+    mqttClient.loop();
+  }
+
+}

mqtt.h

+#ifndef MQTT_H_INCLUDED
+#define MQTT_H_INCLUDED
+
+#include <Arduino.h>
+#include "config.h"
+#include "led_effects.h"
+#include "csv_writer.h"
+#include "co2_sensor.h"
+#include "src/lib/PubSubClient/src/PubSubClient.h"
+#include "wifi_util.h"
+namespace config {
+  extern uint16_t sending_interval;  // [s]
+}
+namespace mqtt {
+  extern String last_successful_publish;
+  void initialize(String &topic);
+  void keepConnection();
+  void publishIfTimeHasCome(const String &timeStamp, int16_t co2, float temp, float hum);
+}
+#endif

platformio.ini

+; PlatformIO Project Configuration File
+;
+;   Build options: build flags, source filter, extra scripting
+;   Upload options: custom port, speed and extra flags
+;   Library options: dependencies, extra library storages
+;
+; Please visit documentation for the other options and examples
+; http://docs.platformio.org/page/projectconf.html
+
+[platformio]
+src_dir = ./
+
+[env:esp8266]
+platform = espressif8266
+board = esp12e
+framework = arduino
+monitor_speed = 115200
+
+[env:esp32]
+platform = espressif32
+board = ttgo-lora32-v1
+framework = arduino
+monitor_speed = 115200

src/lib/Adafruit_NeoPixel/Adafruit_NeoPixel.h

+/*!
+ * @file Adafruit_NeoPixel.h
+ *
+ * This is part of Adafruit's NeoPixel library for the Arduino platform,
+ * allowing a broad range of microcontroller boards (most AVR boards,
+ * many ARM devices, ESP8266 and ESP32, among others) to control Adafruit
+ * NeoPixels, FLORA RGB Smart Pixels and compatible devices -- WS2811,
+ * WS2812, WS2812B, SK6812, etc.
+ *
+ * Adafruit invests time and resources providing this open source code,
+ * please support Adafruit and open-source hardware by purchasing products
+ * from Adafruit!
+ *
+ * Written by Phil "Paint Your Dragon" Burgess for Adafruit Industries,
+ * with contributions by PJRC, Michael Miller and other members of the
+ * open source community.
+ *
+ * This file is part of the Adafruit_NeoPixel library.
+ *
+ * Adafruit_NeoPixel 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.
+ *
+ * Adafruit_NeoPixel 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 NeoPixel.  If not, see
+ * <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef ADAFRUIT_NEOPIXEL_H
+#define ADAFRUIT_NEOPIXEL_H
+
+#ifdef ARDUINO
+  #if (ARDUINO >= 100)
+  #include <Arduino.h>
+  #else
+  #include <WProgram.h>
+  #include <pins_arduino.h>
+  #endif
+#endif
+
+#ifdef TARGET_LPC1768
+  #include <Arduino.h>
+#endif
+
+// The order of primary colors in the NeoPixel data stream can vary among
+// device types, manufacturers and even different revisions of the same
+// item.  The third parameter to the Adafruit_NeoPixel constructor encodes
+// the per-pixel byte offsets of the red, green and blue primaries (plus
+// white, if present) in the data stream -- the following #defines provide
+// an easier-to-use named version for each permutation. e.g. NEO_GRB
+// indicates a NeoPixel-compatible device expecting three bytes per pixel,
+// with the first byte transmitted containing the green value, second
+// containing red and third containing blue. The in-memory representation
+// of a chain of NeoPixels is the same as the data-stream order; no
+// re-ordering of bytes is required when issuing data to the chain.
+// Most of these values won't exist in real-world devices, but it's done
+// this way so we're ready for it (also, if using the WS2811 driver IC,
+// one might have their pixels set up in any weird permutation).
+
+// Bits 5,4 of this value are the offset (0-3) from the first byte of a
+// pixel to the location of the red color byte.  Bits 3,2 are the green
+// offset and 1,0 are the blue offset.  If it is an RGBW-type device
+// (supporting a white primary in addition to R,G,B), bits 7,6 are the
+// offset to the white byte...otherwise, bits 7,6 are set to the same value
+// as 5,4 (red) to indicate an RGB (not RGBW) device.
+// i.e. binary representation:
+// 0bWWRRGGBB for RGBW devices
+// 0bRRRRGGBB for RGB
+
+// RGB NeoPixel permutations; white and red offsets are always same
+// Offset:         W        R        G        B
+#define NEO_RGB  ((0<<6) | (0<<4) | (1<<2) | (2)) ///< Transmit as R,G,B
+#define NEO_RBG  ((0<<6) | (0<<4) | (2<<2) | (1)) ///< Transmit as R,B,G
+#define NEO_GRB  ((1<<6) | (1<<4) | (0<<2) | (2)) ///< Transmit as G,R,B
+#define NEO_GBR  ((2<<6) | (2<<4) | (0<<2) | (1)) ///< Transmit as G,B,R
+#define NEO_BRG  ((1<<6) | (1<<4) | (2<<2) | (0)) ///< Transmit as B,R,G
+#define NEO_BGR  ((2<<6) | (2<<4) | (1<<2) | (0)) ///< Transmit as B,G,R
+
+// RGBW NeoPixel permutations; all 4 offsets are distinct
+// Offset:         W          R          G          B
+#define NEO_WRGB ((0<<6) | (1<<4) | (2<<2) | (3)) ///< Transmit as W,R,G,B
+#define NEO_WRBG ((0<<6) | (1<<4) | (3<<2) | (2)) ///< Transmit as W,R,B,G
+#define NEO_WGRB ((0<<6) | (2<<4) | (1<<2) | (3)) ///< Transmit as W,G,R,B
+#define NEO_WGBR ((0<<6) | (3<<4) | (1<<2) | (2)) ///< Transmit as W,G,B,R
+#define NEO_WBRG ((0<<6) | (2<<4) | (3<<2) | (1)) ///< Transmit as W,B,R,G
+#define NEO_WBGR ((0<<6) | (3<<4) | (2<<2) | (1)) ///< Transmit as W,B,G,R
+
+#define NEO_RWGB ((1<<6) | (0<<4) | (2<<2) | (3)) ///< Transmit as R,W,G,B
+#define NEO_RWBG ((1<<6) | (0<<4) | (3<<2) | (2)) ///< Transmit as R,W,B,G
+#define NEO_RGWB ((2<<6) | (0<<4) | (1<<2) | (3)) ///< Transmit as R,G,W,B
+#define NEO_RGBW ((3<<6) | (0<<4) | (1<<2) | (2)) ///< Transmit as R,G,B,W
+#define NEO_RBWG ((2<<6) | (0<<4) | (3<<2) | (1)) ///< Transmit as R,B,W,G
+#define NEO_RBGW ((3<<6) | (0<<4) | (2<<2) | (1)) ///< Transmit as R,B,G,W
+
+#define NEO_GWRB ((1<<6) | (2<<4) | (0<<2) | (3)) ///< Transmit as G,W,R,B
+#define NEO_GWBR ((1<<6) | (3<<4) | (0<<2) | (2)) ///< Transmit as G,W,B,R
+#define NEO_GRWB ((2<<6) | (1<<4) | (0<<2) | (3)) ///< Transmit as G,R,W,B
+#define NEO_GRBW ((3<<6) | (1<<4) | (0<<2) | (2)) ///< Transmit as G,R,B,W
+#define NEO_GBWR ((2<<6) | (3<<4) | (0<<2) | (1)) ///< Transmit as G,B,W,R
+#define NEO_GBRW ((3<<6) | (2<<4) | (0<<2) | (1)) ///< Transmit as G,B,R,W
+
+#define NEO_BWRG ((1<<6) | (2<<4) | (3<<2) | (0)) ///< Transmit as B,W,R,G
+#define NEO_BWGR ((1<<6) | (3<<4) | (2<<2) | (0)) ///< Transmit as B,W,G,R
+#define NEO_BRWG ((2<<6) | (1<<4) | (3<<2) | (0)) ///< Transmit as B,R,W,G
+#define NEO_BRGW ((3<<6) | (1<<4) | (2<<2) | (0)) ///< Transmit as B,R,G,W
+#define NEO_BGWR ((2<<6) | (3<<4) | (1<<2) | (0)) ///< Transmit as B,G,W,R
+#define NEO_BGRW ((3<<6) | (2<<4) | (1<<2) | (0)) ///< Transmit as B,G,R,W
+
+// Add NEO_KHZ400 to the color order value to indicate a 400 KHz device.
+// All but the earliest v1 NeoPixels expect an 800 KHz data stream, this is
+// the default if unspecified. Because flash space is very limited on ATtiny
+// devices (e.g. Trinket, Gemma), v1 NeoPixels aren't handled by default on
+// those chips, though it can be enabled by removing the ifndef/endif below,
+// but code will be bigger. Conversely, can disable the NEO_KHZ400 line on
+// other MCUs to remove v1 support and save a little space.
+
+#define NEO_KHZ800 0x0000 ///< 800 KHz data transmission
+#ifndef __AVR_ATtiny85__
+#define NEO_KHZ400 0x0100 ///< 400 KHz data transmission
+#endif
+
+// If 400 KHz support is enabled, the third parameter to the constructor
+// requires a 16-bit value (in order to select 400 vs 800 KHz speed).
+// If only 800 KHz is enabled (as is default on ATtiny), an 8-bit value
+// is sufficient to encode pixel color order, saving some space.
+
+#ifdef NEO_KHZ400
+typedef uint16_t neoPixelType; ///< 3rd arg to Adafruit_NeoPixel constructor
+#else
+typedef uint8_t  neoPixelType; ///< 3rd arg to Adafruit_NeoPixel constructor
+#endif
+
+// These two tables are declared outside the Adafruit_NeoPixel class
+// because some boards may require oldschool compilers that don't
+// handle the C++11 constexpr keyword.
+
+/* A PROGMEM (flash mem) table containing 8-bit unsigned sine wave (0-255).
+   Copy & paste this snippet into a Python REPL to regenerate:
+import math
+for x in range(256):
+    print("{:3},".format(int((math.sin(x/128.0*math.pi)+1.0)*127.5+0.5))),
+    if x&15 == 15: print
+*/
+static const uint8_t PROGMEM _NeoPixelSineTable[256] = {
+  128,131,134,137,140,143,146,149,152,155,158,162,165,167,170,173,
+  176,179,182,185,188,190,193,196,198,201,203,206,208,211,213,215,
+  218,220,222,224,226,228,230,232,234,235,237,238,240,241,243,244,
+  245,246,248,249,250,250,251,252,253,253,254,254,254,255,255,255,
+  255,255,255,255,254,254,254,253,253,252,251,250,250,249,248,246,
+  245,244,243,241,240,238,237,235,234,232,230,228,226,224,222,220,
+  218,215,213,211,208,206,203,201,198,196,193,190,188,185,182,179,
+  176,173,170,167,165,162,158,155,152,149,146,143,140,137,134,131,
+  128,124,121,118,115,112,109,106,103,100, 97, 93, 90, 88, 85, 82,
+   79, 76, 73, 70, 67, 65, 62, 59, 57, 54, 52, 49, 47, 44, 42, 40,
+   37, 35, 33, 31, 29, 27, 25, 23, 21, 20, 18, 17, 15, 14, 12, 11,
+   10,  9,  7,  6,  5,  5,  4,  3,  2,  2,  1,  1,  1,  0,  0,  0,
+    0,  0,  0,  0,  1,  1,  1,  2,  2,  3,  4,  5,  5,  6,  7,  9,
+   10, 11, 12, 14, 15, 17, 18, 20, 21, 23, 25, 27, 29, 31, 33, 35,
+   37, 40, 42, 44, 47, 49, 52, 54, 57, 59, 62, 65, 67, 70, 73, 76,
+   79, 82, 85, 88, 90, 93, 97,100,103,106,109,112,115,118,121,124};
+
+/* Similar to above, but for an 8-bit gamma-correction table.
+   Copy & paste this snippet into a Python REPL to regenerate:
+import math
+gamma=2.6
+for x in range(256):
+    print("{:3},".format(int(math.pow((x)/255.0,gamma)*255.0+0.5))),
+    if x&15 == 15: print
+*/
+static const uint8_t PROGMEM _NeoPixelGammaTable[256] = {
+    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+    0,  0,  0,  0,  0,  0,  0,  0,  1,  1,  1,  1,  1,  1,  1,  1,
+    1,  1,  1,  1,  2,  2,  2,  2,  2,  2,  2,  2,  3,  3,  3,  3,
+    3,  3,  4,  4,  4,  4,  5,  5,  5,  5,  5,  6,  6,  6,  6,  7,
+    7,  7,  8,  8,  8,  9,  9,  9, 10, 10, 10, 11, 11, 11, 12, 12,
+   13, 13, 13, 14, 14, 15, 15, 16, 16, 17, 17, 18, 18, 19, 19, 20,
+   20, 21, 21, 22, 22, 23, 24, 24, 25, 25, 26, 27, 27, 28, 29, 29,
+   30, 31, 31, 32, 33, 34, 34, 35, 36, 37, 38, 38, 39, 40, 41, 42,
+   42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
+   58, 59, 60, 61, 62, 63, 64, 65, 66, 68, 69, 70, 71, 72, 73, 75,
+   76, 77, 78, 80, 81, 82, 84, 85, 86, 88, 89, 90, 92, 93, 94, 96,
+   97, 99,100,102,103,105,106,108,109,111,112,114,115,117,119,120,
+  122,124,125,127,129,130,132,134,136,137,139,141,143,145,146,148,
+  150,152,154,156,158,160,162,164,166,168,170,172,174,176,178,180,
+  182,184,186,188,191,193,195,197,199,202,204,206,209,211,213,215,
+  218,220,223,225,227,230,232,235,237,240,242,245,247,250,252,255};
+
+/*! 
+    @brief  Class that stores state and functions for interacting with
+            Adafruit NeoPixels and compatible devices.
+*/
+class Adafruit_NeoPixel {
+
+ public:
+
+  // Constructor: number of LEDs, pin number, LED type
+  Adafruit_NeoPixel(uint16_t n, uint16_t pin=6,
+    neoPixelType type=NEO_GRB + NEO_KHZ800);
+  Adafruit_NeoPixel(void);
+  ~Adafruit_NeoPixel();
+
+  void              begin(void);
+  void              show(void);
+  void              setPin(uint16_t p);
+  void              setPixelColor(uint16_t n, uint8_t r, uint8_t g, uint8_t b);
+  void              setPixelColor(uint16_t n, uint8_t r, uint8_t g, uint8_t b,
+                      uint8_t w);
+  void              setPixelColor(uint16_t n, uint32_t c);
+  void              fill(uint32_t c=0, uint16_t first=0, uint16_t count=0);
+  void              setBrightness(uint8_t);
+  void              clear(void);
+  void              updateLength(uint16_t n);
+  void              updateType(neoPixelType t);
+  /*!
+    @brief   Check whether a call to show() will start sending data
+             immediately or will 'block' for a required interval. NeoPixels
+             require a short quiet time (about 300 microseconds) after the
+             last bit is received before the data 'latches' and new data can
+             start being received. Usually one's sketch is implicitly using
+             this time to generate a new frame of animation...but if it
+             finishes very quickly, this function could be used to see if
+             there's some idle time available for some low-priority
+             concurrent task.
+    @return  1 or true if show() will start sending immediately, 0 or false
+             if show() would block (meaning some idle time is available).
+  */
+  bool canShow(void) {
+    if (endTime > micros()) {
+      endTime = micros();
+    }
+    return (micros() - endTime) >= 300L;
+  }
+  /*!
+    @brief   Get a pointer directly to the NeoPixel data buffer in RAM.
+             Pixel data is stored in a device-native format (a la the NEO_*
+             constants) and is not translated here. Applications that access
+             this buffer will need to be aware of the specific data format
+             and handle colors appropriately.
+    @return  Pointer to NeoPixel buffer (uint8_t* array).
+    @note    This is for high-performance applications where calling
+             setPixelColor() on every single pixel would be too slow (e.g.
+             POV or light-painting projects). There is no bounds checking
+             on the array, creating tremendous potential for mayhem if one
+             writes past the ends of the buffer. Great power, great
+             responsibility and all that.
+  */
+  uint8_t          *getPixels(void) const { return pixels; };
+  uint8_t           getBrightness(void) const;
+  /*!
+    @brief   Retrieve the pin number used for NeoPixel data output.
+    @return  Arduino pin number (-1 if not set).
+  */
+  int16_t           getPin(void) const { return pin; };
+  /*!
+    @brief   Return the number of pixels in an Adafruit_NeoPixel strip object.
+    @return  Pixel count (0 if not set).
+  */
+  uint16_t          numPixels(void) const { return numLEDs; }
+  uint32_t          getPixelColor(uint16_t n) const;
+  /*!
+    @brief   An 8-bit integer sine wave function, not directly compatible
+             with standard trigonometric units like radians or degrees.
+    @param   x  Input angle, 0-255; 256 would loop back to zero, completing
+                the circle (equivalent to 360 degrees or 2 pi radians).
+                One can therefore use an unsigned 8-bit variable and simply
+                add or subtract, allowing it to overflow/underflow and it
+                still does the expected contiguous thing.
+    @return  Sine result, 0 to 255, or -128 to +127 if type-converted to
+             a signed int8_t, but you'll most likely want unsigned as this
+             output is often used for pixel brightness in animation effects.
+  */
+  static uint8_t    sine8(uint8_t x) {
+    return pgm_read_byte(&_NeoPixelSineTable[x]); // 0-255 in, 0-255 out
+  }
+  /*!
+    @brief   An 8-bit gamma-correction function for basic pixel brightness
+             adjustment. Makes color transitions appear more perceptially
+             correct.
+    @param   x  Input brightness, 0 (minimum or off/black) to 255 (maximum).
+    @return  Gamma-adjusted brightness, can then be passed to one of the
+             setPixelColor() functions. This uses a fixed gamma correction
+             exponent of 2.6, which seems reasonably okay for average
+             NeoPixels in average tasks. If you need finer control you'll
+             need to provide your own gamma-correction function instead.
+  */
+  static uint8_t    gamma8(uint8_t x) {
+    return pgm_read_byte(&_NeoPixelGammaTable[x]); // 0-255 in, 0-255 out
+  }
+  /*!
+    @brief   Convert separate red, green and blue values into a single
+             "packed" 32-bit RGB color.
+    @param   r  Red brightness, 0 to 255.
+    @param   g  Green brightness, 0 to 255.
+    @param   b  Blue brightness, 0 to 255.
+    @return  32-bit packed RGB value, which can then be assigned to a
+             variable for later use or passed to the setPixelColor()
+             function. Packed RGB format is predictable, regardless of
+             LED strand color order.
+  */
+  static uint32_t   Color(uint8_t r, uint8_t g, uint8_t b) {
+    return ((uint32_t)r << 16) | ((uint32_t)g <<  8) | b;
+  }
+  /*!
+    @brief   Convert separate red, green, blue and white values into a
+             single "packed" 32-bit WRGB color.
+    @param   r  Red brightness, 0 to 255.
+    @param   g  Green brightness, 0 to 255.
+    @param   b  Blue brightness, 0 to 255.
+    @param   w  White brightness, 0 to 255.
+    @return  32-bit packed WRGB value, which can then be assigned to a
+             variable for later use or passed to the setPixelColor()
+             function. Packed WRGB format is predictable, regardless of
+             LED strand color order.
+  */
+  static uint32_t   Color(uint8_t r, uint8_t g, uint8_t b, uint8_t w) {
+    return ((uint32_t)w << 24) | ((uint32_t)r << 16) | ((uint32_t)g <<  8) | b;
+  }
+  static uint32_t   ColorHSV(uint16_t hue, uint8_t sat=255, uint8_t val=255);
+  /*!
+    @brief   A gamma-correction function for 32-bit packed RGB or WRGB
+             colors. Makes color transitions appear more perceptially
+             correct.
+    @param   x  32-bit packed RGB or WRGB color.
+    @return  Gamma-adjusted packed color, can then be passed in one of the
+             setPixelColor() functions. Like gamma8(), this uses a fixed
+             gamma correction exponent of 2.6, which seems reasonably okay
+             for average NeoPixels in average tasks. If you need finer
+             control you'll need to provide your own gamma-correction
+             function instead.
+  */
+  static uint32_t   gamma32(uint32_t x);
+
+ protected:
+
+#ifdef NEO_KHZ400  // If 400 KHz NeoPixel support enabled...
+  bool              is800KHz;   ///< true if 800 KHz pixels
+#endif
+  bool              begun;      ///< true if begin() previously called
+  uint16_t          numLEDs;    ///< Number of RGB LEDs in strip
+  uint16_t          numBytes;   ///< Size of 'pixels' buffer below
+  int16_t           pin;        ///< Output pin number (-1 if not yet set)
+  uint8_t           brightness; ///< Strip brightness 0-255 (stored as +1)
+  uint8_t          *pixels;     ///< Holds LED color values (3 or 4 bytes each)
+  uint8_t           rOffset;    ///< Red index within each 3- or 4-byte pixel
+  uint8_t           gOffset;    ///< Index of green byte
+  uint8_t           bOffset;    ///< Index of blue byte
+  uint8_t           wOffset;    ///< Index of white (==rOffset if no white)
+  uint32_t          endTime;    ///< Latch timing reference
+#ifdef __AVR__
+  volatile uint8_t *port;       ///< Output PORT register
+  uint8_t           pinMask;    ///< Output PORT bitmask
+#endif
+#if defined(ARDUINO_ARCH_STM32) || defined(ARDUINO_ARCH_ARDUINO_CORE_STM32)
+  GPIO_TypeDef *gpioPort;       ///< Output GPIO PORT
+  uint32_t gpioPin;             ///< Output GPIO PIN
+#endif
+};
+
+#endif // ADAFRUIT_NEOPIXEL_H

src/lib/Adafruit_NeoPixel/CONTRIBUTING.md

+# Contribution Guidelines
+
+This library is the culmination of the expertise of many members of the open source community who have dedicated their time and hard work. The best way to ask for help or propose a new idea is to [create a new issue](https://github.com/adafruit/Adafruit_NeoPixel/issues/new) while creating a Pull Request with your code changes allows you to share your own innovations with the rest of the community.
+
+The following are some guidelines to observe when creating issues or PRs:
+
+- Be friendly; it is important that we can all enjoy a safe space as we are all working on the same project and it is okay for people to have different ideas
+
+- [Use code blocks](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet#code); it helps us help you when we can read your code! On that note also refrain from pasting more than 30 lines of code in a post, instead [create a gist](https://gist.github.com/) if you need to share large snippets
+
+- Use reasonable titles; refrain from using overly long or capitalized titles as they are usually annoying and do little to encourage others to help :smile:
+
+- Be detailed; refrain from mentioning code problems without sharing your source code and always give information regarding your board and version of the library