[Lite3] [Locomotion] [ROS2] ROS2 migration and quadruped modularization based on locomotion of Lite3

Hinzugefügt: 2026-05-12

[00:00:14]Hi, my name is Percy and I'm an algorithm engineer at Deep Robotics.

[00:00:18]Today I'm going to introduce the ROSQ migration of our live robot based on our previous locomotion policy. So let's let me introduce uh the software structure a little bit. So previously if you check the quadrip locom motion from beginner to pro series uh we are using uh UTP communication between the local motion policy and the hardware. So uh in the light three IO deploy ripple there is a local motion policy and it communicates with the joint and IMU through UDP uh it gets the data and it sends the joint data command the target joint post also through UDP to the low level. So right now for this ripple we have done Ross 2 migration. So there will be a another package that's going to get these UDP data and uh publish them in a ROS 2 topic format. So and another and the previous locomotion policy will also be in a ROS2 node and it's also going to publish through uh ROS2 topic. The joint data command the target joints that is also going to publish through the ROS2 topic. So if you look at the readmi here. So the the rapper we are using right now is this SDK deploy. So it does not only have live three here, it also have the M20 here. And this is the first video of this series and you guys can check that. So right here we are uh using the live 3 SK deploy which is the ROS two version of our previous locomotion policy the live three IO deploy. So the data uh the structure the ROS two structure here is pretty easy.

[00:02:03]We have this IO deploy which is the local motion policy. It communicates with if it's in simulation is magical simulation. If it is real world is library. So it gets IMU data and joints data and publish joints command. And if we are using the game pad we have another node for the retray gamepad to control it through this um through this game pad.

[00:02:31]Okay. So now we can actually go into this ripple. So before deploying anything to the real world, it's very important and very important for safety to do a simtosim test first. So we're also going to do that here. And um so this is the ROS topic introduction. So for the IO deploy uh it also like MU joins data generator command is just exactly what I described here. And for the simp here. Okay. So just um get clone this. Okay. This is a little bit wrong. I need to and we have get clone here and uh we going going into this uh directory and source uh the ROS to environment and compile. So let me just remove everything to start again and Wait a second and let it compile.

[00:03:47]So after compiling we can do the sim to sim test. And as for the details of this uh uh folder structure, you can check the third uh video of the quadrip locomotion from beginner to pro series.

[00:04:01]That one has a very specific introduction to all the files in this folder. This one is just a rust two migration. The main structure is pretty similar.

[00:04:19]So we have this uh ROS uh symmetrical simulation coming up one terminal for that the other terminal for running the node and it can just stand up.

[00:04:38]Press C to stand up and press C to enter a control mode.

[00:04:44]And you can just start moving like like this.

[00:04:48]Okay. So this part is the sim to sim test. So uh we have uh do the sim to sync test and everything is working here. We are ready to do the sim to real test. So as I mentioned we have another package that's going to get the UDB data and publish in a raw topic format. So first we need to install compile install that package and then deploy our actual policy. So the actual uh the the package I just mentioned is the live three transfer here. Uh and we also have a live three SDK service that's uh communicate uh between the robot and the AP and it can just auto start on boot.

[00:05:32]So uh the main package is this transfer thing here but we need to compile these live light three SDK servers too. So, let's go into uh the the robot.

[00:05:52]And since this thing is based on ROSS 2 and we need to install ROSS 2 first and our previous live stream products uh doesn't have ROS 2. So, I'm going to show you guys how to install it on our live stream robot. And another thing I need to mention is that uh this rappole and this process is only for the library venture uh edition. No other addition is uh applicable. So okay. So let's first install ROS ROS 2 here.

[00:06:23]And uh to install ROS 2 I suggest just follow the official uh website step. Uh and for for you guys in China here, you may need to switch the sources to uh uh for faster internet communication connection.

[00:06:42]So just uh copy and paste uh everything in the uh official website and install it.

[00:07:52]Okay. So now we have installed uh ROS two here on the robot and we can start using our uh start compiling and installing our packages. Okay. So to install our uh packages uh we need to get clone this ripple this SDK deploy ripple and if you guys see in the read me here introduce that we have this SDK deploy which is the local motion part this SDK service which is uh for the data transfer part and yeah this three transfer this one manages this package and the M20 is the M20 SK deploy is also the locomotion part And um we have another uh readme for uh specifically for this uh live three uh data transfer service. And this is actually the one we're seeing here before this thing. So yeah, let's just go to uh the robot and follow the uh step by step. So preparation uh use this requires network configuration and installing ROS 2. Just uh do it step by step. Okay. So the first step is to go to this.

[00:09:11]Uh so as you can see that this one is already the same as this one and we don't need to do any modification. Just exit and connect to the Wi-Fi.

[00:09:27]So fir the first command here list the possible Wi-Fi the Wi-Fi detected and the next one uh connects it. So so I think I have already connected here and to test it you can just ping like a external website.

[00:09:53]Okay. So I have already connected to external uh to a Wi-Fi that has internet access. You guys can do that. Connect to your own Wi-Fi. Uh so I'm not going to do that do that part here. I'm just going to continue the process.

