DragonPy is a Open source (GPL v3 or later) emulator for the old (1981) homecomputer Dragon 32 and Tandy TRS-80 Color Computer (CoCo)...

The MC6809 project is used to emulate the 6809 CPU.

Dragon 32 with CPython 3 under Linux:

Tandy TRS-80 Color Computer 2b with CPython 2 under Windows:

(Note: Python 2 support was removed)

DragonPy is written in Python. It's platform independent and runs with Python and PyPy under Linux/Windows/OSX/... It's tested with Python 3.x, PyPy

DragonPy will not be a second XRoar written in Python. This project is primarily to lean and understand.

Future goals are:

• Implement a integrated development environment for BASIC programs

A full featured Dragon / CoCo emulator is XRoar.

The Dragon 32 / 64 and CoCo ROMs works in Text mode. Also the "single board computer" ROMs sbc09, Simple6809 and Multicomp6809 works well.

There is a rudimentary BASIC editor with save/load BASIC programm listings direct into RAM.

Looks like this:

(older version of the editor)

The Vectrex (Wikipedia) is a vector display-based video game console. The Hardware are only the 6809 CPU, a 6522 Versatile Interface Adapter and the AY-3-8912 sound chip.

Current state is completely not usable. The 6522 is only a dummy implementation. It makes only sense to display some trace lines, e.g.:

.../DragonPy$ poetry run DragonPy --verbosity 0 --machine=Vectrex run --trace --max_ops=1

Use "BASIC editor / open" in the main menu to open the editor.

You can load/save ASCII .bas files from you local drive or just type a BASIC listing ;) With "inject into DragonPy" you send the current listing from the Editor to the Emulator and with "load from DragonPy" back from emulator to editor. Note: The is currently no "warning" that un-saved content will be "overwritten" and there is no "auto-backup" ;)

The "renumbering" tool can be found in the editor window under "tools"

You can also run the BASIC Editor without the Emulator:

.../DragonPy$ make editor
# or:
.../DragonPy$ poetry run DragonPy editor

A rudimentary BASIC source code highlighting is available and looks like this:

Special feature: The Line number that are used in GOTO, SOGUB etc. are extra marked on the left side.

IMPORTANT: The PyPi package name is DragonPyEmulator and not only "DragonPy"!!!

pip install DragonPyEmulator

~$ git clone https://github.com/jedie/DragonPy.git
~$ cd DragonPy/
~/DragonPy$ ./cli.py --help

The output of ./cli.py --help looks like:

Usage: ./cli.py [OPTIONS] COMMAND [ARGS]...

╭─ Options ────────────────────────────────────────────────────────────────────────────────────────╮
│ --help      Show this message and exit.                                                          │
╰──────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Commands ───────────────────────────────────────────────────────────────────────────────────────╮
│ download-roms       Download/Test only ROM files                                                 │
│ editor              Run only the BASIC editor                                                    │
│ gui                 <<< **start this** - Start the DragonPy tkinter starter GUI                  │
│ log-list            List all exiting loggers and exit.                                           │
│ run                 Run a machine emulation                                                      │
│ version             Print version and exit                                                       │
╰──────────────────────────────────────────────────────────────────────────────────────────────────╯

The output of ./cli.py run --help looks like:

Usage: ./cli.py run [OPTIONS]

 Run a machine emulation

╭─ Options ────────────────────────────────────────────────────────────────────────────────────────╮
│ --verbosity           INTEGER RANGE [0<=x<=3]              Verbosity level; Accepts integer      │
│                                                            value e.g.: "--verbose 2" or can be   │
│                                                            count e.g.: "-vv"                     │
│                                                            [default: 0; 0<=x<=3]                 │
│ --trace/--no-trace                                         Create trace lines                    │
│                                                            [default: no-trace]                   │
│ --max-ops             INTEGER                              If given: Stop CPU after given cycles │
│                                                            else: run forever                     │
│ --machine             [CoCo2b|Dragon32|Dragon64|Multicomp  Used machine configuration            │
│                       6809|Simple6809|Vectrex|sbc09]       [default: Dragon32]                   │
│ --help                                                     Show this message and exit.           │
╰──────────────────────────────────────────────────────────────────────────────────────────────────╯

Usage e.g.:

~/DragonPy$ ./cli.py run
~/DragonPy$ ./cli.py editor

All needed ROM files, will be downloaded automatically.

The files will be downloaded from:

sbc09 and Vectrex ROMs are included.

All ROM files and download will be checked by SHA1 value, before use.

Please use dev-cli.py for development.

The output of ./dev-cli.py --help looks like:

Usage: ./dev-cli.py [OPTIONS] COMMAND [ARGS]...

╭─ Options ────────────────────────────────────────────────────────────────────────────────────────╮
│ --help      Show this message and exit.                                                          │
╰──────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Commands ───────────────────────────────────────────────────────────────────────────────────────╮
│ check-code-style            Check code style by calling darker + flake8                          │
│ coverage                    Run tests and show coverage report.                                  │
│ fix-code-style              Fix code style of all cli_base source code files via darker          │
│ install                     Run pip-sync and install 'cli_base' via pip as editable.             │
│ mypy                        Run Mypy (configured in pyproject.toml)                              │
│ publish                     Build and upload this project to PyPi                                │
│ safety                      Run safety check against current requirements files                  │
│ test                        Run unittests                                                        │
│ tox                         Run tox                                                              │
│ update                      Update "requirements*.txt" dependencies files                        │
│ update-readme-history       Update project history base on git commits/tags in README.md         │
│ update-test-snapshot-files  Update all test snapshot files (by remove and recreate all snapshot  │
│                             files)                                                               │
│ version                     Print version and exit                                               │
╰──────────────────────────────────────────────────────────────────────────────────────────────────╯

Run tests, e.g.:

~/DragonPy$ ./dev-cli.py coverage
# or just:
~/DragonPy$ ./dev-cli.py test
# or with different Python versions:
~/DragonPy$ ./dev-cli.py tox

"sbc09" ROM in Tkinter window:

"Simple6809" ROM in Tkinter window:

The keyboard mapping is stored into dragonpy/Dragon32/keyboard_map.py.

Some notes:

• "CLEAR" is mapped to "Home" / "Pos 1" key
• "BREAK" is mapped to "Escape" button
• "LEFT" is mapped to left cursor key and to normal backspace, too.

A "auto shift" mode is implemented. So normal lowercase letters would be automaticly converted to uppercase letters.

It is possible to paste the content of the clipboard as user input in the machine. Just copy (Ctrl-C) the follow content:

10 CLS
20 FOR I = 0 TO 255:
30 POKE 1024+(I*2),I
40 NEXT I
50 I$ = INKEY$:IF I$="" THEN 50

Focus the DragonPy window and use Ctrl-V to paste the content.

Looks like:

Then just RUN and then it looks like this:

        Main Thread                                     Sub Thread
       (Tkinter GUI)
    +------------------+                         +---------------------+
    |                  |                         |                     |
    | +-------------+  |  CPU cycles/sec queue   |                     |
    | |            <------------------------------------+6809 CPU      |
    | |             |  |                         |       +     ^       |
    | |     GUI     |  |                         |       |     |       |
    | |             |  | Display RAM write queue |    +--v-----+--+    |
    | |  .--------------------------------------------+   Memory  |    |
    | |  |          |  |                         |    +--+-----^--+    |
    | |  |          |  |                         |       |     |       |
    | |  |          |  |                         | +-----v-----+-----+ |
    | |  |          |  |                         | |    Periphery    | |
    | |  |          |  |     Keyboard queue      | |   MC6883 SAM    | |
    | |  |          +--------------------------------->MC6821 PIA    | |
    | |  |          |  |                         | |                 | |
    | +--+-----^----+  |                         | |                 | |
    |    |     |       |                         | +-----------------+ |
    |    |     |       |                         |                     |
    | +--v-----+----+  |                         |                     |
    | |             |  |                         |                     |
    | |   Display   |  |                         |                     |
    | |             |  |                         |                     |
    | +-------------+  |                         |                     |
    +------------------+                         +---------------------+

The current implementation is not really optimized.

With CPython there is round about 490.000 CPU cycles/sec. in console version. This is half as fast as the real Hardware.

With PyPy round about 6.900.000 - 8.000.000 CPU cycles/sec. In other words with PyPy it's 8 times faster as the real Hardware.

e.g. The Dragon 32 6809 machine with a 14.31818 MHz crystal runs with: 0,895MHz (14,31818Mhz/16=0,895MHz) in other words: 895.000 CPU-cycles/sec.

• implement more Dragon 32 periphery
• missing 6809 unittests after coverage run:
  • MUL
  • BVS

Some Python/BASIC tools/scripts around Dragon32/64 / CoCo homecomputer.

All script are copyleft 2013-2020 by Jens Diemer and license unter GNU GPL v3 or above, see LICENSE for more details.

• PyDC - Convert dragon 32 Cassetts WAV files into plain text:
  • github.com/jedie/DragonPy/tree/master/PyDC
• Filter Xroar traces:
  • github.com/jedie/DragonPy/tree/master/misc

• Simple memory HEX viewer:

  • github.com/jedie/DragonPy/tree/master/BASIC/HexViewer

• Test CC Registers:

  • github.com/jedie/DragonPy/tree/master/BASIC/TestCC_Registers

/BASIC/InputOutput/keyboard.bas Display memory Locations $0152 - $0159 (Keyboard matrix state table)

Example screenshow with the "Y" key is pressed down. You see that this is saved in $0153:

Example with "U" is hold down:

• Grant Searle's Multicomp FPGA project:
  • Homepage: http://searle.x10host.com/Multicomp/
  • own dragonpy/Multicomp6809/README
• Lennart Benschop 6809 Single Board Computer:
  • Homepage: http://lennartb.home.xs4all.nl/m6809.html
  • own dragonpy/sbc09/README
• Grant Searle's Simple 6809 design:
  • Homepage: http://searle.x10host.com/6809/Simple6809.html
  • own dragonpy/Simple6809/README

Some links:

• http://www.burgins.com/m6809.html
• http://www.maddes.net/m6809pm/ - Programming Manual for the 6809 microprocessor from Motorola Inc. (now Freescale)
• http://www.6809.org.uk/dragon/hardware.shtml
• http://dragondata.worldofdragon.org/Publications/inside-dragon.htm
• http://koti.mbnet.fi/~atjs/mc6809/ - 6809 Emulation Page

Source codes:

• github.com/naughton/mc6809/blob/master/mc6809.ts
• github.com/maly/6809js/blob/master/6809.js
• http://mamedev.org/source/src/mess/drivers/dragon.c.html
• http://mamedev.org/source/src/mess/machine/dragon.c.html
• http://mamedev.org/source/src/emu/cpu/m6809/m6809.c.html
• github.com/kjetilhoem/hatchling-32/blob/master/hatchling-32/src/no/k/m6809/InstructionSet.scala

Dragon 32 resources:

• Forum: http://archive.worldofdragon.org/phpBB3/index.php
• Wiki: http://archive.worldofdragon.org/index.php?title=Main_Page

Some code based on:

