Provide message to be written to prefix/suffix callbacks:

* Provide message to prefix function.
* Provide prefix and message to suffix function.

Author: aentinger

examples/Threadsafe_Serial_Prefix_Suffix/Threadsafe_Serial_Prefix_Suffix.ino

@@ -57,13 +57,13 @@ void serial_thread_func()
   Serial.begin(9600);
 
   char const * thread_name = rtos::ThisThread::get_name();
-  Serial.prefix([thread_name]() -> String
+  Serial.prefix([thread_name](String const & /* msg */) -> String
                 {
                   char msg[64] = {0};
                   snprintf(msg, sizeof(msg), "[%05lu] %s ", millis(), thread_name);
                   return String(msg);
                 });
-  Serial.suffix([]() -> String
+  Serial.suffix([](String const & /* prefix */, String const & /* msg */) -> String
                 {
                   return String("\r\n");
                 });

src/serial/SerialDispatcher.cpp

@@ -236,36 +236,39 @@ void SerialDispatcher::threadFunc()
                       if (!d.tx_buffer.available())
                         return;
 
+                      /* Retrieve all data stored in the transmit ringbuffer
+                       * and store it into a String for usage by both suffix
+                       * prefix callback functions.
+                       */
+                      String msg;
+                      while(d.tx_buffer.available())
+                        msg += static_cast<char>(d.tx_buffer.read_char());
+
                       /* The prefix callback function allows the
                        * user to insert a custom message before
                        * a new message is written to the serial
                        * driver. This is useful e.g. for wrapping
                        * protocol (e.g. the 'AT' protocol) or providing
                        * a timestamp, a log level, ...
                        */
+                      String prefix;
                       if (d.prefix_func)
-                      {
-                        String const prefix_str = d.prefix_func();
-                        _serial.write(prefix_str.c_str());
-                      }
-
-                      /* Now it's time to actually write the message
-                       * conveyed by the user via Serial.print/println.
-                       */
-                      while(d.tx_buffer.available())
-                      {
-                        _serial.write(d.tx_buffer.read_char());
-                      }
+                        prefix = d.prefix_func(msg);
 
                       /* Similar to the prefix function this callback
                        * allows the user to specify a specific message
                        * to be appended to each message, e.g. '\r\n'.
                        */
+                      String suffix;
                       if (d.suffix_func)
-                      {
-                        String const suffix_str = d.suffix_func();
-                        _serial.write(suffix_str.c_str());
-                      }
+                        suffix = d.suffix_func(prefix, msg);
+
+                      /* Now it's time to actually write the message
+                       * conveyed by the user via Serial.print/println.
+                       */
+                      _serial.write(prefix.c_str());
+                      _serial.write(msg.c_str());
+                      _serial.write(suffix.c_str());
                     });
   }
 }

src/serial/SerialDispatcher.h

@@ -59,8 +59,8 @@ class SerialDispatcher : public arduino::HardwareSerial
   void block();
   void unblock();
 
-  typedef std::function<String(void)> PrefixInjectorCallbackFunc;
-  typedef PrefixInjectorCallbackFunc  SuffixInjectorCallbackFunc;
+  typedef std::function<String(String const &)> PrefixInjectorCallbackFunc;
+  typedef std::function<String(String const &, String const &)>  SuffixInjectorCallbackFunc;
   void prefix(PrefixInjectorCallbackFunc func);
   void suffix(SuffixInjectorCallbackFunc func);