TCL
Este é o programa que faz a interface entre o computador e a FPGA, repassando os valores lidos para o tratamento pelo programa leProbe.py. Ele deve ser criado com o nome getHW.tcl e ficar no mesmo diretório do programa leProbe.py mostrado mais abaixo.
Nome do arquivo: getHW.tcl
Python
Este arquivo deve ser criado em um diretório juntamente com o getHW.tcl. Ele recebe a leitura do probe, feita pelo programa getHW.tcl (mostrado acima), e mostra na tela os valores dos sinais internos da FPGA. Para tanto, ele utiliza o módulo quartus_stp (presente no diretório do quartus/bin ou quartus/bin64).
Para o Linux, é necessário acertar o caminho do arquivo quartus_stp para refletir a instalação feita no seu computador. Para o Windows, deve-se colocar o diretório do quartus_stp no PATH e acertar a variável win para o valor 1.
Nome do arquivo: leProbe.py
#! /usr/bin/env python3
# -*- coding:utf-8 -*-
import subprocess;
def leProbe():
win=0;
if win == 1:
# Para Windows, deve colocar o diretório intelFPGA_lite/20.1/quartus/bin64 no PATH.
programa = ['quartus_stp.exe', '-t', 'getHW.tcl']
else:
caminho = '/home/paulo/intelFPGA_lite/20.1/quartus/bin/'
programa = [caminho+'quartus_stp', '-t', 'getHW.tcl']
# quartus_stp -t getHW.tcl
leitura = subprocess.Popen(programa, stdout=subprocess.PIPE, stderr=subprocess.STDOUT);
stdout,stderr = leitura.communicate()
# O replace compatibiliza o New Line entre o Windows e o Linux
valor = stdout.decode("utf-8").replace('\r\n','\n');
binario = valor.split('getHW.tcl\n')[1].split('\n')[0]
return binario;
def convREG(numREG):
nomeREG = {'00000': 'Zero','00001': 'at','00010': 'v0','00011': 'v1','00100': 'a0','00101': 'a1','00110': 'a2', '00111': 'a3',
'01000': 't0', '01001': 't1', '01010': 't2', '01011': 't3', '01100': 't4', '01101': 't5', '01110': 't6', '01111': 't7',
'10000': 's0', '10001': 's1', '10010': 's2', '10011': 's3', '10100': 's4', '10101': 's5', '10110': 's6', '10111': 's7',
'11000': 't8', '11001': 't9', '11010': 'k0', '11011': 'k1', '11100': 'gp', '11101': 'sp', '11110': 'fp', '11111': 'ra'};
return nomeREG[numREG];
def convInstrucao(opcode, funct):
if opcode == '000000':
if funct == '000000':
return ('NOP');
elif funct == '001000':
return ('JR');
elif funct == '100000':
return ('ADD');
elif funct == '100010':
return ('SUB');
elif funct == '100100':
return ('AND');
elif funct == '100101':
return ('OR');
elif funct == '101010':
return ('SLT');
else:
return ('Erro. opCode: '+str(opcode)+' - funct: '+str(funct));
else:
if opcode == '000010':
return 'JMP';
elif opcode == '000011':
return 'JAL';
elif opcode == '000100':
return 'BEQ';
elif opcode == '000101':
return 'BNE';
elif opcode == '000101':
return 'BNE';
elif opcode == '001000':
return 'ADDI';
elif opcode == '001010':
return 'SLTI';
elif opcode == '001100':
return 'ANDI';
elif opcode == '001101':
return 'ORI';
elif opcode == '001111':
return 'LUI';
elif opcode == '100011':
return 'LW';
elif opcode == '101011':
return 'SW';
else:
return 'ERRO. opCode: '+str(opcode)+' - funct: '+str(funct);
def convULActrl(ULACTRL):
if ULACTRL == '0000':
return 'AND';
elif ULACTRL == '0001':
return 'OR';
elif ULACTRL == '0010':
return 'Soma';
elif ULACTRL == '0110':
return 'Sub';
elif ULACTRL == '0111':
return 'SLT';
else:
return 'ERRO';
def convHEXA(valor, comprimento):
valor = int(valor,2)
return "{0:#0{1}X}".format(valor, comprimento)
# Explanation:
# { # Format identifier
# 0: # first parameter
# # # use "0x" prefix
# 0 # fill with zeroes
# {1} # to a length of n characters (including 0x), defined by the second parameter
# x # hexadecimal number, using lowercase letters for a-f
# X # hexadecimal number, using uppercase letters for A-F
# } # End of format identifier
def convPtCtrl(selMUXPCBEQJMP, selMUXRTRD, habilitaEscritaC, selMUXRTIMED, selMUXULAMEM, BEQ, WR, RD):
if selMUXPCBEQJMP == '1':
if habilitaEscritaC == '0' and WR == '0':
return 'JMP';
else:
return 'Erro no JMP'
if selMUXRTRD == '1' and habilitaEscritaC == '1' and selMUXULAMEM == '0':
if WR == '0' and selMUXRTIMED == '0':
return 'Tipo R';
else:
return 'Erro no Tipo R'
if selMUXRTRD == '0' and habilitaEscritaC == '1' and selMUXULAMEM == '1':
if WR == '0' and selMUXRTIMED == '1':
return 'LW';
else:
return 'Erro no LW'
if WR == '1':
if RD == '0' and selMUXRTIMED == '1' and habilitaEscritaC == '0':
return 'SW';
else:
return 'Erro no SW'
if BEQ == '1':
if RD == '0' and WR == '0' and selMUXRTIMED == '0' and habilitaEscritaC == '0':
return 'BEQ';
else:
return 'Erro no BEQ'
return 'Nao Definido'
def main(argv=None):
# Interpretação da seleçãos dos MUXes:
MUXJMP = {'0': 'PC+4 ou BEQ', '1': 'Jump'};
MUXRTRD = {'0': 'RT', '1': 'RD'};
MUXRTIMED = {'0': 'RT', '1': 'Imediato'};
MUXULAMEM = {'0': 'Saída da ULA', '1': 'Memória'};
#
valor = leProbe();
PC = valor[480:512]
Instrucao = valor[448:480]
opCode = Instrucao[0:6]
funct = Instrucao[26:32]
enderecoRS = Instrucao[6:11]
enderecoRT = Instrucao[11:16]
enderecoRD = Instrucao[16:21]
Imediato = Instrucao[16:32]
conteudoRS = valor[416:448]
conteudoRT = valor[384:416]
valorRD = valor[352:384]
EntradaBULA = valor[320:352]
ImediatoExtendido = valor[288:320]
SaidaULA = valor[256:288];
DadoLidoRAM = valor[224:256];
ProxPC = valor[192:224];
MUXProxPC_EntradaA = valor[160:192];
MUXProxPC_EntradaB = valor[128:160];
#
flagZERO = valor[13];
selMUXPCBEQJMP = valor[12];
selMUXRTRD = valor[11];
selMUXRTIMED = valor[10];
selMUXULAMEM = valor[9];
BEQ = valor[8];
WR = valor[7];
RD = valor[6];
ULActrl = valor[2:6];
habilitaEscritaC = valor[1];
print (' Binario Hexa Decimal');
print ('Etapa de Busca:');
print ('Program Counter: '+str(PC)+' - '+convHEXA(PC, 10)+' - '+str(int(PC,2)) );
print ('MUXProxPC EntradaA: '+str(MUXProxPC_EntradaA)+' - '+convHEXA(MUXProxPC_EntradaA, 10)+' - '+str(int(MUXProxPC_EntradaA,2)) );
print ('MUXProxPC EntradaB: '+str(MUXProxPC_EntradaB)+' - '+convHEXA(MUXProxPC_EntradaB, 10)+' - '+str(int(MUXProxPC_EntradaB,2)) );
print ('ProxPC: '+str(ProxPC)+' - '+convHEXA(ProxPC, 10)+' - '+str(int(ProxPC,2)) );
print ('Instrucao: '+str(Instrucao)+' - '+convHEXA(Instrucao, 10) );
print ('Imediato Estendido: '+str(ImediatoExtendido)+' - '+convHEXA(ImediatoExtendido, 10)+' - '+str(int(ImediatoExtendido,2)) );
print ('\nBanco Registradores:');
print ('Leitura de RS: '+str(conteudoRS)+' - '+convHEXA(conteudoRS,10)+' - '+str(int(conteudoRS,2)));
print ('Leitura de RT: '+str(conteudoRT)+' - '+convHEXA(conteudoRT,10)+' - '+str(int(conteudoRT,2)));
print ('Escrita para RD: '+str(valorRD)+' - '+convHEXA(valorRD,10)+' - '+str(int(valorRD,2)));
print ('Habilita Escrita RD: '+str(habilitaEscritaC));
print ('\nULA:');
print ('Entrada A da ULA: '+str(conteudoRS)+' - '+convHEXA(conteudoRS,10)+' - '+str(int(conteudoRS,2)));
print ('Entrada B da ULA: '+str(EntradaBULA)+' - '+convHEXA(EntradaBULA,10)+' - '+str(int(EntradaBULA,2)));
print ('Saida da ULA: '+str(SaidaULA)+' - '+convHEXA(SaidaULA,10)+' - '+str(int(SaidaULA,2)));
print ('Flag de Zero: '+str(flagZERO));
print ('Controle da ULA: '+str(ULActrl)+' - '+convULActrl(ULActrl));
print ('\nPontos de Controle:');
print ('selMUX Jump/(BEQ PC+4): '+str(selMUXPCBEQJMP)+' - '+MUXJMP[selMUXPCBEQJMP]);
print ('selMUX RT/RD: '+str(selMUXRTRD)+' - '+MUXRTRD[selMUXRTRD]);
print ('selMUX RT/Imediato: '+str(selMUXRTIMED)+' - '+MUXRTIMED[selMUXRTIMED]);
print ('Habilita Escrita RD: '+str(habilitaEscritaC));
print ('selMUX ULA/MEM: '+str(selMUXULAMEM)+' - '+MUXULAMEM[selMUXULAMEM]);
print ('BEQ: '+str(BEQ));
print ('Habilita Leitura RAM: '+str(RD));
print ('Habilita Escrita RAM: '+str(WR));
print ('\nInterpretacao:');
print ('Instrucao: '+convInstrucao(opCode, funct)+' RD:'+convREG(enderecoRD)+' RS:'+convREG(enderecoRS)+' RT:'+convREG(enderecoRT)+' Imed:'+convHEXA(Imediato, 6) );
print ('');
result = convPtCtrl(selMUXPCBEQJMP=selMUXPCBEQJMP, selMUXRTRD=selMUXRTRD, habilitaEscritaC=habilitaEscritaC,
selMUXRTIMED=selMUXRTIMED, selMUXULAMEM=selMUXULAMEM, BEQ=BEQ, WR=WR, RD=RD);
print ('Pontos de Controle: '+result);
print ('=============================\n');
if __name__ == "__main__":
main()
VHDL
O arquivo debugMonitor.vhd é a interface com o probe de teste e deve ser criado no diretório raíz do projeto do Quartus e adicionado ao projeto.
Nome do arquivo: debugMonitor.vhd
library ieee;
use ieee.std_logic_1164.all;
entity debugMonitor is
generic (
DATA_WIDTH : natural := 32;
ADDR_WIDTH : natural := 32;
PROBE_WDTH : natural := 511
);
port (
-- Input ports
PC : in std_logic_vector(ADDR_WIDTH-1 downto 0);
Instrucao : in std_logic_vector(DATA_WIDTH-1 downto 0);
LeituraRS : in std_logic_vector(DATA_WIDTH-1 downto 0);
LeituraRT : in std_logic_vector(DATA_WIDTH-1 downto 0);
EscritaRD : in std_logic_vector(DATA_WIDTH-1 downto 0);
EntradaB_ULA : in std_logic_vector(DATA_WIDTH-1 downto 0);
imediatoEstendido : in std_logic_vector(DATA_WIDTH-1 downto 0);
saidaULA : in std_logic_vector(DATA_WIDTH-1 downto 0);
dadoLido_RAM : in std_logic_vector(DATA_WIDTH-1 downto 0);
proxPC : in std_logic_vector(DATA_WIDTH-1 downto 0);
MUXProxPCEntradaA : in std_logic_vector(DATA_WIDTH-1 downto 0);
MUXProxPCEntradaB : in std_logic_vector(DATA_WIDTH-1 downto 0);
ULActrl : in std_logic_vector(3 downto 0);
zeroFLAG : in std_logic;
escreveC : in std_logic;
MUXPCBEQJUMP : in std_logic;
MUXRTRD : in std_logic;
MUXRTIMED : in std_logic;
MUXULAMEM : in std_logic;
iBEQ : in std_logic;
WR : in std_logic;
RD : in std_logic;
-- Output ports
clkTCL : out std_logic
);
end entity;
architecture arch_name of debugMonitor is
component probesSourcesDebug is
port (
probe : in std_logic_vector(PROBE_WDTH-1 downto 0) := (others => 'X'); -- probe faz a leitura de dados de dentro da FPGA
source : out std_logic -- source escreve dados para dentro da FPGA
);
end component probesSourcesDebug;
begin
probe0 : component probesSourcesDebug
port map (
--probe => sigProbe, -- probes.probe
probe(31 downto 0) => PC,
probe(63 downto 32) => Instrucao,
probe(95 downto 64) => LeituraRS,
probe(127 downto 96) => LeituraRT,
probe(159 downto 128) => EscritaRD,
probe(191 downto 160) => EntradaB_ULA,
probe(223 downto 192) => imediatoEstendido,
probe(255 downto 224) => saidaULA,
probe(287 downto 256) => dadoLido_RAM,
probe(319 downto 288) => proxPC,
probe(351 downto 320) => MUXProxPCEntradaA,
probe(383 downto 352) => MUXProxPCEntradaB,
probe(497 downto 384) => open,
probe(498) => zeroFLAG,
probe(499) => MUXPCBEQJUMP,
probe(500) => MUXRTRD,
probe(501) => MUXRTIMED,
probe(502) => MUXULAMEM,
probe(503) => iBEQ,
probe(504) => WR,
probe(505) => RD,
probe(509 downto 506) => ULActrl,
probe(510) => escreveC,
--probe(PROBE_WDTH-1 downto 256) => open,
source => clkTCL
);
end architecture;
Este trecho de código, deve ser instanciado no top_level do projeto e cada sinal do lado direito deve ser substituido pelo sinal equivalente no projeto em teste.
monitor: work.debugMonitor
port map(PC => PCAtual, -- Saida o PC: entrada de endereco da ROM
Instrucao => FetInstrucao_DecInstrucao, -- Saida de dados da ROM
LeituraRS => Decode_BR_RS_Execute, -- Saida do Banco de Registradores: leitura de RS
LeituraRT => Decode_BR_RT_Execute, -- Saida do Banco de Registradores: leitura de RT
EscritaRD => WB_dadoEscritaC_DEC_DadoEscritaC, -- Entrada do Banco de Registradores (C)
EntradaB_ULA => entradaB_ULA, -- Entrada B da ULA: saida do MUX RT/ImediatoEstendido
imediatoEstendido => Decode_imediatoEstendido_Execute, -- ImediatoEstendido: entrada do MUX RT/ImediatoEstendido
saidaULA => EXEC_endereco_RAM_MEM, -- Saida da ULA: entrada do MUX ULA/MEM
dadoLido_RAM => MEM_dado_Lido_RAM_WB, -- Saida da RAM: entrada do MUX ULA/MEM
proxPC => Fetch_PC_mais_Quatro_Decode, -- Entrada do PC ou saida do MUX ProxPC
MUXProxPCEntradaA => MUXProxPCEntradaA, -- Entrada do MUX ProxPC: vinda MUX PC+4/BEQ
MUXProxPCEntradaB => MUXProxPCEntradaB, -- Entrada do MUX ProxPC: vinda da montagem do endereco de Jump
ULActrl => ULA_CTRL, -- Entrada do ULActrl na ULA: pode ser necessario concatenar 1 bit '0': '0' & ULActrl
zeroFLAG => zFlag, -- Saida do Flag da ULA e entrada da porta AND
escreveC => Decode_escreveC_Decode, -- Entrada do Banco de Registradores: sinal de habilita escrita no terceiro endereco (RD ou RT)
MUXPCBEQJUMP => MUX_PC_BEQ_JUMP, -- Selecao do MUX do proxPC: vem da unidade de controle
MUXRTRD => MUX_RT_RD, -- Selecao do MUX RT/RD: vem da unidade de controle
MUXRTIMED => MUX_RT_IMED, -- Selecao do MUX RT/Imediato: vem da unidade de controle
MUXULAMEM => MUX_ULA_MEM, -- Selecao do MUX ULA/MEM: vem da unidade de controle
iBEQ => BEQ, -- Indicador de instrucao BEQ: vem da unidade de controle
WR => HAB_ESCRITA_MEM, -- Habilita escrita na RAM: vem da unidade de controle
RD => HAB_LEITURA_MEM, -- Habilita leitura da RAM: vem da unidade de controle
--Output
clkTCL => clk_TCL); -- Sem uso: conectar com open
O arquivo qsys é a definição da configuração do probe e deve ser criado no diretório raíz do projeto do Quartus e adicionado ao projeto.
Nome do arquivo: probesSourcesDebug.qsys
