pre-release 1.03

McuLib/m/appWrap.m

@@ -1,144 +1,100 @@
 classdef appWrap
-    % Класс для редактирования кода обёртки МК прямо внутри MATLAB/Simulink
-    % Позволяет работать с кодом микроконтроллера без переключения между IDE
 
     methods(Static)
-        
         function appWrapperFunc()
-            % Загружает код обёртки из файлов в интерфейс MATLAB для редактирования
+            block = gcb;
-            % Автоматически вызывается при выборе типа кода в маске блока
+            % Получаем имя функции и путь к файлам
-            
+            [filename, section, tool, example]= appWrap.getAppWrapperUserFile(block);
-            block = gcb;  % Получаем текущий блок Simulink для редактирования
-            
-            % Определяем какой файл и секцию нужно редактировать
-            [filename, section, tool, example] = appWrap.getAppWrapperUserFile(block);
-            
-            % Показываем подсказку по выбранному типу кода прямо в MATLAB
             mcuMask.tool(tool, example);
 
-            % Очищаем поле редактирования перед загрузкой нового кода
+            % Загружаем содержимое файла
             set_param(block, 'appWrapperCode', '');
-            
+			try
-            % Загружаем код из файла в интерфейс MATLAB
+				code = fileread(filename);
-            try
+				code = regexprep(code, '\r\n?', '\n');  % нормализуем окончания строк
-                % Читаем исходный код из файла
+
-                code = fileread(filename);
+				includesText = editCode.extractSection(code, section);
-                code = regexprep(code, '\r\n?', '\n');  % унифицируем переводы строк для MATLAB
+				set_param(block, 'appWrapperCode', includesText);
-                
+			catch
-                % Вырезаем только нужную секцию для редактирования
+			end
-                includesText = editCode.extractSection(code, section);
+            % % Поиск тела обычной функции
-                
+            % expr = sprintf('void %s()', sel);
-                % Загружаем код в текстовое поле маски для редактирования
+            % funcBody = editCode.extractSection(code, expr);
-                set_param(block, 'appWrapperCode', includesText);
+            % set_param(block, 'wrapperCode', funcBody);
-            catch
-                % Если файл не найден или ошибка чтения - оставляем поле пустым
-                % Пользователь сможет написать код с нуля прямо в MATLAB
-            end
         end
             
         function saveAppWrapperCode()
-            % Сохраняет отредактированный код из MATLAB обратно в файлы обёртки
+            block = gcb;
-            % Вызывается при нажатии кнопки "Сохранить" в интерфейсе
-            
-            block = gcb;  % Текущий редактируемый блок
 
-            % Определяем куда сохранять based на выборе пользователя в MATLAB
+            % Получаем имя функции и путь к файлам
             [filename, section] = appWrap.getAppWrapperUserFile(block);
-            
-            % Проверяем что файл существует перед сохранением
             if ~isfile(filename)
-                errordlg(['Файл не найден: ', filename], 'Ошибка сохранения в MATLAB');
+                errordlg(['Файл не найден: ', filename]);
                 return;
             end
             
-            % Получаем выбранный тип кода и путь к файлам
             sel = get_param(block, 'appWrapperFunc');
             basePath = get_param(block, 'appWrapperPath');
-            
             if isempty(basePath)
-                errordlg('Не указан путь к файлам обёртки.', 'Ошибка в MATLAB');
+                errordlg('Не указан путь к файлам обёртки (wrapperPath).');
                 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);
-            
+            % else
-            % Сохраняем изменения прямо из MATLAB без внешних редакторов
+            %     % Обновляем тело функции
-            fid = fopen(filename, 'w', 'n');
+            %     expr = sprintf('void %s()', sel);
+            %     code = editCode.insertSection(code, expr, newBody);
+            % end
+            fid = fopen(filename, 'w', 'n', 'UTF-8');
             if fid == -1
-                errordlg('Не удалось сохранить файл из MATLAB', 'Ошибка записи');
+                errordlg('Не удалось открыть файл для записи');
                 return;
             end
-            
-            % Записываем обновленный код
             fwrite(fid, code);
             fclose(fid);
-            
+            mcuMask.disp(1, ['Обновлено: ' sel]);
-            % Подтверждаем успешное сохранение в интерфейсе 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('Не удалось открыть файл во внешнем редакторе');
+                    errordlg('Не удалось открыть окно выбора приложения.');
                 end
             else
-                errordlg('Файл не найден для открытия');
+                errordlg('Файл не найден');
             end            
         end
 
 
-        %% SPECIFIC TOOLS
+%% 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('Не указан путь к файлам обёртки.');
+                errordlg('Не указан путь к файлам обёртки (wrapperPath).');
                 return;
             end
-            
+            % Формируем путь к файлу в зависимости от типа запроса
-            % В зависимости от выбора в MATLAB - определяем что редактировать:
             if strcmp(sel, 'Includes')
-                % Редактирование подключения заголовочных файлов
                 filename = fullfile(basePath, 'app_includes.h');
                 section = '// INCLUDES';
                 tool = 'Инклюды для доступа к коду МК в коде оболочке';
-                example =  '#include "main.h"';  % Пример для подсказки в MATLAB
+                example =  '#include "main.h"';
-                
             elseif strcmp(sel, 'Dummy')
-                % Редактирование заглушек для симуляции
                 filename = fullfile(basePath, 'app_wrapper.c');
                 section = '// DUMMY';
                 tool = 'Заглушки для различных функций и переменных';
@@ -148,25 +104,19 @@ classdef appWrap
                     '    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 ...
@@ -177,9 +127,7 @@ classdef appWrap
                     '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 ...
@@ -190,20 +138,17 @@ classdef appWrap
                     '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,124 +1,103 @@
 classdef asynchManage < handle
-    % Менеджер асинхронных операций для работы с моделью Simulink
-    % Решает проблемы блокировки модели при одновременном доступе из GUI
-    % Использует таймеры для отложенного выполнения операций с моделью
-
     properties (Access = private)
-        modelName     % Имя модели Simulink для управления
+        modelName     % Имя модели
-        maskBlockPath % Полный путь к блоку с маской (если нужен доступ к GUI)
+        maskBlockPath % Полный путь к блоку с маской
-        timerSave     % Таймер для операции сохранения модели
+        timerSave
-        timerUpdate   % Таймер для операции обновления модели  
+        timerUpdate
-        timerConfigUpdate % Таймер для обновления конфигурации
+        timerConfigUpdate
     end
 
     methods
         function obj = asynchManage(modelName, maskBlockPath)
-            % Конструктор - создает менеджер для асинхронных операций
+            % Конструктор принимает имя модели и путь к блоку с маской
-            % modelName - имя модели Simulink для управления
-            % maskBlockPath - путь к блоку с маской (опционально, для GUI)
             obj.modelName = modelName;
             if nargin < 2
-                obj.maskBlockPath = ''; % Если не передали - работаем без GUI
+                obj.maskBlockPath = ''; % если не передали, оставляем пустым
             else
                 obj.maskBlockPath = maskBlockPath;
             end
         end
 
         function saveAndUpdateModel(obj)
-            % Асинхронное сохранение и обновление модели
-            % Использует таймер чтобы избежать конфликтов доступа к модели
             obj.timerSave = timer(...
-                'StartDelay', 0.01, ...      % Короткая задержка чтобы освободить модель
+                'StartDelay', 0.01, ...
-                'ExecutionMode', 'singleShot', ... % Однократное выполнение
+                'ExecutionMode', 'singleShot', ...
-                'TimerFcn', @(~,~) obj.saveCallback()); % Колбэк сохранения
+                '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()); % Колбэк обновления GUI
+                'TimerFcn', @(~,~) obj.GUIconfigCallback());
             start(obj.timerConfigUpdate);
         end
     end
 
     methods (Access = private)
         function saveCallback(obj)
-            % Колбэк для сохранения модели - вызывается через таймер
             try
-                % Закрываем маску чтобы разблокировать модель для сохранения
                 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); % Открываем маску снова
+                    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)
-            % Колбэк для обновления GUI из конфигурации
+
             try
-                % Закрываем маску и выполняем настройку (mexing)
                 mcuMask.close(obj.maskBlockPath);
-                mexing(0); % Функция настройки/компиляции
+                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
+end

McuLib/m/compiler.m

@@ -1,160 +1,138 @@
 classdef compiler
-    % Класс для компиляции бинарника S-Function в MATLAB
-    % Управляет процессом сборки mex-файлов для Simulink
     methods(Static)
 
         function compile()
-            % Основная функция компиляции S-Function
-            % Добавляет путь к файлам обёртки и запускает компиляцию
             addpath(mcuPath.get('wrapperPath'));
