No esp launch target found. Please create/select the correct 'Launch Target'

idf_component_register(SRCS "ledc_basic_example_main.c" "OneButton.c"
                    INCLUDE_DIRS ".")

idf_component_register(SRCS "ledc_basic_example_main.c"
                            "OneButton.c"
                    INCLUDE_DIRS ".")

menu "Example control RGB-LED WS2812"

    choice BLINK_LED
        prompt "Blink LED type"
        default BLINK_LED_GPIO if IDF_TARGET_ESP32
        default BLINK_LED_RMT
        help
            Defines the default peripheral for blink example

        config BLINK_LED_GPIO
            bool "GPIO"
        config BLINK_LED_RMT
            bool "RMT - Addressable LED"
    endchoice

    config BLINK_LED_RMT_CHANNEL
        depends on BLINK_LED_RMT
        int "RMT Channel"
        range 0 7
        default 0
        help
            Set the RMT peripheral channel.
            ESP32 RMT channel from 0 to 7
            ESP32-S2 RMT channel from 0 to 3
            ESP32-S3 RMT channel from 0 to 3
            ESP32-C3 RMT channel from 0 to 1

    config BLINK_GPIO
        int "Blink GPIO number"
        range 0 48
        default 8 if IDF_TARGET_ESP32C3 || IDF_TARGET_ESP32H2
        default 18 if IDF_TARGET_ESP32S2
        default 48 if IDF_TARGET_ESP32S3
        default 5
        help
            GPIO number (IOxx) to blink on and off or the RMT signal for the addressable LED.
            Some GPIOs are used for other purposes (flash connections, etc.) and cannot be used to blink.

    config BLINK_PERIOD
        int "Blink period in ms"
        range 10 3600000
        default 1000
        help
            Define the blinking period in milliseconds.
endmenu

cmake_minimum_required(VERSION 3.5)

set(EXTRA_COMPONENT_DIRS $ENV{IDF_PATH}/examples/common_components/led_strip)

include($ENV{IDF_PATH}/tools/cmake/project.cmake)
get_filename_component(ProjectId ${CMAKE_CURRENT_LIST_DIR} NAME)
string(REPLACE " " "_" ProjectId ${ProjectId})
project(${ProjectId})

#include "led_strip.h"

static uint8_t s_led_state = 0;

static led_strip_t *pStrip_a;

static void configure_led(void)
{
    ESP_LOGI("configure_led", "Example configured to blink addressable LED!");
    /* LED strip initialization with the GPIO and pixels number*/
    pStrip_a = led_strip_init(CONFIG_BLINK_LED_RMT_CHANNEL, CONFIG_BLINK_GPIO, 1);
    /* Set all LED off to clear all pixels */
    pStrip_a->clear(pStrip_a, 50);
}

static void blink_led(void)
{
    /* If the addressable LED is enabled */
    if (s_led_state) {
        /* Set the LED pixel using RGB from 0 (0%) to 255 (100%) for each color */
        pStrip_a->set_pixel(pStrip_a, 0, 16, 16, 16);
        /* Refresh the strip to send data */
        pStrip_a->refresh(pStrip_a, 100);
    } else {
        /* Set all LED off to clear all pixels */
        pStrip_a->clear(pStrip_a, 50);
    }
}

void app_main(void)
{
    configure_led();
    while(1)
    {
        /* Toggle the LED state */
        blink_led();
        s_led_state = !s_led_state;
        vTaskDelay(CONFIG_BLINK_PERIOD / portTICK_PERIOD_MS);
    }
}

idf_component_register(SRCS "cmd_wifi.c"
                            "console_example_main.c"
                            "../esp_idf_components/console/commands.c"
                    INCLUDE_DIRS ".")

~/esp/esp-idf$ git status
Отсоединённый указатель HEAD указывает на v4.4.1

$ idf.py --version
ESP-IDF v5.4.1-dirty

каталогпроекта$ idf.py size
...
Total sizes:
Used stat D/IRAM:  155732 bytes ( 171948 remain, 47.5% used)
      .data size:   23580 bytes
      .bss  size:   49864 bytes
      .text size:   82288 bytes
Used Flash size : 1458700 bytes
      .text     : 1034218 bytes
      .rodata   :  424226 bytes
Total image size: 1564568 bytes (.bin may be padded larger)

ESP_ERROR_CHECK(adc1_config_width(ADC_WIDTH_BIT_12));

// ADC1_CHANNEL_2 соответствует выводу GPIO_NUM_2, т. е. GPIO2:
ESP_ERROR_CHECK(adc1_config_channel_atten(ADC1_CHANNEL_2, ADC_ATTEN_DB_11));

uint64_t wakeup_mask = BIT(GPIO_NUM_2);
ESP_ERROR_CHECK(esp_deep_sleep_enable_gpio_wakeup(wakeup_mask, ESP_GPIO_WAKEUP_GPIO_LOW));
ESP_LOGI(__FUNCTION__, "Entering deep sleep...");
esp_sleep_pd_config(ESP_PD_DOMAIN_VDDSDIO, ESP_PD_OPTION_OFF);
esp_deep_sleep_start();

