Razvalyaev/matlab_stm_emulate
9
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Симуляция генерации синусоидального шим и управление по модбас

Browse Source 
note:
- модбас не моделируется,  в s-function просто передаются константы режимов.
- лишние файлы убраны в outdate.
- два канала одной фазы переключаются немного криво: на один такт симуляции проскакивает высокий уровень предыдущего канала и только потом включается текущий канал
This commit is contained in:
alexey
2024-08-21 12:58:52 +03:00
parent fcc3e72824
commit 0958cb80c7
682 changed files with 871653 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

173
.outdate/MCU_Wrapper/MCU.c Normal file
View File

@@ -0,0 +1,173 @@
#define S_FUNCTION_NAME MCU
#define S_FUNCTION_LEVEL 2
#include "mcu_wrapper_conf.h"
double SIM_Sample_Time;
#define MDL_UPDATE
/* Function: mdlUpdate ====================================================
* Abstract:
* This function is called once for every major integration time step.
* Discrete states are typically updated here, but this function is useful
* for performing any tasks that should only take place once per
* integration step.
*/
static void mdlUpdate(SimStruct *S, int_T tid)
{
// get S_Func "periphery"
const real_T *IN = ssGetInputPortRealSignal(S,0);
real_T *DISC = ssGetDiscStates(S);
time_T TIME = ssGetT(S);
//---------------SIMULATE MCU---------------
MCU_Step_Simulation(S, IN, DISC, TIME); // SIMULATE MCU
//------------------------------------------
}//end mdlUpdate
/* Function: mdlOutputs ===================================================
* Abstract:
* In this function, you compute the outputs of your S-function
* block. Generally outputs are placed in the output vector(s),
* ssGetOutputPortSignal.
*/
static void mdlOutputs(SimStruct *S, int_T tid)
{
real_T *PORTA = ssGetOutputPortRealSignal(S,0);
real_T *PORTE = ssGetOutputPortRealSignal(S,1);
real_T *DISC = ssGetDiscStates(S);
//-------------WRITTING GPIOS---------------
for (int i=0; i < PORT_WIDTH; i++)
{
PORTA[i] = DISC[i];
DISC[i] = 0;
PORTE[i] = DISC[PORT_WIDTH + i];
DISC[PORT_WIDTH + i] = 0;
}
//------------------------------------------
}//end mdlOutputs
#define MDL_CHECK_PARAMETERS /* Change to #undef to remove function */
#if defined(MDL_CHECK_PARAMETERS) && defined(MATLAB_MEX_FILE)
static void mdlCheckParameters(SimStruct *S)
{
int i;
// Проверяем и принимаем параметры и разрешаем или запрещаем их менять
// в процессе моделирования
for (i=0; i<1; i++)
{
// Input parameter must be scalar or vector of type double
if (!mxIsDouble(ssGetSFcnParam(S,i)) || mxIsComplex(ssGetSFcnParam(S,i)) ||
mxIsEmpty(ssGetSFcnParam(S,i)))
{
ssSetErrorStatus(S,"Input parameter must be of type double");
return;
}
// Параметр м.б. только скаляром, вектором или матрицей
if (mxGetNumberOfDimensions(ssGetSFcnParam(S,i)) > 2)
{
ssSetErrorStatus(S,"Параметр м.б. только скаляром, вектором или матрицей");
return;
}
// sim_dt = mxGetPr(ssGetSFcnParam(S,0))[0];
// Parameter not tunable
// ssSetSFcnParamTunable(S, i, SS_PRM_NOT_TUNABLE);
// Parameter tunable (we must create a corresponding run-time parameter)
ssSetSFcnParamTunable(S, i, SS_PRM_TUNABLE);
// Parameter tunable only during simulation
// ssSetSFcnParamTunable(S, i, SS_PRM_SIM_ONLY_TUNABLE);
}//for (i=0; i<NPARAMS; i++)
}//end mdlCheckParameters
#endif //MDL_CHECK_PARAMETERS
static void mdlInitializeSizes(SimStruct *S)
{
ssSetNumSFcnParams(S, 1);
// Кол-во ожидаемых и фактических параметров должно совпадать
if(ssGetNumSFcnParams(S) == ssGetSFcnParamsCount(S))
{
// Проверяем и принимаем параметры
mdlCheckParameters(S);
}
else
{
return;// Parameter mismatch will be reported by Simulink
}
ssSetNumContStates(S, 0); // number of continuous states
ssSetNumDiscStates(S, PORT_NUMB*PORT_WIDTH); // number of discrete states
if (!ssSetNumInputPorts(S, 1)) return; // set up input port
ssSetInputPortWidth(S, 0, PORT_WIDTH);
ssSetInputPortDirectFeedThrough(S, 0, 0);
ssSetInputPortRequiredContiguous(S, 0, 1); // direct input signal access
if (!ssSetNumOutputPorts(S, PORT_NUMB)) return; // set up output port
for (int i = 0; i < PORT_NUMB; i++)
ssSetOutputPortWidth(S, i, PORT_WIDTH);
ssSetNumSampleTimes(S, 1);
ssSetNumRWork( S, 5); // number of real work vector elements
ssSetNumIWork( S, 5); // number of integer work vector elements
ssSetNumPWork( S, 0); // number of pointer work vector elements
ssSetNumModes( S, 0); // number of mode work vector elements
ssSetNumNonsampledZCs( S, 0); // number of nonsampled zero crossings
ssSetRuntimeThreadSafetyCompliance(S, RUNTIME_THREAD_SAFETY_COMPLIANCE_TRUE);
/* Take care when specifying exception free code - see sfuntmpl.doc */
ssSetOptions(S, SS_OPTION_EXCEPTION_FREE_CODE);
}
#define MDL_START // Change to #undef to remove function
#if defined(MDL_START)
/* Function: mdlStart =====================================================
* Abstract:
* This function is called once at start of model execution. If you
* have states that should be initialized once, this is the place
* to do it.
*/
static void mdlStart(SimStruct *S)
{
SIM_Initialize_Simulation();
}
#endif // MDL_START
static void mdlInitializeSampleTimes(SimStruct *S)
{
// Шаг дискретизации
SIM_Sample_Time = mxGetPr(ssGetSFcnParam(S,NPARAMS-1))[0];
// Register one pair for each sample time
ssSetSampleTime(S, 0, SIM_Sample_Time);
ssSetOffsetTime(S, 0, 0.0);
}
extern HANDLE hThread;
static void mdlTerminate(SimStruct *S)
{
//TerminateThread(hThread, NULL);
//CloseHandle(hThread);
flag_to_end = 1; // выставляем флаг закончить код МК
ResumeThread(hThread); // запускаем код мк
WaitForSingleObject(hThread, 1000); // и ждем пока он закончиться
SIM_deInitialize_Simulation(); // деинициализируем симуляцию
mexUnlock();
}
#ifdef MATLAB_MEX_FILE /* Is this file being compiled as a
MEX-file? */
#include "simulink.c" /* MEX-file interface mechanism */
#else
#include "cg_sfun.h" /* Code generation registration
function */
#endif

BIN
.outdate/MCU_Wrapper/Outputs/asmjmp.obj Normal file
View File

Binary file not shown.

91
.outdate/MCU_Wrapper/asmjmp.asm Normal file
View File

@@ -0,0 +1,91 @@
.DATA
.CODE
ALIGN 16
READ_REGS PROC
; STORE REGISTERS TO STRUCTURE
; (rcx - pointer to struct)
mov [rcx], rax ; Store rax (Frame)
mov [rcx+8], rbx ; Store rbx
mov [rcx+24], rbp ; Store rbp
mov [rcx+32], rsi ; Store rsi
mov [rcx+40], rdi ; Store rdi
mov [rcx+48], r12 ; Store r12
mov [rcx+56], r13 ; Store r13
mov [rcx+64], r14 ; Store r14
mov [rcx+72], r15 ; Store r15
; STORE RSP
mov r11, rsp ; Store rsp to r11 (in order to not change actual rsp, because it will use in return)
add r11, 8 ; when this func was called, rsp was decreased. So increased it back
mov [rcx+16], r11 ; store rsp to REGS struct
mov [rcx+256+8], r11 ; store rsp to pointer to stack var
ret
READ_REGS ENDP
;-------------------------------------------------------------------------
RESTORE_CONTEXT_AND_JUMP PROC
; SET POINTER TO STACK
mov rax, [rcx] ; rcx = &hmcu = &pStackPtr_Origin
mov qword ptr [rcx+118h], rax ; pStackPtr_Current [rcx+118h] = pStackPtr_Origin [rcx]
STACK_FILLING: ; code copied from disassembled code
cmp dword ptr [rcx+110h], 0 ; compare is Stack_Size[rcx+110h] to the zero
jl REGISTERS_FILLING ; if StackSize less then zero - exit the while
; SAVE VARIABLES OF STRUCTURE IN REGISTERS
movsxd rdx, dword ptr [rcx+110h] ; rdx = Stack_Size [rcx+110h]
mov rbx, qword ptr [rcx+118h] ; rbx = pStackPtr_Current [rcx+118h]
lea r10, [rcx+120h] ; r10 = &Stack_Buff [rcx+120h]
mov rax, qword ptr [r10+rdx*8] ; rax = Stack_Buff[n] [r10+rdx*8] = [&Stack_Buff+Stack_Size*8]
; SAVE FROM STACK_BUFF TO THE REAL STACK
mov qword ptr [rbx], rax ; *pStackPtr_Current = Stack_Buff[n]
; DECREMENT INDEX AND POINTER
sub rbx, 8 ; pStackPtr_Current--
mov qword ptr [rcx+118h], rbx ; pStackPtr_Current = (new)pStackPtr_Current
dec rdx ; Stack_Size--
mov qword ptr [rcx+110h], rdx ; Stack_Size = (new)Stack_Size
jmp STACK_FILLING ; back to comparing
REGISTERS_FILLING:
; SET REGISTERS FROM STRUCTURE
add rcx, 16 ; (set rcx as pointer to struct REGS)
mov rax, [rcx] ; Set rax (Frame)
mov rbx, [rcx+8] ; Set rbx
mov rsp, [rcx+16] ; Set rsp
mov rbp, [rcx+24] ; Set â rbp
mov rsi, [rcx+32] ; Set rsi
mov rdi, [rcx+40] ; Set rdi
mov r12, [rcx+48] ; Set r12
mov r13, [rcx+56] ; Set r13
mov r14, [rcx+64] ; Set r14
mov r15, [rcx+72] ; Set r15
jmp qword ptr [rcx+80] ; go to MCU app
ret
RESTORE_CONTEXT_AND_JUMP ENDP
;-------------------------------------------------------------------------
GET_RSP_ORIGIN PROC
; STORE RSP
mov r11, rsp ; Store rsp to r11 (in order to not change actual rsp, because it will use in return)
add r11, 8 ; when this func was called, rsp was decreased. So increased it back
mov [rcx], r11 ; store origin rsp to pStackPtr
ret
GET_RSP_ORIGIN ENDP
END

194
.outdate/MCU_Wrapper/controller.c Normal file
View File