-            mexing(1);  % 1 - флаг компиляции
+            mexing(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 = { '.\' };
+            includes = { '.\'
+            };
             wrapperPath = mcuPath.get('wrapperPath');
-            
+            % [wrapperPath, ~, ~] = fileparts(wrapperPath);
-            % Формируем строки для BAT-файла
+            % Формируем строки
             wrapperSrcText = compiler.createSourcesBat('code_WRAPPER', sources, wrapperPath);
             wrapperIncText = compiler.createIncludesBat('includes_WRAPPER', includes, wrapperPath);
             
-            % Обновляем BAT-файл для основной обёртки
+            % Записываем результат
-            res = compiler.updateRunMexBat(wrapperSrcText, wrapperIncText, ':: WRAPPER 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 = { '.\' };
+            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');
+            res = compiler.updateRunMexBat(wrapperSrcText, wrapperIncText, ':: APP WRAPPER BAT'); % Всё прошло успешно
 
-            % Обновляем BAT-файл для периферии
             periphConfig.updatePeriphRunMexBat();
         end
             
+
         function res = updateRunMexBat(srcText, incText, Section)
-        % Обновляет секцию в BAT-файле для компиляции mex
         % Входные параметры:
-        %   srcText     - текст для записи set code_... (исходные файлы)
+        %   srcText     - текст для записи set code_...
-        %   incText     - текст для записи set includes_... (пути включения)
+        %   incText     - текст для записи set includes_...
-        %   Section     - секция в BAT-файле для обновления
         %
         % Возвращает:
-        %   res - 1 при успехе, 0 при ошибке
+        %   res - 0 при успехе, 1 при ошибке
-            % Объединяем исходные файлы и пути включения
             periphBat = [srcText '\n\n' incText];
             batPath = fullfile(mcuPath.get('wrapperPath'), 'run_mex.bat');
-            res = 1;  % По умолчанию - ошибка
+            res = 1;
-            
             try
-                % Читаем текущее содержимое BAT-файла
                 code = fileread(batPath);
-                code = regexprep(code, '\r\n?', '\n');  % Нормализуем переводы строк
+                code = regexprep(code, '\r\n?', '\n');
                 
-                % Вставляем новую секцию в BAT-файл
+                % Записываем строки srcText и incText с переносами строк
                 code = editCode.insertSection(code, Section, periphBat);
                 
-                % Записываем обновленный BAT-файл
+                fid = fopen(batPath, 'w', 'n', 'UTF-8');
-                fid = fopen(batPath, 'w', 'n');
                 if fid == -1
                     error('Не удалось открыть файл для записи');
                 end
                 fwrite(fid, code);
                 fclose(fid);
-                res = 1;  % Успех
+                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, '\', '\\');  % Экранирование слешей
+                    srcList{end+1} = strrep(fullPath, '\', '\\');
                 end
             end
         
-            % Формируем srcText с переносами строк и символом продолжения ^
+            % Формируем srcText с переносами строк и ^
             srcText = '';
             for i = 1:numel(srcList)
                 if i < numel(srcList)
-                    srcText = [srcText srcList{i} '^' newline ' '];  % ^ для продолжения строки в BAT
+                    srcText = [srcText srcList{i} '^' newline ' '];
                 else
-                    srcText = [srcText srcList{i}];  % Последний файл без продолжения
+                    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 для компилятора
+                    incList{end+1} = ['-I"' strrep(fullPath, '\', '\\') '"'];
                 end
             end
         
-            % Формируем incText с переносами строк и символом продолжения ^
+            % Формируем incText с переносами строк и ^
             incText = '';
             for i = 1:numel(incList)
                 if i == 1 && numel(incList) ~= 1
-                    incText = [incText incList{i} '^' newline];  % Первый элемент с продолжением
+                    incText = [incText incList{i} '^' newline];
                 elseif i < numel(incList)
-                    incText = [incText ' ' incList{i} '^' newline];  % Средние элементы с продолжением
+                    incText = [incText ' ' incList{i} '^' newline];
                 else
-                    incText = [incText ' ' incList{i}];  % Последний элемент без продолжения
+                    incText = [incText ' ' incList{i}];
                 end
             end
         
-            % Добавляем префикс переменной BAT
+            % Добавляем префикс
             incText = ['set ' prefix_name '=' incText];
         end
         

McuLib/m/configJs.m

@@ -1,61 +1,48 @@
 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 в этой периферии
+                % Проверяем есть ли 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);  % Создаем валидное имя параметра
+                    paramName = matlab.lang.makeValidName(defPrompt);
         
-                    % Проверяем существует ли параметр с таким именем в маске
+                    % Проверка, существует ли параметр с таким именем
                     if ismember(paramName, paramNames)
                         param = mask.getParameter(paramName);
-                        valStr = param.Value;  % Значение как строка из маски
+                        valStr = param.Value;
         
-                        % Проверяем существует ли элемент defPrompt в структуре defines
+                        % Проверяем, существует ли элемент 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
@@ -66,18 +53,12 @@ classdef configJs
         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
@@ -86,26 +67,18 @@ classdef configJs
         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);
-            
+            fid = fopen(config_path, 'w', 'n', 'UTF-8');
-            % Записываем JSON в файл
-            fid = fopen(config_path, 'w', 'n');
             if fid == -1
                 error('Не удалось открыть файл periph_config.json для записи.');
             end
@@ -113,65 +86,58 @@ classdef configJs
             fclose(fid);
         end
 
+
+
         function value = get_field(configStruct, targetConfig)
-            % Рекурсивно ищет поле в структуре конфигурации
+        % получить targetConfig структуру из конфига (для глубоко вложенных)
-            % configStruct - структура для поиска
-            % targetConfig - имя целевого поля
-            % Возвращает значение поля или пустой массив если не найдено
-            
             value = [];
             fields = fieldnames(configStruct);
         
             for i = 1:numel(fields)
                 key = fields{i};
                 if strcmp(key, targetConfig)
-                    % Нашли прямое совпадение
                     value = configStruct.(key);
-                    return;
+                    return;  % нашли и возвращаем
                 elseif isstruct(configStruct.(key))
-                    % Рекурсивно ищем во вложенной структуре
                     value = configJs.get_field(configStruct.(key), targetConfig);
                     if ~isempty(value)
-                        return; % Нашли во вложенной структуре
+                        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};  % Берём последний элемент
+            short = parts{end};
         end
 
         function value = convert_code_value(codeField)
-            % Преобразует значение поля Options в строку для отображения
+            % Преобразует значение поля Options в строку
-            % Обрабатывает разные типы данных: char, string, cell array
-            
             if ischar(codeField)
                 value = codeField;
             elseif isstring(codeField)
                 value = char(codeField);
             elseif iscell(codeField)
-                % Объединяем ячейки в одну строку с переносами
                 value = strjoin(codeField, newline);
             else
-                % Для неподдерживаемых типов возвращаем пустую строку
+                % warning('Неподдерживаемый тип данных: сохранено как пустая строка');
                 value = '';
             end
         end
+
+
     end
 
+
+
     methods(Static, Access=private)
-        % Приватные методы могут быть добавлены здесь при необходимости
+        
     end
-end
+end

McuLib/m/customtable.m

@@ -1,182 +1,159 @@
 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);  % Элемент управления таблицей
+            tableControl = mask.getDialogControl(table_name);
-            tableParameter = mask.getParameter(table_name);    % Параметр с данными таблицы
+            tableParameter = mask.getParameter(table_name);
             nCols = tableControl.getNumberOfColumns;
-            
+            % инициализация колонок если они пустые
-            % Инициализация колонок если они пустые (после removeParameter)
+            % такое случается при removeParameter
             if isempty(tableControl.Columns) || (nCols > 1)
-                % Удаляем все существующие колонки
+                    for i = 1:nCols
-                for i = 1:nCols
+                        tableControl.removeColumn(1);
-                    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
-            % table_names - cell-массив с именами таблиц
+            % Возвращает 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)
-            % Восстанавливает таблицы с сохраненными названиями колонок
+            % Восстанавливает первый столбец в каждой таблице из массива имен
-            % table_names - имена таблиц для восстановления
+            % Использует массив column_titles для установки имени столбца
-            % 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);  % Получаем строковое представление
+            TableStr = get_param(block, tableName);
-            out = customtable.parse__(TableStr);     % Парсим во внутреннем методе
+            out = customtable.parse__(TableStr);
         end
 
         function collect(tableName, cellArray)
-            % Сохраняет cell-массив обратно в табличный параметр
-            % tableName - имя параметра для сохранения
-            % cellArray - cell-массив с данными таблицы
-            
             block = gcb;
-            newTableStr = customtable.collect__(cellArray);  % Конвертируем в строку
+            newTableStr = customtable.collect__(cellArray);
-            set_param(block, tableName, newTableStr);        % Сохраняем в параметр
+            % Записываем обратно в параметр маски
+            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,71 +1,60 @@
 classdef editCode
-    % Класс для редактирования кода C/C++ в текстовых файлах
-    % Обеспечивает извлечение и вставку кода в секции и функции
 
     methods(Static)
         
         function newCode = insertSection(code, sectionName, newText)
-            % Вставка или замена содержимого секции или тела функции
+            % insertSection – вставка или замена содержимого секции или тела функции
-            % 
             % Аргументы:
-            %   code        - исходный текст кода как строка
+            %   code        – исходный текст (строка)
-            %   sectionName - имя секции (например, 'MY_SECTION') или 
+            %   sectionName – имя секции (например, 'MY_SECTION') или заголовок функции (например, 'void myFunc(...)')
-            %                 заголовок функции (например, 'void myFunc(...)')
+            %   newText     – новый текст, который будет вставлен внутрь секции или функции
-            %   newText     - новый текст для вставки внутрь секции или функции
             %
             % Возвращает:
-            %   newCode     - обновлённый текст с подставленным содержимым
+            %   newCode     – обновлённый текст с подставленным содержимым
             %
             % Особенности:
-            %   - Если sectionName начинается с 'void ', считается что это функция,
+            %   - Если sectionName начинается с 'void ', считается что это функция, и вставка происходит внутрь её тела.
-            %     и вставка происходит внутрь её тела
+            %   - В остальных случаях ищется секция между маркерами "<NAME> START" и "<NAME> END", и она заменяется на newText.
-            %   - Для секций ищется блок между маркерами "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, ...
@@ -74,113 +63,111 @@ 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
         
-            % Формируем новую секцию с переданным текстом
+            % Формируем новую секцию с нужным текстом
+            % newText = strrep(newText, '\', '\\');             % экранируем для корректной вставки
             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        - исходный текст кода как строка
+            %   code        – исходный текст (строка)
-            %   sectionName - имя секции (например, 'MY_SECTION') или
+            %   sectionName – имя секции (например, 'MY_SECTION') или заголовок функции (например, 'void myFunc(...)')
-            %                 заголовок функции (например, 'void myFunc(...)')
             %
             % Возвращает:
-            %   result      - извлечённый текст из секции или тела функции
+            %   result      – извлечённый текст из секции или тела функции
             %
             % Особенности:
-            %   - Для функций извлекает содержимое между { и } с учётом вложенности
+            %   - Если sectionName начинается с 'void ', считается что это функция, и извлекается содержимое её тела.
-            %   - Для секций извлекает текст между маркерами START и END
+            %   - В остальных случаях ищется секция между маркерами "<NAME> START" и "<NAME> 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/installTemplates.m

@@ -1,5 +1,5 @@
 function installTemplates(forceCopy)
-% installTemplates Копирует содержимое папки templates (включая вложенные папки) из библиотеки (McuLib.slx) в текущую папку
+% installTemplates Копирует содержимое папки templates (включая вложенные папки) из уровня выше McuLib.slx в текущую папку
 %
 %   installTemplates(forceCopy)
 %

McuLib/m/mainConfig.m

@@ -1,17 +1,10 @@
 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'};
@@ -29,32 +22,29 @@ classdef mainConfig
                 '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);
+
+            jsonStr = jsonencode(config, 'PrettyPrint', true);  % 'PrettyPrint' для форматирования
+
 
             % Диалог сохранения файла
             [file, path] = uiputfile('*.json', 'Сохранить конфигурацию как', 'WrapperConfig.json');
@@ -65,6 +55,8 @@ classdef mainConfig
         
             filepath = fullfile(path, file);
 
+
+
             % Сохраняем в файл
             fid = fopen(filepath, 'w');
             if fid == -1
@@ -75,10 +67,8 @@ classdef mainConfig
             fclose(fid);
         end
 
+
         function import()
-            % Импортирует конфигурацию маски из JSON файла
-            % Восстанавливает параметры обёртки, портов и приложения
-            
             % Получаем путь к текущему блоку
             blockPath = gcb;
             mask = Simulink.Mask.get(blockPath);
@@ -115,20 +105,19 @@ classdef mainConfig
         
             mcuMask.disp(0, 'Конфигурация успешно импортирована.');
 
-            % Обновляем периферию после импорта
             mcuMask.periphUpdate();
         end
 
     end
 
+
     methods(Static, Access=private)
 
+
         function def = exportParamToConfig(mask, paramName)
-            % Экспортирует один параметр маски в структуру для JSON
+            % mask      — объект Simulink.Mask.get(blockPath)
-            % mask      - объект маски Simulink
+            % paramName — имя параметра (как в mask.Parameters.Name)
-            % paramName - имя параметра для экспорта
+        
-            % Возвращает структуру с описанием параметра
-            
             param = mask.getParameter(paramName);
             if isempty(param)
                 mcuMask.disp(0, 'Параметр "%s" не найден в маске.', paramName);
@@ -138,50 +127,53 @@ classdef mainConfig
         
             def = struct();
 
-            % Сохраняем подпись параметра
+            % Prompt
             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;  % Оставляем строкой если не число
+                        def.Default = val;
                     end
                 case 'customtable'
-                    % Для таблиц парсим содержимое в cell-массив
+                    def.Default = customtable.parse(param.Name); % или можно попытаться распарсить значение позже
-                    def.Default = customtable.parse(param.Name);
                 case 'text'
-                    % Для текстовых полей сохраняем пустую строку
+                    def.Default = ''; % или можно попытаться распарсить значение позже
-                    def.Default = '';
                 otherwise
-                    % Для остальных типов сохраняем как есть
                     def.Default = val;
             end
                 
-            % Сохраняем алиас если есть
+            % Alias, если есть
             if ~isempty(param.Alias)
                 def.Def = param.Alias;
             end
+        
+            % % Row (new/current)
+            % try
+            %     rowSetting = param.DialogControl.Row;
+            %     def.NewRow = strcmp(rowSetting, 'new');
+            % catch
+            %     def.NewRow = false;
+            % end
         end
 
+
         function applyDefToMask(mask, paramName, def)
-            % Применяет параметр из конфигурации к маске
+            % mask      — объект Simulink.Mask.get(blockPath)
-            % mask      - объект маски Simulink
+            % paramName — имя параметра маски
-            % paramName - имя параметра для применения
+            % def       — структура, полученная из extractDefFromMask
-            % def       - структура с данными параметра
+        
-            
+            % Получаем параметр
-            % Получаем параметр из маски
             param = mask.getParameter(paramName);
             if isempty(param)
                 mcuMask.disp(0, 'Параметр "%s" не найден в маске.', paramName);
@@ -193,10 +185,9 @@ classdef mainConfig
                 return;
             end
 
-            % Устанавливаем значение в зависимости от типа параметра
             switch lower(def.Type)
                 case 'checkbox'
-                    % Устанавливаем состояние чекбокса
+                    % Логическое значение true/false
                     if islogical(def.Default)
                         param.Value = mainConfig.ternary(def.Default, 'on', 'off');
                     else
@@ -204,7 +195,7 @@ classdef mainConfig
                     end
         
                 case {'edit', 'spinbox'}
-                    % Устанавливаем значение для текстового поля
+                    % Строка или число
                     if isnumeric(def.Default)
                         param.Value = num2str(def.Default);
                     elseif ischar(def.Default) || isstring(def.Default)
@@ -214,7 +205,7 @@ classdef mainConfig
                     end
         
                 case 'customtable'
-                    % Загружаем данные в таблицу
+                    % Массив строк
                     if iscell(def.Default)
                         customtable.collect(paramName, def.Default);
                     else
@@ -222,7 +213,7 @@ classdef mainConfig
                     end
         
                 case 'text'
-                    % Устанавливаем текстовое значение
+                    % Просто текстовая строка
                     if ischar(def.Default) || isstring(def.Default)
                         param.Value = char(def.Default);
                     else
@@ -230,7 +221,7 @@ classdef mainConfig
                     end
         
                 case 'popup'
-                    % Устанавливаем значение выпадающего списка
+                    % popup — установить значение, если оно есть в списке
                     if ischar(def.Default) && isfield(def, 'Def') && any(strcmp(def.Default, def.Def))
                         param.Value = def.Default;
                     else
@@ -238,7 +229,7 @@ classdef mainConfig
                     end
         
                 otherwise
-                    % Универсальная установка значения
+                    % По умолчанию просто устанавливаем строковое значение
                     if ischar(def.Default) || isstring(def.Default)
                         param.Value = char(def.Default);
                     elseif isnumeric(def.Default)
@@ -248,16 +239,16 @@ classdef mainConfig
                     end
             end
         
-            % Обновляем подпись параметра если есть
+            % Применение Prompt, если нужно
             if isfield(def, 'Prompt')
                 param.Prompt = def.Prompt;
             end
         
-            % Обновляем алиас если есть
+            % Применение Alias, если есть
             if isfield(def, 'Def') && ischar(def.Def)
                 param.Alias = def.Def;
             end
-			
+        
             % % Установка Row, если поддерживается
             % if isfield(def, 'NewRow')
             %     try
@@ -272,9 +263,8 @@ classdef mainConfig
             % end
         end
 
+
         function result = ternary(cond, a, b)
-            % Вспомогательная функция - тернарный оператор
-            % cond - условие, a - значение если true, b - значение если false
             if cond
                 result = a;
             else

McuLib/m/mcuMask.m

@@ -1,173 +1,157 @@
 classdef mcuMask
-    % Главный класс управления маской блока Simulink для микроконтроллера
+%% CALLBACKS
-    % Содержит 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);
-            
-            % Разрешаем самомодификацию маски и отключаем ссылки
 			set_param(blk,"MaskSelfModifiable","on")
             set_param(blk, 'LinkStatus', 'none');
-            
+            % mcuMask.disp(1,'');
-            % Проверяем доступность findjobj для внешней консоли
             try
+                % Проверка наличия findjobj
                 findjobjAvailable = exist('findjobj', 'file') == 2;
             catch
                 findjobjAvailable = false;
             end
