Análisis comparativo en sumadores binarios con acarreo serie y Acarreo

Anticipado.
Alexis Calvopiña, Yautibug Daniel, Yungan Richar,
Universidad Nacional de Chimborazo
Facultada de Ingeniería en Electrónica y Telecomunicaciones.

yautibugdaniel@hotmail.com, richardth794@hotmail.com,

Abstract. - In the following report, the comparison between an añadir cualquier par de bits ha sido diseñado, que el circuito
adder with serial carry and an adder with anticipated carry is puede ser replicado N veces para crear un sumador de N bits.
presented. The main element are semi-summers and full adders for
this case we use binary sum of 8 bits, the addition or binary addition
is analogous to the decimal numbers, the difference is that in the A) El semi-sumador
binary numbers a carry is produced when the sum exceeds one while
decimal carries a carry when the sum exceeds nine. Un semi-sumador suma dos bits y genera una suma y una salida
The numbers or addends are added in parallel or in columns,
placing one number on top of the other. All numbers under the same de acarreo.
column have the same place value.

INTRODUCCIÓN

A continuación presentamos el diseño de un sumador de 8-

12 y 20 bits para visualizar la comparación entre el acarreo en
serie y el acarreo anticipado, en referencia en un sumador, la
palabra acarreo es usada de forma similar. En la mayoría de las Fig. 2 Símbolo lógico de un semi-sumador
computadoras, el acarreo del bit de mayor potencia de una
operación aritmética (o el desplazamiento del último bit, en
a) Lógica del semi-sumador.
una operación de desplazamiento) es ubicado en un bit
especial, llamado bit de acarreo, el cual podrá ser usado como
entrada de acarreo en una operación aritmética de precisión Las expresiones correspondientes a la suma y al acarreo de
múltiple. salida se pueden obtener como funciones de las entradas.
Observe que la salida de acarreo (Cout) es 1 sólo cuando A y
El acarreo reserva es, en la suma, la señal que marca el B son 1; por tanto, Cout puede expresarse como una operación
desbordamiento de la suma de dos números y que se añade AND de las variables de entrada.
como 1 al valor de su izquierda.

I. DEFINICIONES 𝑪𝒐𝒖𝒕 = 𝑨𝑩
Ecuacion (1)
1. SUMADORES
La salida correspondiente a la suma ( es 1 sólo si las
Los circuitos sumadores suman dos operandos de N bits variables A y B son distintas.
para producir un resultado de N bits y una señal de llevar a
cabo (la llevan a cabo es un '1' sólo cuando el resultado de la Por tanto, la suma puede expresarse como una operación OR-
suma requiere más de N bits). El circuito de adición básica es exclusiva de las variables de entrada
una de las piedras angulares de diseño de sistemas digitales, y
se ha utilizado en infinidad de aplicaciones desde los primeros
días de la ingeniería digital. =𝑨 ⊕𝑩

El circuito sumador simple realiza una suma casi de la Ecuacion (2)

misma manera que lo hacen los humanos, la realización de la
“derecha a izquierda” operación, poco a poco desde el LSB al
MSB. A partir de las Ecuaciones (1) y (2), se puede desarrollar la
implementación lógica del funcionamiento de un
Al centrarse en los requisitos para la adición de un solo par semisumador. La salida de acarreo se produce mediante una
de bits a partir de dos números binarios de N bits, un desafío puerta AND, siendo A y B sus dos entradas, y la salida de la
de diseño de otro modo complejo se puede dividir en un suma se obtiene mediante una puerta OR-exclusiva.
problema más tratable. Una vez que un circuito que puede
Fig. 2 Diagrama lógico de un semi-sumador

“ Recuerde que la operación OR-exclusiva se implementa con Fig. 5 Circuito lógico de un sumador completo
puertas AND, una puerta OR e inversores. “
El acarreo de salida es 1 cuando las dos entradas de la primera
puerta XOR están a 1 o cuando las dos entradas de la segunda
puerta XOR están a 1. El acarreo de salida del sumador
B) SUMADOR COMPLETO completo se obtiene por tanto del producto lógico (AND) de la
entradas A y B, y del producto lógico de A ⊕B y 𝑪𝒊𝒏 . Después
se aplica la operación OR a estos dos términos
Un sumador acepta dos bits de entrada y un acarreo de entrada,
y genera una salida de suma y un acarreo de salida

