Add the ability to erase tracks. The writer now erases tracks for which no data

is available.

FluxEngine.cydsn/main.c

@@ -511,6 +511,27 @@ static void cmd_write(struct write_frame* f)
     send_reply((struct any_frame*) &r);
 }
 
+static void cmd_erase(struct erase_frame* f)
+{
+    SIDE_REG_Write(f->side);
+    seek_to(current_track);    
+    /* Disk is now spinning. */
+    
+    print("start erasing\r");
+    index_irq = false;
+    while (!index_irq)
+        ;
+    ERASE_REG_Write(1);
+    index_irq = false;
+    while (!index_irq)
+        ;
+    ERASE_REG_Write(0);
+    print("stop erasing\r");
+
+    DECLARE_REPLY_FRAME(struct any_frame, F_FRAME_ERASE_REPLY);
+    send_reply((struct any_frame*) &r);
+}
+
 static void handle_command(void)
 {
     static uint8_t input_buffer[FRAME_SIZE];
@@ -543,6 +564,10 @@ static void handle_command(void)
             cmd_write((struct write_frame*) f);
             break;
             
+        case F_FRAME_ERASE_CMD:
+            cmd_erase((struct erase_frame*) f);
+            break;
+            
         default:
             send_error(F_ERROR_BAD_COMMAND);
     }

lib/usb.cc

@@ -222,3 +222,14 @@ void usbWrite(int side, const Fluxmap& fluxmap)
     await_reply<struct any_frame>(F_FRAME_WRITE_REPLY);
 }
 
+void usbErase(int side)
+{
+    struct erase_frame f = {
+        .f = { .type = F_FRAME_ERASE_CMD, .size = sizeof(f) },
+        .side = (uint8_t) side,
+    };
+    usb_cmd_send(&f, f.f.size);
+
+    await_reply<struct any_frame>(F_FRAME_ERASE_REPLY);
+}
+

lib/usb.h

@@ -9,5 +9,6 @@ extern nanoseconds_t usbGetRotationalPeriod();
 extern void usbTestBulkTransport();
 extern std::unique_ptr<Fluxmap> usbRead(int side, int revolutions);
 extern void usbWrite(int side, const Fluxmap& fluxmap);
+extern void usbErase(int side);
 
 #endif

lib/writer.cc

@@ -73,22 +73,31 @@ void writeTracks(
 
     for (int track=starttrack; track<=endtrack; track++)
     {
-		if ((track < minTrack) || (track > maxTrack))
-			continue;
-
         for (int side=startside; side<=endside; side++)
         {
-			std::cout << fmt::format("{0:>3}.{1}: ", track, side) << std::flush;
+            std::cout << fmt::format("{0:>3}.{1}: ", track, side) << std::flush;
-			Fluxmap fluxmap = producer(track, side);
+            if ((track < minTrack) || (track > maxTrack))
-			fluxmap.precompensate(PRECOMPENSATION_THRESHOLD_TICKS, 2);
+            {
-			if (outdb)
+                if (!outdb)
-				sqlWriteFlux(outdb, track, side, fluxmap);
+                {
-			else
+                    std::cout << "erasing" << std::endl;
-			{
+                    usbSeek(track);
-				usbSeek(track);
+                    usbErase(side);
-				usbWrite(side, fluxmap);
+                }
-			}
+            }
-			std::cout << fmt::format("{0} ms in {1} bytes", int(fluxmap.duration()/1e6), fluxmap.bytes()) << std::endl;
+            else
+            {
+                Fluxmap fluxmap = producer(track, side);
+                fluxmap.precompensate(PRECOMPENSATION_THRESHOLD_TICKS, 2);
+                if (outdb)
+                    sqlWriteFlux(outdb, track, side, fluxmap);
+                else
+                {
+                    usbSeek(track);
+                    usbWrite(side, fluxmap);
+                }
+                std::cout << fmt::format("{0} ms in {1} bytes", int(fluxmap.duration()/1e6), fluxmap.bytes()) << std::endl;
+            }
         }
     }
 }

protocol.h

@@ -50,7 +50,9 @@ enum
     F_FRAME_READ_CMD,             /* read_frame */
     F_FRAME_READ_REPLY,           /* any_frame */
     F_FRAME_WRITE_CMD,            /* write_frame */
-    F_FRAME_WRITE_REPLY,          /* write_reply_frame */
+    F_FRAME_WRITE_REPLY,          /* any_frame */
+    F_FRAME_ERASE_CMD,            /* erase_frame */
+    F_FRAME_ERASE_REPLY,          /* any_frame */
 };
 
 enum
@@ -110,4 +112,10 @@ struct write_frame
     uint32_t bytes_to_write;
 };
 
+struct erase_frame
+{
+    struct frame_header f;
+    uint8_t side;
+};
+
 #endif