GGS
/
fwt_software
8
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 1 Wiki Activity
fwt_software/tests/test_hardwarechecks.cpp

350 lines
14 KiB
C++
Raw Blame History

#include "doctest/doctest.h"
#include "fgc/HardwareChecks.h"
using namespace fgc;
TEST_CASE("usbfs_memory_mb is checked against the value frames actually need") {
CHECK(checkUsbfsMemory("1000", 1000).pass);
CHECK(checkUsbfsMemory("2048\n", 1000).pass);
// The reboot default. This is the exact state that was found on the
// LattePanda and stalled frame delivery.
auto low = checkUsbfsMemory("16", 1000);
CHECK_FALSE(low.pass);
CHECK(low.detail.find("kernel cmdline") != std::string::npos);
}
TEST_CASE("an unreadable usbfs node fails rather than passing by default") {
// A check that did not happen must not report PASS - that is how a silent
// precondition regression survives a green test run.
CHECK_FALSE(checkUsbfsMemory("", 1000).pass);
CHECK_FALSE(checkUsbfsMemory("not-a-number", 1000).pass);
}
TEST_CASE("USB3 LPM must be off, and anything unreadable is a failure") {
CHECK(checkUsb3Lpm("0").pass);
CHECK(checkUsb3Lpm(" 0\n").pass);
auto on = checkUsb3Lpm("1");
CHECK_FALSE(on.pass);
CHECK(on.detail.find("re-enumerate") != std::string::npos);
CHECK_FALSE(checkUsb3Lpm("").pass);
}
TEST_CASE("an SMBus-only adapter is caught before it looks like a dead sensor") {
CHECK(checkI2cFunctionality(kI2cFuncI2c).pass);
CHECK(checkI2cFunctionality(kI2cFuncI2c | 0xF0).pass);
auto smbus = checkI2cFunctionality(0xF0); // SMBus bits only
CHECK_FALSE(smbus.pass);
CHECK(smbus.detail.find("i2cdetect -F") != std::string::npos);
}
TEST_CASE("a tower on limp-home values is a fault, however healthy it looks") {
// The case this exists for: USE DEFAULTS fills the firmware's cfg_rx mask
// completely, so the axis leaves NEEDCFG, reports READY and passes every
// state check - while running values that describe no real drivetrain.
auto r = checkNotLimpHome("yaw", 1);
CHECK(r.ran);
CHECK_FALSE(r.pass);
CHECK(r.detail.find("LIMP-HOME") != std::string::npos);
// It must send the reader to the cause, not to the symptom. "Re-send the
// values" is the wrong instruction when nobody ever sent any.
CHECK(r.detail.find("USE DEFAULTS") != std::string::npos);
CHECK(r.detail.find("Restart the host") != std::string::npos);
}
TEST_CASE("an axis on the host's own values passes") {
auto r = checkNotLimpHome("yaw", 0);
CHECK(r.ran);
CHECK(r.pass);
}
TEST_CASE("a firmware with no limp flag is a version skew, not a passing tower") {
// Absent must not read as limp=0. A firmware predating the flag genuinely
// cannot answer the question, and claiming PASS here would assert something
// the wire never said - the same -1-is-not-zero rule the current echo uses.
auto r = checkNotLimpHome("yaw", -1);
CHECK_FALSE(r.ran);
CHECK(r.detail.find("cannot be told apart") != std::string::npos);
}
TEST_CASE("an undeclared axis has no drivetrain skew to find") {
DrivetrainExpectation want; // declared == false
DrivetrainEcho got; // all -1
auto r = checkDrivetrainAdopted("yaw", want, got);
CHECK_FALSE(r.ran);
CHECK(r.pass);
}
TEST_CASE("a firmware that cannot echo the current is a version skew, not zero current") {
DrivetrainExpectation want{true, 80, 31, 7};
DrivetrainEcho got; // all absent
auto r = checkDrivetrainAdopted("yaw", want, got);
CHECK(r.ran);
CHECK_FALSE(r.pass);
CHECK(r.detail.find("predates") != std::string::npos);
CHECK(r.detail.find("Re-flash") != std::string::npos);
}
TEST_CASE("the IOTA tower's declared current, adopted") {
DrivetrainExpectation want{true, 80, 31, 7}; // 756 mA run, 189 mA homing at 75 mOhm
DrivetrainEcho got{80, 31, 7};
auto r = checkDrivetrainAdopted("yaw", want, got);
CHECK(r.ran);
CHECK(r.pass);
}
TEST_CASE("a homing current that did not land is named as the damaging case") {
// The exact failure that sheared the endstop: run current correct, homing
// current still at the firmware default.
DrivetrainExpectation want{true, 80, 31, 7};
DrivetrainEcho got{80, 31, 31};
auto r = checkDrivetrainAdopted("yaw", want, got);
CHECK_FALSE(r.pass);
CHECK(r.detail.find("homing IRUN wanted 7, firmware has 31") != std::string::npos);
CHECK(r.detail.find("endstop") != std::string::npos);
}
TEST_CASE("every mismatched field is reported, not just the first") {
DrivetrainExpectation want{true, 80, 31, 7};
DrivetrainEcho got{255, 16, 31};
auto r = checkDrivetrainAdopted("yaw", want, got);
CHECK_FALSE(r.pass);
CHECK(r.detail.find("GLOBALSCALER") != std::string::npos);
CHECK(r.detail.find("IRUN wanted 31") != std::string::npos);
CHECK(r.detail.find("homing IRUN") != std::string::npos);
}
// --- the generalised adoption check (config-plan A.6) -----------------------
TEST_CASE("an axis with nothing declared beyond the current is not checked") {
const DeclaredValue none[] = {{"steps_per_rev", false, 0, -1}};
auto r = checkDeclaredValues("yaw", none, 1);
CHECK_FALSE(r.ran);
CHECK(r.pass);
}
TEST_CASE("every declared value matching is a pass that says how many") {
const DeclaredValue v[] = {
{"steps_per_rev", true, 1210778, 1210778},
{"enc_deviation", true, 1500, 1500},
{"normal_speed", true, 39738, 39738},
};
auto r = checkDeclaredValues("yaw", v, 3);
CHECK(r.ran);
CHECK(r.pass);
CHECK(r.detail.find("all 3") != std::string::npos);
}
TEST_CASE("a firmware that cannot echo a declared value fails, and is named a skew") {
// Not a mismatch: the value cannot be confirmed either way, and a check that
// did not happen must never read as a pass.
const DeclaredValue v[] = {
{"steps_per_rev", true, 1210778, -1},
{"enc_deviation", true, 1500, -1},
};
auto r = checkDeclaredValues("yaw", v, 2);
CHECK(r.ran);
CHECK_FALSE(r.pass);
CHECK(r.detail.find("does not echo 2") != std::string::npos);
CHECK(r.detail.find("Re-flash") != std::string::npos);
}
TEST_CASE("a lost SET is caught, and every wrong field is named") {
// The failure mode the handshake introduces: most SETs land, one does not,
// and the axis runs on a value nobody declared.
const DeclaredValue v[] = {
{"steps_per_rev", true, 1210778, 1210778},
{"enc_deviation", true, 1500, 177000}, // stale Delta value
{"homing_speed", true, 9958, 12000}, // firmware default
};
auto r = checkDeclaredValues("yaw", v, 3);
CHECK_FALSE(r.pass);
CHECK(r.detail.find("enc_deviation wanted 1500, firmware has 177000") != std::string::npos);
CHECK(r.detail.find("homing_speed wanted 9958, firmware has 12000") != std::string::npos);
CHECK(r.detail.find("NEEDCFG") != std::string::npos);
}
TEST_CASE("an undeclared value is skipped even when the firmware echoes one") {
// hardware.ini not declaring it means the firmware default IS the intent.
const DeclaredValue v[] = {
{"steps_per_rev", true, 1210778, 1210778},
{"sw_mode", false, 0, 3},
};
auto r = checkDeclaredValues("yaw", v, 2);
CHECK(r.pass);
CHECK(r.detail.find("all 1") != std::string::npos);
}
TEST_CASE("a partly echoed current is a version skew, not a wrong value") {
// The bug this caught: comparing an absent field against -1 reported
// "firmware has -1", which reads as a wrong value and sends someone to
// re-send a CURRENT that was never the problem.
DrivetrainExpectation want{true, 80, 31, 7};
DrivetrainEcho got;
got.global_scaler = 80; // echoed
got.run_irun = -1; // not echoed
got.homing_irun = -1;
auto r = checkDrivetrainAdopted("yaw", want, got);
CHECK_FALSE(r.pass);
CHECK(r.detail.find("2 of 3 fields absent") != std::string::npos);
CHECK(r.detail.find("firmware has -1") == std::string::npos);
}
TEST_CASE("a real mismatch alongside an absent field still names the mismatch") {
DrivetrainExpectation want{true, 80, 31, 7};
DrivetrainEcho got;
got.global_scaler = 255; // wrong
got.run_irun = 31; // right
got.homing_irun = -1; // absent
auto r = checkDrivetrainAdopted("yaw", want, got);
CHECK_FALSE(r.pass);
CHECK(r.detail.find("GLOBALSCALER wanted 80, firmware has 255") != std::string::npos);
}
// --- the travel must fit in positive counts -------------------------------
TEST_CASE("the Delta's centre comfortably holds its travel") {
// ~89k half-travel against a 500000 centre: 411k .. 589k, all positive.
auto r = checkTravelFitsPositive("yaw", 500000, 89000);
CHECK(r.ran);
CHECK(r.pass);
}
TEST_CASE("the IOTA's gear ratio pushes the same centre below zero") {
// The real case: half-travel 604749 against the inherited 500000 default
// gives lim_neg -104749, which is what tower 121 actually homed to.
auto r = checkTravelFitsPositive("yaw", 500000, 604749);
CHECK(r.ran);
CHECK_FALSE(r.pass);
CHECK(r.detail.find("-104749") != std::string::npos);
CHECK(r.detail.find("yaw_center_count") != std::string::npos);
// The suggestion is the next round million above half the travel - 1000000
// here, which is the value actually adopted. Not 2000000: over-suggesting
// wastes range for no reason.
CHECK(r.detail.find("1000000") != std::string::npos);
}
TEST_CASE("raising the centre fixes it") {
auto r = checkTravelFitsPositive("yaw", 1000000, 604749);
CHECK(r.pass);
CHECK(r.detail.find("395251") != std::string::npos);
}
TEST_CASE("the suggestion scales with the drivetrain, not a fixed constant") {
// A ratio big enough that 1000000 would not be enough either.
auto r = checkTravelFitsPositive("yaw", 500000, 1400000);
CHECK_FALSE(r.pass);
CHECK(r.detail.find("2000000") != std::string::npos);
}
TEST_CASE("exactly touching zero is accepted, one count below is not") {
CHECK(checkTravelFitsPositive("yaw", 604749, 604749).pass);
CHECK_FALSE(checkTravelFitsPositive("yaw", 604748, 604749).pass);
}
TEST_CASE("an un-homed axis is not checked") {
auto r = checkTravelFitsPositive("pitch", 500000, 0);
CHECK_FALSE(r.ran);
CHECK(r.pass);
}
// --- the wiring the image was built from ------------------------------------
TEST_CASE("pins built as declared pass") {
const DeclaredValue v[] = {{"cs", true, 1, 1}, {"en", true, 4, 4}};
auto r = checkPinsBuilt("yaw", v, 2);
CHECK(r.ran);
CHECK(r.pass);
}
TEST_CASE("a pin mismatch blames the build, not a lost SET") {
// Pins never travel over the wire, so "a SET was lost" would send someone
// looking in the wrong place. The only fix is a rebuild from this file.
const DeclaredValue v[] = {{"cs", true, 1, 5}, {"en", true, 4, 4}};
auto r = checkPinsBuilt("yaw", v, 2);
CHECK_FALSE(r.pass);
CHECK(r.detail.find("cs declared 1, built with 5") != std::string::npos);
CHECK(r.detail.find("Rebuild and re-flash") != std::string::npos);
CHECK(r.detail.find("SET") == std::string::npos);
}
TEST_CASE("a firmware that does not echo its pins cannot pass") {
const DeclaredValue v[] = {{"cs", true, 1, -1}, {"en", true, 4, -1}};
auto r = checkPinsBuilt("yaw", v, 2);
CHECK(r.ran);
CHECK_FALSE(r.pass);
CHECK(r.detail.find("predates the pin echo") != std::string::npos);
}
TEST_CASE("no [Pins] declared is not checked") {
const DeclaredValue v[] = {{"cs", false, 0, 1}};
auto r = checkPinsBuilt("yaw", v, 1);
CHECK_FALSE(r.ran);
}
// --- test camera ------------------------------------------------------------
TEST_CASE("pixelStats counts each end of the range over every byte") {
std::vector<uint8_t> d(1000, 128);
for (int i = 0; i < 100; ++i) d[i] = 0;
for (int i = 100; i < 150; ++i) d[i] = 5; // still "low": the bound is inclusive
for (int i = 150; i < 200; ++i) d[i] = 250; // "high", inclusive
for (int i = 200; i < 210; ++i) d[i] = 255;
auto st = pixelStats(d);
CHECK(st.samples == 1000);
CHECK(st.pct_low == doctest::Approx(15.0));
CHECK(st.pct_high == doctest::Approx(6.0));
CHECK(pixelStats({}).samples == 0);
}
TEST_CASE("frames: all arriving whole and consistent passes, and says so") {
FrameRun run;
run.wanted = 5; run.got = 5; run.timeout_ms = 2000;
run.width = 2664; run.height = 1520; run.channels = 3;
auto r = checkFramesDelivered("rgb", run);
CHECK(r.pass);
CHECK(r.detail.find("5 complete frames, 2664x1520 x3") != std::string::npos);
}
TEST_CASE("frames: a stall, a size change, bad depth and dropped frames each fail") {
FrameRun ok;
ok.wanted = 5; ok.got = 5; ok.timeout_ms = 2000;
ok.width = 640; ok.height = 480; ok.channels = 3;
FrameRun stall = ok; stall.got = 2;
CHECK_FALSE(checkFramesDelivered("rgb", stall).pass);
CHECK(checkFramesDelivered("rgb", stall).detail.find("2 of 5") != std::string::npos);
FrameRun changed = ok; changed.consistent = false;
CHECK_FALSE(checkFramesDelivered("rgb", changed).pass);
FrameRun depth = ok; depth.channels = 2;
CHECK_FALSE(checkFramesDelivered("rgb", depth).pass);
FrameRun drops = ok; drops.dropped = 1;
CHECK_FALSE(checkFramesDelivered("rgb", drops).pass);
CHECK(checkFramesDelivered("rgb", drops).detail.find("#19") != std::string::npos);
FrameRun none;
CHECK_FALSE(checkFramesDelivered("rgb", none).ran);
}
TEST_CASE("clipping: the forced end must be reached by the threshold share of pixels") {
PixelStats black; black.samples = 100; black.pct_low = 100.0; black.pct_high = 0.0;
PixelStats white; white.samples = 100; white.pct_low = 0.0; white.pct_high = 99.5;
PixelStats grey; grey.samples = 100; grey.pct_low = 1.0; grey.pct_high = 1.0; grey.mean = 128;
CHECK(checkClipped("rgb", false, black, 99.0).pass);
CHECK(checkClipped("rgb", true, white, 99.0).pass);
// A small bright patch at the dark end - the sun in frame - still passes.
PixelStats sun = black; sun.pct_low = 99.2;
CHECK(checkClipped("rgb", false, sun, 99.0).pass);
// A camera that did not follow the settings fails, with the reason.
auto r = checkClipped("rgb", true, grey, 99.0);
CHECK_FALSE(r.pass);
CHECK(r.detail.find("did not reach white") != std::string::npos);
CHECK_FALSE(checkClipped("rgb", false, PixelStats{}, 99.0).pass);
}
Reference in New Issue View Git Blame Copy Permalink