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