[00:10:07]After content connecting to the Wi-Fi, please attempt to ping external networks. So we have already I already succeeded here and usually succeeds. If it doesn't just follow these steps to navigate it and uh uh go to this config yo file and edit it in this way. It should it should be fine. And install ROS 2. We have already installed ROSS 2.

[00:10:31]Just uh follow the official website uh step by step. Uh this one is uh applies to the widest range of cases. So I really suggest follow the official website. So everything every all the preparation is done. We can get clone our this ripple.

[00:11:02]Yeah. So we can either get clone it or just transfer SCP the files from your own computer to the robot.

[00:11:16]So I'm just going to get clone it here.

[00:11:22]And if you can get clone it, uh you don't have to do the SCP. You don't have to transfer the files to the robot. So after get cloning the uh code here we have this SDK deploy and uh we can just uh remove everything here and uh I have already uh I have already removed the M20 SDK so we don't need it here. Uh that one is a different robot and we can go back go back and follow this uh this command. So we're now in the real robot and we better use our uh retro uh game pad to control it. So there's uh something we need to change here is the light SDK deploy main.cpp. CPP and this uh remote command type just use this K retro gamepad and save. Okay, so we change to that and we can just source it and compile.

[00:13:07]So after compiling we can just run this SDK service.

[00:13:15]So this service manages the transfer package and uh and it communicates with the A. So in our AP so we can just click this SDK mode and uh it talks to this SDK service and SDK service manages the transfer package and it starts getting the UDP data and publishes the ROS 2 data. So just turn this thing on and it's going to return to zero position.

[00:13:49]And we can also change the frequency here for the ROSS 2 topic frequency. Now we have a node that's getting the UDP data and publishes the ROSS 2 topic. We need we have this library node up and we're going to make the locomotion node up too. So it can get the joints data and immu data and publishes the joint data command the target joints. So this one uh is a different readme is this um library. This rei is in the library SDK deploy this rem. Okay.

[00:14:28]So what we just did here is that we have this uh this thing up.

[00:14:34]Okay. And now we need to use this node.

[00:14:40]Let's go directly to the uh SIM to real part. And this is what I just mentioned this SDK mode. Just click this thing, turn it on and uh use it.

[00:14:52]So we already have the code here. We don't have to SCP them and we just need to compile them.

[00:15:02]Of course, first source the ROS 2 environment and start compiling this ROS to this package.

[00:15:19]So the comparison has finished. We can just um run source and restaurant run.

[00:15:29]Okay. And since we we are using the gamepad, we can just click this to stand up and click this to enter IO control mode. And we can just control a little bit.

[00:15:42]Okay, it's kind of dangerous. So that that should be enough.

[00:15:47]This is a two node uh structure. ROS 2 structure is very simple and uh and this is this part is the ROS 2 migration of our previous locomotion deployment code to the ROS2 version.

[00:16:02]So we have deployed the locom motion policy the ROS2 version on the robot already and we have two nodes running the first node is the IO deploy the other node is the transfer node. Uh the IO deploy runs the local motion policy while the transfer node gets the UTP data and publish the ROS 2 data. So these two nodes are running on the same computer which is the robot. But this is not the point of this ROS 2 migration.

[00:16:27]We already have a light three IO deploy uh using UDP communication. All these nodes are just in one program. We don't have to do this RO2 migration. So the best advantage of ROS two migration is very easy to expand the hardware and expand the software structure. So we have very standard topics and we can just subscribe and publish to that topic and establish communication. So to show that show this advantage, we're going to run the uh locom motion policy that node on this Ajax Ora and we're going to mount this Ajax or on the robot and establish communication through a Ethernet cable and so one node runs here the other node is still in the robot and they can communicate still uh through this uh cable connection and in that case what if the local motion policy is already uh in an external compute. You guys can expand it even further like uh mount sensors like LAR camera to enable uh external vision for input and you can also embed some like VA large language models into the algorithm too. So this is the point of this ROS tube migration and we can just um start installing now.

[00:17:49]So the first step is this uh we need to mount the 3D print structure parts on the Ajax arena.

[00:17:56]So it we'll also open source these uh models.

[00:18:06]Okay. And we we need three type of screwdrivers here. 2 mm uh 2.5 and three. And for the Ajax ring, we need to use these two.

[00:18:26]>> Okay. So, we have mounted this on the HX3. And the next step is to mount this thing on the robot. So, we have uh three holes here. One, two, three. And um we need to use these uh three screw screws here.

[00:18:48]And for these screws, it's kind of hard to install. So, I recommend using a tweezer to Okay.

[00:19:08]Right. So, we have installed them there and And so we have mounted this thing on the robot and we need to plug in the cables.

[00:19:29]So the first cable is the power supply.

[00:19:32]Uh we need to so be careful. This uh the red is the positive and goes down the bottom. And we need to use the port in the center. the 12 volts port to power the Ajax or ring. So, this one goes here and this uh the other one goes into the Ajax or ring. And the next cable we need to plug in is the Ethernet cable. So, this one uh is so my cable is kind of long. I can go down here.

[00:20:03]This one goes here and the other ends.

