tranZPUter SW-700 (v1) — User Manual

tranZPUter SW-700 v1 User Manual

The tranZPUter SW-700 is a Z80 enhancement board for the Sharp MZ-700. It lifts the original Z80 onto a daughter card and combines the functions of the tranZPUter SW and Video Module v2.0 onto a single board, adding a K64F ARM Cortex-M4 I/O processor, a MAX7000A CPLD, and an Altera Cyclone FPGA. The result upgrades the MZ-700 with 512 KB of additional static RAM, selectable CPU clock rates, soft CPU cores (T80 and ZPU Evolution) in the FPGA, hardware emulation of other Sharp MZ models, enhanced VGA video output, and an SD card filing system — while keeping the machine completely original on power-up until a feature is explicitly enabled.

The firmware component is TZFS (tranZPUter Filing System), loaded automatically by the K64F from SD card at every boot. TZFS adds SD card filing, CP/M 2.2 boot, a built-in Z80 assembler and disassembler, hardware emulation commands, soft CPU switching, VGA output control, and more than 40 new monitor commands — all while keeping the familiar SA-1510 * prompt and every original command intact.

This manual covers everything needed to install and use the tranZPUter SW-700 (v1.2 / v1.3 hardware, original firmware) day-to-day. For hardware architecture and build system details see the TZFS Technical Guide. For source code internals see the TZFS Developer's Guide.

V1 / Original Firmware Notice
This guide covers the original (v1) firmware release of the tranZPUter SW-700, targeting the Sharp MZ-700 only. The video control registers in this version are at I/O ports 0xF8–0xFD.

If your board has been updated to the current firmware (which adds MZ-2000 support and reassigns I/O ports to 0xA8–0xAD), this guide's register addresses will not match. Use the current version User Manual instead. The TZFS H command or the displayed TZFS version number will help identify which firmware is installed.

Supported Hardware

This guide covers two board revisions. Both carry the same K64F ARM Cortex-M4 I/O processor, MAX7000A CPLD, and Altera Cyclone FPGA. The only difference is the FPGA device and its package:

Board Version	FPGA Device	Logic Elements	Block RAM	Package	Notes
v1.2	Altera Cyclone III EP3C25	25K LE	76 KB	144-pin TQFP	First production release. Lower-cost PCB.
v1.3	Altera Cyclone IV EP4CE75	75K LE	~340 KB	484-pin BGA	Recommended. Higher-resolution graphics, more soft-CPU resources.

Both versions are electrically interchangeable from a firmware perspective — the same TZFS binary and the same K64F firmware run on either board. v1.2 is cheaper to manufacture; v1.3 is the recommended choice for new builds due to its larger FPGA. Both versions maintain their own branches in the git repository.

Supported host machine (V1 firmware): Sharp MZ-700 only. MZ-2000 support was not present in the original firmware. If you require MZ-2000 support, use the current firmware and the current version User Manual.

What You Need

To install and use the tranZPUter SW-700 you will need:

A tranZPUter SW-700 v1.2 or v1.3 board, fully assembled and tested.

A Sharp MZ-700 host machine in working condition.

A micro SD card (FAT-formatted, class 10 recommended, up to 32 GB).

The TZFS firmware binary and SD card file collection from the Gitea releases/ directory.

A JTAG programmer compatible with Altera devices (USB Blaster or clone) — required to program the CPLD and FPGA serial configuration device. Only needed once at initial setup, or when updating FPGA/CPLD logic.

A JTAG/SWD programmer (OpenSDA compatible, such as a Freescale FRDM-K64F board) or the optional PJRC MCU — required to flash the K64F firmware. Only needed once at initial setup.

Altera Quartus II (version 13.1 for Cyclone III / IV) — required only if building FPGA logic from source.

Installation

The tranZPUter SW-700 installs into the Sharp MZ-700 by removing the original Z80 from its socket and inserting the board in its place. The board's pass-through Z80 socket carries the original CPU. A second cable from the board connects to the MZ-700 modulator connector to allow the FPGA to intercept and optionally replace the video signal.

