/**
**************************************************************************
* @dir ../MCU_Wrapper
* @brief <b> Папка с исходным кодом оболочки МК. </b>
* @details 
В этой папке содержаться оболочка(англ. wrapper) для запуска и контроля 
эмуляции микроконтроллеров в MATLAB (любого МК, не только STM). 
Оболочка представляет собой S-Function - блок в Simulink, который работает 
по скомпилированому коду. Компиляция происходит с помощью MSVC-компилятора. 
**************************************************************************/

/**
**************************************************************************
* @file mcu_wrapper_conf.h
* @brief Заголовочный файл для оболочки МК.
**************************************************************************
@details
Главный заголовочный файл для матлаба. Включает дейфайны для S-Function,
объявляет базовые функции для симуляции МК и подключает базовые библиотеки:
- для симуляции		    "stm32fxxx_matlab_conf.h"
- для S-Function		"simstruc.h"
- для потоков			<process.h>
**************************************************************************/
#ifndef _WRAPPER_CONF_H_
#define _WRAPPER_CONF_H_

// Includes
#include "simstruc.h"               // For S-Function variables
#include <process.h>                // For threads

#include "app_includes.h"


/**
    * @defgroup	MCU_WRAPPER     MCU Wrapper
    * @brief 		Всякое для оболочки МК
    */

/**
    * @addtogroup	WRAPPER_CONF    Wrapper Configuration
    * @ingroup		MCU_WRAPPER
    * @brief 		Параметры конфигурации для оболочки МК
    * @details		Здесь дефайнами задается параметры оболочки, которые определяют как она будет работать
    * @{
    */

// Parametrs of MCU simulator
//#define RUN_APP_MAIN_FUNC_THREAD                    ///< Enable using thread for MCU main() func
//#define DEKSTOP_CYCLES_FOR_MCU_APP      0xFFFF      ///< number of for() cycles after which MCU thread would be suspended 
//#define MCU_CORE_CLOCK                  150000000   ///< MCU clock rate for simulation

// Parameters of S_Function
// INPUT/OUTPUTS PARAMS START
#define IN_PORT_NUMB           2
#define IN_PORT_1_WIDTH        3
#define IN_PORT_2_WIDTH        6

#define OUT_PORT_NUMB           3
#define OUT_PORT_1_WIDTH        16
#define OUT_PORT_2_WIDTH        16
#define OUT_PORT_3_WIDTH        16

// INPUT/OUTPUTS PARAMS END
/** WRAPPER_CONF
  * @}
  */



/**
  * @addtogroup	MCU_WRAPPER
  * @{
  */

/** @brief Записывает значение в выходной массив блока S-Function
  * @param _var_ Значение, которое необходимо записать (будет преобразовано в float)
  * @param _arr_ind_ Индекс выходного порта
  * @param _val_ind_ Индекс элемента в выходном массиве
  */
#define	WriteOutputArray(_var_, _arr_ind_, _val_ind_)	__WriteOutputArray(Buffer, (float)_var_, _arr_ind_, _val_ind_)

/** @brief Считывает значение из входного массива блока S-Function
  * @param _var_ Значение, которое необходимо записать (будет преобразовано в float)
  * @param _arr_ind_ Индекс входного порта
  * @param _val_ind_ Индекс элемента во входном массиве
  */
#define	ReadInputArray(_arr_ind_, _val_ind_)		__ReadInputArray(Buffer, _arr_ind_, _val_ind_)



// INPUT/OUTPUTS AUTO-PARAMS START
/// === Полный размер буфера ===
#define TOTAL_IN_SIZE (IN_PORT_1_WIDTH + IN_PORT_2_WIDTH)

/// === Смещения массивов (внутри общего буфера) ===
#define OFFSET_IN_ARRAY_1 0
#define OFFSET_IN_ARRAY_2 (OFFSET_IN_ARRAY_1 + IN_PORT_1_WIDTH)

/// === Полный размер буфера ===
#define TOTAL_OUT_SIZE (OUT_PORT_1_WIDTH + OUT_PORT_2_WIDTH + OUT_PORT_3_WIDTH)

/// === Смещения массивов (внутри общего буфера) ===
#define OFFSET_OUT_ARRAY_1 0
#define OFFSET_OUT_ARRAY_2 (OFFSET_OUT_ARRAY_1 + OUT_PORT_1_WIDTH)
#define OFFSET_OUT_ARRAY_3 (OFFSET_OUT_ARRAY_2 + OUT_PORT_2_WIDTH)

// INPUT/OUTPUTS AUTO-PARAMS END

extern const int outLengths[OUT_PORT_NUMB];
extern const int outOffsets[OUT_PORT_NUMB];
extern const int inLengths[IN_PORT_NUMB];
extern const int inOffsets[IN_PORT_NUMB];
#define TOTAL_XD_SIZE (TOTAL_IN_SIZE + TOTAL_OUT_SIZE)
#define XD_INPUT_START      0
#define XD_OUTPUT_START     (XD_INPUT_START + TOTAL_IN_SIZE)





