usb.py 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355
  1. # greaseweazle/usb.py
  2. #
  3. # Written & released by Keir Fraser <keir.xen@gmail.com>
  4. #
  5. # This is free and unencumbered software released into the public domain.
  6. # See the file COPYING for more details, or visit <http://unlicense.org>.
  7. import struct
  8. from greaseweazle import version
  9. from greaseweazle.flux import Flux
  10. ## Control-Path command set
  11. class ControlCmd:
  12. ClearComms = 10000
  13. Normal = 9600
  14. ## Command set
  15. class Cmd:
  16. GetInfo = 0
  17. Seek = 1
  18. Side = 2
  19. SetParams = 3
  20. GetParams = 4
  21. Motor = 5
  22. ReadFlux = 6
  23. WriteFlux = 7
  24. GetFluxStatus = 8
  25. GetIndexTimes = 9
  26. Select = 10
  27. # Bootloader specific:
  28. Update = 1
  29. ## Command responses/acknowledgements
  30. class Ack:
  31. Okay = 0
  32. BadCommand = 1
  33. NoIndex = 2
  34. NoTrk0 = 3
  35. FluxOverflow = 4
  36. FluxUnderflow = 5
  37. Wrprot = 6
  38. Max = 6
  39. ## Cmd.{Get,Set}Params indexes
  40. class Params:
  41. Delays = 0
  42. ## CmdError: Encapsulates a command acknowledgement.
  43. class CmdError(Exception):
  44. str = [ "Okay", "Bad Command", "No Index", "Track 0 not found",
  45. "Flux Overflow", "Flux Underflow", "Disk is Write Protected" ]
  46. def __init__(self, cmd, code):
  47. self.cmd = cmd
  48. self.code = code
  49. def __str__(self):
  50. if self.code <= Ack.Max:
  51. return self.str[self.code]
  52. return "Unknown Error (%u)" % self.code
  53. class Unit:
  54. ## Unit information, instance variables:
  55. ## major, minor: Greaseweazle firmware version number
  56. ## max_index: Maximum index timings for Cmd.ReadFlux
  57. ## max_cmd: Maximum Cmd number accepted by this unit
  58. ## sample_freq: Resolution of all time values passed to/from this unit
  59. ## Unit(ser):
  60. ## Accepts a Pyserial instance for Greaseweazle communications.
  61. def __init__(self, ser):
  62. self.ser = ser
  63. self.reset()
  64. # Copy firmware info to instance variables (see above for definitions).
  65. self._send_cmd(struct.pack("3B", Cmd.GetInfo, 3, 0))
  66. x = struct.unpack("<4BI24x", self.ser.read(32))
  67. (self.major, self.minor, self.max_index,
  68. self.max_cmd, self.sample_freq) = x
  69. # Check whether firmware is in update mode: limited command set if so.
  70. self.update_mode = (self.max_index == 0)
  71. if self.update_mode:
  72. self.update_jumpered = (self.sample_freq & 1)
  73. del self.max_index
  74. del self.sample_freq
  75. return
  76. # We are running main firmware: Check whether an update is needed.
  77. # We can use only the GetInfo command if the firmware is out of date.
  78. self.update_needed = (version.major != self.major
  79. or version.minor != self.minor)
  80. if self.update_needed:
  81. return
  82. # Initialise the delay properties with current firmware values.
  83. self._send_cmd(struct.pack("4B", Cmd.GetParams, 4, Params.Delays, 10))
  84. (self._select_delay, self._step_delay,
  85. self._seek_settle_delay, self._motor_delay,
  86. self._auto_off_delay) = struct.unpack("<5H", self.ser.read(10))
  87. ## reset:
  88. ## Resets communications with Greaseweazle.
  89. def reset(self):
  90. self.ser.reset_output_buffer()
  91. self.ser.baudrate = ControlCmd.ClearComms
  92. self.ser.baudrate = ControlCmd.Normal
  93. self.ser.reset_input_buffer()
  94. ## _send_cmd:
  95. ## Send given command byte sequence to Greaseweazle.
  96. ## Raise a CmdError if command fails.
  97. def _send_cmd(self, cmd):
  98. self.ser.write(cmd)
  99. (c,r) = struct.unpack("2B", self.ser.read(2))
  100. assert c == cmd[0]
  101. if r != 0:
  102. raise CmdError(c, r)
  103. ## seek:
  104. ## Seek the selected drive's heads to the specified track (cyl, side).
  105. def seek(self, cyl, side):
  106. self._send_cmd(struct.pack("3B", Cmd.Seek, 3, cyl))
  107. self._send_cmd(struct.pack("3B", Cmd.Side, 3, side))
  108. ## drive_select:
  109. ## Select/deselect the drive.
  110. def drive_select(self, state):
  111. self._send_cmd(struct.pack("3B", Cmd.Select, 3, int(state)))
  112. ## drive_motor:
  113. ## Turn the selected drive's motor on/off.
  114. def drive_motor(self, state):
  115. self._send_cmd(struct.pack("3B", Cmd.Motor, 3, int(state)))
  116. ## _get_index_times:
  117. ## Get index timing values for the last .read_track() command.
  118. def _get_index_times(self, nr):
  119. self._send_cmd(struct.pack("4B", Cmd.GetIndexTimes, 4, 0, nr))
  120. x = struct.unpack("<%dI" % nr, self.ser.read(4*nr))
  121. return x
  122. ## update_firmware:
  123. ## Update Greaseweazle to the given new firmware.
  124. def update_firmware(self, dat):
  125. self._send_cmd(struct.pack("<2BI", Cmd.Update, 6, len(dat)))
  126. self.ser.write(dat)
  127. (ack,) = struct.unpack("B", self.ser.read(1))
  128. return ack
  129. ## _decode_flux:
  130. ## Decode the Greaseweazle data stream into a list of flux samples.
  131. def _decode_flux(self, dat):
  132. flux = []
  133. dat_i = iter(dat)
  134. try:
  135. while True:
  136. i = next(dat_i)
  137. if i < 250:
  138. flux.append(i)
  139. elif i == 255:
  140. val = (next(dat_i) & 254) >> 1
  141. val += (next(dat_i) & 254) << 6
  142. val += (next(dat_i) & 254) << 13
  143. val += (next(dat_i) & 254) << 20
  144. flux.append(val)
  145. else:
  146. val = (i - 249) * 250
  147. val += next(dat_i) - 1
  148. flux.append(val)
  149. except StopIteration:
  150. pass
  151. assert flux[-1] == 0
  152. return flux[:-1]
  153. ## _encode_flux:
  154. ## Convert the given flux timings into an encoded data stream.
  155. def _encode_flux(self, flux):
  156. dat = bytearray()
  157. for val in flux:
  158. if val == 0:
  159. pass
  160. elif val < 250:
  161. dat.append(val)
  162. else:
  163. high = val // 250
  164. if high <= 5:
  165. dat.append(249+high)
  166. dat.append(1 + val%250)
  167. else:
  168. dat.append(255)
  169. dat.append(1 | (val<<1) & 255)
  170. dat.append(1 | (val>>6) & 255)
  171. dat.append(1 | (val>>13) & 255)
  172. dat.append(1 | (val>>20) & 255)
  173. dat.append(0) # End of Stream
  174. return dat
  175. ## _read_track:
  176. ## Private helper which issues command requests to Greaseweazle.
  177. def _read_track(self, nr_revs):
  178. # Request and read all flux timings for this track.
  179. dat = bytearray()
  180. self._send_cmd(struct.pack("3B", Cmd.ReadFlux, 3, nr_revs+1))
  181. while True:
  182. dat += self.ser.read(1)
  183. dat += self.ser.read(self.ser.in_waiting)
  184. if dat[-1] == 0:
  185. break
  186. # Check flux status. An exception is raised if there was an error.
  187. self._send_cmd(struct.pack("2B", Cmd.GetFluxStatus, 2))
  188. return dat
  189. ## read_track:
  190. ## Read and decode flux and index timings for the current track.
  191. def read_track(self, nr_revs, nr_retries=5):
  192. retry = 0
  193. while True:
  194. try:
  195. dat = self._read_track(nr_revs)
  196. except CmdError as error:
  197. # An error occurred. We may retry on transient overflows.
  198. if error.code == Ack.FluxOverflow and retry < nr_retries:
  199. retry += 1
  200. else:
  201. raise error
  202. else:
  203. # Success!
  204. break
  205. # Decode the flux list and read the index-times list.
  206. flux_list = self._decode_flux(dat)
  207. index_list = self._get_index_times(nr_revs+1)
  208. # Clip the initial partial revolution.
  209. to_index = index_list[0]
  210. for i in range(len(flux_list)):
  211. to_index -= flux_list[i]
  212. if to_index < 0:
  213. flux_list[i] = -to_index
  214. flux_list = flux_list[i:]
  215. break
  216. if to_index >= 0:
  217. # We ran out of flux.
  218. flux_list = []
  219. index_list = index_list[1:]
  220. # Success: Return the requested full index-to-index revolutions.
  221. return Flux(index_list, flux_list, self.sample_freq)
  222. ## write_track:
  223. ## Write the given flux stream to the current track via Greaseweazle.
  224. def write_track(self, flux_list, nr_retries=5):
  225. # Create encoded data stream.
  226. dat = self._encode_flux(flux_list)
  227. retry = 0
  228. while True:
  229. try:
  230. # Write the flux stream to the track via Greaseweazle.
  231. self._send_cmd(struct.pack("<2BIB", Cmd.WriteFlux, 7, 0, 1))
  232. self.ser.write(dat)
  233. self.ser.read(1) # Sync with Greaseweazle
  234. self._send_cmd(struct.pack("2B", Cmd.GetFluxStatus, 2))
  235. except CmdError as error:
  236. # An error occurred. We may retry on transient underflows.
  237. if error.code == Ack.FluxUnderflow and retry < nr_retries:
  238. retry += 1
  239. else:
  240. raise error
  241. else:
  242. # Success!
  243. break
  244. ##
  245. ## Delay-property public getters and setters:
  246. ## select_delay: Delay (usec) after asserting drive select
  247. ## step_delay: Delay (usec) after issuing a head-step command
  248. ## seek_settle_delay: Delay (msec) after completing a head-seek operation
  249. ## motor_delay: Delay (msec) after turning on drive spindle motor
  250. ## auto_off_delay: Timeout (msec) since last command upon which all
  251. ## drives are deselected and spindle motors turned off
  252. ##
  253. def _set_delays(self):
  254. self._send_cmd(struct.pack("<3B5H", Cmd.SetParams,
  255. 3+5*2, Params.Delays,
  256. self._select_delay, self._step_delay,
  257. self._seek_settle_delay,
  258. self._motor_delay, self._auto_off_delay))
  259. @property
  260. def select_delay(self):
  261. return self._select_delay
  262. @select_delay.setter
  263. def select_delay(self, select_delay):
  264. self._select_delay = select_delay
  265. self._set_delays()
  266. @property
  267. def step_delay(self):
  268. return self._step_delay
  269. @step_delay.setter
  270. def step_delay(self, step_delay):
  271. self._step_delay = step_delay
  272. self._set_delays()
  273. @property
  274. def seek_settle_delay(self):
  275. return self._seek_settle_delay
  276. @seek_settle_delay.setter
  277. def seek_settle_delay(self, seek_settle_delay):
  278. self._seek_settle_delay = seek_settle_delay
  279. self._set_delays()
  280. @property
  281. def motor_delay(self):
  282. return self._motor_delay
  283. @motor_delay.setter
  284. def motor_delay(self, motor_delay):
  285. self._motor_delay = motor_delay
  286. self._set_delays()
  287. @property
  288. def auto_off_delay(self):
  289. return self._auto_off_delay
  290. @auto_off_delay.setter
  291. def auto_off_delay(self, auto_off_delay):
  292. self._auto_off_delay = auto_off_delay
  293. self._set_delays()
  294. # Local variables:
  295. # python-indent: 4
  296. # End: