Operaciones aritméticas

Decodificadores
Multiplexores
Memorias

MSI Medium Scale Integration

Operaciones
Aritméticas
Sumadores
Restadores
Multiplicadores
Divisiones
Sumadores
Medio Sumador (Half Adder).
Sumador Completo (Full Adder).
Sumador Serial de 4 bits (Ripple Carry).
Sumador con Acarreo Anticipado (Carry look Ahead)
Sumador BCD
 Medio Sumador (Half Adder).

Un medio sumador (Half Adder) es un circuito lógico digital básico que realiza la suma de dos bits,
produciendo como resultado dos salidas:

1. Suma (S): Representa el bit resultante de la suma de los dos bits de entrada.
2. Acarreo (Co): Representa el bit de acarreo que se genera cuando la suma de los dos bits de entrada
excede 1.

Entradas y salidas
A Suma
•Entradas: A, B (los dos bits que se desean sumar)
•Salidas: S (suma), Co (acarreo)
B Σ HA Acarreo
 Medio Sumador (Half Adder).

A Suma
Tabla de Verdad

B Σ HA Acarreo
A
0
0
B
0
1
Co (Acarreo)
0
0
S (Suma) Decimal
0
1
0
1
1 0 0 1 1
Funciones lógicas 1 1 1 0 2

•Suma: S=A⊕B
•Acarreo: Co=A⋅B
 Sumador Completo (Full Adder).

Un sumador completo es un circuito digital que suma tres bits de entrada:

A, B, Ci (Acarreo de entrada): variables de entrada

Y produce dos salidas:

S,Co: Suma y Acarreo de salida

A diferencia del medio sumador, el sumador completo considera el acarreo que viene de una suma anterior, lo
que permite encadenar sumadores para sumar números binarios de varios bits.

Suma (S)

Σ
A
B
Ci FA Acarreo (Co)
 Sumador Completo (Full Adder).
Tabla de Verdad
A B Ci Co (Acarreo) S (suma) Decimal
Suma (S)

Σ
0 0 0 0 0 0 A
B
0 0 1 0 1 1
Ci FA Acarreo (Co)
0 1 0 0 1 1
0 1 1 1 0 2
1 0 0 0 1 1
1 0 1 1 0 2
1 1 0 1 0 2
1 1 1 1 1 3
Las salidas se definen como:

Suma (S): 𝑆 = 𝐴⨁𝐵⨁𝐶𝑖

Acarreo (Co): 𝐶𝑜 = 𝐴𝐵 + 𝐵𝐶𝑖 + (𝐴𝐶𝑖) o bien 𝐶𝑜 = 𝐶𝑖 𝐴⨁𝐵 + 𝐴𝐵
 Sumador Serial de 4 bits (Ripple Carry).

+ C(3)
C(2)
A(3)
B(3)
C(1)
A(2)
B(2)
C(0)
A(1)
B(1)
Ci
A(0)
B(0)
Problema del acarreo en sumadores
En un sumador en serie (Ripple Carry), cada bit debe
esperar el resultado del acarreo del bit anterior.
Esto causa que el tiempo de propagación crezca
S(4) S(3) S(2) S(1) S(0) linealmente con el número de bits, lo cual vuelve lento el
sumador.
A(3..0)+B(3..0)=S(4..0)

C(1)

Σ Σ Σ
C(0) C(2) C(3)

Σ
Ci
A(0) A(1) A(2) A(3)
B(0) FA B(1) FA B(2) FA B(3) FA

S(0) S(1) S(2) S(3) S(4)

 Sumador TTL 7483

74LS83 Sumador Binario o SN74LS83N es un circuito integrado “CI” de 4 Bit con acarreo rápido y encapsulado DIP-16. El
74LS83 tiene cuatro etapas independientes de circuitos sumadores completos en un solo paquete. Se usa comúnmente en
aplicaciones donde están involucradas operaciones aritméticas.
Sirve para realizar operaciones de un sumador completo binario de 4 bits de alta velocidad con acarreo interno; acepta 2
palabras binarias de 4 bits (A1 – A4, B1 – B4) y una entrada de acarreo (C0). Genera una suma de salida binaria (R1 – R4) y
una salida de acarreo (C4) desde el bit de mas significativo.
 Sumador con Acarreo Anticipado (Carry look ahead adder)

A Carry Look-Ahead Adder (CLA) es un tipo de sumador rápido que mejora la velocidad respecto a los sumadores en
serie (ripple carry adders), porque anticipa los acarreos en lugar de esperar que se propaguen bit a bit.

Concepto básico
En un sumador binario tradicional, el acarreo de salida de cada bit depende del acarreo de entrada anterior. Esto
genera una propagación en cadena (ripple) que hace lento al circuito cuando hay muchos bits.
El CLA evita este problema calculando de forma paralela si cada posición de bit:
•Genera un acarreo (Generate, G)
•Propaga un acarreo (Propagate, P)

Para cada bit 𝑖, con entradas 𝐴𝑖 ,𝐵𝑖 ,y acarreo de entrada 𝐶𝑖 :

Propagate (P):
𝑃𝑖 = 𝐴𝑖 ⊕ 𝐵𝑖
El bit "propaga" un acarreo si al menos uno de los dos es 1.
Generate (G):
𝐺𝑖 = 𝐴𝑖 ⋅ 𝐵𝑖
El bit "genera" un acarreo si ambos son 1.
 Sumador con Acarreo Anticipado (Carry look ahead adder)

Suma (S):
𝑆𝑖 = 𝑃𝑖 ⊕ 𝐶𝑖
Acarreos (C):
𝐶𝑖+1 = 𝐺𝑖 + 𝑃𝑖 ⋅ 𝐶𝑖

Ejemplo en un sumador de 4 bits