Installation steps:

Power off the Sharp MZ-700 and remove the case lid.

Locate the Z80 CPU socket on the MZ-700 mainboard.

Carefully extract the original Z80 CPU using a chip extractor or flat-blade tool. Take care not to bend the pins. Set the original CPU aside safely — it will be reinstalled into the tranZPUter board's pass-through socket.

Insert the original Z80 into the tranZPUter board's pass-through Z80 socket on the underside of the board. Ensure the notch orientation matches.

Insert the tranZPUter board into the Z80 socket on the MZ-700 mainboard. The board plugs in with the K64F and CPLD facing upward. Ensure all 40 pins are fully seated.

Connect the video cable from the tranZPUter board to the MZ-700 modulator connector. This allows the FPGA to intercept the video signal for enhanced output.

Insert the prepared micro SD card into the tranZPUter board's SD card slot.

Refit the case lid and reconnect all cables.

The board is designed so that on power-up with no features enabled, the MZ-700 operates completely as original. The K64F initialises silently, loads TZFS from SD card into the tranZPUter's 512 KB SRAM, and releases the Z80 from reset. No user intervention is required.

Programming the FPGA and CPLD

The CPLD (MAX7000A) and the FPGA serial configuration device (EPCS16 for v1.2, EPCS64 for v1.3) must be programmed before the board is used for the first time. Pre-built JTAG programming files are available in the releases/ directory of the Gitea repository. Programming requires a USB Blaster or compatible interface connected to the board's JTAG header.

JTAG Chain

The JTAG chain on the tranZPUter SW-700 follows Altera best practice: the highest-voltage device (CPLD, 5V-tolerant) is first in the chain, daisy-chained to the FPGA. Both devices are programmed through the single JTAG header using Altera Quartus II Programmer.

Programming the CPLD

Program the MAX7000A CPLD with the .pof file from the release:

# Using Quartus II Programmer (command line):
quartus_pgm -c "USB-Blaster" -m JTAG -o "p;tranZPUter_SW_700_CPLD.pof@1"

Programming the FPGA Configuration Device

The FPGA is configured from the on-board serial configuration device (EPCS16/EPCS64) at every power-up or when the CONFIG switch is pressed (v1.2 only; removed in v1.3). Program the configuration device with the .jic file from the release. This uses the Cyclone FPGA as a programming proxy via the AS (Active Serial) programming mode:

# Program EPCS device via FPGA (AS mode in Quartus Programmer):
quartus_pgm -c "USB-Blaster" -m AS -o "p;tranZPUter_SW_700_FPGA.jic@2"

After programming the EPCS device, power-cycle the board (or press the CONFIG switch on v1.2) to load the new FPGA bitstream from the configuration device.

Flashing the K64F Firmware

The K64F ARM Cortex-M4 I/O processor requires its own firmware (zOS and the TZFS service layer). Pre-built K64F firmware binaries are provided in the releases/ directory. Two programming methods are supported depending on the solder jumper configuration of the board:

Method 1 — PJRC MCU (optional factory-fitted)

If the optional PJRC bootstrap MCU is fitted and solder jumpers JP1–JP5 are configured pads 1-2, the K64F can be programmed via a USB cable connected to the board's USB port. Connect the board to a PC, wait for the mass-storage drive to appear, and copy the firmware .hex file to the drive:

cp releases/tzfs_k64f_firmware.hex /media/K64F_DRIVE/

Method 2 — JTAG/SWD (OpenSDA)

Without the PJRC MCU, use a JTAG/SWD programmer. A Freescale FRDM-K64F development board running OpenSDA firmware is a convenient and inexpensive option. Configure solder jumpers JP1–JP4 pads 2-3, JP5 pins 1-2, connect the SWD header, and use pyOCD or J-Link Commander to flash the firmware:

# Using pyOCD:
pyocd flash --target k64f releases/tzfs_k64f_firmware.hex

Preparing the SD Card

Once the K64F firmware is flashed, prepare a FAT-formatted micro SD card with the TZFS firmware binary and the SD card file collection from the release:

Format the SD card as FAT32 on a PC.

Copy the TZFS firmware binary (tzfs.bin or equivalent) to the root of the card.

Copy the SD card file collection directories (MZF game and program files, CP/M disk images, BASIC images) to the card as supplied in the release archive.

The K64F will detect the TZFS binary at boot and load it into the tranZPUter's 512 KB SRAM automatically before releasing the Z80 from reset.

First Boot

Insert the prepared SD card into the tranZPUter board's SD card slot, ensure the board is correctly installed in the MZ-700, and power on. The K64F initialises, locates the TZFS firmware on the SD card, loads it into the tranZPUter's 512 KB SRAM, and releases the Z80 from reset. The Z80 executes TZFS directly. The familiar MZ-700 sign-on banner appears, appended with "+ TZFS" to confirm that TZFS initialised successfully:

SHARP MZ-700
Monitor 1Z-013A  + TZFS

*

The * is the standard SA-1510 / 1Z-013A monitor prompt. All original MZ-700 monitor commands work exactly as they did on the unmodified machine. Type H to display a paginated help screen listing all TZFS commands. Press Space to advance through pages.

If the + TZFS text is absent, TZFS did not initialise correctly. The most common causes are:

The SD card is not inserted or not correctly seated.

The SD card is not FAT-formatted or the TZFS firmware binary is missing from the root.

The K64F firmware is outdated or was not flashed successfully.

The FPGA configuration device was not programmed or the bitstream is corrupt — check that the FPGA initialises (status LED behaviour on v1.2).

TZFS Monitor Commands

The complete TZFS command set is listed below. Commands marked (T) require the K64F I/O processor and the tranZPUter hardware (present on all SW-700 boards). These are absent on FusionX and picoZ80 builds, but all commands listed here are available on the tranZPUter SW-700.

