new version 0_2_2 from stuttgart

2021-11-15 13:45:36 +01:00 · 2021-11-15 13:45:36 +01:00 · c1b71e9829
parent 0514952897
commit c1b71e9829
32 changed files with 1049 additions and 501 deletions
--- a/.gitignore
+++ b/.gitignore
@ -3,8 +3,6 @@
 .pio/build
 .vscode
 *.ino.cpp
 config.h
 config.hftstuttgart.h
 .project
 .cproject
 .settings
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@ -2,29 +2,11 @@ image: python:3.6
 stages:
 - build
 - release
 before_script:
  - "pip install -U platformio"
  - "cp ampel-firmware/config.public.h ampel-firmware/config.h"
-esp8266:
+job:
  stage: build
-  script: 
+  script: "platformio run"
    - "platformio run --environment esp8266"
    - cp .pio/build/esp8266/firmware.bin esp8266.bin
  artifacts:
    paths:
      - esp8266.bin
    expire_in: 1 week
 release:
    image: inetprocess/gitlab-release
    stage: release
    only:
        - tags
    dependencies: 
        - esp8266
    script:
        - gitlab-release --message '' ./*.bin
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -0,0 +1,25 @@
 # Change Log
 ## [v0.2.2](https://transfer.hft-stuttgart.de/gitlab/co2ampel/ampel-firmware/-/releases/v0.2.2) 2021/10/01
 * MAC address is now shown at startup and via HTTP
 ## [v0.2.1](https://transfer.hft-stuttgart.de/gitlab/co2ampel/ampel-firmware/-/releases/v0.2.1) 2021/06/06
 * BUGFIX: Sensor would keep on calibrating after successful calibration.
 ## [v0.2.0](https://transfer.hft-stuttgart.de/gitlab/co2ampel/ampel-firmware/-/releases/v0.2.0) 2021/06/06
 * BUGFIX: Calibration was not applied correctly (Thanks Michael Käppler for bug finding & fixing!)
 * MQTT works again for ESP32 (board needs to be updated in Arduino IDE/PlaftormIO)
 ## [v0.1.0](https://transfer.hft-stuttgart.de/gitlab/co2ampel/ampel-firmware/-/releases/v0.1.0) 2021/05/19
 * More stable calibration, with 10s timestep
 * Allow commands from Serial/MQTT/Webserver
 * Many bugfixes
 ## [v0.0.9](https://transfer.hft-stuttgart.de/gitlab/co2ampel/ampel-firmware/-/releases/v0.0.9) 2020/12/15
 * First CO2 Ampel release.
 * Basic functionality
--- a/README.md
+++ b/README.md
@ -1,6 +1,6 @@
 # CO<sub>2</sub> Ampel
-*CO<sub>2</sub> Ampel* is an open-source project, written in C++ for ESP8266 or ESP32.
+*CO<sub>2</sub> Ampel* is an open-source project, written in C++ for [ESP8266](https://en.wikipedia.org/wiki/ESP8266) or [ESP32](https://en.wikipedia.org/wiki/ESP32).
 It measures the current CO<sub>2</sub> concentration (in ppm), and displays it on an LED ring.
@ -12,20 +12,20 @@ The *CO<sub>2</sub> Ampel* can:
 * Display CO2 concentration on LED ring.
 * Allow calibration.
-* Get current time over NTP
+* Get current time over [NTP](https://en.wikipedia.org/wiki/Network_Time_Protocol)
-* Send data over MQTT.
+* Send data over [MQTT](https://en.wikipedia.org/wiki/MQTT).
-* Send data over LoRaWAN.
+* Send data over [LoRaWAN](https://en.wikipedia.org/wiki/LoRa#LoRaWAN).
 * Display measurements and configuration on a small website.
-* Log data to a CSV file, directly on the ESP flash memory.
+* Log data to a [CSV](https://en.wikipedia.org/wiki/Comma-separated_values) file, directly on the ESP flash memory.
 * Accept many interactive commands.
 ## 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)
+* [NeoPixel Ring - 12](https://www.adafruit.com/product/1643), or [NeoPixel Ring - 16](https://www.adafruit.com/product/1463) (experimental)
-See the [original documentation](https://transfer.hft-stuttgart.de/gitlab/co2ampel/ampel-documentation) for more info.
+See the [documentation](https://transfer.hft-stuttgart.de/gitlab/co2ampel/ampel-documentation) for more info.
 Or our Wiki [MakerLab Wiki CO2 Ampel](https://wiki.makerlab-murnau.de/books/co2-ampel).
 ## Software Requirements
@ -68,27 +68,49 @@ make upload board=esp32 && make monitor # For ESP32
 * *Upload*
 * *Tools > Serial Monitor*
 ## Available commands
 In Arduino IDE *Serial Monitor* or PlatformIO *Monitor*, type `help` + <kbd>Enter</kbd> in order to list the available commands:
 * `auto_calibrate 0/1` (Disables/enables autocalibration).
 * `calibrate` (Starts calibration process).
 * `calibrate 600` (Starts calibration process, to given ppm).
 * `calibrate! 600` (Calibrates right now, to given ppm).
 * `co2 1500` (Sets co2 level, for debugging purposes).
 * `color 0xFF0015` (Shows color, specified as RGB, for debugging).
 * `csv 60` (Sets CSV writing interval, in s).
 * `format_filesystem` (Deletes the whole filesystem).
 * `free` (Displays available heap space).
 * `local_ip` (Displays local IP and current SSID).
 * `lora 300` (Sets LoRaWAN sending interval, in s).
 * `mqtt 60` (Sets MQTT sending interval, in s).
 * `night_mode` (Toggles night mode on/off).
 * `reset` (Restarts the ESP).
 * `reset_scd` (Resets SCD30).
 * `send_local_ip` (Sends local IP and SSID via MQTT. Can be useful to find sensor).
 * `set_time 1618829570` (Sets time to the given UNIX time).
 * `show_csv` (Displays the complete CSV file on Serial).
 * `timer 30` (Sets measurement interval, in s).
 * `wifi_scan` (Scans available WiFi networks).
 The commands can be sent via the Serial interface, from the webpage or via MQTT.
 ## Authors
- * Eric Duminil
+ * Eric Duminil (HfT Stuttgart)
- * Robert Otto
+ * Robert Otto (HfT Stuttgart)
- * Myriam Guedey
+ * Myriam Guedey (HfT Stuttgart)
- * Tobias Gabriel Erhart
+ * Tobias Gabriel Erhart (HfT Stuttgart)
- * Jonas Stave
+ * Jonas Stave (HfT Stuttgart)
-
+ * Michael Käppler
 Hochschule für Technik Stuttgart
 ## Modifications by
 * Jens Noack
 MakerLab Murnau e.V.
 ## Contributing
-Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.
+
 * Merge requests are welcome, and should be based on the `develop` branch.
 * The `develop` branch gets merged into the `master` once it has been sufficiently tested.
 * 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/)
+Copyright © 2021, [HfT Stuttgart](https://www.hft-stuttgart.de/)
 [GPLv3](https://choosealicense.com/licenses/gpl-3.0/)
--- a/ampel-firmware/ampel-firmware.h
+++ b/ampel-firmware/ampel-firmware.h
@ -20,6 +20,12 @@
 #  ifdef AMPEL_HTTP
 #    include "web_server.h"
 #  endif
 #  if defined(ESP8266)
     //allows sensor to be seen as SENSOR_ID.local, from the local network. For example : espd03cc5.local
 #    include <ESP8266mDNS.h>
 #  elif defined(ESP32)
 #    include <ESPmDNS.h>
 #  endif
 #endif
 #ifdef AMPEL_LORAWAN
@ -27,17 +33,8 @@
 #endif
 #include "util.h"
 #include "sensor_console.h"
 #include "co2_sensor.h"
 #include "led_effects.h"
 #if defined(ESP8266)
 //allows sensor to be seen as SENSOR_ID.local, from the local network. For example : espd03cc5.local
 #  include <ESP8266mDNS.h>
 #elif defined(ESP32)
 #  include <ESPmDNS.h>
 #endif
 void keepServicesAlive();
 void checkFlashButton();
 #endif
--- a/ampel-firmware/ampel-firmware.ino
+++ b/ampel-firmware/ampel-firmware.ino
@ -43,6 +43,7 @@
 * Myriam Guedey
 * Tobias Gabriel Erhart
 * Jonas Stave
 * Michael Käppler
 */
 /*****************************************************************
@ -61,22 +62,31 @@
 void setup() {
  led_effects::setupOnBoardLED();
  led_effects::onBoardLEDOff();
-
+  
  Serial.begin(BAUDS);
-  pinMode(0, INPUT); // Flash button (used for forced calibration)
+  pinMode(buttonPin, INPUT); // Flash button (used for forced calibration)
  Serial.println();
  Serial.print(F("Sensor ID: "));
  Serial.println(ampel.sensorId);
  Serial.print(F("MAC      : "));
  Serial.println(ampel.macAddress);
  Serial.print(F("Board    : "));
  Serial.println(ampel.board);
  Serial.print(F("Firmware : "));
  Serial.println(ampel.version);
  led_effects::setupRing();
-
+  led_effects::showRainbowWheel(5000);
  sensor::initialize();
-  Serial.print(F("Sensor ID: "));
+#ifdef AMPEL_CSV
-  Serial.println(SENSOR_ID);
+  csv_writer::initialize(ampel.sensorId);
-  Serial.print(F("Board    : "));
+#endif
  Serial.println(BOARD);
 #ifdef AMPEL_WIFI
-  WiFiConnect(SENSOR_ID);
+  wifi::connect(ampel.sensorId);
  Serial.print(F("WiFi - Status: "));
  Serial.println(WiFi.status());
@ -88,7 +98,7 @@ void setup() {
    ntp::initialize();
-    if (MDNS.begin(SENSOR_ID.c_str())) { // Start the mDNS responder for SENSOR_ID.local
+    if (MDNS.begin(ampel.sensorId)) { // Start the mDNS responder for SENSOR_ID.local
      MDNS.addService("http", "tcp", 80);
      Serial.println(F("mDNS responder started"));
    } else {
@ -96,24 +106,26 @@ void setup() {
    }
 #  ifdef AMPEL_MQTT
-    mqtt::initialize("CO2sensors/" + SENSOR_ID);
+    mqtt::initialize(ampel.sensorId);
 #  endif
  }
 #endif
 #ifdef AMPEL_CSV
  csv_writer::initialize();
 #endif
 #if defined(AMPEL_LORAWAN) && defined(ESP32)
  lorawan::initialize();
 #endif
 }
 /*****************************************************************
 * Helper functions                                              *
 *****************************************************************/
 void keepServicesAlive();
 void checkFlashButton();
 void checkSerialInput();
 /*****************************************************************
 * Main loop                                                     *
 *****************************************************************/
 void loop() {
 #if defined(AMPEL_LORAWAN) && defined(ESP32)
  //LMIC Library seems to be very sensitive to timing issues, so run it first.
@ -133,6 +145,8 @@ void loop() {
  // Short press for night mode, Long press for calibration.
  checkFlashButton();
  checkSerialInput();
  if (sensor::processData()) {
 #ifdef AMPEL_CSV
    csv_writer::logIfTimeHasCome(sensor::timestamp, sensor::co2, sensor::temperature, sensor::humidity);
@ -148,11 +162,17 @@ void loop() {
  }
  uint32_t duration = millis() - t0;
-  if (duration > max_loop_duration) {
+  if (duration > ampel.max_loop_duration) {
-    max_loop_duration = duration;
+    ampel.max_loop_duration = duration;
    Serial.print(F("Debug - Max loop duration : "));
-    Serial.print(max_loop_duration);
+    Serial.print(ampel.max_loop_duration);
-    Serial.println(" ms.");
+    Serial.println(F(" ms."));
  }
 }
 void checkSerialInput() {
  while (Serial.available() > 0) {
    sensor_console::processSerialInput(Serial.read());
  }
 }
@ -163,16 +183,18 @@ void loop() {
 *   If long press, start calibration process.
 */
 void checkFlashButton() {
-  if (!digitalRead(buttonPin)) { // Button has been pressed
+  if (!digitalRead(0)) { // Button has been pressed
    led_effects::onBoardLEDOn();
    delay(300);
-    if (digitalRead(buttonPin)) {
+    if (digitalRead(0)) {
      Serial.println(F("Flash has been pressed for a short time. Should toggle night mode."));
      led_effects::toggleNightMode();
    } else {
      Serial.println(F("Flash has been pressed for a long time. Keep it pressed for calibration."));
-      if (led_effects::countdownToZero() < 0) {
+      if (led_effects::countdownToZero()) {
        Serial.println(F("You can now release the button."));
        sensor::startCalibrationProcess();
        led_effects::showKITTWheel(color::red, 2);
      }
    }
    led_effects::onBoardLEDOff();
--- a/ampel-firmware/co2_sensor.cpp
+++ b/ampel-firmware/co2_sensor.cpp
@ -1,10 +1,17 @@
 #include "co2_sensor.h"
 namespace config {
-  // Values should be defined in config.h
+  // UPPERCASE values should be defined in config.h
-  uint16_t measurement_timestep = MEASUREMENT_TIMESTEP; // [s] Value between 2 and 1800 (range for SCD30 sensor)
+  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]
  const uint16_t measurement_timestep_bootup = 5; // [s] Measurement timestep during acclimatization.
  const uint8_t max_deviation_during_bootup = 20; // [%]
  const int8_t max_deviation_during_calibration = 30; // [ppm]
  const int16_t timestep_during_calibration = 10; // [s] WARNING: Measurements can be unreliable for timesteps shorter than 10s.
  const int8_t stable_measurements_before_calibration = 120 / timestep_during_calibration; // [-] Stable measurements during at least 2 minutes.
  const uint16_t co2_alert_threshold = 2000; // [ppm] Display a flashing led ring, if concentration exceeds this value
 #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.
@ -12,23 +19,46 @@ namespace config {
 #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]
+  bool auto_calibrate_sensor = AUTO_CALIBRATE_SENSOR; // [true / false]
  const bool debug_sensor_states = false; // If true, log state transitions over serial console
 }
 namespace sensor {
  SCD30 scd30;
-  int16_t co2 = 0;
+  uint16_t co2 = 0;
  float temperature = 0;
  float humidity = 0;
-  String timestamp = "";
+  char timestamp[23];
  int16_t stable_measurements = 0;
-  uint32_t waiting_color = color::blue;
+
-  bool should_calibrate = false;
+  /**
-  unsigned long time_calaibration_started = millis();
+   * Define sensor states
   * BOOTUP -> initial state, until first >0 ppm values are returned
   * READY -> sensor does output valid information (> 0 ppm) and no other condition takes place
   * NEEDS_CALIBRATION -> sensor measurements are too low (< 250 ppm)
   * PREPARE_CALIBRATION_UNSTABLE -> forced calibration was initiated, last measurements were too far apart
   * PREPARE_CALIBRATION_STABLE -> forced calibration was initiated, last measurements were close to each others
   */
  enum state {
    BOOTUP,
    READY,
    NEEDS_CALIBRATION,
    PREPARE_CALIBRATION_UNSTABLE,
    PREPARE_CALIBRATION_STABLE
  };
  const char *state_names[] = {
      "BOOTUP",
      "READY",
      "NEEDS_CALIBRATION",
      "PREPARE_CALIBRATION_UNSTABLE",
      "PREPARE_CALIBRATION_STABLE" };
  state current_state = BOOTUP;
  void switchState(state);
  void initialize() {
 #if defined(ESP8266)
-    Wire.begin(12, 14);  // ESP8266 - SDA: D6, SCL: D5;
+    Wire.begin(12, 14); // ESP8266 - D6, D5;
 #endif
 #if defined(ESP32)
    Wire.begin(21, 22); // ESP32
@ -40,81 +70,103 @@ namespace sensor {
     *  SDA --- SDA (GPIO21) //NOTE: GPIO1 would be more convenient (right next to GPO3)
     */
 #endif
    Serial.println();
    scd30.enableDebugging(); // Prints firmware version in the console.
-    // CO2
+    if (!scd30.begin(config::auto_calibrate_sensor)) {
-    if (scd30.begin(config::auto_calibrate_sensor) == false) {
+      Serial.println(F("ERROR - CO2 sensor not detected. Please check wiring!"));
-      Serial.println("Air sensor not detected. Please check wiring. Freezing...");
+      led_effects::showKITTWheel(color::red, 30);
-      while (1) {
+      ESP.restart();
        led_effects::showWaitingLED(color::red);
      }
    }
-    // SCD30 has its own timer.
+    // Changes of the SCD30's measurement timestep do not come into effect
-    //NOTE: The timer seems to be inaccurate, though, possibly depending on voltage. Should it be offset?
+    // before the next measurement takes place. That means that after a hard reset
-    Serial.println();
+    // of the ESP the SCD30 sometimes needs a long time until switching back to 2 s
-    Serial.print(F("Setting SCD30 timestep to "));
+    // for acclimatization. Resetting it after startup seems to fix this behaviour.
-    Serial.print(config::measurement_timestep);
+    scd30.reset();
    Serial.println(" s.");
    scd30.setMeasurementInterval(config::measurement_timestep); // [s]
    Serial.print(F("Setting temperature offset to -"));
    Serial.print(abs(config::temperature_offset));
-    Serial.println(" K.");
+    Serial.println(F(" K."));
    scd30.setTemperatureOffset(abs(config::temperature_offset)); // setTemperatureOffset only accepts positive numbers, but shifts the temperature down.
    delay(100);
    Serial.print(F("Temperature offset is : -"));
    Serial.print(scd30.getTemperatureOffset());
-    Serial.println(" K");
+    Serial.println(F(" K"));
    Serial.print(F("Auto-calibration is "));
    Serial.println(config::auto_calibrate_sensor ? "ON." : "OFF.");
    // SCD30 has its own timer.
    //NOTE: The timer seems to be inaccurate, though, possibly depending on voltage. Should it be offset?
    Serial.println();
    Serial.print(F("Setting SCD30 timestep to "));
    Serial.print(config::measurement_timestep_bootup);
    Serial.println(F(" s during acclimatization."));
    scd30.setMeasurementInterval(config::measurement_timestep_bootup); // [s]
    sensor_console::defineIntCommand("co2", setCO2forDebugging, F("1500 (Sets co2 level, for debugging purposes)"));
    sensor_console::defineIntCommand("timer", setTimer, F("30 (Sets measurement interval, in s)"));
    sensor_console::defineCommand("calibrate", startCalibrationProcess, F("(Starts calibration process)"));
    sensor_console::defineIntCommand("calibrate", calibrateSensorToSpecificPPM,
        F("600 (Starts calibration process, to given ppm)"));
    sensor_console::defineIntCommand("calibrate!", calibrateSensorRightNow,
        F("600 (Calibrates right now, to given ppm)"));
    sensor_console::defineIntCommand("auto_calibrate", setAutoCalibration, F("0/1 (Disables/enables autocalibration)"));
    sensor_console::defineCommand("reset_scd", resetSCD, F("(Resets SCD30)"));
  }
-  //NOTE: should timer deviation be used to adjust measurement_timestep?
+  bool hasSensorSettled() {
-  void checkTimerDeviation() {
+    static uint16_t last_co2 = 0;
-    static int32_t previous_measurement_at = 0;
+    uint16_t delta;
-    int32_t now = millis();
+    delta = abs(co2 - last_co2);
-    Serial.print("Measurement time offset : ");
+    last_co2 = co2;
-    Serial.print(now - previous_measurement_at - config::measurement_timestep * 1000);
+    // We assume the sensor has acclimated to the environment if measurements
-    Serial.println(" ms.");
+    // change less than a specified percentage of the current value.
-    previous_measurement_at = now;
+    return (co2 > 0 && delta < ((uint32_t) co2 * config::max_deviation_during_bootup / 100));
  }
-  void countStableMeasurements() {
+  bool enoughStableMeasurements() {
    static int16_t previous_co2 = 0;
-    if (co2 > (previous_co2 - 30) && co2 < (previous_co2 + 30)) {
+    if (co2 > (previous_co2 - config::max_deviation_during_calibration)
        && co2 < (previous_co2 + config::max_deviation_during_calibration)) {
      stable_measurements++;
      Serial.print(F("Number of stable measurements : "));
-      Serial.println(stable_measurements);
+      Serial.print(stable_measurements);
-      waiting_color = color::green;
+      Serial.print(F(" / "));
      Serial.println(config::stable_measurements_before_calibration);
      switchState(PREPARE_CALIBRATION_STABLE);
    } else {
      stable_measurements = 0;
-      waiting_color = color::red;
+      switchState(PREPARE_CALIBRATION_UNSTABLE);
    }
    previous_co2 = co2;
    return (stable_measurements == config::stable_measurements_before_calibration);
  }
  void startCalibrationProcess() {
    /** From the sensor documentation:
-     * For best results, the sensor has to be run in a stable environment in continuous mode at
+     * Before applying FRC, SCD30 needs to be operated for 2 minutes with the desired measurement period in continuous mode.
     * a measurement rate of 2s for at least two minutes before applying the FRC command and sending the reference value.
     */
-    Serial.println(F("Setting SCD30 timestep to 2s, prior to calibration."));
+    Serial.print(F("Setting SCD30 timestep to "));
-    scd30.setMeasurementInterval(MEASUREMENT_TIMESTEP); // [s] The change will only take effect after next measurement.
+    Serial.print(config::timestep_during_calibration);
    Serial.println(F("s, prior to calibration."));
    scd30.setMeasurementInterval(config::timestep_during_calibration); // [s] The change will only take effect after next measurement.
    Serial.println(F("Waiting until the measurements are stable for at least 2 minutes."));
    Serial.println(F("It could take a very long time."));
-    should_calibrate = true;
+    switchState(PREPARE_CALIBRATION_UNSTABLE);
    time_calaibration_started = millis();
  }
-  void calibrateAndRestart() {
+  void calibrate() {
    Serial.print(F("Calibrating SCD30 now..."));
    scd30.setAltitudeCompensation(config::altitude_above_sea_level);
    scd30.setForcedRecalibrationFactor(config::co2_calibration_level);
    Serial.println(F(" Done!"));
    Serial.println(F("Sensor calibrated."));
-    ESP.restart(); // softer than ESP.reset
+    switchState(BOOTUP); // In order to stop the calibration and select the desired timestep.
    //WARNING: Do not reset the ampel or the SCD30!
    //At least one measurement needs to happen in order for the calibration to be correctly applied.
  }
  void logToSerial() {
@ -127,29 +179,86 @@ namespace sensor {
    Serial.println(humidity, 1);
  }
-  void displayCO2OnLedRing() {
+  void switchState(state new_state) {
-    int16_t co2_int = co2;
+    if (new_state == current_state) {
    if (co2_int < CALIBRATE_LEVEL) {
      // Sensor should be calibrated.
      led_effects::showWaitingLED(color::magenta);
      return;
    }
-    if(co2_int < 400) {
+    if (config::debug_sensor_states) {
-      co2_int = 400;
+      Serial.print(F("Changing sensor state: "));
      Serial.print(state_names[current_state]);
      Serial.print(F(" -> "));
      Serial.println(state_names[new_state]);
    }
    current_state = new_state;
  }
  void switchStateForCurrentPPM() {
    if (current_state == BOOTUP) {
      if (!hasSensorSettled()) {
        return;
      }
      switchState(READY);
      Serial.println(F("Sensor acclimatization finished."));
      Serial.print(F("Setting SCD30 timestep to "));
      Serial.print(config::measurement_timestep);
      Serial.println(F(" s."));
      if (config::measurement_timestep < 10) {
        Serial.println(F("WARNING: Timesteps shorter than 10s can lead to unreliable measurements!"));
      }
      scd30.setMeasurementInterval(config::measurement_timestep); // [s]
    }
    // Check for pre-calibration states first, because we do not want to
    // leave them before calibration is done.
    if ((current_state == PREPARE_CALIBRATION_UNSTABLE) || (current_state == PREPARE_CALIBRATION_STABLE)) {
      if (enoughStableMeasurements()) {
        calibrate();
      }
    } else if (co2 < 250) {
      // Sensor should be calibrated.
      switchState(NEEDS_CALIBRATION);
    } else {
      switchState(READY);
    }
  }
  void displayCO2OnLedRing() {
    /**
     * Display data, even if it's "old" (with breathing).
-     * Those effects include a short delay.
+     * A short delay is required in order to let background tasks run on the ESP8266.
     * see https://github.com/esp8266/Arduino/issues/3241#issuecomment-301290392
     */
-    if (co2_int < 2000) {
+    if (co2 < config::co2_alert_threshold) {
-      led_effects::displayCO2color(co2_int);
+      led_effects::displayCO2color(co2);
-      led_effects::breathe(co2_int);
+      delay(100);
    } else {
-      // >= 2000: entire ring blinks red
+      // Display a flashing led ring, if concentration exceeds a specific value
      led_effects::redAlert();
    }
  }
  void showState() {
    switch (current_state) {
    case BOOTUP:
      led_effects::showWaitingLED(color::blue);
      break;
    case READY:
      displayCO2OnLedRing();
      break;
    case NEEDS_CALIBRATION:
      led_effects::showWaitingLED(color::magenta);
      break;
    case PREPARE_CALIBRATION_UNSTABLE:
      led_effects::showWaitingLED(color::red);
      break;
    case PREPARE_CALIBRATION_STABLE:
      led_effects::showWaitingLED(color::green);
      break;
    default:
      Serial.println(F("Encountered unknown sensor state")); // This should not happen.
    }
  }
  /** Gets fresh data if available, checks calibration status, displays CO2 levels.
   * Returns true if fresh data is available, for further processing (e.g. MQTT, CSV or LoRa)
   */
@ -157,42 +266,75 @@ namespace sensor {
    bool freshData = scd30.dataAvailable();
    if (freshData) {
-      // checkTimerDeviation();
+      ntp::getLocalTime(timestamp);
      timestamp = ntp::getLocalTime();
      co2 = scd30.getCO2();
      temperature = scd30.getTemperature();
      humidity = scd30.getHumidity();
    }
-    //NOTE: Data is available, but it's sometimes erroneous: the sensor outputs zero ppm but non-zero temperature and non-zero humidity.
+      switchStateForCurrentPPM();
    if (co2 <= 0) {
      // No measurement yet. Waiting.
      led_effects::showWaitingLED(color::blue);
      return false;
    }
-    /**
+      // Log every time fresh data is available.
     * Fresh data. Log it and send it if needed.
     */
    if (freshData) {
      if (should_calibrate) {
        if(millis() - time_calaibration_started > 60000)
        {
          countStableMeasurements();
        }
      }
      logToSerial();
    }
-    if (should_calibrate) {
+    showState();
      if (stable_measurements == 60) {
        calibrateAndRestart();
      }
      led_effects::showWaitingLED(waiting_color);
      return false;
    }
-    displayCO2OnLedRing();
+    // Report data for further processing only if the data is reliable
-    return freshData;
+    // (state 'READY') or manual calibration is necessary (state 'NEEDS_CALIBRATION').
    return freshData && (current_state == READY || current_state == NEEDS_CALIBRATION);
  }
  /*****************************************************************
   * Callbacks for sensor commands                                 *
   *****************************************************************/
  void setCO2forDebugging(int32_t fakeCo2) {
    Serial.print(F("DEBUG. Setting CO2 to "));
    co2 = fakeCo2;
    Serial.println(co2);
    switchStateForCurrentPPM();
  }
  void setAutoCalibration(int32_t autoCalibration) {
    config::auto_calibrate_sensor = autoCalibration;
    scd30.setAutoSelfCalibration(autoCalibration);
    Serial.print(F("Setting auto-calibration to : "));
    Serial.println(autoCalibration ? F("On.") : F("Off."));
  }
  void setTimer(int32_t timestep) {
    if (timestep >= 2 && timestep <= 1800) {
      Serial.print(F("Setting Measurement Interval to : "));
      Serial.print(timestep);
      Serial.println(F("s (change will only be applied after next measurement)."));
      scd30.setMeasurementInterval(timestep);
      config::measurement_timestep = timestep;
      led_effects::showKITTWheel(color::green, 1);
    }
  }
  void calibrateSensorToSpecificPPM(int32_t calibrationLevel) {
    if (calibrationLevel >= 400 && calibrationLevel <= 2000) {
      Serial.print(F("Force calibration, at "));
      config::co2_calibration_level = calibrationLevel;
      Serial.print(config::co2_calibration_level);
      Serial.println(F(" ppm."));
      startCalibrationProcess();
    }
  }
  void calibrateSensorRightNow(int32_t calibrationLevel) {
    if (calibrationLevel >= 400 && calibrationLevel <= 2000) {
      Serial.print(F("Force calibration, right now, at "));
      config::co2_calibration_level = calibrationLevel;
      Serial.print(config::co2_calibration_level);
      Serial.println(F(" ppm."));
      calibrate();
    }
  }
  void resetSCD() {
    Serial.print(F("Resetting SCD30..."));
    scd30.reset();
    Serial.println(F("done."));
  }
 }
--- a/ampel-firmware/co2_sensor.h
+++ b/ampel-firmware/co2_sensor.h
@ -7,24 +7,32 @@
 #include "config.h"
 #include "led_effects.h"
 #include "util.h"
 #include "sensor_console.h"
 #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 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 uint16_t co2;
  extern float temperature;
  extern float humidity;
-  extern String timestamp;
+  extern char timestamp[];
  void initialize();
  bool processData();
  void startCalibrationProcess();
  void setCO2forDebugging(int32_t fakeCo2);
  void setTimer(int32_t timestep);
  void calibrateSensorToSpecificPPM(int32_t calibrationLevel);
  void calibrateSensorRightNow(int32_t calibrationLevel);
  void setAutoCalibration(int32_t autoCalibration);
  void resetSCD();
 }
 #endif
--- a/ampel-firmware/config.public.h
+++ b/ampel-firmware/config.public.h
@ -1,6 +1,5 @@
 #ifndef CONFIG_H_INCLUDED
-#  define CONFIG_H_INCLUDED
+#define CONFIG_H_INCLUDED
 #define buttonPin 0
 // This file is a config template, and can be copied to config.h. Please don't save any important password in this template.
@ -14,18 +13,18 @@
 */
 // Comment or remove those lines if you want to disable the corresponding services
-// #  define AMPEL_WIFI    // Should ESP connect to WiFi? It allows the Ampel to get time from an NTP server.
+//#  define AMPEL_WIFI    // Should ESP connect to WiFi? It allows the Ampel to get time from an NTP server.
-// #  define AMPEL_HTTP    // Should HTTP web server be started? (AMPEL_WIFI should be enabled too)
+//#  define AMPEL_HTTP    // Should HTTP web server be started? (AMPEL_WIFI should be enabled too)
 //#  define AMPEL_MQTT    // Should data be sent over MQTT? (AMPEL_WIFI should be enabled too)
-// #  define AMPEL_CSV     // Should data be logged as CSV, on the ESP flash memory?
+//#  define AMPEL_CSV     // Should data be logged as CSV, on the ESP flash memory?
 // #  define AMPEL_LORAWAN // Should data be sent over LoRaWAN? (Requires ESP32 + LoRa modem, and "MCCI LoRaWAN LMIC library")
 /**
 * WIFI
 */
-#  define WIFI_SSID     ""
+#  define WIFI_SSID     "MY_SSID"
-#  define WIFI_PASSWORD ""
+#  define WIFI_PASSWORD "P4SSW0RD"
 #  define WIFI_TIMEOUT  30 // [s]
 /**
@ -33,8 +32,10 @@
 */
 // How often should measurement be performed, and displayed?
-//NOTE: SCD30 timer does not seem to be very precise. Variations may occur.
+//WARNING: On some sensors, measurements become very unreliable when timestep is set to 2s.
-#  define MEASUREMENT_TIMESTEP 2 // [s] Value between 2 and 1800 (range for SCD30 sensor)
+//NOTE: 10s or longer should be fine in order to get reliable results.
 //NOTE: SCD30 timer does not seem to be very precise. Time variations may occur.
 #  define MEASUREMENT_TIMESTEP 5 // [s] Value between 2 and 1800 (range for SCD30 sensor)
 // 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
@ -44,31 +45,34 @@
 // 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 0 // [K]
+#  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 660 // [m]
+#  define ALTITUDE_ABOVE_SEA_LEVEL 600 // [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 430 // [ppm]
+#  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 false // [true / false]
+#  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.
+// MAX_BRIGHTNESS must be defined, and should be between 0 and 255.
 // min_brightness should be between 0 and max_brightness
 #  define MAX_BRIGHTNESS 128
 // MIN_BRIGHTNESS, if defined, should be between 0 and MAX_BRIGHTNESS - 1
 // If MIN_BRIGHTNESS is not set, or if it is set to MAX_BRIGHTNESS, breathing is disabled.
 #  define MIN_BRIGHTNESS 60
 // How many LEDs in the ring? 12 and 16 are currently supported. If undefined, 12 is used as default.
 #  define LED_COUNT 12
 /**
 * WEB SERVER
@ -76,8 +80,8 @@
 */
 // Define empty strings in order to disable authentication, or remove the constants altogether.
-#  define HTTP_USER ""
+#  define HTTP_USER "co2ampel"
-#  define HTTP_PASSWORD ""
+#  define HTTP_PASSWORD "my_password"
 /**
 * MQTT
@ -106,11 +110,11 @@
 */
 #  define ALLOW_MQTT_COMMANDS false
-// How often measurements should be sent to MQTT server?
+// How often should measurements 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 MQTT_SENDING_INTERVAL MEASUREMENT_TIMESTEP * 5 // [s]
+#  define MQTT_SENDING_INTERVAL MEASUREMENT_TIMESTEP * 5 // [s]
-#  define MQTT_SENDING_INTERVAL 60 // [s]
+//#  define MQTT_SENDING_INTERVAL 60 // [s]
 #  define MQTT_SERVER "test.mosquitto.org"  // MQTT server URL or IP address
 #  define MQTT_PORT 8883
 #  define MQTT_USER ""
@ -149,7 +153,7 @@
 */
 #  define NTP_SERVER "pool.ntp.org"
-#  define UTC_OFFSET_IN_SECONDS 3600 // [s] 3600 for UTC+1
+#  define UTC_OFFSET_IN_SECONDS 7200 // [s] 3600 for UTC+1, 7200 for UTC+1 and daylight saving time
 /**
 * Others
--- a/ampel-firmware/csv_writer.cpp
+++ b/ampel-firmware/csv_writer.cpp
@ -1,14 +1,12 @@
 #include "csv_writer.h"
 //TODO: Allow CSV download via USB Serial, when requested (e.g. via a Python script)
 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 = "";
+  char last_successful_write[23];
 #if defined(ESP8266)
  /**
@ -80,13 +78,16 @@ namespace csv_writer {
  }
 #endif
-  const String filename = "/" + SENSOR_ID + ".csv";
+  char filename[15]; // "/ESPxxxxxx.csv\0"
  int getAvailableSpace() {
    return getTotalSpace() - getUsedSpace();
  }
-  void initialize() {
+  void initialize(const char *sensorId) {
    snprintf(filename, sizeof(filename), "/%s.csv", sensorId);
    Serial.println();
    Serial.print(F("Initializing FS..."));
    if (mountFS()) {
      Serial.println(F("done."));
@ -113,9 +114,13 @@ namespace csv_writer {
    Serial.println();
    // Open dir folder
-    Serial.println("Filesystem content:");
+    Serial.println(F("Filesystem content:"));
    showFilesystemContent();
    Serial.println();
    sensor_console::defineIntCommand("csv", setCSVinterval, F("60 (Sets CSV writing interval, in s)"));
    sensor_console::defineCommand("format_filesystem", formatFilesystem, F("(Deletes the whole filesystem)"));
    sensor_console::defineCommand("show_csv", showCSVContent, F("(Displays the complete CSV file on Serial)"));
  }
  File openOrCreate() {
@ -130,11 +135,11 @@ namespace csv_writer {
    return csv_file;
  }
-  void log(const String &timeStamp, const int16_t &co2, const float &temperature, const float &humidity) {
+  void log(const char *timestamp, const int16_t &co2, const float &temperature, const float &humidity) {
    led_effects::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, temperature, humidity);
+    snprintf(csv_line, sizeof(csv_line), "%s;%d;%.1f;%.1f\r\n", timestamp, co2, temperature, humidity);
    if (csv_file) {
      size_t written_bytes = csv_file.print(csv_line);
      csv_file.close();
@ -143,7 +148,7 @@ namespace csv_writer {
      } else {
        Serial.print(F("CSV - Wrote : "));
        Serial.print(csv_line);
-        last_successful_write = ntp::getLocalTime();
+        ntp::getLocalTime(last_successful_write);
      }
      updateFsInfo();
      delay(50);
@ -154,11 +159,42 @@ namespace csv_writer {
    led_effects::onBoardLEDOff();
  }
-  void logIfTimeHasCome(const String &timeStamp, const int16_t &co2, const float &temperature, const float &humidity) {
+  void logIfTimeHasCome(const char *timeStamp, const int16_t &co2, const float &temperature, const float &humidity) {
    unsigned long now = seconds();
    if (now - last_written_at > config::csv_interval) {
      last_written_at = now;
      log(timeStamp, co2, temperature, humidity);
    }
  }
  /*****************************************************************
   * Callbacks for sensor commands                                 *
   *****************************************************************/
  void setCSVinterval(int32_t csv_interval) {
    config::csv_interval = csv_interval;
    Serial.print(F("Setting CSV Interval to : "));
    Serial.print(config::csv_interval);
    Serial.println("s.");
    led_effects::showKITTWheel(color::green, 1);
  }
  void showCSVContent() {
    Serial.print(F("### "));
    Serial.print(filename);
    Serial.println(F(" ###"));
    File csv_file;
    if (FS_LIB.exists(filename)) {
      csv_file = FS_LIB.open(filename, "r");
      while (csv_file.available()) {
        Serial.write(csv_file.read());
      }
      csv_file.close();
    }
    Serial.println(F("######################"));
  }
  void formatFilesystem() {
    FS_LIB.format();
    led_effects::showKITTWheel(color::blue, 2);
  }
 }
--- a/ampel-firmware/csv_writer.h
+++ b/ampel-firmware/csv_writer.h
@ -14,16 +14,21 @@
 #include "config.h"
 #include "util.h"
 #include "led_effects.h"
 #include "sensor_console.h"
 namespace config {
  extern uint16_t csv_interval; // [s]
 }
 namespace csv_writer {
-  extern String last_successful_write;
+  extern char last_successful_write[];
-  void initialize();
+  void initialize(const char *sensorId);
-  void logIfTimeHasCome(const String &timeStamp, const int16_t &co2, const float &temperature, const float &humidity);
+  void logIfTimeHasCome(const char *timestamp, const int16_t &co2, const float &temperature, const float &humidity);
  int getAvailableSpace();
-  extern const String filename;
+  extern char filename[];
  void setCSVinterval(int32_t csv_interval);
  void showCSVContent();
  void formatFilesystem();
 }
 #endif
--- a/ampel-firmware/led_effects.cpp
+++ b/ampel-firmware/led_effects.cpp
@ -4,17 +4,36 @@
 *****************************************************************/
 namespace config {
  const uint8_t max_brightness = MAX_BRIGHTNESS;
 #if defined(MIN_BRIGHTNESS)
  const uint8_t min_brightness = MIN_BRIGHTNESS;
-  const int kitt_tail = 3; // How many dimmer LEDs follow in K.I.T.T. wheel
+#else
-}
+  const uint8_t min_brightness = MAX_BRIGHTNESS;
-
+#endif
 /*****************************************************************
 * Configuration  (calculated from above values)                 *
 *****************************************************************/
 namespace config //NOTE: Use a class instead? NightMode could then be another state.
 {
  const uint8_t brightness_amplitude = config::max_brightness - config::min_brightness;
-  bool night_mode = false;
+  const int kitt_tail = 3; // How many dimmer LEDs follow in K.I.T.T. wheel
  const uint16_t poor_air_quality_ppm = 1600; // Above this threshold, LED breathing effect is faster.
  bool night_mode = false; //NOTE: Use a class instead? NightMode could then be another state.
 #if !defined(LED_COUNT)
 #  define LED_COUNT 12
 #endif
  const uint16_t led_count = LED_COUNT;
 #if LED_COUNT == 12
  //NOTE: One value has been prepended, to make calculations easier and avoid out of bounds index.
  const uint16_t co2_ticks[led_count + 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°),
  // LEDs >= 1600ppm will be pure red (hue angle 0°), LEDs in-between will be yellowish.
  const uint16_t led_hues[led_count] = { 21845U, 19114U, 16383U, 13653U, 10922U, 8191U, 5461U, 2730U, 0, 0, 0, 0 }; // [hue angle]
 #elif LED_COUNT == 16
  const uint16_t co2_ticks[led_count + 1] = { 0, 500, 600, 700, 800, 900, 1000, 1100, 1200,
                                              1300, 1400, 1500, 1600, 1700, 1800, 2000, 2200 }; // [ppm]
  const uint16_t led_hues[led_count] = {21845U, 19859U, 17873U, 15887U, 13901U, 11915U, 9929U, 7943U,
                                         5957U, 3971U, 1985U, 0, 0, 0, 0, 0}; // [hue angle]
 #else
 #  error "Only 12 and 16 LEDs rings are currently supported."
 #endif
 }
 #if defined(ESP8266)
@ -25,20 +44,7 @@ const int NEOPIXELS_PIN = 5;
 const int NEOPIXELS_PIN = 23;
 #endif
-const int NUMPIXELS = 12;
+Adafruit_NeoPixel pixels(config::led_count, NEOPIXELS_PIN, NEO_GRB + NEO_KHZ800);
 //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]
 // const uint16_t CO2_TICKS[NUMPIXELS + 1] = { 0, 400, 500, 600, 700, 800, 900, 1000, 1100, 1200, 1300, 1400, 1500, 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.
 // For reference, this python code can be used to generate the array
 //    NUMPIXELS = 12
 //    RED_LEDS = 4
 //    hues = [ (2**16-1) // 3 * max(NUMPIXELS - RED_LEDS - i, 0) // (NUMPIXELS - RED_LEDS) for i in range(NUMPIXELS) ]
 //    '{' + ', '.join([str(hue) + ('U' if hue else '') for hue in hues]) + '}; // [hue angle]'
 const uint16_t LED_HUES[NUMPIXELS] = { 21845U, 19114U, 16383U, 13653U, 10922U, 8191U, 5461U, 2730U, 0, 0, 0, 0 }; // [hue angle]
 // const uint16_t LED_HUES[NUMPIXELS] = { 21845U, 20024U, 18204U, 16383U, 14563U, 12742U, 10922U, 9102U, 7281U, 5461U, 3640U, 1820U, 0, 0, 0, 0 }; // [hue angle]
 Adafruit_NeoPixel pixels(NUMPIXELS, NEOPIXELS_PIN, NEO_GRB + NEO_KHZ800);
 namespace led_effects {
  //On-board LED on D4, aka GPIO02
@ -71,10 +77,19 @@ namespace led_effects {
    onBoardLEDOff();
  }
  void showColor(int32_t color) {
    config::night_mode = true; // In order to avoid overwriting the desired color next time CO2 is displayed
    pixels.setBrightness(255);
    pixels.fill(color);
    pixels.show();
  }
  void setupRing() {
    pixels.begin();
    pixels.setBrightness(config::max_brightness);
    LEDsOff();
    sensor_console::defineCommand("night_mode", toggleNightMode, F("(Toggles night mode on/off)"));
    sensor_console::defineIntCommand("color", showColor, F("0xFF0015 (Shows color, specified as RGB, for debugging)"));
  }
  void toggleNightMode() {
@ -89,14 +104,15 @@ namespace led_effects {
  //NOTE: basically one iteration of KITT wheel
  void showWaitingLED(uint32_t color) {
    using namespace config;
    delay(80);
-    if (config::night_mode) {
+    if (night_mode) {
      return;
    }
    static uint16_t kitt_offset = 0;
    pixels.clear();
-    for (int j = config::kitt_tail; j >= 0; j--) {
+    for (int j = kitt_tail; j >= 0; j--) {
-      int ledNumber = abs((kitt_offset - j + NUMPIXELS) % (2 * NUMPIXELS) - NUMPIXELS) % NUMPIXELS; // Triangular function
+      int ledNumber = abs((kitt_offset - j + led_count) % (2 * led_count) - led_count) % led_count; // Triangular function
      pixels.setPixelColor(ledNumber, color * pixels.gamma8(255 - j * 76) / 255);
    }
    pixels.show();
@ -108,7 +124,7 @@ namespace led_effects {
  // 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) {
+    for (int i = 0; i < duration_s * config::led_count; ++i) {
      showWaitingLED(color);
    }
  }
@ -118,10 +134,10 @@ namespace led_effects {
   * 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]) {
+    if (co2 >= config::co2_ticks[ledId + 1]) {
      return 255;
    } else {
-      if (2 * co2 >= CO2_TICKS[ledId] + CO2_TICKS[ledId + 1]) {
+      if (2 * co2 >= config::co2_ticks[ledId] + config::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 {
@ -131,6 +147,17 @@ namespace led_effects {
    }
  }
  /**
   * If enabled, slowly varies the brightness between MAX_BRIGHTNESS & MIN_BRIGHTNESS.
   */
  void breathe(int16_t co2) {
    static uint8_t breathing_offset = 0;
    uint16_t brightness = config::min_brightness + pixels.sine8(breathing_offset) * config::brightness_amplitude / 255;
    pixels.setBrightness(brightness);
    pixels.show();
    breathing_offset += co2 > config::poor_air_quality_ppm ? 6 : 3; // breathing speed. +3 looks like slow human breathing.
  }
  /**
   * Fills the whole ring with green, yellow, orange or black, depending on co2 input and CO2_TICKS.
   */
@ -139,24 +166,28 @@ namespace led_effects {
      return;
    }
    pixels.setBrightness(config::max_brightness);
-    for (int ledId = 0; ledId < NUMPIXELS; ++ledId) {
+    for (int ledId = 0; ledId < config::led_count; ++ledId) {
      uint8_t brightness = getLedBrightness(co2, ledId);
-      pixels.setPixelColor(ledId, pixels.ColorHSV(LED_HUES[ledId], 255, brightness));
+      pixels.setPixelColor(ledId, pixels.ColorHSV(config::led_hues[ledId], 255, brightness));
    }
    pixels.show();
    if (config::brightness_amplitude > 0) {
      breathe(co2);
    }
  }
-  void showRainbowWheel(uint16_t duration_ms, uint16_t hue_increment) {
+  void showRainbowWheel(uint16_t duration_ms) {
    if (config::night_mode) {
      return;
    }
    static uint16_t wheel_offset = 0;
    static uint16_t sine_offset = 0;
    unsigned long t0 = millis();
    pixels.setBrightness(config::max_brightness);
    while (millis() - t0 < duration_ms) {
-      for (int i = 0; i < NUMPIXELS; i++) {
+      for (int i = 0; i < config::led_count; i++) {
-        pixels.setPixelColor(i, pixels.ColorHSV(i * 65535 / NUMPIXELS + wheel_offset));
+        pixels.setPixelColor(i, pixels.ColorHSV(i * 65535 / config::led_count + wheel_offset));
-        wheel_offset += hue_increment;
+        wheel_offset += (pixels.sine8(sine_offset++ / 50) - 127) / 2;
      }
      pixels.show();
      delay(10);
@ -179,37 +210,28 @@ namespace led_effects {
    }
  }
  void breathe(int16_t co2) {
    if (!config::night_mode) {
      static uint16_t breathing_offset = 0;
      uint16_t brightness = config::min_brightness
          + pixels.sine8(breathing_offset) * config::brightness_amplitude / 255;
      pixels.setBrightness(brightness);
      pixels.show();
      breathing_offset += 3; // breathing speed. +3 looks like slow human breathing.
    }
    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.
+   * Displays a complete blue circle, and starts removing LEDs one by one.
-   * Can be used for calibration, e.g. when countdown is 0. Does not work in night mode.
+   * Does nothing in night mode and returns false then. Returns true if
   * the countdown has finished. Can be used for calibration, e.g. when countdown is 0.
   * NOTE: This function is blocking and returns only after the button has
   * been released or after every LED has been turned off.
   */
-  int countdownToZero() {
+  bool countdownToZero() {
    if (config::night_mode) {
      Serial.println(F("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;
+      return false;
    }
    pixels.fill(color::blue);
    pixels.show();
    int countdown;
-    for (countdown = NUMPIXELS; countdown >= 0 && !digitalRead(0); countdown--) {
+    for (countdown = config::led_count; countdown >= 0 && !digitalRead(0); countdown--) {
      pixels.setPixelColor(countdown, color::black);
      pixels.show();
      Serial.println(countdown);
      delay(500);
    }
-    return countdown;
+    return countdown < 0;
  }
 }
--- a/ampel-firmware/led_effects.h
+++ b/ampel-firmware/led_effects.h
@ -2,6 +2,7 @@
 #define LED_EFFECTS_H_INCLUDED
 #include <Arduino.h>
 #include "config.h"
 #include "sensor_console.h"
 // Adafruit NeoPixel (Arduino library for controlling single-wire-based LED pixels and strip)
 // https://github.com/adafruit/Adafruit_NeoPixel
@ -25,11 +26,10 @@ namespace led_effects {
  void setupRing();
  void redAlert();
-  void breathe(int16_t co2);
+  bool countdownToZero();
  int countdownToZero();
  void showWaitingLED(uint32_t color);
  void showKITTWheel(uint32_t color, uint16_t duration_s = 2);
-  void showRainbowWheel(uint16_t duration_ms = 1000, uint16_t hue_increment = 50);
+  void showRainbowWheel(uint16_t duration_ms = 1000);
  void displayCO2color(uint16_t co2);
 }
 #endif
--- a/ampel-firmware/lorawan.cpp
+++ b/ampel-firmware/lorawan.cpp
@ -33,7 +33,7 @@ void os_getDevKey(u1_t *buf) {
 namespace lorawan {
  bool waiting_for_confirmation = false;
  bool connected = false;
-  String last_transmission = "";
+  char last_transmission[23] = "";
  void initialize() {
    Serial.println(F("Starting LoRaWAN. Frequency plan : " LMIC_FREQUENCY_PLAN " MHz."));
@ -47,11 +47,12 @@ namespace lorawan {
    LMIC_reset();
    // Join, but don't send anything yet.
    LMIC_startJoining();
    sensor_console::defineIntCommand("lora", setLoRaInterval, F("300 (Sets LoRaWAN sending interval, in s)"));
  }
  // Checks if OTAA is connected, or if payload should be sent.
  // NOTE: while a transaction is in process (i.e. until the TXcomplete event has been received, no blocking code (e.g. delay loops etc.) are allowed, otherwise the LMIC/OS code might miss the event.
-  // If this rule is not followed, a typical symptom is that the first send is ok and all following ones end with the TX not complete failure.
+  // If this rule is not followed, a typical symptom is that the first send is ok and all following ones end with the 'TX not complete' failure.
  void process() {
    os_runloop_once();
  }
@ -64,8 +65,10 @@ namespace lorawan {
  }
  void onEvent(ev_t ev) {
    char current_time[23];
    ntp::getLocalTime(current_time);
    Serial.print("LoRa - ");
-    Serial.print(ntp::getLocalTime());
+    Serial.print(current_time);
    Serial.print(" - ");
    switch (ev) {
    case EV_JOINING:
@ -93,7 +96,7 @@ namespace lorawan {
          printHex2(artKey[i]);
        }
        Serial.println();
-        Serial.print("  NwkSKey: ");
+        Serial.print(F("  NwkSKey: "));
        for (size_t i = 0; i < sizeof(nwkKey); ++i) {
          if (i != 0)
            Serial.print("-");
@ -112,7 +115,7 @@ namespace lorawan {
      Serial.println(F("EV_REJOIN_FAILED"));
      break;
    case EV_TXCOMPLETE:
-      last_transmission = ntp::getLocalTime();
+      ntp::getLocalTime(last_transmission);
      Serial.println(F("EV_TXCOMPLETE"));
      break;
    case EV_TXSTART:
@ -189,6 +192,17 @@ namespace lorawan {
      preparePayload(co2, temperature, humidity);
    }
  }
  /*****************************************************************
   * Callbacks for sensor commands                                 *
   *****************************************************************/
  void setLoRaInterval(int32_t sending_interval) {
    config::lorawan_sending_interval = sending_interval;
    Serial.print(F("Setting LoRa sending interval to : "));
    Serial.print(config::lorawan_sending_interval);
    Serial.println("s.");
    led_effects::showKITTWheel(color::green, 1);
  }
 }
 void onEvent(ev_t ev) {
--- a/ampel-firmware/lorawan.h
+++ b/ampel-firmware/lorawan.h
@ -13,7 +13,7 @@
 #include <SPI.h>
 #include "led_effects.h"
-
+#include "sensor_console.h"
 #include "util.h"
 namespace config {
@ -39,10 +39,12 @@ namespace config {
 namespace lorawan {
  extern bool waiting_for_confirmation;
  extern bool connected;
-  extern String last_transmission;
+  extern char last_transmission[];
  void initialize();
  void process();
  void preparePayloadIfTimeHasCome(const int16_t &co2, const float &temp, const float &hum);
  void setLoRaInterval(int32_t sending_interval);
 }
 #endif
--- a/ampel-firmware/mqtt.cpp
+++ b/ampel-firmware/mqtt.cpp
@ -2,7 +2,7 @@
 namespace config {
  // Values should be defined in config.h
-  uint16_t sending_interval = MQTT_SENDING_INTERVAL; // [s]
+  uint16_t mqtt_sending_interval = MQTT_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;
@ -23,31 +23,34 @@ namespace mqtt {
  unsigned long last_failed_at = 0;
  bool connected = false;
-  String publish_topic;
+  char publish_topic[21]; // e.g. "CO2sensors/ESPxxxxxx\0"
  const char *json_sensor_format;
-  String last_successful_publish = "";
+  char last_successful_publish[23] = "";
-  void initialize(String &topic) {
+  void initialize(const char *sensorId) {
    json_sensor_format = PSTR("{\"time\":\"%s\", \"co2\":%d, \"temp\":%.1f, \"rh\":%.1f}");
-    publish_topic = topic;
+    snprintf(publish_topic, sizeof(publish_topic), "CO2sensors/%s", sensorId);
-#if defined(ESP8266)
+    // The sensor doesn't check the fingerprint of the MQTT broker, because otherwise this fingerprint should be updated
-    espClient.setInsecure(); // Sorry, we don't want to flash the sensors every 3 months.
+    // on the sensor every 3 months. The connection can still be encrypted, though:
-#endif
+    espClient.setInsecure(); // If not available for ESP32, please update Arduino IDE / PlatformIO
    // mqttClient.setSocketTimeout(config::mqtt_timeout); //NOTE: somehow doesn't seem to have any effect on connect()
    mqttClient.setServer(config::mqtt_server, config::mqtt_port);
    sensor_console::defineIntCommand("mqtt", setMQTTinterval, F("60 (Sets MQTT sending interval, in s)"));
    sensor_console::defineCommand("send_local_ip", sendInfoAboutLocalNetwork,
        F("(Sends local IP and SSID via MQTT. Can be useful to find sensor)"));
  }
-  void publish(const String &timestamp, int16_t co2, float temperature, float humidity) {
+  void publish(const char *timestamp, int16_t co2, float temperature, float humidity) {
    if (WiFi.status() == WL_CONNECTED && mqttClient.connected()) {
      led_effects::onBoardLEDOn();
      Serial.print(F("MQTT - Publishing message ... "));
      char payload[75]; // Should be enough for json...
-      snprintf(payload, sizeof(payload), json_sensor_format, timestamp.c_str(), co2, temperature, humidity);
+      snprintf(payload, sizeof(payload), json_sensor_format, timestamp, co2, temperature, humidity);
      // Topic is the same as clientID. e.g. 'CO2sensors/ESP3d03da'
-      if (mqttClient.publish(publish_topic.c_str(), payload)) {
+      if (mqttClient.publish(publish_topic, payload)) {
        Serial.println(F("OK"));
-        last_successful_publish = ntp::getLocalTime();
+        ntp::getLocalTime(last_successful_publish);
      } else {
        Serial.println(F("Failed."));
      }
@ -55,69 +58,6 @@ namespace mqtt {
    }
  }
  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();
      led_effects::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.");
    led_effects::showKITTWheel(color::green, 1);
  }
 #ifdef AMPEL_CSV
  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.");
    led_effects::showKITTWheel(color::green, 1);
  }
 #endif
  void calibrateSensorToSpecificPPM(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/ESPd03cc5/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
   *
@ -132,46 +72,13 @@ namespace mqtt {
    }
    led_effects::onBoardLEDOn();
    Serial.print(F("Message arrived on topic: "));
-    Serial.print(sub_topic);
+    Serial.println(sub_topic);
-    Serial.print(F(". Message: '"));
+    char command[length + 1];
    String messageString;
    for (unsigned int i = 0; i < length; i++) {
-      Serial.print((char) message[i]);
+      command[i] = message[i];
      messageString += (char) message[i];
    }
-    Serial.println("'.");
+    command[length] = 0;
-
+    sensor_console::execute(command);
    if (messageString.startsWith("co2 ")) {
      setCO2forDebugging(messageString);
    } else if (messageString.startsWith("timer ")) {
      setTimer(messageString);
    } else if (messageString == "calibrate") {
      sensor::startCalibrationProcess();
    } else if (messageString.startsWith("calibrate ")) {
      calibrateSensorToSpecificPPM(messageString);
    } else if (messageString.startsWith("mqtt ")) {
      setMQTTinterval(messageString);
    } else if (messageString == "publish") {
      Serial.println(F("Forcing MQTT publish now."));
      publish(sensor::timestamp, sensor::co2, sensor::temperature, sensor::humidity);
 #ifdef AMPEL_CSV
    } else if (messageString.startsWith("csv ")) {
      setCSVinterval(messageString);
    } else if (messageString == "format_filesystem") {
      FS_LIB.format();
      led_effects::showKITTWheel(color::blue, 2);
 #endif
    } else if (messageString == "night_mode") {
      led_effects::toggleNightMode();
    } else if (messageString == "local_ip") {
      sendInfoAboutLocalNetwork();
    } else if (messageString == "reset") {
      ESP.restart(); // softer than ESP.reset()
    } else {
      led_effects::showKITTWheel(color::red, 1);
      Serial.println(F("Message not supported. Doing nothing."));
    }
    delay(50);
    led_effects::onBoardLEDOff();
  }
@ -188,7 +95,7 @@ namespace mqtt {
    led_effects::onBoardLEDOn();
    // Wait for connection, at most 15s (default)
-    mqttClient.connect(publish_topic.c_str(), config::mqtt_user, config::mqtt_password);
+    mqttClient.connect(publish_topic, config::mqtt_user, config::mqtt_password);
    led_effects::onBoardLEDOff();
    connected = mqttClient.connected();
@ -196,7 +103,7 @@ namespace mqtt {
    if (connected) {
      if (config::allow_mqtt_commands) {
        char control_topic[60]; // Should be enough for "CO2sensors/ESPd03cc5/control"
-        snprintf(control_topic, sizeof(control_topic), "%s/control", publish_topic.c_str());
+        snprintf(control_topic, sizeof(control_topic), "%s/control", publish_topic);
        mqttClient.subscribe(control_topic);
        mqttClient.setCallback(controlSensorCallback);
      }
@ -212,12 +119,12 @@ namespace mqtt {
    }
  }
-  void publishIfTimeHasCome(const String &timeStamp, const int16_t &co2, const float &temp, const float &hum) {
+  void publishIfTimeHasCome(const char *timestamp, const int16_t &co2, const float &temp, const float &hum) {
    // Send message via MQTT according to sending interval
    unsigned long now = seconds();
-    if (now - last_sent_at > config::sending_interval) {
+    if (now - last_sent_at > config::mqtt_sending_interval) {
      last_sent_at = now;
-      publish(timeStamp, co2, temp, hum);
+      publish(timestamp, co2, temp, hum);
    }
  }
@ -229,4 +136,28 @@ namespace mqtt {
    mqttClient.loop();
  }
  /*****************************************************************
   * Callbacks for sensor commands                                 *
   *****************************************************************/
  void setMQTTinterval(int32_t sending_interval) {
    config::mqtt_sending_interval = sending_interval;
    Serial.print(F("Setting MQTT sending interval to : "));
    Serial.print(config::mqtt_sending_interval);
    Serial.println("s.");
    led_effects::showKITTWheel(color::green, 1);
  }
  // It can be hard to find the local IP of a sensor if it isn't connected to Serial port, and if mDNS is disabled.
  // If the sensor can be reach by MQTT, it can answer with info about local_ip and ssid.
  // The sensor will send the info to "CO2sensors/ESP123456/info".
  void sendInfoAboutLocalNetwork() {
    char info_topic[60]; // Should be enough for "CO2sensors/ESP123456/info"
    snprintf(info_topic, sizeof(info_topic), "%s/info", publish_topic);
    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::local_ip, WIFI_SSID);
    mqttClient.publish(info_topic, payload);
  }
 }
--- a/ampel-firmware/mqtt.h
+++ b/ampel-firmware/mqtt.h
@ -4,20 +4,22 @@
 #include <Arduino.h>
 #include "config.h"
 #include "led_effects.h"
-#ifdef AMPEL_CSV
+#include "sensor_console.h"
 #  include "csv_writer.h"
 #endif
 #include "co2_sensor.h"
 #include "src/lib/PubSubClient/src/PubSubClient.h"
 #include "wifi_util.h"
 namespace config {
-  extern uint16_t sending_interval; // [s]
+  extern uint16_t mqtt_sending_interval; // [s]
 }
 namespace mqtt {
-  extern String last_successful_publish;
+  extern char last_successful_publish[];
  extern bool connected;
-  void initialize(String &topic);
+  void initialize(const char *sensorId);
  void keepConnection();
-  void publishIfTimeHasCome(const String &timeStamp, const int16_t &co2, const float &temp, const float &hum);
+  void publishIfTimeHasCome(const char *timestamp, const int16_t &co2, const float &temp, const float &hum);
  void setMQTTinterval(int32_t sending_interval);
  void sendInfoAboutLocalNetwork();
 }
 #endif
--- a/ampel-firmware/sensor_console.cpp
+++ b/ampel-firmware/sensor_console.cpp
@ -0,0 +1,188 @@
 #include "sensor_console.h"
 namespace sensor_console {
  const uint8_t MAX_COMMANDS = 20;
  const uint8_t MAX_COMMAND_SIZE = 30;
  uint8_t commands_count = 0;
  enum input_type {
    NONE,
    INT32,
    STRING
  };
  struct Command {
    const char *name;
    union {
      void (*voidFunction)();
      void (*intFunction)(int32_t);
      void (*strFunction)(char*);
    };
    const char *doc;
    input_type parameter_type;
  };
  struct CommandLine {
    char function_name[MAX_COMMAND_SIZE];
    input_type argument_type;
    int32_t int_argument;
    char str_argument[MAX_COMMAND_SIZE];
  };
  Command commands[MAX_COMMANDS];
  bool addCommand(const char *name, const __FlashStringHelper *doc_fstring) {
    if (commands_count < MAX_COMMANDS) {
      commands[commands_count].name = name;
      commands[commands_count].doc = (const char*) doc_fstring;
      return true;
    } else {
      Serial.println(F("Too many commands have been defined."));
      return false;
    }
  }
  void defineCommand(const char *name, void (*function)(), const __FlashStringHelper *doc_fstring) {
    if (addCommand(name, doc_fstring)) {
      commands[commands_count].voidFunction = function;
      commands[commands_count++].parameter_type = NONE;
    }
  }
  void defineIntCommand(const char *name, void (*function)(int32_t), const __FlashStringHelper *doc_fstring) {
    if (addCommand(name, doc_fstring)) {
      commands[commands_count].intFunction = function;
      commands[commands_count++].parameter_type = INT32;
    }
  }
  void defineStringCommand(const char *name, void (*function)(char*), const __FlashStringHelper *doc_fstring) {
    if (addCommand(name, doc_fstring)) {
      commands[commands_count].strFunction = function;
      commands[commands_count++].parameter_type = STRING;
    }
  }
  /*
   * Tries to split a string command (e.g. 'mqtt 60' or 'show_csv') into
   * a CommandLine struct (function_name, argument_type and argument)
   */
  void parseCommand(const char *command, CommandLine &command_line) {
    if (strlen(command) == 0) {
      Serial.println(F("Received empty command"));
      command_line.argument_type = NONE;
      return;
    }
    char *first_space;
    first_space = strchr(command, ' ');
    if (first_space == NULL) {
      command_line.argument_type = NONE;
      strlcpy(command_line.function_name, command, MAX_COMMAND_SIZE);
      return;
    }
    strlcpy(command_line.function_name, command, first_space - command + 1);
    strlcpy(command_line.str_argument, first_space + 1, MAX_COMMAND_SIZE - (first_space - command) - 1);
    char *end;
    command_line.int_argument = strtol(command_line.str_argument, &end, 0); // Accepts 123 or 0xFF00FF
    if (*end) {
      command_line.argument_type = STRING;
    } else {
      command_line.argument_type = INT32;
    }
  }
  int compareCommandNames(const void *s1, const void *s2) {
    struct Command *c1 = (struct Command*) s1;
    struct Command *c2 = (struct Command*) s2;
    return strcmp(c1->name, c2->name);
  }
  void listAvailableCommands() {
    qsort(commands, commands_count, sizeof(commands[0]), compareCommandNames);
    for (uint8_t i = 0; i < commands_count; i++) {
      Serial.print(F("  "));
      Serial.print(commands[i].name);
      Serial.print(F(" "));
      Serial.print(commands[i].doc);
      Serial.println(F("."));
    }
  }
  /*
   * Saves bytes from Serial.read() until enter is pressed, and tries to run the corresponding command.
   *   http://www.gammon.com.au/serial
   */
  void processSerialInput(const byte input_byte) {
    static char input_line[MAX_COMMAND_SIZE];
    static unsigned int input_pos = 0;
    switch (input_byte) {
    case '\n': // end of text
      Serial.println();
      input_line[input_pos] = 0;
      execute(input_line);
      input_pos = 0;
      break;
    case '\r': // discard carriage return
      break;
    case '\b': // backspace
      if (input_pos > 0) {
        input_pos--;
        Serial.print(F("\b \b"));
      }
      break;
    default:
      if (input_pos == 0) {
        Serial.print(F("> "));
      }
      // keep adding if not full ... allow for terminating null byte
      if (input_pos < (MAX_COMMAND_SIZE - 1)) {
        input_line[input_pos++] = input_byte;
        Serial.print((char) input_byte);
      }
      break;
    }
  }
  /*
   * Tries to find the corresponding callback for a given command. Name and parameter type should fit.
   */
  void execute(const char *command_str) {
    CommandLine input;
    parseCommand(command_str, input);
    for (uint8_t i = 0; i < commands_count; i++) {
      if (!strcmp(input.function_name, commands[i].name) && input.argument_type == commands[i].parameter_type) {
        Serial.print(F("Calling : "));
        Serial.print(input.function_name);
        switch (input.argument_type) {
        case NONE:
          Serial.println(F("()"));
          commands[i].voidFunction();
          return;
        case INT32:
          Serial.print(F("("));
          Serial.print(input.int_argument);
          Serial.println(F(")"));
          commands[i].intFunction(input.int_argument);
          return;
        case STRING:
          Serial.print(F("('"));
          Serial.print(input.str_argument);
          Serial.println(F("')"));
          commands[i].strFunction(input.str_argument);
          return;
        }
      }
    }
    Serial.print(F("'"));
    Serial.print(command_str);
    Serial.println(F("' not supported. Available commands :"));
    listAvailableCommands();
  }
 }
--- a/ampel-firmware/sensor_console.h
+++ b/ampel-firmware/sensor_console.h
@ -0,0 +1,20 @@
 #ifndef SENSOR_CONSOLE_H_INCLUDED
 #define SENSOR_CONSOLE_H_INCLUDED
 #include <Arduino.h>
 /** Other scripts can use this namespace, in order to define commands, via callbacks.
 * Those callbacks can then be used to send commands to the sensor (reset, calibrate, night mode, ...)
 * The callbacks can either have no parameter, or one int32_t parameter.
 */
 namespace sensor_console {
  void defineCommand(const char *name, void (*function)(), const __FlashStringHelper *doc_fstring);
  void defineIntCommand(const char *name, void (*function)(int32_t), const __FlashStringHelper *doc_fstring);
  void defineStringCommand(const char *name, void (*function)(char*), const __FlashStringHelper *doc_fstring);
  void processSerialInput(const byte in_byte);
  void execute(const char *command_line);
 }
 #endif
--- a/ampel-firmware/src/lib/NTPClient-master/NTPClient.cpp
+++ b/ampel-firmware/src/lib/NTPClient-master/NTPClient.cpp
@ -152,19 +152,17 @@ int NTPClient::getSeconds() {
  return (this->getEpochTime() % 60);
 }
-String NTPClient::getFormattedTime(unsigned long secs) {
+void NTPClient::getFormattedTime(char *formatted_time, unsigned long secs) {
  unsigned long rawTime = secs ? secs : this->getEpochTime();
  unsigned int hours = (rawTime % 86400L) / 3600;
  unsigned int minutes = (rawTime % 3600) / 60;
  unsigned int seconds = rawTime % 60;
-  char formatted_time[9];
+  snprintf(formatted_time, 9, "%02d:%02d:%02d", hours, minutes, seconds);
  snprintf(formatted_time, sizeof(formatted_time), "%02d:%02d:%02d", hours, minutes, seconds);
  return String(formatted_time);
 }
 // Based on https://github.com/PaulStoffregen/Time/blob/master/Time.cpp
-String NTPClient::getFormattedDate(unsigned long secs) {
+void NTPClient::getFormattedDate(char *formatted_date, unsigned long secs) {
  unsigned long rawTime = (secs ? secs : this->getEpochTime()) / 86400L;  // in days
  unsigned long days = 0, year = 1970;
  uint8_t month;
@ -187,11 +185,9 @@ String NTPClient::getFormattedDate(unsigned long secs) {
  month++; // jan is month 1
  rawTime++; // first day is day 1
-  char formatted_date[23];
+  char formatted_time[9];
-  snprintf(formatted_date, sizeof(formatted_date), "%4lu-%02d-%02lu %s%+03d",
+  this->getFormattedTime(formatted_time, secs);
-      year, month, rawTime, this->getFormattedTime(secs).c_str(), this->_timeOffset / 3600);
+  snprintf(formatted_date, 23, "%4lu-%02d-%02lu %s%+03d", year, month, rawTime, formatted_time, this->_timeOffset / 3600);
  return String(formatted_date);
 }
 void NTPClient::end() {
--- a/ampel-firmware/src/lib/NTPClient-master/NTPClient.h
+++ b/ampel-firmware/src/lib/NTPClient-master/NTPClient.h
@ -80,7 +80,7 @@ class NTPClient {
    /**
    * @return secs argument (or 0 for current time) formatted like `hh:mm:ss`
    */
-    String getFormattedTime(unsigned long secs = 0);
+    void getFormattedTime(char *formatted_time, unsigned long secs = 0);
    /**
     * @return time in seconds since Jan. 1, 1970
@ -91,7 +91,7 @@ class NTPClient {
    * @return secs argument (or 0 for current date) formatted to ISO 8601
    * like `2004-02-12T15:19:21+00:00`
    */
-    String getFormattedDate(unsigned long secs = 0);
+    void getFormattedDate(char *formatted_date, unsigned long secs = 0);
    /**
     * Stops the underlying UDP client
--- a/ampel-firmware/src/lib/SparkFun_SCD30_Arduino_Library/LICENSE.md
+++ b/ampel-firmware/src/lib/SparkFun_SCD30_Arduino_Library/LICENSE.md
@ -34,7 +34,7 @@ Code
 The MIT License (MIT)
-Copyright (c) 2016 SparkFun Electronics
+Copyright (c) 2020 SparkFun Electronics
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
--- a/ampel-firmware/src/lib/SparkFun_SCD30_Arduino_Library/README.md
+++ b/ampel-firmware/src/lib/SparkFun_SCD30_Arduino_Library/README.md
@ -24,6 +24,7 @@ Thanks to!
 * [awatterott](https://github.com/awatterott) for adding [getAltitudeCompensation()](https://github.com/sparkfun/SparkFun_SCD30_Arduino_Library/pull/18)
 * [jogi-k](https://github.com/jogi-k) for adding [teensy i2clib](https://github.com/sparkfun/SparkFun_SCD30_Arduino_Library/pull/19) support
 * [paulvha](https://github.com/paulvha) for the suggestions and corrections in [his version of the library](https://github.com/paulvha/scd30)
 * [yamamaya](https://github.com/yamamaya) for the [3ms delay](https://github.com/sparkfun/SparkFun_SCD30_Arduino_Library/pull/24)
 Repository Contents
 -------------------
@ -43,8 +44,6 @@ License Information
 This product is _**open source**_!
 Various bits of the code have different licenses applied. Anything SparkFun wrote is beerware; if you see me (or any other SparkFun employee) at the local, and you've found our code helpful, please buy us a round!
 Please use, reuse, and modify these files as you see fit. Please maintain attribution to SparkFun Electronics and release anything derivative under the same license.
 Distributed as-is; no warranty is given.
--- a/ampel-firmware/src/lib/SparkFun_SCD30_Arduino_Library/library.properties
+++ b/ampel-firmware/src/lib/SparkFun_SCD30_Arduino_Library/library.properties
@ -1,5 +1,5 @@
 name=SparkFun SCD30 Arduino Library
-version=1.0.11
+version=1.0.13
 author=SparkFun Electronics
 maintainer=SparkFun Electronics <sparkfun.com>
 sentence=Library for the Sensirion SCD30 CO2 Sensor
--- a/ampel-firmware/src/lib/SparkFun_SCD30_Arduino_Library/src/SparkFun_SCD30_Arduino_Library.cpp
+++ b/ampel-firmware/src/lib/SparkFun_SCD30_Arduino_Library/src/SparkFun_SCD30_Arduino_Library.cpp
@ -266,6 +266,8 @@ bool SCD30::readMeasurement()
  if (_i2cPort->endTransmission() != 0)
    return (0); //Sensor did not ACK
  delay(3);
  const uint8_t receivedBytes = _i2cPort->requestFrom((uint8_t)SCD30_ADDRESS, (uint8_t)18);
  bool error = false;
  if (_i2cPort->available())
@ -358,6 +360,8 @@ bool SCD30::getSettingValue(uint16_t registerAddress, uint16_t *val)
  if (_i2cPort->endTransmission() != 0)
    return (false); //Sensor did not ACK
  delay(3);
  _i2cPort->requestFrom((uint8_t)SCD30_ADDRESS, (uint8_t)3); // Request data and CRC
  if (_i2cPort->available())
  {
@ -389,6 +393,8 @@ uint16_t SCD30::readRegister(uint16_t registerAddress)
  if (_i2cPort->endTransmission() != 0)
    return (0); //Sensor did not ACK
  delay(3);
  _i2cPort->requestFrom((uint8_t)SCD30_ADDRESS, (uint8_t)2);
  if (_i2cPort->available())
  {
--- a/ampel-firmware/src/lib/SparkFun_SCD30_Arduino_Library/src/SparkFun_SCD30_Arduino_Library.h
+++ b/ampel-firmware/src/lib/SparkFun_SCD30_Arduino_Library/src/SparkFun_SCD30_Arduino_Library.h
@ -57,9 +57,10 @@
 #define COMMAND_STOP_MEAS 0x0104
 #define COMMAND_READ_FW_VER 0xD100
-typedef union {
+typedef union
-    byte array[4];
+{
-    float value;
+	byte array[4];
 	float value;
 } ByteToFl; // paulvha
 class SCD30
@ -69,9 +70,9 @@ public:
 	bool begin(bool autoCalibrate) { return begin(Wire, autoCalibrate); }
 #ifdef USE_TEENSY3_I2C_LIB
-	bool begin(i2c_t3 &wirePort = Wire, bool autoCalibrate=true, bool measBegin=true); //By default use Wire port
+	bool begin(i2c_t3 &wirePort = Wire, bool autoCalibrate = false, bool measBegin = true); //By default use Wire port
 #else
-	bool begin(TwoWire &wirePort = Wire, bool autoCalibrate=true, bool measBegin=true); //By default use Wire port
+	bool begin(TwoWire &wirePort = Wire, bool autoCalibrate = false, bool measBegin = true); //By default use Wire port
 #endif
 	void enableDebugging(Stream &debugPort = Serial); //Turn on debug printing. If user doesn't specify then Serial will be used.
@ -82,11 +83,11 @@ public:
 	// based on paulvha
 	bool getSettingValue(uint16_t registerAddress, uint16_t *val);
-	bool getForcedRecalibration(uint16_t *val) {return(getSettingValue(COMMAND_SET_FORCED_RECALIBRATION_FACTOR, val));}
+	bool getForcedRecalibration(uint16_t *val) { return (getSettingValue(COMMAND_SET_FORCED_RECALIBRATION_FACTOR, val)); }
-	bool getMeasurementInterval(uint16_t *val) {return(getSettingValue(COMMAND_SET_MEASUREMENT_INTERVAL, val));}
+	bool getMeasurementInterval(uint16_t *val) { return (getSettingValue(COMMAND_SET_MEASUREMENT_INTERVAL, val)); }
-	bool getTemperatureOffset(uint16_t *val) {return(getSettingValue(COMMAND_SET_TEMPERATURE_OFFSET, val));}
+	bool getTemperatureOffset(uint16_t *val) { return (getSettingValue(COMMAND_SET_TEMPERATURE_OFFSET, val)); }
-	bool getAltitudeCompensation(uint16_t *val) {return(getSettingValue(COMMAND_SET_ALTITUDE_COMPENSATION, val));}
+	bool getAltitudeCompensation(uint16_t *val) { return (getSettingValue(COMMAND_SET_ALTITUDE_COMPENSATION, val)); }
-	bool getFirmwareVersion(uint16_t *val) {return(getSettingValue(COMMAND_READ_FW_VER, val));}
+	bool getFirmwareVersion(uint16_t *val) { return (getSettingValue(COMMAND_READ_FW_VER, val)); }
 	uint16_t getCO2(void);
 	float getHumidity(void);
@ -115,12 +116,11 @@ public:
 	uint8_t computeCRC8(uint8_t data[], uint8_t len);
 private:
 	//Variables
 #ifdef USE_TEENSY3_I2C_LIB
 	i2c_t3 *_i2cPort; //The generic connection to user's chosen I2C hardware
 #else
-	TwoWire *_i2cPort; //The generic connection to user's chosen I2C hardware
+	TwoWire *_i2cPort;																		 //The generic connection to user's chosen I2C hardware
 #endif
 	//Global main datums
 	float co2 = 0;
@ -136,6 +136,5 @@ private:
 	//Debug
 	Stream *_debugPort;			 //The stream to send debug messages to if enabled. Usually Serial.
 	boolean _printDebug = false; //Flag to print debugging variables
 };
 #endif
--- a/ampel-firmware/util.cpp
+++ b/ampel-firmware/util.cpp
@ -5,41 +5,96 @@ namespace config {
  const long utc_offset_in_seconds = UTC_OFFSET_IN_SECONDS; // UTC+1
 }
-// Get last 3 bytes of ESP MAC (worldwide unique)
+#if defined(ESP8266)
-String macToID() {
+const char *current_board = "ESP8266";
-  uint8_t mac[6];
+#  if !defined(AMPEL_WIFI)
-  WiFi.macAddress(mac);
+void preinit() {
-  String result;
+  // WiFi would be initialized otherwise (on ESP8266), even if unused.
-  for (int i = 3; i < 6; i++) {
+  // see https://github.com/esp8266/Arduino/issues/2111#issuecomment-224251391
-    if (mac[i] < 16)
+  ESP8266WiFiClass::preinitWiFiOff();
      result += '0';
    result += String(mac[i], HEX);
  }
  result.toLowerCase();
  return result;
 }
 #  endif
 #elif defined(ESP32)
 const char *current_board = "ESP32";
 #else
 const char *current_board = "UNKNOWN";
 #endif
 //NOTE: ESP32 sometimes couldn't access the NTP server, and every loop would take +1000ms
 // ifdefs could be used to define functions specific to ESP32, e.g. with configTime
 namespace ntp {
  WiFiUDP ntpUDP;
  NTPClient timeClient(ntpUDP, config::ntp_server, config::utc_offset_in_seconds, 60000UL);
  bool connected_at_least_once = false;
  void initialize() {
    timeClient.begin();
  }
  void update() {
-    timeClient.update();
+    connected_at_least_once |= timeClient.update();
  }
-  String getLocalTime() {
+  void getLocalTime(char *timestamp) {
-    return timeClient.getFormattedDate();
+    timeClient.getFormattedDate(timestamp);
  }
  void setLocalTime(int32_t unix_seconds) {
    char time[23];
    timeClient.getFormattedDate(time);
    Serial.print(F("Current time : "));
    Serial.println(time);
    if (connected_at_least_once) {
      Serial.println(F("NTP update already happened. Not changing anything."));
      return;
    }
    Serial.print(F("Setting UNIX time to : "));
    Serial.println(unix_seconds);
    timeClient.setEpochTime(unix_seconds - seconds());
    timeClient.getFormattedDate(time);
    Serial.print(F("Current time : "));
    Serial.println(time);
  }
 }
-uint32_t max_loop_duration = 0;
+void Ampel::showFreeSpace() {
  Serial.print(F("Free heap space : "));
  Serial.print(ESP.getFreeHeap());
  Serial.println(F(" bytes."));
  Serial.print(F("Max free block size : "));
  Serial.print(esp_get_max_free_block_size());
  Serial.println(F(" bytes."));
  Serial.print(F("Heap fragmentation : "));
  Serial.print(esp_get_heap_fragmentation());
  Serial.println(F(" %"));
 }
-//FIXME: Remove every instance of Strings, to avoid heap fragmentation problems. (Start:  "Free heap space : 17104 bytes")
+char sensorId[10]; // e.g "ESPxxxxxx\0"
-// See more https://cpp4arduino.com/2020/02/07/how-to-format-strings-without-the-string-class.html
+char macAddress[18]; // e.g "XX:XX:XX:XX:XX:XX\0"
-const String SENSOR_ID = "ESP" + macToID();
+uint8_t mac[6];
 char* getMacString() {
  WiFi.macAddress(mac);
  // Get all 6 bytes of ESP MAC
  snprintf(macAddress, sizeof(macAddress), "%02X:%02X:%02X:%02X:%02X:%02X", mac[0], mac[1], mac[2], mac[3], mac[4],
      mac[5]);
  return macAddress;
 }
 char* getSensorId() {
  WiFi.macAddress(mac);
  // Get last 3 bytes of ESP MAC (worldwide unique)
  snprintf(sensorId, sizeof(sensorId), "ESP%02x%02x%02x", mac[3], mac[4], mac[5]);
  return sensorId;
 }
 Ampel::Ampel() :
    board(current_board), sensorId(getSensorId()), macAddress(getMacString()), max_loop_duration(0) {
  sensor_console::defineIntCommand("set_time", ntp::setLocalTime, F("1618829570 (Sets time to the given UNIX time)"));
  sensor_console::defineCommand("free", Ampel::showFreeSpace, F("(Displays available heap space)"));
  sensor_console::defineCommand("reset", []() {
    ESP.restart();
  }, F("(Restarts the ESP)"));
 }
 Ampel ampel;
--- a/ampel-firmware/util.h
+++ b/ampel-firmware/util.h
@ -2,26 +2,25 @@
 #define AMPEL_UTIL_H_INCLUDED
 #include <Arduino.h>
 #include "config.h"
 #include "sensor_console.h"
 #include <WiFiUdp.h> // required for NTP
 #include "src/lib/NTPClient-master/NTPClient.h" // NTP
 #if defined(ESP8266)
 #  define BOARD "ESP8266"
 #  include <ESP8266WiFi.h> // required to get MAC address
-#  define get_free_heap_size() system_get_free_heap_size()
+#  define esp_get_max_free_block_size() ESP.getMaxFreeBlockSize()
 #  define esp_get_heap_fragmentation() ESP.getHeapFragmentation()
 #elif defined(ESP32)
 #  define BOARD "ESP32"
 #  include <WiFi.h> // required to get MAC address
-#  define get_free_heap_size() esp_get_free_heap_size()
+#  define esp_get_max_free_block_size() ESP.getMaxAllocHeap() //largest block of heap that can be allocated.
-#else
+#  define esp_get_heap_fragmentation() "?" // apparently not available for ESP32
 #  define BOARD "Unknown"
 #endif
 namespace ntp {
  void initialize();
  void update();
-  String getLocalTime();
+  void getLocalTime(char *timestamp);
 }
 namespace util {
@ -35,10 +34,21 @@ namespace util {
    return b > a ? b : a;
  }
 }
 class Ampel {
 private:
  static void showFreeSpace();
 public:
  const char *version = "v0.2.3-DEV"; // Update manually after significant changes.
  const char *board;
  const char *sensorId;
  const char *macAddress;
  uint32_t max_loop_duration;
  Ampel();
 };
 extern Ampel ampel;
 //NOTE: Only use seconds() for duration comparison, not timestamps comparison. Otherwise, problems happen when millis roll over.
 #define seconds() (millis() / 1000UL)
 extern uint32_t max_loop_duration;
 const extern String SENSOR_ID;
 #endif
--- a/ampel-firmware/web_server.cpp
+++ b/ampel-firmware/web_server.cpp
@ -22,6 +22,7 @@ namespace web_server {
  const char *script_template;
  void handleWebServerRoot();
  void handlePageNotFound();
  void handleWebServerCommand();
 #ifdef AMPEL_CSV
  void handleDeleteCSV();
@ -58,13 +59,13 @@ namespace web_server {
            "</head>\n"
            "<body>\n"
-            "<div class='pure-g'><div class='pure-u-1'><div class='pure-menu'><p class='pure-menu-heading'>MakerLab Murnau e.V. CO<sub>2</sub> Ampel</p></div></div>\n"
+            "<div class='pure-g'><div class='pure-u-1'><div class='pure-menu'><p class='pure-menu-heading'>HfT-Stuttgart CO<sub>2</sub> Ampel</p></div></div>\n"
            "<div class='pure-u-1'><ul class='pure-menu pure-menu-horizontal pure-menu-list'>\n"
            "<li class='pure-menu-item'><a href='#table' class='pure-menu-link'>Info</a></li>\n"
 #ifdef AMPEL_CSV
            "<li class='pure-menu-item'><a href='#graph' class='pure-menu-link'>Graph</a></li>\n"
            "<li class='pure-menu-item'><a href='#log' class='pure-menu-link'>Log</a></li>\n"
-            "<li class='pure-menu-item'><a href='./%s' class='pure-menu-link'>Download CSV</a></li>\n"
+            "<li class='pure-menu-item'><a href='%s' class='pure-menu-link'>Download CSV</a></li>\n"
 #endif
            "<li class='pure-menu-item' id='led'>&#11044;</li>\n" // LED
            "</ul></div></div>\n"
@ -72,16 +73,15 @@ namespace web_server {
            // Show a colored dot on the webpage, with a similar color than on LED Ring.
            "hue=(1-(Math.min(Math.max(parseInt(document.title),500),1600)-500)/1100)*120;\n"
            "document.getElementById('led').style.color=['hsl(',hue,',100%%,50%%)'].join('');\n"
-            "</script>\n");
+            "</script>\n"
-
+            "<div class='pure-g'>\n"
-    body_template =
+            "<div class='pure-u-1' id='graph'></div>\n"// Graph placeholder
        PSTR("<div class='pure-g'>\n"
            "<div class='pure-u-1' id='graph'></div>\n" // Graph placeholder
            "</div>\n"
            "<div class='pure-g'>\n"
-            //Sensor table
+            "<table id='table' class='pure-table-striped pure-u-1 pure-u-md-1-2'>\n");
-            "<table id='table' class='pure-table-striped pure-u-1 pure-u-md-1-2'>\n"
+
-            "<tr><th colspan='2'>%s</th></tr>\n"
+    body_template =
        PSTR("<tr><th colspan='2'>%s</th></tr>\n"
            "<tr><td>CO<sub>2</sub> concentration</td><td>%5d ppm</td></tr>\n"
            "<tr><td>Temperature</td><td>%.1f&#8451;</td></tr>\n"
            "<tr><td>Humidity</td><td>%.1f%%</td></tr>\n"
@ -108,14 +108,19 @@ namespace web_server {
 #endif
            "<tr><th colspan='2'>Sensor</th></tr>\n"
            "<tr><td>Temperature offset</td><td>%.1fK</td></tr>\n" //TODO: Read it from sensor?
            "<tr><td>Auto-calibration?</td><td>%s</td></tr>\n"
            "<tr><td>Local address</td><td><a href='http://%s.local/'>%s.local</a></td></tr>\n"
            "<tr><td>Local IP</td><td><a href='http://%s'>%s</a></td></tr>\n"
            "<tr><td>MAC</td><td>%s</td></tr>\n"
            "<tr><td>Free heap space</td><td>%6d bytes</td></tr>\n"
            "<tr><td>Largest heap block</td><td>%6d bytes</td></tr>\n"
            "<tr><td>Max loop duration</td><td>%5d ms</td></tr>\n"
            "<tr><td>Board</td><td>%s</td></tr>\n"
            "<tr><td>Ampel firmware</td><td>%s</td></tr>\n"
            "<tr><td>Uptime</td><td>%2d d %4d h %02d min %02d s</td></tr>\n"
            "</table>\n"
            "<div id='log' class='pure-u-1 pure-u-md-1-2'></div>\n"
            "<form action='/command'><input type='text' id='send' name='send'><input type='submit' value='Send'></form>\n"
 #ifdef AMPEL_CSV
            "<form action='/delete_csv' method='POST' onsubmit=\"return confirm('Are you really sure you want to delete all data?') && (document.body.style.cursor = 'wait');\">"
            "<input type='submit' value='Delete CSV'/>"
@ -130,7 +135,7 @@ namespace web_server {
 #ifdef AMPEL_CSV
            "<script>\n"
            "document.body.style.cursor = 'default';\n"
-            "fetch('./%s',{credentials:'include'})\n"
+            "fetch('%s',{credentials:'include'})\n"
            ".then(response=>response.text())\n"
            ".then(csvText=>csvToTable(csvText))\n"
            ".then(htmlTable=>addLogTableToPage(htmlTable))\n"
@ -173,15 +178,16 @@ namespace web_server {
    // Web-server
    http.on("/", handleWebServerRoot);
    http.on("/command", handleWebServerCommand);
 #ifdef AMPEL_CSV
-    http.on("/" + csv_writer::filename, handleWebServerCSV);
+    http.on(csv_writer::filename, handleWebServerCSV); //NOTE: csv_writer should have been initialized first.
    http.on("/delete_csv", HTTP_POST, handleDeleteCSV);
 #endif
    http.onNotFound(handlePageNotFound);
    http.begin();
    Serial.print(F("You can access this sensor via http://"));
-    Serial.print(SENSOR_ID);
+    Serial.print(ampel.sensorId);
    Serial.print(F(".local (might be unstable) or http://"));
    Serial.println(WiFi.localIP());
  }
@ -207,44 +213,49 @@ namespace web_server {
    //NOTE: Splitting in multiple parts in order to use less RAM
    char content[2000]; // Update if needed
-    // Header size : 1611 - Body size : 1800 - Script size : 1920
+    // INFO - Header size : 1767 - Body size : 1991 - Script size : 1909
-    // Header
+    snprintf_P(content, sizeof(content), header_template, sensor::co2, ampel.sensorId, wifi::local_ip
    snprintf_P(content, sizeof(content), header_template, sensor::co2, SENSOR_ID.c_str(),
        WiFi.localIP().toString().c_str()
 #ifdef AMPEL_CSV
-        , csv_writer::filename.c_str()
+        , csv_writer::filename
 #endif
        );
    //    Serial.print(F("INFO - Header size : "));
    //    Serial.print(strlen(content));
    http.setContentLength(CONTENT_LENGTH_UNKNOWN);
    http.send_P(200, PSTR("text/html"), content);
    // Body
-    snprintf_P(content, sizeof(content), body_template, SENSOR_ID.c_str(), sensor::co2, sensor::temperature,
+    snprintf_P(content, sizeof(content), body_template, ampel.sensorId, sensor::co2, sensor::temperature,
-        sensor::humidity, sensor::timestamp.c_str(), config::measurement_timestep,
+        sensor::humidity, sensor::timestamp, config::measurement_timestep,
 #ifdef AMPEL_CSV
-        csv_writer::last_successful_write.c_str(), config::csv_interval, csv_writer::getAvailableSpace() / 1024,
+        csv_writer::last_successful_write, config::csv_interval, csv_writer::getAvailableSpace() / 1024,
 #endif
 #ifdef AMPEL_MQTT
-        mqtt::connected ? "Yes" : "No", mqtt::last_successful_publish.c_str(), config::sending_interval,
+        mqtt::connected ? "Yes" : "No", mqtt::last_successful_publish, config::mqtt_sending_interval,
 #endif
 #if defined(AMPEL_LORAWAN) && defined(ESP32)
-        lorawan::connected ? "Yes" : "No", LMIC_FREQUENCY_PLAN, lorawan::last_transmission.c_str(),
+        lorawan::connected ? "Yes" : "No", LMIC_FREQUENCY_PLAN, lorawan::last_transmission,
        config::lorawan_sending_interval,
 #endif
-        config::temperature_offset, SENSOR_ID.c_str(), SENSOR_ID.c_str(), WiFi.localIP().toString().c_str(),
+        config::temperature_offset, config::auto_calibrate_sensor ? "Yes" : "No", ampel.sensorId, ampel.sensorId,
-        WiFi.localIP().toString().c_str(), get_free_heap_size(), max_loop_duration, BOARD, dd, hh, mm, ss);
+        wifi::local_ip, wifi::local_ip, ampel.macAddress, ESP.getFreeHeap(), esp_get_max_free_block_size(),
        ampel.max_loop_duration, ampel.board, ampel.version, dd, hh, mm, ss);
    //    Serial.print(F(" - Body size : "));
    //    Serial.print(strlen(content));
    http.sendContent(content);
    // Script
    snprintf_P(content, sizeof(content), script_template
 #ifdef AMPEL_CSV
-        , csv_writer::filename.c_str(), SENSOR_ID.c_str()
+        , csv_writer::filename, ampel.sensorId
 #endif
        );
    //    Serial.print(F(" - Script size : "));
    //    Serial.println(strlen(content));
    http.sendContent(content);
  }
@ -255,7 +266,9 @@ namespace web_server {
    }
    if (FS_LIB.exists(csv_writer::filename)) {
      fs::File csv_file = FS_LIB.open(csv_writer::filename, "r");
-      http.sendHeader("Content-Length", String(csv_file.size()));
+      char csv_size[10];
      snprintf(csv_size, sizeof(csv_size), "%d", csv_file.size());
      http.sendHeader("Content-Length", csv_size);
      http.streamFile(csv_file, F("text/csv"));
      csv_file.close();
    } else {
@ -267,14 +280,23 @@ namespace web_server {
    if (!shouldBeAllowed()) {
      return http.requestAuthentication(DIGEST_AUTH);
    }
-    Serial.print("Removing CSV file...");
+    Serial.print(F("Removing CSV file..."));
    FS_LIB.remove(csv_writer::filename);
-    Serial.println(" Done!");
+    Serial.println(F(" Done!"));
    http.sendHeader("Location", "/");
    http.send(303);
  }
 #endif
  void handleWebServerCommand() {
    if (!shouldBeAllowed()) {
      return http.requestAuthentication(DIGEST_AUTH);
    }
    http.sendHeader("Location", "/");
    http.send(303);
    sensor_console::execute(http.arg("send").c_str());
  }
  void handlePageNotFound() {
    http.send(404, F("text/plain"), F("404: Not found"));
  }
--- a/ampel-firmware/web_server.h
+++ b/ampel-firmware/web_server.h
@ -1,5 +1,6 @@
 #ifndef WEB_SERVER_H_
 #define WEB_SERVER_H_
 #if defined(ESP8266)
 #  include <ESP8266WebServer.h>
 #elif defined(ESP32)
@ -8,7 +9,9 @@
 #include "config.h"
 #include "util.h"
 #include "wifi_util.h"
 #include "co2_sensor.h"
 #include "sensor_console.h"
 #ifdef AMPEL_CSV
 #  include "csv_writer.h"
 #endif
--- a/ampel-firmware/wifi_util.cpp
+++ b/ampel-firmware/wifi_util.cpp
@ -12,34 +12,69 @@ namespace config {
 #endif
 }
-// Initialize Wi-Fi
+namespace wifi {
-void WiFiConnect(const String &hostname) {
+  char local_ip[16]; // "255.255.255.255\0"
-  //NOTE: WiFi Multi could allow multiple SSID and passwords.
+
-  WiFi.persistent(false); // Don't write user & password to Flash.
+  void scanNetworks() {
-  WiFi.mode(WIFI_STA); // Set ESP to be a WiFi-client only
+    Serial.println();
    Serial.println(F("WiFi - Scanning..."));
    bool async = false;
    bool showHidden = true;
    int n = WiFi.scanNetworks(async, showHidden);
    for (int i = 0; i < n; ++i) {
      Serial.print(F("  * '"));
      Serial.print(WiFi.SSID(i));
      Serial.print(F("' ("));
      int16_t quality = 2 * (100 + WiFi.RSSI(i));
      Serial.print(util::min(util::max(quality, 0), 100));
      Serial.println(F(" %)"));
    }
    Serial.println(F("Done!"));
    Serial.println();
  }
  void showLocalIp() {
    Serial.print(F("WiFi - Local IP : "));
    Serial.println(wifi::local_ip);
    Serial.print(F("WiFi - SSID : "));
    Serial.println(WIFI_SSID);
  }
  // Initialize Wi-Fi
  void connect(const char *hostname) {
    sensor_console::defineCommand("wifi_scan", scanNetworks, F("(Scans available WiFi networks)"));
    sensor_console::defineCommand("local_ip", showLocalIp, F("(Displays local IP and current SSID)"));
    //NOTE: WiFi Multi could allow multiple SSID and passwords.
    WiFi.persistent(false); // Don't write user & password to Flash.
    WiFi.mode(WIFI_STA); // Set ESP to be a WiFi-client only
 #if defined(ESP8266)
    WiFi.hostname(hostname);
 #elif defined(ESP32)
-  WiFi.setHostname(hostname.c_str());
+    WiFi.setHostname(hostname);
 #endif
-  Serial.print(F("WiFi - Connecting to "));
+    Serial.print(F("WiFi - Connecting to "));
-  Serial.println(config::wifi_ssid);
+    Serial.println(config::wifi_ssid);
-  WiFi.begin(config::wifi_ssid, config::wifi_password);
+    WiFi.begin(config::wifi_ssid, config::wifi_password);
-  // Wait for connection, at most wifi_timeout seconds
+    // Wait for connection, at most wifi_timeout seconds
-  for (int i = 0; i <= config::wifi_timeout && (WiFi.status() != WL_CONNECTED); i++) {
+    for (int i = 0; i <= config::wifi_timeout && (WiFi.status() != WL_CONNECTED); i++) {
-    led_effects::showRainbowWheel();
+      led_effects::showRainbowWheel();
-    Serial.print(".");
+      Serial.print(".");
-  }
+    }
-  if (WiFi.status() == WL_CONNECTED) {
+    if (WiFi.status() == WL_CONNECTED) {
-    led_effects::showKITTWheel(color::green);
+      led_effects::showKITTWheel(color::green);
-    Serial.println();
+      Serial.println();
-    Serial.print(F("WiFi - Connected! IP address: "));
+      Serial.print(F("WiFi - Connected! IP address: "));
-    Serial.println(WiFi.localIP());
+      IPAddress address = WiFi.localIP();
-  } else {
+      snprintf(local_ip, sizeof(local_ip), "%d.%d.%d.%d", address[0], address[1], address[2], address[3]);
-    //TODO: Allow sensor to work as an Access Point, in order to define SSID & password?
+      Serial.println(local_ip);
-    led_effects::showKITTWheel(color::red);
+    } else {
-    Serial.println(F("Connection to WiFi failed"));
+      //TODO: Allow sensor to work as an Access Point, in order to define SSID & password?
      led_effects::showKITTWheel(color::red);
      Serial.println(F("Connection to WiFi failed"));
    }
  }
 }
--- a/ampel-firmware/wifi_util.h
+++ b/ampel-firmware/wifi_util.h
@ -5,6 +5,9 @@
 #include "util.h"
 #include "led_effects.h"
-void WiFiConnect(const String &hostname);
+namespace wifi {
  extern char local_ip[];
  void connect(const char *hostname);
 }
 #endif