Tema 4 (v1.0B)

DSBM
TEMA 4
EL SUBSISTEMA DE MEMORIA
Versión 1.0A
Vicente Jiménez - Apuntes de DSBM - Tema 4 - Pag. 1

Historial del documento
Fecha Versión Descripción

3/10/2016 1.0A Generado a partir de apuntes de SEBM
3/5/2020 1.1 Corrección ejemplo MCU en M3
Imagen de portada
Vista de layout de una celda SRAM
http://www.eecs.tufts.edu/~ddemeo01/ee103/vlsi_sramCell.htm

Índice de contenidos
4.1 Generalidades ................................................................................................. 4
4.1.1 Notaciones ............................................................................................... 4
4.1.2 Interacción entre la CPU y la memoria ................................................... 5
4.2 Tipos de Memorias ......................................................................................... 9
4.2.1 RAM (Random Access Memory) ............................................................ 9
4.2.2 Memorias no volátiles ........................................................................... 11
4.2.3 Estructura de las memorias .................................................................... 16
4.3 Decodificación de Memoria ......................................................................... 17
4.3.1 Decodificación de direcciones ............................................................... 17
4.3.2 Decodificación Sencilla ......................................................................... 19
4.3.3 Decodificación incompleta .................................................................... 23
4.3.4 Decodificación de direcciones bajas...................................................... 26
4.3.5 Decodificación sencilla e incompleta .................................................... 35
4.3.6 Decodificación con memorias con bus de datos de menos de 8 bits ..... 35
4.3.7 Decodificación con buses de varias calles ............................................. 36
4.3.8 Memorias con varias calles.................................................................... 41
4.3.8 Memorias ROM ..................................................................................... 42
4.3.10 Señales de control ................................................................................ 54
4.3.11 Buses multiplexados ............................................................................ 56
4.4 Decodificación en MCUs ............................................................................. 57
4.4.1 Memoria interna prioritaria ................................................................... 57
4.4.2 Generación interna de CS* .................................................................... 58
4.5 Acceso a DRAM y otras memorias .............................................................. 62
4.5.1 Acceso a memorias DRAM ................................................................... 62
4.5.2 Acceso a memorias Flash ...................................................................... 67
4.6 Organización de la memoria ......................................................................... 69
Anexo I : Ejemplos de decodificación de memoria ............................................ 74
Anexo II : Conversión Decimal ↔ Hexadecimal ............................................... 92

4.1 Generalidades
4.1.1 Notaciones
Antes de empezar a hablar del susbsistema de memoria, resulta conveniente

clarificar algunos criterios respecto a señales con lógica inversa, o negadas. Existen
algunas señales, como es el caso de las señales de validación (strobes), que pueden
ser consideradas como activas o inactivas. Por ejemplo, una señal de habilitación
puede estar activa (habilitada) o inactiva (inhabilitada). Una señal como A, por
ejemplo, sin ninguna señalización especial, identifica una señal que es activa a
nivel alto “1” e inactiva a nivel bajo “0”.
Una señal con una barra encima, como 𝐴𝐴̅, por ejemplo, identifica una señal
que es activa a nivel bajo “0” e inactiva a nivel alto “1”. En lugar de usarse una
barra se pueden usar los símbolos * y #, por tanto, las siguientes indicaciones:
𝐴𝐴̅ 𝐴𝐴 ∗ 𝐴𝐴#
Todas identifican una señal activa a nivel bajo.
Las señales activas a nivel bajo también suelen identificarse en los diagramas
circuitales mediante un círculo tal y como se muestra en la siguiente figura:
D E F G
La señal D será activa alta mientras que las señales E y F serán activas bajas.
En la figura se muestra una señal G con barra y círculo. Usar dos señalizaciones de
negación refuerza la señalización, no la compensa, por tanto, la señal G es también
activa a nivel bajo.
Algunas señales tienen un uso dual dependiendo de si son altas o bajas, en

ese caso cada posible uso se señala sin cualificar para el uso en nivel alto “1” y con
una marca de tipo barra, * o # para el uso en nivel bajo “0”. Así, por ejemplo, una
señal como:
�
𝑅𝑅 ⁄𝑊𝑊
Identifica una señal que señaliza lectura (Read) con el “1” y escritura (Write)
con el “0”. Acabada esta breve discusión sobre notación pasaremos a describir
brevemente la interacción entre la CPU y el subsistema de memoria.

4.1.2 Interacción entre la CPU y la memoria
La memoria es la parte del sistema que almacena el código y los datos del
programa que corre en la CPU.
DATOS
µP
CPU
ΜΕΜ E/S
DIRECCIONES
CONTROL
La CPU, por tanto, se comunica con la memoria empleando tres buses:

Datos, Direcciones y Control. El protocolo es de tipo Master/Slave. La CPU
(Master) controla en todo momento el funcionamiento del sistema. La memoria
(Slave) responde a las órdenes de la CPU.
La interacción entre la CPU y la memoria distingue dos posibilidades. Que la

CPU lea un dato de la memoria o que la CPU escriba un dato en la memoria. A
ambas transacciones se les denomina, respectivamente, Ciclo de Lectura y Ciclo de
Escritura. Obsérvese que al ser la CPU el Master, el significado de lectura o
escritura es siempre visto des del punto de vista de la CPU.
A continuación se muestra un ejemplo de la secuencia de acciones en un ciclo de

lectura:
• CPU pone la dirección a leer en el bus de direcciones

• CPU indica que desea leer la memoria y activa strobes si pertoca
• Memoria pone el dato deseado por la CPU en el bus de datos
• CPU captura el dato y concluye el ciclo
• Memoria retira el dato al haber acabado el ciclo
Obsérvese como es la CPU la que gestiona todas las acciones a realizar.

Obsérvese también que la CPU presupone que la memoria tiene tiempo a poner el
dato entre el momento que la CPU señaliza la orden de lectura y el momento en
que la CPU lee el contenido del bus.

El procedimiento anterior se puede modificar cuando la CPU es capaz de esperar a
que la memoria ponga el dato en el bus. En ese caso el protocolo sería:
• CPU pone la dirección a leer en el bus de direcciones

• CPU indica que desea leer la memoria y activa strobes si pertoca
• CPU espera a que la memoria señalice que ha puesto el dato
• Memoria pone el dato deseado por la CPU en el bus de datos y lo señaliza
• CPU captura el dato y concluye el ciclo
• Memoria retira el dato al haber acabado el ciclo
Obsérvese como en este caso, el hecho de que la CPU espere a que la memoria
responda, se relajan los requisitos temporales de respuesta de la memoria.
Un ciclo de escritura sería simular:
• CPU pone la dirección donde escribir en el bus de direcciones

• CPU pone el dato a escribir en el bus de datos
• CPU indica que desea escribir en la memoria y activa strobes si pertoca
• Memoria guarda el dato en la posición indicada
• CPU concluye el ciclo
Nuevamente la CPU cuenta con que la memoria tiene tiempo de escribir el

dato entre el instante en que se señaliza la escritura y el instante en que concluye el
ciclo. Una vez más, el protocolo se puede modificar para poder usar memorias
lentas:
• CPU pone la dirección donde escribir en el bus de direcciones

• CPU pone el dato a escribir en el bus de datos
• CPU indica que desea escribir en la memoria y activa strobes si pertoca
• CPU espera a que la memoria señalice el fin de la escritura
• Memoria guarda el dato en la posición indicada y lo señaliza
• CPU concluye el ciclo
La diferencia entre las dos opciones es importante ya que en el primer caso

una memoria lenta podría no tener tiempo de guardar el dato en el intervalo
temporal que le proporciona la CPU. En el segundo caso ese problema no ocurre,
pero la memoria ha de ser capaz de generar la señal que avisa a la CPU de la
finalización de la escritura.
Las distintas CPUs que hay actualmente en el mercado gestionan de distinta

manera el protocolo de comunicación con la memoria. A lo largo de este tema
veremos algunos ejemplos, no obstante, casi todas la memorias tienen algunas
características en común que veremos a continuación.

Señales de la memoria
Direcciones MEM
La figura muestra las conexiones que
típicamente tienen las memorias.
Datos
Corresponden a un conjunto de líneas de
OE datos, un conjunto de líneas de direcciones
y tres líneas de control.
WE
Algunas memorias tienen señales
CS adicionales, pero estas señales son comunes
a casi todas.
STROBES
El bus de datos D0..Dn-1 corresponde a la información que entra o sale de la

memoria. Es un bus, por tanto, bidireccional. El número de líneas (o anchura del
bus) n suele ser una potencia de 2. Algunos valores típicos:
• 8 bits (1 Byte)
• 16 bits (2 Bytes)
• 4 bits (1/2 Byte = 1 Nibble)
• 1 bit (1/8 Byte)
El bus de direcciones A0..Am-1 corresponde a la dirección, o lugar, donde se

almacena la información. El número de líneas m, a priori, puede ser cualquier
número. A diferencia de la CPU que usa un bus de direcciones que hace referencia
a Bytes, las memorias usan un bus de direcciones que hacen referencia a
posiciones. Cada posición tiene un elemento del tamaño del bus de datos.
A modo de ejemplo:
Memoria con D0..D7 y A0..A15

El bus de datos es de 8 bits (1 Byte) el bus de direcciones tiene 216 posiciones de 1
Byte. Por tanto:
1𝐵𝐵𝐵𝐵𝐵𝐵𝐵𝐵
216 𝑃𝑃𝑃𝑃𝑃𝑃𝑃𝑃𝑃𝑃𝑃𝑃𝑃𝑃𝑃𝑃𝑃𝑃𝑃𝑃 = 216 𝐵𝐵𝐵𝐵𝐵𝐵𝐵𝐵𝐵𝐵 = 26 210 𝐵𝐵𝐵𝐵𝐵𝐵𝐵𝐵𝐵𝐵 = 64𝐾𝐾𝐾𝐾𝐾𝐾𝐾𝐾𝐾𝐾𝐾𝐾
𝑃𝑃𝑃𝑃𝑃𝑃𝑃𝑃𝑃𝑃𝑃𝑃𝑃𝑃𝑃𝑃
Memoria con D0..D31 y A0..A9

El bus de datos es de 32 bits (4 Bytes) el bus de direcciones tiene 210 posiciones de
4 Bytes. Por tanto:
210 𝑃𝑃𝑃𝑃𝑃𝑃𝑃𝑃𝑃𝑃𝑃𝑃𝑃𝑃𝑃𝑃𝑃𝑃𝑃𝑃 = 212 𝐵𝐵𝐵𝐵𝐵𝐵𝐵𝐵𝐵𝐵 = 22 210 𝐵𝐵𝐵𝐵𝐵𝐵𝐵𝐵𝐵𝐵 = 4𝐾𝐾𝐾𝐾𝐾𝐾𝐾𝐾𝐾𝐾𝐾𝐾

Memoria con D0 y A0..A19
El bus de datos es de 1 bit (1/8 Byte) el bus de direcciones tiene 220 posiciones de 1
bit. Por tanto:
1
𝐵𝐵𝐵𝐵𝐵𝐵𝐵𝐵
2 𝑃𝑃𝑃𝑃𝑃𝑃𝑃𝑃𝑃𝑃𝑃𝑃𝑃𝑃𝑃𝑃𝑃𝑃𝑃𝑃 8
20
= 217 𝐵𝐵𝐵𝐵𝐵𝐵𝐵𝐵𝐵𝐵 = 27 210 𝐵𝐵𝐵𝐵𝐵𝐵𝐵𝐵𝐵𝐵 = 128𝐾𝐾𝐾𝐾𝐾𝐾𝐾𝐾𝐾𝐾𝐾𝐾
Recordad que en terminología de memorias:
K=210 M=220 G=230 T=240
Esta terminología no se ha de confundir con la de los discos duros, donde:
K=103 M=106 G=109 T=1012
Vistos los buses de datos y direcciones pasaremos a describir las señales de

control:
OE* (Output Enable)

Esta señal, activa baja, proporciona una orden de lectura.
Hace que la memoria ponga en el bus de datos el contenido de la posición apuntada
por el bus de direcciones cuando se halla activa (a "0").
WE* (Write Enable)

Esta señal, activa baja, proporciona una orden de escritura.
Hace que la escriba en la posición apuntada por el bus de direcciones el contenido
que se halle en el bus de datos cuando se halla activa (a "0").
Si OE* y WE* están activos (a "0") al mismo tiempo, una de las dos señales tiene
prioridad sobre la otra. Normalmente WE*, pero se ha de verificar en el datasheet
de la memoria.
CS* (Chip Select) también llamada CE* (Chip Enable)

Esta señal, activa baja, activa e chip de memoria.
Si CS* vale "1" (inactiva) la memoria no responderá a ninguna de las señales de
los buses o de control.
Strobes de calle
Estas señales, de validación, normalmente activas bajas, sólo están presentes en
memorias con bus de datos con más de una calle (más de 8 bits). Permiten indicar
que calles se han de emplear en el acceso a memoria tanto para lectura como para
escritura.
Hay tantos strobes de calle como calles tenga el bus de datos de la memoria.
Suele pasar que las señales de la CPU y de la memoria no coincidan. En esos casos
se ha de incluir entre la CPU y la memoria un circuito que haga de interfaz.

4.2 Tipos de Memorias
4.2.1 RAM (Random Access Memory)
Una memoria RAM es aquella en la que se puede leer o escribir a posiciones

aleatorias. Esto es, obedece a la estructura de memoria que hemos explicado hasta
ahora. Existen varios tipos de memoria RAM, algunos de los cuales describiremos
a continuación:
SRAM DRAM
NVRAM FRAM
SRAM (Static Random Access Memory)

La memoria estática almacena cada bit de información en un circuito biestable.
El circuito biestable está compuesto por dos inversores enfrentados. Una

señal Word Line (WL) permite seleccionar el biestable para leer su estado en la
línea BL o BLB o para escribir un nuevo estado forzando valores complementarios
en BL y BLB. La información de las memorias SRAM se pierde si retiramos la
alimentación ya que, en esa circunstancia, el biestable pierde la información de
estado.
DRAM (Dynamic Random Access Memory)

La memoria estática almacena cada bit de información en un condensador.
El condensador CS almacena el valor lógico

asociado a la celda.
Para acceder a una celda podemos activar el

transistor poniendo un "1" en su Word Line
WL.
Para escribir un nuevo valor en la memoria

ponemos un valor alto "1" o bajo "0" en BL y
conectamos BL con el condensador activando
WL.

Para leer la memoria, activamos WL con lo que el condensador CS que
almacena la información se conecta a la línea BL. El problema es que la línea BL
tiene una capacidad CBL parásita, grande e inevitable. Normalmente CBL es unas 10
veces mayor que CS. Eso hace que leer la memoria sea difícil.
Para leer la celda asociada al condensador CS, precargamos la capacidad de

la línea BL CBL con una tensión de la mitad de la alimentación. A continuación
conectamos CS a BL activando WL. La compartición de carga producirá un
pequeño cambio en la tensión de de la línea BL. En concreto, el "0" se detecta
porque la tensión de BL disminuye y el "1" se detecta porque la tensión de BL
aumenta. El cambio, no obstante es muy sutil.
Como puede verse, la lectura de una celda de la DRAM es destructiva. Es por ello
que a toda lectura le ha de seguir un reescritura del valor que anteriormente había
en la celda.
Debido a su gran simplicidad, las memorias DRAM tienen celdas que ocupan
mucho menos espacio que las memorias SRAM. Eso hace que puedan ser mucho
más densas. Por otro lado, lo complicado de su lectura hace que sean más lentas.
Adicionalmente, el hecho de que la información se almacene en un condensador
hace que la información se pierda si tardamos mucho en leerla.
Todas las celdas de las memorias DRAM se han de leer periódicamente para
refrescar su valor antes de que degenere. El tiempo entre refrescos típico que
garantiza no perder el valor almacenado se halla entre 30ms y 60ms.
NVRAM (Non Volatile Random Access Memory)

Una memoria NVRAM es una memoria que conserva la información aunque se
retire la alimentación. En realidad no es una tecnología distinta de la SRAM.
Se puede implementar de varias maneras:
SRAM con pila de salvaguarda que está activa cuando no hay alimentación
SRAM con circuito de salvaguarda formado por un condensador una memoria

EEPROM de salvaguarda. Cuando se detecta que la alimentación cae, se
emplea la energía almacenada en el condensador para hacer funcionar un
circuito que guarda la información de la SRAM en una memoria no volátil
EEPROM.
Cuando vuelve la alimentación, el mismo circuito vuelve a copiar la
información desde la memoria EEPROM a la memoria SRAM.

FRAM (Ferroelectric Random Access Memory)
Una memoria FRAM es una memoria que con estructura similar a la memoria
DRAM que emplea un condensador ferroeléctrico magnetizable.
El condensador tiene histéresis debido a los materiales ferroeléctricos que

contiene. Ello hace que sea capaz de almacenar la información sin necesidad de
refresco ni de alimentación.
Se trata de una tecnología bastante nueva, pero ya hay microcontroladores que

usan FRAM en lugar de Flash o EEPROM como por ejemplo el MSP430FR59xx.
La lista anterior de memorias RAM no incluye todos los diferentes tipos y subtipos
de memoria RAM por lo que es posible encontrar otros tipos.
4.2.2 Memorias no volátiles
Las memorias SRAM y DRAM son volátiles. La información desaparece al

quitar la alimentación. Las memorias NVRAM son en realidad SRAM por lo que
no es una tecnología distinta.
Las memorias FRAM son no volátiles, pero, a efectos prácticos operan como las
memorias DRAM. Su clasificación no está clara.
A continuación describiremos algunas memorias no volátiles todas ellas conservan
la información en ausencia de información y, en general, requieren procedimiento
especial, muy distinto del de lectura, para almacenar información en ellas.
ROM (Read Only Memory)

Una memoria ROM es una memoria que, como su nombre indica, sólo se puede
leer. Al no poder escribirse, no dispone de línea de entrada Write Enable (WE*).
En general, aunque tengan un bus de datos de varias calles, tampoco tienen
strobes. El motivo por el que las memorias ROM no tiene strobes es que éstos no
son realmente necesarios en los ciclos de lectura.
El motivo por el que no hacen falta los strobes en los ciclos de lectura es que
las interacciones entre la CPU y la Memoria tienen la CPU como Master.
Cuando la CPU pide un dato a la memoria, activa el bus de direcciones y los
strobes de las calles que desea que la memoria llene.
Si la memoria llena todas las calles del bus de datos, las que la CPU desea y las
que no, no se produce ningún error porque la CPU, igualmente, al ser Master, sabe
que sólo ha de leer las calles que ha solicitado y no hará caso del resto de las calles
tanto si la memoria las llena como si no.