gpio_config_t pincfg =
{  .pin_bit_mask = BIT(GPIO_NUM_2),
   .mode         = GPIO_MODE_INPUT,
   .pull_up_en   = GPIO_PULLUP_ENABLE };
ESP_ERROR_CHECK(gpio_config(&pincfg));

// Далее настройка пробуждения вызовами esp_deep_sleep_enable_gpio_wakeup

// и esp_sleep_pd_config, и затем уход в сон через esp_deep_sleep_start.

Squiggles are disabled for this translation unit (/home/username/myproject/src/main.c).

{
    "configurations": [
        {
            "name": "Linux",
            "includePath": [
                "${default}",
                "./include"
            ],
            "defines": [],
            "compilerPath": "/usr/bin/gcc",
            "cStandard": "c17",
            "cppStandard": "gnu++14",
            "intelliSenseMode": "linux-gcc-x64"
        }
    ],
    "version": 4
}

{
    "idf.adapterTargetName": "esp32c3",
    "C_Cpp.errorSquiggles": "enabled"
}

TEvent evt;

for(uint8_t i=0; i < 3; i++)
{
   esp_err_t ret = ESP_OK;  // компилятор выдаст предупреждение на
                            // не используемую переменную ret...
   ESP_GOTO_ON_ERROR(pdTRUE == xQueueReceive(queue, &evt, 100) ? ESP_OK : ESP_FAIL,
                     err_measure, __FUNCTION__, "Failed to read voltage");
   ESP_LOGI(__FUNCTION__, "%.3fV", voltage);err_measure:
   vTaskDelay(100/portTICK_PERIOD_MS);
}

   esp_err_t ret = ESP_OK;
   (void)ret;  // подавляет warning на не используемую переменную ret

#include "esp_idf_version.h"

#if (ESP_IDF_VERSION == ESP_IDF_VERSION_VAL(4, 4, 1))

# include "driver/gpio.h"

# include "driver/uart.h"

#elif (ESP_IDF_VERSION == ESP_IDF_VERSION_VAL(5, 0, 1))

# include "rom/gpio.h"

# include "rom/uart.h"

#endif

# register ESP IDF component

if("v4.4.1-dirty" STREQUAL ${IDF_VER})

idf_component_register( REQUIRES        "driver"
                                        "esp_adc_cal")

elseif("v5.0.1" STREQUAL ${IDF_VER})

idf_component_register( REQUIRES        "driver"
                                        "esp_adc")

endif()

error: format '%u' expects argument of type 'unsigned int', but argument 6
 has type 'uint32_t' {aka 'long unsigned int'} [-Werror=format=]

uint32_t phaseincrement = (uint32_t)((uint64_t)4294967296*freq/samplerate);
ESP_LOGI("", "phaseincrement %u", phaseincrement);

ESP_LOGI("", "phaseincrement %" PRIu32, phaseincrement);

error: expected ')' before 'PRIu32'
   ESP_LOGI("", "phaseincrement %" PRIu32, phaseincrement);
                                   ^~~~~~

error: missing binary operator before token "(" #if (ESP_IDF_VERSION == ESP_IDF_VERSION_VAL(4, 4, 1))

// Здесь не надо указывать атрибут IRAM_ATTR:

void IRAM_ATTR ledc_timer_overflow_isr(void *arg);

// А вот здесь как раз IRAM_ATTR нужен:

void IRAM_ATTR ledc_timer_overflow_isr(void *arg)
{
  // Очистка бит прерываний:
  uint32_t intstatus = READ_PERI_REG(LEDC_INT_ST_REG);
  WRITE_PERI_REG(LEDC_INT_CLR_REG, intstatus);

  // Здесь код обработчика прерывания:
  ...
}

ESP_LOGW(__FUNCTION__, "%d", __LINE__);

I (662) phy_init: phy_version 909,156dee4,Apr  7 2022,20:27:09
I (842) wifi:mode : sta (a0:76:4e:14:5a:3c)
I (842) wifi:enable tsf

W (842) off_task: 475
W (842) off_task: 483

assert failed: 0x4038aaea
Core  0 register dump:
MEPC    : 0x4038085e  RA      : 0x4038a710  SP      : 0x3fcae140  GP      : 0x3fc94a00
TP      : 0x3fc4563c  T0      : 0x37363534  T1      : 0x7271706f  T2      : 0x33323130
S0/FP   : 0x00000000  S1      : 0x00000000  A0      : 0x3fcae154  A1      : 0x00000061
A2      : 0x00000003  A3      : 0x3fcae168  A4      : 0x00000001  A5      : 0x3fca3000
A6      : 0x7a797877  A7      : 0x76757473  S2      : 0x00000000  S3      : 0x00000000
S4      : 0x00000000  S5      : 0x00000000  S6      : 0x00000000  S7      : 0x00000000
S8      : 0x00000000  S9      : 0x00000000  S10     : 0x00000000  S11     : 0x00000000
T3      : 0x6e6d6c6b  T4      : 0x6a696867  T5      : 0x66656463  T6      : 0x62613938
MSTATUS : 0x00001801  MTVEC   : 0x40380001  MCAUSE  : 0x00000007  MTVAL   : 0x00000000
MHARTID : 0x00000000
..

