initial

.gitignore

@@ -0,0 +1,5 @@
+.idea/
+build
+cmake-build-*
+*.o
+*.elf

CMakeLists.txt

@@ -0,0 +1,6 @@
+# The following lines of boilerplate have to be in your project's
+# CMakeLists in this exact order for cmake to work correctly
+cmake_minimum_required(VERSION 3.5)
+
+include($ENV{IDF_PATH}/tools/cmake/project.cmake)
+project(meteo)

Makefile

@@ -0,0 +1,9 @@
+#
+# This is a project Makefile. It is assumed the directory this Makefile resides in is a
+# project subdirectory.
+#
+
+DUMMY_VAR = 2
+PROJECT_NAME := meteo
+
+include $(IDF_PATH)/make/project.mk

README.md

@@ -0,0 +1 @@
+esp8266 meteostation with modbus API

components-todo/bmp280/CMakeLists.txt

@@ -0,0 +1,7 @@
+set(COMPONENT_ADD_INCLUDEDIRS .)
+
+set(COMPONENT_SRCS "bmp280.c")
+
+#set(COMPONENT_REQUIRES console spi_flash)
+
+register_component()

components-todo/bmp280/README.md

@@ -0,0 +1,108 @@
+# Driver for BMP280 and BME280 absolute barometric pressure sensors
+
+The driver works only with BMP280 and BME280 sensors. For BMP080/BMP180 there's
+a separate driver. Even though BMP280 is a successor of BMP180 they are not
+compatible.  They have different registers and different operation modes.
+BMP280 supports two ways of communication: spi and i2c.  This driver provides
+only i2c communication.
+The driver is written for [esp-open-rtos](https://github.com/SuperHouse/esp-open-rtos)
+framework and requires [i2c driver](https://github.com/SuperHouse/esp-open-rtos/tree/master/extras/i2c)
+from it.
+
+## Features
+
+ * I2C communication.
+ * Forced mode (Similar to BMP180 operation).
+ * Normal mode. Continuous measurement.
+ * Soft reset.
+
+## Usage
+
+Connect BMP280 or BME280 module to you ESP8266 module and initialize the I2C SCL and SDA pins:
+
+```
+const uint8_t bus = 0;
+const uint8_t scl_pin = 0;
+const uint8_t sda_pin = 2;
+i2c_init(bus, scl_pin, sda_pin, I2C_FREQ_100K);
+
+```
+
+Pull up SDO pin of BMP280 in order to have address 0x77 `BMP280_I2C_ADDRESS_1`.
+Or pull down SDO pin for address 0x76 `BMP280_I2C_ADDRESS_0`. Otherwise your
+sensor will not work.
+
+The BMP280 or BME280 are auto-detected at initialization based on the chip ID
+and this ID is stored in the device descriptor.
+
+BMP280 supports two operation modes.
+
+### Forced mode
+
+In forced mode, a single measurement is performed according to selected
+configuration. When the measurement is finished, the sensor returns to
+sleep mode and the measurement results can be read.
+
+### Normal mode
+
+Normal mode continuously cycles between measurement period and standby period,
+whose time is defined by standby_time.
+
+## Example
+
+### Forced mode
+
+```
+bmp280_params_t  params;
+float pressure, temperature, humidity;
+
+bmp280_init_default_params(&params);
+params.mode = BMP280_MODE_FORCED;
+
+bmp280_t bmp280_dev;
+bmp280_dev.i2c_addr = BMP280_I2C_ADDRESS_0;
+bmp280_init(&bmp280_dev, &params);
+bool bme280p = bmp280_dev.id == BME280_CHIP_ID;
+
+while(1) {
+  bmp280_force_measurement(&bmp280_dev));
+  // wait for measurement to complete
+  while (bmp280_is_measuring(&bmp280_dev)) {};
+
+  bmp280_read_float(&bmp280_dev, &temperature, &pressure, &humidity);
+  printf("Pressure: %.2f Pa, Temperature: %.2f C", pressure, temperature);
+  if (bme280p)
+    printf(", Humidity: %.2f\n", humidity);
+  vTaskDelay(1000 / portTICK_PERIOD_MS);
+}
+```
+
+### Normal mode
+
+```
+bmp280_params_t  params;
+float pressure, temperature, humidity;
+
+bmp280_init_default_params(&params);
+
+bmp280_t bmp280_dev;
+bmp280_dev.i2c_addr = BMP280_I2C_ADDRESS_0;
+bmp280_init(&bmp280_dev, &params);
+bool bme280p = bmp280_dev.id == BME280_CHIP_ID;
+
+while(1) {
+  bmp280_read_float(&bmp280_dev, &temperature, &pressure, &humidity);
+  printf("Pressure: %.2f Pa, Temperature: %.2f C", pressure, temperature);
+  if (bme280p)
+    printf(", Humidity: %.2f\n", humidity);
+  else
+    printf("\n");
+  vTaskDelay(1000 / portTICK_PERIOD_MS);
+}
+```
+
+## License
+
+The driver is released under MIT license.
+
+Copyright (c) 2016 sheinz (https://github.com/sheinz)

components-todo/bmp280/bmp280.c

@@ -0,0 +1,383 @@
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2016 sheinz (https://github.com/sheinz)
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#include <stddef.h>
+#include "bmp280.h"
+
+#ifdef BMP280_DEBUG
+#include <stdio.h>
+#define debug(fmt, ...) printf("%s" fmt "\n", "bmp280: ", ## __VA_ARGS__);
+#else
+#define debug(fmt, ...)
+#endif
+
+/**
+ * BMP280 registers
+ */
+#define BMP280_REG_TEMP_XLSB   0xFC /* bits: 7-4 */
+#define BMP280_REG_TEMP_LSB    0xFB
+#define BMP280_REG_TEMP_MSB    0xFA
+#define BMP280_REG_TEMP        (BMP280_REG_TEMP_MSB)
+#define BMP280_REG_PRESS_XLSB  0xF9 /* bits: 7-4 */
+#define BMP280_REG_PRESS_LSB   0xF8
+#define BMP280_REG_PRESS_MSB   0xF7
+#define BMP280_REG_PRESSURE    (BMP280_REG_PRESS_MSB)
+#define BMP280_REG_CONFIG      0xF5 /* bits: 7-5 t_sb; 4-2 filter; 0 spi3w_en */
+#define BMP280_REG_CTRL        0xF4 /* bits: 7-5 osrs_t; 4-2 osrs_p; 1-0 mode */
+#define BMP280_REG_STATUS      0xF3 /* bits: 3 measuring; 0 im_update */
+#define BMP280_REG_CTRL_HUM    0xF2 /* bits: 2-0 osrs_h; */
+#define BMP280_REG_RESET       0xE0
+#define BMP280_REG_ID          0xD0
+#define BMP280_REG_CALIB       0x88
+#define BMP280_REG_HUM_CALIB   0x88
+
+
+#define BMP280_RESET_VALUE     0xB6
+
+
+void bmp280_init_default_params(bmp280_params_t *params)
+{
+    params->mode = BMP280_MODE_NORMAL;
+    params->filter = BMP280_FILTER_OFF;
+    params->oversampling_pressure = BMP280_STANDARD;
+    params->oversampling_temperature = BMP280_STANDARD;
+    params->oversampling_humidity = BMP280_STANDARD;
+    params->standby = BMP280_STANDBY_250;
+}
+
+static bool read_register16(i2c_dev_t *dev, uint8_t addr, uint16_t *value)
+{
+    uint8_t d[] = {0, 0};
+    if (!i2c_slave_read(dev->bus, dev->addr, &addr, d, sizeof(d))) {
+        *value = d[0] | (d[1] << 8);
+        return true;
+    }
+    return false;
+}
+
+static inline int read_data(i2c_dev_t *dev, uint8_t addr, uint8_t *value, uint8_t len)
+{
+    return i2c_slave_read(dev->bus, dev->addr, &addr, value, len);
+}
+
+static bool read_calibration_data(bmp280_t *dev)
+{
+
+    if (read_register16(&dev->i2c_dev, 0x88, &dev->dig_T1) &&
+        read_register16(&dev->i2c_dev, 0x8a, (uint16_t *)&dev->dig_T2) &&
+        read_register16(&dev->i2c_dev, 0x8c, (uint16_t *)&dev->dig_T3) &&
+        read_register16(&dev->i2c_dev, 0x8e, &dev->dig_P1) &&
+        read_register16(&dev->i2c_dev, 0x90, (uint16_t *)&dev->dig_P2) &&
+        read_register16(&dev->i2c_dev, 0x92, (uint16_t *)&dev->dig_P3) &&
+        read_register16(&dev->i2c_dev, 0x94, (uint16_t *)&dev->dig_P4) &&
+        read_register16(&dev->i2c_dev, 0x96, (uint16_t *)&dev->dig_P5) &&
+        read_register16(&dev->i2c_dev, 0x98, (uint16_t *)&dev->dig_P6) &&
+        read_register16(&dev->i2c_dev, 0x9a, (uint16_t *)&dev->dig_P7) &&
+        read_register16(&dev->i2c_dev, 0x9c, (uint16_t *)&dev->dig_P8) &&
+        read_register16(&dev->i2c_dev, 0x9e, (uint16_t *)&dev->dig_P9)) {
+
+        debug("Calibration data received:");
+        debug("dig_T1=%d", dev->dig_T1);
+        debug("dig_T2=%d", dev->dig_T2);
+        debug("dig_T3=%d", dev->dig_T3);
+        debug("dig_P1=%d", dev->dig_P1);
+        debug("dig_P2=%d", dev->dig_P2);
+        debug("dig_P3=%d", dev->dig_P3);
+        debug("dig_P4=%d", dev->dig_P4);
+        debug("dig_P5=%d", dev->dig_P5);
+        debug("dig_P6=%d", dev->dig_P6);
+        debug("dig_P7=%d", dev->dig_P7);
+        debug("dig_P8=%d", dev->dig_P8);
+        debug("dig_P9=%d", dev->dig_P9);
+
+        return true;
+    }
+
+    return false;
+}
+
+static bool read_hum_calibration_data(bmp280_t *dev)
+{
+    uint16_t h4, h5;
+
+    if (!read_data(&dev->i2c_dev, 0xa1, &dev->dig_H1, 1) &&
+        read_register16(&dev->i2c_dev, 0xe1, (uint16_t *)&dev->dig_H2) &&
+        !read_data(&dev->i2c_dev, 0xe3, &dev->dig_H3, 1) &&
+        read_register16(&dev->i2c_dev, 0xe4, &h4) &&
+        read_register16(&dev->i2c_dev, 0xe5, &h5) &&
+        !read_data(&dev->i2c_dev, 0xe7, (uint8_t *)&dev->dig_H6, 1)) {
+        dev->dig_H4 = (h4 & 0x00ff) << 4 | (h4 & 0x0f00) >> 8;
+        dev->dig_H5 = h5 >> 4;
+        debug("Calibration data received:");
+        debug("dig_H1=%d", dev->dig_H1);
+        debug("dig_H2=%d", dev->dig_H2);
+        debug("dig_H3=%d", dev->dig_H3);
+        debug("dig_H4=%d", dev->dig_H4);
+        debug("dig_H5=%d", dev->dig_H5);
+        debug("dig_H6=%d", dev->dig_H6);
+        return true;
+    }
+
+    return false;
+}
+
+static int write_register8(i2c_dev_t *dev, uint8_t addr, uint8_t value)
+{
+    return i2c_slave_write(dev->bus, dev->addr, &addr, &value, 1);
+}
+
+bool bmp280_init(bmp280_t *dev, bmp280_params_t *params)
+{
+
+    if (dev->i2c_dev.addr != BMP280_I2C_ADDRESS_0 && dev->i2c_dev.addr != BMP280_I2C_ADDRESS_1) {
+        debug("Invalid I2C address");
+        return false;
+    }
+
+    if (read_data(&dev->i2c_dev, BMP280_REG_ID, &dev->id, 1)) {
+        debug("Sensor not found");
+        return false;
+    }
+
+    if (dev->id != BMP280_CHIP_ID && dev->id != BME280_CHIP_ID) {
+        debug("Sensor wrong version");
+        return false;
+    }
+
+    // Soft reset.
+    if (write_register8(&dev->i2c_dev, BMP280_REG_RESET, BMP280_RESET_VALUE)) {
+        debug("Failed resetting sensor");
+        return false;
+    }
+
+    // Wait until finished copying over the NVP data.
+    while (1) {
+        uint8_t status;
+        if (!read_data(&dev->i2c_dev, BMP280_REG_STATUS, &status, 1) && (status & 1) == 0)
+            break;
+    }
+
+    if (!read_calibration_data(dev)) {
+        debug("Failed to read calibration data");
+        return false;
+    }
+
+    if (dev->id == BME280_CHIP_ID && !read_hum_calibration_data(dev)) {
+        debug("Failed to read humidity calibration data");
+        return false;
+    }
+
+    uint8_t config = (params->standby << 5) | (params->filter << 2);
+    debug("Writing config reg=%x", config);
+    if (write_register8(&dev->i2c_dev, BMP280_REG_CONFIG, config)) {
+        debug("Failed configuring sensor");
+        return false;
+    }
+
+    if (params->mode == BMP280_MODE_FORCED) {
+        params->mode = BMP280_MODE_SLEEP;  // initial mode for forced is sleep
+    }
+
+    uint8_t ctrl = (params->oversampling_temperature << 5) | (params->oversampling_pressure << 2)
+        | (params->mode);
+
+
+    if (dev->id == BME280_CHIP_ID) {
+        // Write crtl hum reg first, only active after write to BMP280_REG_CTRL.
+        uint8_t ctrl_hum = params->oversampling_humidity;
+        debug("Writing ctrl hum reg=%x", ctrl_hum);
+        if (write_register8(&dev->i2c_dev, BMP280_REG_CTRL_HUM, ctrl_hum)) {
+            debug("Failed controlling sensor");
+            return false;
+        }
+    }
+
+    debug("Writing ctrl reg=%x", ctrl);
+    if (write_register8(&dev->i2c_dev, BMP280_REG_CTRL, ctrl)) {
+        debug("Failed controlling sensor");
+        return false;
+    }
+
+    return true;
+}
+
+bool bmp280_force_measurement(bmp280_t *dev)
+{
+    uint8_t ctrl;
+    if (read_data(&dev->i2c_dev, BMP280_REG_CTRL, &ctrl, 1))
+        return false;
+    ctrl &= ~0b11;  // clear two lower bits
+    ctrl |= BMP280_MODE_FORCED;
+    debug("Writing ctrl reg=%x", ctrl);
+    if (write_register8(&dev->i2c_dev, BMP280_REG_CTRL, ctrl)) {
+        debug("Failed starting forced mode");
+        return false;
+    }
+    return true;
+}
+
+bool bmp280_is_measuring(bmp280_t *dev)
+{
+    uint8_t status;
+    if (read_data(&dev->i2c_dev, BMP280_REG_STATUS, &status, 1))
+        return false;
+    if (status & (1 << 3)) {
+        debug("Status: measuring");
+        return true;
+    }
+    debug("Status: idle");
+    return false;
+}
+
+/**
+ * Compensation algorithm is taken from BMP280 datasheet.
+ *
+ * Return value is in degrees Celsius.
+ */
+static inline int32_t compensate_temperature(bmp280_t *dev,
+                                             int32_t adc_temp, int32_t *fine_temp)
+{
+    int32_t var1, var2;
+
+    var1 = ((((adc_temp >> 3) - ((int32_t)dev->dig_T1 << 1)))
+            * (int32_t)dev->dig_T2) >> 11;
+    var2 = (((((adc_temp >> 4) - (int32_t)dev->dig_T1)
+              * ((adc_temp >> 4) - (int32_t)dev->dig_T1)) >> 12)
+            * (int32_t)dev->dig_T3) >> 14;
+
+    *fine_temp = var1 + var2;
+    return (*fine_temp * 5 + 128) >> 8;
+}
+
+/**
+ * Compensation algorithm is taken from BMP280 datasheet.
+ *
+ * Return value is in Pa, 24 integer bits and 8 fractional bits.
+ */
+static inline uint32_t compensate_pressure(bmp280_t *dev,
+                                           int32_t adc_press, int32_t fine_temp)
+{
+    int64_t var1, var2, p;
+
+    var1 = (int64_t)fine_temp - 128000;
+    var2 = var1 * var1 * (int64_t)dev->dig_P6;
+    var2 = var2 + ((var1 * (int64_t)dev->dig_P5) << 17);
+    var2 = var2 + (((int64_t)dev->dig_P4) << 35);
+    var1 = ((var1 * var1 * (int64_t)dev->dig_P3) >> 8) +
+        ((var1 * (int64_t)dev->dig_P2) << 12);
+    var1 = (((int64_t)1 << 47) + var1) * ((int64_t)dev->dig_P1) >> 33;
+
+    if (var1 == 0) {
+        return 0;  // avoid exception caused by division by zero
+    }
+
+    p = 1048576 - adc_press;
+    p = (((p << 31) - var2) * 3125) / var1;
+    var1 = ((int64_t)dev->dig_P9 * (p >> 13) * (p >> 13)) >> 25;
+    var2 = ((int64_t)dev->dig_P8 * p) >> 19;
+
+    p = ((p + var1 + var2) >> 8) + ((int64_t)dev->dig_P7 << 4);
+    return p;
+}
+
+/**
+ * Compensation algorithm is taken from BME280 datasheet.
+ *
+ * Return value is in Pa, 24 integer bits and 8 fractional bits.
+ */
+static inline uint32_t compensate_humidity(bmp280_t *dev,
+                                           int32_t adc_hum, int32_t fine_temp)
+{
+    int32_t v_x1_u32r;
+
+    v_x1_u32r = fine_temp - (int32_t)76800;
+    v_x1_u32r = ((((adc_hum << 14) - ((int32_t)dev->dig_H4 << 20) -
+                   ((int32_t)dev->dig_H5 * v_x1_u32r)) +
+                  (int32_t)16384) >> 15) *
+        (((((((v_x1_u32r * (int32_t)dev->dig_H6) >> 10) *
+             (((v_x1_u32r * (int32_t)dev->dig_H3) >> 11) +
+              (int32_t)32768)) >> 10) + (int32_t)2097152) *
+          (int32_t)dev->dig_H2 + 8192) >> 14);
+    v_x1_u32r = v_x1_u32r - (((((v_x1_u32r >> 15) * (v_x1_u32r >> 15)) >> 7) *
+                              (int32_t)dev->dig_H1) >> 4);
+    v_x1_u32r = v_x1_u32r < 0 ? 0 : v_x1_u32r;
+    v_x1_u32r = v_x1_u32r > 419430400 ? 419430400 : v_x1_u32r;
+    return v_x1_u32r >> 12;
+}
+
+bool bmp280_read_fixed(bmp280_t *dev, int32_t *temperature,
+                       uint32_t *pressure, uint32_t *humidity)
+{
+    int32_t adc_pressure;
+    int32_t adc_temp;
+    uint8_t data[8];
+
+    // Only the BME280 supports reading the humidity.
+    if (dev->id != BME280_CHIP_ID) {
+        if (humidity)
+            *humidity = 0;
+        humidity = NULL;
+    }
+
+    // Need to read in one sequence to ensure they match.
+    size_t size = humidity ? 8 : 6;
+    if (read_data(&dev->i2c_dev, 0xf7, data, size)) {
+        debug("Failed reading");
+        return false;
+    }
+
+    adc_pressure = data[0] << 12 | data[1] << 4 | data[2] >> 4;
+    adc_temp = data[3] << 12 | data[4] << 4 | data[5] >> 4;
+    debug("ADC temperature: %d", adc_temp);
+    debug("ADC pressure: %d", adc_pressure);
+
+    int32_t fine_temp;
+    *temperature = compensate_temperature(dev, adc_temp, &fine_temp);
+    *pressure = compensate_pressure(dev, adc_pressure, fine_temp);
+
+    if (humidity) {
+        int32_t adc_humidity = data[6] << 8 | data[7];
+        debug("ADC humidity: %d", adc_humidity);
+        *humidity = compensate_humidity(dev, adc_humidity, fine_temp);
+    }
+
+    return true;
+}
+
+bool bmp280_read_float(bmp280_t *dev, float *temperature,
+                       float *pressure, float *humidity)
+{
+    int32_t fixed_temperature;
+    uint32_t fixed_pressure;
+    uint32_t fixed_humidity;
+    if (bmp280_read_fixed(dev, &fixed_temperature, &fixed_pressure,
+                          humidity ? &fixed_humidity : NULL)) {
+        *temperature = (float)fixed_temperature/100;
+        *pressure = (float)fixed_pressure/256;
+        if (humidity)
+            *humidity = (float)fixed_humidity/1024;
+        return true;
+    }
+
+    return false;
+}

components-todo/bmp280/bmp280.h

@@ -0,0 +1,198 @@
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2016 sheinz (https://github.com/sheinz)
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#ifndef __BMP280_H__
+#define __BMP280_H__
+
+#include <stdint.h>
+#include <stdbool.h>
+#include "i2c/i2c.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Uncomment to enable debug output.
+ */
+// #define BMP280_DEBUG
+
+/**
+ * BMP280 or BME280 address is 0x77 if SDO pin is high, and is 0x76 if
+ * SDO pin is low.
+ */
+#define BMP280_I2C_ADDRESS_0  0x76
+#define BMP280_I2C_ADDRESS_1  0x77
+
+#define BMP280_CHIP_ID  0x58 /* BMP280 has chip-id 0x58 */
+#define BME280_CHIP_ID  0x60 /* BME280 has chip-id 0x60 */
+
+/**
+ * Mode of BMP280 module operation.
+ * Forced - Measurement is initiated by user.
+ * Normal - Continues measurement.
+ */
+typedef enum {
+    BMP280_MODE_SLEEP = 0,
+    BMP280_MODE_FORCED = 1,
+    BMP280_MODE_NORMAL = 3
+} BMP280_Mode;
+
+typedef enum {
+    BMP280_FILTER_OFF = 0,
+    BMP280_FILTER_2 = 1,
+    BMP280_FILTER_4 = 2,
+    BMP280_FILTER_8 = 3,
+    BMP280_FILTER_16 = 4
+} BMP280_Filter;
+
+/**
+ * Pressure oversampling settings
+ */
+typedef enum {
+    BMP280_SKIPPED = 0,          /* no measurement  */
+    BMP280_ULTRA_LOW_POWER = 1,  /* oversampling x1 */
+    BMP280_LOW_POWER = 2,        /* oversampling x2 */
+    BMP280_STANDARD = 3,         /* oversampling x4 */
+    BMP280_HIGH_RES = 4,         /* oversampling x8 */
+    BMP280_ULTRA_HIGH_RES = 5    /* oversampling x16 */
+} BMP280_Oversampling;
+
+/**
+ * Stand by time between measurements in normal mode
+ */
+typedef enum {
+    BMP280_STANDBY_05 = 0,      /* stand by time 0.5ms */
+    BMP280_STANDBY_62 = 1,      /* stand by time 62.5ms */
+    BMP280_STANDBY_125 = 2,     /* stand by time 125ms */
+    BMP280_STANDBY_250 = 3,     /* stand by time 250ms */
+    BMP280_STANDBY_500 = 4,     /* stand by time 500ms */
+    BMP280_STANDBY_1000 = 5,    /* stand by time 1s */
+    BMP280_STANDBY_2000 = 6,    /* stand by time 2s BMP280, 10ms BME280 */
+    BMP280_STANDBY_4000 = 7,    /* stand by time 4s BMP280, 20ms BME280 */
+} BMP280_StandbyTime;
+
+/**
+ * Configuration parameters for BMP280 module.
+ * Use function bmp280_init_default_params to use default configuration.
+ */
+typedef struct {
+    BMP280_Mode mode;
+    BMP280_Filter filter;
+    BMP280_Oversampling oversampling_pressure;
+    BMP280_Oversampling oversampling_temperature;
+    BMP280_Oversampling oversampling_humidity;
+    BMP280_StandbyTime standby;
+} bmp280_params_t;
+
+
+typedef struct {
+    uint16_t dig_T1;
+    int16_t  dig_T2;
+    int16_t  dig_T3;
+    uint16_t dig_P1;
+    int16_t  dig_P2;
+    int16_t  dig_P3;
+    int16_t  dig_P4;
+    int16_t  dig_P5;
+    int16_t  dig_P6;
+    int16_t  dig_P7;
+    int16_t  dig_P8;
+    int16_t  dig_P9;
+
+    /* Humidity compensation for BME280 */
+    uint8_t  dig_H1;
+    int16_t  dig_H2;
+    uint8_t  dig_H3;
+    int16_t  dig_H4;
+    int16_t  dig_H5;
+    int8_t   dig_H6;
+
+    i2c_dev_t  i2c_dev;  /* I2C dev setting. */
+    uint8_t  id;        /* Chip ID */
+} bmp280_t;
+
+/**
+ * Initialize default parameters.
+ * Default configuration:
+ *      mode: NORAML
+ *      filter: OFF
+ *      oversampling: x4
+ *      standby time: 250ms
+ */
+void bmp280_init_default_params(bmp280_params_t *params);
+
+/**
+ * Initialize BMP280 module, probes for the device, soft resets the device,
+ * reads the calibration constants, and configures the device using the supplied
+ * parameters. Returns true on success otherwise false.
+ *
+ * The I2C address is assumed to have been initialized in the dev, and
+ * may be either BMP280_I2C_ADDRESS_0 or BMP280_I2C_ADDRESS_1. If the I2C
+ * address is unknown then try initializing each in turn.
+ *
+ * This may be called again to soft reset the device and initialize it again.
+ */
+bool bmp280_init(bmp280_t *dev, bmp280_params_t *params);
+
+/**
+ * Start measurement in forced mode.
+ * The module remains in forced mode after this call.
+ * Do not call this method in normal mode.
+ */
+bool bmp280_force_measurement(bmp280_t *dev);
+
+/**
+ * Check if BMP280 is busy with measuring temperature/pressure.
+ * Return true if BMP280 is busy.
+ */
+bool bmp280_is_measuring(bmp280_t *dev);
+
+/**
+ * Read compensated temperature and pressure data:
+ *
+ *  Temperature in degrees Celsius times 100.
+ *
+ *  Pressure in Pascals in fixed point 24 bit integer 8 bit fraction format.
+ *
+ *  Humidity is optional and only read for the BME280, in percent relative
+ *  humidity as a fixed point 22 bit interger and 10 bit fraction format.
+ */
+bool bmp280_read_fixed(bmp280_t *dev, int32_t *temperature,
+                       uint32_t *pressure, uint32_t *humidity);
+
+/**
+ * Read compensated temperature and pressure data:
+ *  Temperature in degrees Celsius.
+ *  Pressure in Pascals.
+ *  Humidity is optional and only read for the BME280, in percent relative
+ *  humidity.
+ */
+bool bmp280_read_float(bmp280_t *dev, float *temperature,
+                       float *pressure, float *humidity);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // __BMP280_H__

components-todo/bmp280/component.mk

@@ -0,0 +1,10 @@
+#
+# Component Makefile
+#
+# This Makefile should, at the very least, just include $(SDK_PATH)/Makefile. By default,
+# this will take the sources in the src/ directory, compile them and link them into
+# lib(subdirectory_name).a in the build directory. This behaviour is entirely configurable,
+# please read the SDK documents if you need to do this.
+#
+
+COMPONENT_ADD_INCLUDEDIRS := .

components-todo/sht3x/CMakeLists.txt

@@ -0,0 +1,5 @@
+set(COMPONENT_ADD_INCLUDEDIRS .)
+
+set(COMPONENT_SRCS "sht3x.c")
+
+register_component()

components-todo/sht3x/README.md

@@ -0,0 +1,389 @@
+# Driver for **SHT3x** digital **temperature and humidity sensor**
+
+The driver is for the usage with the ESP8266 and [esp-open-rtos](https://github.com/SuperHouse/esp-open-rtos). 
+
+It is also working with ESP32 and [ESP-IDF](https://github.com/espressif/esp-idf.git) using a wrapper component for ESP8266 functions, see folder ```components/esp8266_wrapper```, as well as Linux based systems using a wrapper library.
+
+## About the sensor
+
+SHT3x is a digital temperature and humidity sensor that uses an I2C interface with up to 1 MHz communication speed. It can operate with **three levels of repeatability** (low, medium and high) and in two different modes, the **single shot data acquisition mode** (or short **single shot mode**) and the **periodic data acquisition mode** (or short **periodic mode**).
+
+## Measurement process
+
+Once the SHT3x sensor is initialized, it can be used for measurements. 
+
+### Single shot mode
+
+In **single shot mode**, a measurement command triggers the acquisition of **exactly one data pair**. Each data pair consists of temperature and humidity as 16-bit decimal values. 
+
+Due to the measurement duration of up to 15 ms, the measurement process is separated into steps to avoid blocking the user task during measurements:
+
+1. Trigger the sensor with function ```sht3x_start_measurement``` to perform exactly one single measurement.
+
+2. Wait the measurement duration using function ```vTaskDelay``` until the results are available . Use either a constant duration of at least 30 ms or the duration in RTOS ticks returned from function ```sht3x_get_measurement_duration``` to wait.
+
+3. Fetch the results as floating point sensor values with function ```sht3x_get_results``` or as raw data with function ```sht3x_get_raw_data```.
+
+In the *single shot mode*, the user task has to perform all steps every time new sensor values ​​are needed. 
+
+For convenience a high level function ```sht3x_measure``` that comprises all three steps above in only one function to perform a measurement. This function is the easiest way to use the sensor. It is most suitable for users that don't want to have the control on sensor details.
+
+The advantage of this mode is that the sensor can switch between successive measurements into the sleep mode, which is more energy-efficient. This is particularly useful when the measurement rate is less than 1 measurement per second.
+
+### Periodic mode
+
+In this mode, one issued measurement command yields a stream of data pairs. Each data pair consists again of temperature and humidity as 16-bit decimal values. As soon as the measurement command has been sent to the sensor, it automatically performs measurements **periodically at a rate of 0.5, 1, 2, 4 or 10 measurements per second (mps)**. The data pairs can be fetched with the same rate or a lower rate.
+
+As in *single shot mode*, the measurement process is separated into the following steps:
+
+1. Trigger the sensor with function ```sht3x_start_measurement``` with a given rate to start periodic measurements.
+
+2. Wait the measurement duration using function ```vTaskDelay``` until the first results are available . Use either a constant duration of at least 30 ms or the duration in RTOS ticks returned from function ```sht3x_get_measurement_duration``` to wait.
+
+3. Fetch the results as floating point sensor values with function ```sht3x_get_results``` or as raw data with function ```sht3x_get_raw_data```.
+
+However, in contrast to the *single shot mode*, steps 1 and 2 have to be executed only once. Once the measurement is started, the user task hast can simply fetch data periodically.
+
+**Please note:** The rate of fetching the measurement results must not be greater than the rate of periodic measurements of the sensor. Even more, it *should be less* to avoid conflicts caused by the timing tolerance of the sensor.
+
+## Measurement results
+
+Once new measurement results are available, either function ```sht3x_get_raw_data``` or function ```sht3x_get_results``` can be used to fetch the results. 
+
+Function ```_sht3x_get_raw_data``` fetches only raw sensor data in 16-decimal format, checks the CRC checksums and stores them in an byte array of type ```sht3x_raw_data_t```. The user task then can use them directly or to call function ```sht3x_compute_values``` to compute floating point sensor values from them. 
+
+Function ```sht3x_get_results``` combines function ```sht3x_read_raw_data``` and function 
+ ```sht3x_compute_values``` to get the sensor values. This is the preferred approach to get sensor values by the user task.
+
+## Error Handling
+
+Most driver functions return a simple boolean value to indicate whether its execution was successful or an error happened. In the latter case, the member ```error_code``` of the sensor device data structure is set which indicates what error happened. 
+
+There are two different error levels that are ORed into one single ```error_code```, errors in the I2C communication and errors with the SHT3x sensor itself.  To test for a certain error you can AND the *error_code* with one of the error masks, ```SHT3x_I2C_ERROR_MASK``` for I2C errors and ```SHT3x_DRV_ERROR_MASK``` for other errors and then test for a certain error code.
+
+
+## Repeatability
+
+The SHT3x sensor supports **three levels of repeatability** (low, medium and high). Repeatability is the variation in measurement results taken by the sensor under the same conditions, and in a short period of time. It is a measure for the noise on the physical sensor output. The higher the repeatability the smaller are changes in the output of subsequent measurements.
+
+The repeatability settings influences the measurement duration as well as the power consumption of the sensor. The measurement takes 3 ms with low repeatability, 5 ms with medium repeatability and 13.5 ms with high repeatability. That is, the measurement produces a noticeable delay in execution.
+
+While the sensor measures at the lowest repeatability, the average current consumption is 800 μA. That is, the higher the repeatability level, the longer the measurement takes and the higher the power consumption. The sensor consumes only 0.2 μA in standby mode.
+
+The repeatability used for a measurement is specified as parameter of function ```sht3x_start_measurement```.
+
+
+## Usage
+
+Before using the SHT3x driver, function ```i2c_init``` needs to be called for each I2C interface to setup them. 
+
+```
+#include "sht3x/sht3x.h"
+...
+#define I2C_BUS       0
+#define I2C_SCL_PIN   14
+#define I2C_SDA_PIN   13
+
+...
+i2c_init(I2C_BUS, I2C_SCL_PIN, I2C_SDA_PIN, I2C_FREQ_100K)
+...
+```
+
+Once I2C interfaces to be used are initialized, function ```sht3x_init_sensor``` has to be called for each SHT3x sensor to initialize the sensor and to check its availability as well as its error state. The parameters specify the I2C bus to which it is connected and its I2C slave address.
+
+```
+static sht3x_sensor_t* sensor;    // pointer to sensor device data structure
+...
+if ((sensor = sht3x_init_sensor (I2C_BUS, SHT3x_ADDR_2)))
+{
+    ...
+}
+```
+
+Function ```sht3x_init_sensor``` returns a pointer to the sensor device data structure or NULL in case of error.
+
+Finally, a user task that uses the sensor has to be created.
+
+```
+xTaskCreate(user_task, "user_task", 256, NULL, 2, 0);
+```
+
+**Please note:** To avoid concurrency situations when driver functions are used to access the sensor, for example to read data, the user task must not be created until the sensor configuration is completed.
+
+In **periodic mode**, the user task has to start the periodic measurement only once at the beginning of the task. After that, it has only to wait for the results of the first measurement. In the task loop itself, it simply fetches the next measurement results in each cycle.
+
+Thus, in this mode the user task could look like the following:
+
+```
+void user_task (void *pvParameters)
+{
+    float temperature;
+    float humidity;
+
+    // Start periodic measurements with 1 measurement per second.
+    sht3x_start_measurement (sensor, sht3x_periodic_1mps, sht3x_high);
+
+    // Wait until first measurement is ready (constant time of at least 30 ms
+    // or the duration returned from *sht3x_get_measurement_duration*).
+    vTaskDelay (sht3x_get_measurement_duration(sht3x_high));
+
+    TickType_t last_wakeup = xTaskGetTickCount();
+    
+    while (1) 
+    {
+        // Get the values and do something with them.
+        if (sht3x_get_results (sensor, &temperature, &humidity))
+            printf("%.3f SHT3x Sensor: %.2f °C, %.2f %%\n", 
+                   (double)sdk_system_get_time()*1e-3, temperature, humidity);
+                   
+        // Wait until 2 seconds (cycle time) are over.
+        vTaskDelayUntil(&last_wakeup, 2000 / portTICK_PERIOD_MS);
+    }
+}
+
+```
+
+At the beginning of the task, the periodic measurement is started with function ```sht3x_start_measurement``` at high repeatability level and a rate of 1 measurement per second. The task is then delayed with function ```vTaskDelay``` to wait for first measurement results. The duration can be either a constant time of at least 30 ms or the duration returned by ```sht3x_get_measurement_duration```, as in the example. Inside the task loop, simply the measurement results are fetched periodically using function ```sht3x_get_results``` every 2 seconds.
+
+**Please note:** The rate of fetching the measurement results must be not greater than the rate of periodic measurements of the sensor, however, it *should be less* to avoid conflicts caused by the timing tolerance of the sensor.
+
+In **single shot mode**, the measurement has to be triggered 
+in each cycle. Also the waiting for measurement results is required in each cylce, before the results can be fetched.
+
+Thus the user task could look like the following:
+
+```
+void user_task (void *pvParameters)
+{
+    float temperature;
+    float humidity;
+
+    TickType_t last_wakeup = xTaskGetTickCount();
+
+    uint8_t duration = sht3x_get_measurement_duration(sht3x_high);
+    
+    while (1) 
+    {
+        // Trigger one measurement in single shot mode with high repeatability.
+        sht3x_start_measurement (sensor, sht3x_single_shot, sht3x_high);
+        
+        // Wait until measurement is ready (constant time of at least 30 ms
+        // or the duration returned from *sht3x_get_measurement_duration*).
+        vTaskDelay (duration);
+        
+        // retrieve the values and do something with them
+        if (sht3x_get_results (sensor, &temperature, &humidity))
+            printf("%.3f SHT3x Sensor: %.2f °C, %.2f %%\n", 
+                   (double)sdk_system_get_time()*1e-3, temperature, humidity);
+
+        // wait until 5 seconds are over
+        vTaskDelayUntil(&last_wakeup, 5000 / portTICK_PERIOD_MS);
+    }
+}
+```
+
+In contrast to the *periodic mode*, the function ```sht3x_start_measurement``` is called inside the task loop to start exactly one measurement in each cycle. The task is then also delayed every time using function ```vTaskDelay``` before the results are fetched with function ```sht3x_get_results```.
+
+Alternatively, user task can use the high level function ```sht3x_measure``` that comprises these steps in only one function. This would simplify the user task that would then look like the following:
+
+```
+void user_task (void *pvParameters)
+{
+    float temperature;
+    float humidity;
+
+    TickType_t last_wakeup = xTaskGetTickCount();
+
+    while (1) 
+    {
+        // perform one measurement and do something with the results
+        if (sht3x_measure (sensor, &temperature, &humidity))
+            printf("%.3f SHT3x Sensor: %.2f °C, %.2f %%\n", 
+                   (double)sdk_system_get_time()*1e-3, temperature, humidity);
+
+        // wait until 5 seconds are over
+        vTaskDelayUntil(&last_wakeup, 5000 / portTICK_PERIOD_MS);
+    }
+}
+```
+
+
+The code could be extended by an error handling. In the event of an error, most driver functions set the ```error_code``` element of the sensor device data structure. This indicates which error has occurred. Error codes are a combination of I2C communication error codes and SHT3x sensor error codes. To test for a particular error, the *error code* has to be ANDed with one of the error masks ```SHT3x_I2C_ERROR_MASK``` or ```SHT3x_DRV_ERROR_MASK``` and then tested for a certain value.
+
+For example, error handling for ```sht3x_get_results``` could look like:
+```
+
+if (!sht3x_get_results (sensor, &values))
+{
+    // error happened
+    
+    switch (sensor->error_code & SHT3x_I2C_ERROR_MASK)
+    {
+        case SHT3x_I2C_BUSY:        ...
+        case SHT3x_I2C_READ_FAILED: ...
+        ...
+    }
+    switch (sensor->error_code & SHT3x_DRV_ERROR_MASK)
+    {
+        case SHT3x_MEAS_NOT_RUNNING:      ...
+        case SHT3x_READ_RAW_DATA_FAILED:  ...
+        case SHT3x_WRONG_CRC_TEMPERATURE: ...
+        ...
+    }
+}
+```
+
+## Full Example 
+
+```
+/* -- use following constants to define the example mode ----------- */
+
+// #define SINGLE_SHOT_LOW_LEVEL
+// #define SINGLE_SHOT_HIGH_LEVEL
+
+/* -- includes ----------------------------------------------------- */
+
+#include "sht3x.h"
+
+/* -- platform dependent definitions ------------------------------- */
+
+#ifdef ESP_PLATFORM  // ESP32 (ESP-IDF)
+
+// user task stack depth for ESP32
+#define TASK_STACK_DEPTH 2048
+
+#else  // ESP8266 (esp-open-rtos)
+
+// user task stack depth for ESP8266
+#define TASK_STACK_DEPTH 256
+
+#endif  // ESP_PLATFORM
+
+// I2C interface defintions for ESP32 and ESP8266
+#define I2C_BUS       0
+#define I2C_SCL_PIN   14
+#define I2C_SDA_PIN   13
+#define I2C_FREQ      I2C_FREQ_100K
+
+/* -- user tasks --------------------------------------------------- */
+
+static sht3x_sensor_t* sensor;    // sensor device data structure
+
+#if defined(SINGLE_SHOT_HIGH_LEVEL)
+/*
+ * User task that triggers a measurement every 5 seconds. Due to power
+ * efficiency reasons it uses *single shot* mode. In this example it uses the
+ * high level function *sht3x_measure* to perform one measurement in each cycle.
+ */
+void user_task (void *pvParameters)
+{
+    float temperature;
+    float humidity;
+
+    TickType_t last_wakeup = xTaskGetTickCount();
+
+    while (1) 
+    {
+        // perform one measurement and do something with the results
+        if (sht3x_measure (sensor, &temperature, &humidity))
+            printf("%.3f SHT3x Sensor: %.2f °C, %.2f %%\n", 
+                   (double)sdk_system_get_time()*1e-3, temperature, humidity);
+
+        // wait until 5 seconds are over
+        vTaskDelayUntil(&last_wakeup, 5000 / portTICK_PERIOD_MS);
+    }
+}
+
+#elif defined(SINGLE_SHOT_LOW_LEVEL)
+/*
+ * User task that triggers a measurement every 5 seconds. Due to power
+ * efficiency reasons it uses *single shot* mode. In this example it starts the
+ * measurement, waits for the results and fetches the results using separate
+ * functions
+ */
+void user_task (void *pvParameters)
+{
+    float temperature;
+    float humidity;
+
+    TickType_t last_wakeup = xTaskGetTickCount();
+
+    // get the measurement duration for high repeatability;
+    uint8_t duration = sht3x_get_measurement_duration(sht3x_high);
+    
+    while (1) 
+    {
+        // Trigger one measurement in single shot mode with high repeatability.
+        sht3x_start_measurement (sensor, sht3x_single_shot, sht3x_high);
+        
+        // Wait until measurement is ready (constant time of at least 30 ms
+        // or the duration returned from *sht3x_get_measurement_duration*).
+        vTaskDelay (duration);
+        
+        // retrieve the values and do something with them
+        if (sht3x_get_results (sensor, &temperature, &humidity))
+            printf("%.3f SHT3x Sensor: %.2f °C, %.2f %%\n", 
+                   (double)sdk_system_get_time()*1e-3, temperature, humidity);
+
+        // wait until 5 seconds are over
+        vTaskDelayUntil(&last_wakeup, 5000 / portTICK_PERIOD_MS);
+    }
+}
+
+#else  // PERIODIC MODE
+/*
+ * User task that fetches latest measurement results of sensor every 2
+ * seconds. It starts the SHT3x in periodic mode with 1 measurements per
+ * second (*sht3x_periodic_1mps*).
+ */
+void user_task (void *pvParameters)
+{
+    float temperature;
+    float humidity;
+
+    // Start periodic measurements with 1 measurement per second.
+    sht3x_start_measurement (sensor, sht3x_periodic_1mps, sht3x_high);
+
+    // Wait until first measurement is ready (constant time of at least 30 ms
+    // or the duration returned from *sht3x_get_measurement_duration*).
+    vTaskDelay (sht3x_get_measurement_duration(sht3x_high));
+
+    TickType_t last_wakeup = xTaskGetTickCount();
+    
+    while (1) 
+    {
+        // Get the values and do something with them.
+        if (sht3x_get_results (sensor, &temperature, &humidity))
+            printf("%.3f SHT3x Sensor: %.2f °C, %.2f %%\n", 
+                   (double)sdk_system_get_time()*1e-3, temperature, humidity);
+                   
+        // Wait until 2 seconds (cycle time) are over.
+        vTaskDelayUntil(&last_wakeup, 2000 / portTICK_PERIOD_MS);
+    }
+}
+#endif
+
+/* -- main program ------------------------------------------------- */
+
+void user_init(void)
+{
+    // Set UART Parameter.
+    uart_set_baud(0, 115200);
+    // Give the UART some time to settle
+    vTaskDelay(1);
+    
+    // Init I2C bus interfaces at which SHT3x sensors are connected
+    // (different busses are possible).
+    i2c_init(I2C_BUS, I2C_SCL_PIN, I2C_SDA_PIN, I2C_FREQ);
+    
+    // Create the sensors, multiple sensors are possible.
+    if ((sensor = sht3x_init_sensor (I2C_BUS, SHT3x_ADDR_2)))
+    {
+        // Create a user task that uses the sensors.
+        xTaskCreate(user_task, "user_task", TASK_STACK_DEPTH, NULL, 2, 0);
+    }
+
+    // That's it.
+}
+```
+

components-todo/sht3x/component.mk

@@ -0,0 +1,10 @@
+#
+# Component Makefile
+#
+# This Makefile should, at the very least, just include $(SDK_PATH)/Makefile. By default,
+# this will take the sources in the src/ directory, compile them and link them into
+# lib(subdirectory_name).a in the build directory. This behaviour is entirely configurable,
+# please read the SDK documents if you need to do this.
+#
+
+COMPONENT_ADD_INCLUDEDIRS := .

components-todo/sht3x/sht3x.c

@@ -0,0 +1,423 @@
+/*
+ * Driver for Sensirion SHT3x digital temperature and humidity sensor
+ * connected to I2C
+ *
+ * This driver is for the usage with the ESP8266 and FreeRTOS (esp-open-rtos)
+ * [https://github.com/SuperHouse/esp-open-rtos]. It is also working with ESP32
+ * and ESP-IDF [https://github.com/espressif/esp-idf.git] as well as Linux
+ * based systems using a wrapper library for ESP8266 functions.
+ *
+ * ----------------------------------------------------------------
+ *
+ * The BSD License (3-clause license)
+ *
+ * Copyright (c) 2017 Gunar Schorcht (https://github.com/gschorcht)
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its 
+ * contributors may be used to endorse or promote products derived from this
+ * software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <string.h>
+#include <stdlib.h>
+
+#include "sht3x.h"
+
+#define SHT3x_STATUS_CMD               0xF32D
+#define SHT3x_CLEAR_STATUS_CMD         0x3041
+#define SHT3x_RESET_CMD                0x30A2
+#define SHT3x_FETCH_DATA_CMD           0xE000
+#define SHT3x_HEATER_OFF_CMD           0x3066
+
+const uint16_t SHT3x_MEASURE_CMD[6][3] = { 
+        {0x2400,0x240b,0x2416},    // [SINGLE_SHOT][H,M,L] without clock stretching
+        {0x2032,0x2024,0x202f},    // [PERIODIC_05][H,M,L]
+        {0x2130,0x2126,0x212d},    // [PERIODIC_1 ][H,M,L]
+        {0x2236,0x2220,0x222b},    // [PERIODIC_2 ][H,M,L]
+        {0x2234,0x2322,0x2329},    // [PERIODIC_4 ][H,M,L]
+        {0x2737,0x2721,0x272a} };  // [PERIODIC_10][H,M,L]
+
+// due to the fact that ticks can be smaller than portTICK_PERIOD_MS, one and
+// a half tick period added to the duration to be sure that waiting time for 
+// the results is long enough
+#define TIME_TO_TICKS(ms) (1 + ((ms) + (portTICK_PERIOD_MS-1) + portTICK_PERIOD_MS/2 ) / portTICK_PERIOD_MS)
+
+#define SHT3x_MEAS_DURATION_REP_HIGH   15
+#define SHT3x_MEAS_DURATION_REP_MEDIUM 6
+#define SHT3x_MEAS_DURATION_REP_LOW    4
+
+// measurement durations in us 
+const uint16_t SHT3x_MEAS_DURATION_US[3] = { SHT3x_MEAS_DURATION_REP_HIGH   * 1000, 
+                                             SHT3x_MEAS_DURATION_REP_MEDIUM * 1000, 
+                                             SHT3x_MEAS_DURATION_REP_LOW    * 1000 };
+
+// measurement durations in RTOS ticks
+const uint8_t SHT3x_MEAS_DURATION_TICKS[3] = { TIME_TO_TICKS(SHT3x_MEAS_DURATION_REP_HIGH), 
+                                               TIME_TO_TICKS(SHT3x_MEAS_DURATION_REP_MEDIUM), 
+                                               TIME_TO_TICKS(SHT3x_MEAS_DURATION_REP_LOW) };
+
+#if defined(SHT3x_DEBUG_LEVEL_2)
+#define debug(s, f, ...) printf("%s %s: " s "\n", "SHT3x", f, ## __VA_ARGS__)
+#define debug_dev(s, f, d, ...) printf("%s %s: bus %d, addr %02x - " s "\n", "SHT3x", f, d->bus, d->addr, ## __VA_ARGS__)
+#else
+#define debug(s, f, ...)
+#define debug_dev(s, f, d, ...)
+#endif
+
+#if defined(SHT3x_DEBUG_LEVEL_1) || defined(SHT3x_DEBUG_LEVEL_2)
+#define error(s, f, ...) printf("%s %s: " s "\n", "SHT3x", f, ## __VA_ARGS__)
+#define error_dev(s, f, d, ...) printf("%s %s: bus %d, addr %02x - " s "\n", "SHT3x", f, d->bus, d->addr, ## __VA_ARGS__)
+#else
+#define error(s, f, ...)
+#define error_dev(s, f, d, ...)
+#endif
+
+/** Forward declaration of function for internal use */
+
+static bool sht3x_is_measuring  (sht3x_sensor_t*);
+static bool sht3x_send_command  (sht3x_sensor_t*, uint16_t);
+static bool sht3x_read_data     (sht3x_sensor_t*, uint8_t*,  uint32_t);
+static bool sht3x_get_status    (sht3x_sensor_t*, uint16_t*);
+static bool sht3x_reset         (sht3x_sensor_t*);
+
+static uint8_t crc8 (uint8_t data[], int len);
+
+/** ------------------------------------------------ */
+
+bool sht3x_init_driver()
+{
+    return true;
+}
+
+
+sht3x_sensor_t* sht3x_init_sensor(uint8_t bus, uint8_t addr)
+{
+    sht3x_sensor_t* dev;
+
+    if ((dev = malloc (sizeof(sht3x_sensor_t))) == NULL)
+        return NULL;
+    
+    // inititalize sensor data structure
+    dev->bus  = bus;
+    dev->addr = addr;
+    dev->mode = sht3x_single_shot;
+    dev->meas_start_time = 0;
+    dev->meas_started = false;
+    dev->meas_first = false;
+
+    uint16_t status;
+
+    // try to reset the sensor
+    if (!sht3x_reset(dev))
+    {
+        debug_dev ("could not reset the sensor", __FUNCTION__, dev);
+    }
+    
+    // check again the status after clear status command
+    if (!sht3x_get_status(dev, &status))
+    {
+        error_dev ("could not get sensor status", __FUNCTION__, dev);
+        free(dev);
+        return NULL;       
+    }
+    
+    debug_dev ("sensor initialized", __FUNCTION__, dev);
+    return dev;
+}
+
+
+bool sht3x_measure (sht3x_sensor_t* dev, float* temperature, float* humidity)
+{
+    if (!dev || (!temperature && !humidity)) return false;
+
+    if (!sht3x_start_measurement (dev, sht3x_single_shot, sht3x_high))
+        return false;
+
+    vTaskDelay (SHT3x_MEAS_DURATION_TICKS[sht3x_high]);
+
+    sht3x_raw_data_t raw_data;
+    
+    if (!sht3x_get_raw_data (dev, raw_data))
+        return false;
+        
+    return sht3x_compute_values (raw_data, temperature, humidity);
+}
+
+
+bool sht3x_start_measurement (sht3x_sensor_t* dev, sht3x_mode_t mode, sht3x_repeat_t repeat)
+{
+    if (!dev) return false;
+    
+    dev->error_code = SHT3x_OK;
+    dev->mode = mode;
+    dev->repeatability = repeat;
+    
+    // start measurement according to selected mode and return an duration estimate
+    if (!sht3x_send_command(dev, SHT3x_MEASURE_CMD[mode][repeat]))
+    {
+        error_dev ("could not send start measurment command", __FUNCTION__, dev);
+        dev->error_code |= SHT3x_SEND_MEAS_CMD_FAILED;
+        return false;
+    }
+
+    dev->meas_start_time = sdk_system_get_time ();
+    dev->meas_started = true;
+    dev->meas_first = true;
+
+    return true;
+}
+
+
+uint8_t sht3x_get_measurement_duration (sht3x_repeat_t repeat)
+{
+    return SHT3x_MEAS_DURATION_TICKS[repeat];  // in RTOS ticks
+}
+
+
+bool sht3x_get_raw_data(sht3x_sensor_t* dev, sht3x_raw_data_t raw_data)
+{
+    if (!dev || !raw_data) return false;
+
+    dev->error_code = SHT3x_OK;
+
+    if (!dev->meas_started)
+    {
+        debug_dev ("measurement is not started", __FUNCTION__, dev);
+        dev->error_code = SHT3x_MEAS_NOT_STARTED;
+        return sht3x_is_measuring (dev);
+    }
+
+    if (sht3x_is_measuring(dev))
+    {
+        error_dev ("measurement is still running", __FUNCTION__, dev);
+        dev->error_code = SHT3x_MEAS_STILL_RUNNING;
+        return false;
+    }
+
+    // send fetch command in any periodic mode (mode > 0) before read raw data
+    if (dev->mode && !sht3x_send_command(dev, SHT3x_FETCH_DATA_CMD))
+    {
+        debug_dev ("send fetch command failed", __FUNCTION__, dev);
+        dev->error_code |= SHT3x_SEND_FETCH_CMD_FAILED;
+        return false;
+    }
+
+    // read raw data
+    if (!sht3x_read_data(dev, raw_data, sizeof(sht3x_raw_data_t)))
+    {
+        error_dev ("read raw data failed", __FUNCTION__, dev);
+        dev->error_code |= SHT3x_READ_RAW_DATA_FAILED;
+        return false;
+    }
+
+    // reset first measurement flag
+    dev->meas_first = false;
+    
+    // reset measurement started flag in single shot mode
+    if (dev->mode == sht3x_single_shot)
+        dev->meas_started = false;
+    
+    // check temperature crc
+    if (crc8(raw_data,2) != raw_data[2])
+    {
+        error_dev ("CRC check for temperature data failed", __FUNCTION__, dev);
+        dev->error_code |= SHT3x_WRONG_CRC_TEMPERATURE;
+        return false;
+    }
+
+    // check humidity crc
+    if (crc8(raw_data+3,2) != raw_data[5])
+    {
+        error_dev ("CRC check for humidity data failed", __FUNCTION__, dev);
+        dev->error_code |= SHT3x_WRONG_CRC_HUMIDITY;
+        return false;
+    }
+
+    return true;
+}
+
+
+bool sht3x_compute_values (sht3x_raw_data_t raw_data, float* temperature, float* humidity)
+{
+    if (!raw_data) return false;
+
+    if (temperature) 
+        *temperature = ((((raw_data[0] * 256.0) + raw_data[1]) * 175) / 65535.0) - 45;
+
+    if (humidity)
+        *humidity = ((((raw_data[3] * 256.0) + raw_data[4]) * 100) / 65535.0);
+  
+    return true;    
+}
+
+
+bool sht3x_get_results (sht3x_sensor_t* dev, float* temperature, float* humidity)
+{
+    if (!dev || (!temperature && !humidity)) return false;
+
+    sht3x_raw_data_t raw_data;
+    
+    if (!sht3x_get_raw_data (dev, raw_data))
+        return false;
+        
+    return sht3x_compute_values (raw_data, temperature, humidity);
+}
+
+/* Functions for internal use only */
+
+static bool sht3x_is_measuring (sht3x_sensor_t* dev)
+{
+    if (!dev) return false;
+
+    dev->error_code = SHT3x_OK;
+
+    // not running if measurement is not started at all or 
+    // it is not the first measurement in periodic mode
+    if (!dev->meas_started || !dev->meas_first)
+      return false;
+    
+    // not running if time elapsed is greater than duration
+    uint32_t elapsed = sdk_system_get_time() - dev->meas_start_time;
+
+    return elapsed < SHT3x_MEAS_DURATION_US[dev->repeatability];
+}
+
+
+static bool sht3x_send_command(sht3x_sensor_t* dev, uint16_t cmd)
+{
+    if (!dev) return false;
+
+    uint8_t data[2] = { cmd >> 8, cmd & 0xff };
+
+    debug_dev ("send command MSB=%02x LSB=%02x", __FUNCTION__, dev, data[0], data[1]);
+
+    int err = i2c_slave_write(dev->bus, dev->addr, 0, data, 2);
+  
+    if (err)
+    {
+        dev->error_code |= (err == -EBUSY) ? SHT3x_I2C_BUSY : SHT3x_I2C_SEND_CMD_FAILED;
+        error_dev ("i2c error %d on write command %02x", __FUNCTION__, dev, err, cmd);
+        return false;
+    }
+
+    return true;
+}
+
+static bool sht3x_read_data(sht3x_sensor_t* dev, uint8_t *data,  uint32_t len)
+{
+    if (!dev) return false;
+    int err = i2c_slave_read(dev->bus, dev->addr, 0, data, len);
+        
+    if (err)
+    {
+        dev->error_code |= (err == -EBUSY) ? SHT3x_I2C_BUSY : SHT3x_I2C_READ_FAILED;
+        error_dev ("error %d on read %d byte", __FUNCTION__, dev, err, len);
+        return false;
+    }
+
+#   ifdef SHT3x_DEBUG_LEVEL_2
+    printf("SHT3x %s: bus %d, addr %02x - read following bytes: ", 
+           __FUNCTION__, dev->bus, dev->addr);
+    for (int i=0; i < len; i++)
+        printf("%02x ", data[i]);
+    printf("\n");
+#   endif // ifdef SHT3x_DEBUG_LEVEL_2
+
+    return true;
+}
+
+
+static bool sht3x_reset (sht3x_sensor_t* dev)
+{
+    if (!dev) return false;
+
+    debug_dev ("soft-reset triggered", __FUNCTION__, dev);
+    
+    dev->error_code = SHT3x_OK;
+
+    // send reset command
+    if (!sht3x_send_command(dev, SHT3x_RESET_CMD))
+    {
+        dev->error_code |= SHT3x_SEND_RESET_CMD_FAILED;
+        return false;
+    }   
+    // wait for small amount of time needed (according to datasheet 0.5ms)
+    vTaskDelay (100 / portTICK_PERIOD_MS);
+    
+    uint16_t status;
+
+    // check the status after reset
+    if (!sht3x_get_status(dev, &status))
+        return false;
+        
+    return true;    
+}
+
+
+static bool sht3x_get_status (sht3x_sensor_t* dev, uint16_t* status)
+{
+    if (!dev || !status) return false;
+
+    dev->error_code = SHT3x_OK;
+
+    uint8_t  data[3];
+
+    if (!sht3x_send_command(dev, SHT3x_STATUS_CMD) || !sht3x_read_data(dev, data, 3))
+    {
+        dev->error_code |= SHT3x_SEND_STATUS_CMD_FAILED;
+        return false;
+    }
+
+    *status = data[0] << 8 | data[1];
+    debug_dev ("status=%02x", __FUNCTION__, dev, *status);
+    return true;
+}
+
+
+const uint8_t g_polynom = 0x31;
+
+static uint8_t crc8 (uint8_t data[], int len)
+{
+    // initialization value
+    uint8_t crc = 0xff;
+    
+    // iterate over all bytes
+    for (int i=0; i < len; i++)
+    {
+        crc ^= data[i];  
+    
+        for (int i = 0; i < 8; i++)
+        {
+            bool xor = crc & 0x80;
+            crc = crc << 1;
+            crc = xor ? crc ^ g_polynom : crc;
+        }
+    }
+
+    return crc;
+} 
+
+

components-todo/sht3x/sht3x.h

@@ -0,0 +1,280 @@
+/*
+ * Driver for Sensirion SHT3x digital temperature and humidity sensor
+ * connected to I2C
+ *
+ * This driver is for the usage with the ESP8266 and FreeRTOS (esp-open-rtos)
+ * [https://github.com/SuperHouse/esp-open-rtos]. It is also working with ESP32
+ * and ESP-IDF [https://github.com/espressif/esp-idf.git] as well as Linux
+ * based systems using a wrapper library for ESP8266 functions.
+ *
+ * ----------------------------------------------------------------
+ *
+ * The BSD License (3-clause license)
+ *
+ * Copyright (c) 2017 Gunar Schorcht (https://github.com/gschorcht)
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its 
+ * contributors may be used to endorse or promote products derived from this
+ * software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+ 
+#ifndef __SHT3x_H__
+#define __SHT3x_H__
+
+// Uncomment to enable debug output
+// #define SHT3x_DEBUG_LEVEL_1     // only error messages
+// #define SHT3x_DEBUG_LEVEL_2     // error and debug messages
+
+#include "stdint.h"
+#include "stdbool.h"
+
+#include "sht3x_platform.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// definition of possible I2C slave addresses
+#define SHT3x_ADDR_1 0x44        // ADDR pin connected to GND/VSS (default)
+#define SHT3x_ADDR_2 0x45        // ADDR pin connected to VDD
+
+// definition of error codes
+#define SHT3x_OK                     0
+#define SHT3x_NOK                    -1
+
+#define SHT3x_I2C_ERROR_MASK         0x000f
+#define SHT3x_DRV_ERROR_MASK         0xfff0
+
+// error codes for I2C interface ORed with SHT3x error codes
+#define SHT3x_I2C_READ_FAILED        1
+#define SHT3x_I2C_SEND_CMD_FAILED    2
+#define SHT3x_I2C_BUSY               3
+
+// SHT3x driver error codes OR ed with error codes for I2C interface
+#define SHT3x_MEAS_NOT_STARTED       (1  << 8)
+#define SHT3x_MEAS_ALREADY_RUNNING   (2  << 8)
+#define SHT3x_MEAS_STILL_RUNNING     (3  << 8)
+#define SHT3x_READ_RAW_DATA_FAILED   (4  << 8)
+
+#define SHT3x_SEND_MEAS_CMD_FAILED   (5  << 8)
+#define SHT3x_SEND_RESET_CMD_FAILED  (6  << 8)
+#define SHT3x_SEND_STATUS_CMD_FAILED (7  << 8)
+#define SHT3x_SEND_FETCH_CMD_FAILED  (8  << 8)
+
+#define SHT3x_WRONG_CRC_TEMPERATURE  (9  << 8)
+#define SHT3x_WRONG_CRC_HUMIDITY     (10 << 8)
+
+#define SHT3x_RAW_DATA_SIZE 6
+
+/**
+ * @brief	raw data type
+ */
+typedef uint8_t sht3x_raw_data_t [SHT3x_RAW_DATA_SIZE];
+
+
+/**
+ * @brief   possible measurement modes
+ */
+typedef enum {
+    sht3x_single_shot = 0,  // one single measurement
+    sht3x_periodic_05mps,   // periodic with 0.5 measurements per second (mps)
+    sht3x_periodic_1mps,    // periodic with   1 measurements per second (mps)
+    sht3x_periodic_2mps,    // periodic with   2 measurements per second (mps)
+    sht3x_periodic_4mps,    // periodic with   4 measurements per second (mps)
+    sht3x_periodic_10mps    // periodic with  10 measurements per second (mps)
+} sht3x_mode_t;
+    
+    
+/**
+ * @brief   possible repeatability modes
+ */
+typedef enum {
+    sht3x_high = 0,
+    sht3x_medium,
+    sht3x_low
+} sht3x_repeat_t;
+
+/**
+ * @brief 	SHT3x sensor device data structure type
+ */
+typedef struct {
+
+    uint32_t        error_code;      // combined error codes
+    
+    uint8_t         bus;             // I2C bus at which sensor is connected
+    uint8_t         addr;            // I2C slave address of the sensor
+    
+    sht3x_mode_t    mode;            // used measurement mode
+    sht3x_repeat_t  repeatability;   // used repeatability
+ 
+    bool            meas_started;    // indicates whether measurement started
+    uint32_t        meas_start_time; // measurement start time in us
+    bool            meas_first;      // first measurement in periodic mode
+    
+} sht3x_sensor_t;    
+
+
+/**
+ * @brief	Initialize a SHT3x sensor
+ * 
+ * The function creates a data structure describing the sensor and
+ * initializes the sensor device.
+ *  
+ * @param   bus       I2C bus at which the sensor is connected
+ * @param   addr      I2C slave address of the sensor
+ * @return            pointer to sensor data structure, or NULL on error
+ */
+sht3x_sensor_t* sht3x_init_sensor (uint8_t bus, uint8_t addr);
+
+
+/**
+ * @brief   High level measurement function
+ *
+ * For convenience this function comprises all three steps to perform
+ * one measurement in only one function:
+ *
+ * 1. Starts a measurement in single shot mode with high reliability
+ * 2. Waits using *vTaskDelay* until measurement results are available 
+ * 3. Returns the results in kind of floating point sensor values 
+ *
+ * This function is the easiest way to use the sensor. It is most suitable
+ * for users that don't want to have the control on sensor details.
+ *
+ * Please note: The function delays the calling task up to 30 ms to wait for
+ * the  the measurement results. This might lead to problems when the function
+ * is called from a software timer callback function.
+ *
+ * @param   dev         pointer to sensor device data structure
+ * @param   temperature returns temperature in degree Celsius   
+ * @param   humidity    returns humidity in percent
+ * @return              true on success, false on error
+ */
+bool sht3x_measure (sht3x_sensor_t* dev, float* temperature, float* humidity);
+
+
+/**
+ * @brief	Start the measurement in single shot or periodic mode
+ *
+ * The function starts the measurement either in *single shot mode* 
+ * (exactly one measurement) or *periodic mode* (periodic measurements)
+ * with given repeatabilty.
+ *
+ * In the *single shot mode*, this function has to be called for each
+ * measurement. The measurement duration has to be waited every time
+ * before the results can be fetched. 
+ *
+ * In the *periodic mode*, this function has to be called only once. Also 
+ * the measurement duration has to be waited only once until the first
+ * results are available. After this first measurement, the sensor then
+ * automatically performs all subsequent measurements. The rate of periodic
+ * measurements can be 10, 4, 2, 1 or 0.5 measurements per second (mps).
+ * 
+ * Please note: Due to inaccuracies in timing of the sensor, the user task
+ * should fetch the results at a lower rate. The rate of the periodic
+ * measurements is defined by the parameter *mode*.
+ *
+ * @param   dev         pointer to sensor device data structure
+ * @param   mode        measurement mode, see type *sht3x_mode_t*
+ * @param   repeat      repeatability, see type *sht3x_repeat_t*
+ * @return              true on success, false on error
+ */
+bool sht3x_start_measurement (sht3x_sensor_t* dev, sht3x_mode_t mode,
+                              sht3x_repeat_t repeat);
+
+/**
+ * @brief   Get the duration of a measurement in RTOS ticks.
+ *
+ * The function returns the duration in RTOS ticks required by the sensor to
+ * perform a measurement for the given repeatability. Once a measurement is
+ * started with function *sht3x_start_measurement* the user task can use this
+ * duration in RTOS ticks directly to wait with function *vTaskDelay* until
+ * the measurement results can be fetched.
+ *
+ * Please note: The duration only depends on repeatability level. Therefore,
+ * it can be considered as constant for a repeatibility.
+ *
+ * @param   repeat      repeatability, see type *sht3x_repeat_t*
+ * @return              measurement duration given in RTOS ticks
+ */
+uint8_t sht3x_get_measurement_duration (sht3x_repeat_t repeat);
+
+
+/**
+ * @brief	Read measurement results from sensor as raw data
+ *
+ * The function read measurement results from the sensor, checks the CRC
+ * checksum and stores them in the byte array as following.
+ *
+ *      data[0] = Temperature MSB
+ *      data[1] = Temperature LSB
+ *      data[2] = Temperature CRC
+ *      data[3] = Pressure MSB
+ *      data[4] = Pressure LSB 
+ *      data[2] = Pressure CRC
+ *
+ * In case that there are no new data that can be read, the function fails.
+ * 
+ * @param   dev         pointer to sensor device data structure
+ * @param   raw_data    byte array in which raw data are stored 
+ * @return              true on success, false on error
+ */
+bool sht3x_get_raw_data(sht3x_sensor_t* dev, sht3x_raw_data_t raw_data);
+
+
+/**
+ * @brief	Computes sensor values from raw data
+ *
+ * @param   raw_data    byte array that contains raw data  
+ * @param   temperature returns temperature in degree Celsius   
+ * @param   humidity    returns humidity in percent
+ * @return              true on success, false on error
+ */
+bool sht3x_compute_values (sht3x_raw_data_t raw_data, 
+                           float* temperature, float* humidity);
+
+
+/**
+ * @brief	Get measurement results in form of sensor values
+ *
+ * The function combines function *sht3x_read_raw_data* and function 
+ * *sht3x_compute_values* to get the measurement results.
+ * 
+ * In case that there are no results that can be read, the function fails.
+ *
+ * @param   dev         pointer to sensor device data structure
+ * @param   temperature returns temperature in degree Celsius   
+ * @param   humidity    returns humidity in percent
+ * @return              true on success, false on error
+ */
+bool sht3x_get_results (sht3x_sensor_t* dev, 
+                        float* temperature, float* humidity);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __SHT3x_H__ */

components-todo/sht3x/sht3x_platform.h

@@ -0,0 +1,70 @@
+/*
+ * Driver for Sensirion SHT3x digital temperature and humidity sensor
+ * connected to I2C
+ *
+ * This driver is for the usage with the ESP8266 and FreeRTOS (esp-open-rtos)
+ * [https://github.com/SuperHouse/esp-open-rtos]. It is also working with ESP32
+ * and ESP-IDF [https://github.com/espressif/esp-idf.git] as well as Linux
+ * based systems using a wrapper library for ESP8266 functions.
+ *
+ * ----------------------------------------------------------------
+ *
+ * The BSD License (3-clause license)
+ *
+ * Copyright (c) 2017 Gunar Schorcht (https://github.com/gschorcht)
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its 
+ * contributors may be used to endorse or promote products derived from this
+ * software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+ 
+/**
+ * Platform file: platform specific definitions, includes and functions
+ */
+
+#ifndef __SHT3x_PLATFORM_H__
+#define __SHT3x_PLATFORM_H__
+
+#if !defined(ESP_OPEN_RTOS)
+#define ESP_OPEN_RTOS 1
+#endif
+
+#ifdef ESP_OPEN_RTOS  // ESP8266
+
+// platform specific includes
+
+#include "FreeRTOS.h"
+#include "task.h"
+
+#include "espressif/esp_common.h"
+#include "espressif/sdk_private.h"
+
+#include "esp/uart.h"
+#include "i2c/i2c.h"
+
+#endif // ESP_OPEN_RTOS
+
+#endif // __SHT3x_PLATFORM_H__

components/cmd_system/CMakeLists.txt

@@ -0,0 +1,7 @@
+set(COMPONENT_ADD_INCLUDEDIRS .)
+
+set(COMPONENT_SRCS "cmd_system.c")
+
+set(COMPONENT_REQUIRES console spi_flash)
+
+register_component()

components/cmd_system/cmd_system.c

@@ -0,0 +1,173 @@
+/* Console example — various system commands
+
+   This example code is in the Public Domain (or CC0 licensed, at your option.)
+
+   Unless required by applicable law or agreed to in writing, this
+   software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+   CONDITIONS OF ANY KIND, either express or implied.
+*/
+
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+#include "esp_log.h"
+#include "esp_attr.h"
+#include "esp_console.h"
+#include "esp_system.h"
+#include "esp_sleep.h"
+#include "esp_spi_flash.h"
+#include "argtable3/argtable3.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "driver/uart.h"
+#include "rom/uart.h"
+#include "cmd_system.h"
+#include "sdkconfig.h"
+
+#ifdef CONFIG_FREERTOS_USE_STATS_FORMATTING_FUNCTIONS
+#define WITH_TASKS_INFO 1
+#endif
+
+static const char *TAG = "cmd_system";
+
+static void register_free();
+static void register_heap();
+static void register_version();
+static void register_restart();
+#if WITH_TASKS_INFO
+static void register_tasks();
+#endif
+
+void console_register_system()
+{
+    register_free();
+    register_heap();
+    register_version();
+    register_restart();
+#if WITH_TASKS_INFO
+    register_tasks();
+#endif
+}
+
+/* 'version' command */
+static int get_version(int argc, char **argv)
+{
+    esp_chip_info_t info;
+    esp_chip_info(&info);
+    printf("IDF Version:%s\r\n", esp_get_idf_version());
+    printf("Chip info:\r\n");
+    printf("\tmodel:%s\r\n", info.model == CHIP_ESP8266 ? "ESP8266" : "Unknow");
+    printf("\tcores:%d\r\n", info.cores);
+    printf("\tfeature:%s%s%s%s%d%s\r\n",
+           info.features & CHIP_FEATURE_WIFI_BGN ? "/802.11bgn" : "",
+           info.features & CHIP_FEATURE_BLE ? "/BLE" : "",
+           info.features & CHIP_FEATURE_BT ? "/BT" : "",
+           info.features & CHIP_FEATURE_EMB_FLASH ? "/Embedded-Flash:" : "/External-Flash:",
+           spi_flash_get_chip_size() / (1024 * 1024), " MB");
+    printf("\trevision number:%d\r\n", info.revision);
+    return 0;
+}
+
+static void register_version()
+{
+    const esp_console_cmd_t cmd = {
+        .command = "version",
+        .help = "Get version of chip and SDK",
+        .hint = NULL,
+        .func = &get_version,
+    };
+    ESP_ERROR_CHECK( esp_console_cmd_register(&cmd) );
+}
+
+/** 'restart' command restarts the program */
+
+static int restart(int argc, char **argv)
+{
+    ESP_LOGI(TAG, "Restarting");
+    esp_restart();
+}
+
+static void register_restart()
+{
+    const esp_console_cmd_t cmd = {
+        .command = "restart",
+        .help = "Software reset of the chip",
+        .hint = NULL,
+        .func = &restart,
+    };
+    ESP_ERROR_CHECK( esp_console_cmd_register(&cmd) );
+}
+
+/** 'free' command prints available heap memory */
+
+static int free_mem(int argc, char **argv)
+{
+    printf("%d\n", esp_get_free_heap_size());
+    return 0;
+}
+
+static void register_free()
+{
+    const esp_console_cmd_t cmd = {
+        .command = "free",
+        .help = "Get the current size of free heap memory",
+        .hint = NULL,
+        .func = &free_mem,
+    };
+    ESP_ERROR_CHECK( esp_console_cmd_register(&cmd) );
+}
+
+/* 'heap' command prints minumum heap size */
+static int heap_size(int argc, char **argv)
+{
+    uint32_t heap_size = heap_caps_get_minimum_free_size(MALLOC_CAP_32BIT);
+    ESP_LOGI(TAG, "min heap size: %u", heap_size);
+    return 0;
+}
+
+static void register_heap()
+{
+    const esp_console_cmd_t heap_cmd = {
+        .command = "heap",
+        .help = "Get minimum size of free heap memory that was available during program execution",
+        .hint = NULL,
+        .func = &heap_size,
+    };
+    ESP_ERROR_CHECK( esp_console_cmd_register(&heap_cmd) );
+
+}
+
+/** 'tasks' command prints the list of tasks and related information */
+#if WITH_TASKS_INFO
+
+static int tasks_info(int argc, char **argv)
+{
+    const size_t bytes_per_task = 40; /* see vTaskList description */
+    char *task_list_buffer = malloc(uxTaskGetNumberOfTasks() * bytes_per_task);
+    if (task_list_buffer == NULL) {
+        ESP_LOGE(TAG, "failed to allocate buffer for vTaskList output");
+        return 1;
+    }
+    fputs("Task Name\tStatus\tPrio\tHWM\tTask#", stdout);
+#ifdef CONFIG_FREERTOS_VTASKLIST_INCLUDE_COREID
+    fputs("\tAffinity", stdout);
+#endif
+    fputs("\n", stdout);
+    vTaskList(task_list_buffer);
+    fputs(task_list_buffer, stdout);
+    free(task_list_buffer);
+    return 0;
+}
+
+static void register_tasks()
+{
+    const esp_console_cmd_t cmd = {
+        .command = "tasks",
+        .help = "Get information about running tasks",
+        .hint = NULL,
+        .func = &tasks_info,
+    };
+    ESP_ERROR_CHECK( esp_console_cmd_register(&cmd) );
+}
+
+#endif // WITH_TASKS_INFO

components/cmd_system/cmd_system.h

@@ -0,0 +1,20 @@
+/* Console example — various system commands
+
+   This example code is in the Public Domain (or CC0 licensed, at your option.)
+
+   Unless required by applicable law or agreed to in writing, this
+   software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+   CONDITIONS OF ANY KIND, either express or implied.
+*/
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Register system functions
+void console_register_system();
+
+#ifdef __cplusplus
+}
+#endif

components/cmd_system/component.mk

@@ -0,0 +1,10 @@
+#
+# Component Makefile
+#
+# This Makefile should, at the very least, just include $(SDK_PATH)/Makefile. By default,
+# this will take the sources in the src/ directory, compile them and link them into
+# lib(subdirectory_name).a in the build directory. This behaviour is entirely configurable,
+# please read the SDK documents if you need to do this.
+#
+
+COMPONENT_ADD_INCLUDEDIRS := .

components/dht/CMakeLists.txt

@@ -0,0 +1,5 @@
+set(COMPONENT_ADD_INCLUDEDIRS .)
+
+set(COMPONENT_SRCS "dht.c")
+
+register_component()

components/dht/component.mk

@@ -0,0 +1,10 @@
+#
+# Component Makefile
+#
+# This Makefile should, at the very least, just include $(SDK_PATH)/Makefile. By default,
+# this will take the sources in the src/ directory, compile them and link them into
+# lib(subdirectory_name).a in the build directory. This behaviour is entirely configurable,
+# please read the SDK documents if you need to do this.
+#
+
+COMPONENT_ADD_INCLUDEDIRS := .

components/dht/dht.c

@@ -0,0 +1,194 @@
+/*
+ * Part of esp-open-rtos
+ * Copyright (C) 2016 Jonathan Hartsuiker (https://github.com/jsuiker)
+ * BSD Licensed as described in the file LICENSE
+ *
+ */
+
+#include "dht.h"
+#include "FreeRTOS.h"
+#include "string.h"
+#include "task.h"
+#include "driver/gpio.h"
+
+// DHT timer precision in microseconds
+#define DHT_TIMER_INTERVAL 2
+#define DHT_DATA_BITS 40
+
+//#define DEBUG_DHT
+
+// #define DEBUG_DHT
+#ifdef DEBUG_DHT
+#define debug(fmt, ...) printf("%s" fmt "\n", "dht: ", ## __VA_ARGS__);
+#else
+#define debug(fmt, ...) /* (do nothing) */
+#endif
+
+/*
+ *  Note:
+ *  A suitable pull-up resistor should be connected to the selected GPIO line
+ *
+ *  __           ______          _______                              ___________________________
+ *    \    A    /      \   C    /       \   DHT duration_data_low    /                           \
+ *     \_______/   B    \______/    D    \__________________________/   DHT duration_data_high    \__
+ *
+ *
+ *  Initializing communications with the DHT requires four 'phases' as follows:
+ *
+ *  Phase A - MCU pulls signal low for at least 18000 us
+ *  Phase B - MCU allows signal to float back up and waits 20-40us for DHT to pull it low
+ *  Phase C - DHT pulls signal low for ~80us
+ *  Phase D - DHT lets signal float back up for ~80us
+ *
+ *  After this, the DHT transmits its first bit by holding the signal low for 50us
+ *  and then letting it float back high for a period of time that depends on the data bit.
+ *  duration_data_high is shorter than 50us for a logic '0' and longer than 50us for logic '1'.
+ *
+ *  There are a total of 40 data bits transmitted sequentially. These bits are read into a byte array
+ *  of length 5.  The first and third bytes are humidity (%) and temperature (C), respectively.  Bytes 2 and 4
+ *  are zero-filled and the fifth is a checksum such that:
+ *
+ *  byte_5 == (byte_1 + byte_2 + byte_3 + btye_4) & 0xFF
+ *
+*/
+
+
+/**
+ * Wait specified time for pin to go to a specified state.
+ * If timeout is reached and pin doesn't go to a requested state
+ * false is returned.
+ * The elapsed time is returned in pointer 'duration' if it is not NULL.
+ */
+static bool dht_await_pin_state(uint8_t pin, uint32_t timeout,
+        bool expected_pin_state, uint32_t *duration)
+{
+    for (uint32_t i = 0; i < timeout; i += DHT_TIMER_INTERVAL) {
+        // need to wait at least a single interval to prevent reading a jitter
+        os_delay_us(DHT_TIMER_INTERVAL);
+        if (gpio_get_level(pin) == expected_pin_state) {
+            if (duration) {
+                *duration = i;
+            }
+            return true;
+        }
+    }
+
+    return false;
+}
+
+/**
+ * Request data from DHT and read raw bit stream.
+ * The function call should be protected from task switching.
+ * Return false if error occurred.
+ */
+static inline bool dht_fetch_data(dht_sensor_type_t sensor_type, uint8_t pin, bool bits[DHT_DATA_BITS])
+{
+    uint32_t low_duration;
+    uint32_t high_duration;
+
+    // Phase 'A' pulling signal low to initiate read sequence
+    gpio_set_level(pin, 0);
+    os_delay_us(sensor_type == DHT_TYPE_SI7021 ? 500 : 20000);
+    gpio_set_level(pin, 1);
+
+    // Step through Phase 'B', 40us
+    if (!dht_await_pin_state(pin, 40, false, NULL)) {
+        debug("Initialization error, problem in phase 'B'\n");
+        return false;
+    }
+
+    // Step through Phase 'C', 88us
+    if (!dht_await_pin_state(pin, 88, true, NULL)) {
+        debug("Initialization error, problem in phase 'C'\n");
+        return false;
+    }
+
+    // Step through Phase 'D', 88us
+    if (!dht_await_pin_state(pin, 88, false, NULL)) {
+        debug("Initialization error, problem in phase 'D'\n");
+        return false;
+    }
+
+    // Read in each of the 40 bits of data...
+    for (int i = 0; i < DHT_DATA_BITS; i++) {
+        if (!dht_await_pin_state(pin, 65, true, &low_duration)) {
+            debug("LOW bit timeout\n");
+            return false;
+        }
+        if (!dht_await_pin_state(pin, 75, false, &high_duration)) {
+            debug("HIGHT bit timeout\n");
+            return false;
+        }
+        bits[i] = high_duration > low_duration;
+    }
+    return true;
+}
+
+/**
+ * Pack two data bytes into single value and take into account sign bit.
+ */
+static inline int16_t dht_convert_data(dht_sensor_type_t sensor_type, uint8_t msb, uint8_t lsb)
+{
+    int16_t data;
+
+    if (sensor_type == DHT_TYPE_DHT22) {
+        data = msb & 0x7F;
+        data <<= 8;
+        data |= lsb;
+        if (msb & BIT(7)) {
+            data = 0 - data;       // convert it to negative
+        }
+    }
+    else {
+        data = msb * 10;
+    }
+
+    return data;
+}
+
+bool dht_read_data(dht_sensor_type_t sensor_type, uint8_t pin, int16_t *humidity, int16_t *temperature)
+{
+    bool bits[DHT_DATA_BITS];
+    uint8_t data[DHT_DATA_BITS/8] = {0};
+    bool result;
+
+    gpio_set_direction(pin, GPIO_MODE_OUTPUT_OD);
+
+    taskENTER_CRITICAL();
+    result = dht_fetch_data(sensor_type, pin, bits);
+    taskEXIT_CRITICAL();
+
+    if (!result) {
+        return false;
+    }
+
+    for (uint8_t i = 0; i < DHT_DATA_BITS; i++) {
+        // Read each bit into 'result' byte array...
+        data[i/8] <<= 1;
+        data[i/8] |= bits[i];
+    }
+
+    if (data[4] != ((data[0] + data[1] + data[2] + data[3]) & 0xFF)) {
+        debug("Checksum failed, invalid data received from sensor\n");
+        return false;
+    }
+
+    *humidity = dht_convert_data(sensor_type, data[0], data[1]);
+    *temperature = dht_convert_data(sensor_type, data[2], data[3]);
+
+    debug("Sensor data: humidity=%d, temp=%d\n", *humidity, *temperature);
+
+    return true;
+}
+
+bool dht_read_float_data(dht_sensor_type_t sensor_type, uint8_t pin, float *humidity, float *temperature)
+{
+    int16_t i_humidity, i_temp;
+
+    if (dht_read_data(sensor_type, pin, &i_humidity, &i_temp)) {
+        *humidity = (float)i_humidity / 10;
+        *temperature = (float)i_temp / 10;
+        return true;
+    }
+    return false;
+}

components/dht/dht.h

@@ -0,0 +1,50 @@
+/*
+ * Part of esp-open-rtos
+ * Copyright (C) 2016 Jonathan Hartsuiker (https://github.com/jsuiker)
+ * BSD Licensed as described in the file LICENSE
+ *
+ */
+
+#ifndef __DHT_H__
+#define __DHT_H__
+
+#include <stdint.h>
+#include <stdbool.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Sensor type
+ */
+typedef enum
+{
+    DHT_TYPE_DHT11 = 0, //!< DHT11
+    DHT_TYPE_DHT22,     //!< DHT22
+    DHT_TYPE_SI7021     //!< Itead SI7021
+} dht_sensor_type_t;
+
+/**
+ * Read data from sensor on specified pin.
+ *
+ * Humidity and temperature is returned as integers.
+ * For example: humidity=625 is 62.5 %
+ *              temperature=24.4 is 24.4 degrees Celsius
+ *
+ */
+bool dht_read_data(dht_sensor_type_t sensor_type, uint8_t pin, int16_t *humidity, int16_t *temperature);
+
+
+/**
+ * Float version of dht_read_data.
+ *
+ * Return values as floating point values.
+ */
+bool dht_read_float_data(dht_sensor_type_t sensor_type, uint8_t pin, float *humidity, float *temperature);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // __DHT_H__

components/ds18b20/CMakeLists.txt

@@ -0,0 +1,7 @@
+set(COMPONENT_ADD_INCLUDEDIRS .)
+
+set(COMPONENT_SRCS "onewire.c" "ds18b20.c")
+
+#set(COMPONENT_REQUIRES console spi_flash)
+
+register_component()

components/ds18b20/README.md

@@ -0,0 +1,14 @@
+# Yet another one wire driver for the ESP8266
+
+This is a port of a bit-banging one wire driver based on the implementation
+from NodeMCU.
+
+This, in turn, appears to have been based on the PJRC Teensy driver
+(https://www.pjrc.com/teensy/td_libs_OneWire.html), by Jim Studt, Paul
+Stoffregen, and a host of others.
+
+The original code is licensed under the MIT license.  The CRC code was taken
+(at least partially) from Dallas Semiconductor sample code, which was licensed
+under an MIT license with an additional clause (prohibiting inappropriate use
+of the Dallas Semiconductor name).  See the accompanying LICENSE file for
+details.

components/ds18b20/component.mk

@@ -0,0 +1,10 @@
+#
+# Component Makefile
+#
+# This Makefile should, at the very least, just include $(SDK_PATH)/Makefile. By default,
+# this will take the sources in the src/ directory, compile them and link them into
+# lib(subdirectory_name).a in the build directory. This behaviour is entirely configurable,
+# please read the SDK documents if you need to do this.
+#
+
+COMPONENT_ADD_INCLUDEDIRS := .

components/ds18b20/ds18b20.c

@@ -0,0 +1,253 @@
+#include "FreeRTOS.h"
+#include "task.h"
+#include "math.h"
+
+#include "ds18b20.h"
+
+#define DS18B20_WRITE_SCRATCHPAD 0x4E
+#define DS18B20_READ_SCRATCHPAD  0xBE
+#define DS18B20_COPY_SCRATCHPAD  0x48
+#define DS18B20_READ_EEPROM      0xB8
+#define DS18B20_READ_PWRSUPPLY   0xB4
+#define DS18B20_SEARCHROM        0xF0
+#define DS18B20_SKIP_ROM         0xCC
+#define DS18B20_READROM          0x33
+#define DS18B20_MATCHROM         0x55
+#define DS18B20_ALARMSEARCH      0xEC
+#define DS18B20_CONVERT_T        0x44
+
+#define os_sleep_ms(x) vTaskDelay(((x) + portTICK_PERIOD_MS - 1) / portTICK_PERIOD_MS)
+
+#define DS18B20_FAMILY_ID 0x28
+#define DS18S20_FAMILY_ID 0x10
+
+#ifdef DS18B20_DEBUG
+#define debug(fmt, ...) printf("%s" fmt "\n", "DS18B20: ", ## __VA_ARGS__);
+#else
+#define debug(fmt, ...)
+#endif
+
+uint8_t ds18b20_read_all(uint8_t pin, ds_sensor_t *result) {
+    onewire_addr_t addr;
+    onewire_search_t search;
+    uint8_t sensor_id = 0;
+
+    onewire_search_start(&search);
+
+    while ((addr = onewire_search_next(&search, pin)) != ONEWIRE_NONE) {
+        uint8_t crc = onewire_crc8((uint8_t *)&addr, 7);
+        if (crc != (addr >> 56)){
+            debug("CRC check failed: %02X %02X\n", (unsigned)(addr >> 56), crc);
+            return 0;
+        }
+
+        onewire_reset(pin);
+        onewire_select(pin, addr);
+        onewire_write(pin, DS18B20_CONVERT_T);
+
+        onewire_power(pin);
+        vTaskDelay(750 / portTICK_PERIOD_MS);
+
+        onewire_reset(pin);
+        onewire_select(pin, addr);
+        onewire_write(pin, DS18B20_READ_SCRATCHPAD);
+
+        uint8_t get[10];
+
+        for (int k=0;k<9;k++){
+            get[k]=onewire_read(pin);
+        }
+
+        //debug("\n ScratchPAD DATA = %X %X %X %X %X %X %X %X %X\n",get[8],get[7],get[6],get[5],get[4],get[3],get[2],get[1],get[0]);
+        crc = onewire_crc8(get, 8);
+
+        if (crc != get[8]){
+            debug("CRC check failed: %02X %02X\n", get[8], crc);
+            return 0;
+        }
+
+        uint8_t temp_msb = get[1]; // Sign byte + lsbit
+        uint8_t temp_lsb = get[0]; // Temp data plus lsb
+        uint16_t temp = temp_msb << 8 | temp_lsb;
+
+        float temperature;
+
+        temperature = (temp * 625.0)/10000;
+        //debug("Got a DS18B20 Reading: %d.%02d\n", (int)temperature, (int)(temperature - (int)temperature) * 100);
+        result[sensor_id].id = sensor_id;
+        result[sensor_id].value = temperature;
+        sensor_id++;
+    }
+    return sensor_id;
+}
+
+float ds18b20_read_single(uint8_t pin) {
+
+    onewire_reset(pin);
+    onewire_skip_rom(pin);
+    onewire_write(pin, DS18B20_CONVERT_T);
+
+    onewire_power(pin);
+    vTaskDelay(750 / portTICK_PERIOD_MS);
+
+    onewire_reset(pin);
+    onewire_skip_rom(pin);
+    onewire_write(pin, DS18B20_READ_SCRATCHPAD);
+
+    uint8_t get[10];
+
+    for (int k=0;k<9;k++){
+        get[k]=onewire_read(pin);
+    }
+
+    //debug("\n ScratchPAD DATA = %X %X %X %X %X %X %X %X %X\n",get[8],get[7],get[6],get[5],get[4],get[3],get[2],get[1],get[0]);
+    uint8_t crc = onewire_crc8(get, 8);
+
+    if (crc != get[8]){
+        debug("CRC check failed: %02X %02X", get[8], crc);
+        return 0;
+    }
+
+    uint8_t temp_msb = get[1]; // Sign byte + lsbit
+    uint8_t temp_lsb = get[0]; // Temp data plus lsb
+
+    uint16_t temp = temp_msb << 8 | temp_lsb;
+
+    float temperature;
+
+    temperature = (temp * 625.0)/10000;
+    return temperature;
+    //debug("Got a DS18B20 Reading: %d.%02d\n", (int)temperature, (int)(temperature - (int)temperature) * 100);
+}
+
+bool ds18b20_measure(int pin, ds18b20_addr_t addr, bool wait) {
+    if (!onewire_reset(pin)) {
+        return false;
+    }
+    if (addr == DS18B20_ANY) {
+        onewire_skip_rom(pin);
+    } else {
+        onewire_select(pin, addr);
+    }
+    taskENTER_CRITICAL();
+    onewire_write(pin, DS18B20_CONVERT_T);
+    // For parasitic devices, power must be applied within 10us after issuing
+    // the convert command.
+    onewire_power(pin);
+    taskEXIT_CRITICAL();
+
+    if (wait) {
+        os_sleep_ms(750);
+        onewire_depower(pin);
+    }
+
+    return true;
+}
+
+bool ds18b20_read_scratchpad(int pin, ds18b20_addr_t addr, uint8_t *buffer) {
+    uint8_t crc;
+    uint8_t expected_crc;
+
+    if (!onewire_reset(pin)) {
+        return false;
+    }
+    if (addr == DS18B20_ANY) {
+        onewire_skip_rom(pin);
+    } else {
+        onewire_select(pin, addr);
+    }
+    onewire_write(pin, DS18B20_READ_SCRATCHPAD);
+
+    for (int i = 0; i < 8; i++) {
+        buffer[i] = onewire_read(pin);
+    }
+    crc = onewire_read(pin);
+
+    expected_crc = onewire_crc8(buffer, 8);
+    if (crc != expected_crc) {
+        debug("CRC check failed reading scratchpad: %02x %02x %02x %02x %02x %02x %02x %02x : %02x (expected %02x)\n", buffer[0], buffer[1], buffer[2], buffer[3], buffer[4], buffer[5], buffer[6], buffer[7], crc, expected_crc);
+        return false;
+    }
+
+    return true;
+}
+
+float ds18b20_read_temperature(int pin, ds18b20_addr_t addr) {
+    uint8_t scratchpad[8];
+    int16_t temp;
+
+    if (!ds18b20_read_scratchpad(pin, addr, scratchpad)) {
+        return NAN;
+    }
+
+    temp = (int16_t) ((uint16_t)scratchpad[0] | (uint16_t)(scratchpad[1] << 8));
+
+	if (temp == 0x0550) {
+		return NAN;
+	}
+
+    float res;
+
+    // this was wrong - commented out, nobody uses 18S20 anymore.
+
+//    if ((uint8_t)addr == DS18B20_FAMILY_ID) {
+
+    res = (float)temp * 0.0625f;
+
+//    }
+//    else {
+//        // 18S20?
+//        temp = ((temp & 0xfffe) << 3) + (16 - scratchpad[6]) - 4;
+//        res = ((float)temp * 625.0f)/10000 - 0.25f;
+//    }
+    return res;
+}
+
+float ds18b20_measure_and_read(int pin, ds18b20_addr_t addr) {
+    if (!ds18b20_measure(pin, addr, true)) {
+        return NAN;
+    }
+    return ds18b20_read_temperature(pin, addr);
+}
+
+bool ds18b20_measure_and_read_multi(int pin, ds18b20_addr_t *addr_list, int addr_count, float *result_list) {
+    if (!ds18b20_measure(pin, DS18B20_ANY, true)) {
+        for (int i=0; i < addr_count; i++) {
+            result_list[i] = NAN;
+        }
+        return false;
+    }
+    return ds18b20_read_temp_multi(pin, addr_list, addr_count, result_list);
+}
+
+int ds18b20_scan_devices(int pin, ds18b20_addr_t *addr_list, int addr_count) {
+    onewire_search_t search;
+    onewire_addr_t addr;
+    int found = 0;
+
+    onewire_search_start(&search);
+    while ((addr = onewire_search_next(&search, pin)) != ONEWIRE_NONE) {
+        uint8_t family_id = (uint8_t)addr;
+        if (family_id == DS18B20_FAMILY_ID || family_id == DS18S20_FAMILY_ID) {
+            if (found < addr_count) {
+                addr_list[found] = addr;
+            }
+            found++;
+        }
+    }
+    return found;
+}
+
+bool ds18b20_read_temp_multi(int pin, ds18b20_addr_t *addr_list, int addr_count, float *result_list) {
+    bool result = true;
+
+    for (int i = 0; i < addr_count; i++) {
+        result_list[i] = ds18b20_read_temperature(pin, addr_list[i]);
+        if (isnan(result_list[i])) {
+            result = false;
+        }
+    }
+    return result;
+}
+
+

components/ds18b20/ds18b20.h

@@ -0,0 +1,158 @@
+#ifndef DRIVER_DS18B20_H_
+#define DRIVER_DS18B20_H_
+
+#include "onewire.h"
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+/** @file ds18b20.h
+ *
+ *  Communicate with the DS18B20 family of one-wire temperature sensor ICs.
+ *
+ */
+
+typedef onewire_addr_t ds18b20_addr_t;
+
+/** An address value which can be used to indicate "any device on the bus" */
+#define DS18B20_ANY ONEWIRE_NONE
+
+/** Find the addresses of all DS18B20 devices on the bus.
+ *
+ *  Scans the bus for all devices and places their addresses in the supplied
+ *  array.  If there are more than `addr_count` devices on the bus, only the
+ *  first `addr_count` are recorded.
+ *
+ *  @param pin         The GPIO pin connected to the DS18B20 bus
+ *  @param addr_list   A pointer to an array of ds18b20_addr_t values.  This
+ *                     will be populated with the addresses of the found
+ *                     devices.
+ *  @param addr_count  Number of slots in the `addr_list` array.  At most this
+ *                     many addresses will be returned.
+ *
+ *  @returns The number of devices found.  Note that this may be less than,
+ *  equal to, or more than `addr_count`, depending on how many DS18B20 devices
+ *  are attached to the bus.
+ */
+int ds18b20_scan_devices(int pin, ds18b20_addr_t *addr_list, int addr_count);
+
+/** Tell one or more sensors to perform a temperature measurement and
+ *  conversion (CONVERT_T) operation.  This operation can take up to 750ms to
+ *  complete.
+ *
+ *  If `wait=true`, this routine will automatically drive the pin high for the
+ *  necessary 750ms after issuing the command to ensure parasitically-powered
+ *  devices have enough power to perform the conversion operation (for
+ *  non-parasitically-powered devices, this is not necessary but does not
+ *  hurt).  If `wait=false`, this routine will drive the pin high, but will
+ *  then return immediately.  It is up to the caller to wait the requisite time
+ *  and then depower the bus using onewire_depower() or by issuing another
+ *  command once conversion is done.
+ *
+ *  @param pin   The GPIO pin connected to the DS18B20 device
+ *  @param addr  The 64-bit address of the device on the bus.  This can be set
+ *               to ::DS18B20_ANY to send the command to all devices on the bus
+ *               at the same time.
+ *  @param wait  Whether to wait for the necessary 750ms for the DS18B20 to
+ *               finish performing the conversion before returning to the
+ *               caller (You will normally want to do this).
+ *
+ *  @returns `true` if the command was successfully issued, or `false` on error.
+ */
+bool ds18b20_measure(int pin, ds18b20_addr_t addr, bool wait);
+
+/** Read the value from the last CONVERT_T operation.
+ *
+ *  This should be called after ds18b20_measure() to fetch the result of the
+ *  temperature measurement.
+ *
+ *  @param pin     The GPIO pin connected to the DS18B20 device
+ *  @param addr    The 64-bit address of the device to read.  This can be set
+ *                 to ::DS18B20_ANY to read any device on the bus (but note
+ *                 that this will only work if there is exactly one device
+ *                 connected, or they will corrupt each others' transmissions)
+ *
+ *  @returns The temperature in degrees Celsius, or NaN if there was an error.
+ */
+float ds18b20_read_temperature(int pin, ds18b20_addr_t addr);
+
+/** Read the value from the last CONVERT_T operation for multiple devices.
+ *
+ *  This should be called after ds18b20_measure() to fetch the result of the
+ *  temperature measurement.
+ *
+ *  @param pin         The GPIO pin connected to the DS18B20 bus
+ *  @param addr_list   A list of addresses for devices to read.
+ *  @param addr_count  The number of entries in `addr_list`.
+ *  @param result_list An array of floats to hold the returned temperature
+ *                     values.  It should have at least `addr_count` entries.
+ *
+ *  @returns `true` if all temperatures were fetched successfully, or `false`
+ *  if one or more had errors (the temperature for erroring devices will be
+ *  returned as NaN).
+ */
+bool ds18b20_read_temp_multi(int pin, ds18b20_addr_t *addr_list, int addr_count, float *result_list);
+
+/** Perform a ds18b20_measure() followed by ds18b20_read_temperature()
+ *
+ *  @param pin     The GPIO pin connected to the DS18B20 device
+ *  @param addr    The 64-bit address of the device to read.  This can be set
+ *                 to ::DS18B20_ANY to read any device on the bus (but note
+ *                 that this will only work if there is exactly one device
+ *                 connected, or they will corrupt each others' transmissions)
+ *
+ *  @returns The temperature in degrees Celsius, or NaN if there was an error.
+ */
+float ds18b20_measure_and_read(int pin, ds18b20_addr_t addr);
+
+/** Perform a ds18b20_measure() followed by ds18b20_read_temp_multi()
+ *
+ *  @param pin         The GPIO pin connected to the DS18B20 bus
+ *  @param addr_list   A list of addresses for devices to read.
+ *  @param addr_count  The number of entries in `addr_list`.
+ *  @param result_list An array of floats to hold the returned temperature
+ *                     values.  It should have at least `addr_count` entries.
+ *
+ *  @returns `true` if all temperatures were fetched successfully, or `false`
+ *  if one or more had errors (the temperature for erroring devices will be
+ *  returned as NaN).
+ */
+bool ds18b20_measure_and_read_multi(int pin, ds18b20_addr_t *addr_list, int addr_count, float *result_list);
+
+/** Read the scratchpad data for a particular DS18B20 device.
+ *
+ *  This is not generally necessary to do directly.  It is done automatically
+ *  as part of ds18b20_read_temperature().
+ *
+ *  @param pin     The GPIO pin connected to the DS18B20 device
+ *  @param addr    The 64-bit address of the device to read.  This can be set
+ *                 to ::DS18B20_ANY to read any device on the bus (but note
+ *                 that this will only work if there is exactly one device
+ *                 connected, or they will corrupt each others' transmissions)
+ *  @param buffer  An 8-byte buffer to hold the read data.
+ *
+ *  @returns `true` if the data was read successfully, or `false` on error.
+ */
+bool ds18b20_read_scratchpad(int pin, ds18b20_addr_t addr, uint8_t *buffer);
+
+// The following are obsolete/deprecated APIs
+
+typedef struct {
+    uint8_t id;
+    float value;
+} ds_sensor_t;
+
+// Scan all ds18b20 sensors on bus and return its amount.
+// Result are saved in array of ds_sensor_t structure.
+uint8_t ds18b20_read_all(uint8_t pin, ds_sensor_t *result);
+
+// This method is just to demonstrate how to read
+// temperature from single dallas chip.
+float ds18b20_read_single(uint8_t pin);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif  /* DRIVER_DS18B20_H_ */

components/ds18b20/onewire.c

@@ -0,0 +1,453 @@
+#include "onewire.h"
+#include "string.h"
+#include "task.h"
+#include <driver/gpio.h>
+
+#define ONEWIRE_SELECT_ROM 0x55
+#define ONEWIRE_SKIP_ROM   0xcc
+#define ONEWIRE_SEARCH     0xf0
+
+// Waits up to `max_wait` microseconds for the specified pin to go high.
+// Returns true if successful, false if the bus never comes high (likely
+// shorted).
+static inline bool _onewire_wait_for_bus(int pin, int max_wait) {
+    bool state;
+    for (int i = 0; i < ((max_wait + 4) / 5); i++) {
+        if (gpio_get_level(pin)) break;
+        os_delay_us(5);
+    }
+    state = gpio_get_level(pin);
+    // Wait an extra 1us to make sure the devices have an adequate recovery
+    // time before we drive things low again.
+    os_delay_us(1);
+    return state;
+}
+
+// Perform the onewire reset function.  We will wait up to 250uS for
+// the bus to come high, if it doesn't then it is broken or shorted
+// and we return false;
+//
+// Returns true if a device asserted a presence pulse, false otherwise.
+//
+bool onewire_reset(int pin) {
+    bool r;
+
+    gpio_set_direction(pin, GPIO_MODE_OUTPUT_OD);
+    gpio_set_level(pin, 1);
+    // wait until the wire is high... just in case
+    if (!_onewire_wait_for_bus(pin, 250)) return false;
+
+    gpio_set_level(pin, 0);
+    os_delay_us(480);
+
+    taskENTER_CRITICAL();
+    gpio_set_level(pin, 1); // allow it to float
+    os_delay_us(70);
+    r = !gpio_get_level(pin);
+    taskEXIT_CRITICAL();
+
+    // Wait for all devices to finish pulling the bus low before returning
+    if (!_onewire_wait_for_bus(pin, 410)) return false;
+
+    return r;
+}
+
+static bool _onewire_write_bit(int pin, bool v) {
+    if (!_onewire_wait_for_bus(pin, 10)) return false;
+    if (v) {
+        taskENTER_CRITICAL();
+        gpio_set_level(pin, 0);  // drive output low
+        os_delay_us(10);
+        gpio_set_level(pin, 1);  // allow output high
+        taskEXIT_CRITICAL();
+        os_delay_us(55);
+    } else {
+        taskENTER_CRITICAL();
+        gpio_set_level(pin, 0);  // drive output low
+        os_delay_us(65);
+        gpio_set_level(pin, 1); // allow output high
+        taskEXIT_CRITICAL();
+    }
+    os_delay_us(1);
+
+    return true;
+}
+
+static int _onewire_read_bit(int pin) {
+    int r;
+
+    if (!_onewire_wait_for_bus(pin, 10)) return -1;
+    taskENTER_CRITICAL();
+    gpio_set_level(pin, 0);
+    os_delay_us(2);
+    gpio_set_level(pin, 1);  // let pin float, pull up will raise
+    os_delay_us(11);
+    r = gpio_get_level(pin);  // Must sample within 15us of start
+    taskEXIT_CRITICAL();
+    os_delay_us(48);
+
+    return r;
+}
+
+// Write a byte. The writing code uses open-drain mode and expects the pullup
+// resistor to pull the line high when not driven low.  If you need strong
+// power after the write (e.g. DS18B20 in parasite power mode) then call
+// onewire_power() after this is complete to actively drive the line high.
+//
+bool onewire_write(int pin, uint8_t v) {
+    uint8_t bitMask;
+
+    for (bitMask = 0x01; bitMask; bitMask <<= 1) {
+        if (!_onewire_write_bit(pin, (bitMask & v))) {
+            return false;
+        }
+    }
+    return true;
+}
+
+bool onewire_write_bytes(int pin, const uint8_t *buf, size_t count) {
+    size_t i;
+
+    for (i = 0; i < count; i++) {
+        if (!onewire_write(pin, buf[i])) {
+            return false;
+        }
+    }
+    return true;
+}
+
+// Read a byte
+//
+int onewire_read(int pin) {
+    uint8_t bitMask;
+    int r = 0;
+    int bit;
+
+    for (bitMask = 0x01; bitMask; bitMask <<= 1) {
+        bit = _onewire_read_bit(pin);
+        if (bit < 0) {
+            return -1;
+        } else if (bit) {
+            r |= bitMask;
+        }
+    }
+    return r;
+}
+
+bool onewire_read_bytes(int pin, uint8_t *buf, size_t count) {
+    size_t i;
+    int b;
+
+    for (i = 0; i < count; i++) {
+        b = onewire_read(pin);
+        if (b < 0) return false;
+        buf[i] = b;
+    }
+    return true;
+}
+
+bool onewire_select(int pin, onewire_addr_t addr) {
+    uint8_t i;
+
+    if (!onewire_write(pin, ONEWIRE_SELECT_ROM)) {
+        return false;
+    }
+
+    for (i = 0; i < 8; i++) {
+        if (!onewire_write(pin, addr & 0xff)) {
+            return false;
+        }
+        addr >>= 8;
+    }
+
+    return true;
+}
+
+bool onewire_skip_rom(int pin) {
+    return onewire_write(pin, ONEWIRE_SKIP_ROM);
+}
+
+bool onewire_power(int pin) {
+    // Make sure the bus is not being held low before driving it high, or we
+    // may end up shorting ourselves out.
+    if (!_onewire_wait_for_bus(pin, 10)) return false;
+
+    gpio_set_direction(pin, GPIO_MODE_OUTPUT);
+    gpio_set_level(pin, 1);
+
+    return true;
+}
+
+void onewire_depower(int pin) {
+    gpio_set_direction(pin, GPIO_MODE_OUTPUT_OD);
+}
+
+void onewire_search_start(onewire_search_t *search) {
+    // reset the search state
+    memset(search, 0, sizeof(*search));
+}
+
+void onewire_search_prefix(onewire_search_t *search, uint8_t family_code) {
+    uint8_t i;
+
+    search->rom_no[0] = family_code;
+    for (i = 1; i < 8; i++) {
+        search->rom_no[i] = 0;
+    }
+    search->last_discrepancy = 64;
+    search->last_device_found = false;
+}
+
+// Perform a search. If the next device has been successfully enumerated, its
+// ROM address will be returned.  If there are no devices, no further
+// devices, or something horrible happens in the middle of the
+// enumeration then ONEWIRE_NONE is returned.  Use OneWire::reset_search() to
+// start over.
+//
+// --- Replaced by the one from the Dallas Semiconductor web site ---
+//--------------------------------------------------------------------------
+// Perform the 1-Wire Search Algorithm on the 1-Wire bus using the existing
+// search state.
+// Return 1 : device found, ROM number in ROM_NO buffer
+//        0 : device not found, end of search
+//
+onewire_addr_t onewire_search_next(onewire_search_t *search, int pin) {
+    //TODO: add more checking for read/write errors
+    uint8_t id_bit_number;
+    uint8_t last_zero, search_result;
+    int rom_byte_number;
+    int8_t id_bit, cmp_id_bit;
+    onewire_addr_t addr;
+    unsigned char rom_byte_mask;
+    bool search_direction;
+
+    // initialize for search
+    id_bit_number = 1;
+    last_zero = 0;
+    rom_byte_number = 0;
+    rom_byte_mask = 1;
+    search_result = 0;
+
+    // if the last call was not the last one
+    if (!search->last_device_found) {
+        // 1-Wire reset
+        if (!onewire_reset(pin)) {
+            // reset the search
+            search->last_discrepancy = 0;
+            search->last_device_found = false;
+            return ONEWIRE_NONE;
+        }
+
+        // issue the search command
+        onewire_write(pin, ONEWIRE_SEARCH);
+
+        // loop to do the search
+        do {
+            // read a bit and its complement
+            id_bit = _onewire_read_bit(pin);
+            cmp_id_bit = _onewire_read_bit(pin);
+
+            // check for no devices on 1-wire
+            if ((id_bit < 0) || (cmp_id_bit < 0)) {
+                // Read error
+                break;
+            } else if ((id_bit == 1) && (cmp_id_bit == 1)) {
+                break;
+            } else {
+                // all devices coupled have 0 or 1
+                if (id_bit != cmp_id_bit) {
+                    search_direction = id_bit;  // bit write value for search
+                } else {
+                    // if this discrepancy if before the Last Discrepancy
+                    // on a previous next then pick the same as last time
+                    if (id_bit_number < search->last_discrepancy) {
+                        search_direction = ((search->rom_no[rom_byte_number] & rom_byte_mask) > 0);
+                    } else {
+                        // if equal to last pick 1, if not then pick 0
+                        search_direction = (id_bit_number == search->last_discrepancy);
+                    }
+
+                    // if 0 was picked then record its position in LastZero
+                    if (!search_direction) {
+                        last_zero = id_bit_number;
+                    }
+                }
+
+                // set or clear the bit in the ROM byte rom_byte_number
+                // with mask rom_byte_mask
+                if (search_direction) {
+                    search->rom_no[rom_byte_number] |= rom_byte_mask;
+                } else {
+                    search->rom_no[rom_byte_number] &= ~rom_byte_mask;
+                }
+
+                // serial number search direction write bit
+                _onewire_write_bit(pin, search_direction);
+
+                // increment the byte counter id_bit_number
+                // and shift the mask rom_byte_mask
+                id_bit_number++;
+                rom_byte_mask <<= 1;
+
+                // if the mask is 0 then go to new SerialNum byte rom_byte_number and reset mask
+                if (rom_byte_mask == 0) {
+                    rom_byte_number++;
+                    rom_byte_mask = 1;
+                }
+            }
+        } while (rom_byte_number < 8);  // loop until through all ROM bytes 0-7
+
+        // if the search was successful then
+        if (!(id_bit_number < 65)) {
+            // search successful so set last_discrepancy,last_device_found,search_result
+            search->last_discrepancy = last_zero;
+
+            // check for last device
+            if (search->last_discrepancy == 0) {
+                search->last_device_found = true;
+            }
+
+            search_result = 1;
+        }
+    }
+
+    // if no device found then reset counters so next 'search' will be like a first
+    if (!search_result || !search->rom_no[0]) {
+        search->last_discrepancy = 0;
+        search->last_device_found = false;
+        return ONEWIRE_NONE;
+    } else {
+        addr = 0;
+        for (rom_byte_number = 7; rom_byte_number >= 0; rom_byte_number--) {
+            addr = (addr << 8) | search->rom_no[rom_byte_number];
+        }
+        //printf("Ok I found something at %08x%08x...\n", (uint32_t)(addr >> 32), (uint32_t)addr);
+    }
+    return addr;
+}
+
+// The 1-Wire CRC scheme is described in Maxim Application Note 27:
+// "Understanding and Using Cyclic Redundancy Checks with Maxim iButton Products"
+//
+
+#if ONEWIRE_CRC8_TABLE
+// This table comes from Dallas sample code where it is freely reusable,
+// though Copyright (C) 2000 Dallas Semiconductor Corporation
+static const uint8_t dscrc_table[] = {
+      0, 94,188,226, 97, 63,221,131,194,156,126, 32,163,253, 31, 65,
+    157,195, 33,127,252,162, 64, 30, 95,  1,227,189, 62, 96,130,220,
+     35,125,159,193, 66, 28,254,160,225,191, 93,  3,128,222, 60, 98,
+    190,224,  2, 92,223,129, 99, 61,124, 34,192,158, 29, 67,161,255,
+     70, 24,250,164, 39,121,155,197,132,218, 56,102,229,187, 89,  7,
+    219,133,103, 57,186,228,  6, 88, 25, 71,165,251,120, 38,196,154,
+    101, 59,217,135,  4, 90,184,230,167,249, 27, 69,198,152,122, 36,
+    248,166, 68, 26,153,199, 37,123, 58,100,134,216, 91,  5,231,185,
+    140,210, 48,110,237,179, 81, 15, 78, 16,242,172, 47,113,147,205,
+     17, 79,173,243,112, 46,204,146,211,141,111, 49,178,236, 14, 80,
+    175,241, 19, 77,206,144,114, 44,109, 51,209,143, 12, 82,176,238,
+     50,108,142,208, 83, 13,239,177,240,174, 76, 18,145,207, 45,115,
+    202,148,118, 40,171,245, 23, 73,  8, 86,180,234,105, 55,213,139,
+     87,  9,235,181, 54,104,138,212,149,203, 41,119,244,170, 72, 22,
+    233,183, 85, 11,136,214, 52,106, 43,117,151,201, 74, 20,246,168,
+    116, 42,200,150, 21, 75,169,247,182,232, 10, 84,215,137,107, 53};
+
+#ifndef pgm_read_byte
+#define pgm_read_byte(addr) (*(const uint8_t *)(addr))
+#endif
+
+//
+// Compute a Dallas Semiconductor 8 bit CRC. These show up in the ROM
+// and the registers.  (note: this might better be done without to
+// table, it would probably be smaller and certainly fast enough
+// compared to all those delayMicrosecond() calls.  But I got
+// confused, so I use this table from the examples.)
+//
+uint8_t onewire_crc8(const uint8_t *data, uint8_t len) {
+    uint8_t crc = 0;
+
+    while (len--) {
+        crc = pgm_read_byte(dscrc_table + (crc ^ *data++));
+    }
+    return crc;
+}
+#else
+//
+// Compute a Dallas Semiconductor 8 bit CRC directly.
+// this is much slower, but much smaller, than the lookup table.
+//
+uint8_t onewire_crc8(const uint8_t *data, uint8_t len) {
+    uint8_t crc = 0;
+
+    while (len--) {
+        uint8_t inbyte = *data++;
+        for (int i = 8; i; i--) {
+            uint8_t mix = (crc ^ inbyte) & 0x01;
+            crc >>= 1;
+            if (mix) crc ^= 0x8C;
+            inbyte >>= 1;
+        }
+    }
+    return crc;
+}
+#endif
+
+// Compute the 1-Wire CRC16 and compare it against the received CRC.
+// Example usage (reading a DS2408):
+//    // Put everything in a buffer so we can compute the CRC easily.
+//    uint8_t buf[13];
+//    buf[0] = 0xF0;    // Read PIO Registers
+//    buf[1] = 0x88;    // LSB address
+//    buf[2] = 0x00;    // MSB address
+//    WriteBytes(net, buf, 3);    // Write 3 cmd bytes
+//    ReadBytes(net, buf+3, 10);  // Read 6 data bytes, 2 0xFF, 2 CRC16
+//    if (!CheckCRC16(buf, 11, &buf[11])) {
+//        // Handle error.
+//    }
+//
+// @param input - Array of bytes to checksum.
+// @param len - How many bytes to use.
+// @param inverted_crc - The two CRC16 bytes in the received data.
+//                       This should just point into the received data,
+//                       *not* at a 16-bit integer.
+// @param crc - The crc starting value (optional)
+// @return 1, iff the CRC matches.
+bool onewire_check_crc16(const uint8_t* input, size_t len, const uint8_t* inverted_crc, uint16_t crc_iv) {
+    uint16_t crc = ~onewire_crc16(input, len, crc_iv);
+    return (crc & 0xFF) == inverted_crc[0] && (crc >> 8) == inverted_crc[1];
+}
+
+// Compute a Dallas Semiconductor 16 bit CRC.  This is required to check
+// the integrity of data received from many 1-Wire devices.  Note that the
+// CRC computed here is *not* what you'll get from the 1-Wire network,
+// for two reasons:
+//   1) The CRC is transmitted bitwise inverted.
+//   2) Depending on the endian-ness of your processor, the binary
+//      representation of the two-byte return value may have a different
+//      byte order than the two bytes you get from 1-Wire.
+// @param input - Array of bytes to checksum.
+// @param len - How many bytes to use.
+// @param crc - The crc starting value (optional)
+// @return The CRC16, as defined by Dallas Semiconductor.
+uint16_t onewire_crc16(const uint8_t* input, size_t len, uint16_t crc_iv) {
+    uint16_t crc = crc_iv;
+    static const uint8_t oddparity[16] =
+        { 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0 };
+
+    uint16_t i;
+    for (i = 0; i < len; i++) {
+      // Even though we're just copying a byte from the input,
+      // we'll be doing 16-bit computation with it.
+      uint16_t cdata = input[i];
+      cdata = (cdata ^ crc) & 0xff;
+      crc >>= 8;
+
+      if (oddparity[cdata & 0x0F] ^ oddparity[cdata >> 4])
+          crc ^= 0xC001;
+
+      cdata <<= 6;
+      crc ^= cdata;
+      cdata <<= 1;
+      crc ^= cdata;
+    }
+    return crc;
+}

components/ds18b20/onewire.h

@@ -0,0 +1,244 @@
+#ifndef __ONEWIRE_H__
+#define __ONEWIRE_H__
+
+#include "FreeRTOS.h"
+#include <stdint.h>
+#include <stdbool.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** @file onewire.h
+ *
+ *  Routines to access devices using the Dallas Semiconductor 1-Wire(tm)
+ *  protocol.
+ */
+
+/** Select the table-lookup method of computing the 8-bit CRC
+ *  by setting this to 1 during compilation.  The lookup table enlarges code
+ *  size by about 250 bytes.  By default, a slower but very compact algorithm
+ *  is used.
+ */
+#ifndef ONEWIRE_CRC8_TABLE
+#define ONEWIRE_CRC8_TABLE 0
+#endif
+
+/** Type used to hold all 1-Wire device ROM addresses (64-bit) */
+typedef uint64_t onewire_addr_t;
+
+/** Structure to contain the current state for onewire_search_next(), etc */
+typedef struct {
+    uint8_t rom_no[8];
+    uint8_t last_discrepancy;
+    bool last_device_found;
+} onewire_search_t;
+
+/** ::ONEWIRE_NONE is an invalid ROM address that will never occur in a device
+ *  (CRC mismatch), and so can be useful as an indicator for "no-such-device",
+ *   etc.
+ */
+#define ONEWIRE_NONE ((onewire_addr_t)(0xffffffffffffffffLL))
+
+/** Perform a 1-Wire reset cycle.
+ *
+ *  @param pin  The GPIO pin connected to the 1-Wire bus.
+ *
+ *  @returns `true` if at least one device responds with a presence pulse,
+ *           `false` if no devices were detected (or the bus is shorted, etc)
+ */
+bool onewire_reset(int pin);
+
+/** Issue a 1-Wire rom select command to select a particular device.
+ *
+ *  It is necessary to call onewire_reset() before calling this function.
+ *
+ *  @param pin   The GPIO pin connected to the 1-Wire bus.
+ *  @param addr  The ROM address of the device to select
+ *
+ *  @returns `true` if the "ROM select" command could be succesfully issued,
+ *           `false` if there was an error.
+ */
+bool onewire_select(int pin, const onewire_addr_t addr);
+
+/** Issue a 1-Wire "skip ROM" command to select *all* devices on the bus.
+ *
+ *  It is necessary to call onewire_reset() before calling this function.
+ *
+ *  @param pin   The GPIO pin connected to the 1-Wire bus.
+ *
+ *  @returns `true` if the "skip ROM" command could be succesfully issued,
+ *           `false` if there was an error.
+ */
+bool onewire_skip_rom(int pin);
+
+/** Write a byte on the onewire bus.
+ *
+ *  The writing code uses open-drain mode and expects the pullup resistor to
+ *  pull the line high when not driven low.  If you need strong power after the
+ *  write (e.g. DS18B20 in parasite power mode) then call onewire_power() after
+ *  this is complete to actively drive the line high.
+ *
+ *  @param pin   The GPIO pin connected to the 1-Wire bus.
+ *  @param v     The byte value to write
+ *
+ *  @returns `true` if successful, `false` on error.
+ */
+bool onewire_write(int pin, uint8_t v);
+
+/** Write multiple bytes on the 1-Wire bus.
+ *
+ *  See onewire_write() for more info.
+ *
+ *  @param pin    The GPIO pin connected to the 1-Wire bus.
+ *  @param buf    A pointer to the buffer of bytes to be written
+ *  @param count  Number of bytes to write
+ *
+ *  @returns `true` if all bytes written successfully, `false` on error.
+ */
+bool onewire_write_bytes(int pin, const uint8_t *buf, size_t count);
+
+/** Read a byte from a 1-Wire device.
+ *
+ *  @param pin    The GPIO pin connected to the 1-Wire bus.
+ *
+ *  @returns the read byte on success, negative value on error.
+ */
+int onewire_read(int pin);
+
+/** Read multiple bytes from a 1-Wire device.
+ *
+ *  @param pin    The GPIO pin connected to the 1-Wire bus.
+ *  @param buf    A pointer to the buffer to contain the read bytes
+ *  @param count  Number of bytes to read
+ *
+ *  @returns `true` on success, `false` on error.
+ */
+bool onewire_read_bytes(int pin, uint8_t *buf, size_t count);
+
+/** Actively drive the bus high to provide extra power for certain operations
+ *  of parasitically-powered devices.
+ *
+ *  For parasitically-powered devices which need more power than can be
+ *  provided via the normal pull-up resistor, it may be necessary for some
+ *  operations to drive the bus actively high.  This function can be used to
+ *  perform that operation.
+ *
+ *  The bus can be depowered once it is no longer needed by calling
+ *  onewire_depower(), or it will be depowered automatically the next time
+ *  onewire_reset() is called to start another command.
+ *
+ *  Note: Make sure the device(s) you are powering will not pull more current
+ *  than the ESP8266 is able to supply via its GPIO pins (this is especially
+ *  important when multiple devices are on the same bus and they are all
+ *  performing a power-intensive operation at the same time (i.e. multiple
+ *  DS18B20 sensors, which have all been given a "convert T" operation by using
+ *  onewire_skip_rom())).
+ *
+ *  Note: This routine will check to make sure that the bus is already high
+ *  before driving it, to make sure it doesn't attempt to drive it high while
+ *  something else is pulling it low (which could cause a reset or damage the
+ *  ESP8266).
+ *
+ *  @param pin    The GPIO pin connected to the 1-Wire bus.
+ *
+ *  @returns `true` on success, `false` on error.
+ */
+bool onewire_power(int pin);
+
+/** Stop forcing power onto the bus.
+ *
+ *  You only need to do this if you previously called onewire_power() to drive
+ *  the bus high and now want to allow it to float instead.  Note that
+ *  onewire_reset() will also automatically depower the bus first, so you do
+ *  not need to call this first if you just want to start a new operation.
+ *
+ *  @param pin    The GPIO pin connected to the 1-Wire bus.
+ */
+void onewire_depower(int pin);
+
+/** Clear the search state so that it will start from the beginning on the next
+ *  call to onewire_search_next().
+ *
+ *  @param search  The onewire_search_t structure to reset.
+ */
+void onewire_search_start(onewire_search_t *search);
+
+/** Setup the search to search for devices with the specified "family code".
+ *
+ *  @param search       The onewire_search_t structure to update.
+ *  @param family_code  The "family code" to search for.
+ */
+void onewire_search_prefix(onewire_search_t *search, uint8_t family_code);
+
+/** Search for the next device on the bus.
+ *
+ *  The order of returned device addresses is deterministic. You will always
+ *  get the same devices in the same order.
+ *
+ *  @returns the address of the next device on the bus, or ::ONEWIRE_NONE if
+ *  there is no next address.  ::ONEWIRE_NONE might also mean that the bus is
+ *  shorted, there are no devices, or you have already retrieved all of them.
+ *
+ *  It might be a good idea to check the CRC to make sure you didn't get
+ *  garbage.
+ */
+onewire_addr_t onewire_search_next(onewire_search_t *search, int pin);
+
+/** Compute a Dallas Semiconductor 8 bit CRC.
+ *
+ *  These are used in the ROM address and scratchpad registers to verify the
+ *  transmitted data is correct.
+ */
+uint8_t onewire_crc8(const uint8_t *data, uint8_t len);
+
+/** Compute the 1-Wire CRC16 and compare it against the received CRC.
+ *
+ *  Example usage (reading a DS2408):
+ *  @code
+ *      // Put everything in a buffer so we can compute the CRC easily.
+ *      uint8_t buf[13];
+ *      buf[0] = 0xF0;    // Read PIO Registers
+ *      buf[1] = 0x88;    // LSB address
+ *      buf[2] = 0x00;    // MSB address
+ *      onewire_write_bytes(pin, buf, 3);    // Write 3 cmd bytes
+ *      onewire_read_bytes(pin, buf+3, 10);  // Read 6 data bytes, 2 0xFF, 2 CRC16
+ *      if (!onewire_check_crc16(buf, 11, &buf[11])) {
+ *          // TODO: Handle error.
+ *      }
+ *  @endcode
+ *
+ *  @param input         Array of bytes to checksum.
+ *  @param len           Number of bytes in `input`
+ *  @param inverted_crc  The two CRC16 bytes in the received data.
+ *                       This should just point into the received data,
+ *                       *not* at a 16-bit integer.
+ *  @param crc_iv        The crc starting value (optional)
+ *
+ *  @returns `true` if the CRC matches, `false` otherwise.
+ */
+bool onewire_check_crc16(const uint8_t* input, size_t len, const uint8_t* inverted_crc, uint16_t crc_iv);
+
+/** Compute a Dallas Semiconductor 16 bit CRC.
+ *
+ *  This is required to check the integrity of data received from many 1-Wire
+ *  devices.  Note that the CRC computed here is *not* what you'll get from the
+ *  1-Wire network, for two reasons:
+ *    1. The CRC is transmitted bitwise inverted.
+ *    2. Depending on the endian-ness of your processor, the binary
+ *       representation of the two-byte return value may have a different
+ *       byte order than the two bytes you get from 1-Wire.
+ *
+ *  @param input   Array of bytes to checksum.
+ *  @param len     How many bytes are in `input`.
+ *  @param crc_iv  The crc starting value (optional)
+ *
+ *  @returns the CRC16, as defined by Dallas Semiconductor.
+ */
+uint16_t onewire_crc16(const uint8_t* input, size_t len, uint16_t crc_iv);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  /* __ONEWIRE_H__ */

main/CMakeLists.txt

@@ -0,0 +1,6 @@
+set(COMPONENT_SRCS "cmd_wifi.c"
+                   "meteo_task.c"
+                   "meteo_main.c")
+set(COMPONENT_ADD_INCLUDEDIRS ".")
+
+register_component()

main/Kconfig.projbuild

@@ -0,0 +1,11 @@
+menu "App Configuration"
+
+config STORE_HISTORY
+    bool "Store command history in flash"
+    default y
+    help
+        Linenoise line editing library provides functions to save and load
+        command history. If this option is enabled, initalizes a FAT filesystem
+        and uses it to store command history.
+
+endmenu

main/cmd_decl.h

@@ -0,0 +1,20 @@
+/* Console example — declarations of command registration functions.
+
+   This example code is in the Public Domain (or CC0 licensed, at your option.)
+
+   Unless required by applicable law or agreed to in writing, this
+   software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+   CONDITIONS OF ANY KIND, either express or implied.
+*/
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "cmd_system.h"
+#include "cmd_wifi.h"
+
+#ifdef __cplusplus
+}
+#endif

main/cmd_wifi.c

@@ -0,0 +1,285 @@
+/* Console example — WiFi commands
+
+   This example code is in the Public Domain (or CC0 licensed, at your option.)
+
+   Unless required by applicable law or agreed to in writing, this
+   software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+   CONDITIONS OF ANY KIND, either express or implied.
+*/
+
+#include <stdio.h>
+#include <string.h>
+#include "esp_log.h"
+#include "esp_console.h"
+#include "argtable3/argtable3.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/event_groups.h"
+#include "esp_wifi.h"
+#include "tcpip_adapter.h"
+#include "esp_event_loop.h"
+#include "cmd_wifi.h"
+
+#include "nvs.h"
+
+static EventGroupHandle_t wifi_event_group;
+const int CONNECTED_BIT = BIT0;
+
+static esp_err_t event_handler(void *ctx, system_event_t *event)
+{
+    /* For accessing reason codes in case of disconnection */
+    system_event_info_t *info = &event->event_info;
+
+    switch(event->event_id) {
+    case SYSTEM_EVENT_STA_GOT_IP:
+        xEventGroupSetBits(wifi_event_group, CONNECTED_BIT);
+        break;
+    case SYSTEM_EVENT_STA_DISCONNECTED:
+        ESP_LOGI(__func__, "Disconnect reason : %d", info->disconnected.reason);
+        if (info->disconnected.reason == WIFI_REASON_BASIC_RATE_NOT_SUPPORT) {
+            /*Switch to 802.11 bgn mode */
+            esp_wifi_set_protocol(ESP_IF_WIFI_STA, WIFI_PROTOCOL_11B | WIFI_PROTOCOL_11G | WIFI_PROTOCOL_11N);
+        }
+        esp_wifi_connect();
+        xEventGroupClearBits(wifi_event_group, CONNECTED_BIT);
+        break;
+    default:
+        break;
+    }
+    return ESP_OK;
+}
+
+void initialise_wifi(void)
+{
+    esp_err_t rv;
+
+    esp_log_level_set("wifi", ESP_LOG_WARN);
+    static bool initialized = false;
+    if (initialized) {
+        return;
+    }
+    tcpip_adapter_init();
+    wifi_event_group = xEventGroupCreate();
+    ESP_ERROR_CHECK( esp_event_loop_init(event_handler, NULL) );
+    wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
+    ESP_ERROR_CHECK( esp_wifi_init(&cfg) );
+    ESP_ERROR_CHECK( esp_wifi_set_storage(WIFI_STORAGE_FLASH) );
+    ESP_ERROR_CHECK( esp_wifi_set_mode(WIFI_MODE_STA) );
+    ESP_ERROR_CHECK( esp_wifi_start() );
+
+    nvs_handle_t hnvs;
+    ESP_ERROR_CHECK( nvs_open("wifi", NVS_READONLY, &hnvs) );
+
+    uint8_t use_dhcpc;
+    rv = nvs_get_u8(hnvs, "use_dhcpc", &use_dhcpc);
+    if (rv != ESP_OK) {
+        use_dhcpc = 1;
+        ESP_LOGW(__func__, "Fail to read 'use_dhcpc'");
+    }
+
+    if (!use_dhcpc) {
+        char ip[16], gw[16], mask[16];
+        size_t iplen = 16;
+        size_t gwlen = 16;
+        size_t masklen = 16;
+
+        rv = nvs_get_str(hnvs, "static_ip", ip, &iplen);
+        if (rv != ESP_OK) {
+            use_dhcpc = 1;
+            ESP_LOGW(__func__, "Fail to load 'static_ip'");
+        }
+
+        rv = nvs_get_str(hnvs, "static_gw", gw, &gwlen);
+        if (rv != ESP_OK) {
+            use_dhcpc = 1;
+            ESP_LOGW(__func__, "Fail to load 'static_gw'");
+        }
+
+        rv = nvs_get_str(hnvs, "static_mask", mask, &masklen);
+        if (rv != ESP_OK) {
+            use_dhcpc = 1;
+            ESP_LOGW(__func__, "Fail to load 'static_mask'");
+        }
+
+        printf("Static IP config: IP: %s, GW: %s, Mask: %s\n", ip, gw, mask);
+
+        tcpip_adapter_ip_info_t ip_info;
+        if (!use_dhcpc) {
+            ip_info.ip.addr = ipaddr_addr(ip);
+            ip_info.gw.addr = ipaddr_addr(gw);
+            ip_info.netmask.addr = ipaddr_addr(mask);
+
+            if (ip_info.ip.addr == IPADDR_NONE || ip_info.gw.addr == IPADDR_NONE || ip_info.netmask.addr == IPADDR_NONE) {
+                use_dhcpc = 1;
+                ESP_LOGW(__func__, "Fail to parse static IP config");
+            }
+        }
+
+        if (!use_dhcpc) {
+            tcpip_adapter_dhcpc_stop(TCPIP_ADAPTER_IF_STA);
+            tcpip_adapter_set_ip_info(TCPIP_ADAPTER_IF_STA, &ip_info);
+        }
+    }
+    nvs_commit(hnvs);
+    nvs_close(hnvs);
+
+    ESP_ERROR_CHECK( esp_wifi_connect() );
+
+    initialized = true;
+}
+
+static bool wifi_join(const char* ssid, const char* pass, int timeout_ms)
+{
+    initialise_wifi();
+    wifi_config_t wifi_config = { 0 };
+    strncpy((char*) wifi_config.sta.ssid, ssid, sizeof(wifi_config.sta.ssid));
+    if (pass) {
+        strncpy((char*) wifi_config.sta.password, pass, sizeof(wifi_config.sta.password));
+    }
+
+    ESP_ERROR_CHECK( esp_wifi_set_mode(WIFI_MODE_STA) );
+    ESP_ERROR_CHECK( esp_wifi_set_config(ESP_IF_WIFI_STA, &wifi_config) );
+    ESP_ERROR_CHECK( esp_wifi_connect() );
+
+    int bits = xEventGroupWaitBits(wifi_event_group, CONNECTED_BIT,
+            1, 1, timeout_ms / portTICK_PERIOD_MS);
+    return (bits & CONNECTED_BIT) != 0;
+}
+
+/** Arguments used by 'join' function */
+static struct {
+    struct arg_int *timeout;
+    struct arg_str *ssid;
+    struct arg_str *password;
+    struct arg_end *end;
+} join_args;
+
+static int connect(int argc, char** argv)
+{
+    int nerrors = arg_parse(argc, argv, (void**) &join_args);
+    if (nerrors != 0) {
+        arg_print_errors(stderr, join_args.end, argv[0]);
+        return 1;
+    }
+    ESP_LOGI(__func__, "Connecting to '%s'",
+            join_args.ssid->sval[0]);
+
+    bool connected = wifi_join(join_args.ssid->sval[0],
+                           join_args.password->sval[0],
+                           join_args.timeout->ival[0]);
+    if (!connected) {
+        ESP_LOGW(__func__, "Connection timed out");
+        return 1;
+    }
+    ESP_LOGI(__func__, "Connected");
+    return 0;
+}
+
+void console_register_wifi()
+{
+    join_args.timeout = arg_int0(NULL, "timeout", "<t>", "Connection timeout, ms");
+    join_args.timeout->ival[0] = 5000; // set default value
+    join_args.ssid = arg_str1(NULL, NULL, "<ssid>", "SSID of AP");
+    join_args.password = arg_str0(NULL, NULL, "<pass>", "PSK of AP");
+    join_args.end = arg_end(2);
+
+    const esp_console_cmd_t join_cmd = {
+        .command = "join",
+        .help = "Join WiFi AP as a station",
+        .hint = NULL,
+        .func = &connect,
+        .argtable = &join_args
+    };
+
+    ESP_ERROR_CHECK( esp_console_cmd_register(&join_cmd) );
+}
+
+/** Arguments used by 'join' function */
+static struct {
+    struct arg_lit *dhcp_on;
+    struct arg_lit *dhcp_off;
+    struct arg_str *static_ip;
+    struct arg_str *static_gw;
+    struct arg_str *static_mask;
+    struct arg_end *end;
+} ip_args;
+
+static int ipcmd(int argc, char** argv)
+{
+    esp_err_t rv;
+
+    int nerrors = arg_parse(argc, argv, (void**) &ip_args);
+    if (nerrors != 0) {
+        arg_print_errors(stderr, ip_args.end, argv[0]);
+        return 1;
+    }
+
+    nvs_handle_t hnvs;
+    ESP_ERROR_CHECK( nvs_open("wifi", NVS_READWRITE, &hnvs) );
+
+    if (ip_args.dhcp_on->count) {
+        nvs_set_u8(hnvs, "use_dhcpc", 1);
+    } else if (ip_args.dhcp_off->count) {
+        nvs_set_u8(hnvs, "use_dhcpc", 0);
+    }
+
+    if (ip_args.static_ip->count) {
+        nvs_set_str(hnvs, "static_ip", ip_args.static_ip->sval[0]);
+    }
+
+    if (ip_args.static_gw->count) {
+        nvs_set_str(hnvs, "static_gw", ip_args.static_gw->sval[0]);
+    }
+
+    if (ip_args.static_mask->count) {
+        nvs_set_str(hnvs, "static_mask", ip_args.static_mask->sval[0]);
+    }
+
+    // read current config
+
+    uint8_t use_dhcpc;
+    rv = nvs_get_u8(hnvs, "use_dhcpc", &use_dhcpc);
+    if (rv != ESP_OK) {
+        use_dhcpc = 1;
+    }
+
+    char ip[16], gw[16], mask[16];
+    size_t iplen = 16;
+    size_t gwlen = 16;
+    size_t masklen = 16;
+    ip[0] = gw[0] = mask[0] = 0;
+
+    nvs_get_str(hnvs, "static_ip", ip, &iplen);
+    nvs_get_str(hnvs, "static_gw", gw, &gwlen);
+    nvs_get_str(hnvs, "static_mask", mask, &masklen);
+
+    printf("DHCP = %s\n", use_dhcpc ? "Yes (dynamic IP)" : "No (static IP)");
+    printf("Saved static IP = %s\n", ip);
+    printf("Saved static GW = %s\n", gw);
+    printf("Saved static MASK = %s\n", mask);
+
+    nvs_close(hnvs);
+
+    printf("Any changes are applied after restart.\n");
+
+    return 0;
+}
+
+void console_register_ip()
+{
+    ip_args.dhcp_on = arg_lit0("d", "dhcp", "Enable DHCP");
+    ip_args.dhcp_off = arg_lit0("s", "no-dhcp", "Disable DHCP (use static)");
+    ip_args.static_ip = arg_str0("a", NULL, "<IP>", "Set static IP");
+    ip_args.static_gw = arg_str0("g", NULL, "<IP>", "Set static GW");
+    ip_args.static_mask = arg_str0("m", NULL, "<IP>", "Set static MASK (e.g. 255.255.255.0)");
+    ip_args.end = arg_end(5);
+
+    const esp_console_cmd_t ip_cmd = {
+        .command = "ip",
+        .help = "Configure TCP/IP",
+        .hint = NULL,
+        .func = &ipcmd,
+        .argtable = &ip_args
+    };
+
+    ESP_ERROR_CHECK( esp_console_cmd_register(&ip_cmd) );
+}

main/cmd_wifi.h

@@ -0,0 +1,25 @@
+/* Console example — declarations of command registration functions.
+
+   This example code is in the Public Domain (or CC0 licensed, at your option.)
+
+   Unless required by applicable law or agreed to in writing, this
+   software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+   CONDITIONS OF ANY KIND, either express or implied.
+*/
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Register WiFi functions
+void console_register_wifi();
+
+void initialise_wifi(void);
+
+void console_register_ip();
+
+#ifdef __cplusplus
+}
+#endif
+

main/component.mk

@@ -0,0 +1,5 @@
+#
+# "main" pseudo-component makefile.
+#
+# (Uses default behaviour of compiling all source files in directory, adding 'include' to include path.)
+

main/meteo_main.c

@@ -0,0 +1,168 @@
+#include <stdio.h>
+#include <string.h>
+#include "esp_system.h"
+#include "esp_log.h"
+#include "esp_console.h"
+#include "esp_vfs_dev.h"
+#include "FreeRTOS.h"
+#include "task.h"
+#include "driver/uart.h"
+#include "linenoise/linenoise.h"
+#include "argtable3/argtable3.h"
+#include "cmd_decl.h"
+#include "nvs.h"
+#include "nvs_flash.h"
+#include "meteo_task.h"
+
+#define TAG "example"
+
+static void initialize_nvs()
+{
+    esp_err_t err = nvs_flash_init();
+    if (err == ESP_ERR_NVS_NO_FREE_PAGES) {
+        ESP_ERROR_CHECK( nvs_flash_erase() );
+        err = nvs_flash_init();
+    }
+    ESP_ERROR_CHECK(err);
+
+    // ensure the namespaces we need exist
+    nvs_handle_t hnvs;
+    ESP_ERROR_CHECK( nvs_open("wifi", NVS_READWRITE, &hnvs) );
+    nvs_close(hnvs);
+}
+
+static void initialize_console()
+{
+    /* Disable buffering on stdin */
+    setvbuf(stdin, NULL, _IONBF, 0);
+
+    /* Minicom, screen, idf_monitor send CR when ENTER key is pressed */
+    esp_vfs_dev_uart_set_rx_line_endings(ESP_LINE_ENDINGS_CR);
+    /* Move the caret to the beginning of the next line on '\n' */
+    esp_vfs_dev_uart_set_tx_line_endings(ESP_LINE_ENDINGS_CRLF);
+
+    /* Configure UART. Note that REF_TICK is used so that the baud rate remains
+     * correct while APB frequency is changing in light sleep mode.
+     */
+    uart_config_t uart_config = {
+            .baud_rate = CONFIG_ESP_CONSOLE_UART_BAUDRATE,
+            .data_bits = UART_DATA_8_BITS,
+            .parity = UART_PARITY_DISABLE,
+            .stop_bits = UART_STOP_BITS_1,
+    };
+    ESP_ERROR_CHECK( uart_param_config(CONFIG_ESP_CONSOLE_UART_NUM, &uart_config) );
+
+    /* Install UART driver for interrupt-driven reads and writes */
+    ESP_ERROR_CHECK( uart_driver_install(CONFIG_ESP_CONSOLE_UART_NUM,
+            256, 0, 0, NULL, 0) );
+
+    /* Tell VFS to use UART driver */
+    esp_vfs_dev_uart_use_driver(CONFIG_ESP_CONSOLE_UART_NUM);
+
+    /* Initialize the console */
+    esp_console_config_t console_config = {
+            .max_cmdline_args = 8,
+            .max_cmdline_length = 256,
+#if CONFIG_LOG_COLORS
+            .hint_color = atoi(LOG_COLOR_CYAN)
+#endif
+    };
+    ESP_ERROR_CHECK( esp_console_init(&console_config) );
+
+    /* Configure linenoise line completion library */
+    /* Enable multiline editing. If not set, long commands will scroll within
+     * single line.
+     */
+    linenoiseSetMultiLine(1);
+
+    /* Tell linenoise where to get command completions and hints */
+    linenoiseSetCompletionCallback(&esp_console_get_completion);
+    linenoiseSetHintsCallback((linenoiseHintsCallback*) &esp_console_get_hint);
+
+    /* Set command history size */
+    linenoiseHistorySetMaxLen(100);
+}
+
+void app_main()
+{
+    initialize_nvs();
+
+    initialize_console();
+    initialise_wifi();
+    console_register_ip();
+
+    xTaskCreate(meteo_task, "meteo_task", 2048, NULL, 10, NULL);
+
+    /* Print chip information */
+    esp_chip_info_t chip_info;
+    esp_chip_info(&chip_info);
+    printf("This is ESP8266 chip with %d CPU cores, WiFi, ",
+            chip_info.cores);
+
+    printf("silicon revision %d, ", chip_info.revision);
+
+    printf("%dMB %s flash\n", spi_flash_get_chip_size() / (1024 * 1024),
+            (chip_info.features & CHIP_FEATURE_EMB_FLASH) ? "embedded" : "external");
+
+
+
+    /* Register commands */
+    esp_console_register_help_command();
+    console_register_system();
+    console_register_wifi();
+
+    /* Prompt to be printed before each line.
+     * This can be customized, made dynamic, etc.
+     */
+    const char* prompt = LOG_COLOR_I "esp8266> " LOG_RESET_COLOR;
+
+    printf("\n"
+           "Welcome to ESP-IDF console.\n"
+           "Type 'help' to get the list of commands.\n"
+           "Use UP/DOWN arrows to navigate through command history.\n"
+           "Press TAB when typing command name to auto-complete.\n");
+
+    /* Figure out if the terminal supports escape sequences */
+    int probe_status = linenoiseProbe();
+    if (probe_status) { /* zero indicates success */
+        printf("\n"
+               "Your terminal application does not support escape sequences.\n"
+               "Line editing and history features are disabled.\n"
+               "On Windows, try using Putty instead.\n");
+        linenoiseSetDumbMode(1);
+#if CONFIG_LOG_COLORS
+        /* Since the terminal doesn't support escape sequences,
+         * don't use color codes in the prompt.
+         */
+        prompt = "esp8266> ";
+#endif //CONFIG_LOG_COLORS
+    }
+
+    /* Main loop */
+    while(true) {
+        /* Get a line using linenoise.
+         * The line is returned when ENTER is pressed.
+         */
+        char* line = linenoise(prompt);
+        if (line == NULL) { /* Ignore empty lines */
+            continue;
+        }
+        /* Add the command to the history */
+        linenoiseHistoryAdd(line);
+
+        /* Try to run the command */
+        int ret;
+        esp_err_t err = esp_console_run(line, &ret);
+        if (err == ESP_ERR_NOT_FOUND) {
+            printf("Unrecognized command\n");
+        } else if (err == ESP_ERR_INVALID_ARG) {
+            // command was empty
+        } else if (err == ESP_OK && ret != ESP_OK) {
+            printf("Command returned non-zero error code: 0x%x (%s)\n", ret, esp_err_to_name(err));
+        } else if (err != ESP_OK) {
+            printf("Internal error: %s\n", esp_err_to_name(err));
+        }
+        /* linenoise allocates line buffer on the heap, so need to free it */
+        linenoiseFree(line);
+    }
+}

main/meteo_task.c

@@ -0,0 +1,39 @@
+/**
+ * TODO file description
+ */
+
+#include <stdio.h>
+#include <FreeRTOS.h>
+#include <task.h>
+#include "meteo_task.h"
+#include "ds18b20.h"
+#include "dht.h"
+#include "driver/gpio.h"
+
+void meteo_task(void* pvParameters)
+{
+    // Try to unfuck GPIOs
+    PIN_FUNC_SELECT(PERIPHS_IO_MUX_MTDI_U, FUNC_GPIO12);
+    PIN_FUNC_SELECT(PERIPHS_IO_MUX_MTCK_U, FUNC_GPIO13);
+    PIN_FUNC_SELECT(PERIPHS_IO_MUX_MTMS_U, FUNC_GPIO14);
+    PIN_FUNC_SELECT(PERIPHS_IO_MUX_MTDO_U, FUNC_GPIO15);
+
+    float dht_hum, dht_temp, ds_temp;
+    while (1) {
+        // this works ...
+        ds_temp = ds18b20_measure_and_read(0, DS18B20_ANY);
+        if (ds_temp != ds_temp) { // NAN
+            printf("Fail to read temp\n");
+        } else {
+            printf("Dallas: %f °C\n", ds_temp);
+        }
+
+        if (dht_read_float_data(DHT_TYPE_DHT11, 12, &dht_hum, &dht_temp)) {
+            printf("DHT: %f °C, %f %%r.H\n", dht_temp, dht_hum);
+        }
+
+        vTaskDelay(pdMS_TO_TICKS(1000));
+    }
+
+    vTaskDelete(NULL);
+}

main/meteo_task.h

@@ -0,0 +1,10 @@
+/**
+ * TODO file description
+ */
+
+#ifndef METEO_TASK_H
+#define METEO_TASK_H
+
+void meteo_task(void* pvParameters);
+
+#endif //METEO_TASK_H

sdkconfig

@@ -0,0 +1,531 @@
+#
+# Automatically generated file. DO NOT EDIT.
+# Espressif IoT Development Framework (ESP-IDF) Project Configuration
+#
+CONFIG_IDF_TARGET_ESP8266=y
+CONFIG_IDF_TARGET="esp8266"
+
+#
+# SDK tool configuration
+#
+CONFIG_SDK_TOOLPREFIX="xtensa-lx106-elf-"
+CONFIG_SDK_PYTHON="python"
+# CONFIG_SDK_MAKE_WARN_UNDEFINED_VARIABLES is not set
+CONFIG_BOOTLOADER_INIT_SPI_FLASH=y
+# CONFIG_BOOTLOADER_DISABLE_JTAG_IO is not set
+# CONFIG_BOOTLOADER_FAST_BOOT is not set
+# CONFIG_LOG_BOOTLOADER_LEVEL_NONE is not set
+# CONFIG_LOG_BOOTLOADER_LEVEL_ERROR is not set
+# CONFIG_LOG_BOOTLOADER_LEVEL_WARN is not set
+CONFIG_LOG_BOOTLOADER_LEVEL_INFO=y
+# CONFIG_LOG_BOOTLOADER_LEVEL_DEBUG is not set
+# CONFIG_LOG_BOOTLOADER_LEVEL_VERBOSE is not set
+CONFIG_LOG_BOOTLOADER_LEVEL=3
+# CONFIG_BOOTLOADER_APP_TEST is not set
+CONFIG_BOOTLOADER_STORE_OFFSET=0x0
+CONFIG_BOOTLOADER_FLASH_XMC_SUPPORT=y
+CONFIG_ESPTOOLPY_PORT="/dev/ttyUSB0"
+CONFIG_ESPTOOLPY_BAUD_115200B=y
+# CONFIG_ESPTOOLPY_BAUD_230400B is not set
+# CONFIG_ESPTOOLPY_BAUD_921600B is not set
+# CONFIG_ESPTOOLPY_BAUD_2MB is not set
+# CONFIG_ESPTOOLPY_BAUD_OTHER is not set
+CONFIG_ESPTOOLPY_BAUD_OTHER_VAL=115200
+CONFIG_ESPTOOLPY_BAUD=115200
+CONFIG_ESPTOOLPY_COMPRESSED=y
+CONFIG_ESPTOOLPY_FLASHMODE_QIO=y
+# CONFIG_ESPTOOLPY_FLASHMODE_QOUT is not set
+# CONFIG_ESPTOOLPY_FLASHMODE_DIO is not set
+# CONFIG_ESPTOOLPY_FLASHMODE_DOUT is not set
+CONFIG_ESPTOOLPY_FLASHMODE="dio"
+CONFIG_SPI_FLASH_MODE=0x0
+# CONFIG_ESPTOOLPY_FLASHFREQ_80M is not set
+CONFIG_ESPTOOLPY_FLASHFREQ_40M=y
+# CONFIG_ESPTOOLPY_FLASHFREQ_26M is not set
+# CONFIG_ESPTOOLPY_FLASHFREQ_20M is not set
+CONFIG_ESPTOOLPY_FLASHFREQ="40m"
+CONFIG_SPI_FLASH_FREQ=0x0
+# CONFIG_ESPTOOLPY_FLASHSIZE_1MB is not set
+CONFIG_ESPTOOLPY_FLASHSIZE_2MB=y
+# CONFIG_ESPTOOLPY_FLASHSIZE_4MB is not set
+# CONFIG_ESPTOOLPY_FLASHSIZE_8MB is not set
+# CONFIG_ESPTOOLPY_FLASHSIZE_16MB is not set
+CONFIG_ESPTOOLPY_FLASHSIZE="2MB"
+CONFIG_SPI_FLASH_SIZE=0x200000
+CONFIG_ESPTOOLPY_BEFORE_RESET=y
+# CONFIG_ESPTOOLPY_BEFORE_NORESET is not set
+CONFIG_ESPTOOLPY_BEFORE="default_reset"
+CONFIG_ESPTOOLPY_AFTER_HARD_RESET=y
+# CONFIG_ESPTOOLPY_AFTER_SOFT_RESET is not set
+# CONFIG_ESPTOOLPY_AFTER_NORESET is not set
+CONFIG_ESPTOOLPY_AFTER="hard_reset"
+# CONFIG_ESPTOOLPY_MONITOR_BAUD_9600B is not set
+# CONFIG_ESPTOOLPY_MONITOR_BAUD_57600B is not set
+CONFIG_ESPTOOLPY_MONITOR_BAUD_74880B=y
+# CONFIG_ESPTOOLPY_MONITOR_BAUD_115200B is not set
+# CONFIG_ESPTOOLPY_MONITOR_BAUD_230400B is not set
+# CONFIG_ESPTOOLPY_MONITOR_BAUD_921600B is not set
+# CONFIG_ESPTOOLPY_MONITOR_BAUD_2MB is not set
+# CONFIG_ESPTOOLPY_MONITOR_BAUD_OTHER is not set
+CONFIG_ESPTOOLPY_MONITOR_BAUD_OTHER_VAL=74880
+CONFIG_ESPTOOLPY_MONITOR_BAUD=74880
+# CONFIG_STORE_HISTORY is not set
+CONFIG_PARTITION_TABLE_SINGLE_APP=y
+# CONFIG_PARTITION_TABLE_TWO_OTA is not set
+# CONFIG_PARTITION_TABLE_CUSTOM is not set
+CONFIG_PARTITION_TABLE_CUSTOM_FILENAME="partitions.csv"
+CONFIG_PARTITION_TABLE_OFFSET=0x8000
+CONFIG_PARTITION_TABLE_FILENAME="partitions_singleapp.csv"
+CONFIG_COMPILER_OPTIMIZATION_LEVEL_DEBUG=y
+# CONFIG_COMPILER_OPTIMIZATION_LEVEL_RELEASE is not set
+CONFIG_COMPILER_OPTIMIZATION_ASSERTIONS_ENABLE=y
+# CONFIG_COMPILER_OPTIMIZATION_ASSERTIONS_SILENT is not set
+# CONFIG_COMPILER_OPTIMIZATION_ASSERTIONS_DISABLE is not set
+# CONFIG_COMPILER_CXX_EXCEPTIONS is not set
+# CONFIG_COMPILER_STACK_CHECK_MODE_NONE is not set
+CONFIG_COMPILER_STACK_CHECK_MODE_NORM=y
+# CONFIG_COMPILER_STACK_CHECK_MODE_STRONG is not set
+# CONFIG_COMPILER_STACK_CHECK_MODE_ALL is not set
+CONFIG_COMPILER_STACK_CHECK=y
+# CONFIG_COMPILER_WARN_WRITE_STRINGS is not set
+CONFIG_APP_UPDATE_CHECK_APP_SUM=y
+# CONFIG_APP_UPDATE_CHECK_APP_HASH is not set
+CONFIG_APP_COMPILE_TIME_DATE=y
+# CONFIG_APP_EXCLUDE_PROJECT_VER_VAR is not set
+# CONFIG_APP_EXCLUDE_PROJECT_NAME_VAR is not set
+# CONFIG_APP_PROJECT_VER_FROM_CONFIG is not set
+# CONFIG_ENABLE_COAP is not set
+CONFIG_ESP_TLS_USING_MBEDTLS=y
+# CONFIG_ESP_TLS_USING_WOLFSSL is not set
+# CONFIG_ESP_TLS_SERVER is not set
+# CONFIG_ESP_TLS_PSK_VERIFICATION is not set
+# CONFIG_ESP_TLS_INSECURE is not set
+# CONFIG_ESP_WOLFSSL_INTERNAL is not set
+# CONFIG_WOLFSSL_DEBUG is not set
+CONFIG_ESP8266_NMI_WDT=y
+# CONFIG_ESP8266_XTAL_FREQ_40 is not set
+CONFIG_ESP8266_XTAL_FREQ_26=y
+CONFIG_ESP8266_XTAL_FREQ=26
+# CONFIG_ESP8266_DEFAULT_CPU_FREQ_80 is not set
+CONFIG_ESP8266_DEFAULT_CPU_FREQ_160=y
+CONFIG_ESP8266_DEFAULT_CPU_FREQ_MHZ=160
+CONFIG_ESP_FILENAME_MACRO_NO_PATH=y
+# CONFIG_ESP_FILENAME_MACRO_RAW is not set
+# CONFIG_ESP_FILENAME_MACRO_NULL is not set
+CONFIG_USING_NEW_ETS_VPRINTF=y
+# CONFIG_LINK_ETS_PRINTF_TO_IRAM is not set
+CONFIG_ETS_PRINTF_EXIT_WHEN_FLASH_RW=y
+# CONFIG_SOC_FULL_ICACHE is not set
+CONFIG_SOC_IRAM_SIZE=0xC000
+# CONFIG_DISABLE_ROM_UART_PRINT is not set
+# CONFIG_ESP_PANIC_PRINT_HALT is not set
+CONFIG_ESP_PANIC_PRINT_REBOOT=y
+# CONFIG_ESP_PANIC_SILENT_REBOOT is not set
+# CONFIG_ESP_PANIC_GDBSTUB is not set
+CONFIG_RESET_REASON=y
+CONFIG_WIFI_PPT_TASKSTACK_SIZE=5120
+CONFIG_ESP8266_CORE_GLOBAL_DATA_LINK_IRAM=y
+# CONFIG_ESP8266_OTA_FROM_OLD is not set
+# CONFIG_ESP8266_BOOT_COPY_APP is not set
+CONFIG_ESP8266_TIME_SYSCALL_USE_FRC1=y
+# CONFIG_ESP8266_TIME_SYSCALL_USE_NONE is not set
+# CONFIG_PM_ENABLE is not set
+CONFIG_SCAN_AP_MAX=99
+CONFIG_WIFI_TX_RATE_SEQUENCE_FROM_HIGH=y
+# CONFIG_ESP8266_WIFI_QOS_ENABLED is not set
+# CONFIG_ESP8266_WIFI_AMPDU_RX_ENABLED is not set
+# CONFIG_ESP8266_WIFI_AMSDU_ENABLED is not set
+CONFIG_ESP8266_WIFI_RX_BUFFER_NUM=16
+CONFIG_ESP8266_WIFI_LEFT_CONTINUOUS_RX_BUFFER_NUM=16
+CONFIG_ESP8266_WIFI_RX_PKT_NUM=7
+CONFIG_ESP8266_WIFI_TX_PKT_NUM=6
+CONFIG_ESP8266_WIFI_NVS_ENABLED=y
+CONFIG_ESP8266_WIFI_CONNECT_OPEN_ROUTER_WHEN_PWD_IS_SET=y
+CONFIG_ESP8266_WIFI_ENABLE_WPA3_SAE=y
+# CONFIG_ESP8266_WIFI_DEBUG_LOG_ENABLE is not set
+CONFIG_ESP_PHY_CALIBRATION_AND_DATA_STORAGE=y
+# CONFIG_ESP_PHY_INIT_DATA_IN_PARTITION is not set
+CONFIG_ESP_PHY_INIT_DATA_VDD33_CONST=33
+CONFIG_ESP8266_PHY_MAX_WIFI_TX_POWER=20
+# CONFIG_ESP8266_HSPI_HIGH_THROUGHPUT is not set
+CONFIG_ESP_ERR_TO_NAME_LOOKUP=y
+CONFIG_ESP_SYSTEM_EVENT_QUEUE_SIZE=32
+CONFIG_ESP_SYSTEM_EVENT_TASK_STACK_SIZE=2048
+CONFIG_ESP_MAIN_TASK_STACK_SIZE=3584
+CONFIG_ESP_TIMER_TASK_STACK_SIZE=3584
+CONFIG_ESP_CONSOLE_UART_DEFAULT=y
+# CONFIG_ESP_CONSOLE_UART_CUSTOM is not set
+# CONFIG_ESP_CONSOLE_UART_NONE is not set
+CONFIG_ESP_CONSOLE_UART_NUM=0
+CONFIG_ESP_CONSOLE_UART_BAUDRATE=74880
+# CONFIG_ESP_UART0_SWAP_IO is not set
+CONFIG_ESP_TASK_WDT=y
+CONFIG_ESP_TASK_WDT_PANIC=y
+# CONFIG_ESP_TASK_WDT_TIMEOUT_13N is not set
+# CONFIG_ESP_TASK_WDT_TIMEOUT_14N is not set
+CONFIG_ESP_TASK_WDT_TIMEOUT_15N=y
+CONFIG_ESP_TASK_WDT_TIMEOUT_S=15
+# CONFIG_ESP_EVENT_LOOP_PROFILING is not set
+CONFIG_ESP_EVENT_POST_FROM_ISR=y
+CONFIG_ESP_HTTP_CLIENT_ENABLE_HTTPS=y
+# CONFIG_ESP_HTTP_CLIENT_ENABLE_BASIC_AUTH is not set
+CONFIG_HTTP_BUF_SIZE=512
+CONFIG_HTTPD_MAX_REQ_HDR_LEN=512
+CONFIG_HTTPD_MAX_URI_LEN=512
+CONFIG_OTA_BUF_SIZE=256
+# CONFIG_OTA_ALLOW_HTTP is not set
+# CONFIG_FATFS_CODEPAGE_DYNAMIC is not set
+CONFIG_FATFS_CODEPAGE_437=y
+# CONFIG_FATFS_CODEPAGE_720 is not set
+# CONFIG_FATFS_CODEPAGE_737 is not set
+# CONFIG_FATFS_CODEPAGE_771 is not set
+# CONFIG_FATFS_CODEPAGE_775 is not set
+# CONFIG_FATFS_CODEPAGE_850 is not set
+# CONFIG_FATFS_CODEPAGE_852 is not set
+# CONFIG_FATFS_CODEPAGE_855 is not set
+# CONFIG_FATFS_CODEPAGE_857 is not set
+# CONFIG_FATFS_CODEPAGE_860 is not set
+# CONFIG_FATFS_CODEPAGE_861 is not set
+# CONFIG_FATFS_CODEPAGE_862 is not set
+# CONFIG_FATFS_CODEPAGE_863 is not set
+# CONFIG_FATFS_CODEPAGE_864 is not set
+# CONFIG_FATFS_CODEPAGE_865 is not set
+# CONFIG_FATFS_CODEPAGE_866 is not set
+# CONFIG_FATFS_CODEPAGE_869 is not set
+# CONFIG_FATFS_CODEPAGE_932 is not set
+# CONFIG_FATFS_CODEPAGE_936 is not set
+# CONFIG_FATFS_CODEPAGE_949 is not set
+# CONFIG_FATFS_CODEPAGE_950 is not set
+CONFIG_FATFS_CODEPAGE=437
+CONFIG_FATFS_LFN_NONE=y
+# CONFIG_FATFS_LFN_HEAP is not set
+# CONFIG_FATFS_LFN_STACK is not set
+CONFIG_FATFS_FS_LOCK=0
+CONFIG_FATFS_TIMEOUT_MS=10000
+CONFIG_FATFS_PER_FILE_CACHE=y
+CONFIG_FMB_COMM_MODE_TCP_EN=y
+CONFIG_FMB_TCP_PORT_DEFAULT=502
+CONFIG_FMB_TCP_PORT_MAX_CONN=5
+CONFIG_FMB_TCP_CONNECTION_TOUT_SEC=20
+CONFIG_FMB_MASTER_TIMEOUT_MS_RESPOND=150
+CONFIG_FMB_MASTER_DELAY_MS_CONVERT=200
+CONFIG_FMB_QUEUE_LENGTH=20
+CONFIG_FMB_PORT_TASK_STACK_SIZE=4096
+CONFIG_FMB_SERIAL_BUF_SIZE=256
+CONFIG_FMB_PORT_TASK_PRIO=10
+CONFIG_FMB_CONTROLLER_SLAVE_ID_SUPPORT=y
+CONFIG_FMB_CONTROLLER_SLAVE_ID=0x00112233
+CONFIG_FMB_CONTROLLER_NOTIFY_TIMEOUT=20
+CONFIG_FMB_CONTROLLER_NOTIFY_QUEUE_SIZE=20
+CONFIG_FMB_CONTROLLER_STACK_SIZE=4096
+CONFIG_FMB_EVENT_QUEUE_TIMEOUT=20
+CONFIG_FMB_TIMER_GROUP=0
+CONFIG_FMB_TIMER_INDEX=0
+# CONFIG_FMB_TIMER_ISR_IN_IRAM is not set
+# CONFIG_DISABLE_FREERTOS is not set
+CONFIG_FREERTOS_UNICORE=y
+# CONFIG_FREERTOS_ENABLE_REENT is not set
+CONFIG_FREERTOS_NO_AFFINITY=0x7FFFFFFF
+CONFIG_FREERTOS_HZ=100
+CONFIG_FREERTOS_MAX_HOOK=2
+CONFIG_FREERTOS_IDLE_TASK_STACKSIZE=1024
+CONFIG_FREERTOS_ISR_STACKSIZE=512
+# CONFIG_FREERTOS_EXTENED_HOOKS is not set
+CONFIG_FREERTOS_GLOBAL_DATA_LINK_IRAM=y
+# CONFIG_FREERTOS_CODE_LINK_TO_IRAM is not set
+CONFIG_FREERTOS_TIMER_STACKSIZE=2048
+CONFIG_TASK_SWITCH_FASTER=y
+# CONFIG_USE_QUEUE_SETS is not set
+# CONFIG_ENABLE_FREERTOS_SLEEP is not set
+CONFIG_FREERTOS_USE_TRACE_FACILITY=y
+CONFIG_FREERTOS_USE_STATS_FORMATTING_FUNCTIONS=y
+CONFIG_FREERTOS_GENERATE_RUN_TIME_STATS=y
+CONFIG_FREERTOS_RUN_TIME_STATS_USING_ESP_TIMER=y
+# CONFIG_FREERTOS_RUN_TIME_STATS_USING_CPU_CLK is not set
+CONFIG_FREERTOS_WATCHPOINT_END_OF_STACK=y
+# CONFIG_HEAP_DISABLE_IRAM is not set
+# CONFIG_HEAP_TRACING is not set
+CONFIG_LIBSODIUM_USE_MBEDTLS_SHA=y
+# CONFIG_LOG_DEFAULT_LEVEL_NONE is not set
+# CONFIG_LOG_DEFAULT_LEVEL_ERROR is not set
+# CONFIG_LOG_DEFAULT_LEVEL_WARN is not set
+CONFIG_LOG_DEFAULT_LEVEL_INFO=y
+# CONFIG_LOG_DEFAULT_LEVEL_DEBUG is not set
+# CONFIG_LOG_DEFAULT_LEVEL_VERBOSE is not set
+CONFIG_LOG_DEFAULT_LEVEL=3
+CONFIG_LOG_COLORS=y
+# CONFIG_LOG_SET_LEVEL is not set
+CONFIG_LWIP_LOCAL_HOSTNAME="espressif"
+CONFIG_LWIP_DNS_SUPPORT_MDNS_QUERIES=y
+# CONFIG_LWIP_L2_TO_L3_COPY is not set
+# CONFIG_LWIP_IRAM_OPTIMIZATION is not set
+CONFIG_LWIP_TIMERS_ONDEMAND=y
+CONFIG_LWIP_MAX_SOCKETS=10
+# CONFIG_LWIP_USE_ONLY_LWIP_SELECT is not set
+# CONFIG_LWIP_SO_LINGER is not set
+CONFIG_LWIP_SO_REUSE=y
+CONFIG_LWIP_SO_REUSE_RXTOALL=y
+# CONFIG_LWIP_SO_RCVBUF is not set
+# CONFIG_LWIP_NETBUF_RECVINFO is not set
+CONFIG_LWIP_IP4_FRAG=y
+CONFIG_LWIP_IP6_FRAG=y
+# CONFIG_LWIP_IP4_REASSEMBLY is not set
+# CONFIG_LWIP_IP6_REASSEMBLY is not set
+# CONFIG_LWIP_IP_FORWARD is not set
+# CONFIG_LWIP_STATS is not set
+# CONFIG_LWIP_ETHARP_TRUST_IP_MAC is not set
+CONFIG_LWIP_ESP_GRATUITOUS_ARP=y
+CONFIG_LWIP_GARP_TMR_INTERVAL=60
+CONFIG_LWIP_TCPIP_RECVMBOX_SIZE=32
+CONFIG_LWIP_DHCP_DOES_ARP_CHECK=y
+# CONFIG_LWIP_DHCP_RESTORE_LAST_IP is not set
+CONFIG_LWIP_DHCPS_LEASE_UNIT=60
+CONFIG_LWIP_DHCPS_MAX_STATION_NUM=8
+# CONFIG_LWIP_AUTOIP is not set
+# CONFIG_LWIP_IPV6_AUTOCONFIG is not set
+CONFIG_LWIP_NETIF_LOOPBACK=y
+CONFIG_LWIP_LOOPBACK_MAX_PBUFS=8
+CONFIG_LWIP_MAX_ACTIVE_TCP=16
+CONFIG_LWIP_MAX_LISTENING_TCP=16
+CONFIG_LWIP_TCP_MAXRTX=12
+CONFIG_LWIP_TCP_SYNMAXRTX=6
+CONFIG_LWIP_TCP_MSS=1440
+CONFIG_LWIP_TCP_TMR_INTERVAL=250
+CONFIG_LWIP_TCP_MSL=60000
+CONFIG_LWIP_TCP_SND_BUF_DEFAULT=2880
+CONFIG_LWIP_TCP_WND_DEFAULT=5760
+CONFIG_LWIP_TCP_RECVMBOX_SIZE=6
+CONFIG_LWIP_TCP_QUEUE_OOSEQ=y
+# CONFIG_LWIP_TCP_SACK_OUT is not set
+# CONFIG_LWIP_TCP_KEEP_CONNECTION_WHEN_IP_CHANGES is not set
+CONFIG_LWIP_TCP_OVERSIZE_MSS=y
+# CONFIG_LWIP_TCP_OVERSIZE_QUARTER_MSS is not set
+# CONFIG_LWIP_TCP_OVERSIZE_DISABLE is not set
+CONFIG_LWIP_TCP_RTO_TIME=3000
+CONFIG_LWIP_MAX_UDP_PCBS=16
+CONFIG_LWIP_UDP_RECVMBOX_SIZE=6
+CONFIG_LWIP_TCPIP_TASK_STACK_SIZE=2048
+CONFIG_LWIP_TCPIP_TASK_AFFINITY_NO_AFFINITY=y
+# CONFIG_LWIP_TCPIP_TASK_AFFINITY_CPU0 is not set
+CONFIG_LWIP_TCPIP_TASK_AFFINITY=0x7FFFFFFF
+# CONFIG_LWIP_PPP_SUPPORT is not set
+CONFIG_LWIP_IPV6_MEMP_NUM_ND6_QUEUE=3
+CONFIG_LWIP_IPV6_ND6_NUM_NEIGHBORS=5
+# CONFIG_LWIP_MULTICAST_PING is not set
+# CONFIG_LWIP_BROADCAST_PING is not set
+CONFIG_LWIP_MAX_RAW_PCBS=16
+# CONFIG_LWIP_IPV6 is not set
+CONFIG_LWIP_DHCP_MAX_NTP_SERVERS=1
+CONFIG_LWIP_SNTP_UPDATE_DELAY=3600000
+CONFIG_LWIP_ESP_LWIP_ASSERT=y
+# CONFIG_LWIP_DEBUG is not set
+CONFIG_MBEDTLS_INTERNAL_MEM_ALLOC=y
+# CONFIG_MBEDTLS_DEFAULT_MEM_ALLOC is not set
+# CONFIG_MBEDTLS_CUSTOM_MEM_ALLOC is not set
+CONFIG_MBEDTLS_ASYMMETRIC_CONTENT_LEN=y
+CONFIG_MBEDTLS_SSL_IN_CONTENT_LEN=16384
+CONFIG_MBEDTLS_SSL_OUT_CONTENT_LEN=4096
+# CONFIG_MBEDTLS_DYNAMIC_BUFFER is not set
+# CONFIG_MBEDTLS_DEBUG is not set
+CONFIG_MBEDTLS_HAVE_TIME=y
+# CONFIG_MBEDTLS_HAVE_TIME_DATE is not set
+CONFIG_MBEDTLS_TLS_SERVER_AND_CLIENT=y
+# CONFIG_MBEDTLS_TLS_SERVER_ONLY is not set
+# CONFIG_MBEDTLS_TLS_CLIENT_ONLY is not set
+# CONFIG_MBEDTLS_TLS_DISABLED is not set
+CONFIG_MBEDTLS_TLS_SERVER=y
+CONFIG_MBEDTLS_TLS_CLIENT=y
+CONFIG_MBEDTLS_TLS_ENABLED=y
+# CONFIG_MBEDTLS_PSK_MODES is not set
+CONFIG_MBEDTLS_KEY_EXCHANGE_RSA=y
+CONFIG_MBEDTLS_KEY_EXCHANGE_DHE_RSA=y
+CONFIG_MBEDTLS_KEY_EXCHANGE_ELLIPTIC_CURVE=y
+CONFIG_MBEDTLS_KEY_EXCHANGE_ECDHE_RSA=y
+CONFIG_MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA=y
+CONFIG_MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA=y
+CONFIG_MBEDTLS_KEY_EXCHANGE_ECDH_RSA=y
+CONFIG_MBEDTLS_SSL_RENEGOTIATION=y
+# CONFIG_MBEDTLS_SSL_PROTO_SSL3 is not set
+CONFIG_MBEDTLS_SSL_PROTO_TLS1=y
+CONFIG_MBEDTLS_SSL_PROTO_TLS1_1=y
+CONFIG_MBEDTLS_SSL_PROTO_TLS1_2=y
+# CONFIG_MBEDTLS_SSL_PROTO_GMTSSL1_1 is not set
+# CONFIG_MBEDTLS_SSL_PROTO_DTLS is not set
+CONFIG_MBEDTLS_SSL_ALPN=y
+CONFIG_MBEDTLS_CLIENT_SSL_SESSION_TICKETS=y
+CONFIG_MBEDTLS_SERVER_SSL_SESSION_TICKETS=y
+CONFIG_MBEDTLS_AES_C=y
+# CONFIG_MBEDTLS_CAMELLIA_C is not set
+# CONFIG_MBEDTLS_DES_C is not set
+CONFIG_MBEDTLS_RC4_DISABLED=y
+# CONFIG_MBEDTLS_RC4_ENABLED_NO_DEFAULT is not set
+# CONFIG_MBEDTLS_RC4_ENABLED is not set
+# CONFIG_MBEDTLS_BLOWFISH_C is not set
+# CONFIG_MBEDTLS_XTEA_C is not set
+CONFIG_MBEDTLS_CCM_C=y
+CONFIG_MBEDTLS_GCM_C=y
+# CONFIG_MBEDTLS_RIPEMD160_C is not set
+CONFIG_MBEDTLS_PEM_PARSE_C=y
+CONFIG_MBEDTLS_PEM_WRITE_C=y
+CONFIG_MBEDTLS_X509_CRL_PARSE_C=y
+CONFIG_MBEDTLS_X509_CSR_PARSE_C=y
+CONFIG_MBEDTLS_ECP_C=y
+CONFIG_MBEDTLS_ECDH_C=y
+CONFIG_MBEDTLS_ECDSA_C=y
+CONFIG_MBEDTLS_ECP_DP_SECP192R1_ENABLED=y
+CONFIG_MBEDTLS_ECP_DP_SECP224R1_ENABLED=y
+CONFIG_MBEDTLS_ECP_DP_SECP256R1_ENABLED=y
+CONFIG_MBEDTLS_ECP_DP_SECP384R1_ENABLED=y
+CONFIG_MBEDTLS_ECP_DP_SECP521R1_ENABLED=y
+CONFIG_MBEDTLS_ECP_DP_SECP192K1_ENABLED=y
+CONFIG_MBEDTLS_ECP_DP_SECP224K1_ENABLED=y
+CONFIG_MBEDTLS_ECP_DP_SECP256K1_ENABLED=y
+CONFIG_MBEDTLS_ECP_DP_BP256R1_ENABLED=y
+CONFIG_MBEDTLS_ECP_DP_BP384R1_ENABLED=y
+CONFIG_MBEDTLS_ECP_DP_BP512R1_ENABLED=y
+CONFIG_MBEDTLS_ECP_DP_CURVE25519_ENABLED=y
+CONFIG_MBEDTLS_ECP_NIST_OPTIM=y
+# CONFIG_util_assert is not set
+# CONFIG_ESP_SHA is not set
+CONFIG_ESP_AES=y
+CONFIG_ESP_MD5=y
+CONFIG_ESP_ARC4=y
+# CONFIG_ENABLE_MDNS is not set
+CONFIG_MQTT_PROTOCOL_311=y
+CONFIG_MQTT_TRANSPORT_SSL=y
+CONFIG_MQTT_TRANSPORT_WEBSOCKET=y
+CONFIG_MQTT_TRANSPORT_WEBSOCKET_SECURE=y
+# CONFIG_MQTT_USE_CUSTOM_CONFIG is not set
+# CONFIG_MQTT_TASK_CORE_SELECTION_ENABLED is not set
+# CONFIG_MQTT_CUSTOM_OUTBOX is not set
+CONFIG_NEWLIB_STDOUT_LINE_ENDING_CRLF=y
+# CONFIG_NEWLIB_STDOUT_LINE_ENDING_LF is not set
+# CONFIG_NEWLIB_STDOUT_LINE_ENDING_CR is not set
+# CONFIG_NEWLIB_NANO_FORMAT is not set
+# CONFIG_OPENSSL_DEBUG is not set
+CONFIG_OPENSSL_ASSERT_DO_NOTHING=y
+# CONFIG_OPENSSL_ASSERT_EXIT is not set
+CONFIG_PTHREAD_TASK_PRIO_DEFAULT=5
+CONFIG_PTHREAD_TASK_STACK_SIZE_DEFAULT=3072
+CONFIG_PTHREAD_STACK_MIN=768
+CONFIG_PTHREAD_TASK_NAME_DEFAULT="pthread"
+CONFIG_SPIFFS_MAX_PARTITIONS=3
+CONFIG_SPIFFS_CACHE=y
+CONFIG_SPIFFS_CACHE_WR=y
+# CONFIG_SPIFFS_CACHE_STATS is not set
+CONFIG_SPIFFS_PAGE_CHECK=y
+CONFIG_SPIFFS_GC_MAX_RUNS=10
+# CONFIG_SPIFFS_GC_STATS is not set
+CONFIG_SPIFFS_PAGE_SIZE=256
+CONFIG_SPIFFS_OBJ_NAME_LEN=32
+CONFIG_SPIFFS_USE_MAGIC=y
+CONFIG_SPIFFS_USE_MAGIC_LENGTH=y
+CONFIG_SPIFFS_META_LENGTH=4
+CONFIG_SPIFFS_USE_MTIME=y
+# CONFIG_SPIFFS_DBG is not set
+# CONFIG_SPIFFS_API_DBG is not set
+# CONFIG_SPIFFS_GC_DBG is not set
+# CONFIG_SPIFFS_CACHE_DBG is not set
+# CONFIG_SPIFFS_CHECK_DBG is not set
+# CONFIG_SPIFFS_TEST_VISUALISATION is not set
+CONFIG_IP_LOST_TIMER_INTERVAL=120
+CONFIG_TCPIP_ADAPTER_GLOBAL_DATA_LINK_IRAM=y
+CONFIG_VFS_SUPPRESS_SELECT_DEBUG_OUTPUT=y
+CONFIG_VFS_SUPPORT_TERMIOS=y
+CONFIG_SEMIHOSTFS_MAX_MOUNT_POINTS=1
+CONFIG_SEMIHOSTFS_HOST_PATH_MAX_LEN=128
+# CONFIG_WL_SECTOR_SIZE_512 is not set
+CONFIG_WL_SECTOR_SIZE_4096=y
+CONFIG_WL_SECTOR_SIZE=4096
+# CONFIG_ENABLE_UNIFIED_PROVISIONING is not set
+CONFIG_LTM_FAST=y
+CONFIG_WPA_MBEDTLS_CRYPTO=y
+# CONFIG_WPA_DEBUG_PRINT is not set
+# CONFIG_WPA_TESTING_OPTIONS is not set
+# CONFIG_WPA_WPS_WARS is not set
+# CONFIG_WPA_11KV_SUPPORT is not set
+
+# Deprecated options for backward compatibility
+CONFIG_TARGET_PLATFORM="esp8266"
+CONFIG_TOOLPREFIX="xtensa-lx106-elf-"
+# CONFIG_MAKE_WARN_UNDEFINED_VARIABLES is not set
+CONFIG_FLASHMODE_QIO=y
+# CONFIG_FLASHMODE_QOUT is not set
+# CONFIG_FLASHMODE_DIO is not set
+# CONFIG_FLASHMODE_DOUT is not set
+# CONFIG_MONITOR_BAUD_9600B is not set
+# CONFIG_MONITOR_BAUD_57600B is not set
+CONFIG_MONITOR_BAUD_74880B=y
+# CONFIG_MONITOR_BAUD_115200B is not set
+# CONFIG_MONITOR_BAUD_230400B is not set
+# CONFIG_MONITOR_BAUD_921600B is not set
+# CONFIG_MONITOR_BAUD_2MB is not set
+# CONFIG_MONITOR_BAUD_OTHER is not set
+CONFIG_MONITOR_BAUD_OTHER_VAL=74880
+CONFIG_MONITOR_BAUD=74880
+CONFIG_OPTIMIZATION_LEVEL_DEBUG=y
+# CONFIG_OPTIMIZATION_LEVEL_RELEASE is not set
+CONFIG_OPTIMIZATION_ASSERTIONS_ENABLED=y
+# CONFIG_OPTIMIZATION_ASSERTIONS_SILENT is not set
+# CONFIG_OPTIMIZATION_ASSERTIONS_DISABLED is not set
+# CONFIG_CXX_EXCEPTIONS is not set
+# CONFIG_STACK_CHECK_NONE is not set
+CONFIG_STACK_CHECK_NORM=y
+# CONFIG_STACK_CHECK_STRONG is not set
+# CONFIG_STACK_CHECK_ALL is not set
+CONFIG_STACK_CHECK=y
+# CONFIG_WARN_WRITE_STRINGS is not set
+CONFIG_MAIN_TASK_STACK_SIZE=3584
+CONFIG_CONSOLE_UART_DEFAULT=y
+# CONFIG_CONSOLE_UART_CUSTOM is not set
+# CONFIG_CONSOLE_UART_NONE is not set
+CONFIG_CONSOLE_UART_NUM=0
+CONFIG_CONSOLE_UART_BAUDRATE=74880
+# CONFIG_UART0_SWAP_IO is not set
+CONFIG_TASK_WDT=y
+CONFIG_TASK_WDT_PANIC=y
+CONFIG_TASK_WDT_TIMEOUT_S=15
+CONFIG_MB_MASTER_TIMEOUT_MS_RESPOND=150
+CONFIG_MB_MASTER_DELAY_MS_CONVERT=200
+CONFIG_MB_QUEUE_LENGTH=20
+CONFIG_MB_SERIAL_TASK_STACK_SIZE=4096
+CONFIG_MB_SERIAL_BUF_SIZE=256
+CONFIG_MB_SERIAL_TASK_PRIO=10
+CONFIG_MB_CONTROLLER_SLAVE_ID_SUPPORT=y
+CONFIG_MB_CONTROLLER_SLAVE_ID=0x00112233
+CONFIG_MB_CONTROLLER_NOTIFY_TIMEOUT=20
+CONFIG_MB_CONTROLLER_NOTIFY_QUEUE_SIZE=20
+CONFIG_MB_CONTROLLER_STACK_SIZE=4096
+CONFIG_MB_EVENT_QUEUE_TIMEOUT=20
+CONFIG_MB_TIMER_GROUP=0
+CONFIG_MB_TIMER_INDEX=0
+# CONFIG_L2_TO_L3_COPY is not set
+# CONFIG_USE_ONLY_LWIP_SELECT is not set
+CONFIG_ESP_GRATUITOUS_ARP=y
+CONFIG_GARP_TMR_INTERVAL=60
+CONFIG_TCPIP_RECVMBOX_SIZE=32
+CONFIG_TCP_MAXRTX=12
+CONFIG_TCP_SYNMAXRTX=6
+CONFIG_TCP_MSS=1440
+CONFIG_TCP_MSL=60000
+CONFIG_TCP_SND_BUF_DEFAULT=2880
+CONFIG_TCP_WND_DEFAULT=5760
+CONFIG_TCP_RECVMBOX_SIZE=6
+CONFIG_TCP_QUEUE_OOSEQ=y
+# CONFIG_ESP_TCP_KEEP_CONNECTION_WHEN_IP_CHANGES is not set
+CONFIG_TCP_OVERSIZE_MSS=y
+# CONFIG_TCP_OVERSIZE_QUARTER_MSS is not set
+# CONFIG_TCP_OVERSIZE_DISABLE is not set
+CONFIG_UDP_RECVMBOX_SIZE=6
+CONFIG_TCPIP_TASK_STACK_SIZE=2048
+CONFIG_TCPIP_TASK_AFFINITY_NO_AFFINITY=y
+# CONFIG_TCPIP_TASK_AFFINITY_CPU0 is not set
+CONFIG_TCPIP_TASK_AFFINITY=0x7FFFFFFF
+# CONFIG_PPP_SUPPORT is not set
+CONFIG_ESP32_PTHREAD_TASK_PRIO_DEFAULT=5
+CONFIG_ESP32_PTHREAD_TASK_STACK_SIZE_DEFAULT=3072
+CONFIG_ESP32_PTHREAD_STACK_MIN=768
+CONFIG_ESP32_PTHREAD_TASK_NAME_DEFAULT="pthread"
+CONFIG_SUPPRESS_SELECT_DEBUG_OUTPUT=y
+CONFIG_SUPPORT_TERMIOS=y
+# End of deprecated options

sdkconfig.old

@@ -0,0 +1,531 @@
+#
+# Automatically generated file. DO NOT EDIT.
+# Espressif IoT Development Framework (ESP-IDF) Project Configuration
+#
+CONFIG_IDF_TARGET_ESP8266=y
+CONFIG_IDF_TARGET="esp8266"
+
+#
+# SDK tool configuration
+#
+CONFIG_SDK_TOOLPREFIX="xtensa-lx106-elf-"
+CONFIG_SDK_PYTHON="python"
+# CONFIG_SDK_MAKE_WARN_UNDEFINED_VARIABLES is not set
+CONFIG_BOOTLOADER_INIT_SPI_FLASH=y
+# CONFIG_BOOTLOADER_DISABLE_JTAG_IO is not set
+# CONFIG_BOOTLOADER_FAST_BOOT is not set
+# CONFIG_LOG_BOOTLOADER_LEVEL_NONE is not set
+# CONFIG_LOG_BOOTLOADER_LEVEL_ERROR is not set
+# CONFIG_LOG_BOOTLOADER_LEVEL_WARN is not set
+CONFIG_LOG_BOOTLOADER_LEVEL_INFO=y
+# CONFIG_LOG_BOOTLOADER_LEVEL_DEBUG is not set
+# CONFIG_LOG_BOOTLOADER_LEVEL_VERBOSE is not set
+CONFIG_LOG_BOOTLOADER_LEVEL=3
+# CONFIG_BOOTLOADER_APP_TEST is not set
+CONFIG_BOOTLOADER_STORE_OFFSET=0x0
+CONFIG_BOOTLOADER_FLASH_XMC_SUPPORT=y
+CONFIG_ESPTOOLPY_PORT="/dev/ttyUSB0"
+CONFIG_ESPTOOLPY_BAUD_115200B=y
+# CONFIG_ESPTOOLPY_BAUD_230400B is not set
+# CONFIG_ESPTOOLPY_BAUD_921600B is not set
+# CONFIG_ESPTOOLPY_BAUD_2MB is not set
+# CONFIG_ESPTOOLPY_BAUD_OTHER is not set
+CONFIG_ESPTOOLPY_BAUD_OTHER_VAL=115200
+CONFIG_ESPTOOLPY_BAUD=115200
+CONFIG_ESPTOOLPY_COMPRESSED=y
+CONFIG_ESPTOOLPY_FLASHMODE_QIO=y
+# CONFIG_ESPTOOLPY_FLASHMODE_QOUT is not set
+# CONFIG_ESPTOOLPY_FLASHMODE_DIO is not set
+# CONFIG_ESPTOOLPY_FLASHMODE_DOUT is not set
+CONFIG_ESPTOOLPY_FLASHMODE="dio"
+CONFIG_SPI_FLASH_MODE=0x0
+# CONFIG_ESPTOOLPY_FLASHFREQ_80M is not set
+CONFIG_ESPTOOLPY_FLASHFREQ_40M=y
+# CONFIG_ESPTOOLPY_FLASHFREQ_26M is not set
+# CONFIG_ESPTOOLPY_FLASHFREQ_20M is not set
+CONFIG_ESPTOOLPY_FLASHFREQ="40m"
+CONFIG_SPI_FLASH_FREQ=0x0
+# CONFIG_ESPTOOLPY_FLASHSIZE_1MB is not set
+CONFIG_ESPTOOLPY_FLASHSIZE_2MB=y
+# CONFIG_ESPTOOLPY_FLASHSIZE_4MB is not set
+# CONFIG_ESPTOOLPY_FLASHSIZE_8MB is not set
+# CONFIG_ESPTOOLPY_FLASHSIZE_16MB is not set
+CONFIG_ESPTOOLPY_FLASHSIZE="2MB"
+CONFIG_SPI_FLASH_SIZE=0x200000
+CONFIG_ESPTOOLPY_BEFORE_RESET=y
+# CONFIG_ESPTOOLPY_BEFORE_NORESET is not set
+CONFIG_ESPTOOLPY_BEFORE="default_reset"
+CONFIG_ESPTOOLPY_AFTER_HARD_RESET=y
+# CONFIG_ESPTOOLPY_AFTER_SOFT_RESET is not set
+# CONFIG_ESPTOOLPY_AFTER_NORESET is not set
+CONFIG_ESPTOOLPY_AFTER="hard_reset"
+# CONFIG_ESPTOOLPY_MONITOR_BAUD_9600B is not set
+# CONFIG_ESPTOOLPY_MONITOR_BAUD_57600B is not set
+CONFIG_ESPTOOLPY_MONITOR_BAUD_74880B=y
+# CONFIG_ESPTOOLPY_MONITOR_BAUD_115200B is not set
+# CONFIG_ESPTOOLPY_MONITOR_BAUD_230400B is not set
+# CONFIG_ESPTOOLPY_MONITOR_BAUD_921600B is not set
+# CONFIG_ESPTOOLPY_MONITOR_BAUD_2MB is not set
+# CONFIG_ESPTOOLPY_MONITOR_BAUD_OTHER is not set
+CONFIG_ESPTOOLPY_MONITOR_BAUD_OTHER_VAL=74880
+CONFIG_ESPTOOLPY_MONITOR_BAUD=74880
+# CONFIG_STORE_HISTORY is not set
+CONFIG_PARTITION_TABLE_SINGLE_APP=y
+# CONFIG_PARTITION_TABLE_TWO_OTA is not set
+# CONFIG_PARTITION_TABLE_CUSTOM is not set
+CONFIG_PARTITION_TABLE_CUSTOM_FILENAME="partitions.csv"
+CONFIG_PARTITION_TABLE_OFFSET=0x8000
+CONFIG_PARTITION_TABLE_FILENAME="partitions_singleapp.csv"
+CONFIG_COMPILER_OPTIMIZATION_LEVEL_DEBUG=y
+# CONFIG_COMPILER_OPTIMIZATION_LEVEL_RELEASE is not set
+CONFIG_COMPILER_OPTIMIZATION_ASSERTIONS_ENABLE=y
+# CONFIG_COMPILER_OPTIMIZATION_ASSERTIONS_SILENT is not set
+# CONFIG_COMPILER_OPTIMIZATION_ASSERTIONS_DISABLE is not set
+# CONFIG_COMPILER_CXX_EXCEPTIONS is not set
+CONFIG_COMPILER_STACK_CHECK_MODE_NONE=y
+# CONFIG_COMPILER_STACK_CHECK_MODE_NORM is not set
+# CONFIG_COMPILER_STACK_CHECK_MODE_STRONG is not set
+# CONFIG_COMPILER_STACK_CHECK_MODE_ALL is not set
+# CONFIG_COMPILER_STACK_CHECK is not set
+# CONFIG_COMPILER_WARN_WRITE_STRINGS is not set
+CONFIG_APP_UPDATE_CHECK_APP_SUM=y
+# CONFIG_APP_UPDATE_CHECK_APP_HASH is not set
+CONFIG_APP_COMPILE_TIME_DATE=y
+# CONFIG_APP_EXCLUDE_PROJECT_VER_VAR is not set
+# CONFIG_APP_EXCLUDE_PROJECT_NAME_VAR is not set
+# CONFIG_APP_PROJECT_VER_FROM_CONFIG is not set
+# CONFIG_ENABLE_COAP is not set
+CONFIG_ESP_TLS_USING_MBEDTLS=y
+# CONFIG_ESP_TLS_USING_WOLFSSL is not set
+# CONFIG_ESP_TLS_SERVER is not set
+# CONFIG_ESP_TLS_PSK_VERIFICATION is not set
+# CONFIG_ESP_TLS_INSECURE is not set
+# CONFIG_ESP_WOLFSSL_INTERNAL is not set
+# CONFIG_WOLFSSL_DEBUG is not set
+CONFIG_ESP8266_NMI_WDT=y
+# CONFIG_ESP8266_XTAL_FREQ_40 is not set
+CONFIG_ESP8266_XTAL_FREQ_26=y
+CONFIG_ESP8266_XTAL_FREQ=26
+# CONFIG_ESP8266_DEFAULT_CPU_FREQ_80 is not set
+CONFIG_ESP8266_DEFAULT_CPU_FREQ_160=y
+CONFIG_ESP8266_DEFAULT_CPU_FREQ_MHZ=160
+CONFIG_ESP_FILENAME_MACRO_NO_PATH=y
+# CONFIG_ESP_FILENAME_MACRO_RAW is not set
+# CONFIG_ESP_FILENAME_MACRO_NULL is not set
+CONFIG_USING_NEW_ETS_VPRINTF=y
+# CONFIG_LINK_ETS_PRINTF_TO_IRAM is not set
+CONFIG_ETS_PRINTF_EXIT_WHEN_FLASH_RW=y
+# CONFIG_SOC_FULL_ICACHE is not set
+CONFIG_SOC_IRAM_SIZE=0xC000
+# CONFIG_DISABLE_ROM_UART_PRINT is not set
+# CONFIG_ESP_PANIC_PRINT_HALT is not set
+CONFIG_ESP_PANIC_PRINT_REBOOT=y
+# CONFIG_ESP_PANIC_SILENT_REBOOT is not set
+# CONFIG_ESP_PANIC_GDBSTUB is not set
+CONFIG_RESET_REASON=y
+CONFIG_WIFI_PPT_TASKSTACK_SIZE=5120
+CONFIG_ESP8266_CORE_GLOBAL_DATA_LINK_IRAM=y
+# CONFIG_ESP8266_OTA_FROM_OLD is not set
+# CONFIG_ESP8266_BOOT_COPY_APP is not set
+CONFIG_ESP8266_TIME_SYSCALL_USE_FRC1=y
+# CONFIG_ESP8266_TIME_SYSCALL_USE_NONE is not set
+# CONFIG_PM_ENABLE is not set
+CONFIG_SCAN_AP_MAX=99
+CONFIG_WIFI_TX_RATE_SEQUENCE_FROM_HIGH=y
+# CONFIG_ESP8266_WIFI_QOS_ENABLED is not set
+# CONFIG_ESP8266_WIFI_AMPDU_RX_ENABLED is not set
+# CONFIG_ESP8266_WIFI_AMSDU_ENABLED is not set
+CONFIG_ESP8266_WIFI_RX_BUFFER_NUM=16
+CONFIG_ESP8266_WIFI_LEFT_CONTINUOUS_RX_BUFFER_NUM=16
+CONFIG_ESP8266_WIFI_RX_PKT_NUM=7
+CONFIG_ESP8266_WIFI_TX_PKT_NUM=6
+CONFIG_ESP8266_WIFI_NVS_ENABLED=y
+CONFIG_ESP8266_WIFI_CONNECT_OPEN_ROUTER_WHEN_PWD_IS_SET=y
+CONFIG_ESP8266_WIFI_ENABLE_WPA3_SAE=y
+# CONFIG_ESP8266_WIFI_DEBUG_LOG_ENABLE is not set
+CONFIG_ESP_PHY_CALIBRATION_AND_DATA_STORAGE=y
+# CONFIG_ESP_PHY_INIT_DATA_IN_PARTITION is not set
+CONFIG_ESP_PHY_INIT_DATA_VDD33_CONST=33
+CONFIG_ESP8266_PHY_MAX_WIFI_TX_POWER=20
+# CONFIG_ESP8266_HSPI_HIGH_THROUGHPUT is not set
+CONFIG_ESP_ERR_TO_NAME_LOOKUP=y
+CONFIG_ESP_SYSTEM_EVENT_QUEUE_SIZE=32
+CONFIG_ESP_SYSTEM_EVENT_TASK_STACK_SIZE=2048
+CONFIG_ESP_MAIN_TASK_STACK_SIZE=3584
+CONFIG_ESP_TIMER_TASK_STACK_SIZE=3584
+CONFIG_ESP_CONSOLE_UART_DEFAULT=y
+# CONFIG_ESP_CONSOLE_UART_CUSTOM is not set
+# CONFIG_ESP_CONSOLE_UART_NONE is not set
+CONFIG_ESP_CONSOLE_UART_NUM=0
+CONFIG_ESP_CONSOLE_UART_BAUDRATE=74880
+# CONFIG_ESP_UART0_SWAP_IO is not set
+CONFIG_ESP_TASK_WDT=y
+CONFIG_ESP_TASK_WDT_PANIC=y
+# CONFIG_ESP_TASK_WDT_TIMEOUT_13N is not set
+# CONFIG_ESP_TASK_WDT_TIMEOUT_14N is not set
+CONFIG_ESP_TASK_WDT_TIMEOUT_15N=y
+CONFIG_ESP_TASK_WDT_TIMEOUT_S=15
+# CONFIG_ESP_EVENT_LOOP_PROFILING is not set
+CONFIG_ESP_EVENT_POST_FROM_ISR=y
+CONFIG_ESP_HTTP_CLIENT_ENABLE_HTTPS=y
+# CONFIG_ESP_HTTP_CLIENT_ENABLE_BASIC_AUTH is not set
+CONFIG_HTTP_BUF_SIZE=512
+CONFIG_HTTPD_MAX_REQ_HDR_LEN=512
+CONFIG_HTTPD_MAX_URI_LEN=512
+CONFIG_OTA_BUF_SIZE=256
+# CONFIG_OTA_ALLOW_HTTP is not set
+# CONFIG_FATFS_CODEPAGE_DYNAMIC is not set
+CONFIG_FATFS_CODEPAGE_437=y
+# CONFIG_FATFS_CODEPAGE_720 is not set
+# CONFIG_FATFS_CODEPAGE_737 is not set
+# CONFIG_FATFS_CODEPAGE_771 is not set
+# CONFIG_FATFS_CODEPAGE_775 is not set
+# CONFIG_FATFS_CODEPAGE_850 is not set
+# CONFIG_FATFS_CODEPAGE_852 is not set
+# CONFIG_FATFS_CODEPAGE_855 is not set
+# CONFIG_FATFS_CODEPAGE_857 is not set
+# CONFIG_FATFS_CODEPAGE_860 is not set
+# CONFIG_FATFS_CODEPAGE_861 is not set
+# CONFIG_FATFS_CODEPAGE_862 is not set
+# CONFIG_FATFS_CODEPAGE_863 is not set
+# CONFIG_FATFS_CODEPAGE_864 is not set
+# CONFIG_FATFS_CODEPAGE_865 is not set
+# CONFIG_FATFS_CODEPAGE_866 is not set
+# CONFIG_FATFS_CODEPAGE_869 is not set
+# CONFIG_FATFS_CODEPAGE_932 is not set
+# CONFIG_FATFS_CODEPAGE_936 is not set
+# CONFIG_FATFS_CODEPAGE_949 is not set
+# CONFIG_FATFS_CODEPAGE_950 is not set
+CONFIG_FATFS_CODEPAGE=437
+CONFIG_FATFS_LFN_NONE=y
+# CONFIG_FATFS_LFN_HEAP is not set
+# CONFIG_FATFS_LFN_STACK is not set
+CONFIG_FATFS_FS_LOCK=0
+CONFIG_FATFS_TIMEOUT_MS=10000
+CONFIG_FATFS_PER_FILE_CACHE=y
+CONFIG_FMB_COMM_MODE_TCP_EN=y
+CONFIG_FMB_TCP_PORT_DEFAULT=502
+CONFIG_FMB_TCP_PORT_MAX_CONN=5
+CONFIG_FMB_TCP_CONNECTION_TOUT_SEC=20
+CONFIG_FMB_MASTER_TIMEOUT_MS_RESPOND=150
+CONFIG_FMB_MASTER_DELAY_MS_CONVERT=200
+CONFIG_FMB_QUEUE_LENGTH=20
+CONFIG_FMB_PORT_TASK_STACK_SIZE=4096
+CONFIG_FMB_SERIAL_BUF_SIZE=256
+CONFIG_FMB_PORT_TASK_PRIO=10
+CONFIG_FMB_CONTROLLER_SLAVE_ID_SUPPORT=y
+CONFIG_FMB_CONTROLLER_SLAVE_ID=0x00112233
+CONFIG_FMB_CONTROLLER_NOTIFY_TIMEOUT=20
+CONFIG_FMB_CONTROLLER_NOTIFY_QUEUE_SIZE=20
+CONFIG_FMB_CONTROLLER_STACK_SIZE=4096
+CONFIG_FMB_EVENT_QUEUE_TIMEOUT=20
+CONFIG_FMB_TIMER_GROUP=0
+CONFIG_FMB_TIMER_INDEX=0
+# CONFIG_FMB_TIMER_ISR_IN_IRAM is not set
+# CONFIG_DISABLE_FREERTOS is not set
+CONFIG_FREERTOS_UNICORE=y
+# CONFIG_FREERTOS_ENABLE_REENT is not set
+CONFIG_FREERTOS_NO_AFFINITY=0x7FFFFFFF
+CONFIG_FREERTOS_HZ=100
+CONFIG_FREERTOS_MAX_HOOK=2
+CONFIG_FREERTOS_IDLE_TASK_STACKSIZE=1024
+CONFIG_FREERTOS_ISR_STACKSIZE=512
+# CONFIG_FREERTOS_EXTENED_HOOKS is not set
+CONFIG_FREERTOS_GLOBAL_DATA_LINK_IRAM=y
+# CONFIG_FREERTOS_CODE_LINK_TO_IRAM is not set
+CONFIG_FREERTOS_TIMER_STACKSIZE=2048
+CONFIG_TASK_SWITCH_FASTER=y
+# CONFIG_USE_QUEUE_SETS is not set
+# CONFIG_ENABLE_FREERTOS_SLEEP is not set
+CONFIG_FREERTOS_USE_TRACE_FACILITY=y
+CONFIG_FREERTOS_USE_STATS_FORMATTING_FUNCTIONS=y
+CONFIG_FREERTOS_GENERATE_RUN_TIME_STATS=y
+CONFIG_FREERTOS_RUN_TIME_STATS_USING_ESP_TIMER=y
+# CONFIG_FREERTOS_RUN_TIME_STATS_USING_CPU_CLK is not set
+CONFIG_FREERTOS_WATCHPOINT_END_OF_STACK=y
+# CONFIG_HEAP_DISABLE_IRAM is not set
+# CONFIG_HEAP_TRACING is not set
+CONFIG_LIBSODIUM_USE_MBEDTLS_SHA=y
+# CONFIG_LOG_DEFAULT_LEVEL_NONE is not set
+# CONFIG_LOG_DEFAULT_LEVEL_ERROR is not set
+# CONFIG_LOG_DEFAULT_LEVEL_WARN is not set
+CONFIG_LOG_DEFAULT_LEVEL_INFO=y
+# CONFIG_LOG_DEFAULT_LEVEL_DEBUG is not set
+# CONFIG_LOG_DEFAULT_LEVEL_VERBOSE is not set
+CONFIG_LOG_DEFAULT_LEVEL=3
+CONFIG_LOG_COLORS=y
+# CONFIG_LOG_SET_LEVEL is not set
+CONFIG_LWIP_LOCAL_HOSTNAME="espressif"
+CONFIG_LWIP_DNS_SUPPORT_MDNS_QUERIES=y
+# CONFIG_LWIP_L2_TO_L3_COPY is not set
+# CONFIG_LWIP_IRAM_OPTIMIZATION is not set
+CONFIG_LWIP_TIMERS_ONDEMAND=y
+CONFIG_LWIP_MAX_SOCKETS=10
+# CONFIG_LWIP_USE_ONLY_LWIP_SELECT is not set
+# CONFIG_LWIP_SO_LINGER is not set
+CONFIG_LWIP_SO_REUSE=y
+CONFIG_LWIP_SO_REUSE_RXTOALL=y
+# CONFIG_LWIP_SO_RCVBUF is not set
+# CONFIG_LWIP_NETBUF_RECVINFO is not set
+CONFIG_LWIP_IP4_FRAG=y
+CONFIG_LWIP_IP6_FRAG=y
+# CONFIG_LWIP_IP4_REASSEMBLY is not set
+# CONFIG_LWIP_IP6_REASSEMBLY is not set
+# CONFIG_LWIP_IP_FORWARD is not set
+# CONFIG_LWIP_STATS is not set
+# CONFIG_LWIP_ETHARP_TRUST_IP_MAC is not set
+CONFIG_LWIP_ESP_GRATUITOUS_ARP=y
+CONFIG_LWIP_GARP_TMR_INTERVAL=60
+CONFIG_LWIP_TCPIP_RECVMBOX_SIZE=32
+CONFIG_LWIP_DHCP_DOES_ARP_CHECK=y
+# CONFIG_LWIP_DHCP_RESTORE_LAST_IP is not set
+CONFIG_LWIP_DHCPS_LEASE_UNIT=60
+CONFIG_LWIP_DHCPS_MAX_STATION_NUM=8
+# CONFIG_LWIP_AUTOIP is not set
+# CONFIG_LWIP_IPV6_AUTOCONFIG is not set
+CONFIG_LWIP_NETIF_LOOPBACK=y
+CONFIG_LWIP_LOOPBACK_MAX_PBUFS=8
+CONFIG_LWIP_MAX_ACTIVE_TCP=16
+CONFIG_LWIP_MAX_LISTENING_TCP=16
+CONFIG_LWIP_TCP_MAXRTX=12
+CONFIG_LWIP_TCP_SYNMAXRTX=6
+CONFIG_LWIP_TCP_MSS=1440
+CONFIG_LWIP_TCP_TMR_INTERVAL=250
+CONFIG_LWIP_TCP_MSL=60000
+CONFIG_LWIP_TCP_SND_BUF_DEFAULT=2880
+CONFIG_LWIP_TCP_WND_DEFAULT=5760
+CONFIG_LWIP_TCP_RECVMBOX_SIZE=6
+CONFIG_LWIP_TCP_QUEUE_OOSEQ=y
+# CONFIG_LWIP_TCP_SACK_OUT is not set
+# CONFIG_LWIP_TCP_KEEP_CONNECTION_WHEN_IP_CHANGES is not set
+CONFIG_LWIP_TCP_OVERSIZE_MSS=y
+# CONFIG_LWIP_TCP_OVERSIZE_QUARTER_MSS is not set
+# CONFIG_LWIP_TCP_OVERSIZE_DISABLE is not set
+CONFIG_LWIP_TCP_RTO_TIME=3000
+CONFIG_LWIP_MAX_UDP_PCBS=16
+CONFIG_LWIP_UDP_RECVMBOX_SIZE=6
+CONFIG_LWIP_TCPIP_TASK_STACK_SIZE=2048
+CONFIG_LWIP_TCPIP_TASK_AFFINITY_NO_AFFINITY=y
+# CONFIG_LWIP_TCPIP_TASK_AFFINITY_CPU0 is not set
+CONFIG_LWIP_TCPIP_TASK_AFFINITY=0x7FFFFFFF
+# CONFIG_LWIP_PPP_SUPPORT is not set
+CONFIG_LWIP_IPV6_MEMP_NUM_ND6_QUEUE=3
+CONFIG_LWIP_IPV6_ND6_NUM_NEIGHBORS=5
+# CONFIG_LWIP_MULTICAST_PING is not set
+# CONFIG_LWIP_BROADCAST_PING is not set
+CONFIG_LWIP_MAX_RAW_PCBS=16
+# CONFIG_LWIP_IPV6 is not set
+CONFIG_LWIP_DHCP_MAX_NTP_SERVERS=1
+CONFIG_LWIP_SNTP_UPDATE_DELAY=3600000
+CONFIG_LWIP_ESP_LWIP_ASSERT=y
+# CONFIG_LWIP_DEBUG is not set
+CONFIG_MBEDTLS_INTERNAL_MEM_ALLOC=y
+# CONFIG_MBEDTLS_DEFAULT_MEM_ALLOC is not set
+# CONFIG_MBEDTLS_CUSTOM_MEM_ALLOC is not set
+CONFIG_MBEDTLS_ASYMMETRIC_CONTENT_LEN=y
+CONFIG_MBEDTLS_SSL_IN_CONTENT_LEN=16384
+CONFIG_MBEDTLS_SSL_OUT_CONTENT_LEN=4096
+# CONFIG_MBEDTLS_DYNAMIC_BUFFER is not set
+# CONFIG_MBEDTLS_DEBUG is not set
+CONFIG_MBEDTLS_HAVE_TIME=y
+# CONFIG_MBEDTLS_HAVE_TIME_DATE is not set
+CONFIG_MBEDTLS_TLS_SERVER_AND_CLIENT=y
+# CONFIG_MBEDTLS_TLS_SERVER_ONLY is not set
+# CONFIG_MBEDTLS_TLS_CLIENT_ONLY is not set
+# CONFIG_MBEDTLS_TLS_DISABLED is not set
+CONFIG_MBEDTLS_TLS_SERVER=y
+CONFIG_MBEDTLS_TLS_CLIENT=y
+CONFIG_MBEDTLS_TLS_ENABLED=y
+# CONFIG_MBEDTLS_PSK_MODES is not set
+CONFIG_MBEDTLS_KEY_EXCHANGE_RSA=y
+CONFIG_MBEDTLS_KEY_EXCHANGE_DHE_RSA=y
+CONFIG_MBEDTLS_KEY_EXCHANGE_ELLIPTIC_CURVE=y
+CONFIG_MBEDTLS_KEY_EXCHANGE_ECDHE_RSA=y
+CONFIG_MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA=y
+CONFIG_MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA=y
+CONFIG_MBEDTLS_KEY_EXCHANGE_ECDH_RSA=y
+CONFIG_MBEDTLS_SSL_RENEGOTIATION=y
+# CONFIG_MBEDTLS_SSL_PROTO_SSL3 is not set
+CONFIG_MBEDTLS_SSL_PROTO_TLS1=y
+CONFIG_MBEDTLS_SSL_PROTO_TLS1_1=y
+CONFIG_MBEDTLS_SSL_PROTO_TLS1_2=y
+# CONFIG_MBEDTLS_SSL_PROTO_GMTSSL1_1 is not set
+# CONFIG_MBEDTLS_SSL_PROTO_DTLS is not set
+CONFIG_MBEDTLS_SSL_ALPN=y
+CONFIG_MBEDTLS_CLIENT_SSL_SESSION_TICKETS=y
+CONFIG_MBEDTLS_SERVER_SSL_SESSION_TICKETS=y
+CONFIG_MBEDTLS_AES_C=y
+# CONFIG_MBEDTLS_CAMELLIA_C is not set
+# CONFIG_MBEDTLS_DES_C is not set
+CONFIG_MBEDTLS_RC4_DISABLED=y
+# CONFIG_MBEDTLS_RC4_ENABLED_NO_DEFAULT is not set
+# CONFIG_MBEDTLS_RC4_ENABLED is not set
+# CONFIG_MBEDTLS_BLOWFISH_C is not set
+# CONFIG_MBEDTLS_XTEA_C is not set
+CONFIG_MBEDTLS_CCM_C=y
+CONFIG_MBEDTLS_GCM_C=y
+# CONFIG_MBEDTLS_RIPEMD160_C is not set
+CONFIG_MBEDTLS_PEM_PARSE_C=y
+CONFIG_MBEDTLS_PEM_WRITE_C=y
+CONFIG_MBEDTLS_X509_CRL_PARSE_C=y
+CONFIG_MBEDTLS_X509_CSR_PARSE_C=y
+CONFIG_MBEDTLS_ECP_C=y
+CONFIG_MBEDTLS_ECDH_C=y
+CONFIG_MBEDTLS_ECDSA_C=y
+CONFIG_MBEDTLS_ECP_DP_SECP192R1_ENABLED=y
+CONFIG_MBEDTLS_ECP_DP_SECP224R1_ENABLED=y
+CONFIG_MBEDTLS_ECP_DP_SECP256R1_ENABLED=y
+CONFIG_MBEDTLS_ECP_DP_SECP384R1_ENABLED=y
+CONFIG_MBEDTLS_ECP_DP_SECP521R1_ENABLED=y
+CONFIG_MBEDTLS_ECP_DP_SECP192K1_ENABLED=y
+CONFIG_MBEDTLS_ECP_DP_SECP224K1_ENABLED=y
+CONFIG_MBEDTLS_ECP_DP_SECP256K1_ENABLED=y
+CONFIG_MBEDTLS_ECP_DP_BP256R1_ENABLED=y
+CONFIG_MBEDTLS_ECP_DP_BP384R1_ENABLED=y
+CONFIG_MBEDTLS_ECP_DP_BP512R1_ENABLED=y
+CONFIG_MBEDTLS_ECP_DP_CURVE25519_ENABLED=y
+CONFIG_MBEDTLS_ECP_NIST_OPTIM=y
+# CONFIG_util_assert is not set
+# CONFIG_ESP_SHA is not set
+CONFIG_ESP_AES=y
+CONFIG_ESP_MD5=y
+CONFIG_ESP_ARC4=y
+# CONFIG_ENABLE_MDNS is not set
+CONFIG_MQTT_PROTOCOL_311=y
+CONFIG_MQTT_TRANSPORT_SSL=y
+CONFIG_MQTT_TRANSPORT_WEBSOCKET=y
+CONFIG_MQTT_TRANSPORT_WEBSOCKET_SECURE=y
+# CONFIG_MQTT_USE_CUSTOM_CONFIG is not set
+# CONFIG_MQTT_TASK_CORE_SELECTION_ENABLED is not set
+# CONFIG_MQTT_CUSTOM_OUTBOX is not set
+CONFIG_NEWLIB_STDOUT_LINE_ENDING_CRLF=y
+# CONFIG_NEWLIB_STDOUT_LINE_ENDING_LF is not set
+# CONFIG_NEWLIB_STDOUT_LINE_ENDING_CR is not set
+CONFIG_NEWLIB_NANO_FORMAT=y
+# CONFIG_OPENSSL_DEBUG is not set
+CONFIG_OPENSSL_ASSERT_DO_NOTHING=y
+# CONFIG_OPENSSL_ASSERT_EXIT is not set
+CONFIG_PTHREAD_TASK_PRIO_DEFAULT=5
+CONFIG_PTHREAD_TASK_STACK_SIZE_DEFAULT=3072
+CONFIG_PTHREAD_STACK_MIN=768
+CONFIG_PTHREAD_TASK_NAME_DEFAULT="pthread"
+CONFIG_SPIFFS_MAX_PARTITIONS=3
+CONFIG_SPIFFS_CACHE=y
+CONFIG_SPIFFS_CACHE_WR=y
+# CONFIG_SPIFFS_CACHE_STATS is not set
+CONFIG_SPIFFS_PAGE_CHECK=y
+CONFIG_SPIFFS_GC_MAX_RUNS=10
+# CONFIG_SPIFFS_GC_STATS is not set
+CONFIG_SPIFFS_PAGE_SIZE=256
+CONFIG_SPIFFS_OBJ_NAME_LEN=32
+CONFIG_SPIFFS_USE_MAGIC=y
+CONFIG_SPIFFS_USE_MAGIC_LENGTH=y
+CONFIG_SPIFFS_META_LENGTH=4
+CONFIG_SPIFFS_USE_MTIME=y
+# CONFIG_SPIFFS_DBG is not set
+# CONFIG_SPIFFS_API_DBG is not set
+# CONFIG_SPIFFS_GC_DBG is not set
+# CONFIG_SPIFFS_CACHE_DBG is not set
+# CONFIG_SPIFFS_CHECK_DBG is not set
+# CONFIG_SPIFFS_TEST_VISUALISATION is not set
+CONFIG_IP_LOST_TIMER_INTERVAL=120
+CONFIG_TCPIP_ADAPTER_GLOBAL_DATA_LINK_IRAM=y
+CONFIG_VFS_SUPPRESS_SELECT_DEBUG_OUTPUT=y
+CONFIG_VFS_SUPPORT_TERMIOS=y
+CONFIG_SEMIHOSTFS_MAX_MOUNT_POINTS=1
+CONFIG_SEMIHOSTFS_HOST_PATH_MAX_LEN=128
+# CONFIG_WL_SECTOR_SIZE_512 is not set
+CONFIG_WL_SECTOR_SIZE_4096=y
+CONFIG_WL_SECTOR_SIZE=4096
+# CONFIG_ENABLE_UNIFIED_PROVISIONING is not set
+CONFIG_LTM_FAST=y
+CONFIG_WPA_MBEDTLS_CRYPTO=y
+# CONFIG_WPA_DEBUG_PRINT is not set
+# CONFIG_WPA_TESTING_OPTIONS is not set
+# CONFIG_WPA_WPS_WARS is not set
+# CONFIG_WPA_11KV_SUPPORT is not set
+
+# Deprecated options for backward compatibility
+CONFIG_TARGET_PLATFORM="esp8266"
+CONFIG_TOOLPREFIX="xtensa-lx106-elf-"
+# CONFIG_MAKE_WARN_UNDEFINED_VARIABLES is not set
+CONFIG_FLASHMODE_QIO=y
+# CONFIG_FLASHMODE_QOUT is not set
+# CONFIG_FLASHMODE_DIO is not set
+# CONFIG_FLASHMODE_DOUT is not set
+# CONFIG_MONITOR_BAUD_9600B is not set
+# CONFIG_MONITOR_BAUD_57600B is not set
+CONFIG_MONITOR_BAUD_74880B=y
+# CONFIG_MONITOR_BAUD_115200B is not set
+# CONFIG_MONITOR_BAUD_230400B is not set
+# CONFIG_MONITOR_BAUD_921600B is not set
+# CONFIG_MONITOR_BAUD_2MB is not set
+# CONFIG_MONITOR_BAUD_OTHER is not set
+CONFIG_MONITOR_BAUD_OTHER_VAL=74880
+CONFIG_MONITOR_BAUD=74880
+CONFIG_OPTIMIZATION_LEVEL_DEBUG=y
+# CONFIG_OPTIMIZATION_LEVEL_RELEASE is not set
+CONFIG_OPTIMIZATION_ASSERTIONS_ENABLED=y
+# CONFIG_OPTIMIZATION_ASSERTIONS_SILENT is not set
+# CONFIG_OPTIMIZATION_ASSERTIONS_DISABLED is not set
+# CONFIG_CXX_EXCEPTIONS is not set
+CONFIG_STACK_CHECK_NONE=y
+# CONFIG_STACK_CHECK_NORM is not set
+# CONFIG_STACK_CHECK_STRONG is not set
+# CONFIG_STACK_CHECK_ALL is not set
+# CONFIG_STACK_CHECK is not set
+# CONFIG_WARN_WRITE_STRINGS is not set
+CONFIG_MAIN_TASK_STACK_SIZE=3584
+CONFIG_CONSOLE_UART_DEFAULT=y
+# CONFIG_CONSOLE_UART_CUSTOM is not set
+# CONFIG_CONSOLE_UART_NONE is not set
+CONFIG_CONSOLE_UART_NUM=0
+CONFIG_CONSOLE_UART_BAUDRATE=74880
+# CONFIG_UART0_SWAP_IO is not set
+CONFIG_TASK_WDT=y
+CONFIG_TASK_WDT_PANIC=y
+CONFIG_TASK_WDT_TIMEOUT_S=15
+CONFIG_MB_MASTER_TIMEOUT_MS_RESPOND=150
+CONFIG_MB_MASTER_DELAY_MS_CONVERT=200
+CONFIG_MB_QUEUE_LENGTH=20
+CONFIG_MB_SERIAL_TASK_STACK_SIZE=4096
+CONFIG_MB_SERIAL_BUF_SIZE=256
+CONFIG_MB_SERIAL_TASK_PRIO=10
+CONFIG_MB_CONTROLLER_SLAVE_ID_SUPPORT=y
+CONFIG_MB_CONTROLLER_SLAVE_ID=0x00112233
+CONFIG_MB_CONTROLLER_NOTIFY_TIMEOUT=20
+CONFIG_MB_CONTROLLER_NOTIFY_QUEUE_SIZE=20
+CONFIG_MB_CONTROLLER_STACK_SIZE=4096
+CONFIG_MB_EVENT_QUEUE_TIMEOUT=20
+CONFIG_MB_TIMER_GROUP=0
+CONFIG_MB_TIMER_INDEX=0
+# CONFIG_L2_TO_L3_COPY is not set
+# CONFIG_USE_ONLY_LWIP_SELECT is not set
+CONFIG_ESP_GRATUITOUS_ARP=y
+CONFIG_GARP_TMR_INTERVAL=60
+CONFIG_TCPIP_RECVMBOX_SIZE=32
+CONFIG_TCP_MAXRTX=12
+CONFIG_TCP_SYNMAXRTX=6
+CONFIG_TCP_MSS=1440
+CONFIG_TCP_MSL=60000
+CONFIG_TCP_SND_BUF_DEFAULT=2880
+CONFIG_TCP_WND_DEFAULT=5760
+CONFIG_TCP_RECVMBOX_SIZE=6
+CONFIG_TCP_QUEUE_OOSEQ=y
+# CONFIG_ESP_TCP_KEEP_CONNECTION_WHEN_IP_CHANGES is not set
+CONFIG_TCP_OVERSIZE_MSS=y
+# CONFIG_TCP_OVERSIZE_QUARTER_MSS is not set
+# CONFIG_TCP_OVERSIZE_DISABLE is not set
+CONFIG_UDP_RECVMBOX_SIZE=6
+CONFIG_TCPIP_TASK_STACK_SIZE=2048
+CONFIG_TCPIP_TASK_AFFINITY_NO_AFFINITY=y
+# CONFIG_TCPIP_TASK_AFFINITY_CPU0 is not set
+CONFIG_TCPIP_TASK_AFFINITY=0x7FFFFFFF
+# CONFIG_PPP_SUPPORT is not set
+CONFIG_ESP32_PTHREAD_TASK_PRIO_DEFAULT=5
+CONFIG_ESP32_PTHREAD_TASK_STACK_SIZE_DEFAULT=3072
+CONFIG_ESP32_PTHREAD_STACK_MIN=768
+CONFIG_ESP32_PTHREAD_TASK_NAME_DEFAULT="pthread"
+CONFIG_SUPPRESS_SELECT_DEBUG_OUTPUT=y
+CONFIG_SUPPORT_TERMIOS=y
+# End of deprecated options