robsmithdev/arduinofloppydiskreader

DrawBridge aka Arduino Amiga Floppy Disk Reader/Writer - Hardware and software interface for accessing Amiga disks (read/write ADF and SCP) on non-Amiga hardware

• 👋 Hi, I’m @RobSmithDev
• 👀 I’m interested in Retro (eg: Amiga), Electronics and Software
• 🌱 I’m currently learning Verilog
• 📫 How to reach me: https://robsmithdev.co.uk
• https://youtube.com/c/robsmithdev

arduinofloppydiskreader's Issues

Baud rate not set correctly on macOS Ventura

Thank you for all the effort you put into this repo, it's a really great project!

While trying to use it on my 2017 MacBook Pro (macOS Ventura 13.4.1), I was not able to get the CLI working with my Arduino. The Arduino and the floppy disk drive had been successfully tested using a Windows PC.

I used my scope to check the FTDI TX line and it sends the correct initialization byte sequence, but only at 9600 instead of 2000000 baud. When changing the initialization order inside SerialIO::configurePort() by moving ioctl(m_portHandle, IOSSIOSPEED, &baud) past the call to tcsetattr(), the CLI works as expected.

I prepared a pull request and it would be nice if you could consider merging it.

Inconsistent writing

I've been experimenting with writing disks, with inconsistent results. I'm using a variation of your hardware design using a standalone AVR instead of an arduino, for which I've sent you an email yesterday (please check your spam if you didn't receive it).

The issue I'm encountering is that sometimes I'm writing an ADF, and read it back correctly (diff between the read-back version and the original returns no differences), but when I put the disk in my amiga 500 and run a checkdisk with X-copy it finds a bunch of errors. And indeed sometimes graphics in games I've written this way are corrupted, or they failed to run at all.
To make sure the disks are not the issue, I try to transfer the same ADF file to the same disk through a serial cable with transwarp, and there are no errors.

The floppy drive I'm using in conjunction with the AVR hardware is a regular PC floppy drive (mitsumi d359m3d) which is naturally an HD drive. Might this be a problem of insufficient magnetization by the PC drive? The floppies I'm using are DD, so the drive should be able to detect that and change the flux if such a thing is necessary I guess. I have not so far tried connecting the internal amiga drive to the AVR to see if it makes any difference.

Any ideas ?

Question-WD1793FDC compatible use?

This is not really a issue, but more of a question.

With the code you have here for working with Amiga disks. How hard would it be to modify the code to work with floppy disks that were formatted by WD1793FDC's?

The reason I ask is that I am trying to find a way to read and write to old Tandy/TRS-80 Color Computer floppy disks. This includes both the 250Kbps mode of 5.25"/3.5" and the 8" 500Kbps drives. The default sector size is 256 Bytes.

Thanks for any information you might have on this crazy question.

Write errors in first sectors

On a PCB I built (which I can share the schematic and pcb) (no additional ftdi if using a CH340 based nano clone) I see that event though test are passing and write shows success (on a write and verify scenario) when reading the written disk, first sector tend to be not properly written.
Wiring and power are ok, FFD and disk are not a known good since I dont have other systems to try it.

BTW I tested with the pre built windows executable.

Writting .d81 files

Hi Rob,

I have seen the linked repo: https://github.com/hpingel/pyAccess1581 but can only see read usages there and was wondering if your repo has support for writing d81 image files to a disk in the 1581 supported format or if i need to be making a request on that repo for writing 1581.

Thanks for writing this software and hardware combination,

Thanks,
Russell

Porting to RaspberryPi

Hi, I would like to implement this feature in RaspberryPi. I am thinking, that I would port the arduino part to bare c/c++ and use linux scripts. My questions are:

• didn't somebody already do that?
• Is there something I should pay extra attention to?
• Would you suggest some particular steps?

BTW this project is awesome. Thank you for great comments and documentation.

Reading NEC 765-style (double density, MFM, "360KB") floppies

Further to #1 and #3, I'm wondering if it would be possible to adapt this project to read 5.25" double density ("360KB"-ish) floppies, originally written via NEC 765 (original IBM PC-style) floppy controller, in a track-at-once mode?