@@ -0,0 +1,194 @@
/**************************************************************************
Äàííûé ôàéë ñîäåðæèò ôóíêöèè äëÿ ñèìóëÿöèè ÌÊ â Simulink (S-Function).
**************************************************************************/
#include "simstruc.h"
#include "mcu_wrapper_conf.h"
//#include <windows.h>
//#include <synchapi.h>
DEL_MCUHandleTypeDef hmcu; // äëÿ óïðàâëåíèÿ êîíòåêñòîì ïðîãðàììû ÌÊ
HANDLE hThread;
uint32_t idThreads;
unsigned flag_to_end;
double SystemClockDouble = 0; // äëÿ ñèìóëÿöèè ñèñòåìíûõ òèêîâ, ïðîêà ïðîñòî ïî ïðèêîëó
uint64_t SystemClock; // äëÿ ñèìóëÿöèè ñèñòåìíûõ òèêîâ, ïðîêà ïðîñòî ïî ïðèêîëó
/* Extern function of control MCU App from asmjmp.asm */
extern void GET_RSP_ORIGIN(DEL_MCUHandleTypeDef* hmcu);
extern void RESTORE_CONTEXT_AND_JUMP(DEL_MCUHandleTypeDef* hmcu);
extern void READ_REGS(_JUMP_BUFFER* hmcu);
//-------------------------------------------------------------//
//-----------------CONTROLLER SIMULATE FUNCTIONS---------------//
/** MCU STEP SIMULATION */
/**
* @brief Read from simulink S-Block Inputs and write to MCU I/O ports.
* @param in - inputs of S-Function.
* @param disc - discrete array of S-Function. Outputs would be written from disc.
* @param time - current time of simulation (in second).
* @note Âûçûâàåò ãëàâíóþ ôóíêöèþ main èç ïîëüçîâàòåëüñêîãî êîäà è óïðàâëÿåò å¸ õîäîì:
* Ïðåðûâàåò å¸, åñëè îíà ïîïàëà â áåñêîíå÷íûé while, ñèìóëèðóåò ïåðèôåðèþ
* è âîçâðàùàåò â òî÷êó îñòàíîâêè íà ñëåäóþùåì øàãå.
*/
/* simulate controller step */
extern int main(void); // extern while from main.c
unsigned __stdcall MCU_App_Thread(void) {
main(); // ñèìóëÿöèÿ êîäà ÌÊ
return 0;
}
void MCU_Step_Simulation(SimStruct* S, real_T* in, real_T* disc, time_T time)
{
//-----------INIT WRAPPER-----------
if (hmcu.Get_RSP_Origin) // åñëè íàäî ïîëó÷òü óêàçàòåëü íà "íà÷àëî" ñòåêà
{
hmcu.Get_RSP_Origin = 0; // ñáðîñ ôëàãà, ÷òîáû ñþäà áîëüøå íå ïîïàäàòü
// óêàçàòåëü íà "íà÷àëî" ñòåêà - áåðåòñÿ â íà÷àëå ãëàâíîé óïðàâëÿþùåé ôóíêöèè
//GET_RSP_ORIGIN(&hmcu);
// èíèöèàëèçàöèÿ ïîòîêà, êîòîðûé áóäåò âûïîëíÿòü êîä ÌÊ
hThread = (HANDLE)_beginthreadex(NULL, 0, MCU_App_Thread, 0, 0x00000004, &idThreads);
ResumeThread(hThread);
//Sleep(100);
for (int i = TIME_FOR_MCU_APP*10000; i > 0; i--)
{
}
SuspendThread(hThread);
return;
}
//----------------------------------
// Get uwTick (in ms)
//uwTick = time * 1000; // from simulation time
SystemClockDouble += SystemCoreClock * SIM_Sample_Time; // emulate core clock
SystemClock = SystemClockDouble;
uwTick = SystemClock / (SystemCoreClock / 1000);
MCU_readInputs(in); // ñ÷èòûâàíèå ïîðòîâ
MCU_Periph_Simulation(); // simulate peripheral
//// Return to MCU app at line, where it was stopped
//if (hmcu.Resume_MCU_App) // åñëè íåîáõîäèìî âåðíóòñÿ â êîä ÌÊ
//{
// // Ñáðîñ ôëàãîâ
// hmcu.Resume_MCU_App = 0;
// hmcu.Stop_MCU_App = 0;
// // Âîçâðàò â êîä ÌÊ
// RESTORE_CONTEXT_AND_JUMP(&hmcu);
//}
//// ñîõðàíåíèå êîíòåêñòà äî ïåðåõîäà â êîä ÌÊ
//if (!hmcu.Stop_MCU_App && (setjmp(hmcu.main_start) == 0))
//{ // åñëè êîíòåêñò ñîõðàíåí (setjmp == 0) è ÌÊ íå îñòàíîâëåí
// main(); // ñèìóëÿöèÿ êîäà ÌÊ
//}
// note: ïðè âûçîâå longjmp, setjmp != 0, ïîýòîìó ïðîãðàììà íå âîéäåò çàíîâî â main_loop
ResumeThread(hThread);
for (int i = TIME_FOR_MCU_APP; i > 0; i--)
{
}
SuspendThread(hThread);
MCU_writeOutputs(disc); // çàïèñü ïîðòîâ (ïî ôàêòó çàïèñü â áóôåð. çàïèñü â ïîðòû â mdlOutputs)
}
/** SIMULATE MCU PERIPHERAL */
/**
* @brief Simulate peripheral of MCU
* @note Ïîëüçîâàòåëüñêèé êîä, êîòîðûé ñèìóëèðóåò ðàáîòó ïåðèôåðèè ÌÊ.
*/
void MCU_Periph_Simulation(void)
{
Simulate_TIMs();
}
/** READ INPUTS S-FUNCTION */
/**
* @brief Read from simulink S-Block Inputs and write to MCU I/O ports.
* @param in - inputs of S-Function.
* @note Ïîëüçîâàòåëüñêèé êîä, êîòîðûé çàïèñûâàåò â ïîðòû ââîäà-âûâîäà èç disc.
*/
void MCU_readInputs(real_T *in)
{
SFUNC_to_GPIO(in);
}
/** WRITE OUTPUTS S-FUNCTION */
/**
* @brief Read from MCU I/O ports and write to simulink S-Block Outputs.
* @param disc - discrete array of S-Function. Outputs would be written from disc.
* @note Ïîëüçîâàòåëüñêèé êîä, êîòîðûé çàïèñûâàåò â disc ïîðòû ââîäà-âûâîäà.
*/
void MCU_writeOutputs(real_T *disc)
{
GPIO_to_SFUNC(disc);
}
//-----------------CONTROLLER SIMULATE FUNCTIONS---------------//
//-------------------------------------------------------------//
//-------------------------------------------------------------//
//----------INITIALIZE/DEINITIALIZE SIMULATE FUNCTIONS---------//
/** MCU WRAPPER DEINITIALIZATION */
/**
* @brief Initialize structures and variables for simulating MCU.
* @note Ïîëüçîâàòåëüñêèé êîä, êîòîðûé áóäåò íàñòðàèâàòü âñå ñòðóêòóðû.
*/
void SIM_Initialize_Simulation(void)
{
/* user initialization */
Initialize_Periph_Sim();
/* wrapper initialization */
//SystemClock_step = SystemCoreClock * SIM_Sample_Time; // set system clock step
hmcu.Get_RSP_Origin = 1; // set flag to store pionter to "beginning" pf the stack
}
/** MCU WRAPPER DEINITIALIZATION */
/**
* @brief Deinitialize structures and variables for simulating MCU.
* @note Ïîëüçîâàòåëüñêèé êîä, êîòîðûé áóäåò î÷èùàòü âñå ñòðóêòóðû.
*/
void SIM_deInitialize_Simulation(void)
{
// simulate structures of peripheral deinitialization
deInitialize_Periph_Sim();
// mcu peripheral memory deinitialization
deInitialize_MCU();
}
//-------------------------------------------------------------//
//-------------------------------------------------------------//
//------------------- SAVE CONTEXT FUNCTIONS -----------------//
/** SAVE CONTEXT OF PROGRAMM */
/**
* @brief Save context (stack, registers) of running program.
* @note Äàííàÿ ôóíêöèÿ óñòàíàâëèâàåò ñ÷åò÷èê êîììàíä íà íà÷àëî ôóíêöèè.
* Òàê ÷òî âîçâðàò áóäåò ïðîèçâåäåí â íà÷àëî ýòîé ôóíêöèè.
*/
void saveProgramContext(void)
{
_SAVE_RIP_(hmcu);
hmcu.REGS.Rip -= 5; // Ñäâèã RIP ñ ýòîé êîìàíäû íà ïåðâóþ êîìàíäó â ôóíêöèè: sizeof(call getNextAddr) = 5
READ_REGS(&hmcu.REGS); // Ñ÷èòûâàíèå ðåãèñòðîâ
_SAVE_STACK_(hmcu); // Ñ÷èòûâàíèå ðåãèñòðîâ
}
/** GET NEXT INSTRUCTION ADDRESS */
/**
* @brief Gives the address where this function will return.
*/
void* getNextAddr(void) {
return _ReturnAddress();
}
//-------------------------------------------------------------//