Para 𝐴 = 𝐴3 𝐴2 𝐴1 𝐴0 ,𝐵 = 𝐵3 𝐵2 𝐵1 𝐵0 ,y 𝐶0 el acarreo inicial:
Calculamos los propagadores y generadores:
𝑃𝑖 = 𝐴𝑖 ⊕ 𝐵𝑖 , 𝐺𝑖 = 𝐴𝑖 ⋅ 𝐵𝑖
Los acarreos se obtienen:
𝐶1 = 𝐺0 + 𝑃0 𝐶0
𝐶2 = 𝐺1 + 𝑃1 𝐺0 + 𝑃1 𝑃0 𝐶0
𝐶3 = 𝐺2 + 𝑃2 𝐺1 + 𝑃2 𝑃1 𝐺0 + 𝑃2 𝑃1 𝑃0 𝐶0
𝐶4 = 𝐺3 + 𝑃3 𝐺2 + 𝑃3 𝑃2 𝐺1 + 𝑃3 𝑃2 𝑃1 𝐺0 + 𝑃3 𝑃2 𝑃1 𝑃0 𝐶0
Finalmente, las sumas:
𝑆𝑖 = 𝑃𝑖 ⊕ 𝐶𝑖
Sumador con Acarreo Anticipado (Carry look ahead)

Ventaja principal:
En lugar de esperar a que el acarreo
avance bit por bit, el CLA calcula en
paralelo todos los acarreos.
Esto reduce el tiempo de
propagación y hace que sea mucho
más rápido para sumas de gran
cantidad de bits.
 Sumador BCD

Ejercicio:
Diseñar un sumador BCD, es decir, la suma de dos palabras de 4 bits en BCD,
Y el resultado también estará en BCD.
Restador completo
Así como existe el sumador completo (Full Adder), también podemos definir un restador completo (Full Subtractor).
Un restador completo es un circuito combinacional que resta tres bits de entrada:

A → minuendo (bit principal). Tabla de verdad

B → sustraendo (bit que se resta). A B Pi Po R Decimal
Pi → préstamo de entrada (Borrow In). 0 0 0 0 0 0
Y genera dos salidas: 0 0 1 1 1 -1
0 1 0 1 1 -1
R (Differencia) → resultado de la resta. 0 1 1 1 0 -2
Po (Borrow Out) → préstamo de salida.
1 0 0 0 1 1
1 0 1 0 0 0
1 1 0 0 0 0
1 1 1 1 1 -1
Restador completo
Las Expresiones lógicas serian expresadas por:
Diferencia:
𝑅 = 𝐴 ⊕ 𝐵 ⊕ 𝑃𝑖
Préstamo de salida:
ҧ
𝑃𝑜 = 𝐴᪄ 𝐵 + 𝐴᪄ 𝑃𝑖 + 𝐵𝑃𝑖 o bien 𝑃𝑜 = 𝑃𝑖 𝐴⨀𝐵 + 𝐴𝐵

Resta (S)

𝑅
A
B
Pi FS Préstamo (Po)
 Restador Serial de 4 bits (Ripple Carry).

- P(3)
P(2)
A(3)
B(3)
P(1)
A(2)
B(2)
P(0)
A(1)
B(1)
Pi
A(0)
B(0)
R(4) R(3) R(2) R(1) R(0)

A(3..0)-B(3..0)=R(4..0)

P(1)

𝑅 𝑅 𝑅
P(0) P(2) P(3)

𝑅
Pi
A(0) A(1) A(2) A(3)
B(0) FS B(1) FS B(2) FS B(3) FS

R(0) R(1) R(2) R(3) R(4)

 Restador de 4 bits

Restador Binario basado

En un sumador 7483
Sumador-Restador de 4 Bits

Diseñar un Sumador – Restador binario considerando únicamente un sumador 7483

CC
B(3) B’(3)

B(2)
B’(2)

B(1)
B’(1)

B(0)
B’(0)

Pb
Pb
 Multiplicador
Partiendo de la multiplicación decimal:

246 246
X 35
X 35
2*5+2 4*5+3 6*5+0 1230
2*3+1 4*3+1 6*3+0 738
8 6 1 0 8610
 Multiplicador 3 x 2 bits

A(2) A(1) A(0)

X B(1) B(0)
A(2)B(0) A(1)B(0) A(0)B(0)
A(2)B(1) A(1)B(1) A(0)B(1)
M4 M3 M2 M1 M0
 Multiplicación 4 x 3

A(3) A(2) A(1) A(0)

x B(2) B(1) B(0)
A(3)B(0) A(2)B(0) A(1)B(0) A(0)B(0)
A(3)B(1) A(2)B(1) A(1)B(1) A(0)B(1)
A(3)B(2) A(2)B(2) A(1)B(2) A(0)B(2)
M6 M5 M4 M3 M2 M1 M0
Multiplicación 4 x 3
 Vhdl para operaciones aritméticas

library IEEE; library IEEE;

use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL; -- o NUMERIC_STD use IEEE.STD_LOGIC_UNSIGNED.ALL; -- o NUMERIC_STD
si prefieres tipos signed/unsigned si prefieres tipos signed/unsigned

entity sumador_4bits is entity sumador_4bits is

Port ( Port (
A : in STD_LOGIC_VECTOR(3 downto 0); A : in integer range 0 to 15;
B : in STD_LOGIC_VECTOR(3 downto 0); B : in integer range 0 to 15;
S : out STD_LOGIC_VECTOR(4 downto 0) S : out integer range 0 to 31);
); end sumador_4bits;
end sumador_4bits;
architecture Behavioral of sumador_4bits is
architecture Behavioral of sumador_4bits is begin
begin S <= A + B;
S <= ('0' & A) + ('0' & B); end Behavioral;
end Behavioral; Sumador de 4 bits
Vhdl para operaciones aritméticas

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;

entity restador_4bits is
Port (
A : in STD_LOGIC_VECTOR(3 downto 0);
B : in STD_LOGIC_VECTOR(3 downto 0);
Restador de 4 bits
R : out STD_LOGIC_VECTOR(4 downto 0)
);
end restador_4bits;

architecture Behavioral of restador_4bits is

begin
R <= ('0' & A) - ('0' & B);
end Behavioral;
Vhdl para operaciones aritméticas

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;

entity multiplicador_4bits is
Port (
A : in STD_LOGIC_VECTOR(3 downto 0);
B : in STD_LOGIC_VECTOR(3 downto 0); Multiplicador de 4 bits
P : out STD_LOGIC_VECTOR(7 downto 0)
);
end multiplicador_4bits;

architecture Behavioral of multiplicador_4bits is

begin
P <= A * B;
end Behavioral;
 Vhdl para operaciones aritméticas

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

entity divisor_simple is
Port (
A,B : in UNSIGNED(7 downto 0);
Q : out UNSIGNED(7 downto 0);
R : out UNSIGNED(7 downto 0) );
end divisor_simple;
Divisor de 8 bits
architecture Behavioral of divisor_simple is
begin
process(A, B)
begin
if B /= 0 then
Q <= A / B;
R <= A mod B;
else
Q <= (others => '0');
R <= (others => '0');
end if;
end process;
end Behavioral;
 Vhdl para operaciones aritméticas

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;

entity sumador_restador is
Port (
A : in STD_LOGIC_VECTOR(3 downto 0);
B : in STD_LOGIC_VECTOR(3 downto 0);
M : in STD_LOGIC; -- 0 = suma, 1 = resta
R : out STD_LOGIC_VECTOR(4 downto 0) Sumador–Restador controlado de 4 bits
);
end sumador_restador;

architecture Behavioral of sumador_restador is

begin
process(A, B, M)
begin
if M = '0' then
R <= ('0' & A) + ('0' & B);
else
R <= ('0' & A) - ('0' & B);
end if;
end process;
end Behavioral;
 Vhdl para operaciones aritméticas

library IEEE; architecture Behavioral of operaciones_aritmeticas is

use IEEE.STD_LOGIC_1164.ALL; signal resultado : UNSIGNED(15 downto 0) := (others => '0'); -- DIVISIÓN (entera)
use IEEE.NUMERIC_STD.ALL; signal div_err : STD_LOGIC := '0'; when "11" =>
========================================================= begin if B /= 0 then
-- Bloque aritmético configurable resultado(7 downto 0) <= A / B; -- Cociente
-- SEL = 00 → SUMA process(CLK, RST) resultado(15 downto 8) <= A mod B; -- Resto
-- SEL = 01 → RESTA begin div_err <= '0';
-- SEL = 10 → MULTIPLICACIÓN if RST = '1' then else
-- SEL = 11 → DIVISIÓN (entera) resultado <= (others => '0'); resultado <= (others => '0');
========================================================= div_err <= '0'; div_err <= '1';
end if;
entity operaciones_aritmeticas is elsif rising_edge(CLK) then
Port ( case SEL is when others =>
A : in UNSIGNED(7 downto 0); -- SUMA resultado <= (others => '0');
B : in UNSIGNED(7 downto 0); when "00" => div_err <= '0';
SEL : in STD_LOGIC_VECTOR(1 downto 0); resultado <= resize(A,16) + resize(B,16); end case;
CLK : in STD_LOGIC; div_err <= '0'; end if;
RST : in STD_LOGIC; end process;
RES : out UNSIGNED(15 downto 0); -- RESTA
DIV_ERROR : out STD_LOGIC -- '1' si se intenta dividir entre 0 when "01" => RES <= resultado;
); resultado <= resize(A,16) - resize(B,16);
end operaciones_aritmeticas; div_err <= '0'; DIV_ERROR <= div_err;

-- MULTIPLICACIÓN end Behavioral;

when "10" =>
resultado <= resize(A * B,16);
div_err <= '0';

Sumador, restador, multiplicador y divisor binario

 Función aritmética

Implementar el hardware para la siguiente función cuadrada, Considera que 𝑋 es de 2 bits y 𝑌 e Z es de 3 bits, simúlalo en Quartus

library ieee;
𝑋 2 − 12𝑌
use ieee.std_logic_1164.all;
use iee.numeric_std.all;

entity fabcd2 is
port( x: in unsigned(1 downto 0);
y: in unsigned(2 downto 0);
R: out signed(7 downto 0));
end;

Architecture bhv of fabcd2 is

signal p: std_logic_vector( 18 downto 0);
begin
R(0)<=x(0);
b0: entity [Link] port map (x(0) and x(1), x(0) and x(1), p(0),R(1));
b1: entity [Link] port map (x(1), p(0), p(1), p(2));
b2: entity [Link] port map( p(2), y(0), p(4), R(2));
b3: entity [Link] port map ('0', p(1), p(6), p(3));
b4: entity [Link] port map( p(3), y(1), p(4), p(7), p(5));
b5: entity [Link] port map( p(5), y(0), p(8), R(3));
b6: entity [Link] port map('0', p(6), p(9), p(10));
b7: entity [Link] port map( p(10), y(2), p(7), p(11), p(12));
b8: entity [Link] port map( p(12), y(1), p(18), R(4));
b9: entity [Link] port map('0', p(9), p(13), p(14));
b10: entity [Link] port map( p(14), y(2), p(11), p(15), p(16));
b11: entity [Link] port map( p(16), p(18), p(17), R(5));
b12: entity [Link] port map( p(13), p(15), p(17), R(7), R(6));
end;
 Decodificadores

Un decodificador es un circuito o dispositivo que convierte datos codificados en un formato legible o utilizable.
En electrónica digital, transforma una entrada binaria en una salida específica, activando una única línea de salida
correspondiente al código de entrada. Por ejemplo, un decodificador 2-a-4 recibe 2 bits y activa una de 4 salidas.

2𝑛
𝑛 𝑆𝑎𝑙𝑖𝑑𝑎𝑠
𝐸𝑛𝑡𝑟𝑎𝑑𝑎𝑠 𝐷𝑒𝑐𝑜𝑑𝑖𝑓𝑖𝑐𝑎𝑑𝑜𝑟
𝑛: 2𝑛

𝐻𝑎𝑏𝑖𝑙𝑖𝑡𝑎𝑐𝑖𝑜𝑛
• Decodificadores No Excitadores
• Decodificadores Excitadores
Decodificador Excitador BCD a 7 segmentos (7448, 7447)

𝐵𝐼: 𝐵𝑙𝑎𝑛𝑘𝑖𝑛𝑔 𝐼𝑛𝑝𝑢𝑡

𝑅𝐵𝑂: 𝑅𝑖𝑝𝑝𝑙𝑒 𝐵𝑙𝑎𝑛𝑘𝑖𝑛𝑔 𝑂𝑢𝑡𝑝𝑢𝑡
𝑅𝐵𝐼: 𝑅𝑖𝑝𝑝𝑙𝑒 𝐵𝑙𝑎𝑛𝑘𝑖𝑛𝑔 𝑖𝑛𝑝𝑢𝑡
𝐿𝑇: 𝑙𝑎𝑚𝑝 𝑡𝑒𝑠𝑡
Supresión de ceros MSB

Mediante la interacción
De las líneas RBO y RBI y
Una combinación en
común de un cero generado
En RBO y un cero en las
Entradas A,B,C,D. se presenta
La anulación de los displays
Mas significativos.
 Decodificadores No excitadores

Tabla de verdad de un Decodificador con salida en alta Dec 2:4, SA=1

𝑬 𝑯 𝑬 𝟏 𝑬 𝟎 𝑺𝟎 𝑺𝟏 𝑺𝟐 𝑺𝟑
1 * * 0 0 0 0 𝐸1
𝑆3
𝐷𝑒𝑐𝑜𝑑𝑖𝑓𝑖𝑐𝑎𝑑𝑜𝑟 𝑆2
0 0 0 1 0 0 0 𝐸0 𝑆1
2: 4 𝑆0
0 0 1 0 1 0 0 𝐸𝐻
0 1 0 0 0 1 0
0 1 1 0 0 0 1
𝑆0 = 𝐸𝐻 𝐸1 𝐸0
𝑆1 = 𝐸𝐻 𝐸1 𝐸0
𝑆2 = 𝐸𝐻 𝐸1 𝐸0
𝑆3 = 𝐸𝐻 𝐸1 𝐸0
 Decodificadores No Excitadores

Tabla de verdad de un Decodificador con salida en baja

𝑬 𝑯 𝑬 𝟏 𝑬 𝟎 𝑺𝟎 𝑺𝟏 𝑺𝟐 𝑺𝟑 𝑆3
𝐸1
𝑆2
1 * * 1 1 1 1 𝐸0 𝐷𝑒𝑐𝑜𝑑𝑖𝑓𝑖𝑐𝑎𝑑𝑜𝑟 𝑆1
0 0 0 0 1 1 1 2: 4
𝑆0
𝐸𝐻
0 0 1 1 0 1 1
0 1 0 1 1 0 1
0 1 1 1 1 1 0
𝑆0 = 𝐸𝐻 𝐸1 𝐸0
𝑆1 = 𝐸𝐻 𝐸1 𝐸0
𝑆2 = 𝐸𝐻 𝐸1 𝐸0
𝑆3 = 𝐸𝐻 𝐸1 𝐸0
Generación de Funciones Lógicas con Decodificadores

Si para un decodificador con salida en alta o un decodificador con salida en baja, donde cada salida es una
combinación de productos o productos negados asociados a las variables de entrada, y una función es:

𝑓 = 𝑚0 + 𝑚1 + 𝑚2 + ⋯ + 𝑚𝑛

Un decodificador puede verse como una herramienta para generar directamente los minitérminos o sus
complementos de una función lógica. Luego, con un conjunto de compuertas OR (y a veces AND, NOT,
según el caso) se pueden combinar las salidas del decodificador para construir cualquier función
booleana.
Si el decodificador es de 𝑛 entradas y 2𝑛 salidas, cada salida representa un minitérmino (una combinación
única de 0’s y 1’s de las entradas). Una función booleana puede escribirse como una suma de
minitérminos (forma SOP). Estas se conectan con compuertas OR a las salidas correspondientes a los
minitérminos que hacen la función igual a 1.
 Decodificador con salida activa en alta y Minterminos

𝑆𝑖 𝑓 𝑎𝑏𝑐 = ෍(2,3,5)
𝑆0
𝑆1
𝑎 𝐸2 𝑆2
𝑆3 𝑓 𝑎𝑏𝑐 = ෍(2,3,5)
𝑏 𝐸1
𝑆4
c 𝐸0 𝑆5
𝑆6
𝑆7
 Decodificador con salida activa en alta y Maxterminos

𝑆𝑖 𝑓 𝑎𝑏𝑐 = ෑ(0,1,4,6,7)
𝑆0
𝑆1
𝑎 𝐸2 𝑆2
𝑆3 𝑓 𝑎𝑏𝑐 = ෑ(0,1,4,6,7)
𝑏 𝐸1
𝑆4
c 𝐸0 𝑆5
𝑆6
𝑆7
 Decodificador con salida activa en baja y Minterminos

𝑆𝑖 𝑓 𝑎𝑏𝑐 = ෍(2,3,5)
𝑆0
𝑆1
𝑎 𝐸2 𝑆2
𝑆3 𝑓 𝑎𝑏𝑐 = ෍(2,3,5)
𝑏 𝐸1
𝑆4
c 𝐸0 𝑆5
𝑆6
𝑆7
 Decodificador con salida activa en baja y Maxterminos

𝑆𝑖 𝑓 𝑎𝑏𝑐 = ෑ(0,1,4,6,7)
𝑆0
𝑆1
𝑎 𝐸2 𝑆2
𝑆3 𝑓 𝑎𝑏𝑐 = ෑ(0,1,4,6,7)
𝑏 𝐸1
𝑆4
c 𝐸0 𝑆5
𝑆6
𝑆7
 Expansión de decodificadores

La expansión de decodificadores se logra cuando un decodificador por sí solo no es suficiente para cubrir
todas las salidas que se requieren, y entonces se combinan varios para aumentar el número total de salidas
disponibles.
𝑆𝑒𝑎 𝑓 𝑎𝑏𝑐𝑑 = ෑ 2,5,6,9,11,13 b 𝐸2 𝑆0
c 𝐸1
d 𝐸0

a 𝐸𝐻 𝑆7

𝐸2 𝑆8
𝐸1
𝐸0

𝐸𝐻 𝑆15
Se tiene decodificadores 3:8 con salida baja/alta
 Expansión de decodificadores

Decodificador 2:4, SA=1

𝑆0

A 𝐸1 𝑆1
𝑓(𝑎𝑏𝑐𝑑)
B 𝐸0 𝑆2

ab\cd 00 01 11 10 𝑆3
00 0 𝑐 + 𝑑ҧ
01 0 0 𝑐
11 0 0 0 𝑐+𝑑
𝑓 𝑎𝑏𝑐𝑑 = ෑ(1,4,5,11,13,14,15)
10 0 𝑐𝑑
 Expansión de decodificadores

Decodificador 2:4, SA=0

ab\cd 00 01 11 10
00 0 𝑆0
01 0 0 𝑆1
11 0 0 0 C 𝐸1
10 0 𝑆2 𝑓(𝑎𝑏𝑐𝑑)
D 𝐸0
𝑎 + 𝑏ത 𝑎ത 𝑆3
𝑎𝑏ത 𝑎ത + 𝑏ത = 𝑎𝑏

𝑓 𝑎𝑏𝑐𝑑 = ෑ(1,4,5,11,13,14,15)
 Vhdl para funciones con de decodificadores

library ieee; library ieee;

Decodificador 2:4, SA=0 use ieee.std_logic_1164.all; use ieee.std_logic_1164.all;

entity vhdl1 is entity vhdl1 is

port(abcd: in std_logic_vector (3 downto 0); port(abcd: in std_logic_vector (3 downto 0);
𝑆0 f: out std_logic); f: out std_logic);
end; end;
𝑆1
C architecture bhv of vhdl1 is architecture bhv of vhdl1 is
𝐸1
signal s: std_logic_vector(3 downto 0); signal s: std_logic_vector(3 downto 0);
𝑆2
D begin Begin
𝐸0
𝑆3 s(0)<= not(not abcd(1) and not abcd(0)); with abcd(1 downto 0) select
s(1)<= not(not abcd(1) and abcd(0)); s<= x"E" when "00" ,
s(2)<= not( abcd(1) and not abcd(0)); x"D" when "01",
s(3)<= not( abcd(1) and abcd(0)); x"B" when "10",
x"7" when others;
f<= ((s(0) or (abcd(3) or not abcd(2))) and
𝑓 𝑎𝑏𝑐𝑑 = ෑ(1,4,5,11,13,14,15) (s(1) or (abcd(3) and not abcd(2))) and f<= ((s(0) or (abcd(3) or not abcd(2))) and
(s(2) or not (abcd(3) and abcd(2))) and (s(1) or (abcd(3) and not abcd(2))) and
(s(3) or (not abcd(3)))); (s(2) or not (abcd(3) and abcd(2))) and
end; (s(3) or (not abcd(3))));
end;
 Multiplexores

Un multiplexor (MUX) es un circuito digital combinacional que selecciona una de varias entradas y la envía a la salida,
dependiendo del valor de unas líneas de control o selectores.

Definición básica:
Un MUX funciona como un “selector” controlado por señales binarias:
• Tiene 2𝑛 entradas de datos.
• Tiene 𝑛 líneas de selección.
• Tiene 1 salida.

2𝑛
𝐸𝑛𝑡𝑟𝑎𝑑𝑎𝑠 𝑀𝑢𝑙𝑡𝑖𝑝𝑙𝑒𝑥𝑜𝑟 𝑆𝑎𝑙𝑖𝑑𝑎
2𝑛 : 1

𝐻𝑎𝑏𝑖𝑙𝑖𝑡𝑎𝑐𝑖𝑜𝑛

𝑛 𝑙𝑖𝑛𝑒𝑎𝑠 𝑑𝑒 𝑠𝑒𝑙𝑒𝑐𝑐𝑖𝑜𝑛
 Multiplexores

𝑬𝑯 𝑬𝟑 𝑬𝟐 𝑬𝟏 𝑬𝟎 𝑺𝟏 𝑺𝟎 Z
4
1 * * * * * * 0 𝐸𝑛𝑡𝑟𝑎𝑑𝑎𝑠
0 * * * 𝐷0 0 0 𝐷0 𝑀𝑢𝑙𝑡𝑖𝑝𝑙𝑒𝑥𝑜𝑟 𝑆𝑎𝑙𝑖𝑑𝑎
0 * * 𝐷1 * 0 1 𝐷1 4: 1

0 * 𝐷2 * * 1 0 𝐷2
0 𝐷3 * * * 1 1 𝐷3 𝐻𝑎𝑏𝑖𝑙𝑖𝑡𝑎𝑐𝑖𝑜𝑛

2 𝑙𝑖𝑛𝑒𝑎𝑠 𝑑𝑒 𝑠𝑒𝑙𝑒𝑐𝑐𝑖𝑜𝑛

𝑍 = 𝐸𝐻 (𝑆ഥ1 𝑆0 𝐷0 + 𝑆ഥ1 𝑆0 𝐷1 + 𝑆1 𝑆0 𝐷2 + 𝑆1 𝑆0 𝐷3 )
Multiplexores (como selector).

Cte.
‘1’
Var. 𝑀𝑢𝑙𝑡𝑖𝑝𝑙𝑒𝑥𝑜𝑟 Cte. ‘1’ Var.
4: 1

𝐻𝑎𝑏𝑖𝑙𝑖𝑡𝑎𝑐𝑖𝑜𝑛

𝑆1 𝑆0
Multiplexores (como generador de funciones).

𝑆𝑒𝑎 𝑓 𝑎𝑏 = ෍(1,2,3)

0 𝐸0
1 𝐸1
1 𝐸2 Z 𝑓(𝑎𝑏)
1 𝐸3

𝑆1 𝑆0

ab

𝑀𝑢𝑙𝑡𝑖𝑝𝑙𝑒𝑥𝑜𝑟
4: 1
Multiplexores (como generador de funciones).

0 𝐸0
𝑆𝑒𝑎 𝑓 𝑎𝑏𝑐𝑑 = ෍(1,2,3,7,12,14,15)
1 𝐸1
1 𝐸2
1 𝐸3
0 𝐸4
0 𝐸5 Z 𝑓(𝑎𝑏𝑐𝑑)
𝑀𝑢𝑙𝑡𝑖𝑝𝑙𝑒𝑥𝑜𝑟 0 𝐸6
16: 1 1 𝐸7

0 𝐸10
ab
1 𝐸15
𝑆3 𝑆2 𝑆1 𝑆0

a b c d
Multiplexores (Expansión)

𝐸0
Mediante la conexión de la línea 𝐸1
𝐸2
De habilitación con el bit mas 𝐸3
significativo de la función y la 𝑀𝑢𝑙𝑡𝑖𝑝𝑙𝑒𝑥𝑜𝑟
Integración de la compuerta OR 4: 1
𝑎 𝐸𝐻
se logra la expansión de multiplexores 𝑆1 𝑆0
𝑓(𝑎𝑏𝑐)
𝑏 𝑐
𝑆1 𝑆0
𝐸4
𝐸5
𝐸6
𝐸7

𝑀𝑢𝑙𝑡𝑖𝑝𝑙𝑒𝑥𝑜𝑟
𝐸𝐻 4: 1
 Multiplexor

𝑓 𝑎𝑏𝑐𝑑 = ෍(1,2,3,6,7,9,12,13,15)

𝑑 𝑎
𝐸0 b 𝐸0
ab\cd 00 01 11 10 𝑐
00 1 1 1 𝑐+𝑑 𝑐 𝐸1 𝑏ത
𝑓(𝑎𝑏𝑐𝑑) 𝐸1 𝑓(𝑎𝑏𝑐𝑑)
01 1 1 𝑐 𝑐 𝑎
𝐸2 𝑎ത 𝐸2
𝑑
11 1 1 1 𝑐ҧ + 𝑑
𝑐 𝑎.
ത
𝑐𝑑
ҧ 𝐸3 𝐸3
10 1 𝑑 𝑆1 𝑆0 𝑏 𝑆1 𝑆0

𝑎 𝑏 c 𝑑
𝑎𝑏 𝑎ത + 𝑏
𝑎 + 𝑏ത 𝑎ത
 Multiplexor

Se desea diseñar un controlador para una maquina expendedora entrega un producto (F = 1)

Se cuenta con 4 productos todos ellos con su respectivo costo:
• Articulo A=$10
• Articulo B= $15
• Articulo C=$5
• Articulo D=$20
Esta maquina solo acepta monedas de denominación de $5 $10 y $20 las cuales no son acumulativas, esta
maquina entrega el articulo y cambio siempre y cuando sea de las denominaciones aceptadas.

Diseñar este sistema utilizando multiplexores 4:1, 8:1

 Multiplexor

ab\cde 000 001 011 010 110 111 101 100

00 1 1 1 1 1 1
01 1 1 1 1 1
11 1 1
10 1 1 1 1

Con solo multiplexores 8:1

 Multiplexores
--------------------------------------------------------------
-- MUX Genérico N:1
library IEEE; entity mux4_1 is --------------------------------------------------------------
use IEEE.STD_LOGIC_1164.ALL;
Port ( entity muxN is
use IEEE.NUMERIC_STD.ALL;
D0, D1, D2, D3 : in STD_LOGIC; generic ( N : integer := 8 );
-------------------------------------------------------------- SEL : in STD_LOGIC_VECTOR(1 downto 0); Port (
-- MUX 2:1 Y : out STD_LOGIC D : in STD_LOGIC_VECTOR(N-1 downto 0);
-------------------------------------------------------------- ); SEL : in STD_LOGIC_VECTOR(2 downto 0);
entity mux2_1 is end mux4_1; Y : out STD_LOGIC
Port ( );
A : in STD_LOGIC; architecture Behavioral of mux4_1 is end muxN;
B : in STD_LOGIC; begin
S : in STD_LOGIC; process (D0, D1, D2, D3, SEL) architecture Behavioral of muxN is
Y : out STD_LOGIC begin begin
);
case SEL is process (D, SEL)
end mux2_1;
when "00" => Y <= D0; variable index : integer;
architecture Behavioral of mux2_1 is when "01" => Y <= D1; begin
begin when "10" => Y <= D2; index := to_integer(unsigned(SEL));
process (A, B, S) when "11" => Y <= D3; if index < N then
begin when others => Y <= '0'; Y <= D(index);
if S = '0' then end case; else
Y <= A; end process; Y <= '0';
else end Behavioral; end if;
Y <= B; end process;
end if; end Behavioral;
end process;
end Behavioral;
 Memorias (Matriz básica de memoria)

Las memorias están formadas por matrices 7 6 5 4 3 2 1 0

de celdas. 0
1
En cada celda se almacena 1 bit de
2
información
3
Cada fila de esa matriz de memoria se 4
denomina palabra y representa la 5
información que puede leerse/escribirse en 6
cada acceso a la misma. 7
8
9
10
11
12
13
14
15
 Direccionamiento y capacidad de las memorias

La capacidad de una memoria es el La posición de una palabra en

número total de bits que puede una memoria se denomina
almacenar, 2𝑛 𝑥 𝑚 dirección
 Operaciones básicas de las memorias

Al tratarse de dispositivos de almacenamiento, las

memorias cuentan con dos operaciones básicas:
Escritura (write): permite almacenar una palabra
en una determinada dirección de la memoria.
Lectura (read):permite recuperar la palabra
almacenada en una determinada dirección de la
memoria.
Para la implementación de estas operaciones se
necesitan dos buses:
Bus de direcciones (address bus): para indicar la
dirección de lectura/escritura.
Bus de datos (data bus): para leer/escribir la palabra
en sí.
Clasificación de memorias semiconductoras
 Comparación de memorias volátiles y no volátiles