idf_component_register(SRCS "main.c"
                            "cmd_console.c"
                            "i2capp.c"
                            "ds18b20app.c"
                            "si5351a_synth.c"
                            "nvsapp.c"
                            "debug.c"
                            "radiochannels.c"
                            "ifsktx.c"
                            "ifskcrc.c"
                            "OneButton.c"
                            "vars.c"
                            "rs_code157.c"
                            "sleep.c"
                            "blinkapp.c"
                            #"aht10.c"
                            "aht.c"
                            "i2cdev.c"
                       PRIV_REQUIRES
                            fatfs
                            esp_driver_i2c
                       INCLUDE_DIRS "."
                                    "${IDF_PATH}/../esp-idf-lib/components/esp_idf_lib_helpers")

> set
ALLUSERSPROFILE=C:\ProgramData
...
IDF_PATH=C:\Espressif\frameworks\esp-idf-v5.4.1
IDF_PYTHON=C:/Espressif/python_env/idf5.4_py3.11_env/Scripts/python.exe
IDF_PYTHON_DIR=C:\Espressif\python_env\idf5.4_py3.11_env\Scripts\
IDF_PYTHON_ENV_PATH=C:\Espressif\python_env\idf5.4_py3.11_env
IDF_TOOLS_EXPORT_CMD=C:\Espressif\frameworks\esp-idf-v5.4.1\export.bat
IDF_TOOLS_INSTALL_CMD=C:\Espressif\frameworks\esp-idf-v5.4.1\install.bat
IDF_TOOLS_JSON_PATH=C:\Espressif\frameworks\esp-idf-v5.4.1\tools\tools.json
IDF_TOOLS_PATH=C:\Espressif
IDF_TOOLS_PY_PATH=C:\Espressif\frameworks\esp-idf-v5.4.1\tools\idf_tools.py
...
ProgramData=C:\ProgramData
ProgramFiles=C:\Program Files
ProgramFiles(x86)=C:\Program Files (x86)
ProgramW6432=C:\Program Files
windir=C:\Windows

    esp_console_repl_t *repl = NULL;
    esp_console_repl_config_t repl_config = ESP_CONSOLE_REPL_CONFIG_DEFAULT();

#if CONFIG_EXAMPLE_STORE_HISTORY
    initialize_filesystem();
    repl_config.history_save_path = HISTORY_PATH;
#endif
    repl_config.prompt = ">"; // приглашение командной строки консоли
    // Инсталляция консоли (console REPL environment), запуск задачи console_repl:
#if CONFIG_ESP_CONSOLE_UART
    esp_console_dev_uart_config_t uart_config = ESP_CONSOLE_DEV_UART_CONFIG_DEFAULT();
    ESP_ERROR_CHECK(esp_console_new_repl_uart(&uart_config, &repl_config, &repl));
#elif CONFIG_ESP_CONSOLE_USB_CDC
    esp_console_dev_usb_cdc_config_t cdc_config = ESP_CONSOLE_DEV_CDC_CONFIG_DEFAULT();
    ESP_ERROR_CHECK(esp_console_new_repl_usb_cdc(&cdc_config, &repl_config, &repl));
#elif CONFIG_ESP_CONSOLE_USB_SERIAL_JTAG
    esp_console_dev_usb_serial_jtag_config_t usbjtag_config = ESP_CONSOLE_DEV_USB_SERIAL_JTAG_CONFIG_DEFAULT();
    ESP_ERROR_CHECK(esp_console_new_repl_usb_serial_jtag(&usbjtag_config, &repl_config, &repl));
#endif

    ...
    repl_config.prompt = ">"; // приглашение командной строки консоли
    repl_config.task_stack_size = 8196;
    // Инсталляция консоли (console REPL environment), запуск задачи console_repl:
    ...

#include "freertos/FreeRTOS.h"
#include "freertos/task.h"

void print_current_task_info() {
    TaskHandle_t current_task = xTaskGetCurrentTaskHandle();
    char *task_name = pcTaskGetName(current_task);
    UBaseType_t priority = uxTaskPriorityGet(current_task);

    printf("Current Task: %s\n", task_name);
    printf("Priority: %d\n", priority);
    printf("Stack High Water Mark: %d\n", uxTaskGetStackHighWaterMark(current_task));
}

