Qué es la unidad de control: componentes y su diseño

La unidad de control es el componente principal de una unidad central de procesamiento (CPU) en los ordenadores que puede dirigir las operaciones durante la ejecución de un programa por el procesador/ordenador. La función principal de la unidad de control es obtener y ejecutar instrucciones de la memoria de un ordenador. Recibe la instrucción/información de entrada del usuario y la convierte en señales de control, que luego se entregan a la CPU para su posterior ejecución. Se incluye como parte de la arquitectura Von Neumann desarrollada por John Neumann. Se encarga de proporcionar las señales de sincronización y de control y dirige la ejecución de un programa por parte de la CPU. Se incluye como parte interna de la CPU en los ordenadores modernos. Este artículo describe información completa sobre la unidad de control.


¿Qué es la unidad de control?

Es el componente que recibe la señal/información/instrucción de entrada del usuario y la convierte en señales de control para la ejecución en la CPU. Controla y dirige la memoria principal, la unidad aritmética y lógica (ALU), los dispositivos de entrada y salida, y también es responsable de las instrucciones que se envían a la CPU de un ordenador. Obtiene las instrucciones de la memoria principal de un procesador y las envía al registro de instrucciones del procesador, que contiene el contenido del registro.

Diagrama de bloques de la unidad de control

La unidad de control convierte la entrada en señales de control y luego las envía al procesador y dirige la ejecución de un programa. Las operaciones que hay que realizar son dirigidas por el procesador del ordenador. Principalmente la Unidad Central de Procesamiento (CPU) y la Unidad de Procesamiento Gráfico (GPU) requieren una unidad de control como parte interna. El diagrama de bloques de la unidad de control se muestra arriba.

Componentes de una unidad de control

Los componentes de esta unidad son los registros de instrucciones, las señales de control dentro de la CPU, las señales de control hacia/desde el bus, el bus de control, las banderas de entrada y las señales de reloj.

Los componentes de la unidad de control de la CPU son el registro de instrucciones (contiene el opcode y el campo de dirección), la unidad de temporización, el generador de estados de control, la matriz de generación de señales de control y el decodificador de instrucciones.
Los componentes de la unidad de control microprogramada son el generador de direcciones siguientes, un registro de direcciones de control, la memoria de control y el registro de datos de control.

Funciones

El funciones de la unidad de control incluyen las siguientes.

  • Dirige el flujo de la secuencia de datos entre el procesador y otros dispositivos.
  • Puede interpretar las instrucciones y controla el flujo de datos en el procesador.
  • Genera la secuencia de señales de control a partir de las instrucciones o comandos recibidos del registro de instrucciones.
  • Tiene la responsabilidad de controlar las unidades de ejecución, como la ALU, los búferes de datos y los registros de la CPU de un ordenador.
  • Tiene la capacidad de buscar, descodificar, manejar la ejecución y almacenar los resultados.
  • No puede procesar y almacenar los datos
  • Para transferir los datos, se comunica con los dispositivos de entrada y salida y controla todas las unidades del ordenador.

Diseño de la unidad de control

El diseño de la misma puede realizarse mediante dos tipos de unidad de control que incluyen los siguientes.

  • Basado en el cableado
  • Basado en la microprogramación (de un nivel y de dos niveles)
Lee:  ¡No tires tus contadores inteligentes!

Unidad de control cableada

El diseño básico de una unidad de control cableada se muestra arriba. En este tipo, las señales de control son generadas por un circuito lógico de hardware especial sin ningún cambio en la estructura del circuito. En este caso, la señal generada no puede modificarse para su ejecución en el procesador.

Los datos básicos de un opcode (código de operación de una instrucción) se envían al descodificador de instrucciones para su descodificación. El descodificador de instrucciones es el conjunto de descodificadores para descodificar los diferentes tipos de datos del opcode. Esto da lugar a señales de salida que contienen valores de señales activas que se dan como entrada al generador de matrices para generar señales de control para la ejecución de un programa por el procesador del ordenador.

Unidad de control basada en el cableado
Unidad de control basada en cableado

El generador de la matriz proporciona los estados de la unidad de control y las señales de salida del procesador (señales de interrupción). La matriz se construye como la matriz lógica programable. Las señales de control generadas por el generador de matrices se dan como entrada a la siguiente matriz generadora y se combinan con las señales de temporización de la unidad de temporización que contiene patrones rectangulares.

