Add analogRead, touchRead, dacWrite and updated esp-idf

cores/esp32/esp32-hal-adc.c

+// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "esp32-hal-adc.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "rom/ets_sys.h"
+#include "esp_attr.h"
+#include "esp_intr.h"
+#include "soc/rtc_io_reg.h"
+#include "soc/rtc_cntl_reg.h"
+#include "soc/sens_reg.h"
+
+static uint8_t __analogAttenuation = 0;//0db
+static uint8_t __analogWidth = 3;//12 bits
+static uint8_t __analogCycles = 8;
+static uint8_t __analogSamples = 0;//1 sample
+static uint8_t __analogClockDiv = 1;
+
+void __analogSetWidth(uint8_t bits){
+    if(bits < 9){
+        bits = 9;
+    } else if(bits > 12){
+        bits = 12;
+    }
+    __analogWidth = bits - 9;
+    SET_PERI_REG_BITS(SENS_SAR_START_FORCE_REG, SENS_SAR1_BIT_WIDTH, __analogWidth, SENS_SAR1_BIT_WIDTH_S);
+    SET_PERI_REG_BITS(SENS_SAR_READ_CTRL_REG, SENS_SAR1_SAMPLE_BIT, __analogWidth, SENS_SAR1_SAMPLE_BIT_S);
+
+    SET_PERI_REG_BITS(SENS_SAR_START_FORCE_REG, SENS_SAR2_BIT_WIDTH, __analogWidth, SENS_SAR2_BIT_WIDTH_S);
+    SET_PERI_REG_BITS(SENS_SAR_READ_CTRL2_REG, SENS_SAR2_SAMPLE_BIT, __analogWidth, SENS_SAR2_SAMPLE_BIT_S);
+}
+
+void __analogSetCycles(uint8_t cycles){
+    __analogCycles = cycles;
+    SET_PERI_REG_BITS(SENS_SAR_READ_CTRL_REG, SENS_SAR1_SAMPLE_CYCLE, __analogCycles, SENS_SAR1_SAMPLE_CYCLE_S);
+    SET_PERI_REG_BITS(SENS_SAR_READ_CTRL2_REG, SENS_SAR2_SAMPLE_CYCLE, __analogCycles, SENS_SAR2_SAMPLE_CYCLE_S);
+}
+
+void __analogSetSamples(uint8_t samples){
+    if(!samples){
+        return;
+    }
+    __analogSamples = samples - 1;
+    SET_PERI_REG_BITS(SENS_SAR_READ_CTRL_REG, SENS_SAR1_SAMPLE_NUM, __analogSamples, SENS_SAR1_SAMPLE_NUM_S);
+    SET_PERI_REG_BITS(SENS_SAR_READ_CTRL2_REG, SENS_SAR2_SAMPLE_NUM, __analogSamples, SENS_SAR2_SAMPLE_NUM_S);
+}
+
+void __analogSetClockDiv(uint8_t clockDiv){
+    if(!clockDiv){
+        return;
+    }
+    __analogClockDiv = clockDiv;
+    SET_PERI_REG_BITS(SENS_SAR_READ_CTRL_REG, SENS_SAR1_CLK_DIV, __analogClockDiv, SENS_SAR1_CLK_DIV_S);
+    SET_PERI_REG_BITS(SENS_SAR_READ_CTRL2_REG, SENS_SAR2_CLK_DIV, __analogClockDiv, SENS_SAR2_CLK_DIV_S);
+}
+
+void __analogSetAttenuation(uint8_t attenuation){
+    __analogAttenuation = attenuation & 3;
+    uint32_t att_data = 0;
+    int i = 8;
+    while(i--){
+        att_data |= __analogAttenuation << (i * 2);
+    }
+    SET_PERI_REG_BITS(SENS_SAR_MEAS_START1_REG, SENS_MEAS1_DATA_SAR, att_data, SENS_MEAS1_DATA_SAR_S);
+    SET_PERI_REG_BITS(SENS_SAR_MEAS_START2_REG, SENS_MEAS2_DATA_SAR, att_data, SENS_MEAS2_DATA_SAR_S);
+}
+
+void IRAM_ATTR __analogInit(){
+    static bool initialized = false;
+    if(initialized){
+        return;
+    }
+    __analogSetAttenuation(__analogAttenuation);
+    __analogSetCycles(__analogCycles);
+    __analogSetSamples(__analogSamples + 1);//in samples
+    __analogSetClockDiv(__analogClockDiv);
+    __analogSetWidth(__analogWidth + 9);//in bits
+
+    SET_PERI_REG_MASK(SENS_SAR_READ_CTRL_REG, SENS_SAR1_DATA_INV);
+    SET_PERI_REG_MASK(SENS_SAR_READ_CTRL2_REG, SENS_SAR2_DATA_INV);
+
+    SET_PERI_REG_MASK(SENS_SAR_MEAS_START1_REG, SENS_MEAS1_START_FORCE_M); //SAR ADC1 controller (in RTC) is started by SW
+    SET_PERI_REG_MASK(SENS_SAR_MEAS_START1_REG, SENS_SAR1_EN_PAD_FORCE_M); //SAR ADC1 pad enable bitmap is controlled by SW
+    SET_PERI_REG_MASK(SENS_SAR_MEAS_START2_REG, SENS_MEAS2_START_FORCE_M); //SAR ADC2 controller (in RTC) is started by SW
+    SET_PERI_REG_MASK(SENS_SAR_MEAS_START2_REG, SENS_SAR2_EN_PAD_FORCE_M); //SAR ADC2 pad enable bitmap is controlled by SW
+
+    CLEAR_PERI_REG_MASK(SENS_SAR_MEAS_WAIT2_REG, SENS_FORCE_XPD_SAR_M); //force XPD_SAR=0, use XPD_FSM
+    SET_PERI_REG_BITS(SENS_SAR_MEAS_WAIT2_REG, SENS_FORCE_XPD_AMP, 0x2, SENS_FORCE_XPD_AMP_S); //force XPD_AMP=0
+
+    CLEAR_PERI_REG_MASK(SENS_SAR_MEAS_CTRL_REG, 0xfff << SENS_AMP_RST_FB_FSM_S);  //clear FSM
+    SET_PERI_REG_BITS(SENS_SAR_MEAS_WAIT1_REG, SENS_SAR_AMP_WAIT1, 0x1, SENS_SAR_AMP_WAIT1_S);
+    SET_PERI_REG_BITS(SENS_SAR_MEAS_WAIT1_REG, SENS_SAR_AMP_WAIT2, 0x1, SENS_SAR_AMP_WAIT2_S);
+    SET_PERI_REG_BITS(SENS_SAR_MEAS_WAIT2_REG, SENS_SAR_AMP_WAIT3, 0x1, SENS_SAR_AMP_WAIT3_S);
+    while (GET_PERI_REG_BITS2(SENS_SAR_SLAVE_ADDR1_REG, 0x7, SENS_MEAS_STATUS_S) != 0); //wait det_fsm==
+
+    initialized = true;
+}
+
+uint16_t IRAM_ATTR __analogRead(uint8_t pin)
+{
+    int8_t channel = digitalPinToAnalogChannel(pin);
+    if(channel < 0){
+        return 0;//not adc pin
+    }
+    int8_t pad = digitalPinToTouchChannel(pin);
+
+    if(pad >= 0){
+        uint32_t touch = READ_PERI_REG(SENS_SAR_TOUCH_ENABLE_REG);
+        if(touch & (1 << pad)){
+            touch &= ~((1 << (pad + SENS_TOUCH_PAD_OUTEN2_S))
+                    | (1 << (pad + SENS_TOUCH_PAD_OUTEN1_S))
+                    | (1 << (pad + SENS_TOUCH_PAD_WORKEN_S)));
+            WRITE_PERI_REG(SENS_SAR_TOUCH_ENABLE_REG, touch);
+        }
+    } else if(pin == 25){
+        CLEAR_PERI_REG_MASK(RTC_IO_PAD_DAC1_REG, RTC_IO_PDAC1_XPD_DAC | RTC_IO_PDAC1_DAC_XPD_FORCE);//stop dac1
+    } else if(pin == 26){
+        CLEAR_PERI_REG_MASK(RTC_IO_PAD_DAC2_REG, RTC_IO_PDAC2_XPD_DAC | RTC_IO_PDAC2_DAC_XPD_FORCE);//stop dac2
+    }
+
+    pinMode(pin, ANALOG);
+
+    __analogInit();
+
+    if(channel > 7){
+        channel -= 10;
+
+        SET_PERI_REG_BITS(SENS_SAR_MEAS_START2_REG, SENS_SAR2_EN_PAD, (1 << channel), SENS_SAR2_EN_PAD_S);
+        CLEAR_PERI_REG_MASK(SENS_SAR_MEAS_START2_REG, SENS_MEAS2_START_SAR_M);
+        SET_PERI_REG_MASK(SENS_SAR_MEAS_START2_REG, SENS_MEAS2_START_SAR_M);
+        while (GET_PERI_REG_MASK(SENS_SAR_MEAS_START2_REG, SENS_MEAS2_DONE_SAR) == 0) {}; //read done
+        return GET_PERI_REG_BITS2(SENS_SAR_MEAS_START2_REG, SENS_MEAS2_DATA_SAR, SENS_MEAS2_DATA_SAR_S);
+    }
+
+    SET_PERI_REG_BITS(SENS_SAR_MEAS_START1_REG, SENS_SAR1_EN_PAD, (1 << channel), SENS_SAR1_EN_PAD_S);
+    CLEAR_PERI_REG_MASK(SENS_SAR_MEAS_START1_REG, SENS_MEAS1_START_SAR_M);
+    SET_PERI_REG_MASK(SENS_SAR_MEAS_START1_REG, SENS_MEAS1_START_SAR_M);
+    while (GET_PERI_REG_MASK(SENS_SAR_MEAS_START1_REG, SENS_MEAS1_DONE_SAR) == 0) {}; //read done
+    return GET_PERI_REG_BITS2(SENS_SAR_MEAS_START1_REG, SENS_MEAS1_DATA_SAR, SENS_MEAS1_DATA_SAR_S);
+}
+int __hallRead()    //hall sensor without LNA
+{
+    int Sens_Vp0;
+    int Sens_Vn0;
+    int Sens_Vp1;
+    int Sens_Vn1;
+
+    pinMode(36, ANALOG);
+    pinMode(39, ANALOG);
+    SET_PERI_REG_MASK(SENS_SAR_TOUCH_CTRL1_REG, SENS_XPD_HALL_FORCE_M);     // hall sens force enable
+    SET_PERI_REG_MASK(RTC_IO_HALL_SENS_REG, RTC_IO_XPD_HALL);               // xpd hall
+    SET_PERI_REG_MASK(SENS_SAR_TOUCH_CTRL1_REG, SENS_HALL_PHASE_FORCE_M);   // phase force
+    CLEAR_PERI_REG_MASK(RTC_IO_HALL_SENS_REG, RTC_IO_HALL_PHASE);           // hall phase
+    Sens_Vp0 = __analogRead(36);
+    Sens_Vn0 = __analogRead(39);
+    SET_PERI_REG_MASK(RTC_IO_HALL_SENS_REG, RTC_IO_HALL_PHASE);
+    Sens_Vp1 = __analogRead(36);
+    Sens_Vn1 = __analogRead(39);
+    SET_PERI_REG_BITS(SENS_SAR_MEAS_WAIT2_REG, SENS_FORCE_XPD_SAR, 0, SENS_FORCE_XPD_SAR_S);
+    CLEAR_PERI_REG_MASK(SENS_SAR_TOUCH_CTRL1_REG, SENS_XPD_HALL_FORCE);
+    CLEAR_PERI_REG_MASK(SENS_SAR_TOUCH_CTRL1_REG, SENS_HALL_PHASE_FORCE);
+    return (Sens_Vp1 - Sens_Vp0) - (Sens_Vn1 - Sens_Vn0);
+}
+
+extern uint16_t analogRead(uint8_t pin) __attribute__ ((weak, alias("__analogRead")));
+extern void analogSetWidth(uint8_t bits) __attribute__ ((weak, alias("__analogSetWidth")));
+extern void analogSetCycles(uint8_t cycles) __attribute__ ((weak, alias("__analogSetCycles")));
+extern void analogSetSamples(uint8_t samples) __attribute__ ((weak, alias("__analogSetSamples")));
+extern void analogSetClockDiv(uint8_t clockDiv) __attribute__ ((weak, alias("__analogSetClockDiv")));
+//extern void analogSetAttenuation(uint8_t attenuation) __attribute__ ((weak, alias("__analogSetAttenuation")));
+extern int hallRead() __attribute__ ((weak, alias("__hallRead")));

