Official Everybody Edits Forums

ZeldaXD

EE Homeboy

Joined: 2015-02-15

Posts: 1,470

Website

EE Computer [1.12]

EE Computer allows you to store information in a 16x8 RAM (16 registers with 1 byte each) and allows you to do operations with them, including but not limited to: load, store, move, add, subtract, rotate, shift...
You can also write a program with multiple operations.

EE Computer v1.1
Created by ZELDAXD
Special credits: TIJMENTIJ, SLABDRILL & TRYTU

▼HOW TO WRITE A PROGRAM

The computer will start executing operations from line 0 until it finds the operation "stop", so make sure your program has a "stop" somewhere.

Enter the "Program" area and make sure to begin with that you're in line 0 (binary: 00000)
Now you can write your first instruction, for example, ldi r0 10 (binary: 00100 0000 0000 1010)
Afterwards, go to the right-most part of the "Program" area and choose "save line" to save the instruction you just wrote. Now, use "next line" to go to the next line, write another instruction, save, go to next line... etc, until your program is done.
Once it's done, go back to the main area and choose the "Execute all lines" option.

▼FORMATS

Each operation has a format which you need to follow. According to the operation format, the switches in the "Program" area mean:

Takes two registers
417-413: Operation code
412-409: Destination register (Rd)
408-405: N/A
404-401: Source register (Rs)

Takes a register and a 1-byte unsigned integer
417-413: Operation code
412-409: Destination register (Rd)
408-401: Data

Takes a register
417-413: Operation code
412-409: Destination register (Rd)
408-401: N/A

Takes an address (defining address as an address in the code memory, i.e. a line of code)
417-413: Operation code
412-406: N/A
405-401: Address

▼OPERATIONS

Table with operation codes
Rd: Destination register
Rs: Source register
adr: Address (line of code)
PC: Program Counter (keeps track of the current line of code being executed)
NOP: No Operation, doesn't change the content of any register

OP. CODE      MNEMONIC   SYNTAX            EFFECT             FORMAT	NAME
 00000		STOP			NOP				STOP
 00001		MOV	Rd, Rs		Rd <- Rs		A	MOVE
 00010		ST	Rd, Rs		Mem(Rd) <- Rs		A	STORE
 00011		LD	Rd, Rs		Rd <- Mem(Rs)		A	LOAD
 00100		LDI	Rd, data	Rd <- data		B	LOAD INTEGER
 00101		
 00110		ADD	Rd, Rs		Rd <- Rd + Rs		A	ADD
 00111		ADDI	Rd, data	Rd <- Rd + data		B	ADD INTEGER
 01000		SUB	Rd, Rs		Rd <- Rd - Rs		A	SUBTRACT
 01001		SUBI	Rd, data	Rd <- Rd - data		B	SUBTRACT INTEGER
 01010		SHR	Rd		Rd <- SHR(Rd, C)	C	SHIFT RIGHT
 01011		SHL	Rd		Rd <- SHL(Rd, C)	C	SHIFT LEFT
 01100		ROR	Rd		Rd <- ROR(Rd, C)	C	ROTATE RIGHT
 01101		ROL	Rd		Rd <- ROL(Rd, C)	C	ROTATE LEFT
 01110		
 01111		
 10000		NOT	Rd		Rd <- not Rd		C	"NOT" LOGIC OPERATOR
 10001		AND	Rd, Rs		Rd <- Rd and Rs		A	"AND" LOGIC OPERATOR
 10010		OR	Rd, Rs		Rd <- Rd or Rs		A	"OR" LOGIC OPERATOR
 10011		XOR	Rd, Rs		Rd <- Rd xor Rs		A	"XOR" LOGIC OPERATOR
 10100		
 10101		
 10110		CP	Rd, Rs		NOP			A	COMPARE
 10111		CPI	Rd, data	NOP			B	COMPARE INTEGER
 11000		JMP	adr		PC <- adr		D	JUMP
 11001		BRE	adr		PC <- adr		D	BRANCH IF EQUAL
 11010		BRL	adr		PC <- adr		D	BRANCH IF LESSER
 11011		BRG	adr		PC <- adr		D	BRANCH IF GREATER
 11100		VW			NOP				VIEW
 11101		IN	Rd		Rd <- input		C	INPUT
 11110		RAND	Rd		Rd <- RAND(0,255)	C	RANDOM
 11111		DISP	Rd, n		NOP			B	DISPLAY