Para la obtención de una nueva instrucción, la unidad de control se convierte en una etapa inicial para la ejecución de la nueva instrucción. La unidad de control permanece en la etapa inicial o primera etapa mientras las señales de temporización, las señales de entrada y los estados de instrucción de un ordenador no cambien. El cambio de estado de la unidad de control puede plantearse si hay algún cambio en alguna de las señales generadas.

Cuando se produce una señal externa o una interrupción, la unidad de control pasa al siguiente estado y realiza el procesamiento de la señal de interrupción. Las banderas y los estados se utilizan para seleccionar los estados deseados para realizar el ciclo de ejecución de la instrucción.

En el último estado, la unidad de control recupera la siguiente instrucción y envía la salida al contador de programa, luego al registro de direcciones de memoria, al registro de memoria intermedia y, por último, al registro de instrucciones para leer la instrucción. Por último, si la última instrucción (obtenida por la unidad de control) es la instrucción final, entonces pasa al estado de funcionamiento del procesador y espera hasta que el usuario le indique el siguiente programa.

Unidad de control microprogramada

En este tipo, el almacén de control se utiliza para almacenar las señales de control que se codifican durante la ejecución de un programa. La señal de control no se genera inmediatamente y se descodifica porque el microprograma almacena el campo de direcciones en el almacén de control. Todo el proceso es de un solo nivel.

Las microoperaciones se realizan para la ejecución de las microinstrucciones del programa. El diagrama de bloques de la unidad de control microprogramada se muestra arriba. En el diagrama, la dirección de la microinstrucción se obtiene del registro de direcciones de la memoria de control. Toda la información de la unidad de control se almacena permanentemente en la memoria de control llamada ROM.

Lee:  Retroiluminación LED confiable y eficiente para pantallas LCD grandes
Unidad de control basada en la microprogramación
Unidad de control basada en microprogramación

La microinstrucción de la memoria de control se mantiene en el registro de control. Como la microinstrucción tiene forma de palabra de control (contiene valores binarios de control), necesita que se realicen 1 o más microoperaciones para el procesamiento de los datos.

Durante la ejecución de las microinstrucciones, el generador de la siguiente dirección computa la siguiente dirección de la microinstrucción y la envía al registro de direcciones de control para leer la siguiente microinstrucción.
La secuencia de microoperaciones de un microprograma es realizada por el generador de la siguiente dirección y actúa como secuenciador del microprograma para obtener la dirección de la secuencia, es decir, leerla de la memoria de control.

Código Verilog de la unidad de control

A continuación se muestra el código Verilog para la Unidad de Control.

`include «prj_definition.v»

module CONTROL_UNIT(MEM_DATA, RF_DATA_W, RF_ADDR_W, RF_ADDR_R1, RF_ADDR_R2, RF_READ, RF_WRITE, ALU_OP1, ALU_OP2, ALU_OPRN, MEM_ADDR, MEM_READ, MEM_WRITE, RF_DATA_R1, RF_DATA_R2, ALU_RESULT, ZERO, CLK, RST)

// Señales de salida
// Salidas para el archivo de registro

salida [`DATA_INDEX_LIMIT:0] RF_DATA_W;
salida [`ADDRESS_INDEX_LIMIT:0] RF_ADDR_W, RF_ADDR_R1, RF_ADDR_R2;
salida RF_READ, RF_WRITE;

// Salidas para la ALU
salida [`DATA_INDEX_LIMIT:0] ALU_OP1, ALU_OP2;
salida [`ALU_OPRN_INDEX_LIMIT:0] ALU_OPRN;

// Salidas para la memoria
salida [`ADDRESS_INDEX_LIMIT:0] MEM_ADDR;
salida MEM_READ, MEM_WRITE;

// Señales de entrada
entrada [`DATA_INDEX_LIMIT:0] RF_DATA_R1, RF_DATA_R2, ALU_RESULTADO;
entrada ZERO, CLK, RST;

// Señal de entrada
inout [`DATA_INDEX_LIMIT:0] MEM_DATA;

// Redes de estado
alambre [2:0] estado_de_proceso;

//contiene el valor del contador del programa, almacena la instrucción actual, registro del puntero de la pila

