R2022a Release Highlights

New Products

    • Bluetooth Toolbox – Simulate, analyze, and test Bluetooth communications systems
    • DSP HDL Toolbox – Design digital signal processing applications for FPGAs, ASICs, and SoCs
    • Industrial Communication Toolbox – Exchange data over OPC UA, Modbus, MQTT, and other industrial protocols
    • RoadRunner Scenario – Create and play back scenarios for automated driving simulation
    • Wireless Testbench – Explore and test wireless reference applications in real time on SDR hardware

 

Major Updates

    • Econometrics Toolbox – Conduct cointegration tests and fit multivariate time series models interactively in the Econometric Modeler app
    • MATLAB Compiler SDK – Publish a MATLAB function as a Docker container microservice
    • MATLAB Production Server – Map custom request URLs to deployed MATLAB functions, serve static content, and customize request headers
    • Polyspace Access – Identify coding defects, review static analysis results, and monitor software quality metrics
    • Requirements Toolbox – Link requirements to MATLAB code and tests; formalize and validate requirements
    • Risk Management Toolbox – Perform lifetime expected credit loss (ECL) computations at the individual asset or portfolio level
    • Robotics System Toolbox – Construct cuboid scenarios and simulate sensor readings for robotics applications
    • Signal Processing Toolbox – AI workflows: pre-process, extract features, and label signals
    • Simulink Check – Author custom edit-time checks and justify Model Advisor violations
    • Simulink Real-Time – Linux platform support for development computer

 
 

Release Details by Product

MATLAB Product Family

