Grid_To_Code.h

Go to the documentation of this file.

//
// File: Grid_To_Code.h
//
// Code generated for Simulink model 'Grid_To_Code'.
//
// Model version                  : 1.20
// Simulink Coder version         : 8.14 (R2018a) 06-Feb-2018
// C/C++ source code generated on : Mon May 24 14:54:57 2021
//
// Target selection: ert.tlc
// Embedded hardware selection: Custom Processor->Custom
// Code generation objectives:
//    1. Execution efficiency
//    2. RAM efficiency
// Validation result: Not run
//
#ifndef RTW_HEADER_Grid_To_Code_h_
#define RTW_HEADER_Grid_To_Code_h_
#include "math.h"
#ifndef Grid_To_Code_COMMON_INCLUDES_
# define Grid_To_Code_COMMON_INCLUDES_
#include "rtwtypes.h"
#include "rtw_continuous.h"
#include "rtw_solver.h"
#endif                                 // Grid_To_Code_COMMON_INCLUDES_
 
// Macros for accessing real-time model data structure
#ifndef rtmGetErrorStatus
# define rtmGetErrorStatus(rtm)        ((rtm)->errorStatus)
#endif
 
#ifndef rtmSetErrorStatus
# define rtmSetErrorStatus(rtm, val)   ((rtm)->errorStatus = (val))
#endif
 
#ifndef rtmGetStopRequested
# define rtmGetStopRequested(rtm)      ((rtm)->Timing.stopRequestedFlag)
#endif
 
#ifndef rtmSetStopRequested
# define rtmSetStopRequested(rtm, val) ((rtm)->Timing.stopRequestedFlag = (val))
#endif
 
#ifndef rtmGetStopRequestedPtr
# define rtmGetStopRequestedPtr(rtm)   (&((rtm)->Timing.stopRequestedFlag))
#endif
 
#ifndef rtmGetT
# define rtmGetT(rtm)                  (rtmGetTPtr((rtm))[0])
#endif
 
#ifndef rtmGetTPtr
# define rtmGetTPtr(rtm)               ((rtm)->Timing.t)
#endif
 
// Forward declaration for rtModel
typedef struct tag_RTM RT_MODEL;
 
// Block signals and states (default storage) for system '<Root>'
typedef struct {
  real_T StateSpace[3];                // '<S11>/State-Space'
  real_T StateSpace_DSTATE[2];         // '<S11>/State-Space'
  real_T Gain2;                        // '<Root>/Gain2'
  real_T Gain1;                        // '<Root>/Gain1'
  real_T Gain;                         // '<Root>/Gain'
  int_T StateSpace_IWORK[11];          // '<S11>/State-Space'
  struct {
    void *AS;
    void *BS;
    void *CS;
    void *DS;
    void *DX_COL;
    void *BD_COL;
    void *TMP1;
    void *TMP2;
    void *XTMP;
    void *SWITCH_STATUS;
    void *SWITCH_STATUS_INIT;
    void *SW_CHG;
    void *G_STATE;
    void *USWLAST;
    void *XKM12;
    void *XKP12;
    void *XLAST;
    void *ULAST;
    void *IDX_SW_CHG;
    void *Y_SWITCH;
    void *SWITCH_TYPES;
    void *IDX_OUT_SW;
    void *SWITCH_TOPO_SAVED_IDX;
    void *SWITCH_MAP;
  } StateSpace_PWORK;                  // '<S11>/State-Space'
} DW;
 
// Continuous states (default storage)
typedef struct {
  real_T Integrator_CSTATE;            // '<Root>/Integrator'
} X;
 
// State derivatives (default storage)
typedef struct {
  real_T Integrator_CSTATE;            // '<Root>/Integrator'
} XDot;
 
// State disabled
typedef struct {
  boolean_T Integrator_CSTATE;         // '<Root>/Integrator'
} XDis;
 
#ifndef ODE1_INTG
#define ODE1_INTG
 
// ODE1 Integration Data
typedef struct {
  real_T *f[1];                        // derivatives
} ODE1_IntgData;
 
#endif
 
// Constant parameters (default storage)
typedef struct {
  // Expression: S.A
  //  Referenced by: '<S11>/State-Space'
 
  real_T StateSpace_AS_param[4];
 
  // Expression: S.B
  //  Referenced by: '<S11>/State-Space'
 
  real_T StateSpace_BS_param[6];
 
  // Expression: S.C
  //  Referenced by: '<S11>/State-Space'
 
  real_T StateSpace_CS_param[6];
 
  // Expression: S.D
  //  Referenced by: '<S11>/State-Space'
 
  real_T StateSpace_DS_param[9];
 
  // Expression: S.x0
  //  Referenced by: '<S11>/State-Space'
 
  real_T StateSpace_X0_param[2];
} ConstP;
 
