[
    {
        "children": [],
        "depends_on": null,
        "help": null,
        "id": "IDF_CMAKE",
        "name": "IDF_CMAKE",
        "range": null,
        "title": null,
        "type": "bool"
    },
    {
        "children": [],
        "depends_on": null,
        "help": null,
        "id": "IDF_ENV_FPGA",
        "name": "IDF_ENV_FPGA",
        "range": null,
        "title": null,
        "type": "bool"
    },
    {
        "children": [],
        "depends_on": null,
        "help": null,
        "id": "IDF_TARGET_ARCH_RISCV",
        "name": "IDF_TARGET_ARCH_RISCV",
        "range": null,
        "title": null,
        "type": "bool"
    },
    {
        "children": [],
        "depends_on": null,
        "help": null,
        "id": "IDF_TARGET_ARCH_XTENSA",
        "name": "IDF_TARGET_ARCH_XTENSA",
        "range": null,
        "title": null,
        "type": "bool"
    },
    {
        "children": [],
        "depends_on": null,
        "help": null,
        "id": "IDF_TARGET",
        "name": "IDF_TARGET",
        "range": null,
        "title": null,
        "type": "string"
    },
    {
        "children": [],
        "depends_on": null,
        "help": null,
        "id": "IDF_TARGET_ESP32",
        "name": "IDF_TARGET_ESP32",
        "range": null,
        "title": null,
        "type": "bool"
    },
    {
        "children": [],
        "depends_on": null,
        "help": null,
        "id": "IDF_TARGET_ESP32S2",
        "name": "IDF_TARGET_ESP32S2",
        "range": null,
        "title": null,
        "type": "bool"
    },
    {
        "children": [],
        "depends_on": null,
        "help": null,
        "id": "IDF_TARGET_ESP32S3",
        "name": "IDF_TARGET_ESP32S3",
        "range": null,
        "title": null,
        "type": "bool"
    },
    {
        "children": [
            {
                "children": [],
                "depends_on": "<choice IDF_TARGET_ESP32S3_BETA_VERSION>",
                "help": null,
                "id": "IDF_TARGET_ESP32S3_BETA_VERSION_2",
                "name": "IDF_TARGET_ESP32S3_BETA_VERSION_2",
                "range": null,
                "title": "ESP32-S3 beta2",
                "type": "bool"
            }
        ],
        "depends_on": "IDF_TARGET_ESP32S3",
        "help": "Currently ESP32-S3 has several beta versions for internal use only.\nSelect the one that matches your chip model.",
        "id": "esp32-s3-beta-version",
        "name": "IDF_TARGET_ESP32S3_BETA_VERSION",
        "title": "ESP32-S3 beta version",
        "type": "choice"
    },
    {
        "children": [],
        "depends_on": null,
        "help": null,
        "id": "IDF_TARGET_ESP32C3",
        "name": "IDF_TARGET_ESP32C3",
        "range": null,
        "title": null,
        "type": "bool"
    },
    {
        "children": [],
        "depends_on": null,
        "help": null,
        "id": "IDF_FIRMWARE_CHIP_ID",
        "name": "IDF_FIRMWARE_CHIP_ID",
        "range": null,
        "title": null,
        "type": "hex"
    },
    {
        "children": [
            {
                "children": [],
                "depends_on": null,
                "help": "The prefix/path that is used to call the toolchain. The default setting assumes\na crosstool-ng gcc setup that is in your PATH.",
                "id": "SDK_TOOLPREFIX",
                "name": "SDK_TOOLPREFIX",
                "range": null,
                "title": "Compiler toolchain path/prefix",
                "type": "string"
            },
            {
                "children": [],
                "depends_on": "!IDF_CMAKE",
                "help": "The executable name/path that is used to run python.\n\n(Note: This option is used with the legacy GNU Make build system only.)",
                "id": "SDK_PYTHON",
                "name": "SDK_PYTHON",
                "range": null,
                "title": "Python interpreter",
                "type": "string"
            },
            {
                "children": [],
                "depends_on": "!IDF_CMAKE",
                "help": "Adds --warn-undefined-variables to MAKEFLAGS. This causes make to\nprint a warning any time an undefined variable is referenced.\n\nThis option helps find places where a variable reference is misspelled\nor otherwise missing, but it can be unwanted if you have Makefiles which\ndepend on undefined variables expanding to an empty string.\n\n(Note: this option is used with the legacy GNU Make build system only.)",
                "id": "SDK_MAKE_WARN_UNDEFINED_VARIABLES",
                "name": "SDK_MAKE_WARN_UNDEFINED_VARIABLES",
                "range": null,
                "title": "'make' warns on undefined variables",
                "type": "bool"
            },
            {
                "children": [],
                "depends_on": null,
                "help": "Enable this option in case you have a custom toolchain which supports time_t wide 64-bits.\nThis option checks time_t is 64-bits and disables ROM time functions\nto use the time functions from the toolchain instead.\nThis option allows resolving the Y2K38 problem.\nSee \"Setup Linux Toolchain from Scratch\" to build\na custom toolchain which supports 64-bits time_t.\n\nNote: ESP-IDF does not currently come with any pre-compiled toolchain\nthat supports 64-bit wide time_t.\nThis will change in a future major release,\nbut currently 64-bit time_t requires a custom built toolchain.",
                "id": "SDK_TOOLCHAIN_SUPPORTS_TIME_WIDE_64_BITS",
                "name": "SDK_TOOLCHAIN_SUPPORTS_TIME_WIDE_64_BITS",
                "range": null,
                "title": "Toolchain supports time_t wide 64-bits",
                "type": "bool"
            }
        ],
        "depends_on": null,
        "id": "sdk-tool-configuration",
        "title": "SDK tool configuration",
        "type": "menu"
    },
    {
        "children": [
            {
                "children": [
                    {
                        "children": [],
                        "depends_on": "<choice APP_BUILD_TYPE>",
                        "help": null,
                        "id": "APP_BUILD_TYPE_APP_2NDBOOT",
                        "name": "APP_BUILD_TYPE_APP_2NDBOOT",
                        "range": null,
                        "title": "Default (binary application + 2nd stage bootloader)",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "<choice APP_BUILD_TYPE>",
                        "help": null,
                        "id": "APP_BUILD_TYPE_ELF_RAM",
                        "name": "APP_BUILD_TYPE_ELF_RAM",
                        "range": null,
                        "title": "ELF file, loadable into RAM (EXPERIMENTAL))",
                        "type": "bool"
                    }
                ],
                "depends_on": null,
                "help": "Select the way the application is built.\n\nBy default, the application is built as a binary file in a format compatible with\nthe ESP-IDF bootloader. In addition to this application, 2nd stage bootloader is\nalso built. Application and bootloader binaries can be written into flash and\nloaded/executed from there.\n\nAnother option, useful for only very small and limited applications, is to only link\nthe .elf file of the application, such that it can be loaded directly into RAM over\nJTAG. Note that since IRAM and DRAM sizes are very limited, it is not possible to\nbuild any complex application this way. However for kinds of testing and debugging,\nthis option may provide faster iterations, since the application does not need to be\nwritten into flash.\nNote that at the moment, ESP-IDF does not contain all the startup code required to\ninitialize the CPUs and ROM memory (data/bss). Therefore it is necessary to execute\na bit of ROM code prior to executing the application. A gdbinit file may look as follows (for ESP32):\n\n    # Connect to a running instance of OpenOCD\n    target remote :3333\n    # Reset and halt the target\n    mon reset halt\n    # Run to a specific point in ROM code,\n    #  where most of initialization is complete.\n    thb *0x40007d54\n    c\n    # Load the application into RAM\n    load\n    # Run till app_main\n    tb app_main\n    c\n\nExecute this gdbinit file as follows:\n\n    xtensa-esp32-elf-gdb build/app-name.elf -x gdbinit\n\nExample gdbinit files for other targets can be found in tools/test_apps/system/gdb_loadable_elf/\n\nRecommended sdkconfig.defaults for building loadable ELF files is as follows.\nCONFIG_APP_BUILD_TYPE_ELF_RAM is required, other options help reduce application\nmemory footprint.\n\n    CONFIG_APP_BUILD_TYPE_ELF_RAM=y\n    CONFIG_VFS_SUPPORT_TERMIOS=\n    CONFIG_NEWLIB_NANO_FORMAT=y\n    CONFIG_ESP_SYSTEM_PANIC_PRINT_HALT=y\n    CONFIG_ESP_DEBUG_STUBS_ENABLE=\n    CONFIG_ESP_ERR_TO_NAME_LOOKUP=",
                "id": "build-type-application-build-type",
                "name": "APP_BUILD_TYPE",
                "title": "Application build type",
                "type": "choice"
            },
            {
                "children": [],
                "depends_on": null,
                "help": null,
                "id": "APP_BUILD_GENERATE_BINARIES",
                "name": "APP_BUILD_GENERATE_BINARIES",
                "range": null,
                "title": null,
                "type": "bool"
            },
            {
                "children": [],
                "depends_on": null,
                "help": null,
                "id": "APP_BUILD_BOOTLOADER",
                "name": "APP_BUILD_BOOTLOADER",
                "range": null,
                "title": null,
                "type": "bool"
            },
            {
                "children": [],
                "depends_on": null,
                "help": null,
                "id": "APP_BUILD_USE_FLASH_SECTIONS",
                "name": "APP_BUILD_USE_FLASH_SECTIONS",
                "range": null,
                "title": null,
                "type": "bool"
            }
        ],
        "depends_on": null,
        "id": "build-type",
        "title": "Build type",
        "type": "menu"
    },
    {
        "children": [
            {
                "children": [],
                "depends_on": null,
                "help": "Offset address that 2nd bootloader will be flashed to.\nThe value is determined by the ROM bootloader.\nIt's not configurable in ESP-IDF.",
                "id": "BOOTLOADER_OFFSET_IN_FLASH",
                "name": "BOOTLOADER_OFFSET_IN_FLASH",
                "range": null,
                "title": null,
                "type": "hex"
            },
            {
                "children": [
                    {
                        "children": [],
                        "depends_on": "<choice BOOTLOADER_COMPILER_OPTIMIZATION>",
                        "help": null,
                        "id": "BOOTLOADER_COMPILER_OPTIMIZATION_SIZE",
                        "name": "BOOTLOADER_COMPILER_OPTIMIZATION_SIZE",
                        "range": null,
                        "title": "Size (-Os)",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "<choice BOOTLOADER_COMPILER_OPTIMIZATION>",
                        "help": null,
                        "id": "BOOTLOADER_COMPILER_OPTIMIZATION_DEBUG",
                        "name": "BOOTLOADER_COMPILER_OPTIMIZATION_DEBUG",
                        "range": null,
                        "title": "Debug (-Og)",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "<choice BOOTLOADER_COMPILER_OPTIMIZATION>",
                        "help": null,
                        "id": "BOOTLOADER_COMPILER_OPTIMIZATION_PERF",
                        "name": "BOOTLOADER_COMPILER_OPTIMIZATION_PERF",
                        "range": null,
                        "title": "Optimize for performance (-O2)",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "<choice BOOTLOADER_COMPILER_OPTIMIZATION>",
                        "help": null,
                        "id": "BOOTLOADER_COMPILER_OPTIMIZATION_NONE",
                        "name": "BOOTLOADER_COMPILER_OPTIMIZATION_NONE",
                        "range": null,
                        "title": "Debug without optimization (-O0)",
                        "type": "bool"
                    }
                ],
                "depends_on": null,
                "help": "This option sets compiler optimization level (gcc -O argument)\nfor the bootloader.\n\n- The default \"Size\" setting will add the -0s flag to CFLAGS.\n- The \"Debug\" setting will add the -Og flag to CFLAGS.\n- The \"Performance\" setting will add the -O2 flag to CFLAGS.\n- The \"None\" setting will add the -O0 flag to CFLAGS.\n\nNote that custom optimization levels may be unsupported.",
                "id": "bootloader-config-bootloader-optimization-level",
                "name": "BOOTLOADER_COMPILER_OPTIMIZATION",
                "title": "Bootloader optimization Level",
                "type": "choice"
            },
            {
                "children": [
                    {
                        "children": [],
                        "depends_on": "<choice BOOTLOADER_LOG_LEVEL>",
                        "help": null,
                        "id": "BOOTLOADER_LOG_LEVEL_NONE",
                        "name": "BOOTLOADER_LOG_LEVEL_NONE",
                        "range": null,
                        "title": "No output",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "<choice BOOTLOADER_LOG_LEVEL>",
                        "help": null,
                        "id": "BOOTLOADER_LOG_LEVEL_ERROR",
                        "name": "BOOTLOADER_LOG_LEVEL_ERROR",
                        "range": null,
                        "title": "Error",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "<choice BOOTLOADER_LOG_LEVEL>",
                        "help": null,
                        "id": "BOOTLOADER_LOG_LEVEL_WARN",
                        "name": "BOOTLOADER_LOG_LEVEL_WARN",
                        "range": null,
                        "title": "Warning",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "<choice BOOTLOADER_LOG_LEVEL>",
                        "help": null,
                        "id": "BOOTLOADER_LOG_LEVEL_INFO",
                        "name": "BOOTLOADER_LOG_LEVEL_INFO",
                        "range": null,
                        "title": "Info",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "<choice BOOTLOADER_LOG_LEVEL>",
                        "help": null,
                        "id": "BOOTLOADER_LOG_LEVEL_DEBUG",
                        "name": "BOOTLOADER_LOG_LEVEL_DEBUG",
                        "range": null,
                        "title": "Debug",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "<choice BOOTLOADER_LOG_LEVEL>",
                        "help": null,
                        "id": "BOOTLOADER_LOG_LEVEL_VERBOSE",
                        "name": "BOOTLOADER_LOG_LEVEL_VERBOSE",
                        "range": null,
                        "title": "Verbose",
                        "type": "bool"
                    }
                ],
                "depends_on": null,
                "help": "Specify how much output to see in bootloader logs.",
                "id": "bootloader-config-bootloader-log-verbosity",
                "name": "BOOTLOADER_LOG_LEVEL",
                "title": "Bootloader log verbosity",
                "type": "choice"
            },
            {
                "children": [],
                "depends_on": null,
                "help": null,
                "id": "BOOTLOADER_LOG_LEVEL",
                "name": "BOOTLOADER_LOG_LEVEL",
                "range": null,
                "title": null,
                "type": "int"
            },
            {
                "children": [],
                "depends_on": "IDF_TARGET_ESP32 && (ESPTOOLPY_FLASHMODE_QIO || ESPTOOLPY_FLASHMODE_QOUT)",
                "help": "This setting is only used if the SPI flash pins have been overridden by setting the eFuses\nSPI_PAD_CONFIG_xxx, and the SPI flash mode is QIO or QOUT.\n\nWhen this is the case, the eFuse config only defines 3 of the 4 Quad I/O data pins. The WP pin (aka\nESP32 pin \"SD_DATA_3\" or SPI flash pin \"IO2\") is not specified in eFuse. The same pin is also used\nfor external SPIRAM if it is enabled.\n\nIf this config item is set to N (default), the correct WP pin will be automatically used for any\nEspressif chip or module with integrated flash. If a custom setting is needed, set this config item to\nY and specify the GPIO number connected to the WP.",
                "id": "BOOTLOADER_SPI_CUSTOM_WP_PIN",
                "name": "BOOTLOADER_SPI_CUSTOM_WP_PIN",
                "range": null,
                "title": "Use custom SPI Flash WP Pin when flash pins set in eFuse (read help)",
                "type": "bool"
            },
            {
                "children": [],
                "depends_on": "IDF_TARGET_ESP32 && (ESPTOOLPY_FLASHMODE_QIO || ESPTOOLPY_FLASHMODE_QOUT)",
                "help": "The option \"Use custom SPI Flash WP Pin\" must be set or this value is ignored\n\nIf burning a customized set of SPI flash pins in eFuse and using QIO or QOUT mode for flash, set this\nvalue to the GPIO number of the SPI flash WP pin.",
                "id": "BOOTLOADER_SPI_WP_PIN",
                "name": "BOOTLOADER_SPI_WP_PIN",
                "range": null,
                "title": "Custom SPI Flash WP Pin",
                "type": "int"
            },
            {
                "children": [
                    {
                        "children": [],
                        "depends_on": "!ESPTOOLPY_FLASHFREQ_80M && <choice BOOTLOADER_VDDSDIO_BOOST>",
                        "help": null,
                        "id": "BOOTLOADER_VDDSDIO_BOOST_1_8V",
                        "name": "BOOTLOADER_VDDSDIO_BOOST_1_8V",
                        "range": null,
                        "title": "1.8V",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "<choice BOOTLOADER_VDDSDIO_BOOST>",
                        "help": null,
                        "id": "BOOTLOADER_VDDSDIO_BOOST_1_9V",
                        "name": "BOOTLOADER_VDDSDIO_BOOST_1_9V",
                        "range": null,
                        "title": "1.9V",
                        "type": "bool"
                    }
                ],
                "depends_on": null,
                "help": "If this option is enabled, and VDDSDIO LDO is set to 1.8V (using eFuse\nor MTDI bootstrapping pin), bootloader will change LDO settings to\noutput 1.9V instead. This helps prevent flash chip from browning out\nduring flash programming operations.\n\nThis option has no effect if VDDSDIO is set to 3.3V, or if the internal\nVDDSDIO regulator is disabled via eFuse.",
                "id": "bootloader-config-vddsdio-ldo-voltage",
                "name": "BOOTLOADER_VDDSDIO_BOOST",
                "title": "VDDSDIO LDO voltage",
                "type": "choice"
            },
            {
                "children": [
                    {
                        "children": [],
                        "depends_on": "BOOTLOADER_FACTORY_RESET",
                        "help": "The selected GPIO will be configured as an input with internal pull-up enabled.\nTo trigger a factory reset, this GPIO must be pulled low on reset.\nNote that GPIO34-39 do not have an internal pullup and an external one must be provided.",
                        "id": "BOOTLOADER_NUM_PIN_FACTORY_RESET",
                        "name": "BOOTLOADER_NUM_PIN_FACTORY_RESET",
                        "range": null,
                        "title": "Number of the GPIO input for factory reset",
                        "type": "int"
                    },
                    {
                        "children": [],
                        "depends_on": "BOOTLOADER_FACTORY_RESET",
                        "help": "The device will boot from \"factory\" partition (or OTA slot 0 if no factory partition is present) after a\nfactory reset.",
                        "id": "BOOTLOADER_OTA_DATA_ERASE",
                        "name": "BOOTLOADER_OTA_DATA_ERASE",
                        "range": null,
                        "title": "Clear OTA data on factory reset (select factory partition)",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "BOOTLOADER_FACTORY_RESET",
                        "help": "Allows customers to select which data partitions will be erased while factory reset.\n\nSpecify the names of partitions as a comma-delimited with optional spaces for readability. (Like this:\n\"nvs, phy_init, ...\")\nMake sure that the name specified in the partition table and here are the same.\nPartitions of type \"app\" cannot be specified here.",
                        "id": "BOOTLOADER_DATA_FACTORY_RESET",
                        "name": "BOOTLOADER_DATA_FACTORY_RESET",
                        "range": null,
                        "title": "Comma-separated names of partitions to clear on factory reset",
                        "type": "string"
                    }
                ],
                "depends_on": null,
                "help": "Allows to reset the device to factory settings:\n- clear one or more data partitions;\n- boot from \"factory\" partition.\nThe factory reset will occur if there is a GPIO input pulled low while device starts up.\nSee settings below.",
                "id": "BOOTLOADER_FACTORY_RESET",
                "name": "BOOTLOADER_FACTORY_RESET",
                "range": null,
                "title": "GPIO triggers factory reset",
                "type": "bool"
            },
            {
                "children": [
                    {
                        "children": [],
                        "depends_on": "BOOTLOADER_APP_TEST",
                        "help": "The selected GPIO will be configured as an input with internal pull-up enabled.\nTo trigger a test app, this GPIO must be pulled low on reset.\nAfter the GPIO input is deactivated and the device reboots, the old application will boot.\n(factory or OTA[x]).\nNote that GPIO34-39 do not have an internal pullup and an external one must be provided.",
                        "id": "BOOTLOADER_NUM_PIN_APP_TEST",
                        "name": "BOOTLOADER_NUM_PIN_APP_TEST",
                        "range": null,
                        "title": "Number of the GPIO input to boot TEST partition",
                        "type": "int"
                    }
                ],
                "depends_on": "!BOOTLOADER_APP_ANTI_ROLLBACK",
                "help": "Allows to run the test app from \"TEST\" partition.\nA boot from \"test\" partition will occur if there is a GPIO input pulled low while device starts up.\nSee settings below.",
                "id": "BOOTLOADER_APP_TEST",
                "name": "BOOTLOADER_APP_TEST",
                "range": null,
                "title": "GPIO triggers boot from test app partition",
                "type": "bool"
            },
            {
                "children": [],
                "depends_on": "BOOTLOADER_FACTORY_RESET || BOOTLOADER_APP_TEST",
                "help": "The GPIO must be held low continuously for this period of time after reset\nbefore a factory reset or test partition boot (as applicable) is performed.",
                "id": "BOOTLOADER_HOLD_TIME_GPIO",
                "name": "BOOTLOADER_HOLD_TIME_GPIO",
                "range": null,
                "title": "Hold time of GPIO for reset/test mode (seconds)",
                "type": "int"
            },
            {
                "children": [
                    {
                        "children": [],
                        "depends_on": "BOOTLOADER_WDT_ENABLE",
                        "help": "If it is set, the client must itself reset or disable rtc_wdt in their code (app_main()).\nOtherwise rtc_wdt will be disabled before calling app_main function.\nUse function rtc_wdt_feed() for resetting counter of rtc_wdt.\nUse function rtc_wdt_disable() for disabling rtc_wdt.",
                        "id": "BOOTLOADER_WDT_DISABLE_IN_USER_CODE",
                        "name": "BOOTLOADER_WDT_DISABLE_IN_USER_CODE",
                        "range": null,
                        "title": "Allows RTC watchdog disable in user code",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "BOOTLOADER_WDT_ENABLE",
                        "help": "Verify that this parameter is correct and more then the execution time.\nPay attention to options such as reset to factory, trigger test partition and encryption on boot\n- these options can increase the execution time.\nNote: RTC_WDT will reset while encryption operations will be performed.",
                        "id": "BOOTLOADER_WDT_TIME_MS",
                        "name": "BOOTLOADER_WDT_TIME_MS",
                        "range": [
                            0,
                            120000
                        ],
                        "title": "Timeout for RTC watchdog (ms)",
                        "type": "int"
                    }
                ],
                "depends_on": null,
                "help": "Tracks the execution time of startup code.\nIf the execution time is exceeded, the RTC_WDT will restart system.\nIt is also useful to prevent a lock up in start code caused by an unstable power source.\nNOTE: Tracks the execution time starts from the bootloader code - re-set timeout, while selecting the\nsource for slow_clk - and ends calling app_main.\nRe-set timeout is needed due to WDT uses a SLOW_CLK clock source. After changing a frequency slow_clk a\ntime of WDT needs to re-set for new frequency.\nslow_clk depends on ESP32_RTC_CLK_SRC (INTERNAL_RC or EXTERNAL_CRYSTAL).",
                "id": "BOOTLOADER_WDT_ENABLE",
                "name": "BOOTLOADER_WDT_ENABLE",
                "range": null,
                "title": "Use RTC watchdog in start code",
                "type": "bool"
            },
            {
                "children": [
                    {
                        "children": [
                            {
                                "children": [],
                                "depends_on": "BOOTLOADER_APP_ANTI_ROLLBACK",
                                "help": "The secure version is the sequence number stored in the header of each firmware.\nThe security version is set in the bootloader, version is recorded in the eFuse field\nas the number of set ones. The allocated number of bits in the efuse field\nfor storing the security version is limited (see BOOTLOADER_APP_SEC_VER_SIZE_EFUSE_FIELD option).\n\nBootloader: When bootloader selects an app to boot, an app is selected that has\na security version greater or equal that recorded in eFuse field.\nThe app is booted with a higher (or equal) secure version.\n\nThe security version is worth increasing if in previous versions there is\na significant vulnerability and their use is not acceptable.\n\nYour partition table should has a scheme with ota_0 + ota_1 (without factory).",
                                "id": "BOOTLOADER_APP_SECURE_VERSION",
                                "name": "BOOTLOADER_APP_SECURE_VERSION",
                                "range": null,
                                "title": "eFuse secure version of app",
                                "type": "int"
                            },
                            {
                                "children": [],
                                "depends_on": "BOOTLOADER_APP_ANTI_ROLLBACK",
                                "help": "The size of the efuse secure version field.\nIts length is limited to 32 bits for ESP32 and 16 bits for ESP32-S2.\nThis determines how many times the security version can be increased.",
                                "id": "BOOTLOADER_APP_SEC_VER_SIZE_EFUSE_FIELD",
                                "name": "BOOTLOADER_APP_SEC_VER_SIZE_EFUSE_FIELD",
                                "range": null,
                                "title": "Size of the efuse secure version field",
                                "type": "int"
                            },
                            {
                                "children": [],
                                "depends_on": "BOOTLOADER_APP_ANTI_ROLLBACK",
                                "help": "This option allow emulate read/write operations with efuse secure version.\nIt allow to test anti-rollback implemention without permanent write eFuse bits.\nIn partition table should be exist this partition `emul_efuse, data, 5, , 0x2000`.",
                                "id": "BOOTLOADER_EFUSE_SECURE_VERSION_EMULATE",
                                "name": "BOOTLOADER_EFUSE_SECURE_VERSION_EMULATE",
                                "range": null,
                                "title": "Emulate operations with efuse secure version(only test)",
                                "type": "bool"
                            }
                        ],
                        "depends_on": "BOOTLOADER_APP_ROLLBACK_ENABLE",
                        "help": "This option prevents rollback to previous firmware/application image with lower security version.",
                        "id": "BOOTLOADER_APP_ANTI_ROLLBACK",
                        "name": "BOOTLOADER_APP_ANTI_ROLLBACK",
                        "range": null,
                        "title": "Enable app anti-rollback support",
                        "type": "bool"
                    }
                ],
                "depends_on": null,
                "help": "After updating the app, the bootloader runs a new app with the \"ESP_OTA_IMG_PENDING_VERIFY\" state set.\nThis state prevents the re-run of this app. After the first boot of the new app in the user code, the\nfunction should be called to confirm the operability of the app or vice versa about its non-operability.\nIf the app is working, then it is marked as valid. Otherwise, it is marked as not valid and rolls back to\nthe previous working app. A reboot is performed, and the app is booted before the software update.\nNote: If during the first boot a new app the power goes out or the WDT works, then roll back will happen.\nRollback is possible only between the apps with the same security versions.",
                "id": "BOOTLOADER_APP_ROLLBACK_ENABLE",
                "name": "BOOTLOADER_APP_ROLLBACK_ENABLE",
                "range": null,
                "title": "Enable app rollback support",
                "type": "bool"
            },
            {
                "children": [],
                "depends_on": "(SECURE_BOOT && SECURE_BOOT_INSECURE) || !SECURE_BOOT",
                "help": "This option disables the normal validation of an image coming out of\ndeep sleep (checksums, SHA256, and signature). This is a trade-off\nbetween wakeup performance from deep sleep, and image integrity checks.\n\nOnly enable this if you know what you are doing. It should not be used\nin conjunction with using deep_sleep() entry and changing the active OTA\npartition as this would skip the validation upon first load of the new\nOTA partition.\n\nIt is possible to enable this option with Secure Boot if \"allow insecure\noptions\" is enabled, however it's strongly recommended to NOT enable it as\nit may allow a Secure Boot bypass.",
                "id": "BOOTLOADER_SKIP_VALIDATE_IN_DEEP_SLEEP",
                "name": "BOOTLOADER_SKIP_VALIDATE_IN_DEEP_SLEEP",
                "range": null,
                "title": "Skip image validation when exiting deep sleep",
                "type": "bool"
            },
            {
                "children": [],
                "depends_on": "!SECURE_SIGNED_ON_BOOT",
                "help": "Some applications need to boot very quickly from power on. By default, the entire app binary\nis read from flash and verified which takes up a significant portion of the boot time.\n\nEnabling this option will skip validation of the app when the SoC boots from power on.\nNote that in this case it's not possible for the bootloader to detect if an app image is\ncorrupted in the flash, therefore it's not possible to safely fall back to a different app\npartition. Flash corruption of this kind is unlikely but can happen if there is a serious\nfirmware bug or physical damage.\n\nFollowing other reset types, the bootloader will still validate the app image. This increases\nthe chances that flash corruption resulting in a crash can be detected following soft reset, and\nthe bootloader will fall back to a valid app image. To increase the chances of successfully recovering\nfrom a flash corruption event, keep the option BOOTLOADER_WDT_ENABLE enabled and consider also enabling\nBOOTLOADER_WDT_DISABLE_IN_USER_CODE - then manually disable the RTC Watchdog once the app is running.\nIn addition, enable both the Task and Interrupt watchdog timers with reset options set.",
                "id": "BOOTLOADER_SKIP_VALIDATE_ON_POWER_ON",
                "name": "BOOTLOADER_SKIP_VALIDATE_ON_POWER_ON",
                "range": null,
                "title": "Skip image validation from power on reset (READ HELP FIRST)",
                "type": "bool"
            },
            {
                "children": [],
                "depends_on": "!SECURE_SIGNED_ON_BOOT",
                "help": "Selecting this option prevents the bootloader from ever validating the app image before\nbooting it. Any flash corruption of the selected app partition will make the entire SoC\nunbootable.\n\nAlthough flash corruption is a very rare case, it is not recommended to select this option.\nConsider selecting \"Skip image validation from power on reset\" instead. However, if boot time\nis the only important factor then it can be enabled.",
                "id": "BOOTLOADER_SKIP_VALIDATE_ALWAYS",
                "name": "BOOTLOADER_SKIP_VALIDATE_ALWAYS",
                "range": null,
                "title": "Skip image validation always (READ HELP FIRST)",
                "type": "bool"
            },
            {
                "children": [],
                "depends_on": null,
                "help": "Reserve RTC FAST memory for Skip image validation. This option in bytes.\nThis option reserves an area in the RTC FAST memory (access only PRO_CPU).\nUsed to save the addresses of the selected application.\nWhen a wakeup occurs (from Deep sleep), the bootloader retrieves it and\nloads the application without validation.",
                "id": "BOOTLOADER_RESERVE_RTC_SIZE",
                "name": "BOOTLOADER_RESERVE_RTC_SIZE",
                "range": null,
                "title": null,
                "type": "hex"
            },
            {
                "children": [
                    {
                        "children": [],
                        "depends_on": "BOOTLOADER_CUSTOM_RESERVE_RTC",
                        "help": "This option reserves in RTC FAST memory the area for custom purposes.\nIf you want to create your own bootloader and save more information\nin this area of memory, you can increase it. It must be a multiple of 4 bytes.\nThis area (rtc_retain_mem_t) is reserved and has access from the bootloader and an application.",
                        "id": "BOOTLOADER_CUSTOM_RESERVE_RTC_SIZE",
                        "name": "BOOTLOADER_CUSTOM_RESERVE_RTC_SIZE",
                        "range": null,
                        "title": "Size in bytes for custom purposes",
                        "type": "hex"
                    }
                ],
                "depends_on": null,
                "help": "This option allows the customer to place data in the RTC FAST memory,\nthis area remains valid when rebooted, except for power loss.\nThis memory is located at a fixed address and is available\nfor both the bootloader and the application.\n(The application and bootoloader must be compiled with the same option).\nThe RTC FAST memory has access only through PRO_CPU.",
                "id": "BOOTLOADER_CUSTOM_RESERVE_RTC",
                "name": "BOOTLOADER_CUSTOM_RESERVE_RTC",
                "range": null,
                "title": "Reserve RTC FAST memory for custom purposes",
                "type": "bool"
            },
            {
                "children": [],
                "depends_on": null,
                "help": "Perform the startup flow recommended by XMC. Please consult XMC for the details of this flow.\nXMC chips will be forbidden to be used, when this option is disabled.\n\nDON'T DISABLE THIS UNLESS YOU KNOW WHAT YOU ARE DOING.",
                "id": "BOOTLOADER_FLASH_XMC_SUPPORT",
                "name": "BOOTLOADER_FLASH_XMC_SUPPORT",
                "range": null,
                "title": "Enable the support for flash chips of XMC (READ HELP FIRST)",
                "type": "bool"
            }
        ],
        "depends_on": null,
        "id": "bootloader-config",
        "title": "Bootloader config",
        "type": "menu"
    },
    {
        "children": [
            {
                "children": [],
                "depends_on": "SECURE_BOOT || SECURE_SIGNED_ON_BOOT_NO_SECURE_BOOT",
                "help": null,
                "id": "SECURE_SIGNED_ON_BOOT",
                "name": "SECURE_SIGNED_ON_BOOT",
                "range": null,
                "title": null,
                "type": "bool"
            },
            {
                "children": [],
                "depends_on": "SECURE_BOOT || SECURE_SIGNED_ON_UPDATE_NO_SECURE_BOOT",
                "help": null,
                "id": "SECURE_SIGNED_ON_UPDATE",
                "name": "SECURE_SIGNED_ON_UPDATE",
                "range": null,
                "title": null,
                "type": "bool"
            },
            {
                "children": [],
                "depends_on": "SECURE_SIGNED_ON_BOOT || SECURE_SIGNED_ON_UPDATE",
                "help": null,
                "id": "SECURE_SIGNED_APPS",
                "name": "SECURE_SIGNED_APPS",
                "range": null,
                "title": null,
                "type": "bool"
            },
            {
                "children": [],
                "depends_on": "ESP32_REV_MIN_3 || IDF_TARGET_ESP32S2 || IDF_TARGET_ESP32C3",
                "help": null,
                "id": "SECURE_BOOT_SUPPORTS_RSA",
                "name": "SECURE_BOOT_SUPPORTS_RSA",
                "range": null,
                "title": null,
                "type": "bool"
            },
            {
                "children": [],
                "depends_on": "IDF_TARGET_ESP32S2 || IDF_TARGET_ESP32C3",
                "help": null,
                "id": "SECURE_TARGET_HAS_SECURE_ROM_DL_MODE",
                "name": "SECURE_TARGET_HAS_SECURE_ROM_DL_MODE",
                "range": null,
                "title": null,
                "type": "bool"
            },
            {
                "children": [],
                "depends_on": "!SECURE_BOOT",
                "help": "Require apps to be signed to verify their integrity.\n\nThis option uses the same app signature scheme as hardware secure boot, but unlike hardware secure boot it\ndoes not prevent the bootloader from being physically updated. This means that the device can be secured\nagainst remote network access, but not physical access. Compared to using hardware Secure Boot this option\nis much simpler to implement.",
                "id": "SECURE_SIGNED_APPS_NO_SECURE_BOOT",
                "name": "SECURE_SIGNED_APPS_NO_SECURE_BOOT",
                "range": null,
                "title": "Require signed app images",
                "type": "bool"
            },
            {
                "children": [
                    {
                        "children": [],
                        "depends_on": "IDF_TARGET_ESP32 && (SECURE_SIGNED_APPS_NO_SECURE_BOOT || SECURE_BOOT_V1_ENABLED) && <choice SECURE_SIGNED_APPS_SCHEME>",
                        "help": "Embeds the ECDSA public key in the bootloader and signs the application with an ECDSA key.\n\nRefer to the documentation before enabling.",
                        "id": "SECURE_SIGNED_APPS_ECDSA_SCHEME",
                        "name": "SECURE_SIGNED_APPS_ECDSA_SCHEME",
                        "range": null,
                        "title": "ECDSA",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "SECURE_BOOT_SUPPORTS_RSA && (SECURE_SIGNED_APPS_NO_SECURE_BOOT || SECURE_BOOT_V2_ENABLED) && <choice SECURE_SIGNED_APPS_SCHEME>",
                        "help": "Appends the RSA-3072 based Signature block to the application.\nRefer to <Secure Boot Version 2 documentation link> before enabling.",
                        "id": "SECURE_SIGNED_APPS_RSA_SCHEME",
                        "name": "SECURE_SIGNED_APPS_RSA_SCHEME",
                        "range": null,
                        "title": "RSA",
                        "type": "bool"
                    }
                ],
                "depends_on": "SECURE_BOOT || SECURE_SIGNED_APPS_NO_SECURE_BOOT",
                "help": "Select the Secure App signing scheme. Depends on the Chip Revision.\nThere are two options:\n1. ECDSA based secure boot scheme. (Only choice for Secure Boot V1)\nSupported in ESP32 and ESP32-ECO3.\n2. The RSA based secure boot scheme. (Only choice for Secure Boot V2)\nSupported in ESP32-ECO3 (ESP32 Chip Revision 3 onwards), ESP32-S2, ESP32-C3, ESP32-S3.",
                "id": "security-features-app-signing-scheme",
                "name": "SECURE_SIGNED_APPS_SCHEME",
                "title": "App Signing Scheme",
                "type": "choice"
            },
            {
                "children": [],
                "depends_on": "SECURE_SIGNED_APPS_NO_SECURE_BOOT && SECURE_SIGNED_APPS_ECDSA_SCHEME",
                "help": "If this option is set, the bootloader will be compiled with code to verify that an app is signed before\nbooting it.\n\nIf hardware secure boot is enabled, this option is always enabled and cannot be disabled.\nIf hardware secure boot is not enabled, this option doesn't add significant security by itself so most\nusers will want to leave it disabled.",
                "id": "SECURE_SIGNED_ON_BOOT_NO_SECURE_BOOT",
                "name": "SECURE_SIGNED_ON_BOOT_NO_SECURE_BOOT",
                "range": null,
                "title": "Bootloader verifies app signatures",
                "type": "bool"
            },
            {
                "children": [],
                "depends_on": "SECURE_SIGNED_APPS_NO_SECURE_BOOT",
                "help": "If this option is set, any OTA updated apps will have the signature verified before being considered valid.\n\nWhen enabled, the signature is automatically checked whenever the esp_ota_ops.h APIs are used for OTA\nupdates, or esp_image_format.h APIs are used to verify apps.\n\nIf hardware secure boot is enabled, this option is always enabled and cannot be disabled.\nIf hardware secure boot is not enabled, this option still adds significant security against network-based\nattackers by preventing spoofing of OTA updates.",
                "id": "SECURE_SIGNED_ON_UPDATE_NO_SECURE_BOOT",
                "name": "SECURE_SIGNED_ON_UPDATE_NO_SECURE_BOOT",
                "range": null,
                "title": "Verify app signature on update",
                "type": "bool"
            },
            {
                "children": [
                    {
                        "children": [
                            {
                                "children": [],
                                "depends_on": "IDF_TARGET_ESP32 && <choice SECURE_BOOT_VERSION>",
                                "help": "Build a bootloader which enables secure boot version 1 on first boot.\nRefer to the Secure Boot section of the ESP-IDF Programmer's Guide for this version before enabling.",
                                "id": "SECURE_BOOT_V1_ENABLED",
                                "name": "SECURE_BOOT_V1_ENABLED",
                                "range": null,
                                "title": "Enable Secure Boot version 1",
                                "type": "bool"
                            },
                            {
                                "children": [],
                                "depends_on": "SECURE_BOOT_SUPPORTS_RSA && <choice SECURE_BOOT_VERSION>",
                                "help": "Build a bootloader which enables Secure Boot version 2 on first boot.\nRefer to Secure Boot V2 section of the ESP-IDF Programmer's Guide for this version before enabling.",
                                "id": "SECURE_BOOT_V2_ENABLED",
                                "name": "SECURE_BOOT_V2_ENABLED",
                                "range": null,
                                "title": "Enable Secure Boot version 2",
                                "type": "bool"
                            }
                        ],
                        "depends_on": "SECURE_BOOT",
                        "help": "Select the Secure Boot Version. Depends on the Chip Revision.\nSecure Boot V2 is the new RSA based secure boot scheme.\nSupported in ESP32-ECO3 (ESP32 Chip Revision 3 onwards), ESP32-S2, ESP32-C3 ECO3.\nSecure Boot V1 is the AES based secure boot scheme.\nSupported in ESP32 and ESP32-ECO3.",
                        "id": "security-features-enable-hardware-secure-boot-in-bootloader-read-docs-first--select-secure-boot-version",
                        "name": "SECURE_BOOT_VERSION",
                        "title": "Select secure boot version",
                        "type": "choice"
                    }
                ],
                "depends_on": "IDF_TARGET_ESP32 || IDF_TARGET_ESP32S2 || ESP32C3_REV_MIN >= 3",
                "help": "Build a bootloader which enables Secure Boot on first boot.\n\nOnce enabled, Secure Boot will not boot a modified bootloader. The bootloader will only load a partition\ntable or boot an app if the data has a verified digital signature. There are implications for reflashing\nupdated apps once secure boot is enabled.\n\nWhen enabling secure boot, JTAG and ROM BASIC Interpreter are permanently disabled by default.",
                "id": "SECURE_BOOT",
                "name": "SECURE_BOOT",
                "range": null,
                "title": "Enable hardware Secure Boot in bootloader (READ DOCS FIRST)",
                "type": "bool"
            },
            {
                "children": [
                    {
                        "children": [],
                        "depends_on": "<choice SECURE_BOOTLOADER_MODE>",
                        "help": "On first boot, the bootloader will generate a key which is not readable externally or by software. A\ndigest is generated from the bootloader image itself. This digest will be verified on each subsequent\nboot.\n\nEnabling this option means that the bootloader cannot be changed after the first time it is booted.",
                        "id": "SECURE_BOOTLOADER_ONE_TIME_FLASH",
                        "name": "SECURE_BOOTLOADER_ONE_TIME_FLASH",
                        "range": null,
                        "title": "One-time flash",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "<choice SECURE_BOOTLOADER_MODE>",
                        "help": "Generate a reusable secure bootloader key, derived (via SHA-256) from the secure boot signing key.\n\nThis allows the secure bootloader to be re-flashed by anyone with access to the secure boot signing\nkey.\n\nThis option is less secure than one-time flash, because a leak of the digest key from one device\nallows reflashing of any device that uses it.",
                        "id": "SECURE_BOOTLOADER_REFLASHABLE",
                        "name": "SECURE_BOOTLOADER_REFLASHABLE",
                        "range": null,
                        "title": "Reflashable",
                        "type": "bool"
                    }
                ],
                "depends_on": "SECURE_BOOT_V1_ENABLED",
                "help": null,
                "id": "security-features-secure-bootloader-mode",
                "name": "SECURE_BOOTLOADER_MODE",
                "title": "Secure bootloader mode",
                "type": "choice"
            },
            {
                "children": [
                    {
                        "children": [],
                        "depends_on": "SECURE_BOOT_BUILD_SIGNED_BINARIES",
                        "help": "Path to the key file used to sign app images.\n\nKey file is an ECDSA private key (NIST256p curve) in PEM format for Secure Boot V1.\nKey file is an RSA private key in PEM format for Secure Boot V2.\n\nPath is evaluated relative to the project directory.\n\nYou can generate a new signing key by running the following command:\nespsecure.py generate_signing_key secure_boot_signing_key.pem\n\nSee the Secure Boot section of the ESP-IDF Programmer's Guide for this version for details.",
                        "id": "SECURE_BOOT_SIGNING_KEY",
                        "name": "SECURE_BOOT_SIGNING_KEY",
                        "range": null,
                        "title": "Secure boot private signing key",
                        "type": "string"
                    }
                ],
                "depends_on": "SECURE_SIGNED_APPS",
                "help": "Once secure boot or signed app requirement is enabled, app images are required to be signed.\n\nIf enabled (default), these binary files are signed as part of the build process. The file named in\n\"Secure boot private signing key\" will be used to sign the image.\n\nIf disabled, unsigned app/partition data will be built. They must be signed manually using espsecure.py.\nVersion 1 to enable ECDSA Based Secure Boot and Version 2 to enable RSA based Secure Boot.\n(for example, on a remote signing server.)",
                "id": "SECURE_BOOT_BUILD_SIGNED_BINARIES",
                "name": "SECURE_BOOT_BUILD_SIGNED_BINARIES",
                "range": null,
                "title": "Sign binaries during build",
                "type": "bool"
            },
            {
                "children": [],
                "depends_on": "SECURE_SIGNED_APPS && !SECURE_BOOT_BUILD_SIGNED_BINARIES && !SECURE_SIGNED_APPS_RSA_SCHEME",
                "help": "Path to a public key file used to verify signed images.\nSecure Boot V1: This ECDSA public key is compiled into the bootloader and/or\napp, to verify app images.\nSecure Boot V2: This RSA public key is compiled into the signature block at\nthe end of the bootloader/app.\n\nKey file is in raw binary format, and can be extracted from a\nPEM formatted private key using the espsecure.py\nextract_public_key command.\n\nRefer to the Secure Boot section of the ESP-IDF Programmer's Guide for this version before enabling.",
                "id": "SECURE_BOOT_VERIFICATION_KEY",
                "name": "SECURE_BOOT_VERIFICATION_KEY",
                "range": null,
                "title": "Secure boot public signature verification key",
                "type": "string"
            },
            {
                "children": [],
                "depends_on": "SECURE_BOOT && (IDF_TARGET_ESP32S2 || IDF_TARGET_ESP32C3 || IDF_TARGET_ESP32S3)",
                "help": "If this option is set, ROM bootloader will revoke the public key digest burned in efuse block\nif it fails to verify the signature of software bootloader with it.\nRevocation of keys does not happen when enabling secure boot. Once secure boot is enabled,\nkey revocation checks will be done on subsequent boot-up, while verifying the software bootloader\n\nThis feature provides a strong resistance against physical attacks on the device.\n\nNOTE: Once a digest slot is revoked, it can never be used again to verify an image\nThis can lead to permanent bricking of the device, in case all keys are revoked\nbecause of signature verification failure.",
                "id": "SECURE_BOOT_ENABLE_AGGRESSIVE_KEY_REVOKE",
                "name": "SECURE_BOOT_ENABLE_AGGRESSIVE_KEY_REVOKE",
                "range": null,
                "title": "Enable Aggressive key revoke strategy",
                "type": "bool"
            },
            {
                "children": [
                    {
                        "children": [],
                        "depends_on": "<choice SECURE_BOOTLOADER_KEY_ENCODING>",
                        "help": null,
                        "id": "SECURE_BOOTLOADER_KEY_ENCODING_256BIT",
                        "name": "SECURE_BOOTLOADER_KEY_ENCODING_256BIT",
                        "range": null,
                        "title": "No encoding (256 bit key)",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "<choice SECURE_BOOTLOADER_KEY_ENCODING>",
                        "help": null,
                        "id": "SECURE_BOOTLOADER_KEY_ENCODING_192BIT",
                        "name": "SECURE_BOOTLOADER_KEY_ENCODING_192BIT",
                        "range": null,
                        "title": "3/4 encoding (192 bit key)",
                        "type": "bool"
                    }
                ],
                "depends_on": "SECURE_BOOTLOADER_REFLASHABLE",
                "help": "In reflashable secure bootloader mode, a hardware key is derived from the signing key (with SHA-256) and\ncan be written to eFuse with espefuse.py.\n\nNormally this is a 256-bit key, but if 3/4 Coding Scheme is used on the device then the eFuse key is\ntruncated to 192 bits.\n\nThis configuration item doesn't change any firmware code, it only changes the size of key binary which is\ngenerated at build time.",
                "id": "security-features-hardware-key-encoding",
                "name": "SECURE_BOOTLOADER_KEY_ENCODING",
                "title": "Hardware Key Encoding",
                "type": "choice"
            },
            {
                "children": [],
                "depends_on": "SECURE_BOOT",
                "help": "You can disable some of the default protections offered by secure boot, in order to enable testing or a\ncustom combination of security features.\n\nOnly enable these options if you are very sure.\n\nRefer to the Secure Boot section of the ESP-IDF Programmer's Guide for this version before enabling.",
                "id": "SECURE_BOOT_INSECURE",
                "name": "SECURE_BOOT_INSECURE",
                "range": null,
                "title": "Allow potentially insecure options",
                "type": "bool"
            },
            {
                "children": [
                    {
                        "children": [
                            {
                                "children": [],
                                "depends_on": "<choice SECURE_FLASH_ENCRYPTION_KEYSIZE>",
                                "help": null,
                                "id": "SECURE_FLASH_ENCRYPTION_AES128",
                                "name": "SECURE_FLASH_ENCRYPTION_AES128",
                                "range": null,
                                "title": "AES-128 (256-bit key)",
                                "type": "bool"
                            },
                            {
                                "children": [],
                                "depends_on": "<choice SECURE_FLASH_ENCRYPTION_KEYSIZE>",
                                "help": null,
                                "id": "SECURE_FLASH_ENCRYPTION_AES256",
                                "name": "SECURE_FLASH_ENCRYPTION_AES256",
                                "range": null,
                                "title": "AES-256 (512-bit key)",
                                "type": "bool"
                            }
                        ],
                        "depends_on": "IDF_TARGET_ESP32S2 && SECURE_FLASH_ENC_ENABLED",
                        "help": "Size of generated AES-XTS key.\n\nAES-128 uses a 256-bit key (32 bytes) which occupies one Efuse key block.\nAES-256 uses a 512-bit key (64 bytes) which occupies two Efuse key blocks.\n\nThis setting is ignored if either type of key is already burned to Efuse before the first boot.\nIn this case, the pre-burned key is used and no new key is generated.",
                        "id": "security-features-enable-flash-encryption-on-boot-read-docs-first--size-of-generated-aes-xts-key",
                        "name": "SECURE_FLASH_ENCRYPTION_KEYSIZE",
                        "title": "Size of generated AES-XTS key",
                        "type": "choice"
                    },
                    {
                        "children": [
                            {
                                "children": [],
                                "depends_on": "<choice SECURE_FLASH_ENCRYPTION_MODE>",
                                "help": null,
                                "id": "SECURE_FLASH_ENCRYPTION_MODE_DEVELOPMENT",
                                "name": "SECURE_FLASH_ENCRYPTION_MODE_DEVELOPMENT",
                                "range": null,
                                "title": "Development(NOT SECURE)",
                                "type": "bool"
                            },
                            {
                                "children": [],
                                "depends_on": "<choice SECURE_FLASH_ENCRYPTION_MODE>",
                                "help": null,
                                "id": "SECURE_FLASH_ENCRYPTION_MODE_RELEASE",
                                "name": "SECURE_FLASH_ENCRYPTION_MODE_RELEASE",
                                "range": null,
                                "title": "Release",
                                "type": "bool"
                            }
                        ],
                        "depends_on": "SECURE_FLASH_ENC_ENABLED",
                        "help": "By default Development mode is enabled which allows UART bootloader to perform flash encryption operations\n\nSelect Release mode only for production or manufacturing. Once enabled you can not reflash using UART\nbootloader\n\nRefer to the Secure Boot section of the ESP-IDF Programmer's Guide for this version and\nhttps://docs.espressif.com/projects/esp-idf/en/latest/security/flash-encryption.html for details.",
                        "id": "security-features-enable-flash-encryption-on-boot-read-docs-first--enable-usage-mode",
                        "name": "SECURE_FLASH_ENCRYPTION_MODE",
                        "title": "Enable usage mode",
                        "type": "choice"
                    }
                ],
                "depends_on": null,
                "help": "If this option is set, flash contents will be encrypted by the bootloader on first boot.\n\nNote: After first boot, the system will be permanently encrypted. Re-flashing an encrypted\nsystem is complicated and not always possible.\n\nRead https://docs.espressif.com/projects/esp-idf/en/latest/security/flash-encryption.html\nbefore enabling.",
                "id": "SECURE_FLASH_ENC_ENABLED",
                "name": "SECURE_FLASH_ENC_ENABLED",
                "range": null,
                "title": "Enable flash encryption on boot (READ DOCS FIRST)",
                "type": "bool"
            },
            {
                "children": [
                    {
                        "children": [],
                        "depends_on": "(SECURE_BOOT_INSECURE || SECURE_FLASH_ENCRYPTION_MODE_DEVELOPMENT) && IDF_TARGET_ESP32",
                        "help": "By default, the BASIC ROM Console starts on reset if no valid bootloader is\nread from the flash.\n\nWhen either flash encryption or secure boot are enabled, the default is to\ndisable this BASIC fallback mode permanently via eFuse.\n\nIf this option is set, this eFuse is not burned and the BASIC ROM Console may\nremain accessible.  Only set this option in testing environments.",
                        "id": "SECURE_BOOT_ALLOW_ROM_BASIC",
                        "name": "SECURE_BOOT_ALLOW_ROM_BASIC",
                        "range": null,
                        "title": "Leave ROM BASIC Interpreter available on reset",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "SECURE_BOOT_INSECURE || SECURE_FLASH_ENCRYPTION_MODE_DEVELOPMENT",
                        "help": "If not set (default), the bootloader will permanently disable JTAG (across entire chip) on first boot\nwhen either secure boot or flash encryption is enabled.\n\nSetting this option leaves JTAG on for debugging, which negates all protections of flash encryption\nand some of the protections of secure boot.\n\nOnly set this option in testing environments.",
                        "id": "SECURE_BOOT_ALLOW_JTAG",
                        "name": "SECURE_BOOT_ALLOW_JTAG",
                        "range": null,
                        "title": "Allow JTAG Debugging",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "SECURE_BOOT_INSECURE",
                        "help": "If not set (default), app partition size must be a multiple of 64KB. App images are padded to 64KB\nlength, and the bootloader checks any trailing bytes after the signature (before the next 64KB\nboundary) have not been written. This is because flash cache maps entire 64KB pages into the address\nspace. This prevents an attacker from appending unverified data after the app image in the flash,\ncausing it to be mapped into the address space.\n\nSetting this option allows the app partition length to be unaligned, and disables padding of the app\nimage to this length. It is generally not recommended to set this option, unless you have a legacy\npartitioning scheme which doesn't support 64KB aligned partition lengths.",
                        "id": "SECURE_BOOT_ALLOW_SHORT_APP_PARTITION",
                        "name": "SECURE_BOOT_ALLOW_SHORT_APP_PARTITION",
                        "range": null,
                        "title": "Allow app partition length not 64KB aligned",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "SECURE_BOOT_INSECURE && SECURE_BOOT_V2_ENABLED",
                        "help": "If not set (default, recommended), on first boot the bootloader will burn the WR_DIS_RD_DIS\nefuse when Secure Boot is enabled. This prevents any more efuses from being read protected.\n\nIf this option is set, it will remain possible to write the EFUSE_RD_DIS efuse field after Secure\nBoot is enabled. This may allow an attacker to read-protect the BLK2 efuse (for ESP32) and\nBLOCK4-BLOCK10 (i.e. BLOCK_KEY0-BLOCK_KEY5)(for other chips) holding the public key digest, causing an\nimmediate denial of service and possibly allowing an additional fault injection attack to\nbypass the signature protection.\n\nNOTE: Once a BLOCK is read-protected, the application will read all zeros from that block\n\nNOTE: If \"UART ROM download mode (Permanently disabled (recommended))\" or\n\"UART ROM download mode (Permanently switch to Secure mode (recommended))\" is set,\nthen it is __NOT__ possible to read/write efuses using espefuse.py utility.\nHowever, efuse can be read/written from the application",
                        "id": "SECURE_BOOT_V2_ALLOW_EFUSE_RD_DIS",
                        "name": "SECURE_BOOT_V2_ALLOW_EFUSE_RD_DIS",
                        "range": null,
                        "title": "Allow additional read protecting of efuses",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "SECURE_FLASH_ENCRYPTION_MODE_DEVELOPMENT",
                        "help": "If not set (default), the bootloader will permanently disable UART bootloader encryption access on\nfirst boot. If set, the UART bootloader will still be able to access hardware encryption.\n\nIt is recommended to only set this option in testing environments.",
                        "id": "SECURE_FLASH_UART_BOOTLOADER_ALLOW_ENC",
                        "name": "SECURE_FLASH_UART_BOOTLOADER_ALLOW_ENC",
                        "range": null,
                        "title": "Leave UART bootloader encryption enabled",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "SECURE_FLASH_ENCRYPTION_MODE_DEVELOPMENT && IDF_TARGET_ESP32",
                        "help": "If not set (default), the bootloader will permanently disable UART bootloader decryption access on\nfirst boot. If set, the UART bootloader will still be able to access hardware decryption.\n\nOnly set this option in testing environments. Setting this option allows complete bypass of flash\nencryption.",
                        "id": "SECURE_FLASH_UART_BOOTLOADER_ALLOW_DEC",
                        "name": "SECURE_FLASH_UART_BOOTLOADER_ALLOW_DEC",
                        "range": null,
                        "title": "Leave UART bootloader decryption enabled",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "SECURE_FLASH_ENCRYPTION_MODE_DEVELOPMENT",
                        "help": "If not set (default), the bootloader will permanently disable UART bootloader flash cache access on\nfirst boot. If set, the UART bootloader will still be able to access the flash cache.\n\nOnly set this option in testing environments.",
                        "id": "SECURE_FLASH_UART_BOOTLOADER_ALLOW_CACHE",
                        "name": "SECURE_FLASH_UART_BOOTLOADER_ALLOW_CACHE",
                        "range": null,
                        "title": "Leave UART bootloader flash cache enabled",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "SECURE_FLASH_ENCRYPTION_MODE_DEVELOPMENT",
                        "help": "If not set (default), and flash encryption is not yet enabled in eFuses, the 2nd stage bootloader\nwill enable flash encryption: generate the flash encryption key and program eFuses.\nIf this option is set, and flash encryption is not yet enabled, the bootloader will error out and\nreboot.\nIf flash encryption is enabled in eFuses, this option does not change the bootloader behavior.\n\nOnly use this option in testing environments, to avoid accidentally enabling flash encryption on\nthe wrong device. The device needs to have flash encryption already enabled using espefuse.py.",
                        "id": "SECURE_FLASH_REQUIRE_ALREADY_ENABLED",
                        "name": "SECURE_FLASH_REQUIRE_ALREADY_ENABLED",
                        "range": null,
                        "title": "Require flash encryption to be already enabled",
                        "type": "bool"
                    }
                ],
                "depends_on": null,
                "id": "security-features-potentially-insecure-options",
                "title": "Potentially insecure options",
                "type": "menu"
            },
            {
                "children": [
                    {
                        "children": [],
                        "depends_on": "<choice SECURE_UART_ROM_DL_MODE>",
                        "help": "If set, during startup the app will burn an eFuse bit to permanently disable the UART ROM\nDownload Mode. This prevents any future use of esptool.py, espefuse.py and similar tools.\n\nOnce disabled, if the SoC is booted with strapping pins set for ROM Download Mode\nthen an error is printed instead.\n\nIt is recommended to enable this option in any production application where Flash\nEncryption and/or Secure Boot is enabled and access to Download Mode is not required.\n\nIt is also possible to permanently disable Download Mode by calling\nesp_efuse_disable_rom_download_mode() at runtime.",
                        "id": "SECURE_DISABLE_ROM_DL_MODE",
                        "name": "SECURE_DISABLE_ROM_DL_MODE",
                        "range": null,
                        "title": "UART ROM download mode (Permanently disabled (recommended))",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "SECURE_TARGET_HAS_SECURE_ROM_DL_MODE && <choice SECURE_UART_ROM_DL_MODE>",
                        "help": "If set, during startup the app will burn an eFuse bit to permanently switch the UART ROM\nDownload Mode into a separate Secure Download mode. This option can only work if\nDownload Mode is not already disabled by eFuse.\n\nSecure Download mode limits the use of Download Mode functions to simple flash read,\nwrite and erase operations, plus a command to return a summary of currently enabled\nsecurity features.\n\nSecure Download mode is not compatible with the esptool.py flasher stub feature,\nespefuse.py, read/writing memory or registers, encrypted download, or any other\nfeatures that interact with unsupported Download Mode commands.\n\nSecure Download mode should be enabled in any application where Flash Encryption\nand/or Secure Boot is enabled. Disabling this option does not immediately cancel\nthe benefits of the security features, but it increases the potential \"attack\nsurface\" for an attacker to try and bypass them with a successful physical attack.\n\nIt is also possible to enable secure download mode at runtime by calling\nesp_efuse_enable_rom_secure_download_mode()",
                        "id": "SECURE_ENABLE_SECURE_ROM_DL_MODE",
                        "name": "SECURE_ENABLE_SECURE_ROM_DL_MODE",
                        "range": null,
                        "title": "UART ROM download mode (Permanently switch to Secure mode (recommended))",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "<choice SECURE_UART_ROM_DL_MODE>",
                        "help": "This is a potentially insecure option.\nEnabling this option will allow the full UART download mode to stay enabled.\nThis option SHOULD NOT BE ENABLED for production use cases.",
                        "id": "SECURE_INSECURE_ALLOW_DL_MODE",
                        "name": "SECURE_INSECURE_ALLOW_DL_MODE",
                        "range": null,
                        "title": "UART ROM download mode (Enabled (not recommended))",
                        "type": "bool"
                    }
                ],
                "depends_on": "(SECURE_BOOT_V2_ENABLED || SECURE_FLASH_ENC_ENABLED) && (!IDF_TARGET_ESP32 || ESP32_REV_MIN_3)",
                "help": null,
                "id": "security-features-uart-rom-download-mode",
                "name": "SECURE_UART_ROM_DL_MODE",
                "title": "UART ROM download mode",
                "type": "choice"
            }
        ],
        "depends_on": null,
        "id": "security-features",
        "title": "Security features",
        "type": "menu"
    },
    {
        "children": [
            {
                "children": [],
                "depends_on": "!IDF_CMAKE",
                "help": "The serial port that's connected to the ESP chip. This can be overridden by setting the ESPPORT\nenvironment variable.\n\nThis value is ignored when using the CMake-based build system or idf.py.",
                "id": "ESPTOOLPY_PORT",
                "name": "ESPTOOLPY_PORT",
                "range": null,
                "title": "Default serial port",
                "type": "string"
            },
            {
                "children": [
                    {
                        "children": [],
                        "depends_on": "<choice ESPTOOLPY_BAUD>",
                        "help": null,
                        "id": "ESPTOOLPY_BAUD_115200B",
                        "name": "ESPTOOLPY_BAUD_115200B",
                        "range": null,
                        "title": "115200 baud",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "<choice ESPTOOLPY_BAUD>",
                        "help": null,
                        "id": "ESPTOOLPY_BAUD_230400B",
                        "name": "ESPTOOLPY_BAUD_230400B",
                        "range": null,
                        "title": "230400 baud",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "<choice ESPTOOLPY_BAUD>",
                        "help": null,
                        "id": "ESPTOOLPY_BAUD_921600B",
                        "name": "ESPTOOLPY_BAUD_921600B",
                        "range": null,
                        "title": "921600 baud",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "<choice ESPTOOLPY_BAUD>",
                        "help": null,
                        "id": "ESPTOOLPY_BAUD_2MB",
                        "name": "ESPTOOLPY_BAUD_2MB",
                        "range": null,
                        "title": "2Mbaud",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "<choice ESPTOOLPY_BAUD>",
                        "help": null,
                        "id": "ESPTOOLPY_BAUD_OTHER",
                        "name": "ESPTOOLPY_BAUD_OTHER",
                        "range": null,
                        "title": "Other baud rate",
                        "type": "bool"
                    }
                ],
                "depends_on": "!IDF_CMAKE",
                "help": "Default baud rate to use while communicating with the ESP chip. Can be overridden by\nsetting the ESPBAUD variable.\n\nThis value is ignored when using the CMake-based build system or idf.py.",
                "id": "serial-flasher-config-default-baud-rate",
                "name": "ESPTOOLPY_BAUD",
                "title": "Default baud rate",
                "type": "choice"
            },
            {
                "children": [],
                "depends_on": null,
                "help": null,
                "id": "ESPTOOLPY_BAUD_OTHER_VAL",
                "name": "ESPTOOLPY_BAUD_OTHER_VAL",
                "range": null,
                "title": "Other baud rate value",
                "type": "int"
            },
            {
                "children": [],
                "depends_on": "!IDF_CMAKE",
                "help": null,
                "id": "ESPTOOLPY_BAUD",
                "name": "ESPTOOLPY_BAUD",
                "range": null,
                "title": null,
                "type": "int"
            },
            {
                "children": [],
                "depends_on": "!IDF_CMAKE",
                "help": "The flasher tool can send data compressed using zlib, letting the ROM on the ESP chip\ndecompress it on the fly before flashing it. For most payloads, this should result in a\nspeed increase.",
                "id": "ESPTOOLPY_COMPRESSED",
                "name": "ESPTOOLPY_COMPRESSED",
                "range": null,
                "title": "Use compressed upload",
                "type": "bool"
            },
            {
                "children": [],
                "depends_on": null,
                "help": "The flasher tool sends a precompiled download stub first by default. That stub allows things\nlike compressed downloads and more. Usually you should not need to disable that feature",
                "id": "ESPTOOLPY_NO_STUB",
                "name": "ESPTOOLPY_NO_STUB",
                "range": null,
                "title": "Disable download stub",
                "type": "bool"
            },
            {
                "children": [
                    {
                        "children": [],
                        "depends_on": "<choice ESPTOOLPY_FLASHMODE>",
                        "help": null,
                        "id": "ESPTOOLPY_FLASHMODE_QIO",
                        "name": "ESPTOOLPY_FLASHMODE_QIO",
                        "range": null,
                        "title": "QIO",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "<choice ESPTOOLPY_FLASHMODE>",
                        "help": null,
                        "id": "ESPTOOLPY_FLASHMODE_QOUT",
                        "name": "ESPTOOLPY_FLASHMODE_QOUT",
                        "range": null,
                        "title": "QOUT",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "<choice ESPTOOLPY_FLASHMODE>",
                        "help": null,
                        "id": "ESPTOOLPY_FLASHMODE_DIO",
                        "name": "ESPTOOLPY_FLASHMODE_DIO",
                        "range": null,
                        "title": "DIO",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "<choice ESPTOOLPY_FLASHMODE>",
                        "help": null,
                        "id": "ESPTOOLPY_FLASHMODE_DOUT",
                        "name": "ESPTOOLPY_FLASHMODE_DOUT",
                        "range": null,
                        "title": "DOUT",
                        "type": "bool"
                    }
                ],
                "depends_on": null,
                "help": "Mode the flash chip is flashed in, as well as the default mode for the\nbinary to run in.",
                "id": "serial-flasher-config-flash-spi-mode",
                "name": "ESPTOOLPY_FLASHMODE",
                "title": "Flash SPI mode",
                "type": "choice"
            },
            {
                "children": [],
                "depends_on": null,
                "help": null,
                "id": "ESPTOOLPY_FLASHMODE",
                "name": "ESPTOOLPY_FLASHMODE",
                "range": null,
                "title": null,
                "type": "string"
            },
            {
                "children": [
                    {
                        "children": [],
                        "depends_on": "<choice ESPTOOLPY_FLASHFREQ>",
                        "help": null,
                        "id": "ESPTOOLPY_FLASHFREQ_80M",
                        "name": "ESPTOOLPY_FLASHFREQ_80M",
                        "range": null,
                        "title": "80 MHz",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "<choice ESPTOOLPY_FLASHFREQ>",
                        "help": null,
                        "id": "ESPTOOLPY_FLASHFREQ_40M",
                        "name": "ESPTOOLPY_FLASHFREQ_40M",
                        "range": null,
                        "title": "40 MHz",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "<choice ESPTOOLPY_FLASHFREQ>",
                        "help": null,
                        "id": "ESPTOOLPY_FLASHFREQ_26M",
                        "name": "ESPTOOLPY_FLASHFREQ_26M",
                        "range": null,
                        "title": "26 MHz",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "<choice ESPTOOLPY_FLASHFREQ>",
                        "help": null,
                        "id": "ESPTOOLPY_FLASHFREQ_20M",
                        "name": "ESPTOOLPY_FLASHFREQ_20M",
                        "range": null,
                        "title": "20 MHz",
                        "type": "bool"
                    }
                ],
                "depends_on": null,
                "help": "The SPI flash frequency to be used.",
                "id": "serial-flasher-config-flash-spi-speed",
                "name": "ESPTOOLPY_FLASHFREQ",
                "title": "Flash SPI speed",
                "type": "choice"
            },
            {
                "children": [],
                "depends_on": null,
                "help": null,
                "id": "ESPTOOLPY_FLASHFREQ",
                "name": "ESPTOOLPY_FLASHFREQ",
                "range": null,
                "title": null,
                "type": "string"
            },
            {
                "children": [
                    {
                        "children": [],
                        "depends_on": "<choice ESPTOOLPY_FLASHSIZE>",
                        "help": null,
                        "id": "ESPTOOLPY_FLASHSIZE_1MB",
                        "name": "ESPTOOLPY_FLASHSIZE_1MB",
                        "range": null,
                        "title": "1 MB",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "<choice ESPTOOLPY_FLASHSIZE>",
                        "help": null,
                        "id": "ESPTOOLPY_FLASHSIZE_2MB",
                        "name": "ESPTOOLPY_FLASHSIZE_2MB",
                        "range": null,
                        "title": "2 MB",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "<choice ESPTOOLPY_FLASHSIZE>",
                        "help": null,
                        "id": "ESPTOOLPY_FLASHSIZE_4MB",
                        "name": "ESPTOOLPY_FLASHSIZE_4MB",
                        "range": null,
                        "title": "4 MB",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "<choice ESPTOOLPY_FLASHSIZE>",
                        "help": null,
                        "id": "ESPTOOLPY_FLASHSIZE_8MB",
                        "name": "ESPTOOLPY_FLASHSIZE_8MB",
                        "range": null,
                        "title": "8 MB",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "<choice ESPTOOLPY_FLASHSIZE>",
                        "help": null,
                        "id": "ESPTOOLPY_FLASHSIZE_16MB",
                        "name": "ESPTOOLPY_FLASHSIZE_16MB",
                        "range": null,
                        "title": "16 MB",
                        "type": "bool"
                    }
                ],
                "depends_on": null,
                "help": "SPI flash size, in megabytes",
                "id": "serial-flasher-config-flash-size",
                "name": "ESPTOOLPY_FLASHSIZE",
                "title": "Flash size",
                "type": "choice"
            },
            {
                "children": [],
                "depends_on": null,
                "help": null,
                "id": "ESPTOOLPY_FLASHSIZE",
                "name": "ESPTOOLPY_FLASHSIZE",
                "range": null,
                "title": null,
                "type": "string"
            },
            {
                "children": [],
                "depends_on": null,
                "help": "If this option is set, flashing the project will automatically detect\nthe flash size of the target chip and update the bootloader image\nbefore it is flashed.",
                "id": "ESPTOOLPY_FLASHSIZE_DETECT",
                "name": "ESPTOOLPY_FLASHSIZE_DETECT",
                "range": null,
                "title": "Detect flash size when flashing bootloader",
                "type": "bool"
            },
            {
                "children": [
                    {
                        "children": [],
                        "depends_on": "<choice ESPTOOLPY_BEFORE>",
                        "help": null,
                        "id": "ESPTOOLPY_BEFORE_RESET",
                        "name": "ESPTOOLPY_BEFORE_RESET",
                        "range": null,
                        "title": "Reset to bootloader",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "<choice ESPTOOLPY_BEFORE>",
                        "help": null,
                        "id": "ESPTOOLPY_BEFORE_NORESET",
                        "name": "ESPTOOLPY_BEFORE_NORESET",
                        "range": null,
                        "title": "No reset",
                        "type": "bool"
                    }
                ],
                "depends_on": null,
                "help": "Configure whether esptool.py should reset the ESP32 before flashing.\n\nAutomatic resetting depends on the RTS & DTR signals being\nwired from the serial port to the ESP32. Most USB development\nboards do this internally.",
                "id": "serial-flasher-config-before-flashing",
                "name": "ESPTOOLPY_BEFORE",
                "title": "Before flashing",
                "type": "choice"
            },
            {
                "children": [],
                "depends_on": null,
                "help": null,
                "id": "ESPTOOLPY_BEFORE",
                "name": "ESPTOOLPY_BEFORE",
                "range": null,
                "title": null,
                "type": "string"
            },
            {
                "children": [
                    {
                        "children": [],
                        "depends_on": "<choice ESPTOOLPY_AFTER>",
                        "help": null,
                        "id": "ESPTOOLPY_AFTER_RESET",
                        "name": "ESPTOOLPY_AFTER_RESET",
                        "range": null,
                        "title": "Reset after flashing",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "<choice ESPTOOLPY_AFTER>",
                        "help": null,
                        "id": "ESPTOOLPY_AFTER_NORESET",
                        "name": "ESPTOOLPY_AFTER_NORESET",
                        "range": null,
                        "title": "Stay in bootloader",
                        "type": "bool"
                    }
                ],
                "depends_on": null,
                "help": "Configure whether esptool.py should reset the ESP32 after flashing.\n\nAutomatic resetting depends on the RTS & DTR signals being\nwired from the serial port to the ESP32. Most USB development\nboards do this internally.",
                "id": "serial-flasher-config-after-flashing",
                "name": "ESPTOOLPY_AFTER",
                "title": "After flashing",
                "type": "choice"
            },
            {
                "children": [],
                "depends_on": null,
                "help": null,
                "id": "ESPTOOLPY_AFTER",
                "name": "ESPTOOLPY_AFTER",
                "range": null,
                "title": null,
                "type": "string"
            },
            {
                "children": [
                    {
                        "children": [],
                        "depends_on": "<choice ESPTOOLPY_MONITOR_BAUD>",
                        "help": null,
                        "id": "ESPTOOLPY_MONITOR_BAUD_CONSOLE",
                        "name": "ESPTOOLPY_MONITOR_BAUD_CONSOLE",
                        "range": null,
                        "title": "Same as UART console baud rate",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "<choice ESPTOOLPY_MONITOR_BAUD>",
                        "help": null,
                        "id": "ESPTOOLPY_MONITOR_BAUD_9600B",
                        "name": "ESPTOOLPY_MONITOR_BAUD_9600B",
                        "range": null,
                        "title": "9600 bps",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "<choice ESPTOOLPY_MONITOR_BAUD>",
                        "help": null,
                        "id": "ESPTOOLPY_MONITOR_BAUD_57600B",
                        "name": "ESPTOOLPY_MONITOR_BAUD_57600B",
                        "range": null,
                        "title": "57600 bps",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "<choice ESPTOOLPY_MONITOR_BAUD>",
                        "help": null,
                        "id": "ESPTOOLPY_MONITOR_BAUD_115200B",
                        "name": "ESPTOOLPY_MONITOR_BAUD_115200B",
                        "range": null,
                        "title": "115200 bps",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "<choice ESPTOOLPY_MONITOR_BAUD>",
                        "help": null,
                        "id": "ESPTOOLPY_MONITOR_BAUD_230400B",
                        "name": "ESPTOOLPY_MONITOR_BAUD_230400B",
                        "range": null,
                        "title": "230400 bps",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "<choice ESPTOOLPY_MONITOR_BAUD>",
                        "help": null,
                        "id": "ESPTOOLPY_MONITOR_BAUD_921600B",
                        "name": "ESPTOOLPY_MONITOR_BAUD_921600B",
                        "range": null,
                        "title": "921600 bps",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "<choice ESPTOOLPY_MONITOR_BAUD>",
                        "help": null,
                        "id": "ESPTOOLPY_MONITOR_BAUD_2MB",
                        "name": "ESPTOOLPY_MONITOR_BAUD_2MB",
                        "range": null,
                        "title": "2 Mbps",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "<choice ESPTOOLPY_MONITOR_BAUD>",
                        "help": null,
                        "id": "ESPTOOLPY_MONITOR_BAUD_OTHER",
                        "name": "ESPTOOLPY_MONITOR_BAUD_OTHER",
                        "range": null,
                        "title": "Custom baud rate",
                        "type": "bool"
                    }
                ],
                "depends_on": null,
                "help": "Baud rate to use when running 'idf.py monitor' or 'make monitor'\nto view serial output from a running chip.\n\nIf \"Same as UART Console baud rate\" is chosen then the value will\nfollow the \"UART Console baud rate\" config item.\n\nCan override by setting the MONITORBAUD environment variable.",
                "id": "serial-flasher-config--idf-py-monitor-baud-rate",
                "name": "ESPTOOLPY_MONITOR_BAUD",
                "title": "'idf.py monitor' baud rate",
                "type": "choice"
            },
            {
                "children": [],
                "depends_on": null,
                "help": null,
                "id": "ESPTOOLPY_MONITOR_BAUD_OTHER_VAL",
                "name": "ESPTOOLPY_MONITOR_BAUD_OTHER_VAL",
                "range": null,
                "title": "Custom baud rate value",
                "type": "int"
            },
            {
                "children": [],
                "depends_on": null,
                "help": null,
                "id": "ESPTOOLPY_MONITOR_BAUD",
                "name": "ESPTOOLPY_MONITOR_BAUD",
                "range": null,
                "title": null,
                "type": "int"
            }
        ],
        "depends_on": null,
        "id": "serial-flasher-config",
        "title": "Serial flasher config",
        "type": "menu"
    },
    {
        "children": [
            {
                "children": [
                    {
                        "children": [],
                        "depends_on": "<choice PARTITION_TABLE_TYPE>",
                        "help": null,
                        "id": "PARTITION_TABLE_SINGLE_APP",
                        "name": "PARTITION_TABLE_SINGLE_APP",
                        "range": null,
                        "title": "Single factory app, no OTA",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "<choice PARTITION_TABLE_TYPE>",
                        "help": null,
                        "id": "PARTITION_TABLE_TWO_OTA",
                        "name": "PARTITION_TABLE_TWO_OTA",
                        "range": null,
                        "title": "Factory app, two OTA definitions",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "<choice PARTITION_TABLE_TYPE>",
                        "help": null,
                        "id": "PARTITION_TABLE_CUSTOM",
                        "name": "PARTITION_TABLE_CUSTOM",
                        "range": null,
                        "title": "Custom partition table CSV",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "!ESP32_COREDUMP_ENABLE_TO_FLASH && NVS_ENCRYPTION && <choice PARTITION_TABLE_TYPE>",
                        "help": null,
                        "id": "PARTITION_TABLE_SINGLE_APP_ENCRYPTED_NVS",
                        "name": "PARTITION_TABLE_SINGLE_APP_ENCRYPTED_NVS",
                        "range": null,
                        "title": "Single factory app, no OTA, encrypted NVS",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "!ESP_COREDUMP_ENABLE_TO_FLASH && NVS_ENCRYPTION && <choice PARTITION_TABLE_TYPE>",
                        "help": null,
                        "id": "PARTITION_TABLE_TWO_OTA_ENCRYPTED_NVS",
                        "name": "PARTITION_TABLE_TWO_OTA_ENCRYPTED_NVS",
                        "range": null,
                        "title": "Factory app, two OTA definitions, encrypted NVS",
                        "type": "bool"
                    }
                ],
                "depends_on": null,
                "help": "The partition table to flash to the ESP32. The partition table\ndetermines where apps, data and other resources are expected to\nbe found.\n\nThe predefined partition table CSV descriptions can be found\nin the components/partition_table directory. Otherwise it's\npossible to create a new custom partition CSV for your application.",
                "id": "partition-table-partition-table",
                "name": "PARTITION_TABLE_TYPE",
                "title": "Partition Table",
                "type": "choice"
            },
            {
                "children": [],
                "depends_on": null,
                "help": "Name of the custom partition CSV filename. This path is evaluated\nrelative to the project root directory.",
                "id": "PARTITION_TABLE_CUSTOM_FILENAME",
                "name": "PARTITION_TABLE_CUSTOM_FILENAME",
                "range": null,
                "title": "Custom partition CSV file",
                "type": "string"
            },
            {
                "children": [],
                "depends_on": null,
                "help": null,
                "id": "PARTITION_TABLE_FILENAME",
                "name": "PARTITION_TABLE_FILENAME",
                "range": null,
                "title": null,
                "type": "string"
            },
            {
                "children": [],
                "depends_on": null,
                "help": "The address of partition table (by default 0x8000).\nAllows you to move the partition table, it gives more space for the bootloader.\nNote that the bootloader and app will both need to be compiled with the same PARTITION_TABLE_OFFSET value.\n\nThis number should be a multiple of 0x1000.\n\nNote that partition offsets in the partition table CSV file may need to be changed if this value is set to\na higher value. To have each partition offset adapt to the configured partition table offset, leave all\npartition offsets blank in the CSV file.",
                "id": "PARTITION_TABLE_OFFSET",
                "name": "PARTITION_TABLE_OFFSET",
                "range": null,
                "title": "Offset of partition table",
                "type": "hex"
            },
            {
                "children": [],
                "depends_on": "!ESP32_COMPATIBLE_PRE_V3_1_BOOTLOADERS",
                "help": "Generate an MD5 checksum for the partition table for protecting the\nintegrity of the table. The generation should be turned off for legacy\nbootloaders which cannot recognize the MD5 checksum in the partition\ntable.",
                "id": "PARTITION_TABLE_MD5",
                "name": "PARTITION_TABLE_MD5",
                "range": null,
                "title": "Generate an MD5 checksum for the partition table",
                "type": "bool"
            }
        ],
        "depends_on": null,
        "id": "partition-table",
        "title": "Partition Table",
        "type": "menu"
    },
    {
        "children": [
            {
                "children": [
                    {
                        "children": [],
                        "depends_on": "<choice COMPILER_OPTIMIZATION>",
                        "help": null,
                        "id": "COMPILER_OPTIMIZATION_DEFAULT",
                        "name": "COMPILER_OPTIMIZATION_DEFAULT",
                        "range": null,
                        "title": "Debug (-Og)",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "<choice COMPILER_OPTIMIZATION>",
                        "help": null,
                        "id": "COMPILER_OPTIMIZATION_SIZE",
                        "name": "COMPILER_OPTIMIZATION_SIZE",
                        "range": null,
                        "title": "Optimize for size (-Os)",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "<choice COMPILER_OPTIMIZATION>",
                        "help": null,
                        "id": "COMPILER_OPTIMIZATION_PERF",
                        "name": "COMPILER_OPTIMIZATION_PERF",
                        "range": null,
                        "title": "Optimize for performance (-O2)",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "<choice COMPILER_OPTIMIZATION>",
                        "help": null,
                        "id": "COMPILER_OPTIMIZATION_NONE",
                        "name": "COMPILER_OPTIMIZATION_NONE",
                        "range": null,
                        "title": "Debug without optimization (-O0)",
                        "type": "bool"
                    }
                ],
                "depends_on": null,
                "help": "This option sets compiler optimization level (gcc -O argument) for the app.\n\n- The \"Default\" setting will add the -0g flag to CFLAGS.\n- The \"Size\" setting will add the -0s flag to CFLAGS.\n- The \"Performance\" setting will add the -O2 flag to CFLAGS.\n- The \"None\" setting will add the -O0 flag to CFLAGS.\n\nThe \"Size\" setting cause the compiled code to be smaller and faster, but\nmay lead to difficulties of correlating code addresses to source file\nlines when debugging.\n\nThe \"Performance\" setting causes the compiled code to be larger and faster,\nbut will be easier to correlated code addresses to source file lines.\n\n\"None\" with -O0 produces compiled code without optimization.\n\nNote that custom optimization levels may be unsupported.\n\nCompiler optimization for the IDF bootloader is set separately,\nsee the BOOTLOADER_COMPILER_OPTIMIZATION setting.",
                "id": "compiler-options-optimization-level",
                "name": "COMPILER_OPTIMIZATION",
                "title": "Optimization Level",
                "type": "choice"
            },
            {
                "children": [
                    {
                        "children": [],
                        "depends_on": "<choice COMPILER_OPTIMIZATION_ASSERTION_LEVEL>",
                        "help": "Enable assertions. Assertion content and line number will be printed on failure.",
                        "id": "COMPILER_OPTIMIZATION_ASSERTIONS_ENABLE",
                        "name": "COMPILER_OPTIMIZATION_ASSERTIONS_ENABLE",
                        "range": null,
                        "title": "Enabled",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "<choice COMPILER_OPTIMIZATION_ASSERTION_LEVEL>",
                        "help": "Enable silent assertions. Failed assertions will abort(), user needs to\nuse the aborting address to find the line number with the failed assertion.",
                        "id": "COMPILER_OPTIMIZATION_ASSERTIONS_SILENT",
                        "name": "COMPILER_OPTIMIZATION_ASSERTIONS_SILENT",
                        "range": null,
                        "title": "Silent (saves code size)",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "<choice COMPILER_OPTIMIZATION_ASSERTION_LEVEL>",
                        "help": "If assertions are disabled, -DNDEBUG is added to CPPFLAGS.",
                        "id": "COMPILER_OPTIMIZATION_ASSERTIONS_DISABLE",
                        "name": "COMPILER_OPTIMIZATION_ASSERTIONS_DISABLE",
                        "range": null,
                        "title": "Disabled (sets -DNDEBUG)",
                        "type": "bool"
                    }
                ],
                "depends_on": null,
                "help": "Assertions can be:\n\n- Enabled. Failure will print verbose assertion details. This is the default.\n\n- Set to \"silent\" to save code size (failed assertions will abort() but user\n  needs to use the aborting address to find the line number with the failed assertion.)\n\n- Disabled entirely (not recommended for most configurations.) -DNDEBUG is added\n  to CPPFLAGS in this case.",
                "id": "compiler-options-assertion-level",
                "name": "COMPILER_OPTIMIZATION_ASSERTION_LEVEL",
                "title": "Assertion level",
                "type": "choice"
            },
            {
                "children": [
                    {
                        "children": [],
                        "depends_on": "COMPILER_CXX_EXCEPTIONS",
                        "help": "Size (in bytes) of the emergency memory pool for C++ exceptions. This pool will be used to allocate\nmemory for thrown exceptions when there is not enough memory on the heap.",
                        "id": "COMPILER_CXX_EXCEPTIONS_EMG_POOL_SIZE",
                        "name": "COMPILER_CXX_EXCEPTIONS_EMG_POOL_SIZE",
                        "range": null,
                        "title": "Emergency Pool Size",
                        "type": "int"
                    }
                ],
                "depends_on": null,
                "help": "Enabling this option compiles all IDF C++ files with exception support enabled.\n\nDisabling this option disables C++ exception support in all compiled files, and any libstdc++ code\nwhich throws an exception will abort instead.\n\nEnabling this option currently adds an additional ~500 bytes of heap overhead\nwhen an exception is thrown in user code for the first time.",
                "id": "COMPILER_CXX_EXCEPTIONS",
                "is_menuconfig": true,
                "name": "COMPILER_CXX_EXCEPTIONS",
                "range": null,
                "title": "Enable C++ exceptions",
                "type": "menu"
            },
            {
                "children": [],
                "depends_on": null,
                "help": "Enabling this option compiles all C++ files with RTTI support enabled.\nThis increases binary size (typically by tens of kB) but allows using\ndynamic_cast conversion and typeid operator.",
                "id": "COMPILER_CXX_RTTI",
                "name": "COMPILER_CXX_RTTI",
                "range": null,
                "title": "Enable C++ run-time type info (RTTI)",
                "type": "bool"
            },
            {
                "children": [
                    {
                        "children": [],
                        "depends_on": "<choice COMPILER_STACK_CHECK_MODE>",
                        "help": null,
                        "id": "COMPILER_STACK_CHECK_MODE_NONE",
                        "name": "COMPILER_STACK_CHECK_MODE_NONE",
                        "range": null,
                        "title": "None",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "<choice COMPILER_STACK_CHECK_MODE>",
                        "help": null,
                        "id": "COMPILER_STACK_CHECK_MODE_NORM",
                        "name": "COMPILER_STACK_CHECK_MODE_NORM",
                        "range": null,
                        "title": "Normal",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "<choice COMPILER_STACK_CHECK_MODE>",
                        "help": null,
                        "id": "COMPILER_STACK_CHECK_MODE_STRONG",
                        "name": "COMPILER_STACK_CHECK_MODE_STRONG",
                        "range": null,
                        "title": "Strong",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "<choice COMPILER_STACK_CHECK_MODE>",
                        "help": null,
                        "id": "COMPILER_STACK_CHECK_MODE_ALL",
                        "name": "COMPILER_STACK_CHECK_MODE_ALL",
                        "range": null,
                        "title": "Overall",
                        "type": "bool"
                    }
                ],
                "depends_on": null,
                "help": "Stack smashing protection mode. Emit extra code to check for buffer overflows, such as stack\nsmashing attacks. This is done by adding a guard variable to functions with vulnerable objects.\nThe guards are initialized when a function is entered and then checked when the function exits.\nIf a guard check fails, program is halted. Protection has the following modes:\n\n- In NORMAL mode (GCC flag: -fstack-protector) only functions that call alloca, and functions with\n  buffers larger than 8 bytes are protected.\n\n- STRONG mode (GCC flag: -fstack-protector-strong) is like NORMAL, but includes additional functions\n  to be protected -- those that have local array definitions, or have references to local frame\n  addresses.\n\n- In OVERALL mode (GCC flag: -fstack-protector-all) all functions are protected.\n\nModes have the following impact on code performance and coverage:\n\n- performance: NORMAL > STRONG > OVERALL\n\n- coverage: NORMAL < STRONG < OVERALL",
                "id": "compiler-options-stack-smashing-protection-mode",
                "name": "COMPILER_STACK_CHECK_MODE",
                "title": "Stack smashing protection mode",
                "type": "choice"
            },
            {
                "children": [],
                "depends_on": null,
                "help": "Stack smashing protection.",
                "id": "COMPILER_STACK_CHECK",
                "name": "COMPILER_STACK_CHECK",
                "range": null,
                "title": null,
                "type": "bool"
            },
            {
                "children": [],
                "depends_on": null,
                "help": "Adds -Wwrite-strings flag for the C/C++ compilers.\n\nFor C, this gives string constants the type ``const char[]`` so that\ncopying the address of one into a non-const ``char *`` pointer\nproduces a warning. This warning helps to find at compile time code\nthat tries to write into a string constant.\n\nFor C++, this warns about the deprecated conversion from string\nliterals to ``char *``.",
                "id": "COMPILER_WARN_WRITE_STRINGS",
                "name": "COMPILER_WARN_WRITE_STRINGS",
                "range": null,
                "title": "Enable -Wwrite-strings warning flag",
                "type": "bool"
            },
            {
                "children": [],
                "depends_on": null,
                "help": "Enable this option if using GCC 6 or newer, and wanting to disable warnings which don't appear with\nGCC 5.",
                "id": "COMPILER_DISABLE_GCC8_WARNINGS",
                "name": "COMPILER_DISABLE_GCC8_WARNINGS",
                "range": null,
                "title": "Disable new warnings introduced in GCC 6 - 8",
                "type": "bool"
            },
            {
                "children": [],
                "depends_on": null,
                "help": "If enabled, RTL files will be produced during compilation. These files\ncan be used by other tools, for example to calculate call graphs.",
                "id": "COMPILER_DUMP_RTL_FILES",
                "name": "COMPILER_DUMP_RTL_FILES",
                "range": null,
                "title": "Dump RTL files during compilation",
                "type": "bool"
            }
        ],
        "depends_on": null,
        "id": "compiler-options",
        "title": "Compiler options",
        "type": "menu"
    },
    {
        "children": [
            {
                "children": [
                    {
                        "children": [
                            {
                                "children": [],
                                "depends_on": "EFUSE_CUSTOM_TABLE",
                                "help": "Name of the custom eFuse CSV filename. This path is evaluated\nrelative to the project root directory.",
                                "id": "EFUSE_CUSTOM_TABLE_FILENAME",
                                "name": "EFUSE_CUSTOM_TABLE_FILENAME",
                                "range": null,
                                "title": "Custom eFuse CSV file",
                                "type": "string"
                            }
                        ],
                        "depends_on": null,
                        "help": "Allows to generate a structure for eFuse from the CSV file.",
                        "id": "EFUSE_CUSTOM_TABLE",
                        "name": "EFUSE_CUSTOM_TABLE",
                        "range": null,
                        "title": "Use custom eFuse table",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": null,
                        "help": "All read and writes operations are redirected to RAM instead of eFuse registers.\nIf this option is set, all permanent changes (via eFuse) are disabled.\nLog output will state changes which would be applied, but they will not be.",
                        "id": "EFUSE_VIRTUAL",
                        "name": "EFUSE_VIRTUAL",
                        "range": null,
                        "title": "Simulate eFuse operations in RAM",
                        "type": "bool"
                    },
                    {
                        "children": [
                            {
                                "children": [],
                                "depends_on": "<choice EFUSE_CODE_SCHEME_SELECTOR>",
                                "help": null,
                                "id": "EFUSE_CODE_SCHEME_COMPAT_NONE",
                                "name": "EFUSE_CODE_SCHEME_COMPAT_NONE",
                                "range": null,
                                "title": "None Only",
                                "type": "bool"
                            },
                            {
                                "children": [],
                                "depends_on": "<choice EFUSE_CODE_SCHEME_SELECTOR>",
                                "help": null,
                                "id": "EFUSE_CODE_SCHEME_COMPAT_3_4",
                                "name": "EFUSE_CODE_SCHEME_COMPAT_3_4",
                                "range": null,
                                "title": "3/4 and None",
                                "type": "bool"
                            },
                            {
                                "children": [],
                                "depends_on": "<choice EFUSE_CODE_SCHEME_SELECTOR>",
                                "help": null,
                                "id": "EFUSE_CODE_SCHEME_COMPAT_REPEAT",
                                "name": "EFUSE_CODE_SCHEME_COMPAT_REPEAT",
                                "range": null,
                                "title": "Repeat, 3/4 and None (common table does not support it)",
                                "type": "bool"
                            }
                        ],
                        "depends_on": "IDF_TARGET_ESP32",
                        "help": "Selector eFuse code scheme.",
                        "id": "component-config-efuse-bit-manager-coding-scheme-compatibility",
                        "name": "EFUSE_CODE_SCHEME_SELECTOR",
                        "title": "Coding Scheme Compatibility",
                        "type": "choice"
                    },
                    {
                        "children": [],
                        "depends_on": null,
                        "help": null,
                        "id": "EFUSE_MAX_BLK_LEN",
                        "name": "EFUSE_MAX_BLK_LEN",
                        "range": null,
                        "title": null,
                        "type": "int"
                    }
                ],
                "depends_on": null,
                "id": "component-config-efuse-bit-manager",
                "title": "eFuse Bit Manager",
                "type": "menu"
            },
            {
                "children": [
                    {
                        "children": [],
                        "depends_on": "!FREERTOS_UNICORE && ESP32_SPIRAM_SUPPORT",
                        "help": null,
                        "id": "ESP32_ECO3_CACHE_LOCK_FIX",
                        "name": "ESP32_ECO3_CACHE_LOCK_FIX",
                        "range": null,
                        "title": null,
                        "type": "bool"
                    },
                    {
                        "children": [
                            {
                                "children": [],
                                "depends_on": "<choice ESP32_REV_MIN>",
                                "help": null,
                                "id": "ESP32_REV_MIN_0",
                                "name": "ESP32_REV_MIN_0",
                                "range": null,
                                "title": "Rev 0",
                                "type": "bool"
                            },
                            {
                                "children": [],
                                "depends_on": "<choice ESP32_REV_MIN>",
                                "help": null,
                                "id": "ESP32_REV_MIN_1",
                                "name": "ESP32_REV_MIN_1",
                                "range": null,
                                "title": "Rev 1",
                                "type": "bool"
                            },
                            {
                                "children": [],
                                "depends_on": "<choice ESP32_REV_MIN>",
                                "help": null,
                                "id": "ESP32_REV_MIN_2",
                                "name": "ESP32_REV_MIN_2",
                                "range": null,
                                "title": "Rev 2",
                                "type": "bool"
                            },
                            {
                                "children": [],
                                "depends_on": "<choice ESP32_REV_MIN>",
                                "help": null,
                                "id": "ESP32_REV_MIN_3",
                                "name": "ESP32_REV_MIN_3",
                                "range": null,
                                "title": "Rev 3",
                                "type": "bool"
                            }
                        ],
                        "depends_on": null,
                        "help": "Minimum revision that ESP-IDF would support.\nESP-IDF performs different strategy on different esp32 revision.",
                        "id": "component-config-esp32-specific-minimum-supported-esp32-revision",
                        "name": "ESP32_REV_MIN",
                        "title": "Minimum Supported ESP32 Revision",
                        "type": "choice"
                    },
                    {
                        "children": [],
                        "depends_on": null,
                        "help": null,
                        "id": "ESP32_REV_MIN",
                        "name": "ESP32_REV_MIN",
                        "range": null,
                        "title": null,
                        "type": "int"
                    },
                    {
                        "children": [],
                        "depends_on": null,
                        "help": null,
                        "id": "ESP32_DPORT_WORKAROUND",
                        "name": "ESP32_DPORT_WORKAROUND",
                        "range": null,
                        "title": null,
                        "type": "bool"
                    },
                    {
                        "children": [
                            {
                                "children": [],
                                "depends_on": "<choice ESP32_DEFAULT_CPU_FREQ_MHZ>",
                                "help": null,
                                "id": "ESP32_DEFAULT_CPU_FREQ_80",
                                "name": "ESP32_DEFAULT_CPU_FREQ_80",
                                "range": null,
                                "title": "80 MHz",
                                "type": "bool"
                            },
                            {
                                "children": [],
                                "depends_on": "<choice ESP32_DEFAULT_CPU_FREQ_MHZ>",
                                "help": null,
                                "id": "ESP32_DEFAULT_CPU_FREQ_160",
                                "name": "ESP32_DEFAULT_CPU_FREQ_160",
                                "range": null,
                                "title": "160 MHz",
                                "type": "bool"
                            },
                            {
                                "children": [],
                                "depends_on": "<choice ESP32_DEFAULT_CPU_FREQ_MHZ>",
                                "help": null,
                                "id": "ESP32_DEFAULT_CPU_FREQ_240",
                                "name": "ESP32_DEFAULT_CPU_FREQ_240",
                                "range": null,
                                "title": "240 MHz",
                                "type": "bool"
                            }
                        ],
                        "depends_on": null,
                        "help": "CPU frequency to be set on application startup.",
                        "id": "component-config-esp32-specific-cpu-frequency",
                        "name": "ESP32_DEFAULT_CPU_FREQ_MHZ",
                        "title": "CPU frequency",
                        "type": "choice"
                    },
                    {
                        "children": [],
                        "depends_on": null,
                        "help": null,
                        "id": "ESP32_DEFAULT_CPU_FREQ_MHZ",
                        "name": "ESP32_DEFAULT_CPU_FREQ_MHZ",
                        "range": null,
                        "title": null,
                        "type": "int"
                    },
                    {
                        "children": [
                            {
                                "children": [
                                    {
                                        "children": [
                                            {
                                                "children": [],
                                                "depends_on": "<choice SPIRAM_TYPE>",
                                                "help": null,
                                                "id": "SPIRAM_TYPE_AUTO",
                                                "name": "SPIRAM_TYPE_AUTO",
                                                "range": null,
                                                "title": "Auto-detect",
                                                "type": "bool"
                                            },
                                            {
                                                "children": [],
                                                "depends_on": "<choice SPIRAM_TYPE>",
                                                "help": null,
                                                "id": "SPIRAM_TYPE_ESPPSRAM16",
                                                "name": "SPIRAM_TYPE_ESPPSRAM16",
                                                "range": null,
                                                "title": "ESP-PSRAM16 or APS1604",
                                                "type": "bool"
                                            },
                                            {
                                                "children": [],
                                                "depends_on": "<choice SPIRAM_TYPE>",
                                                "help": null,
                                                "id": "SPIRAM_TYPE_ESPPSRAM32",
                                                "name": "SPIRAM_TYPE_ESPPSRAM32",
                                                "range": null,
                                                "title": "ESP-PSRAM32 or IS25WP032",
                                                "type": "bool"
                                            },
                                            {
                                                "children": [],
                                                "depends_on": "<choice SPIRAM_TYPE>",
                                                "help": null,
                                                "id": "SPIRAM_TYPE_ESPPSRAM64",
                                                "name": "SPIRAM_TYPE_ESPPSRAM64",
                                                "range": null,
                                                "title": "ESP-PSRAM64 or LY68L6400",
                                                "type": "bool"
                                            }
                                        ],
                                        "depends_on": "ESP32_SPIRAM_SUPPORT",
                                        "help": null,
                                        "id": "component-config-esp32-specific-support-for-external-spi-connected-ram-spi-ram-config-type-of-spi-ram-chip-in-use",
                                        "name": "SPIRAM_TYPE",
                                        "title": "Type of SPI RAM chip in use",
                                        "type": "choice"
                                    },
                                    {
                                        "children": [],
                                        "depends_on": "ESP32_SPIRAM_SUPPORT",
                                        "help": null,
                                        "id": "SPIRAM_SIZE",
                                        "name": "SPIRAM_SIZE",
                                        "range": null,
                                        "title": null,
                                        "type": "int"
                                    },
                                    {
                                        "children": [
                                            {
                                                "children": [],
                                                "depends_on": "<choice SPIRAM_SPEED>",
                                                "help": null,
                                                "id": "SPIRAM_SPEED_40M",
                                                "name": "SPIRAM_SPEED_40M",
                                                "range": null,
                                                "title": "40MHz clock speed",
                                                "type": "bool"
                                            },
                                            {
                                                "children": [],
                                                "depends_on": "ESPTOOLPY_FLASHFREQ_80M && <choice SPIRAM_SPEED>",
                                                "help": null,
                                                "id": "SPIRAM_SPEED_80M",
                                                "name": "SPIRAM_SPEED_80M",
                                                "range": null,
                                                "title": "80MHz clock speed",
                                                "type": "bool"
                                            }
                                        ],
                                        "depends_on": "ESP32_SPIRAM_SUPPORT",
                                        "help": "Select the speed for the SPI RAM chip.\nIf SPI RAM is enabled, we only support three combinations of SPI speed mode we supported now:\n\n1. Flash SPI running at 40Mhz and RAM SPI running at 40Mhz\n2. Flash SPI running at 80Mhz and RAM SPI running at 40Mhz\n3. Flash SPI running at 80Mhz and RAM SPI running at 80Mhz\n\nNote: If the third mode(80Mhz+80Mhz) is enabled for SPI RAM of type 32MBit, one of the HSPI/VSPI host\nwill be occupied by the system. Which SPI host to use can be selected by the config item\nSPIRAM_OCCUPY_SPI_HOST. Application code should never touch HSPI/VSPI hardware in this case. The\noption to select 80MHz will only be visible if the flash SPI speed is also 80MHz.\n(ESPTOOLPY_FLASHFREQ_80M is true)",
                                        "id": "component-config-esp32-specific-support-for-external-spi-connected-ram-spi-ram-config-set-ram-clock-speed",
                                        "name": "SPIRAM_SPEED",
                                        "title": "Set RAM clock speed",
                                        "type": "choice"
                                    },
                                    {
                                        "children": [],
                                        "depends_on": "ESP32_SPIRAM_SUPPORT",
                                        "help": null,
                                        "id": "SPIRAM",
                                        "name": "SPIRAM",
                                        "range": null,
                                        "title": null,
                                        "type": "bool"
                                    },
                                    {
                                        "children": [
                                            {
                                                "children": [],
                                                "depends_on": "SPIRAM_BOOT_INIT && !SPIRAM_ALLOW_BSS_SEG_EXTERNAL_MEMORY && ESP32_SPIRAM_SUPPORT",
                                                "help": "Normally, if psram initialization is enabled during compile time but not found at runtime, it\nis seen as an error making the CPU panic. If this is enabled, booting will complete\nbut no PSRAM will be available.",
                                                "id": "SPIRAM_IGNORE_NOTFOUND",
                                                "name": "SPIRAM_IGNORE_NOTFOUND",
                                                "range": null,
                                                "title": "Ignore PSRAM when not found",
                                                "type": "bool"
                                            }
                                        ],
                                        "depends_on": "ESP32_SPIRAM_SUPPORT",
                                        "help": "If this is enabled, the SPI RAM will be enabled during initial boot. Unless you\nhave specific requirements, you'll want to leave this enabled so memory allocated\nduring boot-up can also be placed in SPI RAM.",
                                        "id": "SPIRAM_BOOT_INIT",
                                        "name": "SPIRAM_BOOT_INIT",
                                        "range": null,
                                        "title": "Initialize SPI RAM during startup",
                                        "type": "bool"
                                    },
                                    {
                                        "children": [
                                            {
                                                "children": [],
                                                "depends_on": "<choice SPIRAM_USE>",
                                                "help": null,
                                                "id": "SPIRAM_USE_MEMMAP",
                                                "name": "SPIRAM_USE_MEMMAP",
                                                "range": null,
                                                "title": "Integrate RAM into memory map",
                                                "type": "bool"
                                            },
                                            {
                                                "children": [],
                                                "depends_on": "<choice SPIRAM_USE>",
                                                "help": null,
                                                "id": "SPIRAM_USE_CAPS_ALLOC",
                                                "name": "SPIRAM_USE_CAPS_ALLOC",
                                                "range": null,
                                                "title": "Make RAM allocatable using heap_caps_malloc(..., MALLOC_CAP_SPIRAM)",
                                                "type": "bool"
                                            },
                                            {
                                                "children": [],
                                                "depends_on": "<choice SPIRAM_USE>",
                                                "help": null,
                                                "id": "SPIRAM_USE_MALLOC",
                                                "name": "SPIRAM_USE_MALLOC",
                                                "range": null,
                                                "title": "Make RAM allocatable using malloc() as well",
                                                "type": "bool"
                                            }
                                        ],
                                        "depends_on": "ESP32_SPIRAM_SUPPORT",
                                        "help": "The SPI RAM can be accessed in multiple methods: by just having it available as an unmanaged\nmemory region in the CPU's memory map, by integrating it in the heap as 'special' memory\nneeding heap_caps_malloc to allocate, or by fully integrating it making malloc() also able to\nreturn SPI RAM pointers.",
                                        "id": "component-config-esp32-specific-support-for-external-spi-connected-ram-spi-ram-config-spi-ram-access-method",
                                        "name": "SPIRAM_USE",
                                        "title": "SPI RAM access method",
                                        "type": "choice"
                                    },
                                    {
                                        "children": [],
                                        "depends_on": "SPIRAM_BOOT_INIT && ESP32_SPIRAM_SUPPORT",
                                        "help": "Runs a rudimentary memory test on initialization. Aborts when memory test fails. Disable this for\nslightly faster startup.",
                                        "id": "SPIRAM_MEMTEST",
                                        "name": "SPIRAM_MEMTEST",
                                        "range": null,
                                        "title": "Run memory test on SPI RAM initialization",
                                        "type": "bool"
                                    },
                                    {
                                        "children": [],
                                        "depends_on": "SPIRAM_USE_MALLOC && ESP32_SPIRAM_SUPPORT",
                                        "help": "If malloc() is capable of also allocating SPI-connected ram, its allocation strategy will prefer to\nallocate chunks less than this size in internal memory, while allocations larger than this will be\ndone from external RAM. If allocation from the preferred region fails, an attempt is made to allocate\nfrom the non-preferred region instead, so malloc() will not suddenly fail when either internal or\nexternal memory is full.",
                                        "id": "SPIRAM_MALLOC_ALWAYSINTERNAL",
                                        "name": "SPIRAM_MALLOC_ALWAYSINTERNAL",
                                        "range": null,
                                        "title": "Maximum malloc() size, in bytes, to always put in internal memory",
                                        "type": "int"
                                    },
                                    {
                                        "children": [],
                                        "depends_on": "(SPIRAM_USE_CAPS_ALLOC || SPIRAM_USE_MALLOC) && ESP32_SPIRAM_SUPPORT",
                                        "help": "Try to allocate memories of WiFi and LWIP in SPIRAM firstly. If failed, try to allocate internal\nmemory then.",
                                        "id": "SPIRAM_TRY_ALLOCATE_WIFI_LWIP",
                                        "name": "SPIRAM_TRY_ALLOCATE_WIFI_LWIP",
                                        "range": null,
                                        "title": "Try to allocate memories of WiFi and LWIP in SPIRAM firstly. If failed, allocate internal memory",
                                        "type": "bool"
                                    },
                                    {
                                        "children": [],
                                        "depends_on": "SPIRAM_USE_MALLOC && ESP32_SPIRAM_SUPPORT",
                                        "help": "Because the external/internal RAM allocation strategy is not always perfect, it sometimes may happen\nthat the internal memory is entirely filled up. This causes allocations that are specifically done in\ninternal memory, for example the stack for new tasks or memory to service DMA or have memory that's\nalso available when SPI cache is down, to fail. This option reserves a pool specifically for requests\nlike that; the memory in this pool is not given out when a normal malloc() is called.\n\nSet this to 0 to disable this feature.\n\nNote that because FreeRTOS stacks are forced to internal memory, they will also use this memory pool;\nbe sure to keep this in mind when adjusting this value.\n\nNote also that the DMA reserved pool may not be one single contiguous memory region, depending on the\nconfigured size and the static memory usage of the app.",
                                        "id": "SPIRAM_MALLOC_RESERVE_INTERNAL",
                                        "name": "SPIRAM_MALLOC_RESERVE_INTERNAL",
                                        "range": null,
                                        "title": "Reserve this amount of bytes for data that specifically needs to be in DMA or internal memory",
                                        "type": "int"
                                    },
                                    {
                                        "children": [],
                                        "depends_on": "SPIRAM && (IDF_TARGET_ESP32 || IDF_TARGET_ESP32S2) && ESP32_SPIRAM_SUPPORT",
                                        "help": "If enabled, variables with EXT_RAM_ATTR attribute will be placed in SPIRAM instead of internal DRAM.\nBSS section of `lwip`, `net80211`, `pp`, `bt` libraries will be automatically placed\nin SPIRAM. BSS sections from other object files and libraries can also be placed in SPIRAM through\nlinker fragment scheme `extram_bss`.\n\nNote that the variables placed in SPIRAM using EXT_RAM_ATTR will be zero initialized.",
                                        "id": "SPIRAM_ALLOW_BSS_SEG_EXTERNAL_MEMORY",
                                        "name": "SPIRAM_ALLOW_BSS_SEG_EXTERNAL_MEMORY",
                                        "range": null,
                                        "title": "Allow .bss segment placed in external memory",
                                        "type": "bool"
                                    },
                                    {
                                        "children": [],
                                        "depends_on": "(SPIRAM_USE_MEMMAP || SPIRAM_USE_CAPS_ALLOC || SPIRAM_USE_MALLOC) && ESP32_REV_MIN < 3 && ESP32_SPIRAM_SUPPORT",
                                        "help": "Revision 1 of the ESP32 has a bug that can cause a write to PSRAM not to take place in some situations\nwhen the cache line needs to be fetched from external RAM and an interrupt occurs. This enables a\nfix in the compiler (-mfix-esp32-psram-cache-issue) that makes sure the specific code that is\nvulnerable to this will not be emitted.\n\nThis will also not use any bits of newlib that are located in ROM, opting for a version that is\ncompiled with the workaround and located in flash instead.\n\nThe workaround is not required for ESP32 revision 3 and above.",
                                        "id": "SPIRAM_CACHE_WORKAROUND",
                                        "name": "SPIRAM_CACHE_WORKAROUND",
                                        "range": null,
                                        "title": "Enable workaround for bug in SPI RAM cache for Rev1 ESP32s",
                                        "type": "bool"
                                    },
                                    {
                                        "children": [
                                            {
                                                "children": [
                                                    {
                                                        "children": [],
                                                        "depends_on": "<choice SPIRAM_CACHE_WORKAROUND_STRATEGY>",
                                                        "help": null,
                                                        "id": "SPIRAM_CACHE_WORKAROUND_STRATEGY_MEMW",
                                                        "name": "SPIRAM_CACHE_WORKAROUND_STRATEGY_MEMW",
                                                        "range": null,
                                                        "title": "Insert memw after vulnerable instructions (default)",
                                                        "type": "bool"
                                                    },
                                                    {
                                                        "children": [],
                                                        "depends_on": "<choice SPIRAM_CACHE_WORKAROUND_STRATEGY>",
                                                        "help": null,
                                                        "id": "SPIRAM_CACHE_WORKAROUND_STRATEGY_DUPLDST",
                                                        "name": "SPIRAM_CACHE_WORKAROUND_STRATEGY_DUPLDST",
                                                        "range": null,
                                                        "title": "Duplicate LD/ST for 32-bit, memw for 8/16 bit",
                                                        "type": "bool"
                                                    },
                                                    {
                                                        "children": [],
                                                        "depends_on": "<choice SPIRAM_CACHE_WORKAROUND_STRATEGY>",
                                                        "help": null,
                                                        "id": "SPIRAM_CACHE_WORKAROUND_STRATEGY_NOPS",
                                                        "name": "SPIRAM_CACHE_WORKAROUND_STRATEGY_NOPS",
                                                        "range": null,
                                                        "title": "Insert nops between vulnerable loads/stores (old strategy, obsolete)",
                                                        "type": "bool"
                                                    }
                                                ],
                                                "depends_on": "SPIRAM_CACHE_WORKAROUND && ESP32_SPIRAM_SUPPORT",
                                                "help": "Select the workaround strategy. Note that the strategy for precompiled\nlibraries (libgcc, newlib, bt, wifi) is not affected by this selection.\n\nUnless you know you need a different strategy, it's suggested you stay\nwith the default MEMW strategy. Note that DUPLDST can interfere with hardware\nencryption and this will be automatically disabled if this workaround is selected.\n'Insert nops' is the workaround that was used in older esp-idf versions. This workaround\nstill can cause faulty data transfers from/to SPI RAM in some situation.",
                                                "id": "component-config-esp32-specific-support-for-external-spi-connected-ram-spi-ram-config-spiram-cache-workaround-debugging-workaround-strategy",
                                                "name": "SPIRAM_CACHE_WORKAROUND_STRATEGY",
                                                "title": "Workaround strategy",
                                                "type": "choice"
                                            },
                                            {
                                                "children": [],
                                                "depends_on": "ESP32_SPIRAM_SUPPORT",
                                                "help": null,
                                                "id": "SPIRAM_WORKAROUND_NEED_VOLATILE_SPINLOCK",
                                                "name": "SPIRAM_WORKAROUND_NEED_VOLATILE_SPINLOCK",
                                                "range": null,
                                                "title": null,
                                                "type": "bool"
                                            }
                                        ],
                                        "depends_on": "ESP32_SPIRAM_SUPPORT",
                                        "id": "component-config-esp32-specific-support-for-external-spi-connected-ram-spi-ram-config-spiram-cache-workaround-debugging",
                                        "title": "SPIRAM cache workaround debugging",
                                        "type": "menu"
                                    },
                                    {
                                        "children": [
                                            {
                                                "children": [],
                                                "depends_on": "SPIRAM_BANKSWITCH_ENABLE && ESP32_SPIRAM_SUPPORT",
                                                "help": "Select the amount of banks reserved for bank switching. Note that the amount of RAM allocatable with\nmalloc/esp_heap_alloc_caps will decrease by 32K for each page reserved here.\n\nNote that this reservation is only actually done if your program actually uses the himem API. Without\nany himem calls, the reservation is not done and the original amount of memory will be available\nto malloc/esp_heap_alloc_caps.",
                                                "id": "SPIRAM_BANKSWITCH_RESERVE",
                                                "name": "SPIRAM_BANKSWITCH_RESERVE",
                                                "range": null,
                                                "title": "Amount of 32K pages to reserve for bank switching",
                                                "type": "int"
                                            }
                                        ],
                                        "depends_on": "(SPIRAM_USE_MEMMAP || SPIRAM_USE_CAPS_ALLOC || SPIRAM_USE_MALLOC) && ESP32_SPIRAM_SUPPORT",
                                        "help": "The ESP32 only supports 4MiB of external RAM in its address space. The hardware does support larger\nmemories, but these have to be bank-switched in and out of this address space. Enabling this allows you\nto reserve some MMU pages for this, which allows the use of the esp_himem api to manage these banks.\n\n#Note that this is limited to 62 banks, as esp_spiram_writeback_cache needs some kind of mapping of\n#some banks below that mark to work. We cannot at this moment guarantee this to exist when himem is\n#enabled.\n\nIf spiram 2T mode is enabled, the size of 64Mbit psram will be changed as 32Mbit, so himem will be\nunusable.",
                                        "id": "SPIRAM_BANKSWITCH_ENABLE",
                                        "name": "SPIRAM_BANKSWITCH_ENABLE",
                                        "range": null,
                                        "title": "Enable bank switching for >4MiB external RAM",
                                        "type": "bool"
                                    },
                                    {
                                        "children": [],
                                        "depends_on": "SPIRAM_USE_MALLOC && ESP32_SPIRAM_SUPPORT",
                                        "help": "Because some bits of the ESP32 code environment cannot be recompiled with the cache workaround,\nnormally tasks cannot be safely run with their stack residing in external memory; for this reason\nxTaskCreate and friends always allocate stack in internal memory and xTaskCreateStatic will check if\nthe memory passed to it is in internal memory. If you have a task that needs a large amount of stack\nand does not call on ROM code in any way (no direct calls, but also no Bluetooth/WiFi), you can try to\ndisable this and use xTaskCreateStatic to create the tasks stack in external memory.",
                                        "id": "SPIRAM_ALLOW_STACK_EXTERNAL_MEMORY",
                                        "name": "SPIRAM_ALLOW_STACK_EXTERNAL_MEMORY",
                                        "range": null,
                                        "title": "Allow external memory as an argument to xTaskCreateStatic",
                                        "type": "bool"
                                    },
                                    {
                                        "children": [
                                            {
                                                "children": [],
                                                "depends_on": "<choice SPIRAM_OCCUPY_SPI_HOST>",
                                                "help": null,
                                                "id": "SPIRAM_OCCUPY_HSPI_HOST",
                                                "name": "SPIRAM_OCCUPY_HSPI_HOST",
                                                "range": null,
                                                "title": "HSPI host (SPI2)",
                                                "type": "bool"
                                            },
                                            {
                                                "children": [],
                                                "depends_on": "<choice SPIRAM_OCCUPY_SPI_HOST>",
                                                "help": null,
                                                "id": "SPIRAM_OCCUPY_VSPI_HOST",
                                                "name": "SPIRAM_OCCUPY_VSPI_HOST",
                                                "range": null,
                                                "title": "VSPI host (SPI3)",
                                                "type": "bool"
                                            },
                                            {
                                                "children": [],
                                                "depends_on": "<choice SPIRAM_OCCUPY_SPI_HOST>",
                                                "help": null,
                                                "id": "SPIRAM_OCCUPY_NO_HOST",
                                                "name": "SPIRAM_OCCUPY_NO_HOST",
                                                "range": null,
                                                "title": "Will not try to use any host, will abort if not able to use the PSRAM",
                                                "type": "bool"
                                            }
                                        ],
                                        "depends_on": "SPIRAM_SPEED_80M && ESP32_SPIRAM_SUPPORT",
                                        "help": "When both flash and PSRAM is working under 80MHz, and the PSRAM is of type 32MBit, one of the HSPI/VSPI\nhost will be used to output the clock. Select which one to use here.",
                                        "id": "component-config-esp32-specific-support-for-external-spi-connected-ram-spi-ram-config-spi-host-to-use-for-32mbit-psram",
                                        "name": "SPIRAM_OCCUPY_SPI_HOST",
                                        "title": "SPI host to use for 32MBit PSRAM",
                                        "type": "choice"
                                    },
                                    {
                                        "children": [
                                            {
                                                "children": [],
                                                "depends_on": "ESP32_SPIRAM_SUPPORT && ESP32_SPIRAM_SUPPORT",
                                                "help": "The PSRAM CLOCK IO can be any unused GPIO, user can config it based on hardware design. If user use\n1.8V flash and 1.8V psram, this value can only be one of 6, 7, 8, 9, 10, 11, 16, 17.",
                                                "id": "D0WD_PSRAM_CLK_IO",
                                                "name": "D0WD_PSRAM_CLK_IO",
                                                "range": null,
                                                "title": "PSRAM CLK IO number",
                                                "type": "int"
                                            },
                                            {
                                                "children": [],
                                                "depends_on": "ESP32_SPIRAM_SUPPORT && ESP32_SPIRAM_SUPPORT",
                                                "help": "The PSRAM CS IO can be any unused GPIO, user can config it based on hardware design. If user use\n1.8V flash and 1.8V psram, this value can only be one of 6, 7, 8, 9, 10, 11, 16, 17.",
                                                "id": "D0WD_PSRAM_CS_IO",
                                                "name": "D0WD_PSRAM_CS_IO",
                                                "range": null,
                                                "title": "PSRAM CS IO number",
                                                "type": "int"
                                            }
                                        ],
                                        "depends_on": "ESP32_SPIRAM_SUPPORT",
                                        "id": "component-config-esp32-specific-support-for-external-spi-connected-ram-spi-ram-config-psram-clock-and-cs-io-for-esp32-dowd",
                                        "title": "PSRAM clock and cs IO for ESP32-DOWD",
                                        "type": "menu"
                                    },
                                    {
                                        "children": [
                                            {
                                                "children": [],
                                                "depends_on": "ESP32_SPIRAM_SUPPORT && ESP32_SPIRAM_SUPPORT",
                                                "help": "User can config it based on hardware design. For ESP32-D2WD chip, the psram can only be 1.8V psram,\nso this value can only be one of 6, 7, 8, 9, 10, 11, 16, 17.",
                                                "id": "D2WD_PSRAM_CLK_IO",
                                                "name": "D2WD_PSRAM_CLK_IO",
                                                "range": null,
                                                "title": "PSRAM CLK IO number",
                                                "type": "int"
                                            },
                                            {
                                                "children": [],
                                                "depends_on": "ESP32_SPIRAM_SUPPORT && ESP32_SPIRAM_SUPPORT",
                                                "help": "User can config it based on hardware design. For ESP32-D2WD chip, the psram can only be 1.8V psram,\nso this value can only be one of 6, 7, 8, 9, 10, 11, 16, 17.",
                                                "id": "D2WD_PSRAM_CS_IO",
                                                "name": "D2WD_PSRAM_CS_IO",
                                                "range": null,
                                                "title": "PSRAM CS IO number",
                                                "type": "int"
                                            }
                                        ],
                                        "depends_on": "ESP32_SPIRAM_SUPPORT",
                                        "id": "component-config-esp32-specific-support-for-external-spi-connected-ram-spi-ram-config-psram-clock-and-cs-io-for-esp32-d2wd",
                                        "title": "PSRAM clock and cs IO for ESP32-D2WD",
                                        "type": "menu"
                                    },
                                    {
                                        "children": [
                                            {
                                                "children": [],
                                                "depends_on": "ESP32_SPIRAM_SUPPORT && ESP32_SPIRAM_SUPPORT",
                                                "help": "The PSRAM CS IO can be any unused GPIO, user can config it based on hardware design.\n\nFor ESP32-PICO chip, the psram share clock with flash, so user do not need to configure the clock\nIO.\nFor the reference hardware design, please refer to\nhttps://www.espressif.com/sites/default/files/documentation/esp32-pico-d4_datasheet_en.pdf",
                                                "id": "PICO_PSRAM_CS_IO",
                                                "name": "PICO_PSRAM_CS_IO",
                                                "range": null,
                                                "title": "PSRAM CS IO number",
                                                "type": "int"
                                            }
                                        ],
                                        "depends_on": "ESP32_SPIRAM_SUPPORT",
                                        "id": "component-config-esp32-specific-support-for-external-spi-connected-ram-spi-ram-config-psram-clock-and-cs-io-for-esp32-pico",
                                        "title": "PSRAM clock and cs IO for ESP32-PICO",
                                        "type": "menu"
                                    },
                                    {
                                        "children": [],
                                        "depends_on": "IDF_TARGET_ESP32 && (ESPTOOLPY_FLASHMODE_DIO || ESPTOOLPY_FLASHMODE_DOUT) && ESP32_SPIRAM_SUPPORT",
                                        "help": "This setting is only used if the SPI flash pins have been overridden by setting the eFuses\nSPI_PAD_CONFIG_xxx, and the SPI flash mode is DIO or DOUT.\n\nWhen this is the case, the eFuse config only defines 3 of the 4 Quad I/O data pins. The WP pin (aka\nESP32 pin \"SD_DATA_3\" or SPI flash pin \"IO2\") is not specified in eFuse. The psram only has QPI\nmode, so a WP pin setting is necessary.\n\nIf this config item is set to N (default), the correct WP pin will be automatically used for any\nEspressif chip or module with integrated flash. If a custom setting is needed, set this config item\nto Y and specify the GPIO number connected to the WP pin.\n\nWhen flash mode is set to QIO or QOUT, the PSRAM WP pin will be set the same as the SPI Flash WP pin\nconfigured in the bootloader.",
                                        "id": "SPIRAM_CUSTOM_SPIWP_SD3_PIN",
                                        "name": "SPIRAM_CUSTOM_SPIWP_SD3_PIN",
                                        "range": null,
                                        "title": "Use custom SPI PSRAM WP(SD3) Pin when flash pins set in eFuse (read help)",
                                        "type": "bool"
                                    },
                                    {
                                        "children": [],
                                        "depends_on": "IDF_TARGET_ESP32 && (ESPTOOLPY_FLASHMODE_DIO || ESPTOOLPY_FLASHMODE_DOUT) && ESP32_SPIRAM_SUPPORT",
                                        "help": "The option \"Use custom SPI PSRAM WP(SD3) pin\" must be set or this value is ignored\n\nIf burning a customized set of SPI flash pins in eFuse and using DIO or DOUT mode for flash, set this\nvalue to the GPIO number of the SPIRAM WP pin.",
                                        "id": "SPIRAM_SPIWP_SD3_PIN",
                                        "name": "SPIRAM_SPIWP_SD3_PIN",
                                        "range": null,
                                        "title": "Custom SPI PSRAM WP(SD3) Pin",
                                        "type": "int"
                                    },
                                    {
                                        "children": [],
                                        "depends_on": "ESP32_SPIRAM_SUPPORT && ESP32_SPIRAM_SUPPORT",
                                        "help": "Enable this option to fix single bit errors inside 64Mbit PSRAM.\n\nSome 64Mbit PSRAM chips have a hardware issue in the RAM which causes bit errors at multiple\nfixed bit positions.\n\nNote: If this option is enabled, the 64Mbit PSRAM chip will appear to be 32Mbit in size.\nApplications will not be affected unless the use the esp_himem APIs, which are not supported\nin 2T mode.",
                                        "id": "SPIRAM_2T_MODE",
                                        "name": "SPIRAM_2T_MODE",
                                        "range": null,
                                        "title": "Enable SPI PSRAM 2T mode",
                                        "type": "bool"
                                    }
                                ],
                                "depends_on": "ESP32_SPIRAM_SUPPORT",
                                "id": "component-config-esp32-specific-support-for-external-spi-connected-ram-spi-ram-config",
                                "title": "SPI RAM config",
                                "type": "menu"
                            }
                        ],
                        "depends_on": null,
                        "help": "This enables support for an external SPI RAM chip, connected in parallel with the\nmain SPI flash chip.",
                        "id": "ESP32_SPIRAM_SUPPORT",
                        "name": "ESP32_SPIRAM_SUPPORT",
                        "range": null,
                        "title": "Support for external, SPI-connected RAM",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": null,
                        "help": null,
                        "id": "ESP32_MEMMAP_TRACEMEM",
                        "name": "ESP32_MEMMAP_TRACEMEM",
                        "range": null,
                        "title": null,
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": null,
                        "help": null,
                        "id": "ESP32_MEMMAP_TRACEMEM_TWOBANKS",
                        "name": "ESP32_MEMMAP_TRACEMEM_TWOBANKS",
                        "range": null,
                        "title": null,
                        "type": "bool"
                    },
                    {
                        "children": [
                            {
                                "children": [],
                                "depends_on": "ESP32_TRAX && !FREERTOS_UNICORE",
                                "help": "The ESP32 contains a feature which allows you to trace the execution path the processor\nhas taken through the program. This is stored in a chunk of 32K (16K for single-processor)\nof memory that can't be used for general purposes anymore. Disable this if you do not know\nwhat this is.\n\n# Memory to reverse for trace, used in linker script",
                                "id": "ESP32_TRAX_TWOBANKS",
                                "name": "ESP32_TRAX_TWOBANKS",
                                "range": null,
                                "title": "Reserve memory for tracing both pro as well as app cpu execution",
                                "type": "bool"
                            }
                        ],
                        "depends_on": null,
                        "help": "The ESP32 contains a feature which allows you to trace the execution path the processor\nhas taken through the program. This is stored in a chunk of 32K (16K for single-processor)\nof memory that can't be used for general purposes anymore. Disable this if you do not know\nwhat this is.",
                        "id": "ESP32_TRAX",
                        "name": "ESP32_TRAX",
                        "range": null,
                        "title": "Use TRAX tracing feature",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": null,
                        "help": null,
                        "id": "ESP32_TRACEMEM_RESERVE_DRAM",
                        "name": "ESP32_TRACEMEM_RESERVE_DRAM",
                        "range": null,
                        "title": null,
                        "type": "hex"
                    },
                    {
                        "children": [
                            {
                                "children": [],
                                "depends_on": "<choice ESP32_UNIVERSAL_MAC_ADDRESSES>",
                                "help": null,
                                "id": "ESP32_UNIVERSAL_MAC_ADDRESSES_TWO",
                                "name": "ESP32_UNIVERSAL_MAC_ADDRESSES_TWO",
                                "range": null,
                                "title": "Two",
                                "type": "bool"
                            },
                            {
                                "children": [],
                                "depends_on": "<choice ESP32_UNIVERSAL_MAC_ADDRESSES>",
                                "help": null,
                                "id": "ESP32_UNIVERSAL_MAC_ADDRESSES_FOUR",
                                "name": "ESP32_UNIVERSAL_MAC_ADDRESSES_FOUR",
                                "range": null,
                                "title": "Four",
                                "type": "bool"
                            }
                        ],
                        "depends_on": null,
                        "help": "Configure the number of universally administered (by IEEE) MAC addresses.\nDuring initialization, MAC addresses for each network interface are generated or derived from a\nsingle base MAC address.\nIf the number of universal MAC addresses is four, all four interfaces (WiFi station, WiFi softap,\nBluetooth and Ethernet) receive a universally administered MAC address. These are generated\nsequentially by adding 0, 1, 2 and 3 (respectively) to the final octet of the base MAC address.\nIf the number of universal MAC addresses is two, only two interfaces (WiFi station and Bluetooth)\nreceive a universally administered MAC address. These are generated sequentially by adding 0\nand 1 (respectively) to the base MAC address. The remaining two interfaces (WiFi softap and Ethernet)\nreceive local MAC addresses. These are derived from the universal WiFi station and Bluetooth MAC\naddresses, respectively.\nWhen using the default (Espressif-assigned) base MAC address, either setting can be used. When using\na custom universal MAC address range, the correct setting will depend on the allocation of MAC\naddresses in this range (either 2 or 4 per device.)",
                        "id": "component-config-esp32-specific-number-of-universally-administered-by-ieee-mac-address",
                        "name": "ESP32_UNIVERSAL_MAC_ADDRESSES",
                        "title": "Number of universally administered (by IEEE) MAC address",
                        "type": "choice"
                    },
                    {
                        "children": [],
                        "depends_on": null,
                        "help": null,
                        "id": "ESP32_UNIVERSAL_MAC_ADDRESSES",
                        "name": "ESP32_UNIVERSAL_MAC_ADDRESSES",
                        "range": null,
                        "title": null,
                        "type": "int"
                    },
                    {
                        "children": [
                            {
                                "children": [],
                                "depends_on": null,
                                "help": "Bytes of memory to reserve for ULP coprocessor firmware & data.\n\nData is reserved at the beginning of RTC slow memory.",
                                "id": "ESP32_ULP_COPROC_RESERVE_MEM",
                                "name": "ESP32_ULP_COPROC_RESERVE_MEM",
                                "range": [
                                    0,
                                    0
                                ],
                                "title": "RTC slow memory reserved for coprocessor",
                                "type": "int"
                            }
                        ],
                        "depends_on": null,
                        "help": "Set to 'y' if you plan to load a firmware for the coprocessor.\n\nIf this option is enabled, further coprocessor configuration will appear in the Components menu.",
                        "id": "ESP32_ULP_COPROC_ENABLED",
                        "name": "ESP32_ULP_COPROC_ENABLED",
                        "range": null,
                        "title": "Enable Ultra Low Power (ULP) Coprocessor",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": null,
                        "help": "The FreeRTOS panic and unhandled exception handers can detect a JTAG OCD debugger and\ninstead of panicking, have the debugger stop on the offending instruction.",
                        "id": "ESP32_DEBUG_OCDAWARE",
                        "name": "ESP32_DEBUG_OCDAWARE",
                        "range": null,
                        "title": "Make exception and panic handlers JTAG/OCD aware",
                        "type": "bool"
                    },
                    {
                        "children": [
                            {
                                "children": [
                                    {
                                        "children": [],
                                        "depends_on": "<choice ESP32_BROWNOUT_DET_LVL_SEL>",
                                        "help": null,
                                        "id": "ESP32_BROWNOUT_DET_LVL_SEL_0",
                                        "name": "ESP32_BROWNOUT_DET_LVL_SEL_0",
                                        "range": null,
                                        "title": "2.43V +/- 0.05",
                                        "type": "bool"
                                    },
                                    {
                                        "children": [],
                                        "depends_on": "<choice ESP32_BROWNOUT_DET_LVL_SEL>",
                                        "help": null,
                                        "id": "ESP32_BROWNOUT_DET_LVL_SEL_1",
                                        "name": "ESP32_BROWNOUT_DET_LVL_SEL_1",
                                        "range": null,
                                        "title": "2.48V +/- 0.05",
                                        "type": "bool"
                                    },
                                    {
                                        "children": [],
                                        "depends_on": "<choice ESP32_BROWNOUT_DET_LVL_SEL>",
                                        "help": null,
                                        "id": "ESP32_BROWNOUT_DET_LVL_SEL_2",
                                        "name": "ESP32_BROWNOUT_DET_LVL_SEL_2",
                                        "range": null,
                                        "title": "2.58V +/- 0.05",
                                        "type": "bool"
                                    },
                                    {
                                        "children": [],
                                        "depends_on": "<choice ESP32_BROWNOUT_DET_LVL_SEL>",
                                        "help": null,
                                        "id": "ESP32_BROWNOUT_DET_LVL_SEL_3",
                                        "name": "ESP32_BROWNOUT_DET_LVL_SEL_3",
                                        "range": null,
                                        "title": "2.62V +/- 0.05",
                                        "type": "bool"
                                    },
                                    {
                                        "children": [],
                                        "depends_on": "<choice ESP32_BROWNOUT_DET_LVL_SEL>",
                                        "help": null,
                                        "id": "ESP32_BROWNOUT_DET_LVL_SEL_4",
                                        "name": "ESP32_BROWNOUT_DET_LVL_SEL_4",
                                        "range": null,
                                        "title": "2.67V +/- 0.05",
                                        "type": "bool"
                                    },
                                    {
                                        "children": [],
                                        "depends_on": "<choice ESP32_BROWNOUT_DET_LVL_SEL>",
                                        "help": null,
                                        "id": "ESP32_BROWNOUT_DET_LVL_SEL_5",
                                        "name": "ESP32_BROWNOUT_DET_LVL_SEL_5",
                                        "range": null,
                                        "title": "2.70V +/- 0.05",
                                        "type": "bool"
                                    },
                                    {
                                        "children": [],
                                        "depends_on": "<choice ESP32_BROWNOUT_DET_LVL_SEL>",
                                        "help": null,
                                        "id": "ESP32_BROWNOUT_DET_LVL_SEL_6",
                                        "name": "ESP32_BROWNOUT_DET_LVL_SEL_6",
                                        "range": null,
                                        "title": "2.77V +/- 0.05",
                                        "type": "bool"
                                    },
                                    {
                                        "children": [],
                                        "depends_on": "<choice ESP32_BROWNOUT_DET_LVL_SEL>",
                                        "help": null,
                                        "id": "ESP32_BROWNOUT_DET_LVL_SEL_7",
                                        "name": "ESP32_BROWNOUT_DET_LVL_SEL_7",
                                        "range": null,
                                        "title": "2.80V +/- 0.05",
                                        "type": "bool"
                                    }
                                ],
                                "depends_on": "ESP32_BROWNOUT_DET",
                                "help": "The brownout detector will reset the chip when the supply voltage is approximately\nbelow this level. Note that there may be some variation of brownout voltage level\nbetween each ESP32 chip.\n\n#The voltage levels here are estimates, more work needs to be done to figure out the exact voltages\n#of the brownout threshold levels.",
                                "id": "component-config-esp32-specific-hardware-brownout-detect-reset-brownout-voltage-level",
                                "name": "ESP32_BROWNOUT_DET_LVL_SEL",
                                "title": "Brownout voltage level",
                                "type": "choice"
                            }
                        ],
                        "depends_on": null,
                        "help": "The ESP32 has a built-in brownout detector which can detect if the voltage is lower than\na specific value. If this happens, it will reset the chip in order to prevent unintended\nbehaviour.",
                        "id": "ESP32_BROWNOUT_DET",
                        "name": "ESP32_BROWNOUT_DET",
                        "range": null,
                        "title": "Hardware brownout detect & reset",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": null,
                        "help": null,
                        "id": "ESP32_BROWNOUT_DET_LVL",
                        "name": "ESP32_BROWNOUT_DET_LVL",
                        "range": null,
                        "title": null,
                        "type": "int"
                    },
                    {
                        "children": [],
                        "depends_on": "ESP32_BROWNOUT_DET",
                        "help": "When brownout reset occurs, reduce PHY TX power to keep the code running\n\n# Note about the use of \"FRC1\" name: currently FRC1 timer is not used for\n# high resolution timekeeping anymore. Instead the esp_timer API is used.\n# FRC1 name in the option name is kept for compatibility.",
                        "id": "ESP32_REDUCE_PHY_TX_POWER",
                        "name": "ESP32_REDUCE_PHY_TX_POWER",
                        "range": null,
                        "title": "Reduce PHY TX power when brownout reset",
                        "type": "bool"
                    },
                    {
                        "children": [
                            {
                                "children": [],
                                "depends_on": "<choice ESP32_TIME_SYSCALL>",
                                "help": null,
                                "id": "ESP32_TIME_SYSCALL_USE_RTC_FRC1",
                                "name": "ESP32_TIME_SYSCALL_USE_RTC_FRC1",
                                "range": null,
                                "title": "RTC and high-resolution timer",
                                "type": "bool"
                            },
                            {
                                "children": [],
                                "depends_on": "<choice ESP32_TIME_SYSCALL>",
                                "help": null,
                                "id": "ESP32_TIME_SYSCALL_USE_RTC",
                                "name": "ESP32_TIME_SYSCALL_USE_RTC",
                                "range": null,
                                "title": "RTC",
                                "type": "bool"
                            },
                            {
                                "children": [],
                                "depends_on": "<choice ESP32_TIME_SYSCALL>",
                                "help": null,
                                "id": "ESP32_TIME_SYSCALL_USE_FRC1",
                                "name": "ESP32_TIME_SYSCALL_USE_FRC1",
                                "range": null,
                                "title": "High-resolution timer",
                                "type": "bool"
                            },
                            {
                                "children": [],
                                "depends_on": "<choice ESP32_TIME_SYSCALL>",
                                "help": null,
                                "id": "ESP32_TIME_SYSCALL_USE_NONE",
                                "name": "ESP32_TIME_SYSCALL_USE_NONE",
                                "range": null,
                                "title": "None",
                                "type": "bool"
                            }
                        ],
                        "depends_on": null,
                        "help": "This setting defines which hardware timers are used to\nimplement 'gettimeofday' and 'time' functions in C library.\n\n- If both high-resolution and RTC timers are used, timekeeping will\n  continue in deep sleep. Time will be reported at 1 microsecond\n  resolution. This is the default, and the recommended option.\n- If only high-resolution timer is used, gettimeofday will\n  provide time at microsecond resolution.\n  Time will not be preserved when going into deep sleep mode.\n- If only RTC timer is used, timekeeping will continue in\n  deep sleep, but time will be measured at 6.(6) microsecond\n  resolution. Also the gettimeofday function itself may take\n  longer to run.\n- If no timers are used, gettimeofday and time functions\n  return -1 and set errno to ENOSYS.\n- When RTC is used for timekeeping, two RTC_STORE registers are\n  used to keep time in deep sleep mode.",
                        "id": "component-config-esp32-specific-timers-used-for-gettimeofday-function",
                        "name": "ESP32_TIME_SYSCALL",
                        "title": "Timers used for gettimeofday function",
                        "type": "choice"
                    },
                    {
                        "children": [
                            {
                                "children": [],
                                "depends_on": "<choice ESP32_RTC_CLK_SRC>",
                                "help": null,
                                "id": "ESP32_RTC_CLK_SRC_INT_RC",
                                "name": "ESP32_RTC_CLK_SRC_INT_RC",
                                "range": null,
                                "title": "Internal 150kHz RC oscillator",
                                "type": "bool"
                            },
                            {
                                "children": [],
                                "depends_on": "<choice ESP32_RTC_CLK_SRC>",
                                "help": null,
                                "id": "ESP32_RTC_CLK_SRC_EXT_CRYS",
                                "name": "ESP32_RTC_CLK_SRC_EXT_CRYS",
                                "range": null,
                                "title": "External 32kHz crystal",
                                "type": "bool"
                            },
                            {
                                "children": [],
                                "depends_on": "<choice ESP32_RTC_CLK_SRC>",
                                "help": null,
                                "id": "ESP32_RTC_CLK_SRC_EXT_OSC",
                                "name": "ESP32_RTC_CLK_SRC_EXT_OSC",
                                "range": null,
                                "title": "External 32kHz oscillator at 32K_XN pin",
                                "type": "bool"
                            },
                            {
                                "children": [],
                                "depends_on": "<choice ESP32_RTC_CLK_SRC>",
                                "help": null,
                                "id": "ESP32_RTC_CLK_SRC_INT_8MD256",
                                "name": "ESP32_RTC_CLK_SRC_INT_8MD256",
                                "range": null,
                                "title": "Internal 8.5MHz oscillator, divided by 256 (~33kHz)",
                                "type": "bool"
                            }
                        ],
                        "depends_on": null,
                        "help": "Choose which clock is used as RTC clock source.\n\n- \"Internal 150kHz oscillator\" option provides lowest deep sleep current\n  consumption, and does not require extra external components. However\n  frequency stability with respect to temperature is poor, so time may\n  drift in deep/light sleep modes.\n- \"External 32kHz crystal\" provides better frequency stability, at the\n  expense of slightly higher (1uA) deep sleep current consumption.\n- \"External 32kHz oscillator\" allows using 32kHz clock generated by an\n  external circuit. In this case, external clock signal must be connected\n  to 32K_XN pin. Amplitude should be <1.2V in case of sine wave signal,\n  and <1V in case of square wave signal. Common mode voltage should be\n  0.1 < Vcm < 0.5Vamp, where Vamp is the signal amplitude.\n  Additionally, 1nF capacitor must be connected between 32K_XP pin and\n  ground. 32K_XP pin can not be used as a GPIO in this case.\n- \"Internal 8.5MHz oscillator divided by 256\" option results in higher\n  deep sleep current (by 5uA) but has better frequency stability than\n  the internal 150kHz oscillator. It does not require external components.",
                        "id": "component-config-esp32-specific-rtc-clock-source",
                        "name": "ESP32_RTC_CLK_SRC",
                        "title": "RTC clock source",
                        "type": "choice"
                    },
                    {
                        "children": [
                            {
                                "children": [],
                                "depends_on": "<choice ESP32_RTC_EXT_CRYST_ADDIT_CURRENT_METHOD>",
                                "help": null,
                                "id": "ESP32_RTC_EXT_CRYST_ADDIT_CURRENT_NONE",
                                "name": "ESP32_RTC_EXT_CRYST_ADDIT_CURRENT_NONE",
                                "range": null,
                                "title": "None",
                                "type": "bool"
                            },
                            {
                                "children": [],
                                "depends_on": "<choice ESP32_RTC_EXT_CRYST_ADDIT_CURRENT_METHOD>",
                                "help": null,
                                "id": "ESP32_RTC_EXT_CRYST_ADDIT_CURRENT",
                                "name": "ESP32_RTC_EXT_CRYST_ADDIT_CURRENT",
                                "range": null,
                                "title": "Method 1",
                                "type": "bool"
                            },
                            {
                                "children": [],
                                "depends_on": "<choice ESP32_RTC_EXT_CRYST_ADDIT_CURRENT_METHOD>",
                                "help": null,
                                "id": "ESP32_RTC_EXT_CRYST_ADDIT_CURRENT_V2",
                                "name": "ESP32_RTC_EXT_CRYST_ADDIT_CURRENT_V2",
                                "range": null,
                                "title": "Method 2",
                                "type": "bool"
                            }
                        ],
                        "depends_on": "ESP32_RTC_CLK_SRC_EXT_CRYS && ESP32_REV_MIN <= 1",
                        "help": "With some 32kHz crystal configurations, the X32N and X32P pins may not have enough\ndrive strength to keep the crystal oscillating. Choose the method to provide\nadditional current from touchpad 9 to the external 32kHz crystal. Note that\nthe deep sleep current is slightly high (4-5uA) and the touchpad and the\nwakeup sources of both touchpad and ULP are not available in method 1 and method 2.\n\nThis problem is fixed in ESP32 ECO 3, so this workaround is not needed. Setting the\nproject configuration to minimum revision ECO3 will disable this option, , allow\nall wakeup sources, and save some code size.\n\n- \"None\" option will not provide additional current to external crystal\n- \"Method 1\" option can't ensure 100% to solve the external 32k crystal start failed\n  issue, but the touchpad can work in this method.\n- \"Method 2\" option can solve the external 32k issue, but the touchpad can't work\n  in this method.",
                        "id": "component-config-esp32-specific-additional-current-for-external-32khz-crystal",
                        "name": "ESP32_RTC_EXT_CRYST_ADDIT_CURRENT_METHOD",
                        "title": "Additional current for external 32kHz crystal",
                        "type": "choice"
                    },
                    {
                        "children": [],
                        "depends_on": null,
                        "help": "When the startup code initializes RTC_SLOW_CLK, it can perform\ncalibration by comparing the RTC_SLOW_CLK frequency with main XTAL\nfrequency. This option sets the number of RTC_SLOW_CLK cycles measured\nby the calibration routine. Higher numbers increase calibration\nprecision, which may be important for applications which spend a lot of\ntime in deep sleep. Lower numbers reduce startup time.\n\nWhen this option is set to 0, clock calibration will not be performed at\nstartup, and approximate clock frequencies will be assumed:\n\n- 150000 Hz if internal RC oscillator is used as clock source. For this use value 1024.\n- 32768 Hz if the 32k crystal oscillator is used. For this use value 3000 or more.\n  In case more value will help improve the definition of the launch of the crystal.\n  If the crystal could not start, it will be switched to internal RC.",
                        "id": "ESP32_RTC_CLK_CAL_CYCLES",
                        "name": "ESP32_RTC_CLK_CAL_CYCLES",
                        "range": [
                            0,
                            32766
                        ],
                        "title": "Number of cycles for RTC_SLOW_CLK calibration",
                        "type": "int"
                    },
                    {
                        "children": [],
                        "depends_on": "ESP32_RTC_CLK_SRC_EXT_CRYS",
                        "help": "Number of attempts to repeat 32k XTAL calibration\nbefore giving up and switching to the internal RC.\nIncrease this option if the 32k crystal oscillator\ndoes not start and switches to internal RC.",
                        "id": "ESP32_RTC_XTAL_CAL_RETRY",
                        "name": "ESP32_RTC_XTAL_CAL_RETRY",
                        "range": null,
                        "title": "Number of attempts to repeat 32k XTAL calibration",
                        "type": "int"
                    },
                    {
                        "children": [],
                        "depends_on": null,
                        "help": "When ESP32 exits deep sleep, the CPU and the flash chip are powered on\nat the same time. CPU will run deep sleep stub first, and then\nproceed to load code from flash. Some flash chips need sufficient\ntime to pass between power on and first read operation. By default,\nwithout any extra delay, this time is approximately 900us, although\nsome flash chip types need more than that.\n\nBy default extra delay is set to 2000us. When optimizing startup time\nfor applications which require it, this value may be reduced.\n\nIf you are seeing \"flash read err, 1000\" message printed to the\nconsole after deep sleep reset, try increasing this value.",
                        "id": "ESP32_DEEP_SLEEP_WAKEUP_DELAY",
                        "name": "ESP32_DEEP_SLEEP_WAKEUP_DELAY",
                        "range": [
                            0,
                            5000
                        ],
                        "title": "Extra delay in deep sleep wake stub (in us)",
                        "type": "int"
                    },
                    {
                        "children": [
                            {
                                "children": [],
                                "depends_on": "<choice ESP32_XTAL_FREQ_SEL>",
                                "help": null,
                                "id": "ESP32_XTAL_FREQ_40",
                                "name": "ESP32_XTAL_FREQ_40",
                                "range": null,
                                "title": "40 MHz",
                                "type": "bool"
                            },
                            {
                                "children": [],
                                "depends_on": "<choice ESP32_XTAL_FREQ_SEL>",
                                "help": null,
                                "id": "ESP32_XTAL_FREQ_26",
                                "name": "ESP32_XTAL_FREQ_26",
                                "range": null,
                                "title": "26 MHz",
                                "type": "bool"
                            },
                            {
                                "children": [],
                                "depends_on": "<choice ESP32_XTAL_FREQ_SEL>",
                                "help": null,
                                "id": "ESP32_XTAL_FREQ_AUTO",
                                "name": "ESP32_XTAL_FREQ_AUTO",
                                "range": null,
                                "title": "Autodetect",
                                "type": "bool"
                            }
                        ],
                        "depends_on": null,
                        "help": "ESP32 currently supports the following XTAL frequencies:\n\n- 26 MHz\n- 40 MHz\n\nStartup code can automatically estimate XTAL frequency. This feature\nuses the internal 8MHz oscillator as a reference. Because the internal\noscillator frequency is temperature dependent, it is not recommended\nto use automatic XTAL frequency detection in applications which need\nto work at high ambient temperatures and use high-temperature\nqualified chips and modules.",
                        "id": "component-config-esp32-specific-main-xtal-frequency",
                        "name": "ESP32_XTAL_FREQ_SEL",
                        "title": "Main XTAL frequency",
                        "type": "choice"
                    },
                    {
                        "children": [],
                        "depends_on": null,
                        "help": null,
                        "id": "ESP32_XTAL_FREQ",
                        "name": "ESP32_XTAL_FREQ",
                        "range": null,
                        "title": null,
                        "type": "int"
                    },
                    {
                        "children": [],
                        "depends_on": null,
                        "help": "If set, the first time the app boots it will disable the BASIC ROM Console\npermanently (by burning an eFuse).\n\nOtherwise, the BASIC ROM Console starts on reset if no valid bootloader is\nread from the flash.\n\n(Enabling secure boot also disables the BASIC ROM Console by default.)",
                        "id": "ESP32_DISABLE_BASIC_ROM_CONSOLE",
                        "name": "ESP32_DISABLE_BASIC_ROM_CONSOLE",
                        "range": null,
                        "title": "Permanently disable BASIC ROM Console",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "!BT_ENABLED",
                        "help": "If enabled, this disables the linking of binary libraries in the application build. Note\nthat after enabling this Wi-Fi/Bluetooth will not work.",
                        "id": "ESP32_NO_BLOBS",
                        "name": "ESP32_NO_BLOBS",
                        "range": null,
                        "title": "No Binary Blobs",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": null,
                        "help": "Bootloaders before ESP-IDF v2.1 did less initialisation of the\nsystem clock. This setting needs to be enabled to build an app\nwhich can be booted by these older bootloaders.\n\nIf this setting is enabled, the app can be booted by any bootloader\nfrom IDF v1.0 up to the current version.\n\nIf this setting is disabled, the app can only be booted by bootloaders\nfrom IDF v2.1 or newer.\n\nEnabling this setting adds approximately 1KB to the app's IRAM usage.",
                        "id": "ESP32_COMPATIBLE_PRE_V2_1_BOOTLOADERS",
                        "name": "ESP32_COMPATIBLE_PRE_V2_1_BOOTLOADERS",
                        "range": null,
                        "title": "App compatible with bootloaders before ESP-IDF v2.1",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": null,
                        "help": "Partition tables before ESP-IDF V3.1 do not contain an MD5 checksum\nfield, and the bootloader before ESP-IDF v3.1 cannot read a partition\ntable that contains an MD5 checksum field.\n\nEnable this option only if your app needs to boot on a bootloader and/or\npartition table that was generated from a version *before* ESP-IDF v3.1.\n\nIf this option and Flash Encryption are enabled at the same time, and any\ndata partitions in the partition table are marked Encrypted, then the\npartition encrypted flag should be manually verified in the app before accessing\nthe partition (see CVE-2021-27926).",
                        "id": "ESP32_COMPATIBLE_PRE_V3_1_BOOTLOADERS",
                        "name": "ESP32_COMPATIBLE_PRE_V3_1_BOOTLOADERS",
                        "range": null,
                        "title": "App compatible with bootloader and partition table before ESP-IDF v3.1",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": null,
                        "help": null,
                        "id": "ESP32_APP_INIT_CLK",
                        "name": "ESP32_APP_INIT_CLK",
                        "range": null,
                        "title": null,
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "FREERTOS_UNICORE",
                        "help": "This option allows to place .rtc_data and .rtc_rodata sections into\nRTC fast memory segment to free the slow memory region for ULP programs.\nThis option depends on the CONFIG_FREERTOS_UNICORE option because RTC fast memory\ncan be accessed only by PRO_CPU core.",
                        "id": "ESP32_RTCDATA_IN_FAST_MEM",
                        "name": "ESP32_RTCDATA_IN_FAST_MEM",
                        "range": null,
                        "title": "Place RTC_DATA_ATTR and RTC_RODATA_ATTR variables into RTC fast memory segment",
                        "type": "bool"
                    },
                    {
                        "children": [
                            {
                                "children": [],
                                "depends_on": "ESP32_USE_FIXED_STATIC_RAM_SIZE",
                                "help": "RAM size dedicated for static variables (.data & .bss sections).\nPlease note that the actual length will be reduced by BTDM_RESERVE_DRAM if Bluetooth\ncontroller is enabled.",
                                "id": "ESP32_FIXED_STATIC_RAM_SIZE",
                                "name": "ESP32_FIXED_STATIC_RAM_SIZE",
                                "range": null,
                                "title": "Fixed Static RAM size",
                                "type": "hex"
                            }
                        ],
                        "depends_on": null,
                        "help": "If this option is disabled, the DRAM part of the heap starts right after the .bss section,\nwithin the dram0_0 region. As a result, adding or removing some static variables\nwill change the available heap size.\n\nIf this option is enabled, the DRAM part of the heap starts right after the dram0_0 region,\nwhere its length is set with ESP32_FIXED_STATIC_RAM_SIZE",
                        "id": "ESP32_USE_FIXED_STATIC_RAM_SIZE",
                        "name": "ESP32_USE_FIXED_STATIC_RAM_SIZE",
                        "range": null,
                        "title": "Use fixed static RAM size",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": null,
                        "help": "To prevent interrupting DPORT workarounds,\nneed to disable interrupt with a maximum used level in the system.",
                        "id": "ESP32_DPORT_DIS_INTERRUPT_LVL",
                        "name": "ESP32_DPORT_DIS_INTERRUPT_LVL",
                        "range": null,
                        "title": "Disable the interrupt level for the DPORT workarounds",
                        "type": "int"
                    },
                    {
                        "children": [],
                        "depends_on": "FREERTOS_UNICORE",
                        "help": "If enabled, application can use IRAM as byte accessible region for storing data\n(Note: IRAM region cannot be used as task stack)\n\nThis is possible due to handling of exceptions `LoadStoreError (3)` and `LoadStoreAlignmentError (9)`\nEach unaligned read/write access will incur a penalty of maximum of 167 CPU cycles.",
                        "id": "ESP32_IRAM_AS_8BIT_ACCESSIBLE_MEMORY",
                        "name": "ESP32_IRAM_AS_8BIT_ACCESSIBLE_MEMORY",
                        "range": null,
                        "title": "Enable IRAM as 8 bit accessible memory",
                        "type": "bool"
                    }
                ],
                "depends_on": null,
                "id": "component-config-esp32-specific",
                "title": "ESP32-specific",
                "type": "menu"
            },
            {
                "children": [
                    {
                        "children": [],
                        "depends_on": null,
                        "help": "Functions esp_err_to_name() and esp_err_to_name_r() return string representations of error codes from a\npre-generated lookup table. This option can be used to turn off the use of the look-up table in order to\nsave memory but this comes at the price of sacrificing distinguishable (meaningful) output string\nrepresentations.",
                        "id": "ESP_ERR_TO_NAME_LOOKUP",
                        "name": "ESP_ERR_TO_NAME_LOOKUP",
                        "range": null,
                        "title": "Enable lookup of error code strings",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": null,
                        "help": "Config system event queue size in different application.",
                        "id": "ESP_SYSTEM_EVENT_QUEUE_SIZE",
                        "name": "ESP_SYSTEM_EVENT_QUEUE_SIZE",
                        "range": null,
                        "title": "System event queue size",
                        "type": "int"
                    },
                    {
                        "children": [],
                        "depends_on": null,
                        "help": "Config system event task stack size in different application.",
                        "id": "ESP_SYSTEM_EVENT_TASK_STACK_SIZE",
                        "name": "ESP_SYSTEM_EVENT_TASK_STACK_SIZE",
                        "range": null,
                        "title": "Event loop task stack size",
                        "type": "int"
                    },
                    {
                        "children": [],
                        "depends_on": null,
                        "help": "Configure the \"main task\" stack size. This is the stack of the task\nwhich calls app_main(). If app_main() returns then this task is deleted\nand its stack memory is freed.",
                        "id": "ESP_MAIN_TASK_STACK_SIZE",
                        "name": "ESP_MAIN_TASK_STACK_SIZE",
                        "range": null,
                        "title": "Main task stack size",
                        "type": "int"
                    },
                    {
                        "children": [],
                        "depends_on": null,
                        "help": "Configure the IPC tasks stack size. One IPC task runs on each core\n(in dual core mode), and allows for cross-core function calls.\n\nSee IPC documentation for more details.\n\nThe default stack size should be enough for most common use cases.\nIt can be shrunk if you are sure that you do not use any custom\nIPC functionality.",
                        "id": "ESP_IPC_TASK_STACK_SIZE",
                        "name": "ESP_IPC_TASK_STACK_SIZE",
                        "range": [
                            512,
                            65536
                        ],
                        "title": "Inter-Processor Call (IPC) task stack size",
                        "type": "int"
                    },
                    {
                        "children": [],
                        "depends_on": "!FREERTOS_UNICORE",
                        "help": "If this option is not enabled then the IPC task will keep behavior\nsame as prior to that of ESP-IDF v4.0, and hence IPC task will run\nat (configMAX_PRIORITIES - 1) priority.",
                        "id": "ESP_IPC_USES_CALLERS_PRIORITY",
                        "name": "ESP_IPC_USES_CALLERS_PRIORITY",
                        "range": null,
                        "title": "IPC runs at caller's priority",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": null,
                        "help": "Minimal value of size, in bytes, accepted to execute a expression\nwith shared stack.",
                        "id": "ESP_MINIMAL_SHARED_STACK_SIZE",
                        "name": "ESP_MINIMAL_SHARED_STACK_SIZE",
                        "range": null,
                        "title": "Minimal allowed size for shared stack",
                        "type": "int"
                    },
                    {
                        "children": [
                            {
                                "children": [],
                                "depends_on": "<choice ESP_CONSOLE_UART>",
                                "help": null,
                                "id": "ESP_CONSOLE_UART_DEFAULT",
                                "name": "ESP_CONSOLE_UART_DEFAULT",
                                "range": null,
                                "title": "Default: UART0",
                                "type": "bool"
                            },
                            {
                                "children": [],
                                "depends_on": "IDF_TARGET_ESP32S2 && !USB_ENABLED && <choice ESP_CONSOLE_UART>",
                                "help": null,
                                "id": "ESP_CONSOLE_USB_CDC",
                                "name": "ESP_CONSOLE_USB_CDC",
                                "range": null,
                                "title": "USB CDC",
                                "type": "bool"
                            },
                            {
                                "children": [],
                                "depends_on": "IDF_TARGET_ESP32C3 && <choice ESP_CONSOLE_UART>",
                                "help": null,
                                "id": "ESP_CONSOLE_USB_SERIAL_JTAG",
                                "name": "ESP_CONSOLE_USB_SERIAL_JTAG",
                                "range": null,
                                "title": "USB Serial/JTAG Controller",
                                "type": "bool"
                            },
                            {
                                "children": [],
                                "depends_on": "<choice ESP_CONSOLE_UART>",
                                "help": null,
                                "id": "ESP_CONSOLE_UART_CUSTOM",
                                "name": "ESP_CONSOLE_UART_CUSTOM",
                                "range": null,
                                "title": "Custom UART",
                                "type": "bool"
                            },
                            {
                                "children": [],
                                "depends_on": "<choice ESP_CONSOLE_UART>",
                                "help": null,
                                "id": "ESP_CONSOLE_NONE",
                                "name": "ESP_CONSOLE_NONE",
                                "range": null,
                                "title": "None",
                                "type": "bool"
                            }
                        ],
                        "depends_on": null,
                        "help": "Select where to send console output (through stdout and stderr).\n\n- Default is to use UART0 on pre-defined GPIOs.\n- If \"Custom\" is selected, UART0 or UART1 can be chosen,\n  and any pins can be selected.\n- If \"None\" is selected, there will be no console output on any UART, except\n  for initial output from ROM bootloader. This ROM output can be suppressed by\n  GPIO strapping or EFUSE, refer to chip datasheet for details.\n- On chips with USB OTG peripheral, \"USB CDC\" option redirects output to the\n  CDC port. This option uses the CDC driver in the chip ROM.\n  This option is incompatible with TinyUSB stack.\n- On chips with an USB serial/JTAG debug controller, selecting the option\n  for that redirects output to the CDC/ACM (serial port emulation) component\n  of that device.",
                        "id": "component-config-common-esp-related-channel-for-console-output",
                        "name": "ESP_CONSOLE_UART",
                        "title": "Channel for console output",
                        "type": "choice"
                    },
                    {
                        "children": [
                            {
                                "children": [],
                                "depends_on": "<choice ESP_CONSOLE_SECONDARY>",
                                "help": null,
                                "id": "ESP_CONSOLE_SECONDARY_NONE",
                                "name": "ESP_CONSOLE_SECONDARY_NONE",
                                "range": null,
                                "title": "No secondary console",
                                "type": "bool"
                            },
                            {
                                "children": [],
                                "depends_on": "!ESP_CONSOLE_USB_SERIAL_JTAG && <choice ESP_CONSOLE_SECONDARY>",
                                "help": "This option supports output through USB_SERIAL_JTAG port when the UART0 port is not connected.\nThe output currently only supports non-blocking mode without using the console.\nIf you want to output in blocking mode with REPL or input through USB_SERIAL_JTAG port,\nplease change the primary config to ESP_CONSOLE_USB_SERIAL_JTAG above.",
                                "id": "ESP_CONSOLE_SECONDARY_USB_SERIAL_JTAG",
                                "name": "ESP_CONSOLE_SECONDARY_USB_SERIAL_JTAG",
                                "range": null,
                                "title": "USB_SERIAL_JTAG PORT",
                                "type": "bool"
                            }
                        ],
                        "depends_on": "IDF_TARGET_ESP32C3",
                        "help": "This secondary option supports output through other specific port like USB_SERIAL_JTAG\nwhen UART0 port as a primary is selected but not connected. This secondary output currently only supports\nnon-blocking mode without using REPL. If you want to output in blocking mode with REPL or\ninput through this secondary port, please change the primary config to this port\nin `Channel for console output` menu.",
                        "id": "component-config-common-esp-related-channel-for-console-secondary-output",
                        "name": "ESP_CONSOLE_SECONDARY",
                        "title": "Channel for console secondary output",
                        "type": "choice"
                    },
                    {
                        "children": [],
                        "depends_on": null,
                        "help": null,
                        "id": "ESP_CONSOLE_UART",
                        "name": "ESP_CONSOLE_UART",
                        "range": null,
                        "title": null,
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": null,
                        "help": null,
                        "id": "ESP_CONSOLE_MULTIPLE_UART",
                        "name": "ESP_CONSOLE_MULTIPLE_UART",
                        "range": null,
                        "title": null,
                        "type": "bool"
                    },
                    {
                        "children": [
                            {
                                "children": [],
                                "depends_on": "<choice ESP_CONSOLE_UART_NUM>",
                                "help": null,
                                "id": "ESP_CONSOLE_UART_CUSTOM_NUM_0",
                                "name": "ESP_CONSOLE_UART_CUSTOM_NUM_0",
                                "range": null,
                                "title": "UART0",
                                "type": "bool"
                            },
                            {
                                "children": [],
                                "depends_on": "<choice ESP_CONSOLE_UART_NUM>",
                                "help": null,
                                "id": "ESP_CONSOLE_UART_CUSTOM_NUM_1",
                                "name": "ESP_CONSOLE_UART_CUSTOM_NUM_1",
                                "range": null,
                                "title": "UART1",
                                "type": "bool"
                            }
                        ],
                        "depends_on": "ESP_CONSOLE_UART_CUSTOM && ESP_CONSOLE_MULTIPLE_UART",
                        "help": "This UART peripheral is used for console output from the ESP-IDF Bootloader and the app.\n\nIf the configuration is different in the Bootloader binary compared to the app binary, UART\nis reconfigured after the bootloader exits and the app starts.\n\nDue to an ESP32 ROM bug, UART2 is not supported for console output\nvia esp_rom_printf.",
                        "id": "component-config-common-esp-related-uart-peripheral-to-use-for-console-output-0-1-",
                        "name": "ESP_CONSOLE_UART_NUM",
                        "title": "UART peripheral to use for console output (0-1)",
                        "type": "choice"
                    },
                    {
                        "children": [],
                        "depends_on": null,
                        "help": null,
                        "id": "ESP_CONSOLE_UART_NUM",
                        "name": "ESP_CONSOLE_UART_NUM",
                        "range": null,
                        "title": null,
                        "type": "int"
                    },
                    {
                        "children": [],
                        "depends_on": "ESP_CONSOLE_UART_CUSTOM",
                        "help": "This GPIO is used for console UART TX output in the ESP-IDF Bootloader and the app (including\nboot log output and default standard output and standard error of the app).\n\nIf the configuration is different in the Bootloader binary compared to the app binary, UART\nis reconfigured after the bootloader exits and the app starts.",
                        "id": "ESP_CONSOLE_UART_TX_GPIO",
                        "name": "ESP_CONSOLE_UART_TX_GPIO",
                        "range": null,
                        "title": "UART TX on GPIO#",
                        "type": "int"
                    },
                    {
                        "children": [],
                        "depends_on": "ESP_CONSOLE_UART_CUSTOM",
                        "help": "This GPIO is used for UART RX input in the ESP-IDF Bootloader and the app (including\ndefault default standard input of the app).\n\nNote: The default ESP-IDF Bootloader configures this pin but doesn't read anything from the UART.\n\nIf the configuration is different in the Bootloader binary compared to the app binary, UART\nis reconfigured after the bootloader exits and the app starts.",
                        "id": "ESP_CONSOLE_UART_RX_GPIO",
                        "name": "ESP_CONSOLE_UART_RX_GPIO",
                        "range": null,
                        "title": "UART RX on GPIO#",
                        "type": "int"
                    },
                    {
                        "children": [],
                        "depends_on": "ESP_CONSOLE_UART",
                        "help": "This baud rate is used by both the ESP-IDF Bootloader and the app (including\nboot log output and default standard input/output/error of the app).\n\nThe app's maximum baud rate depends on the UART clock source. If Power Management is disabled,\nthe UART clock source is the APB clock and all baud rates in the available range will be sufficiently\naccurate. If Power Management is enabled, REF_TICK clock source is used so the baud rate is divided\nfrom 1MHz. Baud rates above 1Mbps are not possible and values between 500Kbps and 1Mbps may not be\naccurate.\n\nIf the configuration is different in the Bootloader binary compared to the app binary, UART\nis reconfigured after the bootloader exits and the app starts.",
                        "id": "ESP_CONSOLE_UART_BAUDRATE",
                        "name": "ESP_CONSOLE_UART_BAUDRATE",
                        "range": [
                            1200,
                            4000000
                        ],
                        "title": "UART console baud rate",
                        "type": "int"
                    },
                    {
                        "children": [],
                        "depends_on": "ESP_CONSOLE_USB_CDC",
                        "help": "Set the size of USB CDC RX buffer. Increase the buffer size if your application\nis often receiving data over USB CDC.",
                        "id": "ESP_CONSOLE_USB_CDC_RX_BUF_SIZE",
                        "name": "ESP_CONSOLE_USB_CDC_RX_BUF_SIZE",
                        "range": null,
                        "title": "Size of USB CDC RX buffer",
                        "type": "int"
                    },
                    {
                        "children": [],
                        "depends_on": "ESP_CONSOLE_USB_CDC",
                        "help": "If enabled, esp_rom_printf and ESP_EARLY_LOG output will also be sent over USB CDC.\nDisabling this option saves about 1kB or RAM.",
                        "id": "ESP_CONSOLE_USB_CDC_SUPPORT_ETS_PRINTF",
                        "name": "ESP_CONSOLE_USB_CDC_SUPPORT_ETS_PRINTF",
                        "range": null,
                        "title": "Enable esp_rom_printf / ESP_EARLY_LOG via USB CDC",
                        "type": "bool"
                    },
                    {
                        "children": [
                            {
                                "children": [],
                                "depends_on": "ESP_INT_WDT",
                                "help": "The timeout of the watchdog, in miliseconds. Make this higher than the FreeRTOS tick rate.",
                                "id": "ESP_INT_WDT_TIMEOUT_MS",
                                "name": "ESP_INT_WDT_TIMEOUT_MS",
                                "range": [
                                    10,
                                    10000
                                ],
                                "title": "Interrupt watchdog timeout (ms)",
                                "type": "int"
                            },
                            {
                                "children": [],
                                "depends_on": "ESP_INT_WDT && !FREERTOS_UNICORE",
                                "help": "Also detect if interrupts on CPU 1 are disabled for too long.",
                                "id": "ESP_INT_WDT_CHECK_CPU1",
                                "name": "ESP_INT_WDT_CHECK_CPU1",
                                "range": null,
                                "title": "Also watch CPU1 tick interrupt",
                                "type": "bool"
                            }
                        ],
                        "depends_on": null,
                        "help": "This watchdog timer can detect if the FreeRTOS tick interrupt has not been called for a certain time,\neither because a task turned off interrupts and did not turn them on for a long time, or because an\ninterrupt handler did not return. It will try to invoke the panic handler first and failing that\nreset the SoC.",
                        "id": "ESP_INT_WDT",
                        "name": "ESP_INT_WDT",
                        "range": null,
                        "title": "Interrupt watchdog",
                        "type": "bool"
                    },
                    {
                        "children": [
                            {
                                "children": [],
                                "depends_on": "ESP_TASK_WDT",
                                "help": "If this option is enabled, the Task Watchdog Timer will be configured to\ntrigger the panic handler when it times out. This can also be configured\nat run time (see Task Watchdog Timer API Reference)",
                                "id": "ESP_TASK_WDT_PANIC",
                                "name": "ESP_TASK_WDT_PANIC",
                                "range": null,
                                "title": "Invoke panic handler on Task Watchdog timeout",
                                "type": "bool"
                            },
                            {
                                "children": [],
                                "depends_on": "ESP_TASK_WDT",
                                "help": "Timeout period configuration for the Task Watchdog Timer in seconds.\nThis is also configurable at run time (see Task Watchdog Timer API Reference)",
                                "id": "ESP_TASK_WDT_TIMEOUT_S",
                                "name": "ESP_TASK_WDT_TIMEOUT_S",
                                "range": [
                                    1,
                                    60
                                ],
                                "title": "Task Watchdog timeout period (seconds)",
                                "type": "int"
                            },
                            {
                                "children": [],
                                "depends_on": "ESP_TASK_WDT",
                                "help": "If this option is enabled, the Task Watchdog Timer will watch the CPU0\nIdle Task. Having the Task Watchdog watch the Idle Task allows for detection\nof CPU starvation as the Idle Task not being called is usually a symptom of\nCPU starvation. Starvation of the Idle Task is detrimental as FreeRTOS household\ntasks depend on the Idle Task getting some runtime every now and then.",
                                "id": "ESP_TASK_WDT_CHECK_IDLE_TASK_CPU0",
                                "name": "ESP_TASK_WDT_CHECK_IDLE_TASK_CPU0",
                                "range": null,
                                "title": "Watch CPU0 Idle Task",
                                "type": "bool"
                            },
                            {
                                "children": [],
                                "depends_on": "ESP_TASK_WDT && !FREERTOS_UNICORE",
                                "help": "If this option is enabled, the Task Wtachdog Timer will wach the CPU1\nIdle Task.",
                                "id": "ESP_TASK_WDT_CHECK_IDLE_TASK_CPU1",
                                "name": "ESP_TASK_WDT_CHECK_IDLE_TASK_CPU1",
                                "range": null,
                                "title": "Watch CPU1 Idle Task",
                                "type": "bool"
                            }
                        ],
                        "depends_on": null,
                        "help": "The Task Watchdog Timer can be used to make sure individual tasks are still\nrunning. Enabling this option will cause the Task Watchdog Timer to be\ninitialized automatically at startup. The Task Watchdog timer can be\ninitialized after startup as well (see Task Watchdog Timer API Reference)",
                        "id": "ESP_TASK_WDT",
                        "name": "ESP_TASK_WDT",
                        "range": null,
                        "title": "Initialize Task Watchdog Timer on startup",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": null,
                        "help": "If this option is disabled (default), the panic handler code is placed in flash not IRAM.\nThis means that if ESP-IDF crashes while flash cache is disabled, the panic handler will\nautomatically re-enable flash cache before running GDB Stub or Core Dump. This adds some minor\nrisk, if the flash cache status is also corrupted during the crash.\n\nIf this option is enabled, the panic handler code is placed in IRAM. This allows the panic\nhandler to run without needing to re-enable cache first. This may be necessary to debug some\ncomplex issues with crashes while flash cache is disabled (for example, when writing to\nSPI flash.)",
                        "id": "ESP_PANIC_HANDLER_IRAM",
                        "name": "ESP_PANIC_HANDLER_IRAM",
                        "range": null,
                        "title": "Place panic handler code in IRAM",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "!ESP32_TRAX && !ESP32S2_TRAX",
                        "help": "Debug stubs are used by OpenOCD to execute pre-compiled onboard code\nwhich does some useful debugging stuff, e.g. GCOV data dump.",
                        "id": "ESP_DEBUG_STUBS_ENABLE",
                        "name": "ESP_DEBUG_STUBS_ENABLE",
                        "range": null,
                        "title": null,
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": null,
                        "help": null,
                        "id": "ESP_MAC_ADDR_UNIVERSE_WIFI_STA",
                        "name": "ESP_MAC_ADDR_UNIVERSE_WIFI_STA",
                        "range": null,
                        "title": null,
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": null,
                        "help": null,
                        "id": "ESP_MAC_ADDR_UNIVERSE_WIFI_AP",
                        "name": "ESP_MAC_ADDR_UNIVERSE_WIFI_AP",
                        "range": null,
                        "title": null,
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": null,
                        "help": null,
                        "id": "ESP_MAC_ADDR_UNIVERSE_BT",
                        "name": "ESP_MAC_ADDR_UNIVERSE_BT",
                        "range": null,
                        "title": null,
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": null,
                        "help": null,
                        "id": "ESP_MAC_ADDR_UNIVERSE_ETH",
                        "name": "ESP_MAC_ADDR_UNIVERSE_ETH",
                        "range": null,
                        "title": null,
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": null,
                        "help": null,
                        "id": "ESP_ALLOW_BSS_SEG_EXTERNAL_MEMORY",
                        "name": "ESP_ALLOW_BSS_SEG_EXTERNAL_MEMORY",
                        "range": null,
                        "title": null,
                        "type": "bool"
                    }
                ],
                "depends_on": null,
                "id": "component-config-common-esp-related",
                "title": "Common ESP-related",
                "type": "menu"
            },
            {
                "children": [
                    {
                        "children": [
                            {
                                "children": [],
                                "depends_on": "<choice ESP_SYSTEM_PANIC>",
                                "help": "Outputs the relevant registers over the serial port and halt the\nprocessor. Needs a manual reset to restart.",
                                "id": "ESP_SYSTEM_PANIC_PRINT_HALT",
                                "name": "ESP_SYSTEM_PANIC_PRINT_HALT",
                                "range": null,
                                "title": "Print registers and halt",
                                "type": "bool"
                            },
                            {
                                "children": [],
                                "depends_on": "<choice ESP_SYSTEM_PANIC>",
                                "help": "Outputs the relevant registers over the serial port and immediately\nreset the processor.",
                                "id": "ESP_SYSTEM_PANIC_PRINT_REBOOT",
                                "name": "ESP_SYSTEM_PANIC_PRINT_REBOOT",
                                "range": null,
                                "title": "Print registers and reboot",
                                "type": "bool"
                            },
                            {
                                "children": [],
                                "depends_on": "<choice ESP_SYSTEM_PANIC>",
                                "help": "Just resets the processor without outputting anything",
                                "id": "ESP_SYSTEM_PANIC_SILENT_REBOOT",
                                "name": "ESP_SYSTEM_PANIC_SILENT_REBOOT",
                                "range": null,
                                "title": "Silent reboot",
                                "type": "bool"
                            },
                            {
                                "children": [],
                                "depends_on": "<choice ESP_SYSTEM_PANIC>",
                                "help": "Invoke gdbstub on the serial port, allowing for gdb to attach to it to do a postmortem\nof the crash.",
                                "id": "ESP_SYSTEM_PANIC_GDBSTUB",
                                "name": "ESP_SYSTEM_PANIC_GDBSTUB",
                                "range": null,
                                "title": "Invoke GDBStub",
                                "type": "bool"
                            }
                        ],
                        "depends_on": null,
                        "help": "If FreeRTOS detects unexpected behaviour or an unhandled exception, the panic handler is\ninvoked. Configure the panic handler's action here.",
                        "id": "component-config-esp-system-settings-panic-handler-behaviour",
                        "name": "ESP_SYSTEM_PANIC",
                        "title": "Panic handler behaviour",
                        "type": "choice"
                    },
                    {
                        "children": [],
                        "depends_on": null,
                        "help": "Only initialize and use the main core.",
                        "id": "ESP_SYSTEM_SINGLE_CORE_MODE",
                        "name": "ESP_SYSTEM_SINGLE_CORE_MODE",
                        "range": null,
                        "title": null,
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": null,
                        "help": null,
                        "id": "ESP_SYSTEM_RTC_EXT_XTAL",
                        "name": "ESP_SYSTEM_RTC_EXT_XTAL",
                        "range": null,
                        "title": null,
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "ESP_SYSTEM_RTC_EXT_XTAL",
                        "help": "To reduce the startup time of an external RTC crystal,\nwe bootstrap it with a 32kHz square wave for a fixed number of cycles.\nSetting 0 will disable bootstrapping (if disabled, the crystal may take\nlonger to start up or fail to oscillate under some conditions).\n\nIf this value is too high, a faulty crystal may initially start and then fail.\nIf this value is too low, an otherwise good crystal may not start.\n\nTo accurately determine if the crystal has started,\nset a larger \"Number of cycles for RTC_SLOW_CLK calibration\" (about 3000).",
                        "id": "ESP_SYSTEM_RTC_EXT_XTAL_BOOTSTRAP_CYCLES",
                        "name": "ESP_SYSTEM_RTC_EXT_XTAL_BOOTSTRAP_CYCLES",
                        "range": null,
                        "title": "Bootstrap cycles for external 32kHz crystal",
                        "type": "int"
                    },
                    {
                        "children": [],
                        "depends_on": null,
                        "help": null,
                        "id": "ESP_SYSTEM_RTC_FAST_MEM_AS_HEAP_DEPCHECK",
                        "name": "ESP_SYSTEM_RTC_FAST_MEM_AS_HEAP_DEPCHECK",
                        "range": null,
                        "title": null,
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "ESP_SYSTEM_RTC_FAST_MEM_AS_HEAP_DEPCHECK",
                        "help": "This config option allows to add RTC fast memory region to system heap with capability\nsimilar to that of DRAM region but without DMA. This memory will be consumed first per\nheap initialization order by early startup services and scheduler related code. Speed\nwise RTC fast memory operates on APB clock and hence does not have much performance impact.",
                        "id": "ESP_SYSTEM_ALLOW_RTC_FAST_MEM_AS_HEAP",
                        "name": "ESP_SYSTEM_ALLOW_RTC_FAST_MEM_AS_HEAP",
                        "range": null,
                        "title": "Enable RTC fast memory for dynamic allocations",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "!SPIRAM",
                        "help": "If enabled, chip will try to power down flash at light sleep, which costs more time when chip wakes up.\nCan only be enabled if there is no SPIRAM configured. This option will in fact consider VDD_SDIO auto power\nvalue (ESP_PD_OPTION_AUTO) as OFF. Also, it is possible to force a power domain to stay ON during light\nsleep by using esp_sleep_pd_config() function.",
                        "id": "ESP_SYSTEM_PD_FLASH",
                        "name": "ESP_SYSTEM_PD_FLASH",
                        "range": null,
                        "title": "PD flash at light sleep when there is no SPIRAM",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "IDF_TARGET_ESP32C3",
                        "help": "If enabled, the CPU will be powered down in light sleep. Enabling this option will consume\n1.68 KB of internal RAM and will reduce sleep current consumption by about 100 uA.",
                        "id": "ESP_SYSTEM_PM_POWER_DOWN_CPU",
                        "name": "ESP_SYSTEM_PM_POWER_DOWN_CPU",
                        "range": null,
                        "title": "Power down CPU in light sleep",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "SPIRAM",
                        "help": "When the CS pin of SPIRAM is not pulled up, the sleep current will\nincrease during light sleep. If the CS pin of SPIRAM has an external\npull-up, you do not need to select this option, otherwise, you\nshould enable this option.",
                        "id": "ESP_SYSTEM_PSRAM_LEAKAGE_WORKAROUND",
                        "name": "ESP_SYSTEM_PSRAM_LEAKAGE_WORKAROUND",
                        "range": null,
                        "title": "PSRAM leakage current workaround in light sleep",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": null,
                        "help": "When the CS pin of Flash is not pulled up, the sleep current will\nincrease during light sleep. If the CS pin of Flash has an external\npull-up, you do not need to select this option, otherwise, you\nshould enable this option.",
                        "id": "ESP_SYSTEM_FLASH_LEAKAGE_WORKAROUND",
                        "name": "ESP_SYSTEM_FLASH_LEAKAGE_WORKAROUND",
                        "range": null,
                        "title": "Flash leakage current workaround in light sleep",
                        "type": "bool"
                    },
                    {
                        "children": [
                            {
                                "children": [],
                                "depends_on": "ESP_CONSOLE_USB_SERIAL_JTAG || ESP_CONSOLE_SECONDARY_USB_SERIAL_JTAG",
                                "help": "When the chip goes sleep or software reset, the clock source would change to XTAL\nand switch off the BBPLL clock for saving power. However, this might make the\nUSB_SERIAL_JTAG down which depends on BBPLL as its unique clock source.\nTherefore, this is used for keeping bbpll clock always on when USB_SERIAL_JTAG PORT is using.\nIf you want to use USB_SERIAL_JTAG under sw_reset case or sleep-wakeup case, you shoule select\nthis option. But be aware that this might increase the power consumption.",
                                "id": "RTC_CLOCK_BBPLL_POWER_ON_WITH_USB",
                                "name": "RTC_CLOCK_BBPLL_POWER_ON_WITH_USB",
                                "range": null,
                                "title": "Keep BBPLL clock always work",
                                "type": "bool"
                            }
                        ],
                        "depends_on": null,
                        "id": "component-config-esp-system-settings-rtc-clock-config",
                        "title": "RTC Clock Config",
                        "type": "menu"
                    },
                    {
                        "children": [
                            {
                                "children": [
                                    {
                                        "children": [],
                                        "depends_on": "ESP_SYSTEM_MEMPROT_FEATURE",
                                        "help": "Once locked, memory protection settings cannot be changed anymore.\nThe lock is reset only on the chip startup.",
                                        "id": "ESP_SYSTEM_MEMPROT_FEATURE_LOCK",
                                        "name": "ESP_SYSTEM_MEMPROT_FEATURE_LOCK",
                                        "range": null,
                                        "title": "Lock memory protection settings",
                                        "type": "bool"
                                    }
                                ],
                                "depends_on": "IDF_TARGET_ESP32C3 || IDF_TARGET_ESP32S2",
                                "help": "If enabled, the permission control module watches all the memory access and fires the panic handler\nif a permission violation is detected. This feature automatically splits\nthe SRAM memory into data and instruction segments and sets Read/Execute permissions\nfor the instruction part (below given splitting address) and Read/Write permissions\nfor the data part (above the splitting address). The memory protection is effective\non all access through the IRAM0 and DRAM0 buses.",
                                "id": "ESP_SYSTEM_MEMPROT_FEATURE",
                                "name": "ESP_SYSTEM_MEMPROT_FEATURE",
                                "range": null,
                                "title": "Enable memory protection",
                                "type": "bool"
                            }
                        ],
                        "depends_on": null,
                        "id": "component-config-esp-system-settings-memory-protection",
                        "title": "Memory protection",
                        "type": "menu"
                    }
                ],
                "depends_on": null,
                "id": "component-config-esp-system-settings",
                "title": "ESP System Settings",
                "type": "menu"
            },
            {
                "children": [
                    {
                        "children": [
                            {
                                "children": [],
                                "depends_on": "<choice LOG_DEFAULT_LEVEL>",
                                "help": null,
                                "id": "LOG_DEFAULT_LEVEL_NONE",
                                "name": "LOG_DEFAULT_LEVEL_NONE",
                                "range": null,
                                "title": "No output",
                                "type": "bool"
                            },
                            {
                                "children": [],
                                "depends_on": "<choice LOG_DEFAULT_LEVEL>",
                                "help": null,
                                "id": "LOG_DEFAULT_LEVEL_ERROR",
                                "name": "LOG_DEFAULT_LEVEL_ERROR",
                                "range": null,
                                "title": "Error",
                                "type": "bool"
                            },
                            {
                                "children": [],
                                "depends_on": "<choice LOG_DEFAULT_LEVEL>",
                                "help": null,
                                "id": "LOG_DEFAULT_LEVEL_WARN",
                                "name": "LOG_DEFAULT_LEVEL_WARN",
                                "range": null,
                                "title": "Warning",
                                "type": "bool"
                            },
                            {
                                "children": [],
                                "depends_on": "<choice LOG_DEFAULT_LEVEL>",
                                "help": null,
                                "id": "LOG_DEFAULT_LEVEL_INFO",
                                "name": "LOG_DEFAULT_LEVEL_INFO",
                                "range": null,
                                "title": "Info",
                                "type": "bool"
                            },
                            {
                                "children": [],
                                "depends_on": "<choice LOG_DEFAULT_LEVEL>",
                                "help": null,
                                "id": "LOG_DEFAULT_LEVEL_DEBUG",
                                "name": "LOG_DEFAULT_LEVEL_DEBUG",
                                "range": null,
                                "title": "Debug",
                                "type": "bool"
                            },
                            {
                                "children": [],
                                "depends_on": "<choice LOG_DEFAULT_LEVEL>",
                                "help": null,
                                "id": "LOG_DEFAULT_LEVEL_VERBOSE",
                                "name": "LOG_DEFAULT_LEVEL_VERBOSE",
                                "range": null,
                                "title": "Verbose",
                                "type": "bool"
                            }
                        ],
                        "depends_on": null,
                        "help": "Specify how much output to see in logs by default.\nYou can set lower verbosity level at runtime using\nesp_log_level_set function.\n\nNote that this setting limits which log statements\nare compiled into the program. So setting this to, say,\n\"Warning\" would mean that changing log level to \"Debug\"\nat runtime will not be possible.",
                        "id": "component-config-log-output-default-log-verbosity",
                        "name": "LOG_DEFAULT_LEVEL",
                        "title": "Default log verbosity",
                        "type": "choice"
                    },
                    {
                        "children": [],
                        "depends_on": null,
                        "help": null,
                        "id": "LOG_DEFAULT_LEVEL",
                        "name": "LOG_DEFAULT_LEVEL",
                        "range": null,
                        "title": null,
                        "type": "int"
                    },
                    {
                        "children": [],
                        "depends_on": null,
                        "help": "Enable ANSI terminal color codes in bootloader output.\n\nIn order to view these, your terminal program must support ANSI color codes.",
                        "id": "LOG_COLORS",
                        "name": "LOG_COLORS",
                        "range": null,
                        "title": "Use ANSI terminal colors in log output",
                        "type": "bool"
                    },
                    {
                        "children": [
                            {
                                "children": [],
                                "depends_on": "<choice LOG_TIMESTAMP_SOURCE>",
                                "help": null,
                                "id": "LOG_TIMESTAMP_SOURCE_RTOS",
                                "name": "LOG_TIMESTAMP_SOURCE_RTOS",
                                "range": null,
                                "title": "Milliseconds Since Boot",
                                "type": "bool"
                            },
                            {
                                "children": [],
                                "depends_on": "<choice LOG_TIMESTAMP_SOURCE>",
                                "help": null,
                                "id": "LOG_TIMESTAMP_SOURCE_SYSTEM",
                                "name": "LOG_TIMESTAMP_SOURCE_SYSTEM",
                                "range": null,
                                "title": "System Time",
                                "type": "bool"
                            }
                        ],
                        "depends_on": null,
                        "help": "Choose what sort of timestamp is displayed in the log output:\n\n- Milliseconds since boot is calulated from the RTOS tick count multiplied\n  by the tick period. This time will reset after a software reboot.\n  e.g. (90000)\n\n- System time is taken from POSIX time functions which use the ESP32's\n  RTC and FRC1 timers to maintain an accurate time. The system time is\n  initialized to 0 on startup, it can be set with an SNTP sync, or with\n  POSIX time functions. This time will not reset after a software reboot.\n  e.g. (00:01:30.000)\n\n- NOTE: Currently this will not get used in logging from binary blobs\n  (i.e WiFi & Bluetooth libraries), these will always print\n  milliseconds since boot.",
                        "id": "component-config-log-output-log-timestamps",
                        "name": "LOG_TIMESTAMP_SOURCE",
                        "title": "Log Timestamps",
                        "type": "choice"
                    }
                ],
                "depends_on": null,
                "id": "component-config-log-output",
                "title": "Log output",
                "type": "menu"
            },
            {
                "children": [
                    {
                        "children": [
                            {
                                "children": [],
                                "depends_on": "<choice NEWLIB_STDOUT_LINE_ENDING>",
                                "help": null,
                                "id": "NEWLIB_STDOUT_LINE_ENDING_CRLF",
                                "name": "NEWLIB_STDOUT_LINE_ENDING_CRLF",
                                "range": null,
                                "title": "CRLF",
                                "type": "bool"
                            },
                            {
                                "children": [],
                                "depends_on": "<choice NEWLIB_STDOUT_LINE_ENDING>",
                                "help": null,
                                "id": "NEWLIB_STDOUT_LINE_ENDING_LF",
                                "name": "NEWLIB_STDOUT_LINE_ENDING_LF",
                                "range": null,
                                "title": "LF",
                                "type": "bool"
                            },
                            {
                                "children": [],
                                "depends_on": "<choice NEWLIB_STDOUT_LINE_ENDING>",
                                "help": null,
                                "id": "NEWLIB_STDOUT_LINE_ENDING_CR",
                                "name": "NEWLIB_STDOUT_LINE_ENDING_CR",
                                "range": null,
                                "title": "CR",
                                "type": "bool"
                            }
                        ],
                        "depends_on": null,
                        "help": "This option allows configuring the desired line endings sent to UART\nwhen a newline ('\\n', LF) appears on stdout.\nThree options are possible:\n\nCRLF: whenever LF is encountered, prepend it with CR\n\nLF: no modification is applied, stdout is sent as is\n\nCR: each occurence of LF is replaced with CR\n\nThis option doesn't affect behavior of the UART driver (drivers/uart.h).",
                        "id": "component-config-newlib-line-ending-for-uart-output",
                        "name": "NEWLIB_STDOUT_LINE_ENDING",
                        "title": "Line ending for UART output",
                        "type": "choice"
                    },
                    {
                        "children": [
                            {
                                "children": [],
                                "depends_on": "<choice NEWLIB_STDIN_LINE_ENDING>",
                                "help": null,
                                "id": "NEWLIB_STDIN_LINE_ENDING_CRLF",
                                "name": "NEWLIB_STDIN_LINE_ENDING_CRLF",
                                "range": null,
                                "title": "CRLF",
                                "type": "bool"
                            },
                            {
                                "children": [],
                                "depends_on": "<choice NEWLIB_STDIN_LINE_ENDING>",
                                "help": null,
                                "id": "NEWLIB_STDIN_LINE_ENDING_LF",
                                "name": "NEWLIB_STDIN_LINE_ENDING_LF",
                                "range": null,
                                "title": "LF",
                                "type": "bool"
                            },
                            {
                                "children": [],
                                "depends_on": "<choice NEWLIB_STDIN_LINE_ENDING>",
                                "help": null,
                                "id": "NEWLIB_STDIN_LINE_ENDING_CR",
                                "name": "NEWLIB_STDIN_LINE_ENDING_CR",
                                "range": null,
                                "title": "CR",
                                "type": "bool"
                            }
                        ],
                        "depends_on": null,
                        "help": "This option allows configuring which input sequence on UART produces\na newline ('\\n', LF) on stdin.\nThree options are possible:\n\nCRLF: CRLF is converted to LF\n\nLF: no modification is applied, input is sent to stdin as is\n\nCR: each occurence of CR is replaced with LF\n\nThis option doesn't affect behavior of the UART driver (drivers/uart.h).",
                        "id": "component-config-newlib-line-ending-for-uart-input",
                        "name": "NEWLIB_STDIN_LINE_ENDING",
                        "title": "Line ending for UART input",
                        "type": "choice"
                    },
                    {
                        "children": [],
                        "depends_on": null,
                        "help": "ESP32 ROM contains parts of newlib C library, including printf/scanf family\nof functions. These functions have been compiled with so-called \"nano\"\nformatting option. This option doesn't support 64-bit integer formats and C99\nfeatures, such as positional arguments.\n\nFor more details about \"nano\" formatting option, please see newlib readme file,\nsearch for '--enable-newlib-nano-formatted-io':\nhttps://sourceware.org/newlib/README\n\nIf this option is enabled, build system will use functions available in\nROM, reducing the application binary size. Functions available in ROM run\nfaster than functions which run from flash. Functions available in ROM can\nalso run when flash instruction cache is disabled.\n\nIf you need 64-bit integer formatting support or C99 features, keep this\noption disabled.",
                        "id": "NEWLIB_NANO_FORMAT",
                        "name": "NEWLIB_NANO_FORMAT",
                        "range": null,
                        "title": "Enable 'nano' formatting options for printf/scanf family",
                        "type": "bool"
                    }
                ],
                "depends_on": null,
                "id": "component-config-newlib",
                "title": "Newlib",
                "type": "menu"
            },
            {
                "children": [
                    {
                        "children": [
                            {
                                "children": [],
                                "depends_on": "SPI_FLASH_VERIFY_WRITE",
                                "help": "If this option is enabled, if SPI flash write verification fails then a log error line\nwill be written with the address, expected & actual values. This can be useful when\ndebugging hardware SPI flash problems.",
                                "id": "SPI_FLASH_LOG_FAILED_WRITE",
                                "name": "SPI_FLASH_LOG_FAILED_WRITE",
                                "range": null,
                                "title": "Log errors if verification fails",
                                "type": "bool"
                            },
                            {
                                "children": [],
                                "depends_on": "SPI_FLASH_VERIFY_WRITE",
                                "help": "If this option is enabled, any SPI flash write which tries to set zero bits in the flash to\nones will log a warning. Such writes will not result in the requested data appearing identically\nin flash once written, as SPI NOR flash can only set bits to one when an entire sector is erased.\nAfter erasing, individual bits can only be written from one to zero.\n\nNote that some software (such as SPIFFS) which is aware of SPI NOR flash may write one bits as an\noptimisation, relying on the data in flash becoming a bitwise AND of the new data and any existing data.\nSuch software will log spurious warnings if this option is enabled.",
                                "id": "SPI_FLASH_WARN_SETTING_ZERO_TO_ONE",
                                "name": "SPI_FLASH_WARN_SETTING_ZERO_TO_ONE",
                                "range": null,
                                "title": "Log warning if writing zero bits to ones",
                                "type": "bool"
                            }
                        ],
                        "depends_on": null,
                        "help": "If this option is enabled, any time SPI flash is written then the data will be read\nback and verified. This can catch hardware problems with SPI flash, or flash which\nwas not erased before verification.",
                        "id": "SPI_FLASH_VERIFY_WRITE",
                        "name": "SPI_FLASH_VERIFY_WRITE",
                        "range": null,
                        "title": "Verify SPI flash writes",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": null,
                        "help": "This option enables the following APIs:\n\n- spi_flash_reset_counters\n- spi_flash_dump_counters\n- spi_flash_get_counters\n\nThese APIs may be used to collect performance data for spi_flash APIs\nand to help understand behaviour of libraries which use SPI flash.",
                        "id": "SPI_FLASH_ENABLE_COUNTERS",
                        "name": "SPI_FLASH_ENABLE_COUNTERS",
                        "range": null,
                        "title": "Enable operation counters",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": null,
                        "help": "Enable this flag to use patched versions of SPI flash ROM driver functions.\nThis option should be enabled, if any one of the following is true: (1) need to write\nto flash on ESP32-D2WD; (2) main SPI flash is connected to non-default pins; (3) main\nSPI flash chip is manufactured by ISSI.",
                        "id": "SPI_FLASH_ROM_DRIVER_PATCH",
                        "name": "SPI_FLASH_ROM_DRIVER_PATCH",
                        "range": null,
                        "title": "Enable SPI flash ROM driver patched functions",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "IDF_TARGET_ESP32S3 || IDF_TARGET_ESP32C3",
                        "help": "Enable this flag to use new SPI flash driver functions from ROM instead of ESP-IDF.\n\nIf keeping this as \"n\" in your project, you will have less free IRAM.\nBut you can use all of our flash features.\n\nIf making this as \"y\" in your project, you will increase free IRAM.\nBut you may miss out on some flash features and support for new flash chips.\n\nCurrently the ROM cannot support the following features:\n\n- SPI_FLASH_AUTO_SUSPEND (C3, S3)",
                        "id": "SPI_FLASH_ROM_IMPL",
                        "name": "SPI_FLASH_ROM_IMPL",
                        "range": null,
                        "title": "Use esp_flash implementation in ROM",
                        "type": "bool"
                    },
                    {
                        "children": [
                            {
                                "children": [],
                                "depends_on": "<choice SPI_FLASH_DANGEROUS_WRITE>",
                                "help": null,
                                "id": "SPI_FLASH_DANGEROUS_WRITE_ABORTS",
                                "name": "SPI_FLASH_DANGEROUS_WRITE_ABORTS",
                                "range": null,
                                "title": "Aborts",
                                "type": "bool"
                            },
                            {
                                "children": [],
                                "depends_on": "<choice SPI_FLASH_DANGEROUS_WRITE>",
                                "help": null,
                                "id": "SPI_FLASH_DANGEROUS_WRITE_FAILS",
                                "name": "SPI_FLASH_DANGEROUS_WRITE_FAILS",
                                "range": null,
                                "title": "Fails",
                                "type": "bool"
                            },
                            {
                                "children": [],
                                "depends_on": "<choice SPI_FLASH_DANGEROUS_WRITE>",
                                "help": null,
                                "id": "SPI_FLASH_DANGEROUS_WRITE_ALLOWED",
                                "name": "SPI_FLASH_DANGEROUS_WRITE_ALLOWED",
                                "range": null,
                                "title": "Allowed",
                                "type": "bool"
                            }
                        ],
                        "depends_on": null,
                        "help": "SPI flash APIs can optionally abort or return a failure code\nif erasing or writing addresses that fall at the beginning\nof flash (covering the bootloader and partition table) or that\noverlap the app partition that contains the running app.\n\nIt is not recommended to ever write to these regions from an IDF app,\nand this check prevents logic errors or corrupted firmware memory from\ndamaging these regions.\n\nNote that this feature *does not* check calls to the esp_rom_xxx SPI flash\nROM functions. These functions should not be called directly from IDF\napplications.",
                        "id": "component-config-spi-flash-driver-writing-to-dangerous-flash-regions",
                        "name": "SPI_FLASH_DANGEROUS_WRITE",
                        "title": "Writing to dangerous flash regions",
                        "type": "choice"
                    },
                    {
                        "children": [],
                        "depends_on": null,
                        "help": "The implementation of SPI flash has been greatly changed in IDF v4.0.\nEnable this option to use the legacy implementation.",
                        "id": "SPI_FLASH_USE_LEGACY_IMPL",
                        "name": "SPI_FLASH_USE_LEGACY_IMPL",
                        "range": null,
                        "title": "Use the legacy implementation before IDF v4.0",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "!SPI_FLASH_USE_LEGACY_IMPL && !IDF_TARGET_ESP32S2",
                        "help": "Each SPI bus needs a lock for arbitration among devices. This allows multiple\ndevices on a same bus, but may reduce the speed of esp_flash driver access to the\nmain flash chip.\n\nIf you only need to use esp_flash driver to access the main flash chip, disable\nthis option, and the lock will be bypassed on SPI1 bus. Otherwise if extra devices\nare needed to attach to SPI1 bus, enable this option.",
                        "id": "SPI_FLASH_SHARE_SPI1_BUS",
                        "name": "SPI_FLASH_SHARE_SPI1_BUS",
                        "range": null,
                        "title": "Support other devices attached to SPI1 bus",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": null,
                        "help": "Some flash chips can have very high \"max\" erase times, especially for block erase (32KB or 64KB).\nThis option allows to bypass \"block erase\" and always do sector erase commands.\nThis will be much slower overall in most cases, but improves latency for other code to run.",
                        "id": "SPI_FLASH_BYPASS_BLOCK_ERASE",
                        "name": "SPI_FLASH_BYPASS_BLOCK_ERASE",
                        "range": null,
                        "title": "Bypass a block erase and always do sector erase",
                        "type": "bool"
                    },
                    {
                        "children": [
                            {
                                "children": [],
                                "depends_on": "SPI_FLASH_YIELD_DURING_ERASE",
                                "help": "If a duration of one erase command is large\nthen it will yield CPUs after finishing a current command.",
                                "id": "SPI_FLASH_ERASE_YIELD_DURATION_MS",
                                "name": "SPI_FLASH_ERASE_YIELD_DURATION_MS",
                                "range": null,
                                "title": "Duration of erasing to yield CPUs (ms)",
                                "type": "int"
                            },
                            {
                                "children": [],
                                "depends_on": "SPI_FLASH_YIELD_DURING_ERASE",
                                "help": "Defines how many ticks will be before returning to continue a erasing.",
                                "id": "SPI_FLASH_ERASE_YIELD_TICKS",
                                "name": "SPI_FLASH_ERASE_YIELD_TICKS",
                                "range": null,
                                "title": "CPU release time (tick) for an erase operation",
                                "type": "int"
                            }
                        ],
                        "depends_on": null,
                        "help": "This allows to yield the CPUs between erase commands.\nPrevents starvation of other tasks.",
                        "id": "SPI_FLASH_YIELD_DURING_ERASE",
                        "name": "SPI_FLASH_YIELD_DURING_ERASE",
                        "range": null,
                        "title": "Enables yield operation during flash erase",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "IDF_TARGET_ESP32C3 && !SPI_FLASH_USE_LEGACY_IMPL && !SPI_FLASH_ROM_IMPL",
                        "help": "This option is default n before ESP32-C3, because it needs bootloader support.\n\nCAUTION: If you want to OTA to an app with this feature turned on, please make\nsure the bootloader has the support for it. (later than IDF v4.3)\n\nAuto-suspend feature is only supported by XMC chip.\nIf you are using an official module, please contact Espressif Business support.\nAlso reading auto suspend part in `SPI Flash API` document before you enable this function.",
                        "id": "SPI_FLASH_AUTO_SUSPEND",
                        "name": "SPI_FLASH_AUTO_SUSPEND",
                        "range": null,
                        "title": "Auto suspend long erase/write operations (READ DOCS FIRST)",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": null,
                        "help": "Flash write is broken down in terms of multiple (smaller) write operations.\nThis configuration options helps to set individual write chunk size, smaller\nvalue here ensures that cache (and non-IRAM resident interrupts) remains\ndisabled for shorter duration.",
                        "id": "SPI_FLASH_WRITE_CHUNK_SIZE",
                        "name": "SPI_FLASH_WRITE_CHUNK_SIZE",
                        "range": [
                            256,
                            8192
                        ],
                        "title": "Flash write chunk size",
                        "type": "int"
                    },
                    {
                        "children": [],
                        "depends_on": null,
                        "help": "SPI Flash driver uses the flash size configured in bootloader header by default.\nEnable this option to override flash size with latest ESPTOOLPY_FLASHSIZE value from\nthe app header if the size in the bootloader header is incorrect.",
                        "id": "SPI_FLASH_SIZE_OVERRIDE",
                        "name": "SPI_FLASH_SIZE_OVERRIDE",
                        "range": null,
                        "title": "Override flash size in bootloader header by ESPTOOLPY_FLASHSIZE",
                        "type": "bool"
                    },
                    {
                        "children": [],
                        "depends_on": "!SPI_FLASH_USE_LEGACY_IMPL",
                        "help": "This option is helpful if you are using a flash chip whose timeout is quite large or unpredictable.",
                        "id": "SPI_FLASH_CHECK_ERASE_TIMEOUT_DISABLED",
                        "name": "SPI_FLASH_CHECK_ERASE_TIMEOUT_DISABLED",
                        "range": null,
                        "title": "Flash timeout checkout disabled",
                        "type": "bool"
                    },
                    {
                        "children": [
                            {
                                "children": [],
                                "depends_on": null,
                                "help": "Enable this to support auto detection of ISSI chips if chip vendor not directly\ngiven by ``chip_drv`` member of the chip struct. This adds support for variant\nchips, however will extend detecting time.",
                                "id": "SPI_FLASH_SUPPORT_ISSI_CHIP",
                                "name": "SPI_FLASH_SUPPORT_ISSI_CHIP",
                                "range": null,
                                "title": "ISSI",
                                "type": "bool"
                            },
                            {
                                "children": [],
                                "depends_on": null,
                                "help": "Enable this to support auto detection of MXIC chips if chip vendor not directly\ngiven by ``chip_drv`` member of the chip struct. This adds support for variant\nchips, however will extend detecting time.",
                                "id": "SPI_FLASH_SUPPORT_MXIC_CHIP",
                                "name": "SPI_FLASH_SUPPORT_MXIC_CHIP",
                                "range": null,
                                "title": "MXIC",
                                "type": "bool"
                            },
                            {
                                "children": [],
                                "depends_on": null,
                                "help": "Enable this to support auto detection of GD (GigaDevice) chips if chip vendor not\ndirectly given by ``chip_drv`` member of the chip struct. If you are using Wrover\nmodules, please don't disable this, otherwise your flash may not work in 4-bit\nmode.\n\nThis adds support for variant chips, however will extend detecting time and image\nsize. Note that the default chip driver supports the GD chips with product ID\n60H.",
                                "id": "SPI_FLASH_SUPPORT_GD_CHIP",
                                "name": "SPI_FLASH_SUPPORT_GD_CHIP",
                                "range": null,
                                "title": "GigaDevice",
                                "type": "bool"
                            },
                            {
                                "children": [],
                                "depends_on": null,
                                "help": "Enable this to support auto detection of Winbond chips if chip vendor not directly\ngiven by ``chip_drv`` member of the chip struct. This adds support for variant\nchips, however will extend detecting time.",
                                "id": "SPI_FLASH_SUPPORT_WINBOND_CHIP",
                                "name": "SPI_FLASH_SUPPORT_WINBOND_CHIP",
                                "range": null,
                                "title": "Winbond",
                                "type": "bool"
                            },
                            {
                                "children": [],
                                "depends_on": null,
                                "help": "Enable this to support auto detection of BOYA chips if chip vendor not directly\ngiven by ``chip_drv`` member of the chip struct. This adds support for variant\nchips, however will extend detecting time.",
                                "id": "SPI_FLASH_SUPPORT_BOYA_CHIP",
                                "name": "SPI_FLASH_SUPPORT_BOYA_CHIP",
                                "range": null,
                                "title": "BOYA",
                                "type": "bool"
                            },
                            {
                                "children": [],
                                "depends_on": null,
                                "help": "Enable this to support auto detection of TH chips if chip vendor not directly\ngiven by ``chip_drv`` member of the chip struct. This adds support for variant\nchips, however will extend detecting time.",
                                "id": "SPI_FLASH_SUPPORT_TH_CHIP",
                                "name": "SPI_FLASH_SUPPORT_TH_CHIP",
                                "range": null,
                                "title": "TH",
                                "type": "bool"
                            }
                        ],
                        "depends_on": null,
                        "id": "component-config-spi-flash-driver-auto-detect-flash-chips",
                        "title": "Auto-detect flash chips",
                        "type": "menu"
                    },
                    {
                        "children": [],
                        "depends_on": null,
                        "help": "This option enables flash read/write operations to encrypted partition/s. This option\nis kept enabled irrespective of state of flash encryption feature. However, in case\napplication is not using flash encryption feature and is in need of some additional\nmemory from IRAM region (~1KB) then this config can be disabled.",
                        "id": "SPI_FLASH_ENABLE_ENCRYPTED_READ_WRITE",
                        "name": "SPI_FLASH_ENABLE_ENCRYPTED_READ_WRITE",
                        "range": null,
                        "title": "Enable encrypted partition read/write operations",
                        "type": "bool"
                    }
                ],
                "depends_on": null,
                "id": "component-config-spi-flash-driver",
                "title": "SPI Flash driver",
                "type": "menu"
            }
        ],
        "depends_on": null,
        "id": "component-config",
        "title": "Component config",
        "type": "menu"
    },
    {
        "children": [
            {
                "children": [],
                "depends_on": null,
                "help": "Soc, esp32, and driver components, the most common\ncomponents. Some header of these components are included\nimplicitly by headers of other components before IDF v4.0.\nIt's not required for high-level components, but still\nincluded through long header chain everywhere.\n\nThis is harmful to the modularity. So it's changed in IDF\nv4.0.\n\nYou can still include these headers in a legacy way until it\nis totally deprecated by enable this option.",
                "id": "LEGACY_INCLUDE_COMMON_HEADERS",
                "name": "LEGACY_INCLUDE_COMMON_HEADERS",
                "range": null,
                "title": "Include headers across components as before IDF v4.0",
                "type": "bool"
            }
        ],
        "depends_on": null,
        "id": "compatibility-options",
        "title": "Compatibility options",
        "type": "menu"
    }
]