in this tutorial, you will learn how to write a life cycle node with Ros 2 and Python. I will first use a real-life example to explain what life cycle nodes are, and then we will directly dive into the code. You will write your own node and trigger the life cycle transitions from the command line. And just before we get started, note that I have a complete course with much more details where you also learn how to create a life cycle node manager, how to add life cycle nodes to launch files, write C++ life cycle node, etc. You can find the link in the description below. And now let's get started. Before I explain what life cycle nodes are and what different callbacks you need to implement in your code, let's actually understand why you need them and also when to use them. And let's start with an example that could be a real use case. Imagine you are writing a node to read images from a camera and to publish those images to a Ross topic. What you would do in the code is to create the Ross to topic and other Ross

Communications. Then you would initialize the communication with the camera, maybe do some calibration, and then when everything is ready, you can enable the camera and start a ROS timer, for example, to publish the images on the topic at a given frequency. And all that would be started somewhere in the constructor of the class or just after you call the constructor. Nothing wrong with this, but now maybe you want to be able to easily enable or disable the camera and thus stop and start publishing on the topic. Also, you could want to connect or disconnect the camera, handle communication issues, change parameters for the camera or the topics, and this while the node is running. That's completely possible, and you can implement some custom logic in your code to do that. In the end, it will look like a kind of a state machine. And the good news is life cycle nodes are actually made for this purpose. They contain a state machine that will allow you to easily separate your code for different parts of initialization or activation. Then you can easily switch between those states. And let's now see what is a life

cycle node with its state machine. As I explained the state machine, I will continue with this camera example so you have a better idea and a better understanding. So here is the official state machine that you can also find on the official documentation. I'm going to come back to this later, but for now let's actually do a simplified state machine and let's build it step by step. So when you have a normal node, well, a normal node doesn't have different states, okay? You just start the node. So the constructor will be called. In the constructor, you initialize everything, and the node is kind of already active. Now, with a life cycle node, you have different states that correspond to different life cycles of the node. And the first state that we're going to enter when we start the node is the unconfigured state. So in this state, the node will be, well, as you can see, unconfigured, which means that the communication with the hardware and also any ROS communication like topics, services, actions, etc., are not configured. Then we will have a transition between

the unconfigured and the inactive state. And here to do this transition, we have this unconfigure callback. Okay, so that's going to be some function. So there's going to be a callback in your code that will be called so that you can actually configure your node. And what do we do in this unconfigure? For example, with the camera, well here we would create the ROS topic. We might also initialize the hardware communication. Okay, to make sure we can connect to the camera and maybe do the calibration. Okay, so after we are done with this unconfigure, as you can see, the topic is created. So we don't publish on it, but it's created and the hardware is ready. The hardware is configured. Now we are in the inactive state. So inactive means configured but not active. We will need to trigger a sign transition. That's going to be unactivate. Okay, and what do we do in this transition? Well, we will enable the camera and maybe start the ROS timer so that after the unactivate, the node will be in the active state. And while it is

in this active state, while the camera is enabled and configured, the publisher is ready, and the timer is ready so that we can start to publish the data from the camera. Okay, and here we don't need to worry about initializing hardware or anything else because that's already done in the previous state. And then the good thing about this state machine is that let's say the node is in the active state, so publishing the images on topic, you could call on deactivate so that you deactivate the node. And here basically you would do the opposite of what you do in unactivate, so you would disable the camera, maybe stop the ROS timer. Okay, so the node goes back to the inactive state. It is still configured but it's back to being inactive. And then from inactive, as you can see, you can go back to active by just calling unactivate again, or you could decide to clean up, which means you go back to the unconfigured state. And when you clean up, you're going to destroy the ROS to communication. So here the ROS to topic, you're going to stop.

the hardware communication so you can see you can go back from active to inactive, and from inactive to unconfigured. And here you have the three main states of the life cycle note, and there is one more state, the finalized state. So basically, when you want to stop the node, there is this unshut down callback that's going to be called, and you can call unshut down from any other state. And here's what you do: well, you're going to basically deactivate and clean up everything so that the node can arrive in a finalized state, which means then, well, the node is not doing anything, and we can just stop it. There is another state as well to handle errors, but we're going to see that a bit later. For now, you can see that a life cycle node will start in an unconfigured state, and then you have some transitions to go to inactive, to go to active, and also to shut down the node. And we are now going to write the code for a life cycle node in Python. And so I'm not going to start

