error message transmission now happens via uarthandler

StateMachine.cpp

@@ -1,4 +1,5 @@
 #include "StateMachine.hpp"
+#include "UartHandler.hpp"
 
 constexpr uint8_t ERROR_INDICATOR_LED_PIN = 3;
 
@@ -90,7 +91,8 @@ bool StateMachine::raiseError(const String &reason) noexcept
     state = STATE::ERROR;
     lastError = reason;
     digitalWrite(ERROR_INDICATOR_LED_PIN, HIGH);
-    if (Serial) {
-        Serial.println(String("Error!: ") + reason);
+    UartHandler& uart = UartHandler::getInstance();
+    if (uart.isOpen()) {
+        uart.send(String("Error!: ") + reason);
     }
 }

UartHandler.cpp

@@ -14,7 +14,7 @@ UartHandler::~UartHandler()
     }
 }
 
-UartHandler &UartHandler::getInstance()
+UartHandler &UartHandler::getInstance() noexcept
 {
     static UartHandler instance;
     return instance;
@@ -46,8 +46,13 @@ bool UartHandler::isOpen() const noexcept
     return (bool)Serial;
 }
 
-void UartHandler::poll()
+void UartHandler::poll() noexcept
 {
+    if (!isOpen()) {
+        StateMachine::getInstance().raiseError("Serial closed!");
+        return;
+    }
+
     size_t bytesAvail = Serial.available();
     if (bytesAvail) {
         // Consume at max one byte at a time to give consumers a chance to consume packets
@@ -67,7 +72,7 @@ void UartHandler::poll()
     }
 }
 
-void UartHandler::pushPacket()
+void UartHandler::pushPacket() noexcept
 {
     memset(packetRingBuf + packetRingBufWritePos * PACKET_SIZE, 0x00, PACKET_SIZE);
     memcpy(packetRingBuf + packetRingBufWritePos * PACKET_SIZE, inBuf, inBufPos);
@@ -80,7 +85,7 @@ void UartHandler::pushPacket()
     }
 }
 
-bool UartHandler::getNextPacket(char* dest)
+bool UartHandler::getNextPacket(char* dest) noexcept
 {
     if (!numPacketsAvailable) {
         return false;
@@ -92,8 +97,27 @@ bool UartHandler::getNextPacket(char* dest)
     return true;
 }
 
+size_t UartHandler::send(const char *buf, size_t nbytes)
+{
+    if (!isOpen()) {
+        StateMachine::getInstance().raiseError("Serial closed!");
+        return;
+    }
 
-uint8_t UartHandler::getNumAvailablePackets() const
+    return Serial.write(buf, nbytes);
+}
+
+size_t UartHandler::send(const String& str)
+{
+    if (!isOpen()) {
+        StateMachine::getInstance().raiseError("Serial closed!");
+        return;
+    }
+
+    return Serial.write(str.c_str(), str.length());
+}
+
+uint8_t UartHandler::getNumAvailablePackets() const noexcept
 {
     return numPacketsAvailable;
 }

UartHandler.hpp

@@ -7,7 +7,7 @@
 class UartHandler
 {
     public:
-        static UartHandler& getInstance();
+        static UartHandler& getInstance() noexcept;
 
         // Will attempt to initialize the serial port, returns status.
         // May block up to 1000ms.
@@ -15,14 +15,17 @@ class UartHandler
 
         void close();
 
-        void poll();
+        void poll() noexcept;
         // Will write the next available whole line into char* (provide at least 16 bytes!)
         // Returns whether any data was written.
         // If data available is longer than 16 bytes, an error will be raised.
-        bool getNextPacket(char* dest);
+        bool getNextPacket(char* dest) noexcept;
+
+        size_t send(const char* buf, size_t nbytes);
+        size_t send(const String& str);
 
         // Returns how many packets are ready for reading
-        uint8_t getNumAvailablePackets() const;
+        uint8_t getNumAvailablePackets() const noexcept;
 
         bool isOpen() const noexcept;