MATLAB
    • 3 New Apps: Data Cleaner, Hardware Manager, Code Compatibility Analyzer
    • Use new pcode file format with stronger obfuscation
    • Python: Use simpler keyword passing with name=value syntax, and editor support for Python code
    • Graphics: Create animated GIF files; pass tables directly to plot, plot3, polarplot, and other line plotting functions
    • App Building: Create custom UI components with App Designer
    • Live Editor: Develop your own Live Editor tasks
    • N-D Array Math: tensorprod, pagemldivide, pagemrdivide, and pageinv
    • Parquet Files: Use conditional filtering (Predicate Pushdown) with rowfilter; support for reading and writing of row groups and nested data structures

     

    AI, Data Science, and Statistics

    Deep Learning Toolbox

      • Model Pruning: Create compressed version of models that consumes less computational resources
      • MATLAB Deep Learning Model Hub: Discover and use pre-trained deep learning models
      • Deployment of Imported Models: Generate code for additional Keras and ONNX built-in layers
      • Experiment Manager Batch Experiments: Run multiple experiments simultaneously on a remote cluster (requires MATLAB Parallel Server)
      • 1D Convolutional Networks: Create and train networks with 1D transposed convolution for sequence and time series data

       
      Statistics and Machine Learning Toolbox

        • Machine Learning Apps: Save and resume sessions, rank and select features by importance, and reserve data for testing
        • Incremental Machine Learning: Perform drift detection on streaming data; train kernel and multi-class linear models
        • Deployment: Generate C/C++ code for inference with shallow neural nets
        • Simulink: Simulink block for Gaussian process regression

         
        Curve Fitting Toolbox

          • Curve Fitter app: Use new toolstrip design for improved usability; select fitting and validation data from MATLAB table data types

           

          Control Systems

          Model Predictive Control Toolbox

            • MISRA C 2012: Implement MISRA C:2012-compliant controllers with linear MPC and ADAS blocks in Simulink

             

            System Identification Toolbox

              • Nonlinear System Identification: Create Hammerstein-Wiener models that use regression functions based on machine learning algorithms

               

              Simulink Design Optimization

                • Surrogate Optimization Solver in Response Optimizer and Parameter Estimator Apps: Speed up time-consuming optimization problems

                 

                Reinforcement Learning Toolbox

                  • Model-Based Policy Optimization Agent: Use a model of the environment to improve sample efficiency and exploration
                  • Multi-Agent Reinforcement Learning: Train multiple agents in a centralized manner for more efficient exploration and learning

                   

                  Predictive Maintenance Toolbox

                    • Deployment: Generate C/C++ code for RUL similarity models, rotating machinery metrics, and nonlinear signal features
                    • Diagnostic Feature Designer: Extract stationary time series features from signal data

                     

                    Math and Optimization

                    Optimization Toolbox

                      • Problem-Based Optimize Live Editor Task: Solve optimization problems and systems of equations using a visual interface

                       

                      Global Optimization Toolbox

                        • Problem-Based Optimize Live Editor Task: Solve global and multiobjective optimization problems using a visual interface

                         

                        Symbolic Math Toolbox

                          • Symbolic Matrix Functions: Perform parameter-dependent linear algebra calculations in compact matrix notation

                           

                          Partial Differential Equation Toolbox

                            • Electromagnetic Analysis: Solve time-harmonic wave scattering and transmission problems using a finite element method
                            • Thermal Reduced Order Models: Approximate dynamic characteristics of a thermal model for faster execution (e.g., for batteries and CPUs)

                             

                            Application Deployment

                            MATLAB Compiler SDK

                              • Microservice Integration: Create a microservice Docker image using the compiler.package.microserviceDockerImage function

                               

                              MATLAB Production Server

                                • Web Request Handlers: Support for custom URL routes and request payloads

                                 

                                Code Generation

                                AUTOSAR Blockset

                                  • Adaptive AUTOSAR: Use ara::com methods and ara::com with service-oriented communication support events Classic AUTOSAR: Simulate basic software component event failure and recovery, including Release 19-11

                                   

                                  DDS Blockset

                                    • Support for RTI Connext Micro communication middleware

                                     

                                    Fixed-Point Designer

                                  • Estimate design costs of data memory consumption and operator counts in generated code

                                   

                                  MATLAB Coder and GPU Coder

                                    • Generate generic C/C++ code for more deep learning layers
                                    • Improve performance for deep learning network layers, including SIMD
                                    • Support for additional TensorFlow-Keras and ONNX built-in layers
                                    • Incorporate pretrained TensorFlow Lite models for simulation and code generation

                                     

                                    Simulink Coder

                                      • Specify tunable parameters for protected models

                                       

                                      Embedded Coder

                                        • Use deployment types to simplify configuration of top and reference model interfaces
                                        • Improve compliance for MISRA C:2012, MISRA C++:2008, and AUTOSAR C++14
                                        • Generate SIMD code for reduction, bitwise, and shift operations
                                        • Profile stack usage to assess memory consumption

                                         
                                         

                                        Simulink Product Family

                                        Simulink

                                          • Streamline masking workflows with new mask editor
                                          • Integrate custom C++ class with C Function block
                                          • Improve simulation performance by using local solvers in referenced models
                                          • Simulink Fundamentals training course

                                           

                                          Simulink Compiler

                                            • App Creation: Generate a configurable MATLAB UI from a Simulink model without writing code
                                            • FMU Export: Package files and folders as well as protected models into a standalone FMU

                                             

                                            Simulink Report Generator

                                              • Summarize Simulink model contents in a table object
                                              • Include user notes in web views

                                               
                                               

                                              Event-Based Modeling

                                              Stateflow

                                                • Integration of Stateflow breakpoints in the Simulink Breakpoints List pane
                                                • Improved workflows in creating atomic subcharts with entry and exit junctions>
                                                • String datatypes now supported in State Transition Table and Truth Table blocks

                                                 

                                                Physical Modeling

                                                Simscape Electrical

                                                  • Model hydrogen production with new Electrolyzer block
                                                  • Parameterize solar panels by selecting from more than 250 manufacturer-specific datasets
                                                  • Expanded motor library and features, including switched-reluctance machines, PMSM , and detailed iron losses

                                                   

                                                  Real-Time Simulation and Testing

                                                  Simulink Real-Time

                                                    • Install and use Simulink Real-Time on Linux development computers
                                                    • Automatically create an App Designer instrument panel from a model or real-time application
                                                    • Improved test automation with third-party tools with ASAM XIL API classes and methods for MAPort read/write, SignalFactory, SignalGeneratorFactory, and SignalGenerator

                                                     

                                                    Systems Engineering

                                                    System Composer

                                                      • Client-Server Interfaces: Model distributed software service architectures
                                                      • Use subsystem references to add reusable Simulink and Simscape behaviors to components
                                                      • Compare two versions of an architecture model using the Comparison Tool

                                                       

                                                      Verification, Validation, and Test

                                                      Requirements Toolbox

                                                        • Author, link, and validate requirements within MATLAB
                                                        • Trace requirements for test cases created in MATLAB Unit Test
                                                        • Formalize requirements with logical expressions using the Requirements Table block
                                                        • Track requirements impacted by changes in test cases

                                                         

                                                        Simulink Check

                                                          • Author custom checks that run at edit-time
                                                          • Justify and hide check violations
                                                          • Include System Composer models in the Model Testing Dashboard artifact hierarchy
                                                          • Refactor similar clones anywhere in the model
                                                          • Debug equivalence test failures using Model Slicer

                                                           

                                                          Simulink Test

                                                            • New logical and temporal assessment functions and classes
                                                            • Observer support for messages

                                                             

                                                            Simulink Design Verifier

                                                              • Analyze requirements authored in a Requirements Table to check for consistency and completeness

                                                               

                                                              Signal Processing

                                                              Signal Processing Toolbox

                                                                • AI Workflows: Preprocess, extract features, and label signals
                                                                • Generate C/C++ code for more than 200 toolbox functions
                                                                • GPU support for feature extraction, spectral analysis, spectral measurements, and transforms

                                                                 

                                                                DSP Toolbox

                                                                  • Spectrum Analyzer with better responsiveness and toolstrip interface for analysis, estimation, and measurement parameters

                                                                   

                                                                  Wavelet Toolbox

                                                                    • Visualize scalogram with Wavelet Time-Frequency Analyzer app

                                                                     

                                                                    Audio Toolbox

                                                                      • New examples for AI, room acoustics, and electroacoustic modeling

                                                                       

                                                                      Radar

                                                                      Radar Toolbox

                                                                        • Model land and sea surface clutter and reflectivity

                                                                         

                                                                        Mapping Toolbox

                                                                          • Create custom basemaps for offline use
                                                                          • Capture image from basemap with georeferencing information

                                                                           

                                                                          Image Processing and Computer Vision

                                                                          Computer Vision Toolbox

                                                                            • New image data type for image processing and computer vision in Simulink

                                                                             

                                                                            Lidar Toolbox

                                                                              • Lidar Sensor Model: Simulate lidar sensors and generate point cloud data

                                                                               

                                                                              FPGA, ASIC, and SoC Development

                                                                              HDL Coder

                                                                                • Generate IP core for Xilinx Versal devices
                                                                                • Use reference design workflow for Microsemi Libero SoC

                                                                                 

                                                                                Deep Learning HDL Toolbox

                                                                                  • Network custom layer creation, registration, validation, and deployment

                                                                                   

                                                                                  DSP HDL Toolbox

                                                                                    • New Product: Model hardware implementations of DSP algorithms and generate HDL (using HDL Coder)

                                                                                     

                                                                                    Vision HDL Toolbox

                                                                                      • Support multipixel per clock for Histogram and Bilateral Filter blocks

                                                                                       

                                                                                      Wireless HDL Toolbox

                                                                                        • Use DVB-S2 receiver reference application

                                                                                         

                                                                                        HDL Verifier

                                                                                          • Use Vivado simulator for cosimulating an HDL design with a Simulink or MATLAB test bench
                                                                                          • Use hardware buffering to improve FPGA-in-the-loop simulation performance

                                                                                           

                                                                                          Test and Measurement

                                                                                          Industrial Communication Toolbox

                                                                                            • New Product: Exchange data over OPC UA, Modbus, MQTT, and other industrial protocols
                                                                                            • Access plant and manufacturing data directly from OSIsoft PI servers

                                                                                             

                                                                                            Data Acquisition Toolbox

                                                                                              • TDMS File Support: Read data from an individual NI TDMS format file or use datastore to read a collection of TDMS files

                                                                                               

                                                                                              Instrument Control Toolbox

                                                                                                • UDP Explorer App: Create a UDP socket and communicate over networks using UDP protocolNew Instrument Driver Interface: Connect to instruments using IVI and VXIplug&play drivers

                                                                                                 

                                                                                                Vehicle Network Toolbox

                                                                                                  • MDF File Support: Create MDF files and write to MDF files directly from MATLAB

                                                                                                   

                                                                                                  Image Acquisition Toolbox

                                                                                                    • Image Acquisition Explorer App: Preview live video data from your image acquisition hardware and configure device-specific properties and acquisition settings

                                                                                                     

                                                                                                    Wireless Communications

                                                                                                    Communications Toolbox

                                                                                                      • Wireless Communications Onramp: Learn the basics of simulating a wireless communications link in MATLAB

                                                                                                       

                                                                                                      Bluetooth Toolbox

                                                                                                        • New Product: Simulate, analyze, and test Bluetooth communications systems

                                                                                                         

                                                                                                        Wireless Testbench

                                                                                                          • New Product: Explore and test wireless reference applications in real time on SDR hardware

                                                                                                           

                                                                                                          Autonomous Systems,

                                                                                                          Automated Driving Toolbox

                                                                                                            • Cosimulate scenarios in RoadRunner with actors modeled in MATLAB and Simulink

                                                                                                             

                                                                                                            Robotics System Toolbox

                                                                                                              • Robot Scenarios and Sensor Models: Construct cuboid scenario and simulate sensor readings for robotics applications
                                                                                                              • Inverse Kinematics Designer App: Visualize and tune inverse kinematics solvers and create configurations

                                                                                                               

                                                                                                              UAV Toolbox

                                                                                                                • Hardware in the Loop: Enable hardware-in-the-loop (HIL) simulation with Pixhawk Autopilot and Simulink plant model
                                                                                                                • UAV Scenario Designer App: Design and visualize UAV simulation scenarios interactively

                                                                                                                 

                                                                                                                RoadRunner Scenario

                                                                                                                  • New Product: Create and play back scenarios for automated driving simulation

                                                                                                                   

                                                                                                                  Aerospace

                                                                                                                  Aerospace Blockset

                                                                                                                    • 3D Simulation: Supports custom meshes and aircraft lighting in Simulation 3D Aircraft block

                                                                                                                     

                                                                                                                    Computational Finance

                                                                                                                    Financial Instruments Toolbox

                                                                                                                      • Instrument Pricing: Model trinomial trees with finprice
                                                                                                                      • Equity Instruments: Calculate rates and pricing for commodity futures, equity index futures, and FX futures
                                                                                                                      • Live Task: Calibrate an option pricing model interactively

                                                                                                                       

                                                                                                                      Econometrics Toolbox

                                                                                                                        • Conduct cointegration tests and fit multivariate time series models interactively in the Econometrics Modeler app
                                                                                                                        • Bayesian State-Space Models: Analyze posterior distributions of random parameters in multivariate linear state-space models

                                                                                                                         

                                                                                                                        Risk Management Toolbox

                                                                                                                          • Lifetime Credit Risk Analysis: Calculate lifetime expected credit loss
                                                                                                                          • Fairness in Credit Scoring Example: Calculate fairness metrics and detect bias at the data and model level

                                                                                                                           

                                                                                                                          Financial Toolbox

                                                                                                                            • Perform Quasi-Monte Carlo simulation
                                                                                                                            • Portfolio Management: Manage a risk parity portfolio
                                                                                                                            • Backtesting Framework Example: Backtest with deep learning strategies

                                                                                                                             

                                                                                                                            Code Verification

                                                                                                                            Polyspace Access

                                                                                                                              • New web dashboard for improved user experience
                                                                                                                              • Manage Polyspace Access projects programmatically
                                                                                                                              • Visual Studio Code plug-in with new views for configuration, results, baseline, and mass findings justification

                                                                                                                               

                                                                                                                              Polyspace Bug Finder and Polyspace Bug Finder Server

                                                                                                                                • Improve analysis time by using incremental compilation
                                                                                                                                • Support 1,216 C/C++, MISRA C++, CERT-C++, CWE, and AUTOSAR C++ rules with 46 new checks

                                                                                                                                 

                                                                                                                                Automotive

                                                                                                                                AUTOSAR Blockset

                                                                                                                                  • Adaptive AUTOSAR: Use ara::com methods and ara::com events with service-oriented communication support
                                                                                                                                  • Classic AUTOSAR: Simulate basic software component event failure and recovery, including Release 19-11

                                                                                                                                   

                                                                                                                                  Model-Based Calibration Toolbox

                                                                                                                                    • Battery Calibration: Characterize an Equivalent Circuit Battery
                                                                                                                                    • Transient Calibration: Get faster optimization for Simulink models with first-order transient systems

                                                                                                                                     

                                                                                                                                    Powertrain Blockset

                                                                                                                                      • Use Virtual Vehicle Composer app to configure and build full vehicle models, including component sizing, fuel economy, and drive cycle tracking
                                                                                                                                      • Motor Dynamometer Reference Application: Resize and evaluate electric motors and controllers

                                                                                                                                       

                                                                                                                                      Vehicle Dynamics Blockset

                                                                                                                                        • Use Virtual Vehicle Composer app to configure and build full vehicle models, including ride-handling analysis and Unreal Engine visualization
                                                                                                                                        • Use suspension blocks to implement kinematics and compliance test characteristics

                                                                                                                                         

QUICK ENQUIRY