Улучшена скорость полла Watch (переделано формирование таблицы)

доработана демо-терминалка для считывания tms переменных и встроена в DebugVarEdit

.gitignore

@@ -4,4 +4,5 @@
 /build_temp
 /DebugVarEdit_GUI.build
 /DebugVarEdit_GUI.dist
-/DebugVarEdit_GUI.onefile-build
+/DebugVarEdit_GUI.onefile-build
+/parse_xml/build/

README.md

@@ -1,23 +1,56 @@
-# DebugVarEdit — Утилита для генерации переменных для отладки
+# DebugTools - Просмотр переменных по указателям
+Модуль состоит из трех файлов:
+- **debug_tools.c** - реализация считывания переменных
+- **debug_tools.h** - объявление всякого для считывания переменных
+- **debug_vars.c** - определение массива считываемых переменных
 
+Этот модуль предоставляет функциональность для чтения значений переменных во встроенной системе, включая работу с IQ-форматами, защиту доступа и проверку диапазонов памяти.
+
+Для чтения переменных можно использовать функции:
+
+```c
+int Debug_ReadVar(int var_ind, int32_t *return_long);
+int Debug_ReadVarName(int var_ind, DebugVarName_t name_ptr);
+```
+
+
+Переменные доступные для чтения определяются в **debug_vars.c** (их можно прописывать вручную или генерировать через **DebugVarEdit**):
+
+```c
+// Определение массива с указателями на переменные для отладки
+int DebugVar_Qnt = 5;
+#pragma DATA_SECTION(dbg_vars,".dbgvar_info")
+//												pointer_type    iq_type			return_iq_type  short_name
+DebugVar_t dbg_vars[] = {\
+{(uint8_t *)&freqTerm,                         	pt_float,       t_iq_none,      t_iq10,         "freqT"              }, \
+{(uint8_t *)&ADC_sf[0][0],                      pt_int16,       t_iq_none,      t_iq_none,      "ADC_sf00"           }, \
+{(uint8_t *)&ADC_sf[0][1],                      pt_int16,       t_iq_none,      t_iq_none,      "ADC_sf01"           }, \
+{(uint8_t *)&ADC_sf[0][2],                      pt_int16,       t_iq_none,      t_iq_none,      "ADC_sf02"           }, \
+{(uint8_t *)&ADC_sf[0][3],                      pt_int16,       t_iq_none,      t_iq_none,      "ADC_sf03"           }, \
+{(uint8_t *)&Bender[0].KOhms,                   pt_uint16,      t_iq,      		t_iq10,      	"Bend0.KOhm"         }, \
+{(uint8_t *)&Bender[0].Times,                   pt_uint16,      t_iq_none,      t_iq_none,      "Bend0.Time"         }, \
+};
+```
+
+# DebugVarEdit - Настройка переменных
 **DebugVarEdit** — графическое приложение для Windows, предназначенное для настройки и генерации отладочных переменных (`debug_vars.c`) на основе исходного C-проекта. Работает с `makefile` проекта, сохраняет изменения в XML и позволяет удобно редактировать переменные и их типы через интерфейс.
 
 Программа — один исполняемый файл `DebugVarEdit.exe`, не требующий установки и дополнительных зависимостей.
 
 > Требуется Windows 7 или новее.
 
-> [Для разработчиков](#для-разработчиков)
 ---
 
-## Как использовать
+## Как использовать приложение
 
 1. Запустите **DebugVarEdit.exe.**
 
-2. Укажите пути:
+2. Укажите пути и контроллер:
    - **Путь к XML** — новый или существующий файл настроек переменных;
    - **Путь к проекту** — путь к корню проека (папка, которая является корнем для проекта в Code Composer);
    - **Путь к makefile** — путь к `makefile` относительно корня проекта;
    - **Путь для debug_vars.c** — папка, куда будет сгенерирован файл `debug_vars.c` с переменными.
+   - **МК** — TMS или STM. Они отличаются размером int, и также принятыми кодировками файлов (utf-8/cp1251)
 
 3. Нажмите **Сканировать переменные**:
    - Программа проанализирует исходники, указанные в makefile, и найдёт все переменные.
@@ -61,7 +94,7 @@
 ## Пример XML-файла
 
 ```xml
-<project proj_path="C:/myproj" makefile_path="Debug/Makefile" structs_path="debugVars/structs.xml">
+<project proj_path="C:/myproj" makefile_path="Debug/Makefile" structs_path="Src/DebugTools/structs.xml">
   <variables>
     <var name="g_myvar">
       <enable>true</enable>
@@ -79,6 +112,7 @@
 </project>
 ```
 
+---
 ---
 
 # Для разработчиков
@@ -107,14 +141,14 @@ Src
 
 Для запуска приложения:
 - **Python 3.7+**
-- **clang** — используется для парсинга C-кода (требуется `libclang.dll`)
+- **clang** — используется для парсинга C-кода (требуется `libclang.dll`, лежит в папке Src)
 - **PySide2** — GUI-фреймворк
 - **lxml** — работа с XML
 > Python 3.7 и PySide2 рекомендуется для совместимости с Windows 7
 
 Для сборки `.exe`:
 - **Nuitka** — создает полностью автономный `.exe` без внешних зависимостей
-- **PyInstaller** — создает `.exe` с зависимостью от `pythonXX.dll` (Python должен быть установлен)
+- **PyInstaller** — создает `.exe` с зависимостью от `pythonXX.dll` (Python должен быть установлен для запуска `.exe`)
 
 
 ### Сборка:
@@ -134,5 +168,5 @@ Src
 ### Установка зависимостей
 
 ```bash
-pip install PySide2 lxml nuitka pyinstaller
+pip install clang PySide2 lxml nuitka pyinstaller
 ```

Src/DebugVarEdit_GUI.py

@@ -5,8 +5,9 @@ import sys
 import os
 import subprocess
 import lxml.etree as ET
-from generate_debug_vars import type_map
+from generate_debug_vars import type_map, choose_type_map
 from enum import IntEnum
+from tms_debugvar_term import _DemoWindow
 import threading
 from generate_debug_vars import run_generate
 import var_setup
@@ -17,12 +18,14 @@ import scan_vars
 import myXML
 import time
 
+
 from PySide2.QtWidgets import (
     QApplication, QWidget, QTableWidget, QTableWidgetItem,
     QCheckBox, QComboBox, QLineEdit, QVBoxLayout, QHBoxLayout, QPushButton,
     QCompleter, QAbstractItemView, QLabel, QMessageBox, QFileDialog, QTextEdit,
-    QDialog, QTreeWidget, QTreeWidgetItem, QSizePolicy, QHeaderView
+    QDialog, QTreeWidget, QTreeWidgetItem, QSizePolicy, QHeaderView, 
-)
+    QMenuBar, QMenu, QAction
+    )
 from PySide2.QtGui import QTextCursor, QKeyEvent, QIcon, QFont
 from PySide2.QtCore import Qt, QProcess, QObject, Signal, QSettings
 
@@ -58,6 +61,7 @@ class VarEditor(QWidget):
         self.output_path = None
         self._updating = False  # Флаг блокировки рекурсии
         self._resizing = False  # флаг блокировки повторного вызова
+        self.target = 'TMS'
         self.initUI()
 
     def initUI(self):
@@ -122,6 +126,43 @@ class VarEditor(QWidget):
         self.btn_update_vars = QPushButton(scan_title)
         self.btn_update_vars.clicked.connect(self.update_vars_data)
 
+        # Добавляем чекбокс для выбора типовой карты
+        # --- Создаем верхнее меню ---
+        menubar = QMenuBar(self)
+        menubar.setToolTip('Разные размеры int и кодировки файлов')
+        self.target_menu = QMenu("МК:", menubar)
+        # Создаем действия для выбора Target
+        self.action_tms = QAction("TMS", self, checkable=True)
+        self.action_stm = QAction("STM", self, checkable=True)
+        # Инициализируем QSettings с именем организации и приложения
+        self.settings = QSettings("SET", "DebugVarEdit_MainWindow")
+        # Восстанавливаем сохранённое состояние, если есть
+        mcu = self.settings.value("mcu_choosen", True, type=str)
+        self.on_target_selected(mcu)
+
+        self.target_menu.setToolTip(f'TMS: Размер int 16 бит. Кодировка cp1251\nSTM: Размер int 32 бита. Кодировка utf-8')
+        # Группируем действия чтобы выбирался только один
+        self.action_tms.triggered.connect(lambda: self.on_target_selected("TMS"))
+        self.action_tms.setToolTip('Размер int 16 бит. Кодировка cp1251')
+        self.action_stm.triggered.connect(lambda: self.on_target_selected("STM"))
+        self.action_stm.setToolTip('Размер int 32 бита. Кодировка utf-8')
+
+        self.target_menu.addAction(self.action_tms)
+        self.target_menu.addAction(self.action_stm)
+
+        self.terminal_menu = QMenu("Открыть Терминал", menubar)
+        
+        self.action_terminal_tms = QAction("TMS DemoTerminal", self)
+        self.action_terminal_modbus = QAction("Modbus DemoTerminal", self)
+        self.action_terminal_tms.triggered.connect(lambda: self.open_terminal("TMS"))
+        self.action_terminal_modbus.triggered.connect(lambda: self.open_terminal("MODBUS"))
+
+        self.terminal_menu.addAction(self.action_terminal_tms)
+        #self.terminal_menu.addAction(self.action_terminal_modbus)
+
+        menubar.addMenu(self.target_menu)
+        menubar.addMenu(self.terminal_menu)
+
         # Кнопка сохранения
         btn_save = QPushButton(build_title)
         btn_save.clicked.connect(self.save_build)
@@ -137,6 +178,7 @@ class VarEditor(QWidget):
         self.table = VariableTableWidget()
         # Основной layout
         layout = QVBoxLayout()
+        layout.setMenuBar(menubar)  # прикрепляем menubar в layout сверху
         layout.addLayout(xml_layout)
         layout.addLayout(proj_layout)
         layout.addLayout(makefile_layout)
@@ -149,8 +191,30 @@ class VarEditor(QWidget):
 
         self.setLayout(layout)
 
+    def open_terminal(self, target):
+        target = target.lower()
+        
+        if target == "tms":
+            self.terminal_widget = _DemoWindow()  # _DemoWindow наследует QWidget
+            self.terminal_widget.show()
+        elif target == "modbus":
+            a=1
+
+        
+    def on_target_selected(self, target):
+        self.target_menu.setTitle(f'МК: {target}')
+        self.settings.setValue("mcu_choosen", target)
+        self.target = target.lower()
+        if self.target == "stm":
+            choose_type_map(True)
+            self.action_stm.setChecked(True)
+            self.action_tms.setChecked(False)
+        else:
+            choose_type_map(False)
+            self.action_tms.setChecked(True)
+            self.action_stm.setChecked(False)
+        
 
-    
     def get_xml_path(self):
         xml_path = self.xml_output_edit.text().strip()
         return xml_path
@@ -241,7 +305,7 @@ class VarEditor(QWidget):
             return
 
         try:
-            run_generate(self.proj_path, self.xml_path, self.output_path)
+            run_generate(self.proj_path, self.xml_path, self.output_path, self.table._shortname_size)
             QMessageBox.information(self, "Готово", "Файл debug_vars.c успешно сгенерирован.")
             self.update()
         except Exception as e:
@@ -358,15 +422,25 @@ class VarEditor(QWidget):
             super().keyPressEvent(event)
 
     def __browse_makefile(self):
+        if self.target == 'stm':
+            file_filter = "Makefile или Keil-проект (*.uvprojx *.uvproj makefile);;Все файлы (*)"
+            dialog_title = "Выберите Makefile или Keil-проект"
+        else:  # 'TMS' или по умолчанию
+            file_filter = "Makefile (makefile);;Все файлы (*)"
+            dialog_title = "Выберите Makefile"
+
         file_path, _ = QFileDialog.getOpenFileName(
-            self, "Выберите Makefile", filter="Makefile (makefile);;All Files (*)"
+            self,
+            dialog_title,
+            filter=file_filter
         )
-        if file_path and self.proj_path:
+        if file_path:
-            path = myXML.make_relative_path(file_path, self.proj_path)
+            if self.proj_path:
-        else:
+                path = myXML.make_relative_path(file_path, self.proj_path)
-            path = file_path
+            else:
-        self.makefile_edit.setText(path)
+                path = file_path
-        self.makefile_path = path
+            self.makefile_edit.setText(path)
+            self.makefile_path = path
 
     def __browse_source_output(self):
         dir_path = QFileDialog.getExistingDirectory(self, "Выберите папку для debug_vars.c")
@@ -438,12 +512,12 @@ class VarEditor(QWidget):
         self.write_to_xml()
 
 
-    def __open_variable_selector(self):
+    def __open_variable_selector(self):        
+        self.update()
         if not self.vars_list:
             QMessageBox.warning(self, "Нет переменных", f"Сначала загрузите переменные ({scan_title}).")
             return
         
-        self.update()
         dlg = VariableSelectorDialog(self.table, self.vars_list, self.structs, self.typedef_map, self.xml_path, self)
         if dlg.exec_():
             self.write_to_xml()

Src/generate_debug_vars.py

@@ -12,9 +12,10 @@ from xml.dom import minidom
 import myXML
 import argparse
 
+shortnameSize = 10
 
 # === Словарь соответствия типов XML → DebugVarType_t ===