𝑪𝒐𝒖𝒕 = 𝑨𝑩 + (𝑨 ⊕ 𝑩)𝑪𝒊𝒏
Ecuacion (4)

Existen dos semi-sumadores conectados cuyos acarreos de

salida se aplican a una puerta OR, será el que normalmente
empleemos para representar un sumador completo.

Fig. 3 Símbolo lógico de un sumador completo.

a) Lógica del sumador completo.

El sumador completo tiene que sumar dos bits de entrada y un

acarreo de entrada. Del semi-sumador sabemos que la suma de
los bits de entrada A y B es la operación OR-exclusiva de esas
dos variables, A ⊕B. Para sumar el acarreo de entrada (Cin) a
los bits de entrada, hay que aplicar de nuevo la operación OR-
exclusiva, obteniéndose la siguiente ecuación para la salida de
suma del sumador completo:
Fig. 6 Dos semisumadores para formar un sumador completo
 = (𝑨 ⊕ 𝑩) ⊕ 𝑪𝒊𝒏
Ecuacion (3)

C) SUMADORES BINARIOS
EN PARALELO

Para formar un sumador binario en paralelo se conectan dos o

más sumadores completos.

Fig. 4 Lógica necesaria para realizar la suma de tres bits

Cuando se suman dos números binarios, cada columna genera
un bit de suma y un 1 ó 0, correspondiente al bit de acarreo,
Esto significa que para implementar la función del sumador que se añade a la columna inmediata de la izquierda, como se
completo se pueden utilizar dos puertas OR- exclusiva de 2 muestra a continuación con dos números de 2 bits
entradas. La primera tiene que generar el término A ⊕B, y la
segunda tiene como entradas la salida de la primera puerta
XOR y el acarreo de entrada.
Para sumar dos números binarios, se necesita un sumador El sumador de menor orden es el que realiza la suma de los
completo por cada bit que tengan los números que se quieren cuatro bits menos significativo, mientras que el sumador de
sumar. Así, para números de dos bits se necesitan dos orden superior es el que suma los cuatro bits más significativos
sumadores, para números de cuatro bits hacen falta cuatro de los dos números binarios de 8 bits.
sumadores, y así sucesivamente.

La salida de acarreo de cada sumador se conecta a la entrada

de acarreo del sumador de orden inmediatamente superior
E) Bit- Slice

Un circuito comparador de magnitud de división de bits

debe tener cinco entradas y tres salidas. Al igual que con
cualquier diseño combinativo, la tabla de verdad especifica
completamente el comportamiento requerido de la división de
bits de comparador.

Normalmente, una tabla de verdad para una función de

cinco entradas requeriría 32 filas. La tabla de verdad de 8 filas
es adecuada porque ciertas combinaciones de entrada no son
posibles (es decir, las entradas del segmento vecino son
mutuamente excluyentes), y otras son irrelevantes
Fig. 7 Diagrama de bloques de un sumador paralelo

Los bits menos significativos (LSB) de los dos números se

representan como A1 y B1. Los siguientes bits de orden superior
se representan como A2 y B2. Los tres bits de suma son 𝟏 , 𝟐 y
𝟑

El acarreo de salida del sumador completo de más a la

izquierda se convierte en el bit más significativo (MSB) en la
suma 𝟑

D) EXPANSIÓN DE
SUMADORES

Un sumador en paralelo de 4 bits se puede expandir para

realizar sumas de dos números de 8 bits, utilizando dos
Fig.9. Tabla de verdad para comparador de magnitudes de bits
sumadores de cuatro bits.
cortados.

La entrada de acarreo del sumador de menor orden (C0) se Los pares de bits resaltados y asociados lleva muestran que
conecta a tierra, ya que no existe acarreo en la posi- ción del un circuito sumador bit-slice debe procesar tres entradas (los
bit menos significativo, y la salida de acarreo del sumador de dos bits sumando y un acarreo a partir de la etapa anterior) y
menor orden se conecta a la entrada de acarreo del sumador de producir dos salidas (el bit de suma y un llevar a cabo bits).
orden superior

Fig. 8 Sumadores de 4 bits conectados en cascada que forman un

sumador de 16 bits

Este proceso se denomina conexión en cascada. Observe que,

en este caso, el acarreo de salida se designa como C8, dado
que se genera a partir del bit que se encuentra en la posición
número ocho.
 a) ACARREO ANTICIPADO

