{"id":7078,"date":"2022-02-02T08:26:22","date_gmt":"2022-02-02T08:26:22","guid":{"rendered":"http:\/\/fastbitlab.com\/?p=7078"},"modified":"2023-08-08T15:16:47","modified_gmt":"2023-08-08T09:46:47","slug":"fsm-lecture-24-exercise-003-nested-switch-implementation-of-an-fsm-part-1","status":"publish","type":"post","link":"https:\/\/fastbitlab.com\/blog\/fsm-lecture-24-exercise-003-nested-switch-implementation-of-an-fsm-part-1\/","title":{"rendered":"FSM Lecture 24: Exercise-003 Nested switch implementation of an FSM part 1"},"content":{"rendered":"
\n
\n
\n
\n

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

\n

Exercise-003 Nested switch implementation of an FSM part 1<\/span><\/strong><\/h1>\n
\n
\n
\n

 <\/p>\n

<\/div>\n

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

In this article, let\u2019s continue the coding. Write one function to implement a state machine.<\/span><\/p>\n

Go to the file \u2018protimer_state_mach.cpp\u2019, and let\u2019s create a function.<\/span> <\/span><\/span><\/p>\n

event_status_t protimer_state_machine(protimer_t *mobj, event_t  *e){\r\n     switch<\/span> (mobj->active_state){\r\n         case<\/span> IDLE: {\r\n             protimer_state_handler_IDLE(mobj,e);\r\n          }\r\n         case<\/span> TIME_SET: {\r\n              protimer_state_handler_TIME_SET(mobj,e);\r\n}<\/pre>\n
protimer_state_mach.cpp<\/span><\/span><\/p>\n
The function is a protimer; I will call this <\/span>protimer_state_machine<\/b>. This state_machine will receive <\/span>protimer_t<\/b>; its main application object is <\/span>mobj<\/b>. And the state machine also receives the event. And the generalized event structure is <\/span>event_t<\/b>, a pointer to the event structure. <\/span><\/span><\/p>\n
And here we are using a Nested switch. Let’s use the switch case to switch between different states. <\/span>switch (mobj->active_state).<\/b><\/span><\/p>\n
Now, let’s implement the different cases\u2014<\/span>Case IDLE<\/b> (the first active_state IDLE). If the case is IDLE, then let’s call one state handler function here,<\/span> protimer_state_handler_IDLE<\/b>. And for this, we have to send ‘<\/span>mobj<\/b>‘ and<\/span> ‘e’<\/b> (the received event) like you have to implement in different cases. So, one case for each state of the state machine. And inside the <\/span>protimer_state_handler_IDLE()<\/b> function, you have to implement one more switch case, which switches between different events to take different actions.<\/span><\/span><\/p>\n
And we will use the <\/span>\u2018return\u2019<\/b> type to return the status of the event handling. The status could be whether the event is really handled or ignored or caused any transition. That\u2019s why I will use <\/span>\u2018event_status_t.\u2019<\/b> Each event handler should also return the event status. Like this(as shown above), you implement different cases for different states.<\/span><\/span><\/p>\n
 <\/p>\n
\"Figure
Figure 1. Implement code for individual State handlers<\/span><\/figcaption><\/figure>\n
 <\/p>\n
And now, let\u2019s implement for individual State handlers. The first individual state handler is <\/span>protimer_state_handler_IDLE<\/b>. They receive a pointer to the main application object(<\/span>mobj<\/b>) and a pointer to the event, and this individual state handler returns the <\/span>event_status_t<\/b>.<\/span><\/span><\/p>\n
The first state handler is an IDLE state. IDLE state processes various signals. Increment time, a TIME_TICK, START_PAUSE, etc., It also has an Internal activities Entry and Exit. We will also treat them as signals for the implementation purpose. We will call it an Entry event, an Exit event. <\/span> <\/span><\/span><\/p>\n
Let\u2019s use one more switch case. That\u2019s why it\u2019s called a Nested switch. First code snippet shows the upper switch, which is to switch between different states of the state machine, and  second ccode snippets shows the inner switch is to switch between different signals the state processes.<\/span><\/p>\n
switch(e->sig). <\/b>We have to implement one case for each signal, the state processes. Start with ENTRY. We are not using the <\/span>‘break’<\/b> statements because we have to return the status of the event handling. <\/span><\/span><\/p>\n
And one more case for EXIT, one more case for Increment time (INC_TIME), one more case for START_PAUSE, one more case for TIME_TICK. Like that, you have to complete another state handler’s implementation.<\/span><\/p>\n
 <\/p>\n
Let’s define the event_status_t.<\/span><\/p>\n
typedef enum<\/span>{\r\n    EVENT_HANDLED,\r\n    EVENT_IGNORED,\r\n    EVENT_TRANSITION\r\n}event_status_t;\r\n<\/strong><\/pre>\n
Implementation of event_status_t in main.h<\/span><\/p>\n
Go to the main.h, and here create a <\/span>typedef enum<\/b>. The status is <\/span>EVENT_HANDLED, EVENT_IGNORED,<\/b> and <\/span>EVENT_TRANISTION<\/b>. This indicates the status of event handling; After that, <\/span>event_status_t<\/b>.<\/span><\/span><\/p>\n
 <\/p>\n
As per our diagram, the ENTRY action is c_time=0 and e_time=0.  <\/span>mobj->curr_time=0; mobj->elapsed_time=0;<\/b> And after that, display time. We will use one helper function called <\/span>display_time(0); <\/b>After that, <\/span>display_message(\u201cSet time\u201d).<\/b> That\u2019s the Entry action. After completing the Entry action, it should <\/span>return EVENT_HANDLED<\/b>. <\/span><\/span><\/p>\n
event_status_t protimer_state_handler_IDLE(protimer_t *mobj, event_t  *e){\r\nswitch<\/span>(e->sig){\r\n    case<\/span> ENTRY:{\r\n          mobj->curr_time = 0;\r\n          mobj->elapsed_time = 0;\r\n          display_time(0);\r\n          display_message(\"Set\",0,0);\r\n          return<\/span> EVENT_HANDLED;\r\n         }<\/pre>\n
Entry action implementation  in protimer_state_mach.cpp<\/span><\/span><\/span><\/p>\n
It has to return the status( as shown below).<\/span><\/p>\n
event_status_t protimer_state_machine(protimer_t *mobj, event_t *e){\r\n     switch<\/span> (mobj->active_state){\r\n         case<\/span> IDLE: {\r\n               return<\/span> protimer_state_handler_IDLE(mobj,e);\r\n         }\r\n         case<\/span> TIME_SET: {\r\n               return<\/span> protimer_state_handler_TIME_SET(mobj,e);\r\n         }<\/pre>\n
return the status in protimer_state_mach.cpp<\/span><\/span><\/span><\/p>\n
 <\/p>\n
Next, let\u2019s implement the EXIT case.<\/span><\/p>\n
 case<\/span> EXIT:{\r\n      display_clear();\r\n      return<\/span> EVENT_HANDLED;\r\n }<\/pre>\n
Exit action implementation in protimer_state_mach.cpp<\/span><\/span><\/span><\/p>\n
 <\/p>\n
And after that, Increment time. Increment time it has to add 60 seconds to c_time.  <\/span>mobj->curr_time += 60; <\/b><\/span><\/p>\n
The increment time causes the Transition, <\/span>mobj->active_state=TIME_SET<\/b> (the new state is assigned to active_state<\/span>); <\/span>return the status as <\/span>EVENT_TRANSITION<\/b>.<\/span><\/span><\/p>\n
 case<\/span> INC_TIME:{\r\n    mobj->curr_time += 60;\r\n    mobj->active_state = TIME_SET;\r\n    return<\/span> EVENT_TRANSITION;\r\n }<\/pre>\n
INC_TIME implementation<\/span><\/p>\n
 <\/p>\n
Next START_PAUSE. For START_PAUSE, there is no Action, just a Transition. <\/span><\/span><\/p>\n
mobj->active_state = STAT;<\/b> here also return the status as  <\/span>EVENT_TRANSITION<\/b>. <\/span> <\/span><\/span><\/p>\n
 case<\/span> START_PAUSE:{\r\n      mobj->active_state = STAT;\r\n      return<\/span> EVENT_TRANSITION;\r\n }<\/pre>\n
START_PAUSE implementation<\/span><\/p>\n
 <\/p>\n
The next one is TIME_TICK. The TIME_TICK is the Internal Transition. So, there is a Guard. How to implement this? You have to access the sub-second field of the event. The TIME_TICK implementation is shown below.<\/span><\/p>\n
   case<\/span> TIME_TICK:{\r\n        if<\/span>(((protimer_tick_event_t*)(e))->ss == 5){\r\n           do_beep();\r\n           return<\/span> EVENT_HANDLED;\r\n        }\r\n        return<\/span> EVENT_IGNORED;\r\n   }\r\n\r\n }\/\/END OF SWITCH<\/span>\r\n\r\n return<\/span> EVENT_IGNORED;\r\n}<\/pre>\n
TIME_TICK Implementation<\/span><\/p>\n
If(protimer_tick_event *)<\/b> you have to typecast the pointer, you must access the ‘ss’ field. If it = 5, then you have to call <\/span>do_beep();<\/b> then you have to return <\/span>EVENT_HANDLED.<\/b><\/span><\/p>\n
Suppose, if this condition fails, then you return <\/span>EVENT_IGNORED<\/b>. This is the end of the switch case. If this state receives any other event, then it is ignored. That’s why at the end, you return <\/span>EVENT_IGNORED <\/b>by default. <\/span><\/span><\/p>\n
That’s the implementation of the handler of the state IDLE. Likewise, you have to implement similar functions for other states.<\/span><\/p>\n
 <\/p>\n
\"Exercise-003
Figure 2. Helper functions implementation<\/span><\/figcaption><\/figure>\n
 <\/p>\n
Look at Figure 2; These are helper functions to implement our actions. We will implement that at the end. <\/span><\/p>\n
The first helper function is display_time. And after that, display_message, so this is a string value. \u2018String\u2019 is a user-defined data type provided by the Arduino framework to represent string values. I will use String s. After that, do_beep(). <\/span><\/p>\n
 <\/p>\n
Now you give the prototypes of these functions as shown below.<\/span><\/p>\n
#include<\/span> \"main.h\"\r\n#include<\/span> \"lcd.h\"\r\n\r\n\/\/prototypes of helper functions<\/span> \r\nstatic void<\/span> do_beep(void);\r\nstatic void<\/span> display_clear(void);\r\nstatic void<\/span> display_message(String s);\r\nstatic void<\/span> display_time(uint32_t<\/span> time);<\/pre>\n
Prototypes of helper functions<\/span><\/p>\n
Provide the prototypes of those helper functions. And after that, you have to provide the prototypes of state handlers functions as well. So, let\u2019s make them static because these are private to this file. All functions you can make it as static, no problem. <\/span><\/p>\n
 <\/p>\n
\"Exercise-003
Figure 10. Const representation<\/span><\/figcaption><\/figure>\n
 <\/p>\n
Look at Figure 3; mobj is a const pointer, pointing to variable data. Data can be modified. But this pointer cannot be modified. That\u2019s why, as a best practice, you can use \u2018const\u2019 here.<\/span><\/p>\n
How to interpret this? <\/span><\/p>\n
\u2018e\u2019 is a const pointer pointing to const data of this type. Data, as well as pointers, are constant here. The handler should not modify that; it just uses it. But in Protimer_t, the data can be modified. That\u2019s why mobj is a const pointer pointing to variable data. <\/span><\/p>\n
Now you have modified the function declarators. That\u2019s why these function prototypes also have to be modified. <\/span><\/p>\n
 <\/p>\n
FastBit Embedded Brain Academy Courses<\/b><\/span><\/p>\n
 C<\/span><\/b>lick here:<\/span>https:\/\/fastbitlab.com\/course1<\/span><\/a><\/span><\/p>\n
 <\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n","protected":false},"excerpt":{"rendered":"
  Exercise-003 Nested switch implementation of an FSM part 1     In this article, let\u2019s continue the coding. Write one function to implement a state machine. Go to the file \u2018protimer_state_mach.cpp\u2019, and let\u2019s create a function.  event_status_t protimer_state_machine(protimer_t *mobj, event_t  *e){ switch (mobj->active_state){ case IDLE: { protimer_state_handler_IDLE(mobj,e); } case TIME_SET: { protimer_state_handler_TIME_SET(mobj,e); } protimer_state_mach.cpp […]<\/p>\n","protected":false},"author":1,"featured_media":7081,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"ocean_post_layout":"","ocean_both_sidebars_style":"","ocean_both_sidebars_content_width":0,"ocean_both_sidebars_sidebars_width":0,"ocean_sidebar":"0","ocean_second_sidebar":"0","ocean_disable_margins":"enable","ocean_add_body_class":"","ocean_shortcode_before_top_bar":"","ocean_shortcode_after_top_bar":"","ocean_shortcode_before_header":"","ocean_shortcode_after_header":"","ocean_has_shortcode":"","ocean_shortcode_after_title":"","ocean_shortcode_before_footer_widgets":"","ocean_shortcode_after_footer_widgets":"","ocean_shortcode_before_footer_bottom":"","ocean_shortcode_after_footer_bottom":"","ocean_display_top_bar":"default","ocean_display_header":"default","ocean_header_style":"","ocean_center_header_left_menu":"0","ocean_custom_header_template":"0","ocean_custom_logo":0,"ocean_custom_retina_logo":0,"ocean_custom_logo_max_width":0,"ocean_custom_logo_tablet_max_width":0,"ocean_custom_logo_mobile_max_width":0,"ocean_custom_logo_max_height":0,"ocean_custom_logo_tablet_max_height":0,"ocean_custom_logo_mobile_max_height":0,"ocean_header_custom_menu":"0","ocean_menu_typo_font_family":"0","ocean_menu_typo_font_subset":"","ocean_menu_typo_font_size":0,"ocean_menu_typo_font_size_tablet":0,"ocean_menu_typo_font_size_mobile":0,"ocean_menu_typo_font_size_unit":"px","ocean_menu_typo_font_weight":"","ocean_menu_typo_font_weight_tablet":"","ocean_menu_typo_font_weight_mobile":"","ocean_menu_typo_transform":"","ocean_menu_typo_transform_tablet":"","ocean_menu_typo_transform_mobile":"","ocean_menu_typo_line_height":0,"ocean_menu_typo_line_height_tablet":0,"ocean_menu_typo_line_height_mobile":0,"ocean_menu_typo_line_height_unit":"","ocean_menu_typo_spacing":0,"ocean_menu_typo_spacing_tablet":0,"ocean_menu_typo_spacing_mobile":0,"ocean_menu_typo_spacing_unit":"","ocean_menu_link_color":"","ocean_menu_link_color_hover":"","ocean_menu_link_color_active":"","ocean_menu_link_background":"","ocean_menu_link_hover_background":"","ocean_menu_link_active_background":"","ocean_menu_social_links_bg":"","ocean_menu_social_hover_links_bg":"","ocean_menu_social_links_color":"","ocean_menu_social_hover_links_color":"","ocean_disable_title":"default","ocean_disable_heading":"default","ocean_post_title":"","ocean_post_subheading":"","ocean_post_title_style":"","ocean_post_title_background_color":"","ocean_post_title_background":0,"ocean_post_title_bg_image_position":"","ocean_post_title_bg_image_attachment":"","ocean_post_title_bg_image_repeat":"","ocean_post_title_bg_image_size":"","ocean_post_title_height":0,"ocean_post_title_bg_overlay":0.5,"ocean_post_title_bg_overlay_color":"","ocean_disable_breadcrumbs":"default","ocean_breadcrumbs_color":"","ocean_breadcrumbs_separator_color":"","ocean_breadcrumbs_links_color":"","ocean_breadcrumbs_links_hover_color":"","ocean_display_footer_widgets":"default","ocean_display_footer_bottom":"default","ocean_custom_footer_template":"0","ocean_post_oembed":"","ocean_post_self_hosted_media":"","ocean_post_video_embed":"","ocean_link_format":"","ocean_link_format_target":"self","ocean_quote_format":"","ocean_quote_format_link":"post","ocean_gallery_link_images":"off","ocean_gallery_id":[],"footnotes":""},"categories":[8],"tags":[17],"class_list":["post-7078","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-blog","tag-finite-state-machine","entry","has-media"],"yoast_head":"\nExercise-003 Nested switch implementation of an FSM part 1<\/title>\n<meta name=\"description\" content=\"Exercise-003 Nested switch implementation of an FSM part 1. In this article, let\u2019s continue the coding. Write one function to implement a\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/fastbitlab.com\/blog\/fsm-lecture-24-exercise-003-nested-switch-implementation-of-an-fsm-part-1\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Exercise-003 Nested switch implementation of an FSM part 1\" \/>\n<meta property=\"og:description\" content=\"Exercise-003 Nested switch implementation of an FSM part 1. In this article, let\u2019s continue the coding. Write one function to implement a\" \/>\n<meta property=\"og:url\" content=\"https:\/\/fastbitlab.com\/blog\/fsm-lecture-24-exercise-003-nested-switch-implementation-of-an-fsm-part-1\/\" \/>\n<meta property=\"og:site_name\" content=\"FastBit EBA\" \/>\n<meta property=\"article:publisher\" content=\"https:\/\/www.facebook.com\/fastbiteba\/\" \/>\n<meta property=\"article:published_time\" content=\"2022-02-02T08:26:22+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2023-08-08T09:46:47+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/fastbitlab.com\/blog\/wp-content\/uploads\/2022\/02\/fig-1-protimer-code-1.png\" \/>\n\t<meta property=\"og:image:width\" content=\"1181\" \/>\n\t<meta property=\"og:image:height\" content=\"557\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/png\" \/>\n<meta name=\"author\" content=\"FastBitLab\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:creator\" content=\"@fastbiteba\" \/>\n<meta name=\"twitter:site\" content=\"@fastbiteba\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"FastBitLab\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"5 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/fsm-lecture-24-exercise-003-nested-switch-implementation-of-an-fsm-part-1\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/fsm-lecture-24-exercise-003-nested-switch-implementation-of-an-fsm-part-1\\\/\"},\"author\":{\"name\":\"FastBitLab\",\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/#\\\/schema\\\/person\\\/e32b38e733a0d76ffa7e6bc998652e5d\"},\"headline\":\"FSM Lecture 24: Exercise-003 Nested switch implementation of an FSM part 1\",\"datePublished\":\"2022-02-02T08:26:22+00:00\",\"dateModified\":\"2023-08-08T09:46:47+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/fsm-lecture-24-exercise-003-nested-switch-implementation-of-an-fsm-part-1\\\/\"},\"wordCount\":1160,\"commentCount\":0,\"publisher\":{\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/#organization\"},\"image\":{\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/fsm-lecture-24-exercise-003-nested-switch-implementation-of-an-fsm-part-1\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/wp-content\\\/uploads\\\/2022\\\/02\\\/fig-1-protimer-code-1.png\",\"keywords\":[\"Finite state Machine(FSM)\"],\"articleSection\":[\"Blog\"],\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/fsm-lecture-24-exercise-003-nested-switch-implementation-of-an-fsm-part-1\\\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/fsm-lecture-24-exercise-003-nested-switch-implementation-of-an-fsm-part-1\\\/\",\"url\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/fsm-lecture-24-exercise-003-nested-switch-implementation-of-an-fsm-part-1\\\/\",\"name\":\"Exercise-003 Nested switch implementation of an FSM part 1\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/fsm-lecture-24-exercise-003-nested-switch-implementation-of-an-fsm-part-1\\\/#primaryimage\"},\"image\":{\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/fsm-lecture-24-exercise-003-nested-switch-implementation-of-an-fsm-part-1\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/wp-content\\\/uploads\\\/2022\\\/02\\\/fig-1-protimer-code-1.png\",\"datePublished\":\"2022-02-02T08:26:22+00:00\",\"dateModified\":\"2023-08-08T09:46:47+00:00\",\"description\":\"Exercise-003 Nested switch implementation of an FSM part 1. In this article, let\u2019s continue the coding. Write one function to implement a\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/fsm-lecture-24-exercise-003-nested-switch-implementation-of-an-fsm-part-1\\\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/fsm-lecture-24-exercise-003-nested-switch-implementation-of-an-fsm-part-1\\\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/fsm-lecture-24-exercise-003-nested-switch-implementation-of-an-fsm-part-1\\\/#primaryimage\",\"url\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/wp-content\\\/uploads\\\/2022\\\/02\\\/fig-1-protimer-code-1.png\",\"contentUrl\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/wp-content\\\/uploads\\\/2022\\\/02\\\/fig-1-protimer-code-1.png\",\"width\":1181,\"height\":557,\"caption\":\"Figure 1. Implementation of state machine function\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/fsm-lecture-24-exercise-003-nested-switch-implementation-of-an-fsm-part-1\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"FSM Lecture 24: Exercise-003 Nested switch implementation of an FSM part 1\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/#website\",\"url\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/\",\"name\":\"FastBit EBA\",\"description\":\"Your Online Academy of Embedded Systems\",\"publisher\":{\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":\"Organization\",\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/#organization\",\"name\":\"FastBit EBA\",\"url\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/#\\\/schema\\\/logo\\\/image\\\/\",\"url\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/wp-content\\\/uploads\\\/2026\\\/04\\\/logo-EzNrEnyr.png\",\"contentUrl\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/wp-content\\\/uploads\\\/2026\\\/04\\\/logo-EzNrEnyr.png\",\"width\":640,\"height\":640,\"caption\":\"FastBit EBA\"},\"image\":{\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/#\\\/schema\\\/logo\\\/image\\\/\"},\"sameAs\":[\"https:\\\/\\\/www.facebook.com\\\/fastbiteba\\\/\",\"https:\\\/\\\/x.com\\\/fastbiteba\",\"https:\\\/\\\/www.linkedin.com\\\/in\\\/fastbit-embedded-brain-academy-b3167b124\\\/\",\"https:\\\/\\\/www.youtube.com\\\/channel\\\/UCa1REBV9hyrzGp2mjJCagBg\"]},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/#\\\/schema\\\/person\\\/e32b38e733a0d76ffa7e6bc998652e5d\",\"name\":\"FastBitLab\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/9230d0f9bdef28b63a01e7ca274ee7b2e8ed9abe932ee564af8809caaf52a0c8?s=96&d=mm&r=g\",\"url\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/9230d0f9bdef28b63a01e7ca274ee7b2e8ed9abe932ee564af8809caaf52a0c8?s=96&d=mm&r=g\",\"contentUrl\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/9230d0f9bdef28b63a01e7ca274ee7b2e8ed9abe932ee564af8809caaf52a0c8?s=96&d=mm&r=g\",\"caption\":\"FastBitLab\"},\"description\":\"The FastBit Embedded Brain Academy uses the power of internet to bring the online courses related to the field of embedded system programming, Real time operating system, Embedded Linux systems, etc at your finger tip with very low cost. Backed with strong experience of industry, we have produced lots of courses with the customer enrolment over 3000+ across 100+ countries.\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Exercise-003 Nested switch implementation of an FSM part 1","description":"Exercise-003 Nested switch implementation of an FSM part 1. In this article, let\u2019s continue the coding. Write one function to implement a","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/fastbitlab.com\/blog\/fsm-lecture-24-exercise-003-nested-switch-implementation-of-an-fsm-part-1\/","og_locale":"en_US","og_type":"article","og_title":"Exercise-003 Nested switch implementation of an FSM part 1","og_description":"Exercise-003 Nested switch implementation of an FSM part 1. In this article, let\u2019s continue the coding. Write one function to implement a","og_url":"https:\/\/fastbitlab.com\/blog\/fsm-lecture-24-exercise-003-nested-switch-implementation-of-an-fsm-part-1\/","og_site_name":"FastBit EBA","article_publisher":"https:\/\/www.facebook.com\/fastbiteba\/","article_published_time":"2022-02-02T08:26:22+00:00","article_modified_time":"2023-08-08T09:46:47+00:00","og_image":[{"width":1181,"height":557,"url":"https:\/\/fastbitlab.com\/blog\/wp-content\/uploads\/2022\/02\/fig-1-protimer-code-1.png","type":"image\/png"}],"author":"FastBitLab","twitter_card":"summary_large_image","twitter_creator":"@fastbiteba","twitter_site":"@fastbiteba","twitter_misc":{"Written by":"FastBitLab","Est. reading time":"5 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/fastbitlab.com\/blog\/fsm-lecture-24-exercise-003-nested-switch-implementation-of-an-fsm-part-1\/#article","isPartOf":{"@id":"https:\/\/fastbitlab.com\/blog\/fsm-lecture-24-exercise-003-nested-switch-implementation-of-an-fsm-part-1\/"},"author":{"name":"FastBitLab","@id":"https:\/\/fastbitlab.com\/blog\/#\/schema\/person\/e32b38e733a0d76ffa7e6bc998652e5d"},"headline":"FSM Lecture 24: Exercise-003 Nested switch implementation of an FSM part 1","datePublished":"2022-02-02T08:26:22+00:00","dateModified":"2023-08-08T09:46:47+00:00","mainEntityOfPage":{"@id":"https:\/\/fastbitlab.com\/blog\/fsm-lecture-24-exercise-003-nested-switch-implementation-of-an-fsm-part-1\/"},"wordCount":1160,"commentCount":0,"publisher":{"@id":"https:\/\/fastbitlab.com\/blog\/#organization"},"image":{"@id":"https:\/\/fastbitlab.com\/blog\/fsm-lecture-24-exercise-003-nested-switch-implementation-of-an-fsm-part-1\/#primaryimage"},"thumbnailUrl":"https:\/\/fastbitlab.com\/blog\/wp-content\/uploads\/2022\/02\/fig-1-protimer-code-1.png","keywords":["Finite state Machine(FSM)"],"articleSection":["Blog"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/fastbitlab.com\/blog\/fsm-lecture-24-exercise-003-nested-switch-implementation-of-an-fsm-part-1\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/fastbitlab.com\/blog\/fsm-lecture-24-exercise-003-nested-switch-implementation-of-an-fsm-part-1\/","url":"https:\/\/fastbitlab.com\/blog\/fsm-lecture-24-exercise-003-nested-switch-implementation-of-an-fsm-part-1\/","name":"Exercise-003 Nested switch implementation of an FSM part 1","isPartOf":{"@id":"https:\/\/fastbitlab.com\/blog\/#website"},"primaryImageOfPage":{"@id":"https:\/\/fastbitlab.com\/blog\/fsm-lecture-24-exercise-003-nested-switch-implementation-of-an-fsm-part-1\/#primaryimage"},"image":{"@id":"https:\/\/fastbitlab.com\/blog\/fsm-lecture-24-exercise-003-nested-switch-implementation-of-an-fsm-part-1\/#primaryimage"},"thumbnailUrl":"https:\/\/fastbitlab.com\/blog\/wp-content\/uploads\/2022\/02\/fig-1-protimer-code-1.png","datePublished":"2022-02-02T08:26:22+00:00","dateModified":"2023-08-08T09:46:47+00:00","description":"Exercise-003 Nested switch implementation of an FSM part 1. In this article, let\u2019s continue the coding. Write one function to implement a","breadcrumb":{"@id":"https:\/\/fastbitlab.com\/blog\/fsm-lecture-24-exercise-003-nested-switch-implementation-of-an-fsm-part-1\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/fastbitlab.com\/blog\/fsm-lecture-24-exercise-003-nested-switch-implementation-of-an-fsm-part-1\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/fastbitlab.com\/blog\/fsm-lecture-24-exercise-003-nested-switch-implementation-of-an-fsm-part-1\/#primaryimage","url":"https:\/\/fastbitlab.com\/blog\/wp-content\/uploads\/2022\/02\/fig-1-protimer-code-1.png","contentUrl":"https:\/\/fastbitlab.com\/blog\/wp-content\/uploads\/2022\/02\/fig-1-protimer-code-1.png","width":1181,"height":557,"caption":"Figure 1. Implementation of state machine function"},{"@type":"BreadcrumbList","@id":"https:\/\/fastbitlab.com\/blog\/fsm-lecture-24-exercise-003-nested-switch-implementation-of-an-fsm-part-1\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/fastbitlab.com\/blog\/"},{"@type":"ListItem","position":2,"name":"FSM Lecture 24: Exercise-003 Nested switch implementation of an FSM part 1"}]},{"@type":"WebSite","@id":"https:\/\/fastbitlab.com\/blog\/#website","url":"https:\/\/fastbitlab.com\/blog\/","name":"FastBit EBA","description":"Your Online Academy of Embedded Systems","publisher":{"@id":"https:\/\/fastbitlab.com\/blog\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/fastbitlab.com\/blog\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Organization","@id":"https:\/\/fastbitlab.com\/blog\/#organization","name":"FastBit EBA","url":"https:\/\/fastbitlab.com\/blog\/","logo":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/fastbitlab.com\/blog\/#\/schema\/logo\/image\/","url":"https:\/\/fastbitlab.com\/blog\/wp-content\/uploads\/2026\/04\/logo-EzNrEnyr.png","contentUrl":"https:\/\/fastbitlab.com\/blog\/wp-content\/uploads\/2026\/04\/logo-EzNrEnyr.png","width":640,"height":640,"caption":"FastBit EBA"},"image":{"@id":"https:\/\/fastbitlab.com\/blog\/#\/schema\/logo\/image\/"},"sameAs":["https:\/\/www.facebook.com\/fastbiteba\/","https:\/\/x.com\/fastbiteba","https:\/\/www.linkedin.com\/in\/fastbit-embedded-brain-academy-b3167b124\/","https:\/\/www.youtube.com\/channel\/UCa1REBV9hyrzGp2mjJCagBg"]},{"@type":"Person","@id":"https:\/\/fastbitlab.com\/blog\/#\/schema\/person\/e32b38e733a0d76ffa7e6bc998652e5d","name":"FastBitLab","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/secure.gravatar.com\/avatar\/9230d0f9bdef28b63a01e7ca274ee7b2e8ed9abe932ee564af8809caaf52a0c8?s=96&d=mm&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/9230d0f9bdef28b63a01e7ca274ee7b2e8ed9abe932ee564af8809caaf52a0c8?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/9230d0f9bdef28b63a01e7ca274ee7b2e8ed9abe932ee564af8809caaf52a0c8?s=96&d=mm&r=g","caption":"FastBitLab"},"description":"The FastBit Embedded Brain Academy uses the power of internet to bring the online courses related to the field of embedded system programming, Real time operating system, Embedded Linux systems, etc at your finger tip with very low cost. Backed with strong experience of industry, we have produced lots of courses with the customer enrolment over 3000+ across 100+ countries."}]}},"_links":{"self":[{"href":"https:\/\/fastbitlab.com\/blog\/wp-json\/wp\/v2\/posts\/7078","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/fastbitlab.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/fastbitlab.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/fastbitlab.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/fastbitlab.com\/blog\/wp-json\/wp\/v2\/comments?post=7078"}],"version-history":[{"count":5,"href":"https:\/\/fastbitlab.com\/blog\/wp-json\/wp\/v2\/posts\/7078\/revisions"}],"predecessor-version":[{"id":15335,"href":"https:\/\/fastbitlab.com\/blog\/wp-json\/wp\/v2\/posts\/7078\/revisions\/15335"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/fastbitlab.com\/blog\/wp-json\/wp\/v2\/media\/7081"}],"wp:attachment":[{"href":"https:\/\/fastbitlab.com\/blog\/wp-json\/wp\/v2\/media?parent=7078"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/fastbitlab.com\/blog\/wp-json\/wp\/v2\/categories?post=7078"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/fastbitlab.com\/blog\/wp-json\/wp\/v2\/tags?post=7078"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}