Indicate auto/manual fan speed

.gitmodules

@@ -10,3 +10,9 @@
 [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

fantemp/bootloader.cpp

@@ -9,7 +9,7 @@ namespace {
 typedef void (*jmp_fn)() __attribute__((noreturn));
 
 jmp_fn boot = reinterpret_cast<jmp_fn>(0x0000);
-jmp_fn bootloader = reinterpret_cast<jmp_fn>(0x7E00 / 2);
+jmp_fn bootloader = reinterpret_cast<jmp_fn>(0x7800 / 2);
 
 } // namespace
 
@@ -31,7 +31,7 @@ void Bootloader::reset()
 
 bool Bootloader::check()
 {
-	if (pgm_read_byte(reinterpret_cast<uint16_t>(bootloader) * 2) == 0xF8)
+	if (pgm_read_byte(reinterpret_cast<uint16_t>(bootloader) * 2) != 0xFF)
 		return true;
 
 	return false;

fantemp/clock.hpp

@@ -1,6 +1,6 @@
 #pragma once
 
-#define F_CPU 16000000
+#define F_CPU 16'000'000
 #include <util/delay.h>
 
 #include <stdint.h>

fantemp/controller.cpp

@@ -7,6 +7,9 @@ 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;
 
@@ -21,10 +24,13 @@ 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);

fantemp/controller.hpp

@@ -12,6 +12,8 @@ class Controller {
 	static double m_resistance;
 	static double m_temperature;
 	static uint8_t m_fanSpeed;
+	static bool m_dataAvailable;
+	static bool m_autoMode;
 
 	static void init();
 

fantemp/fantemp.cppproj

@@ -81,6 +81,21 @@
       </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>
@@ -126,11 +141,9 @@
   <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.general.UseVprintfLibrary>True</avrgcccpp.linker.general.UseVprintfLibrary>
   <avrgcccpp.linker.libraries.Libraries>
     <ListValues>
       <Value>libm</Value>
-            <Value>libprintf_flt</Value>
     </ListValues>
   </avrgcccpp.linker.libraries.Libraries>
   <avrgcccpp.assembler.general.IncludePaths>
@@ -138,7 +151,7 @@
       <Value>%24(PackRepoDir)\Atmel\ATmega_DFP\1.4.346\include</Value>
     </ListValues>
   </avrgcccpp.assembler.general.IncludePaths>
-      </AvrGccCpp>
+</AvrGccCpp>
     </ToolchainSettings>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
@@ -187,11 +200,9 @@
   <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.general.UseVprintfLibrary>True</avrgcccpp.linker.general.UseVprintfLibrary>
   <avrgcccpp.linker.libraries.Libraries>
     <ListValues>
       <Value>libm</Value>
-            <Value>libprintf_flt</Value>
     </ListValues>
   </avrgcccpp.linker.libraries.Libraries>
   <avrgcccpp.assembler.general.IncludePaths>
@@ -200,7 +211,7 @@
     </ListValues>
   </avrgcccpp.assembler.general.IncludePaths>
   <avrgcccpp.assembler.debugging.DebugLevel>Default (-Wa,-g)</avrgcccpp.assembler.debugging.DebugLevel>
-      </AvrGccCpp>
+</AvrGccCpp>
     </ToolchainSettings>
   </PropertyGroup>
   <ItemGroup>
@@ -231,6 +242,9 @@
     <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>
@@ -246,6 +260,12 @@
     <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>
@@ -255,6 +275,9 @@
     <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>
@@ -273,14 +296,13 @@
     <Compile Include="uart\uart.hpp">
       <SubType>compile</SubType>
     </Compile>
-    <Compile Include="uart\utils.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" />

fantemp/main.cpp

@@ -7,12 +7,15 @@
 
 #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();
@@ -20,11 +23,13 @@ int main()
 	Controller controller;
 	controller.init();
 
-	clk::init();
+	Statistics statistics;
+	statistics.init();
 
 	while (true) {
 		controller.callback();
 		terminal.callback();
+		statistics.callback();
 	}
 
 	return 0;

fantemp/statistics.cpp

@@ -0,0 +1,122 @@
+#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

@@ -0,0 +1,31 @@
+#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

@@ -2,7 +2,7 @@
 
 #include <ctype.h>
 #include <stdint.h>
-#include <stdio.h>
+#include <stdlib.h>
 
 #include <avr/pgmspace.h>
 
@@ -10,6 +10,7 @@
 
 #include "clock.hpp"
 #include "controller.hpp"
+#include "statistics.hpp"
 
 namespace detail {
 
@@ -20,9 +21,14 @@ 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.3");
+GF(VERSION, "1.8");
 
 static inline bool substringEquals(const char *str, const ::detail::FlashString *flashStr, const size_t &size)
 {
@@ -124,6 +130,26 @@ class Terminal {
 		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) {
@@ -142,6 +168,16 @@ class Terminal {
 					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 {
@@ -164,26 +200,36 @@ class Terminal {
 	static void printHelp()
 	{
 		m_serial << F("FanTemp command overview: ") << detail::ENDL;
-		m_serial << detail::HELP_CMD << F(" .......: print this help message") << 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(" .....: show system uptime") << 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];
 
-		sprintf(floatBuffer, "%.2f", Controller::m_adcSample);
+			dtostrf(Controller::m_adcSample, 0, 2, floatBuffer);
 			m_serial << F("ADC value ...: ") << floatBuffer << F(" / 1023") << detail::ENDL;
-		sprintf(floatBuffer, "%.2f", Controller::m_resistance);
+			dtostrf(Controller::m_resistance, 0, 2, floatBuffer);
 			m_serial << F("Resistance ..: ") << floatBuffer << F(" Ohm") << detail::ENDL;
-		sprintf(floatBuffer, "%.2f", Controller::m_temperature);
+			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("%") << 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()
@@ -193,7 +239,7 @@ class Terminal {
 			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 << '#';
 			}
 			m_serial << detail::ENDL;
 		}
@@ -201,6 +247,9 @@ class Terminal {
 
 	static void handleBootloader()
 	{
+		m_serial << F("Saving statistics to EEPROM") << detail::ENDL;
+		Statistics::saveTemperatureHistogram();
+
 		m_serial << F("Entering bootloader...") << detail::ENDL;
 		m_serial.flushTx();
 
@@ -228,6 +277,79 @@ class Terminal {
 		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;