La velocidad a la que se puede efectuar una suma está limitada

por el tiempo necesario para que se propaguen los acarreos a
través de todas las etapas de un sumador paralelo. Un método
que permite acelerar el proceso de adición eliminando este
retardo del acarreo serie es la adición con acarreo anticipado.

El sumador con acarreo anticipado anticipa el acarreo de salida

de cada etapa y, en función de los bits de entrada de cada etapa,
genera el acarreo de salida bien mediante la generación de
acarreo o la propagación de acarreo.

La generación de acarreo tiene lugar cuando el sumador

completo genera internamente un acarreo de salida. Sólo
Fig.10. Casos diferentes que se pueden encontrar cuando la
adición de dos números binarios
cuando ambos bits de entrada son 1 se genera un acarreo. El
acarreo generado, Cg, se expresa como la función AND de los
2 bits de entrada, A y B.
No es posible llevar a cabo
𝑪𝒈 = 𝑨𝒄𝒂𝒓𝒓𝒆𝒐 𝑮𝒆𝒏𝒆𝒓𝒂𝒅𝒐
Entradas
𝑪𝒈 = 𝑨𝑩
Genera acarreo
Ecuacion (5)
Se propaga el arrastre hacia adelante para llevar a cabo

Un diagrama de bloques para el circuito de bit-slice se muestra La propagación de acarreo tiene lugar cuando el acarreo de
a la derecha, y se llama un sumador completo (FA). entrada se transmite como acarreo de salida. Un acarreo de
entrada puede ser propagado por el sumador completo cuando
Sumadores completos se pueden utilizar para ensamblar uno o ambos bits de entrada son igual a 1. El acarreo
circuitos que se pueden añadir cualquier número de bits. propagado, Cp, se expresa como la función OR de los bits de
entrada.
La siguiente figura muestra un circuito sumador 8 bits
𝑪𝒑 = 𝑨𝒄𝒂𝒓𝒓𝒆𝒐 𝑷𝒓𝒐𝒑𝒂𝒈𝒂𝒅𝒐
construido a partir de ocho circuitos de bits denominada
sumador completo individuales.
𝑪𝒑 = 𝑨 + 𝑩

Ecuacion (6)

Acontinuacion se ilustran las condiciones para la generación

de acarreo y la propagación de acarreo. Las tres puntas de
flecha simbolizan la propagación.

Fig. 11 Circuito sumador 8 bits

F) TIPOS DE ACARREO

Los sumadores paralelo pueden clasificarse en dos categorías

dependiendo de la forma en que se manejan los acarreos
internos de una etapa a otra.

Estas categorías son: acarreo serie y acarreo anticipado.

Fig. 12 Ilustración de las condiciones de la generación y la

propagación de acarreo.
El acarreo de salida de un sumador completo puede expresarse II. TABLA DE VALORES Y CALCULOS
en función del acarreo generado (Cg) y el acarreo propagado
(Cp). El acarreo de salida (Cout) es un 1 si el acarreo generado
es 1 O si el acarreo propagado es 1 y el acarreo de entrada (Cin) A. Figuras y tablas
es 1. I. Tabla 1
Tabla de Materiales
En otras palabras, obtenemos un acarreo de salida de 1 si el
sumador completo los genera (A = 1 AND B = 1) o si el Ítem Cant. Materiales Descripción
sumador propaga el acarreo de entrada (A = 1 OR B = 1) AND 1 2 ADC 0808 8 bits
Cin = 1. 2 2 Display 7 segmentos
3 2 Potenciómetros 10kΩ
𝑪𝒐𝒖𝒕 = 𝑪𝒈 + 𝑪𝒑 𝑪𝒊𝒏 4 2 Ruedas de Motor DC Pequeñas
5 1 Tarjeta Zybo VHDL
Ecuación (7) 6 1 Cable USB Micro USB
7 1 Cables Multiuso
Para un sumador completo, el acarreo de salida depende del
acarreo generado (Cg), el acarreo propagado (Cp) y su acarreo II. Tabla 2
Tabla de Equipos Utilizados
de entrada (Cin). Las funciones Cg y Cp para cada etapa están
disponibles de forma inmediata tan pronto como se aplican los Ítem Cant. Equipos Descripción
bits de entrada A y B y el acarreo de entrada del sumador 1 1 Oscilloscopio 2 Puntas
menos significativo (LSB), ya que sólo dependen de estos bits. 1
2 Multímetro 2 Puntas
El acarreo de entrada de cada etapa es el acarreo de salida de 2
3 Fuente de Voltaje Cables
la etapa anterior.
4 1 Computadora Vivado

