Check the new version here

Popular channels

Programación de un microprocesador en lenguaje C

Diagrama



DESCRIPCIÓN DE COMPONENTES Y SUS FUNCIONES

Memoria: contiene el conjunto de instrucciones a ejecutarse (programa) así como también pueden ser almacenados en la misma, datos temporales.

PC (Program Counter o Contador de Programa): registro contador que lleva la secuencia del programa. Contiene la dirección de la instrucción que esta próxima a ejecutarse. Cada vez que se ejecuta una instrucción, el PC se incrementa en uno para poder direccionar la siguiente instrucción.

MAR (Memory Address Register o Registro de Direcciones de Memoria): registro que direcciona la memoria, ya sea para leer de ella una instrucción o para leer o escribir un dato en cualquier localidad.

MBR (Memory Buffer Register o Registro Separador de Memoria): es el registro que captura toda información que sale de la memoria. En la realidad el registro MBR y el Buffer asociado pueden quedar constituidos en un solo registro bidireccional para leer o escribir en la memoria.

IR (Instruction register o registro de instrucción): es el registro que se encarga de recibir el código de operación de la instrucción que se va a ejecutar, para proceder a decodificarlo.

ID (Instruction decoder o Decodificador de instrucción): es un decodificador cuya función es decodificar el código de operación.

T (Contador de tiempo): su función es incrementarse con cada pulso de reloj para proporcionar la secuencia de señales de tiempo que realizan las microoperaciones.

TD (Time decoder o decodificador de tiempo): decodificador que proporciona salidas discretas de tiempo según el avance del contador de tiempo T.

OSC (Oscilador): genera la señal de reloj.

ALU (Arithmetic Logic Unit o unidad lógica - aritmética): en ella se llevan a cabo todas las operaciones lógicas y aritméticas que el computador será capaz de realizar.
A (Acumulador): registro que almacena (acumula) los resultados de operaciones realizadas en la ALU.

F (flags o registro de banderas): registro en el que se guarda en forma de 8 bits individuales el estado del computador después que la ALU ha realizado una operación, como por ejemplo: si existió carry, si el resultado fue cero o si el número es positivo o negativo.

B (Buffer de entrada): Buffer que permite tomar datos del exterior del computador.

C (Registro de salida): registro que se comunica con el exterior del computador y que permite enviar información hacia afuera del mismo.

Circuiteria de control: Tiene como entradas la decodificación de la instrucción qi y la decodificación del tiempo ti y produce salidas que permiten el control de todas las líneas que controlan a los dispositivos que conforman el computador.

Codigo en C

