Now this makes me laugh, because I know that writing an S-Function is very powerful and not that complicated.

In my opinion, understanding S-Functions is the best way to understand how Simulink works.

When looking at the previous posts on this blog, I realized that I wrote a few posts about advanced usage of s-functions (Variable Size Signals and Unit Delay and Scheduling Future Events), but I never covered the basic of how S-Functions work.

Getting Started with S-Functions

For most MATLAB users, I recommend starting by writing S-Functions in MATLAB (in opposite to C or C++). MATLAB S-Functions have some limitations compared to C or C++, but debugging is easier.

Personally, I like to start with examples. In MATLAB, type:

This will launch a library containing links to many examples. In this collection, the simplest model to start with is msfcndemo_timestwo.mdl.

In this model, click on the annotation to open the source code of the S-Function.

Basic structure of an S-Function

If you look at the code, you will find that the S-Function is in fact just a MATLAB function, taking as input a variable block and passing it to another function using the line setup(block).

The block variable

This block variable is an instance of the Simulink.MSFcnRunTimeBlock class. We call it the S-Function run-time object.

Using the run-time object, the S-Function can exchange information with the Simulink engine.

The setup(block) function

In the setup function, the run-time object allows you to specify and obtain information about various characteristics of the block, including ports, parameters, states, work vectors, etc.

In our example msfcn_times_two.m, the properties of ports are set using lines like:

Also, the setup function is responsible for registering a set of callback methods that the Simulink solver will call during different phases of the simulation.

In the times two example, we register only one method, the output function:

If you are interested to see the list of available methods and when they are called, I recommend going through the documentation section How the Simulink Engine Interacts with C S-Functions

Registered Methods

Every time the Simulink engine calls a method of an S-Function, it passes to it the run-time object.

In msfcn_times_two.m, we access the data of the input port and use it to compute the value that will be written to the output port:

Conclusion

This is it for this simple s-function example.

Of course, if you need to multiply a signal by two in Simulink, I recommend using a Gain block, and not an S-Function. But hopefully this simple example gives you an idea of how MATLAB S-functions work.

Now it's your turn

Do you use S-Functions? Are there S-Functions related topics you would like to be covered in a future post? Leave a comment here.

MATLAB Timeseries

In R2012a, most methods for importing and exporting data to and from a model have been standardized to use MATLAB Timeseries.

For example, if you open the dialog of the To Workspace, you will see that timeseries is now the default save format:

Using MATLAB timeseries offers a lot of advantages as I described in a previous post on the dataset logging format.

Importing Bus Data

Let's say I want to import bus data, I create a structure of timeseries:

Then I specify the name of the variable or file, and the bus object in the From Workspace or From File dialog.

and we have a model importing buses!

Exporting Bus data

To export bus data, all you need to do do is connect the bus signal to a To Workspace or To File block and ensure the block is configured to use timeseries as save format (the default).

Once the data is in the MATLAB Workspace, you can use all timeseries methods to process your data.

For example, I can quickly detrend, filter and plot a random signal "b", contained inside bus "busOut":

Now its your turn

Are you going to include these new methods of loading and saving bus data in your workflow? Which is be best block pair for loading/saving buses? Let us know by leaving a comment here

In R2012a, we made your life easier by introducing the Signal Hierarchy Viewer.

When right-clicking on a signal in R2012a, you will notice a new Signal Hierarchy option.

This opens a nice small window listing the hierarchy of signals inside the bus.

As you can see in the image above, the Signal Hierarchy Viewer allows you to filter the signals in the bus to quickly find what you are looking for.

Now it's your turn

What do you think of the Signal Hierarchy Viewer? Let us know by leaving a comment here.

... and I really like that change!

What's new

In R2012a, Simulink automatically refreshes links and model blocks. Yes, you heard me, no longer need to manually select Edit > Links and Model Blocks > Refresh for your model to realize a change in a library or model block.

Here's how it works.

Model Block

Before R2012a, when changing the number of ports of a referenced model, you had to manually select Edit > Links and Model Blocks > Refresh for the Model block to update its ports. In R2012a, saving the referenced mode automatically updates the parent block:

Library Blocks

When you edit a library block, Simulink indicates stale links by displaying the linked blocks grayed out. When you click in the model, as soon as the window becomes active Simulink refreshes any stale links with what is in the library, even if you have not saved the library yet.

Now it's your turn

Try this new behavior and let us know if you are as happy as I am by leaving a comment here.

This visualization tool was introduced in release R2010a and has been improved upon every release thereafter.

