Dragon emulator written in Python ???
Re: Dragon emulator written in Python ???
I enhanced the scraping scripts with: https://github.com/jedie/DragonPy/commi ... ec04c4f6b6
Now i merged the informations from the three sources.
The merged python "data" script looks now -> https://github.com/jedie/DragonPy/blob/ ... ata_raw.py
Now i merged the informations from the three sources.
The merged python "data" script looks now -> https://github.com/jedie/DragonPy/blob/ ... ata_raw.py
... too many ideas and too little time ... Related stuff written in Python:
Dragon 32 emulator / PyDC - Python Dragon 32 converter: https://github.com/jedie/DragonPy
DWLOAD server / Dragon-Lib and other stuff: https://github.com/6809
Dragon 32 emulator / PyDC - Python Dragon 32 converter: https://github.com/jedie/DragonPy
DWLOAD server / Dragon-Lib and other stuff: https://github.com/6809
Re: Dragon emulator written in Python ???
I have worked more on the "code generator"...
The generated code skeleton looks now like this:
full code here: https://github.com/jedie/DragonPy/blob/ ... keleton.py
The generated code skeleton looks now like this:
Code: Select all
class CPU6809Skeleton(object):
@opcode( # Add B accumulator to X (unsigned)
0x3a, # ABX (inherent)
)
def instruction_ABX(self, opcode):
"""
Add the 8-bit unsigned value in accumulator B into index register X.
source code forms: ABX
CC bits "HNZVC": -----
"""
raise NotImplementedError("TODO: $%x ABX") % opcode
@opcode( # Add memory to accumulator with carry
0x89, 0x99, 0xa9, 0xb9, # ADCA (immediate, direct, indexed, extended)
0xc9, 0xd9, 0xe9, 0xf9, # ADCB (immediate, direct, indexed, extended)
)
def instruction_ADC(self, opcode, ea=None, operand=None):
"""
Adds the contents of the C (carry) bit and the memory byte into an 8-bit
accumulator.
source code forms: ADCA P; ADCB P
CC bits "HNZVC": aaaaa
"""
self.CC_HNZVC(a, b, r)
raise NotImplementedError("TODO: $%x ADC") % opcode
...
... too many ideas and too little time ... Related stuff written in Python:
Dragon 32 emulator / PyDC - Python Dragon 32 converter: https://github.com/jedie/DragonPy
DWLOAD server / Dragon-Lib and other stuff: https://github.com/6809
Dragon 32 emulator / PyDC - Python Dragon 32 converter: https://github.com/jedie/DragonPy
DWLOAD server / Dragon-Lib and other stuff: https://github.com/6809
Re: Dragon emulator written in Python ???
Now the generated code is used: https://github.com/jedie/DragonPy/compa ... ...220b514
I reimplement some instructions. e.g.:
COM: https://github.com/jedie/DragonPy/blob/ ... 1273-L1309
JMP: https://github.com/jedie/DragonPy/blob/ ... 1472-L1488
LDA,LDB: https://github.com/jedie/DragonPy/blob/ ... 1529-L1542
I have some trouble to get the CC flags worked. I copied the XRoar code for DEC together:
My Python interpretation is this:
My code is from:
DEC: https://github.com/jedie/DragonPy/blob/ ... 1358-L1418
CC: https://github.com/jedie/DragonPy/blob/ ... #L114-L175
I must collect some concrete example values for the unittests.
Can someone give me some 6809 assembler code examples for carry/overflow cc flags?
I reimplement some instructions. e.g.:
COM: https://github.com/jedie/DragonPy/blob/ ... 1273-L1309
JMP: https://github.com/jedie/DragonPy/blob/ ... 1472-L1488
LDA,LDB: https://github.com/jedie/DragonPy/blob/ ... 1529-L1542
I have some trouble to get the CC flags worked. I copied the XRoar code for DEC together:
Code: Select all
#define SET_Z(r) ( REG_CC |= ((r) ? 0 : CC_Z) )
#define SET_N8(r) ( REG_CC |= (r&0x80)>>4 )
#define SET_NZ8(r) ( SET_N8(r), SET_Z(r&0xff) )
#define CLR_NZV ( REG_CC &= ~(CC_N|CC_Z|CC_V) )
static uint8_t op_dec(struct MC6809 *cpu, uint8_t in) {
unsigned out = in - 1;
CLR_NZV;
SET_NZ8(out);
if (out == 0x7f) REG_CC |= CC_V;
return out;
}
tmp1 = op_dec(cpu, tmp1); break; // DEC, DECA, DECB
Code: Select all
def set_Z8(self, r):
self.Z = 1 if r & 0xff == 0 else 0
def set_N8(self, r):
self.N = 1 if signed8(r) < 0 else 0
def update_NZ8(self, r):
self.set_N8(r)
self.set_Z8(r)
...
r = a - 1
self.cc.update_NZ8(r)
if r == 0x7f:
self.cc.V = 1
DEC: https://github.com/jedie/DragonPy/blob/ ... 1358-L1418
CC: https://github.com/jedie/DragonPy/blob/ ... #L114-L175
I must collect some concrete example values for the unittests.
Can someone give me some 6809 assembler code examples for carry/overflow cc flags?
... too many ideas and too little time ... Related stuff written in Python:
Dragon 32 emulator / PyDC - Python Dragon 32 converter: https://github.com/jedie/DragonPy
DWLOAD server / Dragon-Lib and other stuff: https://github.com/6809
Dragon 32 emulator / PyDC - Python Dragon 32 converter: https://github.com/jedie/DragonPy
DWLOAD server / Dragon-Lib and other stuff: https://github.com/6809
Re: Dragon emulator written in Python ???
Next question: Are all 8/16Bit arithmetic instruction signed?
... too many ideas and too little time ... Related stuff written in Python:
Dragon 32 emulator / PyDC - Python Dragon 32 converter: https://github.com/jedie/DragonPy
DWLOAD server / Dragon-Lib and other stuff: https://github.com/6809
Dragon 32 emulator / PyDC - Python Dragon 32 converter: https://github.com/jedie/DragonPy
DWLOAD server / Dragon-Lib and other stuff: https://github.com/6809
Re: Dragon emulator written in Python ???
next small steps done: BEW, BIT, BNE and "relative" addressing mode, done.
Debug output looks like: https://gist.github.com/jedie/6779646
commints: https://github.com/jedie/DragonPy/commits
Debug output looks like: https://gist.github.com/jedie/6779646
commints: https://github.com/jedie/DragonPy/commits
... too many ideas and too little time ... Related stuff written in Python:
Dragon 32 emulator / PyDC - Python Dragon 32 converter: https://github.com/jedie/DragonPy
DWLOAD server / Dragon-Lib and other stuff: https://github.com/6809
Dragon 32 emulator / PyDC - Python Dragon 32 converter: https://github.com/jedie/DragonPy
DWLOAD server / Dragon-Lib and other stuff: https://github.com/6809
Re: Dragon emulator written in Python ???
Why not simplyjedie wrote: [..]
My Python interpretation is this:Code: Select all
def set_Z8(self, r): self.Z = 1 if r & 0xff == 0 else 0 def set_N8(self, r): self.N = 1 if signed8(r) < 0 else 0 def update_NZ8(self, r): self.set_N8(r) self.set_Z8(r)
Code: Select all
def set_N8(self, r):
self.N = 1 if r & 0x80 else 0
jedie wrote: [..]
I must collect some concrete example values for the unittests.
Can someone give me some 6809 assembler code examples for carry/overflow cc flags?
Code: Select all
lda #-128
suba #1
; overflow set but no carry
lda #127
adda #1
; overflow set but no carry
The dragon on my side: http://klasek.at/hc/dragon/
Re: Dragon emulator written in Python ???
Thank you, that's really really helps me!JeeK wrote:Code: Select all
lda #-128 suba #1 ; overflow set but no carry lda #127 adda #1 ; overflow set but no carry
I have made two unittests:
Code: Select all
def test_Overflow01(self):
self.cpu_test_run(start=0x1000, end=None, mem=[
0x86, 0x80, # LDA #-128
0x80, 0x01, # SUBA #1
])
self.assertEqual(self.cpu.accu_a.get(), 0x7f) # $7f == signed: 127 == unsigned: 127
self.assertEqual(self.cpu.cc.N, 0) # N - 0x08 - bit 3 - Negative result (twos complement)
self.assertEqual(self.cpu.cc.Z, 0) # Z - 0x04 - bit 2 - Zero result
self.assertEqual(self.cpu.cc.V, 1) # V - 0x02 - bit 1 - Overflow
self.assertEqual(self.cpu.cc.C, 0) # C - 0x01 - bit 0 - Carry (or borrow)
def test_Overflow02(self):
self.cpu_test_run(start=0x1000, end=None, mem=[
0x86, 0x7F, # LDA #+127
0x8B, 0x01, # ADDA #1
])
self.assertEqual(self.cpu.accu_a.get(), 0x80) # $80 == signed: -128 == unsigned: 128
self.assertEqual(self.cpu.cc.N, 1) # N - 0x08 - bit 3 - Negative result (twos complement)
self.assertEqual(self.cpu.cc.Z, 0) # Z - 0x04 - bit 2 - Zero result
self.assertEqual(self.cpu.cc.V, 1) # V - 0x02 - bit 1 - Overflow
self.assertEqual(self.cpu.cc.C, 0) # C - 0x01 - bit 0 - Carry (or borrow)
Code: Select all
______________________________________________________________________
test_Overflow01 (__main__.Test6809_CC) ...
init 16384 Bytes ROM (0x8000 - 0xc000)
Read 16383Bytes from d32.rom into ROM 0x8000-0xbfff
init 32768 Bytes RAM (0x0 - 0x8000)
-------------------------------------------------------------------------------
$1000 read pc byte: $86
$1001 read pc byte: $80
$1001 addressing 'immediate byte' value: $80 | $1001: $600-$1dff - Available graphics pages w/o DOS
$1001 *** new op code: $86 (IMMEDIATE) 'instruction_LD8' kwargs: {'operand': <A:0>, 'ea': 4097, 'opcode': 134, 'm': 128}
-------------------------------------------------------------------------------
$1002 read pc byte: $80
$1003 read pc byte: $1
$1003 addressing 'immediate byte' value: $1 | $1003: $600-$1dff - Available graphics pages w/o DOS
$1003 *** new op code: $80 (IMMEDIATE) 'instruction_SUB8' kwargs: {'operand': <A:128>, 'ea': 4099, 'opcode': 128, 'm': 1}
$1004 SUB8 A: -128 - 1 = -129 (unsigned: 127)
-------------------------------------------------------------------------------
ok
______________________________________________________________________
test_Overflow02 (__main__.Test6809_CC) ...
init 16384 Bytes ROM (0x8000 - 0xc000)
Read 16383Bytes from d32.rom into ROM 0x8000-0xbfff
init 32768 Bytes RAM (0x0 - 0x8000)
-------------------------------------------------------------------------------
$1000 read pc byte: $86
$1001 read pc byte: $7f
$1001 addressing 'immediate byte' value: $7f | $1001: $600-$1dff - Available graphics pages w/o DOS
$1001 *** new op code: $86 (IMMEDIATE) 'instruction_LD8' kwargs: {'operand': <A:0>, 'ea': 4097, 'opcode': 134, 'm': 127}
-------------------------------------------------------------------------------
$1002 read pc byte: $8b
$1003 read pc byte: $1
$1003 addressing 'immediate byte' value: $1 | $1003: $600-$1dff - Available graphics pages w/o DOS
$1003 *** new op code: $8b (IMMEDIATE) 'instruction_ADD8' kwargs: {'operand': <A:127>, 'ea': 4099, 'opcode': 139, 'm': 1}
$1004 ADD8 A: 127 + 1 = 128 (unsigned: 128)
-------------------------------------------------------------------------------
ok
You can see: LDA #-128 and SUBA #1 results in accu A == $7f == signed: 127 == unsigned: 127
Flags set to:
N= 0
Z= 0
V= 1
C= 0
Second one LDA #+127 and ADDA #1 results in accu A == $80 == signed: -128 == unsigned: 128
Flags set to:
N= 1
Z= 0
V= 1
C= 0
Is that right?
Have you a example for Carry and Half-Carry?
... too many ideas and too little time ... Related stuff written in Python:
Dragon 32 emulator / PyDC - Python Dragon 32 converter: https://github.com/jedie/DragonPy
DWLOAD server / Dragon-Lib and other stuff: https://github.com/6809
Dragon 32 emulator / PyDC - Python Dragon 32 converter: https://github.com/jedie/DragonPy
DWLOAD server / Dragon-Lib and other stuff: https://github.com/6809
Re: Dragon emulator written in Python ???
I've done some commits: https://github.com/jedie/DragonPy/compa ... ...21a9544
And have more questions:
Where is the STACK in memory? I have found (from http://dragon32.info/info/memmap.html ):
So i set the initial stack pointer to $7E36, is that right?
Next question: Is there no limitation of the stack size? What's happen, if i push more and more values on the stack? "Just" overwrite the "complete" RAM?
And what happen if i PULL more items from stack than exists? PULL memory outside the stack?
And have more questions:
Where is the STACK in memory? I have found (from http://dragon32.info/info/memmap.html ):
Code: Select all
$0021:0022 Top of stack, growing down ($7e36)
Next question: Is there no limitation of the stack size? What's happen, if i push more and more values on the stack? "Just" overwrite the "complete" RAM?
And what happen if i PULL more items from stack than exists? PULL memory outside the stack?
... too many ideas and too little time ... Related stuff written in Python:
Dragon 32 emulator / PyDC - Python Dragon 32 converter: https://github.com/jedie/DragonPy
DWLOAD server / Dragon-Lib and other stuff: https://github.com/6809
Dragon 32 emulator / PyDC - Python Dragon 32 converter: https://github.com/jedie/DragonPy
DWLOAD server / Dragon-Lib and other stuff: https://github.com/6809
Re: Dragon emulator written in Python ???
Not really, no. The ROM loads S with a value after detecting how much RAM is installed.jedie wrote:So i set the initial stack pointer to $7E36, is that right?
It should wrap around between 0 and $FFFF just like other registers.
Re: Dragon emulator written in Python ???
OK, but what's the "default" / "undefined" value of S before RAM size detection? I set it now to 0xffff or maybe a better idea is to set it to 0x0 ? Or is the "start" address completely equal?Sarah wrote:Not really, no. The ROM loads S with a value after detecting how much RAM is installed.jedie wrote:So i set the initial stack pointer to $7E36, is that right?
btw. Inside The Dragon says Stack Space begins at 7F36, so this is the result value if 32K RAM is installed?
I implement "wrap around" for 8/16Bit registers here: https://github.com/jedie/DragonPy/commi ... b1cdb75960Sarah wrote:It should wrap around between 0 and $FFFF just like other registers.
Other question: Whats the initial state of PC ? I tried it to 0x8000 or 0xB3B4
Inside The Dragon says 0xB3B4. So the RESET interrups set the PC to 0xB3B4?
EDIT: OK, tried both:
If PC is set to 0xB3B4 at start, that happens:
Code: Select all
$b3b4 LEA Y: Set Y to $b39b
$b3b7 JMP to $8000
$8000 JMP to $bb40
So i think 0xB3B4 is better as initial as $8000, isn't it?
... too many ideas and too little time ... Related stuff written in Python:
Dragon 32 emulator / PyDC - Python Dragon 32 converter: https://github.com/jedie/DragonPy
DWLOAD server / Dragon-Lib and other stuff: https://github.com/6809
Dragon 32 emulator / PyDC - Python Dragon 32 converter: https://github.com/jedie/DragonPy
DWLOAD server / Dragon-Lib and other stuff: https://github.com/6809