First working test of UART modifications. These modifications:

* Use Shared interrupt
* Handle Each UART individually
* Support Queue Length of 0, which means only use FiFo's as buffers
* Support CPU frequency changes.
* Fix Memory leak in Debug Log code
* increase concurrency between receiving data and it appearing in Queue
* return -1 when queue/fifo empty on read/peek
* Support changing baudrate without disburbing Queue content
* Add logic to powerdown peripheral and Fifo memory when ports are closed.
* disable rx_fifo_full when Queue is full

Author: stickbreaker

cores/esp32/HardwareSerial.cpp

@@ -28,7 +28,7 @@ HardwareSerial Serial1(1);
 HardwareSerial Serial2(2);
 #endif
 
-HardwareSerial::HardwareSerial(int uart_nr) : _uart_nr(uart_nr), _uart(NULL) {}
+HardwareSerial::HardwareSerial(int uart_nr) : _uart_nr(uart_nr), _uart(NULL), _baud(0), _rx_pin(-1), _tx_pin(-1) {}
 
 void HardwareSerial::begin(unsigned long baud, uint32_t config, int8_t rxPin, int8_t txPin, bool invert, unsigned long timeout_ms)
 {
@@ -52,23 +52,29 @@ void HardwareSerial::begin(unsigned long baud, uint32_t config, int8_t rxPin, in
         txPin = TX2;
     }
 
-    _uart = uartBegin(_uart_nr, baud ? baud : 9600, config, rxPin, txPin, 256, invert);
-
-    if(!baud) {
-        time_t startMillis = millis();
-        unsigned long detectedBaudRate = 0;
-        while(millis() - startMillis < timeout_ms && !(detectedBaudRate = uartDetectBaudrate(_uart))) {
-            yield();
-        }
-
-        end();
-
-        if(detectedBaudRate) {
-            delay(100); // Give some time...
-            _uart = uartBegin(_uart_nr, detectedBaudRate, config, rxPin, txPin, 256, invert);
-        } else {
-            log_e("Could not detect baudrate. Serial data at the port must be present within the timeout for detection to be possible");
-            _uart = NULL;
+    if((_uart != NULL)&&(rxPin == _rx_pin)&&( txPin == _tx_pin)&&(baud !=0)){ // just change baud rate, 
+        uartSetBaudRate(_uart,baud);
+        log_i("begin set baud only");
+    } else { // completely reconfigure
+        _uart = uartBegin(_uart_nr, baud ? baud : 9600, config, rxPin, txPin, 256, invert);
+ //       log_i("Init Uart[%d] baud=%d, rx=%d, tx=%d",_uart_nr,baud,rxPin,txPin);
+        
+        if(!baud) {
+            time_t startMillis = millis();
+            unsigned long detectedBaudRate = 0;
+            while(millis() - startMillis < timeout_ms && !(detectedBaudRate = uartDetectBaudrate(_uart))) {
+                yield();
+            }
+
+            end();
+
+            if(detectedBaudRate) {
+                delay(100); // Give some time...
+                _uart = uartBegin(_uart_nr, detectedBaudRate, config, rxPin, txPin, 256, invert);
+            } else {
+                log_e("Could not detect baudrate. Serial data at the port must be present within the timeout for detection to be possible");
+                _uart = NULL;
+            }
         }
     }
 }
@@ -79,7 +85,7 @@ void HardwareSerial::end()
         uartSetDebug(0);
     }
     uartEnd(_uart);
-    _uart = 0;
+    _uart = NULL;
 }
 
 size_t HardwareSerial::setRxBufferSize(size_t new_size) {
@@ -111,23 +117,17 @@ int HardwareSerial::availableForWrite(void)
 
 int HardwareSerial::peek(void)
 {
-    if (available()) {
-        return uartPeek(_uart);
-    }
-    return -1;
+    return uartPeek(_uart);
 }
 
 int HardwareSerial::read(void)
 {
-    if(available()) {
-        return uartRead(_uart);
-    }
-    return -1;
+    return uartRead(_uart);
 }
 
 void HardwareSerial::flush()
 {
-    uartFlush(_uart);
+    uartDrain(_uart);
 }
 
 size_t HardwareSerial::write(uint8_t c)
@@ -141,11 +141,12 @@ size_t HardwareSerial::write(const uint8_t *buffer, size_t size)
     uartWriteBuf(_uart, buffer, size);
     return size;
 }