reg MEM_READ, MEM_WRITE;
reg MEM_ADDR;
reg ALU_OP1, ALU_OP2;
reg ALU_OPRN;
reg RF_ADDR_W, RF_ADDR_R1, RF_ADDR_R2;
reg RF_DATA_W;
reg [1:0] estado, siguiente_estado;

PROC_SM estado_máquina(.ESTADO(proc_estado),.CLK(CLK),.RST(RST));

siempre @ (posedge CLK)
empezar
si (RST)
estado <= RST;
si no
estado <= siguiente_estado;

fin

siempre @ (estado)
empezar

MEM_READ = 1’b0; MEM_WRITE = 1’b0; MEM_ADDR = 1’b0;
ALU_OP1 = 1’b0; ALU_OP2 = 1’b0; ALU_OPRN = 1’b0;
RF_ADDR_R1 = 1’b0; RF_ADDR_R2 = 1’b0; RF_ADDR_W = 1’b0; RF_DATA_W = 1’b0;

case( estado )

`PROC_FETCH : comenzar
next_state = `PROC_DECODE;
MEM_READ = 1’b1;
RF_ADDR_R1 = 1’b0; RF_ADDR_R2 = 1’b0;
RF_ADDR_W = 1’b1;
fin

`PROC_DECODE : comenzar
next_state = `PROC_EXE;
MEM_ADDR = 1’b1;
ALU_OP1 = 1’b1; ALU_OP2 = 1’b1; ALU_OPRN = 1’b1;
MEM_WRITE = 1’b1;
RF_ADDR_R1 = 1’b1; RF_ADDR_R2 = 1’b1;
fin

`PROC_EXE : comenzar
siguiente_estado = `PROC_MEM;
ALU_OP1 = 1’b1; ALU_OP2 = 1’b1; ALU_OPRN = 1’b1;
RF_ADDR_R1 = 1’b0;
fin

`PROC_MEM: comenzar
siguiente_estado = `PROC_WB;
MEM_READ = 1’b1; MEM_WRITE = 1’b0;
fin

`PROC_WB: comenzar
next_state = `PROC_FETCH;
MEM_READ = 1’b1; MEM_WRITE = 1’b0;
fin
endcase

fin
endmodulo;

módulo PROC_SM(ESTADO,CLK,RST);
// lista de entradas
entrada CLK, RST;
// lista de salidas
salida [2:0] ESTADO;

// lista de entrada
entrada CLK, RST;
// lista de salida
salida ESTADO;

reg [2:0] ESTADO;
reg [1:0] estado;
reg [1:0] siguiente_estado;

reg PC_REG, INST_REG, SP_REF;

`define PROC_FETCH 3’h0
`define PROC_DECODE 3’h1
`define PROC_EXE 3’h2
`define PROC_MEM 3’h3
`define PROC_WB 3’h4

// inicio del estado
inicial
comenzar
estado = 2’bxx;
next_state = `PROC_FETCH;
fin