Densidad /
Memoria Tipo Escritura Borrado / Reprogramación Velocidad Ciclos de vida Uso típico
Costo
CD-R, DVD-R,
Alta densidad, almacenamiento
WORM (Write Once, Read Many) No volátil Una sola vez No reprogramable Rápida lectura Permanente
bajo costo legal, distribución de
software
Programable con 100 – 1,000 Baja densidad, Desarrollo y pruebas
EPROM (Erasable PROM) No volátil UV (lento) Lenta
programador ciclos costo medio de firmware
Lectura rápida,
Eléctrica, por Alta densidad, SSD, USB, firmware en
Flash No volátil Eléctrica (bloques completos) escritura 10⁴ – 10⁶
bloques/páginas barato MCUs
media
Menor Configuraciones,
Más lenta que
EEPROM No volátil Eléctrica, por bytes Eléctrica (byte a byte) 10⁵ – 10⁶ densidad, másBIOS, parámetros de
Flash
cara usuario
Muy rápida Baja densidad,
Automotriz, médico,
FeRAM No volátil Eléctrica, por bytes Muy rápida 10¹² – 10¹⁴
(tipo RAM) alto costo sistemas críticos
Ilimitados Cachés de CPU,
Baja densidad,
SRAM (Static RAM) Volátil Libre Pierde datos sin energía Muy rápida mientras haya buffers de alta
muy cara
energía velocidad
Ilimitados Muy alta Memoria principal en
Más lenta que
DRAM (Dynamic RAM) Volátil Libre Pierde datos sin energía (requiere refresco) mientras haya densidad, PC, laptops,
SRAM
energía barata servidores
FIFO Vs LIFO
FIFO Vs LIFO

Característica FIFO (First In, First Out) LIFO (Last In, First Out)
Traducción "Primero en entrar, primero en salir" "Último en entrar, primero en salir"

Una fila de personas en un banco: el primero Una pila de platos: el último que se coloca arriba es el
Analogía práctica
que llega es el primero en ser atendido. primero que se retira.
Los datos se leen en el mismo orden en que
Orden de acceso Los datos se leen en orden inverso al que se escribieron.
se escribieron.
Estructura física Cola (Queue). Pila (Stack).
Buffers de comunicación (UART, USB,
Pila de llamadas en microprocesadores, almacenamiento
Uso típico en hardware Ethernet), pipelines en procesadores, gestión
temporal de variables locales, manejo de interrupciones.
de colas de impresión.
Se suelen usar punteros de lectura (Read
Implementación en Se usa un único puntero de pila (Stack Pointer) que sube y
Pointer) y escritura (Write Pointer) que
memoria baja según inserción o extracción.
avanzan circularmente.

Mantiene el orden original de los datos (ideal Permite recuperar lo más reciente de forma inmediata
Ventaja principal
para flujos de información). (ideal para recursión y deshacer operaciones).
Acceso restringido: solo al dato más antiguo
Desventaja Acceso restringido: solo al último dato ingresado.
pendiente de salir.
 Las memorias RAM y ROM

Las dos principales categorías de memorias semiconductoras de

acceso aleatorio son:
ROM (Read-Only Memory): sólo poseen capacidad de lectura y son no
volátiles.

RAM (Random-Access Memory): poseen capacidad de lectura y escritura y

son volátiles.
Familia de memorias ROM

ROM
Read Only Memory

PROM
ROM de máscara
Programmable ROM

EPROM
Erasable PROM

UV EPROM EEPROM
Ultraviolet EPROM Electrically EPROM
 Memorias ROM

• Una ROM permite almacenar 2n datos de m bits

• No volátiles
• Se graba durante la fabricación (ROM) o en laboratorio
(EPROM, EEPROM…)

• AB[n]: Address BUS [An-1…..A0]

AB[n] DB[m]
Bus de Direcciones ROM Bus de Datos
2𝑛𝑥 𝑚
• DB[m]: Data BUS [Dm-1….D0]
Organización interna de una ROM 16x8
 ROM 23x4 (8 posiciones de 4 bits)
CS A2 A1 A0 D3 D2 D1 D0
ROM 1 - - - Hz Hz Hz Hz
23 x 4 0 0 0 0 0 0 1 1
x A2 D3 0 0 0 1 1 0 0 0
y A1 D2 0 0 1 0 1 0 1 0
z A0 D1 0 0 1 1 1 0 1 1
D0 0 1 0 0 0 1 1 1
0 1 0 1 0 1 1 1
En cada columna se realiza una función (cuando 0 1 1 0 1 1 0 0
CS=0). 0 1 1 1 0 1 0 0

D0(xyz) =  (m0, m3, m4, m5) =  (M1, M2, M6, M7)

Cuando CS no activado (cs=1), salidas en

ALTA IMPEDANCIA
Ejemplo de uso de la ROM:
Convertidor de código Binario natural a Gray
DIR B I N A G R E Y DATO
0 000 0 0 000 0
1 000 1 0 001 1
2 001 0 0 011 3
3 001 1 0 010 2
4 010 0 0 110 6
5 010 1 0 111 7
6 011 0 0 101 5
7 011 1 0 100 4
8 100 0 1 100 C
9 100 1 1 101 D
A 101 0 1 111 F
B 101 1 1 110 E
C 110 0 1 010 A
D 110 1 1 011 B
E 111 0 1 001 9
F 111 1 1 000 8
Memorias RAM

RAM (Random Access Memory):

• Lectura/escritura, volátiles
• Acceso aleatorio
2 tipos principales:
– Estáticas (SRAM) (Static RAM): mantienen el dato almacenado mientras haya
alimentación (con biestables) (más rápida).
– Dinámicas DRAM (Dynamic RAM): requieren el “refrescar” periódicamente la
información (“recargar” condensadores)(más económica).

SRAM DRAM
 Descripción de memoria RAM

Puede tener las líneas de datos unidireccionales (entradas y salidas separadas) o

bidireccionales.

Descripción de RAM 2n x m con líneas de datos bidireccionales:

Organización interna RAM (32kx8)
Expansión de memorias (ancho de palabra)
 Expansión de memorias (ancho de palabra)

Realizar una ROM 23 x 8 con dos ROM 23 x 4

CS

A2 2
2 ROM
A1 1 ROM 1
8x4 8x4
A0 0 0

3 2 1 0 3 2 1 0
ROM 8x8

D7D6D5D4 D3D2D1D0
Realizar una ROM 64kx8 con dos ROM 64kx4
Expansión de longitud de palabra en memorias RAM

CS WE OE

A2 2
A1 1 RAM 2
1 RAM
A0 0 8x4 8x4
0
3 2 1
RAM 0 3 2 1 0
8x8
D7D6D5D4 D3D2D1D0
 Expansión del ancho de palabra en memorias RAM

