It’s 2013 – and the floppy disk is extinct. Floppy drives are no longer sold at computer stores, motherboards have almost all completely eliminated the onboard interface. Computer cases are beginning to lose their 3.5″ front facing bays, and USB floppy disk drives are starting to dry up.
The era of floppies is over. But those puny disks, holding less than 2Mb a piece still rest on your desk, in your drawers and possibly in some archive boxes somewhere. Some of them still might contain something interesting – documents from when you were younger and even software. Maybe they’re in esoteric formats too – Commodore, Atari, Mac? Maybe you wish you’d have migrated them when you had the chance – or built pristine images of them which you could use.
Wouldn’t it be nice to get access to these? The problem is time – it keeps ticking along … and your disks aren’t getting any younger.
Enter the solution – the Kryoflux! A high-resolution USB connected flux sampler which implements a “software” floppy controller, supporting almost every format known and capable of analysing copy protections at the bit cell level. At 75 EUR for the board only, it’s not expensive, but I guess it’s not like buying an Arduino. It’s nice to know that some of this goes towards supporting the Software Preservation Society (SPS), and the device itself has found use in official preservation efforts in libraries around the world.
Before the Kryoflux
Before the Kryoflux, the solution to imaging and preserving disks could be done in several ways. One way was just to read the disk in the native system – i.e. IBM/PC disks in an IBM/PC and Mac disks in a Mac. Unfortunately this meant that one couldn’t preserve a disk if they don’t own a machine of that platform – older hardware often fails for various reasons, not least for the fact that floppy disk drives are mechanical devices. Another disadvantage was the lack of copy protection handling – the controllers are strictly confined to reading and interpreting only “legal” sector formats and custom formats would often present as a read error but in reality was “intended”. So what you can see is only what the disk writer wanted you to see – and any copy you make would be imperfect.
Another solution would be a special dedicated controller, similar to the Kryoflux. The most popular of these was the Catweasel – an expensive piece of hardware that sees very little support nowadays. The more desirable PCI mk.4 no longer available, and was highly sought after at one point in time making second hand acquisitions rather expensive. One problem is that the controller itself wasn’t very well supported under modern systems, making it hard to use.
Of course, this didn’t apply to all systems – some systems like the Amiga were very flexible owing to the stinginess of the designers. They didn’t have floppy disk controllers, and instead implemented floppy routines in software. This is sort of like what the Kryoflux is looking to achieve, just a bit more primitive due to limitations in early hardware. Unfortunately, retro hardware commands high prices, and often come with surprises – sometimes nasty. So a better solution was needed …
Why not DIY?
If one looks at the 34 pin pinout of a floppy drive, it seems simple to adapt a regular drive into “spilling the beans”. As a person who’s played with floppy drives for a bit of an experiment with an Arduino – the floppy disk interface is positively primitive when compared with SCSI or IDE.
Really, it’s as simple as:
- Drive Select – pull low to gain drive’s attention.
- Motor On – pull low to start spinning the disk motor.
- Direction/Step – choose appropriate combinations to step forward by one track or back by one track.
- Head Select – toggle to read side 0 or side 1.
- Track00 – once this is asserted by the drive, you know the heads are “home”.
- Rdata – a logic signal output from the drive which represents the flux from the head.
- Index – a logic signal from the drive telling you when one revolution has completed.
So why wouldn’t one build their own? I had this thought myself – but here are the key reasons I didn’t:
- MFM Bitrate – on a regular PC formatted HD disk, the bitrate is stated at 500kbit/s. Under the MFM encoding, this is doubled to 1000kbit/s when encoded onto the media (due to the need for the stream to be self clocking). That means that in order to have a chance of reading the flux transitions correctly, one must sample the digital signal at a rate at least 2Mhz. Okay – so this isn’t that onerous for some logic analyzers but it’s really not the domain of your Arduino, because you do have to worry about getting this data out of there.
- Getting the Data to the PC – the data rate is fairly high, so serial might not cut it, and USB isn’t exactly the easiest thing to play with.
- Decoding the data – while you will get some 0’s and 1’s out of there if you’re diligent enough, you have to interpret the encoding to get the raw data. This means getting down to the nitty gritty of how the floppy disk controllers sync with the data stream – and this can be really problematic when it comes to special formats when documentation is poor or limited, or with marginal disks.
Doing this will take a lot of time – and when there’s a ready solution available at 75EUR, one might as well not reinvent the wheel and support a worthy cause at the same time.
Of course, I’m not saying that it’s impossible – archivists do actually hook up drives to ‘scopes, record the data and decode it later, but it’s effort above and beyond my abilities (at present).
Something that would be better is an analog system which reads the signal straight from the floppy disk heads rather than from the 34 pin digital interface. This way, you get a better idea of the noise and strength of your signal, and you defeat any special “patterns” which may be written to fool the AGC in a floppy drive. But it increases the data recorded, and for maginal benefit.
I think it’s clear by now, the best solution is something that is accessible to the majority, mass produced as to be affordable and leaves processing to software (to open up the widest possibilities in terms of format support and utility – after all, computing power is ample now). All the while, using commonly available commodity drives – i.e. the ones manufactured for IBM/PCs, and remaining easy to connect and use under a modern operating system. The Kryoflux very nicely fits this niche – it goes further and ensures that the basic reading software, manuals, schematics are all available.
The Schematic for a Kryoflux Rosalie revision D3 board which seems indistinguishable from the D2 board. Schematics, Manuals and Quick Starts are available in the software package from Kryoflux.
Don’t get me wrong. The Kryoflux is not the only kid on the block – the Device Side Data FC5025 intended for 5.25″ disks for example. There was another one I was aware of, but the name escapes me at the present moment. The difference is that the Kryoflux seems to be the most versatile, and most complete read-back solution – and it’s even evolved to writing certain image formats too as a bonus.
The Board Itself
When I got the package, I was really excited. It seems those guys at Kryoflux also pull all stops to make sure the presentation is A+! They even put their seal on the receipt and packaging! I ordered the Basic edition, since I know what I’m doing and I didn’t really need all of the other accessories. The box is pictured above, depicting the fact the boards are produced by Olimex (a prototype/developers board company).
The board is a nice black ENIG PCB which shows a fairly high packing density. It’s nice and small, around the footprint of a credit card. There are many jumpers and connectors – most of which aren’t really important to the users. Basically one should be aware of the Write Gate jumper (remove to inhibit writing – a good idea for archivists), the 34 pin connector, and the USB connector. The other jumpers control multiple-drive behaviour, firmware erasure, test mode enable, JTAG reprogramming and alternate power distribution (which can really damage the board if misused)! The board runs an Atmel AT91SAM7S256 ARM7TDMI microcontroller (familiar to the guys who did ELEC2142 at UNSW before 2012).
The board is beautiful from the rear – with the logo in gold. Lovely. It does appear that the headers and jumpers are hand soldered, but they seem to be done with a decent amount of care, so I’m happy. But one must be extremely careful with bare boards like these. They can be vulnerable to static damage and shorting out, depending where you put them – so don’t just start throwing this around like a “finished product”. Aside from this fact, it is pretty much ready for your average Joe to give it a go.
In my case – I know I handle my boards carefully, but they still need a bit of help. Putting “hot glue” dots, a proxy for rubber feet, helps elevate the board from my PC case and eliminate risk of shorts. A cheap measure, but quite effective.
The board itself is just one part of the equation – another is the USB cable, floppy disk cable, the power supply and the floppy drive which are not included in the basic package. The USB cable can easily be had – any USB A to B cable will suffice.
The floppy drive … well, I hope you have some spares. Since taking this photo, I have purchased another 10 drives to be sure …
So that’s the drives taken care of, at least, the 3.5″ drives. If you’re interested in recovering from 5.25″ disks as well, I better hope you have a spare drive or a few – they fetch quite a price on eBay and will probably get more expensive as time progresses. I regret not having a collection of them myself … although if someone wants to donate some … I’ll be happy to have them.
The next part to solve is the floppy cable. Chances are, you still have a spare lying around – in my case, plenty – but you have to be careful. Cables which shipped with late motherboards may have only two IDC 34 pin connectors – one for the controller, and one for drive A (i.e. with a single twist). These will be suitable if you want to recover from a 3.5″ drive, but leaves no provision to use two drives with the Kryoflux (it’s not exactly a big loss as the floppy “bus” can only talk to one drive at a time, but may be one way to eliminate plugging and unplugging of drives). Others may have three IDC 34 pin connectors which allow for two drives, but only 3.5″ type as the 5.25″ used edge connectors. The older cables came with 5 connectors total – an edge and a pin connector for both A and B positions and a pin connector for the controller. So if you’re using 5.25″ disks – keep a lookout for these cables.
Finally, it’s time for the power supply. If you’re planning on working with 3.5″ floppies, you can take a shortcut here – I made a cable that converts USB into a floppy Berg power connector (with scraps from dead power supplies and USB cables) with a switch that interrupts only the + lead (and leaves ground continuous). Despite floppy drives claiming to use up to 1A peak, in general, I’ve found all of mine operate off USB ports with this cable satisfactorily. (This also allows me to hit plug and unplug drives if needed, but it can be risky if you’re not careful with power sequencing). Of course, if you do this, it’s at your own risk. But it does make it very convenient for a mobile imaging setup using two USB ports and a laptop. For a 5.25″ drive you can use an external power brick or even your internal computer power supply.
The board itself needs the DTC package to operate which can be downloaded from the Kryoflux website. The package also includes the drivers, schematics, user manual, quick start guide and STREAM format reference. From the DTC package, we have the driver which must be installed first to access the board, and then re-installed once the device has the Kryoflux firmware uploaded to it and warm-reinitialized. On one of my computers with some development software on it, the board was detected as Remote GPS Camera Detect COM port – by overriding the driver, I managed to get it to work with little fuss.
The DTC software can be invoked from the command line for the people who are familiar with it, but for the rest of the users, there is a Java user interface that makes calls to the DTC software. So make sure you’ve installed Java first! This software is also fairly neat that it is easy to use, and gives you access to all the important options while providing some visualization of the read data which can be quite handy in diagnosing when a disk won’t read properly.
The first step of being able to use a floppy drive with the Kryoflux board is to run the calibration. This is a test which attempts to determine the highest track that can be accessed by the particular drive by issuing a certain number of step-forward pulses, and then counting how many steps back are needed until the track zero sensor activates (presumably).
Since I had a stack of floppy drives, I gave them all a go to try and find out exactly what the differences are –
Sony MPF920-1 (Jan 97) 81 tracks
Teac FD-235HF 6291 P/N:19307762-91 (?) 81 tracks
Teac FD-235HF A291 P/N:193077A2-91 (2001) 81 tracks
Ergo MD-21-DS350-B1 81 tracks
Mitsubishi Electric MF355F-3250MG Rev. F (Jan 99) 81 tracks
Sony MPF920 Z/161 (May 05) 83 tracks
Panasonic JU-256A347PC Rev. F (Jun 01) 83 tracks
Panasonic JU-257A606PC K742B 83 tracks
Panasonic JU-257A606PC K930A 83 tracks
Panasonic JU-257A606P N1549 (Dec 99) 83 tracks
Panasonic JU-257A605P F9519 83 tracks
Newtronics Mitsumi D359T3 83 tracks
Samsung SFD-321B/LEA Rev. T4 (2002) 83 tracks
Samsung SFD-321B/KEA Rev. T1 83 tracks
Interestingly, we can generalize that Panasonic, Samsung and Newtronics/Mitsumi drives are the ones capable of accessing 84 tracks (0-83 tracks), whereas the rest are generally 82 tracks (0-81 tracks). Interestingly Sony seems to be in both categories, so it can vary on a revision by revision basis.
If that succeeds, we’re basically ready to go and begin imaging. The device supports imaging to the STREAM format (used by the device to stream the information to the software over USB – a hardware dependent, efficient coding of flux reversal timings) and into various sector formats (useful for emulators and for seeing the recorded binary data when things are format-compliant). You can choose to read to multiple outputs at the same time which serves a good purpose – if you read a known format, the Kryoflux can validate the data for accuracy and detect read errors. Otherwise it just reads the flux as STREAM format – but it doesn’t know if there are problems with what is read.
The flux data is visualized as a scatter plot or as a histogram in the window, and when there are read errors, specific error recovery routines are attempted including stepping back/forward and rezeroing the drive.
There is supposed to be a hardware independent DRAFT format which the flux data can be saved to for later analysis, but this hasn’t materialized yet.
The command line DTC.exe program can be used if you are more advanced or don’t need the visualization shown by the UI. The main benefit is a big reduction in CPU usage – as the Java UI does eat quite a bit of CPU power on my netbook causing streaming errors (which are recovered from by retries, but in essence, the Kryoflux streams the flux data live as it’s being read, so it’s sensitive to timing like video capture – if data isn’t read in time, it can be detected as lost and requires a retry). The other reason one might want to interact with DTC.exe directly is if they want to write Amiga disks – this cannot be accomplished with the GUI as yet.
Versions of the software are available for Mac OS X and Linux, although the majority of the userbase seems to be running on Windows – so the latest versions of the software are typically available for Windows first.
Before I finish, I should probably make a note that the Kryoflux software is made available for non commercial uses only. Commercial use requires negotiation with Kryoflux. The DTC software provides basic imaging, but there are more sophisticated analyzation software which allows one to authenticate the disks as untampered originals and identify “unknown” or “specific special format” tracks and sectors and these are not available to the general public and is very expensive.
So there we are – a look at the hardware. Stay tuned for Part 2 …