From 6369fa916c07a3a531f219e233cb587622f1bd08 Mon Sep 17 00:00:00 2001 From: cfif Date: Wed, 15 Apr 2026 14:02:25 +0300 Subject: [PATCH] Init --- APP/inc/ADC_Temp.h | 22 +++++--- APP/main.c | 125 ++++++++++++------------------------------ APP/src/ADC_Temp.c | 132 +++++++++++++++++++++++++++++++++++---------- 3 files changed, 152 insertions(+), 127 deletions(-) diff --git a/APP/inc/ADC_Temp.h b/APP/inc/ADC_Temp.h index 0874d79..fe56e58 100644 --- a/APP/inc/ADC_Temp.h +++ b/APP/inc/ADC_Temp.h @@ -10,8 +10,9 @@ // Типы таблиц NTC typedef enum { - TABLE_KST45 = 0, // Таблица из документа KST45 - TABLE_INCAR = 1 // Таблица из документа Incar + TABLE_DUCT = 0, // Таблица из документа KST45 (Duct) + TABLE_INCAR = 1, // Таблица из документа Incar + TABLE_AMBIENT = 2 // Таблица для NTC 10 кОм (Ambient) } eNtcTable; // Алгоритмы расчёта температуры @@ -30,8 +31,9 @@ typedef enum { #define koef_C 0.0000004890545443703666 // Размеры таблиц -#define TABLE_SIZE_KST45 26 +#define TABLE_SIZE_DUCT 26 #define TABLE_SIZE_INCAR 38 +#define TABLE_SIZE_AMBIENT 39 #define TABLE_SIZE_LOOKUP 1024 // Предварительно вычисленная таблица для быстрого доступа для каждой таблицы @@ -53,12 +55,15 @@ typedef struct { // Структура для хранения таблиц быстрого доступа для каждой конфигурации typedef struct { - adc_temp_lookup kst45[TABLE_SIZE_LOOKUP]; + adc_temp_lookup duct[TABLE_SIZE_LOOKUP]; adc_temp_lookup incar[TABLE_SIZE_LOOKUP]; - bool kst45_initialized; + adc_temp_lookup ambient[TABLE_SIZE_LOOKUP]; + bool duct_initialized; bool incar_initialized; - float kst45_r1; + bool ambient_initialized; + float duct_r1; float incar_r1; + float ambient_r1; } fast_lookup_tables_t; // Глобальная структура для доступа к таблицам @@ -66,7 +71,10 @@ extern fast_lookup_tables_t g_fast_tables; // Функции инициализации и конфигурации void init_fast_lookup_table(eNtcTable table_type, float r1, eAlg use_alg); -void init_both_tables(float r1_kst45, float r1_incar, eAlg use_alg); +void init_duct_table(float r1, eAlg use_alg); +void init_incar_table(float r1, eAlg use_alg); +void init_ambient_table(float r1, eAlg use_alg); +void init_all_tables(float r1_duct, float r1_incar, float r1_ambient, eAlg use_alg); void set_active_config(eNtcTable table_type, float r1); const ntc_config_t* get_active_config(void); const fast_lookup_tables_t* get_fast_tables(void); diff --git a/APP/main.c b/APP/main.c index 1f56488..3be37b0 100644 --- a/APP/main.c +++ b/APP/main.c @@ -47,133 +47,74 @@ void save_table_to_csv(const char* filename, const adc_temp_lookup* table, const printf("Таблица '%s' сохранена в CSV файл: %s\n", table_name, filename); } -// Функция для сохранения обеих таблиц -void save_both_tables(void) { +// Функция для сохранения всех таблиц +void save_all_tables(void) { const fast_lookup_tables_t* tables = get_fast_tables(); // Сохраняем в текстовом формате - save_table_to_file("kst45_table.txt", tables->kst45, "KST45"); + save_table_to_file("duct_table.txt", tables->duct, "DUCT"); save_table_to_file("incar_table.txt", tables->incar, "INCAR"); + save_table_to_file("ambient_table.txt", tables->ambient, "AMBIENT"); // Сохраняем в CSV формате (удобно для Excel) - save_table_to_csv("kst45_table.csv", tables->kst45, "KST45"); + save_table_to_csv("duct_table.csv", tables->duct, "DUCT"); save_table_to_csv("incar_table.csv", tables->incar, "INCAR"); -} - -// Функция для сохранения только рабочего диапазона (без зон насыщения) -void save_working_range_to_file(const char* filename, const adc_temp_lookup* table, - const char* table_name, uint16_t min_adc, uint16_t max_adc) { - FILE* file = fopen(filename, "w"); - if (file == NULL) { - printf("Ошибка: не удалось создать файл %s\n", filename); - return; - } - - fprintf(file, "=== Рабочий диапазон таблицы: %s ===\n", table_name); - fprintf(file, "Диапазон ADC: %u - %u\n", min_adc, max_adc); - fprintf(file, "%-8s %-12s %-15s\n", "ADC", "Temp (°C)", "Resistance (Ω)"); - fprintf(file, "----------------------------------------\n"); - - int count = 0; - for (int i = 0; i < TABLE_SIZE_LOOKUP; i++) { - if (table[i].adc_value >= min_adc && table[i].adc_value <= max_adc) { - fprintf(file, "%-8u %-12.1f %-15.2f\n", - table[i].adc_value, - table[i].temp_c / 10.0f, - table[i].resistance_ohm); - count++; - } - } - - fprintf(file, "\nВсего записей в рабочем диапазоне: %d\n", count); - fclose(file); - printf("Рабочий диапазон таблицы '%s' сохранен в файл: %s\n", table_name, filename); + save_table_to_csv("ambient_table.csv", tables->ambient, "AMBIENT"); } int main() { - // Инициализируем обе таблицы одновременно с разными значениями R1 - init_both_tables(40000.0f, // R1 для KST45 - 40000.0f, // R1 для INCAR - ALG_STEINHART); + // Инициализируем все три таблицы с разными значениями R1 + init_all_tables(20000.0f, // R1 для DUCT (KST45) + 20000.0f, // R1 для INCAR + 20000.0f, // R1 для AMBIENT (NTC 10k) + ALG_STEINHART); - uint16_t adc_value = 3200;//1980; + uint16_t adc_value = 2000; - printf("\n=== Работа с обеими таблицами одновременно ===\n"); + printf("\n=== Работа с тремя датчиками одновременно ===\n"); - // Получаем температуру для KST45 - int16_t temp_kst45 = get_temperature_log_fast_for_table(adc_value, TABLE_KST45); - printf("KST45: ADC=%u, Temp=%.2f °C\n", adc_value, temp_kst45 / 10.0f); + // Получаем температуру для DUCT (KST45) + int16_t temp_duct = get_temperature_log_fast_for_table(adc_value, TABLE_DUCT); + printf("DUCT (KST45): ADC=%u, Temp=%.2f °C\n", adc_value, temp_duct / 10.0f); // Получаем температуру для INCAR int16_t temp_incar = get_temperature_log_fast_for_table(adc_value, TABLE_INCAR); printf("INCAR: ADC=%u, Temp=%.2f °C\n", adc_value, temp_incar / 10.0f); - // Можно переключать активную конфигурацию + // Получаем температуру для AMBIENT (NTC 10k) + int16_t temp_ambient = get_temperature_log_fast_for_table(adc_value, TABLE_AMBIENT); + printf("AMBIENT (NTC 10k): ADC=%u, Temp=%.2f °C\n", adc_value, temp_ambient / 10.0f); + + // Переключение активной конфигурации printf("\n=== Переключение активной конфигурации ===\n"); - set_active_config(TABLE_KST45, 3300.0f); + set_active_config(TABLE_DUCT, 3300.0f); int16_t temp_active1 = get_temperature_log_fast(adc_value); - float temp_kst45_alg = get_temperature_from_adc(adc_value, ALG_STEINHART); - printf("Активная (KST45): Temp=%.2f °C Temp (alg) = %.2f °C\n", temp_active1 / 10.0f, temp_kst45_alg); + printf("Активная (DUCT): Temp=%.2f °C\n", temp_active1 / 10.0f); set_active_config(TABLE_INCAR, 3300.0f); int16_t temp_active2 = get_temperature_log_fast(adc_value); - float temp_incar_alg = get_temperature_from_adc(adc_value, ALG_STEINHART); - printf("Активная (INCAR): Temp=%.2f °C Temp (alg) = %.2f °C\n", temp_active2 / 10.0f, temp_incar_alg); + printf("Активная (INCAR): Temp=%.2f °C\n", temp_active2 / 10.0f); - // Получаем доступ к таблицам для отладки - const fast_lookup_tables_t* tables = get_fast_tables(); -/* - printf("\n=== Пример данных из таблиц быстрого поиска ===\n"); - printf("KST45 таблица (первые 15 записи):\n"); - for(int i = 0; i < 15; i++) { - printf(" ADC: %u, Temp: %.1f °C, R: %.2f Ω\n", - tables->kst45[i].adc_value, - tables->kst45[i].temp_c / 10.0f, - tables->kst45[i].resistance_ohm); - } + set_active_config(TABLE_AMBIENT, 10000.0f); + int16_t temp_active3 = get_temperature_log_fast(adc_value); + printf("Активная (AMBIENT): Temp=%.2f °C\n", temp_active3 / 10.0f); - printf("\nINCAR таблица (первые 15 записи):\n"); - for(int i = 0; i < 15; i++) { - printf(" ADC: %u, Temp: %.1f °C, R: %.2f Ω\n", - tables->incar[i].adc_value, - tables->incar[i].temp_c / 10.0f, - tables->incar[i].resistance_ohm); - } - - printf("\nKST45 таблица (последние 15 записи):\n"); - for(int i = TABLE_SIZE_LOOKUP - 1; i > TABLE_SIZE_LOOKUP - 16; i--) { - printf(" ADC: %u, Temp: %.1f °C, R: %.2f Ω\n", - tables->kst45[i].adc_value, - tables->kst45[i].temp_c / 10.0f, - tables->kst45[i].resistance_ohm); - } - - printf("\nINCAR таблица (последние 15 записи):\n"); - for(int i = TABLE_SIZE_LOOKUP - 1; i > TABLE_SIZE_LOOKUP - 16; i--) { - printf(" ADC: %u, Temp: %.1f °C, R: %.2f Ω\n", - tables->incar[i].adc_value, - tables->incar[i].temp_c / 10.0f, - tables->incar[i].resistance_ohm); - } -*/ // Сохраняем таблицы в файлы printf("\n=== Сохранение таблиц в файлы ===\n"); - save_both_tables(); - - // Сохраняем только рабочие диапазоны (без зон насыщения) - // Для KST45 рабочий диапазон примерно от 58 до 3418 - save_working_range_to_file("kst45_working_range.txt", tables->kst45, "KST45", 58, 3418); - save_working_range_to_file("incar_working_range.txt", tables->incar, "INCAR", 58, 3418); + save_all_tables(); // Пример обратного преобразования (температура -> сопротивление) printf("\n=== Обратное преобразование ===\n"); int16_t temp_test = 250; // 25.0 °C - float resistance_kst45 = get_resistance_log_fast_for_table(temp_test, TABLE_KST45); + float resistance_duct = get_resistance_log_fast_for_table(temp_test, TABLE_DUCT); float resistance_incar = get_resistance_log_fast_for_table(temp_test, TABLE_INCAR); + float resistance_ambient = get_resistance_log_fast_for_table(temp_test, TABLE_AMBIENT); + printf("При %.1f °C:\n", temp_test / 10.0f); - printf(" KST45 сопротивление: %.2f Ω\n", resistance_kst45); + printf(" DUCT сопротивление: %.2f Ω\n", resistance_duct); printf(" INCAR сопротивление: %.2f Ω\n", resistance_incar); + printf(" AMBIENT сопротивление: %.2f Ω\n", resistance_ambient); return 0; } \ No newline at end of file diff --git a/APP/src/ADC_Temp.c b/APP/src/ADC_Temp.c index 3961b53..84ef434 100644 --- a/APP/src/ADC_Temp.c +++ b/APP/src/ADC_Temp.c @@ -12,8 +12,8 @@ typedef struct { float r_nom; // Номинальное сопротивление (Ω) } ntc_table_entry; -// Таблица из документа KST45 -static const ntc_table_entry ntc_table_kst45[] = { +// Таблица из документа KST45 (Duct) +static const ntc_table_entry ntc_table_duct[] = { {-40, 100950.0f}, {-35, 72777.0f}, {-30, 53100.0f}, @@ -84,21 +84,66 @@ static const ntc_table_entry ntc_table_incar[] = { {85, 283.0f} }; +// Таблица для NTC 10 кОм (Ambient) +static const ntc_table_entry ntc_table_ambient[] = { + {-40, 332776.0f}, + {-35, 240264.0f}, + {-30, 175427.0f}, + {-25, 129449.0f}, + {-20, 96481.0f}, + {-15, 72592.0f}, + {-10, 55109.0f}, + {-5, 42193.0f}, + {0, 32566.0f}, + {5, 25338.0f}, + {10, 19869.0f}, + {15, 15695.0f}, + {20, 12486.0f}, + {25, 10000.0f}, + {30, 8060.0f}, + {35, 6536.0f}, + {40, 5331.0f}, + {45, 4373.0f}, + {50, 3606.0f}, + {55, 2990.0f}, + {60, 2490.0f}, + {65, 2085.0f}, + {70, 1754.0f}, + {75, 1482.0f}, + {80, 1257.0f}, + {85, 1071.0f}, + {90, 916.4f}, + {95, 786.9f}, + {100, 678.1f}, + {105, 586.5f}, + {110, 509.1f}, + {115, 443.3f}, + {120, 387.3f}, + {125, 339.5f}, + {130, 298.4f}, + {135, 263.1f}, + {140, 232.6f}, + {145, 206.1f}, + {150, 183.2f} +}; + // Глобальная структура для хранения таблиц быстрого доступа fast_lookup_tables_t g_fast_tables = { - .kst45_initialized = false, + .duct_initialized = false, .incar_initialized = false, - .kst45_r1 = 3300.0f, - .incar_r1 = 3300.0f + .ambient_initialized = false, + .duct_r1 = 3300.0f, + .incar_r1 = 3300.0f, + .ambient_r1 = 3300.0f }; // Активная конфигурация static ntc_config_t active_config = { - .table_type = TABLE_KST45, + .table_type = TABLE_DUCT, .r1 = 3300.0f, .start_temp = -40, .end_temp = 85, - .table_size = TABLE_SIZE_KST45 + .table_size = TABLE_SIZE_DUCT }; // Вспомогательная функция для получения таблицы по типу @@ -107,9 +152,9 @@ static const ntc_table_entry* get_table_by_type(eNtcTable table_type, uint16_t* *size = 0; switch(table_type) { - case TABLE_KST45: - table = ntc_table_kst45; - *size = TABLE_SIZE_KST45; + case TABLE_DUCT: + table = ntc_table_duct; + *size = TABLE_SIZE_DUCT; *start_temp = -40; *end_temp = 85; break; @@ -119,9 +164,15 @@ static const ntc_table_entry* get_table_by_type(eNtcTable table_type, uint16_t* *start_temp = -40; *end_temp = 85; break; + case TABLE_AMBIENT: + table = ntc_table_ambient; + *size = TABLE_SIZE_AMBIENT; + *start_temp = -40; + *end_temp = 150; + break; default: - table = ntc_table_kst45; - *size = TABLE_SIZE_KST45; + table = ntc_table_duct; + *size = TABLE_SIZE_DUCT; *start_temp = -40; *end_temp = 85; break; @@ -132,22 +183,26 @@ static const ntc_table_entry* get_table_by_type(eNtcTable table_type, uint16_t* // Функция для получения указателя на таблицу быстрого доступа по типу static adc_temp_lookup* get_fast_table_by_type(eNtcTable table_type) { switch(table_type) { - case TABLE_KST45: - return g_fast_tables.kst45; + case TABLE_DUCT: + return g_fast_tables.duct; case TABLE_INCAR: return g_fast_tables.incar; + case TABLE_AMBIENT: + return g_fast_tables.ambient; default: - return g_fast_tables.kst45; + return g_fast_tables.duct; } } // Функция для получения статуса инициализации таблицы static bool is_table_initialized(eNtcTable table_type) { switch(table_type) { - case TABLE_KST45: - return g_fast_tables.kst45_initialized; + case TABLE_DUCT: + return g_fast_tables.duct_initialized; case TABLE_INCAR: return g_fast_tables.incar_initialized; + case TABLE_AMBIENT: + return g_fast_tables.ambient_initialized; default: return false; } @@ -309,10 +364,12 @@ void init_fast_lookup_table(eNtcTable table_type, float r1, eAlg use_alg) { adc_temp_lookup* fast_table = get_fast_table_by_type(table_type); // Сохраняем значение R1 для этой таблицы - if (table_type == TABLE_KST45) { - g_fast_tables.kst45_r1 = r1; - } else { + if (table_type == TABLE_DUCT) { + g_fast_tables.duct_r1 = r1; + } else if (table_type == TABLE_INCAR) { g_fast_tables.incar_r1 = r1; + } else { + g_fast_tables.ambient_r1 = r1; } // Находим рабочий диапазон АЦП @@ -407,17 +464,35 @@ void init_fast_lookup_table(eNtcTable table_type, float r1, eAlg use_alg) { } // Устанавливаем флаг инициализации - if (table_type == TABLE_KST45) { - g_fast_tables.kst45_initialized = true; - } else { + if (table_type == TABLE_DUCT) { + g_fast_tables.duct_initialized = true; + } else if (table_type == TABLE_INCAR) { g_fast_tables.incar_initialized = true; + } else { + g_fast_tables.ambient_initialized = true; } } -// Инициализация обеих таблиц -void init_both_tables(float r1_kst45, float r1_incar, eAlg use_alg) { - init_fast_lookup_table(TABLE_KST45, r1_kst45, use_alg); +// Инициализация таблицы Duct +void init_duct_table(float r1, eAlg use_alg) { + init_fast_lookup_table(TABLE_DUCT, r1, use_alg); +} + +// Инициализация таблицы Incar +void init_incar_table(float r1, eAlg use_alg) { + init_fast_lookup_table(TABLE_INCAR, r1, use_alg); +} + +// Инициализация таблицы Ambient +void init_ambient_table(float r1, eAlg use_alg) { + init_fast_lookup_table(TABLE_AMBIENT, r1, use_alg); +} + +// Инициализация всех трех таблиц +void init_all_tables(float r1_duct, float r1_incar, float r1_ambient, eAlg use_alg) { + init_fast_lookup_table(TABLE_DUCT, r1_duct, use_alg); init_fast_lookup_table(TABLE_INCAR, r1_incar, use_alg); + init_fast_lookup_table(TABLE_AMBIENT, r1_ambient, use_alg); } // Установка активной конфигурации @@ -444,8 +519,9 @@ const fast_lookup_tables_t* get_fast_tables(void) { int16_t get_temperature_log_fast_for_table(uint16_t adc_value, eNtcTable table_type) { if (!is_table_initialized(table_type)) { // Если таблица не инициализирована, используем обычный расчет - float temp = get_temperature_from_adc_with_table(adc_value, ALG_STEINHART, table_type, - (table_type == TABLE_KST45) ? g_fast_tables.kst45_r1 : g_fast_tables.incar_r1); + float r1 = (table_type == TABLE_DUCT) ? g_fast_tables.duct_r1 : + ((table_type == TABLE_INCAR) ? g_fast_tables.incar_r1 : g_fast_tables.ambient_r1); + float temp = get_temperature_from_adc_with_table(adc_value, ALG_STEINHART, table_type, r1); return (int16_t)(temp * 10.0f); }