// Fixed parameters(?) of S_Function
#define NPARAMS                 1                               ///< number of input parametrs (only Ts)
#define DISC_STATES_WIDTH       TOTAL_XD_SIZE    ///< width of discrete states array (outbup buffer)



/**
  * @brief      Define for creating thread in suspended state.
  * @details    Define from WinBase.h. We dont wanna include "Windows.h" or smth like this, because of HAL there are a lot of redefine errors.
  */
#define CREATE_SUSPENDED                0x00000004
typedef void* HANDLE; ///< MCU handle typedef

/**
  * @brief  MCU handle Structure definition. 
  * @note 	Prefixes: h - handle, s - settings, f - flag
  */
typedef struct {
    // MCU Thread
    HANDLE          hMCUThread;                 ///< Хендл для потока МК
    int             idMCUThread;                ///< id потока МК (unused)
    // Flags
    unsigned        fMCU_Stop : 1;              ///< флаг для выхода из потока программы МК
    unsigned        fInitDone : 1;              ///< флаг для выхода из потока программы МК

    double          SimTime;                    ///< Текущее время симуляции
    long            SystemClock;                ///< Счетчик тактов для симуляции системных тиков (в целочисленном формате)

    double          SystemClockDouble;          ///< Счетчик в формате double для точной симуляции системных тиков С промежуточными значений
    double          sSystemClock_step;          ///< Шаг тиков для их симуляции, в формате double
    double          sSimSampleTime;             ///< Период дискретизации симуляции
}SIM__MCUHandleTypeDef;
extern SIM__MCUHandleTypeDef hmcu;              // extern для видимости переменной во всех файлах

//-------------------------------------------------------------//
//------------------  SIMULINK WHILE DEFINES  -----------------//
#ifdef RUN_APP_MAIN_FUNC_THREAD
/* DEFINE TO WHILE WITH SIMULINK WHILE */
/**
  * @brief      Redefine C while statement with sim_while() macro.
  * @param      _expression_ - expression for while.
  * @details    Это while который будет использоваться в симулинке @ref sim_while для подробностей.
  */
#define while(_expression_)                          sim_while(_expression_) 
#endif

/* SIMULINK WHILE */
/**
  * @brief      While statement for emulate MCU code in Simulink.
  * @param      _expression_ - expression for while.
  * @details    Данный while необходим, чтобы в конце симуляции, завершить поток МК:
  *             При выставлении флага окончания симуляции, все while будут пропускаться 
  *             и поток сможет дойти до конца функции main и завершить себя. 
  */    
#define sim_while(_expression_)                     while((_expression_)&&(hmcu.fMCU_Stop == 0))

/* DEFAULT WHILE */
/**
  * @brief      Default/Native C while statement.
  * @param      _expression_ - expression for while.
  * @details    Данный while - аналог обычного while, без дополнительного функционала.
  */
#define native_while(_expression_)                   for(; (_expression_); )
  /***************************************************************/

//------------------  SIMULINK WHILE DEFINES  -----------------//
//-------------------------------------------------------------//



//-------------------------------------------------------------//
//---------------- SIMULATE FUNCTIONS PROTOTYPES  -------------//
/* Step simulation */
void MCU_Step_Simulation(SimStruct *S, time_T time);     

/* MCU peripheral simulation */
void MCU_Periph_Simulation(SimStruct* S);

/* Initialize MCU simulation */
void SIM_Initialize_Simulation(SimStruct* S);

/* Deinitialize MCU simulation */
void SIM_deInitialize_Simulation(SimStruct* S);

/* Read inputs S-function  */
void MCU_readInputs(SimStruct* S);

/* Write pre-outputs S-function (out_buff states) */
void MCU_writeOutputs(SimStruct* S);

/* Write outputs of block of S-Function*/
void SIM_writeOutputs(SimStruct* S);

/* Write inputs of block of S-Function*/
void SIM_readInputs(SimStruct* S);

/* Set output of block of S-Function*/
void __WriteOutputArray(real_T* xD, float value, int array_index, int value_index);

/* Get input of block of S-Function*/
float __ReadInputArray(const real_T* xD, int array_index, int value_index);
//---------------- SIMULATE FUNCTIONS PROTOTYPES  -------------//
//-------------------------------------------------------------//

/** MCU_WRAPPER
    * @}
    */
#endif // _WRAPPER_CONF_H_


//-------------------------------------------------------------//
//---------------------BAT FILE DESCRIBTION--------------------//
/**
  * @file run_mex.bat
  * @brief Батник для компиляции оболочки МК.
  * @details
  * Вызывается в матлабе из allmex.m.
  * 
  * Исходный код батника:
  * @include run_mex.bat
  */