diff --git a/examples/ds18b20_broadcaster/Makefile b/examples/ds18b20_broadcaster/Makefile
new file mode 100644
index 0000000..833c3e7
--- /dev/null
+++ b/examples/ds18b20_broadcaster/Makefile
@@ -0,0 +1,3 @@
+PROGRAM=ds18b20_broadcaster
+EXTRA_COMPONENTS = extras/onewire extras/ds18b20
+include ../../common.mk
diff --git a/examples/ds18b20_broadcaster/README.md b/examples/ds18b20_broadcaster/README.md
new file mode 100644
index 0000000..75029bf
--- /dev/null
+++ b/examples/ds18b20_broadcaster/README.md
@@ -0,0 +1,20 @@
+# DS19B20 Broadcaster
+
+>In this example you can see how to get data from multiple 
+>ds18b20 sensor and emit result over udb broadcaster address.
+
+As a client server, you can use this simple udp receiver, writen in python:
+
+```
+import select, socket
+
+s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+s.bind(('<broadcast>', 8005))
+s.setblocking(0)
+
+while True:
+    result = select.select([s],[],[])
+    msg = result[0][0].recv(1024)
+    print msg.strip()
+
+```
\ No newline at end of file
diff --git a/examples/ds18b20_broadcaster/ds18b20_broadcaster.c b/examples/ds18b20_broadcaster/ds18b20_broadcaster.c
new file mode 100644
index 0000000..fe12055
--- /dev/null
+++ b/examples/ds18b20_broadcaster/ds18b20_broadcaster.c
@@ -0,0 +1,128 @@
+/*
+ * This is example of udp broadcaster.
+ * It grab data from ds18b20 sensor and emit result over wifi.
+ *
+ * Author Grzegorz Hetman : ghetman@gmail.com
+ * License public domain/CC0
+ */
+
+#include <string.h>
+
+#include "espressif/esp_common.h"
+#include "esp/uart.h"
+#include "FreeRTOS.h"
+#include "task.h"
+#include "timers.h"
+#include "queue.h"
+#include "lwip/api.h"
+#include "ssid_config.h"
+
+// DS18B20 driver
+#include "ds18b20/ds18b20.h"
+// Onewire init
+#include "onewire/onewire.h"
+
+void broadcast_temperature(void *pvParameters)
+{
+
+    uint8_t amount = 0;
+    uint8_t sensors = 2;
+    ds_sensor_t t[sensors];
+    
+    // Use GPIO 13 as one wire pin. 
+    uint8_t GPIO_FOR_ONE_WIRE = 13;
+
+    char msg[100];
+
+    // Broadcaster part
+    err_t err;
+    // Initialize one wire bus.
+    onewire_init(GPIO_FOR_ONE_WIRE);
+
+    while(1) {
+
+        // Send out some UDP data
+        struct netconn* conn;
+
+        // Create UDP connection
+        conn = netconn_new(NETCONN_UDP);
+
+        // Connect to local port
+        err = netconn_bind(conn, IP_ADDR_ANY, 8004);
+
+        if (err != ERR_OK) {
+            netconn_delete(conn);
+            printf("%s : Could not bind! (%s)\n", __FUNCTION__, lwip_strerr(err));
+            continue;
+        }
+
+        err = netconn_connect(conn, IP_ADDR_BROADCAST, 8005);
+
+        if (err != ERR_OK) {
+            netconn_delete(conn);
+            printf("%s : Could not connect! (%s)\n", __FUNCTION__, lwip_strerr(err));
+            continue;
+        }
+
+        for(;;) {
+            // Search all DS18B20, return its amount and feed 't' structure with result data.
+            amount = ds18b20_read_all(GPIO_FOR_ONE_WIRE, t);
+
+            if (amount < sensors){
+                printf("Something is wrong, I expect to see %d sensors \nbut just %d was detected!\n", sensors, amount);
+            }
+
+            for (int i = 0; i < amount; ++i)
+            {
+                int intpart = (int)t[i].value;
+                int fraction = (int)((t[i].value - intpart) * 100);
+                // Multiple "" here is just to satisfy compiler and don`t raise 'hex escape sequence out of range' warning.
+                sprintf(msg, "Sensor %d report: %d.%02d ""\xC2""\xB0""C\n",t[i].id, intpart, fraction);
+                printf("%s", msg);
+
+                struct netbuf* buf = netbuf_new();
+                void* data = netbuf_alloc(buf, strlen(msg));
+
+                memcpy (data, msg, strlen(msg));
+                err = netconn_send(conn, buf);
+
+                if (err != ERR_OK) {
+                    printf("%s : Could not send data!!! (%s)\n", __FUNCTION__, lwip_strerr(err));
+                    continue;
+                }
+                netbuf_delete(buf); // De-allocate packet buffer
+            }
+            vTaskDelay(1000/portTICK_RATE_MS);
+        }
+
+        err = netconn_disconnect(conn);
+        printf("%s : Disconnected from IP_ADDR_BROADCAST port 12346 (%s)\n", __FUNCTION__, lwip_strerr(err));
+
+        err = netconn_delete(conn);
+        printf("%s : Deleted connection (%s)\n", __FUNCTION__, lwip_strerr(err));
+
+        vTaskDelay(1000/portTICK_RATE_MS);
+    }
+}
+
+void user_init(void)
+{
+    uart_set_baud(0, 115200);
+
+    printf("SDK version:%s\n", sdk_system_get_sdk_version());
+
+    // Set led to indicate wifi status.
+    sdk_wifi_status_led_install(2, PERIPHS_IO_MUX_GPIO2_U, FUNC_GPIO2);
+
+    struct sdk_station_config config = {
+        .ssid = WIFI_SSID,
+        .password = WIFI_PASS,
+    };
+
+    // Required to call wifi_set_opmode before station_set_config.
+    sdk_wifi_set_opmode(STATION_MODE);
+    sdk_wifi_station_set_config(&config);
+
+    xTaskCreate(&broadcast_temperature, (signed char *)"broadcast_temperature", 256, NULL, 2, NULL);
+}
+
diff --git a/examples/ds18b20_onewire/Makefile b/examples/ds18b20_onewire/Makefile
new file mode 100644
index 0000000..c856e7e
--- /dev/null
+++ b/examples/ds18b20_onewire/Makefile
@@ -0,0 +1,3 @@
+PROGRAM=ds18b20_onewire
+EXTRA_COMPONENTS = extras/onewire extras/ds18b20
+include ../../common.mk
diff --git a/examples/ds18b20_onewire/ds18b20_onewire.c b/examples/ds18b20_onewire/ds18b20_onewire.c
new file mode 100644
index 0000000..78d13bf
--- /dev/null
+++ b/examples/ds18b20_onewire/ds18b20_onewire.c
@@ -0,0 +1,59 @@
+/* ds18b20 - Retrieves temperature from ds18b20 sensors and print it out.
+ *
+ * This sample code is in the public domain.,
+ */
+#include "espressif/esp_common.h"
+#include "esp/uart.h"
+
+#include "FreeRTOS.h"
+#include "task.h"
+#include "timers.h"
+#include "queue.h"
+
+// DS18B20 driver
+#include "ds18b20/ds18b20.h"
+// Onewire init
+#include "onewire/onewire.h"
+ 
+void print_temperature(void *pvParameters)
+{
+    int delay = 500;
+    uint8_t amount = 0;
+    // Declare amount of sensors
+    uint8_t sensors = 2;
+    ds_sensor_t t[sensors];
+    
+    // Use GPIO 13 as one wire pin. 
+    uint8_t GPIO_FOR_ONE_WIRE = 13;
+    
+    onewire_init(GPIO_FOR_ONE_WIRE);
+    
+    while(1) {
+        // Search all DS18B20, return its amount and feed 't' structure with result data.
+        amount = ds18b20_read_all(GPIO_FOR_ONE_WIRE, t);
+
+        if (amount < sensors){
+            printf("Something is wrong, I expect to see %d sensors \nbut just %d was detected!\n", sensors, amount);
+        }
+
+        for (int i = 0; i < amount; ++i)
+        {
+            int intpart = (int)t[i].value;
+            int fraction = (int)((t[i].value - intpart) * 100);
+            // Multiple "" here is just to satisfy compiler and don`t raise 'hex escape sequence out of range' warning.
+            printf("Sensor %d report: %d.%02d ""\xC2""\xB0""C\n",t[i].id, intpart, fraction);
+        }
+        printf("\n");
+        vTaskDelay(delay / portTICK_RATE_MS);
+    }
+}
+
+void user_init(void)
+{
+    uart_set_baud(0, 115200);
+
+    printf("SDK version:%s\n", sdk_system_get_sdk_version());
+
+    xTaskCreate(&print_temperature, (signed char *)"print_temperature", 256, NULL, 2, NULL);
+}
+
diff --git a/extras/ds18b20/component.mk b/extras/ds18b20/component.mk
new file mode 100644
index 0000000..866371c
--- /dev/null
+++ b/extras/ds18b20/component.mk
@@ -0,0 +1,9 @@
+# Component makefile for extras/ds18b20
+
+# expected anyone using bmp driver includes it as 'ds18b20/ds18b20.h'
+INC_DIRS += $(ds18b20_ROOT)..
+
+# args for passing into compile rule generation
+ds18b20_SRC_DIR =  $(ds18b20_ROOT)
+
+$(eval $(call component_compile_rules,ds18b20))
diff --git a/extras/ds18b20/ds18b20.c b/extras/ds18b20/ds18b20.c
new file mode 100644
index 0000000..cb4a1d1
--- /dev/null
+++ b/extras/ds18b20/ds18b20.c
@@ -0,0 +1,103 @@
+#include "onewire/onewire.h"
+#include "ds18b20.h"
+
+#define DS1820_WRITE_SCRATCHPAD 0x4E
+#define DS1820_READ_SCRATCHPAD  0xBE
+#define DS1820_COPY_SCRATCHPAD  0x48
+#define DS1820_READ_EEPROM      0xB8
+#define DS1820_READ_PWRSUPPLY   0xB4
+#define DS1820_SEARCHROM        0xF0
+#define DS1820_SKIP_ROM         0xCC
+#define DS1820_READROM          0x33
+#define DS1820_MATCHROM         0x55
+#define DS1820_ALARMSEARCH      0xEC
+#define DS1820_CONVERT_T        0x44
+
+uint8_t ds18b20_read_all(uint8_t pin, ds_sensor_t *result) {
+    
+    uint8_t addr[8];
+    uint8_t sensor_id = 0;
+    onewire_reset_search(pin);
+    
+    while(onewire_search(pin, addr)){
+        uint8_t crc = onewire_crc8(addr, 7);
+        if (crc != addr[7]){
+            printf("CRC check failed: %02X %02X\n", addr[7], crc);
+            return 0;
+        }
+
+        onewire_reset(pin);
+        onewire_select(pin, addr);
+        onewire_write(pin, DS1820_CONVERT_T, ONEWIRE_DEFAULT_POWER);
+        sdk_os_delay_us(750);
+        onewire_reset(pin);
+        onewire_select(pin, addr);
+        onewire_write(pin, DS1820_READ_SCRATCHPAD, ONEWIRE_DEFAULT_POWER);
+
+        uint8_t get[10];
+
+        for (int k=0;k<9;k++){
+            get[k]=onewire_read(pin);
+        }
+        
+        //printf("\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]){
+            printf("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;
+        //printf("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_write(pin, DS1820_SKIP_ROM, ONEWIRE_DEFAULT_POWER);
+    onewire_write(pin, DS1820_CONVERT_T, ONEWIRE_DEFAULT_POWER);
+
+    sdk_os_delay_us(750);
+
+    onewire_reset(pin);
+    onewire_write(pin, DS1820_SKIP_ROM, ONEWIRE_DEFAULT_POWER);
+    onewire_write(pin, DS1820_READ_SCRATCHPAD, ONEWIRE_DEFAULT_POWER);
+    
+    uint8_t get[10];
+
+    for (int k=0;k<9;k++){
+        get[k]=onewire_read(pin);
+    }
+    
+    //printf("\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]){
+        printf("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;
+    //printf("Got a DS18B20 Reading: %d.%02d\n", (int)temperature, (int)(temperature - (int)temperature) * 100);
+}
diff --git a/extras/ds18b20/ds18b20.h b/extras/ds18b20/ds18b20.h
new file mode 100644
index 0000000..594227b
--- /dev/null
+++ b/extras/ds18b20/ds18b20.h
@@ -0,0 +1,17 @@
+#ifndef DRIVER_DS18B20_H_
+#define DRIVER_DS18B20_H_
+
+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);
+
+#endif
diff --git a/extras/onewire/LICENSE b/extras/onewire/LICENSE
new file mode 100644
index 0000000..c5a152a
--- /dev/null
+++ b/extras/onewire/LICENSE
@@ -0,0 +1,31 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 zeroday nodemcu.com
+
+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.
+
+-------------------------------------------------------------------------------
+
+Portions copyright (C) 2000 Dallas Semiconductor Corporation, under the
+following additional terms:
+
+Except as contained in this notice, the name of Dallas Semiconductor
+shall not be used except as stated in the Dallas Semiconductor
+Branding Policy.
+
diff --git a/extras/onewire/README.md b/extras/onewire/README.md
new file mode 100644
index 0000000..e490b9a
--- /dev/null
+++ b/extras/onewire/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.
diff --git a/extras/onewire/component.mk b/extras/onewire/component.mk
new file mode 100644
index 0000000..c453b58
--- /dev/null
+++ b/extras/onewire/component.mk
@@ -0,0 +1,10 @@
+# Component makefile for extras/onewire
+
+# expected anyone using onewire driver includes it as 'onewire/onewire.h'
+INC_DIRS += $(onewire_ROOT)..
+
+# args for passing into compile rule generation
+onewire_INC_DIR =
+onewire_SRC_DIR = $(onewire_ROOT)
+
+$(eval $(call component_compile_rules,onewire))
diff --git a/extras/onewire/onewire.c b/extras/onewire/onewire.c
new file mode 100644
index 0000000..3a946ba
--- /dev/null
+++ b/extras/onewire/onewire.c
@@ -0,0 +1,466 @@
+#include "onewire.h"
+
+// global search state
+static unsigned char ROM_NO[ONEWIRE_NUM][8];
+static uint8_t LastDiscrepancy[ONEWIRE_NUM];
+static uint8_t LastFamilyDiscrepancy[ONEWIRE_NUM];
+static uint8_t LastDeviceFlag[ONEWIRE_NUM];
+
+void onewire_init(uint8_t pin)
+{
+  gpio_enable(pin, GPIO_INPUT);  
+  onewire_reset_search(pin);
+}
+
+// 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 a 0;
+//
+// Returns 1 if a device asserted a presence pulse, 0 otherwise.
+//
+uint8_t onewire_reset(uint8_t pin)
+{
+	uint8_t r;
+	uint8_t retries = 125;
+
+	noInterrupts();
+	DIRECT_MODE_INPUT(pin);
+	interrupts();
+	// wait until the wire is high... just in case
+	do {
+		if (--retries == 0) return 0;
+		delayMicroseconds(2);
+	} while ( !DIRECT_READ(pin));
+
+	noInterrupts();
+	DIRECT_WRITE_LOW(pin);
+	DIRECT_MODE_OUTPUT(pin);	// drive output low
+	interrupts();
+	delayMicroseconds(480);
+	noInterrupts();
+	DIRECT_MODE_INPUT(pin);	// allow it to float
+	delayMicroseconds(70);
+	r = !DIRECT_READ(pin);
+	interrupts();
+	delayMicroseconds(410);
+	return r;
+}
+
+// Write a bit. Port and bit is used to cut lookup time and provide
+// more certain timing.
+//
+static void onewire_write_bit(uint8_t pin, uint8_t v)
+{
+	if (v & 1) {
+		noInterrupts();
+		DIRECT_WRITE_LOW(pin);
+		DIRECT_MODE_OUTPUT(pin);	// drive output low
+		delayMicroseconds(10);
+		DIRECT_WRITE_HIGH(pin);	// drive output high
+		interrupts();
+		delayMicroseconds(55);
+	} else {
+		noInterrupts();
+		DIRECT_WRITE_LOW(pin);
+		DIRECT_MODE_OUTPUT(pin);	// drive output low
+		delayMicroseconds(65);
+		DIRECT_WRITE_HIGH(pin);	// drive output high
+		interrupts();
+		delayMicroseconds(5);
+	}
+}
+
+// Read a bit. Port and bit is used to cut lookup time and provide
+// more certain timing.
+//
+static uint8_t onewire_read_bit(uint8_t pin)
+{
+	uint8_t r;
+
+	noInterrupts();
+	DIRECT_MODE_OUTPUT(pin);
+	DIRECT_WRITE_LOW(pin);
+	delayMicroseconds(3);
+	DIRECT_MODE_INPUT(pin);	// let pin float, pull up will raise
+	delayMicroseconds(10);
+	r = DIRECT_READ(pin);
+	interrupts();
+	delayMicroseconds(53);
+	return r;
+}
+
+// Write a byte. The writing code uses the active drivers to raise the
+// pin high, if you need power after the write (e.g. DS18S20 in
+// parasite power mode) then set 'power' to 1, otherwise the pin will
+// go tri-state at the end of the write to avoid heating in a short or
+// other mishap.
+//
+void onewire_write(uint8_t pin, uint8_t v, uint8_t power /* = 0 */) {
+  uint8_t bitMask;
+
+  for (bitMask = 0x01; bitMask; bitMask <<= 1) {
+	  onewire_write_bit(pin, (bitMask & v)?1:0);
+  }
+  if ( !power) {
+  	noInterrupts();
+  	DIRECT_MODE_INPUT(pin);
+  	DIRECT_WRITE_LOW(pin);
+  	interrupts();
+  }
+}
+
+void onewire_write_bytes(uint8_t pin, const uint8_t *buf, uint16_t count, bool power /* = 0 */) {
+  uint16_t i;
+  for (i = 0 ; i < count ; i++)
+    onewire_write(pin, buf[i], ONEWIRE_DEFAULT_POWER);
+  if (!power) {
+    noInterrupts();
+    DIRECT_MODE_INPUT(pin);
+    DIRECT_WRITE_LOW(pin);
+    interrupts();
+  }
+}
+
+// Read a byte
+//
+uint8_t onewire_read(uint8_t pin) {
+  uint8_t bitMask;
+  uint8_t r = 0;
+
+  for (bitMask = 0x01; bitMask; bitMask <<= 1) {
+  	if (onewire_read_bit(pin)) r |= bitMask;
+  }
+  return r;
+}
+
+void onewire_read_bytes(uint8_t pin, uint8_t *buf, uint16_t count) {
+  uint16_t i;
+  for (i = 0 ; i < count ; i++)
+    buf[i] = onewire_read(pin);
+}
+
+// Do a ROM select
+//
+void onewire_select(uint8_t pin, const uint8_t rom[8])
+{
+    uint8_t i;
+
+    onewire_write(pin, 0x55, ONEWIRE_DEFAULT_POWER);           // Choose ROM
+
+    for (i = 0; i < 8; i++) onewire_write(pin, rom[i], ONEWIRE_DEFAULT_POWER);
+}
+
+// Do a ROM skip
+//
+void onewire_skip(uint8_t pin)
+{
+    onewire_write(pin, 0xCC, ONEWIRE_DEFAULT_POWER);           // Skip ROM
+}
+
+void onewire_depower(uint8_t pin)
+{
+	noInterrupts();
+	DIRECT_MODE_INPUT(pin);
+	interrupts();
+}
+
+// You need to use this function to start a search again from the beginning.
+// You do not need to do it for the first search, though you could.
+//
+void onewire_reset_search(uint8_t pin)
+{
+  // reset the search state
+  LastDiscrepancy[pin] = 0;
+  LastDeviceFlag[pin] = 0;
+  LastFamilyDiscrepancy[pin] = 0;
+  int i;
+  for(i = 7; ; i--) {
+    ROM_NO[pin][i] = 0;
+    if ( i == 0) break;
+  }
+}
+
+// Setup the search to find the device type 'family_code' on the next call
+// to search(*newAddr) if it is present.
+//
+void onewire_target_search(uint8_t pin, uint8_t family_code)
+{
+   // set the search state to find SearchFamily type devices
+   ROM_NO[pin][0] = family_code;
+   uint8_t i;
+   for (i = 1; i < 8; i++)
+      ROM_NO[pin][i] = 0;
+   LastDiscrepancy[pin] = 64;
+   LastFamilyDiscrepancy[pin] = 0;
+   LastDeviceFlag[pin] = 0;
+}
+
+// Perform a search. If this function returns a '1' then it has
+// enumerated the next device and you may retrieve the ROM from the
+// OneWire::address variable. If there are no devices, no further
+// devices, or something horrible happens in the middle of the
+// enumeration then a 0 is returned.  If a new device is found then
+// its address is copied to newAddr.  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
+//
+uint8_t onewire_search(uint8_t pin, uint8_t *newAddr)
+{
+   uint8_t id_bit_number;
+   uint8_t last_zero, rom_byte_number, search_result;
+   uint8_t id_bit, cmp_id_bit;
+
+   unsigned char rom_byte_mask, 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 (!LastDeviceFlag[pin])
+   {
+      // 1-Wire reset
+      if (!onewire_reset(pin))
+      {
+         // reset the search
+         LastDiscrepancy[pin] = 0;
+         LastDeviceFlag[pin] = 0;
+         LastFamilyDiscrepancy[pin] = 0;
+         return 0;
+      }
+
+      // issue the search command
+      onewire_write(pin, 0xF0, ONEWIRE_DEFAULT_POWER);
+
+      // 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 == 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 < LastDiscrepancy[pin])
+                  search_direction = ((ROM_NO[pin][rom_byte_number] & rom_byte_mask) > 0);
+               else
+                  // if equal to last pick 1, if not then pick 0
+                  search_direction = (id_bit_number == LastDiscrepancy[pin]);
+
+               // if 0 was picked then record its position in LastZero
+               if (search_direction == 0)
+               {
+                  last_zero = id_bit_number;
+
+                  // check for Last discrepancy in family
+                  if (last_zero < 9)
+                     LastFamilyDiscrepancy[pin] = last_zero;
+               }
+            }
+
+            // set or clear the bit in the ROM byte rom_byte_number
+            // with mask rom_byte_mask
+            if (search_direction == 1)
+              ROM_NO[pin][rom_byte_number] |= rom_byte_mask;
+            else
+              ROM_NO[pin][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 LastDiscrepancy,LastDeviceFlag,search_result
+         LastDiscrepancy[pin] = last_zero;
+
+         // check for last device
+         if (LastDiscrepancy[pin] == 0)
+            LastDeviceFlag[pin] = 1;
+
+         search_result = 1;
+      }
+   }
+
+   // if no device found then reset counters so next 'search' will be like a first
+   if (!search_result || !ROM_NO[pin][0])
+   {
+      LastDiscrepancy[pin] = 0;
+      LastDeviceFlag[pin] = 0;
+      LastFamilyDiscrepancy[pin] = 0;
+      search_result = 0;
+   }
+   else
+   {
+      for (rom_byte_number = 0; rom_byte_number < 8; rom_byte_number++)
+      {
+         newAddr[rom_byte_number] = ROM_NO[pin][rom_byte_number];
+         //printf("Ok I found something at %d - %x...\n",rom_byte_number, newAddr[rom_byte_number]);
+      }
+   }
+   return search_result;
+}
+
+// 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 *addr, uint8_t len)
+{
+	uint8_t crc = 0;
+
+	while (len--) {
+		crc = pgm_read_byte(dscrc_table + (crc ^ *addr++));
+	}
+	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 *addr, uint8_t len)
+{
+	uint8_t crc = 0;
+	
+	while (len--) {
+		uint8_t inbyte = *addr++;
+    uint8_t i;
+		for (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, uint16_t len, const uint8_t* inverted_crc, uint16_t crc)
+{
+    crc = ~onewire_crc16(input, len, crc);
+    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, uint16_t len, uint16_t crc)
+{
+    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;
+}
\ No newline at end of file
diff --git a/extras/onewire/onewire.h b/extras/onewire/onewire.h
new file mode 100644
index 0000000..1a0b15d
--- /dev/null
+++ b/extras/onewire/onewire.h
@@ -0,0 +1,138 @@
+#ifndef __ONEWIRE_H__
+#define __ONEWIRE_H__
+
+#include <espressif/esp_misc.h> // sdk_os_delay_us
+#include "FreeRTOS.h"
+
+// 1 for keeping the parasitic power on H
+#define ONEWIRE_DEFAULT_POWER 1
+
+// Maximum number of devices.
+#define ONEWIRE_NUM 20
+
+// You can exclude certain features from OneWire.  In theory, this
+// might save some space.  In practice, the compiler automatically
+// removes unused code (technically, the linker, using -fdata-sections
+// and -ffunction-sections when compiling, and Wl,--gc-sections
+// when linking), so most of these will not result in any code size
+// reduction.  Well, unless you try to use the missing features
+// and redesign your program to not need them!  ONEWIRE_CRC8_TABLE
+// is the exception, because it selects a fast but large algorithm
+// or a small but slow algorithm.
+
+// Select the table-lookup method of computing the 8-bit CRC
+// by setting this to 1.  The lookup table enlarges code size by
+// about 250 bytes.  It does NOT consume RAM (but did in very
+// old versions of OneWire).  If you disable this, a slower
+// but very compact algorithm is used.
+#ifndef ONEWIRE_CRC8_TABLE
+#define ONEWIRE_CRC8_TABLE 0
+#endif
+
+// Platform specific I/O definitions
+#define noInterrupts portDISABLE_INTERRUPTS
+#define interrupts portENABLE_INTERRUPTS
+#define delayMicroseconds sdk_os_delay_us
+
+#define DIRECT_READ(pin)         gpio_read(pin)
+#define DIRECT_MODE_INPUT(pin)   gpio_enable(pin, GPIO_INPUT)
+#define DIRECT_MODE_OUTPUT(pin)  gpio_enable(pin, GPIO_OUTPUT)
+#define DIRECT_WRITE_LOW(pin)    gpio_write(pin, 0)
+#define DIRECT_WRITE_HIGH(pin)   gpio_write(pin, 1)
+
+void onewire_init(uint8_t pin);
+
+// Perform a 1-Wire reset cycle. Returns 1 if a device responds
+// with a presence pulse.  Returns 0 if there is no device or the
+// bus is shorted or otherwise held low for more than 250uS
+uint8_t onewire_reset(uint8_t pin);
+
+// Issue a 1-Wire rom select command, you do the reset first.
+void onewire_select(uint8_t pin, const uint8_t rom[8]);
+
+// Issue a 1-Wire rom skip command, to address all on bus.
+void onewire_skip(uint8_t pin);
+
+// Write a byte. If 'power' is one then the wire is held high at
+// the end for parasitically powered devices. You are responsible
+// for eventually depowering it by calling depower() or doing
+// another read or write.
+void onewire_write(uint8_t pin, uint8_t v, uint8_t power);
+
+void onewire_write_bytes(uint8_t pin, const uint8_t *buf, uint16_t count, bool power);
+
+// Read a byte.
+uint8_t onewire_read(uint8_t pin);
+
+void onewire_read_bytes(uint8_t pin, uint8_t *buf, uint16_t count);
+
+// Write a bit. The bus is always left powered at the end, see
+// note in write() about that.
+// void onewire_write_bit(uint8_t pin, uint8_t v);
+
+// Read a bit.
+// uint8_t onewire_read_bit(uint8_t pin);
+
+// Stop forcing power onto the bus. You only need to do this if
+// you used the 'power' flag to write() or used a write_bit() call
+// and aren't about to do another read or write. You would rather
+// not leave this powered if you don't have to, just in case
+// someone shorts your bus.
+void onewire_depower(uint8_t pin);
+
+// Clear the search state so that if will start from the beginning again.
+void onewire_reset_search(uint8_t pin);
+
+// Setup the search to find the device type 'family_code' on the next call
+// to search(*newAddr) if it is present.
+void onewire_target_search(uint8_t pin, uint8_t family_code);
+
+// Look for the next device. Returns 1 if a new address has been
+// returned. A zero might 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.  The order is deterministic. You will always get
+// the same devices in the same order.
+uint8_t onewire_search(uint8_t pin, uint8_t *newAddr);
+
+// Compute a Dallas Semiconductor 8 bit CRC, these are used in the
+// ROM and scratchpad registers.
+uint8_t onewire_crc8(const uint8_t *addr, uint8_t len);
+
+// 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 True, iff the CRC matches.
+bool onewire_check_crc16(const uint8_t* input, uint16_t len, const uint8_t* inverted_crc, uint16_t crc);
+
+// 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, uint16_t len, uint16_t crc);
+
+#endif