Introduction

In 2014, MathWorks introduced the Simulink Data Dictionary. This new feature provides the ability to store Data Types, Parameters, and Signals in database files. This is great news for embedded systems developers who want the flexibility of using data objects and want to avoid using the base workspace with its potential for data corruption.
In its initial implementation, the data dictionary interface is provided by the Simulink Model Explorer. The GUI interface is clean, intuitive, and easy to use. This interface supports importing and exporting dictionaries to m files and mat files.
Unfortunately, in production code generation environments there is frequently a need to interface this data with external tools such as software specification systems, documentation generators, and calibration tools. MathWorks have not published an API for accessing dictionaries from code, indicating that it may possibly be available in a future release. Today, we will look at some portions of the undocumented API for Simulink Data Dictionaries.

Some background information

Simulink Data Dictionaries exist as files having a standard file extension of .sldd. Dictionary files can be opened with the open function, which in turn calls opensldd. This opens the file and launches the Simulink Model Explorer with the selected dictionary node. When a dictionary is opened, a cached copy is created. While working with a dictionary, changes are made to the cached copy. The dictionary file is only changed when the changes are saved by issuing the relevant command. Until the cached copy is saved, it is possible to view differences between the file and the cached copy, and revert any unwanted changes. The file maintains the date, time, and author of the last saved change, but no information about previous revisions.
From the Model Explorer it is possible to add items to a dictionary from a model, the base workspace, or by creating new items. We can associate a Simulink model with a dictionary by using the model properties dropdown in the Simulink editor.
Using data dictionaries it is possible to tailor a model’s code generation for different targets, simply by changing the dictionary that is being used.

The Simulink Data Dictionary API

Programmatic access to Simulink Data Dictionaries is provided by the undocumented MCOS package Simulink.dd. We will look at two package functions and a few methods of the Simulink.dd.Connection class. These provide the basic ability to work with dictionaries from within our m code.

Creating and Opening Dictionary Files

Dictionary files are created with the package function create:

hDict = Simulink.dd.create(dictionaryFileName);

Existing dictionary files are opened using the package function open:

hDict = Simulink.dd.open(dictionaryFileName);

In both cases the functions return a handle of type Simulink.dd.Connection to the named dictionary file.

Modifying a Dictionary

We can use methods of the Simulink.dd.Connection instance to modify an open dictionary. Dictionaries are organized into two sections: The Configurations section contains Simulink.ConfigSet entries, while Parameter, Signal, and DataType items are placed in the Global section. We can get a list of the items in a section using the getChildNames method:

childNamesList = hDict.getChildNames(sectionName);

Adding and removing items from a section are done using the insertEntry and deleteEntry methods, respectively:

hDict.insertEntry(sectionName, entryName, object)
hDict.deleteEntry(sectionName, entryName)

Modifying an existing entry is done using the getEntry, and setEntry methods:

workingCopy = hDict.getEntry(sectionName.entryName)
% modify workingCopy
hDict.setEntry(sectionName.entryName, workingCopy)

A collection of objects from the base workspace can be added to a dictionary using the importFromBaseWorkspace method:

hDict.importFromBaseWorkspace(sectionName, overwriteExisitngObjectsFlag, deleteFromBaseWorkspaceFlag, cellArrayOfNames)

Additional dictionary manipulations are possible using the evalin and assignin methods:

hDict.evalin(commandString)
hDict.assignin(variableName, variable)

Closing a Dictionary

Finalizing a dictionary session is done with the saveChanges, close, and delete methods:

hDict.saveChanges
hDict.close
hDict.delete

Example: Migrate Single Model to Use Dictionary

This example is an adaptation of MathWorks’ interactive example of the same title, using programmatic Matlab commands rather than GUI interactions.

1. Start by using load_system to open the f14 model. This opens the model and executes the PreLoadFcn callback, which loads design data into the base workspace, without opening the Simulink block diagram editor:

   load_system('f14');

2. Use the Simulink package function findVars to find the variables used by the model:

   usedVariables = Simulink.findVars('f14');

3. Next, use the create package function to create and open a new Simulink Data Dictionary:

   hDict = Simulink.dd.create('f14_data_dictionary.sldd');

4. Attach the newly created dictionary to the model:

   set_param('f14', 'DataDictionary', 'f14_data_dictionary.sldd');

5. Use one of the API methods to add these variables to the Data Dictionary:

   overWrite = true;
   deleteFromWorkspace = false;
   for n = 1:numel(usedVariables)
       if strcmp(usedVariables(n).Source, 'base workspace')
           hDict.importFromBaseWorkspace(overWrite, deleteFromWorkspace, {usedVariables(n).Name});
       end
   end
   

6. Save the changes made to the dictionary:

   hDict.saveChanges;

7. Clean up and we are done:

   hDict.close;
   hDict.delete;
   clear hDict;
   

Final notes

MathWorks have recognized the value of data dictionaries for a long time. In 2006, MathWorker Tom Erkkinen published a paper about multitarget modeling using data dictionaries. The Simulink.dd package was added to Matlab in R2011b, and the DataDictionary parameter was added to Simulink models in R2012a. MathWorks have also indicated that a user API for Simulink Data Dictionaries may be in the works. Until it is released we can make do with the undocumented API.
Update March 7, 2015: Matlab release R2015a now includes a fully documented Simulink.data.Dictionary class, which works in a very similar manner. Users of R2015a or newer should use this new Simulink.data.Dictionary class, while users of previous Matlab releases can use the Simulink.dd class presented in this article.
Have you made some good use of this data-dictionary functionality in your project? If so, please share your experience in a comment below.

The post Simulink Data Dictionary appeared first on Undocumented Matlab.