[00:20:10]So this is too long. You need to and do it like this. Okay. So now we have connected the cables.

[00:20:25]So now we have mounted the Ajax ring on the robot and we are ready to uh put the locom motion policy node on this computer and the transfer node on the original robot. Okay. So uh as you guys remember we were on this uh live 3 uh SDK service. So if we look at the readme here we uh built and run it and we can uh make sure it has communication with the local motion policy node. It can establish roster communication. Now what we need to do is just uh change just change it to this computer. Right. And another thing I want to add here is that so we can make this ROSS SDK service node uh auto start on boot. So you can you just follow these command and you can check the status can manage the commands the managing commands here you can use them to control it and it after uh doing the auto start with the this node you can use the A. The a has this SDK mode uh in the in the settings part. Okay, where is it?

[00:21:42]So in the MP you can just click this SDK mode and it's going to send the uh data to the uh to send the UDP signal to the robot and it's going to start uh sending out the ROS 2 topic data and we can establish the communication. Okay.

[00:22:05]So, um I have already So, okay, let let me just shut down the robot and restart everything all again.

[00:22:20]So, first step, turn on the robot.

[00:22:27]Wait for some time to communi to connect the Wi-Fi to the robot.

[00:22:33]Right. So now have connected the game pad to the robot and go to settings here and click this SDK mode thing and it's going to go to zero position.

[00:22:46]It means that it's sending out ROS 2 topic data.

[00:22:50]Okay.

[00:22:52]And the next step is to uh go to the Ajax or so this part is a little bit complicated cuz we are not directly connecting to that. So we need to first SSH into the robot and I have manually set the IP of the Ajax or ring the Ethernet connection to be 192 1.168 1.45.

[00:23:26]So I can just uh SSH again the name.

[00:23:41]Okay, now I'm in the Ajax array. So in the Ajax ar you just uh get clone this ripple again or maybe you can just SCP to the robot and compile compile again.

[00:23:55]So just follow the sim to rule part SSH into it get clone it or you can SCP uh source the ROSS to environment and compile.

[00:24:09]So yeah, I let me just go in here, remove everything and start again.

[00:24:31]So my AJ is uh Ubuntu 222 and I have installed ROS to humble here. The step is the same as installing ROS 2 on the live 3 robot. Uh just follow the official commands step by step.

[00:24:57]Source it and compile.

[00:25:14]So as a reminder, right now we have already started the transfer node on the robot, right? So we click that SDK mode, it's up and um uh now we need to start the locomotion policy node. So what we just did here the SDK service is managing the live three transfer node right. So uh it receives a UDP signal from the app and starts the live three transfer node. So this is what it's been doing.

[00:25:44]Right now we are trying to compile and uh start running the locomotion policy node. So compilation has finished. We can just source it and just rust to run.

[00:25:57]Okay. So we are still using that and let me push a little bit far from me and click this button to uh go up and click another button to enter a control mode. The specific button are uh in the read me and also you can check the our uh quadripad locom motion from beginner to pro series video and we can let it move a little bit. Okay. So, it's kind of dangerous on on the table. Oh, okay. So, yeah. So, you guys can see that this is working and we're just not going to test a little bit too much. So, just let it go down. And this part is search. So, uh we can also check the ROS two structure here. So let me just So uh if we just rush to top of list we can see there's a game pad data that's coming from the ATP the gamepad the IMU data joints command and is what the locomotion policy sends to the robot and the joints data and I'm data are the data that robots send into the locomotion policy from the license three transfer node right so if we rush to node list we can see that there's three nodes uh the structure is exactly the same as here we have this light uh retrain game pad that's ob getting the data from the gamepad the IO deploy the local motion policy and the I3 I3 is the transfer node is getting data from a low level.

[00:28:17]So this will be the roster two migration of our local motion deployment uh no code and the the point of this roster migration is we can easily expand the hardware add something else and use that to control the robot.

[00:28:35]So this will be the end of this video and let me summarize a little bit. So previously uh maybe you guys would think that the robot is already a complex system that you can do everything here.

[00:28:46]It has sensors, it have motors to uh mobilize to be mobilized and he also has a computer built inside is necessary.

[00:28:54]But that is actually wrong. Robots is only a component of a complex system.

[00:29:00]And the whole point of this rosty migration and this video is to show you guys how to actually make it a component and it gets the low-level data IMU and joints and publishes as a standard ROS2 topic. So it can be added to another complex system and in our complex system we mounted another external compute and it we are able to establish communication and use it to build a bigger uh system not just this robot. So this uh kind of way of thinking is a crucial step towards advanced robotics.

[00:29:37]So advanced robotics is not something someone sell or someone that's already been built. you need to build it yourself. So we uh propose to give a component and you can buy this component and buy something else and build a more complex system. Maybe you can have two robots, you can have three robots or you can have a robot and a drone that can uh move together. So to build a more complex system as advanced robotics, it is necessary to think of a robot as only a component and in and this is the most important uh takeaway for this video to uh how to modulize this robot and use it in a more complex system. So if you have further questions you can join the discord server uh and also you can contact our technical support team and um good luck with your own development.

[00:30:32]Thank you.