Documentation

In the Apps gallery, click Embedded Coder.

In the Configuration Parameters dialog box, set these parameters:

Generate code. On the C++ Code tab, click Build.

View the generated code. On the C++ Code tab, click View Code.

If you use your own main, create concrete subclasses from the generated abstract classes shown in RecvData_<T>.h and SendData<T>.h. If you use the generated example main program, concrete subclasses are provided for you in the file.

Implement the class functions SendData and RecvData to call into your selected operating system or middleware to send and receive messages.

Create an instance of your implemented send and receive message classes (send and receive objects).

Create an instance of the model class by using the instances of each message class (send and receive objects) as arguments in the model constructor.

Send and receive messages as required by your application. You are expected to manage the lifetime of the message queues. It is required that the queues are in a state ready to accept messages prior to the first step of the model.

Open the generated example main program (or create your own). If you use the generated example main program, the concrete subclasses RecvData_real_T and SendData_real_T are provided in the file. If you create your own main, create concrete subclasses in your application code:

To receive messages, hand write the implementation of the generated receive class. Implement the class function RecvData to call into your selected operating system or middleware to receive messages.

An example implementation for POSIX is shown:

class mHMIHandlerRecvData_real_T: public RecvData_real_T {
    public:
    void RecvData(real_T* data, int32_T length, int32_T* status)
    {
        // Use POSIX API mq_receive to receive messages
        unsigned int priority = 1;
        *status = mq_receive(msgQueue, (char *)data, length, &priority);
    }
};

Create a receive object.

static mHMIHandlerRecvData_real_T InMsgRecvData_arg;

To send messages, hand write the implementation of the generated send class. Implement the class function SendData to call into your selected operating system or middleware to send messages.

An example implementation for POSIX is shown:

class mHMIHandlerSendData_real_T : public SendData_real_T {
    public:
    void SendData(const real_T* data, int32_T length, int32_T* status)
    {
        // Use the POSIX API mq_send to send messages
        unsigned int priority = 1;
        *status = mq_send(msgQueue, (char*)data, length, priority);
    }
};

Create a send object.

static mHMIHandlerSendData_real_T OutMesgSendData_arg;

Create an instance of the model class by using your send and receive objects as arguments in the model constructor.

static mHMIHandler mHMI_Obj(InMsgRecvData_arg, OutMsgSendData_arg);

Send and receive messages as required by your application and maintain the lifetime of the message queue.

An example implementation for POSIX is shown:

int_T main(int_T argc, const char *argv[])
{
    // Unused arguments
    (void)(argc);
    (void)(argv);

    //Initialize model
    mHMI_obj.initialize();     

    // Open POSIX queue
     mqd_t msgQueue = mq_open("/PosixMQ_Example", O_RDONLY);
     if (msgQueue == -1)
     {
         printf("mq_open failed\n");
         exit(1);
     }     

    // Send and Receive messages
     while (rtmGetErrorStatus(mHMI_Obj.getRTM()) == (NULL)) {
         //perform application tasks here.
         rt_OneStep();
     }   

    // Close POSIX queue
     mq_close(msgQueue);     

    // Terminate model
     mHMI_Obj.terminat():
     return 0;
 }