Mostrando entradas con la etiqueta Resúmenes. Mostrar todas las entradas

Práctica 4

PRÁCTICA 4

MEMORIA

En está práctica veremos el funcionamiento, paso a paso, de la Memoria que

se encuentra en la CPU que hemos visto en clase.

1.- Introducir una memoria RAM de 64Kx8 y realizar un circuito que permita leer y

escribir en ella. Probar a introducir en las direcciones 0023h el dato 3A y en la dirección

C120h el dato 25.

2.- Unir dos memorias del tipo utilizado en el apartado 1, para conformar una de

64Kx16. Comprobar su funcionamiento de forma similar al apartado anterior:

introduciendo algunos datos de 16 bits en varias direcciones.

3.- Unir tres memorias para como las de los apartados anteriores (64Kx8) para

conformar una de 128Kx16. Comprobar su funcionamiento de forma similar al apartado

anterior: introduciendo algunos datos de 16 bits en varias direcciones.

4.- Ampliar la memoria hasta 256Kx16 ¿Qué elemento será necesario para seleccionar

cada banco de dos memorias de 64Kx8? Un decodificador. Comprobar su

funcionamiento de forma similar al apartado anterior: introduciendo algunos datos de 16

bits en varias direcciones.

5.- Transformar la estructura del anterior punto para que los primeros 64K sean de

memoria ROM Observar que señales de control son las que intervienen en cada tipo de

memoria. Indica en cada bando la el banco de direcciones de memoria que direcciona y

obtén el mapa de memoria del conjunto.

Direcciones Componente

0 – 65535 MODULO ROM

65536 – 131071 MODULO RAM 1

131072 – 196607 MODULO RAM 2

196608 – 262143 MODULO RAM 3

Author : jmmontero.ortega Comments : 0

Posted :

Tag : Resúmenes,

Práctica 2

ALU y Camino de datos

Esquema simplificado de una ALU y camino de datos.

Requerimientos:

Para realizar esta práctica se necesita el Simulador de circuitos electrónicos digitales LOGISIM , que es de uso libre y se puede descargar desde este enlace:

http://ozark.hendrix.edu/~burch/logisim/index_es.html

El alumnado tiene un conocimiento previo del uso de este programa, pero como referencia y establecer unas bases se puede ver un tutorial desde este enlace:

http://ozark.hendrix.edu/~burch/logisim/docs/2.1.0-es/guide/tutorial/index.html

Objetivos:

1.-Realizar el diseño de un banco de registros básico de 4 registros.

2.-Realizar el diseño de una ALU sencilla de 4 operaciones.

3.-Construir un camino de datos (compuesto por el banco de registros y la ALU antes realizadas) y también tres registros independientes adicionales.

4.-Comprobar el funcionamiento de este banco de datos para una serie de operaciones elementales simples.

5.-Realizar el cronograma de algunas operaciones elementales.

Repaso a entorno LOGISIM

Como se indicó en el apartado requerimientos se hace necesario un repaso previo de dicho entorno, para el cual se puede utilizar o la web del desarrollador o el enlace al tutorial que se encuentra en este apartado.

En el repaso del entorno se manda;

a) Implementar un circuito decodificador de 2 bits binarios a base 4 (4 salidas de activación independiente).
b)Implementar un bus bidireccional y compartido de 8 bits, capaz de comunicar tres registros entre sí (Raux0, Raux1 y Raux2).Se debe utilizar un dispositivo de entrada de 8 bits para introducir los datos y un display de 2 cifras hexadecimales para visualizar los datos que circulan por el bus.

Desglosemos los apartados con ilustraciones y el correspondiente archivo de Logisim, todo en el archivo comprimido ZIP CircuitosALULogisim, para una mayar compresión. El programa necesario para descomprimir el archivo es 7zip de distribución libre que podemos descargar desde su página oficial: http://www.7-zip.org/download.html

CircuitosALULogisim_GA3 Descargar - Ver

a) Implementar un circuito decodificador de 2 bits binarios a base 4 (4 salidas de activación independiente).

El circuito correspondiente a este decodificador se llama Decodificador.circ. Se recomienda comprobar su funcionamiento en LOGISIM.

El funcionamiento de este decodificador es el siguiente, por medio de las entradas de datos D1 y D0 se ingresan dos números binarios (en cada selector) este las decodifica de binario a el número de salida correspondiente en decimal, para que se active es necesario tener a 1 el Habilitador (por eso se ve azul los cables en la imagen anterior). El bit de más peso tal y como se ve en la imagen es el D1 ya que el selector de bits que divide los bits de entradas está configurado de esa forma.

Veamos su funcionamiento:

b) Implementar un bus bidireccional y compartido de 8 bits, capaz de comunicar tres registros entre sí (Raux0, Raux1 y Raux2).Se debe utilizar un dispositivo de entrada de 8 bits para introducir los datos y un display de 2 cifras hexadecimales para visualizar los datos que circulan por el bus.

El circuito correspondiente a este decodificador se llama Registro con bus bidireccional.circ. Se recomienda comprobar su funcionamiento en LOGISIM.

El funcionamiento de este bus bidireccional y compartido de 8 bits es el siguiente,en la entrada de 8 bits se introduce un número binario de 8 bits ,estos van por el cable hasta un búffer controlado por las señales de triestado (deja pasar la información).Hay tres registros en los que se puede intercambiar la información entre ellos y el display hexadecimal que muestra en todo momento los datos que recorren el bus. Para que funcione el bus y no de error, al ser un bus bidireccional no se puede abrir dos búffer controlados a la vez ,pues se produciría un error.

La carga en los registros se produce poniendo a 1 la pestaña en (Enable)

Ejemplo de cómo cargar un dato a un registro:

Ejemplo de carga entre registros:

Inicio de la práctica

1.-Realizar el diseño de un banco de registros básico de 4 registros.

El circuito correspondiente a este decodificador se llama Registro con bus bidireccional2.circ. Se recomienda comprobar su funcionamiento en LOGISIM.

Consta del circuito del apartado b) y en la parte de arriba se le ha añadido 4 registros en los que la carga es común para todos (Carga Banco), decodificadores que actúan seleccionando los registros para habilitar o deshabilitar o transferir la información (triestado).Ambos decodificadores funciona como se expuso con anterioridad, salvo que tiene la misma entrada de selección de bits, asegurando así que los dos decodificadores trabajan a la par.

2.-Realizar el diseño de una ALU sencilla de 4 operaciones.

-SUMA -AND

-NOT A

-Desplazamiento de 1 bit a la izquierda (Desplazamiento Circular)

Después de realizar la ALU implementaremos todos los elementos en un camino de datos tal como dice el ejercicio 3.

3.-Construir un camino de datos (compuesto por el banco de registros y la ALU antes realizadas) y también tres registros independientes adicionales.

El circuito correspondiente a este decodificador se ALU.circ. Se recomienda comprobar su funcionamiento en LOGISIM.

La ALU está situada en la esquina inferior derecha y contiene un multiplexor para indicar que operación ha de realizarse y un habilitador .La salida de la operación va a un registro temporal (Registro Resul.) que se cargará con el dato del resultado de la operación lógica. Este circuito contiene otro display hexadecimal para comprobar que dato hay en el bus al producirse el resultado. El registro adicional que se ha añadido es el registro del primer operando, puesto que no puede haber dos datos en el mismo bus, este se almacena en el registro del 1º operando, y el 2º operando se coge de cualquiera de los registros restantes.

4.-Comprobar el funcionamiento de este banco de datos para una serie de operaciones elementales simples.

Se puede hacer cualquier operación que queramos entre registros que la ALU pueda soportar(negación del dato A,AND de A y B ,Desplazamiento a la izquierda o suma de A y B. Como ya hemos explicado el funcionamiento de cada parte del circuito de los Banco de registros y de la ALU, entendemos que el lector puede probar con cualquier operación en el LOGISIM.

Cargar en el registro R0 el dato 1Fh

Cargar en el registro R1 el dato 21h

Cargar en el registro R2 el dato 4Ah

Cargar en el registro R3 el dato 35h

Sumar R1 y R2 y almacenarlo en Raux0

Hacer la operación AND entre R0 y R3 y almacenarlos en Raux1

Desplazar dos veces en registro R1 y almacenarlo en el registro Raux2

Llevar R2 al acumulador y complementar su valor. El resultado almacenarlo en R0

5.-Realizar el cronograma de algunas operaciones elementales.

Señales utilizadas:

+Flanco de subida; +De nivel (triestado)

Apartados según siglas:

Reloj (CLK) el bus de datos (donde pones los datos que se están transfiriendo: operandos y resultados de operaciones) y Op(operaciones, que se indicará simbólicamente la que se realiza).

Banco de Registros:

SB(selección Banco) indica el registro con el que estamos trabajando

CB(Carga Banco) es una señal de Triestado que activa los registros para su carga

TB(Triestado Banco) es de salida de datos, según los datos que quiere que salgan del banco de registro la anchura de la señal de triestado debe ser mayor, cogiendo dos pulsos de reloj para dos datos.

Registros Temporales Ri:

C antes del registro y T son las señales de Carga y Triestado(salida) respectivamente tiene señales por flancos y T señales por niveles(triestado).Ahora dependiendo de con que registro se esta trabajando se tendrá que rellenar de una forma o de otra.

Parte de la ALU:

CA (Carga del registro Acumulador) por flancos como ya se ha dicho y carga en este registro valores inmediatos o 1º operando .La ALU no puede tener en el bus más de dos datos a la vez porque se produciría un error,con lo cual se opera desde este registro , 2º operando desde otro registro temporal(Ri).Tmp es otro registro temporal para almacenar el resultado antes de cargarlo a un registro ,ya sea del Banco de registro o aun registro más frecuentemente usado (Ri).Y para cargar en Tmp hace falta activar por flanco a Ctmp (carga de Tmp).

Ci (Carga de errores) es para controlar que no se produzca ningún error, este se realiza después de toda operación aritmética o lógica. Y por último R estado es el registro que almacena si hay un error de: C-accarreo,Z-Cero(Cuando da cero el resultado de una operación) y V-Overflow(Cuando se produce un desbordamiento).

Aclarado esto se entiende que el lector puede verificar cualquier cronograma incluso hacerlo.Aquí hay algunos ejemplos:

La primera operación que nos piden es una AND entre R0 y R3 y almacenarlos en Raux1. Aquí tenemos su cronograma.

La siguiente operación es un Desplazamiento de 2 bits a la izquierda de R1 y almacenarlo en Raux2. El cronograma quedaría de la siguiente manera:

Author : Antonio Castillo Comments : 0

Posted :

Tag : Resúmenes,

Práctica 3

PRÁCTICA 3

UNIDAD DE CONTROL

En esta práctica veremos el funcionamiento, paso a paso, de la Unidad de Control que se encuentra en la CPU que hemos visto en clase.

Primero que nada vamos a pasar a hexadecimal las instrucciones, aclarando antes algunas cuestiones.

A la hora de pasar una instrucción a hexadecimal, debemos mirar previamente qué número le corresponde a cada registro.

En el cuadro vemos que aparece el nombre del registro con su número correspondiente.
Una vez que conocemos dichos números y sabemos como es la estructura de cada instrucción (Tema 2: Programación de microprocesadores MIPS), procedemos a pasarlas a binario.
Cuando ya tenemos en binario toda la instrucción vamos separando en grupos de 4 bits y ¡LISTO para pasarlo a hexadecimal!.

a) ADD $t0, $t1, $t2

0	rs	rt	rd	0	0x20
0 0 0 0 0 0	0 1 0 0 1	0 1 0 0 1	0 1 0 0 0	0 0 0 0 0	1 0 0 0 0 0
0x012A4020

b) ADDI $s0,$s1, 0x0011

8	rs	rt	Inmediato
0 0 1 0 0 0	1 0 0 0 1	1 0 0 0 0	0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1
0x22300011

c) ORI $t0, $t2, 0x00A1

0xD	rs	rt	Inmediato
0 0 1 1 0 1	0 1 0 1 0	0 1 0 0 0	0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 1
0x354800A1

d) SLL $t0, $t0, 0x0002

0	rs	rt	rd	desp	0
0 0 0 0 0 0	0 0 0 0 0	0 1 0 0 0	0 1 0 0 1	0 0 0 1 0	0 0 0 0 0 0
0x00084880

e) SLR $t1, $t0, 0x0002

0	rs	rt	rd	desp	2
0 0 0 0 0 0	0 1 0 0 0	0 0 0 0 0	0 1 0 0 1	0 0 0 1 0	0 0 0 0 1 0
0x01004882

f) LUI $s0,0x0011

0xf	0	rt	Inmediato
0 0 1 1 1 1	0 0 0 0 0	1 0 0 0 0	0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1
0x3C100011

g) SW $t4, 0x0111

0x2b	rs	rt	offset
1 0 1 0 1 1	0 0 0 0 0	0 1 1 0 0	0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 1
0xAC0C0111

h) SLT $t1, $t2, $t0

0	rs	rt	rd	0	0x2a
0 0 0 0 0 0	0 1 0 1 0	0 1 0 0 0	0 1 0 0 1	0 0 0 0 0	1 0 1 0 1 0
0x0148482A

i) J 0x000001A

2	Dirección
0 0 0 0 1 0	0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 0
0x0800001A

j) JR $S0

0	rs	0	8
0 0 0 0 0 0	1 0 0 0 0	0 0 0 0 0 0 0 0 0 0 0 0 0 0 0	0 0 1 0 0 0
0x02000008

Una vez hecho esto, ya tenemos las instrucciones listas para introducirlas en memoria a la hora de la simulación.

A continuación, utilizando la CPU descrita en clase teórica y el lenguaje de transferencia de registro, vamos a realizar la secuencia de transferencias y acciones.

COSAS A TENER EN CUENTA ANTES DE EMPEZAR:

La ALU que se encuentra en la CPU que vamos a utilizar, tiene las siguientes operaciones con sus respectivos códigos, que deberemos tener en cuenta mas tarde a la hora de seleccionar una operación.

1 (000) Suma

2 (001) Resta

3 (010) OR

4 (011) AND

5 (100) Desplazamiento a la derecha de 1,2,3,4 bits

6 (101) Desplazamiento a la izquierda de 1,2,3,4 bits

7 (110) NOT

8 (111) XOR
En el circuito que se nos proporciona con la práctica le hemos hecho una pequeña modificación al Sumador-Restador:

Hemos conectado el acarreo de salida con la entrada de arriba del sumador. De esta forma comprobamos que el resultado es correcto.Sólo tenemos que tener tener en cuenta que cuando realicemos una resta y el primer operando sea mayor que el segundo, el resultado que nos sale para que fuese correcto habría que negarlo. En la imagen anterior vemos como al realizar la resta 8-7 el resultado es 1. Pero, ¿qué pasa si los operandos estuvieran al revés?:

Vemos como el resultado no es correcto. Significaría que es un número negativo y habría que realizar con él la operación NOT.
Las dos primeras fases son comunes a todas las instrucciones. Son la fase FETCH y la de DECODIFICACIÓN. Siempre es igual, asique solo lo escribiré una vez.

FASE FETCH

MAR ← PC

T4

C1
MBR ← MP

Td, L

C2
RI ← MBR

C6 (suponiendo que el 6 es la carga de RI, porque viene C7 al igual que la carga de RE)

DECODIFICACIÓN - - - - - -

De esta forma la instrucción queda cargada en el registro de instrucciones.

NO OS OLVIDEIS QUE SIN ESTOS PASOS NO SE EJECUTARÍA LA INSTRUCCIÓN, ASI QUE RECORDAD QUE, SIEMPRE, SE REALIZA ESTO LO PRIMERO.

¿Porqué hay dos microinstrucciones con el mismo número?

Porque no hay nada que les impida ejecutarse a la vez. Y recordemos que lo mejor es hacer todos los pasos posibles en un mismo ciclo con el fin de acelerar el proceso.

¿Porqué algunas señales las separo en dos líneas si pertenecen a la misma microinstrucción?

Porque cada línea representa un semiciclo debido a que la señal tiene un pequeño tiempo de retardo y si activásemos la carga del registro a la vez que le damos salida a una señal activando un triestado, quizás la señal que sale aún no haya llegado a este registro y lo que capture sea basurilla. Por lo tanto si una señal se activa en flanco de subida, la otra se hará en flanco de bajada. (Esto se deberá tener en cuenta en todas las instrucciones que vamos a ver a continuación).

Una vez dicho todo esto comenzamos con la secuencia de transferencia y acciones:

a) ADD $t0, $t1, $t2

$t0 ç $t1 + $t2	RA=01001($t1), RB=01010($t2), MA=0, MB=0, OP=000, RC=01000($t0), T5
	SC