Command	Parameters	Description
4	—	Switch to 40-column display mode.
8	—	Switch to 80-column display mode.
ASM	`<address>`	Invoke the built-in Z80 assembler starting at `<address>`. Enter mnemonics line by line; assembled bytes are written to RAM and the address advances automatically. Press Enter on a blank line to exit.
B	—	Enable or disable the key-entry beep.
BASIC	—	Locate SA-5510 BASIC (or MZ-700 BASIC) on the SD card, load and execute it.
CD	`[<directory>]`	Change the active SD card directory. With no argument, prints the current path. Supports standard directory navigation.
CP	`<src> <dst> <size>`	Copy a block of memory. All arguments are 4-digit hex: source address, destination address, byte count.
CPM	—	Load CP/M 2.2 from SD card and boot.
D	`<addr> [<addr2>]`	Hex and ASCII dump of memory from `<addr>` to `<addr2>` (or 20 lines if no end address). Pauses at each screenful; press D to page down, U to page up, X to exit.
DASM	`<addr> [<addr2>]`	Disassemble Z80 machine code from `<addr>` to `<addr2>`. Displays address, hex bytes, and mnemonic.
DIR	`[<wildcard>]`	Paged directory listing of the active SD card directory. Optional wildcard pattern, e.g. `DIR *.MZF`.
EC	`<name or file no.>`	Erase a file from the SD card by name or by number.
EX	—	Exit TZFS and restart the machine in its original mode (without TZFS).
F	`[<drive>]`	Boot from floppy disk. Prompts for a drive number if not supplied.
FILL	`<start> <end> [,<value>]`	Fill memory from `<start>` to `<end>` with `<value>` (default 0x00).
FREQ	`<kHz>`	Set the CPU frequency in kHz. 0 restores the board default. Uses the K64F service request API.
H	—	Display the paginated help screen. Press Space to advance.
J	`<address>`	Jump to (execute from) the given hex address.
L / LT	`[<filename>] [,<M>]`	Load from tape (CMT) and execute. Optional `,M` specifies machine model for tape timing.
LTNX	`[<filename>] [,<M>]`	Load from tape without executing.
LC	`<name or no.> [,<M>]`	Load a program from SD card and execute. Optional `,M` specifies the target machine model.
LCNX	`<name or no.> [,<M>]`	Load from SD card without executing.
M	`<address>`	Interactive memory editor. Shows the address and current value; type a hex value to write, press Enter to skip, Ctrl-C to exit.
MZ (T)	`[<mc>]`	Activate hardware emulation for machine code `mc`. Defaults to MZ-700. Valid codes: `80K`, `80C`, `1200`, `80A`, `700`, `800`, `80B`.
MZ80K (T)	—	Activate Sharp MZ-80K hardware emulation.
MZ80C (T)	—	Activate Sharp MZ-80C hardware emulation.
MZ1200 (T)	—	Activate Sharp MZ-1200 hardware emulation.
MZ80A (T)	—	Activate Sharp MZ-80A hardware emulation.
MZ700 (T)	—	Activate Sharp MZ-700 hardware emulation (host native mode).
MZ1500 (T)	—	Activate Sharp MZ-1500 hardware emulation.
MZ800 (T)	—	Activate Sharp MZ-800 hardware emulation.
MZ80B (T)	—	Activate Sharp MZ-80B hardware emulation.
P	—	Run a test on the connected printer.
R	—	Run a comprehensive DRAM memory test. Reports any failed addresses.
RIO	`<port>`	Read an I/O port and print the value. Port is 4-digit hex.
S / ST	`<start> <end> <exec> [,<M>]`	Save a memory range to tape (CMT). Prompts for a filename. Optional `,M` for machine tape timing.
SC	`<start> <end> <exec>`	Save a memory range to SD card. Prompts for a filename.
SD2T	`<name or no.> [,<M>]`	Copy a file from SD card to tape (CMT). Optional `,M` for machine model tape timing.
T	—	Test the 8253 timer chip.
T2SD	`[B] [,<M>]`	Copy tape to SD card. The `B` flag enables Bulk mode (multiple files back-to-back). Optional `,M` for machine model.
T80 (T)	—	Switch from the hardware Z80 to the internal soft T80 CPU core.
TC	`[-]<value>`	Set tape delay compensation in steps. Use `-` prefix to decrease. Run with no arguments to show the current value.
V	—	Verify a file saved to tape against the data currently in memory.
VBORDER (T)	`<colour>`	Set the VGA output border colour (0–15).
VGA (T)	`<mode>`	Set the VGA output mode (0=off, 1=640×480, 2=800×600).
VMODE (T)	`<mode>`	Set the active video mode for the emulated machine.
WIO	`<port> <value>`	Write `<value>` (2-digit hex) to I/O port `<port>` (4-digit hex). Useful for hardware debugging.
Z80 (T)	—	Switch from the soft CPU back to the hard (external) Z80.
ZPU (T)	—	Switch to the ZPU Evolution soft CPU core and boot zOS.

SD Card Operations

TZFS uses the tranZPUter's K64F I/O processor to access a FAT-formatted SD card via a service request API. Files are stored as standard MZF-format files in a conventional directory structure, making it straightforward to manage the SD card from a PC. All SD card commands operate on the currently active directory, which can be changed with CD.

Listing the Directory

Use DIR to display a paged listing of the active SD card directory. An optional wildcard pattern restricts the listing:

* DIR               ; List all files in the active directory
* DIR *.MZF         ; List only .MZF files
* DIR INVADERS*     ; List files whose names begin with INVADERS

Each listing entry shows a file number and the filename. The listing pauses at each screenful; press Space to continue.

Changing Directory

Use CD to navigate the SD card directory structure. With no argument, CD displays the current path:

* CD                ; Show current directory path
* CD MZ700          ; Change into subdirectory MZ700
* CD ..             ; Move up one level

Loading Programs

Use LC to load a program from the active SD card directory and execute it. Use LCNX to load without executing. Files can be specified by name or by the number shown in the DIR listing. Loading by number is faster as no string matching is required. The optional ,M parameter specifies the target machine model for programs designed for a different MZ variant:

* LC INVADERS        ; Load INVADERS from the active directory and execute
* LCNX INVADERS      ; Load without executing (useful for debugging)
* LC 04              ; Load file number 04 and execute
* LC STARTREK,7      ; Load STARTREK targeting MZ-700 memory model

Saving Programs

Use SC to save a memory range to the active SD card directory. The syntax is the same as the tape S command — start address, end address, and execution address as consecutive 4-digit hex values, followed by a filename when prompted:

* SC120020001200
FILE NAME? MYPROG
SAVED

Erasing Files

Use EC to erase a file from the active SD card directory. The file can be identified by name or by the number shown in the DIR listing:

* EC OLDPROG         ; Erase file named OLDPROG
* EC 07              ; Erase file number 07

Tape Operations

TZFS retains full CMT (cassette) support alongside the SD card filing system. All original tape commands work as they did on the unmodified MZ-700 monitor. TZFS extends them with machine model timing selection and adds convenience commands for transferring files between tape and SD card.

Loading from Tape

Use L (or its alias LT) to load a program from tape and execute it. Use LTNX to load without executing. An optional filename can be specified — if given, TZFS searches the tape until it finds a matching header. Without a filename, the first file encountered is loaded.

The optional ,M parameter selects the machine model whose tape timing parameters are used for the load. This is needed when reading tapes made on a different MZ model that uses different baud rates or bit-cell widths.

Code	Machine model
K	Sharp MZ-80K
C	Sharp MZ-80C
1	Sharp MZ-1200
A	Sharp MZ-80A
7	Sharp MZ-700
8	Sharp MZ-800
B	Sharp MZ-80B

* L              ; Load next tape file and execute (default timing)
* LT INVADERS    ; Search for INVADERS on tape and execute
* LTNX ,7        ; Load next file using MZ-700 tape timing, no execute

Saving to Tape

Use S (or ST) to save a memory range to tape. Provide start address, end address, and execution address as consecutive 4-digit hex values, then type the filename when prompted:

* S120020001200
FILE NAME? MYPROG
SAVING...

Verifying a Tape Save

Use V immediately after saving to verify that what was written to tape matches the data still in memory. TZFS reads the tape back and compares it byte by byte, reporting any mismatches.

Copying Tape to SD Card

T2SD loads the next file from tape and saves it directly to the active SD card directory. Press Play on the tape deck before running the command. The optional B flag enables Bulk mode — reads files back-to-back from tape until the end is reached, useful for archiving an entire tape side in one operation:

* T2SD          ; Copy next tape file to SD card (default timing)
* T2SD B        ; Bulk copy — read all files from tape to SD card
* T2SD B,7      ; Bulk copy using MZ-700 tape timing

Copying SD Card to Tape

SD2T loads a named file (or file by number) from the active SD card directory and writes it to tape exactly as if performing a tape-to-tape copy. Press Record on the tape deck when prompted:

* SD2T INVADERS      ; Write INVADERS from SD card to tape
* SD2T 04,7          ; Write file 04 to tape using MZ-700 timing

Tape Delay Compensation

Different CMT decks and tape heads have slightly different read/write timing characteristics. The TC command adjusts a compensation value applied to all tape timing calculations. Adjusting by one or two steps at a time is usually sufficient to resolve intermittent load failures:

* TC            ; Display current compensation value
* TC 2          ; Increase compensation by 2 steps
* TC -1         ; Decrease compensation by 1 step

Soft CPUs

The tranZPUter SW-700 FPGA implements two soft CPU cores alongside the hard external Z80: T80 (a soft-core Z80 implementation) and ZPU Evolution (a 32-bit stack CPU). Switching CPUs asks the K64F to load any required firmware before the FPGA activates the requested core. TZFS exposes three commands for this:

Command	Description
Z80	Switch back to the hard (external) Z80. This is the default state after boot.
T80	Switch to the T80 soft-core Z80 implemented in the FPGA.
ZPU	Switch to the ZPU Evolution soft CPU implemented in the FPGA and boot zOS.

