Follow and star our official account to reach exciting content
ID: Technology Makes Dreams Greater
The main function of a microcontroller is to control peripheral devices and achieve certain communication and data processing.
However, in certain specific situations, mathematical operations are inevitably required, even though microcontrollers are not good at implementing algorithms and performing complex calculations.
This article mainly introduces how to implement digital filtering using a microcontroller.
When collecting data with a microcontroller, random errors in data can occur, which are caused by random interference. The characteristic is that when measuring the same quantity under the same conditions, its size and sign will change unpredictably, but the results of multiple measurements conform to statistical laws.
To overcome errors caused by random interference, filtering technology can be used in hardware, and software algorithms can be used to implement digital filtering. Filtering algorithms are often an important component of system measurement and control algorithms, with strong real-time performance.
Using digital filtering algorithms to overcome errors from random interference has the following advantages:
-
Digital filtering does not require additional hardware costs, only a computation process, is highly reliable, and does not have impedance matching issues. In particular, digital filtering can filter signals with very low frequencies, which analog filters cannot achieve.
-
Digital filtering is implemented using software algorithms, and multiple input channels can share a filtering program, reducing system costs.
-
By appropriately changing the filtering program or calculations, the filtering characteristics can be easily modified, which can have a significant effect on filtering out low-frequency interference and random signals.
-
Common filtering algorithms used in microcontroller systems include limit filtering, median filtering, arithmetic average filtering, weighted average filtering, and moving average filtering.
Limit Filtering Algorithm
During this operation, the difference between two adjacent samples is calculated to find the increment, and then the absolute value of the increment is compared with the maximum allowable difference A.
The size of A depends on the specific situation of the measured object. If it is less than or equal to the maximum allowable difference, the current sample is valid; otherwise, the last sample value is taken as the sample for this data.
The algorithm’s program code is as follows:
1#define A //Maximum allowable difference
2
3char data; //Last data
4
5char filter()
6
7{
8
9 char datanew; //New data variable
10
11 datanew=get_data(); //Get new data variable
12
13 if((datanew-data)>A||(data-datanew>A))
14
15 return data;
16
17 else
18
19 return datanew;
20
21}
The limit filtering method is mainly used to process slowly changing data, such as temperature, object position, etc. When using it, it is crucial to select an appropriate gate limit A. This can usually be obtained from empirical data and can be obtained through experiments if necessary.
Median Filtering Algorithm
The process of this operation is to continuously sample a parameter N times (N is generally an odd number), then arrange the N sampled values in ascending order and take the middle value as the current sample value. This process is essentially a sequence sorting process.
The algorithm’s program code is as follows:
1#define N 11 //Define the number of data to be obtained
2
3char filter()
4
5{
6 7 char value_buff[N]; //Define an array to store data
8 9 char count,i,j,temp;
1011 for(count=0;count<N;count++)
1213 {
1415 value_buff[count]=get_data();
1617 delay(); //If data collection is slow, delay or interrupt is needed1819 }
2021 for(j=0;j<N;j++)
2223 {
2425 if(value_buff[i]>value_buff[i+1])
2627 {
2829 temp=value_buff[i];
3031 value_buff[i]=value_buff[i+1];
3233 value_buff[i+1]=temp;
3435 }
3637 }
3839return value_buff[(N-1)/2];
4041}
Note: The median filter is suitable for removing fluctuations caused by random factors and pulsating interference caused by unstable samplers. If the measured value changes slowly, the median filtering method will be more effective, but if the data changes quickly, this method is not advisable.
Arithmetic Average Filtering Algorithm
The basic principle of this algorithm is very simple: continuously take N sampling values and perform arithmetic averaging.
The algorithm’s program code is as follows:
1char filter()
2
3{
4
5 int sum=0;
6
7 for(count=0;count<N;count++)
8
9 {
10
11 sum+=get_data();
12
13 delay();
14
15 }
16
17 return (char)(sum/N);
18
19}
Note: The arithmetic average filtering algorithm is suitable for filtering signals with random interference. The characteristic of such signals is that they have an average value, and the signal fluctuates up and down around a certain value.
The degree of smoothing of the signal entirely depends on the value of N. When N is large, the smoothing is high but sensitivity is low; when N is small, the smoothing is low but sensitivity is high. For convenience in averaging, N is generally taken as powers of 2 such as 4, 8, 16, 32, etc., to replace division with shift operations in the program.
Weighted Average Filtering Algorithm
As mentioned earlier, the “arithmetic average filtering algorithm” has a conflict between smoothness and sensitivity. To coordinate the relationship between smoothness and sensitivity, weighted average filtering can be used.
The principle is to multiply each of the continuous N sampling values by different weighting coefficients and then sum them up. The weighting coefficients are generally small first and then large to highlight the effect of the latter few samples, enhancing the system’s understanding of the trend of parameter changes.
Each weighting coefficient is a decimal less than 1, and the sum must equal 1. Thus, the sum after the weighted operation is the effective sampling value. The mathematical model for weighted average digital filtering is:
In the formula: D is the weighted average of N sampling values; XN-i is the (N-i)th sampling value; N is the number of samplings; Ci is the weighting coefficient. The weighting coefficient Ci reflects the proportion of various sampling values in the average.
Generally, the later the sampling times, the larger the proportion taken, which increases the new sampling’s weight in the average.
The weighted average filtering method can highlight part of the signal to resist another part of the signal, improving the sensitivity of changes in sampling values.
The sample program code is as follows:
1char codejq[N]={1,2,3,4,5,6,7,8,9,10,11,12}; //The code array is the weighting coefficient table, stored in the program storage area
2
3char codesum_jq=1+2+3+4+5+6+7+8+9+10+11+12;
4
5char filter()
6
7{
8
9 char count;
10
11 char value_buff[N];
12
13 int sum=0;
14
15 for(count=0;count<N;count++)
16
17 {
18
19 value_buff[count]=get_data();
20
21 delay();
22
23 }
24
25 for(count=0;count<N;count++)
26
27 sum+=value_buff[count]*jq[count];
28
29 return (char)(sum/sum_jq);
30
31}
Moving Average Filtering Algorithm
The various average filtering algorithms introduced above have a common point: to obtain a valid sampling value, several continuous samplings must be performed, which cannot guarantee the real-time nature of the system when the sampling speed is slow.
The moving average filtering algorithm introduced here samples only once, and the effective sampling value is obtained by averaging the current sampling value and several previous sampling values.
If N sampling values are averaged, a temporary storage area for N data must be opened in the storage area.
Each time a new data is collected, it is stored in the temporary storage area, while the oldest data is removed, ensuring that these N data are always the most recently updated data. A circular queue structure can conveniently implement this data storage method.
The program code is as follows:
1char value_buff[N];
2
3char i=0;
4
5char filter()
6
7{
8
9 char count;
10
11 int sum=0;
12
13 value_buff[i++]=get_data();
14
15 if(i==N)
16
17 i=0;
18
19 for(count=0;count<N;count++)
20
21 sum=value_buff[count];
22
23 return (char)(sum/N);
24
25}
Low-pass Filtering
The differential equation of an ordinary hardware RC low-pass filter can be expressed using a difference equation, allowing software algorithms to simulate the functionality of hardware filtering. After derivation, the low-pass filtering algorithm is as follows:
1Yn=a* Xn+(1-a) *Yn-1
2
3Where: Xn——Current sampling value
4
5Yn-1——Last filtering output value;
6
7a——Filtering coefficient, typically much less than 1;
8
9Yn——Current filtering output value.
From the above formula, it can be seen that the current filtering output value mainly depends on the last filtering output value (note that it is not the last sampling value, which is fundamentally different from weighted average filtering), and the contribution of the current sampling value to the filtering output is relatively small, but it has some corrective effect. This algorithm simulates the function of a low-pass filter with significant inertia. The cutoff frequency of the filtering algorithm can be calculated using the following formula:
1fL=a/2Pit (pi is approximately 3.14…)
2
3Where: a——Filtering coefficient;
4
5t——Sampling interval time;
6
7For example: when t=0.5s (i.e., 2 times per second), a=1/32;
8
9fL=(1/32)/(2*3.14*0.5)=0.01Hz
When the target parameter is a slowly changing physical quantity, this is very effective. On the other hand, it cannot filter out high-frequency noise above half the sampling frequency. In this example, the sampling frequency is 2Hz, so other methods should be used to filter out noise above 1Hz.
The low-pass filtering algorithm is similar to the weighted average filtering, but the weighting coefficients only have two: a and 1-a. For calculation convenience, a is taken as an integer, and 1-a is replaced with 256-a, and the calculation result discards the lowest byte, since there are only two items, a and 1-a, which are compiled into the program in immediate form without additional tables.
Although the sampling value is a unit byte (8-bit A/D), to ensure calculation accuracy, the filtering output value is represented using two bytes, one byte for the integer and one byte for the decimal, otherwise, the output may not change due to discarding the tail number each time.
Assuming Yn-1 is stored in 30H (integer) and 31H (decimal), Yn is stored in 32H (integer) and 33H (decimal).
| Article organized for the dissemination of related technology, copyright belongs to the original author |
| If there is any infringement, please contact for deletion |
Collection of Good Articles from the Past
Graduate student, should I learn microcontrollers or PLCs?
What is “Microcontroller Decryption”?
How can one learn microcontrollers well?
If you find the article good,sharing is also our motivation to continue updating.
5T Resources Giveaway!Including but not limited to:C/C++, Linux, Python, Java, PHP, Artificial Intelligence, PCB, FPGA, DSP, LabVIEW, Microcontrollers, etc.!
Reply “More Resources” in the official account to get it for free, looking forward to your attention~