#include
#include
void main(){

int memoria[5] = {19,19,19,128,20};
int pc = 0, mar = 0, mbr = 0, ir = 0, tiempo = 0, acomulador = 0, constante = 2, control = 1, registro;

gotoxy(33,2);
printf("Computadora digital" );

// posibles lecturas y escrituras de memoria
while(control <= 1000){
control = control + 1;

// ciclo fetch o de busqueda
if(tiempo == 0){
mar = pc;
tiempo++;
}
if(tiempo == 1){
mbr = memoria[mar];
pc = pc + 1;
tiempo++;
}
if(tiempo == 2){
ir = mbr;
tiempo++;
}

// secuencia de microoperaciones
switch(ir){

// lda nn
case 0:
if(tiempo == 3){
mar = pc;
tiempo++;
}
if(tiempo == 4){
mbr = memoria[mar];
pc = pc + 1;
tiempo++;
}
if(tiempo == 5){
acomulador = mbr;
tiempo = 0;
}
break;

// lda (nn)
case 1:
if(tiempo == 3){
mar = pc;
tiempo++;
}
if(tiempo == 4){
mbr = memoria[mar];
pc = pc + 1;
tiempo++;
}
if(tiempo == 5){
mar = mbr;
tiempo++;
}
if(tiempo == 6){
mbr = memoria[mar];
tiempo++;
}
if(tiempo == 7){
acomulador = mbr;
tiempo = 0;
}
break;

// add nn
case 2:
if(tiempo == 3){
mar = pc;
tiempo++;
}
if(tiempo == 4){
mbr = memoria[mar];
pc = pc + 1;
tiempo++;
}
if(tiempo == 5){
acomulador = acomulador + mbr;
tiempo = 0;
}
break;

// add (nn)
case 3:
if(tiempo == 3){
mar = pc;
tiempo++;
}
if(tiempo == 4){
mbr = memoria[mar];
pc = pc + 1;
tiempo++;
}
if(tiempo == 5){
mar = mbr;
tiempo++;
}
if(tiempo == 6){
mbr = memoria[mar];
tiempo++;
}
if(tiempo == 7){
acomulador = acomulador + mbr;
tiempo = 0;
}
break;

// sub nn
case 4:
if(tiempo == 3){
mar = pc;
tiempo++;
}
if(tiempo == 4){
mbr = memoria[mar];
pc = pc + 1;
tiempo++;
}
if(tiempo == 5){
acomulador = acomulador - mbr;
tiempo = 0;
}
break;

// sub (nn)
case 5:
if(tiempo == 3){
mar = pc;
tiempo++;
}
if(tiempo == 4){
mbr = memoria[mar];
pc = pc + 1;
tiempo++;
}
if(tiempo == 5){
mar = mbr;
tiempo++;
}
if(tiempo == 6){
mbr = memoria[mar];
tiempo++;
}
if(tiempo == 7){
acomulador = acomulador - mbr;
tiempo = 0;
}
break;

// mul nn
case 6:
if(tiempo == 3){
mar = pc;
tiempo++;
}
if(tiempo == 4){
mbr = memoria[mar];
pc = pc + 1;
tiempo++;
}
if(tiempo == 5){
acomulador = acomulador * mbr;
tiempo = 0;
}
break;

// mul (nn)
case 7:
if(tiempo == 3){
mar = pc;
tiempo++;
}
if(tiempo == 4){
mbr = memoria[mar];
pc = pc + 1;
tiempo++;
}
if(tiempo == 5){
mar = mbr;
tiempo++;
}
if(tiempo == 6){
mbr = memoria[mar];
tiempo++;
}
if(tiempo == 7){
acomulador = acomulador * mbr;
tiempo = 0;
}
break;

// sta (nn)
case 8:
if(tiempo == 3){
mar = pc;
tiempo++;
}
if(tiempo == 4){
mbr = memoria[mar];
pc = pc + 1;
tiempo++;
}
if(tiempo == 5){
mar = mbr;
tiempo++;
}
if(tiempo == 6){
memoria[mar] = acomulador;
tiempo = 0;
}
break;

// jmp (nn)
case 9:
if(tiempo == 3)
{
mar = pc;
tiempo++;
}
if(tiempo == 4){
mbr = memoria[mar];
tiempo++;
}
if(tiempo == 5){
pc = mbr;
tiempo = 0;
}
break;

// inc a
case 10:
if(tiempo == 3){
acomulador = acomulador + 1;
tiempo = 0;
}
break;

// dec a
case 11:
if(tiempo == 3){
acomulador = acomulador - 1;
tiempo = 0;
}
break;

// mul a
case 12:
if(tiempo == 3){
acomulador = acomulador * constante;
tiempo = 0;
}
break;

// mpm a
case 13:
if(tiempo == 3){
acomulador = acomulador * acomulador;
tiempo = 0;
}
break;

// rst a
case 14:
if(tiempo == 3){
acomulador = 0;
tiempo = 0;
}
break;

// nva a
case 15:
if(tiempo == 3){
acomulador = pc;
tiempo = 0;
}
break;

// nvt a
case 16:
if(tiempo == 3){
acomulador = tiempo;
tiempo = 0;
}
break;

// mpt a
case 17:
if(tiempo == 3){
acomulador = acomulador * tiempo;
tiempo = 0;
}
break;

// mmt a
case 18:
if(tiempo == 3){
acomulador = acomulador + tiempo;
tiempo = 0;
}
break;

// in a,b
case 19:
if(tiempo == 3){
clrscr ();
gotoxy(33,2);
printf("Computadora digital" );
gotoxy(2,4);
printf("Introduce un numero: " );
scanf("%d", ®istro);
acomulador = registro;
tiempo = 0;
}
break;

// out c,a
case 20:
if(tiempo == 3){
gotoxy(2,4);
printf("El contenido del acomulador es igual a: %d", acomulador);
control = 1001;
tiempo = 0;
}
break;

// en caso de lectura irreconosible de memoria
default:
if(tiempo == 3){
acomulador = acomulador;
tiempo = 0;
}
break;

} // fin de la sentencia de control switch
} // fin cliclo while
getchar();
getchar();
}

En el siguiente link se encuentra el set de instrucciones

https://www.dropbox.com/s/29s943pcnk8i5nu/CICLO%20FETCH%20O%20DE%20BUSQUEDA.docx?dl=0

Ejemplo de programa, carga en memoria las siguientes constantes: int memoria[5] = {0,4,2,8,20}; resultado igual a 12.

Solución

1 - carga el acumulador con 4 con la microoperación 0
2 - suma al contenido del acomulador 8 con la microoperación 2
3 - muestra en pantalla el valor de 4 + 8 con la microoperación 20
0
0
0
0No comments yet