After switching, TZFS firmware continues running on the new CPU without interruption. The Z80, T80, and ZPU cores share the same tranZPUter 512 KB SRAM, so memory contents are identical before and after a switch. CPU switching is transparent to programs that do not depend on cycle-exact Z80 timing.

The FREQ command adjusts the CPU clock frequency independently of which CPU is active. The K64F generates the alternative clock and can set it to any frequency the Z80 can sustain (reliably tested to 24 MHz on a Z84C0020):

* T80            ; Switch to soft T80 core
* Z80            ; Switch back to external Z80
* ZPU            ; Switch to ZPU Evolution core and boot zOS
* FREQ 8000      ; Set CPU frequency to 8 MHz
* FREQ 0         ; Restore board default frequency (3.54 MHz)

Machine Emulation

The tranZPUter SW-700 FPGA implements hardware-level emulation of multiple Sharp MZ models. When a hardware emulation command is issued, TZFS asks the K64F to load the correct monitor ROM for the target machine from the SD card into SRAM. Once loaded, the FPGA reconfigures its video and memory mapping logic to match the target machine and the machine restarts in full compatibility mode. From that point, software designed for the target model runs without modification.

Note (V1 firmware): MZ-2000 emulation is not available in the V1 firmware. The current firmware adds MZ-2000 and MZ-2200 support alongside I/O port changes. If you require MZ-2000 emulation, see the current version guide.

The MZ command activates emulation for a named machine code. The individual named commands are convenience aliases:

* MZ 700         ; Activate MZ-700 hardware emulation (host native)
* MZ700          ; Equivalent alias
* MZ80A          ; Activate MZ-80A hardware emulation
* MZ80B          ; Activate MZ-80B hardware emulation

To return to the host MZ-700 native mode after emulating another model, issue MZ700 or power-cycle the machine. Hardware emulation changes persist across soft resets.

Video Control

The tranZPUter SW-700 FPGA intercepts the MZ-700 video signal and can either pass the original video through or substitute its own enhanced VGA output. Three TZFS commands control VGA output:

Command	Parameters	Description
VGA	`<mode>`	Set the VGA output mode. 0 = off (original video), 1 = 640×480, 2 = 800×600.
VBORDER	`<colour>`	Set the VGA border colour (0–15). Colour values follow the standard Sharp MZ palette.
VMODE	`<mode>`	Set the active video mode for the emulated machine. Mode values depend on the active hardware emulation target.

* VGA 1          ; Enable VGA output at 640x480
* VGA 2          ; Enable VGA output at 800x600
* VGA 0          ; Disable VGA output (revert to original video)
* VBORDER 4      ; Set VGA border colour to 4
* VMODE 2        ; Set video mode 2 for the active emulation target

Video Control Register (V1 — I/O Port 0xF8)

In the V1 firmware, the FPGA video controller is accessed directly via I/O port 0xF8 (the Control Register). The full register map for V1 is:

Port	Register	Description
0xF8	Control Register	VGA mode, colour depth, column width, machine model select
0xF9	Graphics Mode	Graphics mode selection
0xFA	Colour Writer (R)	Red channel colour palette write
0xFB	Colour Writer (G)	Green channel colour palette write
0xFC	Colour Writer (B)	Blue channel colour palette write
0xFD	Memory Page	Memory page register

The Control Register at 0xF8 accepts a byte value that encodes several fields:

Bits	Field	Description
7:6	VGA	VGA output mode: 00=off, 01=640×480, 10=800×600
5	Colour	0=monochrome, 1=colour output
4	80col	0=40-column, 1=80-column
3:0	Model	Machine model: 0100=MZ-700, 0000=MZ-80A, others per model

Example: enable VGA 640×480, colour output, 80-column, MZ-700 model:

LD A, 0x59    ; VGA=01, colour=1, 80col=1, model=0100 (MZ-700)
OUT (0xF8), A ; V1 firmware: Control Register is at 0xF8

V1 vs Current — Register Address Difference
In the V1 firmware the video Control Register is at 0xF8. In the current firmware (after the I/O port re-assignment for MZ-2000 support) it moved to 0xA8. If your TZFS version shows a post-v2.2 build number, or if OUT (0xF8), A has no effect on video, your board is running the current firmware and you should use port 0xA8 — see the current version User Manual.