▼OPERATION DESCRIPTIONS

STOP -> Stops the program
MOV -> Copies the content of the register Rs to the register Rd
ST -> Copies the content of the register Rs to the register that is specified within the contents of the register Rd
LD -> Loads the content of the register that is specified within the contents of the register Rs into the register Rd
LDI -> Loads a 1-byte unsigned integer into the register Rd

ADD -> Adds the contents of the registers Rd and Rs and stores the result in the register Rd
ADDI -> Adds a 1-byte unsigned integer to the contents of the register Rd
SUB -> Subtracts the contents of the registers Rd and Rs and stores the result in the register Rd
SUBI -> Subtracts a 1-byte unsigned integer to the contents of the register Rd
SHR -> Shift all bits of Rd to the right
SHL -> Shift all bits of Rd to the left
ROR -> Rotate all bits of Rd to the right
ROL -> Rotate all bits of Rd to the left

NOT -> Inverses all bits of Rd; NOT logical operator
AND -> Does the logical operation AND with the registers Rd and Rs, and stores the result in Rd; AND logical operator
OR -> Does the logical operation OR with the registers Rd and Rs, and stores the result in Rd; OR logical operator
XOR -> Does the logical operation XOR with the registers Rd and Rs, and stores the result in Rd; XOR logical operator

CP -> Compares the register Rd with the register Rs, does not change the contents of neither Rd nor Rs. According to the comparison, the following switches change: 996 and 997
CPI -> Compares the register Rd with a 1-byte unsigned integer, does not change the contents of Rd. According to the comparison, the following switches change: 996 and 997

Meanings of the switches 996 and 997 according to their state:

996	Meaning
0	Rd != Rs (not equal)
1	Rd == Rs (equal)

997	Meaning
0	Rd > Rs (greater)
1	Rd < Rs (lesser)

JMP -> Jump to the line of code specified in the address
BRE -> Jump to the line of code specified IF switch 996 is set to 1 (equal)
BRL -> Jump to the line of code specified IF switch 997 is set to 1 (lesser)
BRG -> Jump to the line of code specified IF switch 997 is set to 0 (greater)

VIEW -> Pauses the program and allows you to see the RAM and the display
IN -> Asks the user to input a 1-byte unsigned integer and loads it into the register Rd
RAND -> Loads a random 1-byte unsigned integer into the register Rd
DISP -> 7-segment display according to the contents of Rd, uses the format abcdefg

▼DISPLAY

The display is a 7-segment display that uses the format abcdefg

Where, in a byte, with bits 7-0, the bit 6 is A and the bit 0 is G

▼EXAMPLES

Example program:

;First EE Computer program
;4z = x + 2y

in r0		;Load first input into the register 0
in r1		;Load second input into the register 1
shl r1		;Shifts the bits of the register 1 to the left (*2)
add r0 r1	;Add the register 1 to the register 0
shr r0		;Shifts the bits of the register 0 to the right (/2)
shr r0		;Shifts the bits of the register 0 to the right (/2)
stop		;Stop the program

;This the machine code to be input in EE Computer
[0] 11101 0000 0000 0000
[1] 11101 0001 0000 0000
[2] 01011 0001 0000 0000
[3] 00110 0000 0000 0001
[4] 01010 0000 0000 0000
[5] 01010 0000 0000 0000
[6] 00000 0000 0000 0000

▼ASSEMBLER FOR PYTHON

