Programmatic Workflow Overview

The programmatic workflow uses a programmatic interface that you can call into by using the MATLAB^® command line or a MATLAB script to configure a customized C++ class interface. Additionally, you can use the functions to facilitate scripting, automated testing, and developing or utilizing downstream features. The programmatic interface is composed of the following functions:

To programmatically configure a customized C++ interface, follow the outlined workflow:

Open Environment

Open the environment for configuring a customized C++ class interface:

Configure Model as Class

Configure the class name and namespace. When you generate C++ code from a model, that model appears as a class in the generated code. To ease integration and comply with code and interface requirements, you can customize the generated class name. Optionally, you can scope the generated code and prevent symbol clashes within a project by specifying a namespace for the generated class. In modeled systems that use a model hierarchy, you can specify a different namespace for each model in the hierarchy.

The generated C++ class interface, declared in the model header file, incorporates the customized name and namespace:

// File: CppClassWorkflowKeyIgnition.h

namespace CustomizedNamespace
{
  class customized_ModelClass {
    // public data and function members
   public:

    // private data and function members     
   private:

  };
}

Configure Model Data Elements as Class Members

Configure the visibility and access of class members. When you generate C++ code from a model, Simulink data elements appear as class members in the generated code. To adjust the encapsulation of the class data to meet code standards, security, or performance requirements, you can customize the visibility and access of the generated class members. Simulink data elements can be grouped into the following categories of modeling elements:

For each model element category, you can configure the data visibility to control the access modifier (access specifier) of the generated class members. Each option and its impact on the generated C++ class interface, declared in the model header file, is outlined in this table.

File: CppClassWorkflowKeyIgnition.h

namespace CustomizedNamespace
{
  class customized_ModelClass {
   public:
  
    // example inport
    ExtU rtU;

    // example outport
    ExtY rtY;
  
    // example block signals and states
    DW rtDW;

   // Other data, methods, and types (not shown)
   private:
    … 
  };
}

File: CppClassWorkflowKeyIgnition.h

// Class declaration for model example_model
namespace CustomizedNamespace
{
  class customized_ModelClass {
   public:

   protected:

    // example inport
    ExtU rtU;

    // example outport
    ExtY rtY;
  
    // example block signals and states
    DW rtDW;

   // Other data, methods, and types (not shown)   
   private:
    … 
  };
}

File: CppClassWorkflowKeyIgnition.h

namespace CustomizedNamespace
{
  class customized_ModelClass {
   public:
    
   private:
    // example inport
    ExtU rtU;

    // example outport
    ExtY rtY;
  
    // example block signals and states
    DW rtDW;

   // Other data, methods, and types (not shown)
  };
}

File: CppClassWorkflowKeyIgnition.h

namespace CustomizedNamespace
{
  class customized_ModelClass {
   public:

   // model step function
   void step1(real_T rty_engineState,
     const real_T modelParameterArgument);

   // Other data, methods, and types (not shown)
   private:
    … 
  };
}

After you set the data visibility of a model element category, you can configure the member access method to determine how the get and set methods are generated for the data elements. This configuration controls how application code can view and modify the class member data. Each option and its impact on the generated C++ class interface, declared in the model header file, is outlined in this table.

File: CppClassWorkflowKeyIgnition.h

namespace CustomizedNamespace
{
  class customized_ModelClass {
   public:
   // example inport
   void setInport(real_T localArgInput);

   // example outport
   real_T getOutport() const;

   // example of model parameter arguments configured with
   // ‘DataAccess’ ‘Direct'
   real_T const &getInstP() const;

   // example of model parameter arguments configured with
   // ‘DataAccess’ ‘Pointer’
   // real_T const *getInstP() const;

   // example Block parameters get and set methods
   const P &getBlockParameters() const;
 
   void setBlockParameters(const P *pP) const;

   // example Block states get and set methods
   const DW &getDWork() const;
 
   void setDWork(const DW *pDW);
    
   private:
    … 
  };
}

File: CppClassWorkflowKeyIgnition.h

namespace CustomizedNamespace
{
  class customized_ModelClass {
   public:
   // example inport set method
   void setkeyState(real_T localArgInput) {
     rtU.keyState = localArgInput;
   }
 
   // example outport get method
   const real_T *getengineState() const {
     return rtY.engineState;
   }

   // example Block parameters get and set method
   const P &getBlockParameters() const {
     return rtP;
   }
 
   void setBlockParameters(const P *pP) const {
     rtP = *pP;
   }

  // example Block states get and set methods
   const DW &getDWork() const {
     return rtDW;
   }
 
   void setDWork(const DW *pDW) {
     rtDW = *pDW;
   }
     