b) ADDI $s0,$s1, 0x0011

RT2 ç RI(inmediato)	T8
	C10
$s0 ç $s1 + RT2	RA=10001($s1), MA=0, MB=1, OP=000, RC=10000($s0), T5
	SC

c) ORI $t0, $t2, 0x00A1

RT2 ç RI(inmediato)	T8
	C10
$t0 ç $t2 OR RT2	RA=01010($t2), MA=0, MB=1, OP=010, RC=01000($t0), T5
	SC

d) SLL $t0, $t0, 0x0002

RT2 ç RI(desp)	T8
	C10
RT3 ç $t0 SLL RT2	RA=01000($t0), MA=0, MB=1, OP=101
	C11
$t0 ç RT3	RC=01000($t0), T6
	SC

e) SRL $t1, $t0, 0x0002

RT2 ç RI(desp)	T8
	C10
RT3 ç $t0 SRL RT2	RA=01000($t0), MA=0, MB=1, OP=100
	C11
$t1 ç RT3	RC=01001($t1), T6
	SC

f) LUI $s0,0x0011

$s0 ç RI(inmediato)	T8, RC=10000($s0)
	SC

g) SW $t4, 0x0111

MAR ç RI(dir)	T8
	C1
MBR ç $t4	RA=01100($t4), T1
	C3
MP ç MBR	Td, Ta
	E

h) SLT $t1, $t2, $t0

En esta instrucción tropezamos con una pequeña dificultad, y es que nuestra ALU no tiene la operación que queremos realizar. ¿Qué hacemos?, vamos a simularla, usando las operaciones que sí tenemos.

Antes que nada debemos saber que la resta que realiza nuestra ALU es en "Complemento a2", es decir, el segundo operando lo pasa a "Ca2" y realiza una suma.
Nos interesa saber también que el bit de acarreo en el RE es el tercero empezando por la derecha, y en este caso, es el único que nos interesa estudiar, asi que para usarlo a él sólo, tendremos que desplazarlo dos bits a la derecha.
La operación SLT consiste en guardar (en este caso) en $t1:

0x00000001 si el dato de $t2 es menor que el de $t0
0x00000000 si no lo es

El bit de acarreo en este caso va a funcionar al contrario, es decir, nos dará un 0 en el caso de que el primer dato sea menor que el segundo, y un 1 en caso contrario. ¿Qué haremos entonces para conseguir el resultado real?, pues tendremos que realizar la operación NOT con dicho dato.
Después de este último paso, nos volvemos a encontrar con un pequeño problema. Imaginemos que el dato al que vamos a realizarle el NOT es ...00000001(32 bits) (queremos que ese 1, sea un 0). Después de la operación nos quedaríamos con ...11111110. Ya tenemos el 0 que queríamos, pero ahora todos los ceros originales se nos han transformado en 1. Para devolverlos a su estado natural le tendremos que restar todos esos 1, que en hexadecimal le estaríamos restando 0xfffffffe (31 bits en 1 y el último en 0). De esta forma nuestro resultado final, ya es el que buscabamos.
Sabiendo todo esto, vamos a realizar la secuencia de transferencia y acciones de la operación SLT, dividida en cuatro pasos:

h.1) SUB RT3, $t2, $t0

RT3 ç $t2-$t0 ñRE	RA=01010($t2), RB=01000($t0), MA=0, MB=0,Op=001
	C8(para actualizar RE), C11

h.2) SRL RT3, RE, 0x0002

RT1 ç RE	T7
	C9
RT2 ç RI(desp)	T8
	C10
RT3 ç RT1 SRL RT2	MA=1, MB=1, OP=100
	C11

h.3) NOT RT3, RT3

RT1 ç RT3	T6
	C9
RT3 ç NOT RT1	MA=1, MB=0, OP=110
	C11

h.4) RT3 - 0xfffffffe

RT1 ç RT3	T6
	C9
RT2 ç RI(0xfffffffe)	T8
	C10
$t1 ç RT1 - RT2	MA=1, MB=1,Op=001, RC=01001($t1), T5
	SC

Otra opción...

