Create HiSoft C TAP For ZX Spectrum: A Step-by-Step Guide

Are you looking to dust off your old ZX Spectrum and breathe new life into it with some custom C programming? Specifically, do you want to write a C program using a modern editor like Note++, convert it into a format the ZX Spectrum understands, and package it into a TAP file? If so, you've come to the right place! Creating HiSoft C TAP programs for the ZX Spectrum might seem daunting at first, but with the right tools and guidance, it's a rewarding experience. This guide will walk you through the process, providing explanations and a practical example to get you started.

Understanding the Challenge

The core challenge lies in bridging the gap between modern C development environments and the vintage world of the ZX Spectrum. The ZX Spectrum, with its limited resources and unique architecture, requires a specific format for executable files. Here's a breakdown of the steps involved:

1. Writing the C Code: You'll start by writing your C program using an editor like Note++. This is where you'll implement the logic and functionality you want your program to have.
2. Cross-Compilation: The C code needs to be compiled into machine code that the ZX Spectrum's Z80 processor can understand. This requires a cross-compiler, which runs on your modern computer but generates code for a different target architecture (the Z80).
3. Linking and Formatting: The compiled code needs to be linked with any necessary libraries and formatted into a specific memory layout that the ZX Spectrum expects. This often involves creating a header that tells the Spectrum where to load and execute the code.
4. TAP File Creation: Finally, the formatted code and header are packaged into a TAP file, which is a common tape image format used for distributing software on the ZX Spectrum.

Tools You'll Need

To accomplish this, you'll need the following tools:

• A C Cross-Compiler for Z80: Several options are available, including:
  • SDCC (Small Device C Compiler): This is a popular open-source cross-compiler that supports the Z80 processor. It's a good choice for beginners due to its ease of use and extensive documentation.
  • z88dk: Another powerful Z80 cross-compiler with a rich set of libraries and tools.
• A Text Editor: You've already mentioned Note++, which is an excellent choice. Any text editor that supports syntax highlighting and code editing will work.
• A TAP File Creator: A utility to package your compiled code into a TAP file. Several tools are available, often included with the cross-compiler or as standalone utilities.
• ZX Spectrum Emulator (Optional): An emulator like Fuse or Spectaculator allows you to test your TAP file on your computer without needing a physical ZX Spectrum.

Step-by-Step Guide with Example

Let's walk through a simple example to illustrate the process. We'll create a basic program that prints "Hello, ZX Spectrum!" on the screen.

1. Writing the C Code

Open Note++ and create a new file named hello.c. Enter the following code:

#include <stdio.h>

int main() {
 printf("Hello, ZX Spectrum!\n");
 return 0;
}

This is a standard C program that uses the printf function to display text on the console.

2. Cross-Compiling the Code (Using SDCC)

Assuming you have SDCC installed, open a command prompt or terminal and navigate to the directory where you saved hello.c. Use the following command to compile the code:

sdcc -mz80 --code-loc 0x8000 --data-loc 0xC000 hello.c

Let's break down this command:

• sdcc: Invokes the SDCC compiler.
• -mz80: Specifies that we're compiling for the Z80 processor.
• --code-loc 0x8000: Sets the memory address where the compiled code will be loaded. 0x8000 (32768 in decimal) is a common starting address for user programs on the ZX Spectrum. Choosing the right memory location is crucial to avoid conflicts with the system ROM and other memory areas.
• --data-loc 0xC000: Sets the memory address for the program's data. 0xC000 (49152 in decimal) is often used for data.
• hello.c: The name of the C source file.

This command will generate several output files, including hello.ihx (Intel HEX format) and hello.rel (relocatable object file).

3. Creating a Header File

The ZX Spectrum needs a header to know where to load and execute the code. Create a new file named header.asm with the following assembly code:

; Header for Hello World program
org 0x7ffd ; System variable area
dw 0 ; Program length (will be filled in later)
dw 0x8000 ; Load address (same as --code-loc)
dw 0x8000 ; Start address (where execution begins)