Los strobes de calle, si son fundamentales, sin embargo, en los ciclos de
escritura, por eso las memorias RAM con varias calles en el bus de datos necesitan
entradas de strobe de calle.
Si la memoria RAM no tuviera entradas de strobe de calle, siempre almacenaría el
contenido de todas las calles tanto si la CPU las llena como si no. Actualizar una
posición de memoria con el contenido de una calle vacía corrompe la información
que contiene por lo que hacer caso a los strobes de calle de la CPU (que identifican
las calles que contienen información) es fundamental en los ciclos de escritura.
Volviendo a las memorias ROM, una memoria ROM, como su nombre indica,
puede leerse pero no escribirse. Eso significa que han de fabricarse ya escritas.
El diseñador de la memoria envía al fabricante de la ROM el contenido que desea
para ésta y, el fabricante, fabrica una máscara específica para el proceso
tecnológico de fabricación de los chips de ROM pregrabados.
La creación de la máscara tecnológica es un proceso muy caro, es por ello

que las ROM puras (de Máscara) únicamente se emplean cuando se han de fabricar
en un número muy elevado. De hecho, la existencia de las memorias de tipo Flash
ha hecho que este tipo de opción hoy en día sea muy poco habitual.
PROM (Programmable Read Only Memory)

Las memorias Mask ROM sólo son viables en grandes cantidades.
Para el desarrollo de un producto de pequeña tirada no es una opción viable.
Una memoria PROM es una memoria que se puede programar su contenido. La
memoria se compra vacía y se escribe su contenido con un programador especial.
De memorias PROM existen varios tipos.
OTP-ROM (One Time Programmable Read Only Memory)

Las memorias OTP ROM son memorias PROM que únicamente pueden
programarse una vez. Una vez programadas no se pueden borrar.
Dir 2n-1
n Dir 2n-2
Direcciones
Dir 2
Dir 1
Dir 0
Pull-Downs
D7 ……………….. D0

Un ejemplo sería una OTP ROM de fusibles como la de la figura de arriba.
Cada línea asociada a una dirección de la memoria se conecta a las 8 líneas del bus
de datos mediante diodos fusibles.
Si los diodos están enteros, en la memoria se lee "1" en todos sus bits.
Si quemamos un fusible haciéndole pasar una corriente alta, será incapaz de forzar
un "1" y se leerá como "0".
EPROM (Erasable Programmable Read Only Memory)

Desarrollar un sistema usando OTP-ROMs no es una buena idea porque quemamos
una en cada prueba y no es borrable.
Las memorias EPROM tienen un transistor como el de la figura de arriba,

con dos puertas, una de ellas flotante, en cada celda.
En una memoria EPROM no programada los transistores se pueden activar
poniendo una tensión en la puerta de control. Ello da una lectura de “1” en la celda
al detectarse que el transistor conduce.
V++
e- e- e-
e-
e-
Si hacemos pasar corriente con una tensión de control elevada en la puerta de

control algunos electrones atravesarán el óxido y entrarán en la puerta flotante
mediante un fenómeno conocido como "Hot electron injection".
El efecto es que los electrones bloquean el campo eléctrico e impiden que el
transistor vuelva a conducir. La celda se leerá, a partir de ahora, como “0”.
Siempre podemos convertir un “1” en un “0”, pero no al revés. No podemos

eliminar los electrones de una celda concreta, sólo añadirlos.

Para borrar la memoria y poder volverla a programar se ha de hacer incidir una
radiación ultravioleta que retire los electrones de la puerta flotante.
Para que puedan ser borradas, las memorias EPROM tienen una ventana
transparente a los rayos ultravioletas. Eso encarece mucho su encapsulado y, por
tanto, la memoria EPROM en conjunto.
Una memoria EPROM encapsulada sin ventana es más barata y no puede ser
borrada nunca. Puede ser, por tanto, vendida como OTP-ROM igual que si fuera
de fusibles.
EEPROM (o E2PROM)
(Electrically Erasable Programmable Read Only Memory)
Las memorias EPROM tienen un encapsulado caro y, borrarlas, es engorroso.
Las memorias EEPROM emplean transistores con puerta flotante similares a

las memorias EPROM. La diferencia es que la puerta flotante está separada por el
drenador por un óxido muy fino, lo bastante para que la puerta flotante puede ser
descargada por conducción tunel mediante un fenómeno conocido como "Fowler-
Nordheim tunneling". En definitiva cada celda se puede escribir y borrar
independientemente.

Pese a que la memoria EEPROM se pueda leer y escribir, el procedimiento
de borrado y escritura es complejo y requiere más tiempo que la lectura.
Respecto de las memorias EPROM tienen la ventaja de que no requieren un
encapsulado especial y se pueden programar sin sacar del sistema (In System
Programming).
Memorias Flash
Las memorias FLASH emplean transistores similares a los de las memorias
EEPROM. A diferencia de las memorias EEPROM, no se pueden borrar las celdas
independientes. En general se pueden escribir a “0” bit a bit, pero el borrado a “1”
se ha de hacer en todo un bloque de múltiples bytes. Pese a ello son más populares
que las memorias EEPROM porque se pueden hacer más densas y baratas.
Las ventajas de actualización ISP hacen que prácticamente haya substituido a las
memorias Mask ROM.
Existen dos tipos de memorias Flash: NOR y NAND.
NOR Flash
Las memorias NOR Flash tienen transistores accesibles de manera independiente.
La función lógica que se forma en la Bit Line en función del estado de las Word
Lines es NOR, de ahí su nombre.
El acceso independiente al bit asociado a cada transistor hace que las

memorias NOR Flash se puedan tratar igual que las otras memorias PROM. Su
interfaz será, a nivel de lectura, el mismo de las memorias ROM, con bus de
direcciones, bus de datos y señales de control CS* y OE*.

NAND Flash
Las memorias NAND Flash emplean transistores que forman una cadena en serie
de 16 o 32 transistores.
La función lógica entre la Bit Line y las Word Lines es NAND, de ahí su nombre.
La estructura es más compacta que NOR, por tanto admite más bits en el mismo
espacio.
El acceso no es independiente para el bit asociado a cada transistor hace que

las memorias NAND Flash requieran un mecanismo especial de acceso.
Su interfaz es completamente distinto de las otras memorias PROM y se basa en
accesos a nivel de bloques, igual que los discos duros. Es, de hecho, el tipo de
memoria Flash empleada en pendrives y tarjetas de memoria.
4.2.3 Estructura de las memorias
Para hacer un chip de memoria hemos de juntar muchas celdas de un bit.

Normalmente ello se hace en una estructura matricial como la de la figura:

En el caso de la memoria de la figura, el bus de datos es de tamaño Wsize y el bus
de direcciones tiene n+m líneas.
4.3 Decodificación de Memoria

Como ya se mencionó, la conexión entre la CPU y la Memoria requiere de
un circuito que haga de interfaz entre las señales de ambas. La interfaz ha de
realizar dos funciones básicas:
Decodificación de direcciones
Adaptar las direcciones de la Memoria a las de la CPU. Ello es
especialmente importante cuando tenemos varias memorias y una única
CPU.
Adaptación de señales de control

Adaptar señales de control de la CPU a las que tiene la memoria ya que
éstas suelen ser distintas.
Trataremos ambas funciones por separado empezando con la decodificación de

direcciones.
4.3.1 Decodificación de direcciones
Supongamos que tenemos un sistema basado en microprocesador con una CPU y

varios elementos de memoria como el caso mostrado a continuación:
CPU MEM MEM MEM

1 2 3
32KB 16KB 64KB
La decodificación de direcciones hace que la CPU pueda ver cada elemento

de memoria sin solapamientos dentro de su espacio direccionable. Para entender lo
que entendemos como espacio direccionable hemos de introducir el concepto de
Mapa de memoria.
Denominamos Mapa de memoria de una CPU a un diagrama que muestra el

conjunto de Bytes que puede direccionar la CPU. Dentro de este diagrama se
puede mostrar el conjunto de Bytes asociado a cada elemento de memoria.
Supongamos que la CPU del ejemplo anterior tiene un bus de direcciones

que va de A0 a A19. Recordemos que el bus de direcciones de la CPU, siempre está
en Bytes, por tanto, la CPU puede acceder a 220 posiciones distintas, cada una de
un Byte. El espacio direccionable es, por tanto, de 1MByte.

Las tres memorias que tenemos son de 32KBytes, 16 KBytes y 64 KBytes,
por tanto, en total suman 112KB y deberían caber en el espacio direccionable de
1MByte que tiene la CPU.
La siguiente figura muestra esquemáticamente el mapa del espacio

direccionable por al CPU (a la derecha), desde la primera posición 0000h hasta la
última FFFFh para un total de 220 Bytes. También se muestra el espacio que
ocuparía cada elemento de memoria.
FFFFFh
MEM 1
64KB
MEM 2 16KB
MEM 3
32KB
00000h
La decodificación de direcciones permite situar cada elemento de memoria

en una posición concreta del mapa de memoria de la CPU. En teoría, yo podría
poner cada elemento de memoria donde desee dentro del mapa de la CPU siempre
y cuando no tenga solapes entre los bloques de memoria.
A modo de ejemplo:
La memoria 3, de 32 KBytes, la pongo al principio de la memoria. Empezará en la

posición 0000h y acabará en:
𝑀𝑀3 𝐹𝐹𝐹𝐹𝐹𝐹𝐹𝐹𝐹𝐹 = 32𝐾𝐾 − 1 = 215 − 1 = 7𝐹𝐹𝐹𝐹𝐹𝐹ℎ
La memoria 2, de 16 KB, puedo ponerla justo encima de la memoria M3.

Empezará, por tanto en la posición 8000h y acabará en:
𝑀𝑀2 𝐹𝐹𝐹𝐹𝐹𝐹𝐹𝐹𝐹𝐹 = 8000ℎ + 16𝐾𝐾 − 1 = 215 + 214 − 1 = 𝐵𝐵𝐵𝐵𝐵𝐵𝐵𝐵ℎ
La memoria 1, de 64 KBytes, puedo ponerla al final de la memoria, por tanto

acabará en la posición FFFFFh y empezará en:
𝑀𝑀2 𝐼𝐼𝐼𝐼𝐼𝐼𝐼𝐼𝐼𝐼𝐼𝐼 = 𝐹𝐹𝐹𝐹𝐹𝐹𝐹𝐹𝐹𝐹ℎ − 64𝐾𝐾 + 1 = 100000ℎ − 216 = 𝐹𝐹0000ℎ

La siguiente figura muestra el mapa de memoria resultante de esta decodificación:
FFFFFh
MEM 1
64KB
F0000h
0BFFFh
MEM 2 16KB
08000h
MEM 3
32KB
00000h
Con independencia del ancho del bus de datos de la CPU, 8 bits, 16 bits, 32
bits… el mapa de memoria lo escribiremos siempre en bytes ya que la CPU
siempre ha de ser capaz de direccionar bytes independientes.
Para explicar la decodificación de direcciones iremos explicando distintos

casos de más sencillos a más complejos. Las explicaciones no son exhaustivas y
las soluciones no son únicas.
Empezaremos, por simplicidad, con buses de datos de 8 bits y con la

decodificación que denominaremos sencilla.
4.3.2 Decodificación Sencilla
Por definición, denominaremos decodificación sencilla a aquella que cumple dos

restricciones:
Sólo permitimos memorias con número de direcciones que es potencia de

2. Esta restricción es fácil de cumplir ya que prácticamente todas las
memorias la cumplen.
Sólo permitimos poner una memoria en una posición inicial que sea
múltiplo de su tamaño. Esta restricción es más importante.

A modo de ejemplo, en el mapa de memoria asociado a una decodificación como
la siguiente:
FFFFFh
MEM 1
64KB Podemos ver que la memoria 2 no cumple con la primera
restricción al no ser 48KBytes una potencia de 2.
MEM 2
48KB Podemos ver también que la memoria 3 no cumple la
segunda restricción ya que no empieza en una posición
que sea múltiplo de su tamaño.
MEM 3 Empieza a 16 KBytes del inicio del mapa cuando su
32KB tamaño es de 32 KBytes.
MEM 4 16KB
00000h
Como vemos, la decodificación sencilla no permite algunas distribuciones de

memoria en el mapa de la CPU. Pero simplifica mucho la decodificación ya que
independiza entre sí las líneas de direcciones que van de la CPU a la memoria de
las que se emplean para seleccionar la memoria como veremos más adelante.
Decodificación sencilla con CPU y memoria de 8 bits
Para empezar a explicar la decodificación sencilla empezaremos tratando el

caso en que tenemos una memoria y una CPU con buses de datos iguales y de 8
bits.
El número de direcciones m de la CPU tendrá que ser mayor o igual que el número
de direcciones n de la memoria si deseamos que quepa en el mapa.
Asociamos cada dirección de la memoria con la que tiene el mismo nombre en la

CPU. Nos quedarán m-n direcciones de la CPU sin asociar.
Cada posible combinación binaria de Am-1...An de las direcciones de la CPU

no conectadas a la memoria corresponde a un posible marco donde puede estar la
memoria. Para elegir usar uno de los marcos posibles activaremos CS* de la
memoria sólo para esa combinación de valores de la parte alta Am-1...An.
Parte alta
m-n sin asociar
Define un Parte media
marco M n coincidentes
Am-1... An An-1 ..... A0 CPU
Mm-n-1..M0 An-1 ..... A0 MEM

La CPU puede direccionar 2m Bytes y la memoria es de 2n Bytes, por tanto,
la memoria cabe en el mapa de la memoria en 2m-n posiciones que empiezan en un
múltiplo de su tamaño. Cada una de estas posiciones tiene un número de marco
desde 0 hasta 2m-n-1.
Ejemplo
Decodifique las direcciones de manera que la memoria tenga su última posición en
la mitad del mapa de la CPU.
CPU M1
A0..A15 A0..A12
D0..D7 D0..D7
CS
Tanto la CPU como la memoria tienen bus de datos de 8 bits.
La CPU tiene bus de direcciones A0...A15 por lo que puede direccionar.
215+1 𝐵𝐵𝐵𝐵𝐵𝐵𝐵𝐵𝐵𝐵 = 216 𝐵𝐵𝐵𝐵𝐵𝐵𝐵𝐵𝐵𝐵 = 26 210 𝐵𝐵𝐵𝐵𝐵𝐵𝐵𝐵𝐵𝐵 = 64𝐾𝐾𝐾𝐾𝐾𝐾𝐾𝐾𝐾𝐾𝐾𝐾
En CPUs, dado que el bus de direcciones siempre trabaja en Bytes, la capacidad

siempre es 2n+1 donde n es el índice de la línea de dirección más alta.
La memoria tiene bus de datos direcciones A0...A12 por lo que su capacidad será:
213 𝑃𝑃𝑃𝑃𝑃𝑃𝑃𝑃𝑃𝑃𝑃𝑃𝑃𝑃𝑃𝑃𝑒𝑒𝑒𝑒 = 213 𝐵𝐵𝐵𝐵𝐵𝐵𝐵𝐵𝐵𝐵 = 23 210 𝐵𝐵𝐵𝐵𝐵𝐵𝐵𝐵𝐵𝐵 = 8𝐾𝐾𝐾𝐾𝐾𝐾𝐾𝐾𝐾𝐾𝐾𝐾
Si alineamos las direcciones de la CPU con las de la memoria tendremos:
A15 A14 A13 A12 A11 A10 A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 CPU

A12 A11 A10 A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 MEM
Por lo que quedarán libres las líneas de la CPU A15, A14 y A13.
Estas tres líneas definen un número de marco desde 000 a 111 (8 valores).
El número de posiciones en que cabe la memoria dentro del mapa de memoria

cumpliendo que empieza en un múltiplo de su tamaño es:
64𝐾𝐾𝐾𝐾𝐾𝐾𝐾𝐾𝐾𝐾𝐾𝐾
=8
8𝐾𝐾𝐾𝐾𝐾𝐾𝐾𝐾𝐾𝐾𝐾𝐾

Estos son los 8 marcos posibles. La siguiente figura muestra las posiciones de los
marcos, numerados desde 0 (000) a 7 (111) dentro del mapa de memoria de la
CPU:
FFFFh
7
6
5
4
3
2
1
0
0000h
El enunciado del problema pedía que la memoria tenga su última posición en la

mitad del mapa de la CPU. Ello significa que hemos de usar el marco 3 (011).
Con ello la tabla de decodificación que resulta es:

0 1 1 A12 A11 A10 A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 MEM
Como se puede observar, a las líneas A15, A14 y A13 se les ha asignado el marco
número 3 que corresponde a la combinación binaria 011.
Ello significa que la memoria se tendrá que activar para direcciones que se hallen
en el marco indicado, esto es, siempre que A15="0", A14="1" y A13="1". Como la
selección de la memoria se hace con la señal CS* que es activa baja, ello implica
que se ha de implementar la expresión:
�� = 𝐴𝐴15 + ��

𝐶𝐶𝐶𝐶 𝐴𝐴14 + ��
𝐴𝐴13
La memoria es de 8 KBytes = 213 Bytes. Dado que nuestro marco es el número 3,

podemos hallar las posiciones de inicio y final de la memoria:
𝐼𝐼𝐼𝐼𝐼𝐼𝐼𝐼𝐼𝐼𝐼𝐼 = 3 ∙ 213 = 6 ∙ 212 = 6 ∙ 23∙4 = 6000ℎ
𝐹𝐹𝐹𝐹𝐹𝐹𝐹𝐹𝐹𝐹 = (3 + 1) ∙ 213 − 1 = 8 ∙ 212 − 1 = 8 ∙ 23∙4 − 1 = 7𝐹𝐹𝐹𝐹𝐹𝐹ℎ

De todo lo anterior resulta el esquema de conexiones y el mapa de memoria que se
muestran a continuación.
FFFFh
M1 7
A0..A12 A0..A12 6
5
D0..D7 D0..D7 4
7FFFh
MEM
3
6000h
2
A13
1
A14 CS
0
A15 0000h
4.3.3 Decodificación incompleta
Usando decodificación sencilla ponemos situar la memoria en uno de los

2m-n posibles marcos.
Para ello hacemos que CS* se active sólo cuando estamos en el marco deseado.
En el ejemplo anterior, hemos activado la memoria en el marco 3, por tanto,