from scratch, I'm going to start from a node that I've already written here. So that's a very basic node, okay. So what I have done is I have created a ROS to workspace. Then I have created a Python package named lifecycle tutorial. Okay, so if you want to follow, you can do the same. And then I have created a file lifecycle test.py. I have put this file as an executable file. And in this, I have just written a basic node. So the minimum code for a node, you can see from a node. I use the normal node object here, the normal node class. And I create a class here, my node. Okay, so the name of the node here is my node. In the main, what I do is I just initialize ROS to communication. I start the node. I make it spin. And finally, I shut down ROS to communications. So this is the setup. Nothing really complicated. And I'm starting from this very simple code so that it's going to be easier for you to adapt any other node with lifecycle.

nodes. So, what we are going to do here, we are going to first adapt this node to be actually a life cycle node, and then to implement the transition callbacks. And after this, we will build the node, start the node, and then from the terminal, we will use the ROS 2 life cycle command line tool to trigger the different transitions and see when the callbacks are actually called. All right, and at the end of this tutorial, I'm also going to give you some additional information on when it is actually a good idea to use life cycle nodes. Okay, let's get started with the code. The first thing is actually to use a life cycle node instead of a node. So here we use the basic node class instead. We will need to use, so we will need to import from rclpy. And we have something called life cycle. So, life cycle import life cycle node. Okay, so I really encourage you to use the auto completion here. For example, with VS Code and the ROS extension. And we have life cycle node. So then what I will do is simply instead of

inheriting from node. I will inherit from life cycle node. Then the way to create the object here is the same. Okay, the way to make the node spin is the same, so nothing else to change for now. We just need to inherit from life cycle node instead of node, and I'm just going to remove this import here. All right, so now we have a life cycle node, and we can do all of the transitions, but because we don't have any callback implementations, well, nothing's going to happen. So let's come back to actually this image here. The node is going to start in the unconfigured state. To go to inactive, we will go through the unconfigure callback. So let's actually do an unconfigure callback. We're going to add a new method in the class, and I'm going to call it on configure. You can see I even have the autocompletion, and if I press tab here, well, we have a bunch of stuff. So you can see that we're going to receive a state that's going to be a life cycle state so

it's going to be the previous state before you get to the call back. So in this case, for example, if we are in unconfigured and we call unconfigure, we will know that the previous state was unconfigured. And then it's going to return. So we need to return a transition call back return. So make sure that if you don't have the auto-completion, you add those to the Imports here. Okay, I'm just going to remove this. Well, we could leave it, but just to have a bit less code. And I'm going to do things a bit differently in the Callback. So first, before we add any functionality, I'm just going to put a log self. Get logger with info. And I'm just going to put in on conf. Okay, so just to know that when we are in this callback, I'm going to see this log. Okay, so it's going to help us to introspect the node. And then I need to return. I need to return what. I need to return a transition call back returns. That's what I have imported here.

dot. Then you can either return success or error or failure. We're going to keep success for this tutorial. Okay, to keep things simple. So what we're saying here is we just print log. We return success, which means that after unconfigure, then the node will be in the inactive state. Okay. Then another callback we can implement now is on cleanup. So I'm going to implement on cleanup. If we want to go back from inactive to unconfigured. So we'll do def on cleanup. And you can see we also have the auto completion here. I'm just going to remove that. And also I'm not going to use this. I'm just going to put self.get_logger.info within on cleanup. And then I also return the transition callback return success. All right. So as you can see, the minimum code to implement the callback is very easy. Next callback, let's go back here. Well, now that we have implemented those two, we can implement the unactivate and the und deactivate. Okay. So unactivate to go from inactive to active and unactivate

