SIGNETICS-BASED MACHINES CODING/GAMING GUIDE -------------------------------------------- This document was written on 29/8/08, and last updated on 20/8/24, 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 Senko Coin-ops PHUNSY Ravensburg Selbstbaucomputer MIKIT 2650 PoP Comparative Table Pong Other Signetics-Based Machines Project & Component Numbers BIOS Command Quick Reference Floppy Drive Comparison 2650 CPU Editions There are separate Coding and Gaming Guides for the Emerson Arcadia 2001, Interton VC 4000, and Elektor TV Games Computer. -------------------------------------------------------------------------- PIPBUG-Based Machines --------------------- 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. 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) Assembler,AssemblerPlusDemonstration,AssemblerPlusAssemblerList: AssemblerPlusDemonstration.pgm will assemble without errors, but the generated machine code is not being written to memory anywhere (we are asking in this case for ORG $2000, but it doesn't seem to matter where we ask for, it is never generated anywhere). Hence, the current dump of Assembler.pgm should be considered suspect (although it has been verified). As the other two are based on that dump, they are likewise suspect. GuessingGame: STRT = $440 code INPT = $493 code PRNT = $4A6 code MSAG = $4B1 data HexCal aka HexCalc: Enter source address. / appears. Enter destination address. = and result appears. Eg. 20/30=10 Result is the distance between the addresses. PAIR equ $45E gosub CRLF; for (r1 = 3; r1 >= 1; r1--) { PAIR = BINOUT(); COUT('/'); PAIR = (BINOUT() - PAIR) & $7F; COUT('='); BOUT(PAIR); // Byte output in hex COUT(' '); } goto $3F00; BINOUT: ;$46D // Input two hex chars and output in hex *($476) = BIN(); // Input two hex chars and form as byte BOUT(*($476)); // Byte output in hex return *($476); Life-MachineCode: $C00..$C59: baud rate initialization routine? $C26: LIFECRLF $C39: LIFECOUT $C5A: LIFECHIN $C76..$EEC: Life game code $EED..$F54: Life game variables 2650 Line Assembler: "It is not identical but is very similar to the Line Assembler described in the article "2650 mini assembler simplifies programming" by Jamieson Rowe published in the April 1979 issue of Electronics Australia (p. 76-80) and the follow-up article "Improving the 2650 mini line assembler" by A. M. Kollosche in February 1980 (p. 76)." - Chris Burrows. Binary Floating Point Routines (Application Note AS57): The program's prompt is corrupt (maybe the emulated teletype is not ready for it). Each pair of hex digits is not shown until it has been completely input. The spaces around operators are added automatically by the program rather than by the user. The start address determines the rounding mode, as follows: G6A6 will run with rounding. G6AA will run without rounding. Give 8 hex digits, then an operator, then another 8 hex digits, then = Supported operators are +, -, * and : (which is division). MathsDemonstration: Note that the listing is self-contradictory (the machine code does not match the assembly code). STRT: *(MOD) = ADDZ r3; r3 = SUB1(); for (;;) { r0 = CHIN(); if (r0 == '+') goto PLUS; elif (r0 == '-') goto SUBT; elif (r0 == '*') goto MULT; } SUBT: *(MOD) = SUBZ r3; PLUS: // $45C gosub COUT(r0); // print operation symbol ('+' or '-') r2 = r3; // 1st argument r3 = SUB1(); // 2nd argument r0 = r2; // 1st argument MOD: r0 += r3, or r0 -= r3, depending on the desired operation if (r0 < 0) { r0 = r3 - r2; *(A1) = '-'; // store '-' as 1st character r0 |= $30; // format for display *(A2) = r0; // store r0 as 2nd character } elif (r0 >= 10) { *(A1) = '1'; // store '1' as 1st character r0 -= 10; r0 |= $30; // format for display *(A2) = r0; // store r0 as 2nd character } else { r0 |= $30; // format for display *(A1) = r0; // store as 1st character r0 = NUL; *(A2) = r0 [NUL]; // store as 2nd character } goto END; MULT: // $48E gosub COUT(r0); // print operation symbol ('*') r2 = r3; // 1st argument r3 = SUB1(); // 2nd argument r0 = 0; while (r2 != 0) { r0 += r3; r2--; } while (r0 >= 10) { r0 -= 10; r2++; } r2 |= $30; // format for display *(A1) = r2; r0 |= $30; // format for display *(A2) = r0; goto END; SUB1: do { r0 = CHIN(); clear With Carry and COMpare bits } while (r0 < '0' || r0 > '9'); r3 = r0; gosub COUT(r0); r3 &= $0F; // remove display formatting return r3; END: r1 = 0; while (*(MSAG + ++r1) != 0) { COUT(r0); } gosub CRLF; goto STRT; 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: If 23 remaining on your turn, take 2 leaving 21. If 22 remaining on your turn, take 1 leaving 21. If 21 remaining on your turn, take 3 leaving 18 but you are in danger. If 20 remaining on your turn, take 3 leaving 17. If 19 remaining on your turn, take 2 leaving 17. If 18 remaining on your turn, take 1 leaving 17. If 17 remaining on your turn, take 3 leaving 14 but you are in danger. If 16 remaining on your turn, take 3 leaving 13. If 15 remaining on your turn, take 2 leaving 13. If 14 remaining on your turn, take 1 leaving 13. If 13 remaining on your turn, take 3 leaving 10 but you are in danger. If 12 remaining on your turn, take 3 leaving 9. If 11 remaining on your turn, take 2 leaving 9. If 10 remaining on your turn, take 1 leaving 9. If 9 remaining on your turn, you will eventually lose. If 8 remaining on your turn, take 3 leaving 5. If 7 remaining on your turn, take 2 leaving 5. If 6 remaining on your turn, take 1 leaving 5. If 5 remaining on your turn, you will soon lose. If 4 remaining on your turn, take 3 leaving 1 and winning. If 3 remaining on your turn, take 2 leaving 1 and winning. If 2 remaining on your turn, take 1 leaving 1 and winning. If 1 remaining on your turn, you have already lost. STRT = $440 code F1..F6, F8..FA: code $4B3 = PRNT code $4BC = MSGE data Number Game: The ! prompt means to hit ENTER (it presumably uses this user-dependant delay for randomization). Numbers up to 65535 are possible. The target number is stored at $486..$487 in little-endian format. The number of turns taken is stored at $4A8. Reaction Timer: You have to react when the cursor is in the leftmost column. Relative Address Calculator: Enter the 1st address (4 hex digits). Enter the 2nd address (4 hex digits). It will then display the value to use for a relative branch from the 1st to the 2nd instruction (the same as Ami/WinArcadia debugger REL command does). RYTMON: This program does not echo your input to the screen. $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. Star Shoot: The objective is to reach the end configuration shown below in as few moves as possible, by shooting stars. Each move consists of a digit 1-9 corresponding to the position of the star to shoot: Numbering Start End 123 ... *** 456 .*. *.* 789 ... *** The only valid first move is 5. Shots have these results: 1 2 3 4 5 6 7 8 9 .!- !.! -!. !-- -!- --! --- --- --- !!- --- -!! .-- !.! --. !!- --- -!! --- --- --- !-- -!- --! .!- !.! -!. . means the star becomes a dot ! means the star or dot becomes a dot or star (respectively) - are unchanged. It is possible to reach a configuration with zero stars and thus no possible moves, losing the game. Overview of Available Software ------------------------------ These programs are for real-time control and monitoring of custom hardware (which is not fully emulated): Linearization Vector Magnetometer Wind Furnace Controller Games: Alien Hunt Hit the Hurkle Maze Maker Micro BASIC games work if you type G1 and hit ENTER (these programs have not been individually tested recently): acey-deucy blackjack guessing game life lunar lander number game radio log These do nothing very useful, but are not expected to: 2708 eprom programmer on screen clock 1.0 (it works after poking the starting time into memory and registers first) most routines Working but with issues: alien hunt: has ! and " at end of table rows. bit echo: why does it print flashing garbage after each letter? cricket: doesn't randomize very well. life (machine code): for 110 baud, you just need to press U, as documented. For 300 baud, you need to press U (not Y), then ENTER, contrary to the documentation. Then press N for a new field and set it up with Os and spaces, using Ctrl-J repeatedly to move down. line assembler: why does start address begin at 2, and increment by 2 every time F5 (reset) is pressed? mastermind & revised mastermind: you need to use Ctrl-L instead of ENTER after each line of input. music (bach, yankee doodle): why do they print garbage while playing? random morse: why does it print garbage while playing? These probably work, check how to use them: assembler/disassembler message editor microbasic itself is probably ok? what about alternate version? rytmon target shoot All other games are fine. 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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otes 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 dd/mm/yy format. Invalid dates will cause the program to hang. 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." Linearization (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): 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) B = Burn The * is a graphical indicator of your distance from the surface. You must give a 2-digit burn each turn. Neither digit is displayed until both have been entered. 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). Pause the machine and then 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. Eg. use this sequence of debugger commands for 11:58 am: P E $573 '1' E R3 '1' E R2 '5' E R1 '8' J $500 P 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). Paper roll is 6 cm wide and 60 m long. 226 pixels (dots) * 293 pixels (dots). 37.6' pixels (dots) per cm. 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); } Matsushita EUY-10E023LE printer model number can be decomposed as follows: E=Electrosensitive 2=250mm flat cable, 372mm connector cable 3=32/21/16 cpl with 2 spacing dots (horizontally between each character) L=left-to-right scanning, MSD character generator E=manufacturer code 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)" (what article? which magazine?) 2. "EA 1978 Software Record" (plastic on cardboard record): 1. Hex Input routine 2. Hex Listing routine 3. Block Move & Search 4. Tape Verifier 5. Disassembler 6. Tape Measure 7. Dump for Auto-Start 8. 300 Baud Binary Dump 9. 300 Baud Binary Loader 10. Nim Game (we have this) 11. Number Guessing Game (we have this) This is the same item as the Dick Smith Electronics floppy vinyl record B-6300. 3. MultiBug, MATBUG, etc. 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). BINBUG System Software Comparison --------------------------------- Program Vers Input Output Tape DOS Addresses Yr Reference ------------------------------------------------------------------------------------------------- *BINBUG 3.5 300/paralell? DG640 300? ? $ 0..$ 7FF=2K ? *BINBUG 3.6 300/parallel? DG640 300 ? $ 0..$ 7FF=2K 79 BINBUG3.6.pdf BINBUG 4.5 ? DG640 ACOS ? $ 0..$ 7FF=2K ? BINBUG 5.3 ? serial ACOS ? $ 0..$ 7FF=2K ? BINBUG 6.0 Eurocard Eurocard ACOS ? $ 0..$ 7FF=2K ? *BINBUG 6.1 300/1200/2400/par DG640 ACOS VHSDOS $ 0..$ 7FF=2K 82 sbcos_manual.pdf *BINBUG 7.1 300/1200/2400/par 300/1200/2400 ACOS VHSDOS $ 0..$ 7FF=2K 82 sbcos_manual.pdf Multibug Ser. 300 300 300 ? $ 0..$ 7FF=1K 81 (ETI-685) Multibug Mem. Parallel DG640 300 ? $ 0..$ 7FF=1K 81 (ETI-685) MATBUG 4.1 Eurocard DG640 ? ? $ 0..$ 7FF=1K ? matbug_monitor_for_eurocard_system_notes.pdf *GBUG+EDIT5800 300? DG640 $ 0..$ 7FF=1K *MIKEBUG 3 300? DG640 $ 0..$ 7FF=1K *MYBUG 300? DG640 $ 0..$ 7FF=1K BASIC 1 - - - - $ 800..$1FFF=6K ? BASIC 2 - - - - $2000..$3BFF=7K ? ACOS 2.C - - C & D ports - $6000..$63FF=1K ? ACOS 3.C - - E ports - $6000..$63FF=1K ? *ACOS 3.E - - E ports - $6000..$63FF=1K 82 sbcos_manual.pdf *VHSDOS 2.6a - - - - $6800..$6FFF=2K 81 vhs_dos_v26a_source_listing.pdf *MicroDOS 4.5a - - - - $6800..$6FFF=2K ? MICRODOS.SRC * are supported by Ami/WinArcadia 30.02. SBCOS = BINBUG 6.1 + BINBUG 7.1 + ACOS 3.E BINBUG 6.1 & 7.1 support/expect ETI-685 processor board. BINBUG 3.6 & ACOS 3.E are for 1 Mhz CPU. BINBUG Floppy Drives (eg. for VHSDOS/MicroDOS) ---------------------------------------------- The FD1771 controller is used to support single-sided, single-density FM- encoded floppies. Each block (sector) is 256 bytes. There are 10 sectors per track, numbered 1..10 and with an interleave of 7, ie.: 1,8,5,2,9,6,3,10,7,4, giving 2.5K per track. There are 40 tracks, numbered 0..39, giving a total of 400 blocks or exactly 100K per disk. Each block is 256 bytes, as follows: 0: next track (0..39). 1: next sector (1..10). 2..255: data bytes Tracks are numbered from 0..39. Sectors are numbered from 1..10. CMD files are used by VHSDOS and MicroDOS for storage of games. They normally consist of two or more chunks concatenated together. Each chunk has a 3-byte header: 0..1: load address of chunk (big-endian) 2: length of payload in bytes (normally <= $FB) then the payload itself (if any) follows. The CMD file is terminated by a chunk like this: 0..1: start address of game (big-endian) 2: $00 with no payload. CMD chunks can seamlessly cross block boundaries. Note that the above assumes that the block header (ie. "next track" and "next sector" bytes) have already been skipped. To play the Microbyte Adventure game using WinArcadia: 1. Choose "Options|Machine|BINBUG" (or press Ctrl+5). 2. Choose "Options|BIOS|BINBUG ROMs...". 3. Select BINBUG 3.5, 3.6 or 6.1. 4. Select VHSDOS. 5. Click OK. 6. Choose "File|Reinitialize machine". 7. Choose "File|Open...". 8. Select "Adventure.raw". 9 Click OK. 10. Type K and press ENTER. 11. Type ADVENT and press ENTER. The dumped disk is installed for VHSDOS and has one saved game (GAME1.ADV). Note that loading the VHSDOS version under MicroDOS will corrupt the disk! Specifically, the free block list will be corrupted and therefore you will not be able to save the game (as not enough free space will be found) on such a disk. If you want to play it under MicroDOS, you must reinstall it for MicroDOS (by running the INSTALL program). The INSTALL program does the following: $ B16 : Sets this according to the number of rows ($10=16 rows, $18=24 rows). This is part of the game (ADVENT.CMD). $ B17 : Sets this according to the target platform ($00=VHSDOS, $01=MicroDOS). This is part of the game (ADVENT.CMD). $ 3D..$3F: Sets the date stamp of the game (ADVENT.CMD) to the current date. This is done by DOS, and is a side effect of writing to ADVENT.CMD. $3301 : Sets the next sector field of track 5, sector 2 to 3 (from 10). This is done by DOS, and is a side effect of writing to ADVENT.CMD. The vocabulary for Adventure is: NUGGET, GOLD, SILVER, BARS, JEWELERY, COINS, DIAMONDS, VASE, PEARL, EGGS, NEST, TRIDENT, EMERALD, PYRAMID, CHAIN, SPICES, RUG, CHEST, LAMP, LANTERN, KEYS, FOOD, BOTTLE, CAGE, ROD, CLAM, MAGAZINE, BEAR, BLADE, PILLOW, POTTERY, SHARDS, OYSTER, BIRD, TROLL, DRAGON, SNAKE, DWARF, GRATE, BRIDGE, STREAM, STUFFED, FUCKED, AXE, ALL, EVERYTHIng, HILL, DOOR, GO, WALK, RUN, MOVE, CRAWL, FORWARD, CONTINUE, BACK, RETREAT, DESCRIBE, LOOK, L, EXAMINE, GET, CARRY, TAKE, PICKUP, DROP, FILL, LIGHT, OPEN, OIL, CATCH, THROW, ATTACK, KILL, FEED, WATER, UNLOCK, FREE, RELEASE, WAVE, XYZZY, PLOVER, PLUGH, CROSS, CLIMB, JUMP, EMPTY, LOCK, CLOSE, EAT, DRINK, KUNGFOO, LOAD, SAVE, INVENT, INTENTORy, I, SCORE, QUIT, INFO, HELP, BUILDING, HOUSE, DEPRESS, NORTH, N, SOUTH, S, EAST, E, WEST, W, UP, U, DOWN, D, DOWNWARD, NORTHEAST, NE, NORTHWEST, NW, SOUTHEAST, SE, SOUTHWEST, SW, ENTER, INTO, IN, OUT, OUTSIDE, EXIT, LEAVE, FOLLOW. This is a (very) partial map and walkthrough, based on confirmed 2650 version behaviour. See https://rickadams.org/adventure/ for more maps and walkthroughs; the 2650 version appears to be similar to the "550- point" version of the game (although it only goes up to 250 points). eg. https://rickadams.org/adventure/walk550.txt Outdoors: N, W, GET BLADE?, ENTER HOUSE, GET ALL, EXIT HOUSE, S, S, FILL BOTTLE, OIL, FILL LAMP, FILL BOTTLE, OIL, S, UNLOCK GRATE, OPEN GRATE, D. 9 # 7-----5-----6 | | | 8-----4 1 | | 3-----2 | 10 1: at a hill at the end of a road 2: in a forest 3: near a slit in the streambed (oil) 4: beside a stream in a valley 5: at a road near a house (blade) 6: in a forest 7: in a forest 8: in a forest 9: inside the house (bottle, food, keys, lamp) 10: directly above a grate in a dry streambed (grate) 5->9: ENTER HOUSE 9->5: LEAVE HOUSE 10->1 (of 1st level A): UNLOCK GRATE, OPEN GRATE, D 1st level A: W, GET CAGE?, W, GET ROD?, FILL LAMP, LIGHT LAMP, W, W, CATCH BIRD?, W, D 6-----5-----4-----3-----2-----1 1: below the grate 2: in a cobble crawl (cage) 3: in the debris room (rod) 4: in an awkward sloping E/W canyon 5: in the bird chamber (bird) The bird is frightened of black rods. 6: at the top of a small pit 1->10 (of outdoors): U 6->1 (of 2nd level): D 1st level B: 3 | 2 | 1 | 4----? 1: in a secret N/S canyon above a large room 2: in the canyon with the mirror 3: at the underground reservoir 4: in a secret canyon which exits to north and east (rug) 3->1 (of 0th level): U 0th level: ? 21 | | ?-----22----20-19 | | 1----------2 37 38 ? ? | | / | | | 3 36-----35-----34-----33 16 | | | | \ | 4-------------------5-------6 17 15-----? | \ | / 18 \ ? / \ / 13----12-7-14 | 11-8 | 9 | 10 1: at the top of a steep incline above a large room 2: in a cavern with a waterfall (trident) 3: at the end of an immense N/S passage (door) 4: in a giant room Try a magic word. 5: in a long narrow E/W corridor 6: in the oriental room (vase) 7: the swiss cheese room 8: in a tall N/S canyon 9: at a wide place in a very tight N/S canyon [U] 10: the canyon becomes too tight to continue 11: the canyon runs into a mass of boulders - dead end 12: at the east end of the twopit room 13: at the west end of the twopit room [U] 14: in the soft room (pillow) 15: in a bed quilt [U,D] [S is same as SW here] 16: at the junction of three secret canyons 17: in a secret canyon above a sizable passage [D] 18: the passage here is blocked by a recent cave-in 19: in a maze of twisty little tunnels 20: at the junction of a high northerly passage and a low E/W one 21: at a dead end 22: in the hall of the Mountain King [U] Some birds can kill snakes. 33: in a misty cavern 34: in an alcove 35: in a large low room 36: in the plover room - emerald 37: in the dark room 38: dead end crawl 1->3 (of 1st level B): D 22->1 (of 2nd level): U 2nd level: S, GET NUGGET?, 16 | 15-----17 | 18-----14 / | 19 13 / | 9-----8-----7 12 20-----21 | | 4-----5-----6-11 | | 2-----1 10 | 3 1: in the hall of mists Use a magic rod. 2: on the east side of a fissure 3: in the gold nugget room (nugget) 4: at the west end of a long hall 5: at the east end of a long hall 6: at the west end of the hall of mists (diamonds) 7: on the brink of a pit [D] 8: in a dirty broken passage 9: in a room full of dusty rocks [D] 10: in a maze of little tunnels, all alike 11: on the west end of a fissure in the hall of mists 12: in the slab room 13: in a N/S limestone passage 14: at a fork in the path (axe) 15: at a junction with warm walls (pyramid) 16: at a breathtaking view 17: in the chamber of boulders (spices) 18: in a west leading corridor 19: at the N/E side of the troll's bridge 20: outside a barren room 21: inside a barren room (chain) It may be hungry. 12->1 (of 1st level B): U The oil level in the lamp is stored at $1E33. Zeroing $16EF (eg. "E 16EF 0" in the debugger) will prevent the oil from being used up. Location, etc. are likely to be in one or more of $1e22..6,$1e2d..f, $1e38..9,$1e48,$1e4c..f,$1e55..7,$1e75..$1ea1. VHDOS WRTEs: $683F - $D0 TO $0C: "FORCE INTERRUPT" $684C - DFDRV to $10: "FORCE SYSTEM DRIVE" $6850 - $0B TO $0C: "RESTORE" $68C3 - $0B TO $0C: "RESTORE" $6CC7 - $8C TO $0C, IT'S THE READ SECTOR COMMAND SINGLE RECORD IBM FORMAT (128..1024 BYTES) ENABLE HLD, HLT, 10MSEC DELAY $6D0B - $AC TO $0C, IT'S THE WRITE SECTOR COMMAND $6D22 - TO $0F ("DATA REG") $6D32 - $8C TO $0C, IT'S THE READ SECTOR COMMAND $6D6B - R0 TO $10: IT'S SELECT SIDE & DRIVE $6D80 - R0 TO $0D: IT'S THE TRACK SELECTOR!? $6DB3 - R0 TO $0F: "TRACK" $6DB7 - $1B TO $0C: "SEEK WITH HLD" $6DD2 - R0 TO $0E: "WRITE SECTOR REG" $6DDB - $0B TO $0C: "RESTORE" $6DE4 - R0 TO $0F: "TRACK" $6DE8 - $1F TO $0C: "SEEK WITH HLD AND VER" VHSDOS REDEs: 6CC9 - $10 FDINT 6CCD - $0F FDDAT ("DATA REG") 6CE8 - $0D FDTRK 6CF4 - $0C FDCMD - WAITING FOR DRIVE NOT BUSY COMPARE BIT 0 IF ALL COMPARED BITS ARE SET, EQ ELSE LT $6D0D - $10 FDINT $6D11 - $0C FDCMD $6D1E $6D26 $6D4C $6D75 $6D9D $6DA3 $6DB9 $6DBF $6DDD $6DEA $6DEE Raw disk speed: The disk spins clockwise (thus sectors are numbered anticlockwise) at 300 rpm / 60 = 5 rps. There are 10 sectors per revolution. Each sector takes 1/50th sec to read. 256 bytes (1 sector) * 50 sectors = 12,800 bytes per second. Each track (10 sectors) (2.5K) takes 1/5th sec to read. Each byte takes 1/12,800th sec = 78.125 usecs to read (about a scanline). This ignores what is happening at the raw flux level (inter-sector gaps, etc.) but that is unimportant; the overall speed of reading a sector is as stated. Each sector takes 1/50th sec = 20 msecs to read (about a frame). At the flux level: This FD1771 is using a 1 MHz (not 2 MHz) clock. There are 250,000 flux transitions per second. Each bit is 1 clock flux + 1 data flux, so there are 125,000 bits per sec. So theoretically 15,625 bytes per sec, if there were no sector headers, inter-sector gaps, etc. Effective disk speed: However, post-read processing must occur, so we can only really achieve 1/8th of that speed (hence the interleaving). Thus, an effective speed of 12,800 bytes / 8 = 1,600 bytes per second. After each 20 msec sector read, there is about 140 msec of post-processing as the disk continues to spin. But...the CPU has to keep up with the drive as it reads each byte, because the drive has no buffer. With an infinitely fast disk, it takes about 30,642 clocks. ie. about 30.642 msec, between reading an arbitrary byte in a given sector and reading the equivalent byte in the next sector. It also takes time to: change tracks start/stop motor -------------------------------------------------------------------------- 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. 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.". 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 Dice with Display: The rightmost parallel I/O switch (bit 0) needs to be on, otherwise the 7-segment LED digit area of the display will never change. The program relies on random data in uninitialized RAM for its random number generation, hence you should ensure that "Settings|Emulator| Randomize memory?" is on before loading the game. 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". Question 68: The original listing has an error in byte $125: 0124 F9 7C BDRR,r1 $122 which causes an infinite loop. It should instead be: 0124 F9 7E BDRR,r1 $124 The version in the Games Pack incorporates this fix. 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. Desk Clock, 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 ----------------- 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. The CD2650 character set is: $0123456789ABCDEF ---------------- @ABCDEFGHIJKLMNO $0x PQRSTUVWXYZ[.]^< $1x !"#$%&'()*+,-./ $2x 0123456789:;<=>? $3x `abcdefghijklmno $4x (This row can be chessmen) pqrstuvwxyz{|}~# $5x (# is a solid square) !"#$%&'()*+,-./ $6x 0123456789:;<=>? $7x 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 -------- To start a game: press R (twice) then ENTER. Now, from the "OPTION" prompt, press R (once). In editor (at COMMAND prompt): - = go to beginning of file + = go to end of file / = go backwards 15 lines Bx = go backwards x lines space = 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 (all values in hex): 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 handwritten annotations on the listing are generally transcriptions of the V1.3 changes. The following problems are hereby noted. This suggests there are bad bytes in the current 8K BASIC dumps (even though they have been verified) (and therefore also BASIC games), and therefore these dumps should all be regarded as suspect. Or possibly (although very unlikely) even some bug in the emulator's CPU core: (a) all values below 0.8 (eg. 0.799999) cause an OVerFlow error. Eg. LET A=0.7 or PRINT 0.7 $3961 will jump to ERR15 (based on Carry bit test). If you NOP the jump at $3961 out, $3976 will jump to ERR15 shortly afterwards (based on OVerFlow bit test). If both are NOPped out, 0.799999 goes in as $FF66665C (-0.017120) instead of $037FFFFF (0.799999). 0.8 is fine (goes in as $04400000, as expected), and so are higher numbers. Negative numbers do not work correctly (due to the unary subtraction bug mentioned below). Processing of A=0.7 or A=0.8 or similar will pass through EVAL, ECONST, FPDIV. At $3961 (in FPDIV) the interpreter first detects the overflow error (if any). So the bug must occur before then. (b) - (subtraction) operator: gives wrong results (3-2=9 apparently!). This includes unary subtraction, ie. negative numbers. Eg. A=-1 sets A to 3. (c) ^ (power of) operator: gives wrong results (3^2=16,330.57 apparently!). Problematic bytes in the listing: (*) COS function: bytes $3D90..$3D91 (in COS routine) are ambiguous (due to a poor quality printout/photocopy). But logically they would be $06 $04 (LODI,r2 4). Numbers are stored thus: Bit 31 is the sign of the exponent (0=positive, 1=negative). Positive exponents represent large positive or negative numbers. Negative exponents represent small positive or negative numbers (-0.5..0.5). Bits 30..24 are the exponent, ie. the position of the "decimal" (really binary) point. $40..$7F are probably negative (-64..-1). Bit 23 is the sign of the mantissa. Bits 22.. 0 are the mantissa. Positive numbers that have been properly normalized will have mantissa bytes of $400000..$7FFFFF.) The integer part is obtained thus: The mantissa will be shifted right by 23..0 bits, respectively, for stored exponent of 0..23, to obtain the integer part. Basically 23-exponent is how many times to halve the value of the left-hand bits. The fractional part is obtained thus: Mask out the leftmost bits of the mantissa (1..24 of them, respectively, for stored exponent of 0..23). Left shift this value 1..24 times, respectively, for stored exponent of 0..23. This represents the fractional part in 16 millionth (approx.) units. So divide this value by 16,777,216 to obtain the fractional part. Basically the exponent is how many times to double the value of the right-hand bits. The exponent is how many bits are needed to store the integer part of the number. Very small numbers will have negative exponents. Exponent "Decimal" point position -------- ----------------------------- etc. -3 %.000xxxxxxxxxxxxxxxxxxxxxxxx -2 %.00xxxxxxxxxxxxxxxxxxxxxxxx -1 %.0xxxxxxxxxxxxxxxxxxxxxxxx Eg. 0.25 = %.100000000000000000000000 = $7F 40 00 00 = move 24 bits right = 0 (for integer part) 0 %.xxxxxxxxxxxxxxxxxxxxxxxx Eg. 0.5 = %0.10000000000000000000000 = $00 40 00 00 = move 23 bits right = 0 (for integer part) 1 %x.xxxxxxxxxxxxxxxxxxxxxxx Eg. 1.0 = %01.0000000000000000000000 = $01 40 00 00 = move 22 bits right = 1 2 %xx.xxxxxxxxxxxxxxxxxxxxxx Eg. 2.0 = %010.000000000000000000000 = $02 40 00 00 = move 21 bits right = 2 3 %xxx.xxxxxxxxxxxxxxxxxxxxx Eg. 5.0 = %0101.00000000000000000000 = $03 50 00 00 = move 20 bits right = 5 4 %xxxx.xxxxxxxxxxxxxxxxxxxx Eg. 10.0 = %00101.0000000000000000000 = $04 50 00 00 = move 19 bits right = 10 5 %xxxxx.xxxxxxxxxxxxxxxxxxx . 6 %xxxxxx.xxxxxxxxxxxxxxxxxx . 7 %xxxxxxx.xxxxxxxxxxxxxxxxx Eg. 100.0 = %01100100.0000000000000000 = $07 64 00 00 = move 16 bits right = 100 8 %xxxxxxxx.xxxxxxxxxxxxxxxx . 9 %xxxxxxxxx.xxxxxxxxxxxxxxx . 10 %xxxxxxxxxx.xxxxxxxxxxxxxx Eg. 1000.0 = %01111101000.0000000000000 = $0A 7D 00 00 = move 13 bits right = 1000 11 %xxxxxxxxxxx.xxxxxxxxxxxxx 12 %xxxxxxxxxxxx.xxxxxxxxxxxx 13 %xxxxxxxxxxxxx.xxxxxxxxxxx 14 %xxxxxxxxxxxxxx.xxxxxxxxxx 15 %xxxxxxxxxxxxxxx.xxxxxxxxx 16 %xxxxxxxxxxxxxxxx.xxxxxxxx 17 %xxxxxxxxxxxxxxxxx.xxxxxxx 18 %xxxxxxxxxxxxxxxxxx.xxxxxx 19 %xxxxxxxxxxxxxxxxxxx.xxxxx 20 %xxxxxxxxxxxxxxxxxxxx.xxxx 21 %xxxxxxxxxxxxxxxxxxxxx.xxx 22 %xxxxxxxxxxxxxxxxxxxxxx.xx 23 %xxxxxxxxxxxxxxxxxxxxxxx.x 24 %xxxxxxxxxxxxxxxxxxxxxxxx. 25 %xxxxxxxxxxxxxxxxxxxxxxxx0. 26 %xxxxxxxxxxxxxxxxxxxxxxxx00. 27 %xxxxxxxxxxxxxxxxxxxxxxxx000. etc. 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 & Ami/WinArcadia Compatibility ---------------------------------------- 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 12KBASIC-A.pgm was probably typed in by me from the listing. Need to compare with 12KBASIC-B, which may have been modified for PHUNSY or PoP, as there are 982 differences (4%) between them. ALP.bin: Neither of these has been typed in by me from the listing. Need to verify these dumps against the listing and compare with each other. One or both may have been modified for PHUNSY or PoP, as there are 831 differences (4%) between them. AntennaComputer.bin: This is a good dump, as regards the actual antenna computer program. The accompanying BASIC interpreter is why it is marked as a suspect dump. Overflows are very easy to generate, eg. attempting a LOOP of 1000 MHz. 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. Bootstrap.pgm: Does not seem to work, due to missing disk emulation, a bad dump, or both. Needs investigation. DOS.pgm: Gets a "NOT READY" error, presumably due to missing disk emulation. Editor/Assembler: Commands are similar to the 12K BASIC editor, except: G: goes to the supervisor R: runs the assembler Z: frees memory Hamurabi.bin: This is probably a good dump, as regards the actual antenna computer program. The accompanying BASIC interpreter is why it is marked as a suspect dump. Overflows are very easy to generate, eg. at line 1780. 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 (they will appear as small o characters or as squares, depending on VDU setting) and the spacebar to clear them. To begin the simulation, move (with D key) the cursor to the bottom row of the screen. Never move the cursor above the top 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 When you run out of fuel, your ship falls out of the sky, but your exhaust continues to burn and does not fall. This is probably authentic. -------------------------------------------------------------------------- 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 Zaccaria Pinball for Windows ---------------------------- Here is how to run the latest version of Zaccaria Pinball (on Windows 7/8/8.1/10/11), which otherwise would require Steam, without DRM and with all tables: 1. Download Zaccaria_Pinball_v20220905_Steam_RiP from https://filecrypt.cc/Container/066D918234.html Password is cs.rin.ru Extract it all to somewhere (eg. C:\GAMES\ZACCARIA) If WinRAR complains that the file is corrupt, your WinRAR version is probably too old (eg. WinRAR 3.62 and earlier are definitely too old); you will need to download and install a more recent version of WinRAR from https://www.rarlab.com/ 2. Download Zaccaria_Pinball_v20220905_Cracks_Only from https://filecrypt.cc/Container/C2CFA101D4.html Password is cs.rin.ru Extract everything from SSE_v1.4.3 directory into the same directory as previously (thus overwriting ZaccariaPinball.exe and steam_api.dll) 3. Optionally, you can create a desktop shortcut as follows: 3a. Click on an empty part of the desktop, right-click and choose "New >>|Shortcut". 3b. Click "Browse...". 3c. Navigate to where SmartSteamLoader.exe is located (eg. C:\GAMES\ZACCARIA), click the SmartSteamLoader.exe file, and click "OK". 3d. Click "Next...". 3e. Change the shortcut name to eg. "Zaccaria Pinball" or whatever and press ENTER. 4. If you want a better icon for the shortcut: 4a. Download the icon from https://cdn.cloudflare.steamstatic.com/steamcommunity/public/images/apps/444930/08bf6c6da88227cce20ef9e1993f128235a8a46f.ico into the same directory as SmartSteamLoader.exe (C:\GAMES\ZACCARIA or wherever). 4b. Click on the shortcut, right-click and choose "Properties". 4c. Click "Change Icon...". 4d. Click "Browse...". 4e. Double-click the 08bf6c6da88227cce20ef9e1993f128235a8a46f.ico file. 4f. Click "OK" twice. 5. At this point, you may be able to run SmartSteamLoader.exe to launch the game. If this does not work, undertake the below steps as necessary. 6. If you get errors about missing MSVCP100.dll and/or MSVCR100.dll files, or error 0xc000007b, you need either of these (your choice): 6a. Microsoft Visual C++ 2008 Redistributable Package (4,483,040 bytes) from https://download.microsoft.com/download/5/D/8/5D8C65CB-C849-4025-8E95-C3966CAFD8AE/vcredist_x86.exe Run the installer. Or: 6b. Microsoft Visual C++ 2010 SP1 Redistributable Package MFC Security Update (8,993,774 bytes) from https://download.microsoft.com/download/1/6/5/165255E7-1014-4D0A-B094-B6A430A6BFFC/vcredist_x86.exe Run the installer and choose the "Repair" option. (You need the x86 (32-bit) version even if you have an x64 (64-bit) CPU.) 7. If you get errors about missing OpenAL32.dll, you need OpenAL. You can get this from https://openal.org/downloads/oalinst.zip Extract oalinst.exe anywhere and run it. Links were valid as at January 2023. Support thread is at https://cs.rin.ru/forum/viewtopic.php?f=10&t=72437&e=0 If any links are no longer working, please advise; we have copies of all files archived. These 16 tables have an annoying time-limited bonus ball: Black Belt Clown Devil Riders Earth, Wind, Fire Farfalla Locomotion Magic Castle Mexico '86 Pinball Champ Pool Champion Robot Soccer Kings Spooky Star's Phoenix Time Machine Zankor These 11 games don't have the timed ball: Fire Mountain Futureworld Hot Wheels House of Diamonds Mystic Star Shooting the Rapids Space Shuttle Stargod Strike Winter Sports Zaccaria Pinball for Android ---------------------------- Here is how to run the latest version of Zaccaria Pinball (on Android 4.4+), with all tables. Unfortunately an internet connection is required during play and there is only one ball (man/life) per game. 1. Go to https://d.apkpure.com/b/XAPK/hu.magicpixel.Zaccaria?versionCode=25 which will download Zaccaria Pinball_4.0.3_APKPure.apkx (1,049,698,248 bytes). 2. Rename Zaccaria Pinball_4.0.3_APKPure.apkx as Zaccaria Pinball_4.0.3_APKPure.zip 3. Extract this ZIP. 4. Make a new directory (folder): Internal storage/Android/obb/hu.magicpixel.Zaccaria 5. Move main.25.hu.magicpixel.Zaccaria.obb from wherever it was unZIPped to (typically Downloads), to Internal storage/Android/obb/hu.magicpixel.Zaccaria 6. Install hu.magicpixel.Zaccaria.apk as normal (by clicking on it). -------------------------------------------------------------------------- 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 -------------------------------------------------------------------------- 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 CALM. 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) ---------------------------------- See later in this document for PHUNSY video timings. $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). ROMs ---- There are various versions of the PHUNSY monitor: PMON0400.BIN is 04-0 from 1982 (as used in Ami/WinArcadia) PMON0401.BIN is 04-1 from 1982 PMON0402.BIN is 04-2 from 1983 PMON0403.BIN is 04-3 from 1982 (sic) 03A-PMON0404.BIN and 04A-PMON0404.bin are 04-4 from 1983 Game Help --------- These PHUNSY BINs are compatible with Ami/WinArcadia 29.33: 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. The imagery for the character set is at $3000..$32FF. See the commented disassembly of this program for more details. 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 DASS6800 FORTH-01 FUN-CLOCK GEINTJE GETS-002 Not exactly sure what it is showing. Gets into an infinite output loop after a while. GRAPJE-1..5 KLOK The emulator is too fast, or "game" is too slow, by a 1:120 ratio (0.8%). KRANT L-KRANT 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". MWBAS, 14A-MWBAS-06, 20A-MWBAS-06, MWBAS-M6 are the 24/12/1983 version. 13A-MWBAS-06 is the 23/4/1984 version. MWBAS-07 is the 6/11/2010 version. MWBAS-00, MWBAS-05 are undated. 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 MicroWorldBASIC/ directory These dumps are incompatible, problematic or otherwise unusable: 300-BAUD BASIO-20 It reads from extended I/O port(s) for some reason; possibly non-PHUNSY. Maybe it's eg. the CD2650 extended basic functions. Needs investigation. CASSDISK CDC-I/O It's expecting there to be code at $6003 and there isn't any. 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 I/OPACK This seems to expect a different BIOS. LKRANT MEMTA Flashes INPUT ERR very briefly. Probably needs arguments to be provided. MODEST (both dumps) MWBAS-00 MWBAS-M6 PALASM PCITALK Reads/writes from/to extended I/O port(s) for some reason. PH-CHR PHCSRD This tries to read from the cassette (via the Sense pin). PHEDTR2 (both dumps) This reads from extended I/O ports for some reason. PORT9600 PRPRG (E)PR(OM) Pr(o)g(rammer)? Has PHUNSY monitor 04-P4 (special edition?) in it, and Malotaux programmer, and data for various non-Signetics chips. 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" is really just data; * the program might just have bugs (eg. FORTH-00?); * the program might be a bad dump; * the program is expecting command line arguments (eg. SEE-CHAR); * the program is not intended to produce any output (eg. CLEARMEM); * etc. Dutch English ------------------ Dame Lady Krant Newspaper Liedjes Songs Zooi Mess Mini-PHUNSY ----------- $0000..$07FF: 2 K of RAM (same physical 2K that is at $1800..$1FFF on full) $0800..$0FFF: 2 K of RAM (optional) $1000..$17FF: 2 K of RAM (optional) $1800..$1DFF: 1.5K of RAM (for use by BIOS) $1E00..$1FFF: 0.5K of ROM (Mini-Monitor BIOS) Output is 6 7-segment digits and 7 decimal points, as follows: .1.2.3.4.5.6. The first decimal point is always lit. The second to seventh are lit when IOPORT($13) is 1..6, respectively. Input is: 0 4 8 C D->M Reset 1 5 9 D M->D Halt 2 6 A E G DumpCass 3 7 B F Cl LoadCass which in the emulator is: 1=0 2=4 3=8 NL=C /=D->M *=Reset Q=1 W=5 E=9 7=D 8=M->D 9=Halt A=2 S=6 D=A 4=E 5=G 6=DumpCass Z=3 X=7 C=B 1=F 2=Cl 3=LoadCass Cass=Cassette, Cl=Clear, D=Display, G=Go to, M=Memory Full PHUNSY ----------- $0000..$07FF: 2 K of ROM (PHUNSY BIOS) $0800..$0FFF: 2 K of RAM $1000..$17FF: 2 K of RAM (screen memory) $1800..$1FFF: 2 K of RAM (same physical 2K that is at $0000..$07FF on mini) -------------------------------------------------------------------------- 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 From the games book (translated from German): "At the beginning of all programs is the hardware used. "Basic version" means: CPU, data and address input and output, RAM memory and port module, without EPROM and without keyboard and display unit. In these cases is the switch on the memory card in Position "1" to bring so that the RAM area begins at address $0000. If you have the keyboard and display unit use the switch on the memory card in position "2" standing, so that the EPROM is at the beginning of the addressing area. Then you can use the data and address input and output units from detach from the bus plate. You can but also leave them connected. In the case need the data switch There in position DAFLOT and the Address switch Adr in position ADFLOT standing, otherwise nothing works. the~ These two construction stages are of use to you then if you have a program in Single-STEP or single-CLOCK clock through then the switch must STEP-RUN on the keyboard in Stand in the STEP position so that the Seven segment displays in case of her Activation not be overloaded. The program progress can You then on the data and Observe address input and output." Dice.bin shows the number in binary on the glow LEDs; ie: .......* means 1 was rolled ......*. means 2 was rolled ......** means 3 was rolled .....*.. means 4 was rolled .....*.* means 5 was rolled .....**. means 6 was rolled DiceGame.bin is: for (;;) { *($80D..$812) = 0; *($81B) = 0; for (i = 0; i < 3; i++) { gosub RANDOM; gosub SUMME; gosub CONV; *($80D + i) = r3; // 1st..3rd segments gosub KIN; } } SUMME: *($81C) = r3; *($81B) += r3; *($82B) = 0; *($82C) = r3; gosub HEXDEZ; r3 = *($830); *($801) = r3; gosub SEP; r3 = *($801); gosub CONV; *($811) = r3; // 5th segment r3 = *($802); gosub CONV; *($812) = R3; // 6th segment r3 = *($81C); return; RANDOM: r0 = PSU & Sense; NEW: r3 = 0; LOOP: r3++; if (r3 == 7) goto NEW; r0 = PSU & Sense; compare r0 against *($815); if (==) goto LOOP; return; DecCalculation.pgm is: for (;;) { gosub GDEZ; *($827) = r3; *($828) = r2; do { gosub KIN; r3 = *($800); REGS = r3; } while (r3 <= $0F || r3 >= $50); gosub GDEZ; *($829) = r3; *($82A) = r2; r3 = REGS; switch (r3) { case '-': PSL |= COM ; gosub ADDSUB; acase '+': PSL &= ~(COM); gosub ADDSUB; acase '*': gosub MULT; acase '/': gosub DIV; adefault: r3 = *($812) = '3'; // 6th digit goto ERROR; } gosub HEXD; gosub KIN; } GDEZ: do { gosub CDIS; gosub KIN; PSL &= ~(WC); r3 = *($800); if (r3 == '+') { *($8FF) = '+'; r3 = *($80D) = 'P'; // 1st digit } elif (r3 == '-') { *($8FF) = '-'; r3 = *($80D) = '-'; // 1st digit } } while (*($800) != '+' && *($800) != '-'); r2 = *($82D) = 5; gosub LODAT; r3 = $20; if (*($8FF) != '-') { *($81A) |= $90; } *($82E..$830) = *($81A..$81C); gosub DEZHEX; r3 = *($82B); r2 = *($82C); return; LottoNumbers.pgm is: gosub CDIS; // clear display *(LOTTO..LOTTO+14) = 0; // or, *($8F0..$8FE) = 0; RSLT = 0; for (*($8F7) = 1; *($8F7) <= 7; *($8F7)++) { *(LOTTO + *($8F7)) = RANDOM(); *($82C) = *($8F7); gosub HEXDEZ; r3 = *($830); DATA2 = r3; gosub SEP; *($812) = CONV(DATA3); // 6th digit *($811) = CONV(DATA2); // 5th digit *($80D) = CONV(*($8F7)); // 1st digit gosub KIN; } goto START; RANDOM: WBUF = PSU & Sense; for (r3 = 1; r3 <= 49; r3++) { if ((PSU & Sense) != WBUF) { r0 = r3; for (r2 = 1; r2 <= 7; r2++) { if (r0 == *(LOTTO + r2)) { goto RANDOM; } } } } return; // result is in r0 and also in r3 $830 is the number that has just been drawn (1..49). $8F1..$8F6 are the drawn numbers. $8F7 is the sequence number (1..3). The randomizer constantly cycles through 1..49 and stops as soon as the Sense bit changes. Morse Code Practice: Data table is as follows: A $0240 %.-000000 B $0480 %-...0000 C $04A0 %-.-.0000 D $0380 %-..00000 E $0100 %.0000000 : : : Z $04C0 %--..0000 0 $05F8 %-----000 1 $0578 %.----000 : : : 9 $05F0 %----.000 = $0588 %-...-000 ; $06A8 %-.-.-.00 , $06CC %--..--00 - $0684 %-....-00 / $0590 %-..-.000 : $06E0 %---...00 ? $0630 %..--..00 . $0654 %.-.-.-00 $05A8 %-.-.-000 Starting signal (/KA aka /CT) + $0550 %.-.-.000 New message follows (/RN aka /AR) -------------------------------------------------------------------------- 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 Tables ------------------ 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 MIKIT ? ? For NTSC AY-3-8500-1 Pong machines: Rows 0.. 41 are vertical back porch ( 42 rows) Rows 42..233 are main display area (192 rows) Rows 234..257 are vertical front porch ( 24 rows) Rows 258..261 are vertical retrace ( 4 rows) = 262 rows Main display area: 73*192 Entire display area: 128*262 For PAL AY-3-8550 Pong machines: Rows 0.. 43 are vertical back porch ( 44 rows) Rows 44..275 are main display area (232 rows) Rows 276..305 are vertical front porch ( 30 rows) Rows 306..311 are vertical retrace ( 6 rows) = 312 rows Main display area: 73*232 Entire display area: 128*312 For both Pong machines (NTSC and PAL): Columns 0.. 26 are horizontal back porch (27 columns) Columns 27.. 99 are main display area (73 columns) Columns 100..115 are horizontal front porch (16 columns) Columns 116..127 are horizontal retrace (12 columns) = 128 columns Pong: 128 pixels wide in 64 usecs: 128/64 = 2 pixels per usec 64/128 = 500 nsecs per pixel Arcadia/Interton/Elektor (2621 (PAL) USG-based machines): 227 pixels wide in 64 usecs (according to datasheet) 227/64 = 3.546875 pixels per usec 64/227 = 281.938 nsecs per pixel (datasheet says 282 nsecs) Arcadia (2622 (NTSC) USG-based machines): 227 pixels wide in 63.4158810686833 usecs: because 262 rows per frame * 60.1867202475031 frames per second = 15,768.9207058568 rows per second and 1 second / 15,768.9207058568 rows per second = 63.4158810686833 usecs per row Thus 227 pixels per row / 63.4158810686833 usecs per row = 3.579545 pixels per usec * 1,000,000 usecs per second = 3,579,545 pixels per second and 63.4158810686833 usecs per row / 227 pixels per row = 279.3695114840015 ns per pixel Central Data 2650: 904 pixels wide in 64 usecs: 904/64 = 14.125 pixels per usec 64/904 = 70.796 nsecs per pixel Therefore: a Pong pixel is as wide as 1.773438 PAL USG pixels (227 / 128). a Pong pixel is as wide as 7.0625 CD2650 pixels (904 / 128). a PAL USG pixel is as wide as 0.563877 Pong pixels (128 / 227). a PAL 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 PAL USG pixels (227 / 904). The following calculations are for WinArcadia (V29.33) aspect ratios, for 2621/2622 USG-based machines (Arcadia/Interton/Elektor): With blanking areas off: For NTSC: When (vertical) "stretch ntsc?" is off: there are 164 visible X-pixels there are 226 visible Y-pixels this shape is actually 164 / 226 = 0.725664:1 = 2.176991:3 rather than 4:3 so, 226 / 164 / 3 * 4 = 1.837398374 ie. pixels should have a 1.837398374:1 aspect ratio. When (vertical) "stretch ntsc?" is on: there are 164 visible X-pixels there are 226 / 5 * 6 = 271.2 visible Y-pixels this shape is actually 164 / 271.2 = 0.604720:1 = 1.814159:3 rather than 4:3 so, 271.2 / 164 / 3 * 4 = 2.204878049 ie. pixels should have a 2.204878049:1 aspect ratio. For PAL: there are 164 visible X-pixels there are 269 visible Y-pixels this shape is actually 164 / 269 = 0.609665:1 = 1.828996:3 rather than 4:3 so, 269 / 164 / 3 * 4 = 2.186992 ie. pixels should have a 2.186992:1 aspect ratio. With blanking areas on (but calculating for non-blanking areas): For NTSC: When (vertical) "stretch ntsc?" is off: there are 188 X-pixels (non-hblank) (+ 39 hblank = 227) there are 242 Y-pixels (non-vblank) (+ 20 vblank = 262) this shape is actually 188 / 242 = 0.77686:1 = 2.330579:3 rather than 4:3 so, 242 / 188 / 3 * 4 = 1.716312 ie. pixels should have a 1.716312:1 aspect ratio (1.714:1 according to some sites). So instead of doubling the width, it should be about 12/7ths. When (vertical) "stretch ntsc?" is on: there are 188 X-pixels there are 242 / 5 * 6 = 290.4 Y-pixels this shape is actually 188 / 290.4 = 0.64738:1 = 1.942149:3 rather than 4:3 so, 290.4 / 188 / 3 * 4 = 2.059574 ie. pixels should have a 2.059574:1 aspect ratio. So instead of doubling the width, it should be about 72/35ths (12*6=72, 7*5=35). For PAL: there are 184 horizontal pixels (non-hblank) (+ 43 hblank = 227) there are 269 vertical rasters (non-vblank) (+ 43 vblank = 312) this shape is actually 184 / 269 = 0.684015:1 = 2.052045:3 rather than 4:3 so, 269 / 184 / 3 * 4 = 1.949275 ie. pixels should have a 1.949275:1 aspect ratio. So instead of doubling the width, it should be about 39/20ths. Guest screen shape: In wide NTSC mode, with blanking areas off, and (vertical) stretching off: guest screen is 164 * 2 = 328 X-pixels across by 226 Y-pixels down. that's actually 328 / 226 = 1.451327:1 or 4.353982:3 instead of 4:3 In wide NTSC mode, with blanking areas off, and (vertical) stretching on: guest screen is 164 * 2 = 328 X-pixels across by 271.2 Y-pixels down. that's actually 328 / 271.2 = 1.20944 :1 or 3.628319:3 instead of 4:3 In wide PAL mode, with blanking areas off: guest screen is 164 * 2 = 328 X-pixels across by 269 Y-pixels down. that's actually 328 / 269 = 1.219331:1 or 3.657993:3 instead of 4:3 In wide NTSC mode, with blanking areas on, and (vertical) stretching off: guest screen is 188 * 2 = 376 X-pixels across by 242 Y-pixels down. that's actually 376 / 242 = 1.553719:1 or 4.661157:3 instead of 4:3 In wide NTSC mode, with blanking areas on, and (vertical) stretching on: guest screen is 188 * 2 = 376 X-pixels across by 290.4 Y-pixels down. that's actually 376 / 290.4 = 1.294766:1 or 3.884298:3 instead of 4:3 In wide PAL mode, with blanking areas on: guest screen is 184 * 2 = 368 X-pixels across by 269 Y-pixels down. that's actually 328 / 269 = 1.36803 :1 or 4.104089:3 instead of 4:3 DG640 (BINBUG) timing is: Horizontally: 12 MHz master crystal draws 12 million pixels per second. 83.3' nsecs per pixel. 12 pixels are drawn per usec. 768 pixels are drawn per 64 usec rastline. 5 usecs (60 pixels) of horizontal sync per 64 usec rastline. 0.. 59: hsync ( 60 pixels) 60..125: left margin ( 66 pixels) 126..701: main area (576 pixels) 702..767: right margin ( 66 pixels) Or: 0..575: main area (576 pixels) 576..641: right margin ( 66 pixels) 642..701: hsync ( 60 pixels) 702..767: left margin ( 66 pixels) Vertically: 64 usecs per rastline. 312.5 rastlines per frame. 20 msecs per frame. 50 frames per second. 300 usecs of vertical sync (/ 64us = 4.6875 scanlines) per 20 ms frame 3600 pixels of vertical sync (4 scanlines with 528 pixels remainder) 1,000,000 / 64 usecs = 15,625 scanlines per second / 50 fps = 312.5 scanlines per frame. 12 pixels per CPU cycle. 64 CPU cycles per scanline. 20,000 CPU cycles per frame. 1,000,000 CPU cycles per second. Unknown: Positioning of syncs (and colourburst, if one is present) (we are assuming the syncs are centred within the porches for now) PHUNSY timing is: Each pixel takes 0.125 usecs, ie. pixels = usecs * 8. Horizontally: 3.25 usecs * 8 pixels per usec = 26 pixels ( 0.. 25) of front porch 4 usecs * 8 pixels per usec = 32 pixels ( 26.. 57) of horizontal sync 8.75 usecs * 8 pixels per usec = 70 pixels ( 58..127) of back porch: 1 usecs * 8 pixels per usec = 8 pixels ( 58.. 65) of pre-colourburst 2 usecs * 8 pixels per usec = 16 pixels ( 66.. 81) of colourburst 5.75 usecs * 8 pixels per usec = 46 pixels ( 82..127) of post-colourburst 16 usecs * 8 pixels per usec = 128 pixels ( 0..127) of horizontal blank 48 usecs * 8 pixels per usec = 384 pixels (128..512) of usable screen = 64 usecs * 8 pixels per usec = 512 pixels ( 0..512) total Vertically: 0..255: usable screen (256 lines) 256..268: front porch ( 13 lines) 269..272: vertical sync ( 4 lines) 273..312: back porch ( 40 lines) = 313 lines (ie. always long PAL frames) Arcadia, Interton, Elektor have 4 CPU cycles per pixel: NTSC: 227*262 *60= 3,568,440 pixels per second / 4 = 892,110 Hz CPU. PAL: 227*312 *50= 3,541,200 pixels per second / 4 = 885,300 Hz CPU. PHUNSY has 8 CPU cycles per pixel: 512*313 *50= 8,012,800 pixels per second / 8 = 1,001,600 Hz CPU. BINBUG (DG640), CD2650 have 12 CPU cycles per pixel: BINBUG: 768*312.5*50=12,000,000 pixels per second / 12 = 1,000,000 Hz CPU. CD2650: 904*264 *60=14,319,360 pixels per second / 12 = 1,193,280 Hz CPU. ------------------------------------------------------------------------- Pong ---- These are not really Signetics-based machines. !8500 PAL mono, 6 games (1-axis ) (4 pong + 2 shooting) !8500-1 NTSC mono, 6 games (1-axis ) (4 pong + 2 shooting) -8510 PAL colour, 4 games (1-axis?) (4 pong) -8512 PAL colour, 6 games (1-axis?) (4 pong + 2 shooting) !8515 NTSC colour adapter for 8500-1 or 8550-1 !8550 PAL mono, 6 games (2-axis ) (4 pong + 2 shooting) !8550-1 NTSC mono, 6 games (2-axis ) (4 pong + 2 shooting) -8600 PAL mono, 8 games (2-axis ) (8 pong) -8600-1 NTSC mono, 8 games (2-axis ) (8 pong) !8610 PAL mono, 10 games (2-axis ) (8 pong + 2 shooting) !8610-1 NTSC mono, 10 games (2-axis ) (8 pong + 2 shooting) !8615 NTSC colour adapter for 8610-1 -8650 Advanced controls and options when used with AY-3-8600 -8650-1 Advanced controls and options when used with AY-3-8600-1 pipbug: "ETI Circuits No. 3" has "VDU bleeper for ETI 630/631/632", p. 30. -8601..8607: Submarine games, etc. -8700+: Tank battle, motorcycle games, etc. ! = got datasheet - = missing datasheet Articles list (obviously incomplete!): AY-3-8500: "ETI Circuits No. 3" has "Proper identification for TV game chip", p. 38. -------------------------------------------------------------------------- Signetics TWIN minicomputer (1976) ---------------------------------- Master CPU's memory map: $0000..$00FF: 256 bytes of bootstrap ROM (to boot SDOS from disk) $0100..$3FFF: 15.75K of master RAM (for SDOS), including: $1500..$187F: overlay area 1 $1880..$1BFF: overlay area 2 $3FFE..$3FFF: DOS version number (except for very early versions) $4000..$7FFF: 16K window into slave RAM Slave CPU's memory map: $0000..$3FFF: 16K of slave RAM $4000..$7FFF: unmapped (on unexpanded system) Resident (non-overlay) part of SDOS contains: job dispatcher SVC processor device handlers GO, LOAD, SYSTEM, XEQ commands Master CPU: Runs DOS (eg. SDOS, TOS, etc.). Handles all the I/O (keyboard, CRT, floppies, etc.). Debugger is both hardware and software; its software presumably runs on the master CPU. To switch from master to slave, master just executes a HALT instruction. Presumably the slave just resumes from where it left off. Master has 16 interrupt priority levels. Interrupt handlers start at $0000 of master RAM and go up by 2. Slave CPU: All it can do is run programs in its own memory, and ask the master to do work for it (eg. I/O) via service requests (and, of course, can access prototype hardware, depending on which mode is in use). User programs run on it (including Text Editor & Assembler). To switch from slave to master, any master interrupt (but not slave interrupt) will do it. Eg. timer/keyboard/etc. interrupts and Service Requests. Slave has 8 interrupt priority levels. Interrupt handlers start at $0000 of slave RAM and go up by 2 per entry. Resolved ambiguities: lower priority numbers do represent "higher" (more important) priorities. in MOD headers, the destination base address specified by the Set Base command start is always as viewed from the master CPU, even when loading into slave RAM (as the loading as always done by the master CPU). interrupts priorities 1 and 3 are used for master and slave RAM parity errors, respectively. the drive motor on 8" floppy drives runs on 230V AC and is always on. The drive is kept spinning at all times. The head is unloaded when idle, but the diskette is always spinning within its sleeve. Unresolved ambiguities: do we really handle empty drives, out-of-bounds tracks/sectors etc. in the correct way? binbug just ignores the command, we return 0s? Is there a status flag that is relevant? under exactly what circumstances should we generate floppy interrupts? eg. empty drive? track/sector out of bounds? which operations cause an interrupt? All of them? if two interrupts happen simultaneously, does the less important one just get pended for after the more important one finishes or does the less important one get skipped entirely? if the master's II bit was clear before the HALT, can the master ever be awoken? "The debug utility programs are loaded into the top-most 256 bytes of slave memory whenever the system is powered on or the RESET switch is toggled." That isn't happening. "Interrupt disable bit" of "slave command byte" (extended I/O port $E0) might only affect the slave CPU (rather than both CPUs)? We're not currently emulating it at all, even for master CPU. Not sure either whether it is active high or low. in slave mode, when eg. a keystroke or SVC occurs, it switches to the master to handle the interrupt. Afterwards, does the hardware automatically switch back to the slave or not? We assume not. what does the blank key at the top right of the keyboard do? if the guest hasn't read the keyboard port yet, and the user provides more input, what should be done? Currently we just ignore further input (including not generating any interrupts for those keystrokes), apart from just queueing it for later. But that may not be correct. Emulator incompatibilities: apparently Esc should abort LDIR command, but doesn't for us. Maybe it is supposed to raise a special interrupt or similar? the debug trace routine should be loaded into $3F80..$3FFF of slave by eg. EDIT or DEBUG commands but seems not to be). Errata: On page 1-17 of the Tektronix 8002A Service Manual, ITD should be OTD. Thus, to read a sector the steps are: 1. Go RST mode. Check disk status. 2. Go SIO mode. Check disk status. 3. Go OTD mode. Send Normal Read command. 4. Go OTD mode. Send drive number. 5. Go OTD mode. Send sector number. 6. Go OTD mode. Send track number. 7. Go IND mode. Read 1st byte. : : : 134. Go IND mode. Read 128th byte. 135. Go RST mode. Check disk status. SDOS apparently supports these formats: * "Hex" - Appendix C (AOF) * "SMS" - Appendix D (for PROM programmer) * "MOD" - "Binary load module" * "Com" - "Command file" (ie. batch/script file) Here are the contents of the various "bootblocks" (tracks 1..4) of the disks: EXOS: HM19 HM20 HM21 HM22 SDOS 2.0: van_erp HM02 HM03 HM04 HM06 HM07 HM13 HM14 HM16 HM17 HM18 HM23 HM24 HM25 SDOS 4.0: HM01 HM10 SDOS 4.2: config42 HM05 HM15 system42 tss40 TOS 1.0: TWINBoot These have "SDOS" in the expected place but it is all zeroes: cmd_src_5b HM08 HM09 HM11 HM12 margriet1 sdos42_link TWINData These have other files on tracks 1..4: sdos42_cmd_src_1..5 pas_src prom_mod9 rasm sdos42_hwa sdos42_macro_src sdos42_opt_drv sdos42_res_link sdos42_res_master sdos42_util These DOSes are currently compatible with Ami/WinArcadia 32.2: SDOS 2.0 SDOS 4.2 TOS 1.0 - asks for the current date and time on boot. If those are entered, the timer is enabled. UDOS 1.6 These DOSes are currently incompatible: TEKDOS 1.9 - hangs after loading TEKDOS 2.2 - hangs after loading TEKDOS 3.1 - hangs after loading TEKDOS 3.2 - hangs after loading I/O Ports --------- These tables are not yet complete. For reads: Port Name Description ------- ---- ------------ $E8 Data Byte $E9 ? Status Byte bits 7..5: unused bit 4 : parity error bit 3 : framing error bit 2 : data overrun bit 1 : transmit buffer empty bit 0 : data available $EA "Controller Flag Byte" $EB "Disk Status Byte" For writes: Port Name Description ------- ---- ------------ $D0 PCPT High Speed Paper Tape (HSPT) control port $D1 PDPT High Speed Paper Tape (HSPT) data port $E8 ? CRT/TTY output $E9 ? bits 7..3: unused bit 2 : enable TTY interrupts bit 1 : parity select bit 0: : TTY paper tape reader $EA ? Control Device (floppy drive and printer) $EB ? Data Device (floppy drive and printer) $EC ? bit 0 clear = interval timer disabled bit 0 set = interval timer enabled $ED ? "Master Memory Protect" $EE BSPT Common memory bank select: $00 = map slave RAM $0000..$3FFF to master RAM $4000..$7FFF $01 = map slave RAM $4000..$7FFF to master RAM $4000..$7FFF $02 = map slave RAM $8000..$BFFF to master RAM $4000..$7FFF $03 = map slave RAM $C000..$FFFF to master RAM $4000..$7FFF Centronics Model 306C printer: 10 cpi horizontally (in normal mode), 6 cpi vertically. A full row of output (80 characters) is 8" wide (plus margins). Supported paper widths are 4"..9.5". We support 9.5". Vertical standard is 11", which gives 66 rows per page. Total paper size: 665*770 pixels for 9.5"*11" at 70 pixels per inch. Sprocket diameter is 5/32". At 70 pixels per inch that is 10.9375 pixels. -------------------------------------------------------------------------- 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 The maximum possible speed of an S2650 or S2650A is 1250 kHz. Because the minimum long /slow cycle time is 2.4 us, therefore the minimum short/fast cycle time is 2.4 us / 3 = 0.8 us, and 1,000,000 / 0.8 us = 1,250,000 Hz. The maximum possible speed of an S2650A-1 is 2000 kHz. Because the minimum long /slow cycle time is 1.5 us, therefore the minimum short/fast cycle time is 1.5 us / 3 = 0.5 us, and 1,000,000 / 0.5 us = 2,000,000 Hz. -------------------------------------------------------------------------- Project & Component Numbers --------------------------- 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-644 is a modem (ETI AU Oct 1982) (also in ETI Computer Projects #1) *ETI-644A is a revision for the ETI-644 modem (ETI Computer Projects #1) ETI-645 is a turtle robot ("Tasman Turtle") (ETI AU Apr-Jun 1982) (compatible with ETI-685 as mentioned in ETI Aug 1982, p. 91) -ETI-646 is a hand controller for the turtle robot (ETI AU Jul 1982) *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-656 is an EPROM debugger (ETI Computer Projects #1) *ETI-658 is an RS-232 breakout box (ETI Computer Projects #1) *ETI-660 is a 1802 CPU-based machine (for Chip-8) *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-671 is a Microbee parallel printer interface (ETI Computer Projects #1) *ETI-672 is a Microbee teletype printer interface (ETI Computer Projects #1) *ETI-673 is a Microbee multi-PROM interface (ETI Computer Projects #1) *ETI-675 is a Microbee serial-parallel interface (ETI Computer Projects #1) *ETI-676 is a Microbee RS-232 interface (ETI Computer Projects #1) *ETI-678 is a Microbee ROM reader (ETI Computer Projects #1) *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) (can use PIPBUG, BINBUG or SBCBUG) Compatible with: ETI-635 power supply ETI-636 S-100 motherboard ETI-640 VDU ETI-642 16K S-100 RAM card (presumably) ETI-645 turtle robot ETI-670 ASCII keyboard ETI-681 PCG ETI-682 S-100 PROM board ETI-686 PPI-based EPROM programmer The cassette interface (promised in ETI AU Dec 1981, p. 104) and real-time clock/calendar (promised in ETI AU Mar 1982, p. 95) were never published. ETI-686 is a PPI-based EPROM Programmer for ETI-685 (and others) (ETI AU Oct 1982) (also in ETI Computer Projects #1) *ETI-690 is the Little Big Board computer (ETI Computer Projects #1) 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) MW850 is an S-100 motherboard (from MicroWorld) 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 fully encoded ASCII keyboard (Elektor Nov 1978) and a Number Pad for KB04 (ETI) KB06 is a Cursor Control for KB04 (ETI) KB10 is spare key switches for KB04 (ETI) 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 Various component numbers and a quick summary thereof: Code Manufacturer Description Used in --------------------------------------------------------------------------- 2102 is a 1024-bit RAM ? 2112 is a 128-byte SRAM (Static Random Access Memory) ? 2114 is a Fairchild 512-byte SRAM (Static Random Access Memory) Arcadia [U11,U12], Interton 2332 is a Commodore 4K PROM (Programmable Read-Only Memory) Arcadia 2504 is a Signetics 1024-bit DSR (Dynamic Shift Register) ? 2513 is a Signetics Character Generator ETI-560 2519 is a Signetics 40-bit SSR (Static Shift Register) ? 2602 is a Signetics 1024*1-bit SRAM ? 2606 is a Signetics 256*4-bit SRAM ? 2608 is a Signetics 1K PROM (Programmable Read-Only Memory) PIPBUG 2616 is a Intel/Mullard 2K PROM (Programmable Read-Only Memory) Interton, Elektor 2632 is a 4K PROM (Programmable Read-Only Memory) ? 2621 is a Signetics PAL USG (Universal Sync Generator) Arcadia, Interton, Elektor 2622 is a Signetics NTSC USG (Universal Sync Generator) Arcadia [U7] 2636 is a Signetics PVI (Programmable Video Interface) Interton, Elektor 2637 is a Signetics UVI (Universal Video Interface) Arcadia [U9] 2650 is a Signetics CPU (Central Processing Unit) All [U10] 2650-P-02 is a Synertek chip which is *not* 2650-compatible None 2651 is a Signetics PCI (Programmable Communications Interface) ? 2652 is a Signetics Multi-Protocol Communications Circuit (incl. Synchronous Data Link Control (SDLC)) 2653 is a Signetics Polynomial Generator/Checker ? 2655 is a Signetics Programmable Peripheral Interface ? 2656 is a Signetics SMI (System Memory Interface) ? 2657 is a Signetics Direct Memory Access ? 2661 is a Signetics Enhanced Programmable Communication Interface (EPCI) 2670 is a Signetics Display Character and Graphics Generator ? 2671 is a Signetics Programmable Keyboard and Communications Controller 2672 is a Signetics Programmable Video Timing Controller ? 2673 is a Signetics Video Attributes Controller ? 2681 is a Signetics DUART (Dual Async. Receiver/Transmitter) ? 2708 1K EPROM ? 2716 2K EPROM Elektor 2732 4K EPROM Elektor 4066 Quad analog switches Arcadia [U4] 4069 Hex inverter Arcadia [U6] 7400 Quad 2-input NAND gate Arcadia [U1] 7404 Hex inverter Arcadia [U2] 7486 Quad 2-input XOR gate Arcadia [U3,U5] 74145 4-bit D flp-flp w/ cmplmntry outputs & rst Arcadia [U14] (keypad inputs) 74258 Quad 2:1 multiplexer (3-state) Arcadia [U8] (keypad inputs) 74S471 256-byte PROM Dolphin 74LS378 6-bit clock enable Interton, expanded Elektor [IC1] 7805 +5V regulator Arcadia [U13] 82S115 is a Signetics 512*8-bit PROM CD2650 (eg. IPL 1.1 PROM is one of these) 82S123 is a Signetics 32*8-bit PROM ? 82S129 is a Signetics 512*8-bit PROM ? AY-3-8900 is a GI Standard Television Interface Chip ? AY-3-8910 is a GI PSG (Programmable Sound Generator) expanded Elektor AY-5-1013 is a UART Elekterminal AY-5-2376 is a GI keyboard encoder ETI-670 & Elektor KB05 CRT-96364 is an SMC CRT (Cathode Ray Tube) Controller PIPBUG?/BINBUG? EF9364 is a Thomson CRT (Cathode Ray Tube) Controller Selbstbaucomputer MCM6570 is a Motorola Character Generator PIPBUG?/BINBUG? SAA5050 is a Signetics Teletext Character Generator Malzak SN76477 is a TI sound effect generator Malzak, Laser Battle, Lazarian TEA1002 is a Mullard PAL Colour Encoder & Video Summer Interton TMS3615 is a TI OMTS (Octave Multiple Tone Synthesizer) Laser Battle, Lazarian UM1285-8 is an Astec VHF modulator Arcadia Filename Conventions -------------------- ! indicates a modified dump (eg. enhanced or compatibility patched). - indicates a known bad dump. -------------------------------------------------------------------------- BIOS Command Quick Reference ---------------------------- PIPBUG 1 BINBUG CD2650 SI50 PHUNSY TVGC ------------------------------------------ Inspect memory A A A MEM I MEM Alter memory A A A MEM : MEM Set breakpoint B B B BKPT BP1/2 Clear breakpoint C C C BKPT BP1/2 Dump memory to tape D D D WCAS W WCAS Execute program G G E RUN G START Load memory from tape L L L RCAS R RCAS See & alter registers S S I REG REG Cold start DOS ($6800) K Warm start DOS (*$6803) W Run tape recorder R Verify tape V Step STEP Adjust cassette REG A Fast patch REG F : See & alter program counter REG C PC Reset RST Move (copy) memory M Show error message S Show monitor ID X Issue MDCR command T Q bank select/execute Q U bank select/execute U Display selected banks = Verify (compare) memory V Preset (fill) memory P Still to do: PIPBUG 2 HYBUG GBUG+EDIT5800 MIKEBUG MYBUG Selbstbaucomputer MIKIT RYTMON Chaos 2 POPMON etc. Floppy Drive Comparison ----------------------- No. Size Tracks Sectors Sector size Sides Capacity Track Size Format(s) Blocks Dir Files DOS Sectors --- ----- ------ ------- ----------- ----- --------- ---------- --------- ------ --- ----- ----------- BINBUG 0+ 5.25" 40 * 10 * 256b * 1 = 100 K 2.5 K RAW 400 10 100 T0 S1..3 TWIN 2 8 " 77 * 32 * 128b * 1 = 308 K 4 K IMG, TWIN 308 4 78 T1..4 CD2650 0-4 5.25" 35 * 9 * 256B * 1 = 78.75K 2.25K RAW 315 18 64 T2..4 .RAW files are raw disk files of 100K (102,400 bytes) (BINBUG) or 78.75K (80,640 bytes) CD2650), lacking sector and block numbers. .IMG files are raw disk files of 308K (315,392 bytes), lacking sector and block numbers. .TWIN files are disk files of 320,320 bytes, the same as .IMG except that each 128-byte sector is prepended with the track and sector numbers (thus becoming 130 bytes per sector). Blocks: total number of blocks (clusters) on disk (including directory table, etc.). Dir: number of blocks used for directory table. Files: maximum number of files storable. 2650 CPU Editions ----------------- This list is not exhaustive. Philips MAB2650A 1.25 MHz 197x Signetics 2650 1.25 MHz 1975 Signetics 2650-1 2 MHz <= 1976 Signetics 2650A 1.25 MHz 1977 Signetics 2650AI 1.25 MHz ? Used in Malzak Signetics 2650A-1 2 MHz 1977 Signetics 2650B 1.25 MHz 1977 Signetics 2650B-1 2 MHz 1977? Synertek 2650-P-02 is not a member of this CPU family. END OF DOCUMENT-----------------------------------------------------------