Compare commits

...
19 Commits
Author SHA1 Message Date
noahandClaude Opus 4.8 49985631d4 antminer: read best-share fleet-wide + Bixbit "Power Estimated" wattage (R7)
Round 17 R7. Flashing Bixbit onto fleet units surfaced two Antminer scan gaps
(patch 0019): the stock v2023_07 backend never fetched best-share at all
(DataField::BestShare had no source), so it was blank for every stock/Bixbit
Antminer; and it read wattage only from the cgminer stats, which Bixbit-based
firmware leaves at 0 (real draw is in the summary as "Power Estimated").

Now maps BestShare/SessionBestShare to the cgminer summary and adds a
"Power Estimated" wattage fallback (stock power still wins when present).

Verified live: Bixbit S19j Pro (10.4.1.70) now reads 2615 W + best-share
178930671; stock S21 Pro (10.4.1.90) now reads best-share 299464394 -- both were
blank before. 36 antminer backend tests + SELFTEST pass, no wattage regression.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 13:34:01 -06:00
noahandClaude Opus 4.8 8fe61ec427 psu: PSU info scan + version/Vmin/Vmax columns + tooltip V/A (R5/G15)
Round 17 R5/G15. asic-rs had no PSU telemetry. Adds an optional PsuInfo to
MinerData (model, version, rated voltage min/max, live output voltage/current),
a DataField::Psu, and a default parse_psu backends override (patch 0018). ePIC
populates it by merging the summary "Power Supply Stats" with the capabilities
"Psu Info".

GUI: three new columns -- "PSU version", "PSU Vmin", "PSU Vmax" (Hardware group in
the picker) -- and the R2 power tooltip now shows the PSU output voltage (and
amperage when the firmware reports a non-zero current; ePIC leaves current 0, so
it shows just the voltage).

Verified live on ePIC S19j Pro (10.4.1.6/.10): model 117, fw 22, Vmin 11.877 V,
Vmax 15.182 V, output ~13.2 V. 8 model tests + 18 ePIC backend tests + SELFTEST
pass. Non-ePIC firmware leave the PSU fields blank until they add parse_psu.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 12:24:26 -06:00
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
noahandClaude Opus 4.8 da0d1582be scan: cap identification concurrency at 128 to fix Braiins value dropout (R4)
Round 17 R4. Scanning most values from Braiins OS units failed under a
full fleet scan: a /24 returned watts=0 and no best-share/temps/fw for
Braiins miners (and dropped a few responders entirely), while the same
miner scanned in isolation populated fully.

Root cause: asic-rs picks a scan concurrency of 1000 for any range up to
/22, so a /24 fires all ~254 address probes at once. Over a real link
(the fleet is reached across a WireGuard VPN, and a subnet full of dead
IPs holds every TCP connect open for the whole identification timeout)
that burst starves the per-responder get_data. A Braiins miner fans out
~12 authenticated REST calls; under the burst they drop miner/stats, so
"most values" come back blank. It is not FD exhaustion (nofile is 500k),
not the per-call timeout, and not an auth race.

Fix: cap identification concurrency at 128 in the app (GUI scan +
miner_probe). On the live fleet 128 was the highest cap that stayed fully
reliable -- 192 already dropped responders, 254 blanked a Braiins miner.
A /24 still finishes in ~35s; larger ranges just take proportionally
longer and stay correct.

Belt-and-suspenders in the braiins backend (patch 0016): single-flight
the login (one auth instead of ~12 concurrent) and widen the defensive
get_data timeout 5s -> 15s.

Verified live: 10.4.1.0/24 now populates both Braiins corpus miners
(.27 watts=2748 best=55217110, .83 watts=2749) fully and misses no
responders (65/65). SELFTEST PASS.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 09:59:27 -06:00
noahandClaude Opus 4.8 7f802c568f Scan progress: smooth per-address counter (was jumping ~1%/second)
The scan counter jumped in big steps (e.g. +45 for a 4590-address scan) because
(a) progress was only emitted every total/100 addresses and (b) the drain timer
ran once per second, so the gauge only refreshed ~1 Hz. The +45 was total/100, not
a chosen value.

Fix, both cheap:
- scan.rs emits progress per address (throttled only above 5000 addresses to bound
  channel traffic) instead of every 1%.
- ui.rs runs the scan/drain timer at 200 ms (5 Hz) so the counter climbs smoothly;
  drain_scan coalesces the many per-address updates into ONE gauge/status update
  per drain (no extra repaints). A tick accumulator keeps the once-per-second work
  (auto-rescan countdown, idle status) at 1 Hz despite the faster tick.

Net: the counter now climbs several times a second in small increments; overhead
is negligible (unbounded mpsc sends are cheap and the gauge still repaints once per
tick). No user-facing setting added -- the smoothness is size-independent.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 09:21:33 -06:00
noahandClaude Opus 4.8 86338062a5 Round 17 B (part 2, GUI): timezone / change-password / factory-reset dialogs + BOS fix
Wire G10/G11/G12 into the GUI (they already had CLI verbs in part 1):
- MinerCaps gains timezone / change_password / factory_reset (probed from the
  matching supports_*() at scan time; intersect + any_control + is_empty updated).
- ConfigAction gains Timezone(String) / ChangePassword(String) / FactoryReset with
  labels + apply arms. Timezone/FactoryReset go through apply_action(&dyn Miner);
  ChangePassword takes &mut self so it runs on the owned miner in the action loop.
- ui.rs: a shared PromptKind (Power/Tuning/Timezone/Password) generalises the
  value prompt (timezone is IANA-validated before firing; password is non-empty);
  factory-reset uses the confirm dialog with a strong WIPES-config/DHCP warning.
  New gated context-menu items: Set timezone, Change password, Factory reset.

Backend fix (asic-rs patch 0015): BOS send_command treated an empty 2xx body as a
parse error, so change_password reported Ok(false) on success. Empty 2xx is now
Null (success). Found + fixed while live-verifying G11.

Verified live on Braiins 10.4.1.27: full change-password round-trip (root ->
bftest2 -> read with new pw -> restore root), all Ok(true), unit left on root/root.
Timezone shares the CLI-verified set_timezone_config path. Factory-reset is wired +
gated but intentionally NOT live-fired: its behaviour is unrecoverable per firmware
(can revert LuxOS to stock / reset network to DHCP and lose the unit) -- needs a
truly sacrificial console-attached unit. GUI selftest + 89 unit tests pass.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 08:58:00 -06:00
noahandClaude Opus 4.8 c4c85d5b3d Round 17 B (part 1, CLI): timezone / change-password / factory-reset verbs (G10/G11/G12)
Round B wires the already-complete SupportsTimezoneConfig / ChangePassword /
FactoryReset backends to the toolkit. Part 1 adds the committed CLI surface
(GUI dialogs follow in part 2):
- `timezone <ip> [<IANA>]` - read (no arg) or set the timezone (gated on
  supports_timezone_config: Braiins/VNish/ePIC).
- `passwd <ip> <newpass>`  - change the web/API password (gated).
- `factoryreset <ip>`      - factory reset (gated).
Each is capability-gated and the usage banner marks passwd/factoryreset DANGEROUS.

Verified live: timezone set/read/restore end-to-end on Braiins 10.4.1.83
(set America/Edmonton -> read back -> restore Etc/GMT, all Ok). change-password
and factory-reset are implemented + gated but NOT live-run: both are destructive
on the shared corpus (change-password breaks the default auth every other test
relies on; factory-reset can reset a unit to DHCP and lose its IP) -- they need a
dedicated sacrificial/console-attached unit to verify live.