cores/esp32/esp32-hal-adc.h

+/*
+ Arduino.h - Main include file for the Arduino SDK
+ Copyright (c) 2005-2013 Arduino Team.  All right reserved.
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifndef MAIN_ESP32_HAL_ADC_H_
+#define MAIN_ESP32_HAL_ADC_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "esp32-hal.h"
+
+/*
+ * Get ADC value for pin
+ * */
+uint16_t analogRead(uint8_t pin);
+
+/*
+ * Sets the sample bits (9 - 12)
+ * */
+void analogSetWidth(uint8_t bits);
+
+/*
+ * Set number of cycles per sample
+ * Default is 8 and seems to do well
+ * Range is 1 - 255
+ * */
+void analogSetCycles(uint8_t cycles);
+
+/*
+ * Set number of samples in the range.
+ * Default is 1
+ * Range is 1 - 255
+ * This setting splits the range into
+ * "samples" pieces, which could look
+ * like the sensitivity has been multiplied
+ * that many times
+ * */
+void analogSetSamples(uint8_t samples);
+
+/*
+ * Set the divider for the ADC clock.
+ * Default is 1
+ * Range is 1 - 255
+ * */
+void analogSetClockDiv(uint8_t clockDiv);
+
+/*
+ * Get value for HALL sensor (without LNA)
+ * connected to pins 36(SVP) and 39(SVN)
+ * */
+int hallRead();
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* MAIN_ESP32_HAL_ADC_H_ */

cores/esp32/esp32-hal-dac.c

+// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "esp32-hal-dac.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "rom/ets_sys.h"
+#include "esp_attr.h"
+#include "esp_intr.h"
+#include "soc/rtc_io_reg.h"
+#include "soc/rtc_cntl_reg.h"
+#include "soc/sens_reg.h"
+
+void IRAM_ATTR __dacWrite(uint8_t pin, uint8_t value)
+{
+    if(pin < 25 || pin > 26){
+        return;//not dac pin
+    }
+    pinMode(pin, ANALOG);
+    uint8_t channel = pin - 25;
+
+
+    //Disable Tone
+    CLEAR_PERI_REG_MASK(SENS_SAR_DAC_CTRL1_REG, SENS_SW_TONE_EN);
+
+    if (channel) {
+        //Disable Channel Tone
+        CLEAR_PERI_REG_MASK(SENS_SAR_DAC_CTRL2_REG, SENS_DAC_CW_EN2_M);
+        //Set the Dac value
+        SET_PERI_REG_BITS(RTC_IO_PAD_DAC2_REG, RTC_IO_PDAC2_DAC, value, RTC_IO_PDAC2_DAC_S);   //dac_output
+        //Channel output enable
+        SET_PERI_REG_MASK(RTC_IO_PAD_DAC2_REG, RTC_IO_PDAC2_XPD_DAC | RTC_IO_PDAC2_DAC_XPD_FORCE);
+    } else {
+        //Disable Channel Tone
+        CLEAR_PERI_REG_MASK(SENS_SAR_DAC_CTRL2_REG, SENS_DAC_CW_EN1_M);
+        //Set the Dac value
+        SET_PERI_REG_BITS(RTC_IO_PAD_DAC1_REG, RTC_IO_PDAC1_DAC, value, RTC_IO_PDAC1_DAC_S);   //dac_output
+        //Channel output enable
+        SET_PERI_REG_MASK(RTC_IO_PAD_DAC1_REG, RTC_IO_PDAC1_XPD_DAC | RTC_IO_PDAC1_DAC_XPD_FORCE);
+    }
+}
+
+extern void dacWrite(uint8_t pin, uint8_t value) __attribute__ ((weak, alias("__dacWrite")));

cores/esp32/esp32-hal-dac.h

+/*
+ Arduino.h - Main include file for the Arduino SDK
+ Copyright (c) 2005-2013 Arduino Team.  All right reserved.
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifndef MAIN_ESP32_HAL_DAC_H_
+#define MAIN_ESP32_HAL_DAC_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "esp32-hal.h"
+
+void dacWrite(uint8_t pin, uint8_t value);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* MAIN_ESP32_HAL_DAC_H_ */

cores/esp32/esp32-hal-gpio.c

@@ -26,69 +26,97 @@
 
 #define ETS_GPIO_INUM       4
 