An Apple ][ emulator in Python

• Author: James Tauber
• github.com/jtauber/applepy
• License: MIT

A really cool Dragon / CoCo emulator

• Author: Ciaran Anscomb
• http://www.6809.org.uk/xroar/
• License: GNU GPL v2

Page output and find dimensions of console.

• Author: Anatoly Techtonik
• License: Public Domain
• Homepage: bitbucket.org/techtonik/python-pager/
• Stored here: /dragonpy/utils/pager.py

Motorola S-Record utilities

• Author: Gabriel Tremblay
• License: GNU GPL v2
• Homepage: github.com/gabtremblay/pysrec
• Stored here: /dragonpy/utils/srecord_utils.py

Dragon/CoCO Python Library

• Author: Jens Diemer
• pypi.org/project/DragonLib/
• github.com/6809/dragonlib
• License: GNU GPL v3

Implementation of the MC6809 CPU in Python

• Author: Jens Diemer
• pypi.org/project/MC6809
• github.com/6809/MC6809
• License: GNU GPL v3

generic syntax highlighter

• Author: Georg Brandl
• pypi.org/project/Pygments
• http://pygments.org/
• License: BSD License

We use cli-base-utilities to generate the history in this README.

To make a new release, do this:

• Increase your project version number
• Run tests to update the README
• commit the changes
• Create release

• v0.9.2
  • 2024-04-16 - Bugfix packaging
  • 2024-04-16 - Update requirements and apply manageproject updates
  • 2024-02-09 - Update requirements
  • 2024-01-16 - Update requirements + fix code style
  • 2023-12-17 - Fix code style and typos
  • 2023-12-17 - Don't slow down tests because of mass DEBUG log output
  • 2023-12-17 - Apply manageprojects updates
• v0.9.1
  • 2023-11-03 - Fix CI
  • 2023-11-03 - Apply manageprojects updates
  • 2023-11-03 - fix test_tokens_in_string()
  • 2023-11-03 - Auto generate README history
  • 2023-11-03 - Use https://github.com/jedie/cli-base-utilities
  • 2023-11-02 - Bump pip from 23.2.1 to 23.3
• v0.9.0
  • 2023-08-05 - fix publish
  • 2023-08-05 - Split CLI and dev-CLI + remove Python 3.9 support
  • 2023-03-07 - update requirements
  • 2023-03-07 - Update README
• v0.8.0
  • 2023-03-07 - Update README.md
  • 2023-03-06 - Migrate to pip-tools via https://github.com/jedie/manageprojects
  • 2022-10-19 - update requirements
  • 2022-09-11 - Add mandelbrot2.bas
  • 2022-09-11 - Add mandelbrot1.bas listing
  • 2022-08-22 - README.creole -> README.md + update requirements + add some tests
  • 2022-08-22 - cache ~/.cache/
  • 2022-08-22 - don't delete ROM files in tests
  • 2022-08-22 - small code style updates
  • 2022-08-22 - project updates
  • 2022-02-01 - Move click cli commands to devshell
  • 2022-01-31 - +'pip cache information'
  • 2022-01-31 - fix code style
  • 2022-01-31 - Temporary speedup github actions by make the matix smaller ;)
  • 2022-01-31 - Remove linting action -> Obsolete because linting is done via pytest plugin
  • 2022-01-31 - Download ROMs before starting tests (should be cached)
  • 2022-01-31 - Deny any requests in tests via autouse pytest fixtures
  • 2022-01-31 - Display output on error
  • 2022-01-31 - Bugfix: Exist on CLI usage
  • 2022-01-30 - remove a PytestCollectionWarning
  • 2022-01-30 - Fix code styles
  • 2022-01-30 - update utils.py
  • 2022-01-30 - fix format
  • 2022-01-30 - fix meta config stuff
  • 2022-01-30 - Refacotor "download_roms" from old CLI into a dev-shell command
  • 2022-01-30 - remove nose test from CLI
  • 2022-01-30 - Use dev-shell
  • 2022-01-30 - Cache pip+roms

| Forum | http://forum.pylucid.org/ | | IRC | #pylucid on freenode.net | | Jabber | pylucid@conference.jabber.org | | PyPi | pypi.org/project/DragonPyEmulator/ | | Github | github.com/jedie/DragonPy |

• Send Bitcoins to 1823RZ5Md1Q2X5aSXRC5LRPcYdveCiVX6F