flux: Split Flux class and create new WriteoutFlux.

Simplifies users of the flux module a little.

scripts/greaseweazle/flux.py

@@ -5,27 +5,46 @@
 # This is free and unencumbered software released into the public domain.
 # See the file COPYING for more details, or visit <http://unlicense.org>.
 
+from greaseweazle import error
+
 class Flux:
 
     def __init__(self, index_list, flux_list, sample_freq):
         self.index_list = index_list
         self.list = flux_list
         self.sample_freq = sample_freq
-        self.terminate_at_index = True
-
+        self.splice = 0
 
     def __str__(self):
-        s = "Sample Frequency: %f MHz\n" % (self.sample_freq/1000000)
-        s += "Total Flux: %u\n" % len(self.list)
+        s = "\nFlux: %.2f MHz" % (self.sample_freq*1e-6)
+        s += ("\n Total: %u samples, %.2fms\n"
+              % (len(self.list), sum(self.list)*1000/self.sample_freq))
         rev = 0
         for t in self.index_list:
-            s += "Revolution %u: %.2fms\n" % (rev, t*1000/self.sample_freq)
+            s += " Revolution %u: %.2fms\n" % (rev, t*1000/self.sample_freq)
             rev += 1
         return s[:-1]
 
-
     def flux_for_writeout(self):
-        return self.flux()
+        error.check(self.splice == 0,
+                    "Cannot write non-index-aligned raw flux")
+        # Copy the first revolution only to a fresh flux list.
+        flux_list = []
+        to_index = remain = self.index_list[0]
+        for f in self.list:
+            if f > remain:
+                break
+            flux_list.append(f)
+            remain -= f
+        # Extend with "safe" 4us sample values, to avoid unformatted area
+        # at end of track if drive motor is a little slow.
+        four_us = max(self.sample_freq * 4e-6, 1)
+        if remain > four_us:
+            flux_list.append(remain)
+        for i in range(round(to_index/(10*four_us))):
+            flux_list.append(four_us)
+        return WriteoutFlux(to_index, flux_list, self.sample_freq,
+                            terminate_at_index = True)
 
     def flux(self):
         return self
@@ -39,6 +58,25 @@ class Flux:
         """Mean time between index pulses, in seconds (float)"""
         return sum(self.index_list) / (len(self.index_list) * self.sample_freq)
 
+
+class WriteoutFlux(Flux):
+
+    def __init__(self, ticks_to_index, flux_list, sample_freq,
+                 terminate_at_index):
+        super().__init__([ticks_to_index], flux_list, sample_freq)
+        self.terminate_at_index = terminate_at_index
+
+    def __str__(self):
+        s = ("\nWriteoutFlux: %.2f MHz, %.2fms to index, %s\n"
+             " Total: %u samples, %.2fms"
+             % (self.sample_freq*1e-6,
+                self.index_list[0]*1000/self.sample_freq,
+                ("Write all", "Terminate at index")[self.terminate_at_index],
+                len(self.list), sum(self.list)*1000/self.sample_freq))
+        return s
+
+    def flux_for_writeout(self):
+        return self
  
 # Local variables:
 # python-indent: 4

scripts/greaseweazle/image/adf.py

@@ -47,7 +47,7 @@ class ADF:
         return adf
 
 
-    def get_track(self, cyl, side, writeout=False):
+    def get_track(self, cyl, side):
         off = cyl * 2 + side
         if off >= len(self.track_list):
             return None

scripts/greaseweazle/image/hfe.py

@@ -60,7 +60,7 @@ class HFE:
         return hfe
 
 
-    def get_track(self, cyl, side, writeout=False):
+    def get_track(self, cyl, side):
         if side >= self.nr_sides or cyl < self.start_cyl:
             return None
         off = cyl * self.nr_sides + side

scripts/greaseweazle/image/ipf.py

@@ -154,7 +154,7 @@ class IPF:
         return ipf
 
 
-    def get_track(self, cyl, head, writeout=False):
+    def get_track(self, cyl, head):
         pi = self.pi
         if head < pi.minhead or head > pi.maxhead:
             return None

scripts/greaseweazle/image/scp.py

@@ -111,7 +111,7 @@ class SCP:
         return scp
 
 
-    def get_track(self, cyl, side, writeout=False):
+    def get_track(self, cyl, side):
         off = cyl*2 + side
         if off >= len(self.track_list):
             return None
@@ -119,12 +119,6 @@ class SCP:
         if dat is None:
             return None
 
-        # Writeout requires only a single revolution
-        if writeout:
-            tdh = tdh[:12]
-            _, nr, _ = struct.unpack("<3I", tdh)
-            dat = dat[:nr*2]
-        
         index_list = []
         while tdh:
             ticks, _, _ = struct.unpack("<3I", tdh[:12])

scripts/greaseweazle/tools/write.py

@@ -53,7 +53,7 @@ def write_from_image(usb, args, image):
     for cyl in range(args.scyl, args.ecyl+1):
         for side in range(0, args.nr_sides):
 
-            track = image.get_track(cyl, side, writeout=True)
+            track = image.get_track(cyl, side)
             if track is None and not args.erase_empty:
                 continue
 

scripts/greaseweazle/track.py

@@ -8,7 +8,7 @@
 import binascii
 import itertools as it
 from bitarray import bitarray
-from greaseweazle.flux import Flux
+from greaseweazle.flux import WriteoutFlux
 
 # A pristine representation of a track, from a codec and/or a perfect image.
 class MasterTrack:
@@ -141,9 +141,9 @@ class MasterTrack:
             flux_list.append(flux_ticks)
 
         # Package up the flux for return.
-        flux = Flux([ticks_to_index], flux_list,
-                    ticks_to_index / self.time_per_rev)
-        flux.terminate_at_index = splice_at_index
+        flux = WriteoutFlux(ticks_to_index, flux_list,
+                            ticks_to_index / self.time_per_rev,
+                            terminate_at_index = splice_at_index)
         return flux