How to Handle Switch Debouncing in a Microcontroller Circuit in Embedded C

In this article, we go over how to handle switch debouncing in a microcontroller circuit in embedded C.

Switch debouncing in a phenomenon in which a switch is pressed and electrical contact is made by the switch (or button) to underlying circuitry.

Due to the nature of the contact, it may not be a clean press that creates a single electrical contact. It may debouncing, creating a series of presses that could press a switch (or button) several times, creating unintended effects, such as multiple key presses when only one was desired.

So how can we offset or counter these unintended debouncing effects?

Even though this can be offset, at least somewhat, by hardware by placing circuitry such as capacitors by the switch, the approach we take in this article is through software.

This is the theory behind it.

After a switch is pressed, it will make electrical contact with underlying hardware, which shows it was pressed. This may generate debouncing, which creates multiple electrical contact signals. This, again, may create the unintended effects of multiple presses.

So what we need to do is after we detect a switch or button press to register this press and then immediately afterwards add a delay in our software code so that no other presses are detected within this time frame.

This time frame may be about 200ms or 1/5th of a second. This will block any other switch, button, or key press from being registered in this time frame.

You should test out your circuit with the delay you implement and see if this produces a smooth, real-world experience. If not, adjust until you have a good user experience with your input for your circuit.

So by adding a delay in software after a switch press is register avoids multiple presses within that time of delay.

Below is a keypad, which generates key presses.

As an example, let's say that we have the following circuit below with an STM32F407G discovery board with this keypad connected to it.

After each if statement which searches to see which key is pressed, we add a delay in software which prevents multiple presses in about a 200ms time frame. This offsets against any debouncing that may occur.

You can see this in the code below.

#include <stdint.h> #include <stdio.h> void delay() { for (uint32_t i=0; i< 30000; i++); } int main(void) { //Peripheral registers uint32_t volatile *const pGPIODModeReg= (uint32_t*)(0x40020C00); uint32_t volatile *const pInputDataReg= (uint32_t*)(0x40020C00+0x10); uint32_t volatile *const pOutputDataReg= (uint32_t*)(0x40020C00+0x14); uint32_t volatile *const pClockCtrlReg= (uint32_t*)(0x40023800+0x30); uint32_t volatile *const pPullupDownReg= (uint32_t*)(0x40020C00+0x0C); //Enable the peripheral clock of GPIOD peripheral *pClockCtrlReg |= (1 << 3); //Configure PD0, PD1, PD2, and PD3 as outputs for the rows *pGPIODModeReg &= ~(0xFF); *pGPIODModeReg |= 0x55; //Configure PD8, PD9, PD10, and PD11 as inputs for the columns *pGPIODModeReg &= ~(0xFF << 16); //Enable internal pull up resistors for the columns PD8, PD9, PD10, and PD11 *pPullupDownReg &= ~(0xFF << 16); *pPullupDownReg |= (0x55 << 16); while(1) { //Make all rows high *pOutputDataReg |= 0x0f; //make R1 LOW (PD0) *pOutputDataReg &= ~(1 << 0); //Scan the columns //All columns are active HIGH via the pull up resistors to VDD //We must check each column to see whether it is HIGH or LOW //checks PD8 to see whether it is pressed //If PD8 is LOW, it is pressed //*pInputDataReg is normally HIGH via the pull up resistors //If pressed, it becomes LOW //Checks to see whether PD8 is pressed if(!(*pInputDataReg & (1 << 8))) { delay(); printf("1"); } //Checks to see whether PD9 is pressed if(!(*pInputDataReg & (1 << 9))) { delay(); printf("2"); } //Checks to see whether PD10 is pressed if(!(*pInputDataReg & (1 << 10))) { delay(); printf("3"); } //Checks to see whether PD11 is pressed if(!(*pInputDataReg & (1 << 11))) { delay(); printf("A"); } //Make all rows high *pOutputDataReg |= 0x0f; //make R2 LOW (PD1) *pOutputDataReg &= ~(1 << 1); //Checks to see whether PD8 is pressed if(!(*pInputDataReg & (1 << 8))) { delay(); printf("4"); } //Checks to see whether PD9 is pressed if(!(*pInputDataReg & (1 << 9))) { delay(); printf("5"); } //Checks to see whether PD10 is pressed if(!(*pInputDataReg & (1 << 10))) { delay(); printf("6"); } //Checks to see whether PD11 is pressed if(!(*pInputDataReg & (1 << 11))) { delay(); printf("B"); } //Make all rows high *pOutputDataReg |= 0x0f; //make R1 LOW (PD0) *pOutputDataReg &= ~(1 << 2); //Checks to see whether PD8 is pressed if(!(*pInputDataReg & (1 << 8))) { delay(); printf("7"); } //Checks to see whether PD9 is pressed if(!(*pInputDataReg & (1 << 9))) { delay(); printf("8"); } //Checks to see whether PD10 is pressed if(!(*pInputDataReg & (1 << 10))) { delay(); printf("9"); } //Checks to see whether PD11 is pressed if(!(*pInputDataReg & (1 << 11))) { delay(); printf("C"); } //Make all rows high *pOutputDataReg |= 0x0f; //make R1 LOW (PD0) *pOutputDataReg &= ~(1 << 3); //Checks to see whether PD8 is pressed if(!(*pInputDataReg & (1 << 8))) { delay(); printf("*"); } //Checks to see whether PD9 is pressed if(!(*pInputDataReg & (1 << 9))) { delay(); printf("0"); } //Checks to see whether PD10 is pressed if(!(*pInputDataReg & (1 << 10))) { delay(); printf("#"); } //Checks to see whether PD11 is pressed if(!(*pInputDataReg & (1 << 11))) { delay(); printf("D"); } }//ends while loop }

So you can see delays after each if statement, so that we can effectively handle debouncing with a software approach and do not have to be dependent on hardware.

Through a simple delay function, we can counter debouncing that occurs after a switch press.

And this is how to handle switch debouncing in a microcontroller circuit in embedded C.

Related Resources

How to Set Bits of a Number in C

How to Clear Bits of a Number in C