III. ECUACIONES UTILIZADAS

Basándonos en el análisis, podemos desarrollar expresiones

para el acarreo de salida, Cout de cada etapa de sumador
completo.
Fig. 13 Generación de acarreo y propagación de acarreo en función
de los bits de entrada

a) Sumador completo 1 a) Sumador completo 1

𝑪𝒈𝟏 = 𝑨𝟏 𝑩𝟏 𝑪𝒐𝒖𝒕𝟏 = 𝑪𝒈𝟏 + 𝑪𝒑𝟏 𝑪𝒊𝒏𝟏

𝑪𝒑𝟏 = 𝑨𝟏 + 𝑩𝟏
b) Sumador completo 2
b) Sumador completo 2
𝑪𝒊𝒏𝟐 = 𝑪𝒐𝒖𝒕𝟏
𝑪𝒈𝟐 = 𝑨𝟐 𝑩𝟐
𝑪𝒑𝟐 = 𝑨𝟐 + 𝑩𝟐 𝑪𝒐𝒖𝒕𝟐 = 𝑪𝒈𝟐 + 𝑪𝒑𝟐 𝑪𝒊𝒏𝟐 = 𝑪𝒈𝟐 + 𝑪𝒑𝟐 𝑪𝒐𝒖𝒕𝟏
= 𝑪𝒈𝟐 + 𝑪𝒑𝟐 (𝑪𝒈𝟏 + 𝑪𝒑𝟏 𝑪𝒊𝒏𝟏
c) Sumador completo 3 = 𝑪𝒈𝟐 + 𝑪𝒑𝟐 𝑪𝒈𝟏 + 𝑪𝒑𝟐 𝑪𝒑𝟏 𝑪𝒊𝒏𝟏

𝑪𝒈𝟑 = 𝑨𝟑 𝑩𝟑 c) Sumador completo 3

𝑪𝒑𝟏 = 𝑨𝟑 + 𝑩𝟑
𝑪𝒊𝒏𝟑 = 𝑪𝒐𝒖𝒕𝟐
d) Sumador completo 4
𝑪𝒐𝒖𝒕𝟑 = 𝑪𝒈𝟑 + 𝑪𝒑𝟑 𝑪𝒊𝒏𝟑 = 𝑪𝒈𝟑 + 𝑪𝒑𝟑 𝑪𝒐𝒖𝒕𝟐
𝑪𝒈𝟒 = 𝑨𝟒 𝑩𝟒 = 𝑪𝒈𝟑 + 𝑪𝒑𝟑 (𝑪𝒈𝟐 + 𝑪𝒑𝟐 𝑪𝒑𝟏
𝑪𝒑𝟒 = 𝑨𝟒 + 𝑩𝟒 + 𝑪𝒑𝟐 𝑪𝒑𝟏 𝑪𝒊𝒏𝟏 )
= 𝑪𝒈𝟑 + 𝑪𝒑𝟑 𝑪𝒈𝟐 + 𝑪𝒑𝟑 𝑪𝒑𝟐 𝑪𝒈𝟏
+ 𝑪𝒑𝟑 𝑪𝒑𝟐 𝑪𝒑𝟏 𝑪𝒊𝒏𝟏

d) Sumador completo 4
 𝑪𝒊𝒏𝟒 = 𝑪𝒐𝒖𝒕𝟑

𝑪𝒐𝒖𝒕𝟒 = 𝑪𝒈𝟒 + 𝑪𝒑𝟒 𝑪𝒊𝒏𝟒 = 𝑪𝒈𝟒 + 𝑪𝒑𝟒 𝑪𝒐𝒖𝒕𝟑