sólo es accesible entre las direcciones 6000h y 7FFFh que para las que CS* se
halla activo.
Si en lugar de generar CS* partir del marco deseado dejáramos esta señal
siempre activa, la memoria quedaría implementada en todos los marcos a la vez y
obtendríamos el mapa de memoria siguiente:
FFFFh
MEM
7
MEM
6
MEM
5
MEM
4
MEM
3
MEM
2
MEM
1
MEM
0
0000h
No significa ello que tengamos 8 veces la cantidad inicial de memoria sino

que cada byte de la memoria es accesible en 8 direcciones, una en cada marco.
A cada uno de los marcos en que es accesible la memoria se le denomina una
imagen.

El número de imágenes de una memoria es el número de marcos en que ésta
aparece. Ello coincide con el número de combinaciones de valores de la parte alta
del bus de direcciones que activan CS*. Por tanto coincide, a priori, con 2NI donde
NI es el número de indeterminaciones “X” que hay en la selección del marco.
La decodificación incompleta es especialmente útil cuando la memoria a

implementar en un sistema es mucho menor que lo que permite el mapa de
memoria de la CPU ya que permite simplificar mucho la circuitería lógica asociada
a la decodificación de direcciones.
En contraposición la decodificación no incompleta, sin imágenes, se denomina
completa.
Ejemplo
Obtenga la decodificación más sencilla posible que haga que la memoria M1 tenga
su primera posición al principio del mapa y la memoria M2 tenga su última
posición al final del mapa. Obtenga el mapa de memoria resultante.
Considere que el sistema no tiene ni requerirá más memoria adicional a la
indicada.
CPU M1 M2
A0..A19 32KB 64KB
D0..D7 D0..D7
D0..D7
CS CS
La memoria M1 es de 32KB, por tanto las direcciones que tendrá serán:
32𝐾𝐾𝐾𝐾 = 25 210 𝐵𝐵 = 215 𝐵𝐵 → 𝐴𝐴0 … . 𝐴𝐴14
Por su parte, la memoria M2 es de 64KB, por tanto:
64𝐾𝐾𝐾𝐾 = 26 210 𝐵𝐵 = 216 𝐵𝐵 → 𝐴𝐴0 … . 𝐴𝐴15
La memoria M1 tendrá conectadas sus líneas de direcciones A0..A14 a la CPU. De

la CPU quedarán libres las 5 línea A15...A19 las cuales definirán un número de
marco desde 0 (00000) hasta 31 (11111).
Dado que M1 debe tener su primer posición al principio del mapa, si hacemos
decodificación completa (un sólo marco) deberá ocupar el primer marco (00000).
Por su parte, la memoria M2 tendrá conectadas sus líneas de direcciones A0..A15 a

la CPU. De la CPU quedarán libres las 4 línea A16...A19 las cuales definirán un
número de marco desde 0 (0000) hasta 15 (1111).
Dado que M2 debe tener su última posición al final del mapa, si hacemos
decodificación completa (un sólo marco) deberá ocupar el último marco 15 (1111).

A continuación se muestra la tabla resultante de la decodificación completa:
A19 A18 A17 A16 A15 A14 A13 A12 A11 A10 A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 CPU
0 0 0 0 0 A14 A13 A12 A11 A10 A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 M1
1 1 1 1 A15 A14 A13 A12 A11 A10 A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 M2
Las señales CS* de las dos memorias que permiten elegir los marcos adecuados
para cada una serán:
�𝐶𝐶𝐶𝐶
��𝑀𝑀1 = 𝐴𝐴19 + 𝐴𝐴18 + 𝐴𝐴17 + 𝐴𝐴16 + 𝐴𝐴15
�𝐶𝐶𝐶𝐶
��𝑀𝑀2 = ��
𝐴𝐴19 + ��
𝐴𝐴18 + ��
𝐴𝐴17 + ��
𝐴𝐴16
A continuación se muestra el mapa de memoria que resultaría de la decodificación:
FFFFFh
M2 𝑀𝑀2 𝐼𝐼𝐼𝐼𝐼𝐼𝐼𝐼𝐼𝐼𝐼𝐼 = 15 ∙ 216 = 𝐹𝐹0000ℎ
F0000h
𝑀𝑀1 𝐹𝐹𝐹𝐹𝐹𝐹 = (15 + 1) ∙ 216 − 1 = 𝐹𝐹𝐹𝐹𝐹𝐹𝐹𝐹𝐹𝐹ℎ
𝑀𝑀1 𝐼𝐼𝐼𝐼𝐼𝐼𝐼𝐼𝐼𝐼𝐼𝐼 = 0 ∙ 215 = 00000ℎ
𝑀𝑀1 𝐹𝐹𝐹𝐹𝐹𝐹 = (0 + 1) ∙ 215 − 1 = 07𝐹𝐹𝐹𝐹𝐹𝐹ℎ

07FFFh M1
00000h
Ahora bien, la decodificación completa obliga a emplear 5 señales en la generación

de CS* para M1 y 4 señales en la generación de CS* para M2.
Usando decodificación incompleta podemos emplear una única señal en la

decodificación de ambos bloques. Podemos hacer que M1 ocupe los 16 marcos (de
un total de 32) correspondientes a la parte baja de la memoria y que M2 ocupa los
8 marcos (de un total de 16) correspondientes a la parte alta de la memoria.
La tabla resultante de la decodificación sería:
A19 A18 A17 A16 A15 A14 A13 A12 A11 A10 A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 CPU
0 X X X X A14 A13 A12 A11 A10 A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 M1
1 X X X A15 A14 A13 A12 A11 A10 A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 M2
Por tanto, A16, A17 y A18 no se usan en la decodificación y por tanto, la

generación de CS* se simplifica:
��𝑀𝑀1 = 𝐴𝐴19
𝐶𝐶𝐶𝐶
��𝑀𝑀2 = ��
𝐶𝐶𝐶𝐶 𝐴𝐴19

El mapa de memoria resultante en este caso sería:
FFFFFh
M2
F0000h Tenemos 8 imágenes de M2 en la parte alta de la
memoria entre 80000h y FFFFFh.
80000h M2
7FFFFh M1
Tenemos 16 imágenes de M1 en la parte baja de la
memoria entre 00000h y 7FFFFh
07FFFh
M1
00000h
El número de imágenes, evidentemente ha de cuadrar con el espacio ocupado por

la imágenes dividido entre el tamaño de cada una de éstas.
Así, la CPU puede direccionar 220 Bytes, por tanto, cada mitad ocupa 219 Bytes.
219 219
𝐼𝐼𝐼𝐼𝐼𝐼𝐼𝐼𝐼𝐼𝐼𝐼𝐼𝐼𝐼𝐼𝑀𝑀1 = 15 = 24 = 16 𝐼𝐼𝐼𝐼𝐼𝐼𝐼𝐼𝐼𝐼𝐼𝐼𝐼𝐼𝐼𝐼𝑀𝑀2 = 16 = 23 = 8
2 2
4.3.4 Decodificación de direcciones bajas
Usando la decodificación sencilla asignábamos A0 de CPU a A0 de memoria

y continuábamos asignando hasta que agotábamos las direcciones de la memoria
tal y como se muestra a continuación:
Am-1...... An An-1 ..... A0 CPU

Mm-n-1....M0 An-1 ..... A0 MEM
Parte alta Parte media

m-n sin asociar n líneas
Corresponden coincidentes
a un marco
concreto
Las direcciones restantes desde An a Am-1 definían un número de marco en el que

situamos la memoria.
Esta no es, sin embargo, la única manera posible de repartir las direcciones, ni
siquiera usando decodificación sencilla.

Supongamos, a modo de ejemplo, que asignamos A0 de la memoria a A1 de
la CPU, en lugar de A0 como antes, de manera que tengamos esta tabla de
decodificación:
Am-1...... An+1 An .....A1 A0 CPU

Mm-n-2.....M0 An-1 .... A0 B0 MEM
Parte alta Parte media Parte baja
m-n-1 n líneas 1 línea
Corresponden coincidentes Corresponde
a un marco a un módulo
concreto Concreto 0 o 1
La dirección A0 de la CPU que no ha sido asignada a la memoria la

consideraremos parte baja de la decodificación de direcciones y, del mismo modo
que la parte alta tenía asociada un marco, la parte baja tendrá asociada un módulo.
Como la parte baja sólo tiene un bit (A0), habrá dos módulos posibles 0 y 1.
Como puede observarse, al desplazar hacia la izquierda el uso de direcciones

de la CPU, el primer bit asignado al marco es ahora An+1 cuando antes era An. De
la misma manera antes teníamos m-n bits asociados al número de marco cuando
ahora tenemos m-n-1 bits asociados al marco. Tenemos, por tanto, la mitad de
marcos. Cada marco, sin embargo, tendrá el doble de tamaño. Dado que la
memoria total se divide entre todos los marcos disponibles.
Igual que antes, en decodificación completa, seleccionábamos CS* para uno

de los marcos (parte alta), ahora seleccionaremos CS* para uno de los marcos
(parte alta) y uno de los módulos (parte baja).
Si, en el ejemplo propuesto, elegimos el primer marco 0..0 y el primer módulo 0,

tendremos una tabla de decodificación:
Am-1...... An+1 An .....A1 A0 CPU

0.........0 An-1 .... A0 0 MEM
La generación de CS* será:
�𝐶𝐶𝐶𝐶
�� = 𝐴𝐴𝑚𝑚−1 + ⋯ . +𝐴𝐴𝑛𝑛+1 + 𝐴𝐴0
Por tanto, la memoria se seleccionará siempre que estemos en el primer marco

Am-1 .....An+1 = 0 y, además A0=0.
Eso significa que la memoria sólo se seleccionará para las direcciones pares del
primer marco ya que en las direcciones impares A0=1.

La siguiente figura muestra gráficamente el contenido del primer marco:
2n+1-1
Marco 0
Marco 0
0
La memoria, señalada con regiones azules, ocupa las posiciones pares del
primer marco. Las posiciones impares no están conectadas a ninguna memoria.
Es por ello que hemos llamado número de módulo al número definido por las
direcciones bajas. En este caso, con un bit de direcciones bajas, las direcciones
válidas para el módulo 0 son las que cumplen:
𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷ó𝑛𝑛 𝑚𝑚ó𝑑𝑑𝑑𝑑𝑑𝑑𝑑𝑑 2 = 0
Que corresponde a las direcciones pares, mientras que las direcciones válidas para
el módulo 1 son las que cumplen:
𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷ó𝑛𝑛 𝑚𝑚ó𝑑𝑑𝑑𝑑𝑑𝑑𝑑𝑑 2 = 1
Que corresponde a las direcciones impares.
El caso indicado en el ejemplo empleaba un bit para definir las direcciones

bajas, pero en un caso general las direcciones bajas pueden tener cualquier número
de bits. La única restricción es que las líneas sobrantes (número de líneas de más
que tiene la CPU respecto de la memoria) se han de repartir entre la parte alta y la
parte baja.
En definitiva, usando decodificación sencilla, dividimos, para cada memoria, las

direcciones de la CPU en tres partes:

Am-1........................A0 CPU
Mna-1 ..M0 An-1 .... A0 Bnb-1 ..B0 MEM
na líneas n líneas nb líneas
Que codifican coincidentes Que codifican
un número de con la memoria un número de
marco módulo
Si la CPU tiene m líneas y la memoria tiene n líneas, quedan m-n líneas a

repartir entre la parte alta (na líneas que definen el marco) y la parte baja (nb líneas
que definen el módulo). En todo caso se tendrá que cumplir:
𝑚𝑚 = 𝑛𝑛𝑛𝑛 + 𝑛𝑛 + 𝑛𝑛𝑛𝑛
Marco 2na-1
El número de marco nos dice en que marco se halla la
memoria dentro del mapa de la CPU.
Habrá un total de 2na marcos, desde 0 a 2na-1
El marco nmarco tendrá sus extremos:

Número
𝐼𝐼𝐼𝐼𝐼𝐼𝐼𝐼𝐼𝐼𝐼𝐼 = 𝑛𝑛𝑚𝑚𝑚𝑚𝑚𝑚𝑚𝑚𝑚𝑚 2𝑚𝑚−𝑛𝑛𝑛𝑛
de marco
𝐹𝐹𝐹𝐹𝐹𝐹 = (𝑛𝑛𝑚𝑚𝑚𝑚𝑚𝑚𝑚𝑚𝑚𝑚 + 1)2𝑚𝑚−𝑛𝑛𝑛𝑛 − 1
Marco 0
El número de módulo nos dice en que posiciones, dentro del marco, se halla la
memoria.

Habrá un total de 2nb módulos, desde 0 a 2nb-1
Si elegimos un módulo nmodulo, la memoria se hallará en las posiciones que

cumplan:
𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷 𝑚𝑚𝑚𝑚𝑚𝑚𝑚𝑚𝑚𝑚𝑚𝑚 2𝑛𝑛𝑛𝑛 = 𝑛𝑛𝑚𝑚𝑚𝑚𝑚𝑚𝑚𝑚𝑚𝑚𝑚𝑚
(mMarco +1) 2m-na - 1

En este ejemplo hemos
tomado 2 bits para la parte
baja, por tanto hay 22=4
Marco
módulos 0, 1, 2 y 3.
Si escogemos el módulo 1, la
memoria se hallará en las
posiciones del marco que
mMarco 2m-na cumplan:
𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷 𝑚𝑚𝑚𝑚𝑚𝑚𝑚𝑚𝑚𝑚𝑚𝑚 4 = 1
Para entender mejor el concepto de decodificación por direcciones altas y bajas

podemos ver un ejemplo.
Ejemplo
Explore las distintas opciones de decodificación de líneas bajas usando 4 chips de
memoria como el indicado. Obtenga los mapas de memoria resultantes en cada
caso.
CPU M
A0..A15 16KB
D0..D7
D0..D7 4 Chips
CS Iguales
La CPU tiene 16 líneas de direcciones, por tanto, puede direccionar 64 kBytes.

La memoria es de 16 KB, por tanto:
16𝐾𝐾𝐾𝐾 = 24 210 𝐵𝐵 = 214 𝐵𝐵 → 𝐴𝐴0 … . 𝐴𝐴13

Hemos de poner 4 memorias de 16 KB, el total de memoria a poner en el mapa de
la CPU es, por tanto:
𝑇𝑇𝑇𝑇𝑇𝑇𝑇𝑇𝑇𝑇 𝑚𝑚𝑚𝑚𝑚𝑚𝑚𝑚𝑚𝑚𝑚𝑚𝑚𝑚 = 4 ∙ 16𝐾𝐾𝐾𝐾 = 64𝐾𝐾𝐾𝐾
Por tanto, los 4 chips de memoria llenan el mapa de la CPU. No obstante, hay
múltiples maneras de llenar el mapa de la CPU con las 4 memorias dependiendo de
cómo repartamos las direcciones altas y bajas.
En efecto, tenemos 16 direcciones en la CPU y 14 direcciones en la memoria. Nos

sobran, por tanto, 2 líneas de dirección las cuales tenemos que repartir entre las
direcciones altas y bajas.
Opción A : 2 líneas altas
En esta opción no empleamos las líneas bajas para decodificar la memoria, por
tanto tenemos na=2 (4 marcos) y nb=0 (un módulo sin elección).
Tenemos 4 marcos y 4 memorias y, por tanto, habrá que poner una memoria en
cada marco. La siguiente tabla muestra como quedaría la decodificación:

0 0 A13 A12 A11 A10 A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 M1
Por tanto la generación de las señales CS* de las memorias y el mapa de memoria
sería:
FFFFh
Marco
M4 3
��𝑀𝑀1 = 𝐴𝐴15 + 𝐴𝐴14
𝐶𝐶𝐶𝐶
Marco
M3 2 �𝐶𝐶𝐶𝐶
��𝑀𝑀2 = 𝐴𝐴15 + ��
𝐴𝐴14
��𝑀𝑀3 = ��
�𝐶𝐶𝐶𝐶 𝐴𝐴15 + 𝐴𝐴14
Marco
M2 1
��𝑀𝑀4 = ��
�𝐶𝐶𝐶𝐶 𝐴𝐴15 + ��
𝐴𝐴14
M1 0
Marco
0000h

Opción B : 2 líneas bajas
Pero también podríamos no haber empleado las líneas altas y haber empleado sólo
las líneas bajas.
En ese caso tendríamos na=0 (1 marco sin elección) y nb=2 (4 módulos).
Tenemos 4 módulos y 4 memorias y, por tanto, habrá que poner una memoria en
cada módulo. La siguiente tabla muestra como quedaría la decodificación:

A13 A12 A11 A10 A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 0 0 M1
sería:
FFFFh
M4
M3
M2 �𝐶𝐶𝐶𝐶
��𝑀𝑀1 = 𝐴𝐴1 + 𝐴𝐴0
M1
�𝐶𝐶𝐶𝐶
��𝑀𝑀2 = 𝐴𝐴1 + ��
𝐴𝐴0
�𝐶𝐶𝐶𝐶
��𝑀𝑀3 = ��
𝐴𝐴1 + 𝐴𝐴0
��𝑀𝑀4 = ��
𝐴𝐴1 + ��
𝐴𝐴0
M3
M2
M1
0000h
Opción C : 1 línea baja y 1 línea alta
Pero estas no son las únicas opciones que tenemos. También podríamos haber
repartido por igual las líneas altas y bajas.
En ese caso tendríamos na=1 (2 marcos) y nb=1 (2 módulos).

Tenemos 2 marcos y 2 módulos y 4 memorias y, por tanto, habrá que poner cada
memoria en una combinación de marcos y módulos. La siguiente tabla muestra
como quedaría la decodificación:

0 A13 A12 A11 A10 A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 0 M1
sería:
FFFFh
�𝐶𝐶𝐶𝐶
��𝑀𝑀1 = 𝐴𝐴15 + 𝐴𝐴0
M4
M3
��𝑀𝑀2 = 𝐴𝐴15 + ��
𝐴𝐴0
M3
��𝑀𝑀3 = ��
M2 ��𝑀𝑀4 = ��
𝐶𝐶𝐶𝐶 ��
𝐴𝐴15 + 𝐴𝐴0
M1
M2
M1
0000h
Opción D : Reparto no simétrico
Podría parecer que ya hemos agotado todas las opciones. Nos sobraban 2 líneas y
hemos probado a repartir 2+0, 0+2 y 1+1. Sería cierto que hemos agotado las
opciones si hacemos el mismo reparto de líneas para todas las memorias. Pero no
es necesario que así sea.
En la opción D proponemos asignar la parte baja de la memoria (A15=0) a las

memorias M1 y M2 con reparto por direcciones bajas (dos marcos) y asignar la
parte alta de la memoria (A15=1) con reparto por direcciones altas (dos módulos).
La siguiente tabla muestra como quedaría la decodificación:

1 1 A13 A12 A11 A10 A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 4
La generación de las señales CS* de las memorias y el mapa de memoria sería:
FFFFh
M4
��𝑀𝑀1 = 𝐴𝐴15 + 𝐴𝐴0
𝐶𝐶𝐶𝐶
M3 ��𝑀𝑀2 = 𝐴𝐴15 + ��

��𝑀𝑀3 = ��
M2 ��𝑀𝑀4 = ��
𝐴𝐴14
M1
M2
M1
0000h
Lógicamente esta repartición tendría una simétrica:

0 1 A13 A12 A11 A10 A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 4
FFFFh
��𝑀𝑀1 = ��
M2
M1
M2 ��𝑀𝑀2 = ��
𝐴𝐴0
M1
�𝐶𝐶𝐶𝐶
��𝑀𝑀3 = 𝐴𝐴15 + 𝐴𝐴14
M4
�𝐶𝐶𝐶𝐶
��𝑀𝑀4 = 𝐴𝐴15 + ��
𝐴𝐴14
M3
0000h
4.3.5 Decodificación sencilla e incompleta
Todo lo que se ha explicado de la decodificación sencilla se puede ampliar usando

decodificación incompleta.
Am-1........................A0 CPU
Mna-1 ..M0 An-1 .... A0 Bnb-1 ..B0 MEM
Normalmente, sin embargo, no se ponen indeterminaciones en la

decodificación de la parte baja ya que rompe la linealidad de las posiciones de
memoria. Usar la misma memoria en varios módulos haría que se repitieran
direcciones de memoria próximas y eso no suele ser deseable.
Sí puede haber indeterminaciones en la parte alta. Estas darán directamente lugar a
la repetición en múltiples marcos replicando también el módulo asociado a la parte
baja.
En definitiva, la decodificación de direcciones bajas (módulos) permite

entrelazar memorias del mismo tamaño. Cuando las memorias no son del mismo
tamaño lo normal es que no podamos optar por decodificar con direcciones bajas.
Es importante recordar, como hemos visto en el ejemplo anterior, que a

decodificación de memoria se hace chip a chip. Cada chip puede tener distinta
partición de direcciones y distintos marcos y módulos.
4.3.6 Decodificación con memorias con bus de datos de menos de 8 bits
En el mercado podemos encontrar chips de memoria de menos de 8 bits de

ancho de bus de datos. Por ejemplo 4 bits o 1 bit.
Dado que el mínimo tamaño direccionable por las CPUs modernas es de un Byte
(8 bits). Estas memorias se tendrán que poner en paralelo para llenar un ancho de
un Byte.
A modo de ejemplo M1 y M2 tienen 216 posiciones de medio byte (un

nibble). Por tanto, cada una es de 215 Bytes = 32 KBytes.
Juntamos en paralelo los buses de datos para formar un bus de 8 bits. Unimos en el
resto de líneas que llevan el mismo nombre.
El conjunto se comporta ahora como una memoria de 216 posiciones de 1 Byte.
Su capacidad es, por tanto, de 64KBytes.

M1
A0..A15 A0..A15
D0..D7 D0..D3
CS CS
M2
A0..A15
D0..D3
CS
La conexión en paralelo de los dos chips se puede indicar explícitamente en

la tabla de decodificación simple.
Dado que A0 corresponde al nivel de byte, hemos de emplear índices menores para
el nivel por debajo del bit.
Am-1........................A0 A-1 CPU

Mna-1 ..M0 An-1 .... A0 Bnb-1 ..B0 0 M1
Mna-1 ..M0 An-1 .... A0 Bnb-1 ..B0 1 M2
Dado que ambas memorias se hallan en paralelo, ambas tendrán que tener
exactamente la misma decodificación alta (Marcos) y baja (módulos a partir de
A0).
4.3.7 Decodificación con buses de varias calles
La decodificación para CPUs con buses de datos de varias calles guarda

algunas similitudes con el caso anterior. No obstante, una diferencia importante es
que la CPU ha de poder acceder a cada calle por separado.
A modo de ejemplo, una CPU de 16 bits tendrá dos calles de 8 bits. Una calle
0 de D0 a D7 y una calle 1 de D8 a D15. Cada calle tendrá un strobe de calle
asociado que indicará cuando está en uso.

CPU
A1..Am-1
D0..D7
D0..D15
D8..D15
Str C0
Str C1
Recuérdese que la CPU, al ser de 16 bits y tener el bus de direcciones en

Bytes, no muestra el valor de A0 al ser éste siempre 0. Del mismo modo, una CPU
de 32 bits no mostraría el valor de A0 ni de A1.
La memoria ha de llenar siempre todo el bus de datos ya que, de otro modo,

no habría continuidad en la memoria, por tanto, si las memorias son de 8 bits y la
CPU es de 16 bits, necesitamos una memoria para llenar cada calle del bus.
Cada memoria sólo ha de activarse cuando lo diga su strobe de calle. Ello

implica asociar cada strobe de calle con la señal CS* de cada memoria tal y como
se muestra en la siguiente figura:
M1
A0..An-1 A0..An-1
CPU
D0..D7 D0..D7
A1..Am-1
D0..D15
Str C0 CS
Str C0
M2
A0..An-1
Str C1
D8..D15 D0..D7
Str C1 CS

Para sistematizarlo, hemos de incluir las CPUs de varias calles en nuestro
esquema de decodificación sencilla.
Las calles están asociadas a todas las posibles combinaciones de las líneas de
direcciones no mostradas por la CPU (A0 en 16 bits y A0, A1 en 32 bits).
CPU de 16 bits (Addr A1..An-1) CPU de 32 bits (Addr A2..An-1)

A0 Strobe A1 A0 Strobe
0 Str0 0 0 Str0
1 Str1 0 1 Str1
1 0 Str2
1 1 Str3
Para incluir sistemas con varias calles ampliaremos la tabla de decodificación

sencilla.
En el caso de CPUs de 16 bits con direcciones A1...Am-1
Am-1........................A1 A0 Strobe CPU

Mna-1 ..M0 An-1 .... A0 Bnb-1 ......B0 MEM
En el caso de CPUs de 32 bits con direcciones A2...Am-1
Am-1........................A1 A1 A0 Strobe CPU

Mna-1 ..M0 An-1 .... A0 Bnb-1 ......B1 B0 MEM
Como puede verse, seguimos teniendo direcciones alta, bajas y medias. Una
parte de las direcciones A0 en CPUs de 16 bits y A0, A1 en CPUs de 32 bits sólo
serán visibles fuera de la CPU a través de los strobes de calle.
Toda esta explicación es más fácil de ver con un ejemplo.

Ejemplo
Decodifique las direcciones del sistema para que la memoria sea visible de manera
continua desde 0000h y no ocupe ninguna posición de la mitad superior del mapa.
Dibuje el mapa de memoria resultante.
CPU
A1..A19 M1 64KB M2 64KB M3 64KB M4 64KB
A0..An-1 A0..An-1 A0..An-1 A0..An-1
D0..D15
D0..D7 D0..D7 D0..D7 D0..D7
UDS
LDS CS CS CS CS
Las memorias M1 a M4 son de 64KB, por tanto:
1𝑃𝑃𝑃𝑃𝑃𝑃𝑃𝑃𝑃𝑃𝑃𝑃𝑃𝑃𝑃𝑃
216 𝐵𝐵 = 216 𝐵𝐵𝐵𝐵𝐵𝐵𝐵𝐵𝐵𝐵 → 𝐴𝐴0 … . . 𝐴𝐴15
La CPU tiene dos calles y 2 strobes de calle. La señal de strobe LDS* se activa (a
"0") cuando se usa la calle 0 y la señal de strobe UDS* se activa (a "0") cuando se
usa la calle 1.
Hemos de llenar las dos calles de la CPU. Usaremos M1 y M3 en la calle 0 y M2 y

M4 en la calle 1. El resultado de la decodificación será:
A19 A18 A17 A16 .....A1 A0 Strobe CPU

0 x 0 A15 .... A0 0 LDS* M1
0 x 0 A15 .... A0 1 UDS* M2
0 x 1 A15 .... A0 0 LDS* M3
0 x 1 A15 .... A0 1 UDS* M4
Hemos hecho decodificación de direcciones bajas con los strobes de calle y

decodificación de direcciones altas con las líneas A17, A18 y A19.
Obsérvese que hemos empleado decodificación incompleta dejando indeterminada
la línea alta A18.

La generación de las señales CS* y el mapa de memoria serán, por tanto:
FFFFFh
�𝐶𝐶𝐶𝐶
��𝑀𝑀1 = ��
𝐿𝐿𝐿𝐿𝐿𝐿 + 𝐴𝐴17 + 𝐴𝐴19
�𝐶𝐶𝐶𝐶
��𝑀𝑀2 = ��
𝑈𝑈𝑈𝑈𝑈𝑈 + 𝐴𝐴17 + 𝐴𝐴19
�𝐶𝐶𝐶𝐶
��𝑀𝑀3 = ��
𝐿𝐿𝐿𝐿𝐿𝐿 + ��
𝐴𝐴17 + 𝐴𝐴19
�𝐶𝐶𝐶𝐶
��𝑀𝑀4 = ��
𝑈𝑈𝑈𝑈𝑈𝑈 + ��
𝐴𝐴17 + 𝐴𝐴19
M3/M4
M1/M2
M3/M4
M1/M2
00000h
En cada marco ocupado por M1 y M2, M1 ocupa las direcciones pares y M2 las
impares. Igualmente, en cada marco ocupado por M3 y M4, M3 ocupa las
direcciones pares y M4 las impares.
El hecho de que tenemos una indeterminación (A18) hace que tengamos dos
imágenes de cada memoria.
El espacio direccionable por la CPU es de 1MByte. Las memorias ocupan toda la

mitad baja de la memoria que corresponde a 512 KBytes.
Cada memoria es de 64 KBytes, por tanto, entre las 4 ocupan 256 KBytes. Como
hay dos imágenes de cada memoria completamos los 512 KBytes esperados.

4.3.8 Memorias con varias calles
Algunas memorias tienen ancho de bus de datos de más de 8 bits. En esos

casos tendrán entradas de strobe de calle.
Si CPU y memoria tienen el mismo ancho de bus, basta unir cada strobe de
calle de la CPU y la memoria entre si y unir ambos buses de datos. CS* se
generará por la decodificación del resto de direcciones no asociadas a los strobes.
CPU MEM
A1..Am-1
m-1 n A0..An-1
D0..D15 D0..D15
Str0 Str0
Str1 Str1
CS
m-n-1
En definitiva, la memoria tendrá un strobe para cada calle que deberá

activarse cuando esa calle haya de usarse. Si tenemos una CPU de 32 bits (con 4
strobes) y dos memorias de 16 bits (con dos strobes), deberemos asociar los 4
strobes de las memorias (2 de cada una) a los 4 strobes de la CPU. La conexión
entre las cuatro calles de la CPU y las dos de cada memoria deberá ser coherente
con el reparto que hayamos hecho de los strobes.
Usando decodificación sencilla con una memoriay una CPU de 16 bits, al

tener dos calles tanto la CPU como la memoria, A0 no participará en la
decodificación. Sin embargo, no ponemos "X" en A0 para no confundirnos con la
decodificación incompleta.
Am-1......An+1 An......A1 A0 Strobe CPU

Mm-n-2.....M0 An-1 .... A0 0/1
-- Str0/1 MEM
La tabla anterior presupone decodificación sólo de direcciones altas, que es

la única posible si sólo hay una memoria. Si hubieran varias memorias, igual que
en otros casos, se puede realizar decodificación de direcciones altas y bajas.

4.3.8 Memorias ROM
Las memorias ROM son especiales porque no pueden ser escritas.

Dado que los strobes de calle sólo son imprescindibles para escrituras. Las
memorias ROM, aunque sean de más de una calle, no suelen tener strobes de calle.
Su tabla de decodificación será similar al caso visto anteriormente.
CPU ROM
A1..Am-1 m-1 n A0..An-1
D0..D15 D0..D15
Str0 CS
Str1
m-n-1
Para recopilar todo lo visto anteriormente referente a la decodificación sencilla,

pondremos un ejemplo.
Ejemplo
Sitúe las memorias indicadas de manera que se cumplan las restricciones
indicadas.
Muestre el mapa de memoria resultante.
CPU
M1..M4 RAM de 64K Bytes con bus de 8 bits
A2..A23
M5..M8 RAM de 64K Bytes con bus de 16 bits
D0..D31 y strobes LBS*, UBS*
M9..M10 ROM de 256K Bytes con bus de 16 bits
BE0 RAM al principio del mapa / ROM al final
BE1
BE2
BE3

La CPU es de 32 bits y tiene, por tanto, 4 calles.
Las memorias M1 a M4 tendrán direcciones A0...A15 y bus de datos de 8 bits

Una posible tabla de decodificación será la siguiente:
A23 A22..A19 A18 A17 A16...A2 A1 A0 Strobe CPU

0 x...x 0 A15.......A0 0 0 BE0* M1
0 x...x 0 A15.......A0 0 1 BE1* M2
0 x...x 0 A15.......A0 1 0 BE2* M3
0 x...x 0 A15.......A0 1 1 BE3* M4
0 x...x 1 0 A14...A0 0 - BE0/1* M5
0 x...x 1 0 A14...A0 1 - BE2/3* M6
0 x...x 1 1 A14...A0 0 - BE0/1* M7
0 x...x 1 1 A14...A0 1 - BE2/3* M8
1 x...x A16...........A0 0 - BE0/1* M9
1 x...x A16...........A0 1 - BE2/3* M10
Las memorias RAM han de estar al principio del mapa:
Como las memorias M1 a M4 tienen bus de 8 bits, hemos de asignar una a cada
una de las 4 calles de la CPU. Con ello completamos los primeros 256KB de
memoria.
Como las memorias M5 a M8 tienen bus de 16 bits, hemos de asignar cada una dos
calles de la CPU. Asignaremos M5 y M7 a las calles 0 y 1 y las memorias M6 y
M8 a las calles 2 y 3.
Cada grupo de dos memorias llenará las 4 calles de la CPU. La distinción entre los
grupos M5-M6 y M7-M8 la haremos por decodificación de direcciones altas que es
la opción más sencilla. M5-M6 ocuparán un bloque de 128KB consecutivo al
bloque ocupado por M1-M4 y M7-M8 ocupará un bloque de 128KB consecutivo al
de M5-M6.
Con ello tendríamos decodificación completa, pero como nos basta con no
colisionar con la ROM, dejaremos indeterminadas las líneas A19 a A22.
En el caso de la memoria ROM, tenemos dos chips con dos calles para distribuirlos
entre las 4 calles de la CPU. Su estructura será similar a la de los pares M5-M6 o
M7-M8. En total, la ROM ocuparía los 512 KB finales del mapa, pero,
nuevamente, como nos basta con no colisionar con la RAM, indeterminaremos las
líneas A19 a A22.

La generación de las señales CS* será la que sigue:
�𝐶𝐶𝐶𝐶
��𝑀𝑀1 = ��
𝐵𝐵𝐵𝐵0 + 𝐴𝐴18 + 𝐴𝐴23
��𝑀𝑀2
𝐶𝐶𝐶𝐶 = ��
��𝑀𝑀3
𝐶𝐶𝐶𝐶 �� + 𝐴𝐴18 + 𝐴𝐴23
= 𝐵𝐵𝐵𝐵2
��𝑀𝑀4
𝐶𝐶𝐶𝐶 = ��
�𝐶𝐶𝐶𝐶
��𝑀𝑀5 = 𝐴𝐴17 + ��
𝐴𝐴18 + 𝐴𝐴23 �� = ��
𝐿𝐿𝐿𝐿𝐿𝐿 𝐵𝐵𝐵𝐵0 ��
𝑈𝑈𝑈𝑈𝑈𝑈 = ��
𝐵𝐵𝐵𝐵1
�𝐶𝐶𝐶𝐶
��𝑀𝑀6 = 𝐴𝐴17 + ��
𝐴𝐴18 + 𝐴𝐴23 𝐿𝐿𝐿𝐿𝐿𝐿 = 𝐵𝐵𝐵𝐵2 𝑈𝑈𝑈𝑈𝑈𝑈 = ��
�� 𝐵𝐵𝐵𝐵3
�𝐶𝐶𝐶𝐶
��𝑀𝑀7 = ��
𝐴𝐴17 + ��
𝐴𝐴18 + 𝐴𝐴23 �� = ��
𝐵𝐵𝐵𝐵1
��𝑀𝑀8 = ��
𝐶𝐶𝐶𝐶 𝐴𝐴17 + ��
𝐴𝐴18 + 𝐴𝐴23 �� = ��
𝐵𝐵𝐵𝐵3
��𝑀𝑀9 = ��
�𝐶𝐶𝐶𝐶
��𝑀𝑀10 = ��
𝐴𝐴23
Las conexiones de los buses de datos tendrán que ser coherentes con las
definiciones anteriores:
M1 : D0...D7 conectado a D0....D7 de CPU (Calle 0)

M5 : D0...D15 conectado a D0....D15 de CPU (Calles 0 y 1)




El mapa de memoria resultante será el que se muestra a continuación. Debido a su
tamaño lo hemos partido en dos trozos. La mitad inferior del mapa se halla a la
izquierda y la mitad superior a la derecha.
7FFFFFh FFFFFFh
24-1 = 15 M9-M10
Imágenes Entrelazadas
más
F80000h
07FFFFh M7-M8
Entrelazadas
060000h M5-M6 24-1 = 15
Entrelazadas Imágenes
040000h
más
M1-M4
Entrelazadas
000000h 800000h
Todas las memorias tienen indeterminadas 4 líneas (de A19 a A22). Por tanto
tendremos 16 imágenes de cada memoria.
El espacio direccionable por la CPU es de 16 MBytes. Tanto la memoria RAM
como la ROM totalizan 512 KBytes (8 chips de RAM de 64KB y dos chips de
ROM de 256 KB). Tanto la RAM como la ROM ocupan cada una la mitad del
mapa de memoria de 8 MBytes.
El número de imágenes coincide con 8MB/512KB = 16.

4.3.9 Más allá de la decodificación sencilla
Todo lo explicado en la decodificación de direcciones corresponde a la

decodificación sencilla. La decodificación sencilla se fundamenta en repartir las
direcciones de la CPU en dos grupos disjuntos:
• Parte media correspondiente a direcciones de la memoria