to go back from active to inactive so let's do those Def unactivate and you can see all the callbacks will have the same definition here the same parameters and the same WR so we get the previous state which is a life cycle State and we need to return a transition call back written now for on configure and on cleanup you could see that I would return directly the transition cbag return return but for on activate I'm going to call the super okay and I'm going to come back to this in just a few minutes here I'm going to do self. getet logger info in on activate. Okay so we can easily introspect and then I return super unactivate so super actually we're going to call the unactivate from the life cycle node class itself and this is going to return a transition call back return so that's no problem and then I do the def on deactivate same and I will put a log self dot get loger info in deactivate so un deactivate great now the last one we

have is UN shutdown so from any other state, we can call Un shutdown to go to finalized so I'm going to also do def on shutdown. You can see the same thing and for this one, I'm going to do it myself. I'm going to do self dot get logger info in on shutdown and uh return transition call back return dot success. There is one last call back that I didn't put here is the on error, but I'm going to skip it for now and anyway this callback is not so important and not working so well so I'm going to keep those five callbacks okay fine. So as you can see when you have a life cycle node, then you can implement so basically you can override those callbacks. It's actually not mandatory okay you can skip some of them if you want you could just decide to have the unactivate and UND deactivate okay in this case you just remove the UN configure on cleanup okay it doesn't really matter if you remove the implementation the default implementation is going to be called.

from the life cycle node itself. All right, and here we haven't really done anything. We just added a log. Okay, so we don't have any other functionality, just a log. Actually, I'm going to add another log to here. `self.get_logger().info` in Constructor. Okay, so we can know when we start node, we are in the Constructor, and then we are here, here, etc., etc. Now before I try this code, I'm actually going to add a few things because, well, with this code, it's just going to print in `on_configure` when we transition with this callback, etc., so it's not really interesting. Here, I will add a simple publisher with a timer. So let's say we want to publish a number at a given frequency. So I'm going to use a publisher with a timer and to see how we can actually implement that inside the life cycle node. And I'm going to use, so for the message, I'm going to use, for example, `interfaces.MSG` import `int64`. So you probably already know this one.

a basic integer number. We don't want to make things complicated here with the data type. Just use something simple. And then to create the publisher, usually what you would do is you would just do self. Pub. For example, here is equal to self. And then create publisher. Okay, but we are not going to do this in a life cycle node. So I will just create a pub that I will put to known here. So an undefined Pub attribute. And then in unconfigure. So if you remember, we're going to configure the rust two topics and rust to communication in unconfigure. So we are going to create those. So in unconfigure, after this log and before we return, I will do self. Pub is equal to self. Dot create. And actually not create publisher in a life cycle node. For Python, we have create life cycle publisher. So I will create a life cycle publisher. And then well, the way to create a life cycle publisher is the same as a normal publisher. So we put the type. So int 64. Then then we put the topic name. So it's

going to be number, and then we put a q size. I'm going to put 10 just like that. And here we have a life cycle publisher. So note that when you just run the node here, it's going to be in the unconfigured state, so the publisher will not exist. The publisher will only exist after you have called unconfigure. So when the node is in the inactive state, then you will be able to find the publisher. And what I will do is basically everything I do in on configure, I will do the opposite in on cleanup. Okay, as you can see here, you want to do the opposite. So what do I do in on cleanup? Self dot, and there is a method here, destroy um life cycle publisher with self dot. So I create here, I destroy it here, as simple as that. Now, before I create the timer, I'm just going to create a method here. I'm going to call def publish number, um, self. Just a method to publish the number using the well, the publisher we have created here. So let's do message

is int 64 uh message. data is going to be. Let's just hard code and let's say we want to publish the number five. Okay, it's not really a problem here. And then self dot Pub do publish with the message. And maybe maybe we can also add log here. Self do get logger doino. Let's say publish number so we know when we publish the number. All right. Now I'm going to create a timer. So to create a timer what you know so far is you do self. timer like this for example is equal to self. create U timer. And then as soon as you create the timer well it's going to start to call. For example if we give this as a call back. It's going to start to call this at the frequency that you give. So what I will do is I will do as I did for the publisher. I will just initialize the timer to undefined. So we actually don't create a timer in the init. I'm going to create a timer in on configure. So I will do