The novelty of this tool is that it ships as both a Simulink block and a System object (dsp.TimeScope) and therefore offers the same graphical user interface, parameters, and tools in both the MATLAB and Simulink environments.

A Scope for Simulink

To use it in a model, just drag the block from the Library Browser and connect the signal you want to visualize.

As you can see, when used in Simulink, the Time Scope allows you to control the simulation directly on the scopes, for example, it has Start, Pause and Stop buttons. In addition, there is a button to highlight and quickly find the block corresponding to the Scope within the model.

A Scope for MATLAB

For MATLAB-based simulations, the Time Scope System object offers the standard System object methods, for example:

So, what is unique about the Time Scope?

Both the block and System object offer many common features, for example, both include integrated measurement panels, which display Signal Statistics, peak detection and Bi-level measurements:

The Time Scope has a configurable layout that lets you select the number of rows and columns used to display multiple axes:

Unique to this scope is its ability to accept input data as both sample-based and frame-based signals. Also, both block and System object accept complex data and automatically display the data as Magnitude and Phase, or real and imaginary parts.

Look at the demos

Many of the Simulink and MATLAB based examples of the DSP System Toolbox have been updated to take advantage of the Time Scope features. From the Help Browser, look in the demo section of the DSP System Toolbox:

For MATLAB users, you will find demos like:

• Envelope Detection
• GSM Digital Down Converter

and for Simulink:

• Audio Sample Rate Conversion
• Autoscaling and Curve Fitting

Moreover, I strongly recommend going through the block documentation to see everything the Time Scope can do.

Now it's your turn

What do you think of the Time Scope? Let us know by leaving a comment here

I will share a few possible options I usually consider and would like to know how you choose one versus another.

Enabled Subsystem

Maybe it is because it is the first method I learned when I started using Simulink long ago, but I like Enabled Subsystems.

Using this method, you use Simulink blocks to generate one logical signal for each subsystem. This method is useful when you have a small number of mutually exclusive systems and the activation logic is relatively simple.

Switch and Multiport Switch

As explained by Seth in a previous post, the Switch and Multiport Switch blocks can be used to implement conditional execution.

If you enable the Conditional branch execution optimization, Simulink executes only the blocks required to compute the control input and the data input selected by the control input.

I typically use this method only when I need to switch between 2 very simple options, made of just a few directfeedthrough stateless blocks.

Action Subsystems

If Action Subsystem and Switch Case Action Subsystem are especially designed to model if-else and switch-case control flows.

In this approach, you define the conditions in the dialog of the If-Else or Switch-Case block.

One thing to note with this approach is that all blocks in an Action subsystem driven by an If or Switch Case block must run at the same rate as the driving block.

Stateflow and Simulink Functions

For complex activation logic, I recommend going with Stateflow. Inside the chart, you can place the algorithms to be conditionally executed inside Simulink Functions.

I like to use this technique especially when the Simulink function is called from multiple places in the chart.

Stafeflow and Function-Call Subsystems

I have to admit, when I place a large or important algorithm inside a Stateflow Simulink Function, I feel like if I am hiding it. This is why sometimes I prefer to generate Function-Calls from the chart.

Stafeflow, Enumeration and Switch-Case Action Subsystems

One way to make it obvious that one and only one subsystem is active at a time is to generate an enumerated type from the Stateflow chart and use it in a Switch-Case construct.

Conclusion

All these methods have advantages and disadvantages. I think it is important to read and understand the documentation to pick the one appropriate for your use case.

When in doubt, go for readability. Try picking one that you think will make it as easy as possible to understand the functionality of your model.

Now it's your turn

I would be very interested to hear what are your criteria when choosing one versus another.

Let us know by leaving a comment here.

Nishaat: Hey Guy, did you notice the new Model Advisor Exclusions feature in R2012a?

Guy: There are so many new features every release... I think I missed that one. What is it?

Nishaat: When you create models, I bet you sometimes use the Model Advisor.

Guy: Of Course! Model Advisor checks are very useful to ensure design consistency in large modeling environments.

Nishaat: Using exclusions, you will now be able to fine-tune the Model Advisor analysis. This should save you time if there are blocks or subsystems in your model that do not need to be checked.

Guy: Cool, how does that work?

Nishaat: First, identify and right-click on the model elements you want to exclude from Model Advisor analysis and select from which checks you want it excluded.

Nishaat: This will launch the Model Advisor Exclusion Editor

Nishaat: Run the Model Advisor analysis and you will see in the report when an exclusion rule is used in a check.

