toyz80

KO | EN

gitlite — search

#javascript #python #react #ai #golang #android #machine-learning #deep-learning #linux #docker #macos #nodejs #windows #pytorch

(★ 12)

Emulate Z80/i8080 CPU.

toyz80 최신버젼 다운로드

최종 버전 다운로드 (.zip)

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# toyz80
Emulate Z80/i8080 CPU.

This is a toy.  It is not complete yet!  Do send me PRs!

The idea is to get to CP/M 2.2 compatibility and then build this fictional computer in actual hardware.

Currently UT (Unit Test) is rigged in and there is a basic Z80 computer being
emulated that has a console and supports about 98% of the opcodes.  It passes
the famed zexdoc (borrowed from
https://github.com/anotherlin/z80emu/tree/master/testfiles) tests.  Some code
compiled with the outstanding sdcc (http://sdcc.sourceforge.net/) C compiler
works as well.

Once the last few opcodes make it in and are debugged it is time to add
interrupt support and some additional devices (HDD, tape, etc)

In order to play with this code follow the following steps:
1. Install Go.
2. `go get github.com/marcopeereboom/toyz80`

In order to test the Z80 CPU:
1. `cd $GOPATH/src/github.com/marcopeereboom/toyz80/z80`
2. `go test -v`

Adding more opcodes is typically a 3 step process.
1. Add opcode in z80/opcodes.go in the right location.  Array location dictates opcode!
2. Add support for opcode in z80/z80.go in the large switch statement inside func Step.
3. Add UT test case for all edge cases for new opcode in z80/z80_test.go.

Multi byte opcodes are a bit more involved and opcodes that don't have an
example may need some extra magic.  If it works, send me a PR.

There now is a minimal implementation of a fictional computer.  In order to
play with it follow these steps:
1. `cd $GOPATH/src/github.com/marcopeereboom/toyz80`
2. `go build`
3. `./toyz80 device=console,0x02-0x02 device=ram,0x0000-65536 load=0,src/cpuville/tinybasic2dms.bin`

This launches the toy z80 computer with tiny basic at address 0.  The machine
will now wait for you to connect the console.  The console is a unix socket
hard coded at /tmp/toyz80.socket.  Connecting to this socket can be done using
socat in the following manner: `socat /dev/tty,rawer UNIX-CLIENT:/tmp/toyz80.socket`.
The console is where the machine output goes.  This may seem a little hokey but
you'll thank me later (now it *is* a real serial port that can redirected etc).

Unfortunately Windows doesn't handle sockets the way UNIX does and therefore it
does not work.  At some point this will be fixed (who uses Windows anyway?).

At this point the z80 computer is ready to be either started or debugged etc.

Currently the following commands are supported in the control window:
* `mode <emacs|vi>`
* `bp [set|del address]`
* `continue`
* `disassemble [address [count]]`
* `dump [address [count]]`
* `pause`
* `registers`
* `step [count]`
* `pc <address>`

### To-Do
* More instruction tests.
* Add memory fill/load instructions to control.
* Add Assembler to control.
* Add interrupt handling.
* Verify execution times.
* Cleanup, lot's of it.
* Add final missing undocumented instructions.
* Create a BIOS.
* Create floppy driver.
* Create a monitor for the Z80 machine that can be burned to ROM.
* Run CP/M.
* Translate to hardware!

### cpuville

In `src/cpuville` you'll find some publicly available goodies.  I borrowed this
from the excellent Donn Stewart cpuville pages at: http://cpuville.com/Z80.htm

You'll find Donn's ROM monitor and tinybasic which runs on his computer.  Since
toyz80 is based of that hardware it works as expected.

Thanks Donn for your super informational pages!

### sdcc

In order to play with C on your toyz80 install sdcc.  It is installed on a
host of operating systems.  I used brew on OSX.  The standard library that
comes with sdcc is pretty awesome and I was able to make images for the
emulator without modifications.  Of course if I want a more clever crt0 or
something that is another story but to just get going it is not needed.
Essentially it boils down to overriding putchar and getchar so that you can get
a console.

To play with an example do:
```
$ cd src/sdcc
$ make
sdcc -mz80 --code-loc 0x0180 --data-loc 0x1000 hello.c
makebin hello.ihx > hello.bin
$
```

Launch toyz80 (this is the control window):
```
$ toyz80 device=console,0x02-0x02 device=ram,0x0000-65536 load=0,src/sdcc/hello.bin
awaiting console connection on: /tmp/toyz80.socket
```

The emulator is now ready to be connected to.  I used `socat` for that.
```
$ socat /dev/tty,rawer UNIX-CLIENT:/tmp/toyz80.socket
```

At this point the control window is ready.  Type run and watch the z80 action!
```
> run
CPU halted
halt: $0187
af $00bb bc $000d de $000b hl $0000 ix $0000 iy $0000 pc $0187 sp $0000 f S-1H1-NC 
```

The serial window should be printing all kinds of goodies.
```
$ socat /dev/tty,rawer UNIX-CLIENT:/tmp/toyz80.socket
Hello Z80 C world! int 1 string haha hex ff

*
                                           *
                                               *
                                                   *
                                                      *
                                                        *
                                                          *
                                                           *
                                                           *
                                                           *
                                                          *
                                                        *
                                                     *
                                                  *
                                              *
                                          *
                                      *
                                  *
                               *
                           *
                        *
                      *
                    *
                    *
                    *
                    *
                      *
                        *
                           *
                              *
                                  *
                                      *
```

### zexdoc results

In order to assemble zexdoc you have to install zmac.  I grabbed it from
http://48k.ca/zmac.html and compiled it myself and added it to the path.

For example:
```
$ cd z80/zex
$ zmac --zmac zexdoc.src
$ cp zout/zexdoc.cim zexdoc.com
```

The zexdoc tests are very good however they do not test negative indexed
operations.  I missed a signed two's complement displacement and the test
passed however C compiled code did not work right.  That was hilarious to
debug.

```
$ go test -v github.com/marcopeereboom/toyz80/z80 -run=TestZ  
=== RUN   TestZexDoc
Z80doc instruction exerciser
<adc,sbc> hl,<bc,de,hl,sp>....  OK
add hl,<bc,de,hl,sp>..........  OK
add ix,<bc,de,ix,sp>..........  OK
add iy,<bc,de,iy,sp>..........  OK
aluop a,nn....................  OK
aluop a,<b,c,d,e,h,l,(hl),a>..  OK
aluop a,<ixh,ixl,iyh,iyl>.....  OK
aluop a,(<ix,iy>+1)...........  OK
bit n,(<ix,iy>+1).............  OK
bit n,<b,c,d,e,h,l,(hl),a>....  OK
cpd<r>........................  OK
cpi<r>........................  OK
<daa,cpl,scf,ccf>.............  OK
<inc,dec> a...................  OK
<inc,dec> b...................  OK
<inc,dec> bc..................  OK
<inc,dec> c...................  OK
<inc,dec> d...................  OK
<inc,dec> de..................  OK
<inc,dec> e...................  OK
<inc,dec> h...................  OK
<inc,dec> hl..................  OK
<inc,dec> ix..................  OK
<inc,dec> iy..................  OK
<inc,dec> l...................  OK
<inc,dec> iy..................  OK
<inc,dec> l...................  OK
<inc,dec> (hl)................  OK
<inc,dec> sp..................  OK
<inc,dec> (<ix,iy>+1).........  OK
<inc,dec> ixh.................  OK
<inc,dec> ixl.................  OK
<inc,dec> iyh.................  OK
<inc,dec> iyl.................  OK
ld <bc,de>,(nnnn).............  OK
ld hl,(nnnn)..................  OK
ld sp,(nnnn)..................  OK
ld <ix,iy>,(nnnn).............  OK
ld (nnnn),<bc,de>.............  OK
ld (nnnn),hl..................  OK
ld (nnnn),sp..................  OK
ld (nnnn),<ix,iy>.............  OK
ld <bc,de,hl,sp>,nnnn.........  OK
ld <ix,iy>,nnnn...............  OK
ld a,<(bc),(de)>..............  OK
ld <b,c,d,e,h,l,(hl),a>,nn....  OK
ld (<ix,iy>+1),nn.............  OK
ld <b,c,d,e>,(<ix,iy>+1)......  OK
ld <h,l>,(<ix,iy>+1)..........  OK
ld a,(<ix,iy>+1)..............  OK
ld <ixh,ixl,iyh,iyl>,nn.......  OK
ld <bcdehla>,<bcdehla>........  OK
ld <bcdexya>,<bcdexya>........  OK
ld a,(nnnn) / ld (nnnn),a.....  OK
ldd<r> (1)....................  OK
ldd<r> (2)....................  OK
ldi<r> (1)....................  OK
ldi<r> (2)....................  OK
neg...........................  OK
<rrd,rld>.....................  OK
<rlca,rrca,rla,rra>...........  OK
shf/rot (<ix,iy>+1)...........  OK
shf/rot <b,c,d,e,h,l,(hl),a>..  OK
<set,res> n,<bcdehl(hl)a>.....  OK
<set,res> n,(<ix,iy>+1).......  OK
ld (<ix,iy>+1),<b,c,d,e>......  OK
ld (<ix,iy>+1),<h,l>..........  OK
ld (<ix,iy>+1),a..............  OK
ld (<bc,de>),a................  OK
Tests complete--- PASS: TestZexDoc (330.22s)
PASS
ok      github.com/marcopeereboom/toyz80/z80    330.241s
```

toyz80

toyz80 최신버젼 다운로드

오늘의 추천 프로젝트

Was this content helpful?

Recent Feedback

toyz80

toyz80 최신버젼 다운로드

오늘의 추천 프로젝트

Was this content helpful?

Recent Feedback

Download README