gw.py 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416
  1. # gw.py
  2. #
  3. # Greaseweazle control script.
  4. #
  5. # Written & released by Keir Fraser <keir.xen@gmail.com>
  6. #
  7. # This is free and unencumbered software released into the public domain.
  8. # See the file COPYING for more details, or visit <http://unlicense.org>.
  9. import crcmod.predefined
  10. import sys, struct, argparse, serial, collections
  11. from timeit import default_timer as timer
  12. from greaseweazle import version
  13. # 40MHz
  14. scp_freq = 40000000
  15. BAUD_CLEAR_COMMS = 10000
  16. BAUD_NORMAL = 9600
  17. CMD_GET_INFO = 0
  18. CMD_SEEK = 1
  19. CMD_SIDE = 2
  20. CMD_SET_DELAYS = 3
  21. CMD_GET_DELAYS = 4
  22. CMD_MOTOR = 5
  23. CMD_READ_FLUX = 6
  24. CMD_WRITE_FLUX = 7
  25. CMD_GET_FLUX_STATUS = 8
  26. CMD_GET_READ_INFO = 9
  27. # Bootloader-specific:
  28. CMD_UPDATE = 1
  29. ACK_OKAY = 0
  30. ACK_BAD_COMMAND = 1
  31. ACK_NO_INDEX = 2
  32. ACK_NO_TRK0 = 3
  33. ACK_FLUX_OVERFLOW = 4
  34. ACK_FLUX_UNDERFLOW = 5
  35. ACK_WRPROT = 6
  36. ACK_MAX = 6
  37. ack_str = [
  38. "Okay", "Bad Command", "No Index", "Track 0 not found",
  39. "Flux Overflow", "Flux Underflow", "Disk is Write Protected" ]
  40. class CmdError(Exception):
  41. def __init__(self, cmd, code):
  42. self.cmd = cmd
  43. self.code = code
  44. def __str__(self):
  45. if self.code <= ACK_MAX:
  46. return ack_str[self.code]
  47. return "Unknown Error (%u)" % self.code
  48. def send_cmd(cmd):
  49. ser.write(cmd)
  50. (c,r) = struct.unpack("2B", ser.read(2))
  51. assert c == cmd[0]
  52. if r != 0:
  53. raise CmdError(c,r)
  54. def get_fw_info():
  55. send_cmd(struct.pack("3B", CMD_GET_INFO, 3, 0))
  56. x = struct.unpack("<4BI24x", ser.read(32))
  57. return x
  58. def print_fw_info(info):
  59. (major, minor, max_revs, max_cmd, freq) = info
  60. print("Greaseweazle v%u.%u" % (major, minor))
  61. print("Max revs %u" % (max_revs))
  62. print("Max cmd %u" % (max_cmd))
  63. print("Sample frequency: %.2f MHz" % (freq / 1000000))
  64. def seek(cyl, side):
  65. send_cmd(struct.pack("3B", CMD_SEEK, 3, cyl))
  66. send_cmd(struct.pack("3B", CMD_SIDE, 3, side))
  67. def get_delays():
  68. send_cmd(struct.pack("2B", CMD_GET_DELAYS, 2))
  69. return struct.unpack("<4H", ser.read(4*2))
  70. def print_delays(x):
  71. (step_delay, seek_settle, motor_delay, auto_off) = x
  72. print("Step Delay: %ums" % step_delay)
  73. print("Settle Time: %ums" % seek_settle)
  74. print("Motor Delay: %ums" % motor_delay)
  75. print("Auto Off: %ums" % auto_off)
  76. def set_delays(step_delay = None, seek_settle = None,
  77. motor_delay = None, auto_off = None):
  78. (_step_delay, _seek_settle, _motor_delay, _auto_off) = get_delays()
  79. if not step_delay: step_delay = _step_delay
  80. if not seek_settle: seek_settle = _seek_settle
  81. if not motor_delay: motor_delay = _motor_delay
  82. if not auto_off: auto_off = _auto_off
  83. send_cmd(struct.pack("<2B4H", CMD_SET_DELAYS, 10,
  84. step_delay, seek_settle, motor_delay, auto_off))
  85. def motor(state):
  86. send_cmd(struct.pack("3B", CMD_MOTOR, 3, int(state)))
  87. def get_read_info():
  88. send_cmd(struct.pack("2B", CMD_GET_READ_INFO, 2))
  89. x = []
  90. for i in range(7):
  91. x.append(struct.unpack("<2I", ser.read(2*4)))
  92. return x
  93. def print_read_info(info):
  94. for (time, samples) in info:
  95. print("%u ticks, %u samples" % (time, samples))
  96. def write_flux(flux):
  97. start = timer()
  98. x = bytearray()
  99. for val in flux:
  100. if val == 0:
  101. pass
  102. elif val < 250:
  103. x.append(val)
  104. else:
  105. high = val // 250
  106. if high <= 5:
  107. x.append(249+high)
  108. x.append(1 + val%250)
  109. else:
  110. x.append(255)
  111. x.append(1 | (val<<1) & 255)
  112. x.append(1 | (val>>6) & 255)
  113. x.append(1 | (val>>13) & 255)
  114. x.append(1 | (val>>20) & 255)
  115. x.append(0) # End of Stream
  116. end = timer()
  117. #print("%u flux -> %u bytes in %f seconds" % (len(flux), len(x), end-start))
  118. retry = 0
  119. while True:
  120. start = timer()
  121. send_cmd(struct.pack("2B", CMD_WRITE_FLUX, 2))
  122. ser.write(x)
  123. ser.read(1) # Sync with Greaseweazle
  124. try:
  125. send_cmd(struct.pack("2B", CMD_GET_FLUX_STATUS, 2))
  126. except CmdError as error:
  127. if error.code == ACK_FLUX_UNDERFLOW and retry < 5:
  128. retry += 1
  129. print("Retry #%u..." % retry)
  130. continue;
  131. raise
  132. end = timer()
  133. #print("Track written in %f seconds" % (end-start))
  134. break
  135. def read_flux(nr_revs):
  136. retry = 0
  137. while True:
  138. start = timer()
  139. x = collections.deque()
  140. send_cmd(struct.pack("3B", CMD_READ_FLUX, 3, nr_revs))
  141. nr = 0
  142. while True:
  143. x += ser.read(1)
  144. x += ser.read(ser.in_waiting)
  145. nr += 1;
  146. if x[-1] == 0:
  147. break
  148. try:
  149. send_cmd(struct.pack("2B", CMD_GET_FLUX_STATUS, 2))
  150. except CmdError as error:
  151. if error.code == ACK_FLUX_OVERFLOW and retry < 5:
  152. retry += 1
  153. print("Retry #%u..." % retry)
  154. del x
  155. continue;
  156. raise
  157. end = timer()
  158. break
  159. #print("Read %u bytes in %u batches in %f seconds" % (len(x), nr, end-start))
  160. start = timer()
  161. y = []
  162. while x:
  163. i = x.popleft()
  164. if i < 250:
  165. y.append(i)
  166. elif i == 255:
  167. val = (x.popleft() & 254) >> 1
  168. val += (x.popleft() & 254) << 6
  169. val += (x.popleft() & 254) << 13
  170. val += (x.popleft() & 254) << 20
  171. y.append(val)
  172. else:
  173. val = (i - 249) * 250
  174. val += x.popleft() - 1
  175. y.append(val)
  176. assert y[-1] == 0
  177. y = y[:-1]
  178. end = timer()
  179. #print("Processed %u flux values in %f seconds" % (len(y), end-start))
  180. return y
  181. def read(args):
  182. factor = scp_freq / sample_freq
  183. trk_dat = bytearray()
  184. trk_offs = []
  185. if args.single_sided:
  186. track_range = range(args.scyl, args.ecyl+1)
  187. nr_sides = 1
  188. else:
  189. track_range = range(args.scyl*2, (args.ecyl+1)*2)
  190. nr_sides = 2
  191. for i in track_range:
  192. cyl = i >> (nr_sides - 1)
  193. side = i & (nr_sides - 1)
  194. print("\rReading Track %u.%u..." % (cyl, side), end="")
  195. trk_offs.append(len(trk_dat))
  196. seek(cyl, side)
  197. flux = read_flux(args.revs)
  198. info = get_read_info()[:args.revs]
  199. #print_read_info(info)
  200. trk_dat += struct.pack("<3sB", b"TRK", i)
  201. dat_off = 4 + args.revs*12
  202. for (time, samples) in info:
  203. time = int(round(time * factor))
  204. trk_dat += struct.pack("<III", time, samples, dat_off)
  205. dat_off += samples * 2
  206. rem = 0.0
  207. for x in flux:
  208. y = x * factor + rem
  209. val = int(round(y))
  210. rem = y - val
  211. while val >= 65536:
  212. trk_dat.append(0)
  213. trk_dat.append(0)
  214. val -= 65536
  215. if val == 0:
  216. val = 1
  217. trk_dat.append(val>>8)
  218. trk_dat.append(val&255)
  219. print()
  220. csum = 0
  221. for x in trk_dat:
  222. csum += x
  223. trk_offs_dat = bytearray()
  224. for x in trk_offs:
  225. trk_offs_dat += struct.pack("<I", 0x2b0 + x)
  226. trk_offs_dat += bytes(0x2a0 - len(trk_offs_dat))
  227. for x in trk_offs_dat:
  228. csum += x
  229. ds_flag = 0
  230. if args.single_sided:
  231. ds_flag = 1
  232. header_dat = struct.pack("<3s9BI",
  233. b"SCP", # Signature
  234. 0, # Version
  235. 0x80, # DiskType = Other
  236. args.revs, # Nr Revolutions
  237. args.scyl, # Start track
  238. args.ecyl, # End track
  239. 0x21, # Flags = Index, Footer
  240. 0, # 16-bit cell width
  241. ds_flag, # Double Sided
  242. 0, # 25ns capture
  243. csum & 0xffffffff)
  244. with open(args.file, "wb") as f:
  245. f.write(header_dat)
  246. f.write(trk_offs_dat)
  247. f.write(trk_dat)
  248. def write(args):
  249. factor = sample_freq / scp_freq
  250. with open(args.file, "rb") as f:
  251. dat = f.read()
  252. header = struct.unpack("<3s9BI", dat[0:16])
  253. assert header[0] == b"SCP"
  254. trk_offs = struct.unpack("<168I", dat[16:0x2b0])
  255. if args.single_sided:
  256. track_range = range(args.scyl, args.ecyl+1)
  257. nr_sides = 1
  258. else:
  259. track_range = range(args.scyl*2, (args.ecyl+1)*2)
  260. nr_sides = 2
  261. for i in track_range:
  262. cyl = i >> (nr_sides - 1)
  263. side = i & (nr_sides - 1)
  264. print("\rWriting Track %u.%u..." % (cyl, side), end="")
  265. if trk_offs[i] == 0:
  266. continue
  267. seek(cyl, side)
  268. thdr = struct.unpack("<3sBIII", dat[trk_offs[i]:trk_offs[i]+16])
  269. (sig,_,_,samples,off) = thdr
  270. assert sig == b"TRK"
  271. tdat = dat[trk_offs[i]+off:trk_offs[i]+off+samples*2]
  272. flux = []
  273. rem = 0.0
  274. for i in range(0,len(tdat),2):
  275. x = tdat[i]*256 + tdat[i+1]
  276. if x == 0:
  277. rem += 65536.0
  278. continue
  279. y = x * factor + rem
  280. val = int(round(y))
  281. rem = y - val
  282. flux.append(val)
  283. write_flux(flux)
  284. print()
  285. def update(args):
  286. with open(args.file, "rb") as f:
  287. dat = f.read()
  288. (sig, maj, min, pad1, pad2, crc) = struct.unpack(">2s4BH", dat[-8:])
  289. if len(dat) & 3 != 0 or sig != b'GW' or pad1 != 0 or pad2 != 0:
  290. print("%s: Bad update file" % (args.file))
  291. return
  292. crc16 = crcmod.predefined.Crc('crc-ccitt-false')
  293. crc16.update(dat)
  294. if crc16.crcValue != 0:
  295. print("%s: Bad CRC" % (args.file))
  296. print("Updating to v%u.%u..." % (maj, min))
  297. send_cmd(struct.pack("<2BI", CMD_UPDATE, 6, len(dat)))
  298. ser.write(dat)
  299. (ack,) = struct.unpack("B", ser.read(1))
  300. if ack != 0:
  301. print("** UPDATE FAILED: Please retry!")
  302. return
  303. print("Done.")
  304. print("** Now remove the Programming Jumper and reconnect.")
  305. def _main(argv):
  306. actions = {
  307. "read" : read,
  308. "write" : write,
  309. "update" : update
  310. }
  311. parser = argparse.ArgumentParser(
  312. formatter_class=argparse.ArgumentDefaultsHelpFormatter)
  313. parser.add_argument("action")
  314. parser.add_argument("--revs", type=int, default=3,
  315. help="number of revolutions to read per track")
  316. parser.add_argument("--scyl", type=int, default=0,
  317. help="first cylinder to read/write")
  318. parser.add_argument("--ecyl", type=int, default=81,
  319. help="last cylinder to read/write")
  320. parser.add_argument("--single-sided", action="store_true")
  321. # parser.add_argument("--total", type=float, default=8.0,
  322. # help="total length, seconds")
  323. parser.add_argument("file", help="in/out filename")
  324. parser.add_argument("device", help="serial device")
  325. args = parser.parse_args(argv[1:])
  326. if not args.action in actions:
  327. print("** Action \"%s\" is not recognised" % args.action)
  328. print("Valid actions: ", end="")
  329. print(", ".join(str(key) for key in actions.keys()))
  330. return
  331. global ser
  332. ser = serial.Serial(args.device)
  333. ser.baudrate = BAUD_CLEAR_COMMS
  334. ser.baudrate = BAUD_NORMAL
  335. ser.reset_input_buffer()
  336. global sample_freq
  337. info = get_fw_info()
  338. sample_freq = info[4]
  339. update_mode = (info[2] == 0)
  340. print("** %s v%u.%u, Host Tools v%u.%u"
  341. % (("Greaseweazle","Bootloader")[update_mode], info[0], info[1],
  342. version.major, version.minor))
  343. if (not update_mode
  344. and (version.major > info[0]
  345. or (version.major == info[0] and version.minor > info[1]))):
  346. print("Firmware is out of date: Require >= v%u.%u"
  347. % (version.major, version.minor))
  348. print("Install the Update Jumper and \"update <update_file>\"")
  349. return
  350. if update_mode and args.action != "update":
  351. print("Greaseweazle is in Firmware Update Mode:")
  352. print(" The only available action is \"update <update_file>\"")
  353. if info[4] & 1:
  354. print(" Remove the Update Jumper for normal operation")
  355. else:
  356. print(" Main firmware is erased: You *must* perform an update!")
  357. return
  358. if not update_mode and args.action == "update":
  359. print("Greaseweazle is in Normal Mode:")
  360. print(" To \"update\" you must install the Update Jumper")
  361. return
  362. #set_delays(step_delay=3)
  363. #print_delays(get_delays())
  364. actions[args.action](args)
  365. if not update_mode:
  366. motor(False)
  367. def main(argv):
  368. try:
  369. _main(argv)
  370. except CmdError as error:
  371. print("Command Failed: %s" % error)
  372. if __name__ == "__main__":
  373. main(sys.argv)