Plumb the index-cueing logic up into the Flux classes.

scripts/greaseweazle/flux.py

@@ -10,11 +10,12 @@ from greaseweazle import error
 
 class Flux:
 
-    def __init__(self, index_list, flux_list, sample_freq):
+    def __init__(self, index_list, flux_list, sample_freq, index_cued=True):
         self.index_list = index_list
         self.list = flux_list
         self.sample_freq = sample_freq
         self.splice = 0
+        self.index_cued = index_cued
 
 
     def __str__(self):
@@ -33,6 +34,25 @@ class Flux:
                 % (len(self.list), sum(self.list)*1000/self.sample_freq))
 
 
+    def cue_at_index(self):
+
+        if self.index_cued:
+            return
+
+        # Clip the initial partial revolution.
+        to_index = self.index_list[0]
+        for i in range(len(self.list)):
+            to_index -= self.list[i]
+            if to_index < 0:
+                break
+        if to_index < 0:
+            self.list = [-to_index] + self.list[i+1:]
+        else: # we ran out of flux
+            self.list = []
+        self.index_list = self.index_list[1:]
+        self.index_cued = True
+
+
     def flux_for_writeout(self):
 
         error.check(self.splice == 0 or len(self.index_list) > 1,
@@ -62,6 +82,7 @@ class Flux:
             flux_list.append(remain)
 
         return WriteoutFlux(to_index, flux_list, self.sample_freq,
+                            index_cued = True,
                             terminate_at_index = (self.splice == 0))
 
 
@@ -76,16 +97,26 @@ class Flux:
 
 
     @property
-    def mean_index_time(self):
+    def ticks_per_rev(self):
+        """Mean time between index pulses, in sample ticks"""
+        index_list = self.index_list
+        if not self.index_cued:
+            index_list = index_list[1:]
+        return sum(index_list) / len(index_list)
+
+
+    @property
+    def time_per_rev(self):
         """Mean time between index pulses, in seconds (float)"""
-        return sum(self.index_list) / (len(self.index_list) * self.sample_freq)
+        return self.ticks_per_rev / self.sample_freq
 
 
 class WriteoutFlux(Flux):
 
     def __init__(self, ticks_to_index, flux_list, sample_freq,
-                 terminate_at_index):
+                 index_cued, terminate_at_index):
         super().__init__([ticks_to_index], flux_list, sample_freq)
+        self.index_cued = index_cued
         self.terminate_at_index = terminate_at_index
 
 

scripts/greaseweazle/tools/erase.py

@@ -18,9 +18,7 @@ def erase(usb, args):
 
     # @drive_ticks is the time in Greaseweazle ticks between index pulses.
     # We will adjust the flux intervals per track to allow for this.
-    flux = usb.read_track(2)
-    drive_ticks = (flux.index_list[0] + flux.index_list[1]) / 2
-    del flux
+    drive_ticks = usb.read_track(2).ticks_per_rev
 
     for t in args.tracks:
         cyl, head = t.cyl, t.head

scripts/greaseweazle/tools/read.py

@@ -58,6 +58,7 @@ def normalise_rpm(flux, rpm):
 
 def read_and_normalise(usb, args, revs):
     flux = usb.read_track(revs)
+    flux.cue_at_index()
     if args.rpm is not None:
         flux = normalise_rpm(flux, args.rpm)
     return flux

scripts/greaseweazle/tools/write.py

@@ -38,9 +38,7 @@ def write_from_image(usb, args, image):
 
     # @drive_ticks is the time in Greaseweazle ticks between index pulses.
     # We will adjust the flux intervals per track to allow for this.
-    flux = usb.read_track(2)
-    drive_ticks = (flux.index_list[0] + flux.index_list[1]) / 2
-    del flux
+    drive_ticks = usb.read_track(2).ticks_per_rev
 
     verified_count, not_verified_count = 0, 0
 
@@ -80,7 +78,9 @@ def write_from_image(usb, args, image):
         formatter = Formatter()
         verified = False
         for retry in range(3):
-            usb.write_track(flux_list, flux.terminate_at_index)
+            usb.write_track(flux_list = flux_list,
+                            cue_at_index = flux.index_cued,
+                            terminate_at_index = flux.terminate_at_index)
             try:
                 no_verify = args.no_verify or track.verify is None
             except AttributeError: # track.verify undefined
@@ -91,7 +91,8 @@ def write_from_image(usb, args, image):
                 break
             v_revs = 1 if track.splice == 0 else 2
             v_flux = usb.read_track(v_revs)
-            v_flux.scale(flux.mean_index_time / v_flux.mean_index_time)
+            v_flux.cue_at_index()
+            v_flux.scale(flux.time_per_rev / v_flux.time_per_rev)
             verified = track.verify.verify_track(v_flux)
             if verified:
                 verified_count += 1

scripts/greaseweazle/track.py

@@ -143,6 +143,7 @@ class MasterTrack:
         # Package up the flux for return.
         flux = WriteoutFlux(ticks_to_index, flux_list,
                             ticks_to_index / self.time_per_rev,
+                            index_cued = True,
                             terminate_at_index = splice_at_index)
         return flux
 

scripts/greaseweazle/usb.py

@@ -394,21 +394,8 @@ class Unit:
         # Decode the flux list and read the index-times list.
         flux_list, index_list = self._decode_flux(dat)
 
-        # Clip the initial partial revolution.
-        to_index = index_list[0]
-        for i in range(len(flux_list)):
-            to_index -= flux_list[i]
-            if to_index < 0:
-                flux_list[i] = -to_index
-                flux_list = flux_list[i:]
-                break
-        if to_index >= 0:
-            # We ran out of flux.
-            flux_list = []
-        index_list = index_list[1:]
-
         # Success: Return the requested full index-to-index revolutions.
-        return Flux(index_list, flux_list, self.sample_freq)
+        return Flux(index_list, flux_list, self.sample_freq, index_cued=False)
 
 
     ## write_track: