Diseño
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.
Problema
Diseñar una computador digital el cual manipule 3 bit de entrada y 3 bit de salida y así mismo que ejecute la secuencia de microoperaciones que se encuentran en el documento que se encuentra en el link de descarga
Código Arduino
// CURSO DE ARDUINO
// DISEÑO DE UN COMPUTADOR DIGITAL
// ING. EN ELECTRONICA
// ING. VICTOR ALFONSO TANORI RUIZ
// [email protected]
// FECHA DE DESARROLLO: 13 DE MAYO DEL 2015
// DECLARACION DE COMPONENTES + RELOJ + CONSTANTES + VARIABLES DE LECTURAS DEL EXTERIOR + ANALIZADOR
int mar = 0, pc = 0, mbr = 0, ir = 0, tiempo = 0, acomulador , constante = 2, analizador = analizador;
// DECLARACION DE LA LECTURA DE DATOS DEL EXTERIOR
bool lecturauno = LOW, lecturados = LOW, lecturatres = LOW;
// DECLARACION DE MEMORIA DE PROGRAMACION RAM (MEMORIA DE ACCESO ALEATORIO)
// OJO LAS LECTURAS DE MEMORIA SE INICIALIZAN EN CERO ES DECIR SI SE CREA UNA MEMORIA DE [ 5 ] TENEMOS POSICIONES DE 0 - 4 MAS NO DE 1 - 5 MUCHO MENOS DE 0 -5
int memoria[ 5 ] = {0,1,3,2,19};
void setup() {
// DECLARACION DE ENTRADAS Y SALIDAS
pinMode(13, OUTPUT);
pinMode(12, OUTPUT);
pinMode(11, OUTPUT);
pinMode(7, INPUT);
pinMode(6, INPUT);
pinMode(5, INPUT);
}
// EL CICLO LOOP SE EJECUTA INDEFINIDAMENTE
void loop() {
// 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){
// CARGA EL ACOMULADOR CON EL DATO QUE ESTA INMEDIATAMENTE DESPUES AL CODIGO DE OPERACION. INTRUCCION LDA nn = 0
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;
// CARGA EL ACOMULADOR CON EL DATO QUE ESTA EN LA DIRECCION DADA POR nn. INSTRUCCION LDA(nn) = 1
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;
// SUMA AL CONTENIDO DEL ACOMULADOR EL DATO QUE ESTA INMEDIATAMENTE DESPUES AL CODIGO DE OPERACIÓN Y GUARDA EL RESULTADO EN EL ACOMULADOR. INSTRUCCION ADD nn = 2
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;
// SUMA AL CONTENIDO DEL ACOMULADOR EL DATO QUE ESTA EN LA DIRECCION DE MEMORIA DADA POR nn Y GUARDA EL RESULTADO EN EL ACOMULADOR. INTRUCCION ADD(nn) = 3
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;
// RESTA AL CONTENIDO DEL ACOMULADOR EL DATO QUE ESTA INMEDIATAMENTE DESPUES AL CODIGO DE OPERACIÓN Y GUARDA EL RESULTADO EN EL ACOMULADOR. INTRUCCION SUB nn = 4
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;
// RESTA AL CONTENIDO DEL ACOMULADOR EL DATO QUE ESTA EN LA DIRECCION DE MEMORIA DADA POR nn Y GUARDA EL RESULTADO EN EL ACOMULADOR. INSTRUCCION SUB(nn) = 5
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;
// MULTIPLICA AL CONTENIDO DEL ACOMULADOR EL DATO QUE ESTA INMEDIATAMENTE DESPUES AL CODIGO DE OPERACIÓN Y GUARDA EL RESULTADO EN EL ACOMULADOR. INSTRUCCION MUL nn = 6
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;
// MULTIPLICA AL CONTENIDO DEL ACOMULADOR EL DATO QUE ESTA EN LA DIRECCION DE MEMORIA DADA POR nn Y GUARDA EL RESULTADO EN EL ACOMULADOR. INSTRUCCION MUL(nn) = 7
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;
// ALMACENA EL CONTENIDO DEL ACOMULADOR EN LA MEMORIA EN LA DIRECCION DADA POR nn. INSTRUCCION STA(nn) = 8
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;
// EL PROGRAMA REALIZA UN SALTO PARA SEGUIRSE EJECUTANDO EN LA INSTRUCCIÓN QUE ESTA DADA POR nn. INSTRUCCION JMP(nn) = 9
case 9:
if(tiempo == 3)
{
mar = pc;
tiempo++;
}
if(tiempo == 4){
mbr = memoria[mar];
tiempo++;
}
if(tiempo == 5){
pc = mbr;
tiempo = 0;
}
break;
// EL CONTENIDO DEL ACOMULADOR SE INCREMENTA EN UNA UNIDAD. INSTRUCCION INC A = 10
case 10:
if(tiempo == 3){
acomulador = acomulador + 1;
tiempo = 0;
}
break;
// EL CONTENIDO DEL ACOMULADOR SE DECREMENTA EN UNA UNIDAD. INSTRUCCION DEC A = 11
case 11:
if(tiempo == 3){
acomulador = acomulador - 1;
tiempo = 0;
}
break;
// EL CONTENIDO DEL ACOMULADOR SE MULTIPLICA POR 2 UNIDADES. INSTRUCCION MUL A = 12
case 12:
if(tiempo == 3){
acomulador = acomulador * constante;
tiempo = 0;
}
break;
// EL CONTENIDO DEL ACOMULADOR SE MULTIPLICA POR SI MISMO. INSTRUCCION MPM A = 13
case 13:
if(tiempo == 3){
acomulador = acomulador * acomulador;
tiempo = 0;
}
break;
// EL CONTENIDO DEL ACOMULADOR ES IGUAL A CERO. INSTRUCCION RST A = 14
case 14:
if(tiempo == 3){
acomulador = 0;
tiempo = 0;
}
break;
// EL ACOMULADOR TOMA EL VALOR DEL CONTADOR DE PROGRAMA (PC). INSTRUCCION NVA A = 15
case 15:
if(tiempo == 3){
acomulador = pc;
tiempo = 0;
}
break;
// EL ACOMULADOR TOMA EL VALOR DEL TIEMPO (T). INSTRUCCION NVT A = 16
case 16:
if(tiempo == 3){
acomulador = tiempo;
tiempo = 0;
}
break;
// EL CONTENIDO DEL ACOMULADOR SE MULTIPLICA POR EL CONTENIDO DEL TIEMPO. INSTRUCCION MPT A = 17
case 17:
if(tiempo == 3){
acomulador = acomulador * tiempo;
tiempo = 0;
}
break;
// EL CONTENIDO DEL ACOMULADOR SE INCREMENTAR CON EL CONTENIDO DEL TIEMPO. INSTRUCCION MMT A = 18
case 18:
if(tiempo == 3){
acomulador = acomulador + tiempo;
tiempo = 0;
}
break;
// EL ACOMULADOR ENVIA UN DATO AL REGISTRO DE SALIDAS C Y FINALIZA EL PROGRAMA.INSTRUCCION OUT C,A = 19
case 19:
if(tiempo == 3){
if(acomulador == 0){
digitalWrite(11, LOW);
digitalWrite(12, LOW);
digitalWrite(13, LOW);
}
else if(acomulador == 1){
digitalWrite(11, HIGH);
digitalWrite(12, LOW);
digitalWrite(13, LOW);
}
else if(acomulador == 2){
digitalWrite(11, LOW);
digitalWrite(12, HIGH);
digitalWrite(13, LOW);
}
else if(acomulador == 3){
digitalWrite(11, HIGH);
digitalWrite(12, HIGH);
digitalWrite(13, LOW);
}
else if(acomulador == 4){
digitalWrite(11, LOW);
digitalWrite(12, LOW);
digitalWrite(13, HIGH);
}
else if(acomulador == 5){
digitalWrite(11, HIGH);
digitalWrite(12, LOW);
digitalWrite(13, HIGH);
}
else if(acomulador == 6){
digitalWrite(11, LOW);
digitalWrite(12, HIGH);
digitalWrite(13, HIGH);
}
else{
digitalWrite(11, HIGH);
digitalWrite(12, HIGH);
digitalWrite(13, HIGH);
}
}
break;
// EL ACOMULADOR RECIBE UN DATO DEL EXTERIOR A TRAVEZ DEL BUFFER DE ENTRADA B. INSTRUCCION INT A,B = 20
case 20:
if(tiempo == 3){
lecturauno = digitalRead(5);
lecturados = digitalRead(6);
lecturatres = digitalRead(7);
if((lecturauno == LOW) && (lecturados == LOW) && (lecturatres == LOW)){
analizador = 0;
if(analizador == 0){
acomulador = 0;
}
}
if((lecturauno == HIGH) && (lecturados == LOW) && (lecturatres == LOW)){
analizador = 1;
if(analizador == 1){
acomulador = 1;
}
}
if((lecturauno == LOW) && (lecturados == HIGH) && (lecturatres == LOW)){
analizador = 2;
if(analizador == 2){
acomulador = 2;
}
}
if((lecturauno == HIGH) && (lecturados == HIGH) && (lecturatres == LOW)){
analizador = 3;
if(analizador == 3){
acomulador = 3;
}
}
if((lecturauno == LOW) && (lecturados == LOW) && (lecturatres == HIGH)){
analizador = 4;
if(analizador == 4){
acomulador = 4;
}
}
if((lecturauno == HIGH) && (lecturados == LOW) && (lecturatres == HIGH)){
analizador = 5;
if(analizador == 5){
acomulador = 5;
}
}
if((lecturauno == LOW) && (lecturados == HIGH) && (lecturatres == HIGH)){
analizador = 6;
if(analizador == 6){
acomulador = 6;
}
}
if((lecturauno == HIGH) && (lecturados == HIGH) && (lecturatres == HIGH)){
analizador = 7;
if(analizador == 7){
acomulador = 7;
}
}
tiempo = 0;
}
break;
// EN CASO DE QUE SE PRESENTE UNA INSTRUCCION NO PROGRAMADA EL SISTEMA INICIALIZA EL PROGRAMA EJECUTANDO EL CICLO FETCH O DE BUSQUEDA
default:
tiempo = 0;
break;
}
}
Ejemplo de operacion: cargar en memoria los valores 0,2,19,19,19, el resultado es igual a 2 en binario 10 ya que la instrucción 0 carga en el acumulador el dato que es en posición de memoria 1 y la instrucción 19 manda saca el la información por el buffer de salida que son los pines 13,12,11 de la tarjeta Arduino uno r3
En el siguiente link se encuentra el set de instrucciones junto con el conjunto de micro operaciones que la computadora realiza.
https://www.dropbox.com/s/6mhb2ogx08cmbwi/DIGITALES%20CPU.rar?dl=0
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.
Problema
Diseñar una computador digital el cual manipule 3 bit de entrada y 3 bit de salida y así mismo que ejecute la secuencia de microoperaciones que se encuentran en el documento que se encuentra en el link de descarga
Código Arduino
// CURSO DE ARDUINO
// DISEÑO DE UN COMPUTADOR DIGITAL
// ING. EN ELECTRONICA
// ING. VICTOR ALFONSO TANORI RUIZ
// [email protected]
// FECHA DE DESARROLLO: 13 DE MAYO DEL 2015
// DECLARACION DE COMPONENTES + RELOJ + CONSTANTES + VARIABLES DE LECTURAS DEL EXTERIOR + ANALIZADOR
int mar = 0, pc = 0, mbr = 0, ir = 0, tiempo = 0, acomulador , constante = 2, analizador = analizador;
// DECLARACION DE LA LECTURA DE DATOS DEL EXTERIOR
bool lecturauno = LOW, lecturados = LOW, lecturatres = LOW;
// DECLARACION DE MEMORIA DE PROGRAMACION RAM (MEMORIA DE ACCESO ALEATORIO)
// OJO LAS LECTURAS DE MEMORIA SE INICIALIZAN EN CERO ES DECIR SI SE CREA UNA MEMORIA DE [ 5 ] TENEMOS POSICIONES DE 0 - 4 MAS NO DE 1 - 5 MUCHO MENOS DE 0 -5
int memoria[ 5 ] = {0,1,3,2,19};
void setup() {
// DECLARACION DE ENTRADAS Y SALIDAS
pinMode(13, OUTPUT);
pinMode(12, OUTPUT);
pinMode(11, OUTPUT);
pinMode(7, INPUT);
pinMode(6, INPUT);
pinMode(5, INPUT);
}
// EL CICLO LOOP SE EJECUTA INDEFINIDAMENTE
void loop() {
// 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){
// CARGA EL ACOMULADOR CON EL DATO QUE ESTA INMEDIATAMENTE DESPUES AL CODIGO DE OPERACION. INTRUCCION LDA nn = 0
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;
// CARGA EL ACOMULADOR CON EL DATO QUE ESTA EN LA DIRECCION DADA POR nn. INSTRUCCION LDA(nn) = 1
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;
// SUMA AL CONTENIDO DEL ACOMULADOR EL DATO QUE ESTA INMEDIATAMENTE DESPUES AL CODIGO DE OPERACIÓN Y GUARDA EL RESULTADO EN EL ACOMULADOR. INSTRUCCION ADD nn = 2
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;
// SUMA AL CONTENIDO DEL ACOMULADOR EL DATO QUE ESTA EN LA DIRECCION DE MEMORIA DADA POR nn Y GUARDA EL RESULTADO EN EL ACOMULADOR. INTRUCCION ADD(nn) = 3
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;
// RESTA AL CONTENIDO DEL ACOMULADOR EL DATO QUE ESTA INMEDIATAMENTE DESPUES AL CODIGO DE OPERACIÓN Y GUARDA EL RESULTADO EN EL ACOMULADOR. INTRUCCION SUB nn = 4
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;
// RESTA AL CONTENIDO DEL ACOMULADOR EL DATO QUE ESTA EN LA DIRECCION DE MEMORIA DADA POR nn Y GUARDA EL RESULTADO EN EL ACOMULADOR. INSTRUCCION SUB(nn) = 5
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;
// MULTIPLICA AL CONTENIDO DEL ACOMULADOR EL DATO QUE ESTA INMEDIATAMENTE DESPUES AL CODIGO DE OPERACIÓN Y GUARDA EL RESULTADO EN EL ACOMULADOR. INSTRUCCION MUL nn = 6
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;
// MULTIPLICA AL CONTENIDO DEL ACOMULADOR EL DATO QUE ESTA EN LA DIRECCION DE MEMORIA DADA POR nn Y GUARDA EL RESULTADO EN EL ACOMULADOR. INSTRUCCION MUL(nn) = 7
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;
// ALMACENA EL CONTENIDO DEL ACOMULADOR EN LA MEMORIA EN LA DIRECCION DADA POR nn. INSTRUCCION STA(nn) = 8
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;
// EL PROGRAMA REALIZA UN SALTO PARA SEGUIRSE EJECUTANDO EN LA INSTRUCCIÓN QUE ESTA DADA POR nn. INSTRUCCION JMP(nn) = 9
case 9:
if(tiempo == 3)
{
mar = pc;
tiempo++;
}
if(tiempo == 4){
mbr = memoria[mar];
tiempo++;
}
if(tiempo == 5){
pc = mbr;
tiempo = 0;
}
break;
// EL CONTENIDO DEL ACOMULADOR SE INCREMENTA EN UNA UNIDAD. INSTRUCCION INC A = 10
case 10:
if(tiempo == 3){
acomulador = acomulador + 1;
tiempo = 0;
}
break;
// EL CONTENIDO DEL ACOMULADOR SE DECREMENTA EN UNA UNIDAD. INSTRUCCION DEC A = 11
case 11:
if(tiempo == 3){
acomulador = acomulador - 1;
tiempo = 0;
}
break;
// EL CONTENIDO DEL ACOMULADOR SE MULTIPLICA POR 2 UNIDADES. INSTRUCCION MUL A = 12
case 12:
if(tiempo == 3){
acomulador = acomulador * constante;
tiempo = 0;
}
break;
// EL CONTENIDO DEL ACOMULADOR SE MULTIPLICA POR SI MISMO. INSTRUCCION MPM A = 13
case 13:
if(tiempo == 3){
acomulador = acomulador * acomulador;
tiempo = 0;
}
break;
// EL CONTENIDO DEL ACOMULADOR ES IGUAL A CERO. INSTRUCCION RST A = 14
case 14:
if(tiempo == 3){
acomulador = 0;
tiempo = 0;
}
break;
// EL ACOMULADOR TOMA EL VALOR DEL CONTADOR DE PROGRAMA (PC). INSTRUCCION NVA A = 15
case 15:
if(tiempo == 3){
acomulador = pc;
tiempo = 0;
}
break;
// EL ACOMULADOR TOMA EL VALOR DEL TIEMPO (T). INSTRUCCION NVT A = 16
case 16:
if(tiempo == 3){
acomulador = tiempo;
tiempo = 0;
}
break;
// EL CONTENIDO DEL ACOMULADOR SE MULTIPLICA POR EL CONTENIDO DEL TIEMPO. INSTRUCCION MPT A = 17
case 17:
if(tiempo == 3){
acomulador = acomulador * tiempo;
tiempo = 0;
}
break;
// EL CONTENIDO DEL ACOMULADOR SE INCREMENTAR CON EL CONTENIDO DEL TIEMPO. INSTRUCCION MMT A = 18
case 18:
if(tiempo == 3){
acomulador = acomulador + tiempo;
tiempo = 0;
}
break;
// EL ACOMULADOR ENVIA UN DATO AL REGISTRO DE SALIDAS C Y FINALIZA EL PROGRAMA.INSTRUCCION OUT C,A = 19
case 19:
if(tiempo == 3){
if(acomulador == 0){
digitalWrite(11, LOW);
digitalWrite(12, LOW);
digitalWrite(13, LOW);
}
else if(acomulador == 1){
digitalWrite(11, HIGH);
digitalWrite(12, LOW);
digitalWrite(13, LOW);
}
else if(acomulador == 2){
digitalWrite(11, LOW);
digitalWrite(12, HIGH);
digitalWrite(13, LOW);
}
else if(acomulador == 3){
digitalWrite(11, HIGH);
digitalWrite(12, HIGH);
digitalWrite(13, LOW);
}
else if(acomulador == 4){
digitalWrite(11, LOW);
digitalWrite(12, LOW);
digitalWrite(13, HIGH);
}
else if(acomulador == 5){
digitalWrite(11, HIGH);
digitalWrite(12, LOW);
digitalWrite(13, HIGH);
}
else if(acomulador == 6){
digitalWrite(11, LOW);
digitalWrite(12, HIGH);
digitalWrite(13, HIGH);
}
else{
digitalWrite(11, HIGH);
digitalWrite(12, HIGH);
digitalWrite(13, HIGH);
}
}
break;
// EL ACOMULADOR RECIBE UN DATO DEL EXTERIOR A TRAVEZ DEL BUFFER DE ENTRADA B. INSTRUCCION INT A,B = 20
case 20:
if(tiempo == 3){
lecturauno = digitalRead(5);
lecturados = digitalRead(6);
lecturatres = digitalRead(7);
if((lecturauno == LOW) && (lecturados == LOW) && (lecturatres == LOW)){
analizador = 0;
if(analizador == 0){
acomulador = 0;
}
}
if((lecturauno == HIGH) && (lecturados == LOW) && (lecturatres == LOW)){
analizador = 1;
if(analizador == 1){
acomulador = 1;
}
}
if((lecturauno == LOW) && (lecturados == HIGH) && (lecturatres == LOW)){
analizador = 2;
if(analizador == 2){
acomulador = 2;
}
}
if((lecturauno == HIGH) && (lecturados == HIGH) && (lecturatres == LOW)){
analizador = 3;
if(analizador == 3){
acomulador = 3;
}
}
if((lecturauno == LOW) && (lecturados == LOW) && (lecturatres == HIGH)){
analizador = 4;
if(analizador == 4){
acomulador = 4;
}
}
if((lecturauno == HIGH) && (lecturados == LOW) && (lecturatres == HIGH)){
analizador = 5;
if(analizador == 5){
acomulador = 5;
}
}
if((lecturauno == LOW) && (lecturados == HIGH) && (lecturatres == HIGH)){
analizador = 6;
if(analizador == 6){
acomulador = 6;
}
}
if((lecturauno == HIGH) && (lecturados == HIGH) && (lecturatres == HIGH)){
analizador = 7;
if(analizador == 7){
acomulador = 7;
}
}
tiempo = 0;
}
break;
// EN CASO DE QUE SE PRESENTE UNA INSTRUCCION NO PROGRAMADA EL SISTEMA INICIALIZA EL PROGRAMA EJECUTANDO EL CICLO FETCH O DE BUSQUEDA
default:
tiempo = 0;
break;
}
}
Ejemplo de operacion: cargar en memoria los valores 0,2,19,19,19, el resultado es igual a 2 en binario 10 ya que la instrucción 0 carga en el acumulador el dato que es en posición de memoria 1 y la instrucción 19 manda saca el la información por el buffer de salida que son los pines 13,12,11 de la tarjeta Arduino uno r3
En el siguiente link se encuentra el set de instrucciones junto con el conjunto de micro operaciones que la computadora realiza.
https://www.dropbox.com/s/6mhb2ogx08cmbwi/DIGITALES%20CPU.rar?dl=0