• Partes alta y baja para la generación de CS*
Am-1........................A0 CPU
Mna-1 ..M0 An-1 .... A0 Bnb-1 ..B0 MEM
En realidad estamos juntado dos informaciones distintas en la misma tabla.
Por un lado tenemos la asignación de direcciones:
Am-1........................A0 CPU
X....X An-1 .... A0 X.....X MEM ADDR
La asignación de direcciones relaciona en que posiciones del mapa de la

CPU puede ser vista, eventualmente, cada posición de la memoria.
Por otro lado tenemos la generación de CS*:
Am-1........................A0 CPU
Mna-1 ..M0 X.......X Bnb-1 ..B0 MEM CS*
La generación de CS* indica, de todas las opciones que permite la

asignación de direcciones, cuáles serán realmente usadas.
Al juntar las dos informaciones en la misma tabla estamos limitando las

posibilidades que tenemos a la hora de realizar la decodificación ya que una única
tabla no permite usar una dirección de la CPU a la vez en la asignación de
direcciones y en la generación de CS*.
Si separamos ambas tablas, se nos permitirán nuevas opciones de

decodificación. Para entender cómo esto nos ayuda, hemos de entender las
implicaciones del contenido de las dos tablas.

Por simplicidad, sólo se explicarán los casos en los que las memorias tengan
buses de datos de 8 bits. Intentar extender la explicación a memorias de 16 bits en
este momento complica las cosas y hace que la explicación que sigue sea menos
intuitiva.
Empezaremos pues, hablando de la asignación de direcciones:
La asignación de direcciones indica la relación que hay entre las direcciones de

CPU y la memoria si mantenemos siempre activado CS*.
Am-1......Ai+n-1.....Ai.......A0 CPU
X....X An-1 .... A0 X.....X MEM ADDR
Considerando sólo la asignación de direcciones de manera aislada, la memoria

siempre llenará todo el mapa de la CPU. Esta asignación depende sólo de dos
números:
i : Dirección de la CPU asignada a A0 de la memoria

n : Número de líneas de direcciones de la memoria
Supongamos, a modo de ejemplo el tener una CPU capaz de direccionar 64KB y

una memoria de 16KB con i=0 (A0 de memoria y CPU coincidentes).
A15 A14 A13 .......A0 CPU

X X A13....... A0 MEM ADDR
Como se observa, sobran 2 líneas altas (A14 y A15) por

Marco
MEM3 tanto la memoria tendrá 4 imágenes (22) que llenarán todo
el mapa de memoria.
Marco
MEM2 Recordemos que en este momento sólo estamos
estudiando la implicación que tiene la asignación de
Marco
MEM1 direcciones en saber en qué posiciones del mapa de la
CPU puede ser vista cada posición de la memoria.
Esto es, con la asignación de la tabla anterior, cada
MEM0
Marco posición de la memoria puede ser vista, como mucho, en
4 posiciones concretas del mapa de memoria de la CPU.

La asignación cambia para valores de i distintos de 0. Supongamos ahora el
caso de tener la misma CPU y memoria de 16KB pero ahora con i=1 (A0 de la
memoria asociada a A1 de la CPU).
A15 A14....... A1 A0 CPU

X A13 ....... A0 X MEM ADDR
Sobra una línea alta (A15) por tanto la memoria tendrá 2

........ imágenes (21) que llenarán todo el mapa de memoria.
Pos 1
MEM
Pos 1 Sobra también una línea baja (A0) por tanto la memoria
Pos 0
Pos 0
tendrá cada posición repetida 2 (21) veces de manera
consecutiva.
........
Pos 1
Igual que en el caso anterior, cada posición de la memoria
MEM puede ser vista en 4 posiciones distintas dentro del mapa
Pos 1
Pos 0 de la CPU. Lo que cambia en este caso respecto del
Pos 0 anterior es en qué posiciones puede verse.
Hagamos el reparto de direcciones que hagamos, mientras asociemos cada

línea de la memoria a una línea distinta de la CPU, siempre nos quedarán 2 líneas
libres. Lo cual corresponde a 2 indeterminaciones y, por tanto 22=4 posiciones
distintas en las que puede verse cada posición de la memoria. Obsérvese que este
número de posiciones es exactamente el cociente entre el espacio direccionable por
la CPU y el tamaño de la memoria.
PARA LOS MÁS CURIOSOS

(Gente normal abstenerse ya que tiene poco uso práctico)
Resulta interesante notar que no es necesario que las asignaciones sean

consecutivas. Por ejemplo podemos hacer esta asignación:
15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 CPU
13 12 11 10 9 X 8 7 6 5 4 3 2 1 X 0 MEM
Seguimos teniendo 2 indeterminaciones por lo que la cada posición de la memoria

se puede ver en 4 posiciones del mapa de la CPU.
Incluso podemos hacer una asignación como esta:
15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 CPU
3 10 1 X 7 2 8 4 0 11 X 12 5 13 6 9 MEM
Seguimos viendo cada posición de la memoria en 4 posiciones del mapa de la

CPU. Otra cosa es lo complicada que sea la distribución de los elementos de
memoria en el mapa de la CPU. Queda como ejercicio para el lector.

Generación de CS*
La asignación de direcciones asocia cada posición de la memoria a una o

varias posiciones dentro del mapa de la CPU. La generación de CS* indica, como
ya hemos comentado, de todas las posiciones que llenarían el mapa de la CPU a
partir de la asignación de direcciones, cuales permitimos que sean realmente
implementadas.
En decodificación sencilla habíamos usado para generar la señal CS* las líneas de
la CPU no empleadas en la asignación de direcciones:
Am-1........................A0 CPU
Mna-1 ..M0 X.......X Bnb-1 ..B0 MEM CS*
En decodificación sencilla únicamente permitimos elegir, para cada

memoria, un módulo (a partir de las direcciones bajas) y un conjunto de marcos
(que configuran las imágenes) a partir de las direcciones altas.
Los marcos, además, contenían siempre conjuntos completos de toda la memoria
por lo que siempre podíamos acceder a toda la memoria en un único marco.
Esta no es la única manera de proceder aunque, desde luego, es la más

sencilla. El problema es que la casuística asociada a la generación de CS* para
decodificaciones no sencillas es difícil de sistematizar. Por ello explicaremos la
potencia de emplear decodificación no sencilla con dos ejemplos.
Ejemplo
Sitúe la memoria indicada, con decodificación completa, a partir de la dirección
4000h.
CPU M1
A0..A15 32KB
D0..D7 D0..D7
CS

La CPU puede direcciones 216Bytes = 64KBytes
La memoria tiene 32KB con un bus de datos de 8 bits (1 Byte), por tanto contiene
32K=215 posiciones de un byte.
Obsérvese que se nos pide que situemos la memoria a partir de la posición 4000h.
4000ℎ = 4 ∙ 23∙4 = 214
Esta posición no es múltiplo del tamaño de la memoria (215) y, por tanto, no

podemos emplear decodificación sencilla.
Para realizar la asignación de direcciones asignaremos con i=0, esto es, A0 de la

CPU con A0 de la memoria:
A15 A14 .......A0 CPU

X A14....... A0 MEM ADDR
FFFFh
M1
El mapa resultante de la distribución tiene una
indeterminación en las direcciones altas, por tanto, hay
dos imágenes que ocupan, cada una, la mitad del mapa de
la CPU.
M1
Cada dirección de la memoria será accesible en dos
direcciones dentro del mapa de la CPU, una en cada
mitad.
0000h
Para la generación de CS*, elegimos marcos en función de la dirección de

inicio deseada. La idea es que la dirección de inicio quede al principio de un
marco. Para ello buscamos la última potencia de 2 que cumpla que la dirección de
inicio es múltiplo de ella. La dirección de inicio es 214, por tanto tomaremos
marcos de tamaño 214. Ello nos proporciona la siguiente asignación de marcos:
A15 A14 A13......A0 CPU

0 0 X...... X MARCO 0
0 1 X...... X MARCO 1
1 0 X...... X MARCO 2
1 1 X...... X MARCO 3

FFFFh
3
M1
En la figura podemos ver a asignación de marcos
C000h sobreimpresa sobre la distribución resultante de
la asignación de direcciones.
2
8000h
Como se puede ver, cada imagen de la memoria
ocupa 2 marcos al ser la memoria de 215 Bytes y
1
4000h
M1 cada marco de 214 Bytes.
0000h
0
Deseamos que la memoria empiece en la dirección 4000h, por tanto,

podemos emplear los marcos 1 y 2. Para ello realizaremos la siguiente asignación
para la señal CS*
�𝐶𝐶𝐶𝐶
�� = (𝐴𝐴15 + �� + 𝐴𝐴14�
𝐴𝐴14)�𝐴𝐴15
Obsérvese que empleamos una función AND de dos grupos OR. La función
AND no la habíamos usado nunca antes porque nunca habíamos hecho una
selección de dos marcos a la vez que no fuera debida a las indeterminaciones.
Recordad que estamos trabajando en lógica negada ya que CS* se activa por nivel
bajo. Por tanto, CS* ha de valer 0 en (y sólo en) los marcos 1 y 2.
FFFFh
La generación de CS* hace que sólo los marcos
3
M1
1 y 2 sean visibles. Ello se muestra en la figura
C000h de la izquierda.
2 Tendremos, por tanto, la memoria M1 visible
8000h
entre las posiciones 4000h y BFFFh.
1
4000h
M1
0000h
0
Es importante notar que el rango de la CPU 4000h-7FFFh mapea la mitad

superior de la memoria y que el rango 8000h-BFFFh mapea la mitad inferior de la
memoria.
La memoria, por tanto, siguiendo direcciones crecientes de la CPU, empieza en la
mitad, llega al final, salta al principio y acaba en la mitad.

Ejemplo
Divida la memoria indicada en 2 partes, 1/4 al principio del mapa y 3/4 al final.
CPU M1
A0..A15 32KB
D0..D7 D0..D7
CS
La CPU y la memoria son las mismas del ejemplo anterior.
La CPU puede direcciones 216Bytes = 64KBytes

La memoria tiene 32KB con un bus de datos de 8 bits (1 Byte), por tanto contiene
32K=215 posiciones de un byte.
Si deseamos que las posiciones de la memoria sean contiguas sin repeticiones ni

huecos, hemos de hacer la misma asignación de direcciones del ejemplo anterior.
FFFFh
A15 A14 .......A0 CPU
M1 X A14....... A0 MEM ADDR
Igual que en el caso anterior tenemos dos imágenes de
M1
la memoria que ocupan las dos mitades del mapa de la
CPU.
0000h
Como nos piden dividir la memoria en 4 partes y separarlas en bloques de 1/4 y

3/4, necesitamos marcos que sean de 1/4 del tamaño de la memoria. La memoria es
de 215 posiciones, por tanto, el marco habrá de ser de de 213 posiciones. Dado que
el espacio direccionable por la CPU es de 216 bytes, tendremos un número de
marco de 3 bits, esto es, 8 marcos en total desde el número 0 al número 7.

FFFFh
7
6
M1
La figura de la izquierda muestra los 8 marcos sobre las
5 imágenes de la memoria resultantes de la asignación de
direcciones.
4
3 Deseamos que la memoria sea visible en los marcos 0, 5,
2
M1
6 y 7. Esto es, primer 1/4 de memoria al principio del
mapa y 3/4 al final.
1
0
0000h
Los marcos 0, 5, 6 y 7 corresponden a los número binarios 000, 101, 110 y 111,
por tanto, la generación de CS* será:
�� + 𝐴𝐴14 + ��

�� = (𝐴𝐴15 + 𝐴𝐴14 + 𝐴𝐴13)�𝐴𝐴15
𝐶𝐶𝐶𝐶 𝐴𝐴13�
��
�𝐴𝐴15 + 𝐴𝐴14 + 𝐴𝐴13��𝐴𝐴15 + 𝐴𝐴14 + ��
�� 𝐴𝐴13�
La expresión anterior se puede simplificar, pero no se ha hecho para simplificar la

relación que tiene con la asignación de marcos.
FFFFh
7 La memoria ahora se ve ahora en el marco 0 (1/4 inferior
6
M1
de la memoria) y en los marcos 5, 6 y 7 (3/4 superiores
5 de la memoria).
4 Obsérvese que ninguna parte de la memoria se accede en
3 dos lugares distintos del mapa de memoria. La
2
M1
decodificación es, por tanto, completa.
1
0
0000h
Los dos ejemplos anteriores ilustran la utilidad que puede tener emplear
decodificación no sencilla para algunos casos especiales.
En la mayor parte de los casos, sin embargo, la decodificación sencilla suele ser
suficiente.

4.3.10 Señales de control
Hasta ahora hemos visto la manera de realizar la decodificación sencilla de

direcciones. Como recordaremos del principio del apartado no queda por ver como
se compatibilizan las señales de control de la CPU y las memorias.
Afortunadamente, aunque hay mucha variedad en las señales de control de

las CPUs, las memorias suelen ser muy similares.
En la decodificación de direcciones hemos visto como conectar el bus de
direcciones, el bus de datos y los strobes de calle. También hemos visto la
generación de CS*.
A continuación veremos cómo tratar otras de las señales de control.
Señales de control OE* y WE*.
La manera más sencilla de usar OE* y WE* es hacer que se activen siempre
que la CPU indique lectura o escritura respectivamente.
La siguiente figura muestra los circuitos de generación de estas señales para 4 tipos
de CPU que representan la mayor parte de las opciones que podemos encontrar.
CPU WE CPU
R/W W WE
OE R OE
CPU CPU
OE
R/W W WE
WE R OE
En todo caso, lo importante es que WE* se ha de generar en los ciclos de

escritura y OE* se ha de generar en los ciclos de lectura.
En general, aunque algunas memorias lo admiten, se ha de evitar que WE* y OE*
estén activas al mismo tiempo.

Señales de control de validación (Strobes)
Las señales strobe de validación tiene siempre dos estados: activo o inactivo.
Se trata de señales de validación. Eso las diferencia de cualquier otra señal de los
buses.
Existen, básicamente, cuatro tipos de strobe:
• Strobes de calle
Indican el uso de un byte del bus de datos
• Strobes de lectura y escritura

Indican, con dos líneas, si se hace lectura o escritura
R/W* no es strobe, R y W sí lo son.
• Strobes de identificación de destinatario

Se activan para indicar quién ha de acceder al bus.
Ejemplo: MREQ*, MSTB*, IOREQ*
• Strobes globales y/o de identificación de destinatario

Se activan siempre en el acceso al bus.
Ejemplo: ADS*
Es importante que todo chip de memoria tenga, en la medida de lo posible, al

menos un strobe dentro de su decodificación ya que ello garantiza que la memoria
no quede activada cuando no se usen los buses.
A veces sale su uso directamente de la decodificación:
• Porque tenemos un bus de varias calles

• Porque la CPU tiene señales R y W separadas
• Porque necesitamos distinguir entre Memoria y Entrada/Salida
En esos casos no hace falta añadir más strobes que los ya requeridos.
A veces no sale su uso directamente de la decodificación:
• Porque es ROM y no considera las calles

• Porque la CPU es de 8 bits y sólo tiene una calle
• Porque la CPU usa señal R/W* o W/R*
En esos casos conviene añadir un strobe a la generación de CS*

Lo mejor en tal caso es emplear un strobe genérico que se active en todos los
ciclos de bus.

4.3.11 Buses multiplexados
Algunas CPUs, para ahorrar en número de pines y líneas dedicados al bus,

emplean buses multiplexados de direcciones y datos.
En el siguiente ejemplo, la CPU tiene dos conjuntos de líneas de 8 bits. En la

primera parte del ciclo de bus, ambos conjuntos muestran las direcciones con la
parte alta en el primer conjunto y la parte baja en el segundo.
En la segunda mitad del ciclo, la CPU retira las direcciones bajas del segundo
conjunto y emplea éste como bus de datos.
CPU A8…A15 A8…A15
A0..A7
D0..D7 A0…A7 D0…D7
R/W
ALE
Ejemplo de bus multiplexado t
Este tipo de buses suele llevar asociada alguna señal de control, como ALE
en el ejemplo, que simplifica la captura de los datos de direcciones del bus antes de
que se retiren.

4.4 Decodificación en MCUs
Hasta ahora hemos visto la decodificación en microprocesadores.
Los microcontroladores (MCU) se distinguen de los microprocesadores en que ya
incorporan memoria interna.
No todos los MCU admiten memoria externa, pero, cuando lo hacen, se ha de tener
en cuenta la relación que pueda haber entre el uso de memoria externa y memoria
interna.
En general hay dos posibilidades tener en cuenta:
• Memoria interna prioritaria

• Generación interna de CS*
Esta clasificación no es exhaustiva. Se ha de leer siempre el datasheet para ver la

gestión que hace el MCU de la memoria externa.
4.4.1 Memoria interna prioritaria
Cuando un MCU admite memoria externa y tiene memoria interna

prioritaria, la memoria externa sólo se puede ver en los huecos no asignados del
mapa de memoria.
El siguiente ejemplo muestra un microcontrolador con su memoria interna

prioriotaria. Si le añadimos memoria externa que se solape con la interna, la
memoria interna tiene prioridad por lo que la memoria externa que se solapa con la
interna resulta inaccesible desde la CPU.
RAM RAM
RAM Zona RAM
Inaccesible RAM
PROM PROM
Memoria Memoria Mapa
Interna externa Resultante

4.4.2 Generación interna de CS*
Algunos MCU no admiten incluir memoria externa en cualquier lugar del

mapa que ve la CPU. En esos casos lo normal es que haya unos espacios en el
mapa reservados para la memoria externa.
En este ejemplo tenemos dos espacios EXT1 y EXT2 del

RAM mismo tamaño que pueden ser ocupados por memoria
externa.
EXT1 Si no añadimos memoria externa, estos espacios estarán

vacíos.
EXT2
Estos espacios corresponden a dos marcos obtenidos por
decodificación de direcciones altas.
PROM
Para verlo más fácilmente vamos a aplicar datos concretos al ejemplo anterior.
FFFFFh
PROM
128KB A la izquierda se muestra un mapa de memoria de
E0000h un microcontrolador hipotético que tiene 2 áreas
de memoria externa de 128 KB cada una.
La CPU puede direccionar 1MByte (desde

00000h hasta FFFFFh) pero dado que cada área
de memoria externa es de sólo 128 KB (217 Bytes)
7FFFFh EXT2 no hace falta que del microcontrolador salgan más
60000h 128KB de 17 líneas (A0...A16).
5FFFFh EXT1
128KB Para que el circuito externo pueda situar la
40000h memoria en ambos marcos EXT1 y EXT2, el
microcontrolador ya incluye la circuitería
necesaria para generar las señal CS* de ambos
07FFFh marcos que se activan (a "0") cuando la CPU
RAM 32KB intenta acceder a direcciones de éstos.
00000h