Añadiendo esto último al circuito nos ahorramos un par de pasos de la opción de antes, puesto que de esta forma sólo tendríamos que hacer la resta, actualizar el registro de estado y sacaríamos directamente el bit de acarreo en la posición que queremos. Lo de rellenar todo lo demás con unos es para ahorrarnos el último paso puesto que al bit que nos interesa le tenemos que realizar un NOT (ya que queremos almacenar lo contrario), y al hacerlo todos los unos se convertirán en ceros y el bit lo tendremos negado y listo para almacenar en el registro que se nos pide.

i) J 0x000001A

PC ç RI(dir)	T8
	C5

j) JR $S0

PC ç $s0	RA=10000($s0), T1
	C5

Lo útimo que tenemos que hacer en esta práctica es comprobar que todo lo anterior se ha realizado de forma correcta mediante el simulador Logisim. Se introducirá el código de instrucción en la memoria de manera que sean posible realizar todas las fases de la instrucción.

Para comenzar, abriremos con Logisim el circuito que se nos adjunta en la práctica. Y como primer paso, añadiremos las instrucciones (ya en hexadecimal) a la memoria. Para ello, pulsamos el botón derecho del ratón sobre la memoria, y le damos a "Editar contenidos...".

Se nos abrirá una ventana, ahí escribimos las instrucciones y cerramos ventana.

Antes de pasar a simular las instrucciones vamos a simular, una sola vez, la fase FETCH que como ya comenté anteriormente, se repite de igual modo en todas y cada una de ellas.

Hay que pasar de PC a MAR la dirección de la memoria principal a la que queremos acceder. Para ello activamos el triestado de PC (T4) para dar salida a la señal, y así, ésta, accede al bus interno.
Justo después activamos la carga de MAR (C1).
Una vez hemos guardado la dirección que queremos en MAR, debemos llevarla al bus de direcciones. Para ello activamos (Td) y asi la señal recorre dicho bus. A la vez activamos el modo lectura (L) en la memoria principal y la selección de memoria (sel). La memoria accede a dicha dirección, LEE el dato (instrucción) y sale al bus de datos.
Justo después activamos la carga del MBR (C2) desde el bus de datos (el C3 es para cargar desde el bus interno).
Mientras esto ocurre por un lado, por otro se está incrementado la dirección contenida en PC. La señal pasa sola al sumador al igual que el 4 que está fijo. Para hacer efectivo el incremento tan solo tenemos que cargar el resultado de la suma en PC (C4)

a) ADD $t0, $t1, $t2

Teniendo preparada en RI esta instrucción, empezariamos indicando cuáles son los registros de los que van a salir nuestros datos A y B. Para ello RA=01001 y RB=01010. El banco de registros los selecciona y saca los datos por su sitio respectivamente. Los datos llegan a la ALU y, dejando por defecto C.OP=0000, se realiza la suma de ambos. Y para almacenar el resultado de la suma debemos accionar T5, para dar salida al resultado al bus interno, indicar el registro dónde queremos guardar (RC=01000) y por último activamos la carga del banco de registros. A la vez que se almacena la suma en el banco debemos almacenar los indicadores de la operación en el registro de indicadores mediante la senal de carga C8.

b) Con esta instrucción (ADDI) nos encontramos con un problema a la hora de simular. A la hora de sacar el inmediato de RI solo tenemos un triestado que al activarlo da salida a la instrucción entera. Para solucionarlo hemos puesto unos separadores que solo sacarán los 16 últimos bits rellenando los otros 16 con ceros. Este mismo problema nos aparece con otras instucciones, algunas que necesitan sacar los mismos bits y otras como <J dir> que necesitariamos sacar de la instrucción los 26 últimos bits que se corresponen con la dirección a la que se quiere saltar. También les ocurre esto a las instrucciones de desplazamiento, que la cantidad de bits a desplazar está contenido en la instrucción, en los 5 bits contados a partir del sexto bit (empezando a contar por la derecha).

b) ADDI $s0,$s1, 0x0011

Para no tener que explicar tan detalladamente todas las instrucciones, simplemente voy a ir activando y seleccionando, tal y como he indicado en las señales del segunto apartado del trabajo y voy a ir adjuntando las capturas de dichas acciones.

c) ORI $t0, $t2, 0x00A1

d) SLL $t0, $t0, 0x0002 y e) SRL $t1, $t0, 0x0002 son los mismos pasos pero cambiando los registros que se seleccionan y el C.OP según viene en el segundo apartado del trabajo.