void print_detailed_task_info() {
    TaskHandle_t current_task = xTaskGetCurrentTaskHandle();
    TaskStatus_t task_status;

    vTaskGetInfo(current_task, &task_status, pdTRUE, eInvalid);

    printf("Имя задачи: %s\n", task_status.pcTaskName);
    printf("Номер задачи: %d\n", (int)task_status.xTaskNumber);
    printf("Текущее состояние: %d\n", (int)task_status.eCurrentState);
    printf("Текущий приоритет: %d\n", (int)task_status.uxCurrentPriority);
    printf("Базовый приоритет: %d\n", (int)task_status.uxBasePriority);
    printf("Счетчик реального времени: %lu\n", task_status.ulRunTimeCounter);
    printf("Сколько осталось неиспользованного места в стеке: %d\n",
           uxTaskGetStackHighWaterMark(current_task));
}

$ idf.py menuconfig

void print_all_tasks() {
    // Выделите достаточный размер буфера, чтобы в нем
    // поместилась информация, которую выдаст vTaskList:
    char *buffer = malloc(1024);
    if (buffer != NULL) {
        vTaskList(buffer);
        printf("Task Name\tState\tPriority\tStack\tTask#\n");
        printf("------------------------------------------------\n");
        printf("%s\n", buffer);        free(buffer);
    }
}

void print_runtime_stats() {
    char *buffer = malloc(1024);
    if (buffer != NULL) {
        vTaskGetRunTimeStats(buffer);
        printf("Runtime-статистика:\n");
        printf("%s\n", buffer);
        free(buffer);
    }
}

#include "esp_console.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"

static int task_list_cmd(int argc, char **argv) {
    char *buffer = malloc(1024);
    if (buffer) {
        vTaskList(buffer);
        printf("Task Name\tState\tPriority\tStack\tTask#\n");
        printf("------------------------------------------------\n");
        printf("%s\n", buffer);
        free(buffer);
    }
    return 0;
}

static int task_stats_cmd(int argc, char **argv) {
    char *buffer = malloc(1024);
    if (buffer) {
        vTaskGetRunTimeStats(buffer);
        printf("Runtime Statistics:\n");
        printf("%s\n", buffer);
        free(buffer);
    }
    return 0;
}

void register_task_commands() {
    const esp_console_cmd_t cmd_list = {
        .command = "tasklist",
        .help = "List all FreeRTOS tasks",
        .hint = NULL,
        .func = &task_list_cmd,
    };
    const esp_console_cmd_t cmd_stats = {
        .command = "taskstats",
        .help = "Show task runtime statistics",
        .hint = NULL,
        .func = &task_stats_cmd,
    };

    esp_console_cmd_register(&cmd_list);
    esp_console_cmd_register(&cmd_stats);
}

#include < stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"

void task_monitor(void *pvParameters) {
    while (1) {
        printf("\n=== Current Task Info ===\n");

        // Информация текущей задачи:
        TaskHandle_t current = xTaskGetCurrentTaskHandle();
        printf("Current: %s (Priority: %d)\n",
                pcTaskGetName(current),
                uxTaskPriorityGet(current));

        // Периодически выводится список всех задач:
        char *buffer = malloc(1024);
        if (buffer) {
            vTaskList(buffer);
            printf("\nAll Tasks:\n");
            printf("Name\tState\tPri\tStack\t#\n");
            printf("------------------------\n");
            printf("%s\n", buffer);
            free(buffer);
        }

        vTaskDelay(pdMS_TO_TICKS(5000)); // Информация выводится каждые 5 секунд
    }
}

void app_main() {
    // Создание задачи мониторинга:
    xTaskCreate(task_monitor, "task_monitor", 4096, NULL, 1, NULL);

    // Далее код вашего приложения:
    ...
}

#define configGENERATE_RUN_TIME_STATS 1
#define configUSE_STATS_FORMATTING_FUNCTIONS 1

BaseType_t xTaskCreate(
    TaskFunction_t pvTaskCode,
    const char * const pcName,
    const uint32_t usStackDepth,  // ← Это значение задается в БАЙТАХ
    void *pvParameters,
    UBaseType_t uxPriority,
    TaskHandle_t *pxCreatedTask
);

// Все эти значения задаются в байтах. Обратите внимание, что целесообразно
// для размера стека указывать значения, нацело делящиеся на 4, поскольку
// 32-битная платформа для хранения в стеке адресов использует тип uint32_t.
#define SMALL_TASK_STACK    2048   // 2KB
#define MEDIUM_TASK_STACK   4096   // 4KB
#define LARGE_TASK_STACK    8192   // 8KB
#define VERY_LARGE_STACK   16384   // 16KB

// Создание задач, размер стека указан в байтах:
xTaskCreate(my_task, "task1", SMALL_TASK_STACK, NULL, 1, NULL);
xTaskCreate(another_task, "task2", MEDIUM_TASK_STACK, NULL, 1, NULL);

#define MINIMUM_STACK 768   // 768 байт

#define SAFE_MINIMUM 1024   // 1 килобайт

#define COMMON_STACK 4096   // 4 килобайта

