Py65 0.4 Released Jun 6, 2009

Posted by Mike Naberezny in Hardware,Python

Py65 0.4 has been released. Py65 provides tools for simulating hardware based on 6502-like microprocessors.

Here are the highlights of this release:

• We now support an additional microprocessor simulation: the 65C02. While still a work in progress, it is fairly complete and quite usable. It is based on the W65C02S microprocessor from the Western Design Center (WDC).
• The monitor now supports assembling and disassembling the 65C02 opcodes. You can select the target microprocessor with the new mpu command.
• There have been many other small additions and fixes to the monitor, the most useful of which is that most commands now have shortcuts such as d for disassemble.
• A manual has been started and will be periodically published online. It is currently focused on the monitor usage.

For a complete list of changes in this release, please see the changelog. Special thanks to Oscar Lindberg for making major contributions to this release.

If you’re new to Py65, the README has an overview, installation instructions, and a link to the online documentation.

PyWorks 2008 Slides Nov 15, 2008

Posted by Mike Naberezny in Hardware,PHP,Python

Slides from my PyWorks 2008 talks are now available. This conference was shared with php|works and I enjoyed this format. It was great to see many of my Python and PHP friends at the same event. Thanks to everyone who attended my talks.

Py65: Microcontroller Simulation with Python

Download Slides (PDF)

This talk introduced the venerable 6502 microprocessor family, building small computer systems with these parts, and then simulating those systems with Py65.

The audience participation was great. We had fun stepping through some small assembly language programs on the simulator. One attendee wrote:

This was fascinating and the speaker was awesomely enthusiastic. The overview of microcontrollers and their significance was enlightening and entertaining. The simulator design presented was fantastically simple and very Pythonic. I can’t wait to see where this project goes.

Thanks and I’m glad you enjoyed it. For updates on the Py65 simulator, please watch my blog and the Py65 project page on Ohloh.

URL Mapping with Routes

Download Slides (PDF)

We explored the Routes library from the ground up, setting it up and then exploring its options and matching. We worked through many of the examples with live demos on the Python interactive interpreter.

The talk was attended by several Pylons users, who gained a better understanding of how Routes works by seeing it outside the context of any particular web framework.

URL Mapping with Horde/Routes

Download Slides (PDF)

Bonus Slides! Horde/Routes is a PHP 5 library that is a direct port of Routes. Since there were so many PHP folks at this conference as well, I ported all of the examples in my Routes talk to work with Horde/Routes.

These slides will help you get acquainted with the PHP version. Since the two presentations are otherwise identical, you might also find it an interesting comparison between Python and PHP 5.

Py65 0.1: Introducing Py65Mon Nov 9, 2008

Posted by Mike Naberezny in Hardware,Python

Py65 0.1, a 6502 microprocessor simulator written in Python, has been released and is available on the Python Package Index (PyPI). You can now easy_install it:

$ easy_install py65

Py65Mon

Since my initial announcement of Py65, there have been many bug fixes and unit tests added. The most noticeable addition is a new machine language monitor. It will be installed automatically and is started with the py65mon command:

$ py65mon

Py65 Monitor

<6502: A=00, X=00, Y=00, Flags=20, SP=ff, PC=0000>
.

At the prompt, type help for a list of commands or help command for help on a specific command. The monitor commands are very similar to the excellent VICE Monitor, so VICE users should feel right at home.

The biggest difference from VICE is that the load command requires a load address as the second argument and starts reading the binary data from byte 0. It does not expect byte 0 and 1 of the file to contain a Commodore-style load address. Also, assembling and disassembling from the monitor are not yet implemented but are planned.

Hello World

Just like Michal Kowalski’s 6502 Macroassembler & Simulator for Windows, Py65Mon will trap writes to $E001 and echo the bytes to STDOUT.

This is enough to get us to our first “Hello World” program running under Py65. First, we’ll write a short assembly language program to print the message. Save it as hello.asm.

*=$C000
CHAROUT=$F001      ;Originally $E001, now $F001 since Py65 0.2

HELLO:
  LDX #$00
LOOP:
  LDA MESSAGE,X
  BEQ DONE
  STA CHAROUT
  INX
  JMP LOOP
DONE:
  RTS

MESSAGE = *
  !text "Hello, World!"
  !byte 0

We then assemble the program into a binary, using Marco Baye’s Acme Cross-Assembler:

src$ acme --format plain --outfile hello.bin hello.asm

The --format plain switch instructs Acme not to prepend the Commodore-style load address in the binary. If you’d like to get going quickly, you can also download hello.bin.

With the binary ready, we can start the monitor and load it in:

src$ py65mon

Py65 Monitor

<6502: A=00, X=00, Y=00, Flags=20, SP=ff, PC=0000>
.add_label c000 hello

