BlackMark
0f5e40510c
8382 -> 8004 B of flash, 725 -> 511 B of RAM on a part that has 2048. The command names were a std::to_array of string_view, and on a Harvard machine that is the worst of both: the characters land in .data and so does the table's own pointer-and-length pair for each of them, so the firmware carried 216 B of RAM for thirteen words that never change - and paid for them in flash too, since .data is copied out of an initialiser image at startup. They are one NUL-separated blob in flash now, walked with lpm. Separators rather than an offset table, because an offset table is the RAM this exists to give back; the names sit in it in match order, so the walk that finds a name is the same walk that compares it and measures it. Flash falls further than RAM does: the initialiser image and the two tables were 216 B of it, and the blob is 87. The header said the names "cannot" be in flash because they are matched at run time. Being matched at run time is not a reason to be in RAM on a machine with two address spaces - only being *written* is, and nothing writes these. Two smaller things came with it. `reset`'s exact-match rule was a bool on every entry to protect one; it is an index found by searching the list, so reordering the commands cannot move the protection onto a different one. And `version` was the last string_view left, holding its own characters and a pointer to them. The matching is now pinned rather than assumed: lookup() is constexpr and the battery asserts the load-bearing order the README documents - `s` is show and not statistics, `st` is statistics, no abbreviation of `reset` resolves, and `helpful` is not `help`. Red-checked by claiming `s` is statistics. Both modes byte-identical, ten tests green. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
121 lines
4.9 KiB
C++
121 lines
4.9 KiB
C++
// Compile-only battery, built with the cross compiler so the target's 16-bit
|
|
// int is exercised. Two of this firmware's three numeric surfaces are decided
|
|
// entirely at compile time - the fan curve and the thermistor table - and the
|
|
// third, quarter-degrees to whole ones, is the arithmetic between them.
|
|
|
|
#include <cstdint>
|
|
|
|
#include "curve.hpp"
|
|
#include "terminal.hpp"
|
|
#include "thermistor.hpp"
|
|
|
|
namespace {
|
|
|
|
using app::thermistor::whole_degrees;
|
|
|
|
// Rounding to nearest, across zero. A negative quotient truncates toward zero
|
|
// in C, so a `(q + 2) / 4` reads -3.00 C as -2 and every case below the tie
|
|
// with it; the arithmetic shift floors, which is what these hold it to.
|
|
static_assert(whole_degrees(0) == 0);
|
|
static_assert(whole_degrees(1) == 0); // +0.25
|
|
static_assert(whole_degrees(2) == 1); // +0.50, the tie
|
|
static_assert(whole_degrees(3) == 1); // +0.75
|
|
static_assert(whole_degrees(4) == 1); // +1.00
|
|
static_assert(whole_degrees(-1) == 0); // -0.25
|
|
static_assert(whole_degrees(-2) == 0); // -0.50, the tie, toward zero
|
|
static_assert(whole_degrees(-3) == -1);
|
|
static_assert(whole_degrees(-4) == -1);
|
|
static_assert(whole_degrees(-12) == -3);
|
|
static_assert(whole_degrees(-160) == -40); // the table's own floor
|
|
static_assert(whole_degrees(500) == 125); // and its ceiling
|
|
|
|
// The curve is held at zero below the temperature the fan starts at, and
|
|
// saturates inside the table's window rather than at its edge.
|
|
using app::curve::detail::duty_entry;
|
|
static_assert(duty_entry(app::curve::start_celsius - 1) == 0);
|
|
static_assert(duty_entry(app::curve::start_celsius) == 0);
|
|
static_assert(duty_entry(30) == 7);
|
|
static_assert(duty_entry(40) == 36);
|
|
static_assert(duty_entry(49) == 93);
|
|
static_assert(duty_entry(50) == 100);
|
|
static_assert(duty_entry(99) == 100);
|
|
|
|
// Monotone across the whole table: a warmer reading never asks for less air.
|
|
consteval bool curve_rises()
|
|
{
|
|
for (std::int32_t t = 1; t < 100; ++t) {
|
|
if (duty_entry(t) < duty_entry(t - 1)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
static_assert(curve_rises());
|
|
|
|
// The thermistor table, anchored where the Beta equation fixes it rather than
|
|
// against numbers this file computed the same way: the divider reads the
|
|
// thermistor's nominal resistance at
|
|
// adc = full_scale * nominal / (series + nominal), and the equation's own
|
|
// definition puts that count at the nominal temperature.
|
|
using app::thermistor::detail::quarters_entry;
|
|
|
|
inline constexpr std::int32_t nominal_count =
|
|
static_cast<std::int32_t>(app::thermistor::adc_full_scale * app::thermistor::nominal_resistance /
|
|
(app::thermistor::series_resistor + app::thermistor::nominal_resistance));
|
|
static_assert(quarters_entry(nominal_count / 4) >= 100); // 25.00 C, in quarters
|
|
static_assert(quarters_entry(nominal_count / 4 + 1) < 100); // and the step below it
|
|
|
|
// Both clamps, at the ends the divider cannot leave.
|
|
static_assert(quarters_entry(0) == 125 * 4);
|
|
static_assert(quarters_entry(255) == -40 * 4);
|
|
|
|
// An NTC on this divider falls with the count: more counts is more resistance
|
|
// is a colder sensor, over every step of the table.
|
|
consteval bool thermistor_falls()
|
|
{
|
|
for (std::int32_t i = 1; i < 256; ++i) {
|
|
if (quarters_entry(i) > quarters_entry(i - 1)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
static_assert(thermistor_falls());
|
|
|
|
// The console's one parsing rule, read out of the flash blob the names live
|
|
// in. Every case here is a property of the *order* the names sit in, so this
|
|
// is what an edit to that list has to answer to.
|
|
using app::terminal;
|
|
|
|
// Full names, and the ends of the list - a walk that miscounts a separator
|
|
// lands on a neighbour rather than failing, so both ends are named.
|
|
static_assert(terminal::lookup("help") == 0);
|
|
static_assert(terminal::lookup("save") == 12);
|
|
static_assert(terminal::lookup("bootloader") == 4);
|
|
|
|
// Abbreviations resolve to the first entry they prefix. `s` prefixes show,
|
|
// statistics, set and save, and show is first - which is the original's
|
|
// behaviour and the reason the list is ordered rather than sorted.
|
|
static_assert(terminal::lookup("s") == 1);
|
|
static_assert(terminal::lookup("st") == 6);
|
|
static_assert(terminal::lookup("se") == 9);
|
|
static_assert(terminal::lookup("sa") == 12);
|
|
static_assert(terminal::lookup("up") == 5);
|
|
static_assert(terminal::lookup("b") == 4);
|
|
|
|
// `reset` is the exception: it must be typed in full, so no abbreviation of it
|
|
// resolves - and none of its prefixes names anything else either.
|
|
static_assert(terminal::lookup("reset") == 8);
|
|
static_assert(terminal::lookup("rese") == terminal::no_command);
|
|
static_assert(terminal::lookup("res") == terminal::no_command);
|
|
static_assert(terminal::lookup("r") == terminal::no_command);
|
|
|
|
// Nothing, and nothing that matches.
|
|
static_assert(terminal::lookup("") == terminal::no_command);
|
|
static_assert(terminal::lookup("xyzzy") == terminal::no_command);
|
|
|
|
// Longer than the name it prefixes is not a match: `helpful` is not `help`.
|
|
static_assert(terminal::lookup("helpful") == terminal::no_command);
|
|
|
|
} // namespace
|