init commit

Работа с сериальной шиной и макросами

serialbus.py

@@ -0,0 +1,659 @@
+import json
+import os
+from functools import partial
+from PySide2.QtWidgets import *
+from PySide2.QtCore import *
+from PySide2.QtGui import *
+
+class SerialBus:
+    """ВЫСОКОУРОВНЕВЫЙ протокол для работы с серийной шиной (только через регистры)"""
+    
+    def __init__(self, raw_protocol):
+        self.raw = raw_protocol  # Используем низкоуровневый протокол
+        
+    def write_bus(self, data_word, address_tetrad, register_num=0, device_address=1):
+        """
+        Запись в шину по протоколу:
+        1. POKE 0x200A data_word
+        2. POKE 0x200B (0x80AR | (address_tetrad << 4)), где R - номер регистра
+        """
+        # 1. Запись данных в регистр шины
+        success1, result1 = self.raw.poke(0x200A, data_word, device_address)
+        if not success1:
+            return False, f"Ошибка записи данных: {result1}"
+        
+        # 2. Запись управляющего слова
+        control_word = 0x8000 | ((address_tetrad & 0xF) << 4) | (register_num & 0xF)
+        success2, result2 = self.raw.poke(0x200B, control_word, device_address)
+        
+        if success2:
+            return True, f"Запись успешна: управляющее слово=0x{control_word:04X}"
+        else:
+            return False, f"Ошибка записи управляющего слова: {result2}"
+
+    def read_bus(self, address_tetrad, register_num=0, device_address=1):
+        """
+        Чтение из шины по протоколу:
+        1. POKE 0x200B (0x00AR | (address_tetrad << 4)), где R - номер регистра
+        2. PEEK 0x200F
+        """
+        # 1. Запись управляющего слова для чтения
+        control_word = 0x0000 | ((address_tetrad & 0xF) << 4) | (register_num & 0xF)
+        success1, result1 = self.raw.poke(0x200B, control_word, device_address)
+        if not success1:
+            return False, f"Ошибка записи управляющего слова: {result1}"
+        
+        # 2. Чтение данных из регистра шины
+        success2, result2 = self.raw.peek(0x200F, device_address)
+        
+        if success2:
+            return True, result2
+        else:
+            return False, result2
+
+
+class MacroCommandDialog(QDialog):
+    """Диалог для добавления/редактирования команды макроса"""
+    
+    def __init__(self, parent=None, command=None):
+        super().__init__(parent)
+        self.command = command if command else {}
+        self.init_ui()
+        
+    def init_ui(self):
+        self.setWindowTitle("Команда макроса")
+        self.setMinimumWidth(400)
+        
+        layout = QVBoxLayout()
+        
+        # Тип команды
+        type_layout = QHBoxLayout()
+        type_layout.addWidget(QLabel("Тип команды:"))
+        self.cmd_type = QComboBox()
+        self.cmd_type.addItems(["Запись", "Чтение"])
+        type_layout.addWidget(self.cmd_type)
+        layout.addLayout(type_layout)
+        
+        # Адрес устройства
+        addr_layout = QHBoxLayout()
+        addr_layout.addWidget(QLabel("Адрес устройства (0-14):"))
+        self.device_addr = QSpinBox()
+        self.device_addr.setRange(0, 14)
+        addr_layout.addWidget(self.device_addr)
+        layout.addLayout(addr_layout)
+        
+        # Регистр
+        reg_layout = QHBoxLayout()
+        reg_layout.addWidget(QLabel("Регистр (0-15):"))
+        self.register_num = QSpinBox()
+        self.register_num.setRange(0, 15)
+        reg_layout.addWidget(self.register_num)
+        layout.addLayout(reg_layout)
+        
+        # Данные (только для записи)
+        self.data_label = QLabel("Данные (hex):")
+        self.data_edit = QLineEdit("0000")
+        self.data_edit.setMaximumWidth(100)
+        data_layout = QHBoxLayout()
+        data_layout.addWidget(self.data_label)
+        data_layout.addWidget(self.data_edit)
+        layout.addLayout(data_layout)
+        
+        # Загружаем данные команды, если она передана
+        if self.command:
+            if self.command.get('type') == 'write':
+                self.cmd_type.setCurrentText("Запись")
+                self.device_addr.setValue(self.command.get('tetrad', 0))
+                self.register_num.setValue(self.command.get('register', 0))
+                self.data_edit.setText(f"{self.command.get('data', 0):04X}")
+            else:
+                self.cmd_type.setCurrentText("Чтение")
+                self.device_addr.setValue(self.command.get('tetrad', 0))
+                self.register_num.setValue(self.command.get('register', 0))
+        
+        # Подключаем изменение типа команды
+        self.cmd_type.currentTextChanged.connect(self.on_cmd_type_changed)
+        self.on_cmd_type_changed(self.cmd_type.currentText())
+        
+        # Кнопки
+        button_layout = QHBoxLayout()
+        self.ok_btn = QPushButton("OK")
+        self.ok_btn.clicked.connect(self.accept)
+        self.cancel_btn = QPushButton("Отмена")
+        self.cancel_btn.clicked.connect(self.reject)
+        button_layout.addWidget(self.ok_btn)
+        button_layout.addWidget(self.cancel_btn)
+        layout.addLayout(button_layout)
+        
+        self.setLayout(layout)
+        
+    def on_cmd_type_changed(self, text):
+        """Показать/скрыть поле данных в зависимости от типа команды"""
+        if text == "Запись":
+            self.data_label.show()
+            self.data_edit.show()
+        else:
+            self.data_label.hide()
+            self.data_edit.hide()
+            
+    def get_command(self):
+        """Получить команду из диалога"""
+        cmd_type = 'write' if self.cmd_type.currentText() == "Запись" else 'read'
+        command = {
+            'type': cmd_type,
+            'tetrad': self.device_addr.value(),
+            'register': self.register_num.value()
+        }
+        
+        if cmd_type == 'write':
+            try:
+                command['data'] = int(self.data_edit.text(), 16)
+            except ValueError:
+                command['data'] = 0
+                
+        return command
+
+
+class MacroEditorDialog(QDialog):
+    """Диалог для создания/редактирования макроса"""
+    
+    def __init__(self, parent=None, macro=None):
+        super().__init__(parent)
+        self.macro = macro if macro else {'name': '', 'commands': []}
+        self.init_ui()
+        
+    def init_ui(self):
+        self.setWindowTitle("Редактор макроса")
+        self.setMinimumSize(500, 400)
+        
+        layout = QVBoxLayout()
+        
+        # Имя макроса
+        name_layout = QHBoxLayout()
+        name_layout.addWidget(QLabel("Имя макроса:"))
+        self.macro_name = QLineEdit(self.macro.get('name', 'Новый макрос'))
+        name_layout.addWidget(self.macro_name)
+        layout.addLayout(name_layout)
+        
+        # Список команд
+        layout.addWidget(QLabel("Команды:"))
+        self.commands_list = QListWidget()
+        layout.addWidget(self.commands_list)
+        
+        # Кнопки управления командами
+        cmd_buttons_layout = QHBoxLayout()
+        self.add_cmd_btn = QPushButton("Добавить команду")
+        self.add_cmd_btn.clicked.connect(self.add_command)
+        cmd_buttons_layout.addWidget(self.add_cmd_btn)
+        
+        self.edit_cmd_btn = QPushButton("Редактировать")
+        self.edit_cmd_btn.clicked.connect(self.edit_command)
+        cmd_buttons_layout.addWidget(self.edit_cmd_btn)
+        
+        self.remove_cmd_btn = QPushButton("Удалить")
+        self.remove_cmd_btn.clicked.connect(self.remove_command)
+        cmd_buttons_layout.addWidget(self.remove_cmd_btn)
+        
+        self.move_up_btn = QPushButton("Вверх")
+        self.move_up_btn.clicked.connect(self.move_command_up)
+        cmd_buttons_layout.addWidget(self.move_up_btn)
+        
+        self.move_down_btn = QPushButton("Вниз")
+        self.move_down_btn.clicked.connect(self.move_command_down)
+        cmd_buttons_layout.addWidget(self.move_down_btn)
+        
+        layout.addLayout(cmd_buttons_layout)
+        
+        # Загружаем команды, если они есть
+        self.load_commands()
+        
+        # Кнопки сохранения/отмены
+        button_layout = QHBoxLayout()
+        self.save_btn = QPushButton("Сохранить")
+        self.save_btn.clicked.connect(self.accept)
+        self.cancel_btn = QPushButton("Отмена")
+        self.cancel_btn.clicked.connect(self.reject)
+        button_layout.addWidget(self.save_btn)
+        button_layout.addWidget(self.cancel_btn)
+        layout.addLayout(button_layout)
+        
+        self.setLayout(layout)
+        
+    def load_commands(self):
+        """Загрузить команды в список"""
+        self.commands_list.clear()
+        for cmd in self.macro['commands']:
+            if cmd['type'] == 'write':
+                text = f"Запись: устр.{cmd['tetrad']}, рег.{cmd['register']}, 0x{cmd['data']:04X}"
+            else:
+                text = f"Чтение: устр.{cmd['tetrad']}, рег.{cmd['register']}"
+            self.commands_list.addItem(text)
+            
+    def add_command(self):
+        """Добавить новую команду"""
+        dialog = MacroCommandDialog(self)
+        if dialog.exec_():
+            command = dialog.get_command()
+            self.macro['commands'].append(command)
+            self.load_commands()
+            
+    def edit_command(self):
+        """Редактировать выбранную команду"""
+        current_row = self.commands_list.currentRow()
+        if current_row >= 0 and current_row < len(self.macro['commands']):
+            dialog = MacroCommandDialog(self, self.macro['commands'][current_row])
+            if dialog.exec_():
+                self.macro['commands'][current_row] = dialog.get_command()
+                self.load_commands()
+                
+    def remove_command(self):
+        """Удалить выбранную команду"""
+        current_row = self.commands_list.currentRow()
+        if current_row >= 0 and current_row < len(self.macro['commands']):
+            del self.macro['commands'][current_row]
+            self.load_commands()
+            
+    def move_command_up(self):
+        """Переместить команду вверх"""
+        current_row = self.commands_list.currentRow()
+        if current_row > 0:
+            self.macro['commands'][current_row], self.macro['commands'][current_row-1] = \
+                self.macro['commands'][current_row-1], self.macro['commands'][current_row]
+            self.load_commands()
+            self.commands_list.setCurrentRow(current_row-1)
+            
+    def move_command_down(self):
+        """Переместить команду вниз"""
+        current_row = self.commands_list.currentRow()
+        if current_row >= 0 and current_row < len(self.macro['commands']) - 1:
+            self.macro['commands'][current_row], self.macro['commands'][current_row+1] = \
+                self.macro['commands'][current_row+1], self.macro['commands'][current_row]
+            self.load_commands()
+            self.commands_list.setCurrentRow(current_row+1)
+            
+    def get_macro(self):
+        """Получить макрос из диалога"""
+        return {
+            'name': self.macro_name.text(),
+            'commands': self.macro['commands'].copy()
+        }
+
+
+
+class SerialTab(QWidget):
+    """Вкладка для работы с серийной шиной (ТОЛЬКО операции с шиной)"""
+    
+    MACROS_FILE = "macros.json"  # Файл для сохранения макросов
+    
+    def __init__(self, serial_bus, raw_protocol, raw_widget):
+        super().__init__()
+        self.serial_bus = serial_bus
+        self.raw_protocol = raw_protocol
+        self.raw_widget = raw_widget
+        self.macros = []  # Список макросов
+        self.macro_buttons = []  # Список кнопок макросов
+        
+        # Загружаем сохраненные макросы
+        self.load_macros()
+        
+        self.init_ui()
+
+
+    def init_ui(self):
+        layout = QVBoxLayout()
+        
+        # Группа для операций с шиной
+        bus_group = QGroupBox("Операции с шиной (через регистры 0x200A/0x200B/0x200F)")
+        bus_layout = QGridLayout()
+        
+        bus_layout.addWidget(QLabel("Данные для шины (hex):"), 0, 0)
+        self.bus_data_edit = QLineEdit("0000")
+        self.bus_data_edit.setMaximumWidth(100)
+        bus_layout.addWidget(self.bus_data_edit, 0, 1)
+        
+        bus_layout.addWidget(QLabel("Адреса (0-14):"), 0, 2)
+        self.bus_tetrad_edit = QLineEdit("0")
+        self.bus_tetrad_edit.setMaximumWidth(50)
+        bus_layout.addWidget(self.bus_tetrad_edit, 0, 3)
+        
+        bus_layout.addWidget(QLabel("Регистр (0-15):"), 0, 4)
+        self.bus_register_edit = QLineEdit("0")
+        self.bus_register_edit.setMaximumWidth(50)
+        bus_layout.addWidget(self.bus_register_edit, 0, 5)
+        
+        self.bus_write_btn = QPushButton("Записать в шину")
+        self.bus_write_btn.clicked.connect(self.write_to_bus)
+        bus_layout.addWidget(self.bus_write_btn, 1, 0, 1, 3)
+        
+        self.bus_read_btn = QPushButton("Прочитать из шину")
+        self.bus_read_btn.clicked.connect(self.read_from_bus)
+        bus_layout.addWidget(self.bus_read_btn, 1, 3, 1, 3)
+        
+        bus_group.setLayout(bus_layout)
+        layout.addWidget(bus_group)
+        
+        # --- Группа для макросов ---
+        macros_group = QGroupBox("Макросы")
+        macros_layout = QVBoxLayout()
+        
+        # Кнопка создания нового макроса
+        self.create_macro_btn = QPushButton("Создать новый макрос")
+        self.create_macro_btn.clicked.connect(self.create_macro)
+        macros_layout.addWidget(self.create_macro_btn)
+        
+        # Прокручиваемая область для кнопок макросов
+        self.macros_scroll_area = QScrollArea()
+        self.macros_scroll_area.setWidgetResizable(True)
+        # Устанавливаем фиксированную высоту, чтобы вместить 3-4 строки макросов
+        self.macros_scroll_area.setMinimumHeight(150)  # Высота для 3-4 строк
+
+        self.macros_scroll_content = QWidget()
+        self.macros_scroll_layout = QGridLayout()
+        self.macros_scroll_content.setLayout(self.macros_scroll_layout)
+        self.macros_scroll_area.setWidget(self.macros_scroll_content)
+        self.macros_scroll_layout.setAlignment(Qt.AlignTop)
+        macros_layout.addWidget(self.macros_scroll_area)
+        
+        macros_group.setLayout(macros_layout)
+        layout.addWidget(macros_group)
+        
+        # --- ВНЕ ГРУППЫ: Результаты чтения ---
+        results_layout = QGridLayout()
+        
+        # Считанное слово
+        results_layout.addWidget(QLabel("Считанное слово:"), 0, 0)
+        self.bus_read_value_label = QLabel("---")
+        self.bus_read_value_label.setStyleSheet("font-weight: bold; font-size: 14px; border: 1px solid #ccc; padding: 5px;")
+        results_layout.addWidget(self.bus_read_value_label, 0, 1)
+        
+        # Ответ контроллера
+        results_layout.addWidget(QLabel("Ответ контроллера:"), 1, 0)
+        self.bus_result_label = QLabel("---")
+        self.bus_result_label.setStyleSheet("border: 1px solid #ccc; padding: 5px; font-family: monospace;")
+        self.bus_result_label.setWordWrap(True)
+        results_layout.addWidget(self.bus_result_label, 1, 1)
+        
+        # Создаем фрейм для результатов
+        results_frame = QFrame()
+        results_frame.setFrameShape(QFrame.StyledPanel)
+        results_frame.setLayout(results_layout)
+        layout.addWidget(results_frame)
+        
+        layout.addStretch()
+        self.setLayout(layout)
+
+        # После создания интерфейса создаем кнопки для загруженных макросов
+        # ВАЖНО: Используем enumerate для правильных индексов
+        for i, macro in enumerate(self.macros):
+            self.add_macro_button_with_index(macro, i)
+
+    def write_to_bus(self):
+        """Запись в шину через регистры"""
+        try:
+            device_addr = 10
+            data = int(self.bus_data_edit.text(), 16)
+            tetrad = int(self.bus_tetrad_edit.text())
+            register_num = int(self.bus_register_edit.text())
+            
+            success, result = self.serial_bus.write_bus(data, tetrad, register_num, device_addr)
+            
+            if success:
+                self.raw_widget.append_text(f"Запись в шину: адрес={tetrad}, рег={register_num}, данные=0x{data:04X} - OK")
+                self.last_result = f"Запись в шину: данные=0x{data:04X}, адрес=0x{tetrad:X}, регистр=0x{register_num:X}"
+                self.last_result += f"\n{result}"
+            else:
+                self.raw_widget.append_text(f"Запись в шину: адрес={tetrad}, рег={register_num} - Ошибка: {result}")
+                self.last_result = f"Ошибка записи в шину: {result}"
+                
+        except ValueError as e:
+            self.raw_widget.append_text(f"Ошибка в данных: {e}")
+            self.last_result = f"Ошибка в данных: {e}"
+            
+    def read_from_bus(self):
+        """Чтение из шины через регистры"""
+        try:
+            device_addr = 10
+            tetrad = int(self.bus_tetrad_edit.text())
+            register_num = int(self.bus_register_edit.text())
+            
+            success, result = self.serial_bus.read_bus(tetrad, register_num, device_addr)
+            
+            if success:
+                # result теперь словарь с данными
+                hex_str = ' '.join(f'{b:02X}' for b in result['raw_response']['raw'])
+                self.bus_result_label.setText(f"{hex_str}")
+                
+                # Извлекаем считанное слово
+                read_word = result['value']
+                self.bus_read_value_label.setText(f"0x{read_word:04X} ({read_word})")
+                
+                self.raw_widget.append_text(f"Чтение из шины: адрес={tetrad}, рег={register_num} = 0x{read_word:04X}")
+                
+                self.last_result = f"Чтение из шины: адрес=0x{tetrad:X}, регистр=0x{register_num:X}"
+                self.last_result += f"\nСчитано: 0x{read_word:04X} ({read_word})"
+                self.last_result += f"\nОтвет контроллера: {hex_str}"
+            else:
+                self.bus_result_label.setText(f"Ошибка: {result}")
+                self.bus_read_value_label.setText("---")
+                self.raw_widget.append_text(f"Чтение из шины: адрес={tetrad}, рег={register_num} - Ошибка: {result}")
+                self.last_result = f"Ошибка чтения из шины: {result}"
+                    
+        except ValueError as e:
+            self.bus_result_label.setText(f"Ошибка: {e}")
+            self.bus_read_value_label.setText("---")
+            self.raw_widget.append_text(f"Ошибка в данных: {e}")
+            self.last_result = f"Ошибка в данных: {e}"
+                    
+        except ValueError as e:
+            self.bus_result_label.setText(f"Ошибка: {e}")
+            self.bus_read_value_label.setText("---")
+            error_text = f"Ошибка в данных: {e}"
+            self.raw_widget.append_text(f"✗ {error_text}")
+            self.last_result = error_text
+            
+    def create_macro(self):
+        """Создать новый макрос"""
+        dialog = MacroEditorDialog(self)
+        if dialog.exec_():
+            macro = dialog.get_macro()
+            if not macro['name']:
+                macro['name'] = f"Макрос {len(self.macros) + 1}"
+            
+            self.macros.append(macro)
+            self.add_macro_button(macro)
+            self.save_macros()  # Сохраняем после добавления
+
+        dialog.deleteLater()
+        QApplication.processEvents()  # Обрабатываем события
+
+
+    def add_macro_button_with_index(self, macro, index):
+        """Добавить кнопку макроса в интерфейс с указанным индексом"""
+        # Изменяем расчет строк и колонок для 3 колонок
+        items_per_row = 3  # Теперь 3 кнопки в строке
+        row = len(self.macro_buttons) // items_per_row
+        col = len(self.macro_buttons) % items_per_row
+        
+        # Создаем контейнер для кнопки и кнопки редактирования
+        container = QWidget()
+        container_layout = QHBoxLayout()
+        container_layout.setContentsMargins(0, 0, 0, 0)
+        
+        # Основная кнопка макроса
+        macro_btn = QPushButton(macro['name'])
+        macro_btn.setMinimumHeight(40)
+        macro_btn.setStyleSheet("""
+            QPushButton {
+                font-weight: bold;
+                text-align: left;
+                padding: 10px;
+            }
+            QPushButton:hover {
+                background-color: #e0e0e0;
+            }
+        """)
+        
+        # Используем partial для фиксации индекса
+        macro_btn.clicked.connect(partial(self.execute_macro_by_index, index))
+        
+        # Кнопка редактирования
+        edit_btn = QPushButton("✎")
+        edit_btn.setFixedSize(30, 30)
+        edit_btn.setToolTip("Редактировать макрос")
+        edit_btn.clicked.connect(partial(self.edit_macro_by_index, index))
+        
+        # Кнопка удаления
+        delete_btn = QPushButton("✕")
+        delete_btn.setFixedSize(30, 30)
+        delete_btn.setToolTip("Удалить макрос")
+        delete_btn.clicked.connect(partial(self.delete_macro, index))
+        
+        container_layout.addWidget(macro_btn)
+        container_layout.addWidget(edit_btn)
+        container_layout.addWidget(delete_btn)
+        container.setLayout(container_layout)
+        
+        self.macros_scroll_layout.addWidget(container, row, col, 1, 1)  # span изменен на 1
+        self.macro_buttons.append(container)
+
+        
+    def add_macro_button(self, macro):
+        """Добавить кнопку макроса в интерфейс (при создании нового)"""
+        # При создании нового макроса используем последний индекс
+        index = len(self.macros) - 1
+        self.add_macro_button_with_index(macro, index)
+
+    def execute_macro_by_index(self, macro_index):
+        """Выполнить макрос по индексу"""
+        if 0 <= macro_index < len(self.macros):
+            self.execute_macro_commands(self.macros[macro_index]['commands'])
+
+    def edit_macro_by_index(self, macro_index):
+        """Редактировать макрос по индексу"""
+        if 0 <= macro_index < len(self.macros):
+            dialog = MacroEditorDialog(self, self.macros[macro_index])
+            if dialog.exec_():
+                edited_macro = dialog.get_macro()
+                self.macros[macro_index] = edited_macro
+                
+                # Обновляем кнопку - находим ее по индексу
+                if macro_index < len(self.macro_buttons):
+                    container = self.macro_buttons[macro_index]
+                    macro_btn = container.layout().itemAt(0).widget()
+                    if macro_btn:
+                        macro_btn.setText(edited_macro['name'])
+                
+                self.save_macros()
+                
+            dialog.deleteLater()
+            QApplication.processEvents()  # Обрабатываем события
+                
+    # Добавим метод для удаления макроса
+    def delete_macro(self, macro_index):
+        """Удалить макрос"""
+        if 0 <= macro_index < len(self.macros):
+            # Спросим подтверждение
+            reply = QMessageBox.question(
+                self, 
+                "Удаление макроса",
+                f"Удалить макрос '{self.macros[macro_index]['name']}'?",
+                QMessageBox.Yes | QMessageBox.No,
+                QMessageBox.No
+            )
+            
+            if reply == QMessageBox.Yes:
+                # Удаляем макрос из списка
+                del self.macros[macro_index]
+                
+                # Полностью перестраиваем layout
+                self.rebuild_macros_layout()
+                
+                # Сохраняем изменения
+                self.save_macros()
+
+    def execute_macro_commands(self, commands):
+        """Выполнить список команд макроса"""
+        last_read_result = None
+        
+        for i, cmd in enumerate(commands):
+            try:
+                if cmd['type'] == 'write':
+                    success, result = self.serial_bus.write_bus(
+                        cmd['data'], 
+                        cmd['tetrad'], 
+                        cmd['register'], 
+                        10
+                    )
+                    if success:
+                        self.raw_widget.append_text(f"Макрос: запись устр.{cmd['tetrad']}, рег.{cmd['register']}, 0x{cmd['data']:04X} - OK")
+                    else:
+                        self.raw_widget.append_text(f"Макрос: запись устр.{cmd['tetrad']}, рег.{cmd['register']} - Ошибка: {result}")
+                        
+                else:  # read
+                    success, result = self.serial_bus.read_bus(
+                        cmd['tetrad'], 
+                        cmd['register'], 
+                        10
+                    )
+                    if success:
+                        # Сохраняем последний результат чтения для отображения
+                        last_read_result = result
+                        hex_str = ' '.join(f'{b:02X}' for b in result['raw_response']['raw'])
+                        read_word = result['value']
+                        self.raw_widget.append_text(f"Макрос: чтение устр.{cmd['tetrad']}, рег.{cmd['register']} = 0x{read_word:04X}")
+                    else:
+                        self.raw_widget.append_text(f"Макрос: чтение устр.{cmd['tetrad']}, рег.{cmd['register']} - Ошибка: {result}")
+                        
+            except Exception as e:
+                self.raw_widget.append_text(f"Макрос команда {i+1}: ошибка - {e}")
+                
+        # Обновляем интерфейс с результатами последнего чтения
+        if last_read_result:
+            hex_str = ' '.join(f'{b:02X}' for b in last_read_result['raw_response']['raw'])
+            read_word = last_read_result['value']
+            self.bus_result_label.setText(hex_str)
+            self.bus_read_value_label.setText(f"0x{read_word:04X} ({read_word})")
+
+
+    def load_macros(self):
+        """Загрузить макросы из файла"""
+        if os.path.exists(self.MACROS_FILE):
+            try:
+                with open(self.MACROS_FILE, 'r', encoding='utf-8') as f:
+                    self.macros = json.load(f)
+                print(f"Загружено {len(self.macros)} макросов")
+            except Exception as e:
+                print(f"Ошибка загрузки макросов: {e}")
+                self.macros = []
+        else:
+            self.macros = []
+    
+    def save_macros(self):
+        """Сохранить макросы в файл"""
+        try:
+            with open(self.MACROS_FILE, 'w', encoding='utf-8') as f:
+                json.dump(self.macros, f, ensure_ascii=False, indent=2)
+            print(f"Сохранено {len(self.macros)} макросов")
+        except Exception as e:
+            print(f"Ошибка сохранения макросов: {e}")
+
+    def rebuild_macros_layout(self):
+        """Перестроить layout макросов"""
+        # Очищаем layout
+        for i in reversed(range(self.macros_scroll_layout.count())):
+            item = self.macros_scroll_layout.itemAt(i)
+            if item and item.widget():
+                item.widget().setParent(None)
+        
+        # Очищаем список кнопок
+        self.macro_buttons.clear()
+        
+        # Пересоздаем все кнопки с правильными индексами
+        for i, macro in enumerate(self.macros):
+            self.add_macro_button_with_index(macro, i)
+
+
+    def get_last_result(self):
+        """Получить последний результат операции"""
+        result = getattr(self, 'last_result', '')
+        return result