La siguiente figura muestra una posible implementación del interior del
microcontrolador donde se indica la manera en que éste genera las señales de CS*.
Como puede observarse, se trata de la decodificación simple por direcciones altas
que ya hemos visto.
MCU
PROM
CPU A0..A16 A0..A16
A0..A19 A18
D0..D7 D0..D7
CS1
D0..D7 R OE A17,A19
R A17..A19
CS
A17,A18
W CS2
RAM A19
A0..A16 A0..A14
D0..D7 D0..D7 A0..A16
R OE R
W WE W
A15..A19 CS
En definitiva, a la salida del MCU veremos:
MCU
Una señal CS* para cada región de memoria externa
A0..A16 disponible.
D0..D7 Suficientes líneas del bus de direcciones para llenar el área
externa más grande.
R
W El bus de datos.
CS1 Señales de lectura/escritura.

No necesariamente separadas, puede ser también R/W* o
CS1 W/R*.
No hará falta añadir strobes en el circuito externo dado que CS1*, CS2* ya los
incorporan.
El hecho de tener una señal CS* pregenerada no significa que sólo se pueda
poner un chip de memoria, se puede añadir otro nivel de decodificación para
decodificar varios chips de memoria empleando como punto de partida la señal
CS* que genera el MCU.

Ejemplo
Sea el MCU con el mapa de la figura.
Añada la memoria indicada y obtenga el mapa resultante.
FFFFFh
PROM
128KB
E0000h
MCU 2 Chip de 64 KB RAM en EXT1

A0..A16 1 Chip de 32 KB RAM en EXT2
7FFFFh EXT2
D0..D7
60000h 128KB
R 5FFFFh EXT1
W 128KB
40000h
CS1
07FFFh
CS2 RAM 32KB
00000h
Tenemos dos chips de RAM que llamaremos M1 y M2 de 64KB que deberán

ponerse en la zona EXT1 asociada a CS1*. Estas memorias tendrán líneas de
direcciones A0…A15.
Como el espacio disponible en EXT1 es 128 KB y tenemos un total de 128 KB de
memoria a poner (2 x 64 KB), llenaremos toda el área externa y no habrá espacio
para poner imágenes.
Tenemos un chip de RAM que llamaremos M3 de 32 KB que deberá ponerse en la

zona EXT2 asociada a CS2*. Esta memoria tendrá líneas de direcciones A0..A14.
Como el espacio disponible en EXT2 es 128 KB y tenemos que poner sólo 32 KB,
ocuparemos 1/4 del área disponible, por tanto, podemos indeterminar dos
direcciones y tener 4 imágenes.
A continuación se muestra la tabla de decodificación.
CS A16 A15 A14....... A0 CPU

CS1* 0 A15............A0 M1
CS1* 1 A15............A0 M2
CS2* X X A14.......A0 M3
Hemos puesto una nueva columna con los CS* que genera el MCU. El MCU
nunca activará a la vez dos señales CS*, por tanto, basta introducir en la
decodificación de cada memoria el CS* del área en que se desee incluir.

El mapa de memoria resultante y la generación de las señales CS* de las memorias
será:
7FFFFh
M3 32KB
M3 32KB ��𝑀𝑀1 = 𝐶𝐶𝐶𝐶1
𝐶𝐶𝐶𝐶 �� + 𝐴𝐴16
EXT2
M3 32KB 128KB
��𝑀𝑀2 = 𝐶𝐶𝐶𝐶1
𝐶𝐶𝐶𝐶 �� + ��
𝐴𝐴16
60000h M3 32KB
�𝐶𝐶𝐶𝐶
��𝑀𝑀3 = ��
𝐶𝐶𝐶𝐶2
5FFFFh M2
64 KB EXT1
128KB
M1
64 KB
40000h
Para completar la solución del problema hemos de poner todas las conexiones de
los tres chips de memoria RAM.
M1 M2 M3
A0..A15 A0..A15 A0..A15 A0..A15 A0..A14 A0..A14
D0..D7 D0..D7 D0..D7 D0..D7 D0..D7 D0..D7
R OE R OE R OE
W WE W WE W WE
A16 A16
CS CS CS
CS2
CS1 CS1

4.5 Acceso a DRAM y otras memorias
4.5.1 Acceso a memorias DRAM
Las memorias DRAM configuran como ya vimos, debido a su alta densidad, la

memoria global de sistemas con altos requisitos de memoria.
La base de la memoria es una celda de un bit

basada en un condensador CS.
La lectura/escritura se hace seleccionando CS con la

Word Line (WL) y leyéndolo/escribiéndolo a través
de la Bit Line (BL).
La lectura es destructiva. Por tanto, a toda lectura le

sigue una escritura.
Juntando muchas celdas en una estructura matricial de 2n filas y 2m columnas

tenemos el núcleo de una memoria DRAM.
2n Word Lines
n 2n2m=2n+m
Fila
Celdas
2m Bit Lines
2m Sense
m
Columna
D0
Un decodificador de filas permite elegir una de las 2n filas (o páginas). Para

leer las celdas, a cada una de las 2m columnas (Bit Lines) añadimos un
amplificador de sensado. Finalmente añadimos un multiplexor que permite obtener
el resultado de uno de los 2m amplificadores.
Con todo ello obtenemos una memoria de 2n+m bits. El bus de direcciones, por
tanto, estará formado por filas y columnas: A0…Am+n-1
El procedimiento de lectura comienza precargando a Vdd/2 todas las Bit

Lines que configuran las 2m columnas. A continuación se selecciona una de las 2n
Word Lines que configuran las filas conectando todos sus transistores a las Bit
Lines previamente precargadas. Las Bit Lines que después de la conexión queden
por debajo de Vdd/2 serán ceros y las que queden por encima de Vdd/2 serán unos.

El valor leído “0” o “1” se vuelve a escribir en todas las celdas de la fila para
recuperar los valores correctos ya que la lectura es destructiva. Finalmente se
selecciona la columna indicada dentro del conjunto de 2m columnas dando como
resultado el bit de salida.
Un aspecto muy importante a notar es que para todo el proceso de lectura, la
información de la fila a referenciar es necesaria al principio del ciclo de lectura y la
información de la columna no es necesaria hasta el final.
Este hecho se aprovecha en las memorias DRAM multiplexando la información de
filas y columnas. Tal y como se muestra en la siguiente figura.
max (m,n)
n
ADDR
RAS
m
CAS D0
En lugar de usar un bus de direcciones de ancho total n+m, se usa un bus que
tiene como anchura el máximo de estos dos números.
Como al principio del ciclo únicamente es necesaria la información de que fila
hemos de usar, esta se proporciona al principio del bus señalizándolo con una
bajada de la señal RAS* (Row Address Strobe). Un tiempo más tarde, se usan las
mismas líneas para proporcionar la información de la columnas señalizándolo con
la bajada de la señal CAS* (Column Address Strobe).
Si la memoria tuviera un bus de datos de más de un bit, todo el

procedimiento anterior se realizaría para tantas matrices en paralelo como bits
tenga el bus de datos.
D0…D3

El siguiente cronograma muestra el cronograma del proceso de multiplexado de
filas y columnas:
Con el tiempo, las memorias DRAM se han ido mejorando para permitir
lecturas más rápidas. La primera mejora fue las DRAM Fast Page Mode (FPM). La
idea que hay detrás de estas memorias es que si se ha de acceder a varias
posiciones dentro de la misma fila, no debería ser necesario volver a indicar ésta.
El las memorias FPM, por tanto, es posible dar varias transiciones a la señal CAS*
dentro de un único valor de fila señalizado con RAS*. La siguiente figura muestra
un cronograma para este tipo de memoria.

La siguiente mejora a FPM fueron las memorias Extended Data Out (EDO)
que añaden latches a la salida que permite lecturas más rápidas y precargas durante
la lectura. A nivel viene a consistir en un pipeline de dos etapas aplicado a la
lectura de la memoria. La siguiente figura muestra este tipo de memoria donde se
ve que es posible, gracias al latch de salida, que se puede proporcionar una nueva
columna mientras aún se está leyendo el dato anterior.
Suele pasar que en las lecturas a memoria, especialmente cuando el sistema

emplea memorias Cache, se realicen muchas lecturas a posiciones consecutivas. Es
por ello que la siguiente mejora Burst-Mode EDO (BEDO) consiste en permitir
pulsar la señal CAS* sin necesidad de dar las nuevas columnas ya que se emplea
un contador interno para ir dando el valor de columnas consecutivas. La siguiente
figura muestra cómo se pueden obtener datos consecutivos sin necesidad de
proporcionar cada vez el número de columna asociado.

Las memorias hasta la memoria BEDO son asíncronas. Esto es, las distintas
señales de control pueden tener diferentes relaciones entre sus flancos pero no se
emplea ningún reloj común para pautar las distintas operaciones.
Las memorias Syncronous DRAM (SDRAM) emplean un reloj para controlar
todas las señales de manera que los retardos son más predecibles y, por tanto, se
puede apurar al máximo la velocidad de las memorias. La siguiente figura muestra
como todas las señales se sincronizan con los flancos de subida de un reloj común
en las memorias SDRAM.
Las memorias DRAM han seguido evolucionando después de las memorias

SDRAN, bien sea para mejorar la velocidad (en bits/s) o para mejorar la lantencia
(tiempo desde que se pide un dato hasta que se recibe). La descripción de estas
nuevas tecnologías de memoria DRAM, sin embargo, quedan fuera del temario de
esta asignatura..

4.5.2 Acceso a memorias Flash
Las memorias Flash tienen actualmente una importancia tan grande que no
tendría sentido no hacer ningún comentario sobre el procedimiento de acceso a
éstas. Como se comentó anteriormente corresponden a una evolución de la
memoria EEPROM y se pueden dar en dos tipos: NOR y NAND.
Las memorias NOR Flash se diseñan substituir las memorias ROM, EPROM
y EEPROM. Su temporización en lectura es similar a las otras PROM, por lo que
no hace falta dar una explicación específica sobre ellas.
Las memorias NAND Flash pretenden substituir los discos duros y diskettes.
El acceso no se hace a bytes específicos sino a bloques de memoria. Su estructura
interna, por tanto, está optimizada para acceder en lectura y programación a
muchos datos en un tiempo muy corto.
Su interfaz es especial y basada en comandos a diferencia del interfaz clásico
basado en buses de datos y direcciones de las memorias NOR Flash.
Toda la información entra y sale de una memoria NAND Flash a través de un

bus de entrada/salida I/O de 8 o 16 bits de anchura. Eso hace que el número de
pines de una memoria flash no guarde relación con su tamaño sino con el ancho del
bus de acceso.
Las líneas típicas de una memoria flash con bus de 8 bits son:
I/O0 a I/O7 : Bus de entrada/salida

CE# : Entrada : Chip enable (activo bajo)
WE# : Entrada :Write Enable (Activo bajo)
RE# : Entrada : Read Enable (Activo bajo)
CLE : Entrada :Command Latch Enable
ALE : Entrada : Address Latch Enable
R/B# : Salida :Ready / Busy (Activo bajo)
Como se ha indicado, I/O0 a I/O7 son el bus de entrada/salida. El resto son señales
de control.
La señal CE# tiene el comportamiento de un Chip Enable habitual. La memoria no
responderá a ninguna otra señal si esta señal no está activada.
Las señales WE# y RE# indican si el bus I/O se emplea para entrada o salida. Y se
usan para validar cada dato que se mueve por el bus.
Las señales CLE y ALE determinan el tipo de dato que se mueve por el bus:
CLE ALE Contenido del bus I/O0 a I/O7

1 0 Comandos de control
0 1 Direcciones
0 0 Datos desde o hacia la memoria

La siguiente memoria muestra un cronograma de la programación de una memoria
NAND Flash.
El ciclo comienza con CLE alto y ALE bajo, indicando que se va a enviar
una orden de control. En el flanco de subida de WE# se valida el dato 80h que
indica que se va a introducir información.
A ello le sigue una combinación con CLE bajo y ALE alto, lo cual indica que se
envían direcciones. Los 5 bytes correspondientes a la posición a escribir (2 de
columnas y 3 de filas) se señalizan con sendos flancos de subida de WE#.
A continuación le sigue una serie de ciclos de la señal WE# con CLE y ALE bajos
que indican que lo que sigue son datos que serán los que se escribirán a partir de la
posición indicada.
Después de los datos se envía otro comando, señalizado con CLE alto y ALE bajo,
con valor 10h, que da inicio a la programación de los datos enviados.
La memoria señaliza con la bajada de la señal R/B# que la escritura está en
proceso. Cuando esta acaba lo señaliza con el alzado de R/B# con lo que la
memoria puede recibir más órdenes.
El último comando enviado en el ciclo se el comando 70h que pregunta si la
escritura fue correcta. La respuesta se recibe en el flanco de subida de la señal de
lectura RE#.
La verificación, mediante la señal de status, de una escritura correcta es muy

importante en las memorias NAND Flash, ya que las memorias Flash tienen una
vida limitada y, las memorias NAND, en concreto, se emplean en aplicaciones con
muchas lecturas y escrituras. Cuando se detecta que un bloque no se puede
programar fiablemente, este bloque se elimina, substituyéndose por un bloque de
reserva, y no se vuelve a usar nunca más.

4.6 Organización de la memoria
Como ya vimos en el tema anterior, para aprovechar al máximo la velocidad
de la CPU, se establece una jerarquía de memorias que comienza en la memoria
Cache de primer nivel, próxima a la CPU, pasa por todos los niveles de Cache
hasta llegar a la memoria DRAM, sigue con el disco duro y acaba, eventualmente,
en el almacenamiento en red.
La jerarquía de memoria pretende obtener, al mismo tiempo, la velocidad asociada

a las memorias cache y el bajo coste por bit de las memorias masivas.
La jerarquía de memoria sin embargo se aprovecha para algo más que eso. Se
emplea también para:
• Seguridad
• Virtualización de direcciones
• Segmentación de direcciones
Para realizar estas funciones se puede emplear un gestor de memoria o MMU

( Memory Management Unit ). La MMU es un bloque que se inserta entre la CPU
y la memoria y que permite alguna de las funcionalidades mencionadas
anteriormente.
CPU Direcciones MMU Direcciones MEM
Datos Datos
Control Control
En rigor, la MMU puede tanto insertarse después de la CPU como ser una
parte de la misma CPU. Es más fácil entenderla, sin embargo, como un añadido
que es transparente desde el punto de vista de la CPU.
La mayor parte de CPUs en sistemas complejos operan en funcionamiento

multitarea y/o multiusuario. A efectos prácticos podemos entender casi todos los
sistemas modernos con un mínimo de complejidad como multiproceso. Esto es,
compuestos por varios programas que coexisten y funcionan de manera paralela.
El sistema operativo (S.O.) se encarga de asignar tiempo de CPU a cada proceso
dependiendo de su urgencia.
Es dentro de este contexto donde la MMU tiene especial sentido ya que,
normalmente, el comportamiento de la MMU viene controlado por el Sistema
Operativo.

Seguridad mediante la MMU
Veremos ahora, algunas funcionalidades que puede ofrecer una MMU.

Empezaremos por la seguridad.
En un sistema multiproceso no basta con que cada proceso tenga una fracción justa
del tiempo de CPU. También ha de garantizar una cierta seguridad. A nivel
práctico interesa que un proceso no pueda modificar el área de memoria asignada
otros procesos o el propio sistema operativo. Adicionalmente también interesa que
un proceso, en caso de fallo, no se lleve por delante todo el resto del sistema.
Cada vez que la CPU cambia de proceso, el S.O. toma previamente el

control. Antes de ceder el control a otro proceso, puede configurar la MMU para
que el nuevo proceso que ha de correr a continuación no pueda acceder a
posiciones de memoria que no son suyas.
Si el proceso intenta salir de su dominio, la MMU generará una excepción que
devolverá el control al sistema operativo para que tome las medidas apropiadas.
Virtualización de direcciones mediante la MMU
Los sistemas tienen una cantidad de memoria RAM limitada pero pueden
tener bastante más espacio en el disco duro. Si un programa es más grande que el
espacio que tiene asignado en memoria, siempre puede cargar del disco sólo una
parte. Cuando lo necesite siempre puede cargar otra parte.
Esto es lo que se conoce como overlays y no requieren de participación del
sistema operativo. Un programa basado en overlays está compuesto de diferentes
partes (overlays) que se van cargando en memoria dinámicamente según son
necesitadas.
Los overlays tienen el inconveniente que el programa que está en marcha ha de
saber en todo momento que partes necesita e ir cargándolas explícitamente cuando
no están presentes en memoria descartando otras partes en el proceso.
La memoria virtual es una manera de hacer transparente al programa el uso

de más memoria de la disponible sin necesidad de que el programa tenga necesidad
de controlar que partes se hallan en memoria en todo momento.
La idea es usar el disco duro, en el que tenemos mucho más espacio, como si fuera
memoria RAM pero, a diferencia de los overlays, de una manera que es
transparente al funcionamiento del programa en curso.
Como ejemplo de explicación del funcionamiento de la memoria virtual,

consideremos una CPU con un bus de direcciones de 32Gb. Teóricamente sería
capaz de direccionar 232 = 4GBytes. Supongamos que, debido a los costes de la
memoria, el sistema únicamente tiene implementados 16 MBytes (224 Bytes) que
corresponden, por tanto, a sólo 24 líneas de direcciones.

Para gestionar la memoria virtual conectamos la CPU, con sus 32 líneas de
direcciones a la MMU. La MMU, a su vez, la conectamos con la memoria, pero
dado que ésta sólo tiene 16 MBytes, la conectamos con 24 líneas de direcciones.
Al mismo tiempo, reservamos 4 GBytes de memoria en el disco duro del sistema
que será empleado como reserva de memoria virtual. Estos 4 Gb los dividiremos
en bloques, todos del mismo tamaño, que denominaremos páginas.
32 24
CPU Direcciones MMU Direcciones MEM DISCO
1 2
Datos Datos
3 4
.........
Control Control n-1 n
Podemos hacer creer a los programas que realmente hay implementados 4

GBytes de memoria RAM. Al fin y al cabo la CPU puede direccionar todo ese
espacio y todas las direcciones del espacio de 4 GBytes llegan a la MMU.
Lógicamente, en memoria sólo nos cabe una parte de las páginas de memoria
virtual. La MMU hará la traducción de las direcciones que solicita la CPU a las
correspondientes a las páginas que se hallan en memoria.
Si un programa intenta acceder a una dirección de una página que no se halla

