diff --git a/Sming/Arch/Esp8266/Components/esp8266/include/esp_clk.h b/Sming/Arch/Esp8266/Components/esp8266/include/esp_clk.h
new file mode 100644
index 0000000000..ab341bba08
--- /dev/null
+++ b/Sming/Arch/Esp8266/Components/esp8266/include/esp_clk.h
@@ -0,0 +1,22 @@
+#pragma once
+
+#include <stdint.h>
+#include <sming_attr.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// system_get_cpu_frequency is just a wrapper for this ROM function.
+uint8_t ets_get_cpu_frequency(void);
+
+__forceinline static uint32_t esp_get_ccount()
+{
+	uint32_t ccount;
+	__asm__ __volatile__("rsr %0, ccount\n" : "=a"(ccount) : : "memory");
+	return ccount;
+}
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/Sming/Arch/Esp8266/Components/gdbstub/gdbuart.cpp b/Sming/Arch/Esp8266/Components/gdbstub/gdbuart.cpp
index 6ed3f7c7b8..6a6a6eaca9 100644
--- a/Sming/Arch/Esp8266/Components/gdbstub/gdbuart.cpp
+++ b/Sming/Arch/Esp8266/Components/gdbstub/gdbuart.cpp
@@ -12,11 +12,11 @@
 
 #include "gdbuart.h"
 #include "GdbPacket.h"
-#include "driver/uart.h"
-#include "driver/SerialBuffer.h"
-#include "Platform/System.h"
-#include "HardwareSerial.h"
-#include <driver/hw_timer.h>
+#include <driver/uart.h>
+#include <driver/SerialBuffer.h>
+#include <Platform/System.h>
+#include <HardwareSerial.h>
+#include <Platform/Timers.h>
 #include "gdbsyscall.h"
 
 #define GDB_UART UART0 // Only UART0 supports for debugging as RX/TX required
@@ -109,14 +109,7 @@ static size_t ATTR_GDBEXTERNFN gdb_uart_write_char(char c)
 
 int ATTR_GDBEXTERNFN gdbReceiveChar()
 {
-#if GDBSTUB_UART_READ_TIMEOUT
-	constexpr uint32_t timeout = round(double(HW_TIMER2_CLK) * GDBSTUB_UART_READ_TIMEOUT / 1000);
-	auto startTicks = NOW();
-#define checkTimeout() (NOW() - startTicks >= timeout)
-#else
-#define checkTimeout() (false)
-#endif
-
+	OneShotElapseTimer<NanoTime::Milliseconds> timer(GDBSTUB_UART_READ_TIMEOUT);
 	do {
 		wdt_feed();
 		system_soft_wdt_feed();
@@ -127,7 +120,7 @@ int ATTR_GDBEXTERNFN gdbReceiveChar()
 #endif
 			return c;
 		}
-	} while(!checkTimeout());
+	} while(GDBSTUB_UART_READ_TIMEOUT == 0 || !timer.expired());
 
 	return -1;
 }
diff --git a/Sming/Arch/Host/Components/esp_hal/clk.c b/Sming/Arch/Host/Components/esp_hal/clk.c
index eac810203d..74729ee259 100644
--- a/Sming/Arch/Host/Components/esp_hal/clk.c
+++ b/Sming/Arch/Host/Components/esp_hal/clk.c
@@ -1,19 +1,42 @@
 #include "include/esp_clk.h"
+#include "include/esp_system.h"
 