= 𝑪𝒈𝟒 + 𝑪𝒑𝟒 (𝑪𝒈𝟑 + 𝑪𝒑𝟑 𝑪𝒑𝟐
+ 𝑪𝒑𝟑 𝑪𝒑𝟐 𝑪𝒈𝟏 + 𝑪𝒑𝟑 𝑪𝒑𝟐 𝑪𝒑𝟏 𝑪𝒊𝒏𝟏 )
= 𝑪𝒈𝟑 + 𝑪𝒑𝟑 𝑪𝒈𝟐 + 𝑪𝒑𝟑 𝑪𝒑𝟐 𝑪𝒈𝟏
+ 𝑪𝒑𝟑 𝑪𝒑𝟐 𝑪𝒑𝟏 𝑪𝒊𝒏𝟏

Fig. 15. Tipos de Acarreo

IV. DESARROLLO EXPERIMENTAL

Fig. 16. Acarreo en Serie

Fig.13 Esquemático de la entidad final

Fig. 17. Acarreo en Anticipado

Fig. 14. Esquemático general

Fig.18 Multiplexor de los Acarreos

 IV. DESARROLLO DEL CODIGO

A. [1] Elaboración del código para la implementación del

reloj

-- RELOJ DEL ADC

-------------------------------------------------------
--------------------------
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use ieee.std_logic_arith.all;
library IEEE;
Fig.19 Decodificador para Visualización en Hexadecimal use IEEE.STD_LOGIC_1164.ALL;

entity CLOC_ADC is
Port (
cloc : in STD_LOGIC;
reset : in STD_LOGIC;
clock_ADC : out STD_LOGIC);
end CLOC_ADC;

architecture Behavioral of CLOC_ADC is

signal temporal: STD_LOGIC;
signal contador: integer range 0 to 6249 := 0;
begin
divisor_frecuencia: process (reset, cloc)
begin
if (reset = '1') then
temporal <= '0';
contador <= 0;
elsif rising_edge(cloc) then
if (contador = 6249) then
temporal <= NOT(temporal);
contador <= 0;
Fig.20 Reloj Para el ADC
else

V. DESARROLLO SIMULATIVO contador <= contador+1;

end if;

end if;

end process;

clock_ADC <= temporal;

end Behavioral;

B. [2] Elaboración del código del sumador completo

library IEEE;
Fig.20 Simulación Acarreo Serie use IEEE.STD_LOGIC_1164.ALL;

entity Sumador_Completo is
Port ( a : in STD_LOGIC;
b : in STD_LOGIC;
ci : in STD_LOGIC;
co : out STD_LOGIC;
s : out STD_LOGIC);

end Sumador_Completo;

architecture Behavioral of Sumador_Completo is

begin

process (a,b,ci)
begin
s<= (a xor b) xor ci;
co<= (a and b) or ((a xor b) and ci);
Fig.21 Simulación Acarreo Anticipado end process;
 Port ( C0 : out STD_LOGIC;
end Behavioral; A0 : in STD_LOGIC_VECTOR(7 DOWNTO 0);
B0 : in STD_LOGIC_VECTOR(7 DOWNTO 0);
S0 : out STD_LOGIC_VECTOR(7 DOWNTO 0));
end component;

