Compare commits

...
5 Commits
Author SHA1 Message Date
noahandClaude Opus 4.8 34a1a1f3b1 tuning: structured power + hashrate target dialogs (Round C)
Round 17 C, first GUI increment. Adds "Set power target..." and "Set hashrate
target..." to the right-click config menu, each a value prompt that shows the
miner's current target and the firmware-advertised valid range, and validates the
entry against it.

- Power target routes through the existing set_power_limit path (LuxOS/Braiins/
  WhatsMiner; VNish stays masked per operator guidance). Where the firmware
  advertises an envelope (Braiins: 944-6435 W) the prompt shows and enforces it.
- Hashrate target routes through set_tuning_config for firmware that tunes by
  hashrate (ePIC). The apply path preserves the firmware's current tuning
  algorithm and scaling config (ePIC's set_tuning_config requires both), reading
  them back before writing the new target.

Model gains: MinerRow.tuning_target_label + power/hashrate target min/max
(from data.tuning_capabilities), and MinerCaps.hashrate_target (set when the miner
actively tunes by hashrate via set_tuning_config). miner_probe's settune verb now
mirrors the same algorithm+scaling-preserving apply path.

Verified live (reversibly, restored after): ePIC S19j Pro (10.4.1.6) hashrate
94->92->94 TH via set_tuning_config Ok(true); LuxOS/Braiins power targets via
set_power_limit (see the luxminer profile-name fix). Model tests + SELFTEST pass.

Presets (G3) and per-board manual V/F (G7) are deferred: no firmware enumerates
its presets through the standard tuning_capabilities API.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 11:33:43 -06:00
noahandClaude Opus 4.8 0db89d6c55 miner_probe: add tune (read) + settune (write) verbs for structured tuning
Round 17 C groundwork. `tune <ip>` dumps a miner's structured-tuning surface --
what it supports (power_limit / tuning_percent / tuning_config), its current
target, and the capability envelope (power/hashrate min-max or preset list) the
firmware advertises. `settune <ip> <power|hashrate> <v>` applies a target via
set_tuning_config where supported (ePIC/VNish/WM), falling back to the plain
power-limit setter for a power target on firmware that tunes by power
(LuxOS/Braiins).

Used to map the live fleet before wiring the GUI: ePIC tunes by hashrate via
set_tuning_config (needs an algorithm + scaling config); LuxOS/Braiins tune by
power via set_power_limit; VNish/WM accept set_tuning_config; only Braiins
advertises a min/max envelope; preset lists are not exposed by any firmware's
tuning_capabilities.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 11:21:07 -06:00
noahandClaude Opus 4.8 08b3d56864 luxminer: set power-limit profile by name so the default profile is reachable
Round 17 C, found via live tuning verification. LuxOS set_power_limit mapped
watts to a profile but applied it by the profile's Step. The factory "default"
profile has Step "0", which LuxOS profileset reads as an empty parameter
("Missing profile parameter"), so the setter could never select the default and
a miner nudged off it by a watts limit could not be returned to its factory
point. Key on the profile Name instead (patch 0017).

Verified live on a LuxOS S19j Pro (10.4.1.60): set_power_limit(2700)->480MHz/2632W,
set_power_limit(2900)->default/2794W (previously errored). Unit test updated.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 11:20:51 -06:00
noahandClaude Opus 4.8 4e825f3ee5 health: bare-data per-component tooltips (R2)
Round 17 R2. The Health column's per-icon tooltips were prose ("Hashboard 3:
faulted", "Power supply: OK (drawing power)"). Replace them with just the data an
operator wants:

- Hashboards: an operating board shows its number counting DOWN (n-1..0, left to
  right) and its hashrate ("2  ·  33.5 TH/s"); a faulted board shows its error
  message with the firmware code; a board the failed PSU left untested shows
  "unpowered". No "Hashboard N:" prose.
- Fans: just the RPM ("4700 rpm"), unless the fan has a fault (then the error+code).
- Control board: its own and un-attributed faults with codes, else a short OK.
- Power: a healthy PSU's output voltage + amperage when reported, else a short OK;
  a faulted PSU shows the error and code.

Adds per-board hashrate (BoardData.hashrate) and the firmware error code
(MinerMessage.code) to the model, and forward-compatible PSU output V/A fields.
asic-rs does not yet expose PSU output V/A (roadmap G15), so the healthy-PSU
tooltip shows "PSU OK" until that lands, at which point it auto-upgrades to "V / A".

Unit tests (faults_attribute, health_tooltips_are_bare_data_round17_r2) pass;
SELFTEST PASS. Live data confirmed available (per-board hashrate + fan RPM on the
Braiins corpus miners).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 10:45:15 -06:00
noahandClaude Opus 4.8 8e67c50fe0 health/pic: shrink fan icon (R1), blank PIC for non-Antminers (R6), add build cleanup
Round 17 queue.

R1 -- the cooling-fan icon in the Health column read as oversized next to the
brain/chip/bolt icons. All four use a square 512x512 viewBox at the same slot
size, so the fan only *looked* bigger because the Font Awesome fan glyph fills
its box more. Draw the fan at 80% size, centred in its full-size slot, so the
slot advance and the per-icon tooltip hit-test (both keyed to the full width)
are unchanged and nothing else moves.

R6 -- WhatsMiner and other non-Antminer makes showed "?" in the PIC column. A
per-board PIC MCU is an Antminer hashboard property with no meaning elsewhere, so
the cell now shows nothing for non-Antminer brands; an unknown *Antminer* model
still shows "?".

Build hygiene (user ask) -- add scripts/clean-old-builds.sh to reclaim the local
cargo target dir. The app/CLI ship as release and tests run under --release, so
the debug tree, cross-compile trees, and coverage tree are disposable; a stray
cargo check had grown the debug tree to 38G and filled the disk. The script drops
those, keeps the warm release build, and is meant to run after each release push.

SELFTEST PASS; model tests (pic_locked, faults_attribute, health) pass.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 10:31:51 -06:00
10 changed files with 705 additions and 103 deletions
+142
View File
@@ -466,6 +466,137 @@ async fn factoryreset(ip_s: &str) {
}
}
/// READ-ONLY: dump a miner's structured-tuning surface -- what it supports, its
/// current target, and the capability envelope (power/hashrate min-max, or the
/// preset/mode list) the firmware advertises. Drives the round-17 C tuning work:
/// it shows what each live firmware actually offers before any write is wired up.
async fn tune(ip_s: &str) {
let ip: std::net::IpAddr = match ip_s.parse() {
Ok(ip) => ip,
Err(e) => {
eprintln!("bad ip {ip_s}: {e}");
return;
}
};
let f = factory();
match f.scan_miner(ip).await {
Ok(Some(m)) => {
let data = m.get_data().await;
println!(
"{ip}: {} {} {}",
data.device_info.make, data.device_info.firmware, data.device_info.model
);
println!(
" supports: power_limit={} tuning_percent={} tuning_config={}",
m.supports_set_power_limit(),
m.supports_set_tuning_percent(),
m.supports_tuning_config(),
);
println!(" tuning_percent={:?}", data.tuning_percent);
println!(" tuning_target={:?}", data.tuning_target);
match &data.tuning_capabilities {
Some(c) => {
println!(" caps.power={:?}", c.power);
println!(" caps.hashrate={:?}", c.hashrate);
match &c.presets {
Some(p) => {
println!(" caps.presets.default={:?}", p.default);
println!(" caps.presets[{}]:", p.presets.len());
for t in &p.presets {
println!(" - {t:?}");
}
}
None => println!(" caps.presets=None"),
}
}
None => println!(" tuning_capabilities=None"),
}
}
Ok(None) => eprintln!("no miner at {ip}"),
Err(e) => eprintln!("scan_miner {ip}: {e}"),
}
}
/// WRITE (reversible): apply a structured tuning target via set_tuning_config.
/// `settune <ip> power <watts>` or `settune <ip> hashrate <ths>`. Prints the
/// prior target so the caller can restore it. Used to verify the set_tuning_config
/// path on live corpus hardware (round 17 C) before wiring it into the GUI.
async fn settune(ip_s: &str, kind: &str, value: f64) {
use asic_rs::core::config::tuning::TuningConfig;
use asic_rs::core::data::hashrate::HashRateUnit;
use asic_rs::core::data::miner::TuningTarget;
let ip: std::net::IpAddr = match ip_s.parse() {
Ok(ip) => ip,
Err(e) => {
eprintln!("bad ip {ip_s}: {e}");
return;
}
};
let f = factory();
match f.scan_miner(ip).await {
Ok(Some(m)) => {
let before = m.get_data().await;
eprintln!(
"target {ip}: {} {} {} (supports_tuning_config={}); prior target = {:?}",
before.device_info.make,
before.device_info.firmware,
before.device_info.model,
m.supports_tuning_config(),
before.tuning_target,
);
let target = match kind {
"power" => TuningTarget::Power(Power::from_watts(value)),
// Clone the miner's current HashRate to inherit its algorithm
// (HashAlgorithm is not publicly re-exported, so it cannot be named
// directly), overriding just the value and unit.
"hashrate" => match before.hashrate.clone() {
Some(mut hr) => {
hr.value = value;
hr.unit = HashRateUnit::TeraHash;
TuningTarget::HashRate(hr)
}
None => {
eprintln!("miner reports no current hashrate; cannot build a hashrate target");
return;
}
},
_ => {
eprintln!("kind must be 'power' or 'hashrate'");
return;
}
};
// Route by what the firmware actually supports: structured
// set_tuning_config where available (ePIC/VNish/WM), else the plain
// power-limit setter for a power target (LuxOS/Braiins tune by power
// and expose no set_tuning_config).
if m.supports_tuning_config() {
// Mirror the GUI apply path: preserve the firmware's current tuning
// algorithm + scaling (ePIC requires both for set_tuning_config).
let mut cfg = TuningConfig::new(target);
if let Some(algo) = m.get_tuning_config().await.ok().and_then(|c| c.algorithm) {
cfg = cfg.with_algorithm(algo);
}
let scaling = m.get_scaling_config().await.ok();
match m.set_tuning_config(cfg, scaling).await {
Ok(v) => println!("set_tuning_config({kind} {value}) -> Ok({v})"),
Err(e) => println!("set_tuning_config({kind} {value}) -> Err: {e:#}"),
}
} else if kind == "power" && m.supports_set_power_limit() {
match m.set_power_limit(Power::from_watts(value)).await {
Ok(v) => println!("set_power_limit({value} W) -> Ok({v}) [tuning_config unsupported]"),
Err(e) => println!("set_power_limit({value} W) -> Err: {e:#}"),
}
} else {
println!("no structured-tuning path for {kind} on this firmware");
}
let after = m.get_data().await;
println!(" target now = {:?}", after.tuning_target);
}
Ok(None) => eprintln!("no miner at {ip}"),
Err(e) => eprintln!("scan_miner {ip}: {e}"),
}
}
fn main() {
let args: Vec<String> = std::env::args().collect();
let rt = match tokio::runtime::Builder::new_current_thread().enable_all().build() {
@@ -497,6 +628,15 @@ fn main() {
rt.block_on(setpools(&args[2], &args[3], &args[4], &args[5]))
}
Some("msgs") if args.len() == 3 => rt.block_on(msgs(&args[2])),
Some("tune") if args.len() == 3 => rt.block_on(tune(&args[2])),
Some("settune") if args.len() == 5 && matches!(args[3].as_str(), "power" | "hashrate") => {
let value: f64 = args[4].parse().unwrap_or(-1.0);
if value <= 0.0 {
eprintln!("value must be a positive number");
std::process::exit(2);
}
rt.block_on(settune(&args[2], &args[3], value));
}
Some("timezone") if args.len() == 3 => rt.block_on(timezone(&args[2], None)),
Some("timezone") if args.len() == 4 => rt.block_on(timezone(&args[2], Some(&args[3]))),
Some("passwd") if args.len() == 4 => rt.block_on(passwd(&args[2], &args[3])),
@@ -509,6 +649,7 @@ fn main() {
\x20 scan <cidr> [<cidr>...] discover + telemetry (TSV)\n\
\x20 hashrate <cidr> [<cidr>...] raw hashrate/algo dump\n\
\x20 msgs <ip> structured faults + per-board data\n\
\x20 tune <ip> structured-tuning support + capability envelope\n\
\n\
WRITE (MUTATES the miner -- use the test-bed miners, not production):\n\
\x20 light <ip> <on|off> set the locate light\n\
@@ -517,6 +658,7 @@ fn main() {
\x20 resume <ip> resume mining\n\
\x20 restart <ip> restart/reboot\n\
\x20 setpl <ip> <watts> set power limit\n\
\x20 settune <ip> <power|hashrate> <v> set a structured tuning target (prints prior)\n\
\x20 setpools <ip> <url> <user> <pass> set the default pool group\n\
\x20 timezone <ip> [<IANA>] read (no arg) or set the timezone\n\
\x20 passwd <ip> <newpass> change the web/API password (DANGEROUS)\n\
+9
View File
@@ -60,6 +60,13 @@ impl Board {
} else {
vec![]
};
// Per-board hashrate for the R2 Health tooltip demo: split the total three
// ways with a little variety (index-aligned with the 3 boards).
let board_hashrates = if self.mining && self.hashrate > 0.0 {
vec![self.hashrate * 0.34, self.hashrate * 0.35, self.hashrate * 0.31]
} else {
vec![]
};
// Air-cooled WhatsMiners report an ambient reading (asic-rs surfaces it in
// its fluid_temperature field); the scan routes it to env_temp for
// air-cooled models, so the demo mirrors that (round 11 #17).
@@ -109,6 +116,7 @@ impl Board {
board_code,
hashrate_ths: self.hashrate,
expected_ths: self.expected,
board_hashrates,
efficiency,
power_w: self.power,
chip_temp_c: self.temp,
@@ -157,6 +165,7 @@ impl Board {
resume: self.mining,
power_limit: self.mining,
tuning: self.mining,
hashrate_target: self.mining,
firmware_flash,
pools: true,
timezone: self.mining,
+165 -74
View File
@@ -213,6 +213,10 @@ pub struct MinerCaps {
pub resume: bool,
pub power_limit: bool,
pub tuning: bool,
/// Round 17 C: supports setting a structured hashrate target via
/// `set_tuning_config` (the firmware actively tunes by hashrate, e.g. ePIC).
/// Power targets are covered by `power_limit`.
pub hashrate_target: bool,
/// Whether this miner's asic-rs driver supports `upgrade_firmware`
/// (probed via `supports_upgrade_firmware()` at scan time).
pub firmware_flash: bool,
@@ -236,6 +240,7 @@ impl MinerCaps {
resume: self.resume && other.resume,
power_limit: self.power_limit && other.power_limit,
tuning: self.tuning && other.tuning,
hashrate_target: self.hashrate_target && other.hashrate_target,
firmware_flash: self.firmware_flash && other.firmware_flash,
pools: self.pools && other.pools,
timezone: self.timezone && other.timezone,
@@ -268,6 +273,7 @@ impl MinerCaps {
|| self.resume
|| self.power_limit
|| self.tuning
|| self.hashrate_target
|| self.firmware_flash
|| self.pools
|| self.timezone
@@ -306,10 +312,26 @@ pub enum FaultComponent {
pub struct Fault {
pub component: FaultComponent,
pub message: String,
/// Firmware's numeric error code for this message, or 0 when none. Shown in
/// the tooltip alongside the text (round 17 R2) so an operator can look the
/// code up.
pub code: u64,
/// True for Error severity; false for Warning. (Info is dropped upstream.)
pub is_error: bool,
}
impl Fault {
/// The tooltip line for this fault: the message, with the firmware error code
/// appended when there is one (round 17 R2).
pub fn display_line(&self) -> String {
if self.code != 0 {
format!("{} (code {})", self.message, self.code)
} else {
self.message.clone()
}
}
}
/// One component's health for the Health icon column (round 13 #3). Rendered as a
/// coloured icon: grey = unreachable / not detected, red = detected but not
/// functioning, yellow = functioning sub-optimally, green = fully functioning.
@@ -394,9 +416,29 @@ pub struct MinerRow {
// performance
pub hashrate_ths: f64,
pub expected_ths: f64,
/// Per-hashboard hashrate in TH/s, index-aligned with the hashboards (index 0
/// = board 1). Drives the per-board Health tooltip (round 17 R2). Empty when
/// the firmware reports no per-board hashrate.
pub board_hashrates: Vec<f64>,
#[allow(dead_code)] // retained for the "slow" band; not shown as its own column
pub efficiency: f64,
pub power_w: f64,
/// PSU output voltage/current, when the firmware reports them (round 17 R2 /
/// roadmap G15). `None` until the PSU-info scan lands; the power tooltip then
/// shows "V / A" for a healthy PSU instead of a bare "PSU OK".
pub psu_out_voltage_v: Option<f64>,
pub psu_out_current_a: Option<f64>,
/// Current structured tuning target, rendered for display (e.g. "2832 W",
/// "96 TH/s", "preset 3550"), or None (round 17 C).
pub tuning_target_label: Option<String>,
/// Advertised power-target envelope in watts, when the firmware reports one
/// (round 17 C, e.g. Braiins 944-6435 W). Bounds + validate the power-target
/// prompt; `None` leaves it unbounded.
pub power_target_min_w: Option<f64>,
pub power_target_max_w: Option<f64>,
/// Advertised hashrate-target envelope in TH/s, when reported (round 17 C).
pub hashrate_target_min_ths: Option<f64>,
pub hashrate_target_max_ths: Option<f64>,
pub tuning_percent: Option<u8>,
// thermal / cooling
/// Average chip temperature (used for sorting/colour banding of the
@@ -625,7 +667,7 @@ impl MinerRow {
self.faults
.iter()
.filter(|f| f.component == component)
.map(|f| f.message.clone())
.map(|f| f.display_line())
.collect()
}
@@ -635,7 +677,7 @@ impl MinerRow {
self.faults
.iter()
.filter(|f| matches!(f.component, FaultComponent::Other | FaultComponent::Control))
.map(|f| f.message.clone())
.map(|f| f.display_line())
.collect()
}
@@ -646,84 +688,86 @@ impl MinerRow {
/// reports for that component.
pub fn health_tooltips(&self, max_fans: usize, max_boards: usize) -> Vec<String> {
let mut tips: Vec<String> = Vec::with_capacity(2 + max_fans + max_boards);
// Power -- the bolt icon carries any power-supply faults (round 16 #2).
// Power (bolt). A working PSU shows its output voltage + amperage when the
// firmware reports them (else a short OK); a faulted one shows the error
// and code instead (round 17 R2). asic-rs does not yet surface PSU output
// V/A (roadmap G15), so `psu_output` is None until that lands and the OK
// branch shows just the status.
let power_faults = self.fault_texts_for(FaultComponent::Power);
let mut power = format!(
"Power supply: {}",
match self.power_health() {
CompHealth::Ok => "OK (drawing power)",
CompHealth::Down if !power_faults.is_empty() => "fault reported",
CompHealth::Down => "detected but not delivering",
CompHealth::Degraded => "sub-optimal",
CompHealth::Unreachable => "unknown (no wattage/PSU-fan reported)",
}
);
for e in &power_faults {
power.push('\n');
power.push_str(e);
if !power_faults.is_empty() {
tips.push(power_faults.join("\n"));
} else {
tips.push(match (self.power_health(), self.psu_output_label()) {
(CompHealth::Ok, Some(va)) => va,
(CompHealth::Ok, None) => "PSU OK".to_string(),
(CompHealth::Degraded, _) => "PSU sub-optimal".to_string(),
(CompHealth::Down, _) => "PSU not delivering".to_string(),
(CompHealth::Unreachable, _) => "PSU unknown".to_string(),
});
}
tips.push(power);
// Control board -- also carries the miner's un-attributed / control faults.
let mut ctl = format!(
"Control board: {}",
match self.control_health() {
CompHealth::Ok => "OK (miner reachable)",
CompHealth::Degraded => "miner-level fault",
CompHealth::Down => "fault reported",
CompHealth::Unreachable => "unknown",
}
);
for e in self.general_fault_texts() {
ctl.push('\n');
ctl.push_str(&e);
// Control board (brain) -- its own and the miner's un-attributed faults
// with codes; a short OK when clean.
let ctl_faults = self.general_fault_texts();
if !ctl_faults.is_empty() {
tips.push(ctl_faults.join("\n"));
} else {
tips.push(match self.control_health() {
CompHealth::Ok => "Control board OK".to_string(),
_ => "Control board fault".to_string(),
});
}
tips.push(ctl);
// Fans.
// Fans -- just the RPM, unless the fan has a fault (then the error+code).
let fans = self.fan_healths();
for i in 0..max_fans {
let s = match fans.get(i) {
Some(CompHealth::Ok) => {
let rpm = self.fan_rpms.get(i).map(|r| format!(" ({:.0} rpm)", r)).unwrap_or_default();
format!("spinning{rpm}")
let fault = self.fault_texts_for(FaultComponent::Fan(i));
let t = if !fault.is_empty() {
fault.join("\n")
} else {
match fans.get(i) {
Some(_) => format!("{:.0} rpm", self.fan_rpms.get(i).copied().unwrap_or(0.0)),
None => String::new(), // padding slot for fleet alignment
}
Some(CompHealth::Degraded) => {
let rpm = self.fan_rpms.get(i).map(|r| format!(" ({:.0} rpm)", r)).unwrap_or_default();
format!("slow{rpm}")
}
Some(CompHealth::Down) => "stopped (0 rpm)".to_string(),
Some(CompHealth::Unreachable) => "expected but not detected".to_string(),
None => "not present".to_string(),
};
let mut t = format!("Fan {}: {s}", i + 1);
for e in self.fault_texts_for(FaultComponent::Fan(i)) {
t.push('\n');
t.push_str(&e);
}
tips.push(t);
}
// Hashboards. When the PSU has failed the boards can't be tested, so they
// read "unpowered" (grey) rather than "faulted" (round 16 #2/#3).
// Hashboards -- an operating board shows its number (counting DOWN, n-1..0,
// left to right) and hashrate; a faulted board shows its error+code; a
// board the failed PSU left untested shows "unpowered" (round 17 R2,
// round 16 #2/#3). No generic "Hashboard N: faulted" prose.
let boards = self.board_healths();
let psu_down = self.power_supply_faulted();
let n = self.hashboards.map(|v| v as usize).unwrap_or(boards.len());
for i in 0..max_boards {
let s = match boards.get(i) {
Some(CompHealth::Ok) => "hashing".to_string(),
Some(CompHealth::Degraded) => "hashing sub-optimally".to_string(),
Some(CompHealth::Down) => "faulted".to_string(),
Some(CompHealth::Unreachable) if psu_down => "unpowered (PSU fault)".to_string(),
Some(CompHealth::Unreachable) => "expected but not detected".to_string(),
None => "not present".to_string(),
let fault = self.fault_texts_for(FaultComponent::Board(i));
let t = if !fault.is_empty() {
fault.join("\n")
} else if matches!(boards.get(i), Some(CompHealth::Unreachable)) && psu_down {
"unpowered (PSU fault)".to_string()
} else if i < n {
let num = n - 1 - i; // count down, left to right
match self.board_hashrates.get(i).copied() {
Some(hr) if hr > 0.0 => format!("{num} \u{00b7} {hr:.1} TH/s"),
_ => num.to_string(),
}
} else {
String::new() // padding slot for fleet alignment
};
let mut t = format!("Hashboard {}: {s}", i + 1);
for e in self.fault_texts_for(FaultComponent::Board(i)) {
t.push('\n');
t.push_str(&e);
}
tips.push(t);
}
tips
}
/// The PSU output "V / A" tooltip label when the firmware reports it, else
/// None. asic-rs does not yet expose PSU output voltage/current (roadmap G15),
/// so this is a forward-compatible hook that stays None for now (round 17 R2).
fn psu_output_label(&self) -> Option<String> {
match (self.psu_out_voltage_v, self.psu_out_current_a) {
(Some(v), Some(a)) if v > 0.0 => Some(format!("{v:.1} V \u{00b7} {a:.1} A")),
(Some(v), None) if v > 0.0 => Some(format!("{v:.1} V")),
_ => None,
}
}
/// Compact plain-text summary of component health (round 13 #3), used as the
/// Health column's filter/sort-fallback text and the base of its hover
/// tooltip. e.g. "power ok, fans 3/4, boards 3/3".
@@ -1221,11 +1265,20 @@ impl Column {
Column::Cpu => r.cpu.clone(),
Column::BoardCode => r.board_code.clone(),
Column::Algorithm => r.algorithm.clone(),
Column::Pic => match r.pic_present {
Some(true) => "PIC".to_string(),
Some(false) => "noPIC".to_string(),
None => "?".to_string(),
},
Column::Pic => {
// A per-board PIC MCU is an Antminer hashboard property; it has no
// meaning for WhatsMiner or any other make, which show nothing
// rather than a "?" that implies an unanswered Antminer question.
if !r.brand.eq_ignore_ascii_case("antminer") {
String::new()
} else {
match r.pic_present {
Some(true) => "PIC".to_string(),
Some(false) => "noPIC".to_string(),
None => "?".to_string(),
}
}
}
Column::Locked => match r.write_locked {
Some(true) => "locked".to_string(),
Some(false) => "unlocked".to_string(),
@@ -1645,6 +1698,7 @@ mod tests {
let fault = |c: FaultComponent, m: &str| Fault {
component: c,
message: m.to_string(),
code: 0,
is_error: true,
};
let r = MinerRow {
@@ -1687,6 +1741,41 @@ mod tests {
assert!(ptips[2 + 2].contains("unpowered")); // first board tooltip
}
#[test]
fn health_tooltips_are_bare_data_round17_r2() {
// R2: operating boards show their number counting DOWN (n-1..0) left to
// right plus hashrate; fans show just RPM; a fault shows the message with
// its code; no "Hashboard N: faulted" prose.
let r = MinerRow {
is_mining: true,
hashboards: Some(3),
board_status: vec![BoardHealth::Ok, BoardHealth::Ok, BoardHealth::Fault],
board_hashrates: vec![33.5, 34.6, 0.0],
expected_fans: Some(2),
fan_rpms: vec![4700.0, 4650.0],
power_w: 3000.0,
faults: vec![Fault {
component: FaultComponent::Board(2),
message: "Slot 2 chip failure.".to_string(),
code: 540,
is_error: true,
}],
..Default::default()
};
let tips = r.health_tooltips(2, 3);
// power OK (no V/A yet), control OK, 2 fans, 3 boards.
assert_eq!(tips[0], "PSU OK");
assert_eq!(tips[1], "Control board OK");
assert_eq!(tips[2], "4700 rpm");
assert_eq!(tips[3], "4650 rpm");
// Boards count DOWN left->right: leftmost = 2, then 1, then 0.
assert!(tips[4].starts_with("2") && tips[4].contains("33.5 TH/s"), "{}", tips[4]);
assert!(tips[5].starts_with("1") && tips[5].contains("34.6 TH/s"), "{}", tips[5]);
// The faulted board shows its error WITH the code, no "Hashboard" prose.
assert!(tips[6].contains("Slot 2 chip failure.") && tips[6].contains("540"), "{}", tips[6]);
assert!(!tips[6].to_lowercase().contains("hashboard"), "{}", tips[6]);
}
#[test]
fn kpis_match_expected_hardware_output() {
// This does not hardcode fixture counts: it independently recomputes
@@ -1984,13 +2073,14 @@ mod tests {
#[test]
fn pic_locked_error_columns_render() {
// PIC (best-effort): known -> PIC/noPIC, unknown -> "?".
let pic = MinerRow { pic_present: Some(true), ..Default::default() };
let nopic = MinerRow { pic_present: Some(false), ..Default::default() };
let pic_unknown = MinerRow { pic_present: None, ..Default::default() };
assert_eq!(Column::Pic.cell(&pic), "PIC");
assert_eq!(Column::Pic.cell(&nopic), "noPIC");
assert_eq!(Column::Pic.cell(&pic_unknown), "?");
// PIC (best-effort): Antminer known -> PIC/noPIC, unknown Antminer -> "?".
let am = |pic| MinerRow { brand: "Antminer".into(), pic_present: pic, ..Default::default() };
assert_eq!(Column::Pic.cell(&am(Some(true))), "PIC");
assert_eq!(Column::Pic.cell(&am(Some(false))), "noPIC");
assert_eq!(Column::Pic.cell(&am(None)), "?");
// Non-Antminer makes: PIC has no meaning -> blank, never "?".
let wm = MinerRow { brand: "WhatsMiner".into(), pic_present: None, ..Default::default() };
assert_eq!(Column::Pic.cell(&wm), "");
// Access column.
let locked = MinerRow { write_locked: Some(true), ..Default::default() };
@@ -2253,6 +2343,7 @@ mod tests {
resume: true,
power_limit: true,
tuning: true,
hashrate_target: true,
firmware_flash: true,
pools: true,
timezone: true,
+94 -2
View File
@@ -505,6 +505,7 @@ fn messages_to_faults(
Some(Fault {
component,
message: text.to_string(),
code: m.code,
is_error,
})
})
@@ -573,6 +574,20 @@ async fn to_row(miner: &dyn Miner) -> MinerRow {
})
.filter(|&t| t > 0.0)
.collect();
// Per-board hashrate (TH/s), index-aligned with the hashboards, for the
// per-board Health tooltip (round 17 R2). Unlike board_temps this is NOT
// filtered/compacted -- index i must stay board i so the tooltip numbering
// lines up.
let board_hashrates: Vec<f64> = data
.hashboards
.iter()
.map(|b| {
b.hashrate
.as_ref()
.map(|h| h.clone().as_unit(asic_rs::core::data::hashrate::HashRateUnit::TeraHash).value)
.unwrap_or(0.0)
})
.collect();
let fan_rpms: Vec<f64> = data
.fans
.iter()
@@ -660,6 +675,47 @@ async fn to_row(miner: &dyn Miner) -> MinerRow {
// VNish; Braiins and the rest keep asic-rs's answer.
let power_limit = miner.supports_set_power_limit()
&& !data.device_info.firmware.eq_ignore_ascii_case("VNish");
// Structured tuning (round 17 C). Extract the current target + the advertised
// envelope so the "Set performance target" prompt can show/validate bounds.
use asic_rs::core::data::miner::TuningTarget;
let target_watts = |t: &TuningTarget| match t {
TuningTarget::Power(p) => Some(p.as_watts()),
_ => None,
};
let target_ths = |t: &TuningTarget| match t {
TuningTarget::HashRate(h) => Some(
h.clone()
.as_unit(asic_rs::core::data::hashrate::HashRateUnit::TeraHash)
.value,
),
_ => None,
};
let (power_target_min_w, power_target_max_w, hashrate_target_min_ths, hashrate_target_max_ths) =
match &data.tuning_capabilities {
Some(c) => (
c.power.as_ref().and_then(|p| p.minimum.as_ref()).and_then(&target_watts),
c.power.as_ref().and_then(|p| p.maximum.as_ref()).and_then(&target_watts),
c.hashrate.as_ref().and_then(|h| h.minimum.as_ref()).and_then(&target_ths),
c.hashrate.as_ref().and_then(|h| h.maximum.as_ref()).and_then(&target_ths),
),
None => (None, None, None, None),
};
let tuning_target_label = data.tuning_target.as_ref().map(|t| match t {
TuningTarget::Power(p) => format!("{:.0} W", p.as_watts()),
TuningTarget::HashRate(h) => format!(
"{:.0} TH/s",
h.clone().as_unit(asic_rs::core::data::hashrate::HashRateUnit::TeraHash).value
),
TuningTarget::MiningMode(m) => format!("mode {m}"),
TuningTarget::Preset(s) => format!("preset {s}"),
TuningTarget::Manual { .. } => "manual".to_string(),
});
// A hashrate target is offerable only where the firmware actively tunes by
// hashrate through set_tuning_config (ePIC); Braiins advertises a hashrate
// envelope but has no set_tuning_config wired, so it is excluded.
let tunes_by_hashrate = matches!(data.tuning_target, Some(TuningTarget::HashRate(_)))
|| data.tuning_capabilities.as_ref().map(|c| c.hashrate.is_some()).unwrap_or(false);
let hashrate_target = miner.supports_tuning_config() && tunes_by_hashrate;
// Probe what this miner supports being told to do (sync, no extra I/O).
let caps = MinerCaps {
fault_light: miner.supports_set_fault_light(),
@@ -668,6 +724,7 @@ async fn to_row(miner: &dyn Miner) -> MinerRow {
resume: miner.supports_resume(),
power_limit,
tuning: miner.supports_set_tuning_percent(),
hashrate_target,
firmware_flash: miner.supports_upgrade_firmware(),
pools: miner.supports_pools_config(),
timezone: miner.supports_timezone_config(),
@@ -751,8 +808,18 @@ async fn to_row(miner: &dyn Miner) -> MinerRow {
board_code,
hashrate_ths,
expected_ths,
board_hashrates,
efficiency: data.efficiency.unwrap_or(0.0),
power_w,
// PSU output V/A is not yet exposed by asic-rs (roadmap G15); the tooltip
// falls back to a status string until it is.
psu_out_voltage_v: None,
psu_out_current_a: None,
tuning_target_label,
power_target_min_w,
power_target_max_w,
hashrate_target_min_ths,
hashrate_target_max_ths,
tuning_percent: data.tuning_percent,
chip_temp_c,
board_temps,
@@ -790,7 +857,8 @@ pub enum ConfigAction {
Restart,
Pause,
Resume,
PowerLimit(f64), // watts
PowerLimit(f64), // watts
HashRateTarget(f64), // TH/s -- structured hashrate target (round 17 C)
TuningPercent(u8),
Timezone(String), // IANA zone, e.g. "America/Edmonton" (round 17 B / G10)
ChangePassword(String), // new web/API password (round 17 B / G11)
@@ -806,7 +874,8 @@ impl ConfigAction {
ConfigAction::Restart => "restart".into(),
ConfigAction::Pause => "pause".into(),
ConfigAction::Resume => "resume".into(),
ConfigAction::PowerLimit(w) => format!("power limit {w:.0} W"),
ConfigAction::PowerLimit(w) => format!("power target {w:.0} W"),
ConfigAction::HashRateTarget(t) => format!("hashrate target {t:.0} TH/s"),
ConfigAction::TuningPercent(p) => format!("tuning {p}%"),
ConfigAction::Timezone(tz) => format!("timezone {tz}"),
ConfigAction::ChangePassword(_) => "change password".into(),
@@ -824,6 +893,7 @@ impl ConfigAction {
ConfigAction::Pause => "pausing…".into(),
ConfigAction::Resume => "resuming…".into(),
ConfigAction::PowerLimit(_) => "setting power…".into(),
ConfigAction::HashRateTarget(_) => "setting hashrate…".into(),
ConfigAction::TuningPercent(_) => "tuning…".into(),
ConfigAction::Timezone(_) => "setting timezone…".into(),
ConfigAction::ChangePassword(_) => "changing password…".into(),
@@ -858,6 +928,28 @@ async fn apply_action(miner: &dyn Miner, action: &ConfigAction) -> Result<bool,
ConfigAction::Pause => miner.pause(None).await,
ConfigAction::Resume => miner.resume(None).await,
ConfigAction::PowerLimit(w) => miner.set_power_limit(Power::from_watts(*w)).await,
ConfigAction::HashRateTarget(ths) => {
use asic_rs::core::config::tuning::TuningConfig;
use asic_rs::core::data::hashrate::HashRateUnit;
use asic_rs::core::data::miner::TuningTarget;
// Build a HashRate target by cloning the miner's current hashrate to
// inherit its algorithm (HashAlgorithm is not publicly nameable),
// overriding value + unit.
let data = miner.get_data().await;
let Some(mut hr) = data.hashrate.clone() else {
return Err("miner reports no current hashrate; cannot set a hashrate target".into());
};
hr.value = *ths;
hr.unit = HashRateUnit::TeraHash;
let mut cfg = TuningConfig::new(TuningTarget::HashRate(hr));
// Preserve the firmware's current tuning algorithm + scaling (ePIC
// requires both for set_tuning_config; other firmware ignore them).
if let Some(algo) = miner.get_tuning_config().await.ok().and_then(|c| c.algorithm) {
cfg = cfg.with_algorithm(algo);
}
let scaling = miner.get_scaling_config().await.ok();
miner.set_tuning_config(cfg, scaling).await
}
ConfigAction::TuningPercent(p) => miner.set_tuning_percent(*p).await,
ConfigAction::Timezone(tz) => {
use asic_rs::core::config::timezone::{Tz, TimezoneConfig};
+98 -5
View File
@@ -66,6 +66,7 @@ const ID_CTX_PAUSE: i32 = 725;
const ID_CTX_RESUME: i32 = 726;
const ID_CTX_TUNING: i32 = 727;
const ID_CTX_POWER: i32 = 728;
const ID_CTX_HASHRATE: i32 = 740; // Set hashrate target (round 17 C)
const ID_CTX_RESTART: i32 = 729;
// Round 17 B: timezone / change-password / factory-reset config actions.
const ID_CTX_TIMEZONE: i32 = 737;
@@ -97,6 +98,7 @@ const ID_ACTION_CANCEL: i32 = 741;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum PromptKind {
Power,
HashRateTarget,
Tuning,
Timezone,
Password,
@@ -1483,7 +1485,10 @@ impl App {
menu.menu_append(ID_CTX_TUNING, &format!("Set tuning %...{sfx}"));
}
if caps.power_limit {
menu.menu_append(ID_CTX_POWER, &format!("Set power limit...{sfx}"));
menu.menu_append(ID_CTX_POWER, &format!("Set power target...{sfx}"));
}
if caps.hashrate_target {
menu.menu_append(ID_CTX_HASHRATE, &format!("Set hashrate target...{sfx}"));
}
if caps.restart {
menu.menu_append(ID_CTX_RESTART, &format!("Restart{sfx}"));
@@ -2115,6 +2120,7 @@ impl App {
ID_CTX_RESTART => return Some(self.build_confirm_dialog(scan::ConfigAction::Restart)),
// Value entry is itself the confirmation.
ID_CTX_POWER => return Some(self.build_action_prompt(PromptKind::Power)),
ID_CTX_HASHRATE => return Some(self.build_action_prompt(PromptKind::HashRateTarget)),
ID_CTX_TUNING => return Some(self.build_action_prompt(PromptKind::Tuning)),
ID_CTX_TIMEZONE => return Some(self.build_action_prompt(PromptKind::Timezone)),
ID_CTX_PASSWORD => return Some(self.build_action_prompt(PromptKind::Password)),
@@ -2165,21 +2171,81 @@ impl App {
/// A small modal to enter a power limit (watts) or tuning percent for the
/// selection. Built here, shown modally by `dispatch` outside the App borrow.
/// The tightest common tuning envelope (max of the mins .. min of the maxes)
/// across the captured-selection miners that advertise one, plus their shared
/// current-target label ("varies" if they differ), for the target prompts
/// (round 17 C). `get` picks the (min, max) pair for the target kind.
fn selected_envelope(
&self,
get: impl Fn(&MinerRow) -> (Option<f64>, Option<f64>),
) -> (Option<(f64, f64)>, Option<String>) {
let sel = self
.rows
.iter()
.filter(|r| self.action_ips.contains(&r.ip));
let mut lo: Option<f64> = None;
let mut hi: Option<f64> = None;
let mut labels: std::collections::HashSet<String> = std::collections::HashSet::new();
for r in sel {
let (mn, mx) = get(r);
if let Some(m) = mn {
lo = Some(lo.map_or(m, |v: f64| v.max(m)));
}
if let Some(m) = mx {
hi = Some(hi.map_or(m, |v: f64| v.min(m)));
}
if let Some(l) = &r.tuning_target_label {
labels.insert(l.clone());
}
}
let range = match (lo, hi) {
(Some(a), Some(b)) if a <= b => Some((a, b)),
_ => None,
};
let label = match labels.len() {
0 => None,
1 => labels.into_iter().next(),
_ => Some("varies".to_string()),
};
(range, label)
}
fn build_action_prompt(&mut self, kind: PromptKind) -> Widget {
self.action_ips = self.selected_ip_list();
self.action_kind = kind;
let n = self.action_ips.len();
let frame = Widget::main_frame();
let title = match kind {
PromptKind::Power => "Set power limit",
PromptKind::Power => "Set power target",
PromptKind::HashRateTarget => "Set hashrate target",
PromptKind::Tuning => "Set tuning percent",
PromptKind::Timezone => "Set timezone",
PromptKind::Password => "Change password",
};
let dlg = Widget::dialog(frame, title);
let root = Widget::box_sizer(true);
// Append the current target and the advertised valid range to the target
// prompts (round 17 C), so the operator sees what the firmware will accept.
let target_hint = |range: Option<(f64, f64)>, cur: Option<String>, unit: &str| {
let mut s = String::new();
if let Some(c) = cur {
s.push_str(&format!("\nCurrent: {c}."));
}
if let Some((a, b)) = range {
s.push_str(&format!(" Valid range: {a:.0}-{b:.0} {unit}."));
}
s
};
let lbl = match kind {
PromptKind::Power => format!("Power limit in watts for {n} miner(s):"),
PromptKind::Power => {
let (range, cur) = self.selected_envelope(|r| (r.power_target_min_w, r.power_target_max_w));
format!("Power target in watts for {n} miner(s):{}", target_hint(range, cur, "W"))
}
PromptKind::HashRateTarget => {
let (range, cur) =
self.selected_envelope(|r| (r.hashrate_target_min_ths, r.hashrate_target_max_ths));
format!("Hashrate target in TH/s for {n} miner(s):{}", target_hint(range, cur, "TH/s"))
}
PromptKind::Tuning => format!("Tuning percent (0-100) for {n} miner(s):"),
PromptKind::Timezone => format!("IANA timezone (e.g. America/Edmonton) for {n} miner(s):"),
PromptKind::Password => format!("New web/API password for {n} miner(s):"),
@@ -2206,9 +2272,35 @@ impl App {
/// captured selection) so the operator can correct it.
fn apply_action_prompt(&mut self) {
let val = self.action_input.get_value();
// A target must be positive, finite, and within the advertised range when
// one exists (round 17 C).
let in_range = |v: f64, range: Option<(f64, f64)>| {
v > 0.0 && v.is_finite() && range.map_or(true, |(a, b)| v >= a && v <= b)
};
let action = match self.action_kind {
PromptKind::Power => match val.trim().parse::<f64>() {
Ok(w) if w > 0.0 && w.is_finite() => Some(scan::ConfigAction::PowerLimit(w)),
Ok(w)
if in_range(
w,
self.selected_envelope(|r| (r.power_target_min_w, r.power_target_max_w)).0,
) =>
{
Some(scan::ConfigAction::PowerLimit(w))
}
_ => None,
},
PromptKind::HashRateTarget => match val.trim().parse::<f64>() {
Ok(t)
if in_range(
t,
self.selected_envelope(|r| {
(r.hashrate_target_min_ths, r.hashrate_target_max_ths)
})
.0,
) =>
{
Some(scan::ConfigAction::HashRateTarget(t))
}
_ => None,
},
PromptKind::Tuning => match val.trim().parse::<u8>() {
@@ -2237,7 +2329,8 @@ impl App {
}
None => {
let hint = match self.action_kind {
PromptKind::Power => "enter a positive number of watts",
PromptKind::Power => "enter a number of watts within the valid range",
PromptKind::HashRateTarget => "enter a hashrate in TH/s within the valid range",
PromptKind::Tuning => "enter a percent from 0 to 100",
PromptKind::Timezone => "enter a valid IANA zone, e.g. America/Edmonton",
PromptKind::Password => "enter a non-empty password",
+51
View File
@@ -0,0 +1,51 @@
#!/usr/bin/env bash
#
# Reclaim disk from the local cargo build directory.
#
# The app and the miner_probe CLI ship as release builds, and the unit tests run
# under --release too (see the build notes), so the dev/debug profile tree, any
# cross-compile target trees, and the coverage tree are all disposable: they only
# ever reappear if something explicitly rebuilds them, and left alone they grow
# without bound (a stray `cargo check`/`cargo test` can push the debug tree past
# 30 GiB on its own). The release tree is kept warm so the next iteration is still
# incremental; only its throwaway bits are pruned.
#
# Run it right after a release push -- the pushed commit is what CI builds and
# ships, so the local intermediates are spare from that point. Safe to run any
# time; it never deletes the release build itself.
#
# Honours CARGO_TARGET_DIR (the build sets it to ~/.cache/alkane-tk-target).
set -uo pipefail
TARGET="${CARGO_TARGET_DIR:-$HOME/.cache/alkane-tk-target}"
if [ ! -d "$TARGET" ]; then
echo "clean-old-builds: no target dir at $TARGET (nothing to do)"
exit 0
fi
human() { du -sh "$1" 2>/dev/null | cut -f1; }
before=$(human "$TARGET")
# Disposable profile/aux trees -- regenerated on demand, never shipped.
rm -rf "$TARGET"/debug "$TARGET"/llvm-cov-target "$TARGET"/doc 2>/dev/null
# Cross-compile target trees (e.g. armv7-unknown-linux-musleabihf). Rust target
# triples all carry "-unknown-"; the host release/debug trees do not, so this
# never touches the warm release build.
for d in "$TARGET"/*-unknown-*; do
[ -d "$d" ] && rm -rf "$d"
done
# The incremental caches are rebuild accelerators, not build output -- dropping
# them costs one slightly-slower rebuild and can free a few GiB.
rm -rf "$TARGET"/release/incremental 2>/dev/null
# If cargo-sweep is installed, additionally drop release artifacts not touched in
# the last few days (old dependency versions left by past rebuilds), keeping the
# current build. Optional: install with `cargo install cargo-sweep`.
if command -v cargo-sweep >/dev/null 2>&1; then
cargo sweep --time 3 "$TARGET" >/dev/null 2>&1 || true
fi
after=$(human "$TARGET")
echo "clean-old-builds: $TARGET $before -> $after"
@@ -0,0 +1,103 @@
Subject: [PATCH 0017] luxminer v1: select power-limit profile by name, not step
Round 17 C (found via live tuning verification). set_power_limit mapped a watts
target to a LuxOS profile and applied it with `profileset`, but keyed on the
profile's `Step` field. The top/factory profile is named "default" and its Step
is "0"; LuxOS's profileset reads the parameter "0" as empty and answers
"Missing profile parameter" (Code 400). So the setter could never select the
default profile -- and a miner nudged off default by a watts limit could not be
returned to it via the power-limit control, stranding it below its factory point.
parse_profile_watts now keys on `Profile Name` (e.g. "480MHz", "default"), which
profileset accepts for every profile including the default. Verified live on a
LuxOS S19j Pro (10.4.1.60): set_power_limit(2700) -> 480MHz/2632W, and
set_power_limit(2900) -> default/2794W (previously errored), restoring the miner
to its factory profile. Unit test updated to key on names and to cover the
top-profile-is-"default" case.
diff --git a/vendor/asic-rs-firmwares-luxminer/src/backends/v1/mod.rs b/vendor/asic-rs-firmwares-luxminer/src/backends/v1/mod.rs
index 2d1331bf..a4db1e03 100644
--- a/vendor/asic-rs-firmwares-luxminer/src/backends/v1/mod.rs
+++ b/vendor/asic-rs-firmwares-luxminer/src/backends/v1/mod.rs
@@ -1078,8 +1078,14 @@ impl SetFaultLight for LuxMinerV1 {
}
}
-/// Parse a LuxOS `profiles` RPC reply into (step name, watts) pairs, keeping only
-/// profiles that report both a `Step` and a `Watts` value.
+/// Parse a LuxOS `profiles` RPC reply into (profile name, watts) pairs, keeping
+/// only profiles that report both a `Profile Name` and a `Watts` value.
+///
+/// The identifier is the `Profile Name` (e.g. "480MHz", "default"), NOT the
+/// `Step`: `profileset` takes the name, and the default profile's step is "0",
+/// which LuxOS reads as an empty parameter ("Missing profile parameter"), so a
+/// step-keyed setter can never select the default profile and could strand a
+/// miner off its factory point.
fn parse_profile_watts(profiles: &Value) -> Vec<(String, f64)> {
profiles
.get("PROFILES")
@@ -1087,16 +1093,16 @@ fn parse_profile_watts(profiles: &Value) -> Vec<(String, f64)> {
.map(|arr| {
arr.iter()
.filter_map(|p| {
- let step = p.get("Step").and_then(Value::as_str)?.to_string();
+ let name = p.get("Profile Name").and_then(Value::as_str)?.to_string();
let watts = p.get("Watts").and_then(Value::as_f64)?;
- Some((step, watts))
+ Some((name, watts))
})
.collect()
})
.unwrap_or_default()
}
-/// Choose the LuxOS profile step to satisfy a watts power limit: the highest-watt
+/// Choose the LuxOS profile name to satisfy a watts power limit: the highest-watt
/// profile that does not exceed `target_w`, or -- when the target is below every
/// profile -- the lowest-watt profile. Returns None only when there are no
/// profiles to choose from.
@@ -1315,32 +1321,34 @@ mod tests {
#[test]
fn power_limit_profile_selection() {
- // LuxOS reports a ladder of profiles, each with a Step name and Watts.
+ // LuxOS reports a ladder of profiles, each with a Profile Name and Watts.
+ // The top profile is named "default" (its Step is "0", which profileset
+ // rejects -- so selection must key on the name, not the step).
let steps = vec![
- ("-16".to_string(), 865.0),
- ("-4".to_string(), 2385.0),
- ("-2".to_string(), 2790.0),
- ("0".to_string(), 3100.0),
+ ("190MHz".to_string(), 865.0),
+ ("405MHz".to_string(), 2385.0),
+ ("455MHz".to_string(), 2790.0),
+ ("default".to_string(), 3100.0),
];
// The highest profile at or below the requested watts limit.
assert_eq!(
select_profile_at_or_below(&steps, 2500.0).as_deref(),
- Some("-4")
+ Some("405MHz")
);
assert_eq!(
select_profile_at_or_below(&steps, 2790.0).as_deref(),
- Some("-2")
+ Some("455MHz")
);
- // Above every profile -> the maximum profile (a limit can't exceed the
- // hardware's top profile).
+ // Above every profile -> the maximum profile, selected by NAME ("default")
+ // rather than its step "0" (which profileset would reject).
assert_eq!(
select_profile_at_or_below(&steps, 9000.0).as_deref(),
- Some("0")
+ Some("default")
);
// Below every profile -> the minimum profile.
assert_eq!(
select_profile_at_or_below(&steps, 100.0).as_deref(),
- Some("-16")
+ Some("190MHz")
);
// No profiles -> nothing to choose.
assert_eq!(select_profile_at_or_below(&[], 2500.0), None);
@@ -335,13 +335,26 @@ int DrawShape(wxDC* dc, wxUniChar shape, wxCoord x, const wxRect& cell,
if (h < 8) h = 8;
int w = (sv->vbh > 0) ? (int)((double)h * sv->vbw / sv->vbh + 0.5) : h;
if (w < 1) w = 1;
const wxBitmap& bmp = ShapeBitmap(shape, *sv, colour, w, h);
// The Font Awesome fan glyph fills its square box more than the other health
// icons (brain/chip/bolt), so at the shared size it reads as oversized. Draw
// it a bit smaller, centred in its full-size slot, so the slot advance and the
// per-icon tooltip hit-test (both keyed to the full width) are unchanged
// (round 17 R1).
int dw = w, dh = h;
if (shape == SHAPE_FAN) {
dh = (int)(h * 0.80 + 0.5);
if (dh < 8) dh = 8;
dw = (sv->vbh > 0) ? (int)((double)dh * sv->vbw / sv->vbh + 0.5) : dh;
if (dw < 1) dw = 1;
}
const wxBitmap& bmp = ShapeBitmap(shape, *sv, colour, dw, dh);
if (bmp.IsOk()) {
if (health) {
// Left-align and advance by less than the icon width so adjacent health
// icons sit close together (the Font Awesome glyphs carry inner margin,
// so a small bounding-box overlap does not visually collide).
dc->DrawBitmap(bmp, x, cy - h / 2, true);
// Left-align in the full slot (a shrunk fan is centred within it) and
// advance by less than the full icon width so adjacent health icons sit
// close together (the Font Awesome glyphs carry inner margin, so a small
// bounding-box overlap does not visually collide).
dc->DrawBitmap(bmp, x + (w - dw) / 2, cy - dh / 2, true);
int adv = w - 3;
return adv < 1 ? 1 : adv;
}
+1 -1
View File
@@ -1 +1 @@
{"$comment":"This file only protects against accidental modifications. It is not a security mechanism and does not protect against malicious changes.","files":{".cargo_vcs_info.json":"fe8effe2bfdda5d4c390656c016729f531a2b1c60033228557659c0befdde9f2","Cargo.lock":"a2b2cb45bb8b574e4f29ffdcdb5ebafd1dd87a0e6e11b47383973a99be367784","Cargo.toml":"503efa00123f8567f5fe40bf6a93e9e453d13094df0e0e1b7e98bdacdfbd2595","Cargo.toml.orig":"1c4ba0315fb491c086fc22a5c9bafaf7288c6b1fd48679c3d03dbd9df156a8b5","src/backends/mod.rs":"548d988b877410e330a55e275f64b2adad95ca5f1a0f085fe144957c96b8906f","src/backends/v1/mod.rs":"3e57d2c72d1d48c0b86f5438202633fcd9c1ebf375bd87ffe53ea5298ae936ad","src/backends/v1/rpc.rs":"25b0b9d56fbf113d5b8c3d3bc8eb7a0d67967b1f90f6d855da0b9f6ff24ae335","src/firmware.rs":"d95345295ae5043dfc357e69ae56c564b261fdb3b19b5c0ad1765267ff05ab3f","src/lib.rs":"53f7acddeff8f7d82f80d09e0a9f91962011f9ccf2e441c4ca05cd7fc4eb292e","src/test/json/mod.rs":"24191681066d5cf6a3022ad59c1baa92b57e3ce7717bb78d6a682af9e19a38c4","src/test/json/v1/config.json":"6ca9e6217d853d4bf1e75d69159630e9c9184ede96751706b88dfb699b5d59ad","src/test/json/v1/devs.json":"8f746dc6a02953eee5ee96dcf53be8dc7880a8ffc2c6e303f0284bcf6a97f42d","src/test/json/v1/events.json":"913683ff97af3333018807e1cc6e43467ea8a55925e5964dc402616615e2a5e3","src/test/json/v1/fans.json":"f8a9a1234d651055c80f4ebb1380bbb4e6d19eb33012902c55fff1385e592447","src/test/json/v1/healthchipget_0.json":"10619460049333ca016b2beec59ecc514ed9077fb19bdf7d0ed697201f8cb96c","src/test/json/v1/healthchipget_1.json":"80927fb1480c95be7f3a4e155d63f68f97720530ff7cf5d5ade06f2a3e810bf0","src/test/json/v1/healthchipget_2.json":"1e93ee2ab472ee7af58add08b4251e3ce0ad4f986d4325abbf43fd4c9b3dd28f","src/test/json/v1/mod.rs":"5a050f07455e622e35ad79ab1c8a6daf2ea38c4198472e49c6bbfe80538a9e48","src/test/json/v1/pools.json":"0068745327e31853fec051172abb7337f18a4cf9972c51967113d63f4f31f504","src/test/json/v1/power.json":"80534bb4581de7c8b747bf33b5d629b909c6e16a531d18ecb4afd7ffad3f014f","src/test/json/v1/profiles.json":"1f00429036e270daa08f12cd2d7357135070c57acd7a899a3c0af6167fe82abb","src/test/json/v1/stats.json":"2b105f0eb927046c9d2389bde978a43e3d54d12a420dfbe400786bb2f0ae31ca","src/test/json/v1/summary.json":"aaea3378eb7040952037e2f1ef7bd5f20a1b242bf93d4ba0501c46104b0b31a0","src/test/json/v1/temps.json":"1ee781cd2be3ed6a6a07e23be930248735fb51348c160453ba10f6ef71fcb7f1","src/test/json/v1/version.json":"4beb6ca5c0ebf359cee0434fdcc4d0a1a0607436634e46be3fd951e2256595df","src/test/json/v1/voltageget_0.json":"c445fa8674c2542b2d296fbafdd3166c53008dfbd9da8095327217989d37f1da","src/test/json/v1/voltageget_1.json":"96b91c3447dd66e7f1f575ed3b99611062e8b1d516d31422b74e425c46b2f49c","src/test/json/v1/voltageget_2.json":"7d40544021b2e32401135ae333067b770d2d736ada9e60deaca8fd8f5a79a1e3","src/test/mod.rs":"ed52c3d613eabc4a0346bb38bcfdf7a94933d61e368d3c9094821edeab92f81b"},"package":"513792d93a2a21d5258d9e6ac0e6dc9e0a6365118934514b4e656792add78066"}
{"$comment":"This file only protects against accidental modifications. It is not a security mechanism and does not protect against malicious changes.","files":{".cargo_vcs_info.json":"fe8effe2bfdda5d4c390656c016729f531a2b1c60033228557659c0befdde9f2","Cargo.lock":"a2b2cb45bb8b574e4f29ffdcdb5ebafd1dd87a0e6e11b47383973a99be367784","Cargo.toml":"503efa00123f8567f5fe40bf6a93e9e453d13094df0e0e1b7e98bdacdfbd2595","Cargo.toml.orig":"1c4ba0315fb491c086fc22a5c9bafaf7288c6b1fd48679c3d03dbd9df156a8b5","src/backends/mod.rs":"548d988b877410e330a55e275f64b2adad95ca5f1a0f085fe144957c96b8906f","src/backends/v1/mod.rs":"0c12f7714b8486372054261afd263b61f432a446cef8ae9e6cd72550a0cf4f8f","src/backends/v1/rpc.rs":"25b0b9d56fbf113d5b8c3d3bc8eb7a0d67967b1f90f6d855da0b9f6ff24ae335","src/firmware.rs":"d95345295ae5043dfc357e69ae56c564b261fdb3b19b5c0ad1765267ff05ab3f","src/lib.rs":"53f7acddeff8f7d82f80d09e0a9f91962011f9ccf2e441c4ca05cd7fc4eb292e","src/test/json/mod.rs":"24191681066d5cf6a3022ad59c1baa92b57e3ce7717bb78d6a682af9e19a38c4","src/test/json/v1/config.json":"6ca9e6217d853d4bf1e75d69159630e9c9184ede96751706b88dfb699b5d59ad","src/test/json/v1/devs.json":"8f746dc6a02953eee5ee96dcf53be8dc7880a8ffc2c6e303f0284bcf6a97f42d","src/test/json/v1/events.json":"913683ff97af3333018807e1cc6e43467ea8a55925e5964dc402616615e2a5e3","src/test/json/v1/fans.json":"f8a9a1234d651055c80f4ebb1380bbb4e6d19eb33012902c55fff1385e592447","src/test/json/v1/healthchipget_0.json":"10619460049333ca016b2beec59ecc514ed9077fb19bdf7d0ed697201f8cb96c","src/test/json/v1/healthchipget_1.json":"80927fb1480c95be7f3a4e155d63f68f97720530ff7cf5d5ade06f2a3e810bf0","src/test/json/v1/healthchipget_2.json":"1e93ee2ab472ee7af58add08b4251e3ce0ad4f986d4325abbf43fd4c9b3dd28f","src/test/json/v1/mod.rs":"5a050f07455e622e35ad79ab1c8a6daf2ea38c4198472e49c6bbfe80538a9e48","src/test/json/v1/pools.json":"0068745327e31853fec051172abb7337f18a4cf9972c51967113d63f4f31f504","src/test/json/v1/power.json":"80534bb4581de7c8b747bf33b5d629b909c6e16a531d18ecb4afd7ffad3f014f","src/test/json/v1/profiles.json":"1f00429036e270daa08f12cd2d7357135070c57acd7a899a3c0af6167fe82abb","src/test/json/v1/stats.json":"2b105f0eb927046c9d2389bde978a43e3d54d12a420dfbe400786bb2f0ae31ca","src/test/json/v1/summary.json":"aaea3378eb7040952037e2f1ef7bd5f20a1b242bf93d4ba0501c46104b0b31a0","src/test/json/v1/temps.json":"1ee781cd2be3ed6a6a07e23be930248735fb51348c160453ba10f6ef71fcb7f1","src/test/json/v1/version.json":"4beb6ca5c0ebf359cee0434fdcc4d0a1a0607436634e46be3fd951e2256595df","src/test/json/v1/voltageget_0.json":"c445fa8674c2542b2d296fbafdd3166c53008dfbd9da8095327217989d37f1da","src/test/json/v1/voltageget_1.json":"96b91c3447dd66e7f1f575ed3b99611062e8b1d516d31422b74e425c46b2f49c","src/test/json/v1/voltageget_2.json":"7d40544021b2e32401135ae333067b770d2d736ada9e60deaca8fd8f5a79a1e3","src/test/mod.rs":"ed52c3d613eabc4a0346bb38bcfdf7a94933d61e368d3c9094821edeab92f81b"},"package":"513792d93a2a21d5258d9e6ac0e6dc9e0a6365118934514b4e656792add78066"}
+24 -16
View File
@@ -1078,8 +1078,14 @@ impl SetFaultLight for LuxMinerV1 {
}
}
/// Parse a LuxOS `profiles` RPC reply into (step name, watts) pairs, keeping only
/// profiles that report both a `Step` and a `Watts` value.
/// Parse a LuxOS `profiles` RPC reply into (profile name, watts) pairs, keeping
/// only profiles that report both a `Profile Name` and a `Watts` value.
///
/// The identifier is the `Profile Name` (e.g. "480MHz", "default"), NOT the
/// `Step`: `profileset` takes the name, and the default profile's step is "0",
/// which LuxOS reads as an empty parameter ("Missing profile parameter"), so a
/// step-keyed setter can never select the default profile and could strand a
/// miner off its factory point.
fn parse_profile_watts(profiles: &Value) -> Vec<(String, f64)> {
profiles
.get("PROFILES")
@@ -1087,16 +1093,16 @@ fn parse_profile_watts(profiles: &Value) -> Vec<(String, f64)> {
.map(|arr| {
arr.iter()
.filter_map(|p| {
let step = p.get("Step").and_then(Value::as_str)?.to_string();
let name = p.get("Profile Name").and_then(Value::as_str)?.to_string();
let watts = p.get("Watts").and_then(Value::as_f64)?;
Some((step, watts))
Some((name, watts))
})
.collect()
})
.unwrap_or_default()
}
/// Choose the LuxOS profile step to satisfy a watts power limit: the highest-watt
/// Choose the LuxOS profile name to satisfy a watts power limit: the highest-watt
/// profile that does not exceed `target_w`, or -- when the target is below every
/// profile -- the lowest-watt profile. Returns None only when there are no
/// profiles to choose from.
@@ -1315,32 +1321,34 @@ mod tests {
#[test]
fn power_limit_profile_selection() {
// LuxOS reports a ladder of profiles, each with a Step name and Watts.
// LuxOS reports a ladder of profiles, each with a Profile Name and Watts.
// The top profile is named "default" (its Step is "0", which profileset
// rejects -- so selection must key on the name, not the step).
let steps = vec![
("-16".to_string(), 865.0),
("-4".to_string(), 2385.0),
("-2".to_string(), 2790.0),
("0".to_string(), 3100.0),
("190MHz".to_string(), 865.0),
("405MHz".to_string(), 2385.0),
("455MHz".to_string(), 2790.0),
("default".to_string(), 3100.0),
];
// The highest profile at or below the requested watts limit.
assert_eq!(
select_profile_at_or_below(&steps, 2500.0).as_deref(),
Some("-4")
Some("405MHz")
);
assert_eq!(
select_profile_at_or_below(&steps, 2790.0).as_deref(),
Some("-2")
Some("455MHz")
);
// Above every profile -> the maximum profile (a limit can't exceed the
// hardware's top profile).
// Above every profile -> the maximum profile, selected by NAME ("default")
// rather than its step "0" (which profileset would reject).
assert_eq!(
select_profile_at_or_below(&steps, 9000.0).as_deref(),
Some("0")
Some("default")
);
// Below every profile -> the minimum profile.
assert_eq!(
select_profile_at_or_below(&steps, 100.0).as_deref(),
Some("-16")
Some("190MHz")
);
// No profiles -> nothing to choose.
assert_eq!(select_profile_at_or_below(&[], 2500.0), None);