INSTITUTO TECNOLÓGICO DE MÉXICO

CAMPUS MORELIA

DEPARTAMENTO DE INGENIERÍA ELECTRÓNICA

PROCESAMIENTO EN HARDWARE
PRÁCTICA 3
MULTIPLICADOR IEEE CORTO CON UART
Docente: Dr. Arturo Méndez Patiño
Alumnos: Grace Saili Vázquez Gaspar
Mario Téllez Jiménez
No Control: 14121144
15120142

07 de Junio del 2020

1.-INTRODUCCIÓN
El multiplicador es un circuito digital que realiza la multiplicación de números. En muchas
computadoras y otros tipos de procesadores se utilizan multiplicadores en conjunto con otros
operandos en las unidades aritméticas lógicas los cuales son muy útiles en los procesos y tareas
operacionales que realizan. También se utilizan en otras partes del procesador, donde se utilizan para
calcular direcciones, índices de tablas, operadores de incremento y decremento y operaciones
similares.

El estándar define:
Formatos aritméticos: conjuntos de datos de coma flotante binarios y decimales, que
consisten en números finitos, incluidos los ceros con signo y los números desnormalizados o
subnormales, infinitos y valores especiales "no numéricos" (NaN).
Reglas de redondeo: propiedades que deben satisfacerse al redondear los números durante
las operaciones aritméticas y las conversiones.
Manejo de excepciones: indicaciones de condiciones excepcionales, tales como división
por cero, desbordamiento, etc.

Ahora bien, es necesario que se entienda el formato de los números que serán sumados, el formato es
conocido como IEEE corto.
El estándar del IEEE para aritmética en coma flotante (IEEE 754 o IEEE corto) es la norma o
estándar técnico para computación en coma flotante, establecida en 1985 por el Instituto de Ingenieros
Eléctricos y Electrónicos (IEEE). La norma abordó muchos problemas encontrados en las diversas
implementaciones de coma flotante que las hacían difíciles de usar de forma fiable y portátil. Muchas
unidades de coma flotante de hardware utilizan ahora el estándar IEEE 754.

El formato en coma flotante de simple precisión es un formato de número de computador

u ordenador que ocupa 4 bytes (32 bits) en su memoria y representa un amplio rango
dinámico de valores mediante el uso de la coma flotante.
En todo número en punto flotante se distinguen tres componentes:
 Signo: indica el signo del número (0= positivo, 1=negativo)
 Mantisa: contiene la magnitud del número (en binario puro)
 Exponente: contiene el valor de la potencia de la base (sesgado)
 La base queda implícita y es común a todos los números, la más usada es 2.
 Sea el siguiente formato de punto flotante de 32 bits (base 2, normalizado)

Figura 1.- Distribución de bits en el formato IEEE corto o de precisión simple

Este formato proporciona una precisión de 6 a 9 dígitos decimales significativos.
El proceso para realizar una multiplicación en este formato se explica a continuación:
El proceso de multiplicación tiene varios pasos:
1. El signo del resultado es igual a la o-exclusiva de los signos de los operandos.
2. La mantisa del resultado es igual al producto de las mantisas. Este producto es sin
signo.
Dado que los dos operandos están comprendidos entre 1 y 2 el resultado r será:1 ≤ r
<4
Este paso puede requerir una normalización, mediante desplazamiento a la derecha y ajuste
del exponente resultado.
3.-Si la mantisa resultado es del mismo tamaño que la de los operandos habrá que
redondear. El redondeo puede implicar la necesidad de normalización posterior.
4.-El exponente del resultado es igual a la suma de los exponentes de los operandos.
Considerando que usamos una representación sesgada del exponente, al hacer esta suma
estamos sumando dos veces el sesgo, y por tanto habrá que restar este sesgo una vez para
obtener el resultado correcto.

En el proceso de la multiplicación se pueden tener algunas complicaciones como lo son:

Overflow y Underflow
El resultado redondeado es demasiado grande o pequeño para ser representado.
Números denormales:
El uso de este tipo de números complica el proceso de multiplicación.Si el resultado del
cálculo del exponente en una multiplicación es menor que el exponente mínimo
representable, puede ocurrir que el resultado sea un número denormalizado.
En general si el exponente es menor que EXPmin, la mantisa se desplazará a la derecha hasta
que el exponente alcance EXPmin. Si toda la mantisa se ha desplazado fuera, se ha producido
un underflow.
Al usar como factores de una multiplicación números denormales, se opera como si fuesen
números normales, considerando que el exponente no se calcula de igual modo.
 Tabla 1.- Tabla de las “excepciones” del IEEE 745.

2.-OBJETIVO
Implementar un multiplicador en formato IEEE corto en VHDL para una implementación
en FPGA en el futuro.

3.-DESARROLLO
En esta práctica se lleva a cabo la implementación de un multiplicador en formato IEEE corto
con lenguaje VHDL.
Primeramente se debe obtener el signo por medio de sus leyes, si los signos de los operandos son
diferentes el signo es negativo, si son iguales es positivo.
Posteriormente se suman los exponentes y se quita el exceso si es posible (Exponente > 127).
El siguiente paso es multiplicar las mantisas y tomar los bits más significativos, verificar acarreos y
concatenar las partes que conforman dicho formato (Signo, Exponente y Mantisa) para su posterior
visualización e interpretación.
De igual forma es importante implementar condiciones donde el resultado sea cero o infinito según
los datos enviados o bits específicos, ya sea en la composición del resultado o de alguna bandera
durante el procesamiento de datos.
Primero al tener los números A y B de 32 bits, se pasa a encontrar su signo, exponente y mantisa.
Después se procede a obtener la mantisa y con esto se hace uso de dos señales para añadirle un 1 que
se omite en la representación antes del punto, y así poder realizar la multiplicación de las mantisas.
Cuando se hace la multiplicación de las mantisas se obtiene un vector de 48 bits, y se debe de verificar
que esté desnormalizado o no, si el bit más significativo es 1 quiere decir que lo está y si está hacer
la suma de una unidad al exponente. Se debe tener en cuenta los casos especiales a los que está sujeto,
como lo son los infinitos, menos infinito, cero, indeterminado. Se tuvo bastante cuidado al representar
estos ya que si existía una condición mal el resultado no es el correcto.
La última parte es la concatenación de cada parte del resultado para almacenarlo en un vector y así
obtener el resultado de 32 bits. El funcionamiento del ÚART para esta práctica es simplemente que
por el RX entra ambos números y cuando la FPGA internamente realice la multiplicación se envía el
número por el transmisor hacia el microcontrolador, y el resultado se puede apreciar la interfaz del
microcontrolador.

4.-RESULTADOS
Se obtuvieron las tablas de tiempos máximas y mínimas que son las de a continuación, solo
se pusieron pocos resultados de la tabla ya que tiene muchos valores. Se consideraron los
tiempos más altos y más bajos en el procesamiento del multiplicador.

Source Pad Destination Pad Delay

Num1<0> Resultado<0> 37.017
Num1<0> Resultado<1> 36.948
Num1<0> Resultado<2> 36.674
Num1<0> Resultado<3> 36.465
Tabla 2.- Tabla de los tiempos máximos en el procesamiento del multiplicador.

Source Pad Destination Pad Delay

Num2<31> Resultado<28> 10.114
Num2<31> Resultado<29> 9.672
Num2<31> Resultado<30> 8.713
Num2<31> Resultado<31> 8.685
Tabla 3.- Tabla de los tiempos mínimos en el procesamiento del multiplicador.

Con la implementación de la práctica en simulación obtuvimos el reporte de información en

relación a los elementos empleados en la FPGA, los cuales se muestra a continuación.

Cabe mencionar que tenía pensado implementar en físico con una FPGA Basys 2 pero al
final esta tarjeta no resultó viable debido a que aparecía un mensaje de warning en donde
decía que se estaban utilizando más del 100% de los dispositivos en la tarjeta.
Específicamente en “Number of bonded IOBs”.

Figura 2.- Simulación de algunos casos especiales.

