diff --git a/MicroPython_BUILD/components/micropython/esp32/machine_uart.c b/MicroPython_BUILD/components/micropython/esp32/machine_uart.c
index 5ca5b7a..4fb813c 100644
--- a/MicroPython_BUILD/components/micropython/esp32/machine_uart.c
+++ b/MicroPython_BUILD/components/micropython/esp32/machine_uart.c
@@ -42,42 +42,111 @@
 #define UART_CB_TYPE_DATA		1
 #define UART_CB_TYPE_PATTERN	2
 #define UART_CB_TYPE_ERROR		3
-
+#define UART_BUFF_SIZE			256
 
 typedef struct _machine_uart_obj_t {
     mp_obj_base_t base;
     uart_port_t uart_num;
-    uint8_t bits;
-    uint8_t parity;
-    uint8_t stop;
+    int8_t bits;
+    int8_t parity;
+    int8_t stop;
     int8_t tx;
     int8_t rx;
     int8_t rts;
     int8_t cts;
-    uint8_t patern_chr_num;
     int data_cb_size;
-    char patern_char;
+    uint8_t pattern[16];
+    uint8_t pattern_len;
     uint16_t timeout;       // timeout waiting for first char (in ms)
     uint16_t buffer_size;
     uint32_t *data_cb;
     uint32_t *pattern_cb;
     uint32_t *error_cb;
-    TaskHandle_t task_id;
     uint8_t end_task;
+    uint8_t lineend[3];
 } machine_uart_obj_t;
 
-STATIC const char *_parity_name[] = {"None", "1", "0"};
-static QueueHandle_t UART_QUEUE[UART_NUM_MAX] = {NULL};
-static QueueHandle_t uart_mutex = NULL;
+typedef struct _uart_ringbuf_t {
+    uint8_t *buf;
+    uint16_t size;
+    uint16_t iget;
+    uint16_t iput;
+} uart_ringbuf_t;
 