en memoria, la MMU generará una excepción. Eso hará que el SistemaOperativo
se encargue de cargar la página solicitada del disco. Quitando otra de memoria si
es necesario. Todo el proceso es transparente al programa que no sabe que
realmente no hay 4 GBytes de memoria real.
El uso de memoria virtual funciona correctamente siempre y cuando un

programa no emplee tanta memoria virtual que tenga que estar continuamente
forzando a la MMU a pedir la carga bloques del disco duro a la memoria con la
consiguiente caída de velocidad del sistema. En este caso se dice que el programa
hace trashing.

Segmentación de direcciones
Mediante el uso de memoria virtual, todos los programas comparten un

espacio de memoria virtual mucho más amplio que la memoria real del sistema,
pero, en principio, tenemos un espacio de memoria lineal. En el ejemplo anterior,
desde la dirección 0 a la 232-1.
El uso de segmentación va un paso más allá. Consiste en asignar a distintas partes

de código o datos distintas direcciones virtuales.
FFFFFh Nuevamente describiremos la situación con un

ejemplo.
Sea un sistema con 1MByte de memoria real o

3BFFFh virtual como el de la figura de la izquierda.
Data 2
64K El rango de direcciones posibles será una
secuencia lineal de 00000h a FFFFFh
2C000h
Code 2 Supongamos que tenemos dos programas en
48K memoria en un instante dado.
20000h
Un programa “1” con código y datos que ocupan
en conjunto 32 KBytes y un programa “2” dividido
en una parte de código de 48 KBytes seguida de
17FFFh Code+Data 1
una parte de datos de 64 KBytes.
32K
10000h
00000h
El programa “1” comienza en la dirección 10000h, al cargarse en memoria se

podría haber cargado en cualquier posición dentro del mapa, por tanto, durante la
carga del programa se han de reescribir todas las etiquetas absolutas para que
apunten a las direcciones correctas que corresponden a la posición actual del
programa en memoria. Igual pasa para todas las direcciones del programa “2”.
Con objeto de simplificar la gestión de las direcciones podemos dividir las

direcciones en cada segmento como la suma de la posición de inicio de cada
segmento y un offset. Tal y como se muestra en la siguiente figura.

FFFFFh
INICIO OFFSET
3BFFFh 0FFFFh
Data 2
64K
2C000h 2C000h 00000h
2BFFFh 0BFFFh
Code 2
48K
20000h 20000h 00000h
17FFFh Code+Data 1 07FFFh

32K
10000h 10000h 00000h
00000h
Podemos entender la memoria como que tiene tres segmentos de 32 KB, 48

KB y 64 KB. Con objeto de simplificar el funcionamiento de los programas,
podemos asignar a la MMU la tarea de generar la dirección lineal real en función
del offset de cada segmento.
Por ejemplo, cuando el Sistema Operativo toma el control antes de dar curso al
programa “1”, puede programar la MMU para que sume la dirección de inicio de
segmento a todas las direcciones que genere este programa. De esta manera, el
programa puede pensar que realmente está corriendo desde la dirección “0” y, por
tanto, es posible compilarlo y cargarlo en memoria sin necesidad de hacer ninguna
traducción de direcciones absolutas.
A nivel de MMU, la segmentación se puede combinar con la memoria

virtual, de manera que cada programa cree estar corriendo desde la dirección 0 de
memoria pese a que cada programa comienza desde una dirección distinta de
memoria virtual y pese al hecho que no hay, en realidad, suficiente memoria “real”
para que quepan todos los programas que se hallan en fase de ejecución.

Anexo I : Ejemplos de decodificación de memoria
En este anexo se muestran algunos ejemplos de decodificación de memoria que
pertenecían a una versión anterior de estos apuntes. Algunos casos son similares a
los presentados anteriormente, pero otros no lo son.
Decodificación para bus de datos de 1 byte (8 bits) y una Memoria
Si el bus de datos de la CPU y de las memorias es de 8 bits, se unen entre sí todas

las líneas D0 a D7 de CPU y memorias.
Lo que queda es resolver las direcciones.
Supongamos que la CPU tiene n líneas de direcciones A0...An-1.

La memoria deberá tener un número de líneas m menor o igual A0...Am-1.
Si m es menor que n, la memoria no llenará todo el espacio de direcciones de la

CPU. Eso se representa en el mapa de memoria de la CPU que muestra todo su
posible rango de direccionamiento.
A la hora de decodificar, el hecho de que deseamos que la memoria sea contigua

hace que un chip de memoria con m líneas de direcciones (2m posiciones), deba
emplear las direcciones de la CPU desde A0 hasta Am-1 como líneas de direcciones.
Las líneas de la CPU desde m en adelante se usarán para generar CS* de manera
que sólo una combinación de estas líneas genere un señal CS* baja.
0000H
CPU MEM
CPU MEMORIA A0 - A 13 A0 - A 13
n=16 16kB (m=14)
A 14- A 15 DEC. CS
Espacio
DIR.
de 64kB
D0 - D 7 D0 - D 7
FFFFH
Ejemplo de CPU capaz de direccionar 65kB (A0-A15) conectada a una

memoria de 16kB (A0-A13) Las líneas A14 y A15 de la CPU se usan para
general la señal CS*.

Si no se conectaran las direcciones A0-Am de CPU a las direcciones A0-Am de la
memoria, el espacio de memoria estaría fragmentado como en el caso siguiente.
0000H
CPU MEM
CPU A1 - A 14 A0 - A 13
n=16 MEMORIA
16kB (m=14)
Sólo en pos. pares A 0 , A 15 DEC. CS
Espacio
DIR.
de 64kB
D0 - D 7 D0 - D 7
FFFFH
Ejemplo de memoria fragmentada debido a que A0 de la CPU se ha

empleado en la generación de CS* en lugar de conectarla a A0 de la
memoria.
Queda por resolver como se genera el CS* a partir de las líneas restantes del bus de
direcciones. La solución más sencilla y habitual es colocar el inicio de la memoria
en una posición del mapa de direcciones que sea múltiplo de su tamaño.
Si la CPU tiene n líneas de direcciones y la memoria tiene m:
El espacio total de direcciones es 2n bytes. (216=26·210=64k en el ejemplo)

La memoria es de 2m bytes. (214=24·210=16k en el ejemplo)
Podemos dividir el espacio de direcciones en m marcos donde p=2n-m cada una de

los cuales será justamente del tamaño de la memoria. (p=216-14=22=4).
Cada marco m empieza en m·2m y acaba antes de empezar el siguiente en

(m+1)·2m - 1.
A15 A14 A13...A0 CPU

Marco A13...A0 Memoria
Tabla de Decodificación
La memoria se puede situar en cualquiera de estos marcos eligiendo la

combinación adecuada de las líneas de direcciones no usadas directamente en la
memoria.

0000H
Marco 0
CPU (A16 A 15= 00)
n=16
Marco 1
Espacio (A16 A 15= 01)
de 64kB
Marco 2
4 Marcos (A16 A 15= 10)
de 16kB
Marco 3
(A16 A 15= 11)
FFFFH
Marcos seleccionables por la

circuitería de decodificación.
Si deseamos poner la memoria en el marco 0:
0000H
MEMORIA
16kB M0
CPU CPU MEM
n=16
A0 - A 13 A0 - A 13
M1
Espacio
de 64kB A
14
CS
A 15
4 Marcos M2
de 16kB
D0 - D 7 D0 - D 7
M3
FFFFH
Ejemplo de decodificación que sitúa la memoria de 16kB al principio del

espacio de direcciones de la CPU (Página 0).
Strobes no mostrados por simplicidad.
La tabla de direcciones reflejará esta asigación dado que A15 y A14 han de valer 0
(marco 0) para que se active CS* en la memoria.
A15 A14 A13...A0 CPU

0 0 A13...A0 Memoria
Tabla de Decodificación
Negando o no cada una de las líneas A14 y A15 antes de la puerta OR (AND en
lógica negada), podemos poner la memoria en cualquiera de los 4 marcos posibles.

La adición de strobes a la lógica de decodificación de memoria no se ha puesto por
simplicidad, pero podría ser como se muestra:
A
14
A 15
CS
MREQ
En este caso CS* se activará únicamente cuando A14=A15=0 y MREQ* se halle

activa (nivel bajo).
Decodificación para bus de datos de 1 byte (8 bits) y varias Memorias
Cuando tenemos varias memorias, el procedimiento es el mismo que para una

memoria pero repitiéndolo en cada una de las memorias.
Lo único que se ha de vigilar es que los espacios de los diferentes chips de
memoria no se solapen entre sí.
Si, por ejemplo, hemos de poner 2 chips de memoria de 16kB es un mapa de

memoria de CPU de 64kB que tiene soporte para 4 marcos de 16kB, bastaría
asociar cada chip de memoria a un marco distinto.
A15 A14 A13...A0 CPU Rango

0 0 A13...A0 Memoria 1 0 a 214-1
0 1 A13...A0 Memoria 2 2 a 2·214-1
14
Tabla de Decodificación para dos memorias
0000H
MEMORIA 1
16kB M0
CPU CPU MEM MEM
n=16
MEMORIA 2 A0 - A 13 A0 - A 13 A0 - A 13
M1
Espacio 16kB
de 64kB A14 A14
A15 CS A15 CS
4 Marcos M2
de 16kB
D0 - D 7 D0 - D 7 D0 - D 7
M3
FFFFH
Ejemplo de decodificación que sitúa dos memorias de 16kB al principio

del espacio de direcciones de la CPU (Marcos 0 y 1).
Strobes no mostrados por simplicidad.
En el ejemplo anterior las líneas A14 y A15 se han decodificado de manera

independiente en cada memoria. Lo normal, sin embargo, es agrupar la lógica
usando decodificadores.
En efecto, si damos A14 y A15 como entrada de un decodificador binario de 2 a 4,
las 4 salidas serán las correspondientes a los 4 marcos.

Dado que las señales CS* son de lógica negada, emplearemos un decodificador
con salidas negadas.
Adicionalmente, usaremos un decodificador con entrada de habilitación para
añadir la línea de strobe usada para acceder a la memoria.
CPU MEM MEM

A0 - A 13 A0 - A 13 A0 - A 13
CS CS
D0 - D 7 D0 - D 7 D0 - D 7
0
A15 X1 1
A14 X0 2
3
MREQ
Ejemplo de uso de decodificadores.
MREQ* A15 A14 O3* O2* O1* O0*

H X X H H H H
L 0 0 H H H L
L 0 1 H H L H
L 1 0 H L H H
L 1 1 L H H H
Tabla de verdad del decodificador
Cuando tenemos memorias del mismo tamaño, podemos agrupar un conjunto de

ellas que sea potencia de 2 de manera que accesos a posiciones consecutivas den
lugar a accesos a chips distintos de memoria.
En el caso de chips RAM puede mejorar la velocidad de acceso a direcciones
consecutivas. En el caso de ROM no suele ser conveniente porque obliga a
programar los chips con valores que no son contiguos en el mapa de memoria.
A modo de ejemplo, usando las 2 memorias anteriores se podrían agrupar con lo

que resultaría:
A15 A14...A1 A0 CPU Rango

15
0 A13...A0 0 Memoria 1 0 a 2 -2 pares (A0=0)
0 A13...A0 1 Memoria 2 0 a 215-1 impares (A0=1)
Tabla de decodificación de 2 chips memoria con direcciones intercaladas
Lo que es fundamental es que el conjunto de memorias que ocupa 2∙16k = 32kB =

215 asigne todas las posibles combinaciones de los bits A0 a A14 de manera que no
haya huecos en el espacio total asignado de 32kB.

El mapa de memoria y el conexionado resultante sería:
0000H
MEM 1 (pares)
CPU MEM MEM
CPU
n=16 A0 - A 13 A1 - A 14 A1 - A 14
Espacio MEM 2 (impares)

de 64kB CS CS
D0 - D 7 D0 - D 7 D0 - D 7
FFFFH 0
A15 X1 1
A0 X0 2
3
MREQ
Ejemplo de decodificación para memorias intercaladas.
Con 4 memorias de 16kB las combinaciones posibles serían algunas más

dependiendo de si las ponemos consecutivas o intercaladas:

0 0 A13...A0 Memoria 1 0 a 214-1
0 1 A13...A0 Memoria 2 214 a 2·214-1
1 0 A13...A0 Memoria 3 2·214 a 3·214-1
1 1 A13...A0 Memoria 4 3·214 a 4·214-1
Tabla de decodificación 1: 4 Memorias consecutivas
A15 A14...A1 A0 CPU Rango

15
1 A13...A0 0 Memoria 3 215 a 216-1 pares (A0=0)
15
Tabla de decodificación 2: Memorias intercaladas 2 a 2
A15...A2 A1 A0 CPU Rango

A13...A0 0 0 Memoria 1 0 a 216-1 (A0,A1=00)
A13...A0 0 1 Memoria 2 0 a 216-1 (A0,A1=01)
A13...A0 1 0 Memoria 3 0 a 216-1 (A0,A1=10)
A13...A0 1 1 Memoria 4 0 a 216-1 (A0,A1=11)
Tabla de decodificación 3: 4 Memorias intercaladas

A15 A14 A13...A1 A0 CPU Rango
15
1 0 A13...A0 Memoria 3 2·214 a 3·214-1
1 1 A13...A0 Memoria 4 3·214 a 4·214-1
Tabla de decodificación 4: 2 Intercaladas y 2 Consecutivas
Las decodificaciones 1 a 3 se pueden realizar usando un decodificador de 2 a 4, pero la de la tabla

4 es algo más compleja.
A continuación se muestran los mapas de memoria resultantes de las 4

decodifiaciones:
0000H
MEMORIA 1 MEMORIA 1 MEMORIA 1 MEMORIA 1
P0 P0 MEM1 P0 P0
16kB 16kB 16kB 16kB
MEMORIA 2 MEMORIA 2 P1 MEMORIA 2 P1

P1 MEM2 P1
16kB 16kB 16kB
MEMORIA 3 MEMORIA 3 MEMORIA 3

P2 16kB P2 MEM3 P2 P2
16kB 16kB
MEMORIA 4 MEMORIA 4
P3 MEMORIA 4 P3 P3 P3
16kB MEM4 16kB
FFFFH 16kB
+ Mapa 1 Mapa 2 Mapa 3 Mapa 4
Mapas de memoria correspondientes a las tablas anteriores
Caso de memorias de distinto tamaño
La decodificación para memorias de distinto tamaño es similar.
Consideremos, por ejemplo, el caso en que deseamos poner una memoria de 16kB
y otra de 32kB conectadas a una CPU con un espacio de direcciones de 64kB.
La CPU tendrá 4 marcos de 16kB. Situaremos la memoria de 16kB en uno de ellos.

Adicionalmente la CPU tendrá 2 marcos de 32kB. Situaremos la memoria de 32kB
en uno de ellas.
Se habrá de verificar que no se den solapamientos. Ninguna dirección puede ser
asignada a ambos chips de memoria ya que ello daría lugar a una colisión en el bus
de datos.
Elegimos poner la memoria de 32kB en el primero de los 2 marcos de 32 kB

(M032k). También elegimos poner la memoria de 16kB en el tercero de los 4 marcos
de 16kB (M216k).
De esta manera la memoria total es continua.
Si hubiéramos puesto la memoria de 16kB en el marco M016k o en el M316k no nos

sería posible situar la memoria de 32k usando decodificación simple sin tener un
hueco en el mapa de memoria.

0000H
CPU MEM MEM

M0
MEMORIA 1 32k 16k
M0
32kB
M1
A 0 - A14 A0 - A 13
MEMORIA A14
M2 A15
16kB CS A15 CS
M1
M3 D0 - D 7 D0 - D 7 D0 - D 7
FFFFH
Ejemplo de decodificación para dos memorias de distinto tamaño
La tabla de uso de direcciones sería:

0 A14...A0 Mem 32k 0 a 215-1
1 0 A13...A0 Mem 16k 2·214 a 3·214-1
Ejemplo de tabla de decodificación para dos memorias de distinto tamaño
Nuevamente pueden usarse decodificadores. La manera más fácil, en este caso, es

decodificar los 4 marcos de 16kB. La conexión de la memoria de 16kB es directa
conectándola a la salida del marco elegido (M216k).
Para la memoria de 32kB, la señal CS* no puede depender de la línea A14 que entra
en el decodificador.
Las dos posibles opciones son:
A) Conectar A15 a la entrada CS* de la memoria de 32kB igual que en la

figura anterior.
B) Elegir las dos salidas del decodificador asociadas al marco 0 de 32kB

(corresponde a los marcos 0 y 1 de 16kB).
La figura siguiente muestra la realización si se opta por la opción B.

Obsérvese que se usa una puerta AND que corresponde a la función OR en lógica
negada.
Probablemente en este caso concreto sea mejor la opción A, ya que evita el uso de la puerta AND.
Ejemplo de decodificación no standard
Uno podría pensar en la posibilidad de poner la memoria de 16k en el primermarco de 16k, M016k y
la memoria de 32k ocupando los dos marcos M116k y M216k.
Aunque esta opción garantiza la continuidad de la memoria, no es fácil de implementar dado que
los dos marcos consecutivos M116k y M216k no equivalen a ningún marco de 32k.
Ello no implica que no se pueda hacer, pero es más laborioso. Queda como ejercicio para el lector
determinar la circuitería que sería necesaria en este caso.

CPU MEM MEM
32k 16k
A 0 - A14 A0 - A 13
CS CS
D0 - D 7 D0 - D 7 D0 - D 7
0
A15 X1 1
A14 X0 2
3
MREQ
Implementación con un decodificador
Decodificación incompleta y zonas imagen
Si la aplicación diseñada no requiere usar todo el espacio direccionable por el

procesador, se puede optar por realizar una decodificación incompleta.
A modo de ejemplo, si deseamos conectar una memoria de 16kB (214) a un

procesador con 16 líneas de direcciones (216=64kB), podemos prescindir de la
decodificación de las líneas A14 y A15.
0000H
MEMORIA
16kB M0
CPU MEM
MEMORIA A0 - A 13 A0 - A 13
M1
16kB
MEMORIA MREQ CS
16kB M2
D0 - D 7 D0 - D 7
MEMORIA
M3
16kB
FFFFH
Ejemplo de decodificación incompleta
Dado que la información de A14 y A15 que permite elegir los marcos de 16kB
dentro del mapa de memoria no se usa en la decodificación, resulta que la memoria
se halla activa para todos los marcos.