Running CP/M 2.2

CP/M 2.2 is available on the tranZPUter SW-700. From the monitor prompt:

* CPM

TZFS will locate the CP/M image on the active SD card directory, load it, and transfer control to the CP/M CCP. The prompt changes to A>.

CP/M access to disk drives is provided through the tranZPUter's K64F I/O processor service API, which translates CP/M BIOS calls into SD card file operations. The tranZPUter provides 64 KB of program RAM for CP/M. The CBIOS lives in the tranZPUter's upper SRAM, leaving the full lower 64 KB free for applications.

The pre-built SD card image includes a populated CP/M disk area. Navigate with CD to the directory containing the CP/M boot image before typing CPM. Standard CP/M applications — Turbo Pascal, WordStar, Hi-Soft C, assemblers — run without modification.

To return to the TZFS monitor from CP/M, use a warm boot (Ctrl-C from the CCP) which reloads the CCP. To exit fully back to TZFS, use the EX command from the TZFS monitor prompt, or power-cycle — TZFS will reload automatically from SD card.

Using BASIC

TZFS can locate and load a BASIC interpreter from the SD card automatically. From the monitor prompt, type:

* BASIC

TZFS searches the active SD card directory for the BASIC image appropriate to the current hardware emulation target, loads it into RAM, and executes it. The BASIC prompt appears and the interpreter operates as it would on the original hardware.

Because TZFS loads BASIC from SD card rather than ROM, multiple BASIC versions can coexist on the card:

When running in native MZ-700 mode, the MZ-700 BASIC image (1Z-013A BASIC equivalent) is loaded.

When running under MZ-80A hardware emulation, the SA-5510 BASIC image is loaded.

BASIC programs stored on the SD card as MZF files can be loaded from within BASIC using the standard tape LOAD command directed at the appropriate file, or by returning to the TZFS monitor (BYE or MON command if available) and using LC.

To return to the TZFS monitor from BASIC, use the BYE or MON command if available in the BASIC interpreter, or reset the machine — TZFS will reload automatically from the SD card.

V1 vs Current Firmware — Key Differences

The tranZPUter SW-700 firmware has evolved significantly since the original v1 release. The table below summarises the key differences between the V1 firmware (covered by this guide) and the current firmware (covered by the current version User Manual):

Feature	V1 (this guide)	Current version
Supported hosts	Sharp MZ-700 only	Sharp MZ-700 and Sharp MZ-2000
Video Control Register	0xF8	0xA8
Graphics Mode Register	0xF9	0xA9
Colour Writers (R/G/B)	0xFA, 0xFB, 0xFC	0xAA, 0xAB, 0xAC
Memory Page Register	0xFD	0xAD
MZ-2000 hardware emulation	Not available	Available
MZ-2000 graphics mode	Not available	Available
TZFS command set	40+ commands	40+ commands (same set; register addresses differ internally)
CP/M, BASIC, tape, SD	Full support	Full support

How to identify which firmware is installed:

Type H at the TZFS prompt and read the displayed firmware version number. V1 firmware versions are labelled in the v2.2 branch (Git branch v2.2-tranZPUter-SW-HW_700_v1.3 or earlier). Current firmware is in a later branch.

Type WIO F8 00. If the video changes, you are running V1 firmware (port 0xF8 is active). If there is no response, try WIO A8 00 — if that has an effect, you are running the current firmware.

If MZ2000 is a recognised command, you are running the current firmware.

If you update the firmware from V1 to the current version, update any Z80 assembly code that writes to video registers: replace all references to ports 0xF8–0xFD with 0xA8–0xAD respectively.

Troubleshooting

SD card not inserted or not detected — check the card is fully seated in the tranZPUter board's SD card slot.

SD card not FAT-formatted — the K64F expects a standard FAT32-formatted card. Re-format and copy the TZFS firmware binary and SD card file collection again.

