- updated _sidebar accordingly
- also commented out the "events with payload" section in the events cheatsheet

EventSniffer.md

+An **EventSniffer** is a class that can subscribe to a list of topics and when an event is received on one of those topics automatically calls a callback function.  
+In fact in its constructor we have to provide a reference to the [EventBroker](EventBroker), the list (vector) of topics and the callback.  
+  
+The callback type is defined as:
+```cpp
+using OnEventReceived = function<void(uint8_t, uint8_t)>;
+```
+where the two parameters are the event ID and the topic on which that event has been received.  
+  
+For each one of the specified topics, a **Sniffer** is created.  
+A Sniffer is a very simple class that extends [EventHandlerBase](EventHandler): when created it subscribes to the given topic and when an event is posted on that topic (i.e. its *postEvent(const Event& ev)* method is called) it calls the callback function (passing it the event ID and the topic).  
+  
+You can find the complete implementation of the EventSniffer in `src/shared/events/utils/EventSniffer.h`.
+
+## Example
+This example shows the usage of the EventSniffer, in the simple case in which it is subscribed to a single topic.   
+  
+First of all define the possible events and topics:
+```cpp
+#include <Common.h>
+#include "events/EventBroker.h"
+#include "events/utils/EventSniffer.h"
+
+using namespace miosix;
+
+enum ExampleEvents : uint8_t
+{
+    EV_1 = EV_FIRST_SIGNAL,
+    EV_2
+};
+
+enum ExampleTopics : uint8_t
+{
+    TOPIC_1 = 0,
+    TOPIC_2 = 1
+};
+```
+Let's create also a callback function that reacts to the received events:
+```cpp
+void callback(uint8_t ev_sig, uint8_t topic)
+{
+    if (ev_sig == EV_1)
+    {
+        TRACE("Callback : EV_1 on topic %d \n", topic);
+    }
+    else if (ev_sig == EV_2) 
+    {
+        TRACE("Callback : EV_2 on topic %d \n", topic);
+    }
+}
+```
+
+In the main we can create a vector of topics (only `TOPIC_1` in this case) and pass it to the EventSniffer together with a reference to the callback function:
+```cpp
+int main()
+{
+    vector<uint8_t> topics{TOPIC_1};
+    EventSniffer sniffer(*sEventBroker, topics, &callback);
+
+    // the first two events will trigger the callback
+    sEventBroker->post(Event{EV_1}, TOPIC_1);
+    Thread::sleep(100);
+    sEventBroker->post(Event{EV_2}, TOPIC_1);
+    Thread::sleep(100);
+
+    // this will not tigger the callback since
+    // the sniffer is subscribed only to TOPIC_1
+    sEventBroker->post(Event{EV_2}, TOPIC_2);
+    Thread::sleep(100);
+    
+    sEventBroker->stop();
+
+    return 0;
+}
+```
+
+#### Output
+```sh
+0.12> Callback : EV_1 on topic 0 
+0.24> Callback : EV_2 on topic 0
+```
\ No newline at end of file