Explanation:

• org 0x7ffd: Sets the origin to memory address 0x7ffd, part of the system variable area where the Spectrum reads program information.
• dw 0: Reserves a word (2 bytes) for the program length. We'll calculate and fill this in later.
• dw 0x8000: Specifies the load address, which must match the --code-loc used during compilation.
• dw 0x8000: Specifies the start address, where the program's execution will begin.

4. Converting IHX to Binary and Combining with Header

We need to convert the hello.ihx file to a binary format and combine it with the header. You can use a tool like hex2bin or a custom script for this. Here's a conceptual outline using command-line tools (you might need to adapt the commands depending on your specific tools):

1. Convert IHX to BIN:

   hex2bin hello.ihx hello.bin
   

2. Assemble the Header: You'll need an assembler like asm80 or similar to assemble the header.asm file into binary. The exact command will depend on the assembler you choose. Let's assume the assembled header is named header.bin.
3. Concatenate Header and Binary: Use a command-line tool like cat (on Linux/macOS) or copy /b (on Windows) to combine the header and binary files into a single file. Important: The header must come first.

   cat header.bin hello.bin > program.bin  (Linux/macOS)
   copy /b header.bin+hello.bin program.bin (Windows)
   

4. Calculate program length: You must calculate the length of hello.bin in bytes, then edit header.bin to include it. This is often done manually with a hex editor. Remember that the length is stored as a two-byte little-endian value. For example, if hello.bin is 100 bytes long (0x64 in hexadecimal), you'd store the bytes 0x64 0x00 at the beginning of header.bin.

5. Creating the TAP File

Finally, we need to create the TAP file. Several tools can do this. One common approach is to use a tool specifically designed for creating TAP files for the ZX Spectrum. Often, these tools will ask you for the filename to be stored on the tape (e.g., "HELLO"), the load address (0x8000), and the binary data file (program.bin).

Let's assume you are using a command-line tool called tapmake (this is just an example; the actual tool and command syntax will vary):

tapmake -n HELLO -l 0x8000 program.bin hello.tap

• -n HELLO: Sets the filename to "HELLO" on the tape.
• -l 0x8000: Specifies the load address.
• program.bin: The binary file containing the header and compiled code.
• hello.tap: The output TAP file.

Testing Your TAP File

Now that you have your hello.tap file, you can test it using a ZX Spectrum emulator. Load the TAP file into the emulator and run the program. You should see the message "Hello, ZX Spectrum!" displayed on the screen.

Important Considerations

• Memory Management: The ZX Spectrum has limited memory, so it's crucial to manage memory efficiently. Avoid allocating large amounts of memory dynamically.
• ZX Spectrum Specifics: Be aware of the ZX Spectrum's hardware limitations and programming conventions. For example, screen memory is directly accessible at a specific memory address.
• Compiler Options: Experiment with different compiler options to optimize your code for size and performance.
• Debugging: Debugging on the ZX Spectrum can be challenging. Emulators often provide debugging tools to help you identify and fix errors.

Conclusion

Creating HiSoft C TAP programs for the ZX Spectrum is a fantastic way to explore retro computing and learn about low-level programming. While it requires some effort to set up the toolchain and understand the ZX Spectrum's architecture, the process is ultimately rewarding. By following this guide and experimenting with different examples, you'll be well on your way to creating your own custom software for the ZX Spectrum.

Remember to consult the documentation for your chosen cross-compiler and TAP file creation tool for more detailed information and advanced options. Have fun experimenting!

For more information on ZX Spectrum development, visit the World of Spectrum website: World of Spectrum. This site is an invaluable resource for all things ZX Spectrum, including software, hardware, and community forums. Good luck, and happy coding! Now you can proudly create your own programs for your ZX Spectrum and delve into the fascinating world of retro computing.