✨ feat:首次上传,基于钱江代码

RT200T_2_ESP32/.gitignore

+build/
+sdkconfig.old
+/.vscode
+*.o
+*.s
+*.log
+*.lst
+*.d

RT200T_2_ESP32/CMakeLists.txt

+# The following lines of boilerplate have to be in your project's CMakeLists
+# in this exact order for cmake to work correctly
+cmake_minimum_required(VERSION 3.16)
+
+# (Not part of the boilerplate)
+# This example uses an extra component for common functions such as Wi-Fi and Ethernet connection.
+set(EXTRA_COMPONENT_DIRS $ENV{IDF_PATH}/examples/common_components/protocol_examples_common)
+
+include($ENV{IDF_PATH}/tools/cmake/project.cmake)
+project(QJ500-7C)

RT200T_2_ESP32/QJ500_7C_partitions_two_ota.csv

+# Name,   Type, SubType, Offset,   Size, Flags
+# Note: if you have increased the bootloader size, make sure to update the offsets to avoid overlap
+nvs,      data, nvs,     ,        0x4000,
+otadata,  data, ota,     ,        0x2000,
+phy_init, data, phy,     ,        0x1000,
+ota_0,    app,  ota_0,   ,        0x800K,
+ota_1,    app,  ota_1,   ,        0x800K,
\ No newline at end of file

RT200T_2_ESP32/README.md

+| Supported Targets | ESP32 | ESP32-C2 | ESP32-C3 | ESP32-S3 |
+| ----------------- | ----- | -------- | -------- | -------- |
+
+# ESP-IDF Gatt Server Service Table Example
+
+This example shows how to create a GATT service with an attribute table defined in one place. Provided API releases the user from adding attributes one by one as implemented in BLUEDROID. A demo of the other method to create the attribute table is presented in [gatt_server_demo](../gatt_server).
+
+Please, check this [tutorial](tutorial/Gatt_Server_Service_Table_Example_Walkthrough.md) for more information about this example.
+
+## How to Use Example
+
+Before project configuration and build, be sure to set the correct chip target using:
+
+```bash
+idf.py set-target <chip_name>
+```
+
+### Hardware Required
+
+* A development board with ESP32/ESP32-C3/ESP32-H2/ESP32-C2/ESP32-S3 SoC (e.g., ESP32-DevKitC, ESP-WROVER-KIT, etc.)
+* A USB cable for Power supply and programming
+
+See [Development Boards](https://www.espressif.com/en/products/devkits) for more information about it.
+
+### Build and Flash
+
+Run `idf.py -p PORT flash monitor` to build, flash and monitor the project.
+
+(To exit the serial monitor, type ``Ctrl-]``.)
+
+See the [Getting Started Guide](https://idf.espressif.com/) for full steps to configure and use ESP-IDF to build projects.
+
+## Example Output
+
+```
+I (0) cpu_start: Starting scheduler on APP CPU.
+I (512) BTDM_INIT: BT controller compile version [1342a48]
+I (522) system_api: Base MAC address is not set
+I (522) system_api: read default base MAC address from EFUSE
+I (522) phy_init: phy_version 4670,719f9f6,Feb 18 2021,17:07:07
+I (942) GATTS_TABLE_DEMO: create attribute table successfully, the number handle = 8
+
+I (942) GATTS_TABLE_DEMO: SERVICE_START_EVT, status 0, service_handle 40
+I (962) GATTS_TABLE_DEMO: advertising start successfully
+```
+
+## Troubleshooting
+
+For any technical queries, please open an [issue](https://github.com/espressif/esp-idf/issues) on GitHub. We will get back to you soon.

RT200T_2_ESP32/main/CMakeLists.txt

+# Embed the server root certificate into the final binary
+idf_build_get_property(project_dir PROJECT_DIR)
+idf_component_register(SRCS "app_BT_User.c" "bt_app_main.c" "bt_app_hf.c" "bt_app_core.c" "gatts_table_creat_demo.c"
+                    "simple_ota_example.c"
+                    "Protocol_CRC16.c"
+                    "Protocol_Lib.c"
+                    "Protocol_User.c"
+                    "MCU_Core_Protocol.c"
+                    "app_Ble_User.c"
+                    "main_user.c"
+                    INCLUDE_DIRS "."
+                    EMBED_TXTFILES ${project_dir}/server_certs/ca_cert.pem)

RT200T_2_ESP32/main/Kconfig.projbuild

+menu "Example Configuration"
+
+    config EXAMPLE_FIRMWARE_UPGRADE_URL
+        string "firmware upgrade url endpoint"
+        default "https://192.168.0.3:8070/hello_world.bin"
+        help
+            URL of server which hosts the firmware
+            image.
+
+    config EXAMPLE_USE_CERT_BUNDLE
+        bool "Enable certificate bundle"
+        default y
+        depends on MBEDTLS_CERTIFICATE_BUNDLE
+        help
+            Enable trusted root certificate bundle. This approach allows to have
+            OTA updates functional with any public server without requirement
+            to explicitly add its server certificate.
+
+    config EXAMPLE_FIRMWARE_UPGRADE_URL_FROM_STDIN
+        bool
+        default y if EXAMPLE_FIRMWARE_UPGRADE_URL = "FROM_STDIN"
+
+    config EXAMPLE_SKIP_COMMON_NAME_CHECK
+        bool "Skip server certificate CN fieldcheck"
+        default n
+        help
+            This allows you to skip the validation of OTA server certificate CN field.
+
+    config EXAMPLE_FIRMWARE_UPGRADE_BIND_IF
+        bool "Support firmware upgrade bind specified interface"
+        default n
+        help
+            This allows you to bind specified interface in OTA example.
+
+    choice EXAMPLE_FIRMWARE_UPGRADE_BIND_IF_TYPE
+        prompt "Choose OTA data bind interface"
+        default EXAMPLE_FIRMWARE_UPGRADE_BIND_IF_STA
+        depends on EXAMPLE_FIRMWARE_UPGRADE_BIND_IF
+        help
+            Select which interface type of OTA data go through.
+
+        config EXAMPLE_FIRMWARE_UPGRADE_BIND_IF_STA
+            bool "Bind wifi station interface"
+            depends on EXAMPLE_CONNECT_WIFI
+            help
+                Select wifi station interface to pass the OTA data.
+
+        config EXAMPLE_FIRMWARE_UPGRADE_BIND_IF_ETH
+            bool "Bind ethernet interface"
+            depends on EXAMPLE_CONNECT_ETHERNET
+            help
+                Select ethernet interface to pass the OTA data.
+    endchoice
+endmenu

RT200T_2_ESP32/main/MCU_Core_Protocol.c

+#include "Protocol_Lib.h"
+#include "MCU_Core_Protocol.h"
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include "Protocol_User.h"
+#include "gatts_table_creat_demo.h"
+
+#include "app_Ble_User.h"
+
+
+
+

RT200T_2_ESP32/main/MCU_Core_Protocol.h

+#ifndef _MCU_CORE_PROTOCOL_H_
+#define _MCU_CORE_PROTOCOL_H_
+
+#include "Protocol_Lib.h"
+
+#endif

RT200T_2_ESP32/main/Protocol_CRC16.c

+/**
+ * @file        Protocol_CRC16.c
+ * @brief       CRC16计算
+ * @details     CRC16计算
+ * @author      myliu
+ * @date        2022.05.09
+ * @version     V1.0
+ * @copyright   myiu
+ */
+#include "Protocol_CRC16.h"
+
+static const Protocol_uint8_t CRC16_TAB_H [ 256 ] = {0x00u, 0xC1u, 0x81u, 0x40u, 0x01u, 0xC0u, 0x80u, 0x41u, 0x01u, 0xC0u, 0x80u, 0x41u, 0x00u, 0xC1u, 0x81u, 0x40u, 0x01u, 0xC0u, 0x80u, 0x41u, 0x00u, 0xC1u, 0x81u, 0x40u, 0x00u, 0xC1u, 0x81u, 0x40u, 0x01u, 0xC0u, 0x80u, 0x41u, 0x01u, 0xC0u, 0x80u, 0x41u, 0x00u, 0xC1u, 0x81u, 0x40u, 0x00u, 0xC1u, 0x81u, 0x40u, 0x01u, 0xC0u, 0x80u, 0x41u, 0x00u, 0xC1u, 0x81u, 0x40u, 0x01u, 0xC0u, 0x80u, 0x41u, 0x01u, 0xC0u, 0x80u, 0x41u, 0x00u, 0xC1u, 0x81u, 0x40u, 0x01u, 0xC0u, 0x80u, 0x41u, 0x00u, 0xC1u, 0x81u, 0x40u, 0x00u, 0xC1u, 0x81u, 0x40u, 0x01u, 0xC0u, 0x80u, 0x41u, 0x00u, 0xC1u, 0x81u, 0x40u, 0x01u, 0xC0u, 0x80u, 0x41u, 0x01u, 0xC0u, 0x80u, 0x41u, 0x00u, 0xC1u, 0x81u, 0x40u, 0x00u, 0xC1u, 0x81u, 0x40u, 0x01u, 0xC0u, 0x80u, 0x41u, 0x01u, 0xC0u, 0x80u, 0x41u, 0x00u, 0xC1u, 0x81u, 0x40u, 0x01u, 0xC0u, 0x80u, 0x41u, 0x00u, 0xC1u, 0x81u, 0x40u, 0x00u, 0xC1u, 0x81u, 0x40u, 0x01u, 0xC0u, 0x80u, 0x41u, 0x01u, 0xC0u, 0x80u, 0x41u, 0x00u, 0xC1u, 0x81u, 0x40u, 0x00u, 0xC1u, 0x81u, 0x40u, 0x01u, 0xC0u, 0x80u, 0x41u, 0x00u, 0xC1u, 0x81u, 0x40u, 0x01u, 0xC0u, 0x80u, 0x41u, 0x01u, 0xC0u, 0x80u, 0x41u, 0x00u, 0xC1u, 0x81u, 0x40u, 0x00u, 0xC1u, 0x81u, 0x40u, 0x01u, 0xC0u, 0x80u, 0x41u, 0x01u, 0xC0u, 0x80u, 0x41u, 0x00u, 0xC1u, 0x81u, 0x40u, 0x01u, 0xC0u, 0x80u, 0x41u, 0x00u, 0xC1u, 0x81u, 0x40u, 0x00u, 0xC1u, 0x81u, 0x40u, 0x01u, 0xC0u, 0x80u, 0x41u, 0x00u, 0xC1u, 0x81u, 0x40u, 0x01u, 0xC0u, 0x80u, 0x41u, 0x01u, 0xC0u, 0x80u, 0x41u, 0x00u, 0xC1u, 0x81u, 0x40u, 0x01u, 0xC0u, 0x80u, 0x41u, 0x00u, 0xC1u, 0x81u, 0x40u, 0x00u, 0xC1u, 0x81u, 0x40u, 0x01u, 0xC0u, 0x80u, 0x41u, 0x01u, 0xC0u, 0x80u, 0x41u, 0x00u, 0xC1u, 0x81u, 0x40u, 0x00u, 0xC1u, 0x81u, 0x40u, 0x01u, 0xC0u, 0x80u, 0x41u, 0x00u, 0xC1u, 0x81u, 0x40u, 0x01u, 0xC0u, 0x80u, 0x41u, 0x01u, 0xC0u, 0x80u, 0x41u, 0x00u, 0xC1u, 0x81u, 0x40u};
+
+static const Protocol_uint8_t CRC16_TAB_L [ 256 ] = {0x00u, 0xC0u, 0xC1u, 0x01u, 0xC3u, 0x03u, 0x02u, 0xC2u, 0xC6u, 0x06u, 0x07u, 0xC7u, 0x05u, 0xC5u, 0xC4u, 0x04u, 0xCCu, 0x0Cu, 0x0Du, 0xCDu, 0x0Fu, 0xCFu, 0xCEu, 0x0Eu, 0x0Au, 0xCAu, 0xCBu, 0x0Bu, 0xC9u, 0x09u, 0x08u, 0xC8u, 0xD8u, 0x18u, 0x19u, 0xD9u, 0x1Bu, 0xDBu, 0xDAu, 0x1Au, 0x1Eu, 0xDEu, 0xDFu, 0x1Fu, 0xDDu, 0x1Du, 0x1Cu, 0xDCu, 0x14u, 0xD4u, 0xD5u, 0x15u, 0xD7u, 0x17u, 0x16u, 0xD6u, 0xD2u, 0x12u, 0x13u, 0xD3u, 0x11u, 0xD1u, 0xD0u, 0x10u, 0xF0u, 0x30u, 0x31u, 0xF1u, 0x33u, 0xF3u, 0xF2u, 0x32u, 0x36u, 0xF6u, 0xF7u, 0x37u, 0xF5u, 0x35u, 0x34u, 0xF4u, 0x3Cu, 0xFCu, 0xFDu, 0x3Du, 0xFFu, 0x3Fu, 0x3Eu, 0xFEu, 0xFAu, 0x3Au, 0x3Bu, 0xFBu, 0x39u, 0xF9u, 0xF8u, 0x38u, 0x28u, 0xE8u, 0xE9u, 0x29u, 0xEBu, 0x2Bu, 0x2Au, 0xEAu, 0xEEu, 0x2Eu, 0x2Fu, 0xEFu, 0x2Du, 0xEDu, 0xECu, 0x2Cu, 0xE4u, 0x24u, 0x25u, 0xE5u, 0x27u, 0xE7u, 0xE6u, 0x26u, 0x22u, 0xE2u, 0xE3u, 0x23u, 0xE1u, 0x21u, 0x20u, 0xE0u, 0xA0u, 0x60u, 0x61u, 0xA1u, 0x63u, 0xA3u, 0xA2u, 0x62u, 0x66u, 0xA6u, 0xA7u, 0x67u, 0xA5u, 0x65u, 0x64u, 0xA4u, 0x6Cu, 0xACu, 0xADu, 0x6Du, 0xAFu, 0x6Fu, 0x6Eu, 0xAEu, 0xAAu, 0x6Au, 0x6Bu, 0xABu, 0x69u, 0xA9u, 0xA8u, 0x68u, 0x78u, 0xB8u, 0xB9u, 0x79u, 0xBBu, 0x7Bu, 0x7Au, 0xBAu, 0xBEu, 0x7Eu, 0x7Fu, 0xBFu, 0x7Du, 0xBDu, 0xBCu, 0x7Cu, 0xB4u, 0x74u, 0x75u, 0xB5u, 0x77u, 0xB7u, 0xB6u, 0x76u, 0x72u, 0xB2u, 0xB3u, 0x73u, 0xB1u, 0x71u, 0x70u, 0xB0u, 0x50u, 0x90u, 0x91u, 0x51u, 0x93u, 0x53u, 0x52u, 0x92u, 0x96u, 0x56u, 0x57u, 0x97u, 0x55u, 0x95u, 0x94u, 0x54u, 0x9Cu, 0x5Cu, 0x5Du, 0x9Du, 0x5Fu, 0x9Fu, 0x9Eu, 0x5Eu, 0x5Au, 0x9Au, 0x9Bu, 0x5Bu, 0x99u, 0x59u, 0x58u, 0x98u, 0x88u, 0x48u, 0x49u, 0x89u, 0x4Bu, 0x8Bu, 0x8Au, 0x4Au, 0x4Eu, 0x8Eu, 0x8Fu, 0x4Fu, 0x8Du, 0x4Du, 0x4Cu, 0x8Cu, 0x44u, 0x84u, 0x85u, 0x45u, 0x87u, 0x47u, 0x46u, 0x86u, 0x82u, 0x42u, 0x43u, 0x83u, 0x41u, 0x81u, 0x80u, 0x40u};
+
+/**
+ * 获取CRC16校验和
+ */
+/**
+ * @brief 计算传入数据的CRC16
+ * @param[in] pData     计算的数据内容
+ * @param[in] len       计算的数据长度
+ *
+ * @return    校验和
+ *
+ * @since 1.0.0
+ */
+Protocol_uint16_t getCheckSum(const Protocol_uint8_t *pData, int len)
+{
+    Protocol_uint8_t  u8_crc_h = 0xFFu;
+    Protocol_uint8_t  u8_crc_l = 0xFFu;
+    Protocol_uint8_t  u8_index = 0u;
+    Protocol_uint8_t  i        = 0u;
+    Protocol_uint16_t re_value;
+
+    while ( len-- )
+    {
+        u8_index = u8_crc_h ^ (pData [ i++ ]);
+        u8_crc_h = u8_crc_l ^ CRC16_TAB_H [ u8_index ];
+        u8_crc_l = CRC16_TAB_L [ u8_index ];
+    }
+
+    re_value = ( Protocol_uint16_t )u8_crc_h << 8u;
+    re_value |= u8_crc_l;
+
+    return re_value;
+}

RT200T_2_ESP32/main/Protocol_CRC16.h

+#ifndef PROTOCOL_CRC16_H
+#define PROTOCOL_CRC16_H
+
+#include "Protocol_Lib.h"
+
+Protocol_uint16_t getCheckSum(const Protocol_uint8_t *pData, int len);
+
+#endif

RT200T_2_ESP32/main/Protocol_Lib.c

+/**
+ * @file        Protocol_Lib.c
+ * @brief       串口协议解析
+ * @details     串口协议解析
+ * @author      myliu
+ * @date        2022.05.09
+ * @version     V1.0
+ * @copyright   myiu
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include "Protocol_CRC16.h"
+#include "gatts_table_creat_demo.h"
+static UARTOpen          UARTOpen_Cbk;
+static UARTSend          UARTSend_Cbk;
+static UARTRead          UARTRead_Cbk;
+static ProcParse         ProcParseCbk;
+static UARTClose         UARTClose_Cbk;
+static ProtocolSetData   ProtocolSetData_Cbk;
+static Protocol_uint8_t *mDataBufPtr   = Protocol_NULL;
+static Protocol_uint16_t mDataBufLen   = 0;
+static Protocol_uint32_t DataBufMaxLen = 0;
+//#define DEBUG_PRO_DATA 0
+/**
+ * @brief 初始化函数
+ * @param[in] pMemSpace 分配给协议库的内存空间，用来缓存串口数据
+ * @param[in] MemLen    分配的内存空间大小
+ * @param[in] pFunc     回调函数，包括串口打开、发送、读取、关闭，也包括解析后数据回传
+ * @param[in] ProcParseCbk 此回调函数，返回数据从FrameNo开始到CRC16之前，和ProtocolSetData_Cbk二选一
+ * @param[in] ProtocolSetData_Cbk 此回调函数，返回数据区分命令字、电源状态等，和ProcParseCbk二选一，详见结构体Protocol_Data_t
+ *
+ * @warning 此函数KL30和Wakeup都要调用，否则未分配内存，功能不好使，也有可能造成野指针复位
+ *
+ * @since 1.0.0
+ */
+void Protocol_Init(Protocol_uint8_t *pMemSpace, Protocol_uint32_t MemLen, Protocol_Func_t *pFunc)
+{
+    mDataBufPtr         = pMemSpace;
+    DataBufMaxLen       = MemLen;
+    UARTOpen_Cbk        = pFunc->UARTOpen_Cbk;
+    UARTSend_Cbk        = pFunc->UARTSend_Cbk;
+    UARTRead_Cbk        = pFunc->UARTRead_Cbk;
+    ProcParseCbk        = pFunc->ProcParseCbk;
+    UARTClose_Cbk       = pFunc->UARTClose_Cbk;
+    ProtocolSetData_Cbk = pFunc->ProtocolSetData_Cbk;
+
+    if ( UARTOpen_Cbk != Protocol_NULL )
+    {
+        UARTOpen_Cbk( );
+    }
+
+    return;
+}
+
+/**
+ * @brief 串口协议服务函数，包括读取数据，解析数据，如在外部读取数据，可不调用此函数
+ *
+ * @warning 此函数可自定义周期调用，建议20ms周期调用，最大不可超过协议的最小发送周期
+ *
+ * @since 1.0.0
+ */
+void Protocol_Service(void)
+{
+    int               len;
+    Protocol_uint32_t readNum = 0;
+
+    if ( UARTRead_Cbk != Protocol_NULL )
+    {
+        readNum = UARTRead_Cbk(mDataBufPtr + mDataBufLen, 256 - mDataBufLen);
+        if ( readNum > 0 )
+        {
+            mDataBufLen += readNum;
+            // 解析协议
+            len = Protocol_Parse(mDataBufPtr, mDataBufLen);
+            if ( (len > 0) && (len < mDataBufLen) )
+            {
+                // 将未解析的数据移到头部
+                // Move unparsed data to the head
+                memcpy(mDataBufPtr, mDataBufPtr + len, mDataBufLen - len);
+            }
+
+            mDataBufLen -= len;
+        }
+    }
+}
+
+/**
+ * @brief 协议解析函数，如外部获取数据（例如中断），可直接调用此函数解析数据
+ * @param[in] pData     协议数据内容
+ * @param[in] len       需要处理的协议数据长度
+ *
+ * @return    剩余已处理的数据长度
+ *
+ * @since 1.0.0
+ */
+Protocol_uint32_t Protocol_Parse(const Protocol_uint8_t *pData, Protocol_uint32_t len)
+{
+    Protocol_uint32_t remainLen = len;    // 剩余数据长度 Remaining data length
+    Protocol_uint32_t dataLen;            // 数据包长度 Packet length
+    Protocol_uint32_t frameLen;           // 帧长度 Frame length
+    Protocol_uint32_t frameSum;
+    Protocol_Data_t   ProcData;
+    int               i = 0;
+    int               dataBuf [ 256 ];
+
+    /**
+     * 以下部分需要根据协议格式进行相应的修改，解析出每一帧的数据
+     */
+    while ( remainLen >= DATA_PACKAGE_MIN_LEN )
+    {
+        // 找到一帧数据的数据头
+        // Find the data header of a frame of data
+        while ( (remainLen >= 2) && ((pData [ 0 ] != CMD_HEAD1) || (pData [ 1 ] != CMD_HEAD2)) )
+        {
+            pData++;
+            remainLen--;
+            continue;
+        }
+
+        if ( remainLen < DATA_PACKAGE_MIN_LEN )
+        {
+#ifdef DEBUG_PRO_DATA
+
+            d_printf("too short!!!!!!\n");
+#endif
+            break;
+        }
+
+        dataLen  = pData [ 2 ];
+        frameLen = dataLen + DATA_PACKAGE_FIXED_LEN;
+        if ( frameLen > remainLen )
+        {
+            // 数据内容不全
+#ifdef DEBUG_PRO_DATA
+
+            d_printf("Incomplete data packet!!!!!!\n");
+#endif
+            break;
+        }
+
+        // 打印一帧数据，需要时在CommDef.h文件中打开DEBUG_PRO_DATA宏
+#ifdef DEBUG_PRO_DATA
+        for ( i = 0; i < frameLen; ++i )
+        {
+            d_printf("%x ", pData [ i ]);
+        }
+        d_printf("\n");
+#endif
+
+        // 检测校验码 Checksum 
+        frameSum = (pData [ frameLen - 2 ] << 8) | (pData [ frameLen - 1 ]);
+        if ( frameLen > 4 )
+        {
+            if ( getCheckSum(pData + 2, frameLen - 4) == frameSum )
+            {
+                // 解析一帧数据
+                if ( ProcParseCbk != Protocol_NULL )
+                {
+                    ProcParseCbk(pData + 3, dataLen - 2);
+                }
+
+                if ( ProtocolSetData_Cbk != Protocol_NULL )
+                {
+                    ProcData.FrameNo  = pData [ 3 ];
+                    ProcData.PowerSts = (pData [ 4 ] >> 6) & 0x03;
+                    ProcData.CmdID    = pData [ 4 ] & 0x3F;
+                    if ( ProcData.CmdID == 0x10 )
+                    {
+#ifdef DEBUG_PRO_DATA
+                        for ( i = 0; i < frameLen; ++i )
+                        {
+                            d_printf("%x ", pData [ i ]);
+                        }
+                        d_printf("\n");
+#endif
+                    }
+                    if ( ProcData.CmdID == 0x12 )
+                    {
+#ifdef DEBUG_PRO_DATA
+                        for ( i = 0; i < frameLen; ++i )
+                        {
+                            d_printf("%x ", pData [ i ]);
+                        }
+                        d_printf("\n");
+#endif
+                    }
+                    ProcData.DataLen = dataLen - 4;
+                    memcpy(ProcData.Data, pData + 5, ProcData.DataLen);
+                    ProtocolSetData_Cbk(&ProcData);
+                }
+            }
+            else
+            {
+                for ( i = 0; i < frameLen; ++i )
+                {
+                    dataBuf [ i ] = pData [ i ];
+                }
+                i = 0;
+#ifdef DEBUG_PRO_DATA
+
+                d_printf("CheckSum error: new = %x, old = %x!!!!!!\n", getCheckSum(pData + 2, frameLen - 4), frameSum);
+#endif
+            }
+        }
+
+        pData += frameLen;
+        remainLen -= frameLen;
+    }
+
+    return len - remainLen;
+}
+
+/**
+ * 根据协议格式进行拼接
+ */
+/**
+ * @brief 串口协议数据拼接，如初始化发送函数，调用此函数后，数据已通过串口发送
+ * @param[in] cmdID     命令字
+ * @param[in] pData     协议数据内容（不包括协议头、长度、帧序号、命令字、校验和，从数据域算起）
+ * @param[in] len       数据域长度
+ *
+ * @return    已发送的数据长度
+ *
+ * @since 1.0.0
+ */
+Protocol_uint32_t Protocol_Send(const Protocol_uint16_t cmdID, const Protocol_uint8_t *pData, Protocol_uint8_t len)
+{
+    int               i        = 0;
+    Protocol_uint16_t checksum = 0;
+    Protocol_uint8_t  dataBuf [ 256 ];
+    Protocol_uint32_t frameLen;
+
+    if ( len + DATA_PACKAGE_MIN_LEN > 256 )
+    {
+        // printf("sendProtocol data is too len !!!\n");
+        return 0;
+    }
+
+    dataBuf [ 0 ] = CMD_HEAD1;
+    dataBuf [ 1 ] = CMD_HEAD2;    // 同步帧头 Sync frame header
+
+    dataBuf [ 2 ] = len + 4;
+    dataBuf [ 3 ] = len;    // 命令字节 Command byte
+
+    dataBuf [ 4 ] = ( Protocol_uint8_t )cmdID;
+
+    frameLen = 5;
+
+    // 数据 Data
+    for ( i = 0; i < len; ++i )
+    {
+        dataBuf [ frameLen ] = pData [ i ];
+        frameLen++;
+    }
+
+
+    // 校验码 Checksum
+    checksum             = getCheckSum(dataBuf + 2, frameLen - 2);
+    dataBuf [ frameLen ] = (checksum >> 8) & 0x00FF;
+    frameLen++;
+    dataBuf [ frameLen ] = checksum & 0x00FF;
+    frameLen++;
+
+
+    if ( UARTSend_Cbk != Protocol_NULL )
+    {
+        return UARTSend_Cbk(dataBuf, frameLen);
+    }
+    else
+    {
+        return 0;
+    }
+}

RT200T_2_ESP32/main/Protocol_Lib.h

+#ifndef PROTOCOL_LIB_H
+#define PROTOCOL_LIB_H
+
+/*
+Platform_32Bit
+Platform_16Bit
+*/
+#ifdef Platform_16Bit
+    #define Protocol_uint8_t  unsigned char
+    #define Protocol_uint16_t unsigned int
+    #define Protocol_uint32_t unsigned long
+#else
+    #define Protocol_uint8_t  unsigned char
+    #define Protocol_uint16_t unsigned short
+    #define Protocol_uint32_t unsigned int
+    #define Protocol_uint64_t unsigned long long
+#endif
+
+#ifndef Protocol_NULL
+    #define Protocol_NULL ( void * )0u
+#endif /* NULL */
+
+/**<0xEB 0x90 长度 帧序号 命令字 DATA0-DATAN CRC16_1 CRC16_2*/
+#define DATA_PACKAGE_MIN_LEN   7 /**< 0xEB 0x90 + 长度 + 数据包序号 + CMDID + CRC16_1 + CRC16_2 */
+#define DATA_PACKAGE_FIXED_LEN 3 /**< 未计算在长度内的数据  0xEB 0x90 + 长度位 */
+
+#define CMD_HEAD1 0xEB
+#define CMD_HEAD2 0x90
+
+/**@struct   Protocol_Data_t
+ * @brief    解析后的协议数据
+ */
+typedef struct
+{
+    Protocol_uint8_t FrameNo;      /**< 帧序号 */
+    Protocol_uint8_t PowerSts;     /**< 电源状态 */
+    Protocol_uint8_t CmdID;        /**< 命令字 */
+    Protocol_uint8_t DataLen;      /**< 有效数据长度 DATA0-DATAN*/
+    Protocol_uint8_t Data [ 256 ]; /**< 有效数据内容 DATA0-DATAN*/
+} Protocol_Data_t;
+
+typedef Protocol_uint8_t (*UARTOpen)(void);
+typedef Protocol_uint32_t (*UARTSend)(const Protocol_uint8_t *pData, Protocol_uint32_t u32Len);
+typedef Protocol_uint32_t (*UARTRead)(Protocol_uint8_t *pData, Protocol_uint32_t u32Len);
+typedef void (*ProtocolSetData)(const Protocol_Data_t *pData);
+typedef void (*ProcParse)(const Protocol_uint8_t *pData, Protocol_uint32_t u32Len);
+typedef void (*UARTClose)(void);
+
+/**@struct   Protocol_Func_t
+ * @brief    协议解析回调函数
+ */
+typedef struct
+{
+    UARTOpen        UARTOpen_Cbk;        /**< 串口打开回调 */
+    UARTSend        UARTSend_Cbk;        /**< 串口发送回调 */
+    UARTRead        UARTRead_Cbk;        /**< 串口读取回调 */
+    UARTClose       UARTClose_Cbk;       /**< 串口关闭回调 */
+    ProcParse       ProcParseCbk;        /**< 解析后的数据, 处理了数据包序号，命令字和电源状态，和ProcParse二选一 */
+    ProtocolSetData ProtocolSetData_Cbk; /**< 不包含 0xEB 0x90 + 长度 + CRC16_1 + CRC16_2，和ProtocolSetData二选一 */
+} Protocol_Func_t;
+
+void              Protocol_Init(Protocol_uint8_t *pMemSpace, Protocol_uint32_t MemLen, Protocol_Func_t *pFunc);
+void              Protocol_Service(void);
+Protocol_uint32_t Protocol_Parse(const Protocol_uint8_t *pData, Protocol_uint32_t len);
+Protocol_uint32_t Protocol_Send(const Protocol_uint16_t cmdID, const Protocol_uint8_t *pData, Protocol_uint8_t len);
+
+#endif

RT200T_2_ESP32/main/Protocol_User.c

+#include <stdint.h>
+#include "Protocol_User.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "freertos/event_groups.h"
+#include "esp_system.h"
+#include "esp_log.h"
+#include "nvs_flash.h"
+#include "esp_bt.h"
+
+#include "esp_gap_ble_api.h"
+#include "esp_gatts_api.h"
+#include "esp_bt_main.h"
+#include "gatts_table_creat_demo.h"
+#include "esp_gatt_common_api.h"
+
+#include "esp_mac.h"
+
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "esp_system.h"
+#include "esp_log.h"
+#include "driver/uart.h"
+#include "string.h"
+#include "driver/gpio.h"
+#include "MCU_Core_Protocol.h"
+#include "Protocol_Lib.h"
+#include "app_Ble_User.h"
+#include "app_BT_User.h"
+
+#include <stdint.h>
+#include <string.h>
+#include <stdbool.h>
+#include <stdio.h>
+
+
+
+#define TAG "Prot_User"
+Protocol_User_Ctrl_Struct Prot_User;
+
+
+
+#define UART_TX_MAX_DEPTH 1024UL          //(2 * 1024UL)    // 4K
+#define UART_RX_MAX_DEPTH (2 * 1024UL)    // 4K
+#define UART_DATA_BUF_LEN (2 * 1024UL)    // 4K
+//extern void OTA_IC_To_Master( uint8_t len);
+typedef struct
+{
+    Protocol_uint32_t read_pos;
+    Protocol_uint32_t write_pos;
+    Protocol_uint8_t  Rx_Buffer [ UART_RX_MAX_DEPTH ];
+} UARTRxBuf_t;
+
+typedef struct
+{
+    Protocol_uint32_t read_pos;
+    Protocol_uint32_t write_pos;
+    Protocol_uint8_t  Tx_Buffer [ UART_TX_MAX_DEPTH ];
+} UARTTxBuf_t;
+
+static UARTRxBuf_t      UARTRxBuf;
+static UARTTxBuf_t      UARTTxBuf;
+static Protocol_uint8_t UsartDataBuf [ 256 ];
+static Protocol_uint8_t mDataBufPtr [ UART_DATA_BUF_LEN ];
+
+static Protocol_uint8_t  Protocol_OpenUart(void);
+static Protocol_uint32_t Protocol_UartRead(Protocol_uint8_t *pData, Protocol_uint32_t u32Len);
+static Protocol_uint32_t Protocol_UartSend(const Protocol_uint8_t *pData, Protocol_uint32_t u32Len);
+static void              Protocol_UartHandle(const Protocol_Data_t *pData);
+
+void Protocol_KL30_Wakeup_Init(void)
+{
+    Protocol_Func_t pFunc;
+
+    pFunc.UARTOpen_Cbk        = Protocol_OpenUart;
+    pFunc.UARTSend_Cbk        = Protocol_UartSend;
+    pFunc.UARTRead_Cbk        = Protocol_UartRead;
+    pFunc.UARTClose_Cbk       = Protocol_NULL;
+    pFunc.ProcParseCbk        = Protocol_NULL;
+    pFunc.ProtocolSetData_Cbk = Protocol_UartHandle;
+    UARTTxBuf.read_pos        = 0;
+    UARTTxBuf.write_pos       = 0;
+    UARTRxBuf.read_pos        = 0;
+    UARTRxBuf.write_pos       = 0;
+
+    Protocol_Init(mDataBufPtr, UART_DATA_BUF_LEN, &pFunc);
+}
+
+
+void Protocol_Send_Service(void)
+{
+    Protocol_uint32_t i       = 0u;
+    Protocol_uint32_t DataLen = 0u;
+    Protocol_uint32_t SendLen = 0u;
+
+
+    if ( UARTTxBuf.write_pos == UARTTxBuf.read_pos )
+    {
+        return;
+    }
+
+    if ( UARTTxBuf.write_pos > UARTTxBuf.read_pos )
+    {
+        DataLen = UARTTxBuf.write_pos - UARTTxBuf.read_pos;
+    }
+    else
+    {
+        DataLen = UART_TX_MAX_DEPTH - (UARTTxBuf.read_pos - UARTTxBuf.write_pos);
+    }
+
+    if ( DataLen > 255 )
+    {
+        SendLen = 255;
+    }
+    else
+    {
+        SendLen = DataLen;
+    }
+
+    for ( i = 0u; i < SendLen; i++ )
+    {
+        UsartDataBuf [ i ] = UARTTxBuf.Tx_Buffer [ UARTTxBuf.read_pos ];
+        UARTTxBuf.read_pos = (UARTTxBuf.read_pos + 1) % UART_TX_MAX_DEPTH;
+    }
+
+
+    bsp_Uart_Send_Data(UsartDataBuf, SendLen);
+
+}
+
+static Protocol_uint8_t Protocol_OpenUart(void)
+{
+#if 0
+    UART_Channel_Config_st_t loc_config;
+
+    loc_config.u32UARTChEn            = 1;
+    loc_config.u32UARTbps             = 115200;
+    loc_config.pfnUARTConfirmCallBack = Protocol_NULL;
+    loc_config.pfnUARTReadMsgCallBack = UART_Put;
+
+    UART_Init(UART_RLIN31, &loc_config);
+#endif
+    return 1;
+}
+
+static Protocol_uint32_t Protocol_UartRead(Protocol_uint8_t *pData, Protocol_uint32_t len)
+{
+    Protocol_uint32_t i       = 0;
+    Protocol_uint32_t DataLen = 0u;
+    Protocol_uint32_t ReadLen = 0u;
+
+    if ( UARTRxBuf.write_pos == UARTRxBuf.read_pos )
+    {
+        return 0;    //队列空
+    }
+
+    if ( UARTRxBuf.write_pos > UARTRxBuf.read_pos )
+    {
+        DataLen = UARTRxBuf.write_pos - UARTRxBuf.read_pos;
+    }
+    else
+    {
+        DataLen = UART_RX_MAX_DEPTH - (UARTRxBuf.read_pos - UARTRxBuf.write_pos);
+    }
+
+    if ( len > DataLen )
+    {
+        ReadLen = DataLen;
+    }
+    else
+    {
+        ReadLen = len;
+    }
+
+    for ( i = 0u; i < ReadLen; i++ )
+    {
+        pData [ i ]        = UARTRxBuf.Rx_Buffer [ UARTRxBuf.read_pos ];
+        UARTRxBuf.read_pos = (UARTRxBuf.read_pos + 1) % UART_RX_MAX_DEPTH;
+    }
+
+    return ReadLen;
+}
+
+static Protocol_uint32_t Protocol_UartSend(const Protocol_uint8_t *pData, Protocol_uint32_t u32Len)
+{
+    Protocol_uint32_t i         = 0;
+    Protocol_uint32_t RemainLen = 0u;
+
+    if ( UARTTxBuf.write_pos >= UARTTxBuf.read_pos )
+    {
+        RemainLen = UART_TX_MAX_DEPTH - (UARTTxBuf.write_pos - UARTTxBuf.read_pos);
+    }
+    else
+    {
+        RemainLen = UARTTxBuf.read_pos - UARTTxBuf.write_pos;
+    }
+
+    if ( u32Len > RemainLen )
+    {
+        return 1;    //队列已满，无法插入队列
+    }
+
+    for ( i = 0; i < u32Len; i++ )
+    {
+        UARTTxBuf.Tx_Buffer [ UARTTxBuf.write_pos ] = pData [ i ];
+        UARTTxBuf.write_pos                         = (UARTTxBuf.write_pos + 1) % UART_TX_MAX_DEPTH;
+    }
+
+    return 0;
+}
+
+static void Protocol_UartHandle(const Protocol_Data_t *pData)
+{
+    if ( pData->CmdID == 0x20 )
+    {
+        //printf("0x20 is get\r\n");
+        if(Prot_User.State < Prot_Start)
+        {
+            Prot_User.State = Prot_Start;
+            printf("Prot_Start \r\n");
+        }
+    }
+    else if(pData->CmdID == 0x03 )
+    {
+        //printf("0x03 is get\r\n");
+        if(Prot_User.State < Prot_Normal)
+        {
+            Prot_User.State = Prot_Normal;
+
+            printf("Prot_Normal \r\n");
+        }
+
+        if(Prot_User.State >= Prot_Start)
+        {
+            // if(pData->DataLen == 33)
+            {
+                if(BT_User.HF_Ctrl != pData->Data[0])
+                {
+                    BT_User.HF_Ctrl = pData->Data[0];
+                }
+
+                if(strncmp((const char *) ble_uerid, (const char *)&(pData->Data[1]), 32) != 0)
+                {
+                    memcpy(( uint8_t * )ble_uerid, (uint8_t *)&(pData->Data[1]), 32);
+                }
+
+                // esp_log_buffer_hex(TAG, ble_uerid, 32);
+                // esp_log_buffer_hex(TAG, &(pData->Data[1]), 32);
+
+                if(Ble_User.UseridUpdate == 0)
+                {
+                    bsp_Ble_Init();
+
+                    printf("get uuid and init ble!!! \r\n");
+                }
+
+                Ble_User.UseridUpdate = 0xAA;
+            }
+        }
+    }
+    else if(pData->CmdID == 0x21 )
+    {
+        //printf("Wifi_OTA_Request is %d\r\n",Wifi_OTA_Request);
+        if(pData->Data[0] == 1)
+        {
+            // if((pData->CmdID & 0xC0) == 0X40)
+            // {
+                if(Wifi_OTA_Request == 0)
+                {
+                    Wifi_OTA_Request = 1;
+                    printf("get ota req! \r\n");
+                }
+            // }
+        }
+    }
+    else
+    {
+    }
+}
+
+void UART_Put(Protocol_uint16_t Data)
+{
+   Protocol_uint32_t nextPos = 0u;
+
+   nextPos = (UARTRxBuf.write_pos + 1) % UART_RX_MAX_DEPTH;
+
+   if ( nextPos == UARTRxBuf.read_pos )
+   {
+       //队列已满，无法插入队列
+   }
+   else
+   {
+       UARTRxBuf.Rx_Buffer [ UARTRxBuf.write_pos ] = Data;
+       UARTRxBuf.write_pos                         = (UARTRxBuf.write_pos + 1) % UART_RX_MAX_DEPTH;
+   }
+    //printf("into UARTRxBuf!!!!\r\n");
+    return;
+}
+
+
+
+/** 
+ *   @brief    Protocol协议应用层数据赋值和发送
+ */
+
+void Protocol_User_Ctrl_Init(void )
+{
+    Prot_User.State = Prot_Idle;
+    Prot_User.TimeDelay = 0;
+}
+
+void Uart_Send_Id10_Pro(void )
+{
+    uint8_t wtemp[1] = {0};
+    wtemp[0] = 1;
+    Protocol_Send(0x10, wtemp, 1);
+}
+
+void Uart_Send_Id12_Pro(void )
+{
+    uint8_t ID12[15] = {0};
+    ID12[0] |= (uint8_t)(BT_User.BT_Sts << 4);
+    ID12[0] |=  Ble_User.Ble_Sts;
+    unsigned int i = 0;
+    for(i = 0;i < 14;i++)
+    {
+        ID12[ i + 1 ] = BT_Device_Name[ i ];
+    }
+    Protocol_Send(0x12, ID12, 15);
+}
+
+void Uart_Send_Id01_Pro(void)
+{
+    uint8_t ID01[6] = {0x00,0x00,0x00,0x00,0x00,0x00};
+    if(Ble_User.Navi_Updat)
+    {   
+        ID01[0] = Ble_Navi_Data.Navi_Sts;
+        ID01[1] = Ble_Navi_Data.Navi_Turn;
+        ID01[2] = Ble_Navi_Data.Navi_Dte[0];
+        ID01[3] = Ble_Navi_Data.Navi_Dte[1];
+        ID01[4] = Ble_Navi_Data.Navi_Dte[2];
+        ID01[5] = Ble_Navi_Data.Navi_Dte[3];
+
+        //printf("转向编码：%d\r\n",Ble_Navi_Data.Navi_Turn);
+    }
+    Protocol_Send(0x01,ID01,6);
+}
+
+
+void Uart_Send_Id02_Pro(void)
+{
+    uint8_t ID02[1] = {0x00};
+    ID02[0] =  BT_User.Call_Sts;
+    Protocol_Send(0x02, ID02, 1);   
+}
+
+
+
+
+void Prot_Send_Msg_Process(void )
+{
+    if(Prot_User.State < Prot_Start)
+    {
+        Uart_Send_Id10_Pro();
+
+        // printf("send 0x10 \r\n");
+    }
+
+    if(Prot_User.State >=  Prot_Start)
+    {
+        if(Prot_User.TimeDelay == 0)
+        {
+            Uart_Send_Id12_Pro();
+            Prot_User.TimeDelay++;
+            // printf("send 0x12 \r\n");
+        }
+        else
+        {
+            Uart_Send_Id01_Pro();
+            Uart_Send_Id02_Pro();
+            Prot_User.TimeDelay = 0;
+             //printf("send 0x01 0x02 \r\n");
+        }
+    }
+}

RT200T_2_ESP32/main/Protocol_User.h

+#ifndef PROTOCOL_USER_H
+#define PROTOCOL_USER_H
+
+#include "Protocol_Lib.h"
+
+
+#define BLE_START_STA        0x10
+#define MCU_REPLY            0x20
+#define BLE_NAVIGATION       0x01
+#define BLE_WEATHER          0x02
+#define BLE_LOCATION         0x03
+#define BLE_STA              0x12
+#define MCU_TO_BLE_INFO      0x21
+
+
+void Protocol_KL30_Wakeup_Init(void);
+void Protocol_Send_Service(void);    // 10ms任务调用
+void UART_Put(Protocol_uint16_t Data);
+
+typedef enum
+{
+    Prot_Idle = 0, 
+    Prot_Starting,
+    Prot_Start,
+    Prot_Normal,
+}Prot_User_State_Enum;
+typedef struct
+{
+    uint8_t State;
+    uint16_t TimeDelay;
+
+}Protocol_User_Ctrl_Struct;
+
+extern Protocol_User_Ctrl_Struct Prot_User;
+void Protocol_User_Ctrl_Init(void );
+
+void Prot_Send_Msg_Process(void );
+
+#endif

RT200T_2_ESP32/main/app_BT_User.c

+
+#include "app_BT_User.h"
+#include <stdio.h> 
+#include "bt_app_hf.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "bt_app_main.h"
+extern esp_bd_addr_t peer_addr;
+
+#define TAG "APP_BLE_USER"
+
+BT_User_Control_Struct BT_User;
+
+#define BT_ReConn_T 3000
+
+void BT_User_Init(void )
+{
+    BT_User.BT_Sts = BT_Idle;
+    BT_User.Call_Sts = Call_Idle;
+    BT_User.ReconnTime = BT_ReConn_T - 500;
+    BT_User.HF_Ctrl = HF_Idle;
+
+}
+
+void BT_Connect_Event_Pro(void )
+{
+    BT_User.BT_Sts = BT_Conn;
+    BT_User.Call_Sts = Call_Idle;
+    BT_User.ReconnTime = BT_ReConn_T - 500;
+    BT_User.HF_Ctrl = HF_Idle;
+    printf("TB CONN\r\n");
+}
+
+
+void BT_DisConnect_Event_Pro(void )
+{
+    BT_User.BT_Sts = BT_Idle;
+    BT_User.Call_Sts = Call_Idle;
+    BT_User.ReconnTime = BT_ReConn_T - 500;
+    BT_User.HF_Ctrl = HF_Idle;
+    printf("TB DISCONN\r\n");
+}
+
+void BT_User_Process(void )
+{
+    switch(BT_User.Call_Sts)
+    {
+        case Call_OutCalling:
+        {
+            if(BT_User.HF_Ctrl == HF_Reject)
+            {
+                hf_reject_handler();
+            }
+            break;
+        }
+        case Call_IncomeCalling:
+        {
+            if(BT_User.HF_Ctrl == HF_Reject)
+            {
+                hf_reject_handler();
+            }
+            else if(BT_User.HF_Ctrl == HF_Answer)
+            {
+                hf_answer_handler();
+            }
+            break;
+        }
+        case Call_InProcess:
+        {
+            if(BT_User.HF_Ctrl == HF_Reject)
+            {
+                hf_reject_handler();
+            }
+
+            break;
+        }
+        case Call_Idle:
+        {
+            break;
+        }
+    }
+
+    BT_User.HF_Ctrl = HF_Idle;
+
+
+    if(BT_User.BT_Sts == BT_Idle)
+    {
+        BT_User.ReconnTime++;
+        if(BT_User.ReconnTime >= BT_ReConn_T)
+        {
+            printf("Connect Start.................\n");
+            if(app_BT_Get_BondDev() == 1)
+            {
+                esp_hf_client_connect(peer_addr);
+            }
+            
+            printf("Connect Over\n");
+
+            BT_User.ReconnTime = 0;
+        }
+    }
+    else
+    {
+    }
+}
+
+
+
+
+
+
+
+

RT200T_2_ESP32/main/app_BT_User.h

+#ifndef _APP_BT_USER_H_
+#define _APP_BT_USER_H_
+
+#include <stdlib.h>
+
+
+typedef enum
+{
+    BT_Idle = 0, 
+    BT_Conn,
+}BT_Sts_Enum;
+
+
+typedef enum
+{
+    Call_Idle = 0, 
+    Call_IncomeCalling,
+    Call_OutCalling,
+    Call_InProcess,
+}Call_Sts_Enum;
+
+typedef enum
+{
+    HF_Idle = 0, 
+    HF_Answer,
+    HF_Reject,
+}Call_HF_Ctrl_Enum;
+
+typedef struct
+{
+    uint8_t BT_Sts;
+    uint8_t Call_Sts;
+    uint16_t ReconnTime;
+    uint8_t HF_Ctrl;
+}BT_User_Control_Struct;
+
+extern BT_User_Control_Struct BT_User;
+
+void BT_Connect_Event_Pro(void );
+void BT_DisConnect_Event_Pro(void );
+void BT_User_Process(void );
+void BT_User_Init(void );
+
+#endif
\ No newline at end of file

RT200T_2_ESP32/main/app_Ble_User.c

+#include "app_Ble_User.h"
+#include "gatts_table_creat_demo.h"
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include "string.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "freertos/event_groups.h"
+#include "freertos/semphr.h"
+#include "MCU_Core_Protocol.h"
+#include "Protocol_User.h"
+#include "main_user.h"
+
+#define TAG "APP_BLE_USER"
+
+
+
+app_Ble_User_Data_Union BleRecData;
+app_Ble_User_Data_Union BleTransData;
+app_Ble_Rec_Data_Ctrl_Struct RecCtrl;
+
+uint8_t Wifi_OTA_Request = 0;
+
+uint8_t ble_key[32]   =  "1BJ7J8S";
+uint8_t ble_uerid[32] =  {0};
+uint8_t ble_pwd[32]   =  {0};
+uint8_t flavor[4]   =  {0x33, 0, 0, 0};
+
+
+SemaphoreHandle_t BleRecSuc_Semaphore;
+
+
+
+
+Ble_User_Control_Struct Ble_User;
+Ble_Navi_Info_Struct Ble_Navi_Data;
+
+
+uint8_t tp_Ble_Crc(uint8_t *data, uint32_t len )
+{
+    uint8_t val = 0;
+
+    for(uint32_t i = 0; i<len; i++)
+    {
+        val ^= data[i];
+    }
+
+    return val;
+}
+
+void Ble_Clear_Rx_Buffer(void )
+{
+    for(int i = 0; i< sizeof(BleRecData.Data); i++)
+    {
+        BleRecData.Data[i] = 0;
+    }
+}
+
+void Ble_Clear_Tx_Buffer(void )
+{
+    for(int i = 0; i< sizeof(BleTransData.Data); i++)
+    {
+        BleTransData.Data[i] = 0;
+    }
+}
+
+
+
+/**************************************************************************/
+
+/**************************************************************************/
+
+uint8_t Ble_Get_User_Info(void )
+{
+    uint8_t i = 0;
+    uint8_t ret = 0;
+    // for(i = 24; i<32;i++)
+    // {
+    //     ble_uerid[i] = 0x30+i-24;
+    //     ble_pwd[i] = 0x30+i-24;
+    // }
+
+    // ble_uerid[0] = 'v';
+    // ble_uerid[1] = 'i';
+    // ble_uerid[2] = 'v';
+    // ble_uerid[3] = 'a';
+    // ble_uerid[4] = 'v';
+    // ble_uerid[5] = 'i';
+    // ble_uerid[6] = 'v';
+    // ble_uerid[7] = 'a';
+    // ble_uerid[8] = 'v';
+    // ble_uerid[9] = 'i';
+    // ble_uerid[10] = 'v';
+    // ble_uerid[11] = 'a';
+    // ble_uerid[12] = 'v';
+    // ble_uerid[13] = 'i';
+    // ble_uerid[14] = 'v';
+    // ble_uerid[15] = 'a';
+    // ble_uerid[16] = 'v';
+    // ble_uerid[17] = 'i';
+    // ble_uerid[18] = 'v';
+    // ble_uerid[19] = 'a';
+    // ble_uerid[20] = 'v';
+    // ble_uerid[21] = 'i';
+    // ble_uerid[22] = 'v';
+    // ble_uerid[23] = 'a';
+
+
+    // ble_pwd[0] = 'C';
+    // ble_pwd[1] = 'C';
+    // ble_pwd[2] = 'N';
+    // ble_pwd[3] = 'C';
+    // ble_pwd[4] = 'v';
+    // ble_pwd[5] = 'i';
+    // ble_pwd[6] = 'v';
+    // ble_pwd[7] = 'a';
+    // ble_pwd[8] = 'v';
+    // ble_pwd[9] = 'i';
+    // ble_pwd[10] = 'v';
+    // ble_pwd[11] = 'a';
+    // ble_pwd[12] = 'v';
+    // ble_pwd[13] = 'i';
+    // ble_pwd[14] = 'v';
+    // ble_pwd[15] = 'a';
+    // ble_pwd[16] = 'v';
+    // ble_pwd[17] = 'i';
+    // ble_pwd[18] = 'v';
+    // ble_pwd[19] = 'a';
+    // ble_pwd[20] = 'v';
+    // ble_pwd[21] = 'i';
+    // ble_pwd[22] = 'v';
+    // ble_pwd[23] = 'a';
+
+    if(Ble_User.UseridUpdate)
+    {
+        ret = 1;
+    }
+    else
+    {
+        ret = 0;
+    }
+
+    return ret;
+}
+
+void Get_Ble_Raw_Data(uint8_t *data, uint32_t len)
+{
+    uint8_t err = 0;
+    uint8_t crc = 0;
+
+    if(len > 1024)
+    {
+        return;
+    }
+    
+
+    if(data[0] == 0x24)
+    {
+        if(RecCtrl.Sts == BleRec_Idle)
+        {
+            // printf("receive data:");
+            //     for(uint16_t i = 0; i< len; i++)
+            //     {
+            //         printf(" %x ", data[i]);
+            //     }
+            //     printf("\r\n");
+
+            //     printf("\r\n");
+
+            RecCtrl.RecLen = 0;
+            memcpy(( uint8_t * )&BleRecData.Data[RecCtrl.RecLen], data, len);
+            RecCtrl.TotalLen = BleRecData.Msg.Lenth +1 ;
+            RecCtrl.RecLen += len;
+            if(RecCtrl.RecLen >= RecCtrl.TotalLen)
+            {
+                crc = tp_Ble_Crc(BleRecData.Data, RecCtrl.TotalLen - 2);
+
+                // printf("receive data:");
+                // for(uint16_t i = 0; i< RecCtrl.TotalLen; i++)
+                // {
+                //     printf(" %x ", BleRecData.Data[i]);
+                // }
+                // printf("\r\n");
+
+                // printf("rec crc = %d\r\n", crc);
+
+
+                if((BleRecData.Data[RecCtrl.TotalLen - 1] != 0x0A) || (crc != BleRecData.Data[RecCtrl.TotalLen - 2]))
+                {
+                    Ble_Clear_Rx_Buffer();
+                    RecCtrl.Sts = BleRec_Idle;
+                }
+                else
+                {
+                    RecCtrl.Sts = BleRec_Suc;
+
+                    xSemaphoreGive(BleRecSuc_Semaphore);
+                }
+            }
+            else
+            {
+                RecCtrl.Sts = BleRec_Start;
+
+                // printf("BleRec_Start \r\n");
+            }
+        }
+    }
+    else
+    {
+        if(RecCtrl.Sts == BleRec_Start)
+        {
+            if((RecCtrl.RecLen+len) <= RecCtrl.TotalLen)
+            {
+                memcpy(( uint8_t * )&BleRecData.Data[RecCtrl.RecLen], data, len);
+                RecCtrl.RecLen += len;
+
+                if(RecCtrl.RecLen >= RecCtrl.TotalLen)
+                {
+                    crc = tp_Ble_Crc(BleRecData.Data, RecCtrl.TotalLen - 2);
+
+                    // printf("receive data:");
+                    // for(uint16_t i = 0; i< RecCtrl.TotalLen; i++)
+                    // {
+                    //     printf(" %x ", BleRecData.Data[i]);
+                    // }
+                    // printf("\r\n");
+
+                    // printf("rec crc = %d\r\n", crc);
+
+                    if((BleRecData.Data[RecCtrl.TotalLen - 1] != 0x0A) || (crc != BleRecData.Data[RecCtrl.TotalLen - 2]))
+                    {
+                        Ble_Clear_Rx_Buffer();
+                        RecCtrl.Sts = BleRec_Idle;
+                    }
+                    else
+                    {
+                        RecCtrl.Sts = BleRec_Suc;
+
+                        xSemaphoreGive(BleRecSuc_Semaphore);
+                    }
+                }
+            }
+            else
+            {
+                //len err
+                Ble_Clear_Rx_Buffer();
+                RecCtrl.Sts = BleRec_Idle;
+            }
+        }
+    }
+
+}
+
+
+
+/**************************************************************************/
+
+/**************************************************************************/
+
+void Ble_Msg_Authr_RLY(void )
+{
+    uint8_t total_frame = 0;
+    uint8_t trans_len = 0;
+    int err;
+    //Authr suc
+    BleTransData.Msg.FrameHeader = 0x24;
+    BleTransData.Msg.Cmd = 0x58;
+    BleTransData.Msg.Lenth = 104;
+    if((BleTransData.Msg.Lenth+1) % 20 == 0)
+    {
+        total_frame = (BleTransData.Msg.Lenth+1) / 20;
+    }
+    else
+    {
+        total_frame = (BleTransData.Msg.Lenth+1) / 20 + 1;
+    }
+    
+    if(Ble_Get_User_Info())
+    {
+        memcpy(( uint8_t * )&BleTransData.Msg.Param[0], ble_key, 32);
+        memcpy(( uint8_t * )&BleTransData.Msg.Param[32], ble_uerid, 32);
+        memcpy(( uint8_t * )&BleTransData.Msg.Param[64], ble_pwd, 32);
+        memcpy(( uint8_t * )&BleTransData.Msg.Param[96], flavor, 4);
+    }
+    BleTransData.Data[BleTransData.Msg.Lenth - 1] = tp_Ble_Crc(BleTransData.Data, BleTransData.Msg.Lenth - 1);
+    BleTransData.Data[BleTransData.Msg.Lenth] = 0x0A;
+
+    for(uint8_t i = 0; i < total_frame; i++)
+    {
+        if(((BleTransData.Msg.Lenth+1) - 20*i) >= 20)
+        {
+            trans_len = 20;
+        }
+        else
+        {
+            trans_len = (BleTransData.Msg.Lenth+1) - 20*i;
+        }
+
+        // printf("trans_len = %d\r\n", trans_len);
+
+        // printf("trans data:");
+        // for(uint16_t j = 0; j< trans_len; j++)
+        // {
+        //     printf(" %x ", BleTransData.Data[j + i*20]);
+        // }
+        // printf("\r\n");
+
+        // printf("\r\n");
+
+        err = bsp_Ble_Gatts_Send_Indicate( trans_len, &BleTransData.Data[i*20]);
+
+        // vTaskDelay(1);
+    }
+}
+
+void Ble_MsgRec_Authr_Result_Analysis(void )
+{
+    //Authr result
+    if(BleRecData.Msg.Param[0] == 0)
+    {
+        Ble_User.Ble_Sts = Ble_Authr;
+        Ble_User.Request_Navi = 1;
+
+        printf("Authr suc\n");
+    }
+}
+
+
+
+void Ble_Msg_RequestNavi_RLY(void )
+{
+    uint8_t total_frame = 0;
+    uint8_t trans_len = 0;
+
+    if(Ble_User.Request_Navi)
+    {
+        BleTransData.Msg.FrameHeader = 0x24;
+        BleTransData.Msg.Cmd = 0x14;
+        BleTransData.Msg.Lenth = 9;
+        if((BleTransData.Msg.Lenth+1) % 20 == 0)
+        {
+            total_frame = (BleTransData.Msg.Lenth+1) / 20;
+        }
+        else
+        {
+            total_frame = (BleTransData.Msg.Lenth+1) / 20 + 1;
+        }
+
+        BleTransData.Msg.Param[0] = 1;
+        BleTransData.Msg.Param[1] = 80;
+        BleTransData.Msg.Param[2] = 0;
+        BleTransData.Msg.Param[3] = 3;
+        BleTransData.Msg.Param[4] = 0;
+        
+        BleTransData.Data[BleTransData.Msg.Lenth - 1] = tp_Ble_Crc(BleTransData.Data, BleTransData.Msg.Lenth - 1);
+        BleTransData.Data[BleTransData.Msg.Lenth] = 0x0A;
+
+        for(uint8_t i = 0; i < total_frame; i++)
+        {
+            if(((BleTransData.Msg.Lenth+1) - 20*i) >= 20)
+            {
+                trans_len = 20;
+            }
+            else
+            {
+                trans_len = (BleTransData.Msg.Lenth+1) - 20*i;
+            }
+
+            // printf("trans_len = %d\r\n", trans_len);
+
+            // printf("trans data:");
+            // for(uint16_t j = 0; j< trans_len; j++)
+            // {
+            //     printf(" %x ", BleTransData.Data[j + i*20]);
+            // }
+            // printf("\r\n");
+
+            // printf("\r\n");
+
+            bsp_Ble_Gatts_Send_Indicate( trans_len, &BleTransData.Data[i*20]);
+
+            // vTaskDelay(1);
+        }
+
+        Ble_User.Request_Navi = 0;
+    }
+
+
+    
+}
+
+void Ble_MsgRec_Navi_Analysis(void )
+{
+    //Navi data
+    Ble_Navi_Data.Navi_Sts = BleRecData.Msg.Param[0];
+    Ble_Navi_Data.Navi_Turn = BleRecData.Msg.Param[1];
+    Ble_Navi_Data.Navi_Dte[0] = BleRecData.Msg.Param[2];
+    Ble_Navi_Data.Navi_Dte[1] = BleRecData.Msg.Param[3];
+    Ble_Navi_Data.Navi_Dte[2] = BleRecData.Msg.Param[4];
+    Ble_Navi_Data.Navi_Dte[3] = BleRecData.Msg.Param[5];
+
+
+    printf("Navi sts %d    Navi_Turn %x   Navi_Dte0 %x   Navi_Dte1 %x   Navi_Dte2 %x   Navi_Dte3 %x\r\n", \
+    Ble_Navi_Data.Navi_Sts, Ble_Navi_Data.Navi_Turn, Ble_Navi_Data.Navi_Dte[0], Ble_Navi_Data.Navi_Dte[1], Ble_Navi_Data.Navi_Dte[2],Ble_Navi_Data.Navi_Dte[3]);
+
+    Ble_User.Navi_Updat = 1;
+    Ble_User.Navi_T = 0;
+}
+
+void Ble_MsgRec_Navi_Timeout(void )
+{
+    if(Ble_User.Navi_Updat)
+    {
+        Ble_User.Navi_T++;
+        if(Ble_User.Navi_T >= 100)
+        {
+            Ble_User.Navi_Updat = 0;
+            Ble_User.Navi_T = 0;
+        }
+    }
+    else
+    {
+        Ble_User.Navi_T = 0;
+    }
+}
+
+
+
+void Ble_Rec_Msg_Analysis_Process(void )
+{
+    
+    
+}
+
+
+void Ble_Connect_Event_Pro(void )
+{
+    Ble_User.Ble_Sts = Ble_Conn;
+    Ble_User.Request_Navi = 0;
+    Ble_User.Navi_Updat = 0;
+    Ble_User.Navi_T = 0;
+
+    Ble_Clear_Tx_Buffer();
+    Ble_Clear_Rx_Buffer();
+}
+
+
+void Ble_DisConnect_Event_Pro(void )
+{
+    Ble_User.Ble_Sts = Ble_Idle;
+    Ble_User.Request_Navi = 0;
+    Ble_User.Navi_Updat = 0;
+    Ble_User.Navi_T = 0;
+
+    RecCtrl.RecLen = 0;
+    RecCtrl.TotalLen = 0;
+    RecCtrl.Sts = BleRec_Idle;
+
+    Ble_Navi_Data.Navi_Sts = 0;
+    Ble_Navi_Data.Navi_Turn = 0;
+    for(uint8_t i=0; i<sizeof(Ble_Navi_Data.Navi_Dte); i++)
+    {
+        Ble_Navi_Data.Navi_Dte[i] = 0;
+    }
+    
+
+    Ble_Clear_Tx_Buffer();
+    Ble_Clear_Rx_Buffer();
+}
+
+
+void Ble_User_Task(void *pvParameter)
+{
+
+    while (1)
+    {
+        // Ble_Rec_Msg_Analysis_Process();
+        if (pdTRUE == xSemaphoreTake(BleRecSuc_Semaphore, portMAX_DELAY)) 
+        {
+            if(RecCtrl.Sts == BleRec_Suc)
+            {
+                if(BleRecData.Msg.Cmd == EC_BTP_P2C_CLIENT_INFO)
+                {
+                    Ble_Msg_Authr_RLY();
+                }
+                else if(BleRecData.Msg.Cmd == EC_BTP_P2C_CHECK_AUTH_RESULT)
+                {
+                    Ble_MsgRec_Authr_Result_Analysis();
+                    Ble_Msg_RequestNavi_RLY();
+                }
+                else if(BleRecData.Msg.Cmd == EC_BTP_P2C_HUD)
+                {
+                    Ble_MsgRec_Navi_Analysis();
+                }
+
+                Ble_Clear_Tx_Buffer();
+                Ble_Clear_Rx_Buffer();
+                RecCtrl.Sts = BleRec_Idle;
+            }
+        }
+    }
+    vTaskDelete(NULL);
+}
+
+void Ble_User_Init(void )
+{
+    BleRecSuc_Semaphore =     xSemaphoreCreateBinary();
+
+    Ble_User.Ble_Sts = Ble_Idle;
+    Ble_User.Request_Navi = 0;
+    Ble_User.Navi_Updat = 0;
+    Ble_User.Navi_T = 0;
+    Ble_User.UseridUpdate = 0;
+
+    RecCtrl.RecLen = 0;
+    RecCtrl.TotalLen = 0;
+    RecCtrl.Sts = BleRec_Idle;
+
+    Ble_Navi_Data.Navi_Sts = 0;
+    Ble_Navi_Data.Navi_Turn = 0;
+    for(uint8_t i=0; i<sizeof(Ble_Navi_Data.Navi_Dte); i++)
+    {
+        Ble_Navi_Data.Navi_Dte[i] = 0;
+    }
+    
+
+    Ble_Clear_Tx_Buffer();
+    Ble_Clear_Rx_Buffer();
+
+
+    xTaskCreatePinnedToCore(Ble_User_Task, "Ble_User", 4096, NULL, 10, NULL, 0);
+}
+

RT200T_2_ESP32/main/app_Ble_User.h

+#ifndef _APP_BLE_USER_H_
+#define _APP_BLE_USER_H_
+
+#include <stdlib.h>
+
+extern uint8_t ble_uerid[32];
+typedef enum
+{
+    Ble_Idle = 0, 
+    Ble_Conn,
+    Ble_Pair,
+    Ble_Authr,
+}Ble_Sts_Enum;
+
+typedef enum
+{
+    BleRec_Idle = 0, 
+    BleRec_Start,
+
+    BleRec_Suc,
+}Ble_Rec_Sts;
+
+
+
+typedef struct
+{
+    uint8_t Ble_Sts;
+    uint8_t Request_Navi;
+    uint8_t Navi_Updat;
+    uint8_t Navi_T;
+    uint8_t UseridUpdate;
+}Ble_User_Control_Struct;
+
+
+typedef struct
+{
+    uint8_t Navi_Sts;
+    uint8_t Navi_Turn;
+    uint8_t Navi_Dte[4];
+}Ble_Navi_Info_Struct;
+
+
+
+typedef union 
+{
+    struct 
+    {
+        uint8_t FrameHeader;
+        uint8_t Cmd;
+        uint8_t Lenth;
+        uint8_t Param[252];
+    }Msg;
+    uint8_t Data[255];
+}app_Ble_User_Data_Union;
+
+typedef struct 
+{
+    uint32_t RecLen;
+    uint32_t TotalLen;
+    uint8_t Sts;
+}app_Ble_Rec_Data_Ctrl_Struct;
+
+
+extern app_Ble_Rec_Data_Ctrl_Struct RecCtrl;
+extern Ble_User_Control_Struct Ble_User;
+extern Ble_Navi_Info_Struct Ble_Navi_Data;
+extern uint8_t Wifi_OTA_Request;
+
+void Get_Ble_Raw_Data(uint8_t *data, uint32_t len);
+
+
+
+#define EC_BTP_VERSION                      "1.0.5"
+
+#define EC_BTP_OK                           0
+#define EC_BTP_ERR_FAIL                     -1
+
+
+/** @brief    手机向车机汇报客户端信息
+ *   @reqCmd   EC_BTP_P2C_CLIENT_INFO
+ *   @rlyCmd   N/A
+ *   @reqData  
+ *    {
+ *        phoneType:  0                                     ///< 数据类型为int, 0是Android，1是IOS。
+ *        phoneID："zzz",                                   ///< 数据类型为string, 手机ID，可以为IMME或者设备唯一编号，住授权过的手车机端会记机ID。
+ *    }
+ *   @rlyData  N/A
+ */
+#define EC_BTP_P2C_CLIENT_INFO                  0x30
+
+
+/** @brief    车机应答clientinfo
+ *   @reqCmd   EC_BTP_C2P_CLIENT_INFO_RLY
+ *   @rlyCmd   N/A
+ *   @reqData   字段          字节数          内容
+ *              key           32BYTE         格式：字符串。由卡比特项目经理提供
+ *              uuid          32BYTE         格式：字符串。代表每一块仪表的唯一标识，每个仪表都不同。
+ *              pwd           32BYTE         格式：字符串。默认为空，如需要，在卡比特指导下填写。
+ *              flavor        4BYTE          格式：uint32_t。由卡比特项目经理提供。
+ */
+#define EC_BTP_C2P_CLIENT_INFO_RLY              0x58
+
+
+/** @brief    授权结果
+ *   @reqCmd   EC_BTP_P2C_CHECK_AUTH_RESULT
+ *   @rlyCmd   N/A
+ *   @reqData  字段          字节数          内容
+ *          license          1BYTE         校验结果。0:校验成功；其他值校验失败
+ *          msg              64BYTE        如果license不合法，此字段附带错误类型
+ *   @rlyData  N/A
+ */
+#define EC_BTP_P2C_CHECK_AUTH_RESULT            0x60
+
+
+/**
+ * @brief HUD导航图标类型
+ * 
+ */
+#define NaviIconType_NONE                           0        ///< 导航段转向图标类型 无定义，自定义转向图标数组，请忽略这个元素，从左转图标开始
+#define NaviIconType_DEFAULT                        1        ///< 导航段转向图标类型 自车图标，自定义转向图标数组，请忽略这个元素，从左转图标开始
+#define NaviIconType_LEFT                           2        ///< 导航段转向图标类型 左转图标
+#define NaviIconType_RIGHT                          3        ///< 导航段转向图标类型 右转图标
+#define NaviIconType_LEFT_FRONT                     4        ///< 导航段转向图标类型 左前方图标
+#define NaviIconType_RIGHT_FRONT                    5        ///< 导航段转向图标类型 右前方图标
+#define NaviIconType_LEFT_BACK                      6        ///< 导航段转向图标类型 左后方图
+#define NaviIconType_RIGHT_BACK                     7        ///< 导航段转向图标类型 右后方图标
+#define NaviIconType_LEFT_TURN_AROUND               8        ///< 导航段转向图标类型 左转掉头图标
+#define NaviIconType_STRAIGHT                       9        ///< 导航段转向图标类型 直行图标
+#define NaviIconType_ARRIVED_WAYPOINT               10       ///< 导航段转向图标类型 到达途经点图标
+#define NaviIconType_ENTER_ROUNDABOUT               11       ///< 导航段转向图标类型 进入环岛图标
+#define NaviIconType_OUT_ROUNDABOUT                 12       ///< 导航段转向图标类型 驶出环岛图标
+#define NaviIconType_ARRIVED_SERVICE_AREA           13       ///< 导航段转向图标类型 到达服务区图标
+#define NaviIconType_ARRIVED_TOLLGATE               14       ///< 导航段转向图标类型 到达收费站图标
+#define NaviIconType_ARRIVED_DESTINATION            15       ///< 导航段转向图标类型 到达目的地图标
+#define NaviIconType_ARRIVED_TUNNEL                 16       ///< 导航段转向图标类型 到达隧道图标
+#define NaviIconType_CROSSWALK                      17       ///< 导航段转向图标类型：通过人行横道图标
+#define NaviIconType_OVERPASS                       18       ///< 导航段转向图标类型：通过过街天桥图标
+#define NaviIconType_UNDERPASS                      19       ///< 导航段转向图标类型：通过地下通道图标
+#define NaviIconType_SQUARE                         20       ///< 导航段转向图标类型：通过广场图标
+#define NaviIconType_PARK                           21       ///< 导航段转向图标类型：通过公园图标
+#define NaviIconType_STAIRCASE                      22       ///< 导航段转向图标类型：通过扶梯图标
+#define NaviIconType_LIFT                           23       ///< 导航段转向图标类型：通过直梯图标
+#define NaviIconType_CABLEWAY                       24       ///< 导航段转向图标类型：通过索道图标
+#define NaviIconType_SKY_CHANNEL                    25       ///< 导航段转向图标类型：通过空中通道图标
+#define NaviIconType_CHANNEL                        26       ///< 导航段转向图标类型：通过通道、建筑物穿越通道图标
+#define NaviIconType_WALK_ROAD                      27       ///< 导航段转向图标类型：通过行人道路图标
+#define NaviIconType_CRUISE_ROUTE                   28       ///< 导航段转向图标类型：通过游船路线图标
+#define NaviIconType_SIGHTSEEING_BUSLINE            29       ///< 导航段转向图标类型：通过观光车路线图标
+#define NaviIconType_SLIDEWAY                       30       ///< 导航段转向图标类型：通过滑道图标
+#define NaviIconType_LADDER                         31       ///< 导航段转向图标类型：通过阶梯图标
+#define NaviIconType_MERGE_LEFT                     51       ///< 导航段转向图标类型：靠左行驶
+#define NaviIconType_MERGE_RIGHT                    52       ///< 导航段转向图标类型：靠右行驶
+#define NaviIconType_SLOW                           53       ///< 导航段转向图标类型：减速慢行
+#define NaviIconType_ENTRY_RING_LEFT                54       ///< 标准小环岛 绕环岛左转，右侧通行地区的逆时针环岛
+#define NaviIconType_ENTRY_RING_RIGHT               55       ///< 标准小环岛 绕环岛右转，右侧通行地区的逆时针环岛
+#define NaviIconType_ENTRY_RING_CONTINUE            56       ///< 标准小环岛 绕环岛直行，右侧通行地区的逆时针环岛
+#define NaviIconType_ENTRY_RING_UTURN               57       ///< 标准小环岛 绕环岛调头，右侧通行地区的逆时针环岛
+#define NaviIconType_ENTRY_LEFT_RING                58       ///< 进入环岛图标，左侧通行地区的顺时针环岛
+#define NaviIconType_LEAVE_LEFT_RING                59       ///< 驶出环岛图标，左侧通行地区的顺时针环岛
+#define NaviIconType_UTURN_RIGHT                    60       ///< 右转掉头图标，左侧通行地区的掉头
+#define NaviIconType_SPECIAL_CONTINUE               61       ///< 顺行图标(和直行有区别，顺行图标带有虚线)
+#define NaviIconType_ENTRY_LEFT_RING_LEFT           62       ///< 标准小环岛 绕环岛左转，左侧通行地区的顺时针环岛
+#define NaviIconType_ENTRY_LEFT_RING_RIGHT          63       ///< 标准小环岛 绕环岛右转，左侧通行地区的顺时针环岛
+#define NaviIconType_ENTRY_LEFT_RING_CONTINUE       64       ///< 标准小环岛 绕环岛直行，左侧通行地区的顺时针环岛
+#define NaviIconType_ENTRY_LEFT_RING_UTURN          65       ///< 标准小环岛 绕环岛调头，左侧通行地区的顺时针环岛
+#define NaviIconType_SLOPE                          66       ///< 通过斜坡图标
+#define NaviIconType_BRIDGE                         67       ///< 通过桥图标
+#define NaviIconType_FERRYBOAT                      68       ///< 通过渡轮图标
+#define NaviIconType_SUBWAY                         69       ///< 通过地铁图标
+#define NaviIconType_ENTER_BUILDING                 70       ///< 进入建筑物图标
+#define NaviIconType_LEAVE_BUILDING                 71       ///< 离开建筑物图标
+#define NaviIconType_BY_ELEVATOR                    72       ///< 电梯换层图标
+#define NaviIconType_BY_STAIR                       73       ///< 楼梯换层图标
+#define NaviIconType_ESCALATOR                      74       ///< 扶梯换层图标
+#define NaviIconType_LOW_TRAFFIC_CROSS              75       ///< 非导航段通过红绿灯路口图标
+#define NaviIconType_LOW_CROSS                      76       ///< 非导航段通过普通路口图标
+#define NaviIconType_ROTARY_SHARP_LEFT              77       ///< 环岛左后转，右侧通行地区的逆时针环岛
+#define NaviIconType_ROTARY_SHARP_RIGHT             78       ///< 环岛后右转，右侧通行地区的逆时针环岛
+#define NaviIconType_ROTARY_SLIGHT_LEFT             79       ///< 环岛左前转，右侧通行地区的逆时针环岛
+#define NaviIconType_ROTARY_SLIGHT_RIGHT            80       ///< 环岛右前转，右侧通行地区的逆时针环岛
+
+/**
+ * @brief HUD导航功能枚举
+ */
+#define EC_BTP_HUD_FUNCITON_SUPPORT_LOAD 0x01                ///< 路口放大图
+#define EC_BTP_HUD_FUNCITON_SUPPORT_LINE 0x02                ///< 车道引导图
+
+
+/** @brief    
+ *   @reqCmd   EC_BTP_C2P_HUD
+ *   @reqData  字段          字节数          内容
+ *             enable        1BYTE          0:关闭HUD数据，1:开启HUD数据，一次生命周期内只需要发送一次命令。
+ *             maxNaviIcon   2BYTE          车机端支持的导航图标最大值
+ *             funciton      2BYTE          车机端支持的功能，参考 EC_BTP_HUD_FUNCITON_SUPPORT*
+ *   @rlyData  EC_BTP_P2C_HUD
+ */
+#define EC_BTP_C2P_HUD                          0x14
+
+
+#define EC_BTP_NAVI_STATUS_STOPED               0x35          ///< 未导航或导航结束
+#define EC_BTP_NAVI_STATUS_RUNNING              0x33          ///< 正在导航
+
+/** @brief    
+ *   @reqCmd   EC_BTP_P2C_HUD
+ *   @reqData  字段                  字节数      内容
+ *             导航状态              1BYTE       参见:EC_BTP_NAVI_STATUS_*
+ *             导航转向编码          1BYTE       参见:NaviIconType_*
+ *             转向距离              4BYTE       距离转向的距离（单位：米）
+ *             转向⽬的地字节数       1BYTE      转向⽬的地UTF-8所占字节数
+ *             转向⽬的地            60BYTE     最多60个字节（UTF-8编码）
+ *             当前时速              4BYTE      ⻋速（单位：1千米/⼩时）
+ *             导航剩余⾥程          4BYTE       剩余⾥程（单位：米）
+ *             预计到达时间          19BYTE      预计到达时间（格式为：dd.MM.yyyy HH:mm:ss）
+ *             剩余时间              2BYTE       离终点预估剩余时间(单位：分钟)
+ */ 
+#define EC_BTP_P2C_HUD                          0x14
+
+
+
+void Ble_Rec_Msg_Analysis_Process(void );
+
+void Ble_Connect_Event_Pro(void );
+void Ble_DisConnect_Event_Pro(void );
+void Ble_User_Init(void );
+void Ble_Msg_RequestNavi_RLY(void );
+void Ble_MsgRec_Navi_Timeout(void );
+
+#endif
\ No newline at end of file

RT200T_2_ESP32/main/bt_app_core.c

+/*
+ * SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Unlicense OR CC0-1.0
+ */
+
+#include <stdint.h>
+#include <string.h>
+#include <stdbool.h>
+#include "freertos/xtensa_api.h"
+#include "freertos/FreeRTOSConfig.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/queue.h"
+#include "freertos/task.h"
+#include "esp_log.h"
+#include "bt_app_core.h"
+
+static void bt_app_task_handler(void *arg);
+static bool bt_app_send_msg(bt_app_msg_t *msg);
+static void bt_app_work_dispatched(bt_app_msg_t *msg);
+
+static QueueHandle_t bt_app_task_queue = NULL;
+static TaskHandle_t bt_app_task_handle = NULL;
+
+bool bt_app_work_dispatch(bt_app_cb_t p_cback, uint16_t event, void *p_params, int param_len, bt_app_copy_cb_t p_copy_cback)
+{
+    ESP_LOGD(BT_APP_CORE_TAG, "%s event 0x%x, param len %d", __func__, event, param_len);
+
+    bt_app_msg_t msg;
+    memset(&msg, 0, sizeof(bt_app_msg_t));
+
+    msg.sig = BT_APP_SIG_WORK_DISPATCH;
+    msg.event = event;
+    msg.cb = p_cback;
+
+    if (param_len == 0) {
+        return bt_app_send_msg(&msg);
+    } else if (p_params && param_len > 0) {
+        if ((msg.param = malloc(param_len)) != NULL) {
+            memcpy(msg.param, p_params, param_len);
+            /* check if caller has provided a copy callback to do the deep copy */
+            if (p_copy_cback) {
+                p_copy_cback(&msg, msg.param, p_params);
+            }
+            return bt_app_send_msg(&msg);
+        }
+    }
+
+    return false;
+}
+
+static bool bt_app_send_msg(bt_app_msg_t *msg)
+{
+    if (msg == NULL) {
+        return false;
+    }
+
+    if (xQueueSend(bt_app_task_queue, msg, 10 / portTICK_PERIOD_MS) != pdTRUE) {
+        ESP_LOGE(BT_APP_CORE_TAG, "%s xQueue send failed", __func__);
+        return false;
+    }
+    return true;
+}
+
+static void bt_app_work_dispatched(bt_app_msg_t *msg)
+{
+    if (msg->cb) {
+        msg->cb(msg->event, msg->param);
+    }
+}
+
+static void bt_app_task_handler(void *arg)
+{
+    bt_app_msg_t msg;
+    for (;;) {
+        if (pdTRUE == xQueueReceive(bt_app_task_queue, &msg, (TickType_t)portMAX_DELAY)) {
+            ESP_LOGD(BT_APP_CORE_TAG, "%s, sig 0x%x, 0x%x", __func__, msg.sig, msg.event);
+            switch (msg.sig) {
+                case BT_APP_SIG_WORK_DISPATCH:
+                {
+                    bt_app_work_dispatched(&msg);
+                    break;
+                }
+
+                default:
+                    ESP_LOGW(BT_APP_CORE_TAG, "%s, unhandled sig: %d", __func__, msg.sig);
+                    break;
+            } // switch (msg.sig)
+
+            if (msg.param) {
+                free(msg.param);
+            }
+        }
+    }
+}
+
+void bt_app_task_start_up(void)
+{
+    bt_app_task_queue = xQueueCreate(10, sizeof(bt_app_msg_t));
+    xTaskCreate(bt_app_task_handler, "BtAppT", 2048, NULL, configMAX_PRIORITIES - 3, &bt_app_task_handle);
+    return;
+}
+
+void bt_app_task_shut_down(void)
+{
+    if (bt_app_task_handle) {
+        vTaskDelete(bt_app_task_handle);
+        bt_app_task_handle = NULL;
+    }
+    if (bt_app_task_queue) {
+        vQueueDelete(bt_app_task_queue);
+        bt_app_task_queue = NULL;
+    }
+}

RT200T_2_ESP32/main/bt_app_core.h

+/*
+ * SPDX-FileCopyrightText: 2021 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Unlicense OR CC0-1.0
+ */
+
+#ifndef __BT_APP_CORE_H__
+#define __BT_APP_CORE_H__
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <stdio.h>
+
+#define BT_APP_CORE_TAG                   "BT_APP_CORE"
+
+#define BT_APP_SIG_WORK_DISPATCH          (0x01)
+
+/**
+ * @brief     handler for the dispatched work
+ */
+typedef void (* bt_app_cb_t) (uint16_t event, void *param);
+
+/* message to be sent */
+typedef struct {
+    uint16_t             sig;      /*!< signal to bt_app_task */
+    uint16_t             event;    /*!< message event id */
+    bt_app_cb_t          cb;       /*!< context switch callback */
+    void                 *param;   /*!< parameter area needs to be the last */
+} bt_app_msg_t;
+
+/**
+ * @brief     parameter deep-copy function to be customized
+ */
+typedef void (* bt_app_copy_cb_t) (bt_app_msg_t *msg, void *p_dest, void *p_src);
+
+/**
+ * @brief     work dispatcher for the application task
+ */
+bool bt_app_work_dispatch(bt_app_cb_t p_cback, uint16_t event, void *p_params, int param_len, bt_app_copy_cb_t p_copy_cback);
+
+void bt_app_task_start_up(void);
+
+void bt_app_task_shut_down(void);
+
+#endif /* __BT_APP_CORE_H__ */

RT200T_2_ESP32/main/bt_app_hf.c

+/*
+ * SPDX-FileCopyrightText: 2021-2023 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Unlicense OR CC0-1.0
+ */
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <inttypes.h>
+#include "esp_log.h"
+#include "bt_app_core.h"
+#include "bt_app_hf.h"
+#include "esp_bt_main.h"
+#include "esp_bt_device.h"
+#include "esp_gap_bt_api.h"
+#include "esp_hf_client_api.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "freertos/queue.h"
+#include "freertos/semphr.h"
+#include "freertos/ringbuf.h"
+#include "time.h"
+#include "sys/time.h"
+#include "sdkconfig.h"
+
+#include "app_BT_User.h"
+// #include "app_hf_msg_set.h"
+#include "esp_console.h"
+#include "argtable3/argtable3.h"
+
+const char *c_hf_evt_str[] = {
+    "CONNECTION_STATE_EVT",              /*!< connection state changed event */
+    "AUDIO_STATE_EVT",                   /*!< audio connection state change event */
+    "VR_STATE_CHANGE_EVT",                /*!< voice recognition state changed */
+    "CALL_IND_EVT",                      /*!< call indication event */
+    "CALL_SETUP_IND_EVT",                /*!< call setup indication event */
+    "CALL_HELD_IND_EVT",                 /*!< call held indicator event */
+    "NETWORK_STATE_EVT",                 /*!< network state change event */
+    "SIGNAL_STRENGTH_IND_EVT",           /*!< signal strength indication event */
+    "ROAMING_STATUS_IND_EVT",            /*!< roaming status indication event */
+    "BATTERY_LEVEL_IND_EVT",             /*!< battery level indication event */
+    "CURRENT_OPERATOR_EVT",              /*!< current operator name event */
+    "RESP_AND_HOLD_EVT",                 /*!< response and hold event */
+    "CLIP_EVT",                          /*!< Calling Line Identification notification event */
+    "CALL_WAITING_EVT",                  /*!< call waiting notification */
+    "CLCC_EVT",                          /*!< listing current calls event */
+    "VOLUME_CONTROL_EVT",                /*!< audio volume control event */
+    "AT_RESPONSE",                       /*!< audio volume control event */
+    "SUBSCRIBER_INFO_EVT",               /*!< subscriber information event */
+    "INBAND_RING_TONE_EVT",              /*!< in-band ring tone settings */
+    "LAST_VOICE_TAG_NUMBER_EVT",         /*!< requested number from AG event */
+    "RING_IND_EVT",                      /*!< ring indication event */
+    "PKT_STAT_EVT",                      /*!< requested number of packet status event */
+};
+
+// esp_hf_client_connection_state_t
+const char *c_connection_state_str[] = {
+    "disconnected",
+    "connecting",
+    "connected",
+    "slc_connected",
+    "disconnecting",
+};
+
+// esp_hf_client_audio_state_t
+const char *c_audio_state_str[] = {
+    "disconnected",
+    "connecting",
+    "connected",
+    "connected_msbc",
+};
+
+/// esp_hf_vr_state_t
+const char *c_vr_state_str[] = {
+    "disabled",
+    "enabled",
+};
+
+// esp_hf_service_availability_status_t
+const char *c_service_availability_status_str[] = {
+    "unavailable",
+    "available",
+};
+
+// esp_hf_roaming_status_t
+const char *c_roaming_status_str[] = {
+    "inactive",
+    "active",
+};
+
+// esp_hf_client_call_state_t
+const char *c_call_str[] = {
+    "NO call in progress",
+    "call in progress",
+};
+
+// esp_hf_client_callsetup_t
+const char *c_call_setup_str[] = {
+    "NONE",
+    "INCOMING",
+    "OUTGOING_DIALING",
+    "OUTGOING_ALERTING"
+};
+
+// esp_hf_client_callheld_t
+const char *c_call_held_str[] = {
+    "NONE held",
+    "Held and Active",
+    "Held",
+};
+
+// esp_hf_response_and_hold_status_t
+const char *c_resp_and_hold_str[] = {
+    "HELD",
+    "HELD ACCEPTED",
+    "HELD REJECTED",
+};
+
+// esp_hf_client_call_direction_t
+const char *c_call_dir_str[] = {
+    "outgoing",
+    "incoming",
+};
+
+// esp_hf_client_call_state_t
+const char *c_call_state_str[] = {
+    "active",
+    "held",
+    "dialing",
+    "alerting",
+    "incoming",
+    "waiting",
+    "held_by_resp_hold",
+};
+
+// esp_hf_current_call_mpty_type_t
+const char *c_call_mpty_type_str[] = {
+    "single",
+    "multi",
+};
+
+// esp_hf_volume_control_target_t
+const char *c_volume_control_target_str[] = {
+    "SPEAKER",
+    "MICROPHONE"
+};
+
+// esp_hf_at_response_code_t
+const char *c_at_response_code_str[] = {
+    "OK",
+    "ERROR"
+    "ERR_NO_CARRIER",
+    "ERR_BUSY",
+    "ERR_NO_ANSWER",
+    "ERR_DELAYED",
+    "ERR_BLACKLILSTED",
+    "ERR_CME",
+};
+
+// esp_hf_subscriber_service_type_t
+const char *c_subscriber_service_type_str[] = {
+    "unknown",
+    "voice",
+    "fax",
+};
+
+// esp_hf_client_in_band_ring_state_t
+const char *c_inband_ring_state_str[] = {
+    "NOT provided",
+    "Provided",
+};
+
+extern esp_bd_addr_t peer_addr;
+// If you want to connect a specific device, add it's address here
+// esp_bd_addr_t peer_addr = {0xac, 0x67, 0xb2, 0x53, 0x77, 0xbe};
+
+#if CONFIG_BT_HFP_AUDIO_DATA_PATH_HCI
+
+#define ESP_HFP_RINGBUF_SIZE 3600
+static RingbufHandle_t m_rb = NULL;
+
+static void bt_app_hf_client_audio_open(void)
+{
+    m_rb = xRingbufferCreate(ESP_HFP_RINGBUF_SIZE, RINGBUF_TYPE_BYTEBUF);
+}
+
+static void bt_app_hf_client_audio_close(void)
+{
+    if (!m_rb) {
+        return ;
+    }
+
+    vRingbufferDelete(m_rb);
+}
+
+static uint32_t bt_app_hf_client_outgoing_cb(uint8_t *p_buf, uint32_t sz)
+{
+    if (!m_rb) {
+        return 0;
+    }
+
+    size_t item_size = 0;
+    uint8_t *data = xRingbufferReceiveUpTo(m_rb, &item_size, 0, sz);
+    if (item_size == sz) {
+        memcpy(p_buf, data, item_size);
+        vRingbufferReturnItem(m_rb, data);
+        return sz;
+    } else if (0 < item_size) {
+        vRingbufferReturnItem(m_rb, data);
+        return 0;
+    } else {
+        // data not enough, do not read
+        return 0;
+    }
+}
+
+static void bt_app_hf_client_incoming_cb(const uint8_t *buf, uint32_t sz)
+{
+    if (! m_rb) {
+        return;
+    }
+    BaseType_t done = xRingbufferSend(m_rb, (uint8_t *)buf, sz, 0);
+    if (! done) {
+        ESP_LOGE(BT_HF_TAG, "rb send fail");
+    }
+
+    esp_hf_client_outgoing_data_ready();
+}
+#endif /* #if CONFIG_BT_HFP_AUDIO_DATA_PATH_HCI */
+
+/* callback for HF_CLIENT */
+void bt_app_hf_client_cb(esp_hf_client_cb_event_t event, esp_hf_client_cb_param_t *param)
+{
+    if (event <= ESP_HF_CLIENT_PKT_STAT_NUMS_GET_EVT) {
+        ESP_LOGI(BT_HF_TAG, "APP HFP event: %s", c_hf_evt_str[event]);
+    } else {
+        ESP_LOGE(BT_HF_TAG, "APP HFP invalid event %d", event);
+    }
+
+    switch (event) {
+        case ESP_HF_CLIENT_CONNECTION_STATE_EVT:
+        {
+            ESP_LOGI(BT_HF_TAG, "--connection state %s, peer feats 0x%"PRIx32", chld_feats 0x%"PRIx32,
+                    c_connection_state_str[param->conn_stat.state],
+                    param->conn_stat.peer_feat,
+                    param->conn_stat.chld_feat);
+            memcpy(peer_addr,param->conn_stat.remote_bda,ESP_BD_ADDR_LEN);
+
+            if(param->conn_stat.state == 0)
+            {
+                BT_DisConnect_Event_Pro();
+            }
+            else if(param->conn_stat.state == 2)
+            {
+                BT_Connect_Event_Pro();
+            }
+            break;
+        }
+
+        case ESP_HF_CLIENT_AUDIO_STATE_EVT:
+        {
+            ESP_LOGI(BT_HF_TAG, "--audio state %s",
+                    c_audio_state_str[param->audio_stat.state]);
+    #if CONFIG_BT_HFP_AUDIO_DATA_PATH_HCI
+            if (param->audio_stat.state == ESP_HF_CLIENT_AUDIO_STATE_CONNECTED ||
+                param->audio_stat.state == ESP_HF_CLIENT_AUDIO_STATE_CONNECTED_MSBC) {
+                esp_hf_client_register_data_callback(bt_app_hf_client_incoming_cb,
+                                                    bt_app_hf_client_outgoing_cb);
+                bt_app_hf_client_audio_open();
+            } else if (param->audio_stat.state == ESP_HF_CLIENT_AUDIO_STATE_DISCONNECTED) {
+                bt_app_hf_client_audio_close();
+            }
+    #endif /* #if CONFIG_BT_HFP_AUDIO_DATA_PATH_HCI */
+
+            if (param->audio_stat.state == ESP_HF_CLIENT_AUDIO_STATE_CONNECTED ||
+                param->audio_stat.state == ESP_HF_CLIENT_AUDIO_STATE_CONNECTED_MSBC) {
+                    hf_disc_audio_handler();
+                }
+
+            
+            break;
+        }
+
+        case ESP_HF_CLIENT_BVRA_EVT:
+        {
+            ESP_LOGI(BT_HF_TAG, "--VR state %s",
+                    c_vr_state_str[param->bvra.value]);
+            break;
+        }
+
+        case ESP_HF_CLIENT_CIND_SERVICE_AVAILABILITY_EVT:
+        {
+            ESP_LOGI(BT_HF_TAG, "--NETWORK STATE %s",
+                    c_service_availability_status_str[param->service_availability.status]);
+            break;
+        }
+
+        case ESP_HF_CLIENT_CIND_ROAMING_STATUS_EVT:
+        {
+            ESP_LOGI(BT_HF_TAG, "--ROAMING: %s",
+                    c_roaming_status_str[param->roaming.status]);
+            break;
+        }
+
+        case ESP_HF_CLIENT_CIND_SIGNAL_STRENGTH_EVT:
+        {
+            ESP_LOGI(BT_HF_TAG, "-- signal strength: %d",
+                    param->signal_strength.value);
+            break;
+        }
+
+        case ESP_HF_CLIENT_CIND_BATTERY_LEVEL_EVT:
+        {
+            ESP_LOGI(BT_HF_TAG, "--battery level %d",
+                    param->battery_level.value);
+            break;
+        }
+
+        case ESP_HF_CLIENT_COPS_CURRENT_OPERATOR_EVT:
+        {
+            ESP_LOGI(BT_HF_TAG, "--operator name: %s",
+                    param->cops.name);
+            break;
+        }
+
+        case ESP_HF_CLIENT_CIND_CALL_EVT:
+        {
+            ESP_LOGI(BT_HF_TAG, "--Call indicator %s",
+                    c_call_str[param->call.status]);
+
+            if(param->call.status == 0)
+            {
+                BT_User.Call_Sts = Call_Idle;
+
+                printf("call idle\r\n");
+            }
+            else if(param->call.status == 1)
+            {
+                BT_User.Call_Sts = Call_InProcess;
+                printf("call Call_InProcess\r\n");
+            }
+            break;
+        }
+
+        case ESP_HF_CLIENT_CIND_CALL_SETUP_EVT:
+        {
+            ESP_LOGI(BT_HF_TAG, "--Call setup indicator %s",
+                    c_call_setup_str[param->call_setup.status]);
+            
+            switch(param->call_setup.status)
+            {
+                case 0:
+                {
+                    if(BT_User.Call_Sts == Call_IncomeCalling || BT_User.Call_Sts == Call_OutCalling)
+                    {
+                        BT_User.Call_Sts = Call_Idle;
+
+                        printf("call idle\r\n");
+                    }
+                    break;
+                }
+                case 1:
+                {
+                    BT_User.Call_Sts = Call_IncomeCalling;
+
+                    printf("call income\r\n");
+                    break;
+                }
+                case 2:
+                {
+                    BT_User.Call_Sts = Call_OutCalling;
+                    printf("call outcall\r\n");
+                    break;
+                }
+                case 3:
+                {
+                    BT_User.Call_Sts = Call_OutCalling;
+                    printf("call outcall\r\n");
+                    break;
+                }
+            }
+            
+            if(param->call_setup.status == 0)
+            break;
+        }
+
+        case ESP_HF_CLIENT_CIND_CALL_HELD_EVT:
+        {
+            ESP_LOGI(BT_HF_TAG, "--Call held indicator %s",
+                    c_call_held_str[param->call_held.status]);
+            break;
+        }
+
+        case ESP_HF_CLIENT_BTRH_EVT:
+        {
+            ESP_LOGI(BT_HF_TAG, "--response and hold %s",
+                    c_resp_and_hold_str[param->btrh.status]);
+            break;
+        }
+
+        case ESP_HF_CLIENT_CLIP_EVT:
+        {
+            ESP_LOGI(BT_HF_TAG, "--clip number %s",
+                    (param->clip.number == NULL) ? "NULL" : (param->clip.number));
+            break;
+        }
+
+        case ESP_HF_CLIENT_CCWA_EVT:
+        {
+            ESP_LOGI(BT_HF_TAG, "--call_waiting %s",
+                    (param->ccwa.number == NULL) ? "NULL" : (param->ccwa.number));
+            break;
+        }
+
+        case ESP_HF_CLIENT_CLCC_EVT:
+        {
+            ESP_LOGI(BT_HF_TAG, "--Current call: idx %d, dir %s, state %s, mpty %s, number %s",
+                    param->clcc.idx,
+                    c_call_dir_str[param->clcc.dir],
+                    c_call_state_str[param->clcc.status],
+                    c_call_mpty_type_str[param->clcc.mpty],
+                    (param->clcc.number == NULL) ? "NULL" : (param->clcc.number));
+            break;
+        }
+
+        case ESP_HF_CLIENT_VOLUME_CONTROL_EVT:
+        {
+            ESP_LOGI(BT_HF_TAG, "--volume_target: %s, volume %d",
+                    c_volume_control_target_str[param->volume_control.type],
+                    param->volume_control.volume);
+            break;
+        }
+
+        case ESP_HF_CLIENT_AT_RESPONSE_EVT:
+        {
+            ESP_LOGI(BT_HF_TAG, "--AT response event, code %d, cme %d",
+                    param->at_response.code, param->at_response.cme);
+            break;
+        }
+
+        case ESP_HF_CLIENT_CNUM_EVT:
+        {
+            ESP_LOGI(BT_HF_TAG, "--subscriber type %s, number %s",
+                    c_subscriber_service_type_str[param->cnum.type],
+                    (param->cnum.number == NULL) ? "NULL" : param->cnum.number);
+            break;
+        }
+
+        case ESP_HF_CLIENT_BSIR_EVT:
+        {
+            ESP_LOGI(BT_HF_TAG, "--inband ring state %s",
+                    c_inband_ring_state_str[param->bsir.state]);
+            break;
+        }
+
+        case ESP_HF_CLIENT_BINP_EVT:
+        {
+            ESP_LOGI(BT_HF_TAG, "--last voice tag number: %s",
+                    (param->binp.number == NULL) ? "NULL" : param->binp.number);
+            break;
+        }
+        case ESP_HF_CLIENT_PKT_STAT_NUMS_GET_EVT:
+        {
+            ESP_LOGE(BT_HF_TAG, "ESP_HF_CLIENT_PKT_STAT_NUMS_GET_EVT: %d", event);
+            break;
+        }
+        default:
+            ESP_LOGE(BT_HF_TAG, "HF_CLIENT EVT: %d", event);
+            break;
+    }
+}
+
+
+
+
+#define HF_CMD_HANDLER(cmd)    int hf_##cmd##_handler(void )
+
+HF_CMD_HANDLER(conn)
+{
+    printf("connect\n");
+    esp_hf_client_connect(peer_addr);
+    return 0;
+}
+
+HF_CMD_HANDLER(disc)
+{
+    printf("disconnect\n");
+    esp_hf_client_disconnect(peer_addr);
+    return 0;
+}
+
+HF_CMD_HANDLER(conn_audio)
+{
+    printf("connect audio\n");
+    esp_hf_client_connect_audio(peer_addr);
+    return 0;
+}
+
+HF_CMD_HANDLER(disc_audio)
+{
+    printf("disconnect audio\n");
+    esp_hf_client_disconnect_audio(peer_addr);
+    return 0;
+}
+
+HF_CMD_HANDLER(query_op)
+{
+    printf("Query operator\n");
+    esp_hf_client_query_current_operator_name();
+    return 0;
+}
+
+HF_CMD_HANDLER(answer)
+{
+    printf("Answer call\n");
+    esp_hf_client_answer_call();
+    return 0;
+}
+HF_CMD_HANDLER(reject)
+{
+    esp_err_t err;
+    err = esp_hf_client_reject_call();
+    printf("Reject call err %d\n",err);
+    return 0;
+}
+
+const char test_dial_num[] = "17800536969";
+HF_CMD_HANDLER(dial)
+{
+    printf("Dial number %s\n", test_dial_num);
+    esp_hf_client_dial(test_dial_num);
+    return 0;
+}
+
+HF_CMD_HANDLER(redial)
+{
+    printf("Dial number\n");
+    esp_hf_client_dial(NULL);
+    return 0;
+}
+
+HF_CMD_HANDLER(dial_mem)
+{
+    int index = 1;
+    esp_hf_client_dial_memory(index);
+    return 0;
+}
+
+
+HF_CMD_HANDLER(start_vr)
+{
+    printf("Start voice recognition\n");
+    esp_hf_client_start_voice_recognition();
+    return 0;
+}
+
+HF_CMD_HANDLER(stop_vr)
+{
+    printf("Stop voice recognition\n");
+    esp_hf_client_stop_voice_recognition();
+    return 0;
+}
+
+
+// HF_CMD_HANDLER(query_call)
+// {
+//     printf("Query current call status\n");
+//     esp_hf_client_query_current_calls();
+//     return 0;
+// }
+
+// HF_CMD_HANDLER(retrieve_subscriber)
+// {
+//     printf("Retrieve subscriber information\n");
+//     esp_hf_client_retrieve_subscriber_info();
+//     return 0;
+// }
+
+// HF_CMD_HANDLER(request_last_voice_tag)
+// {
+//     printf("Request last voice tag\n");
+//     esp_hf_client_request_last_voice_tag_number();
+//     return 0;
+// }
+
+
+
+// typedef enum {
+//     ESP_HF_BTRH_CMD_HOLD = 0,          /*!< put the incoming call on hold */
+//     ESP_HF_BTRH_CMD_ACCEPT = 1,        /*!< accept a held incoming call */
+//     ESP_HF_BTRH_CMD_REJECT = 2,        /*!< reject a held incoming call */
+// } esp_hf_btrh_cmd_t;
+
+HF_CMD_HANDLER(btrh)
+{
+    int btrh = ESP_HF_BTRH_CMD_HOLD;
+
+    printf("respond and hold command: %d\n", btrh);
+    esp_hf_client_send_btrh_cmd(btrh);
+    return 0;
+}
+
+
+
+
+
+

RT200T_2_ESP32/main/bt_app_hf.h

+/*
+ * SPDX-FileCopyrightText: 2021 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Unlicense OR CC0-1.0
+ */
+
+#ifndef __BT_APP_HF_H__
+#define __BT_APP_HF_H__
+
+#include <stdint.h>
+#include "esp_hf_client_api.h"
+
+
+#define BT_HF_TAG               "BT_HF"
+
+/**
+ * @brief     callback function for HF client
+ */
+void bt_app_hf_client_cb(esp_hf_client_cb_event_t event, esp_hf_client_cb_param_t *param);
+
+
+
+int hf_conn_handler(void );
+int hf_disc_handler(void );
+int hf_conn_audio_handler(void );
+int hf_disc_audio_handler(void );
+int hf_query_op_handler(void );
+int hf_answer_handler(void );
+int hf_reject_handler(void );
+int hf_dial_handler(void );
+int hf_redial_handler(void );
+int hf_dial_mem_handler(void );
+int hf_start_vr_handler(void );
+int hf_stop_vr_handler(void );
+
+
+
+#endif /* __BT_APP_HF_H__*/

RT200T_2_ESP32/main/bt_app_main.c

+/*
+ * SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Unlicense OR CC0-1.0
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <inttypes.h>
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "nvs.h"
+#include "nvs_flash.h"
+#include "esp_system.h"
+#include "esp_log.h"
+#include "esp_bt.h"
+#include "bt_app_core.h"
+#include "esp_bt_main.h"
+#include "esp_bt_device.h"
+#include "esp_gap_bt_api.h"
+#include "esp_hf_client_api.h"
+#include "bt_app_hf.h"
+// #include "gpio_pcm_config.h"
+#include "esp_console.h"
+// #include "app_hf_msg_set.h"
+#include "app_BT_User.h"
+#include "gatts_table_creat_demo.h"
+
+esp_bd_addr_t peer_addr = {0};
+static char peer_bdname[ESP_BT_GAP_MAX_BDNAME_LEN + 1];
+static uint8_t peer_bdname_len;
+int bond_dev_num;
+int last_bond_dev_num = -1;
+
+// esp_bt_gap_remove_bond_device
+
+uint8_t app_BT_Get_BondDev(void )
+{
+    uint8_t ret = 0;
+    bond_dev_num = esp_bt_gap_get_bond_device_num();
+
+    if(bond_dev_num)
+    {
+        esp_bd_addr_t *dev_list = (esp_bd_addr_t *)malloc(sizeof(esp_bd_addr_t) * bond_dev_num);
+        esp_bt_gap_get_bond_device_list(&bond_dev_num, dev_list);
+        memcpy(peer_addr, dev_list[0], 6);
+
+
+        if(bond_dev_num > 1)
+        {
+            for(int i=1; i<bond_dev_num; i++)
+            {
+                esp_bt_gap_remove_bond_device(dev_list[i]);
+            }
+        }
+
+        ret = 1;
+    }
+    else
+    {
+        memset(peer_addr, 0, 6);
+        ret = 0;
+    }
+
+    
+
+    
+
+    return ret;
+}
+
+void BT_Remove_Other_BondDev(void )
+{
+
+}
+
+
+// static const char remote_device_name[] = "ESP_HFP_AG";
+
+static bool get_name_from_eir(uint8_t *eir, char *bdname, uint8_t *bdname_len)
+{
+    uint8_t *rmt_bdname = NULL;
+    uint8_t rmt_bdname_len = 0;
+
+    if (!eir) {
+        return false;
+    }
+
+    rmt_bdname = esp_bt_gap_resolve_eir_data(eir, ESP_BT_EIR_TYPE_CMPL_LOCAL_NAME, &rmt_bdname_len);
+    if (!rmt_bdname) {
+        rmt_bdname = esp_bt_gap_resolve_eir_data(eir, ESP_BT_EIR_TYPE_SHORT_LOCAL_NAME, &rmt_bdname_len);
+    }
+
+    if (rmt_bdname) {
+        if (rmt_bdname_len > ESP_BT_GAP_MAX_BDNAME_LEN) {
+            rmt_bdname_len = ESP_BT_GAP_MAX_BDNAME_LEN;
+        }
+
+        if (bdname) {
+            memcpy(bdname, rmt_bdname, rmt_bdname_len);
+            bdname[rmt_bdname_len] = '\0';
+        }
+        if (bdname_len) {
+            *bdname_len = rmt_bdname_len;
+        }
+        return true;
+    }
+
+    return false;
+}
+
+void esp_bt_gap_cb(esp_bt_gap_cb_event_t event, esp_bt_gap_cb_param_t *param)
+{
+    switch (event) {
+    case ESP_BT_GAP_DISC_RES_EVT: {
+        // esp_hf_client_connect(peer_addr);
+        // esp_bt_gap_cancel_discovery();
+        // printf("event state %d\n", event);
+        break;
+    }
+    case ESP_BT_GAP_DISC_STATE_CHANGED_EVT:
+        ESP_LOGI(BT_HF_TAG, "ESP_BT_GAP_DISC_STATE_CHANGED_EVT");
+    case ESP_BT_GAP_RMT_SRVCS_EVT:
+    case ESP_BT_GAP_RMT_SRVC_REC_EVT:
+        // printf("event state %d\n", event);
+        break;
+    case ESP_BT_GAP_AUTH_CMPL_EVT: {
+        if (param->auth_cmpl.stat == ESP_BT_STATUS_SUCCESS) {
+            ESP_LOGI(BT_HF_TAG, "authentication success: %s", param->auth_cmpl.device_name);
+            esp_log_buffer_hex(BT_HF_TAG, param->auth_cmpl.bda, ESP_BD_ADDR_LEN);
+        } else {
+            ESP_LOGE(BT_HF_TAG, "authentication failed, status:%d", param->auth_cmpl.stat);
+        }
+
+        // printf("event state %d\n", event);
+        break;
+    }
+    case ESP_BT_GAP_PIN_REQ_EVT: {
+        ESP_LOGI(BT_HF_TAG, "ESP_BT_GAP_PIN_REQ_EVT min_16_digit:%d", param->pin_req.min_16_digit);
+        if (param->pin_req.min_16_digit) {
+            ESP_LOGI(BT_HF_TAG, "Input pin code: 0000 0000 0000 0000");
+            esp_bt_pin_code_t pin_code = {0};
+            esp_bt_gap_pin_reply(param->pin_req.bda, true, 16, pin_code);
+        } else {
+            ESP_LOGI(BT_HF_TAG, "Input pin code: 1234");
+            esp_bt_pin_code_t pin_code;
+            pin_code[0] = '1';
+            pin_code[1] = '2';
+            pin_code[2] = '3';
+            pin_code[3] = '4';
+            esp_bt_gap_pin_reply(param->pin_req.bda, true, 4, pin_code);
+        }
+
+        // printf("event state %d\n", event);
+        break;
+    }
+
+#if (CONFIG_BT_SSP_ENABLED == true)
+    case ESP_BT_GAP_CFM_REQ_EVT:
+        ESP_LOGI(BT_HF_TAG, "ESP_BT_GAP_CFM_REQ_EVT Please compare the numeric value: %"PRIu32, param->cfm_req.num_val);
+        esp_bt_gap_ssp_confirm_reply(param->cfm_req.bda, true);
+
+        // printf("event state %d\n", event);
+        break;
+    case ESP_BT_GAP_KEY_NOTIF_EVT:
+        ESP_LOGI(BT_HF_TAG, "ESP_BT_GAP_KEY_NOTIF_EVT passkey:%"PRIu32, param->key_notif.passkey);
+        // printf("event state %d\n", event);
+        break;
+    case ESP_BT_GAP_KEY_REQ_EVT:
+        ESP_LOGI(BT_HF_TAG, "ESP_BT_GAP_KEY_REQ_EVT Please enter passkey!");
+        // printf("event state %d\n", event);
+        break;
+#endif
+
+    case ESP_BT_GAP_MODE_CHG_EVT:
+        ESP_LOGI(BT_HF_TAG, "ESP_BT_GAP_MODE_CHG_EVT mode:%d", param->mode_chg.mode);
+        // printf("event state %d\n", event);
+        break;
+
+    default: {
+        ESP_LOGI(BT_HF_TAG, "event: %d", event);
+        // printf("event state %d\n", event);
+        break;
+    }
+    }
+    return;
+}
+
+/* event for handler "bt_av_hdl_stack_up */
+enum {
+    BT_APP_EVT_STACK_UP = 0,
+};
+
+/* handler for bluetooth stack enabled events */
+static void bt_hf_client_hdl_stack_evt(uint16_t event, void *p_param);
+
+void bsp_BT_Init(void)
+{
+    /* Initialize NVS — it is used to store PHY calibration data */
+    esp_err_t ret = nvs_flash_init();
+    if (ret == ESP_ERR_NVS_NO_FREE_PAGES) {
+        ESP_ERROR_CHECK(nvs_flash_erase());
+        ret = nvs_flash_init();
+    }
+    ESP_ERROR_CHECK( ret );
+
+    // ESP_ERROR_CHECK(esp_bt_controller_mem_release(ESP_BT_MODE_BLE));
+
+    esp_err_t err;
+    esp_bt_controller_config_t bt_cfg = BT_CONTROLLER_INIT_CONFIG_DEFAULT();
+    if ((err = esp_bt_controller_init(&bt_cfg)) != ESP_OK) {
+        ESP_LOGE(BT_HF_TAG, "%s initialize controller failed: %s\n", __func__, esp_err_to_name(ret));
+        return;
+    }
+
+    if ((err = esp_bt_controller_enable(ESP_BT_MODE_BTDM)) != ESP_OK) {
+        ESP_LOGE(BT_HF_TAG, "%s enable controller failed: %s\n", __func__, esp_err_to_name(ret));
+        return;
+    }
+
+    if ((err = esp_bluedroid_init()) != ESP_OK) {
+        ESP_LOGE(BT_HF_TAG, "%s initialize bluedroid failed: %s\n", __func__, esp_err_to_name(ret));
+        return;
+    }
+
+    if ((err = esp_bluedroid_enable()) != ESP_OK) {
+        ESP_LOGE(BT_HF_TAG, "%s enable bluedroid failed: %s\n", __func__, esp_err_to_name(ret));
+        return;
+    }
+
+    /* create application task */
+    bt_app_task_start_up();
+
+    /* Bluetooth device name, connection mode and profile set up */
+    bt_app_work_dispatch(bt_hf_client_hdl_stack_evt, BT_APP_EVT_STACK_UP, NULL, 0, NULL);
+
+#if CONFIG_BT_HFP_AUDIO_DATA_PATH_PCM
+    /* configure the PCM interface and PINs used */
+    // app_gpio_pcm_io_cfg();
+#endif
+
+    /* configure externel chip for acoustic echo cancellation */
+#if ACOUSTIC_ECHO_CANCELLATION_ENABLE
+    // app_gpio_aec_io_cfg();
+#endif /* ACOUSTIC_ECHO_CANCELLATION_ENABLE */
+    // esp_console_repl_t *repl = NULL;
+    // esp_console_repl_config_t repl_config = ESP_CONSOLE_REPL_CONFIG_DEFAULT();
+    // esp_console_dev_uart_config_t uart_config = ESP_CONSOLE_DEV_UART_CONFIG_DEFAULT();
+    // repl_config.prompt = "hfp_hf>";
+
+    // // init console REPL environment
+    // ESP_ERROR_CHECK(esp_console_new_repl_uart(&uart_config, &repl_config, &repl));
+
+    /* Register commands */
+    // register_hfp_hf();
+    // printf("\n ==================================================\n");
+    // printf(" |       Steps to test hfp_hf                     |\n");
+    // printf(" |                                                |\n");
+    // printf(" |  1. Print 'help' to gain overview of commands  |\n");
+    // printf(" |  2. Setup a service level connection           |\n");
+    // printf(" |  3. Run hfp_hf to test                         |\n");
+    // printf(" |                                                |\n");
+    // printf(" =================================================\n\n");
+
+    // start console REPL
+    // ESP_ERROR_CHECK(esp_console_start_repl(repl));
+}
+
+
+static void bt_hf_client_hdl_stack_evt(uint16_t event, void *p_param)
+{
+    ESP_LOGD(BT_HF_TAG, "%s evt %d", __func__, event);
+    switch (event) {
+    case BT_APP_EVT_STACK_UP: {
+        /* set up device name */
+        char *dev_name = "ESP_HFP_HF";
+        esp_bt_dev_set_device_name((char *)BT_Device_Name);
+
+        /* register GAP callback function */
+        esp_bt_gap_register_callback(esp_bt_gap_cb);
+        esp_hf_client_register_callback(bt_app_hf_client_cb);
+        esp_hf_client_init();
+
+        esp_bt_pin_type_t pin_type = ESP_BT_PIN_TYPE_FIXED;
+        esp_bt_pin_code_t pin_code;
+        pin_code[0] = '0';
+        pin_code[1] = '0';
+        pin_code[2] = '0';
+        pin_code[3] = '0';
+        esp_bt_gap_set_pin(pin_type, 4, pin_code);
+
+        /* set discoverable and connectable mode, wait to be connected */
+        esp_bt_gap_set_scan_mode(ESP_BT_CONNECTABLE, ESP_BT_GENERAL_DISCOVERABLE);
+
+        /* start device discovery */
+        ESP_LOGI(BT_HF_TAG, "Starting device discovery...");
+        esp_bt_gap_start_discovery(ESP_BT_INQ_MODE_GENERAL_INQUIRY, 10, 0);
+        break;
+    }
+    default:
+        ESP_LOGE(BT_HF_TAG, "%s unhandled evt %d", __func__, event);
+        break;
+    }
+}

RT200T_2_ESP32/main/bt_app_main.h

+/*
+ * SPDX-FileCopyrightText: 2021 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Unlicense OR CC0-1.0
+ */
+
+#ifndef BT_APP_MAN_H
+#define BT_APP_MAN_H
+
+void bsp_BT_Init(void);
+uint8_t app_BT_Get_BondDev(void );
+#endif
\ No newline at end of file

RT200T_2_ESP32/main/gatts_table_creat_demo.c

+/*
+ * SPDX-FileCopyrightText: 2021-2023 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Unlicense OR CC0-1.0
+ */
+
+/****************************************************************************
+*
+* This demo showcases creating a GATT database using a predefined attribute table.
+* It acts as a GATT server and can send adv data, be connected by client.
+* Run the gatt_client demo, the client demo will automatically connect to the gatt_server_service_table demo.
+* Client demo will enable GATT server's notify after connection. The two devices will then exchange
+* data.
+*
+****************************************************************************/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "freertos/event_groups.h"
+#include "esp_system.h"
+#include "esp_log.h"
+#include "nvs_flash.h"
+#include "esp_bt.h"
+
+#include "esp_gap_ble_api.h"
+#include "esp_gatts_api.h"
+#include "esp_bt_main.h"
+#include "gatts_table_creat_demo.h"
+#include "esp_gatt_common_api.h"
+
+#include "esp_mac.h"
+
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "esp_system.h"
+#include "esp_log.h"
+#include "driver/uart.h"
+#include "string.h"
+#include "driver/gpio.h"
+#include "Protocol_CRC16.h"
+#include "Protocol_Lib.h"
+#include "Protocol_User.h"
+#include "app_Ble_User.h"
+#include "MCU_Core_Protocol.h"
+
+typedef   unsigned char   uint8_t;
+
+unsigned int flag_u;
+
+static const int RX_BUF_SIZE = 1024;
+
+#define TXD_PIN (GPIO_NUM_22)
+#define RXD_PIN (GPIO_NUM_26)
+
+typedef struct
+{
+    uint16_t Rxlen;
+    uint8_t Rxbuff[255];
+} _QJ_UART_Ctrl;
+
+_QJ_UART_Ctrl QJ_UARTRX;
+
+void init_Uart(void) {
+    const uart_config_t uart_config = {
+        .baud_rate = 115200,
+        .data_bits = UART_DATA_8_BITS,
+        .parity = UART_PARITY_DISABLE,
+        .stop_bits = UART_STOP_BITS_1,
+        .flow_ctrl = UART_HW_FLOWCTRL_DISABLE,
+        .source_clk = UART_SCLK_DEFAULT,
+    };
+    // We won't use a buffer for sending data.
+    uart_driver_install(UART_NUM_1, RX_BUF_SIZE * 2, 200, 0, NULL, 0);
+    uart_param_config(UART_NUM_1, &uart_config);
+    uart_set_pin(UART_NUM_1, TXD_PIN, RXD_PIN, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE);
+}
+
+int bsp_Uart_Send_Data(uint8_t * data , unsigned int len)
+{
+    int txBytes = uart_write_bytes(UART_NUM_1, data, len);
+    uart_wait_tx_idle_polling(UART_NUM_1);
+    return txBytes;
+}
+
+
+
+static void Uart_Rx_Task(void *arg)
+{
+    uint8_t* data = (uint8_t*) malloc(RX_BUF_SIZE+1);
+    while (1) 
+    {
+        const int rxBytes = uart_read_bytes(UART_NUM_1, data, RX_BUF_SIZE, 20);
+        if (rxBytes < 1000)
+        {
+            for (uint16_t i = 0; i < rxBytes; i++)
+            {
+                UART_Put(data[i]);
+            }
+        }
+    }
+    free(data);
+}
+
+void bsp_Uart_Init(void )
+{
+    init_Uart();
+    Protocol_KL30_Wakeup_Init();
+    xTaskCreatePinnedToCore(Uart_Rx_Task, "Ble_User", 4096, NULL, 4, NULL, 1);
+}
+
+
+
+
+
+
+
+
+extern void simple_ota_main(void);
+void simple_ota_service(void)
+{
+    if(Wifi_OTA_Request == 1)
+    {
+        Wifi_OTA_Request = 2;
+        simple_ota_main();
+        vTaskDelay(portMAX_DELAY);
+    }
+}
+
+
+
+
+
+
+
+
+
+uint8_t BT_Device_Name[14] = "QJ-Viva";
+
+#define GATTS_TABLE_TAG "GATTS_TABLE_DEMO"
+
+#define PROFILE_NUM                 1
+
+#define PROFILE_APP_IDX             0
+
+#define ESP_APP_ID                  0x55
+#define SAMPLE_DEVICE_NAME          "QJ-Viva"
+#define SVC_INST_ID                 0
+#define SVC_INST_ID1                 1
+
+
+ esp_bd_addr_t rand_addr = {0xC0, 0x30, 0x05, 0x70, 0x09, 0xFA};
+
+/* The max length of characteristic value. When the GATT client performs a write or prepare write operation,
+*  the data length must be less than GATTS_DEMO_CHAR_VAL_LEN_MAX.
+*/
+#define GATTS_DEMO_CHAR_VAL_LEN_MAX 500
+#define PREPARE_BUF_MAX_SIZE        1024
+#define CHAR_DECLARATION_SIZE       (sizeof(uint8_t))
+
+#define ADV_CONFIG_FLAG             (1 << 0)
+#define SCAN_RSP_CONFIG_FLAG        (1 << 1)
+
+static uint8_t adv_config_done       = 0;
+
+uint16_t heart_rate_handle_table[HRS_IDX_NB];
+uint16_t heart_rate_handle_table2[HRS_IDX_NB2];
+
+typedef struct {
+    uint8_t                 *prepare_buf;
+    int                     prepare_len;
+} prepare_type_env_t;
+
+static prepare_type_env_t prepare_write_env;
+
+#define CONFIG_SET_RAW_ADV_DATA
+#ifdef CONFIG_SET_RAW_ADV_DATA
+static uint8_t raw_adv_data[] = {
+        0x02, 0x01, 0x02,
+        0x03, 0x03, 0x69, 0x67,
+        0x09, 0xff, 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+        0x08, 0x09, 'Q', 'J', '-', 'V', 'i', 'v', 'a',  
+
+        // 0x08, 0x16, 0x60, 0xb3, 0x00, 0x00, 0x00, 0x00, 0x00,
+};
+static uint8_t raw_scan_rsp_data[] = {
+        /* flags */
+        0x02, 0x01, 0x02,
+        0x02, 0x0a, 0xeb,
+        /* service uuid */
+        0x03, 0x03, 0x69, 0x67,
+};
+
+#else
+static uint8_t service_uuid[16] = {
+    /* LSB <--------------------------------------------------------------------------------> MSB */
+    //first uuid, 16bit, [12],[13] is the value
+    0xfb, 0x34, 0x9b, 0x5f, 0x80, 0x00, 0x00, 0x80, 0x00, 0x10, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00,
+};
+
+/* The length of adv data must be less than 31 bytes */
+static esp_ble_adv_data_t adv_data = {
+    .set_scan_rsp        = false,
+    .include_name        = true,
+    .include_txpower     = true,
+    .min_interval        = 0x0006, //slave connection min interval, Time = min_interval * 1.25 msec
+    .max_interval        = 0x0010, //slave connection max interval, Time = max_interval * 1.25 msec
+    .appearance          = 0x00,
+    .manufacturer_len    = 0,    //TEST_MANUFACTURER_DATA_LEN,
+    .p_manufacturer_data = NULL, //test_manufacturer,
+    .service_data_len    = 0,
+    .p_service_data      = NULL,
+    .service_uuid_len    = sizeof(service_uuid),
+    .p_service_uuid      = service_uuid,
+    .flag = (ESP_BLE_ADV_FLAG_GEN_DISC | ESP_BLE_ADV_FLAG_BREDR_NOT_SPT),
+};
+
+// scan response data
+static esp_ble_adv_data_t scan_rsp_data = {
+    .set_scan_rsp        = true,
+    .include_name        = true,
+    .include_txpower     = true,
+    .min_interval        = 0x0006,
+    .max_interval        = 0x0010,
+    .appearance          = 0x00,
+    .manufacturer_len    = 0, //TEST_MANUFACTURER_DATA_LEN,
+    .p_manufacturer_data = NULL, //&test_manufacturer[0],
+    .service_data_len    = 0,
+    .p_service_data      = NULL,
+    .service_uuid_len    = sizeof(service_uuid),
+    .p_service_uuid      = service_uuid,
+    .flag = (ESP_BLE_ADV_FLAG_GEN_DISC | ESP_BLE_ADV_FLAG_BREDR_NOT_SPT),
+};
+#endif /* CONFIG_SET_RAW_ADV_DATA */
+
+static esp_ble_adv_params_t adv_params = {
+    .adv_int_min         = 0x20,
+    .adv_int_max         = 0x40,
+    .adv_type            = ADV_TYPE_IND,
+    .own_addr_type       = BLE_ADDR_TYPE_RANDOM,
+    .channel_map         = ADV_CHNL_ALL,
+    .adv_filter_policy   = ADV_FILTER_ALLOW_SCAN_ANY_CON_ANY,
+};
+
+struct gatts_profile_inst {
+    esp_gatts_cb_t gatts_cb;
+    uint16_t gatts_if;
+    uint16_t app_id;
+    uint16_t conn_id;
+    uint16_t service_handle;
+    esp_gatt_srvc_id_t service_id;
+    uint16_t char_handle;
+    esp_bt_uuid_t char_uuid;
+    esp_gatt_perm_t perm;
+    esp_gatt_char_prop_t property;
+    uint16_t descr_handle;
+    esp_bt_uuid_t descr_uuid;
+};
+
+static void gatts_profile_event_handler(esp_gatts_cb_event_t event,
+					esp_gatt_if_t gatts_if, esp_ble_gatts_cb_param_t *param);
+
+/* One gatt-based profile one app_id and one gatts_if, this array will store the gatts_if returned by ESP_GATTS_REG_EVT */
+static struct gatts_profile_inst heart_rate_profile_tab[PROFILE_NUM] = {
+    [PROFILE_APP_IDX] = {
+        .gatts_cb = gatts_profile_event_handler,
+        .gatts_if = ESP_GATT_IF_NONE,       /* Not get the gatt_if, so initial is ESP_GATT_IF_NONE */
+    },
+};
+
+/* Service */
+const uint16_t GATTS_SERVICE_UUID_TEST      = 0x00FF;
+const uint16_t GATTS_CHAR_UUID_TEST_A       = 0xFF01;
+const uint16_t GATTS_CHAR_UUID_TEST_B       = 0xFF02;
+const uint16_t GATTS_CHAR_UUID_TEST_C       = 0xFF03;
+
+const uint16_t device_info_service_uuid = ESP_GATT_UUID_DEVICE_INFO_SVC;
+
+const uint16_t primary_service_uuid         = ESP_GATT_UUID_PRI_SERVICE;
+const uint16_t character_declaration_uuid   = ESP_GATT_UUID_CHAR_DECLARE;
+const uint16_t character_client_config_uuid = ESP_GATT_UUID_CHAR_CLIENT_CONFIG;
+const uint8_t char_prop_read                =  ESP_GATT_CHAR_PROP_BIT_READ;
+const uint8_t char_prop_write               = ESP_GATT_CHAR_PROP_BIT_WRITE;
+const uint8_t char_prop_read_write_notify   = 
+ESP_GATT_CHAR_PROP_BIT_WRITE | ESP_GATT_CHAR_PROP_BIT_READ | ESP_GATT_CHAR_PROP_BIT_NOTIFY;
+const uint8_t heart_measurement_ccc[2]      = {0X00, 0X00};
+ uint8_t char_value[12]                 = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L' };
+
+
+const uint16_t Dev_Svc_2A29_Str = 0x2A29;
+const uint16_t Dev_Svc_2A24_Str = 0x2A24;
+const uint16_t Dev_Svc_2A25_Str = 0x2A25;
+const uint16_t Dev_Svc_2A27_Str = 0x2A27;
+const uint16_t Dev_Svc_2A26_Str = 0x2A26;
+const uint16_t Dev_Svc_2A28_Str = 0x2A28;
+const uint16_t Dev_Svc_2A23_Str = 0x2A23;
+const uint16_t Dev_Svc_2A2A_Str = 0x2A2A;
+const uint16_t Dev_Svc_2A50_Str = 0x2A50;
+
+
+const uint8_t char_prop_write_writenr_notify                =  
+ESP_GATT_CHAR_PROP_BIT_WRITE_NR|ESP_GATT_CHAR_PROP_BIT_WRITE|ESP_GATT_CHAR_PROP_BIT_NOTIFY;
+
+static const uint8_t service_1_uuid[16] = 
+{0Xbc, 0Xbc, 0Xc6, 0Xbf, 0Xb1, 0Xea, 0Xf0, 0Xbd, 0Xec, 0Xc7, 0Xd8, 0Xd6, 0X60, 0Xb3, 0X00, 0X00};
+static const uint8_t char_1_uuid[16] = 
+{0Xbc, 0Xbc, 0Xc6, 0Xbf, 0Xb1, 0Xea, 0Xf0, 0Xbd, 0Xec, 0Xc7, 0Xd8, 0Xd6, 0X62, 0Xb3, 0X00, 0X00};
+
+
+/* Full Database Description - Used to add attributes into the database */
+static const esp_gatts_attr_db_t gatt_db[HRS_IDX_NB] =
+{
+    // Service Declaration
+    [IDX_SVC]        =
+    {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&primary_service_uuid, ESP_GATT_PERM_READ,
+      sizeof(uint16_t), sizeof(device_info_service_uuid), (uint8_t *)&device_info_service_uuid}},
+
+
+    /* Characteristic Declaration */
+    [IDX_CHAR_2A29]     =
+    {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_declaration_uuid, ESP_GATT_PERM_READ,
+      CHAR_DECLARATION_SIZE, CHAR_DECLARATION_SIZE, (uint8_t *)&char_prop_read      }},
+
+    /* Characteristic Value */
+    [IDX_CHAR_VAL_2A29] =
+    {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&Dev_Svc_2A29_Str, ESP_GATT_PERM_READ ,
+      GATTS_DEMO_CHAR_VAL_LEN_MAX, 0, (uint8_t *)((void *)0)}},
+
+    /* Client Characteristic Configuration Descriptor */
+    [IDX_CHAR_CFG_2A29]  =
+    {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_client_config_uuid, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE,
+      sizeof(uint16_t), sizeof(heart_measurement_ccc), (uint8_t *)heart_measurement_ccc}},
+
+
+    /* Characteristic Declaration */
+    [IDX_CHAR_2A24]     =
+    {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_declaration_uuid, ESP_GATT_PERM_READ,
+      CHAR_DECLARATION_SIZE, CHAR_DECLARATION_SIZE, (uint8_t *)&char_prop_read      }},
+
+    /* Characteristic Value */
+    [IDX_CHAR_VAL_2A24] =
+    {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&Dev_Svc_2A24_Str, ESP_GATT_PERM_READ ,
+      GATTS_DEMO_CHAR_VAL_LEN_MAX, 0, (uint8_t *)((void *)0)}},
+
+    /* Client Characteristic Configuration Descriptor */
+    [IDX_CHAR_CFG_2A24]  =
+    {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_client_config_uuid, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE,
+      sizeof(uint16_t), sizeof(heart_measurement_ccc), (uint8_t *)heart_measurement_ccc}},
+
+
+
+    /* Characteristic Declaration */
+    [IDX_CHAR_2A25]     =
+    {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_declaration_uuid, ESP_GATT_PERM_READ,
+      CHAR_DECLARATION_SIZE, CHAR_DECLARATION_SIZE, (uint8_t *)&char_prop_read      }},
+
+    /* Characteristic Value */
+    [IDX_CHAR_VAL_2A25] =
+    {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&Dev_Svc_2A25_Str, ESP_GATT_PERM_READ ,
+      GATTS_DEMO_CHAR_VAL_LEN_MAX, sizeof(char_value), (uint8_t *)char_value}},
+
+    /* Client Characteristic Configuration Descriptor */
+    [IDX_CHAR_CFG_2A25]  =
+    {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_client_config_uuid, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE,
+      sizeof(uint16_t), sizeof(heart_measurement_ccc), (uint8_t *)heart_measurement_ccc}},
+
+
+    /* Characteristic Declaration */
+    [IDX_CHAR_2A27]     =
+    {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_declaration_uuid, ESP_GATT_PERM_READ,
+      CHAR_DECLARATION_SIZE, CHAR_DECLARATION_SIZE, (uint8_t *)&char_prop_read      }},
+
+    /* Characteristic Value */
+    [IDX_CHAR_VAL_2A27] =
+    {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&Dev_Svc_2A27_Str, ESP_GATT_PERM_READ ,
+      GATTS_DEMO_CHAR_VAL_LEN_MAX, 0, (uint8_t *)((void *)0)}},
+
+    /* Client Characteristic Configuration Descriptor */
+    [IDX_CHAR_CFG_2A27]  =
+    {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_client_config_uuid, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE,
+      sizeof(uint16_t), sizeof(heart_measurement_ccc), (uint8_t *)heart_measurement_ccc}},
+    
+
+    /* Characteristic Declaration */
+    [IDX_CHAR_2A26]     =
+    {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_declaration_uuid, ESP_GATT_PERM_READ,
+      CHAR_DECLARATION_SIZE, CHAR_DECLARATION_SIZE, (uint8_t *)&char_prop_read      }},
+
+    /* Characteristic Value */
+    [IDX_CHAR_VAL_2A26] =
+    {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&Dev_Svc_2A26_Str, ESP_GATT_PERM_READ ,
+      GATTS_DEMO_CHAR_VAL_LEN_MAX, 0, (uint8_t *)((void *)0)}},
+
+    /* Client Characteristic Configuration Descriptor */
+    [IDX_CHAR_CFG_2A26]  =
+    {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_client_config_uuid, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE,
+      sizeof(uint16_t), sizeof(heart_measurement_ccc), (uint8_t *)heart_measurement_ccc}},
+
+
+
+    [IDX_CHAR_2A28]     =
+    {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_declaration_uuid, ESP_GATT_PERM_READ,
+      CHAR_DECLARATION_SIZE, CHAR_DECLARATION_SIZE, (uint8_t *)&char_prop_read      }},
+
+    /* Characteristic Value */
+    [IDX_CHAR_VAL_2A28] =
+    {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&Dev_Svc_2A28_Str, ESP_GATT_PERM_READ ,
+      GATTS_DEMO_CHAR_VAL_LEN_MAX, 0, (uint8_t *)((void *)0)}},
+
+    /* Client Characteristic Configuration Descriptor */
+    [IDX_CHAR_CFG_2A28]  =
+    {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_client_config_uuid, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE,
+      sizeof(uint16_t), sizeof(heart_measurement_ccc), (uint8_t *)heart_measurement_ccc}},
+
+
+    [IDX_CHAR_2A23]     =
+    {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_declaration_uuid, ESP_GATT_PERM_READ,
+      CHAR_DECLARATION_SIZE, CHAR_DECLARATION_SIZE, (uint8_t *)&char_prop_read      }},
+
+    /* Characteristic Value */
+    [IDX_CHAR_VAL_2A23] =
+    {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&Dev_Svc_2A23_Str, ESP_GATT_PERM_READ ,
+      GATTS_DEMO_CHAR_VAL_LEN_MAX, 0, (uint8_t *)((void *)0)}},
+
+    /* Client Characteristic Configuration Descriptor */
+    [IDX_CHAR_CFG_2A23]  =
+    {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_client_config_uuid, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE,
+      sizeof(uint16_t), sizeof(heart_measurement_ccc), (uint8_t *)heart_measurement_ccc}},
+
+
+
+    [IDX_CHAR_2A2A]     =
+    {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_declaration_uuid, ESP_GATT_PERM_READ,
+      CHAR_DECLARATION_SIZE, CHAR_DECLARATION_SIZE, (uint8_t *)&char_prop_read      }},
+
+    /* Characteristic Value */
+    [IDX_CHAR_VAL_2A2A] =
+    {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&Dev_Svc_2A2A_Str, ESP_GATT_PERM_READ ,
+      GATTS_DEMO_CHAR_VAL_LEN_MAX, 0, (uint8_t *)((void *)0)}},
+
+    /* Client Characteristic Configuration Descriptor */
+    [IDX_CHAR_CFG_2A2A]  =
+    {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_client_config_uuid, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE,
+      sizeof(uint16_t), sizeof(heart_measurement_ccc), (uint8_t *)heart_measurement_ccc}},
+
+
+    [IDX_CHAR_2A50]     =
+    {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_declaration_uuid, ESP_GATT_PERM_READ,
+      CHAR_DECLARATION_SIZE, CHAR_DECLARATION_SIZE, (uint8_t *)&char_prop_read      }},
+
+    /* Characteristic Value */
+    [IDX_CHAR_VAL_2A50] =
+    {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&Dev_Svc_2A50_Str, ESP_GATT_PERM_READ ,
+      GATTS_DEMO_CHAR_VAL_LEN_MAX, 0, (uint8_t *)((void *)0)}},
+
+    /* Client Characteristic Configuration Descriptor */
+    [IDX_CHAR_CFG_2A50]  =
+    {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_client_config_uuid, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE,
+      sizeof(uint16_t), sizeof(heart_measurement_ccc), (uint8_t *)heart_measurement_ccc}},
+};
+
+
+/* Full Database Description - Used to add attributes into the database */
+static const esp_gatts_attr_db_t gatt_db2[HRS_IDX_NB2] =
+{
+    // Service Declaration
+    [IDX_SVC2]        =
+    {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&primary_service_uuid, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE,
+      sizeof(uint16_t), sizeof(service_1_uuid), (uint8_t *)&service_1_uuid}},
+
+    /* Characteristic Declaration */
+    [IDX_CHAR_A2]     =
+    {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_declaration_uuid, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE,
+      CHAR_DECLARATION_SIZE, CHAR_DECLARATION_SIZE, (uint8_t *)&char_prop_write_writenr_notify      }},
+
+    /* Characteristic Value */
+    [IDX_CHAR_VAL_A2] =
+    {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_128, (uint8_t *)&char_1_uuid,  ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE ,
+      GATTS_DEMO_CHAR_VAL_LEN_MAX, 0, (uint8_t *)((void *)0)}},
+
+    /* Client Characteristic Configuration Descriptor */
+    [IDX_CHAR_CFG_A2]  =
+    {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_client_config_uuid, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE,
+      sizeof(uint16_t), sizeof(heart_measurement_ccc), (uint8_t *)heart_measurement_ccc}},
+};
+
+
+
+int bsp_Ble_Gatts_Send_Indicate( uint8_t len, uint8_t *data)
+{
+    int err = ESP_FAIL;
+    uint8_t retry = 5;
+
+    if(Ble_User.Ble_Sts != Ble_Idle)
+    {
+        // if(en)
+        {
+            while(retry -- )
+            {
+                if(err != ESP_OK)
+                {
+                    err = esp_ble_gatts_send_indicate(heart_rate_profile_tab[0].gatts_if, 
+                                    heart_rate_profile_tab[0].conn_id, 
+                                    heart_rate_handle_table2[IDX_CHAR_VAL_A2],
+                                    len, data, false);
+                }
+                else
+                {
+                    break;
+                }
+            }
+
+            if(err != ESP_OK)
+            {
+                printf("ble trans fail!!\r\n");
+            }
+
+        }
+    }
+
+    return err;
+}
+
+
+static void gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param)
+{
+    switch (event) {
+    #ifdef CONFIG_SET_RAW_ADV_DATA
+        case ESP_GAP_BLE_ADV_DATA_RAW_SET_COMPLETE_EVT:
+            adv_config_done &= (~ADV_CONFIG_FLAG);
+            if (adv_config_done == 0){
+                esp_ble_gap_start_advertising(&adv_params);
+
+                printf("adv 1\r\n");
+            }
+            break;
+        case ESP_GAP_BLE_SCAN_RSP_DATA_RAW_SET_COMPLETE_EVT:
+            adv_config_done &= (~SCAN_RSP_CONFIG_FLAG);
+            if (adv_config_done == 0){
+                esp_ble_gap_start_advertising(&adv_params);
+
+                printf("adv 2\r\n");
+            }
+            break;
+    #else
+        case ESP_GAP_BLE_ADV_DATA_SET_COMPLETE_EVT:
+            adv_config_done &= (~ADV_CONFIG_FLAG);
+            if (adv_config_done == 0){
+                esp_ble_gap_start_advertising(&adv_params);
+            }
+            break;
+        case ESP_GAP_BLE_SCAN_RSP_DATA_SET_COMPLETE_EVT:
+            adv_config_done &= (~SCAN_RSP_CONFIG_FLAG);
+            if (adv_config_done == 0){
+                esp_ble_gap_start_advertising(&adv_params);
+            }
+            break;
+    #endif
+        case ESP_GAP_BLE_ADV_START_COMPLETE_EVT:
+            /* advertising start complete event to indicate advertising start successfully or failed */
+            if (param->adv_start_cmpl.status != ESP_BT_STATUS_SUCCESS) {
+                ESP_LOGE(GATTS_TABLE_TAG, "advertising start failed");
+            }else{
+                ESP_LOGI(GATTS_TABLE_TAG, "advertising start successfully");
+            }
+            break;
+        case ESP_GAP_BLE_ADV_STOP_COMPLETE_EVT:
+            if (param->adv_stop_cmpl.status != ESP_BT_STATUS_SUCCESS) {
+                ESP_LOGE(GATTS_TABLE_TAG, "Advertising stop failed");
+            }
+            else {
+                ESP_LOGI(GATTS_TABLE_TAG, "Stop adv successfully\n");
+            }
+            break;
+        case ESP_GAP_BLE_UPDATE_CONN_PARAMS_EVT:
+            ESP_LOGI(GATTS_TABLE_TAG, "update connection params status = %d, min_int = %d, max_int = %d,conn_int = %d,latency = %d, timeout = %d",
+                  param->update_conn_params.status,
+                  param->update_conn_params.min_int,
+                  param->update_conn_params.max_int,
+                  param->update_conn_params.conn_int,
+                  param->update_conn_params.latency,
+                  param->update_conn_params.timeout);
+            break;
+        default:
+            break;
+    }
+}
+
+void example_prepare_write_event_env(esp_gatt_if_t gatts_if, prepare_type_env_t *prepare_write_env, esp_ble_gatts_cb_param_t *param)
+{
+    ESP_LOGI(GATTS_TABLE_TAG, "prepare write, handle = %d, value len = %d", param->write.handle, param->write.len);
+    esp_gatt_status_t status = ESP_GATT_OK;
+    if (param->write.offset > PREPARE_BUF_MAX_SIZE) {
+        status = ESP_GATT_INVALID_OFFSET;
+    } else if ((param->write.offset + param->write.len) > PREPARE_BUF_MAX_SIZE) {
+        status = ESP_GATT_INVALID_ATTR_LEN;
+    }
+    if (status == ESP_GATT_OK && prepare_write_env->prepare_buf == NULL) {
+        prepare_write_env->prepare_buf = (uint8_t *)malloc(PREPARE_BUF_MAX_SIZE * sizeof(uint8_t));
+        prepare_write_env->prepare_len = 0;
+        if (prepare_write_env->prepare_buf == NULL) {
+            ESP_LOGE(GATTS_TABLE_TAG, "%s, Gatt_server prep no mem", __func__);
+            status = ESP_GATT_NO_RESOURCES;
+        }
+    }
+
+    /*send response when param->write.need_rsp is true */
+    if (param->write.need_rsp){
+        esp_gatt_rsp_t *gatt_rsp = (esp_gatt_rsp_t *)malloc(sizeof(esp_gatt_rsp_t));
+        if (gatt_rsp != NULL){
+            gatt_rsp->attr_value.len = param->write.len;
+            gatt_rsp->attr_value.handle = param->write.handle;
+            gatt_rsp->attr_value.offset = param->write.offset;
+            gatt_rsp->attr_value.auth_req = ESP_GATT_AUTH_REQ_NONE;
+            memcpy(gatt_rsp->attr_value.value, param->write.value, param->write.len);
+            esp_err_t response_err = esp_ble_gatts_send_response(gatts_if, param->write.conn_id, param->write.trans_id, status, gatt_rsp);
+            if (response_err != ESP_OK) {
+               ESP_LOGE(GATTS_TABLE_TAG, "Send response error");
+            }
+            free(gatt_rsp);
+        }else{
+            ESP_LOGE(GATTS_TABLE_TAG, "%s, malloc failed", __func__);
+        }
+    }
+    if (status != ESP_GATT_OK){
+        return;
+    }
+    memcpy(prepare_write_env->prepare_buf + param->write.offset,
+           param->write.value,
+           param->write.len);
+    prepare_write_env->prepare_len += param->write.len;
+
+}
+
+void example_exec_write_event_env(prepare_type_env_t *prepare_write_env, esp_ble_gatts_cb_param_t *param){
+    if (param->exec_write.exec_write_flag == ESP_GATT_PREP_WRITE_EXEC && prepare_write_env->prepare_buf){
+        esp_log_buffer_hex(GATTS_TABLE_TAG, prepare_write_env->prepare_buf, prepare_write_env->prepare_len);
+    }else{
+        ESP_LOGI(GATTS_TABLE_TAG,"ESP_GATT_PREP_WRITE_CANCEL");
+    }
+    if (prepare_write_env->prepare_buf) {
+        free(prepare_write_env->prepare_buf);
+        prepare_write_env->prepare_buf = NULL;
+    }
+    prepare_write_env->prepare_len = 0;
+}
+
+bool create_tab1 = false;
+
+static void gatts_profile_event_handler(esp_gatts_cb_event_t event, esp_gatt_if_t gatts_if, esp_ble_gatts_cb_param_t *param)
+{
+    switch (event) {
+        case ESP_GATTS_REG_EVT:{
+            esp_ble_gap_set_rand_addr(rand_addr);
+            esp_err_t set_dev_name_ret = esp_ble_gap_set_device_name((const char *)BT_Device_Name);
+            if (set_dev_name_ret){
+                ESP_LOGE(GATTS_TABLE_TAG, "set device name failed, error code = %x", set_dev_name_ret);
+            }
+    #ifdef CONFIG_SET_RAW_ADV_DATA
+            esp_err_t raw_adv_ret = esp_ble_gap_config_adv_data_raw(raw_adv_data, sizeof(raw_adv_data));
+            if (raw_adv_ret){
+                ESP_LOGE(GATTS_TABLE_TAG, "config raw adv data failed, error code = %x ", raw_adv_ret);
+            }
+            adv_config_done |= ADV_CONFIG_FLAG;
+            esp_err_t raw_scan_ret = esp_ble_gap_config_scan_rsp_data_raw(raw_scan_rsp_data, sizeof(raw_scan_rsp_data));
+            if (raw_scan_ret){
+                ESP_LOGE(GATTS_TABLE_TAG, "config raw scan rsp data failed, error code = %x", raw_scan_ret);
+            }
+            adv_config_done |= SCAN_RSP_CONFIG_FLAG;
+    #else
+            //config adv data
+            esp_err_t ret = esp_ble_gap_config_adv_data(&adv_data);
+            if (ret){
+                ESP_LOGE(GATTS_TABLE_TAG, "config adv data failed, error code = %x", ret);
+            }
+            adv_config_done |= ADV_CONFIG_FLAG;
+            //config scan response data
+            ret = esp_ble_gap_config_adv_data(&scan_rsp_data);
+            if (ret){
+                ESP_LOGE(GATTS_TABLE_TAG, "config scan response data failed, error code = %x", ret);
+            }
+            adv_config_done |= SCAN_RSP_CONFIG_FLAG;
+    #endif
+            esp_err_t create_attr_ret = esp_ble_gatts_create_attr_tab(gatt_db, gatts_if, HRS_IDX_NB, SVC_INST_ID);
+            if (create_attr_ret){
+                ESP_LOGE(GATTS_TABLE_TAG, "create attr table failed, error code = %x", create_attr_ret);
+            }
+
+            ESP_LOGI(GATTS_TABLE_TAG,"create attr table!!!!!!!!!!!!!!!!!!!!");
+        }
+       	    break;
+        case ESP_GATTS_READ_EVT:
+
+
+            ESP_LOGI(GATTS_TABLE_TAG, "ESP_GATTS_READ_EVT");
+       	    break;
+        case ESP_GATTS_WRITE_EVT:
+            if (!param->write.is_prep){
+                // the data length of gattc write  must be less than GATTS_DEMO_CHAR_VAL_LEN_MAX.
+                ESP_LOGI(GATTS_TABLE_TAG, "GATT_WRITE_EVT, handle = %d, value len = %d, value :", param->write.handle, param->write.len);
+                esp_log_buffer_hex(GATTS_TABLE_TAG, param->write.value, param->write.len);
+
+                // printf("descr_value = %d\r\n", heart_rate_handle_table[IDX_CHAR_CFG_A2]);
+                // printf("handle = %d\r\n", param->write.handle);
+
+                if (heart_rate_handle_table2[IDX_CHAR_VAL_A2] == param->write.handle)
+                {
+                    Get_Ble_Raw_Data(param->write.value, param->write.len);
+                }
+
+                if (heart_rate_handle_table2[IDX_CHAR_CFG_A2] == param->write.handle && param->write.len == 2){
+                    uint16_t descr_value = param->write.value[1]<<8 | param->write.value[0];
+
+                    
+
+                    if (descr_value == 0x0001){
+                        ESP_LOGI(GATTS_TABLE_TAG, "notify enable");
+                        // uint8_t notify_data[15];
+                        // for (int i = 0; i < sizeof(notify_data); ++i)
+                        // {
+                        //     notify_data[i] = i % 0xff;
+                        // }
+                        // //the size of notify_data[] need less than MTU size
+                        // esp_ble_gatts_send_indicate(gatts_if, param->write.conn_id, heart_rate_handle_table2[IDX_CHAR_CFG_A2],
+                        //                         sizeof(notify_data), notify_data, false);
+                    }else if (descr_value == 0x0002){
+                        // ESP_LOGI(GATTS_TABLE_TAG, "indicate enable");
+                        // uint8_t indicate_data[15];
+                        // for (int i = 0; i < sizeof(indicate_data); ++i)
+                        // {
+                        //     indicate_data[i] = i % 0xff;
+                        // }
+
+                        // // if want to change the value in server database, call:
+                        // // esp_ble_gatts_set_attr_value(heart_rate_handle_table[IDX_CHAR_VAL_2A25], sizeof(indicate_data), indicate_data);
+
+
+                        // //the size of indicate_data[] need less than MTU size
+                        // esp_ble_gatts_send_indicate(gatts_if, param->write.conn_id, heart_rate_handle_table2[IDX_CHAR_CFG_A2],
+                        //                     sizeof(indicate_data), indicate_data, true);
+                    }
+                    else if (descr_value == 0x0000){
+                        ESP_LOGI(GATTS_TABLE_TAG, "notify/indicate disable ");
+                    }else{
+                        ESP_LOGE(GATTS_TABLE_TAG, "unknown descr value");
+                        esp_log_buffer_hex(GATTS_TABLE_TAG, param->write.value, param->write.len);
+                    }
+
+                }
+                /* send response when param->write.need_rsp is true*/
+                if (param->write.need_rsp){
+                    esp_ble_gatts_send_response(gatts_if, param->write.conn_id, param->write.trans_id, ESP_GATT_OK, NULL);
+                }
+            }else{
+                /* handle prepare write */
+                example_prepare_write_event_env(gatts_if, &prepare_write_env, param);
+            }
+      	    break;
+        case ESP_GATTS_EXEC_WRITE_EVT:
+            // the length of gattc prepare write data must be less than GATTS_DEMO_CHAR_VAL_LEN_MAX.
+            ESP_LOGI(GATTS_TABLE_TAG, "ESP_GATTS_EXEC_WRITE_EVT");
+            example_exec_write_event_env(&prepare_write_env, param);
+            break;
+        case ESP_GATTS_MTU_EVT:
+            ESP_LOGI(GATTS_TABLE_TAG, "ESP_GATTS_MTU_EVT, MTU %d", param->mtu.mtu);
+            break;
+        case ESP_GATTS_CONF_EVT:
+            ESP_LOGI(GATTS_TABLE_TAG, "ESP_GATTS_CONF_EVT, status = %d, attr_handle %d", param->conf.status, param->conf.handle);
+            break;
+        case ESP_GATTS_START_EVT:
+            if(create_tab1 == false) {
+                ESP_LOGI(GATTS_TABLE_TAG, "SERVICE_START_EVT1, status %d, service_handle %d", param->start.status, param->start.service_handle);
+                esp_err_t create_attr_ret1 = esp_ble_gatts_create_attr_tab(gatt_db2, gatts_if, HRS_IDX_NB2, SVC_INST_ID1);
+                if (create_attr_ret1){
+                    ESP_LOGE(GATTS_TABLE_TAG, "create attr table2 failed, error code = %x", create_attr_ret1);
+                }
+                create_tab1 = true;
+            } else {
+                ESP_LOGI(GATTS_TABLE_TAG, "SERVICE_START_EVT2, status %d, service_handle %d", param->start.status, param->start.service_handle);
+            }
+            break;
+        case ESP_GATTS_CONNECT_EVT:
+
+            Ble_Connect_Event_Pro();
+            ESP_LOGI(GATTS_TABLE_TAG, "ESP_GATTS_CONNECT_EVT, conn_id = %d", param->connect.conn_id);
+            esp_log_buffer_hex(GATTS_TABLE_TAG, param->connect.remote_bda, 6);
+            esp_ble_conn_update_params_t conn_params = {0};
+            memcpy(conn_params.bda, param->connect.remote_bda, sizeof(esp_bd_addr_t));
+            /* For the iOS system, please refer to Apple official documents about the BLE connection parameters restrictions. */
+            conn_params.latency = 0;
+            conn_params.max_int = 0x20;    // max_int = 0x20*1.25ms = 40ms
+            conn_params.min_int = 0x10;    // min_int = 0x10*1.25ms = 20ms
+            conn_params.timeout = 400;    // timeout = 400*10ms = 4000ms
+            //start sent the update connection parameters to the peer device.
+            esp_ble_gap_update_conn_params(&conn_params);
+
+            break;
+        case ESP_GATTS_DISCONNECT_EVT:
+
+            Ble_DisConnect_Event_Pro();
+            ESP_LOGI(GATTS_TABLE_TAG, "ESP_GATTS_DISCONNECT_EVT, reason = 0x%x", param->disconnect.reason);
+            esp_ble_gap_start_advertising(&adv_params);
+
+            break;
+        case ESP_GATTS_CREAT_ATTR_TAB_EVT:{
+            if(create_tab1 == false) {
+                if (param->add_attr_tab.status != ESP_GATT_OK){
+                    ESP_LOGE(GATTS_TABLE_TAG, "create attribute table failed, error code=0x%x", param->add_attr_tab.status);
+                }
+                else if (param->add_attr_tab.num_handle != HRS_IDX_NB){
+                    ESP_LOGE(GATTS_TABLE_TAG, "create attribute table abnormally, num_handle (%d) \
+                            doesn't equal to HRS_IDX_NB(%d)", param->add_attr_tab.num_handle, HRS_IDX_NB);
+                }
+                else {
+                    ESP_LOGI(GATTS_TABLE_TAG, "create attribute table successfully, the number handle = %d\n",param->add_attr_tab.num_handle);
+                    memcpy(heart_rate_handle_table, param->add_attr_tab.handles, sizeof(heart_rate_handle_table));
+                    esp_ble_gatts_start_service(heart_rate_handle_table[IDX_SVC]);
+
+                    // for(int ii = 0; ii<4; ii++)
+                    // {
+                    //     printf("heart_rate_handle_table[%d] = %d\r\n", ii, heart_rate_handle_table[ii]);
+                    // }
+                }
+            } else {
+                if (param->add_attr_tab.status != ESP_GATT_OK){
+                    ESP_LOGE(GATTS_TABLE_TAG, "create attribute table failed, error code=0x%x", param->add_attr_tab.status);
+                }
+                else if (param->add_attr_tab.num_handle != HRS_IDX_NB2){
+                    ESP_LOGE(GATTS_TABLE_TAG, "create attribute table abnormally, num_handle (%d) \
+                            doesn't equal to HRS_IDX_NB(%d)", param->add_attr_tab.num_handle, HRS_IDX_NB2);
+                }
+                else {
+                    ESP_LOGI(GATTS_TABLE_TAG, "create attribute table successfully, the number handle = %d\n",param->add_attr_tab.num_handle);
+                    memcpy(heart_rate_handle_table2, param->add_attr_tab.handles, sizeof(heart_rate_handle_table2));
+                    esp_ble_gatts_start_service(heart_rate_handle_table2[IDX_SVC2]);
+
+                    // for(int ii = 0; ii<4; ii++)
+                    // {
+                    //     printf("heart_rate_handle_table2[%d] = %d\r\n", ii, heart_rate_handle_table2[ii]);
+                    // }
+                }  
+            }
+            break;
+        }
+        case ESP_GATTS_STOP_EVT:
+        case ESP_GATTS_OPEN_EVT:
+        case ESP_GATTS_CANCEL_OPEN_EVT:
+        case ESP_GATTS_CLOSE_EVT:
+        case ESP_GATTS_LISTEN_EVT:
+        case ESP_GATTS_CONGEST_EVT:
+        case ESP_GATTS_UNREG_EVT:
+        case ESP_GATTS_DELETE_EVT:
+        default:
+            break;
+    }
+}
+
+
+static void gatts_event_handler(esp_gatts_cb_event_t event, esp_gatt_if_t gatts_if, esp_ble_gatts_cb_param_t *param)
+{
+
+    /* If event is register event, store the gatts_if for each profile */
+    if (event == ESP_GATTS_REG_EVT) {
+        if (param->reg.status == ESP_GATT_OK) {
+            heart_rate_profile_tab[PROFILE_APP_IDX].gatts_if = gatts_if;
+        } else {
+            ESP_LOGE(GATTS_TABLE_TAG, "reg app failed, app_id %04x, status %d",
+                    param->reg.app_id,
+                    param->reg.status);
+            return;
+        }
+    }
+    do {
+        int idx;
+        for (idx = 0; idx < PROFILE_NUM; idx++) {
+            /* ESP_GATT_IF_NONE, not specify a certain gatt_if, need to call every profile cb function */
+            if (gatts_if == ESP_GATT_IF_NONE || gatts_if == heart_rate_profile_tab[idx].gatts_if) {
+                if (heart_rate_profile_tab[idx].gatts_cb) {
+                    heart_rate_profile_tab[idx].gatts_cb(event, gatts_if, param);
+                }
+            }
+        }
+    } while (0);
+}
+
+
+
+void Get_Mac_Init(void )
+{
+    uint8_t ble_mac[10] = {0};
+    char temp[10] = {0};
+    char temp1[20] = {0};
+    esp_read_mac(ble_mac, ESP_MAC_BT);
+
+
+    sprintf(temp, "%02X%02X", ble_mac[4], ble_mac[5]);
+
+    raw_adv_data[sizeof(raw_adv_data) - 4] = temp[0];
+    raw_adv_data[sizeof(raw_adv_data) - 3] = temp[1];
+    raw_adv_data[sizeof(raw_adv_data) - 2] = temp[2];
+    raw_adv_data[sizeof(raw_adv_data) - 1] = temp[3];
+
+    // ESP_LOGW(GATTS_TABLE_TAG, "BLE_MAC IS %s : ",
+    //                 &raw_adv_data[11]);
+    // ESP_LOGW(GATTS_TABLE_TAG, "BLE_MAC IS %s : ",
+    //                 temp);      
+
+    printf("My MAC:\n");
+    esp_log_buffer_hex(GATTS_TABLE_TAG, ble_mac, 6);          
+
+    BT_Device_Name[sizeof(BT_Device_Name) - 11] = temp[0];
+    BT_Device_Name[sizeof(BT_Device_Name) - 10] = temp[1];
+    BT_Device_Name[sizeof(BT_Device_Name) - 9] = temp[2];
+    BT_Device_Name[sizeof(BT_Device_Name) - 8] = temp[3];
+
+    raw_adv_data[11] = ble_mac[0];
+    raw_adv_data[12] = ble_mac[1];
+    raw_adv_data[13] = ble_mac[2];
+    raw_adv_data[14] = ble_mac[3];
+    raw_adv_data[15] = ble_mac[4];
+    raw_adv_data[16] = ble_mac[5];
+
+    sprintf(temp1, "%02X%02X%02X%02X%02X%02X", ble_mac[0], ble_mac[1], ble_mac[2], ble_mac[3], ble_mac[4], ble_mac[5]);
+
+
+    for(int i=0; i<12; i++)
+    {
+        char_value[i] = temp1[i];
+    }
+}
+
+
+void bsp_Ble_Init(void)
+{
+    esp_err_t ret;
+
+    // Get_Mac_Init();
+
+
+    /* Initialize NVS. */
+    // ret = nvs_flash_init();
+    // if (ret == ESP_ERR_NVS_NO_FREE_PAGES || ret == ESP_ERR_NVS_NEW_VERSION_FOUND) {
+    //     ESP_ERROR_CHECK(nvs_flash_erase());
+    //     ret = nvs_flash_init();
+    // }
+    // ESP_ERROR_CHECK( ret );
+
+    // ESP_ERROR_CHECK(esp_bt_controller_mem_release(ESP_BT_MODE_CLASSIC_BT));
+
+    // esp_bt_controller_config_t bt_cfg = BT_CONTROLLER_INIT_CONFIG_DEFAULT();
+    // ret = esp_bt_controller_init(&bt_cfg);
+    // if (ret) {
+    //     ESP_LOGE(GATTS_TABLE_TAG, "%s enable controller failed: %s", __func__, esp_err_to_name(ret));
+    //     return;
+    // }
+
+    // ret = esp_bt_controller_enable(ESP_BT_MODE_BLE);
+    // if (ret) {
+    //     ESP_LOGE(GATTS_TABLE_TAG, "%s enable controller failed: %s", __func__, esp_err_to_name(ret));
+    //     return;
+    // }
+
+    // ret = esp_bluedroid_init();
+    // if (ret) {
+    //     ESP_LOGE(GATTS_TABLE_TAG, "%s init bluetooth failed: %s", __func__, esp_err_to_name(ret));
+    //     return;
+    // }
+
+    // ret = esp_bluedroid_enable();
+    // if (ret) {
+    //     ESP_LOGE(GATTS_TABLE_TAG, "%s enable bluetooth failed: %s", __func__, esp_err_to_name(ret));
+    //     return;
+    // }
+
+    ret = esp_ble_gatts_register_callback(gatts_event_handler);
+    if (ret){
+        ESP_LOGE(GATTS_TABLE_TAG, "gatts register error, error code = %x", ret);
+        return;
+    }
+
+    ret = esp_ble_gap_register_callback(gap_event_handler);
+    if (ret){
+        ESP_LOGE(GATTS_TABLE_TAG, "gap register error, error code = %x", ret);
+        return;
+    }
+
+    ret = esp_ble_gatts_app_register(ESP_APP_ID);
+    if (ret){
+        ESP_LOGE(GATTS_TABLE_TAG, "gatts app register error, error code = %x", ret);
+        return;
+    }
+
+
+    esp_err_t local_mtu_ret = esp_ble_gatt_set_local_mtu(500);
+    if (local_mtu_ret){
+        ESP_LOGE(GATTS_TABLE_TAG, "set local  MTU failed, error code = %x", local_mtu_ret);
+    }
+
+
+    // /* set the security iocap & auth_req & key size & init key response key parameters to the stack*/
+    // esp_ble_auth_req_t auth_req = ESP_LE_AUTH_REQ_SC_MITM_BOND;     //bonding with peer device after authentication
+    // esp_ble_io_cap_t iocap = ESP_IO_CAP_NONE;           //set the IO capability to No output No input
+    // uint8_t key_size = 16;      //the key size should be 7~16 bytes
+    // uint8_t init_key = ESP_BLE_ENC_KEY_MASK | ESP_BLE_ID_KEY_MASK;
+    // uint8_t rsp_key = ESP_BLE_ENC_KEY_MASK | ESP_BLE_ID_KEY_MASK;
+    // uint8_t oob_support = ESP_BLE_OOB_DISABLE;
+    // esp_ble_gap_set_security_param(ESP_BLE_SM_AUTHEN_REQ_MODE, &auth_req, sizeof(uint8_t));
+    // esp_ble_gap_set_security_param(ESP_BLE_SM_IOCAP_MODE, &iocap, sizeof(uint8_t));
+    // esp_ble_gap_set_security_param(ESP_BLE_SM_MAX_KEY_SIZE, &key_size, sizeof(uint8_t));
+    // esp_ble_gap_set_security_param(ESP_BLE_SM_OOB_SUPPORT, &oob_support, sizeof(uint8_t));
+    // /* If your BLE device act as a Slave, the init_key means you hope which types of key of the master should distribute to you,
+    // and the response key means which key you can distribute to the Master;
+    // If your BLE device act as a master, the response key means you hope which types of key of the slave should distribute to you,
+    // and the init key means which key you can distribute to the slave. */
+    // esp_ble_gap_set_security_param(ESP_BLE_SM_SET_INIT_KEY, &init_key, sizeof(uint8_t));
+    // esp_ble_gap_set_security_param(ESP_BLE_SM_SET_RSP_KEY, &rsp_key, sizeof(uint8_t));
+
+
+
+
+
+    /* set the security iocap & auth_req & key size & init key response key parameters to the stack*/
+    // esp_ble_auth_req_t auth_req = ESP_LE_AUTH_REQ_SC_MITM_BOND;     //bonding with peer device after authentication
+    // esp_ble_io_cap_t iocap = ESP_IO_CAP_NONE;           //set the IO capability to No output No input
+    // uint8_t key_size = 16;      //the key size should be 7~16 bytes
+    // uint8_t init_key = ESP_BLE_ENC_KEY_MASK | ESP_BLE_ID_KEY_MASK;
+    // uint8_t rsp_key = ESP_BLE_ENC_KEY_MASK | ESP_BLE_ID_KEY_MASK;
+    // //set static passkey
+    // uint32_t passkey = 123456;
+    // uint8_t auth_option = ESP_BLE_ONLY_ACCEPT_SPECIFIED_AUTH_DISABLE;
+    // uint8_t oob_support = ESP_BLE_OOB_DISABLE;
+    // ret = esp_ble_gap_set_security_param(ESP_BLE_SM_SET_STATIC_PASSKEY, &passkey, sizeof(uint32_t));
+    // if(ret)
+    // {
+    //     printf("!!!!!!!!!!!!!!\r\n");
+    // }
+    // ret = esp_ble_gap_set_security_param(ESP_BLE_SM_AUTHEN_REQ_MODE, &auth_req, sizeof(uint8_t));
+    // if(ret)
+    // {
+    //     printf("!!!!!!!!!!!!!!\r\n");
+    // }
+    // ret = esp_ble_gap_set_security_param(ESP_BLE_SM_IOCAP_MODE, &iocap, sizeof(uint8_t));
+    // if(ret)
+    // {
+    //     printf("!!!!!!!!!!!!!!\r\n");
+    // }
+    // ret = esp_ble_gap_set_security_param(ESP_BLE_SM_MAX_KEY_SIZE, &key_size, sizeof(uint8_t));
+    // if(ret)
+    // {
+    //     printf("!!!!!!!!!!!!!!\r\n");
+    // }
+    // ret = esp_ble_gap_set_security_param(ESP_BLE_SM_ONLY_ACCEPT_SPECIFIED_SEC_AUTH, &auth_option, sizeof(uint8_t));
+    // if(ret)
+    // {
+    //     printf("!!!!!!!!!!!!!!\r\n");
+    // }
+    // ret = esp_ble_gap_set_security_param(ESP_BLE_SM_OOB_SUPPORT, &oob_support, sizeof(uint8_t));
+    // if(ret)
+    // {
+    //     printf("!!!!!!!!!!!!!!\r\n");
+    // }
+    // /* If your BLE device acts as a Slave, the init_key means you hope which types of key of the master should distribute to you,
+    // and the response key means which key you can distribute to the master;
+    // If your BLE device acts as a master, the response key means you hope which types of key of the slave should distribute to you,
+    // and the init key means which key you can distribute to the slave. */
+    // ret = esp_ble_gap_set_security_param(ESP_BLE_SM_SET_INIT_KEY, &init_key, sizeof(uint8_t));
+    // if(ret)
+    // {
+    //     printf("!!!!!!!!!!!!!!\r\n");
+    // }
+    // ret = esp_ble_gap_set_security_param(ESP_BLE_SM_SET_RSP_KEY, &rsp_key, sizeof(uint8_t));
+    // if(ret)
+    // {
+    //     printf("!!!!!!!!!!!!!!\r\n");
+    // }
+}

RT200T_2_ESP32/main/gatts_table_creat_demo.h

+/*
+ * SPDX-FileCopyrightText: 2021 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Unlicense OR CC0-1.0
+ */
+
+#ifndef GATTS_TABLE_CREAT_DEMO_H
+#define GATTS_TABLE_CREAT_DEMO_H
+
+
+/* Attributes State Machine */
+enum
+{
+    IDX_SVC,
+
+    IDX_CHAR_2A29,
+    IDX_CHAR_VAL_2A29,
+    IDX_CHAR_CFG_2A29,
+
+    IDX_CHAR_2A24,
+    IDX_CHAR_VAL_2A24,
+    IDX_CHAR_CFG_2A24,
+    
+    IDX_CHAR_2A25,
+    IDX_CHAR_VAL_2A25,
+    IDX_CHAR_CFG_2A25,
+
+    IDX_CHAR_2A27,
+    IDX_CHAR_VAL_2A27,
+    IDX_CHAR_CFG_2A27,
+
+    IDX_CHAR_2A26,
+    IDX_CHAR_VAL_2A26,
+    IDX_CHAR_CFG_2A26,
+
+    IDX_CHAR_2A28,
+    IDX_CHAR_VAL_2A28,
+    IDX_CHAR_CFG_2A28,
+
+    IDX_CHAR_2A23,
+    IDX_CHAR_VAL_2A23,
+    IDX_CHAR_CFG_2A23,
+
+
+    IDX_CHAR_2A2A,
+    IDX_CHAR_VAL_2A2A,
+    IDX_CHAR_CFG_2A2A,
+
+    IDX_CHAR_2A50,
+    IDX_CHAR_VAL_2A50,
+    IDX_CHAR_CFG_2A50,
+
+    HRS_IDX_NB,
+};
+
+
+
+enum
+{
+
+
+
+    IDX_SVC2,
+    IDX_CHAR_A2,
+    IDX_CHAR_VAL_A2,
+    IDX_CHAR_CFG_A2,
+
+    HRS_IDX_NB2,
+};
+
+void bsp_Ble_Init(void);
+void bsp_Uart_Init(void );
+
+int bsp_Ble_Gatts_Send_Indicate(uint8_t len, uint8_t *data);
+
+void simple_ota_service(void);
+
+extern uint8_t BT_Device_Name[14];
+
+void Get_Mac_Init(void );
+extern int bsp_Uart_Send_Data(uint8_t * data , unsigned int len);
+extern uint8_t BT_Device_Name[14];
+#endif
\ No newline at end of file

RT200T_2_ESP32/main/main_user.c

+
+#include "app_Ble_User.h"
+#include "gatts_table_creat_demo.h"
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include "string.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "freertos/event_groups.h"
+#include "gatts_table_creat_demo.h"
+#include "main_user.h"
+#include "Protocol_CRC16.h"
+#include "Protocol_User.h"
+#include "bt_app_main.h"
+#include "app_BT_User.h"
+
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "esp_system.h"
+#include "esp_log.h"
+#include "driver/uart.h"
+#include "string.h"
+#include "driver/gpio.h"
+#include "MCU_Core_Protocol.h"
+#include "Protocol_Lib.h"
+#include "app_Ble_User.h"
+#include "app_BT_User.h"
+#include "bt_app_hf.h"
+
+
+#define TAG "MAIN_USER"
+extern esp_bd_addr_t peer_addr;
+
+uint32_t Sys_1ms_Cnt;
+
+#define SYS_RUN_TASK_1MS (1) 
+#define SYS_RUN_TASK_10MS (Sys_1ms_Cnt % 10 == 1) 
+#define SYS_RUN_TASK_20MS (Sys_1ms_Cnt % 20 == 2) 
+#define SYS_RUN_TASK_50MS (Sys_1ms_Cnt % 50 == 3) 
+#define SYS_RUN_TASK_100MS (Sys_1ms_Cnt % 100 == 4) 
+#define SYS_RUN_TASK_1000MS (Sys_1ms_Cnt % 1000 == 5) 
+
+
+
+uint32_t testcnt;
+
+static void Sys_Run_Tasks(void *arg)
+{
+    uint8_t i = 0;
+    while(1)
+    {
+        if(Sys_1ms_Cnt < 499)
+        {
+            Sys_1ms_Cnt ++ ;
+        }
+        else
+        {
+            Sys_1ms_Cnt = 0;
+        }
+
+
+        if(SYS_RUN_TASK_10MS)
+        {
+            Protocol_Send_Service();
+            Protocol_Service();
+
+            BT_User_Process();
+        }
+
+        if(SYS_RUN_TASK_20MS)
+        {
+            
+        }
+
+        if(SYS_RUN_TASK_50MS)
+        {
+            Prot_Send_Msg_Process();
+        }
+
+        if(SYS_RUN_TASK_100MS)
+        {
+            Ble_MsgRec_Navi_Timeout();
+        }
+
+        if(SYS_RUN_TASK_1000MS)
+        {
+            
+            simple_ota_service();
+
+            testcnt++;
+            if(testcnt >= 10)
+            {
+                testcnt = 0;
+
+                printf("BT_User.BT_Sts = %d\r\n", BT_User.BT_Sts);
+                printf("Ble_User.Ble_Sts = %d\r\n", Ble_User.Ble_Sts);
+
+                // esp_log_buffer_hex(TAG, peer_addr, 6);
+
+                // printf("Ble_User.Navi_Updat = %d\r\n", Ble_User.Navi_Updat);
+
+                // printf("RecCtrl.Sts = %d\r\n", RecCtrl.Sts);
+
+
+                // Ble_Msg_RequestNavi_RLY();
+
+
+
+                // if(Prot_User.State < Prot_Normal)
+                // {
+                //     Prot_User.State = Prot_Normal;
+
+                //     printf("Prot_Normal \r\n");
+                // }
+
+
+            }
+        }
+
+        vTaskDelay(1);
+    }
+    vTaskDelete(NULL);
+}
+
+void app_main(void)
+{
+    Protocol_User_Ctrl_Init();
+    BT_User_Init();
+    Ble_User_Init();
+    Get_Mac_Init();
+    bsp_BT_Init();
+    // bsp_Ble_Init();
+    bsp_Uart_Init();
+
+    printf("KL30 INIT OVER~~~~~~\r\n");
+
+    xTaskCreatePinnedToCore(Sys_Run_Tasks, "Sys_Run_Tasks", 4096, NULL, 3, NULL, 1);
+}
+
+
+

RT200T_2_ESP32/main/main_user.h

+#ifndef _MAIN_USER_H_
+#define _MAIN_USER_H_
+
+
+
+
+#endif
\ No newline at end of file

RT200T_2_ESP32/main/simple_ota_example.c

+/* OTA example
+
+   This example code is in the Public Domain (or CC0 licensed, at your option.)
+
+   Unless required by applicable law or agreed to in writing, this
+   software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+   CONDITIONS OF ANY KIND, either express or implied.
+*/
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "esp_system.h"
+#include "esp_event.h"
+#include "esp_log.h"
+#include "esp_ota_ops.h"
+#include "esp_http_client.h"
+#include "esp_https_ota.h"
+#include "protocol_examples_common.h"
+#include "string.h"
+#ifdef CONFIG_EXAMPLE_USE_CERT_BUNDLE
+#include "esp_crt_bundle.h"
+#endif
+
+#include "nvs.h"
+#include "nvs_flash.h"
+#include "protocol_examples_common.h"
+#include <sys/socket.h>
+#if CONFIG_EXAMPLE_CONNECT_WIFI
+#include "esp_wifi.h"
+#endif
+
+#define HASH_LEN 32
+
+#ifdef CONFIG_EXAMPLE_FIRMWARE_UPGRADE_BIND_IF
+/* The interface name value can refer to if_desc in esp_netif_defaults.h */
+#if CONFIG_EXAMPLE_FIRMWARE_UPGRADE_BIND_IF_ETH
+static const char *bind_interface_name = EXAMPLE_NETIF_DESC_ETH;
+#elif CONFIG_EXAMPLE_FIRMWARE_UPGRADE_BIND_IF_STA
+static const char *bind_interface_name = EXAMPLE_NETIF_DESC_STA;
+#endif
+#endif
+
+static const char *TAG = "simple_ota_example";
+extern const uint8_t server_cert_pem_start[] asm("_binary_ca_cert_pem_start");
+extern const uint8_t server_cert_pem_end[] asm("_binary_ca_cert_pem_end");
+
+#define OTA_URL_SIZE 256
+
+esp_err_t _http_event_handler(esp_http_client_event_t *evt)
+{
+    switch (evt->event_id) {
+    case HTTP_EVENT_ERROR:
+        ESP_LOGD(TAG, "HTTP_EVENT_ERROR");
+        break;
+    case HTTP_EVENT_ON_CONNECTED:
+        ESP_LOGD(TAG, "HTTP_EVENT_ON_CONNECTED");
+        break;
+    case HTTP_EVENT_HEADER_SENT:
+        ESP_LOGD(TAG, "HTTP_EVENT_HEADER_SENT");
+        break;
+    case HTTP_EVENT_ON_HEADER:
+        ESP_LOGD(TAG, "HTTP_EVENT_ON_HEADER, key=%s, value=%s", evt->header_key, evt->header_value);
+        break;
+    case HTTP_EVENT_ON_DATA:
+        ESP_LOGD(TAG, "HTTP_EVENT_ON_DATA, len=%d", evt->data_len);
+        break;
+    case HTTP_EVENT_ON_FINISH:
+        ESP_LOGD(TAG, "HTTP_EVENT_ON_FINISH");
+        break;
+    case HTTP_EVENT_DISCONNECTED:
+        ESP_LOGD(TAG, "HTTP_EVENT_DISCONNECTED");
+        break;
+    case HTTP_EVENT_REDIRECT:
+        ESP_LOGD(TAG, "HTTP_EVENT_REDIRECT");
+        break;
+    }
+    return ESP_OK;
+}
+
+void simple_ota_example_task(void *pvParameter)
+{
+    int i = 0;
+    ESP_LOGI(TAG, "Starting OTA example task");
+#ifdef CONFIG_EXAMPLE_FIRMWARE_UPGRADE_BIND_IF
+    esp_netif_t *netif = get_example_netif_from_desc(bind_interface_name);
+    if (netif == NULL) {
+        ESP_LOGE(TAG, "Can't find netif from interface description");
+        abort();
+    }
+    struct ifreq ifr;
+    esp_netif_get_netif_impl_name(netif, ifr.ifr_name);
+    ESP_LOGI(TAG, "Bind interface name is %s", ifr.ifr_name);
+#endif
+    esp_http_client_config_t config = {
+        .url = CONFIG_EXAMPLE_FIRMWARE_UPGRADE_URL,
+#ifdef CONFIG_EXAMPLE_USE_CERT_BUNDLE
+        .crt_bundle_attach = esp_crt_bundle_attach,
+#else
+        .cert_pem = (char *)server_cert_pem_start,
+#endif /* CONFIG_EXAMPLE_USE_CERT_BUNDLE */
+        .event_handler = _http_event_handler,
+        .keep_alive_enable = true,
+#ifdef CONFIG_EXAMPLE_FIRMWARE_UPGRADE_BIND_IF
+        .if_name = &ifr,
+#endif
+    };
+
+#ifdef CONFIG_EXAMPLE_FIRMWARE_UPGRADE_URL_FROM_STDIN
+    char url_buf[OTA_URL_SIZE];
+    if (strcmp(config.url, "FROM_STDIN") == 0) {
+        example_configure_stdin_stdout();
+        fgets(url_buf, OTA_URL_SIZE, stdin);
+        int len = strlen(url_buf);
+        url_buf[len - 1] = '\0';
+        config.url = url_buf;
+    } else {
+        ESP_LOGE(TAG, "Configuration mismatch: wrong firmware upgrade image url");
+        abort();
+    }
+#endif
+
+#ifdef CONFIG_EXAMPLE_SKIP_COMMON_NAME_CHECK
+    config.skip_cert_common_name_check = true;
+#endif
+
+    esp_https_ota_config_t ota_config = {
+        .http_config = &config,
+    };
+    ESP_LOGI(TAG, "Attempting to download update from %s", config.url);
+    esp_err_t ret = esp_https_ota(&ota_config);
+    if (ret == ESP_OK) {
+        ESP_LOGI(TAG, "OTA Succeed");
+
+        printf("\n");
+        printf("==========================================================\n");
+        for(i = 5; i > 0; i--)
+        {
+            printf("============ System will restart in %d second. ============\n", i);
+            vTaskDelay(1000 / portTICK_PERIOD_MS);
+        }
+        printf("============         System rebooting...      ============\n");
+        printf("==========================================================\n");
+        printf("\n");
+
+        esp_restart();
+    } else {
+        ESP_LOGE(TAG, "Firmware upgrade failed");
+    }
+    while (1) {
+        vTaskDelay(1000 / portTICK_PERIOD_MS);
+    }
+}
+
+static void print_sha256(const uint8_t *image_hash, const char *label)
+{
+    char hash_print[HASH_LEN * 2 + 1];
+    hash_print[HASH_LEN * 2] = 0;
+    for (int i = 0; i < HASH_LEN; ++i) {
+        sprintf(&hash_print[i * 2], "%02x", image_hash[i]);
+    }
+    ESP_LOGI(TAG, "%s %s", label, hash_print);
+}
+
+static void get_sha256_of_partitions(void)
+{
+    uint8_t sha_256[HASH_LEN] = { 0 };
+    esp_partition_t partition;
+
+    // get sha256 digest for bootloader
+    partition.address   = ESP_BOOTLOADER_OFFSET;
+    partition.size      = ESP_PARTITION_TABLE_OFFSET;
+    partition.type      = ESP_PARTITION_TYPE_APP;
+    esp_partition_get_sha256(&partition, sha_256);
+    print_sha256(sha_256, "SHA-256 for bootloader: ");
+
+    // get sha256 digest for running partition
+    esp_partition_get_sha256(esp_ota_get_running_partition(), sha_256);
+    print_sha256(sha_256, "SHA-256 for current firmware: ");
+}
+
+void simple_ota_main(void)
+{
+    ESP_LOGI(TAG, "OTA example app_main start");
+    // Initialize NVS.
+    // esp_err_t err = nvs_flash_init();
+    // if (err == ESP_ERR_NVS_NO_FREE_PAGES || err == ESP_ERR_NVS_NEW_VERSION_FOUND) {
+        // 1.OTA app partition table has a smaller NVS partition size than the non-OTA
+        // partition table. This size mismatch may cause NVS initialization to fail.
+        // 2.NVS partition contains data in new format and cannot be recognized by this version of code.
+        // If this happens, we erase NVS partition and initialize NVS again.
+    //     ESP_ERROR_CHECK(nvs_flash_erase());
+    //     err = nvs_flash_init();
+    // }
+    // ESP_ERROR_CHECK(err);
+
+    get_sha256_of_partitions();
+
+    ESP_ERROR_CHECK(esp_netif_init());
+    ESP_ERROR_CHECK(esp_event_loop_create_default());
+
+    /* This helper function configures Wi-Fi or Ethernet, as selected in menuconfig.
+     * Read "Establishing Wi-Fi or Ethernet Connection" section in
+     * examples/protocols/README.md for more information about this function.
+     */
+    ESP_ERROR_CHECK(example_connect());
+
+#if CONFIG_EXAMPLE_CONNECT_WIFI
+    /* Ensure to disable any WiFi power save mode, this allows best throughput
+     * and hence timings for overall OTA operation.
+     */
+    esp_wifi_set_ps(WIFI_PS_NONE);
+#endif // CONFIG_EXAMPLE_CONNECT_WIFI
+
+    xTaskCreate(&simple_ota_example_task, "ota_example_task", 8192, NULL, 5, NULL);
+}

RT200T_2_ESP32/pytest_simple_ota.py

+# SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+# SPDX-License-Identifier: Unlicense OR CC0-1.0
+import http.server
+import multiprocessing
+import os
+import ssl
+import sys
+from typing import Tuple
+
+import pexpect
+import pytest
+from common_test_methods import get_env_config_variable, get_host_ip4_by_dest_ip
+from pytest_embedded import Dut
+
+server_cert = '-----BEGIN CERTIFICATE-----\n' \
+              'MIIDWDCCAkACCQCbF4+gVh/MLjANBgkqhkiG9w0BAQsFADBuMQswCQYDVQQGEwJJ\n'\
+              'TjELMAkGA1UECAwCTUgxDDAKBgNVBAcMA1BVTjEMMAoGA1UECgwDRVNQMQwwCgYD\n'\
+              'VQQLDANFU1AxDDAKBgNVBAMMA0VTUDEaMBgGCSqGSIb3DQEJARYLZXNwQGVzcC5j\n'\
+              'b20wHhcNMjEwNzEyMTIzNjI3WhcNNDEwNzA3MTIzNjI3WjBuMQswCQYDVQQGEwJJ\n'\
+              'TjELMAkGA1UECAwCTUgxDDAKBgNVBAcMA1BVTjEMMAoGA1UECgwDRVNQMQwwCgYD\n'\
+              'VQQLDANFU1AxDDAKBgNVBAMMA0VTUDEaMBgGCSqGSIb3DQEJARYLZXNwQGVzcC5j\n'\
+              'b20wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDhxF/y7bygndxPwiWL\n'\
+              'SwS9LY3uBMaJgup0ufNKVhx+FhGQOu44SghuJAaH3KkPUnt6SOM8jC97/yQuc32W\n'\
+              'ukI7eBZoA12kargSnzdv5m5rZZpd+NznSSpoDArOAONKVlzr25A1+aZbix2mKRbQ\n'\
+              'S5w9o1N2BriQuSzd8gL0Y0zEk3VkOWXEL+0yFUT144HnErnD+xnJtHe11yPO2fEz\n'\
+              'YaGiilh0ddL26PXTugXMZN/8fRVHP50P2OG0SvFpC7vghlLp4VFM1/r3UJnvL6Oz\n'\
+              '3ALc6dhxZEKQucqlpj8l1UegszQToopemtIj0qXTHw2+uUnkUyWIPjPC+wdOAoap\n'\
+              'rFTRAgMBAAEwDQYJKoZIhvcNAQELBQADggEBAItw24y565k3C/zENZlxyzto44ud\n'\
+              'IYPQXN8Fa2pBlLe1zlSIyuaA/rWQ+i1daS8nPotkCbWZyf5N8DYaTE4B0OfvoUPk\n'\
+              'B5uGDmbuk6akvlB5BGiYLfQjWHRsK9/4xjtIqN1H58yf3QNROuKsPAeywWS3Fn32\n'\
+              '3//OpbWaClQePx6udRYMqAitKR+QxL7/BKZQsX+UyShuq8hjphvXvk0BW8ONzuw9\n'\
+              'RcoORxM0FzySYjeQvm4LhzC/P3ZBhEq0xs55aL2a76SJhq5hJy7T/Xz6NFByvlrN\n'\
+              'lFJJey33KFrAf5vnV9qcyWFIo7PYy2VsaaEjFeefr7q3sTFSMlJeadexW2Y=\n'\
+              '-----END CERTIFICATE-----\n'
+
+server_key = '-----BEGIN PRIVATE KEY-----\n'\
+             'MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQDhxF/y7bygndxP\n'\
+             'wiWLSwS9LY3uBMaJgup0ufNKVhx+FhGQOu44SghuJAaH3KkPUnt6SOM8jC97/yQu\n'\
+             'c32WukI7eBZoA12kargSnzdv5m5rZZpd+NznSSpoDArOAONKVlzr25A1+aZbix2m\n'\
+             'KRbQS5w9o1N2BriQuSzd8gL0Y0zEk3VkOWXEL+0yFUT144HnErnD+xnJtHe11yPO\n'\
+             '2fEzYaGiilh0ddL26PXTugXMZN/8fRVHP50P2OG0SvFpC7vghlLp4VFM1/r3UJnv\n'\
+             'L6Oz3ALc6dhxZEKQucqlpj8l1UegszQToopemtIj0qXTHw2+uUnkUyWIPjPC+wdO\n'\
+             'AoaprFTRAgMBAAECggEAE0HCxV/N1Q1h+1OeDDGL5+74yjKSFKyb/vTVcaPCrmaH\n'\
+             'fPvp0ddOvMZJ4FDMAsiQS6/n4gQ7EKKEnYmwTqj4eUYW8yxGUn3f0YbPHbZT+Mkj\n'\
+             'z5woi3nMKi/MxCGDQZX4Ow3xUQlITUqibsfWcFHis8c4mTqdh4qj7xJzehD2PVYF\n'\
+             'gNHZsvVj6MltjBDAVwV1IlGoHjuElm6vuzkfX7phxcA1B4ZqdYY17yCXUnvui46z\n'\
+             'Xn2kUTOOUCEgfgvGa9E+l4OtdXi5IxjaSraU+dlg2KsE4TpCuN2MEVkeR5Ms3Y7Q\n'\
+             'jgJl8vlNFJDQpbFukLcYwG7rO5N5dQ6WWfVia/5XgQKBgQD74at/bXAPrh9NxPmz\n'\
+             'i1oqCHMDoM9sz8xIMZLF9YVu3Jf8ux4xVpRSnNy5RU1gl7ZXbpdgeIQ4v04zy5aw\n'\
+             '8T4tu9K3XnR3UXOy25AK0q+cnnxZg3kFQm+PhtOCKEFjPHrgo2MUfnj+EDddod7N\n'\
+             'JQr9q5rEFbqHupFPpWlqCa3QmQKBgQDldWUGokNaEpmgHDMnHxiibXV5LQhzf8Rq\n'\
+             'gJIQXb7R9EsTSXEvsDyqTBb7PHp2Ko7rZ5YQfyf8OogGGjGElnPoU/a+Jij1gVFv\n'\
+             'kZ064uXAAISBkwHdcuobqc5EbG3ceyH46F+FBFhqM8KcbxJxx08objmh58+83InN\n'\
+             'P9Qr25Xw+QKBgEGXMHuMWgQbSZeM1aFFhoMvlBO7yogBTKb4Ecpu9wI5e3Kan3Al\n'\
+             'pZYltuyf+VhP6XG3IMBEYdoNJyYhu+nzyEdMg8CwXg+8LC7FMis/Ve+o7aS5scgG\n'\
+             '1to/N9DK/swCsdTRdzmc/ZDbVC+TuVsebFBGYZTyO5KgqLpezqaIQrTxAoGALFCU\n'\
+             '10glO9MVyl9H3clap5v+MQ3qcOv/EhaMnw6L2N6WVT481tnxjW4ujgzrFcE4YuxZ\n'\
+             'hgwYu9TOCmeqopGwBvGYWLbj+C4mfSahOAs0FfXDoYazuIIGBpuv03UhbpB1Si4O\n'\
+             'rJDfRnuCnVWyOTkl54gKJ2OusinhjztBjcrV1XkCgYEA3qNi4uBsPdyz9BZGb/3G\n'\
+             'rOMSw0CaT4pEMTLZqURmDP/0hxvTk1polP7O/FYwxVuJnBb6mzDa0xpLFPTpIAnJ\n'\
+             'YXB8xpXU69QVh+EBbemdJWOd+zp5UCfXvb2shAeG3Tn/Dz4cBBMEUutbzP+or0nG\n'\
+             'vSXnRLaxQhooWm+IuX9SuBQ=\n'\
+             '-----END PRIVATE KEY-----\n'
+
+
+def start_https_server(ota_image_dir: str, server_ip: str, server_port: int, server_file: str = None, key_file: str = None) -> None:
+    os.chdir(ota_image_dir)
+
+    if server_file is None:
+        server_file = os.path.join(ota_image_dir, 'server_cert.pem')
+        cert_file_handle = open(server_file, 'w+')
+        cert_file_handle.write(server_cert)
+        cert_file_handle.close()
+
+    if key_file is None:
+        key_file = os.path.join(ota_image_dir, 'server_key.pem')
+        key_file_handle = open('server_key.pem', 'w+')
+        key_file_handle.write(server_key)
+        key_file_handle.close()
+
+    httpd = http.server.HTTPServer((server_ip, server_port), http.server.SimpleHTTPRequestHandler)
+
+    httpd.socket = ssl.wrap_socket(httpd.socket,
+                                   keyfile=key_file,
+                                   certfile=server_file, server_side=True)
+    httpd.serve_forever()
+
+
+def check_sha256(sha256_expected: str, sha256_reported: str) -> None:
+    print('sha256_expected: %s' % (sha256_expected))
+    print('sha256_reported: %s' % (sha256_reported))
+    if sha256_expected not in sha256_reported:
+        raise ValueError('SHA256 mismatch')
+    else:
+        print('SHA256 expected and reported are the same')
+
+
+def calc_all_sha256(dut: Dut) -> Tuple[str, str]:
+    bootloader_path = os.path.join(dut.app.binary_path, 'bootloader', 'bootloader.bin')
+    sha256_bootloader = dut.app.get_sha256(bootloader_path)
+
+    app_path = os.path.join(dut.app.binary_path, 'simple_ota.bin')
+    sha256_app = dut.app.get_sha256(app_path)
+
+    return str(sha256_bootloader), str(sha256_app)
+
+
+@pytest.mark.esp32
+@pytest.mark.esp32c3
+@pytest.mark.esp32s2
+@pytest.mark.esp32s3
+@pytest.mark.wifi_high_traffic
+def test_examples_protocol_simple_ota_example(dut: Dut) -> None:
+    """
+    steps: |
+      1. join AP/Ethernet
+      2. Fetch OTA image over HTTPS
+      3. Reboot with the new OTA image
+    """
+    sha256_bootloader, sha256_app = calc_all_sha256(dut)
+    # Start server
+    thread1 = multiprocessing.Process(target=start_https_server, args=(dut.app.binary_path, '0.0.0.0', 8000))
+    thread1.daemon = True
+    thread1.start()
+    try:
+        # start test
+        dut.expect('Loaded app from partition at offset 0x10000', timeout=30)
+        check_sha256(sha256_bootloader, str(dut.expect(r'SHA-256 for bootloader:\s+([a-f0-9]){64}')[0]))
+        check_sha256(sha256_app, str(dut.expect(r'SHA-256 for current firmware:\s+([a-f0-9]){64}')[0]))
+        # Parse IP address of STA
+        if dut.app.sdkconfig.get('EXAMPLE_WIFI_SSID_PWD_FROM_STDIN') is True:
+            env_name = 'wifi_high_traffic'
+            dut.expect('Please input ssid password:')
+            ap_ssid = get_env_config_variable(env_name, 'ap_ssid')
+            ap_password = get_env_config_variable(env_name, 'ap_password')
+            dut.write(f'{ap_ssid} {ap_password}')
+        try:
+            ip_address = dut.expect(r'IPv4 address: (\d+\.\d+\.\d+\.\d+)[^\d]', timeout=30)[1].decode()
+            print('Connected to AP/Ethernet with IP: {}'.format(ip_address))
+        except pexpect.exceptions.TIMEOUT:
+            raise ValueError('ENV_TEST_FAILURE: Cannot connect to AP/Ethernet')
+        host_ip = get_host_ip4_by_dest_ip(ip_address)
+
+        dut.expect('Starting OTA example task', timeout=30)
+        print('writing to device: {}'.format('https://' + host_ip + ':8000/simple_ota.bin'))
+        dut.write('https://' + host_ip + ':8000/simple_ota.bin')
+        dut.expect('OTA Succeed, Rebooting...', timeout=60)
+        # after reboot
+        dut.expect('Loaded app from partition at offset 0x110000', timeout=30)
+        dut.expect('OTA example app_main start', timeout=10)
+    finally:
+        thread1.terminate()
+
+
+@pytest.mark.esp32
+@pytest.mark.esp32c3
+@pytest.mark.esp32s2
+@pytest.mark.esp32s3
+@pytest.mark.ethernet_ota
+@pytest.mark.parametrize('config', ['spiram',], indirect=True)
+def test_examples_protocol_simple_ota_example_ethernet_with_spiram_config(dut: Dut) -> None:
+    """
+    steps: |
+      1. join AP/Ethernet
+      2. Fetch OTA image over HTTPS
+      3. Reboot with the new OTA image
+    """
+    # Start server
+    thread1 = multiprocessing.Process(target=start_https_server, args=(dut.app.binary_path, '0.0.0.0', 8000))
+    thread1.daemon = True
+    thread1.start()
+    try:
+        # start test
+        dut.expect('Loaded app from partition at offset 0x10000', timeout=30)
+        try:
+            ip_address = dut.expect(r'IPv4 address: (\d+\.\d+\.\d+\.\d+)[^\d]', timeout=30)[1].decode()
+            print('Connected to AP/Ethernet with IP: {}'.format(ip_address))
+        except pexpect.exceptions.TIMEOUT:
+            raise ValueError('ENV_TEST_FAILURE: Cannot connect to AP/Ethernet')
+        host_ip = get_host_ip4_by_dest_ip(ip_address)
+
+        dut.expect('Starting OTA example task', timeout=30)
+        print('writing to device: {}'.format('https://' + host_ip + ':8000/simple_ota.bin'))
+        dut.write('https://' + host_ip + ':8000/simple_ota.bin')
+        dut.expect('OTA Succeed, Rebooting...', timeout=60)
+        # after reboot
+        dut.expect('Loaded app from partition at offset 0x110000', timeout=30)
+        dut.expect('OTA example app_main start', timeout=10)
+    finally:
+        thread1.terminate()
+
+
+@pytest.mark.esp32
+@pytest.mark.esp32c3
+@pytest.mark.flash_encryption_wifi_high_traffic
+@pytest.mark.nightly_run
+@pytest.mark.parametrize('config', ['flash_enc_wifi',], indirect=True)
+@pytest.mark.parametrize('skip_autoflash', ['y'], indirect=True)
+def test_examples_protocol_simple_ota_example_with_flash_encryption_wifi(dut: Dut) -> None:
+    """
+    steps: |
+      1. join AP/Ethernet
+      2. Fetch OTA image over HTTPS
+      3. Reboot with the new OTA image
+    """
+    # start test
+    # Erase flash
+    dut.serial.erase_flash()
+    dut.serial.flash()
+    # Start server
+    thread1 = multiprocessing.Process(target=start_https_server, args=(dut.app.binary_path, '0.0.0.0', 8000))
+    thread1.daemon = True
+    thread1.start()
+    try:
+        dut.expect('Loaded app from partition at offset 0x20000', timeout=30)
+        dut.expect('Flash encryption mode is DEVELOPMENT', timeout=10)
+        # Parse IP address of STA
+        if dut.app.sdkconfig.get('EXAMPLE_WIFI_SSID_PWD_FROM_STDIN') is True:
+            env_name = 'flash_encryption_wifi_high_traffic'
+            dut.expect('Please input ssid password:')
+            ap_ssid = get_env_config_variable(env_name, 'ap_ssid')
+            ap_password = get_env_config_variable(env_name, 'ap_password')
+            dut.write(f'{ap_ssid} {ap_password}')
+        try:
+            ip_address = dut.expect(r'IPv4 address: (\d+\.\d+\.\d+\.\d+)[^\d]', timeout=30)[1].decode()
+            print('Connected to AP/Ethernet with IP: {}'.format(ip_address))
+        except pexpect.exceptions.TIMEOUT:
+            raise ValueError('ENV_TEST_FAILURE: Cannot connect to AP/Ethernet')
+        host_ip = get_host_ip4_by_dest_ip(ip_address)
+
+        dut.expect('Starting OTA example task', timeout=30)
+        print('writing to device: {}'.format('https://' + host_ip + ':8000/simple_ota.bin'))
+        dut.write('https://' + host_ip + ':8000/simple_ota.bin')
+        dut.expect('OTA Succeed, Rebooting...', timeout=60)
+        # after reboot
+        dut.expect('Loaded app from partition at offset 0x120000', timeout=30)
+        dut.expect('Flash encryption mode is DEVELOPMENT', timeout=10)
+        dut.expect('OTA example app_main start', timeout=10)
+    finally:
+        thread1.terminate()
+
+
+@pytest.mark.esp32
+@pytest.mark.esp32c3
+@pytest.mark.esp32s2
+@pytest.mark.esp32s3
+@pytest.mark.ethernet_ota
+@pytest.mark.parametrize('config', ['on_update_no_sb_ecdsa',], indirect=True)
+def test_examples_protocol_simple_ota_example_with_verify_app_signature_on_update_no_secure_boot_ecdsa(dut: Dut) -> None:
+    """
+    steps: |
+      1. join AP/Ethernet
+      2. Fetch OTA image over HTTPS
+      3. Reboot with the new OTA image
+    """
+    sha256_bootloader, sha256_app = calc_all_sha256(dut)
+    # Start server
+    thread1 = multiprocessing.Process(target=start_https_server, args=(dut.app.binary_path, '0.0.0.0', 8000))
+    thread1.daemon = True
+    thread1.start()
+    try:
+        # start test
+        dut.expect('Loaded app from partition at offset 0x20000', timeout=30)
+        check_sha256(sha256_bootloader, str(dut.expect(r'SHA-256 for bootloader:\s+([a-f0-9]){64}')[0]))
+        check_sha256(sha256_app, str(dut.expect(r'SHA-256 for current firmware:\s+([a-f0-9]){64}')[0]))
+        try:
+            ip_address = dut.expect(r'IPv4 address: (\d+\.\d+\.\d+\.\d+)[^\d]', timeout=30)[1].decode()
+            print('Connected to AP/Ethernet with IP: {}'.format(ip_address))
+        except pexpect.exceptions.TIMEOUT:
+            raise ValueError('ENV_TEST_FAILURE: Cannot connect to AP/Ethernet')
+        host_ip = get_host_ip4_by_dest_ip(ip_address)
+
+        dut.expect('Starting OTA example task', timeout=30)
+        print('writing to device: {}'.format('https://' + host_ip + ':8000/simple_ota.bin'))
+        dut.write('https://' + host_ip + ':8000/simple_ota.bin')
+        dut.expect('Writing to partition subtype 16 at offset 0x120000', timeout=20)
+        dut.expect('Verifying image signature...', timeout=60)
+        dut.expect('OTA Succeed, Rebooting...', timeout=60)
+        # after reboot
+        dut.expect('Loaded app from partition at offset 0x120000', timeout=20)
+        dut.expect('OTA example app_main start', timeout=10)
+    finally:
+        thread1.terminate()
+
+
+@pytest.mark.esp32
+@pytest.mark.esp32c3
+@pytest.mark.esp32s2
+@pytest.mark.esp32s3
+@pytest.mark.ethernet_ota
+@pytest.mark.parametrize('config', ['on_update_no_sb_rsa',], indirect=True)
+def test_examples_protocol_simple_ota_example_with_verify_app_signature_on_update_no_secure_boot_rsa(dut: Dut) -> None:
+    """
+    steps: |
+      1. join AP/Ethernet
+      2. Fetch OTA image over HTTPS
+      3. Reboot with the new OTA image
+    """
+    sha256_bootloader, sha256_app = calc_all_sha256(dut)
+    # Start server
+    thread1 = multiprocessing.Process(target=start_https_server, args=(dut.app.binary_path, '0.0.0.0', 8000))
+    thread1.daemon = True
+    thread1.start()
+    try:
+        # start test
+        dut.expect('Loaded app from partition at offset 0x20000', timeout=30)
+        check_sha256(sha256_bootloader, str(dut.expect(r'SHA-256 for bootloader:\s+([a-f0-9]){64}')[0]))
+        check_sha256(sha256_app, str(dut.expect(r'SHA-256 for current firmware:\s+([a-f0-9]){64}')[0]))
+        try:
+            ip_address = dut.expect(r'IPv4 address: (\d+\.\d+\.\d+\.\d+)[^\d]', timeout=30)[1].decode()
+            print('Connected to AP/Ethernet with IP: {}'.format(ip_address))
+        except pexpect.exceptions.TIMEOUT:
+            raise ValueError('ENV_TEST_FAILURE: Cannot connect to AP/Ethernet')
+        host_ip = get_host_ip4_by_dest_ip(ip_address)
+
+        dut.expect('Starting OTA example task', timeout=30)
+        print('writing to device: {}'.format('https://' + host_ip + ':8000/simple_ota.bin'))
+        dut.write('https://' + host_ip + ':8000/simple_ota.bin')
+        dut.expect('Writing to partition subtype 16 at offset 0x120000', timeout=20)
+        dut.expect('Verifying image signature...', timeout=60)
+        dut.expect('#0 app key digest == #0 trusted key digest', timeout=10)
+        dut.expect('Verifying with RSA-PSS...', timeout=10)
+        dut.expect('Signature verified successfully!', timeout=10)
+        dut.expect('OTA Succeed, Rebooting...', timeout=60)
+        # after reboot
+        dut.expect('Loaded app from partition at offset 0x120000', timeout=20)
+        dut.expect('OTA example app_main start', timeout=10)
+    finally:
+        thread1.terminate()
+
+
+if __name__ == '__main__':
+    if sys.argv[2:]:    # if two or more arguments provided:
+        # Usage: example_test.py <image_dir> <server_port> [cert_di>]
+        this_dir = os.path.dirname(os.path.realpath(__file__))
+        bin_dir = os.path.join(this_dir, sys.argv[1])
+        port = int(sys.argv[2])
+        cert_dir = bin_dir if not sys.argv[3:] else os.path.join(this_dir, sys.argv[3])  # optional argument
+        print('Starting HTTPS server at "https://:{}"'.format(port))
+        start_https_server(bin_dir, '', port,
+                           server_file=os.path.join(cert_dir, 'ca_cert.pem'),
+                           key_file=os.path.join(cert_dir, 'ca_key.pem'))

RT200T_2_ESP32/sdkconfig

+#
+# Automatically generated file. DO NOT EDIT.
+# Espressif IoT Development Framework (ESP-IDF) Project Configuration
+#
+CONFIG_SOC_BROWNOUT_RESET_SUPPORTED="Not determined"
+CONFIG_SOC_TWAI_BRP_DIV_SUPPORTED="Not determined"
+CONFIG_SOC_DPORT_WORKAROUND="Not determined"
+CONFIG_SOC_CAPS_ECO_VER_MAX=301
+CONFIG_SOC_ADC_SUPPORTED=y
+CONFIG_SOC_DAC_SUPPORTED=y
+CONFIG_SOC_MCPWM_SUPPORTED=y
+CONFIG_SOC_SDMMC_HOST_SUPPORTED=y
+CONFIG_SOC_BT_SUPPORTED=y
+CONFIG_SOC_PCNT_SUPPORTED=y
+CONFIG_SOC_WIFI_SUPPORTED=y
+CONFIG_SOC_SDIO_SLAVE_SUPPORTED=y
+CONFIG_SOC_TWAI_SUPPORTED=y
+CONFIG_SOC_EMAC_SUPPORTED=y
+CONFIG_SOC_ULP_SUPPORTED=y
+CONFIG_SOC_CCOMP_TIMER_SUPPORTED=y
+CONFIG_SOC_RTC_FAST_MEM_SUPPORTED=y
+CONFIG_SOC_RTC_SLOW_MEM_SUPPORTED=y
+CONFIG_SOC_RTC_MEM_SUPPORTED=y
+CONFIG_SOC_I2S_SUPPORTED=y
+CONFIG_SOC_RMT_SUPPORTED=y
+CONFIG_SOC_SDM_SUPPORTED=y
+CONFIG_SOC_SUPPORT_COEXISTENCE=y
+CONFIG_SOC_AES_SUPPORTED=y
+CONFIG_SOC_MPI_SUPPORTED=y
+CONFIG_SOC_SHA_SUPPORTED=y
+CONFIG_SOC_FLASH_ENC_SUPPORTED=y
+CONFIG_SOC_SECURE_BOOT_SUPPORTED=y
+CONFIG_SOC_TOUCH_SENSOR_SUPPORTED=y
+CONFIG_SOC_DPORT_WORKAROUND_DIS_INTERRUPT_LVL=5
+CONFIG_SOC_XTAL_SUPPORT_26M=y
+CONFIG_SOC_XTAL_SUPPORT_40M=y
+CONFIG_SOC_XTAL_SUPPORT_AUTO_DETECT=y
+CONFIG_SOC_ADC_RTC_CTRL_SUPPORTED=y
+CONFIG_SOC_ADC_DIG_CTRL_SUPPORTED=y
+CONFIG_SOC_ADC_DMA_SUPPORTED=y
+CONFIG_SOC_ADC_PERIPH_NUM=2
+CONFIG_SOC_ADC_MAX_CHANNEL_NUM=10
+CONFIG_SOC_ADC_ATTEN_NUM=4
+CONFIG_SOC_ADC_DIGI_CONTROLLER_NUM=2
+CONFIG_SOC_ADC_PATT_LEN_MAX=16
+CONFIG_SOC_ADC_DIGI_MIN_BITWIDTH=9
+CONFIG_SOC_ADC_DIGI_MAX_BITWIDTH=12
+CONFIG_SOC_ADC_DIGI_RESULT_BYTES=2
+CONFIG_SOC_ADC_DIGI_DATA_BYTES_PER_CONV=4
+CONFIG_SOC_ADC_SAMPLE_FREQ_THRES_HIGH=2
+CONFIG_SOC_ADC_SAMPLE_FREQ_THRES_LOW=20
+CONFIG_SOC_ADC_RTC_MIN_BITWIDTH=9
+CONFIG_SOC_ADC_RTC_MAX_BITWIDTH=12
+CONFIG_SOC_RTC_SLOW_CLOCK_SUPPORT_8MD256=y
+CONFIG_SOC_SHARED_IDCACHE_SUPPORTED=y
+CONFIG_SOC_IDCACHE_PER_CORE=y
+CONFIG_SOC_MMU_LINEAR_ADDRESS_REGION_NUM=5
+CONFIG_SOC_CPU_CORES_NUM=2
+CONFIG_SOC_CPU_INTR_NUM=32
+CONFIG_SOC_CPU_HAS_FPU=y
+CONFIG_SOC_CPU_BREAKPOINTS_NUM=2
+CONFIG_SOC_CPU_WATCHPOINTS_NUM=2
+CONFIG_SOC_CPU_WATCHPOINT_MAX_REGION_SIZE=64
+CONFIG_SOC_DAC_PERIPH_NUM=2
+CONFIG_SOC_DAC_RESOLUTION=8
+CONFIG_SOC_GPIO_PORT=1
+CONFIG_SOC_GPIO_PIN_COUNT=40
+CONFIG_SOC_GPIO_VALID_GPIO_MASK=0xFFFFFFFFFF
+CONFIG_SOC_GPIO_VALID_DIGITAL_IO_PAD_MASK=0xEF0FEA
+CONFIG_SOC_I2C_NUM=2
+CONFIG_SOC_I2C_FIFO_LEN=32
+CONFIG_SOC_I2C_SUPPORT_SLAVE=y
+CONFIG_SOC_I2C_SUPPORT_APB=y
+CONFIG_SOC_CLK_APLL_SUPPORTED=y
+CONFIG_SOC_APLL_MULTIPLIER_OUT_MIN_HZ=350000000
+CONFIG_SOC_APLL_MULTIPLIER_OUT_MAX_HZ=500000000
+CONFIG_SOC_APLL_MIN_HZ=5303031
+CONFIG_SOC_APLL_MAX_HZ=125000000
+CONFIG_SOC_I2S_NUM=2
+CONFIG_SOC_I2S_HW_VERSION_1=y
+CONFIG_SOC_I2S_SUPPORTS_APLL=y
+CONFIG_SOC_I2S_SUPPORTS_PDM=y
+CONFIG_SOC_I2S_SUPPORTS_PDM_TX=y
+CONFIG_SOC_I2S_SUPPORTS_PDM_RX=y
+CONFIG_SOC_I2S_SUPPORTS_ADC_DAC=y
+CONFIG_SOC_I2S_SUPPORTS_ADC=y
+CONFIG_SOC_I2S_SUPPORTS_DAC=y
+CONFIG_SOC_I2S_SUPPORTS_LCD_CAMERA=y
+CONFIG_SOC_I2S_TRANS_SIZE_ALIGN_WORD=y
+CONFIG_SOC_I2S_LCD_I80_VARIANT=y
+CONFIG_SOC_LCD_I80_SUPPORTED=y
+CONFIG_SOC_LCD_I80_BUSES=2
+CONFIG_SOC_LCD_I80_BUS_WIDTH=24
+CONFIG_SOC_LEDC_HAS_TIMER_SPECIFIC_MUX=y
+CONFIG_SOC_LEDC_SUPPORT_APB_CLOCK=y
+CONFIG_SOC_LEDC_SUPPORT_REF_TICK=y
+CONFIG_SOC_LEDC_SUPPORT_HS_MODE=y
+CONFIG_SOC_LEDC_CHANNEL_NUM=8
+CONFIG_SOC_LEDC_TIMER_BIT_WIDE_NUM=20
+CONFIG_SOC_MCPWM_GROUPS=2
+CONFIG_SOC_MCPWM_TIMERS_PER_GROUP=3
+CONFIG_SOC_MCPWM_OPERATORS_PER_GROUP=3
+CONFIG_SOC_MCPWM_COMPARATORS_PER_OPERATOR=2
+CONFIG_SOC_MCPWM_GENERATORS_PER_OPERATOR=2
+CONFIG_SOC_MCPWM_TRIGGERS_PER_OPERATOR=2
+CONFIG_SOC_MCPWM_GPIO_FAULTS_PER_GROUP=3
+CONFIG_SOC_MCPWM_CAPTURE_TIMERS_PER_GROUP=y
+CONFIG_SOC_MCPWM_CAPTURE_CHANNELS_PER_TIMER=3
+CONFIG_SOC_MCPWM_GPIO_SYNCHROS_PER_GROUP=3
+CONFIG_SOC_MPU_MIN_REGION_SIZE=0x20000000
+CONFIG_SOC_MPU_REGIONS_MAX_NUM=8
+CONFIG_SOC_PCNT_GROUPS=1
+CONFIG_SOC_PCNT_UNITS_PER_GROUP=8
+CONFIG_SOC_PCNT_CHANNELS_PER_UNIT=2
+CONFIG_SOC_PCNT_THRES_POINT_PER_UNIT=2
+CONFIG_SOC_RMT_GROUPS=1
+CONFIG_SOC_RMT_TX_CANDIDATES_PER_GROUP=8
+CONFIG_SOC_RMT_RX_CANDIDATES_PER_GROUP=8
+CONFIG_SOC_RMT_CHANNELS_PER_GROUP=8
+CONFIG_SOC_RMT_MEM_WORDS_PER_CHANNEL=64
+CONFIG_SOC_RMT_SUPPORT_REF_TICK=y
+CONFIG_SOC_RMT_SUPPORT_APB=y
+CONFIG_SOC_RMT_CHANNEL_CLK_INDEPENDENT=y
+CONFIG_SOC_RTCIO_PIN_COUNT=18
+CONFIG_SOC_RTCIO_INPUT_OUTPUT_SUPPORTED=y
+CONFIG_SOC_RTCIO_HOLD_SUPPORTED=y
+CONFIG_SOC_RTCIO_WAKE_SUPPORTED=y
+CONFIG_SOC_SDM_GROUPS=1
+CONFIG_SOC_SDM_CHANNELS_PER_GROUP=8
+CONFIG_SOC_SPI_HD_BOTH_INOUT_SUPPORTED=y
+CONFIG_SOC_SPI_AS_CS_SUPPORTED=y
+CONFIG_SOC_SPI_PERIPH_NUM=3
+CONFIG_SOC_SPI_DMA_CHAN_NUM=2
+CONFIG_SOC_SPI_MAX_CS_NUM=3
+CONFIG_SOC_SPI_MAXIMUM_BUFFER_SIZE=64
+CONFIG_SOC_SPI_MAX_PRE_DIVIDER=8192
+CONFIG_SOC_MEMSPI_SRC_FREQ_80M_SUPPORTED=y
+CONFIG_SOC_MEMSPI_SRC_FREQ_40M_SUPPORTED=y
+CONFIG_SOC_MEMSPI_SRC_FREQ_26M_SUPPORTED=y
+CONFIG_SOC_MEMSPI_SRC_FREQ_20M_SUPPORTED=y
+CONFIG_SOC_TIMER_GROUPS=2
+CONFIG_SOC_TIMER_GROUP_TIMERS_PER_GROUP=2
+CONFIG_SOC_TIMER_GROUP_COUNTER_BIT_WIDTH=64
+CONFIG_SOC_TIMER_GROUP_TOTAL_TIMERS=4
+CONFIG_SOC_TIMER_GROUP_SUPPORT_APB=y
+CONFIG_SOC_TOUCH_VERSION_1=y
+CONFIG_SOC_TOUCH_SENSOR_NUM=10
+CONFIG_SOC_TOUCH_PAD_MEASURE_WAIT_MAX=0xFF
+CONFIG_SOC_TWAI_BRP_MIN=2
+CONFIG_SOC_TWAI_SUPPORT_MULTI_ADDRESS_LAYOUT=y
+CONFIG_SOC_UART_NUM=3
+CONFIG_SOC_UART_SUPPORT_APB_CLK=y
+CONFIG_SOC_UART_SUPPORT_REF_TICK=y
+CONFIG_SOC_UART_FIFO_LEN=128
+CONFIG_SOC_UART_BITRATE_MAX=5000000
+CONFIG_SOC_SPIRAM_SUPPORTED=y
+CONFIG_SOC_SPI_MEM_SUPPORT_CONFIG_GPIO_BY_EFUSE=y
+CONFIG_SOC_SHA_SUPPORT_PARALLEL_ENG=y
+CONFIG_SOC_SHA_SUPPORT_SHA1=y
+CONFIG_SOC_SHA_SUPPORT_SHA256=y
+CONFIG_SOC_SHA_SUPPORT_SHA384=y
+CONFIG_SOC_SHA_SUPPORT_SHA512=y
+CONFIG_SOC_RSA_MAX_BIT_LEN=4096
+CONFIG_SOC_AES_SUPPORT_AES_128=y
+CONFIG_SOC_AES_SUPPORT_AES_192=y
+CONFIG_SOC_AES_SUPPORT_AES_256=y
+CONFIG_SOC_SECURE_BOOT_V1=y
+CONFIG_SOC_EFUSE_SECURE_BOOT_KEY_DIGESTS=y
+CONFIG_SOC_FLASH_ENCRYPTED_XTS_AES_BLOCK_MAX=32
+CONFIG_SOC_PHY_DIG_REGS_MEM_SIZE=21
+CONFIG_SOC_PM_SUPPORT_EXT_WAKEUP=y
+CONFIG_SOC_PM_SUPPORT_TOUCH_SENSOR_WAKEUP=y
+CONFIG_SOC_PM_SUPPORT_RTC_PERIPH_PD=y
+CONFIG_SOC_PM_SUPPORT_RTC_FAST_MEM_PD=y
+CONFIG_SOC_PM_SUPPORT_RTC_SLOW_MEM_PD=y
+CONFIG_SOC_PM_SUPPORT_MODEM_PD=y
+CONFIG_SOC_SDMMC_USE_IOMUX=y
+CONFIG_SOC_SDMMC_NUM_SLOTS=2
+CONFIG_SOC_WIFI_WAPI_SUPPORT=y
+CONFIG_SOC_WIFI_CSI_SUPPORT=y
+CONFIG_SOC_WIFI_MESH_SUPPORT=y
+CONFIG_SOC_BLE_SUPPORTED=y
+CONFIG_SOC_BLE_MESH_SUPPORTED=y
+CONFIG_SOC_BT_CLASSIC_SUPPORTED=y
+CONFIG_IDF_CMAKE=y
+CONFIG_IDF_TARGET_ARCH_XTENSA=y
+CONFIG_IDF_TARGET_ARCH="xtensa"
+CONFIG_IDF_TARGET="esp32"
+CONFIG_IDF_TARGET_ESP32=y
+CONFIG_IDF_FIRMWARE_CHIP_ID=0x0000
+
+#
+# Build type
+#
+CONFIG_APP_BUILD_TYPE_APP_2NDBOOT=y
+# CONFIG_APP_BUILD_TYPE_ELF_RAM is not set
+CONFIG_APP_BUILD_GENERATE_BINARIES=y
+CONFIG_APP_BUILD_BOOTLOADER=y
+CONFIG_APP_BUILD_USE_FLASH_SECTIONS=y
+# CONFIG_APP_REPRODUCIBLE_BUILD is not set
+# CONFIG_APP_NO_BLOBS is not set
+# CONFIG_APP_COMPATIBLE_PRE_V2_1_BOOTLOADERS is not set
+# CONFIG_APP_COMPATIBLE_PRE_V3_1_BOOTLOADERS is not set
+# end of Build type
+
+#
+# Bootloader config
+#
+CONFIG_BOOTLOADER_OFFSET_IN_FLASH=0x1000
+CONFIG_BOOTLOADER_COMPILER_OPTIMIZATION_SIZE=y
+# CONFIG_BOOTLOADER_COMPILER_OPTIMIZATION_DEBUG is not set
+# CONFIG_BOOTLOADER_COMPILER_OPTIMIZATION_PERF is not set
+# CONFIG_BOOTLOADER_COMPILER_OPTIMIZATION_NONE is not set
+# CONFIG_BOOTLOADER_LOG_LEVEL_NONE is not set
+# CONFIG_BOOTLOADER_LOG_LEVEL_ERROR is not set
+CONFIG_BOOTLOADER_LOG_LEVEL_WARN=y
+# CONFIG_BOOTLOADER_LOG_LEVEL_INFO is not set
+# CONFIG_BOOTLOADER_LOG_LEVEL_DEBUG is not set
+# CONFIG_BOOTLOADER_LOG_LEVEL_VERBOSE is not set
+CONFIG_BOOTLOADER_LOG_LEVEL=2
+
+#
+# Serial Flash Configurations
+#
+# CONFIG_BOOTLOADER_FLASH_DC_AWARE is not set
+CONFIG_BOOTLOADER_FLASH_XMC_SUPPORT=y
+# end of Serial Flash Configurations
+
+# CONFIG_BOOTLOADER_VDDSDIO_BOOST_1_8V is not set
+CONFIG_BOOTLOADER_VDDSDIO_BOOST_1_9V=y
+# CONFIG_BOOTLOADER_FACTORY_RESET is not set
+# CONFIG_BOOTLOADER_APP_TEST is not set
+CONFIG_BOOTLOADER_REGION_PROTECTION_ENABLE=y
+CONFIG_BOOTLOADER_WDT_ENABLE=y
+# CONFIG_BOOTLOADER_WDT_DISABLE_IN_USER_CODE is not set
+CONFIG_BOOTLOADER_WDT_TIME_MS=9000
+# CONFIG_BOOTLOADER_APP_ROLLBACK_ENABLE is not set
+# CONFIG_BOOTLOADER_SKIP_VALIDATE_IN_DEEP_SLEEP is not set
+# CONFIG_BOOTLOADER_SKIP_VALIDATE_ON_POWER_ON is not set
+# CONFIG_BOOTLOADER_SKIP_VALIDATE_ALWAYS is not set
+CONFIG_BOOTLOADER_RESERVE_RTC_SIZE=0
+# CONFIG_BOOTLOADER_CUSTOM_RESERVE_RTC is not set
+# end of Bootloader config
+
+#
+# Security features
+#
+CONFIG_SECURE_BOOT_V1_SUPPORTED=y
+# CONFIG_SECURE_SIGNED_APPS_NO_SECURE_BOOT is not set
+# CONFIG_SECURE_BOOT is not set
+# CONFIG_SECURE_FLASH_ENC_ENABLED is not set
+# end of Security features
+
+#
+# Application manager
+#
+CONFIG_APP_COMPILE_TIME_DATE=y
+# CONFIG_APP_EXCLUDE_PROJECT_VER_VAR is not set
+# CONFIG_APP_EXCLUDE_PROJECT_NAME_VAR is not set
+# CONFIG_APP_PROJECT_VER_FROM_CONFIG is not set
+CONFIG_APP_RETRIEVE_LEN_ELF_SHA=16
+# end of Application manager
+
+CONFIG_ESP_ROM_HAS_CRC_LE=y
+CONFIG_ESP_ROM_HAS_CRC_BE=y
+CONFIG_ESP_ROM_HAS_MZ_CRC32=y
+CONFIG_ESP_ROM_HAS_JPEG_DECODE=y
+CONFIG_ESP_ROM_NEEDS_SWSETUP_WORKAROUND=y
+
+#
+# Serial flasher config
+#
+# CONFIG_ESPTOOLPY_NO_STUB is not set
+# CONFIG_ESPTOOLPY_FLASHMODE_QIO is not set
+# CONFIG_ESPTOOLPY_FLASHMODE_QOUT is not set
+CONFIG_ESPTOOLPY_FLASHMODE_DIO=y
+# CONFIG_ESPTOOLPY_FLASHMODE_DOUT is not set
+CONFIG_ESPTOOLPY_FLASH_SAMPLE_MODE_STR=y
+CONFIG_ESPTOOLPY_FLASHMODE="dio"
+# CONFIG_ESPTOOLPY_FLASHFREQ_80M is not set
+CONFIG_ESPTOOLPY_FLASHFREQ_40M=y
+# CONFIG_ESPTOOLPY_FLASHFREQ_26M is not set
+# CONFIG_ESPTOOLPY_FLASHFREQ_20M is not set
+CONFIG_ESPTOOLPY_FLASHFREQ="40m"
+# CONFIG_ESPTOOLPY_FLASHSIZE_1MB is not set
+# CONFIG_ESPTOOLPY_FLASHSIZE_2MB is not set
+# CONFIG_ESPTOOLPY_FLASHSIZE_4MB is not set
+CONFIG_ESPTOOLPY_FLASHSIZE_8MB=y
+# CONFIG_ESPTOOLPY_FLASHSIZE_16MB is not set
+# CONFIG_ESPTOOLPY_FLASHSIZE_32MB is not set
+# CONFIG_ESPTOOLPY_FLASHSIZE_64MB is not set
+# CONFIG_ESPTOOLPY_FLASHSIZE_128MB is not set
+CONFIG_ESPTOOLPY_FLASHSIZE="8MB"
+# CONFIG_ESPTOOLPY_HEADER_FLASHSIZE_UPDATE is not set
+CONFIG_ESPTOOLPY_BEFORE_RESET=y
+# CONFIG_ESPTOOLPY_BEFORE_NORESET is not set
+CONFIG_ESPTOOLPY_BEFORE="default_reset"
+CONFIG_ESPTOOLPY_AFTER_RESET=y
+# CONFIG_ESPTOOLPY_AFTER_NORESET is not set
+CONFIG_ESPTOOLPY_AFTER="hard_reset"
+CONFIG_ESPTOOLPY_MONITOR_BAUD=115200
+# end of Serial flasher config
+
+#
+# Partition Table
+#
+# CONFIG_PARTITION_TABLE_SINGLE_APP is not set
+# CONFIG_PARTITION_TABLE_SINGLE_APP_LARGE is not set
+# CONFIG_PARTITION_TABLE_TWO_OTA is not set
+CONFIG_PARTITION_TABLE_CUSTOM=y
+CONFIG_PARTITION_TABLE_CUSTOM_FILENAME="QJ500_7C_partitions_two_ota.csv"
+CONFIG_PARTITION_TABLE_FILENAME="QJ500_7C_partitions_two_ota.csv"
+CONFIG_PARTITION_TABLE_OFFSET=0xA000
+CONFIG_PARTITION_TABLE_MD5=y
+# end of Partition Table
+
+#
+# Example Configuration
+#
+CONFIG_EXAMPLE_FIRMWARE_UPGRADE_URL="http://192.168.137.1:3200/Qj500-7C.bin"
+# CONFIG_EXAMPLE_USE_CERT_BUNDLE is not set
+CONFIG_EXAMPLE_SKIP_COMMON_NAME_CHECK=y
+# CONFIG_EXAMPLE_FIRMWARE_UPGRADE_BIND_IF is not set
+# end of Example Configuration
+
+#
+# Example Connection Configuration
+#
+CONFIG_ENV_GPIO_RANGE_MIN=0
+CONFIG_ENV_GPIO_RANGE_MAX=39
+CONFIG_ENV_GPIO_IN_RANGE_MAX=39
+CONFIG_ENV_GPIO_OUT_RANGE_MAX=33
+CONFIG_EXAMPLE_CONNECT_WIFI=y
+# CONFIG_EXAMPLE_WIFI_SSID_PWD_FROM_STDIN is not set
+CONFIG_EXAMPLE_PROVIDE_WIFI_CONSOLE_CMD=y
+CONFIG_EXAMPLE_WIFI_SSID="myssid"
+CONFIG_EXAMPLE_WIFI_PASSWORD="mypassword"
+CONFIG_EXAMPLE_WIFI_CONN_MAX_RETRY=6
+# CONFIG_EXAMPLE_WIFI_SCAN_METHOD_FAST is not set
+CONFIG_EXAMPLE_WIFI_SCAN_METHOD_ALL_CHANNEL=y
+
+#
+# WiFi Scan threshold
+#
+CONFIG_EXAMPLE_WIFI_SCAN_RSSI_THRESHOLD=-127
+CONFIG_EXAMPLE_WIFI_AUTH_OPEN=y
+# CONFIG_EXAMPLE_WIFI_AUTH_WEP is not set
+# CONFIG_EXAMPLE_WIFI_AUTH_WPA_PSK is not set
+# CONFIG_EXAMPLE_WIFI_AUTH_WPA2_PSK is not set
+# CONFIG_EXAMPLE_WIFI_AUTH_WPA_WPA2_PSK is not set
+# CONFIG_EXAMPLE_WIFI_AUTH_WPA2_ENTERPRISE is not set
+# CONFIG_EXAMPLE_WIFI_AUTH_WPA3_PSK is not set
+# CONFIG_EXAMPLE_WIFI_AUTH_WPA2_WPA3_PSK is not set
+# CONFIG_EXAMPLE_WIFI_AUTH_WAPI_PSK is not set
+# end of WiFi Scan threshold
+
+CONFIG_EXAMPLE_WIFI_CONNECT_AP_BY_SIGNAL=y
+# CONFIG_EXAMPLE_WIFI_CONNECT_AP_BY_SECURITY is not set
+# CONFIG_EXAMPLE_CONNECT_ETHERNET is not set
+CONFIG_EXAMPLE_CONNECT_IPV6=y
+CONFIG_EXAMPLE_CONNECT_IPV6_PREF_LOCAL_LINK=y
+# CONFIG_EXAMPLE_CONNECT_IPV6_PREF_GLOBAL is not set
+# CONFIG_EXAMPLE_CONNECT_IPV6_PREF_SITE_LOCAL is not set
+# CONFIG_EXAMPLE_CONNECT_IPV6_PREF_UNIQUE_LOCAL is not set
+# end of Example Connection Configuration
+
+#
+# Compiler options
+#
+CONFIG_COMPILER_OPTIMIZATION_DEFAULT=y
+# CONFIG_COMPILER_OPTIMIZATION_SIZE is not set
+# CONFIG_COMPILER_OPTIMIZATION_PERF is not set
+# CONFIG_COMPILER_OPTIMIZATION_NONE is not set
+CONFIG_COMPILER_OPTIMIZATION_ASSERTIONS_ENABLE=y
+# CONFIG_COMPILER_OPTIMIZATION_ASSERTIONS_SILENT is not set
+# CONFIG_COMPILER_OPTIMIZATION_ASSERTIONS_DISABLE is not set
+CONFIG_COMPILER_FLOAT_LIB_FROM_GCCLIB=y
+CONFIG_COMPILER_OPTIMIZATION_ASSERTION_LEVEL=2
+# CONFIG_COMPILER_OPTIMIZATION_CHECKS_SILENT is not set
+CONFIG_COMPILER_HIDE_PATHS_MACROS=y
+# CONFIG_COMPILER_CXX_EXCEPTIONS is not set
+# CONFIG_COMPILER_CXX_RTTI is not set
+CONFIG_COMPILER_STACK_CHECK_MODE_NONE=y
+# CONFIG_COMPILER_STACK_CHECK_MODE_NORM is not set
+# CONFIG_COMPILER_STACK_CHECK_MODE_STRONG is not set
+# CONFIG_COMPILER_STACK_CHECK_MODE_ALL is not set
+# CONFIG_COMPILER_WARN_WRITE_STRINGS is not set
+# CONFIG_COMPILER_DUMP_RTL_FILES is not set
+# end of Compiler options
+
+#
+# Component config
+#
+
+#
+# Application Level Tracing
+#
+# CONFIG_APPTRACE_DEST_JTAG is not set
+CONFIG_APPTRACE_DEST_NONE=y
+# CONFIG_APPTRACE_DEST_UART1 is not set
+# CONFIG_APPTRACE_DEST_UART2 is not set
+CONFIG_APPTRACE_DEST_UART_NONE=y
+CONFIG_APPTRACE_UART_TASK_PRIO=1
+CONFIG_APPTRACE_LOCK_ENABLE=y
+# end of Application Level Tracing
+
+#
+# Bluetooth
+#
+CONFIG_BT_ENABLED=y
+CONFIG_BT_BLUEDROID_ENABLED=y
+# CONFIG_BT_NIMBLE_ENABLED is not set
+# CONFIG_BT_CONTROLLER_ONLY is not set
+CONFIG_BT_CONTROLLER_ENABLED=y
+# CONFIG_BT_CONTROLLER_DISABLED is not set
+
+#
+# Bluedroid Options
+#
+CONFIG_BT_BTC_TASK_STACK_SIZE=3072
+CONFIG_BT_BLUEDROID_PINNED_TO_CORE_0=y
+# CONFIG_BT_BLUEDROID_PINNED_TO_CORE_1 is not set
+CONFIG_BT_BLUEDROID_PINNED_TO_CORE=0
+CONFIG_BT_BTU_TASK_STACK_SIZE=4352
+# CONFIG_BT_BLUEDROID_MEM_DEBUG is not set
+CONFIG_BT_CLASSIC_ENABLED=y
+# CONFIG_BT_CLASSIC_BQB_ENABLED is not set
+# CONFIG_BT_A2DP_ENABLE is not set
+# CONFIG_BT_SPP_ENABLED is not set
+# CONFIG_BT_L2CAP_ENABLED is not set
+CONFIG_BT_HFP_ENABLE=y
+CONFIG_BT_HFP_CLIENT_ENABLE=y
+CONFIG_BT_HFP_AG_ENABLE=y
+CONFIG_BT_HFP_AUDIO_DATA_PATH_PCM=y
+# CONFIG_BT_HFP_AUDIO_DATA_PATH_HCI is not set
+# CONFIG_BT_HID_ENABLED is not set
+CONFIG_BT_SSP_ENABLED=y
+CONFIG_BT_BLE_ENABLED=y
+CONFIG_BT_GATTS_ENABLE=y
+# CONFIG_BT_GATTS_PPCP_CHAR_GAP is not set
+# CONFIG_BT_BLE_BLUFI_ENABLE is not set
+CONFIG_BT_GATT_MAX_SR_PROFILES=8
+CONFIG_BT_GATT_MAX_SR_ATTRIBUTES=100
+# CONFIG_BT_GATTS_SEND_SERVICE_CHANGE_MANUAL is not set
+CONFIG_BT_GATTS_SEND_SERVICE_CHANGE_AUTO=y
+CONFIG_BT_GATTS_SEND_SERVICE_CHANGE_MODE=0
+# CONFIG_BT_GATTS_ROBUST_CACHING_ENABLED is not set
+# CONFIG_BT_GATTS_DEVICE_NAME_WRITABLE is not set
+# CONFIG_BT_GATTS_APPEARANCE_WRITABLE is not set
+CONFIG_BT_GATTC_ENABLE=y
+CONFIG_BT_GATTC_MAX_CACHE_CHAR=40
+CONFIG_BT_GATTC_NOTIF_REG_MAX=5
+# CONFIG_BT_GATTC_CACHE_NVS_FLASH is not set
+CONFIG_BT_GATTC_CONNECT_RETRY_COUNT=3
+CONFIG_BT_BLE_SMP_ENABLE=y
+# CONFIG_BT_SMP_SLAVE_CON_PARAMS_UPD_ENABLE is not set
+# CONFIG_BT_STACK_NO_LOG is not set
+
+#
+# BT DEBUG LOG LEVEL
+#
+# CONFIG_BT_LOG_HCI_TRACE_LEVEL_NONE is not set
+# CONFIG_BT_LOG_HCI_TRACE_LEVEL_ERROR is not set
+CONFIG_BT_LOG_HCI_TRACE_LEVEL_WARNING=y
+# CONFIG_BT_LOG_HCI_TRACE_LEVEL_API is not set
+# CONFIG_BT_LOG_HCI_TRACE_LEVEL_EVENT is not set
+# CONFIG_BT_LOG_HCI_TRACE_LEVEL_DEBUG is not set
+# CONFIG_BT_LOG_HCI_TRACE_LEVEL_VERBOSE is not set
+CONFIG_BT_LOG_HCI_TRACE_LEVEL=2
+# CONFIG_BT_LOG_BTM_TRACE_LEVEL_NONE is not set
+# CONFIG_BT_LOG_BTM_TRACE_LEVEL_ERROR is not set
+CONFIG_BT_LOG_BTM_TRACE_LEVEL_WARNING=y
+# CONFIG_BT_LOG_BTM_TRACE_LEVEL_API is not set
+# CONFIG_BT_LOG_BTM_TRACE_LEVEL_EVENT is not set
+# CONFIG_BT_LOG_BTM_TRACE_LEVEL_DEBUG is not set
+# CONFIG_BT_LOG_BTM_TRACE_LEVEL_VERBOSE is not set
+CONFIG_BT_LOG_BTM_TRACE_LEVEL=2
+# CONFIG_BT_LOG_L2CAP_TRACE_LEVEL_NONE is not set
+# CONFIG_BT_LOG_L2CAP_TRACE_LEVEL_ERROR is not set
+CONFIG_BT_LOG_L2CAP_TRACE_LEVEL_WARNING=y
+# CONFIG_BT_LOG_L2CAP_TRACE_LEVEL_API is not set
+# CONFIG_BT_LOG_L2CAP_TRACE_LEVEL_EVENT is not set
+# CONFIG_BT_LOG_L2CAP_TRACE_LEVEL_DEBUG is not set
+# CONFIG_BT_LOG_L2CAP_TRACE_LEVEL_VERBOSE is not set
+CONFIG_BT_LOG_L2CAP_TRACE_LEVEL=2
+# CONFIG_BT_LOG_RFCOMM_TRACE_LEVEL_NONE is not set
+# CONFIG_BT_LOG_RFCOMM_TRACE_LEVEL_ERROR is not set
+CONFIG_BT_LOG_RFCOMM_TRACE_LEVEL_WARNING=y
+# CONFIG_BT_LOG_RFCOMM_TRACE_LEVEL_API is not set
+# CONFIG_BT_LOG_RFCOMM_TRACE_LEVEL_EVENT is not set
+# CONFIG_BT_LOG_RFCOMM_TRACE_LEVEL_DEBUG is not set
+# CONFIG_BT_LOG_RFCOMM_TRACE_LEVEL_VERBOSE is not set
+CONFIG_BT_LOG_RFCOMM_TRACE_LEVEL=2
+# CONFIG_BT_LOG_SDP_TRACE_LEVEL_NONE is not set
+# CONFIG_BT_LOG_SDP_TRACE_LEVEL_ERROR is not set
+CONFIG_BT_LOG_SDP_TRACE_LEVEL_WARNING=y
+# CONFIG_BT_LOG_SDP_TRACE_LEVEL_API is not set
+# CONFIG_BT_LOG_SDP_TRACE_LEVEL_EVENT is not set
+# CONFIG_BT_LOG_SDP_TRACE_LEVEL_DEBUG is not set
+# CONFIG_BT_LOG_SDP_TRACE_LEVEL_VERBOSE is not set
+CONFIG_BT_LOG_SDP_TRACE_LEVEL=2
+# CONFIG_BT_LOG_GAP_TRACE_LEVEL_NONE is not set
+# CONFIG_BT_LOG_GAP_TRACE_LEVEL_ERROR is not set
+CONFIG_BT_LOG_GAP_TRACE_LEVEL_WARNING=y
+# CONFIG_BT_LOG_GAP_TRACE_LEVEL_API is not set
+# CONFIG_BT_LOG_GAP_TRACE_LEVEL_EVENT is not set
+# CONFIG_BT_LOG_GAP_TRACE_LEVEL_DEBUG is not set
+# CONFIG_BT_LOG_GAP_TRACE_LEVEL_VERBOSE is not set
+CONFIG_BT_LOG_GAP_TRACE_LEVEL=2
+# CONFIG_BT_LOG_BNEP_TRACE_LEVEL_NONE is not set
+# CONFIG_BT_LOG_BNEP_TRACE_LEVEL_ERROR is not set
+CONFIG_BT_LOG_BNEP_TRACE_LEVEL_WARNING=y
+# CONFIG_BT_LOG_BNEP_TRACE_LEVEL_API is not set
+# CONFIG_BT_LOG_BNEP_TRACE_LEVEL_EVENT is not set
+# CONFIG_BT_LOG_BNEP_TRACE_LEVEL_DEBUG is not set
+# CONFIG_BT_LOG_BNEP_TRACE_LEVEL_VERBOSE is not set
+CONFIG_BT_LOG_BNEP_TRACE_LEVEL=2
+# CONFIG_BT_LOG_PAN_TRACE_LEVEL_NONE is not set
+# CONFIG_BT_LOG_PAN_TRACE_LEVEL_ERROR is not set
+CONFIG_BT_LOG_PAN_TRACE_LEVEL_WARNING=y
+# CONFIG_BT_LOG_PAN_TRACE_LEVEL_API is not set
+# CONFIG_BT_LOG_PAN_TRACE_LEVEL_EVENT is not set
+# CONFIG_BT_LOG_PAN_TRACE_LEVEL_DEBUG is not set
+# CONFIG_BT_LOG_PAN_TRACE_LEVEL_VERBOSE is not set
+CONFIG_BT_LOG_PAN_TRACE_LEVEL=2
+# CONFIG_BT_LOG_A2D_TRACE_LEVEL_NONE is not set
+# CONFIG_BT_LOG_A2D_TRACE_LEVEL_ERROR is not set
+CONFIG_BT_LOG_A2D_TRACE_LEVEL_WARNING=y
+# CONFIG_BT_LOG_A2D_TRACE_LEVEL_API is not set
+# CONFIG_BT_LOG_A2D_TRACE_LEVEL_EVENT is not set
+# CONFIG_BT_LOG_A2D_TRACE_LEVEL_DEBUG is not set
+# CONFIG_BT_LOG_A2D_TRACE_LEVEL_VERBOSE is not set
+CONFIG_BT_LOG_A2D_TRACE_LEVEL=2
+# CONFIG_BT_LOG_AVDT_TRACE_LEVEL_NONE is not set
+# CONFIG_BT_LOG_AVDT_TRACE_LEVEL_ERROR is not set
+CONFIG_BT_LOG_AVDT_TRACE_LEVEL_WARNING=y
+# CONFIG_BT_LOG_AVDT_TRACE_LEVEL_API is not set
+# CONFIG_BT_LOG_AVDT_TRACE_LEVEL_EVENT is not set
+# CONFIG_BT_LOG_AVDT_TRACE_LEVEL_DEBUG is not set
+# CONFIG_BT_LOG_AVDT_TRACE_LEVEL_VERBOSE is not set
+CONFIG_BT_LOG_AVDT_TRACE_LEVEL=2
+# CONFIG_BT_LOG_AVCT_TRACE_LEVEL_NONE is not set
+# CONFIG_BT_LOG_AVCT_TRACE_LEVEL_ERROR is not set
+CONFIG_BT_LOG_AVCT_TRACE_LEVEL_WARNING=y
+# CONFIG_BT_LOG_AVCT_TRACE_LEVEL_API is not set
+# CONFIG_BT_LOG_AVCT_TRACE_LEVEL_EVENT is not set
+# CONFIG_BT_LOG_AVCT_TRACE_LEVEL_DEBUG is not set
+# CONFIG_BT_LOG_AVCT_TRACE_LEVEL_VERBOSE is not set
+CONFIG_BT_LOG_AVCT_TRACE_LEVEL=2
+# CONFIG_BT_LOG_AVRC_TRACE_LEVEL_NONE is not set
+# CONFIG_BT_LOG_AVRC_TRACE_LEVEL_ERROR is not set
+CONFIG_BT_LOG_AVRC_TRACE_LEVEL_WARNING=y
+# CONFIG_BT_LOG_AVRC_TRACE_LEVEL_API is not set
+# CONFIG_BT_LOG_AVRC_TRACE_LEVEL_EVENT is not set
+# CONFIG_BT_LOG_AVRC_TRACE_LEVEL_DEBUG is not set
+# CONFIG_BT_LOG_AVRC_TRACE_LEVEL_VERBOSE is not set
+CONFIG_BT_LOG_AVRC_TRACE_LEVEL=2
+# CONFIG_BT_LOG_MCA_TRACE_LEVEL_NONE is not set
+# CONFIG_BT_LOG_MCA_TRACE_LEVEL_ERROR is not set
+CONFIG_BT_LOG_MCA_TRACE_LEVEL_WARNING=y
+# CONFIG_BT_LOG_MCA_TRACE_LEVEL_API is not set
+# CONFIG_BT_LOG_MCA_TRACE_LEVEL_EVENT is not set
+# CONFIG_BT_LOG_MCA_TRACE_LEVEL_DEBUG is not set
+# CONFIG_BT_LOG_MCA_TRACE_LEVEL_VERBOSE is not set
+CONFIG_BT_LOG_MCA_TRACE_LEVEL=2
+# CONFIG_BT_LOG_HID_TRACE_LEVEL_NONE is not set
+# CONFIG_BT_LOG_HID_TRACE_LEVEL_ERROR is not set
+CONFIG_BT_LOG_HID_TRACE_LEVEL_WARNING=y
+# CONFIG_BT_LOG_HID_TRACE_LEVEL_API is not set
+# CONFIG_BT_LOG_HID_TRACE_LEVEL_EVENT is not set
+# CONFIG_BT_LOG_HID_TRACE_LEVEL_DEBUG is not set
+# CONFIG_BT_LOG_HID_TRACE_LEVEL_VERBOSE is not set
+CONFIG_BT_LOG_HID_TRACE_LEVEL=2
+# CONFIG_BT_LOG_APPL_TRACE_LEVEL_NONE is not set
+# CONFIG_BT_LOG_APPL_TRACE_LEVEL_ERROR is not set
+CONFIG_BT_LOG_APPL_TRACE_LEVEL_WARNING=y
+# CONFIG_BT_LOG_APPL_TRACE_LEVEL_API is not set
+# CONFIG_BT_LOG_APPL_TRACE_LEVEL_EVENT is not set
+# CONFIG_BT_LOG_APPL_TRACE_LEVEL_DEBUG is not set
+# CONFIG_BT_LOG_APPL_TRACE_LEVEL_VERBOSE is not set
+CONFIG_BT_LOG_APPL_TRACE_LEVEL=2
+# CONFIG_BT_LOG_GATT_TRACE_LEVEL_NONE is not set
+# CONFIG_BT_LOG_GATT_TRACE_LEVEL_ERROR is not set
+CONFIG_BT_LOG_GATT_TRACE_LEVEL_WARNING=y
+# CONFIG_BT_LOG_GATT_TRACE_LEVEL_API is not set
+# CONFIG_BT_LOG_GATT_TRACE_LEVEL_EVENT is not set
+# CONFIG_BT_LOG_GATT_TRACE_LEVEL_DEBUG is not set
+# CONFIG_BT_LOG_GATT_TRACE_LEVEL_VERBOSE is not set
+CONFIG_BT_LOG_GATT_TRACE_LEVEL=2
+# CONFIG_BT_LOG_SMP_TRACE_LEVEL_NONE is not set
+# CONFIG_BT_LOG_SMP_TRACE_LEVEL_ERROR is not set
+CONFIG_BT_LOG_SMP_TRACE_LEVEL_WARNING=y
+# CONFIG_BT_LOG_SMP_TRACE_LEVEL_API is not set
+# CONFIG_BT_LOG_SMP_TRACE_LEVEL_EVENT is not set
+# CONFIG_BT_LOG_SMP_TRACE_LEVEL_DEBUG is not set
+# CONFIG_BT_LOG_SMP_TRACE_LEVEL_VERBOSE is not set
+CONFIG_BT_LOG_SMP_TRACE_LEVEL=2
+# CONFIG_BT_LOG_BTIF_TRACE_LEVEL_NONE is not set
+# CONFIG_BT_LOG_BTIF_TRACE_LEVEL_ERROR is not set
+CONFIG_BT_LOG_BTIF_TRACE_LEVEL_WARNING=y
+# CONFIG_BT_LOG_BTIF_TRACE_LEVEL_API is not set
+# CONFIG_BT_LOG_BTIF_TRACE_LEVEL_EVENT is not set
+# CONFIG_BT_LOG_BTIF_TRACE_LEVEL_DEBUG is not set
+# CONFIG_BT_LOG_BTIF_TRACE_LEVEL_VERBOSE is not set
+CONFIG_BT_LOG_BTIF_TRACE_LEVEL=2
+# CONFIG_BT_LOG_BTC_TRACE_LEVEL_NONE is not set
+# CONFIG_BT_LOG_BTC_TRACE_LEVEL_ERROR is not set
+CONFIG_BT_LOG_BTC_TRACE_LEVEL_WARNING=y
+# CONFIG_BT_LOG_BTC_TRACE_LEVEL_API is not set
+# CONFIG_BT_LOG_BTC_TRACE_LEVEL_EVENT is not set
+# CONFIG_BT_LOG_BTC_TRACE_LEVEL_DEBUG is not set
+# CONFIG_BT_LOG_BTC_TRACE_LEVEL_VERBOSE is not set
+CONFIG_BT_LOG_BTC_TRACE_LEVEL=2
+# CONFIG_BT_LOG_OSI_TRACE_LEVEL_NONE is not set
+# CONFIG_BT_LOG_OSI_TRACE_LEVEL_ERROR is not set
+CONFIG_BT_LOG_OSI_TRACE_LEVEL_WARNING=y
+# CONFIG_BT_LOG_OSI_TRACE_LEVEL_API is not set
+# CONFIG_BT_LOG_OSI_TRACE_LEVEL_EVENT is not set
+# CONFIG_BT_LOG_OSI_TRACE_LEVEL_DEBUG is not set
+# CONFIG_BT_LOG_OSI_TRACE_LEVEL_VERBOSE is not set
+CONFIG_BT_LOG_OSI_TRACE_LEVEL=2
+# CONFIG_BT_LOG_BLUFI_TRACE_LEVEL_NONE is not set
+# CONFIG_BT_LOG_BLUFI_TRACE_LEVEL_ERROR is not set
+CONFIG_BT_LOG_BLUFI_TRACE_LEVEL_WARNING=y
+# CONFIG_BT_LOG_BLUFI_TRACE_LEVEL_API is not set
+# CONFIG_BT_LOG_BLUFI_TRACE_LEVEL_EVENT is not set
+# CONFIG_BT_LOG_BLUFI_TRACE_LEVEL_DEBUG is not set
+# CONFIG_BT_LOG_BLUFI_TRACE_LEVEL_VERBOSE is not set
+CONFIG_BT_LOG_BLUFI_TRACE_LEVEL=2
+# end of BT DEBUG LOG LEVEL
+
+CONFIG_BT_ACL_CONNECTIONS=4
+CONFIG_BT_MULTI_CONNECTION_ENBALE=y
+# CONFIG_BT_ALLOCATION_FROM_SPIRAM_FIRST is not set
+# CONFIG_BT_BLE_DYNAMIC_ENV_MEMORY is not set
+# CONFIG_BT_BLE_HOST_QUEUE_CONG_CHECK is not set
+CONFIG_BT_SMP_ENABLE=y
+CONFIG_BT_SMP_MAX_BONDS=15
+# CONFIG_BT_BLE_ACT_SCAN_REP_ADV_SCAN is not set
+CONFIG_BT_BLE_ESTAB_LINK_CONN_TOUT=30
+CONFIG_BT_MAX_DEVICE_NAME_LEN=32
+# CONFIG_BT_BLE_RPA_SUPPORTED is not set
+CONFIG_BT_BLE_RPA_TIMEOUT=900
+# CONFIG_BT_BLE_HIGH_DUTY_ADV_INTERVAL is not set
+# end of Bluedroid Options
+
+#
+# Controller Options
+#
+# CONFIG_BTDM_CTRL_MODE_BLE_ONLY is not set
+# CONFIG_BTDM_CTRL_MODE_BR_EDR_ONLY is not set
+CONFIG_BTDM_CTRL_MODE_BTDM=y
+CONFIG_BTDM_CTRL_BLE_MAX_CONN=3
+CONFIG_BTDM_CTRL_BR_EDR_MAX_ACL_CONN=2
+CONFIG_BTDM_CTRL_BR_EDR_MAX_SYNC_CONN=2
+# CONFIG_BTDM_CTRL_BR_EDR_SCO_DATA_PATH_HCI is not set
+CONFIG_BTDM_CTRL_BR_EDR_SCO_DATA_PATH_PCM=y
+CONFIG_BTDM_CTRL_BR_EDR_SCO_DATA_PATH_EFF=1
+CONFIG_BTDM_CTRL_PCM_ROLE_EDGE_CONFIG=y
+CONFIG_BTDM_CTRL_PCM_ROLE_MASTER=y
+# CONFIG_BTDM_CTRL_PCM_ROLE_SLAVE is not set
+CONFIG_BTDM_CTRL_PCM_POLAR_FALLING_EDGE=y
+# CONFIG_BTDM_CTRL_PCM_POLAR_RISING_EDGE is not set
+CONFIG_BTDM_CTRL_PCM_ROLE_EFF=0
+CONFIG_BTDM_CTRL_PCM_POLAR_EFF=0
+# CONFIG_BTDM_CTRL_AUTO_LATENCY is not set
+CONFIG_BTDM_CTRL_LEGACY_AUTH_VENDOR_EVT=y
+CONFIG_BTDM_CTRL_LEGACY_AUTH_VENDOR_EVT_EFF=y
+CONFIG_BTDM_CTRL_BLE_MAX_CONN_EFF=3
+CONFIG_BTDM_CTRL_BR_EDR_MAX_ACL_CONN_EFF=2
+CONFIG_BTDM_CTRL_BR_EDR_MAX_SYNC_CONN_EFF=2
+CONFIG_BTDM_CTRL_PINNED_TO_CORE_0=y
+# CONFIG_BTDM_CTRL_PINNED_TO_CORE_1 is not set
+CONFIG_BTDM_CTRL_PINNED_TO_CORE=0
+CONFIG_BTDM_CTRL_HCI_MODE_VHCI=y
+# CONFIG_BTDM_CTRL_HCI_MODE_UART_H4 is not set
+
+#
+# MODEM SLEEP Options
+#
+CONFIG_BTDM_CTRL_MODEM_SLEEP=y
+CONFIG_BTDM_CTRL_MODEM_SLEEP_MODE_ORIG=y
+# CONFIG_BTDM_CTRL_MODEM_SLEEP_MODE_EVED is not set
+CONFIG_BTDM_CTRL_LPCLK_SEL_MAIN_XTAL=y
+# end of MODEM SLEEP Options
+
+CONFIG_BTDM_BLE_DEFAULT_SCA_250PPM=y
+CONFIG_BTDM_BLE_SLEEP_CLOCK_ACCURACY_INDEX_EFF=1
+CONFIG_BTDM_BLE_SCAN_DUPL=y
+CONFIG_BTDM_SCAN_DUPL_TYPE_DEVICE=y
+# CONFIG_BTDM_SCAN_DUPL_TYPE_DATA is not set
+# CONFIG_BTDM_SCAN_DUPL_TYPE_DATA_DEVICE is not set
+CONFIG_BTDM_SCAN_DUPL_TYPE=0
+CONFIG_BTDM_SCAN_DUPL_CACHE_SIZE=100
+CONFIG_BTDM_SCAN_DUPL_CACHE_REFRESH_PERIOD=0
+# CONFIG_BTDM_BLE_MESH_SCAN_DUPL_EN is not set
+CONFIG_BTDM_CTRL_FULL_SCAN_SUPPORTED=y
+CONFIG_BTDM_BLE_ADV_REPORT_FLOW_CTRL_SUPP=y
+CONFIG_BTDM_BLE_ADV_REPORT_FLOW_CTRL_NUM=100
+CONFIG_BTDM_BLE_ADV_REPORT_DISCARD_THRSHOLD=20
+CONFIG_BTDM_RESERVE_DRAM=0xdb5c
+CONFIG_BTDM_CTRL_HLI=y
+# end of Controller Options
+# end of Bluetooth
+
+# CONFIG_BLE_MESH is not set
+
+#
+# Driver Configurations
+#
+
+#
+# Legacy ADC Configuration
+#
+CONFIG_ADC_DISABLE_DAC=y
+# CONFIG_ADC_SUPPRESS_DEPRECATE_WARN is not set
+
+#
+# Legacy ADC Calibration Configuration
+#
+CONFIG_ADC_CAL_EFUSE_TP_ENABLE=y
+CONFIG_ADC_CAL_EFUSE_VREF_ENABLE=y
+CONFIG_ADC_CAL_LUT_ENABLE=y
+# CONFIG_ADC_CALI_SUPPRESS_DEPRECATE_WARN is not set
+# end of Legacy ADC Calibration Configuration
+# end of Legacy ADC Configuration
+
+#
+# SPI Configuration
+#
+# CONFIG_SPI_MASTER_IN_IRAM is not set
+CONFIG_SPI_MASTER_ISR_IN_IRAM=y
+# CONFIG_SPI_SLAVE_IN_IRAM is not set
+CONFIG_SPI_SLAVE_ISR_IN_IRAM=y
+# end of SPI Configuration
+
+#
+# TWAI Configuration
+#
+# CONFIG_TWAI_ISR_IN_IRAM is not set
+CONFIG_TWAI_ERRATA_FIX_BUS_OFF_REC=y
+CONFIG_TWAI_ERRATA_FIX_TX_INTR_LOST=y
+CONFIG_TWAI_ERRATA_FIX_RX_FRAME_INVALID=y
+CONFIG_TWAI_ERRATA_FIX_RX_FIFO_CORRUPT=y
+CONFIG_TWAI_ERRATA_FIX_LISTEN_ONLY_DOM=y
+# end of TWAI Configuration
+
+#
+# UART Configuration
+#
+# CONFIG_UART_ISR_IN_IRAM is not set
+# end of UART Configuration
+
+#
+# GPIO Configuration
+#
+# CONFIG_GPIO_ESP32_SUPPORT_SWITCH_SLP_PULL is not set
+# CONFIG_GPIO_CTRL_FUNC_IN_IRAM is not set
+# end of GPIO Configuration
+
+#
+# Sigma Delta Modulator Configuration
+#
+# CONFIG_SDM_CTRL_FUNC_IN_IRAM is not set
+# CONFIG_SDM_SUPPRESS_DEPRECATE_WARN is not set
+# CONFIG_SDM_ENABLE_DEBUG_LOG is not set
+# end of Sigma Delta Modulator Configuration
+
+#
+# GPTimer Configuration
+#
+# CONFIG_GPTIMER_CTRL_FUNC_IN_IRAM is not set
+# CONFIG_GPTIMER_ISR_IRAM_SAFE is not set
+# CONFIG_GPTIMER_SUPPRESS_DEPRECATE_WARN is not set
+# CONFIG_GPTIMER_ENABLE_DEBUG_LOG is not set
+# end of GPTimer Configuration
+
+#
+# PCNT Configuration
+#
+# CONFIG_PCNT_CTRL_FUNC_IN_IRAM is not set
+# CONFIG_PCNT_ISR_IRAM_SAFE is not set
+# CONFIG_PCNT_SUPPRESS_DEPRECATE_WARN is not set
+# CONFIG_PCNT_ENABLE_DEBUG_LOG is not set
+# end of PCNT Configuration
+
+#
+# RMT Configuration
+#
+# CONFIG_RMT_ISR_IRAM_SAFE is not set
+# CONFIG_RMT_RECV_FUNC_IN_IRAM is not set
+# CONFIG_RMT_SUPPRESS_DEPRECATE_WARN is not set
+# CONFIG_RMT_ENABLE_DEBUG_LOG is not set
+# end of RMT Configuration
+
+#
+# MCPWM Configuration
+#
+# CONFIG_MCPWM_ISR_IRAM_SAFE is not set
+# CONFIG_MCPWM_CTRL_FUNC_IN_IRAM is not set
+# CONFIG_MCPWM_SUPPRESS_DEPRECATE_WARN is not set
+# CONFIG_MCPWM_ENABLE_DEBUG_LOG is not set
+# end of MCPWM Configuration
+
+#
+# I2S Configuration
+#
+# CONFIG_I2S_ISR_IRAM_SAFE is not set
+# CONFIG_I2S_SUPPRESS_DEPRECATE_WARN is not set
+# CONFIG_I2S_ENABLE_DEBUG_LOG is not set
+# end of I2S Configuration
+# end of Driver Configurations
+
+#
+# eFuse Bit Manager
+#
+# CONFIG_EFUSE_CUSTOM_TABLE is not set
+# CONFIG_EFUSE_VIRTUAL is not set
+# CONFIG_EFUSE_CODE_SCHEME_COMPAT_NONE is not set
+CONFIG_EFUSE_CODE_SCHEME_COMPAT_3_4=y
+# CONFIG_EFUSE_CODE_SCHEME_COMPAT_REPEAT is not set
+CONFIG_EFUSE_MAX_BLK_LEN=192
+# end of eFuse Bit Manager
+
+#
+# ESP-TLS
+#
+CONFIG_ESP_TLS_USING_MBEDTLS=y
+# CONFIG_ESP_TLS_USE_SECURE_ELEMENT is not set
+# CONFIG_ESP_TLS_CLIENT_SESSION_TICKETS is not set
+# CONFIG_ESP_TLS_SERVER is not set
+# CONFIG_ESP_TLS_PSK_VERIFICATION is not set
+# CONFIG_ESP_TLS_INSECURE is not set
+# end of ESP-TLS
+
+#
+# ADC and ADC Calibration
+#
+# CONFIG_ADC_ONESHOT_CTRL_FUNC_IN_IRAM is not set
+# CONFIG_ADC_CONTINUOUS_ISR_IRAM_SAFE is not set
+
+#
+# ADC Calibration Configurations
+#
+CONFIG_ADC_CALI_EFUSE_TP_ENABLE=y
+CONFIG_ADC_CALI_EFUSE_VREF_ENABLE=y
+CONFIG_ADC_CALI_LUT_ENABLE=y
+# end of ADC Calibration Configurations
+
+CONFIG_ADC_DISABLE_DAC_OUTPUT=y
+# end of ADC and ADC Calibration
+
+#
+# Common ESP-related
+#
+CONFIG_ESP_ERR_TO_NAME_LOOKUP=y
+# end of Common ESP-related
+
+#
+# Ethernet
+#
+CONFIG_ETH_ENABLED=y
+CONFIG_ETH_USE_ESP32_EMAC=y
+CONFIG_ETH_PHY_INTERFACE_RMII=y
+CONFIG_ETH_RMII_CLK_INPUT=y
+# CONFIG_ETH_RMII_CLK_OUTPUT is not set
+CONFIG_ETH_RMII_CLK_IN_GPIO=0
+CONFIG_ETH_DMA_BUFFER_SIZE=512
+CONFIG_ETH_DMA_RX_BUFFER_NUM=10
+CONFIG_ETH_DMA_TX_BUFFER_NUM=10
+# CONFIG_ETH_IRAM_OPTIMIZATION is not set
+CONFIG_ETH_USE_SPI_ETHERNET=y
+# CONFIG_ETH_SPI_ETHERNET_DM9051 is not set
+# CONFIG_ETH_SPI_ETHERNET_W5500 is not set
+# CONFIG_ETH_SPI_ETHERNET_KSZ8851SNL is not set
+# CONFIG_ETH_USE_OPENETH is not set
+# CONFIG_ETH_TRANSMIT_MUTEX is not set
+# end of Ethernet
+
+#
+# Event Loop Library
+#
+# CONFIG_ESP_EVENT_LOOP_PROFILING is not set
+CONFIG_ESP_EVENT_POST_FROM_ISR=y
+CONFIG_ESP_EVENT_POST_FROM_IRAM_ISR=y
+# end of Event Loop Library
+
+#
+# GDB Stub
+#
+# end of GDB Stub
+
+#
+# ESP HTTP client
+#
+CONFIG_ESP_HTTP_CLIENT_ENABLE_HTTPS=y
+# CONFIG_ESP_HTTP_CLIENT_ENABLE_BASIC_AUTH is not set
+# CONFIG_ESP_HTTP_CLIENT_ENABLE_DIGEST_AUTH is not set
+# end of ESP HTTP client
+
+#
+# HTTP Server
+#
+CONFIG_HTTPD_MAX_REQ_HDR_LEN=512
+CONFIG_HTTPD_MAX_URI_LEN=512
+CONFIG_HTTPD_ERR_RESP_NO_DELAY=y
+CONFIG_HTTPD_PURGE_BUF_LEN=32
+# CONFIG_HTTPD_LOG_PURGE_DATA is not set
+# CONFIG_HTTPD_WS_SUPPORT is not set
+# CONFIG_HTTPD_QUEUE_WORK_BLOCKING is not set
+# end of HTTP Server
+
+#
+# ESP HTTPS OTA
+#
+# CONFIG_ESP_HTTPS_OTA_DECRYPT_CB is not set
+CONFIG_ESP_HTTPS_OTA_ALLOW_HTTP=y
+# end of ESP HTTPS OTA
+
+#
+# ESP HTTPS server
+#
+# CONFIG_ESP_HTTPS_SERVER_ENABLE is not set
+# end of ESP HTTPS server
+
+#
+# Hardware Settings
+#
+
+#
+# Chip revision
+#
+CONFIG_ESP32_REV_MIN_0=y
+# CONFIG_ESP32_REV_MIN_1 is not set
+# CONFIG_ESP32_REV_MIN_1_1 is not set
+# CONFIG_ESP32_REV_MIN_2 is not set
+# CONFIG_ESP32_REV_MIN_3 is not set
+# CONFIG_ESP32_REV_MIN_3_1 is not set
+CONFIG_ESP32_REV_MIN=0
+CONFIG_ESP32_REV_MIN_FULL=0
+CONFIG_ESP_REV_MIN_FULL=0
+
+#
+# Maximum Supported ESP32 Revision (Rev v3.99)
+#
+CONFIG_ESP32_REV_MAX_FULL=399
+CONFIG_ESP_REV_MAX_FULL=399
+# end of Chip revision
+
+#
+# MAC Config
+#
+CONFIG_ESP_MAC_ADDR_UNIVERSE_WIFI_STA=y
+CONFIG_ESP_MAC_ADDR_UNIVERSE_WIFI_AP=y
+CONFIG_ESP_MAC_ADDR_UNIVERSE_BT=y
+CONFIG_ESP_MAC_ADDR_UNIVERSE_ETH=y
+# CONFIG_ESP32_UNIVERSAL_MAC_ADDRESSES_TWO is not set
+CONFIG_ESP32_UNIVERSAL_MAC_ADDRESSES_FOUR=y
+CONFIG_ESP32_UNIVERSAL_MAC_ADDRESSES=4
+# CONFIG_ESP_MAC_IGNORE_MAC_CRC_ERROR is not set
+# end of MAC Config
+
+#
+# Sleep Config
+#
+# CONFIG_ESP_SLEEP_POWER_DOWN_FLASH is not set
+CONFIG_ESP_SLEEP_FLASH_LEAKAGE_WORKAROUND=y
+# CONFIG_ESP_SLEEP_MSPI_NEED_ALL_IO_PU is not set
+CONFIG_ESP_SLEEP_RTC_BUS_ISO_WORKAROUND=y
+# CONFIG_ESP_SLEEP_GPIO_RESET_WORKAROUND is not set
+CONFIG_ESP_SLEEP_DEEP_SLEEP_WAKEUP_DELAY=2000
+CONFIG_ESP_SLEEP_GPIO_ENABLE_INTERNAL_RESISTORS=y
+# end of Sleep Config
+
+#
+# RTC Clock Config
+#
+CONFIG_RTC_CLK_SRC_INT_RC=y
+# CONFIG_RTC_CLK_SRC_EXT_CRYS is not set
+# CONFIG_RTC_CLK_SRC_EXT_OSC is not set
+# CONFIG_RTC_CLK_SRC_INT_8MD256 is not set
+CONFIG_RTC_CLK_CAL_CYCLES=1024
+# end of RTC Clock Config
+
+#
+# Peripheral Control
+#
+# CONFIG_PERIPH_CTRL_FUNC_IN_IRAM is not set
+# end of Peripheral Control
+
+#
+# Main XTAL Config
+#
+# CONFIG_XTAL_FREQ_26 is not set
+CONFIG_XTAL_FREQ_40=y
+# CONFIG_XTAL_FREQ_AUTO is not set
+CONFIG_XTAL_FREQ=40
+# end of Main XTAL Config
+# end of Hardware Settings
+
+#
+# LCD and Touch Panel
+#
+
+#
+# LCD Touch Drivers are maintained in the IDF Component Registry
+#
+
+#
+# LCD Peripheral Configuration
+#
+CONFIG_LCD_PANEL_IO_FORMAT_BUF_SIZE=32
+# CONFIG_LCD_ENABLE_DEBUG_LOG is not set
+# end of LCD Peripheral Configuration
+# end of LCD and Touch Panel
+
+#
+# ESP NETIF Adapter
+#
+CONFIG_ESP_NETIF_IP_LOST_TIMER_INTERVAL=120
+CONFIG_ESP_NETIF_TCPIP_LWIP=y
+# CONFIG_ESP_NETIF_LOOPBACK is not set
+# CONFIG_ESP_NETIF_RECEIVE_REPORT_ERRORS is not set
+# CONFIG_ESP_NETIF_L2_TAP is not set
+# CONFIG_ESP_NETIF_BRIDGE_EN is not set
+# end of ESP NETIF Adapter
+
+#
+# PHY
+#
+CONFIG_ESP_PHY_CALIBRATION_AND_DATA_STORAGE=y
+# CONFIG_ESP_PHY_INIT_DATA_IN_PARTITION is not set
+CONFIG_ESP_PHY_MAX_WIFI_TX_POWER=20
+CONFIG_ESP_PHY_MAX_TX_POWER=20
+# CONFIG_ESP_PHY_REDUCE_TX_POWER is not set
+CONFIG_ESP_PHY_RF_CAL_PARTIAL=y
+# CONFIG_ESP_PHY_RF_CAL_NONE is not set
+# CONFIG_ESP_PHY_RF_CAL_FULL is not set
+CONFIG_ESP_PHY_CALIBRATION_MODE=0
+# end of PHY
+
+#
+# Power Management
+#
+# CONFIG_PM_ENABLE is not set
+# end of Power Management
+
+#
+# ESP PSRAM
+#
+# CONFIG_SPIRAM is not set
+# end of ESP PSRAM
+
+#
+# ESP Ringbuf
+#
+# CONFIG_RINGBUF_PLACE_FUNCTIONS_INTO_FLASH is not set
+# end of ESP Ringbuf
+
+#
+# ESP System Settings
+#
+# CONFIG_ESP_DEFAULT_CPU_FREQ_MHZ_80 is not set
+# CONFIG_ESP_DEFAULT_CPU_FREQ_MHZ_160 is not set
+CONFIG_ESP_DEFAULT_CPU_FREQ_MHZ_240=y
+CONFIG_ESP_DEFAULT_CPU_FREQ_MHZ=240
+
+#
+# Memory
+#
+# CONFIG_ESP32_USE_FIXED_STATIC_RAM_SIZE is not set
+# end of Memory
+
+#
+# Trace memory
+#
+# CONFIG_ESP32_TRAX is not set
+CONFIG_ESP32_TRACEMEM_RESERVE_DRAM=0x0
+# end of Trace memory
+
+# CONFIG_ESP_SYSTEM_PANIC_PRINT_HALT is not set
+CONFIG_ESP_SYSTEM_PANIC_PRINT_REBOOT=y
+# CONFIG_ESP_SYSTEM_PANIC_SILENT_REBOOT is not set
+# CONFIG_ESP_SYSTEM_PANIC_GDBSTUB is not set
+# CONFIG_ESP_SYSTEM_GDBSTUB_RUNTIME is not set
+
+#
+# Memory protection
+#
+# end of Memory protection
+
+CONFIG_ESP_SYSTEM_EVENT_QUEUE_SIZE=32
+CONFIG_ESP_SYSTEM_EVENT_TASK_STACK_SIZE=2304
+CONFIG_ESP_MAIN_TASK_STACK_SIZE=3584
+CONFIG_ESP_MAIN_TASK_AFFINITY_CPU0=y
+# CONFIG_ESP_MAIN_TASK_AFFINITY_CPU1 is not set
+# CONFIG_ESP_MAIN_TASK_AFFINITY_NO_AFFINITY is not set
+CONFIG_ESP_MAIN_TASK_AFFINITY=0x0
+CONFIG_ESP_MINIMAL_SHARED_STACK_SIZE=2048
+CONFIG_ESP_CONSOLE_UART_DEFAULT=y
+# CONFIG_ESP_CONSOLE_UART_CUSTOM is not set
+# CONFIG_ESP_CONSOLE_NONE is not set
+CONFIG_ESP_CONSOLE_UART=y
+CONFIG_ESP_CONSOLE_MULTIPLE_UART=y
+CONFIG_ESP_CONSOLE_UART_NUM=0
+CONFIG_ESP_CONSOLE_UART_BAUDRATE=115200
+CONFIG_ESP_INT_WDT=y
+CONFIG_ESP_INT_WDT_TIMEOUT_MS=300
+CONFIG_ESP_INT_WDT_CHECK_CPU1=y
+CONFIG_ESP_TASK_WDT_EN=y
+CONFIG_ESP_TASK_WDT_INIT=y
+# CONFIG_ESP_TASK_WDT_PANIC is not set
+CONFIG_ESP_TASK_WDT_TIMEOUT_S=5
+CONFIG_ESP_TASK_WDT_CHECK_IDLE_TASK_CPU0=y
+CONFIG_ESP_TASK_WDT_CHECK_IDLE_TASK_CPU1=y
+# CONFIG_ESP_PANIC_HANDLER_IRAM is not set
+# CONFIG_ESP_DEBUG_STUBS_ENABLE is not set
+CONFIG_ESP_DEBUG_OCDAWARE=y
+CONFIG_ESP_SYSTEM_CHECK_INT_LEVEL_5=y
+
+#
+# Brownout Detector
+#
+CONFIG_ESP_BROWNOUT_DET=y
+CONFIG_ESP_BROWNOUT_DET_LVL_SEL_0=y
+# CONFIG_ESP_BROWNOUT_DET_LVL_SEL_1 is not set
+# CONFIG_ESP_BROWNOUT_DET_LVL_SEL_2 is not set
+# CONFIG_ESP_BROWNOUT_DET_LVL_SEL_3 is not set
+# CONFIG_ESP_BROWNOUT_DET_LVL_SEL_4 is not set
+# CONFIG_ESP_BROWNOUT_DET_LVL_SEL_5 is not set
+# CONFIG_ESP_BROWNOUT_DET_LVL_SEL_6 is not set
+# CONFIG_ESP_BROWNOUT_DET_LVL_SEL_7 is not set
+CONFIG_ESP_BROWNOUT_DET_LVL=0
+# end of Brownout Detector
+
+# CONFIG_ESP32_DISABLE_BASIC_ROM_CONSOLE is not set
+CONFIG_ESP_SYSTEM_BROWNOUT_INTR=y
+# end of ESP System Settings
+
+#
+# IPC (Inter-Processor Call)
+#
+CONFIG_ESP_IPC_TASK_STACK_SIZE=1024
+CONFIG_ESP_IPC_USES_CALLERS_PRIORITY=y
+CONFIG_ESP_IPC_ISR_ENABLE=y
+# end of IPC (Inter-Processor Call)
+
+#
+# High resolution timer (esp_timer)
+#
+# CONFIG_ESP_TIMER_PROFILING is not set
+CONFIG_ESP_TIME_FUNCS_USE_RTC_TIMER=y
+CONFIG_ESP_TIME_FUNCS_USE_ESP_TIMER=y
+CONFIG_ESP_TIMER_TASK_STACK_SIZE=3584
+CONFIG_ESP_TIMER_INTERRUPT_LEVEL=1
+# CONFIG_ESP_TIMER_SUPPORTS_ISR_DISPATCH_METHOD is not set
+CONFIG_ESP_TIMER_IMPL_TG0_LAC=y
+# end of High resolution timer (esp_timer)
+
+#
+# Wi-Fi
+#
+CONFIG_ESP32_WIFI_ENABLED=y
+CONFIG_ESP32_WIFI_SW_COEXIST_ENABLE=y
+CONFIG_ESP32_WIFI_STATIC_RX_BUFFER_NUM=10
+CONFIG_ESP32_WIFI_DYNAMIC_RX_BUFFER_NUM=32
+# CONFIG_ESP32_WIFI_STATIC_TX_BUFFER is not set
+CONFIG_ESP32_WIFI_DYNAMIC_TX_BUFFER=y
+CONFIG_ESP32_WIFI_TX_BUFFER_TYPE=1
+CONFIG_ESP32_WIFI_DYNAMIC_TX_BUFFER_NUM=32
+CONFIG_ESP_WIFI_STATIC_RX_MGMT_BUFFER=y
+# CONFIG_ESP_WIFI_DYNAMIC_RX_MGMT_BUFFER is not set
+CONFIG_ESP_WIFI_DYNAMIC_RX_MGMT_BUF=0
+CONFIG_ESP_WIFI_RX_MGMT_BUF_NUM_DEF=5
+# CONFIG_ESP32_WIFI_CSI_ENABLED is not set
+CONFIG_ESP32_WIFI_AMPDU_TX_ENABLED=y
+CONFIG_ESP32_WIFI_TX_BA_WIN=6
+CONFIG_ESP32_WIFI_AMPDU_RX_ENABLED=y
+CONFIG_ESP32_WIFI_RX_BA_WIN=6
+CONFIG_ESP32_WIFI_NVS_ENABLED=y
+CONFIG_ESP32_WIFI_TASK_PINNED_TO_CORE_0=y
+# CONFIG_ESP32_WIFI_TASK_PINNED_TO_CORE_1 is not set
+CONFIG_ESP32_WIFI_SOFTAP_BEACON_MAX_LEN=752
+CONFIG_ESP32_WIFI_MGMT_SBUF_NUM=32
+CONFIG_ESP32_WIFI_IRAM_OPT=y
+CONFIG_ESP32_WIFI_RX_IRAM_OPT=y
+CONFIG_ESP32_WIFI_ENABLE_WPA3_SAE=y
+CONFIG_ESP32_WIFI_ENABLE_WPA3_OWE_STA=y
+# CONFIG_ESP_WIFI_SLP_IRAM_OPT is not set
+CONFIG_ESP_WIFI_STA_DISCONNECTED_PM_ENABLE=y
+# CONFIG_ESP_WIFI_GMAC_SUPPORT is not set
+CONFIG_ESP_WIFI_SOFTAP_SUPPORT=y
+# CONFIG_ESP_WIFI_SLP_BEACON_LOST_OPT is not set
+CONFIG_ESP_WIFI_ESPNOW_MAX_ENCRYPT_NUM=7
+# CONFIG_ESP_WIFI_WPS_PASSPHRASE is not set
+CONFIG_ESP_WIFI_ENTERPRISE_SUPPORT=y
+# CONFIG_ESP_WIFI_ENT_FREE_DYNAMIC_BUFFER is not set
+# end of Wi-Fi
+
+#
+# Core dump
+#
+# CONFIG_ESP_COREDUMP_ENABLE_TO_FLASH is not set
+# CONFIG_ESP_COREDUMP_ENABLE_TO_UART is not set
+CONFIG_ESP_COREDUMP_ENABLE_TO_NONE=y
+# end of Core dump
+
+#
+# FAT Filesystem support
+#
+CONFIG_FATFS_VOLUME_COUNT=2
+# CONFIG_FATFS_SECTOR_512 is not set
+# CONFIG_FATFS_SECTOR_1024 is not set
+# CONFIG_FATFS_SECTOR_2048 is not set
+CONFIG_FATFS_SECTOR_4096=y
+CONFIG_FATFS_SECTORS_PER_CLUSTER_1=y
+# CONFIG_FATFS_SECTORS_PER_CLUSTER_2 is not set
+# CONFIG_FATFS_SECTORS_PER_CLUSTER_4 is not set
+# CONFIG_FATFS_SECTORS_PER_CLUSTER_8 is not set
+# CONFIG_FATFS_SECTORS_PER_CLUSTER_16 is not set
+# CONFIG_FATFS_SECTORS_PER_CLUSTER_32 is not set
+# CONFIG_FATFS_SECTORS_PER_CLUSTER_64 is not set
+# CONFIG_FATFS_SECTORS_PER_CLUSTER_128 is not set
+# CONFIG_FATFS_CODEPAGE_DYNAMIC is not set
+CONFIG_FATFS_CODEPAGE_437=y
+# CONFIG_FATFS_CODEPAGE_720 is not set
+# CONFIG_FATFS_CODEPAGE_737 is not set
+# CONFIG_FATFS_CODEPAGE_771 is not set
+# CONFIG_FATFS_CODEPAGE_775 is not set
+# CONFIG_FATFS_CODEPAGE_850 is not set
+# CONFIG_FATFS_CODEPAGE_852 is not set
+# CONFIG_FATFS_CODEPAGE_855 is not set
+# CONFIG_FATFS_CODEPAGE_857 is not set
+# CONFIG_FATFS_CODEPAGE_860 is not set
+# CONFIG_FATFS_CODEPAGE_861 is not set
+# CONFIG_FATFS_CODEPAGE_862 is not set
+# CONFIG_FATFS_CODEPAGE_863 is not set
+# CONFIG_FATFS_CODEPAGE_864 is not set
+# CONFIG_FATFS_CODEPAGE_865 is not set
+# CONFIG_FATFS_CODEPAGE_866 is not set
+# CONFIG_FATFS_CODEPAGE_869 is not set
+# CONFIG_FATFS_CODEPAGE_932 is not set
+# CONFIG_FATFS_CODEPAGE_936 is not set
+# CONFIG_FATFS_CODEPAGE_949 is not set
+# CONFIG_FATFS_CODEPAGE_950 is not set
+CONFIG_FATFS_AUTO_TYPE=y
+# CONFIG_FATFS_FAT12 is not set
+# CONFIG_FATFS_FAT16 is not set
+CONFIG_FATFS_CODEPAGE=437
+CONFIG_FATFS_LFN_NONE=y
+# CONFIG_FATFS_LFN_HEAP is not set
+# CONFIG_FATFS_LFN_STACK is not set
+CONFIG_FATFS_FS_LOCK=0
+CONFIG_FATFS_TIMEOUT_MS=10000
+CONFIG_FATFS_PER_FILE_CACHE=y
+# CONFIG_FATFS_USE_FASTSEEK is not set
+# end of FAT Filesystem support
+
+#
+# FreeRTOS
+#
+
+#
+# Kernel
+#
+# CONFIG_FREERTOS_SMP is not set
+# CONFIG_FREERTOS_UNICORE is not set
+CONFIG_FREERTOS_HZ=1000
+# CONFIG_FREERTOS_CHECK_STACKOVERFLOW_NONE is not set
+# CONFIG_FREERTOS_CHECK_STACKOVERFLOW_PTRVAL is not set
+CONFIG_FREERTOS_CHECK_STACKOVERFLOW_CANARY=y
+CONFIG_FREERTOS_THREAD_LOCAL_STORAGE_POINTERS=1
+CONFIG_FREERTOS_IDLE_TASK_STACKSIZE=1536
+# CONFIG_FREERTOS_USE_IDLE_HOOK is not set
+# CONFIG_FREERTOS_USE_TICK_HOOK is not set
+CONFIG_FREERTOS_MAX_TASK_NAME_LEN=16
+# CONFIG_FREERTOS_ENABLE_BACKWARD_COMPATIBILITY is not set
+CONFIG_FREERTOS_TIMER_TASK_PRIORITY=1
+CONFIG_FREERTOS_TIMER_TASK_STACK_DEPTH=2048
+CONFIG_FREERTOS_TIMER_QUEUE_LENGTH=10
+CONFIG_FREERTOS_QUEUE_REGISTRY_SIZE=0
+# CONFIG_FREERTOS_USE_TRACE_FACILITY is not set
+# CONFIG_FREERTOS_GENERATE_RUN_TIME_STATS is not set
+# end of Kernel
+
+#
+# Port
+#
+CONFIG_FREERTOS_TASK_FUNCTION_WRAPPER=y
+# CONFIG_FREERTOS_WATCHPOINT_END_OF_STACK is not set
+# CONFIG_FREERTOS_ENABLE_STATIC_TASK_CLEAN_UP is not set
+CONFIG_FREERTOS_CHECK_MUTEX_GIVEN_BY_OWNER=y
+CONFIG_FREERTOS_ISR_STACKSIZE=1536
+CONFIG_FREERTOS_INTERRUPT_BACKTRACE=y
+# CONFIG_FREERTOS_FPU_IN_ISR is not set
+CONFIG_FREERTOS_TICK_SUPPORT_CORETIMER=y
+CONFIG_FREERTOS_CORETIMER_0=y
+# CONFIG_FREERTOS_CORETIMER_1 is not set
+CONFIG_FREERTOS_SYSTICK_USES_CCOUNT=y
+# CONFIG_FREERTOS_PLACE_FUNCTIONS_INTO_FLASH is not set
+# CONFIG_FREERTOS_PLACE_SNAPSHOT_FUNS_INTO_FLASH is not set
+# CONFIG_FREERTOS_CHECK_PORT_CRITICAL_COMPLIANCE is not set
+CONFIG_FREERTOS_ASSERT_ON_UNTESTED_FUNCTION=y
+CONFIG_FREERTOS_ENABLE_TASK_SNAPSHOT=y
+# end of Port
+
+CONFIG_FREERTOS_NO_AFFINITY=0x7FFFFFFF
+CONFIG_FREERTOS_SUPPORT_STATIC_ALLOCATION=y
+CONFIG_FREERTOS_DEBUG_OCDAWARE=y
+# end of FreeRTOS
+
+#
+# Hardware Abstraction Layer (HAL) and Low Level (LL)
+#
+CONFIG_HAL_ASSERTION_EQUALS_SYSTEM=y
+# CONFIG_HAL_ASSERTION_DISABLE is not set
+# CONFIG_HAL_ASSERTION_SILENT is not set
+# CONFIG_HAL_ASSERTION_ENABLE is not set
+CONFIG_HAL_DEFAULT_ASSERTION_LEVEL=2
+# end of Hardware Abstraction Layer (HAL) and Low Level (LL)
+
+#
+# Heap memory debugging
+#
+CONFIG_HEAP_POISONING_DISABLED=y
+# CONFIG_HEAP_POISONING_LIGHT is not set
+# CONFIG_HEAP_POISONING_COMPREHENSIVE is not set
+CONFIG_HEAP_TRACING_OFF=y
+# CONFIG_HEAP_TRACING_STANDALONE is not set
+# CONFIG_HEAP_TRACING_TOHOST is not set
+# CONFIG_HEAP_ABORT_WHEN_ALLOCATION_FAILS is not set
+# end of Heap memory debugging
+
+#
+# Log output
+#
+# CONFIG_LOG_DEFAULT_LEVEL_NONE is not set
+# CONFIG_LOG_DEFAULT_LEVEL_ERROR is not set
+# CONFIG_LOG_DEFAULT_LEVEL_WARN is not set
+CONFIG_LOG_DEFAULT_LEVEL_INFO=y
+# CONFIG_LOG_DEFAULT_LEVEL_DEBUG is not set
+# CONFIG_LOG_DEFAULT_LEVEL_VERBOSE is not set
+CONFIG_LOG_DEFAULT_LEVEL=3
+CONFIG_LOG_MAXIMUM_EQUALS_DEFAULT=y
+# CONFIG_LOG_MAXIMUM_LEVEL_DEBUG is not set
+# CONFIG_LOG_MAXIMUM_LEVEL_VERBOSE is not set
+CONFIG_LOG_MAXIMUM_LEVEL=3
+CONFIG_LOG_COLORS=y
+CONFIG_LOG_TIMESTAMP_SOURCE_RTOS=y
+# CONFIG_LOG_TIMESTAMP_SOURCE_SYSTEM is not set
+# end of Log output
+
+#
+# LWIP
+#
+CONFIG_LWIP_LOCAL_HOSTNAME="QJ500-7C"
+# CONFIG_LWIP_NETIF_API is not set
+CONFIG_LWIP_TCPIP_TASK_PRIO=18
+# CONFIG_LWIP_TCPIP_CORE_LOCKING is not set
+# CONFIG_LWIP_CHECK_THREAD_SAFETY is not set
+CONFIG_LWIP_DNS_SUPPORT_MDNS_QUERIES=y
+# CONFIG_LWIP_L2_TO_L3_COPY is not set
+# CONFIG_LWIP_IRAM_OPTIMIZATION is not set
+CONFIG_LWIP_TIMERS_ONDEMAND=y
+CONFIG_LWIP_MAX_SOCKETS=10
+# CONFIG_LWIP_USE_ONLY_LWIP_SELECT is not set
+# CONFIG_LWIP_SO_LINGER is not set
+CONFIG_LWIP_SO_REUSE=y
+CONFIG_LWIP_SO_REUSE_RXTOALL=y
+# CONFIG_LWIP_SO_RCVBUF is not set
+# CONFIG_LWIP_NETBUF_RECVINFO is not set
+CONFIG_LWIP_IP_DEFAULT_TTL=64
+CONFIG_LWIP_IP4_FRAG=y
+CONFIG_LWIP_IP6_FRAG=y
+# CONFIG_LWIP_IP4_REASSEMBLY is not set
+# CONFIG_LWIP_IP6_REASSEMBLY is not set
+# CONFIG_LWIP_IP_FORWARD is not set
+# CONFIG_LWIP_STATS is not set
+CONFIG_LWIP_ESP_GRATUITOUS_ARP=y
+CONFIG_LWIP_GARP_TMR_INTERVAL=60
+CONFIG_LWIP_ESP_MLDV6_REPORT=y
+CONFIG_LWIP_MLDV6_TMR_INTERVAL=40
+CONFIG_LWIP_TCPIP_RECVMBOX_SIZE=32
+CONFIG_LWIP_DHCP_DOES_ARP_CHECK=y
+# CONFIG_LWIP_DHCP_DISABLE_CLIENT_ID is not set
+CONFIG_LWIP_DHCP_DISABLE_VENDOR_CLASS_ID=y
+# CONFIG_LWIP_DHCP_RESTORE_LAST_IP is not set
+CONFIG_LWIP_DHCP_OPTIONS_LEN=68
+CONFIG_LWIP_NUM_NETIF_CLIENT_DATA=0
+CONFIG_LWIP_DHCP_COARSE_TIMER_SECS=1
+
+#
+# DHCP server
+#
+CONFIG_LWIP_DHCPS=y
+CONFIG_LWIP_DHCPS_LEASE_UNIT=60
+CONFIG_LWIP_DHCPS_MAX_STATION_NUM=8
+# end of DHCP server
+
+# CONFIG_LWIP_AUTOIP is not set
+CONFIG_LWIP_IPV6=y
+# CONFIG_LWIP_IPV6_AUTOCONFIG is not set
+CONFIG_LWIP_IPV6_NUM_ADDRESSES=3
+# CONFIG_LWIP_IPV6_FORWARD is not set
+# CONFIG_LWIP_NETIF_STATUS_CALLBACK is not set
+CONFIG_LWIP_NETIF_LOOPBACK=y
+CONFIG_LWIP_LOOPBACK_MAX_PBUFS=8
+
+#
+# TCP
+#
+CONFIG_LWIP_MAX_ACTIVE_TCP=16
+CONFIG_LWIP_MAX_LISTENING_TCP=16
+CONFIG_LWIP_TCP_HIGH_SPEED_RETRANSMISSION=y
+CONFIG_LWIP_TCP_MAXRTX=12
+CONFIG_LWIP_TCP_SYNMAXRTX=12
+CONFIG_LWIP_TCP_MSS=1440
+CONFIG_LWIP_TCP_TMR_INTERVAL=250
+CONFIG_LWIP_TCP_MSL=60000
+CONFIG_LWIP_TCP_FIN_WAIT_TIMEOUT=20000
+CONFIG_LWIP_TCP_SND_BUF_DEFAULT=5744
+CONFIG_LWIP_TCP_WND_DEFAULT=5744
+CONFIG_LWIP_TCP_RECVMBOX_SIZE=6
+CONFIG_LWIP_TCP_QUEUE_OOSEQ=y
+CONFIG_LWIP_TCP_OOSEQ_TIMEOUT=6
+CONFIG_LWIP_TCP_OOSEQ_MAX_PBUFS=4
+# CONFIG_LWIP_TCP_SACK_OUT is not set
+CONFIG_LWIP_TCP_OVERSIZE_MSS=y
+# CONFIG_LWIP_TCP_OVERSIZE_QUARTER_MSS is not set
+# CONFIG_LWIP_TCP_OVERSIZE_DISABLE is not set
+CONFIG_LWIP_TCP_RTO_TIME=1500
+# end of TCP
+
+#
+# UDP
+#
+CONFIG_LWIP_MAX_UDP_PCBS=16
+CONFIG_LWIP_UDP_RECVMBOX_SIZE=6
+# end of UDP
+
+#
+# Checksums
+#
+# CONFIG_LWIP_CHECKSUM_CHECK_IP is not set
+# CONFIG_LWIP_CHECKSUM_CHECK_UDP is not set
+CONFIG_LWIP_CHECKSUM_CHECK_ICMP=y
+# end of Checksums
+
+CONFIG_LWIP_TCPIP_TASK_STACK_SIZE=3072
+CONFIG_LWIP_TCPIP_TASK_AFFINITY_NO_AFFINITY=y
+# CONFIG_LWIP_TCPIP_TASK_AFFINITY_CPU0 is not set
+# CONFIG_LWIP_TCPIP_TASK_AFFINITY_CPU1 is not set
+CONFIG_LWIP_TCPIP_TASK_AFFINITY=0x7FFFFFFF
+# CONFIG_LWIP_PPP_SUPPORT is not set
+CONFIG_LWIP_IPV6_MEMP_NUM_ND6_QUEUE=3
+CONFIG_LWIP_IPV6_ND6_NUM_NEIGHBORS=5
+CONFIG_LWIP_ND6=y
+# CONFIG_LWIP_FORCE_ROUTER_FORWARDING is not set
+# CONFIG_LWIP_SLIP_SUPPORT is not set
+
+#
+# ICMP
+#
+CONFIG_LWIP_ICMP=y
+# CONFIG_LWIP_MULTICAST_PING is not set
+# CONFIG_LWIP_BROADCAST_PING is not set
+# end of ICMP
+
+#
+# LWIP RAW API
+#
+CONFIG_LWIP_MAX_RAW_PCBS=16
+# end of LWIP RAW API
+
+#
+# SNTP
+#
+CONFIG_LWIP_SNTP_MAX_SERVERS=1
+# CONFIG_LWIP_DHCP_GET_NTP_SRV is not set
+CONFIG_LWIP_SNTP_UPDATE_DELAY=3600000
+# end of SNTP
+
+CONFIG_LWIP_BRIDGEIF_MAX_PORTS=50
+
+#
+# DNS
+#
+CONFIG_LWIP_DNS_MAX_SERVERS=3
+# CONFIG_LWIP_FALLBACK_DNS_SERVER_SUPPORT is not set
+# end of DNS
+
+CONFIG_LWIP_ESP_LWIP_ASSERT=y
+
+#
+# Hooks
+#
+# CONFIG_LWIP_HOOK_TCP_ISN_NONE is not set
+CONFIG_LWIP_HOOK_TCP_ISN_DEFAULT=y
+# CONFIG_LWIP_HOOK_TCP_ISN_CUSTOM is not set
+CONFIG_LWIP_HOOK_IP6_ROUTE_NONE=y
+# CONFIG_LWIP_HOOK_IP6_ROUTE_DEFAULT is not set
+# CONFIG_LWIP_HOOK_IP6_ROUTE_CUSTOM is not set
+CONFIG_LWIP_HOOK_ND6_GET_GW_NONE=y
+# CONFIG_LWIP_HOOK_ND6_GET_GW_DEFAULT is not set
+# CONFIG_LWIP_HOOK_ND6_GET_GW_CUSTOM is not set
+CONFIG_LWIP_HOOK_NETCONN_EXT_RESOLVE_NONE=y
+# CONFIG_LWIP_HOOK_NETCONN_EXT_RESOLVE_DEFAULT is not set
+# CONFIG_LWIP_HOOK_NETCONN_EXT_RESOLVE_CUSTOM is not set
+CONFIG_LWIP_HOOK_IP6_INPUT_NONE=y
+# CONFIG_LWIP_HOOK_IP6_INPUT_DEFAULT is not set
+# CONFIG_LWIP_HOOK_IP6_INPUT_CUSTOM is not set
+# end of Hooks
+
+# CONFIG_LWIP_DEBUG is not set
+# end of LWIP
+
+#
+# mbedTLS
+#
+CONFIG_MBEDTLS_INTERNAL_MEM_ALLOC=y
+# CONFIG_MBEDTLS_DEFAULT_MEM_ALLOC is not set
+# CONFIG_MBEDTLS_CUSTOM_MEM_ALLOC is not set
+CONFIG_MBEDTLS_ASYMMETRIC_CONTENT_LEN=y
+CONFIG_MBEDTLS_SSL_IN_CONTENT_LEN=16384
+CONFIG_MBEDTLS_SSL_OUT_CONTENT_LEN=4096
+# CONFIG_MBEDTLS_DYNAMIC_BUFFER is not set
+# CONFIG_MBEDTLS_DEBUG is not set
+
+#
+# mbedTLS v3.x related
+#
+# CONFIG_MBEDTLS_SSL_PROTO_TLS1_3 is not set
+# CONFIG_MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH is not set
+# CONFIG_MBEDTLS_X509_TRUSTED_CERT_CALLBACK is not set
+# CONFIG_MBEDTLS_SSL_CONTEXT_SERIALIZATION is not set
+CONFIG_MBEDTLS_SSL_KEEP_PEER_CERTIFICATE=y
+CONFIG_MBEDTLS_PKCS7_C=y
+# end of mbedTLS v3.x related
+
+#
+# Certificate Bundle
+#
+CONFIG_MBEDTLS_CERTIFICATE_BUNDLE=y
+CONFIG_MBEDTLS_CERTIFICATE_BUNDLE_DEFAULT_FULL=y
+# CONFIG_MBEDTLS_CERTIFICATE_BUNDLE_DEFAULT_CMN is not set
+# CONFIG_MBEDTLS_CERTIFICATE_BUNDLE_DEFAULT_NONE is not set
+# CONFIG_MBEDTLS_CUSTOM_CERTIFICATE_BUNDLE is not set
+CONFIG_MBEDTLS_CERTIFICATE_BUNDLE_MAX_CERTS=200
+# end of Certificate Bundle
+
+# CONFIG_MBEDTLS_ECP_RESTARTABLE is not set
+CONFIG_MBEDTLS_CMAC_C=y
+CONFIG_MBEDTLS_HARDWARE_AES=y
+# CONFIG_MBEDTLS_GCM_SUPPORT_NON_AES_CIPHER is not set
+CONFIG_MBEDTLS_HARDWARE_MPI=y
+CONFIG_MBEDTLS_HARDWARE_SHA=y
+CONFIG_MBEDTLS_ROM_MD5=y
+# CONFIG_MBEDTLS_ATCA_HW_ECDSA_SIGN is not set
+# CONFIG_MBEDTLS_ATCA_HW_ECDSA_VERIFY is not set
+CONFIG_MBEDTLS_HAVE_TIME=y
+# CONFIG_MBEDTLS_PLATFORM_TIME_ALT is not set
+# CONFIG_MBEDTLS_HAVE_TIME_DATE is not set
+CONFIG_MBEDTLS_ECDSA_DETERMINISTIC=y
+CONFIG_MBEDTLS_SHA512_C=y
+CONFIG_MBEDTLS_TLS_SERVER_AND_CLIENT=y
+# CONFIG_MBEDTLS_TLS_SERVER_ONLY is not set
+# CONFIG_MBEDTLS_TLS_CLIENT_ONLY is not set
+# CONFIG_MBEDTLS_TLS_DISABLED is not set
+CONFIG_MBEDTLS_TLS_SERVER=y
+CONFIG_MBEDTLS_TLS_CLIENT=y
+CONFIG_MBEDTLS_TLS_ENABLED=y
+
+#
+# TLS Key Exchange Methods
+#
+# CONFIG_MBEDTLS_PSK_MODES is not set
+CONFIG_MBEDTLS_KEY_EXCHANGE_RSA=y
+CONFIG_MBEDTLS_KEY_EXCHANGE_ELLIPTIC_CURVE=y
+CONFIG_MBEDTLS_KEY_EXCHANGE_ECDHE_RSA=y
+CONFIG_MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA=y
+CONFIG_MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA=y
+CONFIG_MBEDTLS_KEY_EXCHANGE_ECDH_RSA=y
+# end of TLS Key Exchange Methods
+
+CONFIG_MBEDTLS_SSL_RENEGOTIATION=y
+CONFIG_MBEDTLS_SSL_PROTO_TLS1_2=y
+# CONFIG_MBEDTLS_SSL_PROTO_GMTSSL1_1 is not set
+# CONFIG_MBEDTLS_SSL_PROTO_DTLS is not set
+CONFIG_MBEDTLS_SSL_ALPN=y
+CONFIG_MBEDTLS_CLIENT_SSL_SESSION_TICKETS=y
+CONFIG_MBEDTLS_SERVER_SSL_SESSION_TICKETS=y
+
+#
+# Symmetric Ciphers
+#
+CONFIG_MBEDTLS_AES_C=y
+# CONFIG_MBEDTLS_CAMELLIA_C is not set
+# CONFIG_MBEDTLS_DES_C is not set
+# CONFIG_MBEDTLS_BLOWFISH_C is not set
+# CONFIG_MBEDTLS_XTEA_C is not set
+CONFIG_MBEDTLS_CCM_C=y
+CONFIG_MBEDTLS_GCM_C=y
+# CONFIG_MBEDTLS_NIST_KW_C is not set
+# end of Symmetric Ciphers
+
+# CONFIG_MBEDTLS_RIPEMD160_C is not set
+
+#
+# Certificates
+#
+CONFIG_MBEDTLS_PEM_PARSE_C=y
+CONFIG_MBEDTLS_PEM_WRITE_C=y
+CONFIG_MBEDTLS_X509_CRL_PARSE_C=y
+CONFIG_MBEDTLS_X509_CSR_PARSE_C=y
+# end of Certificates
+
+CONFIG_MBEDTLS_ECP_C=y
+# CONFIG_MBEDTLS_DHM_C is not set
+CONFIG_MBEDTLS_ECDH_C=y
+CONFIG_MBEDTLS_ECDSA_C=y
+# CONFIG_MBEDTLS_ECJPAKE_C is not set
+CONFIG_MBEDTLS_ECP_DP_SECP192R1_ENABLED=y
+CONFIG_MBEDTLS_ECP_DP_SECP224R1_ENABLED=y
+CONFIG_MBEDTLS_ECP_DP_SECP256R1_ENABLED=y
+CONFIG_MBEDTLS_ECP_DP_SECP384R1_ENABLED=y
+CONFIG_MBEDTLS_ECP_DP_SECP521R1_ENABLED=y
+CONFIG_MBEDTLS_ECP_DP_SECP192K1_ENABLED=y
+CONFIG_MBEDTLS_ECP_DP_SECP224K1_ENABLED=y
+CONFIG_MBEDTLS_ECP_DP_SECP256K1_ENABLED=y
+CONFIG_MBEDTLS_ECP_DP_BP256R1_ENABLED=y
+CONFIG_MBEDTLS_ECP_DP_BP384R1_ENABLED=y
+CONFIG_MBEDTLS_ECP_DP_BP512R1_ENABLED=y
+CONFIG_MBEDTLS_ECP_DP_CURVE25519_ENABLED=y
+CONFIG_MBEDTLS_ECP_NIST_OPTIM=y
+CONFIG_MBEDTLS_ECP_FIXED_POINT_OPTIM=y
+# CONFIG_MBEDTLS_POLY1305_C is not set
+# CONFIG_MBEDTLS_CHACHA20_C is not set
+# CONFIG_MBEDTLS_HKDF_C is not set
+# CONFIG_MBEDTLS_THREADING_C is not set
+# CONFIG_MBEDTLS_LARGE_KEY_SOFTWARE_MPI is not set
+# end of mbedTLS
+
+#
+# ESP-MQTT Configurations
+#
+CONFIG_MQTT_PROTOCOL_311=y
+# CONFIG_MQTT_PROTOCOL_5 is not set
+CONFIG_MQTT_TRANSPORT_SSL=y
+CONFIG_MQTT_TRANSPORT_WEBSOCKET=y
+CONFIG_MQTT_TRANSPORT_WEBSOCKET_SECURE=y
+# CONFIG_MQTT_MSG_ID_INCREMENTAL is not set
+# CONFIG_MQTT_SKIP_PUBLISH_IF_DISCONNECTED is not set
+# CONFIG_MQTT_REPORT_DELETED_MESSAGES is not set
+# CONFIG_MQTT_USE_CUSTOM_CONFIG is not set
+# CONFIG_MQTT_TASK_CORE_SELECTION_ENABLED is not set
+# CONFIG_MQTT_CUSTOM_OUTBOX is not set
+# end of ESP-MQTT Configurations
+
+#
+# Newlib
+#
+CONFIG_NEWLIB_STDOUT_LINE_ENDING_CRLF=y
+# CONFIG_NEWLIB_STDOUT_LINE_ENDING_LF is not set
+# CONFIG_NEWLIB_STDOUT_LINE_ENDING_CR is not set
+# CONFIG_NEWLIB_STDIN_LINE_ENDING_CRLF is not set
+# CONFIG_NEWLIB_STDIN_LINE_ENDING_LF is not set
+CONFIG_NEWLIB_STDIN_LINE_ENDING_CR=y
+# CONFIG_NEWLIB_NANO_FORMAT is not set
+CONFIG_NEWLIB_TIME_SYSCALL_USE_RTC_HRT=y
+# CONFIG_NEWLIB_TIME_SYSCALL_USE_RTC is not set
+# CONFIG_NEWLIB_TIME_SYSCALL_USE_HRT is not set
+# CONFIG_NEWLIB_TIME_SYSCALL_USE_NONE is not set
+# end of Newlib
+
+#
+# NVS
+#
+# CONFIG_NVS_ASSERT_ERROR_CHECK is not set
+# end of NVS
+
+#
+# OpenThread
+#
+# CONFIG_OPENTHREAD_ENABLED is not set
+# end of OpenThread
+
+#
+# Protocomm
+#
+CONFIG_ESP_PROTOCOMM_SUPPORT_SECURITY_VERSION_0=y
+CONFIG_ESP_PROTOCOMM_SUPPORT_SECURITY_VERSION_1=y
+CONFIG_ESP_PROTOCOMM_SUPPORT_SECURITY_VERSION_2=y
+# end of Protocomm
+
+#
+# PThreads
+#
+CONFIG_PTHREAD_TASK_PRIO_DEFAULT=5
+CONFIG_PTHREAD_TASK_STACK_SIZE_DEFAULT=3072
+CONFIG_PTHREAD_STACK_MIN=768
+CONFIG_PTHREAD_DEFAULT_CORE_NO_AFFINITY=y
+# CONFIG_PTHREAD_DEFAULT_CORE_0 is not set
+# CONFIG_PTHREAD_DEFAULT_CORE_1 is not set
+CONFIG_PTHREAD_TASK_CORE_DEFAULT=-1
+CONFIG_PTHREAD_TASK_NAME_DEFAULT="pthread"
+# end of PThreads
+
+#
+# MMU Config
+#
+CONFIG_MMU_PAGE_SIZE_64KB=y
+CONFIG_MMU_PAGE_MODE="64KB"
+CONFIG_MMU_PAGE_SIZE=0x10000
+# end of MMU Config
+
+#
+# Main Flash configuration
+#
+
+#
+# SPI Flash behavior when brownout
+#
+CONFIG_SPI_FLASH_BROWNOUT_RESET_XMC=y
+CONFIG_SPI_FLASH_BROWNOUT_RESET=y
+# end of SPI Flash behavior when brownout
+
+#
+# Optional and Experimental Features (READ DOCS FIRST)
+#
+
+#
+# Features here require specific hardware (READ DOCS FIRST!)
+#
+# end of Optional and Experimental Features (READ DOCS FIRST)
+# end of Main Flash configuration
+
+#
+# SPI Flash driver
+#
+# CONFIG_SPI_FLASH_VERIFY_WRITE is not set
+# CONFIG_SPI_FLASH_ENABLE_COUNTERS is not set
+CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y
+CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS=y
+# CONFIG_SPI_FLASH_DANGEROUS_WRITE_FAILS is not set
+# CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED is not set
+# CONFIG_SPI_FLASH_SHARE_SPI1_BUS is not set
+# CONFIG_SPI_FLASH_BYPASS_BLOCK_ERASE is not set
+CONFIG_SPI_FLASH_YIELD_DURING_ERASE=y
+CONFIG_SPI_FLASH_ERASE_YIELD_DURATION_MS=20
+CONFIG_SPI_FLASH_ERASE_YIELD_TICKS=1
+CONFIG_SPI_FLASH_WRITE_CHUNK_SIZE=8192
+# CONFIG_SPI_FLASH_SIZE_OVERRIDE is not set
+# CONFIG_SPI_FLASH_CHECK_ERASE_TIMEOUT_DISABLED is not set
+# CONFIG_SPI_FLASH_OVERRIDE_CHIP_DRIVER_LIST is not set
+
+#
+# Auto-detect flash chips
+#
+CONFIG_SPI_FLASH_SUPPORT_ISSI_CHIP=y
+CONFIG_SPI_FLASH_SUPPORT_MXIC_CHIP=y
+CONFIG_SPI_FLASH_SUPPORT_GD_CHIP=y
+CONFIG_SPI_FLASH_SUPPORT_WINBOND_CHIP=y
+# CONFIG_SPI_FLASH_SUPPORT_BOYA_CHIP is not set
+# CONFIG_SPI_FLASH_SUPPORT_TH_CHIP is not set
+# end of Auto-detect flash chips
+
+CONFIG_SPI_FLASH_ENABLE_ENCRYPTED_READ_WRITE=y
+# end of SPI Flash driver
+
+#
+# SPIFFS Configuration
+#
+CONFIG_SPIFFS_MAX_PARTITIONS=3
+
+#
+# SPIFFS Cache Configuration
+#
+CONFIG_SPIFFS_CACHE=y
+CONFIG_SPIFFS_CACHE_WR=y
+# CONFIG_SPIFFS_CACHE_STATS is not set
+# end of SPIFFS Cache Configuration
+
+CONFIG_SPIFFS_PAGE_CHECK=y
+CONFIG_SPIFFS_GC_MAX_RUNS=10
+# CONFIG_SPIFFS_GC_STATS is not set
+CONFIG_SPIFFS_PAGE_SIZE=256
+CONFIG_SPIFFS_OBJ_NAME_LEN=32
+# CONFIG_SPIFFS_FOLLOW_SYMLINKS is not set
+CONFIG_SPIFFS_USE_MAGIC=y
+CONFIG_SPIFFS_USE_MAGIC_LENGTH=y
+CONFIG_SPIFFS_META_LENGTH=4
+CONFIG_SPIFFS_USE_MTIME=y
+
+#
+# Debug Configuration
+#
+# CONFIG_SPIFFS_DBG is not set
+# CONFIG_SPIFFS_API_DBG is not set
+# CONFIG_SPIFFS_GC_DBG is not set
+# CONFIG_SPIFFS_CACHE_DBG is not set
+# CONFIG_SPIFFS_CHECK_DBG is not set
+# CONFIG_SPIFFS_TEST_VISUALISATION is not set
+# end of Debug Configuration
+# end of SPIFFS Configuration
+
+#
+# TCP Transport
+#
+
+#
+# Websocket
+#
+CONFIG_WS_TRANSPORT=y
+CONFIG_WS_BUFFER_SIZE=1024
+# CONFIG_WS_DYNAMIC_BUFFER is not set
+# end of Websocket
+# end of TCP Transport
+
+#
+# Ultra Low Power (ULP) Co-processor
+#
+# CONFIG_ULP_COPROC_ENABLED is not set
+# end of Ultra Low Power (ULP) Co-processor
+
+#
+# Unity unit testing library
+#
+CONFIG_UNITY_ENABLE_FLOAT=y
+CONFIG_UNITY_ENABLE_DOUBLE=y
+# CONFIG_UNITY_ENABLE_64BIT is not set
+# CONFIG_UNITY_ENABLE_COLOR is not set
+CONFIG_UNITY_ENABLE_IDF_TEST_RUNNER=y
+# CONFIG_UNITY_ENABLE_FIXTURE is not set
+# CONFIG_UNITY_ENABLE_BACKTRACE_ON_FAIL is not set
+# end of Unity unit testing library
+
+#
+# Root Hub configuration
+#
+# end of Root Hub configuration
+
+#
+# Virtual file system
+#
+CONFIG_VFS_SUPPORT_IO=y
+CONFIG_VFS_SUPPORT_DIR=y
+CONFIG_VFS_SUPPORT_SELECT=y
+CONFIG_VFS_SUPPRESS_SELECT_DEBUG_OUTPUT=y
+CONFIG_VFS_SUPPORT_TERMIOS=y
+
+#
+# Host File System I/O (Semihosting)
+#
+CONFIG_VFS_SEMIHOSTFS_MAX_MOUNT_POINTS=1
+# end of Host File System I/O (Semihosting)
+# end of Virtual file system
+
+#
+# Wear Levelling
+#
+# CONFIG_WL_SECTOR_SIZE_512 is not set
+CONFIG_WL_SECTOR_SIZE_4096=y
+CONFIG_WL_SECTOR_SIZE=4096
+# end of Wear Levelling
+
+#
+# Wi-Fi Provisioning Manager
+#
+CONFIG_WIFI_PROV_SCAN_MAX_ENTRIES=16
+CONFIG_WIFI_PROV_AUTOSTOP_TIMEOUT=30
+# CONFIG_WIFI_PROV_BLE_BONDING is not set
+# CONFIG_WIFI_PROV_BLE_FORCE_ENCRYPTION is not set
+# CONFIG_WIFI_PROV_KEEP_BLE_ON_AFTER_PROV is not set
+CONFIG_WIFI_PROV_STA_ALL_CHANNEL_SCAN=y
+# CONFIG_WIFI_PROV_STA_FAST_SCAN is not set
+# end of Wi-Fi Provisioning Manager
+
+#
+# Supplicant
+#
+CONFIG_WPA_MBEDTLS_CRYPTO=y
+CONFIG_WPA_MBEDTLS_TLS_CLIENT=y
+# CONFIG_WPA_WAPI_PSK is not set
+# CONFIG_WPA_DEBUG_PRINT is not set
+# CONFIG_WPA_TESTING_OPTIONS is not set
+# CONFIG_WPA_WPS_STRICT is not set
+# CONFIG_WPA_11KV_SUPPORT is not set
+# CONFIG_WPA_MBO_SUPPORT is not set
+# CONFIG_WPA_DPP_SUPPORT is not set
+# CONFIG_WPA_11R_SUPPORT is not set
+# CONFIG_WPA_WPS_SOFTAP_REGISTRAR is not set
+# end of Supplicant
+# end of Component config
+
+# Deprecated options for backward compatibility
+# CONFIG_NO_BLOBS is not set
+# CONFIG_ESP32_NO_BLOBS is not set
+# CONFIG_ESP32_COMPATIBLE_PRE_V2_1_BOOTLOADERS is not set
+# CONFIG_ESP32_COMPATIBLE_PRE_V3_1_BOOTLOADERS is not set
+# CONFIG_LOG_BOOTLOADER_LEVEL_NONE is not set
+# CONFIG_LOG_BOOTLOADER_LEVEL_ERROR is not set
+CONFIG_LOG_BOOTLOADER_LEVEL_WARN=y
+# CONFIG_LOG_BOOTLOADER_LEVEL_INFO is not set
+# CONFIG_LOG_BOOTLOADER_LEVEL_DEBUG is not set
+# CONFIG_LOG_BOOTLOADER_LEVEL_VERBOSE is not set
+CONFIG_LOG_BOOTLOADER_LEVEL=2
+# CONFIG_APP_ROLLBACK_ENABLE is not set
+# CONFIG_FLASH_ENCRYPTION_ENABLED is not set
+# CONFIG_FLASHMODE_QIO is not set
+# CONFIG_FLASHMODE_QOUT is not set
+CONFIG_FLASHMODE_DIO=y
+# CONFIG_FLASHMODE_DOUT is not set
+CONFIG_MONITOR_BAUD=115200
+CONFIG_OPTIMIZATION_LEVEL_DEBUG=y
+CONFIG_COMPILER_OPTIMIZATION_LEVEL_DEBUG=y
+# CONFIG_OPTIMIZATION_LEVEL_RELEASE is not set
+# CONFIG_COMPILER_OPTIMIZATION_LEVEL_RELEASE is not set
+CONFIG_OPTIMIZATION_ASSERTIONS_ENABLED=y
+# CONFIG_OPTIMIZATION_ASSERTIONS_SILENT is not set
+# CONFIG_OPTIMIZATION_ASSERTIONS_DISABLED is not set
+CONFIG_OPTIMIZATION_ASSERTION_LEVEL=2
+# CONFIG_CXX_EXCEPTIONS is not set
+CONFIG_STACK_CHECK_NONE=y
+# CONFIG_STACK_CHECK_NORM is not set
+# CONFIG_STACK_CHECK_STRONG is not set
+# CONFIG_STACK_CHECK_ALL is not set
+# CONFIG_WARN_WRITE_STRINGS is not set
+# CONFIG_ESP32_APPTRACE_DEST_TRAX is not set
+CONFIG_ESP32_APPTRACE_DEST_NONE=y
+CONFIG_ESP32_APPTRACE_LOCK_ENABLE=y
+CONFIG_BLUEDROID_ENABLED=y
+# CONFIG_NIMBLE_ENABLED is not set
+CONFIG_BTC_TASK_STACK_SIZE=3072
+CONFIG_BLUEDROID_PINNED_TO_CORE_0=y
+# CONFIG_BLUEDROID_PINNED_TO_CORE_1 is not set
+CONFIG_BLUEDROID_PINNED_TO_CORE=0
+CONFIG_BTU_TASK_STACK_SIZE=4352
+# CONFIG_BLUEDROID_MEM_DEBUG is not set
+CONFIG_CLASSIC_BT_ENABLED=y
+# CONFIG_A2DP_ENABLE is not set
+CONFIG_HFP_ENABLE=y
+CONFIG_HFP_CLIENT_ENABLE=y
+CONFIG_HFP_AG_ENABLE=y
+CONFIG_HFP_AUDIO_DATA_PATH_PCM=y
+# CONFIG_HFP_AUDIO_DATA_PATH_HCI is not set
+CONFIG_GATTS_ENABLE=y
+# CONFIG_GATTS_SEND_SERVICE_CHANGE_MANUAL is not set
+CONFIG_GATTS_SEND_SERVICE_CHANGE_AUTO=y
+CONFIG_GATTS_SEND_SERVICE_CHANGE_MODE=0
+CONFIG_GATTC_ENABLE=y
+# CONFIG_GATTC_CACHE_NVS_FLASH is not set
+CONFIG_BLE_SMP_ENABLE=y
+# CONFIG_SMP_SLAVE_CON_PARAMS_UPD_ENABLE is not set
+# CONFIG_HCI_TRACE_LEVEL_NONE is not set
+# CONFIG_HCI_TRACE_LEVEL_ERROR is not set
+CONFIG_HCI_TRACE_LEVEL_WARNING=y
+# CONFIG_HCI_TRACE_LEVEL_API is not set
+# CONFIG_HCI_TRACE_LEVEL_EVENT is not set
+# CONFIG_HCI_TRACE_LEVEL_DEBUG is not set
+# CONFIG_HCI_TRACE_LEVEL_VERBOSE is not set
+CONFIG_HCI_INITIAL_TRACE_LEVEL=2
+# CONFIG_BTM_TRACE_LEVEL_NONE is not set
+# CONFIG_BTM_TRACE_LEVEL_ERROR is not set
+CONFIG_BTM_TRACE_LEVEL_WARNING=y
+# CONFIG_BTM_TRACE_LEVEL_API is not set
+# CONFIG_BTM_TRACE_LEVEL_EVENT is not set
+# CONFIG_BTM_TRACE_LEVEL_DEBUG is not set
+# CONFIG_BTM_TRACE_LEVEL_VERBOSE is not set
+CONFIG_BTM_INITIAL_TRACE_LEVEL=2
+# CONFIG_L2CAP_TRACE_LEVEL_NONE is not set
+# CONFIG_L2CAP_TRACE_LEVEL_ERROR is not set
+CONFIG_L2CAP_TRACE_LEVEL_WARNING=y
+# CONFIG_L2CAP_TRACE_LEVEL_API is not set
+# CONFIG_L2CAP_TRACE_LEVEL_EVENT is not set
+# CONFIG_L2CAP_TRACE_LEVEL_DEBUG is not set
+# CONFIG_L2CAP_TRACE_LEVEL_VERBOSE is not set
+CONFIG_L2CAP_INITIAL_TRACE_LEVEL=2
+# CONFIG_RFCOMM_TRACE_LEVEL_NONE is not set
+# CONFIG_RFCOMM_TRACE_LEVEL_ERROR is not set
+CONFIG_RFCOMM_TRACE_LEVEL_WARNING=y
+# CONFIG_RFCOMM_TRACE_LEVEL_API is not set
+# CONFIG_RFCOMM_TRACE_LEVEL_EVENT is not set
+# CONFIG_RFCOMM_TRACE_LEVEL_DEBUG is not set
+# CONFIG_RFCOMM_TRACE_LEVEL_VERBOSE is not set
+CONFIG_RFCOMM_INITIAL_TRACE_LEVEL=2
+# CONFIG_SDP_TRACE_LEVEL_NONE is not set
+# CONFIG_SDP_TRACE_LEVEL_ERROR is not set
+CONFIG_SDP_TRACE_LEVEL_WARNING=y
+# CONFIG_SDP_TRACE_LEVEL_API is not set
+# CONFIG_SDP_TRACE_LEVEL_EVENT is not set
+# CONFIG_SDP_TRACE_LEVEL_DEBUG is not set
+# CONFIG_SDP_TRACE_LEVEL_VERBOSE is not set
+CONFIG_BTH_LOG_SDP_INITIAL_TRACE_LEVEL=2
+# CONFIG_GAP_TRACE_LEVEL_NONE is not set
+# CONFIG_GAP_TRACE_LEVEL_ERROR is not set
+CONFIG_GAP_TRACE_LEVEL_WARNING=y
+# CONFIG_GAP_TRACE_LEVEL_API is not set
+# CONFIG_GAP_TRACE_LEVEL_EVENT is not set
+# CONFIG_GAP_TRACE_LEVEL_DEBUG is not set
+# CONFIG_GAP_TRACE_LEVEL_VERBOSE is not set
+CONFIG_GAP_INITIAL_TRACE_LEVEL=2
+CONFIG_BNEP_INITIAL_TRACE_LEVEL=2
+# CONFIG_PAN_TRACE_LEVEL_NONE is not set
+# CONFIG_PAN_TRACE_LEVEL_ERROR is not set
+CONFIG_PAN_TRACE_LEVEL_WARNING=y
+# CONFIG_PAN_TRACE_LEVEL_API is not set
+# CONFIG_PAN_TRACE_LEVEL_EVENT is not set
+# CONFIG_PAN_TRACE_LEVEL_DEBUG is not set
+# CONFIG_PAN_TRACE_LEVEL_VERBOSE is not set
+CONFIG_PAN_INITIAL_TRACE_LEVEL=2
+# CONFIG_A2D_TRACE_LEVEL_NONE is not set
+# CONFIG_A2D_TRACE_LEVEL_ERROR is not set
+CONFIG_A2D_TRACE_LEVEL_WARNING=y
+# CONFIG_A2D_TRACE_LEVEL_API is not set
+# CONFIG_A2D_TRACE_LEVEL_EVENT is not set
+# CONFIG_A2D_TRACE_LEVEL_DEBUG is not set
+# CONFIG_A2D_TRACE_LEVEL_VERBOSE is not set
+CONFIG_A2D_INITIAL_TRACE_LEVEL=2
+# CONFIG_AVDT_TRACE_LEVEL_NONE is not set
+# CONFIG_AVDT_TRACE_LEVEL_ERROR is not set
+CONFIG_AVDT_TRACE_LEVEL_WARNING=y
+# CONFIG_AVDT_TRACE_LEVEL_API is not set
+# CONFIG_AVDT_TRACE_LEVEL_EVENT is not set
+# CONFIG_AVDT_TRACE_LEVEL_DEBUG is not set
+# CONFIG_AVDT_TRACE_LEVEL_VERBOSE is not set
+CONFIG_AVDT_INITIAL_TRACE_LEVEL=2
+# CONFIG_AVCT_TRACE_LEVEL_NONE is not set
+# CONFIG_AVCT_TRACE_LEVEL_ERROR is not set
+CONFIG_AVCT_TRACE_LEVEL_WARNING=y
+# CONFIG_AVCT_TRACE_LEVEL_API is not set
+# CONFIG_AVCT_TRACE_LEVEL_EVENT is not set
+# CONFIG_AVCT_TRACE_LEVEL_DEBUG is not set
+# CONFIG_AVCT_TRACE_LEVEL_VERBOSE is not set
+CONFIG_AVCT_INITIAL_TRACE_LEVEL=2
+# CONFIG_AVRC_TRACE_LEVEL_NONE is not set
+# CONFIG_AVRC_TRACE_LEVEL_ERROR is not set
+CONFIG_AVRC_TRACE_LEVEL_WARNING=y
+# CONFIG_AVRC_TRACE_LEVEL_API is not set
+# CONFIG_AVRC_TRACE_LEVEL_EVENT is not set
+# CONFIG_AVRC_TRACE_LEVEL_DEBUG is not set
+# CONFIG_AVRC_TRACE_LEVEL_VERBOSE is not set
+CONFIG_AVRC_INITIAL_TRACE_LEVEL=2
+# CONFIG_MCA_TRACE_LEVEL_NONE is not set
+# CONFIG_MCA_TRACE_LEVEL_ERROR is not set
+CONFIG_MCA_TRACE_LEVEL_WARNING=y
+# CONFIG_MCA_TRACE_LEVEL_API is not set
+# CONFIG_MCA_TRACE_LEVEL_EVENT is not set
+# CONFIG_MCA_TRACE_LEVEL_DEBUG is not set
+# CONFIG_MCA_TRACE_LEVEL_VERBOSE is not set
+CONFIG_MCA_INITIAL_TRACE_LEVEL=2
+# CONFIG_HID_TRACE_LEVEL_NONE is not set
+# CONFIG_HID_TRACE_LEVEL_ERROR is not set
+CONFIG_HID_TRACE_LEVEL_WARNING=y
+# CONFIG_HID_TRACE_LEVEL_API is not set
+# CONFIG_HID_TRACE_LEVEL_EVENT is not set
+# CONFIG_HID_TRACE_LEVEL_DEBUG is not set
+# CONFIG_HID_TRACE_LEVEL_VERBOSE is not set
+CONFIG_HID_INITIAL_TRACE_LEVEL=2
+# CONFIG_APPL_TRACE_LEVEL_NONE is not set
+# CONFIG_APPL_TRACE_LEVEL_ERROR is not set
+CONFIG_APPL_TRACE_LEVEL_WARNING=y
+# CONFIG_APPL_TRACE_LEVEL_API is not set
+# CONFIG_APPL_TRACE_LEVEL_EVENT is not set
+# CONFIG_APPL_TRACE_LEVEL_DEBUG is not set
+# CONFIG_APPL_TRACE_LEVEL_VERBOSE is not set
+CONFIG_APPL_INITIAL_TRACE_LEVEL=2
+# CONFIG_GATT_TRACE_LEVEL_NONE is not set
+# CONFIG_GATT_TRACE_LEVEL_ERROR is not set
+CONFIG_GATT_TRACE_LEVEL_WARNING=y
+# CONFIG_GATT_TRACE_LEVEL_API is not set
+# CONFIG_GATT_TRACE_LEVEL_EVENT is not set
+# CONFIG_GATT_TRACE_LEVEL_DEBUG is not set
+# CONFIG_GATT_TRACE_LEVEL_VERBOSE is not set
+CONFIG_GATT_INITIAL_TRACE_LEVEL=2
+# CONFIG_SMP_TRACE_LEVEL_NONE is not set
+# CONFIG_SMP_TRACE_LEVEL_ERROR is not set
+CONFIG_SMP_TRACE_LEVEL_WARNING=y
+# CONFIG_SMP_TRACE_LEVEL_API is not set
+# CONFIG_SMP_TRACE_LEVEL_EVENT is not set
+# CONFIG_SMP_TRACE_LEVEL_DEBUG is not set
+# CONFIG_SMP_TRACE_LEVEL_VERBOSE is not set
+CONFIG_SMP_INITIAL_TRACE_LEVEL=2
+# CONFIG_BTIF_TRACE_LEVEL_NONE is not set
+# CONFIG_BTIF_TRACE_LEVEL_ERROR is not set
+CONFIG_BTIF_TRACE_LEVEL_WARNING=y
+# CONFIG_BTIF_TRACE_LEVEL_API is not set
+# CONFIG_BTIF_TRACE_LEVEL_EVENT is not set
+# CONFIG_BTIF_TRACE_LEVEL_DEBUG is not set
+# CONFIG_BTIF_TRACE_LEVEL_VERBOSE is not set
+CONFIG_BTIF_INITIAL_TRACE_LEVEL=2
+# CONFIG_BTC_TRACE_LEVEL_NONE is not set
+# CONFIG_BTC_TRACE_LEVEL_ERROR is not set
+CONFIG_BTC_TRACE_LEVEL_WARNING=y
+# CONFIG_BTC_TRACE_LEVEL_API is not set
+# CONFIG_BTC_TRACE_LEVEL_EVENT is not set
+# CONFIG_BTC_TRACE_LEVEL_DEBUG is not set
+# CONFIG_BTC_TRACE_LEVEL_VERBOSE is not set
+CONFIG_BTC_INITIAL_TRACE_LEVEL=2
+# CONFIG_OSI_TRACE_LEVEL_NONE is not set
+# CONFIG_OSI_TRACE_LEVEL_ERROR is not set
+CONFIG_OSI_TRACE_LEVEL_WARNING=y
+# CONFIG_OSI_TRACE_LEVEL_API is not set
+# CONFIG_OSI_TRACE_LEVEL_EVENT is not set
+# CONFIG_OSI_TRACE_LEVEL_DEBUG is not set
+# CONFIG_OSI_TRACE_LEVEL_VERBOSE is not set
+CONFIG_OSI_INITIAL_TRACE_LEVEL=2
+# CONFIG_BLUFI_TRACE_LEVEL_NONE is not set
+# CONFIG_BLUFI_TRACE_LEVEL_ERROR is not set
+CONFIG_BLUFI_TRACE_LEVEL_WARNING=y
+# CONFIG_BLUFI_TRACE_LEVEL_API is not set
+# CONFIG_BLUFI_TRACE_LEVEL_EVENT is not set
+# CONFIG_BLUFI_TRACE_LEVEL_DEBUG is not set
+# CONFIG_BLUFI_TRACE_LEVEL_VERBOSE is not set
+CONFIG_BLUFI_INITIAL_TRACE_LEVEL=2
+# CONFIG_BLE_HOST_QUEUE_CONGESTION_CHECK is not set
+CONFIG_SMP_ENABLE=y
+# CONFIG_BLE_ACTIVE_SCAN_REPORT_ADV_SCAN_RSP_INDIVIDUALLY is not set
+CONFIG_BLE_ESTABLISH_LINK_CONNECTION_TIMEOUT=30
+# CONFIG_BTDM_CONTROLLER_MODE_BLE_ONLY is not set
+# CONFIG_BTDM_CONTROLLER_MODE_BR_EDR_ONLY is not set
+CONFIG_BTDM_CONTROLLER_MODE_BTDM=y
+CONFIG_BTDM_CONTROLLER_BLE_MAX_CONN=3
+CONFIG_BTDM_CONTROLLER_BR_EDR_MAX_ACL_CONN=2
+CONFIG_BTDM_CONTROLLER_BR_EDR_MAX_SYNC_CONN=2
+CONFIG_BTDM_CONTROLLER_BLE_MAX_CONN_EFF=3
+CONFIG_BTDM_CONTROLLER_BR_EDR_MAX_ACL_CONN_EFF=2
+CONFIG_BTDM_CONTROLLER_BR_EDR_MAX_SYNC_CONN_EFF=2
+CONFIG_BTDM_CONTROLLER_PINNED_TO_CORE=0
+CONFIG_BTDM_CONTROLLER_HCI_MODE_VHCI=y
+# CONFIG_BTDM_CONTROLLER_HCI_MODE_UART_H4 is not set
+CONFIG_BTDM_CONTROLLER_MODEM_SLEEP=y
+CONFIG_BLE_SCAN_DUPLICATE=y
+CONFIG_SCAN_DUPLICATE_BY_DEVICE_ADDR=y
+# CONFIG_SCAN_DUPLICATE_BY_ADV_DATA is not set
+# CONFIG_SCAN_DUPLICATE_BY_ADV_DATA_AND_DEVICE_ADDR is not set
+CONFIG_SCAN_DUPLICATE_TYPE=0
+CONFIG_DUPLICATE_SCAN_CACHE_SIZE=100
+# CONFIG_BLE_MESH_SCAN_DUPLICATE_EN is not set
+CONFIG_BTDM_CONTROLLER_FULL_SCAN_SUPPORTED=y
+CONFIG_BLE_ADV_REPORT_FLOW_CONTROL_SUPPORTED=y
+CONFIG_BLE_ADV_REPORT_FLOW_CONTROL_NUM=100
+CONFIG_BLE_ADV_REPORT_DISCARD_THRSHOLD=20
+CONFIG_ADC2_DISABLE_DAC=y
+# CONFIG_MCPWM_ISR_IN_IRAM is not set
+# CONFIG_EVENT_LOOP_PROFILING is not set
+CONFIG_POST_EVENTS_FROM_ISR=y
+CONFIG_POST_EVENTS_FROM_IRAM_ISR=y
+CONFIG_OTA_ALLOW_HTTP=y
+# CONFIG_TWO_UNIVERSAL_MAC_ADDRESS is not set
+CONFIG_FOUR_UNIVERSAL_MAC_ADDRESS=y
+CONFIG_NUMBER_OF_UNIVERSAL_MAC_ADDRESS=4
+# CONFIG_ESP_SYSTEM_PD_FLASH is not set
+CONFIG_ESP32_DEEP_SLEEP_WAKEUP_DELAY=2000
+CONFIG_ESP32_RTC_CLK_SRC_INT_RC=y
+CONFIG_ESP32_RTC_CLOCK_SOURCE_INTERNAL_RC=y
+# CONFIG_ESP32_RTC_CLK_SRC_EXT_CRYS is not set
+# CONFIG_ESP32_RTC_CLOCK_SOURCE_EXTERNAL_CRYSTAL is not set
+# CONFIG_ESP32_RTC_CLK_SRC_EXT_OSC is not set
+# CONFIG_ESP32_RTC_CLOCK_SOURCE_EXTERNAL_OSC is not set
+# CONFIG_ESP32_RTC_CLK_SRC_INT_8MD256 is not set
+# CONFIG_ESP32_RTC_CLOCK_SOURCE_INTERNAL_8MD256 is not set
+CONFIG_ESP32_RTC_CLK_CAL_CYCLES=1024
+# CONFIG_ESP32_XTAL_FREQ_26 is not set
+CONFIG_ESP32_XTAL_FREQ_40=y
+# CONFIG_ESP32_XTAL_FREQ_AUTO is not set
+CONFIG_ESP32_XTAL_FREQ=40
+CONFIG_ESP32_PHY_CALIBRATION_AND_DATA_STORAGE=y
+# CONFIG_ESP32_PHY_INIT_DATA_IN_PARTITION is not set
+CONFIG_ESP32_PHY_MAX_WIFI_TX_POWER=20
+CONFIG_ESP32_PHY_MAX_TX_POWER=20
+# CONFIG_REDUCE_PHY_TX_POWER is not set
+# CONFIG_ESP32_REDUCE_PHY_TX_POWER is not set
+# CONFIG_SPIRAM_SUPPORT is not set
+# CONFIG_ESP32_SPIRAM_SUPPORT is not set
+# CONFIG_ESP32_DEFAULT_CPU_FREQ_80 is not set
+# CONFIG_ESP32_DEFAULT_CPU_FREQ_160 is not set
+CONFIG_ESP32_DEFAULT_CPU_FREQ_240=y
+CONFIG_ESP32_DEFAULT_CPU_FREQ_MHZ=240
+CONFIG_TRACEMEM_RESERVE_DRAM=0x0
+# CONFIG_ESP32_PANIC_PRINT_HALT is not set
+CONFIG_ESP32_PANIC_PRINT_REBOOT=y
+# CONFIG_ESP32_PANIC_SILENT_REBOOT is not set
+# CONFIG_ESP32_PANIC_GDBSTUB is not set
+CONFIG_SYSTEM_EVENT_QUEUE_SIZE=32
+CONFIG_SYSTEM_EVENT_TASK_STACK_SIZE=2304
+CONFIG_MAIN_TASK_STACK_SIZE=3584
+CONFIG_CONSOLE_UART_DEFAULT=y
+# CONFIG_CONSOLE_UART_CUSTOM is not set
+# CONFIG_CONSOLE_UART_NONE is not set
+# CONFIG_ESP_CONSOLE_UART_NONE is not set
+CONFIG_CONSOLE_UART=y
+CONFIG_CONSOLE_UART_NUM=0
+CONFIG_CONSOLE_UART_BAUDRATE=115200
+CONFIG_INT_WDT=y
+CONFIG_INT_WDT_TIMEOUT_MS=300
+CONFIG_INT_WDT_CHECK_CPU1=y
+CONFIG_TASK_WDT=y
+CONFIG_ESP_TASK_WDT=y
+# CONFIG_TASK_WDT_PANIC is not set
+CONFIG_TASK_WDT_TIMEOUT_S=5
+CONFIG_TASK_WDT_CHECK_IDLE_TASK_CPU0=y
+CONFIG_TASK_WDT_CHECK_IDLE_TASK_CPU1=y
+# CONFIG_ESP32_DEBUG_STUBS_ENABLE is not set
+CONFIG_ESP32_DEBUG_OCDAWARE=y
+CONFIG_BROWNOUT_DET=y
+CONFIG_ESP32_BROWNOUT_DET=y
+CONFIG_BROWNOUT_DET_LVL_SEL_0=y
+CONFIG_ESP32_BROWNOUT_DET_LVL_SEL_0=y
+# CONFIG_BROWNOUT_DET_LVL_SEL_1 is not set
+# CONFIG_ESP32_BROWNOUT_DET_LVL_SEL_1 is not set
+# CONFIG_BROWNOUT_DET_LVL_SEL_2 is not set
+# CONFIG_ESP32_BROWNOUT_DET_LVL_SEL_2 is not set
+# CONFIG_BROWNOUT_DET_LVL_SEL_3 is not set
+# CONFIG_ESP32_BROWNOUT_DET_LVL_SEL_3 is not set
+# CONFIG_BROWNOUT_DET_LVL_SEL_4 is not set
+# CONFIG_ESP32_BROWNOUT_DET_LVL_SEL_4 is not set
+# CONFIG_BROWNOUT_DET_LVL_SEL_5 is not set
+# CONFIG_ESP32_BROWNOUT_DET_LVL_SEL_5 is not set
+# CONFIG_BROWNOUT_DET_LVL_SEL_6 is not set
+# CONFIG_ESP32_BROWNOUT_DET_LVL_SEL_6 is not set
+# CONFIG_BROWNOUT_DET_LVL_SEL_7 is not set
+# CONFIG_ESP32_BROWNOUT_DET_LVL_SEL_7 is not set
+CONFIG_BROWNOUT_DET_LVL=0
+CONFIG_ESP32_BROWNOUT_DET_LVL=0
+# CONFIG_DISABLE_BASIC_ROM_CONSOLE is not set
+CONFIG_IPC_TASK_STACK_SIZE=1024
+CONFIG_TIMER_TASK_STACK_SIZE=3584
+CONFIG_SW_COEXIST_ENABLE=y
+# CONFIG_ESP32_ENABLE_COREDUMP_TO_FLASH is not set
+# CONFIG_ESP32_ENABLE_COREDUMP_TO_UART is not set
+CONFIG_ESP32_ENABLE_COREDUMP_TO_NONE=y
+CONFIG_TIMER_TASK_PRIORITY=1
+CONFIG_TIMER_TASK_STACK_DEPTH=2048
+CONFIG_TIMER_QUEUE_LENGTH=10
+# CONFIG_ENABLE_STATIC_TASK_CLEAN_UP_HOOK is not set
+# CONFIG_HAL_ASSERTION_SILIENT is not set
+# CONFIG_L2_TO_L3_COPY is not set
+CONFIG_ESP_GRATUITOUS_ARP=y
+CONFIG_GARP_TMR_INTERVAL=60
+CONFIG_TCPIP_RECVMBOX_SIZE=32
+CONFIG_TCP_MAXRTX=12
+CONFIG_TCP_SYNMAXRTX=12
+CONFIG_TCP_MSS=1440
+CONFIG_TCP_MSL=60000
+CONFIG_TCP_SND_BUF_DEFAULT=5744
+CONFIG_TCP_WND_DEFAULT=5744
+CONFIG_TCP_RECVMBOX_SIZE=6
+CONFIG_TCP_QUEUE_OOSEQ=y
+CONFIG_TCP_OVERSIZE_MSS=y
+# CONFIG_TCP_OVERSIZE_QUARTER_MSS is not set
+# CONFIG_TCP_OVERSIZE_DISABLE is not set
+CONFIG_UDP_RECVMBOX_SIZE=6
+CONFIG_TCPIP_TASK_STACK_SIZE=3072
+CONFIG_TCPIP_TASK_AFFINITY_NO_AFFINITY=y
+# CONFIG_TCPIP_TASK_AFFINITY_CPU0 is not set
+# CONFIG_TCPIP_TASK_AFFINITY_CPU1 is not set
+CONFIG_TCPIP_TASK_AFFINITY=0x7FFFFFFF
+# CONFIG_PPP_SUPPORT is not set
+CONFIG_ESP32_TIME_SYSCALL_USE_RTC_HRT=y
+CONFIG_ESP32_TIME_SYSCALL_USE_RTC_FRC1=y
+# CONFIG_ESP32_TIME_SYSCALL_USE_RTC is not set
+# CONFIG_ESP32_TIME_SYSCALL_USE_HRT is not set
+# CONFIG_ESP32_TIME_SYSCALL_USE_FRC1 is not set
+# CONFIG_ESP32_TIME_SYSCALL_USE_NONE is not set
+CONFIG_ESP32_PTHREAD_TASK_PRIO_DEFAULT=5
+CONFIG_ESP32_PTHREAD_TASK_STACK_SIZE_DEFAULT=3072
+CONFIG_ESP32_PTHREAD_STACK_MIN=768
+CONFIG_ESP32_DEFAULT_PTHREAD_CORE_NO_AFFINITY=y
+# CONFIG_ESP32_DEFAULT_PTHREAD_CORE_0 is not set
+# CONFIG_ESP32_DEFAULT_PTHREAD_CORE_1 is not set
+CONFIG_ESP32_PTHREAD_TASK_CORE_DEFAULT=-1
+CONFIG_ESP32_PTHREAD_TASK_NAME_DEFAULT="pthread"
+CONFIG_SPI_FLASH_WRITING_DANGEROUS_REGIONS_ABORTS=y
+# CONFIG_SPI_FLASH_WRITING_DANGEROUS_REGIONS_FAILS is not set
+# CONFIG_SPI_FLASH_WRITING_DANGEROUS_REGIONS_ALLOWED is not set
+# CONFIG_ESP32_ULP_COPROC_ENABLED is not set
+CONFIG_SUPPRESS_SELECT_DEBUG_OUTPUT=y
+CONFIG_SUPPORT_TERMIOS=y
+CONFIG_SEMIHOSTFS_MAX_MOUNT_POINTS=1
+# End of deprecated options

RT200T_2_ESP32/sdkconfig.ci

+CONFIG_EXAMPLE_WIFI_SSID_PWD_FROM_STDIN=y
+CONFIG_EXAMPLE_FIRMWARE_UPGRADE_URL="FROM_STDIN"
+CONFIG_EXAMPLE_SKIP_COMMON_NAME_CHECK=y
+CONFIG_EXAMPLE_FIRMWARE_UPGRADE_BIND_IF=y
+
+CONFIG_MBEDTLS_TLS_CLIENT_ONLY=y
+CONFIG_COMPILER_OPTIMIZATION_SIZE=y
+CONFIG_EXAMPLE_CONNECT_IPV6=n

RT200T_2_ESP32/sdkconfig.ci.flash_enc_wifi

+CONFIG_EXAMPLE_FIRMWARE_UPGRADE_URL="FROM_STDIN"
+CONFIG_EXAMPLE_SKIP_COMMON_NAME_CHECK=y
+CONFIG_SECURE_FLASH_ENC_ENABLED=y
+CONFIG_SECURE_FLASH_ENCRYPTION_MODE_DEVELOPMENT=y
+CONFIG_SECURE_BOOT_ALLOW_ROM_BASIC=y
+CONFIG_SECURE_BOOT_ALLOW_JTAG=y
+CONFIG_SECURE_FLASH_UART_BOOTLOADER_ALLOW_ENC=y
+CONFIG_SECURE_FLASH_UART_BOOTLOADER_ALLOW_DEC=y
+CONFIG_SECURE_FLASH_UART_BOOTLOADER_ALLOW_CACHE=y
+CONFIG_SECURE_FLASH_REQUIRE_ALREADY_ENABLED=y
+CONFIG_PARTITION_TABLE_OFFSET=0x9000
+CONFIG_EXAMPLE_CONNECT_ETHERNET=n
+CONFIG_EXAMPLE_CONNECT_WIFI=y
+CONFIG_EXAMPLE_WIFI_SSID_PWD_FROM_STDIN=y
+# This is required for nvs encryption (which is enabled by default with flash encryption)
+CONFIG_PARTITION_TABLE_TWO_OTA_ENCRYPTED_NVS=y
+
+CONFIG_MBEDTLS_TLS_CLIENT_ONLY=y
+CONFIG_COMPILER_OPTIMIZATION_SIZE=y
+CONFIG_EXAMPLE_CONNECT_IPV6=n

RT200T_2_ESP32/sdkconfig.ci.on_update_no_sb_ecdsa

+# ECDSA is available only in ESP32
+CONFIG_IDF_TARGET="esp32"
+
+CONFIG_EXAMPLE_FIRMWARE_UPGRADE_URL="FROM_STDIN"
+CONFIG_EXAMPLE_SKIP_COMMON_NAME_CHECK=y
+
+CONFIG_PARTITION_TABLE_OFFSET=0xC000
+
+CONFIG_SECURE_SIGNED_APPS_NO_SECURE_BOOT=y
+CONFIG_SECURE_SIGNED_ON_UPDATE_NO_SECURE_BOOT=y
+CONFIG_SECURE_SIGNED_APPS_ECDSA_SCHEME=y
+CONFIG_SECURE_BOOT_SIGNING_KEY="test/secure_boot_signing_key_ecdsa.pem"
+
+CONFIG_EXAMPLE_CONNECT_ETHERNET=y
+CONFIG_EXAMPLE_CONNECT_WIFI=n
+CONFIG_EXAMPLE_USE_INTERNAL_ETHERNET=y
+CONFIG_EXAMPLE_ETH_PHY_IP101=y
+CONFIG_EXAMPLE_ETH_MDC_GPIO=23
+CONFIG_EXAMPLE_ETH_MDIO_GPIO=18
+CONFIG_EXAMPLE_ETH_PHY_RST_GPIO=5
+CONFIG_EXAMPLE_ETH_PHY_ADDR=1
+CONFIG_EXAMPLE_CONNECT_IPV6=y

RT200T_2_ESP32/sdkconfig.ci.on_update_no_sb_rsa

+# ESP32 supports SIGNED_APPS_RSA_SCHEME only in ECO3
+CONFIG_ESP32_REV_MIN_3=y
+CONFIG_ESP32_REV_MIN=3
+
+CONFIG_EXAMPLE_FIRMWARE_UPGRADE_URL="FROM_STDIN"
+CONFIG_EXAMPLE_SKIP_COMMON_NAME_CHECK=y
+
+CONFIG_PARTITION_TABLE_OFFSET=0xC000
+
+CONFIG_SECURE_SIGNED_APPS_NO_SECURE_BOOT=y
+CONFIG_SECURE_SIGNED_ON_UPDATE_NO_SECURE_BOOT=y
+CONFIG_SECURE_SIGNED_APPS_RSA_SCHEME=y
+CONFIG_SECURE_BOOT_SIGNING_KEY="test/secure_boot_signing_key.pem"
+
+CONFIG_EXAMPLE_CONNECT_ETHERNET=y
+CONFIG_EXAMPLE_CONNECT_WIFI=n
+CONFIG_EXAMPLE_USE_INTERNAL_ETHERNET=y
+CONFIG_EXAMPLE_ETH_PHY_IP101=y
+CONFIG_EXAMPLE_ETH_MDC_GPIO=23
+CONFIG_EXAMPLE_ETH_MDIO_GPIO=18
+CONFIG_EXAMPLE_ETH_PHY_RST_GPIO=5
+CONFIG_EXAMPLE_ETH_PHY_ADDR=1
+
+CONFIG_MBEDTLS_TLS_CLIENT_ONLY=y
+CONFIG_COMPILER_OPTIMIZATION_SIZE=y
+CONFIG_EXAMPLE_CONNECT_IPV6=n

RT200T_2_ESP32/sdkconfig.ci.spiram

+CONFIG_EXAMPLE_FIRMWARE_UPGRADE_URL="FROM_STDIN"
+CONFIG_EXAMPLE_SKIP_COMMON_NAME_CHECK=y
+CONFIG_SPIRAM=y
+CONFIG_SPIRAM_ALLOW_BSS_SEG_EXTERNAL_MEMORY=y
+CONFIG_EXAMPLE_CONNECT_ETHERNET=y
+CONFIG_EXAMPLE_CONNECT_WIFI=n
+CONFIG_EXAMPLE_USE_INTERNAL_ETHERNET=y
+CONFIG_EXAMPLE_ETH_PHY_IP101=y
+CONFIG_EXAMPLE_ETH_MDC_GPIO=23
+CONFIG_EXAMPLE_ETH_MDIO_GPIO=18
+CONFIG_EXAMPLE_ETH_PHY_RST_GPIO=5
+CONFIG_EXAMPLE_ETH_PHY_ADDR=1
+CONFIG_EXAMPLE_CONNECT_IPV6=y

RT200T_2_ESP32/sdkconfig.defaults

+# This file was generated using idf.py save-defconfig. It can be edited manually.
+# Espressif IoT Development Framework (ESP-IDF) Project Minimal Configuration
+#
+CONFIG_BT_ENABLED=y

RT200T_2_ESP32/sdkconfig.defaults.esp32c2

+# This file was generated using idf.py save-defconfig. It can be edited manually.
+# Espressif IoT Development Framework (ESP-IDF) Project Minimal Configuration
+#
+CONFIG_IDF_TARGET="esp32c2"
+CONFIG_BT_ENABLED=y
+# CONFIG_BT_BLE_50_FEATURES_SUPPORTED is not set
+CONFIG_BT_BLE_42_FEATURES_SUPPORTED=y
+# CONFIG_BT_LE_50_FEATURE_SUPPORT is not set
+CONFIG_BT_LE_HCI_EVT_BUF_SIZE=257

RT200T_2_ESP32/sdkconfig.defaults.esp32c3

+# This file was generated using idf.py save-defconfig. It can be edited manually.
+# Espressif IoT Development Framework (ESP-IDF) Project Minimal Configuration
+#
+CONFIG_IDF_TARGET="esp32c3"
+CONFIG_BT_ENABLED=y
+# CONFIG_BT_BLE_50_FEATURES_SUPPORTED is not set
+CONFIG_BT_BLE_42_FEATURES_SUPPORTED=y

RT200T_2_ESP32/sdkconfig.defaults.esp32h2

+# This file was generated using idf.py save-defconfig. It can be edited manually.
+# Espressif IoT Development Framework (ESP-IDF) Project Minimal Configuration
+#
+CONFIG_IDF_TARGET="esp32h2"
+CONFIG_BT_ENABLED=y
+# CONFIG_BT_BLE_50_FEATURES_SUPPORTED is not set
+CONFIG_BT_BLE_42_FEATURES_SUPPORTED=y
+# CONFIG_BT_LE_50_FEATURE_SUPPORT is not set
+CONFIG_RTC_CLK_SRC_EXT_CRYS=y
+CONFIG_RTC_CLK_CAL_CYCLES=576

RT200T_2_ESP32/sdkconfig.defaults.esp32s3

+# This file was generated using idf.py save-defconfig. It can be edited manually.
+# Espressif IoT Development Framework (ESP-IDF) Project Minimal Configuration
+#
+CONFIG_IDF_TARGET="esp32s3"
+CONFIG_BT_ENABLED=y
+# CONFIG_BT_BLE_50_FEATURES_SUPPORTED is not set
+CONFIG_BT_BLE_42_FEATURES_SUPPORTED=y

RT200T_2_ESP32/server_certs/ca_cert.pem

+-----BEGIN CERTIFICATE-----
+MIIDWDCCAkACCQCbF4+gVh/MLjANBgkqhkiG9w0BAQsFADBuMQswCQYDVQQGEwJJ
+TjELMAkGA1UECAwCTUgxDDAKBgNVBAcMA1BVTjEMMAoGA1UECgwDRVNQMQwwCgYD
+VQQLDANFU1AxDDAKBgNVBAMMA0VTUDEaMBgGCSqGSIb3DQEJARYLZXNwQGVzcC5j
+b20wHhcNMjEwNzEyMTIzNjI3WhcNNDEwNzA3MTIzNjI3WjBuMQswCQYDVQQGEwJJ
+TjELMAkGA1UECAwCTUgxDDAKBgNVBAcMA1BVTjEMMAoGA1UECgwDRVNQMQwwCgYD
+VQQLDANFU1AxDDAKBgNVBAMMA0VTUDEaMBgGCSqGSIb3DQEJARYLZXNwQGVzcC5j
+b20wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDhxF/y7bygndxPwiWL
+SwS9LY3uBMaJgup0ufNKVhx+FhGQOu44SghuJAaH3KkPUnt6SOM8jC97/yQuc32W
+ukI7eBZoA12kargSnzdv5m5rZZpd+NznSSpoDArOAONKVlzr25A1+aZbix2mKRbQ
+S5w9o1N2BriQuSzd8gL0Y0zEk3VkOWXEL+0yFUT144HnErnD+xnJtHe11yPO2fEz
+YaGiilh0ddL26PXTugXMZN/8fRVHP50P2OG0SvFpC7vghlLp4VFM1/r3UJnvL6Oz
+3ALc6dhxZEKQucqlpj8l1UegszQToopemtIj0qXTHw2+uUnkUyWIPjPC+wdOAoap
+rFTRAgMBAAEwDQYJKoZIhvcNAQELBQADggEBAItw24y565k3C/zENZlxyzto44ud
+IYPQXN8Fa2pBlLe1zlSIyuaA/rWQ+i1daS8nPotkCbWZyf5N8DYaTE4B0OfvoUPk
+B5uGDmbuk6akvlB5BGiYLfQjWHRsK9/4xjtIqN1H58yf3QNROuKsPAeywWS3Fn32
+3//OpbWaClQePx6udRYMqAitKR+QxL7/BKZQsX+UyShuq8hjphvXvk0BW8ONzuw9
+RcoORxM0FzySYjeQvm4LhzC/P3ZBhEq0xs55aL2a76SJhq5hJy7T/Xz6NFByvlrN
+lFJJey33KFrAf5vnV9qcyWFIo7PYy2VsaaEjFeefr7q3sTFSMlJeadexW2Y=
+-----END CERTIFICATE-----

RT200T_2_ESP32/test/secure_boot_signing_key.pem

+-----BEGIN RSA PRIVATE KEY-----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+-----END RSA PRIVATE KEY-----

RT200T_2_ESP32/test/secure_boot_signing_key_ecdsa.pem

+-----BEGIN EC PRIVATE KEY-----
+MHcCAQEEIOvP45grF4dSM2fWbOAp4W8PgFm30HIZqtNEK13O5hVHoAoGCCqGSM49
+AwEHoUQDQgAE1IL73BARrNpkHj1jG50eHoF2LERCwz1BfbshuAeLcsED5aT92Xgu
+gJvq45LN9p6eBi62ZZwr6Z2ZfX3YB3/8KA==
+-----END EC PRIVATE KEY-----

RT200T_2_ESP32/tutorial/Gatt_Server_Service_Table_Example_Walkthrough.md

+# GATT Server Service Table Example Walkthrough
+
+## Introduction
+
+This document presents a walkthrough of the GATT Server Service Table example code for the ESP32. This example implements a Bluetooth Low Energy (BLE) Generic Attribute (GATT) Server using a table-like data structure to define the server services and characteristics such as the one shown in the figure below Therefore, it demonstrates a practical way to define the server functionality in one place instead of adding services and characteristics one by one. 
+
+This example implements the *Heart Rate Profile* as defined by the [Traditional Profile Specifications](https://www.bluetooth.com/specifications/profiles-overview).
+
+<div align="center"><img src="image/Heart_Rate_Service.png" width = "450" alt="Table-like data structure representing the Heart Rate Service" align=center /> </div>
+
+## Includes
+
+Let’s start by taking a look at the included headers in the [gatts_table_creat_demo.c](../main/gatts_table_creat_demo.c) file:
+
+```c
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "freertos/event_groups.h"
+#include "esp_system.h"
+#include "esp_log.h"
+#include "nvs_flash.h"
+#include "bt.h"
+#include "bta_api.h"
+
+#include "esp_gap_ble_api.h"
+#include "esp_gatts_api.h"
+#include "esp_bt_defs.h"
+#include "esp_bt_main.h"
+#include "esp_bt_main.h"
+#include “gatts_table_creat_demo.h"
+```
+These includes are required for the *FreeRTOS* and underlaying system components to run, including logging functionality and a library to store data in non-volatile flash memory. We are interested in ``bt.h``, ``esp_bt_main.h``, ``esp_gap_ble_api.h`` and ``esp_gatts_api.h`` which expose the BLE APIs required to implement this example.
+
+* ``bt.h``: implements BT controller and VHCI configuration procedures from the host side.
+* ``esp_bt_main.h``: implements initialization and enabling of the Bluedroid stack.
+* ``esp_gap_ble_api.h``: implements GAP configuration such as advertising and connection parameters.
+* ``esp_gatts_api.h``: implements GATT Server configuration such as creating services and characteristics.
+
+## Service Table
+
+The header file [gatts_table_creat_demo.h](../main/gatts_table_creat_demo.h) is where an enumeration of the services and characteristics is created:
+
+```c
+enum
+{
+    HRS_IDX_SVC,
+
+    HRS_IDX_HR_MEAS_CHAR,
+    HRS_IDX_HR_MEAS_VAL,
+    HRS_IDX_HR_MEAS_NTF_CFG,
+
+    HRS_IDX_BOBY_SENSOR_LOC_CHAR,
+    HRS_IDX_BOBY_SENSOR_LOC_VAL,
+
+    HRS_IDX_HR_CTNL_PT_CHAR,
+    HRS_IDX_HR_CTNL_PT_VAL,
+
+    HRS_IDX_NB,
+};
+```
+The enumeration elements are set up in the same order as the Heart Rate Profile attributes, starting with the service followed by the characteristics of that service. In addition, the Heart Rate Measurement characteristic has a Client Characteristic Configuration (CCC) descriptor which is an additional attribute that describes if the characteristic has notifications enabled. The enumeration index can be used to identify each element later when creating the actual attributes table. In summary, the elements are described as follows:
+
+* ``HRS_IDX_SVC``: Heart Rate Service index
+* ``HRS_IDX_HR_MEAS_CHAR``: Heart Rate Measurement characteristic index
+* ``HRS_IDX_HR_MEAS_VAL``: Heart Rate Measurement characteristic value index
+* ``HRS_IDX_HR_MEAS_NTF_CFG``: Heart Rate Measurement notifications configuration (CCC) index
+* ``HRS_IDX_BOBY_SENSOR_LOC_CHAR``: Heart Rate Body Sensor Location characteristic index
+* ``HRS_IDX_BOBY_SENSOR_LOC_VAL``: Heart Rate Body Sensor Location characteristic value index
+* ``HRS_IDX_HR_CTNL_PT_CHAR``: Heart Rate Control Point characteristic index
+* ``HRS_IDX_HR_CTNL_PT_VAL``: Heart Rate Control Point characteristic value index
+* ``HRS_IDX_NB``: Number of table elements.
+
+## Main Entry Point
+
+The entry point to this example is the ``app_main()`` function:
+
+```c
+void app_main()
+{
+    esp_err_t ret;
+
+    // Initialize NVS.
+    ret = nvs_flash_init();
+    if (ret == ESP_ERR_NVS_NO_FREE_PAGES || ret == ESP_ERR_NVS_NEW_VERSION_FOUND) {
+        ESP_ERROR_CHECK(nvs_flash_erase());
+        ret = nvs_flash_init();
+    }
+    ESP_ERROR_CHECK( ret );
+
+    esp_bt_controller_config_t bt_cfg = BT_CONTROLLER_INIT_CONFIG_DEFAULT();
+    ret = esp_bt_controller_init(&bt_cfg);
+    if (ret) {
+        ESP_LOGE(GATTS_TABLE_TAG, "%s enable controller failed\n", __func__);
+        return;
+    }
+
+    ret = esp_bt_controller_enable(ESP_BT_MODE_BLE);
+    if (ret) {
+        ESP_LOGE(GATTS_TABLE_TAG, "%s enable controller failed\n", __func__);
+        return;
+    }
+
+    ESP_LOGI(GATTS_TABLE_TAG, "%s init bluetooth\n", __func__);
+    ret = esp_bluedroid_init();
+    if (ret) {
+        ESP_LOGE(GATTS_TABLE_TAG, "%s init bluetooth failed\n", __func__);
+        return;
+    }
+    ret = esp_bluedroid_enable();
+    if (ret) {
+        ESP_LOGE(GATTS_TABLE_TAG, "%s enable bluetooth failed\n", __func__);
+        return;
+    }
+
+    esp_ble_gatts_register_callback(gatts_event_handler);
+    esp_ble_gap_register_callback(gap_event_handler);
+    esp_ble_gatts_app_register(ESP_HEART_RATE_APP_ID);
+    return;
+}
+```
+
+The main function starts by initializing the non-volatile storage library in order to be able to save parameters in flash memory.
+
+```c
+ret = nvs_flash_init();
+```
+
+## BT Controller and Stack Initialization
+
+See this section in [GATT Server Example Walkthrough](../../gatt_server/tutorial/Gatt_Server_Example_Walkthrough.md).
+
+
+## Application Profiles
+
+This example implements one Application Profile for the Heart Rate Service. An Application Profile is a way to group functionality which is designed to be used by one client application, for example one smartphone mobile app. In this way, different types of profiles can be accommodated in one server. The Application Profile ID, which is an user-assigned number to identify each profile, is used to register the profile in the stack, in this example the ID is 0x55. 
+
+```c
+#define HEART_PROFILE_NUM                       1
+#define HEART_PROFILE_APP_IDX                   0
+#define ESP_HEART_RATE_APP_ID                   0x55
+```
+
+The profiles are stored in the ``heart_rate_profile_tab`` array. Since there is only one profile in this example, one element is stored in the array with index zero as defined by the ``HEART_PROFILE_APP_IDX``. Additionally, the profile event handler callback function is initialized. Each application on the GATT server uses a different interface, represented by the gatts_if parameter. For initialization, this parameter is set to ``ESP_GATT_IF_NONE``, later when the application is registered, the gatts_if parameter is updated with the corresponding interface generated by the stack.
+
+```c
+/* One gatt-based profile one app_id and one gatts_if, this array will store the gatts_if returned by ESP_GATTS_REG_EVT */
+static struct gatts_profile_inst heart_rate_profile_tab[HEART_PROFILE_NUM] = {
+    [HEART_PROFILE_APP_IDX] = {
+        .gatts_cb = gatts_profile_event_handler,
+        .gatts_if = ESP_GATT_IF_NONE,       /* Not get the gatt_if, so initial is ESP_GATT_IF_NONE */
+    },
+
+};
+```
+
+The application registration takes place inside ``app_main()`` using the ``esp_ble_gatts_app_register()`` function:
+
+```c
+esp_ble_gatts_app_register(ESP_HEART_RATE_APP_ID);
+```
+The ``ESP_HEART_RATE_APP_ID`` serves as an application ID, distinguishing between various application layer callbacks. This identifier corresponds to the ``app_id`` found within the ``gatts_reg_evt_param`` in ESP_GATTS_REG_EVT.
+
+## Setting GAP Parameters
+
+The register application event is the first one that is triggered during the lifetime of the program. This example uses this event to configure advertising parameters upon registration in the profile event handler. The functions used to achieve this are:
+
+* ``esp_ble_gap_set_device_name()``: used to set the advertised device name.
+* ``esp_ble_gap_config_adv_data()``: used to configure standard advertising data.
+
+The function used to configure standard Bluetooth Specification advertisement parameters is ``esp_ble_gap_config_adv_data()`` which takes a pointer to an ``esp_ble_adv_data_t`` structure. The ``esp_ble_adv_data_t`` data structure for advertising data has the following definition:
+
+```c
+typedef struct {
+    bool set_scan_rsp;    /*!< Set this advertising data as scan response or not*/
+    bool include_name;    /*!< Advertising data include device name or not */
+    bool include_txpower; /*!< Advertising data include TX power */
+    int min_interval;     /*!< Advertising data show slave preferred connection min interval */
+    int max_interval;     /*!< Advertising data show slave preferred connection max interval */
+    int appearance;       /*!< External appearance of device */
+    uint16_t manufacturer_len; /*!< Manufacturer data length */
+    uint8_t *p_manufacturer_data; /*!< Manufacturer data point */
+    uint16_t service_data_len;    /*!< Service data length */
+    uint8_t *p_service_data;      /*!< Service data point */
+    uint16_t service_uuid_len;    /*!< Service uuid length */
+    uint8_t *p_service_uuid;      /*!< Service uuid array point */
+    uint8_t flag;         /*!< Advertising flag of discovery mode, see BLE_ADV_DATA_FLAG detail */
+} esp_ble_adv_data_t;
+```
+
+In this example, the structure is initialized as follows:
+
+```c
+static esp_ble_adv_data_t heart_rate_adv_config = {
+    .set_scan_rsp = false,
+    .include_name = true,
+    .include_txpower = true,
+    .min_interval = 0x0006,
+    .max_interval = 0x0010,
+    .appearance = 0x00,
+    .manufacturer_len = 0, //TEST_MANUFACTURER_DATA_LEN,
+    .p_manufacturer_data =  NULL, //&test_manufacturer[0],
+    .service_data_len = 0,
+    .p_service_data = NULL,
+    .service_uuid_len = sizeof(heart_rate_service_uuid),
+    .p_service_uuid = heart_rate_service_uuid,
+    .flag = (ESP_BLE_ADV_FLAG_GEN_DISC | ESP_BLE_ADV_FLAG_BREDR_NOT_SPT),
+};
+```
+
+The minimum and maximum slave preferred connection intervals are set in units of 1.25 ms. In this example, the minimum slave preferred connection interval is defined as 0x0006 * 1.25 ms = 7.5 ms and the maximum slave preferred connection interval is initialized as 0x0010 * 1.25 ms = 20 ms.
+
+An advertising payload can be up to 31 bytes of data. It is possible that some of the parameters surpass the 31-byte advertisement packet limit which causes the stack to cut the message and leave some of the parameters out. To solve this, usually the longer parameters are stored in the scan response, which can be configured using the same ``esp_ble_gap_config_adv_data()`` function and an additional esp_ble_adv_data_t type structure with the .set_scan_rsp parameter is set to true. Finally, to set the device name the ``esp_ble_gap_set_device_name()`` function is used. The registering event handler is shown as follows:
+
+```c
+static void gatts_profile_event_handler(esp_gatts_cb_event_t event, 
+esp_gatt_if_t gatts_if, esp_ble_gatts_cb_param_t *param)
+{
+    ESP_LOGE(GATTS_TABLE_TAG, "event = %x\n",event);
+    switch (event) {
+        case ESP_GATTS_REG_EVT:
+            ESP_LOGI(GATTS_TABLE_TAG, "%s %d\n", __func__, __LINE__);
+            esp_ble_gap_set_device_name(SAMPLE_DEVICE_NAME);
+            ESP_LOGI(GATTS_TABLE_TAG, "%s %d\n", __func__, __LINE__);
+            esp_ble_gap_config_adv_data(&heart_rate_adv_config);
+            ESP_LOGI(GATTS_TABLE_TAG, "%s %d\n", __func__, __LINE__);
+…
+```
+
+## GAP Event Handler
+
+Once the advertising data have been set, the ``ESP_GAP_BLE_ADV_DATA_SET_COMPLETE_EVT`` is triggered and managed by the GAP event handler. Moreover, an ``ESP_GAP_BLE_SCAN_RSP_DATA_SET_COMPLETE_EVT`` is triggered as well if the scan response is also set. Once the configuration of the advertising and scan response data has been set, the handler can use any of these events to start advertising, which is done using the ``esp_ble_gap_start_advertising()`` function:
+
+```c
+static void gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param)
+{   
+    ESP_LOGE(GATTS_TABLE_TAG, "GAP_EVT, event %d\n", event);
+    
+    switch (event) {
+    case ESP_GAP_BLE_ADV_DATA_SET_COMPLETE_EVT:
+        esp_ble_gap_start_advertising(&heart_rate_adv_params);
+        break;
+    case ESP_GAP_BLE_ADV_START_COMPLETE_EVT:
+        //advertising start complete event to indicate advertising start successfully or failed
+        if (param->adv_start_cmpl.status != ESP_BT_STATUS_SUCCESS) {
+            ESP_LOGE(GATTS_TABLE_TAG, "Advertising start failed\n");
+        }
+        break;
+    default:
+        break;
+    }
+}
+```
+
+The function to start advertising takes a structure of type ``esp_ble_adv_params_t`` with the advertising parameters required.
+
+```c
+/// Advertising parameters
+typedef struct {
+    uint16_t adv_int_min; /*!< Minimum advertising interval for undirected and low duty cycle directed advertising.
+    Range: 0x0020 to 0x4000
+    Default: N = 0x0800 (1.28 second)
+    Time = N * 0.625 msec
+    Time Range: 20 ms to 10.24 sec */
+    uint16_t adv_int_max; /*!< Maximum advertising interval for undirected and low duty cycle directed advertising.
+    Range: 0x0020 to 0x4000
+    Default: N = 0x0800 (1.28 second)
+    Time = N * 0.625 msec
+    Time Range: 20 ms to 10.24 sec */
+    esp_ble_adv_type_t adv_type;            /*!< Advertising type */
+    esp_ble_addr_type_t own_addr_type;      /*!< Owner bluetooth device address type */
+    esp_bd_addr_t peer_addr;                /*!< Peer device bluetooth device address */
+    esp_ble_addr_type_t peer_addr_type;     /*!< Peer device bluetooth device address type */
+    esp_ble_adv_channel_t channel_map;      /*!< Advertising channel map */
+    esp_ble_adv_filter_t adv_filter_policy; /*!< Advertising filter policy */
+} esp_ble_adv_params_t;
+```
+
+Note that ``esp_ble_gap_config_adv_data()`` configures the data that is advertised to the client and takes an ``esp_ble_adv_data_t structure``, while ``esp_ble_gap_start_advertising()`` makes the server to actually start advertising and takes an ``esp_ble_adv_params_t`` structure. The advertising data is the information that is shown to the client, while the advertising parameters are the configuration required by the BLE stack to execute.
+
+For this example, the advertisement parameters are initialized as follows:
+
+```c
+static esp_ble_adv_params_t heart_rate_adv_params = {
+    .adv_int_min        = 0x20,
+    .adv_int_max        = 0x40,
+    .adv_type           = ADV_TYPE_IND,
+    .own_addr_type      = BLE_ADDR_TYPE_PUBLIC,
+    //.peer_addr            =
+    //.peer_addr_type       =
+    .channel_map        = ADV_CHNL_ALL,
+    .adv_filter_policy = ADV_FILTER_ALLOW_SCAN_ANY_CON_ANY,
+};
+```
+
+These parameters configure the advertising interval between 20 ms to 40 ms. The advertisement is of type ADV_IND, which is generic, not directed to a particular central device and advertises the server as connectable. The address type is public, uses all channels and allows both scan and connection requests from any central.
+
+If the advertising started successfully, an ``ESP_GAP_BLE_ADV_START_COMPLETE_EVT`` event is generated which in this example is used to check if the advertising status is indeed advertising or otherwise print an error message.
+
+```c
+…
+    case ESP_GAP_BLE_ADV_START_COMPLETE_EVT:
+        //advertising start complete event to indicate advertising start successfully or failed
+        if (param->adv_start_cmpl.status != ESP_BT_STATUS_SUCCESS) {
+            ESP_LOGE(GATTS_TABLE_TAG, "Advertising start failed\n");
+        }
+        break;
+…
+```
+
+## GATT Event Handlers
+
+When an Application Profile is registered, an ``ESP_GATTS_REG_EVT`` event is triggered. The parameters of the ``ESP_GATTS_REG_EVT`` are:
+
+```c
+esp_gatt_status_t status;    /*!< Operation status */
+uint16_t app_id;             /*!< Application id which input in register API */
+```
+
+In addition to the previous parameters, the event also contains the GATT interface assigned by the BLE stack. The event is captured by the ``gatts_event_handler()`` which stores the generated interface in the profile table and then forwards it to the corresponding profile event handler.
+
+```c
+static void gatts_event_handler(esp_gatts_cb_event_t event, esp_gatt_if_t gatts_if, esp_ble_gatts_cb_param_t *param)
+{
+    ESP_LOGI(GATTS_TABLE_TAG, "EVT %d, gatts if %d\n", event, gatts_if);
+
+    /* If event is register event, store the gatts_if for each profile */
+    if (event == ESP_GATTS_REG_EVT) {
+        if (param->reg.status == ESP_GATT_OK) {
+            heart_rate_profile_tab[HEART_PROFILE_APP_IDX].gatts_if = gatts_if;
+        } else {
+            ESP_LOGI(GATTS_TABLE_TAG, "Reg app failed, app_id %04x, status %d\n",
+                    param->reg.app_id,
+                    param->reg.status);
+            return;
+        }
+    }
+
+    do {
+        int idx;
+        for (idx = 0; idx < HEART_PROFILE_NUM; idx++) {
+            if (gatts_if == ESP_GATT_IF_NONE || /* ESP_GATT_IF_NONE, not specify a certain gatt_if, need to call every profile cb function */
+            gatts_if == heart_rate_profile_tab[idx].gatts_if) {
+                if (heart_rate_profile_tab[idx].gatts_cb) {
+                    heart_rate_profile_tab[idx].gatts_cb(event, gatts_if, param);
+                }
+            }
+        }
+    } while (0);
+}
+```
+
+## Creating Services and Characteristics with the Attribute Table
+
+The register event is used to create a table of profile attributes by employing the ``esp_ble_gatts_create_attr_tab()`` function. This function takes an argument of type ``esp_gatts_attr_db_t`` which corresponds to a look up table keyed by the enumeration values defined in the header file.
+
+The ``esp_gatts_attr_db_t`` structure has two members:
+
+```c
+esp_attr_control_t    attr_control;       /*!< The attribute control type*/
+esp_attr_desc_t       att_desc;           /*!< The attribute type*/
+```
+
+The attr_control is the auto-respond parameter which can be set as ``ESP_GATT_AUTO_RSP`` to allow the BLE stack to take care of responding messages when read or write events arrive. The other option is ``ESP_GATT_RSP_BY_APP`` which allows to manually respond to messages using the ``esp_ble_gatts_send_response()`` function.
+
+The ``att_desc`` is the attribute description which is made of:
+
+```c
+uint16_t uuid_length;      /*!< UUID length */  
+uint8_t  *uuid_p;          /*!< UUID value */  
+uint16_t perm;             /*!< Attribute permission */        
+uint16_t max_length;       /*!< Maximum length of the element*/    
+uint16_t length;           /*!< Current length of the element*/    
+uint8_t  *value;           /*!< Element value array*/ 
+```
+
+For example, the first element of the table in this example is the service attribute:
+
+```c
+[HRS_IDX_SVC]                       =
+    {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&primary_service_uuid, ESP_GATT_PERM_READ,
+      sizeof(uint16_t), sizeof(heart_rate_svc), (uint8_t *)&heart_rate_svc}},
+```
+
+The initialization values are:
+
+* ``[HRS_IDX_SVC]``: Named or designated initializer in the enum table.
+* ``ESP_GATT_AUTO_RSP``: Auto respond configuration, set to respond automatically by the stack.
+* ``ESP_UUID_LEN_16``: UUID length set to 16 bits.
+* ``(uint8_t *)&primary_service_uuid``: UUID to identify the service as a primary one (0x2800).
+* ``ESP_GATT_PERM_READ``: Read Permission for the service.
+* ``sizeof(uint16_t)``: Maximum length of the service UUID (16 bits).
+* ``sizeof(heart_rate_svc)``: Current service length set to the size of the variable *heart_rate_svc*, which is 16 bits.
+* ``(uint8_t *)&heart_rate_svc``: Service attribute value set to the variable *heart_rate_svc* which contains the Heart Rate Service UUID (0x180D).
+
+The rest of the attributes is initialized in the same way. Some attributes also have the *NOTIFY* property which is set by ``&char_prop_notify``. The complete table structure is initialized as follows:
+
+```c
+/// Full HRS Database Description - Used to add attributes into the database
+static const esp_gatts_attr_db_t heart_rate_gatt_db[HRS_IDX_NB] =
+{
+    // Heart Rate Service Declaration
+    [HRS_IDX_SVC]                       =
+    {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&primary_service_uuid, ESP_GATT_PERM_READ,
+      sizeof(uint16_t), sizeof(heart_rate_svc), (uint8_t *)&heart_rate_svc}},
+
+    // Heart Rate Measurement Characteristic Declaration
+    [HRS_IDX_HR_MEAS_CHAR]            =
+    {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_declaration_uuid, ESP_GATT_PERM_READ,
+      CHAR_DECLARATION_SIZE,CHAR_DECLARATION_SIZE, (uint8_t *)&char_prop_notify}},
+
+    // Heart Rate Measurement Characteristic Value
+    [HRS_IDX_HR_MEAS_VAL]               =
+    {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&heart_rate_meas_uuid, ESP_GATT_PERM_READ,
+      HRPS_HT_MEAS_MAX_LEN,0, NULL}},
+
+    // Heart Rate Measurement Characteristic - Client Characteristic Configuration Descriptor
+    [HRS_IDX_HR_MEAS_NTF_CFG]           =
+    {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_client_config_uuid, ESP_GATT_PERM_READ|ESP_GATT_PERM_WRITE,
+      sizeof(uint16_t),sizeof(heart_measurement_ccc), (uint8_t *)heart_measurement_ccc}},
+
+    // Body Sensor Location Characteristic Declaration
+    [HRS_IDX_BOBY_SENSOR_LOC_CHAR]  =
+    {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_declaration_uuid, ESP_GATT_PERM_READ,
+      CHAR_DECLARATION_SIZE,CHAR_DECLARATION_SIZE, (uint8_t *)&char_prop_read}},
+
+    // Body Sensor Location Characteristic Value
+    [HRS_IDX_BOBY_SENSOR_LOC_VAL]   =
+    {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&body_sensor_location_uuid, ESP_GATT_PERM_READ,
+      sizeof(uint8_t), sizeof(body_sensor_loc_val), (uint8_t *)body_sensor_loc_val}},
+
+    // Heart Rate Control Point Characteristic Declaration
+    [HRS_IDX_HR_CTNL_PT_CHAR]          =
+    {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_declaration_uuid, ESP_GATT_PERM_READ,
+      CHAR_DECLARATION_SIZE,CHAR_DECLARATION_SIZE, (uint8_t *)&char_prop_read_write}},
+
+    // Heart Rate Control Point Characteristic Value
+    [HRS_IDX_HR_CTNL_PT_VAL]             =
+    {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&heart_rate_ctrl_point, ESP_GATT_PERM_WRITE|ESP_GATT_PERM_READ,
+      sizeof(uint8_t), sizeof(heart_ctrl_point), (uint8_t *)heart_ctrl_point}},
+};
+```
+
+## Starting the Service
+When the attribute table is created, an ``ESP_GATTS_CREAT_ATTR_TAB_EVT`` event is triggered. This event has the following parameters:
+
+```c
+esp_gatt_status_t status;    /*!< Operation status */
+esp_bt_uuid_t svc_uuid;      /*!< Service uuid type */
+uint16_t num_handle;         /*!< The number of the attribute handle to be added to the gatts database */
+uint16_t *handles;           /*!< The number to the handles */
+```
+
+This example uses this event to print information and to check that the size of the created table equals the number of elements in the enumeration HRS_IDX_NB. If the table is correctly created, the attribute handles are copied into the handle table heart_rate_handle_table and the service is started using the ``esp_ble_gatts_start_service()`` function:
+
+```c
+case ESP_GATTS_CREAT_ATTR_TAB_EVT:{
+        ESP_LOGI(GATTS_TABLE_TAG, "The number handle =%x\n",param->add_attr_tab.num_handle);
+        if (param->add_attr_tab.status != ESP_GATT_OK){
+            ESP_LOGE(GATTS_TABLE_TAG, "Create attribute table failed, error code=0x%x", param->add_attr_tab.status);
+        }
+        else if (param->add_attr_tab.num_handle != HRS_IDX_NB){
+            ESP_LOGE(GATTS_TABLE_TAG, "Create attribute table abnormally, num_handle (%d) \
+                    doesn't equal to HRS_IDX_NB(%d)", param->add_attr_tab.num_handle, HRS_IDX_NB);
+        }
+        else {
+            memcpy(heart_rate_handle_table, param->add_attr_tab.handles, sizeof(heart_rate_handle_table));
+            esp_ble_gatts_start_service(heart_rate_handle_table[HRS_IDX_SVC]);
+        }
+        break;
+```
+
+The handles stored in the handles pointer of the event parameters are numbers that identify each attribute. The handles can be used to know which characteristic is being read or written to, therefore they can be passed around and to upper layers of the application to handle different actions. 
+
+Finally, the heart_rate_handle_table contains the Application Profile in the form of a structure with information about the attribute parameters as well as GATT interface, connection ID, permissions and application ID. The profile structure is shown as follows, note that not all members are used in this example:
+
+```c
+struct gatts_profile_inst {
+    esp_gatts_cb_t gatts_cb;
+    uint16_t gatts_if;
+    uint16_t app_id;
+    uint16_t conn_id;
+    uint16_t service_handle;
+    esp_gatt_srvc_id_t service_id;
+    uint16_t char_handle;
+    esp_bt_uuid_t char_uuid;
+    esp_gatt_perm_t perm;
+    esp_gatt_char_prop_t property;
+    uint16_t descr_handle;
+    esp_bt_uuid_t descr_uuid;
+};
+```
+
+## Conclusion
+This document explains the work flow of the GATT Server Service Table example code that implements a Heart Rate Profile. This example begins by defining a table of attributes which include all the services and characteristics of the server, then it registers the Application Profile which triggers events that are used to configure GAP parameters and to create the service table. A service table is initialized with all the parameters required for each attribute and the service is started. This example shows a practical way of defining the server attributes by using a table instead of adding characteristic one by one.
+
+
+