Merge pull request #26 from bcmi-labs/data-in-callback

Provide message to be written to prefix/suffix callbacks:

Author: aentinger

examples/Threadsafe_Serial_Prefix_Suffix/Threadsafe_Serial_Prefix_Suffix.ino renamed to examples/Threadsafe_Serial_ProtocolWrapping/Threadsafe_Serial_ProtocolWrapping.ino

@@ -52,32 +52,59 @@ void loop()
  * FUNCTION DEFINITION
  **************************************************************************************/
 
-void serial_thread_func()
+String nmea_message_prefix(String const & /* msg */)
 {
-  Serial.begin(9600);
+  return String("$");
+}
 
-  char const * thread_name = rtos::ThisThread::get_name();
-  Serial.prefix([thread_name]() -> String
-                {
-                  char msg[64] = {0};
-                  snprintf(msg, sizeof(msg), "[%05lu] %s ", millis(), thread_name);
-                  return String(msg);
-                });
-  Serial.suffix([]() -> String
+String nmea_message_suffix(String const & prefix, String const & msg)
+{
+  /* NMEA checksum is calculated over the complete message
+   * starting with '$' and ending with the end of the message.
+   */
+  byte checksum = 0;
+  std::for_each(msg.c_str(),
+                msg.c_str() + msg.length(),
+                [&checksum](char const c)
                 {
-                  return String("\r\n");
+                  checksum ^= static_cast<uint8_t>(c);
                 });
+  /* Assemble the footer of the NMEA message. */
+  char footer[16] = {0};
+  snprintf(footer, sizeof(footer), "*%02X\r\n", checksum);
+  return String(footer);
+}
+
+void serial_thread_func()
+{
+  Serial.begin(9600);
+
+  Serial.prefix(nmea_message_prefix);
+  Serial.suffix(nmea_message_suffix);
 
   for(;;)
   {
     /* Sleep between 5 and 500 ms */
     rtos::ThisThread::sleep_for(rtos::Kernel::Clock::duration_u32(random(5,500)));
-    /* Print a unbroken log message including thread name and timestamp as a prefix. */
+
+    /* Print a fake NMEA GPRMC message:
+     * $GPRMC,062101.714,A,5001.869,N,01912.114,E,955535.7,116.2,290520,000.0,W*45\r\n
+     */
     Serial.block();
-    Serial.print("My ");
-    Serial.print("unbroken ");
-    Serial.print("thread-safe ");
-    Serial.print("message!");
+
+    Serial.print("GPRMC,");
+    Serial.print(millis());
+    Serial.print(",A,");
+    Serial.print("5001.869,");
+    Serial.print("N,");
+    Serial.print("01912.114,");
+    Serial.print("E,");
+    Serial.print("955535.7,");
+    Serial.print("116.2,");
+    Serial.print("290520,");
+    Serial.print("000.0,");
+    Serial.print("W");
+
     Serial.unblock();
   }
 }

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);
 
@@ -76,10 +76,13 @@ class SerialDispatcher : public arduino::HardwareSerial
   bool _has_tread_started;
   bool _terminate_thread;
 
+  static int constexpr THREADSAFE_SERIAL_TRANSMIT_RINGBUFFER_SIZE = 128;
+  typedef arduino::RingBufferN<THREADSAFE_SERIAL_TRANSMIT_RINGBUFFER_SIZE> SerialTransmitRingbuffer;
+
   typedef struct
   {
     osThreadId_t thread_id;
-    arduino::RingBuffer tx_buffer;
+    SerialTransmitRingbuffer tx_buffer;
     bool block_tx_buffer;
     mbed::SharedPtr<arduino::RingBuffer> rx_buffer; /* Only when a thread has expressed interested to read from serial a receive ringbuffer is allocated. */
     PrefixInjectorCallbackFunc prefix_func;