component Principal_Anticipado is
Port ( A : in STD_LOGIC_VECTOR(7 DOWNTO 0);
B : in STD_LOGIC_VECTOR(7 DOWNTO 0);
C. [3] Elaboración del código para el sumador de 8 bits CI : in STD_LOGIC;
CO : out STD_LOGIC;
S : out STD_LOGIC_VECTOR(7 DOWNTO 0));
-- Full adder 8b end component;
-------------------------------------------------------
------------------------- begin
library IEEE; CARR1:Acarreo_Seriee port map
use IEEE.STD_LOGIC_1164.ALL; (C0=>C1,A0=>A,B0=>B,S0=>S1);
CARR2:Principal_Anticipado port map
entity Sumador_8_Bits is (A=>A,B=>B,CI=>'0',CO=>C2,S=>S2);
Port ( A : in STD_LOGIC_VECTOR(7 DOWNTO 0);
B : in STD_LOGIC_VECTOR(7 DOWNTO 0); end Behavioral;
SE : in STD_LOGIC;
C1 : out STD_LOGIC;
C2 : out STD_LOGIC; E. [5] Elaboración del código de los tipos de Acarreo
S1 : out STD_LOGIC_VECTOR(6 DOWNTO 0);
S2 : out STD_LOGIC_VECTOR(6 DOWNTO 0); library IEEE;
S3 : out STD_LOGIC_VECTOR(6 DOWNTO 0); use IEEE.STD_LOGIC_1164.ALL;
cloc : in STD_LOGIC;
reset : in STD_LOGIC; entity Suma_Acarreo is
clock_ADC : out STD_LOGIC_VECTOR(1 downto Port ( co : out STD_LOGIC;
0) A : in STD_LOGIC_VECTOR(7 DOWNTO 0);
); B : in STD_LOGIC_VECTOR(7 DOWNTO 0);
S : out STD_LOGIC_VECTOR(7 DOWNTO 0));
end Sumador_8_Bits; end Suma_Acarreo;
architecture Behavioral of Sumador_8_Bits is architecture Behavioral of Suma_Acarreo is
---------------------------------------------------- signal sa,sb,sc,sd,se,sf,sg :STD_LOGIC;
component CLOC_ADC is
Port (
cloc : in STD_LOGIC; component Sumador_Completo is
reset : in STD_LOGIC; Port ( a : in STD_LOGIC;
clock_ADC : out STD_LOGIC); b : in STD_LOGIC;
end component CLOC_ADC; ci : in STD_LOGIC;
----------------------------------------------------- co : out STD_LOGIC;
component Acarreo_Serie_Anticipado is s : out STD_LOGIC);
Port ( A : in STD_LOGIC_VECTOR(7 DOWNTO 0); end component;
B : in STD_LOGIC_VECTOR(7 DOWNTO 0);
SE : in STD_LOGIC; begin
C1 : out STD_LOGIC; suma0:Sumador_Completo port
C2 : out STD_LOGIC; map(ci=>'0',a=>A(0),b=>B(0),s=>S(0),co=>sa);
S1 : out STD_LOGIC_VECTOR(6 DOWNTO 0); suma1:Sumador_Completo port
S2 : out STD_LOGIC_VECTOR(6 DOWNTO 0); map(ci=>sa,a=>A(1),b=>B(1),s=>S(1),co=>sb);
S3 : out STD_LOGIC_VECTOR(6 DOWNTO 0)); suma2:Sumador_Completo port
map(ci=>sb,a=>A(2),b=>B(2),s=>S(2),co=>sc);
end component; suma3:Sumador_Completo port
map(ci=>sc,a=>A(3),b=>B(3),s=>S(3),co=>sd);
begin suma4:Sumador_Completo port
Acarreo: Acarreo_Serie_Anticipado port map(ci=>sd,a=>A(4),b=>B(4),s=>S(4),co=>se);
map(A=>A,B=>B,SE=>SE,S1=>S1,S2=>S2,S3=>S3,C1=>C1,C2=>C2 suma5:Sumador_Completo port
); map(ci=>se,a=>A(5),b=>B(5),s=>S(5),co=>sf);
clck: CLOC_ADC port map suma6:Sumador_Completo port
(cloc=>cloc,reset=>reset,clock_ADC=>clock_ADC(0)); map(ci=>sf,a=>A(6),b=>B(6),s=>S(6),co=>sg);
clck_2: CLOC_ADC port map suma7:Sumador_Completo port
(cloc=>cloc,reset=>reset,clock_ADC=>clock_ADC(1)); map(ci=>sg,a=>A(7),b=>B(7),s=>S(7),co=>co);
end Behavioral;
end Behavioral;
D. [4] Elaboración del código de los tipos de Acarreo
library IEEE;
use IEEE.STD_LOGIC_1164.ALL; F. [5] Elaboración del código para el acarreo generado
entity Tipos_Acarreo is library IEEE;
Port ( A : in STD_LOGIC_VECTOR(7 DOWNTO 0); use IEEE.STD_LOGIC_1164.ALL;
B : in STD_LOGIC_VECTOR(7 DOWNTO 0);
C1 : out STD_LOGIC; entity Propa_Genera is
C2 : out STD_LOGIC; Port ( a : in STD_LOGIC;
S1 : out STD_LOGIC_VECTOR(7 DOWNTO 0); b : in STD_LOGIC;
S2 : out STD_LOGIC_VECTOR(7 DOWNTO 0)); c : in STD_LOGIC;
end Tipos_Acarreo; cg : out STD_LOGIC;
cp : out STD_LOGIC;
architecture Behavioral of Tipos_Acarreo is s : out STD_LOGIC);
end Propa_Genera;
component Acarreo_Seriee is
architecture Behavioral of Propa_Genera is H. [7] Elaboración del código Decodificador
component Propagacion_Generacion is
Port ( a : in STD_LOGIC;
b : in STD_LOGIC;
c : in STD_LOGIC;
cg : out STD_LOGIC; library IEEE;
cp : out STD_LOGIC; use IEEE.STD_LOGIC_1164.ALL;
s : out STD_LOGIC);
end component;
entity Decodificador is
begin Port ( EN1 : in STD_LOGIC_VECTOR(3 DOWNTO 0);
Suma: Propagacion_Generacion port map EN2 : in STD_LOGIC_VECTOR(3 DOWNTO 0);
(a=>a,b=>b,c=>c,cg=>cg,cp=>cp,s=>s); EN3 : in STD_LOGIC_VECTOR(3 DOWNTO 0);
SA1 : out STD_LOGIC_VECTOR(6 DOWNTO 0);
end Behavioral; SA2 : out STD_LOGIC_VECTOR(6 DOWNTO 0);
SA3 : out STD_LOGIC_VECTOR(6 DOWNTO 0));
end Decodificador;
G. [7] Elaboración del código de Acarreo Anticipado
architecture Behavioral of Decodificador is
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
component Deco_Hexa is
Port ( y0 : in STD_LOGIC;
y1 : in STD_LOGIC;
entity Acarreo_Anticipado is
y2 : in STD_LOGIC;
Port ( A : in std_logic_vector(7 downto 0);
y3 : in STD_LOGIC;
B : in std_logic_vector(7 downto 0);
S : out std_logic_vector(7 downto 0); a : out STD_LOGIC;
SSS1: out std_logic_vector(7 downto 0); b : out STD_LOGIC;
SSS2: out std_logic_vector(7 downto 0); c : out STD_LOGIC;
CC: in std_logic_vector(7 downto 0)); d : out STD_LOGIC;
e : out STD_LOGIC;
f : out STD_LOGIC;
end Acarreo_Anticipado; g : out STD_LOGIC);
architecture Behavioral of Acarreo_Anticipado is end component;