Figura 3.- Simulación de algunos casos especiales (Continuación).

Al realizar el diseño de nuestro multiplicador se realizaron diferentes pruebas para observar

su funcionalidad en los diferentes casos que pueden presentarse. Se muestra enseguida
distintas multiplicaciones que fueron testeadas.
 Figura 4.- Números muy grandes que dan infinito positivo.

Figura 5.- Números muy grandes pero con signo contrario que dan infinito negativo.

Figura 6.- Números muy grandes pero con signo negativo que dan infinito positivo.

.
Figura 7.- Números muy grandes que dan infinito positivo.
Figura 8.- Cero por infinito da un indeterminación pero se dejó estandarizada como 7FC00000 en
el programa (Checar simulación arriba).

Figura 9.- Infinito negativo por infinito positivo.

Figura 10.- Infinito negativo por infinito negativo.

Figura 11.-Numeros muy pequeños que el resultado se redondea a cero. .

Estímulos en el Test Bench para simulación

Num1 <= x"6E22A160"; --Numeros muy grandes que dan infinito positivo
Num2 <= x"6E22A160"; --1.25829155E+28 y 1.25829155E+28
wait for 100 ns;
Num1 <= x"EE22A160"; --Números muy grandes pero con signo contrario que dan infinito negativo
Num2 <= x"6E22A160"; -- -1.25829155E+28 y 1.25829155E+28
wait for 100 ns;
Num1 <= x"EE22A160"; --Números muy grandes negativos ambos que dan un infinito positivo
Num2 <= x"EE22A160"; -- -1.25829155E+28 y -1.25829155E+28
wait for 100 ns;
Num1 <= x"6E22A160"; --Números anteriores puestos de manera contraria infinito negativo
Num2 <= x"EE22A160"; -- 1.25829155E+28 y -1.25829155E+28
wait for 100 ns;
Num1 <= x"71977617"; --Números grandes positivos, infinito positivo
Num2 <= x"53927c02"; -- 1.49999994E+30 y 1.2582914622E+12
wait for 100 ns;
Num1 <= x"00000000"; --Cero * Infinito
Num2 <= x"7F800000";
wait for 100 ns;
Num1 <= x"7F800000"; --Infinito * Infinito = Infinito
Num2 <= x"7F800000";
wait for 100 ns;
Num1 <= x"FF800000"; --Infinito negativo * Infinito Positivo
Num2 <= x"7F800000";
wait for 100 ns;
Num1 <= x"7F800000"; --Infinito positivo * Infinito negativo
Num2 <= x"FF800000";
wait for 100 ns;
Num1 <= x"FF800000"; --Infinito negativo * Infinito negativo = Infinito Positivo
Num2 <= x"FF800000";
wait for 100 ns;
Num1 <= x"7F800000"; --Infinito * Cero = Indeterminación positiva
Num2 <= x"00000000";
wait for 100 ns;
Num1 <= x"0DF3638F"; --Números muy pequeños que se redondean a cero
Num2 <= x"2BB116BA"; -- 1.49999991E-30 * 1.2582914311E-12 = 0
 5.-CÓDIGO MULTIPLICADOR IMPLEMENTADO

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

entity Multiplicador is
Port ( Num1,Num2 : in STD_LOGIC_VECTOR (31 downto 0);
Resultado : out STD_LOGIC_VECTOR (31 downto 0));
end Multiplicador;

architecture Behavioral of Multiplicador is

--Señales para el programa
signal Product: STD_LOGIC_VECTOR(47 downto 0);
signal SignoNum1: STD_LOGIC; --Señal que sirve para almacenar signo del número 1
signal SignoNum2: STD_LOGIC; --Señal que sirve para almacenar signo del número 2
signal MantNum1: STD_LOGIC_VECTOR (23 downto 0); --Señal que es para almacenar la mantisa del
numero 1
signal MantNum2: STD_LOGIC_VECTOR (23 downto 0); --Señal que es para almacenar la mantisa del
numero 2
signal MantResul: STD_LOGIC_VECTOR (22 downto 0); --Señal para la mantisa resultante de la
multiplicación
signal ExpResul: STD_LOGIC_VECTOR (8 downto 0); --Señal para el exponente del resultado de la
multiplicación
signal ExpResulF: STD_LOGIC_VECTOR (8 downto 0); --Señal auxiliar para el exponente del resultado de
la conversión
signal SignoResul: STD_LOGIC;
--Señales para Casos especiales(Excepciones)
signal ExpInfNum1: STD_LOGIC; --Señal para el exponente inf del numero 1
signal ExpInfNum2: STD_LOGIC; --Señal para el exponente inf del numero 1
signal CeroNum1: STD_LOGIC; --Señal para el cero num1
signal CeroNum2: STD_LOGIC; --Señal para el cero num2
signal ExpInfPos: STD_LOGIC;
signal ExpInfNeg: STD_LOGIC;
signal ExpInfCero: STD_LOGIC;
signal ExpInfExc: STD_LOGIC;
begin
--Conversión a formato IEEE corto y multiplicacion
--Obtención del signo
SignoNum1 <= Num1(31); --Lo que hay en el bit 31 del número 1 se pasa a la señal de signo de ese numero 1
SignoNum2 <= Num2(31); --Lo que hay en el bit 31 del número 2 se pasa a la señal de signo de ese numero 2
--Multiplicación del signo de ambos números para el signo final
SignoResul <= SignoNum1 XOR SignoNum2; --Multiplicación signos 1 y 2
--Almacenamiento de las mantisas de ambos números en las señales específicas
MantNum1 <= '0'&Num1(22 downto 0) when Num1(30 downto 23) ="00000000" else
'1'&Num1(22 downto 0);

MantNum2 <= '0'&Num2(22 downto 0) when Num2(30 downto 23)="00000000" else

'1'&Num2(22 downto 0);

--Multiplicación de las mantisas

Product <= MantNum1 * MantNum2;
--Exponente
ExpResulF <= (('0'&Num1(30 downto 23))+('0'&Num2(30 downto 23)))-127 when Product(47)='0' else
(('0'&Num1(30 downto 23))+('0'&Num2(30 downto 23)))-126;

ExpResul <= ('0'&Num1(30 downto 23))+('0'&Num2(30 downto 23));

MantResul <= Product(46 downto 24) when Product(47)='1' else

Product(45 downto 23);

--Excepciones para IEEE Corto

ExpInfNum1 <= '1' when Num1(30 downto 23) = "11111111" else '0'; --Número 1 es infinito --Si los
números son infinitos
ExpInfNum2 <= '1' when Num2(30 downto 23) = "11111111" else '0'; --Número 2 es infinito
CeroNum1 <= '1' when Num1(30 downto 23) = "00000000" else '0'; --Número 1 es cero --Si los
números son cero
CeroNum2 <= '1' when Num2(30 downto 23) = "00000000" else '0'; --Número 2 es cero
ExpInfCero <= '1' when ExpResul < 127 else '0'; --
ExpInfNeg <= '1' when SignoResul ='1' and ExpResulF(8)='1' else '0'; --Infinito Negativo --Si hay
desbordamiento de datos
ExpInfPos <= '1' when SignoResul ='0' and ExpResulF(8)='1' else '0'; --Infinito Positivo
ExpInfExc <= '1' when SignoResul = '0' and ExpResulF(7 downto 0)="11111111" else '0';
--Resultado final
Resultado <= X"FF800000" when ExpInfNeg = '1' --Infinito Negativo
else X"7F800000" when ExpInfNum1 = '1' and ExpInfNum2 = '1' ---Infinito
else X"7F800000" when (ExpInfNum1 or ExpInfNum2)='1' and (CeroNum1 or CeroNum2)/='1'
else X"7FC00000" when (ExpInfNum1 or ExpInfNum2)='1' and (CeroNum1 or CeroNum2) ='1' --
Indefinido numero cero y numero infinito
else X"7F800000" when ExpInfPos = '1' --Infinito Positivo
else X"00000000" when ExpInfCero = '1'
else X"00000000" when ExpInfExc = '1' --Exceso** Tiende a cero número muy pequeño
else X"00000000" when (CeroNum1 or CeroNum2) = '1' and (ExpInfNum1 or ExpInfNum2)/='1' --
Cuando exponente 0 y cero en parte fraccionario
else SignoResul&ExpResulF(7 downto 0)&MantResul;

end Behavioral;
 CÓDIGO IMPLEMENTACIÓN
library IEEE;

use IEEE.STD_LOGIC_1164.ALL;

use IEEE.NUMERIC_STD.ALL;

--Este bloque recibe los datos provenientes del microcontrolador mediante una máquina de estados.

entity Receiver is

Port ( clock : in STD_LOGIC; --Reloj de

25MHz

rxd : in STD_LOGIC; --Bit de entrada UART

n : in STD_LOGIC;

rx_byte : out STD_LOGIC_VECTOR (31 downto 0);

rx_byte2 : out STD_LOGIC_VECTOR (31 downto 0)); --Salida del byte recibido

end Receiver;

architecture Behavioral of Receiver is

constant bit_time: integer:= 217; --Valor 2600

type estados is (mark,start,delay,clean,stop,bytes); --Definición de los estados

signal state: estados:= mark; --Asociación de la

variable

signal RX_Data_1: std_logic :='0'; --Almacena Bit muestreo

signal RX_Data: std_logic :='0'; --Almacena Bit de Data_1

signal baud_count:integer range 0 to bit_time:=0;--Para contar hasta 2600

signal RX_count: integer range 0 to 7:= 0; --8 bits

signal rxbuff: std_logic_vector(7 downto 0):= (others =>'0'); --Buffer en donde se

almacenan los byte recibidos

signal bandera : integer range 0 to 4:=0;

signal rx_byte1: std_logic_vector(31 downto 0):=(others=>'0');

signal rx_byte_2: std_logic_vector(31 downto 0):=(others=>'0');

library IEEE;

use IEEE.STD_LOGIC_1164.ALL;

use IEEE.NUMERIC_STD.ALL;

--Este bloque recibe los datos provenientes del microcontrolador mediante una máquina de estados.

entity Receiver is

Port ( clock : in STD_LOGIC; --Reloj de

25MHz

rxd : in STD_LOGIC; --Bit de entrada UART

n : in STD_LOGIC;

rx_byte : out STD_LOGIC_VECTOR (31 downto 0);

rx_byte2 : out STD_LOGIC_VECTOR (31 downto 0)); --Salida del byte recibido

end Receiver;

architecture Behavioral of Receiver is

constant bit_time: integer:= 217; --Valor 2600

type estados is (mark,start,delay,clean,stop,bytes); --Definición de los estados

signal state: estados:= mark; --Asociación de la

variable

signal RX_Data_1: std_logic :='0'; --Almacena Bit muestreo

signal RX_Data: std_logic :='0'; --Almacena Bit de Data_1

signal baud_count:integer range 0 to bit_time:=0;--Para contar hasta 2600

signal RX_count: integer range 0 to 7:= 0; --8 bits

signal rxbuff: std_logic_vector(7 downto 0):= (others =>'0'); --Buffer en donde se

almacenan los byte recibidos

signal bandera : integer range 0 to 4:=0;

signal rx_byte1: std_logic_vector(31 downto 0):=(others=>'0');

signal rx_byte_2: std_logic_vector(31 downto 0):=(others=>'0');

begin

Muestreo:process(clock)

begin

if rising_edge(clock) then

RX_Data_1 <= rxd;

RX_Data <= RX_Data_1;

end if;

end process;

UART_RX:process(clock) --Inicio de proceso de máquina de estados RX

begin

if rising_edge(clock) then

case state is

when mark => --Este estado nos ayuda a la identificación del bit de inicio

--rx_byte <= "00000000";

state <= mark;

baud_count <= 0;

RX_count <=0;

--Condición para pasar al siguiente estado de inicio de bit

if(RX_Data= '1') then

state <= mark;

else

state <= start;

end if;

when start =>