-typedef struct {
-    uint32_t mux;       /*!< Register to modify various pin settings */
-    uint32_t pud;       /*!< Register to modify to enable or disable pullups or pulldowns */
-    uint32_t pu;        /*!< Bit to set or clear in the above register to enable or disable the pullup, respectively */
-    uint32_t pd;        /*!< Bit to set or clear in the above register to enable or disable the pulldown, respectively */
-} esp32_gpioMux_t;
-
 const DRAM_ATTR esp32_gpioMux_t esp32_gpioMux[GPIO_PIN_COUNT]={
-    {DR_REG_IO_MUX_BASE + 0x44, RTC_IO_TOUCH_PAD1_REG, RTC_IO_TOUCH_PAD1_RUE_M, RTC_IO_TOUCH_PAD1_RDE_M},
-    {DR_REG_IO_MUX_BASE + 0x88, 0, 0, 0},
-    {DR_REG_IO_MUX_BASE + 0x40, RTC_IO_TOUCH_PAD2_REG, RTC_IO_TOUCH_PAD2_RUE_M, RTC_IO_TOUCH_PAD2_RDE_M},
-    {DR_REG_IO_MUX_BASE + 0x84, 0, 0, 0},
-    {DR_REG_IO_MUX_BASE + 0x48, RTC_IO_TOUCH_PAD0_REG, RTC_IO_TOUCH_PAD0_RUE_M, RTC_IO_TOUCH_PAD0_RDE_M},
-    {DR_REG_IO_MUX_BASE + 0x6c, 0, 0, 0},
-    {DR_REG_IO_MUX_BASE + 0x60, 0, 0, 0},
-    {DR_REG_IO_MUX_BASE + 0x64, 0, 0, 0},
-    {DR_REG_IO_MUX_BASE + 0x68, 0, 0, 0},
-    {DR_REG_IO_MUX_BASE + 0x54, 0, 0, 0},
-    {DR_REG_IO_MUX_BASE + 0x58, 0, 0, 0},
-    {DR_REG_IO_MUX_BASE + 0x5c, 0, 0, 0},
-    {DR_REG_IO_MUX_BASE + 0x34, RTC_IO_TOUCH_PAD5_REG, RTC_IO_TOUCH_PAD5_RUE_M, RTC_IO_TOUCH_PAD5_RDE_M},
-    {DR_REG_IO_MUX_BASE + 0x38, RTC_IO_TOUCH_PAD4_REG, RTC_IO_TOUCH_PAD4_RUE_M, RTC_IO_TOUCH_PAD4_RDE_M},
-    {DR_REG_IO_MUX_BASE + 0x30, RTC_IO_TOUCH_PAD6_REG, RTC_IO_TOUCH_PAD6_RUE_M, RTC_IO_TOUCH_PAD6_RDE_M},
-    {DR_REG_IO_MUX_BASE + 0x3c, RTC_IO_TOUCH_PAD3_REG, RTC_IO_TOUCH_PAD3_RUE_M, RTC_IO_TOUCH_PAD3_RDE_M},
-    {DR_REG_IO_MUX_BASE + 0x4c, 0, 0, 0},
-    {DR_REG_IO_MUX_BASE + 0x50, 0, 0, 0},
-    {DR_REG_IO_MUX_BASE + 0x70, 0, 0, 0},
-    {DR_REG_IO_MUX_BASE + 0x74, 0, 0, 0},
-    {DR_REG_IO_MUX_BASE + 0x78, 0, 0, 0},
-    {DR_REG_IO_MUX_BASE + 0x7c, 0, 0, 0},
-    {DR_REG_IO_MUX_BASE + 0x80, 0, 0, 0},
-    {DR_REG_IO_MUX_BASE + 0x8c, 0, 0, 0},
-    {0, 0, 0, 0},
-    {DR_REG_IO_MUX_BASE + 0x24, RTC_IO_PAD_DAC1_REG, RTC_IO_PDAC1_RUE_M, RTC_IO_PDAC1_RDE_M},
-    {DR_REG_IO_MUX_BASE + 0x28, RTC_IO_PAD_DAC2_REG, RTC_IO_PDAC2_RUE_M, RTC_IO_PDAC2_RDE_M},
-    {DR_REG_IO_MUX_BASE + 0x2c, RTC_IO_TOUCH_PAD7_REG, RTC_IO_TOUCH_PAD7_RUE_M, RTC_IO_TOUCH_PAD7_RDE_M},
-    {0, 0, 0, 0},
-    {0, 0, 0, 0},
-    {0, 0, 0, 0},
-    {0, 0, 0, 0},
-    {DR_REG_IO_MUX_BASE + 0x1c, RTC_IO_XTAL_32K_PAD_REG, RTC_IO_X32P_RUE_M, RTC_IO_X32P_RDE_M},
-    {DR_REG_IO_MUX_BASE + 0x20, RTC_IO_XTAL_32K_PAD_REG, RTC_IO_X32N_RUE_M, RTC_IO_X32N_RDE_M},
-    {DR_REG_IO_MUX_BASE + 0x14, 0, 0, 0},
-    {DR_REG_IO_MUX_BASE + 0x18, 0, 0, 0},
-    {DR_REG_IO_MUX_BASE + 0x04, 0, 0, 0},
-    {DR_REG_IO_MUX_BASE + 0x08, 0, 0, 0},
-    {DR_REG_IO_MUX_BASE + 0x0c, 0, 0, 0},
-    {DR_REG_IO_MUX_BASE + 0x10, 0, 0, 0}
+    {0x44, 11, 11, 1},
+    {0x88, -1, -1, -1},
+    {0x40, 12, 12, 2},
+    {0x84, -1, -1, -1},
+    {0x48, 10, 10, 0},
+    {0x6c, -1, -1, -1},
+    {0x60, -1, -1, -1},
+    {0x64, -1, -1, -1},
+    {0x68, -1, -1, -1},
+    {0x54, -1, -1, -1},
+    {0x58, -1, -1, -1},
+    {0x5c, -1, -1, -1},
+    {0x34, 15, 15, 5},
+    {0x38, 14, 14, 4},
+    {0x30, 16, 16, 6},
+    {0x3c, 13, 13, 3},
+    {0x4c, -1, -1, -1},
+    {0x50, -1, -1, -1},
+    {0x70, -1, -1, -1},
+    {0x74, -1, -1, -1},
+    {0x78, -1, -1, -1},
+    {0x7c, -1, -1, -1},
+    {0x80, -1, -1, -1},
+    {0x8c, -1, -1, -1},
+    {0, -1, -1, -1},
+    {0x24, 6, 18, -1}, //DAC1
+    {0x28, 7, 19, -1}, //DAC2
+    {0x2c, 17, 17, 7},
+    {0, -1, -1, -1},
+    {0, -1, -1, -1},
+    {0, -1, -1, -1},
+    {0, -1, -1, -1},
+    {0x1c, 9, 4, 9},
+    {0x20, 8, 5, 8},
+    {0x14, 4, 6, -1},
+    {0x18, 5, 7, -1},
+    {0x04, 0, 0, -1},
+    {0x08, 1, -1, -1},
+    {0x0c, 2, -1, -1},
+    {0x10, 3, 3, -1}
 };
 
 typedef void (*voidFuncPtr)(void);
 static voidFuncPtr __pinInterruptHandlers[GPIO_PIN_COUNT] = {0,};
 