-type_map = dict([
+type_map_tms = dict([
     *[(k, 'pt_int8') for k in ('signed char', 'char')],
     *[(k, 'pt_int16') for k in ('int', 'int16', 'short')],
     *[(k, 'pt_int32') for k in ('long', 'int32', '_iqx')],
@@ -52,6 +53,150 @@ type_map = dict([
     ('struct[]', 'pt_arr_struct'),
     ('union[]', 'pt_arr_union'),
 ])
+# === Словарь соответствия типов XML → DebugVarType_t ===
+type_map_stm32 = dict([
+
+    *[(k, 'pt_int8') for k in (
+        'int8_t', 'signed char', 'char'
+    )],
+
+    # --- 8-bit unsigned ---
+    *[(k, 'pt_uint8') for k in (
+        'uint8_t', 'unsigned char'
+    )],
+
+    # --- 16-bit signed ---
+    *[(k, 'pt_int16') for k in (
+        'int16_t', 'short', 'short int', 'signed short', 'signed short int'
+    )],
+
+    # --- 16-bit unsigned ---
+    *[(k, 'pt_uint16') for k in (
+        'uint16_t', 'unsigned short', 'unsigned short int'
+    )],
+
+    # --- 32-bit signed ---
+    *[(k, 'pt_int32') for k in (
+        'int32_t', 'int', 'signed', 'signed int'
+    )],
+
+    # --- 32-bit unsigned ---
+    *[(k, 'pt_uint32') for k in (
+        'uint32_t', 'unsigned', 'unsigned int'
+    )],
+
+    # --- 64-bit signed ---
+    *[(k, 'pt_int64') for k in (
+        'int64_t', 'long long', 'signed long long', 'signed long long int'
+    )],
+
+    # --- 64-bit unsigned ---
+    *[(k, 'pt_uint64') for k in (
+        'uint64_t', 'unsigned long long', 'unsigned long long int'
+    )],
+
+    # --- Float ---
+    *[(k, 'pt_float') for k in (
+        'float', 'float32_t'
+    )],
+
+    # --- Struct and Union ---
+    ('struct', 'pt_struct'),
+    ('union', 'pt_union'),
+    ('struct*', 'pt_ptr_struct'),
+    ('union*', 'pt_ptr_union'),
+    ('struct[]', 'pt_arr_struct'),
+    ('union[]', 'pt_arr_union'),
+
+    # === POINTERS ===
+
+    # 8-bit
+    *[(k, 'pt_ptr_int8') for k in (
+        'int8_t*', 'signed char*', 'char*'
+    )],
+    *[(k, 'pt_ptr_uint8') for k in (
+        'uint8_t*', 'unsigned char*'
+    )],
+
+    # 16-bit
+    *[(k, 'pt_ptr_int16') for k in (
+        'int16_t*', 'short*', 'short int*', 'signed short*', 'signed short int*'
+    )],
+    *[(k, 'pt_ptr_uint16') for k in (
+        'uint16_t*', 'unsigned short*', 'unsigned short int*'
+    )],
+
+    # 32-bit
+    *[(k, 'pt_ptr_int32') for k in (
+        'int32_t*', 'int*', 'signed*', 'signed int*'
+    )],
+    *[(k, 'pt_ptr_uint32') for k in (
+        'uint32_t*', 'unsigned*', 'unsigned int*'
+    )],
+
+    # 64-bit
+    *[(k, 'pt_ptr_int64') for k in (
+        'int64_t*', 'long long*', 'signed long long*', 'signed long long int*'
+    )],
+    *[(k, 'pt_ptr_uint64') for k in (
+        'uint64_t*', 'unsigned long long*', 'unsigned long long int*'
+    )],
+
+    # float*
+    *[(k, 'pt_ptr_float') for k in (
+        'float*', 'float32_t*'
+    )],
+
+    # === ARRAYS ===
+
+    # 8-bit
+    *[(k, 'pt_arr_int8') for k in (
+        'int8_t[]', 'signed char[]', 'char[]'
+    )],
+    *[(k, 'pt_arr_uint8') for k in (
+        'uint8_t[]', 'unsigned char[]'
+    )],
+
+    # 16-bit
+    *[(k, 'pt_arr_int16') for k in (
+        'int16_t[]', 'short[]', 'short int[]', 'signed short[]', 'signed short int[]'
+    )],
+    *[(k, 'pt_arr_uint16') for k in (
+        'uint16_t[]', 'unsigned short[]', 'unsigned short int[]'
+    )],
+
+    # 32-bit
+    *[(k, 'pt_arr_int32') for k in (
+        'int32_t[]', 'int[]', 'signed[]', 'signed int[]'
+    )],
+    *[(k, 'pt_arr_uint32') for k in (
+        'uint32_t[]', 'unsigned[]', 'unsigned int[]'
+    )],
+
+    # 64-bit
+    *[(k, 'pt_arr_int64') for k in (
+        'int64_t[]', 'long long[]', 'signed long long[]', 'signed long long int[]'
+    )],
+    *[(k, 'pt_arr_uint64') for k in (
+        'uint64_t[]', 'unsigned long long[]', 'unsigned long long int[]'
+    )],
+
+    # float[]
+    *[(k, 'pt_arr_float') for k in (
+        'float[]', 'float32_t[]'
+    )],
+])
+type_map = type_map_tms
+stm_flag_global = 0
+def choose_type_map(stm_flag):
+    global type_map  # объявляем, что будем менять глобальную переменную
+    global stm_flag_global  # объявляем, что будем менять глобальную переменную
+    if stm_flag:
+        type_map = type_map_stm32
+        stm_flag_global = 1
+    else:
+        type_map = type_map_tms
+        stm_flag_global = 0
 
 def map_type_to_pt(typename, varname=None, typedef_map=None):
     typename_orig = typename.strip()
@@ -140,15 +285,20 @@ def add_new_vars_to_xml(proj_path, xml_rel_path, output_path):
     Возвращает True если что-то добавлено и XML перезаписан, иначе False.
     """
 
+    pattern = re.compile(
+        r'{\s*\(uint8_t\s*\*\)\s*&([a-zA-Z_][a-zA-Z0-9_]*(?:\[.*?\])?(?:(?:\.|->)[a-zA-Z_][a-zA-Z0-9_]*(?:\[.*?\])?)*)\s*,\s*'
+        r'(pt_\w+)\s*,\s*'
+        r'(t?_?iq\w+)\s*,\s*'
+        r'(t?_?iq\w+)\s*,\s*'
+        r'"([^"]+)"'
+    )
     # Считываем существующие переменные
     parsed_vars = {}
     if os.path.isfile(output_path):
         with open(output_path, 'r', encoding='utf-8', errors='ignore') as f:
             for line in f:
-                # {(char *)&some.deep.var.name , pt_uint16 , t_iq15 , "ShortName"},
+                # {(uint8_t *)&some.deep.var.name , pt_uint16 , t_iq15 , t_iq10, "ShortName"},
-                m = re.match(
+                m = pattern.search(line)
-    r'{\s*\(char\s*\*\)\s*&([a-zA-Z_][a-zA-Z0-9_]*(?:\.[a-zA-Z_][a-zA-Z0-9_]*)*)\s*,\s*(pt_\w+)\s*,\s*(t?iq_\w+)\s*,\s*"([^"]+)"',
-                line)
                 if m:
                     full_varname = m.group(1)  # e.g., some.deep.var.name
                     pt_type = m.group(2)
@@ -285,12 +435,27 @@ def read_vars_from_xml(proj_path, xml_rel_path):
     return unique_vars, include_files, vars_need_extern
 
 
+def read_file_try_encodings(filepath):
+    if not os.path.isfile(filepath):
+        # Файл не существует — просто вернуть пустую строку или None
+        return "", None
+    for enc in ['utf-8', 'cp1251']:
+        try:
+            with open(filepath, 'r', encoding=enc) as f:
+                content = f.read()
+            return content, enc
+        except UnicodeDecodeError:
+            continue
+    raise UnicodeDecodeError(f"Не удалось прочитать файл {filepath} с кодировками utf-8 и cp1251")
+
 
 
 def generate_vars_file(proj_path, xml_path, output_dir):
     output_dir = os.path.join(proj_path, output_dir)
     os.makedirs(output_dir, exist_ok=True)
     output_path = os.path.join(output_dir, 'debug_vars.c')
+    LIBC_path = os.path.join(output_dir, 'debug_tools.c')
+    LIBH_path = os.path.join(output_dir, 'debug_tools.h')
 
 
     # Запись новых переменных для в XML
@@ -338,7 +503,7 @@ def generate_vars_file(proj_path, xml_path, output_dir):
         # Дополнительные поля, например комментарий
         comment = info.get("comment", "")
         short_name = info.get("shortname", f'"{vname}"')
-        short_trimmed = short_name[:10]                  # ограничиваем длину до 10
+        short_trimmed = short_name[:shortnameSize]                  # ограничиваем длину до 10
 
         if pt_type not in ('pt_struct', 'pt_union'):
             f_name = f'{vname},'
@@ -348,7 +513,7 @@ def generate_vars_file(proj_path, xml_path, output_dir):
             f_short_name = f'"{short_trimmed}"'  # оборачиваем в кавычки
             # Добавим комментарий после записи, если он есть
             comment_str = f' // {comment}' if comment else ''
-            line = f'{{(char *)&{f_name:<57} {f_type:<15} {f_iq:<15} {f_ret_iq:<15} {f_short_name:<21}}}, \\{comment_str}'
+            line = f'{{(uint8_t *)&{f_name:<58} {f_type:<15} {f_iq:<15} {f_ret_iq:<15} {f_short_name:<21}}}, \\{comment_str}'
             new_debug_vars[vname] = line
 
         else:
@@ -394,14 +559,19 @@ def generate_vars_file(proj_path, xml_path, output_dir):
 
     out_lines.append(f'\n\n// Определение массива с указателями на переменные для отладки')
     out_lines.append(f'int DebugVar_Qnt = {len(all_debug_lines)};')
-    out_lines.append('#pragma DATA_SECTION(dbg_vars,".dbgvar_info")')
+    if stm_flag_global == 0: 
+        out_lines.append('#pragma DATA_SECTION(dbg_vars,".dbgvar_info")')
+    out_lines.append('//                                                                      pointer_type    iq_type			return_iq_type  short_name')
     out_lines.append('DebugVar_t dbg_vars[] = {\\')
     out_lines.extend(all_debug_lines)
     out_lines.append('};')
     out_lines.append('')
     # Выберем кодировку для записи файла
     # Если встречается несколько, возьмем первую из set
-    enc_to_write = 'cp1251'
+    if stm_flag_global == 0:
+        enc_to_write = 'cp1251'
+    else:
+        enc_to_write = 'utf-8'
     
     #print("== GLOBAL VARS FOUND ==")
     #for vname, (vtype, path) in vars_in_c.items():
@@ -411,6 +581,16 @@ def generate_vars_file(proj_path, xml_path, output_dir):
     with open(output_path, 'w', encoding=enc_to_write) as f:
         f.write('\n'.join(out_lines))
 
+    if os.path.isfile(LIBC_path):
+        libc_code, _ = read_file_try_encodings(LIBC_path)
+        with open(LIBC_path, 'w', encoding=enc_to_write) as f:
+            f.write(libc_code)
+        
+    if os.path.isfile(LIBH_path):
+        libh_code, _ = read_file_try_encodings(LIBH_path)
+        with open(LIBH_path, 'w', encoding=enc_to_write) as f:
+            f.write(libh_code)
+
     print(f'Файл debug_vars.c сгенерирован в кодировке, переменных: {len(all_debug_lines)}')
 
 
@@ -472,16 +652,17 @@ Usage example:
         print(f"Error: Project path '{proj_path}' не является директорией или не существует.")
         sys.exit(1)
 
-    generate_vars_file(proj_path, xml_path_rel, output_dir_rel)
+    generate_vars_file(proj_path, xml_path_rel, output_dir_rel, 0)
 
 
 
 if __name__ == "__main__":
     main()
 
-def run_generate(proj_path, xml_path, output_dir):
+def run_generate(proj_path, xml_path, output_dir, shortname_size):
     import os
-
+    global shortnameSize
+    shortnameSize = shortname_size
     # Normalize absolute paths
     proj_path = os.path.abspath(proj_path)
     xml_path_abs = os.path.abspath(xml_path)

Src/makefile_parser.py

@@ -1,5 +1,6 @@
 import os
 import re
+from lxml import etree as ET
 
 
 def strip_single_line_comments(code):
@@ -66,89 +67,176 @@ def find_all_includes_recursive(c_files, include_dirs, processed_files=None):
     return include_files
 
 
+def parse_objects_list(objects_list_path, project_root):
+    c_files = []
+    include_dirs = set()
+
+    if not os.path.isfile(objects_list_path):
+        return c_files, include_dirs
+
+    with open(objects_list_path, 'r', encoding='utf-8') as f:
+        lines = f.readlines()
+
+    for line in lines:
+        line = line.strip().strip('"').replace("\\", "/")
+        if line.endswith(".o"):
+            c_file = re.sub(r"\.o$", ".c", line)
+            abs_path = os.path.normpath(os.path.join(project_root, c_file))
+            if os.path.isfile(abs_path):
+                if not any(x in abs_path for x in ["DebugTools", "v120", "v100"]):
+                    c_files.append(abs_path)
+                    include_dirs.add(os.path.dirname(abs_path))
+
+    return c_files, include_dirs
+
+
+def parse_uvprojx(uvprojx_path):
+    import xml.etree.ElementTree as ET
+    import os
+
+    tree = ET.parse(uvprojx_path)
+    root = tree.getroot()
+
+    project_dir = os.path.dirname(os.path.abspath(uvprojx_path))
+
+    c_files = []
+    include_dirs = set()
+    defines = set()
+
+    # Найдём C-файлы и директории
+    for file_elem in root.findall(".//FilePath"):
+        file_path = file_elem.text
+        if file_path:
+            abs_path = os.path.normpath(os.path.join(project_dir, file_path))
+            if os.path.isfile(abs_path):
+                if abs_path.endswith(".c"):
+                    c_files.append(abs_path)
+                    include_dirs.add(os.path.dirname(abs_path))
+
+    # Включаем IncludePath
+    for inc_path_elem in root.findall(".//IncludePath"):
+        path_text = inc_path_elem.text
+        if path_text:
+            paths = path_text.split(';')
+            for p in paths:
+                p = p.strip()
+                if p:
+                    abs_inc_path = os.path.normpath(os.path.join(project_dir, p))
+                    if os.path.isdir(abs_inc_path):
+                        include_dirs.add(abs_inc_path)
+
+    # Добавим <Define>
+    for define_elem in root.findall(".//Define"):
+        def_text = define_elem.text
+        if def_text:
+            for d in def_text.split(','):
+                d = d.strip()
+                if d:
+                    defines.add(d)
+
+    h_files = find_all_includes_recursive(c_files, include_dirs)
+
+    return sorted(c_files), sorted(h_files), sorted(include_dirs), sorted(defines)
+
+
+
 def parse_makefile(makefile_path, proj_path):
-    makefile_dir = os.path.dirname(makefile_path)
+    import os
-    project_root = proj_path
+    import re
+
+    project_root = os.path.abspath(proj_path)
+    c_files = []
+    include_dirs = set()
+    defines = []  # Заглушка: нет define-параметров из Makefile
 
     with open(makefile_path, 'r', encoding='utf-8') as f:
         lines = f.readlines()
 
-    objs_lines = []
+    raw_entries = []
     collecting = False
 
     for line in lines:
         stripped = line.strip()
-        if stripped.startswith("ORDERED_OBJS") and "+=" in stripped:
+
-            parts = stripped.split("\\")
+        if (("ORDERED_OBJS" in stripped or "C_SOURCES" in stripped) and ("+=" in stripped or "=" in stripped)):
-            first_part = parts[0]
-            idx = first_part.find("+=")
-            tail = first_part[idx+2:].strip()
-            if tail:
-                objs_lines.append(tail)
             collecting = True
-            if len(parts) > 1:
-                for p in parts[1:]:
-                    p = p.strip()
-                    if p:
-                        objs_lines.append(p)
-            continue
 
         if collecting:
-            if stripped.endswith("\\"):
+            line_clean = stripped.rstrip("\\").strip()
-                objs_lines.append(stripped[:-1].strip())
+            if line_clean:
-            else:
+                line_clean = re.sub(r"\$\([^)]+\)", "", line_clean)
-                objs_lines.append(stripped)
+                line_clean = re.sub(r"\$\{[^}]+\}", "", line_clean)
+                raw_entries.append(line_clean)
+
+            if not stripped.endswith("\\"):
                 collecting = False
 
-    objs_str = ' '.join(objs_lines)
+    for entry in raw_entries:
+        for token in entry.split():
+            token = token.strip('"')
+            if not token:
+                continue
 
-    objs_str = re.sub(r"\$\([^)]+\)", "", objs_str)
+            token = token.replace("\\", "/")
 
-    objs = []
+            if token.endswith(".obj"):
-    for part in objs_str.split():
+                token = re.sub(r"\.obj$", ".c", token)
-        part = part.strip()
+            elif token.endswith(".o"):
-        if part.startswith('"') and part.endswith('"'):
+                token = re.sub(r"\.o$", ".c", token)
-            part = part[1:-1]
-        if part:
-            objs.append(part)
 
-    c_files = []
+            if token.endswith(".c"):
-    include_dirs = set()
+                abs_path = os.path.normpath(os.path.join(project_root, token))
+                if os.path.isfile(abs_path):
+                    if not any(x in abs_path for x in ["DebugTools", "v120", "v100"]):
+                        c_files.append(abs_path)
+                        include_dirs.add(os.path.dirname(abs_path))
 
-    for obj_path in objs:
+    if not c_files:
-        if "DebugTools" in obj_path:
+        makefile_dir = os.path.dirname(os.path.abspath(makefile_path))
-            continue
+        objects_list_path = os.path.join(makefile_dir, "objects.list")
-        if "v120" in obj_path:
+        c_from_objects, inc_from_objects = parse_objects_list(objects_list_path, project_root)
-            continue
+        c_files.extend(c_from_objects)
-        if "v100" in obj_path:
+        include_dirs.update(inc_from_objects)
-            continue
 
-        if obj_path.startswith("Debug\\") or obj_path.startswith("Debug/"):
+    for line in lines:
-            rel_path = obj_path.replace("Debug\\", "Src\\").replace("Debug/", "Src/")
+        if "-I" in line or "C_INCLUDES" in line:
-        else:
+            matches = re.findall(r"-I\s*([^\s\\]+)", line)
-            rel_path = obj_path
+            for match in matches:
+                match = match.strip('"').replace("\\", "/")
+                abs_include = os.path.normpath(os.path.join(project_root, match))
+                if os.path.isdir(abs_include):
+                    include_dirs.add(abs_include)
 
-        abs_path = os.path.normpath(os.path.join(project_root, rel_path))
+    # Добавляем пути с заменой 'Src' на 'Inc', если путь заканчивается на 'Src'
-
+    additional_includes = set()
-        root, ext = os.path.splitext(abs_path)
+    for inc in include_dirs:
-        if ext.lower() == ".obj":
+        if inc.endswith(os.sep + "Src") or inc.endswith("/Src"):
-            c_path = root + ".c"
+            inc_inc = inc[:-3] + "Inc"  # заменяем 'Src' на 'Inc'
-        else:
+            if os.path.isdir(inc_inc):
-            c_path = abs_path
+                additional_includes.add(inc_inc)
-
-        # Проверяем существование файла, если нет — пропускаем
-        if not os.path.isfile(c_path):
-            continue
-
-        # Сохраняем только .c файлы
-        if c_path.lower().endswith(".c"):
-            c_files.append(c_path)
-            dir_path = os.path.dirname(c_path)
-            if dir_path and "DebugTools" not in dir_path:
-                include_dirs.add(dir_path)
 
+    include_dirs.update(additional_includes)
 
     h_files = find_all_includes_recursive(c_files, include_dirs)
 
+    return sorted(c_files), sorted(h_files), sorted(include_dirs), sorted(defines)
 
-    return sorted(c_files), sorted(h_files), sorted(include_dirs)
+
+def parse_project(project_file_path, project_root=None):
+    """
+    Выбирает парсер в зависимости от расширения project_file_path:
+    - для *.uvprojx и *.uvproj вызывается парсер Keil
+    - для остальных - parse_makefile
+
+    project_root нужен для parse_makefile, если не передан - берется из project_file_path
+    """
+    ext = os.path.splitext(project_file_path)[1].lower()
+
+    if ext in ['.uvprojx', '.uvproj']:
+        # Парсим Keil проект
+        return parse_uvprojx(project_file_path)
+    else:
+        # Парсим makefile
+        if project_root is None:
+            project_root = os.path.dirname(os.path.abspath(project_file_path))
+        return parse_makefile(project_file_path, project_root)

Src/path_hints.py

@@ -0,0 +1,252 @@
+# path_hints.py
+from __future__ import annotations
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Tuple
+
+import re
+
+
+# ---------------------- tokenization helpers ----------------------
+
+def split_path_tokens(path: str) -> List[str]:
+    """
+    Разбивает строку пути на логические части:
+      'foo[2].bar[1]->baz' -> ['foo', '[2]', 'bar', '[1]', 'baz']
+    Аналог твоей split_path(), но оставлена как чистая функция.
+    """
+    tokens: List[str] = []
+    token = ''
+    i = 0
+    L = len(path)
+    while i < L:
+        c = path[i]
+        # '->'
+        if c == '-' and i + 1 < L and path[i:i+2] == '->':
+            if token:
+                tokens.append(token)
+                token = ''
+            i += 2
+            continue
+        # одиночный '-' в конце
+        if c == '-' and i == L - 1:
+            i += 1
+            continue
+        # '.'
+        if c == '.':
+            if token:
+                tokens.append(token)
+                token = ''
+            i += 1
+            continue
+        # '[' ... ']'
+        if c == '[':
+            if token:
+                tokens.append(token)
+                token = ''
+            idx = ''
+            while i < L and path[i] != ']':
+                idx += path[i]
+                i += 1
+            if i < L and path[i] == ']':
+                idx += ']'
+                i += 1
+            tokens.append(idx)
+            continue
+        # обычный символ
+        token += c
+        i += 1
+    if token:
+        tokens.append(token)
+    return tokens
+
+
+def canonical_key(path: str) -> str:
+    """
+    Преобразует путь к канонической форме для индекса / поиска:
+      - '->' -> '.'
+      - '[' -> '.['
+      - lower()
+    """
+    p = path.replace('->', '.')
+    p = p.replace('[', '.[')
+    return p.lower()
+
+
+# ---------------------- индекс узлов ----------------------
+
+@dataclass
+class PathNode:
+    """
+    Узел в логическом дереве путей.
+    Храним:
+      - собственное имя (локальное, напр. 'controller' или '[3]')
+      - полный путь (оригинальный, как его должен видеть пользователь)
+      - тип (опционально; widget может хранить отдельно)
+      - дети
+    """
+    name: str
+    full_path: str
+    type_str: str = ''
+    children: Dict[str, "PathNode"] = field(default_factory=dict)
+
+    def add_child(self, child: "PathNode") -> None:
+        self.children[child.name] = child
+
+
+class PathHints:
+    """
+    Движок автоподсказок / completion.
+    Работает с плоским списком ПОЛНЫХ имён (как показываются пользователю).
+    Сам восстанавливает иерархию и выдаёт подсказки по текущему вводу.
+    Qt-независим.
+    """
+
+    def __init__(self) -> None:
+        self._paths: List[str] = []
+        self._types: Dict[str, str] = {}          # full_path -> type_str (опционально)
+        self._index: Dict[str, PathNode] = {}     # canonical full path -> node
+        self._root_children: Dict[str, PathNode] = {}  # top-level по первому токену
+
+    # ------------ Подаём данные ------------
+    def set_paths(self,
+                  paths: List[Tuple[str, Optional[str]]]
+                  ) -> None:
+        """
+        paths: список кортежей (full_path, type_str|None).
+        Пример: ('project.controller.read.errors.bit.status_er0', 'unsigned int')
+        Поля могут содержать '->' и индексы, т.е. строки в пользовательском формате.
+
+        NOTE: порядок не важен; дерево строится автоматически.
+        """
+        self._paths = []
+        self._types.clear()
+        self._index.clear()
+        self._root_children.clear()
+
+        for p, t in paths:
+            if t is None:
+                t = ''
+            self._add_path(p, t)
+
+    def _add_path(self, full_path: str, type_str: str) -> None:
+        self._paths.append(full_path)
+        self._types[full_path] = type_str
+
+        toks = split_path_tokens(full_path)
+        if not toks:
+            return
+
+        cur_dict = self._root_children
+        cur_full = ''
+        parent_node: Optional[PathNode] = None
+
+        for i, tok in enumerate(toks):
+            # Собираем ПОЛНЫЙ путь
+            if cur_full == '':
+                cur_full = tok
+            else:
+                if tok.startswith('['):
+                    cur_full += tok
+                else:
+                    cur_full += '.' + tok
+
+            # Если узел уже есть
+            node = cur_dict.get(tok)
+            if node is None:
+                # --- ВАЖНО: full_path = cur_full ---
+                node = PathNode(name=tok, full_path=cur_full)
+                cur_dict[tok] = node
+
+            # Регистрируем все узлы, включая промежуточные
+            self._index[canonical_key(cur_full)] = node
+
+            parent_node = node
+            cur_dict = node.children
+
+        # В последний узел добавляем тип
+        if parent_node:
+            parent_node.type_str = type_str
+
+
+    # ------------ Поиск узла ------------
+
+    def find_node(self, path: str) -> Optional[PathNode]:
+        return self._index.get(canonical_key(path))
+
+    # ------------ Подсказки ------------
+
+    def suggest(self,
+                text: str,
+                *,
+                include_partial: bool = True
+                ) -> List[str]:
+        """
+        Вернёт список *полных имён узлов*, подходящих под ввод.
+        Правила (упрощённо, повторяя твою update_completions()):
+          - Если текст пуст → top-level.
+          - Если заканчивается на '.' или '->' или '[' → вернуть детей текущего узла.
+          - Иначе → фильтр по последнему фрагменту (prefix substring match).
+        """
+        text = text or ''
+        stripped = text.strip()
+
+        # пусто: top-level
+        if stripped == '':
+            return sorted(self._root_full_names())
+
+        # Завершение по разделителю?
+        if stripped.endswith('.') or stripped.endswith('->') or stripped.endswith('['):
+            base = stripped[:-1] if stripped.endswith('[') else stripped.rstrip('.').rstrip('>').rstrip('-')
+            node = self.find_node(base)
+            if node:
+                return self._children_full_names(node)
+            # не нашли базу — ничего
+            return []
+
+        # иначе: обычный поиск по последней части
+        toks = split_path_tokens(stripped)
+        prefix_last = toks[-1].lower() if toks else ''
+        parent_toks = toks[:-1]
+
+        if not parent_toks:
+            # фильтр top-level
+            res = []
+            for name, node in self._root_children.items():
+                if prefix_last == '' or prefix_last in name.lower():
+                    res.append(node.full_path)
+            return sorted(res)
+
+        # есть родитель
+        parent_path = self._join_tokens(parent_toks)
+        parent_node = self.find_node(parent_path)
+        if not parent_node:
+            return []
+        res = []
+        for child in parent_node.children.values():
+            if prefix_last == '' or prefix_last in child.name.lower():
+                res.append(child.full_path)
+        return sorted(res)
+
+    # ------------ внутренние вспомогательные ------------
+
+    def _root_full_names(self) -> List[str]:
+        return [node.full_path for node in self._root_children.values()]
+
+    def _children_full_names(self, node: PathNode) -> List[str]:
+        return [ch.full_path for ch in node.children.values()]
+
+    @staticmethod
+    def _join_tokens(tokens: List[str]) -> str:
+        """
+        Собираем путь обратно. Для внутренних нужд (поиск), формат не критичен —
+        всё равно canonical_key() нормализует.
+        """
+        if not tokens:
+            return ''
+        out = tokens[0]
+        for t in tokens[1:]:
+            if t.startswith('['):
+                out += t
+            else:
+                out += '.' + t
+        return out

Src/scan_vars.py

@@ -11,7 +11,7 @@ from clang import cindex
 from clang.cindex import Config
 import lxml.etree as ET
 from xml.dom import minidom
-from makefile_parser import parse_makefile
+from makefile_parser import parse_project
 from collections import deque
 import argparse
 import myXML
@@ -118,11 +118,11 @@ def get_canonical_typedef_file(var_type, include_dirs):
         break
     return None
 
-def analyze_variables_across_files(c_files, h_files, include_dirs):
+def analyze_variables_across_files(c_files, h_files, include_dirs, global_defs):
     optional_printf(PRINT_STATUS, "Starting analysis of variables across files...")
     index = clang.cindex.Index.create()
-    args = [f"-I{inc}" for inc in include_dirs]
+    define_args = [f"-D{d}" for d in global_defs]
-
+    args = [f"-I{inc}" for inc in include_dirs] + define_args
     unique_vars = {}            # имя переменной → словарь с инфой
     h_files_needed = set()
     vars_need_extern = {}       # имя переменной → словарь без поля 'extern'
@@ -154,6 +154,7 @@ def analyze_variables_across_files(c_files, h_files, include_dirs):
                 # Проверяем, начинается ли имя с "_" и содержит заглавные буквы или служебные символы
                 return bool(re.match(r"^_[_A-Z]", var_name))
             
+
             if node.kind == clang.cindex.CursorKind.VAR_DECL:
                 if node.semantic_parent.kind == clang.cindex.CursorKind.TRANSLATION_UNIT:
                     is_extern = (node.storage_class == clang.cindex.StorageClass.EXTERN)
@@ -170,7 +171,12 @@ def analyze_variables_across_files(c_files, h_files, include_dirs):
                         return  # игнорируем только явно известные служебные переменные
                     if node.spelling == 'HUGE': # еще одна служеюная, которую хз как выделять
                         return
+                    
+                    if 'Drivers' in node.location.file.name:
+                        return
 
+                    if 'uint' in node.spelling:
+                        a = 1
                     # Проверяем, является ли тип указателем на функцию
                     # Признак: в типе есть '(' и ')' и '*', например: "void (*)(int)"
                     if "(" in var_type and "*" in var_type and ")" in var_type:
@@ -295,6 +301,8 @@ def strip_ptr_and_array(typename):
 
     return typename
 
+
+
 def analyze_typedefs_and_struct(typedefs, structs):
     optional_printf(PRINT_STATUS, "Resolving typedefs and expanding struct field types...")
 
@@ -422,10 +430,28 @@ def contains_anywhere_in_node(node, target: str) -> bool:
     return False
 
 
-def analyze_typedefs_and_structs_across_files(c_files, include_dirs):
+
+def try_guess_std_include():
+    # Популярные места, где может лежать stdint.h
+    guesses = [
+        r"C:\Keil_v5\ARM\ARMCLANG\include",
+        r"C:\Program Files (x86)\GNU Arm Embedded Toolchain",
+        r"C:\Program Files (x86)\Arm GNU Toolchain"
+    ]
+
+    found = []
+    for base in guesses:
+        for root, dirs, files in os.walk(base):
+            if "stdint.h" in files:
+                found.append(root)
+    return found
+
+def analyze_typedefs_and_structs_across_files(c_files, include_dirs, global_defs):
     optional_printf(PRINT_STATUS, "Starting analysis of typedefs and structs across files...")
     index = clang.cindex.Index.create()
-    args = [f"-I{inc}" for inc in include_dirs]
+    define_args = [f"-D{d}" for d in global_defs]
+    extra_std_include_dirs = try_guess_std_include()
+    args = [f"-I{inc}" for inc in include_dirs] + extra_std_include_dirs + define_args
 
     unique_typedefs_raw = {}
     unique_structs_raw = {}
@@ -452,7 +478,6 @@ def analyze_typedefs_and_structs_across_files(c_files, include_dirs):
 
                 raw_name = node.spelling
                 normalized_name = normalize_type_name(raw_name)
-
                 # struct_name всегда с префиксом
                 if node.spelling and "unnamed" not in normalized_name:
                     struct_name = f"{prefix}{normalized_name}"
@@ -855,10 +880,10 @@ Usage example:
         print(f"Error: Makefile path '{makefile_path}' does not exist.")
         sys.exit(1)
 
-    c_files, h_files, include_dirs = parse_makefile(makefile_path, proj_path)
+    c_files, h_files, include_dirs, global_defs = parse_project(makefile_path, proj_path)
 
-    vars, includes, externs = analyze_variables_across_files(c_files, h_files, include_dirs)
+    vars, includes, externs = analyze_variables_across_files(c_files, h_files, include_dirs, global_defs)
-    typedefs, structs = analyze_typedefs_and_structs_across_files(c_files, include_dirs)
+    typedefs, structs = analyze_typedefs_and_structs_across_files(c_files, include_dirs, global_defs)
 
     vars = dict(sorted(vars.items()))
     includes = get_sorted_headers(c_files, includes, include_dirs)
@@ -898,10 +923,10 @@ def run_scan(proj_path, makefile_path, output_xml, verbose=2):
     if not os.path.isfile(makefile_path):
         raise FileNotFoundError(f"Makefile path '{makefile_path}' does not exist.")
 
-    c_files, h_files, include_dirs = parse_makefile(makefile_path, proj_path)
+    c_files, h_files, include_dirs, global_defs = parse_project(makefile_path, proj_path)
 
-    vars, includes, externs = analyze_variables_across_files(c_files, h_files, include_dirs)
+    vars, includes, externs = analyze_variables_across_files(c_files, h_files, include_dirs, global_defs)
-    typedefs, structs = analyze_typedefs_and_structs_across_files(c_files, include_dirs)
+    typedefs, structs = analyze_typedefs_and_structs_across_files(c_files, include_dirs, global_defs)
 
     vars = dict(sorted(vars.items()))
     includes = get_sorted_headers(c_files, includes, include_dirs)

Src/tms_debugvar_lowlevel.py

@@ -0,0 +1,739 @@
+"""
+LowLevelSelectorWidget (PySide2)
+--------------------------------
+Виджет для:
+  * Выбора XML файла с описанием переменных (как в примере пользователя)
+  * Парсинга всех <variable> и их вложенных <member>
+  * Построения плоского списка путей (имя/подпуть) с расчётом абсолютного адреса (base_address + offset)
+  * Определения структур с полями даты (year, month, day, hour, minute)
+  * Выбора переменной и (опционально) переменной даты / ручного ввода даты
+  * Выбора типов: ptr_type (pt_*), iq_type, return_type
+  * Форматирования адреса в виде 0x000000 (6 HEX)
+  * Генерации словаря/кадра для последующей LowLevel-команды (не отправляет сам)
+
+Интеграция:
+  * Подключите сигнал variablePrepared(dict) к функции, формирующей и отправляющей пакет.
+  * Содержимое dict:
+        {
+            'address': int,
+            'address_hex': str,    # '0x....'
+            'ptr_type': int,       # значение enum pt_*
+            'iq_type': int,
+            'return_type': int,
+            'datetime': {
+                'year': int,
+                'month': int,
+                'day': int,
+                'hour': int,
+                'minute': int,
+            },
+            'path': str,           # полный путь переменной
+            'type_string': str,    # строка типа из XML
+        }
+
+Зависимости: только PySide2 и стандартная библиотека.
+"""
+from __future__ import annotations
+import sys
+import xml.etree.ElementTree as ET
+from dataclasses import dataclass, field
+from typing import List, Dict, Optional, Tuple
+from PySide2 import QtCore, QtGui, QtWidgets
+from path_hints import PathHints
+
+# ------------------------------------------------------------ Enumerations --
+# Сопоставление строк из XML типу ptr_type (адаптируйте под реальный проект)
+PTR_TYPE_MAP = {
+    'int8': 'pt_int8', 'signed char': 'pt_int8', 'char': 'pt_int8',
+    'int16': 'pt_int16', 'short': 'pt_int16', 'int': 'pt_int16',
+    'int32': 'pt_int32', 'long': 'pt_int32',
+    'int64': 'pt_int64', 'long long': 'pt_int64',
+    'uint8': 'pt_uint8', 'unsigned char': 'pt_uint8',
+    'uint16': 'pt_uint16', 'unsigned short': 'pt_uint16', 'unsigned int': 'pt_uint16',
+    'uint32': 'pt_uint32', 'unsigned long': 'pt_uint32',
+    'uint64': 'pt_uint64', 'unsigned long long': 'pt_uint64',
+    'float': 'pt_float', 'floatf': 'pt_float',
+    'struct': 'pt_struct', 'union': 'pt_union',
+}
+
+PT_ENUM_ORDER = [
+    'pt_unknown','pt_int8','pt_int16','pt_int32','pt_int64',
+    'pt_uint8','pt_uint16','pt_uint32','pt_uint64','pt_float',
+    'pt_struct','pt_union'
+]
+
+IQ_ENUM_ORDER = [
+    't_iq_none','t_iq','t_iq1','t_iq2','t_iq3','t_iq4','t_iq5','t_iq6',
+    't_iq7','t_iq8','t_iq9','t_iq10','t_iq11','t_iq12','t_iq13','t_iq14',
+    't_iq15','t_iq16','t_iq17','t_iq18','t_iq19','t_iq20','t_iq21','t_iq22',
+    't_iq23','t_iq24','t_iq25','t_iq26','t_iq27','t_iq28','t_iq29','t_iq30'
+]
+
+# Для примера: маппинг имени enum -> числовое значение (индекс по порядку)
+PT_ENUM_VALUE = {name: idx for idx, name in enumerate(PT_ENUM_ORDER)}
+IQ_ENUM_VALUE = {name: idx for idx, name in enumerate(IQ_ENUM_ORDER)}
+
+# -------------------------------------------------------------- Data types --
+DATE_FIELD_SET = {'year','month','day','hour','minute'}
+
+@dataclass
+class MemberNode:
+    name: str
+    offset: int = 0
+    type_str: str = ''
+    size: Optional[int] = None
+    children: List['MemberNode'] = field(default_factory=list)
+    # --- новые, но необязательные (совместимость) ---
+    kind: Optional[str] = None          # 'array', 'union', ...
+    count: Optional[int] = None         # size1 (число элементов в массиве)
+
+    def is_date_struct(self) -> bool:
+        if not self.children:
+            return False
+        child_names = {c.name for c in self.children}
+        return DATE_FIELD_SET.issubset(child_names)
+
+
+@dataclass
+class VariableNode:
+    name: str
+    address: int
+    type_str: str
+    size: Optional[int]
+    members: List[MemberNode] = field(default_factory=list)
+    # --- новые, но необязательные ---
+    kind: Optional[str] = None          # 'array'
+    count: Optional[int] = None         # size1
+
+    def base_address_hex(self) -> str:
+        return f"0x{self.address:06X}"
+
+
+# --------------------------- XML Parser ----------------------------
+
+class VariablesXML:
+    """
+    Читает твой XML и выдаёт плоский список путей:
+      - Массивы -> name[i], многоуровневые -> name[i][j]
+      - Указатель на структуру -> дети через '->'
+      - Обычная структура -> дети через '.'
+    """
+    # предположительные размеры примитивов (под STM/MCU: int=2)
+    _PRIM_SIZE = {
+        'char':1, 'signed char':1, 'unsigned char':1, 'uint8_t':1, 'int8_t':1,
+        'short':2, 'short int':2, 'signed short':2, 'unsigned short':2,
+        'uint16_t':2, 'int16_t':2,
+        'int':2, 'signed int':2, 'unsigned int':2,
+        'long':4, 'unsigned long':4, 'int32_t':4, 'uint32_t':4,
+        'float':4,
+        'long long':8, 'unsigned long long':8, 'int64_t':8, 'uint64_t':8, 'double':8,
+    }
+
+    def __init__(self, path: str):
+        self.path = path
+        self.timestamp: str = ''
+        self.variables: List[VariableNode] = []
+        self._parse()
+
+    # ------------------ low helpers ------------------
+
+    @staticmethod
+    def _parse_int_guess(txt: Optional[str]) -> Optional[int]:
+        if not txt:
+            return None
+        txt = txt.strip()
+        if txt.startswith(('0x','0X')):
+            return int(txt, 16)
+        # если в строке есть буквы A-F → возможно hex
+        if any(c in 'abcdefABCDEF' for c in txt):
+            try:
+                return int(txt, 16)
+            except ValueError:
+                pass
+        try:
+            return int(txt, 10)
+        except ValueError:
+            return None
+
+    @staticmethod
+    def _is_pointer_to_struct(t: str) -> bool:
+        if not t:
+            return False
+        low = t.replace('\t',' ').replace('\n',' ')
+        return 'struct ' in low and '*' in low
+
+    @staticmethod
+    def _is_struct_or_union(t: str) -> bool:
+        if not t:
+            return False
+        low = t.strip()
+        return low.startswith('struct ') or low.startswith('union ')
+
+    @staticmethod
+    def _strip_array_suffix(t: str) -> str:
+        return t[:-2].strip() if t.endswith('[]') else t
+
+    def _guess_primitive_size(self, type_str: str) -> Optional[int]:
+        if not type_str:
+            return None
+        base = type_str
+        for tok in ('volatile','const'):
+            base = base.replace(tok, '')
+        base = base.replace('*',' ')
+        base = base.replace('[',' ').replace(']',' ')
+        base = ' '.join(base.split()).strip()
+        return self._PRIM_SIZE.get(base)
+
+    # ------------------ XML read ------------------
+
+    def _parse(self):
+        tree = ET.parse(self.path)
+        root = tree.getroot()
+
+        ts = root.find('timestamp')
+        self.timestamp = ts.text.strip() if ts is not None and ts.text else ''
+
+        def parse_member(elem) -> MemberNode:
+            name = elem.get('name','')
+            offset = int(elem.get('offset','0'),16) if elem.get('offset') else 0
+            t = elem.get('type','') or ''
+            size_attr = elem.get('size')
+            size = int(size_attr,16) if size_attr else None
+            kind = elem.get('kind')
+            size1_attr = elem.get('size1')
+            count = None
+            if size1_attr:
+                count = self._parse_int_guess(size1_attr)
+            node = MemberNode(name=name, offset=offset, type_str=t, size=size,
+                              kind=kind, count=count)
+            for ch in elem.findall('member'):
+                node.children.append(parse_member(ch))
+            return node
+
+        for var in root.findall('variable'):
+            addr = int(var.get('address','0'),16)
+            name = var.get('name','')
+            t = var.get('type','') or ''
+            size_attr = var.get('size')
+            size = int(size_attr,16) if size_attr else None
+            kind = var.get('kind')
+            size1_attr = var.get('size1')
+            count = None
+            if size1_attr:
+                count = self._parse_int_guess(size1_attr)
+            members = [parse_member(m) for m in var.findall('member')]
+            self.variables.append(
+                VariableNode(name=name, address=addr, type_str=t, size=size,
+                             members=members, kind=kind, count=count)
+            )
+
+    # ------------------ flatten (expanded) ------------------
+
+    def flattened(self,
+                  max_array_elems: Optional[int] = None
+                  ) -> List[Tuple[str,int,str]]:
+        """
+        Вернёт [(path, addr, type_str), ...].
+        max_array_elems: ограничить разворачивание больших массивов (None = все).
+        """
+        out: List[Tuple[str,int,str]] = []
+
+        def add(path: str, addr: int, t: str):
+            out.append((path, addr, t))
+
+        def compute_stride(size_bytes: Optional[int],
+                           count: Optional[int],
+                           base_type: Optional[str],
+                           node_children: Optional[List[MemberNode]]) -> int:
+            # 1) пробуем size/count
+            if size_bytes and count and count > 0:
+                stride = size_bytes // count
+                if stride * count != size_bytes:
+                    # округлённо вверх
+                    stride = (size_bytes + count - 1) // count
+                if stride <= 0:
+                    stride = 1
+                return stride
+            # 2) размер примитива по типу
+            if base_type:
+                gs = self._guess_primitive_size(base_type)
+                if gs:
+                    return gs
+            # 3) попытка по детям (структура)
+            if node_children:
+                min_off = min(ch.offset for ch in node_children)
+                max_end = min_off
+                for ch in node_children:
+                    sz = ch.size
+                    if not sz:
+                        sz = self._guess_primitive_size(ch.type_str) or 1
+                    end = ch.offset + sz
+                    if end > max_end:
+                        max_end = end
+                stride = max_end - min_off
+                if stride > 0:
+                    return stride
+            return 1
+
+        def expand_members(prefix_name: str,
+                           base_addr: int,
+                           members: List[MemberNode],
+                           parent_is_ptr_struct: bool):
+            """
+            Разворачиваем список members относительно базового адреса.
+            parent_is_ptr_struct: если True, то соединение '->' иначе '.'
+            """
+            join = '->' if parent_is_ptr_struct else '.'
+            for m in members:
+                path_m = f"{prefix_name}{join}{m.name}" if prefix_name else m.name
+                addr_m = base_addr + m.offset
+                add(path_m, addr_m, m.type_str)
+
+                # массив?
+                if (m.kind == 'array') or m.type_str.endswith('[]'):
+                    count = m.count
+                    if count is None:
+                        count = 0  # неизвестно → не разворачиваем
+                    if count <= 0:
+                        continue
+                    base_t = self._strip_array_suffix(m.type_str)
+                    stride = compute_stride(m.size, count, base_t, m.children if m.children else None)
+                    limit = count if max_array_elems is None else min(count, max_array_elems)
+                    for i in range(limit):
+                        path_i = f"{path_m}[{i}]"
+                        addr_i = addr_m + i*stride
+                        add(path_i, addr_i, base_t)
+                        # элемент массива: если структура / union → раскроем поля
+                        if m.children and self._is_struct_or_union(base_t):
+                            expand_members(path_i, addr_i, m.children, parent_is_ptr_struct=False)
+                        # элемент массива: если указатель на структуру
+                        elif self._is_pointer_to_struct(base_t):
+                            # у таких обычно нет children в XML, но если есть — используем
+                            expand_members(path_i, addr_i, m.children, parent_is_ptr_struct=True)
+                    continue
+
+                # не массив
+                if m.children:
+                    is_ptr_struct = self._is_pointer_to_struct(m.type_str)
+                    expand_members(path_m, addr_m, m.children, parent_is_ptr_struct=is_ptr_struct)
+
+        # --- top-level ---
+        for v in self.variables:
+            add(v.name, v.address, v.type_str)
+
+            # top-level массив?
+            if (v.kind == 'array') or v.type_str.endswith('[]'):
+                count = v.count
+                if count is None:
+                    count = 0
+                if count > 0:
+                    base_t = self._strip_array_suffix(v.type_str)
+                    stride = compute_stride(v.size, count, base_t, v.members if v.members else None)
+                    limit = count if max_array_elems is None else min(count, max_array_elems)
+                    for i in range(limit):
+                        p = f"{v.name}[{i}]"
+                        a = v.address + i*stride
+                        add(p, a, base_t)
+                        # массив структур?
+                        if v.members and self._is_struct_or_union(base_t):
+                            expand_members(p, a, v.members, parent_is_ptr_struct=False)
+                        # массив указателей на структуры?
+                        elif self._is_pointer_to_struct(base_t):
+                            expand_members(p, a, v.members, parent_is_ptr_struct=True)
+                continue  # к след. переменной
+
+            # top-level не массив
+            if v.members:
+                is_ptr_struct = self._is_pointer_to_struct(v.type_str)
+                expand_members(v.name, v.address, v.members, parent_is_ptr_struct=is_ptr_struct)
+
+        return out
+
+    # -------------------- date candidates (как было) --------------------
+
+    def date_struct_candidates(self) -> List[Tuple[str,int]]:
+        cands = []
+        for v in self.variables:
+            # верхний уровень (если есть все поля даты)
+            direct_names = {mm.name for mm in v.members}
+            if DATE_FIELD_SET.issubset(direct_names):
+                cands.append((v.name, v.address))
+            # проверка членов первого уровня
+            for m in v.members:
+                if m.is_date_struct():
+                    cands.append((f"{v.name}.{m.name}", v.address + m.offset))
+        return cands
+    
+    
+# ------------------------------------------- Address / validation helpers --
+HEX_ADDR_MASK = QtCore.QRegExp(r"0x[0-9A-Fa-f]{0,6}")
+class HexAddrValidator(QtGui.QRegExpValidator):
+    def __init__(self, parent=None):
+        super().__init__(HEX_ADDR_MASK, parent)
+
+    @staticmethod
+    def normalize(text: str) -> str:
+        if not text:
+            return '0x000000'
+        try:
+            val = int(text,16)
+        except ValueError:
+            return '0x000000'
+        return f"0x{val & 0xFFFFFF:06X}"
+
+# --------------------------------------------------------- Main Widget ----
+class LowLevelSelectorWidget(QtWidgets.QWidget):
+    variablePrepared = QtCore.Signal(dict)
+    xmlLoaded = QtCore.Signal(str)
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setWindowTitle('LowLevel Variable Selector')
+        self._xml: Optional[VariablesXML] = None
+        self._paths = []
+        self._path_info = {}
+        self._addr_index = {}
+        self._hints = PathHints()
+        self._build_ui()
+        self._connect()
+        
+
+    def _build_ui(self):
+        lay = QtWidgets.QVBoxLayout(self)
+
+        # --- File chooser ---
+        file_box = QtWidgets.QHBoxLayout()
+        self.btn_load = QtWidgets.QPushButton('Load XML...')
+        self.lbl_file = QtWidgets.QLabel('<no file>')
+        self.lbl_file.setTextInteractionFlags(QtCore.Qt.TextSelectableByMouse)
+        file_box.addWidget(self.btn_load)
+        file_box.addWidget(self.lbl_file, 1)
+        lay.addLayout(file_box)
+
+        self.lbl_timestamp = QtWidgets.QLabel('Timestamp: -')
+        lay.addWidget(self.lbl_timestamp)
+
+        form = QtWidgets.QFormLayout()
+
+        # --- Search field for variable ---
+        self.edit_var_search = QtWidgets.QLineEdit()
+        self.edit_var_search.setPlaceholderText("Введите имя/путь или адрес 0x......")
+        form.addRow('Variable:', self.edit_var_search)
+
+        # Popup list
+        self._popup = QtWidgets.QListView()
+        self._popup.setWindowFlags(QtCore.Qt.ToolTip)
+        self._popup.setEditTriggers(QtWidgets.QAbstractItemView.NoEditTriggers)
+        self._popup.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
+        self._popup.clicked.connect(self._on_popup_clicked)
+        self._model_all = QtGui.QStandardItemModel(self)
+        self._model_filtered = QtGui.QStandardItemModel(self)
+
+        # Address
+        self.edit_address = QtWidgets.QLineEdit('0x000000')
+        self.edit_address.setValidator(HexAddrValidator(self))
+        self.edit_address.setMaximumWidth(120)
+        form.addRow('Address:', self.edit_address)
+
+        # Manual date spins
+        dt_row = QtWidgets.QHBoxLayout()
+        self.spin_year = QtWidgets.QSpinBox(); self.spin_year.setRange(2000, 2100); self.spin_year.setValue(2025)
+        self.spin_month = QtWidgets.QSpinBox(); self.spin_month.setRange(1,12)
+        self.spin_day = QtWidgets.QSpinBox(); self.spin_day.setRange(1,31)
+        self.spin_hour = QtWidgets.QSpinBox(); self.spin_hour.setRange(0,23)
+        self.spin_minute = QtWidgets.QSpinBox(); self.spin_minute.setRange(0,59)
+        for w,label in [(self.spin_year,'Y'),(self.spin_month,'M'),(self.spin_day,'D'),(self.spin_hour,'h'),(self.spin_minute,'m')]:
+            box = QtWidgets.QVBoxLayout()
+            box.addWidget(QtWidgets.QLabel(label, alignment=QtCore.Qt.AlignHCenter))
+            box.addWidget(w)
+            dt_row.addLayout(box)
+        form.addRow('Manual Date:', dt_row)
+
+        # Types
+        self.cmb_ptr_type = QtWidgets.QComboBox(); self.cmb_ptr_type.addItems(PT_ENUM_ORDER)
+        self.cmb_iq_type = QtWidgets.QComboBox(); self.cmb_iq_type.addItems(IQ_ENUM_ORDER)
+        self.cmb_return_type = QtWidgets.QComboBox(); self.cmb_return_type.addItems(IQ_ENUM_ORDER)
+        form.addRow('ptr_type:', self.cmb_ptr_type)
+        form.addRow('iq_type:', self.cmb_iq_type)
+        form.addRow('return_type:', self.cmb_return_type)
+
+        lay.addLayout(form)
+
+        self.btn_prepare = QtWidgets.QPushButton('Prepare Variable')
+        lay.addWidget(self.btn_prepare)
+        lay.addStretch(1)
+
+        self.txt_info = QtWidgets.QPlainTextEdit()
+        self.txt_info.setReadOnly(True)
+        self.txt_info.setMaximumHeight(140)
+        lay.addWidget(QtWidgets.QLabel('Info:'))
+        lay.addWidget(self.txt_info)
+
+        # Event filter for keyboard on search field
+        self.edit_var_search.installEventFilter(self)
+
+    def _connect(self):
+        self.btn_load.clicked.connect(self._on_load_xml)
+        self.edit_address.editingFinished.connect(self._normalize_address)
+        self.btn_prepare.clicked.connect(self._emit_variable)
+        self.edit_var_search.textEdited.connect(self._on_var_search_edited)
+        self.edit_var_search.returnPressed.connect(self._activate_current_popup_selection)
+
+    # ---------------- XML Load ----------------
+    def _on_load_xml(self):
+        path, _ = QtWidgets.QFileDialog.getOpenFileName(
+            self, 'Select variables XML', '', 'XML Files (*.xml);;All Files (*)')
+        if not path:
+            return
+        try:
+            self._xml = VariablesXML(path)
+        except Exception as e:
+            QtWidgets.QMessageBox.critical(self, 'Parse error', f'Ошибка парсинга:\n{e}')
+            return
+        self.lbl_file.setText(path)
+        self.lbl_timestamp.setText(f'Timestamp: {self._xml.timestamp or "-"}')
+        self._populate_variables()
+        self._apply_timestamp_to_date()
+        self.xmlLoaded.emit(path)
+        self._log(f'Loaded {path}, variables={len(self._xml.variables)}')
+
+    def _apply_timestamp_to_date(self):
+        if not self._xml.timestamp:
+            return
+        import datetime
+        try:
+            # Пример: "Sat Jul 19 15:27:59 2025"
+            dt = datetime.datetime.strptime(self._xml.timestamp, "%a %b %d %H:%M:%S %Y")
+            self.spin_year.setValue(dt.year)
+            self.spin_month.setValue(dt.month)
+            self.spin_day.setValue(dt.day)
+            self.spin_hour.setValue(dt.hour)
+            self.spin_minute.setValue(dt.minute)
+        except Exception as e:
+            print(f"Ошибка разбора timestamp '{self._xml.timestamp}': {e}")
+
+    def _populate_variables(self):
+        if not self._xml:
+            return
+        flat = self._xml.flattened()
+        # flat: [(path, addr, type_str), ...]
+
+        self._paths = []
+        self._path_info = {}
+        self._addr_index = {}
+        self._model_all.clear()        # держим «сырой» полный список (можно не показывать)
+        self._model_filtered.clear()   # текущие подсказки
+
+        # индексирование
+        for path, addr, t in flat:
+            self._paths.append(path)
+            self._path_info[path] = (addr, t)
+            if addr in self._addr_index:
+                self._addr_index[addr] = None
+            else:
+                self._addr_index[addr] = path
+
+            # наполняем «all» модель (необязательная, но пусть остаётся — не используем напрямую)
+            it = QtGui.QStandardItem(f"{path}  [{addr:06X}]")
+            it.setData(path, QtCore.Qt.UserRole+1)
+            it.setData(addr, QtCore.Qt.UserRole+2)
+            it.setData(t, QtCore.Qt.UserRole+3)
+            self._model_all.appendRow(it)
+
+        # построить подсказки
+        self._hints.set_paths([(p, self._path_info[p][1]) for p in self._paths])
+
+        # начальное состояние попапа (пустой ввод → top-level)
+        self._update_popup_model(self._hints.suggest(''))
+
+        self._log(f"Variables loaded: {len(flat)}")
+
+    # --------------- Search mechanics ---------------
+    def _update_popup_model(self, paths: List[str]):
+        """Обновляет модель попапа списком путей (full paths)."""
+        self._model_filtered.clear()
+        limit = 400
+        added = 0
+        for p in paths:
+            info = self._path_info.get(p)
+            if not info:
+                continue
+            addr, t = info
+            it = QtGui.QStandardItem(f"{p}  [{addr:06X}]")
+            it.setData(p, QtCore.Qt.UserRole+1)
+            it.setData(addr, QtCore.Qt.UserRole+2)
+            it.setData(t, QtCore.Qt.UserRole+3)
+            self._model_filtered.appendRow(it)
+            added += 1
+            if added >= limit:
+                break
+        if added >= limit:
+            extra = QtGui.QStandardItem("... (more results truncated)")
+            extra.setEnabled(False)
+            self._model_filtered.appendRow(extra)
+
+    def _show_popup(self):
+        if self._model_filtered.rowCount() == 0:
+            self._popup.hide()
+            return
+        self._popup.setModel(self._model_filtered)
+        self._popup.setMinimumWidth(self.edit_var_search.width())
+        pos = self.edit_var_search.mapToGlobal(QtCore.QPoint(0, self.edit_var_search.height()))
+        self._popup.move(pos)
+        self._popup.show()
+        self._popup.raise_()
+        self._popup.setFocus()
+        self._popup.setCurrentIndex(self._model_filtered.index(0,0))
+
+    def _hide_popup(self):
+        self._popup.hide()
+
+    def _on_var_search_edited(self, text: str):
+        t = text.strip()
+
+        # адрес?
+        if t.startswith("0x") and len(t) >= 3:
+            try:
+                addr = int(t, 16)
+                path = self._addr_index.get(addr)
+                if path:
+                    self._set_current_variable(path, from_address=True)
+                    self._hide_popup()
+                    return
+            except ValueError:
+                pass
+
+        # подсказки по имени
+        suggestions = self._hints.suggest(t)
+        self._update_popup_model(suggestions)
+        self._show_popup()
+
+    def _on_popup_clicked(self, idx: QtCore.QModelIndex):
+        if not idx.isValid():
+            return
+        path = idx.data(QtCore.Qt.UserRole+1)
+        if path:
+            self._set_current_variable(path)
+        self._hide_popup()
+
+    def _activate_current_popup_selection(self):
+        if self._popup.isVisible():
+            idx = self._popup.currentIndex()
+            if idx.isValid():
+                self._on_popup_clicked(idx)
+                return
+        # Попытка прямого совпадения
+        path = self.edit_var_search.text().strip()
+        if path in self._path_info:
+            self._set_current_variable(path)
+
+    def eventFilter(self, obj, ev):
+        if obj is self.edit_var_search and ev.type() == QtCore.QEvent.KeyPress:
+            if ev.key() in (QtCore.Qt.Key_Down, QtCore.Qt.Key_Up):
+                if not self._popup.isVisible():
+                    self._show_popup()
+                else:
+                    step = 1 if ev.key()==QtCore.Qt.Key_Down else -1
+                    cur = self._popup.currentIndex()
+                    row = cur.row() + step
+                    if row < 0: row = 0
+                    if row >= self._model_filtered.rowCount():
+                        row = self._model_filtered.rowCount()-1
+                    self._popup.setCurrentIndex(self._model_filtered.index(row,0))
+                return True
+            elif ev.key() == QtCore.Qt.Key_Escape:
+                self._hide_popup()
+                return True
+        return super().eventFilter(obj, ev)
+
+    def _set_current_variable(self, path: str, from_address=False):
+        if path not in self._path_info:
+            return
+        addr, type_str = self._path_info[path]
+        self.edit_var_search.setText(path)
+        self.edit_address.setText(f"0x{addr:06X}")
+        ptr_enum_name = self._map_type_to_ptr_enum(type_str)
+        self._select_combo_text(self.cmb_ptr_type, ptr_enum_name)
+        source = "ADDR" if from_address else "SEARCH"
+        self._log(f"[{source}] Selected {path} @0x{addr:06X} type={type_str} -> ptr={ptr_enum_name}")
+
+    # --------------- Date struct / address / helpers ---------------
+
+    def _normalize_address(self):
+        self.edit_address.setText(HexAddrValidator.normalize(self.edit_address.text()))
+
+    def _map_type_to_ptr_enum(self, type_str: str) -> str:
+        if not type_str:
+            return 'pt_unknown'
+        low = type_str.lower()
+        token = low.replace('*',' ').replace('[',' ').split()[0]
+        return PTR_TYPE_MAP.get(token, 'pt_unknown')
+
+    def _select_combo_text(self, combo: QtWidgets.QComboBox, text: str):
+        ix = combo.findText(text)
+        if ix >= 0:
+            combo.setCurrentIndex(ix)
+
+    def _collect_datetime(self) -> Dict[str,int]:
+        return {
+            'year': self.spin_year.value(),
+            'month': self.spin_month.value(),
+            'day': self.spin_day.value(),
+            'hour': self.spin_hour.value(),
+            'minute': self.spin_minute.value(),
+        }
+
+    def _emit_variable(self):
+        if not self._path_info:
+            QtWidgets.QMessageBox.warning(self, 'No XML', 'Сначала загрузите XML файл.')
+            return
+        path = self.edit_var_search.text().strip()
+        if path not in self._path_info:
+            QtWidgets.QMessageBox.warning(self, 'Variable', 'Переменная не выбрана / не найдена.')
+            return
+        addr, type_str = self._path_info[path]
+        ptr_type_name = self.cmb_ptr_type.currentText()
+        iq_type_name = self.cmb_iq_type.currentText()
+        ret_type_name = self.cmb_return_type.currentText()
+        out = {
+            'address': addr,
+            'address_hex': f"0x{addr:06X}",
+            'ptr_type': PT_ENUM_VALUE.get(ptr_type_name, 0),
+            'iq_type': IQ_ENUM_VALUE.get(iq_type_name, 0),
+            'return_type': IQ_ENUM_VALUE.get(ret_type_name, 0),
+            'datetime': self._collect_datetime(),
+            'path': path,
+            'type_string': type_str,
+            'ptr_type_name': ptr_type_name,
+            'iq_type_name': iq_type_name,
+            'return_type_name': ret_type_name,
+        }
+        self._log(f"Prepared variable: {out}")
+        self.variablePrepared.emit(out)
+
+    def _log(self, msg: str):
+        self.txt_info.appendPlainText(msg)
+
+# ----------------------------------------------------------- Demo window --
+class _DemoWindow(QtWidgets.QMainWindow):
+    def __init__(self):
+        super().__init__()
+        self.setWindowTitle('LowLevel Selector Demo')
+        self.selector = LowLevelSelectorWidget(self)
+        self.setCentralWidget(self.selector)
+        self.selector.variablePrepared.connect(self.on_var)
+
+    def on_var(self, data: dict):
+        print('Variable prepared ->', data)
+
+    def closeEvent(self, ev):
+        self.setCentralWidget(None)
+        super().closeEvent(ev)
+
+# ----------------------------------------------------------------- main ---
+if __name__ == '__main__':
+    app = QtWidgets.QApplication(sys.argv)
+    w = _DemoWindow()
+    w.resize(640, 520)
+    w.show()
+    sys.exit(app.exec_())

Src/tms_debugvar_term.py

@@ -0,0 +1,970 @@
+from PySide2 import QtCore, QtWidgets, QtSerialPort
+from tms_debugvar_lowlevel import LowLevelSelectorWidget
+import datetime
+
+# ------------------------------- Константы протокола ------------------------
+WATCH_SERVICE_BIT = 0x8000
+DEBUG_OK = 0  # ожидаемый код успешного чтения
+SIGN_BIT_MASK = 0x80
+FRAC_MASK_FULL = 0x7F      # если используем 7 бит дробной части
+# ---------------------------------------------------------------- CRC util ---
+def crc16_ibm(data: bytes, *, init=0xFFFF) -> int:
+    """CRC16-IBM (aka CRC-16/ANSI, polynomial 0xA001 reflected)."""
+    crc = init
+    for b in data:
+        crc ^= b
+        for _ in range(8):
+            if crc & 1:
+                crc = (crc >> 1) ^ 0xA001
+            else:
+                crc >>= 1
+    return crc & 0xFFFF
+
+class Spoiler(QtWidgets.QWidget):
+    def __init__(self, title="", animationDuration=300, parent=None):
+        super().__init__(parent)
+        self._animationDuration = animationDuration
+        self.state = False
+
+        # --- Toggle button ---
+        self.toggleButton = QtWidgets.QToolButton(self)
+        self.toggleButton.setStyleSheet("QToolButton { border: none; }")
+        self.toggleButton.setToolButtonStyle(QtCore.Qt.ToolButtonTextBesideIcon)
+        self.toggleButton.setArrowType(QtCore.Qt.RightArrow)
+        self.toggleButton.setText(title)
+        self.toggleButton.setCheckable(True)
+
+        # --- Header line ---
+        self.headerLine = QtWidgets.QFrame(self)
+        self.headerLine.setFrameShape(QtWidgets.QFrame.HLine)
+        self.headerLine.setFrameShadow(QtWidgets.QFrame.Sunken)
+
+        # --- Content area ---
+        self.contentArea = QtWidgets.QScrollArea(self)
+        self.contentArea.setSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Fixed)
+        self.contentArea.setFrameShape(QtWidgets.QFrame.NoFrame)
+        self.contentArea.setWidgetResizable(True)
+        self._contentWidget = QtWidgets.QWidget()
+        self.contentArea.setWidget(self._contentWidget)
+        self.contentArea.setMaximumHeight(0)
+
+        # --- Анимация только по контенту ---
+        self._ani_content = QtCore.QPropertyAnimation(self.contentArea, b"maximumHeight")
+        self._ani_content.setDuration(animationDuration)
+        self._ani_content.setEasingCurve(QtCore.QEasingCurve.InOutCubic)
+
+        # Следим за шагами анимации → обновляем родителя
+        self._ani_content.valueChanged.connect(self._adjust_parent_size)
+
+        # --- Layout ---
+        self.mainLayout = QtWidgets.QGridLayout(self)
+        self.mainLayout.setVerticalSpacing(0)
+        self.mainLayout.setContentsMargins(0, 0, 0, 0)
+        self.mainLayout.addWidget(self.toggleButton, 0, 0, 1, 1)
+        self.mainLayout.addWidget(self.headerLine, 0, 1, 1, 1)
+        self.mainLayout.addWidget(self.contentArea, 1, 0, 1, 2)
+
+        # --- Signals ---
+        self.toggleButton.clicked.connect(self._on_toggled)
+
+    def setContentLayout(self, contentLayout):
+        old = self._contentWidget.layout()
+        if old:
+            QtWidgets.QWidget().setLayout(old)
+        self._contentWidget.setLayout(contentLayout)
+
+    def getState(self):
+        return self.state
+
+    def _adjust_parent_size(self, *_):
+        top = self.window()
+        if top:
+            size = top.size()
+            size.setHeight(top.sizeHint().height())  # берём новую высоту
+            top.resize(size)  # ширина остаётся прежней
+
+    def _on_toggled(self, checked: bool):
+        self.state = checked
+        self.toggleButton.setArrowType(QtCore.Qt.DownArrow if checked else QtCore.Qt.RightArrow)
+
+        contentHeight = self._contentWidget.sizeHint().height()
+        self._ani_content.stop()
+        self._ani_content.setStartValue(self.contentArea.maximumHeight())
+        self._ani_content.setEndValue(contentHeight if checked else 0)
+
+        # --- Фиксируем ширину на время анимации ---
+        w = self.width()
+        self.setFixedWidth(w)
+        self._ani_content.finished.connect(lambda: self.setMaximumWidth(16777215))  # сброс фикса
+
+        self._ani_content.start()
+
+
+# --------------------------- DebugTerminalWidget ---------------------------
+class DebugTerminalWidget(QtWidgets.QWidget):
+    # Существующие сигналы (Watch)
+    nameRead = QtCore.Signal(int, int, int, str)
+    valueRead = QtCore.Signal(int, int, int, int, float)
+    valuesRead = QtCore.Signal(int, int, list, list, list, list)
+    # Новые сигналы (LowLevel)
+    llValueRead = QtCore.Signal(int, int, int, int, float)  # addr, status, rettype_raw, raw16_signed, scaled
+
+    portOpened = QtCore.Signal(str)
+    portClosed = QtCore.Signal(str)
+    txBytes = QtCore.Signal(bytes)
+    rxBytes = QtCore.Signal(bytes)
+
+    def __init__(self, parent=None, *,
+                 start_byte=0x0A,
+                 cmd_byte=0x46,
+                 cmd_lowlevel=0x47,
+                 iq_scaling=None,
+                 read_timeout_ms=250,
+                 auto_crc_check=True,
+                 drop_if_busy=False,
+                 replace_if_busy=True):
+        super().__init__(parent)
+        self.device_addr = start_byte
+        self.cmd_byte = cmd_byte
+        self.cmd_lowlevel = cmd_lowlevel
+        self.read_timeout_ms = read_timeout_ms
+        self.auto_crc_check = auto_crc_check
+        self._drop_if_busy = drop_if_busy
+        self._replace_if_busy = replace_if_busy
+
+        if iq_scaling is None:
+            iq_scaling = {n: float(1 << n) for n in range(31)}
+            iq_scaling[0] = 1.0
+        self.iq_scaling = iq_scaling
+
+        # Serial
+        self.serial = QtSerialPort.QSerialPort(self)
+        self.serial.setBaudRate(115200)
+        self.serial.readyRead.connect(self._on_ready_read)
+        self.serial.errorOccurred.connect(self._on_serial_error)
+
+        # State
+        self._rx_buf = bytearray()
+        self._busy = False
+        self._pending_cmd = None      # (frame, meta)
+        self._txn_meta = None         # {'service':bool,'index':int,'varqnt':int,'chain':...,'lowlevel':bool}
+
+        self._txn_timer = QtCore.QTimer(self)
+        self._txn_timer.setSingleShot(True)
+        self._txn_timer.timeout.connect(self._on_txn_timeout)
+
+        # Watch polling
+        self._poll_timer = QtCore.QTimer(self)
+        self._poll_timer.timeout.connect(self._on_poll_timeout)
+        self._polling = False
+
+        # LowLevel polling
+        self._ll_poll_timer = QtCore.QTimer(self)
+        self._ll_poll_timer.timeout.connect(self._on_ll_poll_timeout)
+        self._ll_polling = False
+        self._ll_current_var_info = None # Хранит инфо о выбранной LL переменной
+
+        # Кэш: index -> (status, iq, name, is_signed, frac_bits)
+        self._name_cache = {}
+
+        # Очередь service индексов
+        self._service_queue = []
+        self._pending_data_after_services = None  # (base, count)
+
+        self._build_ui()
+        self._connect_ui()
+        self.set_available_ports()
+
+    # ------------------------------ UI ----------------------------------
+    def _build_ui(self):
+        layout = QtWidgets.QVBoxLayout(self)
+
+        # --- Serial group ---
+        g_serial = QtWidgets.QGroupBox("Serial Port")
+        hs = QtWidgets.QHBoxLayout(g_serial)
+        self.cmb_port = QtWidgets.QComboBox()
+        self.btn_refresh = QtWidgets.QPushButton("Refresh")
+        self.cmb_baud = QtWidgets.QComboBox()
+        self.cmb_baud.addItems(["9600","19200","38400","57600","115200","230400"])
+        self.cmb_baud.setCurrentText("115200")
+        self.btn_open = QtWidgets.QPushButton("Open")
+        hs.addWidget(QtWidgets.QLabel("Port:"))
+        hs.addWidget(self.cmb_port, 1)
+        hs.addWidget(self.btn_refresh)
+        hs.addSpacing(10)
+        hs.addWidget(QtWidgets.QLabel("Baud:"))
+        hs.addWidget(self.cmb_baud)
+        hs.addWidget(self.btn_open)
+
+        # --- TabWidget ---
+        self.tabs = QtWidgets.QTabWidget()
+        self._build_watch_tab()
+        self._build_lowlevel_tab() # <-- Вызываем новый метод
+
+        # --- UART Log ---
+        self.log_spoiler = Spoiler("UART Log", animationDuration=300, parent=self)
+        self.log_spoiler.setSizePolicy(QtWidgets.QSizePolicy.Expanding,
+                                       QtWidgets.QSizePolicy.Minimum)
+        log_layout = QtWidgets.QVBoxLayout()
+        self.txt_log = QtWidgets.QTextEdit(); self.txt_log.setReadOnly(True)
+        self.txt_log.setFontFamily("Courier")
+        log_layout.addWidget(self.txt_log)
+        self.log_spoiler.setContentLayout(log_layout)
+
+        layout.addWidget(g_serial, 0)
+        layout.addWidget(self.tabs, 1)
+        layout.addWidget(self.log_spoiler, 0)
+        layout.setStretch(layout.indexOf(g_serial), 0)
+        layout.setStretch(layout.indexOf(self.tabs), 1)
+        layout.setStretch(layout.indexOf(self.log_spoiler), 0)
+
+    def _build_watch_tab(self):
+        # ... (код для вкладки Watch остаётся без изменений)
+        tab = QtWidgets.QWidget()
+        vtab = QtWidgets.QVBoxLayout(tab)
+
+        g_watch = QtWidgets.QGroupBox("Watch Variables")
+        grid = QtWidgets.QGridLayout(g_watch)
+        grid.setHorizontalSpacing(8)
+        grid.setVerticalSpacing(4)
+
+        self.spin_index = QtWidgets.QSpinBox(); self.spin_index.setRange(0, 0x7FFF); self.spin_index.setAccelerated(True)
+        self.chk_hex_index = QtWidgets.QCheckBox("Hex")
+        self.spin_count = QtWidgets.QSpinBox(); self.spin_count.setRange(1,255); self.spin_count.setValue(1)
+        self.btn_read_service = QtWidgets.QPushButton("Read Name/Type")
+        self.btn_read_values = QtWidgets.QPushButton("Read Value(s)")
+        self.btn_poll = QtWidgets.QPushButton("Start Polling")
+        self.spin_interval = QtWidgets.QSpinBox(); self.spin_interval.setRange(50,10000); self.spin_interval.setValue(500); self.spin_interval.setSuffix(" ms")
+        self.chk_auto_service = QtWidgets.QCheckBox("Auto service before values if miss cache"); self.chk_auto_service.setChecked(True)
+        self.chk_raw = QtWidgets.QCheckBox("Raw (no IQ scaling)")
+        self.lbl_name = QtWidgets.QLineEdit(); self.lbl_name.setReadOnly(True)
+        self.lbl_iq = QtWidgets.QLabel("-")
+        self.edit_single_value = QtWidgets.QLineEdit(); self.edit_single_value.setReadOnly(True)
+
+        self.tbl_values = QtWidgets.QTableWidget(0, 5)
+        self.tbl_values.setHorizontalHeaderLabels(["Index","Name","IQ","Raw","Scaled"])
+        hh = self.tbl_values.horizontalHeader()
+        hh.setSectionResizeMode(0, QtWidgets.QHeaderView.ResizeToContents)
+        hh.setSectionResizeMode(1, QtWidgets.QHeaderView.ResizeToContents)
+        hh.setSectionResizeMode(2, QtWidgets.QHeaderView.ResizeToContents)
+        hh.setSectionResizeMode(3, QtWidgets.QHeaderView.ResizeToContents)
+        hh.setSectionResizeMode(4, QtWidgets.QHeaderView.Stretch)
+        self.tbl_values.verticalHeader().setVisible(False)
+
+        r = 0
+        grid.addWidget(QtWidgets.QLabel("Base Index:"), r, 0); grid.addWidget(self.spin_index, r, 1); grid.addWidget(self.chk_hex_index, r, 2); r+=1
+        grid.addWidget(QtWidgets.QLabel("Count:"), r, 0); grid.addWidget(self.spin_count, r, 1); r+=1
+        grid.addWidget(self.btn_read_service, r, 0); grid.addWidget(self.btn_read_values, r, 1); grid.addWidget(self.btn_poll, r, 2); r+=1
+        grid.addWidget(QtWidgets.QLabel("Interval:"), r, 0); grid.addWidget(self.spin_interval, r, 1); grid.addWidget(self.chk_auto_service, r, 2); r+=1
+        grid.addWidget(QtWidgets.QLabel("Name:"), r, 0); grid.addWidget(self.lbl_name, r, 1, 1, 2); r+=1
+        grid.addWidget(QtWidgets.QLabel("IQ:"), r, 0); grid.addWidget(self.lbl_iq, r, 1); grid.addWidget(self.chk_raw, r, 2); r+=1
+        grid.addWidget(QtWidgets.QLabel("Single:"), r, 0); grid.addWidget(self.edit_single_value, r, 1, 1, 2); r+=1
+        grid.addWidget(QtWidgets.QLabel("Array Values:"), r, 0); r+=1
+        grid.addWidget(self.tbl_values, r, 0, 1, 3); grid.setRowStretch(r, 1)
+
+        vtab.addWidget(g_watch, 1)
+        self.tabs.addTab(tab, "Watch")
+
+    def _build_lowlevel_tab(self):
+        tab = QtWidgets.QWidget()
+        main_layout = QtWidgets.QVBoxLayout(tab)
+
+        # --- Селектор переменной ---
+        self.ll_selector = LowLevelSelectorWidget(tab)
+        main_layout.addWidget(self.ll_selector, 1) # Даём ему растягиваться
+
+        # --- Панель управления и статуса ---
+        g_controls = QtWidgets.QGroupBox("Controls & Status")
+        grid = QtWidgets.QGridLayout(g_controls)
+
+        self.btn_ll_read = QtWidgets.QPushButton("Read Once")
+        self.btn_ll_poll = QtWidgets.QPushButton("Start Polling")
+        self.spin_ll_interval = QtWidgets.QSpinBox()
+        self.spin_ll_interval.setRange(50, 10000)
+        self.spin_ll_interval.setValue(500)
+        self.spin_ll_interval.setSuffix(" ms")
+        self.chk_ll_raw = QtWidgets.QCheckBox("Raw (no IQ scaling)")
+
+        self.ll_val_status = QtWidgets.QLabel("-")
+        self.ll_val_rettype = QtWidgets.QLabel("-")
+        self.ll_val_raw = QtWidgets.QLabel("-")
+        self.ll_val_scaled = QtWidgets.QLabel("-")
+        
+        # Размещение виджетов
+        grid.addWidget(self.btn_ll_read, 0, 0)
+        grid.addWidget(self.btn_ll_poll, 0, 1)
+        grid.addWidget(QtWidgets.QLabel("Interval:"), 1, 0)
+        grid.addWidget(self.spin_ll_interval, 1, 1)
+        grid.addWidget(self.chk_ll_raw, 0, 2, 2, 1) # Растянем на 2 строки
+
+        # Результаты в виде формы
+        form_layout = QtWidgets.QFormLayout()
+        form_layout.addRow("Status:", self.ll_val_status)
+        form_layout.addRow("Return Type:", self.ll_val_rettype)
+        form_layout.addRow("Raw Value:", self.ll_val_raw)
+        form_layout.addRow("Scaled Value:", self.ll_val_scaled)
+        
+        grid.addLayout(form_layout, 2, 0, 1, 3)
+        grid.setColumnStretch(2, 1)
+        
+        main_layout.addWidget(g_controls)
+        main_layout.setStretchFactor(g_controls, 0) # Не растягивать
+
+        self.tabs.addTab(tab, "LowLevel")
+
+    def _connect_ui(self):
+        # Watch
+        self.btn_refresh.clicked.connect(self.set_available_ports)
+        self.btn_open.clicked.connect(self._open_close_port)
+        self.btn_read_service.clicked.connect(self.request_service_single)
+        self.btn_read_values.clicked.connect(self.request_values)
+        self.btn_poll.clicked.connect(self._toggle_polling)
+        self.chk_hex_index.stateChanged.connect(self._toggle_index_base)
+        
+        # LowLevel (новые и переделанные)
+        self.ll_selector.variablePrepared.connect(self._on_ll_variable_prepared)
+        self.ll_selector.xmlLoaded.connect(lambda p: self._log(f"[LL] XML loaded: {p}"))
+        self.btn_ll_read.clicked.connect(self.request_lowlevel_once)
+        self.btn_ll_poll.clicked.connect(self._toggle_ll_polling)
+
+    # ----------------------------- SERIAL MGMT ----------------------------
+    # ... (код без изменений)
+    def set_available_ports(self):
+        cur = self.cmb_port.currentText()
+        self.cmb_port.blockSignals(True)
+        self.cmb_port.clear()
+        for info in QtSerialPort.QSerialPortInfo.availablePorts():
+            self.cmb_port.addItem(info.portName())
+        if cur:
+            ix = self.cmb_port.findText(cur)
+            if ix >= 0:
+                self.cmb_port.setCurrentIndex(ix)
+        self.cmb_port.blockSignals(False)
+
+    def _open_close_port(self):
+        if self.serial.isOpen():
+            name = self.serial.portName()
+            self.serial.close()
+            self.btn_open.setText("Open")
+            self._log(f"[PORT] Closed {name}")
+            self.portClosed.emit(name)
+            return
+        port = self.cmb_port.currentText()
+        if not port:
+            self._log("[ERR] No port selected")
+            return
+        self.serial.setPortName(port)
+        self.serial.setBaudRate(int(self.cmb_baud.currentText()))
+        if not self.serial.open(QtCore.QIODevice.ReadWrite):
+            self._log(f"[ERR] Open fail {port}: {self.serial.errorString()}")
+            return
+        self.btn_open.setText("Close")
+        self._log(f"[PORT] Opened {port}")
+        self.portOpened.emit(port)
+
+    # ---------------------------- FRAME BUILD -----------------------------
+    def _build_request(self, index: int, *, service: bool, varqnt: int) -> bytes:
+        dbg = index & 0x7FFF
+        if service:
+            dbg |= WATCH_SERVICE_BIT
+        hi = (dbg >> 8) & 0xFF
+        lo = dbg & 0xFF
+        q = varqnt & 0xFF
+        payload = bytes([self.device_addr & 0xFF, self.cmd_byte & 0xFF, hi, lo, q])
+        crc = crc16_ibm(payload)
+        return payload + bytes([crc & 0xFF, (crc >> 8) & 0xFF])
+
+    def _build_lowlevel_request(self, var_info: dict) -> bytes:
+        # Формат: [adr][cmd_lowlevel][year_hi][year_lo][month][day][hour][minute][addr2][addr1][addr0][pt_type][iq_type][return_type]
+        # Пытаемся получить время из переданной информации
+        dt_info = var_info.get('datetime')
+    
+        if dt_info:
+            # Используем время из var_info
+            year = dt_info.get('year', 2000)
+            month = dt_info.get('month', 1)
+            day = dt_info.get('day', 1)
+            hour = dt_info.get('hour', 0)
+            minute = dt_info.get('minute', 0)
+            self._log("[LL] Using time from selector.")
+        else:
+            # Если в var_info времени нет, используем текущее системное время (старое поведение)
+            now = QtCore.QDateTime.currentDateTime()
+            year = now.date().year()
+            month = now.date().month()
+            day = now.date().day()
+            hour = now.time().hour()
+            minute = now.time().minute()
+            self._log("[LL] Fallback to current system time.")
+
+        addr = var_info.get('address', 0)
+        addr2 = (addr >> 16) & 0xFF
+        addr1 = (addr >> 8) & 0xFF
+        addr0 = addr & 0xFF
+        pt_type = var_info.get('ptr_type', 0) & 0xFF
+        iq_type = var_info.get('iq_type', 0) & 0xFF
+        ret_type = var_info.get('return_type', 0) & 0xFF
+
+        frame_wo_crc = bytes([
+            self.device_addr & 0xFF, self.cmd_lowlevel & 0xFF,
+            (year >> 8) & 0xFF, year & 0xFF,
+            month & 0xFF, day & 0xFF, hour & 0xFF, minute & 0xFF,
+            addr2, addr1, addr0, pt_type, iq_type, ret_type
+        ])
+        crc = crc16_ibm(frame_wo_crc)
+        return frame_wo_crc + bytes([crc & 0xFF, (crc >> 8) & 0xFF])
+
+    # ----------------------------- PUBLIC API -----------------------------
+    def request_service_single(self):
+        idx = int(self.spin_index.value())
+        self._enqueue_or_start(idx, service=True, varqnt=0)
+
+    def request_values(self):
+        base = int(self.spin_index.value())
+        count = int(self.spin_count.value())
+        needed = []
+        if self.chk_auto_service.isChecked():
+            for i in range(base, base+count):
+                if i not in self._name_cache:
+                    needed.append(i)
+        if needed:
+            self._service_queue = needed[:]
+            self._pending_data_after_services = (base, count)
+            self._log(f"[AUTO] Need service for {len(needed)} indices: {needed}")
+            self._kick_service_queue()
+        else:
+            self._enqueue_or_start(base, service=False, varqnt=count)
+
+    def request_lowlevel_once(self):
+        """Запрашивает чтение выбранной LowLevel переменной."""
+        if not self.serial.isOpen():
+            self._log("[LL] Port is not open.")
+            return
+        if self._busy:
+            self._log("[LL] Busy, request dropped.")
+            return
+        if not self._ll_current_var_info:
+            self._log("[LL] No variable selected!")
+            if self._ll_polling: # Если поллинг активен, но переменная пропала - стоп
+                self._toggle_ll_polling()
+            return
+            
+        frame = self._build_lowlevel_request(self._ll_current_var_info)
+        meta = {'lowlevel': True}
+        self._enqueue_raw(frame, meta)
+
+    # -------------------------- SERVICE QUEUE FLOW ------------------------
+    # ... (код без изменений)
+    def _kick_service_queue(self):
+        if self._busy:
+            return
+        if self._service_queue:
+            nxt = self._service_queue.pop(0)
+            self._enqueue_or_start(nxt, service=True, varqnt=0, queue_mode=True)
+        elif self._pending_data_after_services:
+            base, count = self._pending_data_after_services
+            self._pending_data_after_services = None
+            self._enqueue_or_start(base, service=False, varqnt=count)
+    
+    # ------------------------ TRANSACTION SCHEDULER -----------------------
+    # ... (код без изменений)
+    def _enqueue_raw(self, frame: bytes, meta: dict):
+        if self._busy:
+            if self._drop_if_busy and not self._replace_if_busy:
+                self._log("[LOCKSTEP] Busy -> drop")
+                return
+            if self._replace_if_busy:
+                self._pending_cmd = (frame, meta)
+                self._log("[LOCKSTEP] Busy -> replaced pending")
+            else:
+                self._log("[LOCKSTEP] Busy -> ignore")
+            return
+        self._start_txn(frame, meta)
+
+    def _enqueue_or_start(self, index, service: bool, varqnt: int, chain_after=None, queue_mode=False):
+        frame = self._build_request(index, service=service, varqnt=varqnt)
+        meta = {'service': service, 'index': index, 'varqnt': varqnt, 'chain': chain_after, 'queue_mode': queue_mode, 'lowlevel': False}
+        if self._busy:
+            if self._drop_if_busy and not self._replace_if_busy:
+                self._log("[LOCKSTEP] Busy -> drop")
+                return
+            if self._replace_if_busy:
+                self._pending_cmd = (frame, meta)
+                self._log("[LOCKSTEP] Busy -> replaced pending")
+            else:
+                self._log("[LOCKSTEP] Busy -> ignore")
+            return
+        self._start_txn(frame, meta)
+
+    def _start_txn(self, frame: bytes, meta: dict):
+        self._busy = True
+        self._txn_meta = meta
+        self._rx_buf.clear()
+        self._set_ui_busy(True)
+        self._send(frame)
+        self._txn_timer.start(self.read_timeout_ms)
+
+    def _end_txn(self):
+        self._txn_timer.stop()
+        queue_mode = False
+        chain = None
+        meta = self._txn_meta
+        if meta:
+            queue_mode = meta.get('queue_mode', False)
+            chain = meta.get('chain')
+        self._txn_meta = None
+        self._busy = False
+        self._rx_buf.clear()
+        self._set_ui_busy(False)
+
+        if chain:
+            base, serv, q = chain
+            self._enqueue_or_start(base, service=serv, varqnt=q)
+            return
+        if self._pending_cmd is not None:
+            frame, meta = self._pending_cmd; self._pending_cmd = None
+            QtCore.QTimer.singleShot(0, lambda f=frame,m=meta: self._start_txn(f,m))
+            return
+        if queue_mode:
+            QtCore.QTimer.singleShot(0, self._kick_service_queue)
+            return
+
+    def _on_txn_timeout(self):
+        if not self._busy: return
+        is_ll = self._txn_meta.get('lowlevel', False) if self._txn_meta else False
+        log_prefix = "[LL TIMEOUT]" if is_ll else "[TIMEOUT]"
+        self._log(f"{log_prefix} No response")
+        if self._rx_buf:
+            self._log_frame(bytes(self._rx_buf), tx=False)
+        self._end_txn()
+
+    # ------------------------------- TX/RX ---------------------------------
+    # ... (код без изменений)
+    def _send(self, data: bytes):
+        w = self.serial.write(data)
+        if w != len(data):
+            self._log(f"[ERR] Write short {w}/{len(data)}")
+        self.txBytes.emit(data)
+        self._log_frame(data, tx=True)
+
+    def _on_ready_read(self):
+        self._rx_buf.extend(self.serial.readAll().data())
+        if not self._busy:
+            if self._rx_buf:
+                self._log("[WARN] Data while idle -> drop")
+                self._log_frame(bytes(self._rx_buf), tx=False)
+                self._rx_buf.clear()
+            return
+        self._try_parse()
+    
+    # ------------------------------- PARSING -------------------------------
+    def _try_parse(self):
+        if not self._txn_meta:
+            return
+        if self._txn_meta.get('lowlevel', False):
+            self._try_parse_lowlevel()
+        else:
+            self._try_parse_watch()
+
+    def _try_parse_watch(self):
+        # ... (код без изменений)
+        service = self._txn_meta['service']
+        buf = self._rx_buf
+        trailer_len = 4
+        if service:
+            if len(buf) < 7 + trailer_len:
+                return
+            name_len = buf[6]
+            expected = 7 + name_len + trailer_len
+            if len(buf) < expected:
+                return
+            frame = bytes(buf[:expected]); del buf[:expected]
+            self.rxBytes.emit(frame); self._log_frame(frame, tx=False)
+            self._parse_service_frame(frame)
+            self._end_txn()
+        else:
+            if len(buf) < 6 + trailer_len:
+                return
+            varqnt = buf[4]; status = buf[5]
+            if status != DEBUG_OK:
+                expected = 8 + trailer_len
+                if len(buf) < expected: return
+                frame = bytes(buf[:expected]); del buf[:expected]
+                self.rxBytes.emit(frame); self._log_frame(frame, tx=False)
+                self._parse_data_frame(frame, error_mode=True)
+                self._end_txn()
+            else:
+                expected = 6 + varqnt*2 + trailer_len
+                if len(buf) < expected: return
+                frame = bytes(buf[:expected]); del buf[:expected]
+                self.rxBytes.emit(frame); self._log_frame(frame, tx=False)
+                self._parse_data_frame(frame, error_mode=False)
+                self._end_txn()
+
+    def _try_parse_lowlevel(self):
+        # Ожидаемая длина: Успех=13, Ошибка=10
+        buf = self._rx_buf
+        if len(buf) < 10:  # Минимальная длина (ошибка)
+            return
+
+        # Проверяем, что ответ для нас
+        if buf[1] != self.cmd_lowlevel:
+            self._log("[LL] Unexpected cmd in lowlevel parser, flushing.")
+            self._log_frame(bytes(self._rx_buf), tx=False)
+            self._rx_buf.clear()
+            # Не завершаем транзакцию, ждём таймаута
+            return
+            
+        status = buf[2]
+        expected_len = 13 if status == DEBUG_OK else 10
+        
+        if len(buf) >= expected_len:
+            frame = bytes(buf[:expected_len])
+            del buf[:expected_len]
+            self.rxBytes.emit(frame)
+            self._log_frame(frame, tx=False)
+            self._parse_lowlevel_frame(frame, success=(status == DEBUG_OK))
+            self._end_txn()
+
+    def _check_crc(self, payload: bytes, crc_lo: int, crc_hi: int):
+        if not self.auto_crc_check:
+            return True
+        crc_rx = (crc_hi << 8) | crc_lo
+        crc_calc = crc16_ibm(payload)
+        if crc_calc != crc_rx:
+            self._log(f"[CRC FAIL] calc=0x{crc_calc:04X} rx=0x{crc_rx:04X}")
+            return False
+        self._log("[CRC OK]")
+        return True
+    
+    @staticmethod
+    def _clear_service_bit(vhi, vlo):
+        return ((vhi & 0x7F) << 8) | vlo
+        
+    def _parse_service_frame(self, frame: bytes):
+        # ... (код без изменений)
+        payload = frame[:-4]; crc_lo, crc_hi = frame[-4], frame[-3]
+        if len(payload) < 7:
+            self._log("[ERR] Service frame too short"); return
+        self._check_crc(payload, crc_lo, crc_hi)
+        adr, cmd, vhi, vlo, status, iq_raw, name_len = payload[:7]
+        index = self._clear_service_bit(vhi, vlo)
+        if len(payload) < 7 + name_len:
+            self._log("[ERR] Service name truncated"); return
+        name_bytes = payload[7:7+name_len]; name = name_bytes.decode(errors='replace')
+        is_signed = (iq_raw & SIGN_BIT_MASK) != 0
+        frac_bits = iq_raw & FRAC_MASK_FULL
+        if status == DEBUG_OK:
+            self._name_cache[index] = (status, iq_raw, name, is_signed, frac_bits)
+        self.nameRead.emit(index, status, iq_raw, name)
+        if self.spin_count.value() == 1 and index == self.spin_index.value():
+            if status == DEBUG_OK:
+                self.lbl_name.setText(name); self.lbl_iq.setText(f"{frac_bits}{'s' if is_signed else 'u'}")
+            else:
+                self.lbl_name.setText('<err>'); self.lbl_iq.setText('-')
+        self._log(f"[SERVICE] idx={index} status={status} iq_raw=0x{iq_raw:02X} sign={'S' if is_signed else 'U'} frac={frac_bits} name='{name}'")
+
+    def _parse_data_frame(self, frame: bytes, *, error_mode: bool):
+        # ... (код без изменений)
+        payload = frame[:-4]; crc_lo, crc_hi = frame[-4], frame[-3]
+        if len(payload) < 6:
+            self._log("[ERR] Data frame too short"); return
+        self._check_crc(payload, crc_lo, crc_hi)
+        adr, cmd, vhi, vlo, varqnt, status = payload[:6]
+        base = self._clear_service_bit(vhi, vlo)
+        if error_mode:
+            if len(payload) < 8:
+                self._log("[ERR] Error frame truncated"); return
+            err_hi, err_lo = payload[6:8]; bad_index = (err_hi << 8) | err_lo
+            self._log(f"[DATA] ERROR status={status} bad_index={bad_index}")
+            self.valueRead.emit(bad_index, status, 0, 0, float('nan'))
+            self.valuesRead.emit(base, 0, [], [], [], [])
+            return
+        if len(payload) < 6 + varqnt*2:
+            self._log("[ERR] Data payload truncated"); return
+        raw_vals = []
+        pos = 6
+        for _ in range(varqnt):
+            hi = payload[pos]; lo = payload[pos+1]; pos += 2
+            raw16 = (hi << 8) | lo
+            raw_vals.append(raw16)
+        idx_list = []; iq_list = []; name_list = []; scaled_list = []; display_raw_list = []
+        for ofs, raw16 in enumerate(raw_vals):
+            idx = base + ofs
+            status_i, iq_raw, name_i, is_signed, frac_bits = self._name_cache.get(idx, (DEBUG_OK, 0, '', False, 0))
+            if is_signed and (raw16 & 0x8000):
+                value_int = raw16 - 0x10000
+            else:
+                value_int = raw16
+            if self.chk_raw.isChecked():
+                scale = 1.0
+            else:
+                scale = self.iq_scaling.get(frac_bits, 1.0 / (1 << frac_bits))
+            scaled = float(value_int) / scale if frac_bits > 0 else float(value_int)
+            idx_list.append(idx); iq_list.append(iq_raw); name_list.append(name_i)
+            scaled_list.append(scaled); display_raw_list.append(value_int)
+        self._populate_table(idx_list, name_list, iq_list, display_raw_list, scaled_list)
+        if varqnt == 1:
+            self.edit_single_value.setText(str(display_raw_list[0]) if self.chk_raw.isChecked() else f"{scaled_list[0]:.6g}")
+            if idx_list[0] == self.spin_index.value():
+                _, iq_raw0, name0, is_signed0, frac0 = self._name_cache.get(idx_list[0], (DEBUG_OK, 0, '', False, 0))
+                self.lbl_name.setText(name0); self.lbl_iq.setText(f"{frac0}{'s' if is_signed0 else 'u'}")
+            self.valueRead.emit(idx_list[0], status, iq_list[0], display_raw_list[0], scaled_list[0])
+        else:
+            self.edit_single_value.setText("")
+            self.valuesRead.emit(base, varqnt, idx_list, iq_list, display_raw_list, scaled_list)
+        self._log(f"[DATA] base={base} q={varqnt} values={[f'{v:.6g}' for v in scaled_list] if not self.chk_raw.isChecked() else raw_vals}")
+    
+    def _parse_lowlevel_frame(self, frame: bytes, success: bool):
+        payload_len = 9 if success else 6
+        crc_pos = payload_len
+        payload = frame[:payload_len]
+        crc_lo, crc_hi = frame[crc_pos], frame[crc_pos+1]
+
+        self._check_crc(payload, crc_lo, crc_hi)
+        
+        status = payload[2]
+        addr2, addr1, addr0 = payload[3], payload[4], payload[5]
+        addr24 = (addr2 << 16) | (addr1 << 8) | addr0
+
+        self.ll_val_status.setText(f"0x{status:02X} ({'OK' if status == DEBUG_OK else 'ERR'})")
+        
+        if not success:
+            self.ll_val_rettype.setText('-')
+            self.ll_val_raw.setText('-')
+            self.ll_val_scaled.setText('<ERROR>')
+            self.llValueRead.emit(addr24, status, 0, 0, float('nan'))
+            self._log(f"[LL] ERROR status=0x{status:02X} addr=0x{addr24:06X}")
+            return
+
+        return_type = payload[6]
+        data_hi, data_lo = payload[7], payload[8]
+        raw16 = (data_hi << 8) | data_lo
+
+        is_signed = (return_type & SIGN_BIT_MASK) != 0
+        frac_bits = return_type & FRAC_MASK_FULL
+
+        if is_signed and (raw16 & 0x8000):
+            value_int = raw16 - 0x10000
+        else:
+            value_int = raw16
+
+        if self.chk_ll_raw.isChecked():
+            scale = 1.0
+        else:
+            scale = self.iq_scaling.get(frac_bits, 1.0 / (1 << frac_bits)) # 1 / 2^N
+
+        scaled = float(value_int) / scale
+        
+        # Обновляем UI
+        self.ll_val_rettype.setText(f"0x{return_type:02X} ({frac_bits}{'s' if is_signed else 'u'})")
+        self.ll_val_raw.setText(str(value_int))
+        self.ll_val_scaled.setText(f"{scaled:.6g}")
+        
+        self.llValueRead.emit(addr24, status, return_type, value_int, scaled)
+        self._log(f"[LL] OK addr=0x{addr24:06X} type=0x{return_type:02X} raw={value_int} scaled={scaled:.6g}")
+
+    def _populate_table(self, idxs, names, iqs, raws, scaled):
+        """
+        Быстрое массовое обновление таблицы значений.
+        - Не пересоздаём QTableWidgetItem при каждом вызове: обновляем текст.
+        - Блокируем сортировку, сигналы и обновления на время заполнения.
+        - Предвычисляем отображаемые строки (особенно формат scaled).
+        """
+        tbl = self.tbl_values
+        n = len(idxs)
+
+        # Заморозка UI на время массового обновления
+        prev_sorting = tbl.isSortingEnabled()
+        tbl.setSortingEnabled(False)
+        tbl.blockSignals(True)
+        tbl.setUpdatesEnabled(False)
+
+        # Подготовка размера
+        if tbl.rowCount() != n:
+            tbl.setRowCount(n)
+
+        # Предварительно решаем: показывать сырые или масштабированные значения
+        show_raw = self.chk_raw.isChecked()
+
+        # Готовим строки (ускоряет при больших объёмах)
+        # str() заранее, чтобы не повторять в цикле
+        idx_strs    = [str(v) for v in idxs]
+        raw_strs    = [str(v) for v in raws]
+        scaled_strs = raw_strs if show_raw else [f"{v:.6g}" for v in scaled]
+
+        # Флаги необновляемых ячеек (только выбор/просмотр)
+        flags_ro = QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled
+
+        # Локальный шорткат для быстрой установки текста в ячейку
+        def _set_text(row, col, text):
+            item = tbl.item(row, col)
+            if item is None:
+                item = QtWidgets.QTableWidgetItem(text)
+                item.setFlags(flags_ro)
+                tbl.setItem(row, col, item)
+            else:
+                # обновим текст только при изменении (немного экономит на больших данных)
+                if item.text() != text:
+                    item.setText(text)
+                if item.flags() != flags_ro:
+                    item.setFlags(flags_ro)
+
+        # Основной цикл
+        for row in range(n):
+            iq_raw = iqs[row]
+            is_signed = (iq_raw & SIGN_BIT_MASK) != 0
+            frac_bits = iq_raw & FRAC_MASK_FULL
+            iq_disp = f"{frac_bits}{'s' if is_signed else 'u'}"
+
+            _set_text(row, 0, idx_strs[row])
+            _set_text(row, 1, names[row])
+            _set_text(row, 2, iq_disp)
+            _set_text(row, 3, raw_strs[row])
+            _set_text(row, 4, scaled_strs[row])
+
+        # Разморозка
+        tbl.blockSignals(False)
+        tbl.setUpdatesEnabled(True)
+        tbl.setSortingEnabled(prev_sorting)
+        tbl.viewport().update()
+
+
+    # ------------------------------ POLLING --------------------------------
+    def _toggle_polling(self):
+        if self._polling:
+            self._poll_timer.stop()
+            self._polling = False
+            self.btn_poll.setText("Start Polling")
+            self._log("[POLL] Stopped")
+        else:
+            interval = self.spin_interval.value()
+            self._poll_timer.start(interval)
+            self._polling = True
+            self.btn_poll.setText("Stop Polling")
+            self._log(f"[POLL] Started interval={interval}ms")
+        self._set_ui_busy(False) # Обновить доступность кнопок
+
+    def _on_poll_timeout(self):
+        self.request_values()
+
+    def _toggle_ll_polling(self):
+        """Включает и выключает поллинг для LowLevel вкладки."""
+        if self._ll_polling:
+            self._ll_poll_timer.stop()
+            self._ll_polling = False
+            self.btn_ll_poll.setText("Start Polling")
+            self._log("[LL POLL] Stopped")
+        else:
+            if not self._ll_current_var_info:
+                self._log("[LL POLL] Cannot start: no variable selected.")
+                return
+            interval = self.spin_ll_interval.value()
+            self._ll_poll_timer.start(interval)
+            self._ll_polling = True
+            self.btn_ll_poll.setText("Stop Polling")
+            self._log(f"[LL POLL] Started interval={interval}ms")
+        self._set_ui_busy(False) # Обновить доступность кнопок
+
+    def _on_ll_poll_timeout(self):
+        """Слот таймера поллинга для LowLevel."""
+        self.request_lowlevel_once()
+        
+    def _on_ll_variable_prepared(self, var_info: dict):
+        """Срабатывает при выборе переменной в селекторе."""
+        self._ll_current_var_info = var_info
+        self._log(f"[LL] Selected variable '{var_info['path']}' @ {var_info['address_hex']}")
+        # Сбрасываем старые значения
+        self.ll_val_status.setText("-")
+        self.ll_val_rettype.setText("-")
+        self.ll_val_raw.setText("-")
+        self.ll_val_scaled.setText("-")
+
+    # ------------------------------ HELPERS --------------------------------
+    def _toggle_index_base(self, st):
+        # ... (код без изменений)
+        val = self.spin_index.value()
+        if st == QtCore.Qt.Checked:
+            self.spin_index.setDisplayIntegerBase(16); self.spin_index.setPrefix("0x")
+        else:
+            self.spin_index.setDisplayIntegerBase(10); self.spin_index.setPrefix("")
+        self.spin_index.setValue(val)
+
+    def _set_ui_busy(self, busy: bool):
+        # Блокируем кнопки в зависимости от состояния 'busy' и 'polling'
+        
+        # Watch tab
+        can_use_watch = not busy and not self._polling
+        self.btn_read_service.setEnabled(can_use_watch)
+        self.btn_read_values.setEnabled(can_use_watch)
+        
+        # LowLevel tab
+        can_use_ll = not busy and not self._ll_polling
+        self.btn_ll_read.setEnabled(can_use_ll)
+
+    def _on_serial_error(self, err):
+        # ... (код без изменений)
+        if err == QtSerialPort.QSerialPort.NoError: return
+        self._log(f"[SERIAL ERR] {self.serial.errorString()} ({err})")
+        if self._busy: self._end_txn()
+
+    # ------------------------------ LOGGING --------------------------------
+    def _log(self, msg: str):
+        # ... (код без изменений)
+        if not self.log_spoiler.getState():
+            return
+        ts = datetime.datetime.now().strftime('%H:%M:%S.%f')[:-3]
+        self.txt_log.append(f"{ts} {msg}")
+
+    def _log_frame(self, data: bytes, *, tx: bool):
+        # ... (код без изменений)
+        if not self.log_spoiler.getState():
+            return
+        tag = 'TX' if tx else 'RX'
+        hexs = ' '.join(f"{b:02X}" for b in data)
+        ascii_part = ''.join(chr(b) if 32 <= b < 127 else '.' for b in data)
+        self._log(f"[{tag}] {hexs} |{ascii_part}|")
+
+
+# ---------------------------------------------------------- Demo harness ---
+class _DemoWindow(QtWidgets.QMainWindow):
+    def __init__(self):
+        super().__init__()
+        self.setWindowTitle("DebugVar Terminal")
+        self.term = DebugTerminalWidget(self)
+        self.setCentralWidget(self.term)
+        self.term.nameRead.connect(self._on_name)
+        self.term.valueRead.connect(self._on_value)
+        self.term.llValueRead.connect(self._on_ll_value)
+
+    def _on_name(self, index, status, iq, name):
+        return
+        print(f"Name idx={index} status={status} iq={iq} name='{name}'")
+
+    def _on_value(self, index, status, iq, raw16, floatVal):
+        return
+        print(f"Value idx={index} status={status} iq={iq} raw={raw16} val={floatVal}")
+
+    def _on_ll_value(self, addr, status, rettype_raw, raw16, scaled):
+        return
+        print(f"LL addr=0x{addr:06X} status={status} type=0x{rettype_raw:02X} raw={raw16} scaled={scaled}")
+
+    def format_address(addr_text: str) -> str:
+        try:
+            value = int(addr_text, 16)
+        except ValueError:
+            value = 0
+        return f"0x{value:06X}"
+
+    def closeEvent(self, event):
+        self.setCentralWidget(None)
+        if self.term:
+            self.term.deleteLater(); self.term = None
+        super().closeEvent(event)
+
+# ------------------------------- Demo --------------------------------------
+if __name__ == "__main__":
+    import sys
+    app = QtWidgets.QApplication(sys.argv)
+    win = _DemoWindow(); win.show()
+    sys.exit(app.exec_())

Src/var_selector_table.py

@@ -1,86 +1,64 @@
-import re
+# variable_select_widget.py
+import pickle
+import hashlib
+from typing import List, Dict, Any, Optional
+
 from PySide2.QtWidgets import (
-    QWidget, QTreeWidget, QTreeWidgetItem, QVBoxLayout, QLineEdit, 
+    QWidget, QTreeWidget, QTreeWidgetItem, QVBoxLayout, QLineEdit,
     QHeaderView, QCompleter
 )
 from PySide2.QtGui import QKeyEvent
 from PySide2.QtCore import Qt, QStringListModel
-import pickle
-import time
-import hashlib
 
+from path_hints import PathHints, canonical_key, split_path_tokens
+
+
+# ------------------------------------------------------------------
+# utils
+# ------------------------------------------------------------------
 def compute_vars_hash(vars_list):
     return hashlib.sha1(pickle.dumps(vars_list)).hexdigest()
 
-# Вспомогательные функции, которые теперь будут использоваться виджетом
-def split_path(path):
-    """
-    Разбивает путь на компоненты:
-    - 'foo[2].bar[1]->baz' → ['foo', '[2]', 'bar', '[1]', 'baz']
-    Если видит '-' в конце строки (без '>' после) — обрезает этот '-'
-    """
-    tokens = []
-    token = ''
-    i = 0
-    length = len(path)
-    while i < length:
-        c = path[i]
-        # Разделители: '->' и '.'
-        if c == '-' and i + 1 < length and path[i:i+2] == '->':
-            if token:
-                tokens.append(token)
-                token = ''
-            i += 2
-            continue
-        elif c == '-' and i == length - 1:
-            # '-' на конце строки без '>' после — просто пропускаем его
-            i += 1
-            continue
-        elif c == '.':
-            if token:
-                tokens.append(token)
-                token = ''
-            i += 1
-            continue
-        elif c == '[':
-            if token:
-                tokens.append(token)
-                token = ''
-            idx = ''
-            while i < length and path[i] != ']':
-                idx += path[i]
-                i += 1
-            if i < length and path[i] == ']':
-                idx += ']'
-                i += 1
-            tokens.append(idx)
-            continue
-        else:
-            token += c
-            i += 1
-    if token:
-        tokens.append(token)
-    return tokens
 
-
+def is_lazy_item(item: QTreeWidgetItem) -> bool:
-def is_lazy_item(item):
     return item.childCount() == 1 and item.child(0).text(0) == 'lazy_marker'
 
 
+# ------------------------------------------------------------------
+# VariableSelectWidget
+# ------------------------------------------------------------------
 class VariableSelectWidget(QWidget):
+    """
+    Виджет выбора переменных с деревом + строкой поиска + автодополнением.
+    Подсказки полностью через PathHints.
+    ВАЖНО: ожидается, что в данных (vars_list) каждое var['name'] — ПОЛНЫЙ ПУТЬ
+           (например: 'project.adc.status'), даже внутри children.
+    """
+
+    ROLE_NAME      = Qt.UserRole            # локальный хвост (display)
+    ROLE_VAR_DICT  = Qt.UserRole + 100      # исходный dict
+    ROLE_FULLPATH  = Qt.UserRole + 200      # полный путь
+
     def __init__(self, parent=None):
         super().__init__(parent)
-        self.expanded_vars = []
-        self.node_index = {}
-        self.is_autocomplete_on = True  # <--- ДОБАВИТЬ ЭТУ СТРОКУ
-        self._bckspc_pressed = False
-        self.manual_completion_active = False
-        self._vars_hash = None
 
-        # --- UI Элементы ---
+        # данные
+        self.expanded_vars: List[Dict[str, Any]] = []
+        self.is_autocomplete_on = True
+        self.manual_completion_active = False
+        self._bckspc_pressed = False
+        self._vars_hash: Optional[str] = None
+
+        # индекс: canonical_full_path -> item
+        self._item_by_canon: Dict[str, QTreeWidgetItem] = {}
+
+        # подсказки
+        self.hints = PathHints()
+
+        # --- UI ---
         self.search_input = QLineEdit(self)
         self.search_input.setPlaceholderText("Поиск...")
-        
+
         self.tree = QTreeWidget(self)
         self.tree.setHeaderLabels(["Имя переменной", "Тип"])
         self.tree.setSelectionMode(QTreeWidget.ExtendedSelection)
@@ -97,32 +75,58 @@ class VariableSelectWidget(QWidget):
         self.completer.setCaseSensitivity(Qt.CaseInsensitive)
         self.completer.setFilterMode(Qt.MatchContains)
         self.completer.setWidget(self.search_input)
+        self.completer.activated[str].connect(self.insert_completion)
 
-        # --- Layout ---
+        # layout
-        layout = QVBoxLayout(self)
+        lay = QVBoxLayout(self)
-        layout.setContentsMargins(0, 0, 0, 0)
+        lay.setContentsMargins(0, 0, 0, 0)
-        layout.addWidget(self.search_input)
+        lay.addWidget(self.search_input)
-        layout.addWidget(self.tree)
+        lay.addWidget(self.tree)
-        
+
-        # --- Соединения ---
+        # signals
-        #self.search_input.textChanged.connect(self.on_search_text_changed)
+        self.search_input.textChanged.connect(self.on_search_text_changed)
-        self.search_input.textChanged.connect(lambda text: self.on_search_text_changed(text))
         self.search_input.installEventFilter(self)
-        self.completer.activated[str].connect(lambda text: self.insert_completion(text))
 
-    # --- Публичные методы для управления виджетом снаружи ---
+    # ------------------------------------------------------------------
-    
+    # public api
+    # ------------------------------------------------------------------
     def set_autocomplete(self, enabled: bool):
-        """Включает или выключает режим автодополнения."""
         self.is_autocomplete_on = enabled
 
-    def set_data(self, vars_list):
+    def set_data(self, vars_list: List[Dict[str, Any]]):
-        """Основной метод для загрузки данных в виджет."""
+        """
+        Загружаем список переменных (формат: см. класс docstring).
+        """
+        # deepcopy
         self.expanded_vars = pickle.loads(pickle.dumps(vars_list, protocol=pickle.HIGHEST_PROTOCOL))
-        # self.build_completion_list() # Если нужна полная перестройка списка
-        self.populate_tree()
 
+        # rebuild hints из полного списка узлов (каждый узел уже с full_path)
+        self._rebuild_hints_from_vars(self.expanded_vars)
 
+        # rebuild tree
+        self.populate_tree(self.expanded_vars)
+
+    # ------------------------------------------------------------------
+    # hints builder: дети уже содержат ПОЛНЫЙ ПУТЬ
+    # ------------------------------------------------------------------
+    def _rebuild_hints_from_vars(self, vars_list: List[Dict[str, Any]]):
+        paths: List[tuple] = []
+
+        def walk(node: Dict[str, Any]):
+            full = node.get('name', '')
+            if full:
+                paths.append((full, node.get('type')))
+            for ch in node.get('children', []) or []:
+                walk(ch)
+
+        for v in vars_list:
+            walk(v)
+
+        self.hints.set_paths(paths)
+
+    # ------------------------------------------------------------------
+    # tree building
+    # ------------------------------------------------------------------
     def populate_tree(self, vars_list=None):
         if vars_list is None:
             vars_list = self.expanded_vars
@@ -130,477 +134,311 @@ class VariableSelectWidget(QWidget):
         new_hash = compute_vars_hash(vars_list)
         if self._vars_hash == new_hash:
             return
-
         self._vars_hash = new_hash
+
         self.tree.setUpdatesEnabled(False)
         self.tree.blockSignals(True)
         self.tree.clear()
-        self.node_index.clear()
+        self._item_by_canon.clear()
 
-        for var in vars_list:
+        # построим top-level из входного списка: определяем по глубине токенов
-            self.add_tree_item_lazy(None, var)
+        # (vars_list может содержать и глубокие узлы; выберем корни = те, чей full_path не имеет родителя в списке)
+        full_to_node = {v['name']: v for v in vars_list}
+        # но safer: просто добавляем все как top-level, если ты уже передаёшь только корни.
+        # Если в твоих данных vars_list == корни, просто сделаем:
+        for v in vars_list:
+            self._add_tree_item_lazy(None, v)
 
         self.tree.setUpdatesEnabled(True)
         self.tree.blockSignals(False)
+
         header = self.tree.header()
         header.setSectionResizeMode(QHeaderView.Interactive)
         header.setSectionResizeMode(1, QHeaderView.Stretch)
         self.tree.setColumnWidth(0, 400)
-        
+
-    def on_item_expanded(self, item):
+    def on_item_expanded(self, item: QTreeWidgetItem):
         if is_lazy_item(item):
             item.removeChild(item.child(0))
-            var = item.data(0, Qt.UserRole + 100)
+            var = item.data(0, self.ROLE_VAR_DICT)
             if var:
-                for child_var in var.get('children', []):
+                for ch in var.get('children', []) or []:
-                    self.add_tree_item_lazy(item, child_var)
+                    self._add_tree_item_lazy(item, ch)
 
-
+    # ------------------------------------------------------------------
-    def get_full_item_name(self, item):
+    # item creation (var['name'] — ПОЛНЫЙ ПУТЬ)
-        fullname = item.text(0)
+    # ------------------------------------------------------------------
-        # Заменяем '->' на '.'
+    def _add_tree_item_lazy(self, parent: Optional[QTreeWidgetItem], var: Dict[str, Any]):
-        fullname = fullname.replace('->', '.')
+        full_path = var.get('name', '')
-        fullname = fullname.replace('[', '.[')
-        return fullname
-
-    def add_tree_item_lazy(self, parent, var):
-        name = var['name']
         type_str = var.get('type', '')
-        item = QTreeWidgetItem([name, type_str])
+
-        item.setData(0, Qt.UserRole, name)
+        # здесь оставляем полный путь для отображения
-        full_name = self.get_full_item_name(item)
+        item = QTreeWidgetItem([full_path, type_str])
-        self.node_index[full_name.lower()] = item
+        item.setData(0, self.ROLE_NAME, full_path)  # теперь ROLE_NAME = полный путь
+        item.setData(0, self.ROLE_VAR_DICT, var)
+        item.setData(0, self.ROLE_FULLPATH, full_path)
 
         if "(bitfield:" in type_str:
             item.setDisabled(True)
-            self.set_tool(item, "Битовые поля недоступны для выбора")
+            self._set_tool(item, "Битовые поля недоступны для выбора")
 
+        # метаданные
         for i, attr in enumerate(['file', 'extern', 'static']):
             item.setData(0, Qt.UserRole + 1 + i, var.get(attr))
 
+        # в дерево
         if parent is None:
             self.tree.addTopLevelItem(item)
         else:
             parent.addChild(item)
 
-        # Если есть дети — добавляем заглушку (чтобы можно было раскрыть)
+        # lazy children
         if var.get('children'):
             dummy = QTreeWidgetItem(["lazy_marker"])
             item.addChild(dummy)
 
-        # Кэшируем детей для подгрузки по событию
+        # индекс
-        item.setData(0, Qt.UserRole + 100, var)  # Сохраняем var целиком
+        self._item_by_canon[canonical_key(full_path)] = item
 
-    
+    @staticmethod
-    def show_matching_path(self, item, path_parts, level=0):
+    def _tail_token(full_path: str) -> str:
-        node_name = item.text(0).lower()
+        toks = split_path_tokens(full_path)
-        node_parts = split_path(node_name)
+        return toks[-1] if toks else full_path
 
-        if 'project' in node_name:
+    # ------------------------------------------------------------------
-            a = 1
+    # filtering
+    # ------------------------------------------------------------------
+    def filter_tree(self):
+        """
+        Быстрый фильтр:
+        - без разделителей → substring по ЛОКАЛЬНОМУ имени top-level
+        - с разделителями → структурный (по токенам full_path)
+        """
+        text = (self.search_input.text() or '').strip()
+        low = text.lower()
+        parts = split_path_tokens(low) if low else []
+
+        # простой режим (нет ., ->, [):
+        if low and all(x not in low for x in ('.', '->', '[')):
+            for i in range(self.tree.topLevelItemCount()):
+                it = self.tree.topLevelItem(i)
+                full = (it.data(0, self.ROLE_FULLPATH) or '').lower()
+                it.setHidden(low not in full)
+            return
+
+        # структурный
+        for i in range(self.tree.topLevelItemCount()):
+            it = self.tree.topLevelItem(i)
+            self._show_matching_path(it, parts, 0)
+
+    def _show_matching_path(self, item: QTreeWidgetItem, path_parts: List[str], level: int = 0):
+        """
+        Сравниваем введённый путь (разбитый на токены) с ПОЛНЫМ ПУТЁМ узла.
+        Алгоритм: берём полный путь узла, разбиваем в токены, берём уровень level,
+        и сравниваем с соответствующим токеном path_parts[level].
+        """
+        full = (item.data(0, self.ROLE_FULLPATH) or '').lower()
+        node_parts = split_path_tokens(full)
 
         if level >= len(path_parts):
-            # Путь полностью пройден — показываем только этот узел (без раскрытия всех детей)
             item.setHidden(False)
             item.setExpanded(False)
             return True
 
         if level >= len(node_parts):
-            # Уровень поиска больше длины пути узла — скрываем
+            item.setHidden(True)
-            item.setHidden(False)
+            return False
 
         search_part = path_parts[level]
         node_part = node_parts[level]
 
         if search_part == node_part:
-            # Точное совпадение — показываем узел, идём вглубь только по совпадениям
             item.setHidden(False)
             matched_any = False
             self.on_item_expanded(item)
             for i in range(item.childCount()):
-                child = item.child(i)
+                ch = item.child(i)
-                if self.show_matching_path(child, path_parts, level + 1):
+                if self._show_matching_path(ch, path_parts, level + 1):
                     matched_any = True
             item.setExpanded(matched_any)
             return matched_any or item.childCount() == 0
 
         elif node_part.startswith(search_part):
-            # Неполное совпадение — показываем только этот узел, детей скрываем, не раскрываем
             item.setHidden(False)
             item.setExpanded(False)
             return True
-        
+
-        elif search_part in node_part and (level == len(path_parts)-1):
+        elif search_part in node_part and (level == len(path_parts) - 1):
-            # Неполное совпадение — показываем только этот узел, детей скрываем, не раскрываем
             item.setHidden(False)
             item.setExpanded(False)
             return True
 
         else:
-            # Несовпадение — скрываем
             item.setHidden(True)
             return False
 
-
+    # ------------------------------------------------------------------
-    def filter_tree(self):
+    # completions (ONLY PathHints)
-        text = self.search_input.text().strip().lower()
+    # ------------------------------------------------------------------
-        path_parts = split_path(text) if text else []
+    def update_completions(self, text: Optional[str] = None) -> List[str]:
-
-        if '.' not in text and '->' not in text and '[' not in text and text != '':
-            for i in range(self.tree.topLevelItemCount()):
-                item = self.tree.topLevelItem(i)
-                name = item.text(0).lower()
-                if text in name:
-                    item.setHidden(False)
-                    # Не сбрасываем expanded, чтобы можно было раскрывать вручную
-                else:
-                    item.setHidden(True)
-        else:
-            for i in range(self.tree.topLevelItemCount()):
-                item = self.tree.topLevelItem(i)
-                self.show_matching_path(item, path_parts, 0)
-
-
-
-    def find_node_by_path(self, root_vars, path_list):
-        current_level = root_vars
-        node = None
-        for part in path_list:
-            node = None
-            for var in current_level:
-                if var['name'] == part:
-                    node = var
-                    break
-            if node is None:
-                return None
-            current_level = node.get('children', [])
-        return node
-    
-
-    def update_completions(self, text=None):
         if text is None:
-            text = self.search_input.text().strip()
+            text = self.search_input.text()
+        suggestions = self.hints.suggest(text)
+        self.completer.setModel(QStringListModel(suggestions))
+        if suggestions:
+            self.completer.complete()
         else:
-            text = text.strip()
+            self.completer.popup().hide()
+        return suggestions
 
-        normalized_text = text.replace('->', '.')
+    def insert_completion(self, full_path: str):
-        parts = split_path(text)
+        """
-        path_parts = parts[:-1] if parts else []
+        Пользователь выбрал подсказку (full_path).
-        prefix = parts[-1].lower() if parts else ''
+        Если у узла есть дети и пользователь не поставил разделитель —
-        ends_with_sep = text.endswith('.') or text.endswith('->') or text.endswith('[')
+        добавим '.'. Для массивного токена ('[0]') → добавим '.' тоже.
-        is_index_suggestion = text.endswith('[')
+        (Позже допилим '->' при наличии метаданных.)
+        """
+        node = self.hints.find_node(full_path)
+        text = full_path
 
-        completions = []
+        if node and node.children and not (
-
+            text.endswith('.') or text.endswith('->') or text.endswith('[')
-        def find_exact_node(parts):
+        ):
-            if not parts:
+            first_child = next(iter(node.children.values()))
-                return None
+            if first_child.name.startswith('['):
-            fullname = parts[0]
+                text += '['   # пользователь сразу начнёт ввод индекса
-            for p in parts[1:]:
-                fullname += '.' + p
-            return self.node_index.get(fullname.lower())
-
-        if is_index_suggestion:
-            base_text = text[:-1]  # убираем '['
-            parent_node = self.find_node_by_fullname(base_text)
-            if not parent_node:
-                base_text_clean = re.sub(r'\[\d+\]$', '', base_text)
-                parent_node = self.find_node_by_fullname(base_text_clean)
-            if parent_node:
-                seen = set()
-                for i in range(parent_node.childCount()):
-                    child = parent_node.child(i)
-                    if child.isHidden():
-                        continue
-                    cname = child.text(0)
-                    m = re.match(rf'^{re.escape(base_text)}\[(\d+)\]$', cname)
-                    if m and cname not in seen:
-                        completions.append(cname)
-                        seen.add(cname)
-            self.completer.setModel(QStringListModel(completions))
-            return completions
-
-        if ends_with_sep:
-            node = self.find_node_by_fullname(text[:-1])
-            if node:
-                for i in range(node.childCount()):
-                    child = node.child(i)
-                    if child.isHidden():
-                        continue
-                    completions.append(child.text(0))
-        elif not path_parts:
-            # Первый уровень — только если имя начинается с prefix
-            for i in range(self.tree.topLevelItemCount()):
-                item = self.tree.topLevelItem(i)
-                if item.isHidden():
-                    continue
-                name = item.text(0)
-                if name.lower().startswith(prefix):
-                    completions.append(name)
-        else:
-            node = find_exact_node(path_parts)
-            if node:
-                for i in range(node.childCount()):
-                    child = node.child(i)
-                    if child.isHidden():
-                        continue
-                    name = child.text(0)
-                    name_parts = child.data(0, Qt.UserRole + 10)
-                    if name_parts is None:
-                        name_parts = split_path(name)
-                        child.setData(0, Qt.UserRole + 10, name_parts)
-                    if not name_parts:
-                        continue
-                    last_part = name_parts[-1].lower()
-                    if prefix == '' or prefix in last_part:  # ← строго startswith
-                        completions.append(name)
-
-        self.completer.setModel(QStringListModel(completions))
-        self.completer.complete()
-        return completions
-
-
-    # Функция для поиска узла с полным именем
-    def find_node_by_fullname(self, name):
-        if name is None:
-            return None
-        normalized_name = name.replace('->', '.').lower()
-        normalized_name = normalized_name.replace('[', '.[').lower()
-        return self.node_index.get(normalized_name)
-        
-    def insert_completion(self, text):
-        node = self.find_node_by_fullname(text)
-        if node and node.childCount() > 0 and not (text.endswith('.') or text.endswith('->') or text.endswith('[')):
-            # Определяем разделитель по имени первого ребёнка
-            child_name = node.child(0).text(0)
-            if child_name.startswith(text + '->'):
-                text += '->'
-            elif child_name.startswith(text + '.'):
-                text += '.'
-            elif '[' in child_name:
-                text += '['  # для массивов
             else:
-                text += '.'  # fallback
+                text += '.'   # обычный переход
-                
+        if not self._bckspc_pressed:
-            if not self._bckspc_pressed:
-                self.search_input.setText(text)
-                self.search_input.setCursorPosition(len(text))
-
-            self.run_completions(text)
-        else:
             self.search_input.setText(text)
             self.search_input.setCursorPosition(len(text))
+        self.run_completions(text)
 
+    # ------------------------------------------------------------------
+    # events
+    # ------------------------------------------------------------------
     def eventFilter(self, obj, event):
         if obj == self.search_input and isinstance(event, QKeyEvent):
             if event.key() == Qt.Key_Space and event.modifiers() & Qt.ControlModifier:
                 self.manual_completion_active = True
-                text = self.search_input.text().strip()
+                self.run_completions(self.search_input.text())
-                self.run_completions(text)
             elif event.key() == Qt.Key_Escape:
-                # Esc — выключаем ручной режим и скрываем подсказки, если autocomplete выключен
                 if not self.is_autocomplete_on:
                     self.manual_completion_active = False
                     self.completer.popup().hide()
                     return True
-
             if event.key() == Qt.Key_Backspace:
-                self._bckspc_pressed = True 
+                self._bckspc_pressed = True
             else:
                 self._bckspc_pressed = False
-
         return super().eventFilter(obj, event)
-    
-    def run_completions(self, text):  
-        completions = self.update_completions(text)
 
-        if not self.is_autocomplete_on and self._bckspc_pressed:
+    def run_completions(self, text: str):
-            text = text[:-1]
+        if not self.is_autocomplete_on and not self.manual_completion_active:
-            
+            self.completer.popup().hide()
-        if len(completions) == 1 and completions[0].lower() == text.lower():
+            return
-            # Найдем узел с таким именем
+        self.update_completions(text)
-            def find_exact_item(name):
-                stack = [self.tree.topLevelItem(i) for i in range(self.tree.topLevelItemCount())]
-                while stack:
-                    node = stack.pop()
-                    if node.text(0).lower() == name.lower():
-                        return node
-                    for i in range(node.childCount()):
-                        stack.append(node.child(i))
-                return None
 
-            node = find_exact_item(completions[0])
+    def on_search_text_changed(self, text: str):
-            if node and node.childCount() > 0:
+        self.completer.setWidget(self.search_input)
-                # Используем первую подсказку, чтобы определить нужный разделитель                        
-                completions = self.update_completions(text + '.')    
-                if not completions:
-                    return
-                suggestion = completions[0]
-
-                # Ищем, какой символ идёт после текущего текста
-                separator = '.'
-                if suggestion.startswith(text):
-                    rest = suggestion[len(text):]
-                    if rest.startswith(text + '->'):
-                        separator += '->'
-                    elif rest.startswith(text + '.'):
-                        separator += '.'
-                    elif '[' in rest:
-                        separator += '['  # для массивов
-                    else:
-                        separator += '.'  # fallback
-                
-                if not self._bckspc_pressed:
-                    self.search_input.setText(text + separator)
-                completions = self.update_completions(text)
-                self.completer.setModel(QStringListModel(completions))
-                self.completer.complete()
-                return True
-
-        # Иначе просто показываем подсказки
-        self.completer.setModel(QStringListModel(completions))
-        if completions:
-            self.completer.complete()
-        return True
-
-    def on_search_text_changed(self, text):    
-        sender_widget = self.sender()
-        sender_name = sender_widget.objectName() if sender_widget else "Unknown Sender"
-
-        self.completer.setWidget(self.search_input) 
         self.filter_tree()
-        if text == None:
+        if text is None:
-            text = self.search_input.text().strip()
+            text = self.search_input.text()
         if self.is_autocomplete_on:
             self.run_completions(text)
         else:
-            # Если выключено, показываем подсказки только если флаг ручного вызова True
             if self.manual_completion_active:
                 self.run_completions(text)
             else:
                 self.completer.popup().hide()
-    
+
     def focusInEvent(self, event):
         if self.completer.widget() != self.search_input:
             self.completer.setWidget(self.search_input)
         super().focusInEvent(event)
 
-    def _custom_focus_in_event(self, event):
-        # Принудительно установить виджет для completer при получении фокуса
-        if self.completer.widget() != self.search_input:
-            self.completer.setWidget(self.search_input)
-        super(QLineEdit, self.search_input).focusInEvent(event) # Вызвать оригинальный обработчик
-
-
-    def build_completion_list(self):
-        completions = []
-
-        def recurse(var, prefix=''):
-            fullname = f"{prefix}.{var['name']}" if prefix else var['name']
-            completions.append(fullname)
-            for child in var.get('children', []):
-                recurse(child, fullname)
-
-        for v in self.expanded_vars:
-            recurse(v)
-        self.all_completions = completions
-
-    def set_tool(self, item, text):
-        item.setToolTip(0, text)
-        item.setToolTip(1, text)
-
-    def get_all_items(self):
-        """Возвращает все конечные (leaf) элементы, исключая битовые поля и элементы с детьми (реальными)."""
-        def collect_leaf_items(parent):
-            leaf_items = []
-            for i in range(parent.childCount()):
-                child = parent.child(i)
-                if child.isHidden():
-                    continue
-
-                # Если есть заглушка — раскрываем                
-                self.on_item_expanded(child)
-
-                if child.childCount() == 0:
-                    item_type = child.text(1)
-                    if item_type and 'bitfield' in str(item_type).lower():
-                        continue
-                    leaf_items.append(child)
-                else:
-                    leaf_items.extend(collect_leaf_items(child))
-            return leaf_items
-
-        all_leaf_items = []
-        for i in range(self.tree.topLevelItemCount()):
-            top = self.tree.topLevelItem(i)
-
-            # Раскрываем lazy, если надо
-            self.on_item_expanded(top)
-
-            if top.childCount() == 0:
-                item_type = top.text(1)
-                if item_type and 'bitfield' in str(item_type).lower():
-                    continue
-                all_leaf_items.append(top)
-            else:
-                all_leaf_items.extend(collect_leaf_items(top))
-        return all_leaf_items
-
-
-
-    def _get_internal_selected_items(self):
-        """Возвращает выделенные элементы и всех их потомков, включая lazy."""
-        selected = self.tree.selectedItems()
-        all_items = []
-
-        def collect_children(item):
-            # Раскрываем при необходимости
-            # Раскрываем lazy, если надо
-            self.on_item_expanded(item)
-
-            items = [item]
-            for i in range(item.childCount()):
-                child = item.child(i)
-                items.extend(collect_children(child))
-            return items
-
-        for item in selected:
-            all_items.extend(collect_children(item))
-
-        return all_items
-
-    def get_selected_items(self):
-        """Возвращает только конечные (leaf) выделенные элементы, исключая bitfield."""
-        selected = self.tree.selectedItems()
-        leaf_items = []
-        for item in selected:
-            # Раскрываем lazy, если надо
-            self.on_item_expanded(item)
-
-            # Если у узла нет видимых/выделенных детей — он лист
-            if all(item.child(i).isHidden() or not item.child(i).isSelected() for i in range(item.childCount())):
-                item_type = item.data(0, Qt.UserRole)
-                if item_type and 'bitfield' in str(item_type).lower():
-                    continue
-                leaf_items.append(item)
-        return leaf_items
-
-
-    def get_all_var_names(self):
-        """Возвращает имена всех конечных (leaf) переменных, исключая битовые поля и группы."""
-        return [item.text(0) for item in self.get_all_items() if item.text(0)]
-
-
-    def _get_internal_selected_var_names(self):
-        """Возвращает имена выделенных переменных."""
-        return [item.text(0) for item in self._get_internal_selected_items() if item.text(0)]
-
-
-    def get_selected_var_names(self):
-        """Возвращает имена только конечных (leaf) переменных из выделенных."""
-        return [item.text(0) for item in self.get_selected_items() if item.text(0)]
-
     def closeEvent(self, event):
         self.completer.setWidget(None)
         self.completer.deleteLater()
-        super().closeEvent(event)
+        super().closeEvent(event)
+
+    # ------------------------------------------------------------------
+    # lookup by full path
+    # ------------------------------------------------------------------
+    def find_item_by_fullpath(self, path: str) -> Optional[QTreeWidgetItem]:
+        return self._item_by_canon.get(canonical_key(path))
+
+    # ------------------------------------------------------------------
+    # tooltips
+    # ------------------------------------------------------------------
+    def _set_tool(self, item: QTreeWidgetItem, text: str):
+        item.setToolTip(0, text)
+        item.setToolTip(1, text)
+
+    # ------------------------------------------------------------------
+    # selection helpers
+    # ------------------------------------------------------------------
+    def get_all_items(self):
+        """Все leaf-узлы (подгружаем lazy)."""
+        def collect_leaf(parent):
+            leaves = []
+            for i in range(parent.childCount()):
+                ch = parent.child(i)
+                if ch.isHidden():
+                    continue
+                self.on_item_expanded(ch)
+                if ch.childCount() == 0:
+                    t = ch.text(1)
+                    if t and 'bitfield' in t.lower():
+                        continue
+                    leaves.append(ch)
+                else:
+                    leaves.extend(collect_leaf(ch))
+            return leaves
+
+        out = []
+        for i in range(self.tree.topLevelItemCount()):
+            top = self.tree.topLevelItem(i)
+            self.on_item_expanded(top)
+            if top.childCount() == 0:
+                t = top.text(1)
+                if t and 'bitfield' in t.lower():
+                    continue
+                out.append(top)
+            else:
+                out.extend(collect_leaf(top))
+        return out
+
+    def _get_internal_selected_items(self):
+        selected = self.tree.selectedItems()
+        all_items = []
+        def collect(item):
+            self.on_item_expanded(item)
+            res = [item]
+            for i in range(item.childCount()):
+                res.extend(collect(item.child(i)))
+            return res
+        for it in selected:
+            all_items.extend(collect(it))
+        return all_items
+
+    def get_selected_items(self):
+        selected = self.tree.selectedItems()
+        leaves = []
+        for it in selected:
+            self.on_item_expanded(it)
+            if all(it.child(i).isHidden() or not it.child(i).isSelected() for i in range(it.childCount())):
+                t = it.data(0, self.ROLE_NAME)
+                if t and isinstance(t, str) and 'bitfield' in t.lower():
+                    continue
+                leaves.append(it)
+        return leaves
+
+    def get_all_var_names(self):
+        return [it.data(0, self.ROLE_FULLPATH) for it in self.get_all_items() if it.data(0, self.ROLE_FULLPATH)]
+
+    def _get_internal_selected_var_names(self):
+        return [it.data(0, self.ROLE_FULLPATH) for it in self._get_internal_selected_items() if it.data(0, self.ROLE_FULLPATH)]
+
+    def get_selected_var_names(self):
+        return [it.data(0, self.ROLE_FULLPATH) for it in self.get_selected_items() if it.data(0, self.ROLE_FULLPATH)]

Src/var_table.py

@@ -1,10 +1,10 @@
 from PySide2.QtWidgets import (
     QTableWidget, QTableWidgetItem, QCheckBox, QComboBox, QLineEdit, QCompleter,
-    QAbstractItemView, QHeaderView, QLabel,
+    QAbstractItemView, QHeaderView, QLabel, QSpacerItem, QSizePolicy, QSpinBox,
     QDialog, QVBoxLayout, QHBoxLayout, QPushButton, QScrollArea, QWidget
 )
 from PySide2.QtGui import QColor, QBrush, QPalette
-from PySide2.QtCore import Qt
+from PySide2.QtCore import Qt, QSettings
 from enum import IntEnum
 from generate_debug_vars import type_map
 import time
@@ -60,6 +60,57 @@ class FilterDialog(QDialog):
         return [cb.text() for cb in self.checkboxes if cb.isChecked()]
 
 
+class SetSizeDialog(QDialog):
+    """
+    Диалоговое окно для выбора числового значения (размера).
+    """
+    def __init__(self, parent=None, initial_value=10, min_value=1, max_value=50, title="Укажите размер короткого имени"):
+        super().__init__(parent)
+        self.setWindowTitle(title)
+        self.setFixedSize(320, 120)  # Задаем фиксированный размер для аккуратного вида
+
+        # Основной вертикальный макет
+        main_layout = QVBoxLayout(self)
+
+        # Макет для ввода значения
+        input_layout = QHBoxLayout()
+        label = QLabel("Количество символов:", self)
+        
+        self.spin_box = QSpinBox(self)
+        self.spin_box.setRange(min_value, max_value)  # Устанавливаем диапазон допустимых значений
+        initial_value = parent._shortname_size
+        self.spin_box.setValue(initial_value)         # Устанавливаем начальное значение
+        self.spin_box.setFocus()                      # Устанавливаем фокус на поле ввода
+
+        input_layout.addWidget(label)
+        input_layout.addWidget(self.spin_box)
+        main_layout.addLayout(input_layout)
+
+        # Добавляем пустое пространство для лучшего разделения
+        main_layout.addSpacerItem(QSpacerItem(20, 20, QSizePolicy.Minimum, QSizePolicy.Expanding))
+
+        # Макет для кнопок
+        btn_layout = QHBoxLayout()
+        btn_layout.addStretch() # Добавляем растягивающийся элемент, чтобы кнопки были справа
+        
+        btn_ok = QPushButton("OK")
+        btn_cancel = QPushButton("Отмена")
+        
+        btn_layout.addWidget(btn_ok)
+        btn_layout.addWidget(btn_cancel)
+
+        main_layout.addLayout(btn_layout)
+
+        # Подключение сигналов к слотам
+        btn_ok.clicked.connect(self.accept)       # При нажатии "OK" диалог закроется со статусом "Accepted"
+        btn_cancel.clicked.connect(self.reject)   # При нажатии "Отмена" - со статусом "Rejected"
+
+    def get_selected_size(self):
+        """
+        Возвращает значение, выбранное в QSpinBox.
+        """
+        return self.spin_box.value()
+
 class CtrlScrollComboBox(QComboBox):
     def wheelEvent(self, event):
         if event.modifiers() & Qt.ControlModifier:
@@ -83,6 +134,11 @@ class VariableTableWidget(QTableWidget):
         ])
         self.setEditTriggers(QAbstractItemView.AllEditTriggers)
         self.var_list = []
+        # Инициализируем QSettings с именем организации и приложения
+        self.settings = QSettings("SET", "DebugVarEdit_VarTable")
+        # Восстанавливаем сохранённое состояние, если есть
+        shortsize = self.settings.value("shortname_size", True, type=int)
+        self._shortname_size = shortsize
         
         self.type_options = list(dict.fromkeys(type_map.values()))
         self.pt_types_all = [t.replace('pt_', '') for t in self.type_options]
@@ -197,6 +253,8 @@ class VariableTableWidget(QTableWidget):
             ret_combo = CtrlScrollComboBox()
             ret_combo.addItems(self.iq_types)
             value = var['return_type'].replace('t_', '')
+            if value not in self.iq_types:
+                ret_combo.addItem(value)
             ret_combo.setCurrentText(value)
             ret_combo.currentTextChanged.connect(on_change_callback)
             ret_combo.setStyleSheet(style_with_padding)
@@ -231,7 +289,7 @@ class VariableTableWidget(QTableWidget):
             t3 = time.time()
             shortname = short_name_edit.text() if short_name_edit else ""
 
-            long_shortname = len(shortname) > 10
+            long_shortname = len(shortname) > self._shortname_size
             found = name in var_names_set
 
             color = None
@@ -293,6 +351,13 @@ class VariableTableWidget(QTableWidget):
             if dlg.exec_():
                 self._ret_type_filter = dlg.get_selected()
                 self.update_comboboxes({rows.ret_type: self._ret_type_filter})
+                
+        elif logicalIndex == rows.short_name:
+            dlg = SetSizeDialog(self)
+            if dlg.exec_():
+                self._shortname_size = dlg.get_selected_size()   
+                self.settings.setValue("shortname_size", self._shortname_size)             
+                self.check()
 
 
 
@@ -312,10 +377,9 @@ class VariableTableWidget(QTableWidget):
                     combo.clear()
                     
                     combo.addItems(allowed_items)
-                    if current in allowed_items:
+                    if current not in allowed_items:
-                        combo.setCurrentText(current)
+                        combo.addItem(current)
-                    else:
+                    combo.setCurrentText(current)
-                        combo.setCurrentIndex(0)
                     combo.blockSignals(False)
 
 

debug_tools.c

@@ -1,134 +1,288 @@
 #include "debug_tools.h"
-#include "IQmathLib.h"
 
-DebugLowLevel_t debug_ll = DEBUG_LOWLEVEL_INIT;
+#if !defined(GLOBAL_Q)
+#define GLOBAL_Q 16
+#endif
+
+
+DebugLowLevel_t debug_ll = DEBUG_LOWLEVEL_INIT; ///< Ñòðóêòóðà îòëàäêè íèæíåãî óðîâíÿ (èíèöèàëèçàöèÿ)
+
+static int getDebugVar(DebugVar_t *var, int32_t *int_var, float *float_var);
+static int convertDebugVarToIQx(DebugVar_t *var, int32_t *ret_var);
+static int iqTypeToQ(DebugVarIQType_t t);
+static int is_addr_in_allowed_ranges(uint32_t addr_val, const AddrRange_t *ranges, int count);
+
+/**
+ * @brief Ìàññèâ äîïóñòèìûõ äèàïàçîíîâ àäðåñîâ äëÿ îòëàäî÷íîãî ÷òåíèÿ
+ *
+ * Âêëþ÷àåò â ñåáÿ íàáîð äèàïàçîíîâ ïàìÿòè, ðàçðåø¸ííûõ äëÿ äîñòóïà
+ * ôóíêöèåé Debug_LowLevel_ReadVar.
+ */
+static const AddrRange_t debug_allowed_ranges[] = ALLOWED_ADDRESS_RANGES;
+/**
+ * @brief Êîëè÷åñòâî ýëåìåíòîâ â ìàññèâå debug_allowed_ranges
+ */
+static const int debug_allowed_ranges_count = sizeof(debug_allowed_ranges) / sizeof(debug_allowed_ranges[0]);
 
-static int getDebugVar(DebugVar_t *var, long *int_var, float *float_var);
-static int convertDebugVarToIQx(DebugVar_t *var, long *ret_var);
 
 ///////////////////////////----EXAPLE-----//////////////////////////////
-long var_numb = 1;
+int var_numb = 1;           ///< Ïðèìåð ïåðåìåííîé äëÿ îòëàäêè
-DebugVarName_t var_name;
+DebugVarName_t var_name;    ///< Èìÿ ïåðåìåííîé
-long return_var;
+int32_t return_var;         ///< Ïåðåìåííàÿ äëÿ âîçâðàòà ðåçóëüòàòà
-long return_ll_var;
+int32_t return_ll_var;      ///< Âîçâðàùàåìîå çíà÷åíèå ñ íèæíåãî óðîâíÿ
-int result;
+int result;                 ///< Ïåðåìåííàÿ ðåçóëüòàòà
-char ext_date[] = {7, 233, 11, 07, 16, 50};
+DateTime_t ext_date = {2025, 11, 07, 16, 50}; ///< Ïðèìåð âíåøíåé äàòû ñáîðêè
+
+/**
+  * @brief    Ïðèìåð èñïîëüçîâàíèÿ ôóíêöèé îòëàäêè.
+  * @details  Äåìîíñòðàöèîííàÿ ôóíêöèÿ äëÿ ðàáîòû ñ ïåðåìåííûìè îòëàäêè.
+  */
 void Debug_Test_Example(void)
 {
+    return;
     result = Debug_ReadVar(var_numb, &return_var);
-    result = Debug_ReadVarName(var_numb, var_name);
+    result = Debug_ReadVarName(var_numb, var_name, 0);
 
 
-    if(Debug_LowLevel_Initialize(ext_date) == 0)
+    if(Debug_LowLevel_Initialize(&ext_date) == 0)
         result = Debug_LowLevel_ReadVar(&return_ll_var);
 }
 
 ///////////////////////////----PUBLIC-----//////////////////////////////
-int Debug_ReadVar(int var_ind, long *return_long)
+
+/**
+  * @brief    ×èòàåò ïåðåìåííóþ ïî èíäåêñó.
+  * @param    var_ind      – èíäåêñ ïåðåìåííîé.
+  * @param    return_32b   – óêàçàòåëü äëÿ âîçâðàòà ðåçóëüòàòà.
+  * @return   int          – 0: óñïåõ, 1: îøèáêà.
+  * @details  Èñïîëüçóåòñÿ äëÿ ÷òåíèÿ çíà÷åíèé ïåðåìåííûõ ïî èõ èíäåêñó.
+  */
+int Debug_ReadVar(int var_ind, int32_t *return_32b)
 {
-    if(return_long == NULL)
+    int32_t tmp_var;
-        return 1;
-    long tmp_var;
 
+    if(return_32b == NULL)
+        return DEBUG_ERR_INTERNAL;
     if (var_ind >= DebugVar_Qnt)
-        return 1;
+        return DEBUG_ERR_VAR_NUMB;
-    if((dbg_vars[var_numb].ptr_type == pt_struct) || (dbg_vars[var_numb].ptr_type == pt_union) ||
+    if((dbg_vars[var_ind].ptr_type == pt_struct) || (dbg_vars[var_ind].ptr_type == pt_union) ||
-            (dbg_vars[var_numb].ptr_type == pt_unknown))
+            (dbg_vars[var_ind].ptr_type == pt_unknown))
-        return 1;
+        return DEBUG_ERR_INVALID_VAR;
 
-
+    return convertDebugVarToIQx(&dbg_vars[var_ind], return_32b);
-
-    return convertDebugVarToIQx(&dbg_vars[var_numb], return_long);
 }
 
-int Debug_ReadVarName(int var_ind, DebugVarName_t name_ptr)
+/**
+  * @brief    ×èòàåò âîçâðàùàåìûé òèï (IQ) ïåðåìåííîé ïî èíäåêñó.
+  * @param    var_ind      – èíäåêñ ïåðåìåííîé.
+  * @param    vartype       – óêàçàòåëü äëÿ âîçâðàòà òèïà.
+  * @return   int          – 0: óñïåõ, 1: îøèáêà.
+  * @details  Èñïîëüçóåòñÿ äëÿ ÷òåíèÿ âîçâðàùàåìîãî òèïà (IQ) ïåðåìåííûõ ïî èõ èíäåêñó.
+  */
+int Debug_ReadVarReturnType(int var_ind, int *vartype)
 {
-    if(name_ptr == NULL)
+    int rettype;
-        return 1;
+    if(vartype == NULL)
-
+        return DEBUG_ERR_INTERNAL;
     if (var_ind >= DebugVar_Qnt)
-        return 1;
+        return DEBUG_ERR_VAR_NUMB;
+    if((dbg_vars[var_ind].ptr_type == pt_struct) || (dbg_vars[var_ind].ptr_type == pt_union) ||
+            (dbg_vars[var_ind].ptr_type == pt_unknown))
+        return DEBUG_ERR_INVALID_VAR;
 
-    int i;
+    *vartype = iqTypeToQ(dbg_vars[var_ind].return_type);
-    // Êîïèðîâàíèå ñ çàùèòîé îò ïåðåïîëíåíèÿ è ÿâíîé îñòàíîâêîé ïî '\0'
-    for (i = 0; i < sizeof(dbg_vars[var_numb].name); i++)
-    {
-        name_ptr[i] = dbg_vars[var_numb].name[i];
-        if (dbg_vars[var_numb].name[i] == '\0')
-            break;
-    }
-    // Ãàðàíòèðîâàííîå çàâåðøåíèå ñòðîêè (íà ñëó÷àé, åñëè â var->name íå áûëî '\0')
-    name_ptr[sizeof(dbg_vars[var_numb].name) - 1] = '\0';
 
     return 0;
 }
 
-
+/**
-
+  * @brief    ×èòàåò òèï ïåðåìåííîé ïî èíäåêñó.
-int Debug_LowLevel_ReadVar(long *return_long)
+  * @param    var_ind      – èíäåêñ ïåðåìåííîé.
+  * @param    vartype      – óêàçàòåëü äëÿ âîçâðàòà òèïà.
+  * @return   int          – 0: óñïåõ, 1: îøèáêà.
+  * @details  Èñïîëüçóåòñÿ äëÿ ÷òåíèÿ òèïà ïåðåìåííûõ ïî èõ èíäåêñó.
+  */
+int Debug_ReadVarType(int var_ind, int *vartype)
 {
-    if (return_long == NULL)
+    int rettype;
-        return 1;
+    if(vartype == NULL)
-    if (debug_ll.isVerified == 0)
+        return DEBUG_ERR_INTERNAL;
-        return 1;
+    if (var_ind >= DebugVar_Qnt)
+        return DEBUG_ERR_VAR_NUMB;
+    if((dbg_vars[var_ind].ptr_type == pt_struct) || (dbg_vars[var_ind].ptr_type == pt_union) ||
+            (dbg_vars[var_ind].ptr_type == pt_unknown))
+        return DEBUG_ERR_INVALID_VAR;
 
-    char *addr = debug_ll.dbg_var.Ptr;
+    *vartype = dbg_vars[var_ind].ptr_type;
-    unsigned long addr_val = (unsigned long)addr;
 
-    // Ðàçðåø¸ííûå äèàïàçîíû ïàìÿòè (èç .cmd ôàéëà)
+    switch(dbg_vars[var_ind].ptr_type)
-    if (!(
+    {
-        (addr_val <= 0x0007FF) ||  // RAMM0 + RAMM1
+        case pt_int8:
-        (addr_val >= 0x008120 && addr_val <= 0x009FFC) ||  // L0 + L1 SARAM
+        case pt_int16:
-        (addr_val >= 0x3F8000 && addr_val <= 0x3F9FFF) ||  // PRAMH0 + DRAMH0
+        case pt_int32:
-        (addr_val >= 0x3FF000 && addr_val <= 0x3FFFFF) ||  // BOOTROM + RESET
+        case pt_float:
-        (addr_val >= 0x080002 && addr_val <= 0x09FFFF) ||  // RAMEX1
+            *vartype = dbg_vars[var_ind].ptr_type | DEBUG_SIGNED_VAR;
-        (addr_val >= 0x0F0000 && addr_val <= 0x0FFEFF) ||  // RAMEX4
+            break;
-        (addr_val >= 0x100002 && addr_val <= 0x103FFF) ||  // RAMEX0 + RAMEX2 + RAMEX01
+
-        (addr_val >= 0x102000 && addr_val <= 0x103FFF)     // RAMEX2
+        default:
-    )) {
+            *vartype = dbg_vars[var_ind].ptr_type;
-        return 2; // Çàïðåù¸ííûé àäðåñ — íåëüçÿ ÷èòàòü
+            break;
     }
 
-    return convertDebugVarToIQx(&debug_ll.dbg_var, return_long);
+    return 0;
-;
 }
 
-
+/**
-int Debug_LowLevel_Initialize(const char* external_date)
+  * @brief    ×èòàåò èìÿ ïåðåìåííîé ïî èíäåêñó.
+  * @param    var_ind    – èíäåêñ ïåðåìåííîé.
+  * @param    name_ptr   – óêàçàòåëü íà áóôåð èìåíè (DebugVarName_t).
+  * @return   int        – 0: óñïåõ, 1: îøèáêà.
+  * @details  Êîïèðóåò èìÿ ïåðåìåííîé â ïðåäîñòàâëåííûé áóôåð.
+  */
+int Debug_ReadVarName(int var_ind, DebugVarName_t name_ptr, int *length)
 {
-    if (external_date == NULL) {
+    int i;
-        return -1;
+
+    if(name_ptr == NULL)
+        return DEBUG_ERR_INTERNAL;
+
+    if (var_ind >= DebugVar_Qnt)
+        return DEBUG_ERR_VAR_NUMB;
+
+    // Êîïèðîâàíèå ñ çàùèòîé îò ïåðåïîëíåíèÿ è ÿâíîé îñòàíîâêîé ïî '\0'
+    for (i = 0; i < sizeof(dbg_vars[var_ind].name); i++)
+    {
+        name_ptr[i] = dbg_vars[var_ind].name[i];
+        if (dbg_vars[var_ind].name[i] == '\0')
+        {
+            if(length != NULL)
+                *length = i;
+            break;
+        }
+    }
+    // Ãàðàíòèðîâàííîå çàâåðøåíèå ñòðîêè (íà ñëó÷àé, åñëè â var->name íå áûëî '\0')
+    name_ptr[sizeof(dbg_vars[var_ind].name) - 1] = '\0';
+
+    return 0;
+}
+
+/**
+  * @brief    ×èòàåò çíà÷åíèå ïåðåìåííîé îòëàäêè ñ íèæíåãî óðîâíÿ.
+  * @param    return_32b  – óêàçàòåëü íà ïåðåìåííóþ, êóäà çàïèñûâàåòñÿ ðåçóëüòàò.
+  * @return   int         – 0: óñïåõ, 1: îøèáêà, 2: íåäîïóñòèìûé àäðåñ.
+  * @details  Èñïîëüçóåò àäðåññ, ïåðåäàâàåìûé ñ òåðìèíàëêè äëÿ ïîëó÷åíèÿ çíà÷åíèÿ.
+  */
+int Debug_LowLevel_ReadVar(int32_t *return_32b)
+{
+    uint8_t *addr = debug_ll.dbg_var.Ptr;
+    uint32_t addr_val = (uint32_t)addr;
+
+    if (return_32b == NULL)
+        return DEBUG_ERR_INTERNAL;
+    if (debug_ll.isVerified == 0)
+        return DEBUG_ERR_DATATIME;
+
+    if (is_addr_in_allowed_ranges(addr_val, debug_allowed_ranges, debug_allowed_ranges_count) != 0)
+    {
+        return DEBUG_ERR_ADDR; // Çàïðåù¸ííûé àäðåñ — íåëüçÿ ÷èòàòü
     }
 
-    // Ïðåîáðàçóåì external_date â ñòðóêòóðó
+    return convertDebugVarToIQx(&debug_ll.dbg_var, return_32b);
-    DateTime_t ext;
+}
-    ext.year   = (external_date[0] << 8) | external_date[1];
+
-    ext.day    = external_date[2];
+/**
-    ext.month  = external_date[3];
+  * @brief    Èíèöèàëèçàöèÿ îòëàäêè íà íèæíåì óðîâíå ïî äàòå ñáîðêè.
-    ext.hour   = external_date[4];
+  * @param    external_date – ñòðóêòóðà ñ äàòîé DateTime_t
-    ext.minute = external_date[5];
+  * @return   int           – 0: ñîâïàäàåò, 1: íå ñîâïàäàåò, -1: îøèáêà.
+  * @details  Ñðàâíèâàåò äàòó êîìïèëÿöèè ñ çàïðàøèâàåìîé è èíèöèàëèçèðóåò îòëàäî÷íóþ ïåðåìåííóþ.
+  */
+int Debug_LowLevel_Initialize(DateTime_t* external_date)
+{
+    if (external_date == NULL) {
+        return DEBUG_ERR_INTERNAL;
+    }
 
 
     // Ñðàâíåíèå âñåõ ïîëåé
-    if (ext.year   == debug_ll.build_date.year &&
+    if (external_date->year   == debug_ll.build_date.year &&
-        ext.month  == debug_ll.build_date.month &&
+        external_date->month  == debug_ll.build_date.month &&
-        ext.day    == debug_ll.build_date.day &&
+        external_date->day    == debug_ll.build_date.day &&
-        ext.hour   == debug_ll.build_date.hour &&
+        external_date->hour   == debug_ll.build_date.hour &&
-        ext.minute == debug_ll.build_date.minute)
+        external_date->minute == debug_ll.build_date.minute)
     {
         debug_ll.isVerified = 1;
         return 0;  // Ñîâïàëî
     }
     debug_ll.isVerified = 0;
 
-    return 1;  // Íå ñîâïàëî
+    return DEBUG_ERR_DATATIME;  // Íå ñîâïàëî
+}
+
+
+/**
+  * @brief    ×èòàåò âîçâðàùàåìûé òèï (IQ) íèçêîóðîâíåíî çàäàííîé ïåðåìåííîé.
+  * @param    var_ind      – èíäåêñ ïåðåìåííîé.
+  * @param    vartype       – óêàçàòåëü äëÿ âîçâðàòà òèïà.
+  * @return   int          – 0: óñïåõ, 1: îøèáêà.
+  * @details  Èñïîëüçóåòñÿ äëÿ ÷òåíèÿ âîçâðàùàåìîãî òèïà (IQ) ïåðåìåííûõ ïî èõ èíäåêñó.
+  */
+int Debug_LowLevel_ReadVarReturnType(int *vartype)
+{
+    int rettype;
+    if(vartype == NULL)
+        return DEBUG_ERR_INTERNAL;
+    if((debug_ll.dbg_var.ptr_type == pt_struct) || (debug_ll.dbg_var.ptr_type == pt_union) ||
+            (debug_ll.dbg_var.ptr_type == pt_unknown))
+        return DEBUG_ERR_INVALID_VAR;
+
+    *vartype = iqTypeToQ(debug_ll.dbg_var.return_type);
+
+    return 0;
+}
+
+/**
+  * @brief    ×èòàåò òèï íèçêîóðîâíåíî çàäàííîé ïåðåìåííîé.
+  * @param    var_ind      – èíäåêñ ïåðåìåííîé.
+  * @param    vartype      – óêàçàòåëü äëÿ âîçâðàòà òèïà.
+  * @return   int          – 0: óñïåõ, 1: îøèáêà.
+  */
+int Debug_LowLevel_ReadVarType(int *vartype)
+{
+    int rettype;
+    if(vartype == NULL)
+        return DEBUG_ERR_INTERNAL;
+    if((debug_ll.dbg_var.ptr_type == pt_struct) || (debug_ll.dbg_var.ptr_type == pt_union) ||
+            (debug_ll.dbg_var.ptr_type == pt_unknown))
+        return DEBUG_ERR_INVALID_VAR;
+
+    *vartype = debug_ll.dbg_var.ptr_type;
+
+    switch(debug_ll.dbg_var.ptr_type)
+    {
+        case pt_int8:
+        case pt_int16:
+        case pt_int32:
+        case pt_float:
+            *vartype = debug_ll.dbg_var.ptr_type | DEBUG_SIGNED_VAR;
+            break;
+
+        default:
+            *vartype = debug_ll.dbg_var.ptr_type;
+            break;
+    }
+
+    return 0;
 }
 
 
 
-
-
 /////////////////////----INTERNAL FUNCTIONS-----////////////////////////
+/**
+  * @brief    Ïðåîáðàçóåò òèï IQ ïåðåìåííîé â ÷èñëî áèòîâ äëÿ ñäâèãà(Q-ôàêòîð).
+  * @param    t   – òèï IQ (ïåðå÷èñëåíèå DebugVarIQType_t).
+  * @return   int – Q-ôàêòîð (íàïðèìåð, 24), 0: åñëè t_iq_none, -1: îøèáêà.
+  * @details  Ñîïîñòàâëÿåò òèï IQ ïåðåìåííîé ñ ñîîòâåòñòâóþùèì Q-çíà÷åíèåì.
+  */
 static int iqTypeToQ(DebugVarIQType_t t)
 {
     if (t == t_iq_none)
@@ -138,47 +292,53 @@ static int iqTypeToQ(DebugVarIQType_t t)
     else if (t >= t_iq1 && t <= t_iq30)
         return (int)t - (int)t_iq1 + 1; // íàïðèìåð t_iq1 -> 1, t_iq2 -> 2 è ò.ä.
     else
-        return -1;      // îøèáêà
+        return 0;      // îøèáêà
 }
 
-static int convertDebugVarToIQx(DebugVar_t *var, long *ret_var)
+/**
+  * @brief    Ïðåîáðàçóåò ïåðåìåííóþ îòëàäêè â IQ ôîðìàò.
+  * @param    var      – óêàçàòåëü íà ïåðåìåííóþ îòëàäêè.
+  * @param    ret_var  – óêàçàòåëü äëÿ âîçâðàòà çíà÷åíèÿ â ôîðìàòå 32 áèòà.
+  * @return   int      – 0: óñïåõ, 1: îøèáêà ÷òåíèÿ, 2: íåïðàâèëüíûé ôîðìàò, 3: ïåðåïîëíåíèå.
+  * @details  Îïðåäåëÿåò ôîðìàò IQ ïåðåìåííîé, êîíâåðòèðóåò å¸ â 32b ñ ó÷¸òîì ìàñøòàáà.
+  */
+static int convertDebugVarToIQx(DebugVar_t *var, int32_t *ret_var)
 {
-    long iq_numb, iq_united, iq_final;
+    int32_t iq_numb, iq_united, iq_final;
+    int64_t iq_united64 = 0;
+    int64_t iq_final64 = 0;
+    int status;
+
     float float_numb;
 
-    if(getDebugVar(var, &iq_numb, &float_numb) != 0)
+    status = getDebugVar(var, &iq_numb, &float_numb);
-        return 1;
+    if(status != 0)
+        return status;
 
     int src_q = iqTypeToQ(var->iq_type);
     int dst_q = iqTypeToQ(var->return_type);
 
-    if (src_q < 0 || dst_q < 0)
-        return 2; // íåïðàâèëüíûé ôîðìàò
-
-    long long iq_united64 = 0;
-    long long iq_final64 = 0;
-
     // Êîíâåðòàöèÿ ê GLOBAL_Q (64-áèò)
     if (var->iq_type == t_iq_none) {
         if (var->ptr_type == pt_float) {
-            // float_numb óìíîæàåì íà 2^GLOBAL_Q (2^24=16777216)
+            // float_numb óìíîæàåì íà 2^GLOBAL_Q
-            // Ðåçóëüòàò ïðèâîäèì ê long long
+            // Ðåçóëüòàò ïðèâîäèì ê 64 áèòà
-            iq_united64 = (long long)(float_numb * 16777216.0f);
+            iq_united64 = (int64_t)(float_numb * ((uint32_t)1 << GLOBAL_Q));
         } else {
-            iq_united64 = ((long long)iq_numb) << GLOBAL_Q;
+            iq_united64 = ((int64_t)iq_numb) << GLOBAL_Q;
         }
     } else {
         int shift = GLOBAL_Q - src_q;
         if (shift >= 0)
-            iq_united64 = ((long long)iq_numb) << shift;
+            iq_united64 = ((int64_t)iq_numb) << shift;
         else
-            iq_united64 = ((long long)iq_numb) >> (-shift);
+            iq_united64 = ((int64_t)iq_numb) >> (-shift);
     }
 
     // Êîíâåðòàöèÿ èç GLOBAL_Q â öåëåâîé IQ (64-áèò)
     if (var->return_type == t_iq_none) {
         // Âîçâðàùàåì öåëîå, îòáðîñèâ äðîáíóþ ÷àñòü
-        *ret_var = (long)(iq_united64 >> GLOBAL_Q);
+        *ret_var = (uint32_t)(iq_united64 >> GLOBAL_Q);
     } else {
         int shift = dst_q - GLOBAL_Q;
         if (shift >= 0)
@@ -186,61 +346,71 @@ static int convertDebugVarToIQx(DebugVar_t *var, long *ret_var)
         else
             iq_final64 = iq_united64 >> (-shift);
 
-        // Ïðîâåðÿåì ïåðåïîëíåíèå int32_t
+        *ret_var = (int32_t)iq_final64;
-        if (iq_final64 > LONG_MAX || iq_final64 < LONG_MIN)
-            return 3; // ïåðåïîëíåíèå
-
-        *ret_var = (long)iq_final64;
     }
 
     return 0;
 }
 
-static int getDebugVar(DebugVar_t *var, long *int_var, float *float_var)
+/**
+  * @brief    Ïðî÷èòàòü çíà÷åíèå ïåðåìåííîé îòëàäêè.
+  * @param    var        – óêàçàòåëü íà ñòðóêòóðó DebugVar.
+  * @param    int_var    – óêàçàòåëü íà ïåðåìåííóþ òèïà 32 áèòà äëÿ âîçâðàòà öåëî÷èñëåííîãî çíà÷åíèÿ.
+  * @param    float_var  – óêàçàòåëü íà ïåðåìåííóþ òèïà float äëÿ âîçâðàòà çíà÷åíèÿ ñ ïëàâàþùåé òî÷êîé.
+  * @return   int        – 0: óñïåõ, 1: îøèáêà óêàçàòåëåé èëè íåïîääåðæèâàåìûé òèï, 3/4: îøèáêà âûðàâíèâàíèÿ.
+  * @details   çàâèñèìîñòè îò òèïà ïåðåìåííîé ñ÷èòûâàåò å¸ çíà÷åíèå è ñîõðàíÿåò â ñîîòâåòñòâóþùåì óêàçàòåëå.
+  */
+static int getDebugVar(DebugVar_t *var, int32_t *int_var, float *float_var)
 {
-    if (!var || !int_var || !float_var || !var->Ptr)
+    uint8_t *addr = var->Ptr;
-        return 1; // îøèáêà: null óêàçàòåëü
+    uint32_t addr_val = (uint32_t)addr;
 
-    char *addr = var->Ptr;
+    if (!var || !int_var || !float_var || !var->Ptr)
-    unsigned long addr_val = (unsigned long)addr;
+        return DEBUG_ERR_INTERNAL; // îøèáêà: null óêàçàòåëü
 
     switch (var->ptr_type)
     {
         case pt_int8:      // 8 áèò
+            if ((addr_val & ALIGN_8BIT) != 0)  // ïðîâåðÿåì âûðàâíèâàíèå
+                return DEBUG_ERR_ADDR_ALIGN;   // îøèáêà âûðàâíèâàíèÿ
+            *int_var = *((volatile int8_t *)addr);
+            break;
         case pt_uint8:
-            // âûðàâíèâàíèå íå íóæíî äëÿ 8 áèò
+            if ((addr_val & ALIGN_8BIT) != 0)  // ïðîâåðÿåì âûðàâíèâàíèå
-            *int_var = *((volatile char *)addr);
+                return DEBUG_ERR_ADDR_ALIGN;   // îøèáêà âûðàâíèâàíèÿ
+            *int_var = *((volatile uint8_t *)addr);
             break;
 
         case pt_int16:     // 16 áèò (int)
+            if ((addr_val & ALIGN_16BIT) != 0)  // ïðîâåðÿåì âûðàâíèâàíèå
+                return DEBUG_ERR_ADDR_ALIGN;   // îøèáêà âûðàâíèâàíèÿ
+            *int_var = *((volatile int16_t *)addr);
+            break;
         case pt_uint16:
-            *int_var = *((volatile int *)addr);
+            if ((addr_val & ALIGN_16BIT) != 0)  // ïðîâåðÿåì âûðàâíèâàíèå
+                return DEBUG_ERR_ADDR_ALIGN;   // îøèáêà âûðàâíèâàíèÿ
+            *int_var = *((volatile uint16_t *)addr);
             break;
 
-        case pt_int32:     // 32 áèò (long)
+        case pt_int32:     // 32 áèò
+            if ((addr_val & ALIGN_32BIT) != 0)  // ïðîâåðÿåì âûðàâíèâàíèå
+                return DEBUG_ERR_ADDR_ALIGN;   // îøèáêà âûðàâíèâàíèÿ
+            *int_var = *((volatile int32_t *)addr);
+            break;
         case pt_uint32:
-            if (addr_val & 0x1)  // ïðîâåðÿåì âûðàâíèâàíèå ïî 2 ñëîâàì (4 áàéòà)
+            if ((addr_val & ALIGN_32BIT) != 0)  // ïðîâåðÿåì âûðàâíèâàíèå
-                return 3;   // îøèáêà âûðàâíèâàíèÿ
+                return DEBUG_ERR_ADDR_ALIGN;   // îøèáêà âûðàâíèâàíèÿ
-            *int_var = *((volatile long *)addr);
+            *int_var = *((volatile uint32_t *)addr);
             break;
 
-//        case pt_int64:     // 64 áèò (long long)
-//        case pt_uint64:
-//            if (addr_val & 0x3)  // ïðîâåðêà âûðàâíèâàíèÿ ïî 4 ñëîâàì (8 áàéòàì)
-//                return 2;   // îøèáêà âûðàâíèâàíèÿ
-//            // Òóò ïðîñòî ÷èòàåì, íî long long ìîæåò íå ïîìåñòèòüñÿ â *int_var
-//            // Ìîæíî çàìåíèòü ëîãèêó ïîä 64-áèòíîå ÷òåíèå ïðè íåîáõîäèìîñòè
-//            *int_var = *((volatile long long *)addr);
-//            break;
-
         case pt_float:     // float (4 áàéòà)
-            if (addr_val & 0x1)  // ïðîâåðêà âûðàâíèâàíèÿ ïî 2 ñëîâàì
+            if ((addr_val & ALIGN_FLOAT) != 0)  // ïðîâåðêà âûðàâíèâàíèÿ
-                return 4;   // îøèáêà âûðàâíèâàíèÿ
+                return DEBUG_ERR_ADDR_ALIGN;   // îøèáêà âûðàâíèâàíèÿ
             *float_var = *((volatile float *)addr);
             break;
 
         default:
-            return 1; // íåïîääåðæèâàåìûé òèï
+            return DEBUG_ERR_INVALID_VAR; // íåïîääåðæèâàåìûé òèï
         // äëÿ óêàçàòåëåé è ìàññèâîâ íå ïîääåðæèâàåòñÿ ÷òåíèå
 //        case pt_ptr_int8:
 //        case pt_ptr_int16:
@@ -260,210 +430,22 @@ static int getDebugVar(DebugVar_t *var, long *int_var, float *float_var)
 }
 
 
-///////////// OUTDATE ////////////////
+/**
+ * @brief Ïðîâåðÿåò, âõîäèò ëè àäðåñ â îäèí èç äîïóñòèìûõ äèàïàçîíîâ
+ *
+ * @param addr_val  - Çíà÷åíèå àäðåñà äëÿ ïðîâåðêè
+ * @param ranges    - Óêàçàòåëü íà ìàññèâ äèàïàçîíîâ AddrRange_t
+ * @param count     - Êîëè÷åñòâî äèàïàçîíîâ â ìàññèâå
+ * @return 0 åñëè àäðåñ íàõîäèòñÿ â îäíîì èç äèàïàçîíîâ, èíà÷å 1
+ */
+static int is_addr_in_allowed_ranges(uint32_t addr_val, const AddrRange_t *ranges, int count)
+{
+    int i;
 
-//
+    for (i = 0; i < count; i++) {
-//    // ïðèâåäåíèå ê îäíîìó IQ
+        if (addr_val >= ranges[i].start && addr_val <= ranges[i].end) {
-//    switch(var->iq_type)
+            return 0;
-//    {
+        }
-//        case t_iq_none:
+    }
-//            if(var->ptr_type == pt_float)
+    return 1;
-//            {
+}
-//                iq_united = _IQ(float_numb);
-//            }
-//            else
-//            {
-//                iq_united = _IQ(iq_numb);
-//            }
-//            break;
-//        case t_iq1:
-//            iq_united = _IQ1toIQ(iq_numb);
-//            break;
-//        case t_iq2:
-//            iq_united = _IQ2toIQ(iq_numb);
-//            break;
-//        case t_iq3:
-//            iq_united = _IQ3toIQ(iq_numb);
-//            break;
-//        case t_iq4:
-//            iq_united = _IQ4toIQ(iq_numb);
-//            break;
-//        case t_iq5:
-//            iq_united = _IQ5toIQ(iq_numb);
-//            break;
-//        case t_iq6:
-//            iq_united = _IQ6toIQ(iq_numb);
-//            break;
-//        case t_iq7:
-//            iq_united = _IQ7toIQ(iq_numb);
-//            break;
-//        case t_iq8:
-//            iq_united = _IQ8toIQ(iq_numb);
-//            break;
-//        case t_iq9:
-//            iq_united = _IQ9toIQ(iq_numb);
-//            break;
-//        case t_iq10:
-//            iq_united = _IQ10toIQ(iq_numb);
-//            break;
-//        case t_iq11:
-//            iq_united = _IQ11toIQ(iq_numb);
-//            break;
-//        case t_iq12:
-//            iq_united = _IQ12toIQ(iq_numb);
-//            break;
-//        case t_iq13:
-//            iq_united = _IQ13toIQ(iq_numb);
-//            break;
-//        case t_iq14:
-//            iq_united = _IQ14toIQ(iq_numb);
-//            break;
-//        case t_iq15:
-//            iq_united = _IQ15toIQ(iq_numb);
-//            break;
-//        case t_iq16:
-//            iq_united = _IQ16toIQ(iq_numb);
-//            break;
-//        case t_iq17:
-//            iq_united = _IQ17toIQ(iq_numb);
-//            break;
-//        case t_iq18:
-//            iq_united = _IQ18toIQ(iq_numb);
-//            break;
-//        case t_iq19:
-//            iq_united = _IQ19toIQ(iq_numb);
-//            break;
-//        case t_iq20:
-//            iq_united = _IQ20toIQ(iq_numb);
-//            break;
-//        case t_iq21:
-//            iq_united = _IQ21toIQ(iq_numb);
-//            break;
-//        case t_iq22:
-//            iq_united = _IQ22toIQ(iq_numb);
-//            break;
-//        case t_iq23:
-//            iq_united = _IQ23toIQ(iq_numb);
-//            break;
-//        case t_iq24:
-//            iq_united = _IQ24toIQ(iq_numb);
-//            break;
-//        case t_iq25:
-//            iq_united = _IQ25toIQ(iq_numb);
-//            break;
-//        case t_iq26:
-//            iq_united = _IQ26toIQ(iq_numb);
-//            break;
-//        case t_iq27:
-//            iq_united = _IQ27toIQ(iq_numb);
-//            break;
-//        case t_iq28:
-//            iq_united = _IQ28toIQ(iq_numb);
-//            break;
-//        case t_iq29:
-//            iq_united = _IQ29toIQ(iq_numb);
-//            break;
-//        case t_iq30:
-//            iq_united = _IQ30toIQ(iq_numb);
-//            break;
-//    }
-//
-//    // ïðèâåäåíèå îáùåãî IQ ê çàïðàøèâàåìîìó
-//    switch(var->return_type)
-//    {
-//        case t_iq_none:
-//            iq_final = (long)_IQtoF(iq_united);
-//            break;
-//        case t_iq1:
-//            iq_final = _IQtoIQ1(iq_united);
-//            break;
-//        case t_iq2:
-//            iq_final = _IQtoIQ2(iq_united);
-//            break;
-//        case t_iq3:
-//            iq_final = _IQtoIQ3(iq_united);
-//            break;
-//        case t_iq4:
-//            iq_final = _IQtoIQ4(iq_united);
-//            break;
-//        case t_iq5:
-//            iq_final = _IQtoIQ5(iq_united);
-//            break;
-//        case t_iq6:
-//            iq_final = _IQtoIQ6(iq_united);
-//            break;
-//        case t_iq7:
-//            iq_final = _IQtoIQ7(iq_united);
-//            break;
-//        case t_iq8:
-//            iq_final = _IQtoIQ8(iq_united);
-//            break;
-//        case t_iq9:
-//            iq_final = _IQtoIQ9(iq_united);
-//            break;
-//        case t_iq10:
-//            iq_final = _IQtoIQ10(iq_united);
-//            break;
-//        case t_iq11:
-//            iq_final = _IQtoIQ11(iq_united);
-//            break;
-//        case t_iq12:
-//            iq_final = _IQtoIQ12(iq_united);
-//            break;
-//        case t_iq13:
-//            iq_final = _IQtoIQ13(iq_united);
-//            break;
-//        case t_iq14:
-//            iq_final = _IQtoIQ14(iq_united);
-//            break;
-//        case t_iq15:
-//            iq_final = _IQtoIQ15(iq_united);
-//            break;
-//        case t_iq16:
-//            iq_final = _IQtoIQ16(iq_united);
-//            break;
-//        case t_iq17:
-//            iq_final = _IQtoIQ17(iq_united);
-//            break;
-//        case t_iq18:
-//            iq_final = _IQtoIQ18(iq_united);
-//            break;
-//        case t_iq19:
-//            iq_final = _IQtoIQ19(iq_united);
-//            break;
-//        case t_iq20:
-//            iq_final = _IQtoIQ20(iq_united);
-//            break;
-//        case t_iq21:
-//            iq_final = _IQtoIQ21(iq_united);
-//            break;
-//        case t_iq22:
-//            iq_final = _IQtoIQ22(iq_united);
-//            break;
-//        case t_iq23:
-//            iq_final = _IQtoIQ23(iq_united);
-//            break;
-//        case t_iq24:
-//            iq_final = _IQtoIQ24(iq_united);
-//            break;
-//        case t_iq25:
-//            iq_final = _IQtoIQ25(iq_united);
-//            break;
-//        case t_iq26:
-//            iq_final = _IQtoIQ26(iq_united);
-//            break;
-//        case t_iq27:
-//            iq_final = _IQtoIQ27(iq_united);
-//            break;
-//        case t_iq28:
-//            iq_final = _IQtoIQ28(iq_united);
-//            break;
-//        case t_iq29:
-//            iq_final = _IQtoIQ29(iq_united);
-//            break;
-//        case t_iq30:
-//            iq_final = _IQtoIQ30(iq_united);
-//            break;
-//    }
-
-//    *ret_var = iq_final;

debug_tools.h

@@ -1,8 +1,64 @@
 #ifndef DEBUG_TOOLS
 #define DEBUG_TOOLS
-#include "IQmathLib.h"
+#include <stdint.h>
-#include "DSP281x_Device.h"
+#include <limits.h>
 
+
+
+#define ALLOWED_ADDRESS_RANGES    { \
+    {0x000000, 0x0007FF},           \
+    {0x008120, 0x009FFC},           \
+    {0x3F8000, 0x3F9FFF},           \
+    {0x3FF000, 0x3FFFFF},           \
+    {0x080002, 0x09FFFF},           \
+    {0x0F0000, 0x0FFEFF},           \
+    {0x100002, 0x103FFF},           \
+    {0x102000, 0x103FFF}            \
+}
+
+
+#if UINT8_MAX // Åñëè åñòü òèï 8 áèò - çí÷à÷èò àäðåñàöèÿ ïî 8 áèò
+
+    #define ALIGN_8BIT   0x0     ///< Âûðàâíèâàíèå áåç îãðàíè÷åíèé (ëþáîé àäðåñ)
+    #define ALIGN_16BIT  0x1     ///< Âûðàâíèâàíèå: àäðåñ äîëæåí áûòü êðàòåí 2 (addr & 0x1 == 0)
+    #define ALIGN_32BIT  0x3     ///< Âûðàâíèâàíèå: àäðåñ äîëæåí áûòü êðàòåí 4 (addr & 0x3 == 0)
+    #define ALIGN_64BIT  0x7     ///< Âûðàâíèâàíèå: àäðåñ äîëæåí áûòü êðàòåí 8 (addr & 0x7 == 0)
+    #define ALIGN_FLOAT  ALIGN_32BIT
+
+#else // Åñëè íåò òèïà 8 áèò - çíà÷èò àäðåñàöèÿ ïî 16 áèò
+
+    #define ALIGN_8BIT   0x0     ///< Âûðàâíèâàíèå áåç îãðàíè÷åíèé (ëþáîé àäðåñ)
+    #define ALIGN_16BIT  0x0     ///< Âûðàâíèâàíèå áåç îãðàíè÷åíèé (ëþáîé àäðåñ)
+    #define ALIGN_32BIT  0x1     ///< Âûðàâíèâàíèå: àäðåñ äîëæåí áûòü êðàòåí 4 (addr & 0x1 == 0)
+    #define ALIGN_64BIT  0x3     ///< Âûðàâíèâàíèå: àäðåñ äîëæåí áûòü êðàòåí 8 (addr & 0x3 == 0)
+    #define ALIGN_FLOAT  ALIGN_32BIT
+
+#endif //STM32/TMS32
+
+#if !UINT8_MAX
+    typedef unsigned    char uint8_t;
+    typedef signed      char int8_t;
+#endif
+#if !defined(NULL)
+    #define NULL 0
+#endif
+
+#define DEBUG_SIGNED_VAR                (1<<7)
+
+#define DEBUG_OK                        (0)
+#define DEBUG_ERR                       (1<<7)
+#define DEBUG_ERR_VAR_NUMB              (1<<0) | DEBUG_ERR
+#define DEBUG_ERR_INVALID_VAR           (1<<1) | DEBUG_ERR
+#define DEBUG_ERR_ADDR                  (1<<2) | DEBUG_ERR
+#define DEBUG_ERR_ADDR_ALIGN            (1<<3) | DEBUG_ERR
+#define DEBUG_ERR_INTERNAL              (1<<4) | DEBUG_ERR
+#define DEBUG_ERR_DATATIME              (1<<5) | DEBUG_ERR
+
+
+
+/**
+  * @brief Òèï äàííûõ, íà êîòîðûé óêàçûâàåò óêàçàòåëü ïåðåìåííîé îòëàäêè.
+  */
 typedef enum
 {
     pt_unknown,             // unknown
@@ -14,7 +70,7 @@ typedef enum
     pt_uint16,              // unsigned int
     pt_uint32,              // unsigned long
     pt_uint64,              // unsigned long
-    pt_float,               // float
+    pt_float,               // floatf
     pt_struct,              // struct
     pt_union,               // struct
 //    pt_ptr_int8,            // signed char*
@@ -31,6 +87,9 @@ typedef enum
 //    pt_arr_uint32,          // unsigned long[]
 }DebugVarPtrType_t;
 
+/**
+  * @brief Òèïû IQ-ïðåäñòàâëåíèÿ ïåðåìåííîé îòëàäêè.
+  */
 typedef enum
 {
     t_iq_none,
@@ -67,45 +126,83 @@ typedef enum
     t_iq30
 }DebugVarIQType_t;
 
-typedef char DebugVarName_t[11];
+typedef char DebugVarName_t[11];  ///< Èìÿ ïåðåìåííîé îòëàäêè (äî 10 ñèìâîëîâ + \0)
+
+/**
+  * @brief Îïèñàíèå ïåðåìåííîé îòëàäêè.
+  */
 typedef struct
 {
-    char*               Ptr;
+    uint8_t*            Ptr;        ///< Óêàçàòåëü íà çíà÷åíèå ïåðåìåííîé
-    DebugVarPtrType_t   ptr_type;
+    DebugVarPtrType_t   ptr_type;   ///< Òèï çíà÷åíèÿ
-    DebugVarIQType_t    iq_type;
+    DebugVarIQType_t    iq_type;    ///< Òèï IQ ïåðåìåííîé (åñëè åñòü)
-    DebugVarIQType_t    return_type;
+    DebugVarIQType_t    return_type;///< Òèï IQ âîçâðàùàåìîãî çíà÷åíèÿ
-    DebugVarName_t      name;
+    DebugVarName_t      name;       ///< Èìÿ ïåðåìåííîé
-}DebugVar_t;
+} DebugVar_t;
 
+typedef long DebugValue_t;
+
+/**
+  * @brief Ñòðóêòóðà äàòû è âðåìåíè.
+  */
 typedef struct {
-    int year;
+    uint16_t   year;   ///< Ãîä (íàïðèìåð, 2025)
-    char  month;
+    uint8_t  month;    ///< Ìåñÿö (1-12)
-    char  day;
+    uint8_t  day;      ///< Äåíü (1-31)
-    char  hour;
+    uint8_t  hour;     ///< ×àñû (0-23)
-    char  minute;
+    uint8_t  minute;   ///< Ìèíóòû (0-59)
 } DateTime_t;
 
+/**
+ * @brief Ñòðóêòóðà, îïèñûâàþùàÿ äèàïàçîí àäðåñîâ ïàìÿòè.
+ */
+typedef struct {
+    uint32_t start;  ///< Íà÷àëüíûé àäðåñ äèàïàçîíà
+    uint32_t end;    ///< Êîíå÷íûé àäðåñ äèàïàçîíà (âêëþ÷èòåëüíî)
+} AddrRange_t;
+/**
+  * @brief Ñòðóêòóðà íèæíåãî óðîâíÿ îòëàäêè.
+  */
 typedef struct
 {
-    DateTime_t      build_date;
+    DateTime_t      build_date; ///< Äàòà ñáîðêè
-    unsigned int    isVerified;
+    unsigned int    isVerified; ///< Ôëàã èíèöèàëèçàöèè íèçêîóðîâíåíîé îòëàäêè (0 — íåò, 1 — óñïåøíî)
-    DebugVar_t      dbg_var;
+    DebugVar_t      dbg_var;    ///< Ïåðåìåííàÿ äëÿ îòëàäêè
 }DebugLowLevel_t;
-extern DebugLowLevel_t debug_ll;
+extern DebugLowLevel_t debug_ll;  ///< Ãëîáàëüíûé ýêçåìïëÿð îòëàäêè íèæíåãî óðîâíÿ
+
+
+/** @brief Ìàêðîñ èíèöèàëèçàöèè äàòû */
 #define DATE_INIT               {BUILD_YEAR, BUILD_MONTH, BUILD_DATA, BUILD_HOURS, BUILD_MINUTES}
+/** @brief Ìàêðîñ èíèöèàëèçàöèè ïåðåìåííîé îòëàäêè */
 #define DEBUG_VAR_INIT          {0, pt_uint16, t_iq_none, t_iq_none, "\0"}
+/** @brief Ìàêðîñ èíèöèàëèçàöèè íèæíåãî óðîâíÿ îòëàäêè */
 #define DEBUG_LOWLEVEL_INIT     {DATE_INIT, 0, DEBUG_VAR_INIT}
 
 
-extern int DebugVar_Qnt;
+extern int DebugVar_Qnt;          ///< Êîëè÷åñòâî ïåðåìåííûõ îòëàäêè
-extern DebugVar_t dbg_vars[];
+extern DebugVar_t dbg_vars[];     ///< Ìàññèâ ïåðåìåííûõ îòëàäêè
 
 
+/* Ïðèìåð èñïîëüçîâàíèÿ îòëàäêè */
 void Debug_Test_Example(void);
 
-int Debug_ReadVar(int var_ind, long *return_long);
+/* ×èòàåò çíà÷åíèå ïåðåìåííîé ïî èíäåêñó */
-int Debug_ReadVarName(int var_ind, DebugVarName_t name_ptr);
+int Debug_ReadVar(int var_ind, int32_t *return_long);
-int Debug_LowLevel_ReadVar(long *return_long);
+/* ×èòàåò èìÿ ïåðåìåííîé ïî èíäåêñó */
-int Debug_LowLevel_Initialize(const char* external_date);
+int Debug_ReadVarName(int var_ind, DebugVarName_t name_ptr, int *length);
+/* ×èòàåò âîçâðàùàåìûé òèï (IQ) ïåðåìåííîé ïî èíäåêñó */
+int Debug_ReadVarReturnType(int var_ind, int *vartype);
+/* ×èòàåò òèï ïåðåìåííîé ïî èíäåêñó */
+int Debug_ReadVarType(int var_ind, int *vartype);
 
+
+/* ×èòàåò çíà÷åíèå ïåðåìåííîé ñ íèæíåãî óðîâíÿ */
+int Debug_LowLevel_ReadVar(int32_t *return_long);
+/* Èíèöèàëèçèðóåò îòëàäêó íèæíåãî óðîâíÿ */
+int Debug_LowLevel_Initialize(DateTime_t *external_date);
+/* ×èòàåò âîçâðàùàåìûé òèï (IQ) íèçêîóðîâíåíî çàäàííîé ïåðåìåííîé */
+int Debug_LowLevel_ReadVarReturnType(int *vartype);
+/* ×èòàåò òèï íèçêîóðîâíåíî çàäàííîé ïåðåìåííîé.*/
+int Debug_LowLevel_ReadVarType(int *vartype);
 #endif //DEBUG_TOOLS

parse_xml/Src/parse_xml.py

@@ -0,0 +1,352 @@
+# pyinstaller --onefile --distpath . --workpath ./build --specpath ./build parse_xml.py
+# python -m nuitka --standalone --onefile --output-dir=./build parse_xml.py
+import xml.etree.ElementTree as ET
+import xml.dom.minidom
+import sys
+import os
+
+if len(sys.argv) < 3:
+    print("Usage: python simplify_dwarf.py <input.xml> <info.txt> [output.xml]")
+    sys.exit(1)
+
+input_path = sys.argv[1]
+info_path = sys.argv[2]
+
+if len(sys.argv) >= 4:
+    output_path = sys.argv[3]
+else:
+    input_dir = os.path.dirname(os.path.abspath(input_path))
+    output_path = os.path.join(input_dir, "simplified.xml")
+
+tree = ET.parse(input_path)
+root = tree.getroot()
+
+def extract_timestamp(info_path):
+    with open(info_path, "r", encoding="utf-8") as f:
+        for line in f:
+            if "Time Stamp:" in line:
+                parts = line.split("Time Stamp:")
+                if len(parts) > 1:
+                    timestamp = parts[1].strip()
+                    return timestamp
+
+
+
+die_by_id = {die.attrib.get("id"): die for die in root.iter("die") if "id" in die.attrib}
+
+def get_attr(die, attr_type):
+    for attr in die.findall("attribute"):
+        type_elem = attr.find("type")
+        if type_elem is not None and type_elem.text == attr_type:
+            return attr.find("value")
+    return None
+
+def get_die_size(die):
+    """Вернуть размер DIE в байтах из атрибута DW_AT_byte_size."""
+    for attr in die.findall("attribute"):
+        type_elem = attr.find("type")
+        if type_elem is not None and type_elem.text == "DW_AT_byte_size":
+            const_elem = attr.find("value/const")
+            if const_elem is not None:
+                return int(const_elem.text, 0)
+    return None
+
+def resolve_type_die(type_id):
+    """Получить DIE типа, разрешая typedef, const и volatile."""
+    visited = set()
+    while type_id and type_id not in visited:
+        visited.add(type_id)
+        die = die_by_id.get(type_id)
+        if die is None:
+            return None
+        tag = die.findtext("tag")
+        if tag in ("DW_TAG_volatile_type", "DW_TAG_const_type", "DW_TAG_typedef", "DW_TAG_TI_far_type"):
+            ref = get_attr(die, "DW_AT_type")
+            if ref is not None and ref.find("ref") is not None:
+                type_id = ref.find("ref").attrib.get("idref")
+            else:
+                return None
+        else:
+            return die
+    return None
+
+# Словарь для простых базовых типов по тегам (пример)
+base_types_map = {
+    "DW_TAG_base_type": lambda die: die.find("attribute[@type='DW_AT_name']/value/string").text if die.find("attribute[@type='DW_AT_name']/value/string") is not None else "unknown",
+    "DW_TAG_structure_type": lambda die: "struct",
+    "DW_TAG_union_type": lambda die: "union",
+    "DW_TAG_pointer_type": lambda die: "pointer",
+    "DW_TAG_array_type": lambda die: "array",
+}
+
+def get_type_name(type_id):
+    die = resolve_type_die(type_id)
+    if die is None:
+        return "unknown"
+
+    tag = die.findtext("tag")
+
+    if tag == "DW_TAG_pointer_type":
+        ref = get_attr(die, "DW_AT_type")
+        if ref is not None and ref.find("ref") is not None:
+            pointee_id = ref.find("ref").attrib.get("idref")
+            name = get_type_name(pointee_id)
+            return name + "*" if name != "unknown" else name
+        else:
+            return "void*"
+
+    elif tag == "DW_TAG_base_type":
+        name_attr = get_attr(die, "DW_AT_name")
+        if name_attr is not None:
+            return name_attr.findtext("string")
+        else:
+            return "base_type_unknown"
+
+    elif tag == "DW_TAG_structure_type":
+        name_attr = get_attr(die, "DW_AT_name")
+        name = name_attr.findtext("string") if name_attr is not None else "anonymous_struct"
+        return f"struct {name}"
+
+    elif tag == "DW_TAG_union_type":
+        name_attr = get_attr(die, "DW_AT_name")
+        name = name_attr.findtext("string") if name_attr is not None else "anonymous_union"
+        return f"union {name}"
+
+    elif tag == "DW_TAG_array_type":
+        ref = get_attr(die, "DW_AT_type")
+        if ref is not None and ref.find("ref") is not None:
+            element_type_id = ref.find("ref").attrib.get("idref")
+            element_type_name = get_type_name(element_type_id)
+            return f"{element_type_name}[]"
+        else:
+            return "array[]"
+
+    # Добавляем поддержку enum
+    elif tag == "DW_TAG_enumeration_type":
+        name_attr = get_attr(die, "DW_AT_name")
+        name = name_attr.findtext("string") if name_attr is not None else "anonymous_enum"
+        return f"enum {name}"
+    
+    else:
+        return "unknown"
+
+def parse_offset(offset_text):
+    if offset_text and offset_text.startswith("DW_OP_plus_uconst "):
+        return int(offset_text.split()[-1], 0)
+    return 0
+
+
+def get_array_dimensions(array_die):
+    """Рекурсивно получить размеры всех измерений массива из DIE с тегом DW_TAG_array_type."""
+    dims = []
+
+    # Ищем размер текущего измерения
+    # Размер может быть в DW_AT_upper_bound, либо вычисляться из DW_AT_byte_size и типа элемента
+    # Но часто в DWARF размер указывается через дочерние die с тегом DW_TAG_subrange_type
+
+    subrange = None
+    for child in array_die.findall("die"):
+        if child.findtext("tag") == "DW_TAG_subrange_type":
+            subrange = child
+            break
+
+    dim_size = None
+    if subrange is not None:
+        # Ищем атрибут DW_AT_upper_bound
+        ub_attr = get_attr(subrange, "DW_AT_upper_bound")
+        if ub_attr is not None:
+            val = ub_attr.find("value/const")
+            if val is not None:
+                # Размер измерения равен верхней границе + 1 (т.к. верхняя граница индексируется с 0)
+                dim_size = int(val.text, 0) + 1
+
+    if dim_size is None:
+        # Если размер не нашли, попробуем вычислить через общий размер / размер элемента
+        arr_size = get_die_size(array_die)
+        element_type_ref = get_attr(array_die, "DW_AT_type")
+        if element_type_ref is not None and element_type_ref.find("ref") is not None:
+            element_type_id = element_type_ref.find("ref").attrib.get("idref")
+            element_type_die = resolve_type_die(element_type_id)
+            elem_size = get_die_size(element_type_die) if element_type_die is not None else None
+
+            if arr_size is not None and elem_size:
+                dim_size = arr_size // elem_size
+
+    if dim_size is None:
+        dim_size = 0  # Неизвестно
+
+    dims.append(dim_size)
+
+    # Рекурсивно проверяем, если элемент типа тоже массив (многомерный)
+    element_type_ref = get_attr(array_die, "DW_AT_type")
+    if element_type_ref is not None and element_type_ref.find("ref") is not None:
+        element_type_id = element_type_ref.find("ref").attrib.get("idref")
+        element_type_die = resolve_type_die(element_type_id)
+        if element_type_die is not None and element_type_die.findtext("tag") == "DW_TAG_array_type":
+            dims.extend(get_array_dimensions(element_type_die))
+
+    return dims
+
+
+
+
+
+def handle_array_type(member_elem, resolved_type, offset=0):
+    dims = get_array_dimensions(resolved_type)
+
+    # Получаем элементарный тип массива (наибольший элемент в цепочке массивов)
+    def get_base_element_type(die):
+        ref = get_attr(die, "DW_AT_type")
+        if ref is not None and ref.find("ref") is not None:
+            type_id = ref.find("ref").attrib.get("idref")
+            type_die = resolve_type_die(type_id)
+            if type_die is not None and type_die.findtext("tag") == "DW_TAG_array_type":
+                return get_base_element_type(type_die)
+            else:
+                return type_die
+        return None
+
+    element_type_die = get_base_element_type(resolved_type)
+    element_type_name = get_type_name(element_type_die.attrib.get("id")) if element_type_die is not None else "unknown"
+
+    # Формируем строку типа с нужным количеством []
+    type_with_array = element_type_name + "[]" * len(dims)
+    member_elem.set("type", type_with_array)
+
+    # Размер всего массива
+    arr_size = get_die_size(resolved_type)
+    if arr_size is not None:
+        member_elem.set("size", str(arr_size))
+
+    # Добавляем атрибуты size1, size2, ...
+    for i, dim in enumerate(dims, 1):
+        member_elem.set(f"size{i}", str(dim))
+
+    member_elem.set("kind", "array")
+
+    # Если базовый элемент - структура, рекурсивно добавляем её члены
+    if element_type_die is not None and element_type_die.findtext("tag") == "DW_TAG_structure_type":
+        add_members_recursive(member_elem, element_type_die, offset)
+
+
+
+
+def add_members_recursive(parent_elem, struct_die, base_offset=0):
+    tag = struct_die.findtext("tag")
+    is_union = tag == "DW_TAG_union_type"
+
+
+    # Получаем размер структуры/объединения
+    size = get_die_size(struct_die)
+    if size is not None:
+        parent_elem.set("size", hex(size))
+
+
+    for member in struct_die.findall("die"):
+        if member.findtext("tag") != "DW_TAG_member":
+            continue
+
+        name_attr = get_attr(member, "DW_AT_name")
+        offset_attr = get_attr(member, "DW_AT_data_member_location")
+        type_attr = get_attr(member, "DW_AT_type")
+
+        if name_attr is None or offset_attr is None or type_attr is None:
+            continue
+
+        name = name_attr.findtext("string")
+        offset_text = offset_attr.findtext("block")
+        offset = parse_offset(offset_text) + base_offset
+        type_id = type_attr.find("ref").attrib.get("idref")
+        resolved_type = resolve_type_die(type_id)
+        type_name = get_type_name(type_id)
+
+        if type_name == "unknown":
+            continue
+
+        member_elem = ET.SubElement(
+            parent_elem, "member", name=name, offset=hex(offset), type=type_name
+        )
+
+        if is_union:
+            member_elem.set("kind", "union")
+
+        if resolved_type is not None:
+            subtag = resolved_type.findtext("tag")
+
+            # Обработка массива
+            if subtag == "DW_TAG_array_type":
+                handle_array_type(member_elem, resolved_type, offset)
+            # Обработка структур и объединений
+            elif subtag in ("DW_TAG_structure_type", "DW_TAG_union_type"):
+                member_elem.set("type", type_name)
+                add_members_recursive(member_elem, resolved_type, offset)
+            else:
+                member_elem.set("type", type_name)
+
+
+output_root = ET.Element("variables")
+for die in root.iter("die"):
+    if die.findtext("tag") != "DW_TAG_variable":
+        continue
+
+    name_attr = get_attr(die, "DW_AT_name")
+    addr_attr = get_attr(die, "DW_AT_location")
+    type_attr = get_attr(die, "DW_AT_type")
+
+    if name_attr is None or addr_attr is None or type_attr is None:
+        continue
+
+    name = name_attr.findtext("string")
+
+    # Пропускаем переменные с '$' в имени
+    if "$" in name:
+        continue
+
+    addr_text = addr_attr.findtext("block")
+    if not addr_text or not addr_text.startswith("DW_OP_addr "):
+        continue
+
+    addr = int(addr_text.split()[-1], 0)
+    type_id = type_attr.find("ref").attrib.get("idref")
+    resolved_type = resolve_type_die(type_id)
+    type_name = get_type_name(type_id)
+    # Пропускаем переменные, находящиеся в памяти периферии
+    if 0x800 <= addr < 0x8000:
+        continue
+
+    # Проверка на DW_TAG_subroutine_type - пропускаем такие переменные
+    if type_name == "unknown":
+        continue
+
+    var_elem = ET.SubElement(output_root, "variable", name=name, address=hex(addr), type=type_name)
+    if resolved_type is not None:
+            tag = resolved_type.findtext("tag")
+
+            if tag == "DW_TAG_array_type":
+                handle_array_type(var_elem, resolved_type)
+
+            elif tag in ("DW_TAG_structure_type", "DW_TAG_union_type"):
+                add_members_recursive(var_elem, resolved_type)
+
+
+timestamp = extract_timestamp(info_path)
+
+# Создаём новый элемент <timestamp> с текстом timestamp
+timestamp_elem = ET.Element("timestamp")
+timestamp_elem.text = timestamp
+
+# Вставляем тег timestamp в начало (или куда хочешь)
+output_root.insert(0, timestamp_elem)  # В начало списка дочерних элементов
+
+# Красивый вывод
+
+rough_string = ET.tostring(output_root, encoding="utf-8")
+reparsed = xml.dom.minidom.parseString(rough_string)
+pretty_xml = reparsed.toprettyxml(indent="  ")
+
+with open(output_path, "w", encoding="utf-8") as f:
+    f.write(pretty_xml)
+
+os.remove(input_path)
+os.remove(info_path)
+print(f"Simplified and formatted XML saved to: {output_path}")