Temperature Control Unit—Modeling and Implementation of a Particle Filter on a Microcontroller

Abstract

The paper discusses the possibilities of using particle filter estimation algorithms in embedded systems. For this purpose, the dedicated testing platform was built, which allowed for the determination of the estimation quality of a particle filter on a real system, and the microcontroller performance in that scenario. Tests were performed using the obsolete and not very efficient, although energy-saving, STM32F4 Discovery board—it has allowed for an in-depth analysis, and the results can be easily improved by switching to a modern platform. The quality of operations in open- and closed-loop systems was investigated based on the analysis of time simulations conducted for various mathematical models. These analyses made it possible to establish a correlation between the number of particles and the required calculation power. They have shown that it is possible to successfully implement and run a particle filter algorithm on an older and computationally limited device, as well as in real-time scenarios.

1. Introduction

Autonomous and stand-alone solutions that can work together are becoming increasingly popular in automation and robotics [1,2]. This makes it possible to build a fault-tolerant unit, which can act independently of a powerful main server and allows for reducing the amount of data transmitted over the network. The goal can be achieved by putting some data processing mechanisms in peripheral units [3], such as microcontrollers. The advantages of this approach are (1) the insensitivity to server malfunction and (2) the high availability rate. Unfortunately, it may result in poor output quality, e.g., of sensor value estimations, because of the generally lower performance of a unit, and the limited hardware resources. The situation may be even more difficult if a sophisticated algorithm, such as a particle filter (PF) [4], is used, which produces a high-quality output but requires a more powerful processing unit compared to other estimation algorithms [5]. Higher output quality means a better match to the real-life signal value, which is desirable.

In a case where the measurement data needs to be improved, or it is necessary to determine the values of non-measurable variables, state estimation is desirable. Formerly, thanks to the low computational complexity, static estimation, such as weighted least squares (WLS) [6], was mainly used in automation. Unfortunately, low computational complexity was accompanied by low estimation quality. With the development and increased capabilities of computing devices, dynamic state estimation approaches have become widely used. One of the most popular methods for linear systems was the Kalman filter (KF) [7,8], proposed by Rudolf Kalman in 1960 [9]. Later, many variants of Kalman filters for estimating a state of nonlinear systems were proposed. The most common modifications are: based on static linearization, the extended Kalman filter (EKF) [10], and, based on the unscented transformation, the unscented Kalman filter (UKF) [11]. Other interesting modifications can be found in [12,13,14,15]. A more complex algorithm, but also of better output quality for highly nonlinear objects, is the particle filter (PF), proposed in 1993 by Gordon, Salmond, and Smith [4]. It is based on the randomization of particles and the calculation of their weights best matching the system’s actual output. Over the years, various types of particle filters have been developed, such as an auxiliary particle filter (APF) [16] or a likelihood particle filter (LPF) [17]. The main differences involve selecting the transition function from which the particles are drawn. The particle filter is extremely useful in scenarios where enough processing power is available. In previous works, the authors proposed a modification relating to the parallelization of the basic particle filter, dividing it into smaller parts—the sub-filters. The code can be efficiently parallelized [18], resulting in a reduction of processing time without a negative impact on the output quality (except for the resampling step, which is very important in PF methods and, unfortunately, cannot be parallelized).

Problems of applying the efficient use of microcontrollers and PF together have been analyzed in several works [19,20,21]. The researchers used a variety of platforms, ranging from hardware to software. The researchers used different types of platforms, which varied at the hardware and software levels. Some of them were built on commercial hardware platforms offered by, e.g., LEGO Mindstorms. The common parts of the above-mentioned platforms are a high-performance processor and a large amount of RAM memory. The platforms based on low-cost boards such as Nucleo and Discovery boards from ST, Arduino family boards, or just ESP8266 are rare. That was the motivation to test one of the mentioned platforms and check its performance. In our case, we decided to get an older platform—the results can be easily improved by simply replacing the board with its newer equivalent.

The main subject of research in this publication is the state estimation in the temperature control system. The object was prepared as a dedicated platform for this research. In the literature, there are examples of the use of state estimation of thermal processes. For example, in [22], a particle filter was used to regulate the temperature, with the proposed adjustment of particle weights to improve the operation of the algorithm. The authors rely on a complex non-linear process model. In [23], the authors experimentally determined the parameters of the temperature control model, both in an open- and closed-loop system. However, the model was based only on measurement information—the development of the research may be the use of state estimation to improve this information. One can find many sources on the use of temperature estimation for various devices. In works [24,25], the new temperature estimation technique in a permanent magnet using Kalman filtering is proposed. The article [26] presents a review of various methods of state estimation in battery modeling tasks, using the state of temperature too.

In this paper, emphasis is put on the implementation of PF on a computationally weak device; therefore, a simplified (linear) model is adopted concerning [22]. Such an approach provides better implementation options and the opportunity to increase the number of particles. Various versions of the mathematical model that have been proposed can be successfully used for state estimation.

The structure of the work is as follows. Section 2 describes the particle filter algorithm. Section 3 contains the description of the computing platform. Section 4 describes the control object and the procedure of how to identify it. Section 5 describes the results of the experiments. Section 6 and Section 7 contain the discussion and summary, respectively.

2. Particle Filter

The particle filter is a state estimation algorithm that can be used on linear or nonlinear discrete-time systems, including systems with non-Gaussian noises. The system is represented by the following equations:

$$\left\{\begin{array}{c}{\mathbf{x}}^{(k+1)}=\mathbf{f}({\mathbf{x}}^{\left(k\right)},{\mathbf{u}}^{\left(k\right)};k)+{\mathbf{v}}^{\left(k\right)}\hfill \\ {\mathbf{y}}^{\left(k\right)}=\mathbf{g}\left({\mathbf{x}}^{\left(k\right)}\right)+{\mathbf{n}}^{\left(k\right)}\hfill \end{array}\right.,$$

(1)

where k denotes the time step number, ${\mathbf{x}}^{\left(k\right)}$ is the state vector, ${\mathbf{u}}^{\left(k\right)}$ is the control inputs vector, ${\mathbf{y}}^{\left(k\right)}$ is the vector of measurement outputs, $\mathbf{f}(·)$ is the transition functions vector, and $\mathbf{g}(·)$ is the measurement functions vector, ${\mathbf{v}}^{\left(k\right)}$ and ${\mathbf{n}}^{\left(k\right)}$ are the process and measurement noises, respectively. The transition and measurement model can be linear or nonlinear. In the latter case, the equations of state cannot be written in a matrix form [27].

The main purpose of the state estimation is to obtain internal variables ${\mathbf{x}}^{\left(k\right)}$ that cannot be directly measured and to filter out measurement noise from the signals ${\mathbf{y}}^{\left(k\right)}$.

The basis of the particle filter is the recursive Bayesian filter algorithm [28,29]

$$p\left({\mathbf{x}}^{\left(k\right)}|{\mathbf{Y}}^{\left(k\right)}\right)=\frac{p\left({\mathbf{y}}^{\left(k\right)}|{\mathbf{x}}^{\left(k\right)}\right)p\left({\mathbf{x}}^{\left(k\right)}|{\mathbf{Y}}^{(k-1)}\right)}{p\left({\mathbf{y}}^{\left(k\right)}|{\mathbf{Y}}^{(k-1)}\right)},$$

(2)

where:

• ${\mathbf{Y}}^{\left(k\right)}=\{{\mathbf{y}}^{\left(1\right)},\dots ,{\mathbf{y}}^{\left(k\right)}\}$—the set of output vectors,
• $p\left({\mathbf{x}}^{\left(k\right)}|{\mathbf{Y}}^{\left(k\right)}\right)$—the posterior Probability Density Function (PDF);
• $p\left({\mathbf{y}}^{\left(k\right)}|{\mathbf{x}}^{\left(k\right)}\right)$—the likelihood;
• $p\left({\mathbf{x}}^{\left(k\right)}|{\mathbf{Y}}^{(k-1)}\right)$—the prior PDF;
• $p\left({\mathbf{y}}^{\left(k\right)}|{\mathbf{Y}}^{(k-1)}\right)$—the evidence which is given by equation

$$p\left({\mathbf{y}}^{\left(k\right)}|{\mathbf{Y}}^{(k-1)}\right)=\int p\left({\mathbf{y}}^{\left(k\right)}|{\mathbf{x}}^{\left(k\right)}\right)p\left({\mathbf{x}}^{\left(k\right)}|{\mathbf{Y}}^{(k-1)}\right)d{x}^{\left(k\right)}.$$

(3)

The posterior PDF in the particle filter is represented by a set of particles, and its weights are given by $\{{\mathbf{x}}^i,q^i\}$, where each particle ${\mathbf{x}}^i$ has a weight $q^i$, for $i=\{1,\dots ,N_p\}$. The approximation of posterior PDF for a large number of particles can be written as

$$\begin{array}{c}p\left({\mathbf{x}}^{\left(k\right)}|{\mathbf{Y}}^{\left(k\right)}\right)\stackrel{N_p\to \infty }{=}\widehat{p}\left({\mathbf{x}}^{\left(k\right)}|{\mathbf{Y}}^{\left(k\right)}\right)=\sum _{i=1}^{N_p}{q}^{i,\left(k\right)}\delta \left({\mathbf{x}}^{\left(k\right)}-{\mathbf{x}}^{i,\left(k\right)}\right),\hfill \end{array}$$

(4)

where $\delta (·)$ denotes a Dirac Delta function.

The first proposed particle filter algorithm is the bootstrap algorithm [4,28] presented in Algorithm 1 and in Figure 1.

Algorithm 1: Bootstrap Particle Filter (BPF)

1. Initialization. Draw $N_p$ initial values from the posterior PDF ${\mathbf{x}}^{i,\left(0\right)}\sim p\left({\mathbf{x}}^{\left(0\right)}\right)$. Set time step $k:=1$. Do this step only once.

2. Prediction. Draw the new particles ${\mathbf{x}}^{i,\left(k\right)}\sim p\left({\mathbf{x}}^{\left(k\right)}\right|{\mathbf{x}}^{i,(k-1)})$, where $i=\{1,\dots ,N_p\}$ from the transition model.

3. Update. Determine the weights of the $N_p$ particles based on the measurement model $$q^{i,\left(k\right)}=p\left({\mathbf{y}}^{\left(k\right)}\right|{\mathbf{x}}^{i,\left(k\right)}).$$ (5)

4. Normalization. Scale values of the weights in such a way that their sum equals 1.

5. Resampling. Draw $N_p$ particles from among those that already exist. The PDF for drawing is defined by the set of normalized weights (the systematic resampling is applied [30]).

6. End of the iteration. Estimate the state vector at k-th time step, increase the time step $k=k+1$. Jump to the 2nd step.

3. The Platform

Our tests were carried out on a temperature control system, prepared as a dedicated platform built of commercially available elements. The platform consists of three related parts:

• A case—made of steel, plexiglass, printable elements;
• Hardware—microcontroller, sensors, H-bridge, and others;
• Software—code written in the C programming language.

The case (Figure 2) was designed in the Autodesk Inventor and was printed using ABS material. The general idea was to build a chamber that would be partially independent of the external environment and relatively small. As air volume has a great impact on the heating and cooling time of the air inside the chamber; only a small amount of free space was left for additional new measurement instruments. Besides the aspects of functionality, we decided to consider a visual aspect and used plexiglass windows, which enabled us to look inside the case. The dimensions of the box are shown in Figure 3. The total outer case size is 120 × 80 × 70 mm.

For measurement and control purposes, we decided to use the STM32F4 Discovery evaluation board, which is quite old and nowadays does not offer a great performance compared to other boards. We decided that if the solution works fine on this microcontroller, it can work even better on modern embedded platforms. Besides the board, we used two DS18B20 thermometers using a 1-wire interface, one L298N H-bridge controlled by PWM (pulse width modulation), one 40 × 40 × 10 12 V PC fan, one 10 W light-emitting diode (LED), and a PL2303HX converter, which allowed us to communicate with the board through the USART interface. One thermometer and one LED were put inside the chamber. The fan was placed on one side of the case. It allowed two goals to be reached: at low speed, it forced the airflow inside the case to equalize the temperature in the case, whereas at high speed, it cooled down the chamber. The microcontroller, H-bridge, and second thermometer were placed outside the case. We decided to use the led diode as a heater because it produces a large amount of heat and does not need a powerful power supply, which was confirmed in our internal tests in the past. The output power of the diode can be programmed to work between $0\%$ and $100\%$. The power of the diode was reduced by a resistor, as suggested by the manufacturer. The fan can also be controlled, but in the range of $30\%$ to $100\%$ percent. The whole system is shown in Figure 4. The peripherals, which are an integral part of the case, are shown in the Figure 2.

An algorithm written in the C programming language controls the system. We used the STM32CubeIDE environment for board programming and Hercules software for communication over the USART interface. The code was divided into several parts that work together. The PF algorithm was rewritten from our original code in C# language [18] and modified to work with the object.

For the purpose of the estimation algorithm, the system was modelled by several mathematical models explained in the next section. The experiment can be in one of three states: heating, normal (keeping), and cooling down, according to the control inputs. Different models are used when the temperature decreases or when it increases. The switch of the models is based on the indoor temperature, the user-expected temperature, and the tolerance range: $\pm 0.26$ (the value results from the highest resolution of DS18B20, which is $0.065$). The measured temperature has an accuracy of $0.065$. The second thermometer was not used directly in the system during the main tests, it was only used to perform comparison measurements.

4. Research Objects—The Mathematical Models

4.1. Simulation Object

The microcontroller was used in simulated tests and under real-world conditions. For simulation purposes, we used common particle filters examination [4]. According to [31], this object was first proposed in 1978 by Netto, Gimeno, and Mendes. The object is one-dimensional and has no external inputs; it is autonomous. The state change is only due to the presence of process noise. It is given by the discrete-time state-space equations

$$\left\{\begin{array}{c}{x}^{(k+1)}=0.5x^{\left(k\right)}+\frac{25x^{\left(k\right)}}{1+{\left(x^{\left(k\right)}\right)}^2}+8cos\left(1.2k\right)+v^{\left(k\right)}\hfill \\ y^{\left(k\right)}=\frac{{\left(x^{\left(k\right)}\right)}^2}{20}+n^{\left(k\right)}\hfill \end{array}.\right.$$

(6)

Simulation parameters: $v^{\left(k\right)}\sim \mathcal{N}(0;10)$, $n^{\left(k\right)}\sim \mathcal{N}(0;1)$, $x^{\left(0\right)}=0.1$.

4.2. Real Object—Heating and Cooling System

To implement the particle filter algorithm for the real system, it was necessary to define a mathematical model of the tested object. In the literature, many examples involve the modeling and testing of the heating system [32,33,34], but in this study, two-inertial objects were established. The detailed course of the thermal process identification experiment in different versions can be found in [23]. The selected type of system is universal and is often used in the synthesis of a controller [35]; it is given by a transfer function,

$$G\left(s\right)=\frac{K}{(1+s{T}_1)(1+s{T}_2)},$$

(7)

and the differential equation

$$\ddot{y}\left(t\right)=-\left(\frac{1}{T_1}+\frac{1}{T_2}\right)\dot{y}\left(t\right)-\frac{1}{T_1{T}_2}y\left(t\right)+\frac{K}{T_1{T}_2}u\left(t\right),$$

(8)

where t denotes continuous time, K is the gain of the object, and $T_1$ and $T_2$ are the time constants. The notation $\dot{y}$ and $\ddot{y}$ stand for $\frac{dy}{dt}$ and $\frac{d^{2}y}{d{t}^2}$, respectively. Noises that affect the object have been ignored in the continuous-time model.

To identify the parameters of the object, tests with various amplitude step controls were carried out, during which the gain and time constant for the experiments were adjusted. Separate tests were carried out for the heating and cooling processes as different dynamic properties were then demonstrated by the models. Constant parameters were selected for the heating process (denoted by subscript h), while in the case of cooling (subscript c), the gain depends on the initial temperature $y\left(0\right)$ that at the beginning of the experiment should be ideally equal to the temperature measured outside. The resulting parameters in the two modes are as follows:

• heating: $K_h=0.0526$, $T_{h,1}=36.32$, $T_{h,2}=508.48$;
• cooling: $K_c=0.2069-\frac{y\left(0\right)}{100}$, $T_{c,1}=25.00$, $T_{c,2}=148.00$.

Only two modes are assumed, namely, heating or cooling, in which the controls $u_1$ (diode power—for heating) and $u_2$ (fan power—for cooling) work, respectively. The built model can be considered as a jump system [36,37].

Continuous state-space equations, including phase variables, are given by

$$\left\{\begin{array}{c}\left[\begin{array}{c}{\dot{x}}_1\left(t\right)\\ {\dot{x}}_2\left(t\right)\end{array}\right]=\left[\begin{array}{cc}0& 1\\ -\frac{1}{T_1{T}_2}& -\left(\frac{1}{T_1}+\frac{1}{T_2}\right)\end{array}\right]\left[\begin{array}{c}{x}_1\left(t\right)\\ x_2\left(t\right)\end{array}\right]+\left[\begin{array}{c}0\\ \frac{K}{T_1{T}_2}\end{array}\right]u\left(t\right)\hfill \\ y\left(t\right)=\left[\begin{array}{cc}1& 0\end{array}\right]\mathbf{x}\left(t\right)\hfill \end{array}\right..$$

(9)

The system (9) is then discretized with sample time $T_s=1$ second using the Euler extrapolation method, and the obtained discrete state-space equations (dependent on the model parameters), including the modeling errors (1), are shown below

$$\left\{\begin{array}{c}\left[\begin{array}{c}{x}_1^{(k+1)}\\ x_2^{(k+1)}\end{array}\right]=\left[\begin{array}{cc}1& T_s\\ -\frac{T_s}{T_1{T}_2}& 1-T_s\left(\frac{1}{T_1}+\frac{1}{T_2}\right)\end{array}\right]\left[\begin{array}{c}{x}_1^{\left(k\right)}\\ x_2^{\left(k\right)}\end{array}\right]+\left[\begin{array}{c}0\\ \frac{K{T}_s}{T_1{T}_2}\end{array}\right]u^{\left(k\right)}+\left[\begin{array}{c}{v}_1^{\left(k\right)}\\ v_2^{\left(k\right)}\end{array}\right]\hfill \\ y^{\left(k\right)}=\left[\begin{array}{cc}1& 0\end{array}\right]{\mathbf{x}}^{\left(k\right)}+n^{\left(k\right)}\hfill \end{array}\right..$$

(10)

It is worth noting that particle filters are applied in the heating process as well—an example such a process can be found in [22]. In this paper, the complexity of the object has been limited to two state variables and one control signal due to implementation on a computationally weaker device. The noise of the process included in the PF (1) compensates for the nonlinearity omitted in the model. To simplify the above considerations, the process noise in the transition function and the related disturbance transfer function were omitted. The PF algorithm takes into account the initial condition, namely, the temperature $y\left(0\right)$, read in the first step of each experiment. Tests were performed for various noise variances.

4.3. Real Object—Estimation Using the Outdoor Temperature

A system given by the transfer function (7) can be extended by using not just the measured temperature as an output but the difference between internal and external temperatures $y=T_{in}-T_{out}$. The parameters of this object were matched to the dynamics of changes in the new defined signal y.

As it turns out in the test example, such a model will be very sensitive to disturbances in the form of, for example, changes in the outside temperature. Ultimately, when only $T_{in}$ was used in the transition model and when the initial value only depended on the outside temperature, the model performed better.

4.4. Real Object—Estimation without Using a Physical Model

In this model, the state-space equations are based not only on the dynamics of the system model under consideration but on the speed of temperature changes in the previous step. This approach allows for effective state estimation without knowing the exact dynamics of the process.

The discrete-time state variable $x_1^{\left(k\right)}$ is the estimated temperature and accounts for the rate of change in the output of the previous step, as shown below:

$$x_1^{(k+1)}=x_1^{\left(k\right)}+\Delta y^{\left(k\right)}=x_1^{\left(k\right)}+\left(x_1^{\left(k\right)}-x_1^{(k-1)}\right)=2x_1^{\left(k\right)}-x_2^{\left(k\right)}.$$

(11)

The variable $x_2^{\left(k\right)}$ is used to store the history, representing the state variable from the previous step. Therefore, noise with zero error variance is added to it to obtain $x_2^{(k+1)}-x_1^{\left(k\right)}$.

The matrix expression of the state-space equations, taking into account the process noises and based on (11), is given by

$$\left\{\begin{array}{c}\left[\begin{array}{c}{x}_1^{(k+1)}\\ x_2^{(k+1)}\end{array}\right]=\left[\begin{array}{cc}2& -1\\ 1& 0\end{array}\right]\left[\begin{array}{c}{x}_1^{\left(k\right)}\\ x_2^{\left(k\right)}\end{array}\right]+\left[\begin{array}{c}{v}_1^{\left(k\right)}\\ v_2^{\left(k\right)}\end{array}\right]\hfill \\ y^{\left(k\right)}=\left[\begin{array}{cc}1& 0\end{array}\right]{\mathbf{x}}^{\left(k\right)}+n^{\left(k\right)}\hfill \end{array}\right..$$

(12)

It should be noted that the proposed system is autonomous. The change of state is caused only by the presence of system noise, and the parameters to be adjusted are the variances of the noises. The best estimation (based on the graphs) was observed for the parameters ${\sigma }_{v1}^2={10}^{-6}$, ${\sigma }_{v2}^2=0$, and ${\sigma }_n^2=0.0225$.

This approach can be associated with dynamic linearization, which is used, among others, in the ADRC control algorithm [38]. The result of this linearization is a model in the form of a double integrator. Therefore, the discrete-time characteristic polynomial for (12) is $M\left(z\right)={(z-1)}^2$.

5. Experiments Results

The results of the performed tests show that particle filters can be used successfully in low-performance embedded systems. We prepared three different scenarios:

• A test of the platform performance, including a comparison with the original C# implementation,
• A heating and cooling test,
• A heating and normal test.

From among all the conducted tests, only several are chosen to be presented in this section. The remaining test results are shown in Appendix A.

5.1. PF Performance Comparison

The performance is a very important part of data processing, especially in embedded systems. In this part of the tests, we compare the results from four different platforms, including solutions in which processing is done on an outside computer unit or on an embedded board (the details are given in

Table 1. Specification of the hardware platform used in the experiments.

Platform A	Processor	AMD Ryzen 7 2700 (3.20 GHz)
	Memory	DDR4/64 GB
	Operating system	Microsoft Windows 10 (×64)
Platform B	Processor	Intel Core i5 4210M (2.60 GHz)
	Memory	DDR3/8 GB
	Operating system	Microsoft Windows 8.1 (×64)
Platform C	Processor	Intel Atom D525 (1.80 GHz)
	Memory	DDR3/4 GB
	Operating system	Microsoft Windows 7 (×64)
Platform D	Processor	STM32F407VGT6 (168 MHz)
	Memory	192 kB
	Operating system	n/a

). The original C# code, expressing the particle filter algorithm and prepared for platforms A, B, and C, was rewritten to the C language because of the board (platform D) requirements. We also decided to prepare two different versions of the code—a standard version without any platform optimization (S), and a highly optimized code (O). The optimized version includes several specified improvements listed below:

1.

Using only float variable types instead of double (in the entire code);

2.

Changing all numbers by adding f postfix (e.g., 3.0f instead of 3.0);

3.

Using float-specific arithmetic functions such as cosf, powf, and sqrtf;

4.

Enabling FPU (floating point unit);

5.

Selecting—Ofast optimization level in the compiler settings.

After applying the improvements, we used the STM32F4 evaluation board to recheck the performance. As STM32F4 has a limited amount of memory, we decided to reduce the maximum number of iterations and particles (additional changes made for optimizing the C code are given later in the text). Platform tests (Table 1) were repeated with the same parameters to achieve reliable results for comparison.

The one-dimensional object described by Equation (6) was used for these simulation tests. The experiment data (noises and state variables) were regenerated during each experiment. Initial tests showing a comparison of the particle filter operation for the considered platforms are given in [18].

Three tests were carried out with the following number of iterations and number of particles (accordingly) used: $N_p=1000$, $M=500$; $N_p=1000$, $M=500$; and $N_p=500$. The results of the tests are shown in Figure 5.

The performance of the microcontroller with the algorithm in the standard version (S) is much worse than on the other compared platforms. The simulation of the object and the particle filter algorithm on the STM32F4 is from 57 to 360 times slower (without any platform-specific optimizations). It is a huge difference that cannot be compensated for by the simulation scenario. In this case, the microcontroller cannot be used in scenarios when a high number of iterations, a high number of particles, and real-time processing are required. The highly optimized version (O) is much more efficient and can compete with other platforms. The differences are related to clock speed, IPC (instructions per cycle), and the hardware architecture of the platform. The comparison of the standard and optimized version is additionally shown in

Table 2. Performance comparison between platform D (O) and D (S).

Number of Iterations	Number of Particles	Average Execution Time D (S) (ms)	Average Execution Time D (O) (ms)
500	500	23,247	640
500	1000	46,374	1376
1000	1000	92,950	3112

.

As embedded systems are called energy-saving, it is obvious that boards such as STM32F4 consume less energy than a powerful PC in general and offer less computational power. However, the question arises of what is the result of power consumption per task. We performed additional tests based on $M=1000$ and $N_p=1000$ to determine it (

Table 3. Comparison of the energy efficiency of the platform; the lowest value of Energy was marked by bold.

Platform	Processing Time (s)	Consumed Energy (Wh)
A	0.249	0.0068
B	0.260	0.0030
C	1.767	0.0155
D (O)	3.110	0.0012
D (S)	91.750	0.0358

). We used a commercially available current clamp meter to measure the electric current and a commercially available multimeter to measure the voltage. The computation time was measured at the code level by a dedicated function. The results obtained are not particularly clear. The powerful platforms calculate the results much faster and during this time can consume less energy. If we compare Platform D (S) with Platform C, we can see that the second platform consumes about $2.3$ times less energy per task. It is important to note that in this case, the low-energy platform consumed more energy. The situation is different if the highly optimized code is used (Platform D (O)). STM32F4 consumes over 10 times less energy than Platform C, which confirms its usability in different tasks. The most important thing for embedded systems is to prepare the code that can be compiled as fast as possible on a used board. It is also worth noting that the energy consumption of platforms A, B, and C contains the energy consumed by the operating systems, which did not occur in the platform D cases.

5.2. Heating and Cooling Test

In the second part of the experiments, the heating and cooling test was performed. We prepared a scenario in which the air in the case was heated to the desired temperature. After reaching the temperature, the air was immediately cooled down to the base temperature ($19.875°\mathrm{C}$). The information collected online was the indoor temperature and the estimated temperature. The quality of the estimation of the data models was tested and compared to the models given by Equations (10) and (12). The results obtained are shown in Figure 6, Figure 7 and Figure 8 and are denoted as ${\widehat{y}}_{m1}$ and ${\widehat{y}}_{m2}$ for the systems (10) and (12), respectively. Figure A1 from Appendix A shows experiments obtained only with the use of the model (10) because these experiments were used to verify the operation of the estimation for various parameters of the particle filter—for different values of set temperatures and different noise variances. For better visibility of the range and approximations, some fragments of the charts are zoomed in on; they are marked with rectangles in the main picture.

The $u_2$ value is never set to zero as it is a signal related to the fan where the minimal PWM duty cycle is 30% due to below the value the fan is not working correctly. WMuch more importantly, we observed that the fan is very useful to mix up the air in the chamber. In cases when the fan is off, the hot air accumulates itself around the heater and above it. In other places of the chamber, the air stays colder. Further, when $u_2$ was changed to 100% and $u_1$ was changed to 0%, we observed air mixing at the beginning of the experiment. This resulted in a sudden increase in the air temperature around the thermometer. When the air became a semi-homogeneous mixture, the temperature drop was similar to the one described in the article. Using values below 30% for $u_2$ would have had a negative impact on the quality of the experiments. Hence the nominal value of the “off” state of the fan was taken as 30%.

Results obtained for various configurations of particle filter parameters were compared—for the noise variances, the number of particles, and for the different temperature values (see Appendix A,

Table A1. Details of the tests performed ($N_p=1000$).

${\mathit{\sigma }}_{\mathit{v}}^2$	${\mathit{\sigma }}_{\mathit{n}}^2$	Temperature
		22.0 $°{C}$	22.5 $°{C}$	23.0 $°{C}$
0.010	0.005	A-1	B-1	C-1
0.005	0.005	A-2	B-2	C-2
0.001	0.010	A-3	B-3	C-3
0.001	0.001	A-4	B-4	C-4
1.000	0.100	A-5	—	—
0.100	1.000	A-6	—	—

and

Table A2. Details of the performed tests (${\sigma }_v^2=0.010$, ${\sigma }_n^2=0.005$).

${\mathit{N}}_{\mathit{p}}$	Temperature
	22.0 $°{C}$	22.5 $°{C}$	23.0 $°{C}$
100	A3-1	B3-1	C3-1
500	A2-1	B2-1	C2-1
1000	A-1	B-1	C-1

). The results show that the estimates fit the measured values despite slight differences in the initial values. This is due to the use of measurement information in the filtration step. With correct PF settings (such as the number of particles, variances, etc.), the initial errors are quickly compensated for, and the estimate begins to follow the measured temperature. When the assumed temperature was reached, the heater was turned off and the model parameters (10) were switched on in PF.

In the case of model (10), a sufficiently large number of particles is needed for a correct estimation. For Equation (12), the estimation also works correctly when the number of particles is reduced. This may be due to the estimation following a mathematical model, which did not keep the history of the previous sample, as was the case with the second one. The dynamics of the system and the impact of external controls can be treated here (in model (12)) as a disturbance in the estimation task. On the other hand, the model based on an inertial object (model (10)) always adjusts the response to the assumed dynamics, primarily following the measured signal and being more sensitive to external noise. Such a phenomenon may be undesirable, for example, when we want to use the estimate to improve the resolution of the measuring device. The model is based on the rate of change averages of the estimates, assuming values other than the resolution of the thermometer. The estimated value increases slowly in this case, as expected for the temperature.

There is also a visible difference in the operation of the system for different values of the outside temperature. As one can see in Figure 6, the system was warming up to the assumed temperature longer than for Figure 7 and Figure 8. In the first case, the ambient temperature was slightly lower than in the others, which increased the time constant in the facility (value of $y_{out}$ approx 19.3 vs. 19.6).

Ultimately, the mathematical model did not to take into account the outside temperature in this research. As one can read in Section 4.3, the model turned out to be very sensitive to even slight disturbances in this temperature. It is possible to effectively estimate the state for the proposed simplified models using only indoor temperature as the measurement.

In addition, the results of estimation errors (13) for the above-mentioned experiments are presented below. One can confirm the conclusions drawn regarding the reduced errors for the $y_{m2}$ chart —see Figure 9.

$${ϵ}^{\left(k\right)}=y^{\left(k\right)}-{\widehat{y}}^{\left(k\right)}$$

(13)

It is worth noting that the PF calculations were performed in discrete time. The timeline on the presented waveforms has been scaled in such a way that it is possible to read the continuous time from it.

5.3. Heating and Normal Test

The next main test with the temperature control system was the heating and normal test. We take into account the scenario where the control $u_1$ takes one of two values, $90\%$ or $10\%$. The desired temperature was $21.5°\mathrm{C}$. The tests were carried out in about 20 min. The results are shown in Figure 10.

The two-position temperature control (with hysteresis) was implemented. The algorithm of the particle filter takes into account the changes in the operating mode at each switch to ensure that the estimate would follow the measured value. Particle filter settings were selected based on previous observations for the heating and cooling test and separately for the heating and the cooling process. The width of the hysteresis was $0.52°\mathrm{C}$ (which is a multiple of the thermometer resolution). Switching between models takes place more often than before, but it is still possible to observe the accurate tracking of the measurement signal by the estimate. The use of the particle filter can improve sensory information and thus the quality of control in a closed-loop system as well.

6. Discussion

Due to the simplicity of the assumed models, some features have been ignored, such as the nonlinearities of the system, the presence of two input signals at the same time, or the impact of the external temperature. This allowed for an effective implementation of an algorithm that operates with a real object on a device with low computing power. The mentioned features were effectively compensated for by the process noise generated in the particle sampling step. The heating process appeared to be more predictable, and the selection of parameters was unproblematic. The cooling process is also more complex to model.

The results were also obtained for various variances and temperatures (see Appendix A). They show that the assumed values of the process and measurement noise variance have a critical impact on the quality of the PF performance. If the value of ${\sigma }_v^2$ is too high, the results affect the significant deviations of the mathematical model from the real object—in the particle sampling process, significant variance noise is added and later particles may not be able to match the actual measurements. For this research, better results were obtained in the case with lower variance values of the process noise (see Figure A1d,e, for example), which proves that the model is well fitted, despite its simplification. It is also shown by the correct operation of the algorithm and the good adjustment of the estimate to the measurements in the case of different temperature values (operating points), as one can see in Figure A1a,j.

The variance of the measurement noise is responsible for the inaccuracies of the sensor. In each test case, the best effects were observed for the ${\sigma }_n^2$ value set comparable to the resolution of the measuring device. An overly high value of the setting resulted in the limiting of the confidence in the measurement in favor of the mathematical model. Ultimately, a compromise must always be made between trusting the model and the measurements. This allows us to compensate for any inaccuracies by the particle filter.

With correctly selected PF settings, a sufficiently large number of particles is needed for an effective state estimation. The number of particles must also be well suited to the computing power of the microcontroller to its capabilities.

In the case of precise process control, the use of feedback from the estimated value may improve the algorithm’s performance. Estimated values are commonly used in control, for example, in the active disturbance rejection control (ADRC) method [39]. Improving the sensory information may be necessary, for example, if the resolution of the measuring device is too low.

7. Conclusions

In the article, an analysis of the possibilities of using the particle filter algorithm in an embedded system was carried out on real-time tasks. For the experiments, a special platform was built. It provided opportunities to perform tests on a real physical object. The main goal was to determine whether a relatively old platform, such as the STM32F4 Discovery board, is capable of performing calculations using particle filters, known for their high hardware requirements. Research has shown that it is possible, even in real-time scenarios. Our current research is focused on the real-time scenario with a much shorter sampling time, especially in tasks associated with drones. It is planned to also extend the research to uncontrolled environmental conditions. In the future, it is planned to carry out tests under various environmental conditions, for example, at very low or very high outdoor temperatures, e.g., by placing the box in an oven or fridge. We also plan to improve the quality of the measurements performed by the UAV on-board sensors. The work presented in this article is preparation for this.