SIGNETICS-BASED MACHINES CODING/GAMING GUIDE -------------------------------------------- This document was written on 29/8/08, and last updated on 3/7/21, by James Jacobs of Amigan Software. Information herein is believed to be generally accurate, though some is tentative. If you have anything to contribute, please email amigansoftware@gmail.com. This document deals with these machines, in this order: PIPBUG/BINBUG-based machines Signetics Instructor 50 Central Data 2650 Kitronix Coin-ops Zaccaria Coin-ops Chaos 2 Senko Coin-ops Dolphin PHUNSY Ravensburg Selbstbaucomputer MIKIT 2650 PoP Comparative Table Pong Other Signetics-Based Machines There are separate Coding and Gaming Guides for the Emerson Arcadia 2001, Interton VC 4000, and Elektor TV Games Computer. -------------------------------------------------------------------------- PIPBUG-Based Machines --------------------- ANNOTATE and HOWDIF both support PIPBUG-based machines; remember to use the appropriate PIPBUG_J, PIPBUG_K, PIPBUG_L, PIPBUG_M or PIPBUG_P (for ANNOTATE) or ASCII (for HOWDIF) argument. You should ensure that your SYMbol file has the correct start address for your game. ANNOTATEd disassemblies of every available game are now available, so therefore you should not normally need to use DASMX or ANNOTATE. Disassembly of PGM Files ------------------------ See also the Emerson Arcadia 2001 Coding Guide for information about usage of DASMX and VACS, and comprehension of these disassemblies. 1. Make a backup of the .PGM file, to verify against later. 2. Optional: If the game makes heavy use of calls to the PIPBUG monitor, you could copy the monitor to $4..$3FF. 3. Disassemble with DASMX. 4. Annotate with ANNOTATE. 5. Assemble with VACS. 6. Use HOWDIF to verify that the newly generated binary is identical to the original binary. Overview -------- KHz: 1000 ROM: 1K PIPBUG RAM: varies Output: Teletype Input: Teletype Storage: 110 baud Kansas City (audio cassette tape or papertape) These machines have been available since 1975 or 1976. They have been offered as kits and as assembled systems, in various configurations by various manufacturers, including Signetics (ie. Philips), Applied Technology, etc. Their defining characteristic is the use of the 1K PIPBUG ROM BIOS by Signetics as their operating system ("monitor"). This in turn dictates the use of a 2650-family CPU at 1MHz. (PIP stands for Programmable Integrated Processor; it is another name for the 2650). Generally, there is software compatibility betweem these machines. However, issues such as the differing locations (and amounts) of expansion RAM in different machines can cause problems. These machines are not frame-based; they lack a graphics coprocessor (eg. PVI or UVI). The system is effectively CPU + ROM + RAM. There are thus no graphics. However, the output can of course be sent to a Visual Display Unit (VDU) aka monitor (as is done by Ami/WinArcadia), or to a printer-style device, eg. a teletype machine. The ROM (BIOS), as mentioned, is 1K and consists of the PIPBUG monitor firmware. Reading input from a keyboard or teletype is achieved by reading the Sense bit of the CPU. Writing output to a VDU or teletype is achieved by writing the Flag bit of the CPU. Or, you can use the Flag bit to output sound. But you cannot do text output and sound output simultaneously. All I/O is done in ASCII format. Loading and saving from/to papertape and cassette is also supported (on the real machine, but not the emulators). They are designed to be used in conjunction with a standard 110-baud ASCII-based teletype device, such as the DEC VT50, VT52 or VT100, or the Electronics Australia Low Cost VDU. Some machines possess a S-100 ("Altair") bus or other such features (which are not currently emulated). The optional 4-digit LED display lacks decimal points, in contrast to the Signetics Instructor 50 and Dolphin platforms. Writing an output character is done from right to left (bit #0 first, then #1..#7), as follows: Flag on r5 = r0; DLAY(); DLAY(); Flag off for (r4 = 8; r4 > 0; r4--) { DLAY(); r5 >>= 1; if (r5 & %10000000) { Flag on } else { Flag off } } DLAY(); Flag on CHIN returns with an input character in R0, but not until there is input (ie. it is synchronous). The high bit is used for parity and is always masked out by CHIN; therefore, only 7-bit input is supported. (Ie. the extended ASCII set values $80..$FF are unsupported.) The Sense bit is normally high. It pulses low during key transmission (ie. whilst receiving clear bits of a byte). Waiting for the Sense bit to become clear is therefore equivalent to "press any key to continue". Randomization is normally done by asking the user for a keystroke, then rapidly incrementing a register while waiting for the Sense bit to become clear. Eg. printf("PRESS ANY KEY"); HERE: addi,r1 1 tpsu $80 bctr,eq HERE ;if Sense bit is set will generate a random number (0..255) in r1. There is also an optional 4-digit 7-segment LED display which can be attached to the system as an additional output device. Writing to this is done via the WRTD command. The operand is interpreted as follows: bit 7: 1st digit bit 6: 2nd digit bit 5: 3rd digit bit 4: 4th digit bits 3..0: digit ($0..$9 = '0'..'9', $A..$F = ' ') Eg. to write '7' to the 3rd digit would require an operand of $27. A delay is necessary between digit writes on the real machine, but not on the emulator. See the relevant magazine article for more information. CHIN is used for cassette/papertape/keyboard. It works like this: do { switch to alternate register bank PORTC = $80; // enable tape reader } while (Sense bit is set); // ie. until start of start bit PORTC = 0; // disable tape reader DLY(); // wait for half a bit (ie. until centre of start bit) r4 = 0; for (r5 = 8; r5 > 0; r5--) { DLAY(); // wait for one bit r0 = PSU & %10000000; r4 <<= 1; r0 |= r4; r4 = r0; } DLAY(); r4 &= %01111111; // delete parity bit r0 = r4; switch to main register bank clear With Carry flag return; So it is expecting the following format: .01234567# and it returns in the middle of the stop bit (#). So, we enable the tape reader, wait for the Sense bit to become clear, and then disable the tape reader. Then, we read the eight bits from right to left (bits 0..7) via direct sampling of the PSU at the appropriate moment. The parity bit (bit 7) is then discarded (without checking it). COUT is used for cassette/papertape/keyboard. r0 is passed as an argument; it is the ASCII character to be output. It works like this: set Flag bit r5 = r0; DLAY(); DLAY(); clear Flag bit for (r4 = 8; r4 > 0; r4--) { DLAY(); r5 >>= 1; if (r5 & %10000000 == %10000000) { set Flag bit } else { clear Flag bit } } DLAY(); set Flag bit return; So, we set the Flag bit, wait, and clear the Flag bit. Then, we write the eight bits from left to right (bits 0..7). The high bit is not treated any differently to the others. Then we wait again, set the Flag bit and return. Effectively, we write this for each byte: ##.01234567 where # means Flag set, . means Flag clear, and digits mean Flag is set/ cleared according to the relevant bit. We set the Flag before returning. When loading, it waits until the input line goes low, then looks for the start character (':'). Some games have 110 baud and 300 baud versions. These are still all stored on cassette at 110 baud; the baud rate in this case actually refers to the speed of keyboard and screen operations, rather than cassette speed. PIPBUG 2 -------- LLIN and surrounds is: r3 = 0; LLIN: if (r3 == 40) goto EBUG; r0 = CHIN(); if (r0 == DEL) { r0 = r3; if (r0 == 0) goto LLIN; r0 = *($822 + --r3); COUT(r0); goto LLIN; } ... Test program is: for (;;) { r0 = CHIN(); WRTE r0 to extended port $FF REDE r1 from extended port $FF r0 = r1; WRTD r1 to data port WRTC,r0 to control port COUT(r0); } LLIN and surrounds is: r3 = 0; LLIN: if (r3 == 40) goto EBUG; r0 = CHIN(); if (r0 == DEL) { r0 = r3; if (r0 == 0) goto LLIN; r0 = *($822 + --r3); COUT(r0); goto LLIN; } ... Test program is: for (;;) { r0 = CHIN(); WRTE r0 to extended port $FF REDE r1 from extended port $FF r0 = r1; WRTD r1 to data port WRTC,r0 to control port COUT(r0); } Memory Maps ----------- This memory map is supported by AMI/WINARCADIA and ANNOTATE ("P"): EA 78up5+78up10 ("Expanded Mini Computer with EPROM"): 1K ROM + 15.75K RAM + 4K EPROM $0000..$03FF: PIPBUG monitor ROM $0000..$03FD: used $03FE..$03FF: unused? $0400..$0436: expansion RAM (for use by PIPBUG monitor) $0437..$2FF9: expansion RAM (for storage of and use by games) $2FFA..$2FFF: expansion RAM (for use by EPROM) $3000..$3FFF: EPROM $4000..$41FF: ROM? (for eg. PPI-Based 2616 EPROM Programmer) $4200..$57FF: RAM (for the above?) $5800..$7CFF: unused? $6D00..$7FFF: RAM? (eg. for Linearisatie) This memory map is supported by AMI/WINARCADIA but not by ANNOTATE: Modified ABC1500 with CP1002 (see TN132): 2K ROM + 1152 bytes RAM $0000..$03FF: PIPBUG 2 ( 1024 bytes) $0400..$07FF: PIPLA ( 1024 bytes) $0800..$0861: SMI RAM used by PIPBUG2+PIPLA ( 98 bytes) $0862..$087F: SMI RAM unused by PIPBUG2+PIPLA ( 30 bytes) $0880..$0BFF: unused ( 896 bytes) $0C00..$0DFF: motherboard RAM ( 512 bytes) $0E00..$0FFF: optional RAM ( 512 bytes) $1000..$1EFF: unmapped? ( 3840 bytes) $1F00..$1FFF: mirror of $0F00..$0FFF ( 256 bytes) $2000..$7FFF: unmapped? (24576 bytes) These memory maps are supported by ANNOTATE but not by AMI/WINARCADIA: EA 77up2 ("Baby") ("J"): 1K ROM + 256b RAM $0000..$03FF: PIPBUG monitor ROM $0000..$03FD: used $03FE..$03FF: unused? $0400..$0436: 55 bytes of motherboard RAM (for use by PIPBUG monitor) $0437..$04FF: 201 bytes of motherboard RAM (for storage of and use by games) $0500..$07FF: mirrors of $0400..$04FF $0800..$0FFF: mirror of $0000..$07FF $1000..$7FFF: mirrors of $0000..$0FFF Signetics Adaptable Board Computer ("K"): 1K ROM + 512b RAM $0000..$03FF: PIPBUG monitor ROM $0000..$03FD: used $03FE..$03FF: unused? $0400..$0436: 55 bytes of motherboard RAM (for use by PIPBUG monitor) $0437..$05FF: 457 bytes of motherboard RAM (for storage of and use by games) $0600..$07FF: mirror of $0400..$05FF $0800..$0FFF: mirror of $0000..$07FF $1000..$7FFF: mirrors of $0000..$0FFF You will observe that all ROM and RAM is mirrored a total of 16 times (1 "nominal" address and 15 mirrors). The Adaptable Board Computer is in fact another name for the Signetics PC1500 (which is the assembled version of the KT9500). The source for this claim is the fact that the part number of the ABC board is 2650PC1500, as well as the fact that the technical specifications are identical. (The ABC also supports parallel and serial I/O, has an on-board clock, and can be expanded to up to 24K of RAM. These features are not supported by Ami/WinArcadia nor Annotate.) The Signetics PC1001 Microprocessor Prototyping Card (1K RAM) (assembled) is a different, though closely related, machine. The Signetics PC2000 is a 4K expansion RAM board suitable for (at least) the PC1001/PC1500/KT9500. The Signetics PC3000 is another "evaluation kit" (as are the other Signetics-manufactured machines), about which almost nothing is known. The TCT PCG is also known as the ETI-681. EA 78up5 ("1K Mini Computer" aka "2650 Mini Computer") or Signetics PC1001 ("L"): 1K ROM + 1K RAM $0000..$03FF: PIPBUG monitor ROM $0000..$03FD: used $03FE..$03FF: unused? $0400..$0436: 55 bytes of motherboard RAM (for use by PIPBUG monitor) $0437..$07FF: 969 bytes of motherboard RAM? (for storage of and use by games) $0800..$7FFF: unused? EA 78up5+78up10 ("8K Mini Computer"), contiguous configuration ("M"): 1K ROM + 7K RAM $0000..$03FF: PIPBUG monitor ROM $0000..$03FD: used $03FE..$03FF: unused? $0400..$0436: 55 bytes of expansion RAM (for use by PIPBUG monitor) $0437..$1FFF: 7113 bytes of expansion RAM (for storage of and use by games) $2000..$7FFF: unused? These memory maps are not supported by AMI/WINARCADIA nor ANNOTATE: EA 78up5+78up10 ("Expanded Mini Computer"), non-contiguous configuration, without 2K motherboard RAM expansion ("Q"): 1K ROM + 9K RAM $0000..$03FF: PIPBUG monitor ROM $0000..$03FD: used $03FE..$03FF: unused? $0400..$0436: 55 bytes of motherboard RAM (for use by PIPBUG monitor) $0437..$07FF: 1K-55b of motherboard RAM (for storage of and use by games) $0800..$1FFF: unused? $2000..$3FFF: 8192 bytes of expansion RAM (for storage of and use by games) $4000..$7FFF: unused? EA 78up5+78up10 ("Expanded Mini Computer"), non-contiguous configuration, with 2K motherboard RAM expansion ("R"): 1K ROM + 11K RAM $0000..$03FF: PIPBUG monitor ROM $0000..$03FD: used $03FE..$03FF: unused? $0400..$0436: 55 bytes of motherboard RAM (for use by PIPBUG monitor) $0437..$0FFF: 3K-55b of motherboard RAM (for storage of and use by games) $1000..$1FFF: unused? $2000..$3FFF: 8192 bytes of expansion RAM (for storage of and use by games) $4000..$7FFF: unused? EA 78up5 ("4K Mini Computer") ("S"): 1K ROM + 4K RAM $0000..$03FF: PIPBUG monitor ROM $0000..$03FD: used $03FE..$03FF: unused? $0400..$0436: 55 bytes of motherboard RAM (for use by PIPBUG monitor) $0437..$13FF: motherboard RAM (for storage of and use by games) $1400..$7FFF: unused? The mappings of the serial and parallel I/O ports and clock are unknown. ;Hardware Equates/Memory Map (PIPBUG-based machines)---------------------- ; $0000..$03FF: (R/-) 2K of PIPBUG monitor ROM ; $0400..$0436: (R/W) PIPBUG monitor RAM ; $0437..$04FF: (R/W) game RAM ; $0500..$05FF: (*/*) J: mirror of $0400..$04FF ; (R/W) K-M, P: game RAM ; $0600..$07FF: (*/*) J, K: mirror of $0400..$05FF ; (R/W) L, M, P: game RAM ; $0800..$0FFF: (*/*) J, K: mirror of $0000..$07FF ; (?/?) L: unused? ; (R/W) M, P: game RAM ; $1000..$1FFF: (*/*) J, K: mirror of $0000..$0FFF ; (?/?) L: unused? ; (R/W) M, P: game RAM ; $2000..$2FFF: (*/*) J, K: mirror of $0000..$0FFF ; (?/?) L, M: unused? ; (R/W) P: game+utility RAM ; $3000..$3BFF: (*/*) J, K: mirror of $0000..$0BFF ; (?/?) L, M, P: unused? ; $3C00..$3FFF: (*/*) J, K: mirror of $0C00..$0FFF ; (?/?) L, M: unused? ; (R/w) P: utility EPROM ; $4000..$4FFF: (*/*) J, K: mirror of $0000..$0FFF ; (?/?) L, M, P: unused? ; $5000..$5FFF: (*/*) J, K: mirror of $0000..$0FFF ; (?/?) L, M, P: unused? ; $6000..$6FFF: (*/*) J, K: mirror of $0000..$0FFF ; (?/?) L, M, P: unused? ; $7000..$7FFF: (*/*) J, K: mirror of $0000..$0FFF ; (?/?) L, M, P: unused? ;Official PIPBUG Monitor ROM Label Equates-------------------------------- ;INIT equ $0 (R/-) ROM code AINI equ $3 ;(R/-) ROM code VEC equ $19 ;(R/-) ROM data (pointers) EBUG equ $1D ;(R/-) ROM code MBUG equ $22 ;(R/-) ROM code LINE equ $5B ;(R/-) ROM code LLIN equ $60 ;(R/-) ROM code ALIN equ $79 ;(R/-) ROM code ELIN equ $7D ;(R/-) ROM code CLIN equ $7F ;(R/-) ROM code DLIN equ $84 ;(R/-) ROM code CRLF equ $8A ;(R/-) ROM code BLIN equ $95 ;(R/-) ROM code STRT equ $A4 ;(R/-) ROM code ALTE equ $AB ;(R/-) ROM code LALT equ $AE ;(R/-) ROM code CALT equ $D2 ;(R/-) ROM code DALT equ $E3 ;(R/-) ROM code SREG equ $F4 ;(R/-) ROM code LSRE equ $F7 ;(R/-) ROM code ASRE equ $116 ;(R/-) ROM code BSRE equ $12A ;(R/-) ROM code CSRE equ $132 ;(R/-) ROM code GOTO equ $13A ;(R/-) ROM code BK01 equ $160 ;(R/-) ROM code BK02 equ $16E ;(R/-) ROM code BKEN equ $17A ;(R/-) ROM code CLBK equ $1AB ;(R/-) ROM code CLR equ $1CA ;(R/-) ROM code NOK equ $1D7 ;(R/-) ROM code BKPT equ $1E5 ;(R/-) ROM code DISP equ $222 ;(R/-) ROM code BIN equ $224 ;(R/-) ROM code CBCC equ $23D ;(R/-) ROM code LKUP equ $246 ;(R/-) ROM code ALKU equ $248 ;(R/-) ROM code ABRT equ $250 ;(R/-) ROM code ANSI equ $259 ;(R/-) ROM data BOUT equ $269 ;(R/-) ROM code CHIN equ $286 ;(R/-) ROM code ACHI equ $28F ;(R/-) ROM code BCHI equ $296 ;(R/-) ROM code DLAY equ $2A8 ;(R/-) ROM code DLY equ $2AD ;(R/-) ROM code COUT equ $2B4 ;(R/-) ROM code ACOU equ $2C1 ;(R/-) ROM code ONE equ $2CA ;(R/-) ROM code ZERO equ $2CC ;(R/-) ROM code DNUM equ $2D5 ;(R/-) ROM code GNUM equ $2DB ;(R/-) ROM code LNUM equ $2E1 ;(R/-) ROM code BNUM equ $2F2 ;(R/-) ROM code CNUM equ $2F5 ;(R/-) ROM code DUMP equ $310 ;(R/-) ROM code FDUM equ $325 ;(R/-) ROM code CDUM equ $351 ;(R/-) ROM code FORM equ $35B ;(R/-) ROM code GAP equ $35F ;(R/-) ROM code AGAP equ $361 ;(R/-) ROM code ADUM equ $369 ;(R/-) ROM code BDUM equ $36B ;(R/-) ROM code DDUM equ $386 ;(R/-) ROM code EDUM equ $39A ;(R/-) ROM code LOAD equ $3B5 ;(R/-) ROM code ALOA equ $3D4 ;(R/-) ROM code BLOA equ $3E1 ;(R/-) ROM code CLOA equ $3F5 ;(R/-) ROM code ;Official PIPBUG Monitor RAM Variable Equates----------------------------- COM equ $400 ;(R/W) RAM data XGOT equ $409 ;(R/W) RAM code? TEMP equ $40D ;(R/W) RAM data TEMQ equ $40F ;(R/W) RAM data TEMR equ $411 ;(R/W) RAM data TEMS equ $412 ;(R/W) RAM data BUFF equ $413 ;(R/W) RAM data BPTR equ $427 ;(R/W) RAM data MCNT equ $428 ;(R/W) RAM data CNT equ $429 ;(R/W) RAM data CODE equ $42A ;(R/W) RAM data OKGO equ $42B ;(R/W) RAM data BCC equ $42C ;(R/W) RAM data MARK equ $42D ;(R/W) RAM data HDAT equ $42F ;(R/W) RAM data LDAT equ $431 ;(R/W) RAM data HADR equ $433 ;(R/W) RAM data LADR equ $435 ;(R/W) RAM data ;Official Utility RAM Label Equates--------------------------------------- START equ $2FFA ;(R/W) RAM data END equ $2FFC ;(R/W) RAM data NEW equ $2FFE ;(R/W) RAM data ;Official Utility EPROM Label Equates------------------------------------- GPAR equ $3C07 ;(R/w) EPROM subroutine INCRT equ $3C2A ;(R/w) EPROM subroutine PADR equ $3C3C ;(R/w) EPROM subroutine HEXLIST equ $3C50 ;(R/w) EPROM subroutine SEARCH equ $3C6A ;(R/w) EPROM subroutine HEXIN equ $3C8A ;(R/w) EPROM subroutine VERIFY equ $3CDD ;(R/w) EPROM subroutine OK equ $3CF8 ;(R/w) EPROM code section FAULTY equ $3D0E ;(R/w) EPROM code section MOVE equ $3D3B ;(R/w) EPROM subroutine Z3OUT equ $3DBE ;(R/w) EPROM subroutine (300 baud) Z3IN equ $3DE4 ;(R/w) EPROM subroutine (300 baud) ZDUMP equ $3E02 ;(R/w) EPROM subroutine (300 baud) ZLOAD equ $3E53 ;(R/w) EPROM subroutine (300 baud) ZVERIFY equ $3EA2 ;(R/w) EPROM subroutine (300 baud) R/W: read/write R/-: read-only R/w: read/write (but writing requires "burning" EPROM) */*: mirror (resolve address to ascertain R/W attributes) $000..$01C: - $01D..$05A: command handler $05B..$0A3: input a cmd line into buffer $0A4..$0AA: subr that stores double precision into temp $0AB..$0F3: display and alter memory $0F4..$139: selectively display and alter registers $13A..$15F: goto address $160..$1AA: breakpoint runtime code $1AB..$1C9: subr to clear a bkpt $1CA..$223: break point $224..$23C: input two hex chars and form as byte in R1 $23D..$245: calculate the BCC char, EOR and then rotate left $246..$24F: lookup ASCII char in hex value table $250..$268: abort exit from any level of subr $269..$285: byte in R1 output in hex $286..$2A7: 110 baud input for papertape and char 1MHz clock $2A8..$2B3: delay for one bit time $2B4..$2D4: - $2D5..$30F: get a number from the buffer into R1-R2 $310..$35A: dump to paper tape in object format $35B..$3B4: subrs for outputting blanks $3B5..$3FD: load from papertape in object format $3FE..$3FF: unused? Utility EPROM: $2FFA START (RAM) (data) (1st CLI parameter) ($2FFA/$2FFB) $2FFC END (RAM) (data) (2nd CLI parameter) ($2FFC/$2FFD) $2FFE NEW (RAM) (data) (3rd CLI parameter) ($2FFE/$2FFF) $3C07 GPAR (EPROM) (subroutine) $3C2A INCRT (EPROM) (subroutine) $3C3C PADR (EPROM) (subroutine) $3C50 HEXLIST (EPROM) (subroutine) $3C6A SEARCH (EPROM) (subroutine) $3C8A HEXIN (EPROM) (subroutine) $3CDD VERIFY (EPROM) (subroutine) $3CF8 OK (EPROM) (code section) $3CCB ? (EPROM) (subroutine) $3CCE ? (EPROM) (subroutine) $3D0E FAULTY (EPROM) (code section) $3D3B MOVE (EPROM) (subroutine) GuessingGame: STRT = $440 code INPT = $493 code PRNT = $4A6 code MSAG = $4B1 data Life-MachineCode: $C00..$C59: baud rate initialization routine? $C26: LIFECRLF $C39: LIFECOUT $C5A: LIFECHIN $C76..$EEC: Life game code $EED..$F54: Life game variables MicroWorld BASIC: Note that this is *not* byte-for-byte identical to the official PIPBUG release of MicroWorld BASIC, as evidenced by the fact that eg. the official BINBUG patch (aka "personality module") for it will not work. The available dump was originally for PIPBUG, then was ported to PHUNSY, then was ported back to PIPBUG. The first command you should issue is OLD. Then you can RUN or LIST the program. Nim: STRT = $440 code F1..F6, F8..FA: code $4B3 = PRNT code $4BC = MSGE data RYTMON: $172D: r2 = r0; PORTD = $80; gosub $174D; gosub $174D; PORTD = $00; for (r1 = 5; r1 >= 1; r1--) { gosub $174D; r2 >>= 1; if (<) { PORTD = $80; } else { PORTD = $00; } } gosub $174D; PORTD = $80; return; $174D is a delay routine. PIPBUG Commands --------------- A: ALTE Alter Memory B: BKPT Set Breakpoint 1/2 C: CLR Clear Breakpoint 1/2 D: DUMP Dump to Papertape G: GOTO Go To L: LOAD Load from Papertape S: SREG See and Set the Microprocessor *A
Alter Memory 1234 56 # (ie. ENTER) to exit (ie. Ctrl+J) to display the next address to change
to and exit (ie. type the value then press Ctrl+J) to change
to and display the next address *B 1
Set Breakpoint 1 no output if successful *B 2
Set Breakpoint 2 no output if successful *C 1 Clear Breakpoint 1 no output if successful ? if unsuccessful *C 2 Clear Breakpoint 2 no output if successful ? if unsuccessful *D Dump to Papertape *G
Go To *L Load from Papertape *S See and Set the Microprocessor 0..6 = r0..r6 7 = PSU 8 = PSL 56 ? to exit to display the next register to change register to and exit to change register to and display the next register Uppercase input is required at all times. Some useful Ctrl-codes are: Ctrl+G = BEL (7) Ctrl+H = BS (8) Ctrl+I = TAB (9) Ctrl+J = LF (10) Ctrl+M = CR (13) Cassette I/O ------------ A set (1) bit (Sense bit on) is represented by a quickly pulsing signal. About 20 quickly pulsing cycles represents a set bit. A clear (0) bit (Sense bit off) is represented by a slowly pulsing signal. About 10 slowly pulsing cycles represents a clear bit. The length of each bit, in time, is identical regardless of its value. (This is in contrast to the system used on the Elektor, which has identical pulses for all values and differentiates values by the positioning of the pulses.) PIPBUG encodes/decodes the files as Signetics Absolute Object Format (AOF) at 110 baud. There is a low start bit preceding each byte, and two high stop bits following each byte. The parity bit (bit 7 of the data) is always thrown away when reading. The data rate is approximately 10 raw data bytes per second. As values are encoded into ASCII pairs, the actual number of bytes loaded/saved per second from the user's point of view is about 5. As an example, here's the Blackjack game in AOF format: :08EFFF00740F75FF0464C8D2BBA5043EBBA03F06A1E54E980F0402CC0B00040DCC0B010403CC0B02E54C982A3F07873F09923F0498E5031853E50D980F05413F05133F053205413F04E71B6301BBC0B480185F1F08F7E545980A20CC09C9CD09FF1F09A0E5419804C9F21B72E549980720C8ECC8E71BEBE54798063F07871F0731E5501C0000E5589C08F33B0F3F04E13F04F83F026902C13BFA1BED3F04BA3F0498E50398791705413F0513BBA53F062B04209BA03F078707003F049801CF2400E50D1806E503987107003F04D53F04E105423F04E7CF0A063B4C0700044118110F2400E4031808E40D1804BBA01B71FB003F06A1E5089807FB00039A741B59CD0A7428 :09EEFF0CE57F980407001B0801CF2400E50D985F0441980320C801A7001E04AC3F09870C84A9CFE4A93F04ACCB1405423F05133F04E13F05443F0560C8063F04FA07000400985C07003B9B0F2400CC84A9E40D987405413BD83F05323F07891F09A33F04CA3F0498C90A3BC803C106FF3F053C0500CD84623BC5E503986705423F05133F05383F04C2040DE47F18501F0A310001BBA00F85233F04F40E852303C102F800E4FF9806E5001873F900B4801870CC85233F0504CD8523042ABBA01F06DE184FE5259C07273F04F83F051C1BEFE541980A3F06A13F069C3B961B20E54F980B3B8E3B913BE102BBA01B97E55D98103F0498C9073F05133F053205543F04E7E551 :0AEDFF185B9C07353BEAC9733BEB3F05381B92D2DAC1F5020D5022424C41434B4A41434B220D50204C3130303D460D5022594F552048415645202422460D502050205022594F555220424554222049570D54573E46205022544F4F204D554348222047330D54573C3130205022544F4F204C4954544C45222047340D5334360D5022594F55522031535420434152442049532022205333380D4C593D412C323D540D5334360D5022594F5552205345434F4E4420434152442049532022205333380D4C593D420D5334360D50224445414C45522053484F57532022205334390D4C593D430D4C41422B3D410D5022594F552048415645222C412C2253484F57494E472236 :0BECFF140D54543E34204C572A3D57204733370D54413E3231205022594F552752452042555354454422204733320D50224849543F2220415A20545A3A38392047353E0D5334360D5022594F5552204E45585420434152442049532022205333380D4C593D42205D540D47383C0D5334360D50224445414C455220474554532022205334390D4C59432B3D432050224445414C45522053484F5753222C430D54433C31372047333C0D54433E32312050224445414C455220425553544544222047383E0D54413E432047373E0D5022594F55204C4F5345220D4C46572D3D462054463E31302047330D5022594F55275245204F5554220D502257414E5420544F20504CEB :0CEBDE72415920414741494E3F220D41412054413D38392047320D450D502220202A2A594F552057494E2A2A22204C46572B3D462047330D54583A312047343E0D2722414345222050224F5054494F4E222049510D54513D3120520D4C31313D5920520D54583D31312027224A41434B2220520D54583D3132202722515545454E2220520D54583D31332027224B494E472220520D275820520D50204C313321312B3D592C593D580D54593E3130204C31303D590D520D54583A312047373C0D27224143452220543131432B3E323120520D543131432B3E41204731303C0D520D03AA Notes about Cassette Interfaces ------------------------------- PIPBUG, BINBUG (except ACOS), CD2650 and (presumably) Selbstbaucomputer use a standard Kansas City Computer Users Tape Standard (CUTS) cassette interface to transform standard teletype I/O into cassette tape I/O (ie. high and low bits are turned into the appropriate pulse trains when recording, and pulse trains are analyzed and decoded into high and low bits during playback), usually at 110 baud: * Every "0" bit becomes 21.81' cycles (pulses) of a 2400 Hz tone, and * Every "1" bit becomes 10.90' cycles (pulses) of a 1200 Hz tone. In practice, exactly 22 or 11 pulses should be done (as it is best to wait until the next zero crossing before doing the next bit). The BIOS and games only see the teletype Sense and Flag lines, they cannot see the pulse trains. The cassette interface is invisible to the software; as far as it knows there is only an ordinary teletype attached. This means that you can record/play any sort of teletype I/O directly to/ from the tape, not just formal dumps. 300 baud is identical to 110 baud except that only 8 (instead of 22) or 4 (instead of 11) pulses are done; the pulses themselves are identical. To load a tape, translate it to teletype format: * 22 2400 Hz pulses in 9.09' msec = having teletype Sense low for 9.09' msec ("0"). * 11 1200 Hz pulses in 9.09' msec = having teletype Sense high for 9.09' msec ("1"). * If we see a zero crossing every 413.2231 usec it is a "0", and we should see 22 of those (or more if there are several 0 bits). * If we see a zero crossing every 826.4463 usec it is a "1", and we should see 11 of those (or more if there are several 1 bits). and vice versa when saving: * while teletype Sense is 0, flip the tape Sense every 413.2231 / 2 usec. * while teletype Sense is 1, flip the tape Sense every 826.4463 / 2 usec. This is sufficient for all baud rates and encodings. Here is a diagrammatic view of the system: In record mode: Computer Tape Terminal (VDU/keyboard) * -> Flag -----(tape can save this)---> VDU * <- Sense <--(input comes from kybd)--- Keyboard In replay mode: Computer Tape Terminal (VDU/keyboard) * -> Flag -----(tape ignores this)----> VDU * <- Sense <--(input comes from tape) ! Keyboard PIPBUG Decompilation -------------------- Be aware that PIPBUG, and programs for it, generally run with signed (arithmetic) comparisons, as opposed to the Arcadia, etc. which generally run with unsigned (logical) comparisons. COUT has the following side effects when called: PSL: CC = lt; PSL: primary register bank (r1..r3) is always selected PSU: Flag pin is always set r0 = r4 = 0; r5 = the old r0 (ie. what you passed) You should not call it when SP > 5 (you need one level of stack for COUT's return address and another level for DLAY's return address). CHIN has the following side effects when called: PSL: CC = gt; PSL: primary register bank (r1..r3) is always selected PSL: With Carry bit is always set r0 = r4 = return code (1..127) r5 = *(DATABUS) = 0; You should not call it when SP > 5 (you need one level of stack for CHIN's return address and another level for DLAY's/DLY's return address). LIFECOUT has the following side effects when called: PSL: CC = eq; PSL: primary register bank (r1..r3) is always selected PSU: Flag pin is always set r1 = *(DATABUS); r0 = r6 = 0; You should not call it when SP > 4 (you need one level of stack for LIFECOUT's return address, another level for LIFEDELAY's return address, and another level for LIFEDELAY_ALT's return address. LIFECHIN has the following side effects when called: PSL: CC = gt; PSL: primary register bank (r1..r3) is always selected PSL: With Carry bit is always clear r0 = r4 = return code (1..127) r5 = r6 = 0; You should not call it when SP > 4 (you need one level of stack for LIFECHIN's return address, another level for LIFEDELAY's return address, and another level for LIFEDELAY_ALT's return address. Monitor Variables--------------------------------------------------------- *(BPTR): current digit - 1 (ie. buffer size - 1) *(CODE): set by LINE 1 = CR 2 = LF 3 = msg + CR 4 = msg + LF *(TEMR): current register (0..8) *(COM)..*(COM + 6): contents of r0..r6 *(COM + 7): contents of PS? *(COM + 8): contents of PS? Subroutine LINE----------------------------------------------------------- ;The return code is r1, as follows: ; 0 = failure? ; 1 = CR ; 2 = LF ; 3 = msg + CR ; 4 = msg + LF *(BPTR) := r3 := -1; LLIN: for (;;) { if (r3 == BLEN) goto ELIN; // #define BLEN 20 r0 := CHIN(); if (r0 == DELE) // #define DELE $7F { if (r3 != -1) { r0 := *(BUFF + r3); gosub COUT(r0); r3--; } continue; } // implied else if (r0 == CR) // #define CR 13 { ELIN: r1 := 1; // we will return 1 or 3 CLIN: r0 := r3; if (r3 >=) r1 += 2; // ie. if something is in buffer or, if (r3 >= 0 && r3 <= $7F) r1 += 2; *(CODE) := r1; *(CNT) := r3; CRLF: COUT(CR); // #define CR 13 COUT(LF); // #define LF 10 return; } // implied else r1 := 2; if (r0 == LF) goto CLIN; // we will return 2 or 4 *(BUFF + ++r3) = r0; COUT(r0); } End of Subroutine--------------------------------------------------------- Subroutine SREG----------------------------------------------------------- SREG: ;$F4 r2 = GNUM(); for (;;) { if (r2 > 8) goto EBUG; *(TEMR) = r2; r0 = r1 = *(COM + r2); BOUT(r1); // show old value (byte in r1 output in hex) gosub FORM; // printf(" "); r0 = *(CODE) = LINE(); if (r0 < 2) goto MBUG; // exit from "S" command if (r0 == 0) goto CSRE; // failure? never executed anyway? ASRE: ;$116 *(TEMQ) = r0; // ie. *(CODE) r0 = GNUM(); r2 = *(TEMR); *(COM + r2) = r0; // write new value if (r2 != 8) goto BSRE; *(XGOT + 1) = r0; // operand! BSRE: ;$12A r0 = *(TEMQ); // ie. *(CODE) if (r0 == 3) goto MBUG; // if msg+CR, exit from "S" command CSRE: ;$132 r2 = *(TEMR) + 1; } End of Subroutine--------------------------------------------------------- Subroutine DNUM----------------------------------------------------------- DNUM: r0 := *(CODE); if (r0 == 0) goto LNUM; // implied else return; GNUM: r0 := r1 := r2 := *(CODE) := 0; LNUM: r3 := *(BPTR); if (*(BPTR) == *(CNT)) return; r0 := *(*(BUFF) + ++r3); *(BPTR) := r3; if (r0 == ' ') goto DNUM; BNUM: gosub LKUP; CNUM: r1 = ( r1 << 4) & %11110000; // 1st digit r0 = (oldr2 << 4) & %00001111; // 3rd digit newr2 = (oldr2 << 4) & %11110000; // 2nd digit r0 |= r1; r1 := r0; r2 |= r3; r0 := 1; *(CODE) := r0 [1]; goto LNUM; End of Subroutine--------------------------------------------------------- Subroutine CHIN----------------------------------------------------------- CHIN: ;$286 *(DATABUS) = %10000000; // enable tape reader r4 := 0; while (PSU & Sense); // look for start bit *(DATABUS) = %00000000; // disable tape reader gosub(DLY); // waste 3+1460=1463 cycles for (r5 := 8; r5 > 0; r5--) // loop eight times { gosub(DLAY); // wait to middle of data (waste 3+2996=2999 cycles) r0 = PSU & Sense; r4 >>= 1; r4 |= r0; } /* Bits are read from least significant (low bits) to most significant (high bits). This example assumes $FF (or at least $7F) is being received: 1st time: r4 is $00 %........ now r4 becomes $80 %0....... 2nd time: r4 has become $40 %.0...... now r4 becomes $C0 %10...... 3rd time: r4 has become $60 %.10..... now r4 becomes $E0 %210..... 4th time: r4 has become $70 %.210.... now r4 becomes $f0 %3210.... 5th time: r4 has become $78 %.3210... now r4 becomes $F8 %43210... 6th time: r4 has become $7C %.43210.. now r4 becomes $FC %543210.. 7th time: r4 has become $7E %.543210. now r4 becomes $FE %6543210. 8th time: r4 has become $7F %.6543210 now r4 becomes $FF %76543210 High bit (bit 7) is parity! */ gosub(DLAY); // waste 3+2996=2999 cycles r4 &= %01111111; // delete parity bit r0 := r4; ;clear With Carry bit retc,un End of Subroutine--------------------------------------------------------- Subroutine DLAY----------------------------------------------------------- DLAY: // delay for one bit time ;$2A8 r0 = 0; ;2 512 iterations of BDRR,R0 ;1536 DLY: ;$2AD: ;1460 ;alternate entry point 256 iterations of BDRR,R0 ;768 r0 = $E5; ;2 229 iterations of BDRR,R0 ;687 retc,un ;3 End of Subroutine--------------------------------------------------------- I/O Timing ---------- At 1MHz, there are 1,000,000 short/fast cycles per second, which is 333,333.3' long/slow cycles per second. So each long/slow cycle lasts for 1,000,000/333,333.3'=3uS. At 110 baud, each bit ideally lasts for 9090.90' uS. At 300 baud, each bit ideally lasts for 3333.3' uS. At 1200 baud, each bit ideally lasts for 833.3' uS. For a 110 baud teletype, a full bit delay is: bsta,un TDLA ;3 TDLA: eorz r0 ;2 bdrr,r0 $ ;256*3 bdrr,r0 $ ;256*3 TDLY: bdrr,r0 $ ;256*3 lodi,r0 229 ;2 bdrr,r0 $ ;229*3 retc,un ;3 =3001 long/slow cycles=9003uS. and a half bit delay is: bsta,un TDLY ;3 TDLY: bdrr,r0 $ ;256*3 lodi,r0 229 ;2 bdrr,r0 $ ;229*3 retc,un ;3 =1463 long/slow cycles=4389uS. For a 1200 baud RS-232 terminal, a full bit delay is: bsta,un DLAY ;3 DLAY: lodi,r0 89 ;2 DL1: bdrr,r0 DL1 ;3 retc,un ;3 3+2+(3*89)+3=275 long/slow cycles=825uS. and a half bit delay is: bsta,un DLY ;3 DLY: lodi,r0 58 ;2 bctr,un DL1 ;2 DL1: bdrr,r0 DL1 ;3 retc,un ;3 3+2+2+(3*58)+3=184 long/slow cycles=552uS. Note that these delays are shorter than the ideals. However, keep in mind that there is also code that must be run by the caller to process (emit/ receive) each bit; this takes a certain amount of time to run. Each character begins with a start bit (%0). Then data bits 0..6 are sent (least significant bits first). Then a parity bit is sent. Then stop bits are sent? The letter "U" has the 7-bit ASCII code of $55 (%1010101). This would be transmitted as %0,1010101,1. The DG640+TCT PCG are mapped as follows: $7000..$77FF: UDG definitions (each UDG is 8*16 pixels): $7000: 1st row of UDG #0 : : : $700F: 16th row of UDG #0 $7010: 1st row of UDG #1 : : : $701F: 16th row of UDG #1 $77F0: 1st row of UDG #127 : : : $77FF: 16th row of UDG #127 $7800..$7BFF: bit 7: inverse video on/off bits 6..0: character ($00..$7F) $7C00..$7FFF: bit 7: red bit 6: green bit 5: blue bits 4..3: unused bit 2: UDG (otherwise PDG) bit 1: graphics on/off bit 0: flash on/off To read the joystick buttons, use a REDE of port $09. Bits are: bits 7..6: unused bits 5..3: switch bits for joystick A Switch '1' = %000 (fire/serve) Switch '2' = %001 Switch '3' = %010 Switch '4' = %011 Switch '5' = %100 Switch '6' = %101 Switch '7' = %110 Nothing = %111 bits 2..0: switch bits for joystick B (same format as for joystick A) To read the joystick paddles, first WRTE a value of $00..$07 to port $EF, according to what you want to read: Channel '1' (%000): 2nd joystick horizontal Channel '2' (%001): 2nd joystick vertical Channel '3' (%010): 1st joystick horizontal Channel '4' (%011): 1st joystick vertical Channel '5' (%100): unused (or 3rd joystick horizontal) Channel '6' (%101): unused (or 3rd joystick vertical ) Channel '7' (%110): unused (or 4th joystick horizontal) Channel '8' (%111): unused (or 4th joystick vertical ) Now REDE from port $EF in a loop until the MSB is low (ie. until something in the $00..$7F range is returned). The X-axis is inverted, ie. $00=right..$7F=left The Y-axis is normal , ie. $00=up ..$7F=down Game Help --------- Biorhythm: Dates are expected to be in mm/dd/yy format. DG640 Driver: To get the flashing cursor, you need PIPBUG (not BINBUG). ETI-685 Memory Tester: This expects BINBUG 6.1. It is used as follows: G440 where and are the start and end addresses, eg.: G440 1000 1FFF Funny Farm Races: 1. At the "PLAYER 1-" prompt: Type in the name of the first player and press ENTER. 2. For each additional player you want to add: Press P. The machine will say "PLAYER 2-" (or whatever). Type in the name of the player and then press ENTER. 3. Press ENTER to begin. 4. For each player: The machine will ask "BET?". For each bet you want to place: Press Y and then press ENTER. The machine will ask "DOG NO?". Press the number (0..9) of your preferred dog and then press ENTER. The machine will ask "HOW MUCH?". Press N when this player has placed all their bets. 5. Watch the race and then press ENTER. 6. Go to 4. Furnace: This program requires extra hardware (eg. various motors), which is not emulated by AmiPIPBUG/WinPIPBUG. Although it will load and run, it will not do anything useful on the emulators, and, intentionally, does not produce output on the screen. Also, it expects a data table (starting at !6000), which is not present. Guessing Game (machine code version): "When called, the program will wait until you enter any character. It will then generate a random number between 1 and 99, which you must guess. Starting address is $0440." HexCal: Enter source address (2 hex digits), then "/" appears. Enter destination address (2 hex digits), then "=" appears, and tells you the relative offset. Eg. 01/02=01 03/04=7F 05/05=00 The first digit of each pair entered is not echoed to the display until the second digit has been input. Life-MachineCode: "Life is a matrix game concerned with the life, death and birth of cells. Imagine each cell to be in a two-dimensional linear matrix, such that each cell location has eight possible neighbours, as shown: 1 2 3 4 X 5 6 7 8 The rules of cell life, death and birth are as follows: 1. A live cell will survive if it has two or three live neighbours. 2. A live cell will die if it has less than two or more than three live neighbours. 3. A birth in an empty cell will occur if it has exactly three live neighbours. 4. Births and deaths take place simultaneously. To work with practical terminals the program operates with a limited size matrix, but makes it effectively "infinite" by having "wrap around" from side to side and from top to bottom. In our version of Life, live cells are represented by Os, and dead or empty cells as blanks. The program starts with an initial pattern (fed in by the player), and calculates the new patterns "generation by generation". The 32x16 versions are intended for use with the Low Cost VDU of EA February and April 1978. The 32x24 versions are intended for terminals such as the EME-1 VDU, described in the EA January and February 1977 issues. To use the program, type: GC00 and then switch to the appropriate baud rate (110 or 300 baud). Then type a U for 110 baud operation, or a Y for 300 baud operation. The program will respond with the word "LIFE", followed by the prompt character ":". If you respond with "N", the program will expect a new matrix to be supplied. The program will echo the N, followed by a carriage return and line feed. A pattern may then be written in (or "seeded") by using the space bar for blanks (these are printed as dots), Os for live cells, and line feeds (LF) [Ctrl+J in Ami/WinArcadia] for new lines. Blanks are not required on the right hand side of the pattern. Carriage return (CR) will permit overwriting of a line, allowing error correction. Once your pattern is complete, use LFs if necessary to advance to the bottom of the matrix. Once the pattern is completed, the program will reprint it, and give the prompt sign again. If you now respond with a Gxx, $xx generations will be evolved, with a printout after the last generation. G00 will produce printout after 256 generations, while G01 will produce a printout after only one generation. And so on... Immediately after you have typed in this command, the program will respond with a message such as <15S, to indicate that in less than 15 seconds it will print out the result of the Gxx instruction. After printing the result the new generation count and prompt will appear at the bottom left hand corner of the screen. This may overwrite live cells, so try and keep your patterns in the centre of the screen (patterns to the right will wrap around to the left). The remaining instruction is P, which causes the program to print out the existing matrix. The instruction is not used a great deal. This is the result of a simple pattern. This stabilises after four generations, and then continues forever unchanged: O GENERATION 1 OOO O GENERATION 2 OO O OO GENERATION 3 OO OO OO GENERATION 4 O O OO OO GENERATION 5 O O OO One of the most interesting and simple patterns has been named the "Glider". The seed for this is shown below: O O OOO If you are running Life at 1200 baud, it is better to use the autoprint version, which prints out after every generation, and stops automatically when the pattern stabilises. Simply feed in a starting pattern (using the N command), and sit back and watch. The program will continue until a stable pattern is achieved, at which time it will stop. Note, however, that it cannot detect recurring cyclical patterns, so watch out for these. To stop them, you will have to use the reset facility of the 2650." Linearisatie: This program requires extra hardware, eg. light pen, which is not supported by AmiPIPBUG/WinPIPBUG. Although it will load and run, it will not do anything useful on the emulators, and, apparently intentionally, does not produce output on the screen. Lunar Lander (machine code version): The display is as follows: F = Fuel (out of 40) V = Velocity (- is down (towards surface), + is up (away from surface)) D = Distance from surface (- is underground, + is above ground) Maths Demonstration: "This program provides the functions of a simple, 3-function calculator. It will multiply, add or subtract two single digit decimal numbers. Normal plus, minus and equals signs are used, with an asterisk symbol for multiplication. Starts at $0440." Memory Test: You use the program as follows: G48F where is "01".."7F". ("80".."$FF" give infinite tests.) Eg.: G48F 0500 3FFF 7F If there is no resulting output other than linefeeds (just goes back to the "*" prompt), this indicates success. Errors are as follows: Z or S mean that cleared (zeroed) memory did not read back as $00. W means that a single bit of memory (eg. $10) did not read back correctly. L means that set memory did not read back as $FF. The address of the error then follows the error code. Message Editor: "Upon being called, this program will give a prompt character, and await a command character. Command T allows a message to be entered, C allows a stored message to be checked, and R allows it to be repeated until the CPU is reset. In text input mode, the Del character acts as a destructive backspace for correcting errors. To return to command mode, type an Esc. If the message being stored is too long for the buffer, an F will be displayed. Starts at $0440." Micro BASIC programs (eg. Guessing Game (Micro BASIC version), Lunar Lander (Micro BASIC version), Radio Log, Temperature Conversion): Type G1 and then press ENTER to begin execution. Relative Branch Calculator: Enter source address (4 hex digits). Enter destination address (4 hex digits), then "=" appears, and tells you the relative offset (or "?" if out of range). The first digit of each pair entered is not echoed to the display until the second digit has been input. Mini-Disassembler: You must type 6 consecutive hex digits. These are not echoed to the screen (except that Ami/WinArcadia V15.72+ do this for you). The first 4 digits are the starting address (including any leading zeroes) and the last 2 digits are the least significant byte of the ending address (the most significant byte is always the same as that of the starting address). Eg.: 0440FF will disassemble $440..$4FF. Note that the mnemonics used are not always standard Signetics. Eg.: HLT = HALT LPU = LPSU LPL = LPSL PPU = PPSU PPL = PPSL To disassemble another region, type: G440 at the command prompt ("*"). If you get another "*", retry; otherwise, now enter a new 6-digit address range. There are bugs in the published program listing, causing incorrect disassembly of some instructions. There is a fixed version in the Enhancements Pack. There is also the following unfixed bug: Some situations (eg. 3-byte instruction at $1FE..$200 when range argument was "0100FF") result in the mini-disassembler not detecting the end of the range and instead wrapping back around. Music: "The "Music" program occupies locations $4A0 to $5D3, and uses PIPBUG routines. It contains absolute addresses, and is not easily relocated. The music is generated at the flag output of the 2650, and some form of audio transducer is required. This can simply be an audio amplifier and speaker, connected via a suitable attenuator, to the buffered flag output of the CPU. Monotonic musical notes are generated by pulsing the flag output at suitable rates, with the program "reading" the music from a section of memory. The timing of the music is determined by a time value called "UNIT", which is an even number of up to 15 bits, such that $5160 is about 1/32 of a second. Each note is specified by two bytes. The first byte represents the number of UNITs that the note will last: $01 gives a duration of 1 UNIT, while $00 gives 256 UNITs, or 8 seconds with a UNIT value of $5160. The second byte is split into three fields. The most significant bit, bit 7, indicates either a note (%0) or a rest (%1). The next three bits, bits 4, 5 and 6, specify the octave. %111 represents the top octave, while %000 represents the lowest. In practice, the three lowest octaves are not usable, giving a range of only five octaves. The remaining four bits in the second byte represent the note within the octave. The first note in any octave is E, represented by $0, while the last note is D# (D sharp), represented by $B. For rests, bits 6 to 0 are not used, so all rests become $80. It is best to start and end all programs (tunes!) with $80 $80, a long rest, to separate the music from the noises PIPBUG makes while communicating with the terminal. To signify the end of a tune, insert $02 $FF after the long rest. "Yankee Doodle" occupies locations $5D4 to $6B7, and requires a unit value of $2800, while "Bach" occupies locations $6B8 to $7A3, and requires a unit value of $7000. To run the program, type: G58C [
] [] The last two parameters are optional. If they are not given, the program will use the previous values. Thus, to play "Yankee Doodle", type: G58C 5D4 2800 and for "Bach" type: G58C 6B8 7000" -v. low-- ---low--- -middle-- ---high-- -v. high- $30 E $40 E $50 E $60 E $70 E $31 F $41 F $51 F $61 F $71 F $32 F#/Gb $42 F#/Gb $52 F#/Gb $62 F#/Gb $72 F#/Gb $33 G $43 G $53 G $63 G $73 G $34 G#/Ab $44 G#/Ab $54 G#/Ab $64 G#/Ab $74 G#/Ab $35 A $45 A $55 A $65 A $75 A $36 A#/Bb $46 A#/Bb $56 A#/Bb $66 A#/Bb $76 A#/Bb $37 B $47 B $57 B $67 B $77 B $38 C $48 C $58 C $68 C $78 C $39 C#/Db $49 C#/Db $59 C#/Db $69 C#/Db $79 C#/Db $3A D $4A D $5A D $6A D $7A D $3B D#/Eb $4B D#/Eb $5B D#/Eb $6B D#/Eb $7B D#/Eb $80 rest For the purposes of the above table, each "octave" is assumed to begin at E. Note that there is a short delay for Yankee Doodle and a long delay for Bach, before they actually begin to play the song. Nim: "The game of Nim: starting with 23 you and the program take turns at subtracting a number from 1 to 3. The one that leaves 1 after their move wins. Starting address is $0440." The winning strategy is as follows: You will have a turn where there are 6..8 widgets. Taking 1..3 widgets accordingly on this turn will leave 5 widgets. The computer must then take 1..3 widgets, leaving 2..4 widgets. You should then take 1..3 widgets accordingly, to leave 1 widget and therefore win. OnScreenClock: The original published version has a bug at $505 ($00 should be $0C). Set the time like this before starting at $500: *($573) = tens of hours r3 = ones of hours r2 = tens of minutes r1 = ones of minutes All values are stored in ASCII format. Eg. for '5', use $35 (ASCII '5'), not $05. When the time reaches 13:00, it will reset back to 01:00. Rotate: "The computer generates a 4*4 array of the first 16 letters of the alphabet, arranged in a random order. The object of the game is to rearrange the array into the following form: A B C D E F G H I J K L M N O P The array can only be rearranged by rotating [2*2] blocks of four letters clockwise. The block to be rotated is specified by the letter in its top left hand corner. It is invalid to try to rotate by calling letters on either the bottom row or the right hand column of the array. If a mistake is made, it can be corrected once between valid rotations. Any two adjacent letters can be exchanged, with the proviso that only one exchange is permitted. When the required pattern has been achieved, or when the game is aborted, the program will print out the number of moves used. The program occupies locations $440 to $5C7, and uses routines from PIPBUG. To run the program, type: G440 and the computer will respond with "PRESS ANY KEY". Once this has been done, a random pattern will be generated and printed, and the prompt message "ROTATE:" given. Here is a sample printout. The "Z" command was used to terminate the game. *G440 PRESS ANY KEY OJMD EPLI BFHK CNAG ROTATE: F OJMD EPLI BNFK CAHG ROTATE: N OJMD EFLI BANK CHFG ROTATE: N OJMD EPLI BAFN CHGK ROTATE: F OJMD EPLI BAGF CHKN ROTATE: EXCHANGE: L,M OJLD EPMI BAGF CHKN ROTATE: P OJLD EAPI BGMF CHKN ROTATE: M OJLD EAPI BGKM CHNF ROTATE: CANCEL OJLD EAPI GMNF CHKN ROTATE: G OJLD EAPI BHGF CKMN ROTATE: YOU TOOK 07 MOVES If you wish to rotate a particular block, type the letter in the top left hand corner of that block. If you wish to cancel a move, type carriage return, and the program will respond with "CANCEL", and then reprint the last but one block. If you wish to exchange two adjacent letters, type X. The program will respond with "EXCHANGE:", and expect you to type in the two desired letters. If you cannot solve a particular pattern, type Z, and this will abort the game. An average pattern, with only one exchange permitted, should take between 25 and 30 moves. Early attempts may take more." Note that the game does not enforce the rule about only permitting one exchange per game. The unpatched version (ie. as found in the Games Pack) will not work on Ami/WinArcadia. You should use the patched version (ie. as found in the Enhancements Pack). Othello (Reversi) 2.0: Input must be in Y,X (row,col) format. Printer Routines, Trace Routine: Of course, the provided binaries do nothing (ie. do not "work") by themselves, as they are only subroutines. See the relevant magazine articles for more information about how to use them. Solitaire: This game expects a display with more than 16 rows. The SVT-100 terminal which is emulated by Ami/WinArcadia is only one of the output devices that could be hooked up to a real PIPBUG machine. The game was probably designed for a teletype. We suggest using the "Log|Echo I/O to console?" option. Time: This program uses cycle counting techniques. Under Ami/WinArcadia 8.41, this programs appears to run too fast (ie. the "game" time goes faster than the emulator time). The two most likely possibilities would be: (a) the program was not originally tested and tuned to a sufficient precision by its programmer; and/or (b) the real machine is spending a certain number of cycles servicing interrupts. (which don't occur in the emulator). Of course, since it starts counting from minute 1 rather than minute 0, the time as shown in this program will be minute later than that shown by the emulator. When this program says "0100" (ie. "one hour"), emulator time should be approximately "00:59:00.00" (though it would be fair to allow a few milliseconds for initialization). However, emulator time when this event occurs is actually only "00:58:47.20". So this program is 12.80 seconds fast over that 59 minutes. (Or, conversely, you could suggest that the emulator is slow by that amount, or a combination of both.) Such accuracy is approximately 1:276.5625 (slightly worse than 1 second fast per 5 minutes), which makes this program rather useless over lengthy periods. Vector Magnetometer: This program expects extra input (eg. various sensors) and output (eg. pitch and roll indicators) hardware, which is not supported by AmiPIPBUG/ WinPIPBUG. (The LED display, used for output of heading data, is supported.) Although it will load and run, it will not do anything useful on the emulators, and, intentionally, does not produce output on the main screen (only via the LED display). Printer ------- Hardware: In condensed mode, width is 32 columns * 8 pixels = 256 pixels. In expanded mode, width is 16 columns * 16 pixels = 256 pixels. Speed is 2 lines/sec (512 pixels/sec). Printing is left to right. Every 1953.125 cycles (at 1 MHz), it print a column of pixels (dots) (slightly more than 10 such columns per frame). EA printer interface: Uses the data port for (parallel) input and output. Does not use buffering. Can accept a new character every 64th of a second (in condensed mode) or every 32nd of a second (in expanded mode). As soon as the game writes to the data port, it prints the character. While printing is in progress, the high bit of the input data port is low. It is high while idle. ETI-641 printer interface: Uses extended port $19 (25) for (parallel) input and output. Uses an internal 128-byte buffer. Can accept a new character every 200,000th of a second (5 usecs). Once the internal buffer fills, or a CR is received by the printer, it prints (and empties) the entire buffer. While printing is in progress, the high bit of the input extended port $19 (25) is low. It is high while idle. To convert from ASCII to EUY format: output = (input & 0x1F) | ((input & 0x60) << 1); output = ^output; so: %00000000..%00011111 ( 0.. 31) %00100000..%01111111 (32..127) -> %01000000..%11011111 (64..127) %0xx00000 -> %xx00000 %01000000..%11011111 (64..127) %00100000..%00111111 (32..63) -> %0100000..%01011111 (64..127) ASCII -> EUY $00..$1F -> $00..$1F $20..$3F -> $40..$5F $40..$5F -> $80..$9F eg. 'A' ($41 -> $81) $60..$7F -> $C0..$DF $80..$9F -> $00..$1F $A0..$BF -> $40..$5F $C0..$DF -> $80..$9F $E0..$FF -> $C0..$DF The above table is before the one's complement operation. ETI AU article, table 2 is: PPSU $02 ;logical compare LODI,r1 0 PRINT: REDE,r0 $19 BCFR,lt PRINT LODA,r0 BUFFER,r1++ COMI,r0 $04 BCTA,eq END WRTE,r0 $19 BCTR,un PRINT END: LODI,r0 $0D ;CR WRTE,r0 $19 RETC,un ;EA printer driver (at $1400..$143E) is: PSL |= RS; PORTD = $00; r0 = $2A; while (--r0 != 0); PORTD = $40; r5 = r6 = 0; for (;;) { r0 = r5; if (r0 != 0) { r6++; r0 = $20 [' ']; } else { r0 = *($143E + ++r6); if (r0 == 0) { r5 = $FF ['.']; r0 = $20 [' ']; } } r0 |= $40; PORTD = r0; r0 = $C7; while (--r0 != 0); if (r6 == $20) { r4 = 32; do { r0 = 256; while (--r0 != 0); } while (--r4 != 0); PSL &= ~RS; return; } // implied else do { r0 = PORTD; } while (r0 & $80 != $80); } Alternative Operating Systems ----------------------------- Various alternative operating systems were available, eg. C-BUG, SBCBUG, etc. with various levels of compatibility with programs designed for the original PIPBUG. If you have dumps, manuals, etc. for any of these, please email us (at amigansoftware@gmail.com). The following routines are cross-compatible between PIPBUG and BINBUG: Address Label ------- ----- $1D EBUG $5B LINE $8A CRLF $A4 STRT $269 BOUT $27D AGAP $286 CHIN $2B4 COUT $2DB GNUM The following routines have the same names, and roughly equivalent functionality, under both PIPBUG and BINBUG; however, they have different addresses and therefore are not directly cross-compatible. They may also have different register usage, stack usage, side effects, etc. PIPBUG BINBUG Label ------ ------ ----- $1F $22 MBUG $AB $B9 ALTE $F4 $F1 SREG $131 $121 GOTO $160 $14A BK01 $1AB $17B CLBK $1CA $197 CLR $1E5 $1A1 BKPT $246 $28C LKUP $2A8 $39B DLAY $2AD $39F DLY $310 $2E5 DUMP $35B $27B FORM $35F $2FB GAP $3B5 $3C4 LOAD Some variables may also be cross-compatible. BINBUG outputs both to the serial port (at 300 baud) and to the VDU. This VDU RAM is 1K at $7800..$7FFF. The data is stored left-to-right, top-to- bottom, in 16 rows of 64 columns, as ASCII values, as follows: $7800..$783F 1st row of characters $7840..$787F 2nd row of characters : : : $7BFF..$7BFF 16th row of characters Here is a commented disassembly of the SCRF code section of BINBUG 6.1: ;Code Section SCRL ($374)------------------------------------------------- ;SCRF &= $1F; // set scroll mode ;r4 = SCRF ^ %00010000; // toggle fast vs. normal scroll ;*($43A) = 0; // current cursor (X-)location ;FROM_L = $40; ;for (;;) ;{ r4 = (SCRF / 4) | $78; // high byte of address ($78..$7B) ; r5 = (SCRF % 4) * $40; // low byte of address ($00/$40/$80/$C0) ; do ; { PTR_H = FROM_H = r4; ; // FROM_B is $40 more than PTR_B ; *(PTR_B+r5..PTR_B+$FF) = *(FROM_B+r5..FROM_B+$FF); ; if (r4 & 3 == 3) ; { break; ; } } ; while (++r4 != 0); ; r0 = $20; ; // PTR_B is now $7C00 or $7F00 ; *(PTR_B+$C0..PTR_B+$FF) = r0; ; if (r4 & 4 == 0) ; { r4 = 3; ; r5 = $C0; ; goto SC; ; } // implied else ; r4 = SCRF & $0F; ;} ;End of Code Section SCRL------------------------------------------------- Here is a useful table comparing various BIOSes for these machines. As there is insufficient information regarding C-BUG, SBCBUG, etc. they are not listed. Input Output Tape MHz Notes ------------ ------------ ----------- --- ----- PIPBUG 1 110 110 110 1 (1) HYBUG 300 300 High-speed 1 (2) PIPBUG 2 110/300 110/300 110/300? 1 (3) BINBUG 3.5 300 DG-640 ? 1? BINBUG 3.6 300 DG-640 300 1 BINBUG 4.4 300 DG-640 ACOS 1? (4) BINBUG 5.2 1200 1200 ACOS 1? (4) BINBUG 6.1 150 DG-640 ACOS 2? (4) GBUG 300 DG-640 ? 1/2 (5) MIKEBUG 3 300 DG-640 ? 1? MYBUG 300 DG-640 ? 1? Numbers in Input, Output, Tape columns are baud rates, and assume 1 MHz operation (and are doubled at 2 MHz). (1) EA 300 baud mod is possible. (2) 600 and 1200 baud mods are possible. (3) Supports both rates. (4) Supports ACOS and DOS. (5) Optional parallel keyboard support. According to ETI Oct 1982, BINBUG can work at 300, 1200 & 2400 baud (!). SBCOS=SBCBUG=BINBUG 6+BINBUG 7+ACOS These games are hardcoded for 110 baud: On-screen Clock PPI-based EPROM Programmer 110 baud version of Lunar Lander (machine code) 110 baud version of Biorhythms 110 baud version of Funny Farm Races These games are hardcoded for 300 baud: Astro Trek (but an official 110 baud patch is provided with the listing) Reaction Timer 300 baud version of Lunar Lander (machine code) 300 baud version of Biorhythms 300 baud version of Funny Farm Races Unarchived Software ------------------- The following are confirmed but unavailable: 1. "the program supplied with the PROM Programmer article (Jan 1979)" 2. Hunt the Wumpus 3. Disassembler by Ian Binnie 4. "EA 1978 Software Record" (plastic on cardboard record) See the relevant magazine article for more details. This is the same item as the Dick Smith Electronics floppy vinyl record B-6300. 5. Astro-Trek 6. 2650 Chess aka Sargon 7. other software as mentioned in EA Feb 78 p. 73. 8. MultiBug If you know of any other software, or have dumps/tapes/listings of any of the above software, please email us (at amigansoftware@gmail.com). -------------------------------------------------------------------------- Signetics Instructor 50 ----------------------- ANNOTATE and HOWDIF both support the Signetics Instructor 50; remember to use the INSTRUCTOR_N or INSTRUCTOR_O (for ANNOTATE) or INSTRUCTOR (for HOWDIF) argument. You should ensure that your SYMbol file has the correct start address for your game. Annotated disassemblies of every available game are now available, so therefore you should not normally need to use DASMX or ANNOTATE. Not that there are really, strictly speaking, any true games available yet (currently the only available guest software is some examples from the manual and some homebrews). Overview -------- This machine is a "microprocessor development board" aka "trainer". It has 2K of ROM and 640 bytes of RAM. The processor is the Signetics 2650 CPU. A Signetics 2656 SMI (System Memory Interface) is also present. The name of the ROM BIOS is the USE ("User System Executive"). The speed is 895KHz. It would seem that expansion up to 28K of RAM is possible, though perhaps only up to about 24K. The start address for user programs can be specified at runtime by the user as with eg. the Elektor TV Games Computer. BIOS calls are made via eg. ZBSR *DISPLY; there is a zero page jump table at $1FE6..$1FFF. Memory Maps ----------- N: Signetics Instructor 50 (basic) $0000..$01FF: User RAM $0200..$0FFE: Unused $0FFF: I/O port $1000..$177F: Unused $1780..$17BF: User RAM $17C0..$17FF: Monitor RAM $1800..$1FFF: Monitor ROM $2000..$7FFF: Unused O: Signetics Instructor 50 (expanded) $0000..$01FF: User RAM $0200..$0FFE: Expansion RAM $0FFF: I/O port $1000..$177F: Unused $1780..$17BF: User RAM $17C0..$17FF: Monitor RAM $1800..$1FFF: Monitor ROM $2000..$7FFF: Expansion RAM ;Hardware Equates/Memory Map (Signetics Instructor 50)-------------------- ; $0000..$01FF: (R/W) User RAM ; $0200..$0FFE: (-/-) N: unused ; (R/W) O: expansion RAM ; $0FFF: (R/W) I/O port ; $1000..$177F: (-/-) Unused ; $1780..$17BF: (R/W) User RAM ; $17C0..$17FF: (R/W) Monitor RAM ; $1800..$1FFF: (R/-) Monitor ROM ; $2000..$7FFF: (-/-) N: unused ; (R/W) O: expansion RAM ;Hardware Equates--------------------------------------------------------- IOPORT equ $FFF ;(R/W) I/O port ;Official Monitor Label Equates------------------------------------------- DISLSD_SUB equ $1A76 ;(R/-) Nibble GNPA_SUB equ $1B20 ;(R/-) Modify Data MOV_SUB equ $1DB6 ;(R/-) Move DISPLY_SUB equ $1E13 ;(R/-) Display USRDSP_SUB equ $1FD5 ;(R/-) User Display USRDSP equ $1FE6 ;(R/-) User Display DISPLY equ $1FEC ;(R/-) Display DISLSD equ $1FF4 ;(R/-) Nibble GNPA equ $1FFC ;(R/-) Modify Data MOV equ $1FFE ;(R/-) Move R/W: read/write R/-: read-only The "Input Data" subroutine is $1FE8/$1FE9, $1FEA/$1FEB, $1FEE/$1FEF, $1FF0/$1FF1, $1FF2/$1FF3, $1FF6/$1FF7, $1FF8/$1FF9, or $1FFA/$1FFB, and the other vectors are undocumented. Keyboard -------- ------Left Keypad------ ---------Right Keypad---------- .SENS.. .WCAS.. .BKPT.. ...C... ...D... ...E... ...F... ..INT.. .RCAS.. ..REG.. ...8... ...9... ...A... ...B... ..MON.. .STEP.. ..MEM.. ...4... ...5... ...6... ...7... ..RST.. ..RUN.. ENT NXT ...0... ...1... ...2... ...3... MON, RST and ENT NXT are white on orange. All other keys are white on blue. There are no paddles. See the emulator source code for details on bit assignments, etc. Other I/O Devices ----------------- * 8-digit 8-segment LED display (red on black). * "CASSETTE" jacks: "PHONE" and "MIC". * "PARALLEL I/O" section: * 8 glow LEDs ("7".."0"). * 8 corresponding toggle switches (unlabelled). * 1 toggle switch (labelled as follows, where * is the switch), with 3 possible positions: MEMORY 0FFF EXTENDED * I/O PORT 07 NON-EXT DATA PORT "The default is probably EXTENDED I/O PORT $07." * "RUN" glow LED. "It appears to be on all the time. It is on in monitor mode, during stepping, and remains on at breakpoints. It will turn off after the processor executes a HALT ($40) instruction. It won't turn back on again until you hit MON, RST, in that order. You can't just break back into monitor mode after hitting a HALT instruction. Hitting MON, RST somehow brings the machine back to life and into monitor mode; otherwise the machine is dark." - Tyler Whitney. * "FLAG" glow LED. * "INTERRUPT" toggle switch: "DIRECT" or "INDIRECT". * "INTERRUPT SELECTOR" jumper (on underside of machine): "A.C. LINE" (ie. 50Hz) or "KEYBOARD" (ie. INT key). "The default is probably keyboard." * S-100 bus (at rear). Tentative: When an interrupt is generated/received, the Instructor 50 writes $07 or $87 to the data bus, depending on the position of the DIRECT/INDIRECT INTERRUPT switch. Then it does a ZBSR $07 or ZBSR *$07, as appropriate. In NON-EXTENDED I/O mode: REDD,rn to read from the toggle switches WRTD,rn to write to the glow LEDs In EXTENDED I/O mode: REDE,rn $07 to read from the toggle switches WRTE,rn $07 to write to the glow LEDs In MEMORY MAPPED I/O mode: LODA,rn $0FFF to read from the toggle switches STRA,rn $0FFF to write to the glow LEDs Display ------- The display is red on black. Each of the 8 digits is divided into 8 segments, as shown: +0+ The + don't really exist, therefore it is really like this: 5 1 +6+ 0 4 2 5 1 +3+ 7 6 4 2 3 7 Eg. the bottom segment is controlled by bit 3 (so, $08 would set it, $00 would clear it). The display is controllable at the segment level (ie. you can get 256 combinations) via direct hardware access (ie. bypassing USE BIOS functions and using the WRTE instruction), using the bit numbers listed above. The USE BIOS only allows character-level (ie. glyph-level) access. The character set is as follows: ### ..# ### ### #.# ### ### ### ### ### # # . # . # . # # # # . # . . # # # # # #.# ..# ### ### ### ### ### ..# ### ### # # . # # . . # . # . # # # . # # # . # ### ..# ### ### ..# ### ### ..# ### ..# $00 $01 $02 $05 $06 $07 $08 $09 0 or O 1 or I 2 5 or S 6 or G 7 8 9 ### #.. ### ..# ### ### ### #.. #.# ... # # # . # . . # # . # . # # # . # # . . ### ### #.. ### ### ### ### #.. #.# ### # # # # # . # # # . # . # . # . # # # . #.# ### # ### ### # ### #.. #.. ### ### #.. $0A $0B $0C $0D $0E $0F $10 $11 $12 $13 A b. C d. E F P L U r #.# ... ... ... ..# ... ... #.# ... # # . . . . . . . # . . . . # # . . ### ### ### ... ..# ### ... ### ### # # # # . . . . . # . . . . . # # # #.# ### ### ... ### ... ... # ### #.# $14 $15 $16 $17 $18 $19 $1A $1B $1C H o = space J - . Y n Present: ABCDEFGHIJ L NOP RS U Y Missing: K M Q T VWX Z Note the trailing dots for "b." and "d.". See also the Dolphin Coding Guide (later in this document), as the LED hardware is basically the same (although the port numbers are different). USE BIOS -------- "When in Monitor mode, pressing anything on the hex keypad generates Error 2 on the real machine. On the control keypad, you can hit most keys with impunity. Hitting STEP while in monitor mode generates Error 9 on the real machine." - Tyler Whitney. Error 2 means: "Restricted command." Error 9 means: "Next instruction is in the MONITOR area." If the STEP button is pressed and the next instruction would be in the monitor area, it will be reported by the appearance of Error 9. The USRDSP command is used as follows: R0: Return code. R1..R2: Pointer to byte preceding string. R3: $00/$01/$80. $01 returns immediately. Beat the Odds: You can make a bet from any of the following: 0 lamps lit: 250:1 1 lamps lit: 15:1 2 lamps lit: 7:1 3 lamps lit: 7:2 (3.5: 1) 4 lamps lit: 5:2 (2.5: 1) 5 lamps lit: 7:2 (3.5: 1) 6 lamps lit: 7:1 7 lamps lit: 15:1 8 lamps lit: 250:1 0..1 lamps lit: 25:1 2..3 lamps lit: 2:1 4..5 lamps lit: 1:1 6..8 lamps lit: 6:1 0..2 lamps lit: 11:2 (5.5: 1) 3..5 lamps lit: 2:5 ( 1:10) 6..8 lamps lit: 11:2 (5.5: 1) Specific 2-digit number: 250:1 Specific MS digit: 15:1 Specific LS digit: 15:1 Any one of 5 specified 2-digit numbers: 50:1 Any one of 10 specified 2-digit numbers: 25:1 Game of Memories: Game of Memories is a Game of Life according to the rules from John Horton Conway. It was written for the Ami/WinArcadia emulator of the Signetics Instructor 50. The particularity of Game of Memories is that the field for the Game of Life is laid out in a 16�16 byte grid storage area that the emulator can graphic ally represent and so the view can be resembled - whereby the name of the program: Game of Memories. When the progam is loaded into WinArcadia, the field is still not seen. "Tools|Memory editor..." must be invoked. The field is in the memory bank $0E00..$0EFF. You should set "Region" to that memory region, and "View as" to "Characters". Train: Bits 6..4: %000: 0 mph (stopped) %001: 80 mph %010: 40 mph %011: 27 mph %100: 19 mph %101: 15 mph %110: 12 mph %111: 10 mph Bits 3..0: %0000: oP...... HSE %0001: oPOOO... HSE + 3 FC %0010: oPOUU... HSE + 1 FC + 2 EC %0011: oPOUAo.. HSE + 1 FC + 1 EC + 1 �C + 1 C %0100: oPOOo... HSE + 2 FC + 1 C %0101: oPooo... HSE + 3 C %0110: oPUUUo.. HSE + 3 EC + 1 C %0111: o=ooo... LSE + 3 C %1000: o=UUo... LSE + 2 EC + 1 C %1001: o=AAo... LSE + 2 �C + 1 C %1010: o=UUo... LSE + 2 EC + 1 C %1011: o=OOOo.. LSE + 3 FC + 1 C %1100: o=...... LSE %1101: M....... MT %1110: doooo... EM + 4 C %1111: Mooo.... MT + 3 C electric-powered mine engine = EM = d battery-powered mine tractor = MT = M high speed engine = HSE = oP low speed engine = LSE = o= full car = FC = O half-full car = �C = A empty car = EC = U caboose = C = o Unarchived Documentation/Software --------------------------------- The "Signetics Instructor 50 Desktop Computer Software Applications Manual" (incl. Instructor 50 Music Theme, Slot Machine, Stop Watch) is sought. If you have this, or similar, please contact us. Cassette Subsystem ------------------ The cassette subsystem is somewhat like that of the Elektor TV Games Computer, but: 6 pulses for a "0" and 3 pulses for a "1" except 3 extra pulses on the last bit of each byte (6+3 or 3+3). As with the Elektor, the rate at which bits (and thus bytes) can be loaded/saved depends the actual data payload (ie. depends on whether they are "0"s or "1"s). Port $F8 bit 4 is FREQ. The BIOS is flipping that at a constant regular rate (at least while recording). Port $F8 bit 3 is ENV. That is high whilever we are actually recording a bit, and goes low between bits. It stays high for longer for a "0" bit than for a "1" bit. So whilever ENV is high, we just write the current status of the FREQ bit to the tape, and whilever ENV is low, we just write silence. It gets NANDed, so if ENV and FREQ are both high, we are low, and otherwise, we are high. It sets port $F8 to $10 and $18 while writing, and $00 at rest. During playback, the Sense bit is set directly from the tape based on whether above or below the zero-crossing point. -------------------------------------------------------------------------- Central Data 2650 ----------------- ANNOTATE and HOWDIF both support the Central Data 2650; remember to use the CD2650_U (for ANNOTATE) or ASCII (for HOWDIF) argument. You should ensure that your SYMbol file has the correct start address for your game. Annotated disassemblies of every available game are now available, so therefore you should not normally need to use DASMX or ANNOTATE. Overview -------- KHz: 1183 for the slower version 4732 for the faster version ROM: 1K supervisor + ?K pre-programmed character generator RAM: 2K (also used by display subsystem) (736 bytes available for user) Output: VDU, 80*16 characters (5?+1*8?+4? pixels per cell), monochrome Character set: $00..$3F: 1st character generator PROM $40..$7F: 2nd char. gen. PROM (optional) $80..$FF: not normally used Input: Teletype Storage: 300 baud Kansas City (audio cassette tape): clear bit = 4 cycles of 1200Hz set bit = 8 cycles of 2400Hz Characters $00..$3F are the uppercase alphabetic characters, numeric characters and punctuation characters. Characters $40..$7F are not really standardized. They are generally used for eg. lower case characters, Star Trek characters, card symbols and chessmen. A typical configuration is: CD2650 (including CUTS cassette interface) + ASCII-encoded keyboard + video monitor + tape deck + power supply Memory Map ---------- Central Data 2650: $0000..$03FF: 1K of monitor ("supervisor") ROM BIOS $0400..$0FFF: expansion ROM (optional) $1000..$103F: display RAM (unusable) $1040..$14FF: display RAM $1500..$150F: monitor RAM (unusable) $1510..$17E9: user RAM $17EA..$17FF: monitor RAM $1800..$1FFF: unused $2000..$7FFF: expansion RAM/ROM (optional) $1000..$103F: "In the first CD2650 Newsletter, April 1978, Jeff Roloff says: `...if you get hold of some slow RAM for use in the display section, the first four characters will be illegible because of timing problems.' If the RAM was fast enough for the rest of the display it would be fast enough at the beginning. I suspect that he had problems with resetting his counters which made the first character spaces too narrow. I remember designing a frequency synthesiser with 74 series ICs where the downcounter had to start resetting at count 3 to be ready at count 0!" - Richard Rogers. $1500..$150F: "You can't use $1500..$150F because when you reach the end of the line, WCHR at $0396 sends you to LFCR at $0024 which immediately writes a space at the current (too big) cursor position." - Richard Rogers. ;Hardware Equates/Memory Map (Central Data 2650)-------------------------- ; $0000..$03FF: (R/-) Monitor ROM ; $0400..$0FFF: (R/-) Expansion ROM (optional) ; $1000..$103F: (R/W) Display RAM (unusable) ; $1040..$14FF: (R/W) Display RAM ; $1500..$150F: (R/W) Monitor RAM (unusable) ; $1510..$17E9: (R/W) User RAM ; $17EA..$17FF: (R/W) Monitor RAM ; $1800..$1FFF: (-/-) Unused ; $2000..$7FFF: (R/W) Expansion RAM/ROM (optional) ;Official Supervisor Monitor ROM Label Equates---------------------------- INIT equ $0000 ;(R/-) L1 equ $0013 ;(R/-) LFCR equ $0024 ;(R/-) L2 equ $003C ;(R/-) HXOT equ $006A ;(R/-) RETU equ $0083 ;(R/-) SAVR equ $0088 ;(R/-) BPSV equ $00AC ;(R/-) CLRB equ $00BB ;(R/-) WRAD equ $00DB ;(R/-) RUNT equ $00F0 ;(R/-) BKPT equ $00F8 ;(R/-) INSP equ $0122 ;(R/-) ;STRR equ $014C ;(R/-) WRBL equ $0170 ;(R/-) SETR equ $0176 ;(R/-) ;ADDR equ $0185 ;(R/-) TABL equ $019A ;(R/-) DECR equ $019D ;(R/-) HTBL equ $01A6 ;(R/-) INHX equ $01B6 ;(R/-) KRAM equ $01CE ;(R/-) NADD equ $01D1 ;(R/-) NOCH equ $01E6 ;(R/-) TPOT equ $01FB ;(R/-) NEWL equ $0239 ;(R/-) ENDT equ $0249 ;(R/-) SERO equ $024F ;(R/-) NXTB equ $0253 ;(R/-) ONE equ $0264 ;(R/-) ZERO equ $0266 ;(R/-) D2 equ $026F ;(R/-) D1 equ $0273 ;(R/-) D6 equ $0278 ;(R/-) EXEC equ $027F ;(R/-) RETN equ $0288 ;(R/-) COLO equ $028B ;(R/-) WAIT equ $028E ;(R/-) VERI equ $02A0 ;(R/-) NEWC equ $02CE ;(R/-) SERI equ $02E9 ;(R/-) NOST equ $02ED ;(R/-) NEXT equ $02F8 ;(R/-) KBIN equ $030F ;(R/-) L11 equ $031A ;(R/-) TPIN equ $0328 ;(R/-) NATC equ $0353 ;(R/-) ERRR equ $037C ;(R/-) WCHR equ $0396 ;(R/-) GO equ $039F ;(R/-) COMD equ $03C0 ;(R/-) ;Official Supervisor Monitor RAM Label Equates---------------------------- LENT equ $17EA ;(R/W) Length BKP1 equ $17F4 ;(R/W) Breakpoint address, high byte BKP2 equ $17F5 ;(R/W) Breakpoint address, low byte BPD1 equ $17F6 ;(R/W) Breakpoint save pos., high byte BPD2 equ $17F7 ;(R/W) Breakpoint save pos., low byte SUMC equ $17F9 ;(R/W) Sumcheck ADD1 equ $17FA ;(R/W) Address, high byte ADD2 equ $17FB ;(R/W) Address, low byte CUR1 equ $17FE ;(R/W) Cursor pointer, high byte CUR2 equ $17FF ;(R/W) Cursor pointer, low byte The layout of display RAM is unusual: $1000: 0,0 $1001: 0,1 $1002: 0,2 : : : $100F: 0,15 $1010: 1,0 $1011: 1,1... To access a given cell, the formula is: address = $1000 + (x * 16) + y; where x is 0..79 and y is 0..15. Supervisor ---------- A period (.) indicates that the supervisor program is ready for a command. An A indicates that it is waiting for you to type in an address. At any time the supervisor is looking for a keyboard input, you can press Esc which will terminate the present command and wait for a new one. A: Alter or display memory Press A. It will then ask for a hexadecimal address. The address and the data then appear on the next line. You can now: press Esc to quit the alter/display routine enter C to change the data at that location: type in two hex characters to fill the memory location. or press space to display the next memory location B: Set a breakpoint address Press B. It will then ask you for the address of the breakpoint. When this address is reached in the program, the supervisor will save all of the registers and wait for a new command. It signifies that the breakpoint address has been reached by writing the message: BP 1703 indicates breakpoint address was reached. The registers and memory can now be examined as you see fit. After the breakpoint has been executed, it is cleared and the program will be allowed to run past the point next time through. C: Clear a breakpoint address Press C. The supervisor responds by typing the address that the breakpoint was set at. Note that you must set breakpoints at an address position where an instruction would begin. In other words, you cannot set a breakpoint to be executed at an address which is the second or third byte of an instruction. E: Execute a program Press E. It will then ask for the address that is should start executing at. It will then jump to the address and start executing instructions. I: Inspect CPU registers Press I. It will then ask you to type a register number corresponding to the register that you want, as follows: 0 register 0 (r0) 1 register 1, bank 0 (r1) 2 register 2, bank 0 (r2) 3 register 3, bank 0 (r3) 4 register 1, bank 1 (r4) 5 register 2, bank 1 (r5) 6 register 3, bank 1 (r6) 7 Program Status Word, Lower (PSL) 8 Program Status Word, Upper (PSU) The microcomputer will then display the data that was in this register right before the program returned to the supervisor. You now have three options: to stop by pressing Esc to change the register value by entering C or to inspect another register by pressing space There are also the D, L, R and V commands, which are used for tape operations. It seems to be possible to "hang" the supervisor; eg. by pressing E repeatedly. This is because RETN ($288) branches to *ADD1, and sometimes ADD1 has garbage such as $6EEE. The available scan of the supervisor is poor; the following bytes could conceivably be wrong. $13A, $16C, $181: probably $EB but maybe $E8 $316: probably $F8 but maybe $FB $3C4: probably $2E but maybe $28 or $2B The following unnamed variables are used by the supervisor: $17EB $17EC $17ED $17EE $17EF $17F0 $17F1 $17F2 $17F3 $17F8 $17FC $17FD? (not confirmed) The WCHR routine masks its character to the $00..$3F range (ie. it prints everything as uppercase). The KBIN routine can return characters in the $00..$7F range. However, it can only print them as uppercase (because it uses WCHR). The supervisor internally works with letters in the $41..$5A (65..90) (ASCII uppercase "A".."Z") range. It relies on the masking performed by WCHR to output them as $01..$2A (1..26) (CD2650 uppercase "A".."Z"). Ideally, full autodocs for the supervisor (and for the BIOSes of the TVGC, PIPBUG and the SI50) would be available, eg.: WRAD: * Stack required: 2. * Functions called: LFCR, HXOT, WRBL. * Pages: 3. * Addresses: $DB..$EF. * Can branch to: None. * RAM data accessed: ADD1/2. * ROM data accessed: None. * ROM constants used: INCD ($10), CUCD ($1C), SPCD ($20). * Subsections: L2. * Called by: ?. * Registers: r0 will be SPCD ($20), r3 will be CUCD ($1C). * PSW: WC is cleared. 8K BASIC -------- In editor (at COMMAND prompt): - = go to beginning of file + = go to end of file / = go backwards 15 lines Bx = go backwards x lines = go forwards 15 lines Fx = go forwards x lines Cx = change line x Ix = insert after line x Ctrl+C = done changing/inserting Dx = delete x lines from top of screen R = go to BASIC In BASIC (at OPTION prompt): I = Inspect variable L = RUN to line R = RUN Esc = stop running S = Single step Esc = go to editor Standard BASIC 8K BASIC -------------- -------- CLS ERASE var=PEEK(addr) PEEK addr,var PRINT"string" PRINT'string' PRINT var PRINT #var PRINT AT y,x PRINT@y,x 'comment *comment IF a=b THEN IF a=b The interpreter doesn't like blank lines (gives ARG ERROR), but an empty comment (* only) is acceptable. String concatenation (eg. A$='FOO'+'BAR') is not allowed. String assignments (eg. A$='FOO') must exactly fill the allocated (DIMensioned) storage. When running programs: for multi-variable INPUT statements, each entry should be terminated with the RETURN key (not a comma). A normal floating point variable is 8..22 bytes: 1 byte for type ($0x) 2 bytes for pointer to next variable 1..15 bytes for name 4 bytes for contents A floating point array is 4+ bytes: 1 byte for type ($4x) 2 bytes for pointer to next variable 1..15 bytes for name (0..255)*4 bytes for contents A string is 5-274 bytes: 1 byte for type ($8x) 2 bytes for pointer to next variable 1..15 bytes for name 1 byte for length 0..255 bytes for contents Here is a summary of the differences between V1.0 and V1.3 of 8K BASIC: V1.0 V1.3 ----------- ----------- 1780..17AA 00s 25B9..25BB 70 F4 80 1F 3E 98 2C25..2C27 3F 34 0D 3F 3F EE 2E6F..2E74 EE 14 A5 9C 30 5A CE 14 A5 C0 C0 C0 (unofficial) 33B9..33BC 1A 64 19 6F 9C 4F D1 C0 3995 04 03 3E88..3EAA 3F2F..3F31 3F 3C F5 1F 17 96 3F78..3F7A 1F 38 91 1F 17 82 3FD1..3FED 3FEE..3FF3 The following problems are hereby noted. This suggests there are bad bytes in the current 8K BASIC dumps (and therefore also BASIC games). LET statement: assigning a non-integer doesn't work. Eg. A=123 or A=123.0 is OK, but not A=123.4. (Gives OVerFlow error.) - and ^ operators: these give wrong results. COS function: byte $3D91 (in COS routine) is ambiguous (due to a poor quality listing). NEXT statement: sometimes gives NEST ERROR for no apparent reason. To start a game: R (twice) then ENTER. Now R (once). AOF (Signetics Absolute Object File) Format ------------------------------------------- This format is used by the Instructor 50, CD2650, PIPBUG-based machines, and perhaps other platforms. The native tape format is as follows, for each block: 0: colon (:) ($3A) 1..2: load address (big-endian) 3: block length: 0 = last block 1..255 = 2..256 bytes (respectively) 4: checksum for header bytes 0..3 5..n-1: data n: checksum for data Checksums start as $00. For each emitted byte, the following algorithm is applied: SUMC ^= data; SUMC <<= 1; Eg. the following program: $1600: C0 C0 C0 C0 would be encoded as follows: 3A 16 00 03 15 (1st block header) C0 C0 C0 C0 88 (1st block data ) 3A 00 00 00 A3 (2nd block header) For the 1st header: SUMC = 0; // SUMC is %00000000 [$00]; SUMC ^= $3A; // SUMC is %00111010 [$3A]; SUMC <<= 1; // SUMC is %01110100 [$74]; SUMC ^= $16; // SUMC is %01100010 [$62]; SUMC <<= 1; // SUMC is %11000100 [$C4]; SUMC ^= $00; // SUMC is %11000100 [$C4]; SUMC <<= 1; // SUMC is %10001001 [$89]; SUMC ^= $03; // SUMC is %10001010 [$8A]; SUMC <<= 1; // SUMC is %00010101 [$15]; For the 1st data: SUMC = 0; // SUMC is %00000000 [$00]; SUMC ^= $C0; // SUMC is %11000000 [$C0]; SUMC <<= 1; // SUMC is %10000001 [$81]; SUMC ^= $C0; // SUMC is %01000001 [$41]; SUMC <<= 1; // SUMC is %10000010 [$82]; SUMC ^= $C0; // SUMC is %01000010 [$42]; SUMC <<= 1; // SUMC is %10000100 [$84]; SUMC ^= $C0; // SUMC is %01000100 [$44]; SUMC <<= 1; // SUMC is %10001000 [$88]; For the 2nd header: SUMC = 0; // SUMC is %00000000 [$00]; SUMC ^= $3A; // SUMC is %00111010 [$3A]; SUMC <<= 1; // SUMC is %01110100 [$74]; SUMC ^= $00; // SUMC is %01110100 [$74]; SUMC <<= 1; // SUMC is %11101000 [$E8]; SUMC ^= $00; // SUMC is %11101000 [$E8]; SUMC <<= 1; // SUMC is %11010001 [$D1]; SUMC ^= $00; // SUMC is %11010001 [$D1]; SUMC <<= 1; // SUMC is %10100011 [$A3]; Game Help --------- 12KBASIC.pgm: It obeys one-letter commands of the form Xn, where X tells it what to do and n is the line number (or number of lines?). S - save to tape - (not emulated) - pauses during save L - load from tape - (not emulated) R - runs the BASIC program Cn - change from line n onwards D - deletes line 1 Dn - deletes lines from 1 to n E - exits to supervisor An - append after line n? If you have just inserted some lines, it will add them again after the designated line F - scrolls forwards 1 line Fn - scrolls forwards n lines I - insert after line 1 - type in program, Ctrl-C (=ETX) ends input In - insert after line n - type in program, Ctrl-C (=ETX) ends input Bn - scrolls backwards n lines X - scrolls forwards 1 line Xn - ? P - modify string? G - go and run program with following options: D - direct execution of a typed-in line R - run the program S - single step Esc - exits It only needs line numbers as GOTO (and GOSUB, etc.) destinations. At $5800 there is a small test program. It looks as if whoever saved the program first ran it with the extended functions deleted and wrote a small program before saving. So some of the extended functions may be corrupted or they may all be missing. When an error is encountered: these OPTIONs are available: D - direct mode R - rerun the program S - single step Esc - exits Backup.pgm: This program appears to be incomplete. Eg. execution flows beyond the listing into $15C3, it expects a TAPe OUT subroutine at $15C7 and a CLear SCReen subroutine at $1602. There is probably another unscanned page to this listing. Input.pgm: This program is similar in purpose to TVTypewriter.pgm except that it supports both uppercase and lowercase I/O. Since the code for backspace is the same as that for lowercase "h" (8), and the code for a carriage return is the same as that for lowercase "m" (13), these two lowercase letters are unusable in this program. Note that this program has not been tested on the genuine machine and the key bindings are mostly guesswork. Life.pgm: Move around the screen with U/D/L/R for up/down/left/right. Use O (not 0) to set cells and the spacebar to clear them. To begin the simulation, move (with D key) the cursor to the bottom row of the screen. LunarLander.pgm: Here is the disassembly of the machine code routine: $5BF6: 73 REDD,r3 $5BF7: 3F 01 9A BSTA,un DECR $5BFA: CB 02 STRR,r3 $5BFE $5BFC: 17 RETC,un $5BFD: ?? $5BFE: MemoryTest.pgm: The provided dump tests the RAM at $2000..$7FFF. The normal result of running this program is no output (ie. success). The byte at $1512 is the high byte of the starting address. The low byte of the starting address is always $00. The byte at $1513 is the high byte of the (ending address + 1). The low byte of the ending address is always $FF. Therefore, you must test $xx00..yyFF (a multiple of 256 bytes, aligned at a 256-byte boundary). Eg. storing $80 at $1513 gives an ending address of $7FFF, and storing $48 there would give an ending address of $47FF. Ie. start address = *($1512) * $100; end address = (*($1513) * $100) - 1; If you want to see error messages, you could change $1512 to $00 and $1513 to $80, to test $0000..$07FF (which is ROM and therefore fails the test). Output will loop until a key is pressed. Memory is tested destructively. Therefore, you must not test the $1510..$15A8 area, otherwise you will overwrite the program. Contrary to what is stated in the instructions, the are where the program is located ($1510..$15A8) is normal (ie. non- display) user RAM, not display RAM. MorseCode.pgm: This program lacks documentation. It might be originally designed to be interactive rather than to use stored text. NumbersGame.pgm: INT seems to round to the nearest integer, rather than just dropping the fractional part. Therefore, "digits" range in value from 1..12. Pattern.pgm: "The program has been typed into SCREENs 5 and 6. LOAD does not work unless LIST has been used first." - Richard Rogers. To run this program, type the following: 5 LIST 6 LIST 5 LOAD 123 PATTERN You can change the 123 to a different number; it controls the number of blobs to write. ScreenPrinter.pgm: This program refers to (external) printer routines at $4000 and $4147. TVTypewriter.pgm: This program seems to expect the address of KBIN to be $309. However, the correct address is $30F. This change has been made to the available dump. Also, the screen is filled with $00 ("@" symbol). This may be authentic. Unarchived Software ------------------- * Spacewar (clone of "Scelbi's Galaxy Game for the 8008/8080"), by Roger Miskowicz * Star Trek * Target * etc. Excerpt ------- From the "Small Systems Computer Sourcebook" [sic], by J. C. Boonham: "Product: 2650 Single Board Computer Company: Central Data Company Features: Employs Signetics 2650 microprocessor. * There is an in-built 80 character by 16 line video display character generator (64 upper case ASCII character set) with a user programmable set of 64 characters (8x8 matrix) for non-standard characters. * There is a Kansas City Standard cassette interface, a 1024 byte PROM monitor program, 2048 bytes of programmable memory of which 768 are available for programming with the balance dedicated to the display, one 8 bit input port and one 8 bit output port. * In addition there are sockets for 3K of PROM (which may include the Central Data Company's editor and assembler). * A BASIC software package is available on cassette tape. * The user needs to supply 3A at 5V power supply, an ASCII keyboard, a video monitor and possibly some additional memory." -------------------------------------------------------------------------- Kitronix Coin-Ops (ie. Malzak) ------------------------------ KHz: 950 ROM: for Malzak 1: 9K of EPROM (plus character set definitions for SAA 5050 and SAA 5020 chips) RAM: 1K (some used for eg. screen contents) Output: SAA 5050 Teletext generator, 40*25 characters (6*10 pixels per cell), 8 colours SAA 5020 TIC (Timing Interface Circuit) custom playfield generator, 2 colours? 2 2636 PVI chips (both are used for sprites) (only one seems to be used for sound) 2 SN76477 chips (used for sound) Input: 8-way digital joystick P1, P2 buttons Firebutton Coin slot Test switch (Malzak 2 only) Storage: For Malzak 2, $1700..$17FF is non-volatile RAM (battery-backed?) T: Malzak 1: $0000..$07FF: from $0000..$07FF of malzak.5 (ROM code) (2K) $0800..$0BFF: from $0000..$03FF of malzak.4 (ROM code) (1K) $0C00..$0FFF: from $0000..$03FF of malzak.was 2 now 3 (ROM data) (1K) (screen data?) $1000..$1FFF: RAM, hardware registers $1000..$13FF: RAM $1400..$14FF: 1st PVI $1500..$15FF: 2nd PVI $1600..$16FF: playfield tilemap $1700..$17FF: RAM $1800..$1E3F: teletext screen contents $1E40..$1FFF: RAM? $2000..$27FF: from $0800..$0FFF of malzak.5 (ROM code) (2K) $2800..$2FFF: empty $3000..$3FFF: mirror of $1000..$1FFF $4000..$43FF: from $0400..$07FF of malzak.4 (ROM code) (1K) (terrain code) $4400..$4BFF: from $0000..$07FF of malzak.3 (ROM data) (2K) (terrain data) $4C00..$4FFF: empty $5000..$5FFF: mirror of $1000..$1FFF $6000..$6FFF: empty $7000..$7FFF: mirror of $1000..$1FFF V: Malzak 2: $0000..$07FF: from $0000..$07FF of malzak.1a (ROM code) (2K) $0800..$0BFF: from $0000..$03FF of malzak.2b (ROM code) (1K) $0C00..$0FFF: banked area (controlled by bit 6 of I/O port $40) Malzak 1: from $0000..$03FF of malzak.4d (ROM data) (1K) (screen data) Malzak 2: from $0400..$07FF of malzak.4d (ROM data) (1K) (screen data) $1000..$1FFF: RAM, hardware registers, NVRAM $1000..$13FF: RAM $1400..$14FF: 1st PVI $1500..$15FF: 2nd PVI $1600..$16FF: playfield tilemap $1700..$17FF: NVRAM $1800..$1E3F: teletext screen contents $1E40..$1FFF: RAM? $2000..$27FF: from $0800..$0FFF of malzak.1a (ROM code) (2K) $2800..$2BFF: from $0800..$0BFF of malzak.2b (1K) $2C00..$2FFF: empty $3000..$3FFF: mirror of $1000..$1FFF $4000..$43FF: from $0400..$07FF of malzak.2b (ROM code) (1K) (terrain code) $4400..$4BFF: might be banked? If so... Malzak 1: from $0000..$07FF of malzak.3 (ROM data) (2K) (terrain data) Malzak 2: from $0000..$07FF of malzak.3c (ROM data) (2K) (terrain data) $4C00..$4FFF: empty $5000..$5FFF: mirror of $1000..$1FFF $6000..$63FF: from $0C00..$0FFF of malzak.2b (1K) $6000..$6FFF: empty $7000..$7FFF: mirror of $1000..$1FFF Presumably malzak.1 is not accessible to the CPU (contains tile imagery), and likewise the teletext character imagery. Both are identical between Malzak 1 and Malzak 2. $1xxx is deliberately mirrored at $3xxx, $5xxx, $7xxx, because on the 2650, you can only access data on the same 8K page, so mirroring is very useful for the game programmer (otherwise code in the $2000..$7FFF region could not access any of the RAM). For Malzak 2, if *($14CC) is $00 (ie. test switch is at position 4), the game will enter test mode when booting. When it enters test mode, it clears the settings first. 42*25 characters. 6*10 pixels per character (including aesthetic gaps). 64 ($40) bytes allocated per row: $1800..$183F: 1st row $1840..$187F: 2nd row $1880..$18BF: 3rd row $18C0..$18FF: 4th row $1900..$193F: 5th row $1940..$197F: 6th row $1980..$19BF: 7th row $19C0..$19FF: 8th row $1A00..$1A3F: 9th row $1A40..$1A7F: 10th row $1A80..$1ABF: 11th row $1AC0..$1AFF: 12th row $1B00..$1B3F: 13th row $1B40..$1B7F: 14th row $1B80..$1BBF: 15th row $1BC0..$1BFF: 16th row $1C00..$1C3F: 17th row $1C40..$1C7F: 18th row $1C80..$1CBF: 19th row $1CC0..$1CFF: 20th row $1D00..$1D3F: 21st row $1D40..$1D7F: 22nd row $1D80..$1DBF: 23rd row $1DC0..$1DFF: 24th row $1E00..$1E3F: 25th row Input bits are: bit 7: up (active high) bit 6: left (active high) bit 5: right (active high) bit 4: fire (active high) bit 3: 2P (active high) bit 2: 1P (active high) bit 1: down (active high) bit 0: coin slot (active low) For additional technical information about Malzak, consult the Malzak 1 disassembly in the Disassemblies Pack, and the Ami/WinArcadia source code. Maps of Malzak 1 and 2 are available in the Maps Pack at http://amigan.yatho.com/maps.rar -------------------------------------------------------------------------- Zaccaria Coin-Ops ----------------- W/X: Galaxia (W)/Astro Wars (X): $0000..$03FF: from $0000..$03FF of 08h.bin (ROM) (1K) $0400..$07FF: from $0000..$03FF of 10h.bin (ROM) (1K) $0800..$0BFF: from $0000..$03FF of 11h.bin (ROM) (1K) $0C00..$0FFF: from $0000..$03FF of 13h.bin (ROM) (1K) $1000..$13FF: from $0000..$03FF of 08i.bin (ROM) (1K) $1400..$14FF: W: banked: when Flag bit of PSU is clear: bullet RAM when Flag bit of PSU is set: palette RAM (16 bytes) X: RAM $1500..$15FF: 1st 2636 PVI $1600..$16FF: W: 2nd 2636 PVI X: unmapped? $1700..$17FF: W: 3rd 2636 PVI X: unmapped? $1800..$1BFF: banked: when Flag bit of PSU is clear: screen colours when Flag bit of PSU is set: screen contents $1C00..$1CFF: W: RAM X: banked: when Flag bit of PSU is clear: bullet RAM when Flag bit of PSU is set: palette RAM (16 bytes) $1D00..$1FFF: W: RAM X: unmapped? $2000..$23FF: from $0000..$03FF of 10i.bin (ROM) (1K) $2400..$27FF: from $0000..$03FF of 11i.bin (ROM) (1K) $2800..$2BFF: from $0000..$03FF of 13i.bin (ROM) (1K) $2C00..$2FFF: from $0000..$03FF of 11l.bin (ROM) (1K) $3000..$33FF: from $0000..$03FF of 13l.bin (ROM) (1K) $3400..$3FFF: mirror of $1400..$1FFF $4000..$53FF: unknown $5400..$5FFF: mirror of $1400..$1FFF $6000..$63FF: unknown $7400..$7FFF: mirror of $1400..$1FFF For additional technical information about Astro Wars and Galaxia, consult the disassemblies of these games in the Disassemblies Pack, and the Ami/ WinArcadia source code. Regarding the physical layout of the Astro Wars controls: "Astro Wars is left-right buttons (which a two-way joystick can replace) with only one fire button. I can only guess your cabinet is a frankenstein of various parts." - Gatinho. In Astro Wars, the yellow sprites are meteors, not bullets; this explains why they do not emanate from the enemy ships. Laser Battle/Lazarian (LB/LZ): 1st page: $0000..$13FF: 5K of ROM $0000..$03FF: $0000..$03FF of lb02.7c/laz.7c/02-1.7c $0400..$07FF: $0000..$03FF of lb02.6c/laz.6c/02-2.6c $0800..$0BFF: $0000..$03FF of lb02.5c/laz.5c/02-3.5c $0C00..$0FFF: $0000..$03FF of lb02.3c/laz.3c/02-4.3c $1000..$13FF: $0000..$03FF of lb02.2c/laz.2c/02-5.2c $1400..$14FF: unmapped? $1500..$15FF: 256 bytes (1st PVI) $1600..$16FF: 256 bytes (2nd PVI) $1700..$17FF: 256 bytes (3rd PVI) $1800..$1BFF: 1K of display RAM (write-only) $1C00..$1FFF: 1K of RAM 2nd page: $2000..$33FF: 5K of ROM $2000..$23FF: $0000..$03FF of lb02.7b/laz.7b/02-6.7b $2400..$27FF: $0000..$03FF of lb02.6b/laz.6b/02-7.6b $2800..$2BFF: $0000..$03FF of lb02.5b/laz.5b/02-8.5b $2C00..$2FFF: $0000..$03FF of lb02.3b/laz.3b/02-9.3b $3000..$33FF: $0000..$03FF of lb02.2b (Laser Battle) $0800..$0BFF of laz10-62.2b (Lazarian) $3400..$37FF: 1K (mirror of $1400..$17FF) $3800..$3BFF: 1K (Laser Battle: mirror of $1800..$1BFF?) (Lazarian: $0000..$03FF of laz10-62.2b) $3C00..$3FFF: 1K (mirror of $1C00..$1FFF) 3rd page: $4000..$53FF: 5K of ROM $4000..$43FF: $0400..$07FF of lb02.7c/laz.7c/02-1.7c $4400..$47FF: $0400..$07FF of lb02.6c/laz.6c/02-2.6c $4800..$4BFF: $0400..$07FF of lb02.5c/laz.5c/02-3.5c $4C00..$4FFF: $0400..$07FF of lb02.3c/laz.3c/02-4.3c $5000..$53FF: $0400..$07FF of lb02.2c/laz.2c/02-5.2c $5400..$5FFF: 3K (mirror of $1400..$1FFF?) 4th page: $6000..$73FF: 5K of ROM $6000..$63FF: $0400..$07FF of lb02.7b/laz.7b/02-6.7b $6400..$67FF: $0400..$07FF of lb02.6b/laz.6b/02-7.6b $6800..$6BFF: $0400..$07FF of lb02.5b/laz.5b/02-8.5b $6C00..$6FFF: $0400..$07FF of lb02.3b/laz.3b/02-9.3b $7000..$73FF: $0C00..$0FFF of lb02.2b/laz10-62.2b/02-10-11.2b $7400..$77FF: 1K (mirror of $1400..$17FF?) $7800..$7BFF: 1K (Laser Battle: mirror of $1800..$1BFF?) (Lazarian: $0400..$07FF of laz10-62.2b) $7C00..$7FFF: 1K (mirror of $1C00..$1FFF?) There is 6K of PDG imagery. There is 2K of sprite imagery. For Laser Battle: The 1st and 2nd PVIs are used for the "circle" sprites. The 3rd PVI is used for the bullets. Extended I/O port $02 is multiplexed among four inputs. The game writes to extended I/O port $06 to control which input is selected. The input ports are (all active low): $00: bit 7: Button 4 (LB/LZ)/? (CM) bit 6: Button 3 (LB/LZ)/Button 1 (CM) bit 5: Button 2 (LB/LZ)/? (CM) bit 4: Button 1 (LB/LZ)/? (CM) bit 3: Service A (LB/LZ)/Coin C (CM) bit 2: Coin B bit 1: P2 start bit 0: P1 start $10: bit 7: Reset bit 6: Coin A bit 5: ? (LB/LZ)/Joystick 1 right (CM) bit 4: ? (LB/LZ)/Joystick 1 left (CM) bit 3: ? (LB/LZ)/Joystick 1 fire? (CM) bit 2: ? (LB/LZ)/Joystick 2 fire? (CM) bit 1: ? (LB/LZ)/Joystick 2 right (CM) bit 0: ? (LB/LZ)/Joystick 2 left (CM) $20: bit 7: Collision detection (LB/LZ)/Game over melody (CM): %0 = Off %1 = On bit 6: Infinite lives (LB/CM)/Calibration display (LZ): %0 = Off %1 = On bits 5..4: Lives: %00 = 2 lives %01 = 3 lives %10 = 5 lives (LB)/4 lives (LZ/CM) %11 = 6 lives (LB)/5 lives (LZ/CM) bits 3..2: Coin B generosity: %00 = 2 credits %01 = 3 credits %10 = 5 credits %11 = 7 credits bits 1..0: Coin A generosity: %00 = Half credit (LZ)/1 credit (LB/CM) %01 = 1 credit (LZ)/2 credits (LB/CM) %10 = 2 credits (LZ)/3 credits (LB/CM) %11 = 3 credits (LZ)/5 credits (LB/CM) $30 (CM): %1,01,01,00,1 bit 7: Coin C generosity: %0 = Half credit %1 = 1 credit bits 6..5: Extended play: %00 = None %01 = At 20,000 points %10 = At 24,000 points %11 = At 28,000 points bits 4..3: Difficulty: %00 = Easy %01 = Medium %02 = Difficult %03 = Very difficult bits 2..1: Unused bit 0: Win play: %0 = Off %1 = On $30 (LB/LZ): bit 7: Joystick down bit 6: Joystick up bit 5: Joystick right bit 4: Joystick left bit 3: ? bit 2: ? (LB)/Freeze (LZ): %0 = Off %1 = On bit 1: ? (LB)/Firing (LZ): %0 = Rapid %1 = Normal bit 0: ? PSU: Sense: high during vertical blank, low otherwise Lazarian -------- $1C00, $1C54 and/or $1CD7 seem to have something to do with the "extend" DIP switch (ie. "extra ship at x points"). $1C01: low bit is even when 1up's turn, odd when 2up's turn $1F01/$1F03/$1F05: 1UP score: low nybble of $1F01 is tens of thousands digit high nybble of $1F03 is thousands digit low nybble of $1F03 is hundreds digit high nybble of $1F05 is tens digit low nybble of $1F05 is ones digit $1F02/$1F04/$1F06: 2UP score: low nybble of $1F02 is tens of thousands digit high nybble of $1F04 is thousands digit low nybble of $1F04 is hundreds digit high nybble of $1F06 is tens digit low nybble of $1F06 is ones digit $1F07..$1F09: High score: low nybble of $1F07 is tens of thousands digit high nybble of $1F08 is thousands digit low nybble of $1F08 is hundreds digit high nybble of $1F09 is tens digit low nybble of $1F09 is ones digit ;Subroutine ADDSCORE------------------------------------------------------- ;r1 and r2 are passed as arguments; they are how many points to award. ;high nybble of r2: thousands ;low nybble of r2: hundreds ;high nybble of r1: tens ;low nybble of r1: ones ;if (*($1C00) > 26 || (*($1C00) == 20 && *($1CE3 + (*($1C01) & 1)) > 26) ;{ return; ;} ;r3 = *($1C01) & 1; ;*($1F05 + r3) = BCD(*($1F05 + r3) + r1 + $66); ;PSL |= $8; // set With Carry bit ;*($1F03 + r3) = BCD(*($1F03 + r3) + r2 + $66); ;*($1F01 + r3) = BCD(*($1F01 + r3) + $66); ;PSL &= ~($8); // clear With Carry bit 0 2C84 0C 1C 00 LODA,r0 $3c00 ;12,3 12 2C87 E4 1A COMI,r0 $1a ;6,2 18 2C89 15 RETC,gt ;9,1 27 2C8A 0F 1C 01 LODA,r3 $3c01 ;12,3 39 2C8D 47 01 ANDI,r3 $1 ;6,2 45 2C8F E4 14 COMI,r0 $14 ;6,2 51 2C91 98 06 BCFR,eq $2c99 ;9,2 60 2C93 0F 7C E3 LODA,r0 $3ce3,r3 [$3de1] ;12,3 72 2C96 E4 1A COMI,r0 $1a ;6,2 78 2C98 15 RETC,gt ;9,1 87 2C99 0F 7F 05 LODA,r0 $3f05,r3 [$2003] ;12,3 99 2C9C 84 66 ADDI,r0 $66 ;6,2 105 2C9E 81 ADDZ r1 ;6,1 111 2C9F 94 DAR r0 ;9,1 120 2CA0 CF 7F 05 STRA,r0 $3f05,r3 [$2003] ;12,3 132 2CA3 0F 7F 03 LODA,r0 $3f03,r3 [$2001] ;12,3 144 2CA6 77 08 PPSL $8 ;9,2 153 2CA8 82 ADDZ r2 ;6,1 159 2CA9 84 66 ADDI,r0 $66 ;6,2 165 2CAB 94 DAR r0 ;9,1 174 2CAC CF 7F 03 STRA,r0 $3f03,r3 [$2001] ;12,3 186 2CAF 0F 7F 01 LODA,r0 $3f01,r3 [$3fff] ;12,3 198 2CB2 84 66 ADDI,r0 $66 ;6,2 204 2CB4 94 DAR r0 ;9,1 213 2CB5 CF 7F 01 STRA,r0 $3f01,r3 [$3fff] ;12,3 225 2CB8 75 08 CPSL $8 ;9,2 ;if (r3 & 1 == 0) // 1UP ;{ r2 = 1; ; if (*($1CD7) & 1 == 1) ; { goto $2CFE; ;} } ;else // 2UP ;{ r2 = 2; ; if (*($1CD7) & 2 == 2) ; { goto $2CFE; ;} } ;r1 = (*($1C54) << 3) & %00000011; ;if (r1 == 0) ;{ goto $2CFE; ;} // implied else ;r1--; ;if (*($1F01 + r3) != 1) ;{ goto $2CFE; ;} ;if (*($1F03 + r3) < *($2D27 + r1)) ;{ goto $2CFE; ;} ;*($1CD7) |= r2; ;*($1CD8 + r3)++; ;*($1E31) = $CF; ;gosub $1093; ;execution flows into $2CFE 234 2CBA 0C 1C D7 LODA,r0 $3cd7 ;12,3 246 2CBD F7 01 TMI,r3 $1 ;9,2 255 2CBF 18 08 BCTR,eq $2cc9 ;9,2 264 2CC1 06 01 LODI,r2 $1 ;6,2 270 2CC3 F4 01 TMI,r0 $1 ;9,2 279 2CC5 18 37 BCTR,eq $2cfe ;9,2 288 2CC7 1A 06 BCTR,lt $2ccf ;9,2 297 2CC9 06 02 LODI,r2 $2 ;6,2 303 2CCB F4 02 TMI,r0 $2 ;9,2 312 2CCD 18 2F BCTR,eq $2cfe ;9,2 321 2CCF 0D 1C 54 LODA,r1 $3c54 ;12,3 333 2CD2 D1 RRL,r1 ;6,1 339 2CD3 D1 RRL,r1 ;6,1 345 2CD4 D1 RRL,r1 ;6,1 351 2CD5 45 03 ANDI,r1 $3 ;6,2 357 2CD7 18 25 BCTR,eq $2cfe ;9,2 366 2CD9 A5 01 SUBI,r1 $1 ;6,2 372 2CDB 0F 7F 01 LODA,r0 $3f01,r3 [$3fff] ;12,3 384 2CDE E4 01 COMI,r0 $1 ;6,2 390 2CE0 98 1C BCFR,eq $2cfe ;9,2 399 2CE2 0F 7F 03 LODA,r0 $3f03,r3 [$2001] ;12,3 411 2CE5 ED 6D 27 COMA,r0 $2d27,r1 [$2d27] ;12,3 423 2CE8 1A 14 BCTR,lt $2cfe ;9,2 432 2CEA 6A CF IORR,r2 *$2cbb [$1cd7] ;15,2 447 2CEC CA CD STRR,r2 *$2cbb [$1cd7] ;15,2 462 2CEE 0F 7C D8 LODA,r0 $3cd8,r3 [$3dd6] ;12,3 474 2CF1 84 01 ADDI,r0 $1 ;6,2 480 2CF3 CF 7C D8 STRA,r0 $3cd8,r3 [$3dd6] ;12,3 492 2CF6 04 CF LODI,r0 $cf ;6,2 498 2CF8 CC 1E 31 STRA,r0 $3e31 ;12,3 510 2CFB 3F 10 93 BSTA,un $1093 ;9,3 ;if (*($1F01 + r3) > *($1F07)) ;{ goto $2D17; ;} elif (*($1F01 + r3) < *($1F07)) ;{ return; ;} elif (*($1F03 + r3) > *($1F08)) ;{ goto $2D17; ;} elif (*($1F03 + r3) < *($1F08)) ;{ return; ;} elif (*($1F05 + r3) < *($1F09)) ;{ return; ;} 519 2CFE 0F 7F 01 LODA,r0 $3f01,r3 [$3fff] ;12,3 531 2D01 EC 1F 07 COMA,r0 $3f07 ;12,3 543 2D04 19 11 BCTR,gt $2d17 ;9,2 552 2D06 16 RETC,lt ;9,1 561 2D07 0F 7F 03 LODA,r0 $3f03,r3 [$2001] ;12,3 573 2D0A EC 1F 08 COMA,r0 $3f08 ;12,3 585 2D0D 19 08 BCTR,gt $2d17 ;9,2 594 2D0F 16 RETC,lt ;9,1 603 2D10 0F 7F 05 LODA,r0 $3f05,r3 [$2003] ;12,3 615 2D13 EC 1F 09 COMA,r0 $3f09 ;12,3 627 2D16 16 RETC,lt ;9,1 ;*($1F07) = *($1F01 + r3); ;*($1F08) = *($1F03 + r3); ;*($1F09) = *($1F05 + r3); ;return; 636 2D17 0F 7F 01 LODA,r0 $3f01,r3 [$3fff] ;12,3 648 2D1A C8 E6 STRR,r0 *$2d02 [$1f07] ;15,2 663 2D1C 0F 7F 03 LODA,r0 $3f03,r3 [$2001] ;12,3 675 2D1F C8 EA STRR,r0 *$2d0b [$1f08] ;15,2 690 2D21 0F 7F 05 LODA,r0 $3f05,r3 [$2003] ;12,3 702 2D24 C8 EE STRR,r0 *$2d14 [$1f09] ;15,2 717 2D26 17 RETC,un ;9,1 ;Data for Subroutine ADDSCORE--------------------------------------------- 2D27 00 db $00 ;means 10000 2D28 40 db $40 ;means 14000 2D29 80 db $80 ;means 18000 2D2A 0F db $0F ;means never ;Subroutine $4203--------------------------------------------------------- ;r2 = r0; ;if (*($1C3A) != 0) ;{ *($1720..$1729) = *($1C3A..$1C43); // 3rd PVI, sprite #2 imagery ;} ;*($174A) = *($1C1E); ;*($174C) = *($1C1F); ;if (*($1C3C) != 0) ;{ *($1740..$1749) = *($1C3C..$1C45); // 3rd PVI, sprite #3 imagery ;} ;return; 0 4203 C2 STRZ r2 ;6,1 6 4204 0C 1C 3A LODA,r0 $5C3A ;12,3 18 4207 18 0A BCTR,eq $4213 ;9,2 27 4209 07 0A LODI,r3 $A ;6,2 33 420B 0F DC 3A LODA,r0 *$5C3A,r3- [$EF] ;18,3 51 420E CF 77 20 STRA,r0 $5720,r3 [$5810] ;12,3 63 4211 5B 78 BRNR,r3 $420B ;9,2 72 4213 0C 1C 1E LODA,r0 $5C1E ;12,3 84 4216 CC 17 4A STRA,r0 $574A ;12,3 96 4219 0C 1C 1F LODA,r0 $5C1F ;12,3 108 421C CC 17 4C STRA,r0 $574C ;12,3 120 421F 0C 1C 3C LODA,r0 $5C3C ;12,3 132 4222 14 RETC,eq ;9,1 141 4223 07 0A LODI,r3 $A ;6,2 147 4225 0F DC 3C LODA,r0 *$5C3C,r3- [$EF] ;18,3 165 4228 CF 77 40 STRA,r0 $5740,r3 [$5830] ;12,3 177 422B 5B 78 BRNR,r3 $4225 ;9,2 186 422D 17 RETC,un ;9,1 ;Subroutine $422E--------------------------------------------------------- ;IOPORT($1) = *($1C55) ^ %00000001; // RAM ;if (*($1C55) ^ %00000001 == 1 || *($1CD6) == 0) // RAM ;{ return; ;} ;IOPORT($4) = *($1C4B) ^ %11111111; // RAM ;IOPORT($5) = *($1C4C) ^ %11111111; // RAM ;*($1CD6) = 0; // RAM ;return; 195 422E 0C 1C 55 LODA,r0 $5C55 ;12,3 207 4231 24 01 EORI,r0 $1 ;6,2 213 4233 D4 01 WRTE,r0 $1 ;9,2 222 4235 E4 01 COMI,r0 $1 ;6,2 228 4237 14 RETC,eq ;9,1 237 4238 0C 1C D6 LODA,r0 $5CD6 ;12,3 249 423B 14 RETC,eq ;9,1 258 423C 0C 1C 4B LODA,r0 $5C4B ;12,3 270 423F 24 FF EORI,r0 $FF ;6,2 276 4241 D4 04 WRTE,r0 $4 ;9,2 285 4243 0C 1C 4C LODA,r0 $5C4C ;12,3 297 4246 24 FF EORI,r0 $FF ;6,2 303 4248 D4 05 WRTE,r0 $5 ;9,2 312 424A 20 EORZ r0 ;6,1 318 424B C8 EC STRR,r0 *$4239 [$1CD6] ;15,2 333 424D 17 RETC,un ;9,1 -------------------------------------------------------------------------- Chaos 2 ------- KHz: 800 ROM: ? RAM: ? Output: VDU Serial printer (not emulated) Input: Parallel keyboard Real-time clock (without year function) Storage: Cassette (not emulated) 2 single-density floppy drives (not emulated) 20Mb hard disk (not emulated) Chaos 2: $0000..$07FF: 2K of monitor ROM? $0800..$0BFF: RAM? $0C00..$0DFF: variable RAM $0E00..$0FFF: RAM? $1000..$1FFF: 4K of monitor ROM $2000..$5FFF: user programs? $6000..$6FFF: ? $7000..$77FF: DOS? $7800..$79FF: RAM? $7A00..$7CFF: ? $7D00..$7DFF: variable RAM $7E00..$7FFF: ? "The memory map is vaguely in my mind and I should be able to find the all-important I/O map somewhere. There's a boot loader ROM page that is enabled by the flag output that modifies the $1000..$1FFF map somehow. Apart from that it's all RAM. The RAM at $7000..$7FFF holds the file system code." - David J. Greaves. It seems that user programs are normally loaded into the $2xxx region. BIOS/DOS -------- The supported commands are: ACCESS ASK ASCDIS BPCLR BPSET CLOSE CONTROL COPY DEVFIVE DIR END EXECUTE EXEC FILL FIND GOTO IF INPUT LET LIST LOAD LOWERCASE MEMDIS MEMSET OPEN PORT READ REBOOT RUNHEX RUN SAVE TYPESL TYPE VERIFY The LIST command seems to produce garbled output on the emulators (and maybe on the authentic machine). The reason for this has not been ascertained. -------------------------------------------------------------------------- Senko Coin-Ops (eg. Trivia Challenge) ------------------------------------- Y: Trivia Challenge, Rack 'n' Roll, etc.: $0000..$0FFF: ROM (4K) ($0000..$0FFF of senko11.bin) $1000..$14BF: ? $14C0..$14FF: RAM $1500..$17FF: ? $1800..$1BFF: video RAM? $1C00..$1FFF: RAM (1K) $2000..$2FFF: ROM (4K) ($1000..$1FFF of senko11.bin) $3000..$3FFF: ? $4000..$4FFF: ROM (4K) ($2000..$2FFF of senko11.bin) $5000..$5FFF: ? $6000..$6FFF: ROM (4K) ($3000..$3FFF of senko11.bin) senko1.bin (32 bytes): colour PROM? senko10.bin (16K): graphics imagery? senko12.bin (16K): graphics imagery? undumped ( ?K): questions -------------------------------------------------------------------------- Dolphin ------- KHz: 95? ROM: 256 bytes or more RAM: 128 bytes or more Output: 4-digit LED 2 glow LEDs Input: 10-key octal or 18-key hexadecimal keypad Various optional peripherals were available (eg. printer, ASCII keyboard, VDU, speaker, serial and parallel interfaces, cassette, papertape, etc.) but these are not emulated. Dolphin: $0000..$00FF: MO PROM $0100..$01FF: MONI PROM $0200..$07FF: RAM? $0800..$0BFF: 2708 EPROM $0C00..$0FFF: MONA EPROM $1000..$7FFF: ? 10-key (octal) keyboard is: . . . . . . . . . . . . . . . . M 4 5 6 7 . . P 0 1 2 3 18-key (octal) keyboard is: . . . C D E F . . . 8 9 A B . . M 4 5 6 7 . . P 0 1 2 3 "0" is also labelled "START". "1" is also labelled "MONA". "4" is also labelled "MOVE" (or "MONC"?). "." keys do not exist. Sense pin is used for input (connected to a red LED?). Flag pin is used for output, connected to a red LED. ### ..# ### ### #.# ### ### ### ### ### # # . # . # . # # # # . # . . # # # # # #.# ..# ### ### ### ### ### ..# ### ### # # . # # . . # . # . # # # . # # # . # ### ..# ### ### ..# ### ### ..# ### ..# $00 $01 $02 $05 $06 $07 $08 $09 0 or O 1 or I 2 5 or S 6 or G 7 8 9 LED output is done via I/O ports $00..$03. On bit = lit, off bit = unlit. Bit 7 is decimal point. Bit 6 is middle. 0 Bit 5 is top left. 5 1 Bit 4 is bottom left. 6 Bit 3 is bottom. 4 2 Bit 2 is bottom right. 3 7 Bit 1 is top right. Bit 0 is top. Here are the values to show numeric glyphs: '0': $3F '1': $06 '2': $5B '3': $4F '4': $66 '5': $6D '6' (w/o curves): $7C '6' (w/ curves): $7D '7' (w/o curves): $07 '7' (w/ curves): $27 '8': $7F '9' (w/o curves): $67 '9' (w/ curves): $6F The full character set is: ### # ### ### # ### # # # # # # # # # # # # # # # # # # $00 $01 $02 $03 $04 $05 $06 $07 ' ' ''' '1' '7' ### # ### ### # ### # # # # # # # # # # # # # # ### ### ### ### ### ### ### ### $08 $09 $0A $0B $0C $0D $0E $0F '_' '=' 'J' ### # ### ### # ### # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # $10 $11 $12 $13 $14 $15 $16 $17 ### # ### ### # ### # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # ### ### ### ### ### ### ### ### $18 $19 $1A $1B $1C $1D $1E $1F 'u' 'J' # ### # # ### # ### # # ### # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # $20 $21 $22 $23 $24 $25 $26 $27 'r' 'n' '7' # ### # # ### # ### # # ### # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # ### ### ### ### ### ### ### ### $28 $29 $2A $2B $2C $2D $2E $2F # ### # # ### # ### # # ### # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # $30 $31 $32 $33 $34 $35 $36 $37 '1' 'n' # ### # # ### # ### # # ### # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # ### ### ### ### ### ### ### ### $38 $39 $3A $3B $3C $3D $3E $3F 'L' 'C' 'G' 'U' '0' ### # ### ### # ### # # # # ### ### ### ### ### ### ### ### # # # # # # # # $40 $41 $42 $43 $44 $45 $46 $47 '-' '=' ### # ### ### # ### # # # # ### ### ### ### ### ### ### ### # # # # ### ### ### ### ### ### ### ### $48 $49 $4A $4B $4C $4D $4E $4F '=' '3' ### # ### ### # ### # # # # ### ### ### ### ### ### ### ### # # # # # # # # # # # # # # # # # # # # # # # # $50 $51 $52 $53 $54 $55 $56 $57 'r' '?' 'n' ### # ### ### # ### # # # # ### ### ### ### ### ### ### ### # # # # # # # # # # # # ### ### ### ### ### ### ### ### $58 $59 $5A $5B $5C $5D $5E $5F 'c' '2' 'o' 'd' 'a' # ### # # ### # ### # # ### # # # # # # # # # # # # ### ### ### ### ### ### ### ### # # # # # # # # $60 $61 $62 $63 $64 $65 $66 $67 'c' 'u' 'o' '4' '9' # ### # # ### # ### # # ### # # # # # # # # # # # # ### ### ### ### ### ### ### ### # # # # ### ### ### ### ### ### ### ### $68 $69 $6A $6B $6C $6D $6E $6F '5' 'Y' '9' # ### # # ### # ### # # ### # # # # # # # # # # # # ### ### ### ### ### ### ### ### # # # # # # # # # # # # # # # # # # # # # # # # $70 $71 $72 $73 $74 $75 $76 $77 'F' 'P' 'h' 'H' 'A' # ### # # ### # ### # # ### # # # # # # # # # # # # ### ### ### ### ### ### ### ### # # # # # # # # # # # # ### ### ### ### ### ### ### ### $78 $79 $7A $7B $7C $7D $7E $7F 't' 'E' '6' '6' '8' $80..$FF are the same as $00..$7F but with the decimal point lit. The I/O data and control ports seem to have some relationship to the memory map, but this relationship is not clear. Reflexes: Use any odd-numbered guest key (ie. D/9/5/1 column or F/6/7/3 column). (These are normally the host keys NL/n7/n4/n1 and n*/n9/n6/n3 on WinArcadia). There are two official ways you can play it: Game 1: wait until "--" appears, now press a key as soon as possible. Lower scores are better, except that "0.00" means disqualified. "0.01" is perfect score. Game 2: wait until "--" appears. Now wait for almost 10 seconds and then press a key. Higher scores are better. "A" directly following "--" means diqualified. "9.99" is perfect score. Game 3: wait until "--" appears. Now wait for 1 second and then press a key. Scores closer to "1.00" are better. "1.00" is perfect score. CALM Notation ------------- The address field is notated as follows for the CALM equivalents to the LODx and STRx instructions: CALM Signetics ---------------------------- LOAD A,r LODZ r LOAD r,#n LODI,r n LOAD r,�+�' LODR,r m Note that relative addresses are resolved LOAD r,�+�' LODR,r *m for Signetics but not for CALMS. LOAD r,m LODA,r m LOAD r,@m LODA,r *m LOAD A,(r)+m LODA,r0 m,r LOAD A,(r)+@m LODA,r0 *m,r LOAD A,(+r)+m LODA,r0 m,r+ LOAD A,(+r)+@m LODA,r0 *m,r+ LOAD A,(-r)+m LODA,r0 m,r- LOAD A,(-r)+@m LODA,r0 *m,r- For CALM: A is register A (ie. r0). # is an immediate value. r is any register. m is an absolute address. � is the offset from the IAR. �' is the IAR. @ means "contents of" (ie. "*" in Signetics notation). Signetics Name CALM Name Ami/WinArcadia Name --------------------- ---------------------- ------------------- Sense S Input I S I Flag F Output O F O Interrupt Inhibit II Interrupt mask bit IOF I F Inter-Digit Carry IDC Half carry H D H Register Select RS BANK1 B R B With Carry WC WITHCARRY W W W Overflow OVF OVERFLOW V O V Compare COM LOGICOMP L M L Carry C CARRY C C C -------------------------------------------------------------------------- PHUNSY (Philipse Universal System) ---------------------------------- $0000..$07FF: 2K of monitor EPROM (ie. the BIOS) $0800..$0FFF: 2K of RAM: $0800..$0BFF: general purpose RAM $0C00..$0E40: MDCR RAM $0E41..$0EDF: general purpose RAM $0EE0..$0EFF: monitor RAM (scratchpad) $0F00..$0FFF: monitor RAM (command input buffer) $1000..$17FF: 2K of screen RAM $1800..$1FFF: 13*2K of banked RAM (banks U0,U4..UF) 3*2K of banked EPROM (banks U1..U3) bank U0: RAM bank U1: PDCR (Portable Digital Cassette Recorder) bank U2: DASS (DisASSembler) bank U3: LABHND (LABel HaNDler) banks U4..U15: RAM $2000..$3FFF: 8K of general purpose RAM $4000..$7FFF: 16*16K of banked RAM (banks Q0..QF) bank Q0: MWB (MicroWorld BASIC) ($4000..$5983) banks Q1..Q15: empty VDU: 8*6 pixels per character cell (usual character size is 7*5) 64*32 character cells=2048 cells 512*192 pixels To run a BASIC game (after loading it): Q (if necessary) OLD RUN To make BASIC usable (after loading it): NEW To use the label program: 3UU Control port (ie. WRTC operand): bits 7..4 select which U-bank to use at $1800..$1FFF bits 3..0 select which Q-bank to use at $4000..$7FFF Control port reads (REDC) are for serial input. Data port reads (REDD) are for parallel input. If high bit of data port is clear, a key is down. If high bit of data port is set, no key is down. Writing to extended port $7E (WRTE) sets the timer countdown. It is specified in units of 10 milliseconds (ie. 1/100ths of a second), and thus can range from 0.01 to 2.55 seconds ($01..$FF). After expiration, an interrupt is generated, causing execution to jump to $001D. The timer is automatically reloaded whenever it expires. Writing $00 disables the timer. IOAD is the WRTZV pointer: normally $7AB (SROUT) IIAD is the REDZV pointer $7D8 (SERIN) ICAD is the CHIZV pointer $7C4 (DCHIN) SERIN waits for a key to be pressed, then returns it. Its pseudocode is: r5 = 0; r4 = 8; do { r0 = PORTC & 1; } while (r0 != 0); gosub DELAYC; for (r4 = 8; r4 >= 1; r4--) { gosub DELAY; r0 = (PORTC & 1) | r5; r5 = r0 >> 1; } gosub DELAY; r0 = r5 & %01111111; return; CHINP returns a key if one is currently being pressed, otherwise it returns $7F (DEL). Its pseudocode is: r0 = PORTD; if (r0 & %10000000 == %10000000) { r0 = $7F [DEL]; } else { PORTD = 4; r0 = PORTD; PORTD = 0; do { r5 = PORTD; } while (r5 & %10000000 == %10000000); r0 &= $7F; } return; KEYIN waits for a key to be pressed, then returns it. Its pseudocode is: do { r0 = PORTD; } while (r0 & %10000000 == %10000000); PORTD = 4; r0 = PORTD; PORTD = 0; do { r5 = PORTD; } while (r5 & %10000000 == %10000000); r0 &= $7F; return; Sound is generated by rapidly toggling bit 1 of the data port (via WRTD). Game Help --------- These PHUNSY BINs are compatible with Ami/WinArcadia 16.24: 50-THEME 64>374 BELMACH BELMACH0 BIG-CHAR This is a subroutine designed to be called by other programs, by putting the desired ASCII value in r0 and calling $3700. See the commented disassembly of this program for more details. This contains imagery at $3000..$32FF for the character set. There is also code elsewhere in the file ($3300+) to display this imagery. When the IAR is at $3700, R0 holds the ASCII character to display. BMK CHRPRNTR CLEARMEM This works but takes a few moments. COPY This installs these routines: 800G show this help 803G read cassette to RAM 806G save RAM to cassette 809G continue read after error DASS-004 (both dumps) DASS6800 FORTH-01 FUN-CLOCK GEINTJE GETS-002 GRAPJE-1..5 KLOK The emulator is too fast, or game is too slow, by a 1:120 ratio (0.8%). KRANT L-KRANT LABHNDN MODESTA,B,C,N (all except MODEST itself) MWBAS-04,05,06 (all except 00 and M6) Type NEW at startup, otherwise it will always just say "FILE ERROR". OPCD6800 This is not intended to be run, but rather is intended eg. as test input for a 6800 disassembler. OPCODES This is not intended to be run, but rather is intended eg. as test input for a 2650 disassembler. OTHELLO PASS (both dumps) PAUZE PEDT-004 PEDT-0A3 PIANO PMONmini QASS-003 RAMTEST RUNLIGHT SEE-C374 Usage: U Type eg. U0 to start viewing memory from address $0000. SEE-CHAR Usage: 800G Type eg. 800G0 to start viewing memory from address $0000. SEE-EXT (all dumps) all games in the MWB/ directory These dumps are incompatible, problematic or otherwise unusable: 300-BAUD BASIO-20 CASSDISK CDC-I/O CLOCK (10-A and 16-A. FUN.MDCR version is OK.) CONV2>0 This gosubs to $19EC (which doesn't contain anything) for some reason. CONV6>2 COPYOV DAME This is an ASCII picture. DISK FLXWR-02 FORTH-00 FPRINTER GRAPHICS GRAPHS HEXDUMP HYRO-001 (both dumps) I/OPACK KEYB-BEN LIEDJES LKRANT MAXBUG3 MAXCHAR MAXCHAR+ MBUG3-LT MEMTA MODEST (both dumps) MWBAS-00 MWBAS-M6 MX-SYST PALASM PCITALK PDCR-006 PH-CHR PHCSRD This tries to read from the MDCR cassette (via the Sense pin). PHEDTR2 (both dumps) This reads from extended I/O ports for some reason. PMON0400..0404 (all dumps) PORT9600 PRMTHS PRPRG READHEX ROW->COL (both dumps) SCR SEND-JET This jumps to $1914 (which doesn't contain anything) for some reason. SER-I/O SOUTCASS TERML TPRINT-S TPRINTER (both dumps) TRNR-001 ZOOI The reasons are various: * the program is accessing unemulated hardware (eg. SER-I/O); * the "program" is really just a subroutine library for use by other programs (eg. BIG-CHAR); * the program might be a bad dump (eg. FORTH-00?); * the program is expecting command line arguments (eg. SEE-CHAR); * the program is not intended to produce any output (eg. CLEARMEM); * etc. -------------------------------------------------------------------------- Ravensburg Selbstbaucomputer ---------------------------- $0000..$07FF: ROM $0800..$1FFF: RAM $0800..$08FF: BIOS RAM $0900..$1FFF: user RAM $2000..$7FFF: unmapped? If you have a monitor ROM at $0 (either V1 or V2) then the memory card with 4 chips looks like this: Bottom left: $0000-$07FF: 2716 ROM or 28C16 EEPROM Top left: $0800-$0FFF: 6116 RAM (system variables at $800..$8FF; $900+ free) Bottom right: $1000-$17FF: 6116 RAM, 2716 ROM, or 28C16 EEPROM Top right: $1800-$1FFF: 6116 RAM, 2716 ROM, or 28C16 EEPROM The system could also be operated without any monitor! With this mode, you enter your code with a binary address switch and data switch in single step mode ;-) With this, you start at address $0. After entering your program, you could switch to run mode (or stay in single step mode). There was also a 1Hz (one Hertz) clock speed to select instead of the 1MHz clock speed. V0.9 BIOS functions: HEXDEZ (ZBSR,un *$3) @ $5E9 HEXBCD CONV (ZBSR,un *$5) @ $230 CONVT SEP (ZBSR,un *$7) @ $207 SEPNIB COMB (ZBSR,un *$9) @ $21E COMNIB DIS (ZBSR,un *$B) @ $E5 DISP KIN (ZBSR,un *$D) @ $C4 KIN1 INIT (ZBSR,un *$F) @ $235 INIT1 SAVE (ZBSR,un *$11) @ $24E INIT2 RECAL (ZBSR,un *$13) @ $272 INIT3 CDIS (ZBSR,un *$15) @ $296 CDISP BPGOT (ZBSR,un *$17) @ $574 BPFND LODAT (ZBSR,un *$19) @ $149 LOAD ADDSUB (ZBSR,un *$1B) @ $6A0 ADSB MULT (ZBSR,un *$1D) @ $6CD MPYS DIV (ZBSR,un *$1F) @ $700 DIVS DEZHEX (ZBSR,un *$21) @ $649 BCDHEX SEPD (ZBSR,un *$23) @ $197 SEPDIS HEXD (ZBSR,un *$25) @ $774 HEXD1 DHEX (ZBSR,un *$27) @ $79D DHEX1 HEX (ZBSR,un *$29) @ $79F DHEX2 DEZ (ZBSR,un *$2B) @ $776 HEXD2 ERROR (ZBSR,un *$2D) @ $432 ERR Note that byte $673 of the V0.9 BIOS is not listed in the PDF. Its correct value has been ascertained to be $82. V2.0 BIOS functions: KIN (ZBSR,un *$14) @ $384 KBIN WBL (ZBSR,un *$16) @ $16A WRBL WCH (ZBSR,un *$18) @ $425 WCHR INPHX (ZBSR,un *$1A) @ $1B6 INHX OUTHX (ZBSR,un *$1C) @ $4F HXO LINEF (ZBSR,un *$1E) @ $45 LFC PUT (ZBSR,un *$20) @ $2C1 SERO GET (ZBSR,un *$22) @ $35E SERI HXTAB (ZBSR,un *$24) @ $19A TABL ADRES (ZBSR,un *$26) @ $185 ADDR CONTR (ZBSR,un *$28) @ $48C CR HO (ZBSR,un *$2A) @ $4E5 HOME1 CURSL (ZBSR,un *$2C) @ $4EE CURL3 CURSR (ZBSR,un *$2E) @ $52B CURR1 CURSU (ZBSR,un *$30) @ $5E6 CUUP1 CURSD (ZBSR,un *$32) @ $4C2 LF1 SCCLR (ZBSR,un *$34) @ $4CA CLR2 BACK (ZBSR,un *$36) @ $51A BACK1 Diode colours are: CLOCK (red) OPACK (green) OPREQ (yellow) M/IO (red) RUN/WAIT (green) WRP (red) FLAG (red) The keyboard looks like this: ...C... ...D... ...E... ...F... ..CMD.. .FLAG.. ...8... ...9... ...A... ...B... ..RUN.. ..MON.. ...4... ...5... ...6... ...7... ..GOTO. ..PC... ...0... ...1... ...2... ...3... ..RST.. ..NXT.. By default, these are mapped to the following host keys (on WinArcadia): ...a1.. ...a2.. ...a3.. .NumLk. ...n/.. ...n*.. ...Q... ...W... ...E... ...n7.. ...n8.. ...n9.. ...A... ...S... ...D... ...n4.. ...n5.. ...n6.. ...Z... ...X... ...C... ...n1.. ...n2.. ...n3.. These programs are contained in the "2650 Programme.pdf" book. Those marked "*" have been typed in: German Name English Translation -------------------------------------------------- ----------------------------------------------------- 440-Hz-Programm zum Abgleich des CLOCK-Oszillators 440 Hz program for the adjustment of clock oscillator Portadressierung Port addressing Einfache Addition Simple addition Einfache Subtraktion Simple subtraction Einfache Multiplikation Simple multiplication Einfache Division Simple division *Verkehrsampel 1 Traffic lights 1 *Blinklicht Beacon W�rfel Dice *Metronom Metronome Lauflicht Chase lights Voltmeter mit dualer Anzeige Voltmeter with dual displays *Denkzeitbegrenzer Think time limiter *Verkehrsampel 2 Traffic lights 2 VU-Meter Vumeter *Laufschrift Scrolling text W�rfelspiel Craps *Reaktionstest Reaction test Stoppuhr Stopwatch Digitaluhr Digital clock HEX-DEZ-HEX-Wandlung Hexadecimal-decimal-hexadecimal conversion HEX-Rechnen Hexadecimal calculation DEZ-Rechnen Decimal calculation Lottozahlen Lotto numbers Morse-�bungsprogramm Morse test program Voltmeter 2 (3stellig dezimal) Voltmeter 2 (3-adjusting decimal) Monitor commands are: Alter B C Dump E I Load R Verify -------------------------------------------------------------------------- MIKIT 2650 ---------- Clock speed is 1MHz. MIKIT 2650-K1, 2650-P1 (keypad input, LED output, 4 I/O pins, 512 bytes ROM, 256 bytes RAM): $0000..$01FF: BIOS ROM ( 512 bytes) $0200..$03FF: unmapped? $0400..$04FF: RAM ( 256 bytes) $0400..$041F: BIOS RAM ( 32 bytes) $0420..$04FF: user RAM ( 234 bytes) $2000..$7FFF: unmapped? MIKIT 2650-K21, 2650-P21, 2650-K1+2650-K2 (keypad input, LED output, cassette and teletype I/O, 8 I/O ports, 1K ROM, 1K RAM): $0000..$03FF: BIOS ROM (1024 bytes) $0400..$07FF: RAM (1024 bytes) $0400..$041F: BIOS RAM ( 32 bytes) $0420..$07FF: user RAM ( 992 bytes) $2000..$7FFF: unmapped? The cassette recorder uses port 227 for input and port 228 for output. The teletype uses port 229 for input and port 226 for output. There are 8 glow LEDs controlled by writing to the Control port (WRTC). The 6 LED digits are at $402..$407 (in BIOS RAM). $FD seems to be the entry point to the BIOS display routine. The keyboard looks like this: .BLANK. ...R... ...C... ...D... ...E... ...F... ...+... ...G... ...8... ...9... ...A... ...B... ...H... ...P... ...4... ...P... ...6... ...7... ...L... ...S... ...0... ...1... ...2... ...3... BLANK = ? R = Read + = Add? G = Go H = Halt P = Punch L = Load S = Store By default, these are mapped to the following host keys (on WinArcadia): ...a1.. ...a2.. ...a3.. .NumLk. ...n/.. ...n*.. ...Q... ...W... ...E... ...n7.. ...n8.. ...n9.. ...A... ...S... ...D... ...n4.. ...n5.. ...n6.. ...Z... ...X... ...C... ...n1.. ...n2.. ...n3.. Stufenzaehler (Program 5): The entire program is as follows: enable interrupts use main register bank clear With Carry set signed compare for (;;) { for (r1 = 1, r3 = N; r3 > 0; r1++, r3--) { r0 = *(&A + r3); if (r1 == r0) { PORTC = r1; } while (PORTC != *(&B + r3)); } } Ein- und Aus-Schaltbare Blinklampe (Program 7): The entire program is as follows: enable interrupts use main register bank clear With Carry set signed compare AUS: use main register bank PORTC = ........; // clear glow LEDs while (PORTC & %10000000); for (;;) { PORTC = .......#; // light one glow LED for (r4 = 256; r4 > 0; r4--) { for (r5 = 48; r5 > 0; r5--) { if (PORTC & %00000001 == %00000000) { goto AUS; } } } PORTC = ........; // clear glow LEDs for (r4 = 256; r4 > 0; r4--) { for (r5 = 48; r5 > 0; r5--) { if (PORTC & %00000001 == %00000000) { goto AUS; } } } } Elektronischer Wuerfel (Program 8): The entire program is as follows: enable interrupts use main register bank clear With Carry set unsigned compare *($402..$407) = $66; for (;;) { for (r1 = 6; r1 > 0; r1--) { gosub $FD; if (PORTC & %10000000 == %00000000) { *($407) = r1; do { gosub $FD; r0 = PORTC; } while (r0 >= 1 && r0 <= 127); } } } Reaktionzeittest (Program 12): Press any key to begin. As soon as the numbers begin incrementing, press eg. the '1' key. Codiertes Schloss (Program 13): You have to press three keys in succession within limited times. The keys you have to press are stored in *($52A..$52C) (in reverse order). COD is $529. Press 1, then 2, then 3. The entire game is as follows: enable interrupts use main register bank clear With Carry set unsigned compare PORTC = 0; // clear glow LEDs while (PORTC != *($52D)); // wait for first key for (r1 = 2; r1 >= 0; r1--) { for (r2 = 256; r2 > 0; r2--) { wait if (PORTC == *(&COD + r1)) // if pressed correct key { goto S1; } } PORTC = ########; // lose for (;;); S1: ; } PORTC = #.#.#.#.; // win for (;;); -------------------------------------------------------------------------- PoP --- $0.. $B8E: used BIOS ROM $B8F.. $FFF: unused? $1000..$17BF: user RAM? $17C0..$17FF: BIOS RAM $1800..$7FFF: user RAM? -------------------------------------------------------------------------- Comparative Table ----------------- Tape input Tape output ------------------------------------------- Arcadia n/a n/a Interton n/a n/a Elektor 1515+ baud raw via CASIN 1515+ baud raw via CASOUT PIPBUG 1 110 baud CUTS via Sense 110 baud CUTS via Flag PIPBUG 2 110/300 baud CUTS via S 110/300 baud CUTS via F HYBUG 300/600/1200 baud? 300/600/1200 baud? BINBUG 3.6 ? ? BINBUG 6.1 ? ? CD2650 300 baud CUTS via Sense* 300 baud CUTS via Flag* SI50 ? baud raw via Sense ? baud raw via port $F8 Selbst 110 baud CUTS? via Sense 110 baud CUTS? via Flag Notes: * CD2650 at 4.73 MHz does 1200 baud CUTS tape I/O. Keyboard input VDU output ------------------------------------------ Arcadia Memory mapped Memory mapped Interton Memory mapped Memory mapped Elektor Memory mapped Memory mapped PIPBUG 1 110 baud teletype via Sense 110 baud teletype via Flag PIPBUG 2 110/300 baud teletype via Sense 110/300 baud teletype via Flag HYBUG 300/600/1200 baud teletype? 300/600/1200 baud teletype? BINBUG 3.6 300 baud teletype via Sense Memory mapped BINBUG 6.1 ? ? CD2650 Parallel keyboard via Data port Memory mapped SI50 Memory mapped ? Selbst Parallel keyboard via port $07 Ports $1B & $1C Tape format Motor control --------------------------------------------- Arcadia n/a n/a Interton n/a n/a Elektor Elektor (EOF) No? PIPBUG 1 Signetics (AOF) No? PIPBUG 2 Signetics (AOF)? No? HYBUG ? ? BINBUG ? Yes, with ACOS CD2650 Signetics (AOF) Yes SI50 Signetics (AOF) No? Selbst ? Yes -------------------------------------------------------------------------- Pong ---- Not really a Signetics-based machine. Here is some information anyway that may be useful for comparative purposes, at least: For NTSC: Rasters 0.. 41 are vertical back porch ( 42 lines) Rasters 42..233 are main display area (192 lines) Rasters 234..257 are vertical front porch ( 24 lines) Rasters 258..261 are vertical retrace ( 4 lines) = 262 lines Main display area: 73*192 Entire display area: 128*262 For PAL: Rasters 0.. 43 are vertical back porch ( 44 lines) Rasters 44..275 are main display area (232 lines) Rasters 276..305 are vertical front porch ( 30 lines) Rasters 306..311 are vertical retrace ( 6 lines) = 312 lines Main display area: 73*232 Entire display area: 128*312 For both: Pixels 0.. 26 are horizontal back porch (27 pixels) Pixels 27.. 99 are main display area (73 pixels) Pixels 100..115 are horizontal front porch (16 pixels) Pixels 116..127 are horizontal retrace (12 pixels) = 128 pixels Pong: 128 pixels wide in 64 usecs: 128/64 = 2 pixels per usec 64/128 = 0.5 usecs per pixel Arcadia/Interton/Elektor (USG-based machines): 227 pixels wide in 64 usecs: 227/64 = 3.546875 pixels per usec 64/227 = 0.281938 usecs per pixel Central Data 2650: 904 pixels wide in 64 usecs: 904/64 = 14.125 pixels per usec 64/904 = 0.070796 usecs per pixel Therefore: a Pong pixel is as wide as 1.773438 USG pixels (227 / 128). a Pong pixel is as wide as 7.0625 CD2650 pixels (904 / 128). a USG pixel is as wide as 0.563877 Pong pixels (128 / 227). a USG pixel is as wide as 3.982379 CD2650 pixels (904 / 227). a CD2650 pixel is as wide as 0.141593 Pong pixels (128 / 904). a CD2650 pixel is as wide as 0.251106 USG pixels (227 / 904). -------------------------------------------------------------------------- Other Signetics-Based Machines ------------------------------ These other 2650-based machines are known but not yet emulated, due to insufficient documentation and software: * B&S Minimap (reviewed in ETI AU Jun '80, p. 89 & 91) * Philips CE6400: A single board computer based on the Signetics 2650 * Philips IMS (Industrial Microcomputer System) 2650 * Tektronix 8540 * Zaccaria pinball machines. * various other coin-ops There are also presumably various machines (at least a trainer) based on the more specialized Signetics 8X300 CPU (and variants thereof), none of which are currently known, let alone emulated. If you have further details about any of these, or other machines to add to this list, please email us. The following relevant documents are known but unavailable: * Signetics Corp., "PLuS Reference Manual", March 1976 Various model/project numbers and a quick summary thereof: ETI-560 is a Low Cost VDU (ETI AU Aug-Oct 1976) *ETI-560 was also used for the Mains Cable Seeker (ETI AU May 1980) *ETI-604 is a metronome *ETI-606 is a tuning fork ETI-630 is a hex display (ETI AU Dec 1976) ETI-631 is an ASCII keyboard (ETI AU Dec 1976, ETI UK Apr 1977) ETI-631-2 is a keyboard encoder (UART/baud rate generator) (ETI AU Apr 1977) ETI-632 is a VDU for 2650-based machines (and others) (ETI AU Jan-Mar 1977) ETI-633 is a TV Sync Generator for the ETI-632 (and others) (ETI AU Jan 1977) *ETI-634 is an 8080-based machine ETI-635 is a Microcomputer Power Supply (ETI AU Sep 1977) ETI-636 is a Low Cost S-100 Motherboard (ETI AU May 1980) ETI-637 is a CUTS cassette interface (ETI AU Jan 1978) -ETI-638 is an EPROM programmer (ETI AU July 1978) (the example software is for 6800 CPU, but it can be connected to any CPU) *ETI-639 is a computerised musical doorbell ETI-640 is a VDU for 2650-based machines (and others) (aka DG-640 and MW-640) (ETI AU Apr-Jun 1978) ETI-641 is a thermal printer (ETI AU Sep 1978) based on Philips EUR-10E023LE (the example software is for 8080 CPU, but it can be connected to any CPU) ETI-642 is a 16K S-100 RAM card (ETI AU Feb 1979) -ETI-643 is a universal EPROM programmer (ETI AU Dec 1979-Jan 1980) (the example software is for 8080 CPU, but it can be connected to any CPU) *ETI-650 is a STAC (Standard Timer And Controller) timer -ETI-651 is a binary-to-hex number converter (ETI AU Jun 1979) (2650 is mentioned but it is not actually a peripheral) *ETI-652 is an Atari joystick interface for System 80 (ETI AU Aug 1982) *ETI-660 is a Chip-8-based machine *ETI-668 is an EPROM programmer for Microbee (ETI AU Feb 1983) ETI-670 is a Low Cost ASCII Keyboard (ETI AU May 1982) *ETI-680 is a Z80-based machine (aka DG680) ETI-681 is a Programmable Character Generator for the ETI-640 (ETI AU Jun 1980) ETI-682 is an S-100 PROM board (ETI AU March 1981) ETI-685 is a 2650-based Single Board Computer for S-100 bus (ETI AU Dec 1981) (compatible with ETI-635,636,640,681,682,686) ETI-686 is a PPI-based EPROM Programmer for ETI-685 (and others) (ETI AU Oct 1982) ETI-692 is a Current Loop Interface (ETI AU Jan 1985) *ETI-694 is a FORTH computer *ETI-804 is an AY-3-8500-based Pong game (ETI AU Nov 1976) *ETI-811 is an AY-3-8710-based Tank game (ETI AU Oct 1978) CT750 is a Kansas City cassette interface KB04 is a Universal Keyboard in Teletype Model 33 ASR layout (see ETI AU Feb 1978, p. 70) KB05 is a Number Pad for KB04 KB06 is a Cursor Control for KB04 KB10 is spare key switches for KB04 EA 77cc4 is a cassette interface (EA Apr 1977) 2/CC/23 is a Low Cost VDU (EA Feb 1978) *EA 77up5 is a Mini-SCAMP EA 78ut4 is a keyboard encoder for use with Low Cost VDU (EA Apr 1978) EA 78m5 is a video modulator for use with Low Cost VDU (EA Apr 1978) EA 78up5 is a 2650 Mini Computer (EA May 1978) = relevant - = semi-relevant * = irrelevant 2112 is a 256-nybble SRAM. 2114 is a 1024-nybble SRAM. 2513 is a Character Generator from Signetics, used in ETI-560. 2608 is a 1K ROM (eg. PIPBUG). 2616 is a 2K ROM. 2632 is a 4K ROM. 2708 is a 1K EPROM. 2716 is a 2K EPROM. 2732 is a 4K EPROM. AY-5-2376 is a keyboard encoder, used in ETI-670. Filename Conventions -------------------- ! indicates a modified dump (eg. enhanced or compatibility patched). - indicates a known bad dump. END OF DOCUMENT-----------------------------------------------------------