// manejo de la señal de reinicio
siempre @ (posedge RST)
empezar
state = `PROC_FETCH;
next_state = `PROC_FETCH;
fin
siempre @ (posedge CLK)
empezar
estado = siguiente_estado;
fin
siempre @(estado)
empezar
si (estado === `PROC_FETCH)
comenzar
next_state = `PROC_DECODE;

print_instruction(INST_REG);
fin

if (state === `PROC_DECODE)
comenzar
next_state = `PROC_EXE;

fin

if (state === `PROC_EXE)
comenzar
next_state = `PROC_MEM;

print_instruction(SP_REF);
fin

if (state === `PROC_MEM)
comenzar
next_state = `PROC_WB;

fin

if (state === `PROC_WB)
comenzar
next_state = `PROC_FETCH;

print_instruction(PC_REG);
fin
fin

tarea imprimir_instrucción;

Lee:  ¿Cómo crear un LED intermitente con un CI temporizador 555?

entrada [`DATA_INDEX_LIMIT:0] inst;

reg [5:0] opcode;
reg [4:0] rs;
reg [4:0] rt;
reg [4:0] rd;
reg [4:0] shamt; reg [5:0] funct; reg [15:0] inmediato; reg [25:0] dirección;

empezar

// analiza la instrucción
// Tipo R

{opcode, rs, rt, rd, shamt, funct} = inst;

// Tipo I
{opcode, rs, rt, immediate } = inst;
// Tipo J
{código de operación, dirección} = inst;
$write(«@ %6dns -> [0X%08h] «, $time, inst);
case(opcode) // Tipo-R
6’h00 : empezar
case(funct)

6’h20: $write(«añadir r[%02d], r[%02d], r[%02d];», rs, rt, rd);
6’h22: $write(«sub r[%02d], r[%02d], r[%02d];», rs, rt, rd);
6’h2c: $write(«mul r[%02d], r[%02d], r[%02d];», rs, rt, rd);
6’h24: $write(«y r[%02d], r[%02d], r[%02d];», rs, rt, rd);
6’h25: $write(«o r[%02d], r[%02d], r[%02d];», rs, rt, rd);
6’h27: $write(«ni r[%02d], r[%02d], r[%02d];», rs, rt, rd);
6’h2a: $write(«slt r[%02d], r[%02d], r[%02d];», rs, rt, rd);
6’h00: $write(«sll r[%02d], %2d, r[%02d];», rs, shamt, rd);
6’h02: $write(«srl r[%02d], 0X%02h, r[%02d];», rs, shamt, rd);
6’h08: $write(«jr r[%02d];», rs);
por defecto: $escribir(«»);
endcase
fin

// Tipo I

6’h08 : $write(«addi r[%02d], r[%02d], 0X%04h;», rs, rt, inmediato);
6’h1d : $write(«muli r[%02d], r[%02d], 0X%04h;», rs, rt, inmediato);
6’h0c : $write(«andi r[%02d], r[%02d], 0X%04h;», rs, rt, inmediato);
6’h0d : $write(«ori r[%02d], r[%02d], 0X%04h;», rs, rt, inmediato);
6’h0f : $write(«lui r[%02d], 0X%04h;», rt, inmediato);
6’h0a : $write(«slti r[%02d], r[%02d], 0X%04h;», rs, rt, inmediato);
6’h04 : $write(«beq r[%02d], r[%02d], 0X%04h;», rs, rt, inmediato);
6’h05 : $write(«bne r[%02d], r[%02d], 0X%04h;», rs, rt, inmediato);
6’h23 : $write(«lw r[%02d], r[%02d], 0X%04h;», rs, rt, inmediato);
6’h2b : $write(«sw r[%02d], r[%02d], 0X%04h;», rs, rt, inmediato);

// Tipo J

6’h02 : $write(«jmp 0X%07h;», dirección);
6’h03 : $write(«jal 0X%07h;», dirección);
6’h1b : $write(«push;»);
6’h1c : $write(«pop;»);
por defecto: $write(«»);
endcase
$escribir («n»);
fin
fin de la tarea
fin del módulo;

Preguntas frecuentes

1). ¿Cuál es el trabajo de una unidad de control?

El trabajo de la unidad de control es dirigir el flujo de datos o instrucciones para su ejecución por el procesador de un ordenador. Controla, gestiona y coordina la memoria principal, la ALU, los registros y las unidades de entrada y salida. Obtiene las instrucciones y genera señales de control para la ejecución.

2). ¿Qué es la memoria de control?

La memoria de control suele ser RAM o ROM para almacenar la dirección y los datos del registro de control.

3). ¿Qué es la unidad de control Wilkes?

Los circuitos secuenciales y combinacionales de la unidad de control de la instalación eléctrica se sustituyen por la unidad de control de Wilkes. Utiliza una unidad de almacenamiento para guardar las secuencias de instrucciones de un microprograma.

4). ¿Qué es una unidad de control cableada?

La unidad de control cableada genera las señales de control cambiando de un estado a otro en cada pulso de reloj sin ningún cambio físico en el circuito. La generación de señales de control depende del registro de instrucciones, del decodificador y de las señales de interrupción.

5). ¿Qué es la memoria de control?

La información de la unidad de control o los datos se almacenan temporal o permanentemente en la memoria de control.
La memoria de control es de dos tipos. Son la memoria de acceso aleatorio (RAM) y la memoria de sólo lectura (ROM).

Por tanto, se trata de la definición, los componentes, el diseño, el diagrama, las funciones y tipos de Unidad de Control. He aquí una pregunta para ti: «¿Para qué sirve el registro de direcciones de control?»

Javired
Javired

Deja una respuesta

Tu dirección de correo electrónico no será publicada.