Conversion Instructions – Stringy Floppy

How to get Exatron Stringy Floppy Images from your Real TRS-80 Model I or Clone

Are you one of those lucky people in the world who owned an Exatron Stringy Floppy (ESF), still have a working ESF unit, a TRS-80 Model 1 (or clone like the System 80) and a whole bunch of wafers? Furthermore do you have programs specific to the ESF on these wafers that you want to get off before they snap (like the one opposite) so they can live again in emulation?

If so, here is one way to do it. This is a step by step listing of the procedure I used to transfer my own wafers. I’ve made it quite verbose, so it might sound like teaching grandmothers to suck eggs for TRS-80 stalwarts, but it might be a long while since some folk touched these things and/or they might have inherited what they have got from a father or grandfather and not know much about it.

Before you start, check that the program is not already available in the disk or cassette archive. There weren’t a lot of programs written SPECIFICALLY for the ESF. If it’s a game, you might find it in the other archives and so save yourself the hassle.

Here are the steps. This is not the ONLY way to do this. It’s simply the method I used. It assumes you are extracting to a Windows PC platform. It also assumes familiarity with Matthew Reed’s TRS32 emulator.

First check that you can load the program you want successfully in the ESF and the wafer is ok.

Hook up the TRS80 Model 1 via its cassette interface to the PC’s soundcard and make sure you can both record and load programs as WAV files. I suggest using the free program Audacity as your sound recorder/player. You will probably need to play around with sound levels a bit until you can reliably save and load a BASIC program. Make sure you can do this before going any further.

For BASIC Programs

  1. These are easy. Make sure you PC is set to record mode and the correct cassette cable is in the LINE INPUT socket of the sound card.
  2. Boot your TRS-80 and @LOAD your program in.
  3. CSAVE the program out the cassette port to Audacity on the PC, capturing the audio as a file.
  4. Export the Audacity file as an 8-bit mono WAV file.
  5. On the PC, boot up Matthew Reed’s TRS32 emulator, initialise the ESF, attach a new wafer of appropriate length and @NEW it to format.
  6. CLOAD the captured WAV file into the emulator
  7. @SAVE1 the file onto the new wafer. Done!

For Machine Language Programs

These are trickier. Essentially you need to load them into memory but prevent them from executing. You then need to write out the memory block they are residing in to the PC, capturing it as a System file in WAV format. This can then be loaded into the emulator using the SYSTEM command and then transferred to wafer.

I used the monitor program TASMON. However, if you have a copy of the ESF-80 Monitor on wafer and know (or are willing to learn) to use it, this is an alternative to using TASMON as outlined below. The ESF-80 monitor is small, loads fast, and can be relocated on entry.

The method below assumes you have 48K of memory to play with. If you only have 16k, see the notes at the end of this section.

  1. Download a High Memory version of the machine language monitor program TASMON as a WAV file. The WAV contains a relocated version of TASMON which loads into High Memory well clear of the bottom 16K of RAM where most ESF programs will reside. If you need it, you can pick up the TASMON manual here.
  2. Ensure the TRS-80 and PC are set up so that the TRS-80 is ready to load TASMON from the PC via Audacity when required (a bit like having a cassette loaded and ready). Make sure the ESF is attached to the TRS-80 also.
  3. Boot the TRS-80. If you using the expansion interface to get the 48k needed, you’ll need to hold BREAK down so it boots to LEVEL 2 BASIC instead of hanging of course.
  4. Initialise the Stringy Floppy in the normal way (SYSTEM then /12345)
  5. @LOAD in the machine language program holding the SHIFT key down. This will stop it initialising and relocating. Once the tape stops (assuming no errors) the program will be now sitting in RAM. Three numbers will appear on the screen. These will be the memory location start address, the length of the file, and the entry address, all in decimal.
  6. Write those decimal numbers down somewhere. Find out the end address of the program by adding the length of the file to the start address. After doing this, convert the entry, end and start address to HEX. You’ll need these for later. Note: If the end address goes beyond E000H it means you won’t be able to use TASMON for extracting this particular file, as it commences loading in that area. See the notes at the end of this section.
  7. Whatever you do, DON’T reboot the machine at this stage. Now load in TASMON from the PC using the same commands on the TRS-80 you would use as if it’s a machine language cassette file (SYSTEM then T). TASMON should load into high memory right at the top of RAM (E000 to FFFF) and (hopefully!) well clear of anything you’ve loaded in from the ESF.
  8. Once TASMON has loaded, start the program (with /). You’ll now need to write out the data in the area of RAM containing your program.
  9. Reconfigure the PC and Audacity from playback mode to record mode. Having loaded a file in through the cassette port (TASMON) you are now about to write one out. (as if you are putting a blank cassette in the tape recorder).
  10. Set up TASMON to write a WAV of the memory segment where your ESF program is now residing (You’ll need those figures you worked out in step 6). Do this by typing “W <start address in Hex> <end address in Hex> <entry address in Hex>” then press ENTER then type a six letter identifier but DONT press ENTER again just yet.
  11. Click the record button in audacity on the PC
  12. Press ENTER on the TRS80. Tasmon will start writing a SYSTEM file out the cassette port to the PC where audacity will be capturing it.
  13. When finished, stop audacity from recording and write out the file on the PC as an 8 bit, mono WAV.
  14. Boot up Matthew Reed’s emulator with Stringy Floppy enable and disk drives disabled
  15. Initialise the emulated stringy floppy in Level 2 BASIC just as you did on the real machine
  16. Create a new stringy floppy wafer in the emulator long enough to take your program. Initialise it by typing @NEW in Level 2 BASIC
  17. Using the SYSTEM command and whatever file identifier you’ve used, load in the WAV file you just made from the real TRS-80. When finished loading DON’T START IT, but instead select “Warm Boot” from the emulator’s File menu, which will return you to the BASIC prompt but leave the newly loaded memory contents intact.
  18. Using the same decimal (not the hex) figures you wrote down in step 6, save the section of memory on the new wafer by typing @SAVE1,<start address>,<length>,<entry address>.
  19. Type @LOAD to check if the program works. If it works, you’ll know it.

What if I only have 16K and I want to image a machine language program?

If you have the ESF-80 monitor program on wafer, do this. Find out where your ESF program loads by holding the shift key while loading as described above. Then load the ESF-80 Monitor and relocate it to a place above that area if possible. Using ESF-80 monitor commands, reload the program you are tying to extract, then write it out as a SYSTEM file over the cassette port as described above.

If you don’t have the ESF-Monitor program another option is relocate TASMON to an area either at the top or bottom of your 16K and hope that you have enough memory left to squeeze your program in. TASMON allows you to write out machine code to cassette and relocated it as it does so. Hence it can write itself out to a lower starting address. Click here to download a version of TASMON that occupies the top end on 16k RAM i.e. 6000H to 7FFFH. See the TASMON manual for details if you want to put it somewhere else.

What if I have a System 80, Video Genie or PMC 80?

BASIC is no problem but machine language programs can be. The problem is that the System 80’s #1 cassette port is in-built. It’s not possible to specify the external cassette port (#2) for the SYSTEM command. Some System 80s were modified by their owners to switch between the two cassette ports manually. If you have one of these, you’re in luck.