RAM 1Mx8 con

dos RAM 1Mx4
Expansión de número de palabras en memorias
Conseguir una ROM 24 x 4 con dos ROM 23 x 4

CS WEOE

A3
A2 2 2
A1 1 RAM
8x4 1 RAM
8x4
A0 0 0

3 2 1 0 3 2 1 0

RAM16x4

D3D2D1D0
 Expansión de número de palabras en memorias RAM

RAM 1Mx4 con

dos RAM 512K x4
 Expansión de memorias

Diseñar una memoria de 3072 localidades considerando la integración de dos memorias de 512, una de 1024 y dos de 256
mas una de 512, considera que se requiere resguardar un espacio de 128 localidades dentro de La memoria de 1024,
implementa la lógica que controle a la expansión de dicha memoria
0x000
512 𝑀 0 = 512

𝑀1 = 512 0x200
512
0x400
𝑀2 = 896
1024
𝑀2 = 128 Espacio Reservado

𝑀3 = 256 0x800
256
0x900
𝑀4 = 256
256
0xA00
𝑀5 = 512
512
0xC00
 Memorias VHDL (RAM)
library IEEE;
use IEEE.STD_LOGIC_1164.ALL; entity RAM256x8 is
use IEEE.NUMERIC_STD.ALL; Port (
clk : in std_logic;
entity RAM8x8 is we : in std_logic;
Port ( clk : in std_logic; -- Reloj addr : in unsigned(7 downto 0); -- 8 bits -> 256 direcciones
din : in std_logic_vector(7 downto 0);
we : in std_logic; -- Write Enable (1 = escribe)
dout : out std_logic_vector(7 downto 0)
addr : in unsigned(2 downto 0); -- Dirección (3 bits -> 8 posiciones)
);
din : in std_logic_vector(7 downto 0); -- Dato de entrada end RAM256x8;
dout : out std_logic_vector(7 downto 0) -- Dato de salida );
end RAM8x8; architecture Behavioral of RAM256x8 is
type ram_type is array (0 to 255) of std_logic_vector(7 downto 0);
architecture Behavioral of RAM8x8 is signal RAM : ram_type := (others => (others => '0'));
type ram_type is array (0 to 7) of std_logic_vector(7 downto 0); begin
signal RAM : ram_type := (others => (others => '0'));
begin process(clk)
process(clk) begin
if rising_edge(clk) then
begin
if we = '1' then
if rising_edge(clk) then
RAM(to_integer(addr)) <= din;
if we = '1' then end if;
RAM(to_integer(addr)) <= din; -- Escritura dout <= RAM(to_integer(addr));
end if; end if;
dout <= RAM(to_integer(addr)); -- Lectura end process;
end if;
end process; end Behavioral;
end Behavioral;
 Memorias VHDL (RAM con lectura asíncrona y escritura
síncrona)

architecture AsyncRead of RAM8x8 is

type ram_type is array (0 to 7) of std_logic_vector(7 downto 0);
signal RAM : ram_type := (others => (others => '0'));
begin

process(clk)
begin
if rising_edge(clk) then
if we = '1' then
RAM(to_integer(addr)) <= din;
end if;
end if;
end process;

dout <= RAM(to_integer(addr)); -- Lectura asíncrona

end AsyncRead;
 Memorias VHDL ROM de 256x8 bits (sintetizable con
inicialización)

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;
entity ROM256x8 is
entity ROM8x8 is Port (
Port ( addr : in unsigned(7 downto 0);
addr : in unsigned(2 downto 0); -- Dirección (3 bits -> 8 posiciones) dout : out std_logic_vector(7 downto 0)
dout : out std_logic_vector(7 downto 0) -- Dato de salida );
); end ROM256x8;
end ROM8x8;
architecture Behavioral of ROM256x8 is
architecture Behavioral of ROM8x8 is type rom_type is array (0 to 255) of std_logic_vector(7 downto 0);
type rom_type is array (0 to 7) of std_logic_vector(7 downto 0); constant ROM : rom_type := (
constant ROM : rom_type := ( 0 => x"00",
0 => "00000000", -- Dirección 0 1 => x"11",
1 => "00000001", -- Dirección 1 2 => x"22",
2 => "00000010", -- Dirección 2 3 => x"33",
3 => "00000100", -- Dirección 3 4 => x"44",
4 => "00001000", -- Dirección 4 5 => x"55",
5 => "00010000", -- Dirección 5 6 => x"66",
6 => "00100000", -- Dirección 6 7 => x"77",
7 => "01000000" -- Dirección 7 others => x"FF" -- Relleno con FF
); );
begin begin
dout <= ROM(to_integer(addr)); dout <= ROM(to_integer(addr));
end Behavioral; end Behavioral;
Memorias VHDL ROM con salida síncrona (lectura con reloj)
entity ROM8x8_sync is
Port (
clk : in std_logic;
addr : in unsigned(2 downto 0);
dout : out std_logic_vector(7 downto 0)
);
end ROM8x8_sync;

architecture Behavioral of ROM8x8_sync is

type rom_type is array (0 to 7) of std_logic_vector(7 downto 0);
constant ROM : rom_type := (
0 => "00000001",
1 => "00000010",
2 => "00000100",
3 => "00001000",
4 => "00010000",
5 => "00100000",
6 => "01000000",
7 => "10000000"
);
signal temp : std_logic_vector(7 downto 0);
begin
process(clk)
begin
if rising_edge(clk) then
temp <= ROM(to_integer(addr));
end if;
end process;
dout <= temp;
 Memorias

▪ Diseñar a partir de dos displays de 7 ▪ Realizar una calculadora para

segmentos el desplegado de un realizar cuatro operaciones de
numero de cuenta con un efecto de números enteros de 2 x 2 bits
desplazamiento.

Diseñar con memorias el desplegado de una agenda, con 1 displays matricial (5 x 8 o 8 x 8), la cual contendrá
datos compuestos de Nombre y Numero Telefónico con la posibilidad de desplazarse de izquierda a derecha y viceversa