self.timer is equal to self do create timer. I need to give a period in second, let's say one second, and the callback is self.publish number. But then, if you remember well, with unconfigure, we just want to configure stuff and then it's still inactive. So, we don't want to publish right away. We don't want to start the timer right away. So, what I will do is I will just do self.timer do cancel. So, I create but I cancel it right away. So, it's not going to call this callback. And then what I will do is here, we're going to go here in inactive. When we go to unactivate, I will actually activate the timer. So, in unactivate here, I will do self.timer do reset. Okay, when you do reset, you restart the timer. And cancel, you stop it. So, this way, the timer here is configured but not working. And here, it's activated. Okay, so we have a two-step process. And of course, everything I do in unconfigure, I kind of need to undo it in unclean up.

everything I do in unactivate, I'm going to undo it in onactivate. So let's do that. So unconfigure, we create the timer. In oncleanup, I'm just going to destroy the timer. So self.destroy timer, self.timer. So after I destroy a timer, it's not going to work anymore. And then in UND deactivate, well, if I just restart the timer here, I will just do self.timer.do, uh, not reset, but cancel. So I don't destroy the timer, I just cancel it. And as you can see, it's not so complicated. Everything you do in unconfigure, you try to undo it in oncleanup. And the same thing between activate and deactivate. In addition to that, well, with the onshutdown, you can see that we also want to, well, deactivate and clean up stuff. So here in unshutdown, well, we have a publisher and a timer. So basically, we could just do the same thing as in oncleanup. So I'm going to take those two lines here and say that we destroy the publisher and we destroy the timer. And that's going to be

pretty much it. Now, one thing to note also is I'm going to come back to this. Why do I call the super unactivate and super unactivate? Because you can see we have it's not a normal publisher, it's a life cycle publisher. So, a life cycle publisher is actually not going to publish. So, even if you try to publish, even if you really publish stuff when you are still in the inactive state, the life cycle publisher is not going to work. So, you will have nothing published on the topic even if you use the publish method, okay? And when you do unactivate and you call the super unactivate, it's actually going to activate all of the life cycle publishers that you have in the note, okay? So, that's important to call the super here. And in unactivate is going to deactivate the life cycle publishers, okay? So, make sure that you use those two here in unactivate and deactivate. All right, now let's try this. So, I'm going to go to my setup.py here and I'm just going to add an execute

table here. So let's say lifecycle um test is equal to. So the package is lifecycle tutorial. Do lifecycle test. That's the name of the file and the function is the main. Let's go in the terminal. Let's go to the workspace and I'm just going to do a c on build. All right. So we have this normal uh warning here but the package has been finished. Let's source and now I can do Rust to run lifecycle tutorial with lifecycle test. And as you can see now we have in Constructor. So I'm going to open two new terminals here. So we just have in Constructor which is kind of normal because in the main we create the node we make the node spin. So you can see when we create the node we're going to run the code that's right here but anything else here has not been triggered okay. And if I do Ros to node list so I have my node um if I do rose to topic list you can see I don't have so I have

some existing topics but I don't have the number topic all right. It's not here yet. It hasn't been created. So then I will use the ROS to life cycle common line tool and you can do ROS to life cycle nodes. That's going to list the well the nodes that are actually life cycle nodes. So here you can also find my node and then you have different keywords. So ROS to life cycle if I do tab twice you can see the different keywords. I'm going to use the set keyword here. So set and then I put my node and then I will need to give a verb and the verb is easy. Here you have on configure on clean up activate deactivate shutdown. So you just take the configure here clean up activate deactivate and shut down. So I'm going to put configure like this. I'm going to press enter and let's look at what's going to happen. So transitioning successful we went to the Callback un configure. So with we have run this code and you can see we are in configure here. So in the terminal you can see in on

configure now if I do Ross to topic list you can see I have my number topic. So the topic is created, the timer is also created. We have cancelled it. And if I do r two topic Eco number, well you can see nothing is being published for two reasons. First reason is because what? Because we have canceled the timer. But even if we didn't cancel the timer and even if we were publishing something, as the life cycle node is not activated yet, then nothing is going to be published. Okay, now what I will do is I will activate the node. So I will do activate. And let's look at what's going to happen. You can see an activate and then publish number every second. Because now, now the so the timer has been reset here, which means we're going to run this every second. And also the publisher has been activated. So if I go back here, you can see we have publish number and we have the data coming on the number topic. Now if I do deactivate, you can see we are in on deactivate and we stop receiving data.