// Задачи, работающие с сетью, требуют повышенного размера стека:
#define WIFI_TASK_STACK     6144   // 6KB
#define TCP_TASK_STACK      4096   // 4KB
#define HTTP_SERVER_STACK   8192   // 8KB

// Задачи периферийных устройств:
#define SPI_TASK_STACK      2048   // 2KB
#define I2C_TASK_STACK      2048   // 2KB
#define UART_TASK_STACK     2048   // 2KB

// Задачи приложения:
#define UI_TASK_STACK       4096   // 4KB
#define SENSOR_TASK_STACK   3072   // 3KB
#define LOGGING_TASK_STACK  2048   // 2KB

void my_task(void *pvParameters) {
    // Проверка, сколько стека свободно (в байтах) в момент запуска задачи:
    UBaseType_t high_water_mark = uxTaskGetStackHighWaterMark(NULL);
    printf("Выделено для стека задачи: %d байт\n", configSTACK_SIZE);

   // Далее ваш код задачи, который выполняет какие-либо действия,
    // приводящие к утилизации стека задачи:
    ...

    // Проверка текущего состояния стека задачи:
    high_water_mark = uxTaskGetStackHighWaterMark(NULL);
    printf("Минимальное свободное пространство стека за все время: %d bytes\n", high_water_mark);
    printf("Максимальное использованное пространство стека: %d bytes\n", configSTACK_SIZE - high_water_mark);

    if (high_water_mark < 256) {
        printf("WARNING: мало места в стеке! Свободно только %d байт\n", high_water_mark);
    }
}

--- Warning: Failed to decode multiple lines in a row. Try 
 checking the baud rate and XTAL frequency setting in menuconfig

$ idf.py menuconfig

#include < stdio.h>
#include < string.h>
#include < iconv.h>
#include < esp_log.h>

static const char* TAG = "CP1251_TO_UTF8";
void cp1251_to_utf8(const char* cp1251_str, char* utf8_buffer, size_t buffer_size)
{
    iconv_t cd = iconv_open("UTF-8", "CP1251");
    if (cd == (iconv_t)-1) {
        ESP_LOGE(TAG, "Ошибка инициализации iconv");
        strncpy(utf8_buffer, cp1251_str, buffer_size);
        return;
    }
    size_t in_bytes_left = strlen(cp1251_str);
    size_t out_bytes_left = buffer_size - 1; // резервирование пространства под null-терминатор

    char *in_ptr = (char*)cp1251_str;    char *out_ptr = utf8_buffer;
    size_t result = iconv(cd, &in_ptr, &in_bytes_left, &out_ptr, &out_bytes_left);

    if (result == (size_t)-1) {
        ESP_LOGE(TAG, "Ошибка преобразования");
    }

    *out_ptr = '\0'; // завершение Null-терминатором выходной строки

    iconv_close(cd);
}

void app_main()
{
    // Строка текста, закодированная в CP1251 (русский текст "Привет, мир!")
    unsigned char cp1251_text[] = {0xCF, 0xF0, 0xE8, 0xE2, 0xE5, 0xF2, 0x2C,
                                   0x20, 0xEC, 0xE8, 0xF0, 0x21, 0x00};

    char utf8_buffer[256];

    cp1251_to_utf8((char*)cp1251_text, utf8_buffer, sizeof(utf8_buffer));

    printf("Original CP1251: %s\n", cp1251_text);
    printf("Converted UTF-8: %s\n", utf8_buffer);
    ESP_LOGI(TAG, "UTF-8: %s", utf8_buffer);
}

#include < stdio.h>
#include < string.h>
#include < esp_log.h>

static const char* TAG = "CP1251_TO_UTF8";

