release 1.04.1

фикс кривой записи файлов для matlab 2021

McuLib/install_my_library.m

@@ -2,46 +2,24 @@
 function install_my_library()
     libDir = fileparts(mfilename('fullpath'));
 
+    % Путь к файлу-флагу, указывающему, что установка уже была
+    flagFile = fullfile(libDir, '.library_installed.mat');
+
+    % Если библиотека уже установлена — просто выходим
+    if isfile(flagFile)
+        return;
+    end
+
     % 1. Добавляем библиотеку и m-файлы в путь
     addpath(fullfile(libDir, 'lib'));
     addpath(fullfile(libDir, 'm'));
     savepath;
 
-    % 2. Диалог выбора папки для копирования шаблонов
-    defaultTargetDir = pwd;
-    answer = questdlg(['Выберите папку для копирования шаблонов кода. ', ...
-        'По умолчанию текущая папка: ' defaultTargetDir], ...
-        'Выбор папки', ...
-        'Текущая папка', 'Выбрать другую', 'Текущая папка');
-    
-    switch answer
-        case 'Выбрать другую'
-            targetDir = uigetdir(defaultTargetDir, 'Выберите папку для шаблонов');
-            if isequal(targetDir,0)
-                disp('Копирование шаблонов отменено пользователем.');
-                targetDir = '';
-            end
-        case 'Текущая папка'
-            targetDir = defaultTargetDir;
-        otherwise
-            targetDir = defaultTargetDir;
-    end
-    
-    if ~isempty(targetDir)
-        templatesDir = fullfile(libDir, 'templates');
-        templateFiles = dir(fullfile(templatesDir, '*.*'));
-        for k = 1:numel(templateFiles)
-            if ~templateFiles(k).isdir
-                copyfile(fullfile(templatesDir, templateFiles(k).name), ...
-                         fullfile(targetDir, templateFiles(k).name));
-            end
-        end
-        fprintf('Шаблоны кода скопированы в папку:\n%s\n', targetDir);
-    end
-
-    % 3. Обновляем Library Browser
+    % 2. Обновляем Library Browser
     rehash;
     sl_refresh_customizations;
 
-    disp('Библиотека успешно установлена и добавлена в Library Browser.');
+    % 3. Сохраняем флаг установки
+    installedOn = datetime('now');
+    save(flagFile, 'installedOn');
 end

McuLib/m/appWrap.m

@@ -0,0 +1,209 @@
+classdef appWrap
+    % Класс для редактирования кода обёртки МК прямо внутри MATLAB/Simulink
+    % Позволяет работать с кодом микроконтроллера без переключения между IDE
+
+    methods(Static)
+        
+        function appWrapperFunc()
+            % Загружает код обёртки из файлов в интерфейс MATLAB для редактирования
+            % Автоматически вызывается при выборе типа кода в маске блока
+            
+            block = gcb;  % Получаем текущий блок Simulink для редактирования
+            
+            % Определяем какой файл и секцию нужно редактировать
+            [filename, section, tool, example] = appWrap.getAppWrapperUserFile(block);
+            
+            % Показываем подсказку по выбранному типу кода прямо в MATLAB
+            mcuMask.tool(tool, example);
+
+            % Очищаем поле редактирования перед загрузкой нового кода
+            set_param(block, 'appWrapperCode', '');
+            
+            % Загружаем код из файла в интерфейс MATLAB
+            try
+                % Читаем исходный код из файла
+                code = fileread(filename);
+                code = regexprep(code, '\r\n?', '\n');  % унифицируем переводы строк для MATLAB
+                
+                % Вырезаем только нужную секцию для редактирования
+                includesText = editCode.extractSection(code, section);
+                
+                % Загружаем код в текстовое поле маски для редактирования
+                set_param(block, 'appWrapperCode', includesText);
+            catch
+                % Если файл не найден или ошибка чтения - оставляем поле пустым
+                % Пользователь сможет написать код с нуля прямо в MATLAB
+            end
+        end
+            
+        function saveAppWrapperCode()
+            % Сохраняет отредактированный код из MATLAB обратно в файлы обёртки
+            % Вызывается при нажатии кнопки "Сохранить" в интерфейсе
+            
+            block = gcb;  % Текущий редактируемый блок
+
+            % Определяем куда сохранять based на выборе пользователя в MATLAB
+            [filename, section] = appWrap.getAppWrapperUserFile(block);
+            
+            % Проверяем что файл существует перед сохранением
+            if ~isfile(filename)
+                errordlg(['Файл не найден: ', filename], 'Ошибка сохранения в MATLAB');
+                return;
+            end
+            
+            % Получаем выбранный тип кода и путь к файлам
+            sel = get_param(block, 'appWrapperFunc');
+            basePath = get_param(block, 'appWrapperPath');
+            
+            if isempty(basePath)
+                errordlg('Не указан путь к файлам обёртки.', 'Ошибка в MATLAB');
+                return;
+            end
+            
+            % Получаем код который пользователь написал/отредактировал в MATLAB
+            newBody = get_param(block, 'appWrapperCode');
+            
+            % Читаем текущее содержимое файла чтобы сохранить структуру
+            code = fileread(filename);
+            code = regexprep(code, '\r\n?', '\n');
+            
+            % Экранируем специальные символы для корректного сохранения из MATLAB
+            newBody = strrep(newBody, '\', '\\');
+            
+            % Вставляем отредактированную в MATLAB секцию обратно в файл
+            code = editCode.insertSection(code, section, newBody);
+            
+            % Сохраняем изменения прямо из MATLAB без внешних редакторов
+            fid = fopen(filename, 'w', 'n');
+            if fid == -1
+                errordlg('Не удалось сохранить файл из MATLAB', 'Ошибка записи');
+                return;
+            end
+            
+            % Записываем обновленный код
+            fwrite(fid, code);
+            fclose(fid);
+            
+            % Подтверждаем успешное сохранение в интерфейсе MATLAB
+            mcuMask.disp(1, ['Сохранено в MATLAB: ' sel]);
+        end
+
+        function openAppWrapperCode()
+            % Альтернативный способ: открывает файл в системном редакторе
+            % Для случаев когда нужно работать во внешней IDE
+            
+            block = gcb;
+
+            % Получаем абсолютный путь к файлу для открытия
+            filename = mcuPath.getAbsolutePath(appWrap.getAppWrapperUserFile(block));
+            
+            if exist(filename, 'file') == 2
+                % Открываем через системный диалог "Открыть с помощью"
+                % Полезно если нужно использовать привычную IDE вместо редактора MATLAB
+                cmd = sprintf('rundll32.exe shell32.dll,OpenAs_RunDLL %s', filename);
+                status = system(cmd);
+                
+                if status ~= 0
+                    errordlg('Не удалось открыть файл во внешнем редакторе');
+                end
+            else
+                errordlg('Файл не найден для открытия');
+            end            
+        end
+
+
+        %% SPECIFIC TOOLS
+        function [filename, section, tool, example] = getAppWrapperUserFile(block, sel)
+            % Маппинг типов кода на файлы и секции для редактирования в MATLAB
+            % Центральное место настройки - здесь определяется где что редактировать
+            
+            if (nargin < 2)
+                % Получаем какой тип кода пользователь выбрал в интерфейсе MATLAB
+                sel = get_param(block, 'appWrapperFunc');
+            end
+            
+            % Базовый путь к файлам обёртки (настраивается в маске)
+            basePath = mcuPath.get('appWrapperPath');
+            if isempty(basePath)
+                errordlg('Не указан путь к файлам обёртки.');
+                return;
+            end
+            
+            % В зависимости от выбора в MATLAB - определяем что редактировать:
+            if strcmp(sel, 'Includes')
+                % Редактирование подключения заголовочных файлов
+                filename = fullfile(basePath, 'app_includes.h');
+                section = '// INCLUDES';
+                tool = 'Инклюды для доступа к коду МК в коде оболочке';
+                example =  '#include "main.h"';  % Пример для подсказки в MATLAB
+                
+            elseif strcmp(sel, 'Dummy')
+                % Редактирование заглушек для симуляции
+                filename = fullfile(basePath, 'app_wrapper.c');
+                section = '// DUMMY';
+                tool = 'Заглушки для различных функций и переменных';
+                example = ['CAN_HandleTypeDef hcan = {0};' newline...
+                    'void hardware_func(handle *huart) {}' newline...
+                    'int wait_for_hardware_flag(int *flag) {' newline...
+                    '    return 1;' newline...
+                    '}' newline...
+                    ''];
+                    
+            elseif strcmp(sel, 'App Init')
+                % Редактирование кода инициализации приложения
+                filename = fullfile(basePath, 'app_init.c');
+                section = '// USER APP INIT';
+                tool = ['Код для инициализации приложения МК.' newline newline...
+                    'Вызов функций инициализации, если не используется отдельный поток для main().'];
+                example =  'init_func();';
+                
+            elseif strcmp(sel, 'App Step')
+                % Редактирование кода выполняемого на каждом шаге симуляции
+                filename = fullfile(basePath, 'app_wrapper.c');
+                section = '// USER APP STEP';
+                tool = ['Код приложения МК для вызова в шаге симуляции.' newline newline ...
+                    'Вызов функций программы МК, если не используется отдельный поток для main().'];
+                example =  'step_func();';
+                
+            elseif strcmp(sel, 'App Inputs')
+                % Редактирование обработки входных данных от Simulink
+                filename = fullfile(basePath, 'app_io.c');
+                section = '// USER APP INPUT';
+                tool = ['Работа с буффером для портов S-Function' newline newline ...
+                    'Буфер в начале хранит входные порты S-Function, далее идут выходные порты:' newline ...
+                    'Buffer[0:15] - входной порт, Buffer[16:31] - входной 1 порт, ' newline ...
+                    'Buffer[32:47] - выходной 1 порт, Buffer[48:63] - выходной 2 порт'];
+                example = ['// чтение 1-го элемента 0-го входного массива' newline...
+                    'app_variable_2 = ReadInputArray(0, 1);' newline newline...
+                    '// запись в буфер выходов' newline ...
+                    'app_variable_2 = Buffer[10];'];
+                    
+            elseif strcmp(sel, 'App Outputs')
+                % Редактирование формирования выходных данных для Simulink
+                filename = fullfile(basePath, 'app_io.c');
+                section = '// USER APP OUTPUT';
+                tool = ['Работа с буффером для портов S-Function' newline newline ...
+                    'Буфер в начале хранит входные порты S-Function, далее идут выходные порты:' newline ...
+                    'Buffer[0:15] - входной порт, Buffer[16:31] - входной 1 порт, ' newline ...
+                    'Buffer[32:47] - выходной 1 порт, Buffer[48:63] - выходной 2 порт'];
+                example = ['// запись в 1-й элемент 0-го выходного массива' newline...
+                    'WriteOutputArray(app_variable, 0, 1);' newline newline ...
+                    '// запись в буфер выходов' newline ...
+                    'Buffer[XD_OUTPUT_START + 10] = app_variable_2;'];
+                    
+            elseif strcmp(sel, 'App Deinit')
+                % Редактирование кода деинициализации
+                filename = fullfile(basePath, 'app_init.c');
+                section = '// USER APP DEINIT';
+                tool = ['Код для деинициализации приложения МК.' newline newline ...
+                    'Можно деинициализировать приложение МК, для повторного запуска.'];
+                example =  'memset(&htim1, sizeof(htim1), 0;';
+                
+            else
+                % Неизвестный тип кода - выводим сообщение в консоль MATLAB
+                tool = '';
+                mcuMask.disp(0, '\nОшибка выбора типа секции кода: неизвестное значение');
+            end
+        end
+    end
+end

McuLib/m/asynchManage.m

@@ -1,104 +1,124 @@
 classdef asynchManage < handle
+    % Менеджер асинхронных операций для работы с моделью Simulink
+    % Решает проблемы блокировки модели при одновременном доступе из GUI
+    % Использует таймеры для отложенного выполнения операций с моделью
+
     properties (Access = private)
-        modelName     % Имя модели
-        maskBlockPath % Полный путь к блоку с маской
-        timerSave
-        timerUpdate
-        timerConfigUpdate
+        modelName     % Имя модели Simulink для управления
+        maskBlockPath % Полный путь к блоку с маской (если нужен доступ к GUI)
+        timerSave     % Таймер для операции сохранения модели
+        timerUpdate   % Таймер для операции обновления модели  
+        timerConfigUpdate % Таймер для обновления конфигурации
     end
 
     methods
         function obj = asynchManage(modelName, maskBlockPath)
-            % Конструктор принимает имя модели и путь к блоку с маской
+            % Конструктор - создает менеджер для асинхронных операций
+            % modelName - имя модели Simulink для управления
+            % maskBlockPath - путь к блоку с маской (опционально, для GUI)
             obj.modelName = modelName;
             if nargin < 2
-                obj.maskBlockPath = ''; % если не передали, оставляем пустым
+                obj.maskBlockPath = ''; % Если не передали - работаем без GUI
             else
                 obj.maskBlockPath = maskBlockPath;
             end
         end
 
         function saveAndUpdateModel(obj)
+            % Асинхронное сохранение и обновление модели
+            % Использует таймер чтобы избежать конфликтов доступа к модели
             obj.timerSave = timer(...
-                'StartDelay', 0.01, ...
-                'ExecutionMode', 'singleShot', ...
-                'TimerFcn', @(~,~) obj.saveCallback());
+                'StartDelay', 0.01, ...      % Короткая задержка чтобы освободить модель
+                'ExecutionMode', 'singleShot', ... % Однократное выполнение
+                'TimerFcn', @(~,~) obj.saveCallback()); % Колбэк сохранения
             start(obj.timerSave);
         end
 
-
         function updateGUIfromConfig(obj)
+            % Асинхронное обновление GUI из конфигурации
+            % Используется когда нужно перезагрузить маску с новыми параметрами
             obj.timerConfigUpdate = timer(...
-                'StartDelay', 0.01, ...
+                'StartDelay', 0.01, ... % Задержка для стабилизации модели
                 'ExecutionMode', 'singleShot', ...
-                'TimerFcn', @(~,~) obj.GUIconfigCallback());
+                'TimerFcn', @(~,~) obj.GUIconfigCallback()); % Колбэк обновления GUI
             start(obj.timerConfigUpdate);
         end
     end
 
     methods (Access = private)
         function saveCallback(obj)
+            % Колбэк для сохранения модели - вызывается через таймер
             try
-                mcuMask.saveAndClose(obj.maskBlockPath);
+                % Закрываем маску чтобы разблокировать модель для сохранения
+                mcuMask.close(obj.maskBlockPath);
+                % Сохраняем модель (это могло бы вызвать конфликт без таймера)
                 save_system(obj.modelName);
             catch ME
                 warning('progr:Nneg', 'Ошибка при сохранении модели: %s', ME.message);
             end
+            
+            % Очищаем таймер сохранения
             stop(obj.timerSave);
             delete(obj.timerSave);
             obj.timerSave = [];
 
+            % Запускаем таймер для обновления модели после сохранения
             obj.timerUpdate = timer(...
-                'StartDelay', 0.05, ...
+                'StartDelay', 0.05, ... % Большая задержка для полного сохранения
                 'ExecutionMode', 'singleShot', ...
-                'TimerFcn', @(~,~) obj.updateCallback());
+                'TimerFcn', @(~,~) obj.updateCallback()); % Колбэк обновления
             start(obj.timerUpdate);
         end
 
         function updateCallback(obj)
+            % Колбэк для обновления модели - вызывается после сохранения
             try
+                % Команда обновления модели (перекомпиляция и т.д.)
                 set_param(obj.modelName, 'SimulationCommand', 'update');
+                % Повторное сохранение после обновления
                 save_system(obj.modelName);
             catch ME
                 warning('progr:Nneg', 'Ошибка при обновлении модели: %s', ME.message);
             end
 
-            % Открываем маску, если задан путь к блоку
+            % Переоткрываем маску если был указан путь к блоку
             if ~isempty(obj.maskBlockPath)
                 try
-                    mcuMask.open(obj.maskBlockPath, 1);
-                    fprintf('Mask opened for block %s\n', obj.maskBlockPath);
+                    mcuMask.open(obj.maskBlockPath, 1); % Открываем маску снова
                 catch ME
                     warning('progr:Nneg', 'Не удалось открыть маску: %s', ME.message);
                 end
             end
 
+            % Очищаем таймер обновления
             stop(obj.timerUpdate);
             delete(obj.timerUpdate);
             obj.timerUpdate = [];
         end
-        function GUIconfigCallback(obj)
         
+        function GUIconfigCallback(obj)
+            % Колбэк для обновления GUI из конфигурации
             try
-                mcuMask.saveAndClose(obj.maskBlockPath);
-                mexing(0);
+                % Закрываем маску и выполняем настройку (mexing)
+                mcuMask.close(obj.maskBlockPath);
+                mexing(0); % Функция настройки/компиляции
             catch ME
                 warning('progr:Nneg', 'Ошибка при обновлении модели: %s', ME.message);
             end
 
-            % Открываем маску, если задан путь к блоку
+            % Переоткрываем маску с обновленными параметрами
             if ~isempty(obj.maskBlockPath)
                 try
-                    mcuMask.open(obj.maskBlockPath, 1);
+                    mcuMask.open(obj.maskBlockPath, 1); % Открываем обновленную маску
                 catch ME
                     warning('progr:Nneg', 'Не удалось открыть маску: %s', ME.message);
                 end
             end
 
+            % Очищаем таймер обновления конфигурации
             stop(obj.timerConfigUpdate);
             delete(obj.timerConfigUpdate);
             obj.timerConfigUpdate = [];
         end
-
     end
 end

McuLib/m/compiler.m

