build: the libavr pin advances past the consumer-report fixes

timer::engine gains stop()/start() and a runtime TOP, adc gains
disable()/enable(), and libavr_programming_targets() stops leaving .fuse bytes
in the flash HEX. Every one of them is additive, and this port adopts none of
them yet: its 3 built images come out byte-identical across the pin change,
which is what the advance is here to keep true.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

.gitignore

@@ -1,11 +1,9 @@
-.vs
+build/
-Release
+.cache/
-Debug
+
-*.componentinfo.xml
+# Atmel Studio: generated per machine, and its build outputs
-*.elf
+ide/*.componentinfo.xml
-*.o
+ide/Debug/
-*.hex
+ide/Release/
-*.srec
+ide/.vs/
-*.eeprom
+ide/*.log
-*.lss
-*.map

.gitmodules

@@ -1,18 +1,3 @@
-[submodule "fantemp/uart"]
+[submodule "libavr"]
-	path = fantemp/uart
+	path = libavr
-	url = git@git.blackmark.me:avr/uart.git
+	url = ../libavr.git
-[submodule "fantemp/flash"]
-	path = fantemp/flash
-	url = git@git.blackmark.me:avr/flash.git
-[submodule "fantemp/io"]
-	path = fantemp/io
-	url = git@git.blackmark.me:avr/io.git
-[submodule "fantemp/adc"]
-	path = fantemp/adc
-	url = git@git.blackmark.me:avr/adc.git
-[submodule "fantemp/type"]
-	path = fantemp/type
-	url = git@git.blackmark.me:avr/type.git
-[submodule "fantemp/eeprom"]
-	path = fantemp/eeprom
-	url = git@git.blackmark.me:avr/eeprom.git

CMakeLists.txt

@@ -0,0 +1,31 @@
+cmake_minimum_required(VERSION 3.28)
+
+project(fantemp LANGUAGES CXX)
+
+# libavr rides as the pinned submodule; LIBAVR_ROOT (cache or environment)
+# overrides it for tandem development against a working tree. The toolchain
+# file comes from the submodule via CMakePresets.json either way.
+if(NOT LIBAVR_ROOT AND DEFINED ENV{LIBAVR_ROOT})
+	set(LIBAVR_ROOT $ENV{LIBAVR_ROOT})
+endif()
+if(NOT LIBAVR_ROOT)
+	set(LIBAVR_ROOT ${CMAKE_CURRENT_SOURCE_DIR}/libavr)
+endif()
+if(NOT EXISTS ${LIBAVR_ROOT}/CMakeLists.txt)
+	message(FATAL_ERROR "libavr not found at ${LIBAVR_ROOT} — run: git submodule update --init libavr")
+endif()
+add_subdirectory(${LIBAVR_ROOT} libavr-build)
+
+add_executable(fantemp src/main.cpp)
+target_link_libraries(fantemp PRIVATE libavr)
+# The raw image is what the loader takes, and what the reachability check
+# measures the boot-section clearance against.
+add_custom_command(TARGET fantemp POST_BUILD
+                   COMMAND ${CMAKE_SIZE} $<TARGET_FILE:fantemp>
+                   COMMAND ${CMAKE_OBJCOPY} -O binary -R .eeprom
+                           $<TARGET_FILE:fantemp> $<TARGET_FILE_DIR:fantemp>/fantemp.bin
+                   COMMAND ${CMAKE_OBJCOPY} -O ihex -R .eeprom
+                           $<TARGET_FILE:fantemp> $<TARGET_FILE_DIR:fantemp>/fantemp.hex)
+
+enable_testing()
+add_subdirectory(test)

CMakePresets.json

@@ -0,0 +1,59 @@
+{
+	"version": 8,
+	"configurePresets": [
+		{
+			"name": "base",
+			"hidden": true,
+			"generator": "Ninja",
+			"binaryDir": "${sourceDir}/build/${presetName}",
+			"toolchainFile": "${sourceDir}/libavr/cmake/avr-toolchain.cmake",
+			"cacheVariables": {
+				"CMAKE_BUILD_TYPE": "Release",
+				"CMAKE_EXPORT_COMPILE_COMMANDS": "ON",
+				"CMAKE_COLOR_DIAGNOSTICS": "ON"
+			}
+		},
+		{
+			"name": "atmega328p-generated",
+			"inherits": "base",
+			"cacheVariables": {
+				"LIBAVR_MCU": "atmega328p",
+				"LIBAVR_REFLECT": "OFF"
+			}
+		},
+		{
+			"name": "atmega328p-reflect",
+			"inherits": "base",
+			"cacheVariables": {
+				"LIBAVR_MCU": "atmega328p",
+				"LIBAVR_REFLECT": "ON"
+			}
+		}
+	],
+	"buildPresets": [
+		{
+			"name": "atmega328p-generated",
+			"configurePreset": "atmega328p-generated"
+		},
+		{
+			"name": "atmega328p-reflect",
+			"configurePreset": "atmega328p-reflect"
+		}
+	],
+	"testPresets": [
+		{
+			"name": "atmega328p-generated",
+			"configurePreset": "atmega328p-generated",
+			"output": {
+				"outputOnFailure": true
+			}
+		},
+		{
+			"name": "atmega328p-reflect",
+			"configurePreset": "atmega328p-reflect",
+			"output": {
+				"outputOnFailure": true
+			}
+		}
+	]
+}

README.md

@@ -0,0 +1,102 @@
+# fantemp
+
+**v2.2.** Temperature-controlled fan firmware (ATmega328P, 16 MHz), rewritten on
+[libavr](https://git.blackmark.me/avr/libavr): thermistor on ADC0 sampled
+free-running and averaged over 1000 conversions, fan on OC0B at 50 kHz,
+115200 Bd serial console (`help` lists the commands), temperature
+histogram persisted to EEPROM, and a direct jump into a boot-section
+bootloader at `0x7e00`.
+
+The EEPROM format is the legacy firmware's, unchanged: 100 little-endian
+`uint32` buckets at address 0, one per °C. A board carrying years of history
+from FanTemp 1.8b keeps every count — verified on hardware, all 67 non-empty
+buckets byte-identical across the conversion.
+
+## The console
+
+Commands may be abbreviated to any unambiguous-by-order prefix, as the legacy
+firmware allowed: `up` is `uptime`, `st` is `statistics`, `sa` is `save`. The
+table order resolves ties, so `s` is `show` — and `reset` is deliberately the one
+command that cannot be abbreviated, because `r` should not be able to wipe the
+histogram. `save` (new) forces a writeback, which otherwise happens every 30
+minutes and on the way into the bootloader.
+
+`show`, `statistics` and the histogram print one value per line behind a dotted
+label, the way the original did — a run-on line is fine for one reading and
+unreadable when `monitor` emits one a second. `curve` walks every whole degree
+from 10 to 60 with a bar, because the curve is a cubic and five-degree samples
+without a graph show none of its shape.
+
+**Ctrl+C** abandons a half-typed line and gives a fresh prompt, echoing `^C`, and
+it is what stops `monitor`. Stopping on *any* byte, which is what the port did
+first, reads well right up until a host sends a line ending: `monitor\r\n` then
+stopped itself on the `\n` it arrived with, one reading in.
+
+## Reaching the bootloader
+
+`bootloader` **jumps**; it does not reset. That is not a style choice:
+
+- **pureboot hands straight back on WDRF**, by design — an unattended board that
+  watchdog-resets in a loop must not sit in a loader. So the legacy
+  watchdog-reset hand-over arrives and opens no window at all, and on a board
+  with no reset line that is a board that cannot be reflashed.
+- The address is `0x7e00`, the top 512 bytes. The legacy firmware used `0x7800`,
+  a 2 KB boot section's base, which on a board with a 512-byte boot section reads
+  erased — so its `bootloader` command silently never arrived anywhere.
+- `UCSR0B` is cleared first. While `TXEN0` is set the USART owns PD1, so a loader
+  that bit-bangs the same pin receives perfectly and answers into nothing.
+
+`ctest` reads all three back out of the emitted image (`test/check_reachability.py`),
+because none of them is visible from the source alone and the failure mode is an
+unreflashable board. Both the address and the watchdog checks are red-proven
+against the legacy behaviour they exist to catch.
+
+The Steinhart–Hart math of the legacy firmware (runtime doubles + libm
+log) is gone: the Beta equation and the cubic fan curve are evaluated
+consteval into flash tables — the firmware itself never touches floating
+point.
+
+libavr rides as the `libavr/` submodule, pinned to the commit this firmware
+builds against; `LIBAVR_ROOT` (cache or environment) overrides it for
+development against a working tree:
+
+```sh
+git submodule update --init libavr
+cmake --preset atmega328p-generated
+cmake --build --preset atmega328p-generated
+```
+
+## Atmel Studio
+
+`master` carries a Studio solution, so this branch does too: `ide/fantemp.atsln`
+builds the same firmware — byte-identical `.text` and `.data` to the CMake
+build — from the same sources, with the flags mirrored by hand.
+
+Studio finds libavr in the **submodule**, at
+`$(MSBuildProjectDirectory)\..\libavr\include` — correct by construction, and
+anchored to the project rather than written relative to the generated makefile,
+which runs from the configuration's output directory and would need a different
+number of `..`. Unlike the CMake build there is no `LIBAVR_ROOT` to point
+elsewhere: an environment variable set in a shell is not visible to Studio
+launched from the Start menu — which is what the submodule answers.
+
+It also needs a GCC 16.1 toolchain registered as flavour `avr-g++-16.1.0`;
+nothing older can compile `-std=c++26`.
+
+One generated file is required before the project will load, and one command
+checks the flags have not drifted (both from libavr's `tools/atmelstudio/`):
+
+```sh
+python ../libavr/tools/atmelstudio/componentinfo.py \
+    ide/fantemp.componentinfo.xml --device ATmega328P
+python ../libavr/tools/atmelstudio/check-flags.py --solution ide/fantemp.atsln \
+    --compile-commands build/atmega328p-generated/compile_commands.json \
+    --log build/atmelstudio.log
+```
+
+CMake remains the build system; the solution is there so the project opens in
+Studio as its predecessor did. Only the Release configuration is gated against
+CMake — the presets define no debug build — and Debug carries the `-Og
+-gdwarf-4` pair libavr's own debug preset uses.
+
+Legacy (yazoalfa submodules) stays on `master`.

fantemp/bootloader.cpp

@@ -1,46 +0,0 @@
-#include "bootloader.hpp"
-
-#include <avr/io.h>
-#include <avr/pgmspace.h>
-#include <avr/wdt.h>
-
-namespace {
-
-typedef void (*jmp_fn)() __attribute__((noreturn));
-
-jmp_fn boot = reinterpret_cast<jmp_fn>(0x0000);
-jmp_fn bootloader = reinterpret_cast<jmp_fn>(0x7800 / 2);
-
-} // namespace
-
-bool Bootloader::handleReset()
-{
-	wdt_reset();
-	uint8_t mcuStatus = MCUSR;
-	MCUSR &= ~(1 << WDRF);
-	wdt_disable();
-	return (mcuStatus & (1 << WDRF));
-}
-
-void Bootloader::reset()
-{
-	wdt_enable(WDTO_15MS);
-	while (true)
-		;
-}
-
-bool Bootloader::check()
-{
-	if (pgm_read_byte(reinterpret_cast<uint16_t>(bootloader) * 2) != 0xFF)
-		return true;
-
-	return false;
-}
-
-void Bootloader::call()
-{
-	if (check())
-		bootloader();
-	else
-		boot();
-}

fantemp/bootloader.hpp

@@ -1,24 +0,0 @@
-#pragma once
-
-class Bootloader {
-  public:
-	template <typename Fn>
-	static inline void init(Fn callback)
-	{
-		if (handleReset()) {
-			callback();
-			call();
-		}
-	}
-
-	static inline void enter()
-	{
-		reset();
-	}
-
-  private:
-	static bool handleReset();
-	static void reset();
-	static bool check();
-	static void call();
-};

fantemp/clock.cpp

@@ -1,37 +0,0 @@
-#include "clock.hpp"
-
-#include <avr/interrupt.h>
-#include <avr/io.h>
-
-namespace clk {
-
-namespace detail {
-
-volatile uint64_t sm_millisCounter = 0;
-
-ISR(TIMER2_COMPA_vect)
-{
-	++sm_millisCounter;
-}
-
-} // namespace detail
-
-void init()
-{
-	TCCR2A |= (1 << WGM21);
-	TCCR2B |= (1 << CS22) | (1 << CS20);
-	OCR2A = 124;
-	TIMSK2 |= (1 << OCIE2A);
-}
-
-uint64_t millis()
-{
-	const auto oldSreg = SREG;
-	cli();
-	const auto millisCounter = detail::sm_millisCounter;
-	SREG = oldSreg;
-
-	return millisCounter;
-}
-
-} // namespace clk

fantemp/clock.hpp

@@ -1,13 +0,0 @@
-#pragma once
-
-#define F_CPU 16'000'000
-#include <util/delay.h>
-
-#include <stdint.h>
-
-namespace clk {
-
-void init();
-uint64_t millis();
-
-} // namespace clk

fantemp/controller.cpp

@@ -1,69 +0,0 @@
-#include "controller.hpp"
-
-#define ADC_INT_VECTOR
-#include "adc/adc.hpp"
-
-double Controller::m_adcSample;
-double Controller::m_resistance;
-double Controller::m_temperature;
-uint8_t Controller::m_fanSpeed;
-bool Controller::m_dataAvailable = false;
-bool Controller::m_autoMode = true;
-
-volatile uint32_t Controller::m_adcSampleSum;
-volatile bool Controller::m_adcSampleReady = false;
-
-void Controller::init()
-{
-	m_adcPin.init(sampleCallback);
-	pwm::init();
-	pwm::setDuty(100);
-}
-
-void Controller::callback()
-{
-	if (m_adcSampleReady) {
-		m_adcSample = static_cast<double>(m_adcSampleSum) / NUM_ADC_SAMPLES;
-		m_dataAvailable = true;
-		m_adcSampleReady = false;
-
-		m_resistance = m_thermistor.getResistance(m_adcSample);
-		m_temperature = m_thermistor.getTemperature(m_resistance);
-
-		if (m_autoMode)
-			m_fanSpeed = mapTemperature(m_temperature);
-
-		pwm::setDuty(m_fanSpeed);
-	}
-}
-
-uint8_t Controller::mapTemperature(double temperature)
-{
-	[[maybe_unused]] constexpr auto linearCurve = [](double x) { return (10 * x - 200) / 3; };
-	constexpr auto cubicCurve = [](double x) {
-		if (x < 20)
-			return 0.0;
-		return 0.002246 * x * x * x - 0.09 * x * x + 0.91 * x;
-	};
-
-	double fanSpeed = cubicCurve(temperature);
-	return clamp<uint8_t>(fanSpeed, 0, 100);
-}
-
-void Controller::sampleCallback(const uint16_t &adcSample)
-{
-	static uint32_t s_sampleSum = 0;
-	static auto s_sampleCounter = NUM_ADC_SAMPLES;
-
-	s_sampleSum += adcSample;
-
-	if (--s_sampleCounter <= 0) {
-		if (!m_adcSampleReady) {
-			m_adcSampleSum = s_sampleSum;
-			m_adcSampleReady = true;
-		}
-		// else lose this sample, which happens during long running commands like "curve", but has no impact
-		s_sampleSum = 0;
-		s_sampleCounter = NUM_ADC_SAMPLES;
-	}
-}

fantemp/controller.hpp

@@ -1,46 +0,0 @@
-#pragma once
-
-#include "adc/adc.hpp"
-#include "io/io.hpp"
-
-#include "pwm.hpp"
-#include "thermistor.hpp"
-
-class Controller {
-  public:
-	static double m_adcSample;
-	static double m_resistance;
-	static double m_temperature;
-	static uint8_t m_fanSpeed;
-	static bool m_dataAvailable;
-	static bool m_autoMode;
-
-	static void init();
-
-	static void callback();
-
-	static uint8_t mapTemperature(double temperature);
-
-  private:
-	using adc_conf = adc::Config<adc::FreeRunningMode>;
-	static adc::Adc<adc_conf, io::P, io::P::C0> m_adcPin;
-
-	static constexpr auto NUM_ADC_SAMPLES = 1000;
-
-	static volatile uint32_t m_adcSampleSum;
-	static volatile bool m_adcSampleReady;
-
-	static Thermistor m_thermistor;
-
-	static void sampleCallback(const uint16_t &adcSample);
-
-	template <typename T>
-	static T clamp(double value, T lower, T upper)
-	{
-		if (value < lower)
-			return lower;
-		if (value > upper)
-			return upper;
-		return static_cast<T>(value);
-	}
-};

fantemp/fantemp.cppproj

@@ -1,309 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="14.0">
-  <PropertyGroup>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectVersion>7.0</ProjectVersion>
-    <ToolchainName>com.Atmel.AVRGCC8.CPP</ToolchainName>
-    <ProjectGuid>dce6c7e3-ee26-4d79-826b-08594b9ad897</ProjectGuid>
-    <avrdevice>ATmega328P</avrdevice>
-    <avrdeviceseries>none</avrdeviceseries>
-    <OutputType>Executable</OutputType>
-    <Language>CPP</Language>
-    <OutputFileName>$(MSBuildProjectName)</OutputFileName>
-    <OutputFileExtension>.elf</OutputFileExtension>
-    <OutputDirectory>$(MSBuildProjectDirectory)\$(Configuration)</OutputDirectory>
-    <AssemblyName>fantemp</AssemblyName>
-    <Name>fantemp</Name>
-    <RootNamespace>fantemp</RootNamespace>
-    <ToolchainFlavour>avr-g++-9.1.0</ToolchainFlavour>
-    <KeepTimersRunning>true</KeepTimersRunning>
-    <OverrideVtor>false</OverrideVtor>
-    <CacheFlash>true</CacheFlash>
-    <ProgFlashFromRam>true</ProgFlashFromRam>
-    <RamSnippetAddress>0x20000000</RamSnippetAddress>
-    <UncachedRange />
-    <preserveEEPROM>true</preserveEEPROM>
-    <OverrideVtorValue>exception_table</OverrideVtorValue>
-    <BootSegment>2</BootSegment>
-    <ResetRule>0</ResetRule>
-    <eraseonlaunchrule>0</eraseonlaunchrule>
-    <EraseKey />
-    <avrtool>com.atmel.avrdbg.tool.atmelice</avrtool>
-    <avrtoolserialnumber>J41800099437</avrtoolserialnumber>
-    <avrdeviceexpectedsignature>0x1E950F</avrdeviceexpectedsignature>
-    <com_atmel_avrdbg_tool_stk500>
-      <ToolOptions>
-        <InterfaceProperties>
-          <IspClock>125000</IspClock>
-        </InterfaceProperties>
-        <InterfaceName>ISP</InterfaceName>
-      </ToolOptions>
-      <ToolType>com.atmel.avrdbg.tool.stk500</ToolType>
-      <ToolNumber>
-      </ToolNumber>
-      <ToolName>STK500</ToolName>
-    </com_atmel_avrdbg_tool_stk500>
-    <avrtoolinterface>ISP</avrtoolinterface>
-    <avrtoolinterfaceclock>125000</avrtoolinterfaceclock>
-    <AsfFrameworkConfig>
-      <framework-data xmlns="">
-        <options />
-        <configurations />
-        <files />
-        <documentation help="" />
-        <offline-documentation help="" />
-        <dependencies>
-          <content-extension eid="atmel.asf" uuidref="Atmel.ASF" version="3.47.0" />
-        </dependencies>
-      </framework-data>
-    </AsfFrameworkConfig>
-    <com_atmel_avrdbg_tool_atmelice>
-      <ToolOptions>
-        <InterfaceProperties>
-          <IspClock>125000</IspClock>
-        </InterfaceProperties>
-        <InterfaceName>ISP</InterfaceName>
-      </ToolOptions>
-      <ToolType>com.atmel.avrdbg.tool.atmelice</ToolType>
-      <ToolNumber>J41800099437</ToolNumber>
-      <ToolName>Atmel-ICE</ToolName>
-    </com_atmel_avrdbg_tool_atmelice>
-    <custom>
-      <ToolOptions>
-        <InterfaceProperties>
-          <IspClock>125000</IspClock>
-        </InterfaceProperties>
-        <InterfaceName>
-        </InterfaceName>
-      </ToolOptions>
-      <ToolType>custom</ToolType>
-      <ToolNumber>
-      </ToolNumber>
-      <ToolName>Custom Programming Tool</ToolName>
-    </custom>
-    <AAFDebugger>
-      <AAFDebugFiles>
-        <DebugFile>
-          <path>\Debug\fantemp.lss</path>
-          <AAFSetting>
-            <Label>Lss Files</Label>
-            <Extention>.lss</Extention>
-            <Regex>^\s*(?&lt;address&gt;[a-f0-9]*):\s*.*$</Regex>
-            <DebugEnabled>true</DebugEnabled>
-            <RegexGroups>address</RegexGroups>
-            <DebuggerExpression>$pc</DebuggerExpression>
-          </AAFSetting>
-        </DebugFile>
-      </AAFDebugFiles>
-    </AAFDebugger>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
-    <ToolchainSettings>
-      <AvrGccCpp>
-  <avrgcc.common.Device>-mmcu=atmega328p</avrgcc.common.Device>
-  <avrgcc.common.outputfiles.hex>True</avrgcc.common.outputfiles.hex>
-  <avrgcc.common.outputfiles.lss>True</avrgcc.common.outputfiles.lss>
-  <avrgcc.common.outputfiles.eep>True</avrgcc.common.outputfiles.eep>
-  <avrgcc.common.outputfiles.srec>True</avrgcc.common.outputfiles.srec>
-  <avrgcc.common.outputfiles.usersignatures>False</avrgcc.common.outputfiles.usersignatures>
-  <avrgcc.compiler.general.ChangeDefaultCharTypeUnsigned>True</avrgcc.compiler.general.ChangeDefaultCharTypeUnsigned>
-  <avrgcc.compiler.general.ChangeDefaultBitFieldUnsigned>True</avrgcc.compiler.general.ChangeDefaultBitFieldUnsigned>
-  <avrgcc.compiler.symbols.DefSymbols>
-    <ListValues>
-      <Value>NDEBUG</Value>
-    </ListValues>
-  </avrgcc.compiler.symbols.DefSymbols>
-  <avrgcc.compiler.directories.IncludePaths>
-    <ListValues>
-      <Value>%24(PackRepoDir)\Atmel\ATmega_DFP\1.4.346\include</Value>
-    </ListValues>
-  </avrgcc.compiler.directories.IncludePaths>
-  <avrgcc.compiler.optimization.level>Optimize for size (-Os)</avrgcc.compiler.optimization.level>
-  <avrgcc.compiler.optimization.AllocateBytesNeededForEnum>True</avrgcc.compiler.optimization.AllocateBytesNeededForEnum>
-  <avrgcc.compiler.warnings.AllWarnings>True</avrgcc.compiler.warnings.AllWarnings>
-  <avrgcc.compiler.warnings.ExtraWarnings>True</avrgcc.compiler.warnings.ExtraWarnings>
-  <avrgcc.compiler.warnings.Pedantic>True</avrgcc.compiler.warnings.Pedantic>
-  <avrgcc.compiler.miscellaneous.OtherFlags>-fno-threadsafe-statics -std=c11</avrgcc.compiler.miscellaneous.OtherFlags>
-  <avrgcccpp.compiler.general.ChangeDefaultCharTypeUnsigned>True</avrgcccpp.compiler.general.ChangeDefaultCharTypeUnsigned>
-  <avrgcccpp.compiler.general.ChangeDefaultBitFieldUnsigned>True</avrgcccpp.compiler.general.ChangeDefaultBitFieldUnsigned>
-  <avrgcccpp.compiler.symbols.DefSymbols>
-    <ListValues>
-      <Value>NDEBUG</Value>
-    </ListValues>
-  </avrgcccpp.compiler.symbols.DefSymbols>
-  <avrgcccpp.compiler.directories.IncludePaths>
-    <ListValues>
-      <Value>%24(PackRepoDir)\Atmel\ATmega_DFP\1.4.346\include</Value>
-    </ListValues>
-  </avrgcccpp.compiler.directories.IncludePaths>
-  <avrgcccpp.compiler.optimization.level>Optimize for size (-Os)</avrgcccpp.compiler.optimization.level>
-  <avrgcccpp.compiler.optimization.AllocateBytesNeededForEnum>True</avrgcccpp.compiler.optimization.AllocateBytesNeededForEnum>
-  <avrgcccpp.compiler.warnings.AllWarnings>True</avrgcccpp.compiler.warnings.AllWarnings>
-  <avrgcccpp.compiler.warnings.Pedantic>True</avrgcccpp.compiler.warnings.Pedantic>
-  <avrgcccpp.compiler.miscellaneous.OtherFlags>-fno-threadsafe-statics -Wextra -std=c++17</avrgcccpp.compiler.miscellaneous.OtherFlags>
-  <avrgcccpp.linker.libraries.Libraries>
-    <ListValues>
-      <Value>libm</Value>
-    </ListValues>
-  </avrgcccpp.linker.libraries.Libraries>
-  <avrgcccpp.assembler.general.IncludePaths>
-    <ListValues>
-      <Value>%24(PackRepoDir)\Atmel\ATmega_DFP\1.4.346\include</Value>
-    </ListValues>
-  </avrgcccpp.assembler.general.IncludePaths>
-</AvrGccCpp>
-    </ToolchainSettings>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
-    <ToolchainSettings>
-      <AvrGccCpp>
-  <avrgcc.common.Device>-mmcu=atmega328p</avrgcc.common.Device>
-  <avrgcc.common.outputfiles.hex>True</avrgcc.common.outputfiles.hex>
-  <avrgcc.common.outputfiles.lss>True</avrgcc.common.outputfiles.lss>
-  <avrgcc.common.outputfiles.eep>True</avrgcc.common.outputfiles.eep>
-  <avrgcc.common.outputfiles.srec>True</avrgcc.common.outputfiles.srec>
-  <avrgcc.common.outputfiles.usersignatures>False</avrgcc.common.outputfiles.usersignatures>
-  <avrgcc.compiler.general.ChangeDefaultCharTypeUnsigned>True</avrgcc.compiler.general.ChangeDefaultCharTypeUnsigned>
-  <avrgcc.compiler.general.ChangeDefaultBitFieldUnsigned>True</avrgcc.compiler.general.ChangeDefaultBitFieldUnsigned>
-  <avrgcc.compiler.symbols.DefSymbols>
-    <ListValues>
-      <Value>DEBUG</Value>
-    </ListValues>
-  </avrgcc.compiler.symbols.DefSymbols>
-  <avrgcc.compiler.directories.IncludePaths>
-    <ListValues>
-      <Value>%24(PackRepoDir)\Atmel\ATmega_DFP\1.4.346\include</Value>
-    </ListValues>
-  </avrgcc.compiler.directories.IncludePaths>
-  <avrgcc.compiler.optimization.level>Optimize (-O1)</avrgcc.compiler.optimization.level>
-  <avrgcc.compiler.optimization.AllocateBytesNeededForEnum>True</avrgcc.compiler.optimization.AllocateBytesNeededForEnum>
-  <avrgcc.compiler.optimization.DebugLevel>Maximum (-g3)</avrgcc.compiler.optimization.DebugLevel>
-  <avrgcc.compiler.warnings.AllWarnings>True</avrgcc.compiler.warnings.AllWarnings>
-  <avrgcc.compiler.warnings.ExtraWarnings>True</avrgcc.compiler.warnings.ExtraWarnings>
-  <avrgcc.compiler.warnings.Pedantic>True</avrgcc.compiler.warnings.Pedantic>
-  <avrgcc.compiler.miscellaneous.OtherFlags>-fno-threadsafe-statics -std=c11</avrgcc.compiler.miscellaneous.OtherFlags>
-  <avrgcccpp.compiler.general.ChangeDefaultCharTypeUnsigned>True</avrgcccpp.compiler.general.ChangeDefaultCharTypeUnsigned>
-  <avrgcccpp.compiler.general.ChangeDefaultBitFieldUnsigned>True</avrgcccpp.compiler.general.ChangeDefaultBitFieldUnsigned>
-  <avrgcccpp.compiler.symbols.DefSymbols>
-    <ListValues>
-      <Value>DEBUG</Value>
-    </ListValues>
-  </avrgcccpp.compiler.symbols.DefSymbols>
-  <avrgcccpp.compiler.directories.IncludePaths>
-    <ListValues>
-      <Value>%24(PackRepoDir)\Atmel\ATmega_DFP\1.4.346\include</Value>
-    </ListValues>
-  </avrgcccpp.compiler.directories.IncludePaths>
-  <avrgcccpp.compiler.optimization.level>Optimize (-O1)</avrgcccpp.compiler.optimization.level>
-  <avrgcccpp.compiler.optimization.AllocateBytesNeededForEnum>True</avrgcccpp.compiler.optimization.AllocateBytesNeededForEnum>
-  <avrgcccpp.compiler.optimization.DebugLevel>Maximum (-g3)</avrgcccpp.compiler.optimization.DebugLevel>
-  <avrgcccpp.compiler.warnings.AllWarnings>True</avrgcccpp.compiler.warnings.AllWarnings>
-  <avrgcccpp.compiler.warnings.Pedantic>True</avrgcccpp.compiler.warnings.Pedantic>
-  <avrgcccpp.compiler.miscellaneous.OtherFlags>-fno-threadsafe-statics -Wextra -std=c++17</avrgcccpp.compiler.miscellaneous.OtherFlags>
-  <avrgcccpp.linker.libraries.Libraries>
-    <ListValues>
-      <Value>libm</Value>
-    </ListValues>
-  </avrgcccpp.linker.libraries.Libraries>
-  <avrgcccpp.assembler.general.IncludePaths>
-    <ListValues>
-      <Value>%24(PackRepoDir)\Atmel\ATmega_DFP\1.4.346\include</Value>
-    </ListValues>
-  </avrgcccpp.assembler.general.IncludePaths>
-  <avrgcccpp.assembler.debugging.DebugLevel>Default (-Wa,-g)</avrgcccpp.assembler.debugging.DebugLevel>
-</AvrGccCpp>
-    </ToolchainSettings>
-  </PropertyGroup>
-  <ItemGroup>
-    <Compile Include="adc\adc.hpp">
-      <SubType>compile</SubType>
-    </Compile>
-    <Compile Include="adc\config.hpp">
-      <SubType>compile</SubType>
-    </Compile>
-    <Compile Include="adc\hardware.hpp">
-      <SubType>compile</SubType>
-    </Compile>
-    <Compile Include="bootloader.cpp">
-      <SubType>compile</SubType>
-    </Compile>
-    <Compile Include="bootloader.hpp">
-      <SubType>compile</SubType>
-    </Compile>
-    <Compile Include="clock.cpp">
-      <SubType>compile</SubType>
-    </Compile>
-    <Compile Include="clock.hpp">
-      <SubType>compile</SubType>
-    </Compile>
-    <Compile Include="controller.cpp">
-      <SubType>compile</SubType>
-    </Compile>
-    <Compile Include="controller.hpp">
-      <SubType>compile</SubType>
-    </Compile>
-    <Compile Include="eeprom\eeprom.hpp">
-      <SubType>compile</SubType>
-    </Compile>
-    <Compile Include="flash\flash.hpp">
-      <SubType>compile</SubType>
-    </Compile>
-    <Compile Include="io\io.hpp">
-      <SubType>compile</SubType>
-    </Compile>
-    <Compile Include="main.cpp">
-      <SubType>compile</SubType>
-    </Compile>
-    <Compile Include="pwm.cpp">
-      <SubType>compile</SubType>
-    </Compile>
-    <Compile Include="pwm.hpp">
-      <SubType>compile</SubType>
-    </Compile>
-    <Compile Include="statistics.cpp">
-      <SubType>compile</SubType>
-    </Compile>
-    <Compile Include="statistics.hpp">
-      <SubType>compile</SubType>
-    </Compile>
-    <Compile Include="terminal.hpp">
-      <SubType>compile</SubType>
-    </Compile>
-    <Compile Include="thermistor.cpp">
-      <SubType>compile</SubType>
-    </Compile>
-    <Compile Include="thermistor.hpp">
-      <SubType>compile</SubType>
-    </Compile>
-    <Compile Include="type\type.hpp">
-      <SubType>compile</SubType>
-    </Compile>
-    <Compile Include="uart\config.hpp">
-      <SubType>compile</SubType>
-    </Compile>
-    <Compile Include="uart\hardware.hpp">
-      <SubType>compile</SubType>
-    </Compile>
-    <Compile Include="uart\hardware0.hpp">
-      <SubType>compile</SubType>
-    </Compile>
-    <Compile Include="uart\hardware1.hpp">
-      <SubType>compile</SubType>
-    </Compile>
-    <Compile Include="uart\software.hpp">
-      <SubType>compile</SubType>
-    </Compile>
-    <Compile Include="uart\uart.hpp">
-      <SubType>compile</SubType>
-    </Compile>
-  </ItemGroup>
-  <ItemGroup>
-    <Folder Include="flash" />
-    <Folder Include="io" />
-    <Folder Include="adc" />
-    <Folder Include="eeprom" />
-    <Folder Include="type" />
-    <Folder Include="uart" />
-  </ItemGroup>
-  <Import Project="$(AVRSTUDIO_EXE_PATH)\\Vs\\Compiler.targets" />
-</Project>

fantemp/main.cpp

@@ -1,36 +0,0 @@
-#include "clock.hpp"
-
-#include "uart/uart.hpp"
-
-#define UART0_INT_VECTORS
-#include "uart/hardware0.hpp"
-
-#include "bootloader.hpp"
-#include "controller.hpp"
-#include "statistics.hpp"
-#include "terminal.hpp"
-
-int main()
-{
-	Bootloader::init([]() {});
-
-	clk::init();
-
-	using serial = uart::Uart0<uart::Config<115200>>;
-	Terminal<serial> terminal;
-	terminal.init();
-
-	Controller controller;
-	controller.init();
-
-	Statistics statistics;
-	statistics.init();
-
-	while (true) {
-		controller.callback();
-		terminal.callback();
-		statistics.callback();
-	}
-
-	return 0;
-}

fantemp/pwm.cpp

@@ -1,25 +0,0 @@
-#include "pwm.hpp"
-
-#include "io/io.hpp"
-
-namespace pwm {
-
-static constexpr uint8_t PWM_TOP = 40;
-
-void init()
-{
-	io::Pin<io::P::D5> pwmPin;
-	pwmPin.dir(io::Dir::OUT);
-	pwmPin = false;
-
-	TCCR0A = (1 << COM0B1) | (1 << WGM00);
-	TCCR0B = (1 << WGM02) | (1 << CS01);
-	OCR0A = PWM_TOP;
-}
-
-void setDuty(uint8_t percent)
-{
-	OCR0B = (percent * PWM_TOP) / 100;
-}
-
-} // namespace pwm

fantemp/pwm.hpp

@@ -1,10 +0,0 @@
-#pragma once
-
-#include <stdint.h>
-
-namespace pwm {
-
-void init();
-void setDuty(uint8_t percent);
-
-} // namespace pwm

fantemp/statistics.cpp

@@ -1,122 +0,0 @@
-#include "statistics.hpp"
-
-#include <math.h>
-
-#include "eeprom/eeprom.hpp"
-#include "type/type.hpp"
-
-#include "clock.hpp"
-#include "controller.hpp"
-
-uint64_t Statistics::m_lastTemperatureWriteback = 0;
-uint64_t Statistics::m_lastTemperatureSample = 0;
-uint32_t Statistics::m_temperatureHistogram[TEMPERATURE_RANGE];
-
-namespace {
-
-// Must be in translation unit and cannot be forward declared
-EEARRAY(uint32_t, e_temperatureHistogram, Statistics::TEMPERATURE_RANGE);
-
-// Could be declared in every function that uses it, but that would be code duplication
-EepromArray<e_temperatureHistogram, EEARRAY_SIZE(e_temperatureHistogram), true> g_eepTemperatureHistogram;
-
-} // namespace
-
-void Statistics::init()
-{
-	for (uint8_t i = 0; i < g_eepTemperatureHistogram.size(); ++i) {
-		m_temperatureHistogram[i] = g_eepTemperatureHistogram[i];
-		if (m_temperatureHistogram[i] == type::numeric_limits<uint32_t>::max()) {
-			m_temperatureHistogram[i] = 0;
-		}
-	}
-}
-
-void Statistics::callback()
-{
-	if (Controller::m_dataAvailable) {
-		if (clk::millis() >= m_lastTemperatureSample + TEMPERATURE_SAMPLE_DELAY) {
-			const auto temperature = clampTemperature(static_cast<int8_t>(round(Controller::m_temperature)));
-			++m_temperatureHistogram[temperature];
-			m_lastTemperatureSample = clk::millis();
-		}
-
-		if (clk::millis() >= m_lastTemperatureWriteback + TEMPERATURE_WRITEBACK_DELAY) {
-			saveTemperatureHistogram();
-			m_lastTemperatureWriteback = clk::millis();
-		}
-	}
-}
-
-void Statistics::reset()
-{
-	for (uint8_t i = 0; i < TEMPERATURE_RANGE; ++i) {
-		m_temperatureHistogram[i] = 0;
-		g_eepTemperatureHistogram[i] = 0;
-	}
-}
-
-uint8_t Statistics::getMinTemperature()
-{
-	for (uint8_t i = 0; i < TEMPERATURE_RANGE; ++i) {
-		if (m_temperatureHistogram[i] > 0)
-			return i;
-	}
-
-	return TEMPERATURE_RANGE;
-}
-
-uint8_t Statistics::getMaxTemperature()
-{
-	for (int8_t i = TEMPERATURE_RANGE - 1; i >= 0; --i) {
-		if (m_temperatureHistogram[i] > 0)
-			return i;
-	}
-
-	return TEMPERATURE_RANGE;
-}
-
-uint64_t Statistics::getTotalHistogramSamples()
-{
-	uint64_t totalSamples = 0;
-
-	for (uint8_t i = 0; i < TEMPERATURE_RANGE; ++i) {
-		totalSamples += m_temperatureHistogram[i];
-	}
-
-	return totalSamples;
-}
-
-uint32_t Statistics::getHighestHistogramSamples()
-{
-	uint32_t max = 0;
-
-	for (uint8_t i = 0; i < TEMPERATURE_RANGE; ++i) {
-		if (m_temperatureHistogram[i] > max) {
-			max = m_temperatureHistogram[i];
-		}
-	}
-
-	return max;
-}
-
-uint32_t Statistics::getHistogram(const int8_t &temperature)
-{
-	return m_temperatureHistogram[clampTemperature(temperature)];
-}
-
-void Statistics::saveTemperatureHistogram()
-{
-	for (uint8_t i = 0; i < g_eepTemperatureHistogram.size(); ++i) {
-		g_eepTemperatureHistogram[i] = m_temperatureHistogram[i];
-	}
-}
-
-uint8_t Statistics::clampTemperature(const int8_t &temperature)
-{
-	if (temperature < 0)
-		return 0;
-	if (temperature >= TEMPERATURE_RANGE)
-		return TEMPERATURE_RANGE - 1;
-	return static_cast<uint8_t>(temperature);
-}

fantemp/statistics.hpp

@@ -1,31 +0,0 @@
-#pragma once
-
-#include <stdint.h>
-
-class Statistics {
-  public:
-	static constexpr auto TEMPERATURE_RANGE = 100;
-
-	static void init();
-	static void callback();
-	static void reset();
-
-	static uint8_t getMinTemperature();
-	static uint8_t getMaxTemperature();
-
-	static uint64_t getTotalHistogramSamples();
-	static uint32_t getHighestHistogramSamples();
-	static uint32_t getHistogram(const int8_t &temperature);
-
-	static void saveTemperatureHistogram();
-
-  private:
-	static constexpr auto TEMPERATURE_WRITEBACK_DELAY = 1'800'000;
-	static constexpr auto TEMPERATURE_SAMPLE_DELAY = 1'000;
-
-	static uint64_t m_lastTemperatureWriteback;
-	static uint64_t m_lastTemperatureSample;
-	static uint32_t m_temperatureHistogram[TEMPERATURE_RANGE];
-
-	static uint8_t clampTemperature(const int8_t &temperature);
-};

fantemp/terminal.hpp

@@ -1,377 +0,0 @@
-#pragma once
-
-#include <ctype.h>
-#include <stdint.h>
-#include <stdlib.h>
-
-#include <avr/pgmspace.h>
-
-#include "flash/flash.hpp"
-
-#include "clock.hpp"
-#include "controller.hpp"
-#include "statistics.hpp"
-
-namespace detail {
-
-GF(ENDL, "\r\n");
-GF(HELP_CMD, "help");
-GF(SHOW_CMD, "show");
-GF(CURVE_CMD, "curve");
-GF(MONITOR_CMD, "monitor");
-GF(BOOTLOADER_CMD, "bootloader");
-GF(UPTIME_CMD, "uptime");
-GF(STATISTICS_CMD, "statistics");
-GF(HISTOGRAM_CMD, "histogram");
-GF(RESET_CMD, "reset");
-GF(SET_CMD, "set");
-GF(AUTO_CMD, "auto");
-
-GF(VERSION_CMD, "version");
-GF(VERSION, "1.8");
-
-static inline bool substringEquals(const char *str, const ::detail::FlashString *flashStr, const size_t &size)
-{
-	return (strncmp_P(str, reinterpret_cast<const char *>(flashStr), size) == 0);
-}
-
-static inline bool stringEquals(const char *str, const ::detail::FlashString *flashStr, const size_t &size)
-{
-	if (size == strlen_P(reinterpret_cast<const char *>(flashStr))) {
-		return substringEquals(str, flashStr, size);
-	}
-
-	return false;
-}
-
-} // namespace detail
-
-template <class Uart>
-class Terminal {
-  public:
-	static void init()
-	{
-		m_serial.init();
-
-		m_serial << detail::ENDL;
-		printVersion();
-		m_serial << detail::ENDL << F("$ ");
-	}
-
-	static void callback()
-	{
-		if (receiveInput()) {
-			parseInput();
-		}
-
-		if (m_state == State::MONITOR && clk::millis() >= m_monitorDelayLastUpdate + MONITOR_DELAY) {
-			showState();
-			m_monitorDelayLastUpdate = clk::millis();
-		}
-	}
-
-  private:
-	static constexpr auto INPUT_BUFFER_SIZE = 128;
-	static constexpr auto BACKSPACE = uint8_t{0x7f};
-	static constexpr auto CTRL_C = uint8_t{0x03};
-	static constexpr auto MONITOR_DELAY = 500;
-
-	enum class State {
-		NONE,
-		MONITOR,
-	};
-
-	static Uart m_serial;
-	static char m_inputBuffer[INPUT_BUFFER_SIZE];
-	static uint16_t m_inputSize;
-	static State m_state;
-	static uint64_t m_monitorDelayLastUpdate;
-
-	static bool receiveInput()
-	{
-		uint8_t inputByte;
-
-		while (m_serial.rxByte(inputByte)) {
-			if (isprint(inputByte) || inputByte == CTRL_C) {
-				m_inputBuffer[m_inputSize++] = inputByte;
-
-				// Handle Ctrl + C
-				if (inputByte == CTRL_C) {
-					m_serial << F("^C") << detail::ENDL;
-					return true;
-				}
-				// Echo
-				else {
-					m_serial << static_cast<char>(inputByte);
-				}
-			}
-
-			// Handle backspace
-			if (inputByte == BACKSPACE && m_inputSize > 0) {
-				m_serial << F("\b \b");
-				--m_inputSize;
-			}
-			// Handle line terminator
-			else if (inputByte == '\r' || inputByte == '\n') {
-				// Consume possible second line terminator
-				if (m_serial.peek(inputByte) && (inputByte == '\r' || inputByte == '\n')) {
-					m_serial.rxByte(inputByte);
-				}
-				m_serial << detail::ENDL;
-				return true;
-			}
-
-			if (m_inputSize >= INPUT_BUFFER_SIZE) {
-				m_serial << detail::ENDL << F("WARNING: Terminal input buffer overflow!") << detail::ENDL;
-				return true;
-			}
-		}
-
-		return false;
-	}
-
-	static uint8_t parseFanSpeed()
-	{
-		const auto setCmdLen = strlen_P(reinterpret_cast<const char *>(detail::SET_CMD));
-
-		if (m_inputSize > setCmdLen && substringEquals(m_inputBuffer, detail::SET_CMD, setCmdLen) &&
-		    m_inputSize < INPUT_BUFFER_SIZE) {
-			m_inputBuffer[m_inputSize] = '\0'; // Null terminate to be parsable by stdlib
-			const auto *fanSpeedStr = m_inputBuffer + setCmdLen;
-			auto *fanSpeedStrEnd = m_inputBuffer + setCmdLen;
-			const auto fanSpeed = strtol(fanSpeedStr, &fanSpeedStrEnd, 10);
-
-			if (fanSpeedStrEnd != fanSpeedStr && *fanSpeedStr != '\0' && *fanSpeedStrEnd == '\0') {
-				if (fanSpeed >= 0 && fanSpeed <= 100)
-					return static_cast<uint8_t>(fanSpeed);
-			}
-		}
-
-		return 0xFF;
-	}
-
-	static void parseInput()
-	{
-		if (m_inputSize) {
-			if (m_inputBuffer[m_inputSize - 1] == CTRL_C) {
-				handleCtrlC();
-			} else if (m_state == State::NONE) {
-				if (substringEquals(m_inputBuffer, detail::HELP_CMD, m_inputSize)) {
-					printHelp();
-				} else if (substringEquals(m_inputBuffer, detail::SHOW_CMD, m_inputSize)) {
-					showState();
-				} else if (substringEquals(m_inputBuffer, detail::CURVE_CMD, m_inputSize)) {
-					printCurve();
-				} else if (substringEquals(m_inputBuffer, detail::MONITOR_CMD, m_inputSize)) {
-					m_state = State::MONITOR;
-				} else if (substringEquals(m_inputBuffer, detail::BOOTLOADER_CMD, m_inputSize)) {
-					handleBootloader();
-				} else if (substringEquals(m_inputBuffer, detail::UPTIME_CMD, m_inputSize)) {
-					printUptime();
-				} else if (substringEquals(m_inputBuffer, detail::STATISTICS_CMD, m_inputSize)) {
-					printStatistics();
-				} else if (substringEquals(m_inputBuffer, detail::HISTOGRAM_CMD, m_inputSize)) {
-					printHistogram();
-				} else if (stringEquals(m_inputBuffer, detail::RESET_CMD, m_inputSize)) {
-					handleReset();
-				} else if (uint8_t targetFanSpeed = parseFanSpeed(); targetFanSpeed <= 100) {
-					handleSet(targetFanSpeed);
-				} else if (substringEquals(m_inputBuffer, detail::AUTO_CMD, m_inputSize)) {
-					handleAuto();
-				} else if (substringEquals(m_inputBuffer, detail::VERSION_CMD, m_inputSize)) {
-					printVersion();
-				} else {
-					printUnknown();
-				}
-			}
-		}
-
-		m_inputSize = 0;
-		if (m_state == State::NONE)
-			m_serial << F("$ ");
-	}
-
-	static void handleCtrlC()
-	{
-		m_serial << F("Abort!") << detail::ENDL;
-		m_state = State::NONE;
-	}
-
-	static void printHelp()
-	{
-		m_serial << F("FanTemp command overview: ") << detail::ENDL;
-		m_serial << detail::HELP_CMD << F(" .......: prints this help message") << detail::ENDL;
-		m_serial << detail::SHOW_CMD << F(" .......: shows current temperature and fan speed") << detail::ENDL;
-		m_serial << detail::CURVE_CMD << F(" ......: shows mapping from temperature to fan speed") << detail::ENDL;
-		m_serial << detail::MONITOR_CMD << F(" ....: loops the show command until Ctrl + C is pressed") << detail::ENDL;
-		m_serial << detail::BOOTLOADER_CMD << F(" .: enters the bootloader after 3 seconds") << detail::ENDL;
-		m_serial << detail::UPTIME_CMD << F(" .....: shows system uptime") << detail::ENDL;
-		m_serial << detail::STATISTICS_CMD << F(" .: prints overall statistics like min and max temp") << detail::ENDL;
-		m_serial << detail::HISTOGRAM_CMD << F(" ..: prints a histogram of the temperature") << detail::ENDL;
-		m_serial << detail::RESET_CMD << F(" ......: resets statistics to 0 in EEPROM and RAM") << detail::ENDL;
-		m_serial << detail::SET_CMD << F(" ........: sets the fan speed to the provided value") << detail::ENDL;
-		m_serial << detail::AUTO_CMD << F(" .......: turns on automatic fan control") << detail::ENDL;
-		m_serial << detail::VERSION_CMD << F(" ....: displays firmware version") << detail::ENDL;
-	}
-
-	static void showState()
-	{
-		if (Controller::m_dataAvailable) {
-			char floatBuffer[16];
-
-			dtostrf(Controller::m_adcSample, 0, 2, floatBuffer);
-			m_serial << F("ADC value ...: ") << floatBuffer << F(" / 1023") << detail::ENDL;
-			dtostrf(Controller::m_resistance, 0, 2, floatBuffer);
-			m_serial << F("Resistance ..: ") << floatBuffer << F(" Ohm") << detail::ENDL;
-			dtostrf(Controller::m_temperature, 0, 2, floatBuffer);
-			m_serial << F("Temperature .: ") << floatBuffer << F(" C") << detail::ENDL;
-			m_serial << F("Fan speed ...: ") << Controller::m_fanSpeed << F("%")
-			         << (Controller::m_autoMode ? F(" auto") : F(" manual")) << detail::ENDL;
-		} else {
-			m_serial << F("No data available yet!") << detail::ENDL;
-		}
-	}
-
-	static void printCurve()
-	{
-		for (uint8_t i = 10; i <= 60; ++i) {
-			m_serial << i << F(" C = ");
-			m_serial.template txNumber<uint8_t, 10, 3, ' '>(Controller::mapTemperature(i));
-			m_serial << F("%\t");
-			for (uint8_t s = 0; s < Controller::mapTemperature(i); ++s) {
-				m_serial << '#';
-			}
-			m_serial << detail::ENDL;
-		}
-	}
-
-	static void handleBootloader()
-	{
-		m_serial << F("Saving statistics to EEPROM") << detail::ENDL;
-		Statistics::saveTemperatureHistogram();
-
-		m_serial << F("Entering bootloader...") << detail::ENDL;
-		m_serial.flushTx();
-
-		_delay_ms(3000);
-
-		Bootloader::enter();
-	}
-
-	static void printUptime()
-	{
-		constexpr auto delimiter = ':';
-
-		const auto uptime = clk::millis();
-
-		const auto hours = static_cast<uint16_t>(uptime / 1000 / 60 / 60);
-		const auto minutes = static_cast<uint8_t>((uptime / 1000 / 60) % 60);
-		const auto seconds = static_cast<uint8_t>((uptime / 1000) % 60);
-
-		m_serial << F("System uptime: ");
-		m_serial.template txNumber<uint16_t, 10, 2>(hours);
-		m_serial << delimiter;
-		m_serial.template txNumber<uint8_t, 10, 2>(minutes);
-		m_serial << delimiter;
-		m_serial.template txNumber<uint8_t, 10, 2>(seconds);
-		m_serial << detail::ENDL;
-	}
-
-	static void printStatistics()
-	{
-		const auto minTemp = Statistics::getMinTemperature();
-		const auto maxTemp = Statistics::getMaxTemperature();
-
-		m_serial << F("Minimum temperature .: ");
-		if (minTemp != Statistics::TEMPERATURE_RANGE) {
-			m_serial << minTemp << F(" C");
-		} else {
-			m_serial << F("Not available");
-		}
-
-		m_serial << detail::ENDL << F("Maximum temperature .: ");
-		if (maxTemp != Statistics::TEMPERATURE_RANGE) {
-			m_serial << maxTemp << F(" C");
-		} else {
-			m_serial << F("Not available");
-		}
-		m_serial << detail::ENDL;
-	}
-
-	static void printHistogram()
-	{
-		const auto totalSamples = Statistics::getTotalHistogramSamples();
-
-		if (totalSamples > 0) {
-			const auto maximumSamples = Statistics::getHighestHistogramSamples();
-			auto normalizationFactor = (maximumSamples / 100 > 1) ? (maximumSamples / 100) : 1;
-
-			while (maximumSamples / normalizationFactor > 100)
-				++normalizationFactor;
-
-			for (uint8_t t = Statistics::getMinTemperature(); t <= Statistics::getMaxTemperature(); ++t) {
-				const auto histogramSamples = Statistics::getHistogram(t);
-				m_serial.template txNumber<uint8_t, 10, 2>(t);
-				m_serial << F(" C = ");
-				const auto percent =
-				    static_cast<uint8_t>((2 * 100 * histogramSamples + totalSamples) / (2 * totalSamples));
-				m_serial.template txNumber<uint8_t, 10, 3, ' '>(percent);
-				m_serial << F("%\t");
-				const auto normalizedSamples = static_cast<uint8_t>(histogramSamples / normalizationFactor);
-				for (uint8_t i = 0; i < normalizedSamples; ++i) {
-					m_serial << '#';
-				}
-				m_serial << detail::ENDL;
-			}
-		} else {
-			m_serial << F("There is no data yet!") << detail::ENDL;
-		}
-	}
-
-	static void handleReset()
-	{
-		m_serial << F("Resetting statistics in EEPROM and RAM") << detail::ENDL;
-		Statistics::reset();
-		m_serial << F("Reset statistics") << detail::ENDL;
-	}
-
-	static void handleSet(uint8_t targetFanSpeed)
-	{
-		m_serial << F("Setting fan speed to ");
-		m_serial.txNumber(targetFanSpeed);
-		m_serial << detail::ENDL;
-		Controller::m_autoMode = false;
-		Controller::m_fanSpeed = targetFanSpeed;
-	}
-
-	static void handleAuto()
-	{
-		m_serial << F("Turning on automatic fan control") << detail::ENDL;
-		Controller::m_autoMode = true;
-	}
-
-	static void printVersion()
-	{
-		m_serial << F("FanTemp v") << detail::VERSION << detail::ENDL;
-	}
-
-	static void printUnknown()
-	{
-		m_serial << F("Unknown command \"");
-		for (uint16_t i = 0; i < m_inputSize; ++i)
-			m_serial << static_cast<char>(m_inputBuffer[i]);
-		m_serial << F("\"") << detail::ENDL;
-	}
-};
-
-template <class Uart>
-char Terminal<Uart>::m_inputBuffer[INPUT_BUFFER_SIZE];
-
-template <class Uart>
-uint16_t Terminal<Uart>::m_inputSize = 0;
-
-template <class Uart>
-typename Terminal<Uart>::State Terminal<Uart>::m_state = State::NONE;
-
-template <class Uart>
-uint64_t Terminal<Uart>::m_monitorDelayLastUpdate = 0;

fantemp/thermistor.cpp

@@ -1,19 +0,0 @@
-#include "thermistor.hpp"
-
-#include <math.h>
-
-double Thermistor::getResistance(double adcSample)
-{
-	return SERIES_RESISTOR * adcSample / (1023 - adcSample);
-}
-
-double Thermistor::getTemperature(double resistance)
-{
-	double steinhart = resistance / THERMISTOR_NOMINAL;
-	steinhart = log(steinhart);
-	steinhart /= BETA_COEFFICIENT;
-	steinhart += 1.0 / (NOMINAL_TEMPERATURE + 273.15);
-	steinhart = 1.0 / steinhart;
-	steinhart -= 273.15;
-	return steinhart;
-}

fantemp/thermistor.hpp

@@ -1,16 +0,0 @@
-#pragma once
-
-#include <stdint.h>
-
-class Thermistor {
-  public:
-	static double getResistance(double adcSample);
-
-	static double getTemperature(double resistance);
-
-  private:
-	static constexpr auto SERIES_RESISTOR = 9951;
-	static constexpr auto THERMISTOR_NOMINAL = 9270;
-	static constexpr auto BETA_COEFFICIENT = 3212;
-	static constexpr auto NOMINAL_TEMPERATURE = 25;
-};

ide/fantemp.atsln

@@ -3,7 +3,7 @@ Microsoft Visual Studio Solution File, Format Version 12.00
 # Atmel Studio Solution File, Format Version 11.00
 VisualStudioVersion = 14.0.23107.0
 MinimumVisualStudioVersion = 10.0.40219.1
-Project("{E66E83B9-2572-4076-B26E-6BE79FF3018A}") = "fantemp", "fantemp\fantemp.cppproj", "{DCE6C7E3-EE26-4D79-826B-08594B9AD897}"
+Project("{E66E83B9-2572-4076-B26E-6BE79FF3018A}") = "fantemp", "fantemp.cppproj", "{4F0C1D92-6A5B-4E33-9A71-2C8F5B0D47AE}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -11,10 +11,10 @@ Global
 		Release|AVR = Release|AVR
 	EndGlobalSection
 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{DCE6C7E3-EE26-4D79-826B-08594B9AD897}.Debug|AVR.ActiveCfg = Debug|AVR
+		{4F0C1D92-6A5B-4E33-9A71-2C8F5B0D47AE}.Debug|AVR.ActiveCfg = Debug|AVR
-		{DCE6C7E3-EE26-4D79-826B-08594B9AD897}.Debug|AVR.Build.0 = Debug|AVR
+		{4F0C1D92-6A5B-4E33-9A71-2C8F5B0D47AE}.Debug|AVR.Build.0 = Debug|AVR
-		{DCE6C7E3-EE26-4D79-826B-08594B9AD897}.Release|AVR.ActiveCfg = Release|AVR
+		{4F0C1D92-6A5B-4E33-9A71-2C8F5B0D47AE}.Release|AVR.ActiveCfg = Release|AVR
-		{DCE6C7E3-EE26-4D79-826B-08594B9AD897}.Release|AVR.Build.0 = Release|AVR
+		{4F0C1D92-6A5B-4E33-9A71-2C8F5B0D47AE}.Release|AVR.Build.0 = Release|AVR
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

ide/fantemp.cppproj

@@ -0,0 +1,140 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="14.0">
+  <PropertyGroup>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectVersion>7.0</ProjectVersion>
+    <ToolchainName>com.Atmel.AVRGCC8.CPP</ToolchainName>
+    <ProjectGuid>4f0c1d92-6a5b-4e33-9a71-2c8f5b0d47ae</ProjectGuid>
+    <avrdevice>ATmega328P</avrdevice>
+    <avrdeviceseries>none</avrdeviceseries>
+    <OutputType>Executable</OutputType>
+    <Language>CPP</Language>
+    <OutputFileName>$(MSBuildProjectName)</OutputFileName>
+    <OutputFileExtension>.elf</OutputFileExtension>
+    <OutputDirectory>$(MSBuildProjectDirectory)\$(Configuration)</OutputDirectory>
+    <AssemblyName>fantemp</AssemblyName>
+    <Name>fantemp</Name>
+    <RootNamespace>fantemp</RootNamespace>
+    <ToolchainFlavour>avr-g++-16.1.0</ToolchainFlavour>
+    <KeepTimersRunning>true</KeepTimersRunning>
+    <OverrideVtor>false</OverrideVtor>
+    <CacheFlash>true</CacheFlash>
+    <ProgFlashFromRam>true</ProgFlashFromRam>
+    <RamSnippetAddress>0x20000000</RamSnippetAddress>
+    <UncachedRange />
+    <preserveEEPROM>true</preserveEEPROM>
+    <OverrideVtorValue>exception_table</OverrideVtorValue>
+    <BootSegment>2</BootSegment>
+    <ResetRule>0</ResetRule>
+    <eraseonlaunchrule>0</eraseonlaunchrule>
+    <EraseKey />
+    <AsfFrameworkConfig>
+      <framework-data xmlns="">
+  <options />
+  <configurations />
+  <files />
+  <documentation help="" />
+  <offline-documentation help="" />
+  <dependencies>
+    <content-extension eid="atmel.asf" uuidref="Atmel.ASF" version="3.52.0" />
+  </dependencies>
+</framework-data>
+    </AsfFrameworkConfig>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
+    <ToolchainSettings>
+      <AvrGccCpp>
+        <avrgcc.common.Device>-mmcu=atmega328p</avrgcc.common.Device>
+        <avrgcc.common.outputfiles.hex>True</avrgcc.common.outputfiles.hex>
+        <avrgcc.common.outputfiles.lss>True</avrgcc.common.outputfiles.lss>
+        <avrgcc.common.outputfiles.eep>True</avrgcc.common.outputfiles.eep>
+        <avrgcc.common.outputfiles.srec>True</avrgcc.common.outputfiles.srec>
+        <avrgcc.common.outputfiles.usersignatures>False</avrgcc.common.outputfiles.usersignatures>
+        <avrgcccpp.compiler.symbols.DefSymbols>
+          <ListValues>
+            <Value>NDEBUG</Value>
+          </ListValues>
+        </avrgcccpp.compiler.symbols.DefSymbols>
+        <avrgcccpp.compiler.directories.IncludePaths>
+          <ListValues>
+            <Value>$(MSBuildProjectDirectory)\..\libavr\include</Value>
+          </ListValues>
+        </avrgcccpp.compiler.directories.IncludePaths>
+        <avrgcccpp.compiler.optimization.level>Optimize for size (-Os)</avrgcccpp.compiler.optimization.level>
+        <avrgcccpp.compiler.optimization.PrepareFunctionsForGarbageCollection>True</avrgcccpp.compiler.optimization.PrepareFunctionsForGarbageCollection>
+        <avrgcccpp.compiler.optimization.PrepareDataForGarbageCollection>True</avrgcccpp.compiler.optimization.PrepareDataForGarbageCollection>
+        <avrgcccpp.compiler.warnings.AllWarnings>True</avrgcccpp.compiler.warnings.AllWarnings>
+        <avrgcccpp.compiler.miscellaneous.OtherFlags>-std=c++26 -Wextra -mrelax -fno-exceptions -fno-rtti -fno-threadsafe-statics</avrgcccpp.compiler.miscellaneous.OtherFlags>
+        <avrgcccpp.linker.optimization.GarbageCollectUnusedSections>True</avrgcccpp.linker.optimization.GarbageCollectUnusedSections>
+        <avrgcccpp.linker.miscellaneous.LinkerFlags>-mrelax</avrgcccpp.linker.miscellaneous.LinkerFlags>
+      </AvrGccCpp>
+    </ToolchainSettings>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
+    <ToolchainSettings>
+      <AvrGccCpp>
+        <avrgcc.common.Device>-mmcu=atmega328p</avrgcc.common.Device>
+        <avrgcc.common.outputfiles.hex>True</avrgcc.common.outputfiles.hex>
+        <avrgcc.common.outputfiles.lss>True</avrgcc.common.outputfiles.lss>
+        <avrgcc.common.outputfiles.eep>True</avrgcc.common.outputfiles.eep>
+        <avrgcc.common.outputfiles.srec>True</avrgcc.common.outputfiles.srec>
+        <avrgcc.common.outputfiles.usersignatures>False</avrgcc.common.outputfiles.usersignatures>
+        <avrgcccpp.compiler.symbols.DefSymbols>
+          <ListValues>
+            <Value>DEBUG</Value>
+          </ListValues>
+        </avrgcccpp.compiler.symbols.DefSymbols>
+        <avrgcccpp.compiler.directories.IncludePaths>
+          <ListValues>
+            <Value>$(MSBuildProjectDirectory)\..\libavr\include</Value>
+          </ListValues>
+        </avrgcccpp.compiler.directories.IncludePaths>
+        <avrgcccpp.compiler.optimization.level>Optimize debugging experience (-Og)</avrgcccpp.compiler.optimization.level>
+        <avrgcccpp.compiler.optimization.PrepareFunctionsForGarbageCollection>True</avrgcccpp.compiler.optimization.PrepareFunctionsForGarbageCollection>
+        <avrgcccpp.compiler.optimization.PrepareDataForGarbageCollection>True</avrgcccpp.compiler.optimization.PrepareDataForGarbageCollection>
+        <avrgcccpp.compiler.warnings.AllWarnings>True</avrgcccpp.compiler.warnings.AllWarnings>
+        <avrgcccpp.compiler.miscellaneous.OtherFlags>-std=c++26 -Wextra -mrelax -fno-exceptions -fno-rtti -fno-threadsafe-statics -gdwarf-4</avrgcccpp.compiler.miscellaneous.OtherFlags>
+        <avrgcccpp.linker.optimization.GarbageCollectUnusedSections>True</avrgcccpp.linker.optimization.GarbageCollectUnusedSections>
+        <avrgcccpp.linker.miscellaneous.LinkerFlags>-mrelax</avrgcccpp.linker.miscellaneous.LinkerFlags>
+      </AvrGccCpp>
+    </ToolchainSettings>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="..\src\board.hpp">
+      <SubType>compile</SubType>
+      <Link>src\board.hpp</Link>
+    </Compile>
+    <Compile Include="..\src\bootloader.hpp">
+      <SubType>compile</SubType>
+      <Link>src\bootloader.hpp</Link>
+    </Compile>
+    <Compile Include="..\src\controller.hpp">
+      <SubType>compile</SubType>
+      <Link>src\controller.hpp</Link>
+    </Compile>
+    <Compile Include="..\src\curve.hpp">
+      <SubType>compile</SubType>
+      <Link>src\curve.hpp</Link>
+    </Compile>
+    <Compile Include="..\src\main.cpp">
+      <SubType>compile</SubType>
+      <Link>src\main.cpp</Link>
+    </Compile>
+    <Compile Include="..\src\statistics.hpp">
+      <SubType>compile</SubType>
+      <Link>src\statistics.hpp</Link>
+    </Compile>
+    <Compile Include="..\src\terminal.hpp">
+      <SubType>compile</SubType>
+      <Link>src\terminal.hpp</Link>
+    </Compile>
+    <Compile Include="..\src\thermistor.hpp">
+      <SubType>compile</SubType>
+      <Link>src\thermistor.hpp</Link>
+    </Compile>
+  </ItemGroup>
+  <ItemGroup>
+    <Folder Include="src" />
+  </ItemGroup>
+  <Import Project="$(AVRSTUDIO_EXE_PATH)\Vs\Compiler.targets" />
+</Project>

src/board.hpp

@@ -0,0 +1,68 @@
+#pragma once
+
+#include <libavr/libavr.hpp>
+
+// The board composition: every peripheral of the fan controller in one
+// place. ATmega328P at 16 MHz — thermistor divider on ADC0 (PC0), fan on
+// OC0B (PD5) at 50 kHz, console on the hardware UART.
+namespace app {
+
+using namespace avr::literals;
+
+using dev = avr::device<{.clock = 16_MHz}>;
+
+// Millisecond uptime from timer2 CTC (the fan owns timer0).
+class uptime {
+	static inline volatile std::uint64_t ms = 0;
+
+  public:
+	using ticker = dev::timer2<{.frequency = 1_kHz, .on_compare = [] { ms = ms + 1; }}>;
+
+	static std::uint64_t millis()
+	{
+		avr::irq::atomic_guard lock;
+		return ms;
+	}
+};
+
+// 1000-sample averaging window fed by the conversion interrupt.
+class sampler {
+	static inline volatile std::uint32_t sum = 0;
+	static inline volatile std::uint16_t count = 0;
+	static inline volatile std::uint16_t window = 0;
+	static inline volatile bool ready = false;
+
+	static constexpr std::uint16_t samples = 1000;
+
+  public:
+	using input = dev::adc<{.input = avr::adc::input_pin(0),
+	                        .trigger = avr::adc::trigger::free_running,
+	                        .on_conversion = [](std::uint16_t value) {
+		                        sum = sum + value;
+		                        count = count + 1;
+		                        if (count >= samples) {
+			                        window = static_cast<std::uint16_t>(sum / samples);
+			                        sum = 0;
+			                        count = 0;
+			                        ready = true;
+		                        }
+	                        }}>;
+
+	// The finished average (raw 10-bit), once per window.
+	static bool take(std::uint16_t &value)
+	{
+		avr::irq::atomic_guard lock;
+		if (!ready)
+			return false;
+		value = window;
+		ready = false;
+		return true;
+	}
+};
+
+using fan = dev::pwm<avr::pd5, {.frequency = 50_kHz}>;
+
+using serial_t = dev::uart0<{.baud = 115200_Bd, .rx_buffer = 32, .max_baud_error = 2.5_pct}>;
+inline constexpr serial_t serial{};
+
+} // namespace app

src/bootloader.hpp

@@ -0,0 +1,96 @@
+#pragma once
+
+#include <avr/pgmspace.h>
+
+#include <libavr/libavr.hpp>
+
+#include "board.hpp"
+
+// Reaching the resident bootloader from the console.
+//
+// The legacy firmware did this with a watchdog reset: `bootloader` armed the
+// watchdog and hung, and the next boot noticed WDRF and jumped to the boot
+// section. That works for TinySafeBoot and **does not work for pureboot**, which
+// deliberately hands straight back to the application on WDRF — an unattended
+// board that watchdog-resets in a loop must not sit in a loader instead of
+// running. So a reset-based route into pureboot opens no window at all, and on a
+// board whose only way in is the firmware that is a lockout.
+//
+// This route therefore never resets. It jumps, with the reset flags already
+// clear, so the loader starts as if from a clean power-on and opens its window.
+//
+// The address is this board's, and it is not the legacy one: the loader lives in
+// the top 512 bytes at 0x7e00 (`hfuse d4` puts the boot section at 0x7c00 with
+// pureboot's staging slot below its own slot). The legacy firmware probed 0x7800
+// — a 2 KB boot section's base — which on this board reads erased, so its check
+// was always false and its `bootloader` command never actually arrived anywhere.
+namespace app {
+
+class bootloader {
+	using jump_fn = void (*)();
+
+	using guard = dev::watchdog<{.timeout = 16_ms}>;
+
+	// The top 512 bytes. An erased slot reads 0xffff, which is not an
+	// instruction any loader begins with — so this asks "is a loader installed"
+	// rather than "is it the one I expect", which is the check the legacy
+	// firmware got wrong in the other direction by testing one specific byte.
+	static constexpr std::uint16_t base = 0x7e00;
+
+	static bool present()
+	{
+		return pgm_read_word(base) != 0xffff;
+	}
+
+	// A function pointer holds a word address on AVR, so the byte address
+	// halves. [[gnu::noipa]] keeps the call indirect: a constant target folds
+	// into a relative call that cannot reach across flash.
+	[[gnu::noipa, noreturn]] static void call(jump_fn target)
+	{
+		target();
+		__builtin_unreachable();
+	}
+
+  public:
+	// Call first thing in main. reset_cause() reads *and clears* MCUSR, which
+	// matters on its own: a lingering WDRF forces the watchdog back on at its
+	// shortest timeout. The diversion below is a leftover of the legacy route
+	// and is kept only because it is free and cannot hurt — with BOOTRST
+	// programmed the loader has already run before this line, so nothing
+	// normally reaches it.
+	static void handle_reset()
+	{
+		auto cause = avr::power::reset_cause();
+		guard::disable();
+		if (cause.watchdog && present())
+			call(reinterpret_cast<jump_fn>(base / 2));
+	}
+
+	// Hand over for real: no reset, so no WDRF for the loader to refuse.
+	[[noreturn]] static void enter()
+	{
+		// Interrupts first — the receive vector and the timer live in this
+		// application's vector table, and once the loader is running there is no
+		// application to vector into.
+		avr::irq::disable();
+		guard::disable();
+
+		// Release the USART. While TXEN0 is set the peripheral owns PD1, not the
+		// port register, so a loader that bit-bangs the same pin receives
+		// perfectly and answers into nothing — mute, not deaf, and unverifiable
+		// from the host. pureboot clears this itself; TinySafeBoot, which is what
+		// this board still carries, does not. Four bytes make the hand-over work
+		// for either one, which is the only reason this route can be tested
+		// before the loader is replaced.
+		avr::hw::ucsr0b::write(0);
+
+		call(reinterpret_cast<jump_fn>(base / 2));
+	}
+
+	static bool available()
+	{
+		return present();
+	}
+};
+
+} // namespace app

src/controller.hpp

@@ -0,0 +1,77 @@
+#pragma once
+
+#include <cstdint>
+
+#include "board.hpp"
+#include "curve.hpp"
+#include "thermistor.hpp"
+
+// Control loop: averaged thermistor samples → temperature → fan duty
+// through the curve table (auto) or a console-set value (manual).
+namespace app {
+
+class controller {
+	static inline std::uint16_t adc_average = 0;
+	static inline std::int16_t temp_quarters = 0;
+	static inline std::uint8_t percent = 100;
+	static inline bool auto_mode = true;
+	static inline bool have_data = false;
+
+  public:
+	static void init()
+	{
+		fan::duty(avr::percent_t{10000}); // full blast until the first reading
+	}
+
+	static void poll()
+	{
+		std::uint16_t sample;
+		if (!sampler::take(sample))
+			return;
+		adc_average = sample;
+		temp_quarters = thermistor::quarters(sample);
+		have_data = true;
+		if (auto_mode)
+			percent = curve::duty(static_cast<std::int8_t>((temp_quarters + 2) / 4));
+		fan::duty(avr::percent_t{static_cast<std::uint16_t>(percent * 100)});
+	}
+
+	static void set_manual(std::uint8_t p)
+	{
+		auto_mode = false;
+		percent = p;
+		fan::duty(avr::percent_t{static_cast<std::uint16_t>(p * 100)});
+	}
+
+	static void set_automatic()
+	{
+		auto_mode = true;
+	}
+
+	static bool automatic()
+	{
+		return auto_mode;
+	}
+
+	static bool data_available()
+	{
+		return have_data;
+	}
+
+	static std::int16_t temperature_quarters()
+	{
+		return temp_quarters;
+	}
+
+	static std::uint16_t last_adc()
+	{
+		return adc_average;
+	}
+
+	static std::uint8_t fan_percent()
+	{
+		return percent;
+	}
+};
+
+} // namespace app

src/curve.hpp

@@ -0,0 +1,48 @@
+#pragma once
+
+#include <array>
+#include <cstdint>
+
+#include <libavr/flash.hpp>
+
+// The auto-mode fan curve, tabulated at compile time: a cubic in °C
+// (0.002246·x³ − 0.09·x² + 0.91·x, zero below 20 °C) as a flash_table of
+// duty percent per °C.
+namespace app::curve {
+
+namespace detail {
+
+consteval std::uint8_t duty_entry(int celsius)
+{
+	double x = celsius;
+	if (x < 20)
+		return 0;
+	double duty = 0.002246 * x * x * x - 0.09 * x * x + 0.91 * x;
+	if (duty < 0)
+		duty = 0;
+	if (duty > 100)
+		duty = 100;
+	return static_cast<std::uint8_t>(duty + 0.5);
+}
+
+inline constexpr avr::flash_table<[] {
+	std::array<std::uint8_t, 100> out{};
+	for (int t = 0; t < 100; ++t)
+		out[static_cast<std::size_t>(t)] = duty_entry(t);
+	return out;
+}()>
+    table;
+
+} // namespace detail
+
+// Duty percent for a temperature (clamped to the 0..99 °C table window).
+inline std::uint8_t duty(std::int8_t celsius)
+{
+	if (celsius < 0)
+		celsius = 0;
+	if (celsius > 99)
+		celsius = 99;
+	return detail::table[static_cast<std::uint8_t>(celsius)];
+}
+
+} // namespace app::curve

src/main.cpp

@@ -0,0 +1,29 @@
+#include <libavr/libavr.hpp>
+
+#include "board.hpp"
+#include "bootloader.hpp"
+#include "controller.hpp"
+#include "statistics.hpp"
+#include "terminal.hpp"
+
+using namespace app;
+
+template struct avr::isr::emit<uptime::ticker, sampler::input, serial_t>;
+
+int main()
+{
+	bootloader::handle_reset();
+
+	avr::init<uptime::ticker, sampler::input, fan, serial_t, statistics>();
+	avr::irq::enable();
+	sampler::input::start();
+	controller::init();
+	terminal::init();
+
+	while (true) {
+		controller::poll();
+		if (controller::data_available())
+			statistics::record(static_cast<std::int8_t>((controller::temperature_quarters() + 2) / 4));
+		terminal::poll();
+	}
+}

src/statistics.hpp

@@ -0,0 +1,105 @@
+#pragma once
+
+#include <array>
+#include <cstdint>
+
+#include <libavr/libavr.hpp>
+
+#include "board.hpp"
+
+// Temperature histogram: one uint32 bucket per °C 0..99, sampled once a
+// second, written back to EEPROM every 30 minutes (update() only touches
+// changed bytes). Erased EEPROM reads back as 0xffffffff — treated as 0.
+namespace app {
+
+class statistics {
+	static constexpr std::uint8_t range = 100;
+	static constexpr std::uint32_t sample_delay_ms = 1'000;
+	static constexpr std::uint32_t writeback_delay_ms = 1'800'000;
+
+	using stored = avr::eeprom::var<std::array<std::uint32_t, range>, 0>;
+
+	static inline std::array<std::uint32_t, range> histogram{};
+	static inline std::uint64_t last_sample = 0;
+	static inline std::uint64_t last_writeback = 0;
+
+	static constexpr std::uint8_t clamp(std::int8_t t)
+	{
+		return t < 0 ? 0 : (t >= range ? range - 1 : static_cast<std::uint8_t>(t));
+	}
+
+  public:
+	static constexpr auto claims = stored::claims;
+
+	static void init()
+	{
+		histogram = stored::read();
+		for (auto &bucket : histogram)
+			if (bucket == 0xffffffff)
+				bucket = 0;
+	}
+
+	static void record(std::int8_t celsius)
+	{
+		auto now = uptime::millis();
+		if (now >= last_sample + sample_delay_ms) {
+			++histogram[clamp(celsius)];
+			last_sample = now;
+		}
+		if (now >= last_writeback + writeback_delay_ms) {
+			save();
+			last_writeback = now;
+		}
+	}
+
+	static void save()
+	{
+		stored::update(histogram);
+	}
+
+	static void reset()
+	{
+		histogram = {};
+		stored::update(histogram);
+	}
+
+	static std::uint8_t min_temperature()
+	{
+		for (std::uint8_t i = 0; i < range; ++i)
+			if (histogram[i])
+				return i;
+		return range;
+	}
+
+	static std::uint8_t max_temperature()
+	{
+		for (std::uint8_t i = range; i > 0; --i)
+			if (histogram[i - 1])
+				return i - 1;
+		return 0;
+	}
+
+	static std::uint64_t total_samples()
+	{
+		std::uint64_t total = 0;
+		for (auto bucket : histogram)
+			total += bucket;
+		return total;
+	}
+
+	static std::uint32_t highest_bucket()
+	{
+		std::uint32_t highest = 0;
+		for (auto bucket : histogram)
+			if (bucket > highest)
+				highest = bucket;
+		return highest;
+	}
+
+	static std::uint32_t bucket(std::uint8_t celsius)
+	{
+		return histogram[clamp(static_cast<std::int8_t>(celsius))];
+	}
+};
+
+} // namespace app

src/terminal.hpp

@@ -0,0 +1,440 @@
+#pragma once
+
+#include <array>
+#include <cstdint>
+#include <string_view>
+
+#include <libavr/libavr.hpp>
+
+#include "board.hpp"
+#include "bootloader.hpp"
+#include "controller.hpp"
+#include "curve.hpp"
+#include "statistics.hpp"
+#include "thermistor.hpp"
+
+// The serial console: line-buffered commands over the hardware UART.
+// `help` lists everything, command names may be abbreviated, `monitor` streams
+// until Ctrl+C, and Ctrl+C abandons a half-typed line anywhere else.
+namespace app {
+
+class terminal {
+	static constexpr char ctrl_c = 0x03;
+	static constexpr std::uint8_t line_max = 24;
+	static inline char line[line_max]{};
+	static inline std::uint8_t at = 0;
+	static inline bool overflowed = false;
+	static inline bool monitoring = false;
+	static inline std::uint64_t last_monitor = 0;
+
+	// Commands, in the order they are matched — which is the order the original
+	// firmware matched them in, and that order is load-bearing. An abbreviation
+	// resolves to the *first* entry it prefixes, so `s` is show (not statistics,
+	// not set) exactly as it always was, and anything appended to this list
+	// cannot steal an abbreviation that already meant something else.
+	struct command {
+		std::string_view name;
+		bool exact; // reset only: an abbreviation must not be able to wipe data
+	};
+
+	static constexpr std::array<command, 13> commands{{
+	    {"help", false},
+	    {"show", false},
+	    {"curve", false},
+	    {"monitor", false},
+	    {"bootloader", false},
+	    {"uptime", false},
+	    {"statistics", false},
+	    {"histogram", false},
+	    {"reset", true},
+	    {"set", false},
+	    {"auto", false},
+	    {"version", false},
+	    {"save", false},
+	}};
+
+	// Column the descriptions' colons line up in, counted from the start of the
+	// name. The longest name is `bootloader` at 10, so 12 leaves it a space and
+	// one dot — the original's layout exactly.
+	static constexpr std::uint8_t help_column = 12;
+
+	static void prompt()
+	{
+		serial << "> "_P;
+	}
+
+	// `name ....: ` — the dotted label the original used everywhere it printed a
+	// list of things, which is what makes a column of values readable without
+	// counting spaces. One renderer for all three users; only the column differs.
+	static void label(std::string_view text, std::uint8_t column)
+	{
+		serial << text << ' ';
+		for (auto i = text.size() + 1; i < column; ++i)
+			serial << '.';
+		serial << ": "_P;
+	}
+
+	// The same, for a label that is a literal rather than a command name: it
+	// stays in flash, and its width comes from the type, so the padding needs no
+	// hand-counted constant. The command names cannot use this — they are
+	// string_views because they are matched at run time.
+	template <typename Flash>
+	static void label(Flash text, std::uint8_t column)
+	{
+		serial << text << ' ';
+		for (auto i = Flash::size + 1; i < column; ++i)
+			serial << '.';
+		serial << ": "_P;
+	}
+
+	static void help_row(std::string_view name)
+	{
+		label(name, help_column);
+	}
+
+	// Quarter-°C as a signed decimal with a two-digit fraction. The sign is taken
+	// off first: C++ gives a negative remainder for a negative dividend, so
+	// `(q % 4) * 25` on -40.25 C yields -25 and prints "-40.-25".
+	static void temperature(std::int16_t quarters)
+	{
+		if (quarters < 0)
+			serial << '-';
+		auto magnitude = static_cast<std::uint16_t>(quarters < 0 ? -quarters : quarters);
+		serial << magnitude / 4 << '.' << avr::dec<{.width = 2, .fill = '0'}>((magnitude % 4) * 25);
+	}
+
+	static void help()
+	{
+		serial << "\r\nFanTemp "_P << version << " command overview\r\n"_P;
+		help_row(commands[0].name);
+		serial << "prints this help message\r\n"_P;
+		help_row(commands[1].name);
+		serial << "shows current temperature and fan speed\r\n"_P;
+		help_row(commands[2].name);
+		serial << "shows mapping from temperature to fan speed\r\n"_P;
+		help_row(commands[3].name);
+		serial << "loops the show command until Ctrl+C is pressed\r\n"_P;
+		help_row(commands[4].name);
+		serial << "enters the bootloader\r\n"_P;
+		help_row(commands[5].name);
+		serial << "shows system uptime\r\n"_P;
+		help_row(commands[6].name);
+		serial << "prints overall statistics like min and max temp\r\n"_P;
+		help_row(commands[7].name);
+		serial << "prints a histogram of the temperature\r\n"_P;
+		help_row(commands[8].name);
+		serial << "resets statistics to 0 in EEPROM and RAM (no abbreviation)\r\n"_P;
+		help_row(commands[9].name);
+		serial << "sets the fan speed to the provided value, 0-100\r\n"_P;
+		help_row(commands[10].name);
+		serial << "turns on automatic fan control\r\n"_P;
+		help_row(commands[11].name);
+		serial << "displays firmware version\r\n"_P;
+		help_row(commands[12].name);
+		serial << "writes the statistics to EEPROM now\r\n"_P;
+		serial << "commands may be abbreviated: 'up' is uptime\r\n"_P;
+	}
+
+	// The thermistor's resistance from the divider, in whole ohms. The original
+	// printed this beside the reading and it is the one number that says *why* a
+	// temperature is wrong: an open sensor rails the ADC and the resistance goes
+	// to the tens of megohms, a shorted one to zero.
+	static std::uint32_t resistance()
+	{
+		auto adc = controller::last_adc();
+		if (adc >= 1023)
+			return 0xffffffff; // open circuit: the divider has no solution
+		return static_cast<std::uint32_t>(thermistor::series_resistor) * adc / (1023u - adc);
+	}
+
+	// One value per line behind a dotted label, as the original had it. A single
+	// run-on line is fine for one reading and unreadable when `monitor` prints
+	// one a second forever.
+	static void show()
+	{
+		if (!controller::data_available()) {
+			serial << "no data yet\r\n"_P;
+			return;
+		}
+		label("ADC value"_P, reading_column);
+		serial << controller::last_adc() << " / 1023\r\n"_P;
+
+		label("Resistance"_P, reading_column);
+		if (auto ohms = resistance(); ohms == open_circuit)
+			serial << "open circuit\r\n"_P;
+		else
+			serial << ohms << " Ohm\r\n"_P;
+
+		label("Temperature"_P, reading_column);
+		temperature(controller::temperature_quarters());
+		serial << " C\r\n"_P;
+
+		label("Fan speed"_P, reading_column);
+		serial << controller::fan_percent() << "% "_P;
+		if (controller::automatic())
+			serial << "auto\r\n"_P;
+		else
+			serial << "manual\r\n"_P;
+	}
+
+	// Every whole degree from 10 to 60 with a bar, which is the original's and is
+	// the point of the command: the curve is a cubic, and five-degree samples
+	// without a graph show none of its shape. The bar is the duty itself, so it
+	// reads as a percentage without needing a scale.
+	static void print_curve()
+	{
+		for (std::uint8_t t = curve_low; t <= curve_high; ++t) {
+			auto duty = curve::duty(static_cast<std::int8_t>(t));
+			serial << avr::dec<{.width = 2, .fill = '0'}>(t) << " C = "_P << avr::dec<{.width = 3, .fill = ' '}>(duty)
+			       << "% |"_P;
+			for (std::uint8_t i = 0; i < duty; ++i)
+				serial << '#';
+			serial << "\r\n"_P;
+		}
+	}
+
+	static void print_uptime()
+	{
+		auto seconds = static_cast<std::uint32_t>(uptime::millis() / 1000);
+		serial << seconds / 86400 << "d "_P << (seconds / 3600) % 24 << "h "_P << (seconds / 60) % 60 << "m "_P
+		       << seconds % 60 << "s\r\n"_P;
+	}
+
+	static void print_statistics()
+	{
+		auto empty = statistics::total_samples() == 0;
+		label("Minimum temperature"_P, stat_column);
+		if (empty)
+			serial << "not available\r\n"_P;
+		else
+			serial << statistics::min_temperature() << " C\r\n"_P;
+
+		label("Maximum temperature"_P, stat_column);
+		if (empty)
+			serial << "not available\r\n"_P;
+		else
+			serial << statistics::max_temperature() << " C\r\n"_P;
+
+		label("Total samples"_P, stat_column);
+		serial << static_cast<std::uint32_t>(statistics::total_samples()) << "\r\n"_P;
+	}
+
+	static void print_histogram()
+	{
+		auto highest = statistics::highest_bucket();
+		if (highest == 0) {
+			serial << "no data yet\r\n"_P;
+			return;
+		}
+		// The original's normalisation, and its resolution: divide by whatever
+		// makes the tallest bucket fit in a hundred columns, not forty. A bar
+		// that tops out at 40 throws away most of the difference between
+		// neighbouring buckets, which on a distribution this narrow is the whole
+		// picture.
+		std::uint32_t factor = highest / bar_max > 1 ? highest / bar_max : 1;
+		while (highest / factor > bar_max)
+			++factor;
+
+		for (std::uint8_t t = statistics::min_temperature(); t <= statistics::max_temperature(); ++t) {
+			auto count = statistics::bucket(t);
+			// Count first, in a fixed column, so the numbers read as a table
+			// instead of trailing off the ragged right-hand end of the bars.
+			serial << avr::dec<{.width = 2, .fill = '0'}>(t) << " C : "_P << avr::dec<{.width = 10, .fill = ' '}>(count)
+			       << " |"_P;
+			for (std::uint32_t i = 0; i < count / factor; ++i)
+				serial << '#';
+			serial << "\r\n"_P;
+		}
+	}
+
+	// Abbreviations: the input matches a command when it is a non-empty prefix
+	// of it. `reset` is the exception and must be typed in full.
+	//
+	// starts_with, not substr: substr throws std::out_of_range, and one
+	// potentially-throwing call is enough to pull in std::terminate, which does
+	// not exist in a freestanding AVR build. The link fails rather than the
+	// firmware, so this is a build-time trap rather than a runtime one — but it
+	// is a trap, and the whole file avoids substr for that reason.
+	static bool matches(std::string_view input, const command &c)
+	{
+		if (input.empty())
+			return false;
+		if (c.exact)
+			return input == c.name;
+		return c.name.starts_with(input);
+	}
+
+	static void dispatch(std::string_view input)
+	{
+		// A line that overflowed the buffer is not a command — it is the tail of
+		// one. Acting on it is how a truncated `reset` becomes a surprise.
+		if (overflowed) {
+			serial << "input too long, ignored\r\n"_P;
+			overflowed = false;
+			return;
+		}
+
+		// Split on the first space with the (pointer, length) constructor rather
+		// than substr, which throws — see matches().
+		const auto space = input.find(' ');
+		const auto word = space == std::string_view::npos ? input : std::string_view{input.data(), space};
+		const auto rest = space == std::string_view::npos
+		                      ? std::string_view{}
+		                      : std::string_view{input.data() + space + 1, input.size() - space - 1};
+		if (word.empty())
+			return;
+
+		std::uint8_t which = commands.size();
+		for (std::uint8_t i = 0; i < commands.size(); ++i)
+			if (matches(word, commands[i])) {
+				which = i;
+				break;
+			}
+
+		switch (which) {
+		case 0:
+			help();
+			return;
+		case 1:
+			show();
+			return;
+		case 2:
+			print_curve();
+			return;
+		case 3:
+			monitoring = true;
+			return;
+		case 4:
+			serial << "entering bootloader\r\n"_P;
+			statistics::save();
+			serial.drain();
+			bootloader::enter();
+		case 5:
+			print_uptime();
+			return;
+		case 6:
+			print_statistics();
+			return;
+		case 7:
+			print_histogram();
+			return;
+		case 8:
+			statistics::reset();
+			serial << "statistics cleared in EEPROM and RAM\r\n"_P;
+			return;
+		case 9: {
+			std::uint16_t percent = 0;
+			bool valid = !rest.empty();
+			for (char c : rest) {
+				if (c < '0' || c > '9') {
+					valid = false;
+					break;
+				}
+				percent = static_cast<std::uint16_t>(percent * 10 + (c - '0'));
+				if (percent > 100)
+					valid = false;
+			}
+			if (valid) {
+				controller::set_manual(static_cast<std::uint8_t>(percent));
+				serial << "fan "_P << percent << " %, manual\r\n"_P;
+			} else {
+				serial << "set 0..100\r\n"_P;
+			}
+			return;
+		}
+		case 10:
+			controller::set_automatic();
+			serial << "automatic fan control\r\n"_P;
+			return;
+		case 11:
+			serial << "FanTemp "_P << version << " on libavr\r\n"_P;
+			return;
+		case 12:
+			statistics::save();
+			serial << "statistics written to EEPROM\r\n"_P;
+			return;
+		default:
+			serial << '\'' << word << "' is not a command; 'help' for the list\r\n"_P;
+			return;
+		}
+	}
+
+  public:
+	static constexpr std::string_view version = "v2.2";
+	static constexpr std::uint8_t bar_max = 100;
+
+	// Columns the dotted labels' colons land in, and the curve's span. All four
+	// are the original's.
+	static constexpr std::uint8_t reading_column = 13;
+	static constexpr std::uint8_t stat_column = 21;
+	static constexpr std::uint8_t curve_low = 10;
+	static constexpr std::uint8_t curve_high = 60;
+
+	// A railed ADC leaves the divider with no solution rather than a huge one.
+	static constexpr std::uint32_t open_circuit = 0xffffffff;
+
+	static void init()
+	{
+		serial << "\r\nFanTemp "_P << version << " on libavr -- 'help' for commands\r\n"_P;
+		prompt();
+	}
+
+	static void poll()
+	{
+		if (monitoring) {
+			if (uptime::millis() >= last_monitor + 1000) {
+				show();
+				last_monitor = uptime::millis();
+			}
+			// Ctrl+C only, as the original had it. Stopping on *any* byte reads
+			// well until a host sends a line ending: `monitor\r\n` then stops
+			// itself on the `\n` it arrived with, one reading in.
+			if (auto in = serial_t::read(); in && *in == ctrl_c) {
+				serial << "^C\r\n"_P;
+				monitoring = false;
+				prompt();
+			}
+			return;
+		}
+		while (auto in = serial_t::read()) {
+			char c = static_cast<char>(*in);
+			if (c == ctrl_c) {
+				// Abandon whatever was typed and start a fresh line, which is
+				// what Ctrl+C means at every other prompt in the world.
+				serial << "^C\r\n"_P;
+				at = 0;
+				overflowed = false;
+				prompt();
+			} else if (c == '\r' || c == '\n') {
+				serial << "\r\n"_P;
+				if (at == 0 && !overflowed) {
+					prompt(); // a bare Enter just reprompts, no gap needed
+					continue;
+				}
+				dispatch(std::string_view{line, at});
+				at = 0;
+				if (!monitoring) {
+					// A blank line between a command's output and the next
+					// prompt: without it the answer and the thing you type
+					// next run together and a screen of them is unreadable.
+					serial << "\r\n"_P;
+					prompt();
+				}
+			} else if (c == 0x7f || c == 0x08) {
+				if (at) {
+					--at;
+					serial << "\b \b"_P;
+				}
+			} else if (c >= ' ') {
+				if (at < line_max) {
+					line[at++] = c;
+					serial << c; // echo
+				} else {
+					overflowed = true; // reported when the line is submitted
+				}
+			}
+		}
+	}
+};
+
+} // namespace app

src/thermistor.hpp

@@ -0,0 +1,73 @@
+#pragma once
+
+#include <array>
+#include <cstdint>
+
+#include <libavr/flash.hpp>
+
+// NTC thermistor on a series divider, solved entirely at compile time:
+// the Beta equation (logarithm and all) runs consteval into a libavr
+// flash_table — the firmware never does floating point. Raw 10-bit ADC
+// counts map to quarter-°C with linear interpolation between table steps.
+namespace app::thermistor {
+
+inline constexpr double series_resistor = 9951;
+inline constexpr double nominal_resistance = 9270;
+inline constexpr double beta = 3212;
+inline constexpr double nominal_temperature = 25;
+
+namespace detail {
+
+consteval double temperature_of(double adc)
+{
+	double resistance = series_resistor * adc / (1023.0 - adc);
+	// __builtin_log constant-folds on the AVR backend, so the table is
+	// built at compile time with no runtime libm.
+	double steinhart = __builtin_log(resistance / nominal_resistance) / beta + 1.0 / (nominal_temperature + 273.15);
+	return 1.0 / steinhart - 273.15;
+}
+
+// 256 entries over the 10-bit range (steps of 4 counts), quarter-°C,
+// clamped to a sane sensor window; entry 256 mirrors 255 so interpolation
+// at full scale has a right neighbour.
+consteval std::int16_t quarters_entry(int index)
+{
+	double adc = index * 4.0;
+	if (adc < 4)
+		adc = 4;
+	if (adc > 1019)
+		adc = 1019;
+	double t = temperature_of(adc) * 4.0;
+	if (t < -40 * 4)
+		t = -40 * 4;
+	if (t > 125 * 4)
+		t = 125 * 4;
+	return static_cast<std::int16_t>(t < 0 ? t - 0.5 : t + 0.5);
+}
+
+inline constexpr avr::flash_table<[] {
+	std::array<std::int16_t, 257> out{};
+	for (int i = 0; i < 257; ++i)
+		out[static_cast<std::size_t>(i)] = quarters_entry(i < 256 ? i : 255);
+	return out;
+}()>
+    table;
+
+} // namespace detail
+
+// Temperature in quarter-°C from a raw (or averaged) 10-bit sample.
+inline std::int16_t quarters(std::uint16_t adc)
+{
+	std::uint16_t index = adc >> 2; // the 257th entry backs index+1 at full scale
+	std::uint8_t frac = adc & 3;
+	auto a = detail::table[index];
+	auto b = detail::table[static_cast<std::uint16_t>(index + 1)];
+	return static_cast<std::int16_t>(a + ((b - a) * frac) / 4);
+}
+
+inline std::int8_t celsius(std::uint16_t adc)
+{
+	return static_cast<std::int8_t>((quarters(adc) + 2) / 4);
+}
+
+} // namespace app::thermistor

test/CMakeLists.txt

@@ -0,0 +1,12 @@
+# The board has no reset line and no programming header, so the loader-entry
+# route in the emitted image is the only thing standing between a firmware change
+# and an unreflashable board. It has been wrong before — see the script.
+find_package(Python3 COMPONENTS Interpreter)
+if(Python3_FOUND)
+	add_test(NAME fantemp.reachability
+	         COMMAND ${Python3_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/check_reachability.py
+	                 --objdump ${CMAKE_OBJDUMP} --elf $<TARGET_FILE:fantemp>
+	                 --image $<TARGET_FILE_DIR:fantemp>/fantemp.bin)
+else()
+	message(STATUS "Python not found — the reachability check is skipped")
+endif()

test/check_reachability.py

@@ -0,0 +1,132 @@
+#!/usr/bin/env python3
+"""The board's only way in, checked in the emitted image.
+
+This board has no reset line and no programming header. The single route to the
+bootloader is the running firmware's `bootloader` command, so a firmware that
+gets that route wrong is a board that cannot be reflashed — and the failure is
+silent, because everything else still works.
+
+It has been wrong before. The firmware this one replaces probed and jumped to
+`0x7800`, the base of a 2 KB boot section, while the board's loader sits at
+`0x7e00`; `check()` therefore read an erased byte, was false, and the command
+never arrived anywhere. Nothing about that is visible short of trying it on the
+hardware, which is what this replaces.
+
+Three properties, all read out of the disassembly rather than the source:
+
+1. The image ends below the boot section. `hfuse d4` puts that at 0x7c00, so an
+   application reaching into it would be overwritten by the loader — or worse,
+   executed at reset, since BOOTRST points there.
+2. The hand-over targets the loader base. A word address of 0x3f00 is byte
+   0x7e00; anything else is the 0x7800 bug again.
+3. The hand-over does not arm the watchdog. pureboot hands straight back on
+   WDRF by design, so a reset-based route reaches it and opens no window. The
+   legacy firmware's route was exactly that, and it is the one change that
+   cannot be walked back from the host.
+
+    check_reachability.py --objdump avr-objdump --elf fantemp --image fantemp.bin
+"""
+
+from __future__ import annotations
+
+import argparse
+import pathlib
+import re
+import subprocess
+import sys
+
+BOOT_SECTION = 0x7C00  # hfuse d4: BOOTSZ 512 words
+LOADER_BASE = 0x7E00  # pureboot's 512-byte slot, at the top
+WDTCSR = 0x60
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--objdump", required=True)
+    parser.add_argument("--elf", type=pathlib.Path, required=True)
+    parser.add_argument("--image", type=pathlib.Path, required=True)
+    args = parser.parse_args()
+
+    failures = []
+
+    size = args.image.stat().st_size
+    if size >= BOOT_SECTION:
+        failures.append(f"the image is {size} B and reaches 0x{size - 1:04x}, "
+                        f"into the boot section at 0x{BOOT_SECTION:04x}")
+    else:
+        print(f"  ok    image {size} B, ends 0x{size - 1:04x}, "
+              f"{BOOT_SECTION - size} B clear of the boot section")
+
+    text = subprocess.run([args.objdump, "-d", str(args.elf)],
+                          capture_output=True, text=True, check=True).stdout
+
+    # The address the hand-over actually targets, read at its call sites — not
+    # "does the image contain this byte somewhere", which proves nothing: 0x3f is
+    # an ordinary constant that appears in the curve tables, so a check like that
+    # passes just as happily on the 0x7800 bug it is supposed to catch.
+    #
+    # bootloader::call() takes the target as a function pointer, so each call site
+    # loads the *word* address into a register pair immediately before it.
+    lines = text.splitlines()
+    helper = re.compile(r"\b(?:r?call)\b.*<_ZN3app10bootloader4call")
+    sites = []
+    for index, line in enumerate(lines):
+        if not helper.search(line):
+            continue
+        held: dict[str, int] = {}
+        for back in lines[max(0, index - 8):index]:
+            if m := re.search(r"\bldi\s+(r\d+),\s*0x([0-9A-Fa-f]{2})", back):
+                held[m.group(1)] = int(m.group(2), 16)
+        # The AVR ABI passes the pointer in r25:r24.
+        if "r24" in held and "r25" in held:
+            sites.append(held["r25"] << 8 | held["r24"])
+
+    want = LOADER_BASE // 2
+    if not sites:
+        failures.append("no call to bootloader::call with a loaded target — the "
+                        "hand-over could not be read out of the image")
+    elif wrong := [a for a in sites if a != want]:
+        failures.append(f"the hand-over targets word {[hex(a) for a in wrong]} "
+                        f"(byte {[hex(a * 2) for a in wrong]}), not the loader at "
+                        f"0x{LOADER_BASE:04x}")
+    else:
+        print(f"  ok    all {len(sites)} hand-over site(s) target word 0x{want:04x} "
+              f"(byte 0x{LOADER_BASE:04x})")
+
+    # An icall/ijmp has to exist for that address to be jumped to indirectly.
+    if not re.search(r"\b(icall|ijmp)\b", text):
+        failures.append("no icall/ijmp — the hand-over cannot reach across flash")
+    else:
+        print("  ok    an indirect call exists (a relative one cannot reach)")
+
+    # What actually reaches WDTCSR, not what the image happens to load somewhere.
+    # A timed disable writes WDCE|WDE (0x18) and then zero. Arming writes WDE
+    # *without* WDCE — including 0x08, a 16 ms timeout with every prescaler bit
+    # clear, which is precisely what the legacy route used and is why this cannot
+    # be a check for "a prescaler is present".
+    WDCE, WDE = 0x10, 0x08
+    values, held = [], {}
+    for line in text.splitlines():
+        if m := re.search(r"\bldi\s+(r\d+),\s*0x([0-9A-Fa-f]{2})", line):
+            held[m.group(1)] = int(m.group(2), 16)
+        elif m := re.search(rf"\bsts\s+0x00{WDTCSR:02X},\s*(r\d+)", line, re.I):
+            reg = m.group(1)
+            values.append(0 if reg == "r1" else held.get(reg))
+    armed = [v for v in values if v is not None and (v & WDE) and not (v & WDCE)]
+    if armed:
+        failures.append(f"WDTCSR is written {[hex(v) for v in armed]} — WDE without "
+                        f"WDCE is arming the watchdog, and a reset-based hand-over "
+                        f"opens no pureboot window")
+    elif not values:
+        print("  ok    the watchdog is never written")
+    else:
+        print(f"  ok    WDTCSR writes are {[hex(v) if v is not None else '?' for v in values]}"
+              f" — unlock and clear, never an arm")
+
+    for line in failures:
+        print(f"  FAIL  {line}")
+    return 1 if failures else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())