// Таблица преобразования CP1251 в UTF-8 для символов кириллицы (коды 0x80-0xFF):
static const char* cp1251_to_utf8_table[128] = {
    /* 0x80 */ "\u0402", /* 0x81 */ "\u0403", /* 0x82 */ "\u201A", /* 0x83 */ "\u0453",
    /* 0x84 */ "\u201E", /* 0x85 */ "\u2026", /* 0x86 */ "\u2020", /* 0x87 */ "\u2021",
    /* 0x88 */ "\u20AC", /* 0x89 */ "\u2030", /* 0x8A */ "\u0409", /* 0x8B */ "\u2039",
    /* 0x8C */ "\u040A", /* 0x8D */ "\u040C", /* 0x8E */ "\u040B", /* 0x8F */ "\u040F",
    /* 0x90 */ "\u0452", /* 0x91 */ "\u2018", /* 0x92 */ "\u2019", /* 0x93 */ "\u201C",
    /* 0x94 */ "\u201D", /* 0x95 */ "\u2022", /* 0x96 */ "\u2013", /* 0x97 */ "\u2014",
    /* 0x98 */ " ",      /* 0x99 */ "\u2122", /* 0x9A */ "\u0459", /* 0x9B */ "\u203A",
    /* 0x9C */ "\u045A", /* 0x9D */ "\u045C", /* 0x9E */ "\u045B", /* 0x9F */ "\u045F",
    /* 0xA0 */ "\u00A0", /* 0xA1 */ "\u040E", /* 0xA2 */ "\u045E", /* 0xA3 */ "\u0408",
    /* 0xA4 */ "\u00A4", /* 0xA5 */ "\u0490", /* 0xA6 */ "\u00A6", /* 0xA7 */ "\u00A7",
    /* 0xA8 */ "\u0401", /* 0xA9 */ "\u00A9", /* 0xAA */ "\u0404", /* 0xAB */ "\u00AB",
    /* 0xAC */ "\u00AC", /* 0xAD */ "\u00AD", /* 0xAE */ "\u00AE", /* 0xAF */ "\u0407",
    /* 0xB0 */ "\u00B0", /* 0xB1 */ "\u00B1", /* 0xB2 */ "\u0406", /* 0xB3 */ "\u0456",
    /* 0xB4 */ "\u0491", /* 0xB5 */ "\u00B5", /* 0xB6 */ "\u00B6", /* 0xB7 */ "\u00B7",
    /* 0xB8 */ "\u0451", /* 0xB9 */ "\u2116", /* 0xBA */ "\u0454", /* 0xBB */ "\u00BB",
    /* 0xBC */ "\u0458", /* 0xBD */ "\u0405", /* 0xBE */ "\u0455", /* 0xBF */ "\u0457",
    /* 0xC0 */ "\u0410", /* 0xC1 */ "\u0411", /* 0xC2 */ "\u0412", /* 0xC3 */ "\u0413",
    /* 0xC4 */ "\u0414", /* 0xC5 */ "\u0415", /* 0xC6 */ "\u0416", /* 0xC7 */ "\u0417",
    /* 0xC8 */ "\u0418", /* 0xC9 */ "\u0419", /* 0xCA */ "\u041A", /* 0xCB */ "\u041B",
    /* 0xCC */ "\u041C", /* 0xCD */ "\u041D", /* 0xCE */ "\u041E", /* 0xCF */ "\u041F",
    /* 0xD0 */ "\u0420", /* 0xD1 */ "\u0421", /* 0xD2 */ "\u0422", /* 0xD3 */ "\u0423",
    /* 0xD4 */ "\u0424", /* 0xD5 */ "\u0425", /* 0xD6 */ "\u0426", /* 0xD7 */ "\u0427",
    /* 0xD8 */ "\u0428", /* 0xD9 */ "\u0429", /* 0xDA */ "\u042A", /* 0xDB */ "\u042B",
    /* 0xDC */ "\u042C", /* 0xDD */ "\u042D", /* 0xDE */ "\u042E", /* 0xDF */ "\u042F",
    /* 0xE0 */ "\u0430", /* 0xE1 */ "\u0431", /* 0xE2 */ "\u0432", /* 0xE3 */ "\u0433",
    /* 0xE4 */ "\u0434", /* 0xE5 */ "\u0435", /* 0xE6 */ "\u0436", /* 0xE7 */ "\u0437",
    /* 0xE8 */ "\u0438", /* 0xE9 */ "\u0439", /* 0xEA */ "\u043A", /* 0xEB */ "\u043B",
    /* 0xEC */ "\u043C", /* 0xED */ "\u043D", /* 0xEE */ "\u043E", /* 0xEF */ "\u043F",
    /* 0xF0 */ "\u0440", /* 0xF1 */ "\u0441", /* 0xF2 */ "\u0442", /* 0xF3 */ "\u0443",
    /* 0xF4 */ "\u0444", /* 0xF5 */ "\u0445", /* 0xF6 */ "\u0446", /* 0xF7 */ "\u0447",
    /* 0xF8 */ "\u0448", /* 0xF9 */ "\u0449", /* 0xFA */ "\u044A", /* 0xFB */ "\u044B",
    /* 0xFC */ "\u044C", /* 0xFD */ "\u044D", /* 0xFE */ "\u044E", /* 0xFF */ "\u044F"
};

void cp1251_to_utf8_manual(const unsigned char* cp1251_str, char* utf8_buffer, size_t buffer_size)
{
    size_t i = 0, j = 0;

    while (cp1251_str[i] != '\0' && j < buffer_size - 1) {
        unsigned char c = cp1251_str[i++];

        if (c < 0x80) {
            // Символ ASCII - копируем как есть
            if (j < buffer_size - 1) {
                utf8_buffer[j++] = c;
            }
        } else {
            // Символ CP1251 - перекодируем по таблице
            const char* utf8_char = cp1251_to_utf8_table[c - 0x80];
            size_t len = strlen(utf8_char);

            if (j + len < buffer_size - 1) {
                strcpy(&utf8_buffer[j], utf8_char);
                j += len;
            }
        }
    }

    utf8_buffer[j] = '\0';
}