@@ -0,0 +1,162 @@
+classdef compiler
+    % Класс для компиляции бинарника S-Function в MATLAB
+    % Управляет процессом сборки mex-файлов для Simulink
+    methods(Static)
+
+        function compile()
+            % Основная функция компиляции S-Function
+            % Добавляет путь к файлам обёртки и запускает компиляцию
+            addpath(mcuPath.get('wrapperPath'));
+            mexing(1);  % 1 - флаг компиляции
+        end
+
+		% хз че это
+        function get_availbe()
+            addpath(mcuPath.get('wrapperPath'));
+            mexing(1);
+        end
+        function choose()
+            addpath(mcuPath.get('wrapperPath'));
+            mexing(1);
+        end
+
+        function updateRunBat()
+            % Обновление BAT-файла для компиляции S-Function
+            % Формирует списки исходных файлов и путей для включения
+            
+            % === КОМПИЛЯЦИЯ ОСНОВНОЙ ОБЁРТКИ ===
+            sources = {
+                'MCU.c'
+                'mcu_wrapper.c'
+            };
+            % Список заголовочных файлов (.h)
+            includes = { '.\' };
+            wrapperPath = mcuPath.get('wrapperPath');
+            
+            % Формируем строки для BAT-файла
+            wrapperSrcText = compiler.createSourcesBat('code_WRAPPER', sources, wrapperPath);
+            wrapperIncText = compiler.createIncludesBat('includes_WRAPPER', includes, wrapperPath);
+            
+            % Обновляем BAT-файл для основной обёртки
+            res = compiler.updateRunMexBat(wrapperSrcText, wrapperIncText, ':: WRAPPER BAT');
+            
+            % Если ошибка - прекращаем выполнение
+            if res == 0
+                return
+            end
+
+            % === КОМПИЛЯЦИЯ ПРИЛОЖЕНИЯ ОБЁРТКИ ===
+            sources = {
+                'app_wrapper.c'
+                'app_init.c'
+                'app_io.c'
+            };            
+            % Список заголовочных файлов (.h)
+            includes = { '.\' };
+            periphPath = mcuPath.get('appWrapperPath');
+            
+            % Формируем строки для BAT-файла
+            wrapperSrcText = compiler.createSourcesBat('code_APP_WRAPPER', sources, periphPath);
+            wrapperIncText = compiler.createIncludesBat('includes_APP_WRAPPER', includes, periphPath);
+            
+            % Обновляем BAT-файл для обёртки приложения
+            res = compiler.updateRunMexBat(wrapperSrcText, wrapperIncText, ':: APP WRAPPER BAT');
+
+            % Обновляем BAT-файл для периферии
+            periphConfig.updatePeriphRunMexBat();
+        end
+            
+        function res = updateRunMexBat(srcText, incText, Section)
+        % Обновляет секцию в BAT-файле для компиляции mex
+        % Входные параметры:
+        %   srcText     - текст для записи set code_... (исходные файлы)
+        %   incText     - текст для записи set includes_... (пути включения)
+        %   Section     - секция в BAT-файле для обновления
+        %
+        % Возвращает:
+        %   res - 1 при успехе, 0 при ошибке
+            % Объединяем исходные файлы и пути включения
+            periphBat = [srcText '\n\n' incText];
+            batPath = fullfile(mcuPath.get('wrapperPath'), 'run_mex.bat');
+            res = 1;  % По умолчанию - ошибка
+            
+            try
+                % Читаем текущее содержимое BAT-файла
+                code = fileread(batPath);
+                code = regexprep(code, '\r\n?', '\n');  % Нормализуем переводы строк
+                
+                % Вставляем новую секцию в BAT-файл
+                code = editCode.insertSection(code, Section, periphBat);
+                
+                % Записываем обновленный BAT-файл
+                fid = fopen(batPath, 'w', 'n');
+                if fid == -1
+                    error('Не удалось открыть файл для записи');
+                end
+                fwrite(fid, code);
+                fclose(fid);
+                res = 1;  % Успех
+            catch ME
+                % Ошибка записи в BAT-файл
+                mcuMask.disp(0, '\nОшибка: неудачная запись в файл при записи файла: %s', ME.message);
+            end
+        end
+
+        function srcText = createSourcesBat(prefix_name, sources, path)
+            % Создает строку с исходными файлами для BAT-файла
+            % Формат: set code_WRAPPER=file1.c file2.c ...
+            
+            srcList = {};
+            if nargin >= 2 && iscell(sources)
+                for i = 1:numel(sources)
+                    % Формируем полный путь к исходному файлу
+                    fullPath = fullfile(path, sources{i});
+                    srcList{end+1} = strrep(fullPath, '\', '\\');  % Экранирование слешей
+                end
+            end
+        
+            % Формируем srcText с переносами строк и символом продолжения ^
+            srcText = '';
+            for i = 1:numel(srcList)
+                if i < numel(srcList)
+                    srcText = [srcText srcList{i} '^' newline ' '];  % ^ для продолжения строки в BAT
+                else
+                    srcText = [srcText srcList{i}];  % Последний файл без продолжения
+                end
+            end
+        
+            % Добавляем префикс переменной BAT
+            srcText = ['set ' prefix_name '=' srcText];
+        end
+        
+        function incText = createIncludesBat(prefix_name, includes, path)
+            % Создает строку с путями включения для BAT-файла
+            % Формат: set includes_WRAPPER=-I"path1" -I"path2" ...
+            
+            incList = {};
+            if nargin >= 2 && iscell(includes)
+                for i = 1:numel(includes)
+                    % Формируем полный путь для включения
+                    fullPath = fullfile(path, includes{i});
+                    incList{end+1} = ['-I"' strrep(fullPath, '\', '\\') '"'];  % Флаг include для компилятора
+                end
+            end
+        
+            % Формируем incText с переносами строк и символом продолжения ^
+            incText = '';
+            for i = 1:numel(incList)
+                if i == 1 && numel(incList) ~= 1
+                    incText = [incText incList{i} '^' newline];  % Первый элемент с продолжением
+                elseif i < numel(incList)
+                    incText = [incText ' ' incList{i} '^' newline];  % Средние элементы с продолжением
+                else
+                    incText = [incText ' ' incList{i}];  % Последний элемент без продолжения
+                end
+            end
+        
+            % Добавляем префикс переменной BAT
+            incText = ['set ' prefix_name '=' incText];
+        end
+        
+    end
+end

McuLib/m/configJs.m

@@ -0,0 +1,177 @@
+classdef configJs
+    % Класс для работы с JSON конфигурацией периферии в масках Simulink
+    % Обеспечивает чтение, запись и обновление конфигов из/в JSON файлы
+
+    methods(Static)
+    
+        function config = update(blockPath, config)
+            % Обновляет конфигурацию значениями из маски Simulink
+            % blockPath - путь к блоку с маской
+            % config - структура конфигурации для обновления
+            
+            if isempty(config)
+                return;
+            end
+        
+            % Получаем маску и все её параметры
+            mask = Simulink.Mask.get(blockPath);
+            maskParams = mask.Parameters;
+            paramNames = arrayfun(@(p) p.Name, maskParams, 'UniformOutput', false);
+
+            % Обрабатываем все секции периферии в конфиге
+            periphs = fieldnames(config);        
+            for i = 1:numel(periphs)
+                periph = periphs{i};
+        
+                % Проверяем есть ли секция Defines в этой периферии
+                if ~isfield(config.(periph), 'Defines')
+                    continue;
+                end
+        
+                % Получаем все определения (defines) для этой периферии
+                defines = config.(periph).Defines;
+                defNames = fieldnames(defines);
+        
+                % Обходим все определения и обновляем их значения из маски
+                for j = 1:numel(defNames)
+                    defPrompt = defNames{j};
+                    paramName = matlab.lang.makeValidName(defPrompt);  % Создаем валидное имя параметра
+        
+                    % Проверяем существует ли параметр с таким именем в маске
+                    if ismember(paramName, paramNames)
+                        param = mask.getParameter(paramName);
+                        valStr = param.Value;  % Значение как строка из маски
+        
+                        % Проверяем существует ли элемент defPrompt в структуре defines
+                        if isfield(defines, defPrompt)
+                            % Преобразуем строку из маски в соответствующий тип данных
+                            if strcmpi(defines.(defPrompt).Type, 'checkbox')
+                                % Для чекбоксов преобразуем 'on'/'off' в true/false
+                                config.(periph).Defines.(defPrompt).Default = strcmpi(valStr, 'on');
+                            elseif strcmpi(defines.(defPrompt).Type, 'edit')
+                                % Для текстовых полей пробуем преобразовать в число
+                                valNum = str2double(valStr);
+                                if isnan(valNum)
+                                    % Если не число - оставляем строкой
+                                    config.(periph).Defines.(defPrompt).Default = valStr;
+                                else
+                                    % Если число - сохраняем как число
+                                    config.(periph).Defines.(defPrompt).Default = valNum;
+                                end
+                            end
+                        end
+                    end
+                end
+            end
+        end
+       
+        function config = read(blockPath)
+            % Читает JSON конфигурацию из файла указанного в маске
+            % blockPath - путь к блоку с маской
+            % Возвращает структуру конфигурации или пустой массив
+            
+            mask = Simulink.Mask.get(blockPath);
+        
+            % Получаем путь к конфигурационному файлу из параметра маски
+            pathparam = mask.getParameter('periphPath');
+            config_path = pathparam.Value;
+        
+            if ~isempty(config_path)
+                % Читаем и декодируем JSON файл
+                jsonText = fileread(config_path);
+                config = jsondecode(jsonText);
+            else
+                config = [];
+            end
+        end
+
+        function write(config)
+            % Записывает конфигурацию обратно в JSON файл
+            % config - структура конфигурации для записи
+            
+            if isempty(config)
+                return
+            end
+
+            % Получаем handle текущего блока и его маску
+            blockHandle = gcbh;
+            mask = Simulink.Mask.get(blockHandle);
+        
+            % Получаем путь к конфигурационному файлу из маски
+            pathparam = mask.getParameter('periphPath');
+            config_path = pathparam.Value;
+        
+            % Кодируем структуру в JSON с красивым форматированием
+            jsonText = jsonencode(config, 'PrettyPrint', true);
+            
+            % Записываем JSON в файл
+            fid = fopen(config_path, 'w', 'n');
+            if fid == -1
+                error('Не удалось открыть файл periph_config.json для записи.');
+            end
+            fwrite(fid, jsonText, 'char');
+            fclose(fid);
+        end
+
+        function value = get_field(configStruct, targetConfig)
+            % Рекурсивно ищет поле в структуре конфигурации
+            % configStruct - структура для поиска
+            % targetConfig - имя целевого поля
+            % Возвращает значение поля или пустой массив если не найдено
+            
+            value = [];
+            fields = fieldnames(configStruct);
+        
+            for i = 1:numel(fields)
+                key = fields{i};
+                if strcmp(key, targetConfig)
+                    % Нашли прямое совпадение
+                    value = configStruct.(key);
+                    return;
+                elseif isstruct(configStruct.(key))
+                    % Рекурсивно ищем во вложенной структуре
+                    value = configJs.get_field(configStruct.(key), targetConfig);
+                    if ~isempty(value)
+                        return; % Нашли во вложенной структуре
+                    end
+                end
+            end
+        
+            % Если не нашли - возвращаем пустой массив
+            if isempty(value)
+                % Можно раскомментировать для отладки:
+                % error('Поле "%s" не найдено в структуре.', targetConfig);
+            end
+        end
+        
+        function short = get_final_name_from_prefix(prefix)
+            % Извлекает короткое имя из префикса (последняя часть после '_')
+            % prefix - строка с префиксом вида 'PREFIX_NAME'
+            % Возвращает последнюю часть после последнего '_'
+            
+            parts = strsplit(prefix, '_');
+            short = parts{end};  % Берём последний элемент
+        end
+
+        function value = convert_code_value(codeField)
+            % Преобразует значение поля Options в строку для отображения
+            % Обрабатывает разные типы данных: char, string, cell array
+            
+            if ischar(codeField)
+                value = codeField;
+            elseif isstring(codeField)
+                value = char(codeField);
+            elseif iscell(codeField)
+                % Объединяем ячейки в одну строку с переносами
+                value = strjoin(codeField, newline);
+            else
+                % Для неподдерживаемых типов возвращаем пустую строку
+                value = '';
+            end
+        end
+    end
+
+    methods(Static, Access=private)
+        % Приватные методы могут быть добавлены здесь при необходимости
+    end
+end

McuLib/m/customtable.m

@@ -1,157 +1,182 @@
 classdef customtable
+    % Класс для работы с таблицами в масках Simulink
+    % Обеспечивает форматирование, парсинг и управление табличными данными
+    % 1. Таблицы в масках Simulink хранятся как строки специального формата:
+    %    {'строка1';'строка2';'строка3'}
+    % 2. Этот класс преобразует строковое представление в cell-массивы для удобной работы
+    % 3. Обеспечивает очистку от пустых строк, форматирование колонок и массовое обновление
 
     methods(Static)
-        % формирование таблицы на всю ширину
         function format(table_name)
+            % Форматирует таблицу в маске - настраивает колонки и внешний вид
+            % table_name - имя табличного параметра в маске
+            
             block = gcb;
             mask = Simulink.Mask.get(block);
-            tableControl = mask.getDialogControl(table_name);
-            tableParameter = mask.getParameter(table_name);
+            tableControl = mask.getDialogControl(table_name);  % Элемент управления таблицей
+            tableParameter = mask.getParameter(table_name);    % Параметр с данными таблицы
             nCols = tableControl.getNumberOfColumns;
-            if nCols > 0
+            
+            % Инициализация колонок если они пустые (после removeParameter)
+            if isempty(tableControl.Columns) || (nCols > 1)
+                % Удаляем все существующие колонки
                 for i = 1:nCols
                     tableControl.removeColumn(1);
                 end
-            end
+                % Создаем одну колонку по умолчанию
                 column = tableControl.addColumn(Name='Title', Type='edit');
-            tableControl.Sortable = 'on';
+                tableControl.Sortable = 'on';  % Разрешаем сортировку
+            end
+            % Устанавливаем имя колонки равным алиасу параметра
             column.Name = tableParameter.Alias;
         end
         
 
         function update(tableName)
+            % Обновляет таблицу - удаляет пустые строки и сохраняет изменения
+            % tableName - имя табличного параметра для обновления
+            
             block = gcb;
             mask = Simulink.Mask.get(block);
             Table = mask.getParameter(tableName);
             
+            % Парсим текущее содержимое таблицы
             cellArray = customtable.parse(tableName);
+            % Удаляем пустые строки
             cleaned = customtable.removeEmptyRows(cellArray);
 
+            % Если были удалены пустые строки - сохраняем изменения
             if numel(cleaned) ~= numel(cellArray)
+                % Обрамляем каждую строку в кавычки и формируем новое значение
                 quoted = cellfun(@(s) ['''' s ''''], cleaned, 'UniformOutput', false);
                 newStr = ['{' strjoin(quoted, ';') '}'];
-                Table.Value = newStr;
+                Table.Value = newStr;  % Сохраняем обратно в параметр
             end   
         end
 
         function column_titles = save_all_tables(table_names)
-            % Очищает столбцы в каждой таблице из массива имен table_names
-            % Возвращает cell-массив с названиями первых столбцов каждой таблицы
-            block = gcb;
+            % Сохраняет и очищает несколько таблиц одновременно
+            % table_names - cell-массив с именами таблиц
+            % Возвращает массив с названиями первых колонок каждой таблицы
             
-            % Получить объект маски блока
+            block = gcb;
             maskObj = Simulink.Mask.get(block);
             
-            % Инициализировать cell-массив для хранения названий столбцов
+            % Инициализируем массив для хранения названий колонок
             column_titles = cell(size(table_names));
             
             for k = 1:numel(table_names)
                 table_name = table_names{k};
-                
-                % Получить объект управления таблицей
                 tableControl = maskObj.getDialogControl(table_name);
-                
-                % Получить количество столбцов
                 nCols = tableControl.getNumberOfColumns;
                 
                 if nCols > 0
-                    % Получить первый столбец (который будем удалять)
+                    % Сохраняем название первой колонки
                     column = tableControl.getColumn(1);
                     column_titles{k} = column.Name;
                     
-                    % Удаляем все столбцы
-                    % Важно: при удалении столбцов индексы меняются, 
-                    % поэтому удаляем всегда первый столбец nCols раз
+                    % Удаляем все колонки (всегда удаляем первую, т.к. индексы сдвигаются)
                     for i = 1:nCols
                         tableControl.removeColumn(1);
                     end
                 else
-                    % Если столбцов нет, возвращаем пустую строку
-                    column_titles{k} = '';
+                    column_titles{k} = '';  % Если колонок нет
                 end
             end
         end
         
         function restore_all_tables(table_names, column_titles)
-            % Восстанавливает первый столбец в каждой таблице из массива имен
-            % Использует массив column_titles для установки имени столбца
-            block = gcb;
+            % Восстанавливает таблицы с сохраненными названиями колонок
+            % table_names - имена таблиц для восстановления
+            % column_titles - массив с названиями для первых колонок
             
-            % Получить объект маски блока
+            block = gcb;
             maskObj = Simulink.Mask.get(block);
             
             for k = 1:numel(table_names)
                 table_name = table_names{k};
                 title = column_titles{k};
                 
-                % Получить объект управления таблицей
                 tableControl = maskObj.getDialogControl(table_name);
                 
-                % Добавить новый столбец
+                % Добавляем новую колонку с сохраненным названием
                 column = tableControl.addColumn(Name='title', Type='edit');
                 column.Name = title;
             end
         end
 
-
         function out = parse(tableName)
+            % Парсит содержимое таблицы из строкового параметра в cell-массив
+            % tableName - имя табличного параметра
+            % Возвращает cell-массив со строками таблицы
+            
             block = gcb;
-            TableStr = get_param(block, tableName);
-            out = customtable.parse__(TableStr);
+            TableStr = get_param(block, tableName);  % Получаем строковое представление
+            out = customtable.parse__(TableStr);     % Парсим во внутреннем методе
         end
 
         function collect(tableName, cellArray)
+            % Сохраняет cell-массив обратно в табличный параметр
+            % tableName - имя параметра для сохранения
+            % cellArray - cell-массив с данными таблицы
+            
             block = gcb;
-            newTableStr = customtable.collect__(cellArray);
-            % Записываем обратно в параметр маски
-            set_param(block, tableName, newTableStr);
+            newTableStr = customtable.collect__(cellArray);  % Конвертируем в строку
+            set_param(block, tableName, newTableStr);        % Сохраняем в параметр
         end
     end
 
-
-
-
-   
     methods(Static, Access=private)
-
         function out = parse__(tableStr)
+            % Внутренний метод для парсинга строки таблицы в cell-массив
+            % tableStr - строковое представление таблицы в формате {'str1';'str2'}
+            
             str = strtrim(tableStr);
+            % Удаляем обрамляющие фигурные скобки если есть
             if startsWith(str, '{') && endsWith(str, '}')
                 str = str(2:end-1);
             end
         
+            % Разбиваем по разделителю строк ;
             parts = split(str, ';');
             out = cell(numel(parts), 1);
             for i = 1:numel(parts)
                 el = strtrim(parts{i});
+                % Удаляем обрамляющие кавычки если есть
                 if startsWith(el, '''') && endsWith(el, '''')
                     el = el(2:end-1);
                 end
                 out{i} = el;
             end
         
+            % Обработка пустых таблиц
             if isempty(out) || (numel(out) == 1 && isempty(out{1}))
                 out = {};
             end
         end
 
-
         function tableStr = collect__(cellArray)
+            % Внутренний метод для конвертации cell-массива в строку таблицы
+            % cellArray - входной cell-массив
+            % Возвращает строку в формате {'str1';'str2'}
+            
+            % Обрамляем каждую строку в кавычки
             quoted = cellfun(@(s) ['''' s ''''], cellArray, 'UniformOutput', false);
-            tableStr = ['{' strjoin(quoted, ';') '}'];
+            tableStr = ['{' strjoin(quoted, ';') '}'];  % Объединяем в формат таблицы
         end
 
-
         function cleaned = removeEmptyRows(cellArray)
+            % Удаляет пустые строки из cell-массива
+            % cellArray - входной массив данных таблицы
+            % Возвращает очищенный массив без пустых строк
+            
             if isempty(cellArray)
                 cleaned = {};
             else
-                % Проверяем каждую строку, есть ли в ней содержимое (не пустая строка)
+                % Определяем какие строки пустые (после удаления пробелов)
                 isEmptyRow = cellfun(@(s) isempty(strtrim(s)), cellArray);
-                cleaned = cellArray(~isEmptyRow);
+                cleaned = cellArray(~isEmptyRow);  % Фильтруем пустые строки
             end
         end
-
     end
-
 end

McuLib/m/editCode.m

@@ -1,60 +1,71 @@
 classdef editCode
+    % Класс для редактирования кода C/C++ в текстовых файлах
+    % Обеспечивает извлечение и вставку кода в секции и функции
 
     methods(Static)
         
         function newCode = insertSection(code, sectionName, newText)
-            % insertSection – вставка или замена содержимого секции или тела функции
+            % Вставка или замена содержимого секции или тела функции
+            % 
             % Аргументы:
-            %   code        – исходный текст (строка)
-            %   sectionName – имя секции (например, 'MY_SECTION') или заголовок функции (например, 'void myFunc(...)')
-            %   newText     – новый текст, который будет вставлен внутрь секции или функции
+            %   code        - исходный текст кода как строка
+            %   sectionName - имя секции (например, 'MY_SECTION') или 
+            %                 заголовок функции (например, 'void myFunc(...)')
+            %   newText     - новый текст для вставки внутрь секции или функции
             %
             % Возвращает:
-            %   newCode     – обновлённый текст с подставленным содержимым
+            %   newCode     - обновлённый текст с подставленным содержимым
             %
             % Особенности:
-            %   - Если sectionName начинается с 'void ', считается что это функция, и вставка происходит внутрь её тела.
-            %   - В остальных случаях ищется секция между маркерами "<NAME> START" и "<NAME> END", и она заменяется на newText.
+            %   - Если sectionName начинается с 'void ', считается что это функция,
+            %     и вставка происходит внутрь её тела
+            %   - Для секций ищется блок между маркерами "NAME START" и "NAME END"
+            %   - Поддерживает функции с параметрами и вложенными скобками
 
             newCode = code;
 
-            % Если это функция
+            % Обработка функций (если sectionName начинается с 'void ')
             if startsWith(strtrim(sectionName), 'void ')
+                % Извлекаем имя функции из заголовка
                 tokens = regexp(sectionName, 'void\s+(\w+)\s*\(', 'tokens');
                 if isempty(tokens)
-                    return;
+                    return;  % Не удалось извлечь имя функции
                 end
                 funcName = tokens{1}{1};
+                
+                % Ищем начало функции в коде
                 expr = sprintf('void\\s+%s\\s*\\(.*?\\)\\s*\\{', funcName);
                 startIdx = regexp(code, expr, 'start');
                 if isempty(startIdx)
-                    return;
+                    return;  % Функция не найдена
                 end
         
-                % Найдём тело функции с учётом вложенных скобок
+                % Находим тело функции с учётом вложенных фигурных скобок
                 from = startIdx(1);
-                braceCount = 0;
+                braceCount = 0;  % Счётчик уровня вложенности скобок
                 i = from;
                 while i <= length(code)
                     if code(i) == '{'
                         braceCount = braceCount + 1;
                         if braceCount == 1
-                            bodyStart = i + 1;
+                            bodyStart = i + 1;  % Начало тела функции (после {)
                         end
                     elseif code(i) == '}'
                         braceCount = braceCount - 1;
                         if braceCount == 0
-                            bodyEnd = i - 1;
+                            bodyEnd = i - 1;    % Конец тела функции (перед })
                             break;
                         end
                     end
                     i = i + 1;
                 end
         
+                % Проверяем что все скобки закрыты
                 if braceCount ~= 0
-                    return;
+                    return;  % Несбалансированные скобки
                 end
         
+                % Собираем новый код: начало до тела + новый текст + конец после тела
                 newCode = [ ...
                     code(1:bodyStart-1), ...
                     newline, newText, newline, ...
@@ -63,110 +74,113 @@ classdef editCode
                 return;
             end
         
-            % Иначе это обычная секция
-            % Формируем шаблон с группами для поиска нужного блока
+            % Обработка обычных секций (не функций)
+            % Формируем шаблон для поиска секции: начало, содержимое, конец
             pattern = sprintf('(%s START\\s*\\n)(.*?)(\\s*%s END)', sectionName, sectionName);
         
-            % Проверяем, есть ли совпадение
+            % Проверяем наличие секции в коде
             startIdx = regexp(code, pattern, 'start', 'once');
             if isempty(startIdx)
                 error('Секция "%s" не найдена в тексте.', sectionName);
             end
         
-            % Формируем новую секцию с нужным текстом
+            % Формируем новую секцию с переданным текстом
             replacement = sprintf('%s START\n%s\n%s END', sectionName, newText, sectionName);
         
             % Заменяем всю найденную секцию на новую
             newCode = regexprep(code, pattern, replacement, 'dotall');
         end
 
-
-
         function result = extractSection(code, sectionName)
-            % extractSection – извлечение содержимого секции или тела функции
+            % Извлечение содержимого секции или тела функции
+            %
             % Аргументы:
-            %   code        – исходный текст (строка)
-            %   sectionName – имя секции (например, 'MY_SECTION') или заголовок функции (например, 'void myFunc(...)')
+            %   code        - исходный текст кода как строка
+            %   sectionName - имя секции (например, 'MY_SECTION') или
+            %                 заголовок функции (например, 'void myFunc(...)')
             %
             % Возвращает:
-            %   result      – извлечённый текст из секции или тела функции
+            %   result      - извлечённый текст из секции или тела функции
             %
             % Особенности:
-            %   - Если sectionName начинается с 'void ', считается что это функция, и извлекается содержимое её тела.
-            %   - В остальных случаях ищется секция между маркерами "<NAME> START" и "<NAME> END".
+            %   - Для функций извлекает содержимое между { и } с учётом вложенности
+            %   - Для секций извлекает текст между маркерами START и END
+            %   - Сохращает оригинальные отступы и форматирование
 
             result = '';    
-            % Если это функция (начинается с 'void ')
+            
+            % Обработка функций (если sectionName начинается с 'void ')
             if startsWith(strtrim(sectionName), 'void ')
-                % Получаем имя функции из заголовка
+                % Извлекаем имя функции из заголовка
                 tokens = regexp(sectionName, 'void\s+(\w+)\s*\(', 'tokens');
                 if isempty(tokens)
-                    return;
+                    return;  % Не удалось извлечь имя функции
                 end
                 funcName = tokens{1}{1};
         
-                % Строим шаблон начала функции
+                % Ищем начало функции в коде
                 expr = sprintf('void\\s+%s\\s*\\(.*?\\)\\s*\\{', funcName);
                 startIdx = regexp(code, expr, 'start');
                 if isempty(startIdx)
-                    return;
+                    return;  % Функция не найдена
                 end
         
-                % Поиск тела функции с учётом вложенных скобок
+                % Находим тело функции с учётом вложенных фигурных скобок
                 from = startIdx(1);
-                braceCount = 0;
+                braceCount = 0;  % Счётчик уровня вложенности скобок
                 i = from;
                 while i <= length(code)
                     if code(i) == '{'
                         braceCount = braceCount + 1;
                         if braceCount == 1
-                            % Найдём первую новую строку после {
-                            braceOpenIdx = i;
+                            braceOpenIdx = i;  % Позиция открывающей скобки
                         end
                     elseif code(i) == '}'
                         braceCount = braceCount - 1;
                         if braceCount == 0
-                            braceCloseIdx = i;
+                            braceCloseIdx = i;  % Позиция закрывающей скобки
                             break;
                         end
                     end
                     i = i + 1;
                 end
                 
+                % Проверяем что все скобки закрыты
                 if braceCount ~= 0
-                    return;
+                    return;  % Несбалансированные скобки
                 end
                 
-                % Найдём \n после {
+                % Находим первую новую строку после открывающей скобки {
                 newlineAfterOpen = regexp(code(braceOpenIdx:end), '\n', 'once');
                 if isempty(newlineAfterOpen)
-                    return;
+                    return;  % Не найден перевод строки
                 end
-                bodyStart = braceOpenIdx + newlineAfterOpen;
+                bodyStart = braceOpenIdx + newlineAfterOpen;  % Начало тела функции
                 
-                % Найдём \n до }
+                % Находим последнюю новую строку перед закрывающей скобкой }
                 newlinesBeforeClose = regexp(code(1:braceCloseIdx), '\n');
                 if isempty(newlinesBeforeClose)
-                    return;
+                    return;  % Не найдены переводы строк
                 end
-                bodyEnd = newlinesBeforeClose(end) - 1;
+                bodyEnd = newlinesBeforeClose(end) - 1;  % Конец тела функции
                 
-                % Извлекаем блок как есть, включая отступы
+                % Извлекаем тело функции с сохранением форматирования
                 result = code(bodyStart:bodyEnd);
                 return;
             end
         
-            % Иначе считаем, что это секция вида // NAME START ... // NAME END
+            % Обработка обычных секций (не функций)
+            % Ищем секцию между маркерами START и END
             pattern = sprintf('%s START\\s*\\n(.*?)\n%s END', sectionName, sectionName);
         
+            % Извлекаем содержимое секции
             match = regexp(code, pattern, 'tokens', 'dotall');
             if ~isempty(match)
-                result = match{1}{1};
+                result = match{1}{1};  % Возвращаем содержимое секции
             else
+                % Секция не найдена - выводим сообщение об ошибке
                 mcuMask.disp(0, 'Ошибка: cекция "%s" не найдена в тексте.', sectionName);
             end
         end
-
-
     end
 end

McuLib/m/init.m

@@ -1,120 +0,0 @@
-% Cкрипт для задания параметров модели
-
-clear;%очищаем рабочее пространство
-
-%% ПАРАМЕТРЫ МОДЕЛИ
-
-addpath('MCU_Wrapper');
-addpath('motor');
-Ts = 10e-6;%шаг интегрирования
-Decim = 1;%интервал прореживания
-DisableScope = {
-    "Idc";
-    "Udc";
-    };
-
-GED = "23550";
-% GED = "22220";
-
-% начальная скорость ГЭД, доля от NmNom
-w0 = 0;%0.5;%-0.75;%
-% пусковой момент, о.е.
-Mst = 0.6;%0.6;
-
-% разрешаем/запрещаем сбросы/набросы момента нагрузки
-changingLoadEnable = 0;%1
-% разрешаем/запрещаем шум в измеренном токе
-noiseEnable = 0;%1;%
-% ... мощность шума
-NP = 0.08;
-
-
-%% НОМИНАЛЬНЫЕ ВЕЛИЧИНЫ ГЭД
-% ... мощность на валу, Вт
-Pnom = 6300e3;
-% ... линейное напряжение, В (rms)
-Unom = 3300;
-% ... механическая скорость, об/мин
-NmNom = 180;
-% ... число пар полюсов
-Pp = 6;
-% ... коэффициент мощности
-CosFi = 0.87;
-% ... КПД
-Eff = 0.968;
-% ... приведенный к валу момент инерции, кг*м^2
-J = 87e3*0.1;
-
-
-%% РАСЧЕТЫ
-% разкомментирование всех блоков
-
-modelName = [bdroot '/Measurements'];
-blocks = find_system(modelName,  ...
-    'IncludeCommented', 'on', ...
-    'FollowLinks', 'on', ...
-    'LookUnderMasks', 'all', ...
-    'BlockType', 'Scope'); 
-for i = 1:length(blocks)
-    set_param(blocks{i}, 'Commented', 'off');
-end
-% отключение графиков для ускорения смуляции
-for i = 1:length(DisableScope)
-    set_param([modelName '/'] + DisableScope{i}, 'Commented', 'on');
-end
-
-% для упрощения записи
-SQRT2 = sqrt(2);
-SQRT3 = sqrt(3);
-PI2 = pi*2;
-
-% ... полная мощность, ВА
-Snom = Pnom/CosFi/Eff;
-% ... механическая скорость, рад/с
-WmNom = NmNom/60*PI2;
-% ... момент на валу, Н*м
-Mnom = Pnom/WmNom;
-% ... эл. скорость, рад/с
-WeNom = WmNom*Pp;
-% ... эл. скорость, Гц
-FeNom = WeNom/PI2;
-% ... потокосцепление статора, Вб
-PsiNom = Unom*SQRT2/(WeNom*SQRT3);
-% ... напряжение на входе инвертора, B
-UdcNom = Unom*SQRT2;
-% ... ток, А (ampl)
-Inom = Snom/(Unom*SQRT3)*SQRT2*0.5;%0.5 - т.к. обмоток две
-
-% схема замещения ГЭД
-if GED == "22220"
-    GED
-    Rs = 11.8e-3;%Ом
-    Xls = 72.7e-3;%72.7e-3;%Ом
-    Rr = 11.1e-3*2.0;%*0.8;%Ом
-    Xlr = 85.5e-3;%Ом
-    Xm  = 2.9322;%2.87;%Ом
-    Fe = 18;%Гц
-    Lls = Xls/(Fe*PI2);%Гн
-    Llr = Xlr/(Fe*PI2);%Гн
-    Lm = Xm/(Fe*PI2);%Гн
-elseif GED == "23550"
-    GED
-    Rs = 0.0282;%Ом
-    Xls = 0.4016;%Ом
-    Rr = 0.139;%Ом
-    Xlr = 0.2006;%Ом
-    Xm  = 5.2796;%Ом
-    Fe = 18.2;%Гц
-    Lls = Xls/(Fe*PI2);%Гн
-    Llr = Xlr/(Fe*PI2);%Гн
-    Lm = Xm/(Fe*PI2);%Гн
-end
-
-% ёмкость на входе INU, Ф
-Cdc = 50e-3;
-% снаберы в INU
-Csn = Pnom/(1000*WeNom*Unom^2)/10;%Ф (0.5 - т.к. преобразователей два)
-Rsn = 2*Ts/Csn*10;%Ом
-
-% постоянная времени фильтра для тока ГЭД, c
-Tiac = 30e-6;

McuLib/m/installTemplates.m

@@ -0,0 +1,59 @@
+function installTemplates(forceCopy)
+% installTemplates Копирует содержимое папки templates (включая вложенные папки) из библиотеки (McuLib.slx) в текущую папку
+%
+%   installTemplates(forceCopy)
+%
+%   forceCopy — логический параметр (true/false)
+%               Если true, файлы будут перезаписаны.
+%               Если false или не указан, копирование происходит без перезаписи существующих файлов.
+
+if nargin < 1
+    forceCopy = false;
+end
+
+try
+    libDir = fileparts(which('McuLib.slx'));   % папка с McuLib.slx
+    parentDir = fileparts(libDir);              % уровень выше
+    templatesDir = fullfile(parentDir, 'templates');  % папка templates
+
+    targetDir = pwd;  % текущая папка
+    mcuMask.disp(1, '');
+    if ~exist(templatesDir, 'dir')
+        mcuMask.disp(1, 'Папка шаблонов %s не найдена.', templatesDir);
+        return;
+    end
+
+    % Список всех файлов и папок внутри templates (рекурсивно)
+    entries = dir(fullfile(templatesDir, '**', '*'));
+    
+    for k = 1:length(entries)
+        if ~entries(k).isdir
+            % Относительный путь внутри templates
+            relPath = erase(entries(k).folder, [templatesDir filesep]);
+            if startsWith(relPath, filesep)
+                relPath = relPath(2:end); % убрать начальный слеш
+            end
+
+            srcFile = fullfile(entries(k).folder, entries(k).name);
+            destFolder = fullfile(targetDir, relPath);
+            destFile = fullfile(destFolder, entries(k).name);
+
+            if ~exist(destFolder, 'dir')
+                mkdir(destFolder);
+            end
+
+            if forceCopy || ~exist(destFile, 'file')
+                copyfile(srcFile, destFile);
+                mcuMask.disp(0, 'Скопирован файл: %s\n', fullfile(relPath, entries(k).name));
+            else
+                % mcuMask.disp(0, 'Файл уже существует и не перезаписывается: %s\n', fullfile(relPath, entries(k).name));
+            end
+        end
+    end
+
+    mcuMask.disp(0, ['Шаблоны успешно скопированы в ', targetDir]);
+
+catch ME
+    mcuMask.disp(0, 'Ошибка при копировании шаблонов: %s', ME.message);
+end
+end

McuLib/m/mainConfig.m

@@ -0,0 +1,287 @@
+classdef mainConfig
+    % Класс для экспорта и импорта конфигурации маски Simulink в JSON
+    % Позволяет сохранять и загружать настройки блока между сессиями
+
+    methods(Static)
+
+        function config = export()
+            % Экспортирует текущую конфигурацию маски в JSON файл
+            % Сохраняет параметры обёртки, портов и приложения
+            
+            blockPath = gcb;
+            mask = Simulink.Mask.get(blockPath);
+            
+            % Списки параметров для экспорта по категориям
+            wrapParamToExport = {'wrapperPath', 'enableDebug', 'mcuClk', ... 
+                'threadCycles', 'enableThreading', 'enableDeinit', ...
+                'periphPath'};
+            portParamToExport = {'inNumb', ...
+                'in_port_1_name', 'in_port_1_width', ... 
+                'in_port_2_name', 'in_port_2_width', ... 
+                'in_port_3_name', 'in_port_3_width', ... 
+                'in_port_4_name', 'in_port_4_width', ... 
+                'in_port_5_name', 'in_port_5_width', ...
+                'outNumb', ...
+                'out_port_1_name', 'out_port_1_width', ... 
+                'out_port_2_name', 'out_port_2_width', ... 
+                'out_port_3_name', 'out_port_3_width', ... 
+                'out_port_4_name', 'out_port_4_width', ... 
+                'out_port_5_name', 'out_port_5_width',};
+            appParamToExport = {'appWrapperPath', 'srcTable', 'incTable', 'userDefs'};
+
+            % Создаем структуру для конфигурации
+            config = struct();
+            
+            % Экспортируем параметры обёртки
+            for i = 1:numel(wrapParamToExport)
+                paramName = wrapParamToExport{i};
+                def = mainConfig.exportParamToConfig(mask, paramName);
+                config.(paramName) = def; 
+            end
+
+            % Экспортируем параметры портов
+            for i = 1:numel(portParamToExport)
+                paramName = portParamToExport{i};
+                def = mainConfig.exportParamToConfig(mask, paramName);
+                config.(paramName) = def; 
+            end
+
+            % Экспортируем параметры приложения
+            for i = 1:numel(appParamToExport)
+                paramName = appParamToExport{i};
+                def = mainConfig.exportParamToConfig(mask, paramName);
+                config.(paramName) = def; 
+            end
+
+            % Кодируем структуру в JSON с форматированием
+            jsonStr = jsonencode(config, 'PrettyPrint', true);
+
+            % Диалог сохранения файла
+            [file, path] = uiputfile('*.json', 'Сохранить конфигурацию как', 'WrapperConfig.json');
+            if isequal(file, 0) || isequal(path, 0)
+                disp('Сохранение отменено пользователем.');
+                return;
+            end
+        
+            filepath = fullfile(path, file);
+
+            % Сохраняем в файл
+            fid = fopen(filepath, 'w');
+            if fid == -1
+                mcuMask.disp(0, 'Не удалось открыть файл для записи: %s', filename);
+            end
+            
+            fwrite(fid, jsonStr, 'char');
+            fclose(fid);
+        end
+
+        function import()
+            % Импортирует конфигурацию маски из JSON файла
+            % Восстанавливает параметры обёртки, портов и приложения
+            
+            % Получаем путь к текущему блоку
+            blockPath = gcb;
+            mask = Simulink.Mask.get(blockPath);
+        
+            % Выбор JSON-файла через диалоговое окно
+            [file, path] = uigetfile('*.json', 'Выберите файл конфигурации');
+            if isequal(file, 0)
+                mcuMask.disp(0, 'Импорт отменён пользователем.');
+                return;
+            end
+        
+            fullpath = fullfile(path, file);
+        
+            % Чтение и декодирование JSON
+            try
+                jsonStr = fileread(fullpath);
+                config = jsondecode(jsonStr);
+            catch err
+                mcuMask.disp(0, 'Ошибка при чтении или разборе JSON: %s', err.message);
+            end
+        
+            % Применение параметров из конфигурации
+            paramNames = fieldnames(config);
+            for i = 1:numel(paramNames)
+                paramName = paramNames{i};
+                def = config.(paramName);
+        
+                try
+                    mainConfig.applyDefToMask(mask, paramName, def);
+                catch err
+                    mcuMask.disp(0, 'Ошибка при применении параметра "%s": %s', paramName, err.message);
+                end
+            end
+        
+            mcuMask.disp(0, 'Конфигурация успешно импортирована.');
+
+            % Обновляем периферию после импорта
+            mcuMask.periphUpdate();
+        end
+
+    end
+
+    methods(Static, Access=private)
+
+        function def = exportParamToConfig(mask, paramName)
+            % Экспортирует один параметр маски в структуру для JSON
+            % mask      - объект маски Simulink
+            % paramName - имя параметра для экспорта
+            % Возвращает структуру с описанием параметра
+            
+            param = mask.getParameter(paramName);
+            if isempty(param)
+                mcuMask.disp(0, 'Параметр "%s" не найден в маске.', paramName);
+                def = [];
+                return;
+            end
+        
+            def = struct();
+
+            % Сохраняем подпись параметра
+            def.Prompt = param.Prompt;
+        
+            % Сохраняем тип параметра
+            def.Type = param.Type;
+        
+            % Сохраняем значение в зависимости от типа
+            val = param.Value;
+            switch lower(param.Type)
+                case 'checkbox'
+                    % Для чекбоксов преобразуем 'on'/'off' в true/false
+                    def.Default = strcmp(val, 'on');
+                case {'edit', 'spinbox'}
+                    % Для числовых полей пробуем преобразовать в число
+                    num = str2double(val);
+                    if ~isnan(num)
+                        def.Default = num;
+                    else
+                        def.Default = val;  % Оставляем строкой если не число
+                    end
+                case 'customtable'
+                    % Для таблиц парсим содержимое в cell-массив
+                    def.Default = customtable.parse(param.Name);
+                case 'text'
+                    % Для текстовых полей сохраняем пустую строку
+                    def.Default = '';
+                otherwise
+                    % Для остальных типов сохраняем как есть
+                    def.Default = val;
+            end
+                
+            % Сохраняем алиас если есть
+            if ~isempty(param.Alias)
+                def.Def = param.Alias;
+            end
+        end
+
+        function applyDefToMask(mask, paramName, def)
+            % Применяет параметр из конфигурации к маске
+            % mask      - объект маски Simulink
+            % paramName - имя параметра для применения
+            % def       - структура с данными параметра
+            
+            % Получаем параметр из маски
+            param = mask.getParameter(paramName);
+            if isempty(param)
+                mcuMask.disp(0, 'Параметр "%s" не найден в маске.', paramName);
+                return;
+            end
+        
+            if isempty(def)
+                mcuMask.disp(0, 'Параметр "%s" не найден в конфиге.', paramName);
+                return;
+            end
+
+            % Устанавливаем значение в зависимости от типа параметра
+            switch lower(def.Type)
+                case 'checkbox'
+                    % Устанавливаем состояние чекбокса
+                    if islogical(def.Default)
+                        param.Value = mainConfig.ternary(def.Default, 'on', 'off');
+                    else
+                        mcuMask.disp(0, 'Ожидалось логическое значение для checkbox "%s".', paramName);
+                    end
+        
+                case {'edit', 'spinbox'}
+                    % Устанавливаем значение для текстового поля
+                    if isnumeric(def.Default)
+                        param.Value = num2str(def.Default);
+                    elseif ischar(def.Default) || isstring(def.Default)
+                        param.Value = char(def.Default);
+                    else
+                        mcuMask.disp(0, 'Некорректный формат значения для edit "%s".', paramName);
+                    end
+        
+                case 'customtable'
+                    % Загружаем данные в таблицу
+                    if iscell(def.Default)
+                        customtable.collect(paramName, def.Default);
+                    else
+                        mcuMask.disp(0, 'customtable "%s" требует cell-массив строк.', paramName);
+                    end
+        
+                case 'text'
+                    % Устанавливаем текстовое значение
+                    if ischar(def.Default) || isstring(def.Default)
+                        param.Value = char(def.Default);
+                    else
+                        mcuMask.disp(0, 'text-параметр "%s" должен быть строкой.', paramName);
+                    end
+        
+                case 'popup'
+                    % Устанавливаем значение выпадающего списка
+                    if ischar(def.Default) && isfield(def, 'Def') && any(strcmp(def.Default, def.Def))
+                        param.Value = def.Default;
+                    else
+                        mcuMask.disp(0, 'popup-параметр "%s" имеет неверное значение или список.', paramName);
+                    end
+        
+                otherwise
+                    % Универсальная установка значения
+                    if ischar(def.Default) || isstring(def.Default)
+                        param.Value = char(def.Default);
+                    elseif isnumeric(def.Default)
+                        param.Value = num2str(def.Default);
+                    else
+                        mcuMask.disp(0, 'Неизвестный формат значения параметра "%s".', paramName);
+                    end
+            end
+        
+            % Обновляем подпись параметра если есть
+            if isfield(def, 'Prompt')
+                param.Prompt = def.Prompt;
+            end
+        
+            % Обновляем алиас если есть
+            if isfield(def, 'Def') && ischar(def.Def)
+                param.Alias = def.Def;
+            end
+			
+            % % Установка Row, если поддерживается
+            % if isfield(def, 'NewRow')
+            %     try
+            %         if def.NewRow
+            %             param.DialogControl.Row = 'new';
+            %         else
+            %             param.DialogControl.Row = 'current';
+            %         end
+            %     catch
+            %         % Некоторым типам параметров Row может быть неприменим
+            %     end
+            % end
+        end
+
+        function result = ternary(cond, a, b)
+            % Вспомогательная функция - тернарный оператор
+            % cond - условие, a - значение если true, b - значение если false
+            if cond
+                result = a;
+            else
+                result = b;
+            end
+        end
+
+    end
+
+end

McuLib/m/mainWrap.m

@@ -0,0 +1,72 @@
+classdef mainWrap
+
+    methods(Static)        
+        function enableThreading()
+            block = gcb;
+            maskNames = get_param(block, 'MaskNames');
+            maskValues = get_param(block, 'MaskValues');
+            maskEnables = get_param(block, 'MaskEnables');
+            idxEnable = find(strcmp(maskNames, 'enableThreading'));
+            idxEdit = find(strcmp(maskNames, 'threadCycles'));
+            if isempty(idxEnable) || isempty(idxEdit)
+                error('Параметры enableThreading или threadCycles не найдены в маске');
+            end
+            val = maskValues{idxEnable};
+            if strcmp(val, 'on')
+                maskEnables{idxEdit} = 'on';
+            else
+                maskEnables{idxEdit} = 'off';
+            end
+            set_param(block, 'MaskEnables', maskEnables);
+        end
+
+        function enableDeinit()
+            block = gcb;
+            maskNames = get_param(block, 'MaskNames');
+            maskValues = get_param(block, 'MaskValues');
+            maskEnables = get_param(block, 'MaskEnables');
+            idxEnable = find(strcmp(maskNames, 'enableThreading'));
+            idxEdit = find(strcmp(maskNames, 'threadCycles'));
+            if isempty(idxEnable) || isempty(idxEdit)
+                error('Параметры enableThreading или threadCycles не найдены в маске');
+            end
+            val = maskValues{idxEnable};
+            if strcmp(val, 'on')
+                maskEnables{idxEdit} = 'on';
+            else
+                maskEnables{idxEdit} = 'off';
+            end
+            set_param(block, 'MaskEnables', maskEnables);
+        end
+
+        function extConsol()
+            block = gcb;
+            mask = Simulink.Mask.get(block);    
+            fullOut = mask.getParameter('fullOutput');
+            extCons = mask.getParameter('extConsol');
+            if isempty(extCons) || isempty(fullOut)
+                error('Параметры fullOutput или extConsol не найдены в маске');
+            end
+          
+            if(strcmp(extCons.Enabled, 'on'))
+                if strcmp(extCons.Value, 'on')
+                    fullOut.Enabled = 'off';
+                    fullOut.Value = 'on';
+                else
+                    fullOut.Enabled = 'on';
+                end
+            else
+                fullOut.Enabled = 'on';
+            end
+           
+        end
+
+    end
+
+
+%% SPECIFIC TOOLS
+    methods(Static, Access = private)
+
+    end
+
+end

McuLib/m/mcuMask.m

@@ -1,437 +1,207 @@
 classdef mcuMask
+    % Главный класс управления маской блока Simulink для микроконтроллера
+    % Содержит callback-функции и утилиты для работы с маской
     
+%% CALLBACKS - функции обратного вызова для элементов маски
     methods(Static)
-        % Following properties of 'maskInitContext' are avalaible to use:
-        %  - BlockHandle
-        %  - MaskObject
-        %  - MaskWorkspace - Use get/set APIs to work with mask workspace.
+        % Функция инициализации маски - вызывается при загрузке блока
         function MaskInitialization(maskInitContext)
             % Получаем хэндл текущего блока
             blk = gcbh;
             % Получаем объект маски текущего блока
             mask = Simulink.Mask.get(gcb);
-            % mcuMask.disp(1,'');
+            
+            % Разрешаем самомодификацию маски и отключаем ссылки
+			set_param(blk,"MaskSelfModifiable","on")
+            set_param(blk, 'LinkStatus', 'none');
+            
+            % Проверяем доступность findjobj для внешней консоли
             try
-                % Проверка наличия findjobj
                 findjobjAvailable = exist('findjobj', 'file') == 2;
             catch
                 findjobjAvailable = false;
             end
-            % Получаем объект маски текущего блока
-            mask = Simulink.Mask.get(gcb);
-            % Имя checkbox-параметра (укажите точное имя из маски)
-            checkboxParamName = 'extConsol';  % пример
-            findjobjLinkName = 'findjobj_link';  % пример
-            % Получаем параметр по имени
+            
+            % Настраиваем параметры внешней консоли в зависимости от доступности findjobj
+            checkboxParamName = 'extConsol';
+            findjobjLinkName = 'findjobj_link';
+            
             checkboxParam = mask.getParameter(checkboxParamName);
             findjobjLink = mask.getDialogControl(findjobjLinkName);
+            
             if isempty(findjobjLink)
                 error('Параметр %s не найден в маске.', findjobjLinkName);
             end
             if isempty(checkboxParam)
                 error('Параметр %s не найден в маске.', checkboxParamName);
             end
-            % Блокируем чекбокс, если findjobj не найден
+            
+            % Блокируем чекбокс если findjobj не найден
             if ~findjobjAvailable
                 checkboxParam.Enabled = 'off';
-                checkboxParam.Value = 'off'; % и на всякий случай снимаем галочку
+                checkboxParam.Value = 'off';
                 checkboxParam.Prompt  = 'External Console (requires findjobj)';
-                findjobjLink.Visible = 'on';
+                findjobjLink.Visible = 'on';  % Показываем ссылку для скачивания
             else
                 checkboxParam.Enabled = 'on';
                 checkboxParam.Prompt  = 'External Console';
-                findjobjLink.Visible = 'off';
+                findjobjLink.Visible = 'off';  % Скрываем ссылку
             end
-            % формирование таблицы на всю ширину
+            
+            % Форматируем таблицы исходных файлов и инклюдов
             table_names = {'srcTable', 'incTable'};
             for k = 1:numel(table_names)
                 table_name = table_names{k};
-                % customtable.format(table_name);
+                customtable.format(table_name);
             end
-            % запись описания блока
+            
+            % Устанавливаем описание блока
             textDesc = ['Блок для настройки параметров симуляции микроконтроллера. ' newline ...
                 'Позволяет задавать параметры оболочки, приложения МК и периферии'];
 
-            % Получаем объект описания
             toolTextArea = mask.getDialogControl('BlockDesc');
             toolTextArea.Prompt = textDesc;
         end
         
-        %% WRAPPER PARAMS
+        %% WRAPPER PARAMS - callback-функции для параметров обёртки
+        function wrapperPath_add(callbackContext)
+            % Добавление пути к файлам обёртки
+            mcuPath.addPath('wrapperPath');
+        end
+
         function enableThreading(callbackContext)
-            block = gcb;
-            maskNames = get_param(block, 'MaskNames');
-            maskValues = get_param(block, 'MaskValues');
-            maskEnables = get_param(block, 'MaskEnables');
-            idxEnable = find(strcmp(maskNames, 'enableThreading'));
-            idxEdit = find(strcmp(maskNames, 'threadCycles'));
-            if isempty(idxEnable) || isempty(idxEdit)
-                error('Параметры enableThreading или threadCycles не найдены в маске');
-            end
-            val = maskValues{idxEnable};
-            if strcmp(val, 'on')
-                maskEnables{idxEdit} = 'on';
-            else
-                maskEnables{idxEdit} = 'off';
-            end
-            set_param(block, 'MaskEnables', maskEnables);
+            % Включение/выключение многопоточности
+            mainWrap.enableThreading();
         end
 
         function enableDeinit(callbackContext)
-            block = gcb;
-            maskNames = get_param(block, 'MaskNames');
-            maskValues = get_param(block, 'MaskValues');
-            maskEnables = get_param(block, 'MaskEnables');
-            idxEnable = find(strcmp(maskNames, 'enableThreading'));
-            idxEdit = find(strcmp(maskNames, 'threadCycles'));
-            if isempty(idxEnable) || isempty(idxEdit)
-                error('Параметры enableThreading или threadCycles не найдены в маске');
-            end
-            val = maskValues{idxEnable};
-            if strcmp(val, 'on')
-                maskEnables{idxEdit} = 'on';
-            else
-                maskEnables{idxEdit} = 'off';
-            end
-            set_param(block, 'MaskEnables', maskEnables);
+            % Включение/выключение деинициализации
+            mainWrap.enableDeinit();
         end
 
         function extConsol(callbackContext)
-            block = gcb;
-            mask = Simulink.Mask.get(block);    
-            fullOut = mask.getParameter('fullOutput');
-            extCons = mask.getParameter('extConsol');
-            if isempty(extCons) || isempty(fullOut)
-                error('Параметры fullOutput или extConsol не найдены в маске');
+            % Управление внешней консолью
+            mainWrap.extConsol();           
         end
 
-            if(strcmp(extCons.Enabled, 'on'))
-                if strcmp(extCons.Value, 'on')
-                    fullOut.Enabled = 'off';
-                    fullOut.Value = 'on';
-                else
-                    fullOut.Enabled = 'on';
-                end
-            else
-                fullOut.Enabled = 'on';
+        %% USER WRAPPER CODE - callback-функции для пользовательского кода
+        function appWrapperPath_add(callbackContext)
+            % Добавление пути к файлам обёртки приложения
+            mcuPath.addPath('appWrapperPath');
         end
 
+        function appWrapperFunc(callbackContext)
+            % Загрузка функции обёртки для редактирования
+            appWrap.appWrapperFunc();
         end
             
-        function wrapperPath_add(callbackContext)
-            block = gcb;
-            mask = Simulink.Mask.get(block);
-            % Открываем окно выбора папки
-            folderPath = uigetdir('', 'Выберите папку');
-            % Проверка на отмену
-            if isequal(folderPath, 0)
-                return;
-            end
-            % Установка значения параметра маски
-            rel = mcuMask.absoluteToRelativePath(folderPath);
-            param = mask.getParameter('wrapperPath');
-            param.Value = rel;
-            
-        end
-        %% USER WRAPPER CODE
-
-        function wrapperFunc(callbackContext)
-            block = gcb;
-            % Получаем имя функции и путь к файлам
-            [filename, section, tool, example]= mcuMask.getWrapperUserFile(block);
-            mcuMask.tool(tool, example);
-
-            % Загружаем содержимое файла
-            set_param(block, 'wrapperCode', '');
-            code = fileread(filename);
-            code = regexprep(code, '\r\n?', '\n');  % нормализуем окончания строк
-
-            includesText = editCode.extractSection(code, section);
-            set_param(block, 'wrapperCode', includesText);
-            % % Поиск тела обычной функции
-            % expr = sprintf('void %s()', sel);
-            % funcBody = editCode.extractSection(code, expr);
-            % set_param(block, 'wrapperCode', funcBody);
+        function saveAppWrapperCode(callbackContext)
+            % Сохранение отредактированного кода обёртки
+            appWrap.saveAppWrapperCode();
         end
 
-        function saveWrapperCode(callbackContext)
-            block = gcb;
-
-            % Получаем имя функции и путь к файлам
-            [filename, section] = mcuMask.getWrapperUserFile(block);
-            if ~isfile(filename)
-                errordlg(['Файл не найден: ', filename]);
-                return;
+        function openAppWrapperCode(callbackContext)
+            % Открытие кода обёртки во внешнем редакторе
+            appWrap.openAppWrapperCode();
         end
 
-            sel = get_param(block, 'wrapperFunc');
-            basePath = get_param(block, 'wrapperPath');
-            if isempty(basePath)
-                errordlg('Не указан путь к файлам обёртки (wrapperPath).');
-                return;
-            end
-            newBody = get_param(block, 'wrapperCode');
-            code = fileread(filename);
-            code = regexprep(code, '\r\n?', '\n');
-            code = editCode.insertSection(code, section, newBody);
-            % else
-            %     % Обновляем тело функции
-            %     expr = sprintf('void %s()', sel);
-            %     code = editCode.insertSection(code, expr, newBody);
-            % end
-            fid = fopen(filename, 'w', 'n', 'UTF-8');
-            if fid == -1
-                errordlg('Не удалось открыть файл для записи');
-                return;
-            end
-            fwrite(fid, code);
-            fclose(fid);
-            mcuMask.disp(1, ['Обновлено: ' sel]);
-        end
-
-        function openWrapperCode(callbackContext)
-            block = gcb;
-
-            % Получаем имя функции и путь к файлам
-            filename = mcuMask.getAbsolutePath(mcuMask.getWrapperUserFile(block));
-            if exist(filename, 'file') == 2
-                % Формируем команду без кавычек
-                cmd = sprintf('rundll32.exe shell32.dll,OpenAs_RunDLL %s', filename);
-                status = system(cmd);
-                if status ~= 0
-                    errordlg('Не удалось открыть окно выбора приложения.');
-                end
-            else
-                errordlg('Файл не найден');
-            end            
-        end
-
-        %% USER CODE
+        %% USER CODE - callback-функции для пользовательского кода
         function srcTable(callbackContext)
+            % Обновление таблицы исходных файлов
             customtable.update('srcTable');
         end
 
         function incTable(callbackContext)
+            % Обновление таблицы заголовочных файлов
             customtable.update('incTable');
         end
 
         function btnAddSrc(callbackContext)
-            blockHandle = gcb;
-            % Открываем проводник для выбора файлов
-            [files, pathstr] = uigetfile({ ...
-                '*.c;*.cpp',      'Исходные файлы (*.c, *.cpp)'; ...
-                '*.obj;*.lib',    'Библиотеки (*.obj, *.lib)'; ...
-                '*.*',            'Все файлы (*.*)'}, ...
-                'Выберите файлы', ...
-                'MultiSelect', 'on');
-            
-            if isequal(files, 0)
-                return; % Отмена выбора
-            end
-            if ischar(files)
-                files = {files}; % Один файл — в cell
-            end
-            % Парсим строку в cell-массив
-            oldTable = customtable.parse('srcTable');
-
-            % Добавляем новые пути, проверяя уникальность
-            for i = 1:numel(files)
-                fullpath = fullfile(pathstr, files{i});
-                rel = mcuMask.absoluteToRelativePath(fullpath);
-                if ~any(strcmp(rel, oldTable))
-                    oldTable{end+1, 1} = rel;
-                end
-            end
-
-            % Парсим строку в cell-массив
-            customtable.collect('srcTable', oldTable);
-            
+            % Добавление исходных файлов через диалог выбора
+            mcuPath.addSourceFileTable('srcTable', 'Выберите исходные файлы');
         end
 
         function btnAddInc(callbackContext)
-            blockHandle = gcb;
-            % Открываем проводник для выбора папок
-            pathstr = uigetdir(pwd, 'Выберите папку с заголовочными файлами');
-            if isequal(pathstr, 0)
-                return; % Отмена выбора
-            end
-            % Парсим таблицу
-            oldTable = customtable.parse('incTable');
-
-            rel = mcuMask.absoluteToRelativePath(pathstr);
-            
-            % Проверяем наличие пути
-            if ~any(strcmp(rel, oldTable))
-                oldTable{end+1, 1} = rel;
+            % Добавление путей включения через диалог выбора
+            mcuPath.addPathTable('incTable', 'Выберите папку с заголовочными файлами');
         end
 
-            % Собираем таблицу
-            customtable.collect('incTable', oldTable);
-        end
-
-        %% PERIPH CONFIG
-
+        %% PERIPH CONFIG - callback-функции для конфигурации периферии
         function periphPath_add(callbackContext)
-            block = gcbh;
-            mask = Simulink.Mask.get(block);
-            [file, path] = uigetfile({'*.*','Все файлы (*.*)'}, 'Выберите файл');
-            if isequal(file, 0) || isequal(path, 0)
-                % Отмена выбора — ничего не делаем
-                return;
-            end
-            fullFilePath = fullfile(path, file);
-            rel = mcuMask.absoluteToRelativePath(fullFilePath);
-            param = mask.getParameter('periphPath');
-            param.Value = rel;
+            % Добавление пути к конфигурационному файлу периферии
+            mcuPath.addAnyFile('periphPath');
         end
 
-        function compile(callbackContext)
-            addpath('MCU_Wrapper');
-            mexing(1);
-        end
-
-
-        function updateModel(callbackContext)
-            addpath('MCU_Wrapper');
-            res = mexing(1);
-            if res ~= 0
-                return;
-            end
-            
-            modelName = bdroot(gcb);  % получить имя верхнего уровня модели
+        function periphUpdate(callbackContext)
+            % Обновление конфигурации периферии с асинхронным управлением
+            modelName = bdroot(gcb);
             blockName = gcb;
-            mgr = asynchManage(modelName, blockName);  % создать объект класса
-            mgr.saveAndUpdateModel();        % запустить сохранение и обновление
+            mgr = asynchManage(modelName, blockName);
+            mgr.updateGUIfromConfig();  % Запуск обновления через таймер
         end
 
-
-        function findjobj_link(callbackContext)
-            web('https://www.mathworks.com/matlabcentral/fileexchange/14317-findjobj-find-java-handles-of-matlab-graphic-objects');
+        %% COMPILE - callback-функции для компиляции
+        function compile(callbackContext)
+            % Компиляция S-функции
+            compiler.compile();
         end
 
-        function set_name()
+        function setSFuncName(callbackContext)
+            % Установка имени S-функции в исходном коде
             block = gcb;
-            % Получаем параметр имени S-Function из маски блока
-            newName = get_param(block, 'sfuncName');
+            newName = mcuMask.get_name();
     
-            % Путь к файлу, в котором надо заменить строку
-            cFilePath = fullfile(pwd, './MCU_Wrapper/MCU.c');  % <-- укажи правильный путь
+            % Путь к файлу MCU.c
+            cFilePath = fullfile(pwd, mcuPath.get('wrapperPath'), 'MCU.c');
             
-            % Считаем файл в память
+            % Чтение файла
+			try
 				fileText = fileread(cFilePath);
+			catch
+				return;
+			end
             
-            % Регулярное выражение для поиска строки с define
-            % Заменим строку вида: #define S_FUNCTION_NAME old_name
+            % Поиск и замена определения имени S-функции
             pattern = '#define\s+S_FUNCTION_NAME\s+\w+';
-            
-            % Новая строка
             newLine = ['#define S_FUNCTION_NAME ', newName];
-            
-            % Замена
             updatedText = regexprep(fileText, pattern, newLine);
             
-            % Записываем обратно в файл
-            fid = fopen(cFilePath, 'w', 'n', 'UTF-8');
+            % Запись изменений обратно в файл
+            fid = fopen(cFilePath, 'w', 'n');
             if fid == -1
                 error('Не удалось открыть файл для записи.');
             end
             fwrite(fid, updatedText);
             fclose(fid);    
-    
         end
 
+        %% LINK TO EXTERNAL CONSOLE - callback для внешней консоли
+        function findjobj_link(callbackContext)
+            % Открытие ссылки на утилиту findjobj
+            web('https://www.mathworks.com/matlabcentral/fileexchange/14317-findjobj-find-java-handles-of-matlab-graphic-objects');
+        end
     end
 
-
-%% SPECIFIC TOOLS
-    methods(Static, Access = private)
-
-        function [filename, section, tool, example] = getWrapperUserFile(block)        
-            sel = get_param(block, 'wrapperFunc');
-            basePath = get_param(block, 'wrapperPath');
-            if isempty(basePath)
-                errordlg('Не указан путь к файлам обёртки (wrapperPath).');
-                return;
-            end
-            % Формируем путь к файлу в зависимости от типа запроса
-            if strcmp(sel, 'Includes')
-                filename = fullfile(basePath, 'app_includes.h');
-                section = '// INCLUDES';
-                tool = 'Инклюды для доступа к коду МК в коде оболочке';
-                example =  '#include "main.h"';
-            elseif strcmp(sel, 'Dummy')
-                filename = fullfile(basePath, 'app_wrapper.c');
-                section = '// DUMMY';
-                tool = 'Заглушки для различных функций и переменных';
-                example = ['CAN_HandleTypeDef hcan = {0};' newline...
-                    'void hardware_func(handle *huart) {}' newline...
-                    'int wait_for_hardware_flag(int *flag) {' newline...
-                    '    return 1;' newline...
-                    '}' newline...
-                    ''];
-            elseif strcmp(sel, 'App Init')
-                filename = fullfile(basePath, 'app_init.c');
-                section = '// USER APP INIT';
-                tool = ['Код для инициализации приложения МК.' newline newline...
-                    'Вызов функций инициализации, если не используется отдельный поток для main().'];
-                example =  'init_func();';
-            elseif strcmp(sel, 'App Step')
-                filename = fullfile(basePath, 'app_wrapper.c');
-                section = '// USER APP STEP';
-                tool = ['Код приложения МК для вызова в шаге симуляции.' newline newline ...
-                    'Вызов функций программы МК, если не используется отдельный поток для main().'];
-                example =  'step_func();';
-            elseif strcmp(sel, 'App Inputs')
-                filename = fullfile(basePath, 'app_io.c');
-                section = '// USER APP INPUT';
-                tool = ['Работа с буффером для портов S-Function' newline newline ...
-                    'Буфер в начале хранит входные порты S-Function, далее идут выходные порты:' newline ...
-                    'Buffer[0:15] - входной порт, Buffer[16:31] - входной 1 порт, ' newline ...
-                    'Buffer[32:47] - выходной 1 порт, Buffer[48:63] - выходной 2 порт'];
-                example = ['// чтение 1-го элемента 0-го входного массива' newline...
-                    'app_variable_2 = ReadInputArray(0, 1);' newline newline...
-                    '// запись в буфер выходов' newline ...
-                    'app_variable_2 = Buffer[10];'];
-            elseif strcmp(sel, 'App Outputs')
-                filename = fullfile(basePath, 'app_io.c');
-                section = '// USER APP OUTPUT';
-                tool = ['Работа с буффером для портов S-Function' newline newline ...
-                    'Буфер в начале хранит входные порты S-Function, далее идут выходные порты:' newline ...
-                    'Buffer[0:15] - входной порт, Buffer[16:31] - входной 1 порт, ' newline ...
-                    'Buffer[32:47] - выходной 1 порт, Buffer[48:63] - выходной 2 порт'];
-                example = ['// запись в 1-й элемент 0-го выходного массива' newline...
-                    'WriteOutputArray(app_variable, 0, 1);' newline newline ...
-                    '// запись в буфер выходов' newline ...
-                    'Buffer[XD_OUTPUT_START + 10] = app_variable_2;'];
-            elseif strcmp(sel, 'App Deinit')
-                filename = fullfile(basePath, 'app_init.c');
-                section = '// USER APP DEINIT';
-                tool = ['Код для деинициализации приложения МК.' newline newline ...
-                    'Можно деинициализировать приложение МК, для повторного запуска.'];
-                example =  'memset(&htim1, sizeof(htim1), 0;';
-            else
-                tool = '';
-                mcuMask.disp(0, '\nОшибка выбора типа секции кода: неизвестное значение');
-            end
-
-        end
-
-    end
-
-%% GENERAL TOOLS
+%% GENERAL TOOLS - общие утилиты для работы с маской
     methods(Static, Access = public)
 
-        function saveAndClose(blockPath)
+        function updateModel()
+            % Обновление модели с компиляцией S-функции
+            addpath(mcuPath.get('wrapperPath'));
+            res = mexing(1);
+            if res ~= 0
+                return;
+            end
+        end
+
+        function close(blockPath)
+            % Закрытие маски с сохранением параметров
             try
-                % Считываем текущее имя модели
                 modelName = bdroot(blockPath);
-                % Включаем возможность изменения маски
                 set_param(blockPath, 'MaskSelfModifiable', 'on');
                 
-                % Считываем текущие значения параметров маски
+                % Применяем текущие значения маски
                 currentMaskValues = get_param(blockPath, 'MaskValues');
-                
-                % Применяем текущие значения заново, чтобы "применить" маску
                 set_param(blockPath, 'MaskValues', currentMaskValues);
                 save_system(modelName);
             catch ME
@@ -441,92 +211,25 @@ classdef mcuMask
         end
 
         function open(blockPath, clear_flag)
+            % Открытие маски блока
             open_system(blockPath, 'mask');
             mcuMask.disp(clear_flag, '');
         end
 
-
-        function absPath = getAbsolutePath(relPath)
-            % relativeToAbsolutePath — преобразует относительный путь в абсолютный.
-            %
-            % Если путь уже абсолютный — возвращается он же, приведённый к канонической форме.
-            % Если путь относительный — преобразуется относительно текущей директории.
-            
-            % Проверка: абсолютный ли путь
-            if ispc
-                isAbsolute = ~isempty(regexp(relPath, '^[a-zA-Z]:[\\/]', 'once')) || startsWith(relPath, '\\');
-            else
-                isAbsolute = startsWith(relPath, '/');
+        function name = get_name()
+            % Получение имени S-функции из параметра маски
+            block = gcb;
+            name = get_param(block, 'sfuncName');
         end
 
-            if isAbsolute
-                % Канонизируем абсолютный путь (убираем ./, ../ и т.п.)
-                absPath = char(java.io.File(relPath).getCanonicalPath());
-            else
-                % Строим абсолютный путь от текущей директории
-                cwd = pwd;
-                combined = fullfile(cwd, relPath);
-                absPath = char(java.io.File(combined).getCanonicalPath());
-            end
-        end
-
-
-
-        function rel = absoluteToRelativePath(pathstr)
-            % absoluteToRelativePath — преобразует абсолютный путь в относительный от текущей директории.
-            %
-            % Если путь находится в текущей директории или вложенной в неё — добавляется префикс './'
-            % Если выше — формируются переходы '..'
-            % Если путь совпадает с текущей директорией — возвращается '.'
-        
-            % Получаем текущую рабочую директорию
-            cwd = pwd;
-        
-            % Преобразуем пути в канонические абсолютные пути
-            fullpath = char(java.io.File(pathstr).getCanonicalPath());
-            cwd = char(java.io.File(cwd).getCanonicalPath());
-        
-            % Разбиваем пути на части
-            targetParts = strsplit(fullpath, filesep);
-            baseParts = strsplit(cwd, filesep);
-        
-            % Находим длину общего префикса
-            j = 1;
-            while j <= min(length(targetParts), length(baseParts)) && strcmpi(targetParts{j}, baseParts{j})
-                j = j + 1;
-            end
-        
-            % Формируем количество подъемов ".." из cwd
-            numUps = length(baseParts) - (j - 1);
-            ups = repmat({'..'}, 1, numUps);
-        
-            % Оставшаяся часть пути после общего префикса
-            rest = targetParts(j:end);
-        
-            % Объединяем для получения относительного пути
-            relParts = [ups, rest];
-            rel = fullfile(relParts{:});
-        
-            % Если путь пустой — это текущая директория
-            if isempty(rel)
-                rel = '.';
-            end
-        
-            % Если путь не содержит ".." и начинается внутри текущей директории — добавим './'
-            if ~isempty(rest) && isempty(ups)
-                rel = fullfile('.', rel);
-            end
-        end
-
-
-
         function checkbox_state = read_checkbox(checkboxName)
+            % Чтение состояния чекбокса из параметров маски
             maskValues = get_param(gcbh, 'MaskValues');
             paramNames = get_param(gcbh, 'MaskNames');
             
             inxCheckBox = find(strcmp(paramNames, checkboxName));
-            
             checkbox_state_str = maskValues{inxCheckBox};
+            
             if strcmpi(checkbox_state_str, 'on')
                 checkbox_state = 1;
             else
@@ -534,8 +237,8 @@ classdef mcuMask
             end
         end
 
-
         function children = get_children(ctrl)
+            % Получение дочерних элементов управления маски
             if isprop(ctrl, 'DialogControls')
                 children = ctrl.DialogControls;
             elseif isprop(ctrl, 'Controls')
@@ -548,27 +251,28 @@ classdef mcuMask
         end
             
         function params = collect_all_parameters(container)
+            % Рекурсивный сбор всех параметров маски
             params = {};
             children = container.DialogControls;
             for i = 1:numel(children)
                 ctrl = children(i);
                 if isa(ctrl, 'Simulink.dialog.Tab')
-                    % Если вкладка — рекурсивно собираем параметры внутри неё
+                    % Рекурсивный обход вкладок
                     params = [params, mcuMask.collect_all_parameters(ctrl)];
                 else
-                    % Иначе это параметр — добавляем имя
-                    params{end+1} = ctrl.Name; %#ok<AGROW>
+                    % Добавление имени параметра
+                    params{end+1} = ctrl.Name;
                 end
             end
         end
          
         function delete_all_tabs(mask, container)
+            % Рекурсивное удаление всех вкладок маски
             children = container.DialogControls;
-            % Идём в обратном порядке, чтобы безопасно удалять
             for i = numel(children):-1:1
                 ctrl = children(i);
                 if isa(ctrl, 'Simulink.dialog.Tab')
-                    % Сначала рекурсивно удаляем вкладки внутри текущей вкладки
+                    % Рекурсивное удаление вложенных вкладок
                     mcuMask.delete_all_tabs(mask, ctrl);
                     try
                         container.removeDialogControl(ctrl.Name);
@@ -579,22 +283,9 @@ classdef mcuMask
             end
         end
 
-        function res = ternary(cond, valTrue, valFalse)
-            if cond
-                res = valTrue;
-            else
-                res = valFalse;
-            end
-        end
-
-
         function tool(text, example)
-            % Устанавливает заданный текст в параметр Text Area 'toolText' через объект маски
-            
-            % Получаем ссылку на текущий блок
+            % Установка текста подсказки и примера в элементы маски
             block = gcb;
-            
-            % Получаем объект маски
             mask = Simulink.Mask.get(block);
         
             toolTextArea = mask.getDialogControl('toolText');
@@ -604,38 +295,42 @@ classdef mcuMask
         end
 
         function disp(clcFlag, varargin)
+            % Вывод текста в консоль маски
             if clcFlag
                 set_param(gcb, 'consoleOutput', '');
             end
         
             if length(varargin) == 1 && ischar(varargin{1})
-                % Если передан один аргумент — просто строка, передаем напрямую
                 out = varargin{1};
             else
-                % Иначе считаем, что первый аргумент — формат, остальные — параметры
                 out = sprintf(varargin{:});
             end
 
             out_now = get_param(gcb, 'consoleOutput');
+            if ~strcmp(out, '') && ~strcmp(out_now, '')
+                set_param(gcb, 'consoleOutput', [out_now newline out]);
+            else
                 set_param(gcb, 'consoleOutput', [out_now out]);
             end
-
+        end
 
         function updateModelAsync()
+            % Асинхронное обновление модели через таймер
             mdl = bdroot(gcb);
         
             try
-                % Применить изменения, если есть
                 set_param(mdl, 'ApplyChanges', 'on');
             catch
                 beep
-                % Игнорировать, если не удалось
             end
 
             t = timer('StartDelay', 0.01, 'TimerFcn', @(~,~) set_param(mdl, 'SimulationCommand', 'update'));
             start(t);
         end
 
-
+        function v = getMyLibVersion()
+            % Получение версии библиотеки
+            v = 'pre-1.04';
+        end
     end
 end

McuLib/m/mcuPath.m

@@ -0,0 +1,211 @@
+classdef mcuPath
+    % Класс для работы с путями файлов и папок в маске Simulink
+    % Обеспечивает преобразование путей, добавление в таблицы и параметры
+
+    methods(Static)
+
+        %% GET PATH FROM PARAM - получение путей из параметров маски
+        function path = get(paramName)
+            % Получение значения пути из параметра маски
+            % paramName - имя параметра маски содержащего путь
+            % Возвращает строку с путём (абсолютным или относительным)
+            
+            blockPath = gcb;
+            path = get_param(blockPath, paramName);
+        end
+
+        %% ADD PATH TO TABLE - добавление путей в табличные параметры
+
+        function addSourceFileTable(targetParamName, message)
+            % Добавление исходных файлов в таблицу через диалог выбора
+            % targetParamName - имя табличного параметра маски
+            % message - сообщение в диалоге выбора
+            
+            % Открываем проводник для выбора файлов с фильтрами
+            [files, pathstr] = uigetfile({ ...
+                '*.c;*.cpp',      'Исходные файлы (*.c, *.cpp)'; ...
+                '*.obj;*.lib',    'Библиотеки (*.obj, *.lib)'; ...
+                '*.*',            'Все файлы (*.*)'}, ...
+                message, ...
+                'MultiSelect', 'on');  % Разрешаем множественный выбор
+            
+            if isequal(files, 0)
+                return; % Пользователь отменил выбор
+            end
+            
+            % Нормализуем входные данные: один файл -> cell array
+            if ischar(files)
+                files = {files};
+            end
+            
+            % Читаем текущее содержимое таблицы
+            oldTable = customtable.parse(targetParamName);
+
+            % Добавляем новые пути, проверяя уникальность
+            for i = 1:numel(files)
+                fullpath = fullfile(pathstr, files{i});
+                % Преобразуем абсолютный путь в относительный
+                rel = mcuPath.absoluteToRelativePath(fullpath);
+                % Добавляем только если путь ещё не существует в таблице
+                if ~any(strcmp(rel, oldTable))
+                    oldTable{end+1, 1} = rel;
+                end
+            end
+
+            % Сохраняем обновленную таблицу обратно в параметр маски
+            customtable.collect(targetParamName, oldTable);
+        end
+
+        function addPathTable(targetParamName, message)
+            % Добавление путей к папкам в таблицу через диалог выбора
+            % targetParamName - имя табличного параметра маски  
+            % message - сообщение в диалоге выбора
+            
+            % Открываем проводник для выбора папки
+            pathstr = uigetdir(pwd, message);
+            if isequal(pathstr, 0)
+                return; % Пользователь отменил выбор
+            end
+            
+            % Читаем текущее содержимое таблицы
+            oldTable = customtable.parse(targetParamName);
+
+            % Преобразуем абсолютный путь в относительный
+            rel = mcuPath.absoluteToRelativePath(pathstr);
+            
+            % Проверяем наличие пути в таблице и добавляем если нужно
+            if ~any(strcmp(rel, oldTable))
+                oldTable{end+1, 1} = rel;
+            end
+
+            % Сохраняем обновленную таблицу
+            customtable.collect(targetParamName, oldTable);
+        end
+
+        %% ADD PATH TO EDIT - добавление путей в текстовые параметры
+
+        function addPath(targetParamName, message)
+            % Добавление пути к папке в текстовый параметр маски
+            % targetParamName - имя параметра маски для пути
+            % message - сообщение в диалоге выбора (не используется)
+            
+            block = gcb;
+            mask = Simulink.Mask.get(block);
+            
+            % Открываем окно выбора папки
+            folderPath = uigetdir('', 'Выберите папку');
+            
+            % Проверка на отмену выбора
+            if isequal(folderPath, 0)
+                return;
+            end
+            
+            % Преобразуем абсолютный путь в относительный
+            rel = mcuPath.absoluteToRelativePath(folderPath);
+            
+            % Устанавливаем значение параметра маски
+            param = mask.getParameter(targetParamName);
+            param.Value = rel;
+        end
+
+        function addAnyFile(targetParamName, message)
+            % Добавление пути к файлу в текстовый параметр маски
+            % targetParamName - имя параметра маски для пути к файлу
+            % message - сообщение в диалоге выбора (не используется)
+            
+            block = gcbh;
+            mask = Simulink.Mask.get(block);
+            
+            % Открываем проводник для выбора любого файла
+            [file, path] = uigetfile({'*.*','Все файлы (*.*)'}, 'Выберите файл');
+            
+            if isequal(file, 0) || isequal(path, 0)
+                return; % Пользователь отменил выбор
+            end
+            
+            % Формируем полный путь и преобразуем в относительный
+            fullFilePath = fullfile(path, file);
+            rel = mcuPath.absoluteToRelativePath(fullFilePath);
+            
+            % Устанавливаем значение параметра маски
+            param = mask.getParameter(targetParamName);
+            param.Value = rel;
+        end
+
+        %% GET PATH STRING - утилиты преобразования путей
+
+        function absPath = getAbsolutePath(relPath)
+            % Преобразование относительного пути в абсолютный
+            % relPath - относительный или абсолютный путь
+            % Возвращает абсолютный путь в канонической форме
+            
+            % Проверка: абсолютный ли путь уже
+            if ispc
+                % Для Windows: путь начинается с буквы диска или \\
+                isAbsolute = ~isempty(regexp(relPath, '^[a-zA-Z]:[\\/]', 'once')) || startsWith(relPath, '\\');
+            else
+                % Для Unix: путь начинается с /
+                isAbsolute = startsWith(relPath, '/');
+            end
+            
+            if isAbsolute
+                % Канонизируем абсолютный путь (убираем ./, ../ и т.п.)
+                absPath = char(java.io.File(relPath).getCanonicalPath());
+            else
+                % Строим абсолютный путь относительно текущей директории
+                cwd = pwd;
+                combined = fullfile(cwd, relPath);
+                absPath = char(java.io.File(combined).getCanonicalPath());
+            end
+        end
+
+        function rel = absoluteToRelativePath(pathstr)
+            % Преобразование абсолютного пути в относительный относительно текущей директории
+            % pathstr - абсолютный путь для преобразования
+            % Возвращает относительный путь
+            %
+            % Примеры:
+            %   Если путь в текущей директории -> './filename'
+            %   Если путь выше -> '../parent/filename'  
+            %   Если путь совпадает с текущей директорией -> '.'
+
+            % Получаем текущую рабочую директорию
+            cwd = pwd;
+        
+            % Преобразуем оба пути в канонические абсолютные пути
+            fullpath = char(java.io.File(pathstr).getCanonicalPath());
+            cwd = char(java.io.File(cwd).getCanonicalPath());
+        
+            % Разбиваем пути на части по разделителю файловой системы
+            targetParts = strsplit(fullpath, filesep);
+            baseParts = strsplit(cwd, filesep);
+        
+            % Находим длину общего префикса (совпадающих частей пути)
+            j = 1;
+            while j <= min(length(targetParts), length(baseParts)) && strcmpi(targetParts{j}, baseParts{j})
+                j = j + 1;
+            end
+        
+            % Формируем количество подъемов ".." для выхода из базовой директории
+            numUps = length(baseParts) - (j - 1);
+            ups = repmat({'..'}, 1, numUps);
+        
+            % Оставшаяся часть целевого пути после общего префикса
+            rest = targetParts(j:end);
+        
+            % Объединяем части для получения относительного пути
+            relParts = [ups, rest];
+            rel = fullfile(relParts{:});
+        
+            % Если путь пустой - это текущая директория
+            if isempty(rel)
+                rel = '.';
+            end
+        
+            % Если путь не содержит ".." и начинается внутри текущей директории - добавляем './'
+            if ~isempty(rest) && isempty(ups)
+                rel = fullfile('.', rel);
+            end
+        end
+    end
+end

McuLib/m/mcuPorts.m

@@ -1,45 +1,63 @@
 classdef mcuPorts
+    % Класс для управления портами ввода-вывода в маске Simulink
+    % Генерирует конфигурационные файлы для портов на основе параметров маски
 
     methods(Static)
 
         function write()
+            % Основная функция записи конфигурации портов в файлы
+            % Генерирует заголовочный файл и файл реализации для портов
+            
             block = gcb;
             mask = Simulink.Mask.get(block);
-            hPath = fullfile('.\MCU_Wrapper', 'mcu_wrapper_conf.h');
-            cPath = fullfile('.\MCU_Wrapper', 'mcu_wrapper.c');
+            
+            % Пути к конфигурационным файлам
+            hPath = fullfile(mcuPath.get('wrapperPath'), 'mcu_wrapper_conf.h');
+            cPath = fullfile(mcuPath.get('wrapperPath'), 'mcu_wrapper.c');
+            
+            % Устанавливаем значения по умолчанию для неиспользуемых портов
             mcuPorts.defaultUnused();
-            %% CREATE
+            
+            %% СОЗДАНИЕ КОНФИГУРАЦИИ ДЛЯ ВХОДНЫХ ПОРТОВ
             prefixNumb = 'IN';
             [widths, portPrefixes] = mcuPorts.getMaskNames('in');
             
+            % Генерируем текст для заголовочного файла и файла реализации
             headerText = mcuPorts.addPortHeaderDefines('', widths, prefixNumb, portPrefixes);
             cText = mcuPorts.addPortCDefines('', widths, prefixNumb, portPrefixes);
             
+            %% СОЗДАНИЕ КОНФИГУРАЦИИ ДЛЯ ВЫХОДНЫХ ПОРТОВ
             prefixNumb = 'OUT';
             [widths, portPrefixes] = mcuPorts.getMaskNames('out');
             
+            % Добавляем выходные порты к существующей конфигурации
             headerText = mcuPorts.addPortHeaderDefines(headerText, widths, prefixNumb, portPrefixes);
             cText = mcuPorts.addPortCDefines(cText, widths, prefixNumb, portPrefixes);
 
-            %% WRITE
-
+            %% ЗАПИСЬ В ФАЙЛЫ
+            % Читаем существующее содержимое файлов
             hCode = fileread(hPath);
             hCode = regexprep(hCode, '\r\n?', '\n');
             cCode = fileread(cPath);
             cCode = regexprep(cCode, '\r\n?', '\n');
 
+            % Вставляем сгенерированную конфигурацию в заголовочный файл
             code = editCode.insertSection(hCode, '// INPUT/OUTPUTS PARAMS', headerText.PARAMS);            
             code = editCode.insertSection(code, '// INPUT/OUTPUTS AUTO-PARAMS', headerText.AUTO_PARAMS);
 
-            fid = fopen(hPath, 'w', 'n', 'UTF-8');
+            % Записываем обновленный заголовочный файл
+            fid = fopen(hPath, 'w', 'n');
             if fid == -1
                 error('Не удалось открыть файл для записи');
             end
             fwrite(fid, code);
             fclose(fid);
 
+            % Вставляем сгенерированную конфигурацию в файл реализации
             code = editCode.insertSection(cCode, '// INPUT/OUTPUTS AUTO-PARAMS', cText);
-            fid = fopen(cPath, 'w', 'n', 'UTF-8');
+            
+            % Записываем обновленный файл реализации
+            fid = fopen(cPath, 'w', 'n');
             if fid == -1
                 error('Не удалось открыть файл для записи');
             end
@@ -47,39 +65,46 @@ classdef mcuPorts
             fclose(fid);
         end
 
-
         function [portwidth, defnames] = getMaskNames(port_prefix)
+            % Получение имен и ширин портов из параметров маски
+            % port_prefix - префикс портов ('in' или 'out')
+            % Возвращает ширины портов и их имена
+            
             block = gcb;
-            % Получаем значение из спиннера
             mask = Simulink.Mask.get(block);
+            
+            % Получаем количество портов из спиннера
             paramName = sprintf('%sNumb', port_prefix);
             param = mask.getParameter(paramName);
             numb = str2double(param.Value);
             
-            
-            % Инициализируем массив для значений
+            % Инициализируем массивы для имен и ширин портов
             defnames = strings(1, numb);
             portwidth = [];
         
-            % Чтение значений edit-параметров
+            % Читаем значения параметров для каждого порта
             for i = 1:numb
+                % Получаем имя порта
                 paramName = sprintf('%s_port_%d_name', port_prefix, i);
                 param = mask.getParameter(paramName);
                 defnames(i) = param.Value;
+                
+                % Получаем ширину порта
                 paramName = sprintf('%s_port_%d_width', port_prefix, i);
                 param = mask.getParameter(paramName);
                 portwidth(i) = str2double(param.Value);
             end
         end
 
-
         function updateMask()
+            % Обновление видимости параметров портов в маске
+            % Вызывается при изменении количества портов
             mcuPorts.updateMask_prefix('in');
             mcuPorts.updateMask_prefix('out');
         end
 
-
         function defaultUnused()
+            % Установка значений по умолчанию для неиспользуемых портов
             mcuPorts.defaultUnused_prefix('in');
             mcuPorts.defaultUnused_prefix('out');
         end
@@ -87,84 +112,93 @@ classdef mcuPorts
 
     methods(Static, Access=private)
 
-
-
         function updateMask_prefix(port_prefix)
+            % Обновление видимости параметров для конкретного типа портов
+            % port_prefix - префикс портов ('in' или 'out')
+            
             block = gcb;
-            % Получаем значение из спиннера
             mask = Simulink.Mask.get(block);
+            
+            % Получаем текущее количество портов
             paramName = sprintf('%sNumb', port_prefix);
             param = mask.getParameter(paramName);
             n = str2double(param.Value);
             
-            % Максимальное количество портов
+            % Максимальное количество портов из диапазона параметра
             maxPorts = param.Range(2);
             
-            % Проходим по всем edit-полям
+            % Обходим все возможные порты
             for i = 1:maxPorts
-                % Формируем имя параметра
+                % Формируем имена параметров для имени и ширины порта
                 paramDefName = sprintf('%s_port_%d_name', port_prefix, i);
                 paramWidthName = sprintf('%s_port_%d_width', port_prefix, i);
                 paramDef = mask.getParameter(paramDefName);
                 paramWidth = mask.getParameter(paramWidthName);
             
                 if i <= n
-                    % Показываем параметр
+                    % Показываем параметры для используемых портов
                     paramDef.Visible = 'on';
                     paramWidth.Visible = 'on';
             
-                    % Если значение пустое — задаём дефолтное
+                    % Устанавливаем значения по умолчанию если пустые
                     if isempty(strtrim(paramDef.Value))
                         paramDef.Value = upper(port_prefix);
                     end
-                    % Если значение пустое — задаём дефолтное
                     if isempty(strtrim(paramWidth.Value)) || strcmp(paramWidth.Value, '0')
                         paramWidth.Value = '16';
                     end
                 else
-                    % Скрываем параметр
+                    % Скрываем параметры для неиспользуемых портов
                     paramDef.Visible = 'off';
                     paramWidth.Visible = 'off';
                 end
             end
         end
 
-
         function defaultUnused_prefix(port_prefix)
+            % Установка значений по умолчанию для неиспользуемых портов
+            % port_prefix - префикс портов ('in' или 'out')
+            
             block = gcb;
-            % Получаем значение из спиннера
             mask = Simulink.Mask.get(block);
+            
+            % Получаем количество используемых портов
             paramName = sprintf('%sNumb', port_prefix);
             param = mask.getParameter(paramName);
             numb = str2double(param.Value);
 
             % Максимальное количество портов
             maxPorts = param.Range(2);
-            % Чтение значений edit-параметров
+            
+            % Устанавливаем значения по умолчанию для неиспользуемых портов
             for i = numb+1:maxPorts
                 paramName = sprintf('%s_port_%d_name', port_prefix, i);
                 param = mask.getParameter(paramName);
-                param.Value = upper(port_prefix);
+                param.Value = upper(port_prefix);  % Имя по умолчанию
+                
                 paramName = sprintf('%s_port_%d_width', port_prefix, i);
                 param = mask.getParameter(paramName);
-                param.Value = '16';
+                param.Value = '16';  % Ширина по умолчанию
             end
         end
 
-
         function headerText = addPortHeaderDefines(existingText, widths, prefixNumb, portPrefixes)
-            % existingText — структура с полями PARAMS, AUTO_PARAMS
-            % widths — вектор ширин портов
-            % prefixNumb — префикс общего счётчика (например, 'OUT')
-            % portPrefixes — {'OUT', 'OUT', ...}
+            % Генерация define-макросов для заголовочного файла
+            % existingText - существующий текст конфигурации
+            % widths - вектор ширин портов
+            % prefixNumb - общий префикс ('IN' или 'OUT')
+            % portPrefixes - массив префиксов для каждого порта
+            % Возвращает структуру с PARAMS и AUTO_PARAMS
             
             n = numel(widths);
             upperPrefix = upper(prefixNumb);
         
-            % === PARAMS ===
+            % === БАЗОВЫЕ ПАРАМЕТРЫ ===
             lines = {
                 sprintf('#define %s_PORT_NUMB           %d', upperPrefix, n)
             };
+            
+            % Добавляем define для ширины каждого порта
             for i = 1:n
                 lines{end+1} = sprintf('#define %s_PORT_%d_WIDTH        %d', ...
                     upper(portPrefixes{i}), i, widths(i));
@@ -172,10 +206,10 @@ classdef mcuPorts
             newParams = strjoin(lines, newline);
             newParams = [newParams, newline];
         
-            % === AUTO-PARAMS ===
+            % === АВТОМАТИЧЕСКИ ГЕНЕРИРУЕМЫЕ ПАРАМЕТРЫ ===
             lines = {};
         
-            % Формируем выражение суммы ширин с добавлением PORT
+            % Формируем выражение для общего размера буфера
             sumExprParts = cell(1,n);
             for i = 1:n
                 sumExprParts{i} = sprintf('%s_PORT_%d_WIDTH', upper(portPrefixes{i}), i);
@@ -188,17 +222,18 @@ classdef mcuPorts
             lines{end+1} = '';
             lines{end+1} = sprintf('/// === Смещения массивов (внутри общего буфера) ===');
         
+            % Генерируем define для смещений каждого массива в буфере
             for i = 1:n
                 if i == 1
-                    lines{end+1} = '#define OFFSET_ARRAY_1 0';
+                    lines{end+1} = sprintf('#define OFFSET_%s_ARRAY_1 0', upperPrefix);
                 else
-                    lines{end+1} = sprintf('#define OFFSET_ARRAY_%d (OFFSET_ARRAY_%d + %s_PORT_%d_WIDTH)', ...
-                        i, i - 1, upper(portPrefixes{i - 1}), i - 1);
+                    lines{end+1} = sprintf('#define OFFSET_%s_ARRAY_%d (OFFSET_%s_ARRAY_%d + %s_PORT_%d_WIDTH)', ...
+                        upperPrefix, i, upperPrefix, i - 1, upper(portPrefixes{i - 1}), i - 1);
                 end
             end
             newAuto = strjoin(lines, newline);
         
-            % === Добавление к существующему ===
+            % === ОБЪЕДИНЕНИЕ С СУЩЕСТВУЮЩИМ ТЕКСТОМ ===
             if isfield(existingText, 'PARAMS')
                 headerText.PARAMS = [existingText.PARAMS, newline, newParams];
             else
@@ -212,12 +247,13 @@ classdef mcuPorts
             end
         end
 
-
         function cText = addPortCDefines(existingText, widths, prefixNumb, portPrefixes)
-            % existingText — существующий текст .c
-            % widths — вектор ширин портов
-            % prefixNumb — общий префикс ('OUT')
-            % portPrefixes — {'OUT', 'LOG', ...}
+            % Генерация кода для файла реализации (.c)
+            % existingText - существующий текст
+            % widths - вектор ширин портов
+            % prefixNumb - общий префикс ('IN' или 'OUT')
+            % portPrefixes - массив префиксов для каждого порта
+            % Возвращает текст для вставки в .c файл
             
             n = numel(widths);
             upperPrefix = upper(prefixNumb);
@@ -225,39 +261,42 @@ classdef mcuPorts
         
             lines = {};
         
-            % === Таблица длин ===
+            % === ТАБЛИЦА ДЛИН МАССИВОВ ===
             lines{end+1} = '/**';
             lines{end+1} = sprintf('  * @brief Таблица длин массивов %s', upperPrefix);
             lines{end+1} = '  */';
-            % Здесь используем общий префикс для количества портов
             lines{end+1} = sprintf('const int %sLengths[%s_PORT_NUMB] = {', lowerPrefix, upperPrefix);
+            
+            % Заполняем таблицу длин
             for i = 1:n
                 comma = ',';
                 if i == n
                     comma = '';
                 end
-                % Используем макросы с портовыми префиксами из portPrefixes
                 lines{end+1} = sprintf('    %s_PORT_%d_WIDTH%s', upper(portPrefixes{i}), i, comma);
             end
             lines{end+1} = '};';
         
-            % === Таблица смещений ===
+            % === ТАБЛИЦА СМЕЩЕНИЙ ===
             lines{end+1} = '/**';
             lines{end+1} = sprintf('  * @brief Таблица смещений в выходном массиве %s', upperPrefix);
             lines{end+1} = '  */';
             lines{end+1} = sprintf('const int %sOffsets[%s_PORT_NUMB] = {', lowerPrefix, upperPrefix);
+            
+            % Заполняем таблицу смещений
             for i = 1:n
                 comma = ',';
                 if i == n
                     comma = '';
                 end
-                lines{end+1} = sprintf('    OFFSET_ARRAY_%d%s', i, comma);
+                lines{end+1} = sprintf('    OFFSET_%s_ARRAY_%d%s', upperPrefix, i, comma);
             end
             lines{end+1} = '};';
             lines{end+1} = '';
         
             newText = strjoin(lines, newline);
         
+            % Объединяем с существующим текстом
             if nargin < 1 || isempty(existingText)
                 cText = newText;
             else
@@ -265,20 +304,14 @@ classdef mcuPorts
             end
         end
 
-
-
-
-
         function val = iff(cond, a, b)
-            % Условное выражение inline
+            % Вспомогательная функция - тернарный оператор
+            % cond - условие, a - значение если true, b - значение если false
             if cond
                 val = a;
             else
                 val = b;
             end
         end
-
-
     end
-
 end

McuLib/m/mexing.m

@@ -1,147 +1,153 @@
-% Компилирует S-function
+% Компилирует S-function для блока микроконтроллера в Simulink
+% compile_mode: 1 - компиляция, 0 - обновление конфигурации
 function res = mexing(compile_mode)
     global Ts
-    Ts = 0.00001;
+    Ts = 0.00001;  % Установка глобального времени дискретизации
     
     if compile_mode == 1
-        delete("*.mexw64")
-        delete("*.mexw64.pdb")
-        delete(".\MCU_Wrapper\Outputs\*.*");
-        set_param(gcb, 'consoleOutput', '');    
-        % Порты S-Function
-        mcuPorts.write();
-        % Дефайны
-        definesUserArg = parseDefinesMaskText();
-        definesWrapperConfigArg = buildWrapperDefinesString();
-        definesPeriphConfigArg = buildConfigDefinesString();
-        definesConfigArg = [definesWrapperConfigArg  + " " + definesPeriphConfigArg];    
-            
-        %режимы компиляции
-        if mcuMask.read_checkbox('enableDebug')
-            modeArg = "debug";
-        else
-            modeArg = "release";
-        end    
-        if mcuMask.read_checkbox('fullOutput') || mcuMask.read_checkbox('extConsol') 
-            echoArg = 'echo_enable';
-        else
-            echoArg = 'echo_disable';    
-        end
-        
-        [includesArg, codeArg] = make_mex_arguments('incTable', 'srcTable');
-        
-        % Вызов батника с двумя параметрами: includes и code
-        cmd = sprintf('.\\MCU_Wrapper\\run_mex.bat "%s" "%s" "%s" "%s" %s %s', includesArg, codeArg, definesUserArg, definesConfigArg, modeArg, echoArg);
-            
-        if mcuMask.read_checkbox('extConsol')
-            cmdout = runBatAndShowOutput(cmd);
-        else
-            [status, cmdout]= system(cmd);
-        end
-        
-        % Сохраним вывод в параметр маски с именем 'consoleOutput'
-        mcuMask.disp(1, cmdout);
+        % === РЕЖИМ КОМПИЛЯЦИИ ===
+        setenv('VSLANG', '1033');  % Английский для Visual Studio
 
+        % Обновление параметров блока
         block = gcb;
-    
         newName = get_param(block, 'sfuncName');
         oldName = get_param(block, 'FunctionName');
         if ~strcmp(newName, oldName)
-            set_param(block, 'FunctionName', newName);   
+            set_param(block, 'FunctionName', newName);  % Обновление имени функции
         end
 
         newParam = get_param(block, 'sfuncParam');
         oldParam = get_param(block, 'Parameters');
         if ~strcmp(newParam, oldParam)
-            set_param(block, 'Parameters', newParam);   
+            set_param(block, 'Parameters', newParam);  % Обновление параметров
         end
         
-        if status == 0
-            res = 0;
+        % Очистка предыдущих файлов компиляции
+        delete('*.mexw64')
+        delete('*.mexw64.pdb')
+        delete([mcuPath.get('wrapperPath'),  '\Outputs\*.*']);
+        set_param(gcb, 'consoleOutput', '');  % Очистка консоли вывода
+    
+        % Обновление BAT-файла для компиляции
+        compiler.updateRunBat();
+        
+        % Формирование дефайнов для компиляции
+        definesUserArg = parseDefinesMaskText();  % Пользовательские дефайны
+        definesWrapperConfigArg = buildWrapperDefinesString();  % Дефайны обёртки
+        definesPeriphConfigArg = buildConfigDefinesString();  % Дефайны периферии
+        definesConfigArg = [definesWrapperConfigArg  + " " + definesPeriphConfigArg];    
+            
+        % Определение режимов компиляции
+        if mcuMask.read_checkbox('enableDebug')
+            modeArg = "debug";  % Режим отладки
         else
-            res = 1;
+            modeArg = "release";  % Релизный режим
         end    
-        beep
+        
+        if mcuMask.read_checkbox('fullOutput') || mcuMask.read_checkbox('extConsol') 
+            echoArg = 'echo_enable';  % Подробный вывод
         else
+            echoArg = 'echo_disable';  % Минимальный вывод
+        end
+        
+        % Формирование аргументов для компиляции
+        [includesArg, codeArg] = make_mex_arguments('incTable', 'srcTable');
+        Name = mcuMask.get_name();  % Имя S-функции
+
+        % Вызов батника компиляции
+        run_bat_mex_path = fullfile(mcuPath.get('wrapperPath'), 'run_mex.bat');
+        cmd = sprintf('%s %s "%s" "%s" "%s" "%s" %s %s', run_bat_mex_path, Name, includesArg, codeArg, definesUserArg, definesConfigArg, modeArg, echoArg);
+            
+        if mcuMask.read_checkbox('extConsol')
+            % Запуск с внешней консолью
+            cmdout = runBatAndShowOutput(cmd);
+        else
+            % Запуск в фоновом режиме
+            [status, cmdout]= system(cmd);
+        end
+        
+        % Сохранение вывода в параметр маски
+        mcuMask.disp(1, cmdout);
+
+        if status == 0
+            res = 0;  % Успешная компиляция
+        else
+            res = 1;  % Ошибка компиляции
+        end
+        beep  % Звуковое уведомление
+
+    else
+        % === РЕЖИМ ОБНОВЛЕНИЯ КОНФИГУРАЦИИ ===
         blockPath = gcb;
-        config = periphConfig.read_config(blockPath);
-        config = periphConfig.update_config(blockPath, config);
-        periphConfig.write_config(config);
-        periphConfig.update(blockPath, config);
-        % Порты S-Function
-        mcuPorts.write();
-        % set_param(gcb, 'consoleOutput', 'Peripheral configuration file loaded. Re-open Block Parameters');
+        config = configJs.read(blockPath);  % Чтение конфигурации
+        config = configJs.update(blockPath, config);  % Обновление конфигурации
+        configJs.write(config);  % Запись конфигурации
+        periphConfig.updateMask(blockPath, config);  % Обновление маски
     end
 end
 
-%% COMPILE PARAMS
-
+%% COMPILE PARAMS - функции формирования параметров компиляции
 
 function [includesArg, codeArg] = make_mex_arguments(incTableName, srcTableame)
-%MAKE_MEX_ARGUMENTS Формирует строки аргументов для вызова mex-компиляции через батник
-%
-% [includesArg, codeArg] = make_mex_arguments(includesCell, codeCell)
+% Формирует строки аргументов для вызова mex-компиляции через батник
 %
 % Вход:
-%   includesCell — ячейковый массив путей к директориям include
-%   codeCell     — ячейковый массив исходных файлов
+%   incTableName - имя таблицы с путями включения
+%   srcTableame - имя таблицы с исходными файлами
 %
 % Выход:
-%   includesArg  — строка для передачи в батник, например: "-I"inc1" -I"inc2""
-%   codeArg      — строка с исходниками, например: ""src1.c" "src2.cpp""
+%   includesArg - строка с флагами включения (-I"path")
+%   codeArg - строка с исходными файлами ("file1.c" "file2.cpp")
 
-
-    % Здесь пример получения из маски текущего блока (замени по своему)
+    % Получение данных из таблиц маски
     includesCell = customtable.parse(incTableName);
     codeCell = customtable.parse(srcTableame);
 
-    % Оборачиваем пути в кавычки и добавляем -I
+    % Формирование строки путей включения с флагом -I
     includesStr = strjoin(cellfun(@(f) ['-I"' f '"'], includesCell, 'UniformOutput', false), ' ');
 
-    % Оборачиваем имена файлов в кавычки
+    % Формирование строки исходных файлов в кавычках
     codeStr = strjoin(cellfun(@(f) ['"' f '"'], codeCell, 'UniformOutput', false), ' ');
 
-    % Удаляем символ переноса строки и пробел в конце, если вдруг попал
+    % Удаление лишних пробелов
     codeStr = strtrim(codeStr);
     includesStr = strtrim(includesStr);
 
-    % Оборачиваем всю строку в кавычки, чтобы батник корректно понял
-    % includesArg = ['"' includesStr '"'];
-    % codeArg = ['"' codeStr '"'];
     includesArg = includesStr;
     codeArg = codeStr;
-
 end
 
-
 function definesWrapperArg = buildWrapperDefinesString()
+% Формирование дефайнов для конфигурации обёртки
 
     definesWrapperArg = '';
+    % Добавление дефайнов из параметров маски
     definesWrapperArg = addDefineByParam(definesWrapperArg, 'enableThreading', 0);
     definesWrapperArg = addDefineByParam(definesWrapperArg, 'enableDeinit', 0);
     definesWrapperArg = addDefineByParam(definesWrapperArg, 'threadCycles', 1);
     definesWrapperArg = addDefineByParam(definesWrapperArg, 'mcuClk', 1);
 end
 
-
 function definesUserArg = parseDefinesMaskText()
+% Парсинг пользовательских дефайнов из текстового поля маски
+
     blockHandle = gcbh;
-    % Получаем MaskValues и MaskNames
+    % Получение параметров маски
     maskValues = get_param(blockHandle, 'MaskValues');
     paramNames = get_param(blockHandle, 'MaskNames');
 
-    % Индекс параметра userDefs
+    % Поиск параметра с пользовательскими дефайнами
     idxUserDefs = find(strcmp(paramNames, 'userDefs'));
-    definesText = maskValues{idxUserDefs}; % Текст с пользовательскими определениями
+    definesText = maskValues{idxUserDefs};
 
-    % Убираем буквальные символы \n и \r
+    % Обработка специальных символов
     definesText = strrep(definesText, '\n', ' ');
     definesText = strrep(definesText, '\r', ' ');
 
-    % Разбиваем по переносам строк
+    % Разбиение на строки
     lines = split(definesText, {'\n', '\r\n', '\r'});
 
-    parts = strings(1,0); % пустой массив строк
+    parts = strings(1,0); % массив для хранения дефайнов
 
     for k = 1:numel(lines)
         line = strtrim(lines{k});
@@ -149,7 +155,7 @@ function definesUserArg = parseDefinesMaskText()
             continue;
         end
 
-        % Разбиваем по пробелам, чтобы получить отдельные определения в строке
+        % Разбиение строки на токены
         tokens = split(line);
 
         for t = 1:numel(tokens)
@@ -158,11 +164,13 @@ function definesUserArg = parseDefinesMaskText()
                 continue;
             end
 
+            % Обработка дефайнов с значениями и без
             eqIdx = strfind(token, '=');
             if isempty(eqIdx)
-                % Просто ключ без значения
+                % Дефайн без значения
                 parts(end+1) = sprintf('-D"%s"', token);
             else
+                % Дефайн со значением
                 key = strtrim(token(1:eqIdx(1)-1));
                 val = strtrim(token(eqIdx(1)+1:end));
                 parts(end+1) = sprintf('-D"%s__EQ__%s"', key, val);
@@ -173,13 +181,13 @@ function definesUserArg = parseDefinesMaskText()
     definesUserArg = strjoin(parts, ' ');
 end
 
-
-
 function definesWrapperArg = buildConfigDefinesString()
+% Формирование дефайнов из конфигурации периферии
+
     blockHandle = gcbh;
     mask = Simulink.Mask.get(blockHandle);
 
-    tabName = 'configTabAll';  % Имя вкладки (Prompt)
+    tabName = 'configTabAll';  % Имя вкладки с конфигурацией
 
     tabCtrl = mask.getDialogControl(tabName);
 
@@ -187,73 +195,91 @@ function definesWrapperArg = buildConfigDefinesString()
         error('Вкладка с названием "%s" не найдена в маске', tabName);
     end
 
-
+    % Сбор всех параметров из вкладки конфигурации
     params = mcuMask.collect_all_parameters(tabCtrl);
     definesWrapperArg = '';
     for i = 1:numel(params)
-        % Получаем имя параметра из контрола
         paramName = string(params(i));
         try
-            % Получаем объект параметра по имени
             param = mask.getParameter(paramName);
 
-            % Определяем тип параметра
+            % Обработка разных типов параметров
             switch lower(param.Type)
                 case 'checkbox'
                     definesWrapperArg = addDefineByParam(definesWrapperArg, paramName, 0);
                 case 'edit'
                     definesWrapperArg = addDefineByParam(definesWrapperArg, paramName, 1);
+                case 'popup'
+                    definesWrapperArg = addDefineByParam(definesWrapperArg, paramName, 0);
                 otherwise
-                    % Необрабатываемые типы
+                    % Пропуск необрабатываемых типов
             end
         catch ME
-            % warning('Не удалось получить параметр "%s": %s', paramName, ME.message);
+            % Игнорирование ошибок для отсутствующих параметров
         end
     end
 end
 
-
-%% PARSE FUNCTIONS
-
 function definesWrapperArg = addDefineByParam(definesWrapperArg, paramName, val_define)
+% Добавление дефайна на основе параметра маски
+
     blockHandle = gcbh;
     mask = Simulink.Mask.get(blockHandle);
 
-    % Получаем MaskValues, MaskNames
+    % Получение значений маски
     maskValues = get_param(blockHandle, 'MaskValues');
     paramNames = get_param(blockHandle, 'MaskNames');
-    param = mask.getParameter(paramName); % для alias
+    param = mask.getParameter(paramName);
 
-    % Найдём индекс нужного параметра
+    % Поиск индекса параметра
     idxParam = find(strcmp(paramNames, paramName), 1);
     if isempty(idxParam)
         error('Parameter "%s" not found in block mask parameters.', paramName);
     end
 
-    % Берём alias из маски
-    alias = param.Alias;
+    % Определение имени дефайна (алиас или значение)
+    val = '';
+    if ~strcmp(param.Type, 'popup')
+        def_name = param.Alias;
+    else
+        if strcmp(param.Alias, '')
+            def_name = param.Value;
+        else
+            def_name = param.Alias;
+            val = param.Value;
+        end
+    end
 
+    if strcmp(def_name, '')
+        return;
+    end
+
+    % Формирование дефайна в зависимости от типа параметра
     if val_define ~= 0
-        % Значение параметра
+        % Параметры с значениями
         val = maskValues{idxParam};
         if strcmp(param.Evaluate, 'on')
-            val = evalin('base', val);   % Вычисляем выражение
-            val = num2str(val);          % Преобразуем результат в строку
+            val = evalin('base', val);  % Вычисление выражений
+            val = num2str(val);
         end
-        % Формируем define с кавычками и значением
-        newDefine = ['-D"' alias '__EQ__' val '"'];
-    else
+        newDefine = ['-D"' def_name '__EQ__' val '"'];
+    elseif ~strcmp(param.Type, 'popup')
+        % Чекбоксы
         if mcuMask.read_checkbox(paramName)
-            % Формируем define с кавычками без значения
-            newDefine = ['-D"' alias '"'];
+            newDefine = ['-D"' def_name '"'];
         else
             newDefine = '';
         end
+    else
+        % Выпадающие списки
+        if strcmp(param.Alias, '')
+            newDefine = ['-D"' def_name '"'];
+        else
+            newDefine = ['-D"' def_name '__EQ__' val '"'];
+        end
     end
 
-
-
-    % Добавляем новый define к существующему (string)
+    % Добавление дефайна к результирующей строке
     if isempty(definesWrapperArg) || strlength(strtrim(definesWrapperArg)) == 0
         definesWrapperArg = newDefine;
     else
@@ -261,19 +287,22 @@ function definesWrapperArg = addDefineByParam(definesWrapperArg, paramName, val_
     end
 end
 
+%% CONSOLE FUNCTIONS - функции работы с консолью
 
-%% CONSOLE FUNCTIONS
 function cmdret = runBatAndShowOutput(cmd)
+% Запуск BAT-файла с отображением вывода в реальном времени
+
     import java.io.*;
     import java.lang.*;
-    cmdEnglish = ['chcp 437 > nul && ' cmd];
+    
+    cmdEnglish = ['chcp 437 > nul && ' cmd];  % Установка английской кодировки
     pb = java.lang.ProcessBuilder({'cmd.exe', '/c', cmdEnglish});
     pb.redirectErrorStream(true);
     process = pb.start();
 
+    % Чтение вывода процесса
     reader = BufferedReader(InputStreamReader(process.getInputStream()));
-
-    cmdret = ""; % Здесь будем накапливать весь вывод
+    cmdret = "";
 
     while true
         if reader.ready()
@@ -281,36 +310,37 @@ function cmdret = runBatAndShowOutput(cmd)
             if isempty(line)
                 break;
             end
-            cmdret = cmdret + string(line) + newline; % сохраняем вывод
-            % Здесь выводим только новую строку
-            safeLine = strrep(line, '''', ''''''); % Экранируем апострофы
-            logWindow_append(safeLine);
-            drawnow; % обновляем GUI
+            cmdret = cmdret + string(line) + newline;
+            safeLine = strrep(line, '''', '''''');  % Экранирование кавычек
+            logWindow_append(safeLine);  % Вывод в окно лога
+            drawnow;
         else
             if ~process.isAlive()
-                % дочитываем оставшиеся строки
+                % Дочтение оставшегося вывода
                 while reader.ready()
                     line = char(reader.readLine());
                     if isempty(line)
                         break;
                     end
-                    cmdret = cmdret + string(line) + newline; % сохраняем вывод
+                    cmdret = cmdret + string(line) + newline;
                     safeLine = strrep(line, '''', '''''');
                     logWindow_append(safeLine);
                     drawnow;
                 end
                 break;
             end
-            pause(0.2);
+            pause(0.2);  % Пауза между проверками
         end
     end
     process.waitFor();
 end
 
-
 function logWindow_append(line)
+% Добавление строки в окно лога с автоскроллингом
+
     persistent fig hEdit jScrollPane jTextArea
 
+    % Создание окна лога при первом вызове
     if isempty(fig) || ~isvalid(fig)
         fig = figure('Name', 'Log Window', 'Position', [100 100 600 400]);
         hEdit = uicontrol('Style', 'edit', ...
@@ -322,10 +352,12 @@ function logWindow_append(line)
             'BackgroundColor', 'white', ...
             'Tag', 'LogWindowFigure');
 
-        jScrollPane = findjobj(hEdit);                  % JScrollPane
-        jTextArea = jScrollPane.getViewport.getView;   % JTextArea внутри JScrollPane
+        % Получение Java-компонентов для управления скроллингом
+        jScrollPane = findjobj(hEdit);
+        jTextArea = jScrollPane.getViewport.getView;
     end
 
+    % Добавление новой строки
     oldText = get(hEdit, 'String');
     if ischar(oldText)
         oldText = {oldText};
@@ -333,32 +365,30 @@ function logWindow_append(line)
 
     set(hEdit, 'String', [oldText; {line}]);
     drawnow;
-    % Автоскролл вниз:
+    
+    % Автоскроллинг вниз
     jTextArea.setCaretPosition(jTextArea.getDocument.getLength);
     drawnow;
 end
 
-
-%% READ CONFIGS
-
 function isOpen = isMaskDialogOpen(blockPath)
+% Проверка открыто ли диалоговое окно маски
+
     isOpen = false;
 
     try
-        % Получаем имя блока
         blockName = get_param(blockPath, 'Name');
 
-        % Получаем список окон MATLAB GUI
+        % Получение всех открытых окон Java
         jWindows = java.awt.Window.getWindows();
 
         for i = 1:numel(jWindows)
             win = jWindows(i);
 
-            % Проверка, что окно видимое и активно
             if win.isShowing()
                 try
                     title = char(win.getTitle());
-                    % Проверка по ключевому слову, соответствующему заголовку маски
+                    % Поиск окна маски по заголовку
                     if contains(title, ['Mask Editor: ' blockName]) || ...
                        contains(title, ['Mask: ' blockName]) || ...
                        contains(title, blockName)
@@ -366,7 +396,7 @@ function isOpen = isMaskDialogOpen(blockPath)
                         return;
                     end
                 catch
-                    % Окно не имеет заголовка — пропускаем
+                    % Пропуск окон без заголовка
                 end
             end
         end
@@ -374,4 +404,3 @@ function isOpen = isMaskDialogOpen(blockPath)
         isOpen = false;
     end
 end
-

McuLib/m/periphConfig.m

@@ -1,102 +1,45 @@
 classdef periphConfig
+    % Класс для управления конфигурацией периферии в маске Simulink
+    % Динамически создает элементы маски на основе JSON конфигурации
 
     methods(Static)
-        function update(blockPath, config)
-        %     blockPath = [blockPath '/MCU'];
+        function updateMask(blockPath, config)
+            % Основная функция обновления маски на основе конфигурации
+            % Динамически создает вкладки и параметры для периферийных модулей
+            % blockPath - путь к блоку Simulink
+            % config - структура конфигурации из JSON файла
             
-            % Проверяем, была ли маска открыта
-%             wasOpen = isMaskDialogOpen(blockPath);
             mask = Simulink.Mask.get(blockPath);
-            periphPath = get_param(blockPath, 'periphPath');            
-            [periphPath, ~, ~] = fileparts(periphPath);
 
+            % Сохраняем состояние таблиц перед изменением маски
             tableNames = {'incTable', 'srcTable'};
             columns_backup = customtable.save_all_tables(tableNames);
             
+            try
+                % Получаем настройки ширины строк из параметра маски
+                rowWidth = str2double(get_param(blockPath, 'rowWidth'));
+
+                % Очищаем контейнер конфигурации перед созданием новых элементов
                 containerName = 'configTabAll';
                 periphConfig.clear_all_from_container(mask, containerName);
             
-            % Ищем контейнер, в который будем добавлять вкладки
+                % Получаем контейнер для вкладок конфигурации
                 container = mask.getDialogControl(containerName);
                 if isempty(container)
                     error('Контейнер "%s" не найден в маске.', containerName);
                 end
             
+                % Обрабатываем конфигурацию если она не пустая
                 if ~isempty(config)
-
-                if isfield(config, 'Code')
-                    res = periphConfig.addCodeConfig(config.Code, periphPath);
-                    if res == 0
-                        error('Ошибка: неудачное добавление кода периферии. Проверьте корректность файлов и путей в конфигурационном файле')
-                    end
-                else
-                    error('Ошибка: в конфигурационном файле не задан исходный код для симуляции периферии')
-                end
-                
-                if isfield(config, 'UserCode')
-                    res = periphConfig.addUserCodeConfig(config.UserCode);
-                    if res == 0
-                        error('Ошибка: неудачное добавление функций для симуляции. Проверьте корректность названий функций в конфигурационном файле')
-                    end
-                else
-                    error('Ошибка: в конфигурационном файле не заданы функции для симуляции периферии')
-                end
-
-                % Проходим по каждому модулю (ADC, TIM...)
+                    % Проходим по каждому модулю периферии (ADC, TIM, UART и т.д.)
                     periphs = fieldnames(config);
                     for i = 1:numel(periphs)
                         periph = periphs{i};
     
-                    % Пропускаем Code и UserCode, они уже обработаны
-                    if strcmp(periph, 'Code') || strcmp(periph, 'UserCode')
-                        continue;
-                    end
+                        % Сохраняем код модуля (исходники и инклюды) в скрытые параметры
+                        periphConfig.store_single_periph_code(mask, periph, config.(periph));
                         
-                    defines = config.(periph).Defines;
-                    defNames = fieldnames(defines);
-            
-                    % Создаём вкладку для модуля
-                    tabCtrl = container.addDialogControl('tab', periph);
-                    tabCtrl.Prompt = [periph ' Config'];
-            
-                    for j = 1:numel(defNames)
-                        defPrompt = defNames{j};
-                        def = defines.(defPrompt);
-
-                        % Вызов функции добавления одного параметра
-                        periphConfig.addDefineConfig(mask, containerName, periph, defPrompt, def);
-                    end
-                end
-            end
-            % Восстанавливаем таблицы
-            customtable.restore_all_tables(tableNames, columns_backup);
-        
-            % % Повторно открываем маску, если она была открыта
-            % if wasOpen
-            %     open_system(blockPath, 'mask');
-            % end
-        end
-        
-        function config = update_config(blockPath, config)
-            if isempty(config)
-                return;
-            end
-        
-            mask = Simulink.Mask.get(blockPath);
-            maskParams = mask.Parameters;
-            paramNames = arrayfun(@(p) p.Name, maskParams, 'UniformOutput', false);
-
-            % Обработка остальных секций (с дефайнами)
-            periphs = fieldnames(config);        
-            for i = 1:numel(periphs)
-                periph = periphs{i};
-        
-                % Пропускаем Code и UserCode, они уже обработаны
-                if strcmp(periph, 'Code') || strcmp(periph, 'UserCode')
-                    continue;
-                end
-        
-                % Проверяем есть ли Defines
+                        % Пропускаем модули без секции Defines
                         if ~isfield(config.(periph), 'Defines')
                             continue;
                         end
@@ -104,77 +47,421 @@ classdef periphConfig
                         defines = config.(periph).Defines;
                         defNames = fieldnames(defines);
                 
+                        % Создаем вкладку для модуля периферии
+                        tabCtrl = container.addDialogControl('tab', periph);
+                        tabCtrl.Prompt = [periph ' Config'];  % Отображаемое имя вкладки
+                
+                        % Карта для отслеживания количества строк в каждой вкладке
+                        rowCountMap = containers.Map();
+                        
+                        % Добавляем все параметры Defines в созданную вкладку
                         for j = 1:numel(defNames)
                             defPrompt = defNames{j};
-                    paramName = matlab.lang.makeValidName(defPrompt);
+                            def = defines.(defPrompt);
     
-                    % Проверка, существует ли параметр с таким именем
-                    if ismember(paramName, paramNames)
-                        param = mask.getParameter(paramName);
-                        valStr = param.Value;
-        
-                        % Проверяем, существует ли элемент defPrompt в структуре defines
-                        if isfield(defines, defPrompt)
-                            % Преобразуем строку в соответствующий тип
-                            if strcmpi(defines.(defPrompt).Type, 'checkbox')
-                                config.(periph).Defines.(defPrompt).Default = strcmpi(valStr, 'on');
-                            elseif strcmpi(defines.(defPrompt).Type, 'edit')
-                                valNum = str2double(valStr);
-                                if isnan(valNum)
-                                    config.(periph).Defines.(defPrompt).Default = valStr;
-                                else
-                                    config.(periph).Defines.(defPrompt).Default = valNum;
-                                end
-                            end
-                        end
-                    end
+                            % Добавление одного параметра конфигурации
+                            periphConfig.addConfig(mask, containerName, periph, defPrompt, def, rowCountMap, rowWidth);
                         end
                     end
                 end
                 
-        function config = read_config(blockPath)
+                % Создаем скрытые параметры для хранения кода периферии
+                periphConfig.create_all_code_storage_params(blockPath, config);
+                
+                % Обновляем состояние маски (включение/выключение вкладок)
+                periphConfig.update();
+            
+                % Восстанавливаем таблицы после изменений
+                customtable.restore_all_tables(tableNames, columns_backup);
+            catch
+                % В случае ошибки восстанавливаем таблицы
+                customtable.restore_all_tables(tableNames, columns_backup);
+            end
+        end
+        
+        function update()
+            % Обновление состояния маски - включение/выключение вкладок
+            % на основе состояний чекбоксов управления
+            
+            blockPath = gcb;
             mask = Simulink.Mask.get(blockPath);
 
-            pathparam = mask.getParameter('periphPath');
-            config_path = pathparam.Value;
+            % Читаем текущую конфигурацию
+            config = configJs.read(blockPath);
+            containerName = 'configTabAll';
+            container = mask.getDialogControl(containerName);
             
-            if ~isempty(config_path)
-                jsonText = fileread(config_path);
-                config = jsondecode(jsonText);
+            % Получаем все параметры для проверки наличия чекбоксов
+            paramsAll = mcuMask.collect_all_parameters(container);          
+            
+            % Получаем имена всех вкладок в контейнере
+            allTabs = container.DialogControls;
+            allTabNames = arrayfun(@(t) t.Name, allTabs, 'UniformOutput', false);
+            
+            fieldsConfig = fieldnames(config);
+            
+            % Обрабатываем каждую вкладку
+            for i = 1:length(allTabNames)
+                periph = fieldsConfig{i};
+                
+                % Проверяем наличие чекбокса управления для этой вкладки
+                checkboxName = ['Tab_' periph '_Enable'];
+                if ismember(checkboxName, paramsAll)
+                    % Чекбокс найден - управляем состоянием вкладки
+                    paramObj = mask.getParameter(checkboxName);
+                    val = paramObj.Value;
+                    
+                    try
+                        tab = container.getDialogControl(periph);
+                        if strcmpi(val, 'off')
+                            % Выключаем вкладку и очищаем связанные параметры
+                            tab.Enabled = 'off';
+                            periphConfig.clear_tab_params(mask, config.(periph), periph);
                         else
-                config = [];
+                            % Включаем вкладку и синхронизируем параметры
+                            tab.Enabled = 'on';
+                            periphConfig.sync_tab_params(mask, config.(periph), periph);
+                        end
+                    catch
+                        warning('Вкладка с именем "%s" не найдена.', periph);
+                    end
+                    
+                else
+                    % Чекбокса нет - просто включаем вкладку
+                    try
+                        tab = container.getDialogControl(periph);
+                        tab.Enabled = 'on';
+                        % Синхронизируем параметры если есть конфигурация
+                        if isfield(config, periph)
+                            periphConfig.sync_tab_params(mask, config.(periph), periph);
+                        end
+                    catch
+                        % Вкладка может быть необязательной - игнорируем ошибку
+                    end
+                end
             end
         end
 
-        function write_config(config)
-            if isempty(config)
-                return
+        function periphParamCallback(paramName)
+            % Callback-функция для параметров периферии
+            % Обрабатывает изменения чекбоксов и других параметров
+            
+            blockPath = gcb;
+            mask = Simulink.Mask.get(blockPath);
+            hObj = mask.getParameter(paramName);
+            config = configJs.read(blockPath);
+            container = mask.getDialogControl('configTabAll');
+        
+            % === Обработка чекбоксов управления вкладками ===
+            exprTab = '^Tab_(\w+)_Enable$';
+            tokensTab = regexp(paramName, exprTab, 'tokens');
+        
+            if ~isempty(tokensTab)
+                periph = tokensTab{1}{1};
+        
+                try
+                    tab = container.getDialogControl(periph);
+                    paramVal = hObj.Value;
+        
+                    if strcmpi(paramVal, 'off')
+                        % Выключаем вкладку и очищаем параметры
+                        tab.Enabled = 'off';
+                        if isfield(config, periph)
+                            periphConfig.clear_tab_params(mask, config.(periph), periph);
+                        end
+                    else
+                        % Включаем вкладку и синхронизируем параметры
+                        tab.Enabled = 'on';
+                        if isfield(config, periph)
+                            periphConfig.sync_tab_params(mask, config.(periph), periph);
+                        end
+                    end
+                catch
+                    warning('Ошибка обработки вкладки "%s".', periph);
+                end
+                return;
             end
         
-            blockHandle = gcbh;
-            mask = Simulink.Mask.get(blockHandle);
+            % === Обработка параметров, связанных с Sources/Includes ===
+            nameBase = paramName;
             
-            pathparam = mask.getParameter('periphPath');
-            config_path = pathparam.Value;
+            paramNames = string({mask.Parameters.Name});
+            hasSources = any(paramNames == "Hidden_" + nameBase + "_Sources");
+            hasIncludes = any(paramNames == "Hidden_" + nameBase + "_Includes");
             
-            jsonText = jsonencode(config, 'PrettyPrint', true);
-            fid = fopen(config_path, 'w', 'n', 'UTF-8');
-            if fid == -1
-                error('Не удалось открыть файл periph_config.json для записи.');
+            if hasSources || hasIncludes
+                useVal = hObj.Value;
+            
+                % Получаем структуру конфигурации для этого параметра
+                try
+                    valueStruct = configJs.get_field(config, nameBase);
+                catch
+                    warning('Не удалось найти путь %s в config.', nameBase);
+                    return;
                 end
-            fwrite(fid, jsonText, 'char');
-            fclose(fid);
+            
+                if strcmpi(useVal, 'on')
+                    % Сохраняем код если параметр включен
+                    try
+                        periphConfig.store_single_periph_code(mask, nameBase, valueStruct);
+                    catch
+                        warning('Не удалось сохранить параметры для %s.', nameBase);
+                    end
+                else
+                    % Очищаем код если параметр выключен
+                    periphConfig.clear_single_periph_code_param(mask, nameBase);
+                end
+                return;
+            end
+        end
+
+        function updatePeriphRunMexBat()
+            % Обновление BAT-файла для компиляции с кодом периферии
+            % Собирает все исходники и инклюды из скрытых параметров
+            
+            blockPath = gcb;
+            % Восстанавливаем код периферии из скрытых параметров маски
+            CodeStruct = periphConfig.restore_periph_code_from_mask(blockPath);
+            periphPath = mcuPath.get('periphPath');
+            [periphPath, ~, ~] = fileparts(periphPath);
+            
+            % Добавляем код в BAT-файл компиляции
+            periphConfig.addCodeBat(CodeStruct, periphPath);
+        end
+    end
+
+    methods(Static, Access=private)
+        function addHiddenParam(mask, containerName, nameBase, kind, existingParams)
+            % Создание скрытого параметра для хранения кода
+            % nameBase - базовое имя параметра
+            % kind - тип ('Sources' или 'Includes')
+            
+            prettyName = strrep(nameBase, '_', ' ');
+            paramName = ['Hidden_' char(nameBase) '_' kind];
+            
+            % Проверяем не существует ли уже параметр
+            if ismember(paramName, existingParams)
+                return;
+            end
+        
+            % Создаем скрытый параметр
+            mask.addParameter( ...
+                'Name', paramName, ...
+                'Type', 'edit', ...
+                'Prompt', ['Hidden ' prettyName ' ' kind], ...
+                'Value', '', ...
+                'Visible', 'off', ...
+                'Container', containerName ...
+            );
+        end
+
+        function clear_tab_params(mask, configStruct, prefix, depth)
+            % Рекурсивная очистка параметров вкладки
+            % Используется при выключении вкладки
+            
+            if nargin < 4
+                depth = 0;
+            end
+            maxDepth = 3;  % Ограничение глубины рекурсии
+            
+            fields = fieldnames(configStruct);
+        
+            for i = 1:numel(fields)
+                key = fields{i};
+                value = configStruct.(key);
+                paramName = [prefix '_' key];
+        
+                if isstruct(value)
+                    if depth < maxDepth
+                        % Рекурсивный вызов для вложенных структур
+                        periphConfig.clear_tab_params(mask, value, paramName, depth + 1);
+                    end
+                else
+                    % Очищаем параметры Sources/Includes
+                    if strcmp(key, 'Sources') || strcmp(key, 'Includes')
+                        baseName = configJs.get_final_name_from_prefix(prefix);
+                        periphConfig.clear_single_periph_code_param(mask, baseName);
+                    end
+                end
+            end
+        end
+        
+        function sync_tab_params(mask, configStruct, prefix, depth)
+            % Рекурсивная синхронизация параметров вкладки
+            % Используется при включении вкладки
+            
+            if nargin < 4
+                depth = 0;
+            end
+            maxDepth = 3;
+            
+            fields = fieldnames(configStruct);
+        
+            for i = 1:numel(fields)
+                key = fields{i};
+                value = configStruct.(key);
+                paramName = [prefix '_' key];
+        
+                if isstruct(value)
+                    if depth < maxDepth
+                        periphConfig.sync_tab_params(mask, value, paramName, depth + 1);
+                    end
+                else
+                    if strcmp(key, 'Sources') || strcmp(key, 'Includes')
+                        baseName = configJs.get_final_name_from_prefix(prefix);
+                        periphConfig.store_single_periph_code(mask, baseName, configStruct);
+                    end
+                end
+            end
+        end
+
+        function create_all_code_storage_params(blockPath, config)
+            % Создание всех скрытых параметров для хранения кода периферии
+            
+            mask = Simulink.Mask.get(blockPath);
+        
+            containerName = 'configTabAll';
+            container = mask.getDialogControl(containerName);
+            existingParams = mcuMask.collect_all_parameters(container);
+        
+            % Создаем скрытую вкладку для хранения параметров кода
+            tabName = 'hiddenCodeTab';
+            tab = mask.getDialogControl(tabName);
+            if isempty(tab)
+                tab = container.addDialogControl('tab', tabName);
+                tab.Prompt = 'Hidden Code Settings';
+                tab.Visible = 'off';
+            else
+                tab.Visible = 'off';
+            end
+        
+            % Рекурсивный обход конфигурации для создания параметров
+            periphConfig.process_struct_recursive(mask, tabName, config, {}, existingParams);
+        end
+        
+        function process_struct_recursive(mask, tabName, currentStruct, nameStack, existingParams)
+            % Рекурсивный обход структуры конфигурации
+            % Создает скрытые параметры для всех Sources и Includes
+            
+            fields = fieldnames(currentStruct);
+            for i = 1:numel(fields)
+                fieldName = fields{i};
+                value = currentStruct.(fieldName);
+                newStack = [nameStack, fieldName];
+        
+                if isstruct(value)
+                    % Проверяем наличие Sources и Includes в структуре
+                    hasSources = isfield(value, 'Sources');
+                    hasIncludes = isfield(value, 'Includes');
+        
+                    if hasSources
+                        periphConfig.addHiddenParam(mask, tabName, fieldName, 'Sources', existingParams);
+                    end
+                    if hasIncludes
+                        periphConfig.addHiddenParam(mask, tabName, fieldName, 'Includes', existingParams);
+                    end
+        
+                    % Рекурсивно продолжаем обход
+                    periphConfig.process_struct_recursive(mask, tabName, value, newStack, existingParams);
+                end
+            end
+        end
+
+        function cleanup_obsolete_code_params(blockPath, config)
+            % Очистка устаревших скрытых параметров
+            % Удаляет параметры для периферии, которой больше нет в конфигурации
+            
+            mask = Simulink.Mask.get(blockPath);
+            maskParams = mask.Parameters;
+        
+            % Получаем список актуальных периферийных модулей
+            validPeriphs = fieldnames(config);
+        
+            for i = 1:numel(maskParams)
+                paramName = maskParams(i).Name;
+        
+                % Ищем параметры хранения кода
+                expr = '^Hidden_(\w+)_(Sources|Includes)$';
+                tokens = regexp(paramName, expr, 'tokens');
+                if ~isempty(tokens)
+                    periph = tokens{1}{1};
+        
+                    % Удаляем параметр если периферия больше не существует
+                    if ~ismember(periph, validPeriphs)
+                        mask.removeParameter(paramName);
+                    end
+                end
+            end
+        end
+
+        function codeStruct = restore_periph_code_from_mask(blockPath)
+            % Восстановление кода периферии из скрытых параметров маски
+            % Собирает все Sources и Includes в одну структуру
+            
+            mask = Simulink.Mask.get(blockPath);
+            maskParams = mask.Parameters;
+            
+            allSources = {};
+            allIncludes = {};
+            
+            for i = 1:numel(maskParams)
+                name = maskParams(i).Name;
+                
+                % Поиск параметров Sources
+                tokensSrc = regexp(name, '^Hidden_(\w+)_Sources$', 'tokens');
+                if ~isempty(tokensSrc)
+                    val = maskParams(i).Value;
+                    
+                    if ischar(val) || isstring(val)
+                        valStr = strtrim(char(val));
+                        % Пропускаем пустые значения
+                        if isempty(valStr) || strcmp(valStr, '[]')
+                            continue;
+                        end
+                        
+                        % Разбиваем на строки и фильтруем пустые
+                        lines = splitlines(valStr);
+                        lines = lines(~cellfun(@(x) all(isspace(x)) || isempty(x), lines));
+                        allSources = [allSources; lines];
+                    end
+                    continue;
+                end
+                
+                % Поиск параметров Includes
+                tokensInc = regexp(name, '^Hidden_(\w+)_Includes$', 'tokens');
+                if ~isempty(tokensInc)
+                    val = maskParams(i).Value;
+                    
+                    if ischar(val) || isstring(val)
+                        valStr = strtrim(char(val));
+                        if isempty(valStr) || strcmp(valStr, '[]')
+                            continue;
+                        end
+                        
+                        lines = splitlines(valStr);
+                        lines = lines(~cellfun(@(x) all(isspace(x)) || isempty(x), lines));
+                        allIncludes = [allIncludes; lines];
+                    end
+                    continue;
+                end
+            end
+            
+            % Формируем результирующую структуру
+            codeStruct = struct();
+            codeStruct.Sources = allSources;
+            codeStruct.Includes = allIncludes;
         end
 
         function clear_all_from_container(mask, containerName)
-            % allControls = mask.getDialogControls();
+            % Полная очистка контейнера - удаление всех параметров и вкладок
+            
             container = mask.getDialogControl(containerName);
             if isempty(container)
                 warning('Контейнер "%s" не найден.', containerName);
                 return;
             end
         
-            % Рекурсивно собрать все параметры (не вкладки)
+            % Собираем все параметры в контейнере
             paramsToDelete = mcuMask.collect_all_parameters(container);
         
             % Удаляем все параметры
@@ -186,74 +473,27 @@ classdef periphConfig
                 end
             end
         
-            % Рекурсивно удалить все вкладки внутри контейнера
+            % Рекурсивно удаляем все вкладки
             mcuMask.delete_all_tabs(mask, container);
         end
 
-    end
+        function res = addCodeBat(codeConfig, codePath)
+            % Добавление кода периферии в BAT-файл компиляции
             
-    methods(Static, Access=private)
-        
-        function res = addCodeConfig(codeConfig, periphPath)
-            % Возвращает 0 при успехе, 1 при ошибке            
             try
-                % Источники
-                srcList = {};
-                if isfield(codeConfig, 'Sources') && isfield(codeConfig.Sources, 'Options')
-                    srcFiles = codeConfig.Sources.Options;
-                    for i = 1:numel(srcFiles)
-                        fullPath = fullfile(periphPath, srcFiles{i});
-                        srcList{end+1} = [strrep(fullPath, '\', '\\')];
-                    end
-                end
+                % Формируем строки для BAT-файла
+                srcText = compiler.createSourcesBat('code_PERIPH', codeConfig.Sources, codePath);
+                incText = compiler.createIncludesBat('includes_PERIPH', codeConfig.Includes, codePath);
                 
-                % Формируем srcText с переносами строк и ^
-                srcText = '';
-                for i = 1:numel(srcList)
-                    if i < numel(srcList)
-                        srcText = [srcText srcList{i} '^' newline ' '];
-                    else
-                        srcText = [srcText srcList{i}];
-                    end
-                end
-                
-                % Инклуды
-                incList = {};
-                if isfield(codeConfig, 'Includes') && isfield(codeConfig.Includes, 'Options')
-                    incPaths = codeConfig.Includes.Options;
-                    for i = 1:numel(incPaths)
-                        fullPath = fullfile(periphPath, incPaths{i});
-                        incList{end+1} = ['-I"' strrep(fullPath, '\', '\\') '"'];
-                    end
-                end
-                
-                % Формируем incText с переносами строк и ^
-                incText = '';
-                for i = 1:numel(incList)
-                    if i == 1 && numel(incList) ~= 1
-                        incText = [incText incList{i} '^' newline];
-                    elseif i < numel(incList)
-                        incText = [incText ' ' incList{i} '^' newline];
-                    else
-                        incText = [incText ' ' incList{i}];
-                    end
-                end
-                
-                % Добавляем префиксы
-                srcText = ['set code_PERIPH' '=' srcText];
-                incText = ['set includes_PERIPH' '=' incText];
-                
-                % Записываем результат
-                res = periphConfig.updateRunMexBat(srcText, incText); % Всё прошло успешно
+                % Обновляем BAT-файл
+                res = compiler.updateRunMexBat(srcText, incText, ':: PERIPH BAT');
             catch
-                % В случае ошибки просто возвращаем 1
-                res = 1;
+                res = 1;  % Ошибка
             end
         end
 
-
-        function res = addUserCodeConfig(userCodeConfig)
-            % userCodeConfig — структура config.UserCode
+        function res = addUserFunctions(userCodeConfig)
+            % Добавление пользовательских функций в код обёртки
             
             initFuncsText = '';
             simFuncsText = '';
@@ -262,45 +502,46 @@ classdef periphConfig
             if isfield(userCodeConfig, 'Functions')
                 funcs = userCodeConfig.Functions;
 
-                if isfield(funcs, 'PeriphInit') && isfield(funcs.PeriphInit, 'Options')
-                    initFuncs = funcs.PeriphInit.Options;
+                % Обрабатываем функции инициализации
+                if isfield(funcs, 'PeriphInit')
+                    initFuncs = funcs.PeriphInit;
                     initFuncsText = strjoin(strcat('\t', initFuncs, ';'), '\n');
                 end
                 
-                if isfield(funcs, 'PeriphSimulation') && isfield(funcs.PeriphSimulation, 'Options')
-                    simFuncs = funcs.PeriphSimulation.Options;
+                % Обрабатываем функции симуляции
+                if isfield(funcs, 'PeriphSimulation')
+                    simFuncs = funcs.PeriphSimulation;
                     simFuncsText = strjoin(strcat('\t', simFuncs, ';'), '\n');
                 end
 
-                if isfield(funcs, 'PeriphDeinit') && isfield(funcs.PeriphDeinit, 'Options')
-                    deinitFuncs = funcs.PeriphDeinit.Options;
+                % Обрабатываем функции деинициализации
+                if isfield(funcs, 'PeriphDeinit')
+                    deinitFuncs = funcs.PeriphDeinit;
                     deinitFuncsText = strjoin(strcat('\t', deinitFuncs, ';'), '\n');
                 end
 
-                res = periphConfig.updateWrapperCode(initFuncsText, simFuncsText, deinitFuncsText);
+                % Записываем функции в файл обёртки
+                res = periphConfig.writeWrapperCode(initFuncsText, simFuncsText, deinitFuncsText);
             end
         end
 
+        function res = writeWrapperCode(initFuncsText, simFuncsText, deinitFuncsText)
+            % Запись пользовательских функций в файл mcu_wrapper.c
             
-        function res = updateWrapperCode(initFuncsText, simFuncsText, deinitFuncsText)
-        % Входные параметры:
-        %   srcText     - текст для записи set code_...
-        %   incText     - текст для записи set includes_...
-        %
-        % Возвращает:
-        %   res - 0 при успехе, 1 при ошибке
-            wrapPath = fullfile('.\MCU_Wrapper', 'mcu_wrapper.c');
+            wrapPath = fullfile(mcuPath.get('wrapperPath'), 'mcu_wrapper.c');
             res = 1;
             try
+                % Читаем текущее содержимое файла
                 code = fileread(wrapPath);
                 code = regexprep(code, '\r\n?', '\n');
                 
-                % Записываем строки initFuncsText и simFuncsText
+                % Вставляем функции в соответствующие секции
                 code = editCode.insertSection(code, '// PERIPH INIT', initFuncsText);
                 code = editCode.insertSection(code, '// PERIPH SIM', simFuncsText);
                 code = editCode.insertSection(code, '// PERIPH DEINIT', deinitFuncsText);
                 
-                fid = fopen(wrapPath, 'w', 'n', 'UTF-8');
+                % Записываем обновленный файл
+                fid = fopen(wrapPath, 'w', 'n');
                 if fid == -1
                     error('Не удалось открыть файл для записи');
                 end
@@ -312,76 +553,74 @@ classdef periphConfig
             end
         end
         
+        function addConfig(mask, containerName, periphName, defPrompt, def, rowCountMap, rowWidth)
+            % Добавление одного параметра конфигурации в маску
+            % mask - объект маски
+            % containerName - имя контейнера
+            % periphName - имя периферийного модуля
+            % defPrompt - имя параметра
+            % def - структура с описанием параметра
+            % rowCountMap - карта для отслеживания строк
+            % rowWidth - ширина строки
             
-
-        function res = updateRunMexBat(srcText, incText)
-        % Входные параметры:
-        %   srcText     - текст для записи set code_...
-        %   incText     - текст для записи set includes_...
-        %
-        % Возвращает:
-        %   res - 0 при успехе, 1 при ошибке
-            periphBat = [srcText '\n\n' incText];
-            batPath = fullfile('.\MCU_Wrapper', 'run_mex.bat');
-            res = 1;
-            try
-                code = fileread(batPath);
-                code = regexprep(code, '\r\n?', '\n');
-                
-                % Записываем строки srcText и incText с переносами строк
-                code = editCode.insertSection(code, ':: PERIPH BAT', periphBat);
-                
-                fid = fopen(batPath, 'w', 'n', 'UTF-8');
-                if fid == -1
-                    error('Не удалось открыть файл для записи');
-                end
-                fwrite(fid, code);
-                fclose(fid);
-                res = 1;
-            catch ME
-                mcuMask.disp(0, '\nОшибка: неудачная запись в файл при записи файла: %s', ME.message);
+            % Инициализация счетчика строк для этого модуля
+            if ~isKey(rowCountMap, periphName)
+                rowCountMap(periphName) = 0;
             end
+            rowCount = rowCountMap(periphName) + 1;
+
+            % Определяем начинать ли новую строку
+            if ~isfield(def, 'NewRow')
+                def.NewRow = mod(rowCount - 1, rowWidth) == 0;
+            elseif def.NewRow == true
+                rowCount = 1;
             end
+            rowCountMap(periphName) = rowCount;
 
-
-
-        function addDefineConfig(mask, containerName, periphName, defPrompt, def)
-            % mask           — объект маски Simulink.Mask.get(blockPath)
-            % containerName  — имя контейнера, в который добавляем параметр (например, 'configTabAll')
-            % periphName     — имя вкладки / контейнера для текущего периферийного блока (например, 'ADC')
-            % defPrompt      — имя параметра в Defines (например, 'shift_enable')
-            % def            — структура с описанием параметра (Prompt, Def, Type, Default, NewRow и т.п.)
-        
-            % Найдем контейнер с таким именем
+            % Получаем контейнер
             container = mask.getDialogControl(containerName);
             if isempty(container)
                 error('Контейнер "%s" не найден в маске.', containerName);
             end
         
-            % Проверим, есть ли вкладка с именем periphName, если нет — создадим
+            % Создаем вкладку если её нет
             tabCtrl = mask.getDialogControl(periphName);
             if isempty(tabCtrl)
                 tabCtrl = container.addDialogControl('tab', periphName);
                 tabCtrl.Prompt = [periphName ' Config'];
             end
         
-            % Определяем тип параметра (checkbox или edit)
+            % Определяем тип параметра
             switch lower(def.Type)
                 case 'checkbox'
                     paramType = 'checkbox';
                 case 'edit'
                     paramType = 'edit';
+                case 'popup'
+                    paramType = 'popup';
                 otherwise
-                    % Игнорируем остальные типы
-                    return;
+                    return;  % Пропускаем неизвестные типы
             end
         
+            % Создаем валидное имя параметра
             paramName = matlab.lang.makeValidName(defPrompt);
         
-            % Преобразуем значение Default в строку для Value
+            % Устанавливаем значение по умолчанию
+            if strcmp(paramType, 'popup')
+                if isfield(def, 'Def') && iscell(def.Def) && ~isempty(def.Def)
+                    choices = def.Def;
+                    valStr = '';
+                elseif isfield(def, 'Options')
+                    choices = def.Def;
+                    valStr = '';
+                else
+                    warning('Popout параметр "%s" не содержит допустимого списка в Def.', defPrompt);
+                    return;
+                end
+            else
                 val = def.Default;
                 if islogical(val)
-                valStr = mcuMask.ternary(val, 'on', 'off');
+                    valStr = periphConfig.ternary(val, 'on', 'off');
                 elseif isnumeric(val)
                     valStr = num2str(val);
                 elseif ischar(val)
@@ -389,8 +628,17 @@ classdef periphConfig
                 else
                     error('Unsupported default value type for %s.%s', periphName, defPrompt);
                 end
+            end
         
             % Добавляем параметр в маску
+            if strcmp(paramType, 'popup')
+                param = mask.addParameter( ...
+                    'Type', paramType, ...
+                    'Prompt', def.Prompt, ...
+                    'Name', paramName, ...
+                    'Container', periphName ...
+                );
+            else
                 param = mask.addParameter( ...
                     'Type', paramType, ...
                     'Prompt', def.Prompt, ...
@@ -398,8 +646,8 @@ classdef periphConfig
                     'Value', valStr, ...
                     'Container', periphName ...
                 );
+            end
         
-            param.Alias = def.Def;
             param.Evaluate = 'off';
         
             if def.NewRow
@@ -407,8 +655,76 @@ classdef periphConfig
             else
                 param.DialogControl.Row = 'current';
             end
+
+            if isfield(def, 'Def')
+                if strcmp(paramType, 'popup')
+                    if iscell(def.Def)
+                        param.TypeOptions = def.Def;
+                    elseif isfield(def, 'Options')
+                        param.Alias = def.Def;
+                        param.TypeOptions = def.Options;
+                    end
+                else
+                    param.Alias = def.Def;
+                end
             end
 
+            callback = sprintf('try periphConfig.periphParamCallback("%s"); catch end', paramName);
+            param.Callback = callback;
+        end
 
+        %% ELEMENTARY FUNCTIONS - базовые вспомогательные функции
+        
+        function clear_single_periph_code_param(mask, periph)
+            % Очистка кода одного модуля периферии
+            
+            paramNames = {
+                ['Hidden_' char(periph) '_Sources'],
+                ['Hidden_' char(periph) '_Includes']
+            };
+        
+            for i = 1:numel(paramNames)
+                paramName = paramNames{i};
+                try
+                    param = mask.getParameter(paramName);
+                    param.Value = '';
+                catch
+                    % Параметр не существует - игнорируем
+                end
+            end
+        end
+        
+        function store_single_periph_code(mask, periph, code)
+            % Сохранение кода одного модуля периферии в скрытые параметры
+            
+            if isfield(code, 'Sources')
+                paramName = ['Hidden_' char(periph) '_Sources'];
+                try
+                    param = mask.getParameter(paramName);
+                    param.Value = configJs.convert_code_value(code.Sources);
+                catch
+                    mcuMask.disp(0, ['Параметр ' paramName ' не найден']);
+                end
+            end
+        
+            if isfield(code, 'Includes')
+                paramName = ['Hidden_' char(periph) '_Includes'];
+                try
+                    param = mask.getParameter(paramName);
+                    param.Value = configJs.convert_code_value(code.Includes);
+                catch
+                    mcuMask.disp(0, ['Параметр ' paramName ' не найден']);
+                end
+            end
+        end
+
+        function res = ternary(cond, valTrue, valFalse)
+            % Вспомогательная функция - тернарный оператор
+            if cond
+                res = valTrue;
+            else
+                res = valFalse;
+            end
+        end
     end
 end

McuLib/templates/MCU_Wrapper/MCU.c

@@ -115,7 +115,7 @@ static void mdlInitializeSizes(SimStruct* S)
 	for (int i = 0; i < IN_PORT_NUMB; i++)
 	{
 		ssSetInputPortWidth(S, i, inLengths[i]);
-		ssSetInputPortDirectFeedThrough(S, i, 0); // или 1, если нужно
+		ssSetInputPortDirectFeedThrough(S, i, 0);
 		ssSetInputPortRequiredContiguous(S, i, 1);
 	}
 

McuLib/templates/MCU_Wrapper/mcu_wrapper.c

@@ -212,13 +212,13 @@ void SIM_writeOutputs(SimStruct* S)
     int global_index;
 
     //-------------WRITTING OUTPUT--------------
-    for (int j = 0; j < OUT_PORT_NUMB; j++)
+    for (int arr_ind = 0; arr_ind < OUT_PORT_NUMB; arr_ind++)
     {
-        Output = ssGetOutputPortRealSignal(S, j);
-        for (int i = 0; i < outLengths[i]; i++)
+        Output = ssGetOutputPortRealSignal(S, arr_ind);
+        for (int val_ind = 0; val_ind < outLengths[arr_ind]; val_ind++)
         {
-            global_index = XD_OUTPUT_START + outOffsets[j] + i;
-            Output[i] = Out_Buff[global_index];
+            global_index = XD_OUTPUT_START + outOffsets[arr_ind] + val_ind;
+            Output[val_ind] = Out_Buff[global_index];
             Out_Buff[global_index] = 0;
         }
     }
@@ -236,13 +236,13 @@ void SIM_readInputs(SimStruct* S)
     int global_index;
 
     //-------------READING INPUTS---------------
-    for (int j = 0; j < IN_PORT_NUMB; j++)
+    for (int arr_ind = 0; arr_ind < IN_PORT_NUMB; arr_ind++)
     {
-        Input = ssGetInputPortRealSignal(S, j);
-        for (int i = 0; i < inLengths[j]; i++)
+        Input = ssGetInputPortRealSignal(S, arr_ind);
+        for (int val_ind = 0; val_ind < inLengths[arr_ind]; val_ind++)
         {
-            global_index = XD_INPUT_START + inOffsets[j] + i;
-            In_Buff[global_index] = Input[i];
+            global_index = XD_INPUT_START + inOffsets[arr_ind] + val_ind;
+            In_Buff[global_index] = Input[val_ind];
         }
     }
     //------------------------------------------

McuLib/templates/MCU_Wrapper/run_mex.bat

@@ -11,11 +11,12 @@
 :: %4 — режим компиляции (debug/release)
 
 :: Сохраняем как переменные
-set includes_USER=%~1
-set code_USER=%~2
-set defines_USER=%~3
-set defines_CONFIG=%~4
-set compil_mode=%~5
+set filename=%~1
+set includes_USER=%~2
+set code_USER=%~3
+set defines_USER=%~4
+set defines_CONFIG=%~5
+set compil_mode=%~6
 
 :: Заменяем __EQ__ на =
 set defines_USER=%defines_USER:__EQ__==%
@@ -29,15 +30,17 @@ set defines_WRAPPER=-D"MATLAB"^ -D"__sizeof_ptr=8"
 
 :: -------------------------WRAPPER PATHS AND CODE---------------------------
 :: оболочка, которая будет моделировать работу МК в симулинке
-set includes_WRAPPER=-I"."^
- -I".\MCU_Wrapper"^
- -I".\app_wrapper"
+:: WRAPPER BAT START
+
+:: WRAPPER BAT END
+
+:: APP WRAPPER BAT START
+
+:: APP WRAPPER BAT END
+
+set includes_WRAPPER= %includes_WRAPPER% %includes_APP_WRAPPER%
+set code_WRAPPER= %code_WRAPPER% %code_APP_WRAPPER%
 
-set code_WRAPPER= .\MCU_Wrapper\MCU.c^
- .\MCU_Wrapper\mcu_wrapper.c^
- .\app_wrapper\app_init.c^
- .\app_wrapper\app_io.c^
- .\app_wrapper\app_wrapper.c
 
 :: PERIPH BAT START
 
@@ -51,15 +54,15 @@ set includes= %includes_WRAPPER% %includes_PERIPH% %includes_USER%
 set codes= %code_WRAPPER% %code_PERIPH% %code_USER%
 set defines= %defines_WRAPPER% %defines_CONFIG% %defines_USER%
 :: -------OUTPUT FOLDER--------
-set output= -outdir "."
+set output= -outdir "." -output %filename%
 
 :: если нужен дебаг, до запускаем run_mex с припиской debug
-IF [%1]==[debug] (set debug= -g)
+IF %compil_mode%==debug (set debug= -g)
 ::-------------------------------------------------------------------------
 
 
 ::------START COMPILING-------    
-if "%6"=="echo_enable" (
+if "%7"=="echo_enable" (
     echo Compiling...
 
     echo ===========================

McuLib/templates/app_wrapper/app_configs.h

@@ -1,7 +1,7 @@
 /**
 **************************************************************************
 * @file app_config.h
-* @brief Заголовочный файл для пользовательских конфигураций.
+* @brief Заголовочный файл для пользовательских конфигураций.
 **************************************************************************/
 #ifndef _APP_CONFIG
 #define _APP_CONFIG

mcuwrapper.prj

@@ -1,19 +1,19 @@
 <deployment-project plugin="plugin.toolbox" plugin-version="1.0">
-  <configuration file="E:\.WORK\MATLAB\matlab_23550\McuLib\mcuwrapper.prj" location="E:\.WORK\MATLAB\matlab_23550\McuLib" name="mcuwrapper" target="target.toolbox" target-name="Package Toolbox">
-    <param.appname>mcuwrapper</param.appname>
+  <configuration build-checksum="1391118035" file="F:\Work\Projects\MATLAB\mcu_matlab_lib\mcuwrapper.prj" location="F:\Work\Projects\MATLAB\mcu_matlab_lib" name="mcuwrapper" target="target.toolbox" target-name="Package Toolbox">
+    <param.appname>MCU Wrapper</param.appname>
     <param.authnamewatermark>Razvalyaev</param.authnamewatermark>
     <param.email>wot890089@mail.ru</param.email>
     <param.company>NIO-12</param.company>
     <param.summary>Library for run MCU program in Simulink</param.summary>
     <param.description />
     <param.screenshot />
-    <param.version>1.0</param.version>
-    <param.output>${PROJECT_ROOT}\mcuwrapper.mltbx</param.output>
+    <param.version>1.04</param.version>
+    <param.output>${PROJECT_ROOT}\MCU Wrapper.mltbx</param.output>
     <param.products.name />
     <param.products.id />
     <param.products.version />
     <param.platforms />
-    <param.guid>e7dd2564-e462-4878-b445-45763482263f</param.guid>
+    <param.guid>bcf7498f-65f2-487f-b762-d3e88d9a4ebe</param.guid>
     <param.exclude.filters />
     <param.exclude.pcodedmfiles>true</param.exclude.pcodedmfiles>
     <param.examples />
@@ -27,7 +27,7 @@
     <param.exported.on.package>false</param.exported.on.package>
     <param.required.addons>
       <requiredaddons>
-        <requiredAddOn earliest="earliest" fromRepository="true" id="e5534541-4a80-11e4-9553-005056977bd0" include="true" latest="latest">findjobj - find java handles of Matlab graphic objects</requiredAddOn>
+        <requiredAddOn earliest="earliest" fromRepository="true" id="e5534541-4a80-11e4-9553-005056977bd0" include="false" latest="latest">findjobj - find java handles of Matlab graphic objects</requiredAddOn>
       </requiredaddons>
     </param.required.addons>
     <param.matlab.project.id />
@@ -48,7 +48,6 @@
     <unset>
       <param.description />
       <param.screenshot />
-      <param.version />
       <param.output />
       <param.products.name />
       <param.products.id />
@@ -82,27 +81,52 @@
       <param.additional.sw.linux.url />
     </unset>
     <fileset.rootdir>
-      <file>${PROJECT_ROOT}</file>
+      <file>${PROJECT_ROOT}\McuLib</file>
     </fileset.rootdir>
     <fileset.rootfiles>
-      <file>${PROJECT_ROOT}\install_my_library.m</file>
-      <file>${PROJECT_ROOT}\lib</file>
-      <file>${PROJECT_ROOT}\m</file>
-      <file>${PROJECT_ROOT}\sl_customization.m</file>
-      <file>${PROJECT_ROOT}\slblocks.m</file>
-      <file>${PROJECT_ROOT}\startup.m</file>
-      <file>${PROJECT_ROOT}\templates</file>
+      <file>${PROJECT_ROOT}\McuLib\install_my_library.m</file>
+      <file>${PROJECT_ROOT}\McuLib\lib</file>
+      <file>${PROJECT_ROOT}\McuLib\m</file>
+      <file>${PROJECT_ROOT}\McuLib\sl_customization.m</file>
+      <file>${PROJECT_ROOT}\McuLib\slblocks.m</file>
+      <file>${PROJECT_ROOT}\McuLib\startup.m</file>
+      <file>${PROJECT_ROOT}\McuLib\templates</file>
     </fileset.rootfiles>
     <fileset.depfun.included />
     <fileset.depfun.excluded />
     <fileset.package />
     <build-deliverables>
-      <file location="${PROJECT_ROOT}" name="mcuwrapper.mltbx" optional="false">E:\.WORK\MATLAB\matlab_23550\McuLib\mcuwrapper.mltbx</file>
+      <file location="${PROJECT_ROOT}" name="MCU Wrapper.mltbx" optional="false">F:\Work\Projects\MATLAB\mcu_matlab_lib\MCU Wrapper.mltbx</file>
     </build-deliverables>
     <workflow />
     <matlab>
-      <root>C:\Program Files\MyProgs\MATLAB\R2023a</root>
-      <toolboxes />
+      <root>C:\Program Files\MATLAB\R2021b</root>
+      <toolboxes>
+        <toolbox name="matlabcoder" />
+        <toolbox name="embeddedcoder" />
+        <toolbox name="gpucoder" />
+        <toolbox name="fixedpoint" />
+      </toolboxes>
+      <toolbox>
+        <matlabcoder>
+          <enabled>true</enabled>
+        </matlabcoder>
+      </toolbox>
+      <toolbox>
+        <embeddedcoder>
+          <enabled>true</enabled>
+        </embeddedcoder>
+      </toolbox>
+      <toolbox>
+        <gpucoder>
+          <enabled>true</enabled>
+        </gpucoder>
+      </toolbox>
+      <toolbox>
+        <fixedpoint>
+          <enabled>true</enabled>
+        </fixedpoint>
+      </toolbox>
     </matlab>
     <platform>
       <unix>false</unix>