+STATIC const char *_parity_name[] = {"None", "1", "0"};
+static QueueHandle_t UART_QUEUE[2] = {NULL};
+static QueueHandle_t uart_mutex = NULL;
+TaskHandle_t task_id[2] = {NULL};
+
+static uart_ringbuf_t uart_buffer[2];
+static uart_ringbuf_t *uart_buf[2] = {NULL};
+
+//-----------------------------------------------------------
+static void uart_ringbuf_alloc(uint8_t uart_num, uint16_t sz)
+{
+	uart_buffer[uart_num].buf = m_new(uint8_t, sz);
+	uart_buffer[uart_num].size = sz;
+	uart_buffer[uart_num].iget = 0;
+	uart_buffer[uart_num].iput = 0;
+	uart_buf[uart_num] = &uart_buffer[uart_num];
+}
+
+//-----------------------------------------------------------------------
+static int uart_buf_get(uart_ringbuf_t *r, uint8_t *dest, uint16_t len) {
+    if (r->iget == r->iput) return -1; // input buffer empty
+
+    int res = 0;
+	for (int i=0; i<len; i++) {
+		dest[i] = r->buf[r->iget++];
+		res++;
+	    if (r->iget == r->iput) break;
+	}
+	// move the buffer and adjust the pointers
+	memmove(r->buf, r->buf+res, res);
+	r->iget -= res;
+	r->iput -= res;
+
+    return res;
+}
+
+//-------------------------------------------------------------------------
+static int uart_buf_put(uart_ringbuf_t *r, uint8_t *source, uint16_t len) {
+	int res = 0;
+	for (int i=0; i<len; i++) {
+	    if (r->iput >= r->size) return 1; // overflow
+	    r->buf[r->iput++] = source[i];
+	}
+	return res;
+}
+
+//---------------------------------------------------------------------------------------
+int pattern_match(uint8_t *text, int text_length, uint8_t *pattern, int pattern_length) {
+	int c, d, e, position = -1;
+
+	if (pattern_length > text_length) return -1;
+
+	for (c = 0; c <= (text_length - pattern_length); c++) {
+		position = e = c;
+
+		for (d = 0; d < pattern_length; d++) {
+			if (pattern[d] == text[e]) e++;
+			else break;
+		}
+		if (d == pattern_length) return position;
+	}
+
+	return -1;
+}
 
 //---------------------------------------------
 static void uart_event_task(void *pvParameters)
 {
 	machine_uart_obj_t *self = (machine_uart_obj_t *)pvParameters;
     uart_event_t event;
-    size_t buffered_size;
-    uint8_t* dtmp = (uint8_t*) malloc(self->buffer_size);
+    size_t datasize;
+    int res;
+    uint8_t* dtmp = (uint8_t*) malloc(UART_BUFF_SIZE);
+
     for(;;) {
     	if (self->end_task) break;
     	if (UART_QUEUE[self->uart_num] == NULL) {
@@ -87,24 +156,51 @@ static void uart_event_task(void *pvParameters)
         //Waiting for UART event.
         if (xQueueReceive(UART_QUEUE[self->uart_num], (void * )&event, 1000 / portTICK_PERIOD_MS)) {
         	if (uart_mutex) xSemaphoreTake(uart_mutex, 200 / portTICK_PERIOD_MS);
-            bzero(dtmp, self->buffer_size);
+            bzero(dtmp, UART_BUFF_SIZE);
             switch(event.type) {
                 //Event of UART receiving data
-                /*We'd better handler data event fast, there would be much more data events than
-                other types of events. If we take too much time on data event, the queue might
-                be full.*/
                 case UART_DATA:
-                    if (self->data_cb) {
-                        size_t datasize;
-                        uart_get_buffered_data_len(self->uart_num, &datasize);
-                        if ((self->data_cb_size > 0) && (datasize >= self->data_cb_size)) {
-							uart_read_bytes(self->uart_num, dtmp, datasize, 20 / portTICK_PERIOD_MS);
-							mp_obj_t tuple[3];
-							tuple[0] = mp_obj_new_int(self->uart_num);
-							tuple[1] = mp_obj_new_int(UART_CB_TYPE_DATA);
-							tuple[2] = mp_obj_new_str((const char*)dtmp, datasize, 0);
-							mp_sched_schedule(self->data_cb, mp_obj_new_tuple(3, tuple));
-                        }
+                	// move UART data to MPy buffer
+                    uart_get_buffered_data_len(self->uart_num+1, &datasize);
+                    if (datasize > 0) {
+                    	// read data from UART buffer
+						if (uart_read_bytes(self->uart_num+1, dtmp, datasize, 0) > 0) {
+							res = uart_buf_put(uart_buf[self->uart_num], dtmp, datasize);
+							if (res) {
+								// MPy buffer full
+								if (self->error_cb) {
+									mp_obj_t tuple[3];
+									tuple[0] = mp_obj_new_int(self->uart_num+1);
+									tuple[1] = mp_obj_new_int(UART_CB_TYPE_ERROR);
+									tuple[2] = mp_obj_new_int(UART_BUFFER_FULL);
+									mp_sched_schedule(self->error_cb, mp_obj_new_tuple(3, tuple));
+								}
+							}
+							else {
+								if ((self->data_cb_size > 0) && (uart_buf[self->uart_num]->iput >= self->data_cb_size)) {
+									// ** callback on data length received
+									uart_buf_get(uart_buf[self->uart_num], dtmp, self->data_cb_size);
+									mp_obj_t tuple[3];
+									tuple[0] = mp_obj_new_int(self->uart_num+1);
+									tuple[1] = mp_obj_new_int(UART_CB_TYPE_DATA);
+									tuple[2] = mp_obj_new_str((const char*)dtmp, datasize, 0);
+									mp_sched_schedule(self->data_cb, mp_obj_new_tuple(3, tuple));
+								}
+								else if (self->pattern_cb) {
+									// ** callback on pattern received
+									res = pattern_match(uart_buf[self->uart_num]->buf, uart_buf[self->uart_num]->iput, self->pattern, self->pattern_len);
+									if (res >= 0) {
+										// found, pull data, including pattern from buffer
+										uart_buf_get(uart_buf[self->uart_num], dtmp, res+self->pattern_len);
+										mp_obj_t tuple[3];
+										tuple[0] = mp_obj_new_int(self->uart_num+1);
+										tuple[1] = mp_obj_new_int(UART_CB_TYPE_PATTERN);
+										tuple[2] = mp_obj_new_str((const char*)dtmp, res, 0);
+										mp_sched_schedule(self->pattern_cb, mp_obj_new_tuple(3, tuple));
+									}
+								}
+							}
+						}
                     }
                     break;
                 //Event of HW FIFO overflow detected
@@ -112,11 +208,11 @@ static void uart_event_task(void *pvParameters)
                     // If fifo overflow happened, you should consider adding flow control for your application.
                     // The ISR has already reset the rx FIFO,
                     // As an example, we directly flush the rx buffer here in order to read more data.
-                    uart_flush_input(self->uart_num);
+                    uart_flush_input(self->uart_num+1);
                     xQueueReset(UART_QUEUE[self->uart_num]);
                     if (self->error_cb) {
 						mp_obj_t tuple[3];
-						tuple[0] = mp_obj_new_int(self->uart_num);
+						tuple[0] = mp_obj_new_int(self->uart_num+1);
 						tuple[1] = mp_obj_new_int(UART_CB_TYPE_ERROR);
 						tuple[2] = mp_obj_new_int(UART_FIFO_OVF);
 						mp_sched_schedule(self->error_cb, mp_obj_new_tuple(3, tuple));
@@ -126,11 +222,11 @@ static void uart_event_task(void *pvParameters)
                 case UART_BUFFER_FULL:
                     // If buffer full happened, you should consider increasing your buffer size
                     // As an example, we directly flush the rx buffer here in order to read more data.
-                    uart_flush_input(self->uart_num);
+                    uart_flush_input(self->uart_num+1);
                     xQueueReset(UART_QUEUE[self->uart_num]);
                     if (self->error_cb) {
 						mp_obj_t tuple[3];
-						tuple[0] = mp_obj_new_int(self->uart_num);
+						tuple[0] = mp_obj_new_int(self->uart_num+1);
 						tuple[1] = mp_obj_new_int(UART_CB_TYPE_ERROR);
 						tuple[2] = mp_obj_new_int(UART_BUFFER_FULL);
 						mp_sched_schedule(self->error_cb, mp_obj_new_tuple(3, tuple));
@@ -140,7 +236,7 @@ static void uart_event_task(void *pvParameters)
                 case UART_BREAK:
                     if (self->error_cb) {
 						mp_obj_t tuple[3];
-						tuple[0] = mp_obj_new_int(self->uart_num);
+						tuple[0] = mp_obj_new_int(self->uart_num+1);
 						tuple[1] = mp_obj_new_int(UART_CB_TYPE_ERROR);
 						tuple[2] = mp_obj_new_int(UART_BREAK);
 						mp_sched_schedule(self->error_cb, mp_obj_new_tuple(3, tuple));
@@ -150,7 +246,7 @@ static void uart_event_task(void *pvParameters)
                 case UART_PARITY_ERR:
                     if (self->error_cb) {
 						mp_obj_t tuple[3];
-						tuple[0] = mp_obj_new_int(self->uart_num);
+						tuple[0] = mp_obj_new_int(self->uart_num+1);
 						tuple[1] = mp_obj_new_int(UART_CB_TYPE_ERROR);
 						tuple[2] = mp_obj_new_int(UART_PARITY_ERR);
 						mp_sched_schedule(self->error_cb, mp_obj_new_tuple(3, tuple));
@@ -160,37 +256,12 @@ static void uart_event_task(void *pvParameters)
                 case UART_FRAME_ERR:
                     if (self->error_cb) {
 						mp_obj_t tuple[3];
-						tuple[0] = mp_obj_new_int(self->uart_num);
+						tuple[0] = mp_obj_new_int(self->uart_num+1);
 						tuple[1] = mp_obj_new_int(UART_CB_TYPE_ERROR);
 						tuple[2] = mp_obj_new_int(UART_FRAME_ERR);
 						mp_sched_schedule(self->error_cb, mp_obj_new_tuple(3, tuple));
                     }
                     break;
-                //UART_PATTERN_DET
-                case UART_PATTERN_DET:
-                    uart_get_buffered_data_len(self->uart_num, &buffered_size);
-                    int pos = uart_pattern_pop_pos(self->uart_num);
-                    if (pos == -1) {
-                        // There used to be a UART_PATTERN_DET event, but the pattern position queue is full so that it can not
-                        // record the position. We should set a larger queue size.
-                        // As an example, we directly flush the rx buffer here.
-                        uart_flush_input(self->uart_num);
-                    }
-                    else {
-                        if (self->pattern_cb) {
-							uart_read_bytes(self->uart_num, dtmp, pos, 100 / portTICK_PERIOD_MS);
-							uint8_t pat[self->patern_chr_num + 1];
-							memset(pat, 0, sizeof(pat));
-							uart_read_bytes(self->uart_num, pat, self->patern_chr_num, 100 / portTICK_PERIOD_MS);
-                        	mp_obj_t tuple[4];
-                        	tuple[0] = mp_obj_new_int(self->uart_num);
-							tuple[1] = mp_obj_new_int(UART_CB_TYPE_PATTERN);
-                        	tuple[2] = mp_obj_new_str((const char*)pat, self->patern_chr_num, 0);
-                        	tuple[3] = mp_obj_new_str((const char*)dtmp, pos, 0);
-                        	mp_sched_schedule(self->pattern_cb, mp_obj_new_tuple(4, tuple));
-                        }
-                    }
-                    break;
                 //Others
                 default:
                     //ESP_LOGI(TAG, "uart event type: %d", event.type);
@@ -201,6 +272,7 @@ static void uart_event_task(void *pvParameters)
     }
     free(dtmp);
     dtmp = NULL;
+    task_id[self->uart_num] = NULL;
     vTaskDelete(NULL);
 }
 
@@ -210,40 +282,41 @@ static void uart_event_task(void *pvParameters)
 
 //--------------------------------------
 static const mp_arg_t allowed_args[] = {
-    { MP_QSTR_baudrate,						 MP_ARG_INT, {.u_int = 0} },
-    { MP_QSTR_bits,							 MP_ARG_INT, {.u_int = 0} },
+    { MP_QSTR_baudrate,						 MP_ARG_INT, {.u_int = -1} },
+    { MP_QSTR_bits,							 MP_ARG_INT, {.u_int = -1} },
     { MP_QSTR_parity,						 MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
-    { MP_QSTR_stop,							 MP_ARG_INT, {.u_int = 0} },
+    { MP_QSTR_stop,							 MP_ARG_INT, {.u_int = -1} },
     { MP_QSTR_tx,			MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = UART_PIN_NO_CHANGE} },
     { MP_QSTR_rx,			MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = UART_PIN_NO_CHANGE} },
     { MP_QSTR_rts,			MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = UART_PIN_NO_CHANGE} },
     { MP_QSTR_cts,			MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = UART_PIN_NO_CHANGE} },
-    { MP_QSTR_timeout,		MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0} },
-    { MP_QSTR_buffer_size,	MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 256} },
+    { MP_QSTR_timeout,		MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = -1} },
+    { MP_QSTR_buffer_size,	MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 512} },
+    { MP_QSTR_lineend,		MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = mp_const_none} },
 };
 