<6502: A=00, X=00, Y=00, Flags=20, SP=ff, PC=0000>
.load "hello.bin" hello
Wrote +29 bytes from $c000 to $c01c

Py65Mon supports symbolic addressing in most commands. The first command, add_label, defines hello as a label for address $C000. The second command loads the binary into that address.

We can now set the program counter with the registers command, and execute the code up to RTS with the return command.

<6502: A=00, X=00, Y=00, Flags=20, SP=ff, PC=0000>
.registers pc=hello

<6502: A=00, X=0d, Y=00, Flags=20, SP=ff, PC=c000>
.return
Hello, World!
<6502: A=00, X=0d, Y=00, Flags=20, SP=ff, PC=c00e>
.

Now we have run the program, printed “Hello, World!”, and returned to the prompt. We can see the program counter is left at $C00E.

You can also use the step command to step through the program. Just set the program counter to the start address again ($C000 or hello) and repeatedly enter step. As you are stepping repeatedly, you can simply hit ENTER to repeat the last command.

From here you can also explore other commands, e.g. mem c000:c003 to display the memory in that address range. The default radix is hexadecimal. You can also prefix with $ for hexadecimal or + for decimal, like mem +49152:+49155.

Next Steps

Py65 and its monitor are now complete enough to run most simple 6502 programs, including many from the 6502.org Source Code Repository. The next versions will include more I/O devices and monitor commands, with the goal of running a sophisticated 6502 program like Lee’s Davisons’ Enhanced 6502 BASIC.

Commodore LCD Firmware, Schematics, and Specifications Oct 4, 2008

Posted by Mike Naberezny in Hardware

Download images of the EPROMs in Bil Herd’s Commodore LCD prototype:
commodore-lcd-roms-bil-herd.zip (Added Oct 4, 2008)

Download images of the EPROMs in Jeff Porter’s Commodore LCD prototype:
commodore-lcd-roms-jeff-porter.zip (Added May 24, 2023)

Download the prelim spec: commodore-lcd-preliminary-spec.pdf (Added May 15, 2012)
Download more specifications: commodore-lcd-specs.zip (Added Mar 11, 2017)
Download the schematics: commodore-lcd-schematics.zip (Added May 27, 2022)

I’ve always been curious about this machine so I sent my EPROM programmer to Bil so that he could read the EPROMs. Bil was very kind to do this and we should all thank him for it. This is the first time that these images have been seen in many years.

Start your disassemblers!

Update May 15, 2012: Via Bil Herd, Bob Russell has provided the Preliminary Specification of the LCD. The actual prototype hardware owned by Bil Herd has quite a few differences from this spec.

Update Jan 21, 2014: Gábor Lénárt used these dumps to create a Commodore LCD emulator in JavaScript. Incredible work!

Update Nov 28, 2014: Bil Herd has posted a Commodore LCD Teardown video on YouTube.

Update Dec 7, 2016: Added a dump of the character ROM from Bil’s LCD and photos. The character ROM is socket U16, which appears to be a 2332 pinout like the C64. The character ROM itself is a 2764 EPROM with a sticker “LCD CHAR ROM“. The extra pins hang out of the socket and are tied to Vcc with hand-wiring, including the highest address line, so 4K is readable by the LCD. Bil and I dumped this 2764 in my EPROM programmer. We did not disturb the hand-wiring, so we only read 4K of it (like the LCD does). The data layout is like other Commodore character ROMs. Steve Gray created a rendering of it. The character set is interesting compared to other Commodore computers; e.g. the presence of a tilde and curly braces that were perhaps added to support the built-in terminal.

Update Mar 11, 2017: Added a new ZIP file, commodore-lcd-specs.zip, with specifications. It includes detailed technical descriptions of the LCD controller and MMU chips. These were scanned by Andy Finkel and forwarded by Bil Herd.

Update May 12, 2022: I’ve created a GitHub repository with Commodore LCD ROM disassemblies. I started with the LCD KERNAL disassembly by Gábor Lénárt and have disassembled and commented more routines.

Update May 27, 2022: Added a new ZIP file, commodore-lcd-schematics.zip, with the schematics. The original pages are owned by Bil Herd. Thanks to Bil for allowing them to be scanned and posted.

Update June 1, 2022: Johan Grip has redrawn the schematics in KiCad and released his files under the CERN Open Hardware License v2.0 Strongly-Reciprocal (CERN-OHL-S). According to this explanation, it is a “strong copyleft” license. Alternatively, the original Commodore LCD schematics are available and contain the same information.

Update May 24, 2023: Added a new ZIP file, commodore-lcd-roms-jeff-porter.zip, with dumps of the EPROM’s from Jeff Porter’s Commodore CLD prototype. Photos of Jeff’s CLCD and his printer are also available.