Compare commits
4 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
| 0b6807bd2c | |||
| 49be34efc9 | |||
| 041322a62e | |||
| 1aa3c5b955 |
Binary file not shown.
@ -2,12 +2,24 @@
|
||||
function install_my_library()
|
||||
libDir = fileparts(mfilename('fullpath'));
|
||||
|
||||
% Путь к файлу-флагу, указывающему, что установка уже была
|
||||
flagFile = fullfile(libDir, '.library_installed.mat');
|
||||
|
||||
% Если библиотека уже установлена — просто выходим
|
||||
if isfile(flagFile)
|
||||
return;
|
||||
end
|
||||
|
||||
% 1. Добавляем библиотеку и m-файлы в путь
|
||||
addpath(fullfile(libDir, 'lib'));
|
||||
addpath(fullfile(libDir, 'm'));
|
||||
savepath;
|
||||
|
||||
% 3. Обновляем Library Browser
|
||||
% 2. Обновляем Library Browser
|
||||
rehash;
|
||||
sl_refresh_customizations;
|
||||
|
||||
% 3. Сохраняем флаг установки
|
||||
installedOn = datetime('now');
|
||||
save(flagFile, 'installedOn');
|
||||
end
|
||||
|
||||
Binary file not shown.
209
McuLib/m/appWrap.m
Normal file
209
McuLib/m/appWrap.m
Normal file
@ -0,0 +1,209 @@
|
||||
classdef appWrap
|
||||
% Класс для редактирования кода обёртки МК прямо внутри MATLAB/Simulink
|
||||
% Позволяет работать с кодом микроконтроллера без переключения между IDE
|
||||
|
||||
methods(Static)
|
||||
|
||||
function appWrapperFunc()
|
||||
% Загружает код обёртки из файлов в интерфейс MATLAB для редактирования
|
||||
% Автоматически вызывается при выборе типа кода в маске блока
|
||||
|
||||
block = gcb; % Получаем текущий блок Simulink для редактирования
|
||||
|
||||
% Определяем какой файл и секцию нужно редактировать
|
||||
[filename, section, tool, example] = appWrap.getAppWrapperUserFile(block);
|
||||
|
||||
% Показываем подсказку по выбранному типу кода прямо в MATLAB
|
||||
mcuMask.tool(tool, example);
|
||||
|
||||
% Очищаем поле редактирования перед загрузкой нового кода
|
||||
set_param(block, 'appWrapperCode', '');
|
||||
|
||||
% Загружаем код из файла в интерфейс MATLAB
|
||||
try
|
||||
% Читаем исходный код из файла
|
||||
code = fileread(filename);
|
||||
code = regexprep(code, '\r\n?', '\n'); % унифицируем переводы строк для MATLAB
|
||||
|
||||
% Вырезаем только нужную секцию для редактирования
|
||||
includesText = editCode.extractSection(code, section);
|
||||
|
||||
% Загружаем код в текстовое поле маски для редактирования
|
||||
set_param(block, 'appWrapperCode', includesText);
|
||||
catch
|
||||
% Если файл не найден или ошибка чтения - оставляем поле пустым
|
||||
% Пользователь сможет написать код с нуля прямо в MATLAB
|
||||
end
|
||||
end
|
||||
|
||||
function saveAppWrapperCode()
|
||||
% Сохраняет отредактированный код из MATLAB обратно в файлы обёртки
|
||||
% Вызывается при нажатии кнопки "Сохранить" в интерфейсе
|
||||
|
||||
block = gcb; % Текущий редактируемый блок
|
||||
|
||||
% Определяем куда сохранять based на выборе пользователя в MATLAB
|
||||
[filename, section] = appWrap.getAppWrapperUserFile(block);
|
||||
|
||||
% Проверяем что файл существует перед сохранением
|
||||
if ~isfile(filename)
|
||||
errordlg(['Файл не найден: ', filename], 'Ошибка сохранения в MATLAB');
|
||||
return;
|
||||
end
|
||||
|
||||
% Получаем выбранный тип кода и путь к файлам
|
||||
sel = get_param(block, 'appWrapperFunc');
|
||||
basePath = get_param(block, 'appWrapperPath');
|
||||
|
||||
if isempty(basePath)
|
||||
errordlg('Не указан путь к файлам обёртки.', 'Ошибка в MATLAB');
|
||||
return;
|
||||
end
|
||||
|
||||
% Получаем код который пользователь написал/отредактировал в MATLAB
|
||||
newBody = get_param(block, 'appWrapperCode');
|
||||
|
||||
% Читаем текущее содержимое файла чтобы сохранить структуру
|
||||
code = fileread(filename);
|
||||
code = regexprep(code, '\r\n?', '\n');
|
||||
|
||||
% Экранируем специальные символы для корректного сохранения из MATLAB
|
||||
newBody = strrep(newBody, '\', '\\');
|
||||
|
||||
% Вставляем отредактированную в MATLAB секцию обратно в файл
|
||||
code = editCode.insertSection(code, section, newBody);
|
||||
|
||||
% Сохраняем изменения прямо из MATLAB без внешних редакторов
|
||||
fid = fopen(filename, 'w', 'n');
|
||||
if fid == -1
|
||||
errordlg('Не удалось сохранить файл из MATLAB', 'Ошибка записи');
|
||||
return;
|
||||
end
|
||||
|
||||
% Записываем обновленный код
|
||||
fwrite(fid, code);
|
||||
fclose(fid);
|
||||
|
||||
% Подтверждаем успешное сохранение в интерфейсе MATLAB
|
||||
mcuMask.disp(1, ['Сохранено в MATLAB: ' sel]);
|
||||
end
|
||||
|
||||
function openAppWrapperCode()
|
||||
% Альтернативный способ: открывает файл в системном редакторе
|
||||
% Для случаев когда нужно работать во внешней IDE
|
||||
|
||||
block = gcb;
|
||||
|
||||
% Получаем абсолютный путь к файлу для открытия
|
||||
filename = mcuPath.getAbsolutePath(appWrap.getAppWrapperUserFile(block));
|
||||
|
||||
if exist(filename, 'file') == 2
|
||||
% Открываем через системный диалог "Открыть с помощью"
|
||||
% Полезно если нужно использовать привычную IDE вместо редактора MATLAB
|
||||
cmd = sprintf('rundll32.exe shell32.dll,OpenAs_RunDLL %s', filename);
|
||||
status = system(cmd);
|
||||
|
||||
if status ~= 0
|
||||
errordlg('Не удалось открыть файл во внешнем редакторе');
|
||||
end
|
||||
else
|
||||
errordlg('Файл не найден для открытия');
|
||||
end
|
||||
end
|
||||
|
||||
|
||||
%% SPECIFIC TOOLS
|
||||
function [filename, section, tool, example] = getAppWrapperUserFile(block, sel)
|
||||
% Маппинг типов кода на файлы и секции для редактирования в MATLAB
|
||||
% Центральное место настройки - здесь определяется где что редактировать
|
||||
|
||||
if (nargin < 2)
|
||||
% Получаем какой тип кода пользователь выбрал в интерфейсе MATLAB
|
||||
sel = get_param(block, 'appWrapperFunc');
|
||||
end
|
||||
|
||||
% Базовый путь к файлам обёртки (настраивается в маске)
|
||||
basePath = mcuPath.get('appWrapperPath');
|
||||
if isempty(basePath)
|
||||
errordlg('Не указан путь к файлам обёртки.');
|
||||
return;
|
||||
end
|
||||
|
||||
% В зависимости от выбора в MATLAB - определяем что редактировать:
|
||||
if strcmp(sel, 'Includes')
|
||||
% Редактирование подключения заголовочных файлов
|
||||
filename = fullfile(basePath, 'app_includes.h');
|
||||
section = '// INCLUDES';
|
||||
tool = 'Инклюды для доступа к коду МК в коде оболочке';
|
||||
example = '#include "main.h"'; % Пример для подсказки в MATLAB
|
||||
|
||||
elseif strcmp(sel, 'Dummy')
|
||||
% Редактирование заглушек для симуляции
|
||||
filename = fullfile(basePath, 'app_wrapper.c');
|
||||
section = '// DUMMY';
|
||||
tool = 'Заглушки для различных функций и переменных';
|
||||
example = ['CAN_HandleTypeDef hcan = {0};' newline...
|
||||
'void hardware_func(handle *huart) {}' newline...
|
||||
'int wait_for_hardware_flag(int *flag) {' newline...
|
||||
' return 1;' newline...
|
||||
'}' newline...
|
||||
''];
|
||||
|
||||
elseif strcmp(sel, 'App Init')
|
||||
% Редактирование кода инициализации приложения
|
||||
filename = fullfile(basePath, 'app_init.c');
|
||||
section = '// USER APP INIT';
|
||||
tool = ['Код для инициализации приложения МК.' newline newline...
|
||||
'Вызов функций инициализации, если не используется отдельный поток для main().'];
|
||||
example = 'init_func();';
|
||||
|
||||
elseif strcmp(sel, 'App Step')
|
||||
% Редактирование кода выполняемого на каждом шаге симуляции
|
||||
filename = fullfile(basePath, 'app_wrapper.c');
|
||||
section = '// USER APP STEP';
|
||||
tool = ['Код приложения МК для вызова в шаге симуляции.' newline newline ...
|
||||
'Вызов функций программы МК, если не используется отдельный поток для main().'];
|
||||
example = 'step_func();';
|
||||
|
||||
elseif strcmp(sel, 'App Inputs')
|
||||
% Редактирование обработки входных данных от Simulink
|
||||
filename = fullfile(basePath, 'app_io.c');
|
||||
section = '// USER APP INPUT';
|
||||
tool = ['Работа с буффером для портов S-Function' newline newline ...
|
||||
'Буфер в начале хранит входные порты S-Function, далее идут выходные порты:' newline ...
|
||||
'Buffer[0:15] - входной порт, Buffer[16:31] - входной 1 порт, ' newline ...
|
||||
'Buffer[32:47] - выходной 1 порт, Buffer[48:63] - выходной 2 порт'];
|
||||
example = ['// чтение 1-го элемента 0-го входного массива' newline...
|
||||
'app_variable_2 = ReadInputArray(0, 1);' newline newline...
|
||||
'// запись в буфер выходов' newline ...
|
||||
'app_variable_2 = Buffer[10];'];
|
||||
|
||||
elseif strcmp(sel, 'App Outputs')
|
||||
% Редактирование формирования выходных данных для Simulink
|
||||
filename = fullfile(basePath, 'app_io.c');
|
||||
section = '// USER APP OUTPUT';
|
||||
tool = ['Работа с буффером для портов S-Function' newline newline ...
|
||||
'Буфер в начале хранит входные порты S-Function, далее идут выходные порты:' newline ...
|
||||
'Buffer[0:15] - входной порт, Buffer[16:31] - входной 1 порт, ' newline ...
|
||||
'Buffer[32:47] - выходной 1 порт, Buffer[48:63] - выходной 2 порт'];
|
||||
example = ['// запись в 1-й элемент 0-го выходного массива' newline...
|
||||
'WriteOutputArray(app_variable, 0, 1);' newline newline ...
|
||||
'// запись в буфер выходов' newline ...
|
||||
'Buffer[XD_OUTPUT_START + 10] = app_variable_2;'];
|
||||
|
||||
elseif strcmp(sel, 'App Deinit')
|
||||
% Редактирование кода деинициализации
|
||||
filename = fullfile(basePath, 'app_init.c');
|
||||
section = '// USER APP DEINIT';
|
||||
tool = ['Код для деинициализации приложения МК.' newline newline ...
|
||||
'Можно деинициализировать приложение МК, для повторного запуска.'];
|
||||
example = 'memset(&htim1, sizeof(htim1), 0;';
|
||||
|
||||
else
|
||||
% Неизвестный тип кода - выводим сообщение в консоль MATLAB
|
||||
tool = '';
|
||||
mcuMask.disp(0, '\nОшибка выбора типа секции кода: неизвестное значение');
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@ -1,103 +1,124 @@
|
||||
classdef asynchManage < handle
|
||||
% Менеджер асинхронных операций для работы с моделью Simulink
|
||||
% Решает проблемы блокировки модели при одновременном доступе из GUI
|
||||
% Использует таймеры для отложенного выполнения операций с моделью
|
||||
|
||||
properties (Access = private)
|
||||
modelName % Имя модели
|
||||
maskBlockPath % Полный путь к блоку с маской
|
||||
timerSave
|
||||
timerUpdate
|
||||
timerConfigUpdate
|
||||
modelName % Имя модели Simulink для управления
|
||||
maskBlockPath % Полный путь к блоку с маской (если нужен доступ к GUI)
|
||||
timerSave % Таймер для операции сохранения модели
|
||||
timerUpdate % Таймер для операции обновления модели
|
||||
timerConfigUpdate % Таймер для обновления конфигурации
|
||||
end
|
||||
|
||||
methods
|
||||
function obj = asynchManage(modelName, maskBlockPath)
|
||||
% Конструктор принимает имя модели и путь к блоку с маской
|
||||
% Конструктор - создает менеджер для асинхронных операций
|
||||
% modelName - имя модели Simulink для управления
|
||||
% maskBlockPath - путь к блоку с маской (опционально, для GUI)
|
||||
obj.modelName = modelName;
|
||||
if nargin < 2
|
||||
obj.maskBlockPath = ''; % если не передали, оставляем пустым
|
||||
obj.maskBlockPath = ''; % Если не передали - работаем без GUI
|
||||
else
|
||||
obj.maskBlockPath = maskBlockPath;
|
||||
end
|
||||
end
|
||||
|
||||
function saveAndUpdateModel(obj)
|
||||
% Асинхронное сохранение и обновление модели
|
||||
% Использует таймер чтобы избежать конфликтов доступа к модели
|
||||
obj.timerSave = timer(...
|
||||
'StartDelay', 0.01, ...
|
||||
'ExecutionMode', 'singleShot', ...
|
||||
'TimerFcn', @(~,~) obj.saveCallback());
|
||||
'StartDelay', 0.01, ... % Короткая задержка чтобы освободить модель
|
||||
'ExecutionMode', 'singleShot', ... % Однократное выполнение
|
||||
'TimerFcn', @(~,~) obj.saveCallback()); % Колбэк сохранения
|
||||
start(obj.timerSave);
|
||||
end
|
||||
|
||||
|
||||
function updateGUIfromConfig(obj)
|
||||
% Асинхронное обновление GUI из конфигурации
|
||||
% Используется когда нужно перезагрузить маску с новыми параметрами
|
||||
obj.timerConfigUpdate = timer(...
|
||||
'StartDelay', 0.01, ...
|
||||
'StartDelay', 0.01, ... % Задержка для стабилизации модели
|
||||
'ExecutionMode', 'singleShot', ...
|
||||
'TimerFcn', @(~,~) obj.GUIconfigCallback());
|
||||
'TimerFcn', @(~,~) obj.GUIconfigCallback()); % Колбэк обновления GUI
|
||||
start(obj.timerConfigUpdate);
|
||||
end
|
||||
end
|
||||
|
||||
methods (Access = private)
|
||||
function saveCallback(obj)
|
||||
% Колбэк для сохранения модели - вызывается через таймер
|
||||
try
|
||||
mcuMask.saveAndClose(obj.maskBlockPath);
|
||||
% Закрываем маску чтобы разблокировать модель для сохранения
|
||||
mcuMask.close(obj.maskBlockPath);
|
||||
% Сохраняем модель (это могло бы вызвать конфликт без таймера)
|
||||
save_system(obj.modelName);
|
||||
catch ME
|
||||
warning('progr:Nneg', 'Ошибка при сохранении модели: %s', ME.message);
|
||||
end
|
||||
|
||||
% Очищаем таймер сохранения
|
||||
stop(obj.timerSave);
|
||||
delete(obj.timerSave);
|
||||
obj.timerSave = [];
|
||||
|
||||
% Запускаем таймер для обновления модели после сохранения
|
||||
obj.timerUpdate = timer(...
|
||||
'StartDelay', 0.05, ...
|
||||
'StartDelay', 0.05, ... % Большая задержка для полного сохранения
|
||||
'ExecutionMode', 'singleShot', ...
|
||||
'TimerFcn', @(~,~) obj.updateCallback());
|
||||
'TimerFcn', @(~,~) obj.updateCallback()); % Колбэк обновления
|
||||
start(obj.timerUpdate);
|
||||
end
|
||||
|
||||
function updateCallback(obj)
|
||||
% Колбэк для обновления модели - вызывается после сохранения
|
||||
try
|
||||
% Команда обновления модели (перекомпиляция и т.д.)
|
||||
set_param(obj.modelName, 'SimulationCommand', 'update');
|
||||
% Повторное сохранение после обновления
|
||||
save_system(obj.modelName);
|
||||
catch ME
|
||||
warning('progr:Nneg', 'Ошибка при обновлении модели: %s', ME.message);
|
||||
end
|
||||
|
||||
% Открываем маску, если задан путь к блоку
|
||||
% Переоткрываем маску если был указан путь к блоку
|
||||
if ~isempty(obj.maskBlockPath)
|
||||
try
|
||||
mcuMask.open(obj.maskBlockPath, 1);
|
||||
mcuMask.open(obj.maskBlockPath, 1); % Открываем маску снова
|
||||
catch ME
|
||||
warning('progr:Nneg', 'Не удалось открыть маску: %s', ME.message);
|
||||
end
|
||||
end
|
||||
|
||||
% Очищаем таймер обновления
|
||||
stop(obj.timerUpdate);
|
||||
delete(obj.timerUpdate);
|
||||
obj.timerUpdate = [];
|
||||
end
|
||||
function GUIconfigCallback(obj)
|
||||
|
||||
function GUIconfigCallback(obj)
|
||||
% Колбэк для обновления GUI из конфигурации
|
||||
try
|
||||
mcuMask.saveAndClose(obj.maskBlockPath);
|
||||
mexing(0);
|
||||
% Закрываем маску и выполняем настройку (mexing)
|
||||
mcuMask.close(obj.maskBlockPath);
|
||||
mexing(0); % Функция настройки/компиляции
|
||||
catch ME
|
||||
warning('progr:Nneg', 'Ошибка при обновлении модели: %s', ME.message);
|
||||
end
|
||||
|
||||
% Открываем маску, если задан путь к блоку
|
||||
% Переоткрываем маску с обновленными параметрами
|
||||
if ~isempty(obj.maskBlockPath)
|
||||
try
|
||||
mcuMask.open(obj.maskBlockPath, 1);
|
||||
mcuMask.open(obj.maskBlockPath, 1); % Открываем обновленную маску
|
||||
catch ME
|
||||
warning('progr:Nneg', 'Не удалось открыть маску: %s', ME.message);
|
||||
end
|
||||
end
|
||||
|
||||
% Очищаем таймер обновления конфигурации
|
||||
stop(obj.timerConfigUpdate);
|
||||
delete(obj.timerConfigUpdate);
|
||||
obj.timerConfigUpdate = [];
|
||||
end
|
||||
|
||||
end
|
||||
end
|
||||
162
McuLib/m/compiler.m
Normal file
162
McuLib/m/compiler.m
Normal file
@ -0,0 +1,162 @@
|
||||
classdef compiler
|
||||
% Класс для компиляции бинарника S-Function в MATLAB
|
||||
% Управляет процессом сборки mex-файлов для Simulink
|
||||
methods(Static)
|
||||
|
||||
function compile()
|
||||
% Основная функция компиляции S-Function
|
||||
% Добавляет путь к файлам обёртки и запускает компиляцию
|
||||
addpath(mcuPath.get('wrapperPath'));
|
||||
mexing(1); % 1 - флаг компиляции
|
||||
end
|
||||
|
||||
% хз че это
|
||||
function get_availbe()
|
||||
addpath(mcuPath.get('wrapperPath'));
|
||||
mexing(1);
|
||||
end
|
||||
function choose()
|
||||
addpath(mcuPath.get('wrapperPath'));
|
||||
mexing(1);
|
||||
end
|
||||
|
||||
function updateRunBat()
|
||||
% Обновление BAT-файла для компиляции S-Function
|
||||
% Формирует списки исходных файлов и путей для включения
|
||||
|
||||
% === КОМПИЛЯЦИЯ ОСНОВНОЙ ОБЁРТКИ ===
|
||||
sources = {
|
||||
'MCU.c'
|
||||
'mcu_wrapper.c'
|
||||
};
|
||||
% Список заголовочных файлов (.h)
|
||||
includes = { '.\' };
|
||||
wrapperPath = mcuPath.get('wrapperPath');
|
||||
|
||||
% Формируем строки для BAT-файла
|
||||
wrapperSrcText = compiler.createSourcesBat('code_WRAPPER', sources, wrapperPath);
|
||||
wrapperIncText = compiler.createIncludesBat('includes_WRAPPER', includes, wrapperPath);
|
||||
|
||||
% Обновляем BAT-файл для основной обёртки
|
||||
res = compiler.updateRunMexBat(wrapperSrcText, wrapperIncText, ':: WRAPPER BAT');
|
||||
|
||||
% Если ошибка - прекращаем выполнение
|
||||
if res == 0
|
||||
return
|
||||
end
|
||||
|
||||
% === КОМПИЛЯЦИЯ ПРИЛОЖЕНИЯ ОБЁРТКИ ===
|
||||
sources = {
|
||||
'app_wrapper.c'
|
||||
'app_init.c'
|
||||
'app_io.c'
|
||||
};
|
||||
% Список заголовочных файлов (.h)
|
||||
includes = { '.\' };
|
||||
periphPath = mcuPath.get('appWrapperPath');
|
||||
|
||||
% Формируем строки для BAT-файла
|
||||
wrapperSrcText = compiler.createSourcesBat('code_APP_WRAPPER', sources, periphPath);
|
||||
wrapperIncText = compiler.createIncludesBat('includes_APP_WRAPPER', includes, periphPath);
|
||||
|
||||
% Обновляем BAT-файл для обёртки приложения
|
||||
res = compiler.updateRunMexBat(wrapperSrcText, wrapperIncText, ':: APP WRAPPER BAT');
|
||||
|
||||
% Обновляем BAT-файл для периферии
|
||||
periphConfig.updatePeriphRunMexBat();
|
||||
end
|
||||
|
||||
function res = updateRunMexBat(srcText, incText, Section)
|
||||
% Обновляет секцию в BAT-файле для компиляции mex
|
||||
% Входные параметры:
|
||||
% srcText - текст для записи set code_... (исходные файлы)
|
||||
% incText - текст для записи set includes_... (пути включения)
|
||||
% Section - секция в BAT-файле для обновления
|
||||
%
|
||||
% Возвращает:
|
||||
% res - 1 при успехе, 0 при ошибке
|
||||
% Объединяем исходные файлы и пути включения
|
||||
periphBat = [srcText '\n\n' incText];
|
||||
batPath = fullfile(mcuPath.get('wrapperPath'), 'run_mex.bat');
|
||||
res = 1; % По умолчанию - ошибка
|
||||
|
||||
try
|
||||
% Читаем текущее содержимое BAT-файла
|
||||
code = fileread(batPath);
|
||||
code = regexprep(code, '\r\n?', '\n'); % Нормализуем переводы строк
|
||||
|
||||
% Вставляем новую секцию в BAT-файл
|
||||
code = editCode.insertSection(code, Section, periphBat);
|
||||
|
||||
% Записываем обновленный BAT-файл
|
||||
fid = fopen(batPath, 'w', 'n');
|
||||
if fid == -1
|
||||
error('Не удалось открыть файл для записи');
|
||||
end
|
||||
fwrite(fid, code);
|
||||
fclose(fid);
|
||||
res = 1; % Успех
|
||||
catch ME
|
||||
% Ошибка записи в BAT-файл
|
||||
mcuMask.disp(0, '\nОшибка: неудачная запись в файл при записи файла: %s', ME.message);
|
||||
end
|
||||
end
|
||||
|
||||
function srcText = createSourcesBat(prefix_name, sources, path)
|
||||
% Создает строку с исходными файлами для BAT-файла
|
||||
% Формат: set code_WRAPPER=file1.c file2.c ...
|
||||
|
||||
srcList = {};
|
||||
if nargin >= 2 && iscell(sources)
|
||||
for i = 1:numel(sources)
|
||||
% Формируем полный путь к исходному файлу
|
||||
fullPath = fullfile(path, sources{i});
|
||||
srcList{end+1} = strrep(fullPath, '\', '\\'); % Экранирование слешей
|
||||
end
|
||||
end
|
||||
|
||||
% Формируем srcText с переносами строк и символом продолжения ^
|
||||
srcText = '';
|
||||
for i = 1:numel(srcList)
|
||||
if i < numel(srcList)
|
||||
srcText = [srcText srcList{i} '^' newline ' ']; % ^ для продолжения строки в BAT
|
||||
else
|
||||
srcText = [srcText srcList{i}]; % Последний файл без продолжения
|
||||
end
|
||||
end
|
||||
|
||||
% Добавляем префикс переменной BAT
|
||||
srcText = ['set ' prefix_name '=' srcText];
|
||||
end
|
||||
|
||||
function incText = createIncludesBat(prefix_name, includes, path)
|
||||
% Создает строку с путями включения для BAT-файла
|
||||
% Формат: set includes_WRAPPER=-I"path1" -I"path2" ...
|
||||
|
||||
incList = {};
|
||||
if nargin >= 2 && iscell(includes)
|
||||
for i = 1:numel(includes)
|
||||
% Формируем полный путь для включения
|
||||
fullPath = fullfile(path, includes{i});
|
||||
incList{end+1} = ['-I"' strrep(fullPath, '\', '\\') '"']; % Флаг include для компилятора
|
||||
end
|
||||
end
|
||||
|
||||
% Формируем incText с переносами строк и символом продолжения ^
|
||||
incText = '';
|
||||
for i = 1:numel(incList)
|
||||
if i == 1 && numel(incList) ~= 1
|
||||
incText = [incText incList{i} '^' newline]; % Первый элемент с продолжением
|
||||
elseif i < numel(incList)
|
||||
incText = [incText ' ' incList{i} '^' newline]; % Средние элементы с продолжением
|
||||
else
|
||||
incText = [incText ' ' incList{i}]; % Последний элемент без продолжения
|
||||
end
|
||||
end
|
||||
|
||||
% Добавляем префикс переменной BAT
|
||||
incText = ['set ' prefix_name '=' incText];
|
||||
end
|
||||
|
||||
end
|
||||
end
|
||||
177
McuLib/m/configJs.m
Normal file
177
McuLib/m/configJs.m
Normal file
@ -0,0 +1,177 @@
|
||||
classdef configJs
|
||||
% Класс для работы с JSON конфигурацией периферии в масках Simulink
|
||||
% Обеспечивает чтение, запись и обновление конфигов из/в JSON файлы
|
||||
|
||||
methods(Static)
|
||||
|
||||
function config = update(blockPath, config)
|
||||
% Обновляет конфигурацию значениями из маски Simulink
|
||||
% blockPath - путь к блоку с маской
|
||||
% config - структура конфигурации для обновления
|
||||
|
||||
if isempty(config)
|
||||
return;
|
||||
end
|
||||
|
||||
% Получаем маску и все её параметры
|
||||
mask = Simulink.Mask.get(blockPath);
|
||||
maskParams = mask.Parameters;
|
||||
paramNames = arrayfun(@(p) p.Name, maskParams, 'UniformOutput', false);
|
||||
|
||||
% Обрабатываем все секции периферии в конфиге
|
||||
periphs = fieldnames(config);
|
||||
for i = 1:numel(periphs)
|
||||
periph = periphs{i};
|
||||
|
||||
% Проверяем есть ли секция Defines в этой периферии
|
||||
if ~isfield(config.(periph), 'Defines')
|
||||
continue;
|
||||
end
|
||||
|
||||
% Получаем все определения (defines) для этой периферии
|
||||
defines = config.(periph).Defines;
|
||||
defNames = fieldnames(defines);
|
||||
|
||||
% Обходим все определения и обновляем их значения из маски
|
||||
for j = 1:numel(defNames)
|
||||
defPrompt = defNames{j};
|
||||
paramName = matlab.lang.makeValidName(defPrompt); % Создаем валидное имя параметра
|
||||
|
||||
% Проверяем существует ли параметр с таким именем в маске
|
||||
if ismember(paramName, paramNames)
|
||||
param = mask.getParameter(paramName);
|
||||
valStr = param.Value; % Значение как строка из маски
|
||||
|
||||
% Проверяем существует ли элемент defPrompt в структуре defines
|
||||
if isfield(defines, defPrompt)
|
||||
% Преобразуем строку из маски в соответствующий тип данных
|
||||
if strcmpi(defines.(defPrompt).Type, 'checkbox')
|
||||
% Для чекбоксов преобразуем 'on'/'off' в true/false
|
||||
config.(periph).Defines.(defPrompt).Default = strcmpi(valStr, 'on');
|
||||
elseif strcmpi(defines.(defPrompt).Type, 'edit')
|
||||
% Для текстовых полей пробуем преобразовать в число
|
||||
valNum = str2double(valStr);
|
||||
if isnan(valNum)
|
||||
% Если не число - оставляем строкой
|
||||
config.(periph).Defines.(defPrompt).Default = valStr;
|
||||
else
|
||||
% Если число - сохраняем как число
|
||||
config.(periph).Defines.(defPrompt).Default = valNum;
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
function config = read(blockPath)
|
||||
% Читает JSON конфигурацию из файла указанного в маске
|
||||
% blockPath - путь к блоку с маской
|
||||
% Возвращает структуру конфигурации или пустой массив
|
||||
|
||||
mask = Simulink.Mask.get(blockPath);
|
||||
|
||||
% Получаем путь к конфигурационному файлу из параметра маски
|
||||
pathparam = mask.getParameter('periphPath');
|
||||
config_path = pathparam.Value;
|
||||
|
||||
if ~isempty(config_path)
|
||||
% Читаем и декодируем JSON файл
|
||||
jsonText = fileread(config_path);
|
||||
config = jsondecode(jsonText);
|
||||
else
|
||||
config = [];
|
||||
end
|
||||
end
|
||||
|
||||
function write(config)
|
||||
% Записывает конфигурацию обратно в JSON файл
|
||||
% config - структура конфигурации для записи
|
||||
|
||||
if isempty(config)
|
||||
return
|
||||
end
|
||||
|
||||
% Получаем handle текущего блока и его маску
|
||||
blockHandle = gcbh;
|
||||
mask = Simulink.Mask.get(blockHandle);
|
||||
|
||||
% Получаем путь к конфигурационному файлу из маски
|
||||
pathparam = mask.getParameter('periphPath');
|
||||
config_path = pathparam.Value;
|
||||
|
||||
% Кодируем структуру в JSON с красивым форматированием
|
||||
jsonText = jsonencode(config, 'PrettyPrint', true);
|
||||
|
||||
% Записываем JSON в файл
|
||||
fid = fopen(config_path, 'w', 'n');
|
||||
if fid == -1
|
||||
error('Не удалось открыть файл periph_config.json для записи.');
|
||||
end
|
||||
fwrite(fid, jsonText, 'char');
|
||||
fclose(fid);
|
||||
end
|
||||
|
||||
function value = get_field(configStruct, targetConfig)
|
||||
% Рекурсивно ищет поле в структуре конфигурации
|
||||
% configStruct - структура для поиска
|
||||
% targetConfig - имя целевого поля
|
||||
% Возвращает значение поля или пустой массив если не найдено
|
||||
|
||||
value = [];
|
||||
fields = fieldnames(configStruct);
|
||||
|
||||
for i = 1:numel(fields)
|
||||
key = fields{i};
|
||||
if strcmp(key, targetConfig)
|
||||
% Нашли прямое совпадение
|
||||
value = configStruct.(key);
|
||||
return;
|
||||
elseif isstruct(configStruct.(key))
|
||||
% Рекурсивно ищем во вложенной структуре
|
||||
value = configJs.get_field(configStruct.(key), targetConfig);
|
||||
if ~isempty(value)
|
||||
return; % Нашли во вложенной структуре
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
% Если не нашли - возвращаем пустой массив
|
||||
if isempty(value)
|
||||
% Можно раскомментировать для отладки:
|
||||
% error('Поле "%s" не найдено в структуре.', targetConfig);
|
||||
end
|
||||
end
|
||||
|
||||
function short = get_final_name_from_prefix(prefix)
|
||||
% Извлекает короткое имя из префикса (последняя часть после '_')
|
||||
% prefix - строка с префиксом вида 'PREFIX_NAME'
|
||||
% Возвращает последнюю часть после последнего '_'
|
||||
|
||||
parts = strsplit(prefix, '_');
|
||||
short = parts{end}; % Берём последний элемент
|
||||
end
|
||||
|
||||
function value = convert_code_value(codeField)
|
||||
% Преобразует значение поля Options в строку для отображения
|
||||
% Обрабатывает разные типы данных: char, string, cell array
|
||||
|
||||
if ischar(codeField)
|
||||
value = codeField;
|
||||
elseif isstring(codeField)
|
||||
value = char(codeField);
|
||||
elseif iscell(codeField)
|
||||
% Объединяем ячейки в одну строку с переносами
|
||||
value = strjoin(codeField, newline);
|
||||
else
|
||||
% Для неподдерживаемых типов возвращаем пустую строку
|
||||
value = '';
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
methods(Static, Access=private)
|
||||
% Приватные методы могут быть добавлены здесь при необходимости
|
||||
end
|
||||
end
|
||||
@ -1,157 +1,182 @@
|
||||
classdef customtable
|
||||
% Класс для работы с таблицами в масках Simulink
|
||||
% Обеспечивает форматирование, парсинг и управление табличными данными
|
||||
% 1. Таблицы в масках Simulink хранятся как строки специального формата:
|
||||
% {'строка1';'строка2';'строка3'}
|
||||
% 2. Этот класс преобразует строковое представление в cell-массивы для удобной работы
|
||||
% 3. Обеспечивает очистку от пустых строк, форматирование колонок и массовое обновление
|
||||
|
||||
methods(Static)
|
||||
% формирование таблицы на всю ширину
|
||||
function format(table_name)
|
||||
% Форматирует таблицу в маске - настраивает колонки и внешний вид
|
||||
% table_name - имя табличного параметра в маске
|
||||
|
||||
block = gcb;
|
||||
mask = Simulink.Mask.get(block);
|
||||
tableControl = mask.getDialogControl(table_name);
|
||||
tableParameter = mask.getParameter(table_name);
|
||||
tableControl = mask.getDialogControl(table_name); % Элемент управления таблицей
|
||||
tableParameter = mask.getParameter(table_name); % Параметр с данными таблицы
|
||||
nCols = tableControl.getNumberOfColumns;
|
||||
% if nCols > 0
|
||||
% for i = 1:nCols
|
||||
% tableControl.removeColumn(1);
|
||||
% end
|
||||
% end
|
||||
% column = tableControl.addColumn(Name='Title', Type='edit');
|
||||
% tableControl.Sortable = 'on';
|
||||
|
||||
% Инициализация колонок если они пустые (после removeParameter)
|
||||
if isempty(tableControl.Columns) || (nCols > 1)
|
||||
% Удаляем все существующие колонки
|
||||
for i = 1:nCols
|
||||
tableControl.removeColumn(1);
|
||||
end
|
||||
% Создаем одну колонку по умолчанию
|
||||
column = tableControl.addColumn(Name='Title', Type='edit');
|
||||
tableControl.Sortable = 'on'; % Разрешаем сортировку
|
||||
end
|
||||
% Устанавливаем имя колонки равным алиасу параметра
|
||||
column.Name = tableParameter.Alias;
|
||||
end
|
||||
|
||||
|
||||
function update(tableName)
|
||||
% Обновляет таблицу - удаляет пустые строки и сохраняет изменения
|
||||
% tableName - имя табличного параметра для обновления
|
||||
|
||||
block = gcb;
|
||||
mask = Simulink.Mask.get(block);
|
||||
Table = mask.getParameter(tableName);
|
||||
|
||||
% Парсим текущее содержимое таблицы
|
||||
cellArray = customtable.parse(tableName);
|
||||
% Удаляем пустые строки
|
||||
cleaned = customtable.removeEmptyRows(cellArray);
|
||||
|
||||
% Если были удалены пустые строки - сохраняем изменения
|
||||
if numel(cleaned) ~= numel(cellArray)
|
||||
% Обрамляем каждую строку в кавычки и формируем новое значение
|
||||
quoted = cellfun(@(s) ['''' s ''''], cleaned, 'UniformOutput', false);
|
||||
newStr = ['{' strjoin(quoted, ';') '}'];
|
||||
Table.Value = newStr;
|
||||
Table.Value = newStr; % Сохраняем обратно в параметр
|
||||
end
|
||||
end
|
||||
|
||||
function column_titles = save_all_tables(table_names)
|
||||
% Очищает столбцы в каждой таблице из массива имен table_names
|
||||
% Возвращает cell-массив с названиями первых столбцов каждой таблицы
|
||||
block = gcb;
|
||||
% Сохраняет и очищает несколько таблиц одновременно
|
||||
% table_names - cell-массив с именами таблиц
|
||||
% Возвращает массив с названиями первых колонок каждой таблицы
|
||||
|
||||
% Получить объект маски блока
|
||||
block = gcb;
|
||||
maskObj = Simulink.Mask.get(block);
|
||||
|
||||
% Инициализировать cell-массив для хранения названий столбцов
|
||||
% Инициализируем массив для хранения названий колонок
|
||||
column_titles = cell(size(table_names));
|
||||
|
||||
for k = 1:numel(table_names)
|
||||
table_name = table_names{k};
|
||||
|
||||
% Получить объект управления таблицей
|
||||
tableControl = maskObj.getDialogControl(table_name);
|
||||
|
||||
% Получить количество столбцов
|
||||
nCols = tableControl.getNumberOfColumns;
|
||||
|
||||
if nCols > 0
|
||||
% Получить первый столбец (который будем удалять)
|
||||
% Сохраняем название первой колонки
|
||||
column = tableControl.getColumn(1);
|
||||
column_titles{k} = column.Name;
|
||||
|
||||
% Удаляем все столбцы
|
||||
% Важно: при удалении столбцов индексы меняются,
|
||||
% поэтому удаляем всегда первый столбец nCols раз
|
||||
% Удаляем все колонки (всегда удаляем первую, т.к. индексы сдвигаются)
|
||||
for i = 1:nCols
|
||||
tableControl.removeColumn(1);
|
||||
end
|
||||
else
|
||||
% Если столбцов нет, возвращаем пустую строку
|
||||
column_titles{k} = '';
|
||||
column_titles{k} = ''; % Если колонок нет
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
function restore_all_tables(table_names, column_titles)
|
||||
% Восстанавливает первый столбец в каждой таблице из массива имен
|
||||
% Использует массив column_titles для установки имени столбца
|
||||
block = gcb;
|
||||
% Восстанавливает таблицы с сохраненными названиями колонок
|
||||
% table_names - имена таблиц для восстановления
|
||||
% column_titles - массив с названиями для первых колонок
|
||||
|
||||
% Получить объект маски блока
|
||||
block = gcb;
|
||||
maskObj = Simulink.Mask.get(block);
|
||||
|
||||
for k = 1:numel(table_names)
|
||||
table_name = table_names{k};
|
||||
title = column_titles{k};
|
||||
|
||||
% Получить объект управления таблицей
|
||||
tableControl = maskObj.getDialogControl(table_name);
|
||||
|
||||
% Добавить новый столбец
|
||||
% Добавляем новую колонку с сохраненным названием
|
||||
column = tableControl.addColumn(Name='title', Type='edit');
|
||||
column.Name = title;
|
||||
end
|
||||
end
|
||||
|
||||
|
||||
function out = parse(tableName)
|
||||
% Парсит содержимое таблицы из строкового параметра в cell-массив
|
||||
% tableName - имя табличного параметра
|
||||
% Возвращает cell-массив со строками таблицы
|
||||
|
||||
block = gcb;
|
||||
TableStr = get_param(block, tableName);
|
||||
out = customtable.parse__(TableStr);
|
||||
TableStr = get_param(block, tableName); % Получаем строковое представление
|
||||
out = customtable.parse__(TableStr); % Парсим во внутреннем методе
|
||||
end
|
||||
|
||||
function collect(tableName, cellArray)
|
||||
% Сохраняет cell-массив обратно в табличный параметр
|
||||
% tableName - имя параметра для сохранения
|
||||
% cellArray - cell-массив с данными таблицы
|
||||
|
||||
block = gcb;
|
||||
newTableStr = customtable.collect__(cellArray);
|
||||
% Записываем обратно в параметр маски
|
||||
set_param(block, tableName, newTableStr);
|
||||
newTableStr = customtable.collect__(cellArray); % Конвертируем в строку
|
||||
set_param(block, tableName, newTableStr); % Сохраняем в параметр
|
||||
end
|
||||
end
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
methods(Static, Access=private)
|
||||
|
||||
function out = parse__(tableStr)
|
||||
% Внутренний метод для парсинга строки таблицы в cell-массив
|
||||
% tableStr - строковое представление таблицы в формате {'str1';'str2'}
|
||||
|
||||
str = strtrim(tableStr);
|
||||
% Удаляем обрамляющие фигурные скобки если есть
|
||||
if startsWith(str, '{') && endsWith(str, '}')
|
||||
str = str(2:end-1);
|
||||
end
|
||||
|
||||
% Разбиваем по разделителю строк ;
|
||||
parts = split(str, ';');
|
||||
out = cell(numel(parts), 1);
|
||||
for i = 1:numel(parts)
|
||||
el = strtrim(parts{i});
|
||||
% Удаляем обрамляющие кавычки если есть
|
||||
if startsWith(el, '''') && endsWith(el, '''')
|
||||
el = el(2:end-1);
|
||||
end
|
||||
out{i} = el;
|
||||
end
|
||||
|
||||
% Обработка пустых таблиц
|
||||
if isempty(out) || (numel(out) == 1 && isempty(out{1}))
|
||||
out = {};
|
||||
end
|
||||
end
|
||||
|
||||
|
||||
function tableStr = collect__(cellArray)
|
||||
% Внутренний метод для конвертации cell-массива в строку таблицы
|
||||
% cellArray - входной cell-массив
|
||||
% Возвращает строку в формате {'str1';'str2'}
|
||||
|
||||
% Обрамляем каждую строку в кавычки
|
||||
quoted = cellfun(@(s) ['''' s ''''], cellArray, 'UniformOutput', false);
|
||||
tableStr = ['{' strjoin(quoted, ';') '}'];
|
||||
tableStr = ['{' strjoin(quoted, ';') '}']; % Объединяем в формат таблицы
|
||||
end
|
||||
|
||||
|
||||
function cleaned = removeEmptyRows(cellArray)
|
||||
% Удаляет пустые строки из cell-массива
|
||||
% cellArray - входной массив данных таблицы
|
||||
% Возвращает очищенный массив без пустых строк
|
||||
|
||||
if isempty(cellArray)
|
||||
cleaned = {};
|
||||
else
|
||||
% Проверяем каждую строку, есть ли в ней содержимое (не пустая строка)
|
||||
% Определяем какие строки пустые (после удаления пробелов)
|
||||
isEmptyRow = cellfun(@(s) isempty(strtrim(s)), cellArray);
|
||||
cleaned = cellArray(~isEmptyRow);
|
||||
cleaned = cellArray(~isEmptyRow); % Фильтруем пустые строки
|
||||
end
|
||||
end
|
||||
|
||||
end
|
||||
|
||||
end
|
||||
@ -1,60 +1,71 @@
|
||||
classdef editCode
|
||||
% Класс для редактирования кода C/C++ в текстовых файлах
|
||||
% Обеспечивает извлечение и вставку кода в секции и функции
|
||||
|
||||
methods(Static)
|
||||
|
||||
function newCode = insertSection(code, sectionName, newText)
|
||||
% insertSection – вставка или замена содержимого секции или тела функции
|
||||
% Вставка или замена содержимого секции или тела функции
|
||||
%
|
||||
% Аргументы:
|
||||
% code – исходный текст (строка)
|
||||
% sectionName – имя секции (например, 'MY_SECTION') или заголовок функции (например, 'void myFunc(...)')
|
||||
% newText – новый текст, который будет вставлен внутрь секции или функции
|
||||
% code - исходный текст кода как строка
|
||||
% sectionName - имя секции (например, 'MY_SECTION') или
|
||||
% заголовок функции (например, 'void myFunc(...)')
|
||||
% newText - новый текст для вставки внутрь секции или функции
|
||||
%
|
||||
% Возвращает:
|
||||
% newCode – обновлённый текст с подставленным содержимым
|
||||
% newCode - обновлённый текст с подставленным содержимым
|
||||
%
|
||||
% Особенности:
|
||||
% - Если sectionName начинается с 'void ', считается что это функция, и вставка происходит внутрь её тела.
|
||||
% - В остальных случаях ищется секция между маркерами "<NAME> START" и "<NAME> END", и она заменяется на newText.
|
||||
% - Если sectionName начинается с 'void ', считается что это функция,
|
||||
% и вставка происходит внутрь её тела
|
||||
% - Для секций ищется блок между маркерами "NAME START" и "NAME END"
|
||||
% - Поддерживает функции с параметрами и вложенными скобками
|
||||
|
||||
newCode = code;
|
||||
|
||||
% Если это функция
|
||||
% Обработка функций (если sectionName начинается с 'void ')
|
||||
if startsWith(strtrim(sectionName), 'void ')
|
||||
% Извлекаем имя функции из заголовка
|
||||
tokens = regexp(sectionName, 'void\s+(\w+)\s*\(', 'tokens');
|
||||
if isempty(tokens)
|
||||
return;
|
||||
return; % Не удалось извлечь имя функции
|
||||
end
|
||||
funcName = tokens{1}{1};
|
||||
|
||||
% Ищем начало функции в коде
|
||||
expr = sprintf('void\\s+%s\\s*\\(.*?\\)\\s*\\{', funcName);
|
||||
startIdx = regexp(code, expr, 'start');
|
||||
if isempty(startIdx)
|
||||
return;
|
||||
return; % Функция не найдена
|
||||
end
|
||||
|
||||
% Найдём тело функции с учётом вложенных скобок
|
||||
% Находим тело функции с учётом вложенных фигурных скобок
|
||||
from = startIdx(1);
|
||||
braceCount = 0;
|
||||
braceCount = 0; % Счётчик уровня вложенности скобок
|
||||
i = from;
|
||||
while i <= length(code)
|
||||
if code(i) == '{'
|
||||
braceCount = braceCount + 1;
|
||||
if braceCount == 1
|
||||
bodyStart = i + 1;
|
||||
bodyStart = i + 1; % Начало тела функции (после {)
|
||||
end
|
||||
elseif code(i) == '}'
|
||||
braceCount = braceCount - 1;
|
||||
if braceCount == 0
|
||||
bodyEnd = i - 1;
|
||||
bodyEnd = i - 1; % Конец тела функции (перед })
|
||||
break;
|
||||
end
|
||||
end
|
||||
i = i + 1;
|
||||
end
|
||||
|
||||
% Проверяем что все скобки закрыты
|
||||
if braceCount ~= 0
|
||||
return;
|
||||
return; % Несбалансированные скобки
|
||||
end
|
||||
|
||||
% Собираем новый код: начало до тела + новый текст + конец после тела
|
||||
newCode = [ ...
|
||||
code(1:bodyStart-1), ...
|
||||
newline, newText, newline, ...
|
||||
@ -63,111 +74,113 @@ classdef editCode
|
||||
return;
|
||||
end
|
||||
|
||||
% Иначе это обычная секция
|
||||
% Формируем шаблон с группами для поиска нужного блока
|
||||
% Обработка обычных секций (не функций)
|
||||
% Формируем шаблон для поиска секции: начало, содержимое, конец
|
||||
pattern = sprintf('(%s START\\s*\\n)(.*?)(\\s*%s END)', sectionName, sectionName);
|
||||
|
||||
% Проверяем, есть ли совпадение
|
||||
% Проверяем наличие секции в коде
|
||||
startIdx = regexp(code, pattern, 'start', 'once');
|
||||
if isempty(startIdx)
|
||||
error('Секция "%s" не найдена в тексте.', sectionName);
|
||||
end
|
||||
|
||||
% Формируем новую секцию с нужным текстом
|
||||
% 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 – исходный текст (строка)
|
||||
% sectionName – имя секции (например, 'MY_SECTION') или заголовок функции (например, 'void myFunc(...)')
|
||||
% code - исходный текст кода как строка
|
||||
% sectionName - имя секции (например, 'MY_SECTION') или
|
||||
% заголовок функции (например, 'void myFunc(...)')
|
||||
%
|
||||
% Возвращает:
|
||||
% result – извлечённый текст из секции или тела функции
|
||||
% result - извлечённый текст из секции или тела функции
|
||||
%
|
||||
% Особенности:
|
||||
% - Если sectionName начинается с 'void ', считается что это функция, и извлекается содержимое её тела.
|
||||
% - В остальных случаях ищется секция между маркерами "<NAME> START" и "<NAME> END".
|
||||
% - Для функций извлекает содержимое между { и } с учётом вложенности
|
||||
% - Для секций извлекает текст между маркерами START и END
|
||||
% - Сохращает оригинальные отступы и форматирование
|
||||
|
||||
result = '';
|
||||
% Если это функция (начинается с 'void ')
|
||||
|
||||
% Обработка функций (если sectionName начинается с 'void ')
|
||||
if startsWith(strtrim(sectionName), 'void ')
|
||||
% Получаем имя функции из заголовка
|
||||
% Извлекаем имя функции из заголовка
|
||||
tokens = regexp(sectionName, 'void\s+(\w+)\s*\(', 'tokens');
|
||||
if isempty(tokens)
|
||||
return;
|
||||
return; % Не удалось извлечь имя функции
|
||||
end
|
||||
funcName = tokens{1}{1};
|
||||
|
||||
% Строим шаблон начала функции
|
||||
% Ищем начало функции в коде
|
||||
expr = sprintf('void\\s+%s\\s*\\(.*?\\)\\s*\\{', funcName);
|
||||
startIdx = regexp(code, expr, 'start');
|
||||
if isempty(startIdx)
|
||||
return;
|
||||
return; % Функция не найдена
|
||||
end
|
||||
|
||||
% Поиск тела функции с учётом вложенных скобок
|
||||
% Находим тело функции с учётом вложенных фигурных скобок
|
||||
from = startIdx(1);
|
||||
braceCount = 0;
|
||||
braceCount = 0; % Счётчик уровня вложенности скобок
|
||||
i = from;
|
||||
while i <= length(code)
|
||||
if code(i) == '{'
|
||||
braceCount = braceCount + 1;
|
||||
if braceCount == 1
|
||||
% Найдём первую новую строку после {
|
||||
braceOpenIdx = i;
|
||||
braceOpenIdx = i; % Позиция открывающей скобки
|
||||
end
|
||||
elseif code(i) == '}'
|
||||
braceCount = braceCount - 1;
|
||||
if braceCount == 0
|
||||
braceCloseIdx = i;
|
||||
braceCloseIdx = i; % Позиция закрывающей скобки
|
||||
break;
|
||||
end
|
||||
end
|
||||
i = i + 1;
|
||||
end
|
||||
|
||||
% Проверяем что все скобки закрыты
|
||||
if braceCount ~= 0
|
||||
return;
|
||||
return; % Несбалансированные скобки
|
||||
end
|
||||
|
||||
% Найдём \n после {
|
||||
% Находим первую новую строку после открывающей скобки {
|
||||
newlineAfterOpen = regexp(code(braceOpenIdx:end), '\n', 'once');
|
||||
if isempty(newlineAfterOpen)
|
||||
return;
|
||||
return; % Не найден перевод строки
|
||||
end
|
||||
bodyStart = braceOpenIdx + newlineAfterOpen;
|
||||
bodyStart = braceOpenIdx + newlineAfterOpen; % Начало тела функции
|
||||
|
||||
% Найдём \n до }
|
||||
% Находим последнюю новую строку перед закрывающей скобкой }
|
||||
newlinesBeforeClose = regexp(code(1:braceCloseIdx), '\n');
|
||||
if isempty(newlinesBeforeClose)
|
||||
return;
|
||||
return; % Не найдены переводы строк
|
||||
end
|
||||
bodyEnd = newlinesBeforeClose(end) - 1;
|
||||
bodyEnd = newlinesBeforeClose(end) - 1; % Конец тела функции
|
||||
|
||||
% Извлекаем блок как есть, включая отступы
|
||||
% Извлекаем тело функции с сохранением форматирования
|
||||
result = code(bodyStart:bodyEnd);
|
||||
return;
|
||||
end
|
||||
|
||||
% Иначе считаем, что это секция вида // NAME START ... // NAME END
|
||||
% Обработка обычных секций (не функций)
|
||||
% Ищем секцию между маркерами START и END
|
||||
pattern = sprintf('%s START\\s*\\n(.*?)\n%s END', sectionName, sectionName);
|
||||
|
||||
% Извлекаем содержимое секции
|
||||
match = regexp(code, pattern, 'tokens', 'dotall');
|
||||
if ~isempty(match)
|
||||
result = match{1}{1};
|
||||
result = match{1}{1}; % Возвращаем содержимое секции
|
||||
else
|
||||
% Секция не найдена - выводим сообщение об ошибке
|
||||
mcuMask.disp(0, 'Ошибка: cекция "%s" не найдена в тексте.', sectionName);
|
||||
end
|
||||
end
|
||||
|
||||
|
||||
end
|
||||
end
|
||||
@ -1,5 +1,5 @@
|
||||
function installTemplates(forceCopy)
|
||||
% installTemplates Копирует содержимое папки templates (включая вложенные папки) из уровня выше McuLib.slx в текущую папку
|
||||
% installTemplates Копирует содержимое папки templates (включая вложенные папки) из библиотеки (McuLib.slx) в текущую папку
|
||||
%
|
||||
% installTemplates(forceCopy)
|
||||
%
|
||||
|
||||
287
McuLib/m/mainConfig.m
Normal file
287
McuLib/m/mainConfig.m
Normal file
@ -0,0 +1,287 @@
|
||||
classdef mainConfig
|
||||
% Класс для экспорта и импорта конфигурации маски Simulink в JSON
|
||||
% Позволяет сохранять и загружать настройки блока между сессиями
|
||||
|
||||
methods(Static)
|
||||
|
||||
function config = export()
|
||||
% Экспортирует текущую конфигурацию маски в JSON файл
|
||||
% Сохраняет параметры обёртки, портов и приложения
|
||||
|
||||
blockPath = gcb;
|
||||
mask = Simulink.Mask.get(blockPath);
|
||||
|
||||
% Списки параметров для экспорта по категориям
|
||||
wrapParamToExport = {'wrapperPath', 'enableDebug', 'mcuClk', ...
|
||||
'threadCycles', 'enableThreading', 'enableDeinit', ...
|
||||
'periphPath'};
|
||||
portParamToExport = {'inNumb', ...
|
||||
'in_port_1_name', 'in_port_1_width', ...
|
||||
'in_port_2_name', 'in_port_2_width', ...
|
||||
'in_port_3_name', 'in_port_3_width', ...
|
||||
'in_port_4_name', 'in_port_4_width', ...
|
||||
'in_port_5_name', 'in_port_5_width', ...
|
||||
'outNumb', ...
|
||||
'out_port_1_name', 'out_port_1_width', ...
|
||||
'out_port_2_name', 'out_port_2_width', ...
|
||||
'out_port_3_name', 'out_port_3_width', ...
|
||||
'out_port_4_name', 'out_port_4_width', ...
|
||||
'out_port_5_name', 'out_port_5_width',};
|
||||
appParamToExport = {'appWrapperPath', 'srcTable', 'incTable', 'userDefs'};
|
||||
|
||||
% Создаем структуру для конфигурации
|
||||
config = struct();
|
||||
|
||||
% Экспортируем параметры обёртки
|
||||
for i = 1:numel(wrapParamToExport)
|
||||
paramName = wrapParamToExport{i};
|
||||
def = mainConfig.exportParamToConfig(mask, paramName);
|
||||
config.(paramName) = def;
|
||||
end
|
||||
|
||||
% Экспортируем параметры портов
|
||||
for i = 1:numel(portParamToExport)
|
||||
paramName = portParamToExport{i};
|
||||
def = mainConfig.exportParamToConfig(mask, paramName);
|
||||
config.(paramName) = def;
|
||||
end
|
||||
|
||||
% Экспортируем параметры приложения
|
||||
for i = 1:numel(appParamToExport)
|
||||
paramName = appParamToExport{i};
|
||||
def = mainConfig.exportParamToConfig(mask, paramName);
|
||||
config.(paramName) = def;
|
||||
end
|
||||
|
||||
% Кодируем структуру в JSON с форматированием
|
||||
jsonStr = jsonencode(config, 'PrettyPrint', true);
|
||||
|
||||
% Диалог сохранения файла
|
||||
[file, path] = uiputfile('*.json', 'Сохранить конфигурацию как', 'WrapperConfig.json');
|
||||
if isequal(file, 0) || isequal(path, 0)
|
||||
disp('Сохранение отменено пользователем.');
|
||||
return;
|
||||
end
|
||||
|
||||
filepath = fullfile(path, file);
|
||||
|
||||
% Сохраняем в файл
|
||||
fid = fopen(filepath, 'w');
|
||||
if fid == -1
|
||||
mcuMask.disp(0, 'Не удалось открыть файл для записи: %s', filename);
|
||||
end
|
||||
|
||||
fwrite(fid, jsonStr, 'char');
|
||||
fclose(fid);
|
||||
end
|
||||
|
||||
function import()
|
||||
% Импортирует конфигурацию маски из JSON файла
|
||||
% Восстанавливает параметры обёртки, портов и приложения
|
||||
|
||||
% Получаем путь к текущему блоку
|
||||
blockPath = gcb;
|
||||
mask = Simulink.Mask.get(blockPath);
|
||||
|
||||
% Выбор JSON-файла через диалоговое окно
|
||||
[file, path] = uigetfile('*.json', 'Выберите файл конфигурации');
|
||||
if isequal(file, 0)
|
||||
mcuMask.disp(0, 'Импорт отменён пользователем.');
|
||||
return;
|
||||
end
|
||||
|
||||
fullpath = fullfile(path, file);
|
||||
|
||||
% Чтение и декодирование JSON
|
||||
try
|
||||
jsonStr = fileread(fullpath);
|
||||
config = jsondecode(jsonStr);
|
||||
catch err
|
||||
mcuMask.disp(0, 'Ошибка при чтении или разборе JSON: %s', err.message);
|
||||
end
|
||||
|
||||
% Применение параметров из конфигурации
|
||||
paramNames = fieldnames(config);
|
||||
for i = 1:numel(paramNames)
|
||||
paramName = paramNames{i};
|
||||
def = config.(paramName);
|
||||
|
||||
try
|
||||
mainConfig.applyDefToMask(mask, paramName, def);
|
||||
catch err
|
||||
mcuMask.disp(0, 'Ошибка при применении параметра "%s": %s', paramName, err.message);
|
||||
end
|
||||
end
|
||||
|
||||
mcuMask.disp(0, 'Конфигурация успешно импортирована.');
|
||||
|
||||
% Обновляем периферию после импорта
|
||||
mcuMask.periphUpdate();
|
||||
end
|
||||
|
||||
end
|
||||
|
||||
methods(Static, Access=private)
|
||||
|
||||
function def = exportParamToConfig(mask, paramName)
|
||||
% Экспортирует один параметр маски в структуру для JSON
|
||||
% mask - объект маски Simulink
|
||||
% paramName - имя параметра для экспорта
|
||||
% Возвращает структуру с описанием параметра
|
||||
|
||||
param = mask.getParameter(paramName);
|
||||
if isempty(param)
|
||||
mcuMask.disp(0, 'Параметр "%s" не найден в маске.', paramName);
|
||||
def = [];
|
||||
return;
|
||||
end
|
||||
|
||||
def = struct();
|
||||
|
||||
% Сохраняем подпись параметра
|
||||
def.Prompt = param.Prompt;
|
||||
|
||||
% Сохраняем тип параметра
|
||||
def.Type = param.Type;
|
||||
|
||||
% Сохраняем значение в зависимости от типа
|
||||
val = param.Value;
|
||||
switch lower(param.Type)
|
||||
case 'checkbox'
|
||||
% Для чекбоксов преобразуем 'on'/'off' в true/false
|
||||
def.Default = strcmp(val, 'on');
|
||||
case {'edit', 'spinbox'}
|
||||
% Для числовых полей пробуем преобразовать в число
|
||||
num = str2double(val);
|
||||
if ~isnan(num)
|
||||
def.Default = num;
|
||||
else
|
||||
def.Default = val; % Оставляем строкой если не число
|
||||
end
|
||||
case 'customtable'
|
||||
% Для таблиц парсим содержимое в cell-массив
|
||||
def.Default = customtable.parse(param.Name);
|
||||
case 'text'
|
||||
% Для текстовых полей сохраняем пустую строку
|
||||
def.Default = '';
|
||||
otherwise
|
||||
% Для остальных типов сохраняем как есть
|
||||
def.Default = val;
|
||||
end
|
||||
|
||||
% Сохраняем алиас если есть
|
||||
if ~isempty(param.Alias)
|
||||
def.Def = param.Alias;
|
||||
end
|
||||
end
|
||||
|
||||
function applyDefToMask(mask, paramName, def)
|
||||
% Применяет параметр из конфигурации к маске
|
||||
% mask - объект маски Simulink
|
||||
% paramName - имя параметра для применения
|
||||
% def - структура с данными параметра
|
||||
|
||||
% Получаем параметр из маски
|
||||
param = mask.getParameter(paramName);
|
||||
if isempty(param)
|
||||
mcuMask.disp(0, 'Параметр "%s" не найден в маске.', paramName);
|
||||
return;
|
||||
end
|
||||
|
||||
if isempty(def)
|
||||
mcuMask.disp(0, 'Параметр "%s" не найден в конфиге.', paramName);
|
||||
return;
|
||||
end
|
||||
|
||||
% Устанавливаем значение в зависимости от типа параметра
|
||||
switch lower(def.Type)
|
||||
case 'checkbox'
|
||||
% Устанавливаем состояние чекбокса
|
||||
if islogical(def.Default)
|
||||
param.Value = mainConfig.ternary(def.Default, 'on', 'off');
|
||||
else
|
||||
mcuMask.disp(0, 'Ожидалось логическое значение для checkbox "%s".', paramName);
|
||||
end
|
||||
|
||||
case {'edit', 'spinbox'}
|
||||
% Устанавливаем значение для текстового поля
|
||||
if isnumeric(def.Default)
|
||||
param.Value = num2str(def.Default);
|
||||
elseif ischar(def.Default) || isstring(def.Default)
|
||||
param.Value = char(def.Default);
|
||||
else
|
||||
mcuMask.disp(0, 'Некорректный формат значения для edit "%s".', paramName);
|
||||
end
|
||||
|
||||
case 'customtable'
|
||||
% Загружаем данные в таблицу
|
||||
if iscell(def.Default)
|
||||
customtable.collect(paramName, def.Default);
|
||||
else
|
||||
mcuMask.disp(0, 'customtable "%s" требует cell-массив строк.', paramName);
|
||||
end
|
||||
|
||||
case 'text'
|
||||
% Устанавливаем текстовое значение
|
||||
if ischar(def.Default) || isstring(def.Default)
|
||||
param.Value = char(def.Default);
|
||||
else
|
||||
mcuMask.disp(0, 'text-параметр "%s" должен быть строкой.', paramName);
|
||||
end
|
||||
|
||||
case 'popup'
|
||||
% Устанавливаем значение выпадающего списка
|
||||
if ischar(def.Default) && isfield(def, 'Def') && any(strcmp(def.Default, def.Def))
|
||||
param.Value = def.Default;
|
||||
else
|
||||
mcuMask.disp(0, 'popup-параметр "%s" имеет неверное значение или список.', paramName);
|
||||
end
|
||||
|
||||
otherwise
|
||||
% Универсальная установка значения
|
||||
if ischar(def.Default) || isstring(def.Default)
|
||||
param.Value = char(def.Default);
|
||||
elseif isnumeric(def.Default)
|
||||
param.Value = num2str(def.Default);
|
||||
else
|
||||
mcuMask.disp(0, 'Неизвестный формат значения параметра "%s".', paramName);
|
||||
end
|
||||
end
|
||||
|
||||
% Обновляем подпись параметра если есть
|
||||
if isfield(def, 'Prompt')
|
||||
param.Prompt = def.Prompt;
|
||||
end
|
||||
|
||||
% Обновляем алиас если есть
|
||||
if isfield(def, 'Def') && ischar(def.Def)
|
||||
param.Alias = def.Def;
|
||||
end
|
||||
|
||||
% % Установка Row, если поддерживается
|
||||
% if isfield(def, 'NewRow')
|
||||
% try
|
||||
% if def.NewRow
|
||||
% param.DialogControl.Row = 'new';
|
||||
% else
|
||||
% param.DialogControl.Row = 'current';
|
||||
% end
|
||||
% catch
|
||||
% % Некоторым типам параметров Row может быть неприменим
|
||||
% end
|
||||
% end
|
||||
end
|
||||
|
||||
function result = ternary(cond, a, b)
|
||||
% Вспомогательная функция - тернарный оператор
|
||||
% cond - условие, a - значение если true, b - значение если false
|
||||
if cond
|
||||
result = a;
|
||||
else
|
||||
result = b;
|
||||
end
|
||||
end
|
||||
|
||||
end
|
||||
|
||||
end
|
||||
72
McuLib/m/mainWrap.m
Normal file
72
McuLib/m/mainWrap.m
Normal file
@ -0,0 +1,72 @@
|
||||
classdef mainWrap
|
||||
|
||||
methods(Static)
|
||||
function enableThreading()
|
||||
block = gcb;
|
||||
maskNames = get_param(block, 'MaskNames');
|
||||
maskValues = get_param(block, 'MaskValues');
|
||||
maskEnables = get_param(block, 'MaskEnables');
|
||||
idxEnable = find(strcmp(maskNames, 'enableThreading'));
|
||||
idxEdit = find(strcmp(maskNames, 'threadCycles'));
|
||||
if isempty(idxEnable) || isempty(idxEdit)
|
||||
error('Параметры enableThreading или threadCycles не найдены в маске');
|
||||
end
|
||||
val = maskValues{idxEnable};
|
||||
if strcmp(val, 'on')
|
||||
maskEnables{idxEdit} = 'on';
|
||||
else
|
||||
maskEnables{idxEdit} = 'off';
|
||||
end
|
||||
set_param(block, 'MaskEnables', maskEnables);
|
||||
end
|
||||
|
||||
function enableDeinit()
|
||||
block = gcb;
|
||||
maskNames = get_param(block, 'MaskNames');
|
||||
maskValues = get_param(block, 'MaskValues');
|
||||
maskEnables = get_param(block, 'MaskEnables');
|
||||
idxEnable = find(strcmp(maskNames, 'enableThreading'));
|
||||
idxEdit = find(strcmp(maskNames, 'threadCycles'));
|
||||
if isempty(idxEnable) || isempty(idxEdit)
|
||||
error('Параметры enableThreading или threadCycles не найдены в маске');
|
||||
end
|
||||
val = maskValues{idxEnable};
|
||||
if strcmp(val, 'on')
|
||||
maskEnables{idxEdit} = 'on';
|
||||
else
|
||||
maskEnables{idxEdit} = 'off';
|
||||
end
|
||||
set_param(block, 'MaskEnables', maskEnables);
|
||||
end
|
||||
|
||||
function extConsol()
|
||||
block = gcb;
|
||||
mask = Simulink.Mask.get(block);
|
||||
fullOut = mask.getParameter('fullOutput');
|
||||
extCons = mask.getParameter('extConsol');
|
||||
if isempty(extCons) || isempty(fullOut)
|
||||
error('Параметры fullOutput или extConsol не найдены в маске');
|
||||
end
|
||||
|
||||
if(strcmp(extCons.Enabled, 'on'))
|
||||
if strcmp(extCons.Value, 'on')
|
||||
fullOut.Enabled = 'off';
|
||||
fullOut.Value = 'on';
|
||||
else
|
||||
fullOut.Enabled = 'on';
|
||||
end
|
||||
else
|
||||
fullOut.Enabled = 'on';
|
||||
end
|
||||
|
||||
end
|
||||
|
||||
end
|
||||
|
||||
|
||||
%% SPECIFIC TOOLS
|
||||
methods(Static, Access = private)
|
||||
|
||||
end
|
||||
|
||||
end
|
||||
@ -1,347 +1,173 @@
|
||||
classdef mcuMask
|
||||
% Главный класс управления маской блока Simulink для микроконтроллера
|
||||
% Содержит callback-функции и утилиты для работы с маской
|
||||
|
||||
%% CALLBACKS - функции обратного вызова для элементов маски
|
||||
methods(Static)
|
||||
% Following properties of 'maskInitContext' are avalaible to use:
|
||||
% - BlockHandle
|
||||
% - MaskObject
|
||||
% - MaskWorkspace - Use get/set APIs to work with mask workspace.
|
||||
% Функция инициализации маски - вызывается при загрузке блока
|
||||
function MaskInitialization(maskInitContext)
|
||||
% Получаем хэндл текущего блока
|
||||
blk = gcbh;
|
||||
set_param(blk,"MaskSelfModifiable","on")
|
||||
set_param(blk, 'LinkStatus', 'none');
|
||||
% Получаем объект маски текущего блока
|
||||
mask = Simulink.Mask.get(gcb);
|
||||
% mcuMask.disp(1,'');
|
||||
|
||||
% Разрешаем самомодификацию маски и отключаем ссылки
|
||||
set_param(blk,"MaskSelfModifiable","on")
|
||||
set_param(blk, 'LinkStatus', 'none');
|
||||
|
||||
% Проверяем доступность findjobj для внешней консоли
|
||||
try
|
||||
% Проверка наличия findjobj
|
||||
findjobjAvailable = exist('findjobj', 'file') == 2;
|
||||
catch
|
||||
findjobjAvailable = false;
|
||||
end
|
||||
% Получаем объект маски текущего блока
|
||||
mask = Simulink.Mask.get(gcb);
|
||||
% Имя checkbox-параметра (укажите точное имя из маски)
|
||||
checkboxParamName = 'extConsol'; % пример
|
||||
findjobjLinkName = 'findjobj_link'; % пример
|
||||
% Получаем параметр по имени
|
||||
|
||||
% Настраиваем параметры внешней консоли в зависимости от доступности findjobj
|
||||
checkboxParamName = 'extConsol';
|
||||
findjobjLinkName = 'findjobj_link';
|
||||
|
||||
checkboxParam = mask.getParameter(checkboxParamName);
|
||||
findjobjLink = mask.getDialogControl(findjobjLinkName);
|
||||
|
||||
if isempty(findjobjLink)
|
||||
error('Параметр %s не найден в маске.', findjobjLinkName);
|
||||
end
|
||||
if isempty(checkboxParam)
|
||||
error('Параметр %s не найден в маске.', checkboxParamName);
|
||||
end
|
||||
% Блокируем чекбокс, если findjobj не найден
|
||||
|
||||
% Блокируем чекбокс если findjobj не найден
|
||||
if ~findjobjAvailable
|
||||
checkboxParam.Enabled = 'off';
|
||||
checkboxParam.Value = 'off'; % и на всякий случай снимаем галочку
|
||||
checkboxParam.Value = 'off';
|
||||
checkboxParam.Prompt = 'External Console (requires findjobj)';
|
||||
findjobjLink.Visible = 'on';
|
||||
findjobjLink.Visible = 'on'; % Показываем ссылку для скачивания
|
||||
else
|
||||
checkboxParam.Enabled = 'on';
|
||||
checkboxParam.Prompt = 'External Console';
|
||||
findjobjLink.Visible = 'off';
|
||||
findjobjLink.Visible = 'off'; % Скрываем ссылку
|
||||
end
|
||||
% формирование таблицы на всю ширину
|
||||
|
||||
% Форматируем таблицы исходных файлов и инклюдов
|
||||
table_names = {'srcTable', 'incTable'};
|
||||
for k = 1:numel(table_names)
|
||||
table_name = table_names{k};
|
||||
customtable.format(table_name);
|
||||
end
|
||||
% запись описания блока
|
||||
|
||||
% Устанавливаем описание блока
|
||||
textDesc = ['Блок для настройки параметров симуляции микроконтроллера. ' newline ...
|
||||
'Позволяет задавать параметры оболочки, приложения МК и периферии'];
|
||||
|
||||
% Получаем объект описания
|
||||
toolTextArea = mask.getDialogControl('BlockDesc');
|
||||
toolTextArea.Prompt = textDesc;
|
||||
end
|
||||
|
||||
%% WRAPPER PARAMS
|
||||
%% WRAPPER PARAMS - callback-функции для параметров обёртки
|
||||
function wrapperPath_add(callbackContext)
|
||||
% Добавление пути к файлам обёртки
|
||||
mcuPath.addPath('wrapperPath');
|
||||
end
|
||||
|
||||
function enableThreading(callbackContext)
|
||||
block = gcb;
|
||||
maskNames = get_param(block, 'MaskNames');
|
||||
maskValues = get_param(block, 'MaskValues');
|
||||
maskEnables = get_param(block, 'MaskEnables');
|
||||
idxEnable = find(strcmp(maskNames, 'enableThreading'));
|
||||
idxEdit = find(strcmp(maskNames, 'threadCycles'));
|
||||
if isempty(idxEnable) || isempty(idxEdit)
|
||||
error('Параметры enableThreading или threadCycles не найдены в маске');
|
||||
end
|
||||
val = maskValues{idxEnable};
|
||||
if strcmp(val, 'on')
|
||||
maskEnables{idxEdit} = 'on';
|
||||
else
|
||||
maskEnables{idxEdit} = 'off';
|
||||
end
|
||||
set_param(block, 'MaskEnables', maskEnables);
|
||||
% Включение/выключение многопоточности
|
||||
mainWrap.enableThreading();
|
||||
end
|
||||
|
||||
function enableDeinit(callbackContext)
|
||||
block = gcb;
|
||||
maskNames = get_param(block, 'MaskNames');
|
||||
maskValues = get_param(block, 'MaskValues');
|
||||
maskEnables = get_param(block, 'MaskEnables');
|
||||
idxEnable = find(strcmp(maskNames, 'enableThreading'));
|
||||
idxEdit = find(strcmp(maskNames, 'threadCycles'));
|
||||
if isempty(idxEnable) || isempty(idxEdit)
|
||||
error('Параметры enableThreading или threadCycles не найдены в маске');
|
||||
end
|
||||
val = maskValues{idxEnable};
|
||||
if strcmp(val, 'on')
|
||||
maskEnables{idxEdit} = 'on';
|
||||
else
|
||||
maskEnables{idxEdit} = 'off';
|
||||
end
|
||||
set_param(block, 'MaskEnables', maskEnables);
|
||||
% Включение/выключение деинициализации
|
||||
mainWrap.enableDeinit();
|
||||
end
|
||||
|
||||
function extConsol(callbackContext)
|
||||
block = gcb;
|
||||
mask = Simulink.Mask.get(block);
|
||||
fullOut = mask.getParameter('fullOutput');
|
||||
extCons = mask.getParameter('extConsol');
|
||||
if isempty(extCons) || isempty(fullOut)
|
||||
error('Параметры fullOutput или extConsol не найдены в маске');
|
||||
% Управление внешней консолью
|
||||
mainWrap.extConsol();
|
||||
end
|
||||
|
||||
if(strcmp(extCons.Enabled, 'on'))
|
||||
if strcmp(extCons.Value, 'on')
|
||||
fullOut.Enabled = 'off';
|
||||
fullOut.Value = 'on';
|
||||
else
|
||||
fullOut.Enabled = 'on';
|
||||
end
|
||||
else
|
||||
fullOut.Enabled = 'on';
|
||||
%% USER WRAPPER CODE - callback-функции для пользовательского кода
|
||||
function appWrapperPath_add(callbackContext)
|
||||
% Добавление пути к файлам обёртки приложения
|
||||
mcuPath.addPath('appWrapperPath');
|
||||
end
|
||||
|
||||
function appWrapperFunc(callbackContext)
|
||||
% Загрузка функции обёртки для редактирования
|
||||
appWrap.appWrapperFunc();
|
||||
end
|
||||
|
||||
function wrapperPath_add(callbackContext)
|
||||
block = gcb;
|
||||
mask = Simulink.Mask.get(block);
|
||||
% Открываем окно выбора папки
|
||||
folderPath = uigetdir('', 'Выберите папку');
|
||||
% Проверка на отмену
|
||||
if isequal(folderPath, 0)
|
||||
return;
|
||||
end
|
||||
% Установка значения параметра маски
|
||||
rel = mcuMask.absoluteToRelativePath(folderPath);
|
||||
param = mask.getParameter('wrapperPath');
|
||||
param.Value = rel;
|
||||
|
||||
end
|
||||
%% USER WRAPPER CODE
|
||||
|
||||
function wrapperFunc(callbackContext)
|
||||
block = gcb;
|
||||
% Получаем имя функции и путь к файлам
|
||||
[filename, section, tool, example]= mcuMask.getWrapperUserFile(block);
|
||||
mcuMask.tool(tool, example);
|
||||
|
||||
% Загружаем содержимое файла
|
||||
set_param(block, 'wrapperCode', '');
|
||||
try
|
||||
code = fileread(filename);
|
||||
code = regexprep(code, '\r\n?', '\n'); % нормализуем окончания строк
|
||||
|
||||
includesText = editCode.extractSection(code, section);
|
||||
set_param(block, 'wrapperCode', includesText);
|
||||
catch
|
||||
end
|
||||
% % Поиск тела обычной функции
|
||||
% expr = sprintf('void %s()', sel);
|
||||
% funcBody = editCode.extractSection(code, expr);
|
||||
% set_param(block, 'wrapperCode', funcBody);
|
||||
function saveAppWrapperCode(callbackContext)
|
||||
% Сохранение отредактированного кода обёртки
|
||||
appWrap.saveAppWrapperCode();
|
||||
end
|
||||
|
||||
function saveWrapperCode(callbackContext)
|
||||
block = gcb;
|
||||
|
||||
% Получаем имя функции и путь к файлам
|
||||
[filename, section] = mcuMask.getWrapperUserFile(block);
|
||||
if ~isfile(filename)
|
||||
errordlg(['Файл не найден: ', filename]);
|
||||
return;
|
||||
function openAppWrapperCode(callbackContext)
|
||||
% Открытие кода обёртки во внешнем редакторе
|
||||
appWrap.openAppWrapperCode();
|
||||
end
|
||||
|
||||
sel = get_param(block, 'wrapperFunc');
|
||||
basePath = get_param(block, 'wrapperPath');
|
||||
if isempty(basePath)
|
||||
errordlg('Не указан путь к файлам обёртки (wrapperPath).');
|
||||
return;
|
||||
end
|
||||
newBody = get_param(block, 'wrapperCode');
|
||||
code = fileread(filename);
|
||||
code = regexprep(code, '\r\n?', '\n');
|
||||
newBody = strrep(newBody, '\', '\\');
|
||||
code = editCode.insertSection(code, section, newBody);
|
||||
% else
|
||||
% % Обновляем тело функции
|
||||
% expr = sprintf('void %s()', sel);
|
||||
% code = editCode.insertSection(code, expr, newBody);
|
||||
% end
|
||||
fid = fopen(filename, 'w', 'n', 'UTF-8');
|
||||
if fid == -1
|
||||
errordlg('Не удалось открыть файл для записи');
|
||||
return;
|
||||
end
|
||||
fwrite(fid, code);
|
||||
fclose(fid);
|
||||
mcuMask.disp(1, ['Обновлено: ' sel]);
|
||||
end
|
||||
|
||||
function openWrapperCode(callbackContext)
|
||||
block = gcb;
|
||||
|
||||
% Получаем имя функции и путь к файлам
|
||||
filename = mcuMask.getAbsolutePath(mcuMask.getWrapperUserFile(block));
|
||||
if exist(filename, 'file') == 2
|
||||
% Формируем команду без кавычек
|
||||
cmd = sprintf('rundll32.exe shell32.dll,OpenAs_RunDLL %s', filename);
|
||||
status = system(cmd);
|
||||
if status ~= 0
|
||||
errordlg('Не удалось открыть окно выбора приложения.');
|
||||
end
|
||||
else
|
||||
errordlg('Файл не найден');
|
||||
end
|
||||
end
|
||||
|
||||
%% USER CODE
|
||||
%% USER CODE - callback-функции для пользовательского кода
|
||||
function srcTable(callbackContext)
|
||||
% Обновление таблицы исходных файлов
|
||||
customtable.update('srcTable');
|
||||
end
|
||||
|
||||
function incTable(callbackContext)
|
||||
% Обновление таблицы заголовочных файлов
|
||||
customtable.update('incTable');
|
||||
end
|
||||
|
||||
function btnAddSrc(callbackContext)
|
||||
blockHandle = gcb;
|
||||
% Открываем проводник для выбора файлов
|
||||
[files, pathstr] = uigetfile({ ...
|
||||
'*.c;*.cpp', 'Исходные файлы (*.c, *.cpp)'; ...
|
||||
'*.obj;*.lib', 'Библиотеки (*.obj, *.lib)'; ...
|
||||
'*.*', 'Все файлы (*.*)'}, ...
|
||||
'Выберите файлы', ...
|
||||
'MultiSelect', 'on');
|
||||
|
||||
if isequal(files, 0)
|
||||
return; % Отмена выбора
|
||||
end
|
||||
if ischar(files)
|
||||
files = {files}; % Один файл — в cell
|
||||
end
|
||||
% Парсим строку в cell-массив
|
||||
oldTable = customtable.parse('srcTable');
|
||||
|
||||
% Добавляем новые пути, проверяя уникальность
|
||||
for i = 1:numel(files)
|
||||
fullpath = fullfile(pathstr, files{i});
|
||||
rel = mcuMask.absoluteToRelativePath(fullpath);
|
||||
if ~any(strcmp(rel, oldTable))
|
||||
oldTable{end+1, 1} = rel;
|
||||
end
|
||||
end
|
||||
|
||||
% Парсим строку в cell-массив
|
||||
customtable.collect('srcTable', oldTable);
|
||||
|
||||
% Добавление исходных файлов через диалог выбора
|
||||
mcuPath.addSourceFileTable('srcTable', 'Выберите исходные файлы');
|
||||
end
|
||||
|
||||
function btnAddInc(callbackContext)
|
||||
blockHandle = gcb;
|
||||
% Открываем проводник для выбора папок
|
||||
pathstr = uigetdir(pwd, 'Выберите папку с заголовочными файлами');
|
||||
if isequal(pathstr, 0)
|
||||
return; % Отмена выбора
|
||||
end
|
||||
% Парсим таблицу
|
||||
oldTable = customtable.parse('incTable');
|
||||
|
||||
rel = mcuMask.absoluteToRelativePath(pathstr);
|
||||
|
||||
% Проверяем наличие пути
|
||||
if ~any(strcmp(rel, oldTable))
|
||||
oldTable{end+1, 1} = rel;
|
||||
% Добавление путей включения через диалог выбора
|
||||
mcuPath.addPathTable('incTable', 'Выберите папку с заголовочными файлами');
|
||||
end
|
||||
|
||||
% Собираем таблицу
|
||||
customtable.collect('incTable', oldTable);
|
||||
end
|
||||
|
||||
%% PERIPH CONFIG
|
||||
|
||||
%% PERIPH CONFIG - callback-функции для конфигурации периферии
|
||||
function periphPath_add(callbackContext)
|
||||
block = gcbh;
|
||||
mask = Simulink.Mask.get(block);
|
||||
[file, path] = uigetfile({'*.*','Все файлы (*.*)'}, 'Выберите файл');
|
||||
if isequal(file, 0) || isequal(path, 0)
|
||||
% Отмена выбора — ничего не делаем
|
||||
return;
|
||||
end
|
||||
fullFilePath = fullfile(path, file);
|
||||
rel = mcuMask.absoluteToRelativePath(fullFilePath);
|
||||
param = mask.getParameter('periphPath');
|
||||
param.Value = rel;
|
||||
% Добавление пути к конфигурационному файлу периферии
|
||||
mcuPath.addAnyFile('periphPath');
|
||||
end
|
||||
|
||||
function compile(callbackContext)
|
||||
addpath('MCU_Wrapper');
|
||||
mexing(1);
|
||||
end
|
||||
|
||||
|
||||
function updateModel(callbackContext)
|
||||
addpath('MCU_Wrapper');
|
||||
res = mexing(1);
|
||||
if res ~= 0
|
||||
return;
|
||||
end
|
||||
|
||||
modelName = bdroot(gcb); % получить имя верхнего уровня модели
|
||||
function periphUpdate(callbackContext)
|
||||
% Обновление конфигурации периферии с асинхронным управлением
|
||||
modelName = bdroot(gcb);
|
||||
blockName = gcb;
|
||||
mgr = asynchManage(modelName, blockName); % создать объект класса
|
||||
mgr.saveAndUpdateModel(); % запустить сохранение и обновление
|
||||
mgr = asynchManage(modelName, blockName);
|
||||
mgr.updateGUIfromConfig(); % Запуск обновления через таймер
|
||||
end
|
||||
|
||||
|
||||
function findjobj_link(callbackContext)
|
||||
web('https://www.mathworks.com/matlabcentral/fileexchange/14317-findjobj-find-java-handles-of-matlab-graphic-objects');
|
||||
%% COMPILE - callback-функции для компиляции
|
||||
function compile(callbackContext)
|
||||
% Компиляция S-функции
|
||||
compiler.compile();
|
||||
end
|
||||
|
||||
function set_name()
|
||||
function setSFuncName(callbackContext)
|
||||
% Установка имени S-функции в исходном коде
|
||||
block = gcb;
|
||||
% Получаем параметр имени S-Function из маски блока
|
||||
newName = mcuMask.get_name();
|
||||
|
||||
% Путь к файлу, в котором надо заменить строку
|
||||
cFilePath = fullfile(pwd, './MCU_Wrapper/MCU.c'); % <-- укажи правильный путь
|
||||
% Путь к файлу MCU.c
|
||||
cFilePath = fullfile(pwd, mcuPath.get('wrapperPath'), 'MCU.c');
|
||||
|
||||
% Считаем файл в память
|
||||
% Чтение файла
|
||||
try
|
||||
fileText = fileread(cFilePath);
|
||||
catch
|
||||
return;
|
||||
end
|
||||
|
||||
% Регулярное выражение для поиска строки с define
|
||||
% Заменим строку вида: #define S_FUNCTION_NAME old_name
|
||||
% Поиск и замена определения имени S-функции
|
||||
pattern = '#define\s+S_FUNCTION_NAME\s+\w+';
|
||||
|
||||
% Новая строка
|
||||
newLine = ['#define S_FUNCTION_NAME ', newName];
|
||||
|
||||
% Замена
|
||||
updatedText = regexprep(fileText, pattern, newLine);
|
||||
|
||||
% Записываем обратно в файл
|
||||
fid = fopen(cFilePath, 'w', 'n', 'UTF-8');
|
||||
% Запись изменений обратно в файл
|
||||
fid = fopen(cFilePath, 'w', 'n');
|
||||
if fid == -1
|
||||
error('Не удалось открыть файл для записи.');
|
||||
end
|
||||
@ -349,103 +175,33 @@ classdef mcuMask
|
||||
fclose(fid);
|
||||
end
|
||||
|
||||
function name = get_name()
|
||||
block = gcb;
|
||||
% Получаем параметр имени S-Function из маски блока
|
||||
name = get_param(block, 'sfuncName');
|
||||
%% LINK TO EXTERNAL CONSOLE - callback для внешней консоли
|
||||
function findjobj_link(callbackContext)
|
||||
% Открытие ссылки на утилиту findjobj
|
||||
web('https://www.mathworks.com/matlabcentral/fileexchange/14317-findjobj-find-java-handles-of-matlab-graphic-objects');
|
||||
end
|
||||
end
|
||||
|
||||
|
||||
%% SPECIFIC TOOLS
|
||||
methods(Static, Access = private)
|
||||
|
||||
function [filename, section, tool, example] = getWrapperUserFile(block)
|
||||
sel = get_param(block, 'wrapperFunc');
|
||||
basePath = get_param(block, 'wrapperPath');
|
||||
if isempty(basePath)
|
||||
errordlg('Не указан путь к файлам обёртки (wrapperPath).');
|
||||
return;
|
||||
end
|
||||
% Формируем путь к файлу в зависимости от типа запроса
|
||||
if strcmp(sel, 'Includes')
|
||||
filename = fullfile(basePath, 'app_includes.h');
|
||||
section = '// INCLUDES';
|
||||
tool = 'Инклюды для доступа к коду МК в коде оболочке';
|
||||
example = '#include "main.h"';
|
||||
elseif strcmp(sel, 'Dummy')
|
||||
filename = fullfile(basePath, 'app_wrapper.c');
|
||||
section = '// DUMMY';
|
||||
tool = 'Заглушки для различных функций и переменных';
|
||||
example = ['CAN_HandleTypeDef hcan = {0};' newline...
|
||||
'void hardware_func(handle *huart) {}' newline...
|
||||
'int wait_for_hardware_flag(int *flag) {' newline...
|
||||
' return 1;' newline...
|
||||
'}' newline...
|
||||
''];
|
||||
elseif strcmp(sel, 'App Init')
|
||||
filename = fullfile(basePath, 'app_init.c');
|
||||
section = '// USER APP INIT';
|
||||
tool = ['Код для инициализации приложения МК.' newline newline...
|
||||
'Вызов функций инициализации, если не используется отдельный поток для main().'];
|
||||
example = 'init_func();';
|
||||
elseif strcmp(sel, 'App Step')
|
||||
filename = fullfile(basePath, 'app_wrapper.c');
|
||||
section = '// USER APP STEP';
|
||||
tool = ['Код приложения МК для вызова в шаге симуляции.' newline newline ...
|
||||
'Вызов функций программы МК, если не используется отдельный поток для main().'];
|
||||
example = 'step_func();';
|
||||
elseif strcmp(sel, 'App Inputs')
|
||||
filename = fullfile(basePath, 'app_io.c');
|
||||
section = '// USER APP INPUT';
|
||||
tool = ['Работа с буффером для портов S-Function' newline newline ...
|
||||
'Буфер в начале хранит входные порты S-Function, далее идут выходные порты:' newline ...
|
||||
'Buffer[0:15] - входной порт, Buffer[16:31] - входной 1 порт, ' newline ...
|
||||
'Buffer[32:47] - выходной 1 порт, Buffer[48:63] - выходной 2 порт'];
|
||||
example = ['// чтение 1-го элемента 0-го входного массива' newline...
|
||||
'app_variable_2 = ReadInputArray(0, 1);' newline newline...
|
||||
'// запись в буфер выходов' newline ...
|
||||
'app_variable_2 = Buffer[10];'];
|
||||
elseif strcmp(sel, 'App Outputs')
|
||||
filename = fullfile(basePath, 'app_io.c');
|
||||
section = '// USER APP OUTPUT';
|
||||
tool = ['Работа с буффером для портов S-Function' newline newline ...
|
||||
'Буфер в начале хранит входные порты S-Function, далее идут выходные порты:' newline ...
|
||||
'Buffer[0:15] - входной порт, Buffer[16:31] - входной 1 порт, ' newline ...
|
||||
'Buffer[32:47] - выходной 1 порт, Buffer[48:63] - выходной 2 порт'];
|
||||
example = ['// запись в 1-й элемент 0-го выходного массива' newline...
|
||||
'WriteOutputArray(app_variable, 0, 1);' newline newline ...
|
||||
'// запись в буфер выходов' newline ...
|
||||
'Buffer[XD_OUTPUT_START + 10] = app_variable_2;'];
|
||||
elseif strcmp(sel, 'App Deinit')
|
||||
filename = fullfile(basePath, 'app_init.c');
|
||||
section = '// USER APP DEINIT';
|
||||
tool = ['Код для деинициализации приложения МК.' newline newline ...
|
||||
'Можно деинициализировать приложение МК, для повторного запуска.'];
|
||||
example = 'memset(&htim1, sizeof(htim1), 0;';
|
||||
else
|
||||
tool = '';
|
||||
mcuMask.disp(0, '\nОшибка выбора типа секции кода: неизвестное значение');
|
||||
end
|
||||
|
||||
end
|
||||
|
||||
end
|
||||
|
||||
%% GENERAL TOOLS
|
||||
%% GENERAL TOOLS - общие утилиты для работы с маской
|
||||
methods(Static, Access = public)
|
||||
|
||||
function saveAndClose(blockPath)
|
||||
function updateModel()
|
||||
% Обновление модели с компиляцией S-функции
|
||||
addpath(mcuPath.get('wrapperPath'));
|
||||
res = mexing(1);
|
||||
if res ~= 0
|
||||
return;
|
||||
end
|
||||
end
|
||||
|
||||
function close(blockPath)
|
||||
% Закрытие маски с сохранением параметров
|
||||
try
|
||||
% Считываем текущее имя модели
|
||||
modelName = bdroot(blockPath);
|
||||
% Включаем возможность изменения маски
|
||||
set_param(blockPath, 'MaskSelfModifiable', 'on');
|
||||
|
||||
% Считываем текущие значения параметров маски
|
||||
% Применяем текущие значения маски
|
||||
currentMaskValues = get_param(blockPath, 'MaskValues');
|
||||
|
||||
% Применяем текущие значения заново, чтобы "применить" маску
|
||||
set_param(blockPath, 'MaskValues', currentMaskValues);
|
||||
save_system(modelName);
|
||||
catch ME
|
||||
@ -455,92 +211,25 @@ classdef mcuMask
|
||||
end
|
||||
|
||||
function open(blockPath, clear_flag)
|
||||
% Открытие маски блока
|
||||
open_system(blockPath, 'mask');
|
||||
mcuMask.disp(clear_flag, '');
|
||||
end
|
||||
|
||||
|
||||
function absPath = getAbsolutePath(relPath)
|
||||
% relativeToAbsolutePath — преобразует относительный путь в абсолютный.
|
||||
%
|
||||
% Если путь уже абсолютный — возвращается он же, приведённый к канонической форме.
|
||||
% Если путь относительный — преобразуется относительно текущей директории.
|
||||
|
||||
% Проверка: абсолютный ли путь
|
||||
if ispc
|
||||
isAbsolute = ~isempty(regexp(relPath, '^[a-zA-Z]:[\\/]', 'once')) || startsWith(relPath, '\\');
|
||||
else
|
||||
isAbsolute = startsWith(relPath, '/');
|
||||
function name = get_name()
|
||||
% Получение имени S-функции из параметра маски
|
||||
block = gcb;
|
||||
name = get_param(block, 'sfuncName');
|
||||
end
|
||||
|
||||
if isAbsolute
|
||||
% Канонизируем абсолютный путь (убираем ./, ../ и т.п.)
|
||||
absPath = char(java.io.File(relPath).getCanonicalPath());
|
||||
else
|
||||
% Строим абсолютный путь от текущей директории
|
||||
cwd = pwd;
|
||||
combined = fullfile(cwd, relPath);
|
||||
absPath = char(java.io.File(combined).getCanonicalPath());
|
||||
end
|
||||
end
|
||||
|
||||
|
||||
|
||||
function rel = absoluteToRelativePath(pathstr)
|
||||
% absoluteToRelativePath — преобразует абсолютный путь в относительный от текущей директории.
|
||||
%
|
||||
% Если путь находится в текущей директории или вложенной в неё — добавляется префикс './'
|
||||
% Если выше — формируются переходы '..'
|
||||
% Если путь совпадает с текущей директорией — возвращается '.'
|
||||
|
||||
% Получаем текущую рабочую директорию
|
||||
cwd = pwd;
|
||||
|
||||
% Преобразуем пути в канонические абсолютные пути
|
||||
fullpath = char(java.io.File(pathstr).getCanonicalPath());
|
||||
cwd = char(java.io.File(cwd).getCanonicalPath());
|
||||
|
||||
% Разбиваем пути на части
|
||||
targetParts = strsplit(fullpath, filesep);
|
||||
baseParts = strsplit(cwd, filesep);
|
||||
|
||||
% Находим длину общего префикса
|
||||
j = 1;
|
||||
while j <= min(length(targetParts), length(baseParts)) && strcmpi(targetParts{j}, baseParts{j})
|
||||
j = j + 1;
|
||||
end
|
||||
|
||||
% Формируем количество подъемов ".." из cwd
|
||||
numUps = length(baseParts) - (j - 1);
|
||||
ups = repmat({'..'}, 1, numUps);
|
||||
|
||||
% Оставшаяся часть пути после общего префикса
|
||||
rest = targetParts(j:end);
|
||||
|
||||
% Объединяем для получения относительного пути
|
||||
relParts = [ups, rest];
|
||||
rel = fullfile(relParts{:});
|
||||
|
||||
% Если путь пустой — это текущая директория
|
||||
if isempty(rel)
|
||||
rel = '.';
|
||||
end
|
||||
|
||||
% Если путь не содержит ".." и начинается внутри текущей директории — добавим './'
|
||||
if ~isempty(rest) && isempty(ups)
|
||||
rel = fullfile('.', rel);
|
||||
end
|
||||
end
|
||||
|
||||
|
||||
|
||||
function checkbox_state = read_checkbox(checkboxName)
|
||||
% Чтение состояния чекбокса из параметров маски
|
||||
maskValues = get_param(gcbh, 'MaskValues');
|
||||
paramNames = get_param(gcbh, 'MaskNames');
|
||||
|
||||
inxCheckBox = find(strcmp(paramNames, checkboxName));
|
||||
|
||||
checkbox_state_str = maskValues{inxCheckBox};
|
||||
|
||||
if strcmpi(checkbox_state_str, 'on')
|
||||
checkbox_state = 1;
|
||||
else
|
||||
@ -548,8 +237,8 @@ classdef mcuMask
|
||||
end
|
||||
end
|
||||
|
||||
|
||||
function children = get_children(ctrl)
|
||||
% Получение дочерних элементов управления маски
|
||||
if isprop(ctrl, 'DialogControls')
|
||||
children = ctrl.DialogControls;
|
||||
elseif isprop(ctrl, 'Controls')
|
||||
@ -562,27 +251,28 @@ classdef mcuMask
|
||||
end
|
||||
|
||||
function params = collect_all_parameters(container)
|
||||
% Рекурсивный сбор всех параметров маски
|
||||
params = {};
|
||||
children = container.DialogControls;
|
||||
for i = 1:numel(children)
|
||||
ctrl = children(i);
|
||||
if isa(ctrl, 'Simulink.dialog.Tab')
|
||||
% Если вкладка — рекурсивно собираем параметры внутри неё
|
||||
% Рекурсивный обход вкладок
|
||||
params = [params, mcuMask.collect_all_parameters(ctrl)];
|
||||
else
|
||||
% Иначе это параметр — добавляем имя
|
||||
params{end+1} = ctrl.Name; %#ok<AGROW>
|
||||
% Добавление имени параметра
|
||||
params{end+1} = ctrl.Name;
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
function delete_all_tabs(mask, container)
|
||||
% Рекурсивное удаление всех вкладок маски
|
||||
children = container.DialogControls;
|
||||
% Идём в обратном порядке, чтобы безопасно удалять
|
||||
for i = numel(children):-1:1
|
||||
ctrl = children(i);
|
||||
if isa(ctrl, 'Simulink.dialog.Tab')
|
||||
% Сначала рекурсивно удаляем вкладки внутри текущей вкладки
|
||||
% Рекурсивное удаление вложенных вкладок
|
||||
mcuMask.delete_all_tabs(mask, ctrl);
|
||||
try
|
||||
container.removeDialogControl(ctrl.Name);
|
||||
@ -593,22 +283,9 @@ classdef mcuMask
|
||||
end
|
||||
end
|
||||
|
||||
function res = ternary(cond, valTrue, valFalse)
|
||||
if cond
|
||||
res = valTrue;
|
||||
else
|
||||
res = valFalse;
|
||||
end
|
||||
end
|
||||
|
||||
|
||||
function tool(text, example)
|
||||
% Устанавливает заданный текст в параметр Text Area 'toolText' через объект маски
|
||||
|
||||
% Получаем ссылку на текущий блок
|
||||
% Установка текста подсказки и примера в элементы маски
|
||||
block = gcb;
|
||||
|
||||
% Получаем объект маски
|
||||
mask = Simulink.Mask.get(block);
|
||||
|
||||
toolTextArea = mask.getDialogControl('toolText');
|
||||
@ -618,38 +295,42 @@ classdef mcuMask
|
||||
end
|
||||
|
||||
function disp(clcFlag, varargin)
|
||||
% Вывод текста в консоль маски
|
||||
if clcFlag
|
||||
set_param(gcb, 'consoleOutput', '');
|
||||
end
|
||||
|
||||
if length(varargin) == 1 && ischar(varargin{1})
|
||||
% Если передан один аргумент — просто строка, передаем напрямую
|
||||
out = varargin{1};
|
||||
else
|
||||
% Иначе считаем, что первый аргумент — формат, остальные — параметры
|
||||
out = sprintf(varargin{:});
|
||||
end
|
||||
|
||||
out_now = get_param(gcb, 'consoleOutput');
|
||||
if ~strcmp(out, '') && ~strcmp(out_now, '')
|
||||
set_param(gcb, 'consoleOutput', [out_now newline out]);
|
||||
else
|
||||
set_param(gcb, 'consoleOutput', [out_now out]);
|
||||
end
|
||||
|
||||
end
|
||||
|
||||
function updateModelAsync()
|
||||
% Асинхронное обновление модели через таймер
|
||||
mdl = bdroot(gcb);
|
||||
|
||||
try
|
||||
% Применить изменения, если есть
|
||||
set_param(mdl, 'ApplyChanges', 'on');
|
||||
catch
|
||||
beep
|
||||
% Игнорировать, если не удалось
|
||||
end
|
||||
|
||||
t = timer('StartDelay', 0.01, 'TimerFcn', @(~,~) set_param(mdl, 'SimulationCommand', 'update'));
|
||||
start(t);
|
||||
end
|
||||
|
||||
|
||||
function v = getMyLibVersion()
|
||||
% Получение версии библиотеки
|
||||
v = 'pre-1.04';
|
||||
end
|
||||
end
|
||||
end
|
||||
211
McuLib/m/mcuPath.m
Normal file
211
McuLib/m/mcuPath.m
Normal file
@ -0,0 +1,211 @@
|
||||
classdef mcuPath
|
||||
% Класс для работы с путями файлов и папок в маске Simulink
|
||||
% Обеспечивает преобразование путей, добавление в таблицы и параметры
|
||||
|
||||
methods(Static)
|
||||
|
||||
%% GET PATH FROM PARAM - получение путей из параметров маски
|
||||
function path = get(paramName)
|
||||
% Получение значения пути из параметра маски
|
||||
% paramName - имя параметра маски содержащего путь
|
||||
% Возвращает строку с путём (абсолютным или относительным)
|
||||
|
||||
blockPath = gcb;
|
||||
path = get_param(blockPath, paramName);
|
||||
end
|
||||
|
||||
%% ADD PATH TO TABLE - добавление путей в табличные параметры
|
||||
|
||||
function addSourceFileTable(targetParamName, message)
|
||||
% Добавление исходных файлов в таблицу через диалог выбора
|
||||
% targetParamName - имя табличного параметра маски
|
||||
% message - сообщение в диалоге выбора
|
||||
|
||||
% Открываем проводник для выбора файлов с фильтрами
|
||||
[files, pathstr] = uigetfile({ ...
|
||||
'*.c;*.cpp', 'Исходные файлы (*.c, *.cpp)'; ...
|
||||
'*.obj;*.lib', 'Библиотеки (*.obj, *.lib)'; ...
|
||||
'*.*', 'Все файлы (*.*)'}, ...
|
||||
message, ...
|
||||
'MultiSelect', 'on'); % Разрешаем множественный выбор
|
||||
|
||||
if isequal(files, 0)
|
||||
return; % Пользователь отменил выбор
|
||||
end
|
||||
|
||||
% Нормализуем входные данные: один файл -> cell array
|
||||
if ischar(files)
|
||||
files = {files};
|
||||
end
|
||||
|
||||
% Читаем текущее содержимое таблицы
|
||||
oldTable = customtable.parse(targetParamName);
|
||||
|
||||
% Добавляем новые пути, проверяя уникальность
|
||||
for i = 1:numel(files)
|
||||
fullpath = fullfile(pathstr, files{i});
|
||||
% Преобразуем абсолютный путь в относительный
|
||||
rel = mcuPath.absoluteToRelativePath(fullpath);
|
||||
% Добавляем только если путь ещё не существует в таблице
|
||||
if ~any(strcmp(rel, oldTable))
|
||||
oldTable{end+1, 1} = rel;
|
||||
end
|
||||
end
|
||||
|
||||
% Сохраняем обновленную таблицу обратно в параметр маски
|
||||
customtable.collect(targetParamName, oldTable);
|
||||
end
|
||||
|
||||
function addPathTable(targetParamName, message)
|
||||
% Добавление путей к папкам в таблицу через диалог выбора
|
||||
% targetParamName - имя табличного параметра маски
|
||||
% message - сообщение в диалоге выбора
|
||||
|
||||
% Открываем проводник для выбора папки
|
||||
pathstr = uigetdir(pwd, message);
|
||||
if isequal(pathstr, 0)
|
||||
return; % Пользователь отменил выбор
|
||||
end
|
||||
|
||||
% Читаем текущее содержимое таблицы
|
||||
oldTable = customtable.parse(targetParamName);
|
||||
|
||||
% Преобразуем абсолютный путь в относительный
|
||||
rel = mcuPath.absoluteToRelativePath(pathstr);
|
||||
|
||||
% Проверяем наличие пути в таблице и добавляем если нужно
|
||||
if ~any(strcmp(rel, oldTable))
|
||||
oldTable{end+1, 1} = rel;
|
||||
end
|
||||
|
||||
% Сохраняем обновленную таблицу
|
||||
customtable.collect(targetParamName, oldTable);
|
||||
end
|
||||
|
||||
%% ADD PATH TO EDIT - добавление путей в текстовые параметры
|
||||
|
||||
function addPath(targetParamName, message)
|
||||
% Добавление пути к папке в текстовый параметр маски
|
||||
% targetParamName - имя параметра маски для пути
|
||||
% message - сообщение в диалоге выбора (не используется)
|
||||
|
||||
block = gcb;
|
||||
mask = Simulink.Mask.get(block);
|
||||
|
||||
% Открываем окно выбора папки
|
||||
folderPath = uigetdir('', 'Выберите папку');
|
||||
|
||||
% Проверка на отмену выбора
|
||||
if isequal(folderPath, 0)
|
||||
return;
|
||||
end
|
||||
|
||||
% Преобразуем абсолютный путь в относительный
|
||||
rel = mcuPath.absoluteToRelativePath(folderPath);
|
||||
|
||||
% Устанавливаем значение параметра маски
|
||||
param = mask.getParameter(targetParamName);
|
||||
param.Value = rel;
|
||||
end
|
||||
|
||||
function addAnyFile(targetParamName, message)
|
||||
% Добавление пути к файлу в текстовый параметр маски
|
||||
% targetParamName - имя параметра маски для пути к файлу
|
||||
% message - сообщение в диалоге выбора (не используется)
|
||||
|
||||
block = gcbh;
|
||||
mask = Simulink.Mask.get(block);
|
||||
|
||||
% Открываем проводник для выбора любого файла
|
||||
[file, path] = uigetfile({'*.*','Все файлы (*.*)'}, 'Выберите файл');
|
||||
|
||||
if isequal(file, 0) || isequal(path, 0)
|
||||
return; % Пользователь отменил выбор
|
||||
end
|
||||
|
||||
% Формируем полный путь и преобразуем в относительный
|
||||
fullFilePath = fullfile(path, file);
|
||||
rel = mcuPath.absoluteToRelativePath(fullFilePath);
|
||||
|
||||
% Устанавливаем значение параметра маски
|
||||
param = mask.getParameter(targetParamName);
|
||||
param.Value = rel;
|
||||
end
|
||||
|
||||
%% GET PATH STRING - утилиты преобразования путей
|
||||
|
||||
function absPath = getAbsolutePath(relPath)
|
||||
% Преобразование относительного пути в абсолютный
|
||||
% relPath - относительный или абсолютный путь
|
||||
% Возвращает абсолютный путь в канонической форме
|
||||
|
||||
% Проверка: абсолютный ли путь уже
|
||||
if ispc
|
||||
% Для Windows: путь начинается с буквы диска или \\
|
||||
isAbsolute = ~isempty(regexp(relPath, '^[a-zA-Z]:[\\/]', 'once')) || startsWith(relPath, '\\');
|
||||
else
|
||||
% Для Unix: путь начинается с /
|
||||
isAbsolute = startsWith(relPath, '/');
|
||||
end
|
||||
|
||||
if isAbsolute
|
||||
% Канонизируем абсолютный путь (убираем ./, ../ и т.п.)
|
||||
absPath = char(java.io.File(relPath).getCanonicalPath());
|
||||
else
|
||||
% Строим абсолютный путь относительно текущей директории
|
||||
cwd = pwd;
|
||||
combined = fullfile(cwd, relPath);
|
||||
absPath = char(java.io.File(combined).getCanonicalPath());
|
||||
end
|
||||
end
|
||||
|
||||
function rel = absoluteToRelativePath(pathstr)
|
||||
% Преобразование абсолютного пути в относительный относительно текущей директории
|
||||
% pathstr - абсолютный путь для преобразования
|
||||
% Возвращает относительный путь
|
||||
%
|
||||
% Примеры:
|
||||
% Если путь в текущей директории -> './filename'
|
||||
% Если путь выше -> '../parent/filename'
|
||||
% Если путь совпадает с текущей директорией -> '.'
|
||||
|
||||
% Получаем текущую рабочую директорию
|
||||
cwd = pwd;
|
||||
|
||||
% Преобразуем оба пути в канонические абсолютные пути
|
||||
fullpath = char(java.io.File(pathstr).getCanonicalPath());
|
||||
cwd = char(java.io.File(cwd).getCanonicalPath());
|
||||
|
||||
% Разбиваем пути на части по разделителю файловой системы
|
||||
targetParts = strsplit(fullpath, filesep);
|
||||
baseParts = strsplit(cwd, filesep);
|
||||
|
||||
% Находим длину общего префикса (совпадающих частей пути)
|
||||
j = 1;
|
||||
while j <= min(length(targetParts), length(baseParts)) && strcmpi(targetParts{j}, baseParts{j})
|
||||
j = j + 1;
|
||||
end
|
||||
|
||||
% Формируем количество подъемов ".." для выхода из базовой директории
|
||||
numUps = length(baseParts) - (j - 1);
|
||||
ups = repmat({'..'}, 1, numUps);
|
||||
|
||||
% Оставшаяся часть целевого пути после общего префикса
|
||||
rest = targetParts(j:end);
|
||||
|
||||
% Объединяем части для получения относительного пути
|
||||
relParts = [ups, rest];
|
||||
rel = fullfile(relParts{:});
|
||||
|
||||
% Если путь пустой - это текущая директория
|
||||
if isempty(rel)
|
||||
rel = '.';
|
||||
end
|
||||
|
||||
% Если путь не содержит ".." и начинается внутри текущей директории - добавляем './'
|
||||
if ~isempty(rest) && isempty(ups)
|
||||
rel = fullfile('.', rel);
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@ -1,45 +1,63 @@
|
||||
classdef mcuPorts
|
||||
% Класс для управления портами ввода-вывода в маске Simulink
|
||||
% Генерирует конфигурационные файлы для портов на основе параметров маски
|
||||
|
||||
methods(Static)
|
||||
|
||||
function write()
|
||||
% Основная функция записи конфигурации портов в файлы
|
||||
% Генерирует заголовочный файл и файл реализации для портов
|
||||
|
||||
block = gcb;
|
||||
mask = Simulink.Mask.get(block);
|
||||
hPath = fullfile('.\MCU_Wrapper', 'mcu_wrapper_conf.h');
|
||||
cPath = fullfile('.\MCU_Wrapper', 'mcu_wrapper.c');
|
||||
|
||||
% Пути к конфигурационным файлам
|
||||
hPath = fullfile(mcuPath.get('wrapperPath'), 'mcu_wrapper_conf.h');
|
||||
cPath = fullfile(mcuPath.get('wrapperPath'), 'mcu_wrapper.c');
|
||||
|
||||
% Устанавливаем значения по умолчанию для неиспользуемых портов
|
||||
mcuPorts.defaultUnused();
|
||||
%% CREATE
|
||||
|
||||
%% СОЗДАНИЕ КОНФИГУРАЦИИ ДЛЯ ВХОДНЫХ ПОРТОВ
|
||||
prefixNumb = 'IN';
|
||||
[widths, portPrefixes] = mcuPorts.getMaskNames('in');
|
||||
|
||||
% Генерируем текст для заголовочного файла и файла реализации
|
||||
headerText = mcuPorts.addPortHeaderDefines('', widths, prefixNumb, portPrefixes);
|
||||
cText = mcuPorts.addPortCDefines('', widths, prefixNumb, portPrefixes);
|
||||
|
||||
%% СОЗДАНИЕ КОНФИГУРАЦИИ ДЛЯ ВЫХОДНЫХ ПОРТОВ
|
||||
prefixNumb = 'OUT';
|
||||
[widths, portPrefixes] = mcuPorts.getMaskNames('out');
|
||||
|
||||
% Добавляем выходные порты к существующей конфигурации
|
||||
headerText = mcuPorts.addPortHeaderDefines(headerText, widths, prefixNumb, portPrefixes);
|
||||
cText = mcuPorts.addPortCDefines(cText, widths, prefixNumb, portPrefixes);
|
||||
|
||||
%% WRITE
|
||||
|
||||
%% ЗАПИСЬ В ФАЙЛЫ
|
||||
% Читаем существующее содержимое файлов
|
||||
hCode = fileread(hPath);
|
||||
hCode = regexprep(hCode, '\r\n?', '\n');
|
||||
cCode = fileread(cPath);
|
||||
cCode = regexprep(cCode, '\r\n?', '\n');
|
||||
|
||||
% Вставляем сгенерированную конфигурацию в заголовочный файл
|
||||
code = editCode.insertSection(hCode, '// INPUT/OUTPUTS PARAMS', headerText.PARAMS);
|
||||
code = editCode.insertSection(code, '// INPUT/OUTPUTS AUTO-PARAMS', headerText.AUTO_PARAMS);
|
||||
|
||||
fid = fopen(hPath, 'w', 'n', 'UTF-8');
|
||||
% Записываем обновленный заголовочный файл
|
||||
fid = fopen(hPath, 'w', 'n');
|
||||
if fid == -1
|
||||
error('Не удалось открыть файл для записи');
|
||||
end
|
||||
fwrite(fid, code);
|
||||
fclose(fid);
|
||||
|
||||
% Вставляем сгенерированную конфигурацию в файл реализации
|
||||
code = editCode.insertSection(cCode, '// INPUT/OUTPUTS AUTO-PARAMS', cText);
|
||||
fid = fopen(cPath, 'w', 'n', 'UTF-8');
|
||||
|
||||
% Записываем обновленный файл реализации
|
||||
fid = fopen(cPath, 'w', 'n');
|
||||
if fid == -1
|
||||
error('Не удалось открыть файл для записи');
|
||||
end
|
||||
@ -47,39 +65,46 @@ classdef mcuPorts
|
||||
fclose(fid);
|
||||
end
|
||||
|
||||
|
||||
function [portwidth, defnames] = getMaskNames(port_prefix)
|
||||
% Получение имен и ширин портов из параметров маски
|
||||
% port_prefix - префикс портов ('in' или 'out')
|
||||
% Возвращает ширины портов и их имена
|
||||
|
||||
block = gcb;
|
||||
% Получаем значение из спиннера
|
||||
mask = Simulink.Mask.get(block);
|
||||
|
||||
% Получаем количество портов из спиннера
|
||||
paramName = sprintf('%sNumb', port_prefix);
|
||||
param = mask.getParameter(paramName);
|
||||
numb = str2double(param.Value);
|
||||
|
||||
|
||||
% Инициализируем массив для значений
|
||||
% Инициализируем массивы для имен и ширин портов
|
||||
defnames = strings(1, numb);
|
||||
portwidth = [];
|
||||
|
||||
% Чтение значений edit-параметров
|
||||
% Читаем значения параметров для каждого порта
|
||||
for i = 1:numb
|
||||
% Получаем имя порта
|
||||
paramName = sprintf('%s_port_%d_name', port_prefix, i);
|
||||
param = mask.getParameter(paramName);
|
||||
defnames(i) = param.Value;
|
||||
|
||||
% Получаем ширину порта
|
||||
paramName = sprintf('%s_port_%d_width', port_prefix, i);
|
||||
param = mask.getParameter(paramName);
|
||||
portwidth(i) = str2double(param.Value);
|
||||
end
|
||||
end
|
||||
|
||||
|
||||
function updateMask()
|
||||
% Обновление видимости параметров портов в маске
|
||||
% Вызывается при изменении количества портов
|
||||
mcuPorts.updateMask_prefix('in');
|
||||
mcuPorts.updateMask_prefix('out');
|
||||
end
|
||||
|
||||
|
||||
function defaultUnused()
|
||||
% Установка значений по умолчанию для неиспользуемых портов
|
||||
mcuPorts.defaultUnused_prefix('in');
|
||||
mcuPorts.defaultUnused_prefix('out');
|
||||
end
|
||||
@ -87,84 +112,93 @@ classdef mcuPorts
|
||||
|
||||
methods(Static, Access=private)
|
||||
|
||||
|
||||
|
||||
function updateMask_prefix(port_prefix)
|
||||
% Обновление видимости параметров для конкретного типа портов
|
||||
% port_prefix - префикс портов ('in' или 'out')
|
||||
|
||||
block = gcb;
|
||||
% Получаем значение из спиннера
|
||||
mask = Simulink.Mask.get(block);
|
||||
|
||||
% Получаем текущее количество портов
|
||||
paramName = sprintf('%sNumb', port_prefix);
|
||||
param = mask.getParameter(paramName);
|
||||
n = str2double(param.Value);
|
||||
|
||||
% Максимальное количество портов
|
||||
% Максимальное количество портов из диапазона параметра
|
||||
maxPorts = param.Range(2);
|
||||
|
||||
% Проходим по всем edit-полям
|
||||
% Обходим все возможные порты
|
||||
for i = 1:maxPorts
|
||||
% Формируем имя параметра
|
||||
% Формируем имена параметров для имени и ширины порта
|
||||
paramDefName = sprintf('%s_port_%d_name', port_prefix, i);
|
||||
paramWidthName = sprintf('%s_port_%d_width', port_prefix, i);
|
||||
paramDef = mask.getParameter(paramDefName);
|
||||
paramWidth = mask.getParameter(paramWidthName);
|
||||
|
||||
if i <= n
|
||||
% Показываем параметр
|
||||
% Показываем параметры для используемых портов
|
||||
paramDef.Visible = 'on';
|
||||
paramWidth.Visible = 'on';
|
||||
|
||||
% Если значение пустое — задаём дефолтное
|
||||
% Устанавливаем значения по умолчанию если пустые
|
||||
if isempty(strtrim(paramDef.Value))
|
||||
paramDef.Value = upper(port_prefix);
|
||||
end
|
||||
% Если значение пустое — задаём дефолтное
|
||||
if isempty(strtrim(paramWidth.Value)) || strcmp(paramWidth.Value, '0')
|
||||
paramWidth.Value = '16';
|
||||
end
|
||||
else
|
||||
% Скрываем параметр
|
||||
% Скрываем параметры для неиспользуемых портов
|
||||
paramDef.Visible = 'off';
|
||||
paramWidth.Visible = 'off';
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
|
||||
function defaultUnused_prefix(port_prefix)
|
||||
% Установка значений по умолчанию для неиспользуемых портов
|
||||
% port_prefix - префикс портов ('in' или 'out')
|
||||
|
||||
block = gcb;
|
||||
% Получаем значение из спиннера
|
||||
mask = Simulink.Mask.get(block);
|
||||
|
||||
% Получаем количество используемых портов
|
||||
paramName = sprintf('%sNumb', port_prefix);
|
||||
param = mask.getParameter(paramName);
|
||||
numb = str2double(param.Value);
|
||||
|
||||
% Максимальное количество портов
|
||||
maxPorts = param.Range(2);
|
||||
% Чтение значений edit-параметров
|
||||
|
||||
% Устанавливаем значения по умолчанию для неиспользуемых портов
|
||||
for i = numb+1:maxPorts
|
||||
paramName = sprintf('%s_port_%d_name', port_prefix, i);
|
||||
param = mask.getParameter(paramName);
|
||||
param.Value = upper(port_prefix);
|
||||
param.Value = upper(port_prefix); % Имя по умолчанию
|
||||
|
||||
paramName = sprintf('%s_port_%d_width', port_prefix, i);
|
||||
param = mask.getParameter(paramName);
|
||||
param.Value = '16';
|
||||
param.Value = '16'; % Ширина по умолчанию
|
||||
end
|
||||
end
|
||||
|
||||
|
||||
function headerText = addPortHeaderDefines(existingText, widths, prefixNumb, portPrefixes)
|
||||
% existingText — структура с полями PARAMS, AUTO_PARAMS
|
||||
% widths — вектор ширин портов
|
||||
% prefixNumb — префикс общего счётчика (например, 'OUT')
|
||||
% portPrefixes — {'OUT', 'OUT', ...}
|
||||
% Генерация define-макросов для заголовочного файла
|
||||
% existingText - существующий текст конфигурации
|
||||
% widths - вектор ширин портов
|
||||
% prefixNumb - общий префикс ('IN' или 'OUT')
|
||||
% portPrefixes - массив префиксов для каждого порта
|
||||
% Возвращает структуру с PARAMS и AUTO_PARAMS
|
||||
|
||||
n = numel(widths);
|
||||
upperPrefix = upper(prefixNumb);
|
||||
|
||||
% === PARAMS ===
|
||||
% === БАЗОВЫЕ ПАРАМЕТРЫ ===
|
||||
lines = {
|
||||
sprintf('#define %s_PORT_NUMB %d', upperPrefix, n)
|
||||
};
|
||||
|
||||
% Добавляем define для ширины каждого порта
|
||||
for i = 1:n
|
||||
lines{end+1} = sprintf('#define %s_PORT_%d_WIDTH %d', ...
|
||||
upper(portPrefixes{i}), i, widths(i));
|
||||
@ -172,10 +206,10 @@ classdef mcuPorts
|
||||
newParams = strjoin(lines, newline);
|
||||
newParams = [newParams, newline];
|
||||
|
||||
% === AUTO-PARAMS ===
|
||||
% === АВТОМАТИЧЕСКИ ГЕНЕРИРУЕМЫЕ ПАРАМЕТРЫ ===
|
||||
lines = {};
|
||||
|
||||
% Формируем выражение суммы ширин с добавлением PORT
|
||||
% Формируем выражение для общего размера буфера
|
||||
sumExprParts = cell(1,n);
|
||||
for i = 1:n
|
||||
sumExprParts{i} = sprintf('%s_PORT_%d_WIDTH', upper(portPrefixes{i}), i);
|
||||
@ -188,6 +222,7 @@ 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);
|
||||
@ -198,7 +233,7 @@ classdef mcuPorts
|
||||
end
|
||||
newAuto = strjoin(lines, newline);
|
||||
|
||||
% === Добавление к существующему ===
|
||||
% === ОБЪЕДИНЕНИЕ С СУЩЕСТВУЮЩИМ ТЕКСТОМ ===
|
||||
if isfield(existingText, 'PARAMS')
|
||||
headerText.PARAMS = [existingText.PARAMS, newline, newParams];
|
||||
else
|
||||
@ -212,12 +247,13 @@ classdef mcuPorts
|
||||
end
|
||||
end
|
||||
|
||||
|
||||
function cText = addPortCDefines(existingText, widths, prefixNumb, portPrefixes)
|
||||
% existingText — существующий текст .c
|
||||
% widths — вектор ширин портов
|
||||
% prefixNumb — общий префикс ('OUT')
|
||||
% portPrefixes — {'OUT', 'LOG', ...}
|
||||
% Генерация кода для файла реализации (.c)
|
||||
% existingText - существующий текст
|
||||
% widths - вектор ширин портов
|
||||
% prefixNumb - общий префикс ('IN' или 'OUT')
|
||||
% portPrefixes - массив префиксов для каждого порта
|
||||
% Возвращает текст для вставки в .c файл
|
||||
|
||||
n = numel(widths);
|
||||
upperPrefix = upper(prefixNumb);
|
||||
@ -225,27 +261,29 @@ classdef mcuPorts
|
||||
|
||||
lines = {};
|
||||
|
||||
% === Таблица длин ===
|
||||
% === ТАБЛИЦА ДЛИН МАССИВОВ ===
|
||||
lines{end+1} = '/**';
|
||||
lines{end+1} = sprintf(' * @brief Таблица длин массивов %s', upperPrefix);
|
||||
lines{end+1} = ' */';
|
||||
% Здесь используем общий префикс для количества портов
|
||||
lines{end+1} = sprintf('const int %sLengths[%s_PORT_NUMB] = {', lowerPrefix, upperPrefix);
|
||||
|
||||
% Заполняем таблицу длин
|
||||
for i = 1:n
|
||||
comma = ',';
|
||||
if i == n
|
||||
comma = '';
|
||||
end
|
||||
% Используем макросы с портовыми префиксами из portPrefixes
|
||||
lines{end+1} = sprintf(' %s_PORT_%d_WIDTH%s', upper(portPrefixes{i}), i, comma);
|
||||
end
|
||||
lines{end+1} = '};';
|
||||
|
||||
% === Таблица смещений ===
|
||||
% === ТАБЛИЦА СМЕЩЕНИЙ ===
|
||||
lines{end+1} = '/**';
|
||||
lines{end+1} = sprintf(' * @brief Таблица смещений в выходном массиве %s', upperPrefix);
|
||||
lines{end+1} = ' */';
|
||||
lines{end+1} = sprintf('const int %sOffsets[%s_PORT_NUMB] = {', lowerPrefix, upperPrefix);
|
||||
|
||||
% Заполняем таблицу смещений
|
||||
for i = 1:n
|
||||
comma = ',';
|
||||
if i == n
|
||||
@ -258,6 +296,7 @@ classdef mcuPorts
|
||||
|
||||
newText = strjoin(lines, newline);
|
||||
|
||||
% Объединяем с существующим текстом
|
||||
if nargin < 1 || isempty(existingText)
|
||||
cText = newText;
|
||||
else
|
||||
@ -265,20 +304,14 @@ classdef mcuPorts
|
||||
end
|
||||
end
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
function val = iff(cond, a, b)
|
||||
% Условное выражение inline
|
||||
% Вспомогательная функция - тернарный оператор
|
||||
% cond - условие, a - значение если true, b - значение если false
|
||||
if cond
|
||||
val = a;
|
||||
else
|
||||
val = b;
|
||||
end
|
||||
end
|
||||
|
||||
|
||||
end
|
||||
|
||||
end
|
||||
@ -1,144 +1,153 @@
|
||||
% Компилирует S-function
|
||||
% Компилирует S-function для блока микроконтроллера в Simulink
|
||||
% compile_mode: 1 - компиляция, 0 - обновление конфигурации
|
||||
function res = mexing(compile_mode)
|
||||
global Ts
|
||||
Ts = 0.00001;
|
||||
Ts = 0.00001; % Установка глобального времени дискретизации
|
||||
|
||||
if compile_mode == 1
|
||||
delete("*.mexw64")
|
||||
delete("*.mexw64.pdb")
|
||||
delete(".\MCU_Wrapper\Outputs\*.*");
|
||||
set_param(gcb, 'consoleOutput', '');
|
||||
% Дефайны
|
||||
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
|
||||
cmd = sprintf('.\\MCU_Wrapper\\run_mex.bat %s "%s" "%s" "%s" "%s" %s %s', 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);
|
||||
% === РЕЖИМ КОМПИЛЯЦИИ ===
|
||||
setenv('VSLANG', '1033'); % Английский для Visual Studio
|
||||
|
||||
% Обновление параметров блока
|
||||
block = gcb;
|
||||
|
||||
newName = get_param(block, 'sfuncName');
|
||||
oldName = get_param(block, 'FunctionName');
|
||||
if ~strcmp(newName, oldName)
|
||||
set_param(block, 'FunctionName', newName);
|
||||
set_param(block, 'FunctionName', newName); % Обновление имени функции
|
||||
end
|
||||
|
||||
newParam = get_param(block, 'sfuncParam');
|
||||
oldParam = get_param(block, 'Parameters');
|
||||
if ~strcmp(newParam, oldParam)
|
||||
set_param(block, 'Parameters', newParam);
|
||||
set_param(block, 'Parameters', newParam); % Обновление параметров
|
||||
end
|
||||
|
||||
% Очистка предыдущих файлов компиляции
|
||||
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 = periphConfig.read_config(blockPath);
|
||||
config = periphConfig.update_config(blockPath, config);
|
||||
periphConfig.write_config(config);
|
||||
periphConfig.update(blockPath, config);
|
||||
config = configJs.read(blockPath); % Чтение конфигурации
|
||||
config = configJs.update(blockPath, config); % Обновление конфигурации
|
||||
configJs.write(config); % Запись конфигурации
|
||||
periphConfig.updateMask(blockPath, config); % Обновление маски
|
||||
end
|
||||
end
|
||||
|
||||
%% COMPILE PARAMS
|
||||
|
||||
%% COMPILE PARAMS - функции формирования параметров компиляции
|
||||
|
||||
function [includesArg, codeArg] = make_mex_arguments(incTableName, srcTableame)
|
||||
%MAKE_MEX_ARGUMENTS Формирует строки аргументов для вызова mex-компиляции через батник
|
||||
%
|
||||
% [includesArg, codeArg] = make_mex_arguments(includesCell, codeCell)
|
||||
% Формирует строки аргументов для вызова mex-компиляции через батник
|
||||
%
|
||||
% Вход:
|
||||
% includesCell — ячейковый массив путей к директориям include
|
||||
% codeCell — ячейковый массив исходных файлов
|
||||
% incTableName - имя таблицы с путями включения
|
||||
% srcTableame - имя таблицы с исходными файлами
|
||||
%
|
||||
% Выход:
|
||||
% includesArg — строка для передачи в батник, например: "-I"inc1" -I"inc2""
|
||||
% codeArg — строка с исходниками, например: ""src1.c" "src2.cpp""
|
||||
% includesArg - строка с флагами включения (-I"path")
|
||||
% codeArg - строка с исходными файлами ("file1.c" "file2.cpp")
|
||||
|
||||
|
||||
% Здесь пример получения из маски текущего блока (замени по своему)
|
||||
% Получение данных из таблиц маски
|
||||
includesCell = customtable.parse(incTableName);
|
||||
codeCell = customtable.parse(srcTableame);
|
||||
|
||||
% Оборачиваем пути в кавычки и добавляем -I
|
||||
% Формирование строки путей включения с флагом -I
|
||||
includesStr = strjoin(cellfun(@(f) ['-I"' f '"'], includesCell, 'UniformOutput', false), ' ');
|
||||
|
||||
% Оборачиваем имена файлов в кавычки
|
||||
% Формирование строки исходных файлов в кавычках
|
||||
codeStr = strjoin(cellfun(@(f) ['"' f '"'], codeCell, 'UniformOutput', false), ' ');
|
||||
|
||||
% Удаляем символ переноса строки и пробел в конце, если вдруг попал
|
||||
% Удаление лишних пробелов
|
||||
codeStr = strtrim(codeStr);
|
||||
includesStr = strtrim(includesStr);
|
||||
|
||||
% Оборачиваем всю строку в кавычки, чтобы батник корректно понял
|
||||
% includesArg = ['"' includesStr '"'];
|
||||
% codeArg = ['"' codeStr '"'];
|
||||
includesArg = includesStr;
|
||||
codeArg = codeStr;
|
||||
|
||||
end
|
||||
|
||||
|
||||
function definesWrapperArg = buildWrapperDefinesString()
|
||||
% Формирование дефайнов для конфигурации обёртки
|
||||
|
||||
definesWrapperArg = '';
|
||||
% Добавление дефайнов из параметров маски
|
||||
definesWrapperArg = addDefineByParam(definesWrapperArg, 'enableThreading', 0);
|
||||
definesWrapperArg = addDefineByParam(definesWrapperArg, 'enableDeinit', 0);
|
||||
definesWrapperArg = addDefineByParam(definesWrapperArg, 'threadCycles', 1);
|
||||
definesWrapperArg = addDefineByParam(definesWrapperArg, 'mcuClk', 1);
|
||||
end
|
||||
|
||||
|
||||
function definesUserArg = parseDefinesMaskText()
|
||||
% Парсинг пользовательских дефайнов из текстового поля маски
|
||||
|
||||
blockHandle = gcbh;
|
||||
% Получаем MaskValues и MaskNames
|
||||
% Получение параметров маски
|
||||
maskValues = get_param(blockHandle, 'MaskValues');
|
||||
paramNames = get_param(blockHandle, 'MaskNames');
|
||||
|
||||
% Индекс параметра userDefs
|
||||
% Поиск параметра с пользовательскими дефайнами
|
||||
idxUserDefs = find(strcmp(paramNames, 'userDefs'));
|
||||
definesText = maskValues{idxUserDefs}; % Текст с пользовательскими определениями
|
||||
definesText = maskValues{idxUserDefs};
|
||||
|
||||
% Убираем буквальные символы \n и \r
|
||||
% Обработка специальных символов
|
||||
definesText = strrep(definesText, '\n', ' ');
|
||||
definesText = strrep(definesText, '\r', ' ');
|
||||
|
||||
% Разбиваем по переносам строк
|
||||
% Разбиение на строки
|
||||
lines = split(definesText, {'\n', '\r\n', '\r'});
|
||||
|
||||
parts = strings(1,0); % пустой массив строк
|
||||
parts = strings(1,0); % массив для хранения дефайнов
|
||||
|
||||
for k = 1:numel(lines)
|
||||
line = strtrim(lines{k});
|
||||
@ -146,7 +155,7 @@ function definesUserArg = parseDefinesMaskText()
|
||||
continue;
|
||||
end
|
||||
|
||||
% Разбиваем по пробелам, чтобы получить отдельные определения в строке
|
||||
% Разбиение строки на токены
|
||||
tokens = split(line);
|
||||
|
||||
for t = 1:numel(tokens)
|
||||
@ -155,11 +164,13 @@ function definesUserArg = parseDefinesMaskText()
|
||||
continue;
|
||||
end
|
||||
|
||||
% Обработка дефайнов с значениями и без
|
||||
eqIdx = strfind(token, '=');
|
||||
if isempty(eqIdx)
|
||||
% Просто ключ без значения
|
||||
% Дефайн без значения
|
||||
parts(end+1) = sprintf('-D"%s"', token);
|
||||
else
|
||||
% Дефайн со значением
|
||||
key = strtrim(token(1:eqIdx(1)-1));
|
||||
val = strtrim(token(eqIdx(1)+1:end));
|
||||
parts(end+1) = sprintf('-D"%s__EQ__%s"', key, val);
|
||||
@ -170,13 +181,13 @@ function definesUserArg = parseDefinesMaskText()
|
||||
definesUserArg = strjoin(parts, ' ');
|
||||
end
|
||||
|
||||
|
||||
|
||||
function definesWrapperArg = buildConfigDefinesString()
|
||||
% Формирование дефайнов из конфигурации периферии
|
||||
|
||||
blockHandle = gcbh;
|
||||
mask = Simulink.Mask.get(blockHandle);
|
||||
|
||||
tabName = 'configTabAll'; % Имя вкладки (Prompt)
|
||||
tabName = 'configTabAll'; % Имя вкладки с конфигурацией
|
||||
|
||||
tabCtrl = mask.getDialogControl(tabName);
|
||||
|
||||
@ -184,73 +195,91 @@ function definesWrapperArg = buildConfigDefinesString()
|
||||
error('Вкладка с названием "%s" не найдена в маске', tabName);
|
||||
end
|
||||
|
||||
|
||||
% Сбор всех параметров из вкладки конфигурации
|
||||
params = mcuMask.collect_all_parameters(tabCtrl);
|
||||
definesWrapperArg = '';
|
||||
for i = 1:numel(params)
|
||||
% Получаем имя параметра из контрола
|
||||
paramName = string(params(i));
|
||||
try
|
||||
% Получаем объект параметра по имени
|
||||
param = mask.getParameter(paramName);
|
||||
|
||||
% Определяем тип параметра
|
||||
% Обработка разных типов параметров
|
||||
switch lower(param.Type)
|
||||
case 'checkbox'
|
||||
definesWrapperArg = addDefineByParam(definesWrapperArg, paramName, 0);
|
||||
case 'edit'
|
||||
definesWrapperArg = addDefineByParam(definesWrapperArg, paramName, 1);
|
||||
case 'popup'
|
||||
definesWrapperArg = addDefineByParam(definesWrapperArg, paramName, 0);
|
||||
otherwise
|
||||
% Необрабатываемые типы
|
||||
% Пропуск необрабатываемых типов
|
||||
end
|
||||
catch ME
|
||||
% warning('Не удалось получить параметр "%s": %s', paramName, ME.message);
|
||||
% Игнорирование ошибок для отсутствующих параметров
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
|
||||
%% PARSE FUNCTIONS
|
||||
|
||||
function definesWrapperArg = addDefineByParam(definesWrapperArg, paramName, val_define)
|
||||
% Добавление дефайна на основе параметра маски
|
||||
|
||||
blockHandle = gcbh;
|
||||
mask = Simulink.Mask.get(blockHandle);
|
||||
|
||||
% Получаем MaskValues, MaskNames
|
||||
% Получение значений маски
|
||||
maskValues = get_param(blockHandle, 'MaskValues');
|
||||
paramNames = get_param(blockHandle, 'MaskNames');
|
||||
param = mask.getParameter(paramName); % для alias
|
||||
param = mask.getParameter(paramName);
|
||||
|
||||
% Найдём индекс нужного параметра
|
||||
% Поиск индекса параметра
|
||||
idxParam = find(strcmp(paramNames, paramName), 1);
|
||||
if isempty(idxParam)
|
||||
error('Parameter "%s" not found in block mask parameters.', paramName);
|
||||
end
|
||||
|
||||
% Берём alias из маски
|
||||
alias = param.Alias;
|
||||
% Определение имени дефайна (алиас или значение)
|
||||
val = '';
|
||||
if ~strcmp(param.Type, 'popup')
|
||||
def_name = param.Alias;
|
||||
else
|
||||
if strcmp(param.Alias, '')
|
||||
def_name = param.Value;
|
||||
else
|
||||
def_name = param.Alias;
|
||||
val = param.Value;
|
||||
end
|
||||
end
|
||||
|
||||
if strcmp(def_name, '')
|
||||
return;
|
||||
end
|
||||
|
||||
% Формирование дефайна в зависимости от типа параметра
|
||||
if val_define ~= 0
|
||||
% Значение параметра
|
||||
% Параметры с значениями
|
||||
val = maskValues{idxParam};
|
||||
if strcmp(param.Evaluate, 'on')
|
||||
val = evalin('base', val); % Вычисляем выражение
|
||||
val = num2str(val); % Преобразуем результат в строку
|
||||
val = evalin('base', val); % Вычисление выражений
|
||||
val = num2str(val);
|
||||
end
|
||||
% Формируем define с кавычками и значением
|
||||
newDefine = ['-D"' alias '__EQ__' val '"'];
|
||||
else
|
||||
newDefine = ['-D"' def_name '__EQ__' val '"'];
|
||||
elseif ~strcmp(param.Type, 'popup')
|
||||
% Чекбоксы
|
||||
if mcuMask.read_checkbox(paramName)
|
||||
% Формируем define с кавычками без значения
|
||||
newDefine = ['-D"' alias '"'];
|
||||
newDefine = ['-D"' def_name '"'];
|
||||
else
|
||||
newDefine = '';
|
||||
end
|
||||
else
|
||||
% Выпадающие списки
|
||||
if strcmp(param.Alias, '')
|
||||
newDefine = ['-D"' def_name '"'];
|
||||
else
|
||||
newDefine = ['-D"' def_name '__EQ__' val '"'];
|
||||
end
|
||||
end
|
||||
|
||||
|
||||
|
||||
% Добавляем новый define к существующему (string)
|
||||
% Добавление дефайна к результирующей строке
|
||||
if isempty(definesWrapperArg) || strlength(strtrim(definesWrapperArg)) == 0
|
||||
definesWrapperArg = newDefine;
|
||||
else
|
||||
@ -258,19 +287,22 @@ function definesWrapperArg = addDefineByParam(definesWrapperArg, paramName, val_
|
||||
end
|
||||
end
|
||||
|
||||
%% CONSOLE FUNCTIONS - функции работы с консолью
|
||||
|
||||
%% CONSOLE FUNCTIONS
|
||||
function cmdret = runBatAndShowOutput(cmd)
|
||||
% Запуск BAT-файла с отображением вывода в реальном времени
|
||||
|
||||
import java.io.*;
|
||||
import java.lang.*;
|
||||
cmdEnglish = ['chcp 437 > nul && ' cmd];
|
||||
|
||||
cmdEnglish = ['chcp 437 > nul && ' cmd]; % Установка английской кодировки
|
||||
pb = java.lang.ProcessBuilder({'cmd.exe', '/c', cmdEnglish});
|
||||
pb.redirectErrorStream(true);
|
||||
process = pb.start();
|
||||
|
||||
% Чтение вывода процесса
|
||||
reader = BufferedReader(InputStreamReader(process.getInputStream()));
|
||||
|
||||
cmdret = ""; % Здесь будем накапливать весь вывод
|
||||
cmdret = "";
|
||||
|
||||
while true
|
||||
if reader.ready()
|
||||
@ -278,36 +310,37 @@ function cmdret = runBatAndShowOutput(cmd)
|
||||
if isempty(line)
|
||||
break;
|
||||
end
|
||||
cmdret = cmdret + string(line) + newline; % сохраняем вывод
|
||||
% Здесь выводим только новую строку
|
||||
safeLine = strrep(line, '''', ''''''); % Экранируем апострофы
|
||||
logWindow_append(safeLine);
|
||||
drawnow; % обновляем GUI
|
||||
cmdret = cmdret + string(line) + newline;
|
||||
safeLine = strrep(line, '''', ''''''); % Экранирование кавычек
|
||||
logWindow_append(safeLine); % Вывод в окно лога
|
||||
drawnow;
|
||||
else
|
||||
if ~process.isAlive()
|
||||
% дочитываем оставшиеся строки
|
||||
% Дочтение оставшегося вывода
|
||||
while reader.ready()
|
||||
line = char(reader.readLine());
|
||||
if isempty(line)
|
||||
break;
|
||||
end
|
||||
cmdret = cmdret + string(line) + newline; % сохраняем вывод
|
||||
cmdret = cmdret + string(line) + newline;
|
||||
safeLine = strrep(line, '''', '''''');
|
||||
logWindow_append(safeLine);
|
||||
drawnow;
|
||||
end
|
||||
break;
|
||||
end
|
||||
pause(0.2);
|
||||
pause(0.2); % Пауза между проверками
|
||||
end
|
||||
end
|
||||
process.waitFor();
|
||||
end
|
||||
|
||||
|
||||
function logWindow_append(line)
|
||||
% Добавление строки в окно лога с автоскроллингом
|
||||
|
||||
persistent fig hEdit jScrollPane jTextArea
|
||||
|
||||
% Создание окна лога при первом вызове
|
||||
if isempty(fig) || ~isvalid(fig)
|
||||
fig = figure('Name', 'Log Window', 'Position', [100 100 600 400]);
|
||||
hEdit = uicontrol('Style', 'edit', ...
|
||||
@ -319,10 +352,12 @@ function logWindow_append(line)
|
||||
'BackgroundColor', 'white', ...
|
||||
'Tag', 'LogWindowFigure');
|
||||
|
||||
jScrollPane = findjobj(hEdit); % JScrollPane
|
||||
jTextArea = jScrollPane.getViewport.getView; % JTextArea внутри JScrollPane
|
||||
% Получение Java-компонентов для управления скроллингом
|
||||
jScrollPane = findjobj(hEdit);
|
||||
jTextArea = jScrollPane.getViewport.getView;
|
||||
end
|
||||
|
||||
% Добавление новой строки
|
||||
oldText = get(hEdit, 'String');
|
||||
if ischar(oldText)
|
||||
oldText = {oldText};
|
||||
@ -330,32 +365,30 @@ function logWindow_append(line)
|
||||
|
||||
set(hEdit, 'String', [oldText; {line}]);
|
||||
drawnow;
|
||||
% Автоскролл вниз:
|
||||
|
||||
% Автоскроллинг вниз
|
||||
jTextArea.setCaretPosition(jTextArea.getDocument.getLength);
|
||||
drawnow;
|
||||
end
|
||||
|
||||
|
||||
%% READ CONFIGS
|
||||
|
||||
function isOpen = isMaskDialogOpen(blockPath)
|
||||
% Проверка открыто ли диалоговое окно маски
|
||||
|
||||
isOpen = false;
|
||||
|
||||
try
|
||||
% Получаем имя блока
|
||||
blockName = get_param(blockPath, 'Name');
|
||||
|
||||
% Получаем список окон MATLAB GUI
|
||||
% Получение всех открытых окон Java
|
||||
jWindows = java.awt.Window.getWindows();
|
||||
|
||||
for i = 1:numel(jWindows)
|
||||
win = jWindows(i);
|
||||
|
||||
% Проверка, что окно видимое и активно
|
||||
if win.isShowing()
|
||||
try
|
||||
title = char(win.getTitle());
|
||||
% Проверка по ключевому слову, соответствующему заголовку маски
|
||||
% Поиск окна маски по заголовку
|
||||
if contains(title, ['Mask Editor: ' blockName]) || ...
|
||||
contains(title, ['Mask: ' blockName]) || ...
|
||||
contains(title, blockName)
|
||||
@ -363,7 +396,7 @@ function isOpen = isMaskDialogOpen(blockPath)
|
||||
return;
|
||||
end
|
||||
catch
|
||||
% Окно не имеет заголовка — пропускаем
|
||||
% Пропуск окон без заголовка
|
||||
end
|
||||
end
|
||||
end
|
||||
@ -371,4 +404,3 @@ function isOpen = isMaskDialogOpen(blockPath)
|
||||
isOpen = false;
|
||||
end
|
||||
end
|
||||
|
||||
|
||||
@ -1,102 +1,45 @@
|
||||
classdef periphConfig
|
||||
% Класс для управления конфигурацией периферии в маске Simulink
|
||||
% Динамически создает элементы маски на основе JSON конфигурации
|
||||
|
||||
methods(Static)
|
||||
function update(blockPath, config)
|
||||
% blockPath = [blockPath '/MCU'];
|
||||
function updateMask(blockPath, config)
|
||||
% Основная функция обновления маски на основе конфигурации
|
||||
% Динамически создает вкладки и параметры для периферийных модулей
|
||||
% blockPath - путь к блоку Simulink
|
||||
% config - структура конфигурации из JSON файла
|
||||
|
||||
% Проверяем, была ли маска открыта
|
||||
% wasOpen = isMaskDialogOpen(blockPath);
|
||||
mask = Simulink.Mask.get(blockPath);
|
||||
periphPath = get_param(blockPath, 'periphPath');
|
||||
[periphPath, ~, ~] = fileparts(periphPath);
|
||||
|
||||
% Сохраняем состояние таблиц перед изменением маски
|
||||
tableNames = {'incTable', 'srcTable'};
|
||||
columns_backup = customtable.save_all_tables(tableNames);
|
||||
|
||||
try
|
||||
% Получаем настройки ширины строк из параметра маски
|
||||
rowWidth = str2double(get_param(blockPath, 'rowWidth'));
|
||||
|
||||
% Очищаем контейнер конфигурации перед созданием новых элементов
|
||||
containerName = 'configTabAll';
|
||||
periphConfig.clear_all_from_container(mask, containerName);
|
||||
|
||||
% Ищем контейнер, в который будем добавлять вкладки
|
||||
% Получаем контейнер для вкладок конфигурации
|
||||
container = mask.getDialogControl(containerName);
|
||||
if isempty(container)
|
||||
error('Контейнер "%s" не найден в маске.', containerName);
|
||||
end
|
||||
|
||||
% Обрабатываем конфигурацию если она не пустая
|
||||
if ~isempty(config)
|
||||
|
||||
if isfield(config, 'Code')
|
||||
res = periphConfig.addCodeConfig(config.Code, periphPath);
|
||||
if res == 0
|
||||
error('Ошибка: неудачное добавление кода периферии. Проверьте корректность файлов и путей в конфигурационном файле')
|
||||
end
|
||||
else
|
||||
error('Ошибка: в конфигурационном файле не задан исходный код для симуляции периферии')
|
||||
end
|
||||
|
||||
if isfield(config, 'UserCode')
|
||||
res = periphConfig.addUserCodeConfig(config.UserCode);
|
||||
if res == 0
|
||||
error('Ошибка: неудачное добавление функций для симуляции. Проверьте корректность названий функций в конфигурационном файле')
|
||||
end
|
||||
else
|
||||
error('Ошибка: в конфигурационном файле не заданы функции для симуляции периферии')
|
||||
end
|
||||
|
||||
% Проходим по каждому модулю (ADC, TIM...)
|
||||
% Проходим по каждому модулю периферии (ADC, TIM, UART и т.д.)
|
||||
periphs = fieldnames(config);
|
||||
for i = 1:numel(periphs)
|
||||
periph = periphs{i};
|
||||
|
||||
% Пропускаем Code и UserCode, они уже обработаны
|
||||
if strcmp(periph, 'Code') || strcmp(periph, 'UserCode')
|
||||
continue;
|
||||
end
|
||||
% Сохраняем код модуля (исходники и инклюды) в скрытые параметры
|
||||
periphConfig.store_single_periph_code(mask, periph, config.(periph));
|
||||
|
||||
defines = config.(periph).Defines;
|
||||
defNames = fieldnames(defines);
|
||||
|
||||
% Создаём вкладку для модуля
|
||||
tabCtrl = container.addDialogControl('tab', periph);
|
||||
tabCtrl.Prompt = [periph ' Config'];
|
||||
|
||||
for j = 1:numel(defNames)
|
||||
defPrompt = defNames{j};
|
||||
def = defines.(defPrompt);
|
||||
|
||||
% Вызов функции добавления одного параметра
|
||||
periphConfig.addDefineConfig(mask, containerName, periph, defPrompt, def);
|
||||
end
|
||||
end
|
||||
end
|
||||
% Восстанавливаем таблицы
|
||||
customtable.restore_all_tables(tableNames, columns_backup);
|
||||
|
||||
% % Повторно открываем маску, если она была открыта
|
||||
% if wasOpen
|
||||
% open_system(blockPath, 'mask');
|
||||
% end
|
||||
end
|
||||
|
||||
function config = update_config(blockPath, config)
|
||||
if isempty(config)
|
||||
return;
|
||||
end
|
||||
|
||||
mask = Simulink.Mask.get(blockPath);
|
||||
maskParams = mask.Parameters;
|
||||
paramNames = arrayfun(@(p) p.Name, maskParams, 'UniformOutput', false);
|
||||
|
||||
% Обработка остальных секций (с дефайнами)
|
||||
periphs = fieldnames(config);
|
||||
for i = 1:numel(periphs)
|
||||
periph = periphs{i};
|
||||
|
||||
% Пропускаем Code и UserCode, они уже обработаны
|
||||
if strcmp(periph, 'Code') || strcmp(periph, 'UserCode')
|
||||
continue;
|
||||
end
|
||||
|
||||
% Проверяем есть ли Defines
|
||||
% Пропускаем модули без секции Defines
|
||||
if ~isfield(config.(periph), 'Defines')
|
||||
continue;
|
||||
end
|
||||
@ -104,77 +47,421 @@ classdef periphConfig
|
||||
defines = config.(periph).Defines;
|
||||
defNames = fieldnames(defines);
|
||||
|
||||
% Создаем вкладку для модуля периферии
|
||||
tabCtrl = container.addDialogControl('tab', periph);
|
||||
tabCtrl.Prompt = [periph ' Config']; % Отображаемое имя вкладки
|
||||
|
||||
% Карта для отслеживания количества строк в каждой вкладке
|
||||
rowCountMap = containers.Map();
|
||||
|
||||
% Добавляем все параметры Defines в созданную вкладку
|
||||
for j = 1:numel(defNames)
|
||||
defPrompt = defNames{j};
|
||||
paramName = matlab.lang.makeValidName(defPrompt);
|
||||
def = defines.(defPrompt);
|
||||
|
||||
% Проверка, существует ли параметр с таким именем
|
||||
if ismember(paramName, paramNames)
|
||||
param = mask.getParameter(paramName);
|
||||
valStr = param.Value;
|
||||
|
||||
% Проверяем, существует ли элемент defPrompt в структуре defines
|
||||
if isfield(defines, defPrompt)
|
||||
% Преобразуем строку в соответствующий тип
|
||||
if strcmpi(defines.(defPrompt).Type, 'checkbox')
|
||||
config.(periph).Defines.(defPrompt).Default = strcmpi(valStr, 'on');
|
||||
elseif strcmpi(defines.(defPrompt).Type, 'edit')
|
||||
valNum = str2double(valStr);
|
||||
if isnan(valNum)
|
||||
config.(periph).Defines.(defPrompt).Default = valStr;
|
||||
else
|
||||
config.(periph).Defines.(defPrompt).Default = valNum;
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
% Добавление одного параметра конфигурации
|
||||
periphConfig.addConfig(mask, containerName, periph, defPrompt, def, rowCountMap, rowWidth);
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
function config = read_config(blockPath)
|
||||
% Создаем скрытые параметры для хранения кода периферии
|
||||
periphConfig.create_all_code_storage_params(blockPath, config);
|
||||
|
||||
% Обновляем состояние маски (включение/выключение вкладок)
|
||||
periphConfig.update();
|
||||
|
||||
% Восстанавливаем таблицы после изменений
|
||||
customtable.restore_all_tables(tableNames, columns_backup);
|
||||
catch
|
||||
% В случае ошибки восстанавливаем таблицы
|
||||
customtable.restore_all_tables(tableNames, columns_backup);
|
||||
end
|
||||
end
|
||||
|
||||
function update()
|
||||
% Обновление состояния маски - включение/выключение вкладок
|
||||
% на основе состояний чекбоксов управления
|
||||
|
||||
blockPath = gcb;
|
||||
mask = Simulink.Mask.get(blockPath);
|
||||
|
||||
pathparam = mask.getParameter('periphPath');
|
||||
config_path = pathparam.Value;
|
||||
% Читаем текущую конфигурацию
|
||||
config = configJs.read(blockPath);
|
||||
containerName = 'configTabAll';
|
||||
container = mask.getDialogControl(containerName);
|
||||
|
||||
if ~isempty(config_path)
|
||||
jsonText = fileread(config_path);
|
||||
config = jsondecode(jsonText);
|
||||
% Получаем все параметры для проверки наличия чекбоксов
|
||||
paramsAll = mcuMask.collect_all_parameters(container);
|
||||
|
||||
% Получаем имена всех вкладок в контейнере
|
||||
allTabs = container.DialogControls;
|
||||
allTabNames = arrayfun(@(t) t.Name, allTabs, 'UniformOutput', false);
|
||||
|
||||
fieldsConfig = fieldnames(config);
|
||||
|
||||
% Обрабатываем каждую вкладку
|
||||
for i = 1:length(allTabNames)
|
||||
periph = fieldsConfig{i};
|
||||
|
||||
% Проверяем наличие чекбокса управления для этой вкладки
|
||||
checkboxName = ['Tab_' periph '_Enable'];
|
||||
if ismember(checkboxName, paramsAll)
|
||||
% Чекбокс найден - управляем состоянием вкладки
|
||||
paramObj = mask.getParameter(checkboxName);
|
||||
val = paramObj.Value;
|
||||
|
||||
try
|
||||
tab = container.getDialogControl(periph);
|
||||
if strcmpi(val, 'off')
|
||||
% Выключаем вкладку и очищаем связанные параметры
|
||||
tab.Enabled = 'off';
|
||||
periphConfig.clear_tab_params(mask, config.(periph), periph);
|
||||
else
|
||||
config = [];
|
||||
% Включаем вкладку и синхронизируем параметры
|
||||
tab.Enabled = 'on';
|
||||
periphConfig.sync_tab_params(mask, config.(periph), periph);
|
||||
end
|
||||
catch
|
||||
warning('Вкладка с именем "%s" не найдена.', periph);
|
||||
end
|
||||
|
||||
else
|
||||
% Чекбокса нет - просто включаем вкладку
|
||||
try
|
||||
tab = container.getDialogControl(periph);
|
||||
tab.Enabled = 'on';
|
||||
% Синхронизируем параметры если есть конфигурация
|
||||
if isfield(config, periph)
|
||||
periphConfig.sync_tab_params(mask, config.(periph), periph);
|
||||
end
|
||||
catch
|
||||
% Вкладка может быть необязательной - игнорируем ошибку
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
function write_config(config)
|
||||
if isempty(config)
|
||||
return
|
||||
function periphParamCallback(paramName)
|
||||
% Callback-функция для параметров периферии
|
||||
% Обрабатывает изменения чекбоксов и других параметров
|
||||
|
||||
blockPath = gcb;
|
||||
mask = Simulink.Mask.get(blockPath);
|
||||
hObj = mask.getParameter(paramName);
|
||||
config = configJs.read(blockPath);
|
||||
container = mask.getDialogControl('configTabAll');
|
||||
|
||||
% === Обработка чекбоксов управления вкладками ===
|
||||
exprTab = '^Tab_(\w+)_Enable$';
|
||||
tokensTab = regexp(paramName, exprTab, 'tokens');
|
||||
|
||||
if ~isempty(tokensTab)
|
||||
periph = tokensTab{1}{1};
|
||||
|
||||
try
|
||||
tab = container.getDialogControl(periph);
|
||||
paramVal = hObj.Value;
|
||||
|
||||
if strcmpi(paramVal, 'off')
|
||||
% Выключаем вкладку и очищаем параметры
|
||||
tab.Enabled = 'off';
|
||||
if isfield(config, periph)
|
||||
periphConfig.clear_tab_params(mask, config.(periph), periph);
|
||||
end
|
||||
else
|
||||
% Включаем вкладку и синхронизируем параметры
|
||||
tab.Enabled = 'on';
|
||||
if isfield(config, periph)
|
||||
periphConfig.sync_tab_params(mask, config.(periph), periph);
|
||||
end
|
||||
end
|
||||
catch
|
||||
warning('Ошибка обработки вкладки "%s".', periph);
|
||||
end
|
||||
return;
|
||||
end
|
||||
|
||||
blockHandle = gcbh;
|
||||
mask = Simulink.Mask.get(blockHandle);
|
||||
% === Обработка параметров, связанных с Sources/Includes ===
|
||||
nameBase = paramName;
|
||||
|
||||
pathparam = mask.getParameter('periphPath');
|
||||
config_path = pathparam.Value;
|
||||
paramNames = string({mask.Parameters.Name});
|
||||
hasSources = any(paramNames == "Hidden_" + nameBase + "_Sources");
|
||||
hasIncludes = any(paramNames == "Hidden_" + nameBase + "_Includes");
|
||||
|
||||
jsonText = jsonencode(config, 'PrettyPrint', true);
|
||||
fid = fopen(config_path, 'w', 'n', 'UTF-8');
|
||||
if fid == -1
|
||||
error('Не удалось открыть файл periph_config.json для записи.');
|
||||
if hasSources || hasIncludes
|
||||
useVal = hObj.Value;
|
||||
|
||||
% Получаем структуру конфигурации для этого параметра
|
||||
try
|
||||
valueStruct = configJs.get_field(config, nameBase);
|
||||
catch
|
||||
warning('Не удалось найти путь %s в config.', nameBase);
|
||||
return;
|
||||
end
|
||||
fwrite(fid, jsonText, 'char');
|
||||
fclose(fid);
|
||||
|
||||
if strcmpi(useVal, 'on')
|
||||
% Сохраняем код если параметр включен
|
||||
try
|
||||
periphConfig.store_single_periph_code(mask, nameBase, valueStruct);
|
||||
catch
|
||||
warning('Не удалось сохранить параметры для %s.', nameBase);
|
||||
end
|
||||
else
|
||||
% Очищаем код если параметр выключен
|
||||
periphConfig.clear_single_periph_code_param(mask, nameBase);
|
||||
end
|
||||
return;
|
||||
end
|
||||
end
|
||||
|
||||
function updatePeriphRunMexBat()
|
||||
% Обновление BAT-файла для компиляции с кодом периферии
|
||||
% Собирает все исходники и инклюды из скрытых параметров
|
||||
|
||||
blockPath = gcb;
|
||||
% Восстанавливаем код периферии из скрытых параметров маски
|
||||
CodeStruct = periphConfig.restore_periph_code_from_mask(blockPath);
|
||||
periphPath = mcuPath.get('periphPath');
|
||||
[periphPath, ~, ~] = fileparts(periphPath);
|
||||
|
||||
% Добавляем код в BAT-файл компиляции
|
||||
periphConfig.addCodeBat(CodeStruct, periphPath);
|
||||
end
|
||||
end
|
||||
|
||||
methods(Static, Access=private)
|
||||
function addHiddenParam(mask, containerName, nameBase, kind, existingParams)
|
||||
% Создание скрытого параметра для хранения кода
|
||||
% nameBase - базовое имя параметра
|
||||
% kind - тип ('Sources' или 'Includes')
|
||||
|
||||
prettyName = strrep(nameBase, '_', ' ');
|
||||
paramName = ['Hidden_' char(nameBase) '_' kind];
|
||||
|
||||
% Проверяем не существует ли уже параметр
|
||||
if ismember(paramName, existingParams)
|
||||
return;
|
||||
end
|
||||
|
||||
% Создаем скрытый параметр
|
||||
mask.addParameter( ...
|
||||
'Name', paramName, ...
|
||||
'Type', 'edit', ...
|
||||
'Prompt', ['Hidden ' prettyName ' ' kind], ...
|
||||
'Value', '', ...
|
||||
'Visible', 'off', ...
|
||||
'Container', containerName ...
|
||||
);
|
||||
end
|
||||
|
||||
function clear_tab_params(mask, configStruct, prefix, depth)
|
||||
% Рекурсивная очистка параметров вкладки
|
||||
% Используется при выключении вкладки
|
||||
|
||||
if nargin < 4
|
||||
depth = 0;
|
||||
end
|
||||
maxDepth = 3; % Ограничение глубины рекурсии
|
||||
|
||||
fields = fieldnames(configStruct);
|
||||
|
||||
for i = 1:numel(fields)
|
||||
key = fields{i};
|
||||
value = configStruct.(key);
|
||||
paramName = [prefix '_' key];
|
||||
|
||||
if isstruct(value)
|
||||
if depth < maxDepth
|
||||
% Рекурсивный вызов для вложенных структур
|
||||
periphConfig.clear_tab_params(mask, value, paramName, depth + 1);
|
||||
end
|
||||
else
|
||||
% Очищаем параметры Sources/Includes
|
||||
if strcmp(key, 'Sources') || strcmp(key, 'Includes')
|
||||
baseName = configJs.get_final_name_from_prefix(prefix);
|
||||
periphConfig.clear_single_periph_code_param(mask, baseName);
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
function sync_tab_params(mask, configStruct, prefix, depth)
|
||||
% Рекурсивная синхронизация параметров вкладки
|
||||
% Используется при включении вкладки
|
||||
|
||||
if nargin < 4
|
||||
depth = 0;
|
||||
end
|
||||
maxDepth = 3;
|
||||
|
||||
fields = fieldnames(configStruct);
|
||||
|
||||
for i = 1:numel(fields)
|
||||
key = fields{i};
|
||||
value = configStruct.(key);
|
||||
paramName = [prefix '_' key];
|
||||
|
||||
if isstruct(value)
|
||||
if depth < maxDepth
|
||||
periphConfig.sync_tab_params(mask, value, paramName, depth + 1);
|
||||
end
|
||||
else
|
||||
if strcmp(key, 'Sources') || strcmp(key, 'Includes')
|
||||
baseName = configJs.get_final_name_from_prefix(prefix);
|
||||
periphConfig.store_single_periph_code(mask, baseName, configStruct);
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
function create_all_code_storage_params(blockPath, config)
|
||||
% Создание всех скрытых параметров для хранения кода периферии
|
||||
|
||||
mask = Simulink.Mask.get(blockPath);
|
||||
|
||||
containerName = 'configTabAll';
|
||||
container = mask.getDialogControl(containerName);
|
||||
existingParams = mcuMask.collect_all_parameters(container);
|
||||
|
||||
% Создаем скрытую вкладку для хранения параметров кода
|
||||
tabName = 'hiddenCodeTab';
|
||||
tab = mask.getDialogControl(tabName);
|
||||
if isempty(tab)
|
||||
tab = container.addDialogControl('tab', tabName);
|
||||
tab.Prompt = 'Hidden Code Settings';
|
||||
tab.Visible = 'off';
|
||||
else
|
||||
tab.Visible = 'off';
|
||||
end
|
||||
|
||||
% Рекурсивный обход конфигурации для создания параметров
|
||||
periphConfig.process_struct_recursive(mask, tabName, config, {}, existingParams);
|
||||
end
|
||||
|
||||
function process_struct_recursive(mask, tabName, currentStruct, nameStack, existingParams)
|
||||
% Рекурсивный обход структуры конфигурации
|
||||
% Создает скрытые параметры для всех Sources и Includes
|
||||
|
||||
fields = fieldnames(currentStruct);
|
||||
for i = 1:numel(fields)
|
||||
fieldName = fields{i};
|
||||
value = currentStruct.(fieldName);
|
||||
newStack = [nameStack, fieldName];
|
||||
|
||||
if isstruct(value)
|
||||
% Проверяем наличие Sources и Includes в структуре
|
||||
hasSources = isfield(value, 'Sources');
|
||||
hasIncludes = isfield(value, 'Includes');
|
||||
|
||||
if hasSources
|
||||
periphConfig.addHiddenParam(mask, tabName, fieldName, 'Sources', existingParams);
|
||||
end
|
||||
if hasIncludes
|
||||
periphConfig.addHiddenParam(mask, tabName, fieldName, 'Includes', existingParams);
|
||||
end
|
||||
|
||||
% Рекурсивно продолжаем обход
|
||||
periphConfig.process_struct_recursive(mask, tabName, value, newStack, existingParams);
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
function cleanup_obsolete_code_params(blockPath, config)
|
||||
% Очистка устаревших скрытых параметров
|
||||
% Удаляет параметры для периферии, которой больше нет в конфигурации
|
||||
|
||||
mask = Simulink.Mask.get(blockPath);
|
||||
maskParams = mask.Parameters;
|
||||
|
||||
% Получаем список актуальных периферийных модулей
|
||||
validPeriphs = fieldnames(config);
|
||||
|
||||
for i = 1:numel(maskParams)
|
||||
paramName = maskParams(i).Name;
|
||||
|
||||
% Ищем параметры хранения кода
|
||||
expr = '^Hidden_(\w+)_(Sources|Includes)$';
|
||||
tokens = regexp(paramName, expr, 'tokens');
|
||||
if ~isempty(tokens)
|
||||
periph = tokens{1}{1};
|
||||
|
||||
% Удаляем параметр если периферия больше не существует
|
||||
if ~ismember(periph, validPeriphs)
|
||||
mask.removeParameter(paramName);
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
function codeStruct = restore_periph_code_from_mask(blockPath)
|
||||
% Восстановление кода периферии из скрытых параметров маски
|
||||
% Собирает все Sources и Includes в одну структуру
|
||||
|
||||
mask = Simulink.Mask.get(blockPath);
|
||||
maskParams = mask.Parameters;
|
||||
|
||||
allSources = {};
|
||||
allIncludes = {};
|
||||
|
||||
for i = 1:numel(maskParams)
|
||||
name = maskParams(i).Name;
|
||||
|
||||
% Поиск параметров Sources
|
||||
tokensSrc = regexp(name, '^Hidden_(\w+)_Sources$', 'tokens');
|
||||
if ~isempty(tokensSrc)
|
||||
val = maskParams(i).Value;
|
||||
|
||||
if ischar(val) || isstring(val)
|
||||
valStr = strtrim(char(val));
|
||||
% Пропускаем пустые значения
|
||||
if isempty(valStr) || strcmp(valStr, '[]')
|
||||
continue;
|
||||
end
|
||||
|
||||
% Разбиваем на строки и фильтруем пустые
|
||||
lines = splitlines(valStr);
|
||||
lines = lines(~cellfun(@(x) all(isspace(x)) || isempty(x), lines));
|
||||
allSources = [allSources; lines];
|
||||
end
|
||||
continue;
|
||||
end
|
||||
|
||||
% Поиск параметров Includes
|
||||
tokensInc = regexp(name, '^Hidden_(\w+)_Includes$', 'tokens');
|
||||
if ~isempty(tokensInc)
|
||||
val = maskParams(i).Value;
|
||||
|
||||
if ischar(val) || isstring(val)
|
||||
valStr = strtrim(char(val));
|
||||
if isempty(valStr) || strcmp(valStr, '[]')
|
||||
continue;
|
||||
end
|
||||
|
||||
lines = splitlines(valStr);
|
||||
lines = lines(~cellfun(@(x) all(isspace(x)) || isempty(x), lines));
|
||||
allIncludes = [allIncludes; lines];
|
||||
end
|
||||
continue;
|
||||
end
|
||||
end
|
||||
|
||||
% Формируем результирующую структуру
|
||||
codeStruct = struct();
|
||||
codeStruct.Sources = allSources;
|
||||
codeStruct.Includes = allIncludes;
|
||||
end
|
||||
|
||||
function clear_all_from_container(mask, containerName)
|
||||
% allControls = mask.getDialogControls();
|
||||
% Полная очистка контейнера - удаление всех параметров и вкладок
|
||||
|
||||
container = mask.getDialogControl(containerName);
|
||||
if isempty(container)
|
||||
warning('Контейнер "%s" не найден.', containerName);
|
||||
return;
|
||||
end
|
||||
|
||||
% Рекурсивно собрать все параметры (не вкладки)
|
||||
% Собираем все параметры в контейнере
|
||||
paramsToDelete = mcuMask.collect_all_parameters(container);
|
||||
|
||||
% Удаляем все параметры
|
||||
@ -186,74 +473,27 @@ classdef periphConfig
|
||||
end
|
||||
end
|
||||
|
||||
% Рекурсивно удалить все вкладки внутри контейнера
|
||||
% Рекурсивно удаляем все вкладки
|
||||
mcuMask.delete_all_tabs(mask, container);
|
||||
end
|
||||
|
||||
end
|
||||
function res = addCodeBat(codeConfig, codePath)
|
||||
% Добавление кода периферии в BAT-файл компиляции
|
||||
|
||||
methods(Static, Access=private)
|
||||
|
||||
function res = addCodeConfig(codeConfig, periphPath)
|
||||
% Возвращает 0 при успехе, 1 при ошибке
|
||||
try
|
||||
% Источники
|
||||
srcList = {};
|
||||
if isfield(codeConfig, 'Sources') && isfield(codeConfig.Sources, 'Options')
|
||||
srcFiles = codeConfig.Sources.Options;
|
||||
for i = 1:numel(srcFiles)
|
||||
fullPath = fullfile(periphPath, srcFiles{i});
|
||||
srcList{end+1} = [strrep(fullPath, '\', '\\')];
|
||||
end
|
||||
end
|
||||
% Формируем строки для BAT-файла
|
||||
srcText = compiler.createSourcesBat('code_PERIPH', codeConfig.Sources, codePath);
|
||||
incText = compiler.createIncludesBat('includes_PERIPH', codeConfig.Includes, codePath);
|
||||
|
||||
% Формируем srcText с переносами строк и ^
|
||||
srcText = '';
|
||||
for i = 1:numel(srcList)
|
||||
if i < numel(srcList)
|
||||
srcText = [srcText srcList{i} '^' newline ' '];
|
||||
else
|
||||
srcText = [srcText srcList{i}];
|
||||
end
|
||||
end
|
||||
|
||||
% Инклуды
|
||||
incList = {};
|
||||
if isfield(codeConfig, 'Includes') && isfield(codeConfig.Includes, 'Options')
|
||||
incPaths = codeConfig.Includes.Options;
|
||||
for i = 1:numel(incPaths)
|
||||
fullPath = fullfile(periphPath, incPaths{i});
|
||||
incList{end+1} = ['-I"' strrep(fullPath, '\', '\\') '"'];
|
||||
end
|
||||
end
|
||||
|
||||
% Формируем incText с переносами строк и ^
|
||||
incText = '';
|
||||
for i = 1:numel(incList)
|
||||
if i == 1 && numel(incList) ~= 1
|
||||
incText = [incText incList{i} '^' newline];
|
||||
elseif i < numel(incList)
|
||||
incText = [incText ' ' incList{i} '^' newline];
|
||||
else
|
||||
incText = [incText ' ' incList{i}];
|
||||
end
|
||||
end
|
||||
|
||||
% Добавляем префиксы
|
||||
srcText = ['set code_PERIPH' '=' srcText];
|
||||
incText = ['set includes_PERIPH' '=' incText];
|
||||
|
||||
% Записываем результат
|
||||
res = periphConfig.updateRunMexBat(srcText, incText); % Всё прошло успешно
|
||||
% Обновляем BAT-файл
|
||||
res = compiler.updateRunMexBat(srcText, incText, ':: PERIPH BAT');
|
||||
catch
|
||||
% В случае ошибки просто возвращаем 1
|
||||
res = 1;
|
||||
res = 1; % Ошибка
|
||||
end
|
||||
end
|
||||
|
||||
|
||||
function res = addUserCodeConfig(userCodeConfig)
|
||||
% userCodeConfig — структура config.UserCode
|
||||
function res = addUserFunctions(userCodeConfig)
|
||||
% Добавление пользовательских функций в код обёртки
|
||||
|
||||
initFuncsText = '';
|
||||
simFuncsText = '';
|
||||
@ -262,45 +502,46 @@ classdef periphConfig
|
||||
if isfield(userCodeConfig, 'Functions')
|
||||
funcs = userCodeConfig.Functions;
|
||||
|
||||
if isfield(funcs, 'PeriphInit') && isfield(funcs.PeriphInit, 'Options')
|
||||
initFuncs = funcs.PeriphInit.Options;
|
||||
% Обрабатываем функции инициализации
|
||||
if isfield(funcs, 'PeriphInit')
|
||||
initFuncs = funcs.PeriphInit;
|
||||
initFuncsText = strjoin(strcat('\t', initFuncs, ';'), '\n');
|
||||
end
|
||||
|
||||
if isfield(funcs, 'PeriphSimulation') && isfield(funcs.PeriphSimulation, 'Options')
|
||||
simFuncs = funcs.PeriphSimulation.Options;
|
||||
% Обрабатываем функции симуляции
|
||||
if isfield(funcs, 'PeriphSimulation')
|
||||
simFuncs = funcs.PeriphSimulation;
|
||||
simFuncsText = strjoin(strcat('\t', simFuncs, ';'), '\n');
|
||||
end
|
||||
|
||||
if isfield(funcs, 'PeriphDeinit') && isfield(funcs.PeriphDeinit, 'Options')
|
||||
deinitFuncs = funcs.PeriphDeinit.Options;
|
||||
% Обрабатываем функции деинициализации
|
||||
if isfield(funcs, 'PeriphDeinit')
|
||||
deinitFuncs = funcs.PeriphDeinit;
|
||||
deinitFuncsText = strjoin(strcat('\t', deinitFuncs, ';'), '\n');
|
||||
end
|
||||
|
||||
res = periphConfig.updateWrapperCode(initFuncsText, simFuncsText, deinitFuncsText);
|
||||
% Записываем функции в файл обёртки
|
||||
res = periphConfig.writeWrapperCode(initFuncsText, simFuncsText, deinitFuncsText);
|
||||
end
|
||||
end
|
||||
|
||||
function res = writeWrapperCode(initFuncsText, simFuncsText, deinitFuncsText)
|
||||
% Запись пользовательских функций в файл mcu_wrapper.c
|
||||
|
||||
function res = updateWrapperCode(initFuncsText, simFuncsText, deinitFuncsText)
|
||||
% Входные параметры:
|
||||
% srcText - текст для записи set code_...
|
||||
% incText - текст для записи set includes_...
|
||||
%
|
||||
% Возвращает:
|
||||
% res - 0 при успехе, 1 при ошибке
|
||||
wrapPath = fullfile('.\MCU_Wrapper', 'mcu_wrapper.c');
|
||||
wrapPath = fullfile(mcuPath.get('wrapperPath'), 'mcu_wrapper.c');
|
||||
res = 1;
|
||||
try
|
||||
% Читаем текущее содержимое файла
|
||||
code = fileread(wrapPath);
|
||||
code = regexprep(code, '\r\n?', '\n');
|
||||
|
||||
% Записываем строки initFuncsText и simFuncsText
|
||||
% Вставляем функции в соответствующие секции
|
||||
code = editCode.insertSection(code, '// PERIPH INIT', initFuncsText);
|
||||
code = editCode.insertSection(code, '// PERIPH SIM', simFuncsText);
|
||||
code = editCode.insertSection(code, '// PERIPH DEINIT', deinitFuncsText);
|
||||
|
||||
fid = fopen(wrapPath, 'w', 'n', 'UTF-8');
|
||||
% Записываем обновленный файл
|
||||
fid = fopen(wrapPath, 'w', 'n');
|
||||
if fid == -1
|
||||
error('Не удалось открыть файл для записи');
|
||||
end
|
||||
@ -312,76 +553,74 @@ classdef periphConfig
|
||||
end
|
||||
end
|
||||
|
||||
function addConfig(mask, containerName, periphName, defPrompt, def, rowCountMap, rowWidth)
|
||||
% Добавление одного параметра конфигурации в маску
|
||||
% mask - объект маски
|
||||
% containerName - имя контейнера
|
||||
% periphName - имя периферийного модуля
|
||||
% defPrompt - имя параметра
|
||||
% def - структура с описанием параметра
|
||||
% rowCountMap - карта для отслеживания строк
|
||||
% rowWidth - ширина строки
|
||||
|
||||
|
||||
function res = updateRunMexBat(srcText, incText)
|
||||
% Входные параметры:
|
||||
% srcText - текст для записи set code_...
|
||||
% incText - текст для записи set includes_...
|
||||
%
|
||||
% Возвращает:
|
||||
% res - 0 при успехе, 1 при ошибке
|
||||
periphBat = [srcText '\n\n' incText];
|
||||
batPath = fullfile('.\MCU_Wrapper', 'run_mex.bat');
|
||||
res = 1;
|
||||
try
|
||||
code = fileread(batPath);
|
||||
code = regexprep(code, '\r\n?', '\n');
|
||||
|
||||
% Записываем строки srcText и incText с переносами строк
|
||||
code = editCode.insertSection(code, ':: PERIPH BAT', periphBat);
|
||||
|
||||
fid = fopen(batPath, 'w', 'n', 'UTF-8');
|
||||
if fid == -1
|
||||
error('Не удалось открыть файл для записи');
|
||||
end
|
||||
fwrite(fid, code);
|
||||
fclose(fid);
|
||||
res = 1;
|
||||
catch ME
|
||||
mcuMask.disp(0, '\nОшибка: неудачная запись в файл при записи файла: %s', ME.message);
|
||||
% Инициализация счетчика строк для этого модуля
|
||||
if ~isKey(rowCountMap, periphName)
|
||||
rowCountMap(periphName) = 0;
|
||||
end
|
||||
rowCount = rowCountMap(periphName) + 1;
|
||||
|
||||
% Определяем начинать ли новую строку
|
||||
if ~isfield(def, 'NewRow')
|
||||
def.NewRow = mod(rowCount - 1, rowWidth) == 0;
|
||||
elseif def.NewRow == true
|
||||
rowCount = 1;
|
||||
end
|
||||
rowCountMap(periphName) = rowCount;
|
||||
|
||||
|
||||
|
||||
function addDefineConfig(mask, containerName, periphName, defPrompt, def)
|
||||
% mask — объект маски Simulink.Mask.get(blockPath)
|
||||
% containerName — имя контейнера, в который добавляем параметр (например, 'configTabAll')
|
||||
% periphName — имя вкладки / контейнера для текущего периферийного блока (например, 'ADC')
|
||||
% defPrompt — имя параметра в Defines (например, 'shift_enable')
|
||||
% def — структура с описанием параметра (Prompt, Def, Type, Default, NewRow и т.п.)
|
||||
|
||||
% Найдем контейнер с таким именем
|
||||
% Получаем контейнер
|
||||
container = mask.getDialogControl(containerName);
|
||||
if isempty(container)
|
||||
error('Контейнер "%s" не найден в маске.', containerName);
|
||||
end
|
||||
|
||||
% Проверим, есть ли вкладка с именем periphName, если нет — создадим
|
||||
% Создаем вкладку если её нет
|
||||
tabCtrl = mask.getDialogControl(periphName);
|
||||
if isempty(tabCtrl)
|
||||
tabCtrl = container.addDialogControl('tab', periphName);
|
||||
tabCtrl.Prompt = [periphName ' Config'];
|
||||
end
|
||||
|
||||
% Определяем тип параметра (checkbox или edit)
|
||||
% Определяем тип параметра
|
||||
switch lower(def.Type)
|
||||
case 'checkbox'
|
||||
paramType = 'checkbox';
|
||||
case 'edit'
|
||||
paramType = 'edit';
|
||||
case 'popup'
|
||||
paramType = 'popup';
|
||||
otherwise
|
||||
% Игнорируем остальные типы
|
||||
return;
|
||||
return; % Пропускаем неизвестные типы
|
||||
end
|
||||
|
||||
% Создаем валидное имя параметра
|
||||
paramName = matlab.lang.makeValidName(defPrompt);
|
||||
|
||||
% Преобразуем значение Default в строку для Value
|
||||
% Устанавливаем значение по умолчанию
|
||||
if strcmp(paramType, 'popup')
|
||||
if isfield(def, 'Def') && iscell(def.Def) && ~isempty(def.Def)
|
||||
choices = def.Def;
|
||||
valStr = '';
|
||||
elseif isfield(def, 'Options')
|
||||
choices = def.Def;
|
||||
valStr = '';
|
||||
else
|
||||
warning('Popout параметр "%s" не содержит допустимого списка в Def.', defPrompt);
|
||||
return;
|
||||
end
|
||||
else
|
||||
val = def.Default;
|
||||
if islogical(val)
|
||||
valStr = mcuMask.ternary(val, 'on', 'off');
|
||||
valStr = periphConfig.ternary(val, 'on', 'off');
|
||||
elseif isnumeric(val)
|
||||
valStr = num2str(val);
|
||||
elseif ischar(val)
|
||||
@ -389,8 +628,17 @@ classdef periphConfig
|
||||
else
|
||||
error('Unsupported default value type for %s.%s', periphName, defPrompt);
|
||||
end
|
||||
end
|
||||
|
||||
% Добавляем параметр в маску
|
||||
if strcmp(paramType, 'popup')
|
||||
param = mask.addParameter( ...
|
||||
'Type', paramType, ...
|
||||
'Prompt', def.Prompt, ...
|
||||
'Name', paramName, ...
|
||||
'Container', periphName ...
|
||||
);
|
||||
else
|
||||
param = mask.addParameter( ...
|
||||
'Type', paramType, ...
|
||||
'Prompt', def.Prompt, ...
|
||||
@ -398,6 +646,7 @@ classdef periphConfig
|
||||
'Value', valStr, ...
|
||||
'Container', periphName ...
|
||||
);
|
||||
end
|
||||
|
||||
param.Evaluate = 'off';
|
||||
|
||||
@ -406,9 +655,76 @@ classdef periphConfig
|
||||
else
|
||||
param.DialogControl.Row = 'current';
|
||||
end
|
||||
|
||||
if isfield(def, 'Def')
|
||||
if strcmp(paramType, 'popup')
|
||||
if iscell(def.Def)
|
||||
param.TypeOptions = def.Def;
|
||||
elseif isfield(def, 'Options')
|
||||
param.Alias = def.Def;
|
||||
param.TypeOptions = def.Options;
|
||||
end
|
||||
else
|
||||
param.Alias = def.Def;
|
||||
end
|
||||
end
|
||||
|
||||
callback = sprintf('try periphConfig.periphParamCallback("%s"); catch end', paramName);
|
||||
param.Callback = callback;
|
||||
end
|
||||
|
||||
%% ELEMENTARY FUNCTIONS - базовые вспомогательные функции
|
||||
|
||||
function clear_single_periph_code_param(mask, periph)
|
||||
% Очистка кода одного модуля периферии
|
||||
|
||||
paramNames = {
|
||||
['Hidden_' char(periph) '_Sources'],
|
||||
['Hidden_' char(periph) '_Includes']
|
||||
};
|
||||
|
||||
for i = 1:numel(paramNames)
|
||||
paramName = paramNames{i};
|
||||
try
|
||||
param = mask.getParameter(paramName);
|
||||
param.Value = '';
|
||||
catch
|
||||
% Параметр не существует - игнорируем
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
function store_single_periph_code(mask, periph, code)
|
||||
% Сохранение кода одного модуля периферии в скрытые параметры
|
||||
|
||||
if isfield(code, 'Sources')
|
||||
paramName = ['Hidden_' char(periph) '_Sources'];
|
||||
try
|
||||
param = mask.getParameter(paramName);
|
||||
param.Value = configJs.convert_code_value(code.Sources);
|
||||
catch
|
||||
mcuMask.disp(0, ['Параметр ' paramName ' не найден']);
|
||||
end
|
||||
end
|
||||
|
||||
if isfield(code, 'Includes')
|
||||
paramName = ['Hidden_' char(periph) '_Includes'];
|
||||
try
|
||||
param = mask.getParameter(paramName);
|
||||
param.Value = configJs.convert_code_value(code.Includes);
|
||||
catch
|
||||
mcuMask.disp(0, ['Параметр ' paramName ' не найден']);
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
function res = ternary(cond, valTrue, valFalse)
|
||||
% Вспомогательная функция - тернарный оператор
|
||||
if cond
|
||||
res = valTrue;
|
||||
else
|
||||
res = valFalse;
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@ -30,15 +30,17 @@ set defines_WRAPPER=-D"MATLAB"^ -D"__sizeof_ptr=8"
|
||||
|
||||
:: -------------------------WRAPPER PATHS AND CODE---------------------------
|
||||
:: оболочка, которая будет моделировать работу МК в симулинке
|
||||
set includes_WRAPPER=-I"."^
|
||||
-I".\MCU_Wrapper"^
|
||||
-I".\app_wrapper"
|
||||
:: WRAPPER BAT START
|
||||
|
||||
:: WRAPPER BAT END
|
||||
|
||||
:: APP WRAPPER BAT START
|
||||
|
||||
:: APP WRAPPER BAT END
|
||||
|
||||
set includes_WRAPPER= %includes_WRAPPER% %includes_APP_WRAPPER%
|
||||
set code_WRAPPER= %code_WRAPPER% %code_APP_WRAPPER%
|
||||
|
||||
set code_WRAPPER= .\MCU_Wrapper\MCU.c^
|
||||
.\MCU_Wrapper\mcu_wrapper.c^
|
||||
.\app_wrapper\app_init.c^
|
||||
.\app_wrapper\app_io.c^
|
||||
.\app_wrapper\app_wrapper.c
|
||||
|
||||
:: PERIPH BAT START
|
||||
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
<deployment-project plugin="plugin.toolbox" plugin-version="1.0">
|
||||
<configuration build-checksum="1721556499" file="E:\.WORK\MATLAB\mcu_matlab\mcuwrapper.prj" location="E:\.WORK\MATLAB\mcu_matlab" name="mcuwrapper" target="target.toolbox" target-name="Package Toolbox">
|
||||
<configuration build-checksum="1391118035" file="F:\Work\Projects\MATLAB\mcu_matlab_lib\mcuwrapper.prj" location="F:\Work\Projects\MATLAB\mcu_matlab_lib" name="mcuwrapper" target="target.toolbox" target-name="Package Toolbox">
|
||||
<param.appname>MCU Wrapper</param.appname>
|
||||
<param.authnamewatermark>Razvalyaev</param.authnamewatermark>
|
||||
<param.email>wot890089@mail.ru</param.email>
|
||||
@ -7,7 +7,7 @@
|
||||
<param.summary>Library for run MCU program in Simulink</param.summary>
|
||||
<param.description />
|
||||
<param.screenshot />
|
||||
<param.version>1.01</param.version>
|
||||
<param.version>1.04</param.version>
|
||||
<param.output>${PROJECT_ROOT}\MCU Wrapper.mltbx</param.output>
|
||||
<param.products.name />
|
||||
<param.products.id />
|
||||
@ -27,7 +27,7 @@
|
||||
<param.exported.on.package>false</param.exported.on.package>
|
||||
<param.required.addons>
|
||||
<requiredaddons>
|
||||
<requiredAddOn earliest="earliest" fromRepository="true" id="e5534541-4a80-11e4-9553-005056977bd0" include="true" latest="latest">findjobj - find java handles of Matlab graphic objects</requiredAddOn>
|
||||
<requiredAddOn earliest="earliest" fromRepository="true" id="e5534541-4a80-11e4-9553-005056977bd0" include="false" latest="latest">findjobj - find java handles of Matlab graphic objects</requiredAddOn>
|
||||
</requiredaddons>
|
||||
</param.required.addons>
|
||||
<param.matlab.project.id />
|
||||
@ -96,12 +96,37 @@
|
||||
<fileset.depfun.excluded />
|
||||
<fileset.package />
|
||||
<build-deliverables>
|
||||
<file location="${PROJECT_ROOT}" name="MCU Wrapper.mltbx" optional="false">E:\.WORK\MATLAB\mcu_matlab\MCU Wrapper.mltbx</file>
|
||||
<file location="${PROJECT_ROOT}" name="MCU Wrapper.mltbx" optional="false">F:\Work\Projects\MATLAB\mcu_matlab_lib\MCU Wrapper.mltbx</file>
|
||||
</build-deliverables>
|
||||
<workflow />
|
||||
<matlab>
|
||||
<root>C:\Program Files\MyProgs\MATLAB\R2023a</root>
|
||||
<toolboxes />
|
||||
<root>C:\Program Files\MATLAB\R2021b</root>
|
||||
<toolboxes>
|
||||
<toolbox name="matlabcoder" />
|
||||
<toolbox name="embeddedcoder" />
|
||||
<toolbox name="gpucoder" />
|
||||
<toolbox name="fixedpoint" />
|
||||
</toolboxes>
|
||||
<toolbox>
|
||||
<matlabcoder>
|
||||
<enabled>true</enabled>
|
||||
</matlabcoder>
|
||||
</toolbox>
|
||||
<toolbox>
|
||||
<embeddedcoder>
|
||||
<enabled>true</enabled>
|
||||
</embeddedcoder>
|
||||
</toolbox>
|
||||
<toolbox>
|
||||
<gpucoder>
|
||||
<enabled>true</enabled>
|
||||
</gpucoder>
|
||||
</toolbox>
|
||||
<toolbox>
|
||||
<fixedpoint>
|
||||
<enabled>true</enabled>
|
||||
</fixedpoint>
|
||||
</toolbox>
|
||||
</matlab>
|
||||
<platform>
|
||||
<unix>false</unix>
|
||||
|
||||
Loading…
Reference in New Issue
Block a user