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.

$ 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=$E001
 
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.

Here’s an approach that uses filesystem functions. When combined with some lesser-known PHP streams functionality, it has several practical applications.

Opening Files for Reading and Writing

There are several modes for opening a file that will allow you to seek to arbitrary positions in the file and read or write at those positions. One of the most frequently used of these modes is w+, which the tmpfile function uses automatically.

We can repeatedly write, then rewind the pointer and read:

$f = tmpfile();
fwrite($f, 'foo');
fwrite($f, 'bar');
 
rewind($f);
$contents = stream_get_contents($f);  //=> "foobar"
fclose($f);

When writing to the filesystem, the above provides yet another inefficient solution to David’s exercise. Now let’s take it a bit further to see how this can be useful.

In-Memory Streams

PHP 5.1 introduced two new in-memory streams: php://memory and php://temp. The php://memory stream operates entirely in memory. The php://temp stream operates in memory until it reaches a given size, then transparently switches to the filesystem.

We can modify the above example to use the php://memory stream instead of hitting the filesystem:

$f = fopen('php://memory', 'w+');
fwrite($f, 'foo');
fwrite($f, 'bar');
 
rewind($f);
$contents = stream_get_contents($f);  //=> "foobar"
fclose($f);

Putting a string inside a fast temporary stream can be very useful. For example, we can then attach filters to that stream.

Testing

Temporary streams are also handy for testing. There are some rather elaborate virtual file system libraries out there but many time

Truncated by Planet Horde, read more at the original (another 4353 bytes)

• kizapr-u102.bin
• sizapr-u103.bin
• sept-m-13apr-u104.bin
• ss-calc-13apr-u105.bin

You can also download them as a single archive: commodore-lcd-roms.zip

I’ve always been curious about this machine so I sent my device 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!

The slides are now available in PDF format.

We were located in Hall B of the Santa Clara Convention Center, which is a very large room that’s also used for the keynotes. Andi told us the room was selected based on the number of people who registered for our session. We initially had doubts but the attendance was greater than any previous year and the room worked out quite well. We were thankful that unlike last year, everyone was able to get a seat.

Thank you to all who attended. We enjoyed meeting many of you during the breaks and hope that you found our session helpful.

Since much of the hardware I restore is over twenty-five years old, at least half of it is not working when I receive it. I try to repair everything I can when it’s practical. My Flickr photos page has daily progress of my chip-level repairs on this equipment.

Recently, I received a Commodore SuperPET computer. This is a remarkable machine that was a collaboration between Commodore and the Computer Systems Group at the University of Waterloo in Ontario, Canada. The SuperPET is a standard Commodore PET 8032 computer with an internal expansion that adds a powerful Motorola 6809 microprocessor, an additional 64K of expansion RAM, a fast 6551-based RS232 serial port, and custom Waterloo software in ROM.

The SuperPET can operate in MOS 6502 mode, where it is a Commodore PET 8032 with the extra 64K expansion and 6551 ACIA. Curiously, this 64K expansion memory is not compatible with the 8096. A switch on the side puts the SuperPET into 6809 mode, where it can run a number of disk-based Waterloo programming languages including BASIC, Pascal, APL, Fortan, and COBOL. When in 6809 mode, a menu in ROM prompts the user to select a language which is then loaded from disk.

My SuperPET seemed to work when I got it, with the 6502 mode working perfectly and 6809 mode showing the power-on menu. However, after obtaining the disk-based software, none of the Waterloo languages would run after loading. After verifying the disks were good, I suspected the 64K expansion RAM since the rest of the machine seemed to be working. Using technical information from the PET Index on 6502.org, I wrote several memory test programs to exercise the expansion RAM.

The expansion RAM is comprised of thirty-two 4116 DRAM chips. A couple of these had become loose from their sockets and my test program found that one of them had failed. I got a replacement from the pick-up counter at Jameco and installed it. Now, my SuperPET passes my expansion memory test and also boots all of the Waterloo languages. It is now fully functional and I’m exploring the Waterloo software.

One of the most interesting features of the Waterloo languages is how files are accessed. Commodore disk drives attached to the SuperPET are accessed with a filename like disk8/1.program-name which selects unit 8, drive 1. The SuperPET was designed to be attached to a mainframe computer, known as the “host”, through its serial port. Accessing a file like host/program-name would load it from the mainframe if it was running the special HOSTCM program from Waterloo.

The HOSTCM program was available for VM/CMS and other mainframe operating systems. Beyond that, I’ve not been able to find out much information about it. I would like to figure out the protocol and write a program so that a modern PC could be used as a host computer for the SuperPET.

If you have any information on the SuperPET or have Commodore hardware you’d like to donate, please contact me.