-static enum { ARG_baudrate, ARG_bits, ARG_parity, ARG_stop, ARG_tx, ARG_rx, ARG_rts, ARG_cts, ARG_timeout, ARG_buffer_size };
+enum { ARG_baudrate, ARG_bits, ARG_parity, ARG_stop, ARG_tx, ARG_rx, ARG_rts, ARG_cts, ARG_timeout, ARG_buffer_size, ARG_lineend };
 
 //-----------------------------------------------------------------------------------------------
 STATIC void machine_uart_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
     machine_uart_obj_t *self = MP_OBJ_TO_PTR(self_in);
     uint32_t baudrate;
-    uart_get_baudrate(self->uart_num, &baudrate);
+    uart_get_baudrate(self->uart_num+1, &baudrate);
 
     mp_printf(print, "UART(%u, baudrate=%u, bits=%u, parity=%s, stop=%u, tx=%d, rx=%d, rts=%d, cts=%d, timeout=%u, buf_size=%u)",
-        self->uart_num, baudrate, self->bits, _parity_name[self->parity],
+        self->uart_num+1, baudrate, self->bits, _parity_name[self->parity],
         self->stop, self->tx, self->rx, self->rts, self->cts, self->timeout, self->buffer_size);
     if (self->data_cb) {
     	mp_printf(print, "\n     data CB: True, on len: %d", self->data_cb_size);
     }
     if (self->pattern_cb) {
-    	mp_printf(print, "\n     patern CB: True, pattern len: %d, pattern char: '%c'", self->patern_chr_num, self->patern_char);
+    	mp_printf(print, "\n     pattern CB: True, pattern: [%s]", self->pattern);
     }
     if (self->error_cb) {
     	mp_printf(print, "\n     error CB: True");
     }
-    if (self->task_id) {
-    	mp_printf(print, "\n     Event task minimum free stack: %u", uxTaskGetStackHighWaterMark(self->task_id));
+    if (task_id[self->uart_num]) {
+    	mp_printf(print, "\n     Event task minimum free stack: %u", uxTaskGetStackHighWaterMark(task_id[self->uart_num]));
     }
 }
 
@@ -253,102 +326,114 @@ STATIC void machine_uart_init_helper(machine_uart_obj_t *self, size_t n_args, co
     mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
 
     // wait for all data to be transmitted before changing settings
-    uart_wait_tx_done(self->uart_num, pdMS_TO_TICKS(1000));
+    uart_wait_tx_done(self->uart_num+1, pdMS_TO_TICKS(1000));
 
     // set baudrate
     uint32_t baudrate = 115200;
     if (args[ARG_baudrate].u_int > 0) {
-        uart_set_baudrate(self->uart_num, args[ARG_baudrate].u_int);
-        uart_get_baudrate(self->uart_num, &baudrate);
-    }
-
-    if (((self->tx == -2) && (args[ARG_tx].u_int == UART_PIN_NO_CHANGE)) ||
-    		((self->rx == -2) && (args[ARG_rx].u_int == UART_PIN_NO_CHANGE))) {
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "Tx&Rx pins must be set: u=machine.UART(uart_num, tx=pin, rx=pin)"));
-    }
-
-    esp_err_t res =uart_set_pin(self->uart_num, args[ARG_tx].u_int, args[ARG_rx].u_int, args[ARG_rts].u_int, args[ARG_cts].u_int);
-    if (res != ESP_OK) {
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "Error setting pins"));
-    }
-    if (args[ARG_tx].u_int != UART_PIN_NO_CHANGE) {
-        self->tx = args[ARG_tx].u_int;
-    }
-
-    if (args[ARG_rx].u_int != UART_PIN_NO_CHANGE) {
-        self->rx = args[ARG_rx].u_int;
-    }
-
-    if (args[ARG_rts].u_int != UART_PIN_NO_CHANGE) {
-        self->rts = args[ARG_rts].u_int;
-    }
-
-    if (args[ARG_cts].u_int != UART_PIN_NO_CHANGE) {
-        self->cts = args[ARG_cts].u_int;
+        uart_set_baudrate(self->uart_num+1, args[ARG_baudrate].u_int);
+        uart_get_baudrate(self->uart_num+1, &baudrate);
     }
 
     // set data bits
-    switch (args[ARG_bits].u_int) {
-        case 0:
-            break;
-        case 5:
-            uart_set_word_length(self->uart_num, UART_DATA_5_BITS);
-            self->bits = 5;
-            break;
-        case 6:
-            uart_set_word_length(self->uart_num, UART_DATA_6_BITS);
-            self->bits = 6;
-            break;
-        case 7:
-            uart_set_word_length(self->uart_num, UART_DATA_7_BITS);
-            self->bits = 7;
-            break;
-        case 8:
-            uart_set_word_length(self->uart_num, UART_DATA_8_BITS);
-            self->bits = 8;
-            break;
-        default:
-            mp_raise_ValueError("invalid data bits");
-            break;
+    if ((args[ARG_bits].u_int >= 0) && (args[ARG_bits].u_int != self->bits)) {
+		switch (args[ARG_bits].u_int) {
+			case 0:
+				break;
+			case 5:
+				uart_set_word_length(self->uart_num+1, UART_DATA_5_BITS);
+				self->bits = 5;
+				break;
+			case 6:
+				uart_set_word_length(self->uart_num+1, UART_DATA_6_BITS);
+				self->bits = 6;
+				break;
+			case 7:
+				uart_set_word_length(self->uart_num+1, UART_DATA_7_BITS);
+				self->bits = 7;
+				break;
+			case 8:
+				uart_set_word_length(self->uart_num+1, UART_DATA_8_BITS);
+				self->bits = 8;
+				break;
+			default:
+				mp_raise_ValueError("invalid data bits");
+				break;
+		}
     }
 
     // set parity
     if (args[ARG_parity].u_obj != MP_OBJ_NULL) {
         if (args[ARG_parity].u_obj == mp_const_none) {
-            uart_set_parity(self->uart_num, UART_PARITY_DISABLE);
-            self->parity = 0;
-        } else {
+        	if (self->parity != UART_PARITY_DISABLE) {
+                uart_set_parity(self->uart_num+1, UART_PARITY_DISABLE);
+                self->parity = UART_PARITY_DISABLE;
+        }
+        }
+        else {
             mp_int_t parity = mp_obj_get_int(args[ARG_parity].u_obj);
-            if (parity & 1) {
-                uart_set_parity(self->uart_num, UART_PARITY_ODD);
-                self->parity = 1;
-            } else {
-                uart_set_parity(self->uart_num, UART_PARITY_EVEN);
-                self->parity = 2;
+            if ((parity & 1) && (self->parity != UART_PARITY_ODD)) {
+                uart_set_parity(self->uart_num+1, UART_PARITY_ODD);
+                self->parity = UART_PARITY_ODD;
+            }
+            else if (self->parity != UART_PARITY_EVEN){
+                uart_set_parity(self->uart_num+1, UART_PARITY_EVEN);
+                self->parity = UART_PARITY_EVEN;
             }
         }
     }
 
     // set stop bits
-    switch (args[ARG_stop].u_int) {
-        // FIXME: ESP32 also supports 1.5 stop bits
-        case 0:
-            break;
-        case 1:
-            uart_set_stop_bits(self->uart_num, UART_STOP_BITS_1);
-            self->stop = 1;
-            break;
-        case 2:
-            uart_set_stop_bits(self->uart_num, UART_STOP_BITS_2);
-            self->stop = 2;
-            break;
-        default:
-            mp_raise_ValueError("invalid stop bits");
-            break;
+    if ((args[ARG_stop].u_int >= 0) && (args[ARG_stop].u_int != self->stop)) {
+		switch (args[ARG_stop].u_int) {
+			case 0:
+				break;
+			case 1:
+				uart_set_stop_bits(self->uart_num+1, UART_STOP_BITS_1);
+				self->stop = UART_STOP_BITS_1;
+				break;
+			case 2:
+				uart_set_stop_bits(self->uart_num+1, UART_STOP_BITS_2);
+				self->stop = UART_STOP_BITS_2;
+				break;
+			case 3:
+				uart_set_stop_bits(self->uart_num+1, UART_STOP_BITS_1_5);
+				self->stop = UART_STOP_BITS_1_5;
+				break;
+			default:
+				mp_raise_ValueError("invalid stop bits");
+				break;
+		}
+    }
+
+    // set pins
+    if (((self->tx == -2) && (args[ARG_tx].u_int == UART_PIN_NO_CHANGE)) ||	((self->rx == -2) && (args[ARG_rx].u_int == UART_PIN_NO_CHANGE))) {
+        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "Tx&Rx pins must be set: u=machine.UART(uart_num, tx=pin, rx=pin)"));
+    }
+
+    if ((self->tx != args[ARG_tx].u_int) || (self->rx != args[ARG_rx].u_int) ||
+    	(self->rts != args[ARG_rts].u_int) || (self->cts != args[ARG_cts].u_int)) {
+
+    	esp_err_t res = uart_set_pin(self->uart_num+1, args[ARG_tx].u_int, args[ARG_rx].u_int, args[ARG_rts].u_int, args[ARG_cts].u_int);
+		if (res != ESP_OK) {
+			nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "Error setting pins"));
+		}
+
+		if (args[ARG_tx].u_int != UART_PIN_NO_CHANGE)  self->tx  = args[ARG_tx].u_int;
+		if (args[ARG_rx].u_int != UART_PIN_NO_CHANGE)  self->rx  = args[ARG_rx].u_int;
+		if (args[ARG_rts].u_int != UART_PIN_NO_CHANGE) self->rts = args[ARG_rts].u_int;
+		if (args[ARG_cts].u_int != UART_PIN_NO_CHANGE) self->cts = args[ARG_cts].u_int;
     }
 
     // set timeout