if(baud_count = bit_time/2) then --Si es menor el contador de

baudios a la mitad de el total
en constante

if (RX_Data= '0') then

baud_count <= 0;

state <= delay; --Pasa al estado delay que es el que toma los
datos recibidos
else

state <= mark;

end if;

else

baud_count <= baud_count+1; --Se le añade un 1 al contador de

baudios y se mantiene en este estado

state <= start;

end if;

when delay => --Estado para capturar los 8 bits de datos del
paquete

if(baud_count < bit_time ) then

baud_count <= baud_count+1;

state <= delay;

else

baud_count <= 0;

rxbuff(RX_count)<=RX_Data; --Realmente el RX_Count es un

contador y RX data se le pasa al contador valor inicial de 0

if(RX_count < 7) then

RX_count <= RX_count+1;

state <= delay;

else

RX_count <= 0;

--bandera <=bandera+1;

state <= stop;

end if;

end if;
when stop =>

if(baud_count < bit_time) then

baud_count <= baud_count+1;

state <= stop;

--rx_byte <= rxbuff;

else

baud_count <= 0;

state <= clean;

end if;

when clean =>

if n='0' then

if(bandera <4) then

rx_byte1(7 downto 0) <= rx_byte1(15 downto 8);

rx_byte1(15 downto 8)<= rx_byte1(23 downto 16);

rx_byte1(23 downto 16)<= rx_byte1(31 downto 24);

rx_byte1(31 downto 24)<= rxbuff;

bandera <=bandera+1;

state <= start;

else

rx_byte <= rx_byte1;

state <= start;

end if;
elsif n='1' then

if(bandera <4) then

rx_byte_2(7 downto 0) <= rx_byte_2(15 downto 8);

rx_byte_2(15 downto 8)<= rx_byte_2(23 downto 16);

rx_byte_2(23 downto 16)<= rx_byte_2(31 downto 24);

rx_byte_2(31 downto 24)<= rxbuff;

bandera <=bandera+1;

state <= start;

else

rx_byte2 <= rx_byte_2;

state <= start;

end if;

end if;

when others =>

state <= mark;

end case;

end if;

end process;

end Behavioral;
Figura 12.- Simulación de Multiplicador con comunicación. .
 6.-CODIGO MICROCONTROLADOR