As far as I can tell, the Amiga floppies the code currently reads are 3.5" double density floppies, written with a custom floppy controller (ie, part of the Amiga chipset, rather than a third party "floppy controller" chip like the NEC 765). These seem to be MFM encoded ("double density"), 8x track, double sided, 3.5" floppies, spun at 300rpm. And it appears that the Amiga always wrote them in "track at once" mode, which allowed omitting inter-sector gaps and thus fitting 11 * 512 byte sectors onto the track (versus the 9, or perhaps 10, possible with a NEC 765 style controller that tried to update individual sectors in place). Giving a total capacity of 880KiB (80 * 11 * 2 * 512 bytes) or so.

5.25" double density is also MFM encoded, onto floppies spun at 300rpm, and either single or double sided, with usually 4x tracks per side. These figures seem relatively close to what the code already supports (and track stepping is already independent of reading the track). As best I can remember/find out, 5.25" double density drives using MFM encoding had a data rate of 250Kbps, as discussed in #1, which means the bit rate might need changing.

This HxC thread seems to suggest the Amiga bit rate was close to 250Kbps but slightly different (the same thread suggests PC double density fits 12500 +/- 0.5% bits per track, just slightly less than the Amiga).

But I see in #1 you suggest the Amiga bit rate was 300Kbps? Do you happen to remember where you got the 300Kbps figure from? (It's fine if it was just off the top of your head; just trying to figure out how much the timing constants might need tweaking.)

There seem to be some magic values in the read code, which I'm guessing are related to the data rate coming in. Do you have any notes on how those values were calculated? And/or any other raw media bit rates values in the code to look out for (timer programming values)?

My thought here is that maybe it would be possible to read (I have no interest in writing) non-Amiga disks simply by stepping to the right track, doing a raw track media read with "read track" and then decoding both the MFM encoding and the sector data from the track bits on the PC side later. Does that sound plausible? From memory the NEC 765 style controllers write sector preambles and other framing that one can search for to locate the sectors out of the track bits, so I'm assuming given a MFM-transition timing accurate media bit rate read of the track data it should in theory be "just a matter of programming" to decode the sectors out of the MFM data, and put it into some suitable (existing) container format.

Does this sound plausible to you?

Thanks in advance,

Ewen

Linux capsimage segfault

when trying to use drawbridge with capsimage.so.5 on linux (gentoo linux) the programm segfaults

[195963.033547] drawbridge[1328066]: segfault at 5607833e35ef ip 00007f46bdbefbe8 sp 00007ffdd58f16b0 error 4 in libcapsimage.so.5.1[7f46bdbec000+e000] likely on CPU 2 (core 2, socket 0) [195963.033558] Code: 66 90 55 53 48 83 ec 08 48 8d 05 a3 19 01 00 48 8b 18 48 8b 68 08 48 39 dd 74 25 0f 1f 80 00 00 00 00 48 8b 3b 48 85 ff 74 06 <48> 8b 07 ff 50 08 48 c7 03 00 00 00 00 48 83 c3 08 48 39 dd

Sucessfully read ATARI ST DD Disks (720 MBytes, 820 mBytes, 930 MBytes )

Just as a feedback: I have rebuilt the project with an Arduino Nano, using the builtin ttyUSB it offers. It worked. I could read complete Tracks information from my old ATARI ST disks. I have written a script (for linux) to extrackt the sectors from the tracks and also to check the integrity of the data (using CRC16 checks). This way, I was able to write Disk.img files which can be simply mounted with the standard Linux command "mount" (using the FAT file system driver). The surprise: I could even produce images from disks with uncommon formats (10, or 11 sectors per track, instead of 9), which I could not even produce in the early days (2002) with a buildin PC floppy drive. Great!

However, I like also to read 1.4MBytes HD disks, since I think the modification to the Arduinos firmware would be minimal.

Take this as an improvement proposal:

1. In the diagnostics code, measure the timings of the read bits to determine if it is a DD or HD disk.
2. Allow a Setting: DD or HD.
3. Apply different timing boundaries cuts/checks for DD and HD disks, and adjust the amount of data per track which need to be read. (80/111 for SD and DD, 40/55 for HD)

That already would be all (for reading). This way, also standard PC-Floppies could be read. And then this would be an universal floppy controller for (nearly) all existing formats.

