Revert "Wrapping chrono for arduino compatibility"

paveldn · paveldn · commit 36095daf644d · 2026-02-22T13:36:53.000+01:00
This reverts commit d94191c.
diff --git a/README.rst b/README.rst
@@ -20,6 +20,15 @@ This library is compatible with both **PlatformIO** and **Arduino** toolchains.
 
 No migration is required for existing PlatformIO projects.
 
+Documentation
+-------------
+
+- `Protocol reference <doc/protocol_reference.rst>`_
+- `PlatformIO usage example <doc/usage_platformio.rst>`_
+- `Arduino usage example <doc/usage_arduino.rst>`_
+- `hOn simulator <doc/hon_simulator.rst>`_
+- `SmartAir2 simulator <doc/smartair2_simulator.rst>`_
+
 Protocol description
 --------------------
 
@@ -64,12 +73,3 @@ Where:
  * **Frame data** - n byte, data of the frame, can be empty. Sometimes first 2 bytes of data are used as a subcommand. Max size 246
  * **Checksum** - 1 byte, the least significant byte of the sum of all bytes of the frame except separator bytes, CRC, and checksum itself.
  * **CRC** - 2 bytes, CRC 16 of all bytes of the frame except separator bytes, checksum byte, and CRC itself (`CRC-16/ARC <https://crccalc.com/?crc=&method=CRC-16/ARC&datatype=1&outtype=0>`_ algorithm used). CRC is available only if the frame flags byte indicates it.
-
-Documentation
--------------
-
-- `Protocol reference <doc/protocol_reference.rst>`_
-- `PlatformIO usage example <doc/usage_platformio.rst>`_
-- `Arduino usage example <doc/usage_arduino.rst>`_
-- `hOn simulator <doc/hon_simulator.rst>`_
-- `SmartAir2 simulator <doc/smartair2_simulator.rst>`_
diff --git a/src/protocol/haier_protocol.cpp b/src/protocol/haier_protocol.cpp
@@ -1,17 +1,17 @@
 #include <cstring>
+#include <chrono>
 #include <memory>
