{"id":7243,"date":"2022-02-09T08:08:45","date_gmt":"2022-02-09T08:08:45","guid":{"rendered":"http:\/\/fastbitlab.com\/?p=7243"},"modified":"2023-08-08T16:42:02","modified_gmt":"2023-08-08T11:12:02","slug":"fsm-lecture-30-exercise-003-button-software-debouncing-implementation","status":"publish","type":"post","link":"https:\/\/fastbitlab.com\/blog\/fsm-lecture-30-exercise-003-button-software-debouncing-implementation\/","title":{"rendered":"FSM Lecture 30: Exercise-003 Button software de-bouncing implementation"},"content":{"rendered":"
\n
\n
\n
\n

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

\n

Exercise-003 Button software de-bouncing implementation<\/span><\/h1>\n
\n
\n
\n

 <\/p>\n

<\/div>\n

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

In this article, we will implement software button debouncing.<\/span><\/p>\n

\"Creation
Figure 1. Creation of state machine diagram<\/span><\/figcaption><\/figure>\n

Just right-click over the project and go to Create diagram and Statemachine diagram(shown in Figure 1); you can do that.<\/span><\/p>\n

 <\/p>\n

\"State
Figure 2. State machine diagram of pins different states<\/span><\/figcaption><\/figure>\n

 A state machine diagram can represent pins in different states, as shown in Figure 2. <\/span><\/span><\/p>\n

We will not implement this as a standard UML specification-based state machine. We will implement this as a normal function, but I just wanted to let you know that the pin debouncing can also be represented in a state machine diagram. <\/span><\/span><\/p>\n

Here, we have got three states. NOT PRESSED, PRESSED, and BOUNCE. Assume that this is implemented as a function, and the function receives the button pad value.<\/span><\/p>\n

First, the pin will be in the Not pressed state, and when the button pad value is non-zero, that means someone has pressed the buttons. So, there will be a Transition to a bounce state. And the action is set_curr_time. <\/span><\/p>\n

But the key point here is that when the pin is in the Not pressed state and if the button pad value becomes non-zero, the state machine moves to the Bounce state. And in the Bounce state, it has to wait for 50 milliseconds, so that’s the bounce period. 50 milliseconds is spent here. The beginning of that 50 milliseconds is marked by this set current time. So, we can do this using millis().<\/span><\/p>\n

While the state machine is in the Bounce state, after 50 milliseconds, it has to re-verify the button pad value once again (the fresh button pad value). If it is 0, that means no one has pressed the button. That\u2019s why it goes to a Not pressed state. But if the button pad value is non-zero after 50 milliseconds, it goes to the Pressed state. That indicates someone has really pressed the button. <\/span><\/p>\n

And while it is in the Pressed state, it stays there until the button pad value returns to 0.<\/span><\/p>\n

When someone releases the button, the button pad value becomes 0, which indicates that someone has released the button. That\u2019s why the Transition value comes to a bounce state again. Because you have to debounce the release state also. And the beginning of the time is marked by the set_curr_time function.<\/span><\/p>\n

Now we will implement this as a small function. Let\u2019s go to the code. We will create another enum in main.h\u2014 typedef enum as shown below. <\/span><\/p>\n

typedef enum<\/span>{\r\n          NOT_PRESSED,\r\n          BOUNCE,\r\n          PRESSED\r\n}button_state_t;<\/pre>\n
 create enum function in main.h<\/span><\/p>\n
 <\/p>\n
static<\/span> uint8_t<\/span> process_button_pad_value(uint8_t<\/span> btn_pad_value)\r\n{\r\n   static<\/span> button_state_t btn_sm_state = NOT_PRESSED;\r\n   static<\/span> uint32_t<\/span> curr_time = millis();\r\n\r\n   switch<\/span>(btn_sm_state){\r\n    case<\/span> NOT_PRESSED:{\r\n     if<\/span>(btn_pad_value){\r\n       btn_sm_state = BOUNCE;\r\n       curr_time = millis();\r\n      }\r\n     break<\/span>;\r\n}<\/pre>\n
Case NOT_PRESSED state<\/span><\/p>\n
We have already defined a function <\/span>process_button_pad_value<\/b>; inside this, we will do that. First, I will take a variable <\/span>static button_state_t btn_sm_state = NOT_PRESSED<\/b>. And we will take one more variable here to store the current time <\/span>static uint32 curr_time = millis();<\/b><\/span><\/p>\n
Now let’s use the switch case. <\/span>switch(btn_sm_state)<\/b>. Let’s write different cases for NOT PRESSED, BOUNCE, and PRESSED states.<\/span><\/span><\/p>\n
When it is Not pressed, the statemachine says that if the btn_pad_value is non zero, there is a transition.  Here we have to set the current time. That will be used in the BOUNCE state to timeout after 50 milliseconds. After that, we have to put a break statement (Figure 1).<\/span><\/p>\n
 <\/p>\n
 case<\/span> BOUNCE:{\r\n    if<\/span>(millis() - curr_time >= 50 ){\r\n       \/\/50ms has passed<\/span> \r\n       if<\/span>(btn_pad_value){\r\n         btn_sm_state = PRESSED;\r\n         return<\/span> btn_pad_value;\r\n        }\r\n        else<\/span>\r\n          btn_sm_state = NOT_PRESSED;\r\n     }\r\n     break<\/span>;\r\n }\r\n\r\n case<\/span> PRESSED:{  \r\n    if<\/span>(!btn_pad_value){\r\n      btn_sm_state = BOUNCE;\r\n      curr_time = millis();\r\n    }  \r\n    break<\/span>;\r\n}\r\n\r\n} \r\nreturn<\/span> 0;\r\n}\r\n\r\n<\/pre>\n
Case BOUNCE and PRESSED state<\/span><\/p>\n
When it comes to the BOUNCE, it should not do anything until the 50 milliseconds passes. That’s why let’s do nothing until 50 milliseconds passes (shown in Figure 2). <\/span><\/p>\n
Now, here I recheck the button  pad value. So, <\/span>if(btn_pad_value)<\/b>,if it is set, then go to Pressed state.  <\/span>btn_sm_state = PRESSED;  else btn_sm_state = NOT_PRESSED;<\/b> and then <\/span>break<\/b>;<\/span><\/span><\/p>\n
 <\/p>\n
While it is in the PRESSED state<\/span>, if btn_pad_value is 0, it must go to the BOUNCE state. And since it is going to the Bounce state, you have to reinitialize the current time. Because this marks the starting point, the 50 milliseconds are recalculated. So, millis(). Put a break statement. <\/span><\/p>\n
And also <\/span>process_button_pad_value<\/b> function returns something. See Figure 5, If it is really Pressed, if the  <\/span>process_button_pad_value<\/b> function decides that after 50 milliseconds, something has really Pressed, then it has to return the btn_pad_value. <\/span><\/span><\/p>\n
Because this btn_pad_value is a value after the software debounces, after waiting for 50 milliseconds, that\u2019s why let\u2019s return that value back to the caller.  <\/span><\/p>\n
And <\/span>process_button_pad_value <\/b>function by default returns 0. <\/span><\/span><\/p>\n
 <\/p>\n
void<\/span> setup() {\r\n   \/\/ put your setup code here, to run once:<\/span>\r\n   Serial<\/span>.begin(115200);\r\n   display_init();\r\n   Serial<\/span>.println(\"Productive timer application\");\r\n   Serial<\/span>.println(\"===========================\");\r\n   pinMode(PIN_BUTTON1,INPUT);\r\n   pinMode(PIN_BUTTON2,INPUT);\r\n   pinMode(PIN_BUTTON3,INPUT);\r\n\r\n   protimer_init(&protimer);\r\n}<\/pre>\n
setup() function<\/span><\/p>\n
Now let\u2019s give attention to implementing the lcd.c and lcd.h files. That will be our last implementation, and after that, we can test it. <\/span><\/p>\n
First of all, we will write the setup function. In the setup function, we have to do various setups. <\/span><\/p>\n