-            
+            % Имя checkbox-параметра (укажите точное имя из маски)
-            % Настраиваем параметры внешней консоли в зависимости от доступности findjobj
+            checkboxParamName = 'extConsol';  % пример
-            checkboxParamName = 'extConsol';
+            findjobjLinkName = 'findjobj_link';  % пример
-            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);
             end
-            
+            % запись описания блока
-            % Устанавливаем описание блока
             textDesc = ['Блок для настройки параметров симуляции микроконтроллера. ' newline ...
                 'Позволяет задавать параметры оболочки, приложения МК и периферии'];
 
+            % Получаем объект описания
             toolTextArea = mask.getDialogControl('BlockDesc');
             toolTextArea.Prompt = textDesc;
         end
         
-        %% WRAPPER PARAMS - callback-функции для параметров обёртки
+        %% WRAPPER PARAMS
         function wrapperPath_add(callbackContext)
-            % Добавление пути к файлам обёртки
             mcuPath.addPath('wrapperPath');
         end
 
         function enableThreading(callbackContext)
-            % Включение/выключение многопоточности
             mainWrap.enableThreading();
         end
 
         function enableDeinit(callbackContext)
-            % Включение/выключение деинициализации
             mainWrap.enableDeinit();
         end
 
         function extConsol(callbackContext)
-            % Управление внешней консолью
             mainWrap.extConsol();           
         end
 
-        %% USER WRAPPER CODE - callback-функции для пользовательского кода
+        %% USER WRAPPER CODE
         function appWrapperPath_add(callbackContext)
-            % Добавление пути к файлам обёртки приложения
             mcuPath.addPath('appWrapperPath');
         end
 
         function appWrapperFunc(callbackContext)
-            % Загрузка функции обёртки для редактирования
             appWrap.appWrapperFunc();
         end
             
         function saveAppWrapperCode(callbackContext)
-            % Сохранение отредактированного кода обёртки
             appWrap.saveAppWrapperCode();
         end
 
         function openAppWrapperCode(callbackContext)
-            % Открытие кода обёртки во внешнем редакторе
             appWrap.openAppWrapperCode();
         end
 
-        %% USER CODE - callback-функции для пользовательского кода
+        %% USER CODE
         function srcTable(callbackContext)
-            % Обновление таблицы исходных файлов
             customtable.update('srcTable');
         end
 
         function incTable(callbackContext)
-            % Обновление таблицы заголовочных файлов
             customtable.update('incTable');
         end
 
         function btnAddSrc(callbackContext)
-            % Добавление исходных файлов через диалог выбора
             mcuPath.addSourceFileTable('srcTable', 'Выберите исходные файлы');
         end
 
         function btnAddInc(callbackContext)
-            % Добавление путей включения через диалог выбора
             mcuPath.addPathTable('incTable', 'Выберите папку с заголовочными файлами');
         end
 
-        %% PERIPH CONFIG - callback-функции для конфигурации периферии
+        %% PERIPH CONFIG
         function periphPath_add(callbackContext)
-            % Добавление пути к конфигурационному файлу периферии
             mcuPath.addAnyFile('periphPath');
         end
 
         function periphUpdate(callbackContext)
-            % Обновление конфигурации периферии с асинхронным управлением
+            modelName = bdroot(gcb);  % получить имя верхнего уровня модели
-            modelName = bdroot(gcb);
             blockName = gcb;
-            mgr = asynchManage(modelName, blockName);
+            mgr = asynchManage(modelName, blockName);  % создать объект класса
-            mgr.updateGUIfromConfig();  % Запуск обновления через таймер
+            mgr.updateGUIfromConfig();        % запустить сохранение и обновление
         end
 
-        %% COMPILE - callback-функции для компиляции
+        %% COMPILE
         function compile(callbackContext)
-            % Компиляция S-функции
             compiler.compile();
         end
 
         function setSFuncName(callbackContext)
-            % Установка имени S-функции в исходном коде
             block = gcb;
+            % Получаем параметр имени S-Function из маски блока
             newName = mcuMask.get_name();
     
-            % Путь к файлу MCU.c
+            % Путь к файлу, в котором надо заменить строку
-            cFilePath = fullfile(pwd, mcuPath.get('wrapperPath'), 'MCU.c');
+            cFilePath = fullfile(pwd, mcuPath.get('wrapperPath'), 'MCU.c');  % <-- укажи правильный путь
             
-            % Чтение файла
+            % Считаем файл в память
 			try
 				fileText = fileread(cFilePath);
 			catch
 				return;
 			end
             
-            % Поиск и замена определения имени S-функции
+            % Регулярное выражение для поиска строки с define
+            % Заменим строку вида: #define S_FUNCTION_NAME old_name
             pattern = '#define\s+S_FUNCTION_NAME\s+\w+';
+            
+            % Новая строка
             newLine = ['#define S_FUNCTION_NAME ', newName];
+            
+            % Замена
             updatedText = regexprep(fileText, pattern, newLine);
             
-            % Запись изменений обратно в файл
+            % Записываем обратно в файл
-            fid = fopen(cFilePath, 'w', 'n');
+            fid = fopen(cFilePath, 'w', 'n', 'UTF-8');
             if fid == -1
                 error('Не удалось открыть файл для записи.');
             end
@@ -175,33 +159,39 @@ classdef mcuMask
             fclose(fid);    
         end
 
-        %% LINK TO EXTERNAL CONSOLE - callback для внешней консоли
+        %% LINK TO EXTERNAL CONSOLE
         function findjobj_link(callbackContext)
-            % Открытие ссылки на утилиту findjobj
+            web https://www.mathworks.com/matlabcentral/fileexchange/14317-findjobj-find-java-handles-of-matlab-graphic-objects;
-            web('https://www.mathworks.com/matlabcentral/fileexchange/14317-findjobj-find-java-handles-of-matlab-graphic-objects');
         end
     end
 
-%% GENERAL TOOLS - общие утилиты для работы с маской
+%% GENERAL TOOLS
     methods(Static, Access = public)
 
         function updateModel()
-            % Обновление модели с компиляцией S-функции
             addpath(mcuPath.get('wrapperPath'));
             res = mexing(1);
             if res ~= 0
                 return;
             end
+            
+            % modelName = bdroot(gcb);  % получить имя верхнего уровня модели
+            % blockName = gcb;
+            % mgr = asynchManage(modelName, blockName);  % создать объект класса
+            % mgr.saveAndUpdateModel();        % запустить сохранение и обновление
         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
@@ -211,25 +201,24 @@ classdef mcuMask
         end
 
         function open(blockPath, clear_flag)
-            % Открытие маски блока
             open_system(blockPath, 'mask');
             mcuMask.disp(clear_flag, '');
         end
 
         function name = get_name()
-            % Получение имени S-функции из параметра маски
             block = gcb;
+            % Получаем параметр имени S-Function из маски блока
             name = get_param(block, 'sfuncName');
         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};
             
+            checkbox_state_str = maskValues{inxCheckBox};
             if strcmpi(checkbox_state_str, 'on')
                 checkbox_state = 1;
             else
@@ -237,8 +226,8 @@ classdef mcuMask
             end
         end
 
+
         function children = get_children(ctrl)
-            % Получение дочерних элементов управления маски
             if isprop(ctrl, 'DialogControls')
                 children = ctrl.DialogControls;
             elseif isprop(ctrl, 'Controls')
@@ -251,28 +240,27 @@ 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;
+                    params{end+1} = ctrl.Name; %#ok<AGROW>
                 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);
@@ -283,9 +271,14 @@ classdef mcuMask
             end
         end
 
+        
         function tool(text, example)
-            % Установка текста подсказки и примера в элементы маски
+            % Устанавливает заданный текст в параметр Text Area 'toolText' через объект маски
+            
+            % Получаем ссылку на текущий блок
             block = gcb;
+            
+            % Получаем объект маски
             mask = Simulink.Mask.get(block);
         
             toolTextArea = mask.getDialogControl('toolText');
@@ -295,14 +288,15 @@ 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
 
@@ -310,18 +304,20 @@ classdef mcuMask
             if ~strcmp(out, '') && ~strcmp(out_now, '')
                 set_param(gcb, 'consoleOutput', [out_now newline out]);
             else
-                set_param(gcb, 'consoleOutput', [out_now out]);
+            set_param(gcb, 'consoleOutput', [out_now out]);
-            end
+        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'));
@@ -329,8 +325,8 @@ classdef mcuMask
         end
 
         function v = getMyLibVersion()
-            % Получение версии библиотеки
+            v = 'pre-1.03';
-            v = 'pre-1.04';
         end
+
     end
 end

McuLib/m/mcuPath.m

@@ -1,150 +1,109 @@
 classdef mcuPath
-    % Класс для работы с путями файлов и папок в маске Simulink
-    % Обеспечивает преобразование путей, добавление в таблицы и параметры
-
     methods(Static)
 
-        %% GET PATH FROM PARAM - получение путей из параметров маски
+        %% GET PATH FROM PARAM
         function path = get(paramName)
-            % Получение значения пути из параметра маски
-            % paramName - имя параметра маски содержащего путь
-            % Возвращает строку с путём (абсолютным или относительным)
-            
             blockPath = gcb;
             path = get_param(blockPath, paramName);
         end
 
-        %% ADD PATH TO TABLE - добавление путей в табличные параметры
+        %% ADD PATH TO TABLE
 
         function addSourceFileTable(targetParamName, message)
