Automated ROS and ROS 2 Node Generation from Prototyping to Production
Overview
MATLAB and Simulink support a live connection with ROS network for your ROS based desktop simulation. In addition, you can generate stand-alone C++ nodes from MATLAB and Simulink through automated code generation. Starting with R2021b, it also supports embedding a deep learning network into ROS nodes using GPU coder (e.g., generate CUDA code of object detection algorithm from MATLAB Script using GPU Coder).
This webinar discusses automated C++ ROS / ROS2 node generation from MATLAB scripts and Simulink models. We will also highlight ROS Toolbox feature updates and propose the workflow that successful users have adopted.
Highlights
Through several examples, webinar covers the following topics:
- ROS and ROS 2 node generation and deployment from MATLAB scripts
- ROS and ROS 2 node generation and deployment from Simulink models
- ROS-compatible CUDA node generation from Simulink using GPU coder
- Working with generated ROS nodes
About the Presenters
YJ Lim is a Senior Technical Product Manager of robotics and autonomous systems at the MathWorks. YJ has over 20 years of experience in robotics and autonomous systems area, including prior experience at Vecna robotics, Hstar Technologies, SimQuest, Energid Technologies, and GM Korea. Lim received his Ph.D. in mechanical engineering from Rensselaer Polytechnic Institute (RPI) and his Master from KAIST in S. Korea.
Murat Belge is a consulting engineer at the MathWorks. He is the technology team lead for ROS Toolbox. He worked in MathWorks for over 15 years in various areas including code generation for embedded systems, networking protocols, middleware representation and integration, IOT, device driver abstraction and integration, targeting embedded Linux systems, embedded vision and motor control. His experience includes developing embedded vision algorithms for SIMD processors and developing time domain reflectometry diagnostics systems for digital subscriber lines. Belge received his Ph.D. from Northeastern University, M.S. and B.S. from Bilkent University in Turkey, all in electrical engineering.
Recorded: 7 Dec 2021
Hello, everyone. Welcome to this webinar. My name is YJ Lim, technical robotics product manager at MathWorks. I will be presenting with Murat Belge today. We will be talking about Automated ROS and ROS2 Note Generation from Prototyping to Production.
Before we begin, let me do a few housekeeping for your better experience of this webinar. If you have any problem hearing the audio or seeing the presentation, please contact to the webinar host by typing in the chat panel. If you have any question for the presenters related to the topic, you can type them in the question and answer panel. Those questions will be answered at the end of the presentation.
Here is a quick introduction of today's presenters. I am a senior technical product manager of robotics and autonomous systems at MathWorks. I have spent the past 20 years developing robotics and autonomous systems. Before joining MathWorks, I worked on several robotics project at companies, including Vecna Robotics, Hstar Technologies, Energid Technologies, and the GM R&D Center. Murat, would you introduce yourself?
Hello, everybody. My name is Murat Belge. I am the development lead for the ROS Toolbox. I have 20-plus years experience in embedded software development, automated code generation, and middleware integration. My previous experience includes developing signal processing algorithms for digital subscriber lines and developing image processing algorithms.
Thank you, Murat. First, let me post a quick poll to better understand how you test your autonomous system. A, are you using simulation? B, do you do software in the simulation? C, do you do hardware in the loop? D, do you test your code in the target process? E, do you try, try, and try until you test and validate your algorithm? F, you are not involved with testing your algorithms or systems. Thank you for your input.
Robot Operating System or ROS is an enabling technology to build and test a variety of system applications through access to a large set of software, tools, and ROS-enabled hardware. In this webinar, we will discuss an automated C/C++ ROS and ROS2 note generation from the MATLAB script and the Simulink model to code directly from algorithm development to implementation without hand coding in C/C++. And we will also highlight MathWorks ROS features support and proposed workflows that successful users have adapted.
Let me begin by introducing an automated C++ code generation. MATLAB and Simulink enable modular design by providing a common platform to develop a plant, design our algorithm, and simulate the plant and algorithms. Once the system design is deemed to operate as intended, you can deploy your system design and the algorithm by generating efficient, consistent, and portable code. This approach reduced hand coding error and reduced the time to market.
One of the greatest features of MATLAB and Simulink is automated code generation. You develop your application in the MATLAB and Simulink environment by taking advantage of MATLAB language, Simulink blocks, staple diagrams, and the many other solutions. You can then deploy it as a C++ application.
For example, the embedded code product that enables code generation has a flexible interface for the code customization, which enables and generates the code to be used with several C++ development frameworks, including ROS. The basic idea behind the automated code generation is following-- you write the code in a high-level language. A code the generator takes the high-level language and translates it into a general purpose programming languages.
The MathWorks code generator support generating C, C++, HDL, and GPU Coder. Code generator automatically convert designs in high-level languages into implementation in general purpose languages that are suitable for deployment into various target environments. Code generator plays multiple roles in user design and the development process.
For many industrial customers, production code generation is their ultimate goal. Users pay attention to the many aspects of generating the code. Efficiency is one of the top concerns. Our goal is that automatic generated code can be as good as or better than hand code from experienced programmers.
There are many success stories of companies using automated code generation. NASA's Orian Program used automatic code generation in their guidance, navigation, and control-applied software. Voyage is one of the first companies to deploy a Level 3 autonomous vehicle. Simulink paired with embedded code is used to generate and deploy the code to the vehicles on board the ROS network.
Let's dive into ROS, and ROS node, ROS2 capability from MATLAB and Simulink. In the right hand side, this is how traditional ROS was enabled-system looks like. There is on host of ROS-enabled simulator and the hardware. Through the ROS network, they can communicate with nodes that would enable autonomy visualization and so on.
For an autonomous system development, system should have a functional component of a perception, planning, and control. MATLAB and Simulink open tools for autonomous system development. And now we have a tight bridge to the ROS from MATLAB and Simulink.
There are basically three workflows. The first is data analysis and playback. After you load the data from the simulation and the hardware, then you want to bring them into MATLAB and Simulink environment for the upline design task. You can use rosbag import and playback function.
Next is desktop simulation. This embark a live connection between ROS in an instance of MATLAB for the algorithm development. And finally deployment, the same implementation you may have used for the prototyping can be automatically generated as a standalone ROS node. Then you no longer require MATLAB to be executed.
I want to point out beyond just the bridging was with MATLAB and Simulink, you can complement traditional ROS solutions with MATLAB Simulink tooling. So now let's take a look at each workflow with some examples, first, rosbag data import and playback.
You can extract the specific topic from the time stamped data to analyze and visualize them. The ability to read a ROS spec file and to work with specialized ROS message types with the sensor will allow you to bring all your design data into the MATLAB and the Simulink without the need for a lot of preprocessing code.
With a 2021 list, you can also write rosbag file or the messy data generated from MATLAB and Simulink. With a this new workflow you can write the ROS data to the bag file inside of MATLAB and Simulink. This video shown here is to record camera image later, and decompose from a Neil engine simulator into a ROS spec file, and to playback the selected topics.
Next is desktop simulation. This is a MATLAB over Simulink in the loop with your external simulator or hardware. In this slide, we have a load manipulator in the Gazebo simulator. By joining ROS network up to initializing ROS from the MATLAB, you can control the robot arm and the deceived image streams for the camera input from Gazebo simulator.
Similarly, you can do Simulink in the loop simulation with Gazebo simulator through the ROS toolbox. Here, I'm showing several examples that we ship from robotics the system toolbox and the ROS toolbox. We have a virtual-machine imaging that is fully computer for ROS and ROS2 with several examples, as are shown here. I encourage you to try that out.
Here is another example of collision simulation with unity simulator through ROS toolbox. After creating a warehouse scene in the unity, you can co-simulate a warehouse robot to plan a path and to follow the waypoints with obstacle avoidance, while Simulink recieve laser scan and the camera input from the unity for the input of your navigation algorithms.
MATLAB and Simulink can make test simulation easy with ROS together with many other design tools to test and verify robotics algorithm and the application. ROS toolbox really play a gateway to connect external simulator over devices with MATLAB and Simulink.
The third workflow is an automated ROS node generation. We can deploy ROS node from MATLAB and Simulink to either local host or remote device with multiple options.
When you generate ROS node to the local host there are two options we can choose. One for the build only, another for build and run. Build model will generate the ROS node locally and compile ROS node on the your host machine. When you do build and learn, ROS node will even be executed on the your host machine.
So when would I use this option? If we have no connection to the hardware, or you want the computer or set-up the remote ROS device later, you can build the ROS node in the local host. And then you can manually transfer the generator ROS node to the target ROS device later.
With the built and run option, you can use high computational power over development host machine to execute generated ROS node. Or you can accelerate the simulation speed, as well.
One of the use of cases for the building and run locally is to use the learning algorithms on the development host machine. The perception module is executing in your host PC, while receiving sensor data. And you can send in the other ROS command data to the ROS and other robot hardware.
Another user case is an automated valet parking example that we ship from ROS toolbox. This single parking valet model can be broken out into four separate two models. To facilitate deployment as a distributed system, by deploying three ROS nodes locally as a standalone ROS nodes, you can speed up the simulation.
Now, you can also generate ROS nod to the remote ROS device automatically. We have three options, build the model, build and load, and the built and run. When you do build the model, you generate C++ node to ROS device then you specify. This option will be good when you do not know the configuration or setups of ROS device yet.
For example, you are not sure if your robot is connected to the network, or you have another nodes to build it together, then you can just do them in build the model.
Build a local and a build and load option will generate C++ ROS node to the remote ROS device, and the copy the source folder to the workspace, and do the Catkin or Colcon build.
Again when you have other nodes to build it together or a load is not computed into ROS node yet, you can do build and load. Lastly, when you do build and run, it will execute standalone ROS node on a remote ROS device without connection to the host.
One example of this use of cases is the deployment of standalone ROS node to the remote robot, to another robot. This is a mini race car on open source in a platform for robotics research. The platform host's state of the art sensor and then computing hardware placed on top of a mini race car.
What you are seeing here is using office floor plan image. You can create an occupancy map for the robot to deliver on object from one office to another office while following the path. By creating Gazebo world from floor plan imaging, you can connect your algorithms of the nodes to Gazebo simulator using ROS network. Then you can also deploy your algorithms to the ideal robot hardware using ROS node generation remotely that we just discussed.
OK, now I will turn it over to more for the detail of how to generate ROS node from MATLAB and Simulink, and even for GPU Coder.
Thank you, YJ. Hello, everybody. I'm going to talk about automated ROS generation from MATLAB code of Simulink models. I will present several hands on examples so that you can compare and contrast the workflow between the two.
You can often achieve similar results with either MATLAB or Simulink. The choice, in most cases, comes down to personal preferences. But I'm going to make a brief comparison of MATLAB-based workflow with a Simulink-based workflow with detailed examples of how you would go about generating a standalone ROS node in each case.
So with that, let's get started. So this is a brief, somewhat simplified, overview of MATLAB versus Simulink-based workflow. On the MATLAB column, you see that if you are doing textual programming whereas in Simulink case, the programming language is graphical. You are looking at blocks and signals and their connections.
In the case of Simulink, there's a built in notion of time. Simulink is a time-based simulation engine. So the scheduling that you are doing is time based. So this can be advantages. And in some cases, where you need to take finite timing steps while computing the results of an algorithm, for example.
Whereas in MATLAB, there is no built in notion of time. Of course, you can incorporate it into your MATLAB scripts. But general programming is event based.
In both cases, you can include stateflow charts. And you can do PIL and profiling. PIL is posted in the loop. And so we get an extra feature called External mode, which allows you to run your Simulink models on the hardware while leaving the results on the host computer.
And in addition in the Simulink there is some system architecture tools. So there there's a new product called System Composer, which allow you to create architecture diagrams and allow you to build high level systems. So if you are working with several Simulink nodes, several nodes, basically, if you're aiming at generating several nodes, then you may want to start with Simulink.
Whereas in MATLAB, you are also looking at programming single nodes. And one extra thing is that in Simulink you can incorporate MATLAB code into your Simulink models. Whereas, the reverse is not true.
So what are the steps to deploy MATLAB function as a C++ node. We have two basic ingredients. Number one, you have a function. You have a function that represents your node. Here you can see 10 lines of code. I'm just creating a subscriber. And whenever a new message is received, I basically just print it out using a callback.
The second thing you need a configuration object, MATLAB code or configuration object. This allows you to specify the characteristics of your hardware deployment platform. Once you have these two, you tell MATLAB coder to generate code and then outcomes C++ ROS node.
Again, you have your scripts, generate code, outcome C++ code. This is a very powerful concept, because often you have 10 lines of MATLAB code. And then when you look at the generated C++ code, there's thousands of lines. There's a lot of things that you don't have to know, you don't need to know. So MATLAB is a very high level language so that allows you to program your ROS node in just a couple of statements, and then get a C++ code that represents to the system.
OK so I'm going to go through the detailed examples of how you deploy a function. So I pre-recorded the example, I'm just going to narrate it. So we're generating a standalone note from our MATLAB script. Let's take a look at MATLAB script first.
The first and foremost, you have your MATLAB function, cannot take any input arguments and returns no outputs. This is because we are targeting this to run stand alone. So there is no way to provide inputs to program or nobody to return the outputs to. You're just running it on the command line. So no inputs no outputs.
We are subscribing to the point topic. And we're installing a callback. And the callback is going to process the results whenever we receive a new message. And the data format has to be struck for generation to work. That's an important point and we have a while 1 loop over here to make sure that the program execution does not, basically, fall through. Again, our callback function is just printing out the results.
OK, now the next step is creating a configuration object. We are using the coder that config command to create the configuration object. And we are selecting a standalone executable. There is different kinds of configuration. And in this case, since we are generating a standalone node, we are using the exe configuration.
We set the hardware to robot operating system. You can deploy to either ROS or ROS in this case, we're going to deploy to ROS. But this is like the important steps in terms of selecting the final ROS network that you have deployed here.
And here to the deployment platform will be local host. And I'm going to run the code immediately after building it. So I'm just selecting the builder run as the build action.
You can look at the properties of the hardware objectives. These are defined by the ROS toolbox. And then you can find the detailed explanation on all of them. Let's start by initializing our ROS master. In this case, as I'm deploying it to the host computer, I'm starting a master on the host computer itself.
Once I do that, the next step will be to execute my codegen command. I specify my script name and the configuration object. And we are off to the races. So once I execute that command, MATLAB Coder takes over, generates the C++ code. You can see that there are some folders being generated on the left hand side. And then we call the Catkin builder to build the generated code.
And some of you might recognize that there are standard folders that are supposed to be in a Catkin Workspace, for example, develop folder and whatnot. This is literally what we are doing actually. We are creating a Catkin workspace in the code generation folder. Once the code generation goes through, you can see that all nodes start. And it starts printing out myNode is alive.
Next let's send a message to the node and see if it receives and prints it out. You're going to generate a publisher that publishes on the geometry messages point. Again the data format instructs, so I'm just creating a publisher. At the same time, I'm getting a default message for that message type.
To make it more interesting I'm going to change the xyz coordinates the default messages 0 for all of these subfields. And then I called a send method off to publisher to send the message. And then as soon as I basically hit the Enter, you saw that message printed out on the ROS node. And I can do this again and again. And then the messages will be displayed on the running ROS node.
OK, so this is basically the steps. We have this as an example in the ROS toolbox. But the overall process is entirely very, very simple. You have your MATLAB lab function. You have you create a configuration object. You set your hardware up to ROS toolbox. And then you do a code gen and out comes the ROS node.
So we're going to do the same thing with Simulink right now. So on the left, you have the MATLAB script that I just ran on the right. That's the code description of that in Simulink.
So here we have a subscriber block, which is subscribed to topic. And we have enabled subsystem. Whenever a new message is received, the contents of the enabled subsystem is executed. Inside the enabled subsystem, we just have a MATLAB function block, which just prints out results. Again, this basically illustrates the earlier point that I made. In your Simulink models, you can actually embed MATLAB code.
OK, so the first step, let's simulate the model. Make sure that it is doing the right thing. So this is not code generation yet. We are just simulating it within the Simulink environment and trying to see whether it's doing the right thing. You can see the simulation 10 times advancing.
I'm going to go through the same steps, create a publisher here, and publish a message, and then see if our model is receiving it. By doing that, I can make sure that message type and the topic is the message and topic that I expect in a Simulink model. So I change the coordinates of the message, xyz coordinates, and I send it. And when I did that, the Diagnostic Weaver has a new message that's printed out.
And this is actually console outputs. I mean, whenever you output something into a console in Simulink, it's actually directed into the Diagnostic Weaver. So that's why we are seeing the messages in the Diagnostic Weaver. Again, this is the simulation mode. It's not code. I'm not generating code yet. I am still in the MATLAB Simulink environment.
All right, so let's stop this. And let's go to the next step. So a quick high level overview of code generation from Simulink. Again, we have the Simulink model. And we, basically, configured the hardware characteristics or the configuration set for Simulink is basically configured through graphical UI. And then we select the ROS network that you want to deploy to. Again, I'm going to use ROS here. But you can also deploy your Simulink modeling to ROS network.
Then you click on the hardware settings. And then specify the characters of your hardware. When you target a model for robot operating system, the default hardware comes up as a generic unspecified. But if you are deploying this to an on platform, for example, you need select the compatible arm cortex-a9 or something to that effect to make sure that your operations are correctly executed for that hardware platform.
And exactly the same thing that was available in the MATLAB Coder workflow, you have a choice of deploying to your local host or remote device. If you are on the local host, the code is compiled and executed on your host computer. Whereas, if you are connected to a remote device, the code is actually compiled on the remote device. And then you deploy it.
And then we have actually ways of giving us information about your remote device. We execute SSH commands to build the code. So we need your user credentials. Plus, you need to specify your process installation folder and your Catkin workspace.
So again these options were available in MATLAB Coder, too. It's just basically inside the configuration. But you have essentially a mirror symmetric representation of your Simulink configs with the METLAB configuration object, as well. And we have a utility to test the connection to your hardware if you want to.
All right so let's go into code generation. So I'm going to, basically, go through the model briefly again. So we have the subscriber. I'm going to open the subscriber block mask and look at the parameters a little bit.
So we are expecting messages to be published on the topic and geometric space point is a type. And the sample time for the block is 0.01. So this means that I'm going to check if new messages available or not, hundred times per second.
I'm going to look at the contents of that signal line. It appears funny. So it's basically a representation of a bus. There is like dots in the middle. I can use the signal hierarchy viewer to see what the contents of that bus is. This is basically aggregate data type, signal type, in Simulink. And a its a client representation in MATLAB is a structure. So inside there I have the MATLAB function block. And I'm just printing out the coordinates of the received message.
All right, let's go to the top level. And then let's start the code generation process. So I'm going to open the robot operating system ROS app from the tool stripped. And then that drops me into the ROS tab. I'm going to select my deployment network, which is ROS. And then I'm going to deploy just to local host. So we're going to select local host as our deployment platform.
And then once those are done, I click on the build model button under deploy. And then we are again off to the races. It's a similar process with as we have seen with MATLAB Coder in this particular instance. We are actually again generating code from the Simulink model, C++ code.
We are generating a Catkin workspace in in the current code generation folder. And then building the code using Catkin tools. And if you want, you can click on this view diagnostics hyperlink at the bottom of the Simulink model to see the progress of the code generation.
So this will take a while. And we are done. In this case, the node did not start running, because I choose not to. So I'm going to basically use a ROS device tool to launch to ROS node. But you can see, some of the folders here and then my node is already generated from the developed folder. It's called the my node exe.
So I'm creating a ROS device object here that's connected to local host. And this object is telling me that I already have a node available under the current folder called my node.
So this ROS device object has a bunch of methods. One of them is running a method for running a node, called run node. And when I execute that I'm going to launch the standalone node I just generated out of Simulink. So you can see that it started running and then printed out some information.
So it's boring at this point. It looks like it's not doing anything, but it's continuously checking the messages. Since nobody's publishing, there's nothing printed out. Again, I'm going through the same steps to create a publisher. And I got a default message. I'm going to make it more interesting by changing xyz coordinates and then use the Send method to publish it to ROS network.
As soon as I do that, I can see that the ROS node is printed out received message. I can do this again and again. And I'm seeing the messages being printed out on the console. Let me change the Z-coordinate a little bit. And then published again. So it's like we are convinced at this point that everything is running fine.
I can stop node. So again, this is a part of the ROS device object. I can start and stop ROS node at will. So this is basically generate executable, there is no build going on anymore. It's a very quick process. I can restart my node. Just to prove the point. And I'm going to do it the same steps, change the message coordinates and then rerun this again.
And everything seems to be running just fine. So this process is again is similar. And then we were able to run the generator node. So there is an extra feature in the Simulink, where you can incorporate deep neural networks into a Simulink model. So this is a hot topic, AI and AI-enabled robots.
ROS toolbox allows you to incorporate deep neural networks into your ROS nodes. You have to use the GPU coder to generate the CUDA code. And then you can deploy this into an NVIDIA machine, for example, Jeston Xavier or Jeston Nano. Or you could actually deploy this to your local host computer if you have NVIDIA GPU card.
So the configuration steps for this, I'm going to just briefly touch upon that. But before that, we have some support packages for NVIDIA compatible hardware for Jetsons, and Jetson Xaviers, and whatnot. So you may want to download and install them. It gives you a couple of device drivers that you can use with your board, and also allows you to communicate with the board itself.
So I'm going to present an example that we are shipping. It's somewhat a simplified form of that example. If I click on this link, this opens to online documentation for ROS toolbox. And the example name is Lane and Vehicle Detection in ROS. I strip down the lane detection part to make the subsystem a little bit simpler to explain. So let's go through that.
So I'm going to go through the configuration steps, just explain the model a little bit. As you can see, there's a subscriber block. It's receiving images from the ROS network.
The image-type sensor messages image or message-type sensor messages image inside enable subsystem. We are converting the message into a matrix, which represents the image actually, and then calling a Yolo v2 vehicle detectors. So this is a pre-trained network. You can download the coefficients from MATLAB website. And then we annotate the images and then publish it. We also display that on the video view.
I'm going to click on the hardware settings and just to demonstrate the configuration process. You need to enable a couple of settings in the configuration set to generate CUDA-enabled code. Our target is ROS. And for simulation, we're going to use GPU acceleration. So I'm just checking that on. And we're going to go into the hardware implementation pane.
And under the device, page details, we are checking support long on. So this is a setting, which is available for most compilers. You need to check this for the end media compiler. And then we go into the code generation pane, click on the GPU code, and then make sure that C block are checked on.
And that's about it. We are configured for CUDA-enabled ROS node generation. Now we can open a ROS code generation app. Select deployment targets, deployment site, and then click on the Build button to generate code.
And this is half of this looks like once it's run either on the host computer or on an the NVIDIA Jetson Nano board. So this is basically the simulation. As you can see, the vehicles are detected and indicated by the bounding boxes. Note that I have a GPU card on my host computer that otherwise you couldn't run this on your host computer.
And then the same thing, I'm going to deploy it into Jetson Nano board. So I go through the configuration and code generation step. Fast forward, and once everything is compiled, it's going to start running on the Jetson Nano board. And this is basically a capture of that process. So you can see the vehicles are being detected. And then the monitor is actually connected to the Jetson Nano board.
All right, with that I'd like to end my part of the presentation. And I'm going to ask YJ to take over the presentation again. Thanks.
Thanks, Murat. So now once you generate ROS node from MATLAB and Simulink, can we still change and tune the parameters of the ROS node generated?
Yes, there are several ways that you can work with it. Here, we have a generator ROS node. First that you can use ROS device object. Or you can configure your deployed algorithm using ROS parameter server. Lastly, you can use external mode to tune the parameter and the visualized data directly in the Simulink model. Let's take a look at it.
By using ROS device option, you can create a connection with ROS device from host. Then you can start and stop ROS node on the connected ROS device. Or you can check the status of ROS network. Or by using rosparam utility, you can configure your deployed algorithm to send or receive the lost messages or values in the parameter server. This lets you interact with the deployed node from the MATLAB.
In the Simulink, you can use the external mode to tune the generator ROS node in situ, even though the code itself is learning on the target computer. It can be a good debugging tool while you are still designing your algorithm to tune the parameters and the visualized signal on your model while your model is learning.
In this same following robot example, we already deployed and executed the ROS node of the same following algorithm to our target Ubuntu machine. We can have a companion Simulink model. In here, there is a node, and the control and navigation algorithm there. But we can display what robot is seeing by disabling messages published on the image topics. You can also look at the velocity that the robot is moving. Also you can start and stop the robot as desired.
OK summary. I hope you are now able to see the how MATLAB and Simulink make ROS-based development process easy. Specifically, how to use an automated ROS and ROS2 node generation for the prototyping as well as the production.
So this brings us to the end of this section. Here is a quick recap of what we discussed today. There ROS support provided by MathWorks ROS toolbox let you to automatically generate standalone C++ ROS nodes from the algorithms designed in MATLAB and Simulink. The generator ROS node incorporate ROS frameworks. So this allows you to speed up the development process and remove a manual implementation errors.
Using MATLAB and Simulink, you can process directly from algorithm development to implementation without hand coding in C++. I encourage you to download a trial to check out the reference example on the ROS capability and the automated ROS node generation from MATLAB and Simulink.
To learn more about MathWorks robotics tool and ROS, please visit our webpage and the Robot Is The Solution page. Don't forget to visit MATLAB GItHub Repository. In addition, we have a large number of examples that are published on our webpage to help you to accelerate your development effort. And we will be happy to support your specific user cases as well. So feel free to reach out to us with any questions.
Thank you for your attention. So now, please post your question in the question and answer panel. We will take a few moments to review them and then come back online to answer your questions. Thank you.