250
.outdate/MCU_Wrapper/controller.h Normal file
View File

@@ -0,0 +1,250 @@
/**************************************************************************
Ãëàâíûé çàãîëîâî÷íûé ôàéë äëÿ ìàòëàáà. Âêëþ÷àåò äåéôàéíû äëÿ S-Function,
îáúÿâëÿåò áàçîâûå ôóíêöèè äëÿ ñèìóëÿöèè ÌÊ è ïîäêëþ÷àåò áàçîâûå áèáëèîòåêè:
äëÿ S-Function "simstruc.h"
äëÿ ÌÊ "main.h"
äëÿ ñèìóëÿöèè "stm32f4xx_matlab_conf.h"
**************************************************************************/
#ifndef _CONTROLLER_H_
#define _CONTROLLER_H_
typedef void* HANDLE;
#include "mcu_wrapper_conf.h" // For stm simulate functions
#include "simstruc.h" // For S-Function variables
#include <process.h> // For threads
// Parameters of S_Function
#define NPARAMS 1 // number of input parametrs (only Ts)
#define PORT_WIDTH 16 // width of one port
#define PORT_NUMB 2 // amount of ports
// Parametrs of MCU simulation
#define MAX_STACK_SIZE 0xFFFF // If stack is bigger than this number - exit simulations.
#define MAX_WHILE_TIMEOUT 0xFFF // timeout for while. If after this amount of cycles app stil in while - stop app and go to wrapper
#define TIME_FOR_MCU_APP 0xFF //
/** MCU HANDLE STRUCTURE */
/**
* @brief MCU handle Structure definition.
* @var pStackPtr_Origin - pointer to the "beginning" of the stack (RSP before go to MCU app)
* @vars Main stop context - context of MCU app at stop point.
Included: registers, pointer to stack and saved stack.
* @var Main start context - context of wrapper, before go to MCU app @ref setjmp/longjmp.
* @vars Flags and counters - flags and counter that control MCU app.
* @note Do not change stucrure before Stack_Buff, the assembly code uses fixed address offsets.
*/
typedef struct _DEL_MCUHandleTypeDef {
uint64_t* pStackPtr_Origin; /* óêàçàòåëü íà "íà÷àëî" ñòåêà - êîíåö ñòåêà ó óïðàâëÿþùåé ÌÊîì ôóíêöèè */
// Main stop context
_JUMP_BUFFER REGS; /* ðåãèñòðû âî âðåìÿ ïðèîñòàíîâêè ïðîãðàììû ÌÊ */
int long Stack_Size; /* ðàçìåð ñòåêà - îò "íà÷àëà" äî "âåðõíóøêè" */
uint64_t* pStackPtr_Current; /* óêàçàòåëü íà ïîñëåäíèé ýëåìåíò ñòåêà */
uint64_t Stack_Buff[MAX_STACK_SIZE]; /* ñîäåðæèìîå ñòåêà îò "íà÷àëà" äî "âåðõíóøêè" âî âðåìÿ ïðèîñòàíîâêè */
// Main start context
jmp_buf main_start; /* áóôôåð, äëÿ âûõîäà èç ïðîãðàììû ÌÊ - longjmp(main_start) */
// Flags and counters
int While_Timeout; /* ñ÷åò÷èê, ïîñëå èñòå÷åíèÿ êîòîðîãî while ïðåðûâàåòñÿ */
unsigned Stop_MCU_App : 1; /* ôëàã äëÿ îñòàíîâêè ïðîãðàììû ÌÊ */
unsigned Resume_MCU_App : 1; /* ôëàã äëÿ âîçîáíîâëåíèÿ ðàáîòû ïðîãðàììû ÌÊ */
unsigned Get_RSP_Origin : 1; /* ôëàã äëÿ ïîëó÷åíèÿ óêàçàòåëÿ íà "íà÷àëî" ñòåêà */
}DEL_MCUHandleTypeDef;
extern DEL_MCUHandleTypeDef hmcu; /* extern äëÿ âèäèìîñòè ïåðåìåííîé âî âñåõ ôàéëàõ */
// Variable for param of S-Function
extern double SIM_Sample_Time; // sample time
//-------------------------------------------------------------//
//------------------- SAVE CONTEXT DEFINES ------------------//
/** SAVE STACK */
/**
* @brief Save stack of running program.
* @param _hmcu_ - MCU Handle structure with registers and stack buff for filling.
*
* @code @ref _SAVE_STACK_CODE_ to see for replace _SAVE_STACK_ macros (for debug).
*/
#define _SAVE_STACK_(_hmcu_) if(1){ \
/* Ñáðîñ èíäåêñà áóôåðà äëÿ ñòåêà */ _hmcu_.Stack_Size = 0; \
/* Ïîêà âåñü íåîáõîäèìûé ñòåê íå ñîõðàíåí */ native_while( _hmcu_.pStackPtr_Current != _hmcu_.pStackPtr_Origin) \
/* Åñëè áóôåð íå ïåðåïîëíåí: */ if(_hmcu_.Stack_Size <= MAX_STACK_SIZE) \
/* Ñîõðàíåíèå ñòåêà */ _hmcu_.Stack_Buff[_hmcu_.Stack_Size++] = *_hmcu_.pStackPtr_Current++; \
/* Åñëè áóôåð ïåðåïîëíåí: */ else { \
/* Ñîîáùåíèå îá îøèáêå è âûõîä èç ïðîãðàììû */ printf("Max stack size is reached\n"); \
exit(0); \
}}else
/***************************************************************/
/** SAVE PROGRAMM COUNTER */
/**
* @brief Save programm counter (RIP register) of running program.
* @param _hmcu_ - MCU Handle structure with registers and stack buff for filling
* @note Èñïîëüçóåòñÿ âìåñòå ñ @ref _SAVE_CONTEXT_ äëÿ îïðåäåëåíèÿ òî÷êè âîçâðàòà.
* Âûçûâàåòñÿ äî èëè ïîñëå _SAVE_CONTEXT_, êàê âàì íóæíî.
* @ret Store address of next instruction after this macros in Rip
*/
#define _SAVE_RIP_(_hmcu_) _hmcu_.REGS.Rip = getNextAddr()
/***************************************************************/
//------------------- SAVE CONTEXT DEFINES ------------------//
//-------------------------------------------------------------//
//-------------------------------------------------------------//
//------------------ SIMULINK WHILE DEFINES -----------------//
/** DEFINE TO WHILE WITH SIMULINK WHILE */
/**
* @brief Redefine C while statement with sim_while() macro.
* @param _expression_ - expression for while.
* @note @ref sim_while äëÿ ïîäðîáíîñòåé.
*/
#define while(_expression_) sim_while(_expression_) /* while êîòîðûé áóäåò èñïîëüçîâàòüñÿ â ñèìóëèíêå */
/** DEFAULT WHILE */
/**
* @brief Default/Native C while statement.
* @param _expression_ - expression for while.
* @note Äàííûé while - àíàëîã îáû÷íîãî while, áåç äîïîëíèòåëüíîãî ôóíêöèîíàëà.
*/
#define native_while(_expression_) for(; (_expression_); )
/***************************************************************/
/** SIMULINK WHILE */
/**
* @brief While statement for emulate MCU code in Simulink.
* @param _expression_ - expression for while.
* @note Äàííûé while, ðàáîòàåò êàê îáû÷íûé, ïîêà ôëàã îêîí÷àíèÿ ñèìóëÿöèè (flag_to_end)
* ðàâåí íóëþ. Ò.å. ñèìóëÿöèÿ ïðîäîëæàåòñÿ.
Êîãäà âðåìÿ ñèìóëÿöèè çàêîí÷èëàñü (ôëàã âûñòàâëÿåòñÿ â 1) âñå while â êîäå ÌÊ áóäóò ïðîïóñêàòüñÿ
*
*
* @code @ref sim_while_CODE_ to see for replace while sim_while (for debug).
*/
extern unsigned flag_to_end;
#define sim_while(_expression_) while((_expression_)&&(flag_to_end == 0))
//#define sim_while(_expression_) while(0);if(_expression_&&(hmcu.While_Timeout>-5)){ \
///* Óñòàíîâêà òàéìàóòà äëÿ while */ hmcu.While_Timeout = MAX_WHILE_TIMEOUT; \
// } \
///* Öèêë while - for(;_expression_;) */ native_while(_expression_) \
///* Åñëè òàéìàóò èñòåê */ if(hmcu.While_Timeout-- < 0 ) { \
///* Cáðîñ òàéìàóòà, ÷òîáû íà ñëåä øàãå âîéòè â òåëî öèêëà */ hmcu.While_Timeout = 0; \
///* Óñòàíîâêà ôëàãà äëÿ îñòàíîâêè ïðîãðàììû */ hmcu.Stop_MCU_App = 1; \
///* Óñòàíîâêà ôëàãà äëÿ âîçâðàòà â êîä ÌÊ íà ñëåä øàãå */ hmcu.Resume_MCU_App = 1; \
///* Ñîõðàíåíèå êîíòåêñòà */ saveProgramContext(); \
// if(hmcu.Stop_MCU_App) \
///* Âîçâðàò â îáîëî÷êó */ longjmp(hmcu.main_start, 1); \
// } \
///* Èíà÷å - âûïîëíåíèå òåëà öèêëà */ else
//------------------ SIMULINK WHILE DEFINES -----------------//
//-------------------------------------------------------------//
//-------------------------------------------------------------//
//---------------- SIMULATE FUNCTIONS PROTOTYPES -------------//
/** MCU STEP SIMULATION */
/**
* @brief Read from simulink S-Block Inputs and write to MCU I/O ports.
* @param in - inputs of S-Function.
* @param disc - discrete array of S-Function. Outputs would be written from disc.
* @param time - current time of simulation (in second).
* @note Âûçûâàåò ãëàâíóþ ôóíêöèþ main èç ïîëüçîâàòåëüñêîãî êîäà è óïðàâëÿåò å¸ õîäîì:
* Ïðåðûâàåò å¸, åñëè îíà ïîïàëà â áåñêîíå÷íûé while, ñèìóëèðóåò ïåðèôåðèþ
* è âîçâðàùàåò â òî÷êó îñòàíîâêè íà ñëåäóþùåì øàãå.
*/
/* simulate controller step */
void MCU_Step_Simulation(SimStruct *S, const real_T *in,
real_T *disc, time_T time); /* step simulation */
/** SIMULATE MCU PERIPHERAL */
/**
* @brief Simulate peripheral of MCU
* @note Ïîëüçîâàòåëüñêèé êîä, êîòîðûé ñèìóëèðóåò ðàáîòó ïåðèôåðèè ÌÊ.
*/
void MCU_Periph_Simulation(void); /* MCU peripheral simulation */
/** MCU WRAPPER INITIALIZATION */
/**
* @brief Initialize structures and variables for simulating MCU.
* @note Ïîëüçîâàòåëüñêèé êîä, êîòîðûé áóäåò íàñòðàèâàòü âñå ñòðóêòóðû.
*/
void SIM_Initialize_Simulation(void); /* initialize MCU simulation */
/** MCU WRAPPER DEINITIALIZATION */
/**
* @brief Deinitialize structures and variables for simulating MCU.
* @note Ïîëüçîâàòåëüñêèé êîä, êîòîðûé áóäåò î÷èùàòü âñå ñòðóêòóðû.
*/
void SIM_deInitialize_Simulation(void); /* SIM_deInitialize_Simulation MCU simulation */
/** READ INPUTS S-FUNCTION */
/**
* @brief Read from simulink S-Block Inputs and write to MCU I/O ports.
* @param in - inputs of S-Function.
* @note Ïîëüçîâàòåëüñêèé êîä, êîòîðûé çàïèñûâàåò â ïîðòû ââîäà-âûâîäà èç disc.
*/
void MCU_readInputs(real_T* in);
/** WRITE OUTPUTS S-FUNCTION */
/**
* @brief Read from MCU I/O ports and write to simulink S-Block Outputs.
* @param disc - discrete array of S-Function. Outputs would be written from disc.
* @note Ïîëüçîâàòåëüñêèé êîä, êîòîðûé çàïèñûâàåò â disc ïîðòû ââîäà-âûâîäà.
*/
void MCU_writeOutputs(real_T* disc);
/** SAVE CONTEXT OF PROGRAMM */
/**
* @brief Save context (stack, registers) of running program.
* @note Äàííàÿ ôóíêöèÿ óñòàíàâëèâàåò ñ÷åò÷èê êîììàíä íà íà÷àëî ôóíêöèè.
* Òàê ÷òî âîçâðàò áóäåò ïðîèçâåäåí â íà÷àëî ýòîé ôóíêöèè.
*/
void saveProgramContext(void);
/** GET NEXT INSTRUCTION ADDRESS */
/**
* @brief Gives the address where this function will return.
*/
void* getNextAddr(void);
//---------------- SIMULATE FUNCTIONS PROTOTYPES -------------//
//-------------------------------------------------------------//
#endif // _CONTROLLER_H_
/** MACROSES REPLACEMENT CODE */
/** _SAVE_STACK_CODE_
* CODE TO REPLACE _SAVE_STACK_() MACROS (FOR DEBUG) */
/*
hmcu.Stack_Size = 0; // Ñáðîñ èíäåêñà áóôåðà äëÿ ñòåêà
// Ïîêà âåñü íåîáõîäèìûé ñòåê íå ñîõðàíåí
native_while(hmcu.pStackPtr_Current != hmcu.pStackPtr_Origin)
if (hmcu.Stack_Size <= MAX_STACK_SIZE) // Åñëè áóôåð íå ïåðåïîëíåí
hmcu.Stack_Buff[hmcu.Stack_Size++] = *hmcu.pStackPtr_Current++; // Ñîõðàíåíèå ñòåêà
else { // Åñëè áóôåð ïåðåïîëíåí
printf("Max stack size is reached\n"); // Ñîîáùåíèå îá îøèáêå è âûõîä èç ïðîãðàììû
exit(0); }
*/
/***************************************************************/
/** sim_while_CODE_
* CODE TO REPLACE sim_while() MACROS (FOR DEBUG) */
/*
while(0);if(_expression_&&(hmcu.While_Timeout>-5)){
hmcu.While_Timeout = MAX_WHILE_TIMEOUT; // Óñòàíîâêà òàéìàóòà äëÿ while
}
native_while(_expression_) // Öèêë while - for(;_expression_;)
if (hmcu.While_Timeout-- < 0) { // Åñëè òàéìàóò èñòåê
hmcu.While_Timeout = 0; // Ñáðîñ òàéìàóòà, ÷òîáû íà ñëåä øàãå âîéòè â òåëî öèêëà
hmcu.Stop_MCU_App = 1; // Óñòàíîâêà ôëàãà äëÿ îñòàíîâêè ïðîãðàììû
hmcu.Resume_MCU_App = 1; // Óñòàíîâêà ôëàãà äëÿ âîçâðàòà â êîä ÌÊ íà ñëåä øàãå
saveProgramContext(); // Ñîõðàíåíèå êîíòåêñòà
if(hmcu.Stop_MCU_App) // Åñëè ïðèëîæåíèå áûëî îñòàíîâëåíî
longjmp(hmcu.main_start, 1); // Âîçâðàò â îáîëî÷êó
// èíà÷å (ïðè âîçâðàùåíèè â êîä ÌÊ) ïðîäîëæèòü âûïîëíåíèå êîäà
}
else // Èíà÷å - âûïîëíåíèå òåëà öèêëà
*/
/***************************************************************/

