def asignacion_variables(self, valor):
edicion = self.sender()
if edicion.inputMask() == "HH" and len(valor)==2:
for i in range(2):
if edicion == self.edit_hex[i]:
config.val_h[i] = valor
config.val_b[i] = hex_a_bin(config.val_h[i])
config.val_d[i] = hex_a_dec(config.val_h[i])
config.val_s[i] = dec_a_sig(config.val_d[i])
config.var_op[i] = bin_a_op(config.val_b[i])
self.edit_bin[i].setText(config.val_b[i])
elif edicion.inputMask() == "BBBBBBBB" and len(valor)==8:
for i in range(2):
if edicion == self.edit_bin[i]:
config.val_h[i] = bin_a_hex(valor)
config.val_b[i] = valor
config.val_d[i] = bin_a_dec(config.val_b[i])
config.val_s[i] = dec_a_sig(config.val_d[i])
config.var_op[i] = bin_a_op(config.val_b[i])
self.edit_hex[i].setText(config.val_h[i])
config.A = config.var_op[0]
config.B = config.var_op[1]
for i in range(2):
self.lbl_valor_hex[i].setText(config.val_h[i])
self.lbl_valor_bin[i].setText(config.val_b[i])
self.lbl_valor_dec[i].setText(config.val_d[i])
self.lbl_valor_sig[i].setText(config.val_s[i])
config.R, config.F = unidad_aritmetica_logica(config.A, config.B, 0, config.S)
self.actualizar_cadenas()
def control_ALU(self):
control_variable = self.sender()
for i in range(5):
if control_variable == self.btn_descod_op[i]:
if control_variable.text() == "0":
control_variable.setText("1")
config.descod_op[i] = 1
elif control_variable.text() == "1":
control_variable.setText("0")
self.lbl_senales[i].setText("0")
config.descod_op[i] = 0
op = int(op_a_bin(config.descod_op), 2)
if op >= 25:
op = 1
S_con = config.senal_control_USC1[op]
for i in range(len(S_con) - 1):
self.lbl_senales[i].setText(str(S_con[i]))
alu = unidad_aritmetica_logica(config.Acumulador, config.Var_Ingreso,
config.Registro_F[0], S_con[0:12])
config.Resultado_ALU = alu[0]
config.Banderas_ALU = alu[1]
self.actualizar_cadenas()
def unidad_secuencial_calculo(estado_anterior_USC, entrada_externa_USC,
senal_control_USC):
acumulador_A_anterior = estado_anterior_USC[0]
registro_F_anterior = estado_anterior_USC[1]
dato_externo = entrada_externa_USC
control_ALU = senal_control_USC[0:12]
control_LCT = senal_control_USC[12:21]
entrada_A = acumulador_A_anterior
entrada_B = dato_externo
resultado_actual, banderas_actual = unidad_aritmetica_logica(
entrada_A, entrada_B, registro_F_anterior[0], control_ALU)
registro_F_acutal = logica_control_temporizacion(registro_F_anterior,
banderas_actual,
[0, 0, 0, 0], control_LCT)
acumulador_A_actual = resultado_actual
estado_actual_USC = [acumulador_A_actual, registro_F_acutal]
return estado_actual_USC
def control_ALU(self):
control_variable = self.sender()
for i in range(7):
if control_variable == self.btn_senales[i]:
if control_variable.text() == "0":
control_variable.setText("1")
self.lbl_senales[i].setText("1")
config.S[config.S_alu_simple[i]] = 1
elif control_variable.text() == "1":
control_variable.setText("0")
self.lbl_senales[i].setText("0")
config.S[config.S_alu_simple[i]] = 0
config.R, config.F = unidad_aritmetica_logica(config.A, config.B, 0, config.S)
self.actualizar_cadenas()
def control_USC(self):
op = int(op_a_bin(config.descod_op), 2)
if op >= 25:
op = 0
S_con = config.senal_control_USC1[op]
usc = unidad_secuencial_calculo([config.Acumulador, config.Registro_F],
config.Var_Ingreso, S_con)
config.Acumulador = usc[0]
config.Registro_F = usc[1]
alu = unidad_aritmetica_logica(config.Acumulador, config.Var_Ingreso,
config.Registro_F[0], S_con[0:12])
config.Resultado_ALU = alu[0]
config.Banderas_ALU = alu[1]
self.actualizar_cadenas()
def asignacion_variables(self, valor):
edicion = self.sender()
if edicion.inputMask() == "HH" and len(valor) == 2:
if edicion == self.edit_hex:
config.val_h = valor
config.val_b = hex_a_bin(config.val_h)
config.val_d = hex_a_dec(config.val_h)
config.val_s = dec_a_sig(config.val_d)
config.Var_Ingreso = bin_a_op(config.val_b)
self.edit_bin.setText(config.val_b)
elif edicion.inputMask() == "BBBBBBBB" and len(valor) == 8:
if edicion == self.edit_bin:
config.val_h = bin_a_hex(valor)
config.val_b = valor
config.val_d = bin_a_dec(config.val_b)
config.val_s = dec_a_sig(config.val_d)
config.Var_Ingreso = bin_a_op(config.val_b)
self.edit_hex.setText(config.val_h)
self.lbl_valor_hex.setText(config.val_h)
self.lbl_valor_bin.setText(config.val_b)
self.lbl_valor_dec.setText(config.val_d)
self.lbl_valor_sig.setText(config.val_s)
op = int(op_a_bin(config.descod_op), 2)
if op >= 25:
op = 0
S_con = config.senal_control_USC1[op]
config.Resultado_ALU, config.Banderas_ALU = unidad_aritmetica_logica(
config.Acumulador, config.Var_Ingreso, config.Registro_F[0],
S_con[0:12])
self.actualizar_cadenas()
def unidad_secuencial_calculo(estado_anterior_USC, entrada_externa_USC,
banderas_cp, senal_control_USC):
acumulador_A_anterior = estado_anterior_USC[0]
acumulador_B_anterior = estado_anterior_USC[1]
acumulador_C_anterior = estado_anterior_USC[2]
registro_F_anterior = estado_anterior_USC[3]
dato_externo = entrada_externa_USC[0]
dato_memoria = entrada_externa_USC[1]
control_ALU = senal_control_USC[0:12]
control_LCT = senal_control_USC[12:21]
control_LE = senal_control_USC[21]
control_entrada_A = senal_control_USC[22:24]
control_entrada_B = senal_control_USC[24:27]
control_acumulador = senal_control_USC[27:30]
if control_entrada_A == [0, 0]:
entrada_A = acumulador_A_anterior
elif control_entrada_A == [1, 0]:
entrada_A = acumulador_B_anterior
elif control_entrada_A == [0, 1]:
entrada_A = acumulador_C_anterior
if control_entrada_B == [0, 0, 0]:
entrada_B = dato_externo
elif control_entrada_B == [1, 0, 0]:
entrada_B = dato_memoria
elif control_entrada_B == [0, 1, 0]:
entrada_B = acumulador_A_anterior
elif control_entrada_B == [1, 1, 0]:
entrada_B = acumulador_B_anterior
elif control_entrada_B == [0, 0, 1]:
entrada_B = acumulador_C_anterior
resultado_actual, banderas_actual = unidad_aritmetica_logica(
entrada_A, entrada_B, registro_F_anterior[0], control_ALU)
registro_F_acutal = logica_control_temporizacion(registro_F_anterior,
banderas_actual,
banderas_cp, control_LCT)
acumulador_A_actual = acumulador_A_anterior
acumulador_B_actual = acumulador_B_anterior
acumulador_C_actual = acumulador_C_anterior
if control_acumulador[0] == 1:
acumulador_A_actual = resultado_actual
if control_acumulador[1] == 1:
acumulador_B_actual = resultado_actual
if control_acumulador[2] == 1:
acumulador_C_actual = resultado_actual
estado_actual_USC = [
acumulador_A_actual, acumulador_B_actual, acumulador_C_actual,
registro_F_acutal
]
dato_a_memoria = [entrada_A, resultado_actual]
return estado_actual_USC, dato_a_memoria