TZFS firmware binary missing — ensure the TZFS firmware binary (tzfs.bin or equivalent) is present in the root of the SD card.

K64F firmware not flashed or outdated — verify the K64F was programmed with the correct firmware from the releases/ directory. An unprogrammed K64F will not load TZFS at boot.

FPGA not configured — ensure the EPCS configuration device was programmed correctly. If the FPGA has not configured (no logic active), the board will not function. On v1.2, try pressing the CONFIG switch; on v1.3, power-cycle after programming the EPCS64.

VGA output is absent, garbled, or video commands have no effect

Wrong register address — verify you are using port 0xF8 (V1 firmware). If your board has been updated to the current firmware, the register has moved to 0xA8. Check firmware version as described in the V1 vs Current section above.

Video cable not connected — the video cable between the tranZPUter board and the MZ-700 modulator connector must be connected for the FPGA to intercept the video signal. Check both connectors are fully seated.

Monitor or display does not accept VGA signal — verify the display accepts the selected VGA mode (640×480 or 800×600). Try mode 1 first (640×480 is the most universally supported).

FPGA bitstream is for the wrong board version — ensure the EPCS device was programmed with the bitstream for your hardware (v1.2 Cyclone III vs v1.3 Cyclone IV). Mismatched bitstreams will produce incorrect or absent video.

Tape loads fail or produce errors

Tape timing mismatch — if the tape was recorded on a different MZ model, use the ,M parameter to select the appropriate machine model timing (see Tape Operations).

Tape head speed variation — use the TC command to adjust tape delay compensation. Increasing or decreasing by one or two steps usually resolves intermittent failures.

Tape condition — aged or poorly stored tapes may have drop-outs. Try cleaning the tape head and capstan with isopropyl alcohol before retrying.

CP/M does not boot or shows BIOS errors

CP/M image not present on SD card — ensure the SD card contains the CP/M boot image in the directory that was active when CPM was typed. Use DIR to confirm.

Wrong active directory — navigate with CD to the directory containing the CP/M image before typing CPM.

K64F service timeout — if the K64F does not respond to a BIOS service request within the expected window, CP/M will stall. Power-cycle the board and retry. If the problem persists, check K64F firmware compatibility.

Machine crashes or resets unexpectedly after loading a program

Program targets wrong machine model — programs written for a specific MZ model may crash on a different model. Activate the appropriate hardware emulation before loading (e.g. MZ80A before loading MZ-80A software).

Program overwrites TZFS workspace — TZFS reserves areas of the tranZPUter's 512 KB SRAM. Programs that use the full lower 64 KB may corrupt TZFS data. Use LCNX to load without executing and inspect the load address with D before running.

T80 or ZPU commands are not recognised or cause a crash

FPGA bitstream does not include the soft CPU cores — ensure the EPCS was programmed with the full production bitstream from the release, not a partial or test build.

ZPU firmware not present on SD card — the ZPU command requires the K64F to load zOS from SD card before switching. Ensure the zOS firmware image is present in the correct directory on the SD card.

Reference Sites

Resource	Link
tranZPUter SW-700 V1 project page	/sharpmz-700-upgrades-tranzputer-sw/
tranZPUter SW-700 Current project page	/sharpmz-700-upgrades-tranzputer-sw-current/
Current version User Manual	/sharpmz-700-upgrades-tranzputer-sw-current-usermanual/
TZFS Technical Guide	/sharpmz-upgrades-tzfs-technicalguide/
TZFS Developer’s Guide	/sharpmz-upgrades-tzfs-developersguide/
tranZPUter project page (original SW)	/tranzputer/
tranZPUter Fusion project page	/tranzputerfusion/
TZFS User Manual (generic, all platforms)	/sharpmz-upgrades-tzfs-usermanual/
Sharp MZ-700 specifications	/sharpmz-700-specifications/
Sharp MZ Series technical reference	Bundled in repository `docs/` directory
Altera Quartus II 13.1 (Cyclone III/IV)	Available from Intel FPGA legacy downloads

tranZPUter SW-700 (v1) — User Manual