-#include "utils/simple_time.h"
 #include "protocol/haier_protocol.h"
 
 namespace haier_protocol
 {
 
 constexpr uint8_t MAX_PACKET_RETRIES = 9;
-constexpr simple_time::ms_t DEFAULT_ANSWER_TIMEOUT = 200;
-constexpr simple_time::ms_t DEFAULT_COOLDOWN_INTERVAL = 400;
+constexpr std::chrono::milliseconds DEFAULT_ANSWER_TIMEOUT = std::chrono::milliseconds(200);
+constexpr std::chrono::milliseconds DEFAULT_COOLDOWN_INTERVAL = std::chrono::milliseconds(400);
 
 #if HAIER_LOG_LEVEL > 3
-  static simple_time::ms_t last_message_sent_;
+  static std::chrono::steady_clock::time_point last_message_sent_;
 #endif
 
 ProtocolHandler::ProtocolHandler(ProtocolStream &stream) noexcept : ProtocolHandler(stream, MAX_FRAME_SIZE + 10)
@@ -34,14 +34,14 @@ ProtocolHandler::ProtocolHandler(ProtocolStream& stream, size_t buffer_size) noe
   answer_timeout_interval_(DEFAULT_ANSWER_TIMEOUT),
   cooldown_interval_(DEFAULT_COOLDOWN_INTERVAL)
 {
-  this->cooldown_time_point_ = simple_time::zero_ms();
+  this->cooldown_time_point_ = std::chrono::steady_clock::time_point();
 }
 
 void ProtocolHandler::loop()
 {
   this->transport_.read_data();
   this->transport_.process_data();
-  simple_time::ms_t now = simple_time::now_ms();
+  std::chrono::steady_clock::time_point now = std::chrono::steady_clock::now();
   switch (this->state_)
   {
   case ProtocolState::IDLE:
@@ -135,7 +135,7 @@ void ProtocolHandler::loop()
     if (this->transport_.available() > 0)
     {
 #if HAIER_LOG_LEVEL > 3
-      HAIER_LOGD("Answer delay %dms", (int)(now - last_message_sent_));
+      HAIER_LOGD("Answer delay %dms", std::chrono::duration_cast<std::chrono::milliseconds>(now - last_message_sent_));
 #endif
       TimestampedFrame frame;
       this->transport_.pop(frame);
@@ -175,7 +175,7 @@ bool ProtocolHandler::write_message_(const HaierMessage &message, bool use_crc)
   {
     HAIER_LOGE("Error sending message: %02X", frame_type);
   }
-  simple_time::ms_t now = simple_time::now_ms();
+  std::chrono::steady_clock::time_point now = std::chrono::steady_clock::now();
 #if HAIER_LOG_LEVEL > 3
   last_message_sent_ = now;
 #endif
@@ -185,32 +185,32 @@ bool ProtocolHandler::write_message_(const HaierMessage &message, bool use_crc)
 
 void ProtocolHandler::set_answer_timeout(long long answer_timeout_miliseconds)
 {
-  this->set_answer_timeout(simple_time::ms_t(answer_timeout_miliseconds));
+  this->set_answer_timeout(std::chrono::milliseconds(answer_timeout_miliseconds));
 }
 
-void ProtocolHandler::set_answer_timeout(simple_time::ms_t answer_timeout)
+void ProtocolHandler::set_answer_timeout(std::chrono::milliseconds answer_timeout)
 {
   this->answer_timeout_interval_ = answer_timeout;
 }
 
 void ProtocolHandler::set_cooldown_interval(long long answer_timeout_miliseconds)
 {
-  this->set_cooldown_interval(simple_time::ms_t(answer_timeout_miliseconds));
+  this->set_cooldown_interval(std::chrono::milliseconds(answer_timeout_miliseconds));
 }
 
-void ProtocolHandler::set_cooldown_interval(simple_time::ms_t answer_timeout)
+void ProtocolHandler::set_cooldown_interval(std::chrono::milliseconds answer_timeout)
 {
   this->cooldown_interval_ = answer_timeout;
 }
 
-void ProtocolHandler::send_message(const HaierMessage& message, bool use_crc, uint8_t num_repeats, simple_time::ms_t interval)
+void ProtocolHandler::send_message(const HaierMessage& message, bool use_crc, uint8_t num_repeats, std::chrono::milliseconds interval)
 {
   this->outgoing_messages_.push({ message, use_crc, false, std::min(num_repeats, MAX_PACKET_RETRIES) + 1, interval });
 }
 
 void ProtocolHandler::send_message_without_answer(const HaierMessage& message, bool use_crc)
 {
-  this->outgoing_messages_.push({ message, use_crc, true, 1, simple_time::zero_ms() });
+  this->outgoing_messages_.push({ message, use_crc, true, 1, std::chrono::milliseconds::zero() });
 }
 
 void ProtocolHandler::send_answer(const HaierMessage &answer)
diff --git a/src/protocol/haier_protocol.h b/src/protocol/haier_protocol.h
@@ -3,7 +3,7 @@
 
 #include <stdint.h>
 #include <stddef.h>
-#include "utils/simple_time.h"
+#include <chrono>
 #include <functional>
 #include <map>
 #include <queue>
@@ -60,10 +60,10 @@ class ProtocolHandler
 	size_t get_outgoing_queue_size() const noexcept {return this->outgoing_messages_.size(); };
 	bool is_waiting_for_answer() const {return (this->state_ == ProtocolState::WAITING_FOR_ANSWER); };
 	void set_answer_timeout(long long answer_timeout_miliseconds);
-	void set_answer_timeout(simple_time::ms_t answer_timeout);
+	void set_answer_timeout(std::chrono::milliseconds answer_timeout);
 	void set_cooldown_interval(long long answer_timeout_miliseconds);
-	void set_cooldown_interval(simple_time::ms_t answer_timeout);
-	void send_message(const HaierMessage& message, bool use_crc, uint8_t num_retries = 0, simple_time::ms_t interval = simple_time::zero_ms());
+	void set_cooldown_interval(std::chrono::milliseconds answer_timeout);
+	void send_message(const HaierMessage& message, bool use_crc, uint8_t num_retries = 0, std::chrono::milliseconds interval = std::chrono::milliseconds::zero());
 	void send_message_without_answer(const HaierMessage& message, bool use_crc);
 	void send_answer(const HaierMessage& answer);
 	void send_answer(const HaierMessage& answer, bool use_crc);
@@ -92,7 +92,7 @@ class ProtocolHandler
 		bool use_crc;
 		bool no_answer;
 		int number_of_retries;
-		simple_time::ms_t retry_interval;
+		std::chrono::milliseconds retry_interval;
 	};
 	using OutgoingQueue = std::queue<OutgoingQueueItem>;
 	TransportLevelHandler                   transport_;
@@ -108,11 +108,11 @@ class ProtocolHandler
 	bool                                    incoming_message_crc_status_;
 	bool                                    answer_sent_;
 	FrameType                               last_message_type_;
-	simple_time::ms_t               answer_timeout_interval_;
-	simple_time::ms_t               cooldown_interval_;
-	simple_time::ms_t               cooldown_time_point_;
-	simple_time::ms_t               answer_time_point_;
-	simple_time::ms_t               retry_time_point_;
+	std::chrono::milliseconds               answer_timeout_interval_;
+	std::chrono::milliseconds               cooldown_interval_;
+	std::chrono::steady_clock::time_point   cooldown_time_point_;
+	std::chrono::steady_clock::time_point   answer_time_point_;
+	std::chrono::steady_clock::time_point   retry_time_point_;
 };
 
 
diff --git a/src/transport/protocol_transport.cpp b/src/transport/protocol_transport.cpp
@@ -6,7 +6,7 @@
 namespace haier_protocol
 {
 
-constexpr simple_time::ms_t FRAME_TIMEOUT_MS = 300;
+constexpr std::chrono::duration<long long, std::milli> FRAME_TIMEOUT(300);
 
 TransportLevelHandler::TransportLevelHandler(ProtocolStream &stream, size_t buffer_size) noexcept : stream_(stream),
   buffer_(buffer_size),
@@ -81,8 +81,8 @@ void TransportLevelHandler::process_data()
 {
   if (this->current_frame_.get_status() > FrameStatus::FRAME_EMPTY)
   {
-    simple_time::ms_t now = simple_time::now_ms();
-    if ((now - this->frame_start_) > FRAME_TIMEOUT_MS)
+    std::chrono::steady_clock::time_point now = std::chrono::steady_clock::now();
+    if (std::chrono::duration_cast<std::chrono::milliseconds>(now - this->frame_start_) > FRAME_TIMEOUT)
     {
       // Timeout
       HAIER_LOGW("Frame timeout!");
@@ -112,7 +112,6 @@ void TransportLevelHandler::process_data()
           if (this->pos_ - bytes_to_drop == FRAME_SEPARATORS_COUNT)
           {
             this->frame_start_found_ = true;
-            this->frame_start_ = simple_time::now_ms();
             if (bytes_to_drop > 0)
             {
               // Dropping garbage
diff --git a/src/transport/protocol_transport.h b/src/transport/protocol_transport.h
@@ -2,7 +2,7 @@
 #define PROTOCOL_TRANSPORT_H
 #include <stdint.h>
 #include <cstddef>
-#include "utils/simple_time.h"
+#include <chrono>
 #include <queue>
 #include "utils/haier_log.h"
 #include "utils/circular_buffer.h"
@@ -15,7 +15,7 @@ namespace haier_protocol
 struct TimestampedFrame
 {
 	HaierFrame frame;
-	simple_time::ms_t timestamp;
+	std::chrono::steady_clock::time_point timestamp;
 };
 
 class TransportLevelHandler
@@ -42,7 +42,7 @@ class TransportLevelHandler
 	size_t                          sep_count_;
 	bool                            frame_start_found_;
 	HaierFrame                      current_frame_;
-	simple_time::ms_t   frame_start_;
+	std::chrono::steady_clock::time_point   frame_start_;
 	std::queue<TimestampedFrame>    incoming_queue_;
 };
 
diff --git a/src/utils/simple_time.h b/src/utils/simple_time.h
diff --git a/test/ci/arduino_example/arduino_example.ino b/test/ci/arduino_example/arduino_example.ino
@@ -1,59 +1,7 @@
-#include <Arduino.h>
 #include <HaierProtocol.h>
 
-using namespace haier_protocol;
-
-class UartProtocolStream : public ProtocolStream {
-public:
-	explicit UartProtocolStream(Stream& serial) : serial_(serial) {}
-
-	size_t available() noexcept override {
-		return static_cast<size_t>(serial_.available());
-	}
-
-	size_t read_array(uint8_t* data, size_t len) noexcept override {
-		size_t read_count = 0;
-		while (read_count < len && serial_.available() > 0) {
-			int value = serial_.read();
-			if (value < 0) {
-				break;
-			}
-			data[read_count++] = static_cast<uint8_t>(value);
-		}
-		return read_count;
-	}
-
-	void write_array(const uint8_t* data, size_t len) noexcept override {
-		serial_.write(data, len);
-	}
-
-private:
-	Stream& serial_;
-};
-
-UartProtocolStream proto_stream(Serial1);
-ProtocolHandler protocol(proto_stream);
-
-HandlerError on_control(FrameType type, const uint8_t* data, size_t size) {
-	(void)data;
-	(void)size;
-
-	if (type == FrameType::CONTROL) {
-		HaierMessage confirm(FrameType::CONFIRM);
-		protocol.send_answer(confirm);
-		return HandlerError::HANDLER_OK;
-	}
-	protocol.no_answer();
-	return HandlerError::UNSUPPORTED_MESSAGE;
-}
-
 void setup() {
-	Serial.begin(115200);
-	Serial1.begin(9600);
-
-	protocol.set_message_handler(FrameType::CONTROL, on_control);
 }
 
 void loop() {
-	protocol.loop();
 }
diff --git a/test/ci/platformio_example/src/main.cpp b/test/ci/platformio_example/src/main.cpp
@@ -1,69 +1,9 @@
 #include <Arduino.h>
 #include <HaierProtocol.h>
 
-using namespace haier_protocol;
-
-class UartProtocolStream : public ProtocolStream {
-public:
-  explicit UartProtocolStream(HardwareSerial& serial) : serial_(serial) {}
-
-  size_t available() noexcept override {
-    return static_cast<size_t>(serial_.available());
-  }
-
-  size_t read_array(uint8_t* data, size_t len) noexcept override {
-    size_t read_count = 0;
-    while (read_count < len && serial_.available() > 0) {
-      int value = serial_.read();
-      if (value < 0) {
-        break;
-      }
-      data[read_count++] = static_cast<uint8_t>(value);
-    }
-    return read_count;
-  }
-
-  void write_array(const uint8_t* data, size_t len) noexcept override {
-    serial_.write(data, len);
-    serial_.flush();
-  }
-
-private:
-  HardwareSerial& serial_;
-};
-
-UartProtocolStream proto_stream(Serial2);
-ProtocolHandler protocol(proto_stream);
-
-HandlerError on_message(FrameType type, const uint8_t* data, size_t size) {
-  if (type == FrameType::CONTROL) {
-    HaierMessage answer(FrameType::CONFIRM);
-    protocol.send_answer(answer);
-    return HandlerError::HANDLER_OK;
-  }
-  protocol.no_answer();
-  return HandlerError::UNSUPPORTED_MESSAGE;
-}
-
 void setup() {
-  Serial.begin(115200);
-  Serial2.begin(9600, SERIAL_8N1, 16, 17);
-
-  protocol.set_message_handler(FrameType::CONTROL, on_message);
-  protocol.set_answer_timeout(200);
-  protocol.set_cooldown_interval(400);
+  // minimal build-only example
 }
 
 void loop() {
-  protocol.loop();
-
-  // Example outgoing request every 5 seconds
-  static uint32_t last_send = 0;
-  uint32_t now = millis();
-  if (now - last_send > 5000) {
-    uint8_t payload[] = {0x01, 0x02};
-      HaierMessage msg(FrameType::CONTROL, payload, sizeof(payload));
-      protocol.send_message(msg, true, 1, 300);
-    last_send = now;
-  }
 }

Original file line number	Diff line number	Diff line change
`@@ -1,17 +1,17 @@`
`1`	`1`	`#include <cstring>`
	`2`	`+#include <chrono>`
`2`	`3`	`#include <memory>`
`3`		`-#include "utils/simple_time.h"`
`4`	`4`	`#include "protocol/haier_protocol.h"`
`5`	`5`
`6`	`6`	`namespace haier_protocol`
`7`	`7`	`{`
`8`	`8`
`9`	`9`	`constexpr uint8_t MAX_PACKET_RETRIES = 9;`
`10`		`-constexpr simple_time::ms_t DEFAULT_ANSWER_TIMEOUT = 200;`
`11`		`-constexpr simple_time::ms_t DEFAULT_COOLDOWN_INTERVAL = 400;`
	`10`	`+constexpr std::chrono::milliseconds DEFAULT_ANSWER_TIMEOUT = std::chrono::milliseconds(200);`
	`11`	`+constexpr std::chrono::milliseconds DEFAULT_COOLDOWN_INTERVAL = std::chrono::milliseconds(400);`
`12`	`12`
`13`	`13`	`#if HAIER_LOG_LEVEL > 3`
`14`		`- static simple_time::ms_t last_message_sent_;`
	`14`	`+ static std::chrono::steady_clock::time_point last_message_sent_;`
`15`	`15`	`#endif`
`16`	`16`
`17`	`17`	`ProtocolHandler::ProtocolHandler(ProtocolStream &stream) noexcept : ProtocolHandler(stream, MAX_FRAME_SIZE + 10)`
`@@ -34,14 +34,14 @@ ProtocolHandler::ProtocolHandler(ProtocolStream& stream, size_t buffer_size) noe`
`34`	`34`	`answer_timeout_interval_(DEFAULT_ANSWER_TIMEOUT),`
`35`	`35`	`cooldown_interval_(DEFAULT_COOLDOWN_INTERVAL)`
`36`	`36`	`{`
`37`		`- this->cooldown_time_point_ = simple_time::zero_ms();`
	`37`	`+ this->cooldown_time_point_ = std::chrono::steady_clock::time_point();`
`38`	`38`	`}`
`39`	`39`
`40`	`40`	`void ProtocolHandler::loop()`
`41`	`41`	`{`
`42`	`42`	`this->transport_.read_data();`
`43`	`43`	`this->transport_.process_data();`
`44`		`- simple_time::ms_t now = simple_time::now_ms();`
	`44`	`+ std::chrono::steady_clock::time_point now = std::chrono::steady_clock::now();`
`45`	`45`	`switch (this->state_)`
`46`	`46`	`{`
`47`	`47`	`case ProtocolState::IDLE:`
`@@ -135,7 +135,7 @@ void ProtocolHandler::loop()`
`135`	`135`	`if (this->transport_.available() > 0)`
`136`	`136`	`{`
`137`	`137`	`#if HAIER_LOG_LEVEL > 3`
`138`		`- HAIER_LOGD("Answer delay %dms", (int)(now - last_message_sent_));`
	`138`	`+ HAIER_LOGD("Answer delay %dms", std::chrono::duration_cast<std::chrono::milliseconds>(now - last_message_sent_));`
`139`	`139`	`#endif`
`140`	`140`	`TimestampedFrame frame;`
`141`	`141`	`this->transport_.pop(frame);`
`@@ -175,7 +175,7 @@ bool ProtocolHandler::write_message_(const HaierMessage &message, bool use_crc)`
`175`	`175`	`{`
`176`	`176`	`HAIER_LOGE("Error sending message: %02X", frame_type);`
`177`	`177`	`}`
`178`		`- simple_time::ms_t now = simple_time::now_ms();`
	`178`	`+ std::chrono::steady_clock::time_point now = std::chrono::steady_clock::now();`
`179`	`179`	`#if HAIER_LOG_LEVEL > 3`
`180`	`180`	`last_message_sent_ = now;`
`181`	`181`	`#endif`
`@@ -185,32 +185,32 @@ bool ProtocolHandler::write_message_(const HaierMessage &message, bool use_crc)`
`185`	`185`
`186`	`186`	`void ProtocolHandler::set_answer_timeout(long long answer_timeout_miliseconds)`
`187`	`187`	`{`
`188`		`- this->set_answer_timeout(simple_time::ms_t(answer_timeout_miliseconds));`
	`188`	`+ this->set_answer_timeout(std::chrono::milliseconds(answer_timeout_miliseconds));`
`189`	`189`	`}`
`190`	`190`
`191`		`-void ProtocolHandler::set_answer_timeout(simple_time::ms_t answer_timeout)`
	`191`	`+void ProtocolHandler::set_answer_timeout(std::chrono::milliseconds answer_timeout)`
`192`	`192`	`{`
`193`	`193`	`this->answer_timeout_interval_ = answer_timeout;`
`194`	`194`	`}`
`195`	`195`
`196`	`196`	`void ProtocolHandler::set_cooldown_interval(long long answer_timeout_miliseconds)`
`197`	`197`	`{`
`198`		`- this->set_cooldown_interval(simple_time::ms_t(answer_timeout_miliseconds));`
	`198`	`+ this->set_cooldown_interval(std::chrono::milliseconds(answer_timeout_miliseconds));`
`199`	`199`	`}`
`200`	`200`
`201`		`-void ProtocolHandler::set_cooldown_interval(simple_time::ms_t answer_timeout)`
	`201`	`+void ProtocolHandler::set_cooldown_interval(std::chrono::milliseconds answer_timeout)`
`202`	`202`	`{`
`203`	`203`	`this->cooldown_interval_ = answer_timeout;`
`204`	`204`	`}`
`205`	`205`
`206`		`-void ProtocolHandler::send_message(const HaierMessage& message, bool use_crc, uint8_t num_repeats, simple_time::ms_t interval)`
	`206`	`+void ProtocolHandler::send_message(const HaierMessage& message, bool use_crc, uint8_t num_repeats, std::chrono::milliseconds interval)`
`207`	`207`	`{`
`208`	`208`	`this->outgoing_messages_.push({ message, use_crc, false, std::min(num_repeats, MAX_PACKET_RETRIES) + 1, interval });`
`209`	`209`	`}`
`210`	`210`
`211`	`211`	`void ProtocolHandler::send_message_without_answer(const HaierMessage& message, bool use_crc)`
`212`	`212`	`{`
`213`		`- this->outgoing_messages_.push({ message, use_crc, true, 1, simple_time::zero_ms() });`
	`213`	`+ this->outgoing_messages_.push({ message, use_crc, true, 1, std::chrono::milliseconds::zero() });`
`214`	`214`	`}`
`215`	`215`
`216`	`216`	`void ProtocolHandler::send_answer(const HaierMessage &answer)`
Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,7 @@`
`6`	`6`	`namespace haier_protocol`
`7`	`7`	`{`
`8`	`8`
`9`		`-constexpr simple_time::ms_t FRAME_TIMEOUT_MS = 300;`
	`9`	`+constexpr std::chrono::duration<long long, std::milli> FRAME_TIMEOUT(300);`
`10`	`10`
`11`	`11`	`TransportLevelHandler::TransportLevelHandler(ProtocolStream &stream, size_t buffer_size) noexcept : stream_(stream),`
`12`	`12`	`buffer_(buffer_size),`
`@@ -81,8 +81,8 @@ void TransportLevelHandler::process_data()`
`81`	`81`	`{`
`82`	`82`	`if (this->current_frame_.get_status() > FrameStatus::FRAME_EMPTY)`
`83`	`83`	`{`
`84`		`- simple_time::ms_t now = simple_time::now_ms();`
`85`		`- if ((now - this->frame_start_) > FRAME_TIMEOUT_MS)`
	`84`	`+ std::chrono::steady_clock::time_point now = std::chrono::steady_clock::now();`
	`85`	`+ if (std::chrono::duration_cast<std::chrono::milliseconds>(now - this->frame_start_) > FRAME_TIMEOUT)`
`86`	`86`	`{`
`87`	`87`	`// Timeout`
`88`	`88`	`HAIER_LOGW("Frame timeout!");`
`@@ -112,7 +112,6 @@ void TransportLevelHandler::process_data()`
`112`	`112`	`if (this->pos_ - bytes_to_drop == FRAME_SEPARATORS_COUNT)`
`113`	`113`	`{`
`114`	`114`	`this->frame_start_found_ = true;`
`115`		`- this->frame_start_ = simple_time::now_ms();`
`116`	`115`	`if (bytes_to_drop > 0)`
`117`	`116`	`{`
`118`	`117`	`// Dropping garbage`