component Propa_Genera is begin

Port ( a : in STD_LOGIC; Deco1: Deco_Hexa port map(y0=>EN1(0),y1=>EN1(1),y2=>EN1(2),
b : in STD_LOGIC; y3=>EN1(3),a=>SA1(0),b=>SA1(1),c=>SA1(2),
c : in STD_LOGIC; d=>SA1(3),e=>SA1(4),f=>SA1(5),g=>SA1(6));
cg : out STD_LOGIC;
cp : out STD_LOGIC; Deco2: Deco_Hexa port map(y0=>EN2(0),y1=>EN2(1),y2=>EN2(2),
s : out STD_LOGIC); y3=>EN2(3),a=>SA2(0),b=>SA2(1),c=>SA2(2),
end component; d=>SA2(3),e=>SA2(4),f=>SA2(5),g=>SA2(6));

begin Deco3: Deco_Hexa port map(y0=>EN3(0),y1=>EN3(1),y2=>EN3(2),

SUMA0: Propa_Genera port map ( y3=>EN3(3),a=>SA3(0),b=>SA3(1),c=>SA3(2),
a=>A(0),b=>B(0),s=>S(0), d=>SA3(3),e=>SA3(4),f=>SA3(5),g=>SA3(6));
c=>CC(0),cg=>SSS1(0),cp=>SSS2(0));
end Behavioral;
SUMA1: Propa_Genera port map (
a=>A(1),b=>B(1),s=>S(1),
c=>CC(1),cg=>SSS1(1),cp=>SSS2(1)); V. DESARROLLO APLICATIVO
SUMA2: Propa_Genera port map (
a=>A(2),b=>B(2),s=>S(2),
c=>CC(2),cg=>SSS1(2),cp=>SSS2(2));

SUMA3: Propa_Genera port map (

a=>A(3),b=>B(3),s=>S(3),
c=>CC(3),cg=>SSS1(3),cp=>SSS2(3));

SUMA4: Propa_Genera port map (

a=>A(4),b=>B(4),s=>S(4),
c=>CC(4),cg=>SSS1(4),cp=>SSS2(4));

SUMA5: Propa_Genera port map (

a=>A(5),b=>B(5),s=>S(5),
c=>CC(5),cg=>SSS1(5),cp=>SSS2(5));