-// The current CPU frequency
-static uint8_t __cpu_frequency = 80;
+// The current CPU frequency in MHz (ticks per us)
+static uint8_t cpu_frequency = SYS_CPU_80MHZ;
 
 bool system_update_cpu_freq(uint8 freq)
 {
-	if(freq == 80 || freq == 160) {
-		__cpu_frequency = freq;
+	if(freq == SYS_CPU_80MHZ || freq == SYS_CPU_160MHZ) {
+		cpu_frequency = freq;
 		return true;
 	} else {
 		return false;
 	}
 }
 
+uint8_t ets_get_cpu_frequency(void)
+{
+	return cpu_frequency;
+}
+
 uint8 system_get_cpu_freq(void)
 {
-	return __cpu_frequency;
+	return ets_get_cpu_frequency();
+}
+
+/*
+ * The 'correct' conversion is actually:
+ *
+ * 		`os_get_nanoseconds() / (1000UL * cpu_frequency)`
+ *
+ * However, in use this just ends up returning 0 all the time which is
+ * not particularly useful.
+ *
+ * On my dev. system a straight nanosecond count gives quite useful
+ * values when evaluating code paths. Try :sample:`Basic_Delegates`.
+ *
+ */
+uint32_t esp_get_ccount()
+{
+	return os_get_nanoseconds();
 }
diff --git a/Sming/Arch/Host/Components/esp_hal/include/esp_clk.h b/Sming/Arch/Host/Components/esp_hal/include/esp_clk.h
index ab707dc969..e85ccf4772 100644
--- a/Sming/Arch/Host/Components/esp_hal/include/esp_clk.h
+++ b/Sming/Arch/Host/Components/esp_hal/include/esp_clk.h
@@ -11,7 +11,11 @@ extern "C" {
 #define SYS_CPU_160MHZ 160
 
 bool system_update_cpu_freq(uint8 freq);
-uint8 system_get_cpu_freq(void);
+uint8_t ets_get_cpu_frequency(void);
+uint8_t system_get_cpu_freq(void);
+
+/* Emulation of CPU cycle count */
+uint32_t esp_get_ccount();
 
 #ifdef __cplusplus
 }
diff --git a/Sming/Arch/Host/Components/esp_hal/system.cpp b/Sming/Arch/Host/Components/esp_hal/system.cpp
index dd810daa16..6e03336885 100644
--- a/Sming/Arch/Host/Components/esp_hal/system.cpp
+++ b/Sming/Arch/Host/Components/esp_hal/system.cpp
@@ -2,7 +2,7 @@
 #include <hostlib/hostapi.h>
 #include <hostlib/threads.h>
 #include <sys/time.h>
-#include <Rational.h>
+#include <Platform/Timers.h>
 
 /* System time */
 
@@ -54,8 +54,8 @@ uint32_t system_get_time()
 
 void os_delay_us(uint32_t us)
 {
-	auto start = system_get_time();
-	while(system_get_time() - start < us) {
+	ElapseTimer timer(us);
+	while(!timer.expired()) {
 		//
 	}
 }
diff --git a/Sming/Arch/Host/Components/hostlib/startup.cpp b/Sming/Arch/Host/Components/hostlib/startup.cpp
index 2359127d99..74ef3672a2 100644
--- a/Sming/Arch/Host/Components/hostlib/startup.cpp
+++ b/Sming/Arch/Host/Components/hostlib/startup.cpp
@@ -26,7 +26,6 @@
 #include "options.h"
 #include <spi_flash/flashmem.h>
 #include <driver/uart_server.h>
-#include <driver/hw_timer.h>
 #include <BitManipulations.h>
 #include <esp_timer_legacy.h>
 #include <esp_tasks.h>
@@ -34,6 +33,7 @@
 #include <stdlib.h>
 
 #include <Platform/System.h>
+#include <Platform/Timers.h>
 
 static int exitCode = 0;
 static bool done = false;
@@ -237,15 +237,13 @@ int main(int argc, char* argv[])
 
 		init();
 
-		const uint32_t lwipServiceInterval = 50000;
-		uint32_t lwipNextService = 0;
+		OneShotElapseTimer<NanoTime::Milliseconds> lwipServiceTimer(50);
 		while(!done) {
-			auto now = system_get_time();
 			host_service_tasks();
 			host_service_timers();
-			if(lwip_initialised && (now >= lwipNextService)) {
+			if(lwip_initialised && lwipServiceTimer.expired()) {
 				host_lwip_service();
-				lwipNextService = now + lwipServiceInterval;
+				lwipServiceTimer.start();
 			}
 			system_soft_wdt_feed();
 		}
diff --git a/Sming/Core/NanoTime.cpp b/Sming/Core/NanoTime.cpp
new file mode 100644
index 0000000000..a50681409a
--- /dev/null
+++ b/Sming/Core/NanoTime.cpp
@@ -0,0 +1,145 @@
+/****
+ * Sming Framework Project - Open Source framework for high efficiency native ESP8266 development.
+ * Created 2015 by Skurydin Alexey
+ * http://github.com/SmingHub/Sming
+ * All files of the Sming Core are provided under the LGPL v3 license.
+ *
+ * NanoTime.cpp
+ *
+ * @author mikee47 <mike@sillyhouse.net>
+ *
+ ****/
+
+#include "NanoTime.h"
+
+#include <WString.h>
+
+namespace NanoTime
+{
+const char* unitToString(Unit unit)
+{
+	switch(unit) {
+	case Nanoseconds:
+		return "ns";
+	case Microseconds:
+		return "us";
+	case Milliseconds:
+		return "ms";
+	case Seconds:
+		return "s";
+	case Minutes:
+		return "m";
+	case Hours:
+		return "h";
+	case Days:
+		return "d";
+	default:
+		return "?s";
+	}
+}
+
+const char* unitToLongString(Unit unit)
+{
+	switch(unit) {
+	case Nanoseconds:
+		return "nanoseconds";
+	case Microseconds:
+		return "microseconds";
+	case Milliseconds:
+		return "milliseconds";
+	case Seconds:
+		return "seconds";
+	case Minutes:
+		return "minutes";
+	case Hours:
+		return "hours";
+	case Days:
+		return "days";
+	default:
+		return "?s";
+	}
+}
+
+String Frequency::toString() const
+{
+	auto freq = frequency;
+	unsigned div = 0;
+	while(freq % 1000 == 0) {
+		freq /= 1000;
+		++div;
+	}
+	String s(freq);
+	if(div == 1) {
+		s += 'K';
+	} else if(div == 2) {
+		s += 'M';
+	} else if(div == 3) {
+		s += 'G';
+	}
+	s += "Hz";
+	return s;
+}
+
+template <unsigned BufSize> class FormatBuffer
+{
+public:
+	FormatBuffer()
+	{
+		buffer[0] = '\0';
+	}
+
+	void add(unsigned value, unsigned digits)
+	{
+		pos += strlen(ultoa_wp(value, &buffer[pos], 10, digits, '0'));
+	}
+
+	void add(char c)
+	{
+		buffer[pos++] = c;
+	}
+
+	operator String() const
+	{
+		return String(buffer, pos);
+	}
+
+private:
+	char buffer[BufSize];
+	unsigned pos = 0;
+};
+
+String TimeValue::toString() const
+{
+	if(overflow) {
+		return "(OVF)";
+	}
+
+	FormatBuffer<64> buf;
+
+	if(days != 0) {
+		buf.add(days, 0);
+		buf.add('d');
+		buf.add(' ');
+	}
+
+	buf.add(hours, 2);
+	buf.add(':');
+	buf.add(minutes, 2);
+	buf.add(':');
+	buf.add(seconds, 2);
+
+	if(unit < NanoTime::Seconds) {
+		buf.add('.');
+		buf.add(milliseconds, 3);
+		if(microseconds != 0 || nanoseconds != 0) {
+			buf.add(microseconds, 3);
+			if(nanoseconds != 0) {
+				buf.add(nanoseconds, 3);
+			}
+		}
+	}
+
+	return buf;
+}
+
+} // namespace NanoTime
diff --git a/Sming/Core/NanoTime.h b/Sming/Core/NanoTime.h
new file mode 100644
index 0000000000..143e0b16b1
--- /dev/null
+++ b/Sming/Core/NanoTime.h
@@ -0,0 +1,718 @@
+/****
+ * Sming Framework Project - Open Source framework for high efficiency native ESP8266 development.
+ * Created 2015 by Skurydin Alexey
+ * http://github.com/SmingHub/Sming
+ * All files of the Sming Core are provided under the LGPL v3 license.
+ *
+ * NanoTime.h - Utilities for handling time periods at nanosecond resolution
+ *
+ * @author mikee47 <mike@sillyhouse.net>
+ *
+ * Note: C++ provides the `chrono` utilities but is not well-suited for embedded applications:
+ *
+ * - Only uses 64-bit calculations. NanoTime can use any integral type, although uint32_t is the most useful.
+ * - Time conversions are truncated. A value of 0.99 seconds would be treated as 0.
+ *   NanoTime rounds results so would return 1.
+ * - Supports compile-time calculations but no runtime calculation support.
+ *
+ ****/
+
+#pragma once
+
+#include <stdint.h>
+#include <esp_attr.h>
+#include <sming_attr.h>
+#include <math.h>
+#include "Rational.h"
+#include <WString.h>
+
+/** @defgroup   timer Timers
+ *  @brief      System timer support classes
+*/
+
+/** @defgroup   system_clocks System clocks
+ *  @brief System clock definitions
+ *  @ingroup    timer
+ *  @{
+*/
+
+namespace NanoTime
+{
+/**
+ * @brief Identify units for a scalar quantity of time
+ * @note Ordered in increasing unit size, e.g. days > seconds
+ */
+enum Unit {
+	Nanoseconds,
+	Microseconds,
+	Milliseconds,
+	Seconds,
+	Minutes,
+	Hours,
+	Days,
+	UnitMax = Days,
+};
+
+/**
+ * @brief Get a string identifying the given time units, e.g. "ns"
+ */
+const char* unitToString(Unit unit);
+
+/**
+ * @brief Get a long string identifying the given time units, e.g. "seconds"
+ */
+const char* unitToLongString(Unit unit);
+
+/**
+ * @brief Class to represent a frequency
+ */
+struct Frequency {
+	Frequency(uint32_t frequency) : frequency(frequency)
+	{
+	}
+
+	operator uint32_t()
+	{
+		return frequency;
+	}
+
+	/**
+	 * @brief Get frequency as compact string
+	 * @note Drop trailing zeroes to produce a more compact string, e.g.
+	 *		0 -> 0Hz
+	 *		1000 -> 1KHz
+	 *		4553000 -> 4553KHz
+	 *		1000000000 -> 1GHz
+	 *
+	 */
+	String toString() const;
+
+	uint32_t frequency;
+};
+
+/**
+ * @brief List of clock ticks for each supported unit of time
+ */
+constexpr BasicRatio32 unitTicks[UnitMax + 1] = {
+	{1000000000, 1},   // Nanoseconds
+	{1000000, 1},	  // Microseconds
+	{1000, 1},		   // Milliseconds
+	{1, 1},			   // Seconds
+	{1, 60},		   // Minutes
+	{1, 60 * 60},	  // Hours
+	{1, 24 * 60 * 60}, // Days
+};
+
+/**
+ * @brief Class template to define tick std::ratio type
+ * @tparam unit
+ * @retval std::ratio Ticks per second
+ * @note This would be preferable:
+ * `template <Unit unit> using UnitTickRatio = std::ratio<unitTicks[unit].num, unitTicks[unit].den>;`
+ * But GCC 4.8 doesn't like it (lvalue required as unary '&' operand)
+ */
+template <Unit unit> struct UnitTickRatio {
+	static constexpr uint64_t num = unitTicks[unit].num;
+	static constexpr uint64_t den = unitTicks[unit].den;
+};
+
+// Forward declarations
+template <class Clock_, Unit unit_, uint64_t time_> struct TimeConst;
+template <class Clock_, uint64_t ticks_> struct TicksConst;
+template <class Clock_, Unit unit_, typename TimeType_> struct TimeSource;
+template <typename T> struct Time;
+template <typename Clock_, typename T> struct Ticks;
+
+/**
+ * @brief Class template representing a physical Clock with fixed timing characteristics
+ * @tparam ClockDef The actual Clock being constructed (so we can query its properties)
+ * @tparam frequency_ Clock frequency in Hz
+ * @tparam TickType_ Variable type representing the clock's tick value
+ * @tparam maxTicks_ Maximum count value for the clock
+ * @note Physical clocks are implemented using this as a base.
+ * The provided frequency accounts for any prescaler setting in force. Fixing this
+ * at compile time helps to avoid expensive runtime calculations and permits static range checks.
+ * @see Use `TimeSource` to work with a Clock in specific time units
+ */
+template <typename ClockDef, uint32_t frequency_, typename TickType_, TickType_ maxTicks_> struct Clock {
+	using TickType = TickType_;
+	template <uint64_t ticks> using TicksConst = TicksConst<Clock, ticks>;
+	template <Unit unit, uint64_t time> using TimeConst = TimeConst<Clock, unit, time>;
+	template <Unit unit> using TicksPerUnit = std::ratio_divide<std::ratio<frequency_>, UnitTickRatio<unit>>;
+	template <Unit unit, typename TimeType> using TimeSource = TimeSource<Clock, unit, TimeType>;
+	template <typename T> using Ticks = Ticks<Clock, T>;
+
+	static constexpr const char* typeName()
+	{
+		return ClockDef::typeName();
+	}
+
+	static constexpr uint32_t frequency()
+	{
+		return frequency_;
+	}
+
+	using MaxTicks = TicksConst<maxTicks_>;
+	static constexpr MaxTicks maxTicks()
+	{
+		return MaxTicks();
+	}
+
+	template <Unit unit> using MaxTime = typename MaxTicks::template TimeConst<unit>;
+	template <Unit unit> static constexpr MaxTime<unit> maxTime()
+	{
+		return MaxTime<unit>();
+	}
+
+	/**
+	 * @brief Get ticks per unit as a Ratio object
+	 * @retval BasicRatio32
+	 */
+	static Ratio32 ticksPerUnit(Unit unit)
+	{
+		const auto& tpu = unitTicks[unit];
+		return Ratio32(frequency_ * tpu.den, tpu.num);
+	}
+
+	/**
+	 * @brief Class template defining a fixed time quantity
+	 * @tparam time
+	 * @retval TimeConst
+	 */
+	template <Unit unit, uint64_t time> static constexpr TimeConst<unit, time> timeConst()
+	{
+		return TimeConst<unit, time>();
+	}
+
+	/**
+	 * @brief Class template defining a fixed tick quantity
+	 * @tparam ticks
+	 * @retval TicksConst<Clock, ticks>
+	 */
+	template <uint64_t ticks> static constexpr TicksConst<ticks> ticksConst()
+	{
+		return TicksConst<ticks>();
+	}
+
+	/**
+	 * @brief Create a Time Source for this Clock
+	 * @tparam unit
+	 * @tparam TimeType
+	 */
+	template <Unit unit, typename TimeType> static constexpr TimeSource<unit, TimeType> timeSource()
+	{
+		return TimeSource<unit, TimeType>();
+	}
+
+	/**
+	 * @brief Get the number of ticks for a given time
+	 * @param time
+	 * @retval TimeType Tick count, rounded to the nearest tick
+	 */
+	template <Unit unit, typename TimeType> static Ticks<TimeType> timeToTicks(TimeType time)
+	{
+		return TimeSource<unit, TimeType>::timeToTicks(time);
+	}
+
+	/**
+	 * @brief Get the time for a given number of clock ticks
+	 * @param ticks
+	 * @retval TimeType Time count, rounded to the nearest unit
+	 */
+	template <Unit unit, typename TimeType> static Time<TimeType> ticksToTime(TimeType ticks)
+	{
+		return TimeSource<unit, TimeType>::ticksToTime(ticks);
+	}
+
+	static String toString()
+	{
+		String s;
+		s += typeName();
+		s += '/';
+		s += Frequency(frequency()).toString();
+		return s;
+	}
+};
+
+/**
+ * @brief Function template to convert a constant time quantity from one unit to another
+ * @param time The time to convert
+ * @tparam unitsFrom Units for `time` parameter
+ * @tparam unitsTo Units for return value
+ * @retval TimeType Converted time
+ * @note example:
+ *
+ * 	uint32_t micros = convert<50, Milliseconds, Microseconds>();
+ */
+template <uint64_t time, Unit unitsFrom, Unit unitsTo> constexpr uint64_t convert()
+{
+	return ({
+		using R = std::ratio_divide<UnitTickRatio<unitsTo>, UnitTickRatio<unitsFrom>>;
+		round(double(time) * R::num / R::den);
+	});
+}
+
+/**
+ * @brief Function template to convert a time quantity from one unit to another
+ * @tparam TimeType Variable type to use for calculation
+ * @param time The time to convert
+ * @param unitsFrom Units for `time` parameter
+ * @param unitsTo Units for return value
+ * @retval TimeType Converted time, returns TimeType(-1) if calculation overflowed
+ */
+template <typename TimeType> __forceinline TimeType convert(const TimeType& time, Unit unitsFrom, Unit unitsTo)
+{
+	if(unitsFrom == unitsTo) {
+		return time;
+	}
+
+	using R = Ratio<TimeType>;
+	return time * R(unitsTo) / R(unitsFrom);
+}
+
+/**
+ * @brief A time time broken into its constituent elements
+ * @note Useful for analysing and printing time values
+ */
+struct TimeValue {
+	TimeValue() = default;
+
+	/**
+	 * @brief Resolve a time value into constituent components
+	 * @param time The time to resolve
+	 * @param unit Units for given time
+	 */
+	template <typename TimeType> TimeValue(Unit unit, TimeType time)
+	{
+		set(unit, time);
+	}
+
+	template <typename TimeType> void set(Unit unit, TimeType time);
+
+	/**
+	 * @brief Get sub-second time entirely in microseconds
+	 */
+	uint32_t getMicroseconds() const
+	{
+		return microseconds + (milliseconds * 1000);
+	}
+
+	/**
+	 * @brief Get sub-second time entirely in nanoseconds
+	 */
+	uint32_t getNanoseconds() const
+	{
+		return nanoseconds + getMicroseconds() * 1000;
+	}
+
+	String toString() const;
+
+	operator String() const
+	{
+		return toString();
+	}
+
+	bool overflow = false;
+	Unit unit = Seconds; ///< Time unit passed to set() call
+	uint32_t days = 0;
+	uint8_t hours = 0;
+	uint8_t minutes = 0;
+	uint8_t seconds = 0;
+	uint16_t milliseconds = 0;
+	uint32_t microseconds = 0;
+	uint32_t nanoseconds = 0;
+};
+
+template <typename TimeType> void TimeValue::set(Unit unit, TimeType time)
+{
+	overflow = (time == TimeType(-1));
+	this->unit = unit;
+
+	TimeType elem[UnitMax + 1] = {0};
+	elem[unit] = time;
+
+	auto divmod = [&elem](Unit u, uint16_t div) {
+		elem[u + 1] = elem[u] / div;
+		elem[u] %= div;
+	};
+
+	if(unit < Days) {
+		if(unit < Hours) {
+			if(unit < Minutes) {
+				if(unit < Seconds) {
+					if(unit < Milliseconds) {
+						if(unit < Microseconds) {
+							divmod(Nanoseconds, 1000);
+						}
+						divmod(Microseconds, 1000);
+					}
+					divmod(Milliseconds, 1000);
+				}
+				divmod(Seconds, 60);
+			}
+			divmod(Minutes, 60);
+		}
+		divmod(Hours, 24);
+	}
+
+	nanoseconds = elem[Nanoseconds];
+	microseconds = elem[Microseconds];
+	milliseconds = elem[Milliseconds];
+	seconds = elem[Seconds];
+	minutes = elem[Minutes];
+	hours = elem[Hours];
+	days = elem[Days];
+}
+
+/**
+ * @brief Class to handle a simple time value with associated unit
+ */
+template <typename T> struct Time {
+	Time(Unit unit, T time) : unit(unit), time(time)
+	{
+	}
+
+	operator T() const
+	{
+		return time;
+	}
+
+	String toString() const
+	{
+		String s(time);
+		s += unitToString(unit);
+		return s;
+	}
+
+	TimeValue value() const
+	{
+		return TimeValue(unit, time);
+	}
+
+	template <Unit unitTo> Time as() const
+	{
+		return Time(unitTo, convert(time, unit, unitTo));
+	}
+
+	Unit unit;
+	T time;
+};
+
+/**
+ * @brief Helper function to create a Time and deduce the type
+ */
+template <typename T> Time<T> time(Unit unit, T value)
+{
+	return Time<T>(unit, value);
+}
+
+/**
+ * @brief Class to handle a tick value associated with a clock
+ */
+template <typename Clock_, typename T> struct Ticks {
+	using Clock = Clock_;
+
+	static constexpr Clock clock()
+	{
+		return Clock();
+	}
+
+	Ticks(T ticks) : ticks(ticks)
+	{
+	}
+
+	operator T() const
+	{
+		return ticks;
+	}
+
+	String toString() const
+	{
+		return String(ticks);
+	}
+
+	template <Unit unit> Time<T> as()
+	{
+		return Time<T>(unit, Clock::template ticksToTime<unit>(ticks));
+	}
+
+	T ticks;
+};
+
+/**
+ * @brief Class template to represent a fixed time value for a specific Clock
+ * @tparam Clock_
+ * @tparam unit_
+ * @tparam time_
+ * @note Includes compile-time range checking. Time is taken as reference for conversions.
+ */
+template <class Clock_, Unit unit_, uint64_t time_> struct TimeConst {
+	using Clock = Clock_;
+	using TicksPerUnit = typename Clock::template TicksPerUnit<unit_>;
+
+	static constexpr Clock clock()
+	{
+		return Clock();
+	}
+
+	static constexpr Unit unit()
+	{
+		return unit_;
+	}
+
+	static constexpr uint64_t time()
+	{
+		return time_;
+	}
+
+	constexpr operator uint64_t()
+	{
+		return time_;
+	}
+
+	/**
+	 * @brief Get ticks per unit as a Ratio object
+	 * @retval BasicRatio32
+	 */
+	static Ratio32 ticksPerUnit()
+	{
+		return BasicRatio32{TicksPerUnit::num, TicksPerUnit::den};
+	}
+
+	/**
+	 * @brief Return the corresponding tick value for the time interval
+	 * @retval TimeType
+	 */
+	static constexpr uint64_t ticks()
+	{
+		return round(double(time_) * TicksPerUnit::num / TicksPerUnit::den);
+	}
+
+	/**
+	 * @brief Use this function to perform a static (compile-time) range check against Clock maxTicks
+	 * @retval TimeType
+	 */
+	static constexpr void check()
+	{
+		static_assert(ticks() <= Clock::maxTicks(), "Time exceeds clock range");
+	}
+
+	/**
+	 * @brief Obtain the actual Clock time by converting tick value
+	 * @retval TimeType
+	 */
+	static constexpr uint64_t clockTime()
+	{
+		return round(double(ticks()) * TicksPerUnit::den / TicksPerUnit::num);
+	}
+
+	/**
+	 * @brief Obtain the time in a different set of units
+	 * @tparam unit
+	 * @retval TimeType
+	 */
+	template <Unit unit> static constexpr uint64_t as()
+	{
+		return convert<time_, unit_, unit>();
+	}
+
+	static TimeValue value()
+	{
+		return TimeValue(unit_, time_);
+	}
+
+	static TimeValue clockValue()
+	{
+		return TimeValue(unit_, clockTime());
+	}
+
+	static String toString()
+	{
+		return Time<uint64_t>(unit_, time_).toString();
+	}
+};
+
+/**
+ * @brief Class template representing a fixed clock tick count
+ * @tparam Source_
+ * @tparam ticks_
+ * @note Includes compile-time range checking
+ */
+template <class Clock_, uint64_t ticks_> struct TicksConst {
+	using Clock = Clock_;
+	using TickType = uint64_t;
+	using TimeType = uint64_t;
+
+	static constexpr TickType ticks()
+	{
+		return ticks_;
+	}
+
+	constexpr operator TickType()
+	{
+		return ticks_;
+	}
+
+	/**
+	 * @brief Obtain the tick count with a static range check against Clock maxTicks
+	 * @retval TimeType
+	 */
+	static constexpr void check()
+	{
+		static_assert(ticks_ <= Clock::maxTicks(), "Ticks exceeds clock range");
+	}
+
+	template <Unit unit>
+	using TimeConst = TimeConst<Clock, unit,
+								TimeType(round(double(ticks_) * Clock::template TicksPerUnit<unit>::den /
+											   Clock::template TicksPerUnit<unit>::num))>;
+
+	/**
+	 * @brief Get the time for the tick count in a specific time unit
+	 * @tparam unit
+	 * @retval Time<TimeType>
+	 */
+	template <Unit unit> static constexpr TimeConst<unit> as()
+	{
+		return TimeConst<unit>();
+	}
+
+	static String toString()
+	{
+		return ticks_;
+	}
+};
+
+/**
+ * @brief Function template to convert a time quantity from one unit to another
+ * @tparam unitsFrom Units for `time` parameter
+ * @tparam unitsTo Units for return value
+ * @tparam TimeType Variable type to use for calculation
+ * @param time The time to convert
+ * @retval TimeType Converted time, returns TimeType(-1) if calculation overflowed
+ */
+template <Unit unitsFrom, Unit unitsTo, typename TimeType> __forceinline TimeType convert(const TimeType& time)
+{
+	if(unitsFrom == unitsTo) {
+		return time;
+	}
+
+	using R = std::ratio_divide<UnitTickRatio<unitsTo>, UnitTickRatio<unitsFrom>>;
+	return muldiv<R::num, R::den>(time);
+}
+
+/**
+ * @brief Class template for accessing a Clock in specific time units
+ * @tparam Clock_
+ * @tparam units_
+ * @tparam TimeType_ Limits range of calculations
+ * @note Includes compile-time range checking. Time is taken as reference for conversions.
+ */
+template <class Clock_, Unit unit_, typename TimeType_> struct TimeSource : public Clock_ {
+	using Clock = Clock_;
+	using TimeType = TimeType_;
+	using TicksPerUnit = typename Clock::template TicksPerUnit<unit_>;
+	template <uint64_t time> using TimeConst = TimeConst<Clock, unit_, time>;
+	template <uint64_t ticks> using TicksConst = TicksConst<Clock, ticks>;
+
+	static constexpr Unit unit()
+	{
+		return unit_;
+	}
+
+	/**
+	 * @brief Number of clock ticks per unit of time
+	 * @retval BasicRatio32 Result as a rational fraction
+	 */
+	static constexpr BasicRatio32 ticksPerUnit()
+	{
+		return {TicksPerUnit::num, TicksPerUnit::den};
+	}
+
+	/**
+	 * @brief Get the time corresponding to the maximum clock tick value
+	 */
+	using MaxClockTime = typename Clock::template MaxTime<unit_>;
+	static constexpr MaxClockTime maxClockTime()
+	{
+		return MaxClockTime();
+	}
+
+	// Check against arbitrary minimum - could be 1, but is that actually useful?
+	static_assert(maxClockTime() >= 5, "Time units too large for Clock ");
+
+	/**
+	 * @brief Obtain a TimeConst type representing the given time quantity
+	 * @tparam time
+	 * @retval TimeConst
+	 * @note Use methods of TimeConst to obtain corresponding tick count, etc.
+	 */
+	template <uint64_t time> static constexpr TimeConst<time> timeConst()
+	{
+		return TimeConst<time>();
+	}
+
+	/**
+	 * @brief Class template defining a fixed tick quantity
+	 * @tparam ticks
+	 * @retval TicksConst
+	 * @note Use methods of TickConst to obtain corresponding time values, etc.
+	 */
+	template <uint64_t ticks> static constexpr TicksConst<ticks> ticksConst()
+	{
+		return TicksConst<ticks>();
+	}
+
+	/**
+	 * @brief The maximum time value supported by timeToTicks without overflowing
+	 * @retval TimeType Passing values larger than this to `timeToTicks()` will truncate at maximum value
+	 */
+	static constexpr Time<TimeType_> maxCalcTime()
+	{
+		return Time<TimeType_>(unit_, MuldivLimits<TicksPerUnit::num, TicksPerUnit::den, TimeType>::maxValue());
+	}
+
+	/**
+	 * @brief The maximum tick value supported by ticksToTime without overflowing
+	 * @retval TimeType Passing values larger than this to `ticksToTime()` will truncate at maximum value
+	 */
+	static constexpr Ticks<Clock_, TimeType_> maxCalcTicks()
+	{
+		return MuldivLimits<TicksPerUnit::den, TicksPerUnit::num, TimeType>::maxValue();
+	}
+
+	/**
+	 * @brief Get the number of ticks for a given time
+	 * @param time
+	 * @retval TimeType Tick count, rounded to the nearest tick
+	 */
+	static Ticks<Clock_, TimeType_> timeToTicks(TimeType time)
+	{
+		return muldiv<TicksPerUnit::num, TicksPerUnit::den>(time);
+	}
+
+	/**
+	 * @brief Get the time for a given number of clock ticks
+	 * @param ticks
+	 * @retval TimeType Time count, rounded to the nearest unit
+	 */
+	static Time<TimeType_> ticksToTime(TimeType ticks)
+	{
+		return Time<TimeType_>(unit_, muldiv<TicksPerUnit::den, TicksPerUnit::num>(ticks));
+	}
+
+	static String toString()
+	{
+		String s;
+		s += Clock::toString();
+		s += '/';
+		s += sizeof(TimeType) * 8;
+		s += "-bit/";
+		s += unitToLongString(unit_);
+		return s;
+	}
+};
+
+} // namespace NanoTime
+
+/** @} */
diff --git a/Sming/Core/PolledTimer.h b/Sming/Core/PolledTimer.h
new file mode 100644
index 0000000000..e9d67859c7
--- /dev/null
+++ b/Sming/Core/PolledTimer.h
@@ -0,0 +1,256 @@
+/****
+ * Sming Framework Project - Open Source framework for high efficiency native ESP8266 development.
+ * Created 2015 by Skurydin Alexey
+ * http://github.com/SmingHub/Sming
+ * All files of the Sming Core are provided under the LGPL v3 license.
+ *
+ * PolledTimer.h - template class to assist with measurement of elapsed time periods
+ *
+ * @author mikee47 <mike@sillyhouse.net>
+ *
+ * Developed from the excellent esp8266 Arduino project's PolledTimer.h
+ * 	Copyright (c) 2018 Daniel Salazar. All rights reserved.
+ * 	https://github.com/esp8266/Arduino/blob/master/cores/esp8266/PolledTimeout.h
+ *
+ * Generally Sming uses timer callbacks but for some applications a polled timer
+ * is more appropriate, especially if timer intervals are less than few hundred
+ * microseconds, or even in nanoseconds.
+ *
+ * Here we have the `PolledTimer` template class. See `Platform/Timers.h` for implementations.
+ *
+ ****/
+
+#pragma once
+
+#include <stdint.h>
+#include <esp_attr.h>
+#include <sming_attr.h>
+#include <Platform/Clocks.h>
+
+/** @defgroup polled_timer Polled timers
+ *  @brief    Polled interval timers
+ *  @ingroup  timer
+ *  @{
+*/
+
+/**
+ * @brief Timer intervals are limited to the maximum clock time, minus this safety margin
+ * @note Specified in microseconds, this is the minimum timer poll interval to ensure no missed
+ * polls across the full timer range. Larger margin means smaller time range.
+ */
+#ifndef POLLED_TIMER_MARGIN_US
+#define POLLED_TIMER_MARGIN_US 250000
+#endif
+
+namespace PolledTimer
+{
+/**
+ * @brief Template class to implement a polled timer
+ * @tparam Clock Clock source
+ * @tparam unit Time unit for tick/time conversions
+ * @tparam IsPeriodic
+ * @tparam TimeType Variable type to use (uint32_t or uint64_t)
+ * @note Intervals and expiry use 'tick' values which are very efficient, whereas 'time' values
+ * must be computed so are very slow (~100+ cycles for uint32_t, considerably more for uint64_t).
+ * The class keeps a note of a 'start' time (in ticks) used to determine the `elapsed()` return value.
+ * An 'interval' value may be given is specified, then the `expired()` method returns true.
+ *
+ * If the interval is set to 0, the timer will expire immediately, and remain so: `canWait()` will return false.
+ * Call `cancel()` to prevent the timer from ever expiring: `canExpire()` will return false.
+ * Call `start()` to set the timer going with the previously set interval.
+ * Call `reset()` to set the timer with a new interval.
+ *
+ * A periodic timer will automatically restart when expired.
+ * A one-shot timer will remain expired until reset.
+ */
+template <class Clock, NanoTime::Unit unit_, bool IsPeriodic, typename TimeType>
+class Timer : public NanoTime::TimeSource<Clock, unit_, TimeType>
+{
+public:
+	static_assert(std::is_unsigned<TimeType>::value == true, "TimeType must be unsigned");
+
+	using TickType = typename Clock::TickType;
+	using Clock::ticks;
+	using Margin = NanoTime::TimeConst<Clock, NanoTime::Microseconds, POLLED_TIMER_MARGIN_US>;
+
+	static constexpr NanoTime::Unit unit()
+	{
+		return unit_;
+	}
+
+	static constexpr TickType maxInterval()
+	{
+		return Clock::maxTicks() - Margin::ticks();
+	}
+
+	static constexpr Margin margin()
+	{
+		return Margin();
+	}
+
+	/**
+	 * @brief Create a Timer with optional expiry time
+	 * @param interval Relative time until expiry
+	 */
+	IRAM_ATTR Timer(const TimeType& timeInterval = 0)
+	{
+		reset(timeInterval);
+	}
+
+	/**
+	 * @brief Start the timer
+	 */
+	__forceinline void IRAM_ATTR start()
+	{
+		startTicks = ticks();
+		if(!IsPeriodic) {
+			// One-shot timers require manual reset
+			hasExpired = false;
+		}
+	}
+
+	/**
+	 * @brief Start the timer with a new expiry interval
+	 * @param interval Time to expire after last call to start()
+	 */
+	template <uint64_t timeInterval> __forceinline void IRAM_ATTR reset()
+	{
+		auto ticks = checkTime<timeInterval>();
+		resetTicks(ticks);
+	}
+
+	/**
+	 * @brief Check the given time interval is valid and return the corresponding tick count
+	 * @tparam timeInterval
+	 * @retval uint32_t
+	 * @note If time interval is invalid fails compilation
+	 */
+	template <uint64_t timeInterval> constexpr uint32_t checkTime()
+	{
+		auto time = this->template timeConst<timeInterval>();
+		time.check();
+		constexpr auto ticks = time.ticks();
+		static_assert(ticks < maxInterval(), "Polled time interval too long");
+		return ticks;
+	}
+
+	/**
+	 * @brief Start the timer with a new expiry interval
+	 * @param interval Time to expire after last call to start()
+	 * @retval bool true on success, false on failure
+	 * @see See `resetTicks()`
+	 */
+	__forceinline bool IRAM_ATTR reset(const TimeType& timeInterval)
+	{
+		return resetTicks(this->template timeToTicks(timeInterval));
+	}
+
+	/**
+	 * @brief Start the timer with a new expiry interval
+	 * @param interval Clock ticks to expire after last call to start()
+	 * @retval bool true on success, false if interval is out of range
+	 * @note If time interval is 0, timer will expire immediately, and if it
+	 * exceeds the maximum interval the timer will never expire.
+	 */
+	__forceinline bool IRAM_ATTR resetTicks(const TimeType& interval)
+	{
+		start();
+		this->interval = interval;
+		neverExpires = (interval > maxInterval());
+		return !neverExpires;
+	}
+
+	/**
+	 * @brief Cancelling a timer means it will never expire
+	 */
+	__forceinline void IRAM_ATTR cancel()
+	{
+		interval = 1; // Ensure canWait() returns true
+		neverExpires = true;
+		if(!IsPeriodic) {
+			hasExpired = true;
+		}
+	}
+
+	/**
+	 * @brief Get elapsed ticks since start() was last called
+	 */
+	__forceinline TickType elapsedTicks() const
+	{
+		return ticks() - startTicks;
+	}
+
+	/**
+	 * @brief Get elapsed time since start() was last called
+	 */
+	__forceinline NanoTime::Time<TimeType> elapsedTime() const
+	{
+		return this->template ticksToTime(elapsedTicks());
+	}
+
+	__forceinline bool canExpire() const
+	{
+		return !neverExpires;
+	}
+
+	__forceinline bool canWait() const
+	{
+		return interval != 0;
+	}
+
+	/**
+	 * @brief Determine if timer has expired
+	 * @retval bool
+	 */
+	__forceinline bool expired()
+	{
+		return IsPeriodic ? expiredRetrigger() : expiredOneShot();
+	}
+
+private:
+	bool IRAM_ATTR checkExpired(const TickType& ticks) const
+	{
+		// canWait() is not checked here
+		// returns "can expire" and "time expired"
+		return !neverExpires && (TickType(ticks - startTicks) >= interval);
+	}
+
+	bool IRAM_ATTR expiredRetrigger()
+	{
+		if(!canWait()) {
+			return true;
+		}
+
+		bool result = false;
+		TickType current = ticks();
+		while(checkExpired(current)) {
+			result = true;
+			startTicks += interval;
+		}
+
+		return result;
+	}
+
+	bool IRAM_ATTR expiredOneShot()
+	{
+		// Remain triggered until manually reset or cancelled
+		if(!canWait() || hasExpired) {
+			return true;
+		}
+		hasExpired = checkExpired(ticks());
+		return hasExpired;
+	}
+
+	TickType startTicks;
+	TickType interval;
+	bool neverExpires; ///< Set when timer cancelled or set to maximal interval
+	bool hasExpired;   ///< Set when one-shot timer expiry reported
+};
+
+// Standard timer types
+template <typename Clock, NanoTime::Unit unit> using OneShot = Timer<Clock, unit, false, uint32_t>;
+template <typename Clock, NanoTime::Unit unit> using Periodic = Timer<Clock, unit, true, uint32_t>;
+
+} // namespace PolledTimer
+
+/** @} */
diff --git a/Sming/Platform/Clocks.h b/Sming/Platform/Clocks.h
new file mode 100644
index 0000000000..2605bbc91c
--- /dev/null
+++ b/Sming/Platform/Clocks.h
@@ -0,0 +1,110 @@
+/****
+ * Sming Framework Project - Open Source framework for high efficiency native ESP8266 development.
+ * Created 2015 by Skurydin Alexey
+ * http://github.com/SmingHub/Sming
+ * All files of the Sming Core are provided under the LGPL v3 license.
+ *
+ * Clocks.h
+ *
+ * @author mikee47 <mike@sillyhouse.net>
+ *
+ ****/
+
+#pragma once
+
+#include <NanoTime.h>
+#include <driver/hw_timer.h>
+#include <esp_clk.h>
+#include "System.h"
+
+/** @ingroup system_clocks
+ *  @{
+ */
+
+/**
+ * @brief Clock implementation for Hardware Timer 1
+ * @tparam clkdiv Prescaler in use
+ */
+template <hw_timer_clkdiv_t clkdiv>
+struct Timer1Clock
+	: public NanoTime::Clock<Timer1Clock<clkdiv>, HW_TIMER_BASE_CLK / (1 << clkdiv), uint32_t, MAX_HW_TIMER1_INTERVAL> {
+	static constexpr uint32_t prescale()
+	{
+		return 1 << clkdiv;
+	}
+
+	static constexpr const char* typeName()
+	{
+		return "Timer1Clock";
+	}
+
+	/*
+	 * As Timer1 is a down-counter, when active this will indicate remaining ticks until the next interrupt.
+	 */
+	static uint32_t __forceinline ticks()
+	{
+		return hw_timer1_read();
+	}
+};
+
+/**
+ * @brief Clock implementation for Hardware Timer 2
+ * @note Prescaler is fixed
+ * @see See `driver/hw_timer.h`
+ */
+struct Timer2Clock : public NanoTime::Clock<Timer2Clock, HW_TIMER2_CLK, uint32_t, 0xFFFFFFFFU> {
+	static constexpr const char* typeName()
+	{
+		return "Timer2Clock";
+	}
+
+	static uint32_t __forceinline ticks()
+	{
+		return NOW();
+	}
+};
+
+/**
+ * @brief Clock implementation for CPU cycle times
+ * @note The intended purpose is to evaluate code performance and possibly for _very_ short
+ * time interval requirements. The 32-bit counter overflows:
+ *
+ * 		Overflows every 53.687 seconds @ 80MHz CPU clock
+ * 		Overflows every 26.843 seconds @ 160MHz CPU clock
+ *
+ * Generally this will provide the shortest time periods.
+ *
+ * Time calculations are fixed at compile time, so you should use either
+ * CpuCycleClockNormal or CpuCycleClockFast depending on the currently configured CPU speed.
+ * @see See `System::setCpuFrequency()`
+ */
+template <CpuFrequency cpuFreq>
+struct CpuCycleClock
+	: public NanoTime::Clock<CpuCycleClock<cpuFreq>, uint32_t(cpuFreq) * 1000000, uint32_t, 0xFFFFFFFF> {
+	static constexpr const char* typeName()
+	{
+		return "CpuCycleClock";
+	}
+
+	static uint32_t __forceinline ticks()
+	{
+		return esp_get_ccount();
+	}
+
+	static constexpr bool isFast()
+	{
+		return cpuFreq == eCF_160MHz;
+	}
+};
+
+/**
+ * @brief
+ */
+using CpuCycleClockNormal = CpuCycleClock<eCF_80MHz>;
+
+/**
+ * @brief
+ */
+using CpuCycleClockFast = CpuCycleClock<eCF_160MHz>;
+
+/** @} */
diff --git a/Sming/Platform/Timers.h b/Sming/Platform/Timers.h
new file mode 100644
index 0000000000..07ace431a3
--- /dev/null
+++ b/Sming/Platform/Timers.h
@@ -0,0 +1,59 @@
+/****
+ * Sming Framework Project - Open Source framework for high efficiency native ESP8266 development.
+ * Created 2015 by Skurydin Alexey
+ * http://github.com/SmingHub/Sming
+ * All files of the Sming Core are provided under the LGPL v3 license.
+ *
+ * PolledTimer.h - template class to assist with measurement of elapsed time periods
+ *
+ * @author mikee47 <mike@sillyhouse.net>
+ *
+ * Developed from the excellent esp8266 Arduino project's PolledTimer.h
+ * 	Copyright (c) 2018 Daniel Salazar. All rights reserved.
+ * 	https://github.com/esp8266/Arduino/blob/master/cores/esp8266/PolledTimeout.h
+ *
+ * Generally Sming uses timer callbacks but for some applications a polled timer
+ * is more appropriate, especially if timer intervals are less than few hundred
+ * microseconds, or even in nanoseconds.
+ *
+ ****/
+
+#pragma once
+
+#include <PolledTimer.h>
+#include "Clocks.h"
+
+/** @ingroup polled_timer
+ *  @{
+*/
+
+/*
+ * Elapse timers
+ */
+
+template <NanoTime::Unit unit> using OneShotElapseTimer = PolledTimer::OneShot<Timer2Clock, unit>;
+template <NanoTime::Unit unit> using PeriodicElapseTimer = PolledTimer::Periodic<Timer2Clock, unit>;
+
+using OneShotFastMs = OneShotElapseTimer<NanoTime::Milliseconds>;
+using OneShotFastUs = OneShotElapseTimer<NanoTime::Microseconds>;
+
+using ElapseTimer = OneShotFastUs;
+
+/*
+ * CPU Cycle timers
+ */
+
+template <NanoTime::Unit units> using OneShotCpuCycleTimer = PolledTimer::OneShot<CpuCycleClockNormal, units>;
+template <NanoTime::Unit units> using PeriodicCpuCycleTimer = PolledTimer::Periodic<CpuCycleClockNormal, units>;
+template <NanoTime::Unit units> using OneShotCpuCycleTimerFast = PolledTimer::OneShot<CpuCycleClockFast, units>;
+template <NanoTime::Unit units> using PeriodicCpuCycleTimerFast = PolledTimer::Periodic<CpuCycleClockFast, units>;
+using CpuCycleTimer = OneShotCpuCycleTimer<NanoTime::Nanoseconds>;
+using CpuCycleTimerFast = OneShotCpuCycleTimerFast<NanoTime::Nanoseconds>;
+
+/*
+ * Arduino-compatible types
+ */
+
+typedef OneShotFastMs oneShotFastMs SMING_DEPRECATED;
+typedef OneShotFastUs oneShotFastUs SMING_DEPRECATED;
+/** @} */
diff --git a/Sming/Services/Profiling/CycleCounter.h b/Sming/Services/Profiling/CycleCounter.h
deleted file mode 100644
index 0026f86025..0000000000
--- a/Sming/Services/Profiling/CycleCounter.h
+++ /dev/null
@@ -1,62 +0,0 @@
-/****
- * Sming Framework Project - Open Source framework for high efficiency native ESP8266 development.
- * Created 2015 by Skurydin Alexey
- * http://github.com/SmingHub/Sming
- * All files of the Sming Core are provided under the LGPL v3 license.
- *
- * CycleCounter.h - Class to measure elapesd time periods using CPU cycle counter.
- *
- * Intended purpose is to evaluate code performance and possibly for _very_ short
- * time interval requirements.
- *
- * Note that the CPU frequency may not be constant. If you require accurate time
- * period evaluation see `ElapseTimer`.
- *
- ****/
-#pragma once
-
-#include <stdint.h>
-#include <sming_attr.h>
-
-#ifdef ARCH_HOST
-#include <x86intrin.h>
-#endif
-
-/**
- * @brief Class for counting CPU cycles
- */
-class CycleCounter
-{
-public:
-	__forceinline CycleCounter()
-	{
-		start();
-	}
-
-	/** @brief Get the current CPU cycle count */
-	static uint32_t __forceinline count()
-	{
-#ifdef ARCH_HOST
-		return __rdtsc();
-#else
-		volatile uint32_t ccount;
-		__asm__ volatile("rsr %0, ccount" : "=r"(ccount));
-		return ccount;
-#endif
-	}
-
-	/** @brief Reset the start position to the current cycle count */
-	void __forceinline start()
-	{
-		startCount = count();
-	}
-
-	/** @brief Get elapsed cycle count since start() was last called */
-	uint32_t __forceinline elapsed()
-	{
-		return count() - startCount;
-	}
-
-private:
-	uint32_t startCount;
-};
diff --git a/Sming/Services/Profiling/ElapseTimer.h b/Sming/Services/Profiling/ElapseTimer.h
deleted file mode 100644
index cbf755c358..0000000000
--- a/Sming/Services/Profiling/ElapseTimer.h
+++ /dev/null
@@ -1,81 +0,0 @@
-/****
- * Sming Framework Project - Open Source framework for high efficiency native ESP8266 development.
- * Created 2015 by Skurydin Alexey
- * http://github.com/SmingHub/Sming
- * All files of the Sming Core are provided under the LGPL v3 license.
- *
- * ElapseTimer.h - Class to measure elapsed time periods by polling hardware timer.
- *
- ****/
-#pragma once
-
-#include <driver/hw_timer.h>
-#include <muldiv.h>
-
-/**
- * @brief Microsecond elapse timer to efficiently measure intervals
- * @note Maintains time using the hardware 'tick' counter values and only performs
- * conversion to microseconds when necessary.
- * The class keeps a note of a 'start' time used to determine the `elapsed()` return value.
- * An 'interval' value may be given is specified, then the `expired()` method returns true.
- */
-class ElapseTimer
-{
-public:
-	/**
-	 * @brief Create new ElapseTimer with optional expiry time
-	 * @param interval Microseconds to expiry after last call to start()
-	 * @note Conversion between microseconds and ticks is relatively expensive, so pass 0 if not required.
-	 */
-	__forceinline ElapseTimer(uint32_t interval = 0)
-	{
-		setInterval(interval);
-		start();
-	}
-
-	/**
-	 * @brief Set expiry interval
-	 * @param interval Microseconds to expiry after last call to start()
-	 */
-	void __forceinline setInterval(uint32_t interval)
-	{
-		this->interval = (interval == 0) ? 0 : muldiv<HW_TIMER2_CLK, 1000000>(interval);
-	}
-
-	/**
-	 * @brief Get the current tick value
-	 */
-	uint32_t __forceinline ticks()
-	{
-		return NOW();
-	}
-
-	/**
-	 * @brief re-start the timer
-	 */
-	void __forceinline start()
-	{
-		startTicks = ticks();
-	}
-
-	/**
-	 * @brief Get elapsed time in microseconds since start() was last called
-	 */
-	uint32_t __forceinline elapsed()
-	{
-		return muldiv<1000000, HW_TIMER2_CLK>(ticks() - startTicks);
-	}
-
-	/**
-	 * @brief Determine if timer has expired
-	 * @retval bool
-	 */
-	bool __forceinline expired()
-	{
-		return (ticks() - startTicks) >= interval;
-	}
-
-private:
-	uint32_t startTicks;
-	uint32_t interval;
-};
diff --git a/docs/source/information/index.rst b/docs/source/information/index.rst
index 54fca6df77..1cc0653922 100644
--- a/docs/source/information/index.rst
+++ b/docs/source/information/index.rst
@@ -5,6 +5,7 @@ Information
    :maxdepth: 1
 
    /_inc/Sming/building
+   events
    interrupts
    timers
    debugging
diff --git a/docs/source/information/timers.rst b/docs/source/information/timers.rst
index 15a9621ab4..d84e9badbd 100644
--- a/docs/source/information/timers.rst
+++ b/docs/source/information/timers.rst
@@ -1,5 +1,19 @@
 Timers
-------
+======
+
+.. highlight:: c++
+
+Generally, timers in Sming fall into two categories: Callback Timers and Polled Timers
+
+Callback Timers
+---------------
+
+A callback timer is operated by programming a time interval, then arming it. When the timer
+'fires' a function of your choosing gets called. Timers can be 'one-shot', for timing single
+events, or 'auto-reset' repetitive timers. A repetitive timer will ensure that time intervals
+between successive callbacks are consistent.
+
+There are two categories of callback timer.
 
 Hardware timers
    The ESP8266 has two main hardware timers. Timer1 is a countdown timer, which triggers
@@ -24,3 +38,156 @@ Software timers
    and delegate callback functions so you can use it with class methods, capturing lambdas, etc.
 
    The *SimpleTimer* class uses less RAM, but only supports regular function callbacks.
+
+Polled timers
+-------------
+
+Polled timers can be used to measure elapsed time intervals or to check for timeouts within code loops.
+Traditionally one might do this as follows::
+
+   const unsigned TIMEOUT_MS = 100;
+
+   unsigned start = millis();
+   while(millis() - start < TIMEOUT_MS) {
+      // do some stuff
+   }
+   unsigned elapsed = millis() - start;
+   Serial.print("Elapsed time: ");
+   Serial.print(elapsed);
+   Serial.println("ms");
+
+.. note::
+
+   A common source of bugs when hand-coding such loops can be illustrated by this alternative::
+
+      unsigned timeout = millis() + TIMEOUT_MS;
+      while(millis() < timeout) {
+         // do some stuff
+      }
+
+   At first glance this looks better than the first approach as we don't have a subtraction within the loop.
+   However, when millis() exceeds *MAXINT - TIMEOUT_MS* the *timeout* calculation will wrap and the
+   loop will never get executed.
+   This takes a little under 25 days, but with microseconds it'll happen in less than an hour.
+   This may not be the desired behaviour.
+
+It's generally safer and easier to use a Polled Timer::
+
+   OneShotFastMs timer(TIMEOUT_MS);
+   while(!timer.expired()) {
+      // do some stuff
+   }
+   auto elapsed = timer.elapsedTime(); // Returns a `NanoTime::Time` object, value with time units
+   Serial.print("Elapsed time: ");
+   Serial.println(elapsed.toString()); // Includes units in the elapsed time interval
+   // Show time rounded to nearest whole seconds
+   Serial.println(elapsed.as<NanoTime::Seconds>().toString());
+
+If you prefer to use microseconds, use *OneShotFastUs* instead or specify the units directly::
+
+   OneShotElapseTimer<NanoTime::Microseconds> timer;
+
+Another advantage of polled timers is speed. Every call to millis (or micros) requires a calculation
+from clock ticks into milliseconds (or microseconds). It's also a function call.
+
+Polled timers measure time using hardware clock ticks, and query the hardware timer register directly
+without any function calls or calculations. This makes them a much better choice for tight timing loops.
+
+Here's the output from the :source:`BenchmarkPolledTimer <tests/HostTests/app/test-clocks.cpp#L231>` module:
+
+.. code-block:: text
+
+   How many loop iterations can we achieve in 100 ms ?
+   Using millis(), managed 55984 iterations, average loop time = 1786ns (143 CPU cycles)
+   Using micros(), managed 145441 iterations, average loop time = 688ns (55 CPU cycles)
+   Using PolledTimer, managed 266653 iterations, average loop time = 375ns (30 CPU cycles)
+
+Timer range
+-----------
+
+The maximum interval for a timer varies depending on the clock source and the selected prescaler.
+The count may be further restricted by hardware. For example, Timer1 only provides a 23-bit count
+which means with a /16 prescaler (the default for HardwareTimer) it overflows after only 1.67 seconds.
+
+It's therefore important to check that timers are being used within their valid range. There are generally
+two ways to do this:
+
+Runtime checks
+   This means checking function/method return values and acting accordingly.
+   This often gets omitted because it can lead to cluttered code, which then leads to undiagnosed
+   bugs creeping in which can be very difficult to track down later on.
+
+   With a polled timer, you'd use one of these methods to set the time interval::
+
+      bool reset(const TimeType& timeInterval);
+      bool resetTicks(const TimeType& interval);
+
+   They both return true on success.
+
+Static checks
+   These checks are performed during code compilation, so if a check fails the code won't compile.
+   In regular 'C' code you'd do this using #if statements, but C++ offers a much better way using
+   `static_assert <https://en.cppreference.com/w/cpp/language/static_assert>`__.
+
+   To reset a polled timer and incorporate a static check, use this method::   
+
+      template <uint64_t timeInterval> void reset();
+
+   Note that timeInterval cannot be a variable (even if it's *const*) as the compiler must be
+   able to determine its value. It must therefore be *constexpr compatible*.
+
+You can use static checking to pre-validate the range for a timer before using it::
+
+   timer.checkTime<10>();
+   timer.checkTime<10000>();
+
+This will throw a compile-time error if the timer is not capable of using intervals in the
+range 10 - 10000 microseconds (or whichever time unit you've selected). It doesn't add any
+code to the application. If the code compiles, then you can be confident that the timer
+will function as expected and you don't need to check return values.
+
+Clocks
+------
+
+Timers and their capabilities can vary considerably. For example, Timer1 can be configured with
+a prescaler of 1, 16 or 256 which affects both the resolution and range of the timer. One might
+also consider the CPU cycle counter to have a selectable prescaler of 1 or 2, depending on
+whether it's running at 80MHz or 160MHz.
+
+A *Clock* definition is a class template which allows us to query timer properties and perform time
+conversions for a specific timer configuration. These definitions can be found in :source:`Sming/Platform/Clocks.h`.
+
+.. note:: A Clock is a purely virtual construct and does not provide any means to configure the hardware,
+   although it does provide the *ticks()* method to obtain the current timer value.
+
+Clocks are made more useful by *TimeSource*, a generic class template defined in :source:`Sming/Core/NanoTime.h`.
+This provides methods to convert between time values and tick values for a specific time unit.
+
+Let's say we want a microsecond source using Timer2::
+
+   TimeSource<Timer2Clock, NanoTime::Microseconds, uint32_t> t2source;
+
+We can now call methods of *t2source* like this::
+
+   // What's the maximum Timer2 value in microseconds?
+   Serial.println(t2source.maxClockTime());
+
+   // How many clock ticks per microsecond ?
+   Serial.println(t2source.ticksPerUnit()); // 5/1
+
+   // How many clock ticks for 100us ?
+   Serial.println(t2source.template timeConst<100>().ticks());
+
+Note that all of these values are computed at compile time. Some runtime conversions::
+
+   Serial.println(t2source.timeToTicks(100));
+   Serial.println(t2source.ticksToTime(10000));
+
+The results of conversions are rounded rather than truncated, which provides more accurate
+results and reduces timing jitter.
+ 
+For debugging purposes you can print a description::
+
+   Serial.println(t2source.toString()); // "Timer2Clock/5MHz/32-bit/microseconds"
+
+See :source:`Sming/Core/NanoTime.h` for further details.
diff --git a/samples/Basic_Delegates/app/speed.cpp b/samples/Basic_Delegates/app/speed.cpp
index f61b486a46..9db218196d 100644
--- a/samples/Basic_Delegates/app/speed.cpp
+++ b/samples/Basic_Delegates/app/speed.cpp
@@ -3,7 +3,7 @@
  */
 
 #include <SmingCore.h>
-#include <Services/Profiling/CycleCounter.h>
+#include <Platform/Timers.h>
 #include "callbacks.h"
 
 #ifdef ARCH_HOST
@@ -15,29 +15,32 @@ const unsigned ITERATIONS = 100000;
 typedef Delegate<void(int)> TestDelegate;
 typedef void (*TestCallback)(int);
 
-static void printTime(const char* name, unsigned elapsed)
+// Use for high resolution loop timing
+static CpuCycleTimer timer;
+
+static void printTime(const char* name, unsigned ticks)
 {
-	Serial.printf("%s: %u\r\n", name, elapsed / ITERATIONS);
+	Serial.printf("%s: %u cycles, %s\r\n", name, ticks, timer.ticksToTime(ticks).toString().c_str());
 }
 
 static void __attribute__((noinline)) evaluateCallback(const char* name, TestCallback callback, int testParam)
 {
-	CycleCounter counter;
+	timer.start();
 	for(unsigned i = 0; i < ITERATIONS; ++i) {
 		callback(testParam);
 	}
-	unsigned elapsed = counter.elapsed();
-	printTime(name, elapsed);
+	unsigned ticks = timer.elapsedTicks();
+	printTime(name, ticks / ITERATIONS);
 }
 
 static void __attribute__((noinline)) evaluateDelegate(const char* name, TestDelegate delegate, int testParam)
 {
-	CycleCounter counter;
+	timer.start();
 	for(unsigned i = 0; i < ITERATIONS; ++i) {
 		delegate(testParam);
 	}
-	unsigned elapsed = counter.elapsed();
-	printTime(name, elapsed);
+	unsigned ticks = timer.elapsedTicks();
+	printTime(name, ticks / ITERATIONS);
 }
 
 void evaluateSpeed()
diff --git a/samples/Basic_ProgMem/app/TestProgmem.cpp b/samples/Basic_ProgMem/app/TestProgmem.cpp
index 8101a41f43..2b98a3ebf8 100644
--- a/samples/Basic_ProgMem/app/TestProgmem.cpp
+++ b/samples/Basic_ProgMem/app/TestProgmem.cpp
@@ -7,7 +7,7 @@
 #include "TestProgmem.h"
 #include "FlashData.h"
 #include "Print.h"
-#include "Services/Profiling/ElapseTimer.h"
+#include <Platform/Timers.h>
 
 // Note: contains nulls which won't display, but will be stored
 #define DEMO_TEST_TEXT "This is a flash string -\0Second -\0Third -\0Fourth."
@@ -166,11 +166,11 @@ void testSpeed(Print& out)
 	timer.start();
 	for(unsigned i = 0; i < iterations; ++i)
 		tmp += sumBuffer(demoText, sizeof(demoText));
-	baseline = timer.elapsed();
+	baseline = timer.elapsedTime();
 	out.printf("Elapsed: %u\n", baseline);
 
 #define END()                                                                                                          \
-	elapsed = timer.elapsed();                                                                                         \
+	elapsed = timer.elapsedTime();                                                                                     \
 	out.printf("Elapsed: %u (baseline + %u)\n", elapsed, elapsed - baseline);
 
 	_FPUTS("Load PSTR into stack buffer...");
diff --git a/tests/HostTests/app/modules.h b/tests/HostTests/app/modules.h
index 6c4e549992..45bc548689 100644
--- a/tests/HostTests/app/modules.h
+++ b/tests/HostTests/app/modules.h
@@ -4,4 +4,5 @@
 	XX(json5)                                                                                                          \
 	XX(json6)                                                                                                          \
 	XX(files)                                                                                                          \
-	XX(rational)
+	XX(rational)                                                                                                       \
+	XX(clocks)
diff --git a/tests/HostTests/app/test-clocks.cpp b/tests/HostTests/app/test-clocks.cpp
new file mode 100644
index 0000000000..06998fd506
--- /dev/null
+++ b/tests/HostTests/app/test-clocks.cpp
@@ -0,0 +1,451 @@
+/*
+ * Tests optimised time conversion code use for hardware timer.
+ * We do this by evaluating various time values and comparing against floating-point
+ * calculation.
+ */
+
+#include "common.h"
+#include <Platform/Timers.h>
+
+template <class Clock, typename TimeType> class ClockTestTemplate : public TestGroup
+{
+public:
+	using Micros = NanoTime::TimeSource<Clock, NanoTime::Microseconds, TimeType>;
+
+	ClockTestTemplate()
+		: TestGroup(F("TimeSource: ") + Micros::toString()), refCycles("Reference cycles"),
+		  calcCycles("Calculation cycles")
+	{
+#if DEBUG_VERBOSE_LEVEL == DBG
+		verbose = true;
+#endif
+	}
+
+	void execute() override
+	{
+		if(Clock::frequency() == 160000000) {
+			System.setCpuFrequency(eCF_160MHz);
+		} else {
+			System.setCpuFrequency(eCF_80MHz);
+		}
+
+		printLimits();
+
+		for(unsigned i = 0; i < 2000; ++i) {
+			auto value = os_random();
+			check<NanoTime::Milliseconds>(value);
+			check<NanoTime::Microseconds>(value);
+			check<NanoTime::Nanoseconds>(value);
+		}
+
+		printStats();
+	}
+
+	template <NanoTime::Unit unit> void check(TimeType value)
+	{
+		using TimeSource = NanoTime::TimeSource<Clock, unit, TimeType>;
+
+		//		Serial.print("HwTimer::maxTime = ");
+		//		Serial.println(HwTimer::maxTime());
+
+		this->timeunit = unit;
+
+		noInterrupts();
+
+		valueIsTime = true;
+		this->value = value % (TimeSource::maxCalcTime() + 1);
+		refCycles.start();
+		ref = timeToTicksRef();
+		refCycles.update();
+
+		calcCycles.start();
+		calc = TimeSource::timeToTicks(this->value);
+		calcCycles.update();
+
+		if(calc != ref) {
+			calc = TimeSource::timeToTicks(this->value);
+		}
+
+		compare();
+
+		valueIsTime = false;
+		this->value = value % (TimeSource::maxCalcTicks() + 1);
+		refCycles.start();
+		ref = ticksToTimeRef();
+		refCycles.update();
+
+		calcCycles.start();
+		calc = TimeSource::ticksToTime(this->value);
+		calcCycles.update();
+		compare();
+
+		interrupts();
+	}
+
+	void printStats()
+	{
+		Serial.println(refCycles);
+		Serial.println(calcCycles);
+	}
+
+	template <NanoTime::Unit unit> void printMaxTicks()
+	{
+		NanoTime::TimeSource<Clock, unit, TimeType> src;
+		auto time = src.maxClockTime();
+
+		Serial.print("    ");
+		Serial.print(src.maxTicks());
+		Serial.print(" ticks = ");
+		Serial.print(time.toString());
+		Serial.print(" = ");
+		Serial.println(time.value());
+	};
+
+	template <NanoTime::Unit unit> void printMaxCalcTicks()
+	{
+		NanoTime::TimeSource<Clock, unit, TimeType> src;
+		auto time = src.maxCalcTicks().template as<unit>();
+
+		Serial.print("    ");
+		Serial.print(src.maxCalcTicks());
+		Serial.print(" ticks = ");
+		Serial.print(time.toString());
+		Serial.print(" = ");
+		Serial.println(time.value());
+	};
+
+	template <NanoTime::Unit unit> void printMaxTime()
+	{
+		NanoTime::TimeSource<Clock, unit, TimeType> source;
+		auto time = source.maxCalcTime();
+		auto ticks = source.timeToTicks(time);
+
+		Serial.print("    ");
+		Serial.print(time.toString());
+		Serial.print(" = ");
+		Serial.print(time.value());
+		Serial.print(" = ");
+		Serial.print(ticks);
+		Serial.println(" ticks");
+	};
+
+	void printLimits()
+	{
+		m_puts("Limits:\r\n");
+
+		m_puts("  clock ticks:\r\n");
+		printMaxTicks<NanoTime::Milliseconds>();
+		printMaxTicks<NanoTime::Microseconds>();
+		printMaxTicks<NanoTime::Nanoseconds>();
+
+		m_puts("  ticks -> time:\r\n");
+		printMaxCalcTicks<NanoTime::Milliseconds>();
+		printMaxCalcTicks<NanoTime::Microseconds>();
+		printMaxCalcTicks<NanoTime::Nanoseconds>();
+
+		m_puts("  time -> ticks:\r\n");
+		printMaxTime<NanoTime::Milliseconds>();
+		printMaxTime<NanoTime::Microseconds>();
+		printMaxTime<NanoTime::Nanoseconds>();
+	}
+
+private:
+	const char* get_tag(bool is_time)
+	{
+		return is_time ? "time" : "ticks";
+	}
+
+	void print()
+	{
+		String value_tag = get_tag(valueIsTime);
+		String result_tag = get_tag(!valueIsTime);
+		auto diff = calc - ref;
+
+		Serial.print("  ");
+		Serial.print(value_tag);
+		Serial.print(": ");
+		Serial.print(value);
+		Serial.print(" (");
+		Serial.print(unitToString(timeunit));
+		Serial.print("), ref ");
+		Serial.print(result_tag);
+		Serial.print(": ");
+		Serial.print(ref);
+		Serial.print(", calc ");
+		Serial.print(result_tag);
+		Serial.print(": ");
+		Serial.print(calc);
+		Serial.print(", diff: ");
+		Serial.println(diff);
+	}
+
+	void compare()
+	{
+		// Tolerate a +/- 1 in result to account for FP rounding
+		int64_t diff = calc - ref;
+		bool ok = abs(diff) == 0; //1;
+		if(verbose || calc != ref) {
+			print();
+		}
+		TEST_ASSERT(ok);
+	};
+
+#define USE_FP_CALC
+
+	uint64_t timeToTicksRef()
+	{
+		auto unitTicks = NanoTime::unitTicks[timeunit];
+#ifdef USE_FP_CALC
+		return round(double(value) * Clock::frequency() * unitTicks.den / unitTicks.num);
+#else
+		return value / Ratio64 r(unitTicks.num, Clock::frequency() * unitTicks.den);
+#endif
+	}
+
+	uint64_t ticksToTimeRef()
+	{
+		auto unitTicks = NanoTime::unitTicks[timeunit];
+#ifdef USE_FP_CALC
+		return round(double(value) * unitTicks.num / (Clock::frequency() * unitTicks.den));
+#else
+		return value * Ratio64 r(unitTicks.num, Clock::frequency() * unitTicks.den);
+#endif
+	}
+
+private:
+	NanoTime::Unit timeunit = NanoTime::Seconds;
+	TimeType value = 0; // ticks or time as input to calculation
+	bool valueIsTime = false;
+	uint64_t ref = 0;  // Reference result
+	TimeType calc = 0; // Calculated result
+	bool verbose = false;
+	CycleTimes refCycles;
+	CycleTimes calcCycles;
+};
+
+/*
+ * Why use a Polled timer? Comparison versus hand-coded loops.
+ */
+class BenchmarkPolledTimer : public TestGroup
+{
+public:
+	BenchmarkPolledTimer() : TestGroup(_F("Benchmark Polled Timer"))
+	{
+	}
+
+	static constexpr unsigned TIMEOUT_MS = 100;
+
+	unsigned __attribute__((noinline)) millis_loop()
+	{
+		unsigned loopCount = 0;
+		unsigned start = millis();
+		while(millis() - start < TIMEOUT_MS) {
+			++loopCount;
+		}
+		return loopCount;
+	}
+
+	unsigned __attribute__((noinline)) micros_loop()
+	{
+		unsigned loopCount = 0;
+		unsigned start = micros();
+		while(micros() - start < (TIMEOUT_MS * 1000)) {
+			++loopCount;
+		}
+		return loopCount;
+	}
+
+	unsigned __attribute__((noinline)) polledTimer_loop()
+	{
+		unsigned loopCount = 0;
+		OneShotFastMs timer(TIMEOUT_MS);
+		while(!timer.expired()) {
+			++loopCount;
+		}
+		return loopCount;
+	}
+
+	void execute() override
+	{
+		Serial.print("How many loop iterations can we achieve in ");
+		Serial.print(TIMEOUT_MS);
+		Serial.println(" ms ?");
+
+		auto print = [](const char* type, uint32_t loopCount) {
+			Serial.print("Using ");
+			Serial.print(type);
+			Serial.print(", managed ");
+			Serial.print(loopCount);
+			Serial.print(" iterations, average loop time = ");
+			using namespace NanoTime;
+			constexpr auto nsTotal = convert<TIMEOUT_MS, Milliseconds, Nanoseconds>();
+			auto nsPerLoop = time(Nanoseconds, muldiv(nsTotal, 1U, loopCount));
+			Serial.print(nsPerLoop.toString());
+			Serial.print(" (");
+			auto cycles = CpuCycleClockNormal::template timeToTicks<Nanoseconds>(uint32_t(nsPerLoop));
+			Serial.print(cycles.toString());
+			Serial.println(" CPU cycles)");
+		};
+
+		print("millis()", millis_loop());
+		print("micros()", micros_loop());
+		print("PolledTimer", polledTimer_loop());
+	}
+};
+
+template <hw_timer_clkdiv_t clkdiv, NanoTime::Unit unit, typename TimeType>
+struct Timer1TestSource : public Timer1Clock<clkdiv> {
+	static TimeType timeToTicks_test1(const TimeType& time)
+	{
+		/*
+		 * Refactorise to eliminate overflow when scaling down and avoid division by
+		 * using pre-defined constant values.
+		 *
+		 * Original code:
+		 *
+		 * 		if(us > 0x35A)
+		 * 			return (us / 4) * (frequency / 250000) + (us % 4) * (frequency / 1000000);
+		 *
+		 * This only works for /16 prescale. It's also un-necessary since the ratio reduces to 5:1,
+		 * i.e. it's just a x5 multiplication.
+		 *
+		 * However, with /256 prescale it's a little tricker. This code is used in the
+		 * `ets_timer_arm_new` function for converting milliseconds into ticks:
+		 *
+		 * 		if(ms > 13743)
+		 * 			return (ms / 4) * (frequency / 250) + (ms % 4) * (frequency / 1000)
+		 *
+		 * In this case the ratio is 625:2 which limits the range to 1'54"31.947, but this
+		 * calculation offers an improvement to 3'49"25.92. It is probably slightly faster
+		 * as well.
+		 *
+		 * Converting from microseconds the ratio is 16:5.
+		 *
+		 * The advantage of muldiv is that it is generic and will work with any ratio.
+		 * In most cases it's just as fast, offers overflow detection and a greater range by
+		 * using 64-bit calculations when necessary.
+		 *
+		 * Ideally all time conversions should be pre-calculated so that time-critical code
+		 * (e.g. within ISRs) operates using the timer tick values.
+		 *
+		 */
+		constexpr uint32_t prediv = 4;
+		constexpr auto unitTicks = NanoTime::unitTicks[unit];
+		constexpr auto frequency = Timer1TestSource::frequency();
+		constexpr uint32_t mul = frequency * unitTicks.den / (unitTicks.num / prediv);
+		constexpr uint32_t div = frequency * unitTicks.den / unitTicks.num;
+
+		if(clkdiv == TIMER_CLKDIV_16) {
+			//		debug_i("prediv = %u, frequency = %u, mul = %u, div = %u", prediv, frequency, mul, div);
+			return (time / prediv) * mul + (time % prediv) * div;
+		} else {
+			using R = std::ratio<frequency * unitTicks.den, unitTicks.num>;
+			return muldiv<R::num, R::den>(time);
+		}
+	}
+
+	TimeType timeToTicks_test2(const TimeType& time)
+	{
+		/*
+		 * Evaluate performance using full muldiv64 all the time.
+		 * In practice, this is un-necessary and the implemented solution is to
+		 * only use it when an overflow would occur.
+		 */
+		return uint64_t(time) * Timer1TestSource::ticksPerUnit(unit); // 116
+		//		return muldiv(time, uint32_t(TPU::num), uint32_t(TPU::den)); // 47
+	}
+};
+
+template <hw_timer_clkdiv_t clkdiv, typename TimeType> void testTimer1()
+{
+	using Clock = Timer1TestSource<clkdiv, NanoTime::Microseconds, uint32_t>;
+	using TimeSource = NanoTime::TimeSource<Clock, NanoTime::Microseconds, TimeType>;
+	Clock timer1;
+
+	//	Timer1TestSource<NanoTime::Microseconds, uint32_t, TIMER_CLKDIV_16> timer1;
+
+	CycleTimes m1("ticks"), m2("ticks1"), m3("ticks2");
+
+	for(unsigned i = 0; i < 5000; ++i) {
+		TimeType time = os_random(); //0x7fffffff;
+		if(sizeof(time) == sizeof(uint64_t)) {
+			//			time = (time << 32) | os_random();
+		}
+
+		time %= TimeSource::maxCalcTime();
+
+		m1.start();
+		volatile TimeType ticks = TimeSource::timeToTicks(time);
+		m1.update();
+
+		m2.start();
+		volatile TimeType ticks1 = timer1.timeToTicks_test1(time);
+		m2.update();
+
+		m3.start();
+		volatile TimeType ticks2 = timer1.timeToTicks_test2(time);
+		m3.update();
+
+		TimeType refticks = round(double(time) * TimeSource::TicksPerUnit::num / TimeSource::TicksPerUnit::den);
+
+		//		uint64_t refticks = timer1.timeToTicksRef(time);
+
+		auto check = [time, refticks](const char* tag, TimeType ticks) {
+			if(refticks != ticks) {
+				int64_t diff = int64_t(ticks) - int64_t(refticks);
+
+				Serial.print("time = ");
+				Serial.print(time);
+				Serial.print(", refticks = ");
+				Serial.print(refticks);
+				Serial.print(", ");
+				Serial.print(tag);
+				Serial.print(" = ");
+				Serial.print(ticks);
+				Serial.print(", diff = ");
+				Serial.println(diff);
+			}
+		};
+
+		check("ticks", ticks);
+		check("ticks1", ticks1);
+		check("ticks2", ticks2);
+
+		//		if(refticks != ticks || refticks != ticks1 || refticks != ticks2) {
+		//			m_printf("time = %u (0x%08x), ticks = %u, ticks1 = %u, ticks2 = %u\r\n", time, time, ticks, ticks1, ticks2);
+		//		}
+	}
+
+	Serial.println(m1);
+	Serial.println(m2);
+	Serial.println(m3);
+}
+
+class TimerCalcTest : public TestGroup
+{
+public:
+	TimerCalcTest() : TestGroup(_F("Timer calculations"))
+	{
+	}
+
+	void execute() override
+	{
+		testTimer1<TIMER_CLKDIV_16, uint32_t>();
+		testTimer1<TIMER_CLKDIV_256, uint32_t>();
+	}
+};
+
+void REGISTER_TEST(clocks)
+{
+	registerGroup<BenchmarkPolledTimer>();
+
+	registerGroup<TimerCalcTest>();
+
+	registerGroup<ClockTestTemplate<Timer1Clock<TIMER_CLKDIV_16>, uint32_t>>();
+	registerGroup<ClockTestTemplate<Timer1Clock<TIMER_CLKDIV_256>, uint32_t>>();
+
+	registerGroup<ClockTestTemplate<Timer2Clock, uint32_t>>();
+
+	registerGroup<ClockTestTemplate<CpuCycleClockNormal, uint32_t>>();
+	registerGroup<ClockTestTemplate<CpuCycleClockFast, uint64_t>>();
+}
diff --git a/tests/HostTests/app/timing.h b/tests/HostTests/app/timing.h
index b831dc9e50..97b46017c8 100644
--- a/tests/HostTests/app/timing.h
+++ b/tests/HostTests/app/timing.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <Services/Profiling/CycleCounter.h>
+#include <Platform/Timers.h>
 #include <Services/Profiling/MinMax.h>
 
 using MinMax32 = Profiling::MinMax<uint32_t>;
@@ -19,9 +19,9 @@ class CycleTimes : public MinMax32
 
 	__forceinline void IRAM_ATTR update()
 	{
-		MinMax32::update(timer.elapsed());
+		MinMax32::update(timer.elapsedTicks());
 	}
 
 private:
-	CycleCounter timer;
+	CpuCycleTimer timer;
 };