Broken access on Linux - firmware 1.8

Using command-line ArduinoReaderWriter to read a fully-functional floppy (I tried with several floppies, successfully dumped on Windows), the process does not even start, with an error of Disk has checksum errors/mssing data.

I tried several Linux machines and several floppies, with the same result.

With Windows it works.

Here is a video:

Firmware version is 1.8:

Using Arduino Duemilanove with on-board USB UART (FT232RL) for read-only?

This looks like a real exciting project, and I'm considering trying to adapt it for my (non-Amiga) use case.

Could you clarify the Arduino hardware requirements a little further for me? In particular I happen to have a AT Mega 328-based Arduino Duemilanove board here already which I'm wondering if I can use "as is" (the early Duemilanove boards came with a AT Mega 168, but later ones were 328-based, and mine has a sticker staying AT Mega 328; according to the Arduino website it's an AT Mega 328P). It looks like the Arduino Uno is also AT Mega 328P based.

As best I can tell your project needs:

• AT Mega 328P-based Arduino (eg, 2KB RAM) or bigger

• 16MHz clock (for the timing loops)

• USB-serial capable of 2Mbps on standard Arduino TX/RX pins

• For write support only (which I don't need), wired access to control the CTS serial line to slow down PC host from sending data, eg via using an external USB/serial module with a CTS line

The Arduino Duemilanove board has a FTDI FT232RL onboard, which seems to be capable of 2Mbps serial. Is this likely to be sufficient for read-only purposes? (AFAICT CTS is just grounded on the Duemilanove onboard USB-serial, so I'm assuming write support is a no go without an external USB-serial device.)

AFAICT the Arduino Uno does not have a FT232RL on it; instead programming seems to be via a smaller AT Mega device, which presumably has its own serial IO implementation. I'm not sure if that one will do 2Mbps?

Can you clarify if an external USB-serial device is needed even for read-only access? (AFAICT many of those external USB-serial, eg, PMOD, devices are using, eg, FT232RL or similar).

Thanks,

Ewen

Linux compile does not work OOTB with latest desktop ubuntu

1. download codebase onto an ubuntu latest desktop for intel git clone https://github.com/RobSmithDev/ArduinoFloppyDiskReader.git
2. cd ArduinoFloppyDiskReader/ArduinoFloppyReader/ArduinoFloppyReader
3. make

Returns the following output:

/ArduinoFloppyDiskReader/ArduinoFloppyReader/ArduinoFloppyReader$ make 
g++ -Wall -std=c++14 -Wno-psabi -O3 -pthread -I../lib -o drawbridge Main.cpp ../lib/ftdi.cpp ../lib/SerialIO.cpp ../lib/RotationExtractor.cpp ../lib/pll.cpp ../lib/ArduinoInterface.cpp ../lib/ADFWriter.cpp ../lib/capsapi/CapsPlug.cpp -L../lib -ldl
Main.cpp: In function ‘void listSettings(const std::wstring&)’:
Main.cpp:137:23: warning: format not a string literal and no format arguments [-Wformat-security]
  137 |                 printf(io.getLastErrorStr().c_str());
      |                 ~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp: In function ‘void programmeSetting(const std::wstring&, const std::wstring&, bool)’:
Main.cpp:156:23: warning: format not a string literal and no format arguments [-Wformat-security]
  156 |                 printf(io.getLastErrorStr().c_str());
      |                 ~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In file included from ../lib/SerialIO.cpp:70:
/usr/include/unistd.h:1076:20: error: ‘intptr_t’ was not declared in this scope; did you mean ‘FTDI::intptr_t’?
 1076 | extern void *sbrk (intptr_t __delta) __THROW;
      |                    ^~~~~~~~
      |                    FTDI::intptr_t
In file included from /usr/lib/gcc/x86_64-linux-gnu/13/include/stdint.h:9,
                 from ../lib/ftdi.h:39,
                 from ../lib/SerialIO.h:41,
                 from ../lib/SerialIO.cpp:30:
/usr/include/stdint.h:87:33: note: ‘FTDI::intptr_t’ declared here
   87 | typedef long int                intptr_t;
      |                                 ^~~~~~~~
../lib/SerialIO.cpp: In member function ‘bool SerialIO::getCTSStatus()’:
../lib/ftdi.h:47:15: error: ‘uint32_t’ was not declared in this scope; did you mean ‘FTDI::uint32_t’?
   47 | #define ULONG uint32_t
      |               ^~~~~~~~
../lib/SerialIO.cpp:180:17: note: in expansion of macro ‘ULONG’
  180 |                 ULONG status;
      |                 ^~~~~
In file included from /usr/include/stdint.h:37:
/usr/include/x86_64-linux-gnu/bits/stdint-uintn.h:26:20: note: ‘FTDI::uint32_t’ declared here
   26 | typedef __uint32_t uint32_t;
      |                    ^~~~~~~~
../lib/SerialIO.cpp:181:47: error: ‘status’ was not declared in this scope; did you mean ‘statx’?
  181 |                 if (m_ftdi.FT_GetModemStatus(&status) != FTDI::FT_STATUS::FT_OK) return false;
      |                                               ^~~~~~
      |                                               statx
../lib/SerialIO.cpp:182:25: error: ‘status’ was not declared in this scope; did you mean ‘statx’?
  182 |                 return (status & FT_MODEM_STATUS_CTS) != 0;
      |                         ^~~~~~
      |                         statx
../lib/SerialIO.cpp: In static member function ‘static void SerialIO::enumSerialPorts(std::vector<SerialPortInformation>&)’:
../lib/ftdi.h:41:15: error: ‘uint32_t’ was not declared in this scope; did you mean ‘FTDI::uint32_t’?
   41 | #define DWORD uint32_t
      |               ^~~~~~~~
../lib/SerialIO.cpp:205:9: note: in expansion of macro ‘DWORD’
  205 |         DWORD numDevs;
      |         ^~~~~
/usr/include/x86_64-linux-gnu/bits/stdint-uintn.h:26:20: note: ‘FTDI::uint32_t’ declared here
   26 | typedef __uint32_t uint32_t;
      |                    ^~~~~~~~
../lib/SerialIO.cpp:207:64: error: ‘numDevs’ was not declared in this scope
  207 |         FTDI::FT_STATUS status = ftdi.FT_CreateDeviceInfoList(&numDevs);
      |                                                                ^~~~~~~
../lib/SerialIO.cpp: In member function ‘bool SerialIO::checkForOverrun()’:
../lib/ftdi.h:47:15: error: ‘uint32_t’ was not declared in this scope; did you mean ‘FTDI::uint32_t’?
   47 | #define ULONG uint32_t
      |               ^~~~~~~~
../lib/SerialIO.cpp:699:17: note: in expansion of macro ‘ULONG’
  699 |                 ULONG status;
      |                 ^~~~~
/usr/include/x86_64-linux-gnu/bits/stdint-uintn.h:26:20: note: ‘FTDI::uint32_t’ declared here
   26 | typedef __uint32_t uint32_t;
      |                    ^~~~~~~~
../lib/SerialIO.cpp:700:47: error: ‘status’ was not declared in this scope; did you mean ‘statx’?
  700 |                 if (m_ftdi.FT_GetModemStatus(&status) != FTDI::FT_STATUS::FT_OK) return false;
      |                                               ^~~~~~
      |                                               statx
../lib/SerialIO.cpp:701:25: error: ‘status’ was not declared in this scope; did you mean ‘statx’?
  701 |                 return (status & (FT_MODEM_STATUS_OE | FT_MODEM_STATUS_FE)) != 0;
      |                         ^~~~~~
      |                         statx
../lib/SerialIO.cpp: In member function ‘unsigned int SerialIO::getBytesWaiting()’:
../lib/ftdi.h:41:15: error: ‘uint32_t’ was not declared in this scope; did you mean ‘FTDI::uint32_t’?
   41 | #define DWORD uint32_t
      |               ^~~~~~~~
../lib/SerialIO.cpp:722:17: note: in expansion of macro ‘DWORD’
  722 |                 DWORD queueSize = 0;
      |                 ^~~~~
/usr/include/x86_64-linux-gnu/bits/stdint-uintn.h:26:20: note: ‘FTDI::uint32_t’ declared here
   26 | typedef __uint32_t uint32_t;
      |                    ^~~~~~~~
../lib/SerialIO.cpp:723:47: error: ‘queueSize’ was not declared in this scope
  723 |                 if (m_ftdi.FT_GetQueueStatus(&queueSize) != FTDI::FT_STATUS::FT_OK) return 0;
      |                                               ^~~~~~~~~
../lib/SerialIO.cpp:724:24: error: ‘queueSize’ was not declared in this scope
  724 |                 return queueSize;
      |                        ^~~~~~~~~
../lib/SerialIO.cpp: In member function ‘unsigned int SerialIO::write(const void*, unsigned int)’:
../lib/ftdi.h:41:15: error: ‘uint32_t’ was not declared in this scope; did you mean ‘FTDI::uint32_t’?
   41 | #define DWORD uint32_t
      |               ^~~~~~~~
../lib/SerialIO.cpp:751:17: note: in expansion of macro ‘DWORD’
  751 |                 DWORD written = 0;
      |                 ^~~~~
/usr/include/x86_64-linux-gnu/bits/stdint-uintn.h:26:20: note: ‘FTDI::uint32_t’ declared here
   26 | typedef __uint32_t uint32_t;
      |                    ^~~~~~~~
../lib/SerialIO.cpp:752:64: error: ‘written’ was not declared in this scope; did you mean ‘write’?
  752 |                 if (m_ftdi.FT_Write((LPVOID)data, dataLength, &written) != FTDI::FT_STATUS::FT_OK) written = 0;
      |                                                                ^~~~~~~
      |                                                                write
../lib/SerialIO.cpp:753:24: error: ‘written’ was not declared in this scope; did you mean ‘write’?
  753 |                 return written;
      |                        ^~~~~~~
      |                        write
../lib/SerialIO.cpp: In member function ‘unsigned int SerialIO::justRead(void*, unsigned int)’:
../lib/ftdi.h:41:15: error: ‘uint32_t’ was not declared in this scope; did you mean ‘FTDI::uint32_t’?
   41 | #define DWORD uint32_t
      |               ^~~~~~~~
../lib/SerialIO.cpp:811:17: note: in expansion of macro ‘DWORD’
  811 |                 DWORD dataRead = 0;
      |                 ^~~~~
/usr/include/x86_64-linux-gnu/bits/stdint-uintn.h:26:20: note: ‘FTDI::uint32_t’ declared here
   26 | typedef __uint32_t uint32_t;
      |                    ^~~~~~~~
../lib/SerialIO.cpp:812:63: error: ‘dataRead’ was not declared in this scope
  812 |                 if (m_ftdi.FT_Read((LPVOID)data, dataLength, &dataRead) != FTDI::FT_STATUS::FT_OK) dataRead = 0;
      |                                                               ^~~~~~~~
../lib/SerialIO.cpp:813:24: error: ‘dataRead’ was not declared in this scope
  813 |                 return dataRead;
      |                        ^~~~~~~~
../lib/SerialIO.cpp: In member function ‘unsigned int SerialIO::read(void*, unsigned int)’:
../lib/ftdi.h:41:15: error: ‘uint32_t’ was not declared in this scope; did you mean ‘FTDI::uint32_t’?
   41 | #define DWORD uint32_t
      |               ^~~~~~~~
../lib/SerialIO.cpp:845:17: note: in expansion of macro ‘DWORD’
  845 |                 DWORD dataRead = 0;
      |                 ^~~~~
/usr/include/x86_64-linux-gnu/bits/stdint-uintn.h:26:20: note: ‘FTDI::uint32_t’ declared here
   26 | typedef __uint32_t uint32_t;
      |                    ^~~~~~~~
../lib/SerialIO.cpp:846:63: error: ‘dataRead’ was not declared in this scope
  846 |                 if (m_ftdi.FT_Read((LPVOID)data, dataLength, &dataRead) != FTDI::FT_STATUS::FT_OK) dataRead = 0;
      |                                                               ^~~~~~~~
../lib/SerialIO.cpp:847:24: error: ‘dataRead’ was not declared in this scope
  847 |                 return dataRead;
      |                        ^~~~~~~~
make: *** [makefile:56: drawbridge] Error 1

This looks like one or more libraries are not installed right.

I just don't know what to do.

It does not run under WindowsXP

Launching the EXE file, this dialog is raised:

("it's not a valid Win32 application")

Created Python scripts to read IBM/DOS/Commodore 1581 via ArduinoReader

Hi Robert,

Nothing new for you but maybe of interest for other people browsing the issues:

https://github.com/hpingel/pyAccess1581

Cheers,
H.

Ported the sketch to work with Arduino Pro Micro (Atmega32U4, 5V, 16Mhz)

Hi Robert,

Thank you for your work on this and sharing the project as open source software! Greatly appreciated! I built your project last weekend on a breadboard. I only had an Arduino Pro Micro at hand + a FTDI thingy. As the Pro Micro differs from the Pro Mini I wasn't sure if I could make it work.

Long story short: By changing some defines in your sketch I am able to run the software on an Arduino Pro Micro 5V 16Mhz. The Pro Micro has it's own USB port but this is currently unused as the communication to the PC goes via FTDI.

If you are interested I can share my code changes. I was wondering if there would be any way to use the Pro Micro without the FTDI dongle in future. But I don't know where the CTS pin would end up.

Cheers,
Henning

Checksum errors while reading

I found two old Amiga diskettes from 1996 :) I created two games at that time :)
So I wanted to see how the games work and came up at this solution with Arduino.
After ordering all componets and soldering wires I had problem with power supply for the floppy drive and decided to replace it with cell phone charger where I have measured 5.12V.
Diagnostics went fine. At least reading. I didn't test writting because I don't want to destroy my floppies and I don't have any extra.
After clicking on Copy Disk the floppy drive LED turn on but everything stops at Current Track: 1 Current Side: Lower with error message: Disk has checksum errors/missing/damaged data.
After making few minutes break and tried again it stops at track 2 lower.
Clicking on Retry do not help.
I tried both diskettes and the problem is the same.
Any ideas what can I try to read those diskettes?