Guy: Pretty cool, I'll definitely start using Model Advisor Exclusions soon!

Now it's your turn

Will exclusions be useful in your workflow? Leave us a comment here.

Today guest blogger Pravallika describes how she used new features of the System Identification Toolbox to design a controller for a DC motor

Any controls engineer knows that the key to designing a good controller is having a good plant model. But what do you do if you don’t have the underlying equations?

System identification can help in that case. In R2012a, the System Identification Toolbox added support for estimating parameters of a model type that is most intuitive and easiest to work with for controls engineers – continuous-time transfer functions. You can specify how many poles and zeros you want your transfer function to have, and the toolbox determines locations of poles and zeros automatically. If the system you are trying to model has a delay, the toolbox can automatically determine its value.

The Setup

I have been working with the setup shown in the image below. It is very simple; it is a small DC motor connected to an Arduino board.

I applied a voltage to the motor and recorded the resulting motion. I imported this data in MATLAB and constructed an iddata object.

Here is what the data look like, using the iddata plot command.

Estimation

Let’s begin by estimating the simplest possible transfer function – first-order, with no zeros. For that, we use the new function tfest.

After the estimation is completed, we can compare the output of the model with the measured shaft angle. The comparison shows that the model does a good job in capturing dynamics of the motor.

Validation

To ensure that the estimated transfer function represents motor dynamics, we need to validate this transfer function against an independent data set.

I tried feeding other sets of data acquired experimentally through the identified transfer function and compared the result with the measured shaft angle. Even though the fit is not perfect, the identified transfer function does a pretty good job in capturing system dynamics.

Using the Estimated Transfer Function

Now let's use the identified transfer function model to design a PID controller using pidtune.

One notable quality of models obtained with System Identification Toolbox is that they not only contain the information about the “nominal” parameter values, but also carry information about parameter uncertainty. We can check the effect of this parameter uncertainty on the bode plot magnitude of the estimated transfer function.

We can also use the function rsample to sample this parameter uncertainty to create an array of transfer functions to test our controller.

The plot above shows the closed-loop step response for the nominal plant as well as the additional ten step responses for the sampled parameter uncertainty. We can see that the PID controller we designed works well in the face of uncertainty in estimated transfer function parameters.

Estimating Other Model Types

In addition to estimating continuous-time transfer functions, System Identification Toolbox lets you estimate continuous-time state-space models and process models (special, low-order transfer functions). You can quickly compare different models and pick the one that is most appropriate for your problem.

Now it is your turn

How do you develop plant models? Try using new capabilities for continuous-time transfer function estimation and let us know what you think by leaving us a comment here.

External Mode vs. Normal Mode

In external mode, Simulink Coder is used to dynamically link generated algorithm code with generated hardware driver code. The resulting executable runs in Windows kernel mode and communicates with Simulink via External Mode.

In normal mode, the algorithm runs in Simulink and the I/O drivers run in a separate Windows kernel mode process that maintains the real-time clock.

The following diagram illustrates the difference between these two modes:

Advantages of Normal Mode

As you can guess based on the above diagram, normal mode offers lower performance when compared to external mode. On the other hand, normal mode offers interesting advantages:

• Support for variable step solvers
• No need for Simulink Coder

You can also use Normal Mode on Windows 64-bit, where External Mode is only supported in Windows 32-bit as of R2012a.

How does that work?

Most blocks in the Real-Time Windows Target library have at least 2 parameters: Sample Time and Maximum missed ticks.

Since, in normal mode, only the I/O drivers are synchronized with the real-time clock, it is possible for the simulation to miss clock ticks. When this happens, the Maximum missed ticks parameter determines how your model should behave. Set it to a value of zero if you want your model to error out at the first missed tick. Use a larger value if your application can deal with a few missed ticks. Note that, if the model misses a few ticks, it will resynchronize with the real-time clock as soon as possible.

Now it's your turn

Do you think Real-Time Windows Target normal mode will be useful for you? Leave a comment here.

Legends for Simulink Scopes

When opening the Scope parameters dialog in R2012a, you will notice a new option:

When simulating the model, the legend will appear and you will be able to choose its position:

The selected position will be saved with model.

The information displayed in the legend can come from multiple sources in the model:

• Signal name
• Block name if signal is not named
• Name of elements for composite signals
• Port number if source block has multiple ports
• Signal index for vectors

I tried to illustrate all those in the following example:

Now it's your turn

Are you happy the legends are now available in the Simulink Scope? Leave a comment here.