def main(argv):
parser = util.ArgumentParser(usage='%(prog)s [options] file')
parser.add_argument("--device", help="greaseweazle device name")
parser.add_argument("--drive", type=util.drive_letter, default='A',
help="drive to write (A,B,0,1,2)")
parser.add_argument("--tracks", type=util.TrackSet,
help="which tracks to write")
parser.add_argument("--erase-empty", action="store_true",
help="erase empty tracks (default: skip)")
parser.add_argument("--no-verify", action="store_true",
help="disable verify")
parser.add_argument("file", help="input filename")
parser.description = description
parser.prog += ' ' + argv[1]
args = parser.parse_args(argv[2:])
try:
usb = util.usb_open(args.device)
image = open_image(args)
tracks = util.TrackSet('c=0-81:h=0-1')
if args.tracks is not None:
tracks.update_from_trackspec(args.tracks.trackspec)
args.tracks = tracks
print("Writing %s" % (args.tracks))
util.with_drive_selected(write_from_image, usb, args, image)
except USB.CmdError as error:
print("Command Failed: %s" % error)
def main(argv):
parser = util.ArgumentParser(usage='%(prog)s [options]')
parser.add_argument("--device", help="greaseweazle device name")
parser.add_argument("--drive",
type=util.drive_letter,
default='A',
help="drive to write (A,B,0,1,2)")
parser.add_argument("--cyls",
type=int,
default=80,
help="number of drive cylinders")
parser.add_argument("--passes",
type=int,
default=3,
help="number of passes across the cleaning disk")
parser.add_argument("--linger",
type=int,
default=100,
help="linger time per step, milliseconds")
parser.description = description
parser.prog += ' ' + argv[1]
args = parser.parse_args(argv[2:])
try:
usb = util.usb_open(args.device)
util.with_drive_selected(clean, usb, args)
except USB.CmdError as error:
print("Command Failed: %s" % error)
def main(argv):
parser = util.ArgumentParser(usage='%(prog)s [options]')
parser.add_argument("--device", help="device name (COM/serial port)")
parser.add_argument("--drive",
type=util.drive_letter,
default='A',
help="drive to write (A,B,0,1,2)")
parser.add_argument("--tracks",
type=util.TrackSet,
help="which tracks to erase")
parser.description = description
parser.prog += ' ' + argv[1]
args = parser.parse_args(argv[2:])
try:
usb = util.usb_open(args.device)
tracks = util.TrackSet('c=0-81:h=0-1')
if args.tracks is not None:
tracks.update_from_trackspec(args.tracks.trackspec)
args.tracks = tracks
print("Erasing %s" % (args.tracks))
util.with_drive_selected(erase, usb, args)
except USB.CmdError as error:
print("Command Failed: %s" % error)
def main(argv):
epilog = (util.drive_desc)
parser = util.ArgumentParser(usage='%(prog)s [options] cylinder',
epilog=epilog)
parser.add_argument("--device", help="device name (COM/serial port)")
parser.add_argument("--drive",
type=util.drive_letter,
default='A',
help="drive to read")
parser.add_argument("--force",
action="store_true",
help="allow extreme cylinders with no prompt")
parser.add_argument("--motor-on",
action="store_true",
help="seek with drive motor activated")
parser.add_argument("cylinder", type=int, help="cylinder to seek")
parser.description = description
parser.prog += ' ' + argv[1]
args = parser.parse_args(argv[2:])
try:
struct.pack('b', args.cylinder)
except struct.error:
raise error.Fatal("Cylinder %d out of range" % args.cylinder)
if not 0 <= args.cylinder <= 83 and not args.force:
answer = input("Seek to extreme cylinder %d, Yes/No? " % args.cylinder)
if answer != "Yes":
return
try:
usb = util.usb_open(args.device)
util.with_drive_selected(seek, usb, args, motor=args.motor_on)
except USB.CmdError as err:
print("Command Failed: %s" % err)
def main(argv):
parser = util.ArgumentParser()
parser.add_argument("--drive",
type=util.drive_letter,
default='A',
help="drive to write (A,B,0,1,2)")
parser.add_argument("--scyl",
type=int,
default=0,
help="first cylinder to write")
parser.add_argument("--ecyl",
type=int,
default=81,
help="last cylinder to write")
parser.add_argument("--single-sided",
action="store_true",
help="single-sided write")
parser.add_argument("device",
nargs="?",
default="auto",
help="serial device")
parser.prog += ' ' + argv[1]
args = parser.parse_args(argv[2:])
args.nr_sides = 1 if args.single_sided else 2
try:
usb = util.usb_open(args.device)
util.with_drive_selected(erase, usb, args)
except USB.CmdError as error:
print("Command Failed: %s" % error)
def main(argv):
epilog = (util.drive_desc + "\n" + util.speed_desc + "\n" +
util.tspec_desc)
parser = util.ArgumentParser(usage='%(prog)s [options]', epilog=epilog)
parser.add_argument("--device", help="device name (COM/serial port)")
parser.add_argument("--drive",
type=util.drive_letter,
default='A',
help="drive to read")
parser.add_argument("--tracks",
type=util.TrackSet,
metavar="TSPEC",
help="which tracks to erase")
parser.add_argument("--hfreq",
action="store_true",
help="erase by writing a high-frequency signal")
parser.add_argument("--fake-index",
type=util.period,
metavar="SPEED",
help="fake index pulses at SPEED")
parser.description = description
parser.prog += ' ' + argv[1]
args = parser.parse_args(argv[2:])
try:
usb = util.usb_open(args.device)
tracks = util.TrackSet('c=0-81:h=0-1')
if args.tracks is not None:
tracks.update_from_trackspec(args.tracks.trackspec)
args.tracks = tracks
print("Erasing %s" % (args.tracks))
util.with_drive_selected(erase, usb, args)
except USB.CmdError as error:
print("Command Failed: %s" % error)
def main(argv):
parser = util.ArgumentParser()
parser.add_argument("--drive", type=util.drive_letter, default='A',
help="drive to read (A,B,0,1,2)")
parser.add_argument("--revs", type=int, default=3,
help="number of revolutions to read per track")
parser.add_argument("--scyl", type=int, default=0,
help="first cylinder to read")
parser.add_argument("--ecyl", type=int, default=81,
help="last cylinder to read")
parser.add_argument("--single-sided", action="store_true",
help="single-sided read")
parser.add_argument("--double-step", action="store_true",
help="double-step drive heads")
parser.add_argument("file", help="output filename")
parser.add_argument("device", nargs="?", default="auto",
help="serial device")
parser.prog += ' ' + argv[1]
args = parser.parse_args(argv[2:])
args.nr_sides = 1 if args.single_sided else 2
try:
usb = util.usb_open(args.device)
image = open_image(args)
util.with_drive_selected(read_to_image, usb, args, image)
except USB.CmdError as error:
print("Command Failed: %s" % error)
def main(argv):
parser = util.ArgumentParser(usage='%(prog)s [options] file')
parser.add_argument("--device", help="greaseweazle device name")
parser.add_argument("--drive", type=util.drive_letter, default='A',
help="drive to write (A,B,0,1,2)")
parser.add_argument("--scyl", type=int, default=0,
help="first cylinder to write")
parser.add_argument("--ecyl", type=int, default=81,
help="last cylinder to write")
parser.add_argument("--single-sided", action="store_true",
help="single-sided write")
parser.add_argument("--double-step", action="store_true",
help="double-step drive heads")
parser.add_argument("--erase-empty", action="store_true",
help="erase empty tracks (default: skip)")
parser.add_argument("--no-verify", action="store_true",
help="disable verify")
parser.add_argument("file", help="input filename")
parser.description = description
parser.prog += ' ' + argv[1]
args = parser.parse_args(argv[2:])
args.nr_sides = 1 if args.single_sided else 2
try:
usb = util.usb_open(args.device)
image = open_image(args)
util.with_drive_selected(write_from_image, usb, args, image)
except USB.CmdError as error:
print("Command Failed: %s" % error)
def main(argv):
parser = util.ArgumentParser(usage='%(prog)s [options] file')
parser.add_argument("--device", help="greaseweazle device name")
parser.add_argument("--drive",
type=util.drive_letter,
default='A',
help="drive to read (A,B,0,1,2)")
parser.add_argument("--format", help="disk format")
parser.add_argument("--revs",
type=int,
help="number of revolutions to read per track")
parser.add_argument("--scyl", type=int, help="first cylinder to read")
parser.add_argument("--ecyl", type=int, help="last cylinder to read")
parser.add_argument("--single-sided",
action="store_true",
help="single-sided read")
parser.add_argument("--double-step",
action="store_true",
help="double-step drive heads")
parser.add_argument("--rate", type=int, help="data rate (kbit/s)")
parser.add_argument("--rpm", type=int, help="convert drive speed to RPM")
parser.add_argument("file", help="output filename")
parser.description = description
parser.prog += ' ' + argv[1]
args = parser.parse_args(argv[2:])
args.nr_sides = 1 if args.single_sided else 2
args.file, args.file_opts = util.split_opts(args.file)
try:
usb = util.usb_open(args.device)
image_class = util.get_image_class(args.file)
if not args.format and hasattr(image_class, 'default_format'):
args.format = image_class.default_format
decoder = None
if args.format:
try:
mod = importlib.import_module('greaseweazle.codec.' +
args.format)
decoder = mod.decode_track
except (ModuleNotFoundError, AttributeError) as ex:
raise error.Fatal("Unknown format '%s'" % args.format) from ex
if args.scyl is None: args.scyl = mod.default_cyls[0]
if args.ecyl is None: args.ecyl = mod.default_cyls[1]
if args.revs is None: args.revs = mod.default_revs
if args.scyl is None: args.scyl = 0
if args.ecyl is None: args.ecyl = 81
if args.revs is None: args.revs = 3
print("Reading c=%s s=%s revs=%d" % (range_str(
args.scyl, args.ecyl), range_str(0, args.nr_sides - 1), args.revs))
image = open_image(args, image_class)
util.with_drive_selected(read_to_image,
usb,
args,
image,
decoder=decoder)
except USB.CmdError as err:
print("Command Failed: %s" % err)
def main(argv):
parser = util.ArgumentParser(usage='%(prog)s [options] file')
parser.add_argument("--device", help="greaseweazle device name")
parser.add_argument("--drive",
type=util.drive_letter,
default='A',
help="drive to read (A,B,0,1,2)")
parser.add_argument("--format", help="disk format")
parser.add_argument("--revs",
type=int,
help="number of revolutions to read per track")
parser.add_argument("--tracks",
type=util.TrackSet,
help="which tracks to read")
parser.add_argument("--rate", type=int, help="data rate (kbit/s)")
parser.add_argument("--rpm", type=int, help="convert drive speed to RPM")
parser.add_argument("--retries",
type=int,
default=3,
help="number of retries on decode failure")
parser.add_argument("file", help="output filename")
parser.description = description
parser.prog += ' ' + argv[1]
args = parser.parse_args(argv[2:])
args.file, args.file_opts = util.split_opts(args.file)
try:
usb = util.usb_open(args.device)
image_class = util.get_image_class(args.file)
if not args.format and hasattr(image_class, 'default_format'):
args.format = image_class.default_format
decoder, def_tracks = None, None
if args.format:
try:
mod = importlib.import_module('greaseweazle.codec.' +
args.format)
decoder = mod.decode_track
except (ModuleNotFoundError, AttributeError) as ex:
raise error.Fatal("Unknown format '%s'" % args.format) from ex
def_tracks = util.TrackSet(mod.default_trackset)
if args.revs is None: args.revs = mod.default_revs
if def_tracks is None:
def_tracks = util.TrackSet('c=0-81:h=0-1')
if args.revs is None: args.revs = 3
if args.tracks is not None:
def_tracks.update_from_trackspec(args.tracks.trackspec)
args.tracks = def_tracks
print(("Reading %s revs=" % args.tracks) + str(args.revs))
with open_image(args, image_class) as image:
util.with_drive_selected(read_to_image,
usb,
args,
image,
decoder=decoder)
except USB.CmdError as err:
print("Command Failed: %s" % err)
def main(argv):
epilog = "FORMAT options:\n" + formats.print_formats()
parser = util.ArgumentParser(usage='%(prog)s [options] file',
epilog=epilog)
parser.add_argument("--device", help="device name (COM/serial port)")
parser.add_argument("--drive", type=util.drive_letter, default='A',
help="drive to write (A,B,0,1,2)")
parser.add_argument("--format", help="disk format")
parser.add_argument("--tracks", type=util.TrackSet,
help="which tracks to write")
parser.add_argument("--erase-empty", action="store_true",
help="erase empty tracks (default: skip)")
parser.add_argument("--no-verify", action="store_true",
help="disable verify")
parser.add_argument("--retries", type=int, default=3,
help="number of retries on verify failure")
parser.add_argument("--precomp", type=PrecompSpec,
help="write precompensation")
parser.add_argument("file", help="input filename")
parser.description = description
parser.prog += ' ' + argv[1]
args = parser.parse_args(argv[2:])
try:
image_class = util.get_image_class(args.file)
if not args.format and hasattr(image_class, 'default_format'):
args.format = image_class.default_format
def_tracks, args.fmt_cls = None, None
if args.format:
try:
args.fmt_cls = formats.formats[args.format]()
except KeyError as ex:
raise error.Fatal("""\
Unknown format '%s'
Known formats:\n%s"""
% (args.format, formats.print_formats()))
def_tracks = args.fmt_cls.default_tracks
if def_tracks is None:
def_tracks = util.TrackSet('c=0-81:h=0-1')
if args.tracks is not None:
def_tracks.update_from_trackspec(args.tracks.trackspec)
args.tracks = def_tracks
usb = util.usb_open(args.device)
image = open_image(args, image_class)
print("Writing " + str(args.tracks))
if args.precomp is not None:
print(args.precomp)
if args.format:
print("Format " + args.format)
util.with_drive_selected(write_from_image, usb, args, image)
except USB.CmdError as err:
print("Command Failed: %s" % err)
def main(argv):
parser = util.ArgumentParser(usage='%(prog)s [options]')
parser.add_argument("--device", help="greaseweazle device name")
parser.add_argument("--drive", type=util.drive_letter, default='A',
help="drive to read (A,B,0,1,2)")
parser.add_argument("--nr", type=int, default=1,
help="number of iterations")
parser.description = description
parser.prog += ' ' + argv[1]
args = parser.parse_args(argv[2:])
try:
usb = util.usb_open(args.device)
util.with_drive_selected(print_rpm, usb, args)
except USB.CmdError as err:
print("Command Failed: %s" % err)
def pin_get(argv):
epilog = (util.drive_desc)
parser = util.ArgumentParser(usage='%(prog)s [options] pin',
epilog=epilog)
parser.add_argument("--device", help="device name (COM/serial port)")
parser.add_argument("--drive", type=util.drive_letter, default='A',
help="drive to read")
parser.add_argument("pin", type=int, help="pin number")
parser.description = description
parser.prog += ' pin get'
args = parser.parse_args(argv[3:])
try:
usb = util.usb_open(args.device)
util.with_drive_selected(_pin_get, usb, args, motor=False)
except USB.CmdError as error:
print("Command Failed: %s" % error)
def main(argv):
parser = util.ArgumentParser(usage='%(prog)s [options] cylinder')
parser.add_argument("--device", help="greaseweazle device name")
parser.add_argument("--drive",
type=util.drive_letter,
default='A',
help="drive to read (A,B,0,1,2)")
parser.add_argument("cylinder", type=int, help="cylinder to seek")
parser.description = description
parser.prog += ' ' + argv[1]
args = parser.parse_args(argv[2:])
try:
usb = util.usb_open(args.device)
util.with_drive_selected(seek, usb, args, motor=False)
except USB.CmdError as error:
print("Command Failed: %s" % error)
def main(argv):
parser = util.ArgumentParser(usage='%(prog)s [options] file')
parser.add_argument("--device", help="greaseweazle device name")
parser.add_argument("--drive",
type=util.drive_letter,
default='A',
help="drive to read (A,B,0,1,2)")
parser.add_argument("--revs",
type=int,
default=3,
help="number of revolutions to read per track")
parser.add_argument("--scyl",
type=int,
default=0,
help="first cylinder to read")
parser.add_argument("--ecyl",
type=int,
default=81,
help="last cylinder to read")
parser.add_argument("--single-sided",
action="store_true",
help="single-sided read")
parser.add_argument("--double-step",
action="store_true",
help="double-step drive heads")
parser.add_argument("--rate", type=int, help="data rate (kbit/s)")
parser.add_argument("--rpm", type=int, help="convert drive speed to RPM")
parser.add_argument("file", help="output filename")
parser.description = description
parser.prog += ' ' + argv[1]
args = parser.parse_args(argv[2:])
args.nr_sides = 1 if args.single_sided else 2
args.file, args.file_opts = util.split_opts(args.file)
try:
usb = util.usb_open(args.device)
image = open_image(args)
util.with_drive_selected(read_to_image, usb, args, image)
except USB.CmdError as error:
print("Command Failed: %s" % error)
def main(argv):
parser = util.ArgumentParser()
parser.add_argument("--drive", type=util.drive_letter, default='A',
help="drive to step (A,B,0,1,2)")
parser.add_argument("--ecyl", type=int, default=81,
help="last cylinder in step range")
parser.add_argument("--repeat", type=int, default=0,
help="times to repeat (0 = forever)")
parser.add_argument("--wait", action='store_true',
help="wait for input between step cycles")
parser.add_argument("device", nargs="?", default="auto",
help="serial device")
parser.prog += ' ' + argv[1]
args = parser.parse_args(argv[2:])
args.scyl = 0
args.repeat = args.repeat if args.repeat else -1
try:
usb = util.usb_open(args.device)
util.with_drive_selected(step, usb, args)
except USB.CmdError as error:
print("Command Failed: %s" % error)
def main(argv):
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument("--drive",
type=util.drive_letter,
default='A',
help="drive to write (A,B,0,1,2)")
parser.add_argument("--scyl",
type=int,
default=0,
help="first cylinder to write")
parser.add_argument("--ecyl",
type=int,
default=81,
help="last cylinder to write")
parser.add_argument("--single-sided",
action="store_true",
help="single-sided write")
parser.add_argument("--adjust-speed",
action="store_true",
help="adjust write-flux times for drive speed")
parser.add_argument("file", help="input filename")
parser.add_argument("device",
nargs="?",
default="auto",
help="serial device")
parser.prog += ' ' + argv[1]
args = parser.parse_args(argv[2:])
args.nr_sides = 1 if args.single_sided else 2
try:
usb = util.usb_open(args.device)
util.with_drive_selected(write_from_image, usb, args)
except USB.CmdError as error:
print("Command Failed: %s" % error)
def main(argv):
epilog = (util.drive_desc + "\n" + util.speed_desc + "\n" +
util.tspec_desc + "\nFORMAT options:\n" +
formats.print_formats())
parser = util.ArgumentParser(usage='%(prog)s [options] file',
epilog=epilog)
parser.add_argument("--device", help="device name (COM/serial port)")
parser.add_argument("--drive",
type=util.drive_letter,
default='A',
help="drive to read")
parser.add_argument("--format",
help="disk format (output is converted unless --raw)")
parser.add_argument("--revs",
type=int,
metavar="N",
help="number of revolutions to read per track")
parser.add_argument("--tracks",
type=util.TrackSet,
metavar="TSPEC",
help="which tracks to read")
parser.add_argument("--raw",
action="store_true",
help="output raw stream (--format verifies only)")
parser.add_argument("--fake-index",
type=util.period,
metavar="SPEED",
help="fake index pulses at SPEED")
parser.add_argument("--adjust-speed",
type=util.period,
metavar="SPEED",
help="scale track data to effective drive SPEED")
parser.add_argument("--retries",
type=int,
default=3,
metavar="N",
help="number of retries per seek-retry")
parser.add_argument("--seek-retries",
type=int,
default=3,
metavar="N",
help="number of seek retries")
parser.add_argument("-n",
"--no-clobber",
action="store_true",
help="do not overwrite an existing file")
parser.add_argument("file", help="output filename")
parser.description = description
parser.prog += ' ' + argv[1]
args = parser.parse_args(argv[2:])
args.file, args.file_opts = util.split_opts(args.file)
try:
usb = util.usb_open(args.device)
image_class = util.get_image_class(args.file)
if not args.format and hasattr(image_class, 'default_format'):
args.format = image_class.default_format
decoder, def_tracks, args.fmt_cls = None, None, None
if args.format:
try:
args.fmt_cls = formats.formats[args.format]()
except KeyError as ex:
raise error.Fatal("""\
Unknown format '%s'
Known formats:\n%s""" % (args.format, formats.print_formats()))
decoder = args.fmt_cls.decode_track
def_tracks = args.fmt_cls.default_tracks
if args.revs is None: args.revs = args.fmt_cls.default_revs
if def_tracks is None:
def_tracks = util.TrackSet('c=0-81:h=0-1')
if args.revs is None: args.revs = 3
if args.tracks is not None:
def_tracks.update_from_trackspec(args.tracks.trackspec)
args.tracks = def_tracks
print(("Reading %s revs=" % args.tracks) + str(args.revs))
if args.format:
print("Format " + args.format)
with open_image(args, image_class) as image:
util.with_drive_selected(read_to_image,
usb,
args,
image,
decoder=decoder)
except USB.CmdError as err:
print("Command Failed: %s" % err)