SUMA6: Propa_Genera port map (

a=>A(6),b=>B(6),s=>S(6),
c=>CC(6),cg=>SSS1(6),cp=>SSS2(6));

SUMA7: Propa_Genera port map (

a=>A(7),b=>B(7),s=>S(7),
c=>CC(7),cg=>SSS1(7),cp=>SSS2(7));

end Behavioral;
Fig.21 Comprobacion de la Tarjeta FPGA modelo Zybo Z7
Fig. 22 Conexión del primer ADC para el ingreso de datos ala tarjeta

Fig. 25 Alimentación de todas los circuitos

Fig. 23 Conexión del segundo ADC para el ingreso de datos ala tarjeta

Fig. 26 Comprobación de la practica

Fig. 24 Conexión de la matriz de display para visualización en

Hexadecimal

Fig. 27 Visualización máxima de la suma de 8bits en hexadecimal

 dígito de la derecha y cuando llegues a máximo dígito que
permite la base, tenemos que ponerlo a cero" y sumarle uno al
dígito que está a su izquierda.

El diseño de un sumador no fue realmente complicado, y su

implementación, lo que se llamará su construcción, tampoco lo
fue. Realmente la lógica que se ocupó para poder crear el
sistema fue muy sencilla, pero se debió de hacer de la forma
correcta. El punto realmente esencial estuvo en análisis del
problema. Decidimos, pues, de ocupar la lógica de un circuito
y de compuertas para poder resolver el problema de un
sumador binario de bit a bit, puesto que solo podían haber 2
resultados.

VII. RECOMENDACIONES
Fig. 28 Visualización de los acarreos en Serie y Anticipados
Es de notar también que, aunque no viene explícitamente en la
práctica, al hacer la tabla de verdad de un sumador binario
podemos ver la relación entre la suma como operación
aritmética binaria y el de la compuerta OR como operación
lógica, la cual une valores de señales. Para la suma binaria.

Un uno más otro uno es cero y llevamos uno de acarreo, por lo

que el resultado será 01 + 01 = 10.

VIII. REFERENCIAS

[1] G. G. Talaván., «PRÁCTICAS DE COMPUTADORES

I,» 2010. [En línea]. Available:
http://avellano.fis.usal.es/~compi/sesion4.htm. [Último
acceso: 10 Junio 2018].
[2] A. G. González, «PANAMAHITEK,» 02 Diciembre 2016.
Fig. 28 Ajuste del Osciloscopio para observar el tiempo de los Acarreos
[En línea]. Available: http://panamahitek.com/que-es-y-
como-funciona-un-sumador-completo. [Último acceso: 23
06 2018].
[3] C. Ramos, «ESTADO FINITO,» 18 Diciembre 2012. [En
línea]. Available: http://www.estadofinito.com/memoria-
ROM. [Último acceso: 20 junio 2018].

Fig. 29 Comprobación que la respuesta de los dos Acarreos son iguales

VI. CONCLUSIONES

En el presente trabajo que hemos realizado aprendimos las

diferentes formas de acarreo ya que consiste en "llevarse una"
cuando realizas una suma, esto es tanto en el sistema binario
como en cualquier otro (decimal). Vamos sumando uno al
 IX. ANEXOS

 RICHAR ARTURO YUNGAN

Fig. 28 Hoja Prerrequisito para la presentación. 
Tengo 24 años de edad, nací en la
ciudad de Riobamba el 7 de
septiembre de 1994, ingresé a la
“Escuela Superior Politécnica de
Chimborazo” en la Carrera de
Ingeniería en Mantenimiento
retirándome por situaciones
económicas. Ingrese a la
“Universidad Nacional de
Chimborazo” en la escuela de “Electrónica y
Telecomunicaciones” en la cual deseo terminar mis estudios,
esforzándome para poder cumplir mis sueños ya que mi pasión
siempre ha sido y será la Electrónica.

X. AUTORES

 DANIEL PATRICIO YAUTIBUG

Daniel Patricio Yautibug

Apugllón y soy estudiante de la
Universidad Nacional de Chimborazo
en la carrera de Electrónica y
Telecomunicaciones. mis estudios
primarios y secundarios los realicé en
el Colegio Nacional Velasco Ibarra de
la ciudad de Guamote, Actualmente estudia en la Universidad
Nacional de Chimborazo en la carrera de Ingeniería
Electrónica Y Telecomunicaciones