void app_main() {
    // Русский текст в кодировке CP1251:
    unsigned char cp1251_text[] = {0xCF, 0xF0, 0xE8, 0xE2, 0xE5, 0xF2, 0x2C,
                                   0x20, 0xEC, 0xE8, 0xF0, 0x21, 0x00};

    char utf8_buffer[256];

    cp1251_to_utf8_manual(cp1251_text, utf8_buffer, sizeof(utf8_buffer));

    printf("CP1251: %s\n", cp1251_text);
    printf("UTF-8: %s\n", utf8_buffer);
    ESP_LOGI(TAG, "Converted: %s", utf8_buffer);
}

#include < stdio.h>
#include < string.h>

typedef struct {
    unsigned char cp1251;
    const char* utf8;
} cp1251_utf8_map_t;

// Таблица соответствия кодов русских символов cp1251
// символам UTF8 (вы можете расширить эту таблицу):
static const cp1251_utf8_map_t cp1251_utf8_map[] = {
    {0xC0, "А"}, {0xC1, "Б"}, {0xC2, "В"}, {0xC3, "Г"}, {0xC4, "Д"},
    {0xC5, "Е"}, {0xC6, "Ж"}, {0xC7, "З"}, {0xC8, "И"}, {0xC9, "Й"},
    {0xCA, "К"}, {0xCB, "Л"}, {0xCC, "М"}, {0xCD, "Н"}, {0xCE, "О"},
    {0xCF, "П"}, {0xD0, "Р"}, {0xD1, "С"}, {0xD2, "Т"}, {0xD3, "У"},
    {0xD4, "Ф"}, {0xD5, "Х"}, {0xD6, "Ц"}, {0xD7, "Ч"}, {0xD8, "Ш"},
    {0xD9, "Щ"}, {0xDA, "Ъ"}, {0xDB, "Ы"}, {0xDC, "Ь"}, {0xDD, "Э"},
    {0xDE, "Ю"}, {0xDF, "Я"}, {0xE0, "а"}, {0xE1, "б"}, {0xE2, "в"},
    {0xE3, "г"}, {0xE4, "д"}, {0xE5, "е"}, {0xE6, "ж"}, {0xE7, "з"},
    {0xE8, "и"}, {0xE9, "й"}, {0xEA, "к"}, {0xEB, "л"}, {0xEC, "м"},
    {0xED, "н"}, {0xEE, "о"}, {0xEF, "п"}, {0xF0, "р"}, {0xF1, "с"},
    {0xF2, "т"}, {0xF3, "у"}, {0xF4, "ф"}, {0xF5, "х"}, {0xF6, "ц"},
    {0xF7, "ч"}, {0xF8, "ш"}, {0xF9, "щ"}, {0xFA, "ъ"}, {0xFB, "ы"},
    {0xFC, "ь"}, {0xFD, "э"}, {0xFE, "ю"}, {0xFF, "я"},
    {0x00, NULL} // маркер конца таблицы
};

const char* cp1251_char_to_utf8(unsigned char c) {
    for (int i = 0; cp1251_utf8_map[i].utf8 != NULL; i++) {
        if (cp1251_utf8_map[i].cp1251 == c) {
            return cp1251_utf8_map[i].utf8;
        }
    }
    return NULL;
}

void cp1251_to_utf8_simple(const unsigned char* cp1251_str, char* utf8_buffer, size_t buffer_size)
{
    size_t i = 0, j = 0;

    while (cp1251_str[i] != '\0' && j < buffer_size - 1) {
        unsigned char c = cp1251_str[i++];

        if (c < 0x80) {
            // ASCII            utf8_buffer[j++] = c;
        } else {
            // CP1251
            const char* utf8_char = cp1251_char_to_utf8(c);
            if (utf8_char) {
                size_t len = strlen(utf8_char);
                if (j + len < buffer_size) {
                    strcpy(&utf8_buffer[j], utf8_char);
                    j += len;
                }
            } else {
                // Неизвестный символ - скопируйте его как есть или замените
                utf8_buffer[j++] = '?';
            }
        }
    }

    utf8_buffer[j] = '\0';
}