88
.outdate/MCU_Wrapper/run_mex.bat Normal file
View File

@@ -0,0 +1,88 @@
@echo off
set defines=-D"STM32F103xB" -D"USE_HAL_DRIVER"^
-D"MATLAB"^
-D"__sizeof_ptr=8"
:: -------------------------USERS PATHS AND CODE---------------------------
:: заголовочные файлы (не добавлять CMSIS и HAL, они добавлены ниже)
set includes_USER= -I".\Core\Inc"
:: исходный код
setlocal enabledelayedexpansion
set code_USER=
for %%f in (.\Core\Src\*.c) do (
set code_USER=!code_USER! %%f
)
::-------------------------------------------------------------------------
:: -----------------------MCU LIBRARIES & SIMULATOR------------------------
:: -----MCU LIBRARIES STUFF----
:: заголовочные файлы
set includes_MCU= -I".\MCU_STM32F1xx_Matlab"^
-I".\MCU_STM32F1xx_Matlab\Drivers\STM32F1xx_SIMULINK"^
-I".\MCU_STM32F1xx_Matlab\Drivers\CMSIS"^
-I".\MCU_STM32F1xx_Matlab\Drivers\CMSIS\Device\STM32F1xx"^
-I".\MCU_STM32F1xx_Matlab\Drivers\STM32F1xx_HAL_Driver\Inc"^
-I".\MCU_STM32F1xx_Matlab\Drivers\STM32F1xx_HAL_Driver\Inc\Legacy"
:: код библиотек МК, переделанный для матлаб
set code_MCU= .\MCU_STM32F1xx_Matlab\Drivers\STM32F1xx_HAL_Driver\Src\stm32f1xx_hal_rcc.c^
.\MCU_STM32F1xx_Matlab\Drivers\STM32F1xx_HAL_Driver\Src\stm32f1xx_hal_gpio.c^
.\MCU_STM32F1xx_Matlab\Drivers\STM32F1xx_HAL_Driver\Src\stm32f1xx_hal_pwr.c^
.\MCU_STM32F1xx_Matlab\Drivers\STM32F1xx_HAL_Driver\Src\stm32f1xx_hal_cortex.c^
.\MCU_STM32F1xx_Matlab\Drivers\STM32F1xx_HAL_Driver\Src\stm32f1xx_hal.c^
.\MCU_STM32F1xx_Matlab\Drivers\STM32F1xx_HAL_Driver\Src\stm32f1xx_hal_tim.c^
.\MCU_STM32F1xx_Matlab\Drivers\STM32F1xx_HAL_Driver\Src\stm32f1xx_hal_tim_ex.c^
.\MCU_STM32F1xx_Matlab\Drivers\STM32F1xx_HAL_Driver\Src\stm32f1xx_hal_dma.c^
.\MCU_STM32F1xx_Matlab\Drivers\STM32F1xx_HAL_Driver\Src\stm32f1xx_hal_exti.c
:: .\MCU_STM32F1xx_Matlab\Drivers\STM32F1xx_HAL_Driver\Src\stm32f1xx_hal_flash_ramfunc.c^
:: .\MCU_STM32F1xx_Matlab\Drivers\STM32F1xx_HAL_Driver\Src\stm32f1xx_hal_flash.c^
:: .\MCU_STM32F1xx_Matlab\Drivers\STM32F1xx_HAL_Driver\Src\stm32f1xx_hal_flash_ex.c^
:: .\MCU_STM32F1xx_Matlab\Drivers\STM32F1xx_HAL_Driver\Src\stm32f1xx_hal_rcc_ex.c^
:: --------MCU SIMULATOR-------
:: код, которая будет симулировать перефирию МК в симулинке
set code_MCU_Sim= .\MCU_STM32F1xx_Matlab\stm32f1xx_matlab_conf.c^
.\MCU_STM32F1xx_Matlab\Drivers\STM32F1xx_SIMULINK\stm32f1xx_matlab_gpio.c^
.\MCU_STM32F1xx_Matlab\Drivers\STM32F1xx_SIMULINK\stm32f1xx_matlab_tim.c^
.\MCU_STM32F1xx_Matlab\Drivers\STM32F1xx_SIMULINK\stm32f1xx_periph_registers.c
::-------------------------------------------------------------------------
:: -------------------------WRAPPER PATHS AND CODE---------------------------
:: оболочка, которая будет моделировать работу МК в симулинке
set includes_WRAPPER= -I".\MCU_Wrapper"
set code_WRAPPER= .\MCU_Wrapper\Outputs\asmjmp.obj^
.\MCU_Wrapper\MCU.c^
.\MCU_Wrapper\mcu_wrapper.c
:: оболочка, которая будет моделировать работу МК в симулинке
set asm_WRAPPER=asmjmp
set output_folder=.\MCU_Wrapper\Outputs\
set asm_source=.\MCU_Wrapper\%asm_WRAPPER%.asm
set asm_obj=%output_folder%%asm_WRAPPER%.obj
::-------------------------------------------------------------------------
:: ---------------------SET PARAMS FOR MEX COMPILING-----------------------
:: --------ALL INCLUDES--------
set includes= %includes_USER% %includes_MCU% %includes_WRAPPER%
set codes= %code_WRAPPER% %code_USER% %code_MCU% %code_MCU_Sim%
:: -------OUTPUT FOLDER--------
set output= -outdir "."
:: если нужен дебаг, до запускаем run mex с припиской debug
IF [%1]==[debug] (set debug= -g)
::-------------------------------------------------------------------------
::------START COMPILING-------
set asm_exe= "C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.29.30133\bin\Hostx64\x64\ml64.exe"
set asm_command= /c /Zi /Fo %asm_obj% %asm_source%
%asm_exe% %asm_command%
echo.
echo Compiling...
mex %output% %defines% %includes% %codes% %debug%

90
.outdate/MCU_Wrapper/run_mex.bat.stm32f4xx Normal file
View File

@@ -0,0 +1,90 @@
@echo off
set defines=-D"STM32F407xx" -D"USE_HAL_DRIVER"^
-D"MATLAB"^
-D"__sizeof_ptr=8"
:: -------------------------USERS PATHS AND CODE---------------------------
:: заголовочные файлы (не добавлять CMSIS и HAL, они добавлены ниже)
set includes_USER= -I".\Core\Inc"
:: исходный код
set code_USER=.\Core\Src\main.c^
.\Core\Src\tim.c^
.\Core\Src\gpio.c^
.\Core\Src\stm32f4xx_it.c^
.\Core\Src\system_stm32f4xx.c
:: .\Core\Src\stm32f4xx_hal_msp.c^
::-------------------------------------------------------------------------
:: -----------------------MCU LIBRARIES & SIMULATOR------------------------
:: -----MCU LIBRARIES STUFF----
:: заголовочные файлы
set includes_MCU= -I".\MCU_STM32F4xx_Matlab"^
-I".\MCU_STM32F4xx_Matlab\Drivers\STM32F4xx_SIMULINK"^
-I".\MCU_STM32F4xx_Matlab\Drivers\CMSIS"^
-I".\MCU_STM32F4xx_Matlab\Drivers\STM32F4xx_HAL_Driver\Inc"^
-I".\MCU_STM32F4xx_Matlab\Drivers\STM32F4xx_HAL_Driver\Inc\Legacy"
:: код библиотек МК, переделанный для матлаб
set code_MCU=.\MCU_STM32F4xx_Matlab\Drivers\STM32F4xx_HAL_Driver\Src\stm32f4xx_hal_tim.c^
.\MCU_STM32F4xx_Matlab\Drivers\STM32F4xx_HAL_Driver\Src\stm32f4xx_hal_tim_ex.c^
.\MCU_STM32F4xx_Matlab\Drivers\STM32F4xx_HAL_Driver\Src\stm32f4xx_hal_rcc.c^
.\MCU_STM32F4xx_Matlab\Drivers\STM32F4xx_HAL_Driver\Src\stm32f4xx_hal_gpio.c^
.\MCU_STM32F4xx_Matlab\Drivers\STM32F4xx_HAL_Driver\Src\stm32f4xx_hal_dma.c^
.\MCU_STM32F4xx_Matlab\Drivers\STM32F4xx_HAL_Driver\Src\stm32f4xx_hal_pwr.c^
.\MCU_STM32F4xx_Matlab\Drivers\STM32F4xx_HAL_Driver\Src\stm32f4xx_hal_pwr_ex.c^
.\MCU_STM32F4xx_Matlab\Drivers\STM32F4xx_HAL_Driver\Src\stm32f4xx_hal_cortex.c^
.\MCU_STM32F4xx_Matlab\Drivers\STM32F4xx_HAL_Driver\Src\stm32f4xx_hal.c^
.\MCU_STM32F4xx_Matlab\Drivers\STM32F4xx_HAL_Driver\Src\stm32f4xx_hal_exti.c
:: .\MCU_STM32F4xx_Matlab\Drivers\STM32F4xx_HAL_Driver\Src\stm32f4xx_hal_flash_ramfunc.c^
:: .\MCU_STM32F4xx_Matlab\Drivers\STM32F4xx_HAL_Driver\Src\stm32f4xx_hal_flash.c^
:: .\MCU_STM32F4xx_Matlab\Drivers\STM32F4xx_HAL_Driver\Src\stm32f4xx_hal_flash_ex.c^
:: .\MCU_STM32F4xx_Matlab\Drivers\STM32F4xx_HAL_Driver\Src\stm32f4xx_hal_rcc_ex.c^
:: --------MCU SIMULATOR-------
:: код, которая будет симулировать перефирию МК в симулинке
set code_MCU_Sim= .\MCU_STM32F4xx_Matlab\stm32f4xx_matlab_conf.c^
.\MCU_STM32F4xx_Matlab\Drivers\STM32F4xx_SIMULINK\stm32f4xx_matlab_gpio.c^
.\MCU_STM32F4xx_Matlab\Drivers\STM32F4xx_SIMULINK\stm32f4xx_matlab_tim.c^
.\MCU_STM32F4xx_Matlab\Drivers\STM32F4xx_SIMULINK\stm32f4xx_periph_registers.c
::-------------------------------------------------------------------------
:: -------------------------WRAPPER PATHS AND CODE---------------------------
:: оболочка, которая будет моделировать работу МК в симулинке
set includes_WRAPPER= -I".\MCU_Wrapper"
set code_WRAPPER= .\MCU_Wrapper\Outputs\asmjmp.obj^
.\MCU_Wrapper\MCU.c^
.\MCU_Wrapper\controller.c
:: оболочка, которая будет моделировать работу МК в симулинке
set asm_WRAPPER=asmjmp
set output_folder=.\MCU_Wrapper\Outputs\
set asm_source=.\MCU_Wrapper\%asm_WRAPPER%.asm
set asm_obj=%output_folder%%asm_WRAPPER%.obj
::-------------------------------------------------------------------------
:: ---------------------SET PARAMS FOR MEX COMPILING-----------------------
:: --------ALL INCLUDES--------
set includes= %includes_USER% %includes_MCU% %includes_WRAPPER%
set codes= %code_WRAPPER% %code_USER% %code_MCU% %code_MCU_Sim%
:: -------OUTPUT FOLDER--------
set output= -outdir "."
:: если нужен дебаг, до запускаем run mex с припиской debug
IF [%1]==[debug] (set debug= -g)
::-------------------------------------------------------------------------
::------START COMPILING-------
set asm_exe= "C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.29.30133\bin\Hostx64\x64\ml64.exe"
set asm_command= /c /Zi /Fo %asm_obj% %asm_source%
%asm_exe% %asm_command%
echo.
echo Compiling...
mex %output% %defines% %includes% %codes% %debug%