It's not a filter at all, it's a recursive estimator which is very convenient to implement as a computer algorithm ; i.e. for each instance, you use the previous output as an input.
To grasp the meaning of Kalman Filter by starting from definitions and complicated equations is nearly impossible.The equation below, is much easier to start with.
The k's on the subscript are states. Here we can treat it as discrete time intervals, such as k=1 means 1ms, k=2 means 2ms.
Our purpose is to find 
, the estimate of the signal x. And we wish to find it for each consequent k's.
Also here, 
is the measurement value. Keep in mind that, we are not perfectly sure of these values. Otherwise, we won't be needing to do all these. And 
is called "Kalman Gain" (which is the key point of all these), and 
is the estimate of the signal on the previous state.
The only unknown component in this equation is the Kalman Gain . Because, we have the measurement values, and we already have the previous estimated signal. You should calculate this Kalman Gain for each consequent state.
On the other hand, let's assume to be 0.5, what do we get? It's a simple averaging! In other words, we should find smarter coefficients at each state. The bottom line is :
"Kalman filter finds the most optimum averaging factor for each consequent state;& somehow remembers a little bit about the past states."
Build a Model
First of all, we must be sure that, Kalman filtering conditions fit to our problem.
The two equations of KLF are:
It means that each xk (our signal values) may be evaluated by using a linear stochastic equation (the first one). Any xk is a linear combination of its previous value plus a control signal uk and a process noise (which may be hard to conceptualize). Remember that, most of the time, there's no control signal uk.
The second equation tells that any measurement value (which we are not sure its accuracy) is a linear combination of the signal value and the measurement noise. They are both considered to be Gaussian.
The process noise and measurement noise are *statisticlly independent. [*(of events or values) having the probability of their joint occurrence equal to the product of their individual probabilities.] The entities A, B and H are in general form matrices. But in most of our signal processing problems, we use models such that these entities are just numeric values. Also as an additional ease, while these values may change between states, most of the time, we can assume that they're constant. If we are pretty sure that our system fits into this model , the only thing left is to estimate the mean and standard deviation of the noise functions Wk-1 and vk. We know that, in real life, no signal is pure Gaussian, but we may assume it with some approximation. This is not a big problem, because we'll see that the Kalman Filtering Algorithm tries to converge into correct estimations, even if the Gaussian noise parameters are poorly estimated. The only thing to keep in mind is : "The better you estimate the noise parameters, the better estimates you get." |
 |
| Starting the Process |
When you fit your problem(model) into the KLF, the next step is to determine the parameters and the initial values.
We have two distinct set of equations :
*Time Update (prediction) and *Measurement Update (correction). Both equation sets are applied at each kth state.
[*Can be derived from the linear stochastic difference equation (2 equations of KLF), by taking the partial derivative and setting them to zero ]
Time Update (prediction)
Measurement Update (correction)
When we make the modeling , we know the matrices A, B and H. Most probably, they will be numerical constants.(And even most probably, they'll be equal to 1.)
R is rather simple to find out, because, in general, we're quite sure about the noise in the environment. But finding out Q is not so obvious.
To start the process, we need to know the estimate of x0, and P0.
Iterate
Since we gathered all the information we need and started the process, now we can iterate through the estimates. Previous estimates will be the input for the current state.
| Here, In Measurement Update equations, we really find The values we evaluate at Measurement Update stage are also called "posterior" values. Which also makes sense. |
|
source: http://bilgin.esme.org
********************************************************
 |
|
Now let's try to estimate a scalar random constant, such as a "voltage reading" from a source. So let's assume that it has a constant value of aV (volts) , but of of course these are noisy readings above and below a volts. And we assume that the standard deviation of the measurement noise is 0.1 V.
Now let's build our model:
We have reduced the equations to a very simple form.
• Above all, we have a 1 dimensional signal problem, so every entity in our model is a numerical value, not a matrix.
• We have no such control signal uk, and it's out of the game
• As the signal is a constant value, the constant A is just 1, because we already know that the next value will be same as the previous one. We are lucky that we have a constant value in this example, but even if it were any other linear nature, again we could easily assume that the value A will be 1.
• The value H = 1, because we know that the measurement is composed of the state value and some noise. You'll rarely encounter real life cases that H is different from 1.
Let's as
| TIME (ms) | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 |
| VALUE (V) | 0.39 | 0.50 | 0.48 | 0.29 | 0.25 | 0.32 | 0.34 | 0.48 | 0.41 | 0.45 |
We should start from somewhere, such as k=0. We should find or assume some initial state. Here, we throw out some initial values. Let's assume estimate of X0 = 0, and P0 = 1. Then why didn't we choose P0 = 0 for example? It's simple. If we chose that way, this would mean that there's no noise in the environment, and this assumption would lead all the consequent
to be zero (remaining as the initial state). So we choose P0 something other that zero.Let's write the Time Update and Measurement Update equations.
Now, let's calculate the
values for each iteration.
Here, I displayed the first 2 state iterations in detail, the others follow the same pattern. I've completed the other numerical values via a computer algorithm, which is the appropriate solution.
The chart here (right) shows that the Kalman Filter algorithm converges to the true voltage value. Here, I displayed the first 10 iterations and we clearly see the signs of convergence. In 50 or so iterations, it'll converge even better.
To enable the convergence in fewer steps, you should
• Model the system more elegantly
• Estimate the noise more precisely