-            % Добавление исходных файлов в таблицу через диалог выбора
+            % Открываем проводник для выбора файлов
-            % targetParamName - имя табличного параметра маски
-            % message - сообщение в диалоге выбора
-            
-            % Открываем проводник для выбора файлов с фильтрами
             [files, pathstr] = uigetfile({ ...
                 '*.c;*.cpp',      'Исходные файлы (*.c, *.cpp)'; ...
                 '*.obj;*.lib',    'Библиотеки (*.obj, *.lib)'; ...
                 '*.*',            'Все файлы (*.*)'}, ...
                 message, ...
-                'MultiSelect', 'on');  % Разрешаем множественный выбор
+                'MultiSelect', 'on');
             
             if isequal(files, 0)
-                return; % Пользователь отменил выбор
+                return; % Отмена выбора
             end
-            
-            % Нормализуем входные данные: один файл -> cell array
             if ischar(files)
-                files = {files};
+                files = {files}; % Один файл — в cell
             end
-            
+            % Парсим строку в cell-массив
-            % Читаем текущее содержимое таблицы
             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
 
-            % Сохраняем обновленную таблицу обратно в параметр маски
+            % Парсим строку в cell-массив
             customtable.collect(targetParamName, oldTable);
+            
         end
 
         function addPathTable(targetParamName, message)
-            % Добавление путей к папкам в таблицу через диалог выбора
+            % Открываем проводник для выбора папок
-            % targetParamName - имя табличного параметра маски  
-            % message - сообщение в диалоге выбора
-            
-            % Открываем проводник для выбора папки
             pathstr = uigetdir(pwd, message);
             if isequal(pathstr, 0)
-                return; % Пользователь отменил выбор
+                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 - добавление путей в текстовые параметры
+        %% 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; % Пользователь отменил выбор
+                % Отмена выбора — ничего не делаем
+                return;
             end
-            
-            % Формируем полный путь и преобразуем в относительный
             fullFilePath = fullfile(path, file);
             rel = mcuPath.absoluteToRelativePath(fullFilePath);
-            
-            % Устанавливаем значение параметра маски
             param = mask.getParameter(targetParamName);
             param.Value = rel;
         end
 
-        %% GET PATH STRING - утилиты преобразования путей
+        %% GET PATH STRING
 
         function absPath = getAbsolutePath(relPath)
-            % Преобразование относительного пути в абсолютный
+            % relativeToAbsolutePath — преобразует относительный путь в абсолютный.
-            % relPath - относительный или абсолютный путь
+            %
-            % Возвращает абсолютный путь в канонической форме
+            % Если путь уже абсолютный — возвращается он же, приведённый к канонической форме.
+            % Если путь относительный — преобразуется относительно текущей директории.
             
-            % Проверка: абсолютный ли путь уже
+            % Проверка: абсолютный ли путь
             if ispc
-                % Для Windows: путь начинается с буквы диска или \\
                 isAbsolute = ~isempty(regexp(relPath, '^[a-zA-Z]:[\\/]', 'once')) || startsWith(relPath, '\\');
             else
-                % Для Unix: путь начинается с /
                 isAbsolute = startsWith(relPath, '/');
             end
             
@@ -152,7 +111,7 @@ classdef mcuPath
                 % Канонизируем абсолютный путь (убираем ./, ../ и т.п.)
                 absPath = char(java.io.File(relPath).getCanonicalPath());
             else
-                % Строим абсолютный путь относительно текущей директории
+                % Строим абсолютный путь от текущей директории
                 cwd = pwd;
                 combined = fullfile(cwd, relPath);
                 absPath = char(java.io.File(combined).getCanonicalPath());
@@ -160,52 +119,50 @@ classdef mcuPath
         end
 
         function rel = absoluteToRelativePath(pathstr)
-            % Преобразование абсолютного пути в относительный относительно текущей директории
+            % absoluteToRelativePath — преобразует абсолютный путь в относительный от текущей директории.
-            % 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
         
-            % Формируем количество подъемов ".." для выхода из базовой директории
+            % Формируем количество подъемов ".." из 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
+
     end
 end

McuLib/m/mcuPorts.m

@@ -1,63 +1,45 @@
 classdef mcuPorts
-    % Класс для управления портами ввода-вывода в маске Simulink
-    % Генерирует конфигурационные файлы для портов на основе параметров маски
 
     methods(Static)
 
         function write()
-            % Основная функция записи конфигурации портов в файлы
-            % Генерирует заголовочный файл и файл реализации для портов
-            
             block = gcb;
             mask = Simulink.Mask.get(block);
-            
-            % Пути к конфигурационным файлам
             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
@@ -65,46 +47,39 @@ 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
@@ -112,93 +87,84 @@ 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)
-            % Генерация define-макросов для заголовочного файла
+            % existingText — структура с полями PARAMS, AUTO_PARAMS
-            % existingText - существующий текст конфигурации
+            % widths — вектор ширин портов
-            % widths - вектор ширин портов
+            % prefixNumb — префикс общего счётчика (например, 'OUT')
-            % prefixNumb - общий префикс ('IN' или 'OUT')
+            % portPrefixes — {'OUT', '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));
@@ -206,10 +172,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);
@@ -222,7 +188,6 @@ classdef mcuPorts
             lines{end+1} = '';
             lines{end+1} = sprintf('/// === Смещения массивов (внутри общего буфера) ===');
         
-            % Генерируем define для смещений каждого массива в буфере
             for i = 1:n
                 if i == 1
                     lines{end+1} = sprintf('#define OFFSET_%s_ARRAY_1 0', upperPrefix);
@@ -233,7 +198,7 @@ classdef mcuPorts
             end
             newAuto = strjoin(lines, newline);
         
-            % === ОБЪЕДИНЕНИЕ С СУЩЕСТВУЮЩИМ ТЕКСТОМ ===
+            % === Добавление к существующему ===
             if isfield(existingText, 'PARAMS')
                 headerText.PARAMS = [existingText.PARAMS, newline, newParams];
             else
@@ -247,43 +212,40 @@ classdef mcuPorts
             end
         end
 
+
         function cText = addPortCDefines(existingText, widths, prefixNumb, portPrefixes)
-            % Генерация кода для файла реализации (.c)
+            % existingText — существующий текст .c
-            % existingText - существующий текст
+            % widths — вектор ширин портов
-            % widths - вектор ширин портов
+            % prefixNumb — общий префикс ('OUT')
-            % prefixNumb - общий префикс ('IN' или 'OUT')
+            % portPrefixes — {'OUT', 'LOG', ...}
-            % portPrefixes - массив префиксов для каждого порта
+        
-            % Возвращает текст для вставки в .c файл
-            
             n = numel(widths);
             upperPrefix = upper(prefixNumb);
             lowerPrefix = lower(prefixNumb);
         
             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
@@ -296,7 +258,6 @@ classdef mcuPorts
         
             newText = strjoin(lines, newline);
         
-            % Объединяем с существующим текстом
             if nargin < 1 || isempty(existingText)
                 cText = newText;
             else
@@ -304,14 +265,20 @@ 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,152 +1,146 @@
-% Компилирует S-function для блока микроконтроллера в Simulink
+% Компилирует S-function
-% compile_mode: 1 - компиляция, 0 - обновление конфигурации
 function res = mexing(compile_mode)
+    global Ts
+    Ts = 0.00001;
     
     if compile_mode == 1
-        block = gcb;
+        delete('*.mexw64')
-        % === РЕЖИМ КОМПИЛЯЦИИ ===
+        delete('*.mexw64.pdb')
-        setenv('VSLANG', '1033');  % Английский для Visual Studio
+        delete([mcuPath.get('wrapperPath'),  '\Outputs\*.*']);
+        set_param(gcb, 'consoleOutput', '');    
+        compiler.updateRunBat();
+        % Дефайны
+        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');
+        
+        Name = mcuMask.get_name();
 
-        % Обновление параметров блока
+        % Вызов батника с двумя параметрами: includes и code
+        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
+        
+        % Сохраним вывод в параметр маски с именем 'consoleOutput'
+        mcuMask.disp(1, cmdout);
+
+        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);   
-            mcuMask.setSFuncName(block);
         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
-        
-        % Очистка предыдущих файлов компиляции
-        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
-            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');
-        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;  % Успешная компиляция
+            res = 0;
         else
-            res = 1;  % Ошибка компиляции
+            res = 1;
         end
-        beep  % Звуковое уведомление
+        beep
-
     else
-        % === РЕЖИМ ОБНОВЛЕНИЯ КОНФИГУРАЦИИ ===
         blockPath = gcb;
-        config = configJs.read(blockPath);  % Чтение конфигурации
+        config = configJs.read(blockPath);
-        config = configJs.update(blockPath, config);  % Обновление конфигурации
+        config = configJs.update(blockPath, config);
-        configJs.write(config);  % Запись конфигурации
+        configJs.write(config);
-        periphConfig.updateMask(blockPath, config);  % Обновление маски
+        periphConfig.updateMask(blockPath, config);
     end
 end
 
-%% COMPILE PARAMS - функции формирования параметров компиляции
+%% COMPILE PARAMS
+
 
 function [includesArg, codeArg] = make_mex_arguments(incTableName, srcTableame)