You can directly write the program in EE Computer assembly and it will compile it to the machine code which you can input manually in the EE Computer. It will compile once you write the instruction "stop" (don't write comments in the code)
Try it online here

▼CODE

operations = {"stop":"nof",
              "mov":"a",
              "st":"a",
              "ld":"a",
              "ldi":"b",
              "op5":"c",
              "add":"a",
              "addi":"b",
              "sub":"a",
              "subi":"b",
              "shr":"c",
              "shl":"c",
              "ror":"c",
              "rol":"c",
              "op14":"c",
              "op15":"c",
              "not":"c",
              "and":"a",
              "or":"a",
              "xor":"a",
              "op20":"c",
              "op21":"c",
              "cp":"a",
              "cpi":"b",
              "jmp":"d",
              "bre":"d",
              "brl":"d",
              "brg":"d",
              "vw":"nof",
              "in":"c",
              "rand":"c",
              "disp":"b"}
def toMachineCode(line):
    try:
        code = ""
        args = line.split()
        operation = args.pop(0)

        op_format = operations[operation]
        if op_format == 'nof':
            code += "000000000000"
        for i in range(0, len(args)):
            arg = args[i]
            s = ""
            if ((op_format in ['a', 'b', 'c']) and 'r' in arg and i == 0):
                s = "{0:04b}".format(int(arg[1:]))
            elif op_format in ['b', 'd']:
                s = "{0:08b}".format(int(arg))
            else:
                s = "0000" + "{0:04b}".format(int(arg[1:]))
            code += s if (op_format in ['a', 'b']) else s + "00000000" if op_format == 'c' else "0000" + s
            
        opcode = "{0:05b}".format((list(operations).index(operation)))
        code = opcode + code
        return code if len(code) == 17 else "Error! Please check the syntax of the expression."
    except:
        return "Error! Unknown."
if __name__ == "__main__":
    lines = []
    while (True):
        line = input().lower()
        if (line != "stop"):
            lines.append(toMachineCode(line))
        else:
            lines.append("00000000000000000")
            if (len(lines) > 31):
                print("Error! Program has over 32 lines of code.")
                lines.clear()
            for i in range(0, len(lines)):
                res = lines[i]
                if ("Error" not in lines[i]):
                    res = lines[i][0:5] + " " + lines[i][5:9] + " " + lines[i][9:13] + " " + lines[i][13:17]
                print("[" + str(i) + "] " + res)
            lines.clear()

(it's probably not very well written but it just works)

---

Is EEU Out Yet?

HomerJC170

Member

From: 42.39561, -71.13051

Joined: 2015-08-11

Posts: 68

Re: EE Computer [1.12]

good job

---

Thanks XENONETIX, very cool!
Last edited by Xenonetix (Today 2:34 pm)

"Rule #1: Be slightly annoying, not too much to where it could cause a problem, but just enough to where you are annoying."
"Rule #2: All your heros will die."

ZeldaXD

EE Homeboy

Joined: 2015-02-15

Posts: 1,470

Website

Re: EE Computer [1.12]

It has been updated to v1.1
The documentation has been extensively updated, I've expanded the number of operations from 7 to 25 (with enough space for 32), and you can also write a program.
Please report any bugs you may find.

---

Is EEU Out Yet?

tijmentij

New Member

Joined: 2018-10-12

Posts: 2

Re: EE Computer [1.12]

If you add a jump at line 0 to jump to line 0 (aka infinte loop) it won't go infinte, at most i got was it repeaded 2 times and that was it

Trytu

Member

From: Poland

Joined: 2017-12-10

Posts: 744

Re: EE Computer [1.12]

I wrote animation program and i want to share it:

▼chunk of code

[0]  00100 0000 00000010
[1]  00100 0001 00000100
[2]  00100 0010 00001000
[3]  00100 0011 00010000
[4]  00100 0100 00100000
[5]  00100 0101 01000000
[6]  00100 0110 00000000
[7]  11111 0000 00000000
[8]  11111 0001 00000000
[9]  11111 0010 00000000
[10] 11111 0011 00000000
[11] 11111 0100 00000000
[12] 11111 0101 00000000
[13] 00111 0110 00000001
[14] 10111 0110 00000011 (can be bigger, but don't get too big if you want to go out after some time)
[15] 11010 0000 00000111 (00000110 for infinite loop)
[16] 00100 0110 00000000
[17] 11111 0110 00000000
[18] 00000 0000 00000000

program should show segment looping 3 times around first character
if you want to be able to watch the animation, ask someone to stand in main menu (near the display) and spectate him

997    Meaning
0    Rd > Rs (greater)
1    Rd < Rs (lesser)

for me 0 should be lesser, it's more intuitive for me, because 0 < 1
still amazing project

I'm curious if "RAM" would be good LED switch matrice display
i know there is LED switch segment display, but as matrice it looks more cool
you would build somewhere RAM as matrice 8x16 or 8x8

---

My hоbby is mainly Dog ѕport. Appears boring? Not at all!
I also try to learn Hindi in my spare time.

Here is my web site :: Instagram раsswoгd forgot;
https: //i.imgur.com/4puJMaQ.png
Thanks to user=3619Nikko99/user for signature
https: //media.discordapp.net/attachments/402174325349941249/482121641745186816/KHiX2DEFewAAAABJRU5ErkJggg.png
https: //i.imgur.com/YFtzyXA.png

Kizuna Ai

Formerly Night More

From: Brazil, Learn, Dev.

Joined: 2018-12-02

Posts: 233

Website

Re: EE Computer [1.12]

I love playing.
my computer rico lol

---

Fernandinha is the name of NightMore

Friendly
Official

ZeldaXD

EE Homeboy

Joined: 2015-02-15

Posts: 1,470

Website

Re: EE Computer [1.12]

If you add a jump at line 0 to jump to line 0 (aka infinte loop) it won't go infinte, at most i got was it repeaded 2 times and that was it

It's fixed now

v1.11
- Fixed bug with jump operation
- Added a pause and a force stop option while running the program, just hold right while in the system.
- Added an area where you can see all saved lines of code
- Added the IN (input) operation
- Added the VW (view) operation

---

Is EEU Out Yet?

Slabdrill

Formerly 12345678908642

From: canada

Joined: 2015-08-15

Posts: 3,358

Website

Re: EE Computer [1.12]

▼random sample program

Multiplies two input numbers. Output is in register 3, and will be added to whatever previous value was in register 3. Registers 0-2 will be modified, but it does not matter what they were set to previously.

0 in r0
1 in r1
2 jmp 7
3 shr r1
4 cpi r1 00000000
5 bre 13
6 shl r0
7 ldi r2 00000001
8 and r2 r1
9 cpi r2 00000000
10 bre 3
11 add r3 r0
12 jmp 3
13 stop

code:
[00000] 11101 0000 00000000
[00001] 11101 0001 00000000
[00010] 11000 0000 00000111
[00011] 01010 0001 00000000
[00100] 10111 0001 00000000
[00101] 11001 0000 00001101
[00110] 01011 0000 00000000
[00111] 00100 0010 00000001
[01000] 10001 0010 00000001
[01001] 10111 0010 00000000
[01010] 11001 0000 00000011
[01011] 00110 0011 00000000
[01100] 11000 0000 00000011
[01101] 00000 0000 00000000

EDIT: made it a bit faster (moved line 8 to line 3, line 2 argument changed to 7)

▼a more complex program, untested

;multiplier. puts outputs into two registers (r5 and r4).
0 in r0
1 in r1
2 jmp 11
3 shr r1
4 cpi r1 00000000
5 bre 22
6 cpi r0 10000000
7 brl 9 ;it's about to get bitshifted, if the most significant bit is 1 then add one to the next register (the 1 won't matter after the shift)
8 addi r3 00000001
9 shl r0
10 shl r3
11 ldi r2 00000001
12 and r2 r1
13 cpi r2 00000000
14 bre 3
15 add r5 r3
16 ld r2 r4
17 add r4 r0
18 cpi r4 r2 ;if r4 went down, it must have overflowed
19 brg 3
20 addi r5 00000001
21 jmp 3
22 stop

alt version (shorter+faster but will never halt if input 2 = 00000000):

0 in r0
1 in r1
2 jmp 8
3 cpi r0 10000000
4 brl 6
5 addi r3 00000001
6 shl r0
7 shl r3
8 rotr r1 ;1 in the ones bit rotates to the highest bit, which is easily comparable
9 cpi r1 10000000
10 brl 3
11 subi r1 10000000 ;i need a halting condition and i decided waiting for register 1 to be 0 would be best (alternative is having a counter register)
12 add r5 r3
13 ld r2 r4
14 add r4 r0
15 cp r4 r2
16 brg 18
17 addi r5 00000001
18 cpi r1 00000001
19 brg 3
20 stop

[0] 11101 0000 00000000
[1] 11101 0001 00000000
[2] 11000 0000 00001000
[3] 10111 0000 10000000
[4] 11010 0000 00000110
[5] 00111 0011 00000001
[6] 01011 0000 00000000
[7] 01011 0011 00000000
[8] 01100 0001 00000000
[9] 10111 0001 10000000
[10] 11010 0000 00000011
[11] 01001 0001 10000000
[12] 00110 0101 00000011
[13] 00011 0010 00000100
[14] 00110 0100 00000000
[15] 10110 0100 00000010
[16] 11011 0000 00010010
[17] 00111 0101 00000001
[18] 10111 0001 00000001
[19] 11011 0000 00000011
[20] 00000 0000 00000000

---

suddenly random sig change

ZeldaXD

EE Homeboy

Joined: 2015-02-15

Posts: 1,470

Website

Re: EE Computer [1.12]

v1.12
- Changed the read/write system, it's smaller and faster now
Please report any bugs you may find.

---

Is EEU Out Yet?