def test(self, ui, dev):
disabled_die = ui.prompt_int_single("Disabled Die? 0-3, 4=NO")
#option = ui.prompt_int_single("Option?")
for frq in FRQS:
ran_frq = False
while not ran_frq:
try:
self.running = False
time.sleep(1)
# do settings for this round
self.frequency = [frq]*4
self.voltage = [VLT_MIN]*4
if disabled_die <= 3:
#self.frequency[disabled_die] = 0
self.voltage[disabled_die] = 0
# apply settings
self.set(ui)
# get dev
dev = usbctrl.poll_hf_ctrl_device(printer=ui.log)
# run test
self.run(ui, dev, frq)
# mark ready for next
ran_frq = True
self.confirm(ui)
except KeyboardInterrupt:
ui.log('exiting')
ui.end()
return
except:
ui.log("Error in frq")
ui.log("ex: (%s, %s, %s)" % (sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2]))
time.sleep(10)
def debugstream(printer):
# usb ctrl
dev = usbctrl.poll_hf_ctrl_device(printer=printer)
while running:
time.sleep(1)
debug = dev.debug_stream()
if len(debug.stream):
printer("\n{}".format(debug))
def debugstream(printer):
# usb ctrl
dev = usbctrl.poll_hf_ctrl_device(printer=printer)
while running:
time.sleep(1)
debug = dev.debug_stream()
if len(debug.stream):
printer("\n{}".format(debug))
def main(args):
ui = HFProfilerUI()
try:
ui.setup()
ui.refresh()
ui.prompt_show("Please connect device.")
dev = usbctrl.poll_hf_ctrl_device(printer=ui.log)
ret = ui.prompt("HashFast Profiling Tool. Press 's' to start", "s")
if ret:
profiler = HFProfilerInteractive()
profiler.start(ui, dev)
finally:
ui.end()
def main(args):
ui = HFProfilerUI()
try:
ui.setup()
ui.refresh()
ui.prompt_show("Please connect device.")
dev = usbctrl.poll_hf_ctrl_device(printer=ui.log)
ret = ui.prompt("HashFast Profiling Tool. Press 's' to start", "s")
if ret:
profiler = HFProfilerInteractive()
profiler.start(ui, dev)
finally:
ui.end()
def test(self, ui, dev):
option = ui.prompt_int_single("Option?")
for frq in FRQS:
ran_frq = False
while not ran_frq:
try:
time.sleep(1)
# do settings for this round
self.frequency = [frq] * 4
self.voltage = [VLT_MIN] * 4
# apply settings
self.set(ui)
# run voltage test
for vlt in VLTS:
ran_vlt = False
while not ran_vlt:
try:
time.sleep(1)
self.voltage = [vlt] * 4
# set voltage
dev = usbctrl.poll_hf_ctrl_device(
printer=ui.log)
ui.log('setting voltage to {}'.format(vlt))
self.vset(ui, dev)
# run test
self.run(ui, dev, option)
# mark ready for next
ran_vlt = True
except KeyboardInterrupt:
ui.log('exiting')
ui.end()
return
except:
ui.log("Error in vlt")
ran_frq = True
except KeyboardInterrupt:
ui.log('exiting')
ui.end()
return
except:
ui.log("Error in frq")
def test(self, ui, dev):
option = ui.prompt_int_single("Option?")
for frq in FRQS:
ran_frq = False
while not ran_frq:
try:
time.sleep(1)
# do settings for this round
self.frequency = [frq]*4
self.voltage = [VLT_MIN]*4
# apply settings
self.set(ui)
# run voltage test
for vlt in VLTS:
ran_vlt = False
while not ran_vlt:
try:
time.sleep(1)
self.voltage = [vlt]*4
# set voltage
dev = usbctrl.poll_hf_ctrl_device(printer=ui.log)
ui.log('setting voltage to {}'.format(vlt))
self.vset(ui, dev)
# run test
self.run(ui, dev, option)
# mark ready for next
ran_vlt = True
except KeyboardInterrupt:
ui.log('exiting')
ui.end()
return
except:
ui.log("Error in vlt")
ran_frq = True
except KeyboardInterrupt:
ui.log('exiting')
ui.end()
return
except:
ui.log("Error in frq")
def test(self, ui, dev):
disabled_die = ui.prompt_int_single("Disabled Die? 0-3, 4=NO")
#option = ui.prompt_int_single("Option?")
for frq in FRQS:
ran_frq = False
while not ran_frq:
try:
self.running = False
time.sleep(1)
# do settings for this round
self.frequency = [frq] * 4
self.voltage = [VLT_MIN] * 4
if disabled_die <= 3:
#self.frequency[disabled_die] = 0
self.voltage[disabled_die] = 0
# apply settings
self.set(ui)
# get dev
dev = usbctrl.poll_hf_ctrl_device(printer=ui.log)
# run test
self.run(ui, dev, frq)
# mark ready for next
ran_frq = True
self.confirm(ui)
except KeyboardInterrupt:
ui.log('exiting')
ui.end()
return
except:
ui.log("Error in frq")
ui.log("ex: (%s, %s, %s)" %
(sys.exc_info()[0], sys.exc_info()[1],
sys.exc_info()[2]))
time.sleep(10)
def main(args):
# query device
dev = usbctrl.poll_hf_ctrl_device()
print(dev.info())
print(dev.status())
config = dev.config()
print(config)
print(dev.name())
for module in range(config.modules):
print(dev.version(module))
print(dev.serial(module))
print(dev.power(module))
print(dev.fan(module))
if args.fan is not None:
module, fan, speed = args.fan
dev.fan_set(module, fan, speed)
if args.name is not None:
name = args.name
dev.name_set(name)
if args.power is not None:
power = args.power
dev.power_set(0, power)
if args.reboot_app is not None:
module = args.reboot_app
dev.reboot(module, 0x0000)
if args.reboot_load is not None:
module = args.reboot_load
dev.reboot(module, 0x0001)
if args.voltage is not None:
module, die, mvolts = args.voltage
dev.voltage_set(module, die, mvolts)
if args.cores:
print(dev.core_overview())
if args.core_enable is not None:
core, persist = args.core_enable
dev.core_enable(core, persist)
if args.core_disable is not None:
core, persist = args.core_disable
dev.core_disable(core, persist)
if args.core_clear is not None:
persist = args.core_clear
dev.core_clear(persist)
if args.core_status is not None:
core = args.core_status
print(dev.core_status(core))
if args.die_status is not None:
die = args.die_status
t = dev.core_die_status(die)
print(t)
if args.asic_status is not None:
asic = args.asic_status
print(dev.core_asic_status(asic))
if args.debug_stream:
print(dev.debug_stream())
def monitor_temp(self, ui):
runtime = 0
self.req_stop = False
die_stops = [False for x in range(4)]
run_stats = self.run_stats
# get dev
dev = usbctrl.poll_hf_ctrl_device(printer=ui.log)
# wait for init
time.sleep(5)
# monitor
while self.running:
try:
# time
loop_time = 0.4
time.sleep(loop_time)
runtime += loop_time
if runtime > STEP_TIME:
self.req_stop = True
# die voltage
for di, drs in enumerate(run_stats):
this_die = self.test.dies[di]
if this_die['moving'] is None:
continue
#if die_stops[di] is True:
# continue
current_mv = this_die['moving'][-1]
for ri, rs in enumerate(drs):
if rs['s'] is False:
dev.voltage_set(0, di, rs['vlt'])
ui.next_round_die(di, True)
self.voltage[di] = rs['vlt']
rs['s'] = True
rs['sm'] = current_mv
break
if rs['c'] is False:
if rs['sm'] is not current_mv:
######
## Record to CSV
######
# write logfile
with open(self.csvfilename, 'a') as csvfile:
this_die['moving_hashes'] = current_mv['hashes']
this_die['moving_hashrate'] = current_mv['hashrate']
this_die['moving_noncerate'] = current_mv['noncerate']
this_die['moving_lhwrate'] = current_mv['lhwrate']
this_die['moving_dhwrate'] = current_mv['dhwrate']
csvwriter = csv.DictWriter(csvfile, fn, extrasaction='ignore')
csvwriter.writerow(this_die)
###
###
rs['em'] = current_mv
rs['c'] = True
if rs['sm']['hashrate'] > 100*10**9 and (rs['em']['lhwrate'] >= rs['sm']['lhwrate'] or rs['em']['dhwrate'] >= rs['sm']['dhwrate']):
# recommend the last operating point
prev_rs = drs[(ri - 1)]
self.recommend[di].append(prev_rs)
# stop testing this die
die_stops[di] = True
else:
continue
else:
break
for die_stop in die_stops:
if die_stop is False:
break
self.req_stop = True
# ui stats
ui.current_round.total_hashes = self.test.stats['hashes']
ui.current_round.total_errors = self.test.stats['lhw']
ui.current_round.hash_rate = self.test.stats['hashrate']
ui.current_round.stats = self.test.stats
if self.test.dies is not None:
for dinfo in ui.die_info:
if dinfo is not None:
die = self.test.dies[dinfo.index]
if die is not None:
dinfo.die = die
if self.voltage[dinfo.index] is not None:
die['voltage'] = self.voltage[dinfo.index]
dinfo.thermal_cutoff = die['thermal_cutoff']
dinfo.active = die['active']
dinfo.pending = die['pending']
dinfo.temp = die['temperature']
dinfo.vm = die['core_voltage']
except:
ui.log('exception in thread')
def monitor_temp(self, ui):
runtime = 0
self.req_stop = False
die_stops = [False for x in range(4)]
run_stats = self.run_stats
# get dev
dev = usbctrl.poll_hf_ctrl_device(printer=ui.log)
# wait for init
time.sleep(5)
# monitor
while self.running:
try:
# time
loop_time = 0.4
time.sleep(loop_time)
runtime += loop_time
if runtime > STEP_TIME:
self.req_stop = True
# die voltage
for di, drs in enumerate(run_stats):
this_die = self.test.dies[di]
if this_die['moving'] is None:
continue
#if die_stops[di] is True:
# continue
current_mv = this_die['moving'][-1]
for ri, rs in enumerate(drs):
if rs['s'] is False:
dev.voltage_set(0, di, rs['vlt'])
ui.next_round_die(di, True)
self.voltage[di] = rs['vlt']
rs['s'] = True
rs['sm'] = current_mv
break
if rs['c'] is False:
if rs['sm'] is not current_mv:
######
## Record to CSV
######
# write logfile
with open(self.csvfilename, 'a') as csvfile:
this_die['moving_hashes'] = current_mv[
'hashes']
this_die['moving_hashrate'] = current_mv[
'hashrate']
this_die['moving_noncerate'] = current_mv[
'noncerate']
this_die['moving_lhwrate'] = current_mv[
'lhwrate']
this_die['moving_dhwrate'] = current_mv[
'dhwrate']
csvwriter = csv.DictWriter(
csvfile, fn, extrasaction='ignore')
csvwriter.writerow(this_die)
###
###
rs['em'] = current_mv
rs['c'] = True
if rs['sm']['hashrate'] > 100 * 10**9 and (
rs['em']['lhwrate'] >=
rs['sm']['lhwrate']
or rs['em']['dhwrate'] >=
rs['sm']['dhwrate']):
# recommend the last operating point
prev_rs = drs[(ri - 1)]
self.recommend[di].append(prev_rs)
# stop testing this die
die_stops[di] = True
else:
continue
else:
break
for die_stop in die_stops:
if die_stop is False:
break
self.req_stop = True
# ui stats
ui.current_round.total_hashes = self.test.stats['hashes']
ui.current_round.total_errors = self.test.stats['lhw']
ui.current_round.hash_rate = self.test.stats['hashrate']
ui.current_round.stats = self.test.stats
if self.test.dies is not None:
for dinfo in ui.die_info:
if dinfo is not None:
die = self.test.dies[dinfo.index]
if die is not None:
dinfo.die = die
if self.voltage[dinfo.index] is not None:
die['voltage'] = self.voltage[dinfo.index]
dinfo.thermal_cutoff = die['thermal_cutoff']
dinfo.active = die['active']
dinfo.pending = die['pending']
dinfo.temp = die['temperature']
dinfo.vm = die['core_voltage']
except:
ui.log('exception in thread')
def main(args):
if args.debug:
print("WARNING - Debug builds are experimental!")
print("HashFast is not responsible for damage resulting from debug builds.")
updater = HF_Updater()
####################
# BOOTLOADER #
####################
if args.bootloader:
# doing a load, wait for a valid HashFast device
dev = util.poll_hf_device()
if dev is util.USB_DEV_DFU:
# found a device that needs a bootloader
print("Bootloader not detected.")
for flash_size in [512, 128]:
try:
dfu = updater.fetch_release_bootloader(flash=flash_size)
updater.load_firmware_dfu(dfu, flash=flash_size)
break
except:
pass
# wait for device to reboot
util.poll_hf_device()
return
elif dev is util.USB_DEV_HF:
# found device in application mode
updater.dev = usbctrl.poll_hf_ctrl_device(printer=printme)
#updater.enumerate_modules()
updater.enter_loader()
# load firmware
updater.dev_loader = usbctrl.poll_hf_ctrl_device_loader(printer=printme)
updater.enumerate_modules_loader()
# get flash size
loader_version = updater.read_version_loader().version
if loader_version >= 4:
flash_size = int(updater.read_flash_size_loader().flash_size / 1024)
else:
flash_size = 512
print("Using flash_size of: {}k".format(flash_size))
# fetch file
hfu = updater.fetch_release_bootloader_update(flash=flash_size)
updater.load_firmware_hfu(hfu, force=False)
updater.enter_app()
####################
# LIST #
####################
elif args.list:
# list releases/builds
if args.debug:
updater.list_debug_builds()
else:
updater.list_release_firmwares()
####################
# FIRMWARE #
####################
else:
# doing a load, wait for a valid HashFast device
dev = util.poll_hf_device()
if dev is util.USB_DEV_DFU:
# found a device that needs a bootloader
print("Bootloader not detected.")
for flash_size in [512, 128]:
try:
# if no release specified, then latest will be loaded
dfu = updater.fetch_release_bootloader(args.release, flash=flash_size)
updater.load_firmware_dfu(dfu, flash=flash_size)
break
except:
pass
# wait for device to reboot
util.poll_hf_device()
elif dev is util.USB_DEV_HF:
# found device in application mode
updater.dev = usbctrl.poll_hf_ctrl_device(printer=printme)
#updater.enumerate_modules()
updater.enter_loader()
# load firmware
if args.debug or args.build:
if args.build:
updater.dev_loader = usbctrl.poll_hf_ctrl_device_loader(printer=printme)
updater.enumerate_modules_loader()
# get flash size
loader_version = updater.read_version_loader().version
if loader_version >= 4:
flash_size = int(updater.read_flash_size_loader().flash_size / 1024)
else:
flash_size = 512
print("Using flash_size of: {}k".format(flash_size))
# fetch file
hfu = updater.fetch_debug_build(args.build, flash=flash_size)
updater.load_firmware_hfu(hfu)
updater.enter_app()
else:
raise HF_UpdateError("You must specify a debug build with --build BUILD")
else:
# if no release specified, then latest will be loaded
updater.dev_loader = usbctrl.poll_hf_ctrl_device_loader(printer=printme)
updater.enumerate_modules_loader()
# get flash size
loader_version = updater.read_version_loader().version
if loader_version >= 4:
flash_size = int(updater.read_flash_size_loader().flash_size / 1024)
else:
flash_size = 512
print("Using flash_size of: {}k".format(flash_size))
# fetch file
# if no release specified, then latest will be loaded
hfu = updater.fetch_release_firmware(args.release, flash=flash_size)
updater.load_firmware_hfu(hfu)
updater.enter_app()
def main(args):
# query device
dev = usbctrl.poll_hf_ctrl_device()
print(dev.info())
print(dev.status())
config = dev.config()
print(config)
print(dev.name())
for module in range(config.modules):
print(dev.version(module))
print(dev.serial(module))
print(dev.power(module))
print(dev.fan(module))
if args.fan is not None:
module, fan, speed = args.fan
dev.fan_set(module, fan, speed)
if args.name is not None:
name = args.name
dev.name_set(name)
if args.power is not None:
power = args.power
dev.power_set(0, power)
if args.reboot_app is not None:
module = args.reboot_app
dev.reboot(module, 0x0000)
if args.reboot_load is not None:
module = args.reboot_load
dev.reboot(module, 0x0001)
if args.voltage is not None:
module, die, mvolts = args.voltage
dev.voltage_set(module, die, mvolts)
if args.cores:
print(dev.core_overview())
if args.core_enable is not None:
core, persist = args.core_enable
dev.core_enable(core, persist)
if args.core_disable is not None:
core, persist = args.core_disable
dev.core_disable(core, persist)
if args.core_clear is not None:
persist = args.core_clear
dev.core_clear(persist)
if args.core_status is not None:
core = args.core_status
print(dev.core_status(core))
if args.die_status is not None:
die = args.die_status
t = dev.core_die_status(die)
print(t)
if args.asic_status is not None:
asic = args.asic_status
print(dev.core_asic_status(asic))
if args.debug_stream:
print(dev.debug_stream())
