Embedded System Design, Vahid/Givargis Last update: 10/12/99 5:08 PM
Any embedded system’s functionality consists of three aspects: processing, storage,
and communication. Processing is the transformation of data, storage is the retention of
data for later use, and communication is the transfer of data. Each of these aspects must
be implemented. We use
to implement processing,
to implement communication. The earlier chapters described common
processor types: general-purpose processors, standard single-purpose processors, and
custom single-purpose processors. This chapter describes memories.
A memory stores large numbers of bits. These bits exist as
for a total of
bits. We refer to a memory as an
m x n
address input signals are necessary to identify a particular word. Stated another way, if a
address inputs, it can have up to
signals are necessary to output
(and possibly input) a selected word. To
a memory means to retrieve the word of a
particular address, while to
a memory means to store a word in a particular address.
Some memories can only be read from (ROM), while others can be both read from and
written to (RAM). There isn’t much demand for a memory that can only be written to
(what purpose would such a memory serve?). Most memories have an enable input; when
this enable is low, the address is ignored, and no data is written to or read from the
Read-only memory -- ROM
, or read-only memory, is a memory that can be read from, but not typically
written to, during execution of an embedded system. Of course, there must be a
mechanism for setting the bits in the memory (otherwise, of what use would the read data
serve?), but we call this "programming," not writing. Such programming is usually done
off-line, i.e., when the memory is not actively serving as a memory in an embedded
system. We usually program a ROM before inserting it into the embedded system. Figure
1(b) provides a block diagram of a ROM.
We can use ROM for various purposes. One use is to store a software program for a
general-purpose processor. We may write each program instruction to one ROM word.
For some processors, we write each instruction to several ROM words. For other
processors, we may pack several instructions into a single ROM word. A related use is to
store constant data, like large lookup tables of strings or numbers.
Another common use is to implement a combinational circuit. We can implement
any combinational function of
variables by using a
ROM, and we can implement
functions of the same
variables using a
ROM. We simply program the ROM to
implement the truth table for the functions, as shown in Figure 2.
Figure 3 provides a symbolic view of the internal design of an 8x4 ROM. To the