O lo que es lo mismo, se cumple:
MREQ* A15 A14 Marco de 16k CS*

0 0 0 0 0
0 0 1 1 0
0 1 0 2 0
0 1 1 3 0
Tabla de decodificación incompleta
En realidad, cuando se accede a cada marco se está accediendo a la misma

memoria, ya que CS* está activo en todos los marcos.
Por tanto, para x desde 0 a 214-1 todas las direcciones:
X X+214 X+2·214 X+3·214
Son equivalentes.
Se puede decir que la memoria de cada una de los marcos es una imagen exacta de
la de las otras. Es por ello que a todas ellas se les denomina Zonas Imagen.
En general, cuando no se usa un número m de direcciones del bus de direcciones

para realizar la decodificación, el número de zonas imagen mínimo es 2m.
En nuestro caso no hemos usado 2 líneas A14 y A15 y tenemos 22 = 4 zonas imagen.
Es fácil saber el número de zonas imagen a partir de la tabla de decodificación.

Basta para ello ver el número combinaciones binarias para los indeterminados de la
tabla de direcciones.
Los rangos se obtienen para todas las posibles combinaciones binarias de las X de
la tabla.
A15 A14 A13...A0 CPU N img. Rangos

0 a 214-1
214 a 2·214-1
X X A13...A0 Memoria 22=4
2·214 a 3·214-1
3·214 a 4·214-1
Tabla de decodificación incompleta con X en las líneas no usadas
Es interesante obtener el número de imágenes de un análisis como el de la tabla

anterior, ya que el hecho de usar todas las líneas de direcciones no garantiza la
ausencia de zonas imagen. En el siguiente ejemplo usamos todas las direcciones
de la CPU y, por la manera de hacer la decodificación, tenemos 2 zonas imagen.

0000H
MEMORIA CPU MEM
16kB M0
A0 - A 13 A0 - A 13
M1
CS
M2
D0 - D 7 D0 - D 7
MEMORIA
M3
16kB
FFFFH 0
A15 X1 1
A14 X0 2
3
MREQ
Ejemplo con zonas imagen usando todas las direcciones en la decodificación
Evaluar el número de zonas imagen es fácil a partir de la tabla de direcciones:

0 0 0 a 214-1
A13...A0 Memoria 2
1 1 3·214 a 4·214-1
Evaluación de las zonas imagen a partir de la tabla de decodificación
Obsérvese que no hay ninguna X en la tabla. De hecho, el número de zonas imagen

no tiene porque ser una potencia de 2. En efecto, si en lugar de tomarse las salidas
0 y 3 del decodificador se tomaran las salidas 0, 1 y 2 tendríamos:

0 0 0 a 214-1
0 1 A13...A0 Memoria 3 2 a 2·214-1
14
1 0 2·214 a 3·214-1
Decodificación con 3 zonas imagen

Memorias de menos de 8 bits
Si la memoria es de menos de 8 bits, podemos juntar varias de ellas con el mismo

ancho de direcciones hasta obtener una memoria equivalente de 8 bits.
Para ello juntaremos las líneas de direcciones de todas las memorias junto con CS*
y otras señales de control.
Luego juntaremos agruparemos las líneas de datos de las memorias hasta llegar a
las 8 líneas necesarias para completar un byte.
CPU
D
0
D -D
0 3
D
7
A0 - A m-1
CS
D -D
0 3
A0 - A m-1 A0 - A m-1
Am- A n-1 DEC. CS

DIR.
Ejemplo de decodificación para CPU de 8 bits y memorias de 4 bits.
Es posible poner esta distribución de memoria en la tabla de reparto de direcciones.

Por ejemplo, si deseáramos poner 2 chips de 16k posiciones de 4 bits en la segunda
página de 16k de un procesador con 16 líneas de direccionamiento (64kB), la tabla
resultaría:
A15 A14 A13...A0 Bits 7..0 CPU Rangos

0 1 A13...A0 Bits 3..0 Mem. 1 1014 a 2·1014-1 (bits 3..0)
0 1 A13...A0 Bits 7..4 Mem. 2 1014 a 2·1014-1 (bits 7..4)
Tabla de decodificación con una columna para la distribución de bits.

La siguiente figura muestra como quedaría el mapa de memoria.
Bits 7..4 Bits 3..0

0000H
P0
MEM. 2 MEM. 1
P1
16k (4bits) 16k (4bits)
P2
P3
FFFFH
Mapa de memoria para 2 memorias de menos de 1 byte.
Decodificación para bus de datos de varios bytes
Los buses de datos de los µP/µC no siempre son de 8 bits (1 byte).
El número de bytes (NB) del bus de datos suele ser una potencia de 2.
La anchura w, en bits, del bus de datos suele ser por tanto del tipo w=8·2x=8·NB.
Los valores habituales son 8 (byte), 16 (word) y 32 (dword).
Con independencia de la anchura del bus de datos, las líneas de direcciones de la

CPU A0..An-1 siempre referencian bytes (8 bits). El mapa de memoria también se
da en bytes puesto que usa la codificación de las líneas del bus de direcciones.
Las direcciones de las memorias, sin embargo, suelen ser siempre desde A0 con independencia de
que sean bytes, word, dwords o incluso bits independientes.
Si el bus de datos es de 16 bits, no tiene sentido que la línea A0 salga de la CPU

puesto que cuando A0 sea 0 (direcciones pares), los datos vendrán por las líneas D0
a D7 y cuando A0 sea 1 (direcciones impares), los datos vendrán por las líneas D8 a
D15. De hecho, la información de A0 saldrá de la CPU no por una línea con ese
nombre sino a través de la activación de los strobes de byte.
Ancho del bus de datos Dir. salientes CPU Ejemplo Strobes

8 bits (Byte) A0...An-1 MREQ*
16 bits (Word) A1..An-1 UDS*,LDS*
32 bits (Dword) A2..An-1 BE0*,BE1*,BE2*,BE3*
Lineas de direcciones y Strobes

A la hora de hacer la decodificación, la manera de proceder, a priori, es la misma
que cuando decodificamos con buses de datos de 8 bits.
Si las memorias son de 8 bits (1 Byte), los bits de direcciones más bajos que no
salen del procesador, A0 en 16 bits y A0, A1 en 32 bits deberán ser decodificados,
puesto que pertenecen a chips distintos. La única diferencia con el caso de buses de
8 bits es que valores, por ejemplo, de A0=0 y A0=1 pueden ser accedidos a la vez
usando los strobes.
A modo de ejemplo mostraremos como poner 2 chips de 128kB (217) en un

procesador 68000 que tiene un bus de datos de 16 bits.
Los dos chips de memoria usarán A0 en la decodificación por lo que uno empleará
direcciones pares y el otro impares. En conjunto direccionarán 256kB (218). El
68000 tiene 24 líneas de direcciones por lo que tiene 224-18=26=64 páginas de
268kB.
Situaremos, a modo de ejemplo, la memoria en el último marco, el número 63.
A23 A22 A21 A20 A19 A18 A17..A1 Strobes (A0) CPU Rango
63·218
LDS* MEM a
1 1 1 1 1 1 A16..A0
(A0=0) 1 64·218-1
(Pares)
A16..A0 63·218
UDS* MEM a
1 1 1 1 1 1
(A0=1) 2 64·218-1
(Impares)
Ejemplo de tabla de decodificación en el µP 68000
El mapa de memoria resultante será:
000000H
FC0000H
MEM 1 / MEM 2 P63
FFFFFFH

Un diagrama circuital que implementa esta decodificación es:
A 1 ... A 17
A 18... A A 0 ... A 16 A 0 ... A 16

23
LDS MEM 1 MEM 2

CS CS
CPU D 0 ... D 7 D 0 ... D 7
UDS
D 0 ... D 7
D 8 ... D 15
Caso de que se tratara de una CPU de 32 bits, el número de chips de memoria de 8

bits habría de ser múltiplo de 4.
A continuación se muestra un ejemplo que conecta una CPU con 24 líneas en el
bus de direcciones y con bus de datos de 32 bits con 4 memorias de 128kB para un
total de 512kB en el primer marco de memoria (de 512kB).
Strobes
A23 A22 A21 A20 A19 A18..A2 (A1A0) CPU Rango
0 0 0 0 0 A16..A0 BE0* (00) Mem 1 0 a 219-1
Dir. mod 4 = 0
19
0 0 0 0 0 A16..A0 BE1* (01) Mem 2 0 a 2 -1
Dir. mod 4 = 1
19
0 0 0 0 0 A16..A0 BE2* (10) Mem 3 0 a 2 -1
Dir. mod 4 = 2
19
0 0 0 0 0 A16..A0 BE3* (11) Mem 4 0 a 2 -1
Dir. mod 4 = 3
Ejemplo de tabla de decodificación para una CPU de 32bits
Memorias de más de 8 bits
Para µP/µC con bus de datos de más de 8 bits, también existe la posibilidad de
emplear memorias con el mismo ancho de bus de datos que el microprocesador.
Si la CPU puede hacer accesos con ancho menor que el bus de datos, es necesario
que la memoria, para operaciones de escritura, cuente con strobes de byte igual que
la CPU. En operaciones de lectura no es necesario dado que la CPU sencillamente
ignorará los bytes no solicitados con los strobes.

El procedimiento de decodificación es similar al caso anterior. La diferencia se
halla en que los strobes de byte de la CPU no se usarán para generar las señales
CS* de los chips de memoria sino que se conectarán, para memorias RAM, a los
strobes de entrada de la memoria. Si la memoria es de tipo ROM y no tiene
entradas de strobe de byte, lo que si se empleará es un strobe general de la CPU
dentro de la generación de la señal CS*.
La siguiente tabla muestra como conectar un chip de memoria de 128k (217)

posiciones de 16 bits (total de 256kB) en un procesador 68000 que tiene también
un bus de datos de 16 bits. Situaremos, igual que en caso anterior, la memoria en el
último marco, el número 63.
A23 A22 A21 A20 A19 A18 A17..A1 A0 CPU Rango

63·218
1 1 1 1 1 1 A16..A0 -- MEM a
64·218-1
Ejemplo de tabla de decodificación para CPU y memoria de 16 bits
El mapa de memoria resultante será:
000000H
FC0000H
MEM 128k x 16 bits P63
FFFFFFH

Un circuito que realiza la conexión entre la CPU y la memoria sería:
CPU MEM
A 1 ... A 17 A 0 ... A 16
A 18... A 23 CS
LDS LB
UDS UB
D 0 ... D 15
D 0 ... D 15
Si la memoria es de tipo ROM, podríamos prescindir de las señales LB* y UB*.
Decodificación con solapamientos
Tal y como se ha indicado anteriormente, no suele ser conveniente que una

dirección de memoria de se asocie al mismo tiempo a dos chips distintos dado que
daría lugar a una colisión en el bus de datos.
En algunas ocasiones, no obstante, puede ser interesante aprovechar el
solapamiento y las zonas imagen para simplificar la circuitería de decodificación.
A modo de ejemplo se mostrará la conexión de dos memorias de 16kB en una CPU

con un espacio de direcciones de 64kB.
CPU MEM 1 MEM 2

A0 - A 13 A0 - A 13 A0 - A 13
A14 A15
CS CS
MREQ MREQ
D0 - D 7 D0 - D 7 D0 - D 7
Ejemplo de decodificación con solapamientos

La tabla de decodificación resultante será:

0 0 A13...A0 Mem. 1 y 2 0 a 214-1
0 1 A13...A0 Memoria 2 2 a 2·214-1
14
1 0 A13...A0 Memoria 1 2·214 a 3·214-1

1 1 A13...A0 No usado 3·214 a 4·214-1
Ejemplo de tabla de decodificación con solapamientos
El mapa de memoria será:
0000H
MEMORIAS
1y 2 P0
SOLAPADAS
4000H
MEMORIA 2 P1
16kB
8000H
MEMORIA 1
16kB P2
C000H
P3
FFFFH
La CPU podrá acceder a la memoria 1 en el rango de 8000H a BFFFH.

También podrá acceder a la memoria 2 en el rango de 4000H a 7FFFH.
Pero se deberá cuidar mucho la programación para que nunca se intente acceder en
lectura a direcciones dentro del rango 0000H a 3FFFFH.
Por otro lado, el acceso en escritura este rango solapado podría ser interesante en
aplicaciones en las que interese escribir a la vez en los dos bloques de memoria.
Comentarios adicionales
En general, este tipo de decodificación no suele ser muy útil porque desaprovecha mucho el
espacio de memoria disponible debido a los rangos en los que se dan solapamientos.
Si el espacio de direccionamiento de la CPU es de 2n y las memorias son de 2m bytes, podrán
conectarse un máximo de n-m memorias de este modo (Un CS* a cada línea del bus de direcciones
de la CPU que no va al bus de direcciones de las memorias).
El número de páginas disponibles de 2m bytes es, sin embargo 2n-m.
De ello, la eficiencia de uso del espacio de direcciones es (n-m)/2n-m.
Para el ejemplo n=16 y m=14, la eficiencia máxima es 2/22 = 50%.
Pero para n=24 y m=14, se podrían poner como máximo 10 chips de 16kB y la eficiencia bajaría
hasta 10/210 ≈ 1%

Anexo II : Conversión Decimal ↔ Hexadecimal
La numeración hexadecimal emplea 16 posibles valores para cada dígito. Dado que
en notación decimal empleamos sólo 10 valores (0...9), los valores restantes en
hexadecimal se extraen del abecedario. De ello:
Decimal Hexadecimal Decimal Hexadecimal

0 0 8 8
1 1 9 9
2 2 10 A
3 3 11 B
4 4 12 C
5 5 13 D
6 6 14 E
7 7 15 F
La conversión de hexadecimal a decimal es directa teniendo en cuenta que cada

dígito hexadecimal tiene un peso 16x donde x es la posición de este dígito
empezando por cero y de derecha a izquierda:
4D2H = 4∙162+13∙161+2∙160 = 2 + 16 ( 13 + 16 ( 4 ) ) = 1234
La conversión inversa, de decimal a hexadecimal, se puede hacer por divisiones

sucesivas del número decimal:
1234 16 Para el número 1234 decimal, se divide por 16 y se obtiene 2

77 2 de cociente y 77 de resto. Reservamos el cociente como dígito
hexadecimal de menor peso.
77 16
El resto obtenido se vuele a dividir y volvemos a reservar el
13
cociente como siguiente dígito hexadecimal más significativo
4 que el anterior.
El proceso se repite hasta que el resto sea menor que 16.
4 D 2
Este último resto constituye el dígito más significativo.

Tema 4 (v1.0B)

Cargado por

Copyright:

Formatos disponibles

Tema 4 (v1.0B)

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Tema 4 (v1.0B)

Cargado por

Copyright:

Formatos disponibles

DSBM

Vicente Jiménez - Apuntes de DSBM - Tema 4 - Pag. 1

Fecha Versión Descripción

Vicente Jiménez - Apuntes de DSBM - Tema 4 - Pag. 2

Vicente Jiménez - Apuntes de DSBM - Tema 4 - Pag. 3

Antes de empezar a hablar del susbsistema de memoria, resulta conveniente

Todas identifican una señal activa a nivel bajo.

Algunas señales tienen un uso dual dependiendo de si son altas o bajas, en

Vicente Jiménez - Apuntes de DSBM - Tema 4 - Pag. 4

La CPU, por tanto, se comunica con la memoria empleando tres buses:

La interacción entre la CPU y la memoria distingue dos posibilidades. Que la

A continuación se muestra un ejemplo de la secuencia de acciones en un ciclo de

• CPU pone la dirección a leer en el bus de direcciones

Obsérvese como es la CPU la que gestiona todas las acciones a realizar.

Vicente Jiménez - Apuntes de DSBM - Tema 4 - Pag. 5

• CPU pone la dirección a leer en el bus de direcciones

Un ciclo de escritura sería simular:

• CPU pone la dirección donde escribir en el bus de direcciones

Nuevamente la CPU cuenta con que la memoria tiene tiempo de escribir el

• CPU pone la dirección donde escribir en el bus de direcciones

La diferencia entre las dos opciones es importante ya que en el primer caso

Las distintas CPUs que hay actualmente en el mercado gestionan de distinta

Vicente Jiménez - Apuntes de DSBM - Tema 4 - Pag. 6

El bus de datos D0..Dn-1 corresponde a la información que entra o sale de la

El bus de direcciones A0..Am-1 corresponde a la dirección, o lugar, donde se

Memoria con D0..D7 y A0..A15

Memoria con D0..D31 y A0..A9

Vicente Jiménez - Apuntes de DSBM - Tema 4 - Pag. 7

Recordad que en terminología de memorias:

K=210 M=220 G=230 T=240

Esta terminología no se ha de confundir con la de los discos duros, donde:

K=103 M=106 G=109 T=1012

Vistos los buses de datos y direcciones pasaremos a describir las señales de

OE* (Output Enable)

WE* (Write Enable)

CS* (Chip Select) también llamada CE* (Chip Enable)

Vicente Jiménez - Apuntes de DSBM - Tema 4 - Pag. 8

Una memoria RAM es aquella en la que se puede leer o escribir a posiciones

SRAM (Static Random Access Memory)

El circuito biestable está compuesto por dos inversores enfrentados. Una

DRAM (Dynamic Random Access Memory)

El condensador CS almacena el valor lógico

Para acceder a una celda podemos activar el

Para escribir un nuevo valor en la memoria

Vicente Jiménez - Apuntes de DSBM - Tema 4 - Pag. 9

Para leer la celda asociada al condensador CS, precargamos la capacidad de

NVRAM (Non Volatile Random Access Memory)

Se puede implementar de varias maneras:

SRAM con circuito de salvaguarda formado por un condensador una memoria

Vicente Jiménez - Apuntes de DSBM - Tema 4 - Pag. 10

El condensador tiene histéresis debido a los materiales ferroeléctricos que

Se trata de una tecnología bastante nueva, pero ya hay microcontroladores que

4.2.2 Memorias no volátiles

Las memorias SRAM y DRAM son volátiles. La información desaparece al

ROM (Read Only Memory)

Vicente Jiménez - Apuntes de DSBM - Tema 4 - Pag. 11

La creación de la máscara tecnológica es un proceso muy caro, es por ello

PROM (Programmable Read Only Memory)

OTP-ROM (One Time Programmable Read Only Memory)

Vicente Jiménez - Apuntes de DSBM - Tema 4 - Pag. 12

�� = 𝐴𝐴15 + ��