Embedded Coder® Support Package for ARM® Cortex®-R Processors lets you generate, execute, and verify code from MATLAB® and Simulink® on ARM Cortex-R based processors. Support for select real-time operating systems, compiler toolchains, and hardware boards is included. This support package is functional for R2016b and beyond. If you have download or installation issues, please contact Technical Support: www.mathworks.com/contact_ts
Embedded Coder® Support Package for ARM® Cortex®-M Fast Models enables the use of virtual platforms as a hardware target in PIL and External Mode simulations. This package currently supports the Cortex-M family of Arm CPUs, including the following cores: - Arm Cortex-M0+- Arm Cortex-M0- Arm Cortex-M1- Arm Cortex-M3- Arm Cortex-M4 - Arm Cortex-M7For information on how to obtain Arm Fast Models, see the Support Package documentation. To enable Arm Compiler as a toolchain in Embedded Coder, see the Arm Compiler Support Package for Embedded Coder.
DSP System Toolbox™ Support Package for ARM® Cortex®-A Processors with NEON™ technology provides optimization for the Ne10 library when generating code with Embedded Coder® for ARM Cortex-A processors.This support package is functional for R2014b and beyond.
Embedded Coder® Support Package for ARM® Cortex®-A Processors lets you generate NEON™ optimized code for math operations using the Ne10 Library. Use this generated code for ARM Cortex-A processors. For DSP filter support, use the ARM Cortex A Ne10 Library Support from DSP System Toolbox™.This support package is functional for R2014a and beyond.If you have download or installation issues, please contact Technical Support: www.mathworks.com/contact_ts
Embedded Coder® Support Package for ARM® Cortex®-M Processors lets you generate optimized code for math operations using the CMSIS library. Use this generated code for ARM Cortex-M processors. For DSP filter support, use ARM Cortex-M CMSIS Library Support from DSP System Toolbox™.This support package is functional for R2013b and beyond.If you have download or installation issues, please contact Technical Support: www.mathworks.com/contact_tsNote for Linux users:This support package downloads and uses the GNU Tools for ARM Processors third-party application. This 32-bit embedded application requires the libc6-i386 package to run on a 64-bit Linux platform. Without the libc6-i386 package, compilation of MathWorks generated code fails. To install the libc6-i386 package on Ubuntu and Debian, type this example command in the Linux terminal: sudo apt-get install libc6:i386MATLAB R2018b and later versions are unaffected.
QEMU is an emulator and virtualization machine that allows you to run a cross-platform application on your computer. You can use QEMU emulator for verification and validation of the generated code for ARM Cortex-M or ARM Cortex-A hardware processor platforms using Embedded Coder® Support Package for ARM® Cortex®-M Processors or Embedded Coder® Support Package for ARM® Cortex®-A Processors on your computer without the need of the actual ARM Cortex-M or ARM Cortex-A based processor.The Embedded Coder Interface to QEMU emulator is available as add-on. It deploys the generated application on the QEMU emulator. However, this add-on does not support any code generation.The installer file for Embedded Coder® Interface to QEMU Emulator works only when you have installed either Embedded Coder Support Package for ARM Cortex-M Processors or Embedded Coder Support Package for ARM Cortex-A ProcessorsFor more details on how to install the Embedded Coder Interface to QEMU Emulator add-on, please visit: http://www.mathworks.com/help/supportpkg/armcortexm/ref/getqemuemulatoraddon.html?searchHighlight=QEMU This .mlpkginstall file is functional for R2016a and beyond.If you have download or installation issues, please contact Technical Support: www.mathworks.com/contact_ts
DSP System Toolbox™ Support Package for ARM® Cortex®-M Processors, when paired with Embedded Coder®, enables you to generate optimized C code from MATLAB® System objects™ or Simulink® blocks. This is done for ARM Cortex-M processor-based systems using the Cortex Microcontroller Software Interface Standard (CMSIS) DSP library.This support package is functional for R2013b and beyond.
Simulink® Coder™ Support Package for ARM® Cortex®-based VEX® Microcontroller enables you to create and run Simulink® models on a VEX microcontroller. The support package includes a library of Simulink blocks for configuring and accessing VEX peripherals, and it has student-competition specific blocks.This support package is functional for R2014a and beyond.----------------------** Not supported on newer versions of macOS*** Supported on Windows and Mac versions up to 10.10Note (R2021a users):Simulink models may fail to build with the following error in R2021a.Error Report: Command "codertarget.vexarmcortex.internal.addCompilerPath();" threw an error: Unable to resolve the name matlabshared.toolchain.gnu_gcc_arm.getGnuArmToolsDir.Kindly update the support package to the latest version to resolve this issue.If you have download or installation issues, please contact Technical Support: www.mathworks.com/contact_ts
Embedded Coder® Support Package for ARM® Compiler enables the use of Arm Compiler 5 and 6 with Embedded Coder. All Arm Cores are supported by this package.For information on how to obtain Arm Compiler, see the Support Package documentation. To enable Arm Fast Models for use as a virtual target in Embedded Coder for simplified simulations, see the Arm Cortex-M Fast Model Support Package for Embedded Coder.
Models a robot arm with 5 degrees of freedom and a gripper, along with two conveyor belts. The robot transfers parts from one conveyor belt to the other. One conveyor belt brings the parts to the robot arm, and the other belt transports the parts away from the robot arm. The model includes electrical actuation, supervisory logic, and optimization of end effector trajectory. Please read the README.md file to get started.Use the "Download" button above to get files compatible with the latest release of MATLAB.You can also test this example in MATLAB Online.Use the links below to get files compatible with earlier releases of MATLAB.For R2023b: Use Download button above For R2023a: https://github.com/mathworks/Simscape-Robot-Conveyor-Belts/archive/23.1.2.5.zipFor R2022b: https://github.com/mathworks/Simscape-Robot-Conveyor-Belts/archive/22.2.2.5.zipFor R2022a: https://github.com/mathworks/Simscape-Robot-Conveyor-Belts/archive/22.1.2.5.zipFor R2021b: https://github.com/mathworks/Simscape-Robot-Conveyor-Belts/archive/21.2.2.4.zipFor R2021a: https://github.com/mathworks/Simscape-Robot-Conveyor-Belts/archive/21.1.2.3.zipFor R2020b: https://github.com/mathworks/Simscape-Robot-Conveyor-Belts/archive/20.2.2.2.zipFor R2020a: https://github.com/mathworks/Simscape-Robot-Conveyor-Belts/archive/20.1.2.1.zipFor R2019b: https://github.com/mathworks/Simscape-Robot-Conveyor-Belts/archive/19.2.2.0.zipFor R2019a: https://github.com/mathworks/Simscape-Robot-Conveyor-Belts/archive/19.1.1.5.zipFor R2018b: https://github.com/mathworks/Simscape-Robot-Conveyor-Belts/archive/18.2.1.4.zipFor R2018a: https://github.com/mathworks/Simscape-Robot-Conveyor-Belts/archive/18.1.1.3.zipFor R2017b: https://github.com/mathworks/Simscape-Robot-Conveyor-Belts/archive/17.2.1.2.zipFor R2017a: https://github.com/mathworks/Simscape-Robot-Conveyor-Belts/archive/17.1.1.1.zipFor R2016b: https://github.com/mathworks/Simscape-Robot-Conveyor-Belts/archive/16.2.1.0.zipThe robot arm model was created in Onshape and imported into Simscape Multibody. Visit this File Exchange entry to learn more about Onshape https://www.mathworks.com/products/simmechanics/onshape.htmlTry these free, hands-on tutorials to learn how to use Simscape:https://www.mathworks.com/learn/tutorials/simscape-onramp.htmlhttps://www.mathworks.com/learn/tutorials/circuit-simulation-onramp.htmlFind other Simscape examples by searching posts for the keyword "physical modeling" https://www.mathworks.com/matlabcentral/fileexchange/?term=%22physical+modeling%22Learn more about MathWorks Simscape Products: https://www.mathworks.com/physical-modeling/
MinGW-w64 is a compiler suite for Windows based on the GNU tool chain. It includes a GCC compiler and related tools for compiling C and C++ applications for Windows. C and C++ applications compiled with MinGW-w64 GCC can be called from MATLAB using MEX. This GCC compiler can also be helpful for other MathWorks products that require a C or C++ compiler. R2023b and later: MinGW 6.3 must be configured manually. MinGW 6.3 can be downloaded from here. R2023a: MinGW 8.1 must be configured manually. MinGW 8.1 can be downloaded from here. Follow instructions on this page to configure MinGW 6.3 or 8.1 as a MEX compiler. FAQ: This link provides answers to some frequently asked questions.https://www.mathworks.com/matlabcentral/answers/311290-faq-how-do-i-install-the-mingw-compiler#answer_242526?s_tid=prof_contriblnkSee additional information on installing this compiler at: http://www.mathworks.com/help/matlab/matlab_external/install-mingw-support-package.html Learn more about other compilers supported by MathWorks Products at: https://www.mathworks.com/support/requirements/supported-compilers.htmlIf you are having difficulty installing, please contact Technical Support or see MATLAB Answers: https://www.mathworks.com/support/contact_us.html https://www.mathworks.com/matlabcentral/answers/?term=mingw
A COM based interface that allows you to call R functions from within MATLAB. The functions are:openR - Connect to an R server process.evalR - Run an R command.getRdata - Copies an R variable to MATLAB.putRdata - Copies MATLAB data to an R variable.closeR - Close connection to R server process.Rdemo - An example of using R from withing MATLAB.
Embedded Coder® Support Package for Intel® SoC Platform supports ANSI® C code generation for the ARM® portion of the Intel SoC. When used in combination with the HDL Coder™ Support Package for Intel SoC Platform, this solution can program the Intel SoC using C and HDL code generation. The hardware/software codesign workflow spans simulation, prototyping, verification, and implementation.This support package is functional for R2014b and beyond.If you have download or installation issues, please contact Technical Support: www.mathworks.com/contact_ts
The BeagleBoard (https://beagleboard.org/) is a low-cost, single-board computer designed for audio, video, and digital signal processing.With R2012a, Simulink provides built-in support for prototyping, testing, and running models on the BeagleBoard. You can design algorithms in Simulink for audio processing and computer vision applications then see them perform with hardware.To install support for the BeagleBoard, at the R2012a MATLAB command prompt, type "targetinstaller". Target Installer opens.• If you did not download the support package, choose Internet. Target Installer automatically downloads and installs the support package.• If you did download the support package, choose Folder. After you specify a location, Target Installer installs the support package.Simulink Support Package for BeagleBoard Hardware includes the following driver blocks: • Video Input and Display• Audio Input and Output• UDP Send and Receive--------------------- This FileExchange entry is for R2012a support.For R2012b support, see:www.mathworks.com/matlabcentral/fileexchange/37897For R2013a and beyond, see:www.mathworks.com/matlabcentral/fileexchange/40310For more information on built-in Simulink hardware support, see:http://www.mathworks.com/discovery/simulink-embedded-hardware.html---------------------
The DSP System Toolbox™ Support Package for ARM® Cortex®-M Processors, when paired with EmbeddedCoder®, enables you to generate optimized C code from MATLAB® System objects™ or Simulink® blocks.This is done for ARM Cortex-M processor-based systems using the Cortex Microcontroller SoftwareInterface Standard (CMSIS) library. Benefits include an immediate increase in performance whencompared to standard C code generation.The generated code optimization is provided via Code Replacement Library (CRL) for CMSIS functions,including math operations such as abs, add, sub and mult, and DSP algorithms such as FIR, FFT and IFFT .The CRL for CMSIS is supported in both Simulink-to-C and MATLAB-to-C workflows on all MathWorkssupported hardware platforms. As an example of MATLAB-to-C workflow, the white paper illustrates how to port the generated C code from MATLAB (R2014b) to IAR Embedded Workbench®.
In this example, we have a Simulink model based on the shallow network with five layers described in Loren’s blog below for image classification using MNIST data:https://blogs.mathworks.com/loren/2015/08/04/artificial-neural-networks-for-beginners/We have three versions of the model – in double precision, single precision and a fixed-point version. These models can then be tested using live data from an Arduino Due using the Simulink® Support Package for Arduino® Hardware and deployed to the Arduino board as a standalone application.The single precision and fixed-point versions were generated using Fixed-Point Designer as described in the links below. The fixed-point model uses no more than 16 bits and the accuracy of the model is above 94%.https://www.youtube.com/watch?v=sxSodI0pwPwhttps://www.youtube.com/watch?v=zX44UvyLeAchttps://www.youtube.com/watch?v=nkZAB7LIRXI&t=12s
An updated version of Pplane that works on Matlab R2018b.Copyright to John C Polking, Rice University, 2003 for original version.Updated by Hugh Harvey and George Williams, University of Bristol, 2016.
halfprecision converts the input argument to/from a half precision floating point bit pattern corresponding to IEEE 754r. The bit pattern is stored in a uint16 class variable. Please note that halfprecision is *not* a class. That is, you cannot do any arithmetic with the half precision bit patterns. halfprecision is simply a function that converts the IEEE 754r half precision bit pattern to/from other numeric MATLAB variables, and performs various tests on the bit patterns (isinf, isnan, eps, etc.).The half precision bit pattern is as follows: 1 bit sign bit 5 bits exponent, biased by 15 10 bits mantissa, hidden leading bit, normalized to 1.0 Special floating point bit patterns recognized and supported: All exponent bits zero: - If all mantissa bits are zero, then number is zero (possibly signed) - Otherwise, number is a denormalized bit pattern (leading bit is present) All exponent bits set to 1: - If all mantissa bits are zero, then number is +Infinity or -Infinity - Otherwise, number is NaN (Not a Number)More details of this floating point format can be found here: http://en.wikipedia.org/wiki/Half_precision Building: halfprecision requires that a mex routine be built (one time only). This process is typically self-building the first time you call the function as long as you have the files halfprecision.m and halfprecision.c in the same directory somewhere on the MATLAB path. If you need to manually build the mex function, see the documentation in halfprecision.m for instructions on building the mex routine. Syntax B = halfprecision(A) C = halfprecision(B,classname or function) L = halfprecision(directive) halfprecision(B,'disp') Description A = a MATLAB numeric array, char array, or logical array. B = the variable A converted into half precision floating point bit pattern. The bit pattern will be returned as a uint16 class variable. The values displayed are simply the bit pattern interpreted as if it were an unsigned 16-bit integer. To see the halfprecision values, use the 'disp' option, which simply converts the bit patterns into a single class and then displays them. C = the half precision floating point bit pattern in B converted into class S. B must be a uint16 or int16 class variable. classname = char string naming the desired class (e.g., 'single', 'int32', etc.) function = char string giving one of the following functions: 'isinf' = returns a logical variable, true where B is inf 'isnan' = returns a logical variable, true where B is nan 'isnormal' = returns a logical variable, true where B is normalized 'isdenormal' = returns a logical variable, true where B is denormalized 'eps' = returns eps of the half precision values directive = char string giving one of the following directives: 'openmp' = returns a logical variable, true when compiled with OpenMP 'realmax' = returns max half precision value 'realmin' = returns min half precision normalized value 'realmindenormal' = returns min half precision denormalized value 'version' = returns a string with compilation memory model 'disp' = The floating point bit values are simply displayed. Examples >> a = [-inf -1e30 -1.2 NaN 1.2 1e30 inf] a = 1.0e+030 * -Inf -1.0000 -0.0000 NaN 0.0000 1.0000 Inf >> b = halfprecision(a) b = 64512 64512 48333 65024 15565 31744 31744 >> halfprecision(b,'disp') -Inf -Inf -1.2002 NaN 1.2002 Inf Inf >> halfprecision(b,'double') ans = -Inf -Inf -1.2002 NaN 1.2002 Inf Inf >> 2^(-24) ans = 5.9605e-008 >> halfprecision(ans) ans = 1 >> halfprecision(ans,'disp') 5.9605e-008 >> 2^(-25) ans = 2.9802e-008 >> halfprecision(ans) ans = 1 >> halfprecision(ans,'disp') 5.9605e-008 >> 2^(-26) ans = 1.4901e-008 >> halfprecision(ans) ans = 0 >> halfprecision(ans,'disp') 0 Note that the special cases of -Inf, +Inf, and NaN are handled correctly. Also, note that the -1e30 and 1e30 values overflow the half precision format and are converted into half precision -Inf and +Inf values, and stay that way when they are converted back into doubles. Caveat: I have only tested this code on a PC, which is Little Endian. I put in code to handle Big Endian machines, but I do not have a way to test it, so I can't say for sure that it will work properly. Let me know if you have problems.
solving of inverse kinematics and model of arm robot
In this example we illustrate a MATLAB and Simulink workflow on how to train and deploy a machine learning model to a low-power microcontroller on the edge. We demonstrate how to train a shallow neural network for a regression problem, how to generate readable single precision floating point or Fixed-point code and how to deploy to an ARM cortex M microcontroller such as an Arduino Uno. We use the engine dataset for estimating engine emission levels based on measurements of fuel consumption and speed. This is a regression problem and we use a shallow neural network to model the system. The download contains the example dataset, the trained model exported as a MATLAB function and an equivalent Simulink model and a detailed article explaining the workflow steps. It also contains all the required scripts to automate some of the tasks.
MATLAB Graphics Updater Update your code to work with the MATLAB graphics changes in R2014b. The MATLAB Graphics Updater app checks MATLAB files for code that requires updating in order to work with the MATLAB graphics changes introduced in R2014b. It produces an interactive HTML report with a list of possible issues, help dialogs with descriptions of the issues, and the recommended solutions. For some issues, the app can automatically replace the current code with the recommended solution.Missing Graphics FinderAnalyze MATLAB figures for missing graphics objects.The Missing Graphics Finder app detects when graphics objects are obscured behind uipanels within a figure. The app analyzes all open MATLAB figures and apps and generates a list of objects that are hidden behind panels. To fix them, set the uipanel as the parent of the hidden graphics object. This fix is compatible with previous versions of MATLAB.
This example shows how to define a two-link planar robot arm with symbolic variables, and compute the forward and inverse kinematics. The example also visualizes the results with contour plots. Further, it shows how to calculate the system Jacobian and use it further in a Simulink model. The Simulink model uses the inverse kinematics equations and the system Jacobian to simulate the robot to make it write or draw the word 'hello'.
NXT SCARA is a two-link planar robot arm built with LEGO Mindstorms NXT. SCARA stands for Selective Compliant Assembly Robot Arm. Please refer the following URL to know more detailed information about SCARA.http://en.wikipedia.org/wiki/SCARAThis demo presents sample models and documents describe the following contents. How to Build NXT SCARAGeometric Model and Inverse KinematicsTrajectory MakingController Design for Tracking ControlNXT SCARA Model IllustrationSimulation and Experimental Results You can simulate NXT SCARA model and generate controller program that can be executed on the NXT. Furthermore, you can watch movies of NXT SCARA simulation and control experiment at the following URL.http://www.youtube.com/watch?v=kanmZErt4iohttp://www.youtube.com/watch?v=7F2H19teyMYThis demo requires Embedded Coder Robot NXT Demo as MBD environment. You need to download it from the following URL before trying this demo.http://www.mathworks.com/matlabcentral/fileexchange/13399 LEGO(R) is a trademark of the LEGO Group of companies which does not sponsor, authorize or endorse this demo. LEGO(R) and Mindstorms(R) are registered trademarks of The LEGO Group.
This projects aims to develop a robotic arm, which can replicate the arm movement of a human operator. The human operator arm gestures are acquired from the Kinect’s depth image using skeletal tracking applications. Then, this arm gestures are used to calculate the angular position of each joints in the robotic arm using laws of cosines (Ref: http://www.terecop.eu/TRTWR-RIE2014/files/00_WFr1/00_WFr1_10.pdf). This angular position is calibrated into the corresponding commands applied to each of the joints. Please refer the video demonstration of the project: https://www.youtube.com/watch?v=UJ1d0Z1D104 Hardware Requirements:1. Robotis Bioloid Premium Humanoid (CM-530) (Ref: http://support.robotis.com/en/product/bioloid/bioloid_prem_main.htm)2. Microsoft Kinect Xbox 360 (Ref: http://support.xbox.com/en-GB/xbox-360/accessories/kinect-sensor-setup)Software Requirements:1. Bioloid Toolbox for MATLAB (Ref: http://incognite.felk.cvut.cz/index.php?page=projects/bioloid&cat=projects)2. Kinect SDK (Ref: https://www.microsoft.com/en-in/download/details.aspx?id=40278)3. MATLAB R2013
Compute coefficient of determination of data fit model and RMSE [r2 rmse] = rsquare(y,f) [r2 rmse] = rsquare(y,f,c) RSQUARE computes the coefficient of determination (R-square) value from actual data Y and model data F. The code uses a general version of R-square, based on comparing the variability of the estimation errors with the variability of the original values. RSQUARE also outputs the root mean squared error (RMSE) for the user's convenience. Note: RSQUARE ignores comparisons involving NaN values. INPUTS Y : Actual data F : Model fit OPTION C : Constant term in model R-square may be a questionable measure of fit when no constant term is included in the model. [DEFAULT] TRUE : Use traditional R-square computation FALSE : Uses alternate R-square computation for model without constant term [R2 = 1 - NORM(Y-F)/NORM(Y)] OUTPUT R2 : Coefficient of determination RMSE : Root mean squared error EXAMPLE x = 0:0.1:10; y = 2.*x + 1 + randn(size(x)); p = polyfit(x,y,1); f = polyval(p,x); [r2 rmse] = rsquare(y,f); figure; plot(x,y,'b-'); hold on; plot(x,f,'r-'); title(strcat(['R2 = ' num2str(r2) '; RMSE = ' num2str(rmse)])) Jered R Wells 11/17/11 jered [dot] wells [at] duke [dot] edu v1.2 (02/14/2012) Thanks to John D'Errico for useful comments and insight which has helped to improve this code. His code POLYFITN was consulted in the inclusion of the C-option (REF. File ID: #34765).
open and run SMART_GUI.m in the matlab Files folder. Follow the directions in the Messages box. The program can simulate only articulated robots, with indefinite number of degrees of freedom. A robot with six DOF is already configured but you can load your own robot with extension .STL and edit the parameters in the table that shows by pressing the button Edit Parameters in the Settings tab.In the first tab you can edit the program settings, in the second you will give commands to the robot. In the tab Programs you can create a list of commands to run automatically and in the last tab you can simulate the dynamical behavior of the robot.You can download the documentation of the program using the link provided in documentation file (in Portuguese only, in the future I will write in English).There are some functionalities that I could not implement in this version. Hopefully they will be released in the future.All suggestions for more features are welcome. If you found a problem please comment.
In this submission we model a small three-degrees of freedom(DOF) robotic arm which was purchased from www.roboholicmaniacs.com in MATLAB Simscape. The actuators used in this arm are stepper motors. The main inputs to this 3 DOF arm are the torque angles to these actuators which will output the x,y and z position of the end effector or the gripper. These codes are part of Chapter 3 in the book: "Digital Twin Development and Deployment on the Cloud" Elsevier, 2020, Nassim Khaled, Bibin Pattel and Affan Siddiqui
When building a complex GUI it is a common requirement to build a fullscreen interface. To preserve compatibility of GUIs between different OS, MATLAB is not natively aware of Windows specific desktop elements. Using the new docked figures may not be the right solution when the GUI is targeting MATLAB inexperienced users. Accurate figure maximization can only be achieved by interaction with Windows User32.dll APIs. Due to the large number of requests I received to update my to work in R14 environment, I hereby submit a new function for maximization of MATLAB figures. This is not just an update but also adds options to ignore the Windows TaskBar. Test function and complete mex C-code are included.AUGUST 2005 UPDATE.With SP2, the figure frame class has been changed in MATLAB R14. Due to the large number of emails I received I decided to post this quickfix of maxfig (formely known as ).
This function finds the forward kinematics of the RA-01 Robotic Arm made by Images SI, Inc., New York. The RA-01 has five degrees of freedom. This function outputs two vectors. The first vector is the forward kinematics of the central position of the end effector, while the second vector is the forward kinematics of a finger of the end effector (a gripper). Note that it does not matter which finger it is as the position of one finger is simply the negative of the other hence, the value gotten for the y-direction is actually "plus or minus y".
Through the MULTI Toolbox for Embedded Coder, the Simulink user easily generates and compiles optimized code with the industry-leading Green Hills Optimizing C/C++ Compilers and runs the compiled code through the MULTI® IDE on either its built-in instruction set simulator or on an embedded processor. Results and behavior of the code running in this Processor-In-the-Loop (PIL) manner can then be verified against Simulink’s simulated tests.After the program completes, the user can employ the complete set of features in the MULTI Integrated Development Environment (IDE), separately from Simulink, in various use cases such as:Multicore debugging, run control and analysis with the MULTI IDE and TimeMachine: - Multicore debugger with OS awareness for INTEGRITY RTOS, µ-velOSity RTOS, Linux and other operating systems - MISRA C Adherence Checker - Reverse-execution debugging with TimeMachine Suite - Run-time Error Detection & Memory Leak Detection - Code Coverage Analysis & Performance Profiler - DoubleCheck® Source Code Analyzer - Instruction set simulator for the processor core - Flash programming on embedded boardEmbed and run the code on the INTEGRITY® RTOS, µ-velOSity RTOS and other operating systemsCertified for safety-critical uses in Automotive (ISO 26262 ASIL D), Industrial (IEC 61508 SIL 3) and Railway (EN 50128 SIL 3) Features - Single core, single thread programs running “bare board”, that is, with no target operating system - Run-to-completion mode for PIL verification is implemented today. Interactive debugging and breakpoints are planned. - Processor architectures supported are Arm Cortex-A, Cortex-R, Cortex-M, Renesas RH850, RISC-V, Power PC, TriCore - Supports Linux and Windows host operating systemsProcessor SupportOn MULTI’s instruction set simulator - Cortex-A – ARM v8 (64 bit) and ARM v7 (32 bit) - Cortex-R – ARM v8 (32 bit) and ARM v7 (32 bit) - Cortex-M – ARM v7 (32 bit) - RH850 - RISC-V (32 bit and 64 bit) - Power Architecture - TriCoreOn Boards with Green Hills Probe - Renesas R-Car Starter Kit Premier (H3)Required Green Hills Products - MULTI IDE v6.1.4 (and newer) and Optimizing C/C++ Compilers - When running on a board, a Green Hills Probe V4 or Green Hills SuperTrace Probe is requiredRequired Products from MathWorks - MATLAB R2021A or later - Simulink - Embedded Coder - MATLAB Coder - Simulink Coder
MATLAB Coder generates C and C++ code from MATLAB code for a variety of hardware platforms, from desktop systems to embedded hardware. It supports most of the MATLAB language and a wide range of toolboxes, and you can deploy a variety of pretrained deep learning networks such as YOLOv2, ResNet-50, SqueezeNet, and MobileNet from Deep Learning Toolbox. You can generate optimized code for pre-processing and post-processing along with your trained deep learning networks to deploy complete applications.Supported deep learning networksWith MATLAB Coder or Simulink Coder, MATLAB Coder Interface for Deep Learning provides the ability to generate plain (library-free) C/C++ code for deep learning networks. Additionally, it provides the option to generate code that calls into the following target-specific, optimized libraries:Intel oneAPI Deep Neural Network Library (oneDNN, formerly MKL-DNN): For Intel CPUs that support AVX2ARM Compute Library: For ARM Cortex-A processors that support NEON instructionsWhen used in Simulink with Deep Learning Toolbox and without MATLAB Coder or Simulink Coder, you can accelerate simulations of Simulink models that include deep learning blocks using the Intel oneDNN optimization library.For more information on building supported optimization libraries, please see these links:MATLAB Coder: How do I build the Intel MKL-DNN library for Deep Learning C++ code generation and deployment?MATLAB Coder: How do I build the ARM Compute Library for Deep Learning C++ code generation and deployment?To learn more about the recommended settings for optimizing the inference perfomance of plain, library-free C/C++ code generated from deep learning networks, please see the below link:How can I optimize the performance of library-free C/C++ code generated from deep learning networks?This support package is functional for R2018b and beyond.If you have download or installation problems, please contact Technical Support - https://www.mathworks.com/support/contact_us.htmlhttps://www.youtube.com/watch?v=qhgIHKt_Wgk
The Nth Octave Hand Arm and AC Filter Tool Box is based on the octave toolbox by Christophe Couvreur which is on the Matlab File Exchange ID number 69. This toolbox makes the filters more stable. For high sampling rates the time records are downsampled. For the low sampling rates the time records are upsampled. Depending on the Filter types. Iterative resampling is used in the Nth octave band time filter to improve the attenuation of the resample program. Also the filters are settled by preappending time data, then deleting the preappended data after filtering. There are two options for the downsampling filters to optimizeperformance for continuous signals or for impulsive signals. For continuous noise the time domain does not have significant impulses; however, for impulsive time records there are often very large impulses with distinctive peaks. There are two antialiasing filters and interpolation schemes available. The first program is the built-in Matlab "resample" progam which uses a Kaiser window fir filter for antialising and uses an unknown interpolation method. The second program available for downsampling is bessel_down_sample which uses a Bessel filter for antialiasing and uses interp with the cubic spline option for interpolation. The resample function has good antialising up to the Nyquist frequency; however, it has significant ringing effect when there are impulses. The bessel_down_sample function has good antialising; however, there is excessive attenuation near the Nyquist frequency. The bessel_down_sample function experiences no ringing due to impulses so it is very useful for peak estimation. The following programs were written by Edward L. Zechmann Last modified 5 August 2010. Leq_all_calc: calculates the A-weighted, C-weighted and Linear weighted sound levels and other metrics given a time record in Pa. ACweight_time_filter: applies an A or C weighting filter to a time record and returns the A or C weighted time record.ACdsgn: designs A and C weighting filters for use with the program filter. hand_arm_time_fil Useful in characterizing hand arm vibrations of powered hand tools. Applies the hand-arm filters to a tie record according to ISO 5349-1.Nth_oct_time_filter: applies a digital filter to a time record and returns the center frequencies, sound levels, peak levels, and time records in each band. Nth_octdsgn designs a digital filter given the sampling rate, center frequency, number of bands per octave, and the order of the butterworth filter.Test_ACweight Tests the A and C weighting filters using sinusoids. The examples indicate the accuracy of estimating LeqA, LeqC and Peak levels. The examlpes output data arrays and plots of the filter tolerances. Test_hand_arm Tests the hand-arm vibrations filters using sinusoids. The output data and plots indicate how accurately RMS acceleration of sinusoids can be estimated. Test_Nth_oct_filters1 Tests the Nth octave band filters usign sinusoids. The program outputs data files and plots which indicate the eaccuracy of estimating Leq and Peak levels with the 1/3 octave and 1/12 octave band filters. The examles may take 2 to 12 hours to run. Test_Nth_octave_Band2: tests the filters using known spectral distributions provided by spatialpattern by Jon Yearsley Fex ID 5091. The program creates white, pink, and brown noise and returns the Nth octave band spectra and time records and a plot of the spectra. If you find any bugs or have and questions please post a comment or send me an email at ezechma1@hotmail.com
It's a simple GUI that calculates a random position of the end-effector, calculates the inverse kinematic and plot the joints' trajectory in a figure. You can send the positions to the arm's controller with the 'Send' button.% For a correct execution, it must select the motors following this table:% #servo_motor ------------ char to use for the motor selection% 1 a% 2 b% 3 c
As an example of MATLAB-to-C workflow with optimized code generation on ARM Cortex-M processors, the white paper illustrates how to port the generated C code from MATLAB (R2014b) to KEIL μVision IDE (v5.12).
This is a Simulink Model to Control a Robotic Arm By Gestures that are captured using Kinect Sensor. A Robot Arm is developed using Servo Motors that replicates the Right Arm Shoulder, Elbow and Hand Movements. Software Required:1. Matlab 2013a or later2. Arduino IDEComponents Required : 1. Kinect Sensor 2. Arduino Board 3. Servo Motors 4. Matlab 2013a A Project By J.Karthikeyan B.Avinashhttps://www.youtube.com/watch?v=Z4z3K5SwySEThe Zip file contains the Matlab Simulink Support for Kinect and the Simulink Model named "GestureControlledRoboticArm" that WE HAVE CREATED and also the Arduino Code/Wiring Diagram. The Simulink Support for Kinect was downloaded from Mathworks File Exchange and the full credits go to "Takashi Chikamasa" for providing it. We do not own the copyrights or have developed the Simulink Support For Kinect. Simulink Support for Kinect consists of IMAQ, Image, IR, Depth, Motion and Skeleton blocks to achieve real-time image data acquisition from Kinect devices such as Microsoft Kinect or ASUS Xtion PRO under Simulink simulation environment. It works with 32bit/64bit version of MATLAB R2010b or later in Windows7 32bit/64bit and it requires the following 3rd party software:[C MEX Compiler] - Microsoft Visual Studio 2010 Express Edition (VC++) - Microsoft Windows SDK 7.1[To use OpenNI http://openni.ru/ ] - OpenNI - PrimeSense NITE - PrimeSensor Module[To use Microsoft Kinect SDK http://www.microsoft.com/en-us/kinectforwindows/ ] - Microsoft Kinect for Windows SDK v1.6For more detailed information, please refer to document in the zip file and help of the blocks.[Optional MATLAB products] - Computer Vision System Toolbox (highly recommended) - DSP System Toolbox (to acquire Kinect Microphone Array data) - Simulink Coder (to generate *.exe file)
Video here: https://www.youtube.com/watch?v=cmW7pRLut8A2-link planar arm with a compliant controller and gravity compensation. The user can click and drag to move the end-effector's target position. Hit a keyboard key to change to "disturbance-mode." This mode instead applies a disturbance force to the end-effector.FILES:MAIN.m -- Run this first!Plotter.m -- Display the arm and integrate the equations in real timederiverRelativeAngles.m -- Derives all dynamics and controls equations.ALL other files -- Auto-written by deriverRelativeAngles.m
Camera-to-Arm-CalibrationThe method operates by finding the parameters that minimize the difference in the position of the checkerboard given by the camera and arm when it is projected into the cameras coordinate system. For more details on how the calibration operates see http://www.zjtaylor.com/welcome/download_pdf?pdf=Arm+Calibration.pdf Calibration guide=================1) Download the code2) Obtain a checkerboard3) Rigidly mount the checkerboard to the robots end effector4) Move the robotic arm into a new pose where the entire checkerboard can be seen from the camera5) Capture the camera image and record the arm base to end effector transformation.6) Repeat steps 4-5 at least 10 times (20+ times is recommended)7) Run the calibration code using CalCamArm.m8) The Calibration should be complete. For more details and optional inputs / outputs run "help CalCamArm"Any issues / comments / ideas / etc give me an email at z.taylor@acfr.usyd.edu.au
A 4 DOF arm based on the Motoman IA20 was built in AutoDesk Inventor. SimMechanics is used to generate a Simulink model. This model generates the dynamics for the robot implicitly, so there is no need to solve the equations of motion by hand. The dynamics are used by an control optimization software: DIDO, available commercially. Sample results are included along with a video and analysis which compares it against the traditional trajectory.
the project demonstrates a robot arm architecture with control subsystem and the relation to virtual reality
We used Simulink, ThingSpeak and Arduino to program a robotic arm so that it can be controlled from practically anywhere. Then we used thingspeak to send commands to the Arduino MKR1000 on the points that the robotic arm should move to so as to lift and drop off an object from specific location. This submission contains all the files necessary to repeat this project.
This submission contains a set of files for analyzing N-dimensional convex polyhedra. It is intended for fairly low dimensions N -- basically low enough so that vertex and facet enumeration using MATLAB's convhulln() command is tractable. For now, it is also limited to bounded polyhedra (i.e., polytopes). A bounded convex polyhedron can be represented either as the convex hull of a finite set of vertices V(i,:) or by using a combination of linear constraint equalities and inequalities, A*x<=b, Aeq*x=beqHere, A and Aeq are MxN and PxN matrices while b and beq are Mx1 and Px1 column vectors, respectively. The (in)equality representation expresses the polyhedron as the intersection of two regions. One region is a solid N-dimensional shape, described by the inequalities, while the other is a possibly lower-dimensional sub-space, described by the equalities. The screenshot above illustrates this, showing how a triangle in 3D can be represented as the intersection of a tetrahedron (a solid shape in R^3) and a plane.The package contains tools for converting between the two representations (see VERT2LCON and LCON2VERT) as well as for taking intersections and unions of polyhedra in either form (see intersectionHull and unionHull).The package was inspired by Michael Kleder's vert2con and con2vert functions, which were limited to N-dimensional polyhedra possessing non-zero volume in R^N.Thus, for example, they could not handle a triangle floating in R^3 as depicted in the above screenshot. Although a triangle has non-zero volume (i.e., area) in R^2 it has zero volume in R^3. The extension made in this package covers general bounded polyhedra. NOTE: however, when using linear constraint data A, b, Aeq, beq to represent a given polyhedron, it is important that the inequalities A*x<=b still be chosen to correspond with a region of non-zero N-dimensional volume. Zero-volume polyhedra are captured by adding equality constraints Aeq*x=beq. EXAMPLE: Consider the 3D polyhedron defined by x+y+z=1, x>=0, y>=0, z>=0. Equivalent constraint in/equalities can be obtained from the known vertices by doing, >> [A,b,Aeq,beq]=vert2lcon(eye(3)) A = 0.4082 -0.8165 0.4082 0.4082 0.4082 -0.8165 -0.8165 0.4082 0.4082 b = 0.4082 0.4082 0.4082 Aeq = 0.5774 0.5774 0.5774 beq = 0.5774Conversely, the vertices can be obtained by doing, >> V=lcon2vert(A,b,Aeq,beq) V = 1.0000 0.0000 0.0000 0.0000 0.0000 1.0000 -0.0000 1.0000 0.0000When an interior point of the polyhedron is known a priori, one can instead use QLCON2VERT, a quicker version of LCON2VERT which uses the known point to get around some computationally intensive steps.
This simulation finds the angular velocity time histories requiredto raise a glass from ground level to table height in a straight 45 degree trajectory. Build Robot constructs the robot from inputs, and Go! starts the simulation.Editable fields are:d_1 - Base of initial triangle formed by first armd_2 - Base of initial triangle formed by second armh - height of initial triangle formed by two armstable_height - height of table where glass is placedTime - Amount of time motion should take.d_1, d_2 and h determine the lengths of the two arms, and Timedetermines the initial angular velocities.The plot menu allows you to generate plots of the angle and angular velocity time histories for the two arms. The angles are measured from inertial horizontal (i.e., the bottom two angles of the initial triangle) and the angular velocities are of dextral reference frames aligned with the two arms (i.e. {}^\mathcal{I}\omega^\mathcal{A} = \dot\omega_1 and {}^\mathcal{I}\omega^\mathcal{B} = -\dot\omega_2).
This contains the demo files and the presentation PDF file used in the "Introduction to Object-Oriented Programming in MATLAB(R)" Webinar, which was delivered in April 2009. These are meant to augment the Webinar, not replace it. Check out the On-Demand Webinars to view:http://www.mathworks.com/company/events/webinars/For more information on Object-Oriented Programming in MATLAB, visithttps://www.mathworks.com/products/matlab/object-oriented-programming.html
popen() -- for "pipe open" -- is a very useful system call provided in many flavors of Unix. It runs a command passed in as a string then returns a file handle so that the parent process can read or write to the process as if it was a file; data passed this way is connected to the standard input or the standard output of the child process.I created this because I wanted to process very long MP3 files in Matlab. Originally I wrote mp3read to allow me to decode just a small section of a long MP3 file without having to decode the whole thing, but every time I wanted to read another segment, I had to open the file again, then seek through to the point I wanted to read.Instead, by using popen to open an MP3 decoding process that writes to standard output, I can "pull" as many frames as I want from the file, then put the process to sleep while I deal with those frames, then, on my next read from popen, the process is reawoken and the next block of data can be accessed. But this could be used for any application where there are long data streams to read or write, and you want to handle them a bit at a time.Two functions are provided, popenr.c for reading from command pipes, and popenw.w for writing to command pipes. Reading and writing to the same command is not supported at present.
This script is responsible for getting 3D data from the Kinect, where we have used the MATLAB interface for Kinect 2.0 by Terven Juan and Cordova-Esparza Diana. After we have gotten the 3D coordinates we have used the inverse kinematics and Newton's method to find the rotational angles required for the robot. Then we output the rotational angles via serial to the Arduino and wait for a finish flag from the Arduino when it has finished moving the motors to its position.We are transferring 7 bytes of information to the Arudino, first three are for the angles, and the next three are for the directions and the last byte is for the hand state.https://www.youtube.com/watch?v=GL4GasN--xw
Instrument Control Toolbox™ Support Package for R&S® VISA Interface enables you to control instruments, make measurements, analyze data, and build test systems. Once data is in MATLAB® , you can analyze and visualize that data for tasks such as signal processing, statistical analysis, digital filtering, and curve fitting. VISA is a standard for configuring and programming test systems. Instrument Control Toolbox enables you to work with VISA interfaces directly from MATLAB or Simulink® .This support package is functional for R2018a and beyond.
this matlab file is designed to draw anomaly figures, the color of the colorbar is from blue to white and then to red, corresponding to the anomaly values from negative to zero to positive, respectively. The color white always correspondes to value zero. You should input two values like caxis in matlab, that is the min and the max value of color values designed. e.g. colormap(b2r(-3,5)) The brightness of blue and red will change according to your setting, so that the brightness of the color corresponded to the color of his opposite number e.g. colormap(b2r(-3,6)) is from light blue to deep red e.g. colormap(b2r(-3,3)) is from deep blue to deep red I'd advise you to use colorbar first to make sure the caxis' cmax and cmin Examples: ------------------------------ figure peaks; colormap(b2r(-6,8)), colorbar, title('b2r') There is also a similar colorbar named darkb2r with colors much darker.
Design and verify practical SDR systems using Communications Toolbox™ Support Package for USRP® Radio. The support package enables the use of USRP® as a standalone peripheral for live RF data I/O using MATLAB® functions or Simulink® blocks. This support package is functional for R2013a and beyond.
Simulink® Support Package for BeagleBoard Hardware enables you to create and run Simulink models on BeagleBoard hardware. The support package includes a library of Simulink blocks for configuring and accessing I/O peripherals and communication interfaces. It also enables you to interactively monitor and tune algorithms developed in Simulink as they run on BeagleBoard. This support package is functional for R2013a and beyond.
This patch will allow users of Data Acquisition Toolbox 3.1 (R2012a) and 3.2 (R2012b) to use the Digilent Analog Discovery board to capture/generate voltage data, both clocked and non-clocked, in the foreground using the Session-based interface.For more details on capabilities for this support package, please visit:http://www.mathworks.com/hardware-support/digilent-analog-discovery.html This submission supports R2012a and R2012b only. For future releases of MATLAB, please refer to: http://www.mathworks.com/matlabcentral/fileexchange/40344
This function calls R to run R script (.r file) under Matlab, and returns 'runR.log' in the same folder with the input R script file.This code only works in Windows environments. It might work in Mac by modifying 'FindRpath'. 'RscriptFileName' : path + filename of the R script to be run.'Rpath' (optional) : the path for the installed 'R.exe'. e.g. Rpath = 'C:\Program Files\R\R-3.1.1\bin';If 'Rpath' is not provided, 'FindRpath' will be executed to automatically find the path for R in Windows Program Files folder.Example: >> Rpath = 'C:\Program Files\R\R-3.1.1\bin';>> RscriptFileName = 'D:\test\lmm.R';>> RunRcode(RscriptFileName, Rpath);or just >> RunRcode(RscriptFileName);
Embedded Coder® Support Package for BeagleBone Black Hardware enables you to create and run Simulink® models on BeagleBone Black hardware. The support package includes a library of Simulink blocks for configuring and accessing BeagleBone Black peripherals and communication interfaces. For NEON™ optimized code for DSP filters, use ARM® Cortex® A Ne10 Library Support from DSP System Toolbox™.This support package is functional for R2014b and beyond.If you have download or installation issues, please contact Technical Support: www.mathworks.com/contact_ts
Model of a 7-DOF arm robot in MATLAB Simulink with Sliding Control Mode controller. The model will include the dynamic model, actuation system, controller and a 3D real time representation of the robotic arm.
The BeagleBoard (beagleboard.org) is a low-cost, single-board computer designed for audio, video, and digital signal processing.In R2012b, Simulink provides built-in support for prototyping, testing, and running models on the BeagleBoard. You can design algorithms in Simulink for audio processing and computer vision applications then see them perform with hardware.--------------SPECIAL INSTALLATION INSTRUCTIONSNote: for R2012b, do not use the Download Submission button.1. Open R2012b MATLAB.2. Enter "targetinstaller" at the MATLAB command prompt.3. When Target Installer opens, choose Internet, and follow the instructions provided.--------------Simulink support for the BeagleBoard includes the following driver blocks: • Video Input and Display • Audio Input and Output • UDP Send and Receive For more information on built-in hardware support, see: http://www.mathworks.com/discovery/simulink-embedded-hardware.html--------------For R2012a support, see: www.mathworks.com/matlabcentral/fileexchange/35205For R2013a and beyond, see:www.mathworks.com/matlabcentral/fileexchange/40310--------------
This block allows you to simulate a Simulink(R) model in "real-time". You can also set a factor of real-time, for exampel three times real-time of half real-time. It is possible to set the priority of the the Simulink process and model thread.To install: Unpack the zip-file in a directory and add that directory to your MATLAB(R) path. When you start simulink the block library should be added automatically to your Simulink library browser.
In R2008b, fopen no longer supports vaxd and vaxg file formats. This tool lets your use the ieee-le file format to read these files in R2008b and later. These tools are not for writing vaxd or vaxg files. Though you could write VAXF_to_uint32le.m, VAXD_to_uint64le.m, and VAXG_to_uint64le.m functions as well as fwriteVAXD.m and fwriteVAXG.m files if you wanted to enerate new files in VAXD or VAXG formats.VAXD and VAXG are two methods VAX uses for representing floating point double precision numbers. VAX has a single method for representing single precision floating point numbers, VAXF. A VAXD encoded file uses VAXD standard for double precision and VAXF for single precision. A VAXG encoded file uses VAXG for double precision and VAXF for single precision. Information for how numbers are encoded can be found here: http://www.opengroup.org/onlinepubs/9629399/chap14.htm#tagfcjh_20To patch your code: 1) Open your file with the 'ieee-le' format instead of 'vaxd' or 'vaxg'. 2) Replace fread commands with freadVAXD and freadVAXG functions.Notes: 1) freadVAXD and freadVAXG assume three input arguments whereas the fread in MATLAB can take a number of different input arguments. 2) All code is written in MATLAB. Speed might be improved by writing C-MEX functions.Example:If your code originally looked like this:fid = fopen('myfile', 'r', 'vaxd');A = fread(fid, 2, 'double');A = fread(fid, 3, 'uint32');fclose(fid);You would change your code to look like this: fid = fopen('myfile', 'r', 'ieee-le');A = freadVAXD(fid, 2, 'double');A = freadVAXD(fid, 3, 'uint32');fclose(fid);Contains:anExampleVADG.m - code to test the accuracy (and generate data file on R2008a or earlier)freadVAXD.m - reads files assuming vaxd 64bit double precision floating point numbers and vaxf single precision floating point numbersfreadVAXG.m - reads files assuming vaxg 64bit double precision floating point numbers and vaxf single precision floating point numbersuint32le_to_VAXF.m - converts 1 uint32 bit number into a floating point number (assuming vaxf encoding)uint64le_to_VAXD.m - converts 2 uint32 bit numbers into a floating point number (assuming vaxd encoding)uint64le_to_VAXG.m - converts 2 uint32 bit numbers into a floating point number (assuming vaxg encoding)readme.txt - this filetestData.mat - sample datatest_vaxd - the sample data encoded in vaxd and vaxf double/single floating point numberstest_vaxg - the sample data encoded in vaxg and vaxf double/single floating point numbers
MATLAB supports interoperability with R but you might want to translate R to MATLAB or the reverse. This script illustrates an experiment in such translation using the interface to ChatGPT 3.5 at OpenAI.com. Similar things can be done programmatically using the OpenAI API but I find the present API interfaces with a less capable model.[1]For other code creation and translation experiments, see my scripts at MATLAB File Exchange.
This is a small practical example that illustrates the use of Matlab for performing the kinematic simulation of a robot arm. The example also makes use of Matlab's graphical capabilities.The animation (mpeg1 format) shows a renderized robot manipulator arm with six degrees of freedom. The hand moves on a cylinder describing an spiral from bottom to top.
To successfully operate real-time software on any microprocessor system, control and management of all interrupt services is required. Unfortunately, depending on your BIOS, it may not be possible to turn off certain interrupts known as System Management Interrupts (SMIs). These interrupts are not accessible from operating system, kernel, or application software and the CPU cannot be instructed to ignore them. However, for some chipsets, such as the Intel ICH5 family, it is possible to programmatically prevent or disable the generation of SMIs.Unexpected SMIs will cause random and spurious CPU overloads. The enclosed S-function and Simulink block will disable SMIs on the Intel ICH5 chipset family and help avoid these overloads.
Embedded Coder® Support Package for STMicroelectronics STM32 Processors enables users to build, load, and run Simulink models on STM32 devices using two separate workflows included in this support package. Any STM32F4xx, STM32F7xx, STM32G4xx and single core STM32H7xx family processor based boards are supported using STM32CubeMX-generated peripheral configurations and few ST Discovery boards are supported using built-in peripheral configurations. Capabilities of both workflows include: Rapid prototyping of algorithms on-chip using automated build, deploy, and executionPerform real-time parameter tuning and logging using external modePerform processor-in-the-loop (PIL) with execution profilingGenerate processor optimized code, including CMSIS-DSPDriver block libraries for on-chip and on-board peripherals such as ADC, digital I/O, PWM, SPI, I2C, CAN FD and more (varies by support package and workflow)STM32CubeMX workflow specific capabilities include: Support for peripheral configuration using STM32CubeMX integrationSuitable for generation of production code used in high volume deploymentIncludes peripheral driver blocks for digital I/O, ADC, PWM, and IRQSpeed motor control development with example models for Motor Control Blockset™Supported Hardware: any STM32F4xx, STM32F7xx, STM32G4xx, single core STM32H7xx, STM32L4xx, STM32L5xx, and STM32WBxx based board (Nucleo, Discovery, or custom)Discovery board specific capabilities include: Peripheral driver blocks for digital I/O, ADC, PWM, IRQ, I2C, SCI, and SPIBoard-specific audio, MODBUS®, WiFi, ThingSpeak™, and environmental sensors blocksSupported Hardware: STM32F746G-Discovery, STM32F769I-Discovery, STM32L475VG-Discovery (B-L475E-IOT01A), STM32F4-DiscoveryFor detailed information, view the online documentation and examples. View videos on how to install the package and how to deploy your first model. This support package is functional for R2013b and beyond. STM32CubeMX workflow was added in 2021b. See release notes for details. Note: This support package was formerly known as Embedded Coder Support for STMicroelectronics Discovery Boards till 2021b. For download or installation issues, please contact MathWorks Technical Support. For easy-to-use support of STM32 Nucleo boards, consider the Simulink Coder Support Package for STMicroelectronics Nucleo Boards.