Erase track before writing - fixes checksum errors

RobSmithDev · RobSmithDev · commit 2ba438a3237c · 2018-03-27T16:49:01.000+01:00
diff --git a/ArduinoFloppyReader/ArduinoFloppyReader/Main.cpp b/ArduinoFloppyReader/ArduinoFloppyReader/Main.cpp
@@ -37,7 +37,7 @@ void adf2Disk(wchar_t* argv[], bool verify) {
 	printf("\nWrite disk from ADF mode\n\n");
 	if (!verify) printf("WARNING: It is STRONGLY recommended to write with verify support turned on.\r\n\r\n");
 
-	ADFResult result = writer.ADFToDisk(argv[2],verify, [](const int currentTrack, const DiskSurface currentSide, bool isVerifyError) ->WriteResponse {
+	ADFResult result = writer.ADFToDisk(argv[2],true, verify, [](const int currentTrack, const DiskSurface currentSide, bool isVerifyError) ->WriteResponse {
 		if (isVerifyError) {
 			char input;
 			do {
diff --git a/ArduinoFloppyReader/ArduinoFloppyReaderWin/ArduinoFloppyReaderWin.aps b/ArduinoFloppyReader/ArduinoFloppyReaderWin/ArduinoFloppyReaderWin.aps
diff --git a/ArduinoFloppyReader/ArduinoFloppyReaderWin/ArduinoFloppyReaderWin.rc b/ArduinoFloppyReader/ArduinoFloppyReaderWin/ArduinoFloppyReaderWin.rc
diff --git a/ArduinoFloppyReader/ArduinoFloppyReaderWin/ArduinoFloppyReaderWinDlg.cpp b/ArduinoFloppyReader/ArduinoFloppyReaderWin/ArduinoFloppyReaderWinDlg.cpp
@@ -279,6 +279,7 @@ void CArduinoFloppyReaderWinDlg::DoDataExchange(CDataExchange* pDX)
 	DDX_Control(pDX, IDC_STARTSTOP2, m_writeButton);
 	DDX_Control(pDX, IDC_CHECK1, m_verify);
 	DDX_Control(pDX, IDC_STARTSTOP3, m_diagnostics);
+	DDX_Control(pDX, IDC_ERASE, m_erase);
 }
 
 BEGIN_MESSAGE_MAP(CArduinoFloppyReaderWinDlg, CDialogEx)
@@ -351,6 +352,7 @@ BOOL CArduinoFloppyReaderWinDlg::OnInitDialog()
 	}
 	m_spinner.SetRange(1, 999);
 	m_verify.SetCheck(TRUE);
+	m_erase.SetCheck(TRUE);
 
 	return TRUE;  // return TRUE  unless you set the focus to a control
 }
@@ -509,7 +511,7 @@ bool CArduinoFloppyReaderWinDlg::runThreadWrite() {
 
 	m_inputADF.GetWindowText(filename);
 	
-	ArduinoFloppyReader::ADFResult readerResult = writer.ADFToDisk(filename.GetBuffer(), m_verify.GetCheck()!=0,
+	ArduinoFloppyReader::ADFResult readerResult = writer.ADFToDisk(filename.GetBuffer(), m_erase.GetCheck()!=0, m_verify.GetCheck()!=0,
 		[this](const int currentTrack, const ArduinoFloppyReader::DiskSurface currentSide, const bool isVerifyError) -> ArduinoFloppyReader::WriteResponse {
 
 		if (m_cancelButtonPressed) return ArduinoFloppyReader::WriteResponse::wrAbort;
@@ -570,6 +572,7 @@ void CArduinoFloppyReaderWinDlg::enableDialog(bool enable) {
 	m_inputADF.EnableWindow(enable);
 	m_comport.EnableWindow(enable);
 	m_verify.EnableWindow(enable);
+	m_erase.EnableWindow(enable);
 	m_diagnostics.EnableWindow(enable);
 
 	if (enable) {
diff --git a/ArduinoFloppyReader/ArduinoFloppyReaderWin/ArduinoFloppyReaderWinDlg.h b/ArduinoFloppyReader/ArduinoFloppyReaderWin/ArduinoFloppyReaderWinDlg.h
@@ -91,4 +91,5 @@ class CArduinoFloppyReaderWinDlg : public CDialogEx
 	void saveComPort();
 	afx_msg void OnBnClickedStartstop3();
 	CButton m_diagnostics;
+	CButton m_erase;
 };
diff --git a/ArduinoFloppyReader/ArduinoFloppyReaderWin/resource.h b/ArduinoFloppyReader/ArduinoFloppyReaderWin/resource.h
diff --git a/ArduinoFloppyReader/lib/ADFWriter.cpp b/ArduinoFloppyReader/lib/ADFWriter.cpp
@@ -52,7 +52,6 @@ using namespace ArduinoFloppyReader;
 #define NUM_SECTORS_PER_TRACK 11						 // Number of sectors per track
 #define RAW_SECTOR_SIZE (8+56+SECTOR_BYTES+SECTOR_BYTES)      // Size of a sector, *Including* the sector sync word longs
 #define ADF_TRACK_SIZE (SECTOR_BYTES*NUM_SECTORS_PER_TRACK)   // Bytes required for a single track
-#define TRACK_FILLER_SIZE 256                                 // Theritically this would be 532 bytes, but if the disk spins slower or fast this would be wrong
 
 
 const char* TEST_BYTE_SEQUENCE = "amiga.robsmithdev.co.uk";
@@ -67,7 +66,7 @@ typedef struct alignas(8) {
 	// Raw sector data
 	RawEncodedSector sectors[NUM_SECTORS_PER_TRACK];
 	// Blank "Filler" gap content. (this may get overwritten by the sectors a little)
-	unsigned char filler2[TRACK_FILLER_SIZE];
+	unsigned char filler2[8];
 } FullDiskTrack;
 
 // Structure to hold data while we decode it
@@ -877,7 +876,7 @@ bool ADFWriter::runDiagnostics(const unsigned int comPort, std::function<void(bo
 
 
 // Writes an ADF file back to a floppy disk.  Return FALSE in the callback to abort this operation 
-ADFResult ADFWriter::ADFToDisk(const std::wstring inputFile, bool verify, std::function < WriteResponse(const int currentTrack, const DiskSurface currentSide, const bool isVerifyError) > callback) {
+ADFResult ADFWriter::ADFToDisk(const std::wstring inputFile, bool eraseFirst, bool verify, std::function < WriteResponse(const int currentTrack, const DiskSurface currentSide, const bool isVerifyError) > callback) {
 	if (!m_device.isOpen()) return ADFResult::adfrDriveError;
 
 	// Upgrade to writing mode
@@ -935,7 +934,13 @@ ADFResult ADFWriter::ADFToDisk(const std::wstring inputFile, bool verify, std::f
 		for (unsigned int a = 0; a < NUM_SECTORS_PER_TRACK; a++) trackRead.invalidSectors[a].clear();
 
 		int failCount = 0;
-		while ((verify) && (trackRead.validSectors.size()<NUM_SECTORS_PER_TRACK)) {
+		while (trackRead.validSectors.size()<NUM_SECTORS_PER_TRACK) {
+
+			if (eraseFirst) {
+				if (m_device.eraseCurrentTrack() != DiagnosticResponse::drOK)
+					return adfrDriveError;
+			}
+
 			switch (m_device.writeCurrentTrack((const unsigned char*)(&disktrack), sizeof(disktrack), false)) {
 			case DiagnosticResponse::drWriteProtected: CloseHandle(hADFFile);
 							return ADFResult::adfrDiskWriteProtected;
@@ -996,6 +1001,7 @@ ADFResult ADFWriter::ADFToDisk(const std::wstring inputFile, bool verify, std::f
 					}
 				}
 			}
+			else break;
 		}
 
 
diff --git a/ArduinoFloppyReader/lib/ADFWriter.h b/ArduinoFloppyReader/lib/ADFWriter.h
@@ -84,7 +84,7 @@ namespace ArduinoFloppyReader {
 		ADFResult DiskToADF(const std::wstring outputFile, const unsigned int numTracks, std::function < WriteResponse(const int currentTrack, const DiskSurface currentSide, const int retryCounter, const int sectorsFound, const int badSectorsFound)> callback);
 
 		// Writes an ADF file back to a floppy disk.  Return FALSE in the callback to abort this operation.  If verify is set then the track isread back and and sector checksums are checked for 11 valid sectors
-		ADFResult ADFToDisk(const std::wstring inputFile, bool verify, std::function < WriteResponse(const int currentTrack, const DiskSurface currentSide, const bool isVerifyError) > callback);
+		ADFResult ADFToDisk(const std::wstring inputFile, bool eraseFirst, bool verify, std::function < WriteResponse(const int currentTrack, const DiskSurface currentSide, const bool isVerifyError) > callback);
 	
 		// Run diagnostics on the system.  You do not need to call openDevice first.  Return TURE if everything passed
 		bool runDiagnostics(const unsigned int comPort, std::function<void(bool isError, const std::string message)> messageOutput, std::function<bool(bool isQuestion, const std::string question)> askQuestion);
diff --git a/ArduinoFloppyReader/lib/ArduinoInterface.cpp b/ArduinoFloppyReader/lib/ArduinoInterface.cpp
@@ -44,6 +44,7 @@ using namespace ArduinoFloppyReader;
 #define COMMAND_DISABLE            '-'
 #define COMMAND_WRITETRACK         '>'
 #define COMMAND_ENABLEWRITE        '~'
+#define COMMAND_ERASETRACK         'X'
 #define COMMAND_DIAGNOSTICS        '&'
 
 
@@ -61,6 +62,7 @@ std::string lastCommandToName(LastCommand cmd) {
 	case lcReadTrack:		return "ReadTrack";
 	case lcWriteTrack:		return "WriteTrack";
 	case lcRunDiagnostics:	return "RunDiagnostics";
+	case lcEraseTrack:		return "EraseTrack";
 	default:				return "Unknown";
 	}
 }
@@ -581,6 +583,50 @@ DiagnosticResponse ArduinoInterface::readCurrentTrack(RawTrackData& trackData, c
 	return m_lastError;
 }
 
+// Asks the Arduino to wipe the current track
+DiagnosticResponse ArduinoInterface::eraseCurrentTrack() {
+	m_lastError = runCommand(COMMAND_ERASETRACK);
+	if (m_lastError != DiagnosticResponse::drOK) {
+		m_lastCommand = lcEraseTrack;
+		return m_lastError;
+	}
+
+	unsigned char chr;
+	if (!deviceRead(&chr, 1)) {
+		m_lastCommand = lcEraseTrack;
+		m_lastError = DiagnosticResponse::drReadResponseFailed;
+		return m_lastError;
+	}
+
+	// 'N' means NO Writing, aka write protected
+	if (chr == 'N') {
+		m_lastCommand = lcEraseTrack;
+		m_lastError = DiagnosticResponse::drWriteProtected;
+		return m_lastError;
+	}
+	if (chr != 'Y') {
+		m_lastCommand = lcEraseTrack;
+		m_lastError = DiagnosticResponse::drStatusError;
+		return m_lastError;
+	}
+
+	unsigned char response;
+	if (!deviceRead(&response, 1)) {
+		m_lastCommand = lcEraseTrack;
+		m_lastError = DiagnosticResponse::drReadResponseFailed;
+		return m_lastError;
+	}
+	// If this is a '1' then the Arduino erased the track
+	if (response != '1') {
+		m_lastCommand = lcEraseTrack;
+		m_lastError = DiagnosticResponse::drStatusError;
+		return m_lastError;
+	}
+
+	m_lastError = DiagnosticResponse::drOK;
+	return m_lastError;
+}
+
 // Writes RAW data onto the current track
 DiagnosticResponse ArduinoInterface::writeCurrentTrack(const unsigned char* data, const unsigned short numBytes, const bool writeFromIndexPulse) {
 	m_lastError = runCommand(COMMAND_WRITETRACK);
diff --git a/ArduinoFloppyReader/lib/ArduinoInterface.h b/ArduinoFloppyReader/lib/ArduinoInterface.h
@@ -107,6 +107,7 @@ namespace ArduinoFloppyReader {
 		lcSelectSurface,
 		lcReadTrack,
 		lcWriteTrack,
+		lcEraseTrack,
 		lcRunDiagnostics
 	};
 
@@ -176,6 +177,9 @@ namespace ArduinoFloppyReader {
 		// Attempts to write a sector back to the disk.  This must be pre-formatted and MFM encoded correctly
 		DiagnosticResponse  writeCurrentTrack(const unsigned char*, const unsigned short numBytes, const bool writeFromIndexPulse);
 
+		// Asks the Arduino to wipe the current track, filling it with the 0xAA pattern
+		DiagnosticResponse eraseCurrentTrack();
+
 		// Check CTS status 
 		DiagnosticResponse testCTS(const unsigned int portNumber);
 
diff --git a/FloppyDriveController.sketch/FloppyDriveController.sketch.ino b/FloppyDriveController.sketch/FloppyDriveController.sketch.ino
@@ -424,8 +424,9 @@ void writeTrackFromUART() {
         serialBytesInUse--;
 
         
-        // Theres a small possability, looking at the decompiled ASM (and less likely even with these few extra instructions) we actually might get back here before the TCNT2 overflows back to zero causing this to write early
+        // Theres a small possibility, looking at the decompiled ASM (and less likely even with these few extra instructions) we actually might get back here before the TCNT2 overflows back to zero causing this to write early
         while (TCNT2>=240) {}
+		
         // Now we write the data.  Hopefully by the time we get back to the top everything is ready again
         WRITE_BIT(0x10,B10000000);
         CHECK_SERIAL();
@@ -443,6 +444,59 @@ void writeTrackFromUART() {
         CHECK_SERIAL();
         WRITE_BIT(0xF0,B00000001);
     }  
+	
+	// Turn off the write head
+    PIN_WRITE_GATE_PORT|=PIN_WRITE_GATE_MASK;
+
+    // Done!
+    writeByteToUART('1');
+    digitalWrite(PIN_ACTIVITY_LED,LOW);
+    
+    // Disable the 500khz signal
+    TCCR2B = 0;   // No Clock (turn off)    
+}
+
+
+
+
+// Write a track to disk from the UART - the data should be pre-MFM encoded raw track data where '1's are the pulses/phase reversals to trigger
+void eraseTrack() {
+    // Configure timer 2 just as a counter in NORMAL mode
+    TCCR2A = 0 ;              // No physical output port pins and normal operation
+    TCCR2B = bit(CS20);       // Precale = 1  
+    
+    // Check if its write protected.  You can only do this after the write gate has been pulled low
+    if (digitalRead(PIN_WRITE_PROTECTED) == LOW) {
+        writeByteToUART('N'); 
+        digitalWrite(PIN_WRITE_GATE,HIGH);
+        return;
+    } else writeByteToUART('Y');
+    
+    register unsigned char currentByte;
+
+    digitalWrite(PIN_ACTIVITY_LED,HIGH);
+   
+    // Enable writing
+    PIN_WRITE_GATE_PORT&=~PIN_WRITE_GATE_MASK;
+
+    // Reset the counter, ready for writing
+    TCNT2=0;  
+    currentByte = 0xAA;
+
+    // Write complete blank track - at 300rpm, 500kbps, a track takes approx 1/5 second to write.  This is roughly 12500 bytes.  Our RAW read is 13888 bytes, so we'll use that just to make sure we get every last bit.
+    for (register unsigned int counter=0; counter<RAW_TRACKDATA_LENGTH; counter++) {
+        WRITE_BIT(0x10,B10000000);
+        WRITE_BIT(0x30,B01000000);
+        WRITE_BIT(0x50,B00100000);
+        WRITE_BIT(0x70,B00010000);
+        WRITE_BIT(0x90,B00001000);
+        WRITE_BIT(0xB0,B00000100);
+        WRITE_BIT(0xD0,B00000010);
+        WRITE_BIT(0xF0,B00000001);
+        while (TCNT2>=240) {}
+    }  
+  
+    // Turn off the write head
     PIN_WRITE_GATE_PORT|=PIN_WRITE_GATE_MASK;
 
     // Done!
@@ -526,7 +580,7 @@ void loop() {
                  writeByteToUART('V');  // Followed
                  writeByteToUART('1');  // By
                  writeByteToUART('.');  // Version
-                 writeByteToUART('2');  // Number
+                 writeByteToUART('3');  // Number
                  break;
   
         // Command "." means go back to track 0
@@ -574,6 +628,14 @@ void loop() {
                      writeTrackFromUART();
                   }
                   break;
+
+        // Command "X" Erase current track (writes 0xAA to it)
+        case 'X': if (!driveEnabled) writeByteToUART('0'); else
+                  if (!inWriteMode) writeByteToUART('0'); else {
+                     writeByteToUART('1');
+                     eraseTrack();
+                  }
+                  break;
   
         // Turn off the drive motor
         case '-': digitalWrite(PIN_DRIVE_ENABLE_MOTOR,HIGH);
diff --git a/readme.md b/readme.md
@@ -18,6 +18,7 @@ If you want to use the AVR directly instead of within the Arduino environment, t
 For further details including how to wire this up please visit [http://amiga.robsmithdev.co.uk]
 
 # Whats changed?
+V2.2 Fixed 99% of checksum errors when writing by erasing the track first
 V2.1 Diagnostics and potential write bug fixed
 V2.0 Disk reading has been vastly improved and you can now also write disks!
 V1.0 Initial release, can read disks fairly well
