Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
a4d0cb65f0 | ||
|
|
29b9b17c67 | ||
|
|
8deecf3558 | ||
|
|
3a6a190ce1 | ||
|
|
1f0a4cbe76 | ||
|
|
fbc43216fb | ||
|
|
a4fcb6e763 | ||
|
|
76409b0d3b | ||
|
|
4aec6d40ad | ||
|
|
33a116d9fd | ||
|
|
45d9632590 | ||
|
|
0265370be2 | ||
|
|
fadd851e04 | ||
|
|
24f9d9682d | ||
|
|
3f9fc4a24b | ||
|
|
8ab607de6c | ||
|
|
a60bb34e64 | ||
|
|
c944897807 | ||
|
|
a6e22581d7 | ||
|
|
b15de7f747 | ||
|
|
f887affd6d | ||
|
|
e5e6b0f1e1 | ||
|
|
ad28dab542 | ||
|
|
42e3bf8f5b | ||
|
|
4154a50ed0 |
@@ -77,7 +77,12 @@ jobs:
|
||||
- name: Microbenchmarks
|
||||
if: steps.ver.outputs.release == 'true'
|
||||
run: |
|
||||
cargo test -p alkane-gui --release --offline -- --ignored --nocapture bench_
|
||||
# Capture the bench stdout for the weighted-average delta badge (round 19
|
||||
# #1) while keeping the step a hard gate: pipefail preserves cargo's exit
|
||||
# code (each bench asserts its own absolute ceiling) even through tee.
|
||||
set -o pipefail
|
||||
cargo test -p alkane-gui --release --offline -- --ignored --nocapture bench_ \
|
||||
| tee bench-current.txt
|
||||
|
||||
- name: Headless UI self-test
|
||||
if: steps.ver.outputs.release == 'true'
|
||||
@@ -97,6 +102,40 @@ jobs:
|
||||
echo "cargo-audit not installed on this runner; skipping"
|
||||
fi
|
||||
|
||||
# Merge coverage from the unit tests AND the headless self-test (ci/coverage.sh)
|
||||
# so the committed badge reflects real coverage, not the tests-only number a
|
||||
# plain `cargo llvm-cov` reports. Best-effort: cargo-llvm-cov is fetched as a
|
||||
# prebuilt binary because the vendored .cargo/config blocks `cargo install`,
|
||||
# and the instrumented rebuild is slow, so a failure here never blocks a
|
||||
# release. Feeds steps.cov.outputs.pct to the badge refresh below. xvfb is
|
||||
# already installed by the self-test step above.
|
||||
- name: Coverage (best-effort)
|
||||
id: cov
|
||||
if: steps.ver.outputs.release == 'true'
|
||||
continue-on-error: true
|
||||
run: |
|
||||
rustup component add llvm-tools-preview >/dev/null 2>&1 || true
|
||||
if ! command -v cargo-llvm-cov >/dev/null 2>&1; then
|
||||
V=0.8.7
|
||||
URL="https://github.com/taiki-e/cargo-llvm-cov/releases/download/v${V}/cargo-llvm-cov-x86_64-unknown-linux-gnu.tar.gz"
|
||||
DEST="${CARGO_HOME:-$HOME/.cargo}/bin"
|
||||
mkdir -p "$DEST"
|
||||
curl -fsSL "$URL" | tar -xz -C "$DEST" && export PATH="$DEST:$PATH" \
|
||||
|| echo "cargo-llvm-cov download failed"
|
||||
fi
|
||||
if command -v cargo-llvm-cov >/dev/null 2>&1; then
|
||||
PCT=$(bash ci/coverage.sh --summary-only 2>/dev/null \
|
||||
| awk '/^TOTAL/{gsub(/%/,"",$10); print $10}')
|
||||
if [ -n "$PCT" ]; then
|
||||
echo "pct=${PCT}" >> "$GITHUB_OUTPUT"
|
||||
echo "line coverage (tests + self-test): ${PCT}%"
|
||||
else
|
||||
echo "coverage report produced no TOTAL line; badge left as committed"
|
||||
fi
|
||||
else
|
||||
echo "cargo-llvm-cov unavailable; coverage badge left as committed"
|
||||
fi
|
||||
|
||||
# Refresh the committed README badges from live metrics and push any change
|
||||
# back to main. Best-effort: a locked-down runner that can't push must not
|
||||
# fail the release. A badges-only push does not bump the version (see
|
||||
@@ -109,7 +148,18 @@ jobs:
|
||||
run: |
|
||||
PASS=$(cargo test -p alkane-gui --offline 2>&1 \
|
||||
| grep -hoE '[0-9]+ passed' | grep -oE '[0-9]+' | awk '{s+=$1} END{print s+0}')
|
||||
python3 ci/gen-badges.py --tests "${PASS:-0}" --bench "row-render + scan-parse"
|
||||
# Update the coverage badge only when the coverage step produced a number;
|
||||
# otherwise leave the committed coverage.svg untouched.
|
||||
COV="${{ steps.cov.outputs.pct }}"
|
||||
COV_ARG=""
|
||||
[ -n "$COV" ] && COV_ARG="--coverage $COV"
|
||||
# Weighted-average microbench delta vs the previous release (round 19 #1).
|
||||
# bench-badge.py also rewrites badges/bench-baseline.json, which is
|
||||
# committed below with the SVGs (badges/* does not trip a release bump).
|
||||
BENCH_DELTA=$(python3 ci/bench-badge.py --current bench-current.txt \
|
||||
--baseline badges/bench-baseline.json 2>/dev/null || echo NEW)
|
||||
python3 ci/gen-badges.py --tests "${PASS:-0}" $COV_ARG \
|
||||
--bench-delta "${BENCH_DELTA:-NEW}" --bench "row-render + scan-parse"
|
||||
if [ -n "$(git status --porcelain badges)" ]; then
|
||||
git config user.name "alkane-ci"
|
||||
git config user.email "ci@bluefla.re"
|
||||
@@ -117,8 +167,8 @@ jobs:
|
||||
git commit -m "ci: refresh README badges [skip release]"
|
||||
API="${GITHUB_API_URL:-https://gitea.bluefla.re/api/v1}"
|
||||
HOST="${API%/api/v1}"
|
||||
git push "${HOST}/${GITHUB_REPOSITORY}.git" "HEAD:main" \
|
||||
-c http.extraheader="Authorization: token ${TOKEN}" || echo "badge push skipped"
|
||||
git -c http.extraheader="Authorization: token ${TOKEN}" \
|
||||
push "${HOST}/${GITHUB_REPOSITORY}.git" "HEAD:main" || echo "badge push skipped"
|
||||
else
|
||||
echo "badges unchanged"
|
||||
fi
|
||||
|
||||
@@ -0,0 +1,11 @@
|
||||
{
|
||||
"bench_parse_line_near_max_addrs": 3901086.0,
|
||||
"bench_parse_targets_many_ranges_near_cap": 290127400.0,
|
||||
"bench_render_cells": 29363207.0,
|
||||
"bench_sort_by_each_column": 4468641.0,
|
||||
"bench_targets_to_cidrs_large_range": 3605972.0,
|
||||
"bench_upsert_cold_start_population": 91616782.0,
|
||||
"bench_view_pipeline": 1396303.0,
|
||||
"bench_view_pipeline_default_sort": 2723906.0,
|
||||
"bench_view_pipeline_with_filter": 1491721.0
|
||||
}
|
||||
@@ -1,19 +1,19 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" width="206.0" height="20" role="img" aria-label="bench: row-render + scan-parse">
|
||||
<title>bench: row-render + scan-parse</title>
|
||||
<svg xmlns="http://www.w3.org/2000/svg" width="147.5" height="20" role="img" aria-label="bench: +52.9% vs prev">
|
||||
<title>bench: +52.9% vs prev</title>
|
||||
<linearGradient id="s" x2="0" y2="100%">
|
||||
<stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
|
||||
<stop offset="1" stop-opacity=".1"/>
|
||||
</linearGradient>
|
||||
<clipPath id="r"><rect width="206.0" height="20" rx="3" fill="#fff"/></clipPath>
|
||||
<clipPath id="r"><rect width="147.5" height="20" rx="3" fill="#fff"/></clipPath>
|
||||
<g clip-path="url(#r)">
|
||||
<rect width="44.5" height="20" fill="#555"/>
|
||||
<rect x="44.5" width="161.5" height="20" fill="#007ec6"/>
|
||||
<rect width="206.0" height="20" fill="url(#s)"/>
|
||||
<rect x="44.5" width="103.0" height="20" fill="#fe7d37"/>
|
||||
<rect width="147.5" height="20" fill="url(#s)"/>
|
||||
</g>
|
||||
<g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" font-size="11">
|
||||
<text x="22.2" y="15" fill="#010101" fill-opacity=".3">bench</text>
|
||||
<text x="22.2" y="14">bench</text>
|
||||
<text x="125.2" y="15" fill="#010101" fill-opacity=".3">row-render + scan-parse</text>
|
||||
<text x="125.2" y="14">row-render + scan-parse</text>
|
||||
<text x="96.0" y="15" fill="#010101" fill-opacity=".3">+52.9% vs prev</text>
|
||||
<text x="96.0" y="14">+52.9% vs prev</text>
|
||||
</g>
|
||||
</svg>
|
||||
|
||||
|
Before Width: | Height: | Size: 993 B After Width: | Height: | Size: 955 B |
@@ -1,5 +1,5 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" width="95.5" height="20" role="img" aria-label="coverage: 46%">
|
||||
<title>coverage: 46%</title>
|
||||
<svg xmlns="http://www.w3.org/2000/svg" width="95.5" height="20" role="img" aria-label="coverage: 44%">
|
||||
<title>coverage: 44%</title>
|
||||
<linearGradient id="s" x2="0" y2="100%">
|
||||
<stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
|
||||
<stop offset="1" stop-opacity=".1"/>
|
||||
@@ -13,7 +13,7 @@
|
||||
<g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" font-size="11">
|
||||
<text x="32.0" y="15" fill="#010101" fill-opacity=".3">coverage</text>
|
||||
<text x="32.0" y="14">coverage</text>
|
||||
<text x="79.8" y="15" fill="#010101" fill-opacity=".3">46%</text>
|
||||
<text x="79.8" y="14">46%</text>
|
||||
<text x="79.8" y="15" fill="#010101" fill-opacity=".3">44%</text>
|
||||
<text x="79.8" y="14">44%</text>
|
||||
</g>
|
||||
</svg>
|
||||
|
||||
|
Before Width: | Height: | Size: 919 B After Width: | Height: | Size: 919 B |
@@ -1,5 +1,5 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" width="141.0" height="20" role="img" aria-label="lines of code: 13.2k">
|
||||
<title>lines of code: 13.2k</title>
|
||||
<svg xmlns="http://www.w3.org/2000/svg" width="141.0" height="20" role="img" aria-label="lines of code: 13.5k">
|
||||
<title>lines of code: 13.5k</title>
|
||||
<linearGradient id="s" x2="0" y2="100%">
|
||||
<stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
|
||||
<stop offset="1" stop-opacity=".1"/>
|
||||
@@ -13,7 +13,7 @@
|
||||
<g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" font-size="11">
|
||||
<text x="48.2" y="15" fill="#010101" fill-opacity=".3">lines of code</text>
|
||||
<text x="48.2" y="14">lines of code</text>
|
||||
<text x="118.8" y="15" fill="#010101" fill-opacity=".3">13.2k</text>
|
||||
<text x="118.8" y="14">13.2k</text>
|
||||
<text x="118.8" y="15" fill="#010101" fill-opacity=".3">13.5k</text>
|
||||
<text x="118.8" y="14">13.5k</text>
|
||||
</g>
|
||||
</svg>
|
||||
|
||||
|
Before Width: | Height: | Size: 952 B After Width: | Height: | Size: 952 B |
@@ -1,5 +1,5 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" width="121.5" height="20" role="img" aria-label="tests: 99 passing">
|
||||
<title>tests: 99 passing</title>
|
||||
<svg xmlns="http://www.w3.org/2000/svg" width="121.5" height="20" role="img" aria-label="tests: 93 passing">
|
||||
<title>tests: 93 passing</title>
|
||||
<linearGradient id="s" x2="0" y2="100%">
|
||||
<stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
|
||||
<stop offset="1" stop-opacity=".1"/>
|
||||
@@ -13,7 +13,7 @@
|
||||
<g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" font-size="11">
|
||||
<text x="22.2" y="15" fill="#010101" fill-opacity=".3">tests</text>
|
||||
<text x="22.2" y="14">tests</text>
|
||||
<text x="83.0" y="15" fill="#010101" fill-opacity=".3">99 passing</text>
|
||||
<text x="83.0" y="14">99 passing</text>
|
||||
<text x="83.0" y="15" fill="#010101" fill-opacity=".3">93 passing</text>
|
||||
<text x="83.0" y="14">93 passing</text>
|
||||
</g>
|
||||
</svg>
|
||||
|
||||
|
Before Width: | Height: | Size: 935 B After Width: | Height: | Size: 935 B |
@@ -0,0 +1,98 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Compute the weighted-average microbenchmark delta versus the previous release.
|
||||
|
||||
Reads the captured stdout of `cargo test ... --ignored --nocapture bench_` (whose
|
||||
timings are Rust `Duration` Debug strings: "12.3ms", "512us"/"512µs", "840ns",
|
||||
"1.2s"), compares each bench to a committed baseline of the previous release's
|
||||
numbers, and prints the time-weighted average change as a signed percentage:
|
||||
|
||||
(sum(current) / sum(baseline) - 1) * 100 over benches present in both
|
||||
|
||||
Weighting by duration means the slow benches dominate, so the number tracks
|
||||
overall wall-time change rather than giving a tiny bench equal say. Then the
|
||||
baseline is rewritten with the current numbers, so the next release compares
|
||||
against this one ("the previous commit").
|
||||
|
||||
Usage:
|
||||
bench-badge.py --current bench-current.txt --baseline badges/bench-baseline.json
|
||||
|
||||
Prints the delta as a plain number (e.g. "-3.2", or "NEW" when there is no
|
||||
usable baseline) to stdout. The baseline JSON lives under badges/ so committing
|
||||
it back does not trip compute-version.sh's path-based release bump.
|
||||
"""
|
||||
import argparse
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import sys
|
||||
|
||||
# A Duration Debug token: a number immediately followed by a time unit, with the
|
||||
# multi-char units listed before the bare "s" so alternation prefers them. The
|
||||
# trailing (?![a-zA-Z]) stops "s" in words like "rows"/"cidrs" from matching.
|
||||
_DUR = re.compile(r"([0-9]+(?:\.[0-9]+)?)\s*(ns|µs|us|ms|s)(?![a-zA-Z])")
|
||||
_UNIT_NS = {"ns": 1.0, "us": 1e3, "µs": 1e3, "ms": 1e6, "s": 1e9}
|
||||
_NAME = re.compile(r"^(bench_[A-Za-z0-9_]+)\s*:")
|
||||
|
||||
|
||||
def parse_bench(text: str) -> dict:
|
||||
"""Map each bench name to its timing in nanoseconds (the last Duration on the
|
||||
line, since every bench prints its timing last)."""
|
||||
out = {}
|
||||
for line in text.splitlines():
|
||||
m = _NAME.match(line.strip())
|
||||
if not m:
|
||||
continue
|
||||
durs = _DUR.findall(line)
|
||||
if not durs:
|
||||
continue
|
||||
val, unit = durs[-1]
|
||||
out[m.group(1)] = float(val) * _UNIT_NS[unit]
|
||||
return out
|
||||
|
||||
|
||||
def main() -> int:
|
||||
ap = argparse.ArgumentParser()
|
||||
ap.add_argument("--current", required=True, help="captured bench stdout")
|
||||
ap.add_argument("--baseline", required=True, help="baseline JSON (read + rewrite)")
|
||||
ap.add_argument("--no-write", action="store_true", help="do not update the baseline")
|
||||
args = ap.parse_args()
|
||||
|
||||
try:
|
||||
with open(args.current, encoding="utf-8") as fh:
|
||||
current = parse_bench(fh.read())
|
||||
except OSError as e:
|
||||
print(f"bench-badge: cannot read current results: {e}", file=sys.stderr)
|
||||
print("NEW")
|
||||
return 0
|
||||
|
||||
if not current:
|
||||
print("bench-badge: no bench lines parsed from current results", file=sys.stderr)
|
||||
print("NEW")
|
||||
return 0
|
||||
|
||||
baseline = {}
|
||||
try:
|
||||
with open(args.baseline, encoding="utf-8") as fh:
|
||||
baseline = {k: float(v) for k, v in json.load(fh).items()}
|
||||
except (OSError, ValueError):
|
||||
baseline = {}
|
||||
|
||||
common = [k for k in current if k in baseline and baseline[k] > 0]
|
||||
if common:
|
||||
sum_new = sum(current[k] for k in common)
|
||||
sum_old = sum(baseline[k] for k in common)
|
||||
delta = (sum_new / sum_old - 1.0) * 100.0 if sum_old > 0 else 0.0
|
||||
print(f"{delta:.1f}")
|
||||
else:
|
||||
print("NEW")
|
||||
|
||||
if not args.no_write:
|
||||
os.makedirs(os.path.dirname(args.baseline) or ".", exist_ok=True)
|
||||
with open(args.baseline, "w", encoding="utf-8") as fh:
|
||||
json.dump({k: round(v, 1) for k, v in sorted(current.items())}, fh, indent=2)
|
||||
fh.write("\n")
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main())
|
||||
@@ -12,18 +12,22 @@ set -euo pipefail
|
||||
|
||||
export WX_RS_WXCONFIG="${WX_RS_WXCONFIG:-$HOME/.cache/wx-3.3.3-linux/bin/wx-config}"
|
||||
|
||||
# The dependency tree is fully vendored, so the instrumented builds run offline by
|
||||
# default; override with CARGO_LLVM_COV_FLAGS if you need something else.
|
||||
read -ra CARGO_FLAGS <<<"${CARGO_LLVM_COV_FLAGS:---offline}"
|
||||
|
||||
# A display for the self-test's real widgets.
|
||||
need_xvfb() { command -v xvfb-run >/dev/null 2>&1; }
|
||||
|
||||
cargo llvm-cov clean --workspace
|
||||
|
||||
# 1. Unit tests.
|
||||
cargo llvm-cov --no-report -p alkane-gui --bin alkane-toolkit
|
||||
cargo llvm-cov --no-report "${CARGO_FLAGS[@]}" -p alkane-gui --bin alkane-toolkit
|
||||
|
||||
# 2. Headless UI self-test, under the same instrumentation, its coverage appended.
|
||||
if need_xvfb; then
|
||||
xvfb-run -a env GDK_BACKEND=x11 ALKANE_SELFTEST=1 \
|
||||
cargo llvm-cov run --no-report --bin alkane-toolkit
|
||||
cargo llvm-cov run --no-report "${CARGO_FLAGS[@]}" --bin alkane-toolkit
|
||||
else
|
||||
echo "coverage.sh: xvfb-run not found; skipping the self-test run (unit tests only)" >&2
|
||||
fi
|
||||
|
||||
@@ -108,6 +108,18 @@ def loc_color(n: int) -> str:
|
||||
return "blue"
|
||||
|
||||
|
||||
def bench_color(delta_pct: float) -> str:
|
||||
# Negative delta = faster than the previous release. A +/-2% dead band absorbs
|
||||
# the run-to-run jitter of microbenchmarks on a shared CI runner.
|
||||
if delta_pct <= -2.0:
|
||||
return "brightgreen"
|
||||
if delta_pct < 2.0:
|
||||
return "blue"
|
||||
if delta_pct < 10.0:
|
||||
return "yellow"
|
||||
return "orange"
|
||||
|
||||
|
||||
def cov_color(pct: float) -> str:
|
||||
if pct >= 80:
|
||||
return "brightgreen"
|
||||
@@ -133,6 +145,10 @@ def main() -> int:
|
||||
ap.add_argument("--tests", type=int, default=None)
|
||||
ap.add_argument("--coverage", type=float, default=None)
|
||||
ap.add_argument("--bench", default=None)
|
||||
# Weighted-average microbench delta vs the previous release, as a signed
|
||||
# percentage string (e.g. "-3.2"), or "NEW"/"" when there is no baseline yet
|
||||
# (round 19 #1). Takes precedence over --bench for the bench badge.
|
||||
ap.add_argument("--bench-delta", default=None)
|
||||
ap.add_argument("--clippy", default="clean")
|
||||
args = ap.parse_args()
|
||||
|
||||
@@ -156,7 +172,21 @@ def main() -> int:
|
||||
write("tests", "tests", f"{args.tests} passing", "brightgreen")
|
||||
if args.coverage is not None:
|
||||
write("coverage", "coverage", f"{args.coverage:.0f}%", cov_color(args.coverage))
|
||||
if args.bench is not None:
|
||||
# Bench badge: prefer the weighted-average delta vs the previous release; fall
|
||||
# back to the static label (first run, or when the delta could not be computed).
|
||||
delta = None
|
||||
if args.bench_delta not in (None, "", "NEW"):
|
||||
try:
|
||||
delta = float(args.bench_delta)
|
||||
except ValueError:
|
||||
delta = None
|
||||
if delta is not None:
|
||||
# Negative = faster than the previous release (good).
|
||||
msg = f"{'+' if delta > 0 else ''}{delta:.1f}% vs prev"
|
||||
write("bench", "bench", msg, bench_color(delta))
|
||||
elif args.bench_delta == "NEW":
|
||||
write("bench", "bench", "baseline set", "blue")
|
||||
elif args.bench is not None:
|
||||
write("bench", "bench", args.bench, "blue")
|
||||
return 0
|
||||
|
||||
|
||||
@@ -9,6 +9,28 @@
|
||||
|
||||
use crate::model::{BoardHealth, MinerRow};
|
||||
|
||||
/// A compact UTC timestamp "YYYYMMDD-HHMMSS" for a default export filename
|
||||
/// (round 19 #5). UTC keeps this dependency-free (no chrono) and unambiguous.
|
||||
pub fn timestamp_utc() -> String {
|
||||
let secs = std::time::SystemTime::now()
|
||||
.duration_since(std::time::UNIX_EPOCH)
|
||||
.map(|d| d.as_secs())
|
||||
.unwrap_or(0);
|
||||
let sod = secs % 86_400;
|
||||
let (h, mi, s) = (sod / 3600, (sod % 3600) / 60, sod % 60);
|
||||
// Civil date from days since 1970-01-01 (Howard Hinnant's civil_from_days).
|
||||
let z = (secs / 86_400) as i64 + 719_468;
|
||||
let era = if z >= 0 { z } else { z - 146_096 } / 146_097;
|
||||
let doe = z - era * 146_097; // [0, 146096]
|
||||
let yoe = (doe - doe / 1460 + doe / 36_524 - doe / 146_096) / 365; // [0, 399]
|
||||
let doy = doe - (365 * yoe + yoe / 4 - yoe / 100); // [0, 365]
|
||||
let mp = (5 * doy + 2) / 153; // [0, 11]
|
||||
let d = doy - (153 * mp + 2) / 5 + 1; // [1, 31]
|
||||
let m = if mp < 10 { mp + 3 } else { mp - 9 }; // [1, 12]
|
||||
let y = yoe + era * 400 + i64::from(m <= 2);
|
||||
format!("{y:04}{m:02}{d:02}-{h:02}{mi:02}{s:02}")
|
||||
}
|
||||
|
||||
/// Escape one CSV field: neutralise spreadsheet formula injection, then quote it
|
||||
/// when it contains a comma, quote, CR or LF (doubling any embedded quotes).
|
||||
///
|
||||
@@ -105,14 +127,42 @@ fn scalar_columns() -> Vec<Col> {
|
||||
]
|
||||
}
|
||||
|
||||
/// 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);
|
||||
// Group keys for the four variable-length field families (each expands to
|
||||
// per-index columns). Shown as single checkboxes in the export picker (round 19 #6).
|
||||
pub const GROUP_BOARD_TEMPS: &str = "board temps";
|
||||
pub const GROUP_FANS: &str = "fan rpms";
|
||||
pub const GROUP_BOARD_STATUS: &str = "board status";
|
||||
pub const GROUP_POOLS: &str = "pools";
|
||||
|
||||
/// Every selectable export field, in output order: each scalar column header,
|
||||
/// then the four variable-length group keys.
|
||||
pub fn export_field_names() -> Vec<String> {
|
||||
let mut v: Vec<String> = scalar_columns().iter().map(|(h, _)| (*h).to_string()).collect();
|
||||
v.push(GROUP_BOARD_TEMPS.to_string());
|
||||
v.push(GROUP_FANS.to_string());
|
||||
v.push(GROUP_BOARD_STATUS.to_string());
|
||||
v.push(GROUP_POOLS.to_string());
|
||||
v
|
||||
}
|
||||
|
||||
/// Build the CSV for `rows` including only the selected fields (scalar column
|
||||
/// headers and/or the group keys above), in the fixed output order (round 19 #6).
|
||||
/// Empty rows still emit a header line.
|
||||
pub fn rows_to_csv_selected(
|
||||
rows: &[MinerRow],
|
||||
selected: &std::collections::HashSet<String>,
|
||||
) -> String {
|
||||
let cols: Vec<Col> =
|
||||
scalar_columns().into_iter().filter(|(h, _)| selected.contains(*h)).collect();
|
||||
// A group's columns appear only when it is selected; an unselected group's
|
||||
// width stays 0, so the header/value loops below emit nothing for it.
|
||||
let width = |want: bool, f: &dyn Fn(&MinerRow) -> usize| -> usize {
|
||||
if want { rows.iter().map(f).max().unwrap_or(0) } else { 0 }
|
||||
};
|
||||
let max_board_temps = width(selected.contains(GROUP_BOARD_TEMPS), &|r| r.board_temps.len());
|
||||
let max_fans = width(selected.contains(GROUP_FANS), &|r| r.fan_rpms.len());
|
||||
let max_boards = width(selected.contains(GROUP_BOARD_STATUS), &|r| r.board_status.len());
|
||||
let max_pools = width(selected.contains(GROUP_POOLS), &|r| r.pools.len());
|
||||
|
||||
// Header.
|
||||
let mut headers: Vec<String> = cols.iter().map(|(h, _)| (*h).to_string()).collect();
|
||||
@@ -174,7 +224,8 @@ mod tests {
|
||||
},
|
||||
MinerRow { ip: "10.0.0.2".into(), model: "M30S".into(), ..Default::default() },
|
||||
];
|
||||
let csv = rows_to_csv(&rows);
|
||||
let all: std::collections::HashSet<String> = export_field_names().into_iter().collect();
|
||||
let csv = rows_to_csv_selected(&rows, &all);
|
||||
let lines: Vec<&str> = csv.lines().collect();
|
||||
assert_eq!(lines.len(), 3, "header + 2 rows");
|
||||
assert!(lines[0].starts_with("ip,model,brand,"));
|
||||
|
||||
@@ -92,6 +92,11 @@ impl Board {
|
||||
"10.255.1.166" => vec![Ok, Ok, Missing],
|
||||
_ => vec![Ok, Ok, Ok],
|
||||
}
|
||||
} else if self.paused {
|
||||
// A paused miner's boards are physically present but idle (asic-rs
|
||||
// reports active=false -> Fault), so the Health column shows them blue
|
||||
// rather than red (round 19 #19); the offline demo mirrors that.
|
||||
vec![Fault, Fault, Fault]
|
||||
} else {
|
||||
vec![]
|
||||
};
|
||||
@@ -123,6 +128,10 @@ impl Board {
|
||||
cpu,
|
||||
board_code,
|
||||
hashrate_ths: self.hashrate,
|
||||
// A miner that is mining or paused reported a current hashrate (a paused
|
||||
// one reports 0 -> "0.00T"); the blank stock demo miner reports none, so
|
||||
// it keeps the "-" dash (round 19 follow-up).
|
||||
hashrate_known: self.mining || self.paused,
|
||||
expected_ths: self.expected,
|
||||
board_hashrates,
|
||||
board_voltages,
|
||||
|
||||
@@ -1,58 +1,44 @@
|
||||
//! Fetch a miner's log over its firmware API and regex-scan it for useful
|
||||
//! signals (round 12 #12). This is the "logs through API" path the operator
|
||||
//! asked for: where a firmware exposes its log we can read board/PIC lines and
|
||||
//! other metrics without SSH.
|
||||
//! Fetch a miner's log for the "View log (API)" viewer (round 12 #12, reworked
|
||||
//! round 19 #11-16).
|
||||
//!
|
||||
//! Per firmware:
|
||||
//! - VNish (aftermarket Antminer): POST /api/v1/unlock to get a bearer token,
|
||||
//! then GET /api/v1/logs/miner -- the full miner log (PSU init, per-chain
|
||||
//! chip detection, tuning, errors).
|
||||
//! - Stock Antminer: GET /cgi-bin/log.cgi behind digest auth (older models
|
||||
//! such as the Z15 do not serve it -> reported as unavailable).
|
||||
//! - WhatsMiner: the btminer log is not exposed on :4028, but get_error_code
|
||||
//! (unauthenticated) returns the active fault codes, which we format as the
|
||||
//! log view.
|
||||
//! The log is fetched through asic-rs's per-backend `read_logs()` API, which
|
||||
//! knows each firmware's real transport (Antminer/Z15 + BixBit stock web,
|
||||
//! Braiins gRPC/journal, VNish and ePIC HTTP, ...). This replaced the GUI's
|
||||
//! narrow three-way curl fetch, whose stock `/cgi-bin/log.cgi` `else` branch
|
||||
//! failed on every firmware that does not serve that CGI (Braiins, LuxOS, Z15,
|
||||
//! BixBit).
|
||||
//!
|
||||
//! We shell out to `curl` (already a dependency of the access probe) so the
|
||||
//! offline/vendored build gains no new crate, and cap the fetched text so a huge
|
||||
//! log never bloats the viewer.
|
||||
//! WhatsMiner is the exception: its btminer log is not exposed over the API, and
|
||||
//! asic-rs has no `read_logs` for it, so the viewer falls back to the active
|
||||
//! fault codes (get_error_code on :4028, unauthenticated). LuxOS likewise has no
|
||||
//! asic-rs log API and reports the log as unavailable.
|
||||
|
||||
use std::process::Command;
|
||||
use std::time::Duration;
|
||||
|
||||
/// Cap on the log text we keep for display (bytes); the regex summary is still
|
||||
/// computed over everything fetched.
|
||||
/// Cap on the log text we keep for display (bytes); a miner's freshest lines are
|
||||
/// at the tail, so we keep the tail.
|
||||
const MAX_LOG_BYTES: usize = 256 * 1024;
|
||||
|
||||
/// A fetched log plus the signals a regex pass pulled out of it.
|
||||
/// A fetched log for the viewer.
|
||||
pub struct LogScan {
|
||||
/// The (possibly tail-trimmed) log text for the viewer.
|
||||
/// The (possibly tail-trimmed) log text.
|
||||
pub text: String,
|
||||
/// One-line-per-finding summary shown above the log.
|
||||
pub summary: Vec<String>,
|
||||
}
|
||||
|
||||
/// Fetch and scan one miner's log. `brand` is the make ("Antminer"/"Whatsminer"),
|
||||
/// `firmware` the family ("VNish"/"Stock"/...). `vnish_pass`/`wm` creds are used
|
||||
/// where that firmware needs auth. Returns `Err` only when no log could be read.
|
||||
pub fn scan_log(
|
||||
ip: &str,
|
||||
brand: &str,
|
||||
firmware: &str,
|
||||
vnish_pass: &str,
|
||||
antminer_user: &str,
|
||||
antminer_pass: &str,
|
||||
) -> Result<LogScan, String> {
|
||||
let raw = if firmware.eq_ignore_ascii_case("vnish") {
|
||||
fetch_vnish_log(ip, vnish_pass)?
|
||||
} else if brand.eq_ignore_ascii_case("whatsminer") {
|
||||
fetch_whatsminer_errors(ip)?
|
||||
} else {
|
||||
// Stock / other Antminer-family web firmware.
|
||||
fetch_antminer_log(ip, antminer_user, antminer_pass)?
|
||||
};
|
||||
let summary = summarize_log(&raw);
|
||||
Ok(LogScan { text: tail(&raw, MAX_LOG_BYTES), summary })
|
||||
/// Fetch one miner's log. `brand` is the make ("Antminer"/"Whatsminer"/...);
|
||||
/// `timeout_secs` is the per-miner identification timeout. Returns `Err` only
|
||||
/// when no log could be read.
|
||||
pub fn scan_log(ip: &str, brand: &str, timeout_secs: u64) -> Result<LogScan, String> {
|
||||
// WhatsMiner's real log is not exposed over its API and asic-rs has no
|
||||
// read_logs for it, so show the active fault codes instead of failing.
|
||||
if brand.eq_ignore_ascii_case("whatsminer") {
|
||||
let resp = crate::access_probe::whatsminer_get_error_code(ip)
|
||||
.ok_or_else(|| "WhatsMiner did not answer get_error_code on :4028".to_string())?;
|
||||
return Ok(LogScan { text: tail(&resp, MAX_LOG_BYTES) });
|
||||
}
|
||||
let text = crate::scan::fetch_log(ip, timeout_secs)?;
|
||||
if text.trim().is_empty() {
|
||||
return Err("the miner returned an empty log".to_string());
|
||||
}
|
||||
Ok(LogScan { text: tail(&text, MAX_LOG_BYTES) })
|
||||
}
|
||||
|
||||
/// Keep the last `max` bytes of `s` (a log's tail is the freshest), on a line
|
||||
@@ -69,199 +55,10 @@ fn tail(s: &str, max: usize) -> String {
|
||||
start += 1;
|
||||
}
|
||||
// then advance to the next line boundary so we don't cut a line in half
|
||||
let start = s[start..]
|
||||
.find('\n')
|
||||
.map(|i| start + i + 1)
|
||||
.unwrap_or(start);
|
||||
let start = s[start..].find('\n').map(|i| start + i + 1).unwrap_or(start);
|
||||
format!("[... earlier log trimmed ...]\n{}", &s[start..])
|
||||
}
|
||||
|
||||
/// Regex-free scan for the high-value signals in a miner log: PIC / hashboard
|
||||
/// firmware lines, per-chain chip detection, and the most recent errors.
|
||||
fn summarize_log(log: &str) -> Vec<String> {
|
||||
let mut out = Vec::new();
|
||||
let lc_has = |line: &str, needle: &str| line.to_ascii_lowercase().contains(needle);
|
||||
|
||||
// PIC / hashboard-controller status from the log. Aftermarket firmwares state
|
||||
// it explicitly ("no-PIC miner"); stock boot logs print a PIC version. This
|
||||
// is the log-regex PIC scan the operator asked for (round 12 #12).
|
||||
let pic_lines: Vec<&str> = log.lines().filter(|l| lc_has(l, "pic")).collect();
|
||||
if pic_lines.iter().any(|l| lc_has(l, "no-pic") || lc_has(l, "no pic")) {
|
||||
out.push("PIC: not present (log reports a no-PIC miner)".to_string());
|
||||
} else if let Some(l) = pic_lines
|
||||
.iter()
|
||||
.find(|l| lc_has(l, "version") || lc_has(l, "fw") || lc_has(l, "found"))
|
||||
{
|
||||
out.push(format!("PIC: present -- {}", l.trim()));
|
||||
} else if !pic_lines.is_empty() {
|
||||
out.push(format!("PIC: {} log line(s) mention PIC", pic_lines.len()));
|
||||
for l in pic_lines.iter().take(3) {
|
||||
out.push(format!(" {}", l.trim()));
|
||||
}
|
||||
} else {
|
||||
out.push("PIC: no PIC lines in the log".to_string());
|
||||
}
|
||||
|
||||
// Latest per-chain chip-detection line (the most recent board bring-up).
|
||||
if let Some(l) = log.lines().rev().find(|l| lc_has(l, "chips detected")) {
|
||||
out.push(format!("Chains: {}", l.trim()));
|
||||
}
|
||||
|
||||
// Recent errors (log history, beyond asic-rs's current-message snapshot).
|
||||
// Skip the get_error_code header line (it contains "error" but is not one).
|
||||
let errors: Vec<&str> = log
|
||||
.lines()
|
||||
.rev()
|
||||
.filter(|l| (lc_has(l, "error") || lc_has(l, "fail")) && !lc_has(l, "get_error_code"))
|
||||
.take(3)
|
||||
.collect();
|
||||
if errors.is_empty() {
|
||||
out.push("Errors: none in the log".to_string());
|
||||
} else {
|
||||
out.push(format!("Errors: {} recent", errors.len()));
|
||||
for l in errors {
|
||||
out.push(format!(" {}", l.trim()));
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// VNish: unlock -> bearer -> the full miner log.
|
||||
fn fetch_vnish_log(ip: &str, pass: &str) -> Result<String, String> {
|
||||
// The password goes in the POST body read from stdin (-d @-), never on argv,
|
||||
// and is JSON-encoded by serde so it is both un-leakable and correctly escaped
|
||||
// (round 18 #12).
|
||||
let body = serde_json::json!({ "pw": pass }).to_string();
|
||||
let unlock = curl(
|
||||
&[
|
||||
"-s",
|
||||
"--connect-timeout",
|
||||
"5",
|
||||
"--max-time",
|
||||
"9",
|
||||
"-X",
|
||||
"POST",
|
||||
"-H",
|
||||
"Content-Type: application/json",
|
||||
"-d",
|
||||
"@-",
|
||||
&format!("http://{ip}/api/v1/unlock"),
|
||||
],
|
||||
Some(body.as_bytes()),
|
||||
)?;
|
||||
let token = serde_json::from_str::<serde_json::Value>(&unlock)
|
||||
.ok()
|
||||
.and_then(|v| v.get("token").and_then(|t| t.as_str()).map(str::to_string))
|
||||
.filter(|t| !t.is_empty())
|
||||
.ok_or_else(|| "VNish unlock rejected (check the VNish password in scan credentials)".to_string())?;
|
||||
let log = curl(
|
||||
&[
|
||||
"-s",
|
||||
"--connect-timeout",
|
||||
"5",
|
||||
"--max-time",
|
||||
"12",
|
||||
"-H",
|
||||
&format!("Authorization: Bearer {token}"),
|
||||
&format!("http://{ip}/api/v1/logs/miner"),
|
||||
],
|
||||
None,
|
||||
)?;
|
||||
if log.trim().is_empty() {
|
||||
return Err("VNish returned an empty log".to_string());
|
||||
}
|
||||
Ok(log)
|
||||
}
|
||||
|
||||
/// Stock Antminer web log (digest auth). Absent on older models (404).
|
||||
fn fetch_antminer_log(ip: &str, user: &str, pass: &str) -> Result<String, String> {
|
||||
// Credentials go through a curl config on stdin (-K -), never on argv, so they
|
||||
// can't be read from the process list (round 18 #12).
|
||||
let config = format!("user = \"{}\"\n", curl_config_quote(&format!("{user}:{pass}")));
|
||||
let body = curl(
|
||||
&[
|
||||
"-s",
|
||||
"--digest",
|
||||
"--connect-timeout",
|
||||
"5",
|
||||
"--max-time",
|
||||
"12",
|
||||
"-K",
|
||||
"-",
|
||||
&format!("http://{ip}/cgi-bin/log.cgi"),
|
||||
],
|
||||
Some(config.as_bytes()),
|
||||
)?;
|
||||
if body.contains("404 - Not Found") || body.trim().is_empty() {
|
||||
return Err("this firmware does not expose a log over its web API".to_string());
|
||||
}
|
||||
Ok(body)
|
||||
}
|
||||
|
||||
/// WhatsMiner: format the active error codes (get_error_code, unauthenticated).
|
||||
fn fetch_whatsminer_errors(ip: &str) -> Result<String, String> {
|
||||
let resp = crate::access_probe::whatsminer_get_error_code(ip)
|
||||
.ok_or_else(|| "WhatsMiner did not answer get_error_code on :4028".to_string())?;
|
||||
Ok(resp)
|
||||
}
|
||||
|
||||
/// Run curl and return stdout, with a hard wall-clock cap. stdout is drained on a
|
||||
/// separate thread so a large log (hundreds of KB) never deadlocks on a full pipe
|
||||
/// -- the reason a naive "wait then read" times out on the VNish log.
|
||||
fn curl(args: &[&str], stdin_data: Option<&[u8]>) -> Result<String, String> {
|
||||
use std::io::{Read, Write};
|
||||
let mut cmd = Command::new("curl");
|
||||
cmd.args(args);
|
||||
cmd.stdout(std::process::Stdio::piped());
|
||||
cmd.stderr(std::process::Stdio::null());
|
||||
if stdin_data.is_some() {
|
||||
cmd.stdin(std::process::Stdio::piped());
|
||||
}
|
||||
let mut child = cmd.spawn().map_err(|e| format!("spawn curl: {e}"))?;
|
||||
if let Some(data) = stdin_data {
|
||||
if let Some(mut si) = child.stdin.take() {
|
||||
let _ = si.write_all(data);
|
||||
} // dropping `si` closes the pipe so curl stops reading the config/body
|
||||
}
|
||||
let stdout = child.stdout.take().ok_or("no curl stdout")?;
|
||||
let reader = std::thread::spawn(move || {
|
||||
// Bound the buffer: a miner-controlled response must not exhaust memory
|
||||
// (round 18 #12). The viewer only keeps the last MAX_LOG_BYTES anyway, so
|
||||
// read a small multiple of that and drop the rest.
|
||||
const READ_CAP: u64 = (MAX_LOG_BYTES as u64) * 8; // 2 MiB
|
||||
let mut buf = Vec::new();
|
||||
let _ = stdout.take(READ_CAP).read_to_end(&mut buf);
|
||||
buf
|
||||
});
|
||||
let timeout = Duration::from_secs(20);
|
||||
let start = std::time::Instant::now();
|
||||
let mut timed_out = false;
|
||||
loop {
|
||||
match child.try_wait().map_err(|e| e.to_string())? {
|
||||
Some(_) => break,
|
||||
None => {
|
||||
if start.elapsed() >= timeout {
|
||||
let _ = child.kill();
|
||||
let _ = child.wait(); // reap so we never leave a zombie (round 18 #12)
|
||||
timed_out = true;
|
||||
break;
|
||||
}
|
||||
std::thread::sleep(Duration::from_millis(50));
|
||||
}
|
||||
}
|
||||
}
|
||||
let buf = reader.join().unwrap_or_default();
|
||||
if timed_out && buf.is_empty() {
|
||||
return Err("log fetch timed out".into());
|
||||
}
|
||||
Ok(String::from_utf8_lossy(&buf).into_owned())
|
||||
}
|
||||
|
||||
/// Escape a value for a curl `--config` file (double-quoted string).
|
||||
fn curl_config_quote(s: &str) -> String {
|
||||
s.replace('\\', "\\\\").replace('"', "\\\"")
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
@@ -276,34 +73,6 @@ mod tests {
|
||||
assert!(out.len() < s.len());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn summarize_finds_pic_chains_and_errors() {
|
||||
let log = "\
|
||||
[t] INFO: Initializing PSU
|
||||
[t] INFO: chain#1 - 126 chips detected
|
||||
[t] INFO: check PIC on chain 1: version 0x03
|
||||
[t] ERROR: Failed load miner config
|
||||
[t] INFO: chain#2 - 126 chips detected";
|
||||
let s = summarize_log(log);
|
||||
assert!(s.iter().any(|l| l.contains("PIC: present")), "PIC present: {s:?}");
|
||||
assert!(s.iter().any(|l| l.contains("chips detected")), "chains: {s:?}");
|
||||
assert!(s.iter().any(|l| l.contains("Errors: 1")), "errors: {s:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn summarize_detects_no_pic_miner() {
|
||||
let log = "[t] ERROR: This is a no-PIC miner, so all connected chains ...\n[t] INFO: mining";
|
||||
let s = summarize_log(log);
|
||||
assert!(s.iter().any(|l| l.contains("PIC: not present")), "{s:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn summarize_handles_no_pic_lines() {
|
||||
let log = "[t] INFO: chain#1 - 126 chips detected\n[t] INFO: mining";
|
||||
let s = summarize_log(log);
|
||||
assert!(s.iter().any(|l| l.contains("no PIC lines")), "{s:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn tail_trims_on_line_boundary() {
|
||||
let log = "aaaa\nbbbb\ncccc\n";
|
||||
|
||||
@@ -43,27 +43,17 @@ fn main() {
|
||||
std::process::exit(0);
|
||||
}
|
||||
|
||||
// Headless log-scan check: `ALKANE_LOG_SCAN="<ip> <brand> <firmware>"` fetches
|
||||
// the miner's log over its firmware API and prints the regex summary (round
|
||||
// 12 #12), so the VNish/Antminer/WhatsMiner log paths can be verified without
|
||||
// the GUI.
|
||||
// Headless log-scan check: `ALKANE_LOG_SCAN="<ip> <brand>"` fetches the miner's
|
||||
// log through asic-rs's per-backend read_logs() (round 19 #11-16), so the log
|
||||
// paths can be verified without the GUI. WhatsMiner falls back to fault codes.
|
||||
if let Some(spec) = std::env::var_os("ALKANE_LOG_SCAN") {
|
||||
let spec = spec.to_string_lossy();
|
||||
let mut it = spec.split_whitespace();
|
||||
let ip = it.next().unwrap_or("");
|
||||
let brand = it.next().unwrap_or("");
|
||||
let firmware = it.next().unwrap_or("");
|
||||
let (au, ap) = credentials::load_credentials().unwrap_or_else(|| ("root".into(), "root".into()));
|
||||
let vp = credentials::firmware_default_for("VNish").1;
|
||||
let vp = if vp.is_empty() { "admin".to_string() } else { vp };
|
||||
match log_scan::scan_log(ip, brand, firmware, &vp, &au, &ap) {
|
||||
Ok(s) => {
|
||||
println!("LOGSCAN {ip} ({brand}/{firmware}): {} log bytes", s.text.len());
|
||||
for line in &s.summary {
|
||||
println!(" {line}");
|
||||
}
|
||||
}
|
||||
Err(e) => println!("LOGSCAN {ip} ({brand}/{firmware}): ERROR {e}"),
|
||||
match log_scan::scan_log(ip, brand, scan::load_scan_timeout()) {
|
||||
Ok(s) => println!("LOGSCAN {ip} ({brand}): {} log bytes", s.text.len()),
|
||||
Err(e) => println!("LOGSCAN {ip} ({brand}): ERROR {e}"),
|
||||
}
|
||||
std::process::exit(0);
|
||||
}
|
||||
|
||||
@@ -66,8 +66,8 @@ pub fn format_si(value_base: f64, unit: &str) -> String {
|
||||
}
|
||||
|
||||
/// Like `format_si` but for a cooling-fan RPM reading: no unit/space suffix,
|
||||
/// and "-" (rather than "0") for an absent/non-positive reading, since a fan
|
||||
/// column packs several of these per cell (see `Column::Cooling`).
|
||||
/// and "-" (rather than "0") for an absent/non-positive reading (see the per-fan
|
||||
/// `Column::Fan1`..`Fan4` columns).
|
||||
pub fn format_fan_rpm(rpm: f64) -> String {
|
||||
match si_mantissa_and_prefix(rpm) {
|
||||
Some((num, prefix)) => format!("{num}{prefix}"),
|
||||
@@ -82,6 +82,17 @@ pub fn format_hashrate_ths(ths: f64) -> Option<String> {
|
||||
si_mantissa_and_prefix(ths * 1e12).map(|(num, prefix)| format!("{num}{prefix}"))
|
||||
}
|
||||
|
||||
/// The current-hashrate reading for the combined Hashrate cell, distinguishing a
|
||||
/// reported zero from an unreadable one: `Some("0.00T")` when the firmware reported
|
||||
/// a hashrate that rounds to zero, `Some("<n>T")` for a positive reading, and
|
||||
/// `None` (renders as the "-" dash) only when the hashrate is unreadable/absent.
|
||||
pub fn format_hashrate_actual(ths: f64, known: bool) -> Option<String> {
|
||||
if !known {
|
||||
return None;
|
||||
}
|
||||
Some(format_hashrate_ths(ths).unwrap_or_else(|| "0.00T".to_string()))
|
||||
}
|
||||
|
||||
/// A hashrate number (no unit) for a given mining algorithm (round 18 #7). asic-rs
|
||||
/// stores every hashrate normalised to "TH/s", but for Equihash the underlying
|
||||
/// count is Sol/s that it reinterprets through the base H unit, so `ths * 1e12`
|
||||
@@ -106,12 +117,42 @@ pub fn actual_expected_ratio(actual: f64, expected: f64) -> Option<f64> {
|
||||
if expected > 0.0 { Some(actual / expected) } else { None }
|
||||
}
|
||||
|
||||
/// Mean of `vals`, or `default` when empty -- a scalar sort key for the
|
||||
/// slash-joined per-board columns (round 19 #10).
|
||||
fn avg_or(vals: &[f64], default: f64) -> f64 {
|
||||
if vals.is_empty() {
|
||||
default
|
||||
} else {
|
||||
vals.iter().sum::<f64>() / vals.len() as f64
|
||||
}
|
||||
}
|
||||
|
||||
/// Mean of the POSITIVE entries in `vals`, or `default` when none are positive.
|
||||
/// Board voltage/frequency store 0.0 for a board that reports no value (rendered
|
||||
/// "-"), so a plain average would drag the sort/filter key toward zero and
|
||||
/// mis-rank the miner (round 19 review); this skips those placeholders.
|
||||
fn avg_positive(vals: &[f64], default: f64) -> f64 {
|
||||
let (sum, n) = vals.iter().filter(|&&v| v > 0.0).fold((0.0, 0usize), |(s, n), &v| (s + v, n + 1));
|
||||
if n == 0 { default } else { sum / n as f64 }
|
||||
}
|
||||
|
||||
/// Render a per-board vector as one slash-joined cell (blank when empty), each
|
||||
/// value formatted by `f` -- the shared shape of the Board HR/V/freq columns
|
||||
/// (round 19 #10).
|
||||
fn join_board(vals: &[f64], f: impl Fn(f64) -> String) -> String {
|
||||
if vals.is_empty() {
|
||||
String::new()
|
||||
} else {
|
||||
vals.iter().map(|&v| f(v)).collect::<Vec<_>>().join(" / ")
|
||||
}
|
||||
}
|
||||
|
||||
/// Render the combined Hashrate cell "actual/expected" (no spaces around the
|
||||
/// slash, prefix-only unit): blank when neither is known, the bare actual when
|
||||
/// only it is known, "-/<expected>" when only the expected is known, and
|
||||
/// "<actual>/<expected>" when both are (e.g. "80.5T/95.0T").
|
||||
fn combined_si(actual_ths: f64, expected_ths: f64) -> String {
|
||||
match (format_hashrate_ths(actual_ths), format_hashrate_ths(expected_ths)) {
|
||||
fn combined_si(actual_ths: f64, actual_known: bool, expected_ths: f64) -> String {
|
||||
match (format_hashrate_actual(actual_ths, actual_known), format_hashrate_ths(expected_ths)) {
|
||||
(None, None) => String::new(),
|
||||
(Some(a), None) => a,
|
||||
(None, Some(e)) => format!("-/{e}"),
|
||||
@@ -443,6 +484,11 @@ pub struct MinerRow {
|
||||
pub board_code: String,
|
||||
/// Mining algorithm (e.g. "SHA256", "Scrypt", "Equihash"), from asic-rs.
|
||||
pub algorithm: String,
|
||||
/// ASIC chip type/model (e.g. "BM1370") and hashboard model/part
|
||||
/// (e.g. "A3HB70601"), where the firmware reports them (round 19 #10:
|
||||
/// WhatsMiner, Braiins, ePIC; not exposed by Antminer/LuxOS). Empty = unknown.
|
||||
pub chip_type: String,
|
||||
pub hashboard_model: String,
|
||||
/// Whether the hashboards carry a PIC MCU. asic-rs does not report this over
|
||||
/// the network, so it is a best-effort inference (model-string heuristic):
|
||||
/// `None` = unknown, `Some(true)` = PIC, `Some(false)` = noPIC. True
|
||||
@@ -461,6 +507,16 @@ pub struct MinerRow {
|
||||
pub faults: Vec<Fault>,
|
||||
// performance
|
||||
pub hashrate_ths: f64,
|
||||
/// Whether the firmware actually reported a current hashrate. A reported 0
|
||||
/// renders as "0.00T"; only an unreadable/absent reading (this is false) shows
|
||||
/// the "-" dash. `hashrate_ths` alone can't distinguish the two (both are 0.0).
|
||||
pub hashrate_known: bool,
|
||||
/// Rolling average hashrate windows in TH/s (round 19 #10, T2): 1m/5m/15m/24h.
|
||||
/// 0.0 means the firmware does not report that window.
|
||||
pub hashrate_1m_ths: f64,
|
||||
pub hashrate_5m_ths: f64,
|
||||
pub hashrate_15m_ths: f64,
|
||||
pub hashrate_24h_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
|
||||
@@ -486,6 +542,9 @@ pub struct MinerRow {
|
||||
/// 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,
|
||||
/// PSU serial number where the firmware reports it (round 19 #10: Braiins,
|
||||
/// WhatsMiner V3, VNish). Empty = unknown.
|
||||
pub psu_serial: 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",
|
||||
@@ -519,9 +578,17 @@ pub struct MinerRow {
|
||||
/// (round 11 #17).
|
||||
pub env_temp_c: f64,
|
||||
pub outlet_temp_c: f64,
|
||||
/// Board temperature safety thresholds in Celsius (round 19 #10, T3): target /
|
||||
/// hot / dangerous. `None` per field when the firmware does not report it.
|
||||
pub temp_target_c: Option<f64>,
|
||||
pub temp_hot_c: Option<f64>,
|
||||
pub temp_dangerous_c: Option<f64>,
|
||||
/// Individual cooling-fan RPMs (empty if unknown). PSU fan is tracked
|
||||
/// separately below since it is not part of the cooling-fan set.
|
||||
pub fan_rpms: Vec<f64>,
|
||||
/// Miner-level fan duty cycle as a percentage (round 19 #10, T3); `None` when
|
||||
/// the firmware does not report it (no firmware exposes a maximum RPM).
|
||||
pub fan_speed_percent: Option<f64>,
|
||||
pub psu_fan_rpm: f64,
|
||||
pub fan_count: Option<u32>,
|
||||
pub expected_fans: Option<u32>,
|
||||
@@ -542,10 +609,23 @@ pub struct MinerRow {
|
||||
// shares
|
||||
pub best_share: Option<f64>,
|
||||
pub session_best_share: Option<f64>,
|
||||
/// Accepted / rejected share counts, summed across all configured pools
|
||||
/// (round 19 #10). `None` when the firmware reports neither.
|
||||
pub accepted_shares: Option<u64>,
|
||||
pub rejected_shares: Option<u64>,
|
||||
/// Cumulative share statistics from the miner summary (round 19 #10, T2):
|
||||
/// difficulty-weighted accepted / rejected work, raw stale count, and blocks
|
||||
/// found. `None` where the firmware does not report the value.
|
||||
pub difficulty_accepted: Option<f64>,
|
||||
pub difficulty_rejected: Option<f64>,
|
||||
pub stale_shares: Option<u64>,
|
||||
pub found_blocks: Option<u64>,
|
||||
// state
|
||||
pub uptime_secs: u64,
|
||||
pub light_flashing: Option<bool>,
|
||||
pub operating_state: String,
|
||||
/// Auto-tuner status label (round 19 #10, T3); empty when not reported.
|
||||
pub tuner_status: String,
|
||||
pub is_mining: bool,
|
||||
pub slow: bool,
|
||||
/// Not-mining because an operator paused it (distinct from simply idle);
|
||||
@@ -870,6 +950,39 @@ impl MinerRow {
|
||||
}
|
||||
}
|
||||
|
||||
/// Rejected-share percentage of all submitted shares (round 19 #10), or
|
||||
/// `None` when the firmware reports neither count.
|
||||
pub fn reject_ratio(&self) -> Option<f64> {
|
||||
match (self.accepted_shares, self.rejected_shares) {
|
||||
(Some(a), Some(r)) => {
|
||||
let total = a.saturating_add(r);
|
||||
Some(if total > 0 { r as f64 / total as f64 * 100.0 } else { 0.0 })
|
||||
}
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
/// Efficiency as (value, unit) for display, computed per algorithm (round 19
|
||||
/// #9/#23). asic-rs stores efficiency as watts-per-TH for EVERY algorithm,
|
||||
/// which is meaningless for Equihash (whose rate is really Sol/s reinterpreted
|
||||
/// through the base H unit), so recompute J-per-thousand-Sol there from the
|
||||
/// real Sol/s count. SHA256/Scrypt families reuse asic-rs's J/TH value.
|
||||
/// `None` when power or hashrate is unknown, so the cell stays blank rather
|
||||
/// than showing a garbage or zero figure.
|
||||
pub fn efficiency_display(&self) -> Option<(f64, &'static str)> {
|
||||
if self.algorithm.eq_ignore_ascii_case("equihash") {
|
||||
if self.power_w <= 0.0 || self.hashrate_ths <= 0.0 {
|
||||
return None;
|
||||
}
|
||||
let sol_per_s = self.hashrate_ths * 1e12;
|
||||
Some((self.power_w / sol_per_s * 1000.0, "J/kSol"))
|
||||
} else if self.efficiency > 0.0 {
|
||||
Some((self.efficiency, "J/TH"))
|
||||
} else {
|
||||
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".
|
||||
@@ -948,8 +1061,20 @@ impl MinerRow {
|
||||
/// counted as operator-paused when it is not currently mining and its raw
|
||||
/// operating-state string says so (case-insensitively), shared by the live
|
||||
/// scan (`scan::to_row`) and the fixtures/tests.
|
||||
///
|
||||
/// "Paused" covers every intentional, resumable halt -- operator- or
|
||||
/// firmware-initiated -- not just the literal "Paused" state: a miner an operator
|
||||
/// stopped is halted on purpose, not broken, so it must read blue in Health and
|
||||
/// count under the Paused KPI rather than "not hashing". Firmwares spell it
|
||||
/// differently: VNish reports "stopped", Braiins uses Paused/Stopped/Suspended,
|
||||
/// others "paused". A failure is a distinct Error state (never matched here) and
|
||||
/// still reads as broken (round 19 #19).
|
||||
pub fn is_paused(operating_state: &str, is_mining: bool) -> bool {
|
||||
!is_mining && operating_state.to_lowercase().contains("pause")
|
||||
if is_mining {
|
||||
return false;
|
||||
}
|
||||
let s = operating_state.to_lowercase();
|
||||
s.contains("pause") || s.contains("stop") || s.contains("suspend")
|
||||
}
|
||||
|
||||
/// The typed-confirmation gate for the irreversible firmware-flash action: the
|
||||
@@ -972,9 +1097,28 @@ pub enum Column {
|
||||
/// column picker or the display order; it exists only as a `sort` target the
|
||||
/// Hashrate header cycles into.
|
||||
HashrateRel,
|
||||
/// Rolling average hashrate windows (round 19 #10, T2): 1m/5m/15m/24h, each a
|
||||
/// single TH/s value. Populated per firmware where the API exposes the window
|
||||
/// (LuxOS and Braiins report all four; WhatsMiner V1 1m/5m/15m, V3 1m/15m;
|
||||
/// Antminer/ePIC/VNish report none). Auto-hidden when empty across the fleet.
|
||||
Hashrate1m,
|
||||
Hashrate5m,
|
||||
Hashrate15m,
|
||||
Hashrate24h,
|
||||
Power,
|
||||
ChipTemp,
|
||||
Cooling,
|
||||
// Per-fan RPM columns (round 19 #8): the old single "Fan (RPM)" column packed
|
||||
// every fan into one slash-joined cell; these split it into one column per fan
|
||||
// (fans 1-4), auto-hidden when a miner has fewer. asic-rs exposes no maximum /
|
||||
// target RPM, so each shows the actual RPM only.
|
||||
Fan1,
|
||||
Fan2,
|
||||
Fan3,
|
||||
Fan4,
|
||||
/// Miner-level fan duty cycle % (round 19 #10, T3). No firmware exposes a
|
||||
/// maximum RPM, so this normalized duty cycle is the fan-load indicator.
|
||||
/// Populated on ePIC, LuxOS, and Braiins; others leave it empty (auto-hidden).
|
||||
FanSpeedPercent,
|
||||
Firmware,
|
||||
FwVersion,
|
||||
Worker,
|
||||
@@ -999,22 +1143,30 @@ pub enum Column {
|
||||
FluidTemp,
|
||||
EnvTemp,
|
||||
OutletTemp,
|
||||
/// Board temperature safety thresholds (round 19 #10, T3): target / hot /
|
||||
/// dangerous. Populated where the firmware reports them (LuxOS full set, ePIC
|
||||
/// hot+dangerous, Braiins defaults, VNish target+dangerous); auto-hidden empty.
|
||||
TargetTemp,
|
||||
HotTemp,
|
||||
DangerousTemp,
|
||||
PsuFan,
|
||||
/// PSU identity + rated voltage envelope (round 17 R5). Populated where the
|
||||
/// firmware exposes PSU info (ePIC today).
|
||||
PsuVersion,
|
||||
PsuSerial,
|
||||
PsuVMin,
|
||||
PsuVMax,
|
||||
FanCount,
|
||||
ExpectedFans,
|
||||
TotalChips,
|
||||
Hashboards,
|
||||
Mac,
|
||||
Hostname,
|
||||
Serial,
|
||||
ApiVersion,
|
||||
Cpu,
|
||||
BoardCode,
|
||||
ChipType,
|
||||
HbType,
|
||||
Algorithm,
|
||||
Pic,
|
||||
Locked,
|
||||
@@ -1022,9 +1174,30 @@ pub enum Column {
|
||||
Uptime,
|
||||
Light,
|
||||
OperatingState,
|
||||
/// Auto-tuner status label (round 19 #10, T3); Braiins/ePIC today.
|
||||
Tuner,
|
||||
BestShare,
|
||||
SessionBestShare,
|
||||
TuningPercent,
|
||||
// Round 19 #10: more scanned values surfaced as columns.
|
||||
/// Current tuning target (power or hashrate), e.g. "3200 W" or "100 TH".
|
||||
Target,
|
||||
/// Accepted / rejected share counts and the rejection ratio.
|
||||
Accepted,
|
||||
Rejected,
|
||||
RejectRatio,
|
||||
/// Cumulative share statistics (round 19 #10, T2): difficulty-weighted
|
||||
/// accepted / rejected work, raw stale count, and blocks found. Populated on
|
||||
/// the cgminer family (Antminer, LuxOS, WhatsMiner V1/V2); other firmwares
|
||||
/// leave them empty (auto-hidden).
|
||||
DiffAccepted,
|
||||
DiffRejected,
|
||||
StaleShares,
|
||||
Blocks,
|
||||
/// Per-hashboard hashrate / voltage / frequency, slash-joined like Chip temp.
|
||||
BoardHashrate,
|
||||
BoardVoltage,
|
||||
BoardFrequency,
|
||||
PoolUrl,
|
||||
Pool1Url,
|
||||
Pool1Worker,
|
||||
@@ -1036,22 +1209,27 @@ 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; 47] = [
|
||||
pub const ALL_COLUMNS: [Column; 72] = [
|
||||
Column::Ip,
|
||||
Column::Hashrate,
|
||||
Column::Hashrate1m,
|
||||
Column::Hashrate5m,
|
||||
Column::Hashrate15m,
|
||||
Column::Hashrate24h,
|
||||
Column::Health,
|
||||
// The detailed per-board dot column (round 11 #10). Not in DEFAULT_VISIBLE
|
||||
// (the Health column shows composite board health by default), but it belongs
|
||||
// in ALL_COLUMNS so it is selectable in the column picker (round 18 #12: it
|
||||
// was accidentally omitted, making the column unreachable).
|
||||
Column::Hashboards,
|
||||
Column::Power,
|
||||
Column::ChipTemp,
|
||||
Column::Cooling,
|
||||
Column::Fan1,
|
||||
Column::Fan2,
|
||||
Column::Fan3,
|
||||
Column::Fan4,
|
||||
Column::FanSpeedPercent,
|
||||
Column::Firmware,
|
||||
Column::FwVersion,
|
||||
Column::Worker,
|
||||
// Pool account (the part before the dot) before Worker (the rig part after
|
||||
// it), per round 19 #22.
|
||||
Column::PoolAccount,
|
||||
Column::Worker,
|
||||
Column::Model,
|
||||
Column::Brand,
|
||||
Column::Submodel,
|
||||
@@ -1059,8 +1237,12 @@ pub const ALL_COLUMNS: [Column; 47] = [
|
||||
Column::FluidTemp,
|
||||
Column::EnvTemp,
|
||||
Column::OutletTemp,
|
||||
Column::TargetTemp,
|
||||
Column::HotTemp,
|
||||
Column::DangerousTemp,
|
||||
Column::PsuFan,
|
||||
Column::PsuVersion,
|
||||
Column::PsuSerial,
|
||||
Column::PsuVMin,
|
||||
Column::PsuVMax,
|
||||
Column::FanCount,
|
||||
@@ -1072,15 +1254,29 @@ pub const ALL_COLUMNS: [Column; 47] = [
|
||||
Column::ApiVersion,
|
||||
Column::Cpu,
|
||||
Column::BoardCode,
|
||||
Column::ChipType,
|
||||
Column::HbType,
|
||||
Column::Algorithm,
|
||||
Column::Pic,
|
||||
Column::Locked,
|
||||
Column::Uptime,
|
||||
Column::Light,
|
||||
Column::OperatingState,
|
||||
Column::Tuner,
|
||||
Column::BestShare,
|
||||
Column::SessionBestShare,
|
||||
Column::TuningPercent,
|
||||
Column::Target,
|
||||
Column::Accepted,
|
||||
Column::Rejected,
|
||||
Column::RejectRatio,
|
||||
Column::DiffAccepted,
|
||||
Column::DiffRejected,
|
||||
Column::StaleShares,
|
||||
Column::Blocks,
|
||||
Column::BoardHashrate,
|
||||
Column::BoardVoltage,
|
||||
Column::BoardFrequency,
|
||||
Column::PoolUrl,
|
||||
Column::Pool1Url,
|
||||
Column::Pool1Worker,
|
||||
@@ -1113,9 +1309,28 @@ impl Column {
|
||||
Column::Ip => "IP",
|
||||
Column::Hashrate => "Hashrate",
|
||||
Column::HashrateRel => "Rel. hashrate",
|
||||
Column::Hashrate1m => "HR 1m",
|
||||
Column::Hashrate5m => "HR 5m",
|
||||
Column::Hashrate15m => "HR 15m",
|
||||
Column::Hashrate24h => "HR 24h",
|
||||
Column::Power => "Power",
|
||||
Column::ChipTemp => "Chip temp",
|
||||
Column::Cooling => "Fan (RPM)",
|
||||
Column::Fan1 => "Fan 1 (RPM)",
|
||||
Column::Fan2 => "Fan 2 (RPM)",
|
||||
Column::Fan3 => "Fan 3 (RPM)",
|
||||
Column::Fan4 => "Fan 4 (RPM)",
|
||||
Column::FanSpeedPercent => "Fan %",
|
||||
Column::Target => "Target",
|
||||
Column::Accepted => "Accepted",
|
||||
Column::Rejected => "Rejected",
|
||||
Column::RejectRatio => "Reject %",
|
||||
Column::DiffAccepted => "Diff acc",
|
||||
Column::DiffRejected => "Diff rej",
|
||||
Column::StaleShares => "Stale",
|
||||
Column::Blocks => "Blocks",
|
||||
Column::BoardHashrate => "Board HR",
|
||||
Column::BoardVoltage => "Board V",
|
||||
Column::BoardFrequency => "Board freq",
|
||||
Column::Firmware => "Firmware",
|
||||
Column::FwVersion => "FW Version",
|
||||
Column::Worker => "Worker",
|
||||
@@ -1128,24 +1343,29 @@ impl Column {
|
||||
Column::HealthFans => "Health (fans)",
|
||||
Column::HealthBoards => "Health (boards)",
|
||||
Column::Status => "Status",
|
||||
Column::Efficiency => "Efficiency (J/TH)",
|
||||
Column::Efficiency => "Efficiency",
|
||||
Column::FluidTemp => "Fluid temp",
|
||||
Column::EnvTemp => "Env temp",
|
||||
Column::OutletTemp => "Outlet temp",
|
||||
Column::TargetTemp => "Target temp",
|
||||
Column::HotTemp => "Hot temp",
|
||||
Column::DangerousTemp => "Dangerous temp",
|
||||
Column::PsuFan => "PSU fan (RPM)",
|
||||
Column::PsuVersion => "PSU version",
|
||||
Column::PsuSerial => "PSU serial",
|
||||
Column::PsuVMin => "PSU Vmin",
|
||||
Column::PsuVMax => "PSU Vmax",
|
||||
Column::FanCount => "Fans",
|
||||
Column::ExpectedFans => "Fans (exp)",
|
||||
Column::TotalChips => "Chips",
|
||||
Column::Hashboards => "Boards",
|
||||
Column::Mac => "MAC",
|
||||
Column::Hostname => "Hostname",
|
||||
Column::Serial => "Serial",
|
||||
Column::ApiVersion => "API ver",
|
||||
Column::Cpu => "CPU",
|
||||
Column::BoardCode => "Control Board",
|
||||
Column::ChipType => "Chip",
|
||||
Column::HbType => "HB model",
|
||||
Column::Algorithm => "Algorithm",
|
||||
Column::Pic => "PIC",
|
||||
Column::Locked => "Access",
|
||||
@@ -1153,6 +1373,7 @@ impl Column {
|
||||
Column::Uptime => "Uptime",
|
||||
Column::Light => "Light",
|
||||
Column::OperatingState => "State",
|
||||
Column::Tuner => "Tuner",
|
||||
Column::BestShare => "Best share",
|
||||
Column::SessionBestShare => "Session best",
|
||||
Column::TuningPercent => "Tuning %",
|
||||
@@ -1171,10 +1392,22 @@ impl Column {
|
||||
Column::Ip => 130,
|
||||
Column::Hashrate => 110,
|
||||
Column::HashrateRel => 110,
|
||||
Column::Hashrate1m | Column::Hashrate5m | Column::Hashrate15m | Column::Hashrate24h => {
|
||||
95
|
||||
}
|
||||
Column::Power => 90,
|
||||
Column::ChipTemp | Column::FluidTemp | Column::EnvTemp | Column::OutletTemp => 95,
|
||||
Column::Cooling | Column::PsuFan => 100,
|
||||
Column::TargetTemp | Column::HotTemp | Column::DangerousTemp => 105,
|
||||
Column::Fan1 | Column::Fan2 | Column::Fan3 | Column::Fan4 | Column::PsuFan => 90,
|
||||
Column::FanSpeedPercent => 80,
|
||||
Column::Target => 110,
|
||||
Column::Accepted | Column::Rejected => 100,
|
||||
Column::RejectRatio => 90,
|
||||
Column::DiffAccepted | Column::DiffRejected => 110,
|
||||
Column::StaleShares | Column::Blocks => 80,
|
||||
Column::BoardHashrate | Column::BoardVoltage | Column::BoardFrequency => 130,
|
||||
Column::PsuVersion => 100,
|
||||
Column::PsuSerial => 150,
|
||||
Column::PsuVMin | Column::PsuVMax => 90,
|
||||
Column::Firmware => 110,
|
||||
Column::FwVersion => 130,
|
||||
@@ -1189,18 +1422,21 @@ impl Column {
|
||||
Column::HealthPower | Column::HealthFans | Column::HealthBoards => 170,
|
||||
Column::Status => 95,
|
||||
Column::Efficiency => 120,
|
||||
Column::FanCount | Column::TotalChips | Column::Hashboards => 70,
|
||||
Column::FanCount | Column::TotalChips => 70,
|
||||
Column::ExpectedFans | Column::TuningPercent => 90,
|
||||
Column::Mac | Column::Hostname | Column::Serial => 150,
|
||||
Column::ApiVersion | Column::Light => 90,
|
||||
Column::Cpu => 70,
|
||||
Column::BoardCode => 70,
|
||||
Column::ChipType => 90,
|
||||
Column::HbType => 110,
|
||||
Column::Algorithm => 100,
|
||||
Column::Pic => 70,
|
||||
Column::Locked => 90,
|
||||
Column::Error => 160,
|
||||
Column::Uptime => 100,
|
||||
Column::OperatingState => 100,
|
||||
Column::Tuner => 100,
|
||||
Column::BestShare | Column::SessionBestShare => 110,
|
||||
Column::PoolUrl | Column::Pool1Url | Column::Pool2Url | Column::Pool3Url => 200,
|
||||
Column::Pool1Worker | Column::Pool2Worker | Column::Pool3Worker => 150,
|
||||
@@ -1215,20 +1451,40 @@ impl Column {
|
||||
self,
|
||||
Column::Hashrate
|
||||
| Column::HashrateRel
|
||||
| Column::Hashrate1m
|
||||
| Column::Hashrate5m
|
||||
| Column::Hashrate15m
|
||||
| Column::Hashrate24h
|
||||
| Column::Power
|
||||
| Column::Efficiency
|
||||
| Column::ChipTemp
|
||||
| Column::FluidTemp
|
||||
| Column::EnvTemp
|
||||
| Column::OutletTemp
|
||||
| Column::Cooling
|
||||
| Column::TargetTemp
|
||||
| Column::HotTemp
|
||||
| Column::DangerousTemp
|
||||
| Column::Fan1
|
||||
| Column::Fan2
|
||||
| Column::Fan3
|
||||
| Column::Fan4
|
||||
| Column::FanSpeedPercent
|
||||
| Column::Accepted
|
||||
| Column::Rejected
|
||||
| Column::RejectRatio
|
||||
| Column::DiffAccepted
|
||||
| Column::DiffRejected
|
||||
| Column::StaleShares
|
||||
| Column::Blocks
|
||||
| Column::BoardHashrate
|
||||
| Column::BoardVoltage
|
||||
| Column::BoardFrequency
|
||||
| Column::PsuFan
|
||||
| Column::PsuVMin
|
||||
| Column::PsuVMax
|
||||
| Column::FanCount
|
||||
| Column::ExpectedFans
|
||||
| Column::TotalChips
|
||||
| Column::Hashboards
|
||||
| Column::Uptime
|
||||
| Column::BestShare
|
||||
| Column::SessionBestShare
|
||||
@@ -1243,25 +1499,21 @@ impl Column {
|
||||
/// here so a filter like "ChipTemp <= 50" cannot match a miner with no
|
||||
/// temperature reading.
|
||||
pub fn num_value(&self, r: &MinerRow) -> Option<f64> {
|
||||
// The 3 combined (actual/expected) columns must never let a numeric
|
||||
// filter match a row that only has an expected value: their cell()
|
||||
// The combined (actual/expected) columns (Hashrate, TotalChips) must never
|
||||
// let a numeric filter match a row that only has an expected value: their cell()
|
||||
// renders "- / <expected>" (non-empty) in that case, so the generic
|
||||
// blank check below is not enough on its own.
|
||||
match self {
|
||||
Column::Hashrate if r.hashrate_ths <= 0.0 => return None,
|
||||
Column::Hashboards if r.hashboards.is_none() => return None,
|
||||
// An unreadable hashrate has no numeric value; a reported 0 does (0.0),
|
||||
// so a filter like "hashrate > 0" excludes a stopped miner but "<= 50"
|
||||
// still matches it.
|
||||
Column::Hashrate if !r.hashrate_known => return None,
|
||||
Column::TotalChips if r.total_chips.is_none() => return None,
|
||||
_ => {}
|
||||
}
|
||||
if !self.is_numeric() || self.cell(r).is_empty() {
|
||||
return None;
|
||||
}
|
||||
// The Boards column's sort_key is a composite (online*100 + total) tuned
|
||||
// for sorting; a numeric filter must compare the actual detected board
|
||||
// count the cell shows, not that score (round 18 #12).
|
||||
if let Column::Hashboards = self {
|
||||
return r.hashboards.map(|v| v as f64);
|
||||
}
|
||||
match self.sort_key(r) {
|
||||
SortKey::Num(v) if v.is_finite() => Some(v),
|
||||
_ => None,
|
||||
@@ -1275,43 +1527,59 @@ impl Column {
|
||||
let none = f64::NEG_INFINITY;
|
||||
match self {
|
||||
Column::Hashrate => SortKey::Num(r.hashrate_ths),
|
||||
// Rolling average windows; a 0.0 (window not reported) sorts to the
|
||||
// bottom (round 19 #10, T2).
|
||||
Column::Hashrate1m => {
|
||||
SortKey::Num(if r.hashrate_1m_ths > 0.0 { r.hashrate_1m_ths } else { none })
|
||||
}
|
||||
Column::Hashrate5m => {
|
||||
SortKey::Num(if r.hashrate_5m_ths > 0.0 { r.hashrate_5m_ths } else { none })
|
||||
}
|
||||
Column::Hashrate15m => {
|
||||
SortKey::Num(if r.hashrate_15m_ths > 0.0 { r.hashrate_15m_ths } else { none })
|
||||
}
|
||||
Column::Hashrate24h => {
|
||||
SortKey::Num(if r.hashrate_24h_ths > 0.0 { r.hashrate_24h_ths } else { none })
|
||||
}
|
||||
// Relative hashrate = actual/expected; unknown expectation sorts to
|
||||
// the bottom (round 11 #16).
|
||||
Column::HashrateRel => {
|
||||
SortKey::Num(actual_expected_ratio(r.hashrate_ths, r.expected_ths).unwrap_or(none))
|
||||
}
|
||||
Column::Power => SortKey::Num(r.power_w),
|
||||
Column::Efficiency => SortKey::Num(if r.efficiency > 0.0 { r.efficiency } else { none }),
|
||||
Column::Efficiency => {
|
||||
SortKey::Num(r.efficiency_display().map(|(v, _)| v).unwrap_or(none))
|
||||
}
|
||||
Column::ChipTemp => SortKey::Num(r.chip_temp_c),
|
||||
Column::FluidTemp => SortKey::Num(r.fluid_temp_c),
|
||||
Column::EnvTemp => SortKey::Num(r.env_temp_c),
|
||||
Column::OutletTemp => SortKey::Num(r.outlet_temp_c),
|
||||
Column::Cooling => SortKey::Num(if r.fan_rpms.is_empty() {
|
||||
none
|
||||
} else {
|
||||
r.fan_rpms.iter().cloned().fold(f64::INFINITY, f64::min)
|
||||
}),
|
||||
Column::TargetTemp => SortKey::Num(r.temp_target_c.unwrap_or(none)),
|
||||
Column::HotTemp => SortKey::Num(r.temp_hot_c.unwrap_or(none)),
|
||||
Column::DangerousTemp => SortKey::Num(r.temp_dangerous_c.unwrap_or(none)),
|
||||
Column::Fan1 => SortKey::Num(r.fan_rpms.first().copied().unwrap_or(none)),
|
||||
Column::Fan2 => SortKey::Num(r.fan_rpms.get(1).copied().unwrap_or(none)),
|
||||
Column::Fan3 => SortKey::Num(r.fan_rpms.get(2).copied().unwrap_or(none)),
|
||||
Column::Fan4 => SortKey::Num(r.fan_rpms.get(3).copied().unwrap_or(none)),
|
||||
Column::FanSpeedPercent => SortKey::Num(r.fan_speed_percent.unwrap_or(none)),
|
||||
Column::Accepted => SortKey::Num(r.accepted_shares.map(|v| v as f64).unwrap_or(none)),
|
||||
Column::Rejected => SortKey::Num(r.rejected_shares.map(|v| v as f64).unwrap_or(none)),
|
||||
Column::RejectRatio => SortKey::Num(r.reject_ratio().unwrap_or(none)),
|
||||
Column::DiffAccepted => SortKey::Num(r.difficulty_accepted.unwrap_or(none)),
|
||||
Column::DiffRejected => SortKey::Num(r.difficulty_rejected.unwrap_or(none)),
|
||||
Column::StaleShares => {
|
||||
SortKey::Num(r.stale_shares.map(|v| v as f64).unwrap_or(none))
|
||||
}
|
||||
Column::Blocks => SortKey::Num(r.found_blocks.map(|v| v as f64).unwrap_or(none)),
|
||||
Column::BoardHashrate => SortKey::Num(avg_or(&r.board_hashrates, none)),
|
||||
Column::BoardVoltage => SortKey::Num(avg_positive(&r.board_voltages, none)),
|
||||
Column::BoardFrequency => SortKey::Num(avg_positive(&r.board_frequencies, none)),
|
||||
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)),
|
||||
// The Boards column shows per-hashboard health dots, so sort by the
|
||||
// number of ONLINE (green) boards -- surfacing units with dead/missing
|
||||
// boards -- with the total board count as a tiebreaker (so full-health
|
||||
// units still order by how many boards they have). Falls back to the
|
||||
// reported board count when no per-board health is available (round 11).
|
||||
Column::Hashboards => {
|
||||
if r.board_status.is_empty() {
|
||||
SortKey::Num(r.hashboards.map(|v| v as f64).unwrap_or(none))
|
||||
} else {
|
||||
let online =
|
||||
r.board_status.iter().filter(|h| matches!(h, BoardHealth::Ok)).count();
|
||||
let total = r.board_status.len();
|
||||
SortKey::Num((online * 100 + total) as f64)
|
||||
}
|
||||
}
|
||||
Column::Uptime => SortKey::Num(if r.uptime_secs > 0 { r.uptime_secs as f64 } else { none }),
|
||||
Column::BestShare => SortKey::Num(r.best_share.unwrap_or(none)),
|
||||
Column::SessionBestShare => SortKey::Num(r.session_best_share.unwrap_or(none)),
|
||||
@@ -1346,7 +1614,13 @@ impl Column {
|
||||
let pool_worker = |i: usize| r.pools.get(i).map(|(_, w)| w.clone()).unwrap_or_default();
|
||||
match self {
|
||||
Column::Ip => r.ip.clone(),
|
||||
Column::Hashrate => combined_si(r.hashrate_ths, r.expected_ths),
|
||||
Column::Hashrate => combined_si(r.hashrate_ths, r.hashrate_known, r.expected_ths),
|
||||
// Rolling average windows: a single TH/s value, blank when not reported
|
||||
// (round 19 #10, T2).
|
||||
Column::Hashrate1m => format_hashrate_ths(r.hashrate_1m_ths).unwrap_or_default(),
|
||||
Column::Hashrate5m => format_hashrate_ths(r.hashrate_5m_ths).unwrap_or_default(),
|
||||
Column::Hashrate15m => format_hashrate_ths(r.hashrate_15m_ths).unwrap_or_default(),
|
||||
Column::Hashrate24h => format_hashrate_ths(r.hashrate_24h_ths).unwrap_or_default(),
|
||||
// Never displayed as its own column; rendered as a percentage only for
|
||||
// completeness (e.g. a debug/self-test read of the cell).
|
||||
Column::HashrateRel => actual_expected_ratio(r.hashrate_ths, r.expected_ths)
|
||||
@@ -1359,7 +1633,12 @@ impl Column {
|
||||
String::new()
|
||||
}
|
||||
}
|
||||
Column::Efficiency => num(r.efficiency, 1, ""),
|
||||
// The unit lives in the value now, not the header (round 19 #9), and
|
||||
// is algorithm-aware (J/TH for SHA256 families, J/kSol for Equihash).
|
||||
Column::Efficiency => r
|
||||
.efficiency_display()
|
||||
.map(|(v, u)| format!("{v:.1} {u}"))
|
||||
.unwrap_or_default(),
|
||||
// Per-hashboard chip temps as integers ("77 / 64 / 74"); fall back to
|
||||
// the average (integer) when per-board readings aren't available.
|
||||
Column::ChipTemp => {
|
||||
@@ -1377,17 +1656,48 @@ impl Column {
|
||||
Column::FluidTemp => num(r.fluid_temp_c, 1, " C"),
|
||||
Column::EnvTemp => num(r.env_temp_c, 1, " C"),
|
||||
Column::OutletTemp => num(r.outlet_temp_c, 1, " C"),
|
||||
Column::Cooling => {
|
||||
r.fan_rpms.iter().map(|&v| format_fan_rpm(v)).collect::<Vec<_>>().join("/")
|
||||
Column::TargetTemp => r.temp_target_c.map(|v| num(v, 0, " C")).unwrap_or_default(),
|
||||
Column::HotTemp => r.temp_hot_c.map(|v| num(v, 0, " C")).unwrap_or_default(),
|
||||
Column::DangerousTemp => r.temp_dangerous_c.map(|v| num(v, 0, " C")).unwrap_or_default(),
|
||||
// Per-fan RPM: blank (not "-") when the fan index is absent, so a miner
|
||||
// with fewer fans leaves the extra Fan columns empty and auto-hide can
|
||||
// drop them (round 19 #8).
|
||||
Column::Fan1 => r.fan_rpms.first().map(|&v| format_fan_rpm(v)).unwrap_or_default(),
|
||||
Column::Fan2 => r.fan_rpms.get(1).map(|&v| format_fan_rpm(v)).unwrap_or_default(),
|
||||
Column::Fan3 => r.fan_rpms.get(2).map(|&v| format_fan_rpm(v)).unwrap_or_default(),
|
||||
Column::Fan4 => r.fan_rpms.get(3).map(|&v| format_fan_rpm(v)).unwrap_or_default(),
|
||||
Column::FanSpeedPercent => {
|
||||
r.fan_speed_percent.map(|v| format!("{v:.0}%")).unwrap_or_default()
|
||||
}
|
||||
Column::Target => r.tuning_target_label.clone().unwrap_or_default(),
|
||||
Column::Accepted => r.accepted_shares.map(|v| v.to_string()).unwrap_or_default(),
|
||||
Column::Rejected => r.rejected_shares.map(|v| v.to_string()).unwrap_or_default(),
|
||||
Column::RejectRatio => r.reject_ratio().map(|v| format!("{v:.2}%")).unwrap_or_default(),
|
||||
// Difficulty-weighted work (SI-formatted like Best share); raw stale /
|
||||
// block counts as plain integers (round 19 #10, T2).
|
||||
Column::DiffAccepted => r.difficulty_accepted.map(|v| format_si(v, "")).unwrap_or_default(),
|
||||
Column::DiffRejected => r.difficulty_rejected.map(|v| format_si(v, "")).unwrap_or_default(),
|
||||
Column::StaleShares => r.stale_shares.map(|v| v.to_string()).unwrap_or_default(),
|
||||
Column::Blocks => r.found_blocks.map(|v| v.to_string()).unwrap_or_default(),
|
||||
// Per-hashboard hashrate / voltage / frequency, slash-joined like Chip
|
||||
// temp; "-" for a board with no reading, blank when none at all.
|
||||
Column::BoardHashrate => join_board(&r.board_hashrates, |v| {
|
||||
format_hashrate_ths(v).unwrap_or_else(|| "-".to_string())
|
||||
}),
|
||||
Column::BoardVoltage => {
|
||||
join_board(&r.board_voltages, |v| if v > 0.0 { format!("{v:.2}") } else { "-".into() })
|
||||
}
|
||||
Column::BoardFrequency => {
|
||||
join_board(&r.board_frequencies, |v| if v > 0.0 { format!("{v:.0}") } else { "-".into() })
|
||||
}
|
||||
Column::PsuFan => num(r.psu_fan_rpm, 0, ""),
|
||||
Column::PsuVersion => r.psu_version.clone(),
|
||||
Column::PsuSerial => r.psu_serial.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),
|
||||
Column::Hashboards => combined_count(r.hashboards, r.expected_hashboards),
|
||||
Column::Firmware => r.firmware.clone(),
|
||||
Column::FwVersion => r.fw_version.clone(),
|
||||
Column::Worker => split_worker(&r.worker).1.to_string(),
|
||||
@@ -1402,6 +1712,8 @@ impl Column {
|
||||
Column::ApiVersion => r.api_version.clone(),
|
||||
Column::Cpu => r.cpu.clone(),
|
||||
Column::BoardCode => r.board_code.clone(),
|
||||
Column::ChipType => r.chip_type.clone(),
|
||||
Column::HbType => r.hashboard_model.clone(),
|
||||
Column::Algorithm => r.algorithm.clone(),
|
||||
Column::Pic => match r.pic_present {
|
||||
// A per-board PIC MCU is a known Antminer-hashboard property. Show
|
||||
@@ -1436,6 +1748,7 @@ impl Column {
|
||||
None => String::new(),
|
||||
},
|
||||
Column::OperatingState => r.operating_state.clone(),
|
||||
Column::Tuner => r.tuner_status.clone(),
|
||||
Column::BestShare => r.best_share.map(|v| format_si(v, "")).unwrap_or_default(),
|
||||
Column::SessionBestShare => {
|
||||
r.session_best_share.map(|v| format_si(v, "")).unwrap_or_default()
|
||||
@@ -1458,24 +1771,29 @@ impl Column {
|
||||
Column::Ip | Column::Model | Column::Brand | Column::Submodel | Column::Mac
|
||||
| Column::Hostname | Column::Serial => (0, "Identity"),
|
||||
Column::Firmware | Column::FwVersion | Column::ApiVersion | Column::Algorithm
|
||||
| Column::Pic | Column::Cpu | Column::BoardCode => (1, "Firmware & board"),
|
||||
| Column::Pic | Column::Cpu | Column::BoardCode | Column::ChipType
|
||||
| Column::HbType => (1, "Firmware & board"),
|
||||
Column::Health | Column::HealthPower | Column::HealthFans | Column::HealthBoards
|
||||
| Column::Status | Column::Error | Column::Locked | Column::Light
|
||||
| Column::OperatingState => (2, "Health & status"),
|
||||
Column::Hashrate | Column::HashrateRel | Column::Power | Column::Efficiency
|
||||
| Column::OperatingState | Column::Tuner => (2, "Health & status"),
|
||||
Column::Hashrate | Column::HashrateRel | Column::Hashrate1m | Column::Hashrate5m
|
||||
| Column::Hashrate15m | Column::Hashrate24h | Column::Power | Column::Efficiency
|
||||
| Column::TuningPercent | Column::BestShare | Column::SessionBestShare
|
||||
| Column::Uptime => (3, "Performance"),
|
||||
Column::ChipTemp | Column::FluidTemp | Column::EnvTemp | Column::OutletTemp => {
|
||||
| Column::Uptime | Column::Target | Column::BoardHashrate | Column::BoardVoltage
|
||||
| Column::BoardFrequency => (3, "Performance"),
|
||||
Column::ChipTemp | Column::FluidTemp | Column::EnvTemp | Column::OutletTemp
|
||||
| Column::TargetTemp | Column::HotTemp | Column::DangerousTemp => {
|
||||
(4, "Temperature")
|
||||
}
|
||||
Column::Cooling | Column::PsuFan | Column::FanCount | Column::ExpectedFans => {
|
||||
(5, "Cooling")
|
||||
}
|
||||
Column::TotalChips | Column::Hashboards | Column::PsuVersion | Column::PsuVMin
|
||||
Column::Fan1 | Column::Fan2 | Column::Fan3 | Column::Fan4 | Column::PsuFan
|
||||
| Column::FanCount | Column::ExpectedFans | Column::FanSpeedPercent => (5, "Cooling"),
|
||||
Column::TotalChips | Column::PsuVersion | Column::PsuSerial | 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"),
|
||||
| Column::Pool3Worker | Column::Accepted | Column::Rejected
|
||||
| Column::RejectRatio | Column::DiffAccepted | Column::DiffRejected
|
||||
| Column::StaleShares | Column::Blocks => (7, "Pools"),
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -2526,7 +2844,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn numeric_filter_operators() {
|
||||
let r = MinerRow { hashrate_ths: 100.0, is_mining: true, ..Default::default() };
|
||||
let r = MinerRow { hashrate_ths: 100.0, hashrate_known: true, is_mining: true, ..Default::default() };
|
||||
let c = Column::Hashrate;
|
||||
let n = |op, a: f64, b: f64| ColFilter::Num { op, a, b }.matches(c, &r);
|
||||
assert!(n(NumOp::Gt, 50.0, 0.0));
|
||||
@@ -2547,7 +2865,7 @@ mod tests {
|
||||
assert_eq!(Column::Firmware.num_value(&r), None, "text column");
|
||||
assert_eq!(Column::Ip.num_value(&r), None, "IP is text, not numeric");
|
||||
assert_eq!(Column::Efficiency.num_value(&r), None, "blank numeric -> None");
|
||||
let r2 = MinerRow { hashrate_ths: 42.0, ..Default::default() };
|
||||
let r2 = MinerRow { hashrate_ths: 42.0, hashrate_known: true, ..Default::default() };
|
||||
assert_eq!(Column::Hashrate.num_value(&r2), Some(42.0));
|
||||
}
|
||||
|
||||
@@ -2616,40 +2934,46 @@ mod tests {
|
||||
fn combined_cell_all_four_cases() {
|
||||
let neither = MinerRow::default();
|
||||
assert_eq!(Column::Hashrate.cell(&neither), "", "both unknown -> blank");
|
||||
assert_eq!(Column::Hashboards.cell(&neither), "");
|
||||
assert_eq!(Column::TotalChips.cell(&neither), "");
|
||||
|
||||
let actual_only = MinerRow {
|
||||
hashrate_ths: 60.0,
|
||||
hashboards: Some(3),
|
||||
hashrate_known: true,
|
||||
total_chips: Some(210),
|
||||
..Default::default()
|
||||
};
|
||||
assert_eq!(Column::Hashrate.cell(&actual_only), "60.0T", "only actual -> bare actual");
|
||||
assert_eq!(Column::Hashboards.cell(&actual_only), "3");
|
||||
assert_eq!(Column::TotalChips.cell(&actual_only), "210");
|
||||
|
||||
let expected_only = MinerRow {
|
||||
expected_ths: 200.0,
|
||||
expected_hashboards: Some(3),
|
||||
expected_chips: Some(228),
|
||||
..Default::default()
|
||||
};
|
||||
assert_eq!(Column::Hashrate.cell(&expected_only), "-/200T", "only expected -> '-/<expected>'");
|
||||
assert_eq!(Column::Hashboards.cell(&expected_only), "- / 3");
|
||||
assert_eq!(Column::Hashrate.cell(&expected_only), "-/200T", "only expected (actual unreadable) -> '-/<expected>'");
|
||||
assert_eq!(Column::TotalChips.cell(&expected_only), "- / 228");
|
||||
|
||||
// A reported zero is a real reading -> "0.00T", never the dash. The dash
|
||||
// (expected_only above) is reserved for an unreadable actual.
|
||||
let reported_zero = MinerRow {
|
||||
hashrate_ths: 0.0,
|
||||
hashrate_known: true,
|
||||
expected_ths: 200.0,
|
||||
..Default::default()
|
||||
};
|
||||
assert_eq!(Column::Hashrate.cell(&reported_zero), "0.00T/200T", "reported 0 -> 0.00T, not a dash");
|
||||
let reported_zero_no_expected = MinerRow { hashrate_ths: 0.0, hashrate_known: true, ..Default::default() };
|
||||
assert_eq!(Column::Hashrate.cell(&reported_zero_no_expected), "0.00T");
|
||||
|
||||
let both = MinerRow {
|
||||
hashrate_ths: 60.0,
|
||||
hashrate_known: true,
|
||||
expected_ths: 200.0,
|
||||
hashboards: Some(3),
|
||||
expected_hashboards: Some(3),
|
||||
total_chips: Some(190),
|
||||
expected_chips: Some(228),
|
||||
..Default::default()
|
||||
};
|
||||
assert_eq!(Column::Hashrate.cell(&both), "60.0T/200T", "both known -> '<actual>/<expected>'");
|
||||
assert_eq!(Column::Hashboards.cell(&both), "3 / 3");
|
||||
assert_eq!(Column::TotalChips.cell(&both), "190 / 228");
|
||||
}
|
||||
|
||||
@@ -2659,52 +2983,39 @@ mod tests {
|
||||
// value -- there is no actual reading to compare.
|
||||
let expected_only = MinerRow {
|
||||
expected_ths: 200.0,
|
||||
expected_hashboards: Some(3),
|
||||
expected_chips: Some(228),
|
||||
..Default::default()
|
||||
};
|
||||
assert_eq!(Column::Hashrate.num_value(&expected_only), None);
|
||||
assert_eq!(Column::Hashboards.num_value(&expected_only), None);
|
||||
assert_eq!(Column::TotalChips.num_value(&expected_only), None);
|
||||
|
||||
let both = MinerRow {
|
||||
hashrate_ths: 60.0,
|
||||
hashrate_known: true,
|
||||
expected_ths: 200.0,
|
||||
hashboards: Some(3),
|
||||
expected_hashboards: Some(3),
|
||||
total_chips: Some(190),
|
||||
expected_chips: Some(228),
|
||||
..Default::default()
|
||||
};
|
||||
assert_eq!(Column::Hashrate.num_value(&both), Some(60.0));
|
||||
assert_eq!(Column::Hashboards.num_value(&both), Some(3.0));
|
||||
assert_eq!(Column::TotalChips.num_value(&both), Some(190.0));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn hashboards_num_value_is_board_count_with_per_board_health() {
|
||||
// With per-board health present (the normal live-scan case), the Boards
|
||||
// filter must still compare the detected board count, not the composite
|
||||
// sort score online*100+total (round 18 #12). The `both` fixture above
|
||||
// leaves board_status empty, so it never exercised this path.
|
||||
let r = MinerRow {
|
||||
hashboards: Some(3),
|
||||
expected_hashboards: Some(3),
|
||||
board_status: vec![BoardHealth::Ok, BoardHealth::Ok, BoardHealth::Ok],
|
||||
..Default::default()
|
||||
};
|
||||
assert_eq!(Column::Hashboards.num_value(&r), Some(3.0), "filter sees the board count, not 303");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn cooling_column_joins_fan_rpms_and_sorts_by_min() {
|
||||
fn per_fan_columns_show_each_fan_and_hide_when_absent() {
|
||||
// Round 19 #8: the old slash-joined Cooling column is now one column per fan.
|
||||
let r = MinerRow { fan_rpms: vec![4200.0, 3990.0, 4500.0], ..Default::default() };
|
||||
assert_eq!(Column::Cooling.cell(&r), "4.2k/4.0k/4.5k");
|
||||
assert_eq!(Column::Cooling.num_value(&r), Some(3990.0));
|
||||
assert_eq!(Column::Fan1.cell(&r), "4.2k");
|
||||
assert_eq!(Column::Fan2.cell(&r), "4.0k");
|
||||
assert_eq!(Column::Fan3.cell(&r), "4.5k");
|
||||
// A miner with only 3 fans leaves Fan 4 blank (so auto-hide can drop it).
|
||||
assert_eq!(Column::Fan4.cell(&r), "");
|
||||
assert_eq!(Column::Fan1.num_value(&r), Some(4200.0));
|
||||
assert_eq!(Column::Fan4.num_value(&r), None);
|
||||
|
||||
let none = MinerRow::default();
|
||||
assert_eq!(Column::Cooling.cell(&none), "");
|
||||
assert_eq!(Column::Cooling.num_value(&none), None);
|
||||
assert_eq!(Column::Fan1.cell(&none), "");
|
||||
assert_eq!(Column::Fan1.num_value(&none), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -2754,8 +3065,16 @@ mod tests {
|
||||
fn is_paused_detection() {
|
||||
assert!(is_paused("Paused", false));
|
||||
assert!(is_paused("PAUSED (manual)", false));
|
||||
assert!(!is_paused("Paused", true), "mining overrides an even stale 'paused' state string");
|
||||
// Intentional halts other firmwares report: VNish "Stopped" (miner_state
|
||||
// "stopped"), Braiins "Suspended", a "Stopping" transition (round 19 #19 /
|
||||
// 10.4.1.122 read as broken before this).
|
||||
assert!(is_paused("Stopped", false), "an operator-stopped miner is paused, not broken");
|
||||
assert!(is_paused("Stopping", false));
|
||||
assert!(is_paused("Suspended", false));
|
||||
assert!(!is_paused("Stopped", true), "mining overrides a stale 'stopped' state string");
|
||||
assert!(!is_paused("Mining", false));
|
||||
assert!(!is_paused("Error", false), "a failure is broken, not paused");
|
||||
assert!(!is_paused("Idling", false), "plain idle is not an explicit halt");
|
||||
assert!(!is_paused("", false));
|
||||
}
|
||||
|
||||
|
||||
@@ -133,10 +133,9 @@ mod tests {
|
||||
assert!(view.visible.contains(&Column::Locked));
|
||||
// The Health column (round 13 #3) replaced these in the default profile.
|
||||
assert!(!view.visible.contains(&Column::Error));
|
||||
assert!(!view.visible.contains(&Column::Hashboards));
|
||||
// Columns dropped from the default profile in round 11.
|
||||
assert!(!view.visible.contains(&Column::BoardCode), "not in the default profile");
|
||||
assert!(!view.visible.contains(&Column::Cooling), "not in the default profile");
|
||||
assert!(!view.visible.contains(&Column::Fan1), "not in the default profile");
|
||||
// to_view covers every column in `order`.
|
||||
assert_eq!(view.order.len(), ALL_COLUMNS.len());
|
||||
// Round-trip a snapshot back out.
|
||||
|
||||
@@ -4,7 +4,7 @@
|
||||
use crate::model::{MinerCaps, MinerRow};
|
||||
use asic_rs::core::data::firmware::FirmwareImage;
|
||||
use asic_rs::core::traits::miner::Miner;
|
||||
use futures_util::StreamExt;
|
||||
use futures_util::{FutureExt, StreamExt};
|
||||
use measurements::Power;
|
||||
use std::collections::HashSet;
|
||||
use std::net::Ipv4Addr;
|
||||
@@ -39,11 +39,43 @@ 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
|
||||
/// Default 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.
|
||||
/// 128 was the highest cap that stayed fully reliable on the live fleet; it is
|
||||
/// now the default of a user-adjustable setting (round 19 #25).
|
||||
pub const SCAN_CONCURRENCY_LIMIT: usize = 128;
|
||||
/// The user-configurable scan concurrency is clamped to this range: a floor so a
|
||||
/// scan is never effectively serial, and a ceiling so a large range can't open
|
||||
/// hundreds of connections and saturate the network (round 19 #25). Higher
|
||||
/// values scan faster but can starve per-responder telemetry (see above).
|
||||
pub const MIN_SCAN_CONCURRENCY: usize = 8;
|
||||
// Ceiling kept at 256: the code below documents that 128 is fully reliable and 192
|
||||
// already dropped responders, and identification + telemetry run concurrently so
|
||||
// the peak socket count is ~2x this. 256 gives headroom for a fast sweep without
|
||||
// inviting the mass value-drops (which read as phantom faults) that higher caps
|
||||
// caused on the live fleet (round 19 review).
|
||||
pub const MAX_SCAN_CONCURRENCY: usize = 256;
|
||||
pub const SCAN_CONCURRENCY_FILE: &str = "scan-concurrency.txt";
|
||||
|
||||
/// Load the saved scan concurrency (in-flight probes), clamped to
|
||||
/// [MIN_SCAN_CONCURRENCY, MAX_SCAN_CONCURRENCY].
|
||||
pub fn load_scan_concurrency() -> usize {
|
||||
std::fs::read_to_string(config_path(SCAN_CONCURRENCY_FILE))
|
||||
.ok()
|
||||
.and_then(|s| s.trim().parse::<usize>().ok())
|
||||
.map(|n| n.clamp(MIN_SCAN_CONCURRENCY, MAX_SCAN_CONCURRENCY))
|
||||
.unwrap_or(SCAN_CONCURRENCY_LIMIT)
|
||||
}
|
||||
|
||||
/// Save the scan concurrency, clamped to the allowed range.
|
||||
pub fn save_scan_concurrency(n: usize) -> std::io::Result<()> {
|
||||
let p = config_path(SCAN_CONCURRENCY_FILE);
|
||||
if let Some(dir) = p.parent() {
|
||||
std::fs::create_dir_all(dir)?;
|
||||
}
|
||||
std::fs::write(p, n.clamp(MIN_SCAN_CONCURRENCY, MAX_SCAN_CONCURRENCY).to_string())
|
||||
}
|
||||
pub const DEFAULT_RANGE: &str = "10.255.1.0/24";
|
||||
/// Default seconds between automatic rescans.
|
||||
pub const DEFAULT_AUTO_SECS: u64 = 300;
|
||||
@@ -374,6 +406,8 @@ pub fn start_scan(lines: Vec<String>, timeout_secs: u64) -> ScanHandle {
|
||||
let target_set: HashSet<String> = targets.iter().map(|ip| ip.to_string()).collect();
|
||||
let _ = tx.send(ScanMsg::Started { total, targets: target_set });
|
||||
let cidrs = targets_to_cidrs(&targets);
|
||||
// User-adjustable in-flight probe cap (round 19 #25).
|
||||
let concurrency = load_scan_concurrency();
|
||||
|
||||
let thread_cancel = cancel.clone();
|
||||
let err_tx = tx.clone();
|
||||
@@ -398,7 +432,8 @@ pub fn start_scan(lines: Vec<String>, timeout_secs: u64) -> ScanHandle {
|
||||
// 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);
|
||||
// The cap is now user-adjustable (round 19 #25); the default is 128.
|
||||
.with_concurrent_limit(concurrency);
|
||||
for (ip, prefix) in &cidrs {
|
||||
factory = match factory.with_subnet(&format!("{ip}/{prefix}")) {
|
||||
Ok(f) => f,
|
||||
@@ -421,17 +456,41 @@ pub fn start_scan(lines: Vec<String>, timeout_secs: u64) -> ScanHandle {
|
||||
// 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);
|
||||
let ptx = tx.clone();
|
||||
let mut results = factory
|
||||
.scan_stream_with_ip()
|
||||
.map(|(ip, miner)| async move {
|
||||
match miner {
|
||||
// Only surface a row for an address that actually has a miner
|
||||
// behind it; a non-responding address is never a phantom row.
|
||||
Some(m) => (ip, Some(to_row(&*m).await)),
|
||||
None => (ip, None),
|
||||
.map(|(ip, miner)| {
|
||||
let ptx = ptx.clone();
|
||||
async move {
|
||||
match miner {
|
||||
// Only surface a row for an address that actually has a
|
||||
// miner behind it; a non-responding address is never a
|
||||
// phantom row.
|
||||
Some(m) => {
|
||||
// Fast path (round 19 #18): emit a lightweight identity
|
||||
// row from identification alone the instant the miner
|
||||
// is found, so it shows immediately; the full telemetry
|
||||
// row (get_data) upserts over it when it completes. The
|
||||
// ordering holds because the partial is sent before this
|
||||
// future awaits get_data and returns the full row.
|
||||
let _ = ptx.send(ScanMsg::Row(partial_row(&*m, ip)));
|
||||
// Isolate one miner's telemetry: asic-rs backends
|
||||
// parse miner-controlled data, so a panic (a stray
|
||||
// unwrap/index on a malformed field) must not unwind
|
||||
// the whole sweep and abort every other miner (round
|
||||
// 19 review). On panic the miner keeps its partial
|
||||
// identity row and the scan continues.
|
||||
let row = std::panic::AssertUnwindSafe(to_row(&*m))
|
||||
.catch_unwind()
|
||||
.await
|
||||
.ok();
|
||||
(ip, row)
|
||||
}
|
||||
None => (ip, None),
|
||||
}
|
||||
}
|
||||
})
|
||||
.buffer_unordered(SCAN_CONCURRENCY_LIMIT);
|
||||
.buffer_unordered(concurrency);
|
||||
while let Some((ip, row)) = results.next().await {
|
||||
if thread_cancel.load(Ordering::Relaxed) {
|
||||
return; // Stop / re-scan requested
|
||||
@@ -642,13 +701,81 @@ async fn detect_aftermarket_antminer(ip: std::net::IpAddr) -> Option<&'static st
|
||||
}
|
||||
}
|
||||
|
||||
/// A lightweight row built from identification alone (no `get_data`), emitted the
|
||||
/// instant a miner is identified so it appears in the fleet immediately; the full
|
||||
/// telemetry row upserts over it when `get_data` completes (round 19 #18). Only
|
||||
/// the cheap, synchronous identity + capability accessors are read here -- no
|
||||
/// network I/O beyond what identification already did.
|
||||
fn partial_row(miner: &dyn Miner, ip: std::net::IpAddr) -> MinerRow {
|
||||
let di = miner.get_device_info();
|
||||
let (firmware, _fw_vendor) = crate::naming::firmware_family(&di.firmware);
|
||||
let brand = crate::naming::brand(&di.make);
|
||||
let model = crate::naming::clean_model(&di.make, &di.model);
|
||||
let submodel = crate::naming::submodel(&di.make, &di.model);
|
||||
// Same VNish power-limit masking as the full row (round 9 #3).
|
||||
let power_limit =
|
||||
miner.supports_set_power_limit() && !di.firmware.eq_ignore_ascii_case("VNish");
|
||||
let caps = MinerCaps {
|
||||
fault_light: miner.supports_set_fault_light(),
|
||||
restart: miner.supports_restart(),
|
||||
pause: miner.supports_pause(),
|
||||
resume: miner.supports_resume(),
|
||||
power_limit,
|
||||
tuning: miner.supports_set_tuning_percent(),
|
||||
// hashrate_target needs the tuning envelope from get_data; the full row
|
||||
// fills it in a moment later.
|
||||
hashrate_target: false,
|
||||
supports_presets: miner.supports_presets(),
|
||||
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(),
|
||||
};
|
||||
MinerRow {
|
||||
ip: ip.to_string(),
|
||||
brand,
|
||||
model,
|
||||
submodel,
|
||||
firmware,
|
||||
algorithm: di.algo.to_string(),
|
||||
write_locked: Some(!caps.any_control()),
|
||||
caps,
|
||||
..Default::default()
|
||||
}
|
||||
}
|
||||
|
||||
async fn to_row(miner: &dyn Miner) -> MinerRow {
|
||||
let data = miner.get_data().await;
|
||||
// Whether the firmware reported a current hashrate at all: a reported 0 renders
|
||||
// "0.00T", an absent one the "-" dash (round 19 follow-up).
|
||||
let hashrate_known = data.hashrate.is_some();
|
||||
let hashrate_ths = data
|
||||
.hashrate
|
||||
.as_ref()
|
||||
.map(|h| h.clone().as_unit(asic_rs::core::data::hashrate::HashRateUnit::TeraHash).value)
|
||||
.unwrap_or(0.0);
|
||||
// Rolling average windows in TH/s (round 19 #10, T2); 0.0 = window not reported.
|
||||
let (hashrate_1m_ths, hashrate_5m_ths, hashrate_15m_ths, hashrate_24h_ths) = {
|
||||
let to_ths = |h: &Option<asic_rs::core::data::hashrate::HashRate>| {
|
||||
h.as_ref()
|
||||
.map(|h| {
|
||||
h.clone()
|
||||
.as_unit(asic_rs::core::data::hashrate::HashRateUnit::TeraHash)
|
||||
.value
|
||||
})
|
||||
.unwrap_or(0.0)
|
||||
};
|
||||
match data.hashrate_averages.as_ref() {
|
||||
Some(a) => (
|
||||
to_ths(&a.avg_1m),
|
||||
to_ths(&a.avg_5m),
|
||||
to_ths(&a.avg_15m),
|
||||
to_ths(&a.avg_24h),
|
||||
),
|
||||
None => (0.0, 0.0, 0.0, 0.0),
|
||||
}
|
||||
};
|
||||
let mut expected_ths = data
|
||||
.expected_hashrate
|
||||
.as_ref()
|
||||
@@ -945,6 +1072,15 @@ async fn to_row(miner: &dyn Miner) -> MinerRow {
|
||||
selected: false,
|
||||
caps,
|
||||
algorithm,
|
||||
// ASIC chip type + hashboard model, from the first board that reports them
|
||||
// (uniform across boards); empty where the firmware doesn't expose them
|
||||
// (round 19 #10).
|
||||
chip_type: data.hashboards.iter().find_map(|b| b.chip_type.clone()).unwrap_or_default(),
|
||||
hashboard_model: data
|
||||
.hashboards
|
||||
.iter()
|
||||
.find_map(|b| b.hashboard_model.clone())
|
||||
.unwrap_or_default(),
|
||||
pic_present,
|
||||
write_locked,
|
||||
errors,
|
||||
@@ -978,6 +1114,11 @@ async fn to_row(miner: &dyn Miner) -> MinerRow {
|
||||
cpu,
|
||||
board_code,
|
||||
hashrate_ths,
|
||||
hashrate_known,
|
||||
hashrate_1m_ths,
|
||||
hashrate_5m_ths,
|
||||
hashrate_15m_ths,
|
||||
hashrate_24h_ths,
|
||||
expected_ths,
|
||||
board_hashrates,
|
||||
board_expected_hashrates,
|
||||
@@ -1000,6 +1141,7 @@ async fn to_row(miner: &dyn Miner) -> MinerRow {
|
||||
(None, None) => String::new(),
|
||||
})
|
||||
.unwrap_or_default(),
|
||||
psu_serial: data.psu.as_ref().and_then(|p| p.serial.clone()).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,
|
||||
@@ -1013,7 +1155,11 @@ async fn to_row(miner: &dyn Miner) -> MinerRow {
|
||||
fluid_temp_c,
|
||||
env_temp_c,
|
||||
outlet_temp_c,
|
||||
temp_target_c: data.temp_target,
|
||||
temp_hot_c: data.temp_hot,
|
||||
temp_dangerous_c: data.temp_dangerous,
|
||||
fan_rpms,
|
||||
fan_speed_percent: data.fan_speed_percent,
|
||||
psu_fan_rpm,
|
||||
fan_count: (!data.fans.is_empty()).then_some(data.fans.len() as u32),
|
||||
expected_fans: data.expected_fans.map(|v| v as u32),
|
||||
@@ -1027,9 +1173,39 @@ async fn to_row(miner: &dyn Miner) -> MinerRow {
|
||||
pools,
|
||||
best_share: data.best_share,
|
||||
session_best_share: data.session_best_share,
|
||||
// Accepted / rejected shares summed across every configured pool (round 19
|
||||
// #10); None when no pool reports the count.
|
||||
accepted_shares: {
|
||||
let mut total = 0u64;
|
||||
let mut any = false;
|
||||
for p in data.pools.iter().flat_map(|g| g.pools.iter()) {
|
||||
if let Some(v) = p.accepted_shares {
|
||||
total = total.saturating_add(v);
|
||||
any = true;
|
||||
}
|
||||
}
|
||||
any.then_some(total)
|
||||
},
|
||||
rejected_shares: {
|
||||
let mut total = 0u64;
|
||||
let mut any = false;
|
||||
for p in data.pools.iter().flat_map(|g| g.pools.iter()) {
|
||||
if let Some(v) = p.rejected_shares {
|
||||
total = total.saturating_add(v);
|
||||
any = true;
|
||||
}
|
||||
}
|
||||
any.then_some(total)
|
||||
},
|
||||
// Cumulative share stats from the miner summary (round 19 #10, T2).
|
||||
difficulty_accepted: data.share_summary.as_ref().and_then(|s| s.difficulty_accepted),
|
||||
difficulty_rejected: data.share_summary.as_ref().and_then(|s| s.difficulty_rejected),
|
||||
stale_shares: data.share_summary.as_ref().and_then(|s| s.stale_shares),
|
||||
found_blocks: data.share_summary.as_ref().and_then(|s| s.found_blocks),
|
||||
uptime_secs: data.uptime.map(|d| d.as_secs()).unwrap_or(0),
|
||||
light_flashing: data.light_flashing,
|
||||
operating_state,
|
||||
tuner_status: data.tuner_status.clone().unwrap_or_default(),
|
||||
is_mining,
|
||||
slow,
|
||||
paused,
|
||||
@@ -1171,6 +1347,37 @@ async fn apply_action(miner: &dyn Miner, action: &ConfigAction) -> Result<bool,
|
||||
result.map_err(|e| e.to_string())
|
||||
}
|
||||
|
||||
/// Fetch one miner's log via asic-rs's per-backend `read_logs()` (round 19
|
||||
/// #11-16). Runs synchronously on the caller's thread in a short-lived
|
||||
/// current-thread runtime (mirroring `start_config_action`), so the GUI's
|
||||
/// existing "log-fetch" worker thread can call it directly. `Err` when the IP is
|
||||
/// unparseable, no miner answers, the backend has no log API (e.g. LuxOS,
|
||||
/// WhatsMiner), or the fetch fails/times out.
|
||||
pub fn fetch_log(ip: &str, timeout_secs: u64) -> Result<String, String> {
|
||||
let addr: std::net::IpAddr = ip.parse().map_err(|_| "bad IP".to_string())?;
|
||||
let rt = tokio::runtime::Builder::new_current_thread()
|
||||
.enable_all()
|
||||
.build()
|
||||
.map_err(|e| format!("runtime: {e}"))?;
|
||||
rt.block_on(async move {
|
||||
let factory =
|
||||
crate::credentials::configured_factory().with_identification_timeout_secs(timeout_secs.max(1));
|
||||
let miner = match factory.scan_miner(addr).await {
|
||||
Ok(Some(m)) => m,
|
||||
Ok(None) => return Err("no miner answered at this IP".to_string()),
|
||||
Err(e) => return Err(format!("{e}")),
|
||||
};
|
||||
if !miner.supports_read_logs() {
|
||||
return Err("this firmware's backend does not expose logs over its API".to_string());
|
||||
}
|
||||
match tokio::time::timeout(std::time::Duration::from_secs(25), miner.read_logs()).await {
|
||||
Ok(Ok(text)) => Ok(text),
|
||||
Ok(Err(e)) => Err(format!("read logs: {e}")),
|
||||
Err(_) => Err("log fetch timed out".to_string()),
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
/// Apply `action` to each miner in `ips` on a background thread: re-discover the
|
||||
/// miner (asic-rs `scan_miner`), run the setter, and report per-IP results. In
|
||||
/// fake-scan mode it reports simulated successes so the flow works offline.
|
||||
|
||||
@@ -43,6 +43,11 @@ const ID_COLS_CATEGORIES: i32 = 232;
|
||||
const ID_FILTER_OK: i32 = 205;
|
||||
const ID_FILTER_CANCEL: i32 = 206;
|
||||
const ID_FILTER_RESET: i32 = 210;
|
||||
// Export column-picker dialog (round 19 #6).
|
||||
const ID_EXPORT_OK: i32 = 207;
|
||||
const ID_EXPORT_CANCEL: i32 = 208;
|
||||
const ID_EXPORT_ALL: i32 = 209;
|
||||
const ID_EXPORT_NONE: i32 = 211;
|
||||
// Per-column "All"/"None" buttons in the filter panel are ID_FILTER_ALL_BASE +
|
||||
// column index (and the None equivalent). 100 columns of headroom each.
|
||||
const ID_FILTER_ALL_BASE: i32 = 300;
|
||||
@@ -133,6 +138,8 @@ const ID_HDR_COLUMNS: i32 = 764;
|
||||
// (round 11 #16).
|
||||
const ID_HDR_SORT_REL_ASC: i32 = 765;
|
||||
const ID_HDR_SORT_REL_DESC: i32 = 766;
|
||||
// Auto-size every column at once (round 19 #4).
|
||||
const ID_HDR_AUTOSIZE_ALL: i32 = 767;
|
||||
// Ticks (~seconds) to keep an action's result on the status bar before the
|
||||
// idle/countdown status takes over again.
|
||||
// Filter dialog: the column-selector dropdown + the comparator dropdown.
|
||||
@@ -189,8 +196,8 @@ fn tint_toward(base: (u8, u8, u8), target: (u8, u8, u8), f: f64) -> (u8, u8, u8)
|
||||
(lerp(base.0, target.0), lerp(base.1, target.1), lerp(base.2, target.2))
|
||||
}
|
||||
|
||||
/// Colour for a combined actual/expected ratio (Hashrate/Hashboards/
|
||||
/// TotalChips): full red at 50% (or below), amber at 75%, green at 100%+,
|
||||
/// Colour for a combined actual/expected ratio (Hashrate/TotalChips):
|
||||
/// full red at 50% (or below), amber at 75%, green at 100%+,
|
||||
/// interpolated linearly -- calibrated so a miner running at half its expected
|
||||
/// output reads as clearly bad, and 100% reads green.
|
||||
fn ratio_color(pal: &Palette, ratio: f64) -> (u8, u8, u8) {
|
||||
@@ -238,15 +245,9 @@ fn temp_color(pal: &Palette, temp_c: f64) -> (u8, u8, u8) {
|
||||
tint_toward(pal.accent, pal.red, ((temp_c - 40.0) / 50.0).clamp(0.0, 1.0))
|
||||
}
|
||||
|
||||
/// Colour for one cooling-fan RPM: muted grey (stopped/unknown) fading to
|
||||
/// accent blue as the RPM approaches 6000 (comfortably above a healthy fan's
|
||||
/// typical ceiling, so a spinning fan reads as a clear, saturated blue).
|
||||
fn fan_color(pal: &Palette, rpm: f64) -> (u8, u8, u8) {
|
||||
tint_toward(pal.label, pal.accent, (rpm / 6000.0).clamp(0.0, 1.0))
|
||||
}
|
||||
|
||||
/// Build the segment-encoded cell for a combined actual/expected column
|
||||
/// (Hashrate/Hashboards/TotalChips) from its already-formatted parts: the
|
||||
/// (Hashrate/TotalChips) from its already-formatted parts: the
|
||||
/// actual half is coloured by `ratio` when both halves are known, the separator
|
||||
/// `sep` and the expected half stay the default text colour, and an unknown
|
||||
/// actual shows "-". Round-trips (via decode_segments_plain) to the same plain
|
||||
@@ -313,7 +314,6 @@ fn encode_flag_cell(plain: &str, color: Option<(u8, u8, u8)>) -> String {
|
||||
/// Shape-sentinel strings the SegmentRenderer draws as small vector icons rather
|
||||
/// than text (round 11 #10/#13). These byte values MUST match the SHAPE_* set in
|
||||
/// widgets_bridge.cpp. They are control characters, never emoji/pictographs.
|
||||
const SHAPE_DOT: &str = "\u{0007}";
|
||||
const SHAPE_LOCK: &str = "\u{0002}";
|
||||
const SHAPE_UNLOCK: &str = "\u{0003}";
|
||||
// Status-column KPI icons (round 12 #11): one sentinel per status, each drawn
|
||||
@@ -376,28 +376,6 @@ fn svg_viewbox(svg: &str) -> (i32, i32) {
|
||||
.unwrap_or((1, 1))
|
||||
}
|
||||
|
||||
/// Boards column: one status dot per hashboard (round 11 #10). Board 1 is the
|
||||
/// rightmost dot, so boards render high-position-first (left to right). green =
|
||||
/// present and hashing, red = present but idle/faulty, grey = not detected.
|
||||
fn encode_board_dots(pal: &Palette, status: &[crate::model::BoardHealth]) -> String {
|
||||
use crate::model::BoardHealth;
|
||||
if status.is_empty() {
|
||||
return encode_segments(&[(None, String::new())]);
|
||||
}
|
||||
let segs: Vec<Segment> = status
|
||||
.iter()
|
||||
.rev()
|
||||
.map(|h| {
|
||||
let color = match h {
|
||||
BoardHealth::Ok => pal.green,
|
||||
BoardHealth::Fault => pal.red,
|
||||
BoardHealth::Missing => pal.label,
|
||||
};
|
||||
(Some(color), SHAPE_DOT.to_string())
|
||||
})
|
||||
.collect();
|
||||
encode_segments(&segs)
|
||||
}
|
||||
|
||||
/// Access column: a green open padlock (writable) or red closed padlock
|
||||
/// (view-only); blank when the lock state is unknown (round 11 #13).
|
||||
@@ -460,19 +438,44 @@ fn encode_component_health(
|
||||
max_fans: usize,
|
||||
max_boards: usize,
|
||||
) -> String {
|
||||
use crate::model::CompHealth;
|
||||
let mut segs: Vec<Segment> = Vec::new();
|
||||
// On a paused/stopped miner, a component that is off *because* the miner is
|
||||
// halted is expected, not a fault, so it reads blue (paused) instead of red.
|
||||
// But this only applies where "not working" is a consequence of the pause:
|
||||
// - Hashboards: idle (not hashing) is exactly what pausing does -> blue when
|
||||
// paused (any detected board; an undetected one stays grey). Round 19 #19.
|
||||
// - Fans: blue ONLY when actually stopped (0 RPM -> Down); a fan still
|
||||
// spinning stays green/amber -- pausing doesn't necessarily stop the fans.
|
||||
// - Control board + PSU: still running / powered, so they keep their true
|
||||
// health (green when fine) even while paused -- never forced blue.
|
||||
let paused = r.paused;
|
||||
let board_col = |h: CompHealth| {
|
||||
if paused && h != CompHealth::Unreachable {
|
||||
pal.accent
|
||||
} else {
|
||||
health_color(pal, h)
|
||||
}
|
||||
};
|
||||
let fan_col = |h: CompHealth| {
|
||||
if paused && h == CompHealth::Down {
|
||||
pal.accent
|
||||
} else {
|
||||
health_color(pal, h)
|
||||
}
|
||||
};
|
||||
segs.push((Some(health_color(pal, r.power_health())), SHAPE_BOLT.to_string()));
|
||||
segs.push((Some(health_color(pal, r.control_health())), SHAPE_BRAIN.to_string()));
|
||||
let fans = r.fan_healths();
|
||||
for h in &fans {
|
||||
segs.push((Some(health_color(pal, *h)), SHAPE_FAN.to_string()));
|
||||
segs.push((Some(fan_col(*h)), SHAPE_FAN.to_string()));
|
||||
}
|
||||
for _ in fans.len()..max_fans {
|
||||
segs.push((None, SHAPE_GAP.to_string()));
|
||||
}
|
||||
let boards = r.board_healths();
|
||||
for h in &boards {
|
||||
segs.push((Some(health_color(pal, *h)), SHAPE_CHIP.to_string()));
|
||||
segs.push((Some(board_col(*h)), SHAPE_CHIP.to_string()));
|
||||
}
|
||||
for _ in boards.len()..max_boards {
|
||||
segs.push((None, SHAPE_GAP.to_string()));
|
||||
@@ -533,23 +536,6 @@ fn svg_width_for_height(svg: &str, h: i32) -> i32 {
|
||||
.max(1)
|
||||
}
|
||||
|
||||
/// Build the segment-encoded cell text for the Cooling column: each fan's RPM
|
||||
/// gets its own grey-to-blue colour by speed, and the "/" separators between
|
||||
/// them stay in the default text colour.
|
||||
fn encode_cooling_cell(pal: &Palette, fans: &[f64]) -> String {
|
||||
if fans.is_empty() {
|
||||
return encode_segments(&[(None, String::new())]);
|
||||
}
|
||||
let mut segs: Vec<Segment> = Vec::with_capacity(fans.len() * 2 - 1);
|
||||
for (i, &rpm) in fans.iter().enumerate() {
|
||||
if i > 0 {
|
||||
segs.push((None, "/".to_string()));
|
||||
}
|
||||
segs.push((Some(fan_color(pal, rpm)), format_fan_rpm(rpm)));
|
||||
}
|
||||
encode_segments(&segs)
|
||||
}
|
||||
|
||||
/// Format a filter's numeric bound without a trailing ".0" for whole numbers.
|
||||
fn fmt_num(v: f64) -> String {
|
||||
if v.is_finite() && v == v.trunc() && v.abs() < 1e15 {
|
||||
@@ -642,11 +628,6 @@ pub struct App {
|
||||
kpi_power: Widget,
|
||||
progress: Widget,
|
||||
pub table: Option<Widget>,
|
||||
// Whether the columns have had their one-time content-fit autosize applied
|
||||
// since the table was last (re)built (round 18 #10). Reset on rebuild; set
|
||||
// the first time fill_rows runs with rows present, so the default widths fit
|
||||
// their contents (capped) once and manual resizes afterwards are preserved.
|
||||
columns_autosized: bool,
|
||||
// Set when a scan streamed new rows this drain; flushed by tick() at most once
|
||||
// per second (or immediately once the scan ends) so the full table refill runs
|
||||
// ~1 Hz during a scan instead of every fast tick (round 18 #12).
|
||||
@@ -668,6 +649,10 @@ pub struct App {
|
||||
refresh: Option<scan::RefreshHandle>,
|
||||
// scan loop (play/pause/stop + auto-rescan)
|
||||
playing: bool,
|
||||
// True when the user explicitly Stopped the scan (as opposed to Paused the
|
||||
// auto-rescan loop). Distinguishes the idle status line "Scan Stopped" from
|
||||
// "Scan Paused"; cleared when a scan starts (round 19 #17).
|
||||
scan_stopped: bool,
|
||||
auto_secs: u64,
|
||||
// Per-miner scan timeout in seconds (round 14 #2).
|
||||
scan_timeout_secs: u64,
|
||||
@@ -793,10 +778,15 @@ pub struct App {
|
||||
ranges_edit: Widget,
|
||||
ranges_auto: Widget,
|
||||
ranges_timeout: Widget,
|
||||
/// Scan-concurrency (in-flight probes) input in the ranges dialog (round 19 #25).
|
||||
ranges_concurrency: Widget,
|
||||
columns_dialog: Widget,
|
||||
columns_list: Widget,
|
||||
/// The columns-dialog "hide empty columns" checkbox, read at Apply.
|
||||
columns_hide_empty_cb: Widget,
|
||||
/// Export column-picker dialog + its checklist (round 19 #6).
|
||||
export_dialog: Widget,
|
||||
export_list: Widget,
|
||||
/// When set, columns with no scanned value in any row are hidden from the
|
||||
/// table (non-destructively -- clearing it restores them) (round 11 #9).
|
||||
auto_hide_empty: bool,
|
||||
@@ -1029,7 +1019,6 @@ pub fn build(frame: Widget) -> App {
|
||||
kpi_power,
|
||||
progress,
|
||||
table: None,
|
||||
columns_autosized: false,
|
||||
rows_dirty: false,
|
||||
built_columns: Vec::new(),
|
||||
table_parent,
|
||||
@@ -1040,6 +1029,7 @@ pub fn build(frame: Widget) -> App {
|
||||
target_ips: HashSet::new(),
|
||||
refresh: None,
|
||||
playing: true,
|
||||
scan_stopped: false,
|
||||
auto_secs: scan::load_auto_secs(),
|
||||
scan_timeout_secs: scan::load_scan_timeout(),
|
||||
countdown: 0,
|
||||
@@ -1103,9 +1093,12 @@ pub fn build(frame: Widget) -> App {
|
||||
ranges_edit: frame,
|
||||
ranges_auto: frame,
|
||||
ranges_timeout: frame,
|
||||
ranges_concurrency: frame,
|
||||
columns_dialog: frame,
|
||||
columns_list: frame,
|
||||
columns_hide_empty_cb: frame,
|
||||
export_dialog: frame,
|
||||
export_list: frame,
|
||||
auto_hide_empty: false,
|
||||
filter_dialog: frame,
|
||||
filter_col_choice: frame,
|
||||
@@ -1211,13 +1204,22 @@ impl App {
|
||||
Some((sc, false)) if sc == c => title.push_str(" v"),
|
||||
_ => {}
|
||||
}
|
||||
if matches!(c, Column::Hashrate | Column::Health | Column::Hashboards | Column::TotalChips | Column::ChipTemp | Column::Cooling | Column::Locked | Column::Light | Column::Error | Column::Status | Column::Firmware) {
|
||||
// These columns show two-tone / multi-tone text (actual vs.
|
||||
// expected, or one colour per fan) via a custom renderer that
|
||||
// parses the segment-encoded cell value fill_rows writes.
|
||||
t.dvlc_append_colored_col(&title, c.width(), !fixed);
|
||||
// Data/text columns are right-aligned (round 19 #21). IP and the
|
||||
// icon columns (Health/Access/Light) stay left-aligned so their
|
||||
// fixed-width icon slots anchor at a consistent left edge and line up
|
||||
// across rows (round 19 Health-column follow-up).
|
||||
let align = if matches!(c, Column::Ip | Column::Health | Column::Locked | Column::Light) {
|
||||
wx_rs::ALIGN_LEFT
|
||||
} else {
|
||||
t.dvlc_append_text_col(&title, c.width(), !fixed);
|
||||
wx_rs::ALIGN_RIGHT
|
||||
};
|
||||
if matches!(c, Column::Hashrate | Column::Health | Column::TotalChips | Column::ChipTemp | Column::Locked | Column::Light | Column::Error | Column::Status | Column::Firmware) {
|
||||
// These columns show two-tone / multi-tone text (actual vs.
|
||||
// expected) via a custom renderer that parses the segment-encoded
|
||||
// cell value fill_rows writes.
|
||||
t.dvlc_append_colored_col(&title, c.width(), !fixed, align);
|
||||
} else {
|
||||
t.dvlc_append_text_col(&title, c.width(), !fixed, align);
|
||||
}
|
||||
}
|
||||
// Add the table to the root sizer (proportion 1 => fills the area under
|
||||
@@ -1233,9 +1235,6 @@ impl App {
|
||||
// detect an auto-hide-empty set change and rebuild rather than render
|
||||
// against stale columns (round 18 #12).
|
||||
self.built_columns = self.table_columns();
|
||||
// Fresh columns come back at their configured default widths; let the
|
||||
// next fill_rows shrink them to fit their contents (round 18 #10).
|
||||
self.columns_autosized = false;
|
||||
self.fill_rows();
|
||||
}
|
||||
|
||||
@@ -1286,7 +1285,9 @@ impl App {
|
||||
// on the ACTUAL being known, so an unknown actual renders as
|
||||
// "-/<expected>" in the default colour rather than a red 0%.
|
||||
Column::Hashrate => {
|
||||
let actual = format_hashrate_ths(r.hashrate_ths);
|
||||
// A reported 0 shows "0.00T" (not a dash); the dash is only for
|
||||
// an unreadable reading (hashrate_known == false).
|
||||
let actual = format_hashrate_actual(r.hashrate_ths, r.hashrate_known);
|
||||
let expected = format_hashrate_ths(r.expected_ths);
|
||||
let ratio = (r.hashrate_ths > 0.0)
|
||||
.then(|| actual_expected_ratio(r.hashrate_ths, r.expected_ths))
|
||||
@@ -1300,8 +1301,6 @@ impl App {
|
||||
Some(op) => encode_segments(&[(Some(self.pal.amber), op.clone())]),
|
||||
None => encode_component_health(&self.pal, r, max_fans, max_boards),
|
||||
},
|
||||
// Boards column: per-hashboard health dots (round 11 #10).
|
||||
Column::Hashboards => encode_board_dots(&self.pal, &r.board_status),
|
||||
Column::TotalChips => {
|
||||
let actual = r.total_chips.map(|v| v.to_string());
|
||||
let expected = r.expected_chips.map(|v| v.to_string());
|
||||
@@ -1314,7 +1313,6 @@ impl App {
|
||||
encode_combined_cell(&self.pal, actual, expected, " / ", ratio)
|
||||
}
|
||||
Column::ChipTemp => encode_board_temps_cell(&self.pal, &r.board_temps, r.chip_temp_c),
|
||||
Column::Cooling => encode_cooling_cell(&self.pal, &r.fan_rpms),
|
||||
// Access column: a padlock icon, green open (writable) / red
|
||||
// closed (view-only) (round 11 #13).
|
||||
Column::Locked => encode_access_icon(&self.pal, r.write_locked),
|
||||
@@ -1353,17 +1351,14 @@ impl App {
|
||||
}
|
||||
}
|
||||
}
|
||||
// Item 10: the first time we have rows to measure after a (re)build, set
|
||||
// each column's width to the smaller of its content-fit width and its
|
||||
// configured default (the cap), so columns are no wider than needed. Done
|
||||
// once per rebuild; the user's later manual resizes are then preserved
|
||||
// because subsequent fill_rows calls (scan updates) skip this.
|
||||
if !self.columns_autosized && !self.view_idx.is_empty() {
|
||||
for (pos, c) in cols.iter().enumerate() {
|
||||
t.dvlc_autosize_col_capped(pos, c.width());
|
||||
}
|
||||
self.columns_autosized = true;
|
||||
}
|
||||
// Columns keep their configured default widths (scaled by the table zoom
|
||||
// via table_zoom_reapply). A previous build re-ran a content-fit autosize
|
||||
// on every rebuild, but on GTK reading a column's width immediately after
|
||||
// SetWidth(AUTOSIZE) returns a value from before the native measurement
|
||||
// lands, so a rebuild (language change, hide/show, reorder) collapsed every
|
||||
// column to the floor (round 19 #3/#24). Autosize is now on-demand only
|
||||
// (the header menu's "Auto-size" items), where the columns are realised so
|
||||
// the measurement is valid.
|
||||
if let Some(row) = top {
|
||||
t.dvlc_ensure_visible(row.min(self.view_idx.len().saturating_sub(1)));
|
||||
}
|
||||
@@ -1572,10 +1567,14 @@ impl App {
|
||||
menu.menu_append(ID_CTX_LIGHT_ON, &format!("Flash lights{sfx}"));
|
||||
}
|
||||
}
|
||||
if caps.pause {
|
||||
// State-aware (round 19 #20): only offer Pause when at least one
|
||||
// selected miner is actually running, and Resume only when at least
|
||||
// one is paused, so a paused miner never shows "Pause" and a running
|
||||
// one never shows "Resume". On a mixed selection both can appear.
|
||||
if caps.pause && selected.iter().any(|r| !r.paused) {
|
||||
menu.menu_append(ID_CTX_PAUSE, &format!("Pause mining{sfx}"));
|
||||
}
|
||||
if caps.resume {
|
||||
if caps.resume && selected.iter().any(|r| r.paused) {
|
||||
menu.menu_append(ID_CTX_RESUME, &format!("Resume mining{sfx}"));
|
||||
}
|
||||
if caps.tuning {
|
||||
@@ -2001,24 +2000,16 @@ impl App {
|
||||
}
|
||||
let rows = self.selected_rows();
|
||||
let Some(r) = rows.first() else { return };
|
||||
let (ip, brand, firmware) = (r.ip.clone(), r.brand.clone(), r.firmware.clone());
|
||||
// VNish unlock password + Antminer web login: a per-firmware override
|
||||
// (round 12 #13) wins, else the shipped default / saved global creds.
|
||||
let vnish_pass = credentials::load_firmware_credentials()
|
||||
.get("VNish")
|
||||
.map(|(_, p)| p.clone())
|
||||
.filter(|p| !p.is_empty())
|
||||
.unwrap_or_else(|| credentials::firmware_default_for("VNish").1);
|
||||
let vnish_pass = if vnish_pass.is_empty() { "admin".to_string() } else { vnish_pass };
|
||||
let (am_user, am_pass) =
|
||||
credentials::load_credentials().unwrap_or_else(|| ("root".into(), "root".into()));
|
||||
let (ip, brand) = (r.ip.clone(), r.brand.clone());
|
||||
// asic-rs read_logs() authenticates through configured_factory() (the saved
|
||||
// scan credentials), so no per-firmware creds are threaded here (round 19
|
||||
// #11-16). WhatsMiner's fault-code fallback is unauthenticated.
|
||||
let timeout = self.scan_timeout_secs;
|
||||
wx_rs::set_status_text(&format!("fetching log from {ip}..."));
|
||||
let (tx, rx) = std::sync::mpsc::channel();
|
||||
let ip_thread = ip.clone();
|
||||
let spawned = std::thread::Builder::new().name("log-fetch".into()).spawn(move || {
|
||||
let res = crate::log_scan::scan_log(
|
||||
&ip_thread, &brand, &firmware, &vnish_pass, &am_user, &am_pass,
|
||||
);
|
||||
let res = crate::log_scan::scan_log(&ip_thread, &brand, timeout);
|
||||
let _ = tx.send(res);
|
||||
});
|
||||
if spawned.is_err() {
|
||||
@@ -2064,12 +2055,6 @@ impl App {
|
||||
let frame = Widget::main_frame();
|
||||
let dlg = Widget::dialog(frame, &format!("Miner log (API) -- {ip}"));
|
||||
let root = Widget::box_sizer(true);
|
||||
let summary = if scan.summary.is_empty() {
|
||||
"(no summary)".to_string()
|
||||
} else {
|
||||
scan.summary.join("\n")
|
||||
};
|
||||
root.add(Widget::static_text(dlg, &summary), 0, sf::BORDER_ALL, 8);
|
||||
let text = Widget::text_ctrl(dlg, true);
|
||||
text.set_min_size(760, 420);
|
||||
text.set_value(&scan.text);
|
||||
@@ -2342,7 +2327,9 @@ impl App {
|
||||
ID_SCAN_CREDS => return Some(self.build_firmware_creds_dialog()),
|
||||
ID_LOGS_OPEN => return Some(self.build_logs_dialog()),
|
||||
ID_HDR_SORT_ASC | ID_HDR_SORT_DESC | ID_HDR_SORT_REL_ASC | ID_HDR_SORT_REL_DESC
|
||||
| ID_HDR_HIDE | ID_HDR_AUTOSIZE | ID_HDR_COLUMNS => return self.on_header_menu(id),
|
||||
| ID_HDR_HIDE | ID_HDR_AUTOSIZE | ID_HDR_AUTOSIZE_ALL | ID_HDR_COLUMNS => {
|
||||
return self.on_header_menu(id)
|
||||
}
|
||||
ID_CTX_OPEN => {
|
||||
for ip in self.selected_ip_list() {
|
||||
wx_rs::launch_browser(&format!("http://{ip}"));
|
||||
@@ -3130,6 +3117,7 @@ impl App {
|
||||
self.selected_ips = keep.into_iter().filter(|ip| self.target_ips.contains(ip)).collect();
|
||||
self.scan_total = total;
|
||||
self.scanning = true;
|
||||
self.scan_stopped = false;
|
||||
self.progress.gauge_set_range(total.max(1) as i32);
|
||||
self.progress.gauge_set_value(0);
|
||||
self.progress.show(true);
|
||||
@@ -3250,11 +3238,16 @@ impl App {
|
||||
self.start_new_scan();
|
||||
}
|
||||
} else {
|
||||
wx_rs::set_status_text(&format!(
|
||||
"{} miners - {}",
|
||||
self.rows.len(),
|
||||
if self.playing { "auto-rescan off" } else { "paused" }
|
||||
));
|
||||
// Distinguish an explicit Stop from a Pause so the idle tick doesn't
|
||||
// overwrite "Scan Stopped" with "paused" (round 19 #17).
|
||||
let tail = if self.playing {
|
||||
"auto-rescan off"
|
||||
} else if self.scan_stopped {
|
||||
"Scan Stopped"
|
||||
} else {
|
||||
"Scan Paused"
|
||||
};
|
||||
wx_rs::set_status_text(&format!("{} miners - {}", self.rows.len(), tail));
|
||||
}
|
||||
to_show
|
||||
}
|
||||
@@ -3393,6 +3386,7 @@ impl App {
|
||||
}
|
||||
menu.menu_append_separator();
|
||||
menu.menu_append(ID_HDR_AUTOSIZE, "Auto-size this column");
|
||||
menu.menu_append(ID_HDR_AUTOSIZE_ALL, "Auto-size all columns");
|
||||
// The fixed IP column can't be hidden.
|
||||
if !self.view.is_fixed(col) {
|
||||
menu.menu_append(ID_HDR_HIDE, &format!("Hide {}", col.title()));
|
||||
@@ -3437,6 +3431,17 @@ impl App {
|
||||
t.dvlc_autosize_col(pos);
|
||||
}
|
||||
}
|
||||
// Auto-size every column to its content (round 19 #4). Done on demand
|
||||
// (the columns are realised here, so the measurement is valid, unlike a
|
||||
// rebuild-time autosize -- see rebuild_table). Ctrl+A selects all rows
|
||||
// natively on the GtkTreeView, so this is the "resize all" companion.
|
||||
ID_HDR_AUTOSIZE_ALL => {
|
||||
if let Some(t) = self.table {
|
||||
for pos in 0..t.dvlc_col_count() {
|
||||
t.dvlc_autosize_col(pos);
|
||||
}
|
||||
}
|
||||
}
|
||||
ID_HDR_COLUMNS => return Some(self.build_columns_dialog()),
|
||||
_ => {}
|
||||
}
|
||||
@@ -3530,6 +3535,19 @@ impl App {
|
||||
to_edit.set_value(&self.scan_timeout_secs.to_string());
|
||||
to_edit.set_min_size(60, -1);
|
||||
auto_row.add(to_edit, 0, sf::ALIGN_CENTRE_VERTICAL | sf::BORDER_ALL, 6);
|
||||
// Scan concurrency (in-flight probes): higher scans faster but can starve
|
||||
// per-miner telemetry; clamped to [MIN, MAX] on apply (round 19 #25).
|
||||
auto_row.add_stretch(1);
|
||||
let cc_lbl = Widget::static_text(dlg, "Concurrency:");
|
||||
auto_row.add(cc_lbl, 0, sf::ALIGN_CENTRE_VERTICAL | sf::BORDER_ALL, 6);
|
||||
let cc_edit = Widget::text_ctrl(dlg, false);
|
||||
cc_edit.set_value(&scan::load_scan_concurrency().to_string());
|
||||
cc_edit.set_min_size(60, -1);
|
||||
cc_edit.set_tool_tip(&format!(
|
||||
"In-flight probes per scan ({}-{}). Higher is faster but can drop values on slow miners; default {}.",
|
||||
scan::MIN_SCAN_CONCURRENCY, scan::MAX_SCAN_CONCURRENCY, scan::SCAN_CONCURRENCY_LIMIT
|
||||
));
|
||||
auto_row.add(cc_edit, 0, sf::ALIGN_CENTRE_VERTICAL | sf::BORDER_ALL, 6);
|
||||
root.add_sizer(auto_row, 0, sf::EXPAND | sf::BORDER_LEFT | sf::BORDER_RIGHT, 6);
|
||||
let btns = Widget::box_sizer(false);
|
||||
let apply = Widget::button(dlg, "Apply", ID_RANGES_APPLY);
|
||||
@@ -3542,6 +3560,7 @@ impl App {
|
||||
self.ranges_edit = edit;
|
||||
self.ranges_auto = auto_edit;
|
||||
self.ranges_timeout = to_edit;
|
||||
self.ranges_concurrency = cc_edit;
|
||||
dlg
|
||||
}
|
||||
|
||||
@@ -3572,6 +3591,10 @@ impl App {
|
||||
self.scan_timeout_secs = secs.max(1);
|
||||
let _ = scan::save_scan_timeout(self.scan_timeout_secs);
|
||||
}
|
||||
// Save the scan concurrency (round 19 #25), clamped in save_scan_concurrency.
|
||||
if let Ok(n) = self.ranges_concurrency.get_value().trim().parse::<usize>() {
|
||||
let _ = scan::save_scan_concurrency(n);
|
||||
}
|
||||
let _ = scan::save_ranges(&lines);
|
||||
self.begin_scan(lines);
|
||||
wx_rs::set_status_text("scanning...");
|
||||
@@ -3699,20 +3722,81 @@ impl App {
|
||||
/// Export the full scan data to a CSV the user picks (round 15 #14). Every
|
||||
/// scanned data point is exported, one value per cell -- more complete and
|
||||
/// machine-readable than the on-screen table.
|
||||
fn apply_export(&mut self) {
|
||||
/// Export toolbar button: open the column-picker dialog (round 19 #6), unless
|
||||
/// there is nothing to export yet. Returns the dialog to show modally.
|
||||
fn open_export_dialog(&mut self) -> Option<Widget> {
|
||||
if self.rows.is_empty() {
|
||||
wx_rs::set_status_text("nothing to export yet -- run a scan first");
|
||||
return None;
|
||||
}
|
||||
Some(self.build_export_dialog())
|
||||
}
|
||||
|
||||
/// A checklist of every export field (all on by default), with All/None and
|
||||
/// Export/Cancel. OK -> do_export (round 19 #6).
|
||||
fn build_export_dialog(&mut self) -> Widget {
|
||||
let frame = Widget::main_frame();
|
||||
let dlg = Widget::dialog(frame, "Export columns");
|
||||
let root = Widget::box_sizer(true);
|
||||
root.add(Widget::static_text(dlg, "Choose the columns to export:"), 0, sf::BORDER_ALL, 8);
|
||||
let clb = Widget::check_list_box(dlg);
|
||||
for name in crate::export::export_field_names() {
|
||||
clb.clb_append(&name);
|
||||
clb.clb_set_checked(clb.clb_count() - 1, true);
|
||||
}
|
||||
root.add(clb, 1, sf::EXPAND | sf::BORDER_ALL, 8);
|
||||
let sel = Widget::box_sizer(false);
|
||||
sel.add(Widget::button(dlg, "All", ID_EXPORT_ALL), 0, sf::BORDER_ALL, 4);
|
||||
sel.add(Widget::button(dlg, "None", ID_EXPORT_NONE), 0, sf::BORDER_ALL, 4);
|
||||
root.add_sizer(sel, 0, sf::BORDER_LEFT | sf::BORDER_RIGHT, 4);
|
||||
let btns = Widget::box_sizer(false);
|
||||
btns.add_stretch(1);
|
||||
btns.add(Widget::button(dlg, "Export", ID_EXPORT_OK), 0, sf::BORDER_ALL, 6);
|
||||
btns.add(Widget::button(dlg, "Cancel", ID_EXPORT_CANCEL), 0, sf::BORDER_ALL, 6);
|
||||
root.add_sizer(btns, 0, sf::EXPAND | sf::BORDER_ALL, 6);
|
||||
root.set_sizer_on(dlg);
|
||||
dlg.set_min_size(360, 480);
|
||||
dlg.fit(dlg);
|
||||
self.export_dialog = dlg;
|
||||
self.export_list = clb;
|
||||
dlg
|
||||
}
|
||||
|
||||
fn export_check_all(&self, checked: bool) {
|
||||
let clb = self.export_list;
|
||||
for i in 0..clb.clb_count() {
|
||||
clb.clb_set_checked(i, checked);
|
||||
}
|
||||
}
|
||||
|
||||
/// Read the checked export fields, then save the filtered CSV. Default filename
|
||||
/// carries a UTC date+time so successive exports don't collide (round 19 #5).
|
||||
fn do_export(&mut self) {
|
||||
let names = crate::export::export_field_names();
|
||||
let clb = self.export_list;
|
||||
let mut selected: HashSet<String> = HashSet::new();
|
||||
for i in 0..clb.clb_count() {
|
||||
if clb.clb_checked(i) {
|
||||
if let Some(n) = names.get(i) {
|
||||
selected.insert(n.clone());
|
||||
}
|
||||
}
|
||||
}
|
||||
self.export_dialog.close(1);
|
||||
if selected.is_empty() {
|
||||
wx_rs::set_status_text("no columns selected -- export cancelled");
|
||||
return;
|
||||
}
|
||||
let default_name = format!("alkane-export-{}.csv", crate::export::timestamp_utc());
|
||||
let Some(path) = Widget::save_file_dialog(
|
||||
Widget::main_frame(),
|
||||
"Export scan data",
|
||||
"alkane-export.csv",
|
||||
&default_name,
|
||||
"CSV files (*.csv)|*.csv|All files (*.*)|*.*",
|
||||
) else {
|
||||
return; // cancelled
|
||||
};
|
||||
let csv = crate::export::rows_to_csv(&self.rows);
|
||||
let csv = crate::export::rows_to_csv_selected(&self.rows, &selected);
|
||||
match std::fs::write(&path, csv) {
|
||||
Ok(()) => {
|
||||
crate::logs::log(format!("exported {} miner(s) to {path}", self.rows.len()));
|
||||
@@ -4224,7 +4308,11 @@ impl App {
|
||||
ID_RANGES => return Some(self.build_ranges_dialog()),
|
||||
ID_RANGES_APPLY => self.apply_ranges(),
|
||||
ID_RANGES_CANCEL => self.ranges_dialog.close(0),
|
||||
ID_EXPORT => self.apply_export(),
|
||||
ID_EXPORT => return self.open_export_dialog(),
|
||||
ID_EXPORT_OK => self.do_export(),
|
||||
ID_EXPORT_CANCEL => self.export_dialog.close(0),
|
||||
ID_EXPORT_ALL => self.export_check_all(true),
|
||||
ID_EXPORT_NONE => self.export_check_all(false),
|
||||
ID_SETTINGS => self.open_settings_menu(),
|
||||
ID_LOGS_REFRESH => self.logs_text.set_value(&crate::logs::dump()),
|
||||
ID_LOGS_CLEAR => {
|
||||
@@ -4294,6 +4382,7 @@ impl App {
|
||||
// Resume/start the scan loop: scan now (unless one is
|
||||
// already running) + auto-rescan on.
|
||||
self.playing = true;
|
||||
self.scan_stopped = false;
|
||||
if !self.scanning {
|
||||
self.start_new_scan();
|
||||
}
|
||||
@@ -4301,12 +4390,14 @@ impl App {
|
||||
ID_PAUSE => {
|
||||
// Stop the auto-rescan loop (a scan in flight finishes).
|
||||
self.playing = false;
|
||||
wx_rs::set_status_text(&format!("{} miners - paused", self.rows.len()));
|
||||
self.scan_stopped = false;
|
||||
wx_rs::set_status_text(&format!("{} miners - Scan Paused", self.rows.len()));
|
||||
}
|
||||
ID_STOP => {
|
||||
// Halt the loop and cancel any in-flight scan (dropping
|
||||
// the receiver alone would leave the thread probing).
|
||||
self.playing = false;
|
||||
self.scan_stopped = true;
|
||||
self.countdown = 0;
|
||||
self.scanning = false;
|
||||
if let Some(old) = self.scan.take() {
|
||||
@@ -4314,7 +4405,7 @@ impl App {
|
||||
}
|
||||
self.progress.show(false);
|
||||
self.table_parent.layout();
|
||||
wx_rs::set_status_text(&format!("{} miners - stopped", self.rows.len()));
|
||||
wx_rs::set_status_text(&format!("{} miners - Scan Stopped", self.rows.len()));
|
||||
}
|
||||
ID_FILTER_ALL_BASE => self.filter_check_all(true),
|
||||
ID_FILTER_NONE_BASE => self.filter_check_all(false),
|
||||
@@ -4345,11 +4436,6 @@ impl App {
|
||||
pub fn run_fixture_selftest(&mut self) -> bool {
|
||||
self.rows = crate::fixtures::bench_fleet();
|
||||
self.view = ViewState::default();
|
||||
// Show the detailed per-board Boards column so its dot-sentinel rendering
|
||||
// is actually exercised (round 18 #12: it is opt-in, not default-visible,
|
||||
// so without this the Boards check below was dead). rebuild_table (not
|
||||
// fill_rows) so the widget's columns match the changed visible set.
|
||||
self.view.visible.insert(crate::model::Column::Hashboards);
|
||||
self.rebuild_table();
|
||||
|
||||
let mut ok = true;
|
||||
@@ -4398,12 +4484,12 @@ impl App {
|
||||
// Icon/dot columns (round 11 #10/#13) render shape sentinels, not
|
||||
// text, so they don't round-trip to c.cell(r); they're verified
|
||||
// structurally in the icon-column spot-check below.
|
||||
if matches!(c, Column::Health | Column::Hashboards | Column::Locked | Column::Light | Column::Status) {
|
||||
if matches!(c, Column::Health | Column::Locked | Column::Light | Column::Status) {
|
||||
continue;
|
||||
}
|
||||
let want = c.cell(r);
|
||||
let raw = t.dvlc_get_cell(disp_row, j).unwrap_or_default();
|
||||
let got = if matches!(c, Column::Hashrate | Column::TotalChips | Column::ChipTemp | Column::Cooling | Column::Error | Column::Firmware) {
|
||||
let got = if matches!(c, Column::Hashrate | Column::TotalChips | Column::ChipTemp | Column::Error | Column::Firmware) {
|
||||
decode_segments_plain(&raw)
|
||||
} else {
|
||||
raw
|
||||
@@ -4438,15 +4524,9 @@ impl App {
|
||||
// displayed cell.
|
||||
let status_of = |row: usize| -> &'static str { self.rows[self.view_idx[row]].status() };
|
||||
// Icon columns (round 11 #10/#13): the store carries shape sentinels
|
||||
// (dots / padlock), not text -- verify they are present.
|
||||
let boards_col = cols.iter().position(|c| *c == Column::Hashboards);
|
||||
// (padlock), not text -- verify they are present.
|
||||
let access_col = cols.iter().position(|c| *c == Column::Locked);
|
||||
let health_col = cols.iter().position(|c| *c == Column::Health);
|
||||
if let (Some(bc), Some(row)) = (boards_col, find("10.255.1.166")) {
|
||||
let raw = t.dvlc_get_cell(row, bc).unwrap_or_default();
|
||||
check("Boards column renders dot sentinels for a mining miner",
|
||||
raw.contains('\u{0007}'), format!("cell={raw:?}"));
|
||||
}
|
||||
// Health column (round 13 #3): the power (bolt) and control-board (brain)
|
||||
// icons are always emitted, plus a chip icon per hashboard for a mining
|
||||
// miner; verify the sentinels are present.
|
||||
@@ -4632,15 +4712,6 @@ mod tests {
|
||||
assert_eq!(temp_color(&p, 65.0), tint_toward(p.accent, p.red, 0.5), "midpoint blend");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fan_color_grey_to_blue_scale() {
|
||||
let p = test_pal();
|
||||
assert_eq!(fan_color(&p, 0.0), p.label, "stopped fan -> grey label colour");
|
||||
assert_eq!(fan_color(&p, 6000.0), p.accent, "at/above ceiling -> saturated accent blue");
|
||||
assert_eq!(fan_color(&p, 12000.0), p.accent, "clamped above the ceiling");
|
||||
assert_eq!(fan_color(&p, 3000.0), tint_toward(p.label, p.accent, 0.5), "halfway blend");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn combined_cell_unknown_actual_is_not_coloured_red() {
|
||||
let p = test_pal();
|
||||
@@ -4669,23 +4740,4 @@ mod tests {
|
||||
let actual_only = encode_combined_cell(&p, Some("95.0T".to_string()), None, "/", None);
|
||||
assert_eq!(decode_segments_plain(&actual_only), "95.0T");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn cooling_cell_colours_each_fan_with_black_slashes() {
|
||||
let p = test_pal();
|
||||
assert_eq!(
|
||||
decode_segments_plain(&encode_cooling_cell(&p, &[4800.0, 4600.0])),
|
||||
"4.8k/4.6k",
|
||||
);
|
||||
// Slash segments carry no colour (they render in the default text colour).
|
||||
let encoded = encode_cooling_cell(&p, &[4800.0, 4600.0]);
|
||||
let expected = encode_segments(&[
|
||||
(Some(fan_color(&p, 4800.0)), format_fan_rpm(4800.0)),
|
||||
(None, "/".to_string()),
|
||||
(Some(fan_color(&p, 4600.0)), format_fan_rpm(4600.0)),
|
||||
]);
|
||||
assert_eq!(encoded, expected);
|
||||
// No fans -> a single empty segment that decodes to "".
|
||||
assert_eq!(decode_segments_plain(&encode_cooling_cell(&p, &[])), "");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,233 @@
|
||||
Subject: [PATCH 0023] telemetry: PSU serial + chip/hashboard type + best-share
|
||||
|
||||
Round 19 #10 telemetry extension (tier 1 -- struct-only, no new DataField, and
|
||||
every command read is already fetched so there are no extra round-trips):
|
||||
|
||||
- PsuInfo gains a `serial` field. Braiins v26_04 parse_psu is corrected to read
|
||||
the human model_name and the firmware fw_version (it had used the numeric type
|
||||
code as the model and dropped fw_version entirely) and to capture serial_number.
|
||||
ePIC and WhatsMiner v1/v2 report no PSU serial (left None).
|
||||
- BoardData gains `chip_type` (ASIC model, e.g. "BM1370") and `hashboard_model`
|
||||
(e.g. "A3HB70601"). Braiins miner/hw/hashboards populates both.
|
||||
- best_share (all-time) wired for Antminer v2020 and WhatsMiner v1/v2 from the
|
||||
already-fetched cgminer/btminer `summary` "Best Share"; those backends had the
|
||||
empty default GetBestShare (v2023_07 already had it).
|
||||
|
||||
Existing fixture tests for braiins/antminer/whatsminer pass unchanged.
|
||||
|
||||
diff --git a/vendor/asic-rs-core/src/data/board.rs b/vendor/asic-rs-core/src/data/board.rs
|
||||
index 1a2c5ead..32ce4e6a 100644
|
||||
--- a/vendor/asic-rs-core/src/data/board.rs
|
||||
+++ b/vendor/asic-rs-core/src/data/board.rs
|
||||
@@ -90,6 +90,12 @@ pub struct BoardData {
|
||||
pub tuned: Option<bool>,
|
||||
/// Whether this board is enabled and actively mining
|
||||
pub active: Option<bool>,
|
||||
+ /// The ASIC chip type/model on this board (e.g. "BM1370"), when reported.
|
||||
+ /// Not exposed by Antminer/LuxOS (their network API reports only the control
|
||||
+ /// board type).
|
||||
+ pub chip_type: Option<String>,
|
||||
+ /// The hashboard model / part identifier (e.g. "A3HB70601"), when reported.
|
||||
+ pub hashboard_model: Option<String>,
|
||||
}
|
||||
|
||||
impl BoardData {
|
||||
diff --git a/vendor/asic-rs-core/src/data/psu.rs b/vendor/asic-rs-core/src/data/psu.rs
|
||||
index 810ba47c..cb73b23e 100644
|
||||
--- a/vendor/asic-rs-core/src/data/psu.rs
|
||||
+++ b/vendor/asic-rs-core/src/data/psu.rs
|
||||
@@ -19,6 +19,8 @@ pub struct PsuInfo {
|
||||
pub model: Option<String>,
|
||||
/// PSU firmware/hardware version, when reported.
|
||||
pub version: Option<String>,
|
||||
+ /// PSU serial number, when reported (Braiins, WhatsMiner V3, VNish).
|
||||
+ pub serial: Option<String>,
|
||||
/// Minimum rated output voltage in volts, when reported.
|
||||
pub voltage_min: Option<f64>,
|
||||
/// Maximum rated output voltage in volts, when reported.
|
||||
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 bd8662b1..63f819f8 100644
|
||||
--- a/vendor/asic-rs-firmwares-antminer/src/backends/v2020/mod.rs
|
||||
+++ b/vendor/asic-rs-firmwares-antminer/src/backends/v2020/mod.rs
|
||||
@@ -499,6 +499,16 @@ impl GetDataLocations for AntMinerV2020 {
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
+ // cgminer summary "Best Share" (all-time). RPC_SUMMARY is already
|
||||
+ // fetched, so this adds no round-trip (round 19 #10).
|
||||
+ DataField::BestShare => vec![(
|
||||
+ RPC_SUMMARY,
|
||||
+ DataExtractor {
|
||||
+ func: get_by_pointer,
|
||||
+ key: Some("/SUMMARY/0/Best Share"),
|
||||
+ tag: None,
|
||||
+ },
|
||||
+ )],
|
||||
// `total_rateideal`, by contrast, says nothing about its own
|
||||
// scale, so carry STATS' `rate_unit` alongside it.
|
||||
DataField::ExpectedHashrate => vec![
|
||||
@@ -873,7 +883,13 @@ impl GetUptime for AntMinerV2020 {
|
||||
}
|
||||
}
|
||||
|
||||
-impl GetBestShare for AntMinerV2020 {}
|
||||
+impl GetBestShare for AntMinerV2020 {
|
||||
+ fn parse_best_share(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
|
||||
+ // cgminer summary "Best Share" (all-time); guard against a 0 placeholder
|
||||
+ // (round 19 #10).
|
||||
+ data.extract::<f64>(DataField::BestShare).filter(|&v| v > 0.0)
|
||||
+ }
|
||||
+}
|
||||
impl GetSessionBestShare for AntMinerV2020 {}
|
||||
|
||||
impl GetOperatingState for AntMinerV2020 {}
|
||||
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 9b72ed94..22e34b0b 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
|
||||
@@ -498,6 +498,16 @@ impl GetHashboards for BraiinsV2604 {
|
||||
.and_then(|v| v.as_f64())
|
||||
.map(Frequency::from_hertz);
|
||||
board.active = chain.pointer("/enabled").and_then(|v| v.as_bool());
|
||||
+ // ASIC chip model + hashboard model/part (round 19 #10 telemetry
|
||||
+ // extension). BOS+ miner/hw/hashboards reports chip_type ("BM1370")
|
||||
+ // and model ("A3HB70601"); board_name is the human label if present.
|
||||
+ board.chip_type =
|
||||
+ chain.pointer("/chip_type").and_then(|v| v.as_str()).map(str::to_string);
|
||||
+ board.hashboard_model = chain
|
||||
+ .pointer("/model")
|
||||
+ .or_else(|| chain.pointer("/board_name"))
|
||||
+ .and_then(|v| v.as_str())
|
||||
+ .map(str::to_string);
|
||||
}
|
||||
|
||||
hashboards
|
||||
@@ -676,13 +686,15 @@ impl GetWattage for BraiinsV2604 {
|
||||
}
|
||||
|
||||
fn parse_psu(&self, data: &HashMap<DataField, Value>) -> Option<PsuInfo> {
|
||||
- // BOS miner/details -> psu_info {version, min_voltage.volt, max_voltage.volt}.
|
||||
- // "version" is the PSU type code (117 = the APW12 ePIC also reports as model
|
||||
- // 117), so expose it as the model for consistency across firmwares.
|
||||
+ // BOS miner/details -> psu_info { model_name, fw_version, serial_number,
|
||||
+ // version (numeric type code), min_voltage.volt, max_voltage.volt }. Read
|
||||
+ // the human model_name and the firmware version (the old code used the
|
||||
+ // numeric "version" type code as the model and dropped fw_version entirely).
|
||||
let d = data.get(&DataField::Psu)?;
|
||||
let psu = PsuInfo {
|
||||
- model: d.pointer("/version").and_then(|v| v.as_i64()).map(|n| n.to_string()),
|
||||
- version: None,
|
||||
+ model: d.pointer("/model_name").and_then(|v| v.as_str()).map(str::to_string),
|
||||
+ version: d.pointer("/fw_version").and_then(|v| v.as_i64()).map(|n| n.to_string()),
|
||||
+ serial: d.pointer("/serial_number").and_then(|v| v.as_str()).map(str::to_string),
|
||||
voltage_min: d.pointer("/min_voltage/volt").and_then(|v| v.as_f64()),
|
||||
voltage_max: d.pointer("/max_voltage/volt").and_then(|v| v.as_f64()),
|
||||
output_voltage: None,
|
||||
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 3365824d..7238dc27 100644
|
||||
--- a/vendor/asic-rs-firmwares-epic/src/backends/v1/mod.rs
|
||||
+++ b/vendor/asic-rs-firmwares-epic/src/backends/v1/mod.rs
|
||||
@@ -1128,6 +1128,7 @@ impl GetWattage for PowerPlayV1 {
|
||||
let psu = PsuInfo {
|
||||
model: f(info, "/PSU Type").map(|n| format!("{n:.0}")),
|
||||
version: f(info, "/FW").map(|n| format!("{n:.0}")),
|
||||
+ serial: None, // ePIC capabilities does not report a PSU serial
|
||||
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"),
|
||||
diff --git a/vendor/asic-rs-firmwares-sealminer/src/backends/v2025/mod.rs b/vendor/asic-rs-firmwares-sealminer/src/backends/v2025/mod.rs
|
||||
index 9617da70..f71750e1 100644
|
||||
--- a/vendor/asic-rs-firmwares-sealminer/src/backends/v2025/mod.rs
|
||||
+++ b/vendor/asic-rs-firmwares-sealminer/src/backends/v2025/mod.rs
|
||||
@@ -474,6 +474,7 @@ impl GetHashboards for SealMinerV2025 {
|
||||
frequency: freq,
|
||||
tuned,
|
||||
active: Some(online),
|
||||
+ ..Default::default()
|
||||
}
|
||||
})
|
||||
.collect()
|
||||
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 3c8512ad..eb2bdad8 100644
|
||||
--- a/vendor/asic-rs-firmwares-whatsminer/src/backends/v1/mod.rs
|
||||
+++ b/vendor/asic-rs-firmwares-whatsminer/src/backends/v1/mod.rs
|
||||
@@ -244,6 +244,16 @@ impl GetDataLocations for WhatsMinerV1 {
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
+ // btminer summary "Best Share" (all-time); RPC_SUMMARY already fetched
|
||||
+ // (round 19 #10).
|
||||
+ DataField::BestShare => vec![(
|
||||
+ RPC_SUMMARY,
|
||||
+ DataExtractor {
|
||||
+ func: get_by_pointer,
|
||||
+ key: Some("/SUMMARY/0/Best Share"),
|
||||
+ tag: None,
|
||||
+ },
|
||||
+ )],
|
||||
DataField::ExpectedHashrate => vec![(
|
||||
RPC_SUMMARY,
|
||||
DataExtractor {
|
||||
@@ -483,6 +493,7 @@ impl GetWattage for WhatsMinerV1 {
|
||||
let psu = PsuInfo {
|
||||
model: s("/model").or_else(|| s("/name")),
|
||||
version: s("/hw_version").or_else(|| s("/sw_version")),
|
||||
+ serial: None, // v1/v2 get_psu does not report a serial (V3 does)
|
||||
voltage_min: None,
|
||||
voltage_max: None,
|
||||
output_voltage: None,
|
||||
@@ -548,7 +559,11 @@ impl GetUptime for WhatsMinerV1 {
|
||||
}
|
||||
}
|
||||
|
||||
-impl GetBestShare for WhatsMinerV1 {}
|
||||
+impl GetBestShare for WhatsMinerV1 {
|
||||
+ fn parse_best_share(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
|
||||
+ data.extract::<f64>(DataField::BestShare).filter(|&v| v > 0.0)
|
||||
+ }
|
||||
+}
|
||||
impl GetSessionBestShare for WhatsMinerV1 {}
|
||||
impl GetOperatingState for WhatsMinerV1 {}
|
||||
|
||||
diff --git a/vendor/asic-rs-firmwares-whatsminer/src/backends/v2/mod.rs b/vendor/asic-rs-firmwares-whatsminer/src/backends/v2/mod.rs
|
||||
index de36a126..5de37579 100644
|
||||
--- a/vendor/asic-rs-firmwares-whatsminer/src/backends/v2/mod.rs
|
||||
+++ b/vendor/asic-rs-firmwares-whatsminer/src/backends/v2/mod.rs
|
||||
@@ -255,6 +255,16 @@ impl GetDataLocations for WhatsMinerV2 {
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
+ // btminer summary "Best Share" (all-time); RPC_SUMMARY already fetched
|
||||
+ // (round 19 #10).
|
||||
+ DataField::BestShare => vec![(
|
||||
+ RPC_SUMMARY,
|
||||
+ DataExtractor {
|
||||
+ func: get_by_pointer,
|
||||
+ key: Some("/SUMMARY/0/Best Share"),
|
||||
+ tag: None,
|
||||
+ },
|
||||
+ )],
|
||||
DataField::ExpectedHashrate => vec![(
|
||||
RPC_SUMMARY,
|
||||
DataExtractor {
|
||||
@@ -490,6 +500,7 @@ impl GetWattage for WhatsMinerV2 {
|
||||
let psu = PsuInfo {
|
||||
model: s("/model").or_else(|| s("/name")),
|
||||
version: s("/hw_version").or_else(|| s("/sw_version")),
|
||||
+ serial: None, // v1/v2 get_psu does not report a serial (V3 does)
|
||||
voltage_min: None,
|
||||
voltage_max: None,
|
||||
output_voltage: None,
|
||||
@@ -577,7 +588,11 @@ impl GetUptime for WhatsMinerV2 {
|
||||
}
|
||||
}
|
||||
|
||||
-impl GetBestShare for WhatsMinerV2 {}
|
||||
+impl GetBestShare for WhatsMinerV2 {
|
||||
+ fn parse_best_share(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
|
||||
+ data.extract::<f64>(DataField::BestShare).filter(|&v| v > 0.0)
|
||||
+ }
|
||||
+}
|
||||
impl GetSessionBestShare for WhatsMinerV2 {}
|
||||
impl GetOperatingState for WhatsMinerV2 {}
|
||||
|
||||
@@ -0,0 +1,93 @@
|
||||
Subject: [PATCH 0024] whatsminer v3 PSU serial + epic chip/hashboard type
|
||||
|
||||
Round 19 #10 telemetry extension, tier 1 sub-batch B. Both fields ride existing
|
||||
DataFields (Psu / Hashboards) on commands the collector already fetches, so there
|
||||
are no extra round-trips, and both reuse the PsuInfo.serial and
|
||||
BoardData.chip_type/hashboard_model fields added in patch 0023 -- no core or GUI
|
||||
change, the existing columns just populate for more firmwares.
|
||||
|
||||
- WhatsMiner V3: add a DataField::Psu location (get.device.info /msg/power) and a
|
||||
parse_psu that reads model/type, sw/hwversion and the serial (sn). V3 carried
|
||||
no PSU parse at all (default None) even though /msg/power is already fetched for
|
||||
the PSU fan.
|
||||
- ePIC: parse_hashboards now reads capabilities "Chip Type" (e.g. "BM1366") and
|
||||
"Model Subtype" (e.g. "BHB56801") and applies them to every board (capabilities
|
||||
reports them miner-wide). The capabilities command is already fetched for
|
||||
hashboards.
|
||||
|
||||
Existing fixture tests for whatsminer/epic pass unchanged.
|
||||
|
||||
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 7238dc27..2abb0706 100644
|
||||
--- a/vendor/asic-rs-firmwares-epic/src/backends/v1/mod.rs
|
||||
+++ b/vendor/asic-rs-firmwares-epic/src/backends/v1/mod.rs
|
||||
@@ -797,6 +797,21 @@ impl GetHashboards for PowerPlayV1 {
|
||||
.pointer("/Capabilities/Performance Estimator/Hashes Per Second Per Chip")
|
||||
.and_then(|v| v.as_f64());
|
||||
|
||||
+ // ASIC chip type + hashboard model from capabilities (round 19 #10);
|
||||
+ // capabilities reports them miner-wide, so apply to every board.
|
||||
+ let chip_type =
|
||||
+ api_data.pointer("/Capabilities/Chip Type").and_then(|v| v.as_str()).map(str::to_string);
|
||||
+ let hashboard_model = api_data
|
||||
+ .pointer("/Capabilities/Model Subtype")
|
||||
+ .and_then(|v| v.as_str())
|
||||
+ .map(str::to_string);
|
||||
+ if chip_type.is_some() || hashboard_model.is_some() {
|
||||
+ for board in &mut hashboards {
|
||||
+ board.chip_type = chip_type.clone();
|
||||
+ board.hashboard_model = hashboard_model.clone();
|
||||
+ }
|
||||
+ }
|
||||
+
|
||||
// Active status
|
||||
if let Some(boards) = api_data
|
||||
.pointer("/Summary/HBStatus")
|
||||
diff --git a/vendor/asic-rs-firmwares-whatsminer/src/backends/v3/mod.rs b/vendor/asic-rs-firmwares-whatsminer/src/backends/v3/mod.rs
|
||||
index c00c6d44..930abe38 100644
|
||||
--- a/vendor/asic-rs-firmwares-whatsminer/src/backends/v3/mod.rs
|
||||
+++ b/vendor/asic-rs-firmwares-whatsminer/src/backends/v3/mod.rs
|
||||
@@ -21,6 +21,7 @@ use asic_rs_core::{
|
||||
message::{MessageSeverity, MinerMessage},
|
||||
miner::{MiningMode, TuningTarget},
|
||||
pool::{PoolData, PoolGroupData, PoolURL},
|
||||
+ psu::PsuInfo,
|
||||
},
|
||||
traits::{miner::*, model::MinerModel},
|
||||
util::is_expected_write_error,
|
||||
@@ -235,6 +236,16 @@ impl GetDataLocations for WhatsMinerV3 {
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
+ // PSU identity block (round 19 #10): get.device.info /msg/power carries
|
||||
+ // model/type, sw/hwversion and the serial (sn). Already fetched.
|
||||
+ DataField::Psu => vec![(
|
||||
+ RPC_GET_DEVICE_INFO,
|
||||
+ DataExtractor {
|
||||
+ func: get_by_pointer,
|
||||
+ key: Some("/msg/power"),
|
||||
+ tag: None,
|
||||
+ },
|
||||
+ )],
|
||||
DataField::Hashboards => vec![
|
||||
(
|
||||
RPC_GET_DEVICE_INFO,
|
||||
@@ -509,6 +520,18 @@ impl GetWattage for WhatsMinerV3 {
|
||||
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> {
|
||||
+ // get.device.info /msg/power: model/type, sw/hwversion, sn (round 19 #10).
|
||||
+ let d = data.get(&DataField::Psu)?;
|
||||
+ let s = |k: &str| d.pointer(k).and_then(|v| v.as_str()).filter(|s| !s.is_empty()).map(str::to_string);
|
||||
+ let psu = PsuInfo {
|
||||
+ model: s("/model").or_else(|| s("/type")),
|
||||
+ version: s("/swversion").or_else(|| s("/hwversion")),
|
||||
+ serial: s("/sn"),
|
||||
+ ..Default::default()
|
||||
+ };
|
||||
+ (psu != PsuInfo::default()).then_some(psu)
|
||||
+ }
|
||||
}
|
||||
/// Parses tuning target from V3 tagged data (mode from get.device.info, limit from summary).
|
||||
/// Mode "0" (Low) / "2" (High) → MiningMode, "1" (Normal) / unknown → Power(limit).
|
||||
@@ -0,0 +1,491 @@
|
||||
Subject: [PATCH 0025] telemetry: rolling average hashrate windows (1m/5m/15m/24h)
|
||||
|
||||
Round 19 #10 telemetry extension, tier 2. Exposes the rolling average hashrate
|
||||
windows the GUI wanted (1m/5m/15m/24h).
|
||||
|
||||
- New HashrateAverages sub-struct (data/hashrate.rs): avg_1m/5m/15m/24h, each an
|
||||
Option<HashRate> carrying the same unit and algorithm as the current hashrate.
|
||||
- New DataField::HashrateAverages; MinerData gains hashrate_averages.
|
||||
- The windows ride the EXISTING GetHashrate trait via a defaulted
|
||||
parse_hashrate_averages method (default None), so no new supertrait bound and no
|
||||
empty impl per backend; only backends that expose the data override it, and
|
||||
parse_data wires it in.
|
||||
- Backends (each reads a command the collector already fetches, so no extra
|
||||
round-trips; each window is filtered to > 0 and the struct is dropped when every
|
||||
window is absent):
|
||||
- WhatsMiner V1: btminer summary MHS 1m/5m/15m (MegaHash); no 24h.
|
||||
- WhatsMiner V3: get.miner.status summary hash-1min / hash-15min (TeraHash).
|
||||
- LuxOS: summary GHS 1m/5m/15m/24h (GigaHash) -- full window set.
|
||||
- Braiins v25_07 + v26_04: miner_stats real_hashrate last_1m/5m/15m/24h.
|
||||
- Antminer, WhatsMiner V2, ePIC, VNish, sealminer expose no standard 1/5/15
|
||||
window (fixtures confirm) and inherit None.
|
||||
|
||||
Fixture tests for whatsminer v1 and braiins v26_04 assert the parsed windows.
|
||||
|
||||
diff --git a/vendor/asic-rs-core/src/data/collector.rs b/vendor/asic-rs-core/src/data/collector.rs
|
||||
index d1456548..5899c039 100644
|
||||
--- a/vendor/asic-rs-core/src/data/collector.rs
|
||||
+++ b/vendor/asic-rs-core/src/data/collector.rs
|
||||
@@ -56,6 +56,9 @@ pub enum DataField {
|
||||
/// Expected hashrate for the miner.
|
||||
#[cfg_attr(feature = "python", pydantic(value = "ExpectedHashrate"))]
|
||||
ExpectedHashrate,
|
||||
+ /// Rolling average hashrate windows (1m/5m/15m/24h) reported by the miner.
|
||||
+ #[cfg_attr(feature = "python", pydantic(value = "HashrateAverages"))]
|
||||
+ HashrateAverages,
|
||||
/// Fan speed or fan configuration.
|
||||
#[cfg_attr(feature = "python", pydantic(value = "Fans"))]
|
||||
Fans,
|
||||
diff --git a/vendor/asic-rs-core/src/data/hashrate.rs b/vendor/asic-rs-core/src/data/hashrate.rs
|
||||
index 3e3ff9ab..6107745d 100644
|
||||
--- a/vendor/asic-rs-core/src/data/hashrate.rs
|
||||
+++ b/vendor/asic-rs-core/src/data/hashrate.rs
|
||||
@@ -318,3 +318,32 @@ impl Div<HashRate> for Power {
|
||||
self.as_watts() / hash_rate.value
|
||||
}
|
||||
}
|
||||
+
|
||||
+/// Rolling average hashrate over standard time windows, as reported by firmware.
|
||||
+///
|
||||
+/// Each window is optional; a backend fills in only the windows its firmware
|
||||
+/// exposes. The 24h window is reported by Braiins only. Every value carries the
|
||||
+/// same unit and mining algorithm as the miner's current hashrate.
|
||||
+#[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 HashrateAverages {
|
||||
+ /// Average hashrate over the last minute, when reported.
|
||||
+ pub avg_1m: Option<HashRate>,
|
||||
+ /// Average hashrate over the last 5 minutes, when reported.
|
||||
+ pub avg_5m: Option<HashRate>,
|
||||
+ /// Average hashrate over the last 15 minutes, when reported.
|
||||
+ pub avg_15m: Option<HashRate>,
|
||||
+ /// Average hashrate over the last 24 hours, when reported (Braiins only).
|
||||
+ pub avg_24h: Option<HashRate>,
|
||||
+}
|
||||
+
|
||||
+impl HashrateAverages {
|
||||
+ /// True when no window is populated.
|
||||
+ pub fn is_empty(&self) -> bool {
|
||||
+ self.avg_1m.is_none()
|
||||
+ && self.avg_5m.is_none()
|
||||
+ && self.avg_15m.is_none()
|
||||
+ && self.avg_24h.is_none()
|
||||
+ }
|
||||
+}
|
||||
diff --git a/vendor/asic-rs-core/src/data/miner.rs b/vendor/asic-rs-core/src/data/miner.rs
|
||||
index b2b8a578..38c7f3be 100644
|
||||
--- a/vendor/asic-rs-core/src/data/miner.rs
|
||||
+++ b/vendor/asic-rs-core/src/data/miner.rs
|
||||
@@ -12,7 +12,7 @@ use super::{
|
||||
capabilities::TuningCapabilities,
|
||||
device::DeviceInfo,
|
||||
fan::FanData,
|
||||
- hashrate::HashRate,
|
||||
+ hashrate::{HashRate, HashrateAverages},
|
||||
message::MinerMessage,
|
||||
operating_state::OperatingState,
|
||||
pool::PoolGroupData,
|
||||
@@ -165,6 +165,8 @@ pub struct MinerData {
|
||||
pub hashboards: Vec<BoardData>,
|
||||
/// The current hashrate of the miner
|
||||
pub hashrate: Option<HashRate>,
|
||||
+ /// Rolling average hashrate windows (1m/5m/15m/24h), when reported
|
||||
+ pub hashrate_averages: Option<HashrateAverages>,
|
||||
/// The expected hashrate of the miner
|
||||
pub expected_hashrate: Option<HashRate>,
|
||||
/// The total expected number of chips across all boards on this miner
|
||||
diff --git a/vendor/asic-rs-core/src/traits/miner.rs b/vendor/asic-rs-core/src/traits/miner.rs
|
||||
index db1ba653..cfabb624 100644
|
||||
--- a/vendor/asic-rs-core/src/traits/miner.rs
|
||||
+++ b/vendor/asic-rs-core/src/traits/miner.rs
|
||||
@@ -28,7 +28,7 @@ use crate::{
|
||||
device::DeviceInfo,
|
||||
fan::FanData,
|
||||
firmware::{FirmwareImage, FirmwareStats},
|
||||
- hashrate::{HashRate, HashRateUnit},
|
||||
+ hashrate::{HashRate, HashRateUnit, HashrateAverages},
|
||||
message::MinerMessage,
|
||||
miner::{MinerData, TuningTarget},
|
||||
operating_state::OperatingState,
|
||||
@@ -271,6 +271,7 @@ impl<
|
||||
let control_board_version = self.parse_control_board_version(&data);
|
||||
let uptime = self.parse_uptime(&data);
|
||||
let hashrate = self.parse_hashrate(&data);
|
||||
+ let hashrate_averages = self.parse_hashrate_averages(&data);
|
||||
let expected_hashrate = self.parse_expected_hashrate(&data);
|
||||
let wattage = self.parse_wattage(&data);
|
||||
let psu = self.parse_psu(&data);
|
||||
@@ -353,6 +354,7 @@ impl<
|
||||
expected_hashboards: device_info.hardware.board_count(),
|
||||
hashboards,
|
||||
hashrate,
|
||||
+ hashrate_averages,
|
||||
expected_hashrate,
|
||||
|
||||
// Chip information
|
||||
@@ -632,6 +634,20 @@ pub trait GetHashrate: CollectData {
|
||||
fn parse_hashrate(&self, data: &HashMap<DataField, Value>) -> Option<HashRate> {
|
||||
None
|
||||
}
|
||||
+ #[tracing::instrument(level = "debug")]
|
||||
+ async fn get_hashrate_averages(&self) -> Option<HashrateAverages> {
|
||||
+ let mut collector = self.get_collector();
|
||||
+ let data = collector
|
||||
+ .collect(&[DataField::HashrateAverages, DataField::Hashrate])
|
||||
+ .await;
|
||||
+ self.parse_hashrate_averages(&data)
|
||||
+ }
|
||||
+ /// Rolling average hashrate windows. Backends that expose them override this;
|
||||
+ /// the values carry the same unit and algorithm as the current hashrate.
|
||||
+ #[allow(unused_variables)]
|
||||
+ fn parse_hashrate_averages(&self, data: &HashMap<DataField, Value>) -> Option<HashrateAverages> {
|
||||
+ None
|
||||
+ }
|
||||
}
|
||||
|
||||
// Expected Hashrate
|
||||
diff --git a/vendor/asic-rs-firmwares-braiins/src/backends/v25_07/mod.rs b/vendor/asic-rs-firmwares-braiins/src/backends/v25_07/mod.rs
|
||||
index 57c0c2c7..7e07967f 100644
|
||||
--- a/vendor/asic-rs-firmwares-braiins/src/backends/v25_07/mod.rs
|
||||
+++ b/vendor/asic-rs-firmwares-braiins/src/backends/v25_07/mod.rs
|
||||
@@ -16,7 +16,7 @@ use asic_rs_core::{
|
||||
command::MinerCommand,
|
||||
device::{DeviceInfo, HashAlgorithm},
|
||||
fan::FanData,
|
||||
- hashrate::{HashRate, HashRateUnit},
|
||||
+ hashrate::{HashRate, HashRateUnit, HashrateAverages},
|
||||
message::{MessageSeverity, MinerMessage},
|
||||
miner::TuningTarget,
|
||||
operating_state::OperatingState,
|
||||
@@ -204,6 +204,16 @@ impl GetDataLocations for BraiinsV2507 {
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
+ // Rolling averages from miner_stats real_hashrate (round 19 #10, T2);
|
||||
+ // command already fetched. Braiins reports the full 1m/5m/15m/24h set.
|
||||
+ DataField::HashrateAverages => vec![(
|
||||
+ WEB_MINER_STATS,
|
||||
+ DataExtractor {
|
||||
+ func: get_by_pointer,
|
||||
+ key: Some("/miner_stats/real_hashrate"),
|
||||
+ tag: None,
|
||||
+ },
|
||||
+ )],
|
||||
DataField::ExpectedHashrate => vec![(
|
||||
WEB_MINER_DETAILS,
|
||||
DataExtractor {
|
||||
@@ -494,6 +504,31 @@ impl GetHashrate for BraiinsV2507 {
|
||||
.as_unit(HashRateUnit::default())
|
||||
})
|
||||
}
|
||||
+ fn parse_hashrate_averages(&self, data: &HashMap<DataField, Value>) -> Option<HashrateAverages> {
|
||||
+ // miner_stats real_hashrate last_1m/5m/15m/24h (GigaHash); full window set
|
||||
+ // (round 19 #10).
|
||||
+ let d = data.get(&DataField::HashrateAverages)?;
|
||||
+ let ghs = |k: &str| {
|
||||
+ d.pointer(&format!("/{k}/gigahash_per_second"))
|
||||
+ .and_then(|v| v.as_f64())
|
||||
+ .filter(|&f| f > 0.0)
|
||||
+ .map(|f| {
|
||||
+ HashRate {
|
||||
+ value: f,
|
||||
+ unit: HashRateUnit::GigaHash,
|
||||
+ algo: self.device_info.algo,
|
||||
+ }
|
||||
+ .as_unit(HashRateUnit::default())
|
||||
+ })
|
||||
+ };
|
||||
+ let avgs = HashrateAverages {
|
||||
+ avg_1m: ghs("last_1m"),
|
||||
+ avg_5m: ghs("last_5m"),
|
||||
+ avg_15m: ghs("last_15m"),
|
||||
+ avg_24h: ghs("last_24h"),
|
||||
+ };
|
||||
+ (!avgs.is_empty()).then_some(avgs)
|
||||
+ }
|
||||
}
|
||||
|
||||
impl GetExpectedHashrate for BraiinsV2507 {
|
||||
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 22e34b0b..2f5be88c 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
|
||||
@@ -17,7 +17,7 @@ use asic_rs_core::{
|
||||
device::{DeviceInfo, HashAlgorithm},
|
||||
fan::FanData,
|
||||
firmware::{FirmwareStats, FirmwareUpdate},
|
||||
- hashrate::{HashRate, HashRateUnit},
|
||||
+ hashrate::{HashRate, HashRateUnit, HashrateAverages},
|
||||
message::{MessageSeverity, MinerMessage},
|
||||
miner::TuningTarget,
|
||||
operating_state::OperatingState,
|
||||
@@ -207,6 +207,16 @@ impl GetDataLocations for BraiinsV2604 {
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
+ // Rolling averages from miner_stats real_hashrate (round 19 #10, T2);
|
||||
+ // command already fetched. Braiins reports the full 1m/5m/15m/24h set.
|
||||
+ DataField::HashrateAverages => vec![(
|
||||
+ WEB_MINER_STATS,
|
||||
+ DataExtractor {
|
||||
+ func: get_by_pointer,
|
||||
+ key: Some("/miner_stats/real_hashrate"),
|
||||
+ tag: None,
|
||||
+ },
|
||||
+ )],
|
||||
DataField::ExpectedHashrate => vec![(
|
||||
WEB_MINER_DETAILS,
|
||||
DataExtractor {
|
||||
@@ -525,6 +535,31 @@ impl GetHashrate for BraiinsV2604 {
|
||||
.as_unit(HashRateUnit::default())
|
||||
})
|
||||
}
|
||||
+ fn parse_hashrate_averages(&self, data: &HashMap<DataField, Value>) -> Option<HashrateAverages> {
|
||||
+ // miner_stats real_hashrate last_1m/5m/15m/24h (GigaHash); full window set
|
||||
+ // (round 19 #10).
|
||||
+ let d = data.get(&DataField::HashrateAverages)?;
|
||||
+ let ghs = |k: &str| {
|
||||
+ d.pointer(&format!("/{k}/gigahash_per_second"))
|
||||
+ .and_then(|v| v.as_f64())
|
||||
+ .filter(|&f| f > 0.0)
|
||||
+ .map(|f| {
|
||||
+ HashRate {
|
||||
+ value: f,
|
||||
+ unit: HashRateUnit::GigaHash,
|
||||
+ algo: self.device_info.algo,
|
||||
+ }
|
||||
+ .as_unit(HashRateUnit::default())
|
||||
+ })
|
||||
+ };
|
||||
+ let avgs = HashrateAverages {
|
||||
+ avg_1m: ghs("last_1m"),
|
||||
+ avg_5m: ghs("last_5m"),
|
||||
+ avg_15m: ghs("last_15m"),
|
||||
+ avg_24h: ghs("last_24h"),
|
||||
+ };
|
||||
+ (!avgs.is_empty()).then_some(avgs)
|
||||
+ }
|
||||
}
|
||||
|
||||
impl GetExpectedHashrate for BraiinsV2604 {
|
||||
@@ -1241,6 +1276,17 @@ mod tests {
|
||||
assert_eq!(miner_data.pools[0].len(), 2);
|
||||
assert!(miner_data.hashrate.is_some());
|
||||
assert!(miner_data.expected_hashrate.is_some());
|
||||
+ // Rolling averages: miner_stats real_hashrate last_1m/5m/15m/24h (GigaHash);
|
||||
+ // Braiins reports the full window set (round 19 #10, T2).
|
||||
+ let avgs = miner_data
|
||||
+ .hashrate_averages
|
||||
+ .expect("braiins exposes rolling averages");
|
||||
+ assert!(avgs.avg_1m.is_some() && avgs.avg_5m.is_some());
|
||||
+ assert!(avgs.avg_15m.is_some() && avgs.avg_24h.is_some());
|
||||
+ if let Some(hr) = &avgs.avg_1m {
|
||||
+ assert_eq!(hr.unit, HashRateUnit::TeraHash);
|
||||
+ assert!((hr.value - 247.3507543407177).abs() < 1e-3);
|
||||
+ }
|
||||
}
|
||||
|
||||
#[test]
|
||||
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 b5a5a73c..a75a3f97 100644
|
||||
--- a/vendor/asic-rs-firmwares-luxminer/src/backends/v1/mod.rs
|
||||
+++ b/vendor/asic-rs-firmwares-luxminer/src/backends/v1/mod.rs
|
||||
@@ -16,7 +16,7 @@ use asic_rs_core::{
|
||||
command::MinerCommand,
|
||||
device::{DeviceInfo, HashAlgorithm},
|
||||
fan::FanData,
|
||||
- hashrate::{HashRate, HashRateUnit},
|
||||
+ hashrate::{HashRate, HashRateUnit, HashrateAverages},
|
||||
message::{MessageSeverity, MinerMessage},
|
||||
miner::TuningTarget,
|
||||
pool::{PoolData, PoolGroupData, PoolURL},
|
||||
@@ -537,6 +537,16 @@ impl GetDataLocations for LuxMinerV1 {
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
+ // LuxOS summary exposes full rolling windows GHS 1m/5m/15m/24h
|
||||
+ // (GigaHash); RPC_SUMMARY is already fetched (round 19 #10, T2).
|
||||
+ DataField::HashrateAverages => vec![(
|
||||
+ RPC_SUMMARY,
|
||||
+ DataExtractor {
|
||||
+ func: get_by_pointer,
|
||||
+ key: Some("/SUMMARY/0"),
|
||||
+ tag: None,
|
||||
+ },
|
||||
+ )],
|
||||
DataField::ExpectedHashrate => vec![(
|
||||
RPC_DEVS,
|
||||
DataExtractor {
|
||||
@@ -843,6 +853,30 @@ impl GetHashrate for LuxMinerV1 {
|
||||
.as_unit(HashRateUnit::default())
|
||||
})
|
||||
}
|
||||
+ fn parse_hashrate_averages(&self, data: &HashMap<DataField, Value>) -> Option<HashrateAverages> {
|
||||
+ // LuxOS summary GHS 1m/5m/15m/24h (GigaHash); full window set (round 19 #10).
|
||||
+ let d = data.get(&DataField::HashrateAverages)?;
|
||||
+ let ghs = |k: &str| {
|
||||
+ d.pointer(k)
|
||||
+ .and_then(|v| v.as_f64())
|
||||
+ .filter(|&f| f > 0.0)
|
||||
+ .map(|f| {
|
||||
+ HashRate {
|
||||
+ value: f,
|
||||
+ unit: HashRateUnit::GigaHash,
|
||||
+ algo: self.device_info.algo,
|
||||
+ }
|
||||
+ .as_unit(HashRateUnit::default())
|
||||
+ })
|
||||
+ };
|
||||
+ let avgs = HashrateAverages {
|
||||
+ avg_1m: ghs("/GHS 1m"),
|
||||
+ avg_5m: ghs("/GHS 5m"),
|
||||
+ avg_15m: ghs("/GHS 15m"),
|
||||
+ avg_24h: ghs("/GHS 24h"),
|
||||
+ };
|
||||
+ (!avgs.is_empty()).then_some(avgs)
|
||||
+ }
|
||||
}
|
||||
|
||||
impl GetExpectedHashrate for LuxMinerV1 {
|
||||
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 eb2bdad8..584ae8d1 100644
|
||||
--- a/vendor/asic-rs-firmwares-whatsminer/src/backends/v1/mod.rs
|
||||
+++ b/vendor/asic-rs-firmwares-whatsminer/src/backends/v1/mod.rs
|
||||
@@ -14,7 +14,7 @@ use asic_rs_core::{
|
||||
command::MinerCommand,
|
||||
device::{DeviceInfo, HashAlgorithm},
|
||||
fan::FanData,
|
||||
- hashrate::{HashRate, HashRateUnit},
|
||||
+ hashrate::{HashRate, HashRateUnit, HashrateAverages},
|
||||
message::{MessageSeverity, MinerMessage},
|
||||
miner::TuningTarget,
|
||||
pool::{PoolData, PoolGroupData, PoolURL},
|
||||
@@ -244,6 +244,16 @@ impl GetDataLocations for WhatsMinerV1 {
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
+ // Rolling average windows from btminer summary (round 19 #10, T2);
|
||||
+ // RPC_SUMMARY is already fetched.
|
||||
+ DataField::HashrateAverages => vec![(
|
||||
+ RPC_SUMMARY,
|
||||
+ DataExtractor {
|
||||
+ func: get_by_pointer,
|
||||
+ key: Some("/SUMMARY/0"),
|
||||
+ tag: None,
|
||||
+ },
|
||||
+ )],
|
||||
// btminer summary "Best Share" (all-time); RPC_SUMMARY already fetched
|
||||
// (round 19 #10).
|
||||
DataField::BestShare => vec![(
|
||||
@@ -429,6 +439,30 @@ impl GetHashrate for WhatsMinerV1 {
|
||||
.as_unit(HashRateUnit::default())
|
||||
})
|
||||
}
|
||||
+ fn parse_hashrate_averages(&self, data: &HashMap<DataField, Value>) -> Option<HashrateAverages> {
|
||||
+ // btminer summary MHS 1m/5m/15m (MegaHash); no 24h window (round 19 #10).
|
||||
+ let d = data.get(&DataField::HashrateAverages)?;
|
||||
+ let mhs = |k: &str| {
|
||||
+ d.pointer(k)
|
||||
+ .and_then(|v| v.as_f64())
|
||||
+ .filter(|&f| f > 0.0)
|
||||
+ .map(|f| {
|
||||
+ HashRate {
|
||||
+ value: f,
|
||||
+ unit: HashRateUnit::MegaHash,
|
||||
+ algo: self.device_info.algo,
|
||||
+ }
|
||||
+ .as_unit(HashRateUnit::default())
|
||||
+ })
|
||||
+ };
|
||||
+ let avgs = HashrateAverages {
|
||||
+ avg_1m: mhs("/MHS 1m"),
|
||||
+ avg_5m: mhs("/MHS 5m"),
|
||||
+ avg_15m: mhs("/MHS 15m"),
|
||||
+ avg_24h: None,
|
||||
+ };
|
||||
+ (!avgs.is_empty()).then_some(avgs)
|
||||
+ }
|
||||
}
|
||||
impl GetExpectedHashrate for WhatsMinerV1 {
|
||||
fn parse_expected_hashrate(&self, data: &HashMap<DataField, Value>) -> Option<HashRate> {
|
||||
@@ -924,6 +958,17 @@ mod integration_tests {
|
||||
algo: HashAlgorithm::SHA256,
|
||||
})
|
||||
);
|
||||
+ // Rolling averages: btminer summary MHS 1m/5m/15m (MegaHash), no 24h window
|
||||
+ // (round 19 #10, T2).
|
||||
+ let avgs = miner_data
|
||||
+ .hashrate_averages
|
||||
+ .ok_or_else(|| anyhow::anyhow!("v1 should expose rolling averages"))?;
|
||||
+ assert!(avgs.avg_1m.is_some() && avgs.avg_5m.is_some() && avgs.avg_15m.is_some());
|
||||
+ assert!(avgs.avg_24h.is_none());
|
||||
+ if let Some(hr) = &avgs.avg_1m {
|
||||
+ assert_eq!(hr.unit, HashRateUnit::TeraHash);
|
||||
+ assert!((hr.value - 67.43935249).abs() < 1e-6);
|
||||
+ }
|
||||
assert_eq!(miner_data.wattage, Some(Power::from_watts(3417f64)));
|
||||
assert_eq!(
|
||||
miner_data.tuning_target,
|
||||
diff --git a/vendor/asic-rs-firmwares-whatsminer/src/backends/v3/mod.rs b/vendor/asic-rs-firmwares-whatsminer/src/backends/v3/mod.rs
|
||||
index 930abe38..04608936 100644
|
||||
--- a/vendor/asic-rs-firmwares-whatsminer/src/backends/v3/mod.rs
|
||||
+++ b/vendor/asic-rs-firmwares-whatsminer/src/backends/v3/mod.rs
|
||||
@@ -17,7 +17,7 @@ use asic_rs_core::{
|
||||
command::MinerCommand,
|
||||
device::{DeviceInfo, HashAlgorithm},
|
||||
fan::FanData,
|
||||
- hashrate::{HashRate, HashRateUnit},
|
||||
+ hashrate::{HashRate, HashRateUnit, HashrateAverages},
|
||||
message::{MessageSeverity, MinerMessage},
|
||||
miner::{MiningMode, TuningTarget},
|
||||
pool::{PoolData, PoolGroupData, PoolURL},
|
||||
@@ -296,6 +296,16 @@ impl GetDataLocations for WhatsMinerV3 {
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
+ // Rolling averages from get.miner.status summary (round 19 #10, T2);
|
||||
+ // command already fetched. V3 exposes 1min and 15min only.
|
||||
+ DataField::HashrateAverages => vec![(
|
||||
+ rpc_get_miner_status_summary,
|
||||
+ DataExtractor {
|
||||
+ func: get_by_pointer,
|
||||
+ key: Some("/msg/summary"),
|
||||
+ tag: None,
|
||||
+ },
|
||||
+ )],
|
||||
DataField::ExpectedHashrate => vec![(
|
||||
rpc_get_miner_status_summary,
|
||||
DataExtractor {
|
||||
@@ -465,6 +475,31 @@ impl GetHashrate for WhatsMinerV3 {
|
||||
.as_unit(HashRateUnit::default())
|
||||
})
|
||||
}
|
||||
+ fn parse_hashrate_averages(&self, data: &HashMap<DataField, Value>) -> Option<HashrateAverages> {
|
||||
+ // get.miner.status summary hash-1min / hash-15min (TeraHash); V3 reports
|
||||
+ // no 5m or 24h window (round 19 #10).
|
||||
+ let d = data.get(&DataField::HashrateAverages)?;
|
||||
+ let ths = |k: &str| {
|
||||
+ d.pointer(k)
|
||||
+ .and_then(|v| v.as_f64())
|
||||
+ .filter(|&f| f > 0.0)
|
||||
+ .map(|f| {
|
||||
+ HashRate {
|
||||
+ value: f,
|
||||
+ unit: HashRateUnit::TeraHash,
|
||||
+ algo: self.device_info.algo,
|
||||
+ }
|
||||
+ .as_unit(HashRateUnit::default())
|
||||
+ })
|
||||
+ };
|
||||
+ let avgs = HashrateAverages {
|
||||
+ avg_1m: ths("/hash-1min"),
|
||||
+ avg_5m: None,
|
||||
+ avg_15m: ths("/hash-15min"),
|
||||
+ avg_24h: None,
|
||||
+ };
|
||||
+ (!avgs.is_empty()).then_some(avgs)
|
||||
+ }
|
||||
}
|
||||
impl GetExpectedHashrate for WhatsMinerV3 {
|
||||
fn parse_expected_hashrate(&self, data: &HashMap<DataField, Value>) -> Option<HashRate> {
|
||||
@@ -0,0 +1,399 @@
|
||||
Subject: [PATCH 0026] telemetry: cumulative share stats (difficulty acc/rej, stale, blocks)
|
||||
|
||||
Round 19 #10 telemetry extension, tier 2b. Exposes the cumulative share
|
||||
statistics the GUI wanted: difficulty-weighted accepted/rejected work, raw stale
|
||||
share count, and blocks found.
|
||||
|
||||
- New ShareSummary sub-struct (data/share.rs) + parse_cgminer_share_summary helper
|
||||
that reads a cgminer/btminer SUMMARY[0] object ("Difficulty Accepted",
|
||||
"Difficulty Rejected", "Stale", "Found Blocks").
|
||||
- New DataField::ShareSummary; MinerData gains share_summary.
|
||||
- Rides the EXISTING GetBestShare trait via a defaulted parse_share_summary method
|
||||
(default None), so no new supertrait bound and no empty impl per backend; only
|
||||
the cgminer-family backends override it. parse_data wires it in.
|
||||
- Backends (each reads the SUMMARY the collector already fetches, so no extra
|
||||
round-trips): Antminer v2020 + v2023_07, LuxOS, WhatsMiner V1 + V2. These are
|
||||
miner-level aggregates, not per-pool, so they are top-level MinerData fields (the
|
||||
per-pool accepted/rejected share counts stay on PoolData). Braiins does not
|
||||
expose cumulative difficulty; ePIC reports only the current difficulty target;
|
||||
WhatsMiner V3 and VNish expose none -> all inherit None.
|
||||
|
||||
Fixture tests for whatsminer v1 and antminer v2020 assert the parsed values.
|
||||
|
||||
diff --git a/vendor/asic-rs-core/src/data/collector.rs b/vendor/asic-rs-core/src/data/collector.rs
|
||||
index 5899c039..942b39f6 100644
|
||||
--- a/vendor/asic-rs-core/src/data/collector.rs
|
||||
+++ b/vendor/asic-rs-core/src/data/collector.rs
|
||||
@@ -111,6 +111,9 @@ pub enum DataField {
|
||||
/// Difficulty of the best share found over the miner's lifetime, when reported.
|
||||
#[cfg_attr(feature = "python", pydantic(value = "BestShare"))]
|
||||
BestShare,
|
||||
+ /// Cumulative share statistics (difficulty accepted/rejected, stale, blocks).
|
||||
+ #[cfg_attr(feature = "python", pydantic(value = "ShareSummary"))]
|
||||
+ ShareSummary,
|
||||
/// Difficulty of the best share found since the last boot or hashing start, when reported.
|
||||
#[cfg_attr(feature = "python", pydantic(value = "SessionBestShare"))]
|
||||
SessionBestShare,
|
||||
diff --git a/vendor/asic-rs-core/src/data/miner.rs b/vendor/asic-rs-core/src/data/miner.rs
|
||||
index 38c7f3be..660850f4 100644
|
||||
--- a/vendor/asic-rs-core/src/data/miner.rs
|
||||
+++ b/vendor/asic-rs-core/src/data/miner.rs
|
||||
@@ -17,6 +17,7 @@ use super::{
|
||||
operating_state::OperatingState,
|
||||
pool::PoolGroupData,
|
||||
psu::PsuInfo,
|
||||
+ share::ShareSummary,
|
||||
};
|
||||
use crate::data::{
|
||||
deserialize::deserialize_macaddr,
|
||||
@@ -237,6 +238,9 @@ pub struct MinerData {
|
||||
/// Difficulty of the best share found since the last boot or hashing start,
|
||||
/// when the firmware distinguishes session from all-time.
|
||||
pub session_best_share: Option<f64>,
|
||||
+ /// Cumulative share statistics (difficulty accepted/rejected, stale, blocks),
|
||||
+ /// when reported. Miner-level aggregate from the cgminer/btminer summary.
|
||||
+ pub share_summary: Option<ShareSummary>,
|
||||
}
|
||||
|
||||
#[cfg(feature = "python")]
|
||||
diff --git a/vendor/asic-rs-core/src/data/share.rs b/vendor/asic-rs-core/src/data/share.rs
|
||||
index 3cc50651..73b0a0a8 100644
|
||||
--- a/vendor/asic-rs-core/src/data/share.rs
|
||||
+++ b/vendor/asic-rs-core/src/data/share.rs
|
||||
@@ -3,7 +3,61 @@
|
||||
//! Firmwares report best-share difficulty as a JSON number, a decimal string,
|
||||
//! or an AxeOS-style suffix string (`"483k"`, `"1.2M"`).
|
||||
|
||||
+#[cfg(feature = "python")]
|
||||
+use pyo3::pyclass;
|
||||
+use serde::{Deserialize, Serialize};
|
||||
use serde_json::Value;
|
||||
+use ts_rs::TS;
|
||||
+
|
||||
+/// Cumulative share statistics reported by a miner (round 19 #10, T2).
|
||||
+///
|
||||
+/// These are miner-level aggregates from the cgminer/btminer summary. Difficulty
|
||||
+/// values are difficulty-weighted sums (not raw share counts, which live on
|
||||
+/// [`PoolData`][`super::pool::PoolData`]). Every field is optional; a backend
|
||||
+/// fills in only what its firmware exposes.
|
||||
+#[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 ShareSummary {
|
||||
+ /// Difficulty-weighted accepted work, when reported.
|
||||
+ pub difficulty_accepted: Option<f64>,
|
||||
+ /// Difficulty-weighted rejected work, when reported.
|
||||
+ pub difficulty_rejected: Option<f64>,
|
||||
+ /// Raw stale share count, when reported.
|
||||
+ pub stale_shares: Option<u64>,
|
||||
+ /// Number of blocks found by this miner, when reported.
|
||||
+ pub found_blocks: Option<u64>,
|
||||
+}
|
||||
+
|
||||
+impl ShareSummary {
|
||||
+ /// True when no field is populated.
|
||||
+ pub fn is_empty(&self) -> bool {
|
||||
+ self.difficulty_accepted.is_none()
|
||||
+ && self.difficulty_rejected.is_none()
|
||||
+ && self.stale_shares.is_none()
|
||||
+ && self.found_blocks.is_none()
|
||||
+ }
|
||||
+}
|
||||
+
|
||||
+/// Parse a [`ShareSummary`] from a cgminer/btminer `SUMMARY[0]` object (the value
|
||||
+/// extracted at `/SUMMARY/0`). Reads "Difficulty Accepted", "Difficulty Rejected",
|
||||
+/// "Stale", and "Found Blocks". Returns `None` when none are present.
|
||||
+pub fn parse_cgminer_share_summary(summary: &Value) -> Option<ShareSummary> {
|
||||
+ let f = |k: &str| {
|
||||
+ summary
|
||||
+ .get(k)
|
||||
+ .and_then(|v| v.as_f64())
|
||||
+ .filter(|v| v.is_finite() && *v >= 0.0)
|
||||
+ };
|
||||
+ let u = |k: &str| summary.get(k).and_then(|v| v.as_u64());
|
||||
+ let s = ShareSummary {
|
||||
+ difficulty_accepted: f("Difficulty Accepted"),
|
||||
+ difficulty_rejected: f("Difficulty Rejected"),
|
||||
+ stale_shares: u("Stale"),
|
||||
+ found_blocks: u("Found Blocks"),
|
||||
+ };
|
||||
+ (!s.is_empty()).then_some(s)
|
||||
+}
|
||||
|
||||
/// Parse a share difficulty from a JSON value.
|
||||
///
|
||||
diff --git a/vendor/asic-rs-core/src/traits/miner.rs b/vendor/asic-rs-core/src/traits/miner.rs
|
||||
index cfabb624..76344342 100644
|
||||
--- a/vendor/asic-rs-core/src/traits/miner.rs
|
||||
+++ b/vendor/asic-rs-core/src/traits/miner.rs
|
||||
@@ -34,6 +34,7 @@ use crate::{
|
||||
operating_state::OperatingState,
|
||||
pool::PoolGroupData,
|
||||
psu::PsuInfo,
|
||||
+ share::ShareSummary,
|
||||
},
|
||||
traits::firmware::MinerFirmware,
|
||||
traits::model::MinerModel,
|
||||
@@ -291,6 +292,7 @@ impl<
|
||||
let pools = self.parse_pools(&data);
|
||||
let best_share = self.parse_best_share(&data);
|
||||
let session_best_share = self.parse_session_best_share(&data);
|
||||
+ let share_summary = self.parse_share_summary(&data);
|
||||
let device_info = self.get_device_info();
|
||||
|
||||
// computed fields
|
||||
@@ -388,6 +390,7 @@ impl<
|
||||
pools,
|
||||
best_share,
|
||||
session_best_share,
|
||||
+ share_summary,
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -914,6 +917,18 @@ pub trait GetBestShare: CollectData {
|
||||
fn parse_best_share(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
|
||||
None
|
||||
}
|
||||
+ #[tracing::instrument(level = "debug")]
|
||||
+ async fn get_share_summary(&self) -> Option<ShareSummary> {
|
||||
+ let mut collector = self.get_collector();
|
||||
+ let data = collector.collect(&[DataField::ShareSummary]).await;
|
||||
+ self.parse_share_summary(&data)
|
||||
+ }
|
||||
+ /// Cumulative share statistics (difficulty accepted/rejected, stale, blocks).
|
||||
+ /// Backends that expose them override this; others return None.
|
||||
+ #[allow(unused_variables)]
|
||||
+ fn parse_share_summary(&self, data: &HashMap<DataField, Value>) -> Option<ShareSummary> {
|
||||
+ None
|
||||
+ }
|
||||
}
|
||||
|
||||
// Best share difficulty (this session / since boot)
|
||||
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 63f819f8..71195737 100644
|
||||
--- a/vendor/asic-rs-firmwares-antminer/src/backends/v2020/mod.rs
|
||||
+++ b/vendor/asic-rs-firmwares-antminer/src/backends/v2020/mod.rs
|
||||
@@ -21,6 +21,7 @@ use asic_rs_core::{
|
||||
message::{MessageSeverity, MinerMessage},
|
||||
miner::{MiningMode, TuningTarget},
|
||||
pool::{PoolData, PoolGroupData, PoolURL},
|
||||
+ share::{ShareSummary, parse_cgminer_share_summary},
|
||||
},
|
||||
traits::{miner::*, model::MinerModel},
|
||||
};
|
||||
@@ -509,6 +510,16 @@ impl GetDataLocations for AntMinerV2020 {
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
+ // Cumulative share stats from cgminer summary (round 19 #10, T2);
|
||||
+ // RPC_SUMMARY already fetched.
|
||||
+ DataField::ShareSummary => vec![(
|
||||
+ RPC_SUMMARY,
|
||||
+ DataExtractor {
|
||||
+ func: get_by_pointer,
|
||||
+ key: Some("/SUMMARY/0"),
|
||||
+ tag: None,
|
||||
+ },
|
||||
+ )],
|
||||
// `total_rateideal`, by contrast, says nothing about its own
|
||||
// scale, so carry STATS' `rate_unit` alongside it.
|
||||
DataField::ExpectedHashrate => vec![
|
||||
@@ -889,6 +900,10 @@ impl GetBestShare for AntMinerV2020 {
|
||||
// (round 19 #10).
|
||||
data.extract::<f64>(DataField::BestShare).filter(|&v| v > 0.0)
|
||||
}
|
||||
+ fn parse_share_summary(&self, data: &HashMap<DataField, Value>) -> Option<ShareSummary> {
|
||||
+ data.get(&DataField::ShareSummary)
|
||||
+ .and_then(parse_cgminer_share_summary)
|
||||
+ }
|
||||
}
|
||||
impl GetSessionBestShare for AntMinerV2020 {}
|
||||
|
||||
@@ -1679,6 +1694,12 @@ mod tests {
|
||||
algo: HashAlgorithm::SHA256,
|
||||
}
|
||||
);
|
||||
+ // Cumulative share stats from cgminer summary (round 19 #10, T2).
|
||||
+ let shares = miner_data.share_summary.expect("share summary");
|
||||
+ assert_eq!(shares.difficulty_accepted, Some(1305083904.0));
|
||||
+ assert_eq!(shares.difficulty_rejected, Some(2490368.0));
|
||||
+ assert_eq!(shares.stale_shares, Some(1));
|
||||
+ assert_eq!(shares.found_blocks, Some(0));
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
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 1ac2bad1..58e8a5c2 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
|
||||
@@ -23,6 +23,7 @@ use asic_rs_core::{
|
||||
message::{MessageSeverity, MinerMessage},
|
||||
miner::{MiningMode, TuningTarget},
|
||||
pool::{PoolData, PoolGroupData, PoolURL},
|
||||
+ share::{ShareSummary, parse_cgminer_share_summary},
|
||||
},
|
||||
traits::{miner::*, model::MinerModel},
|
||||
};
|
||||
@@ -547,6 +548,16 @@ impl GetDataLocations for AntMinerV202307 {
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
+ // Cumulative share stats from cgminer summary (round 19 #10, T2);
|
||||
+ // RPC_SUMMARY already fetched.
|
||||
+ DataField::ShareSummary => vec![(
|
||||
+ RPC_SUMMARY,
|
||||
+ DataExtractor {
|
||||
+ func: get_by_pointer,
|
||||
+ key: Some("/SUMMARY/0"),
|
||||
+ tag: None,
|
||||
+ },
|
||||
+ )],
|
||||
DataField::SessionBestShare => vec![(
|
||||
RPC_SUMMARY,
|
||||
DataExtractor {
|
||||
@@ -955,6 +966,10 @@ impl GetBestShare for AntMinerV202307 {
|
||||
// reports 0 when it has never found a share (round 17 R7).
|
||||
data.extract::<f64>(DataField::BestShare).filter(|&v| v > 0.0)
|
||||
}
|
||||
+ fn parse_share_summary(&self, data: &HashMap<DataField, Value>) -> Option<ShareSummary> {
|
||||
+ data.get(&DataField::ShareSummary)
|
||||
+ .and_then(parse_cgminer_share_summary)
|
||||
+ }
|
||||
}
|
||||
|
||||
impl GetSessionBestShare for AntMinerV202307 {
|
||||
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 a75a3f97..413f237a 100644
|
||||
--- a/vendor/asic-rs-firmwares-luxminer/src/backends/v1/mod.rs
|
||||
+++ b/vendor/asic-rs-firmwares-luxminer/src/backends/v1/mod.rs
|
||||
@@ -20,6 +20,7 @@ use asic_rs_core::{
|
||||
message::{MessageSeverity, MinerMessage},
|
||||
miner::TuningTarget,
|
||||
pool::{PoolData, PoolGroupData, PoolURL},
|
||||
+ share::{ShareSummary, parse_cgminer_share_summary},
|
||||
},
|
||||
traits::{miner::*, model::MinerModel},
|
||||
};
|
||||
@@ -455,6 +456,16 @@ impl GetDataLocations for LuxMinerV1 {
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
+ // Cumulative share stats from LuxOS summary (round 19 #10, T2);
|
||||
+ // RPC_SUMMARY already fetched.
|
||||
+ DataField::ShareSummary => vec![(
|
||||
+ RPC_SUMMARY,
|
||||
+ DataExtractor {
|
||||
+ func: get_by_pointer,
|
||||
+ key: Some("/SUMMARY/0"),
|
||||
+ tag: None,
|
||||
+ },
|
||||
+ )],
|
||||
DataField::SessionBestShare => vec![(
|
||||
RPC_SUMMARY,
|
||||
DataExtractor {
|
||||
@@ -945,6 +956,10 @@ impl GetBestShare for LuxMinerV1 {
|
||||
// LuxOS summary -> "Best Share" (all-time), round 16 / G9.
|
||||
data.extract::<f64>(DataField::BestShare)
|
||||
}
|
||||
+ fn parse_share_summary(&self, data: &HashMap<DataField, Value>) -> Option<ShareSummary> {
|
||||
+ data.get(&DataField::ShareSummary)
|
||||
+ .and_then(parse_cgminer_share_summary)
|
||||
+ }
|
||||
}
|
||||
impl GetSessionBestShare for LuxMinerV1 {
|
||||
fn parse_session_best_share(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
|
||||
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 584ae8d1..aacd1077 100644
|
||||
--- a/vendor/asic-rs-firmwares-whatsminer/src/backends/v1/mod.rs
|
||||
+++ b/vendor/asic-rs-firmwares-whatsminer/src/backends/v1/mod.rs
|
||||
@@ -19,6 +19,7 @@ use asic_rs_core::{
|
||||
miner::TuningTarget,
|
||||
pool::{PoolData, PoolGroupData, PoolURL},
|
||||
psu::PsuInfo,
|
||||
+ share::{ShareSummary, parse_cgminer_share_summary},
|
||||
},
|
||||
traits::{miner::*, model::MinerModel},
|
||||
};
|
||||
@@ -264,6 +265,16 @@ impl GetDataLocations for WhatsMinerV1 {
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
+ // Cumulative share stats from btminer summary (round 19 #10, T2);
|
||||
+ // RPC_SUMMARY already fetched.
|
||||
+ DataField::ShareSummary => vec![(
|
||||
+ RPC_SUMMARY,
|
||||
+ DataExtractor {
|
||||
+ func: get_by_pointer,
|
||||
+ key: Some("/SUMMARY/0"),
|
||||
+ tag: None,
|
||||
+ },
|
||||
+ )],
|
||||
DataField::ExpectedHashrate => vec![(
|
||||
RPC_SUMMARY,
|
||||
DataExtractor {
|
||||
@@ -597,6 +608,10 @@ impl GetBestShare for WhatsMinerV1 {
|
||||
fn parse_best_share(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
|
||||
data.extract::<f64>(DataField::BestShare).filter(|&v| v > 0.0)
|
||||
}
|
||||
+ fn parse_share_summary(&self, data: &HashMap<DataField, Value>) -> Option<ShareSummary> {
|
||||
+ data.get(&DataField::ShareSummary)
|
||||
+ .and_then(parse_cgminer_share_summary)
|
||||
+ }
|
||||
}
|
||||
impl GetSessionBestShare for WhatsMinerV1 {}
|
||||
impl GetOperatingState for WhatsMinerV1 {}
|
||||
@@ -969,6 +984,14 @@ mod integration_tests {
|
||||
assert_eq!(hr.unit, HashRateUnit::TeraHash);
|
||||
assert!((hr.value - 67.43935249).abs() < 1e-6);
|
||||
}
|
||||
+ // Cumulative share stats from summary (round 19 #10, T2).
|
||||
+ let shares = miner_data
|
||||
+ .share_summary
|
||||
+ .ok_or_else(|| anyhow::anyhow!("v1 should expose share summary"))?;
|
||||
+ assert_eq!(shares.difficulty_accepted, Some(158334976.0));
|
||||
+ assert_eq!(shares.difficulty_rejected, Some(0.0));
|
||||
+ assert_eq!(shares.stale_shares, Some(0));
|
||||
+ assert_eq!(shares.found_blocks, Some(0));
|
||||
assert_eq!(miner_data.wattage, Some(Power::from_watts(3417f64)));
|
||||
assert_eq!(
|
||||
miner_data.tuning_target,
|
||||
diff --git a/vendor/asic-rs-firmwares-whatsminer/src/backends/v2/mod.rs b/vendor/asic-rs-firmwares-whatsminer/src/backends/v2/mod.rs
|
||||
index 5de37579..4cfcee19 100644
|
||||
--- a/vendor/asic-rs-firmwares-whatsminer/src/backends/v2/mod.rs
|
||||
+++ b/vendor/asic-rs-firmwares-whatsminer/src/backends/v2/mod.rs
|
||||
@@ -21,6 +21,7 @@ use asic_rs_core::{
|
||||
miner::{MiningMode, TuningTarget},
|
||||
pool::{PoolData, PoolGroupData, PoolURL},
|
||||
psu::PsuInfo,
|
||||
+ share::{ShareSummary, parse_cgminer_share_summary},
|
||||
},
|
||||
traits::{miner::*, model::MinerModel},
|
||||
util::is_expected_write_error,
|
||||
@@ -265,6 +266,16 @@ impl GetDataLocations for WhatsMinerV2 {
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
+ // Cumulative share stats from btminer summary (round 19 #10, T2);
|
||||
+ // RPC_SUMMARY already fetched.
|
||||
+ DataField::ShareSummary => vec![(
|
||||
+ RPC_SUMMARY,
|
||||
+ DataExtractor {
|
||||
+ func: get_by_pointer,
|
||||
+ key: Some("/SUMMARY/0"),
|
||||
+ tag: None,
|
||||
+ },
|
||||
+ )],
|
||||
DataField::ExpectedHashrate => vec![(
|
||||
RPC_SUMMARY,
|
||||
DataExtractor {
|
||||
@@ -592,6 +603,10 @@ impl GetBestShare for WhatsMinerV2 {
|
||||
fn parse_best_share(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
|
||||
data.extract::<f64>(DataField::BestShare).filter(|&v| v > 0.0)
|
||||
}
|
||||
+ fn parse_share_summary(&self, data: &HashMap<DataField, Value>) -> Option<ShareSummary> {
|
||||
+ data.get(&DataField::ShareSummary)
|
||||
+ .and_then(parse_cgminer_share_summary)
|
||||
+ }
|
||||
}
|
||||
impl GetSessionBestShare for WhatsMinerV2 {}
|
||||
impl GetOperatingState for WhatsMinerV2 {}
|
||||
@@ -0,0 +1,267 @@
|
||||
Subject: [PATCH 0027] telemetry: miner-level fan duty cycle (fan speed %)
|
||||
|
||||
Round 19 #10 / #8 telemetry extension, tier 3. Exposes the fan duty cycle as a
|
||||
miner-level percentage. No firmware exposes a maximum fan RPM, so this normalized
|
||||
duty cycle is the fan-load indicator the GUI wanted alongside the per-fan RPMs.
|
||||
|
||||
- New DataField::FanSpeedPercent; MinerData gains fan_speed_percent (Option<f64>,
|
||||
0-100). Modeled as a top-level miner-level value (most firmwares report a single
|
||||
duty), so FanData is untouched (no Eq/literal churn across 17 crates).
|
||||
- Rides the EXISTING GetFans trait via a defaulted parse_fan_speed_percent method
|
||||
(default None), so no new supertrait bound; only backends that expose it override.
|
||||
- Backends (each reads a command the collector already fetches, so no extra
|
||||
round-trips): ePIC (summary /Fans/Fans Speed, single %), LuxOS (max of FANS[].Speed),
|
||||
Braiins v25_07 + v26_04 (max of cooling fans[].target_speed_ratio x 100). Antminer
|
||||
(pwm via config command) and VNish (fan_duty) have no data fixtures and are left
|
||||
for a live-verified pass; WhatsMiner is fw-locked -> None.
|
||||
|
||||
Fixture tests for epic, luxminer, and braiins v26_04 assert the parsed percentage.
|
||||
|
||||
diff --git a/vendor/asic-rs-core/src/data/collector.rs b/vendor/asic-rs-core/src/data/collector.rs
|
||||
index 942b39f6..07d9d571 100644
|
||||
--- a/vendor/asic-rs-core/src/data/collector.rs
|
||||
+++ b/vendor/asic-rs-core/src/data/collector.rs
|
||||
@@ -62,6 +62,9 @@ pub enum DataField {
|
||||
/// Fan speed or fan configuration.
|
||||
#[cfg_attr(feature = "python", pydantic(value = "Fans"))]
|
||||
Fans,
|
||||
+ /// Miner-level fan duty cycle as a percentage (0-100).
|
||||
+ #[cfg_attr(feature = "python", pydantic(value = "FanSpeedPercent"))]
|
||||
+ FanSpeedPercent,
|
||||
/// PSU fan speed or configuration.
|
||||
#[cfg_attr(feature = "python", pydantic(value = "PsuFans"))]
|
||||
PsuFans,
|
||||
diff --git a/vendor/asic-rs-core/src/data/miner.rs b/vendor/asic-rs-core/src/data/miner.rs
|
||||
index 660850f4..6dc73d26 100644
|
||||
--- a/vendor/asic-rs-core/src/data/miner.rs
|
||||
+++ b/vendor/asic-rs-core/src/data/miner.rs
|
||||
@@ -178,6 +178,9 @@ pub struct MinerData {
|
||||
pub expected_fans: Option<u8>,
|
||||
/// The current fan information for the miner
|
||||
pub fans: Vec<FanData>,
|
||||
+ /// Miner-level fan duty cycle as a percentage (0-100), when reported. Firmware
|
||||
+ /// exposes no maximum RPM, so this duty cycle is the normalized fan indicator.
|
||||
+ pub fan_speed_percent: Option<f64>,
|
||||
/// The current PDU fan information for the miner
|
||||
pub psu_fans: Vec<FanData>,
|
||||
/// The average temperature across all chips in the miner
|
||||
diff --git a/vendor/asic-rs-core/src/traits/miner.rs b/vendor/asic-rs-core/src/traits/miner.rs
|
||||
index 76344342..baac9387 100644
|
||||
--- a/vendor/asic-rs-core/src/traits/miner.rs
|
||||
+++ b/vendor/asic-rs-core/src/traits/miner.rs
|
||||
@@ -283,6 +283,7 @@ impl<
|
||||
let fluid_temperature = self.parse_fluid_temperature(&data);
|
||||
let outlet_fluid_temperature = self.parse_outlet_fluid_temperature(&data);
|
||||
let fans = self.parse_fans(&data);
|
||||
+ let fan_speed_percent = self.parse_fan_speed_percent(&data);
|
||||
let psu_fans = self.parse_psu_fans(&data);
|
||||
let hashboards = self.parse_hashboards(&data);
|
||||
let light_flashing = self.parse_light_flashing(&data);
|
||||
@@ -366,6 +367,7 @@ impl<
|
||||
// Cooling information
|
||||
expected_fans: device_info.hardware.fans,
|
||||
fans,
|
||||
+ fan_speed_percent,
|
||||
psu_fans,
|
||||
average_temperature,
|
||||
fluid_temperature,
|
||||
@@ -682,6 +684,18 @@ pub trait GetFans: CollectData {
|
||||
fn parse_fans(&self, data: &HashMap<DataField, Value>) -> Vec<FanData> {
|
||||
vec![]
|
||||
}
|
||||
+ #[tracing::instrument(level = "debug")]
|
||||
+ async fn get_fan_speed_percent(&self) -> Option<f64> {
|
||||
+ let mut collector = self.get_collector();
|
||||
+ let data = collector.collect(&[DataField::FanSpeedPercent]).await;
|
||||
+ self.parse_fan_speed_percent(&data)
|
||||
+ }
|
||||
+ /// Miner-level fan duty cycle as a percentage (0-100). Backends that expose it
|
||||
+ /// override this; others return None.
|
||||
+ #[allow(unused_variables)]
|
||||
+ fn parse_fan_speed_percent(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
|
||||
+ None
|
||||
+ }
|
||||
}
|
||||
|
||||
// PSU Fans
|
||||
diff --git a/vendor/asic-rs-firmwares-braiins/src/backends/v25_07/mod.rs b/vendor/asic-rs-firmwares-braiins/src/backends/v25_07/mod.rs
|
||||
index 7e07967f..86e84d8c 100644
|
||||
--- a/vendor/asic-rs-firmwares-braiins/src/backends/v25_07/mod.rs
|
||||
+++ b/vendor/asic-rs-firmwares-braiins/src/backends/v25_07/mod.rs
|
||||
@@ -230,6 +230,16 @@ impl GetDataLocations for BraiinsV2507 {
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
+ // Miner-level fan duty cycle (round 19 #10, T3): max target_speed_ratio;
|
||||
+ // cooling state already fetched.
|
||||
+ DataField::FanSpeedPercent => vec![(
|
||||
+ WEB_COOLING_STATE,
|
||||
+ DataExtractor {
|
||||
+ func: get_by_pointer,
|
||||
+ key: Some("/fans"),
|
||||
+ tag: None,
|
||||
+ },
|
||||
+ )],
|
||||
DataField::Hashboards => vec![(
|
||||
WEB_HASHBOARDS,
|
||||
DataExtractor {
|
||||
@@ -567,6 +577,18 @@ impl GetFans for BraiinsV2507 {
|
||||
|
||||
fans
|
||||
}
|
||||
+ fn parse_fan_speed_percent(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
|
||||
+ // Braiins fans[].target_speed_ratio is a 0-1 duty ratio; report the max as
|
||||
+ // a percentage (round 19 #10, T3).
|
||||
+ data.get(&DataField::FanSpeedPercent)
|
||||
+ .and_then(|v| v.as_array())
|
||||
+ .into_iter()
|
||||
+ .flatten()
|
||||
+ .filter_map(|f| f.pointer("/target_speed_ratio").and_then(|v| v.as_f64()))
|
||||
+ .filter(|v| v.is_finite() && *v >= 0.0)
|
||||
+ .map(|v| v * 100.0)
|
||||
+ .max_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal))
|
||||
+ }
|
||||
}
|
||||
|
||||
impl GetLightFlashing for BraiinsV2507 {
|
||||
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 2f5be88c..303fca49 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
|
||||
@@ -233,6 +233,16 @@ impl GetDataLocations for BraiinsV2604 {
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
+ // Miner-level fan duty cycle (round 19 #10, T3): max target_speed_ratio;
|
||||
+ // cooling state already fetched.
|
||||
+ DataField::FanSpeedPercent => vec![(
|
||||
+ WEB_COOLING_STATE,
|
||||
+ DataExtractor {
|
||||
+ func: get_by_pointer,
|
||||
+ key: Some("/fans"),
|
||||
+ tag: None,
|
||||
+ },
|
||||
+ )],
|
||||
DataField::Hashboards => vec![(
|
||||
WEB_HASHBOARDS,
|
||||
DataExtractor {
|
||||
@@ -598,6 +608,18 @@ impl GetFans for BraiinsV2604 {
|
||||
|
||||
fans
|
||||
}
|
||||
+ fn parse_fan_speed_percent(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
|
||||
+ // Braiins fans[].target_speed_ratio is a 0-1 duty ratio; report the max as
|
||||
+ // a percentage (round 19 #10, T3).
|
||||
+ data.get(&DataField::FanSpeedPercent)
|
||||
+ .and_then(|v| v.as_array())
|
||||
+ .into_iter()
|
||||
+ .flatten()
|
||||
+ .filter_map(|f| f.pointer("/target_speed_ratio").and_then(|v| v.as_f64()))
|
||||
+ .filter(|v| v.is_finite() && *v >= 0.0)
|
||||
+ .map(|v| v * 100.0)
|
||||
+ .max_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal))
|
||||
+ }
|
||||
}
|
||||
|
||||
impl GetLightFlashing for BraiinsV2604 {
|
||||
@@ -1287,6 +1309,10 @@ mod tests {
|
||||
assert_eq!(hr.unit, HashRateUnit::TeraHash);
|
||||
assert!((hr.value - 247.3507543407177).abs() < 1e-3);
|
||||
}
|
||||
+ // Miner-level fan duty cycle = max target_speed_ratio (0.92) x 100 (round
|
||||
+ // 19 #10, T3).
|
||||
+ let fan_pct = miner_data.fan_speed_percent.expect("braiins fan duty");
|
||||
+ assert!((fan_pct - 92.0).abs() < 1e-6);
|
||||
}
|
||||
|
||||
#[test]
|
||||
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 2abb0706..16c7872b 100644
|
||||
--- a/vendor/asic-rs-firmwares-epic/src/backends/v1/mod.rs
|
||||
+++ b/vendor/asic-rs-firmwares-epic/src/backends/v1/mod.rs
|
||||
@@ -473,6 +473,15 @@ impl GetDataLocations for PowerPlayV1 {
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
+ // Miner-level fan duty cycle (round 19 #10, T3); summary already fetched.
|
||||
+ DataField::FanSpeedPercent => vec![(
|
||||
+ WEB_SUMMARY,
|
||||
+ DataExtractor {
|
||||
+ func: get_by_pointer,
|
||||
+ key: Some("/Fans/Fans Speed"),
|
||||
+ tag: None,
|
||||
+ },
|
||||
+ )],
|
||||
DataField::Hashboards => vec![
|
||||
(
|
||||
WEB_TEMPS,
|
||||
@@ -1120,6 +1129,11 @@ impl GetFans for PowerPlayV1 {
|
||||
|
||||
fans
|
||||
}
|
||||
+ fn parse_fan_speed_percent(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
|
||||
+ // ePIC summary /Fans/Fans Speed is a single miner-level duty % (round 19 #10).
|
||||
+ data.extract::<f64>(DataField::FanSpeedPercent)
|
||||
+ .filter(|v| v.is_finite() && *v >= 0.0)
|
||||
+ }
|
||||
}
|
||||
|
||||
impl GetPsuFans for PowerPlayV1 {}
|
||||
@@ -2189,6 +2203,8 @@ mod tests {
|
||||
|
||||
assert_eq!(miner_data.uptime, Some(Duration::from_secs(23170)));
|
||||
assert_eq!(miner_data.wattage, Some(Power::from_watts(2166.6174)));
|
||||
+ // Miner-level fan duty cycle from summary /Fans/Fans Speed (round 19 #10, T3).
|
||||
+ assert_eq!(miner_data.fan_speed_percent, Some(100.0));
|
||||
assert_eq!(miner_data.hashboards.len(), 3);
|
||||
assert_eq!(miner_data.hashboards[0].active, Some(false));
|
||||
assert_eq!(miner_data.hashboards[1].chips.len(), 110);
|
||||
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 413f237a..edab7c4c 100644
|
||||
--- a/vendor/asic-rs-firmwares-luxminer/src/backends/v1/mod.rs
|
||||
+++ b/vendor/asic-rs-firmwares-luxminer/src/backends/v1/mod.rs
|
||||
@@ -295,6 +295,16 @@ impl GetDataLocations for LuxMinerV1 {
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
+ // Miner-level fan duty cycle (round 19 #10, T3): max of per-fan Speed;
|
||||
+ // RPC_FANS already fetched.
|
||||
+ DataField::FanSpeedPercent => vec![(
|
||||
+ RPC_FANS,
|
||||
+ DataExtractor {
|
||||
+ func: get_by_pointer,
|
||||
+ key: Some("/FANS"),
|
||||
+ tag: None,
|
||||
+ },
|
||||
+ )],
|
||||
DataField::ApiVersion => vec![(
|
||||
RPC_VERSION,
|
||||
DataExtractor {
|
||||
@@ -936,6 +946,17 @@ impl GetFans for LuxMinerV1 {
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
+ fn parse_fan_speed_percent(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
|
||||
+ // LuxOS FANS[].Speed is per-fan duty %; report the fleet-facing maximum
|
||||
+ // (round 19 #10, T3).
|
||||
+ data.get(&DataField::FanSpeedPercent)
|
||||
+ .and_then(|v| v.as_array())
|
||||
+ .into_iter()
|
||||
+ .flatten()
|
||||
+ .filter_map(|f| f.get("Speed").and_then(|v| v.as_f64()))
|
||||
+ .filter(|v| v.is_finite() && *v >= 0.0)
|
||||
+ .max_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal))
|
||||
+ }
|
||||
}
|
||||
|
||||
impl GetLightFlashing for LuxMinerV1 {
|
||||
@@ -1680,6 +1701,9 @@ mod tests {
|
||||
Some(TuningTarget::Power(Power::from_watts(1188f64)))
|
||||
);
|
||||
assert_eq!(miner_data.fans.len(), 4);
|
||||
+ // Miner-level fan duty cycle = max of per-fan Speed (all 20 here); round 19
|
||||
+ // #10, T3.
|
||||
+ assert_eq!(miner_data.fan_speed_percent, Some(20.0));
|
||||
assert_eq!(miner_data.hashboards[0].chips.len(), 77);
|
||||
assert_eq!(miner_data.pools.len(), 2);
|
||||
assert_eq!(miner_data.pools[0].len(), 2);
|
||||
@@ -0,0 +1,136 @@
|
||||
Subject: [PATCH 0028] telemetry: board temperature thresholds (critical / shutdown)
|
||||
|
||||
Round 19 #10 telemetry extension, tier 3. Exposes the board temperature safety
|
||||
thresholds ("board dangerous temp" from item #10).
|
||||
|
||||
- New DataField::TemperatureLimits; MinerData gains temp_critical and temp_shutdown
|
||||
(Celsius). Rides the EXISTING GetFluidTemperature trait via a defaulted
|
||||
parse_temperature_limits method returning (critical, shutdown), so no new
|
||||
supertrait bound; only backends that expose the thresholds override it.
|
||||
- ePIC: summary /Misc Critical Temp + Shutdown Temp (already-fetched summary).
|
||||
Antminer/WhatsMiner do not expose thresholds; LuxOS needs an unwired tempctrl
|
||||
command (no fixture) and VNish/Braiins need live verification -> left for a
|
||||
live-verified pass, all inherit (None, None).
|
||||
|
||||
Fixture test for epic asserts the parsed thresholds.
|
||||
|
||||
diff --git a/vendor/asic-rs-core/src/data/collector.rs b/vendor/asic-rs-core/src/data/collector.rs
|
||||
index 07d9d571..1e6e7e9d 100644
|
||||
--- a/vendor/asic-rs-core/src/data/collector.rs
|
||||
+++ b/vendor/asic-rs-core/src/data/collector.rs
|
||||
@@ -65,6 +65,9 @@ pub enum DataField {
|
||||
/// Miner-level fan duty cycle as a percentage (0-100).
|
||||
#[cfg_attr(feature = "python", pydantic(value = "FanSpeedPercent"))]
|
||||
FanSpeedPercent,
|
||||
+ /// Board temperature safety thresholds (critical / shutdown), in Celsius.
|
||||
+ #[cfg_attr(feature = "python", pydantic(value = "TemperatureLimits"))]
|
||||
+ TemperatureLimits,
|
||||
/// PSU fan speed or configuration.
|
||||
#[cfg_attr(feature = "python", pydantic(value = "PsuFans"))]
|
||||
PsuFans,
|
||||
diff --git a/vendor/asic-rs-core/src/data/miner.rs b/vendor/asic-rs-core/src/data/miner.rs
|
||||
index 6dc73d26..08782856 100644
|
||||
--- a/vendor/asic-rs-core/src/data/miner.rs
|
||||
+++ b/vendor/asic-rs-core/src/data/miner.rs
|
||||
@@ -181,6 +181,10 @@ pub struct MinerData {
|
||||
/// Miner-level fan duty cycle as a percentage (0-100), when reported. Firmware
|
||||
/// exposes no maximum RPM, so this duty cycle is the normalized fan indicator.
|
||||
pub fan_speed_percent: Option<f64>,
|
||||
+ /// Board critical temperature threshold in Celsius, when reported (round 19 #10).
|
||||
+ pub temp_critical: Option<f64>,
|
||||
+ /// Board shutdown temperature threshold in Celsius, when reported (round 19 #10).
|
||||
+ pub temp_shutdown: Option<f64>,
|
||||
/// The current PDU fan information for the miner
|
||||
pub psu_fans: Vec<FanData>,
|
||||
/// The average temperature across all chips in the miner
|
||||
diff --git a/vendor/asic-rs-core/src/traits/miner.rs b/vendor/asic-rs-core/src/traits/miner.rs
|
||||
index baac9387..9de51761 100644
|
||||
--- a/vendor/asic-rs-core/src/traits/miner.rs
|
||||
+++ b/vendor/asic-rs-core/src/traits/miner.rs
|
||||
@@ -282,6 +282,7 @@ impl<
|
||||
let tuning_capabilities = self.parse_tuning_capabilities(&data);
|
||||
let fluid_temperature = self.parse_fluid_temperature(&data);
|
||||
let outlet_fluid_temperature = self.parse_outlet_fluid_temperature(&data);
|
||||
+ let (temp_critical, temp_shutdown) = self.parse_temperature_limits(&data);
|
||||
let fans = self.parse_fans(&data);
|
||||
let fan_speed_percent = self.parse_fan_speed_percent(&data);
|
||||
let psu_fans = self.parse_psu_fans(&data);
|
||||
@@ -368,6 +369,8 @@ impl<
|
||||
expected_fans: device_info.hardware.fans,
|
||||
fans,
|
||||
fan_speed_percent,
|
||||
+ temp_critical,
|
||||
+ temp_shutdown,
|
||||
psu_fans,
|
||||
average_temperature,
|
||||
fluid_temperature,
|
||||
@@ -741,6 +744,15 @@ pub trait GetFluidTemperature: CollectData {
|
||||
) -> Option<Temperature> {
|
||||
None
|
||||
}
|
||||
+ /// Board temperature safety thresholds as (critical, shutdown) in Celsius.
|
||||
+ /// Backends that expose them override this; others return (None, None).
|
||||
+ #[allow(unused_variables)]
|
||||
+ fn parse_temperature_limits(
|
||||
+ &self,
|
||||
+ data: &HashMap<DataField, Value>,
|
||||
+ ) -> (Option<f64>, Option<f64>) {
|
||||
+ (None, None)
|
||||
+ }
|
||||
}
|
||||
|
||||
// Wattage
|
||||
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 16c7872b..0c9a851b 100644
|
||||
--- a/vendor/asic-rs-firmwares-epic/src/backends/v1/mod.rs
|
||||
+++ b/vendor/asic-rs-firmwares-epic/src/backends/v1/mod.rs
|
||||
@@ -482,6 +482,16 @@ impl GetDataLocations for PowerPlayV1 {
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
+ // Board temperature thresholds (round 19 #10, T3); summary /Misc carries
|
||||
+ // Critical Temp and Shutdown Temp. Already fetched.
|
||||
+ DataField::TemperatureLimits => vec![(
|
||||
+ WEB_SUMMARY,
|
||||
+ DataExtractor {
|
||||
+ func: get_by_pointer,
|
||||
+ key: Some("/Misc"),
|
||||
+ tag: None,
|
||||
+ },
|
||||
+ )],
|
||||
DataField::Hashboards => vec![
|
||||
(
|
||||
WEB_TEMPS,
|
||||
@@ -1139,7 +1149,21 @@ impl GetFans for PowerPlayV1 {
|
||||
impl GetPsuFans for PowerPlayV1 {}
|
||||
impl GetTuningCapabilities for PowerPlayV1 {}
|
||||
|
||||
-impl GetFluidTemperature for PowerPlayV1 {}
|
||||
+impl GetFluidTemperature for PowerPlayV1 {
|
||||
+ fn parse_temperature_limits(
|
||||
+ &self,
|
||||
+ data: &HashMap<DataField, Value>,
|
||||
+ ) -> (Option<f64>, Option<f64>) {
|
||||
+ // ePIC summary /Misc: Critical Temp + Shutdown Temp (round 19 #10, T3).
|
||||
+ let d = data.get(&DataField::TemperatureLimits);
|
||||
+ let f = |k: &str| {
|
||||
+ d.and_then(|v| v.pointer(k))
|
||||
+ .and_then(|v| v.as_f64())
|
||||
+ .filter(|v| v.is_finite() && *v > 0.0)
|
||||
+ };
|
||||
+ (f("/Critical Temp"), f("/Shutdown Temp"))
|
||||
+ }
|
||||
+}
|
||||
|
||||
impl GetWattage for PowerPlayV1 {
|
||||
fn parse_wattage(&self, data: &HashMap<DataField, Value>) -> Option<Power> {
|
||||
@@ -2205,6 +2229,9 @@ mod tests {
|
||||
assert_eq!(miner_data.wattage, Some(Power::from_watts(2166.6174)));
|
||||
// Miner-level fan duty cycle from summary /Fans/Fans Speed (round 19 #10, T3).
|
||||
assert_eq!(miner_data.fan_speed_percent, Some(100.0));
|
||||
+ // Board temp thresholds from summary /Misc (round 19 #10, T3).
|
||||
+ assert_eq!(miner_data.temp_critical, Some(100.0));
|
||||
+ assert_eq!(miner_data.temp_shutdown, Some(85.0));
|
||||
assert_eq!(miner_data.hashboards.len(), 3);
|
||||
assert_eq!(miner_data.hashboards[0].active, Some(false));
|
||||
assert_eq!(miner_data.hashboards[1].chips.len(), 110);
|
||||
@@ -0,0 +1,378 @@
|
||||
Subject: [PATCH 0029] telemetry: board temp thresholds -> target/hot/dangerous (LuxOS, Braiins; remap ePIC)
|
||||
|
||||
Round 19 #10, tier 3. Remodels the board temperature thresholds to the
|
||||
target/hot/dangerous scheme from item #10 and adds the LuxOS and Braiins backends.
|
||||
Supersedes the ePIC-only critical/shutdown model from patch 0028.
|
||||
|
||||
- MinerData: temp_critical/temp_shutdown -> temp_target/temp_hot/temp_dangerous.
|
||||
parse_temperature_limits (on the existing GetFluidTemperature trait) now returns
|
||||
(target, hot, dangerous).
|
||||
- LuxOS: new tempctrl RPC command; ChipTarget/ChipHot/ChipDangerous
|
||||
(live-verified 83/93/100, fixture tempctrl.json).
|
||||
- Braiins v25_07 + v26_04: configuration/constraints cooling_constraints defaults
|
||||
target/hot/dangerous (live-verified 60/80/90, fixture configuration_constraints.json;
|
||||
WEB_CONSTRAINTS already fetched).
|
||||
- ePIC remap: Shutdown Temp -> hot, Critical Temp -> dangerous, no target.
|
||||
- Antminer/WhatsMiner expose no thresholds; VNish handled separately (settings auth).
|
||||
|
||||
Fixture tests for epic, luxminer, braiins v26_04 assert the parsed thresholds.
|
||||
|
||||
diff --git a/vendor/asic-rs-core/src/data/miner.rs b/vendor/asic-rs-core/src/data/miner.rs
|
||||
index 08782856..9f74fc43 100644
|
||||
--- a/vendor/asic-rs-core/src/data/miner.rs
|
||||
+++ b/vendor/asic-rs-core/src/data/miner.rs
|
||||
@@ -181,10 +181,12 @@ pub struct MinerData {
|
||||
/// Miner-level fan duty cycle as a percentage (0-100), when reported. Firmware
|
||||
/// exposes no maximum RPM, so this duty cycle is the normalized fan indicator.
|
||||
pub fan_speed_percent: Option<f64>,
|
||||
- /// Board critical temperature threshold in Celsius, when reported (round 19 #10).
|
||||
- pub temp_critical: Option<f64>,
|
||||
- /// Board shutdown temperature threshold in Celsius, when reported (round 19 #10).
|
||||
- pub temp_shutdown: Option<f64>,
|
||||
+ /// Board target temperature threshold in Celsius, when reported (round 19 #10).
|
||||
+ pub temp_target: Option<f64>,
|
||||
+ /// Board hot temperature threshold in Celsius, when reported (round 19 #10).
|
||||
+ pub temp_hot: Option<f64>,
|
||||
+ /// Board dangerous temperature threshold in Celsius, when reported (round 19 #10).
|
||||
+ pub temp_dangerous: Option<f64>,
|
||||
/// The current PDU fan information for the miner
|
||||
pub psu_fans: Vec<FanData>,
|
||||
/// The average temperature across all chips in the miner
|
||||
diff --git a/vendor/asic-rs-core/src/traits/miner.rs b/vendor/asic-rs-core/src/traits/miner.rs
|
||||
index 9de51761..25ea6168 100644
|
||||
--- a/vendor/asic-rs-core/src/traits/miner.rs
|
||||
+++ b/vendor/asic-rs-core/src/traits/miner.rs
|
||||
@@ -282,7 +282,7 @@ impl<
|
||||
let tuning_capabilities = self.parse_tuning_capabilities(&data);
|
||||
let fluid_temperature = self.parse_fluid_temperature(&data);
|
||||
let outlet_fluid_temperature = self.parse_outlet_fluid_temperature(&data);
|
||||
- let (temp_critical, temp_shutdown) = self.parse_temperature_limits(&data);
|
||||
+ let (temp_target, temp_hot, temp_dangerous) = self.parse_temperature_limits(&data);
|
||||
let fans = self.parse_fans(&data);
|
||||
let fan_speed_percent = self.parse_fan_speed_percent(&data);
|
||||
let psu_fans = self.parse_psu_fans(&data);
|
||||
@@ -369,8 +369,9 @@ impl<
|
||||
expected_fans: device_info.hardware.fans,
|
||||
fans,
|
||||
fan_speed_percent,
|
||||
- temp_critical,
|
||||
- temp_shutdown,
|
||||
+ temp_target,
|
||||
+ temp_hot,
|
||||
+ temp_dangerous,
|
||||
psu_fans,
|
||||
average_temperature,
|
||||
fluid_temperature,
|
||||
@@ -744,14 +745,14 @@ pub trait GetFluidTemperature: CollectData {
|
||||
) -> Option<Temperature> {
|
||||
None
|
||||
}
|
||||
- /// Board temperature safety thresholds as (critical, shutdown) in Celsius.
|
||||
- /// Backends that expose them override this; others return (None, None).
|
||||
+ /// Board temperature safety thresholds as (target, hot, dangerous) in Celsius.
|
||||
+ /// Backends that expose them override this; others return (None, None, None).
|
||||
#[allow(unused_variables)]
|
||||
fn parse_temperature_limits(
|
||||
&self,
|
||||
data: &HashMap<DataField, Value>,
|
||||
- ) -> (Option<f64>, Option<f64>) {
|
||||
- (None, None)
|
||||
+ ) -> (Option<f64>, Option<f64>, Option<f64>) {
|
||||
+ (None, None, None)
|
||||
}
|
||||
}
|
||||
|
||||
diff --git a/vendor/asic-rs-firmwares-braiins/src/backends/v25_07/mod.rs b/vendor/asic-rs-firmwares-braiins/src/backends/v25_07/mod.rs
|
||||
index 86e84d8c..0dec8d38 100644
|
||||
--- a/vendor/asic-rs-firmwares-braiins/src/backends/v25_07/mod.rs
|
||||
+++ b/vendor/asic-rs-firmwares-braiins/src/backends/v25_07/mod.rs
|
||||
@@ -372,6 +372,16 @@ impl GetDataLocations for BraiinsV2507 {
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
+ // Board temp thresholds (round 19 #10, T3): cooling_constraints defaults
|
||||
+ // (target/hot/dangerous); WEB_CONSTRAINTS already fetched.
|
||||
+ DataField::TemperatureLimits => vec![(
|
||||
+ WEB_CONSTRAINTS,
|
||||
+ DataExtractor {
|
||||
+ func: get_by_pointer,
|
||||
+ key: Some("/cooling_constraints"),
|
||||
+ tag: None,
|
||||
+ },
|
||||
+ )],
|
||||
_ => vec![],
|
||||
}
|
||||
}
|
||||
@@ -725,7 +735,26 @@ impl GetScaledTuningTarget for BraiinsV2507 {
|
||||
}
|
||||
}
|
||||
|
||||
-impl GetFluidTemperature for BraiinsV2507 {}
|
||||
+impl GetFluidTemperature for BraiinsV2507 {
|
||||
+ fn parse_temperature_limits(
|
||||
+ &self,
|
||||
+ data: &HashMap<DataField, Value>,
|
||||
+ ) -> (Option<f64>, Option<f64>, Option<f64>) {
|
||||
+ // Braiins cooling_constraints target/hot/dangerous default thresholds in
|
||||
+ // degree_c (round 19 #10, T3).
|
||||
+ let d = data.get(&DataField::TemperatureLimits);
|
||||
+ let f = |k: &str| {
|
||||
+ d.and_then(|v| v.pointer(&format!("/{k}/default/degree_c")))
|
||||
+ .and_then(|v| v.as_f64())
|
||||
+ .filter(|v| v.is_finite() && *v > 0.0)
|
||||
+ };
|
||||
+ (
|
||||
+ f("target_temperature"),
|
||||
+ f("hot_temperature"),
|
||||
+ f("dangerous_temperature"),
|
||||
+ )
|
||||
+ }
|
||||
+}
|
||||
impl GetTuningCapabilities for BraiinsV2507 {
|
||||
fn parse_tuning_capabilities(
|
||||
&self,
|
||||
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 303fca49..4e423e5b 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
|
||||
@@ -393,6 +393,16 @@ impl GetDataLocations for BraiinsV2604 {
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
+ // Board temp thresholds (round 19 #10, T3): cooling_constraints defaults
|
||||
+ // (target/hot/dangerous); WEB_CONSTRAINTS already fetched.
|
||||
+ DataField::TemperatureLimits => vec![(
|
||||
+ WEB_CONSTRAINTS,
|
||||
+ DataExtractor {
|
||||
+ func: get_by_pointer,
|
||||
+ key: Some("/cooling_constraints"),
|
||||
+ tag: None,
|
||||
+ },
|
||||
+ )],
|
||||
_ => vec![],
|
||||
}
|
||||
}
|
||||
@@ -775,7 +785,26 @@ impl GetScaledTuningTarget for BraiinsV2604 {
|
||||
}
|
||||
}
|
||||
|
||||
-impl GetFluidTemperature for BraiinsV2604 {}
|
||||
+impl GetFluidTemperature for BraiinsV2604 {
|
||||
+ fn parse_temperature_limits(
|
||||
+ &self,
|
||||
+ data: &HashMap<DataField, Value>,
|
||||
+ ) -> (Option<f64>, Option<f64>, Option<f64>) {
|
||||
+ // Braiins cooling_constraints target/hot/dangerous default thresholds in
|
||||
+ // degree_c (round 19 #10, T3).
|
||||
+ let d = data.get(&DataField::TemperatureLimits);
|
||||
+ let f = |k: &str| {
|
||||
+ d.and_then(|v| v.pointer(&format!("/{k}/default/degree_c")))
|
||||
+ .and_then(|v| v.as_f64())
|
||||
+ .filter(|v| v.is_finite() && *v > 0.0)
|
||||
+ };
|
||||
+ (
|
||||
+ f("target_temperature"),
|
||||
+ f("hot_temperature"),
|
||||
+ f("dangerous_temperature"),
|
||||
+ )
|
||||
+ }
|
||||
+}
|
||||
impl GetTuningCapabilities for BraiinsV2604 {
|
||||
fn parse_tuning_capabilities(
|
||||
&self,
|
||||
@@ -1167,10 +1196,10 @@ mod tests {
|
||||
|
||||
use super::*;
|
||||
use crate::test::json::v26_04::{
|
||||
- WEB_COOLING_STATE_COMMAND, WEB_HASHBOARDS_COMMAND, WEB_LOCATE_COMMAND,
|
||||
- WEB_MINER_CONFIGURATION_COMMAND, WEB_MINER_DETAILS_COMMAND, WEB_MINER_STATS_COMMAND,
|
||||
- WEB_NETWORK_COMMAND, WEB_PERFORMANCE_TUNER_STATE_COMMAND, WEB_POOLS_COMMAND,
|
||||
- WEB_VERSION_COMMAND,
|
||||
+ WEB_CONSTRAINTS_COMMAND, WEB_COOLING_STATE_COMMAND, WEB_HASHBOARDS_COMMAND,
|
||||
+ WEB_LOCATE_COMMAND, WEB_MINER_CONFIGURATION_COMMAND, WEB_MINER_DETAILS_COMMAND,
|
||||
+ WEB_MINER_STATS_COMMAND, WEB_NETWORK_COMMAND, WEB_PERFORMANCE_TUNER_STATE_COMMAND,
|
||||
+ WEB_POOLS_COMMAND, WEB_VERSION_COMMAND,
|
||||
};
|
||||
|
||||
#[tokio::test]
|
||||
@@ -1251,6 +1280,13 @@ mod tests {
|
||||
},
|
||||
Value::from_str(WEB_HASHBOARDS_COMMAND).unwrap(),
|
||||
);
|
||||
+ results.insert(
|
||||
+ MinerCommand::WebAPI {
|
||||
+ command: "configuration/constraints",
|
||||
+ parameters: None,
|
||||
+ },
|
||||
+ Value::from_str(WEB_CONSTRAINTS_COMMAND).unwrap(),
|
||||
+ );
|
||||
results.insert(
|
||||
MinerCommand::WebAPI {
|
||||
command: "actions/locate",
|
||||
@@ -1313,6 +1349,10 @@ mod tests {
|
||||
// 19 #10, T3).
|
||||
let fan_pct = miner_data.fan_speed_percent.expect("braiins fan duty");
|
||||
assert!((fan_pct - 92.0).abs() < 1e-6);
|
||||
+ // Board temp thresholds from cooling_constraints defaults (round 19 #10, T3).
|
||||
+ assert_eq!(miner_data.temp_target, Some(60.0));
|
||||
+ assert_eq!(miner_data.temp_hot, Some(80.0));
|
||||
+ assert_eq!(miner_data.temp_dangerous, Some(90.0));
|
||||
}
|
||||
|
||||
#[test]
|
||||
diff --git a/vendor/asic-rs-firmwares-braiins/src/test/json/v26_04/mod.rs b/vendor/asic-rs-firmwares-braiins/src/test/json/v26_04/mod.rs
|
||||
index 06b35fef..3904b012 100644
|
||||
--- a/vendor/asic-rs-firmwares-braiins/src/test/json/v26_04/mod.rs
|
||||
+++ b/vendor/asic-rs-firmwares-braiins/src/test/json/v26_04/mod.rs
|
||||
@@ -12,3 +12,4 @@ pub(crate) const WEB_POOLS_COMMAND: &str = include_str!("pools.json");
|
||||
pub(crate) const WEB_COOLING_STATE_COMMAND: &str = include_str!("cooling_state.json");
|
||||
pub(crate) const WEB_HASHBOARDS_COMMAND: &str = include_str!("miner_hw_hashboards.json");
|
||||
pub(crate) const WEB_LOCATE_COMMAND: &str = include_str!("actions_locate.json");
|
||||
+pub(crate) const WEB_CONSTRAINTS_COMMAND: &str = include_str!("configuration_constraints.json");
|
||||
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 0c9a851b..2e12e07a 100644
|
||||
--- a/vendor/asic-rs-firmwares-epic/src/backends/v1/mod.rs
|
||||
+++ b/vendor/asic-rs-firmwares-epic/src/backends/v1/mod.rs
|
||||
@@ -1153,15 +1153,16 @@ impl GetFluidTemperature for PowerPlayV1 {
|
||||
fn parse_temperature_limits(
|
||||
&self,
|
||||
data: &HashMap<DataField, Value>,
|
||||
- ) -> (Option<f64>, Option<f64>) {
|
||||
- // ePIC summary /Misc: Critical Temp + Shutdown Temp (round 19 #10, T3).
|
||||
+ ) -> (Option<f64>, Option<f64>, Option<f64>) {
|
||||
+ // ePIC summary /Misc: Shutdown Temp (hot) + Critical Temp (dangerous); no
|
||||
+ // target threshold reported (round 19 #10, T3).
|
||||
let d = data.get(&DataField::TemperatureLimits);
|
||||
let f = |k: &str| {
|
||||
d.and_then(|v| v.pointer(k))
|
||||
.and_then(|v| v.as_f64())
|
||||
.filter(|v| v.is_finite() && *v > 0.0)
|
||||
};
|
||||
- (f("/Critical Temp"), f("/Shutdown Temp"))
|
||||
+ (None, f("/Shutdown Temp"), f("/Critical Temp"))
|
||||
}
|
||||
}
|
||||
|
||||
@@ -2229,9 +2230,11 @@ mod tests {
|
||||
assert_eq!(miner_data.wattage, Some(Power::from_watts(2166.6174)));
|
||||
// Miner-level fan duty cycle from summary /Fans/Fans Speed (round 19 #10, T3).
|
||||
assert_eq!(miner_data.fan_speed_percent, Some(100.0));
|
||||
- // Board temp thresholds from summary /Misc (round 19 #10, T3).
|
||||
- assert_eq!(miner_data.temp_critical, Some(100.0));
|
||||
- assert_eq!(miner_data.temp_shutdown, Some(85.0));
|
||||
+ // Board temp thresholds from summary /Misc (round 19 #10, T3): Shutdown->hot,
|
||||
+ // Critical->dangerous, no target.
|
||||
+ assert_eq!(miner_data.temp_target, None);
|
||||
+ assert_eq!(miner_data.temp_hot, Some(85.0));
|
||||
+ assert_eq!(miner_data.temp_dangerous, Some(100.0));
|
||||
assert_eq!(miner_data.hashboards.len(), 3);
|
||||
assert_eq!(miner_data.hashboards[0].active, Some(false));
|
||||
assert_eq!(miner_data.hashboards[1].chips.len(), 110);
|
||||
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 edab7c4c..de9c2d35 100644
|
||||
--- a/vendor/asic-rs-firmwares-luxminer/src/backends/v1/mod.rs
|
||||
+++ b/vendor/asic-rs-firmwares-luxminer/src/backends/v1/mod.rs
|
||||
@@ -278,6 +278,11 @@ impl GetDataLocations for LuxMinerV1 {
|
||||
parameters: None,
|
||||
};
|
||||
|
||||
+ const RPC_TEMPCTRL: MinerCommand = MinerCommand::RPC {
|
||||
+ command: "tempctrl",
|
||||
+ parameters: None,
|
||||
+ };
|
||||
+
|
||||
match data_field {
|
||||
DataField::Mac => vec![(
|
||||
RPC_CONFIG,
|
||||
@@ -305,6 +310,16 @@ impl GetDataLocations for LuxMinerV1 {
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
+ // Board temp thresholds (round 19 #10, T3): LuxOS tempctrl reports
|
||||
+ // ChipTarget / ChipHot / ChipDangerous.
|
||||
+ DataField::TemperatureLimits => vec![(
|
||||
+ RPC_TEMPCTRL,
|
||||
+ DataExtractor {
|
||||
+ func: get_by_pointer,
|
||||
+ key: Some("/TEMPCTRL/0"),
|
||||
+ tag: None,
|
||||
+ },
|
||||
+ )],
|
||||
DataField::ApiVersion => vec![(
|
||||
RPC_VERSION,
|
||||
DataExtractor {
|
||||
@@ -690,6 +705,20 @@ impl GetFluidTemperature for LuxMinerV1 {
|
||||
(None, None) => None,
|
||||
}
|
||||
}
|
||||
+ fn parse_temperature_limits(
|
||||
+ &self,
|
||||
+ data: &HashMap<DataField, Value>,
|
||||
+ ) -> (Option<f64>, Option<f64>, Option<f64>) {
|
||||
+ // LuxOS tempctrl chip thresholds ChipTarget / ChipHot / ChipDangerous
|
||||
+ // (round 19 #10, T3).
|
||||
+ let d = data.get(&DataField::TemperatureLimits);
|
||||
+ let f = |k: &str| {
|
||||
+ d.and_then(|v| v.get(k))
|
||||
+ .and_then(|v| v.as_f64())
|
||||
+ .filter(|v| v.is_finite() && *v > 0.0)
|
||||
+ };
|
||||
+ (f("ChipTarget"), f("ChipHot"), f("ChipDangerous"))
|
||||
+ }
|
||||
}
|
||||
|
||||
impl GetFirmwareVersion for LuxMinerV1 {
|
||||
@@ -1465,7 +1494,8 @@ mod tests {
|
||||
use super::*;
|
||||
use crate::test::json::v1::{
|
||||
CONFIG, DEVS, EVENTS, FANS, HEALTHCHIPGET_0, HEALTHCHIPGET_1, HEALTHCHIPGET_2, POOLS,
|
||||
- POWER, PROFILES, STATS, SUMMARY, TEMPS, VERSION, VOLTAGEGET_0, VOLTAGEGET_1, VOLTAGEGET_2,
|
||||
+ POWER, PROFILES, STATS, SUMMARY, TEMPCTRL, TEMPS, VERSION, VOLTAGEGET_0, VOLTAGEGET_1,
|
||||
+ VOLTAGEGET_2,
|
||||
};
|
||||
|
||||
#[test]
|
||||
@@ -1582,6 +1612,11 @@ mod tests {
|
||||
parameters: None,
|
||||
};
|
||||
|
||||
+ let tempctrl_cmd = MinerCommand::RPC {
|
||||
+ command: "tempctrl",
|
||||
+ parameters: None,
|
||||
+ };
|
||||
+
|
||||
results.insert(version_cmd, Value::from_str(VERSION)?);
|
||||
results.insert(stats_cmd, Value::from_str(STATS)?);
|
||||
results.insert(summary_cmd, Value::from_str(SUMMARY)?);
|
||||
@@ -1591,6 +1626,7 @@ mod tests {
|
||||
results.insert(power_cmd, Value::from_str(POWER)?);
|
||||
results.insert(profiles_cmd, Value::from_str(PROFILES)?);
|
||||
results.insert(temps_cmd, Value::from_str(TEMPS)?);
|
||||
+ results.insert(tempctrl_cmd, Value::from_str(TEMPCTRL)?);
|
||||
results.insert(devs_cmd, Value::from_str(DEVS)?);
|
||||
results.insert(
|
||||
MinerCommand::RPC {
|
||||
@@ -1704,6 +1740,11 @@ mod tests {
|
||||
// Miner-level fan duty cycle = max of per-fan Speed (all 20 here); round 19
|
||||
// #10, T3.
|
||||
assert_eq!(miner_data.fan_speed_percent, Some(20.0));
|
||||
+ // Board temp thresholds from tempctrl ChipTarget/ChipHot/ChipDangerous
|
||||
+ // (round 19 #10, T3).
|
||||
+ assert_eq!(miner_data.temp_target, Some(83.0));
|
||||
+ assert_eq!(miner_data.temp_hot, Some(93.0));
|
||||
+ assert_eq!(miner_data.temp_dangerous, Some(100.0));
|
||||
assert_eq!(miner_data.hashboards[0].chips.len(), 77);
|
||||
assert_eq!(miner_data.pools.len(), 2);
|
||||
assert_eq!(miner_data.pools[0].len(), 2);
|
||||
diff --git a/vendor/asic-rs-firmwares-luxminer/src/test/json/v1/mod.rs b/vendor/asic-rs-firmwares-luxminer/src/test/json/v1/mod.rs
|
||||
index 7f328a47..02500ccb 100644
|
||||
--- a/vendor/asic-rs-firmwares-luxminer/src/test/json/v1/mod.rs
|
||||
+++ b/vendor/asic-rs-firmwares-luxminer/src/test/json/v1/mod.rs
|
||||
@@ -10,6 +10,7 @@ pub(crate) const PROFILES: &str = include_str!("profiles.json");
|
||||
pub(crate) const STATS: &str = include_str!("stats.json");
|
||||
pub(crate) const SUMMARY: &str = include_str!("summary.json");
|
||||
pub(crate) const TEMPS: &str = include_str!("temps.json");
|
||||
+pub(crate) const TEMPCTRL: &str = include_str!("tempctrl.json");
|
||||
pub(crate) const VERSION: &str = include_str!("version.json");
|
||||
pub(crate) const EVENTS: &str = include_str!("events.json");
|
||||
|
||||
@@ -0,0 +1,364 @@
|
||||
Subject: [PATCH 0030] telemetry: VNish fan% + temp thresholds; WhatsMiner chip type
|
||||
|
||||
Round 19 #10, tier 3 live-verified follow-up. Populates existing columns for more
|
||||
firmwares; no core or GUI change.
|
||||
|
||||
- VNish (v1_2_0 + v1_3_0): fan duty % from summary /miner/cooling/fan_duty; board
|
||||
temp thresholds from settings (restart_temp -> dangerous, auto cooling mode param
|
||||
-> target; no hot). Both commands already fetched. Live-verified on 10.4.1.50
|
||||
(fan_duty 81, restart_temp 90, auto param 65). VNish exposes no PSU serial
|
||||
(factory-info absent) so it stays None.
|
||||
- WhatsMiner chip type (per noah, do not drop): v1/v2 summary "Chip Data" merged
|
||||
into the hashboards data -> BoardData.chip_type (first token, e.g. "HP5A01-19101436");
|
||||
v3 get.device.info chipdataN -> chip_type and hash-board ("K40") -> hashboard_model.
|
||||
Live WhatsMiner summaries often omit "Chip Data" (populates where present); v3
|
||||
chip data is live on newer units.
|
||||
|
||||
Fixture tests: whatsminer v1/v3 assert chip_type/hashboard_model; vnish asserts the
|
||||
parsed fan % and temp thresholds.
|
||||
|
||||
diff --git a/vendor/asic-rs-firmwares-vnish/src/backends/v1_2_0/mod.rs b/vendor/asic-rs-firmwares-vnish/src/backends/v1_2_0/mod.rs
|
||||
index e734a03e..ad2779b6 100644
|
||||
--- a/vendor/asic-rs-firmwares-vnish/src/backends/v1_2_0/mod.rs
|
||||
+++ b/vendor/asic-rs-firmwares-vnish/src/backends/v1_2_0/mod.rs
|
||||
@@ -369,6 +369,25 @@ impl GetDataLocations for VnishV120 {
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
+ // Miner-level fan duty cycle (round 19 #10, T3); summary already fetched.
|
||||
+ DataField::FanSpeedPercent => vec![(
|
||||
+ WEB_SUMMARY,
|
||||
+ DataExtractor {
|
||||
+ func: get_by_pointer,
|
||||
+ key: Some("/miner/cooling/fan_duty"),
|
||||
+ tag: None,
|
||||
+ },
|
||||
+ )],
|
||||
+ // Board temp thresholds (round 19 #10, T3): settings restart_temp
|
||||
+ // (dangerous) + auto cooling target. Settings already fetched.
|
||||
+ DataField::TemperatureLimits => vec![(
|
||||
+ WEB_SETTINGS,
|
||||
+ DataExtractor {
|
||||
+ func: get_by_pointer,
|
||||
+ key: Some("/miner"),
|
||||
+ tag: None,
|
||||
+ },
|
||||
+ )],
|
||||
_ => vec![],
|
||||
}
|
||||
}
|
||||
@@ -678,6 +697,12 @@ impl GetFans for VnishV120 {
|
||||
|
||||
fans
|
||||
}
|
||||
+ fn parse_fan_speed_percent(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
|
||||
+ // VNish summary /miner/cooling/fan_duty is a miner-level duty % (round 19 #10).
|
||||
+ data.get(&DataField::FanSpeedPercent)
|
||||
+ .and_then(|v| v.as_f64())
|
||||
+ .filter(|v| v.is_finite() && *v >= 0.0)
|
||||
+ }
|
||||
}
|
||||
|
||||
impl GetPsuFans for VnishV120 {}
|
||||
@@ -766,6 +791,26 @@ impl GetFluidTemperature for VnishV120 {
|
||||
.max()
|
||||
.map(|t| Temperature::from_celsius(t as f64))
|
||||
}
|
||||
+ fn parse_temperature_limits(
|
||||
+ &self,
|
||||
+ data: &HashMap<DataField, Value>,
|
||||
+ ) -> (Option<f64>, Option<f64>, Option<f64>) {
|
||||
+ // VNish settings: restart_temp is the dangerous threshold; the auto cooling
|
||||
+ // mode "param" is the target temperature. No hot threshold (round 19 #10, T3).
|
||||
+ let m = data.get(&DataField::TemperatureLimits);
|
||||
+ let dangerous = m
|
||||
+ .and_then(|v| v.pointer("/misc/restart_temp"))
|
||||
+ .and_then(|v| v.as_f64())
|
||||
+ .filter(|v| v.is_finite() && *v > 0.0);
|
||||
+ let target = m
|
||||
+ .filter(|v| {
|
||||
+ v.pointer("/cooling/settings/mode/name").and_then(|n| n.as_str()) == Some("auto")
|
||||
+ })
|
||||
+ .and_then(|v| v.pointer("/cooling/settings/mode/param"))
|
||||
+ .and_then(|v| v.as_f64())
|
||||
+ .filter(|v| v.is_finite() && *v > 0.0);
|
||||
+ (target, None, dangerous)
|
||||
+ }
|
||||
}
|
||||
|
||||
impl GetWattage for VnishV120 {
|
||||
diff --git a/vendor/asic-rs-firmwares-vnish/src/backends/v1_3_0/mod.rs b/vendor/asic-rs-firmwares-vnish/src/backends/v1_3_0/mod.rs
|
||||
index 0a5d694e..4f0453a1 100644
|
||||
--- a/vendor/asic-rs-firmwares-vnish/src/backends/v1_3_0/mod.rs
|
||||
+++ b/vendor/asic-rs-firmwares-vnish/src/backends/v1_3_0/mod.rs
|
||||
@@ -375,6 +375,26 @@ impl GetDataLocations for VnishV130 {
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
+ // Miner-level fan duty cycle (round 19 #10, T3); summary already fetched.
|
||||
+ DataField::FanSpeedPercent => vec![(
|
||||
+ WEB_SUMMARY,
|
||||
+ DataExtractor {
|
||||
+ func: get_by_pointer,
|
||||
+ key: Some("/miner/cooling/fan_duty"),
|
||||
+ tag: None,
|
||||
+ },
|
||||
+ )],
|
||||
+ // Board temp thresholds (round 19 #10, T3): settings /miner/misc/restart_temp
|
||||
+ // (dangerous) + auto cooling target (/miner/cooling/settings/mode/param).
|
||||
+ // Settings already fetched for the tuning preset.
|
||||
+ DataField::TemperatureLimits => vec![(
|
||||
+ WEB_SETTINGS,
|
||||
+ DataExtractor {
|
||||
+ func: get_by_pointer,
|
||||
+ key: Some("/miner"),
|
||||
+ tag: None,
|
||||
+ },
|
||||
+ )],
|
||||
_ => vec![],
|
||||
}
|
||||
}
|
||||
@@ -683,6 +703,12 @@ impl GetFans for VnishV130 {
|
||||
|
||||
fans
|
||||
}
|
||||
+ fn parse_fan_speed_percent(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
|
||||
+ // VNish summary /miner/cooling/fan_duty is a miner-level duty % (round 19 #10).
|
||||
+ data.get(&DataField::FanSpeedPercent)
|
||||
+ .and_then(|v| v.as_f64())
|
||||
+ .filter(|v| v.is_finite() && *v >= 0.0)
|
||||
+ }
|
||||
}
|
||||
|
||||
impl GetPsuFans for VnishV130 {}
|
||||
@@ -716,6 +742,26 @@ impl GetFluidTemperature for VnishV130 {
|
||||
.max()
|
||||
.map(|t| Temperature::from_celsius(t as f64))
|
||||
}
|
||||
+ fn parse_temperature_limits(
|
||||
+ &self,
|
||||
+ data: &HashMap<DataField, Value>,
|
||||
+ ) -> (Option<f64>, Option<f64>, Option<f64>) {
|
||||
+ // VNish settings: restart_temp is the dangerous threshold; the auto cooling
|
||||
+ // mode "param" is the target temperature. No hot threshold (round 19 #10, T3).
|
||||
+ let m = data.get(&DataField::TemperatureLimits);
|
||||
+ let dangerous = m
|
||||
+ .and_then(|v| v.pointer("/misc/restart_temp"))
|
||||
+ .and_then(|v| v.as_f64())
|
||||
+ .filter(|v| v.is_finite() && *v > 0.0);
|
||||
+ let target = m
|
||||
+ .filter(|v| {
|
||||
+ v.pointer("/cooling/settings/mode/name").and_then(|n| n.as_str()) == Some("auto")
|
||||
+ })
|
||||
+ .and_then(|v| v.pointer("/cooling/settings/mode/param"))
|
||||
+ .and_then(|v| v.as_f64())
|
||||
+ .filter(|v| v.is_finite() && *v > 0.0);
|
||||
+ (target, None, dangerous)
|
||||
+ }
|
||||
}
|
||||
|
||||
impl GetWattage for VnishV130 {
|
||||
@@ -1354,6 +1400,28 @@ mod tests {
|
||||
);
|
||||
}
|
||||
|
||||
+ /// Fan duty cycle (summary /miner/cooling/fan_duty) and board temp thresholds
|
||||
+ /// (settings restart_temp -> dangerous, auto cooling param -> target); round 19
|
||||
+ /// #10, T3. Values match the live 10.4.1.50 fleet unit.
|
||||
+ #[test]
|
||||
+ fn fan_duty_and_temp_thresholds() {
|
||||
+ let miner = VnishV130::new(IpAddr::from([127, 0, 0, 1]), AntMinerModel::S19jPro);
|
||||
+ let mut data: HashMap<DataField, Value> = HashMap::new();
|
||||
+ data.insert(DataField::FanSpeedPercent, json!(81));
|
||||
+ data.insert(
|
||||
+ DataField::TemperatureLimits,
|
||||
+ json!({
|
||||
+ "misc": { "restart_temp": 90 },
|
||||
+ "cooling": { "settings": { "mode": { "name": "auto", "param": 65 } } }
|
||||
+ }),
|
||||
+ );
|
||||
+ assert_eq!(miner.parse_fan_speed_percent(&data), Some(81.0));
|
||||
+ assert_eq!(
|
||||
+ miner.parse_temperature_limits(&data),
|
||||
+ (Some(65.0), None, Some(90.0))
|
||||
+ );
|
||||
+ }
|
||||
+
|
||||
/// An L9 is a Scrypt miner and VNish says so in `/info`, both in
|
||||
/// `algorithm` and by reporting `hr_measure: MH/s`. Before this was wired
|
||||
/// up it came back as a SHA-256 miner and every figure was read as GH/s,
|
||||
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 aacd1077..4025a931 100644
|
||||
--- a/vendor/asic-rs-firmwares-whatsminer/src/backends/v1/mod.rs
|
||||
+++ b/vendor/asic-rs-firmwares-whatsminer/src/backends/v1/mod.rs
|
||||
@@ -205,14 +205,26 @@ impl GetDataLocations for WhatsMinerV1 {
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
- DataField::Hashboards => vec![(
|
||||
- RPC_DEVS,
|
||||
- DataExtractor {
|
||||
- func: get_by_pointer,
|
||||
- key: Some(""),
|
||||
- tag: None,
|
||||
- },
|
||||
- )],
|
||||
+ DataField::Hashboards => vec![
|
||||
+ (
|
||||
+ RPC_DEVS,
|
||||
+ DataExtractor {
|
||||
+ func: get_by_pointer,
|
||||
+ key: Some(""),
|
||||
+ tag: None,
|
||||
+ },
|
||||
+ ),
|
||||
+ // Merge in summary so "Chip Data" (miner-wide chip marking) is
|
||||
+ // available per board (round 19 #10); RPC_SUMMARY already fetched.
|
||||
+ (
|
||||
+ RPC_SUMMARY,
|
||||
+ DataExtractor {
|
||||
+ func: get_by_pointer,
|
||||
+ key: Some("/SUMMARY/0"),
|
||||
+ tag: None,
|
||||
+ },
|
||||
+ ),
|
||||
+ ],
|
||||
DataField::Pools => vec![(
|
||||
RPC_POOLS,
|
||||
DataExtractor {
|
||||
@@ -436,6 +448,20 @@ impl GetHashboards for WhatsMinerV1 {
|
||||
);
|
||||
}
|
||||
|
||||
+ // Chip marking from the merged summary "Chip Data" (miner-wide, first
|
||||
+ // token), applied to every board (round 19 #10).
|
||||
+ let chip_type = hashboard_data
|
||||
+ .pointer("/Chip Data")
|
||||
+ .and_then(|v| v.as_str())
|
||||
+ .and_then(|s| s.split_whitespace().next())
|
||||
+ .filter(|s| !s.is_empty())
|
||||
+ .map(str::to_string);
|
||||
+ if chip_type.is_some() {
|
||||
+ for board in hashboards.iter_mut() {
|
||||
+ board.chip_type = chip_type.clone();
|
||||
+ }
|
||||
+ }
|
||||
+
|
||||
hashboards
|
||||
}
|
||||
}
|
||||
@@ -992,6 +1018,12 @@ mod integration_tests {
|
||||
assert_eq!(shares.difficulty_rejected, Some(0.0));
|
||||
assert_eq!(shares.stale_shares, Some(0));
|
||||
assert_eq!(shares.found_blocks, Some(0));
|
||||
+ // Chip marking from summary "Chip Data" first token (round 19 #10).
|
||||
+ assert!(!miner_data.hashboards.is_empty());
|
||||
+ assert_eq!(
|
||||
+ miner_data.hashboards[0].chip_type.as_deref(),
|
||||
+ Some("HP5A01-19101436")
|
||||
+ );
|
||||
assert_eq!(miner_data.wattage, Some(Power::from_watts(3417f64)));
|
||||
assert_eq!(
|
||||
miner_data.tuning_target,
|
||||
diff --git a/vendor/asic-rs-firmwares-whatsminer/src/backends/v2/mod.rs b/vendor/asic-rs-firmwares-whatsminer/src/backends/v2/mod.rs
|
||||
index 4cfcee19..2b340e28 100644
|
||||
--- a/vendor/asic-rs-firmwares-whatsminer/src/backends/v2/mod.rs
|
||||
+++ b/vendor/asic-rs-firmwares-whatsminer/src/backends/v2/mod.rs
|
||||
@@ -216,14 +216,26 @@ impl GetDataLocations for WhatsMinerV2 {
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
- DataField::Hashboards => vec![(
|
||||
- RPC_DEVS,
|
||||
- DataExtractor {
|
||||
- func: get_by_pointer,
|
||||
- key: Some(""),
|
||||
- tag: None,
|
||||
- },
|
||||
- )],
|
||||
+ DataField::Hashboards => vec![
|
||||
+ (
|
||||
+ RPC_DEVS,
|
||||
+ DataExtractor {
|
||||
+ func: get_by_pointer,
|
||||
+ key: Some(""),
|
||||
+ tag: None,
|
||||
+ },
|
||||
+ ),
|
||||
+ // Merge in summary so "Chip Data" (miner-wide chip marking) is
|
||||
+ // available per board (round 19 #10); RPC_SUMMARY already fetched.
|
||||
+ (
|
||||
+ RPC_SUMMARY,
|
||||
+ DataExtractor {
|
||||
+ func: get_by_pointer,
|
||||
+ key: Some("/SUMMARY/0"),
|
||||
+ tag: None,
|
||||
+ },
|
||||
+ ),
|
||||
+ ],
|
||||
DataField::Pools => vec![(
|
||||
RPC_POOLS,
|
||||
DataExtractor {
|
||||
@@ -433,6 +445,20 @@ impl GetHashboards for WhatsMinerV2 {
|
||||
);
|
||||
}
|
||||
|
||||
+ // Chip marking from the merged summary "Chip Data" (miner-wide, first
|
||||
+ // token), applied to every board (round 19 #10).
|
||||
+ let chip_type = hashboard_data
|
||||
+ .pointer("/Chip Data")
|
||||
+ .and_then(|v| v.as_str())
|
||||
+ .and_then(|s| s.split_whitespace().next())
|
||||
+ .filter(|s| !s.is_empty())
|
||||
+ .map(str::to_string);
|
||||
+ if chip_type.is_some() {
|
||||
+ for board in hashboards.iter_mut() {
|
||||
+ board.chip_type = chip_type.clone();
|
||||
+ }
|
||||
+ }
|
||||
+
|
||||
hashboards
|
||||
}
|
||||
}
|
||||
diff --git a/vendor/asic-rs-firmwares-whatsminer/src/backends/v3/mod.rs b/vendor/asic-rs-firmwares-whatsminer/src/backends/v3/mod.rs
|
||||
index 04608936..77a1c6ec 100644
|
||||
--- a/vendor/asic-rs-firmwares-whatsminer/src/backends/v3/mod.rs
|
||||
+++ b/vendor/asic-rs-firmwares-whatsminer/src/backends/v3/mod.rs
|
||||
@@ -459,6 +459,19 @@ impl GetHashboards for WhatsMinerV3 {
|
||||
.map(|h| h.value > 0.0)
|
||||
.unwrap_or(false),
|
||||
);
|
||||
+ // Chip marking (per-board chipdataN, first token) + hashboard model
|
||||
+ // (miner-wide hash-board, e.g. "K40") from get.device.info (round 19 #10).
|
||||
+ board.chip_type = hashboard_data
|
||||
+ .pointer(&format!("/chipdata{idx}"))
|
||||
+ .and_then(|v| v.as_str())
|
||||
+ .and_then(|s| s.split_whitespace().next())
|
||||
+ .filter(|s| !s.is_empty())
|
||||
+ .map(str::to_string);
|
||||
+ board.hashboard_model = hashboard_data
|
||||
+ .pointer("/hash-board")
|
||||
+ .and_then(|v| v.as_str())
|
||||
+ .filter(|s| !s.is_empty())
|
||||
+ .map(str::to_string);
|
||||
}
|
||||
|
||||
hashboards
|
||||
@@ -1241,6 +1254,17 @@ mod integration_tests {
|
||||
assert!(miner_data.is_mining);
|
||||
assert_eq!(miner_data.fans.len(), 2);
|
||||
assert_eq!(miner_data.pools[0].len(), 3);
|
||||
+ // Chip marking (chipdataN first token) + hashboard model (hash-board);
|
||||
+ // round 19 #10.
|
||||
+ assert!(!miner_data.hashboards.is_empty());
|
||||
+ assert_eq!(
|
||||
+ miner_data.hashboards[0].chip_type.as_deref(),
|
||||
+ Some("K8EC374-2426")
|
||||
+ );
|
||||
+ assert_eq!(
|
||||
+ miner_data.hashboards[0].hashboard_model.as_deref(),
|
||||
+ Some("K40")
|
||||
+ );
|
||||
|
||||
Ok(())
|
||||
}
|
||||
@@ -0,0 +1,237 @@
|
||||
Subject: [PATCH 0031] telemetry: auto-tuner status (Braiins, ePIC)
|
||||
|
||||
Round 19 #10, tier 3. Exposes the auto-tuner status as a human-readable label.
|
||||
|
||||
- New DataField::TunerStatus; MinerData gains tuner_status (Option<String>).
|
||||
Rides the existing GetOperatingState trait via a defaulted parse_tuner_status
|
||||
method (no supertrait bound); parse_data wires it in.
|
||||
- Braiins v25_07 + v26_04: performance/tuner-state overall_tuner_state, mapped
|
||||
through the BOS+ TunerState enum (bos-plus-api performance.proto: 1 Disabled,
|
||||
2 Stable, 3 Tuning, 4 Error, 5 Continuous, 6 Preheat). Command already fetched.
|
||||
- ePIC: summary PerpetualTune -> "Off" (not running), "Optimized" (settled) or
|
||||
"Tuning" (running, not yet optimized). Summary already fetched.
|
||||
- WhatsMiner/Antminer/LuxOS/VNish report no distinct tuner status -> None.
|
||||
|
||||
Fixture tests: braiins v26_04 asserts "Continuous" (state 5), epic asserts "Tuning".
|
||||
|
||||
diff --git a/vendor/asic-rs-core/src/data/collector.rs b/vendor/asic-rs-core/src/data/collector.rs
|
||||
index 1e6e7e9d..8f9b4c9c 100644
|
||||
--- a/vendor/asic-rs-core/src/data/collector.rs
|
||||
+++ b/vendor/asic-rs-core/src/data/collector.rs
|
||||
@@ -68,6 +68,9 @@ pub enum DataField {
|
||||
/// Board temperature safety thresholds (critical / shutdown), in Celsius.
|
||||
#[cfg_attr(feature = "python", pydantic(value = "TemperatureLimits"))]
|
||||
TemperatureLimits,
|
||||
+ /// Auto-tuner status (a human-readable label, e.g. "Stable", "Tuning").
|
||||
+ #[cfg_attr(feature = "python", pydantic(value = "TunerStatus"))]
|
||||
+ TunerStatus,
|
||||
/// PSU fan speed or configuration.
|
||||
#[cfg_attr(feature = "python", pydantic(value = "PsuFans"))]
|
||||
PsuFans,
|
||||
diff --git a/vendor/asic-rs-core/src/data/miner.rs b/vendor/asic-rs-core/src/data/miner.rs
|
||||
index 9f74fc43..8832a049 100644
|
||||
--- a/vendor/asic-rs-core/src/data/miner.rs
|
||||
+++ b/vendor/asic-rs-core/src/data/miner.rs
|
||||
@@ -236,6 +236,9 @@ pub struct MinerData {
|
||||
#[serde(default)]
|
||||
#[cfg_attr(feature = "python", pydantic(default = None))]
|
||||
pub operating_state: Option<OperatingState>,
|
||||
+ /// Auto-tuner status as a human-readable label (round 19 #10), when reported:
|
||||
+ /// e.g. "Stable"/"Tuning" (Braiins), "Optimized"/"Tuning"/"Off" (ePIC).
|
||||
+ pub tuner_status: Option<String>,
|
||||
/// The current pools configured on the miner
|
||||
pub pools: Vec<PoolGroupData>,
|
||||
/// Difficulty of the best share found over the miner's lifetime, when reported.
|
||||
diff --git a/vendor/asic-rs-core/src/traits/miner.rs b/vendor/asic-rs-core/src/traits/miner.rs
|
||||
index 25ea6168..397b2e8c 100644
|
||||
--- a/vendor/asic-rs-core/src/traits/miner.rs
|
||||
+++ b/vendor/asic-rs-core/src/traits/miner.rs
|
||||
@@ -290,6 +290,7 @@ impl<
|
||||
let light_flashing = self.parse_light_flashing(&data);
|
||||
let is_mining = self.parse_is_mining(&data);
|
||||
let operating_state = self.parse_operating_state(&data);
|
||||
+ let tuner_status = self.parse_tuner_status(&data);
|
||||
let messages = self.parse_messages(&data);
|
||||
let pools = self.parse_pools(&data);
|
||||
let best_share = self.parse_best_share(&data);
|
||||
@@ -392,6 +393,7 @@ impl<
|
||||
uptime,
|
||||
is_mining,
|
||||
operating_state,
|
||||
+ tuner_status,
|
||||
|
||||
pools,
|
||||
best_share,
|
||||
@@ -914,6 +916,18 @@ pub trait GetOperatingState: CollectData {
|
||||
fn parse_operating_state(&self, data: &HashMap<DataField, Value>) -> Option<OperatingState> {
|
||||
None
|
||||
}
|
||||
+ #[tracing::instrument(level = "debug")]
|
||||
+ async fn get_tuner_status(&self) -> Option<String> {
|
||||
+ let mut collector = self.get_collector();
|
||||
+ let data = collector.collect(&[DataField::TunerStatus]).await;
|
||||
+ self.parse_tuner_status(&data)
|
||||
+ }
|
||||
+ /// Auto-tuner status as a human-readable label. Backends that expose it override
|
||||
+ /// this; others return None.
|
||||
+ #[allow(unused_variables)]
|
||||
+ fn parse_tuner_status(&self, data: &HashMap<DataField, Value>) -> Option<String> {
|
||||
+ None
|
||||
+ }
|
||||
}
|
||||
|
||||
// Pools
|
||||
diff --git a/vendor/asic-rs-firmwares-braiins/src/backends/v25_07/mod.rs b/vendor/asic-rs-firmwares-braiins/src/backends/v25_07/mod.rs
|
||||
index 0dec8d38..f5937521 100644
|
||||
--- a/vendor/asic-rs-firmwares-braiins/src/backends/v25_07/mod.rs
|
||||
+++ b/vendor/asic-rs-firmwares-braiins/src/backends/v25_07/mod.rs
|
||||
@@ -272,6 +272,16 @@ impl GetDataLocations for BraiinsV2507 {
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
+ // Auto-tuner status (round 19 #10, T3): performance/tuner-state
|
||||
+ // overall_tuner_state enum; command already fetched.
|
||||
+ DataField::TunerStatus => vec![(
|
||||
+ WEB_PERFORMANCE_TUNER_STATE,
|
||||
+ DataExtractor {
|
||||
+ func: get_by_pointer,
|
||||
+ key: Some("/overall_tuner_state"),
|
||||
+ tag: None,
|
||||
+ },
|
||||
+ )],
|
||||
DataField::Uptime => vec![(
|
||||
WEB_MINER_DETAILS,
|
||||
DataExtractor {
|
||||
@@ -630,6 +640,21 @@ impl GetOperatingState for BraiinsV2507 {
|
||||
},
|
||||
})
|
||||
}
|
||||
+ fn parse_tuner_status(&self, data: &HashMap<DataField, Value>) -> Option<String> {
|
||||
+ // BOS+ TunerState enum (bos-plus-api performance.proto): 1 Disabled,
|
||||
+ // 2 Stable, 3 Tuning, 4 Error, 5 Continuous, 6 Preheat (round 19 #10, T3).
|
||||
+ Some(match data.get(&DataField::TunerStatus)?.as_u64()? {
|
||||
+ 0 => return None,
|
||||
+ 1 => "Disabled",
|
||||
+ 2 => "Stable",
|
||||
+ 3 => "Tuning",
|
||||
+ 4 => "Error",
|
||||
+ 5 => "Continuous",
|
||||
+ 6 => "Preheat",
|
||||
+ _ => return None,
|
||||
+ })
|
||||
+ .map(str::to_string)
|
||||
+ }
|
||||
}
|
||||
|
||||
impl GetIsMining for BraiinsV2507 {
|
||||
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 4e423e5b..07afc871 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
|
||||
@@ -275,6 +275,16 @@ impl GetDataLocations for BraiinsV2604 {
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
+ // Auto-tuner status (round 19 #10, T3): performance/tuner-state
|
||||
+ // overall_tuner_state enum; command already fetched.
|
||||
+ DataField::TunerStatus => vec![(
|
||||
+ WEB_PERFORMANCE_TUNER_STATE,
|
||||
+ DataExtractor {
|
||||
+ func: get_by_pointer,
|
||||
+ key: Some("/overall_tuner_state"),
|
||||
+ tag: None,
|
||||
+ },
|
||||
+ )],
|
||||
DataField::Uptime => vec![(
|
||||
WEB_MINER_DETAILS,
|
||||
DataExtractor {
|
||||
@@ -667,6 +677,21 @@ impl GetOperatingState for BraiinsV2604 {
|
||||
},
|
||||
})
|
||||
}
|
||||
+ fn parse_tuner_status(&self, data: &HashMap<DataField, Value>) -> Option<String> {
|
||||
+ // BOS+ TunerState enum (bos-plus-api performance.proto): 1 Disabled,
|
||||
+ // 2 Stable, 3 Tuning, 4 Error, 5 Continuous, 6 Preheat (round 19 #10, T3).
|
||||
+ Some(match data.get(&DataField::TunerStatus)?.as_u64()? {
|
||||
+ 0 => return None,
|
||||
+ 1 => "Disabled",
|
||||
+ 2 => "Stable",
|
||||
+ 3 => "Tuning",
|
||||
+ 4 => "Error",
|
||||
+ 5 => "Continuous",
|
||||
+ 6 => "Preheat",
|
||||
+ _ => return None,
|
||||
+ })
|
||||
+ .map(str::to_string)
|
||||
+ }
|
||||
}
|
||||
|
||||
impl GetIsMining for BraiinsV2604 {
|
||||
@@ -1353,6 +1378,8 @@ mod tests {
|
||||
assert_eq!(miner_data.temp_target, Some(60.0));
|
||||
assert_eq!(miner_data.temp_hot, Some(80.0));
|
||||
assert_eq!(miner_data.temp_dangerous, Some(90.0));
|
||||
+ // Auto-tuner status: overall_tuner_state 5 -> Continuous (round 19 #10, T3).
|
||||
+ assert_eq!(miner_data.tuner_status.as_deref(), Some("Continuous"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
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 2e12e07a..e0df43e3 100644
|
||||
--- a/vendor/asic-rs-firmwares-epic/src/backends/v1/mod.rs
|
||||
+++ b/vendor/asic-rs-firmwares-epic/src/backends/v1/mod.rs
|
||||
@@ -594,6 +594,16 @@ impl GetDataLocations for PowerPlayV1 {
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
+ // Auto-tuner status (round 19 #10, T3): PowerPlay PerpetualTune; summary
|
||||
+ // already fetched.
|
||||
+ DataField::TunerStatus => vec![(
|
||||
+ WEB_SUMMARY,
|
||||
+ DataExtractor {
|
||||
+ func: get_by_pointer,
|
||||
+ key: Some("/PerpetualTune"),
|
||||
+ tag: None,
|
||||
+ },
|
||||
+ )],
|
||||
DataField::LightFlashing => vec![(
|
||||
WEB_SUMMARY,
|
||||
DataExtractor {
|
||||
@@ -1408,6 +1418,28 @@ impl GetOperatingState for PowerPlayV1 {
|
||||
.and_then(Value::as_str)
|
||||
.and_then(OperatingState::from_label)
|
||||
}
|
||||
+ fn parse_tuner_status(&self, data: &HashMap<DataField, Value>) -> Option<String> {
|
||||
+ // ePIC PerpetualTune: Running gates it; the per-algorithm Optimized flag
|
||||
+ // distinguishes a settled tune from an in-progress one (round 19 #10, T3).
|
||||
+ let pt = data.get(&DataField::TunerStatus)?;
|
||||
+ if !pt.pointer("/Running").and_then(|v| v.as_bool()).unwrap_or(false) {
|
||||
+ return Some("Off".to_string());
|
||||
+ }
|
||||
+ let optimized = pt
|
||||
+ .pointer("/Algorithm")
|
||||
+ .and_then(|v| v.as_object())
|
||||
+ .and_then(|algos| {
|
||||
+ algos
|
||||
+ .values()
|
||||
+ .filter_map(|a| a.pointer("/Optimized").and_then(|v| v.as_bool()))
|
||||
+ .next()
|
||||
+ });
|
||||
+ Some(match optimized {
|
||||
+ Some(true) => "Optimized",
|
||||
+ _ => "Tuning",
|
||||
+ })
|
||||
+ .map(str::to_string)
|
||||
+ }
|
||||
}
|
||||
|
||||
impl GetIsMining for PowerPlayV1 {
|
||||
@@ -2235,6 +2267,8 @@ mod tests {
|
||||
assert_eq!(miner_data.temp_target, None);
|
||||
assert_eq!(miner_data.temp_hot, Some(85.0));
|
||||
assert_eq!(miner_data.temp_dangerous, Some(100.0));
|
||||
+ // Auto-tuner: PerpetualTune Running=true, Optimized=false -> Tuning (T3).
|
||||
+ assert_eq!(miner_data.tuner_status.as_deref(), Some("Tuning"));
|
||||
assert_eq!(miner_data.hashboards.len(), 3);
|
||||
assert_eq!(miner_data.hashboards[0].active, Some(false));
|
||||
assert_eq!(miner_data.hashboards[1].chips.len(), 110);
|
||||
@@ -0,0 +1,283 @@
|
||||
Subject: [PATCH 0032] telemetry: vnish per-hashboard fault messages
|
||||
|
||||
Round 20 #1. VNish previously surfaced only a single miner-level state message
|
||||
(board 0, no component), so per-hashboard faults landed on the control-board
|
||||
(brain) tooltip instead of the board they name, and the Health column could not
|
||||
red the specific faulted hashboard.
|
||||
|
||||
- DataField::Messages now also collects /miner/chains from the summary (tagged),
|
||||
alongside /miner/miner_status (now tagged "miner_status"). The summary chains
|
||||
carry per-chain diagnostics the /chains endpoint omits: chip_statuses
|
||||
{red,orange,grey} and status.state.
|
||||
- parse_messages emits one MinerMessage per faulted board, attributed to
|
||||
MinerComponent::HashBoard { idx } (chain ids are 1-based; board positions
|
||||
0-based): red chip(s) -> Error, a non-normal chain state with no failed chips
|
||||
-> Error (state text), orange chip(s) -> Warning. Healthy boards (all grey,
|
||||
state "mining") produce no message, so no false faults on good miners.
|
||||
- Applied to both v1_3_0 and v1_2_0 backends. Verified live against healthy
|
||||
WildRose/VNish S21 miners (10.7.1.x): all chains grey/mining -> zero messages.
|
||||
|
||||
diff --git a/vendor/asic-rs-firmwares-vnish/src/backends/v1_2_0/mod.rs b/vendor/asic-rs-firmwares-vnish/src/backends/v1_2_0/mod.rs
|
||||
index ad2779b6..85011853 100644
|
||||
--- a/vendor/asic-rs-firmwares-vnish/src/backends/v1_2_0/mod.rs
|
||||
+++ b/vendor/asic-rs-firmwares-vnish/src/backends/v1_2_0/mod.rs
|
||||
@@ -20,7 +20,7 @@ use asic_rs_core::{
|
||||
device::DeviceInfo,
|
||||
fan::FanData,
|
||||
hashrate::{HashRate, HashRateUnit},
|
||||
- message::{MessageSeverity, MinerMessage},
|
||||
+ message::{MessageSeverity, MinerComponent, MinerMessage},
|
||||
miner::TuningTarget,
|
||||
operating_state::OperatingState,
|
||||
pool::{PoolData, PoolGroupData, PoolURL},
|
||||
@@ -353,14 +353,26 @@ impl GetDataLocations for VnishV120 {
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
- DataField::Messages => vec![(
|
||||
- WEB_SUMMARY,
|
||||
- DataExtractor {
|
||||
- func: get_by_pointer,
|
||||
- key: Some("/miner/miner_status"),
|
||||
- tag: None,
|
||||
- },
|
||||
- )],
|
||||
+ DataField::Messages => vec![
|
||||
+ (
|
||||
+ WEB_SUMMARY,
|
||||
+ DataExtractor {
|
||||
+ func: get_by_pointer,
|
||||
+ key: Some("/miner/miner_status"),
|
||||
+ tag: Some("miner_status"),
|
||||
+ },
|
||||
+ ),
|
||||
+ // Per-hashboard diagnostics (chip status buckets + per-chain state)
|
||||
+ // for per-board fault messages in parse_messages.
|
||||
+ (
|
||||
+ WEB_SUMMARY,
|
||||
+ DataExtractor {
|
||||
+ func: get_by_pointer,
|
||||
+ key: Some("/miner/chains"),
|
||||
+ tag: Some("chains"),
|
||||
+ },
|
||||
+ ),
|
||||
+ ],
|
||||
DataField::TuningTarget => vec![(
|
||||
WEB_SETTINGS,
|
||||
DataExtractor {
|
||||
@@ -850,9 +862,12 @@ impl GetMessages for VnishV120 {
|
||||
/// reported here rather than computed from invented thresholds.
|
||||
fn parse_messages(&self, data: &HashMap<DataField, Value>) -> Vec<MinerMessage> {
|
||||
let mut messages = Vec::new();
|
||||
+ let msg = data.get(&DataField::Messages);
|
||||
|
||||
- if let Some(status) = data.get(&DataField::Messages)
|
||||
- && let Some(state) = status.pointer("/miner_state").and_then(|v| v.as_str())
|
||||
+ // Miner-level state verdict (now under the "miner_status" tag).
|
||||
+ if let Some(state) = msg
|
||||
+ .and_then(|v| v.pointer("/miner_status/miner_state"))
|
||||
+ .and_then(|v| v.as_str())
|
||||
{
|
||||
let normal = matches!(
|
||||
state.to_lowercase().as_str(),
|
||||
@@ -872,6 +887,68 @@ impl GetMessages for VnishV120 {
|
||||
}
|
||||
}
|
||||
|
||||
+ // Per-hashboard faults from the summary chains (round 20 #1). VNish reports
|
||||
+ // per-chip status buckets (`red` = failed, `orange` = degraded, `grey` =
|
||||
+ // healthy) and a per-chain state; attribute each fault to its own board so
|
||||
+ // the Health column reds the right hashboard icon and that icon's tooltip
|
||||
+ // carries the specific fault, instead of everything landing on the miner-
|
||||
+ // level (brain) message. Chain ids are 1-based; board positions are 0-based.
|
||||
+ if let Some(chains) = msg
|
||||
+ .and_then(|v| v.pointer("/chains"))
|
||||
+ .and_then(|v| v.as_array())
|
||||
+ {
|
||||
+ for chain in chains {
|
||||
+ let Some(id) = chain.pointer("/id").and_then(|v| v.as_u64()) else {
|
||||
+ continue;
|
||||
+ };
|
||||
+ let idx = id.saturating_sub(1) as u16;
|
||||
+ let red = chain
|
||||
+ .pointer("/chip_statuses/red")
|
||||
+ .and_then(|v| v.as_u64())
|
||||
+ .unwrap_or(0);
|
||||
+ let orange = chain
|
||||
+ .pointer("/chip_statuses/orange")
|
||||
+ .and_then(|v| v.as_u64())
|
||||
+ .unwrap_or(0);
|
||||
+ let state = chain
|
||||
+ .pointer("/status/state")
|
||||
+ .and_then(|v| v.as_str())
|
||||
+ .unwrap_or("");
|
||||
+ let state_ok = matches!(
|
||||
+ state.to_lowercase().as_str(),
|
||||
+ "" | "mining" | "auto-tuning" | "auto_tuning" | "tuning"
|
||||
+ );
|
||||
+
|
||||
+ if red > 0 {
|
||||
+ messages.push(MinerMessage::with_component(
|
||||
+ 0,
|
||||
+ 0,
|
||||
+ format!("Hashboard {id}: {red} failed chip(s)"),
|
||||
+ MessageSeverity::Error,
|
||||
+ Some(MinerComponent::hashboard(idx)),
|
||||
+ ));
|
||||
+ } else if !state_ok {
|
||||
+ // A board not in a normal state but with no failed chips: report
|
||||
+ // the state itself (e.g. "initializing", "disabled", "stopped").
|
||||
+ messages.push(MinerMessage::with_component(
|
||||
+ 0,
|
||||
+ 0,
|
||||
+ format!("Hashboard {id}: {state}"),
|
||||
+ MessageSeverity::Error,
|
||||
+ Some(MinerComponent::hashboard(idx)),
|
||||
+ ));
|
||||
+ } else if orange > 0 {
|
||||
+ messages.push(MinerMessage::with_component(
|
||||
+ 0,
|
||||
+ 0,
|
||||
+ format!("Hashboard {id}: {orange} degraded chip(s)"),
|
||||
+ MessageSeverity::Warning,
|
||||
+ Some(MinerComponent::hashboard(idx)),
|
||||
+ ));
|
||||
+ }
|
||||
+ }
|
||||
+ }
|
||||
+
|
||||
messages
|
||||
}
|
||||
}
|
||||
diff --git a/vendor/asic-rs-firmwares-vnish/src/backends/v1_3_0/mod.rs b/vendor/asic-rs-firmwares-vnish/src/backends/v1_3_0/mod.rs
|
||||
index 4f0453a1..1301a657 100644
|
||||
--- a/vendor/asic-rs-firmwares-vnish/src/backends/v1_3_0/mod.rs
|
||||
+++ b/vendor/asic-rs-firmwares-vnish/src/backends/v1_3_0/mod.rs
|
||||
@@ -20,7 +20,7 @@ use asic_rs_core::{
|
||||
device::DeviceInfo,
|
||||
fan::FanData,
|
||||
hashrate::{HashRate, HashRateUnit},
|
||||
- message::{MessageSeverity, MinerMessage},
|
||||
+ message::{MessageSeverity, MinerComponent, MinerMessage},
|
||||
miner::TuningTarget,
|
||||
operating_state::OperatingState,
|
||||
pool::{PoolData, PoolGroupData, PoolURL},
|
||||
@@ -351,14 +351,26 @@ impl GetDataLocations for VnishV130 {
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
- DataField::Messages => vec![(
|
||||
- WEB_SUMMARY,
|
||||
- DataExtractor {
|
||||
- func: get_by_pointer,
|
||||
- key: Some("/miner/miner_status"),
|
||||
- tag: None,
|
||||
- },
|
||||
- )],
|
||||
+ DataField::Messages => vec![
|
||||
+ (
|
||||
+ WEB_SUMMARY,
|
||||
+ DataExtractor {
|
||||
+ func: get_by_pointer,
|
||||
+ key: Some("/miner/miner_status"),
|
||||
+ tag: Some("miner_status"),
|
||||
+ },
|
||||
+ ),
|
||||
+ // Per-hashboard diagnostics (chip status buckets + per-chain state)
|
||||
+ // for per-board fault messages in parse_messages.
|
||||
+ (
|
||||
+ WEB_SUMMARY,
|
||||
+ DataExtractor {
|
||||
+ func: get_by_pointer,
|
||||
+ key: Some("/miner/chains"),
|
||||
+ tag: Some("chains"),
|
||||
+ },
|
||||
+ ),
|
||||
+ ],
|
||||
DataField::TuningPercent => vec![(
|
||||
WEB_SUMMARY,
|
||||
DataExtractor {
|
||||
@@ -805,9 +817,12 @@ impl GetMessages for VnishV130 {
|
||||
/// reported here rather than computed from invented thresholds.
|
||||
fn parse_messages(&self, data: &HashMap<DataField, Value>) -> Vec<MinerMessage> {
|
||||
let mut messages = Vec::new();
|
||||
+ let msg = data.get(&DataField::Messages);
|
||||
|
||||
- if let Some(status) = data.get(&DataField::Messages)
|
||||
- && let Some(state) = status.pointer("/miner_state").and_then(|v| v.as_str())
|
||||
+ // Miner-level state verdict (now under the "miner_status" tag).
|
||||
+ if let Some(state) = msg
|
||||
+ .and_then(|v| v.pointer("/miner_status/miner_state"))
|
||||
+ .and_then(|v| v.as_str())
|
||||
{
|
||||
let normal = matches!(
|
||||
state.to_lowercase().as_str(),
|
||||
@@ -827,6 +842,68 @@ impl GetMessages for VnishV130 {
|
||||
}
|
||||
}
|
||||
|
||||
+ // Per-hashboard faults from the summary chains (round 20 #1). VNish reports
|
||||
+ // per-chip status buckets (`red` = failed, `orange` = degraded, `grey` =
|
||||
+ // healthy) and a per-chain state; attribute each fault to its own board so
|
||||
+ // the Health column reds the right hashboard icon and that icon's tooltip
|
||||
+ // carries the specific fault, instead of everything landing on the miner-
|
||||
+ // level (brain) message. Chain ids are 1-based; board positions are 0-based.
|
||||
+ if let Some(chains) = msg
|
||||
+ .and_then(|v| v.pointer("/chains"))
|
||||
+ .and_then(|v| v.as_array())
|
||||
+ {
|
||||
+ for chain in chains {
|
||||
+ let Some(id) = chain.pointer("/id").and_then(|v| v.as_u64()) else {
|
||||
+ continue;
|
||||
+ };
|
||||
+ let idx = id.saturating_sub(1) as u16;
|
||||
+ let red = chain
|
||||
+ .pointer("/chip_statuses/red")
|
||||
+ .and_then(|v| v.as_u64())
|
||||
+ .unwrap_or(0);
|
||||
+ let orange = chain
|
||||
+ .pointer("/chip_statuses/orange")
|
||||
+ .and_then(|v| v.as_u64())
|
||||
+ .unwrap_or(0);
|
||||
+ let state = chain
|
||||
+ .pointer("/status/state")
|
||||
+ .and_then(|v| v.as_str())
|
||||
+ .unwrap_or("");
|
||||
+ let state_ok = matches!(
|
||||
+ state.to_lowercase().as_str(),
|
||||
+ "" | "mining" | "auto-tuning" | "auto_tuning" | "tuning"
|
||||
+ );
|
||||
+
|
||||
+ if red > 0 {
|
||||
+ messages.push(MinerMessage::with_component(
|
||||
+ 0,
|
||||
+ 0,
|
||||
+ format!("Hashboard {id}: {red} failed chip(s)"),
|
||||
+ MessageSeverity::Error,
|
||||
+ Some(MinerComponent::hashboard(idx)),
|
||||
+ ));
|
||||
+ } else if !state_ok {
|
||||
+ // A board not in a normal state but with no failed chips: report
|
||||
+ // the state itself (e.g. "initializing", "disabled", "stopped").
|
||||
+ messages.push(MinerMessage::with_component(
|
||||
+ 0,
|
||||
+ 0,
|
||||
+ format!("Hashboard {id}: {state}"),
|
||||
+ MessageSeverity::Error,
|
||||
+ Some(MinerComponent::hashboard(idx)),
|
||||
+ ));
|
||||
+ } else if orange > 0 {
|
||||
+ messages.push(MinerMessage::with_component(
|
||||
+ 0,
|
||||
+ 0,
|
||||
+ format!("Hashboard {id}: {orange} degraded chip(s)"),
|
||||
+ MessageSeverity::Warning,
|
||||
+ Some(MinerComponent::hashboard(idx)),
|
||||
+ ));
|
||||
+ }
|
||||
+ }
|
||||
+ }
|
||||
+
|
||||
messages
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,39 @@
|
||||
Subject: [PATCH 0005] health tooltips: convert tip area to widget coordinates
|
||||
|
||||
Round 19 #2 (the real fix). The GtkTreeView "query-tooltip" handler for the Health
|
||||
column set a per-icon tip area from gtk_tree_view_get_cell_area, whose rectangle is
|
||||
in BIN-WINDOW coordinates, but gtk_tooltip_set_tip_area expects WIDGET coordinates.
|
||||
The area was therefore offset upward by the column-header height, so it did not
|
||||
contain the pointer -- and GTK suppresses a tooltip whose tip area excludes the
|
||||
cursor. That is why the health icon tooltips never appeared, while the Errors column
|
||||
(which sets no tip area) worked. Convert the slot rectangle back to widget
|
||||
coordinates with gtk_tree_view_convert_bin_window_to_widget_coords before setting it.
|
||||
|
||||
diff --git a/cpp_src/widgets_bridge.cpp b/cpp_src/widgets_bridge.cpp
|
||||
index ba9f1c04..6d09ccb7 100644
|
||||
--- a/cpp_src/widgets_bridge.cpp
|
||||
+++ b/cpp_src/widgets_bridge.cpp
|
||||
@@ -1019,9 +1019,21 @@ static gboolean dvlc_query_tooltip(GtkWidget* tv, gint x, gint y, gboolean keybo
|
||||
// or moves the tooltip as the pointer crosses from one icon to the next -- the
|
||||
// old tooltip just stays put with stale text. Setting a per-slot area makes GTK
|
||||
// hide + re-show + reposition the tooltip for each icon.
|
||||
+ //
|
||||
+ // CRITICAL (round 19 #2, the reason the health tooltips never showed): the slot
|
||||
+ // geometry above (block_left, crect) is in BIN-WINDOW coordinates (what
|
||||
+ // gtk_tree_view_get_cell_area and get_path_at_pos use), but
|
||||
+ // gtk_tooltip_set_tip_area expects WIDGET coordinates. Feeding it bin-window
|
||||
+ // coords offsets the area upward by the header height, so it does not contain
|
||||
+ // the pointer -- and GTK then suppresses the tooltip entirely (it only shows a
|
||||
+ // tooltip whose tip area contains the cursor). The Errors column worked because
|
||||
+ // it sets no tip area. Convert the slot rect back to widget coordinates.
|
||||
+ gint area_wx = 0, area_wy = 0;
|
||||
+ gtk_tree_view_convert_bin_window_to_widget_coords(
|
||||
+ GTK_TREE_VIEW(tv), block_left + slot * adv, crect.y, &area_wx, &area_wy);
|
||||
GdkRectangle area;
|
||||
- area.x = block_left + slot * adv;
|
||||
- area.y = crect.y;
|
||||
+ area.x = area_wx;
|
||||
+ area.y = area_wy;
|
||||
area.width = adv;
|
||||
area.height = crect.height;
|
||||
gtk_tooltip_set_tip_area(tooltip, &area);
|
||||
@@ -351,13 +351,16 @@ int DrawShape(wxDC* dc, wxUniChar shape, wxCoord x, const wxRect& cell,
|
||||
const wxBitmap& bmp = ShapeBitmap(shape, *sv, colour, dw, dh);
|
||||
if (bmp.IsOk()) {
|
||||
if (health) {
|
||||
// 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;
|
||||
// UNIFORM fixed-width slot (round 19): every health icon (and the
|
||||
// alignment gap) advances by the same amount -- the square (h - 3) -- so
|
||||
// power/control/fan/board icons line up in fixed columns across rows
|
||||
// regardless of each glyph's aspect ratio (a narrow bolt or a shrunk fan
|
||||
// no longer shifts the icons after it). Each glyph is centred in its slot.
|
||||
// This matches SHAPE_GAP's advance and the per-icon tooltip hit-test.
|
||||
int adv = h - 3;
|
||||
if (adv < 1) adv = 1;
|
||||
dc->DrawBitmap(bmp, x + (adv - dw) / 2, cy - dh / 2, true);
|
||||
return adv;
|
||||
}
|
||||
int slot = (w > SHAPE_ADVANCE) ? w : SHAPE_ADVANCE;
|
||||
dc->DrawBitmap(bmp, x + (slot - w) / 2, cy - h / 2, true);
|
||||
@@ -452,7 +455,13 @@ class SegmentRenderer : public wxDataViewCustomRenderer {
|
||||
wxRect bg = cell;
|
||||
if (wxDataViewColumn* owner = const_cast<SegmentRenderer*>(this)->GetOwner()) {
|
||||
int cw = owner->GetWidth();
|
||||
if (cw > bg.width) bg.width = cw;
|
||||
// Extend BOTH directions by the column width. For a right-aligned column
|
||||
// (round 19 #21) wx anchors `cell` at the content's left edge (near the
|
||||
// column's right side), so extending only rightward left the column's left
|
||||
// portion unstriped; over-spanning both sides and letting the cell-DC clip
|
||||
// trim it fills the whole cell regardless of alignment (round 19 review M1).
|
||||
bg.x -= cw;
|
||||
bg.width += 2 * cw;
|
||||
}
|
||||
bg.y -= 40;
|
||||
bg.height += 80;
|
||||
@@ -535,7 +544,10 @@ class SegmentRenderer : public wxDataViewCustomRenderer {
|
||||
} 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;
|
||||
// UNIFORM fixed-width slot (round 19), matching DrawShape + the gap, so
|
||||
// every health icon lines up in fixed columns across rows regardless of
|
||||
// its glyph aspect. Width is measured square (hh - 3), not per-glyph.
|
||||
adv = hh - 3;
|
||||
if (adv < 1) adv = 1;
|
||||
} else if (ww > adv) {
|
||||
adv = ww;
|
||||
@@ -975,7 +987,10 @@ static gboolean dvlc_query_tooltip(GtkWidget* tv, gint x, gint y, gboolean keybo
|
||||
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).
|
||||
// Icon advance must match DrawShape's now-UNIFORM health-icon slot, which is
|
||||
// (row height - 1, capped at 28*zoom) - 3 for every glyph and gap alike. The
|
||||
// earlier per-glyph advance (w-3) shifted the hit slots so tooltips landed on
|
||||
// the wrong icon (round 19 #2); with the uniform slot the hit-test lines up.
|
||||
int h = crect.height - 1;
|
||||
int cap = (int)(28 * g_table_zoom + 0.5);
|
||||
if (cap < 8) cap = 8;
|
||||
@@ -983,11 +998,20 @@ static gboolean dvlc_query_tooltip(GtkWidget* tv, gint x, gint y, gboolean keybo
|
||||
if (h < 8) h = 8;
|
||||
int adv = h - 3;
|
||||
if (adv < 1) adv = 1;
|
||||
int off = bx - crect.x;
|
||||
int n = (int)iit->second.size();
|
||||
// A right-aligned column (round 19 #21) draws the icon block flush to the
|
||||
// cell's right edge, so measure the pointer from the block's left, not the
|
||||
// cell's left.
|
||||
int block_left = crect.x;
|
||||
if (wxcol->GetAlignment() == wxALIGN_RIGHT) {
|
||||
int content_w = n * adv;
|
||||
if (content_w < crect.width) block_left = crect.x + (crect.width - content_w);
|
||||
}
|
||||
int off = bx - block_left;
|
||||
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;
|
||||
if (slot >= n) slot = n - 1;
|
||||
const wxString& tip = iit->second[(size_t)slot];
|
||||
if (tip.IsEmpty()) return FALSE;
|
||||
// Scope the tooltip's "tip area" to just this icon's slot (round 18 #4a).
|
||||
@@ -995,9 +1019,21 @@ static gboolean dvlc_query_tooltip(GtkWidget* tv, gint x, gint y, gboolean keybo
|
||||
// or moves the tooltip as the pointer crosses from one icon to the next -- the
|
||||
// old tooltip just stays put with stale text. Setting a per-slot area makes GTK
|
||||
// hide + re-show + reposition the tooltip for each icon.
|
||||
//
|
||||
// CRITICAL (round 19 #2, the reason the health tooltips never showed): the slot
|
||||
// geometry above (block_left, crect) is in BIN-WINDOW coordinates (what
|
||||
// gtk_tree_view_get_cell_area and get_path_at_pos use), but
|
||||
// gtk_tooltip_set_tip_area expects WIDGET coordinates. Feeding it bin-window
|
||||
// coords offsets the area upward by the header height, so it does not contain
|
||||
// the pointer -- and GTK then suppresses the tooltip entirely (it only shows a
|
||||
// tooltip whose tip area contains the cursor). The Errors column worked because
|
||||
// it sets no tip area. Convert the slot rect back to widget coordinates.
|
||||
gint area_wx = 0, area_wy = 0;
|
||||
gtk_tree_view_convert_bin_window_to_widget_coords(
|
||||
GTK_TREE_VIEW(tv), block_left + slot * adv, crect.y, &area_wx, &area_wy);
|
||||
GdkRectangle area;
|
||||
area.x = crect.x + slot * adv;
|
||||
area.y = crect.y;
|
||||
area.x = area_wx;
|
||||
area.y = area_wy;
|
||||
area.width = adv;
|
||||
area.height = crect.height;
|
||||
gtk_tooltip_set_tip_area(tooltip, &area);
|
||||
@@ -1126,14 +1162,23 @@ void* wxbr_dvlc(void* parent) {
|
||||
return (void*)dv;
|
||||
}
|
||||
|
||||
void wxbr_dvlc_append_text_col(void* win, const char* title, int width, int reorderable) {
|
||||
// Map the bridge alignment code (0 left, 1 right, 2 centre) to a wxAlignment.
|
||||
static wxAlignment dvlc_wx_align(int align) {
|
||||
switch (align) {
|
||||
case 1: return wxALIGN_RIGHT;
|
||||
case 2: return wxALIGN_CENTER;
|
||||
default: return wxALIGN_NOT;
|
||||
}
|
||||
}
|
||||
|
||||
void wxbr_dvlc_append_text_col(void* win, const char* title, int width, int reorderable, int align) {
|
||||
wxDataViewCtrl* dv = (wxDataViewCtrl*)win;
|
||||
int flags = wxDATAVIEW_COL_RESIZABLE;
|
||||
if (reorderable) flags |= wxDATAVIEW_COL_REORDERABLE;
|
||||
unsigned col = dv->GetColumnCount(); // next model column index
|
||||
dvlc_store(win)->AppendColumn("string");
|
||||
dv->AppendTextColumn(wxString::FromUTF8(title), col, wxDATAVIEW_CELL_INERT,
|
||||
width, wxALIGN_NOT, flags);
|
||||
width, dvlc_wx_align(align), flags);
|
||||
// Record the 100% column width for the zoom (round 14 #3); the first column of
|
||||
// a (re)built table resets the list.
|
||||
if (col == 0) g_zoom_base_w.clear();
|
||||
@@ -1144,15 +1189,17 @@ void wxbr_dvlc_append_text_col(void* win, const char* title, int width, int reor
|
||||
// SegmentRenderer so its cell values can carry the '\x1f'/'\x1e' colour-run
|
||||
// encoding produced by alkane_gui::model::encode_segments. An ordinary string
|
||||
// with no encoding in it still renders fine (single default-coloured run).
|
||||
void* wxbr_dvlc_append_colored_col(void* win, const char* title, int width, int reorderable) {
|
||||
void* wxbr_dvlc_append_colored_col(void* win, const char* title, int width, int reorderable, int align) {
|
||||
wxDataViewCtrl* dv = (wxDataViewCtrl*)win;
|
||||
int flags = wxDATAVIEW_COL_RESIZABLE;
|
||||
if (reorderable) flags |= wxDATAVIEW_COL_REORDERABLE;
|
||||
unsigned col = dv->GetColumnCount(); // next model column index
|
||||
dvlc_store(win)->AppendColumn("string");
|
||||
SegmentRenderer* renderer = new SegmentRenderer();
|
||||
wxAlignment al = dvlc_wx_align(align);
|
||||
renderer->SetAlignment(al);
|
||||
wxDataViewColumn* c = new wxDataViewColumn(wxString::FromUTF8(title), renderer, col,
|
||||
width, wxALIGN_NOT, flags);
|
||||
width, al, flags);
|
||||
dv->AppendColumn(c);
|
||||
// Record the 100% column width for the zoom (round 14 #3).
|
||||
if (col == 0) g_zoom_base_w.clear();
|
||||
|
||||
@@ -7,6 +7,11 @@
|
||||
use std::ffi::CString;
|
||||
use std::os::raw::{c_char, c_int, c_long, c_void};
|
||||
|
||||
/// Column alignment for `dvlc_append_text_col` / `dvlc_append_colored_col`.
|
||||
pub const ALIGN_LEFT: i32 = 0;
|
||||
pub const ALIGN_RIGHT: i32 = 1;
|
||||
pub const ALIGN_CENTER: i32 = 2;
|
||||
|
||||
mod notsafe {
|
||||
use std::os::raw::{c_char, c_int, c_long, c_void};
|
||||
|
||||
@@ -56,8 +61,8 @@ mod notsafe {
|
||||
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;
|
||||
pub fn wxbr_dvlc_append_text_col(win: *mut c_void, title: *const c_char, width: c_int, reorderable: c_int, align: c_int);
|
||||
pub fn wxbr_dvlc_append_colored_col(win: *mut c_void, title: *const c_char, width: c_int, reorderable: c_int, align: c_int) -> *mut c_void;
|
||||
pub fn wxbr_dvlc_append_toggle_col(win: *mut c_void, width: c_int);
|
||||
pub fn wxbr_dvlc_append_row(win: *mut c_void, nvals: c_int, vals: *const *const c_char);
|
||||
pub fn wxbr_dvlc_delete_row(win: *mut c_void, row: usize);
|
||||
@@ -577,17 +582,23 @@ impl Widget {
|
||||
Widget(unsafe { notsafe::wxbr_dvlc(parent.0) })
|
||||
}
|
||||
|
||||
pub fn dvlc_append_text_col(&self, title: &str, width: i32, reorderable: bool) {
|
||||
/// Append a text column. `align` is the cell + header alignment:
|
||||
/// [`ALIGN_LEFT`] (0), [`ALIGN_RIGHT`] (1) or [`ALIGN_CENTER`] (2).
|
||||
pub fn dvlc_append_text_col(&self, title: &str, width: i32, reorderable: bool, align: i32) {
|
||||
let c = CString::new(title).unwrap_or_default();
|
||||
unsafe { notsafe::wxbr_dvlc_append_text_col(self.0, c.as_ptr(), width, reorderable as c_int) }
|
||||
unsafe {
|
||||
notsafe::wxbr_dvlc_append_text_col(self.0, c.as_ptr(), width, reorderable as c_int, align)
|
||||
}
|
||||
}
|
||||
|
||||
/// Like `dvlc_append_text_col`, but the column renders cell values through
|
||||
/// the SegmentRenderer, so a value built with `model::encode_segments` is
|
||||
/// drawn as coloured text runs (a plain string still renders normally).
|
||||
pub fn dvlc_append_colored_col(&self, title: &str, width: i32, reorderable: bool) {
|
||||
pub fn dvlc_append_colored_col(&self, title: &str, width: i32, reorderable: bool, align: i32) {
|
||||
let c = CString::new(title).unwrap_or_default();
|
||||
unsafe { notsafe::wxbr_dvlc_append_colored_col(self.0, c.as_ptr(), width, reorderable as c_int) };
|
||||
unsafe {
|
||||
notsafe::wxbr_dvlc_append_colored_col(self.0, c.as_ptr(), width, reorderable as c_int, align)
|
||||
};
|
||||
}
|
||||
|
||||
pub fn dvlc_append_toggle_col(&self, width: i32) {
|
||||
|
||||
@@ -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":"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"}
|
||||
{"$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":"0f2547d5763225a3c5387da695de52b65c38eeb7942d14ecef36a72388c7a451","src/data/capabilities.rs":"29cbab6262fb8888b30b4674a30ef03983e005b4e18eefddfbbf9c568e1e1e17","src/data/collector.rs":"b0ea657174d7259a7e9d9c232e707293940a4cce2558e1976dbf6ec5c726fe71","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":"037a4cce611c9dafb03eb18c4d088c42df5a9bf23f376c0436aded7a3d657b0d","src/data/message.rs":"7b399ab1a0b6e43e61a5461d29a2752beed2d1fd7b214eb891572f8994d47c11","src/data/miner.rs":"7a0d2a7ce07ac5480ca0e1e80549828220df7802077f735cd334f6f21f0e0112","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":"99adfa10cfc59e245f41f77c70951e7aac5b3422e48abd270c56c3db122bbb6d","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":"1adf2f76b04fcaf0a4042f055eab07b2c87ea76fb8856a3c6741defa98e1f354","src/traits/mod.rs":"61406c4d2603299e4bad57c6f90115cadf93cee50a857bbfbb00d99f3a6873ac","src/traits/model.rs":"efde2b5cae4c4f018436bb68b236f354b5a733f7dafdeaf3f1c534b469a22d64","src/util.rs":"53255c65e85b97236cb34b452e2cb522edf377f49d2232645e0e0e33c447bb23"},"package":"1f25e625fc4c645ce995c5609a9fdff6f047d6a5e4d6be9dc167999a43197f58"}
|
||||
@@ -90,6 +90,12 @@ pub struct BoardData {
|
||||
pub tuned: Option<bool>,
|
||||
/// Whether this board is enabled and actively mining
|
||||
pub active: Option<bool>,
|
||||
/// The ASIC chip type/model on this board (e.g. "BM1370"), when reported.
|
||||
/// Not exposed by Antminer/LuxOS (their network API reports only the control
|
||||
/// board type).
|
||||
pub chip_type: Option<String>,
|
||||
/// The hashboard model / part identifier (e.g. "A3HB70601"), when reported.
|
||||
pub hashboard_model: Option<String>,
|
||||
}
|
||||
|
||||
impl BoardData {
|
||||
|
||||
@@ -56,9 +56,21 @@ pub enum DataField {
|
||||
/// Expected hashrate for the miner.
|
||||
#[cfg_attr(feature = "python", pydantic(value = "ExpectedHashrate"))]
|
||||
ExpectedHashrate,
|
||||
/// Rolling average hashrate windows (1m/5m/15m/24h) reported by the miner.
|
||||
#[cfg_attr(feature = "python", pydantic(value = "HashrateAverages"))]
|
||||
HashrateAverages,
|
||||
/// Fan speed or fan configuration.
|
||||
#[cfg_attr(feature = "python", pydantic(value = "Fans"))]
|
||||
Fans,
|
||||
/// Miner-level fan duty cycle as a percentage (0-100).
|
||||
#[cfg_attr(feature = "python", pydantic(value = "FanSpeedPercent"))]
|
||||
FanSpeedPercent,
|
||||
/// Board temperature safety thresholds (critical / shutdown), in Celsius.
|
||||
#[cfg_attr(feature = "python", pydantic(value = "TemperatureLimits"))]
|
||||
TemperatureLimits,
|
||||
/// Auto-tuner status (a human-readable label, e.g. "Stable", "Tuning").
|
||||
#[cfg_attr(feature = "python", pydantic(value = "TunerStatus"))]
|
||||
TunerStatus,
|
||||
/// PSU fan speed or configuration.
|
||||
#[cfg_attr(feature = "python", pydantic(value = "PsuFans"))]
|
||||
PsuFans,
|
||||
@@ -108,6 +120,9 @@ pub enum DataField {
|
||||
/// Difficulty of the best share found over the miner's lifetime, when reported.
|
||||
#[cfg_attr(feature = "python", pydantic(value = "BestShare"))]
|
||||
BestShare,
|
||||
/// Cumulative share statistics (difficulty accepted/rejected, stale, blocks).
|
||||
#[cfg_attr(feature = "python", pydantic(value = "ShareSummary"))]
|
||||
ShareSummary,
|
||||
/// Difficulty of the best share found since the last boot or hashing start, when reported.
|
||||
#[cfg_attr(feature = "python", pydantic(value = "SessionBestShare"))]
|
||||
SessionBestShare,
|
||||
|
||||
@@ -318,3 +318,32 @@ impl Div<HashRate> for Power {
|
||||
self.as_watts() / hash_rate.value
|
||||
}
|
||||
}
|
||||
|
||||
/// Rolling average hashrate over standard time windows, as reported by firmware.
|
||||
///
|
||||
/// Each window is optional; a backend fills in only the windows its firmware
|
||||
/// exposes. The 24h window is reported by Braiins only. Every value carries the
|
||||
/// same unit and mining algorithm as the miner's current hashrate.
|
||||
#[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 HashrateAverages {
|
||||
/// Average hashrate over the last minute, when reported.
|
||||
pub avg_1m: Option<HashRate>,
|
||||
/// Average hashrate over the last 5 minutes, when reported.
|
||||
pub avg_5m: Option<HashRate>,
|
||||
/// Average hashrate over the last 15 minutes, when reported.
|
||||
pub avg_15m: Option<HashRate>,
|
||||
/// Average hashrate over the last 24 hours, when reported (Braiins only).
|
||||
pub avg_24h: Option<HashRate>,
|
||||
}
|
||||
|
||||
impl HashrateAverages {
|
||||
/// True when no window is populated.
|
||||
pub fn is_empty(&self) -> bool {
|
||||
self.avg_1m.is_none()
|
||||
&& self.avg_5m.is_none()
|
||||
&& self.avg_15m.is_none()
|
||||
&& self.avg_24h.is_none()
|
||||
}
|
||||
}
|
||||
|
||||
@@ -12,11 +12,12 @@ use super::{
|
||||
capabilities::TuningCapabilities,
|
||||
device::DeviceInfo,
|
||||
fan::FanData,
|
||||
hashrate::HashRate,
|
||||
hashrate::{HashRate, HashrateAverages},
|
||||
message::MinerMessage,
|
||||
operating_state::OperatingState,
|
||||
pool::PoolGroupData,
|
||||
psu::PsuInfo,
|
||||
share::ShareSummary,
|
||||
};
|
||||
use crate::data::{
|
||||
deserialize::deserialize_macaddr,
|
||||
@@ -165,6 +166,8 @@ pub struct MinerData {
|
||||
pub hashboards: Vec<BoardData>,
|
||||
/// The current hashrate of the miner
|
||||
pub hashrate: Option<HashRate>,
|
||||
/// Rolling average hashrate windows (1m/5m/15m/24h), when reported
|
||||
pub hashrate_averages: Option<HashrateAverages>,
|
||||
/// The expected hashrate of the miner
|
||||
pub expected_hashrate: Option<HashRate>,
|
||||
/// The total expected number of chips across all boards on this miner
|
||||
@@ -175,6 +178,15 @@ pub struct MinerData {
|
||||
pub expected_fans: Option<u8>,
|
||||
/// The current fan information for the miner
|
||||
pub fans: Vec<FanData>,
|
||||
/// Miner-level fan duty cycle as a percentage (0-100), when reported. Firmware
|
||||
/// exposes no maximum RPM, so this duty cycle is the normalized fan indicator.
|
||||
pub fan_speed_percent: Option<f64>,
|
||||
/// Board target temperature threshold in Celsius, when reported (round 19 #10).
|
||||
pub temp_target: Option<f64>,
|
||||
/// Board hot temperature threshold in Celsius, when reported (round 19 #10).
|
||||
pub temp_hot: Option<f64>,
|
||||
/// Board dangerous temperature threshold in Celsius, when reported (round 19 #10).
|
||||
pub temp_dangerous: Option<f64>,
|
||||
/// The current PDU fan information for the miner
|
||||
pub psu_fans: Vec<FanData>,
|
||||
/// The average temperature across all chips in the miner
|
||||
@@ -224,6 +236,9 @@ pub struct MinerData {
|
||||
#[serde(default)]
|
||||
#[cfg_attr(feature = "python", pydantic(default = None))]
|
||||
pub operating_state: Option<OperatingState>,
|
||||
/// Auto-tuner status as a human-readable label (round 19 #10), when reported:
|
||||
/// e.g. "Stable"/"Tuning" (Braiins), "Optimized"/"Tuning"/"Off" (ePIC).
|
||||
pub tuner_status: Option<String>,
|
||||
/// The current pools configured on the miner
|
||||
pub pools: Vec<PoolGroupData>,
|
||||
/// Difficulty of the best share found over the miner's lifetime, when reported.
|
||||
@@ -235,6 +250,9 @@ pub struct MinerData {
|
||||
/// Difficulty of the best share found since the last boot or hashing start,
|
||||
/// when the firmware distinguishes session from all-time.
|
||||
pub session_best_share: Option<f64>,
|
||||
/// Cumulative share statistics (difficulty accepted/rejected, stale, blocks),
|
||||
/// when reported. Miner-level aggregate from the cgminer/btminer summary.
|
||||
pub share_summary: Option<ShareSummary>,
|
||||
}
|
||||
|
||||
#[cfg(feature = "python")]
|
||||
|
||||
@@ -19,6 +19,8 @@ pub struct PsuInfo {
|
||||
pub model: Option<String>,
|
||||
/// PSU firmware/hardware version, when reported.
|
||||
pub version: Option<String>,
|
||||
/// PSU serial number, when reported (Braiins, WhatsMiner V3, VNish).
|
||||
pub serial: Option<String>,
|
||||
/// Minimum rated output voltage in volts, when reported.
|
||||
pub voltage_min: Option<f64>,
|
||||
/// Maximum rated output voltage in volts, when reported.
|
||||
|
||||
@@ -3,7 +3,61 @@
|
||||
//! Firmwares report best-share difficulty as a JSON number, a decimal string,
|
||||
//! or an AxeOS-style suffix string (`"483k"`, `"1.2M"`).
|
||||
|
||||
#[cfg(feature = "python")]
|
||||
use pyo3::pyclass;
|
||||
use serde::{Deserialize, Serialize};
|
||||
use serde_json::Value;
|
||||
use ts_rs::TS;
|
||||
|
||||
/// Cumulative share statistics reported by a miner (round 19 #10, T2).
|
||||
///
|
||||
/// These are miner-level aggregates from the cgminer/btminer summary. Difficulty
|
||||
/// values are difficulty-weighted sums (not raw share counts, which live on
|
||||
/// [`PoolData`][`super::pool::PoolData`]). Every field is optional; a backend
|
||||
/// fills in only what its firmware exposes.
|
||||
#[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 ShareSummary {
|
||||
/// Difficulty-weighted accepted work, when reported.
|
||||
pub difficulty_accepted: Option<f64>,
|
||||
/// Difficulty-weighted rejected work, when reported.
|
||||
pub difficulty_rejected: Option<f64>,
|
||||
/// Raw stale share count, when reported.
|
||||
pub stale_shares: Option<u64>,
|
||||
/// Number of blocks found by this miner, when reported.
|
||||
pub found_blocks: Option<u64>,
|
||||
}
|
||||
|
||||
impl ShareSummary {
|
||||
/// True when no field is populated.
|
||||
pub fn is_empty(&self) -> bool {
|
||||
self.difficulty_accepted.is_none()
|
||||
&& self.difficulty_rejected.is_none()
|
||||
&& self.stale_shares.is_none()
|
||||
&& self.found_blocks.is_none()
|
||||
}
|
||||
}
|
||||
|
||||
/// Parse a [`ShareSummary`] from a cgminer/btminer `SUMMARY[0]` object (the value
|
||||
/// extracted at `/SUMMARY/0`). Reads "Difficulty Accepted", "Difficulty Rejected",
|
||||
/// "Stale", and "Found Blocks". Returns `None` when none are present.
|
||||
pub fn parse_cgminer_share_summary(summary: &Value) -> Option<ShareSummary> {
|
||||
let f = |k: &str| {
|
||||
summary
|
||||
.get(k)
|
||||
.and_then(|v| v.as_f64())
|
||||
.filter(|v| v.is_finite() && *v >= 0.0)
|
||||
};
|
||||
let u = |k: &str| summary.get(k).and_then(|v| v.as_u64());
|
||||
let s = ShareSummary {
|
||||
difficulty_accepted: f("Difficulty Accepted"),
|
||||
difficulty_rejected: f("Difficulty Rejected"),
|
||||
stale_shares: u("Stale"),
|
||||
found_blocks: u("Found Blocks"),
|
||||
};
|
||||
(!s.is_empty()).then_some(s)
|
||||
}
|
||||
|
||||
/// Parse a share difficulty from a JSON value.
|
||||
///
|
||||
|
||||
@@ -28,12 +28,13 @@ use crate::{
|
||||
device::DeviceInfo,
|
||||
fan::FanData,
|
||||
firmware::{FirmwareImage, FirmwareStats},
|
||||
hashrate::{HashRate, HashRateUnit},
|
||||
hashrate::{HashRate, HashRateUnit, HashrateAverages},
|
||||
message::MinerMessage,
|
||||
miner::{MinerData, TuningTarget},
|
||||
operating_state::OperatingState,
|
||||
pool::PoolGroupData,
|
||||
psu::PsuInfo,
|
||||
share::ShareSummary,
|
||||
},
|
||||
traits::firmware::MinerFirmware,
|
||||
traits::model::MinerModel,
|
||||
@@ -271,6 +272,7 @@ impl<
|
||||
let control_board_version = self.parse_control_board_version(&data);
|
||||
let uptime = self.parse_uptime(&data);
|
||||
let hashrate = self.parse_hashrate(&data);
|
||||
let hashrate_averages = self.parse_hashrate_averages(&data);
|
||||
let expected_hashrate = self.parse_expected_hashrate(&data);
|
||||
let wattage = self.parse_wattage(&data);
|
||||
let psu = self.parse_psu(&data);
|
||||
@@ -280,16 +282,20 @@ impl<
|
||||
let tuning_capabilities = self.parse_tuning_capabilities(&data);
|
||||
let fluid_temperature = self.parse_fluid_temperature(&data);
|
||||
let outlet_fluid_temperature = self.parse_outlet_fluid_temperature(&data);
|
||||
let (temp_target, temp_hot, temp_dangerous) = self.parse_temperature_limits(&data);
|
||||
let fans = self.parse_fans(&data);
|
||||
let fan_speed_percent = self.parse_fan_speed_percent(&data);
|
||||
let psu_fans = self.parse_psu_fans(&data);
|
||||
let hashboards = self.parse_hashboards(&data);
|
||||
let light_flashing = self.parse_light_flashing(&data);
|
||||
let is_mining = self.parse_is_mining(&data);
|
||||
let operating_state = self.parse_operating_state(&data);
|
||||
let tuner_status = self.parse_tuner_status(&data);
|
||||
let messages = self.parse_messages(&data);
|
||||
let pools = self.parse_pools(&data);
|
||||
let best_share = self.parse_best_share(&data);
|
||||
let session_best_share = self.parse_session_best_share(&data);
|
||||
let share_summary = self.parse_share_summary(&data);
|
||||
let device_info = self.get_device_info();
|
||||
|
||||
// computed fields
|
||||
@@ -353,6 +359,7 @@ impl<
|
||||
expected_hashboards: device_info.hardware.board_count(),
|
||||
hashboards,
|
||||
hashrate,
|
||||
hashrate_averages,
|
||||
expected_hashrate,
|
||||
|
||||
// Chip information
|
||||
@@ -362,6 +369,10 @@ impl<
|
||||
// Cooling information
|
||||
expected_fans: device_info.hardware.fans,
|
||||
fans,
|
||||
fan_speed_percent,
|
||||
temp_target,
|
||||
temp_hot,
|
||||
temp_dangerous,
|
||||
psu_fans,
|
||||
average_temperature,
|
||||
fluid_temperature,
|
||||
@@ -382,10 +393,12 @@ impl<
|
||||
uptime,
|
||||
is_mining,
|
||||
operating_state,
|
||||
tuner_status,
|
||||
|
||||
pools,
|
||||
best_share,
|
||||
session_best_share,
|
||||
share_summary,
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -632,6 +645,20 @@ pub trait GetHashrate: CollectData {
|
||||
fn parse_hashrate(&self, data: &HashMap<DataField, Value>) -> Option<HashRate> {
|
||||
None
|
||||
}
|
||||
#[tracing::instrument(level = "debug")]
|
||||
async fn get_hashrate_averages(&self) -> Option<HashrateAverages> {
|
||||
let mut collector = self.get_collector();
|
||||
let data = collector
|
||||
.collect(&[DataField::HashrateAverages, DataField::Hashrate])
|
||||
.await;
|
||||
self.parse_hashrate_averages(&data)
|
||||
}
|
||||
/// Rolling average hashrate windows. Backends that expose them override this;
|
||||
/// the values carry the same unit and algorithm as the current hashrate.
|
||||
#[allow(unused_variables)]
|
||||
fn parse_hashrate_averages(&self, data: &HashMap<DataField, Value>) -> Option<HashrateAverages> {
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
// Expected Hashrate
|
||||
@@ -663,6 +690,18 @@ pub trait GetFans: CollectData {
|
||||
fn parse_fans(&self, data: &HashMap<DataField, Value>) -> Vec<FanData> {
|
||||
vec![]
|
||||
}
|
||||
#[tracing::instrument(level = "debug")]
|
||||
async fn get_fan_speed_percent(&self) -> Option<f64> {
|
||||
let mut collector = self.get_collector();
|
||||
let data = collector.collect(&[DataField::FanSpeedPercent]).await;
|
||||
self.parse_fan_speed_percent(&data)
|
||||
}
|
||||
/// Miner-level fan duty cycle as a percentage (0-100). Backends that expose it
|
||||
/// override this; others return None.
|
||||
#[allow(unused_variables)]
|
||||
fn parse_fan_speed_percent(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
// PSU Fans
|
||||
@@ -708,6 +747,15 @@ pub trait GetFluidTemperature: CollectData {
|
||||
) -> Option<Temperature> {
|
||||
None
|
||||
}
|
||||
/// Board temperature safety thresholds as (target, hot, dangerous) in Celsius.
|
||||
/// Backends that expose them override this; others return (None, None, None).
|
||||
#[allow(unused_variables)]
|
||||
fn parse_temperature_limits(
|
||||
&self,
|
||||
data: &HashMap<DataField, Value>,
|
||||
) -> (Option<f64>, Option<f64>, Option<f64>) {
|
||||
(None, None, None)
|
||||
}
|
||||
}
|
||||
|
||||
// Wattage
|
||||
@@ -868,6 +916,18 @@ pub trait GetOperatingState: CollectData {
|
||||
fn parse_operating_state(&self, data: &HashMap<DataField, Value>) -> Option<OperatingState> {
|
||||
None
|
||||
}
|
||||
#[tracing::instrument(level = "debug")]
|
||||
async fn get_tuner_status(&self) -> Option<String> {
|
||||
let mut collector = self.get_collector();
|
||||
let data = collector.collect(&[DataField::TunerStatus]).await;
|
||||
self.parse_tuner_status(&data)
|
||||
}
|
||||
/// Auto-tuner status as a human-readable label. Backends that expose it override
|
||||
/// this; others return None.
|
||||
#[allow(unused_variables)]
|
||||
fn parse_tuner_status(&self, data: &HashMap<DataField, Value>) -> Option<String> {
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
// Pools
|
||||
@@ -898,6 +958,18 @@ pub trait GetBestShare: CollectData {
|
||||
fn parse_best_share(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
|
||||
None
|
||||
}
|
||||
#[tracing::instrument(level = "debug")]
|
||||
async fn get_share_summary(&self) -> Option<ShareSummary> {
|
||||
let mut collector = self.get_collector();
|
||||
let data = collector.collect(&[DataField::ShareSummary]).await;
|
||||
self.parse_share_summary(&data)
|
||||
}
|
||||
/// Cumulative share statistics (difficulty accepted/rejected, stale, blocks).
|
||||
/// Backends that expose them override this; others return None.
|
||||
#[allow(unused_variables)]
|
||||
fn parse_share_summary(&self, data: &HashMap<DataField, Value>) -> Option<ShareSummary> {
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
// Best share difficulty (this session / since boot)
|
||||
|
||||
@@ -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":"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"}
|
||||
{"$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":"b2dbba5377a739bc8be3380cfbd09aa80893841c15c305bfd25f900ba7b6a0c9","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":"0906bff13eb51bd47fb0e06cc2c1955fe459c601cb467efc917801ead825dd61","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"}
|
||||
@@ -21,6 +21,7 @@ use asic_rs_core::{
|
||||
message::{MessageSeverity, MinerMessage},
|
||||
miner::{MiningMode, TuningTarget},
|
||||
pool::{PoolData, PoolGroupData, PoolURL},
|
||||
share::{ShareSummary, parse_cgminer_share_summary},
|
||||
},
|
||||
traits::{miner::*, model::MinerModel},
|
||||
};
|
||||
@@ -499,6 +500,26 @@ impl GetDataLocations for AntMinerV2020 {
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
// cgminer summary "Best Share" (all-time). RPC_SUMMARY is already
|
||||
// fetched, so this adds no round-trip (round 19 #10).
|
||||
DataField::BestShare => vec![(
|
||||
RPC_SUMMARY,
|
||||
DataExtractor {
|
||||
func: get_by_pointer,
|
||||
key: Some("/SUMMARY/0/Best Share"),
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
// Cumulative share stats from cgminer summary (round 19 #10, T2);
|
||||
// RPC_SUMMARY already fetched.
|
||||
DataField::ShareSummary => vec![(
|
||||
RPC_SUMMARY,
|
||||
DataExtractor {
|
||||
func: get_by_pointer,
|
||||
key: Some("/SUMMARY/0"),
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
// `total_rateideal`, by contrast, says nothing about its own
|
||||
// scale, so carry STATS' `rate_unit` alongside it.
|
||||
DataField::ExpectedHashrate => vec![
|
||||
@@ -873,7 +894,17 @@ impl GetUptime for AntMinerV2020 {
|
||||
}
|
||||
}
|
||||
|
||||
impl GetBestShare for AntMinerV2020 {}
|
||||
impl GetBestShare for AntMinerV2020 {
|
||||
fn parse_best_share(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
|
||||
// cgminer summary "Best Share" (all-time); guard against a 0 placeholder
|
||||
// (round 19 #10).
|
||||
data.extract::<f64>(DataField::BestShare).filter(|&v| v > 0.0)
|
||||
}
|
||||
fn parse_share_summary(&self, data: &HashMap<DataField, Value>) -> Option<ShareSummary> {
|
||||
data.get(&DataField::ShareSummary)
|
||||
.and_then(parse_cgminer_share_summary)
|
||||
}
|
||||
}
|
||||
impl GetSessionBestShare for AntMinerV2020 {}
|
||||
|
||||
impl GetOperatingState for AntMinerV2020 {}
|
||||
@@ -1663,6 +1694,12 @@ mod tests {
|
||||
algo: HashAlgorithm::SHA256,
|
||||
}
|
||||
);
|
||||
// Cumulative share stats from cgminer summary (round 19 #10, T2).
|
||||
let shares = miner_data.share_summary.expect("share summary");
|
||||
assert_eq!(shares.difficulty_accepted, Some(1305083904.0));
|
||||
assert_eq!(shares.difficulty_rejected, Some(2490368.0));
|
||||
assert_eq!(shares.stale_shares, Some(1));
|
||||
assert_eq!(shares.found_blocks, Some(0));
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
|
||||
@@ -23,6 +23,7 @@ use asic_rs_core::{
|
||||
message::{MessageSeverity, MinerMessage},
|
||||
miner::{MiningMode, TuningTarget},
|
||||
pool::{PoolData, PoolGroupData, PoolURL},
|
||||
share::{ShareSummary, parse_cgminer_share_summary},
|
||||
},
|
||||
traits::{miner::*, model::MinerModel},
|
||||
};
|
||||
@@ -547,6 +548,16 @@ impl GetDataLocations for AntMinerV202307 {
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
// Cumulative share stats from cgminer summary (round 19 #10, T2);
|
||||
// RPC_SUMMARY already fetched.
|
||||
DataField::ShareSummary => vec![(
|
||||
RPC_SUMMARY,
|
||||
DataExtractor {
|
||||
func: get_by_pointer,
|
||||
key: Some("/SUMMARY/0"),
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
DataField::SessionBestShare => vec![(
|
||||
RPC_SUMMARY,
|
||||
DataExtractor {
|
||||
@@ -955,6 +966,10 @@ impl GetBestShare for AntMinerV202307 {
|
||||
// reports 0 when it has never found a share (round 17 R7).
|
||||
data.extract::<f64>(DataField::BestShare).filter(|&v| v > 0.0)
|
||||
}
|
||||
fn parse_share_summary(&self, data: &HashMap<DataField, Value>) -> Option<ShareSummary> {
|
||||
data.get(&DataField::ShareSummary)
|
||||
.and_then(parse_cgminer_share_summary)
|
||||
}
|
||||
}
|
||||
|
||||
impl GetSessionBestShare for AntMinerV202307 {
|
||||
|
||||
@@ -16,7 +16,7 @@ use asic_rs_core::{
|
||||
command::MinerCommand,
|
||||
device::{DeviceInfo, HashAlgorithm},
|
||||
fan::FanData,
|
||||
hashrate::{HashRate, HashRateUnit},
|
||||
hashrate::{HashRate, HashRateUnit, HashrateAverages},
|
||||
message::{MessageSeverity, MinerMessage},
|
||||
miner::TuningTarget,
|
||||
operating_state::OperatingState,
|
||||
@@ -204,6 +204,16 @@ impl GetDataLocations for BraiinsV2507 {
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
// Rolling averages from miner_stats real_hashrate (round 19 #10, T2);
|
||||
// command already fetched. Braiins reports the full 1m/5m/15m/24h set.
|
||||
DataField::HashrateAverages => vec![(
|
||||
WEB_MINER_STATS,
|
||||
DataExtractor {
|
||||
func: get_by_pointer,
|
||||
key: Some("/miner_stats/real_hashrate"),
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
DataField::ExpectedHashrate => vec![(
|
||||
WEB_MINER_DETAILS,
|
||||
DataExtractor {
|
||||
@@ -220,6 +230,16 @@ impl GetDataLocations for BraiinsV2507 {
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
// Miner-level fan duty cycle (round 19 #10, T3): max target_speed_ratio;
|
||||
// cooling state already fetched.
|
||||
DataField::FanSpeedPercent => vec![(
|
||||
WEB_COOLING_STATE,
|
||||
DataExtractor {
|
||||
func: get_by_pointer,
|
||||
key: Some("/fans"),
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
DataField::Hashboards => vec![(
|
||||
WEB_HASHBOARDS,
|
||||
DataExtractor {
|
||||
@@ -252,6 +272,16 @@ impl GetDataLocations for BraiinsV2507 {
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
// Auto-tuner status (round 19 #10, T3): performance/tuner-state
|
||||
// overall_tuner_state enum; command already fetched.
|
||||
DataField::TunerStatus => vec![(
|
||||
WEB_PERFORMANCE_TUNER_STATE,
|
||||
DataExtractor {
|
||||
func: get_by_pointer,
|
||||
key: Some("/overall_tuner_state"),
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
DataField::Uptime => vec![(
|
||||
WEB_MINER_DETAILS,
|
||||
DataExtractor {
|
||||
@@ -352,6 +382,16 @@ impl GetDataLocations for BraiinsV2507 {
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
// Board temp thresholds (round 19 #10, T3): cooling_constraints defaults
|
||||
// (target/hot/dangerous); WEB_CONSTRAINTS already fetched.
|
||||
DataField::TemperatureLimits => vec![(
|
||||
WEB_CONSTRAINTS,
|
||||
DataExtractor {
|
||||
func: get_by_pointer,
|
||||
key: Some("/cooling_constraints"),
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
_ => vec![],
|
||||
}
|
||||
}
|
||||
@@ -494,6 +534,31 @@ impl GetHashrate for BraiinsV2507 {
|
||||
.as_unit(HashRateUnit::default())
|
||||
})
|
||||
}
|
||||
fn parse_hashrate_averages(&self, data: &HashMap<DataField, Value>) -> Option<HashrateAverages> {
|
||||
// miner_stats real_hashrate last_1m/5m/15m/24h (GigaHash); full window set
|
||||
// (round 19 #10).
|
||||
let d = data.get(&DataField::HashrateAverages)?;
|
||||
let ghs = |k: &str| {
|
||||
d.pointer(&format!("/{k}/gigahash_per_second"))
|
||||
.and_then(|v| v.as_f64())
|
||||
.filter(|&f| f > 0.0)
|
||||
.map(|f| {
|
||||
HashRate {
|
||||
value: f,
|
||||
unit: HashRateUnit::GigaHash,
|
||||
algo: self.device_info.algo,
|
||||
}
|
||||
.as_unit(HashRateUnit::default())
|
||||
})
|
||||
};
|
||||
let avgs = HashrateAverages {
|
||||
avg_1m: ghs("last_1m"),
|
||||
avg_5m: ghs("last_5m"),
|
||||
avg_15m: ghs("last_15m"),
|
||||
avg_24h: ghs("last_24h"),
|
||||
};
|
||||
(!avgs.is_empty()).then_some(avgs)
|
||||
}
|
||||
}
|
||||
|
||||
impl GetExpectedHashrate for BraiinsV2507 {
|
||||
@@ -532,6 +597,18 @@ impl GetFans for BraiinsV2507 {
|
||||
|
||||
fans
|
||||
}
|
||||
fn parse_fan_speed_percent(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
|
||||
// Braiins fans[].target_speed_ratio is a 0-1 duty ratio; report the max as
|
||||
// a percentage (round 19 #10, T3).
|
||||
data.get(&DataField::FanSpeedPercent)
|
||||
.and_then(|v| v.as_array())
|
||||
.into_iter()
|
||||
.flatten()
|
||||
.filter_map(|f| f.pointer("/target_speed_ratio").and_then(|v| v.as_f64()))
|
||||
.filter(|v| v.is_finite() && *v >= 0.0)
|
||||
.map(|v| v * 100.0)
|
||||
.max_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal))
|
||||
}
|
||||
}
|
||||
|
||||
impl GetLightFlashing for BraiinsV2507 {
|
||||
@@ -563,6 +640,21 @@ impl GetOperatingState for BraiinsV2507 {
|
||||
},
|
||||
})
|
||||
}
|
||||
fn parse_tuner_status(&self, data: &HashMap<DataField, Value>) -> Option<String> {
|
||||
// BOS+ TunerState enum (bos-plus-api performance.proto): 1 Disabled,
|
||||
// 2 Stable, 3 Tuning, 4 Error, 5 Continuous, 6 Preheat (round 19 #10, T3).
|
||||
Some(match data.get(&DataField::TunerStatus)?.as_u64()? {
|
||||
0 => return None,
|
||||
1 => "Disabled",
|
||||
2 => "Stable",
|
||||
3 => "Tuning",
|
||||
4 => "Error",
|
||||
5 => "Continuous",
|
||||
6 => "Preheat",
|
||||
_ => return None,
|
||||
})
|
||||
.map(str::to_string)
|
||||
}
|
||||
}
|
||||
|
||||
impl GetIsMining for BraiinsV2507 {
|
||||
@@ -668,7 +760,26 @@ impl GetScaledTuningTarget for BraiinsV2507 {
|
||||
}
|
||||
}
|
||||
|
||||
impl GetFluidTemperature for BraiinsV2507 {}
|
||||
impl GetFluidTemperature for BraiinsV2507 {
|
||||
fn parse_temperature_limits(
|
||||
&self,
|
||||
data: &HashMap<DataField, Value>,
|
||||
) -> (Option<f64>, Option<f64>, Option<f64>) {
|
||||
// Braiins cooling_constraints target/hot/dangerous default thresholds in
|
||||
// degree_c (round 19 #10, T3).
|
||||
let d = data.get(&DataField::TemperatureLimits);
|
||||
let f = |k: &str| {
|
||||
d.and_then(|v| v.pointer(&format!("/{k}/default/degree_c")))
|
||||
.and_then(|v| v.as_f64())
|
||||
.filter(|v| v.is_finite() && *v > 0.0)
|
||||
};
|
||||
(
|
||||
f("target_temperature"),
|
||||
f("hot_temperature"),
|
||||
f("dangerous_temperature"),
|
||||
)
|
||||
}
|
||||
}
|
||||
impl GetTuningCapabilities for BraiinsV2507 {
|
||||
fn parse_tuning_capabilities(
|
||||
&self,
|
||||
|
||||
@@ -17,7 +17,7 @@ use asic_rs_core::{
|
||||
device::{DeviceInfo, HashAlgorithm},
|
||||
fan::FanData,
|
||||
firmware::{FirmwareStats, FirmwareUpdate},
|
||||
hashrate::{HashRate, HashRateUnit},
|
||||
hashrate::{HashRate, HashRateUnit, HashrateAverages},
|
||||
message::{MessageSeverity, MinerMessage},
|
||||
miner::TuningTarget,
|
||||
operating_state::OperatingState,
|
||||
@@ -207,6 +207,16 @@ impl GetDataLocations for BraiinsV2604 {
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
// Rolling averages from miner_stats real_hashrate (round 19 #10, T2);
|
||||
// command already fetched. Braiins reports the full 1m/5m/15m/24h set.
|
||||
DataField::HashrateAverages => vec![(
|
||||
WEB_MINER_STATS,
|
||||
DataExtractor {
|
||||
func: get_by_pointer,
|
||||
key: Some("/miner_stats/real_hashrate"),
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
DataField::ExpectedHashrate => vec![(
|
||||
WEB_MINER_DETAILS,
|
||||
DataExtractor {
|
||||
@@ -223,6 +233,16 @@ impl GetDataLocations for BraiinsV2604 {
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
// Miner-level fan duty cycle (round 19 #10, T3): max target_speed_ratio;
|
||||
// cooling state already fetched.
|
||||
DataField::FanSpeedPercent => vec![(
|
||||
WEB_COOLING_STATE,
|
||||
DataExtractor {
|
||||
func: get_by_pointer,
|
||||
key: Some("/fans"),
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
DataField::Hashboards => vec![(
|
||||
WEB_HASHBOARDS,
|
||||
DataExtractor {
|
||||
@@ -255,6 +275,16 @@ impl GetDataLocations for BraiinsV2604 {
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
// Auto-tuner status (round 19 #10, T3): performance/tuner-state
|
||||
// overall_tuner_state enum; command already fetched.
|
||||
DataField::TunerStatus => vec![(
|
||||
WEB_PERFORMANCE_TUNER_STATE,
|
||||
DataExtractor {
|
||||
func: get_by_pointer,
|
||||
key: Some("/overall_tuner_state"),
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
DataField::Uptime => vec![(
|
||||
WEB_MINER_DETAILS,
|
||||
DataExtractor {
|
||||
@@ -373,6 +403,16 @@ impl GetDataLocations for BraiinsV2604 {
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
// Board temp thresholds (round 19 #10, T3): cooling_constraints defaults
|
||||
// (target/hot/dangerous); WEB_CONSTRAINTS already fetched.
|
||||
DataField::TemperatureLimits => vec![(
|
||||
WEB_CONSTRAINTS,
|
||||
DataExtractor {
|
||||
func: get_by_pointer,
|
||||
key: Some("/cooling_constraints"),
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
_ => vec![],
|
||||
}
|
||||
}
|
||||
@@ -498,6 +538,16 @@ impl GetHashboards for BraiinsV2604 {
|
||||
.and_then(|v| v.as_f64())
|
||||
.map(Frequency::from_hertz);
|
||||
board.active = chain.pointer("/enabled").and_then(|v| v.as_bool());
|
||||
// ASIC chip model + hashboard model/part (round 19 #10 telemetry
|
||||
// extension). BOS+ miner/hw/hashboards reports chip_type ("BM1370")
|
||||
// and model ("A3HB70601"); board_name is the human label if present.
|
||||
board.chip_type =
|
||||
chain.pointer("/chip_type").and_then(|v| v.as_str()).map(str::to_string);
|
||||
board.hashboard_model = chain
|
||||
.pointer("/model")
|
||||
.or_else(|| chain.pointer("/board_name"))
|
||||
.and_then(|v| v.as_str())
|
||||
.map(str::to_string);
|
||||
}
|
||||
|
||||
hashboards
|
||||
@@ -515,6 +565,31 @@ impl GetHashrate for BraiinsV2604 {
|
||||
.as_unit(HashRateUnit::default())
|
||||
})
|
||||
}
|
||||
fn parse_hashrate_averages(&self, data: &HashMap<DataField, Value>) -> Option<HashrateAverages> {
|
||||
// miner_stats real_hashrate last_1m/5m/15m/24h (GigaHash); full window set
|
||||
// (round 19 #10).
|
||||
let d = data.get(&DataField::HashrateAverages)?;
|
||||
let ghs = |k: &str| {
|
||||
d.pointer(&format!("/{k}/gigahash_per_second"))
|
||||
.and_then(|v| v.as_f64())
|
||||
.filter(|&f| f > 0.0)
|
||||
.map(|f| {
|
||||
HashRate {
|
||||
value: f,
|
||||
unit: HashRateUnit::GigaHash,
|
||||
algo: self.device_info.algo,
|
||||
}
|
||||
.as_unit(HashRateUnit::default())
|
||||
})
|
||||
};
|
||||
let avgs = HashrateAverages {
|
||||
avg_1m: ghs("last_1m"),
|
||||
avg_5m: ghs("last_5m"),
|
||||
avg_15m: ghs("last_15m"),
|
||||
avg_24h: ghs("last_24h"),
|
||||
};
|
||||
(!avgs.is_empty()).then_some(avgs)
|
||||
}
|
||||
}
|
||||
|
||||
impl GetExpectedHashrate for BraiinsV2604 {
|
||||
@@ -553,6 +628,18 @@ impl GetFans for BraiinsV2604 {
|
||||
|
||||
fans
|
||||
}
|
||||
fn parse_fan_speed_percent(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
|
||||
// Braiins fans[].target_speed_ratio is a 0-1 duty ratio; report the max as
|
||||
// a percentage (round 19 #10, T3).
|
||||
data.get(&DataField::FanSpeedPercent)
|
||||
.and_then(|v| v.as_array())
|
||||
.into_iter()
|
||||
.flatten()
|
||||
.filter_map(|f| f.pointer("/target_speed_ratio").and_then(|v| v.as_f64()))
|
||||
.filter(|v| v.is_finite() && *v >= 0.0)
|
||||
.map(|v| v * 100.0)
|
||||
.max_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal))
|
||||
}
|
||||
}
|
||||
|
||||
impl GetLightFlashing for BraiinsV2604 {
|
||||
@@ -590,6 +677,21 @@ impl GetOperatingState for BraiinsV2604 {
|
||||
},
|
||||
})
|
||||
}
|
||||
fn parse_tuner_status(&self, data: &HashMap<DataField, Value>) -> Option<String> {
|
||||
// BOS+ TunerState enum (bos-plus-api performance.proto): 1 Disabled,
|
||||
// 2 Stable, 3 Tuning, 4 Error, 5 Continuous, 6 Preheat (round 19 #10, T3).
|
||||
Some(match data.get(&DataField::TunerStatus)?.as_u64()? {
|
||||
0 => return None,
|
||||
1 => "Disabled",
|
||||
2 => "Stable",
|
||||
3 => "Tuning",
|
||||
4 => "Error",
|
||||
5 => "Continuous",
|
||||
6 => "Preheat",
|
||||
_ => return None,
|
||||
})
|
||||
.map(str::to_string)
|
||||
}
|
||||
}
|
||||
|
||||
impl GetIsMining for BraiinsV2604 {
|
||||
@@ -676,13 +778,15 @@ impl GetWattage for BraiinsV2604 {
|
||||
}
|
||||
|
||||
fn parse_psu(&self, data: &HashMap<DataField, Value>) -> Option<PsuInfo> {
|
||||
// BOS miner/details -> psu_info {version, min_voltage.volt, max_voltage.volt}.
|
||||
// "version" is the PSU type code (117 = the APW12 ePIC also reports as model
|
||||
// 117), so expose it as the model for consistency across firmwares.
|
||||
// BOS miner/details -> psu_info { model_name, fw_version, serial_number,
|
||||
// version (numeric type code), min_voltage.volt, max_voltage.volt }. Read
|
||||
// the human model_name and the firmware version (the old code used the
|
||||
// numeric "version" type code as the model and dropped fw_version entirely).
|
||||
let d = data.get(&DataField::Psu)?;
|
||||
let psu = PsuInfo {
|
||||
model: d.pointer("/version").and_then(|v| v.as_i64()).map(|n| n.to_string()),
|
||||
version: None,
|
||||
model: d.pointer("/model_name").and_then(|v| v.as_str()).map(str::to_string),
|
||||
version: d.pointer("/fw_version").and_then(|v| v.as_i64()).map(|n| n.to_string()),
|
||||
serial: d.pointer("/serial_number").and_then(|v| v.as_str()).map(str::to_string),
|
||||
voltage_min: d.pointer("/min_voltage/volt").and_then(|v| v.as_f64()),
|
||||
voltage_max: d.pointer("/max_voltage/volt").and_then(|v| v.as_f64()),
|
||||
output_voltage: None,
|
||||
@@ -706,7 +810,26 @@ impl GetScaledTuningTarget for BraiinsV2604 {
|
||||
}
|
||||
}
|
||||
|
||||
impl GetFluidTemperature for BraiinsV2604 {}
|
||||
impl GetFluidTemperature for BraiinsV2604 {
|
||||
fn parse_temperature_limits(
|
||||
&self,
|
||||
data: &HashMap<DataField, Value>,
|
||||
) -> (Option<f64>, Option<f64>, Option<f64>) {
|
||||
// Braiins cooling_constraints target/hot/dangerous default thresholds in
|
||||
// degree_c (round 19 #10, T3).
|
||||
let d = data.get(&DataField::TemperatureLimits);
|
||||
let f = |k: &str| {
|
||||
d.and_then(|v| v.pointer(&format!("/{k}/default/degree_c")))
|
||||
.and_then(|v| v.as_f64())
|
||||
.filter(|v| v.is_finite() && *v > 0.0)
|
||||
};
|
||||
(
|
||||
f("target_temperature"),
|
||||
f("hot_temperature"),
|
||||
f("dangerous_temperature"),
|
||||
)
|
||||
}
|
||||
}
|
||||
impl GetTuningCapabilities for BraiinsV2604 {
|
||||
fn parse_tuning_capabilities(
|
||||
&self,
|
||||
@@ -1098,10 +1221,10 @@ mod tests {
|
||||
|
||||
use super::*;
|
||||
use crate::test::json::v26_04::{
|
||||
WEB_COOLING_STATE_COMMAND, WEB_HASHBOARDS_COMMAND, WEB_LOCATE_COMMAND,
|
||||
WEB_MINER_CONFIGURATION_COMMAND, WEB_MINER_DETAILS_COMMAND, WEB_MINER_STATS_COMMAND,
|
||||
WEB_NETWORK_COMMAND, WEB_PERFORMANCE_TUNER_STATE_COMMAND, WEB_POOLS_COMMAND,
|
||||
WEB_VERSION_COMMAND,
|
||||
WEB_CONSTRAINTS_COMMAND, WEB_COOLING_STATE_COMMAND, WEB_HASHBOARDS_COMMAND,
|
||||
WEB_LOCATE_COMMAND, WEB_MINER_CONFIGURATION_COMMAND, WEB_MINER_DETAILS_COMMAND,
|
||||
WEB_MINER_STATS_COMMAND, WEB_NETWORK_COMMAND, WEB_PERFORMANCE_TUNER_STATE_COMMAND,
|
||||
WEB_POOLS_COMMAND, WEB_VERSION_COMMAND,
|
||||
};
|
||||
|
||||
#[tokio::test]
|
||||
@@ -1182,6 +1305,13 @@ mod tests {
|
||||
},
|
||||
Value::from_str(WEB_HASHBOARDS_COMMAND).unwrap(),
|
||||
);
|
||||
results.insert(
|
||||
MinerCommand::WebAPI {
|
||||
command: "configuration/constraints",
|
||||
parameters: None,
|
||||
},
|
||||
Value::from_str(WEB_CONSTRAINTS_COMMAND).unwrap(),
|
||||
);
|
||||
results.insert(
|
||||
MinerCommand::WebAPI {
|
||||
command: "actions/locate",
|
||||
@@ -1229,6 +1359,27 @@ mod tests {
|
||||
assert_eq!(miner_data.pools[0].len(), 2);
|
||||
assert!(miner_data.hashrate.is_some());
|
||||
assert!(miner_data.expected_hashrate.is_some());
|
||||
// Rolling averages: miner_stats real_hashrate last_1m/5m/15m/24h (GigaHash);
|
||||
// Braiins reports the full window set (round 19 #10, T2).
|
||||
let avgs = miner_data
|
||||
.hashrate_averages
|
||||
.expect("braiins exposes rolling averages");
|
||||
assert!(avgs.avg_1m.is_some() && avgs.avg_5m.is_some());
|
||||
assert!(avgs.avg_15m.is_some() && avgs.avg_24h.is_some());
|
||||
if let Some(hr) = &avgs.avg_1m {
|
||||
assert_eq!(hr.unit, HashRateUnit::TeraHash);
|
||||
assert!((hr.value - 247.3507543407177).abs() < 1e-3);
|
||||
}
|
||||
// Miner-level fan duty cycle = max target_speed_ratio (0.92) x 100 (round
|
||||
// 19 #10, T3).
|
||||
let fan_pct = miner_data.fan_speed_percent.expect("braiins fan duty");
|
||||
assert!((fan_pct - 92.0).abs() < 1e-6);
|
||||
// Board temp thresholds from cooling_constraints defaults (round 19 #10, T3).
|
||||
assert_eq!(miner_data.temp_target, Some(60.0));
|
||||
assert_eq!(miner_data.temp_hot, Some(80.0));
|
||||
assert_eq!(miner_data.temp_dangerous, Some(90.0));
|
||||
// Auto-tuner status: overall_tuner_state 5 -> Continuous (round 19 #10, T3).
|
||||
assert_eq!(miner_data.tuner_status.as_deref(), Some("Continuous"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
@@ -0,0 +1,200 @@
|
||||
{
|
||||
"tuner_constraints": {
|
||||
"power_target": {
|
||||
"default": {
|
||||
"watt": 2832
|
||||
},
|
||||
"min": {
|
||||
"watt": 944
|
||||
},
|
||||
"max": {
|
||||
"watt": 6435
|
||||
}
|
||||
},
|
||||
"hashrate_target": {
|
||||
"default": {
|
||||
"terahash_per_second": 96.0
|
||||
},
|
||||
"min": {
|
||||
"terahash_per_second": 70.75
|
||||
},
|
||||
"max": {
|
||||
"terahash_per_second": 252.57
|
||||
}
|
||||
},
|
||||
"enabled": {
|
||||
"default": true
|
||||
},
|
||||
"default_mode": 1
|
||||
},
|
||||
"cooling_constraints": {
|
||||
"default_cooling_mode": 1,
|
||||
"target_temperature": {
|
||||
"default": {
|
||||
"degree_c": 60.0
|
||||
},
|
||||
"min": {
|
||||
"degree_c": 0.0
|
||||
},
|
||||
"max": {
|
||||
"degree_c": 200.0
|
||||
}
|
||||
},
|
||||
"hot_temperature": {
|
||||
"default": {
|
||||
"degree_c": 80.0
|
||||
},
|
||||
"min": {
|
||||
"degree_c": 0.0
|
||||
},
|
||||
"max": {
|
||||
"degree_c": 200.0
|
||||
}
|
||||
},
|
||||
"dangerous_temperature": {
|
||||
"default": {
|
||||
"degree_c": 90.0
|
||||
},
|
||||
"min": {
|
||||
"degree_c": 0.0
|
||||
},
|
||||
"max": {
|
||||
"degree_c": 200.0
|
||||
}
|
||||
},
|
||||
"fan_speed_ratio": {
|
||||
"default": 1.0,
|
||||
"min": 0.0,
|
||||
"max": 1.0
|
||||
},
|
||||
"minimum_required_fans": {
|
||||
"default": 2,
|
||||
"min": 0,
|
||||
"max": 4
|
||||
},
|
||||
"min_fan_speed": {
|
||||
"default": 0,
|
||||
"min": 0,
|
||||
"max": 100
|
||||
},
|
||||
"max_fan_speed": {
|
||||
"default": 100,
|
||||
"min": 0,
|
||||
"max": 100
|
||||
},
|
||||
"pause_cooldown_fan_speed_ratio": {
|
||||
"default": 0.2,
|
||||
"min": 0.0,
|
||||
"max": 1.0
|
||||
},
|
||||
"default_fan_pause_mode": 2,
|
||||
"default_fan_pause_runtime": 1,
|
||||
"fan_pause_runtime_limited_duration_s": 120
|
||||
},
|
||||
"dps_constraints": {
|
||||
"power_step": {
|
||||
"default": {
|
||||
"watt": 300
|
||||
},
|
||||
"min": {
|
||||
"watt": 1
|
||||
},
|
||||
"max": {
|
||||
"watt": 1000
|
||||
}
|
||||
},
|
||||
"hashrate_step": {
|
||||
"default": {
|
||||
"terahash_per_second": 11.0
|
||||
},
|
||||
"min": {
|
||||
"terahash_per_second": 0.1
|
||||
},
|
||||
"max": {
|
||||
"terahash_per_second": 100.0
|
||||
}
|
||||
},
|
||||
"min_power_target": {
|
||||
"default": {
|
||||
"watt": 944
|
||||
},
|
||||
"min": {
|
||||
"watt": 944
|
||||
},
|
||||
"max": {
|
||||
"watt": 6435
|
||||
}
|
||||
},
|
||||
"min_hashrate_target": {
|
||||
"default": {
|
||||
"terahash_per_second": 70.75
|
||||
},
|
||||
"min": {
|
||||
"terahash_per_second": 70.75
|
||||
},
|
||||
"max": {
|
||||
"terahash_per_second": 252.57
|
||||
}
|
||||
},
|
||||
"shutdown_enabled": {
|
||||
"default": false
|
||||
},
|
||||
"shutdown_duration": {
|
||||
"default": {
|
||||
"hours": 3
|
||||
},
|
||||
"min": {
|
||||
"hours": 0
|
||||
},
|
||||
"max": {
|
||||
"hours": 999
|
||||
}
|
||||
},
|
||||
"enabled": {
|
||||
"default": true
|
||||
},
|
||||
"mode": 1,
|
||||
"on_start_target_percent": {
|
||||
"default": 100,
|
||||
"min": 50,
|
||||
"max": 100
|
||||
}
|
||||
},
|
||||
"hashboards_constraints": {
|
||||
"hashboard_ids": [
|
||||
"1",
|
||||
"2",
|
||||
"3"
|
||||
],
|
||||
"enabled": {
|
||||
"default": true
|
||||
},
|
||||
"frequency": {
|
||||
"default": {
|
||||
"hertz": 505000000.0
|
||||
},
|
||||
"min": {
|
||||
"hertz": 50000000.0
|
||||
},
|
||||
"max": {
|
||||
"hertz": 1300000000.0
|
||||
}
|
||||
},
|
||||
"voltage": {
|
||||
"default": {
|
||||
"volt": 13.4
|
||||
},
|
||||
"min": {
|
||||
"volt": 11.96
|
||||
},
|
||||
"max": {
|
||||
"volt": 15.2
|
||||
}
|
||||
},
|
||||
"quick_ramping_time_s": {
|
||||
"default": 30,
|
||||
"min": 2,
|
||||
"max": 600
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -12,3 +12,4 @@ pub(crate) const WEB_POOLS_COMMAND: &str = include_str!("pools.json");
|
||||
pub(crate) const WEB_COOLING_STATE_COMMAND: &str = include_str!("cooling_state.json");
|
||||
pub(crate) const WEB_HASHBOARDS_COMMAND: &str = include_str!("miner_hw_hashboards.json");
|
||||
pub(crate) const WEB_LOCATE_COMMAND: &str = include_str!("actions_locate.json");
|
||||
pub(crate) const WEB_CONSTRAINTS_COMMAND: &str = include_str!("configuration_constraints.json");
|
||||
|
||||
@@ -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":"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"}
|
||||
{"$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":"b42ecb0edb9e92f5de47fbac632b3f6edcb0160546619dc619ba75a9f070e791","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"}
|
||||
@@ -473,6 +473,25 @@ impl GetDataLocations for PowerPlayV1 {
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
// Miner-level fan duty cycle (round 19 #10, T3); summary already fetched.
|
||||
DataField::FanSpeedPercent => vec![(
|
||||
WEB_SUMMARY,
|
||||
DataExtractor {
|
||||
func: get_by_pointer,
|
||||
key: Some("/Fans/Fans Speed"),
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
// Board temperature thresholds (round 19 #10, T3); summary /Misc carries
|
||||
// Critical Temp and Shutdown Temp. Already fetched.
|
||||
DataField::TemperatureLimits => vec![(
|
||||
WEB_SUMMARY,
|
||||
DataExtractor {
|
||||
func: get_by_pointer,
|
||||
key: Some("/Misc"),
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
DataField::Hashboards => vec![
|
||||
(
|
||||
WEB_TEMPS,
|
||||
@@ -575,6 +594,16 @@ impl GetDataLocations for PowerPlayV1 {
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
// Auto-tuner status (round 19 #10, T3): PowerPlay PerpetualTune; summary
|
||||
// already fetched.
|
||||
DataField::TunerStatus => vec![(
|
||||
WEB_SUMMARY,
|
||||
DataExtractor {
|
||||
func: get_by_pointer,
|
||||
key: Some("/PerpetualTune"),
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
DataField::LightFlashing => vec![(
|
||||
WEB_SUMMARY,
|
||||
DataExtractor {
|
||||
@@ -797,6 +826,21 @@ impl GetHashboards for PowerPlayV1 {
|
||||
.pointer("/Capabilities/Performance Estimator/Hashes Per Second Per Chip")
|
||||
.and_then(|v| v.as_f64());
|
||||
|
||||
// ASIC chip type + hashboard model from capabilities (round 19 #10);
|
||||
// capabilities reports them miner-wide, so apply to every board.
|
||||
let chip_type =
|
||||
api_data.pointer("/Capabilities/Chip Type").and_then(|v| v.as_str()).map(str::to_string);
|
||||
let hashboard_model = api_data
|
||||
.pointer("/Capabilities/Model Subtype")
|
||||
.and_then(|v| v.as_str())
|
||||
.map(str::to_string);
|
||||
if chip_type.is_some() || hashboard_model.is_some() {
|
||||
for board in &mut hashboards {
|
||||
board.chip_type = chip_type.clone();
|
||||
board.hashboard_model = hashboard_model.clone();
|
||||
}
|
||||
}
|
||||
|
||||
// Active status
|
||||
if let Some(boards) = api_data
|
||||
.pointer("/Summary/HBStatus")
|
||||
@@ -1105,12 +1149,32 @@ impl GetFans for PowerPlayV1 {
|
||||
|
||||
fans
|
||||
}
|
||||
fn parse_fan_speed_percent(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
|
||||
// ePIC summary /Fans/Fans Speed is a single miner-level duty % (round 19 #10).
|
||||
data.extract::<f64>(DataField::FanSpeedPercent)
|
||||
.filter(|v| v.is_finite() && *v >= 0.0)
|
||||
}
|
||||
}
|
||||
|
||||
impl GetPsuFans for PowerPlayV1 {}
|
||||
impl GetTuningCapabilities for PowerPlayV1 {}
|
||||
|
||||
impl GetFluidTemperature for PowerPlayV1 {}
|
||||
impl GetFluidTemperature for PowerPlayV1 {
|
||||
fn parse_temperature_limits(
|
||||
&self,
|
||||
data: &HashMap<DataField, Value>,
|
||||
) -> (Option<f64>, Option<f64>, Option<f64>) {
|
||||
// ePIC summary /Misc: Shutdown Temp (hot) + Critical Temp (dangerous); no
|
||||
// target threshold reported (round 19 #10, T3).
|
||||
let d = data.get(&DataField::TemperatureLimits);
|
||||
let f = |k: &str| {
|
||||
d.and_then(|v| v.pointer(k))
|
||||
.and_then(|v| v.as_f64())
|
||||
.filter(|v| v.is_finite() && *v > 0.0)
|
||||
};
|
||||
(None, f("/Shutdown Temp"), f("/Critical Temp"))
|
||||
}
|
||||
}
|
||||
|
||||
impl GetWattage for PowerPlayV1 {
|
||||
fn parse_wattage(&self, data: &HashMap<DataField, Value>) -> Option<Power> {
|
||||
@@ -1128,6 +1192,7 @@ impl GetWattage for PowerPlayV1 {
|
||||
let psu = PsuInfo {
|
||||
model: f(info, "/PSU Type").map(|n| format!("{n:.0}")),
|
||||
version: f(info, "/FW").map(|n| format!("{n:.0}")),
|
||||
serial: None, // ePIC capabilities does not report a PSU serial
|
||||
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"),
|
||||
@@ -1353,6 +1418,28 @@ impl GetOperatingState for PowerPlayV1 {
|
||||
.and_then(Value::as_str)
|
||||
.and_then(OperatingState::from_label)
|
||||
}
|
||||
fn parse_tuner_status(&self, data: &HashMap<DataField, Value>) -> Option<String> {
|
||||
// ePIC PerpetualTune: Running gates it; the per-algorithm Optimized flag
|
||||
// distinguishes a settled tune from an in-progress one (round 19 #10, T3).
|
||||
let pt = data.get(&DataField::TunerStatus)?;
|
||||
if !pt.pointer("/Running").and_then(|v| v.as_bool()).unwrap_or(false) {
|
||||
return Some("Off".to_string());
|
||||
}
|
||||
let optimized = pt
|
||||
.pointer("/Algorithm")
|
||||
.and_then(|v| v.as_object())
|
||||
.and_then(|algos| {
|
||||
algos
|
||||
.values()
|
||||
.filter_map(|a| a.pointer("/Optimized").and_then(|v| v.as_bool()))
|
||||
.next()
|
||||
});
|
||||
Some(match optimized {
|
||||
Some(true) => "Optimized",
|
||||
_ => "Tuning",
|
||||
})
|
||||
.map(str::to_string)
|
||||
}
|
||||
}
|
||||
|
||||
impl GetIsMining for PowerPlayV1 {
|
||||
@@ -2173,6 +2260,15 @@ mod tests {
|
||||
|
||||
assert_eq!(miner_data.uptime, Some(Duration::from_secs(23170)));
|
||||
assert_eq!(miner_data.wattage, Some(Power::from_watts(2166.6174)));
|
||||
// Miner-level fan duty cycle from summary /Fans/Fans Speed (round 19 #10, T3).
|
||||
assert_eq!(miner_data.fan_speed_percent, Some(100.0));
|
||||
// Board temp thresholds from summary /Misc (round 19 #10, T3): Shutdown->hot,
|
||||
// Critical->dangerous, no target.
|
||||
assert_eq!(miner_data.temp_target, None);
|
||||
assert_eq!(miner_data.temp_hot, Some(85.0));
|
||||
assert_eq!(miner_data.temp_dangerous, Some(100.0));
|
||||
// Auto-tuner: PerpetualTune Running=true, Optimized=false -> Tuning (T3).
|
||||
assert_eq!(miner_data.tuner_status.as_deref(), Some("Tuning"));
|
||||
assert_eq!(miner_data.hashboards.len(), 3);
|
||||
assert_eq!(miner_data.hashboards[0].active, Some(false));
|
||||
assert_eq!(miner_data.hashboards[1].chips.len(), 110);
|
||||
|
||||
@@ -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":"abcf1ffb8443efa70838489b026730ac19de774ba9e6f7c9a9800e3ba03c06a4","src/backends/v1/rpc.rs":"25b0b9d56fbf113d5b8c3d3bc8eb7a0d67967b1f90f6d855da0b9f6ff24ae335","src/firmware.rs":"d95345295ae5043dfc357e69ae56c564b261fdb3b19b5c0ad1765267ff05ab3f","src/lib.rs":"53f7acddeff8f7d82f80d09e0a9f91962011f9ccf2e441c4ca05cd7fc4eb292e","src/test/json/mod.rs":"24191681066d5cf6a3022ad59c1baa92b57e3ce7717bb78d6a682af9e19a38c4","src/test/json/v1/config.json":"6ca9e6217d853d4bf1e75d69159630e9c9184ede96751706b88dfb699b5d59ad","src/test/json/v1/devs.json":"8f746dc6a02953eee5ee96dcf53be8dc7880a8ffc2c6e303f0284bcf6a97f42d","src/test/json/v1/events.json":"913683ff97af3333018807e1cc6e43467ea8a55925e5964dc402616615e2a5e3","src/test/json/v1/fans.json":"f8a9a1234d651055c80f4ebb1380bbb4e6d19eb33012902c55fff1385e592447","src/test/json/v1/healthchipget_0.json":"10619460049333ca016b2beec59ecc514ed9077fb19bdf7d0ed697201f8cb96c","src/test/json/v1/healthchipget_1.json":"80927fb1480c95be7f3a4e155d63f68f97720530ff7cf5d5ade06f2a3e810bf0","src/test/json/v1/healthchipget_2.json":"1e93ee2ab472ee7af58add08b4251e3ce0ad4f986d4325abbf43fd4c9b3dd28f","src/test/json/v1/mod.rs":"5a050f07455e622e35ad79ab1c8a6daf2ea38c4198472e49c6bbfe80538a9e48","src/test/json/v1/pools.json":"0068745327e31853fec051172abb7337f18a4cf9972c51967113d63f4f31f504","src/test/json/v1/power.json":"80534bb4581de7c8b747bf33b5d629b909c6e16a531d18ecb4afd7ffad3f014f","src/test/json/v1/profiles.json":"1f00429036e270daa08f12cd2d7357135070c57acd7a899a3c0af6167fe82abb","src/test/json/v1/stats.json":"2b105f0eb927046c9d2389bde978a43e3d54d12a420dfbe400786bb2f0ae31ca","src/test/json/v1/summary.json":"aaea3378eb7040952037e2f1ef7bd5f20a1b242bf93d4ba0501c46104b0b31a0","src/test/json/v1/temps.json":"1ee781cd2be3ed6a6a07e23be930248735fb51348c160453ba10f6ef71fcb7f1","src/test/json/v1/version.json":"4beb6ca5c0ebf359cee0434fdcc4d0a1a0607436634e46be3fd951e2256595df","src/test/json/v1/voltageget_0.json":"c445fa8674c2542b2d296fbafdd3166c53008dfbd9da8095327217989d37f1da","src/test/json/v1/voltageget_1.json":"96b91c3447dd66e7f1f575ed3b99611062e8b1d516d31422b74e425c46b2f49c","src/test/json/v1/voltageget_2.json":"7d40544021b2e32401135ae333067b770d2d736ada9e60deaca8fd8f5a79a1e3","src/test/mod.rs":"ed52c3d613eabc4a0346bb38bcfdf7a94933d61e368d3c9094821edeab92f81b"},"package":"513792d93a2a21d5258d9e6ac0e6dc9e0a6365118934514b4e656792add78066"}
|
||||
{"$comment":"This file only protects against accidental modifications. It is not a security mechanism and does not protect against malicious changes.","files":{".cargo_vcs_info.json":"fe8effe2bfdda5d4c390656c016729f531a2b1c60033228557659c0befdde9f2","Cargo.lock":"a2b2cb45bb8b574e4f29ffdcdb5ebafd1dd87a0e6e11b47383973a99be367784","Cargo.toml":"503efa00123f8567f5fe40bf6a93e9e453d13094df0e0e1b7e98bdacdfbd2595","Cargo.toml.orig":"1c4ba0315fb491c086fc22a5c9bafaf7288c6b1fd48679c3d03dbd9df156a8b5","src/backends/mod.rs":"548d988b877410e330a55e275f64b2adad95ca5f1a0f085fe144957c96b8906f","src/backends/v1/mod.rs":"a66ca11f7ab20d83d17ef0b6106810524902e0650ac770144f3998e597dd0541","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":"e8d449dbe57fd97fa70908673438c069a050548e800b6e9762c5a622bd7acc6d","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"}
|
||||
@@ -16,10 +16,11 @@ use asic_rs_core::{
|
||||
command::MinerCommand,
|
||||
device::{DeviceInfo, HashAlgorithm},
|
||||
fan::FanData,
|
||||
hashrate::{HashRate, HashRateUnit},
|
||||
hashrate::{HashRate, HashRateUnit, HashrateAverages},
|
||||
message::{MessageSeverity, MinerMessage},
|
||||
miner::TuningTarget,
|
||||
pool::{PoolData, PoolGroupData, PoolURL},
|
||||
share::{ShareSummary, parse_cgminer_share_summary},
|
||||
},
|
||||
traits::{miner::*, model::MinerModel},
|
||||
};
|
||||
@@ -277,6 +278,11 @@ impl GetDataLocations for LuxMinerV1 {
|
||||
parameters: None,
|
||||
};
|
||||
|
||||
const RPC_TEMPCTRL: MinerCommand = MinerCommand::RPC {
|
||||
command: "tempctrl",
|
||||
parameters: None,
|
||||
};
|
||||
|
||||
match data_field {
|
||||
DataField::Mac => vec![(
|
||||
RPC_CONFIG,
|
||||
@@ -294,6 +300,26 @@ impl GetDataLocations for LuxMinerV1 {
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
// Miner-level fan duty cycle (round 19 #10, T3): max of per-fan Speed;
|
||||
// RPC_FANS already fetched.
|
||||
DataField::FanSpeedPercent => vec![(
|
||||
RPC_FANS,
|
||||
DataExtractor {
|
||||
func: get_by_pointer,
|
||||
key: Some("/FANS"),
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
// Board temp thresholds (round 19 #10, T3): LuxOS tempctrl reports
|
||||
// ChipTarget / ChipHot / ChipDangerous.
|
||||
DataField::TemperatureLimits => vec![(
|
||||
RPC_TEMPCTRL,
|
||||
DataExtractor {
|
||||
func: get_by_pointer,
|
||||
key: Some("/TEMPCTRL/0"),
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
DataField::ApiVersion => vec![(
|
||||
RPC_VERSION,
|
||||
DataExtractor {
|
||||
@@ -455,6 +481,16 @@ impl GetDataLocations for LuxMinerV1 {
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
// Cumulative share stats from LuxOS summary (round 19 #10, T2);
|
||||
// RPC_SUMMARY already fetched.
|
||||
DataField::ShareSummary => vec![(
|
||||
RPC_SUMMARY,
|
||||
DataExtractor {
|
||||
func: get_by_pointer,
|
||||
key: Some("/SUMMARY/0"),
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
DataField::SessionBestShare => vec![(
|
||||
RPC_SUMMARY,
|
||||
DataExtractor {
|
||||
@@ -537,6 +573,16 @@ impl GetDataLocations for LuxMinerV1 {
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
// LuxOS summary exposes full rolling windows GHS 1m/5m/15m/24h
|
||||
// (GigaHash); RPC_SUMMARY is already fetched (round 19 #10, T2).
|
||||
DataField::HashrateAverages => vec![(
|
||||
RPC_SUMMARY,
|
||||
DataExtractor {
|
||||
func: get_by_pointer,
|
||||
key: Some("/SUMMARY/0"),
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
DataField::ExpectedHashrate => vec![(
|
||||
RPC_DEVS,
|
||||
DataExtractor {
|
||||
@@ -659,6 +705,20 @@ impl GetFluidTemperature for LuxMinerV1 {
|
||||
(None, None) => None,
|
||||
}
|
||||
}
|
||||
fn parse_temperature_limits(
|
||||
&self,
|
||||
data: &HashMap<DataField, Value>,
|
||||
) -> (Option<f64>, Option<f64>, Option<f64>) {
|
||||
// LuxOS tempctrl chip thresholds ChipTarget / ChipHot / ChipDangerous
|
||||
// (round 19 #10, T3).
|
||||
let d = data.get(&DataField::TemperatureLimits);
|
||||
let f = |k: &str| {
|
||||
d.and_then(|v| v.get(k))
|
||||
.and_then(|v| v.as_f64())
|
||||
.filter(|v| v.is_finite() && *v > 0.0)
|
||||
};
|
||||
(f("ChipTarget"), f("ChipHot"), f("ChipDangerous"))
|
||||
}
|
||||
}
|
||||
|
||||
impl GetFirmwareVersion for LuxMinerV1 {
|
||||
@@ -843,6 +903,30 @@ impl GetHashrate for LuxMinerV1 {
|
||||
.as_unit(HashRateUnit::default())
|
||||
})
|
||||
}
|
||||
fn parse_hashrate_averages(&self, data: &HashMap<DataField, Value>) -> Option<HashrateAverages> {
|
||||
// LuxOS summary GHS 1m/5m/15m/24h (GigaHash); full window set (round 19 #10).
|
||||
let d = data.get(&DataField::HashrateAverages)?;
|
||||
let ghs = |k: &str| {
|
||||
d.pointer(k)
|
||||
.and_then(|v| v.as_f64())
|
||||
.filter(|&f| f > 0.0)
|
||||
.map(|f| {
|
||||
HashRate {
|
||||
value: f,
|
||||
unit: HashRateUnit::GigaHash,
|
||||
algo: self.device_info.algo,
|
||||
}
|
||||
.as_unit(HashRateUnit::default())
|
||||
})
|
||||
};
|
||||
let avgs = HashrateAverages {
|
||||
avg_1m: ghs("/GHS 1m"),
|
||||
avg_5m: ghs("/GHS 5m"),
|
||||
avg_15m: ghs("/GHS 15m"),
|
||||
avg_24h: ghs("/GHS 24h"),
|
||||
};
|
||||
(!avgs.is_empty()).then_some(avgs)
|
||||
}
|
||||
}
|
||||
|
||||
impl GetExpectedHashrate for LuxMinerV1 {
|
||||
@@ -891,6 +975,17 @@ impl GetFans for LuxMinerV1 {
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
fn parse_fan_speed_percent(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
|
||||
// LuxOS FANS[].Speed is per-fan duty %; report the fleet-facing maximum
|
||||
// (round 19 #10, T3).
|
||||
data.get(&DataField::FanSpeedPercent)
|
||||
.and_then(|v| v.as_array())
|
||||
.into_iter()
|
||||
.flatten()
|
||||
.filter_map(|f| f.get("Speed").and_then(|v| v.as_f64()))
|
||||
.filter(|v| v.is_finite() && *v >= 0.0)
|
||||
.max_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal))
|
||||
}
|
||||
}
|
||||
|
||||
impl GetLightFlashing for LuxMinerV1 {
|
||||
@@ -911,6 +1006,10 @@ impl GetBestShare for LuxMinerV1 {
|
||||
// LuxOS summary -> "Best Share" (all-time), round 16 / G9.
|
||||
data.extract::<f64>(DataField::BestShare)
|
||||
}
|
||||
fn parse_share_summary(&self, data: &HashMap<DataField, Value>) -> Option<ShareSummary> {
|
||||
data.get(&DataField::ShareSummary)
|
||||
.and_then(parse_cgminer_share_summary)
|
||||
}
|
||||
}
|
||||
impl GetSessionBestShare for LuxMinerV1 {
|
||||
fn parse_session_best_share(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
|
||||
@@ -1395,7 +1494,8 @@ mod tests {
|
||||
use super::*;
|
||||
use crate::test::json::v1::{
|
||||
CONFIG, DEVS, EVENTS, FANS, HEALTHCHIPGET_0, HEALTHCHIPGET_1, HEALTHCHIPGET_2, POOLS,
|
||||
POWER, PROFILES, STATS, SUMMARY, TEMPS, VERSION, VOLTAGEGET_0, VOLTAGEGET_1, VOLTAGEGET_2,
|
||||
POWER, PROFILES, STATS, SUMMARY, TEMPCTRL, TEMPS, VERSION, VOLTAGEGET_0, VOLTAGEGET_1,
|
||||
VOLTAGEGET_2,
|
||||
};
|
||||
|
||||
#[test]
|
||||
@@ -1512,6 +1612,11 @@ mod tests {
|
||||
parameters: None,
|
||||
};
|
||||
|
||||
let tempctrl_cmd = MinerCommand::RPC {
|
||||
command: "tempctrl",
|
||||
parameters: None,
|
||||
};
|
||||
|
||||
results.insert(version_cmd, Value::from_str(VERSION)?);
|
||||
results.insert(stats_cmd, Value::from_str(STATS)?);
|
||||
results.insert(summary_cmd, Value::from_str(SUMMARY)?);
|
||||
@@ -1521,6 +1626,7 @@ mod tests {
|
||||
results.insert(power_cmd, Value::from_str(POWER)?);
|
||||
results.insert(profiles_cmd, Value::from_str(PROFILES)?);
|
||||
results.insert(temps_cmd, Value::from_str(TEMPS)?);
|
||||
results.insert(tempctrl_cmd, Value::from_str(TEMPCTRL)?);
|
||||
results.insert(devs_cmd, Value::from_str(DEVS)?);
|
||||
results.insert(
|
||||
MinerCommand::RPC {
|
||||
@@ -1631,6 +1737,14 @@ mod tests {
|
||||
Some(TuningTarget::Power(Power::from_watts(1188f64)))
|
||||
);
|
||||
assert_eq!(miner_data.fans.len(), 4);
|
||||
// Miner-level fan duty cycle = max of per-fan Speed (all 20 here); round 19
|
||||
// #10, T3.
|
||||
assert_eq!(miner_data.fan_speed_percent, Some(20.0));
|
||||
// Board temp thresholds from tempctrl ChipTarget/ChipHot/ChipDangerous
|
||||
// (round 19 #10, T3).
|
||||
assert_eq!(miner_data.temp_target, Some(83.0));
|
||||
assert_eq!(miner_data.temp_hot, Some(93.0));
|
||||
assert_eq!(miner_data.temp_dangerous, Some(100.0));
|
||||
assert_eq!(miner_data.hashboards[0].chips.len(), 77);
|
||||
assert_eq!(miner_data.pools.len(), 2);
|
||||
assert_eq!(miner_data.pools[0].len(), 2);
|
||||
|
||||
@@ -10,6 +10,7 @@ pub(crate) const PROFILES: &str = include_str!("profiles.json");
|
||||
pub(crate) const STATS: &str = include_str!("stats.json");
|
||||
pub(crate) const SUMMARY: &str = include_str!("summary.json");
|
||||
pub(crate) const TEMPS: &str = include_str!("temps.json");
|
||||
pub(crate) const TEMPCTRL: &str = include_str!("tempctrl.json");
|
||||
pub(crate) const VERSION: &str = include_str!("version.json");
|
||||
pub(crate) const EVENTS: &str = include_str!("events.json");
|
||||
|
||||
|
||||
@@ -0,0 +1,26 @@
|
||||
{
|
||||
"STATUS": [
|
||||
{
|
||||
"Code": 200,
|
||||
"Description": "LUXminer 2026.9.21.003141-c8f244146",
|
||||
"Msg": "Temperature control",
|
||||
"STATUS": "S",
|
||||
"When": 1790206067
|
||||
}
|
||||
],
|
||||
"TEMPCTRL": [
|
||||
{
|
||||
"ChipDangerous": 100.0,
|
||||
"ChipHot": 93.0,
|
||||
"ChipTarget": 83.0,
|
||||
"Dangerous": 70.0,
|
||||
"Hot": 65.0,
|
||||
"Mode": "Automatic",
|
||||
"Target": 45.0,
|
||||
"WaterInletDangerous": 50.0,
|
||||
"WaterInletHot": 49.0,
|
||||
"WaterInletStartup": 15.0
|
||||
}
|
||||
],
|
||||
"id": 1
|
||||
}
|
||||
@@ -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":"12ece361e797e765d9a8d0d233ae045a68f3473faa5da14ada40fdb691abf3a0","Cargo.lock":"b527674a090d313c33a0a22c4d0a81936d5e9c13c2dc4e0d5f468d0d4421f1b8","Cargo.toml":"2ab1a2951b599aa549512faaeadf0d386d291fe6505dc29bf164b234be40869b","Cargo.toml.orig":"8436254854a45004b0cbb2d518fa4b59832cac91de1e5600de32f5baa4300a8c","src/backends/mod.rs":"947a81f33fa6ec8c3a801ad127f59ad78d96de927c3e86bee4587e2aace2914d","src/backends/v2025/mod.rs":"4c7fbda80d5a4717a655538b043f9fe55bd24b676a14ac97f32a53f51a0be40d","src/backends/v2025/rpc.rs":"2ed396bfed1e5d39cd20f90629b10acbde98d8e5c6d35e42ab5309343c90aa8c","src/backends/v2025/web.rs":"07ceefc9813f9c12df4312b249ac9cd49eebaf8466478cf5cfb6c13cc85eee65","src/firmware.rs":"69a62f81a6e7e94b75c1f952f77403451da6945b0683d2e5edfcbd585cc6921e","src/lib.rs":"53f7acddeff8f7d82f80d09e0a9f91962011f9ccf2e441c4ca05cd7fc4eb292e","src/test/json/mod.rs":"53e0a575ba942b132519c759b328a9ca8fcd67aca3fbfa93b5266ee9661f3579","src/test/json/v2025/get_system_info.json":"d394dd5a4874846c7ab019723e7a6e6c64800ad90fb913bf4ab97af0d806c5ce","src/test/json/v2025/miner_psu_status.json":"d62162f8eb00c4494f9ea421f5f47be13cf89091b9416de38d18fadb33458372","src/test/json/v2025/mod.rs":"8bb0fd3c0af51ece34903a79085e285e99c6dd0f2d11f3e020515d399fc78696","src/test/json/v2025/pools.json":"6ab4894d5b6c6d6359a3d21189be3bffd17f7bd820816a12293e2e8911dbeb6f","src/test/json/v2025/stats.json":"4d54226c4396aba5151a6195744a78c3e60f2807af918849196e76d180ae55c6","src/test/json/v2025/summary.json":"f794595e7068ebc7ace7176f4381b61464057aaa3170d5307971e5fc1a2a37be","src/test/json/v2025/version.json":"177606e67c34a59867b320cb0fe8bf2d1d743ee1e8f14a24b7c588910f9ad22c","src/test/mod.rs":"ed52c3d613eabc4a0346bb38bcfdf7a94933d61e368d3c9094821edeab92f81b"},"package":"ff5e051802299683f94b3a3771f065071551c85a1cd21dc09a5f05efce0e90d5"}
|
||||
{"$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":"12ece361e797e765d9a8d0d233ae045a68f3473faa5da14ada40fdb691abf3a0","Cargo.lock":"b527674a090d313c33a0a22c4d0a81936d5e9c13c2dc4e0d5f468d0d4421f1b8","Cargo.toml":"2ab1a2951b599aa549512faaeadf0d386d291fe6505dc29bf164b234be40869b","Cargo.toml.orig":"8436254854a45004b0cbb2d518fa4b59832cac91de1e5600de32f5baa4300a8c","src/backends/mod.rs":"947a81f33fa6ec8c3a801ad127f59ad78d96de927c3e86bee4587e2aace2914d","src/backends/v2025/mod.rs":"db8ee27c551ae6b5e312e0975823839e3b465ccfdbecc190da2c4e40fa0db1ad","src/backends/v2025/rpc.rs":"2ed396bfed1e5d39cd20f90629b10acbde98d8e5c6d35e42ab5309343c90aa8c","src/backends/v2025/web.rs":"07ceefc9813f9c12df4312b249ac9cd49eebaf8466478cf5cfb6c13cc85eee65","src/firmware.rs":"69a62f81a6e7e94b75c1f952f77403451da6945b0683d2e5edfcbd585cc6921e","src/lib.rs":"53f7acddeff8f7d82f80d09e0a9f91962011f9ccf2e441c4ca05cd7fc4eb292e","src/test/json/mod.rs":"53e0a575ba942b132519c759b328a9ca8fcd67aca3fbfa93b5266ee9661f3579","src/test/json/v2025/get_system_info.json":"d394dd5a4874846c7ab019723e7a6e6c64800ad90fb913bf4ab97af0d806c5ce","src/test/json/v2025/miner_psu_status.json":"d62162f8eb00c4494f9ea421f5f47be13cf89091b9416de38d18fadb33458372","src/test/json/v2025/mod.rs":"8bb0fd3c0af51ece34903a79085e285e99c6dd0f2d11f3e020515d399fc78696","src/test/json/v2025/pools.json":"6ab4894d5b6c6d6359a3d21189be3bffd17f7bd820816a12293e2e8911dbeb6f","src/test/json/v2025/stats.json":"4d54226c4396aba5151a6195744a78c3e60f2807af918849196e76d180ae55c6","src/test/json/v2025/summary.json":"f794595e7068ebc7ace7176f4381b61464057aaa3170d5307971e5fc1a2a37be","src/test/json/v2025/version.json":"177606e67c34a59867b320cb0fe8bf2d1d743ee1e8f14a24b7c588910f9ad22c","src/test/mod.rs":"ed52c3d613eabc4a0346bb38bcfdf7a94933d61e368d3c9094821edeab92f81b"},"package":"ff5e051802299683f94b3a3771f065071551c85a1cd21dc09a5f05efce0e90d5"}
|
||||
@@ -474,6 +474,7 @@ impl GetHashboards for SealMinerV2025 {
|
||||
frequency: freq,
|
||||
tuned,
|
||||
active: Some(online),
|
||||
..Default::default()
|
||||
}
|
||||
})
|
||||
.collect()
|
||||
|
||||
@@ -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":"de321c89f62a60690ba07d6bb145ac688c6141c458638e68b3ed36b50b8de1f1","Cargo.lock":"5942ec7c9cf5c201bd32442d65020dc3ae72e33cb5aaf374b2a26501571a1487","Cargo.toml":"cb9ee00cbb415fa66a71a7d4822839bb3552336ec9ab975ae7b1137c711449cb","Cargo.toml.orig":"08409c395e4d502015da62e97efdc9c5bc6e3076031144f3f5aa35c900c7c735","src/backends/mod.rs":"26591e67688f8d015242295dde5050c4b34986e9980018a855346291a0472206","src/backends/v1_2_0/mod.rs":"fc68a12769890e18231255c6a53cb2c68e4706a887d91f49113c6192684340d2","src/backends/v1_2_0/web.rs":"ac89f16bf623f7d85590d34b45c99b0e522d9d434b4c22af7fa8a8a653e09d2e","src/backends/v1_3_0/mod.rs":"0bba1bf94e7a86d763dbedda3bb5d68cf760e17f744204b0bbc0de4e3754f795","src/backends/v1_3_0/web.rs":"1ec4cbe6bdc26f165d9e54e9bf2aac4c3706357ce4677dc21113710d4a26c3c1","src/firmware.rs":"168eeffaef90cb1525bb2e126e73905b5205d49215437263813e30323f6b7a05","src/lib.rs":"16ea1c0007fa6d6c86c1f83d3ac9cdf065cd9936cd52f35ef89c227397bbc54a","src/timezone.rs":"309bf23de1bdc9126bde5db8dabff0d2c0fea797dbf2630a772a18539838a05e"},"package":"1cb662e56f104c0fe45c8ccdac13f60cbcaad45ac228f939c6ac46ff40335052"}
|
||||
{"$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":"de321c89f62a60690ba07d6bb145ac688c6141c458638e68b3ed36b50b8de1f1","Cargo.lock":"5942ec7c9cf5c201bd32442d65020dc3ae72e33cb5aaf374b2a26501571a1487","Cargo.toml":"cb9ee00cbb415fa66a71a7d4822839bb3552336ec9ab975ae7b1137c711449cb","Cargo.toml.orig":"08409c395e4d502015da62e97efdc9c5bc6e3076031144f3f5aa35c900c7c735","src/backends/mod.rs":"26591e67688f8d015242295dde5050c4b34986e9980018a855346291a0472206","src/backends/v1_2_0/mod.rs":"1634197592d962894e330b65a808518734aa26af57f182ea64dca59e3e9eb58b","src/backends/v1_2_0/web.rs":"ac89f16bf623f7d85590d34b45c99b0e522d9d434b4c22af7fa8a8a653e09d2e","src/backends/v1_3_0/mod.rs":"ab0a02f3fe1e6400f07f2bd148cb05e027cfc1e5b1fbfe6f2f01a1dddf78bb51","src/backends/v1_3_0/web.rs":"1ec4cbe6bdc26f165d9e54e9bf2aac4c3706357ce4677dc21113710d4a26c3c1","src/firmware.rs":"168eeffaef90cb1525bb2e126e73905b5205d49215437263813e30323f6b7a05","src/lib.rs":"16ea1c0007fa6d6c86c1f83d3ac9cdf065cd9936cd52f35ef89c227397bbc54a","src/timezone.rs":"309bf23de1bdc9126bde5db8dabff0d2c0fea797dbf2630a772a18539838a05e"},"package":"1cb662e56f104c0fe45c8ccdac13f60cbcaad45ac228f939c6ac46ff40335052"}
|
||||
@@ -20,7 +20,7 @@ use asic_rs_core::{
|
||||
device::DeviceInfo,
|
||||
fan::FanData,
|
||||
hashrate::{HashRate, HashRateUnit},
|
||||
message::{MessageSeverity, MinerMessage},
|
||||
message::{MessageSeverity, MinerComponent, MinerMessage},
|
||||
miner::TuningTarget,
|
||||
operating_state::OperatingState,
|
||||
pool::{PoolData, PoolGroupData, PoolURL},
|
||||
@@ -353,14 +353,26 @@ impl GetDataLocations for VnishV120 {
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
DataField::Messages => vec![(
|
||||
WEB_SUMMARY,
|
||||
DataExtractor {
|
||||
func: get_by_pointer,
|
||||
key: Some("/miner/miner_status"),
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
DataField::Messages => vec![
|
||||
(
|
||||
WEB_SUMMARY,
|
||||
DataExtractor {
|
||||
func: get_by_pointer,
|
||||
key: Some("/miner/miner_status"),
|
||||
tag: Some("miner_status"),
|
||||
},
|
||||
),
|
||||
// Per-hashboard diagnostics (chip status buckets + per-chain state)
|
||||
// for per-board fault messages in parse_messages.
|
||||
(
|
||||
WEB_SUMMARY,
|
||||
DataExtractor {
|
||||
func: get_by_pointer,
|
||||
key: Some("/miner/chains"),
|
||||
tag: Some("chains"),
|
||||
},
|
||||
),
|
||||
],
|
||||
DataField::TuningTarget => vec![(
|
||||
WEB_SETTINGS,
|
||||
DataExtractor {
|
||||
@@ -369,6 +381,25 @@ impl GetDataLocations for VnishV120 {
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
// Miner-level fan duty cycle (round 19 #10, T3); summary already fetched.
|
||||
DataField::FanSpeedPercent => vec![(
|
||||
WEB_SUMMARY,
|
||||
DataExtractor {
|
||||
func: get_by_pointer,
|
||||
key: Some("/miner/cooling/fan_duty"),
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
// Board temp thresholds (round 19 #10, T3): settings restart_temp
|
||||
// (dangerous) + auto cooling target. Settings already fetched.
|
||||
DataField::TemperatureLimits => vec![(
|
||||
WEB_SETTINGS,
|
||||
DataExtractor {
|
||||
func: get_by_pointer,
|
||||
key: Some("/miner"),
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
_ => vec![],
|
||||
}
|
||||
}
|
||||
@@ -678,6 +709,12 @@ impl GetFans for VnishV120 {
|
||||
|
||||
fans
|
||||
}
|
||||
fn parse_fan_speed_percent(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
|
||||
// VNish summary /miner/cooling/fan_duty is a miner-level duty % (round 19 #10).
|
||||
data.get(&DataField::FanSpeedPercent)
|
||||
.and_then(|v| v.as_f64())
|
||||
.filter(|v| v.is_finite() && *v >= 0.0)
|
||||
}
|
||||
}
|
||||
|
||||
impl GetPsuFans for VnishV120 {}
|
||||
@@ -766,6 +803,26 @@ impl GetFluidTemperature for VnishV120 {
|
||||
.max()
|
||||
.map(|t| Temperature::from_celsius(t as f64))
|
||||
}
|
||||
fn parse_temperature_limits(
|
||||
&self,
|
||||
data: &HashMap<DataField, Value>,
|
||||
) -> (Option<f64>, Option<f64>, Option<f64>) {
|
||||
// VNish settings: restart_temp is the dangerous threshold; the auto cooling
|
||||
// mode "param" is the target temperature. No hot threshold (round 19 #10, T3).
|
||||
let m = data.get(&DataField::TemperatureLimits);
|
||||
let dangerous = m
|
||||
.and_then(|v| v.pointer("/misc/restart_temp"))
|
||||
.and_then(|v| v.as_f64())
|
||||
.filter(|v| v.is_finite() && *v > 0.0);
|
||||
let target = m
|
||||
.filter(|v| {
|
||||
v.pointer("/cooling/settings/mode/name").and_then(|n| n.as_str()) == Some("auto")
|
||||
})
|
||||
.and_then(|v| v.pointer("/cooling/settings/mode/param"))
|
||||
.and_then(|v| v.as_f64())
|
||||
.filter(|v| v.is_finite() && *v > 0.0);
|
||||
(target, None, dangerous)
|
||||
}
|
||||
}
|
||||
|
||||
impl GetWattage for VnishV120 {
|
||||
@@ -805,9 +862,12 @@ impl GetMessages for VnishV120 {
|
||||
/// reported here rather than computed from invented thresholds.
|
||||
fn parse_messages(&self, data: &HashMap<DataField, Value>) -> Vec<MinerMessage> {
|
||||
let mut messages = Vec::new();
|
||||
let msg = data.get(&DataField::Messages);
|
||||
|
||||
if let Some(status) = data.get(&DataField::Messages)
|
||||
&& let Some(state) = status.pointer("/miner_state").and_then(|v| v.as_str())
|
||||
// Miner-level state verdict (now under the "miner_status" tag).
|
||||
if let Some(state) = msg
|
||||
.and_then(|v| v.pointer("/miner_status/miner_state"))
|
||||
.and_then(|v| v.as_str())
|
||||
{
|
||||
let normal = matches!(
|
||||
state.to_lowercase().as_str(),
|
||||
@@ -827,6 +887,68 @@ impl GetMessages for VnishV120 {
|
||||
}
|
||||
}
|
||||
|
||||
// Per-hashboard faults from the summary chains (round 20 #1). VNish reports
|
||||
// per-chip status buckets (`red` = failed, `orange` = degraded, `grey` =
|
||||
// healthy) and a per-chain state; attribute each fault to its own board so
|
||||
// the Health column reds the right hashboard icon and that icon's tooltip
|
||||
// carries the specific fault, instead of everything landing on the miner-
|
||||
// level (brain) message. Chain ids are 1-based; board positions are 0-based.
|
||||
if let Some(chains) = msg
|
||||
.and_then(|v| v.pointer("/chains"))
|
||||
.and_then(|v| v.as_array())
|
||||
{
|
||||
for chain in chains {
|
||||
let Some(id) = chain.pointer("/id").and_then(|v| v.as_u64()) else {
|
||||
continue;
|
||||
};
|
||||
let idx = id.saturating_sub(1) as u16;
|
||||
let red = chain
|
||||
.pointer("/chip_statuses/red")
|
||||
.and_then(|v| v.as_u64())
|
||||
.unwrap_or(0);
|
||||
let orange = chain
|
||||
.pointer("/chip_statuses/orange")
|
||||
.and_then(|v| v.as_u64())
|
||||
.unwrap_or(0);
|
||||
let state = chain
|
||||
.pointer("/status/state")
|
||||
.and_then(|v| v.as_str())
|
||||
.unwrap_or("");
|
||||
let state_ok = matches!(
|
||||
state.to_lowercase().as_str(),
|
||||
"" | "mining" | "auto-tuning" | "auto_tuning" | "tuning"
|
||||
);
|
||||
|
||||
if red > 0 {
|
||||
messages.push(MinerMessage::with_component(
|
||||
0,
|
||||
0,
|
||||
format!("Hashboard {id}: {red} failed chip(s)"),
|
||||
MessageSeverity::Error,
|
||||
Some(MinerComponent::hashboard(idx)),
|
||||
));
|
||||
} else if !state_ok {
|
||||
// A board not in a normal state but with no failed chips: report
|
||||
// the state itself (e.g. "initializing", "disabled", "stopped").
|
||||
messages.push(MinerMessage::with_component(
|
||||
0,
|
||||
0,
|
||||
format!("Hashboard {id}: {state}"),
|
||||
MessageSeverity::Error,
|
||||
Some(MinerComponent::hashboard(idx)),
|
||||
));
|
||||
} else if orange > 0 {
|
||||
messages.push(MinerMessage::with_component(
|
||||
0,
|
||||
0,
|
||||
format!("Hashboard {id}: {orange} degraded chip(s)"),
|
||||
MessageSeverity::Warning,
|
||||
Some(MinerComponent::hashboard(idx)),
|
||||
));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
messages
|
||||
}
|
||||
}
|
||||
|
||||
@@ -20,7 +20,7 @@ use asic_rs_core::{
|
||||
device::DeviceInfo,
|
||||
fan::FanData,
|
||||
hashrate::{HashRate, HashRateUnit},
|
||||
message::{MessageSeverity, MinerMessage},
|
||||
message::{MessageSeverity, MinerComponent, MinerMessage},
|
||||
miner::TuningTarget,
|
||||
operating_state::OperatingState,
|
||||
pool::{PoolData, PoolGroupData, PoolURL},
|
||||
@@ -351,14 +351,26 @@ impl GetDataLocations for VnishV130 {
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
DataField::Messages => vec![(
|
||||
WEB_SUMMARY,
|
||||
DataExtractor {
|
||||
func: get_by_pointer,
|
||||
key: Some("/miner/miner_status"),
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
DataField::Messages => vec![
|
||||
(
|
||||
WEB_SUMMARY,
|
||||
DataExtractor {
|
||||
func: get_by_pointer,
|
||||
key: Some("/miner/miner_status"),
|
||||
tag: Some("miner_status"),
|
||||
},
|
||||
),
|
||||
// Per-hashboard diagnostics (chip status buckets + per-chain state)
|
||||
// for per-board fault messages in parse_messages.
|
||||
(
|
||||
WEB_SUMMARY,
|
||||
DataExtractor {
|
||||
func: get_by_pointer,
|
||||
key: Some("/miner/chains"),
|
||||
tag: Some("chains"),
|
||||
},
|
||||
),
|
||||
],
|
||||
DataField::TuningPercent => vec![(
|
||||
WEB_SUMMARY,
|
||||
DataExtractor {
|
||||
@@ -375,6 +387,26 @@ impl GetDataLocations for VnishV130 {
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
// Miner-level fan duty cycle (round 19 #10, T3); summary already fetched.
|
||||
DataField::FanSpeedPercent => vec![(
|
||||
WEB_SUMMARY,
|
||||
DataExtractor {
|
||||
func: get_by_pointer,
|
||||
key: Some("/miner/cooling/fan_duty"),
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
// Board temp thresholds (round 19 #10, T3): settings /miner/misc/restart_temp
|
||||
// (dangerous) + auto cooling target (/miner/cooling/settings/mode/param).
|
||||
// Settings already fetched for the tuning preset.
|
||||
DataField::TemperatureLimits => vec![(
|
||||
WEB_SETTINGS,
|
||||
DataExtractor {
|
||||
func: get_by_pointer,
|
||||
key: Some("/miner"),
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
_ => vec![],
|
||||
}
|
||||
}
|
||||
@@ -683,6 +715,12 @@ impl GetFans for VnishV130 {
|
||||
|
||||
fans
|
||||
}
|
||||
fn parse_fan_speed_percent(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
|
||||
// VNish summary /miner/cooling/fan_duty is a miner-level duty % (round 19 #10).
|
||||
data.get(&DataField::FanSpeedPercent)
|
||||
.and_then(|v| v.as_f64())
|
||||
.filter(|v| v.is_finite() && *v >= 0.0)
|
||||
}
|
||||
}
|
||||
|
||||
impl GetPsuFans for VnishV130 {}
|
||||
@@ -716,6 +754,26 @@ impl GetFluidTemperature for VnishV130 {
|
||||
.max()
|
||||
.map(|t| Temperature::from_celsius(t as f64))
|
||||
}
|
||||
fn parse_temperature_limits(
|
||||
&self,
|
||||
data: &HashMap<DataField, Value>,
|
||||
) -> (Option<f64>, Option<f64>, Option<f64>) {
|
||||
// VNish settings: restart_temp is the dangerous threshold; the auto cooling
|
||||
// mode "param" is the target temperature. No hot threshold (round 19 #10, T3).
|
||||
let m = data.get(&DataField::TemperatureLimits);
|
||||
let dangerous = m
|
||||
.and_then(|v| v.pointer("/misc/restart_temp"))
|
||||
.and_then(|v| v.as_f64())
|
||||
.filter(|v| v.is_finite() && *v > 0.0);
|
||||
let target = m
|
||||
.filter(|v| {
|
||||
v.pointer("/cooling/settings/mode/name").and_then(|n| n.as_str()) == Some("auto")
|
||||
})
|
||||
.and_then(|v| v.pointer("/cooling/settings/mode/param"))
|
||||
.and_then(|v| v.as_f64())
|
||||
.filter(|v| v.is_finite() && *v > 0.0);
|
||||
(target, None, dangerous)
|
||||
}
|
||||
}
|
||||
|
||||
impl GetWattage for VnishV130 {
|
||||
@@ -759,9 +817,12 @@ impl GetMessages for VnishV130 {
|
||||
/// reported here rather than computed from invented thresholds.
|
||||
fn parse_messages(&self, data: &HashMap<DataField, Value>) -> Vec<MinerMessage> {
|
||||
let mut messages = Vec::new();
|
||||
let msg = data.get(&DataField::Messages);
|
||||
|
||||
if let Some(status) = data.get(&DataField::Messages)
|
||||
&& let Some(state) = status.pointer("/miner_state").and_then(|v| v.as_str())
|
||||
// Miner-level state verdict (now under the "miner_status" tag).
|
||||
if let Some(state) = msg
|
||||
.and_then(|v| v.pointer("/miner_status/miner_state"))
|
||||
.and_then(|v| v.as_str())
|
||||
{
|
||||
let normal = matches!(
|
||||
state.to_lowercase().as_str(),
|
||||
@@ -781,6 +842,68 @@ impl GetMessages for VnishV130 {
|
||||
}
|
||||
}
|
||||
|
||||
// Per-hashboard faults from the summary chains (round 20 #1). VNish reports
|
||||
// per-chip status buckets (`red` = failed, `orange` = degraded, `grey` =
|
||||
// healthy) and a per-chain state; attribute each fault to its own board so
|
||||
// the Health column reds the right hashboard icon and that icon's tooltip
|
||||
// carries the specific fault, instead of everything landing on the miner-
|
||||
// level (brain) message. Chain ids are 1-based; board positions are 0-based.
|
||||
if let Some(chains) = msg
|
||||
.and_then(|v| v.pointer("/chains"))
|
||||
.and_then(|v| v.as_array())
|
||||
{
|
||||
for chain in chains {
|
||||
let Some(id) = chain.pointer("/id").and_then(|v| v.as_u64()) else {
|
||||
continue;
|
||||
};
|
||||
let idx = id.saturating_sub(1) as u16;
|
||||
let red = chain
|
||||
.pointer("/chip_statuses/red")
|
||||
.and_then(|v| v.as_u64())
|
||||
.unwrap_or(0);
|
||||
let orange = chain
|
||||
.pointer("/chip_statuses/orange")
|
||||
.and_then(|v| v.as_u64())
|
||||
.unwrap_or(0);
|
||||
let state = chain
|
||||
.pointer("/status/state")
|
||||
.and_then(|v| v.as_str())
|
||||
.unwrap_or("");
|
||||
let state_ok = matches!(
|
||||
state.to_lowercase().as_str(),
|
||||
"" | "mining" | "auto-tuning" | "auto_tuning" | "tuning"
|
||||
);
|
||||
|
||||
if red > 0 {
|
||||
messages.push(MinerMessage::with_component(
|
||||
0,
|
||||
0,
|
||||
format!("Hashboard {id}: {red} failed chip(s)"),
|
||||
MessageSeverity::Error,
|
||||
Some(MinerComponent::hashboard(idx)),
|
||||
));
|
||||
} else if !state_ok {
|
||||
// A board not in a normal state but with no failed chips: report
|
||||
// the state itself (e.g. "initializing", "disabled", "stopped").
|
||||
messages.push(MinerMessage::with_component(
|
||||
0,
|
||||
0,
|
||||
format!("Hashboard {id}: {state}"),
|
||||
MessageSeverity::Error,
|
||||
Some(MinerComponent::hashboard(idx)),
|
||||
));
|
||||
} else if orange > 0 {
|
||||
messages.push(MinerMessage::with_component(
|
||||
0,
|
||||
0,
|
||||
format!("Hashboard {id}: {orange} degraded chip(s)"),
|
||||
MessageSeverity::Warning,
|
||||
Some(MinerComponent::hashboard(idx)),
|
||||
));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
messages
|
||||
}
|
||||
}
|
||||
@@ -1354,6 +1477,28 @@ mod tests {
|
||||
);
|
||||
}
|
||||
|
||||
/// Fan duty cycle (summary /miner/cooling/fan_duty) and board temp thresholds
|
||||
/// (settings restart_temp -> dangerous, auto cooling param -> target); round 19
|
||||
/// #10, T3. Values match the live 10.4.1.50 fleet unit.
|
||||
#[test]
|
||||
fn fan_duty_and_temp_thresholds() {
|
||||
let miner = VnishV130::new(IpAddr::from([127, 0, 0, 1]), AntMinerModel::S19jPro);
|
||||
let mut data: HashMap<DataField, Value> = HashMap::new();
|
||||
data.insert(DataField::FanSpeedPercent, json!(81));
|
||||
data.insert(
|
||||
DataField::TemperatureLimits,
|
||||
json!({
|
||||
"misc": { "restart_temp": 90 },
|
||||
"cooling": { "settings": { "mode": { "name": "auto", "param": 65 } } }
|
||||
}),
|
||||
);
|
||||
assert_eq!(miner.parse_fan_speed_percent(&data), Some(81.0));
|
||||
assert_eq!(
|
||||
miner.parse_temperature_limits(&data),
|
||||
(Some(65.0), None, Some(90.0))
|
||||
);
|
||||
}
|
||||
|
||||
/// An L9 is a Scrypt miner and VNish says so in `/info`, both in
|
||||
/// `algorithm` and by reporting `hr_measure: MH/s`. Before this was wired
|
||||
/// up it came back as a SHA-256 miner and every figure was read as GH/s,
|
||||
|
||||
@@ -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":"1ada5892a5758e97d315b7e6550623bd1cf7062c84e701a7145fe4e9b84068a3","src/backends/v1/rpc.rs":"72f9b67c2389ab6e9968e0eb340bd2b6aad9aaf059f4429eb31398863bb87f42","src/backends/v2/mod.rs":"b9c23ad19f8921052b909d4f98e989ee0d0cecc4bd738f47e80404eb3d762656","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":"a12ec375a02238d5e26b64e2f7aeb0fc336747d86ae012dc154265ee5afaabbf","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":"2b1532bad5a75f90bb6556c9856ccb13522935779678eb764dd6de546ee0999d","src/backends/v1/rpc.rs":"72f9b67c2389ab6e9968e0eb340bd2b6aad9aaf059f4429eb31398863bb87f42","src/backends/v2/mod.rs":"b490e6ae2438b798c866800345e25ae1689f0d43237a9c165a2cca9bbe567c40","src/backends/v2/rpc.rs":"52f8d504c236009b020bf33b5550236e36d07b2c73a15bdcfcafa5188e4e1cb6","src/backends/v3/mod.rs":"fe308cc4944a5abbb578a3c87c1538ba189d25fdaae4c06faeb151a3cb5aedc7","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":"a12ec375a02238d5e26b64e2f7aeb0fc336747d86ae012dc154265ee5afaabbf","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"}
|
||||
@@ -14,11 +14,12 @@ use asic_rs_core::{
|
||||
command::MinerCommand,
|
||||
device::{DeviceInfo, HashAlgorithm},
|
||||
fan::FanData,
|
||||
hashrate::{HashRate, HashRateUnit},
|
||||
hashrate::{HashRate, HashRateUnit, HashrateAverages},
|
||||
message::{MessageSeverity, MinerMessage},
|
||||
miner::TuningTarget,
|
||||
pool::{PoolData, PoolGroupData, PoolURL},
|
||||
psu::PsuInfo,
|
||||
share::{ShareSummary, parse_cgminer_share_summary},
|
||||
},
|
||||
traits::{miner::*, model::MinerModel},
|
||||
};
|
||||
@@ -204,14 +205,26 @@ impl GetDataLocations for WhatsMinerV1 {
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
DataField::Hashboards => vec![(
|
||||
RPC_DEVS,
|
||||
DataExtractor {
|
||||
func: get_by_pointer,
|
||||
key: Some(""),
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
DataField::Hashboards => vec![
|
||||
(
|
||||
RPC_DEVS,
|
||||
DataExtractor {
|
||||
func: get_by_pointer,
|
||||
key: Some(""),
|
||||
tag: None,
|
||||
},
|
||||
),
|
||||
// Merge in summary so "Chip Data" (miner-wide chip marking) is
|
||||
// available per board (round 19 #10); RPC_SUMMARY already fetched.
|
||||
(
|
||||
RPC_SUMMARY,
|
||||
DataExtractor {
|
||||
func: get_by_pointer,
|
||||
key: Some("/SUMMARY/0"),
|
||||
tag: None,
|
||||
},
|
||||
),
|
||||
],
|
||||
DataField::Pools => vec![(
|
||||
RPC_POOLS,
|
||||
DataExtractor {
|
||||
@@ -244,6 +257,36 @@ impl GetDataLocations for WhatsMinerV1 {
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
// Rolling average windows from btminer summary (round 19 #10, T2);
|
||||
// RPC_SUMMARY is already fetched.
|
||||
DataField::HashrateAverages => vec![(
|
||||
RPC_SUMMARY,
|
||||
DataExtractor {
|
||||
func: get_by_pointer,
|
||||
key: Some("/SUMMARY/0"),
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
// btminer summary "Best Share" (all-time); RPC_SUMMARY already fetched
|
||||
// (round 19 #10).
|
||||
DataField::BestShare => vec![(
|
||||
RPC_SUMMARY,
|
||||
DataExtractor {
|
||||
func: get_by_pointer,
|
||||
key: Some("/SUMMARY/0/Best Share"),
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
// Cumulative share stats from btminer summary (round 19 #10, T2);
|
||||
// RPC_SUMMARY already fetched.
|
||||
DataField::ShareSummary => vec![(
|
||||
RPC_SUMMARY,
|
||||
DataExtractor {
|
||||
func: get_by_pointer,
|
||||
key: Some("/SUMMARY/0"),
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
DataField::ExpectedHashrate => vec![(
|
||||
RPC_SUMMARY,
|
||||
DataExtractor {
|
||||
@@ -405,6 +448,20 @@ impl GetHashboards for WhatsMinerV1 {
|
||||
);
|
||||
}
|
||||
|
||||
// Chip marking from the merged summary "Chip Data" (miner-wide, first
|
||||
// token), applied to every board (round 19 #10).
|
||||
let chip_type = hashboard_data
|
||||
.pointer("/Chip Data")
|
||||
.and_then(|v| v.as_str())
|
||||
.and_then(|s| s.split_whitespace().next())
|
||||
.filter(|s| !s.is_empty())
|
||||
.map(str::to_string);
|
||||
if chip_type.is_some() {
|
||||
for board in hashboards.iter_mut() {
|
||||
board.chip_type = chip_type.clone();
|
||||
}
|
||||
}
|
||||
|
||||
hashboards
|
||||
}
|
||||
}
|
||||
@@ -419,6 +476,30 @@ impl GetHashrate for WhatsMinerV1 {
|
||||
.as_unit(HashRateUnit::default())
|
||||
})
|
||||
}
|
||||
fn parse_hashrate_averages(&self, data: &HashMap<DataField, Value>) -> Option<HashrateAverages> {
|
||||
// btminer summary MHS 1m/5m/15m (MegaHash); no 24h window (round 19 #10).
|
||||
let d = data.get(&DataField::HashrateAverages)?;
|
||||
let mhs = |k: &str| {
|
||||
d.pointer(k)
|
||||
.and_then(|v| v.as_f64())
|
||||
.filter(|&f| f > 0.0)
|
||||
.map(|f| {
|
||||
HashRate {
|
||||
value: f,
|
||||
unit: HashRateUnit::MegaHash,
|
||||
algo: self.device_info.algo,
|
||||
}
|
||||
.as_unit(HashRateUnit::default())
|
||||
})
|
||||
};
|
||||
let avgs = HashrateAverages {
|
||||
avg_1m: mhs("/MHS 1m"),
|
||||
avg_5m: mhs("/MHS 5m"),
|
||||
avg_15m: mhs("/MHS 15m"),
|
||||
avg_24h: None,
|
||||
};
|
||||
(!avgs.is_empty()).then_some(avgs)
|
||||
}
|
||||
}
|
||||
impl GetExpectedHashrate for WhatsMinerV1 {
|
||||
fn parse_expected_hashrate(&self, data: &HashMap<DataField, Value>) -> Option<HashRate> {
|
||||
@@ -483,6 +564,7 @@ impl GetWattage for WhatsMinerV1 {
|
||||
let psu = PsuInfo {
|
||||
model: s("/model").or_else(|| s("/name")),
|
||||
version: s("/hw_version").or_else(|| s("/sw_version")),
|
||||
serial: None, // v1/v2 get_psu does not report a serial (V3 does)
|
||||
voltage_min: None,
|
||||
voltage_max: None,
|
||||
output_voltage: None,
|
||||
@@ -548,7 +630,15 @@ impl GetUptime for WhatsMinerV1 {
|
||||
}
|
||||
}
|
||||
|
||||
impl GetBestShare for WhatsMinerV1 {}
|
||||
impl GetBestShare for WhatsMinerV1 {
|
||||
fn parse_best_share(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
|
||||
data.extract::<f64>(DataField::BestShare).filter(|&v| v > 0.0)
|
||||
}
|
||||
fn parse_share_summary(&self, data: &HashMap<DataField, Value>) -> Option<ShareSummary> {
|
||||
data.get(&DataField::ShareSummary)
|
||||
.and_then(parse_cgminer_share_summary)
|
||||
}
|
||||
}
|
||||
impl GetSessionBestShare for WhatsMinerV1 {}
|
||||
impl GetOperatingState for WhatsMinerV1 {}
|
||||
|
||||
@@ -909,6 +999,31 @@ mod integration_tests {
|
||||
algo: HashAlgorithm::SHA256,
|
||||
})
|
||||
);
|
||||
// Rolling averages: btminer summary MHS 1m/5m/15m (MegaHash), no 24h window
|
||||
// (round 19 #10, T2).
|
||||
let avgs = miner_data
|
||||
.hashrate_averages
|
||||
.ok_or_else(|| anyhow::anyhow!("v1 should expose rolling averages"))?;
|
||||
assert!(avgs.avg_1m.is_some() && avgs.avg_5m.is_some() && avgs.avg_15m.is_some());
|
||||
assert!(avgs.avg_24h.is_none());
|
||||
if let Some(hr) = &avgs.avg_1m {
|
||||
assert_eq!(hr.unit, HashRateUnit::TeraHash);
|
||||
assert!((hr.value - 67.43935249).abs() < 1e-6);
|
||||
}
|
||||
// Cumulative share stats from summary (round 19 #10, T2).
|
||||
let shares = miner_data
|
||||
.share_summary
|
||||
.ok_or_else(|| anyhow::anyhow!("v1 should expose share summary"))?;
|
||||
assert_eq!(shares.difficulty_accepted, Some(158334976.0));
|
||||
assert_eq!(shares.difficulty_rejected, Some(0.0));
|
||||
assert_eq!(shares.stale_shares, Some(0));
|
||||
assert_eq!(shares.found_blocks, Some(0));
|
||||
// Chip marking from summary "Chip Data" first token (round 19 #10).
|
||||
assert!(!miner_data.hashboards.is_empty());
|
||||
assert_eq!(
|
||||
miner_data.hashboards[0].chip_type.as_deref(),
|
||||
Some("HP5A01-19101436")
|
||||
);
|
||||
assert_eq!(miner_data.wattage, Some(Power::from_watts(3417f64)));
|
||||
assert_eq!(
|
||||
miner_data.tuning_target,
|
||||
|
||||
@@ -21,6 +21,7 @@ use asic_rs_core::{
|
||||
miner::{MiningMode, TuningTarget},
|
||||
pool::{PoolData, PoolGroupData, PoolURL},
|
||||
psu::PsuInfo,
|
||||
share::{ShareSummary, parse_cgminer_share_summary},
|
||||
},
|
||||
traits::{miner::*, model::MinerModel},
|
||||
util::is_expected_write_error,
|
||||
@@ -215,14 +216,26 @@ impl GetDataLocations for WhatsMinerV2 {
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
DataField::Hashboards => vec![(
|
||||
RPC_DEVS,
|
||||
DataExtractor {
|
||||
func: get_by_pointer,
|
||||
key: Some(""),
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
DataField::Hashboards => vec![
|
||||
(
|
||||
RPC_DEVS,
|
||||
DataExtractor {
|
||||
func: get_by_pointer,
|
||||
key: Some(""),
|
||||
tag: None,
|
||||
},
|
||||
),
|
||||
// Merge in summary so "Chip Data" (miner-wide chip marking) is
|
||||
// available per board (round 19 #10); RPC_SUMMARY already fetched.
|
||||
(
|
||||
RPC_SUMMARY,
|
||||
DataExtractor {
|
||||
func: get_by_pointer,
|
||||
key: Some("/SUMMARY/0"),
|
||||
tag: None,
|
||||
},
|
||||
),
|
||||
],
|
||||
DataField::Pools => vec![(
|
||||
RPC_POOLS,
|
||||
DataExtractor {
|
||||
@@ -255,6 +268,26 @@ impl GetDataLocations for WhatsMinerV2 {
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
// btminer summary "Best Share" (all-time); RPC_SUMMARY already fetched
|
||||
// (round 19 #10).
|
||||
DataField::BestShare => vec![(
|
||||
RPC_SUMMARY,
|
||||
DataExtractor {
|
||||
func: get_by_pointer,
|
||||
key: Some("/SUMMARY/0/Best Share"),
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
// Cumulative share stats from btminer summary (round 19 #10, T2);
|
||||
// RPC_SUMMARY already fetched.
|
||||
DataField::ShareSummary => vec![(
|
||||
RPC_SUMMARY,
|
||||
DataExtractor {
|
||||
func: get_by_pointer,
|
||||
key: Some("/SUMMARY/0"),
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
DataField::ExpectedHashrate => vec![(
|
||||
RPC_SUMMARY,
|
||||
DataExtractor {
|
||||
@@ -412,6 +445,20 @@ impl GetHashboards for WhatsMinerV2 {
|
||||
);
|
||||
}
|
||||
|
||||
// Chip marking from the merged summary "Chip Data" (miner-wide, first
|
||||
// token), applied to every board (round 19 #10).
|
||||
let chip_type = hashboard_data
|
||||
.pointer("/Chip Data")
|
||||
.and_then(|v| v.as_str())
|
||||
.and_then(|s| s.split_whitespace().next())
|
||||
.filter(|s| !s.is_empty())
|
||||
.map(str::to_string);
|
||||
if chip_type.is_some() {
|
||||
for board in hashboards.iter_mut() {
|
||||
board.chip_type = chip_type.clone();
|
||||
}
|
||||
}
|
||||
|
||||
hashboards
|
||||
}
|
||||
}
|
||||
@@ -490,6 +537,7 @@ impl GetWattage for WhatsMinerV2 {
|
||||
let psu = PsuInfo {
|
||||
model: s("/model").or_else(|| s("/name")),
|
||||
version: s("/hw_version").or_else(|| s("/sw_version")),
|
||||
serial: None, // v1/v2 get_psu does not report a serial (V3 does)
|
||||
voltage_min: None,
|
||||
voltage_max: None,
|
||||
output_voltage: None,
|
||||
@@ -577,7 +625,15 @@ impl GetUptime for WhatsMinerV2 {
|
||||
}
|
||||
}
|
||||
|
||||
impl GetBestShare for WhatsMinerV2 {}
|
||||
impl GetBestShare for WhatsMinerV2 {
|
||||
fn parse_best_share(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
|
||||
data.extract::<f64>(DataField::BestShare).filter(|&v| v > 0.0)
|
||||
}
|
||||
fn parse_share_summary(&self, data: &HashMap<DataField, Value>) -> Option<ShareSummary> {
|
||||
data.get(&DataField::ShareSummary)
|
||||
.and_then(parse_cgminer_share_summary)
|
||||
}
|
||||
}
|
||||
impl GetSessionBestShare for WhatsMinerV2 {}
|
||||
impl GetOperatingState for WhatsMinerV2 {}
|
||||
|
||||
|
||||
@@ -17,10 +17,11 @@ use asic_rs_core::{
|
||||
command::MinerCommand,
|
||||
device::{DeviceInfo, HashAlgorithm},
|
||||
fan::FanData,
|
||||
hashrate::{HashRate, HashRateUnit},
|
||||
hashrate::{HashRate, HashRateUnit, HashrateAverages},
|
||||
message::{MessageSeverity, MinerMessage},
|
||||
miner::{MiningMode, TuningTarget},
|
||||
pool::{PoolData, PoolGroupData, PoolURL},
|
||||
psu::PsuInfo,
|
||||
},
|
||||
traits::{miner::*, model::MinerModel},
|
||||
util::is_expected_write_error,
|
||||
@@ -235,6 +236,16 @@ impl GetDataLocations for WhatsMinerV3 {
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
// PSU identity block (round 19 #10): get.device.info /msg/power carries
|
||||
// model/type, sw/hwversion and the serial (sn). Already fetched.
|
||||
DataField::Psu => vec![(
|
||||
RPC_GET_DEVICE_INFO,
|
||||
DataExtractor {
|
||||
func: get_by_pointer,
|
||||
key: Some("/msg/power"),
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
DataField::Hashboards => vec![
|
||||
(
|
||||
RPC_GET_DEVICE_INFO,
|
||||
@@ -285,6 +296,16 @@ impl GetDataLocations for WhatsMinerV3 {
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
// Rolling averages from get.miner.status summary (round 19 #10, T2);
|
||||
// command already fetched. V3 exposes 1min and 15min only.
|
||||
DataField::HashrateAverages => vec![(
|
||||
rpc_get_miner_status_summary,
|
||||
DataExtractor {
|
||||
func: get_by_pointer,
|
||||
key: Some("/msg/summary"),
|
||||
tag: None,
|
||||
},
|
||||
)],
|
||||
DataField::ExpectedHashrate => vec![(
|
||||
rpc_get_miner_status_summary,
|
||||
DataExtractor {
|
||||
@@ -438,6 +459,19 @@ impl GetHashboards for WhatsMinerV3 {
|
||||
.map(|h| h.value > 0.0)
|
||||
.unwrap_or(false),
|
||||
);
|
||||
// Chip marking (per-board chipdataN, first token) + hashboard model
|
||||
// (miner-wide hash-board, e.g. "K40") from get.device.info (round 19 #10).
|
||||
board.chip_type = hashboard_data
|
||||
.pointer(&format!("/chipdata{idx}"))
|
||||
.and_then(|v| v.as_str())
|
||||
.and_then(|s| s.split_whitespace().next())
|
||||
.filter(|s| !s.is_empty())
|
||||
.map(str::to_string);
|
||||
board.hashboard_model = hashboard_data
|
||||
.pointer("/hash-board")
|
||||
.and_then(|v| v.as_str())
|
||||
.filter(|s| !s.is_empty())
|
||||
.map(str::to_string);
|
||||
}
|
||||
|
||||
hashboards
|
||||
@@ -454,6 +488,31 @@ impl GetHashrate for WhatsMinerV3 {
|
||||
.as_unit(HashRateUnit::default())
|
||||
})
|
||||
}
|
||||
fn parse_hashrate_averages(&self, data: &HashMap<DataField, Value>) -> Option<HashrateAverages> {
|
||||
// get.miner.status summary hash-1min / hash-15min (TeraHash); V3 reports
|
||||
// no 5m or 24h window (round 19 #10).
|
||||
let d = data.get(&DataField::HashrateAverages)?;
|
||||
let ths = |k: &str| {
|
||||
d.pointer(k)
|
||||
.and_then(|v| v.as_f64())
|
||||
.filter(|&f| f > 0.0)
|
||||
.map(|f| {
|
||||
HashRate {
|
||||
value: f,
|
||||
unit: HashRateUnit::TeraHash,
|
||||
algo: self.device_info.algo,
|
||||
}
|
||||
.as_unit(HashRateUnit::default())
|
||||
})
|
||||
};
|
||||
let avgs = HashrateAverages {
|
||||
avg_1m: ths("/hash-1min"),
|
||||
avg_5m: None,
|
||||
avg_15m: ths("/hash-15min"),
|
||||
avg_24h: None,
|
||||
};
|
||||
(!avgs.is_empty()).then_some(avgs)
|
||||
}
|
||||
}
|
||||
impl GetExpectedHashrate for WhatsMinerV3 {
|
||||
fn parse_expected_hashrate(&self, data: &HashMap<DataField, Value>) -> Option<HashRate> {
|
||||
@@ -509,6 +568,18 @@ impl GetWattage for WhatsMinerV3 {
|
||||
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> {
|
||||
// get.device.info /msg/power: model/type, sw/hwversion, sn (round 19 #10).
|
||||
let d = data.get(&DataField::Psu)?;
|
||||
let s = |k: &str| d.pointer(k).and_then(|v| v.as_str()).filter(|s| !s.is_empty()).map(str::to_string);
|
||||
let psu = PsuInfo {
|
||||
model: s("/model").or_else(|| s("/type")),
|
||||
version: s("/swversion").or_else(|| s("/hwversion")),
|
||||
serial: s("/sn"),
|
||||
..Default::default()
|
||||
};
|
||||
(psu != PsuInfo::default()).then_some(psu)
|
||||
}
|
||||
}
|
||||
/// Parses tuning target from V3 tagged data (mode from get.device.info, limit from summary).
|
||||
/// Mode "0" (Low) / "2" (High) → MiningMode, "1" (Normal) / unknown → Power(limit).
|
||||
@@ -1183,6 +1254,17 @@ mod integration_tests {
|
||||
assert!(miner_data.is_mining);
|
||||
assert_eq!(miner_data.fans.len(), 2);
|
||||
assert_eq!(miner_data.pools[0].len(), 3);
|
||||
// Chip marking (chipdataN first token) + hashboard model (hash-board);
|
||||
// round 19 #10.
|
||||
assert!(!miner_data.hashboards.is_empty());
|
||||
assert_eq!(
|
||||
miner_data.hashboards[0].chip_type.as_deref(),
|
||||
Some("K8EC374-2426")
|
||||
);
|
||||
assert_eq!(
|
||||
miner_data.hashboards[0].hashboard_model.as_deref(),
|
||||
Some("K40")
|
||||
);
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||