{"id":13236,"date":"2022-12-17T10:36:34","date_gmt":"2022-12-17T05:06:34","guid":{"rendered":"https:\/\/fastbitlab.com\/?p=13236"},"modified":"2023-08-22T12:19:50","modified_gmt":"2023-08-22T06:49:50","slug":"microcontroller-embedded-c-programming-lecture-141-using-volatile-with-isr-part-1","status":"publish","type":"post","link":"https:\/\/fastbitlab.com\/blog\/microcontroller-embedded-c-programming-lecture-141-using-volatile-with-isr-part-1\/","title":{"rendered":"Microcontroller Embedded C Programming Lecture 141| Using ‘volatile’ with ISR Part-1"},"content":{"rendered":"
\n
\n
\n
\n
\n\n<\/div>\n

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

\n

Using ‘volatile’ with ISR Part-1<\/strong><\/span><\/h1>\n
\n
\n
\n
<\/div>\n

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

Use volatile when your code is dealing with below scenarios<\/strong><\/span><\/p>\n

    \n
  1. Memory-mapped peripheral registers of the microcontrollers<\/span><\/li>\n
  2. Multiple tasks accessing global variables(read\/write) in an RTOS multithreaded application<\/span><\/li>\n
  3. When a global variable is used to share data between the main code and an ISR code.<\/span><\/li>\n<\/ol>\n

     <\/p>\n

    In the previous articles, we explored the case of using the ‘volatile<\/span>‘ keyword with memory-mapped peripheral register access. <\/span>In this article, let’s explore when a global variable is used to share data between the main code and an ISR code. <\/span><\/p>\n

    Now let’s see how we can use volatile with this scenario.<\/span><\/p>\n

    Here I have a project 008button_ISR. So, let me explain this project’s source code.<\/span><\/p>\n

    #include<\/span> <stdint.h>\r\n#include<\/span> <stdio.h>\r\n\r\n\/\/global shared variable between main code and ISR<\/span>\r\nuint8_t<\/span>  g_button_pressed = 0;\r\nuint32_t<\/span> g_button_press_count =0;\r\n\r\nvoid<\/span> button_init(void<\/span>);\r\n\r\nuint32_t<\/span>  *pEXTTIPendReg       = (uint32_t<\/span>*) (0x40013C00 + 0x14);\r\nuint32_t<\/span>  *pClkCtrlReg         = (uint32_t<\/span>*) (0x40023800 + 0x30);\r\nuint32_t<\/span>  *pClkCtrlRegApb2     = (uint32_t<\/span>*) (0x40023800 + 0x44);\r\nuint32_t <\/span> *pGPIOAModeReg       = (uint32_t<\/span>*) (0x40020000 + 0x00);\r\nuint32_t<\/span>  *pEXTIMaskReg        = (uint32_t<\/span>*) (0x40013C00 + 0x00);\r\nuint32_t <\/span> *pEXTTIEdgeCtrlReg   = (uint32_t<\/span>*) (0x40013C00 + 0x08);\r\nuint32_t<\/span>  *pNVICIRQEnReg       = (uint32_<\/span>t*) 0xE000E100;\r\n\r\n\r\nint<\/span> main(void<\/span>)\r\n{\r\n    button_init();\r\n\r\n    while<\/span>(1)\r\n    {\r\n      \/\/Disable interrupt<\/span>\r\n       *pEXTIMaskReg &= ~( 1 << 0);\r\n\r\n    if<\/span>(g_button_pressed){\r\n      \/\/Some delay until button debouncing gets over<\/span>\r\n       for<\/span>(uint32_t<\/span> i=0;i<500000\/2;i++);\r\n       g_button_press_count++;\r\n       printf<\/span>(\"Button is pressed : %lu\\n\",g_button_press_count);\r\n       g_button_pressed = 0;\r\n     }\r\n\r\n     \/\/Enable interrupt<\/span>\r\n     *pEXTIMaskReg |= ( 1 << 0);\r\n    }\r\n    }\r\n\r\n\r\nvoid<\/span> button_init(void<\/span>)\r\n{\r\n\r\n  *pClkCtrlReg |= ( 1 << 0);\r\n\r\n  *pClkCtrlRegApb2 |= ( 1 << 14);\r\n\r\n  *pEXTTIEdgeCtrlReg |= ( 1 << 0);\r\n\r\n  *pEXTIMaskReg |= ( 1 << 0);\r\n\r\n  *pNVICIRQEnReg |= ( 1 << 6);\r\n\r\n}\r\n\r\n\/* This is button interrupt handler*\/<\/span>\r\nvoid<\/span> EXTI0_IRQHandler(void<\/span>)\r\n{\r\n   \/\/Make this flag SET . if button pressed<\/span>\r\n   g_button_pressed = 1;\r\n\r\n   *pEXTTIPendReg |= ( 1 << 0);\r\n}\r\n\r\n<\/pre>\n
    There are 2 main functions in this code. <\/span><\/p>\n
    The first function is the main function and the second function is the ISR. This is the button ISR. This button ISR will get executed whenever the onboard button of the board is pressed. <\/span><\/p>\n
    What we do in this ISR is very simple, we set the global flag. So, g_button_pressed is a global flag and that will be set and the ISR exits. So, that’s the only thing ISR does.<\/span><\/p>\n
     <\/p>\n
    What the main function does is, it is actually trapped inside the infinite loop and for every iteration, the main code checks this g_button_pressed global flag.<\/span><\/p>\n
    And if this global flag is really set(that is by the ISR), then it prints how many times the button is pressed so far. <\/span><\/p>\n
    What it does is, it just uses one count variable, it just increments that count, And then it just prints that count value to indicate these many times the button is pressed so far.  After that, it resets this global flag. g_button_pressed = 0 is like invalidating the flag. <\/span><\/p>\n
    And again the flag will be set by the ISR, and again if condition executes, then printf will be printed, like that.<\/span><\/p>\n
     <\/p>\n
    for<\/span>(<\/span>uint32_t i =0; i<500000\/2; i++);<\/span><\/strong> <\/span> This is a small delay.  This delay is for button debouncing. So, this introduces some delay until the button debouncing gets over. <\/span><\/p>\n
     <\/p>\n
    If you want to reproduce this code on your board, then you should be using the STM32F4 discovery board. So, if you have some other board then you have to modify this code. Because different boards have different pins where the button is connected and also the interrupt configuration changes. So, you cannot simply download it on some other board and you can make it work. <\/span><\/p>\n
    So, if you have a discovery board, then you can try this code. Otherwise, please identify the places where you can use ‘volatile’ in this project to make this application behave as intended. Because this project works only with the O0 optimization level. So the moment you change the optimization level this application breaks.<\/span><\/p>\n
     <\/p>\n
    Let me show you how to run this code.<\/span><\/p>\n
    First, let’s make the optimization is None(-O0). And after that, let’s build the project, and then debug. And after that, go to SWV\/ITM Data Console, and let’s start the tracing, and after that just run the code.<\/span><\/p>\n
    The code is running, and press the button. You can see in Figure 1, it is printing when the button is pressed: 1 times , 2 times, 3 times, 4 times, like that. This is working properly.<\/span><\/p>\n
    \"Using
    Figure 1. Output<\/span><\/figcaption><\/figure>\n
     <\/p>\n
    Let’s change the optimization level to O3. Let’s start the trace first. Let’s start the tracing and then hit run. <\/span><\/p>\n
    Now let me press the button once, it printed 18 times, as shown in Figure 2. So, I just pressed the button once but it printed 18 times. That means there is some problem with the code.<\/span><\/p>\n
    \"Using
    Figure 2. Output<\/span><\/figcaption><\/figure>\n
     <\/p>\n
    The application is not behaving properly, so you have to fix this. Identify the places where, and you can use volatile to fix this issue. I’ll explain in the next article.<\/span><\/p>\n
     <\/p>\n
    FastBit Embedded Brain Academy Courses<\/b><\/span><\/p>\n
    Click here:<\/span> <\/span><\/span><\/span>https:\/\/fastbitlab.com\/course1<\/span><\/a><\/span><\/p>\n
     <\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n","protected":false},"excerpt":{"rendered":"
      Using ‘volatile’ with ISR Part-1   Use volatile when your code is dealing with below scenarios Memory-mapped peripheral registers of the microcontrollers Multiple tasks accessing global variables(read\/write) in an RTOS multithreaded application When a global variable is used to share data between the main code and an ISR code.   In the previous articles, […]<\/p>\n","protected":false},"author":1,"featured_media":13239,"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":"enable","ocean_disable_heading":"default","ocean_post_title":"Using 'volatile' with ISR Part-1","ocean_post_subheading":"","ocean_post_title_style":"solid-color","ocean_post_title_background_color":"#08b8cc","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":[16],"class_list":["post-13236","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-blog","tag-microcontroller-embedded-c-programming","entry","has-media"],"yoast_head":"\nUsing 'volatile' with ISR: Part 1 | Microcontroller Embedded C<\/title>\n<meta name=\"description\" content=\"Microcontroller Embedded C Programming Lecture - Using 'volatile' with ISR Part-1.Learn how to effectively use the 'volatile' keyword in C\" \/>\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\/microcontroller-embedded-c-programming-lecture-141-using-volatile-with-isr-part-1\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Using 'volatile' with ISR: Part 1 | Microcontroller Embedded C\" \/>\n<meta property=\"og:description\" content=\"Microcontroller Embedded C Programming Lecture - Using 'volatile' with ISR Part-1.Learn how to effectively use the 'volatile' keyword in C\" \/>\n<meta property=\"og:url\" content=\"https:\/\/fastbitlab.com\/blog\/microcontroller-embedded-c-programming-lecture-141-using-volatile-with-isr-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-12-17T05:06:34+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2023-08-22T06:49:50+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/fastbitlab.com\/blog\/wp-content\/uploads\/2022\/12\/Figure-1-5.png\" \/>\n\t<meta property=\"og:image:width\" content=\"1669\" \/>\n\t<meta property=\"og:image:height\" content=\"979\" \/>\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=\"4 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/microcontroller-embedded-c-programming-lecture-141-using-volatile-with-isr-part-1\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/microcontroller-embedded-c-programming-lecture-141-using-volatile-with-isr-part-1\\\/\"},\"author\":{\"name\":\"FastBitLab\",\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/#\\\/schema\\\/person\\\/e32b38e733a0d76ffa7e6bc998652e5d\"},\"headline\":\"Microcontroller Embedded C Programming Lecture 141| Using ‘volatile’ with ISR Part-1\",\"datePublished\":\"2022-12-17T05:06:34+00:00\",\"dateModified\":\"2023-08-22T06:49:50+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/microcontroller-embedded-c-programming-lecture-141-using-volatile-with-isr-part-1\\\/\"},\"wordCount\":711,\"commentCount\":0,\"publisher\":{\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/#organization\"},\"image\":{\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/microcontroller-embedded-c-programming-lecture-141-using-volatile-with-isr-part-1\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/wp-content\\\/uploads\\\/2022\\\/12\\\/Figure-1-5.png\",\"keywords\":[\"Microcontroller Embedded C programming Lectures\"],\"articleSection\":[\"Blog\"],\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/microcontroller-embedded-c-programming-lecture-141-using-volatile-with-isr-part-1\\\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/microcontroller-embedded-c-programming-lecture-141-using-volatile-with-isr-part-1\\\/\",\"url\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/microcontroller-embedded-c-programming-lecture-141-using-volatile-with-isr-part-1\\\/\",\"name\":\"Using 'volatile' with ISR: Part 1 | Microcontroller Embedded C\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/microcontroller-embedded-c-programming-lecture-141-using-volatile-with-isr-part-1\\\/#primaryimage\"},\"image\":{\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/microcontroller-embedded-c-programming-lecture-141-using-volatile-with-isr-part-1\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/wp-content\\\/uploads\\\/2022\\\/12\\\/Figure-1-5.png\",\"datePublished\":\"2022-12-17T05:06:34+00:00\",\"dateModified\":\"2023-08-22T06:49:50+00:00\",\"description\":\"Microcontroller Embedded C Programming Lecture - Using 'volatile' with ISR Part-1.Learn how to effectively use the 'volatile' keyword in C\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/microcontroller-embedded-c-programming-lecture-141-using-volatile-with-isr-part-1\\\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/microcontroller-embedded-c-programming-lecture-141-using-volatile-with-isr-part-1\\\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/microcontroller-embedded-c-programming-lecture-141-using-volatile-with-isr-part-1\\\/#primaryimage\",\"url\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/wp-content\\\/uploads\\\/2022\\\/12\\\/Figure-1-5.png\",\"contentUrl\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/wp-content\\\/uploads\\\/2022\\\/12\\\/Figure-1-5.png\",\"width\":1669,\"height\":979,\"caption\":\"Figure 1. Code\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/microcontroller-embedded-c-programming-lecture-141-using-volatile-with-isr-part-1\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Microcontroller Embedded C Programming Lecture 141| Using ‘volatile’ with ISR 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":"Using 'volatile' with ISR: Part 1 | Microcontroller Embedded C","description":"Microcontroller Embedded C Programming Lecture - Using 'volatile' with ISR Part-1.Learn how to effectively use the 'volatile' keyword in C","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\/microcontroller-embedded-c-programming-lecture-141-using-volatile-with-isr-part-1\/","og_locale":"en_US","og_type":"article","og_title":"Using 'volatile' with ISR: Part 1 | Microcontroller Embedded C","og_description":"Microcontroller Embedded C Programming Lecture - Using 'volatile' with ISR Part-1.Learn how to effectively use the 'volatile' keyword in C","og_url":"https:\/\/fastbitlab.com\/blog\/microcontroller-embedded-c-programming-lecture-141-using-volatile-with-isr-part-1\/","og_site_name":"FastBit EBA","article_publisher":"https:\/\/www.facebook.com\/fastbiteba\/","article_published_time":"2022-12-17T05:06:34+00:00","article_modified_time":"2023-08-22T06:49:50+00:00","og_image":[{"width":1669,"height":979,"url":"https:\/\/fastbitlab.com\/blog\/wp-content\/uploads\/2022\/12\/Figure-1-5.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":"4 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/fastbitlab.com\/blog\/microcontroller-embedded-c-programming-lecture-141-using-volatile-with-isr-part-1\/#article","isPartOf":{"@id":"https:\/\/fastbitlab.com\/blog\/microcontroller-embedded-c-programming-lecture-141-using-volatile-with-isr-part-1\/"},"author":{"name":"FastBitLab","@id":"https:\/\/fastbitlab.com\/blog\/#\/schema\/person\/e32b38e733a0d76ffa7e6bc998652e5d"},"headline":"Microcontroller Embedded C Programming Lecture 141| Using ‘volatile’ with ISR Part-1","datePublished":"2022-12-17T05:06:34+00:00","dateModified":"2023-08-22T06:49:50+00:00","mainEntityOfPage":{"@id":"https:\/\/fastbitlab.com\/blog\/microcontroller-embedded-c-programming-lecture-141-using-volatile-with-isr-part-1\/"},"wordCount":711,"commentCount":0,"publisher":{"@id":"https:\/\/fastbitlab.com\/blog\/#organization"},"image":{"@id":"https:\/\/fastbitlab.com\/blog\/microcontroller-embedded-c-programming-lecture-141-using-volatile-with-isr-part-1\/#primaryimage"},"thumbnailUrl":"https:\/\/fastbitlab.com\/blog\/wp-content\/uploads\/2022\/12\/Figure-1-5.png","keywords":["Microcontroller Embedded C programming Lectures"],"articleSection":["Blog"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/fastbitlab.com\/blog\/microcontroller-embedded-c-programming-lecture-141-using-volatile-with-isr-part-1\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/fastbitlab.com\/blog\/microcontroller-embedded-c-programming-lecture-141-using-volatile-with-isr-part-1\/","url":"https:\/\/fastbitlab.com\/blog\/microcontroller-embedded-c-programming-lecture-141-using-volatile-with-isr-part-1\/","name":"Using 'volatile' with ISR: Part 1 | Microcontroller Embedded C","isPartOf":{"@id":"https:\/\/fastbitlab.com\/blog\/#website"},"primaryImageOfPage":{"@id":"https:\/\/fastbitlab.com\/blog\/microcontroller-embedded-c-programming-lecture-141-using-volatile-with-isr-part-1\/#primaryimage"},"image":{"@id":"https:\/\/fastbitlab.com\/blog\/microcontroller-embedded-c-programming-lecture-141-using-volatile-with-isr-part-1\/#primaryimage"},"thumbnailUrl":"https:\/\/fastbitlab.com\/blog\/wp-content\/uploads\/2022\/12\/Figure-1-5.png","datePublished":"2022-12-17T05:06:34+00:00","dateModified":"2023-08-22T06:49:50+00:00","description":"Microcontroller Embedded C Programming Lecture - Using 'volatile' with ISR Part-1.Learn how to effectively use the 'volatile' keyword in C","breadcrumb":{"@id":"https:\/\/fastbitlab.com\/blog\/microcontroller-embedded-c-programming-lecture-141-using-volatile-with-isr-part-1\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/fastbitlab.com\/blog\/microcontroller-embedded-c-programming-lecture-141-using-volatile-with-isr-part-1\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/fastbitlab.com\/blog\/microcontroller-embedded-c-programming-lecture-141-using-volatile-with-isr-part-1\/#primaryimage","url":"https:\/\/fastbitlab.com\/blog\/wp-content\/uploads\/2022\/12\/Figure-1-5.png","contentUrl":"https:\/\/fastbitlab.com\/blog\/wp-content\/uploads\/2022\/12\/Figure-1-5.png","width":1669,"height":979,"caption":"Figure 1. Code"},{"@type":"BreadcrumbList","@id":"https:\/\/fastbitlab.com\/blog\/microcontroller-embedded-c-programming-lecture-141-using-volatile-with-isr-part-1\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/fastbitlab.com\/blog\/"},{"@type":"ListItem","position":2,"name":"Microcontroller Embedded C Programming Lecture 141| Using ‘volatile’ with ISR 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\/13236","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=13236"}],"version-history":[{"count":5,"href":"https:\/\/fastbitlab.com\/blog\/wp-json\/wp\/v2\/posts\/13236\/revisions"}],"predecessor-version":[{"id":13258,"href":"https:\/\/fastbitlab.com\/blog\/wp-json\/wp\/v2\/posts\/13236\/revisions\/13258"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/fastbitlab.com\/blog\/wp-json\/wp\/v2\/media\/13239"}],"wp:attachment":[{"href":"https:\/\/fastbitlab.com\/blog\/wp-json\/wp\/v2\/media?parent=13236"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/fastbitlab.com\/blog\/wp-json\/wp\/v2\/categories?post=13236"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/fastbitlab.com\/blog\/wp-json\/wp\/v2\/tags?post=13236"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}