// Таблица преобразования CP1251 в UTF-8 для символов кириллицы (коды 0x80-0xFF):
static const char* cp1251_to_utf8_table[128] = {
    /* 0x80 */ "\u0402", /* 0x81 */ "\u0403", /* 0x82 */ "\u201A", /* 0x83 */ "\u0453",
    /* 0x84 */ "\u201E", /* 0x85 */ "\u2026", /* 0x86 */ "\u2020", /* 0x87 */ "\u2021",
    /* 0x88 */ "\u20AC", /* 0x89 */ "\u2030", /* 0x8A */ "\u0409", /* 0x8B */ "\u2039",
    /* 0x8C */ "\u040A", /* 0x8D */ "\u040C", /* 0x8E */ "\u040B", /* 0x8F */ "\u040F",
    /* 0x90 */ "\u0452", /* 0x91 */ "\u2018", /* 0x92 */ "\u2019", /* 0x93 */ "\u201C",
    /* 0x94 */ "\u201D", /* 0x95 */ "\u2022", /* 0x96 */ "\u2013", /* 0x97 */ "\u2014",
    /* 0x98 */ "\u0020", /* 0x99 */ "\u2122", /* 0x9A */ "\u0459", /* 0x9B */ "\u203A",
             // ^ здесь ошибка
    /* 0x9C */ "\u045A", /* 0x9D */ "\u045C", /* 0x9E */ "\u045B", /* 0x9F */ "\u045F",
    /* 0xA0 */ "\u00A0", /* 0xA1 */ "\u040E", /* 0xA2 */ "\u045E", /* 0xA3 */ "\u0408",
    ...

// Packed структура (выравнивание 1 байт)
struct __attribute__((packed)) network_packet {
    uint8_t header;
    uint32_t timestamp;
    uint16_t checksum;
};

void process_packet_safe(void)
{
    #pragma GCC diagnostic push
    #pragma GCC diagnostic ignored "-Waddress-of-packed-member"

    struct network_packet packet;

    // Здесь предупреждение подавлено
    uint32_t *ts_ptr = &packet.timestamp;
    *ts_ptr = 123456789;

    #pragma GCC diagnostic pop

    printf("Timestamp: %lu\n", *ts_ptr);
}

void process_packet_unsafe(void)
{
    struct network_packet packet;

    // Здесь будет предупреждение
    uint32_t *ts_ptr = &packet.timestamp;
    *ts_ptr = 987654321;

    printf("Timestamp: %lu\n", *ts_ptr);
}

void app_main(void)
{
    process_packet_safe();    // без предупреждения
    process_packet_unsafe();  // с предупреждением
}

void safe_access_example(void)
{
    struct network_packet packet;

    // Безопасное чтение
    uint32_t timestamp;
    memcpy(&timestamp, &packet.timestamp, sizeof(timestamp));

    // Безопасная запись
    uint32_t new_ts = 123456;
    memcpy(&packet.timestamp, &new_ts, sizeof(new_ts));
}

#include "esp_rom_sys.h"

void delay_microseconds(uint32_t us) {
    esp_rom_delay_us(us);
}

// Использование:
delay_microseconds(1000); // Задержка 1000 микросекунд = 1 мс

#include "esp32c3/rom/ets_sys.h"

void delay_us(uint32_t microseconds) {
    ets_delay_us(microseconds);
}

// Использование:
delay_us(500); // Задержка 500 микросекунд

#include "freertos/FreeRTOS.h"
#include "freertos/task.h"

void delay_ms(uint32_t milliseconds) {
    vTaskDelay(milliseconds / portTICK_PERIOD_MS);
}

#include "esp_cpu.h"
#include "soc/rtc.h"

void precise_delay_us(uint32_t us)
{
   // Вместо 1000000 подберите константу под известную частоту CPU:
   uint32_t cycles_per_us = esp_cpu_get_cycle_count() / 1000000;
   uint32_t cycles = us * cycles_per_us;

   uint32_t start = esp_cpu_get_cycle_count();
   while (esp_cpu_get_cycle_count() - start < cycles) {
        // busy wait
   }
}

#include "esp_timer.h"

void timer_delay_us(uint64_t us) {
    uint64_t start = esp_timer_get_time();
    while (esp_timer_get_time() - start < us) {
        // busy wait
    }
}

#include "esp_attr.h"

void IRAM_ATTR busy_delay_us(uint32_t us) {
    uint32_t cycles = us * (CONFIG_ESP_DEFAULT_CPU_FREQ_MHZ);
    __asm__ __volatile__ (
        "1: \n"        " addi %0, %0, -1 \n"
        " bnez %0, 1b \n"
        : "+r" (cycles)
    );
}

#include < stdio.h>
#include "esp_rom_sys.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"

void app_main(void)
{
    while (1) {
        printf("Задержка 1 секунда...\n");
        esp_rom_delay_us(1000000); // 1 секунда

        printf("Задержка 500 мкс...\n");
        esp_rom_delay_us(500); // 500 микросекунд

        printf("Задержка 100 мс через FreeRTOS...\n");
        vTaskDelay(100 / portTICK_PERIOD_MS); // 100 миллисекунд
    }
}

#include "driver/gptimer.h"

void precise_timer_delay_us(uint64_t us) {
    gptimer_handle_t gptimer = NULL;
    gptimer_config_t timer_config = {
        .clk_src = GPTIMER_CLK_SRC_DEFAULT,
        .direction = GPTIMER_COUNT_UP,
        .resolution_hz = 1000000, // 1 МГц = 1 мкс разрешение
    };

    esp_err_t err = gptimer_new_timer(&timer_config, &gptimer);
    if (err == ESP_OK) {
        gptimer_start(gptimer);
        uint64_t count;
        gptimer_get_raw_count(gptimer, &count);
        while (gptimer_get_raw_count(gptimer, &count) == ESP_OK && count < us) {}
        gptimer_stop(gptimer);
        gptimer_del_timer(gptimer);
    }
}