{"id":7668,"date":"2022-02-22T04:18:48","date_gmt":"2022-02-22T04:18:48","guid":{"rendered":"http:\/\/fastbitlab.com\/?p=7668"},"modified":"2023-08-29T15:35:23","modified_gmt":"2023-08-29T10:05:23","slug":"fsm-lecture-46-run-to-completion-and-qp-framework","status":"publish","type":"post","link":"https:\/\/fastbitlab.com\/blog\/fsm-lecture-46-run-to-completion-and-qp-framework\/","title":{"rendered":"FSM Lecture 46- Run-to-completion(RTC) and QP\u2122 framework"},"content":{"rendered":"
\n
\n
\n
\n

 <\/p>\n<\/div>\n

\n

Run-to-completion(RTC) and QP\u2122 framework<\/strong><\/span><\/h1>\n
\n
\n
\n

 <\/p>\n

<\/div>\n

 <\/p>\n<\/div>\n<\/div>\n<\/div>\n

The make an event code generates the event(it’s an event producer code). And the event producer sends the event to the event dispatcher function, and then the dispatcher function post that event to the state machine. And the state machine executes the behavioral action of that event. And then, the state machine returns to the event dispatcher, and then the event dispatcher returns to the super loop. That is our Arduino loop function. <\/span><\/p>\n

We can summarize the whole step like this, as shown in Figure 1.<\/span><\/p>\n

\"Figure
Figure 1. Run-to-completion(RTC) pattern<\/span><\/figcaption><\/figure>\n

 <\/p>\n

First, the code checks whether the event is available or not. And then if an event is available, then a post the event to the state machine. State machine executes the actions associated with that event, and then state machine returns back to the super loop. This is the run to completion pattern or RTC pattern.<\/span><\/p>\n

Run-to-completion(RTC):<\/b><\/span> Processing of the current event must finish first, before processing the next event.<\/span><\/span><\/p>\n

If you use the run-to-completion paradigm, you should not put any blocking code (e.g., delay()) anywhere here, violating the rtc paradigm.<\/span><\/p>\n

\"Figure
Figure 2. Run-to-completion(RTC) paradigm<\/span><\/figcaption><\/figure>\n

 <\/p>\n

The implementation of UML state machines follows the run-to-completion paradigm. Figure 2 shows what the specification says.<\/span><\/p>\n

Please remember that the UML StateMachines should be implemented in a run-to-completion fashion. <\/span><\/p>\n

 <\/p>\n

The event-driven + rtc paradigm provides better power efficiency. When the events are absent, you can utilize the MCU low power modes to put the microcontroller to sleep and make MCU active only during the execution of an rtc step.<\/span><\/p>\n

Figure 1 shows the RTC step. When the rtc step is completed, the microcontroller can sleep until another event wakes it up.<\/span> <\/span><\/span><\/p>\n

We need an event processor code to solve hierarchical state machines or implement the hierarchical state machines. The event processor solves the traversal of nested hierarchical state machines. I mean, it traverses through various states, which are nested inside the hierarchical state machine, and it calls the appropriate state handler. It takes care of executing various transition sequences as per the UML specification. For all this, we need a background event processor.  <\/span><\/p>\n

We used a flat state machine in the previous exercises and didn’t use any event processor. A generic code processes the calling of various state handlers and solves various state transitions as per the specification.<\/span><\/p>\n

When you start using the nested hierarchical state machines, it will become tedious to implement various state traversals and maintain the execution of transition sequences. Everything by yourself. That’s why you have to go for some framework or use some generic event processor code, which can help you implement the hierarchical state machines in your project. <\/span><\/p>\n

That is why, in this article, I’ll be introducing QP real-time embedded framework and  QM tool by Quantum Leaps, LLC. And this is a famous framework, and it also comes with a graphical modeling tool called QP Modeler. And this is quite famous in the field of modern embedded system programming using event-driven architecture.<\/span><\/p>\n

You can explore more about this with these links.<\/span><\/p>\n

Quantum Leaps<\/span><\/a><\/span><\/p>\n

QP real-time embedded frameworks (RTEFs)<\/span><\/a><\/span><\/p>\n

Licensing and Pricing<\/span><\/a><\/span><\/p>\n

We want to thank Miro Samek, the founder and the CEO of Quantum Leaps, LLC, for giving us permission to use the QP framework and its associated components in this course. You will be using the QP framework, QP modeler tool, QHSM Event Processor, and QP Nano Arduino Library to implement that event-driven hierarchical state machine projects. <\/span><\/p>\n

 <\/p>\n

QP\u2122 real-time embedded frameworks (RTEFs) and QM\u2122 modeling tool by Quantum Leaps, LLC<\/span><\/p>\n