   private:
    … 
  };
}

File: CppClassWorkflowKeyIgnition.h

namespace CustomizedNamespace
{
  class customized_ModelClass {
    
   // public data and function members
   public:

   // External inputs (root inport signals with default storage)
   struct ExtU {
     real_T keyState;                   // '<Root>/keyState'
   };
  
   // External outputs (root outports fed by signals with default storage)
   struct ExtY {
     real_T engineState[3];             // '<Root>/engineState'
     real_T cycleTime;                  // '<Root>/cycleTime'
   };
    …

   // example inport
   void setExternalInputs(const ExtU *pExtU);
 
   // example outport 
   const ExtY &getExternalOutputs() const;

   // Other model element categories may not be configured as ‘Structure-based method’
        
  private:
    … 
  };
}

File: CppClassWorkflowKeyIgnition.h

namespace CustomizedNamespace
{
  class customized_ModelClass {
   public:

   // External inputs (root inport signals with default storage)
   struct ExtU {
     real_T keyState;                   // '<Root>/keyState'
   };
  
   // External outputs (root outports fed by signals with default storage)
   struct ExtY {
     real_T engineState[3];             // '<Root>/engineState'
     real_T cycleTime;                  // '<Root>/cycleTime'
   };
    …

   // example inport
   void setExternalInputs(const ExtU *pExtU);
 
   // example outport 
   const ExtY &getExternalOutputs() const;

   // example inport
   void setExternalInputs(const ExtU *pExtU)
   {
      rtU = *pExtU;
   }
 
   // example outport
   const ExtY &getExternalOutputs() const
   {
      return rtY;
   }
   // Other model element categories may not be configured as ‘Inlined structure-based method’
    
   private:
    … 
  };
}

File: CppClassWorkflowKeyIgnition.h

namespace CustomizedNamespace
{
  class customized_ModelClass {
   public: 
   // External inputs (root inport signals with default storage)
   struct ExtU {
     real_T keyState;                   // '<Root>/keyState'
   };
  
   // External outputs (root outports fed by signals with default storage)
   struct ExtY {
     real_T engineState[3];             // '<Root>/engineState'
     real_T cycleTime;                  // '<Root>/cycleTime'
   };
    …

   // External inputs
   ExtU rtU;
 
   // External outputs
   ExtY rtY;
        
   private:
    … 
  };
}

For each model element category, valid data visibility and member access method combinations are outlined in this table.

For model parameter arguments, you can configure block parameters to be instance-specific or shared when the visibility is private. See Configure Parameters for C++ Interface Code Generation for more information. To configure Individual arguments visibility for model parameter arguments, the model must be a referenced model. Only referenced models can generate methods that use individual arguments.

For inports, outports, and model parameter arguments, you can additionally specify whether the data for the model element category is stored by value ('Direct') or pointer ('Pointer') in the generated code.

When configuring data access for Inports or Outports as pointer members, the model must have model configuration parameters set to either generate an example ERT main program (ert_main.cpp) or generate code only. Additionally, the data access method for the inports or outports must be structure-based. To configure the data access method for model parameter arguments, data visibility cannot be set to Individual arguments.

Configure Model Functions as Class Methods

Configure the class method names and arguments. When you generate C++ code from a model, model functions appear as class methods in the generated code. To integrate with external code or interface requirements, you can customize the name of the generated class methods. Additionally, for base-rate periodic functions and Simulink Functions, you can configure the name, order, and identifier of the generated arguments.

The generated class methods are referred to as entry-point methods and are locations in code where a transfer of program control (execution) occurs. Entry-point methods vary depending on the type of Simulink model and can be grouped into the following types:

The generated C++ class interface, declared in the model header file, incorporates the function name and argument customizations in the generated entry-point methods:

File: CppClassWorkflowKeyIgnition.h

namespace CustomizedNamespace
{
  class customized_ModelClass {
   public:
    // model initialize function- customized name
   void customized_initialize();

    // model step function- customized name & arguments
   void customized_step(customArg1, const* customArg2);

    // model terminate function- customized name
   void customized_terminate();

    // Constructor
   customized_ModelClass();

    // Destructor
   ~customized_ModelClass();
 
   private:
  … 
  };
}

Generate C++ Class Interface

Generate the customized C++ class interface by generating code from the model. To verify your customized C++ class interface configurations, build the model and view the generated class, class member, and class method representations.

If the generated code representation does not meet your requirements, reconfigure the interface and generate code again until code generations requirements are satisfied. For guidance on understanding the generated code, see Analyze Generated Data Code Interface Report.

Considerations and Limitations