-    self->timeout = args[ARG_timeout].u_int;
+    if (args[ARG_timeout].u_int >= 0) self->timeout = args[ARG_timeout].u_int;
+
+    // set line end
+    if (MP_OBJ_IS_STR(args[ARG_lineend].u_obj)) {
+    	size_t lnendlen;
+    	const char *lnend = mp_obj_str_get_data(args[ARG_lineend].u_obj, &lnendlen);
+    	if ((lnend) && (lnendlen > 0) && (lnendlen > 0)) sprintf((char *)self->lineend, "%s", lnend);
+	}
 }
 
 //------------------------------------------------------------------------------------------------------------------
@@ -384,21 +469,21 @@ STATIC mp_obj_t machine_uart_make_new(const mp_obj_type_t *type, size_t n_args,
 	// Create UART instance, set defaults
     machine_uart_obj_t *self = m_new_obj(machine_uart_obj_t);
     self->base.type = &machine_uart_type;
-    self->uart_num = uart_num;
-    self->bits = 8;
-    self->parity = 0;
-    self->stop = 1;
-    self->rts = -1;
-    self->cts = -1;
+    self->uart_num = uart_num-1;
+    self->bits = UART_DATA_8_BITS;
+    self->parity = UART_PARITY_DISABLE;
+    self->stop = UART_STOP_BITS_1;
+    self->rts = UART_PIN_NO_CHANGE;
+    self->cts = UART_PIN_NO_CHANGE;
     self->timeout = 0;
-    self->patern_chr_num = 3;
-    self->patern_char = '+';
+    self->pattern[0] = 0;
+    self->pattern_len = 0;
     self->data_cb = NULL;
     self->pattern_cb = NULL;
     self->error_cb = NULL;
-    self->task_id = NULL;
     self->data_cb_size = 0;
     self->end_task = 0;
+    sprintf((char *)self->lineend, "\r\n");
 
 
     switch (uart_num) {
@@ -423,35 +508,40 @@ STATIC mp_obj_t machine_uart_make_new(const mp_obj_type_t *type, size_t n_args,
     mp_arg_parse_all(n_args-1, args+1, &kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, kargs);
 
     int bufsize = kargs[ARG_buffer_size].u_int;
-    if (bufsize < 256) bufsize = 256;
-    if (bufsize > 4096) bufsize = 4096;
+    if (bufsize < 512) bufsize = 512;
+    if (bufsize > 8192) bufsize = 8192;
     self->buffer_size = bufsize;
 
-    // Remove any existing configuration
-    uart_driver_delete(self->uart_num);
+	if (uart_buf[self->uart_num] == NULL) {
+		uart_ringbuf_alloc(self->uart_num, bufsize);
+		if (uart_buf[self->uart_num] == NULL) {
+	        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "UART(%d) Error allocating ring buffer", uart_num));
+		}
+	}
+
+	// Remove any existing configuration
+    uart_driver_delete(uart_num);
 
     // init the peripheral
     // Setup
-    uart_param_config(self->uart_num, &uartcfg);
+    uart_param_config(uart_num, &uartcfg);
 
-    // RX buffer size is set from argument (default 256), TX buffer is disabled.
-    esp_err_t res = uart_driver_install(uart_num, bufsize, 0, 10, &UART_QUEUE[self->uart_num], 0);
-    //esp_err_t res = uart_driver_install(uart_num, bufsize, 0, 0, NULL, 0);
+    // RX ring buffer size is set to UART_BUFF_SIZE (256), TX buffer is disabled.
+    esp_err_t res = uart_driver_install(uart_num, UART_BUFF_SIZE, 0, 10, &UART_QUEUE[self->uart_num], 0);
     if (res != ESP_OK) {
         nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "UART(%d) Error installing driver", uart_num));
     }
 
-
     machine_uart_init_helper(self, n_args - 1, args + 1, &kw_args);
 
     // Make sure pins are connected.
-    uart_set_pin(self->uart_num, self->tx, self->rx, self->rts, self->cts);
+    uart_set_pin(uart_num, self->tx, self->rx, self->rts, self->cts);
 
-    //Set uart pattern detect function (This is the test pattern ABCD+++).
-    uart_disable_pattern_det_intr(self->uart_num);
+    //Disable uart pattern detect function
+    uart_disable_pattern_det_intr(uart_num);
 
     //Create a task to handler UART event from ISR
-    xTaskCreate(uart_event_task, "uart_event_task", 1024, (void *)self, 12, &self->task_id);
+    if (task_id[self->uart_num] == NULL) xTaskCreate(uart_event_task, "uart_event_task", 1024, (void *)self, 12, &task_id[self->uart_num]);
 
     return MP_OBJ_FROM_PTR(self);
 }