Visual Studio 2019

Hi,

Was wanting to compile and take a closer look at your code in Visual Studio 2019. However, the project is 2017 ... I have tried changing the version in VS Studio / properties and selecting 2019 / and selecting the latest SDK ... but when I compile, I get a lot of warnings / missing SDK Spectar etc.

If you have a bit of time / free weekend / bored ... would you be able to take a look?

Cheers

BBC Micro - floppy drive

Any clue if this would work for a 5.1/4 floppy drive for the BBC Micro? I initially focused on getting the machine back up and running, since it now boots I want to backup/dump the floppies first. The floppy drive I have has a card edge style 34 pin connector with MOLEX (not MOLEX Berg) for power.

Writing doesn't work for me

Unfortunately I never managed to get floppy disk writing to work. I always get: "An unknown response was received from the Arduino while executing the WriteTrack command". I would be glad if someone could help me here. I tried to contact Rob via hackster.io but without response.

I tried multiple PCs, FTDI boards and Floppy Disk Drives.

Original message on hackster was:

"Hello Robert!

I built your Amiga Floppy Disk Reader/Writer. First thank you very much for your great work engineering it :)

Unfortunately I cannot write to disks. Every else seems to work but I can't actually ready disks w/o checksum errors as I don't have a single Amiga Floppy - I built the thing to write them.

The Diagnostics runs fine until it comes to writing. Then I get the message "An unknown response was received from the Arduino while executing the WriteTrack command". Same message when I try to write an ADF to the Disk (no matter if erase or verify is on or off).

I read that it often has to do with the CTS line, but I checked it multiple times and the connection from the FTDI to the Arduino is solid. What did work: I once connected the CTS line to Arduino A3 instead of A2 (A3 is unused) and adjusted the sketch accordingly. Strange thing: In diagnostics mode I got a CTS error, but writing without verifying worked for the first time! But the disk was not readable on the Amiga.

Do you have any tips for me to get it working? I spent hours finding the error. Should I try other FTDI boards? Here you can see pictures of the current board and setup:

https://ibb.co/hYszUz
https://ibb.co/ngP2hK

Thank you very much!

PS: I tried different USB ports (without HUB), Floppy is a Mitsumi, Cable is 10-15cm, I use an additional 5V power supply, voltage is stable also when the motor starts spinning."