-uint32_t  HardwareSerial::baudRate()
 
+uint32_t  HardwareSerial::baudRate()
 {
 	return uartGetBaudRate(_uart);
 }
+
 HardwareSerial::operator bool() const
 {
     return true;

cores/esp32/HardwareSerial.h

@@ -94,6 +94,9 @@ class HardwareSerial: public Stream
 protected:
     int _uart_nr;
     uart_t* _uart;
+    uint32_t _baud;
+    int _rx_pin;
+    int _tx_pin;
 };
 
 #if !defined(NO_GLOBAL_INSTANCES) && !defined(NO_GLOBAL_SERIAL)

cores/esp32/esp32-hal-misc.c

@@ -21,8 +21,13 @@
 #include "esp_partition.h"
 #include "esp_log.h"
 #include "esp_timer.h"
+#ifdef CONFIG_BT_ENABLED
 #include "esp_bt.h"
+#endif //CONFIG_BT_ENABLED
 #include <sys/time.h>
+#include "soc/rtc.h"
+#include "soc/rtc_cntl_reg.h"
+#include "rom/rtc.h"
 #include "esp32-hal.h"
 
 //Undocumented!!! Get chip temperature in Farenheit
@@ -39,19 +44,57 @@ void yield()
     vPortYield();
 }
 
+static uint32_t _cpu_freq_mhz = CONFIG_ESP32_DEFAULT_CPU_FREQ_MHZ;
+static uint32_t _sys_time_multiplier = 1;
+
+bool setCpuFrequency(uint32_t cpu_freq_mhz){
+    rtc_cpu_freq_config_t conf, cconf;
+    rtc_clk_cpu_freq_get_config(&cconf);
+    if(cconf.freq_mhz == cpu_freq_mhz && _cpu_freq_mhz == cpu_freq_mhz){
+        return true;
+    }
+    if(!rtc_clk_cpu_freq_mhz_to_config(cpu_freq_mhz, &conf)){
+        log_e("CPU clock could not be set to %u MHz", cpu_freq_mhz);
+        return false;
+    }
+#if ARDUHAL_LOG_LEVEL >= ARDUHAL_LOG_LEVEL_INFO
+    log_i("%s: %u / %u = %u Mhz", (conf.source == RTC_CPU_FREQ_SRC_PLL)?"PLL":((conf.source == RTC_CPU_FREQ_SRC_APLL)?"APLL":((conf.source == RTC_CPU_FREQ_SRC_XTAL)?"XTAL":"8M")), conf.source_freq_mhz, conf.div, conf.freq_mhz);
+    delay(300);
+#endif
+    rtc_clk_cpu_freq_set_config_fast(&conf);
+    _cpu_freq_mhz = conf.freq_mhz;
+    _sys_time_multiplier = 80 / getApbFrequency();
+    return true;
+}
+
+uint32_t getCpuFrequency(){
+    rtc_cpu_freq_config_t conf;
+    rtc_clk_cpu_freq_get_config(&conf);
+    return conf.freq_mhz;
+}
+
+uint32_t getApbFrequency(){
+    rtc_cpu_freq_config_t conf;
+    rtc_clk_cpu_freq_get_config(&conf);
+    if(conf.freq_mhz >= 80){
+        return 80000000;
+    }
+    return (conf.source_freq_mhz * 1000000) / conf.div;
+}
+
 unsigned long IRAM_ATTR micros()
 {
-    return (unsigned long) esp_timer_get_time();
+    return (unsigned long) (esp_timer_get_time()) * _sys_time_multiplier;
 }
 
 unsigned long IRAM_ATTR millis()
 {
-    return (unsigned long) (esp_timer_get_time() / 1000);
+    return (unsigned long) (micros() / 1000);
 }
 
 void delay(uint32_t ms)
 {
-    vTaskDelay(ms / portTICK_PERIOD_MS);
+    vTaskDelay((ms * _cpu_freq_mhz) / (portTICK_PERIOD_MS * 240));
 }
 
 void IRAM_ATTR delayMicroseconds(uint32_t us)
@@ -84,6 +127,9 @@ bool btInUse(){ return false; }
 
 void initArduino()
 {
+#ifdef F_CPU
+    setCpuFrequency(F_CPU/1000000L);
+#endif
 #if CONFIG_SPIRAM_SUPPORT
     psramInit();
 #endif