MCU key debounce program

Usually, the switches used for buttons are mechanical elastic switches. When the mechanical contacts are opened and closed, due to the elastic effect of the mechanical contacts, a button switch will not be stably connected immediately when closed, nor will it be completely disconnected at once when disconnected. Instead, it will be accompanied by a series of jitters at the moment of closing and disconnecting, as shown in Figure 8-10.
The length of the key stable closing time is determined by the operator, usually more than 100ms. If you deliberately press it quickly, it can reach about 40-50ms, and it is difficult to be lower. The jitter time is determined by the mechanical characteristics of the key, and is generally within 10ms. In order to ensure that the program responds only once to a key closing or disconnection, the key must be debounced. When a key state change is detected, it does not respond immediately, but waits for the closing or disconnection to stabilize before processing. Key debounce can be divided into hardware debounce and software debounce.

Hardware debounce is to connect a capacitor in parallel to the key, as shown in Figure 8-11, and use the charge and discharge characteristics of the capacitor to smooth the voltage burrs generated during the jitter process, thereby achieving debounce. However, in actual applications, the effect of this method is often not very good, and it also increases the cost and circuit complexity, so it is not often used in practice.
In most cases, we use software, i.e. programs, to achieve debounce. The simplest debounce principle is that after detecting a change in the key state, wait for a delay of about 10ms to allow the jitter to disappear before performing another key state detection. If the state is the same as the state just detected, it can be confirmed that the key has stabilized. Slightly modify the previous program to obtain a new program with debounce function as follows. Download this program to the board and try it out. Is the problem of adding numbers multiple times when pressing a button solved? Does it feel good to solve the problem?

This program uses a simple algorithm to achieve key debounce. As a simple demonstration program, we can write it like this, but when actually developing a project, the program is often very large and has many status values. The while(1) main loop needs to constantly scan various status values ​​to see if they have changed and schedule tasks in a timely manner. If this delay operation is added in the middle of the program, it is very likely that an event has occurred, but our program is still in the delay operation. When the event has occurred, the program is still in the delay operation. When we check again after the delay is completed, it is too late and the event cannot be detected. In order to avoid this situation, we should try to shorten the time taken by the while(1) loop once. If a long delay operation is required, we must think of other ways to deal with it.

So how to deal with the delay required for debounce operation? In fact, in addition to this simple delay, we have better ways to deal with the key jitter problem. For example, we enable a timer interrupt, interrupt once every 2ms, scan the key status once and store it, scan 8 times in a row, and see if the key status of these 8 consecutive times is consistent. The time for 8 key presses is about 16ms. If the key status remains consistent within 16ms, it can be determined that the key is now in a stable stage, not in a jitter stage, as shown in Figure 8-12.
If the time on the left is the starting time 0, it will move left every 2ms. Each time it moves, it will determine whether the current 8 consecutive key states are all 1 or all 0. If they are all 1, it will be determined as a bounce, if they are all 0, it will be determined as a press. If 0 and 1 are interlaced, it will be considered as a jitter, and no judgment will be made. Think about it, is this more reliable than a simple delay?

Using this method, we can avoid occupying the execution time of the microcontroller through delay and de-jittering, and instead transform it into a key state judgment rather than a key process judgment. We only judge the 8 consecutive states of the current key for 16ms, and no longer care about what it has done in these 16ms. Then, we will implement it with a program according to this idea, and also take K4 as an example. This algorithm is a good method that we often use in actual projects. I would like to introduce it to you. You can use this method to eliminate jitter in the future. Of course, there are other methods to eliminate jitter, and the program implementation is even more diverse. You can also consider other algorithms and expand your ideas.