Assembler kind of works ; created simple assembly program that prints Tick! every second.

8 files changed, 57 insertions, 31 deletions

diff --git a/asm/asmlex.mll b/asm/asmlex.mll
index 98caa26..726b732 100644
--- a/asm/asmlex.mll
+++ b/asm/asmlex.mll
@@ -53,8 +53,8 @@
 			let v =
 				let c = Char.code n.[i] in
 				if c >= Char.code '0' && c <= Char.code '9' then c - (Char.code '0')
-				else if c >= Char.code 'a' && c <= Char.code 'f' then c - (Char.code 'a')
-				else c - (Char.code 'A') in
+				else if c >= Char.code 'a' && c <= Char.code 'f' then c - (Char.code 'a') + 10
+				else c - (Char.code 'A') + 10 in
 			res := !res + v
 		done;
 		!res
diff --git a/asm/assembler.ml b/asm/assembler.ml
index 2c91366..1158181 100644
--- a/asm/assembler.ml
+++ b/asm/assembler.ml
@@ -108,7 +108,7 @@ let print_program p =
 			sprintf "liu %s %s" (rts r) (its i)
 		| Liuz (r,i) -> (0b11011 lsl 11) lxor (r lsl 8) lxor (value i land 0xFF),
 			sprintf "liuz %s %s" (rts r) (its i)
-        | TwoRawBytes(a, b) -> (a lsl 8) lxor b, sprintf "bytes %d %d" a b
+        | TwoRawBytes(a, b) -> (a) lxor (b lsl 8), sprintf "bytes %d %d" a b
         in
 	let n = List.length p.text in
 	let rev_lbls = Array.make n "" in
diff --git a/asm/test.asm b/asm/test.asm
index 2597f1f..d37ca61 100644
--- a/asm/test.asm
+++ b/asm/test.asm
@@ -4,6 +4,7 @@
 init:
     liuz B 0x40
     lw B 0(B)
+    jz B init
     add D D B
     push D
     la A msgtick
@@ -12,13 +13,14 @@ init:
     j init
 
 ser_out_msg:
-    lb B 0(A)
-    jz B ser_out_msg_ret
     liuz C 0x41
     lil C 0x02
+ser_out_msg_loop:
+    lb B 0(A)
+    jz B ser_out_msg_ret
     sb B 0(C)
     incri A 1
-    j ser_out_msg
+    j ser_out_msg_loop
 ser_out_msg_ret:
     jr RA
 
diff --git a/cpu/cpu.ml b/cpu/cpu.ml
index b7e394b..1d1eea8 100644
--- a/cpu/cpu.ml
+++ b/cpu/cpu.ml
@@ -6,6 +6,8 @@ let ser_in_busy, save_ser_in_busy = loop 1
 
 let dbg_ra, save_dbg_ra = loop 16
 let dbg_read_data, save_dbg_read_data = loop 8
+let dbg_wa, save_dbg_wa = loop 16
+let dbg_write_data, save_dbg_write_data = loop 8
 
 let cpu_ram ra we wa d =
     (*  Ram chip has word size = 8 bits and address size = 16 bits
@@ -61,6 +63,8 @@ let cpu_ram ra we wa d =
 
     save_dbg_ra ra ^.
     save_dbg_read_data read_data ^.
+    save_dbg_wa wa ^.
+    save_dbg_write_data d ^.
     read_data
     
 
@@ -183,6 +187,7 @@ let rl, rh, i, ex, exf, pc =
     let instr_j = exec ^& eq_c 5 i_i 0b01000 in
     let next_pc = mux instr_j next_pc (nadder 16 pc (sign_extend 11 16 i_jd)) in
     (* instruction : jal *)
+    let link_pc = next_pc in
     let instr_jal = exec ^& eq_c 5 i_i 0b01001 in
     let next_pc = mux instr_jal next_pc (nadder 16 pc (sign_extend 11 16 i_jd)) in
     let instr_jalxx = instr_jal in
@@ -196,7 +201,7 @@ let rl, rh, i, ex, exf, pc =
     let next_pc = mux cond_jxxr next_pc v_r in
     (* prologue for jal/jalr *)
     let wr = mux instr_jalxx wr (const "011") in
-    let rwd = mux instr_jalxx rwd next_pc in
+    let rwd = mux instr_jalxx rwd link_pc in
 
     (* instruction : lra *)
     let instr_lra = exec ^& eq_c 5 i_i 0b01100 in
@@ -287,11 +292,13 @@ let p =
         [
             "read_ilow", 1, rl;
             "read_ihi", 1, rh;
-            "exec_instr", 1, ex;
-            "exec_finished", 1, exf;
-            "instruction", 16, i;
+            "ex_instr", 1, ex;
+            "ex_finish", 1, exf;
+            "i", 16, i;
             "ra", 16, dbg_ra;
             "read_data", 8, dbg_read_data;
+            "wa", 16, dbg_wa;
+            "write_data", 8, dbg_write_data;
             "pc", 16, pc;
             "r0_Z", 16, r0;
             "r1_A", 16, r1;
diff --git a/cpu/prog_test1.rom b/cpu/prog_test1.rom
index 9695447..0d352b7 100644
--- a/cpu/prog_test1.rom
+++ b/cpu/prog_test1.rom
@@ -1,30 +1,36 @@
-48 8
-10101010 11111011		# liuz SP 85
+58 8
+11111111 11111011		# liuz SP 255
+00000000 00100000		# add D Z Z
 	# init:
 00000010 01011011		# liuz B 64
 00000010 01000001		# lw B 0(B)
-00010110 11000000		# add C C B
+00100000 10110011		# lilz E init
+00000000 10101011		# liu E init
+01000010 10101010		# jer E B Z
+00010001 00100000		# add D D B
 01111111 11101100		# incri SP -2
-00000111 11010001		# sw C 0(SP)
-01010100 10010011		# lilz A msgtick
+00000111 00110001		# sw D 0(SP)
+00101100 10010011		# lilz A msgtick
 00000000 10001011		# liu A msgtick
 00010000 00010010		# jal ser_out_msg
-00000111 11000001		# lw C 0(SP)
+00000111 00100001		# lw D 0(SP)
 01000000 11101100		# incri SP 2
-00110111 11100010		# j init
+01100111 11100010		# j init
 	# ser_out_msg:
-00000100 01001001		# lb B 0(A)
-00010100 10110011		# lilz E ser_out_msg_ret
-00000000 10101011		# liu E ser_out_msg_ret
-01000101 01001010		# jer B E Z
 10000010 11011011		# liuz C 65
 01000000 11000011		# lil C 2
+	# ser_out_msg_loop:
+00000100 01001001		# lb B 0(A)
+01001100 10110011		# lilz E ser_out_msg_ret
+00000000 10101011		# liu E ser_out_msg_ret
+01000010 10101010		# jer E B Z
 00000110 01011001		# sb B 0(C)
-01001111 11100010		# j ser_out_msg
+10000000 10001100		# incri A 1
+00101111 11100010		# j ser_out_msg_loop
 	# ser_out_msg_ret:
 00000000 01101010		# jr RA
 	# msgtick:
-10010110 00101010		# bytes 84 105
-11010110 11000110		# bytes 99 107
-00000000 10000100		# bytes 33 0
+00101010 10010110		# bytes 84 105
+11000110 11010110		# bytes 99 107
+10000100 00000000		# bytes 33 0
 
diff --git a/monitor/disp.c b/monitor/disp.c
index 992c712..84dd941 100644
--- a/monitor/disp.c
+++ b/monitor/disp.c
@@ -86,19 +86,18 @@ void disp_display(t_mon *mon) {
     
     wprintw(wpstatus, "\nInputs:\n");
     for (i = 0; i < mon->n_inputs; i++) {
-        wprintw(wpstatus, " %d. %s%s\t%s (%d)\t%s\n",
+        wprintw(wpstatus, "%s %d. %s (%d)\t%s\n",
+            (i == mon->ticker_input ? "T" : (i == mon->ser_in_in ? ">" : " ")),
             i, 
-            (i == mon->ticker_input ? "T" : ""),
-            (i == mon->ser_in_in ? ">" : ""),
             mon->inputs[i].name, mon->inputs[i].size, mon->inputs[i].value);
     }
     if (mon->n_inputs == 0) wprintw(wpstatus, "\t(none)\n");
 
     wprintw(wpstatus, "\nOutputs:\n");
     for (i = 0; i < mon->n_outputs; i++) {
-        wprintw(wpstatus, " %d. %s%s\t%s\t%s\t%ld\n", i, 
-            (i == mon->ser_out ? "<" : ""),
-            (i == mon->ser_in_busy_out ? "!" : ""),
+        wprintw(wpstatus, "%s %d. %s\t%s %ld\n", 
+            (i == mon->ser_out ? "<" : (i == mon->ser_in_busy_out ? "!" : " ")),
+            i,
             mon->outputs[i].name, mon->outputs[i].v_bin, mon->outputs[i].v_int);
     }
     if (mon->n_outputs == 0) wprintw(wpstatus, "\t(none)\n");
@@ -147,4 +146,14 @@ void disp_display(t_mon *mon) {
 }
 
 
+void disp_display_ser(t_mon *mon) {
+    if (mon->ser_out_buf != 0) {
+        wprintw(wpoutput, "%c", mon->ser_out_buf);
+        wrefresh(wpoutput);
+        mon->ser_out_buf = 0;
+
+        wmove(wcmdline, 0, cmd_pos + 2);
+        wrefresh(wcmdline);
+    }
+}
 
diff --git a/monitor/mon.c b/monitor/mon.c
index 19055c7..baef98b 100644
--- a/monitor/mon.c
+++ b/monitor/mon.c
@@ -285,4 +285,5 @@ void mon_step(t_mon *mon) {
     }
     
     mon->step++;
+    disp_display_ser(mon);
 }
diff --git a/monitor/mon.h b/monitor/mon.h
index 0040eda..32d60c4 100644
--- a/monitor/mon.h
+++ b/monitor/mon.h
@@ -61,6 +61,7 @@ typedef struct {
 
 void disp_init();
 void disp_display(t_mon *mon);
+void disp_display_ser(t_mon *mon);
 void disp_finish();
 
 void handle_kbd(t_mon *mon);