here from the topic. Okay, the topic is still here. We can still listen to it, but we stop receiving data. Okay, so what we have done so far is to go from here to here to here and then back to inactive. When we are inactive, I can do a loop like this again so I can activate. You can see in unactivate, we get the data again and then I can deactivate again. Okay, the node stays configured and now I'm back to inactive again. From inactive, I can go back to unconfigure if I want. So just to show you ROS 2 topic list, the number topic is still here, but now if I do cleanup, okay, you can see on cleanup. And if I do ROS 2 topic list, the number topic is gone because in on cleanup, we have actually destroyed the publisher. Okay, so that's how you can actually trigger the different transition and the different callbacks and know that you have to provide a correct transition. So for now, well, we are back to the unconfigured state. So the only transition you can call are configure and shut down.

if I try to call activate from here, so activate, it's not going to work, okay, because you can see we can only call configure and shut down. So actually it's called shutdown and you can see in on shut shutdown. And now the thing is with shutdown, you can do well you are in finalized State and you cannot do anything else, okay. So this is just for kind of introspection purposes. The only thing you can do right now is basically just uh kill the note. So contrl C and we kill the note, all right. And you have successfully written your first life cycle node with the different Transitions and you also know how to trigger the transitions with the Ros to life cycle common line tool. And just to finish here, I'm going to give you more information on actually when to use those life cycle nodes and some best practices here. So one very common use case is if you are using some Hardware. So that was the example I gave you at the beginning of this tutorial. So let's say you're initializing some hardware.

for a camera well in unconfigure and un cleanup, you would initialize the communication with the hardware. Okay, so right here, you could configure the hardware, and also you would configure the ROS to communication. If you have anything that would take time or anything that will allocate a lot of resources, then probably try to do it in unconfigure. Okay, so that's where you initialize the hardware. In unactivate, you're going to just activate stuff. So for example, if you are controlling a motor, then the communication with the motor is set up here. And then in unactivate, you will just activate the torque of the motor. Okay, so then you can control it. And also, this is going to activate the Publishers, so the life cycle Publishers that you have, not that for anything else like a subscriber, a service server, an action server, there is no really a life cycle version of those. Okay, those are going to be normal subscribers, etc. It's just for life cycle Publishers. Okay, you have this specific thing about activating them in the unactivate. So here you configure the hardware, you also allocate stuff that

will take a lot of memory, and you set up Rost to Communication in this phase here on activate and deactivate. It's going to activate the Publishers, and you may also activate the hardware that you have previously initialized. So using life cycle node is actually a good idea if you want to have more control on the order of initialization for your Hardware. Okay, so you can easily separate the different parts of initialization. Another good point is if you want to synchronize several nodes. Let's say you have three nodes that are controlling three pieces of Hardware. Maybe you want to first initialize all the hardware and then to activate them at the same time. Well, you can have three life cycle nodes, and then you're going to call the on configure for each node and make sure that you wait until all the nodes are in the inactive state. And then once all the nodes are in the inactive state, you can just activate them all, and this is going to be super quick. And then you can achieve a good synchronization between nodes. Then well to finish here one thing

you need to know is that life cycle nodes are actually used a lot already in ROS. Specifically in Stacks like navigation tool or ROS control. Okay, life cycle nodes are used everywhere, all right. And that's the end of this tutorial on ROS life cycle nodes. I hope you enjoyed it. And if you like the way I teach, then you will definitely love this complete 14-hour course in which you learn the most important ROS intermediate and advanced concepts. ROS actions, life cycle nodes, executors, and components. The part on life cycle nodes itself is almost 3 hours, so you will get much more details. For example, you will see how to create a life cycle node in C++ and how to use a life cycle node manager and launch files so you don't need to do the transitions by yourself on the terminal. All right, thank you for watching and I hope to see you in the course.

ROS2 - Lifecycle Node Tutorial

Learn how to program robots - step by step.
Arduino, Raspberry Pi, ROS, ROS2, etc.