#include <msp430fr6989.h>
int rx,tx; //Variables donde se almacena TX y RX
int dato;
int cont=0,conttx=0;
void enviar(char dato);
int main(void)
{
WDTCTL = WDTPW | WDTHOLD; // stop watchdog timer
PM5CTL0 &= ~LOCKLPM5;
FRCTL0=FRCTLPW;
CSCTL0 = 0xA500; //Abre candado
CSCTL1 = 0x0040; //Configuración del Reloj General del microcontrolador a 1MHz
CSCTL2 = 0x0033;
CSCTL3 = 0x0000;
CSCTL0_H =0x00; //Cierra Candado*/
//Configuración UART1
UCA1CTLW0=0x00C1;
//ParOff/ParNo/TxLSB/8bits/StopNo/UARTMode/Asynch/SMCLK/CharacterErrNo/IntCherrNo/SleepNo/KeyOpen
UCA1BRW=6; //Baudios selección. *Ver Tabla de Velocidades (USER GUIDE) 9600
BAUDIOS ACTUALMENTE
UCA1MCTLW=0x2081;
UCA1CTLW0&=~1; //Se cierra candado de configuración
UCA1IE=1; //Bandera de interrupción habilitada
P3DIR = 0x08; //Se configura para que sea función UART
P3SEL1 = 0x08; //Configuración para UART en pines
P3SEL0 = 0x30; //Configuración para UART en pines
P3OUT = 0x20; //Configuración para UART en pines
P3REN = 0x20; //Configuración para UART en pines

__enable_interrupt(); //Habilitador global de interrupciones, nunca olvidar.

for(;;){ //Ciclo for infinito para evitar que ingrese el programa a otro
código distinto al del
//Programa actual
}}
//Vector de interrupciones del UART 1
#pragma vector = USCI_A1_VECTOR
__interrupt void UART_ISR(void)
{
UCA1IFG=0; //Limpia la bandera de interrupciones

if(cont < 3){

rx=UCA1RXBUF; //Pasa a la variable rx lo que tiene el registro de recepción
cont++;
}
if(conttx<3){
while (UCA1STATW & 1); //Espera a que se desocupe el bus
UCA1TXBUF=tx; //Pasa lo que tiene el registro de recepción a una variable tx
conttx++
}
}
7.-CONCLUSIONES
Se logró implementar la práctica anterior de comunicación UART en el entorno del código
del microcontrolador, esto nos ayuda a no tener que conectar muchos cables al dispositivo a
fin de hacer la multiplicación de esa manera y por medio del microcontrolador poder
controlar la introducción de los dos números que se requieren, el resultado se puede ver
reflejado en la misma interfaz del microcontrolador, sin embargo si se presentaron algunos
problemas a la hora de la implementación del programa, ya que como no se pudo probar en
físico debido a problemas con la tarjeta FPGA Basys 2 se tuvo que implementar y simular.
Se usaron registros de corrimiento para el almacenaje de los bytes que se simulaba iba
“enviando” el microcontrolador y así tener vectores correctos con los números que se envían
desde el microcontrolador. Con la finalización de la práctica quedo muy en claro las ventajas
que tiene la utilización de este tipo de multiplicación, ya que sirve para multiplicaciones de
números muy grandes pero como todo, se obtiene algo pero se pierde otra cosa, se obtiene la
multiplicación pero se pierde precisión. Hay que tener en cuenta los casos especiales de esta
representación de datos, ya que si no se toman en cuenta pueden dar lugar a que la
multiplicación arroje resultados erróneos, los casos como Under y Over flows, redondeos,
infinitos positivos y negativos, hasta la cuestión del cero.

Sin embargo es un método muy usado para la representación de información digital en

computadores, es bastante interesante el tema, no descarto seguir estudiando esta área.
VÁZQUEZ GASPAR GRACE SAILI - 14121144

Logramos concluir la gran importancia de intercomunicar dispositivos y las distintas

características que pueden poseer distintos compiladores, esto lo logramos interpretar y
darnos cuenta mediante la obtención de resultados ya que en realización al compilador ciertas
operaciones se obtenían resultados diferentes, por lo cual tuvimos que tener especial cuidado
en esas operaciones ya sea de números muy grandes o números muy pequeños para obtener
los resultados deseados, de esta forma empelamos distintos métodos que nos permitieron una
correcta implementación con el uso de banderas o estados que nos permitían detectar cuando
ocurrían ciertas operaciones lo cual significaba que podíamos estar trabajando en los límites
de operación en relación al formato que empleamos de operación, cabe resaltar la importancia
de implementación y la dificultad en relación a las consideraciones que se deben de tener con
los overflows, underflows, acarreos, bits de mayor peso, banderas de operación, exponentes
y signos.

TÉLLEZ JIMÉNEZ MARIO - 15120142

7.-CÓNEXIONES Y MANERA DE PROBARLO

NET "clock" LOC="B8";

NET "rxd" LOC="T12";
NET "TX_out" LOC="B12";
NET "TX_Active" LOC="J14";

Simplemente lo que se realiza es hacer las conexiones de

esas patas de la FPGA NEXYS 2 a las del
microcontrolador MSP430FR6989 las cuales están
marcadas como RX y TX de la parte del
microcontrolador. (Vea imagen abajo).
 Figura 13- MSP430FR6989 Con indicativo de donde se conecta RX y TX.

También se conecta una línea de GND de ambos

dispositivos. El programa generado .bit se carga con el
programa Adept o directamente desde el entorno de
Xilinx y el programa del microcontrolador también se
carga desde el programa CODE COMPOSER
STUDIO y se corre en carrera libre, el primer número
se carga desde la ventana de Expresiones y cuando se
quiera cargar el segundo número simplemente se pone
en alto el botón J14

La multiplicación se verá reflejada en el resultado del

programa CODE COMPOSER STUDIO.