Somewhat finished the design for my Binary > BCD program. Once all the RAM clearing commands are included, it should add up to like 101 instructions (fffffffuuuuuuu). I will probably increase the ROM limit to 127 instructions soon. Also this program uses variable reading from RAM. ie, RAM(B) -> A, or something like that. It's the same as what is already available for writing, just for reading from RAM. I will add this function to the processor soon.

RAM(1): Holds initial value
RAM(2-4): Holds the 3 BCD groups
RAM(10): Holds RAM INDEX
RAM(20): Holds outer loop
RAM(30): Holds carry value
RAM(40): Holds BCD shift/carry loop
RAM(50): Holds BCD +3 loop

INPUT > RAM(1)
SET RAM INDEX(10): 2

------------------------------------------------------------------------------------------------------------------------------------------------------------
LOOP: repeats whole process 8 times
-------------------------------------------------------------------------------------------------------------------------------------------------------------
---------------------------------------
gets carry and shifts initial value
--------------------------------------
SET RAM CARRY(30): 0
RAM(1) > A
10000000 > B
AND AB > C
C > A
IF A==B
SET RAM CARRY(30): 1

RAM(1) > A
RAM(1) > B
ADD AB > RAM(1)
----------------------------------------
loop: adds carries, gets carries and shifts all 3 BCD fields
----------------------------------------
RAM INDEX(10) > B
RAM(B) > A
RAM(B) > B
ADD AB > C
C > A
RAM CARRY(30) > B
ADD AB > C
C > A
RAM INDEX(10) > B
A > RAM(B)

00010000 (16) > B
AND AB > C
C > A
0 > RAM CARRY(30)
IF A==B
1 > RAM CARRY(30)
RAM INDEX(10) > B
RAM(B) > A
00010000 > B
XOR AB > C
C > A
RAM INDEX(10) > B
A > RAM(B)

RAM INDEX(10) > A
00000001 > B
ADD AB > RAM INDEX(10)
RAM BCD LOOP(40) > A
ADD AB > RAM BCD LOOP(40)
RAM BCD LOOP(40) > A
00000011 > B

IF (A==B, else go back to start of this loop)
leave this loop;
/loop end

----------------------------------------------------------


2 > RAM INDEX(10)


RAM OUTER LOOP(20) > A
00000111 > B
IF (A==B, else, continue onwards)
JUMP TO END OF PROGRAM;

--------------------------------------------------------------------------------
loop: checks each BCD field if they are 5 or more, and adds 3
---------------------------------------------------------------------------------

RAM INDEX(10) > B
RAM(B) > A
00000011 > B
ADD AB > C
C > A
00001000 > B
AND AB > C
C > A
IF (A==B)
RAM INDEX(10) > B
RAM(B) > A
00000011 > B
ADD AB > C
C > A
RAM INDEX(10) > B
A > RAM(B)

RAM INDEX(10) > A
00000001 > B
ADD AB > RAM INDEX(10)
RAM BCD LOOP2(50) > A
ADD AB > RAM BCD LOOP2(50)
RAM BCD LOOP2(50) > A
00000010 > B
IF (A==B, else go back to start of loop)
leave this loop;

/loop end
----------------------------------------------------------------

2 > RAM INDEX(10)
0 > RAM BCD LOOP(40)
0 > RAM BCD LOOP2(50)
RAM OUTER LOOP(20) > A
00000001 > B
ADD AB > RAM OUTER LOOP(20)
RAM OUTER LOOP(20) > A
00001000 > B
IF (A==B, else go back to start of loop)
leave this loop;


//loop end
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

OUTPUT > RAM(2)
OUTPUT > RAM(3)
OUTPUT > RAM(4)

Funniest thing is. The program will probably take a little over 1.5 hours to complete (about 1500 instructions after all the loops). 60fps yields about 20 instructions per minute.

EDIT: Added the two new data flow operations:

RAM(B) -> A (reads from RAM, stores in A. B is used as address)

RAM(B) -> B (reads from RAM, stores in B. B is used as address)

Instructions are added to the front page post.

EDIT 2: Increased ROM size 16%. Now supports 116 instructions.

EDIT 3: Created a program helper. This should make it far easier to make programs (rather than placing INWR pixels everywhere). Hopefully I haven't mixed any of the wires up. I'll know by tomorrow if there is.

Remember, once you have finished, drag a box of C4 over the INWR, copy it, paste it into the diamond box, wait for the BRAY to dissapear and then fill the holes with INWR. When you have done that, blow it up (with fire or something) and then copy/paste the INWR into the blue template.

Yeah it does feel better to do it by hand sometimes.

In other news. I have finally achieved what I set out to achieve by making this computer in the first place. And that is successfully implementing the double dabble algorithm (converts binary to BCD, which is essentially converting it to decimal).

http://en.wikipedia.org/wiki/Double_dabble

I believe I was the first to implement double dabble via hardware, and now I have become the first to implement it via software.

Be warned though, this program takes about 1.5 hours to complete at 60fps.

Here's a video at 10x speed.

Going to look into adding A > B and A < B now.

It's about 97 instructions long in the end. Also my RAM doesn't clear automatically. Therefore I needed to use a seperate clear instruction whenever I wrote to RAM. So you might be able to make it about 80 instructions if your RAM clears automatically when writing.

Let me know if you have any questions china-richway2. If you don't understand anything I can explain it for you. The method in my previous post was just my draft. Although it happened to be a perfect draft that worked flawlessly the first time I tried it lol. Will be cool to see this program working on your processor too.