-% Формирует строки аргументов для вызова mex-компиляции через батник
+%MAKE_MEX_ARGUMENTS Формирует строки аргументов для вызова mex-компиляции через батник
+%
+% [includesArg, codeArg] = make_mex_arguments(includesCell, codeCell)
 %
 % Вход:
-%   incTableName - имя таблицы с путями включения
+%   includesCell — ячейковый массив путей к директориям include
-%   srcTableame - имя таблицы с исходными файлами
+%   codeCell     — ячейковый массив исходных файлов
 %
 % Выход:
-%   includesArg - строка с флагами включения (-I"path")
+%   includesArg  — строка для передачи в батник, например: "-I"inc1" -I"inc2""
-%   codeArg - строка с исходными файлами ("file1.c" "file2.cpp")
+%   codeArg      — строка с исходниками, например: ""src1.c" "src2.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()
-% Парсинг пользовательских дефайнов из текстового поля маски
 
+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});
@@ -154,7 +148,7 @@ function definesUserArg = parseDefinesMaskText()
             continue;
         end
 
-        % Разбиение строки на токены
+        % Разбиваем по пробелам, чтобы получить отдельные определения в строке
         tokens = split(line);
 
         for t = 1:numel(tokens)
@@ -163,13 +157,11 @@ 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);
@@ -180,13 +172,13 @@ function definesUserArg = parseDefinesMaskText()
     definesUserArg = strjoin(parts, ' ');
 end
 
-function definesWrapperArg = buildConfigDefinesString()
-% Формирование дефайнов из конфигурации периферии
 
+
+function definesWrapperArg = buildConfigDefinesString()
     blockHandle = gcbh;
     mask = Simulink.Mask.get(blockHandle);
 
-    tabName = 'configTabAll';  % Имя вкладки с конфигурацией
+    tabName = 'configTabAll';  % Имя вкладки (Prompt)
 
     tabCtrl = mask.getDialogControl(tabName);
 
@@ -194,15 +186,17 @@ 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);
@@ -211,32 +205,33 @@ function definesWrapperArg = buildConfigDefinesString()
                 case 'popup'
                     definesWrapperArg = addDefineByParam(definesWrapperArg, paramName, 0);
                 otherwise
-                    % Пропуск необрабатываемых типов
+                    % Необрабатываемые типы
             end
         catch ME
-            % Игнорирование ошибок для отсутствующих параметров
+            % warning('Не удалось получить параметр "%s": %s', paramName, ME.message);
         end
     end
 end
 
-function definesWrapperArg = addDefineByParam(definesWrapperArg, paramName, val_define)
-% Добавление дефайна на основе параметра маски
 
+%% 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);
+    param = mask.getParameter(paramName); % для alias
 
-    % Поиск индекса параметра
+    % Найдём индекс нужного параметра
     idxParam = find(strcmp(paramNames, paramName), 1);
     if isempty(idxParam)
         error('Parameter "%s" not found in block mask parameters.', paramName);
     end
 
-    % Определение имени дефайна (алиас или значение)
+    % Берём alias из маски
     val = '';
     if ~strcmp(param.Type, 'popup')
         def_name = param.Alias;