@@ -466,33 +556,105 @@ MP_DEFINE_CONST_FUN_OBJ_KW(machine_uart_init_obj, 1, machine_uart_init);
 //--------------------------------------------------
 STATIC mp_obj_t machine_uart_any(mp_obj_t self_in) {
     machine_uart_obj_t *self = MP_OBJ_TO_PTR(self_in);
-    size_t rxbufsize;
-    uart_get_buffered_data_len(self->uart_num, &rxbufsize);
-    return MP_OBJ_NEW_SMALL_INT(rxbufsize);
+
+    if (uart_mutex) xSemaphoreTake(uart_mutex, 200 / portTICK_PERIOD_MS);
+    int res = uart_buf[self->uart_num]->iput;
+	if (uart_mutex) xSemaphoreGive(uart_mutex);
+
+    return MP_OBJ_NEW_SMALL_INT(res);
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_1(machine_uart_any_obj, machine_uart_any);
 
 //-----------------------------------------------------
 STATIC mp_obj_t machine_uart_flush(mp_obj_t self_in) {
     machine_uart_obj_t *self = MP_OBJ_TO_PTR(self_in);
-    uart_flush_input(self->uart_num);
-    return mp_const_none;
+
+    if (uart_mutex) xSemaphoreTake(uart_mutex, 200 / portTICK_PERIOD_MS);
+    uart_flush_input(self->uart_num+1);
+    uart_buf[self->uart_num]->iput = 0;
+    uart_buf[self->uart_num]->iget = 0;
+	if (uart_mutex) xSemaphoreGive(uart_mutex);
+
+	return mp_const_none;
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_1(machine_uart_flush_obj, machine_uart_flush);
 
+//------------------------------------------------------------------------
+STATIC mp_obj_t machine_uart_readln(size_t n_args, const mp_obj_t *args) {
+    machine_uart_obj_t *self = MP_OBJ_TO_PTR(args[0]);
+
+    vstr_t vstr;
+    int res = -1;
+	int lnendlen = strlen((char *)self->lineend);
+	int timeout = self->timeout;
+	if (n_args == 2) timeout = mp_obj_get_int(args[1]);
+
+	if (timeout == 0) {
+		if (uart_mutex) xSemaphoreTake(uart_mutex, 200 / portTICK_PERIOD_MS);
+    	// just return the buffer content if line end was found
+		if (uart_buf[self->uart_num]->iput < lnendlen) {
+	    	if (uart_mutex) xSemaphoreGive(uart_mutex);
+	    	return mp_const_none;
+		}
+		res = pattern_match(uart_buf[self->uart_num]->buf, uart_buf[self->uart_num]->iput, self->lineend, lnendlen);
+		if (res >= 0) {
+			// found, pull data, including pattern from buffer
+			vstr_init_len(&vstr, res+lnendlen);
+			uart_buf_get(uart_buf[self->uart_num], (uint8_t *)vstr.buf, res+lnendlen);
+		}
+    	if (uart_mutex) xSemaphoreGive(uart_mutex);
+    	if (res < 0) return mp_const_none;
+    }
+    else {
+    	// wait until line end received or timeout
+    	int wait = timeout;
+        int buflen = 0;
+    	mp_hal_set_wdt_tmo();
+		MP_THREAD_GIL_EXIT();
+		while (wait > 0) {
+			if (uart_mutex) xSemaphoreTake(uart_mutex, 200 / portTICK_PERIOD_MS);
+			if (buflen < uart_buf[self->uart_num]->iput) {
+				buflen = uart_buf[self->uart_num]->iput;
+				wait = timeout; // new data received, reset timeout
+			}
+			if (uart_buf[self->uart_num]->iput < lnendlen) {
+		    	if (uart_mutex) xSemaphoreGive(uart_mutex);
+	    		vTaskDelay(10 / portTICK_PERIOD_MS);
+				wait -= 10;
+				mp_hal_reset_wdt();
+				continue;
+			}
+			res = pattern_match(uart_buf[self->uart_num]->buf, uart_buf[self->uart_num]->iput, self->lineend, lnendlen);
+			if (res >= 0) {
+				// found, pull data, including pattern from buffer
+				vstr_init_len(&vstr, res+lnendlen);
+				uart_buf_get(uart_buf[self->uart_num], (uint8_t *)vstr.buf, res+lnendlen);
+		    	if (uart_mutex) xSemaphoreGive(uart_mutex);
+				break;
+			}
+	    	if (uart_mutex) xSemaphoreGive(uart_mutex);
+    		vTaskDelay(10 / portTICK_PERIOD_MS);
+			wait -= 10;
+			mp_hal_reset_wdt();
+		}
+		MP_THREAD_GIL_ENTER();
+    	if (res < 0) return mp_const_none;
+    }
+
+    return mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(machine_uart_readln_obj, 1, 2, machine_uart_readln);
+
+
 //-----------------------------------------------------------------------------------------------
 STATIC mp_obj_t machine_uart_callback(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args)
 {
-	enum { ARG_type, ARG_func, ARG_pattern, ARG_patternlen, ARG_datalen, ARG_timeout, ARG_predelay, ARG_postdelay };
+	enum { ARG_type, ARG_func, ARG_pattern, ARG_datalen };
     const mp_arg_t allowed_args[] = {
         { MP_QSTR_type,			MP_ARG_REQUIRED | MP_ARG_INT, { .u_int = 0 } },
         { MP_QSTR_func,			MP_ARG_REQUIRED | MP_ARG_OBJ, { .u_obj = mp_const_none } },
-        { MP_QSTR_pattern_char,	MP_ARG_KW_ONLY  | MP_ARG_OBJ, { .u_obj = mp_const_none } },
-        { MP_QSTR_pattern_len,	MP_ARG_KW_ONLY  | MP_ARG_INT, { .u_int = -1 } },
+        { MP_QSTR_pattern,		MP_ARG_KW_ONLY  | MP_ARG_OBJ, { .u_obj = mp_const_none } },
         { MP_QSTR_data_len,		MP_ARG_KW_ONLY  | MP_ARG_INT, { .u_int = -1 } },
-        { MP_QSTR_timeout,		MP_ARG_KW_ONLY  | MP_ARG_INT, { .u_int = -1 } },
-        { MP_QSTR_pre_delay,	MP_ARG_KW_ONLY  | MP_ARG_INT, { .u_int = -1 } },
-        { MP_QSTR_post_delay,	MP_ARG_KW_ONLY  | MP_ARG_INT, { .u_int = -1 } },
     };
 
     machine_uart_obj_t *self = MP_OBJ_TO_PTR(pos_args[0]);
@@ -508,8 +670,9 @@ STATIC mp_obj_t machine_uart_callback(size_t n_args, const mp_obj_t *pos_args, m
         		self->data_cb_size = 0;
                 break;
             case UART_CB_TYPE_PATTERN:
-        	    uart_disable_pattern_det_intr(self->uart_num);
             	self->pattern_cb = NULL;
+            	self->pattern[0] = 0;
+            	self->pattern_len = 0;
                 break;
             case UART_CB_TYPE_ERROR:
             	self->error_cb = NULL;
@@ -522,28 +685,17 @@ STATIC mp_obj_t machine_uart_callback(size_t n_args, const mp_obj_t *pos_args, m
     }
 
 
-    int patlen = -1;
     int datalen = -1;
-    int timeout = 10000;
-    int predelay = 10;
-    int postdelay = 10;
-    char pchar = self->patern_char;
+    size_t patternlen = 0;
+    const char * pattern = NULL;
 
     if (MP_OBJ_IS_STR(args[ARG_pattern].u_obj)) {
-    	const char * pattern = mp_obj_str_get_str(args[ARG_pattern].u_obj);
-    	if ((pattern) && strlen(pattern) > 0) pchar = pattern[0];
+    	pattern = mp_obj_str_get_data(args[ARG_pattern].u_obj, &patternlen);
+    	if (patternlen > sizeof(self->pattern)) patternlen = sizeof(self->pattern);
 	}
 
-	if ((args[ARG_patternlen].u_int > 1) && (args[ARG_patternlen].u_int <= 64)) patlen = args[ARG_patternlen].u_int;
     if ((args[ARG_datalen].u_int >= 0) && (args[ARG_datalen].u_int < self->buffer_size)) datalen = args[ARG_datalen].u_int;
 
-    int tmp = args[ARG_timeout].u_int;
-    if ((tmp >= 1) && (tmp <= 200000)) timeout = tmp * 80;
-    tmp = args[ARG_predelay].u_int;
-    if ((tmp >= 1) && (tmp <= 200000)) predelay = tmp * 80;
-    tmp = args[ARG_postdelay].u_int;
-    if ((tmp >= 1) && (tmp <= 200000)) postdelay = tmp * 80;
-
 	if (uart_mutex) xSemaphoreTake(uart_mutex, 200 / portTICK_PERIOD_MS);
     switch(cbtype) {
         case UART_CB_TYPE_DATA:
@@ -551,13 +703,11 @@ STATIC mp_obj_t machine_uart_callback(size_t n_args, const mp_obj_t *pos_args, m
     		self->data_cb = args[ARG_func].u_obj;
             break;
         case UART_CB_TYPE_PATTERN:
-    	    uart_disable_pattern_det_intr(self->uart_num);
+        	if (pattern) {
+        		memcpy(self->pattern, pattern, patternlen);
+        		self->pattern_len = patternlen;
+        	}
     		self->pattern_cb = args[ARG_func].u_obj;
-    		if (patlen > 0) self->patern_chr_num = patlen;
-    		if (pchar != self->patern_char) self->patern_char = pchar;
-    	    uart_enable_pattern_det_intr(self->uart_num, self->patern_char, self->patern_chr_num, timeout, postdelay, predelay);
-    	    //Reset the pattern queue length to record at most 10 pattern positions.
-    	    uart_pattern_queue_reset(self->uart_num, 10);
             break;
         case UART_CB_TYPE_ERROR:
     		self->error_cb = args[ARG_func].u_obj;
@@ -581,6 +731,7 @@ STATIC const mp_rom_map_elem_t machine_uart_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR_readline),		MP_ROM_PTR(&mp_stream_unbuffered_readline_obj) },
     { MP_ROM_QSTR(MP_QSTR_readinto),		MP_ROM_PTR(&mp_stream_readinto_obj) },
     { MP_ROM_QSTR(MP_QSTR_write),			MP_ROM_PTR(&mp_stream_write_obj) },
+    { MP_ROM_QSTR(MP_QSTR_readln),			MP_ROM_PTR(&machine_uart_readln_obj) },
     { MP_ROM_QSTR(MP_QSTR_flush),			MP_ROM_PTR(&machine_uart_flush_obj) },
     { MP_ROM_QSTR(MP_QSTR_callback),		MP_ROM_PTR(&machine_uart_callback_obj) },
 
@@ -601,18 +752,30 @@ STATIC mp_uint_t machine_uart_read(mp_obj_t self_in, void *buf_in, mp_uint_t siz
     }
 
     int bytes_read = 0;
-	mp_hal_set_wdt_tmo();
     if (self->timeout == 0) {
-        bytes_read = uart_read_bytes(self->uart_num, buf_in, size, 0);
+    	// just return the buffer content
+    	if (uart_mutex) xSemaphoreTake(uart_mutex, 200 / portTICK_PERIOD_MS);
+    	bytes_read = uart_buf_get(uart_buf[self->uart_num], (uint8_t *)buf_in, size);
+    	if (uart_mutex) xSemaphoreGive(uart_mutex);
+    	if (bytes_read < 0) bytes_read = 0;
     }
     else {
+    	// wait until data received or timeout
+    	mp_hal_set_wdt_tmo();
 		int wait = self->timeout;
 		MP_THREAD_GIL_EXIT();
 		while (wait > 0) {
-			bytes_read = uart_read_bytes(self->uart_num, buf_in, size, pdMS_TO_TICKS(10));
-			if (bytes_read != 0) break;
-			mp_hal_reset_wdt();
-			wait -= 10;
+	    	if (uart_mutex) xSemaphoreTake(uart_mutex, 200 / portTICK_PERIOD_MS);
+			if (uart_buf[self->uart_num]->iput < size) {
+		    	if (uart_mutex) xSemaphoreGive(uart_mutex);
+	    		vTaskDelay(10 / portTICK_PERIOD_MS);
+				wait -= 10;
+				mp_hal_reset_wdt();
+				continue;
+			}
+	    	bytes_read = uart_buf_get(uart_buf[self->uart_num], (uint8_t *)buf_in, size);
+	    	if (uart_mutex) xSemaphoreGive(uart_mutex);
+			break;
 		}
 		MP_THREAD_GIL_ENTER();
     }
@@ -629,7 +792,7 @@ STATIC mp_uint_t machine_uart_read(mp_obj_t self_in, void *buf_in, mp_uint_t siz
 STATIC mp_uint_t machine_uart_write(mp_obj_t self_in, const void *buf_in, mp_uint_t size, int *errcode) {
     machine_uart_obj_t *self = MP_OBJ_TO_PTR(self_in);
 
-    int bytes_written = uart_write_bytes(self->uart_num, buf_in, size);
+    int bytes_written = uart_write_bytes(self->uart_num+1, buf_in, size);
 
     if (bytes_written < 0) {
         *errcode = MP_EAGAIN;
@@ -648,7 +811,10 @@ STATIC mp_uint_t machine_uart_ioctl(mp_obj_t self_in, mp_uint_t request, mp_uint
         mp_uint_t flags = arg;
         ret = 0;
         size_t rxbufsize;
-        uart_get_buffered_data_len(self->uart_num, &rxbufsize);
+    	if (uart_mutex) xSemaphoreTake(uart_mutex, 200 / portTICK_PERIOD_MS);
+        rxbufsize = uart_buf[self->uart_num]->iput;
+    	if (uart_mutex) xSemaphoreGive(uart_mutex);
+
         if ((flags & MP_STREAM_POLL_RD) && rxbufsize > 0) {
             ret |= MP_STREAM_POLL_RD;
         }
diff --git a/MicroPython_BUILD/components/micropython/esp32/modnetwork.c b/MicroPython_BUILD/components/micropython/esp32/modnetwork.c
index cf6b57f..765fc57 100644
--- a/MicroPython_BUILD/components/micropython/esp32/modnetwork.c
+++ b/MicroPython_BUILD/components/micropython/esp32/modnetwork.c
@@ -166,8 +166,34 @@ static bool wifi_sta_connected = false;
 static uint8_t _isConnected = 0;
 
 static mp_obj_t event_callback = NULL;
+static mp_obj_t probereq_callback = NULL;
 static QueueHandle_t wifi_mutex = NULL;
 
+#ifdef INCLUDE_PROBEREQRECVED
+
+static QueueHandle_t probereq_mutex = NULL;
+
+//------------------------------------------------------------------------
+static void processPROBEREQRECVED(const uint8_t *frame, int len, int rssi)
+{
+	if (probereq_callback != NULL) {
+		if (probereq_mutex) xSemaphoreTake(probereq_mutex, 1000);
+		//mp_obj_t tuple[3];
+		mp_obj_dict_t *dct = mp_obj_new_dict(0);
+		mp_obj_dict_store(dct, mp_obj_new_str("rssi", 4, false), mp_obj_new_int(rssi));
+		mp_obj_dict_store(dct, mp_obj_new_str("len", 3, false), mp_obj_new_int(len));
+		mp_obj_dict_store(dct, mp_obj_new_str("frame", 5, false), mp_obj_new_str((const char*)frame, len, false));
+
+		//tuple[0] = mp_obj_new_int(SYSTEM_EVENT_AP_PROBEREQRECVED);
+		//tuple[1] = mp_obj_new_str("Receive probe request packet", 28, false);
+		//tuple[2] = dct;
+
+		mp_sched_schedule(probereq_callback, dct); //mp_obj_new_tuple(3, tuple));
+		if (probereq_mutex) xSemaphoreGive(probereq_mutex);
+	}
+}
+
+#endif
 
 //------------------------------------------------------
 static void processEvent_callback(system_event_t *event)
@@ -343,6 +369,7 @@ STATIC mp_obj_t get_wlan(size_t n_args, const mp_obj_t *args) {
         ESP_EXCEPTIONS( esp_wifi_set_mode(0) );
         ESP_EXCEPTIONS( esp_wifi_start() );
         ESP_LOGD("modnetwork", "Started");
+
         initialized = 1;
     }
 
@@ -368,6 +395,10 @@ STATIC mp_obj_t esp_initialize() {
 
         if (wifi_mutex == NULL) wifi_mutex = xSemaphoreCreateMutex();
 
+		#ifdef INCLUDE_PROBEREQRECVED
+        if (probereq_mutex == NULL) probereq_mutex = xSemaphoreCreateMutex();
+        esp_wifi_set_sta_rx_probe_req(processPROBEREQRECVED);
+		#endif
 		initialized = 1;
     }
     return mp_const_none;
@@ -683,6 +714,27 @@ STATIC mp_obj_t esp_callback(size_t n_args, const mp_obj_t *args)
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(esp_callback_obj, 1, 2, esp_callback);
 
+#ifdef INCLUDE_PROBEREQRECVED
+//------------------------------------------------------------------------
+STATIC mp_obj_t esp_probereq_callback(size_t n_args, const mp_obj_t *args)
+{
+    if (n_args == 1) {
+    	if (probereq_callback == NULL) return mp_const_false;
+    	return mp_const_true;
+    }
+
+	if (probereq_mutex) xSemaphoreTake(probereq_mutex, 1000);
+    if ((MP_OBJ_IS_FUN(args[1])) || (MP_OBJ_IS_METH(args[1]))) {
+		probereq_callback = args[1];
+    }
+    else probereq_callback = NULL;
+	if (probereq_mutex) xSemaphoreGive(probereq_mutex);
+
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(esp_probereq_callback_obj, 1, 2, esp_probereq_callback);
+#endif
+
 STATIC const mp_map_elem_t wlan_if_locals_dict_table[] = {
     { MP_OBJ_NEW_QSTR(MP_QSTR_active), (mp_obj_t)&esp_active_obj },
     { MP_OBJ_NEW_QSTR(MP_QSTR_connect), (mp_obj_t)&esp_connect_obj },
@@ -693,6 +745,9 @@ STATIC const mp_map_elem_t wlan_if_locals_dict_table[] = {
     { MP_OBJ_NEW_QSTR(MP_QSTR_config), (mp_obj_t)&esp_config_obj },
     { MP_OBJ_NEW_QSTR(MP_QSTR_ifconfig), (mp_obj_t)&esp_ifconfig_obj },
     { MP_OBJ_NEW_QSTR(MP_QSTR_eventCB), (mp_obj_t)&esp_callback_obj },
+	#ifdef INCLUDE_PROBEREQRECVED
+    { MP_OBJ_NEW_QSTR(MP_QSTR_probereqCB), (mp_obj_t)&esp_probereq_callback_obj },
+	#endif
 };
 
 STATIC MP_DEFINE_CONST_DICT(wlan_if_locals_dict, wlan_if_locals_dict_table);
diff --git a/MicroPython_BUILD/components/micropython/esp32/modnetwork.h b/MicroPython_BUILD/components/micropython/esp32/modnetwork.h
index bbacec8..50801e9 100644
--- a/MicroPython_BUILD/components/micropython/esp32/modnetwork.h
+++ b/MicroPython_BUILD/components/micropython/esp32/modnetwork.h
@@ -26,6 +26,8 @@
 #ifndef MICROPY_INCLUDED_ESP32_MODNETWORK_H
 #define MICROPY_INCLUDED_ESP32_MODNETWORK_H
 
+//#define INCLUDE_PROBEREQRECVED
+
 enum { PHY_LAN8720, PHY_TLK110 };
 
 typedef struct _wlan_if_obj_t {
@@ -33,6 +35,11 @@ typedef struct _wlan_if_obj_t {
     int if_id;
 } wlan_if_obj_t;
 
+#ifdef INCLUDE_PROBEREQRECVED
+typedef void (*wifi_sta_rx_probe_req_t)(const uint8_t *frame, int len, int rssi);
+extern esp_err_t esp_wifi_set_sta_rx_probe_req(wifi_sta_rx_probe_req_t cb);
+#endif
+
 extern const mp_obj_type_t wlan_if_type;
 
 #ifdef CONFIG_MICROPY_USE_ETHERNET
diff --git a/MicroPython_BUILD/components/micropython/esp32/mpversion.h b/MicroPython_BUILD/components/micropython/esp32/mpversion.h
index 2b4c396..5f09c9c 100644
--- a/MicroPython_BUILD/components/micropython/esp32/mpversion.h
+++ b/MicroPython_BUILD/components/micropython/esp32/mpversion.h
@@ -1,8 +1,8 @@
 // MicroPython version info
-#define MICROPY_GIT_TAG "ESP32_LoBo_v3.1.15"
+#define MICROPY_GIT_TAG "ESP32_LoBo_v3.1.16"
 #define MICROPY_GIT_HASH "gdaa8cfa8"
-#define MICROPY_BUILD_DATE "2017-02-03"
+#define MICROPY_BUILD_DATE "2017-02-04"
 #define MICROPY_VERSION_MAJOR (3)
 #define MICROPY_VERSION_MINOR (1)
-#define MICROPY_VERSION_MICRO (15)
-#define MICROPY_VERSION_STRING "3.1.15"
+#define MICROPY_VERSION_MICRO (16)
+#define MICROPY_VERSION_STRING "3.1.16"
diff --git a/MicroPython_BUILD/components/micropython/extmod/modutimeq.c b/MicroPython_BUILD/components/micropython/extmod/modutimeq.c
index 64f29fb..0c07ae9 100644
--- a/MicroPython_BUILD/components/micropython/extmod/modutimeq.c
+++ b/MicroPython_BUILD/components/micropython/extmod/modutimeq.c
@@ -37,7 +37,7 @@
 
 #define DEBUG 0
 
-// the algorithm here is modelled on CPython's heapq.py
+// the algorithm here is modeled on CPython's heapq.py
 
 struct qentry {
     mp_uint_t time;
@@ -121,6 +121,7 @@ STATIC void heap_siftup(mp_obj_utimeq_t *heap, mp_uint_t pos) {
     heap_siftdown(heap, start_pos, pos);
 }
 
+//------------------------------------------------------------------------
 STATIC mp_obj_t mod_utimeq_heappush(size_t n_args, const mp_obj_t *args) {
     (void)n_args;
     mp_obj_t heap_in = args[0];
@@ -134,7 +135,8 @@ STATIC mp_obj_t mod_utimeq_heappush(size_t n_args, const mp_obj_t *args) {
     	mp_float_t time = mp_obj_float_get(args[1]);
         itime = (uint32_t)time;
     }
-    else itime = MP_OBJ_SMALL_INT_VALUE(args[1]);
+    else itime = mp_obj_get_int(args[1]);
+
     heap->items[l].time = itime;
     heap->items[l].id = utimeq_id++;
     heap->items[l].callback = args[2];
@@ -145,6 +147,7 @@ STATIC mp_obj_t mod_utimeq_heappush(size_t n_args, const mp_obj_t *args) {
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mod_utimeq_heappush_obj, 4, 4, mod_utimeq_heappush);
 
+//-----------------------------------------------------------------------
 STATIC mp_obj_t mod_utimeq_heappop(mp_obj_t heap_in, mp_obj_t list_ref) {
     mp_obj_utimeq_t *heap = get_heap(heap_in);
     if (heap->len == 0) {
@@ -156,7 +159,7 @@ STATIC mp_obj_t mod_utimeq_heappop(mp_obj_t heap_in, mp_obj_t list_ref) {
     }
 
     struct qentry *item = &heap->items[0];
-    ret->items[0] = MP_OBJ_NEW_SMALL_INT(item->time);
+    ret->items[0] = mp_obj_new_int(item->time);
     ret->items[1] = item->callback;
     ret->items[2] = item->args;
     heap->len -= 1;
@@ -170,6 +173,7 @@ STATIC mp_obj_t mod_utimeq_heappop(mp_obj_t heap_in, mp_obj_t list_ref) {
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_2(mod_utimeq_heappop_obj, mod_utimeq_heappop);
 
+//-----------------------------------------------------
 STATIC mp_obj_t mod_utimeq_peektime(mp_obj_t heap_in) {
     mp_obj_utimeq_t *heap = get_heap(heap_in);
     if (heap->len == 0) {
@@ -177,7 +181,7 @@ STATIC mp_obj_t mod_utimeq_peektime(mp_obj_t heap_in) {
     }
 
     struct qentry *item = &heap->items[0];
-    return MP_OBJ_NEW_SMALL_INT(item->time);
+    return mp_obj_new_int(item->time);
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_1(mod_utimeq_peektime_obj, mod_utimeq_peektime);
 
diff --git a/MicroPython_BUILD/firmware/MicroPython_LoBo_esp32.zip b/MicroPython_BUILD/firmware/MicroPython_LoBo_esp32.zip
index b2f83c2..37a1184 100644
Binary files a/MicroPython_BUILD/firmware/MicroPython_LoBo_esp32.zip and b/MicroPython_BUILD/firmware/MicroPython_LoBo_esp32.zip differ
diff --git a/MicroPython_BUILD/firmware/MicroPython_LoBo_esp32_all.zip b/MicroPython_BUILD/firmware/MicroPython_LoBo_esp32_all.zip
index 69fa7a7..e5a7897 100644
Binary files a/MicroPython_BUILD/firmware/MicroPython_LoBo_esp32_all.zip and b/MicroPython_BUILD/firmware/MicroPython_LoBo_esp32_all.zip differ
diff --git a/MicroPython_BUILD/firmware/MicroPython_LoBo_esp32_ota.zip b/MicroPython_BUILD/firmware/MicroPython_LoBo_esp32_ota.zip
index 14ea902..1ca9380 100644
Binary files a/MicroPython_BUILD/firmware/MicroPython_LoBo_esp32_ota.zip and b/MicroPython_BUILD/firmware/MicroPython_LoBo_esp32_ota.zip differ
diff --git a/MicroPython_BUILD/firmware/MicroPython_LoBo_esp32_psram.zip b/MicroPython_BUILD/firmware/MicroPython_LoBo_esp32_psram.zip
index cf7f291..5560a14 100644
Binary files a/MicroPython_BUILD/firmware/MicroPython_LoBo_esp32_psram.zip and b/MicroPython_BUILD/firmware/MicroPython_LoBo_esp32_psram.zip differ
diff --git a/MicroPython_BUILD/firmware/MicroPython_LoBo_esp32_psram_all.zip b/MicroPython_BUILD/firmware/MicroPython_LoBo_esp32_psram_all.zip
index 9748470..40aa8c3 100644
Binary files a/MicroPython_BUILD/firmware/MicroPython_LoBo_esp32_psram_all.zip and b/MicroPython_BUILD/firmware/MicroPython_LoBo_esp32_psram_all.zip differ
diff --git a/MicroPython_BUILD/firmware/MicroPython_LoBo_esp32_psram_ota.zip b/MicroPython_BUILD/firmware/MicroPython_LoBo_esp32_psram_ota.zip
index fd521af..98f644a 100644
Binary files a/MicroPython_BUILD/firmware/MicroPython_LoBo_esp32_psram_ota.zip and b/MicroPython_BUILD/firmware/MicroPython_LoBo_esp32_psram_ota.zip differ
diff --git a/MicroPython_BUILD/firmware/esp32/MicroPython.bin b/MicroPython_BUILD/firmware/esp32/MicroPython.bin
index 08dfd15..62f6bfa 100644
Binary files a/MicroPython_BUILD/firmware/esp32/MicroPython.bin and b/MicroPython_BUILD/firmware/esp32/MicroPython.bin differ
diff --git a/MicroPython_BUILD/firmware/esp32/bootloader/bootloader.bin b/MicroPython_BUILD/firmware/esp32/bootloader/bootloader.bin
index 7c87586..3096ff6 100644
Binary files a/MicroPython_BUILD/firmware/esp32/bootloader/bootloader.bin and b/MicroPython_BUILD/firmware/esp32/bootloader/bootloader.bin differ
diff --git a/MicroPython_BUILD/firmware/esp32_all/MicroPython.bin b/MicroPython_BUILD/firmware/esp32_all/MicroPython.bin
index 7eb8505..01e6bbb 100644
Binary files a/MicroPython_BUILD/firmware/esp32_all/MicroPython.bin and b/MicroPython_BUILD/firmware/esp32_all/MicroPython.bin differ
diff --git a/MicroPython_BUILD/firmware/esp32_all/bootloader/bootloader.bin b/MicroPython_BUILD/firmware/esp32_all/bootloader/bootloader.bin
index e6ed412..bd29813 100644
Binary files a/MicroPython_BUILD/firmware/esp32_all/bootloader/bootloader.bin and b/MicroPython_BUILD/firmware/esp32_all/bootloader/bootloader.bin differ
diff --git a/MicroPython_BUILD/firmware/esp32_ota/MicroPython.bin b/MicroPython_BUILD/firmware/esp32_ota/MicroPython.bin
index 76cfb6d..06913c5 100644
Binary files a/MicroPython_BUILD/firmware/esp32_ota/MicroPython.bin and b/MicroPython_BUILD/firmware/esp32_ota/MicroPython.bin differ
diff --git a/MicroPython_BUILD/firmware/esp32_ota/bootloader/bootloader.bin b/MicroPython_BUILD/firmware/esp32_ota/bootloader/bootloader.bin
index d1700d6..56f14b8 100644
Binary files a/MicroPython_BUILD/firmware/esp32_ota/bootloader/bootloader.bin and b/MicroPython_BUILD/firmware/esp32_ota/bootloader/bootloader.bin differ
diff --git a/MicroPython_BUILD/firmware/esp32_psram/MicroPython.bin b/MicroPython_BUILD/firmware/esp32_psram/MicroPython.bin
index f771ecd..e983acf 100644
Binary files a/MicroPython_BUILD/firmware/esp32_psram/MicroPython.bin and b/MicroPython_BUILD/firmware/esp32_psram/MicroPython.bin differ
diff --git a/MicroPython_BUILD/firmware/esp32_psram/bootloader/bootloader.bin b/MicroPython_BUILD/firmware/esp32_psram/bootloader/bootloader.bin
index 9fcc15d..2bd4f7e 100644
Binary files a/MicroPython_BUILD/firmware/esp32_psram/bootloader/bootloader.bin and b/MicroPython_BUILD/firmware/esp32_psram/bootloader/bootloader.bin differ
diff --git a/MicroPython_BUILD/firmware/esp32_psram_all/MicroPython.bin b/MicroPython_BUILD/firmware/esp32_psram_all/MicroPython.bin
index 77c5848..33d68ad 100644
Binary files a/MicroPython_BUILD/firmware/esp32_psram_all/MicroPython.bin and b/MicroPython_BUILD/firmware/esp32_psram_all/MicroPython.bin differ
diff --git a/MicroPython_BUILD/firmware/esp32_psram_all/bootloader/bootloader.bin b/MicroPython_BUILD/firmware/esp32_psram_all/bootloader/bootloader.bin
index 3431080..fa67fca 100644
Binary files a/MicroPython_BUILD/firmware/esp32_psram_all/bootloader/bootloader.bin and b/MicroPython_BUILD/firmware/esp32_psram_all/bootloader/bootloader.bin differ
diff --git a/MicroPython_BUILD/firmware/esp32_psram_ota/MicroPython.bin b/MicroPython_BUILD/firmware/esp32_psram_ota/MicroPython.bin
index e01db9a..f5cf186 100644
Binary files a/MicroPython_BUILD/firmware/esp32_psram_ota/MicroPython.bin and b/MicroPython_BUILD/firmware/esp32_psram_ota/MicroPython.bin differ
diff --git a/MicroPython_BUILD/firmware/esp32_psram_ota/bootloader/bootloader.bin b/MicroPython_BUILD/firmware/esp32_psram_ota/bootloader/bootloader.bin
index e4a753b..270e49f 100644
Binary files a/MicroPython_BUILD/firmware/esp32_psram_ota/bootloader/bootloader.bin and b/MicroPython_BUILD/firmware/esp32_psram_ota/bootloader/bootloader.bin differ