// External outputs (root outports fed by signals with default storage)
typedef struct {
  real32_T R1_Voltage;                   // '<Root>/R1_Voltage'
  real32_T R2_Voltage;                   // '<Root>/R2_Voltage'
  real32_T R3_Voltage;                   // '<Root>/R3_Voltage'
} ExtY;
 
// Real-time Model Data Structure
struct tag_RTM {
  const char_T *errorStatus;
  RTWSolverInfo solverInfo;
  X *contStates;
  int_T *periodicContStateIndices;
  real_T *periodicContStateRanges;
  real_T *derivs;
  boolean_T *contStateDisabled;
  boolean_T zCCacheNeedsReset;
  boolean_T derivCacheNeedsReset;
  boolean_T CTOutputIncnstWithState;
  real_T odeF[1][1];
  ODE1_IntgData intgData;
 
  //
  //  Sizes:
  //  The following substructure contains sizes information
  //  for many of the model attributes such as inputs, outputs,
  //  dwork, sample times, etc.
 
  struct {
    int_T numContStates;
    int_T numPeriodicContStates;
    int_T numSampTimes;
  } Sizes;
 
  //
  //  Timing:
  //  The following substructure contains information regarding
  //  the timing information for the model.
 
  struct {
    uint32_T clockTick0;
    time_T stepSize0;
    uint32_T clockTick1;
    SimTimeStep simTimeStep;
    boolean_T stopRequestedFlag;
    time_T *t;
    time_T tArray[2];
  } Timing;
};
 
// Constant parameters (default storage)
extern const ConstP rtConstP;
 
// Class declaration for model Grid_To_Code
class GRID_MODEL_TESTModelClass
  {
  // public data and function members
 public:
  // model initialize function
  void initialize();
 
  // model step function
  void step();
 
  // Constructor
  GRID_MODEL_TESTModelClass();
 
  // Destructor
  ~GRID_MODEL_TESTModelClass();
 
  // Root outports get method
  const ExtY & getExternalOutputs() const;
 
  // Real-Time Model get method
  RT_MODEL * getRTM();
 
  // protected data and function members
 protected:
  // External outputs
  ExtY rtY;
 
  // private data and function members
 private:
  // Block signals and states
  DW rtDW;
  X rtX;                               // Block continuous states
 
  // Real-Time Model
  RT_MODEL rtM;
 
  // Continuous states update member function
  void rt_ertODEUpdateContinuousStates(RTWSolverInfo *si );
 
  // Derivatives member function
  void Grid_To_Code_derivatives();
};
 
//-
//  These blocks were eliminated from the model due to optimizations:
//
//  Block '<S4>/do not delete this gain' : Eliminated nontunable gain of 1
//  Block '<S5>/do not delete this gain' : Eliminated nontunable gain of 1
//  Block '<S6>/do not delete this gain' : Eliminated nontunable gain of 1
 
 
//-
//  The generated code includes comments that allow you to trace directly
//  back to the appropriate location in the model.  The basic format
//  is <system>/block_name, where system is the system number (uniquely
//  assigned by Simulink) and block_name is the name of the block.
//
//  Use the MATLAB hilite_system command to trace the generated code back
//  to the model.  For example,
//
//  hilite_system('<S3>')    - opens system 3
//  hilite_system('<S3>/Kp') - opens and selects block Kp which resides in S3
//
//  Here is the system hierarchy for this model
//
//  '<Root>' : 'Grid_To_Code'
//  '<S1>'   : 'Grid_To_Code/Controlled Voltage Source'
//  '<S2>'   : 'Grid_To_Code/Controlled Voltage Source1'
//  '<S3>'   : 'Grid_To_Code/Controlled Voltage Source2'
//  '<S4>'   : 'Grid_To_Code/L1'
//  '<S5>'   : 'Grid_To_Code/L2'
//  '<S6>'   : 'Grid_To_Code/L3'
//  '<S7>'   : 'Grid_To_Code/powergui'
//  '<S8>'   : 'Grid_To_Code/L1/Model'
//  '<S9>'   : 'Grid_To_Code/L2/Model'
//  '<S10>'  : 'Grid_To_Code/L3/Model'
//  '<S11>'  : 'Grid_To_Code/powergui/EquivalentModel1'
//  '<S12>'  : 'Grid_To_Code/powergui/EquivalentModel1/Sources'
//  '<S13>'  : 'Grid_To_Code/powergui/EquivalentModel1/Yout'
 
#endif                                 // RTW_HEADER_Grid_To_Code_h_
 
//
// File trailer for generated code.
//
// [EOF]
//