Diseño de CPU
Aquí hay un núcleo de computadora diseñado en lenguaje Verilog HDL, que puede ejecutar programas simples. Lo completé como ejemplo de diseño en mi clase de posgrado. El diseño se probó en el entorno de software Quartus II y se descargó en una placa experimental de desarrollo casera para ejecutarlo. Entre ellos, la memoria es una estructura de Harvard, que se organiza directamente utilizando los elementos de memoria proporcionados por Quartus II.
Programa
//Reloj de entrada básico
//Control de reinicio: reset_n, el nivel bajo está activo.
//Salida básica: o
//Memoria de programa iram, 16 bits, los 5 bits superiores son el código de instrucción de clase, inicializado en imem16.mif.
//Memoria de datos, 16 bits, sin inicialización de archivos de datos.
La señal de dirección de la memoria lpm debe ser estable a 1 latido antes de leer y escribir datos.
//Formato de instrucción: código de instrucción alto de 5 bits, código de dirección de 11 bits, datos inmediatos de 16 bits (divididos en 8 bits alto y bajo).
Prueba del módulo
(
Reloj,
Reset_n,
Oh,
//Salida de depuración (opcional):
opc,
omar,
ojp,
oqw,
orda,
oadd,
oout
);
reloj de entrada;
Entrada reset_n;
salida[15:0]o;
salida[15:0]oqw;
salida [10:0] opc, omar
Salida[2:0]ojp;
Salida olda, oadd, oout
Cable dwren
cable [15:0]q_w;
cable[15:0]q_data;
reg [15:0] b, a, ir, da, oo, ddata
reg [10:0] pc, mar
reg[2:0]jp; //beat
reg dwrit//control de escritura
//Comando:
Reg lda, // buscar: recupera el número de la unidad de datos a da.
Agregar, // Agregar: da se agrega a la unidad de datos y el resultado se coloca en da.
Salida, // salida: envía el contenido de la unidad de datos al registro de salida.
Sdal, //reducir datos inmediatos de 8 bits: expande los datos inmediatos de 8 bits a 16 bits y envíalos a da.
Sdah, //Número inmediato alto de 8 bits: use el número inmediato de 8 bits como los 8 bits superiores, conéctelo con los 8 bits bajos del da original, forme 16 bits y colóquelo en da.
str//da unidad de almacenamiento de datos de envío:
//Salida de señal analógica:
Asignar o= oo
Asignar opc= pc
Asignación omar = mar
Asignación ojp = jp
Asignación oqw = q _ w;
Asignación olda = lda p>
asignar oadd = add
Asignar oout = out
Asignar dwren = dwrit
//Memoria de instrucciones:
lpm_rom iram(.address(pc).inclock(clock).q(q_w));//memoria del programa
def param iram.LPM_width = 16;
def param iram . LPM _ ancho ad = 11;
def param iram.lpm_outdata = "No registrado"
def param iram _ en datos = " REGISTRADO "; >
def param iram . LPM _ dirección _ control = " REGISTRADO ";
def param iram .
//Almacenamiento de datos:
lpm_ram_dq dram(.data(ddata).address(mar).us(dwren).inclock(clock).
q(q _ data)); def param dram . LPM _ ancho = 16;
def param dram .lpm_outdata = " No registrarse"
def param dram. LPM_in data = " REGISTERED "
def param dram. LPM_address_control = " REGISTERED "
siempre @(reloj de borde positivo o borde negativo reset_n)
Iniciar
if (!reset_n)
Iniciar
pc & lt= 0;
lda & lt= 0;
añadir& lt= 0;
fuera & lt= 0;
sdal & lt= 0;
sdah & lt= 0;
str & lt= 0;
jp & lt=0;
Fin
Otros
Inicio
jp & lt= jp+1;
Caso (jp)
0:Inicio
Fin
1:Inicio
Caso (q_w[15:11])
5 ' b 00001:LDA <= 1;//lda :00001
5 ' b 00010:add <= 1;//Dirección:00010
5 ' b 00011: salida <= 1;//salida:00011
5 ' b 00100:sdal <= 1;//8 bits inferiores, extendidos con 16 bits con signo
5 ' b 00101:sdah <= 1;//El alto 8 bits se combinan con los 8 bits bajos anteriores para formar 16 bits.
5 ' b 00110:str <= 1;//da unidad de datos de envío
Fin de caso
Fin
2 : inicio
if (lda || add || out || str)
mar & lt= q _ w[10:0];
Fin
3:PC<=PC+1;
4:Iniciar
IF (lda)
Iniciar
da & lt= q _ data
jp & lt= 0;
lda & lt= 0;
Fin
Otro
Si (añadir)
Inicio
b & lt= q _ data
a & lt= da
p >Fin
Otro
Si (fuera)
Inicio
oo & lt= q_data
jp & lt= 0;
out & lt= 0;
Fin
Otro
if (sdal)
Inicio
da & lt= {{8{q_w[7]}}, q_w[7:0]} // Expandir a 16 números con signo.
sdal & lt= 0;
Fin
Otro
if (sdah)
Inicio
p>
da[15:0]<= {q_w[7:0],da[7:0]};
sdah <= 0;
Fin
Otro
if (cadena)
Inicio
ddata & lt= da
dwrit & lt= 1;
Fin
Fin
5:Inicio
Si (Agregar)
Iniciar
da & lt= a+b;
jp & lt= 0;
Agregar & lt= 0;
Fin
Otro
if(cadena)
Inicio
str & lt= 0;
dwrit & lt = 0;
Fin
Fin
Fin caso
Fin
Fin
Fin del módulo
///////////Ejemplo de simulación o ejecución de un programa/////////
//ensamblaje//
// sdal 5 2005 //
// sdah 6 2806 //
// str 10 300a //
/ / sdal 3 2003 //
//Agregar 10 100a //
// str 15 300f //
// fuera 15 180f //
//Escribe los 16 números hexadecimales compilados en imem16.mif //
//////16 salida del resultado: 0608/////////.