• Select Accelerator or Rapid Accelerator simulation mode (also see here)
• Enable the options for Compiler optimization, automatic Block Reduction and others in the Optimization pane of the Configuration Parameters window.
• Switch the Compiler optimization from faster build to faster run.
• Disable the options for debugging/animation support, overflow detection and echoing expressions without semicolons in the Simulation Target pane of the Configuration Parameters window. Note that overflow detection is important for fixed-point data so if your model includes FP data, keep this option enabled.
• Disable similar configuration options in Stateflow’s Configuration Parameters window (which is similar but separate from the Simulink window).
• Keep Stateflow charts and Simulink blocks/models closed during simulation to prevent run-time updates (this relates to the animation feature, if enabled)
• Keep output scopes closed during simulation run-time; open the scopes only after the simulation ends. If a scope must remain open in run-time, reduce the number of data points (via decimation, reduced time range and reduced number of plotted signals), increase the plotting refresh period, disable scope scrolling, remove data markers and legends, limit the history size, and use reduced fidelity in the viewer parameters. A similar recommendation applies to regular Matlab plots, by the way.
• Vectorize processing by combining multiple signals into a vector and applying the processing on the vector rather than on the separate signals.
• Sample data in batches (rather than one-by-one) using frame-based processing (R2011b and newer). This can speed up simulations by 10x or more, at the expense of just a little extra memory.
• Aggregate small blocks into larger ones.
• Load the model in memory using load_system instead of open_system and simulate it using the sim command, then post process/display the outputs.
• Avoid blocks that do not support code generation, since they would have to be run in slower interpreted mode.
• If your simulation does not use linear algebra (matrix arithmetic), disable BLAS library support in the Simulation Target pane. But if it does use it, then ensure that BLAS is enabled for optimal performance.
• Avoid algebraic loops where possible.
• Avoid Matlab S-Function and Interpreted Matlab Function blocks. Instead, use Matlab Function, System and C-MEX blocks.
   

  Note: IMHO, the naming of these blocks is quite confusing: Matlab Function refers to a subset of the Matlab language previously called Embedded Matlab that can be directly converted into C-code without requiring the Matlab run-time (MCR); this is basically the language subset used by the Matlab Coder Toolbox. Interpreted Matlab Function refers to the full Matlab functionality and requires the Matlab run-time (MCR) – it was previously called Matlab Function.

• Reduce, simplify or eliminate initialization and termination phases.
• Use the Mask Editor to reduce block images resolution and size.
• Store configurations in loadable MAT files rather than programmatically.
• Consolidate multiple set_param calls into a single call having several name / value pairs.
• Use a stronger platform (esp. increase the amount of memory).
• Limit or disable log output, and disk I/O in general.
• Use the sldiagnostics and slprofreport functions and the Simulink Profiler, to identify and eliminate simulation bottlenecks.
• Use the performanceadvisor function and the Simulink Model Performance Advisor to automatically adjust model configurations for best performance (R2012b and newer; also see this webinar).
• Manually adjust model solver parameters for optimal performance, based on a-priori knowledge about the model behavior.
• Use a faster solver that can still process the model. Different models may require different solvers to run optimally (also see here).
• Tune solver parameters (decrease solver order, increase step size and error tolerance) to improve solution convergence speed at the expense of some accuracy. One user reported a 20x speedup by simply increasing the step-size.
• Prevent excessive zero-crossing or disable zero-crossing detection (also see here and here).
• Use simpler models or models with reduced fidelity.
• Store the simulation state at specific points, then load these states for repeated later simulations, thus saving the simulation time of the loaded portion.
• Run simulations in parallel using Parallel Computing Toolbox (also see here, here and here). An easy way to do this is to run the sim command within a parfor loop.
• Move some calculations onto FPGA or GPU.
• Use a real-time system and set simulation speed to real-time (high priority).

Some additional ideas can be found in the blog posts and webinars mentioned in the hyperlinks at the top of this post. One of the newsletter articles concludes with an example of how applying some of these techniques to a specific model resulted in reduced simulation time, from 453 down to 5 seconds.
I would like to take this opportunity to congratulate MathWorks on a job well done with Simulink’s Performance Advisor. I expect a variant of this tool to be available for regular Matlab m-code in some future Matlab release; it would blend in nicely with the existing mlint (Code Analyzer) tool.

Advanced Matlab Programming course – London 10-11 March, 2014

If this topic has piqued your interest, consider joining my Advanced Matlab Programming course in London on 10-11 March, 2014. In this course/seminar I will explore numerous other ways by which we can improve Matlab’s performance and create professional code. This is a unique opportunity to take your Matlab skills to a higher level within a couple of days.

The post Improving Simulink performance appeared first on Undocumented Matlab.

>> a='הצלחה!'
a =
!
>> currentCharacterEncoding = slCharacterEncoding();
>> currentCharacterEncoding = get_param(0, 'CharacterEncoding')  % equivalent alternative
currentCharacterEncoding =
windows-1252
% Now modify the default encoding to something more useful
>> slCharacterEncoding('ISO_8859-8')
>> set_param(0, 'CharacterEncoding', 'ISO_8859-8');   % equivalent alternative
>> currentCharacterEncoding = slCharacterEncoding()
currentCharacterEncoding =
ISO-8859-8
>> a='הצלחה!'
a =
!                  % still no good in the Command Window...
% Let's try to read a file with some Hebrew words:
>> neutral = importdata('neutral.txt')
neutral =
שולחן'
    'כסא'
    'מנורה'
    'צלחת'
    'סיר'
    'מזלג'

So, it appears that while we did not solve the problems with the Command Window, at least we can now read the prayer book for our New Year prayers…
Let this be a year of fulfillment, prosperity, health and happiness to all. Shana Tova everybody!

The post Reading non-Latin text files appeared first on Undocumented Matlab.