|
|
# -*- encoding: utf-8 -*-
|
|
|
"""
|
|
|
@File : execute_instruction.py
|
|
|
@License : (C)Copyright 2021-2023
|
|
|
|
|
|
@Modify Time @Author @Version @Description
|
|
|
------------ ------- -------- -----------
|
|
|
2023/11/10 17:14 zart20 1.0 None
|
|
|
"""
|
|
|
import re
|
|
|
import time
|
|
|
from tkinter import filedialog
|
|
|
from gui import *
|
|
|
|
|
|
inscode_map = {
|
|
|
'取数': '000001', '存数': '000010', '加法': '000011', '减法': '000111',
|
|
|
'乘法': '000100', '除法': '001000', '打印': '000101', '停机': '000110',
|
|
|
'跳转': '001001'
|
|
|
}
|
|
|
|
|
|
|
|
|
class ExecInstructWithText:
|
|
|
def __init__(self):
|
|
|
self.wait_time = 0.1 # 节拍计时
|
|
|
self.gui = GUISim() # 主界面显示
|
|
|
self.alu = self.gui.alu # alu实例化
|
|
|
self.memo = self.gui.memo # memo 实例化
|
|
|
self.sing = self.gui.sigctrl # 信号实例化
|
|
|
self.textbox = self.gui.textbox # 信息输入框实例化
|
|
|
self.regs = {"R1": self.alu.r1, "R2": self.alu.r2, "R3": self.alu.r3, "R4": self.alu.r4} # 寄存器值槽
|
|
|
self.sing_times1 = 0 # 取数指令的节拍计数变量
|
|
|
self.sing_times2 = 0 # 存数指令的节拍
|
|
|
self.menu_test()
|
|
|
self.show_msg() # 显示消息框
|
|
|
self.manual_opera_step = 0
|
|
|
self.entry_replace(self.sing.pc_reg, f"{0:016b}")
|
|
|
self.ctrl_stop = False
|
|
|
|
|
|
self.register_mapping = {
|
|
|
"01": (self.alu.r2, "mco-r2"),
|
|
|
"10": (self.alu.r3, "mco-r3"),
|
|
|
"11": (self.alu.r4, "mco-r4"),
|
|
|
"00": (self.alu.r1, "mco-r1"),
|
|
|
}
|
|
|
|
|
|
# self.textbox.msg_box("kkxs")
|
|
|
|
|
|
def reset(self):
|
|
|
self.__init__()
|
|
|
self.textbox.clear()
|
|
|
|
|
|
def stop_exec(self):
|
|
|
if self.ctrl_stop == True:
|
|
|
self.ctrl_stop = False
|
|
|
self.ctrl_exec.config(text="暂停执行")
|
|
|
self.exec_auto()
|
|
|
else:
|
|
|
self.ctrl_stop = True
|
|
|
self.ctrl_exec.config(text="继续执行")
|
|
|
|
|
|
def show_msg(self):
|
|
|
"""显示固定信息"""
|
|
|
self.textbox.reset_button.configure(command=self.reset)
|
|
|
self.textbox.canvas.delete("button")
|
|
|
self.textbox.main_msg_box("系统控制", 0, 0)
|
|
|
self.textbox.create_button("自动执行指令", x=1, y=0, command=self.exec_auto)
|
|
|
self.ctrl_exec = self.textbox.create_button("暂停执行", x=1, y=1, command=self.stop_exec)
|
|
|
self.prev_button = self.textbox.create_button("上一步", x=2, y=0, command=self.prev)
|
|
|
self.next_button = self.textbox.create_button("下一步", x=2, y=1, command=self.exec_next)
|
|
|
page2 = self.textbox.page2
|
|
|
self.textbox.main_msg_box("运算器控制", 0, 0, page2)
|
|
|
self.textbox.create_button("更改运算", x=1, y=0, frame=page2, command=self.manual_opera_io)
|
|
|
self.textbox.create_button("更改输入输出", x=1, y=1, frame=page2, command=self.manual_opera_io)
|
|
|
self.textbox.create_button("更改R1-R4", x=3, y=1, frame=page2, command=self.manual_reg)
|
|
|
self.alu_reg = self.textbox.create_combobox(x=3, y=0, frame=page2, values=["R1", "R2", "R3", "R4"])
|
|
|
self.alu_reg_value = self.textbox.create_entry(x=2, y=0, frame=page2)
|
|
|
page3 = self.textbox.page3
|
|
|
self.textbox.main_msg_box("信号控制", 0, 0, page3)
|
|
|
self.textbox.create_button("自动连续执行", x=1, y=0, frame=page3, command=self.exec_auto)
|
|
|
self.textbox.create_button("单指令执行", x=2, y=0, frame=page3, command=self.one_instruct)
|
|
|
self.textbox.create_button("更改信号", x=3, y=0, frame=page3, command=self.modify_sing)
|
|
|
self.textbox.create_button("更改REG", x=1, y=1, frame=page3, command=self.modify_ctrl_reg)
|
|
|
sing_obj = ['->R1', '->R2', '->R3', '->R4', '->IR', '->ALU', '->PC+1', '->Memory']
|
|
|
self.sing_single = self.textbox.create_combobox(x=3, y=1, frame=page3, values=list(sing_obj))
|
|
|
sing_inscode = inscode_map.keys() # 获取指令
|
|
|
self.sing_instruct = self.textbox.create_combobox(x=2, y=1, frame=page3, values=list(sing_inscode))
|
|
|
page4 = self.textbox.page4
|
|
|
self.textbox.main_msg_box("内存控制", 0, 0, page4)
|
|
|
self.textbox.create_button("更改内存REG", x=1, y=0, frame=page4, command=self.modify_memo_reg)
|
|
|
self.textbox.create_button("更改部分储存", x=1, y=1, frame=page4, command=self.manual_input)
|
|
|
self.textbox.create_button("装载一段程序", x=2, y=0, frame=page4, command=self.read_file)
|
|
|
self.textbox.create_button("装载一批数据", x=2, y=1, frame=page4, command=self.load_many_data)
|
|
|
def one_instruct(self):
|
|
|
inscode = self.sing_instruct.get()
|
|
|
inscode = inscode_map[inscode]
|
|
|
self.exe_one_instruct(inscode)
|
|
|
def modify_sing(self):
|
|
|
sing = self.sing_single.get()
|
|
|
cpu_data.SigObj[sing][1] = True
|
|
|
self.sing.show_singe()
|
|
|
print(sing)
|
|
|
def manual_reg(self): # 手动更改寄存器
|
|
|
reg = self.alu_reg.get()
|
|
|
value = self.alu_reg_value.get()
|
|
|
self.entry_replace(self.regs[reg], value)
|
|
|
self.textbox.send_msg("更改成功")
|
|
|
def modify_memo_reg(self): # 更改控制器寄存器
|
|
|
def n_mco_button():
|
|
|
value = self.n_mco.get()
|
|
|
self.entry_replace(self.memo.mco, value)
|
|
|
self.textbox.send_msg("更改成功")
|
|
|
def n_mad_button():
|
|
|
value = self.n_mad.get()
|
|
|
self.memo.show_maddr(value)
|
|
|
self.textbox.send_msg("更改成功")
|
|
|
top = tk.Toplevel()
|
|
|
top.title("内存寄存器修改")
|
|
|
# top.geometry(f"{460}x{200}")
|
|
|
tk.Label(top, text="新Mcontent值：", font=('微软雅黑', 16)).grid(row=0, column=0, padx=5, pady=5, sticky="e")
|
|
|
self.n_mco = tk.Entry(top, font=('微软雅黑', 12), width=16)
|
|
|
self.n_mco.grid(row=0, column=1, padx=5, pady=5)
|
|
|
tk.Button(top, text="确定", font=('微软雅黑', 12), width=10, bg="white", command=n_mco_button) \
|
|
|
.grid(row=0, column=2, padx=5, pady=5)
|
|
|
|
|
|
tk.Label(top, text="新Maddr值：", font=('微软雅黑', 16)).grid(row=1, column=0, padx=5, pady=5, sticky="e")
|
|
|
self.n_mad = tk.Entry(top, font=('微软雅黑', 12), width=16)
|
|
|
self.n_mad.grid(row=1, column=1, padx=5, pady=5)
|
|
|
tk.Button(top, text="确定", font=('微软雅黑', 12), width=10, bg="white", command=n_mad_button) \
|
|
|
.grid(row=1, column=2, padx=5, pady=5)
|
|
|
def load_many_data(self): # 更改控制器寄存器
|
|
|
def load_memo_finish():
|
|
|
start = self.memo_addr.get()
|
|
|
start = int(start, 16)
|
|
|
data = self.memo_text.get("1.0", "end")
|
|
|
data = data.split("\n")
|
|
|
for index, line in enumerate(data):
|
|
|
line = line.replace("\n", "")
|
|
|
if index+start < 20 and re.match("^[01]{16}$", line):
|
|
|
self.memo.mem_save(index+start, line, load=True)
|
|
|
self.textbox.send_msg(f"【{index+start:02X}】数据装载完成")
|
|
|
else:
|
|
|
if index+start > 19:
|
|
|
break
|
|
|
elif line == "":
|
|
|
self.textbox.send_msg(f"【{index+start:02X}】数据异常请检查")
|
|
|
top = tk.Toplevel()
|
|
|
top.title("装载一批数据")
|
|
|
top.geometry(f"{245}x{330}")
|
|
|
tk.Label(top, text="起始地址：", font=('微软雅黑', 16)).grid(row=0, column=0, padx=5, pady=5, sticky="e")
|
|
|
self.memo_addr = ttk.Combobox(top, values=[f"{i:02X}" for i in range(20)], width=10, font=('微软雅黑', 12))
|
|
|
self.memo_addr.grid(row=0, column=1, padx=5, pady=5)
|
|
|
self.memo_text = tk.Text(top, font=('微软雅黑', 12), width=16, height=10)
|
|
|
self.memo_text.grid(row=1, column=0, columnspan=2, padx=5, pady=5)
|
|
|
tk.Button(top, text="确定", font=('微软雅黑', 12), width=10, bg="white", command=load_memo_finish) \
|
|
|
.grid(row=2, column=1, padx=5, pady=5)
|
|
|
def modify_ctrl_reg(self): # 更改控制器寄存器
|
|
|
def n_pc_button():
|
|
|
value = self.n_pc.get()
|
|
|
self.entry_replace(self.sing.pc_reg, value)
|
|
|
self.textbox.send_msg("更改成功")
|
|
|
def n_ir_button():
|
|
|
value = self.n_ir.get()
|
|
|
self.entry_replace(self.sing.ir_reg, value)
|
|
|
self.sing.ir_reg_value() # 更新IR的值
|
|
|
self.textbox.send_msg("更改成功")
|
|
|
|
|
|
def n_clock_button():
|
|
|
value = self.n_clock.get()
|
|
|
self.sing.clo_mark(int(value) - 1)
|
|
|
self.textbox.send_msg("更改成功")
|
|
|
|
|
|
def n_inscode_button():
|
|
|
value = self.n_inscode.get()
|
|
|
self.entry_replace(self.sing.ins, value)
|
|
|
self.textbox.send_msg("更改成功")
|
|
|
|
|
|
top = tk.Toplevel()
|
|
|
top.title("控制器控制")
|
|
|
top.geometry(f"{450}x{200}")
|
|
|
tk.Label(top, text="新PC值：", font=('微软雅黑', 16)).grid(row=0, column=0, padx=5, pady=5, sticky="e")
|
|
|
self.n_pc = tk.Entry(top, font=('微软雅黑', 12), width=16)
|
|
|
self.n_pc.grid(row=0, column=1, padx=5, pady=5)
|
|
|
tk.Button(top, text="确定", font=('微软雅黑', 12), width=10, bg="white", command=n_pc_button) \
|
|
|
.grid(row=0, column=2, padx=5, pady=5)
|
|
|
tk.Label(top, text="新IR值：", font=('微软雅黑', 16)).grid(row=1, column=0, padx=5, pady=5, sticky="e")
|
|
|
self.n_ir = tk.Entry(top, font=('微软雅黑', 12), width=16)
|
|
|
self.n_ir.grid(row=1, column=1, padx=5, pady=5)
|
|
|
tk.Button(top, text="确定", font=('微软雅黑', 12), width=10, bg="white", command=n_ir_button) \
|
|
|
.grid(row=1, column=2, padx=5, pady=5)
|
|
|
tk.Label(top, text="新Clock值：", font=('微软雅黑', 16)).grid(row=2, column=0, padx=5, pady=5, sticky="e")
|
|
|
self.n_clock = tk.Entry(top, font=('微软雅黑', 12), width=16)
|
|
|
self.n_clock.grid(row=2, column=1, padx=5, pady=5)
|
|
|
tk.Button(top, text="确定", font=('微软雅黑', 12), width=10, bg="white", command=n_clock_button) \
|
|
|
.grid(row=2, column=2, padx=5, pady=5)
|
|
|
tk.Label(top, text="新Inscode值：", font=('微软雅黑', 16)).grid(row=3, column=0, padx=5, pady=5, sticky="e")
|
|
|
self.n_inscode = tk.Entry(top, font=('微软雅黑', 12), width=16)
|
|
|
self.n_inscode.grid(row=3, column=1, padx=5, pady=5)
|
|
|
tk.Button(top, text="确定", font=('微软雅黑', 12), width=10, bg="white", command=n_inscode_button) \
|
|
|
.grid(row=3, column=2, padx=5, pady=5)
|
|
|
|
|
|
def manual_opera_io(self): # 手动更改运算
|
|
|
values = list(cpu_data.ALUio.keys())
|
|
|
|
|
|
def ok():
|
|
|
in1_val = self.in1.get()
|
|
|
in2_val = self.in2.get()
|
|
|
out_val = self.out.get()
|
|
|
opera_val = self.opera_op.get()
|
|
|
|
|
|
for io in cpu_data.ALUio:
|
|
|
cpu_data.ALUio[io] = False # 重置所有输入输出
|
|
|
cpu_data.ALUio[in1_val] = True
|
|
|
cpu_data.ALUio[in2_val] = True
|
|
|
cpu_data.ALUio[out_val] = True
|
|
|
self.alu.show_alu_line(cpu_data.ALUio) # 显示数据控制线
|
|
|
|
|
|
for op in cpu_data.ALUop:
|
|
|
cpu_data.ALUop[op] = False # 重置所有操作
|
|
|
cpu_data.ALUop[opera_val] = True
|
|
|
self.alu.alu_operation()
|
|
|
|
|
|
top = tk.Toplevel()
|
|
|
top.title("运算器控制")
|
|
|
top.geometry(f"{360}x{180}")
|
|
|
tk.Label(top, text="ALU输入", font=('微软雅黑', 16)).grid(row=0, column=0, padx=5, pady=5)
|
|
|
tk.Label(top, text="ALU输出", font=('微软雅黑', 16)).grid(row=1, column=0, padx=5, pady=5)
|
|
|
tk.Label(top, text="运算符", font=('微软雅黑', 16)).grid(row=2, column=0, padx=5, pady=5)
|
|
|
self.in1 = ttk.Combobox(top, values=values, width=10, font=('微软雅黑', 12))
|
|
|
self.in1.set(values[0]) # 设置默认选项
|
|
|
self.in1.grid(row=0, column=1, padx=5, pady=5)
|
|
|
self.in2 = ttk.Combobox(top, values=values, width=10, font=('微软雅黑', 12))
|
|
|
self.in2.set(values[0]) # 设置默认选项
|
|
|
self.in2.grid(row=0, column=2, padx=5, pady=5)
|
|
|
self.out = ttk.Combobox(top, values=values, width=10, font=('微软雅黑', 12))
|
|
|
self.out.set(values[0]) # 设置默认选项
|
|
|
self.out.grid(row=1, column=1, padx=5, pady=5)
|
|
|
self.opera_op = ttk.Combobox(top, values=["+", "-", "x", "÷"], width=10, font=('微软雅黑', 12))
|
|
|
self.opera_op.set("+") # 设置默认选项
|
|
|
self.opera_op.grid(row=2, column=1, padx=5, pady=5)
|
|
|
|
|
|
tk.Button(top, text="确定", font=('微软雅黑', 12), width=10, bg="white", command=ok) \
|
|
|
.grid(row=8, column=1, padx=5, pady=5)
|
|
|
|
|
|
def menu_test(self):
|
|
|
menu_bar = tk.Menu(root)
|
|
|
root.config(menu=menu_bar)
|
|
|
|
|
|
font = ("son", 12)
|
|
|
|
|
|
lode_menu = tk.Menu(menu_bar, tearoff=0)
|
|
|
menu_bar.add_cascade(label="装载程序", menu=lode_menu, font=font)
|
|
|
lode_menu.add_command(label="从文件装载", command=self.read_file, font=font)
|
|
|
lode_menu.add_command(label="手动输入", command=self.manual_input, font=font)
|
|
|
|
|
|
file_menu = tk.Menu(menu_bar, tearoff=0)
|
|
|
menu_bar.add_cascade(label="单指令执行", menu=file_menu)
|
|
|
|
|
|
file_menu.add_command(label="取数", command=lambda: self.exe_one_instruct("000001"))
|
|
|
file_menu.add_command(label="存数", command=lambda: self.exe_one_instruct("000010"))
|
|
|
file_menu.add_command(label="加法", command=lambda: self.exe_one_instruct("000011"))
|
|
|
file_menu.add_command(label="减法", command=lambda: self.exe_one_instruct("000111"))
|
|
|
file_menu.add_command(label="乘法", command=lambda: self.exe_one_instruct("000100"))
|
|
|
file_menu.add_command(label="除法", command=lambda: self.exe_one_instruct("001000"))
|
|
|
file_menu.add_command(label="打印", command=lambda: self.exe_one_instruct("000101"))
|
|
|
file_menu.add_command(label="停机", command=lambda: self.exe_one_instruct("000110"))
|
|
|
file_menu.add_command(label="顺序执行", command=lambda: self.exec_auto())
|
|
|
|
|
|
def entry_replace(self, entry: tk.Entry, value):
|
|
|
entry.delete(0, tk.END)
|
|
|
entry.insert(0, value)
|
|
|
|
|
|
def binary_addition(self, num1, num2):
|
|
|
result = bin_to_dec(num1) + bin_to_dec(num2) # 转为10进制的加
|
|
|
result_binary = dec_to_bin(result)
|
|
|
return result_binary
|
|
|
|
|
|
def binary_subtraction(self, num1, num2):
|
|
|
result = bin_to_dec(num1) - bin_to_dec(num2) # 转为10进制的减
|
|
|
result_binary = dec_to_bin(result)
|
|
|
return result_binary
|
|
|
|
|
|
def binary_multiplication(self, num1, num2):
|
|
|
result = bin_to_dec(num1) * bin_to_dec(num2) # 转为10进制的加
|
|
|
result_binary = dec_to_bin(result)
|
|
|
return result_binary
|
|
|
|
|
|
def binary_division(self, dividend, divisor):
|
|
|
quotient = bin_to_dec(dividend) // bin_to_dec(divisor)
|
|
|
result_binary = dec_to_bin(quotient)
|
|
|
return result_binary
|
|
|
# remainder = bin(int(dividend, 2) % int(divisor, 2))[2:]
|
|
|
|
|
|
def reg_enhance_display(self, rx):
|
|
|
"""强化显示R1-R4"""
|
|
|
self.alu.canvas.delete("reg")
|
|
|
for i in range(4):
|
|
|
if rx == f"R{i + 1}":
|
|
|
self.alu.canvas.create_line(365, 120 + i * 90, 513, 120 + i * 90, width=8, fill="#00FF00", tag="reg")
|
|
|
self.alu.canvas.create_line(365, 75 + i * 90, 513, 75 + i * 90, width=8, fill="#00FF00", tag="reg")
|
|
|
|
|
|
def gen_opera(self, rx=None, ry=None, op=None, sing_num=None): # 一般计算规则
|
|
|
"""
|
|
|
rx为小号寄存器，ry为大号寄存器
|
|
|
寄存器字母一定要填大写
|
|
|
"""
|
|
|
for io in cpu_data.ALUio:
|
|
|
cpu_data.ALUio[io] = False # 清空ALU的数据线
|
|
|
|
|
|
if op is not None:
|
|
|
cpu_data.ALUop[op] = True # 设置ALU的操作
|
|
|
|
|
|
rt1, rt2 = None, None # 用于存储寄存器的实体框
|
|
|
for reg, entry in self.regs.items(): # 遍历寄存器编号和寄存器实体框
|
|
|
entry.config(bg=WHITE) # 寄存器恢复
|
|
|
if reg == rx:
|
|
|
rt1 = entry
|
|
|
if sing_num == 4:
|
|
|
cpu_data.ALUio[f"{rx}_ALU_1"] = True
|
|
|
if reg == ry:
|
|
|
rt2 = entry
|
|
|
if sing_num == 4:
|
|
|
cpu_data.ALUio[f"{ry}_ALU_2"] = True
|
|
|
if rx is not None and ry is not None:
|
|
|
v1 = rt1.get() # 获取R1的值
|
|
|
v2 = rt2.get() # 获取R2的值
|
|
|
|
|
|
if sing_num == 4:
|
|
|
self.alu.show_alu_line(cpu_data.ALUio) # 节拍5时显示寄存器到ALU的路线
|
|
|
self.alu.alu_operation() # 显示符号
|
|
|
rt1.config(bg=RED)
|
|
|
rt2.config(bg=RED)
|
|
|
if sing_num == 5:
|
|
|
if op == "+":
|
|
|
v = self.binary_addition(v1, v2) # 二进制加
|
|
|
elif op == "-":
|
|
|
v = self.binary_subtraction(v1, v2) # 二进制减法
|
|
|
elif op == "x":
|
|
|
v = self.binary_multiplication(v1, v2) # 二进制乘法
|
|
|
elif op == "÷":
|
|
|
v = self.binary_division(v1, v2) # 二进制除法
|
|
|
else:
|
|
|
v = None
|
|
|
# alu_line.append(f"ALU_{rx}") # 用于显示ALU的数据线
|
|
|
cpu_data.ALUio[f"ALU_{rx}"] = True
|
|
|
|
|
|
self.alu.alu_operation() # 显示符号
|
|
|
self.alu.show_alu_line(cpu_data.ALUio) # 显示数据控制线
|
|
|
self.entry_replace(rt1, f"{v}") # 替换R1中的值
|
|
|
rt1.config(bg=RED)
|
|
|
|
|
|
def pc_add_one(self, b16):
|
|
|
v = int(b16, 2)
|
|
|
return f"{v + 1:016b}"
|
|
|
|
|
|
def reg_update(self):
|
|
|
self.sing.pc_reg.config(bg=WHITE) # 更新PC寄存器的背景显示
|
|
|
self.sing.ins.config(bg=WHITE) # 更新ins背景
|
|
|
self.sing.ir_reg.config(bg=WHITE) # 更新IR的颜色
|
|
|
self.alu.r1.config(bg=WHITE)
|
|
|
self.alu.r2.config(bg=WHITE)
|
|
|
self.alu.r3.config(bg=WHITE)
|
|
|
self.alu.r4.config(bg=WHITE)
|
|
|
|
|
|
# 储存寄存器在储存类中已经处理，这里不再重复处理
|
|
|
|
|
|
def read_file(self):
|
|
|
filename = filedialog.askopenfilename(title="选择文件", filetypes=[("TXT文件", "*.txt")])
|
|
|
if filename:
|
|
|
with open(filename, "r", encoding="utf8") as f:
|
|
|
memo_line = f.readlines() # 按行读取文件信息
|
|
|
for index, line in enumerate(memo_line):
|
|
|
line = line.replace("\n", "") # 去掉换行符
|
|
|
if index < 20 and re.match("^[01]{16}$", line):
|
|
|
self.memo.mem_save(index, line, load=True)
|
|
|
else:
|
|
|
self.textbox.send_msg(f"【{index:02X}】数据异常请检查")
|
|
|
if index > 19:
|
|
|
break
|
|
|
self.textbox.send_msg("装载完成")
|
|
|
self.entry_replace(self.sing.pc_reg, f"{0:016b}")
|
|
|
|
|
|
def on_inscode_select(self, event):
|
|
|
# 获取选择的值
|
|
|
selected_value = self.inscode_input.get()
|
|
|
inscode = inscode_map.get(selected_value)
|
|
|
self.inscode_input.set(inscode)
|
|
|
print(selected_value)
|
|
|
|
|
|
def load_finish(self):
|
|
|
self.child_window.destroy()
|
|
|
self.entry_replace(self.sing.pc_reg, f"{0:016b}")
|
|
|
self.textbox.send_msg("装载完成")
|
|
|
|
|
|
def on_offset_select(self, event):
|
|
|
ox16 = self.o_value_input.get()
|
|
|
value = int(ox16, 16)
|
|
|
self.o_value_input.set(f"{value:010b}")
|
|
|
|
|
|
def data_to_mome(self, offset_input):
|
|
|
data_input = self.d_value.get()
|
|
|
if offset_input and data_input:
|
|
|
offset = int(offset_input, 16)
|
|
|
if re.match("^-?[01]{16}$", data_input):
|
|
|
self.memo.mem_save(offset, data_input, load=True)
|
|
|
self.textbox.send_msg("数据装载完成\n" + f"{offset:02X}：{data_input}")
|
|
|
elif re.match("^-?\d+$", data_input) and len(data_input) < 7: # 如果是10进制数不可能多于7位
|
|
|
# data_input = f"{int(data_input):016b}"
|
|
|
data_input = cpu_data.dec_to_bin(int(data_input))
|
|
|
self.memo.mem_save(offset, data_input, load=True)
|
|
|
self.textbox.send_msg("数据装载完成\n" + f"{offset:02X}：{data_input}")
|
|
|
else:
|
|
|
if len(data_input) > 16:
|
|
|
self.textbox.send_msg(f"{data_input}不是16位数。")
|
|
|
else:
|
|
|
self.textbox.send_msg(f"{data_input}不是规范的二进制数。")
|
|
|
|
|
|
def save_to_mome(self, offset):
|
|
|
inscode = self.inscode_input.get()
|
|
|
value = self.o_value_input.get()
|
|
|
if offset:
|
|
|
offset = int(offset, 16)
|
|
|
if inscode and value:
|
|
|
value = inscode + value
|
|
|
self.memo.mem_save(offset, value, load=True)
|
|
|
self.textbox.send_msg(f"指令装载完成\n{offset:02X}：{value}")
|
|
|
|
|
|
def manual_input(self):
|
|
|
self.child_window = tk.Toplevel(root)
|
|
|
self.child_window.title("手动输入程序")
|
|
|
self.child_window.geometry("350x360")
|
|
|
fram_down = tk.Frame(self.child_window)
|
|
|
tk.Label(fram_down, text="指令输入", font=("微软雅黑", 16, "bold")).grid(row=0, column=0, columnspan=3)
|
|
|
fram_down.place(x=0, y=0, width=350, height=360)
|
|
|
offset_label = tk.Label(fram_down, text="地址", font=("微软雅黑", 16))
|
|
|
offset_label.grid(row=1, column=0, sticky="nsew")
|
|
|
inscode_label = tk.Label(fram_down, text="指令", font=("微软雅黑", 16))
|
|
|
inscode_label.grid(row=1, column=1, sticky="nsew")
|
|
|
o_value_label = tk.Label(fram_down, text="寻址地址", font=("微软雅黑", 16))
|
|
|
o_value_label.grid(row=1, column=2, sticky="nsew")
|
|
|
hex_options = [f"{i:02X}" for i in range(20)] # 生成00-13的16进制选项
|
|
|
offset_input = ttk.Combobox(fram_down, values=hex_options, font=("微软雅黑", 12), width=1)
|
|
|
offset_input.grid(row=2, column=0, sticky="nsew", padx=5)
|
|
|
inscode_options = list(inscode_map.keys())
|
|
|
self.inscode_input = ttk.Combobox(fram_down, values=inscode_options, font=("微软雅黑", 12), width=6)
|
|
|
self.inscode_input.grid(row=2, column=1, sticky="nsew", padx=5)
|
|
|
self.inscode_input.bind("<<ComboboxSelected>>", self.on_inscode_select)
|
|
|
bin_options = [f"{i:02X}" for i in range(20)] # 生成00-13的16进制选项
|
|
|
self.o_value_input = ttk.Combobox(fram_down, values=bin_options, font=("微软雅黑", 12), width=10)
|
|
|
self.o_value_input.grid(row=2, column=2, sticky="nsew", padx=5)
|
|
|
self.o_value_input.bind("<<ComboboxSelected>>", self.on_offset_select)
|
|
|
save_b = tk.Button(fram_down, text="确认", bg=RED, font=("微软雅黑", 12),
|
|
|
command=lambda: self.save_to_mome(offset_input.get()))
|
|
|
save_b.grid(row=3, column=0, columnspan=3, sticky="nsew", padx=10, pady=4)
|
|
|
tk.Label(fram_down, text="*" * 300, font=("微软雅黑", 16)).grid(row=4, column=0, columnspan=3)
|
|
|
tk.Label(fram_down, text="数据输入", font=("微软雅黑", 16, "bold")).grid(row=5, column=0, columnspan=3)
|
|
|
d_off = tk.Label(fram_down, text="地址", font=("微软雅黑", 16))
|
|
|
d_off.grid(row=6, column=0, sticky="nsew")
|
|
|
d_value_lb = tk.Label(fram_down, text="数据", font=("微软雅黑", 16))
|
|
|
d_value_lb.grid(row=6, column=1, columnspan=2, sticky="nsew")
|
|
|
hex_options = [f"{i:02X}" for i in range(20)] # 生成00-13的16进制选项
|
|
|
d_off_in = ttk.Combobox(fram_down, values=hex_options, font=("微软雅黑", 12), width=1)
|
|
|
d_off_in.grid(row=7, column=0, sticky="nsew", padx=5)
|
|
|
self.d_value = tk.Entry(fram_down, font=("微软雅黑", 12))
|
|
|
self.d_value.grid(row=7, column=1, columnspan=2, sticky="nsew")
|
|
|
self.d_value.insert(0, "支持10进制和16位进制")
|
|
|
d_save = tk.Button(fram_down, text="确认", bg=RED, font=("微软雅黑", 12),
|
|
|
command=lambda: self.data_to_mome(d_off_in.get()))
|
|
|
d_save.grid(row=8, column=0, columnspan=3, sticky="nsew", padx=10, pady=4)
|
|
|
# 配置列权重，使它们按比例占据整个宽度
|
|
|
fram_down.columnconfigure(0, weight=2)
|
|
|
fram_down.columnconfigure(1, weight=6)
|
|
|
fram_down.columnconfigure(2, weight=10)
|
|
|
finish = tk.Button(fram_down, text="装载完成", bg=GOLD, font=("微软雅黑", 12), command=self.load_finish)
|
|
|
finish.grid(row=9, column=2, sticky="nsew", padx=10)
|
|
|
|
|
|
def SimGet(self, sing_num, reg_code=None):
|
|
|
"""取数指令"""
|
|
|
self.textbox.send_instr("取数")
|
|
|
if sing_num == 3:
|
|
|
self.textbox.send_msg(f"======Step{sing_num + 1}======")
|
|
|
self.reg_update() # 恢复寄存器
|
|
|
self.sing.clo_mark(sing_num) # 显示节拍
|
|
|
cpu_data.SigObj['->Memory'][1] = True
|
|
|
self.sing.show_singe() # 显示控制器信号
|
|
|
self.gui.addr_line() # 更新地址线
|
|
|
self.alu.show_alu_line() # 更新alu的数据线
|
|
|
self.memo.mad_to_memo(1) # 更新mad-mome的地址线,参数为真则显示
|
|
|
cpu_data.SigObj['Memory->Mcontent'][1] = True
|
|
|
self.gui.singe_ctrl_line() # 显示控制线
|
|
|
|
|
|
if reg_code in self.register_mapping: # 选择寄存器
|
|
|
register, data_line = self.register_mapping[reg_code]
|
|
|
self.gui.data_line(data_line)
|
|
|
self.entry_replace(register, self.memo.mco.get())
|
|
|
register.config(bg=RED)
|
|
|
canvas.update()
|
|
|
|
|
|
def SimPut(self, sing_num, reg_code=None):
|
|
|
"""存数指令"""
|
|
|
self.textbox.send_instr("存数")
|
|
|
if sing_num == 3:
|
|
|
self.textbox.send_msg(f"======Step{sing_num + 1}======")
|
|
|
if reg_code in self.register_mapping: # 选择寄存器
|
|
|
register, data_line = self.register_mapping[reg_code]
|
|
|
mco, reg = data_line.split("-")
|
|
|
|
|
|
self.reg_update() # 恢复寄存器
|
|
|
self.sing.clo_mark(sing_num)
|
|
|
cpu_data.SigObj['->Memory'][1] = True
|
|
|
self.sing.show_singe() # 显示控制器信号
|
|
|
cpu_data.SigObj['Mcontent->Memory'][1] = True
|
|
|
self.gui.singe_ctrl_line()
|
|
|
self.gui.addr_line()
|
|
|
# self.gui.data_line("r1-mco")
|
|
|
self.alu.show_alu_line() # 更新alu的数据线
|
|
|
# self.memo.mad_to_memo() # 更新mad-mome的地址线,参数为真则显示
|
|
|
self.memo.mco_to_memo() # 更新储存的显示显示
|
|
|
|
|
|
self.gui.data_line(f"{reg}-{mco}") # 重构参数
|
|
|
self.entry_replace(self.memo.mco, register.get())
|
|
|
register.config(bg=RED)
|
|
|
|
|
|
self.memo.mco_to_memo() # 显示
|
|
|
canvas.update()
|
|
|
|
|
|
def SimAddr(self, sing_num, reg_code=None):
|
|
|
"""加法指令"""
|
|
|
self.textbox.send_instr("加法")
|
|
|
|
|
|
if sing_num == 3:
|
|
|
self.textbox.send_msg(f"======Step{sing_num + 1}======")
|
|
|
if reg_code in self.register_mapping: # 选择寄存器
|
|
|
register, data_line = self.register_mapping[reg_code]
|
|
|
mco, reg = data_line.split("-")
|
|
|
reg = int(reg[-1]) + 1
|
|
|
|
|
|
self.reg_update()
|
|
|
self.sing.clo_mark(sing_num) # 显示节拍
|
|
|
cpu_data.SigObj['->Memory'][1] = True
|
|
|
self.sing.show_singe() # 显示控制器信号
|
|
|
cpu_data.SigObj[f'Mcontent->R{reg}'][1] = True
|
|
|
cpu_data.SigObj[f'->R{reg}'][1] = True
|
|
|
self.gui.singe_ctrl_line() # 显示控制线
|
|
|
self.gui.addr_line() # 更新地址线
|
|
|
self.memo.mad_to_memo(1) # 更新mad-mome的地址线,参数为真则显示
|
|
|
self.gui.data_line(f"mco-r{reg}") # 更新数据线
|
|
|
self.alu.show_alu_line() # 更新alu的数据线
|
|
|
|
|
|
# self.memo.mad_to_memo() # 显示memo动画
|
|
|
self.entry_replace(eval(f'self.alu.r{reg}'), self.memo.mco.get()) # 更新显示R1中的值
|
|
|
canvas.update()
|
|
|
|
|
|
if sing_num == 4:
|
|
|
self.textbox.send_msg(f"======Step{sing_num + 1}======")
|
|
|
if reg_code in self.register_mapping: # 选择寄存器
|
|
|
register, data_line = self.register_mapping[reg_code]
|
|
|
mco, reg = data_line.split("-")
|
|
|
reg = int(reg[-1]) + 1
|
|
|
|
|
|
self.reg_update()
|
|
|
self.sing.clo_mark(sing_num) # 显示节拍
|
|
|
cpu_data.SigObj['->ALU'][1] = True
|
|
|
self.sing.show_singe() # 显示控制器信号
|
|
|
cpu_data.SigObj['->ALU'][1] = True
|
|
|
self.gui.singe_ctrl_line() # 显示控制线
|
|
|
self.gui.addr_line() # 更新地址线
|
|
|
self.gui.data_line() # 更新数据线
|
|
|
self.memo.mad_to_memo() # 更新mad-mome的地址线,参数为真则显示
|
|
|
self.alu.show_alu_line() # 更新alu的数据线
|
|
|
|
|
|
self.gen_opera(f"R{reg - 1}", f"R{reg}", "+", sing_num)
|
|
|
canvas.update()
|
|
|
|
|
|
if sing_num == 5:
|
|
|
self.textbox.send_msg(f"======Step{sing_num + 1}======")
|
|
|
if reg_code in self.register_mapping: # 查找寄存器
|
|
|
register, data_line = self.register_mapping[reg_code]
|
|
|
mco, reg = data_line.split("-")
|
|
|
reg = int(reg[-1]) + 1
|
|
|
|
|
|
self.reg_update()
|
|
|
self.sing.clo_mark(sing_num) # 显示节拍
|
|
|
self.sing.show_singe() # 显示控制器信号
|
|
|
self.gui.singe_ctrl_line() # 显示控制线
|
|
|
self.gui.addr_line() # 更新地址线
|
|
|
self.gui.data_line() # 更新数据线
|
|
|
self.memo.mad_to_memo() # 更新mad-mome的地址线,参数为真则显示
|
|
|
self.alu.show_alu_line() # 更新alu的数据线
|
|
|
|
|
|
self.gen_opera(f"R{reg - 1}", f"R{reg}", "+", sing_num)
|
|
|
canvas.update()
|
|
|
|
|
|
def SimMinus(self, sing_num, reg_code):
|
|
|
"""减法指令"""
|
|
|
self.textbox.send_instr(f"减法")
|
|
|
|
|
|
register, data_line = self.register_mapping[reg_code]
|
|
|
mco, reg = data_line.split("-")
|
|
|
reg = int(reg[-1]) + 1
|
|
|
|
|
|
if sing_num == 3:
|
|
|
self.textbox.send_msg(f"======Step{sing_num + 1}======")
|
|
|
self.reg_update()
|
|
|
self.sing.clo_mark(sing_num) # 显示节拍
|
|
|
cpu_data.SigObj['->Memory'][1] = True
|
|
|
self.sing.show_singe() # 显示控制器信号
|
|
|
cpu_data.SigObj[f'Mcontent->R{reg}'][1] = True
|
|
|
cpu_data.SigObj[f'->R{reg}'][1] = True
|
|
|
self.gui.singe_ctrl_line() # 显示控制线
|
|
|
self.gui.addr_line() # 更新地址线
|
|
|
self.memo.mad_to_memo(1) # 更新mad-mome的地址线,参数为真则显示
|
|
|
self.gui.data_line(f"mco-r{reg}") # 更新数据线
|
|
|
self.alu.show_alu_line() # 更新alu的数据线
|
|
|
|
|
|
self.entry_replace(eval(f"self.alu.r{reg}"), self.memo.mco.get()) # 更新显示R2中的值
|
|
|
canvas.update()
|
|
|
|
|
|
if sing_num == 4:
|
|
|
self.textbox.send_msg(f"======Step{sing_num + 1}======")
|
|
|
self.reg_update()
|
|
|
self.sing.clo_mark(sing_num) # 显示节拍
|
|
|
cpu_data.SigObj['->ALU'][1] = True
|
|
|
self.sing.show_singe() # 显示控制器信号
|
|
|
cpu_data.SigObj['->ALU'][1] = True
|
|
|
self.gui.singe_ctrl_line() # 显示控制线
|
|
|
self.gui.addr_line() # 更新地址线
|
|
|
self.gui.data_line() # 更新数据线
|
|
|
self.memo.mad_to_memo() # 更新mad-mome的地址线,参数为真则显示
|
|
|
self.alu.show_alu_line() # 更新alu的数据线
|
|
|
|
|
|
self.gen_opera(f"R{reg - 1}", f"R{reg}", "-", sing_num)
|
|
|
canvas.update()
|
|
|
|
|
|
if sing_num == 5:
|
|
|
self.textbox.send_msg(f"======Step{sing_num + 1}======")
|
|
|
self.reg_update()
|
|
|
self.sing.clo_mark(sing_num) # 显示节拍
|
|
|
self.sing.show_singe() # 显示控制器信号
|
|
|
self.gui.singe_ctrl_line() # 显示控制线
|
|
|
self.gui.addr_line() # 更新地址线
|
|
|
self.gui.data_line() # 更新数据线
|
|
|
self.memo.mad_to_memo() # 更新mad-mome的地址线,参数为真则显示
|
|
|
self.alu.show_alu_line() # 更新alu的数据线
|
|
|
|
|
|
self.gen_opera(f"R{reg - 1}", f"R{reg}", "-", sing_num)
|
|
|
canvas.update()
|
|
|
|
|
|
def SimProduct(self, sing_num, reg_code):
|
|
|
"""乘法指令"""
|
|
|
self.textbox.send_instr(f"乘法")
|
|
|
|
|
|
register, data_line = self.register_mapping[reg_code]
|
|
|
mco, reg = data_line.split("-")
|
|
|
reg = int(reg[-1]) + 1
|
|
|
|
|
|
if sing_num == 3:
|
|
|
self.textbox.send_msg(f"======Step{sing_num + 1}======")
|
|
|
self.reg_update()
|
|
|
self.sing.clo_mark(sing_num) # 显示节拍
|
|
|
cpu_data.SigObj['->Memory'][1] = True
|
|
|
self.sing.show_singe() # 显示控制器信号
|
|
|
cpu_data.SigObj[f'Mcontent->R{reg}'][1] = True
|
|
|
cpu_data.SigObj[f'->R{reg}'][1] = True
|
|
|
self.gui.singe_ctrl_line() # 显示控制线
|
|
|
self.gui.addr_line() # 更新地址线
|
|
|
self.memo.mad_to_memo(1) # 更新mad-mome的地址线,参数为真则显示
|
|
|
self.gui.data_line(f"mco-r{reg}") # 更新数据线
|
|
|
self.alu.show_alu_line() # 更新alu的数据线
|
|
|
|
|
|
self.entry_replace(eval(f"self.alu.r{reg}"), self.memo.mco.get()) # 更新显示R2中的值
|
|
|
canvas.update()
|
|
|
|
|
|
if sing_num == 4:
|
|
|
self.textbox.send_msg(f"======Step{sing_num + 1}======")
|
|
|
self.reg_update()
|
|
|
self.sing.clo_mark(sing_num) # 显示节拍
|
|
|
cpu_data.SigObj['->ALU'][1] = True
|
|
|
self.sing.show_singe() # 显示控制器信号
|
|
|
cpu_data.SigObj['->ALU'][1] = True
|
|
|
self.gui.singe_ctrl_line() # 显示控制线
|
|
|
self.gui.addr_line() # 更新地址线
|
|
|
self.gui.data_line() # 更新数据线
|
|
|
self.memo.mad_to_memo() # 更新mad-mome的地址线,参数为真则显示
|
|
|
self.alu.show_alu_line() # 更新alu的数据线
|
|
|
|
|
|
self.gen_opera(f"R{reg - 1}", f"R{reg}", "x", sing_num)
|
|
|
canvas.update()
|
|
|
|
|
|
if sing_num == 5:
|
|
|
self.textbox.send_msg(f"======Step{sing_num + 1}======")
|
|
|
self.reg_update()
|
|
|
self.sing.clo_mark(sing_num) # 显示节拍
|
|
|
self.sing.show_singe() # 显示控制器信号
|
|
|
self.gui.singe_ctrl_line() # 显示控制线
|
|
|
self.gui.addr_line() # 更新地址线
|
|
|
self.gui.data_line() # 更新数据线
|
|
|
self.memo.mad_to_memo() # 更新mad-mome的地址线,参数为真则显示
|
|
|
self.alu.show_alu_line() # 更新alu的数据线
|
|
|
|
|
|
self.gen_opera(f"R{reg - 1}", f"R{reg}", "x", sing_num)
|
|
|
canvas.update()
|
|
|
|
|
|
def SimDiv(self, sing_num, reg_code):
|
|
|
"""除法指令"""
|
|
|
self.textbox.send_instr(f"除法")
|
|
|
|
|
|
register, data_line = self.register_mapping[reg_code]
|
|
|
mco, reg = data_line.split("-")
|
|
|
reg = int(reg[-1]) + 1
|
|
|
|
|
|
if sing_num == 3:
|
|
|
self.textbox.send_msg(f"======Step{sing_num + 1}======")
|
|
|
self.reg_update()
|
|
|
self.sing.clo_mark(sing_num) # 显示节拍
|
|
|
cpu_data.SigObj['->Memory'][1] = True
|
|
|
self.sing.show_singe() # 显示控制器信号
|
|
|
cpu_data.SigObj[f'Mcontent->R{reg}'][1] = True
|
|
|
cpu_data.SigObj[f'->R{reg}'][1] = True
|
|
|
self.gui.singe_ctrl_line() # 显示控制线
|
|
|
self.gui.addr_line() # 更新地址线
|
|
|
self.memo.mad_to_memo(1) # 更新mad-mome的地址线,参数为真则显示
|
|
|
self.gui.data_line(f"mco-r{reg}") # 更新数据线
|
|
|
self.alu.show_alu_line() # 更新alu的数据线
|
|
|
|
|
|
self.entry_replace(eval(f"self.alu.r{reg}"), self.memo.mco.get()) # 更新显示R2中的值
|
|
|
canvas.update()
|
|
|
|
|
|
if sing_num == 4:
|
|
|
self.textbox.send_msg(f"======Step{sing_num + 1}======")
|
|
|
self.reg_update()
|
|
|
self.sing.clo_mark(sing_num) # 显示节拍
|
|
|
cpu_data.SigObj['->ALU'][1] = True
|
|
|
self.sing.show_singe() # 显示控制器信号
|
|
|
cpu_data.SigObj['->ALU'][1] = True
|
|
|
self.gui.singe_ctrl_line() # 显示控制线
|
|
|
self.gui.addr_line() # 更新地址线
|
|
|
self.gui.data_line() # 更新数据线
|
|
|
self.memo.mad_to_memo() # 更新mad-mome的地址线,参数为真则显示
|
|
|
self.alu.show_alu_line() # 更新alu的数据线
|
|
|
|
|
|
self.gen_opera(f"R{reg - 1}", f"R{reg}", "÷", sing_num)
|
|
|
canvas.update()
|
|
|
|
|
|
if sing_num == 5:
|
|
|
self.textbox.send_msg(f"======Step{sing_num + 1}======")
|
|
|
self.reg_update()
|
|
|
self.sing.clo_mark(sing_num) # 显示节拍
|
|
|
self.sing.show_singe() # 显示控制器信号
|
|
|
self.gui.singe_ctrl_line() # 显示控制线
|
|
|
self.gui.addr_line() # 更新地址线
|
|
|
self.gui.data_line() # 更新数据线
|
|
|
self.memo.mad_to_memo() # 更新mad-mome的地址线,参数为真则显示
|
|
|
self.alu.show_alu_line() # 更新alu的数据线0.
|
|
|
|
|
|
self.gen_opera(f"R{reg - 1}", f"R{reg}", "÷", sing_num)
|
|
|
canvas.update()
|
|
|
|
|
|
def SimPrint(self, sing_num):
|
|
|
self.textbox.send_instr("打印")
|
|
|
|
|
|
if sing_num == 3:
|
|
|
self.textbox.send_msg(f"======Step{sing_num + 1}======")
|
|
|
self.reg_update()
|
|
|
self.sing.clo_mark(sing_num) # 显示节拍
|
|
|
cpu_data.SigObj['->Memory'][1] = True
|
|
|
self.sing.show_singe() # 显示控制器信号
|
|
|
cpu_data.SigObj['->R1'][1] = True
|
|
|
cpu_data.SigObj['Mcontent->R1'][1] = True
|
|
|
self.gui.singe_ctrl_line() # 显示控制线
|
|
|
self.gui.addr_line() # 更新地址线
|
|
|
self.memo.mad_to_memo(1) # 更新mad-mome的地址线,参数为真则显示
|
|
|
self.gui.data_line("mco-r1") # 更新数据线
|
|
|
self.alu.show_alu_line() # 更新alu的数据线
|
|
|
|
|
|
self.entry_replace(self.alu.r1, self.memo.mco.get()) # 更新显示R2中的值
|
|
|
canvas.update()
|
|
|
|
|
|
if sing_num == 4:
|
|
|
self.textbox.send_msg(f"======Step{sing_num + 1}======")
|
|
|
self.reg_update()
|
|
|
self.sing.clo_mark(sing_num) # 显示节拍
|
|
|
cpu_data.SigObj['->R1'][1] = True # 更新R1的值
|
|
|
self.sing.show_singe() # 显示控制器信号
|
|
|
cpu_data.SigObj['->R1'][1] = True # 更新R1的值
|
|
|
self.gui.singe_ctrl_line() # 显示控制线
|
|
|
self.gui.addr_line() # 更新地址线
|
|
|
self.gui.data_line() # 更新数据线
|
|
|
self.memo.mad_to_memo() # 更新mad-mome的地址线,参数为真则显示
|
|
|
self.alu.show_alu_line() # 更新alu的数据线
|
|
|
|
|
|
val = self.alu.r1.get()
|
|
|
self.textbox.send_msg(f"打印输出：\n'{val}'")
|
|
|
binary_string = bin_to_dec(val)
|
|
|
self.textbox.send_msg(f"10进制转换：'{binary_string}'")
|
|
|
canvas.update()
|
|
|
|
|
|
# print(self.alu.r1.get())
|
|
|
|
|
|
def SimStop(self, sing_num):
|
|
|
self.textbox.send_instr("停机")
|
|
|
if sing_num == 3:
|
|
|
self.textbox.send_msg(f"======Step{sing_num + 1}======")
|
|
|
self.reg_update()
|
|
|
self.sing.clo_mark(sing_num) # 显示节拍
|
|
|
cpu_data.SigObj['->PC+1'][1] = True # 更新PC+1的值
|
|
|
self.sing.show_singe() # 显示控制器信号
|
|
|
cpu_data.SigObj['->PC+1'][1] = True # 更新PC+1的值
|
|
|
self.gui.singe_ctrl_line() # 显示控制线
|
|
|
|
|
|
self.gui.addr_line() # 更新地址线
|
|
|
self.gui.data_line() # 更新数据线
|
|
|
self.memo.mad_to_memo() # 更新mad-mome的地址线,参数为真则显示
|
|
|
self.alu.show_alu_line() # 更新alu的数据线
|
|
|
|
|
|
self.sing.pc_value = f"{0:016b}" # PC 置0
|
|
|
self.sing.pc_reg_value()
|
|
|
self.textbox.send_msg("PC = 0")
|
|
|
self.sing.pc_reg.config(bg=RED)
|
|
|
self.sing.ins.config(bg=RED)
|
|
|
canvas.update()
|
|
|
|
|
|
if sing_num == 4:
|
|
|
self.textbox.send_msg(f"======Step{sing_num + 1}======")
|
|
|
self.reg_update()
|
|
|
self.sing.clo_mark() # 显示节拍
|
|
|
self.sing.show_singe() # 显示控制器信号
|
|
|
self.gui.singe_ctrl_line() # 显示控制线
|
|
|
self.gui.addr_line() # 更新地址线
|
|
|
self.gui.data_line() # 更新数据线
|
|
|
self.memo.mad_to_memo() # 更新mad-mome的地址线,参数为真则显示
|
|
|
self.alu.show_alu_line() # 更新alu的数据线
|
|
|
self.textbox.send_msg("系统停机")
|
|
|
canvas.update()
|
|
|
|
|
|
def SimGoto(self, sing_num):
|
|
|
self.textbox.send_instr("跳转")
|
|
|
if sing_num == 3:
|
|
|
self.textbox.send_msg(f"======Step{sing_num + 1}======")
|
|
|
self.reg_update()
|
|
|
self.sing.clo_mark(sing_num) # 显示节拍
|
|
|
cpu_data.SigObj['->Memory'][1] = True # 更新Memory的值
|
|
|
self.sing.show_singe() # 显示控制器信号
|
|
|
cpu_data.SigObj['PC->Maddr'][1] = True
|
|
|
cpu_data.SigObj['Mcontent->PC'][1] = True
|
|
|
cpu_data.SigObj["->PC+1"][1] = True
|
|
|
self.gui.singe_ctrl_line() # 显示控制线
|
|
|
|
|
|
self.gui.addr_line() # 更新地址线
|
|
|
self.memo.mad_to_memo(1) # 更新mad-mome的地址线,参数为真则显示
|
|
|
self.gui.data_line("mco-pc") # 更新数据线
|
|
|
self.alu.show_alu_line() # 更新alu的数据线
|
|
|
|
|
|
mco_value = self.memo.mco.get()
|
|
|
self.entry_replace(self.sing.pc_reg, mco_value)
|
|
|
self.memo.mco.config(bg=RED)
|
|
|
self.sing.pc_reg.config(bg=RED)
|
|
|
canvas.update()
|
|
|
|
|
|
def lw_(self, one_inscode=None, is_meter=None, step=None):
|
|
|
'''
|
|
|
取指令
|
|
|
:param one_inscode: 执行模式,分单指令自动执行，和分节拍手动执行
|
|
|
:param is_meter: 控制是否为分节拍模式 True则表示分节拍执行
|
|
|
:param step: 节拍步骤
|
|
|
:return: 停机指令
|
|
|
'''
|
|
|
self.alu.show_alu_line(None) # 更新ALU的数据线
|
|
|
if step <= 2: # 前三节拍都更新取指令，后面的节拍更新其他指令
|
|
|
self.textbox.send_instr("取指令")
|
|
|
|
|
|
if step == 0:
|
|
|
self.textbox.send_msg(f"\n\n\n======Step{step + 1}======")
|
|
|
self.reg_update() # 更新各个寄存器颜色为白色
|
|
|
self.sing.clo_mark(step) # 显示节拍
|
|
|
|
|
|
cpu_data.SigObj['->Memory'][1] = True # 更新Memory的值
|
|
|
self.sing.show_singe() # 显示控制器信号
|
|
|
|
|
|
cpu_data.SigObj['PC->Maddr'][1] = True # 更新PC->Maddr的值
|
|
|
self.gui.singe_ctrl_line() # 显示信号控制线
|
|
|
|
|
|
cpu_data.SigObj['PC->Maddr'][1] = True # 更新PC->Maddr的值
|
|
|
self.gui.addr_line() # 显示地址线
|
|
|
|
|
|
self.gui.data_line() # 更新数据线
|
|
|
self.memo.mad_to_memo() # 更新mad-mome的地址线
|
|
|
|
|
|
self.alu.alu_operation() # 更新alu的符号
|
|
|
|
|
|
canvas.update() # 刷新显示
|
|
|
|
|
|
maddr = self.sing.pc_reg.get() # 获取pc寄存器的值
|
|
|
self.sing.pc_reg.config(bg=RED) # 更新PC寄存器的背景显示
|
|
|
self.memo.show_maddr(maddr, 1) # 更新maddr的显示和值
|
|
|
|
|
|
self.alu.show_alu_line(None) # 显示ALU的数据线
|
|
|
|
|
|
if step == 1:
|
|
|
self.textbox.send_msg(f"======Step{step + 1}======")
|
|
|
self.reg_update() # 更新各个寄存器颜色为白色
|
|
|
self.sing.clo_mark(step) # 显示节拍
|
|
|
|
|
|
cpu_data.SigObj['->IR'][1] = True
|
|
|
self.sing.show_singe() # 显示控制器信号
|
|
|
|
|
|
cpu_data.SigObj['->IR'][1] = True
|
|
|
self.gui.singe_ctrl_line() # 显示控制线
|
|
|
self.gui.addr_line() # 更新显示地址线
|
|
|
self.memo.mad_to_memo(1) # 更新mad-mome的地址线,参数为真则显示
|
|
|
self.gui.data_line("mco-ir") # 更新数据线
|
|
|
|
|
|
data = self.memo.mco.get() # 取得mco中的值
|
|
|
self.sing.ir_value = data # 更新 ir的值
|
|
|
self.sing.ir_reg_value() # 显示IR
|
|
|
self.sing.ir_reg.config(bg=RED) # 更新IR的颜色
|
|
|
|
|
|
canvas.update() # 刷新显示
|
|
|
|
|
|
if step >= 2:
|
|
|
global inscode
|
|
|
if step == 2:
|
|
|
self.textbox.send_msg(f"======Step{step + 1}======")
|
|
|
self.reg_update() # 更新各个寄存器颜色为白色
|
|
|
self.sing.clo_mark(step) # 显示节拍
|
|
|
|
|
|
cpu_data.SigObj['->PC+1'][1] = True # 更新PC+1的值
|
|
|
cpu_data.SigObj['->IR'][1] = True # 更新IR的值
|
|
|
self.sing.show_singe() # 显示控制器信号
|
|
|
|
|
|
cpu_data.SigObj['->PC+1'][1] = True # 更新PC+1的值
|
|
|
cpu_data.SigObj['->IR'][1] = True # 更新IR的值
|
|
|
self.gui.singe_ctrl_line() # 显示控制线
|
|
|
|
|
|
cpu_data.SigObj['IR->Maddr'][1] = True # 更新IR->Maddr的值
|
|
|
self.gui.addr_line() # 更新地址线
|
|
|
self.gui.data_line() # 更新数据线
|
|
|
self.memo.mad_to_memo() # 更新mad-mome的地址线,参数为真则显示
|
|
|
|
|
|
self.sing.pc_value = self.sing.pc_reg.get()
|
|
|
self.sing.pc_value = self.pc_add_one(self.sing.pc_value) # pc+1
|
|
|
self.sing.pc_reg_value() # 更新PC显示
|
|
|
self.sing.pc_reg.config(bg=RED) # 更新PC背景
|
|
|
|
|
|
inscode, addr = self.sing.ir_value[:6], self.sing.ir_value[6:] # 拆分操作码和指令地址
|
|
|
self.sing.ir_reg.config(bg=RED) # 更新IR背景
|
|
|
self.entry_replace(self.sing.ins, inscode) # 更新 inscode值
|
|
|
self.sing.ins.config(bg=RED) # 更新insCode背景
|
|
|
self.memo.mad_value = f"{int(addr, 2):016b}" # 更新 maddr值
|
|
|
self.memo.show_maddr(self.memo.mad_value, 1) # 显示maddr值
|
|
|
|
|
|
canvas.update() # 刷新显示
|
|
|
if is_meter is None:
|
|
|
time.sleep(self.wait_time)
|
|
|
|
|
|
if one_inscode is not None: # 如果有单指令，直接执行指令
|
|
|
self.instruct(one_inscode)
|
|
|
else: # 如果没有单指令，执行读取到的指令
|
|
|
if is_meter: # 如果是分节拍执行。
|
|
|
stop_tag = self.instruct(inscode, step) # 加入步骤参数
|
|
|
return stop_tag
|
|
|
else: # 不分节拍执行
|
|
|
stop_tag = self.instruct(inscode) # 不加步骤参数
|
|
|
if stop_tag == "stop": return "stop"
|
|
|
|
|
|
if is_meter is None and step < 2: # 不分节拍执行时，增加等待时间
|
|
|
time.sleep(self.wait_time)
|
|
|
|
|
|
def instruct(self, inscode, step=None):
|
|
|
com_code = inscode[2:]
|
|
|
reg_code = inscode[:2]
|
|
|
|
|
|
if com_code == '0001': # 取数指令
|
|
|
if step is not None: # 当有手动指令时执行手动指令
|
|
|
self.SimGet(step, reg_code)
|
|
|
if step >= 3:
|
|
|
return "end"
|
|
|
else:
|
|
|
for i in range(3, 4):
|
|
|
self.SimGet(i, reg_code)
|
|
|
time.sleep(self.wait_time)
|
|
|
|
|
|
if com_code == "0010": # 存数指令
|
|
|
if step is not None:
|
|
|
self.SimPut(step, reg_code)
|
|
|
if step >= 3:
|
|
|
return "end"
|
|
|
else:
|
|
|
for i in range(3, 4):
|
|
|
self.SimPut(i, reg_code)
|
|
|
time.sleep(self.wait_time)
|
|
|
|
|
|
if com_code == "0011":
|
|
|
if reg_code != "11": # 加法指令
|
|
|
if step is not None:
|
|
|
self.SimAddr(step, reg_code)
|
|
|
if step >= 5:
|
|
|
return "end"
|
|
|
else:
|
|
|
for i in range(3, 6):
|
|
|
self.SimAddr(i, reg_code)
|
|
|
time.sleep(self.wait_time)
|
|
|
else:
|
|
|
self.textbox.send_msg("寄存器超限！！！", fg="#FF0000")
|
|
|
|
|
|
if com_code == "0111": # 减法指令
|
|
|
if reg_code != "11": # 加法指令
|
|
|
if step is not None:
|
|
|
self.SimMinus(step, reg_code)
|
|
|
if step >= 5:
|
|
|
return "end"
|
|
|
else:
|
|
|
for i in range(3, 6):
|
|
|
self.SimMinus(i, reg_code)
|
|
|
time.sleep(self.wait_time)
|
|
|
else:
|
|
|
self.textbox.send_msg("寄存器超限！！！", fg="#FF0000")
|
|
|
|
|
|
if com_code == "0100": # 乘法指令
|
|
|
if reg_code != "11":
|
|
|
if step is not None:
|
|
|
self.SimProduct(step, reg_code)
|
|
|
if step >= 5:
|
|
|
return "end"
|
|
|
else:
|
|
|
for i in range(3, 6):
|
|
|
self.SimProduct(i, reg_code)
|
|
|
time.sleep(self.wait_time)
|
|
|
else:
|
|
|
self.textbox.send_msg("寄存器超限！！！", fg="#FF0000")
|
|
|
|
|
|
if com_code == "1000": # 除法指令
|
|
|
if reg_code != "11":
|
|
|
if step is not None:
|
|
|
self.SimDiv(step, reg_code)
|
|
|
if step >= 5:
|
|
|
return "end"
|
|
|
else:
|
|
|
for i in range(3, 6):
|
|
|
self.SimDiv(i, reg_code)
|
|
|
time.sleep(self.wait_time)
|
|
|
else:
|
|
|
self.textbox.send_msg("寄存器超限！！！", fg="#FF0000")
|
|
|
|
|
|
if com_code == "1001": # 跳转指令
|
|
|
if step is not None:
|
|
|
self.SimGoto(step)
|
|
|
if step >= 3:
|
|
|
return "end"
|
|
|
else:
|
|
|
for i in range(3, 4):
|
|
|
self.SimGoto(i)
|
|
|
time.sleep(self.wait_time)
|
|
|
|
|
|
if com_code == "0101": # 打印指令
|
|
|
if step is not None:
|
|
|
self.SimPrint(step)
|
|
|
if step >= 4:
|
|
|
return "end"
|
|
|
else:
|
|
|
for i in range(3, 5):
|
|
|
self.SimPrint(i)
|
|
|
time.sleep(self.wait_time)
|
|
|
|
|
|
if com_code == "0110": # 停机指令
|
|
|
if step is not None:
|
|
|
self.SimStop(step)
|
|
|
if step >= 4:
|
|
|
return "stop"
|
|
|
else:
|
|
|
for i in range(3, 5):
|
|
|
self.SimStop(i)
|
|
|
time.sleep(self.wait_time)
|
|
|
if i >= 4:
|
|
|
return "stop" # 停机标志
|
|
|
|
|
|
def exe_one_instruct(self, inscode):
|
|
|
"""单指令执行"""
|
|
|
for i in range(3):
|
|
|
self.lw_(inscode, step=i)
|
|
|
|
|
|
def exec_auto(self): # 自动执行储存程序
|
|
|
while True:
|
|
|
instr_stute = None # 指令状态为"stop"时退出循环。
|
|
|
if self.ctrl_stop:
|
|
|
break
|
|
|
for i in range(3):
|
|
|
instr_stute = self.lw_(step=i)
|
|
|
if instr_stute == "stop":
|
|
|
break
|
|
|
|
|
|
def exec_next(self): # 执行下一步
|
|
|
statu = self.lw_(is_meter=True, step=self.manual_opera_step) # 执行指令
|
|
|
self.manual_opera_step += 1
|
|
|
if statu == "end" or self.manual_opera_step > 5: # 指令结束或者节拍序号大于5都将节拍重置鱼0
|
|
|
self.manual_opera_step = 0
|
|
|
elif statu == "stop": # 若上一条指令返回停机指令，则disable下一步按键
|
|
|
self.next_button.config(state=tk.DISABLED)
|
|
|
|
|
|
if self.manual_opera_step > 0:
|
|
|
self.prev_button.config(state=tk.NORMAL)
|
|
|
|
|
|
def prev(self): # 执行上一步
|
|
|
self.next_button.config(state=tk.NORMAL)
|
|
|
if self.manual_opera_step > 0:
|
|
|
self.manual_opera_step -= 1
|
|
|
self.lw_(is_meter=True, step=self.manual_opera_step)
|
|
|
else:
|
|
|
self.prev_button.config(state=tk.DISABLED)
|
|
|
|
|
|
def exec_manual_operation(self):
|
|
|
'''分节拍顺序执行'''
|
|
|
self.lw_(is_meter=True, step=self.manual_opera_step)
|
|
|
|
|
|
def main():
|
|
|
SimMem[0] = f"0000010000001010" # SimMem[10] => r1
|
|
|
SimMem[1] = f"0000110000001011" # r1+SimMem[11] => r1
|
|
|
SimMem[2] = f"0001000000001100" # r1*SimMem[12] => r1
|
|
|
SimMem[3] = f"0010000000001101" # r1//SimMem[13] => r1
|
|
|
SimMem[4] = f"0001110000001110" # r1-SimMem[14] => r1
|
|
|
SimMem[5] = f"0000100000001111" # 存数到15地址 r1 => SimMem[15]
|
|
|
SimMem[6] = f"0001010000001111" # 打印 SimMem[15]
|
|
|
SimMem[7] = f"0001100000000000" # 停机
|
|
|
|
|
|
SimMem[10] = dec_to_bin(9) # 10 地址数据
|
|
|
SimMem[11] = dec_to_bin(11) # 11 地址数据
|
|
|
SimMem[12] = dec_to_bin(5) # 12 地址数据
|
|
|
SimMem[13] = dec_to_bin(10) # 13 号位的值
|
|
|
SimMem[14] = dec_to_bin(11) # 14 地址数据
|
|
|
|
|
|
exe = ExecInstructWithText()
|
|
|
root.mainloop()
|
|
|
|
|
|
if __name__ == '__main__':
|
|
|
main()
|