Also: ci/compute-version.sh now treats crates/alkane-gui/src/bin/* as a UI change
so CLI-tool changes trigger a release.

Note: the VNish timezone READ errors ("Unrecognised VNish timezone GMT, expected
GMT+N/-N") is a pre-existing vnish backend parse quirk, separate from this wiring.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-21 22:58:43 -06:00
noahandClaude Opus 4.8 25c8ccf1ff Round 17 A (part 2, G13): LuxOS pool ops privileged + removepool
The luxminer pool write commands (addgroup/groupquota/removegroup/addpool/
switchpool/enablepool/disablepool) sent privileged=false -> no session_id, which
fails with "Missing session_id" on password-set LuxOS units (all other LuxOS
writes are already privileged). Flipped all seven to privileged=true and added the
missing removepool. asic-rs patch 0014.

Verified no regression on default corpus unit 10.4.1.60 (set_pools_config still
applies). The password-set failure needs a password-set LuxOS unit to verify live.

Round A remaining: G8 (constraints/limits reads) and G14 (telemetry enrichment) are
deferred to the rounds that consume them (G8 -> the tuning/cooling dialogs in C/D;
G14 -> detail-panel/tooltip work) rather than built as unused plumbing now.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-21 22:47:18 -06:00
noahandClaude Opus 4.8 307539543d Round 17 A (part 1): committed write CLI (G1) + best-share reads (G9) + parity roadmap
Executing the aftermarket config+scan parity plan (docs/aftermarket-parity-roadmap.md,
from the ultracode writer/adversary workflow). This is Round A's foundation + first cheap win.

G1 - miner_probe is now a committed config+scan CLI, not a local-only diagnostic. Added
capability-gated write verbs: `light <ip> <on|off>`, `pause`, `resume`, `restart` (alongside
the existing setpl/setpools/led), a READ vs WRITE usage banner warning that write verbs mutate
(use the test-bed miners, not production), and best_share/session_best_share columns in `scan`.
Verified: `light on`/`light off` on a LuxOS corpus unit -> Ok(true) (reversible).

G9 - implement GetBestShare/GetSessionBestShare (were empty impls feeding two dead columns):
Braiins v26_04 reads miner/stats -> /miner_stats/best_share; LuxMiner v1 reads summary ->
/SUMMARY/0/Best Share + Best Session Share. Both reuse already-collected responses (no extra
calls). asic-rs patch 0013. Verified live read-only: BOS 10.4.1.83 = 130601978 (no session on
BOS); LuxOS 10.4.1.60 = 638881749/638881749, 10.4.1.67 = 497802665/497802665 -- exact API match.
(WhatsMiner stock summary exposes no best-share on the tested units; deferred. The roadmap's BOS
source "miner_stats" was a typo for the real "miner/stats" endpoint.)

Also commits the parity roadmap (docs/) as the plan of record for rounds A-F.
Round A remainder (G8 constraints reads, G13 LuxOS pool-op privileged fix, G14 telemetry
enrichment) follows; G13 needs a password-set LuxOS unit to fully verify.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-21 22:36:59 -06:00
noahandClaude Opus 4.8 561c50e5dc GUI round 16 (#4/#5/#6/#7): UMC OS colour, pool + restore dialog polish, new icons
- #4 ePIC miners report their firmware family as "UMC OS"; colour that row light
  blue in the Firmware column (was falling through to the theme default / black),
  matching the existing ePIC colour.
- #5 Configure-pools dialog: widen the "+" buttons so the glyph shows; the dropdown
  "add" entry now reads "Add new"; user-added values can be removed via a "Remove
  saved value" submenu (pool_prefs::remove_saved); dropped the intro tidbit and
  narrowed the window.
- #6 Restore-to-stock confirmation: the miner list is now a height-capped,
  scrollable text box instead of one unbounded label, so restoring hundreds at
  once stays usable. Removed the "Flash firmware..." right-click option for now
  (the in-app flash path is parked while it is reworked).
- #7 Replaced the brain (control board) and fan Health icons with the new
  operator-supplied artwork, image-traced from PNG to SVG (potrace) and stripped
  of explicit fills so the Health column's per-state recolouring still applies.

Headless selftest passes (fixtures render through the real widgets); all GUI unit
tests pass.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-21 17:43:45 -06:00
noahandClaude Opus 4.8 74b97162f5 GUI round 16 (#1/#2/#3): per-component health attribution + tooltips
Health icons and their hover tooltips now reflect the miner's actual per-component
faults instead of a generic "faulted".

- #1 Each Health icon's tooltip carries the specific fault text for THAT component
  (e.g. "Slot 0 error reading chip id.", "Power current error."), sourced from
  asic-rs's structured MinerMessage.component (HashBoard idx / PowerSupply / Fan /
  ControlBoard) rather than fragile string matching on the summary. New MinerRow
  `faults` field + FaultComponent/Fault types; scan.rs maps messages -> faults.
- #2 A power-supply fault turns the bolt icon red, lists the PSU faults on its
  tooltip, and greys (not reds) every hashboard -- the boards can't be powered or
  tested, so they read "unpowered (PSU fault)".
- #3 When the miner reports board-specific faults, ONLY the named boards are red;
  the rest stay green. A whole-miner stall zeroes every board's hashrate, which
  previously reddened working boards the error codes actually exonerate.

Backend enabler (asic-rs patch 0012): the WhatsMiner V1 backend now sources faults
from get_error_code (like V2/V3; its summary error fields are empty on H6OS), and
a targeted repair fixes firmware that emits an invalid bare-pair error_code array.

Verified live: 10.7.1.231 (PSU) greys its boards + shows the 4 PSU faults on the
bolt; 10.8.1.234 (540/541/561) reds boards 1+2 and leaves board 3 green. Unit
tests cover the attribution and the malformed-array repair; all suites pass.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-21 17:30:18 -06:00
noahandClaude Opus 4.8 75663f4c23 asic-rs: implement LuxOS set_power_limit (via profiles); document ePIC PSU gating
Follow-up to the Round 15 corpus. The toolkit reported supports_power_limit=false
for LuxOS and ePIC; investigated both against the live corpus (S19j Pro).

LuxOS was genuinely under-reporting: it tunes by discrete named profiles that each
carry a Watts rating (the `profiles` RPC gives Step + Watts), applied via
profileset -- pure frequency/voltage tuning, no PSU dependency. Implemented
SetPowerLimit to map the requested watts to the highest profile whose Watts does
not exceed it (or the lowest profile when the target is below all of them). The
pure mapping (parse_profile_watts + select_profile_at_or_below) has a unit test.
Live-verified: set_power_limit(2500) on an S19j Pro picked step -4 (2385 W) and
the miner's active profile became 445MHz/-4.

ePIC is left at false, now with a comment explaining why: PowerPlay's only true
power-limit path is the PowerTune perpetual-tune algorithm, which the firmware
gates on the PSU -- on a fixed-voltage Bitmain APW12 (S19j Pro) it answers "Power
optimization is not supported by this PSU". That is a per-PSU runtime property the
synchronous capability check cannot see, so reporting true would over-advertise on
most reflashed Antminers. Hashrate tuning remains available via set_tuning_config.

Captured as asic-rs patch 0011. luxminer + epic crate tests pass.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-21 16:40:38 -06:00
noahandClaude Opus 4.8 9eb6a0f229 asic-rs: fix Antminer locate-LED (and reboot) on legacy web-UI firmware
Round 15 #7. The "flash the light" action failed on old (< 2023.07) Antminer
firmware -- the LuCI web-UI generation, e.g. the Z15/Z15J. set_fault_light
returned Ok(false) on live hardware while appearing to "succeed".

Root cause (confirmed on a live Z15): that firmware's blink.cgi ignores the JSON
body {"blink":"true"} the backend sent (answering 200 with an empty text/html
body, so the JSON parse fails and the error is swallowed into Ok(false)). Its own
blink.html POSTs a form field action=startBlink/stopBlink and reads state back via
action=onPageLoaded -> {"isBlinking":bool}; the action handler also often answers
401/500 even on success, so HTTP status is not a reliable signal.

Fix (v2020 backend): add a form-encoded POST helper; blink() now fires
action=startBlink/stopBlink, ignores the unreliable status, and reads the real
state back via onPageLoaded; set_fault_light reports success only when the observed
isBlinking matches the request. The LightFlashing read is routed to the same path
(get_blink_status.cgi is 404 here) and remapped to {"blink":bool}.

Also switch reboot() from POST to GET to match the same firmware's reboot.html (the
Restart action was affected); not live-fired, to avoid rebooting production miners.

Captured as asic-rs patch 0010. Also teach ci/compute-version.sh that vendor/* and
thirdparty/asic-rs/* are backend changes, so vendored fixes trigger a release.

Verified live: Z15/Z15J now return Ok(true) with the light genuinely toggling;
VNish (4 control boards) and WhatsMiner (H6OS/H616) unchanged; antminer tests pass.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-21 15:19:05 -06:00
noahandClaude Opus 4.8 bafbd519bb GUI round 15 (part 2, #13): Settings menu, localization, Logs page
Add a Settings menu (the old Credentials toolbar button is now "Settings")
containing Credentials, a Language sub-menu, and a Logs page.

Localization (#13): a small i18n layer -- visible strings are wrapped in
t("English") and looked up per language, falling back to English. Built-in
translations for Mandarin, Russian, French, Spanish and Portuguese cover the
toolbar buttons, KPI captions and table column headers; changing the language
re-labels them live (columns via a table rebuild) and localizes dialogs as
they open. The choice persists under the config dir and loads at startup.
(Dialog-internal strings and status text are not yet fully translated -- the
framework is in place to extend them.)

Logs page (#13): an in-app activity log (scans, operations applied, export,
language change) shown in Settings > Logs with Refresh / Clear.

New wx-rs bridge: menu sub-menus (menu_append_submenu). Bridge patches
0002/0003 regenerated. Unit tests + headless selftest pass; the Chinese UI
was verified rendering end to end.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-21 14:54:10 -06:00
noahandClaude Opus 4.8 0d19e958f0 GUI round 15 (part 1): pool dropdowns, aligned health icons, export, more
Twelve of the round-15 items (the code items; the live-hardware flashing/
testing and the settings/localization/logs work follow separately):

#1 Configure-pools: three pool rows (address, account, worker, password),
each field with a "+" dropdown of presets (top-11 BTC pool stratums;
worker-name placeholders) plus user-addable, persisted entries. Worker
picks insert at the cursor rather than replacing. Writes up to three pools
per miner via set_pools_config, worker expanded per unit.

#2 PIC detection: replace the broken SSH i2cdump (it read 0x48, the temp
sensor, not the PIC) with a model lookup -- no firmware exposes PIC over the
network, so infer it from the model (noPIC: S19k Pro, S21 family, T21,
explicit noPIC; PIC: rest of the S19 line).

#4 Zoom: an editable percent field in the status bar (type an exact scale)
and Ctrl +/- / Ctrl+0 to zoom in/out/reset.

#5 Health icons align in fixed slots (power, control, fans, hashboards);
miners with fewer fans/boards leave a gap so hashboards still line up. The
max fan/board counts are computed parametrically from the fleet.

#6 Light: the locate-light column is on by default (last), shown as a
green-over-red beacon flashing quickly instead of a single amber dot.

#8 The bottom-left status line is now scan-only; operation progress lives in
the Health column (per miner) and failures in the bottom-right indicator.

#9 / #10 / #11: drop the Credentials-dialog blurb; move the scan-ranges
format help to a tooltip; make Restore-to-stock a plain confirmation (no
typed keyword, no warning wall).

#12 Z15 fans: the v2020 backend now reads fans from higher fan slots
(the Z15 reports fan3/fan4 with fan1/fan2 = 0). Vendored patch 0009.

#14 Export: an Export button writes every scanned data point to a CSV, one
value per cell (lists expanded to indexed columns) -- complete and
machine-readable, unlike the on-screen table.

#15 Health tooltips are per-icon: hovering a specific fan or hashboard shows
just that component's state, with errors attributed to the board that names
them in the message.

New wx-rs bridge surface: widget tooltips, save-file dialog, insert-at-cursor,
status-bar zoom entry + Ctrl+/-, the light beacon + alignment-gap sentinels,
and per-icon cell tooltips (bridge patches 0002/0003 regenerated). Unit tests
(worker templates, PIC map, CSV export, health) + headless selftest pass.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-21 14:43:00 -06:00
53 changed files with 4995 additions and 426 deletions
+4 -2
View File
@@ -30,12 +30,14 @@ ui=false; backend=false
while IFS= read -r f; do
[ -z "$f" ] && continue
case "$f" in
crates/alkane-gui/src/ui.rs|crates/alkane-gui/src/fixtures.rs|thirdparty/wx-rs/*)
crates/alkane-gui/src/ui.rs|crates/alkane-gui/src/fixtures.rs|thirdparty/wx-rs/*|\
crates/alkane-gui/src/bin/*)
ui=true ;;
crates/alkane-core/*|crates/alkane-discovery/*|crates/alkane-access/*|\
crates/alkane-flash/*|crates/alkane-artifacts/*|crates/alkane-cli/*|\
crates/alkane-gui/src/scan.rs|crates/alkane-gui/src/model.rs|\
crates/alkane-gui/src/main.rs|Cargo.toml|Cargo.lock|.gitea/*|ci/*|scripts/*)
crates/alkane-gui/src/main.rs|Cargo.toml|Cargo.lock|.gitea/*|ci/*|scripts/*|\
vendor/*|thirdparty/asic-rs/*)
backend=true ;;
*) : ;; # docs, HANDOFF, README, thirdparty/wxwidgets tree: no bump
esac
@@ -1 +1,29 @@
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 640 640"><!--!Font Awesome Free 7.3.1 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license/free Copyright 2026 Fonticons, Inc.--><path d="M184 120C184 89.1 209.1 64 240 64L264 64C281.7 64 296 78.3 296 96L296 544C296 561.7 281.7 576 264 576L232 576C202.2 576 177.1 555.6 170 528C169.3 528 168.7 528 168 528C123.8 528 88 492.2 88 448C88 430 94 413.4 104 400C84.6 385.4 72 362.2 72 336C72 305.1 89.6 278.2 115.2 264.9C108.1 252.9 104 238.9 104 224C104 179.8 139.8 144 184 144L184 120zM456 120L456 144C500.2 144 536 179.8 536 224C536 239 531.9 253 524.8 264.9C550.5 278.2 568 305 568 336C568 362.2 555.4 385.4 536 400C546 413.4 552 430 552 448C552 492.2 516.2 528 472 528C471.3 528 470.7 528 470 528C462.9 555.6 437.8 576 408 576L376 576C358.3 576 344 561.7 344 544L344 96C344 78.3 358.3 64 376 64L400 64C430.9 64 456 89.1 456 120z"/></svg>
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512"><g transform="translate(0.000000,512.000000) scale(0.100000,-0.100000)" >
<path d="M2152 4645 c-35 -8 -95 -28 -133 -46 l-70 -32 39 -41 c109 -115 121
-180 41 -222 -48 -24 -74 -11 -168 85 -225 229 -555 240 -774 25 l-59 -57 57
-22 c103 -38 134 -107 76 -166 -36 -36 -54 -36 -145 -3 -290 107 -608 -44
-712 -339 -13 -36 -13 -39 4 -32 147 57 237 37 237 -54 0 -56 -26 -78 -115
-101 -479 -123 -584 -723 -175 -995 92 -62 102 -71 105 -100 4 -40 -1 -56 -25
-80 -34 -35 -81 -33 -146 5 -28 17 -53 29 -55 27 -2 -2 14 -38 35 -80 114
-227 341 -383 586 -404 l70 -5 1 103 c4 397 280 752 674 870 70 21 101 23 447
28 l373 6 25 26 c19 18 28 42 35 85 15 107 57 173 141 219 54 30 55 30 234 33
108 2 191 -1 207 -7 60 -23 72 -111 21 -151 -23 -18 -41 -20 -185 -20 -200 0
-238 -16 -238 -98 0 -66 -30 -134 -84 -188 -82 -81 -98 -84 -482 -84 -348 0
-405 -6 -526 -55 -355 -144 -547 -560 -421 -912 156 -434 650 -621 1049 -398
60 34 224 176 224 195 0 4 -17 19 -38 33 -109 72 -138 132 -92 190 43 54 75
48 192 -36 291 -208 673 -260 1012 -136 205 74 390 218 518 399 71 102 72 106
48 140 -37 52 -90 177 -90 213 0 68 62 109 126 82 25 -10 36 -26 58 -81 153
-385 618 -488 905 -201 197 197 213 494 39 725 -38 52 -148 142 -172 142 -6 0
-20 -33 -30 -72 -33 -128 -107 -172 -175 -104 -31 32 -31 62 3 171 114 371
-43 798 -372 1015 -71 47 -198 108 -206 99 -3 -2 13 -40 35 -84 46 -92 43
-132 -12 -160 -64 -34 -95 -17 -149 81 -251 454 -793 618 -1249 378 -99 -52
-140 -57 -176 -18 -43 46 -30 109 28 144 l31 19 -39 17 c-102 42 -247 54 -363
29z"/>
<path d="M4064 2007 c-184 -270 -531 -485 -854 -529 -49 -7 -90 -16 -90 -20 0
-19 163 -171 228 -213 494 -318 1255 -101 1387 395 15 55 18 199 6 254 l-6 30
-155 1 c-119 1 -168 6 -210 19 -67 22 -184 79 -226 111 l-31 24 -49 -72z"/>
<path d="M2431 1509 c-51 -58 -53 -62 -47 -103 13 -83 97 -179 179 -205 18 -5
62 -12 98 -16 138 -13 125 -2 531 -464 231 -265 244 -275 305 -259 63 17 68
37 68 276 l0 214 -80 27 c-237 80 -440 241 -552 441 -23 41 -33 50 -56 50 -49
0 -179 30 -284 66 -55 19 -103 34 -105 34 -2 0 -28 -27 -57 -61z"/>
</g></svg>

Before

Width:  |  Height:  |  Size: 920 B

After

Width:  |  Height:  |  Size: 2.0 KiB

@@ -1 +1,38 @@
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 640 640"><!--!Font Awesome Free 7.3.1 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license/free Copyright 2026 Fonticons, Inc.--><path d="M224 208C224 128.5 288.5 64 368 64C376.8 64 384 71.2 384 80L384 232.2C399 226.9 415.2 224 432 224C511.5 224 576 288.5 576 368C576 376.8 568.8 384 560 384L407.8 384C413.1 399 416 415.2 416 432C416 511.5 351.5 576 272 576C263.2 576 256 568.8 256 560L256 407.8C241 413.1 224.8 416 208 416C128.5 416 64 351.5 64 272C64 263.2 71.2 256 80 256L232.2 256C226.9 241 224 224.8 224 208zM320 352C337.7 352 352 337.7 352 320C352 302.3 337.7 288 320 288C302.3 288 288 302.3 288 320C288 337.7 302.3 352 320 352z"/></svg>
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512"><g transform="translate(0.000000,512.000000) scale(0.100000,-0.100000)" >
<path d="M1970 5109 c-158 -18 -233 -52 -290 -130 -63 -88 -40 -168 95 -329
290 -345 492 -728 595 -1130 7 -25 34 -86 61 -136 l49 -91 108 -6 c76 -3 130
-12 187 -31 44 -14 83 -22 87 -18 13 13 87 322 112 470 126 749 -33 1218 -462
1362 -134 45 -353 60 -542 39z"/>
<path d="M3615 4886 c-82 -30 -119 -107 -130 -271 -29 -409 -151 -830 -337
-1160 -41 -74 -72 -146 -94 -220 l-33 -110 34 -27 c45 -38 120 -139 157 -213
17 -33 32 -61 33 -63 10 -11 325 187 480 303 704 524 836 1036 386 1499 -221
228 -372 307 -496 262z"/>
<path d="M975 4370 c-226 -36 -431 -174 -638 -430 -97 -120 -131 -220 -107
-310 24 -90 105 -132 280 -145 435 -32 872 -164 1211 -366 30 -17 103 -47 163
-64 l108 -33 29 33 c42 48 130 113 209 154 l70 37 -56 99 c-246 438 -574 799
-857 943 -131 67 -298 101 -412 82z"/>
<path d="M4795 3451 c-23 -10 -86 -56 -140 -103 -326 -277 -690 -475 -1066
-579 -76 -21 -144 -48 -205 -82 l-91 -51 -6 -105 c-3 -75 -13 -130 -31 -186
-14 -44 -22 -83 -18 -87 10 -10 261 -74 382 -97 794 -154 1301 2 1450 447 74
222 63 625 -20 756 -63 99 -158 131 -255 87z"/>
<path d="M2443 3095 c-206 -45 -374 -215 -418 -422 -82 -385 263 -730 648
-648 209 44 378 213 423 424 81 385 -268 730 -653 646z m152 -179 c59 -25 75
-97 31 -141 -24 -24 -35 -28 -111 -40 -54 -9 -121 -76 -130 -130 -12 -76 -16
-87 -40 -111 -26 -26 -72 -32 -107 -13 -49 26 -54 133 -10 232 45 101 163 191
274 207 29 4 54 8 56 9 1 0 18 -5 37 -13z"/>
<path d="M767 3009 c-562 -63 -820 -407 -758 -1013 20 -185 49 -255 133 -316
87 -64 167 -40 333 100 329 276 698 475 1070 575 65 18 132 45 192 79 l93 51
0 73 c0 79 21 199 46 258 20 47 20 47 -116 83 -359 95 -742 138 -993 110z"/>
<path d="M1770 2244 c-141 -81 -339 -216 -449 -304 -716 -578 -764 -1101 -146
-1599 106 -85 171 -115 255 -115 139 -2 184 64 206 302 43 463 178 899 372
1206 14 23 40 90 58 151 l33 109 -40 34 c-48 41 -117 137 -155 215 -16 31 -31
57 -34 56 -3 0 -48 -25 -100 -55z"/>
<path d="M3098 2066 c-35 -44 -138 -121 -213 -158 -33 -17 -61 -32 -63 -33
-12 -10 203 -350 312 -494 527 -695 1026 -820 1490 -372 193 187 268 305 270
421 1 129 -67 183 -251 201 -210 20 -292 32 -408 55 -297 62 -591 172 -836
314 -36 21 -106 50 -155 64 -50 14 -97 28 -105 31 -8 3 -25 -9 -41 -29z"/>
<path d="M2256 1882 c-25 -41 -108 -428 -131 -612 -18 -143 -21 -439 -5 -550
74 -535 419 -776 1015 -710 174 19 246 50 305 131 63 87 39 170 -92 324 -277
326 -474 689 -579 1066 -21 74 -49 146 -82 207 l-51 92 -73 0 c-79 0 -200 21
-257 45 -41 17 -43 18 -50 7z"/>
</g></svg>

Before

Width:  |  Height:  |  Size: 727 B

After

Width:  |  Height:  |  Size: 2.5 KiB

+583 -6
View File
@@ -8,15 +8,26 @@
//! Scan the given subnets and print, per responder (TSV):
//! ip make firmware model_id control_board watts supports_power_limit supports_tuning
//!
//! Mutation modes (setpl) are intentionally NOT included here: asic-rs exposes
//! no read-back of a miner's configured power limit, so an exact
//! restore-to-prior-state cannot be guaranteed from this tool alone.
//! miner_probe setpl <ip> <watts>
//! Apply a power limit to ONE miner and print the setter's result. This
//! MUTATES the device -- capture and restore its prior configured limit
//! separately (e.g. WhatsMiner cgminer API on :4028 reports "Power Limit"
//! read-only). asic-rs has no power-limit read-back, so this tool cannot
//! restore on its own.
//!
//! Credentials come from ~/.config/alkane-toolkit/scan-credentials.txt, or from
//! ALKANE_PROBE_USER / ALKANE_PROBE_PASS if set (so a test can authenticate
//! without touching the app's saved config).
use asic_rs::MinerFactory;
use asic_rs::core::traits::miner::MinerAuth;
use futures_util::StreamExt;
use measurements::Power;
fn load_creds() -> Option<(String, String)> {
if let (Ok(u), Ok(pw)) = (std::env::var("ALKANE_PROBE_USER"), std::env::var("ALKANE_PROBE_PASS")) {
return Some((u, pw));
}
let home = std::env::var("HOME").ok()?;
let p = std::path::PathBuf::from(home)
.join(".config/alkane-toolkit/scan-credentials.txt");
@@ -51,7 +62,19 @@ async fn scan(cidrs: &[String]) {
}
};
}
println!("ip\tmake\tfirmware\tmodel_id\tcontrol_board\twatts\tsupports_power_limit\tsupports_tuning");
// Cap identification concurrency to match the GUI (see
// scan::SCAN_CONCURRENCY_LIMIT). asic-rs defaults to 1000, which over a real
// link starves the per-responder get_data -- Braiins miners drop most values
// (watts=0, no best-share) and some responders are missed entirely. 128 is the
// highest cap that stayed fully reliable on the live fleet. ALKANE_PROBE_CONCURRENCY
// overrides it for diagnostics.
let concurrency = std::env::var("ALKANE_PROBE_CONCURRENCY")
.ok()
.and_then(|c| c.parse::<usize>().ok())
.unwrap_or(128);
eprintln!("(scan concurrency = {concurrency})");
f = f.with_concurrent_limit(concurrency);
println!("ip\tmake\tfirmware\tfw_version\tmodel_id\tcontrol_board\twatts\tsupports_power_limit\tsupports_tuning\tbest_share\tsession_best_share");
let mut stream = f.scan_stream_with_ip();
let mut found = 0usize;
while let Some((ip, miner)) = stream.next().await {
@@ -63,10 +86,14 @@ async fn scan(cidrs: &[String]) {
.as_ref()
.map(|c| c.to_string())
.unwrap_or_default();
let fw_ver = data.firmware_version.clone().unwrap_or_default();
let bs = data.best_share.map(|v| format!("{v:.0}")).unwrap_or_default();
let sbs = data.session_best_share.map(|v| format!("{v:.0}")).unwrap_or_default();
println!(
"{ip}\t{}\t{}\t{}\t{}\t{watts:.0}\t{}\t{}",
"{ip}\t{}\t{}\t{}\t{}\t{}\t{watts:.0}\t{}\t{}\t{bs}\t{sbs}",
data.device_info.make,
data.device_info.firmware,
fw_ver,
data.device_info.model,
cb,
m.supports_set_power_limit(),
@@ -78,6 +105,499 @@ async fn scan(cidrs: &[String]) {
eprintln!("scan complete: {found} miner(s) responded");
}
/// Dump raw hashrate value/unit/algo (and expected) as asic-rs reports them,
/// to diagnose the SI-prefix handling for non-SHA algorithms (round-9 #8, Z15).
async fn hashrate(cidrs: &[String]) {
let mut f = factory();
for c in cidrs {
f = match f.with_subnet(c) {
Ok(f) => f,
Err(e) => {
eprintln!("bad subnet {c}: {e}");
return;
}
};
}
println!("ip\tmodel\talgo\thr_value\thr_unit\texp_value\texp_unit");
let mut stream = f.scan_stream_with_ip();
while let Some((ip, miner)) = stream.next().await {
if let Some(m) = miner {
let data = m.get_data().await;
let hr = data.hashrate.as_ref();
let exp = data.expected_hashrate.as_ref();
println!(
"{ip}\t{}\t{}\t{}\t{}\t{}\t{}",
data.device_info.model,
hr.map(|h| h.algo.to_string()).unwrap_or_default(),
hr.map(|h| h.value).unwrap_or(0.0),
hr.map(|h| format!("{:?}", h.unit)).unwrap_or_default(),
exp.map(|h| h.value).unwrap_or(0.0),
exp.map(|h| format!("{:?}", h.unit)).unwrap_or_default(),
);
}
}
eprintln!("hashrate dump complete");
}
async fn setpl(ip_s: &str, watts: f64) {
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;
eprintln!(
"target {ip}: {} {} {} (supports_power_limit={})",
data.device_info.make,
data.device_info.firmware,
data.device_info.model,
m.supports_set_power_limit()
);
match m.set_power_limit(Power::from_watts(watts)).await {
Ok(v) => println!("set_power_limit({watts:.0} W) -> Ok({v})"),
// {e:#} prints the full anyhow chain (the miner's own Msg is the
// root cause), which is exactly what we need to characterise #4.
Err(e) => println!("set_power_limit({watts:.0} W) -> Err: {e:#}"),
}
}
Ok(None) => eprintln!("no miner at {ip}"),
Err(e) => eprintln!("scan_miner {ip}: {e}"),
}
}
/// LOCAL-ONLY: toggle a miner's locate light on then back off, to validate the
/// (token-authenticated) write path safely -- the LED is reversible and does not
/// disturb mining. Restores the light to off afterward.
async fn led(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;
eprintln!(
"target {ip}: {} {} {} (supports_set_fault_light={})",
data.device_info.make,
data.device_info.firmware,
data.device_info.model,
m.supports_set_fault_light()
);
match m.set_fault_light(true).await {
Ok(v) => println!("set_fault_light(on) -> Ok({v})"),
Err(e) => println!("set_fault_light(on) -> Err: {e:#}"),
}
let after_on = m.get_data().await.light_flashing;
println!(" light_flashing after on = {after_on:?}");
// Restore: turn the locate light back off.
match m.set_fault_light(false).await {
Ok(v) => println!("set_fault_light(off) [restore] -> Ok({v})"),
Err(e) => println!("set_fault_light(off) [restore] -> Err: {e:#}"),
}
let after_off = m.get_data().await.light_flashing;
println!(" light_flashing after off = {after_off:?}");
}
Ok(None) => eprintln!("no miner at {ip}"),
Err(e) => eprintln!("scan_miner {ip}: {e}"),
}
}
/// Apply a single "default" pool group to ONE miner via asic-rs set_pools_config
/// (the same path the GUI's pool feature uses). MUTATES the device's pool config.
/// Usage: setpools <ip> <url> <user> <pass>
async fn setpools(ip_s: &str, url: &str, user: &str, pass: &str) {
use asic_rs::core::config::pools::{PoolConfig, PoolGroupConfig};
use asic_rs::core::data::pool::PoolURL;
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;
eprintln!(
"target {ip}: {} {} {} (supports_pools_config={})",
data.device_info.make,
data.device_info.firmware,
data.device_info.model,
m.supports_pools_config()
);
let group = PoolGroupConfig {
name: "default".to_string(),
quota: 1,
pools: vec![PoolConfig {
url: PoolURL::from(url.to_string()),
username: user.to_string(),
password: pass.to_string(),
}],
};
match m.set_pools_config(vec![group]).await {
Ok(v) => println!("set_pools_config -> Ok({v})"),
Err(e) => println!("set_pools_config -> Err: {e:#}"),
}
// Read back the configured pools to verify.
let after = m.get_data().await;
for (i, p) in after.pools.iter().flat_map(|g| g.pools.iter()).enumerate() {
let u = p.url.as_ref().map(|u| u.to_string()).unwrap_or_default();
let acct = p.user.clone().unwrap_or_default();
println!(" pool[{i}] {u} user={acct}");
}
}
Ok(None) => eprintln!("no miner at {ip}"),
Err(e) => eprintln!("scan_miner {ip}: {e}"),
}
}
/// READ-ONLY: dump a miner's structured messages (code + severity + component +
/// text) plus its per-board data, to design health/error attribution.
async fn msgs(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 d = m.get_data().await;
let th = |h: &Option<asic_rs::core::data::hashrate::HashRate>| {
h.clone().map(|x| x.as_unit(asic_rs::core::data::hashrate::HashRateUnit::TeraHash).value)
};
println!(
"{ip}: {} {} hashboards={:?} expected={:?}",
d.device_info.firmware,
d.device_info.model,
d.hashboards.len(),
d.expected_hashboards,
);
println!(
" TOTAL hashrate={:?} TH wattage={:?} W fluid/env_temp={:?} best_share={:?}",
th(&d.hashrate),
d.wattage.as_ref().map(|p| p.as_watts()),
d.fluid_temperature.as_ref().map(|t| t.as_celsius()),
d.best_share,
);
let fans: Vec<i64> = d
.fans
.iter()
.map(|f| f.rpm.as_ref().map(|r| r.as_rpm() as i64).unwrap_or(-1))
.collect();
println!(" fans(rpm)={fans:?} psu_fans={}", d.psu_fans.len());
for b in d.hashboards.iter() {
println!(
" board pos={} hr={:?}TH chips={:?}/{:?} board_temp={:?} outlet_temp={:?}",
b.position,
th(&b.hashrate),
b.working_chips,
b.expected_chips,
b.board_temperature.as_ref().map(|t| t.as_celsius()),
b.outlet_chip_temperature.as_ref().map(|t| t.as_celsius()),
);
}
if d.messages.is_empty() {
println!(" (no messages)");
}
for msg in &d.messages {
println!(
" MSG code={} sev={:?} comp={:?} :: {}",
msg.code, msg.severity, msg.component, msg.message
);
}
}
Ok(None) => eprintln!("no miner at {ip}"),
Err(e) => eprintln!("scan_miner {ip}: {e}"),
}
}
/// Set the locate light to an explicit on/off state (round 16/G1). Capability-gated.
async fn light(ip_s: &str, on: bool) {
let Ok(ip) = ip_s.parse::<std::net::IpAddr>() else {
eprintln!("bad ip {ip_s}");
return;
};
match factory().scan_miner(ip).await {
Ok(Some(m)) => {
if !m.supports_set_fault_light() {
eprintln!("{ip}: locate light not supported");
return;
}
match m.set_fault_light(on).await {
Ok(v) => println!("{ip} light {} -> Ok({v})", if on { "on" } else { "off" }),
Err(e) => println!("{ip} light -> Err: {e:#}"),
}
}
Ok(None) => eprintln!("no miner at {ip}"),
Err(e) => eprintln!("scan_miner {ip}: {e}"),
}
}
/// Run a simple lifecycle action (restart / pause / resume) on one miner (G1).
/// Capability-gated; MUTATES (pause/restart disrupt mining -- run on the test bed).
async fn lifecycle(ip_s: &str, verb: &str) {
let Ok(ip) = ip_s.parse::<std::net::IpAddr>() else {
eprintln!("bad ip {ip_s}");
return;
};
match factory().scan_miner(ip).await {
Ok(Some(m)) => {
let res = match verb {
"restart" if m.supports_restart() => m.restart().await,
"pause" if m.supports_pause() => m.pause(None).await,
"resume" if m.supports_resume() => m.resume(None).await,
"restart" | "pause" | "resume" => {
eprintln!("{ip}: {verb} not supported");
return;
}
_ => {
eprintln!("unknown lifecycle verb {verb}");
return;
}
};
match res {
Ok(v) => println!("{ip} {verb} -> Ok({v})"),
Err(e) => println!("{ip} {verb} -> Err: {e:#}"),
}
}
Ok(None) => eprintln!("no miner at {ip}"),
Err(e) => eprintln!("scan_miner {ip}: {e}"),
}
}
/// Read (no tz arg) or set the miner's timezone (round 16 / G10). Capability-gated.
async fn timezone(ip_s: &str, tz: Option<&str>) {
use asic_rs::core::config::timezone::{Tz, TimezoneConfig};
let Ok(ip) = ip_s.parse::<std::net::IpAddr>() else {
eprintln!("bad ip {ip_s}");
return;
};
match factory().scan_miner(ip).await {
Ok(Some(m)) => {
if !m.supports_timezone_config() {
eprintln!("{ip}: timezone config not supported");
return;
}
if let Some(tz_s) = tz {
let Ok(zone) = tz_s.parse::<Tz>() else {
eprintln!("bad IANA timezone '{tz_s}' (e.g. America/Edmonton)");
return;
};
let cfg = TimezoneConfig {
timezone: Some(zone),
available: Vec::new(),
};
match m.set_timezone_config(cfg).await {
Ok(v) => println!("{ip} set timezone {zone} -> Ok({v})"),
Err(e) => println!("{ip} set timezone -> Err: {e:#}"),
}
}
match m.get_timezone_config().await {
Ok(c) => println!(
"{ip} timezone now: {:?} ({} available)",
c.timezone.map(|t| t.to_string()),
c.available.len()
),
Err(e) => println!("{ip} read timezone -> Err: {e:#}"),
}
}
Ok(None) => eprintln!("no miner at {ip}"),
Err(e) => eprintln!("scan_miner {ip}: {e}"),
}
}
/// Change the miner's web/API password (round 16 / G11). Capability-gated.
/// DANGEROUS: a failed change can lock the toolkit out -- use a dedicated unit.
async fn passwd(ip_s: &str, newpass: &str) {
let Ok(ip) = ip_s.parse::<std::net::IpAddr>() else {
eprintln!("bad ip {ip_s}");
return;
};
match factory().scan_miner(ip).await {
Ok(Some(mut m)) => {
if !m.supports_change_password() {
eprintln!("{ip}: change password not supported");
return;
}
match m.change_password(newpass).await {
Ok(v) => println!("{ip} change_password -> Ok({v})"),
Err(e) => println!("{ip} change_password -> Err: {e:#}"),
}
}
Ok(None) => eprintln!("no miner at {ip}"),
Err(e) => eprintln!("scan_miner {ip}: {e}"),
}
}
/// Factory-reset the miner (round 16 / G12). Capability-gated. DESTRUCTIVE:
/// wipes config and may reset the network (unit can drop off its IP) -- only run
/// on a sacrificial/console-attached unit.
async fn factoryreset(ip_s: &str) {
let Ok(ip) = ip_s.parse::<std::net::IpAddr>() else {
eprintln!("bad ip {ip_s}");
return;
};
match factory().scan_miner(ip).await {
Ok(Some(m)) => {
if !m.supports_factory_reset() {
eprintln!("{ip}: factory reset not supported");
return;
}
match m.factory_reset().await {
Ok(v) => println!("{ip} factory_reset -> Ok({v})"),
Err(e) => println!("{ip} factory_reset -> Err: {e:#}"),
}
}
Ok(None) => eprintln!("no miner at {ip}"),
Err(e) => eprintln!("scan_miner {ip}: {e}"),
}
}
/// 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!(" psu={:?}", data.psu);
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() {
@@ -89,8 +609,65 @@ fn main() {
};
match args.get(1).map(String::as_str) {
Some("scan") if args.len() >= 3 => rt.block_on(scan(&args[2..])),
Some("hashrate") if args.len() >= 3 => rt.block_on(hashrate(&args[2..])),
Some("setpl") if args.len() == 4 => {
let watts: f64 = args[3].parse().unwrap_or(-1.0);
if watts <= 0.0 {
eprintln!("watts must be a positive number");
std::process::exit(2);
}
rt.block_on(setpl(&args[2], watts));
}
Some("led") if args.len() == 3 => rt.block_on(led(&args[2])),
Some("light") if args.len() == 4 && matches!(args[3].as_str(), "on" | "off") => {
rt.block_on(light(&args[2], args[3] == "on"))
}
Some(v @ ("restart" | "pause" | "resume")) if args.len() == 3 => {
rt.block_on(lifecycle(&args[2], v))
}
Some("setpools") if args.len() == 6 => {
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])),
Some("factoryreset") if args.len() == 3 => rt.block_on(factoryreset(&args[2])),
_ => {
eprintln!("usage: miner_probe scan <cidr> [<cidr>...]");
eprintln!(
"miner_probe -- asic-rs config + scan CLI for the alkane-toolkit fleet\n\
\n\
READ (safe on any miner):\n\
\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\
\x20 led <ip> toggle locate light on then off (reversible test)\n\
\x20 pause <ip> pause mining\n\
\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\
\x20 factoryreset <ip> factory reset (DESTRUCTIVE; sacrificial units only)\n\
\n\
Each write verb is capability-gated (skips miners that do not support it).\n\
Credentials: ALKANE_PROBE_USER/PASS or ~/.config/alkane-toolkit/scan-credentials.txt."
);
std::process::exit(2);
}
}
+187
View File
@@ -0,0 +1,187 @@
//! CSV export of the full scan data (round 15 #14).
//!
//! Unlike the on-screen table (which packs several values into one cell, e.g.
//! "95T/96T" or a row of health icons), the export is one value per cell and
//! covers every scanned data point, so it is complete and machine-readable.
//! Variable-length fields (per-board temps, per-fan RPMs, per-board health, the
//! pool list) are expanded into indexed columns out to the widest miner in the
//! set, so every row has the same columns.
use crate::model::{BoardHealth, MinerRow};
/// Escape one CSV field: quote it when it contains a comma, quote, CR or LF, and
/// double any embedded quotes.
fn esc(s: &str) -> String {
if s.contains([',', '"', '\n', '\r']) {
format!("\"{}\"", s.replace('"', "\"\""))
} else {
s.to_string()
}
}
fn num(v: f64) -> String {
if v == 0.0 {
String::new()
} else if v.fract() == 0.0 {
format!("{v:.0}")
} else {
format!("{v:.3}")
}
}
fn opt_bool(v: Option<bool>, yes: &str, no: &str) -> String {
match v {
Some(true) => yes.to_string(),
Some(false) => no.to_string(),
None => String::new(),
}
}
fn board_health_str(h: &BoardHealth) -> &'static str {
match h {
BoardHealth::Ok => "ok",
BoardHealth::Fault => "fault",
BoardHealth::Missing => "missing",
}
}
/// The fixed scalar columns, in order: (header, extractor).
type Col = (&'static str, fn(&MinerRow) -> String);
fn scalar_columns() -> Vec<Col> {
vec![
("ip", |r| r.ip.clone()),
("model", |r| r.model.clone()),
("brand", |r| r.brand.clone()),
("submodel", |r| r.submodel.clone()),
("mac", |r| r.mac.clone()),
("hostname", |r| r.hostname.clone()),
("serial", |r| r.serial.clone()),
("firmware", |r| r.firmware.clone()),
("fw_version", |r| r.fw_version.clone()),
("api_version", |r| r.api_version.clone()),
("control_board", |r| r.control_board.clone()),
("cpu", |r| r.cpu.clone()),
("board_code", |r| r.board_code.clone()),
("algorithm", |r| r.algorithm.clone()),
("status", |r| r.status().to_string()),
("operating_state", |r| r.operating_state.clone()),
("is_mining", |r| r.is_mining.to_string()),
("slow", |r| r.slow.to_string()),
("paused", |r| r.paused.to_string()),
("pic", |r| opt_bool(r.pic_present, "PIC", "noPIC")),
("write_locked", |r| opt_bool(r.write_locked, "locked", "unlocked")),
("light_flashing", |r| opt_bool(r.light_flashing, "on", "off")),
("hashrate_ths", |r| num(r.hashrate_ths)),
("expected_ths", |r| num(r.expected_ths)),
("efficiency_j_th", |r| num(r.efficiency)),
("power_w", |r| num(r.power_w)),
("tuning_percent", |r| r.tuning_percent.map(|v| v.to_string()).unwrap_or_default()),
("chip_temp_c", |r| num(r.chip_temp_c)),
("fluid_temp_c", |r| num(r.fluid_temp_c)),
("env_temp_c", |r| num(r.env_temp_c)),
("outlet_temp_c", |r| num(r.outlet_temp_c)),
("psu_fan_rpm", |r| num(r.psu_fan_rpm)),
("fan_count", |r| r.fan_count.map(|v| v.to_string()).unwrap_or_default()),
("expected_fans", |r| r.expected_fans.map(|v| v.to_string()).unwrap_or_default()),
("total_chips", |r| r.total_chips.map(|v| v.to_string()).unwrap_or_default()),
("expected_chips", |r| r.expected_chips.map(|v| v.to_string()).unwrap_or_default()),
("hashboards", |r| r.hashboards.map(|v| v.to_string()).unwrap_or_default()),
("expected_hashboards", |r| r.expected_hashboards.map(|v| v.to_string()).unwrap_or_default()),
("uptime_secs", |r| if r.uptime_secs > 0 { r.uptime_secs.to_string() } else { String::new() }),
("best_share", |r| r.best_share.map(num).unwrap_or_default()),
("session_best_share", |r| r.session_best_share.map(num).unwrap_or_default()),
("pool_account", |r| r.worker.split_once('.').map(|(a, _)| a).unwrap_or(&r.worker).to_string()),
("pool_url", |r| r.pool_url.clone()),
("errors", |r| r.errors.join("; ")),
]
}
/// Build the full CSV for `rows`. Empty rows still emit a header line.
pub fn rows_to_csv(rows: &[MinerRow]) -> String {
let cols = scalar_columns();
// Widest variable-length fields across the set.
let max_board_temps = rows.iter().map(|r| r.board_temps.len()).max().unwrap_or(0);
let max_fans = rows.iter().map(|r| r.fan_rpms.len()).max().unwrap_or(0);
let max_boards = rows.iter().map(|r| r.board_status.len()).max().unwrap_or(0);
let max_pools = rows.iter().map(|r| r.pools.len()).max().unwrap_or(0);
// Header.
let mut headers: Vec<String> = cols.iter().map(|(h, _)| (*h).to_string()).collect();
for i in 1..=max_board_temps {
headers.push(format!("board_temp_{i}_c"));
}
for i in 1..=max_fans {
headers.push(format!("fan_{i}_rpm"));
}
for i in 1..=max_boards {
headers.push(format!("board_{i}_status"));
}
for i in 1..=max_pools {
headers.push(format!("pool_{i}_url"));
headers.push(format!("pool_{i}_worker"));
}
let mut out = String::new();
out.push_str(&headers.iter().map(|h| esc(h)).collect::<Vec<_>>().join(","));
out.push('\n');
for r in rows {
let mut vals: Vec<String> = cols.iter().map(|(_, f)| f(r)).collect();
for i in 0..max_board_temps {
vals.push(r.board_temps.get(i).map(|&t| num(t)).unwrap_or_default());
}
for i in 0..max_fans {
vals.push(r.fan_rpms.get(i).map(|&t| num(t)).unwrap_or_default());
}
for i in 0..max_boards {
vals.push(r.board_status.get(i).map(board_health_str).unwrap_or("").to_string());
}
for i in 0..max_pools {
let (u, w) = r.pools.get(i).cloned().unwrap_or_default();
vals.push(u);
vals.push(w);
}
out.push_str(&vals.iter().map(|v| esc(v)).collect::<Vec<_>>().join(","));
out.push('\n');
}
out
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn csv_has_header_and_one_row_per_miner() {
let rows = vec![
MinerRow {
ip: "10.0.0.1".into(),
model: "S19".into(),
hashrate_ths: 95.0,
expected_ths: 96.0,
board_temps: vec![77.0, 64.0, 74.0],
fan_rpms: vec![6000.0, 6100.0],
..Default::default()
},
MinerRow { ip: "10.0.0.2".into(), model: "M30S".into(), ..Default::default() },
];
let csv = rows_to_csv(&rows);
let lines: Vec<&str> = csv.lines().collect();
assert_eq!(lines.len(), 3, "header + 2 rows");
assert!(lines[0].starts_with("ip,model,brand,"));
// Expanded columns out to the widest miner (3 board temps, 2 fans).
assert!(lines[0].contains("board_temp_3_c"));
assert!(lines[0].contains("fan_2_rpm"));
assert!(lines[1].starts_with("10.0.0.1,S19,"));
// One value per cell: hashrate and expected are separate columns.
assert!(lines[1].contains(",95,96,") || lines[1].contains("95,96"));
}
#[test]
fn csv_escapes_commas_and_quotes() {
assert_eq!(esc("a,b"), "\"a,b\"");
assert_eq!(esc("he said \"hi\""), "\"he said \"\"hi\"\"\"");
assert_eq!(esc("plain"), "plain");
}
}
+19
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,
@@ -127,6 +135,13 @@ impl Board {
board_status,
total_chips: chips,
psu_fan_rpm: if self.mining { self.fan * 0.9 } else { 0.0 },
// PSU info demo (round 17 R5): mining units show a version + rated
// envelope + live output, so the columns and the R2 PSU tooltip render.
psu_version: if self.mining { "22 (117)".to_string() } else { String::new() },
psu_voltage_min_v: self.mining.then_some(11.88),
psu_voltage_max_v: self.mining.then_some(15.18),
psu_out_voltage_v: self.mining.then_some(13.2),
psu_out_current_a: self.mining.then_some(210.0),
uptime_secs: if self.mining { 3600 * 24 * 2 + 3600 * 5 } else { 0 },
// One unit is "being located" so the Light column's yellow dot is
// demonstrable offline (round 11 #10).
@@ -157,8 +172,12 @@ impl Board {
resume: self.mining,
power_limit: self.mining,
tuning: self.mining,
hashrate_target: self.mining,
firmware_flash,
pools: true,
timezone: self.mining,
change_password: true,
factory_reset: true,
},
// Demo values for the round-8/9 columns (synthetic, so the columns
// show variety offline). control_board is derived above via naming.
+162
View File
@@ -0,0 +1,162 @@
//! Lightweight UI localization (round 15 #13).
//!
//! Visible strings are wrapped in `t("English text")`; the English text is the
//! lookup key. `t` returns the translation for the current language, falling back
//! to the English key when a string has no translation yet. The language is a
//! process-global, persisted under the config dir; changing it re-titles the
//! table columns and toolbar/KPI labels live and localizes dialogs as they open.
use std::path::PathBuf;
use std::sync::atomic::{AtomicU8, Ordering};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Lang {
En,
Zh,
Ru,
Fr,
Es,
Pt,
}
impl Lang {
pub fn all() -> [Lang; 6] {
[Lang::En, Lang::Zh, Lang::Ru, Lang::Fr, Lang::Es, Lang::Pt]
}
/// The language's own name, for the selector menu.
pub fn label(self) -> &'static str {
match self {
Lang::En => "English",
Lang::Zh => "\u{4e2d}\u{6587}", // 中文
Lang::Ru => "\u{0420}\u{0443}\u{0441}\u{0441}\u{043a}\u{0438}\u{0439}", // Русский
Lang::Fr => "Fran\u{e7}ais",
Lang::Es => "Espa\u{f1}ol",
Lang::Pt => "Portugu\u{ea}s",
}
}
fn code(self) -> &'static str {
match self {
Lang::En => "en",
Lang::Zh => "zh",
Lang::Ru => "ru",
Lang::Fr => "fr",
Lang::Es => "es",
Lang::Pt => "pt",
}
}
fn from_code(s: &str) -> Lang {
match s.trim() {
"zh" => Lang::Zh,
"ru" => Lang::Ru,
"fr" => Lang::Fr,
"es" => Lang::Es,
"pt" => Lang::Pt,
_ => Lang::En,
}
}
fn index(self) -> usize {
match self {
Lang::En => 0,
Lang::Zh => 1,
Lang::Ru => 2,
Lang::Fr => 3,
Lang::Es => 4,
Lang::Pt => 5,
}
}
}
static CURRENT: AtomicU8 = AtomicU8::new(0);
const LANG_FILE: &str = "language.txt";
fn config_path() -> PathBuf {
let home = std::env::var("HOME").unwrap_or_else(|_| ".".into());
PathBuf::from(home).join(".config/alkane-toolkit").join(LANG_FILE)
}
/// Load the saved language into the global (call once at startup).
pub fn init() {
let l = std::fs::read_to_string(config_path())
.ok()
.map(|s| Lang::from_code(&s))
.unwrap_or(Lang::En);
CURRENT.store(lang_to_u8(l), Ordering::Relaxed);
}
pub fn current() -> Lang {
u8_to_lang(CURRENT.load(Ordering::Relaxed))
}
/// Set + persist the language.
pub fn set(l: Lang) {
CURRENT.store(lang_to_u8(l), Ordering::Relaxed);
let p = config_path();
if let Some(dir) = p.parent() {
let _ = std::fs::create_dir_all(dir);
}
let _ = std::fs::write(p, l.code());
}
fn lang_to_u8(l: Lang) -> u8 {
l.index() as u8
}
fn u8_to_lang(v: u8) -> Lang {
Lang::all().get(v as usize).copied().unwrap_or(Lang::En)
}
/// Translate `key` (an English string) to the current language, or return `key`
/// when there is no translation.
pub fn t(key: &str) -> String {
let lang = current();
if lang == Lang::En {
return key.to_string();
}
for (en, tr) in TABLE {
if *en == key {
let s = tr[lang.index()];
if !s.is_empty() {
return s.to_string();
}
break;
}
}
key.to_string()
}
// Translation table: (English, [en, zh, ru, fr, es, pt]). The en slot mirrors the
// key (unused by `t`, kept for readability). An empty slot falls back to English.
#[rustfmt::skip]
const TABLE: &[(&str, [&str; 6])] = &[
// Toolbar + settings
("Scan ranges", ["Scan ranges", "\u{626b}\u{63cf}\u{8303}\u{56f4}", "\u{0414}\u{0438}\u{0430}\u{043f}\u{0430}\u{0437}\u{043e}\u{043d}\u{044b}", "Plages", "Rangos", "Faixas"]),
("Presets", ["Presets", "\u{9884}\u{8bbe}", "\u{041f}\u{0440}\u{0435}\u{0441}\u{0435}\u{0442}\u{044b}", "Pr\u{e9}r\u{e9}glages", "Ajustes", "Predefini\u{e7}\u{f5}es"]),
("Filter", ["Filter", "\u{7b5b}\u{9009}", "\u{0424}\u{0438}\u{043b}\u{044c}\u{0442}\u{0440}", "Filtre", "Filtro", "Filtro"]),
("Columns", ["Columns", "\u{5217}", "\u{0421}\u{0442}\u{043e}\u{043b}\u{0431}\u{0446}\u{044b}", "Colonnes", "Columnas", "Colunas"]),
("Export", ["Export", "\u{5bfc}\u{51fa}", "\u{042d}\u{043a}\u{0441}\u{043f}\u{043e}\u{0440}\u{0442}", "Exporter", "Exportar", "Exportar"]),
("Settings", ["Settings", "\u{8bbe}\u{7f6e}", "\u{041d}\u{0430}\u{0441}\u{0442}\u{0440}\u{043e}\u{0439}\u{043a}\u{0438}", "Param\u{e8}tres", "Ajustes", "Configura\u{e7}\u{f5}es"]),
("Credentials", ["Credentials", "\u{51ed}\u{636e}", "\u{0423}\u{0447}\u{0451}\u{0442}\u{043d}\u{044b}\u{0435} \u{0434}\u{0430}\u{043d}\u{043d}\u{044b}\u{0435}", "Identifiants", "Credenciales", "Credenciais"]),
("Language", ["Language", "\u{8bed}\u{8a00}", "\u{042f}\u{0437}\u{044b}\u{043a}", "Langue", "Idioma", "Idioma"]),
("Logs", ["Logs", "\u{65e5}\u{5fd7}", "\u{0416}\u{0443}\u{0440}\u{043d}\u{0430}\u{043b}", "Journaux", "Registros", "Registos"]),
// KPI captions
("Total", ["Total", "\u{603b}\u{6570}", "\u{0412}\u{0441}\u{0435}\u{0433}\u{043e}", "Total", "Total", "Total"]),
("Hashing", ["Hashing", "\u{6b63}\u{5728}\u{6316}\u{77ff}", "\u{0425}\u{0435}\u{0448}\u{0438}\u{0440}\u{043e}\u{0432}\u{0430}\u{043d}\u{0438}\u{0435}", "Minage", "Minando", "Minerando"]),
("Slow", ["Slow", "\u{7f13}\u{6162}", "\u{041c}\u{0435}\u{0434}\u{043b}\u{0435}\u{043d}\u{043d}\u{043e}", "Lent", "Lento", "Lento"]),
("Not hashing", ["Not hashing", "\u{672a}\u{6316}\u{77ff}", "\u{041d}\u{0435} \u{0445}\u{0435}\u{0448}\u{0438}\u{0440}\u{0443}\u{0435}\u{0442}", "Inactif", "Inactivo", "Inativo"]),
("Paused", ["Paused", "\u{5df2}\u{6682}\u{505c}", "\u{041f}\u{0430}\u{0443}\u{0437}\u{0430}", "En pause", "Pausado", "Pausado"]),
("Est. power", ["Est. power", "\u{4f30}\u{8ba1}\u{529f}\u{7387}", "\u{041e}\u{0446}. \u{043c}\u{043e}\u{0449}\u{043d}.", "Puiss. est.", "Pot. est.", "Pot. est."]),
// Column headers (the default-visible set + common ones)
("Model", ["Model", "\u{578b}\u{53f7}", "\u{041c}\u{043e}\u{0434}\u{0435}\u{043b}\u{044c}", "Mod\u{e8}le", "Modelo", "Modelo"]),
("Health", ["Health", "\u{72b6}\u{6001}", "\u{0421}\u{043e}\u{0441}\u{0442}\u{043e}\u{044f}\u{043d}\u{0438}\u{0435}", "\u{c9}tat", "Estado", "Sa\u{fa}de"]),
("Hashrate", ["Hashrate", "\u{7b97}\u{529b}", "\u{0425}\u{0435}\u{0448}\u{0440}\u{0435}\u{0439}\u{0442}", "Hashrate", "Hashrate", "Hashrate"]),
("Power", ["Power", "\u{529f}\u{7387}", "\u{041c}\u{043e}\u{0449}\u{043d}\u{043e}\u{0441}\u{0442}\u{044c}", "Puissance", "Potencia", "Pot\u{ea}ncia"]),
("Chip temp", ["Chip temp", "\u{82af}\u{7247}\u{6e29}\u{5ea6}", "\u{0422}\u{0435}\u{043c}\u{043f}. \u{0447}\u{0438}\u{043f}\u{0430}", "Temp. puce", "Temp. chip", "Temp. chip"]),
("Firmware", ["Firmware", "\u{56fa}\u{4ef6}", "\u{041f}\u{0440}\u{043e}\u{0448}\u{0438}\u{0432}\u{043a}\u{0430}", "Firmware", "Firmware", "Firmware"]),
("CPU", ["CPU", "CPU", "\u{041f}\u{0440}\u{043e}\u{0446}.", "Processeur", "CPU", "CPU"]),
("Access", ["Access", "\u{8bbf}\u{95ee}", "\u{0414}\u{043e}\u{0441}\u{0442}\u{0443}\u{043f}", "Acc\u{e8}s", "Acceso", "Acesso"]),
("Light", ["Light", "\u{6307}\u{793a}\u{706f}", "\u{041f}\u{043e}\u{0434}\u{0441}\u{0432}\u{0435}\u{0442}\u{043a}\u{0430}", "Voyant", "Luz", "Luz"]),
("Fan (RPM)", ["Fan (RPM)", "\u{98ce}\u{6247} (RPM)", "\u{0412}\u{0435}\u{043d}\u{0442}. (\u{043e}\u{0431}/\u{043c}\u{0438}\u{043d})", "Ventilo (TR/M)", "Ventilador (RPM)", "Ventoinha (RPM)"]),
("Control Board", ["Control Board", "\u{63a7}\u{5236}\u{677f}", "\u{041f}\u{043b}\u{0430}\u{0442}\u{0430} \u{0443}\u{043f}\u{0440}.", "Carte de contr\u{f4}le", "Placa control", "Placa controlo"]),
("Uptime", ["Uptime", "\u{8fd0}\u{884c}\u{65f6}\u{95f4}", "\u{0412}\u{0440}\u{0435}\u{043c}\u{044f} \u{0440}\u{0430}\u{0431}.", "Dur\u{e9}e", "Tiempo activo", "Tempo ativo"]),
("Serial", ["Serial", "\u{5e8f}\u{5217}\u{53f7}", "\u{0421}\u{0435}\u{0440}\u{0438}\u{0439}\u{043d}\u{044b}\u{0439}", "N\u{b0} de s\u{e9}rie", "N\u{b0} de serie", "N\u{b0} de s\u{e9}rie"]),
];
+42
View File
@@ -0,0 +1,42 @@
//! In-app activity log (round 15 #13). A small, process-global ring buffer of
//! timestamped messages -- scans starting/finishing, operations applied, errors --
//! shown in the Settings > Logs page. Thread-safe so background workers can append.
use std::sync::Mutex;
use std::time::{SystemTime, UNIX_EPOCH};
const MAX_ENTRIES: usize = 2000;
static LOG: Mutex<Vec<String>> = Mutex::new(Vec::new());
/// Local wall-clock HH:MM:SS for a log line. Uses the system clock offset from
/// UTC via the TZ-less epoch; good enough for an activity log timestamp.
fn stamp() -> String {
let secs = SystemTime::now().duration_since(UNIX_EPOCH).map(|d| d.as_secs()).unwrap_or(0);
let t = secs % 86_400;
format!("{:02}:{:02}:{:02}", t / 3600, (t % 3600) / 60, t % 60)
}
/// Append a message to the activity log (timestamped).
pub fn log(msg: impl Into<String>) {
let line = format!("{} {}", stamp(), msg.into());
if let Ok(mut v) = LOG.lock() {
v.push(line);
let len = v.len();
if len > MAX_ENTRIES {
v.drain(0..len - MAX_ENTRIES);
}
}
}
/// The whole log as one string, newest last (for the Logs page text box).
pub fn dump() -> String {
LOG.lock().map(|v| v.join("\n")).unwrap_or_default()
}
/// Clear the log.
pub fn clear() {
if let Ok(mut v) = LOG.lock() {
v.clear();
}
}
+7
View File
@@ -3,10 +3,14 @@
mod access_probe;
mod credentials;
mod export;
mod fixtures;
mod i18n;
mod logs;
mod log_scan;
mod model;
mod naming;
mod pool_prefs;
mod presets;
mod restore;
mod scan;
@@ -65,6 +69,9 @@ fn main() {
std::process::exit(0);
}
// Load the saved UI language before any strings are built (round 15 #13).
i18n::init();
// Bootstrap the wx app + main frame (upstream bridge).
wx_rs::init_app("alkane-toolkit", 1280, 800);
// Follow the system light/dark appearance.
+406 -36
View File
@@ -213,12 +213,21 @@ 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,
/// Whether this miner's driver supports writing pool configuration (probed
/// via `supports_pools_config()` at scan time; round 14 #7).
pub pools: bool,
/// Round 17 B: supports setting the timezone / changing the web password /
/// factory reset (probed via the matching `supports_*()` at scan time).
pub timezone: bool,
pub change_password: bool,
pub factory_reset: bool,
}
impl MinerCaps {
@@ -231,8 +240,12 @@ 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,
change_password: self.change_password && other.change_password,
factory_reset: self.factory_reset && other.factory_reset,
}
}
@@ -260,8 +273,12 @@ impl MinerCaps {
|| self.resume
|| self.power_limit
|| self.tuning
|| self.hashrate_target
|| self.firmware_flash
|| self.pools
|| self.timezone
|| self.change_password
|| self.factory_reset
}
}
@@ -275,6 +292,46 @@ pub enum BoardHealth {
Missing,
}
/// Which physical component a miner fault message is attributed to (round 16 #1).
/// Mapped from asic-rs's structured `MinerMessage.component`; `Other` covers
/// messages with no specific component (e.g. an ambient-temperature warning).
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum FaultComponent {
Power,
Control,
Fan(usize),
Board(usize),
Other,
}
/// One structured fault/message from a miner (round 16 #1). Carries the specific
/// human-readable text and the component it belongs to, so the Health column's
/// per-icon tooltips can show the actual fault (e.g. "Slot 0 error reading chip
/// id") on the specific board rather than a generic "faulted".
#[derive(Debug, Clone)]
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.
@@ -353,12 +410,40 @@ pub struct MinerRow {
/// severe first. Empty means none. The Error column shows a summary; the
/// full list is the hover tooltip (added with the tooltip bridge support).
pub errors: Vec<String>,
/// Structured faults with their attributed component (round 16 #1/#2/#3),
/// used to colour each Health icon and drive its specific per-icon tooltip.
pub faults: Vec<Fault>,
// 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>,
/// PSU identity + rated voltage envelope, when the firmware reports it (round
/// 17 R5 / G15; ePIC today). `psu_version` is blank when unknown.
pub psu_version: String,
pub psu_voltage_min_v: Option<f64>,
pub psu_voltage_max_v: 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
@@ -431,6 +516,11 @@ impl MinerRow {
/// live); grey (unknown) otherwise -- asic-rs has no direct PSU-fault flag, so
/// a missing wattage reading is treated as unknown, never a false "down".
pub fn power_health(&self) -> CompHealth {
// A reported power-supply fault (round 16 #2) is authoritative: red, even
// if a residual wattage is still being read.
if self.faults_for(FaultComponent::Power).next().is_some() {
return CompHealth::Down;
}
if self.power_w > 0.0 || self.psu_fan_rpm > 0.0 || self.is_mining {
CompHealth::Ok
} else {
@@ -438,11 +528,39 @@ impl MinerRow {
}
}
/// Control-board health (round 13 #3). The miner answered the scan, so its
/// control board is reachable and running; there is no network signal for a
/// degraded controller, so this is green for any responding miner.
/// Control-board health (round 13 #3, round 16 #1). The miner answered the
/// scan, so its control board is reachable; red if the miner reports a
/// control-board fault, yellow if it reports a miner-level fault with no
/// specific component (e.g. ambient temperature too high), else green.
pub fn control_health(&self) -> CompHealth {
CompHealth::Ok
if self.faults_for(FaultComponent::Control).next().is_some() {
CompHealth::Down
} else if self.general_faults().next().is_some() {
CompHealth::Degraded
} else {
CompHealth::Ok
}
}
/// Iterator over this row's Error-severity faults for a given component.
fn faults_for(&self, component: FaultComponent) -> impl Iterator<Item = &Fault> {
self.faults
.iter()
.filter(move |f| f.is_error && f.component == component)
}
/// Error-severity faults not tied to a specific component (control-board /
/// miner-level), for the control-board icon tooltip.
fn general_faults(&self) -> impl Iterator<Item = &Fault> {
self.faults
.iter()
.filter(|f| f.is_error && matches!(f.component, FaultComponent::Other))
}
/// True when the miner reports a power-supply fault, which means the
/// hashboards cannot be powered or evaluated (round 16 #2).
fn power_supply_faulted(&self) -> bool {
self.faults_for(FaultComponent::Power).next().is_some()
}
/// Per-fan health (round 13 #3), front-to-back / top-to-bottom in the order
@@ -470,31 +588,52 @@ impl MinerRow {
.collect()
}
/// Per-hashboard health (round 13 #3). Uses the per-board status when the
/// miner reports it (green ok / red faulted / grey missing); otherwise falls
/// back to the present-vs-expected board counts (present green, shortfall
/// grey). Empty when neither is known.
/// Per-hashboard health (round 13 #3, reworked round 16 #2/#3). Layers three
/// signals, most-authoritative last:
/// 1. Base: the per-board status the miner reports (green ok / red faulted /
/// grey missing), else the present-vs-expected board counts.
/// 2. Per-board fault messages (round 16 #3): when the miner reports
/// board-specific faults, ONLY the named boards are red and the rest are
/// green -- a whole-miner stall zeroes every board's hashrate, so the raw
/// status wrongly reds working boards that the error codes exonerate.
/// 3. Power-supply fault (round 16 #2): the boards can't be powered or
/// evaluated, so every board is grey (not red).
pub fn board_healths(&self) -> Vec<CompHealth> {
if !self.board_status.is_empty() {
// A miner that is mining but "slow" is hashing sub-optimally, so its
// present-and-hashing boards read yellow rather than green.
let ok = if self.slow { CompHealth::Degraded } else { CompHealth::Ok };
return self
.board_status
// 1. Base health from board status / counts.
let ok = if self.slow { CompHealth::Degraded } else { CompHealth::Ok };
let mut base: Vec<CompHealth> = if !self.board_status.is_empty() {
self.board_status
.iter()
.map(|h| match h {
BoardHealth::Ok => ok,
BoardHealth::Fault => CompHealth::Down,
BoardHealth::Missing => CompHealth::Unreachable,
})
.collect();
.collect()
} else {
let present = self.hashboards.map(|n| n as usize).unwrap_or(0);
let expected = self.expected_hashboards.map(|n| n as usize).unwrap_or(present);
let n = present.max(expected);
(0..n)
.map(|i| if i < present { CompHealth::Ok } else { CompHealth::Unreachable })
.collect()
};
if base.is_empty() {
return base;
}
let present = self.hashboards.map(|n| n as usize).unwrap_or(0);
let expected = self.expected_hashboards.map(|n| n as usize).unwrap_or(present);
let n = present.max(expected);
(0..n)
.map(|i| if i < present { CompHealth::Ok } else { CompHealth::Unreachable })
.collect()
// 3. A PSU fault means no board can be powered/tested -> all grey.
if self.power_supply_faulted() {
return vec![CompHealth::Unreachable; base.len()];
}
// 2. Board-specific faults are authoritative: red only the named boards,
// green the rest (overriding a stall-induced all-red).
let board_faulted = |i: usize| self.faults_for(FaultComponent::Board(i)).next().is_some();
if (0..base.len()).any(board_faulted) {
for (i, h) in base.iter_mut().enumerate() {
*h = if board_faulted(i) { CompHealth::Down } else { ok };
}
}
base
}
/// The sort key for the Health column and its facet pseudo-columns (round 13
@@ -527,6 +666,113 @@ impl MinerRow {
val as f64
}
/// Human-readable fault messages attributed to a specific component
/// (round 16 #1), for that Health icon's hover tooltip.
fn fault_texts_for(&self, component: FaultComponent) -> Vec<String> {
self.faults
.iter()
.filter(|f| f.component == component)
.map(|f| f.display_line())
.collect()
}
/// Fault messages not tied to a specific board/fan/PSU (miner-level or
/// control-board), for the control-board icon tooltip (round 16 #1).
fn general_fault_texts(&self) -> Vec<String> {
self.faults
.iter()
.filter(|f| matches!(f.component, FaultComponent::Other | FaultComponent::Control))
.map(|f| f.display_line())
.collect()
}
/// Per-icon hover tooltips for the Health column, in the same draw order (and
/// length) as `encode_component_health`'s segments: power, control, each fan
/// padded to `max_fans`, each hashboard padded to `max_boards` (round 15 #15,
/// round 16 #1/#2). Each icon's tooltip carries the specific faults the miner
/// 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 (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);
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(),
});
}
// 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(),
});
}
// 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 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
}
};
tips.push(t);
}
// 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 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
};
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".
@@ -657,6 +903,11 @@ pub enum Column {
EnvTemp,
OutletTemp,
PsuFan,
/// PSU identity + rated voltage envelope (round 17 R5). Populated where the
/// firmware exposes PSU info (ePIC today).
PsuVersion,
PsuVMin,
PsuVMax,
FanCount,
ExpectedFans,
TotalChips,
@@ -688,7 +939,7 @@ pub enum Column {
/// Every column, in registry order. Ip first, then the default-visible set
/// (UI-SPEC order), then all remaining metrics.
pub const ALL_COLUMNS: [Column; 43] = [
pub const ALL_COLUMNS: [Column; 46] = [
Column::Ip,
Column::Hashrate,
Column::Health,
@@ -707,6 +958,9 @@ pub const ALL_COLUMNS: [Column; 43] = [
Column::EnvTemp,
Column::OutletTemp,
Column::PsuFan,
Column::PsuVersion,
Column::PsuVMin,
Column::PsuVMax,
Column::FanCount,
Column::ExpectedFans,
Column::TotalChips,
@@ -738,7 +992,7 @@ pub const ALL_COLUMNS: [Column; 43] = [
/// order: model, health (component icons), hashrate, power, chip temp, firmware,
/// CPU, access. The Health column (round 13 #3) folds the old Errors, Boards and
/// Status columns into one row of per-component icons.
pub const DEFAULT_VISIBLE: [Column; 8] = [
pub const DEFAULT_VISIBLE: [Column; 9] = [
Column::Model,
Column::Health,
Column::Hashrate,
@@ -747,6 +1001,8 @@ pub const DEFAULT_VISIBLE: [Column; 8] = [
Column::Firmware,
Column::Cpu,
Column::Locked,
// Locate-light beacon, last (round 15 #6).
Column::Light,
];
impl Column {
@@ -775,6 +1031,9 @@ impl Column {
Column::EnvTemp => "Env temp",
Column::OutletTemp => "Outlet temp",
Column::PsuFan => "PSU fan (RPM)",
Column::PsuVersion => "PSU version",
Column::PsuVMin => "PSU Vmin",
Column::PsuVMax => "PSU Vmax",
Column::FanCount => "Fans",
Column::ExpectedFans => "Fans (exp)",
Column::TotalChips => "Chips",
@@ -813,6 +1072,8 @@ impl Column {
Column::Power => 90,
Column::ChipTemp | Column::FluidTemp | Column::EnvTemp | Column::OutletTemp => 95,
Column::Cooling | Column::PsuFan => 100,
Column::PsuVersion => 100,
Column::PsuVMin | Column::PsuVMax => 90,
Column::Firmware => 110,
Column::FwVersion => 130,
Column::Worker => 130,
@@ -860,6 +1121,8 @@ impl Column {
| Column::OutletTemp
| Column::Cooling
| Column::PsuFan
| Column::PsuVMin
| Column::PsuVMax
| Column::FanCount
| Column::ExpectedFans
| Column::TotalChips
@@ -921,6 +1184,8 @@ impl Column {
r.fan_rpms.iter().cloned().fold(f64::INFINITY, f64::min)
}),
Column::PsuFan => SortKey::Num(r.psu_fan_rpm),
Column::PsuVMin => SortKey::Num(r.psu_voltage_min_v.unwrap_or(none)),
Column::PsuVMax => SortKey::Num(r.psu_voltage_max_v.unwrap_or(none)),
Column::FanCount => SortKey::Num(r.fan_count.map(|v| v as f64).unwrap_or(none)),
Column::ExpectedFans => SortKey::Num(r.expected_fans.map(|v| v as f64).unwrap_or(none)),
Column::TotalChips => SortKey::Num(r.total_chips.map(|v| v as f64).unwrap_or(none)),
@@ -1003,6 +1268,9 @@ impl Column {
r.fan_rpms.iter().map(|&v| format_fan_rpm(v)).collect::<Vec<_>>().join("/")
}
Column::PsuFan => num(r.psu_fan_rpm, 0, ""),
Column::PsuVersion => r.psu_version.clone(),
Column::PsuVMin => r.psu_voltage_min_v.map(|v| format!("{v:.2} V")).unwrap_or_default(),
Column::PsuVMax => r.psu_voltage_max_v.map(|v| format!("{v:.2} V")).unwrap_or_default(),
Column::FanCount => count(r.fan_count),
Column::ExpectedFans => count(r.expected_fans),
Column::TotalChips => combined_count(r.total_chips, r.expected_chips),
@@ -1022,11 +1290,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(),
@@ -1087,7 +1364,8 @@ impl Column {
Column::Cooling | Column::PsuFan | Column::FanCount | Column::ExpectedFans => {
(5, "Cooling")
}
Column::TotalChips | Column::Hashboards => (6, "Hardware"),
Column::TotalChips | Column::Hashboards | Column::PsuVersion | Column::PsuVMin
| Column::PsuVMax => (6, "Hardware"),
Column::Worker | Column::PoolAccount | Column::PoolUrl | Column::Pool1Url
| Column::Pool1Worker | Column::Pool2Url | Column::Pool2Worker | Column::Pool3Url
| Column::Pool3Worker => (7, "Pools"),
@@ -1437,6 +1715,93 @@ mod tests {
assert!(broken < healthy, "broken {broken} should score below healthy {healthy}");
}
#[test]
fn faults_attribute_to_the_right_component() {
// Round 16 #3: a whole-miner stall zeroes every board's hashrate, but the
// per-board fault codes name only some boards. Only the named boards go
// red; the un-named board stays green, and the tooltips carry the specific
// message on the right board.
let fault = |c: FaultComponent, m: &str| Fault {
component: c,
message: m.to_string(),
code: 0,
is_error: true,
};
let r = MinerRow {
is_mining: false,
board_status: vec![BoardHealth::Fault, BoardHealth::Fault, BoardHealth::Fault],
expected_fans: Some(2),
fan_rpms: vec![6000.0, 6000.0],
power_w: 3000.0,
faults: vec![
fault(FaultComponent::Board(0), "Slot 0 error reading chip id."),
fault(FaultComponent::Board(1), "Slot 1 loss of balance error."),
],
..Default::default()
};
let boards = r.board_healths();
assert_eq!(boards[0], CompHealth::Down); // named -> red
assert_eq!(boards[1], CompHealth::Down); // named -> red
assert_eq!(boards[2], CompHealth::Ok); // NOT named -> green, despite Fault status
// Tooltip for board 1 carries its specific message (not board 3's).
let tips = r.health_tooltips(2, 3);
let board_tips = &tips[2 + 2..]; // after power, control, 2 fans
assert!(board_tips[0].contains("Slot 0 error reading chip id."));
assert!(!board_tips[2].contains("Slot"), "board 3 has no fault text");
// Round 16 #2: a power-supply fault greys every board (they can't be
// powered/tested), turns the bolt red, and the PSU message shows on the
// power tooltip.
let psu = MinerRow {
power_w: 40.0,
board_status: vec![BoardHealth::Fault, BoardHealth::Fault, BoardHealth::Fault],
expected_fans: Some(2),
fan_rpms: vec![6000.0, 6000.0],
faults: vec![fault(FaultComponent::Power, "Power current error.")],
..Default::default()
};
assert_eq!(psu.power_health(), CompHealth::Down);
assert!(psu.board_healths().iter().all(|h| *h == CompHealth::Unreachable));
let ptips = psu.health_tooltips(2, 3);
assert!(ptips[0].contains("Power current error."));
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
@@ -1734,13 +2099,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() };
@@ -2003,8 +2369,12 @@ mod tests {
resume: true,
power_limit: true,
tuning: true,
hashrate_target: true,
firmware_flash: true,
pools: true,
timezone: true,
change_password: true,
factory_reset: true,
};
let idle = MinerCaps { fault_light: true, restart: true, ..Default::default() };
// Two full miners keep every action.
+131
View File
@@ -0,0 +1,131 @@
//! Dropdown presets + user-saved values for the Configure-pools dialog (round 15
//! #1). Each pool field (address / account / worker / password) has a "+" menu
//! offering built-in presets (pool stratums, worker placeholders) plus values the
//! user has saved, and the user can add the current box value to the saved list.
//! Saved lists persist one-per-line under the config dir.
use std::path::PathBuf;
const CONFIG_DIR: &str = ".config/alkane-toolkit";
/// Which pool field a "+" menu belongs to.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PoolField {
Address,
Account,
Worker,
Password,
}
impl PoolField {
fn saved_file(self) -> &'static str {
match self {
PoolField::Address => "pool-addresses.txt",
PoolField::Account => "pool-accounts.txt",
PoolField::Worker => "pool-workers.txt",
PoolField::Password => "pool-passwords.txt",
}
}
/// Built-in presets offered before the user's saved values.
pub fn presets(self) -> Vec<&'static str> {
match self {
// Top Bitcoin pools by hashrate with their primary stratum endpoints
// (researched round 15; verify in-app before relying on any one).
PoolField::Address => POOL_STRATUMS.iter().map(|(_, u)| *u).collect(),
PoolField::Account => Vec::new(),
// Per-miner worker-name placeholders (see MinerRow::expand_worker_template).
PoolField::Worker => vec![
"{ip1}", "{ip2}", "{ip3}", "{ip4}", "{serial}", "{mac}", "{nameplate-hr}",
"{brand}", "{model}", "{submodel}", "{cpu}", "{cb}", "{firmware}", "{hostname}",
],
PoolField::Password => vec!["x"],
}
}
}
/// (pool name, primary stratum URL). Used for the address dropdown labels.
pub const POOL_STRATUMS: &[(&str, &str)] = &[
("Foundry USA", "stratum+tcp://btc.foundryusapool.com:3333"),
("AntPool", "stratum+tcp://ss.antpool.com:3333"),
("F2Pool", "stratum+tcp://btc.f2pool.com:1314"),
("ViaBTC", "stratum+tcp://btc.viabtc.io:3333"),
("SpiderPool", "stratum+tcp://btc-us.spiderpool.com:2309"),
("Binance Pool", "stratum+tcp://bs.poolbinance.com:3333"),
("Luxor", "stratum+tcp://btc.global.luxor.tech:700"),
("SBI Crypto", "stratum+tcp://us1.sbicrypto.com:3333"),
("Braiins Pool", "stratum+tcp://stratum.braiins.com:3333"),
("ULTIMUSPOOL", "stratum+tcp://bs.ultimuspool.com:8888"),
("SECPOOL", "stratum+tcp://btc.secpool.com:3333"),
];
fn config_path(file: &str) -> PathBuf {
let home = std::env::var("HOME").unwrap_or_else(|_| ".".into());
PathBuf::from(home).join(CONFIG_DIR).join(file)
}
/// The user's saved values for `field`, in save order (most recent last).
pub fn load_saved(field: PoolField) -> Vec<String> {
std::fs::read_to_string(config_path(field.saved_file()))
.ok()
.map(|s| s.lines().map(str::trim).filter(|l| !l.is_empty()).map(String::from).collect())
.unwrap_or_default()
}
/// Add `value` to `field`'s saved list (deduplicated, no-op if empty/already
/// present or already a preset). Returns true if it was newly added.
pub fn add_saved(field: PoolField, value: &str) -> bool {
let value = value.trim();
if value.is_empty() {
return false;
}
if field.presets().iter().any(|p| *p == value) {
return false;
}
let mut saved = load_saved(field);
if saved.iter().any(|s| s == value) {
return false;
}
saved.push(value.to_string());
let p = config_path(field.saved_file());
if let Some(dir) = p.parent() {
let _ = std::fs::create_dir_all(dir);
}
let _ = std::fs::write(p, saved.join("\n"));
true
}
/// Remove `value` from `field`'s saved list (round 16 #5). Returns true if it was
/// present and removed. Presets cannot be removed (they are not in the saved file).
pub fn remove_saved(field: PoolField, value: &str) -> bool {
let value = value.trim();
let mut saved = load_saved(field);
let before = saved.len();
saved.retain(|s| s != value);
if saved.len() == before {
return false;
}
let p = config_path(field.saved_file());
let _ = std::fs::write(p, saved.join("\n"));
true
}
/// The full dropdown list for a field: presets first, then the user's saved
/// values. For the address field each entry is labelled with the pool name.
pub fn dropdown_entries(field: PoolField) -> Vec<(String, String)> {
// (label, value)
let mut out: Vec<(String, String)> = Vec::new();
if field == PoolField::Address {
for (name, url) in POOL_STRATUMS {
out.push((format!("{name} -- {url}"), url.to_string()));
}
} else {
for p in field.presets() {
out.push((p.to_string(), p.to_string()));
}
}
for s in load_saved(field) {
out.push((s.clone(), s));
}
out
}
+2 -1
View File
@@ -15,7 +15,7 @@ pub const PRESETS_FILE: &str = "presets.json";
/// IP, model, health (component icons), hashrate, power, chip temp, firmware,
/// CPU, access. The Health column (round 13 #3) replaced the old errors, boards
/// (hashboard dots) and status columns.
const DEFAULT_PROFILE: [Column; 9] = [
const DEFAULT_PROFILE: [Column; 10] = [
Column::Ip,
Column::Model,
Column::Health,
@@ -25,6 +25,7 @@ const DEFAULT_PROFILE: [Column; 9] = [
Column::Firmware,
Column::Cpu,
Column::Locked,
Column::Light,
];
/// A serializable snapshot of a `ViewState` (Vec-based so JSON has no map keys
+264 -24
View File
@@ -34,6 +34,11 @@ pub const AUTO_FILE: &str = "auto-rescan-secs.txt";
pub const SCAN_TIMEOUT_FILE: &str = "scan-timeout-secs.txt";
/// Default per-miner scan timeout (matches asic-rs' identification timeout).
pub const DEFAULT_SCAN_TIMEOUT_SECS: u64 = 10;
/// Maximum in-flight address probes during a scan. asic-rs would otherwise use
/// 1000 for any range up to /22, saturating a real link and starving the
/// per-responder get_data (Braiins miners drop most values under that burst).
/// 128 was the highest cap that stayed fully reliable on the live fleet.
pub const SCAN_CONCURRENCY_LIMIT: usize = 128;
pub const DEFAULT_RANGE: &str = "10.255.1.0/24";
/// Default seconds between automatic rescans.
pub const DEFAULT_AUTO_SECS: u64 = 300;
@@ -377,7 +382,18 @@ pub fn start_scan(lines: Vec<String>, timeout_secs: u64) -> ScanHandle {
};
rt.block_on(async move {
let mut factory = crate::credentials::configured_factory()
.with_identification_timeout_secs(timeout_secs.max(1));
.with_identification_timeout_secs(timeout_secs.max(1))
// Cap identification concurrency. asic-rs defaults to 1000 for any
// range up to /22, so a /24 fires all 254 probes at once. Over a
// real link (VPN, or a subnet full of dead IPs whose TCP connects
// sit open for the whole identification timeout) that burst starves
// the per-responder get_data -- a Braiins miner fans out ~12
// authenticated REST calls and drops most of its values (watts=0,
// no best-share/temps), and some responders are missed entirely.
// 128 is the highest cap that stayed fully reliable on the live
// fleet (192 already dropped responders); a /24 still finishes in
// ~35s. Larger ranges just take proportionally longer, still correct.
.with_concurrent_limit(SCAN_CONCURRENCY_LIMIT);
for (ip, prefix) in &cidrs {
factory = match factory.with_subnet(&format!("{ip}/{prefix}")) {
Ok(f) => f,
@@ -391,7 +407,10 @@ pub fn start_scan(lines: Vec<String>, timeout_secs: u64) -> ScanHandle {
// get accurate progress plus the responders.
let mut stream = factory.scan_stream_with_ip();
let mut done = 0usize;
let step = (total / 100).max(1); // throttle progress messages
// Emit progress per address for a smoothly-climbing counter; only a
// very large scan (> 5000 addresses) is throttled, to bound channel
// traffic. The UI coalesces these to one gauge update per refresh.
let step = (total / 5000).max(1);
while let Some((ip, miner)) = stream.next().await {
if thread_cancel.load(Ordering::Relaxed) {
return; // Stop / re-scan requested
@@ -455,6 +474,71 @@ fn summarize_messages(messages: &[asic_rs::core::data::message::MinerMessage]) -
ranked.into_iter().map(|(_, s)| s).collect()
}
/// Convert a miner's structured messages into `Fault`s with their attributed
/// component (round 16 #1/#2/#3), so the Health column can colour and describe
/// each icon from the actual per-component faults. Info-severity messages are
/// dropped; Error and Warning are kept (only Error drives colour).
fn messages_to_faults(
messages: &[asic_rs::core::data::message::MinerMessage],
) -> Vec<crate::model::Fault> {
use asic_rs::core::data::message::{MessageSeverity, MinerComponent};
use crate::model::{Fault, FaultComponent};
messages
.iter()
.filter_map(|m| {
let is_error = match m.severity {
MessageSeverity::Error => true,
MessageSeverity::Warning => false,
MessageSeverity::Info => return None,
};
let text = m.message.trim();
if text.is_empty() {
return None;
}
let component = match &m.component {
Some(MinerComponent::PowerSupply { .. }) => FaultComponent::Power,
Some(MinerComponent::ControlBoard {}) => FaultComponent::Control,
Some(MinerComponent::Fan { idx }) => FaultComponent::Fan(*idx as usize),
Some(MinerComponent::HashBoard { idx, .. }) => FaultComponent::Board(*idx as usize),
None => FaultComponent::Other,
};
Some(Fault {
component,
message: text.to_string(),
code: m.code,
is_error,
})
})
.collect()
}
/// Infer whether an Antminer's hashboards carry a per-board PIC MCU from the
/// model string (round 14 #2). No firmware (stock cgminer, Vnish, LuxOS, Braiins)
/// exposes a PIC flag over the network; PIC-vs-noPIC is fixed by the hashboard
/// type, so a model map is the only network-only method:
/// - noPIC: an explicit "noPIC" model, the S19k Pro board, and the BM1368+
/// generation (S21 family, T21), where Bitmain dropped the per-board PIC.
/// - PIC: the rest of the S19 line (BM1362/BM1366, PIC16F1704/1542).
/// - unknown: everything else (older Antminers, non-Antminer makes).
/// The one genuinely ambiguous model is the plain "S19j Pro" (both PIC and noPIC
/// revisions exist); it is assumed PIC unless the model string says noPIC.
fn infer_pic(model: &str) -> Option<bool> {
let m = model.to_lowercase();
if m.contains("nopic") {
return Some(false);
}
if m.contains("s21") || m.contains("t21") {
return Some(false);
}
if m.contains("s19k") {
return Some(false);
}
if m.contains("s19") {
return Some(true);
}
None
}
async fn to_row(miner: &dyn Miner) -> MinerRow {
let data = miner.get_data().await;
let hashrate_ths = data
@@ -490,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()
@@ -577,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(),
@@ -585,13 +724,17 @@ 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(),
change_password: miner.supports_change_password(),
factory_reset: miner.supports_factory_reset(),
};
// PIC vs noPIC is not reported over the network by asic-rs; best-effort
// heuristic from the model string, else unknown (true detection needs an
// on-board SSH/I2C probe -- a separate feature).
let pic_present = if model.to_lowercase().contains("nopic") { Some(false) } else { None };
// PIC vs noPIC (round 14 #2 rework). No firmware exposes a PIC flag over the
// network -- it's a fixed hardware property of the hashboard type -- so infer
// it from the model, which every API reports. See `infer_pic`.
let pic_present = infer_pic(&model);
// Access: locked/view-only when the miner exposes no writable control at
// all, otherwise unlocked. Inferred from asic-rs capabilities (there is no
// direct lock-state field). This now covers WhatsMiner too: since round 12
@@ -626,6 +769,7 @@ async fn to_row(miner: &dyn Miner) -> MinerRow {
}
}
let errors = summarize_messages(&data.messages);
let faults = messages_to_faults(&data.messages);
MinerRow {
ip: data.ip.to_string(),
selected: false,
@@ -634,6 +778,7 @@ async fn to_row(miner: &dyn Miner) -> MinerRow {
pic_present,
write_locked,
errors,
faults,
model,
brand,
submodel,
@@ -663,8 +808,31 @@ 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 info (round 17 R5/G15; ePIC exposes it today). A reported-but-zero
// output current (ePIC leaves it 0) is treated as absent so the R2 tooltip
// shows just the voltage.
psu_out_voltage_v: data.psu.as_ref().and_then(|p| p.output_voltage).filter(|&v| v > 0.0),
psu_out_current_a: data.psu.as_ref().and_then(|p| p.output_current).filter(|&a| a > 0.0),
psu_version: data
.psu
.as_ref()
.map(|p| match (&p.model, &p.version) {
(Some(m), Some(v)) => format!("{v} ({m})"),
(None, Some(v)) => v.clone(),
(Some(m), None) => m.clone(),
(None, None) => String::new(),
})
.unwrap_or_default(),
psu_voltage_min_v: data.psu.as_ref().and_then(|p| p.voltage_min),
psu_voltage_max_v: data.psu.as_ref().and_then(|p| p.voltage_max),
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,
@@ -702,8 +870,12 @@ 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)
FactoryReset, // round 17 B / G12
}
impl ConfigAction {
@@ -715,8 +887,12 @@ 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(),
ConfigAction::FactoryReset => "factory reset".into(),
}
}
@@ -730,7 +906,11 @@ 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(),
ConfigAction::FactoryReset => "factory resetting…".into(),
}
}
}
@@ -761,7 +941,48 @@ 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};
match tz.parse::<Tz>() {
Ok(zone) => {
miner
.set_timezone_config(TimezoneConfig {
timezone: Some(zone),
available: Vec::new(),
})
.await
}
Err(_) => return Err(format!("invalid IANA timezone '{tz}'")),
}
}
ConfigAction::FactoryReset => miner.factory_reset().await,
// ChangePassword takes &mut self; handled in the run loop, not here.
ConfigAction::ChangePassword(_) => {
return Err("internal: change-password handled separately".to_string());
}
};
result.map_err(|e| e.to_string())
}
@@ -817,11 +1038,21 @@ pub fn start_config_action(ips: Vec<String>, action: ConfigAction) -> ActionHand
let (success, detail) = match ip_s.parse::<std::net::IpAddr>() {
Err(_) => (false, "bad IP".to_string()),
Ok(ip) => match factory.scan_miner(ip).await {
Ok(Some(miner)) => match apply_action(&*miner, &action).await {
Ok(true) => (true, "ok".to_string()),
Ok(false) => (false, "refused".to_string()),
Err(e) => (false, format!("{e}")),
},
Ok(Some(mut miner)) => {
// change_password takes &mut self, so it can't go through
// apply_action(&dyn Miner); run it on the owned miner here.
let outcome = match &action {
ConfigAction::ChangePassword(p) => {
miner.change_password(p).await.map_err(|e| e.to_string())
}
other => apply_action(&*miner, other).await,
};
match outcome {
Ok(true) => (true, "ok".to_string()),
Ok(false) => (false, "refused".to_string()),
Err(e) => (false, format!("{e}")),
}
}
Ok(None) => (false, "no miner at IP".to_string()),
Err(e) => (false, format!("{e}")),
},
@@ -842,16 +1073,20 @@ pub fn start_config_action(ips: Vec<String>, action: ConfigAction) -> ActionHand
ActionHandle { rx, cancel }
}
/// One miner's pool config to write (round 14 #7). The worker `username` has
/// already been expanded from the per-firmware worker template in the UI (which
/// holds the scanned MinerRow), so this carries a fully-resolved endpoint.
pub struct PoolTarget {
pub ip: String,
/// One resolved pool endpoint (worker already expanded from the template).
pub struct PoolEntry {
pub url: String,
pub username: String,
pub password: String,
}
/// One miner's pool config to write (round 14 #7, round 15 #1): up to three
/// pools (primary + backups), each already worker-expanded in the UI.
pub struct PoolTarget {
pub ip: String,
pub pools: Vec<PoolEntry>,
}
/// Apply a single "default" pool group to each target miner on a background
/// thread (round 14 #7). Reuses the ActionMsg/ActionHandle plumbing so the
/// existing drain_action + status handling covers it. Miners whose backend does
@@ -869,10 +1104,11 @@ pub fn start_pools_action(targets: Vec<PoolTarget>) -> ActionHandle {
let err_tx = tx.clone();
let res = std::thread::Builder::new().name("fake-pools".into()).spawn(move || {
for t in targets {
let first = t.pools.first().map(|p| p.username.clone()).unwrap_or_default();
let _ = tx.send(ActionMsg::Result {
ip: t.ip,
ok: true,
detail: format!("simulated ({})", t.username),
detail: format!("simulated ({} pool(s), {first})", t.pools.len()),
});
}
let _ = tx.send(ActionMsg::Done { ok: total, total });
@@ -910,11 +1146,15 @@ pub fn start_pools_action(targets: Vec<PoolTarget>) -> ActionHandle {
let group = PoolGroupConfig {
name: "default".to_string(),
quota: 1,
pools: vec![PoolConfig {
url: PoolURL::from(t.url.clone()),
username: t.username.clone(),
password: t.password.clone(),
}],
pools: t
.pools
.iter()
.map(|p| PoolConfig {
url: PoolURL::from(p.url.clone()),
username: p.username.clone(),
password: p.password.clone(),
})
.collect(),
};
match miner.set_pools_config(vec![group]).await {
Ok(true) => (true, "ok".to_string()),
File diff suppressed because it is too large Load Diff
+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,39 @@
Subject: [PATCH 0009] antminer: read Z15-style fans from higher fan slots
Round-15 #12. The v2020 backend's parse_fans only read fan1..hardware.fans, but
some models report their fans in higher slots and leave the low ones at 0 -- the
Z15 has fan_num=2 yet reports its two fans in fan3/fan4 with fan1/fan2 = 0, so no
fans were read. Scan a generous range of fan slots (1..16) and collect the
non-zero readings instead, renumbered 0.. in the order found. Verified against a
live Z15 (fan3=4920, fan4=5160). The antminer crate tests pass unchanged.
diff --git a/vendor/asic-rs-firmwares-antminer/src/backends/v2020/mod.rs b/vendor/asic-rs-firmwares-antminer/src/backends/v2020/mod.rs
index 0ce462c9..38935a59 100644
--- a/vendor/asic-rs-firmwares-antminer/src/backends/v2020/mod.rs
+++ b/vendor/asic-rs-firmwares-antminer/src/backends/v2020/mod.rs
@@ -833,15 +833,23 @@ impl GetFans for AntMinerV2020 {
let mut fans: Vec<FanData> = Vec::new();
if let Some(stats_data) = data.get(&DataField::Fans) {
- for i in 1..=self.device_info.hardware.fans.unwrap_or(4) {
+ // Some models report their fans in higher fan slots and leave the low
+ // ones at 0 -- the Z15, for example, has fan_num=2 but reports its two
+ // fans in fan3/fan4 with fan1/fan2 = 0. So scan a generous range of
+ // slots and collect the non-zero readings rather than only reading
+ // fan1..hardware.fans (which missed the Z15 entirely). The collected
+ // fans are renumbered 0.. in the order found (round 14 #12).
+ let mut pos: i16 = 0;
+ for i in 1..=16 {
if let Some(fan_speed) =
stats_data.get(format!("fan{}", i)).and_then(|v| v.as_f64())
&& fan_speed > 0.0
{
fans.push(FanData {
- position: (i - 1) as i16,
+ position: pos,
rpm: Some(AngularVelocity::from_rpm(fan_speed)),
});
+ pos += 1;
}
}
}
@@ -0,0 +1,183 @@
Subject: [PATCH 0010] antminer: fix v2020 locate-LED + reboot for the legacy web UI
Round-15 #7. On old (< 2023.07) Antminer firmware -- the LuCI-derived web UI, e.g.
the Z15/Z15J -- the "flash the locate light" action never worked: set_fault_light
returned Ok(false) on real hardware even though the request "succeeded".
Root cause (confirmed against a live Z15): that firmware's blink.cgi does NOT take
the JSON body {"blink":"true"} the backend sent (it silently ignores it, answering
200 with an empty text/html body, so the JSON parse fails and the error is swallowed
into Ok(false)). Its own blink.html instead POSTs a form field action=startBlink /
stopBlink, and reads state back with action=onPageLoaded -> {"isBlinking":bool}.
The action handler also frequently answers 401/500 even when the toggle succeeds, so
its HTTP status is not a reliable success signal.
Fix: add send_web_form_command (application/x-www-form-urlencoded POST; this reqwest
build has no .form()); blink() now fires action=startBlink/stopBlink, ignores the
unreliable status, and reads the real state back via onPageLoaded; set_fault_light
reports success only when the observed isBlinking matches the request. The LightFlashing
data read is routed to the same onPageLoaded path (get_blink_status.cgi is 404 on this
firmware) and remapped to {"blink":bool} so the shared /blink extractor still works.
Also fixes reboot() for the same generation: reboot.html does type:'GET', but the
backend POSTed to reboot.cgi. Switched to GET to match the vendor UI (the Restart
action was affected). Not live-fired, to avoid rebooting production miners.
Verified live: Z15 and Z15J now return set_fault_light(on/off) -> Ok(true) with the
light genuinely toggling; VNish (AMLogic/CVITek/Xilinx/BeagleBoneBlack) and WhatsMiner
(H6OS/H616) remain Ok(true) with no regression.
diff --git a/vendor/asic-rs-firmwares-antminer/src/backends/v2020/mod.rs b/vendor/asic-rs-firmwares-antminer/src/backends/v2020/mod.rs
index 38935a59..bd8662b1 100644
--- a/vendor/asic-rs-firmwares-antminer/src/backends/v2020/mod.rs
+++ b/vendor/asic-rs-firmwares-antminer/src/backends/v2020/mod.rs
@@ -1111,9 +1111,17 @@ impl SetFaultLight for AntMinerV2020 {
true
}
- #[allow(unused_variables)]
async fn set_fault_light(&self, fault: bool) -> anyhow::Result<bool> {
- Ok(self.web.blink(fault).await.is_ok())
+ // `blink()` fires the toggle then reads the state back as `{"isBlinking":
+ // bool}` (the legacy CGI's own HTTP status is unreliable). Report success
+ // only when the observed locate-LED state matches what was requested.
+ let observed = self
+ .web
+ .blink(fault)
+ .await?
+ .get("isBlinking")
+ .and_then(serde_json::Value::as_bool);
+ Ok(observed == Some(fault))
}
}
diff --git a/vendor/asic-rs-firmwares-antminer/src/backends/v2020/web.rs b/vendor/asic-rs-firmwares-antminer/src/backends/v2020/web.rs
index 7d6f237c..a50cc4ee 100644
--- a/vendor/asic-rs-firmwares-antminer/src/backends/v2020/web.rs
+++ b/vendor/asic-rs-firmwares-antminer/src/backends/v2020/web.rs
@@ -240,6 +240,45 @@ impl AntMinerWebAPI {
Ok(response)
}
+ /// POST a form-encoded (`application/x-www-form-urlencoded`) body to a CGI
+ /// endpoint and parse the JSON reply. The legacy LuCI web UI endpoints (e.g.
+ /// `blink.cgi`) expect `action=...` form fields, not a JSON body. An empty
+ /// reply parses to `{}`; a non-2xx status bails.
+ async fn send_web_form_command(&self, command: &str, form: &[(&str, &str)]) -> Result<Value> {
+ let url = format!("http://{}:{}/cgi-bin/{}.cgi", self.ip, self.port, command);
+ // Build an application/x-www-form-urlencoded body by hand (this reqwest
+ // build has no `.form()` helper). The only fields used are `action` with
+ // fixed ASCII values, so percent-encoding is unnecessary.
+ let body = form
+ .iter()
+ .map(|(k, v)| format!("{k}={v}"))
+ .collect::<Vec<_>>()
+ .join("&");
+ let response = self
+ .client()?
+ .post(&url)
+ .header(
+ reqwest::header::CONTENT_TYPE,
+ "application/x-www-form-urlencoded",
+ )
+ .body(body)
+ .timeout(self.timeout)
+ .send_digest_auth((self.auth.username(), self.auth.password()))
+ .await
+ .map_err(|e| anyhow!(e.to_string()))?;
+
+ let status = response.status();
+ if !status.is_success() {
+ bail!("HTTP request failed with status code {}", status);
+ }
+ let text = response.text().await.map_err(|e| anyhow!(e.to_string()))?;
+ if text.trim().is_empty() {
+ Ok(json!({}))
+ } else {
+ serde_json::from_str(&text).map_err(|e| anyhow!(e.to_string()))
+ }
+ }
+
pub async fn get_miner_conf(&self) -> Result<Value> {
self.send_web_command("get_miner_conf", false, None, Method::GET)
.await
@@ -257,17 +296,31 @@ impl AntMinerWebAPI {
}
pub async fn blink(&self, blink: bool) -> Result<Value> {
- let param = if blink {
- json!({"blink": "true"})
- } else {
- json!({"blink": "false"})
- };
- self.send_web_command("blink", false, Some(param), Method::POST)
+ // Legacy LuCI web UI: the locate LED is toggled by POSTing an `action`
+ // form field to blink.cgi (`startBlink`/`stopBlink`) -- NOT a JSON body
+ // like the newer (>= 2023.07) firmware expects. The handler performs the
+ // action but frequently answers 401/500 even on success, so its HTTP
+ // status is not a reliable signal: fire it, ignore the response, then read
+ // the real state back via `onPageLoaded`.
+ let action = if blink { "startBlink" } else { "stopBlink" };
+ let _ = self
+ .send_web_form_command("blink", &[("action", action)])
+ .await;
+ self.blink_status().await
+ }
+
+ /// Query the locate-LED state via the legacy blink.cgi `onPageLoaded` action,
+ /// which reliably answers `200 {"isBlinking": bool}`.
+ pub async fn blink_status(&self) -> Result<Value> {
+ self.send_web_form_command("blink", &[("action", "onPageLoaded")])
.await
}
pub async fn reboot(&self) -> Result<Value> {
- self.send_web_command("reboot", false, None, Method::POST)
+ // The legacy LuCI web UI reboots via GET /cgi-bin/reboot.cgi (its own
+ // reboot.html does `type: 'GET'`); a POST is not what this firmware
+ // generation expects.
+ self.send_web_command("reboot", false, None, Method::GET)
.await
}
@@ -350,8 +403,17 @@ impl AntMinerWebAPI {
}
pub async fn get_blink_status(&self) -> Result<Value> {
- self.send_web_command("get_blink_status", false, None, Method::GET)
- .await
+ // The old firmware has no `get_blink_status.cgi` (it answers 404); the
+ // locate state lives behind blink.cgi's `onPageLoaded` action as
+ // `{"isBlinking": bool}`. Remap it to `{"blink": bool}` so the shared
+ // LightFlashing extractor (key `/blink`) keeps working.
+ let flashing = self
+ .blink_status()
+ .await?
+ .get("isBlinking")
+ .and_then(Value::as_bool)
+ .unwrap_or(false);
+ Ok(json!({ "blink": flashing }))
}
pub async fn set_network_conf(
@@ -383,10 +445,16 @@ impl APIClient for AntMinerWebAPI {
MinerCommand::WebAPI {
command,
parameters,
- } => self
- .send_web_command(command, false, parameters.clone(), Method::GET)
- .await
- .map_err(|e| anyhow!(e.to_string())),
+ } => {
+ // The legacy blink status lives behind a POST form action, not a
+ // GET .cgi (which 404s), so route it through the dedicated helper.
+ if *command == "get_blink_status" {
+ return self.get_blink_status().await;
+ }
+ self.send_web_command(command, false, parameters.clone(), Method::GET)
+ .await
+ .map_err(|e| anyhow!(e.to_string()))
+ }
_ => Err(anyhow!("Unsupported command type for Web client")),
}
}
@@ -0,0 +1,162 @@
Subject: [PATCH 0011] luxminer: implement set_power_limit; epic: document PSU gating
Round-15 follow-up. The toolkit reported supports_power_limit=false for LuxOS and
ePIC (UMC OS) miners. Investigated against the live corpus (S19j Pro on both).
LuxOS: genuinely under-reported. LuxOS tunes by discrete named profiles, each
carrying a Watts rating (the `profiles` RPC returns Step + Watts), applied with
profileset -- pure frequency/voltage tuning, no special PSU needed. Implemented
SetPowerLimit by mapping the requested watts to the highest profile whose Watts
does not exceed it (or the lowest profile when the target is below all of them),
then profileset. supports_set_power_limit now returns true. The pure mapping is
factored into parse_profile_watts + select_profile_at_or_below with a unit test.
Verified live: set_power_limit(2500) on an S19j Pro selected step -4 (2385 W, the
highest <= 2500) and the miner's active profile became 445MHz/-4.
ePIC: NOT under-reporting after all -- left at false, with a comment explaining
why. ePIC PowerPlay's only true power-limit path is the PowerTune perpetual-tune
algorithm, which the firmware gates on the PSU: on a fixed-voltage Bitmain PSU
(the APW12 on an S19j Pro) perpetualtune/algo rejects it with "Power optimization
is not supported by this PSU". That support is a per-PSU runtime property this
synchronous, no-I/O capability check cannot observe, so advertising true would
over-report on most reflashed Antminers. (Hashrate tuning stays available via
set_tuning_config.)
diff --git a/vendor/asic-rs-firmwares-epic/src/backends/v1/mod.rs b/vendor/asic-rs-firmwares-epic/src/backends/v1/mod.rs
index a6f555f7..c21e05b1 100644
--- a/vendor/asic-rs-firmwares-epic/src/backends/v1/mod.rs
+++ b/vendor/asic-rs-firmwares-epic/src/backends/v1/mod.rs
@@ -1369,6 +1369,14 @@ impl SetFaultLight for PowerPlayV1 {
#[async_trait]
impl SetPowerLimit for PowerPlayV1 {
fn supports_set_power_limit(&self) -> bool {
+ // ePIC PowerPlay's only true power-limit mechanism is the PowerTune
+ // perpetual-tune algorithm, which the firmware gates on the PSU: on a
+ // fixed-voltage Bitmain PSU (e.g. the APW12 on an S19j Pro) the
+ // perpetualtune/algo endpoint rejects it with "Power optimization is not
+ // supported by this PSU". Since that support is a per-PSU runtime property
+ // that this synchronous, no-I/O capability check cannot observe, report
+ // false rather than over-advertise a control that fails on most reflashed
+ // Antminers. (Hashrate tuning is exposed separately via set_tuning_config.)
false
}
}
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 af89167c..aac39eb6 100644
--- a/vendor/asic-rs-firmwares-luxminer/src/backends/v1/mod.rs
+++ b/vendor/asic-rs-firmwares-luxminer/src/backends/v1/mod.rs
@@ -1052,10 +1052,66 @@ 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.
+fn parse_profile_watts(profiles: &Value) -> Vec<(String, f64)> {
+ profiles
+ .get("PROFILES")
+ .and_then(Value::as_array)
+ .map(|arr| {
+ arr.iter()
+ .filter_map(|p| {
+ let step = p.get("Step").and_then(Value::as_str)?.to_string();
+ let watts = p.get("Watts").and_then(Value::as_f64)?;
+ Some((step, watts))
+ })
+ .collect()
+ })
+ .unwrap_or_default()
+}
+
+/// Choose the LuxOS profile step 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.
+fn select_profile_at_or_below(steps: &[(String, f64)], target_w: f64) -> Option<String> {
+ if steps.is_empty() {
+ return None;
+ }
+ let mut sorted: Vec<&(String, f64)> = steps.iter().collect();
+ sorted.sort_by(|a, b| a.1.partial_cmp(&b.1).unwrap_or(std::cmp::Ordering::Equal));
+ sorted
+ .iter()
+ .rev()
+ .find(|(_, w)| *w <= target_w)
+ .or_else(|| sorted.first())
+ .map(|(s, _)| s.clone())
+}
+
#[async_trait]
impl SetPowerLimit for LuxMinerV1 {
fn supports_set_power_limit(&self) -> bool {
- false
+ true
+ }
+
+ async fn set_power_limit(&self, power: Power) -> anyhow::Result<bool> {
+ // LuxOS tunes by discrete named profiles (each carries a Watts rating),
+ // not a raw watts setpoint. Map the requested limit to the highest profile
+ // whose Watts does not exceed it (or the lowest profile when the target is
+ // below every profile), then apply it with profileset.
+ let profiles = self.rpc.profiles().await?;
+ let steps = parse_profile_watts(&profiles);
+ let Some(chosen) = select_profile_at_or_below(&steps, power.as_watts()) else {
+ anyhow::bail!("LuxOS reported no tunable profiles with a Step/Watts pair");
+ };
+ let resp = self.rpc.profileset(&chosen).await?;
+ // LuxOS answers with a STATUS array; "S"/"I" is success. A missing status
+ // after a non-error reply is treated as applied.
+ Ok(resp
+ .pointer("/STATUS/0/STATUS")
+ .and_then(Value::as_str)
+ .map(|s| matches!(s, "S" | "I"))
+ .unwrap_or(true))
}
}
@@ -1231,6 +1287,46 @@ mod tests {
POWER, PROFILES, STATS, SUMMARY, TEMPS, VERSION, VOLTAGEGET_0, VOLTAGEGET_1, VOLTAGEGET_2,
};
+ #[test]
+ fn power_limit_profile_selection() {
+ // LuxOS reports a ladder of profiles, each with a Step name and Watts.
+ let steps = vec![
+ ("-16".to_string(), 865.0),
+ ("-4".to_string(), 2385.0),
+ ("-2".to_string(), 2790.0),
+ ("0".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")
+ );
+ assert_eq!(
+ select_profile_at_or_below(&steps, 2790.0).as_deref(),
+ Some("-2")
+ );
+ // Above every profile -> the maximum profile (a limit can't exceed the
+ // hardware's top profile).
+ assert_eq!(
+ select_profile_at_or_below(&steps, 9000.0).as_deref(),
+ Some("0")
+ );
+ // Below every profile -> the minimum profile.
+ assert_eq!(
+ select_profile_at_or_below(&steps, 100.0).as_deref(),
+ Some("-16")
+ );
+ // No profiles -> nothing to choose.
+ assert_eq!(select_profile_at_or_below(&[], 2500.0), None);
+
+ // parse_profile_watts against the captured LuxOS `profiles` reply: it
+ // yields tunable profiles and selection finds a real step among them.
+ let profiles: Value = serde_json::from_str(PROFILES).unwrap();
+ let parsed = parse_profile_watts(&profiles);
+ assert!(!parsed.is_empty(), "fixture should carry tunable profiles");
+ assert!(select_profile_at_or_below(&parsed, 2500.0).is_some());
+ }
+
#[tokio::test]
async fn test_luxminer_v1() -> anyhow::Result<()> {
@@ -0,0 +1,229 @@
Subject: [PATCH 0012] whatsminer: robust per-component fault messages (V1 source + malformed-array repair)
Round-16 #1/#3. The toolkit could not attribute WhatsMiner faults to specific
hashboards. Two backend gaps, both found against live H6OS units:
1. V1 backend sourced messages from `summary` (/SUMMARY/0 "Error Code N"), which
is empty on these units -- the real faults are in get_error_code, like V2/V3.
Repointed DataField::Messages to get_error_code (/Msg/error_code) and rewrote
parse_messages to read the {code: timestamp} array (mirroring V2). asic-rs's
error_codes::error_info already maps each code to a MinerComponent (HashBoard
idx / PowerSupply / Fan / ControlBoard) and human text.
2. Some firmware emits an INVALID error_code array of bare "code":"timestamp"
pairs (`["540":"..","541":".."]`) instead of objects (`[{"540":".."}]`), which
fails the whole response parse so no messages surface at all. Added
error_codes::repair_error_code_array (targeted, no-op on valid input) and call
it in the V1 and V2 RPC read paths before parsing.
Verified live: 10.7.1.231 -> PowerSupply errors 205/206/217/251; 10.8.1.234 (the
malformed-array unit) -> 540 HashBoard 0, 541/561 HashBoard 1, 600 miner-level --
board 2 correctly clean. Unit test covers the repair; whatsminer tests pass.
diff --git a/vendor/asic-rs-firmwares-whatsminer/src/backends/v1/mod.rs b/vendor/asic-rs-firmwares-whatsminer/src/backends/v1/mod.rs
index c9c96713..67907049 100644
--- a/vendor/asic-rs-firmwares-whatsminer/src/backends/v1/mod.rs
+++ b/vendor/asic-rs-firmwares-whatsminer/src/backends/v1/mod.rs
@@ -117,6 +117,10 @@ impl GetDataLocations for WhatsMinerV1 {
command: "get_psu",
parameters: None,
};
+ const RPC_GET_ERROR_CODE: MinerCommand = MinerCommand::RPC {
+ command: "get_error_code",
+ parameters: None,
+ };
match data_field {
DataField::Mac => vec![(
@@ -254,10 +258,10 @@ impl GetDataLocations for WhatsMinerV1 {
},
)],
DataField::Messages => vec![(
- RPC_SUMMARY,
+ RPC_GET_ERROR_CODE,
DataExtractor {
func: get_by_pointer,
- key: Some("/SUMMARY/0"),
+ key: Some("/Msg/error_code"),
tag: None,
},
)],
@@ -471,32 +475,43 @@ impl GetTuningCapabilities for WhatsMinerV1 {}
impl GetLightFlashing for WhatsMinerV1 {}
impl GetMessages for WhatsMinerV1 {
fn parse_messages(&self, data: &HashMap<DataField, Value>) -> Vec<MinerMessage> {
+ // WhatsMiner V1 (H6OS) reports faults via get_error_code -> Msg.error_code,
+ // an array of {code: timestamp} objects (the same shape as V2/V3; the RPC
+ // layer repairs the occasional invalid bare-pair array first). The older
+ // summary "Error Code N" fields are frequently empty on these units.
let mut messages = Vec::new();
-
- let error_count = data
- .get(&DataField::Messages)
- .and_then(|val| {
- val.pointer("/Error Code Count")
- .and_then(|val| val.as_u64())
- })
- .unwrap_or(0u64) as usize;
- for idx in 0..error_count {
- let e_code = data
- .get(&DataField::Messages)
- .and_then(|val| val.pointer(&format!("/Error Code {}", idx)))
- .and_then(|val| val.as_u64());
- if let Some(code) = e_code {
- let info = crate::error_codes::error_info(code);
+ let Some(errors) = data.get(&DataField::Messages) else {
+ return messages;
+ };
+ for obj in errors.as_array().unwrap_or(&Vec::new()).iter() {
+ let Some(obj) = obj.as_object() else {
+ continue;
+ };
+ for (code, time) in obj.iter() {
+ let Some(time_str) = time.as_str() else {
+ continue;
+ };
+ let timestamp =
+ chrono::NaiveDateTime::parse_from_str(time_str, "%Y-%m-%d %H:%M:%S")
+ .map(|t| {
+ chrono::DateTime::<chrono::Utc>::from_naive_utc_and_offset(
+ t,
+ chrono::Utc,
+ )
+ })
+ .map(|dt| dt.timestamp() as u32)
+ .unwrap_or(0);
+ let parsed_code = code.parse::<u64>().unwrap_or(0);
+ let info = crate::error_codes::error_info(parsed_code);
messages.push(MinerMessage::with_component(
- 0,
- code,
+ timestamp,
+ parsed_code,
info.message,
MessageSeverity::Error,
info.component,
));
}
}
-
messages
}
}
diff --git a/vendor/asic-rs-firmwares-whatsminer/src/backends/v1/rpc.rs b/vendor/asic-rs-firmwares-whatsminer/src/backends/v1/rpc.rs
index 6e6c604e..384bbcd3 100644
--- a/vendor/asic-rs-firmwares-whatsminer/src/backends/v1/rpc.rs
+++ b/vendor/asic-rs-firmwares-whatsminer/src/backends/v1/rpc.rs
@@ -106,6 +106,9 @@ impl RPCAPIClient for WhatsMinerRPCAPI {
let response = response
.replace('\n', "") // Fix for WM V1, can have newlines in version which breaks the json parser
.replace(",}", "}"); // Fix for WM V1, can have trailing commas which breaks the json parser
+ // Fix for WM V1 get_error_code, which can emit an invalid array of bare
+ // "code":"timestamp" pairs (`["540":".."]`) that fails the whole parse.
+ let response = crate::error_codes::repair_error_code_array(&response);
self.parse_rpc_result(&response)
}
diff --git a/vendor/asic-rs-firmwares-whatsminer/src/backends/v2/rpc.rs b/vendor/asic-rs-firmwares-whatsminer/src/backends/v2/rpc.rs
index 9eec7a93..99da6a89 100644
--- a/vendor/asic-rs-firmwares-whatsminer/src/backends/v2/rpc.rs
+++ b/vendor/asic-rs-firmwares-whatsminer/src/backends/v2/rpc.rs
@@ -202,6 +202,9 @@ impl WhatsMinerRPCAPI {
read_stream_response(&mut stream, DEFAULT_RPC_TIMEOUT).await
};
let response = response?;
+ // Repair the occasional invalid get_error_code array (bare
+ // "code":"timestamp" pairs) before parsing; a no-op on valid responses.
+ let response = crate::error_codes::repair_error_code_array(&response);
self.parse_rpc_result(&response)
}
diff --git a/vendor/asic-rs-firmwares-whatsminer/src/error_codes.rs b/vendor/asic-rs-firmwares-whatsminer/src/error_codes.rs
index b442e9dc..5bd8b02a 100644
--- a/vendor/asic-rs-firmwares-whatsminer/src/error_codes.rs
+++ b/vendor/asic-rs-firmwares-whatsminer/src/error_codes.rs
@@ -2,6 +2,56 @@ use asic_rs_core::data::message::MinerComponent;
const UNKNOWN: &str = "Unknown error type.";
+/// Repair an invalid `error_code` array emitted by some WhatsMiner firmware.
+///
+/// Certain (older, H6OS) firmwares report the fault list as bare
+/// `"code":"timestamp"` pairs directly inside a JSON array
+/// (`"error_code":["540":"..","541":".."]`) rather than an array of single-key
+/// objects (`[{"540":".."},{"541":".."}]`). The bare form is not valid JSON and
+/// fails the whole response parse, so no messages are surfaced at all. Rewrite the
+/// bare pairs into objects; already-valid (object-wrapped or empty) arrays and
+/// responses without an `error_code` array are returned unchanged.
+pub fn repair_error_code_array(raw: &str) -> String {
+ const KEY: &str = "\"error_code\":[";
+ let Some(pos) = raw.find(KEY) else {
+ return raw.to_string();
+ };
+ let open = pos + KEY.len() - 1; // index of the '['
+ let bytes = raw.as_bytes();
+ let mut depth = 0i32;
+ let mut close = None;
+ for (i, &b) in bytes.iter().enumerate().skip(open) {
+ match b {
+ b'[' => depth += 1,
+ b']' => {
+ depth -= 1;
+ if depth == 0 {
+ close = Some(i);
+ break;
+ }
+ }
+ _ => {}
+ }
+ }
+ let Some(close) = close else {
+ return raw.to_string();
+ };
+ let inner = &raw[open + 1..close];
+ // Already valid (each entry object-wrapped) or empty -> leave untouched.
+ if inner.trim().is_empty() || inner.contains('{') {
+ return raw.to_string();
+ }
+ // Timestamps carry no commas, so a top-level comma split isolates each pair.
+ let wrapped = inner
+ .split(',')
+ .map(str::trim)
+ .filter(|s| !s.is_empty())
+ .map(|pair| format!("{{{pair}}}"))
+ .collect::<Vec<_>>()
+ .join(",");
+ format!("{}{}{}", &raw[..=open], wrapped, &raw[close..])
+}
+
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ErrorInfo {
pub message: String,
@@ -514,6 +564,27 @@ fn serial_info_error(sub: u64, val: u64) -> String {
mod tests {
use super::*;
+ #[test]
+ fn repair_malformed_error_code_array() {
+ // Bare "code":"timestamp" pairs inside the array (invalid JSON) -> objects.
+ let bad = r#"{"STATUS":"S","Msg":{"error_code":["540":"2026-09-22 07:08:14","561":"2026-09-21 22:26:36"]},"Description":""}"#;
+ let fixed = repair_error_code_array(bad);
+ let v: serde_json::Value = serde_json::from_str(&fixed).expect("repaired JSON must parse");
+ let arr = v["Msg"]["error_code"].as_array().unwrap();
+ assert_eq!(arr.len(), 2);
+ assert_eq!(arr[0]["540"], "2026-09-22 07:08:14");
+ assert_eq!(arr[1]["561"], "2026-09-21 22:26:36");
+
+ // Already-valid (object-wrapped) arrays are returned unchanged.
+ let good = r#"{"Msg":{"error_code":[{"205":"2026-09-20 03:35:44"}]}}"#;
+ assert_eq!(repair_error_code_array(good), good);
+ // Empty array and no-array responses are untouched.
+ let empty = r#"{"Msg":{"error_code":[]}}"#;
+ assert_eq!(repair_error_code_array(empty), empty);
+ let none = r#"{"STATUS":"S"}"#;
+ assert_eq!(repair_error_code_array(none), none);
+ }
+
#[test]
fn short_code_returns_unknown() {
// Act
@@ -0,0 +1,98 @@
Subject: [PATCH 0013] braiins+luxminer: implement best-share / session-best-share (round 16 G9)
The GetBestShare/GetSessionBestShare traits had empty impls on every backend, so
MinerData.best_share/session_best_share were always None and the toolkit's two
"Best share" / "Session best" columns were dead.
Braiins v26_04: map DataField::BestShare to the already-fetched miner/stats WebAPI
response (/miner_stats/best_share) and parse it. (BOS has no session-best field ->
session stays None.) Verified live read-only on 10.4.1.83: 130601978.
LuxMiner v1: map DataField::BestShare + SessionBestShare to the already-fetched
summary RPC (/SUMMARY/0/Best Share and /Best Session Share) and parse both.
Verified live read-only on 10.4.1.60 (638881749/638881749) and 10.4.1.67
(497802665/497802665).
No extra network calls (both reuse commands already collected by get_data).
diff --git a/vendor/asic-rs-firmwares-braiins/src/backends/v26_04/mod.rs b/vendor/asic-rs-firmwares-braiins/src/backends/v26_04/mod.rs
index fa947aee..e65fb201 100644
--- a/vendor/asic-rs-firmwares-braiins/src/backends/v26_04/mod.rs
+++ b/vendor/asic-rs-firmwares-braiins/src/backends/v26_04/mod.rs
@@ -286,6 +286,14 @@ impl GetDataLocations for BraiinsV2604 {
tag: None,
},
)],
+ DataField::BestShare => vec![(
+ WEB_MINER_STATS,
+ DataExtractor {
+ func: get_by_pointer,
+ key: Some("/miner_stats/best_share"),
+ tag: None,
+ },
+ )],
DataField::TuningTarget => vec![
(
WEB_MINER_CONFIGURATION,
@@ -548,7 +556,13 @@ impl GetUptime for BraiinsV2604 {
}
}
-impl GetBestShare for BraiinsV2604 {}
+impl GetBestShare for BraiinsV2604 {
+ fn parse_best_share(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
+ // Braiins OS reports the all-time best share at miner/stats -> miner_stats.best_share
+ // (round 16 / G9). Large diffs may exceed f64 exactness but are fine for display.
+ data.extract::<f64>(DataField::BestShare)
+ }
+}
impl GetSessionBestShare for BraiinsV2604 {}
impl GetOperatingState for BraiinsV2604 {
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 aac39eb6..2d1331bf 100644
--- a/vendor/asic-rs-firmwares-luxminer/src/backends/v1/mod.rs
+++ b/vendor/asic-rs-firmwares-luxminer/src/backends/v1/mod.rs
@@ -445,6 +445,22 @@ impl GetDataLocations for LuxMinerV1 {
tag: None,
},
)],
+ DataField::BestShare => vec![(
+ RPC_SUMMARY,
+ DataExtractor {
+ func: get_by_pointer,
+ key: Some("/SUMMARY/0/Best Share"),
+ tag: None,
+ },
+ )],
+ DataField::SessionBestShare => vec![(
+ RPC_SUMMARY,
+ DataExtractor {
+ func: get_by_pointer,
+ key: Some("/SUMMARY/0/Best Session Share"),
+ tag: None,
+ },
+ )],
DataField::Uptime => vec![(
RPC_STATS,
DataExtractor {
@@ -888,8 +904,18 @@ impl GetUptime for LuxMinerV1 {
}
}
-impl GetBestShare for LuxMinerV1 {}
-impl GetSessionBestShare for LuxMinerV1 {}
+impl GetBestShare for LuxMinerV1 {
+ fn parse_best_share(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
+ // LuxOS summary -> "Best Share" (all-time), round 16 / G9.
+ data.extract::<f64>(DataField::BestShare)
+ }
+}
+impl GetSessionBestShare for LuxMinerV1 {
+ fn parse_session_best_share(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
+ // LuxOS summary -> "Best Session Share" (since boot), round 16 / G9.
+ data.extract::<f64>(DataField::SessionBestShare)
+ }
+}
impl GetOperatingState for LuxMinerV1 {}
@@ -0,0 +1,88 @@
Subject: [PATCH 0014] luxminer: pool ops must be privileged (send session_id); add removepool
Round 16 / G13. The LuxOS pool write commands (addgroup, groupquota, removegroup,
addpool, switchpool, enablepool, disablepool) were sent with privileged=false, so
no session_id was included. That works on default units but FAILS with a
"Missing session_id" error on password-set LuxOS units (every other LuxOS write --
profileset/fanset/curtail/etc. -- is already privileged=true). Flip all seven pool
ops to privileged=true so send_command prepends the logon session token, and add
the missing rpc.removepool (privileged) for future incremental pool editing.
Verified no regression on a default corpus unit (10.4.1.60): set_pools_config still
applies correctly via the new privileged path. The password-set failure path is a
code-correct fix but needs a password-set LuxOS unit to reproduce/verify live.
diff --git a/vendor/asic-rs-firmwares-luxminer/src/backends/v1/rpc.rs b/vendor/asic-rs-firmwares-luxminer/src/backends/v1/rpc.rs
index 1afc686c..39d7ef63 100644
--- a/vendor/asic-rs-firmwares-luxminer/src/backends/v1/rpc.rs
+++ b/vendor/asic-rs-firmwares-luxminer/src/backends/v1/rpc.rs
@@ -239,7 +239,7 @@ impl LUXMinerRPCAPI {
pub async fn addgroup(&self, name: &str, quota: u32) -> anyhow::Result<Value> {
self.send_command(
"addgroup",
- false,
+ true,
Some(Value::String(format!("{name},{quota}"))),
)
.await
@@ -248,7 +248,7 @@ impl LUXMinerRPCAPI {
pub async fn groupquota(&self, group_id: u32, quota: u32) -> anyhow::Result<Value> {
self.send_command(
"groupquota",
- false,
+ true,
Some(Value::String(format!("{group_id},{quota}"))),
)
.await
@@ -257,7 +257,7 @@ impl LUXMinerRPCAPI {
pub async fn removegroup(&self, group_id: u32) -> anyhow::Result<Value> {
self.send_command(
"removegroup",
- false,
+ true,
Some(Value::String(group_id.to_string())),
)
.await
@@ -275,14 +275,14 @@ impl LUXMinerRPCAPI {
params.push(group_id);
}
- self.send_command("addpool", false, Some(Value::String(params.join(","))))
+ self.send_command("addpool", true, Some(Value::String(params.join(","))))
.await
}
pub async fn switchpool(&self, pool_id: i32) -> anyhow::Result<Value> {
self.send_command(
"switchpool",
- false,
+ true,
Some(Value::String(pool_id.to_string())),
)
.await
@@ -291,7 +291,7 @@ impl LUXMinerRPCAPI {
pub async fn enablepool(&self, pool_id: i32) -> anyhow::Result<Value> {
self.send_command(
"enablepool",
- false,
+ true,
Some(Value::String(pool_id.to_string())),
)
.await
@@ -300,7 +300,16 @@ impl LUXMinerRPCAPI {
pub async fn disablepool(&self, pool_id: i32) -> anyhow::Result<Value> {
self.send_command(
"disablepool",
- false,
+ true,
+ Some(Value::String(pool_id.to_string())),
+ )
+ .await
+ }
+
+ pub async fn removepool(&self, pool_id: i32) -> anyhow::Result<Value> {
+ self.send_command(
+ "removepool",
+ true,
Some(Value::String(pool_id.to_string())),
)
.await
@@ -0,0 +1,37 @@
Subject: [PATCH 0015] braiins v26_04: treat an empty 2xx body as success (not a parse error)
Found live verifying change-password (round 17 B / G11). The BOS REST setters like
PUT auth/password answer 2xx with an empty body; send_command tried
response.json() on it, which fails, so change_password (which does `.is_ok()`)
reported Ok(false) even though the password DID change. Read the body as text
first: an empty body on a success status is Null (success), a non-empty body must
still parse. Verified live on 10.4.1.27: change root->bftest2 now returns Ok(true),
the new password authenticates, and restore -> root returns Ok(true).
diff --git a/vendor/asic-rs-firmwares-braiins/src/backends/v26_04/web.rs b/vendor/asic-rs-firmwares-braiins/src/backends/v26_04/web.rs
index 624eca4c..3e06b682 100644
--- a/vendor/asic-rs-firmwares-braiins/src/backends/v26_04/web.rs
+++ b/vendor/asic-rs-firmwares-braiins/src/backends/v26_04/web.rs
@@ -57,11 +57,20 @@ impl WebAPIClient for BraiinsWebAPI {
let status = response.status();
if status.is_success() {
- let json_data = response
- .json()
+ // Some setters (e.g. PUT auth/password) answer 2xx with an empty or
+ // non-JSON body. An empty body is success, not a parse error -- treat
+ // it as Null so callers using `.is_ok()` don't read a real success as
+ // failure. A non-empty body must still parse.
+ let body = response
+ .text()
.await
.map_err(|e| BraiinsError::ParseError(e.to_string()))?;
- Ok(json_data)
+ if body.trim().is_empty() {
+ Ok(Value::Null)
+ } else {
+ Ok(serde_json::from_str(&body)
+ .map_err(|e| BraiinsError::ParseError(e.to_string()))?)
+ }
} else {
// The API reports why it rejected a request in the body.
let status = status.as_u16();
@@ -0,0 +1,62 @@
Subject: [PATCH 0016] braiins v26_04: single-flight auth + defensive get_data timeout
Round 17 R4 support. Braiins get_data fans out to ~12 authenticated REST calls
concurrently. Two hardening changes so a Braiins miner survives a busy scan:
- ensure_authenticated single-flights the login. Previously all ~12 concurrent
commands could see no token and each POST /auth/login -- a thundering herd that
doubled the connection load. Now the write lock is held across the login with a
double-check, so exactly one call authenticates and the rest reuse the token.
- The per-call timeout goes 5s -> 15s as defensive headroom (a healthy miner still
answers well under a second) so a call queued behind a scan burst completes
instead of dropping miner/stats.
Neither is the primary fix for the fleet-scan value dropout -- that is the
app-side scan concurrency cap (scan::SCAN_CONCURRENCY_LIMIT = 128), which keeps
the identification burst from starving these calls. These are the belt to that
suspenders. Verified live: a 10.4.1.0/24 scan now populates both Braiins corpus
miners (.27, .83) fully (watts, best-share, fw/control-board) and misses no
responders.
diff --git a/vendor/asic-rs-firmwares-braiins/src/backends/v26_04/web.rs b/vendor/asic-rs-firmwares-braiins/src/backends/v26_04/web.rs
index 3e06b682..ae433d98 100644
--- a/vendor/asic-rs-firmwares-braiins/src/backends/v26_04/web.rs
+++ b/vendor/asic-rs-firmwares-braiins/src/backends/v26_04/web.rs
@@ -87,7 +87,13 @@ impl BraiinsWebAPI {
client: OnceCell::new(),
ip,
port: 80,
- timeout: Duration::from_secs(5),
+ // Braiins get_data fans out to ~12 authenticated REST calls that run
+ // concurrently. A healthy miner answers well under a second; the extra
+ // headroom over the old 5 s is defensive so a call that queues behind a
+ // scan burst still completes instead of dropping miner/stats
+ // (hashrate/watts/best-share). The real fix for the fleet-scan dropout
+ // is the app-side scan concurrency cap (see scan::SCAN_CONCURRENCY_LIMIT).
+ timeout: Duration::from_secs(15),
bearer_token: RwLock::new(None),
auth,
}
@@ -122,13 +128,22 @@ impl BraiinsWebAPI {
return Ok(());
}
+ // Single-flight the login: get_data fires ~12 commands concurrently, and
+ // without this they would ALL see no token and each POST /auth/login (a
+ // thundering herd that doubles the connection load and races under a
+ // high-concurrency fleet scan, dropping most values). Hold the write lock
+ // across the login so exactly one call authenticates and the rest reuse it.
+ let mut guard = self.bearer_token.write().await;
+ if guard.is_some() {
+ return Ok(());
+ }
let token = match &self.auth {
MinerAuth::TokenAuth(token) => token.expose_secret().to_string(),
MinerAuth::UserAndPass(creds) => {
self.authenticate(creds.password.expose_secret()).await?
}
};
- *self.bearer_token.write().await = Some(token);
+ *guard = Some(token);
Ok(())
}
@@ -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);
+202
View File
@@ -0,0 +1,202 @@
Subject: [PATCH 0018] core + epic: PSU info scan (identity, rated envelope, output V/A)
Round 17 R5/G15. asic-rs had no PSU telemetry. Adds a PsuInfo type (model,
version, rated voltage min/max, live output voltage/current) as an optional
MinerData.psu field, a DataField::Psu, and a default parse_psu(&data) -> None
that backends override.
ePIC (PowerPlay v1) populates it: DataField::Psu merges the summary "Power Supply
Stats" (tag "stats") and the capabilities "Psu Info" (tag "info"); parse_psu reads
model/FW + Min/Max Vout (millivolts -> volts) + live Output Voltage/Current.
Verified live on ePIC S19j Pro (10.4.1.6/.10): model 117, fw 22, Vmin 11.877 V,
Vmax 15.182 V, output ~13.2-13.4 V. Feeds the new PSU version/Vmin/Vmax columns
and the R2 power tooltip (output V/A). Other backends leave psu None until they
add their own parse_psu.
diff --git a/vendor/asic-rs-core/src/data/collector.rs b/vendor/asic-rs-core/src/data/collector.rs
index 93a0111a..d1456548 100644
--- a/vendor/asic-rs-core/src/data/collector.rs
+++ b/vendor/asic-rs-core/src/data/collector.rs
@@ -74,6 +74,9 @@ pub enum DataField {
/// Current power consumption in watts.
#[cfg_attr(feature = "python", pydantic(value = "Wattage"))]
Wattage,
+ /// Power-supply info (identity, rated voltage envelope, live output V/A).
+ #[cfg_attr(feature = "python", pydantic(value = "Psu"))]
+ Psu,
/// manual tuning percent of full power (100 = unthrottled).
#[cfg_attr(feature = "python", pydantic(value = "TuningPercent"))]
TuningPercent,
diff --git a/vendor/asic-rs-core/src/data/miner.rs b/vendor/asic-rs-core/src/data/miner.rs
index be6f4c8f..b2b8a578 100644
--- a/vendor/asic-rs-core/src/data/miner.rs
+++ b/vendor/asic-rs-core/src/data/miner.rs
@@ -16,6 +16,7 @@ use super::{
message::MinerMessage,
operating_state::OperatingState,
pool::PoolGroupData,
+ psu::PsuInfo,
};
use crate::data::{
deserialize::deserialize_macaddr,
@@ -192,6 +193,9 @@ pub struct MinerData {
#[serde(serialize_with = "serialize_power")]
#[ts(type = "number | null")]
pub wattage: Option<Power>,
+ /// Power-supply info (identity, rated voltage envelope, live output V/A),
+ /// when the firmware reports it.
+ pub psu: Option<PsuInfo>,
/// The current manual tuning percent of full power (100 = unthrottled), where supported
pub tuning_percent: Option<u8>,
/// The current tuning target of the miner, such as power target or hashrate target
diff --git a/vendor/asic-rs-core/src/data/mod.rs b/vendor/asic-rs-core/src/data/mod.rs
index c69c43eb..3b7f98c0 100644
--- a/vendor/asic-rs-core/src/data/mod.rs
+++ b/vendor/asic-rs-core/src/data/mod.rs
@@ -15,5 +15,6 @@ pub mod message;
pub mod miner;
pub mod operating_state;
pub mod pool;
+pub mod psu;
pub(crate) mod serialize;
pub mod share;
diff --git a/vendor/asic-rs-core/src/data/psu.rs b/vendor/asic-rs-core/src/data/psu.rs
new file mode 100644
index 00000000..810ba47c
--- /dev/null
+++ b/vendor/asic-rs-core/src/data/psu.rs
@@ -0,0 +1,30 @@
+//! Power-supply (PSU) information reported by a miner's firmware.
+//!
+//! A backend fills in only what its firmware actually exposes; every field is
+//! optional. Some firmware reports the PSU's identity and rated voltage envelope
+//! (min/max output voltage), others also report the live output voltage and
+//! current. Voltages are in volts and currents in amps.
+
+#[cfg(feature = "python")]
+use pyo3::pyclass;
+use serde::{Deserialize, Serialize};
+use ts_rs::TS;
+
+/// Power-supply identity and voltage telemetry for one miner.
+#[cfg_attr(feature = "python", pyclass(from_py_object, module = "asic_rs"))]
+#[cfg_attr(feature = "python", asic_rs_pydantic::py_pydantic_model(getters))]
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default, TS)]
+pub struct PsuInfo {
+ /// PSU model / type identifier, when reported.
+ pub model: Option<String>,
+ /// PSU firmware/hardware version, when reported.
+ pub version: Option<String>,
+ /// Minimum rated output voltage in volts, when reported.
+ pub voltage_min: Option<f64>,
+ /// Maximum rated output voltage in volts, when reported.
+ pub voltage_max: Option<f64>,
+ /// Live output voltage in volts, when reported.
+ pub output_voltage: Option<f64>,
+ /// Live output current in amps, when reported.
+ pub output_current: Option<f64>,
+}
diff --git a/vendor/asic-rs-core/src/traits/miner.rs b/vendor/asic-rs-core/src/traits/miner.rs
index d08b1b5a..db1ba653 100644
--- a/vendor/asic-rs-core/src/traits/miner.rs
+++ b/vendor/asic-rs-core/src/traits/miner.rs
@@ -33,6 +33,7 @@ use crate::{
miner::{MinerData, TuningTarget},
operating_state::OperatingState,
pool::PoolGroupData,
+ psu::PsuInfo,
},
traits::firmware::MinerFirmware,
traits::model::MinerModel,
@@ -272,6 +273,7 @@ impl<
let hashrate = self.parse_hashrate(&data);
let expected_hashrate = self.parse_expected_hashrate(&data);
let wattage = self.parse_wattage(&data);
+ let psu = self.parse_psu(&data);
let tuning_percent = self.parse_tuning_percent(&data);
let tuning_target = self.parse_tuning_target(&data);
let scaled_tuning_target = self.parse_scaled_tuning_target(&data);
@@ -367,6 +369,7 @@ impl<
// Power information
wattage,
+ psu,
tuning_percent,
tuning_target,
scaled_tuning_target,
@@ -720,6 +723,10 @@ pub trait GetWattage: CollectData {
fn parse_wattage(&self, data: &HashMap<DataField, Value>) -> Option<Power> {
None
}
+ #[allow(unused_variables)]
+ fn parse_psu(&self, data: &HashMap<DataField, Value>) -> Option<PsuInfo> {
+ None
+ }
}
// Tuning Percent
diff --git a/vendor/asic-rs-firmwares-epic/src/backends/v1/mod.rs b/vendor/asic-rs-firmwares-epic/src/backends/v1/mod.rs
index c21e05b1..3365824d 100644
--- a/vendor/asic-rs-firmwares-epic/src/backends/v1/mod.rs
+++ b/vendor/asic-rs-firmwares-epic/src/backends/v1/mod.rs
@@ -24,6 +24,7 @@ use asic_rs_core::{
miner::TuningTarget,
operating_state::OperatingState,
pool::{PoolData, PoolGroupData, PoolURL},
+ psu::PsuInfo,
},
traits::{miner::*, model::MinerModel},
util::unix_timestamp_secs,
@@ -436,6 +437,26 @@ impl GetDataLocations for PowerPlayV1 {
tag: None,
},
)],
+ // PSU: live stats from summary + rated envelope/identity from
+ // capabilities, tagged so parse_psu can read both (round 17 R5/G15).
+ DataField::Psu => vec![
+ (
+ WEB_SUMMARY,
+ DataExtractor {
+ func: get_by_pointer,
+ key: Some("/Power Supply Stats"),
+ tag: Some("stats"),
+ },
+ ),
+ (
+ WEB_CAPABILITIES,
+ DataExtractor {
+ func: get_by_pointer,
+ key: Some("/Psu Info"),
+ tag: Some("info"),
+ },
+ ),
+ ],
DataField::TuningTarget => vec![(
WEB_SUMMARY,
DataExtractor {
@@ -1095,6 +1116,25 @@ impl GetWattage for PowerPlayV1 {
fn parse_wattage(&self, data: &HashMap<DataField, Value>) -> Option<Power> {
data.extract_map::<f64, _>(DataField::Wattage, Power::from_watts)
}
+
+ fn parse_psu(&self, data: &HashMap<DataField, Value>) -> Option<PsuInfo> {
+ // DataField::Psu is the merged {stats: Power Supply Stats, info: Psu Info}
+ // (see get_locations). capabilities Vout + summary Target Voltage are in
+ // millivolts; summary Output Voltage/Current are already volts/amps.
+ let d = data.get(&DataField::Psu)?;
+ let stats = d.pointer("/stats");
+ let info = d.pointer("/info");
+ let f = |v: Option<&Value>, key: &str| v.and_then(|o| o.pointer(key)).and_then(tuning_value_as_f64);
+ let psu = PsuInfo {
+ model: f(info, "/PSU Type").map(|n| format!("{n:.0}")),
+ version: f(info, "/FW").map(|n| format!("{n:.0}")),
+ voltage_min: f(info, "/Min Vout").map(|mv| mv / 1000.0),
+ voltage_max: f(info, "/Max Vout").map(|mv| mv / 1000.0),
+ output_voltage: f(stats, "/Output Voltage"),
+ output_current: f(stats, "/Output Current"),
+ };
+ (psu != PsuInfo::default()).then_some(psu)
+ }
}
fn tuning_value_as_f64(value: &Value) -> Option<f64> {
@@ -0,0 +1,128 @@
Subject: [PATCH 0019] antminer v2023_07: best-share + Bixbit "Power Estimated" wattage
Round 17 R7 (found by flashing Bixbit onto fleet units). The v2023_07 stock
backend scanned hashrate/boards/temps/fans fine but reported no best-share for the
WHOLE Antminer fleet (DataField::BestShare had no get_locations entry, so it was
never fetched) and no wattage for Bixbit-based firmware (it reads the cgminer
stats power, which Bixbit leaves 0, putting the real figure in the summary as
"Power Estimated").
- Map DataField::BestShare / SessionBestShare to the cgminer summary
("Best Share" / "Best Session Share") and implement GetBestShare /
GetSessionBestShare (guard 0 -> None).
- Add the summary to DataField::Wattage under a "summary" tag and fall back to
"Power Estimated" in parse_wattage when the stats power is 0/absent. Stock
behaviour is preserved (a non-zero stats power still wins; a present-but-zero
power still reads 0 W).
Verified live: Bixbit S19j Pro (10.4.1.70) now reads wattage 2615 W + best-share
178930671 (was both blank); stock S21 Pro (10.4.1.90) now reads best-share
299464394 (was blank). 36 antminer backend tests pass; no wattage regression.
diff --git a/vendor/asic-rs-firmwares-antminer/src/backends/v2023_07/mod.rs b/vendor/asic-rs-firmwares-antminer/src/backends/v2023_07/mod.rs
index 6d6dc593..1ac2bad1 100644
--- a/vendor/asic-rs-firmwares-antminer/src/backends/v2023_07/mod.rs
+++ b/vendor/asic-rs-firmwares-antminer/src/backends/v2023_07/mod.rs
@@ -521,8 +521,40 @@ impl GetDataLocations for AntMinerV202307 {
tag: None,
},
),
+ // Bixbit-based firmware reports Power=0 in stats but the real
+ // figure as "Power Estimated" in the cgminer summary; carry it
+ // under a "summary" tag so parse_wattage can fall back to it
+ // without colliding with the stats keys (round 17 R7).
+ (
+ RPC_SUMMARY,
+ DataExtractor {
+ func: get_by_pointer,
+ key: Some("/SUMMARY/0"),
+ tag: Some("summary"),
+ },
+ ),
]
}
+ // Best share (all-time / session) from the cgminer summary. Antminer
+ // stock, Bixbit, and other cgminer-based firmware all report it here;
+ // it was previously unmapped, so best-share was blank fleet-wide
+ // (round 17 R7).
+ DataField::BestShare => vec![(
+ RPC_SUMMARY,
+ DataExtractor {
+ func: get_by_pointer,
+ key: Some("/SUMMARY/0/Best Share"),
+ tag: None,
+ },
+ )],
+ DataField::SessionBestShare => vec![(
+ RPC_SUMMARY,
+ DataExtractor {
+ func: get_by_pointer,
+ key: Some("/SUMMARY/0/Best Session Share"),
+ tag: None,
+ },
+ )],
DataField::SerialNumber => vec![
(
WEB_SYSTEM_INFO,
@@ -778,8 +810,6 @@ impl GetUptime for AntMinerV202307 {
}
}
-impl GetBestShare for AntMinerV202307 {}
-impl GetSessionBestShare for AntMinerV202307 {}
impl GetOperatingState for AntMinerV202307 {}
@@ -888,14 +918,30 @@ impl GetWattage for AntMinerV202307 {
}
}
- if let Some(power) = stats_data
+ let primary = stats_data
.get("power")
.or_else(|| stats_data.get("Power"))
// Same firmware version spells this differently per model: the
// L9 reports `power`, the L11 `watt`.
.or_else(|| stats_data.get("watt"))
+ .and_then(|v| v.as_f64());
+ if let Some(power) = primary
+ && power > 0.0
+ {
+ return Some(Power::from_watts(power));
+ }
+ // Bixbit-based firmware leaves the stats power at 0 and reports the
+ // real draw as "Power Estimated" in the summary (round 17 R7).
+ if let Some(est) = stats_data
+ .pointer("/summary/Power Estimated")
.and_then(|v| v.as_f64())
+ && est > 0.0
{
+ return Some(Power::from_watts(est));
+ }
+ // Preserve the prior behaviour: a present-but-zero stats power still
+ // reads as 0 W rather than blank.
+ if let Some(power) = primary {
return Some(Power::from_watts(power));
}
}
@@ -903,6 +949,21 @@ impl GetWattage for AntMinerV202307 {
}
}
+impl GetBestShare for AntMinerV202307 {
+ fn parse_best_share(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
+ // cgminer summary "Best Share" (all-time). Guard against a firmware that
+ // reports 0 when it has never found a share (round 17 R7).
+ data.extract::<f64>(DataField::BestShare).filter(|&v| v > 0.0)
+ }
+}
+
+impl GetSessionBestShare for AntMinerV202307 {
+ fn parse_session_best_share(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
+ data.extract::<f64>(DataField::SessionBestShare)
+ .filter(|&v| v > 0.0)
+ }
+}
+
impl GetTuningTarget for AntMinerV202307 {
fn parse_tuning_target(&self, data: &HashMap<DataField, Value>) -> Option<TuningTarget> {
data.get(&DataField::TuningTarget)
+65 -1
View File
@@ -10,7 +10,7 @@
+pub use widgets::*;
--- a/src/widgets.rs
+++ b/src/widgets.rs
@@ -0,0 +1,847 @@
@@ -0,0 +1,911 @@
+// widgets.rs — alkane-toolkit extension: Rust bindings for the widget bridge
+// in cpp_src/widgets_bridge.cpp. Handles are opaque pointers owned by the
+// wxWidgets object tree (parents own children; nothing to free in Rust).
@@ -40,6 +40,7 @@
+ pub fn wxbr_bind_size(win: *mut c_void);
+ pub fn wxbr_fit(win: *mut c_void);
+ pub fn wxbr_set_min_size(win: *mut c_void, w: c_int, h: c_int);
+ pub fn wxbr_set_tooltip(win: *mut c_void, text: *const c_char);
+ pub fn wxbr_static_text(parent: *mut c_void, label: *const c_char) -> *mut c_void;
+ pub fn wxbr_set_label(win: *mut c_void, label: *const c_char);
+ pub fn wxbr_get_label(win: *mut c_void, buf: *mut c_char, cap: c_int) -> c_int;
@@ -50,6 +51,7 @@
+ pub fn wxbr_text_ctrl(parent: *mut c_void, multiline: c_int) -> *mut c_void;
+ pub fn wxbr_text_ctrl_get(win: *mut c_void, buf: *mut c_char, cap: c_int) -> c_int;
+ pub fn wxbr_text_ctrl_set(win: *mut c_void, value: *const c_char);
+ pub fn wxbr_text_ctrl_write(win: *mut c_void, value: *const c_char);
+ pub fn wxbr_check_box(parent: *mut c_void, label: *const c_char) -> *mut c_void;
+ pub fn wxbr_check_box_get(win: *mut c_void) -> c_int;
+ pub fn wxbr_check_box_set(win: *mut c_void, v: c_int);
@@ -64,6 +66,7 @@
+ pub fn wxbr_dialog_show_modal(win: *mut c_void) -> c_int;
+ pub fn wxbr_dialog_close(win: *mut c_void, code: c_int);
+ pub fn wxbr_file_dialog(parent: *mut c_void, title: *const c_char, buf: *mut c_char, cap: c_int) -> c_int;
+ pub fn wxbr_save_file_dialog(parent: *mut c_void, title: *const c_char, default_name: *const c_char, wildcard: *const c_char, buf: *mut c_char, cap: c_int) -> c_int;
+ pub fn wxbr_dvlc(parent: *mut c_void) -> *mut c_void;
+ pub fn wxbr_dvlc_append_text_col(win: *mut c_void, title: *const c_char, width: c_int, reorderable: c_int);
+ pub fn wxbr_dvlc_append_colored_col(win: *mut c_void, title: *const c_char, width: c_int, reorderable: c_int) -> *mut c_void;
@@ -74,6 +77,7 @@
+ pub fn wxbr_dvlc_row_count(win: *mut c_void) -> c_int;
+ pub fn wxbr_dvlc_set_cell(win: *mut c_void, row: usize, col: usize, value: *const c_char);
+ pub fn wxbr_dvlc_set_cell_tooltip(win: *mut c_void, row: usize, col: usize, text: *const c_char);
+ pub fn wxbr_dvlc_set_icon_tooltips(win: *mut c_void, row: usize, col: usize, joined: *const c_char);
+ pub fn wxbr_dvlc_get_cell(win: *mut c_void, row: usize, col: usize, buf: *mut c_char, cap: c_int) -> c_int;
+ pub fn wxbr_dvlc_col_count(win: *mut c_void) -> c_int;
+ pub fn wxbr_dvlc_autosize_col(win: *mut c_void, pos: c_int);
@@ -98,6 +102,7 @@
+ pub fn wxbr_menu_new() -> *mut c_void;
+ pub fn wxbr_menu_append(menu: *mut c_void, id: c_int, label: *const c_char);
+ pub fn wxbr_menu_append_separator(menu: *mut c_void);
+ pub fn wxbr_menu_append_submenu(menu: *mut c_void, label: *const c_char, submenu: *mut c_void);
+ pub fn wxbr_popup_menu(win: *mut c_void, menu: *mut c_void);
+ pub fn wxbr_timer(id: c_int, ms: c_int) -> *mut c_void;
+ pub fn wxbr_gauge(parent: *mut c_void, range: c_int) -> *mut c_void;
@@ -391,6 +396,12 @@
+ unsafe { notsafe::wxbr_set_min_size(self.0, w, h) }
+ }
+
+ /// Attach a hover tooltip to this widget (round 15 #10). Empty clears it.
+ pub fn set_tool_tip(&self, text: &str) {
+ let c = CString::new(text).unwrap_or_default();
+ unsafe { notsafe::wxbr_set_tooltip(self.0, c.as_ptr()) }
+ }
+
+ pub fn static_text(parent: Widget, label: &str) -> Widget {
+ let c = CString::new(label).unwrap_or_default();
+ Widget(unsafe { notsafe::wxbr_static_text(parent.0, c.as_ptr()) })
@@ -452,6 +463,13 @@
+ unsafe { notsafe::wxbr_text_ctrl_set(self.0, c.as_ptr()) }
+ }
+
+ /// Insert `value` at the text control's cursor (replacing any selection),
+ /// rather than replacing the whole contents (round 15 #1).
+ pub fn write_text(&self, value: &str) {
+ let c = CString::new(value).unwrap_or_default();
+ unsafe { notsafe::wxbr_text_ctrl_write(self.0, c.as_ptr()) }
+ }
+
+ pub fn check_box(parent: Widget, label: &str) -> Widget {
+ let c = CString::new(label).unwrap_or_default();
+ Widget(unsafe { notsafe::wxbr_check_box(parent.0, c.as_ptr()) })
@@ -529,6 +547,36 @@
+ Some(String::from_utf8_lossy(&bytes).into_owned())
+ }
+
+ /// Save-file dialog (round 15 #14): returns the chosen path, or None if
+ /// cancelled. `default_name` prefills the filename; `wildcard` is a wx filter
+ /// string like "CSV files (*.csv)|*.csv".
+ pub fn save_file_dialog(
+ parent: Widget,
+ title: &str,
+ default_name: &str,
+ wildcard: &str,
+ ) -> Option<String> {
+ let t = CString::new(title).unwrap_or_default();
+ let d = CString::new(default_name).unwrap_or_default();
+ let w = CString::new(wildcard).unwrap_or_default();
+ let mut buf = vec![0i8; 4096];
+ let n = unsafe {
+ notsafe::wxbr_save_file_dialog(
+ parent.0,
+ t.as_ptr(),
+ d.as_ptr(),
+ w.as_ptr(),
+ buf.as_mut_ptr(),
+ buf.len() as c_int,
+ )
+ };
+ if n <= 0 {
+ return None;
+ }
+ let bytes: Vec<u8> = buf[..(n - 1) as usize].iter().map(|&b| b as u8).collect();
+ Some(String::from_utf8_lossy(&bytes).into_owned())
+ }
+
+ // ---- data view list ctrl ----
+
+ pub fn dvlc(parent: Widget) -> Widget {
@@ -582,6 +630,15 @@
+ unsafe { notsafe::wxbr_dvlc_set_cell_tooltip(self.0, row, col, c.as_ptr()) }
+ }
+
+ /// Set per-icon hover tooltips for a cell (round 15 #15): one tooltip per icon
+ /// in draw order. The bridge shows the one under the pointer. Passing an empty
+ /// slice clears them.
+ pub fn dvlc_set_icon_tooltips(&self, row: usize, col: usize, tips: &[String]) {
+ let joined = tips.join("\u{1f}");
+ let c = CString::new(joined).unwrap_or_default();
+ unsafe { notsafe::wxbr_dvlc_set_icon_tooltips(self.0, row, col, c.as_ptr()) }
+ }
+
+ pub fn dvlc_get_cell(&self, row: usize, col: usize) -> Option<String> {
+ let mut buf = vec![0i8; 4096];
+ let n = unsafe {
@@ -735,6 +792,13 @@
+ unsafe { notsafe::wxbr_menu_append_separator(self.0) }
+ }
+
+ /// Append `submenu` under this menu with `label` (round 15 #13). This menu
+ /// takes ownership of the submenu.
+ pub fn menu_append_submenu(&self, label: &str, submenu: Widget) {
+ let c = CString::new(label).unwrap_or_default();
+ unsafe { notsafe::wxbr_menu_append_submenu(self.0, c.as_ptr(), submenu.0) }
+ }
+
+ /// Show `menu` as a popup on this window; blocks until dismissed.
+ pub fn popup_menu(&self, menu: Widget) {
+ unsafe { notsafe::wxbr_popup_menu(self.0, menu.0) }
+188 -21
View File
@@ -1,6 +1,6 @@
--- a/cpp_src/widgets_bridge.cpp
+++ b/cpp_src/widgets_bridge.cpp
@@ -0,0 +1,1886 @@
@@ -0,0 +1,2053 @@
+// widgets_bridge.cpp — alkane-toolkit extension to wx-rs
+// Adds the widget/event surface the toolkit UI needs on top of the upstream
+// render-callback bridge (which is kept untouched).
@@ -88,6 +88,10 @@
+ // Per-cell hover tooltip text, keyed by (row, model column). Used for the
+ // Errors column's full-message tooltip (see the GTK query-tooltip handler).
+ std::map<std::pair<unsigned, unsigned>, wxString> cell_tip;
+ // Per-ICON hover tooltips for a cell (round 15 #15): the Health column stores
+ // one tooltip per component icon so the tooltip pertains to the icon under the
+ // pointer, not the whole cell.
+ std::map<std::pair<unsigned, unsigned>, std::vector<wxString>> icon_tip;
+ bool GetAttrByRow(unsigned int row, unsigned int col,
+ wxDataViewItemAttr& attr) const override {
+ (void)col;
@@ -176,6 +180,13 @@
+const wxUniChar SHAPE_BRAIN = 0x0E; // control board
+const wxUniChar SHAPE_FAN = 0x0F; // cooling fan
+const wxUniChar SHAPE_CHIP = 0x10; // hashboard
+// Locate-light beacon (round 15 #6): a green dot above a red dot, both flashing
+// quickly while the miner's locate light is on.
+const wxUniChar SHAPE_LIGHT_BEACON = 0x11;
+// Health-column alignment gap (round 15 #5): draws nothing but advances by one
+// health-icon width, so component icons line up in fixed slots across rows even
+// when a miner has fewer fans/boards than the widest in the fleet.
+const wxUniChar SHAPE_GAP = 0x12;
+const int SHAPE_ADVANCE = 15; // horizontal space one shape occupies
+
+// Table zoom factor (round 14 #3), 1.0 = 100%. A status-bar slider scales the
@@ -186,7 +197,7 @@
+static wxFont g_zoom_base_font; // its font at 100% (captured lazily)
+static wxVector<int> g_zoom_base_w; // column widths at 100% (per column)
+static wxSlider* g_zoom_slider = nullptr; // the status-bar zoom slider
+static wxStaticText* g_zoom_label = nullptr; // the "100%" readout next to it
+static wxTextCtrl* g_zoom_entry = nullptr; // the editable "100%" field next to it
+
+// Animation phase for the pulsing locate-light dot (round 12 #6), advanced by a
+// wxTimer while any such dot is on screen; the treeview it repaints is tracked so
@@ -199,7 +210,8 @@
+ wxUniChar c = s[0];
+ if (c == SHAPE_DOT || c == SHAPE_LOCK || c == SHAPE_UNLOCK ||
+ c == SHAPE_HASHING || c == SHAPE_SLOW || c == SHAPE_NOTHASHING ||
+ c == SHAPE_PAUSED || c == SHAPE_PULSE_DOT ||
+ c == SHAPE_PAUSED || c == SHAPE_PULSE_DOT || c == SHAPE_LIGHT_BEACON ||
+ c == SHAPE_GAP ||
+ c == SHAPE_BOLT || c == SHAPE_BRAIN || c == SHAPE_FAN || c == SHAPE_CHIP) {
+ out = c;
+ return true;
@@ -299,6 +311,18 @@
+int DrawShape(wxDC* dc, wxUniChar shape, wxCoord x, const wxRect& cell,
+ const wxColour& colour, const wxColour& bg) {
+ int cy = cell.y + cell.height / 2;
+ // Health-column alignment gap (round 15 #5): occupy one health-icon width but
+ // draw nothing, so component icons line up in fixed slots across rows. The
+ // health icons are square, so the advance is (h - 3) just like a real one.
+ if (shape == SHAPE_GAP) {
+ int h = cell.height - 1;
+ int cap = (int)(28 * g_table_zoom + 0.5);
+ if (cap < 8) cap = 8;
+ if (h > cap) h = cap;
+ if (h < 8) h = 8;
+ int adv = h - 3;
+ return adv < 1 ? 1 : adv;
+ }
+ // SVG-backed icon (access padlocks #9, status KPI icons #11): recolour to the
+ // segment colour, rasterise (cached), and draw centred in its slot.
+ if (const ShapeSvg* sv = LookupShapeSvg(shape)) {
@@ -330,6 +354,20 @@
+ }
+ }
+ int cx = x + SHAPE_ADVANCE / 2;
+ if (shape == SHAPE_LIGHT_BEACON) {
+ // A green dot above a red dot, both flashing quickly (round 15 #6). The blink
+ // is a fast on/off (~0.5 s) driven by the shared pulse phase.
+ double a = (std::sin(g_pulse_phase * 3.0) > 0.0) ? 1.0 : 0.18;
+ wxColour green = BlendColour(bg, wxColour(30, 175, 70), a);
+ wxColour red = BlendColour(bg, wxColour(215, 45, 40), a);
+ int r = 3;
+ dc->SetPen(*wxTRANSPARENT_PEN);
+ dc->SetBrush(wxBrush(green));
+ dc->DrawCircle(cx, cy - (r + 1), r);
+ dc->SetBrush(wxBrush(red));
+ dc->DrawCircle(cx, cy + (r + 1), r);
+ return SHAPE_ADVANCE;
+ }
+ if (shape == SHAPE_DOT || shape == SHAPE_PULSE_DOT) {
+ wxColour fill = colour;
+ if (shape == SHAPE_PULSE_DOT) {
@@ -478,7 +516,12 @@
+ // with the table zoom (round 14 #3).
+ int hh = (int)((health ? 22 : 15) * g_table_zoom + 0.5);
+ if (hh < 8) hh = 8;
+ if (const ShapeSvg* sv = LookupShapeSvg(shape)) {
+ // The alignment gap is one health-icon-width slot that draws nothing
+ // (round 15 #5); health icons are square, so its advance is hh - 3.
+ if (shape == SHAPE_GAP) {
+ adv = hh - 3;
+ if (adv < 1) adv = 1;
+ } else if (const ShapeSvg* sv = LookupShapeSvg(shape)) {
+ int ww = (sv->vbh > 0) ? (int)((double)hh * sv->vbw / sv->vbh + 0.5) : hh;
+ if (health) {
+ adv = ww - 3;
@@ -641,6 +684,16 @@
+ ((wxWindow*)win)->SetMinSize(wxSize(w, h));
+}
+
+// Attach a hover tooltip to any widget (round 15 #10). An empty string clears it.
+void wxbr_set_tooltip(void* win, const char* text) {
+ wxWindow* w = (wxWindow*)win;
+ if (text && *text) {
+ w->SetToolTip(wxString::FromUTF8(text));
+ } else {
+ w->UnsetToolTip();
+ }
+}
+
+// ---- static text / fonts --------------------------------------------------
+
+void* wxbr_static_text(void* parent, const char* label) {
@@ -727,6 +780,15 @@
+ ((wxTextCtrl*)win)->SetValue(wxString::FromUTF8(value));
+}
+
+// Insert text at the current cursor position, replacing any selection (round 15
+// #1: worker-name placeholders are inserted, not overwritten). Leaves focus + the
+// cursor after the inserted text.
+void wxbr_text_ctrl_write(void* win, const char* value) {
+ wxTextCtrl* t = (wxTextCtrl*)win;
+ t->WriteText(wxString::FromUTF8(value));
+ t->SetFocus();
+}
+
+// ---- checkbox -------------------------------------------------------------
+
+void* wxbr_check_box(void* parent, const char* label) {
@@ -840,6 +902,25 @@
+ return n + 1;
+}
+
+// Save-file dialog (round 15 #14). `default_name` prefills the filename;
+// `wildcard` is a wxWidgets filter string (e.g. "CSV files (*.csv)|*.csv").
+// Returns the chosen path in `buf` (length+1), or 0 if cancelled.
+int wxbr_save_file_dialog(void* parent, const char* title, const char* default_name,
+ const char* wildcard, char* buf, int cap) {
+ wxString wc = (wildcard && *wildcard) ? wxString::FromUTF8(wildcard)
+ : wxString(wxFileSelectorDefaultWildcardStr);
+ wxFileDialog dlg((wxWindow*)parent, wxString::FromUTF8(title), wxEmptyString,
+ wxString::FromUTF8(default_name ? default_name : ""), wc,
+ wxFD_SAVE | wxFD_OVERWRITE_PROMPT);
+ if (dlg.ShowModal() != wxID_OK) return 0;
+ wxCharBuffer b = dlg.GetPath().ToUTF8();
+ int n = (int)strlen(b.data());
+ if (n >= cap) n = cap - 1;
+ memcpy(buf, b.data(), n);
+ buf[n] = 0;
+ return n + 1;
+}
+
+// ---- data view list ctrl ------------------------------------------------------
+
+static AttrListStore* dvlc_store(void* win) {
@@ -864,12 +945,38 @@
+ return FALSE;
+ gint* idx = gtk_tree_path_get_indices(path);
+ int row = idx ? idx[0] : -1;
+ gtk_tree_path_free(path);
+ if (row < 0 || !gcol) return FALSE;
+ if (row < 0 || !gcol) { gtk_tree_path_free(path); return FALSE; }
+ wxDataViewColumn* wxcol = dv->GTKColumnToWX(gcol);
+ if (!wxcol) return FALSE;
+ if (!wxcol) { gtk_tree_path_free(path); return FALSE; }
+ AttrListStore* store = static_cast<AttrListStore*>(dv->GetModel());
+ auto it = store->cell_tip.find({(unsigned)row, wxcol->GetModelColumn()});
+ unsigned mcol = wxcol->GetModelColumn();
+ // Per-icon tooltip (round 15 #15): if this cell has one tooltip per icon, pick
+ // the one under the pointer from the icon slot the x-offset falls in.
+ auto iit = store->icon_tip.find({(unsigned)row, mcol});
+ if (iit != store->icon_tip.end() && !iit->second.empty()) {
+ GdkRectangle crect;
+ gtk_tree_view_get_cell_area(GTK_TREE_VIEW(tv), path, gcol, &crect);
+ gtk_tree_path_free(path);
+ // Icon advance matches DrawShape's health-icon width (square icons: h - 3).
+ int h = crect.height - 1;
+ int cap = (int)(28 * g_table_zoom + 0.5);
+ if (cap < 8) cap = 8;
+ if (h > cap) h = cap;
+ if (h < 8) h = 8;
+ int adv = h - 3;
+ if (adv < 1) adv = 1;
+ int off = bx - crect.x;
+ if (off < 0) off = 0;
+ int slot = off / adv;
+ if (slot < 0) slot = 0;
+ if (slot >= (int)iit->second.size()) slot = (int)iit->second.size() - 1;
+ const wxString& tip = iit->second[(size_t)slot];
+ if (tip.IsEmpty()) return FALSE;
+ gtk_tooltip_set_text(tooltip, tip.utf8_str());
+ return TRUE;
+ }
+ gtk_tree_path_free(path);
+ auto it = store->cell_tip.find({(unsigned)row, mcol});
+ if (it == store->cell_tip.end() || it->second.IsEmpty()) return FALSE;
+ gtk_tooltip_set_text(tooltip, it->second.utf8_str());
+ return TRUE;
@@ -1054,6 +1161,30 @@
+ store->DeleteAllItems();
+ store->row_fg.clear();
+ store->cell_tip.clear();
+ store->icon_tip.clear();
+}
+
+// Set per-icon tooltips for one cell (round 15 #15): `joined` is the tooltips for
+// each icon in draw order, separated by 0x1f. An empty string clears them.
+void wxbr_dvlc_set_icon_tooltips(void* win, unsigned row, unsigned col, const char* joined) {
+ AttrListStore* store = dvlc_store(win);
+ if (!joined || !joined[0]) {
+ store->icon_tip.erase({row, col});
+ return;
+ }
+ std::vector<wxString> tips;
+ wxString s = wxString::FromUTF8(joined);
+ wxString cur;
+ for (size_t i = 0; i < s.length(); i++) {
+ if (s[i] == wxUniChar(0x1f)) {
+ tips.push_back(cur);
+ cur.clear();
+ } else {
+ cur += s[i];
+ }
+ }
+ tips.push_back(cur);
+ store->icon_tip[{row, col}] = tips;
+}
+
+// Set (or clear, with an empty string) the hover tooltip for one cell,
@@ -1597,6 +1728,12 @@
+ ((wxMenu*)menu)->Append(id, wxString::FromUTF8(label));
+}
+
+// Append `submenu` under `menu` as a labelled sub-menu (round 15 #13); `menu`
+// takes ownership of `submenu`.
+void wxbr_menu_append_submenu(void* menu, const char* label, void* submenu) {
+ ((wxMenu*)menu)->AppendSubMenu((wxMenu*)submenu, wxString::FromUTF8(label));
+}
+
+void wxbr_menu_append_separator(void* menu) {
+ ((wxMenu*)menu)->AppendSeparator();
+}
@@ -1754,17 +1891,17 @@
+ g_status_indicator->SetSize(r.x + 4, y, r.width - 8, h);
+ }
+ }
+ // Zoom slider + "NNN%" label in the far-right field (round 14 #3): label at the
+ // right edge, slider filling the space to its left.
+ if (g_zoom_slider && g_zoom_label) {
+ // Zoom slider + editable "NNN%" entry in the far-right field (round 14 #3, #4):
+ // the entry at the right edge, slider filling the space to its left.
+ if (g_zoom_slider && g_zoom_entry) {
+ int fld = (sb->GetFieldsCount() >= 3) ? 2 : 1;
+ wxRect r;
+ if (sb->GetFieldRect(fld, r)) {
+ wxSize lbest = g_zoom_label->GetBestSize();
+ int lw = lbest.GetWidth() + 6;
+ int lh = lbest.GetHeight();
+ g_zoom_label->SetSize(r.x + r.width - lw, r.y + (r.height - lh) / 2, lw, lh);
+ int sw = r.width - lw - 8;
+ int ew = 52;
+ int eh = g_zoom_entry->GetBestSize().GetHeight();
+ if (eh > r.height - 2) eh = r.height - 2;
+ g_zoom_entry->SetSize(r.x + r.width - ew - 2, r.y + (r.height - eh) / 2, ew, eh);
+ int sw = r.width - ew - 10;
+ if (sw < 20) sw = 20;
+ int sh = r.height - 2;
+ g_zoom_slider->SetSize(r.x + 2, r.y + (r.height - sh) / 2, sw, sh);
@@ -1799,9 +1936,9 @@
+ g_zoom_table->Refresh();
+ g_zoom_table->Update();
+ }
+ if (g_zoom_label) {
+ g_zoom_label->SetLabel(wxString::Format(wxT("%d%%"), (int)(factor * 100 + 0.5)));
+ reposition_status_indicator();
+ if (g_zoom_entry) {
+ // ChangeValue does not fire wxEVT_TEXT, so this never loops back into a zoom.
+ g_zoom_entry->ChangeValue(wxString::Format(wxT("%d%%"), (int)(factor * 100 + 0.5)));
+ }
+}
+
@@ -1837,6 +1974,7 @@
+// #3). Widens the bar to three fields (status | indicator | zoom) and wires the
+// slider straight to apply_table_zoom -- no Rust round-trip. Call after the table
+// exists so the slider can find it.
+void wxbr_table_set_zoom(double factor); // defined below; used by the handlers here
+void wxbr_status_zoom_init(void* frame_ptr) {
+ wxFrame* frame = (wxFrame*)frame_ptr;
+ wxStatusBar* sb = frame->GetStatusBar();
@@ -1850,15 +1988,44 @@
+ if (!g_zoom_slider) {
+ g_zoom_slider = new wxSlider(sb, wxID_ANY, 100, 50, 250);
+ g_zoom_slider->SetToolTip(wxT("Table zoom"));
+ g_zoom_label = new wxStaticText(sb, wxID_ANY, wxT("100%"),
+ wxDefaultPosition, wxDefaultSize, wxALIGN_RIGHT | wxST_NO_AUTORESIZE);
+ // Editable percent field (round 15 #4): type an exact scale and press Enter.
+ g_zoom_entry = new wxTextCtrl(sb, wxID_ANY, wxT("100%"), wxDefaultPosition,
+ wxDefaultSize, wxTE_PROCESS_ENTER | wxTE_RIGHT);
+ g_zoom_entry->SetToolTip(wxT("Table zoom (type a %, Enter)"));
+ g_zoom_slider->Bind(wxEVT_SLIDER, [](wxCommandEvent& e) {
+ apply_table_zoom(e.GetInt() / 100.0);
+ });
+ g_zoom_entry->Bind(wxEVT_TEXT_ENTER, [](wxCommandEvent&) {
+ if (!g_zoom_entry) return;
+ wxString s = g_zoom_entry->GetValue();
+ s.Replace("%", "");
+ s.Trim(true).Trim(false);
+ long pct = 0;
+ if (s.ToLong(&pct) && pct > 0) wxbr_table_set_zoom(pct / 100.0);
+ });
+ sb->Bind(wxEVT_SIZE, [](wxSizeEvent& ev) {
+ reposition_status_indicator();
+ ev.Skip();
+ });
+ // Ctrl +/- / Ctrl+0 zoom the table from anywhere in the window (round 15 #4).
+ frame->Bind(wxEVT_CHAR_HOOK, [](wxKeyEvent& e) {
+ if (e.ControlDown()) {
+ int k = e.GetKeyCode();
+ if (k == '=' || k == '+' || k == WXK_NUMPAD_ADD) {
+ wxbr_table_set_zoom(g_table_zoom + 0.1);
+ return;
+ }
+ if (k == '-' || k == WXK_NUMPAD_SUBTRACT) {
+ wxbr_table_set_zoom(g_table_zoom - 0.1);
+ return;
+ }
+ if (k == '0' || k == WXK_NUMPAD0) {
+ wxbr_table_set_zoom(1.0);
+ return;
+ }
+ }
+ e.Skip();
+ });
+ }
+ reposition_status_indicator();
+}
@@ -85,6 +85,10 @@ class AttrListStore : public wxDataViewListStore {
// Per-cell hover tooltip text, keyed by (row, model column). Used for the
// Errors column's full-message tooltip (see the GTK query-tooltip handler).
std::map<std::pair<unsigned, unsigned>, wxString> cell_tip;
// Per-ICON hover tooltips for a cell (round 15 #15): the Health column stores
// one tooltip per component icon so the tooltip pertains to the icon under the
// pointer, not the whole cell.
std::map<std::pair<unsigned, unsigned>, std::vector<wxString>> icon_tip;
bool GetAttrByRow(unsigned int row, unsigned int col,
wxDataViewItemAttr& attr) const override {
(void)col;
@@ -173,6 +177,13 @@ const wxUniChar SHAPE_BOLT = 0x0C; // power supply
const wxUniChar SHAPE_BRAIN = 0x0E; // control board
const wxUniChar SHAPE_FAN = 0x0F; // cooling fan
const wxUniChar SHAPE_CHIP = 0x10; // hashboard
// Locate-light beacon (round 15 #6): a green dot above a red dot, both flashing
// quickly while the miner's locate light is on.
const wxUniChar SHAPE_LIGHT_BEACON = 0x11;
// Health-column alignment gap (round 15 #5): draws nothing but advances by one
// health-icon width, so component icons line up in fixed slots across rows even
// when a miner has fewer fans/boards than the widest in the fleet.
const wxUniChar SHAPE_GAP = 0x12;
const int SHAPE_ADVANCE = 15; // horizontal space one shape occupies
// Table zoom factor (round 14 #3), 1.0 = 100%. A status-bar slider scales the
@@ -183,7 +194,7 @@ static wxDataViewCtrl* g_zoom_table = nullptr; // the table the zoom scales
static wxFont g_zoom_base_font; // its font at 100% (captured lazily)
static wxVector<int> g_zoom_base_w; // column widths at 100% (per column)
static wxSlider* g_zoom_slider = nullptr; // the status-bar zoom slider
static wxStaticText* g_zoom_label = nullptr; // the "100%" readout next to it
static wxTextCtrl* g_zoom_entry = nullptr; // the editable "100%" field next to it
// Animation phase for the pulsing locate-light dot (round 12 #6), advanced by a
// wxTimer while any such dot is on screen; the treeview it repaints is tracked so
@@ -196,7 +207,8 @@ bool IsShapeSentinel(const wxString& s, wxUniChar& out) {
wxUniChar c = s[0];
if (c == SHAPE_DOT || c == SHAPE_LOCK || c == SHAPE_UNLOCK ||
c == SHAPE_HASHING || c == SHAPE_SLOW || c == SHAPE_NOTHASHING ||
c == SHAPE_PAUSED || c == SHAPE_PULSE_DOT ||
c == SHAPE_PAUSED || c == SHAPE_PULSE_DOT || c == SHAPE_LIGHT_BEACON ||
c == SHAPE_GAP ||
c == SHAPE_BOLT || c == SHAPE_BRAIN || c == SHAPE_FAN || c == SHAPE_CHIP) {
out = c;
return true;
@@ -296,6 +308,18 @@ const wxBitmap& ShapeBitmap(wxUniChar shape, const ShapeSvg& sv, const wxColour&
int DrawShape(wxDC* dc, wxUniChar shape, wxCoord x, const wxRect& cell,
const wxColour& colour, const wxColour& bg) {
int cy = cell.y + cell.height / 2;
// Health-column alignment gap (round 15 #5): occupy one health-icon width but
// draw nothing, so component icons line up in fixed slots across rows. The
// health icons are square, so the advance is (h - 3) just like a real one.
if (shape == SHAPE_GAP) {
int h = cell.height - 1;
int cap = (int)(28 * g_table_zoom + 0.5);
if (cap < 8) cap = 8;
if (h > cap) h = cap;
if (h < 8) h = 8;
int adv = h - 3;
return adv < 1 ? 1 : adv;
}
// SVG-backed icon (access padlocks #9, status KPI icons #11): recolour to the
// segment colour, rasterise (cached), and draw centred in its slot.
if (const ShapeSvg* sv = LookupShapeSvg(shape)) {
@@ -311,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;
}
@@ -327,6 +364,20 @@ int DrawShape(wxDC* dc, wxUniChar shape, wxCoord x, const wxRect& cell,
}
}
int cx = x + SHAPE_ADVANCE / 2;
if (shape == SHAPE_LIGHT_BEACON) {
// A green dot above a red dot, both flashing quickly (round 15 #6). The blink
// is a fast on/off (~0.5 s) driven by the shared pulse phase.
double a = (std::sin(g_pulse_phase * 3.0) > 0.0) ? 1.0 : 0.18;
wxColour green = BlendColour(bg, wxColour(30, 175, 70), a);
wxColour red = BlendColour(bg, wxColour(215, 45, 40), a);
int r = 3;
dc->SetPen(*wxTRANSPARENT_PEN);
dc->SetBrush(wxBrush(green));
dc->DrawCircle(cx, cy - (r + 1), r);
dc->SetBrush(wxBrush(red));
dc->DrawCircle(cx, cy + (r + 1), r);
return SHAPE_ADVANCE;
}
if (shape == SHAPE_DOT || shape == SHAPE_PULSE_DOT) {
wxColour fill = colour;
if (shape == SHAPE_PULSE_DOT) {
@@ -475,7 +526,12 @@ class SegmentRenderer : public wxDataViewCustomRenderer {
// with the table zoom (round 14 #3).
int hh = (int)((health ? 22 : 15) * g_table_zoom + 0.5);
if (hh < 8) hh = 8;
if (const ShapeSvg* sv = LookupShapeSvg(shape)) {
// The alignment gap is one health-icon-width slot that draws nothing
// (round 15 #5); health icons are square, so its advance is hh - 3.
if (shape == SHAPE_GAP) {
adv = hh - 3;
if (adv < 1) adv = 1;
} else if (const ShapeSvg* sv = LookupShapeSvg(shape)) {
int ww = (sv->vbh > 0) ? (int)((double)hh * sv->vbw / sv->vbh + 0.5) : hh;
if (health) {
adv = ww - 3;
@@ -638,6 +694,16 @@ void wxbr_set_min_size(void* win, int w, int h) {
((wxWindow*)win)->SetMinSize(wxSize(w, h));
}
// Attach a hover tooltip to any widget (round 15 #10). An empty string clears it.
void wxbr_set_tooltip(void* win, const char* text) {
wxWindow* w = (wxWindow*)win;
if (text && *text) {
w->SetToolTip(wxString::FromUTF8(text));
} else {
w->UnsetToolTip();
}
}
// ---- static text / fonts --------------------------------------------------
void* wxbr_static_text(void* parent, const char* label) {
@@ -724,6 +790,15 @@ void wxbr_text_ctrl_set(void* win, const char* value) {
((wxTextCtrl*)win)->SetValue(wxString::FromUTF8(value));
}
// Insert text at the current cursor position, replacing any selection (round 15
// #1: worker-name placeholders are inserted, not overwritten). Leaves focus + the
// cursor after the inserted text.
void wxbr_text_ctrl_write(void* win, const char* value) {
wxTextCtrl* t = (wxTextCtrl*)win;
t->WriteText(wxString::FromUTF8(value));
t->SetFocus();
}
// ---- checkbox -------------------------------------------------------------
void* wxbr_check_box(void* parent, const char* label) {
@@ -837,6 +912,25 @@ int wxbr_file_dialog(void* parent, const char* title, char* buf, int cap) {
return n + 1;
}
// Save-file dialog (round 15 #14). `default_name` prefills the filename;
// `wildcard` is a wxWidgets filter string (e.g. "CSV files (*.csv)|*.csv").
// Returns the chosen path in `buf` (length+1), or 0 if cancelled.
int wxbr_save_file_dialog(void* parent, const char* title, const char* default_name,
const char* wildcard, char* buf, int cap) {
wxString wc = (wildcard && *wildcard) ? wxString::FromUTF8(wildcard)
: wxString(wxFileSelectorDefaultWildcardStr);
wxFileDialog dlg((wxWindow*)parent, wxString::FromUTF8(title), wxEmptyString,
wxString::FromUTF8(default_name ? default_name : ""), wc,
wxFD_SAVE | wxFD_OVERWRITE_PROMPT);
if (dlg.ShowModal() != wxID_OK) return 0;
wxCharBuffer b = dlg.GetPath().ToUTF8();
int n = (int)strlen(b.data());
if (n >= cap) n = cap - 1;
memcpy(buf, b.data(), n);
buf[n] = 0;
return n + 1;
}
// ---- data view list ctrl ------------------------------------------------------
static AttrListStore* dvlc_store(void* win) {
@@ -861,12 +955,38 @@ static gboolean dvlc_query_tooltip(GtkWidget* tv, gint x, gint y, gboolean keybo
return FALSE;
gint* idx = gtk_tree_path_get_indices(path);
int row = idx ? idx[0] : -1;
gtk_tree_path_free(path);
if (row < 0 || !gcol) return FALSE;
if (row < 0 || !gcol) { gtk_tree_path_free(path); return FALSE; }
wxDataViewColumn* wxcol = dv->GTKColumnToWX(gcol);
if (!wxcol) return FALSE;
if (!wxcol) { gtk_tree_path_free(path); return FALSE; }
AttrListStore* store = static_cast<AttrListStore*>(dv->GetModel());
auto it = store->cell_tip.find({(unsigned)row, wxcol->GetModelColumn()});
unsigned mcol = wxcol->GetModelColumn();
// Per-icon tooltip (round 15 #15): if this cell has one tooltip per icon, pick
// the one under the pointer from the icon slot the x-offset falls in.
auto iit = store->icon_tip.find({(unsigned)row, mcol});
if (iit != store->icon_tip.end() && !iit->second.empty()) {
GdkRectangle crect;
gtk_tree_view_get_cell_area(GTK_TREE_VIEW(tv), path, gcol, &crect);
gtk_tree_path_free(path);
// Icon advance matches DrawShape's health-icon width (square icons: h - 3).
int h = crect.height - 1;
int cap = (int)(28 * g_table_zoom + 0.5);
if (cap < 8) cap = 8;
if (h > cap) h = cap;
if (h < 8) h = 8;
int adv = h - 3;
if (adv < 1) adv = 1;
int off = bx - crect.x;
if (off < 0) off = 0;
int slot = off / adv;
if (slot < 0) slot = 0;
if (slot >= (int)iit->second.size()) slot = (int)iit->second.size() - 1;
const wxString& tip = iit->second[(size_t)slot];
if (tip.IsEmpty()) return FALSE;
gtk_tooltip_set_text(tooltip, tip.utf8_str());
return TRUE;
}
gtk_tree_path_free(path);
auto it = store->cell_tip.find({(unsigned)row, mcol});
if (it == store->cell_tip.end() || it->second.IsEmpty()) return FALSE;
gtk_tooltip_set_text(tooltip, it->second.utf8_str());
return TRUE;
@@ -1051,6 +1171,30 @@ void wxbr_dvlc_clear(void* win) {
store->DeleteAllItems();
store->row_fg.clear();
store->cell_tip.clear();
store->icon_tip.clear();
}
// Set per-icon tooltips for one cell (round 15 #15): `joined` is the tooltips for
// each icon in draw order, separated by 0x1f. An empty string clears them.
void wxbr_dvlc_set_icon_tooltips(void* win, unsigned row, unsigned col, const char* joined) {
AttrListStore* store = dvlc_store(win);
if (!joined || !joined[0]) {
store->icon_tip.erase({row, col});
return;
}
std::vector<wxString> tips;
wxString s = wxString::FromUTF8(joined);
wxString cur;
for (size_t i = 0; i < s.length(); i++) {
if (s[i] == wxUniChar(0x1f)) {
tips.push_back(cur);
cur.clear();
} else {
cur += s[i];
}
}
tips.push_back(cur);
store->icon_tip[{row, col}] = tips;
}
// Set (or clear, with an empty string) the hover tooltip for one cell,
@@ -1594,6 +1738,12 @@ void wxbr_menu_append(void* menu, int id, const char* label) {
((wxMenu*)menu)->Append(id, wxString::FromUTF8(label));
}
// Append `submenu` under `menu` as a labelled sub-menu (round 15 #13); `menu`
// takes ownership of `submenu`.
void wxbr_menu_append_submenu(void* menu, const char* label, void* submenu) {
((wxMenu*)menu)->AppendSubMenu((wxMenu*)submenu, wxString::FromUTF8(label));
}
void wxbr_menu_append_separator(void* menu) {
((wxMenu*)menu)->AppendSeparator();
}
@@ -1751,17 +1901,17 @@ static void reposition_status_indicator() {
g_status_indicator->SetSize(r.x + 4, y, r.width - 8, h);
}
}
// Zoom slider + "NNN%" label in the far-right field (round 14 #3): label at the
// right edge, slider filling the space to its left.
if (g_zoom_slider && g_zoom_label) {
// Zoom slider + editable "NNN%" entry in the far-right field (round 14 #3, #4):
// the entry at the right edge, slider filling the space to its left.
if (g_zoom_slider && g_zoom_entry) {
int fld = (sb->GetFieldsCount() >= 3) ? 2 : 1;
wxRect r;
if (sb->GetFieldRect(fld, r)) {
wxSize lbest = g_zoom_label->GetBestSize();
int lw = lbest.GetWidth() + 6;
int lh = lbest.GetHeight();
g_zoom_label->SetSize(r.x + r.width - lw, r.y + (r.height - lh) / 2, lw, lh);
int sw = r.width - lw - 8;
int ew = 52;
int eh = g_zoom_entry->GetBestSize().GetHeight();
if (eh > r.height - 2) eh = r.height - 2;
g_zoom_entry->SetSize(r.x + r.width - ew - 2, r.y + (r.height - eh) / 2, ew, eh);
int sw = r.width - ew - 10;
if (sw < 20) sw = 20;
int sh = r.height - 2;
g_zoom_slider->SetSize(r.x + 2, r.y + (r.height - sh) / 2, sw, sh);
@@ -1796,9 +1946,9 @@ static void apply_table_zoom(double factor) {
g_zoom_table->Refresh();
g_zoom_table->Update();
}
if (g_zoom_label) {
g_zoom_label->SetLabel(wxString::Format(wxT("%d%%"), (int)(factor * 100 + 0.5)));
reposition_status_indicator();
if (g_zoom_entry) {
// ChangeValue does not fire wxEVT_TEXT, so this never loops back into a zoom.
g_zoom_entry->ChangeValue(wxString::Format(wxT("%d%%"), (int)(factor * 100 + 0.5)));
}
}
@@ -1834,6 +1984,7 @@ void wxbr_status_indicator_set(const char* text, int r, int g, int b) {
// #3). Widens the bar to three fields (status | indicator | zoom) and wires the
// slider straight to apply_table_zoom -- no Rust round-trip. Call after the table
// exists so the slider can find it.
void wxbr_table_set_zoom(double factor); // defined below; used by the handlers here
void wxbr_status_zoom_init(void* frame_ptr) {
wxFrame* frame = (wxFrame*)frame_ptr;
wxStatusBar* sb = frame->GetStatusBar();
@@ -1847,15 +1998,44 @@ void wxbr_status_zoom_init(void* frame_ptr) {
if (!g_zoom_slider) {
g_zoom_slider = new wxSlider(sb, wxID_ANY, 100, 50, 250);
g_zoom_slider->SetToolTip(wxT("Table zoom"));
g_zoom_label = new wxStaticText(sb, wxID_ANY, wxT("100%"),
wxDefaultPosition, wxDefaultSize, wxALIGN_RIGHT | wxST_NO_AUTORESIZE);
// Editable percent field (round 15 #4): type an exact scale and press Enter.
g_zoom_entry = new wxTextCtrl(sb, wxID_ANY, wxT("100%"), wxDefaultPosition,
wxDefaultSize, wxTE_PROCESS_ENTER | wxTE_RIGHT);
g_zoom_entry->SetToolTip(wxT("Table zoom (type a %, Enter)"));
g_zoom_slider->Bind(wxEVT_SLIDER, [](wxCommandEvent& e) {
apply_table_zoom(e.GetInt() / 100.0);
});
g_zoom_entry->Bind(wxEVT_TEXT_ENTER, [](wxCommandEvent&) {
if (!g_zoom_entry) return;
wxString s = g_zoom_entry->GetValue();
s.Replace("%", "");
s.Trim(true).Trim(false);
long pct = 0;
if (s.ToLong(&pct) && pct > 0) wxbr_table_set_zoom(pct / 100.0);
});
sb->Bind(wxEVT_SIZE, [](wxSizeEvent& ev) {
reposition_status_indicator();
ev.Skip();
});
// Ctrl +/- / Ctrl+0 zoom the table from anywhere in the window (round 15 #4).
frame->Bind(wxEVT_CHAR_HOOK, [](wxKeyEvent& e) {
if (e.ControlDown()) {
int k = e.GetKeyCode();
if (k == '=' || k == '+' || k == WXK_NUMPAD_ADD) {
wxbr_table_set_zoom(g_table_zoom + 0.1);
return;
}
if (k == '-' || k == WXK_NUMPAD_SUBTRACT) {
wxbr_table_set_zoom(g_table_zoom - 0.1);
return;
}
if (k == '0' || k == WXK_NUMPAD0) {
wxbr_table_set_zoom(1.0);
return;
}
}
e.Skip();
});
}
reposition_status_indicator();
}
+64
View File
@@ -27,6 +27,7 @@ mod notsafe {
pub fn wxbr_bind_size(win: *mut c_void);
pub fn wxbr_fit(win: *mut c_void);
pub fn wxbr_set_min_size(win: *mut c_void, w: c_int, h: c_int);
pub fn wxbr_set_tooltip(win: *mut c_void, text: *const c_char);
pub fn wxbr_static_text(parent: *mut c_void, label: *const c_char) -> *mut c_void;
pub fn wxbr_set_label(win: *mut c_void, label: *const c_char);
pub fn wxbr_get_label(win: *mut c_void, buf: *mut c_char, cap: c_int) -> c_int;
@@ -37,6 +38,7 @@ mod notsafe {
pub fn wxbr_text_ctrl(parent: *mut c_void, multiline: c_int) -> *mut c_void;
pub fn wxbr_text_ctrl_get(win: *mut c_void, buf: *mut c_char, cap: c_int) -> c_int;
pub fn wxbr_text_ctrl_set(win: *mut c_void, value: *const c_char);
pub fn wxbr_text_ctrl_write(win: *mut c_void, value: *const c_char);
pub fn wxbr_check_box(parent: *mut c_void, label: *const c_char) -> *mut c_void;
pub fn wxbr_check_box_get(win: *mut c_void) -> c_int;
pub fn wxbr_check_box_set(win: *mut c_void, v: c_int);
@@ -51,6 +53,7 @@ mod notsafe {
pub fn wxbr_dialog_show_modal(win: *mut c_void) -> c_int;
pub fn wxbr_dialog_close(win: *mut c_void, code: c_int);
pub fn wxbr_file_dialog(parent: *mut c_void, title: *const c_char, buf: *mut c_char, cap: c_int) -> c_int;
pub fn wxbr_save_file_dialog(parent: *mut c_void, title: *const c_char, default_name: *const c_char, wildcard: *const c_char, buf: *mut c_char, cap: c_int) -> c_int;
pub fn wxbr_dvlc(parent: *mut c_void) -> *mut c_void;
pub fn wxbr_dvlc_append_text_col(win: *mut c_void, title: *const c_char, width: c_int, reorderable: c_int);
pub fn wxbr_dvlc_append_colored_col(win: *mut c_void, title: *const c_char, width: c_int, reorderable: c_int) -> *mut c_void;
@@ -61,6 +64,7 @@ mod notsafe {
pub fn wxbr_dvlc_row_count(win: *mut c_void) -> c_int;
pub fn wxbr_dvlc_set_cell(win: *mut c_void, row: usize, col: usize, value: *const c_char);
pub fn wxbr_dvlc_set_cell_tooltip(win: *mut c_void, row: usize, col: usize, text: *const c_char);
pub fn wxbr_dvlc_set_icon_tooltips(win: *mut c_void, row: usize, col: usize, joined: *const c_char);
pub fn wxbr_dvlc_get_cell(win: *mut c_void, row: usize, col: usize, buf: *mut c_char, cap: c_int) -> c_int;
pub fn wxbr_dvlc_col_count(win: *mut c_void) -> c_int;
pub fn wxbr_dvlc_autosize_col(win: *mut c_void, pos: c_int);
@@ -85,6 +89,7 @@ mod notsafe {
pub fn wxbr_menu_new() -> *mut c_void;
pub fn wxbr_menu_append(menu: *mut c_void, id: c_int, label: *const c_char);
pub fn wxbr_menu_append_separator(menu: *mut c_void);
pub fn wxbr_menu_append_submenu(menu: *mut c_void, label: *const c_char, submenu: *mut c_void);
pub fn wxbr_popup_menu(win: *mut c_void, menu: *mut c_void);
pub fn wxbr_timer(id: c_int, ms: c_int) -> *mut c_void;
pub fn wxbr_gauge(parent: *mut c_void, range: c_int) -> *mut c_void;
@@ -378,6 +383,12 @@ impl Widget {
unsafe { notsafe::wxbr_set_min_size(self.0, w, h) }
}
/// Attach a hover tooltip to this widget (round 15 #10). Empty clears it.
pub fn set_tool_tip(&self, text: &str) {
let c = CString::new(text).unwrap_or_default();
unsafe { notsafe::wxbr_set_tooltip(self.0, c.as_ptr()) }
}
pub fn static_text(parent: Widget, label: &str) -> Widget {
let c = CString::new(label).unwrap_or_default();
Widget(unsafe { notsafe::wxbr_static_text(parent.0, c.as_ptr()) })
@@ -439,6 +450,13 @@ impl Widget {
unsafe { notsafe::wxbr_text_ctrl_set(self.0, c.as_ptr()) }
}
/// Insert `value` at the text control's cursor (replacing any selection),
/// rather than replacing the whole contents (round 15 #1).
pub fn write_text(&self, value: &str) {
let c = CString::new(value).unwrap_or_default();
unsafe { notsafe::wxbr_text_ctrl_write(self.0, c.as_ptr()) }
}
pub fn check_box(parent: Widget, label: &str) -> Widget {
let c = CString::new(label).unwrap_or_default();
Widget(unsafe { notsafe::wxbr_check_box(parent.0, c.as_ptr()) })
@@ -516,6 +534,36 @@ impl Widget {
Some(String::from_utf8_lossy(&bytes).into_owned())
}
/// Save-file dialog (round 15 #14): returns the chosen path, or None if
/// cancelled. `default_name` prefills the filename; `wildcard` is a wx filter
/// string like "CSV files (*.csv)|*.csv".
pub fn save_file_dialog(
parent: Widget,
title: &str,
default_name: &str,
wildcard: &str,
) -> Option<String> {
let t = CString::new(title).unwrap_or_default();
let d = CString::new(default_name).unwrap_or_default();
let w = CString::new(wildcard).unwrap_or_default();
let mut buf = vec![0i8; 4096];
let n = unsafe {
notsafe::wxbr_save_file_dialog(
parent.0,
t.as_ptr(),
d.as_ptr(),
w.as_ptr(),
buf.as_mut_ptr(),
buf.len() as c_int,
)
};
if n <= 0 {
return None;
}
let bytes: Vec<u8> = buf[..(n - 1) as usize].iter().map(|&b| b as u8).collect();
Some(String::from_utf8_lossy(&bytes).into_owned())
}
// ---- data view list ctrl ----
pub fn dvlc(parent: Widget) -> Widget {
@@ -569,6 +617,15 @@ impl Widget {
unsafe { notsafe::wxbr_dvlc_set_cell_tooltip(self.0, row, col, c.as_ptr()) }
}
/// Set per-icon hover tooltips for a cell (round 15 #15): one tooltip per icon
/// in draw order. The bridge shows the one under the pointer. Passing an empty
/// slice clears them.
pub fn dvlc_set_icon_tooltips(&self, row: usize, col: usize, tips: &[String]) {
let joined = tips.join("\u{1f}");
let c = CString::new(joined).unwrap_or_default();
unsafe { notsafe::wxbr_dvlc_set_icon_tooltips(self.0, row, col, c.as_ptr()) }
}
pub fn dvlc_get_cell(&self, row: usize, col: usize) -> Option<String> {
let mut buf = vec![0i8; 4096];
let n = unsafe {
@@ -722,6 +779,13 @@ impl Widget {
unsafe { notsafe::wxbr_menu_append_separator(self.0) }
}
/// Append `submenu` under this menu with `label` (round 15 #13). This menu
/// takes ownership of the submenu.
pub fn menu_append_submenu(&self, label: &str, submenu: Widget) {
let c = CString::new(label).unwrap_or_default();
unsafe { notsafe::wxbr_menu_append_submenu(self.0, c.as_ptr(), submenu.0) }
}
/// Show `menu` as a popup on this window; blocks until dismissed.
pub fn popup_menu(&self, menu: Widget) {
unsafe { notsafe::wxbr_popup_menu(self.0, menu.0) }
+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":"20173e90df24055f67bf03e2b3bb3bc396168f39aa45b36828b1963749d7838a","Cargo.lock":"2f4e619eefd164b57242e6bae57ddf3f73053f6af308a1dea181936d6a41a291","Cargo.toml":"2310d9df1678c138cc82922659ba19d00a92fd2f107a21047890e53fd79c492d","Cargo.toml.orig":"6c6d97588811d1b3b4c0839aa016d6133745b96f7620d390d093d60a8e29d501","src/config/collector.rs":"8c79ac6d3a04f93efc78b176ef7f6b1dc44e50d2bc95d813439b47422d6bb28f","src/config/fan.rs":"80c305261643542f11368342c3dcea29bbd3b016fb6f2962fdad6489dac2734a","src/config/mod.rs":"0d14701319d84ded3cd2f6ba6f92bff18c8e5cff90a2229592d97baae3ed4de3","src/config/pools.rs":"a74ab648053eb51305c4e1bbb6c05db57575ff2542b4fd53d28d33687a62eee3","src/config/preset.rs":"e68d694d3cf537c67ecb3b535a77904e25cc3b206a6ec214fc904011229b8a7c","src/config/scaling.rs":"f402e00c75ef796068765ab1a82ce6a3a0eb88f484c4a67f574ede90a3abaeeb","src/config/temperature.rs":"c6fd6f9cc8e565f27b58fb571fd33b58dcf2112a50b570f6b54a3c11c13d1fbe","src/config/timezone.rs":"4470fd704885e62e3bc8da8087dce6b002dd3fa92cec54d96ce88a06f03e1cbe","src/config/tuning.rs":"31a0826419d4690315f6eecc03250bfb4e5342431ff261015a9f9f3d87e69b6c","src/data/board.rs":"d6816919357d770f9ae6dedea66bbfdec9ab0f4c8391f9928b90039b668ee026","src/data/capabilities.rs":"29cbab6262fb8888b30b4674a30ef03983e005b4e18eefddfbbf9c568e1e1e17","src/data/collector.rs":"792489f8292863a7d57b9867096349d3257ddaf5bb0b5317e7a4366aa1b9dec9","src/data/command.rs":"53cd7e5e87888a76ba866b33b6d87400112bc3eeb4b5e331a381dfbb2c04579e","src/data/deserialize.rs":"461a84defd6f2fb53c8b3c059463c2bfcf69df80db0f5aa2d30b47e710163992","src/data/device.rs":"813b0d41834b217da9f2d51fc7d9cb0f12db6aa7501dd43b6c3f992f29e7827f","src/data/fan.rs":"9307626335008c04d5e5c742bdd7ff5c6e9055dbd84d0e7a655e6e656da3df78","src/data/firmware.rs":"648acace3b289f623cf678f36fb854ff5ddafb8e2f651ae4a15128ae719f87ba","src/data/hashrate.rs":"9d9e47a33753956fcfef7a5fb2a8eb315464aed41fe25be41acb36dd223a0880","src/data/message.rs":"7b399ab1a0b6e43e61a5461d29a2752beed2d1fd7b214eb891572f8994d47c11","src/data/miner.rs":"641ed29589112fdecf96a2065b05a1878af2a08bb60bff5e624bf56cc08e4a3a","src/data/mod.rs":"620b6876d0c88ad80c4aad1ed8ce8f8c4a76641c1e1c61e02cff115b1ab1da55","src/data/operating_state.rs":"7dccbfcc3eada16d0f890772323d4626fa9f298f7fc1882675ae3672d94f6da3","src/data/pool.rs":"a6bff9e56239915a095c4f99187a2d5f4631c3641332071c5134128cacaecceb","src/data/serialize.rs":"347f8cdf619156ac73aa0d89ed41555bd7332ef60cc92f945bc0f16f4ad29137","src/data/share.rs":"46c927b83eddaec7a01c6e0d8cc3af1d163d724421ecc94d4484db158fa27f4f","src/discovery.rs":"efc236592941e72609bd3be18551834f648b608caaf73b9555f75b9838692f6b","src/errors.rs":"0238c8cb6585d05cdd01aec031895e5240e3883f44f3fa22a7398027a360ef1a","src/lib.rs":"e2c8ecde3cf8edda920470f8b938056b60448184a5c81672f04a8e0235c3cf22","src/test/api.rs":"5defa33709c14cadfa7390981c3c7d3f324ef1878e4ee56c089dbf85665b57ae","src/test/mod.rs":"0b44b178ea8950b75fe09047797085f03e5c0eb17d62ca1f3e62a8f643fda87c","src/test/util.rs":"c6f5a3cccb40f1d6a7c316b52c70c59f8dda24a6ad83cb5aeac0b5d970debd0e","src/traits/auth.rs":"dffa58542ac9e57175f5dcad261f80b3efeba76ef3a039b0d9c6f9eb14a19893","src/traits/discovery.rs":"b232ea113c675178ae62c9f5ee35d0329e3a4465388133992c0db8d697113e34","src/traits/entry.rs":"03cf30045be6ba92a414d36990d316d572be21e6c66039ed8193da9a3c27cf53","src/traits/firmware.rs":"94831620bb8c8c4ce2ad69f8fd7b9679ee1de63b1f99529559e24f2118710638","src/traits/identification.rs":"67866931aa28c2e5b0e07dbacae47c1d82b53addea333f75033c451bbd2c9a77","src/traits/make.rs":"1d099cd51ecb354d20acef4cc1d2b3f75b682b6d6c887553861e185602d465f4","src/traits/miner.rs":"b198869b22a5e56366014a4090946cb44e9cddda32e77c62e57a90ceec8f1348","src/traits/mod.rs":"61406c4d2603299e4bad57c6f90115cadf93cee50a857bbfbb00d99f3a6873ac","src/traits/model.rs":"efde2b5cae4c4f018436bb68b236f354b5a733f7dafdeaf3f1c534b469a22d64","src/util.rs":"53255c65e85b97236cb34b452e2cb522edf377f49d2232645e0e0e33c447bb23"},"package":"1f25e625fc4c645ce995c5609a9fdff6f047d6a5e4d6be9dc167999a43197f58"}
{"$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":"20173e90df24055f67bf03e2b3bb3bc396168f39aa45b36828b1963749d7838a","Cargo.lock":"2f4e619eefd164b57242e6bae57ddf3f73053f6af308a1dea181936d6a41a291","Cargo.toml":"2310d9df1678c138cc82922659ba19d00a92fd2f107a21047890e53fd79c492d","Cargo.toml.orig":"6c6d97588811d1b3b4c0839aa016d6133745b96f7620d390d093d60a8e29d501","src/config/collector.rs":"8c79ac6d3a04f93efc78b176ef7f6b1dc44e50d2bc95d813439b47422d6bb28f","src/config/fan.rs":"80c305261643542f11368342c3dcea29bbd3b016fb6f2962fdad6489dac2734a","src/config/mod.rs":"0d14701319d84ded3cd2f6ba6f92bff18c8e5cff90a2229592d97baae3ed4de3","src/config/pools.rs":"a74ab648053eb51305c4e1bbb6c05db57575ff2542b4fd53d28d33687a62eee3","src/config/preset.rs":"e68d694d3cf537c67ecb3b535a77904e25cc3b206a6ec214fc904011229b8a7c","src/config/scaling.rs":"f402e00c75ef796068765ab1a82ce6a3a0eb88f484c4a67f574ede90a3abaeeb","src/config/temperature.rs":"c6fd6f9cc8e565f27b58fb571fd33b58dcf2112a50b570f6b54a3c11c13d1fbe","src/config/timezone.rs":"4470fd704885e62e3bc8da8087dce6b002dd3fa92cec54d96ce88a06f03e1cbe","src/config/tuning.rs":"31a0826419d4690315f6eecc03250bfb4e5342431ff261015a9f9f3d87e69b6c","src/data/board.rs":"d6816919357d770f9ae6dedea66bbfdec9ab0f4c8391f9928b90039b668ee026","src/data/capabilities.rs":"29cbab6262fb8888b30b4674a30ef03983e005b4e18eefddfbbf9c568e1e1e17","src/data/collector.rs":"dea53811c7c4f6dc2ba0ae5aab3b7bae9a06dfc9df0eef79117074845a0bf91f","src/data/command.rs":"53cd7e5e87888a76ba866b33b6d87400112bc3eeb4b5e331a381dfbb2c04579e","src/data/deserialize.rs":"461a84defd6f2fb53c8b3c059463c2bfcf69df80db0f5aa2d30b47e710163992","src/data/device.rs":"813b0d41834b217da9f2d51fc7d9cb0f12db6aa7501dd43b6c3f992f29e7827f","src/data/fan.rs":"9307626335008c04d5e5c742bdd7ff5c6e9055dbd84d0e7a655e6e656da3df78","src/data/firmware.rs":"648acace3b289f623cf678f36fb854ff5ddafb8e2f651ae4a15128ae719f87ba","src/data/hashrate.rs":"9d9e47a33753956fcfef7a5fb2a8eb315464aed41fe25be41acb36dd223a0880","src/data/message.rs":"7b399ab1a0b6e43e61a5461d29a2752beed2d1fd7b214eb891572f8994d47c11","src/data/miner.rs":"b07fc087b56cdaba6202a0dd23a1bf14d82f1907a7e3a5424aa98113b73c4fe5","src/data/mod.rs":"f63a6bd20fb2389e434257ccfe646321b25449993c937ece0d29850e0ab2279f","src/data/operating_state.rs":"7dccbfcc3eada16d0f890772323d4626fa9f298f7fc1882675ae3672d94f6da3","src/data/pool.rs":"a6bff9e56239915a095c4f99187a2d5f4631c3641332071c5134128cacaecceb","src/data/serialize.rs":"347f8cdf619156ac73aa0d89ed41555bd7332ef60cc92f945bc0f16f4ad29137","src/data/share.rs":"46c927b83eddaec7a01c6e0d8cc3af1d163d724421ecc94d4484db158fa27f4f","src/discovery.rs":"efc236592941e72609bd3be18551834f648b608caaf73b9555f75b9838692f6b","src/errors.rs":"0238c8cb6585d05cdd01aec031895e5240e3883f44f3fa22a7398027a360ef1a","src/lib.rs":"e2c8ecde3cf8edda920470f8b938056b60448184a5c81672f04a8e0235c3cf22","src/test/api.rs":"5defa33709c14cadfa7390981c3c7d3f324ef1878e4ee56c089dbf85665b57ae","src/test/mod.rs":"0b44b178ea8950b75fe09047797085f03e5c0eb17d62ca1f3e62a8f643fda87c","src/test/util.rs":"c6f5a3cccb40f1d6a7c316b52c70c59f8dda24a6ad83cb5aeac0b5d970debd0e","src/traits/auth.rs":"dffa58542ac9e57175f5dcad261f80b3efeba76ef3a039b0d9c6f9eb14a19893","src/traits/discovery.rs":"b232ea113c675178ae62c9f5ee35d0329e3a4465388133992c0db8d697113e34","src/traits/entry.rs":"03cf30045be6ba92a414d36990d316d572be21e6c66039ed8193da9a3c27cf53","src/traits/firmware.rs":"94831620bb8c8c4ce2ad69f8fd7b9679ee1de63b1f99529559e24f2118710638","src/traits/identification.rs":"67866931aa28c2e5b0e07dbacae47c1d82b53addea333f75033c451bbd2c9a77","src/traits/make.rs":"1d099cd51ecb354d20acef4cc1d2b3f75b682b6d6c887553861e185602d465f4","src/traits/miner.rs":"7ed55e9b085ea156357d0519c42e2b622e89fa2f81458bc73c42b6cfc6a94819","src/traits/mod.rs":"61406c4d2603299e4bad57c6f90115cadf93cee50a857bbfbb00d99f3a6873ac","src/traits/model.rs":"efde2b5cae4c4f018436bb68b236f354b5a733f7dafdeaf3f1c534b469a22d64","src/util.rs":"53255c65e85b97236cb34b452e2cb522edf377f49d2232645e0e0e33c447bb23"},"package":"1f25e625fc4c645ce995c5609a9fdff6f047d6a5e4d6be9dc167999a43197f58"}
+3
View File
@@ -74,6 +74,9 @@ pub enum DataField {
/// Current power consumption in watts.
#[cfg_attr(feature = "python", pydantic(value = "Wattage"))]
Wattage,
/// Power-supply info (identity, rated voltage envelope, live output V/A).
#[cfg_attr(feature = "python", pydantic(value = "Psu"))]
Psu,
/// manual tuning percent of full power (100 = unthrottled).
#[cfg_attr(feature = "python", pydantic(value = "TuningPercent"))]
TuningPercent,
+4
View File
@@ -16,6 +16,7 @@ use super::{
message::MinerMessage,
operating_state::OperatingState,
pool::PoolGroupData,
psu::PsuInfo,
};
use crate::data::{
deserialize::deserialize_macaddr,
@@ -192,6 +193,9 @@ pub struct MinerData {
#[serde(serialize_with = "serialize_power")]
#[ts(type = "number | null")]
pub wattage: Option<Power>,
/// Power-supply info (identity, rated voltage envelope, live output V/A),
/// when the firmware reports it.
pub psu: Option<PsuInfo>,
/// The current manual tuning percent of full power (100 = unthrottled), where supported
pub tuning_percent: Option<u8>,
/// The current tuning target of the miner, such as power target or hashrate target
+1
View File
@@ -15,5 +15,6 @@ pub mod message;
pub mod miner;
pub mod operating_state;
pub mod pool;
pub mod psu;
pub(crate) mod serialize;
pub mod share;
+30
View File
@@ -0,0 +1,30 @@
//! Power-supply (PSU) information reported by a miner's firmware.
//!
//! A backend fills in only what its firmware actually exposes; every field is
//! optional. Some firmware reports the PSU's identity and rated voltage envelope
//! (min/max output voltage), others also report the live output voltage and
//! current. Voltages are in volts and currents in amps.
#[cfg(feature = "python")]
use pyo3::pyclass;
use serde::{Deserialize, Serialize};
use ts_rs::TS;
/// Power-supply identity and voltage telemetry for one miner.
#[cfg_attr(feature = "python", pyclass(from_py_object, module = "asic_rs"))]
#[cfg_attr(feature = "python", asic_rs_pydantic::py_pydantic_model(getters))]
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default, TS)]
pub struct PsuInfo {
/// PSU model / type identifier, when reported.
pub model: Option<String>,
/// PSU firmware/hardware version, when reported.
pub version: Option<String>,
/// Minimum rated output voltage in volts, when reported.
pub voltage_min: Option<f64>,
/// Maximum rated output voltage in volts, when reported.
pub voltage_max: Option<f64>,
/// Live output voltage in volts, when reported.
pub output_voltage: Option<f64>,
/// Live output current in amps, when reported.
pub output_current: Option<f64>,
}
+7
View File
@@ -33,6 +33,7 @@ use crate::{
miner::{MinerData, TuningTarget},
operating_state::OperatingState,
pool::PoolGroupData,
psu::PsuInfo,
},
traits::firmware::MinerFirmware,
traits::model::MinerModel,
@@ -272,6 +273,7 @@ impl<
let hashrate = self.parse_hashrate(&data);
let expected_hashrate = self.parse_expected_hashrate(&data);
let wattage = self.parse_wattage(&data);
let psu = self.parse_psu(&data);
let tuning_percent = self.parse_tuning_percent(&data);
let tuning_target = self.parse_tuning_target(&data);
let scaled_tuning_target = self.parse_scaled_tuning_target(&data);
@@ -367,6 +369,7 @@ impl<
// Power information
wattage,
psu,
tuning_percent,
tuning_target,
scaled_tuning_target,
@@ -720,6 +723,10 @@ pub trait GetWattage: CollectData {
fn parse_wattage(&self, data: &HashMap<DataField, Value>) -> Option<Power> {
None
}
#[allow(unused_variables)]
fn parse_psu(&self, data: &HashMap<DataField, Value>) -> Option<PsuInfo> {
None
}
}
// Tuning Percent
+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":"6e42d50107b1a43fd7cf4a4c4f538468a337ed219ad8d6b23bd9abdabd123bd5","Cargo.lock":"7f984c7231c91f2def8f3e2e923a85c2e0b3239492f5ce23400881ea4de1aa16","Cargo.toml":"8a447efc18cd97d019a9771fb258b06f694499500561564eec75480e46bcc554","Cargo.toml.orig":"6c9e7b86804255debe03545c6358eb975d3d470810a19e6c40c680299a686b1f","src/backends/mod.rs":"65cdc60cdf38968f5a7e197338f4cf6173406ce69a4f0aaa96a9e29f4f581b6e","src/backends/v2020/firmware.rs":"5a41bfb8f42f17523e68f8702e87d75bcdb268bd4950bb66227f6966ef3576a9","src/backends/v2020/mod.rs":"cf1bd56ca56178968f8ef57955f06d14f4c3775f27ca3a85ac280919f19b8e50","src/backends/v2020/rpc.rs":"b517f88b9125fe1d8a20d5167f5d0d105b1339fce3d1a9fad5592e00470f46fb","src/backends/v2020/web.rs":"d39b67ed83781b2c4fa84a445b9ffe785ae3001941f800ad9860e050c61c6506","src/backends/v2023_07/firmware.rs":"c07668e351d48dab3e24511b1aa9ab5e408bbcb5a438fdb0542a1377f94b9bbb","src/backends/v2023_07/mod.rs":"278e4dd04a753858e12df96ead3522aef0616ebf6f27b3da4f1a12b064c19ee6","src/backends/v2023_07/rpc.rs":"2b24bbb432b302dd15f7a354054fc96c6a75cac2c8e75b8bcc11da37255a05a3","src/backends/v2023_07/web.rs":"d39b67ed83781b2c4fa84a445b9ffe785ae3001941f800ad9860e050c61c6506","src/firmware.rs":"e75c21d63218204b61bfab067599402e5c0b20452beaf0b16bfa79bf8afb6b35","src/lib.rs":"53f7acddeff8f7d82f80d09e0a9f91962011f9ccf2e441c4ca05cd7fc4eb292e","src/test/json/mod.rs":"a3ef4d6805bb4f8ea087e3a9b875e5a1664580e1ff3e3cd2015bb0c5c18ae7bb","src/test/json/v2020/devs.json":"df17cdfc9522e23450702b93f70ff701892db54c6ce6d986300453ad5e0d22db","src/test/json/v2020/mod.rs":"4c2512d36af834d400a865a94c2e8b1919f9d8dcbf54ab2530c73861c51af67d","src/test/json/v2020/pools.json":"4c4d19ad3ef0de84bfb18daaa48428b5f7917d23287c0196eacf3a6e389e7634","src/test/json/v2020/stats.json":"6d3cb463abb7539ae77aa44ef38e62a5dc0db54670aeacf3bbd01e83f49aa1fd","src/test/json/v2020/summary.json":"2f18c81f989b7c5f70dcb0ddac0520e56ec98b6da25c24e59354a6126c965dae","src/test/json/v2020/system_info.json":"51d1ce922e39a254518a24be56ca86ef1b5843582fb26c1ff0ec4ff6f8f91ccf","src/test/json/v2020/version.json":"ae898c4c9ea3462c3e79f9de755f1fccb4ef122b94a4a512e61aa74491c1a8e9","src/test/json/v2023_07/l11_stats.json":"2eab324f253ced9a0ea4e46466691e0e71fc6fde7558fec86bd5acf6bb9c717d","src/test/json/v2023_07/l11_summary.json":"1e0fdb61b968005d0ec5393d9dc889b09efb1398ffa427629bcc0a98d1b67c22","src/test/json/v2023_07/l11_version.json":"d116921a71731c6e492aed109731c39561e34a24c7df2a88d11ac52b80f6100a","src/test/json/v2023_07/l9_stats.json":"731ee545f16dafd356d22703248b91a37f74585ad73cc27441eb3461ce53dca0","src/test/json/v2023_07/l9_summary.json":"b32b5131ad46859b270d2dbb6bdba3c4e5d7301298daee4ce56332c98faaf81d","src/test/json/v2023_07/l9_version.json":"82f03ca6ea8873f12c4d9455f21b98c547801b58fbff1dcd83c837c0f337a129","src/test/json/v2023_07/mod.rs":"1360a8b155b120f2e755ede0736bcc0d76a9d1d693b984a1b51a16e6c0413791","src/test/mod.rs":"ed52c3d613eabc4a0346bb38bcfdf7a94933d61e368d3c9094821edeab92f81b"},"package":"0c06e3ecbf95ae3fe5e30aacae55cf6e7ad3d965f4a93b2f85c7b64f61fc75e2"}
{"$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":"6e42d50107b1a43fd7cf4a4c4f538468a337ed219ad8d6b23bd9abdabd123bd5","Cargo.lock":"7f984c7231c91f2def8f3e2e923a85c2e0b3239492f5ce23400881ea4de1aa16","Cargo.toml":"8a447efc18cd97d019a9771fb258b06f694499500561564eec75480e46bcc554","Cargo.toml.orig":"6c9e7b86804255debe03545c6358eb975d3d470810a19e6c40c680299a686b1f","src/backends/mod.rs":"65cdc60cdf38968f5a7e197338f4cf6173406ce69a4f0aaa96a9e29f4f581b6e","src/backends/v2020/firmware.rs":"5a41bfb8f42f17523e68f8702e87d75bcdb268bd4950bb66227f6966ef3576a9","src/backends/v2020/mod.rs":"efcaa6b186c8b6e79e9799a647291b895c5ff59f058722e98455ef68bc97c548","src/backends/v2020/rpc.rs":"b517f88b9125fe1d8a20d5167f5d0d105b1339fce3d1a9fad5592e00470f46fb","src/backends/v2020/web.rs":"a6a3ad3eb77551b098b0092553b02cee43d165476d8c92164e12a1e765753b0d","src/backends/v2023_07/firmware.rs":"c07668e351d48dab3e24511b1aa9ab5e408bbcb5a438fdb0542a1377f94b9bbb","src/backends/v2023_07/mod.rs":"0c294d8515c56149571d2a504d68352bdaa206d0b996056f560c2ec60d9927f4","src/backends/v2023_07/rpc.rs":"2b24bbb432b302dd15f7a354054fc96c6a75cac2c8e75b8bcc11da37255a05a3","src/backends/v2023_07/web.rs":"d39b67ed83781b2c4fa84a445b9ffe785ae3001941f800ad9860e050c61c6506","src/firmware.rs":"e75c21d63218204b61bfab067599402e5c0b20452beaf0b16bfa79bf8afb6b35","src/lib.rs":"53f7acddeff8f7d82f80d09e0a9f91962011f9ccf2e441c4ca05cd7fc4eb292e","src/test/json/mod.rs":"a3ef4d6805bb4f8ea087e3a9b875e5a1664580e1ff3e3cd2015bb0c5c18ae7bb","src/test/json/v2020/devs.json":"df17cdfc9522e23450702b93f70ff701892db54c6ce6d986300453ad5e0d22db","src/test/json/v2020/mod.rs":"4c2512d36af834d400a865a94c2e8b1919f9d8dcbf54ab2530c73861c51af67d","src/test/json/v2020/pools.json":"4c4d19ad3ef0de84bfb18daaa48428b5f7917d23287c0196eacf3a6e389e7634","src/test/json/v2020/stats.json":"6d3cb463abb7539ae77aa44ef38e62a5dc0db54670aeacf3bbd01e83f49aa1fd","src/test/json/v2020/summary.json":"2f18c81f989b7c5f70dcb0ddac0520e56ec98b6da25c24e59354a6126c965dae","src/test/json/v2020/system_info.json":"51d1ce922e39a254518a24be56ca86ef1b5843582fb26c1ff0ec4ff6f8f91ccf","src/test/json/v2020/version.json":"ae898c4c9ea3462c3e79f9de755f1fccb4ef122b94a4a512e61aa74491c1a8e9","src/test/json/v2023_07/l11_stats.json":"2eab324f253ced9a0ea4e46466691e0e71fc6fde7558fec86bd5acf6bb9c717d","src/test/json/v2023_07/l11_summary.json":"1e0fdb61b968005d0ec5393d9dc889b09efb1398ffa427629bcc0a98d1b67c22","src/test/json/v2023_07/l11_version.json":"d116921a71731c6e492aed109731c39561e34a24c7df2a88d11ac52b80f6100a","src/test/json/v2023_07/l9_stats.json":"731ee545f16dafd356d22703248b91a37f74585ad73cc27441eb3461ce53dca0","src/test/json/v2023_07/l9_summary.json":"b32b5131ad46859b270d2dbb6bdba3c4e5d7301298daee4ce56332c98faaf81d","src/test/json/v2023_07/l9_version.json":"82f03ca6ea8873f12c4d9455f21b98c547801b58fbff1dcd83c837c0f337a129","src/test/json/v2023_07/mod.rs":"1360a8b155b120f2e755ede0736bcc0d76a9d1d693b984a1b51a16e6c0413791","src/test/mod.rs":"ed52c3d613eabc4a0346bb38bcfdf7a94933d61e368d3c9094821edeab92f81b"},"package":"0c06e3ecbf95ae3fe5e30aacae55cf6e7ad3d965f4a93b2f85c7b64f61fc75e2"}
+20 -4
View File
@@ -833,15 +833,23 @@ impl GetFans for AntMinerV2020 {
let mut fans: Vec<FanData> = Vec::new();
if let Some(stats_data) = data.get(&DataField::Fans) {
for i in 1..=self.device_info.hardware.fans.unwrap_or(4) {
// Some models report their fans in higher fan slots and leave the low
// ones at 0 -- the Z15, for example, has fan_num=2 but reports its two
// fans in fan3/fan4 with fan1/fan2 = 0. So scan a generous range of
// slots and collect the non-zero readings rather than only reading
// fan1..hardware.fans (which missed the Z15 entirely). The collected
// fans are renumbered 0.. in the order found (round 14 #12).
let mut pos: i16 = 0;
for i in 1..=16 {
if let Some(fan_speed) =
stats_data.get(format!("fan{}", i)).and_then(|v| v.as_f64())
&& fan_speed > 0.0
{
fans.push(FanData {
position: (i - 1) as i16,
position: pos,
rpm: Some(AngularVelocity::from_rpm(fan_speed)),
});
pos += 1;
}
}
}
@@ -1103,9 +1111,17 @@ impl SetFaultLight for AntMinerV2020 {
true
}
#[allow(unused_variables)]
async fn set_fault_light(&self, fault: bool) -> anyhow::Result<bool> {
Ok(self.web.blink(fault).await.is_ok())
// `blink()` fires the toggle then reads the state back as `{"isBlinking":
// bool}` (the legacy CGI's own HTTP status is unreliable). Report success
// only when the observed locate-LED state matches what was requested.
let observed = self
.web
.blink(fault)
.await?
.get("isBlinking")
.and_then(serde_json::Value::as_bool);
Ok(observed == Some(fault))
}
}
+81 -13
View File
@@ -240,6 +240,45 @@ impl AntMinerWebAPI {
Ok(response)
}
/// POST a form-encoded (`application/x-www-form-urlencoded`) body to a CGI
/// endpoint and parse the JSON reply. The legacy LuCI web UI endpoints (e.g.
/// `blink.cgi`) expect `action=...` form fields, not a JSON body. An empty
/// reply parses to `{}`; a non-2xx status bails.
async fn send_web_form_command(&self, command: &str, form: &[(&str, &str)]) -> Result<Value> {
let url = format!("http://{}:{}/cgi-bin/{}.cgi", self.ip, self.port, command);
// Build an application/x-www-form-urlencoded body by hand (this reqwest
// build has no `.form()` helper). The only fields used are `action` with
// fixed ASCII values, so percent-encoding is unnecessary.
let body = form
.iter()
.map(|(k, v)| format!("{k}={v}"))
.collect::<Vec<_>>()
.join("&");
let response = self
.client()?
.post(&url)
.header(
reqwest::header::CONTENT_TYPE,
"application/x-www-form-urlencoded",
)
.body(body)
.timeout(self.timeout)
.send_digest_auth((self.auth.username(), self.auth.password()))
.await
.map_err(|e| anyhow!(e.to_string()))?;
let status = response.status();
if !status.is_success() {
bail!("HTTP request failed with status code {}", status);
}
let text = response.text().await.map_err(|e| anyhow!(e.to_string()))?;
if text.trim().is_empty() {
Ok(json!({}))
} else {
serde_json::from_str(&text).map_err(|e| anyhow!(e.to_string()))
}
}
pub async fn get_miner_conf(&self) -> Result<Value> {
self.send_web_command("get_miner_conf", false, None, Method::GET)
.await
@@ -257,17 +296,31 @@ impl AntMinerWebAPI {
}
pub async fn blink(&self, blink: bool) -> Result<Value> {
let param = if blink {
json!({"blink": "true"})
} else {
json!({"blink": "false"})
};
self.send_web_command("blink", false, Some(param), Method::POST)
// Legacy LuCI web UI: the locate LED is toggled by POSTing an `action`
// form field to blink.cgi (`startBlink`/`stopBlink`) -- NOT a JSON body
// like the newer (>= 2023.07) firmware expects. The handler performs the
// action but frequently answers 401/500 even on success, so its HTTP
// status is not a reliable signal: fire it, ignore the response, then read
// the real state back via `onPageLoaded`.
let action = if blink { "startBlink" } else { "stopBlink" };
let _ = self
.send_web_form_command("blink", &[("action", action)])
.await;
self.blink_status().await
}
/// Query the locate-LED state via the legacy blink.cgi `onPageLoaded` action,
/// which reliably answers `200 {"isBlinking": bool}`.
pub async fn blink_status(&self) -> Result<Value> {
self.send_web_form_command("blink", &[("action", "onPageLoaded")])
.await
}
pub async fn reboot(&self) -> Result<Value> {
self.send_web_command("reboot", false, None, Method::POST)
// The legacy LuCI web UI reboots via GET /cgi-bin/reboot.cgi (its own
// reboot.html does `type: 'GET'`); a POST is not what this firmware
// generation expects.
self.send_web_command("reboot", false, None, Method::GET)
.await
}
@@ -350,8 +403,17 @@ impl AntMinerWebAPI {
}
pub async fn get_blink_status(&self) -> Result<Value> {
self.send_web_command("get_blink_status", false, None, Method::GET)
.await
// The old firmware has no `get_blink_status.cgi` (it answers 404); the
// locate state lives behind blink.cgi's `onPageLoaded` action as
// `{"isBlinking": bool}`. Remap it to `{"blink": bool}` so the shared
// LightFlashing extractor (key `/blink`) keeps working.
let flashing = self
.blink_status()
.await?
.get("isBlinking")
.and_then(Value::as_bool)
.unwrap_or(false);
Ok(json!({ "blink": flashing }))
}
pub async fn set_network_conf(
@@ -383,10 +445,16 @@ impl APIClient for AntMinerWebAPI {
MinerCommand::WebAPI {
command,
parameters,
} => self
.send_web_command(command, false, parameters.clone(), Method::GET)
.await
.map_err(|e| anyhow!(e.to_string())),
} => {
// The legacy blink status lives behind a POST form action, not a
// GET .cgi (which 404s), so route it through the dedicated helper.
if *command == "get_blink_status" {
return self.get_blink_status().await;
}
self.send_web_command(command, false, parameters.clone(), Method::GET)
.await
.map_err(|e| anyhow!(e.to_string()))
}
_ => Err(anyhow!("Unsupported command type for Web client")),
}
}
@@ -521,8 +521,40 @@ impl GetDataLocations for AntMinerV202307 {
tag: None,
},
),
// Bixbit-based firmware reports Power=0 in stats but the real
// figure as "Power Estimated" in the cgminer summary; carry it
// under a "summary" tag so parse_wattage can fall back to it
// without colliding with the stats keys (round 17 R7).
(
RPC_SUMMARY,
DataExtractor {
func: get_by_pointer,
key: Some("/SUMMARY/0"),
tag: Some("summary"),
},
),
]
}
// Best share (all-time / session) from the cgminer summary. Antminer
// stock, Bixbit, and other cgminer-based firmware all report it here;
// it was previously unmapped, so best-share was blank fleet-wide
// (round 17 R7).
DataField::BestShare => vec![(
RPC_SUMMARY,
DataExtractor {
func: get_by_pointer,
key: Some("/SUMMARY/0/Best Share"),
tag: None,
},
)],
DataField::SessionBestShare => vec![(
RPC_SUMMARY,
DataExtractor {
func: get_by_pointer,
key: Some("/SUMMARY/0/Best Session Share"),
tag: None,
},
)],
DataField::SerialNumber => vec![
(
WEB_SYSTEM_INFO,
@@ -778,8 +810,6 @@ impl GetUptime for AntMinerV202307 {
}
}
impl GetBestShare for AntMinerV202307 {}
impl GetSessionBestShare for AntMinerV202307 {}
impl GetOperatingState for AntMinerV202307 {}
@@ -888,21 +918,52 @@ impl GetWattage for AntMinerV202307 {
}
}
if let Some(power) = stats_data
let primary = stats_data
.get("power")
.or_else(|| stats_data.get("Power"))
// Same firmware version spells this differently per model: the
// L9 reports `power`, the L11 `watt`.
.or_else(|| stats_data.get("watt"))
.and_then(|v| v.as_f64())
.and_then(|v| v.as_f64());
if let Some(power) = primary
&& power > 0.0
{
return Some(Power::from_watts(power));
}
// Bixbit-based firmware leaves the stats power at 0 and reports the
// real draw as "Power Estimated" in the summary (round 17 R7).
if let Some(est) = stats_data
.pointer("/summary/Power Estimated")
.and_then(|v| v.as_f64())
&& est > 0.0
{
return Some(Power::from_watts(est));
}
// Preserve the prior behaviour: a present-but-zero stats power still
// reads as 0 W rather than blank.
if let Some(power) = primary {
return Some(Power::from_watts(power));
}
}
None
}
}
impl GetBestShare for AntMinerV202307 {
fn parse_best_share(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
// cgminer summary "Best Share" (all-time). Guard against a firmware that
// reports 0 when it has never found a share (round 17 R7).
data.extract::<f64>(DataField::BestShare).filter(|&v| v > 0.0)
}
}
impl GetSessionBestShare for AntMinerV202307 {
fn parse_session_best_share(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
data.extract::<f64>(DataField::SessionBestShare)
.filter(|&v| v > 0.0)
}
}
impl GetTuningTarget for AntMinerV202307 {
fn parse_tuning_target(&self, data: &HashMap<DataField, Value>) -> Option<TuningTarget> {
data.get(&DataField::TuningTarget)
File diff suppressed because one or more lines are too long
+15 -1
View File
@@ -286,6 +286,14 @@ impl GetDataLocations for BraiinsV2604 {
tag: None,
},
)],
DataField::BestShare => vec![(
WEB_MINER_STATS,
DataExtractor {
func: get_by_pointer,
key: Some("/miner_stats/best_share"),
tag: None,
},
)],
DataField::TuningTarget => vec![
(
WEB_MINER_CONFIGURATION,
@@ -548,7 +556,13 @@ impl GetUptime for BraiinsV2604 {
}
}
impl GetBestShare for BraiinsV2604 {}
impl GetBestShare for BraiinsV2604 {
fn parse_best_share(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
// Braiins OS reports the all-time best share at miner/stats -> miner_stats.best_share
// (round 16 / G9). Large diffs may exceed f64 exactness but are fine for display.
data.extract::<f64>(DataField::BestShare)
}
}
impl GetSessionBestShare for BraiinsV2604 {}
impl GetOperatingState for BraiinsV2604 {
+29 -5
View File
@@ -57,11 +57,20 @@ impl WebAPIClient for BraiinsWebAPI {
let status = response.status();
if status.is_success() {
let json_data = response
.json()
// Some setters (e.g. PUT auth/password) answer 2xx with an empty or
// non-JSON body. An empty body is success, not a parse error -- treat
// it as Null so callers using `.is_ok()` don't read a real success as
// failure. A non-empty body must still parse.
let body = response
.text()
.await
.map_err(|e| BraiinsError::ParseError(e.to_string()))?;
Ok(json_data)
if body.trim().is_empty() {
Ok(Value::Null)
} else {
Ok(serde_json::from_str(&body)
.map_err(|e| BraiinsError::ParseError(e.to_string()))?)
}
} else {
// The API reports why it rejected a request in the body.
let status = status.as_u16();
@@ -78,7 +87,13 @@ impl BraiinsWebAPI {
client: OnceCell::new(),
ip,
port: 80,
timeout: Duration::from_secs(5),
// Braiins get_data fans out to ~12 authenticated REST calls that run
// concurrently. A healthy miner answers well under a second; the extra
// headroom over the old 5 s is defensive so a call that queues behind a
// scan burst still completes instead of dropping miner/stats
// (hashrate/watts/best-share). The real fix for the fleet-scan dropout
// is the app-side scan concurrency cap (see scan::SCAN_CONCURRENCY_LIMIT).
timeout: Duration::from_secs(15),
bearer_token: RwLock::new(None),
auth,
}
@@ -113,13 +128,22 @@ impl BraiinsWebAPI {
return Ok(());
}
// Single-flight the login: get_data fires ~12 commands concurrently, and
// without this they would ALL see no token and each POST /auth/login (a
// thundering herd that doubles the connection load and races under a
// high-concurrency fleet scan, dropping most values). Hold the write lock
// across the login so exactly one call authenticates and the rest reuse it.
let mut guard = self.bearer_token.write().await;
if guard.is_some() {
return Ok(());
}
let token = match &self.auth {
MinerAuth::TokenAuth(token) => token.expose_secret().to_string(),
MinerAuth::UserAndPass(creds) => {
self.authenticate(creds.password.expose_secret()).await?
}
};
*self.bearer_token.write().await = Some(token);
*guard = Some(token);
Ok(())
}
+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":"4c9489c1f9b5f16e3fd8ab777da35bb120ccd0ca05f780cf94853c89fb5c8946","Cargo.lock":"69db8793725d6071e21b4353fb89537912096d7eccebd6ee597367330141f613","Cargo.toml":"df82261a9c3187bee15a7d6092d54ad2e9c7e4d1f127cd577c457d913f6881cf","Cargo.toml.orig":"e7c4ef90bc86763dad35d1a4da1c17c7e2f59eaac79e2f011647ae31c43d5e2b","src/backends/mod.rs":"1362c4d3805dccb7a78ef6b45d6a81b8f63b2be75fcf80329b6c2b0dd9e2d5c5","src/backends/v1/mod.rs":"360f173deb62c38bceb907774be6caaea5814b4f543d8d7f3c72828db31640b9","src/backends/v1/web.rs":"3a567a4f581baa5d9d2d4e59d8acc754eec51d49b0a4f5434d87614b037a4a55","src/firmware.rs":"fb88124a51089756cc3271f3d4a234d73add61ab919c4710ef26a52dc8b5ef80","src/lib.rs":"53f7acddeff8f7d82f80d09e0a9f91962011f9ccf2e441c4ca05cd7fc4eb292e","src/test/json/mod.rs":"24191681066d5cf6a3022ad59c1baa92b57e3ce7717bb78d6a682af9e19a38c4","src/test/json/v1/capabilities.json":"d2b3dae7aa2a1e2977e0ddf62cf2d730de64cf12bf62388c12fd23dc5278bbcb","src/test/json/v1/chip_clocks.json":"d1f46d3aad6ad55ec1c02d0b26aa4c5034c1ccaefb130d7b0e46efe48bb122a0","src/test/json/v1/chip_hashrates.json":"9601a1289f93fe4e27c722d51b3a31daa71aec71f2c29e71f6d1eefe01edf7f2","src/test/json/v1/chip_temps.json":"cb7390e424af57f55f0c974ddfe0c98c4d5b4dbcd85887e38ff8caf7b19f62fe","src/test/json/v1/chip_voltages.json":"cb7390e424af57f55f0c974ddfe0c98c4d5b4dbcd85887e38ff8caf7b19f62fe","src/test/json/v1/mod.rs":"5671105221b84b0b6edb2df34b25bfc9e33459da285d4316be0db23ddb630e8d","src/test/json/v1/network.json":"3374b419fa2f0bc19544c670e08118bbc45bd4d121a577c5a6403c8c8100f628","src/test/json/v1/summary.json":"ac8ac018da9d619b5884f283b730bad2bf0a7e8f2032a7119193c9e5d87d6a7c","src/test/json/v1/temps.json":"794edf870985ed4398ead96670b8f5d01deb4d825fb14a8325087a29cd939fa8","src/test/mod.rs":"ed52c3d613eabc4a0346bb38bcfdf7a94933d61e368d3c9094821edeab92f81b"},"package":"268dc7c8b3289fccd3230ff87f7bfc727a3e7e2f6f72ae56ab9d27c63eabc5cf"}
{"$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":"4c9489c1f9b5f16e3fd8ab777da35bb120ccd0ca05f780cf94853c89fb5c8946","Cargo.lock":"69db8793725d6071e21b4353fb89537912096d7eccebd6ee597367330141f613","Cargo.toml":"df82261a9c3187bee15a7d6092d54ad2e9c7e4d1f127cd577c457d913f6881cf","Cargo.toml.orig":"e7c4ef90bc86763dad35d1a4da1c17c7e2f59eaac79e2f011647ae31c43d5e2b","src/backends/mod.rs":"1362c4d3805dccb7a78ef6b45d6a81b8f63b2be75fcf80329b6c2b0dd9e2d5c5","src/backends/v1/mod.rs":"dff1b68393fd0a065dc67a16219654f279cbfb9adad2eaea35caedea26df989f","src/backends/v1/web.rs":"3a567a4f581baa5d9d2d4e59d8acc754eec51d49b0a4f5434d87614b037a4a55","src/firmware.rs":"fb88124a51089756cc3271f3d4a234d73add61ab919c4710ef26a52dc8b5ef80","src/lib.rs":"53f7acddeff8f7d82f80d09e0a9f91962011f9ccf2e441c4ca05cd7fc4eb292e","src/test/json/mod.rs":"24191681066d5cf6a3022ad59c1baa92b57e3ce7717bb78d6a682af9e19a38c4","src/test/json/v1/capabilities.json":"d2b3dae7aa2a1e2977e0ddf62cf2d730de64cf12bf62388c12fd23dc5278bbcb","src/test/json/v1/chip_clocks.json":"d1f46d3aad6ad55ec1c02d0b26aa4c5034c1ccaefb130d7b0e46efe48bb122a0","src/test/json/v1/chip_hashrates.json":"9601a1289f93fe4e27c722d51b3a31daa71aec71f2c29e71f6d1eefe01edf7f2","src/test/json/v1/chip_temps.json":"cb7390e424af57f55f0c974ddfe0c98c4d5b4dbcd85887e38ff8caf7b19f62fe","src/test/json/v1/chip_voltages.json":"cb7390e424af57f55f0c974ddfe0c98c4d5b4dbcd85887e38ff8caf7b19f62fe","src/test/json/v1/mod.rs":"5671105221b84b0b6edb2df34b25bfc9e33459da285d4316be0db23ddb630e8d","src/test/json/v1/network.json":"3374b419fa2f0bc19544c670e08118bbc45bd4d121a577c5a6403c8c8100f628","src/test/json/v1/summary.json":"ac8ac018da9d619b5884f283b730bad2bf0a7e8f2032a7119193c9e5d87d6a7c","src/test/json/v1/temps.json":"794edf870985ed4398ead96670b8f5d01deb4d825fb14a8325087a29cd939fa8","src/test/mod.rs":"ed52c3d613eabc4a0346bb38bcfdf7a94933d61e368d3c9094821edeab92f81b"},"package":"268dc7c8b3289fccd3230ff87f7bfc727a3e7e2f6f72ae56ab9d27c63eabc5cf"}
+48
View File
@@ -24,6 +24,7 @@ use asic_rs_core::{
miner::TuningTarget,
operating_state::OperatingState,
pool::{PoolData, PoolGroupData, PoolURL},
psu::PsuInfo,
},
traits::{miner::*, model::MinerModel},
util::unix_timestamp_secs,
@@ -436,6 +437,26 @@ impl GetDataLocations for PowerPlayV1 {
tag: None,
},
)],
// PSU: live stats from summary + rated envelope/identity from
// capabilities, tagged so parse_psu can read both (round 17 R5/G15).
DataField::Psu => vec![
(
WEB_SUMMARY,
DataExtractor {
func: get_by_pointer,
key: Some("/Power Supply Stats"),
tag: Some("stats"),
},
),
(
WEB_CAPABILITIES,
DataExtractor {
func: get_by_pointer,
key: Some("/Psu Info"),
tag: Some("info"),
},
),
],
DataField::TuningTarget => vec![(
WEB_SUMMARY,
DataExtractor {
@@ -1095,6 +1116,25 @@ impl GetWattage for PowerPlayV1 {
fn parse_wattage(&self, data: &HashMap<DataField, Value>) -> Option<Power> {
data.extract_map::<f64, _>(DataField::Wattage, Power::from_watts)
}
fn parse_psu(&self, data: &HashMap<DataField, Value>) -> Option<PsuInfo> {
// DataField::Psu is the merged {stats: Power Supply Stats, info: Psu Info}
// (see get_locations). capabilities Vout + summary Target Voltage are in
// millivolts; summary Output Voltage/Current are already volts/amps.
let d = data.get(&DataField::Psu)?;
let stats = d.pointer("/stats");
let info = d.pointer("/info");
let f = |v: Option<&Value>, key: &str| v.and_then(|o| o.pointer(key)).and_then(tuning_value_as_f64);
let psu = PsuInfo {
model: f(info, "/PSU Type").map(|n| format!("{n:.0}")),
version: f(info, "/FW").map(|n| format!("{n:.0}")),
voltage_min: f(info, "/Min Vout").map(|mv| mv / 1000.0),
voltage_max: f(info, "/Max Vout").map(|mv| mv / 1000.0),
output_voltage: f(stats, "/Output Voltage"),
output_current: f(stats, "/Output Current"),
};
(psu != PsuInfo::default()).then_some(psu)
}
}
fn tuning_value_as_f64(value: &Value) -> Option<f64> {
@@ -1369,6 +1409,14 @@ impl SetFaultLight for PowerPlayV1 {
#[async_trait]
impl SetPowerLimit for PowerPlayV1 {
fn supports_set_power_limit(&self) -> bool {
// ePIC PowerPlay's only true power-limit mechanism is the PowerTune
// perpetual-tune algorithm, which the firmware gates on the PSU: on a
// fixed-voltage Bitmain PSU (e.g. the APW12 on an S19j Pro) the
// perpetualtune/algo endpoint rejects it with "Power optimization is not
// supported by this PSU". Since that support is a per-PSU runtime property
// that this synchronous, no-I/O capability check cannot observe, report
// false rather than over-advertise a control that fails on most reflashed
// Antminers. (Hashrate tuning is exposed separately via set_tuning_config.)
false
}
}
+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":"fc109beb7fa4713b5f7a6d717e225ff91baa6f8ef497bc770a435f92981c2879","src/backends/v1/rpc.rs":"9dea9c65629e1e9b833b96a4ae88014f7195a26036104f92daa264fbdf13feba","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"}
+133 -3
View File
@@ -445,6 +445,22 @@ impl GetDataLocations for LuxMinerV1 {
tag: None,
},
)],
DataField::BestShare => vec![(
RPC_SUMMARY,
DataExtractor {
func: get_by_pointer,
key: Some("/SUMMARY/0/Best Share"),
tag: None,
},
)],
DataField::SessionBestShare => vec![(
RPC_SUMMARY,
DataExtractor {
func: get_by_pointer,
key: Some("/SUMMARY/0/Best Session Share"),
tag: None,
},
)],
DataField::Uptime => vec![(
RPC_STATS,
DataExtractor {
@@ -888,8 +904,18 @@ impl GetUptime for LuxMinerV1 {
}
}
impl GetBestShare for LuxMinerV1 {}
impl GetSessionBestShare for LuxMinerV1 {}
impl GetBestShare for LuxMinerV1 {
fn parse_best_share(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
// LuxOS summary -> "Best Share" (all-time), round 16 / G9.
data.extract::<f64>(DataField::BestShare)
}
}
impl GetSessionBestShare for LuxMinerV1 {
fn parse_session_best_share(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
// LuxOS summary -> "Best Session Share" (since boot), round 16 / G9.
data.extract::<f64>(DataField::SessionBestShare)
}
}
impl GetOperatingState for LuxMinerV1 {}
@@ -1052,10 +1078,72 @@ impl SetFaultLight for LuxMinerV1 {
}
}
/// 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")
.and_then(Value::as_array)
.map(|arr| {
arr.iter()
.filter_map(|p| {
let name = p.get("Profile Name").and_then(Value::as_str)?.to_string();
let watts = p.get("Watts").and_then(Value::as_f64)?;
Some((name, watts))
})
.collect()
})
.unwrap_or_default()
}
/// 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.
fn select_profile_at_or_below(steps: &[(String, f64)], target_w: f64) -> Option<String> {
if steps.is_empty() {
return None;
}
let mut sorted: Vec<&(String, f64)> = steps.iter().collect();
sorted.sort_by(|a, b| a.1.partial_cmp(&b.1).unwrap_or(std::cmp::Ordering::Equal));
sorted
.iter()
.rev()
.find(|(_, w)| *w <= target_w)
.or_else(|| sorted.first())
.map(|(s, _)| s.clone())
}
#[async_trait]
impl SetPowerLimit for LuxMinerV1 {
fn supports_set_power_limit(&self) -> bool {
false
true
}
async fn set_power_limit(&self, power: Power) -> anyhow::Result<bool> {
// LuxOS tunes by discrete named profiles (each carries a Watts rating),
// not a raw watts setpoint. Map the requested limit to the highest profile
// whose Watts does not exceed it (or the lowest profile when the target is
// below every profile), then apply it with profileset.
let profiles = self.rpc.profiles().await?;
let steps = parse_profile_watts(&profiles);
let Some(chosen) = select_profile_at_or_below(&steps, power.as_watts()) else {
anyhow::bail!("LuxOS reported no tunable profiles with a Step/Watts pair");
};
let resp = self.rpc.profileset(&chosen).await?;
// LuxOS answers with a STATUS array; "S"/"I" is success. A missing status
// after a non-error reply is treated as applied.
Ok(resp
.pointer("/STATUS/0/STATUS")
.and_then(Value::as_str)
.map(|s| matches!(s, "S" | "I"))
.unwrap_or(true))
}
}
@@ -1231,6 +1319,48 @@ mod tests {
POWER, PROFILES, STATS, SUMMARY, TEMPS, VERSION, VOLTAGEGET_0, VOLTAGEGET_1, VOLTAGEGET_2,
};
#[test]
fn power_limit_profile_selection() {
// 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![
("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("405MHz")
);
assert_eq!(
select_profile_at_or_below(&steps, 2790.0).as_deref(),
Some("455MHz")
);
// 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("default")
);
// Below every profile -> the minimum profile.
assert_eq!(
select_profile_at_or_below(&steps, 100.0).as_deref(),
Some("190MHz")
);
// No profiles -> nothing to choose.
assert_eq!(select_profile_at_or_below(&[], 2500.0), None);
// parse_profile_watts against the captured LuxOS `profiles` reply: it
// yields tunable profiles and selection finds a real step among them.
let profiles: Value = serde_json::from_str(PROFILES).unwrap();
let parsed = parse_profile_watts(&profiles);
assert!(!parsed.is_empty(), "fixture should carry tunable profiles");
assert!(select_profile_at_or_below(&parsed, 2500.0).is_some());
}
#[tokio::test]
async fn test_luxminer_v1() -> anyhow::Result<()> {
+16 -7
View File
@@ -239,7 +239,7 @@ impl LUXMinerRPCAPI {
pub async fn addgroup(&self, name: &str, quota: u32) -> anyhow::Result<Value> {
self.send_command(
"addgroup",
false,
true,
Some(Value::String(format!("{name},{quota}"))),
)
.await
@@ -248,7 +248,7 @@ impl LUXMinerRPCAPI {
pub async fn groupquota(&self, group_id: u32, quota: u32) -> anyhow::Result<Value> {
self.send_command(
"groupquota",
false,
true,
Some(Value::String(format!("{group_id},{quota}"))),
)
.await
@@ -257,7 +257,7 @@ impl LUXMinerRPCAPI {
pub async fn removegroup(&self, group_id: u32) -> anyhow::Result<Value> {
self.send_command(
"removegroup",
false,
true,
Some(Value::String(group_id.to_string())),
)
.await
@@ -275,14 +275,14 @@ impl LUXMinerRPCAPI {
params.push(group_id);
}
self.send_command("addpool", false, Some(Value::String(params.join(","))))
self.send_command("addpool", true, Some(Value::String(params.join(","))))
.await
}
pub async fn switchpool(&self, pool_id: i32) -> anyhow::Result<Value> {
self.send_command(
"switchpool",
false,
true,
Some(Value::String(pool_id.to_string())),
)
.await
@@ -291,7 +291,7 @@ impl LUXMinerRPCAPI {
pub async fn enablepool(&self, pool_id: i32) -> anyhow::Result<Value> {
self.send_command(
"enablepool",
false,
true,
Some(Value::String(pool_id.to_string())),
)
.await
@@ -300,7 +300,16 @@ impl LUXMinerRPCAPI {
pub async fn disablepool(&self, pool_id: i32) -> anyhow::Result<Value> {
self.send_command(
"disablepool",
false,
true,
Some(Value::String(pool_id.to_string())),
)
.await
}
pub async fn removepool(&self, pool_id: i32) -> anyhow::Result<Value> {
self.send_command(
"removepool",
true,
Some(Value::String(pool_id.to_string())),
)
.await
+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":"30f09ad063df45fdf223aff235fe2da15cb1a7e79e86d7012074153b91662fc4","Cargo.lock":"9d0886791db53421d3218ab72d964145b86cfbe9738eaf09aac5d3c89a1c0190","Cargo.toml":"8c2e9938436850f2e250e8268ed7b385fce903e2077923b207a0560ca3e3242c","Cargo.toml.orig":"891fcfa45e79d6bc4d838c4f3075618f791bd013c99231da48e752b987f409d5","src/backends/mod.rs":"0f5a0ae31d5443d0d0f41a2540def806196238c92d22761b3ad9843cb2e77f45","src/backends/v1/mod.rs":"e46575e2bea28ad2933c09c69d0324e3fe1407fe42736b2f1882ec52721cc042","src/backends/v1/rpc.rs":"4cee9caeb9bc291c4efec04f4b7fc2b8eaead904a1f2d0f30e13236476d9aac5","src/backends/v2/mod.rs":"68fd8c1762b424a7785174fdb3ae4fede1d599632657808d4b7c76bcfbfb202c","src/backends/v2/rpc.rs":"b7afc5357d24de42350d4ec15a6b5a37698e4fd77b2c2cc8071f303ee62e957c","src/backends/v3/mod.rs":"f19e673c47c2cc366e2ff7782bca93daf750563d62221a12a043b3ee79a15251","src/backends/v3/rpc.rs":"7a5f80aec4af1bcaa0d36e67345aa9acbbd8ead73c0be474f06305358b38e81b","src/error_codes.rs":"de85845f52b1d4e1a0bff73462cef00962b60fad8a3ed71c7bb083c02df3a413","src/firmware.rs":"6d002e481ce0a897c0485b9393b0382fcb25811164e893eb8eb67b2ff392ca0d","src/lib.rs":"710b46c9d934f26f900e1366ca1df5f872896e7d8da03569c0f159859e899cc9","src/test/json/mod.rs":"99760925ccfefc40d2455d3567fb1ecfc99e9e55e70478190ef372a954825909","src/test/json/v1/devs.json":"b4fd010f0bae3584efde93387cf2dab5933b499cc30a2dd7635fdc994b56c3b8","src/test/json/v1/get_psu.json":"8c11b6495e0bd5da496dd5c10ca53ec53b2d8fe9a3737f470ec9ce2c1aaf9d99","src/test/json/v1/get_version.json":"c43e947e654792ab191210d50c6f793ee0dd7af41e8cb59f0722b70f32a203bc","src/test/json/v1/mod.rs":"e79509eee78a1fef63735afe385299813726822c8259a02d1dcf5e8b4db9d04e","src/test/json/v1/pools.json":"b570808a3428a0773d7d2ee322150d8fd0794a33804af970300a7fef128a8a01","src/test/json/v1/status.json":"00ec38dd9f980b7ac0ffd6f815374afdbbed98d601bd8ef18bcf0f76ae0aa853","src/test/json/v1/summary.json":"d6e3e75654eb4019e1f479b3d9cf3097130f1afb85dd3338682c094fd4ab498a","src/test/json/v1/summary_with_errors.json":"1ba682f6ad5c43e41ae22a4069d0f52f04da3f07a18031bf4c07e07b3c59cc97","src/test/json/v2/devs.json":"2d203e41ef6ef337c0c81456b73d08730882c3167403c557c3c9776022a972d1","src/test/json/v2/get_error_code.json":"e90b702fd97bceb4f62dcb8228f75ff5ce930290355dca94eefd7192f7f57009","src/test/json/v2/get_error_code_with_errors.json":"6cb6038366eb3835684421c41be0b2b30ae8ce79a7ed51a85f4f52f70da9df16","src/test/json/v2/get_miner_info.json":"55d2af984833a692f502188ae4df4e41bdc10386b47f921c896a452ef1de9062","src/test/json/v2/get_psu.json":"b43086b65897061521d1f6611e200ef372a1724f9ea1876e347c03d5fb19b8f2","src/test/json/v2/get_version.json":"b17e3a81603b43186b2e15745e6822b6c82b3c6f5928b22f84e683d7728dbfcd","src/test/json/v2/mod.rs":"c847205d076323bbd9698e393d241b08f3cf75d32aae86f7058cf8748266b935","src/test/json/v2/pools.json":"926d34e8dae774473ebfec83d4a38e77ca73231708f07683763e212be7af0580","src/test/json/v2/status.json":"fc268cd23864ef99e84813dbf8eb916b2e6f339351a0ee5dab217cbe02569fc3","src/test/json/v2/summary.json":"4e4c01b986e2960893f58d0f1ea4dce23b8ef88db4985348f7f0183eb4818478","src/test/json/v3/get_device_info.json":"83ac22ea9a11adbceb4c963db80aa62d9a2aa50d019a372394dece817d924cda","src/test/json/v3/get_device_info_with_errors.json":"24cee4b7840e87e12147cbfddf6c361f3b378a15bb85330b339d3be9e17cdbd5","src/test/json/v3/get_miner_status_edevs.json":"2d831c06113f555e0988df994c2e602a053a4aea603dded0db8f0f80e191ca5a","src/test/json/v3/get_miner_status_pools.json":"cd65c2efd3a5ce80b57aae46c420298a34ca06df7ac7f8c36fd556217703d242","src/test/json/v3/get_miner_status_summary.json":"799a94ba13ef54aed0f81a3d041d6c1fa263d4183754b384c69ca12d85a8d3ba","src/test/json/v3/mod.rs":"7ea3a8ff1b81c7a5b0f44f7c12dda880a9aeac5b0e6b56ac4fff4f4a7cbfe451","src/test/mod.rs":"ed52c3d613eabc4a0346bb38bcfdf7a94933d61e368d3c9094821edeab92f81b"},"package":"c85da6325b62f061327dc5f7605dd3721c823a9e8a2cfd6a356363dfbc84d66e"}
{"$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":"30f09ad063df45fdf223aff235fe2da15cb1a7e79e86d7012074153b91662fc4","Cargo.lock":"9d0886791db53421d3218ab72d964145b86cfbe9738eaf09aac5d3c89a1c0190","Cargo.toml":"8c2e9938436850f2e250e8268ed7b385fce903e2077923b207a0560ca3e3242c","Cargo.toml.orig":"891fcfa45e79d6bc4d838c4f3075618f791bd013c99231da48e752b987f409d5","src/backends/mod.rs":"0f5a0ae31d5443d0d0f41a2540def806196238c92d22761b3ad9843cb2e77f45","src/backends/v1/mod.rs":"3a8bdecd1eb271de474b2aca85b5f8e598ba64fe5defc9c8dd9b8c66444a2ed4","src/backends/v1/rpc.rs":"72f9b67c2389ab6e9968e0eb340bd2b6aad9aaf059f4429eb31398863bb87f42","src/backends/v2/mod.rs":"68fd8c1762b424a7785174fdb3ae4fede1d599632657808d4b7c76bcfbfb202c","src/backends/v2/rpc.rs":"52f8d504c236009b020bf33b5550236e36d07b2c73a15bdcfcafa5188e4e1cb6","src/backends/v3/mod.rs":"f19e673c47c2cc366e2ff7782bca93daf750563d62221a12a043b3ee79a15251","src/backends/v3/rpc.rs":"7a5f80aec4af1bcaa0d36e67345aa9acbbd8ead73c0be474f06305358b38e81b","src/error_codes.rs":"b2af610880fb400a9e6297662371a6b3b55077b72cf11115b77fd4d2df44e6a1","src/firmware.rs":"6d002e481ce0a897c0485b9393b0382fcb25811164e893eb8eb67b2ff392ca0d","src/lib.rs":"710b46c9d934f26f900e1366ca1df5f872896e7d8da03569c0f159859e899cc9","src/test/json/mod.rs":"99760925ccfefc40d2455d3567fb1ecfc99e9e55e70478190ef372a954825909","src/test/json/v1/devs.json":"b4fd010f0bae3584efde93387cf2dab5933b499cc30a2dd7635fdc994b56c3b8","src/test/json/v1/get_psu.json":"8c11b6495e0bd5da496dd5c10ca53ec53b2d8fe9a3737f470ec9ce2c1aaf9d99","src/test/json/v1/get_version.json":"c43e947e654792ab191210d50c6f793ee0dd7af41e8cb59f0722b70f32a203bc","src/test/json/v1/mod.rs":"e79509eee78a1fef63735afe385299813726822c8259a02d1dcf5e8b4db9d04e","src/test/json/v1/pools.json":"b570808a3428a0773d7d2ee322150d8fd0794a33804af970300a7fef128a8a01","src/test/json/v1/status.json":"00ec38dd9f980b7ac0ffd6f815374afdbbed98d601bd8ef18bcf0f76ae0aa853","src/test/json/v1/summary.json":"d6e3e75654eb4019e1f479b3d9cf3097130f1afb85dd3338682c094fd4ab498a","src/test/json/v1/summary_with_errors.json":"1ba682f6ad5c43e41ae22a4069d0f52f04da3f07a18031bf4c07e07b3c59cc97","src/test/json/v2/devs.json":"2d203e41ef6ef337c0c81456b73d08730882c3167403c557c3c9776022a972d1","src/test/json/v2/get_error_code.json":"e90b702fd97bceb4f62dcb8228f75ff5ce930290355dca94eefd7192f7f57009","src/test/json/v2/get_error_code_with_errors.json":"6cb6038366eb3835684421c41be0b2b30ae8ce79a7ed51a85f4f52f70da9df16","src/test/json/v2/get_miner_info.json":"55d2af984833a692f502188ae4df4e41bdc10386b47f921c896a452ef1de9062","src/test/json/v2/get_psu.json":"b43086b65897061521d1f6611e200ef372a1724f9ea1876e347c03d5fb19b8f2","src/test/json/v2/get_version.json":"b17e3a81603b43186b2e15745e6822b6c82b3c6f5928b22f84e683d7728dbfcd","src/test/json/v2/mod.rs":"c847205d076323bbd9698e393d241b08f3cf75d32aae86f7058cf8748266b935","src/test/json/v2/pools.json":"926d34e8dae774473ebfec83d4a38e77ca73231708f07683763e212be7af0580","src/test/json/v2/status.json":"fc268cd23864ef99e84813dbf8eb916b2e6f339351a0ee5dab217cbe02569fc3","src/test/json/v2/summary.json":"4e4c01b986e2960893f58d0f1ea4dce23b8ef88db4985348f7f0183eb4818478","src/test/json/v3/get_device_info.json":"83ac22ea9a11adbceb4c963db80aa62d9a2aa50d019a372394dece817d924cda","src/test/json/v3/get_device_info_with_errors.json":"24cee4b7840e87e12147cbfddf6c361f3b378a15bb85330b339d3be9e17cdbd5","src/test/json/v3/get_miner_status_edevs.json":"2d831c06113f555e0988df994c2e602a053a4aea603dded0db8f0f80e191ca5a","src/test/json/v3/get_miner_status_pools.json":"cd65c2efd3a5ce80b57aae46c420298a34ca06df7ac7f8c36fd556217703d242","src/test/json/v3/get_miner_status_summary.json":"799a94ba13ef54aed0f81a3d041d6c1fa263d4183754b384c69ca12d85a8d3ba","src/test/json/v3/mod.rs":"7ea3a8ff1b81c7a5b0f44f7c12dda880a9aeac5b0e6b56ac4fff4f4a7cbfe451","src/test/mod.rs":"ed52c3d613eabc4a0346bb38bcfdf7a94933d61e368d3c9094821edeab92f81b"},"package":"c85da6325b62f061327dc5f7605dd3721c823a9e8a2cfd6a356363dfbc84d66e"}
+35 -20
View File
@@ -117,6 +117,10 @@ impl GetDataLocations for WhatsMinerV1 {
command: "get_psu",
parameters: None,
};
const RPC_GET_ERROR_CODE: MinerCommand = MinerCommand::RPC {
command: "get_error_code",
parameters: None,
};
match data_field {
DataField::Mac => vec![(
@@ -254,10 +258,10 @@ impl GetDataLocations for WhatsMinerV1 {
},
)],
DataField::Messages => vec![(
RPC_SUMMARY,
RPC_GET_ERROR_CODE,
DataExtractor {
func: get_by_pointer,
key: Some("/SUMMARY/0"),
key: Some("/Msg/error_code"),
tag: None,
},
)],
@@ -471,32 +475,43 @@ impl GetTuningCapabilities for WhatsMinerV1 {}
impl GetLightFlashing for WhatsMinerV1 {}
impl GetMessages for WhatsMinerV1 {
fn parse_messages(&self, data: &HashMap<DataField, Value>) -> Vec<MinerMessage> {
// WhatsMiner V1 (H6OS) reports faults via get_error_code -> Msg.error_code,
// an array of {code: timestamp} objects (the same shape as V2/V3; the RPC
// layer repairs the occasional invalid bare-pair array first). The older
// summary "Error Code N" fields are frequently empty on these units.
let mut messages = Vec::new();
let error_count = data
.get(&DataField::Messages)
.and_then(|val| {
val.pointer("/Error Code Count")
.and_then(|val| val.as_u64())
})
.unwrap_or(0u64) as usize;
for idx in 0..error_count {
let e_code = data
.get(&DataField::Messages)
.and_then(|val| val.pointer(&format!("/Error Code {}", idx)))
.and_then(|val| val.as_u64());
if let Some(code) = e_code {
let info = crate::error_codes::error_info(code);
let Some(errors) = data.get(&DataField::Messages) else {
return messages;
};
for obj in errors.as_array().unwrap_or(&Vec::new()).iter() {
let Some(obj) = obj.as_object() else {
continue;
};
for (code, time) in obj.iter() {
let Some(time_str) = time.as_str() else {
continue;
};
let timestamp =
chrono::NaiveDateTime::parse_from_str(time_str, "%Y-%m-%d %H:%M:%S")
.map(|t| {
chrono::DateTime::<chrono::Utc>::from_naive_utc_and_offset(
t,
chrono::Utc,
)
})
.map(|dt| dt.timestamp() as u32)
.unwrap_or(0);
let parsed_code = code.parse::<u64>().unwrap_or(0);
let info = crate::error_codes::error_info(parsed_code);
messages.push(MinerMessage::with_component(
0,
code,
timestamp,
parsed_code,
info.message,
MessageSeverity::Error,
info.component,
));
}
}
messages
}
}
@@ -106,6 +106,9 @@ impl RPCAPIClient for WhatsMinerRPCAPI {
let response = response
.replace('\n', "") // Fix for WM V1, can have newlines in version which breaks the json parser
.replace(",}", "}"); // Fix for WM V1, can have trailing commas which breaks the json parser
// Fix for WM V1 get_error_code, which can emit an invalid array of bare
// "code":"timestamp" pairs (`["540":".."]`) that fails the whole parse.
let response = crate::error_codes::repair_error_code_array(&response);
self.parse_rpc_result(&response)
}
@@ -202,6 +202,9 @@ impl WhatsMinerRPCAPI {
read_stream_response(&mut stream, DEFAULT_RPC_TIMEOUT).await
};
let response = response?;
// Repair the occasional invalid get_error_code array (bare
// "code":"timestamp" pairs) before parsing; a no-op on valid responses.
let response = crate::error_codes::repair_error_code_array(&response);
self.parse_rpc_result(&response)
}
+71
View File
@@ -2,6 +2,56 @@ use asic_rs_core::data::message::MinerComponent;
const UNKNOWN: &str = "Unknown error type.";
/// Repair an invalid `error_code` array emitted by some WhatsMiner firmware.
///
/// Certain (older, H6OS) firmwares report the fault list as bare
/// `"code":"timestamp"` pairs directly inside a JSON array
/// (`"error_code":["540":"..","541":".."]`) rather than an array of single-key
/// objects (`[{"540":".."},{"541":".."}]`). The bare form is not valid JSON and
/// fails the whole response parse, so no messages are surfaced at all. Rewrite the
/// bare pairs into objects; already-valid (object-wrapped or empty) arrays and
/// responses without an `error_code` array are returned unchanged.
pub fn repair_error_code_array(raw: &str) -> String {
const KEY: &str = "\"error_code\":[";
let Some(pos) = raw.find(KEY) else {
return raw.to_string();
};
let open = pos + KEY.len() - 1; // index of the '['
let bytes = raw.as_bytes();
let mut depth = 0i32;
let mut close = None;
for (i, &b) in bytes.iter().enumerate().skip(open) {
match b {
b'[' => depth += 1,
b']' => {
depth -= 1;
if depth == 0 {
close = Some(i);
break;
}
}
_ => {}
}
}
let Some(close) = close else {
return raw.to_string();
};
let inner = &raw[open + 1..close];
// Already valid (each entry object-wrapped) or empty -> leave untouched.
if inner.trim().is_empty() || inner.contains('{') {
return raw.to_string();
}
// Timestamps carry no commas, so a top-level comma split isolates each pair.
let wrapped = inner
.split(',')
.map(str::trim)
.filter(|s| !s.is_empty())
.map(|pair| format!("{{{pair}}}"))
.collect::<Vec<_>>()
.join(",");
format!("{}{}{}", &raw[..=open], wrapped, &raw[close..])
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ErrorInfo {
pub message: String,
@@ -514,6 +564,27 @@ fn serial_info_error(sub: u64, val: u64) -> String {
mod tests {
use super::*;
#[test]
fn repair_malformed_error_code_array() {
// Bare "code":"timestamp" pairs inside the array (invalid JSON) -> objects.
let bad = r#"{"STATUS":"S","Msg":{"error_code":["540":"2026-09-22 07:08:14","561":"2026-09-21 22:26:36"]},"Description":""}"#;
let fixed = repair_error_code_array(bad);
let v: serde_json::Value = serde_json::from_str(&fixed).expect("repaired JSON must parse");
let arr = v["Msg"]["error_code"].as_array().unwrap();
assert_eq!(arr.len(), 2);
assert_eq!(arr[0]["540"], "2026-09-22 07:08:14");
assert_eq!(arr[1]["561"], "2026-09-21 22:26:36");
// Already-valid (object-wrapped) arrays are returned unchanged.
let good = r#"{"Msg":{"error_code":[{"205":"2026-09-20 03:35:44"}]}}"#;
assert_eq!(repair_error_code_array(good), good);
// Empty array and no-array responses are untouched.
let empty = r#"{"Msg":{"error_code":[]}}"#;
assert_eq!(repair_error_code_array(empty), empty);
let none = r#"{"STATUS":"S"}"#;
assert_eq!(repair_error_code_array(none), none);
}
#[test]
fn short_code_returns_unknown() {
// Act