PROGRAM
DESIGN:
Components for Embedded Programs:
In this
section, we consider code for three structures or components that are commonly
used in embedded software: the state machine, the circular buffer, and the
queue. State machines are well suited to reactive systems such as user
interfaces; circular buffers and queues are useful in digital signal processing.
State Machines
When
inputs appear intermittently rather than as periodic samples, it is often
convenient to think of the system as reacting to those inputs.
The
reaction of most systems can be characterized in terms of the input received
and the current state of the system. This leads naturally to a finite-state
machine style of describing the reactive system’s behavior.
Moreover,
if the behavior is specified in that way, it is natural to write the program
implementing that behavior in a state machine style.
The state
machine style of programming is also an efficient implementation of such
computations. Finite-state machines are usually first encountered in the
context of hardware design.
Stream-Oriented Programming and
Circular Buffers
The data
stream style makes sense for data that comes in regularly and must be processed
on the fly. For each sample, the filter must emit one output that depends on
the values of the last n inputs. In a
typical workstation application, we would process the samples over a given
interval by reading them all in from a file and then computing the results all
at once in a batch process. In an embedded system we must not only emit outputs
in real time, but we must also do so using a minimum amount of memory.
The
circular buffer is a data structure that lets us handle streaming data in an
efficient way. Figure 2.13 illustrates how a circular buffer stores a subset of
the data stream. At each point in time, the algorithm needs a subset of the data
stream that forms a window into the stream. The window slides with time as we
throw out old values no longer needed and add new values. Since the size of the
window does not change, we can use a fixed-size buffer to hold the current
data.
To avoid
constantly copying data within the buffer, we will move the head of the buffer
in time. The buffer points to the location at which the next sample will be
placed; every time we add a sample, we automatically overwrite the oldest
sample, which is the one that needs to be thrown out. When the pointer gets to
the end of the buffer, it wraps around to the top.
Related Topics
Privacy Policy, Terms and Conditions, DMCA Policy and Compliant
Copyright © 2018-2024 BrainKart.com; All Rights Reserved. Developed by Therithal info, Chennai.