@@ -253,24 +248,23 @@ function definesWrapperArg = addDefineByParam(definesWrapperArg, paramName, val_
         return;
     end
 
-    % Формирование дефайна в зависимости от типа параметра
     if val_define ~= 0
-        % Параметры с значениями
+        % Значение параметра
         val = maskValues{idxParam};
         if strcmp(param.Evaluate, 'on')
-            val = evalin('base', val);  % Вычисление выражений
+            val = evalin('base', val);   % Вычисляем выражение
-            val = num2str(val);
+            val = num2str(val);          % Преобразуем результат в строку
         end
+        % Формируем define с кавычками и значением
         newDefine = ['-D"' def_name '__EQ__' val '"'];
     elseif ~strcmp(param.Type, 'popup')
-        % Чекбоксы
         if mcuMask.read_checkbox(paramName)
+            % Формируем define с кавычками без значения
             newDefine = ['-D"' def_name '"'];
         else
             newDefine = '';
         end
     else
-        % Выпадающие списки
         if strcmp(param.Alias, '')
             newDefine = ['-D"' def_name '"'];
         else
@@ -278,7 +272,9 @@ function definesWrapperArg = addDefineByParam(definesWrapperArg, paramName, val_
         end
     end
 
-    % Добавление дефайна к результирующей строке
+
+
+    % Добавляем новый define к существующему (string)
     if isempty(definesWrapperArg) || strlength(strtrim(definesWrapperArg)) == 0
         definesWrapperArg = newDefine;
     else
@@ -286,22 +282,19 @@ 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()
@@ -309,37 +302,36 @@ function cmdret = runBatAndShowOutput(cmd)
             if isempty(line)
                 break;
             end
-            cmdret = cmdret + string(line) + newline;
+            cmdret = cmdret + string(line) + newline; % сохраняем вывод
-            safeLine = strrep(line, '''', '''''');  % Экранирование кавычек
+            % Здесь выводим только новую строку
-            logWindow_append(safeLine);  % Вывод в окно лога
+            safeLine = strrep(line, '''', ''''''); % Экранируем апострофы
-            drawnow;
+            logWindow_append(safeLine);
+            drawnow; % обновляем GUI
         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)
-% Добавление строки в окно лога с автоскроллингом
 
+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', ...
@@ -351,12 +343,10 @@ function logWindow_append(line)
             'BackgroundColor', 'white', ...
             'Tag', 'LogWindowFigure');
 
-        % Получение Java-компонентов для управления скроллингом
+        jScrollPane = findjobj(hEdit);                  % JScrollPane
-        jScrollPane = findjobj(hEdit);
+        jTextArea = jScrollPane.getViewport.getView;   % JTextArea внутри JScrollPane
-        jTextArea = jScrollPane.getViewport.getView;
     end
 
-    % Добавление новой строки
     oldText = get(hEdit, 'String');
     if ischar(oldText)
         oldText = {oldText};
@@ -364,30 +354,32 @@ function logWindow_append(line)
 
     set(hEdit, 'String', [oldText; {line}]);
     drawnow;
-    
+    % Автоскролл вниз:
-    % Автоскроллинг вниз
     jTextArea.setCaretPosition(jTextArea.getDocument.getLength);
     drawnow;
 end
 
-function isOpen = isMaskDialogOpen(blockPath)
-% Проверка открыто ли диалоговое окно маски
 
+%% READ CONFIGS
+
+function isOpen = isMaskDialogOpen(blockPath)
     isOpen = false;
 
     try
+        % Получаем имя блока
         blockName = get_param(blockPath, 'Name');
 
-        % Получение всех открытых окон Java
+        % Получаем список окон MATLAB GUI
         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)
@@ -395,11 +387,12 @@ function isOpen = isMaskDialogOpen(blockPath)
                         return;
                     end
                 catch
-                    % Пропуск окон без заголовка
+                    % Окно не имеет заголовка — пропускаем
                 end
             end
         end
     catch
         isOpen = false;
     end
-end
+end
+

McuLib/m/periphConfig.m

@@ -1,45 +1,37 @@
 classdef periphConfig
-    % Класс для управления конфигурацией периферии в маске Simulink
-    % Динамически создает элементы маски на основе JSON конфигурации
 
     methods(Static)
         function updateMask(blockPath, config)
-            % Основная функция обновления маски на основе конфигурации
+        %     blockPath = [blockPath '/MCU'];
-            % Динамически создает вкладки и параметры для периферийных модулей
+        
-            % blockPath - путь к блоку Simulink
+            % Проверяем, была ли маска открыта
-            % config - структура конфигурации из JSON файла
+%             wasOpen = isMaskDialogOpen(blockPath);
-            
             mask = Simulink.Mask.get(blockPath);
 
-            % Сохраняем состояние таблиц перед изменением маски
             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)
-                    % Проходим по каждому модулю периферии (ADC, TIM, UART и т.д.)
+                    % Проходим по каждому модулю (ADC, TIM...)
                     periphs = fieldnames(config);
                     for i = 1:numel(periphs)
                         periph = periphs{i};
     
-                        % Сохраняем код модуля (исходники и инклюды) в скрытые параметры
+                        % Сохраняем код, если он есть
                         periphConfig.store_single_periph_code(mask, periph, config.(periph));
                         
-                        % Пропускаем модули без секции Defines
+                        % Проверяем наличие Defines
                         if ~isfield(config.(periph), 'Defines')
                             continue;
                         end
@@ -47,80 +39,68 @@ classdef periphConfig
                         defines = config.(periph).Defines;
                         defNames = fieldnames(defines);
                 
-                        % Создаем вкладку для модуля периферии
+                        % Создаём вкладку для модуля
                         tabCtrl = container.addDialogControl('tab', periph);
-                        tabCtrl.Prompt = [periph ' Config'];  % Отображаемое имя вкладки
+                        tabCtrl.Prompt = [periph ' Config'];
                 
-                        % Карта для отслеживания количества строк в каждой вкладке
                         rowCountMap = containers.Map();
-                        
-                        % Добавляем все параметры Defines в созданную вкладку
                         for j = 1:numel(defNames)
                             defPrompt = defNames{j};
                             def = defines.(defPrompt);
     
-                            % Добавление одного параметра конфигурации
+                            % Вызов функции добавления одного параметра
                             periphConfig.addConfig(mask, containerName, periph, defPrompt, def, rowCountMap, rowWidth);
                         end
                     end
                 end
-                
-                % Создаем скрытые параметры для хранения кода периферии
                 periphConfig.create_all_code_storage_params(blockPath, config);
-                
+                % periphConfig.cleanup_obsolete_code_params(blockPath, config);
-                % Обновляем состояние маски (включение/выключение вкладок)
+
                 periphConfig.update();
             
-                % Восстанавливаем таблицы после изменений
+                % Восстанавлиperiph = allTabNamesваем таблицы
                 customtable.restore_all_tables(tableNames, columns_backup);
             catch
-                % В случае ошибки восстанавливаем таблицы
+                % Восстанавливаем таблицы
                 customtable.restore_all_tables(tableNames, columns_backup);
             end
-
+            % % Повторно открываем маску, если она была открыта
-            periphConfig.addUserFunctions(config.UserCode);
+            % if wasOpen
+            %     open_system(blockPath, 'mask');
+            % end
         end
         
         function update()
-            % Обновление состояния маски - включение/выключение вкладок
-            % на основе состояний чекбоксов управления
-            
             blockPath = gcb;
             mask = Simulink.Mask.get(blockPath);
 
-            % Читаем текущую конфигурацию
             config = configJs.read(blockPath);
             containerName = 'configTabAll';
             container = mask.getDialogControl(containerName);
-            
-            % Получаем все параметры для проверки наличия чекбоксов
             paramsAll = mcuMask.collect_all_parameters(container);          
-            
+            % Получаем все имена в  кладок из container (у вас должен быть container)
-            % Получаем имена всех вкладок в контейнере
             allTabs = container.DialogControls;
             allTabNames = arrayfun(@(t) t.Name, allTabs, 'UniformOutput', false);
             
             fieldsConfig = fieldnames(config);
-            
+            % Цикл по всем вкладкам в контейнере
-            % Обрабатываем каждую вкладку
             for i = 1:length(allTabNames)
                 periph = fieldsConfig{i};
                 
-                % Проверяем наличие чекбокса управления для этой вкладки
+                % Попытка найти параметр чекбокса Tab_<Periph>_Enable
                 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
-                            % Включаем вкладку и синхронизируем параметры
                             tab.Enabled = 'on';
                             periphConfig.sync_tab_params(mask, config.(periph), periph);
                         end
@@ -129,32 +109,31 @@ classdef periphConfig
                     end
                     
                 else
-                    % Чекбокса нет - просто включаем вкладку
+                    % Чекбокса нет — просто пытаемся включить вкладку, если она есть
                     try
                         tab = container.getDialogControl(periph);
                         tab.Enabled = 'on';
-                        % Синхронизируем параметры если есть конфигурация
+                        % Опционально можно синхронизировать параметры, если есть config поле
                         if isfield(config, periph)
-                            periphConfig.sync_tab_params(mask, config.(periph), periph);
+                               periphConfig.sync_tab_params(mask, config.(periph), periph);
                         end
                     catch
-                        % Вкладка может быть необязательной - игнорируем ошибку
+                        % Можно не выводить предупреждение — вкладка может быть необязательной
+                        % warning('Вкладка с именем "%s" не найдена.', periph);
                     end
                 end
             end
+
         end
 
         function periphParamCallback(paramName)
-            % Callback-функция для параметров периферии
-            % Обрабатывает изменения чекбоксов и других параметров
-            
             blockPath = gcb;
             mask = Simulink.Mask.get(blockPath);
             hObj = mask.getParameter(paramName);
             config = configJs.read(blockPath);
             container = mask.getDialogControl('configTabAll');
         
-            % === Обработка чекбоксов управления вкладками ===
+            % === Проверка на Tab_<Periph>_Enable ===
             exprTab = '^Tab_(\w+)_Enable$';
             tokensTab = regexp(paramName, exprTab, 'tokens');
         
@@ -166,13 +145,11 @@ classdef periphConfig
                     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);
@@ -184,17 +161,19 @@ classdef periphConfig
                 return;
             end
         
-            % === Обработка параметров, связанных с Sources/Includes ===
+            % === Проверка на параметр, связанный с Sources/Includes ===
+            % Проверка: это параметр, у которого есть соответствующий Hidden_<Name>_Sources или Hidden_<Name>_Includes
             nameBase = paramName;
             
             paramNames = string({mask.Parameters.Name});
             hasSources = any(paramNames == "Hidden_" + nameBase + "_Sources");
             hasIncludes = any(paramNames == "Hidden_" + nameBase + "_Includes");
             
+            
             if hasSources || hasIncludes
                 useVal = hObj.Value;
             
-                % Получаем структуру конфигурации для этого параметра
+                % Получаем содержимое config по nameBase — возможно, вложенное
                 try
                     valueStruct = configJs.get_field(config, nameBase);
                 catch
@@ -203,50 +182,49 @@ classdef periphConfig
                 end
             
                 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
+
+        
+            % === Если не подошло ни под одно из условий ===
+            % warning('Объект "%s" не поддерживается универсальным коллбеком.', paramName);
         end
 
         function updatePeriphRunMexBat()
-            % Обновление BAT-файла для компиляции с кодом периферии
+            % Запись run_mex.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', ...
@@ -255,16 +233,14 @@ classdef periphConfig
                 'Visible', 'off', ...
                 'Container', containerName ...
             );
+            fprintf('Создан скрытый параметр: %s\n', paramName);
         end
 
         function clear_tab_params(mask, configStruct, prefix, depth)
-            % Рекурсивная очистка параметров вкладки
-            % Используется при выключении вкладки
-            
             if nargin < 4
                 depth = 0;
             end
-            maxDepth = 3;  % Ограничение глубины рекурсии
+            maxDepth = 3;  % Максимальная глубина рекурсии
             
             fields = fieldnames(configStruct);
         
@@ -275,11 +251,10 @@ classdef periphConfig
         
                 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);
@@ -288,14 +263,12 @@ classdef periphConfig
             end
         end
         
+        
         function sync_tab_params(mask, configStruct, prefix, depth)
-            % Рекурсивная синхронизация параметров вкладки
-            % Используется при включении вкладки
-            
             if nargin < 4
                 depth = 0;
             end
-            maxDepth = 3;
+            maxDepth = 3;  % Максимальная глубина рекурсии
             
             fields = fieldnames(configStruct);
         
@@ -306,6 +279,7 @@ classdef periphConfig
         
                 if isstruct(value)
                     if depth < maxDepth
+                        % Рекурсивный вызов для вложенных структур с увеличением глубины
                         periphConfig.sync_tab_params(mask, value, paramName, depth + 1);
                     end
                 else
@@ -318,15 +292,13 @@ classdef periphConfig
         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)
@@ -337,22 +309,20 @@ classdef periphConfig
                 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];
+                newStack = [nameStack, fieldName];  % Добавляем уровень к имени
         
+                % Если value — структура, обходим дальше
                 if isstruct(value)
-                    % Проверяем наличие Sources и Includes в структуре
+                    % Проверяем: это структура с Sources/Includes или просто промежуточный узел?
                     hasSources = isfield(value, 'Sources');
                     hasIncludes = isfield(value, 'Includes');
         
@@ -369,37 +339,33 @@ classdef periphConfig
             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;
         
-                % Ищем параметры хранения кода
+                % Проверяем, является ли параметром хранения Sources или Includes
                 expr = '^Hidden_(\w+)_(Sources|Includes)$';
                 tokens = regexp(paramName, expr, 'tokens');
                 if ~isempty(tokens)
                     periph = tokens{1}{1};
         
-                    % Удаляем параметр если периферия больше не существует
+                    % Если периферии больше нет – удаляем параметр
                     if ~ismember(periph, validPeriphs)
                         mask.removeParameter(paramName);
+                        fprintf('Удалён устаревший параметр: %s\n', paramName);
                     end
                 end
             end
         end
 
         function codeStruct = restore_periph_code_from_mask(blockPath)
-            % Восстановление кода периферии из скрытых параметров маски
-            % Собирает все Sources и Includes в одну структуру
-            
             mask = Simulink.Mask.get(blockPath);
             maskParams = mask.Parameters;
             
@@ -409,27 +375,26 @@ classdef periphConfig
             for i = 1:numel(maskParams)
                 name = maskParams(i).Name;
                 
-                % Поиск параметров Sources
+                % Ищем параметры 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];
+                        allSources = [allSources; lines]; %#ok<AGROW>
                     end
                     continue;
                 end
                 
-                % Поиск параметров Includes
+                % Ищем параметры Includes
                 tokensInc = regexp(name, '^Hidden_(\w+)_Includes$', 'tokens');
                 if ~isempty(tokensInc)
                     val = maskParams(i).Value;
@@ -442,28 +407,27 @@ classdef periphConfig
                         
                         lines = splitlines(valStr);
                         lines = lines(~cellfun(@(x) all(isspace(x)) || isempty(x), lines));
-                        allIncludes = [allIncludes; lines];
+                        allIncludes = [allIncludes; lines]; %#ok<AGROW>
                     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);
         
             % Удаляем все параметры
@@ -475,27 +439,30 @@ classdef periphConfig
                 end
             end
         
-            % Рекурсивно удаляем все вкладки
+            % Рекурсивно удалить все вкладки внутри контейнера
             mcuMask.delete_all_tabs(mask, container);
         end
 
+        
         function res = addCodeBat(codeConfig, codePath)
-            % Добавление кода периферии в BAT-файл компиляции
+            % Добавить сурсы и пути в батник
-            
+            % Возвращает 0 при успехе, 1 при ошибке            
             try
-                % Формируем строки для BAT-файла
+                % Формируем строки
                 srcText = compiler.createSourcesBat('code_PERIPH', codeConfig.Sources, codePath);
                 incText = compiler.createIncludesBat('includes_PERIPH', codeConfig.Includes, codePath);
                 
-                % Обновляем BAT-файл
+                % Записываем результат
-                res = compiler.updateRunMexBat(srcText, incText, ':: PERIPH BAT');
+                res = compiler.updateRunMexBat(srcText, incText, ':: PERIPH BAT'); % Всё прошло успешно
             catch
-                res = 1;  % Ошибка
+                % В случае ошибки просто возвращаем 1
+                res = 1;
             end
         end
 
         function res = addUserFunctions(userCodeConfig)
-            % Добавление пользовательских функций в код обёртки
+            % Добавить функции и дефайны в исходный код wrapper
+            % userCodeConfig — структура config.UserCode
             
             initFuncsText = '';
             simFuncsText = '';
@@ -504,45 +471,43 @@ classdef periphConfig
             if isfield(userCodeConfig, 'Functions')
                 funcs = userCodeConfig.Functions;
 
-                % Обрабатываем функции инициализации
                 if isfield(funcs, 'PeriphInit')
                     initFuncs = funcs.PeriphInit;
                     initFuncsText = strjoin(strcat('\t', initFuncs, ';'), '\n');
                 end
                 
-                % Обрабатываем функции симуляции
                 if isfield(funcs, 'PeriphSimulation')
                     simFuncs = funcs.PeriphSimulation;
                     simFuncsText = strjoin(strcat('\t', simFuncs, ';'), '\n');
                 end
 
-                % Обрабатываем функции деинициализации
                 if isfield(funcs, 'PeriphDeinit')
                     deinitFuncs = funcs.PeriphDeinit;
                     deinitFuncsText = strjoin(strcat('\t', deinitFuncs, ';'), '\n');
                 end
 
-                % Записываем функции в файл обёртки
                 res = periphConfig.writeWrapperCode(initFuncsText, simFuncsText, deinitFuncsText);
             end
         end
 
         function res = writeWrapperCode(initFuncsText, simFuncsText, deinitFuncsText)
-            % Запись пользовательских функций в файл mcu_wrapper.c
+        % Входные параметры:
-            
+        %   srcText     - текст для записи set code_...
+        %   incText     - текст для записи set includes_...
+        %
+        % Возвращает:
+        %   res - 0 при успехе, 1 при ошибке
             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');
                 if fid == -1
                     error('Не удалось открыть файл для записи');
@@ -556,22 +521,18 @@ classdef periphConfig
         end
         
         function addConfig(mask, containerName, periphName, defPrompt, def, rowCountMap, rowWidth)
-            % Добавление одного параметра конфигурации в маску
+            % mask           — объект маски Simulink.Mask.get(blockPath)
-            % mask - объект маски
+            % containerName  — имя контейнера, в который добавляем параметр (например, 'configTabAll')
-            % containerName - имя контейнера
+            % periphName     — имя вкладки / контейнера для текущего периферийного блока (например, 'ADC')
-            % periphName - имя периферийного модуля
+            % defPrompt      — имя параметра в Defines (например, 'shift_enable')
-            % defPrompt - имя параметра
+            % def            — структура с описанием параметра (Prompt, Def, Type, Default, NewRow и т.п.)
-            % def - структура с описанием параметра
+        
-            % rowCountMap - карта для отслеживания строк
-            % rowWidth - ширина строки
-            
-            % Инициализация счетчика строк для этого модуля
             if ~isKey(rowCountMap, periphName)
                 rowCountMap(periphName) = 0;
             end
             rowCount = rowCountMap(periphName) + 1;
 
-            % Определяем начинать ли новую строку
+            % Устанавливаем NewRow, если он не задан
             if ~isfield(def, 'NewRow')
                 def.NewRow = mod(rowCount - 1, rowWidth) == 0;
             elseif def.NewRow == true
@@ -579,20 +540,20 @@ classdef periphConfig
             end
             rowCountMap(periphName) = rowCount;
 
-            % Получаем контейнер
+            % Найдем контейнер с таким именем
             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';
@@ -601,20 +562,20 @@ classdef periphConfig
                 case 'popup'
                     paramType = 'popup';
                 otherwise
-                    return;  % Пропускаем неизвестные типы
+                    % Игнорируем остальные типы
+                    return;
             end
         
-            % Создаем валидное имя параметра
             paramName = matlab.lang.makeValidName(defPrompt);
         
-            % Устанавливаем значение по умолчанию
+            % Получаем значение
             if strcmp(paramType, 'popup')
                 if isfield(def, 'Def') && iscell(def.Def) && ~isempty(def.Def)
                     choices = def.Def;
-                    valStr = '';
+                    valStr = ''; % по умолчанию — ничего
                 elseif isfield(def, 'Options')
                     choices = def.Def;
-                    valStr = '';
+                    valStr = ''; % по умолчанию — ничего
                 else
                     warning('Popout параметр "%s" не содержит допустимого списка в Def.', defPrompt);
                     return;
@@ -675,11 +636,12 @@ classdef periphConfig
             param.Callback = callback;
         end
 
-        %% ELEMENTARY FUNCTIONS - базовые вспомогательные функции
+
+
+        %% ELEMENTARY
         
         function clear_single_periph_code_param(mask, periph)
-            % Очистка кода одного модуля периферии
+        % Очистка кода одного поля конфига
-            
             paramNames = {
                 ['Hidden_' char(periph) '_Sources'],
                 ['Hidden_' char(periph) '_Includes']
@@ -691,14 +653,14 @@ classdef periphConfig
                     param = mask.getParameter(paramName);
                     param.Value = '';
                 catch
-                    % Параметр не существует - игнорируем
+                    % Параметр не существует — ничего не делаем
                 end
             end
         end
         
         function store_single_periph_code(mask, periph, code)
-            % Сохранение кода одного модуля периферии в скрытые параметры
+        % Запись кода одного поля конфига
-            
+            % Сохраняем Sources, если они есть
             if isfield(code, 'Sources')
                 paramName = ['Hidden_' char(periph) '_Sources'];
                 try
@@ -709,6 +671,7 @@ classdef periphConfig
                 end
             end
         
+            % Сохраняем Includes, если они есть
             if isfield(code, 'Includes')
                 paramName = ['Hidden_' char(periph) '_Includes'];
                 try
@@ -720,13 +683,15 @@ classdef periphConfig
             end
         end
 
+        
+        
         function res = ternary(cond, valTrue, valFalse)
-            % Вспомогательная функция - тернарный оператор
             if cond
                 res = valTrue;
             else
                 res = valFalse;
             end
         end
+
     end
-end
+end

mcuwrapper.prj

@@ -7,7 +7,7 @@
     <param.summary>Library for run MCU program in Simulink</param.summary>
     <param.description />
     <param.screenshot />
-    <param.version>1.04</param.version>
+    <param.version>1.03</param.version>
     <param.output>${PROJECT_ROOT}\MCU Wrapper.mltbx</param.output>
     <param.products.name />
     <param.products.id />
@@ -84,6 +84,7 @@
       <file>${PROJECT_ROOT}\McuLib</file>
     </fileset.rootdir>
     <fileset.rootfiles>
+      <file>${PROJECT_ROOT}\McuLib\.library_installed.mat</file>
       <file>${PROJECT_ROOT}\McuLib\install_my_library.m</file>
       <file>${PROJECT_ROOT}\McuLib\lib</file>
       <file>${PROJECT_ROOT}\McuLib\m</file>
@@ -100,12 +101,14 @@
     </build-deliverables>
     <workflow />
     <matlab>
-      <root>C:\Program Files\MATLAB\R2021b</root>
+      <root>C:\Program Files\MATLAB\R2023a</root>
       <toolboxes>
         <toolbox name="matlabcoder" />
         <toolbox name="embeddedcoder" />
         <toolbox name="gpucoder" />
         <toolbox name="fixedpoint" />
+        <toolbox name="matlabhdlcoder" />
+        <toolbox name="neuralnetwork" />
       </toolboxes>
       <toolbox>
         <matlabcoder>
@@ -127,6 +130,16 @@
           <enabled>true</enabled>
         </fixedpoint>
       </toolbox>
+      <toolbox>
+        <matlabhdlcoder>
+          <enabled>true</enabled>
+        </matlabhdlcoder>
+      </toolbox>
+      <toolbox>
+        <neuralnetwork>
+          <enabled>true</enabled>
+        </neuralnetwork>
+      </toolbox>
     </matlab>
     <platform>
       <unix>false</unix>