+#include "driver/rtc_io.h"
+
 extern void IRAM_ATTR __pinMode(uint8_t pin, uint8_t mode)
 {
 
-    if(pin > 39 || !esp32_gpioMux[pin].mux) {
+    if(!digitalPinIsValid(pin)) {
         return;
     }
 
+    uint32_t rtc_reg = rtc_gpio_desc[pin].reg;
+    if(mode == ANALOG) {
+        if(!rtc_reg) {
+            return;//not rtc pin
+        }
+        //lock rtc
+        uint32_t reg_val = ESP_REG(rtc_reg);
+        if(reg_val & rtc_gpio_desc[pin].mux){
+            return;//already in adc mode
+        }
+        reg_val &= ~(
+                (RTC_IO_TOUCH_PAD1_FUN_SEL_V << rtc_gpio_desc[pin].func)
+                |rtc_gpio_desc[pin].ie
+                |rtc_gpio_desc[pin].pullup
+                |rtc_gpio_desc[pin].pulldown);
+        ESP_REG(RTC_GPIO_ENABLE_W1TC_REG) = (1 << (rtc_gpio_desc[pin].rtc_num + RTC_GPIO_ENABLE_W1TC_S));
+        ESP_REG(rtc_reg) = reg_val | rtc_gpio_desc[pin].mux;
+        //unlock rtc
+        ESP_REG(DR_REG_IO_MUX_BASE + esp32_gpioMux[pin].reg) = ((uint32_t)2 << MCU_SEL_S) | ((uint32_t)2 << FUN_DRV_S) | FUN_IE;
+        return;
+    } else if(rtc_reg) {
+        //lock rtc
+        ESP_REG(rtc_reg) = ESP_REG(rtc_reg) & ~(rtc_gpio_desc[pin].mux);
+        if(mode & PULLUP) {
+            ESP_REG(rtc_reg) = (ESP_REG(rtc_reg) | rtc_gpio_desc[pin].pullup) & ~(rtc_gpio_desc[pin].pulldown);
+        } else if(mode & PULLDOWN) {
+            ESP_REG(rtc_reg) = (ESP_REG(rtc_reg) | rtc_gpio_desc[pin].pulldown) & ~(rtc_gpio_desc[pin].pullup);
+        } else {
+            ESP_REG(rtc_reg) = ESP_REG(rtc_reg) & ~(rtc_gpio_desc[pin].pullup | rtc_gpio_desc[pin].pulldown);
+        }
+        //unlock rtc
+    }
+
     uint32_t pinFunction = 0, pinControl = 0;
-    const esp32_gpioMux_t * mux = &esp32_gpioMux[pin];
 
+    //lock gpio
     if(mode & INPUT) {
         if(pin < 32) {
             GPIO.enable_w1tc = ((uint32_t)1 << pin);
@@ -102,7 +130,10 @@ extern void IRAM_ATTR __pinMode(uint8_t pin, uint8_t mode)
             pinFunction |= FUN_PD;
         }
     } else if(mode & OUTPUT) {
-        if(pin < 32) {
+        if(pin > 33){
+            //unlock gpio
+            return;//pins above 33 can be only inputs
+        } else if(pin < 32) {
             GPIO.enable_w1ts = ((uint32_t)1 << pin);
         } else {
             GPIO.enable1_w1ts.val = ((uint32_t)1 << (pin - 32));
@@ -120,25 +151,14 @@ extern void IRAM_ATTR __pinMode(uint8_t pin, uint8_t mode)
         pinFunction |= ((uint32_t)(mode >> 5) << MCU_SEL_S);
     }
 
-    ESP_REG(mux->mux) = pinFunction;
-
-    if(mux->pud){
-        if((mode & INPUT) && (mode & (PULLUP|PULLDOWN))) {
-            if(mode & PULLUP) {
-                ESP_REG(mux->pud) = (ESP_REG(mux->pud) | mux->pu) & ~(mux->pd);
-            } else {
-                ESP_REG(mux->pud) = (ESP_REG(mux->pud) | mux->pd) & ~(mux->pu);
-            }
-        } else {
-            ESP_REG(mux->pud) = ESP_REG(mux->pud) & ~(mux->pu | mux->pd);
-        }
-    }
+    ESP_REG(DR_REG_IO_MUX_BASE + esp32_gpioMux[pin].reg) = pinFunction;
 
     if(mode & OPEN_DRAIN) {
         pinControl = (1 << GPIO_PIN0_PAD_DRIVER_S);
     }
 
     GPIO.pin[pin].val = pinControl;
+    //unlock gpio
 }
 
 extern void IRAM_ATTR __digitalWrite(uint8_t pin, uint8_t val)
@@ -146,13 +166,13 @@ extern void IRAM_ATTR __digitalWrite(uint8_t pin, uint8_t val)
     if(val) {
         if(pin < 32) {
             GPIO.out_w1ts = ((uint32_t)1 << pin);
-        } else if(pin < 35) {
+        } else if(pin < 34) {
             GPIO.out1_w1ts.val = ((uint32_t)1 << (pin - 32));
         }
     } else {
         if(pin < 32) {
             GPIO.out_w1tc = ((uint32_t)1 << pin);
-        } else if(pin < 35) {
+        } else if(pin < 34) {
             GPIO.out1_w1tc.val = ((uint32_t)1 << (pin - 32));
         }
     }
@@ -215,6 +235,7 @@ extern void __attachInterrupt(uint8_t pin, voidFuncPtr userFunc, int intr_type)
         ESP_INTR_ENABLE(ETS_GPIO_INUM);
     }
     __pinInterruptHandlers[pin] = userFunc;
+    //lock gpio
     ESP_INTR_DISABLE(ETS_GPIO_INUM);
     if(core_id) { //APP_CPU
         GPIO.pin[pin].int_ena = 1;
@@ -223,15 +244,18 @@ extern void __attachInterrupt(uint8_t pin, voidFuncPtr userFunc, int intr_type)
     }
     GPIO.pin[pin].int_type = intr_type;
     ESP_INTR_ENABLE(ETS_GPIO_INUM);
+    //unlock gpio
 }
 
 extern void __detachInterrupt(uint8_t pin)
 {
-    __pinInterruptHandlers[pin] = NULL;
+    //lock gpio
     ESP_INTR_DISABLE(ETS_GPIO_INUM);
+    __pinInterruptHandlers[pin] = NULL;
     GPIO.pin[pin].int_ena = 0;
     GPIO.pin[pin].int_type = 0;
     ESP_INTR_ENABLE(ETS_GPIO_INUM);
+    //unlock gpio
 }
 
 

cores/esp32/esp32-hal-gpio.h

@@ -39,11 +39,13 @@ extern "C" {
 #define OPEN_DRAIN        0x10
 #define OUTPUT_OPEN_DRAIN 0x12
 #define SPECIAL           0xF0
-#define FUNCTION_0        0x00
-#define FUNCTION_1        0x20
-#define FUNCTION_2        0x40
-#define FUNCTION_3        0x70
-#define FUNCTION_4        0x80
+#define FUNCTION_1        0x00
+#define FUNCTION_2        0x20
+#define FUNCTION_3        0x40
+#define FUNCTION_4        0x60
+#define FUNCTION_5        0x80
+#define FUNCTION_6        0xA0
+#define ANALOG            0xC0
 
 //Interrupt Modes
 #define DISABLED  0x00
@@ -55,6 +57,22 @@ extern "C" {
 #define ONLOW_WE  0x0C
 #define ONHIGH_WE 0x0D
 
+typedef struct {
+    uint8_t reg;      /*!< GPIO register offset from DR_REG_IO_MUX_BASE */
+    int8_t rtc;       /*!< RTC GPIO number (-1 if not RTC GPIO pin) */
+    int8_t adc;       /*!< ADC Channel number (-1 if not ADC pin) */
+    int8_t touch;     /*!< Touch Channel number (-1 if not Touch pin) */
+} esp32_gpioMux_t;
+
+extern const esp32_gpioMux_t esp32_gpioMux[40];
+
+#define digitalPinIsValid(pin)          ((pin) < 40 && esp32_gpioMux[(pin)].reg)
+#define digitalPinCanOutput(pin)        ((pin) < 34 && esp32_gpioMux[(pin)].reg)
+#define digitalPinToRtcPin(pin)         (((pin) < 40)?esp32_gpioMux[(pin)].rtc:-1)
+#define digitalPinToAnalogChannel(pin)  (((pin) < 40)?esp32_gpioMux[(pin)].adc:-1)
+#define digitalPinToTouchChannel(pin)   (((pin) < 40)?esp32_gpioMux[(pin)].touch:-1)
+#define digitalPinToDacChannel(pin)     (((pin) == 25)?0:((pin) == 26)?1:-1)
+
 void pinMode(uint8_t pin, uint8_t mode);
 void digitalWrite(uint8_t pin, uint8_t val);
 int digitalRead(uint8_t pin);

cores/esp32/esp32-hal-touch.c

+// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "esp32-hal-touch.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "rom/ets_sys.h"
+#include "esp_attr.h"
+#include "esp_intr.h"
+#include "soc/rtc_io_reg.h"
+#include "soc/rtc_cntl_reg.h"
+#include "soc/sens_reg.h"
+
+#define RTC_TOUCH_INUM 5
+
+static uint16_t __touchSleepCycles = 0x1000;
+static uint16_t __touchMeasureCycles = 0x1000;
+
+typedef void (*voidFuncPtr)(void);
+static voidFuncPtr __touchInterruptHandlers[10] = {0,};
+
+void IRAM_ATTR __touchISR(void * arg)
+{
+    uint32_t pad_intr = READ_PERI_REG(SENS_SAR_TOUCH_CTRL2_REG) & 0x3ff;
+    uint32_t rtc_intr = READ_PERI_REG(RTC_CNTL_INT_ST_REG);
+    uint8_t i = 0;
+    //clear interrupt
+    WRITE_PERI_REG(RTC_CNTL_INT_CLR_REG, rtc_intr);
+    SET_PERI_REG_MASK(SENS_SAR_TOUCH_CTRL2_REG, SENS_TOUCH_MEAS_EN_CLR);
+
+    if (rtc_intr & RTC_CNTL_TOUCH_INT_ST) {
+        for (i = 0; i < 10; ++i) {
+            if ((pad_intr >> i) & 0x01) {
+                if(__touchInterruptHandlers[i]){
+                    __touchInterruptHandlers[i]();
+                }
+            }
+        }
+    }
+}
+
+void __touchSetCycles(uint16_t measure, uint16_t sleep)
+{
+    __touchSleepCycles = sleep;
+    __touchMeasureCycles = measure;
+    //Touch pad SleepCycle Time
+    SET_PERI_REG_BITS(SENS_SAR_TOUCH_CTRL2_REG, SENS_TOUCH_SLEEP_CYCLES, __touchSleepCycles, SENS_TOUCH_SLEEP_CYCLES_S);
+    //Touch Pad Measure Time
+    SET_PERI_REG_BITS(SENS_SAR_TOUCH_CTRL1_REG, SENS_TOUCH_MEAS_DELAY, __touchMeasureCycles, SENS_TOUCH_MEAS_DELAY_S);
+}
+
+void __touchInit()
+{
+    static bool initialized = false;
+    if(initialized){
+        return;
+    }
+    SET_PERI_REG_BITS(RTC_IO_TOUCH_CFG_REG, RTC_IO_TOUCH_XPD_BIAS, 1, RTC_IO_TOUCH_XPD_BIAS_S);
+    SET_PERI_REG_MASK(SENS_SAR_TOUCH_CTRL2_REG, SENS_TOUCH_MEAS_EN_CLR);
+    //clear touch enable
+    WRITE_PERI_REG(SENS_SAR_TOUCH_ENABLE_REG, 0x0);
+    SET_PERI_REG_MASK(RTC_CNTL_STATE0_REG, RTC_CNTL_TOUCH_SLP_TIMER_EN);
+
+    __touchSetCycles(__touchMeasureCycles, __touchSleepCycles);
+
+    ESP_INTR_DISABLE(RTC_TOUCH_INUM);
+    intr_matrix_set(xPortGetCoreID(), ETS_RTC_CORE_INTR_SOURCE, RTC_TOUCH_INUM);
+    xt_set_interrupt_handler(RTC_TOUCH_INUM, &__touchISR, NULL);
+    ESP_INTR_ENABLE(RTC_TOUCH_INUM);
+    initialized = true;
+}
+
+uint16_t __touchRead(uint8_t pin)
+{
+    int8_t pad = digitalPinToTouchChannel(pin);
+    if(pad < 0){
+        return 0;
+    }
+
+    pinMode(pin, ANALOG);
+
+    __touchInit();
+
+    uint32_t v0 = READ_PERI_REG(SENS_SAR_TOUCH_ENABLE_REG);
+    //Disable Intr & enable touch pad
+    WRITE_PERI_REG(SENS_SAR_TOUCH_ENABLE_REG,
+            (v0 & ~((1 << (pad + SENS_TOUCH_PAD_OUTEN2_S)) | (1 << (pad + SENS_TOUCH_PAD_OUTEN1_S))))
+            | (1 << (pad + SENS_TOUCH_PAD_WORKEN_S)));
+
+    SET_PERI_REG_MASK(SENS_SAR_TOUCH_ENABLE_REG, (1 << (pad + SENS_TOUCH_PAD_WORKEN_S)));
+
+    uint32_t rtc_tio_reg = RTC_IO_TOUCH_PAD0_REG + pad * 4;
+    WRITE_PERI_REG(rtc_tio_reg, (READ_PERI_REG(rtc_tio_reg)
+                      & ~(RTC_IO_TOUCH_PAD0_DAC_M))
+                      | (7 << RTC_IO_TOUCH_PAD0_DAC_S)//Touch Set Slope
+                      | RTC_IO_TOUCH_PAD0_TIE_OPT_M   //Enable Tie,Init Level
+                      | RTC_IO_TOUCH_PAD0_START_M     //Enable Touch Pad IO
+                      | RTC_IO_TOUCH_PAD0_XPD_M);     //Enable Touch Pad Power on
+
+    //force oneTime test start
+    SET_PERI_REG_MASK(SENS_SAR_TOUCH_CTRL2_REG, SENS_TOUCH_START_EN_M|SENS_TOUCH_START_FORCE_M);
+
+    SET_PERI_REG_BITS(SENS_SAR_TOUCH_CTRL1_REG, SENS_TOUCH_XPD_WAIT, 10, SENS_TOUCH_XPD_WAIT_S);
+
+    while (GET_PERI_REG_MASK(SENS_SAR_TOUCH_CTRL2_REG, SENS_TOUCH_MEAS_DONE) == 0) {};
+
+    uint16_t touch_value = READ_PERI_REG(SENS_SAR_TOUCH_OUT1_REG + (pad / 2) * 4) >> ((pad & 1) ? SENS_TOUCH_MEAS_OUT1_S : SENS_TOUCH_MEAS_OUT0_S);
+
+    //clear touch force ,select the Touch mode is Timer
+    CLEAR_PERI_REG_MASK(SENS_SAR_TOUCH_CTRL2_REG, SENS_TOUCH_START_EN_M|SENS_TOUCH_START_FORCE_M);
+
+    //restore previous value
+    WRITE_PERI_REG(SENS_SAR_TOUCH_ENABLE_REG, v0);
+    return touch_value;
+}
+
+void __touchAttachInterrupt(uint8_t pin, void (*userFunc)(void), uint16_t threshold)
+{
+    int8_t pad = digitalPinToTouchChannel(pin);
+    if(pad < 0){
+        return;
+    }
+
+    pinMode(pin, ANALOG);
+
+    __touchInit();
+
+    __touchInterruptHandlers[pad] = userFunc;
+
+    //clear touch force ,select the Touch mode is Timer
+    CLEAR_PERI_REG_MASK(SENS_SAR_TOUCH_CTRL2_REG, SENS_TOUCH_START_EN_M|SENS_TOUCH_START_FORCE_M);
+
+    //interrupt when touch value < threshold
+    CLEAR_PERI_REG_MASK(SENS_SAR_TOUCH_CTRL1_REG, SENS_TOUCH_OUT_SEL);
+    //Intr will give ,when SET0 < threshold
+    SET_PERI_REG_MASK(SENS_SAR_TOUCH_CTRL1_REG, SENS_TOUCH_OUT_1EN);
+    //Enable Rtc Touch Module Intr,the Interrupt need Rtc out  Enable
+    SET_PERI_REG_MASK(RTC_CNTL_INT_ENA_REG, RTC_CNTL_TOUCH_INT_ENA);
+
+    //set threshold
+    uint8_t shift = (pad & 1) ? SENS_TOUCH_OUT_TH1_S : SENS_TOUCH_OUT_TH0_S;
+    SET_PERI_REG_BITS((SENS_SAR_TOUCH_THRES1_REG + (pad / 2) * 4), SENS_TOUCH_OUT_TH0, threshold, shift);
+
+    uint32_t rtc_tio_reg = RTC_IO_TOUCH_PAD0_REG + pad * 4;
+    WRITE_PERI_REG(rtc_tio_reg, (READ_PERI_REG(rtc_tio_reg)
+                      & ~(RTC_IO_TOUCH_PAD0_DAC_M))
+                      | (7 << RTC_IO_TOUCH_PAD0_DAC_S)//Touch Set Slope
+                      | RTC_IO_TOUCH_PAD0_TIE_OPT_M   //Enable Tie,Init Level
+                      | RTC_IO_TOUCH_PAD0_START_M     //Enable Touch Pad IO
+                      | RTC_IO_TOUCH_PAD0_XPD_M);     //Enable Touch Pad Power on
+
+    //Enable Digital rtc control :work mode and out mode
+    SET_PERI_REG_MASK(SENS_SAR_TOUCH_ENABLE_REG,
+                      (1 << (pad + SENS_TOUCH_PAD_WORKEN_S)) | \
+                      (1 << (pad + SENS_TOUCH_PAD_OUTEN2_S)) | \
+                      (1 << (pad + SENS_TOUCH_PAD_OUTEN1_S)));
+}
+
+extern uint16_t touchRead(uint8_t pin) __attribute__ ((weak, alias("__touchRead")));
+extern void touchAttachInterrupt(uint8_t pin, void (*userFunc)(void), uint16_t threshold) __attribute__ ((weak, alias("__touchAttachInterrupt")));
+extern void touchSetCycles(uint16_t measure, uint16_t sleep) __attribute__ ((weak, alias("__touchSetCycles")));

cores/esp32/esp32-hal-touch.h

+/*
+ Arduino.h - Main include file for the Arduino SDK
+ Copyright (c) 2005-2013 Arduino Team.  All right reserved.
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifndef MAIN_ESP32_HAL_TOUCH_H_
+#define MAIN_ESP32_HAL_TOUCH_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "esp32-hal.h"
+
+/*
+ * Set cycles that measurement operation takes
+ * The result from touchRead, threshold and detection
+ * accuracy depend on these values. Defaults are
+ * 0x1000 for measure and 0x1000 for sleep.
+ * With default values touchRead takes 0.5ms
+ * */
+void touchSetCycles(uint16_t measure, uint16_t sleep);
+
+/*
+ * Read touch pad (values close to 0 mean touch detected)
+ * You can use this method to chose a good threshold value
+ * to use as value for touchAttachInterrupt
+ * */
+uint16_t touchRead(uint8_t pin);
+
+/*
+ * Set function to be called if touch pad value falls
+ * below the given threshold. Use touchRead to determine
+ * a proper threshold between touched and untouched state
+ * */
+void touchAttachInterrupt(uint8_t pin, void (*userFunc)(void), uint16_t threshold);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* MAIN_ESP32_HAL_TOUCH_H_ */

cores/esp32/esp32-hal.h

@@ -50,6 +50,9 @@ void vPortYield( void );
 #include "esp32-hal-matrix.h"
 #include "esp32-hal-uart.h"
 #include "esp32-hal-gpio.h"
+#include "esp32-hal-touch.h"
+#include "esp32-hal-dac.h"
+#include "esp32-hal-adc.h"
 #include "esp32-hal-spi.h"
 #include "esp32-hal-i2c.h"
 #include "esp32-hal-ledc.h"

platform.txt

@@ -26,7 +26,7 @@ compiler.S.flags=-c -g3 -x assembler-with-cpp -MMD -mlongcalls
 
 compiler.c.elf.cmd=xtensa-esp32-elf-gcc
 compiler.c.elf.flags="-L{compiler.sdk.path}/lib" "-L{compiler.sdk.path}/ld" -nostdlib -T esp32_out.ld -T esp32.common.ld -T esp32.rom.ld -T esp32.peripherals.ld -u call_user_start_cpu0 -Wl,--gc-sections -Wl,-static -Wl,--undefined=uxTopUsedPriority
-compiler.c.elf.libs=-lapp_update -lbt -lbtdm_app -lc -lcoexist -lcore -ldriver -lesp32 -lethernet -lexpat -lfreertos -lg -lhal -ljson -llog -llwip -lm -lmbedtls -lnet80211 -lnewlib -lnghttp -lnvs_flash -lopenssl -lphy -lpp -lrtc -lsmartconfig -lspi_flash -ltcpip_adapter -lvfs -lwpa -lwpa2 -lwpa_supplicant -lwps -lxtensa-debug-module 
+compiler.c.elf.libs=-lapp_update -lbt -lbtdm_app -lc -lcoexist -lcore -ldriver -lesp32 -lethernet -lexpat -lfreertos -lg -lhal -ljson -llog -llwip -lm -lmbedtls -lnet80211 -lnewlib -lnghttp -lnvs_flash -lopenssl -lphy -lpp -lrtc -lsmartconfig -lspi_flash -ltcpip_adapter -lulp -lvfs -lwpa -lwpa2 -lwpa_supplicant -lwps -lxtensa-debug-module 
 
 compiler.as.cmd=xtensa-esp32-elf-as
 

tools/sdk/include/bt/bt.h

@@ -16,6 +16,7 @@
 #define __BT_H__
 
 #include <stdint.h>
+#include <stdbool.h>
 #include "esp_err.h"
 
 #ifdef __cplusplus

tools/sdk/include/config/sdkconfig.h

@@ -17,13 +17,16 @@
 #define CONFIG_FREERTOS_THREAD_LOCAL_STORAGE_POINTERS 1
 #define CONFIG_BT_RESERVE_DRAM 0x10000
 #define CONFIG_LOG_BOOTLOADER_LEVEL_ERROR 1
+#define CONFIG_CONSOLE_UART_BAUDRATE 115200
 #define CONFIG_LWIP_MAX_SOCKETS 4
 #define CONFIG_ESP32_ENABLE_STACK_BT 1
 #define CONFIG_ULP_COPROC_RESERVE_MEM 0
 #define CONFIG_ESPTOOLPY_BAUD 921600
 #define CONFIG_TOOLPREFIX "xtensa-esp32-elf-"
+#define CONFIG_CONSOLE_UART_NUM 0
 #define CONFIG_ESP32_RTC_CLOCK_SOURCE_INTERNAL_RC 1
 #define CONFIG_LWIP_THREAD_LOCAL_STORAGE_INDEX 0
+#define CONFIG_CONSOLE_UART_DEFAULT 1
 #define CONFIG_MBEDTLS_SSL_MAX_CONTENT_LEN 16384
 #define CONFIG_AUTOSTART_ARDUINO 1
 #define CONFIG_LOG_DEFAULT_LEVEL_ERROR 1
@@ -58,6 +61,7 @@
 #define CONFIG_MBEDTLS_HARDWARE_SHA 1
 #define CONFIG_FREERTOS_CORETIMER_0 1
 #define CONFIG_PARTITION_TABLE_CUSTOM_FILENAME "partitions.csv"
+#define CONFIG_MBEDTLS_HAVE_TIME 1
 #define CONFIG_FREERTOS_ISR_STACKSIZE 1536
 #define CONFIG_OPTIMIZATION_LEVEL_DEBUG 1
 #define CONFIG_SYSTEM_EVENT_QUEUE_SIZE 32

tools/sdk/include/driver/driver/adc.h

+// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef _DRIVER_ADC_H_
+#define _DRIVER_ADC_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+#include "esp_err.h"
+
+typedef enum {
+    ADC_ATTEN_0db   = 0,  /*!<The input voltage of ADC will be reduced to about 1/1 */
+    ADC_ATTEN_2_5db = 1,  /*!<The input voltage of ADC will be reduced to about 1/1.34 */
+    ADC_ATTEN_6db   = 2,  /*!<The input voltage of ADC will be reduced to about 1/2 */
+    ADC_ATTEN_11db  = 3,  /*!<The input voltage of ADC will be reduced to about 1/3.6*/
+} adc_atten_t;
+
+typedef enum {
+    ADC_WIDTH_9Bit  = 0, /*!< ADC capture width is 9Bit*/
+    ADC_WIDTH_10Bit = 1, /*!< ADC capture width is 10Bit*/
+    ADC_WIDTH_11Bit = 2, /*!< ADC capture width is 11Bit*/
+    ADC_WIDTH_12Bit = 3, /*!< ADC capture width is 12Bit*/
+} adc_bits_width_t;
+
+typedef enum {
+    ADC1_CHANNEL_0 = 0, /*!< ADC1 channel 0 is GPIO36 */
+    ADC1_CHANNEL_1,     /*!< ADC1 channel 1 is GPIO37 */
+    ADC1_CHANNEL_2,     /*!< ADC1 channel 2 is GPIO38 */
+    ADC1_CHANNEL_3,     /*!< ADC1 channel 3 is GPIO39 */
+    ADC1_CHANNEL_4,     /*!< ADC1 channel 4 is GPIO32 */
+    ADC1_CHANNEL_5,     /*!< ADC1 channel 5 is GPIO33 */
+    ADC1_CHANNEL_6,     /*!< ADC1 channel 6 is GPIO34 */
+    ADC1_CHANNEL_7,     /*!< ADC1 channel 7 is GPIO35 */
+    ADC1_CHANNEL_MAX,
+} adc1_channel_t;
+
+/**
+ * @brief Configuration ADC1 capture width.
+ *
+ * The configuration is in effect for all channels of ADC1
+ *
+ * @param  width_bit ADC1
+ *
+ * @return
+ *     - ESP_OK success
+ *     - ESP_ERR_INVALID_ARG Parameter error
+ */
+esp_err_t adc1_config_width(adc_bits_width_t width_bit);
+
+/**
+ * @brief Configuration ADC1 capture attenuation of channels.
+ *
+ * @param  channel the ADC1 channel
+ * @param  atten attenuation
+ *
+ * @return
+ *     - ESP_OK success
+ *     - ESP_ERR_INVALID_ARG Parameter error
+ */
+esp_err_t adc1_config_channel_atten(adc1_channel_t channel, adc_atten_t atten);
+
+/**
+ * @brief ADC1 get the value of the voltage.
+ *
+ * @param  channel the ADC1 channel
+ *
+ * @return
+ *     - -1 Parameter error
+ *     -  Other the value of ADC1 channel
+ */
+int adc1_get_voltage(adc1_channel_t channel);
+
+/**
+ * @brief Hall  Sensor output value.
+ *        @note
+ *        The Hall Sensor uses Channel_0 and Channel_3 of ADC1.
+ *        So, firstly: please configure ADC1 module by calling adc1_config_width before calling hall_sensor_read.
+                 We recommend that the WIDTH ADC1 be configured as 12Bit, because the values of hall_sensor_read are small and almost the same if WIDTH ADC1 is configured as 9Bit, 10Bit or 11Bit.
+ *            secondly: when you use the hall sensor, please do not use Channel_0 and Channel_3 of ADC1 as
+ *                   ADC channels.
+ *
+ * @return the value of hall sensor
+ */
+int hall_sensor_read();
+
+/**
+ *----------EXAMPLE TO USE ADC1------------ *
+ * @code{c}
+ *     adc1_config_width(ADC_WIDTH_12Bit);//config adc1 width
+ *     adc1_config_channel_atten(ADC1_CHANNEL_0,ADC_ATTEN_0db);//config channel0 attenuation
+ *     int val=adc1_get_voltage(ADC1_CHANNEL_0);//get the  val of channel0
+ * @endcode
+ **/
+
+/**
+ *----------EXAMPLE TO USE HALL SENSOR------------ *
+ * @code{c}
+ *     adc1_config_width(ADC_WIDTH_12Bit);//config adc1 width
+ *     int val=hall_sensor_read();
+ * @endcode
+ **/
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  /*_DRIVER_ADC_H_*/
+

tools/sdk/include/driver/driver/dac.h

+// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef _DRIVER_DAC_H_
+#define _DRIVER_DAC_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+#include "esp_err.h"
+
+typedef enum {
+    DAC_CHANNEL_1 = 1,  /*!< DAC channel 1 is GPIO25 */
+    DAC_CHANNEL_2,      /*!< DAC channel 2 is GPIO26 */
+    DAC_CHANNEL_MAX,
+} dac_channel_t;
+
+/**
+ * @brief Set Dac output voltage.
+ *
+ * Dac width is 8bit ,and the voltage max is vdd
+ *
+ * @param channel dac channel
+ * @param dac_value dac output value
+ *
+ * @return
+ *     - ESP_OK success
+ *     - ESP_ERR_INVALID_ARG Parameter error
+ */
+esp_err_t dac_out_voltage(dac_channel_t channel, uint8_t dac_value);
+
+/**
+ *----------EXAMPLE TO USE DAC------------ *
+ * @code{c}
+ * dac_out_voltage(DAC_CHANNEL_1,200);//the dac out voltage ≈ 200*vdd/255
+ * @endcode
+ **/
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  /*_DRIVER_DAC_H_*/
+

tools/sdk/include/driver/driver/gpio.h

@@ -117,32 +117,6 @@ extern const uint32_t GPIO_PIN_MUX_REG[GPIO_PIN_COUNT];
 #define GPIO_IS_VALID_GPIO(gpio_num)      ((gpio_num < GPIO_PIN_COUNT && GPIO_PIN_MUX_REG[gpio_num] != 0))   //to decide whether it is a valid GPIO number
 #define GPIO_IS_VALID_OUTPUT_GPIO(gpio_num)      ((GPIO_IS_VALID_GPIO(gpio_num)) && (gpio_num < 34))         //to decide whether it can be a valid GPIO number of output mode
 
-/**
- * @brief Pullup/pulldown information for a single GPIO pad
- */
-typedef struct {
-    uint32_t reg;       /*!< Register to modify to enable or disable pullups or pulldowns */
-    uint32_t pu;        /*!< Bit to set or clear in the above register to enable or disable the pullup, respectively */
-    uint32_t pd;        /*!< Bit to set or clear in the above register to enable or disable the pulldown, respectively */
-} gpio_pu_pd_desc_t;
-
-
-/**
- * Per-GPIO pullup/pulldown information
- * On the ESP32, some GPIOs need their pullups and pulldowns enabled and disabled in the RTC 
- * peripheral instead of in the GPIO peripheral. This array documents for every GPIO what bit
- * to set or clear.
- * 
- * This array is non-static, so if you need a very quick way of toggling the pull-up/downs, you can just
- * do e.g. REG_SET_BIT(gpio_pu_pd_desc[gpio_num].reg, gpio_pu_pd_desc[gpio_num].pu); inline.
- * 
- * ToDo: Functions using the contents of this array will do a read/modify/write on GPIO as well as RTC
- * registers. We may need to look into muxes/locks for other code that accesses these RTC registers when we
- * write drivers for the RTC stuff.
- */
-extern const gpio_pu_pd_desc_t gpio_pu_pd_desc[GPIO_PIN_COUNT];
-
-
 typedef enum {
     GPIO_NUM_0 = 0,     /*!< GPIO0, input and output */
     GPIO_NUM_1 = 1,     /*!< GPIO1, input and output */

tools/sdk/include/driver/driver/pcnt.h

@@ -27,9 +27,9 @@ typedef enum {
 } pcnt_ctrl_mode_t;
 
 typedef enum {
-    PCNT_COUNT_DIS = 0,            /*!< Counter mode: Decrease counter value*/
+    PCNT_COUNT_DIS = 0,            /*!< Counter mode: Inhibit counter(counter value will not change in this condition)*/
     PCNT_COUNT_INC = 1,            /*!< Counter mode: Increase counter value*/
-    PCNT_COUNT_DEC = 2,            /*!< Counter mode: Inhibit counter(counter value will not change in this condition)*/
+    PCNT_COUNT_DEC = 2,            /*!< Counter mode: Decrease counter value*/
     PCNT_COUNT_MAX
 } pcnt_count_mode_t;
 
@@ -45,7 +45,7 @@ typedef enum {
     PCNT_UNIT_MAX,
 } pcnt_unit_t; 
 
-typedef enum{
+typedef enum {
     PCNT_CHANNEL_0 = 0x00,           /*!< PCNT channel0 */
     PCNT_CHANNEL_1 = 0x01,           /*!< PCNT channel1 */
     PCNT_CHANNEL_MAX,

tools/sdk/include/driver/driver/rtc_io.h

+// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef _DRIVER_RTC_GPIO_H_
+#define _DRIVER_RTC_GPIO_H_
+
+#include <stdint.h>
+#include "esp_err.h"
+#include "driver/gpio.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief Pullup/pulldown information for a single GPIO pad
+ */
+typedef struct {
+    uint32_t reg;       /*!< Register of Rtc Pad */
+    uint32_t mux;       /*!< Mux seletct the Rtc pad is Digital Pad or Rtc pad */
+    uint32_t func;      /*!< Select Rtc Pad Func */
+    uint32_t ie;        /*!< Input Enable */
+    uint32_t pullup;    /*!< Pullup Enable */
+    uint32_t pulldown;  /*!< PullDown Enable */
+    int rtc_num;        /*!< The Rtc number */
+} rtc_gpio_desc_t;
+
+typedef enum {
+    RTC_GPIO_MODE_INPUT_ONLY , /*!< Pad output           */
+    RTC_GPIO_MODE_OUTPUT_ONLY, /*!< Pad input          */
+    RTC_GPIO_MODE_INPUT_OUTUT, /*!< Pad pull output + input      */
+    RTC_GPIO_MODE_DISABLED, /*!< Pad (output + input) disable       */
+} rtc_gpio_mode_t;
+
+#define RTC_GPIO_IS_VALID_GPIO(gpio_num)      ((gpio_num < GPIO_PIN_COUNT && rtc_gpio_desc[gpio_num].reg != 0))   //to decide whether it is a valid GPIO number
+
+extern const rtc_gpio_desc_t rtc_gpio_desc[GPIO_PIN_COUNT] ;
+
+/*
+ * @brief Init a gpio as rtc gpio
+ *
+ *        when init a pad as analog function,need to call this funciton
+ *
+ * @param  gpio_num gpio_num GPIO number. If you want to set the trigger type of e.g. of GPIO16, gpio_num should be GPIO_NUM_12 (12);
+ *
+ * @return
+ *     - ESP_OK success
+ *     - ESP_ERR_INVALID_ARG Parameter error
+ */
+esp_err_t rtc_gpio_init(gpio_num_t gpio_num);
+
+/**
+ * @brief Init a gpio as digital gpio
+ *
+ * @param  gpio_num gpio_num GPIO number. If you want to set the trigger type of e.g. of GPIO16, gpio_num should be GPIO_NUM_12 (12);
+ *
+ * @return
+ *     - ESP_OK success
+ *     - ESP_ERR_INVALID_ARG Parameter error
+ */
+esp_err_t rtc_gpio_deinit(gpio_num_t gpio_num);
+
+/**
+ * @brief Get the rtc io input level
+ *
+ * @param  gpio_num gpio_num GPIO number. If you want to set the trigger type of e.g. of GPIO16, gpio_num should be GPIO_NUM_12 (12);
+ *
+ * @return
+ *     - 1 High level
+ *     - 0 Low level
+ */
+uint32_t rtc_gpio_get_level(gpio_num_t gpio_num);
+
+/**
+ * @brief Set the rtc io output level
+ *
+ * @param  gpio_num  GPIO number. If you want to set the trigger type of e.g. of GPIO16, gpio_num should be GPIO_NUM_12 (12);
+ * @param  level output level;
+ *
+ * @return
+ *     - 1 High level
+ *     - 0 Low level
+ */
+esp_err_t rtc_gpio_set_level(gpio_num_t gpio_num, uint32_t level);
+
+/**
+ * @brief    Rtc gpio set direction
+ *
+ * Configure Rtc gpio direction,such as output_only,input_only,output_and_input
+ *
+ * @param  gpio_num  Configure GPIO pins number, it should be GPIO number. If you want to set direction of e.g. GPIO12, gpio_num should be GPIO_NUM_12 (12);
+ * @param  mode GPIO direction
+ *
+ * @return
+ *     - ESP_OK Success
+ *     - ESP_ERR_INVALID_ARG GPIO error
+ */
+esp_err_t rtc_gpio_set_direction(gpio_num_t gpio_num, rtc_gpio_mode_t mode);
+
+/**
+ * @brief  Rtc gpio pullup enable
+ *
+ * If the user needs to configure the GPIO pull ,Please call gpio_set_pull_mode.This function will be called in gpio_set_pull
+ *
+ * @param  gpio_num GPIO number. If you want to set pull up or down mode for e.g. GPIO12, gpio_num should be GPIO_NUM_12 (12);
+ *
+ * @return
+ *     - True  the gpio number is Rts pad
+ *     - False the gpio number is Digital pad
+ */
+esp_err_t rtc_gpio_pullup_en(gpio_num_t gpio_num);
+
+/**
+ * @brief  Rtc gpio pulldown enable
+ *
+ * If the user needs to configure the GPIO pull ,Please call gpio_set_pull_mode.This function will be called in gpio_set_pull
+ *
+ * @param  gpio_num GPIO number. If you want to set pull up or down mode for e.g. GPIO12, gpio_num should be GPIO_NUM_12 (12);
+ *
+ * @return
+ *     - True  the gpio number is Rts pad
+ *     - False the gpio number is Digital pad
+ */
+esp_err_t rtc_gpio_pulldown_en(gpio_num_t gpio_num);
+
+/**
+ * @brief  Rtc gpio pullup clear
+ *
+ * If the user needs to configure the GPIO pull ,Please call gpio_set_pull_mode.This function will be called in gpio_set_pull
+ *
+ * @param  gpio_num GPIO number. If you want to set pull up or down mode for e.g. GPIO12, gpio_num should be GPIO_NUM_12 (12);
+ *
+ * @return
+ *     - True  the gpio number is Rts pad
+ *     - False the gpio number is Digital pad
+ */
+esp_err_t rtc_gpio_pullup_dis(gpio_num_t gpio_num);
+
+/**
+ * @brief  Rtc gpio pulldown clear
+ *
+ * If the user needs to configure the GPIO pull ,Please call gpio_set_pull_mode.This function will be called in gpio_set_pull
+ *
+ * @param  gpio_num GPIO number. If you want to set pull up or down mode for e.g. GPIO12, gpio_num should be GPIO_NUM_12 (12);
+ *
+ * @return
+ *     - True  the gpio number is Rts pad
+ *     - False the gpio number is Digital pad
+ */
+esp_err_t rtc_gpio_pulldown_dis(gpio_num_t gpio_num);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

tools/sdk/include/driver/driver/touch_pad.h

+// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef _DRIVER_TOUCH_PAD_H_
+#define _DRIVER_TOUCH_PAD_H_
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include "esp_intr.h"
+#include "esp_err.h"
+#define TOUCH_PAD_SLEEP_CYCLE_CONFIG   (0x1000)//The Time is 150Khz,the Max value is 0xffff
+#define TOUCH_PAD_MEASURE_CYCLE_CONFIG (0xffff)//The Time is 8Mhz,the Max value is 0xffff
+typedef enum {
+    TOUCH_PAD_NUM0 = 0, /*!< Touch pad channel 0 is GPIO4 */
+    TOUCH_PAD_NUM1,    /*!< Touch pad channel 0 is GPIO0 */
+    TOUCH_PAD_NUM2,    /*!< Touch pad channel 0 is GPIO2 */
+    TOUCH_PAD_NUM3,    /*!< Touch pad channel 0 is GPIO15 */
+    TOUCH_PAD_NUM4,    /*!< Touch pad channel 0 is GPIO13 */
+    TOUCH_PAD_NUM5,    /*!< Touch pad channel 0 is GPIO12 */
+    TOUCH_PAD_NUM6,    /*!< Touch pad channel 0 is GPIO14 */
+    TOUCH_PAD_NUM7,    /*!< Touch pad channel 0 is GPIO27*/
+    TOUCH_PAD_NUM8,    /*!< Touch pad channel 0 is GPIO33*/
+    TOUCH_PAD_NUM9,    /*!< Touch pad channel 0 is GPIO32*/
+    TOUCH_PAD_MAX,
+} touch_pad_t;
+/**
+ * @brief       Initialize touch module.
+ *
+ *This function int touch pad module ,enable touch module
+ *
+ * @return    None
+ *
+ */
+void touch_pad_init();
+
+/**
+ * @brief       Configure touch pad interrupt threshold.
+ *
+ *
+ * @param[in]  touch_num  : config touch num
+ *
+ * @param[in]  threshold : interrupt threshold  ,When the touch_pad_register less than threshold,
+ *                         will trigger the touch interrupt.User can use touch_pad_read function
+ *                         to determine the threshold.
+ *
+ * @return    - ESP_OK Success
+ *            - ESP_ERR_INVALID_ARG Touch pad error
+ *
+ */
+esp_err_t touch_pad_config(touch_pad_t touch_num, uint16_t threshold);
+
+/**
+ * @brief       get touch pad touch_pad_register counter.
+ *
+ *User can use this function to determine the the interrupt threshold .When you do not touch  the
+ *pad ,read the touch_pad_read number(NumNotTouch) by the touch_pad_register.When you touch the pad ,read the touch_pad_register
+ *number(NumTouch) by the touch_pad_read.Normal NumNotTouch>NumTouch,so you can select a interrupt threshold.
+ *
+ * @param[in]  touch_num    : touch num
+ * @param[out]  touch_value : touch output value
+ *
+ *  @return   - ESP_OK Success
+ *            - ESP_ERR_INVALID_ARG Touch pad error
+ *
+ */
+esp_err_t touch_pad_read(touch_pad_t touch_num, uint16_t * touch_value);
+
+/**
+ * @brief   register TouchPad interrupt handler, the handler is an ISR.
+ *          The handler will be attached to the same CPU core that this function is running on.
+ *          @note
+ *          Users should know that which CPU is running and then pick a INUM that is not used by system.
+ *          We can find the information of INUM and interrupt level in soc.h.
+ *
+ * @param  touch_intr_num  Touch interrupt number,check the info in soc.h, and please see the core-isa.h for more details
+ * @param  fn  Interrupt handler function.
+ *
+ *         @note
+ *         Note that the handler function MUST be defined with attribution of "IRAM_ATTR".
+ *
+ * @param  arg  Parameter for handler function
+ *
+ * @return
+ *     - ESP_OK Success ;
+ *     - ESP_ERR_INVALID_ARG GPIO error
+ */
+esp_err_t touch_pad_isr_handler_register(uint32_t touch_intr_num, void(*fn)(void*), void *arg);
+
+
+/**
+ * ***************        ATTENTION       ********************/
+/**
+ *@attention
+*Touch button is through the body's capacitive characteristics, 
+*there is a charge discharge circuit inside the. When the hands touch, 
+*the charge and discharge time will be slow.
+*Because of the different hardware, each pad needs to be calibrated at the factory.
+*We use touch_pad_read to determine factory parament.
+*/
+/**
+ *----------EXAMPLE TO CONIFGURE GPIO AS OUTPUT ------------ *
+ * @code{c}
+ *  touch_pad_init();                            
+ *  void taskA(void* arg)
+ *  {
+ *      for(;;){
+ *          vtaskDelay(20/portTICK_PERIOD_MS);
+ *          ets_printf("tocuch pad value %u\n",touch_pad_read(0));//Take the touched status and untouched status value
+ *      } 
+ *  }
+ * @endcode
+ **/
+/**
+ *----------EXAMPLE TO SET ISR HANDLER ----------------------
+ * @code{c}
+ * //the first parameter is INUM, you can pick one form interrupt level 1/2 which is not used by the system.
+ * touch_pad_isr_handler_register(19,rtc_intr,NULL);    //hook the isr handler for TouchPad interrupt
+ * @endcode
+ * @note
+ *     1. user should arrange the INUMs that used, better not to use a same INUM for different interrupt.
+ *     2. do not pick the INUM that already occupied by the system.
+ *     3. refer to soc.h to check which INUMs that can be used.
+ */
+/**
+ *----------EXAMPLE TO USE TOUCH_PAD------------ *
+ * @code{c}
+ *   touch_pad_init();//only init one time
+ *   touch_pad_config(0,300);//set the intr threshold,use touch_pad_read to determine this threshold 
+ *   touch_pad_isr_handler_register(19,rtc_intr,NULL)
+ *   #include "esp_attr.h"
+ *   void IRAM_ATTR rtc_intr(void * arg)
+ *   {
+ *       uint32_t pad_intr = READ_PERI_REG(SARADC_SAR_TOUCH_CTRL2_REG) & 0x3ff;
+ *       uint8_t i = 0;
+ *       uint32_t rtc_intr = READ_PERI_REG(RTC_CNTL_INT_ST_REG);
+ *       WRITE_PERI_REG(RTC_CNTL_INT_CLR_REG, rtc_intr);
+ *       SET_PERI_REG_MASK(SARADC_SAR_TOUCH_CTRL2_REG, SARADC_TOUCH_MEAS_EN_CLR);
+ *       if (rtc_intr & RTC_CNTL_TOUCH_INT_ST) {
+ *           for (i = 0; i < TOUCH_PAD_MAX; ++i) {
+ *               if ((pad_intr >> i) & 0x01) {
+ *                   ets_printf("touch pad intr %u\n",i);
+ *               }
+ *           }
+ *       }
+ *  }
+ * @endcode
+ **/
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif/*_DRIVER_TOUCH_PAD_H_*/
+

tools/sdk/include/esp32/esp_coexist.h

+// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <stdbool.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief Init software coexist
+ *
+ * @return Init ok or failed.
+ */
+esp_err_t coex_init(void);
+
+/**
+ * @brief Get software coexist enable or not
+ *
+ * @return software coexist enable status.
+ */
+bool coexist_get_enable(void);
+
+/**
+ * @brief Set software coexist enable or not
+ *
+ * @param enable software coexist or disable it
+ *
+ * @return Void.
+ */
+void coexist_set_enable(bool enable);
+
+#ifdef __cplusplus
+}
+#endif

tools/sdk/include/esp32/rom/uart.h

@@ -18,6 +18,8 @@
 #include "esp_types.h"
 #include "esp_attr.h"
 #include "ets_sys.h"
+#include "soc/soc.h"
+#include "soc/uart_reg.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -260,11 +262,16 @@ void uart_tx_flush(uint8_t uart_no);
 /**
   * @brief Wait until uart tx full empty and the last char send ok.
   *
-  * @param  uint8_t uart_no : 0 for UART0, 1 for UART1.
+  * @param  uart_no : 0 for UART0, 1 for UART1, 2 for UART2
   *
-  * @return None.
+  * The function defined in ROM code has a bug, so we define the correct version
+  * here for compatibility.
   */
-void uart_tx_wait_idle(uint8_t uart_no);
+static inline void uart_tx_wait_idle(uint8_t uart_no) {
+    while(REG_GET_FIELD(UART_STATUS_REG(uart_no), UART_ST_UTX_OUT)) {
+        ;
+    }
+}
 
 /**
   * @brief Get an input char from message channel.

tools/sdk/include/esp32/soc/soc.h

@@ -153,7 +153,7 @@
 #define DR_REG_FRC_TIMER_BASE                   0x3ff47000
 #define DR_REG_RTCCNTL_BASE                     0x3ff48000
 #define DR_REG_RTCIO_BASE                       0x3ff48400
-#define DR_REG_SARADC_BASE                      0x3ff48800
+#define DR_REG_SENS_BASE                      0x3ff48800
 #define DR_REG_IO_MUX_BASE                      0x3ff49000
 #define DR_REG_RTCMEM0_BASE                     0x3ff61000
 #define DR_REG_RTCMEM1_BASE                     0x3ff62000
@@ -213,10 +213,10 @@
 #define ETS_TG1_LACT_LEVEL_INTR_SOURCE          21/**< interrupt of TIMER_GROUP1, LACT, level*/
 #define ETS_GPIO_INTR_SOURCE                    22/**< interrupt of GPIO, level*/
 #define ETS_GPIO_NMI_SOURCE                     23/**< interrupt of GPIO, NMI*/
-#define ETS_FROM_CPU_INTR0_SOURCE               24/**< interrupt0 generated from a CPU, level*/
-#define ETS_FROM_CPU_INTR1_SOURCE               25/**< interrupt1 generated from a CPU, level*/
-#define ETS_FROM_CPU_INTR2_SOURCE               26/**< interrupt2 generated from a CPU, level*/
-#define ETS_FROM_CPU_INTR3_SOURCE               27/**< interrupt3 generated from a CPU, level*/
+#define ETS_FROM_CPU_INTR0_SOURCE               24/**< interrupt0 generated from a CPU, level*/ /* Used for FreeRTOS */
+#define ETS_FROM_CPU_INTR1_SOURCE               25/**< interrupt1 generated from a CPU, level*/ /* Used for FreeRTOS */
+#define ETS_FROM_CPU_INTR2_SOURCE               26/**< interrupt2 generated from a CPU, level*/ /* Used for VHCI */
+#define ETS_FROM_CPU_INTR3_SOURCE               27/**< interrupt3 generated from a CPU, level*/ /* Reserved */
 #define ETS_SPI0_INTR_SOURCE                    28/**< interrupt of SPI0, level, SPI0 is for Cache Access, do not use this*/
 #define ETS_SPI1_INTR_SOURCE                    29/**< interrupt of SPI1, level, SPI1 is for flash read/write, do not use this*/
 #define ETS_SPI2_INTR_SOURCE                    30/**< interrupt of SPI2, level*/

tools/sdk/ld/esp32.rom.ld

@@ -1841,3 +1841,22 @@ PROVIDE ( _xtos_syscall_handler = 0x40000790 );
 PROVIDE ( _xtos_unhandled_exception = 0x4000c024 );
 PROVIDE ( _xtos_unhandled_interrupt = 0x4000c01c );
 PROVIDE ( _xtos_vpri_enabled = 0x3ffe0654 );
+/* Following are static data, but can be used, not generated by script <<<<< btdm data */
+PROVIDE ( ld_acl_env = 0x3ffb8258 );
+PROVIDE ( ld_active_ch_map = 0x3ffb8334 );
+PROVIDE ( ld_bcst_acl_env = 0x3ffb8274 );
+PROVIDE ( ld_csb_rx_env = 0x3ffb8278 );
+PROVIDE ( ld_csb_tx_env = 0x3ffb827c );
+PROVIDE ( ld_env = 0x3ffb9510 );
+PROVIDE ( ld_fm_env = 0x3ffb8284 );
+PROVIDE ( ld_inq_env = 0x3ffb82e4 );
+PROVIDE ( ld_iscan_env = 0x3ffb82e8 );
+PROVIDE ( ld_page_env = 0x3ffb82f0 );
+PROVIDE ( ld_pca_env = 0x3ffb82f4 );
+PROVIDE ( ld_pscan_env = 0x3ffb8308 );
+PROVIDE ( ld_sched_env = 0x3ffb830c );
+PROVIDE ( ld_sched_params = 0x3ffb96c0 );
+PROVIDE ( ld_sco_env = 0x3ffb824c );
+PROVIDE ( ld_sscan_env = 0x3ffb832c );
+PROVIDE ( ld_strain_env = 0x3ffb8330 );
+/* Above are static data, but can be used, not generated by script >>>>> btdm data */