old-computer-simulator

computer_interface.cs (5119B)

---

 using Godot;
 using System;
 using static emulator;
 
 public partial class computer_interface : Node {
 
 const int INDEXES_BUTTON_DATA = 7;
 const int INDEXES_BUTTON_ADDR = 15;
 
 [Export] public Button[] buttons;
 [Export] public Sprite2D[] lamp_current_instruction;
 [Export] public Sprite2D[] lamp_addr;
 
 [Export] public Color lamp_on = Colors.Red;
 [Export] public Color lamp_off = Colors.DarkGray;
 
 [Export] public Button button_off_on;
 [Export] public Button button_stop;
 [Export] public Button button_run;
 [Export] public Button button_single_step;
 [Export] public Button button_examine;
 [Export] public Button button_examine_next;
 [Export] public Button button_deposit;
 [Export] public Button button_deposit_next;
 [Export] public Button button_reset;
 [Export] public Button button_clear;
 
 IntPtr _emu;
 ushort curr_addr;
 byte curr_instr;
 bool worked = false;
 
 public override void _Ready() {
   _emu = emu_create();
   
   int r = emu_load_program(_emu, "altair.bin");
   if (r != 0) {
     GD.Print("error to load program: altair.bin");
   }
   
 
   if (button_run != null) button_run.Pressed += run_pressed;
   if (button_stop != null) button_stop.Pressed += stop_pressed;
   if (button_single_step != null) button_single_step.Pressed += single_step_pressed;
   if (button_examine != null) button_examine.Pressed += examine_pressed;
   if (button_examine_next != null) button_examine_next.Pressed += examine_next_pressed;
   if (button_deposit != null) button_deposit.Pressed += deposit_pressed;
   if (button_deposit_next != null) button_deposit_next.Pressed += deposit_next_pressed;
   if (button_reset != null) button_reset.Pressed += reset_pressed;
   if (button_clear != null) button_clear.Pressed += clear_pressed;
 
   if (buttons != null) {
     for (int i = 0; i < buttons.Length; i++) {
       if (buttons[i] != null) {
         buttons[i].Pressed += bit_button_pressed;
       }
     }
   }
 
   update_lamps();
 }
 
 public override void _Notification(int what) {
   if (what == NotificationPredelete) {
     emu_destroy(_emu);
   }
 }
 
 public override void _Process(double delta) {
   if (!worked) return;
 
   int r = emu_step(_emu);
   if (r > 0) {
     worked = false;
     return;
   }
 
   curr_addr = (ushort)emu_get_pc(_emu);
   curr_instr = emu_mem_read(_emu, curr_addr);
 
   update_lamps();
 
   byte reg_a = emu_get_reg(_emu, 0b111);
   byte reg_b = emu_get_reg(_emu, 0b000);
   byte reg_c = emu_get_reg(_emu, 0b001);
   byte reg_d = emu_get_reg(_emu, 0b010);
   GD.Print($"opcode=0x{curr_instr:X2}; pc=0x{curr_addr:X4}; a=0x{reg_a:X2}; b=0x{reg_b:X2}; c=0x{reg_c:X2}; d=0x{reg_d:X2}");
 }
 
 void update_lamps() {
   update_data_lamps(curr_instr);
   update_addr_lamps(curr_addr);
 }
 
 ushort read_switches_addr() {
   byte b0 = assem_byte(buttons, 0, 8);
   byte b1 = assem_byte(buttons, 8, 8);
   return (ushort)((b1 << 8) | b0);
 }
 
 byte read_switches_data() {
   return assem_byte(buttons, 0, INDEXES_BUTTON_DATA + 1);
 }
 
 void bit_button_pressed() {
   update_lamps();
 }
 
 void run_pressed() {
   worked = true;
 }
 
 void stop_pressed() {
   worked = false;
 }
 
 void single_step_pressed() {
   worked = false;
   emu_step(_emu);
   curr_addr = (ushort)emu_get_pc(_emu);
   curr_instr = emu_mem_read(_emu, curr_addr);
   update_lamps();
 }
 
 void examine_pressed() {
   worked = false;
   curr_addr = read_switches_addr();
   emu_set_pc(_emu, curr_addr);
   curr_instr = emu_mem_read(_emu, curr_addr);
   update_lamps();
 
   GD.Print($"Examine at 0x{curr_addr:X4}: 0x{curr_instr:X2}");
 }
 
 void examine_next_pressed() {
   worked = false;
   curr_addr++;
   emu_set_pc(_emu, curr_addr);
   curr_instr = emu_mem_read(_emu, curr_addr);
   update_lamps();
 
   GD.Print($"Examine Next at 0x{curr_addr:X4}: 0x{curr_instr:X2}");
 }
 
 void deposit_pressed() {
   worked = false;
   byte val = read_switches_data();
   
   emu_mem_write(_emu, curr_addr, val);
   curr_instr = val;
   update_lamps();
 
   GD.Print($"Deposit 0x{val:X2} at 0x{curr_addr:X4}");
 }
 
 void deposit_next_pressed() {
   worked = false;
   
   curr_addr++;
   emu_set_pc(_emu, curr_addr);
   
   byte val = read_switches_data();
   emu_mem_write(_emu, curr_addr, val);
   curr_instr = val;
   update_lamps();
 
   GD.Print($"Deposit Next 0x{val:X2} at 0x{curr_addr:X4}");
 }
 
 void reset_pressed() {
   worked = false;
   emu_set_pc(_emu, 0);
   curr_addr = 0;
   curr_instr = emu_mem_read(_emu, curr_addr);
   update_lamps();
 }
 
 void clear_pressed() {
   update_lamps();
 }
 
 void update_data_lamps(byte value) {
   for (int i = 0; i < 8 && i < lamp_current_instruction.Length; i++) {
     bool is_bit_set = (value & (1 << i)) != 0;
     lamp_current_instruction[i].SelfModulate = is_bit_set ? lamp_on : lamp_off;
   }
 }
 
 void update_addr_lamps(ushort value) {
   for (int i = 0; i < 16 && i < lamp_addr.Length; i++) {
     bool is_bit_set = (value & (1 << i)) != 0;
     lamp_addr[i].SelfModulate = is_bit_set ? lamp_on : lamp_off;
   }
 }
 
 byte assem_byte(Button[] btns, int offset, int count = 8) {
   byte r = 0;
   if (btns == null) return r;
 
   for (int i = 0; i < count && i < 8; i++) {
     int index = offset + i;
     if (index < btns.Length && btns[index] != null && btns[index].ButtonPressed) {
       r |= (byte)(1 << i);
     }
   }
   return r;
 }
 
 }