Cleaning up/adding missing comments within examples.

examples/Breaks_6/Breaks_6.ino

@@ -1,3 +1,7 @@
+/* This example is in fact expected to break, since we try
+ * to access a thread-private variable.
+ */
+
 #include <Arduino_Threads.h>
 
 void setup()

examples/Threading_Basics/Shared_Counter/Consumer.inot

@@ -6,5 +6,11 @@ void setup()
 
 void loop()
 {
+  /* If a value is available for reading within the internal
+   * queue then the value is removed from the queue and made
+   * available to the calling function. Should no data be
+   * available, then this thread is suspended until new data
+   * is available for reading.
+   */
   Serial.println(counter);
 }

examples/Threading_Basics/Shared_Counter/Producer.inot

@@ -6,6 +6,10 @@ void setup()
 void loop()
 {
   static int i = 0;
+  /* Every 100 ms a new value is inserted into the shared variable
+   * 'counter'. Internally this is stored within a queue in a FIFO
+   * (First-In/First-Out) manner.
+   */
   counter = i;
   i++;
   delay(100);

examples/Threading_Basics/Shared_Counter/SharedVariables.h

@@ -1 +1,2 @@
+/* Define a shared variable named 'counter' of type 'int'. */
 SHARED(counter, int);

examples/Threading_Basics/Shared_Counter/Shared_Counter.ino

@@ -1,3 +1,8 @@
+/* This example demonstrates data exchange between
+ * threads using a shared counter variable defined
+ * within 'SharedVariables.h'.
+ */
+
 void setup()
 {
   Producer.start();

examples/Threading_Basics/Source_Sink_Counter/Consumer.inot

@@ -1,3 +1,4 @@
+/* Define a data sink named 'counter' of type 'int' with a internal queue size of 10. */
 SINK(counter, int, 10);
 
 void setup()

examples/Threading_Basics/Source_Sink_Counter/Producer.inot

@@ -1,3 +1,4 @@
+/* Define a data source named 'counter' of type 'int'. */
 SOURCE(counter, int);
 
 void setup()

examples/Threading_Basics/Source_Sink_Counter/Source_Sink_Counter.ino

@@ -1,7 +1,6 @@
-/*
- * This examples demonstrates the SOURCE/SINK abstraction.
- * Each thread may have any number of SOURCES and SINKS that can be connected
- * together using the "connectTo" method.
+/* This examples demonstrates the SOURCE/SINK abstraction. Each thread
+ * may have any number of SOURCES and SINKS that can be connected
+ * together using the 'connectTo' method.
  */
 
 void setup()

examples/Threading_Basics/Source_Sink_LED/Sink_Thread.inot

@@ -1,8 +1,4 @@
-
-/*
- * An 'bool' SINK with a size of '0'. This kind of SINK has no buffer so the reading thread
- * will block until the writing thread has written something, or vice versa.
- */
+/* Define a data sink named 'led' of type 'bool' with a internal queue size of 1. */
 SINK(led, bool);
 
 void setup()
@@ -12,9 +8,9 @@ void setup()
 
 void loop()
 {
-  /* Read a 'bool' from the SINK and discard it. Since there is basically no delay in the loop
-   * this call will surely block until something comes from the connected SOURCE. In this case
-   * the pace is dictated by the SOURCE that sends data every 100 ms.
+  /* Read a 'bool' value from the SINK and discard it. Since there is no delay in the loop
+   * this call will block until new data is inserted from the connected SOURCE. This means
+   * that the pace is dictated by the SOURCE that sends data every 100 ms.
    */
   digitalWrite(LED_BUILTIN, led);
 }

examples/Threading_Basics/Source_Sink_LED/Source_Sink_LED.ino

@@ -1,7 +1,6 @@
-/*
- * This examples demonstrates the SOURCE/SINK abstraction.
- * Each thread may have any number of SOURCES and SINKS that can be connected
- * together using the "connectTo" method.
+/* This examples demonstrates the SOURCE/SINK abstraction. Each thread
+ * may have any number of SOURCES and SINKS that can be connected
+ * together using the 'connectTo' method.
  */
 
 void setup()

examples/Threading_Basics/Source_Sink_LED/Source_Thread.inot

@@ -1,4 +1,4 @@
-/* The output SOURCE, it sends 'bool' values. */
+/* Define a data source named 'led' of type 'bool'. */
 SOURCE(led, bool);
 
 void setup()

examples/Threadsafe_IO/SPI/SPI.ino

@@ -1,3 +1,9 @@
+/* This example demonstrates how multiple threads can communicate
+ * with a single SPI client device using the BusDevice abstraction
+ * for SPI. In a similar way multiple threads can interface
+ * with different client devices on the same SPI bus.
+ */
+
 /**************************************************************************************
  * INCLUDE
  **************************************************************************************/

examples/Threadsafe_IO/SPI_BusIO/SPI_BusIO.ino

@@ -1,3 +1,12 @@
+/* This example demonstrates how multiple threads can communicate
+ * with a single SPI client device using the BusDevice abstraction
+ * for SPI. In a similar way multiple threads can interface
+ * with different client devices on the same SPI bus.
+ *
+ * This example uses Adafruit_BusIO style read(), write(),
+ * write_then_read() APIs.
+ */
+
 /**************************************************************************************
  * INCLUDE
  **************************************************************************************/

examples/Threadsafe_IO/Serial_GlobalPrefixSuffix/Serial_GlobalPrefixSuffix.ino

@@ -1,3 +1,10 @@
+/* This example demonstrates how every Serial message can be prefixed
+ * as well as suffixed by a user-configurable message. In this example
+ * this functionality is used for appending the current timestamp and
+ * prepending a line feed. Other uses might be to prepend the thread
+ * from which a given serial message is originating.
+ */
+
 /**************************************************************************************
  * INCLUDE
  **************************************************************************************/

examples/Threadsafe_IO/Serial_ProtocolWrapping/Serial_ProtocolWrapping.ino

@@ -1,3 +1,10 @@
+/* This example demonstrates how every Serial message can be prefixed
+ * as well as suffixed by a user-configurable message. In this example
+ * this functionality is used for prepending the right header for a
+ * pseudo NMEA-encoded (think GPS) message as well as for calculating
+ * and appending the checksum at the end.
+ */
+
 /**************************************************************************************
  * INCLUDE
  **************************************************************************************/

examples/Threadsafe_IO/Serial_Reader/Serial_Reader.ino

@@ -1,3 +1,9 @@
+/* This example demonstrates how multiple threads can subscribe to
+ * reading from the same physical Serial interface. Incoming data
+ * is copied into per-thread receive buffers so that no thread
+ * can "steal" data from another thread by reading it first.
+ */
+
 /**************************************************************************************
  * INCLUDE
  **************************************************************************************/

examples/Threadsafe_IO/Serial_Writer/Serial_Writer.ino

@@ -1,3 +1,8 @@
+/* This example demonstrates how multiple threads can write to
+ * the same physical Serial interface without interfering with
+ * one another.
+ */
+
 /**************************************************************************************
  * INCLUDE
  **************************************************************************************/

examples/Threadsafe_IO/Wire/Wire.ino

@@ -1,3 +1,9 @@
+/* This example demonstrates how multiple threads can communicate
+ * with a single Wire client device using the BusDevice abstraction
+ * for Wire. In a similar way multiple threads can interface
+ * with different client devices on the same Wire bus.
+ */
+
 /**************************************************************************************
  * INCLUDE
  **************************************************************************************/

examples/Threadsafe_IO/Wire_BusIO/Wire_BusIO.ino

@@ -1,4 +1,13 @@
- /**************************************************************************************
+/* This example demonstrates how multiple threads can communicate
+ * with a single Wire client device using the BusDevice abstraction
+ * for Wire. In a similar way multiple threads can interface
+ * with different client devices on the same Wire bus.
+ *
+ * This example uses Adafruit_BusIO style read(), write(),
+ * write_then_read() APIs.
+ */
+
+/**************************************************************************************
  * INCLUDE
  **************************************************************************************/