Introduce optional javascript semantics for event handling

inc/core/MicroBitConfig.h

@@ -171,6 +171,21 @@ extern uint32_t __etext;
 #define MESSAGE_BUS_LISTENER_MAX_QUEUE_DEPTH    10
 #endif
 
+//
+// Define MESSAGE_BUS concurrency behaviour. 
+// Set to MESSAGE_BUS_CONCURRENT_LISTENERS to fire event handler 
+// concurrently when a given event is raised, and process events sequentially as they arrive (default micro:bit semantics). 
+// Set to MESSAGE_BUS_CONCURRENT_EVENTS to to fire event handlers sequentially for any given event, while still allowing 
+// concurrent processing of events.
+//
+//
+// Permissable values are:
+//   0: MESSAGE_BUS_CONCURRENT_LISTENERS
+//   1: MESSAGE_BUS_CONCURRENT_EVENTS
+//
+#ifndef MESSAGE_BUS_CONCURRENCY_MODE
+#define MESSAGE_BUS_CONCURRENCY_MODE            MESSAGE_BUS_CONCURRENT_LISTENERS
+#endif
 //
 // Core micro:bit services
 //

inc/core/MicroBitListener.h

@@ -28,9 +28,9 @@ DEALINGS IN THE SOFTWARE.
 
 #include "mbed.h"
 #include "MicroBitConfig.h"
+#include "MicroBitLock.h"
 #include "MicroBitEvent.h"
 #include "MemberFunctionCallback.h"
-#include "MicroBitConfig.h"
 
 // MicroBitListener flags...
 #define MESSAGE_BUS_LISTENER_PARAMETERISED          0x0001
@@ -67,7 +67,7 @@ struct MicroBitListener
 
 	MicroBitEvent 	            evt;
 	MicroBitEventQueueItem 	    *evt_queue;
-
+    MicroBitLock                lock;
 	MicroBitListener *next;
 
 	/**

inc/core/MicroBitLock.h

@@ -0,0 +1,66 @@
+/*
+The MIT License (MIT)
+
+Copyright (c) 2016 British Broadcasting Corporation.
+This software is provided by Lancaster University by arrangement with the BBC.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+*/
+
+/**
+ * A simple lock, mostly used for mutual exclusion.
+ */
+
+#ifndef MICROBIT_LOCK_H
+#define MICROBIT_LOCK_H
+
+#include "MicroBitConfig.h"
+
+class Fiber;
+
+class MicroBitLock
+{
+    private:
+    bool    locked;
+    Fiber   *queue;
+
+    public:
+
+    /**
+     * Create a new lock that can be used for mutual exclusion and condition synchronisation.
+     */
+    MicroBitLock();
+
+    /**
+     * Block the calling fiber until the lock is available
+     **/
+    void wait();
+
+    /**
+     * Release the lock, and signal to one waiting fiber to continue
+     */
+    void notify();
+
+    /**
+     * Release the lock, and signal to all waiting fibers to continue
+     */
+    void notifyAll();
+};
+
+#endif

inc/drivers/MicroBitMessageBus.h

@@ -33,6 +33,9 @@ DEALINGS IN THE SOFTWARE.
 #include "MicroBitListener.h"
 #include "EventModel.h"
 
+#define MESSAGE_BUS_CONCURRENT_LISTENERS        0
+#define MESSAGE_BUS_CONCURRENT_EVENTS           1
+
 /**
   * Class definition for the MicroBitMessageBus.
   *
@@ -105,7 +108,7 @@ class MicroBitMessageBus : public EventModel, public MicroBitComponent
       * @note It is recommended that all external code uses the send() function instead of this function,
       *       or the constructors provided by MicrobitEvent.
       */
-	int process(MicroBitEvent &evt, bool urgent = false);
+	int process(MicroBitEvent evt, bool urgent = false);
 
     /**
       * Returns the microBitListener with the given position in our list.
@@ -144,7 +147,6 @@ class MicroBitMessageBus : public EventModel, public MicroBitComponent
     MicroBitListener            *listeners;		    // Chain of active listeners.
     MicroBitEventQueueItem      *evt_queue_head;    // Head of queued events to be processed.
     MicroBitEventQueueItem      *evt_queue_tail;    // Tail of queued events to be processed.
-    uint16_t                    nonce_val;          // The last nonce issued.
     uint16_t                    queueLength;        // The number of events currently waiting to be processed.
 
     /**

inc/platform/yotta_cfg_mappings.h

@@ -171,4 +171,8 @@
     #define MICROBIT_BLE_DEVICE_INFORMATION_SERVICE YOTTA_CFG_MICROBIT_DAL_BLUETOOTH_DEVICE_INFO_SERVICE
 #endif
 
+#ifdef YOTTA_CFG_MICROBIT_DAL_MESSAGE_BUS_CONCURRENCY_MODE
+    #define MESSAGE_BUS_CONCURRENCY_MODE YOTTA_CFG_MICROBIT_DAL_MESSAGE_BUS_CONCURRENCY_MODE
+#endif
+
 #endif

source/core/MicroBitFiber.cpp

@@ -428,12 +428,7 @@ int fiber_wake_on_event(uint16_t id, uint16_t value)
         // If we're out of memory, there's nothing we can do.
         // keep running in the context of the current thread as a best effort.
         if (forkedFiber != NULL)
-        {
             f = forkedFiber;
-            dequeue_fiber(f);
-            queue_fiber(f, &runQueue);
-            schedule();
-        }
     }
 
     // Encode the event data in the context field. It's handy having a 32 bit core. :-)
@@ -942,3 +937,84 @@ void idle_task()
         schedule();
     }
 }
+
+/**
+ * Create a new lock that can be used for mutual exclusion and condition synchronisation.
+ */
+MicroBitLock::MicroBitLock()
+{
+    queue = NULL;
+    locked = false;
+}
+
+/**
+ * Block the calling fiber until the lock is available
+ **/
+void MicroBitLock::wait()
+{
+    Fiber *f = currentFiber;
+
+    // If the scheduler is not running, then simply exit, as we're running monothreaded.
+    if (!fiber_scheduler_running())
+        return;
+
+    if (locked)
+    {
+        // wait() is a blocking call, so if we're in a fork on block context,
+        // it's time to spawn a new fiber...
+        if (currentFiber->flags & MICROBIT_FIBER_FLAG_FOB)
+        {
+            // Allocate a new fiber. This will come from the fiber pool if availiable,
+            // else a new one will be allocated on the heap.
+            forkedFiber = getFiberContext();
+
+            // If we're out of memory, there's nothing we can do.
+            // keep running in the context of the current thread as a best effort.
+            if (forkedFiber != NULL)
+                f = forkedFiber;
+        }
+
+        // Remove fiber from the run queue
+        dequeue_fiber(f);
+
+        // Add fiber to the sleep queue. We maintain strict ordering here to reduce lookup times.
+        queue_fiber(f, &queue);
+
+        // Finally, enter the scheduler.
+        schedule();
+    }
+
+    locked = true;
+}
+
+/**
+ * Release the lock, and signal to one waiting fiber to continue
+ */
+void MicroBitLock::notify()
+{
+    Fiber *f = queue;
+
+    if (f)
+    {
+        dequeue_fiber(f);
+        queue_fiber(f, &runQueue);
+    }
+    locked = false;
+}
+
+/**
+ * Release the lock, and signal to all waiting fibers to continue
+ */
+void MicroBitLock::notifyAll()
+{
+    Fiber *f = queue;
+
+    while (f)
+    {
+        dequeue_fiber(f);
+        queue_fiber(f, &runQueue);
+        f = queue;
+    }
+
+    locked = false;
+}

source/drivers/MicroBitDisplay.cpp

@@ -354,8 +354,7 @@ void MicroBitDisplay::updateScrollText()
 void MicroBitDisplay::updatePrintText()
 {
     image.print(printingChar < printingText.length() ? printingText.charAt(printingChar) : ' ',0,0);
-
-    if (printingChar > printingText.length())
+    if (printingChar >= printingText.length())
     {
         animationMode = ANIMATION_MODE_NONE;
 
@@ -448,7 +447,7 @@ void MicroBitDisplay::stopAnimation()
 void MicroBitDisplay::waitForFreeDisplay()
 {
     // If there's an ongoing animation, wait for our turn to display.
-    if (animationMode != ANIMATION_MODE_NONE && animationMode != ANIMATION_MODE_STOPPED)
+    while (animationMode != ANIMATION_MODE_NONE && animationMode != ANIMATION_MODE_STOPPED)
         fiber_wait_for_event(MICROBIT_ID_NOTIFY, MICROBIT_DISPLAY_EVT_FREE);
 }
 
@@ -492,7 +491,7 @@ int MicroBitDisplay::printCharAsync(char c, int delay)
         if (delay > 0)
         {
             animationDelay = delay;
-            animationTick = 0;
+            animationTick = delay-1;
             animationMode = ANIMATION_MODE_PRINT_CHARACTER;
         }
     }
@@ -533,7 +532,7 @@ int MicroBitDisplay::printAsync(ManagedString s, int delay)
         printingChar = 0;
         printingText = s;
         animationDelay = delay;
-        animationTick = 0;
+        animationTick = delay-1;
 
         animationMode = ANIMATION_MODE_PRINT_TEXT;
     }
@@ -576,7 +575,7 @@ int MicroBitDisplay::printAsync(MicroBitImage i, int x, int y, int alpha, int de
         if(delay > 0)
         {
             animationDelay = delay;
-            animationTick = 0;
+            animationTick = delay-1;
             animationMode = ANIMATION_MODE_PRINT_CHARACTER;
         }
     }

source/drivers/MicroBitMessageBus.cpp

@@ -95,14 +95,19 @@ void async_callback(void *param)
         // Queue this event up for later, if that's how we've been configured.
         if (listener->flags & MESSAGE_BUS_LISTENER_QUEUE_IF_BUSY)
         {
+#if (MESSAGE_BUS_CONCURRENCY_MODE == MESSAGE_BUS_CONCURRENT_LISTENERS)
             listener->queue(listener->evt);
             return;
+#endif
         }
     }
 
     // Determine the calling convention for the callback, and invoke...
     // C++ is really bad at this! Especially as the ARM compiler is yet to support C++ 11 :-/
 
+#if (MESSAGE_BUS_CONCURRENCY_MODE == MESSAGE_BUS_CONCURRENT_EVENTS)
+    listener->lock.wait();
+#endif
     // Record that we have a fiber going into this listener...
     listener->flags |= MESSAGE_BUS_LISTENER_BUSY;
 
@@ -138,6 +143,10 @@ void async_callback(void *param)
 
     // The fiber of exiting... clear our state.
     listener->flags &= ~MESSAGE_BUS_LISTENER_BUSY;
+
+#if (MESSAGE_BUS_CONCURRENCY_MODE == MESSAGE_BUS_CONCURRENT_EVENTS)
+    listener->lock.notify();
+#endif
 }
 
 /**
@@ -261,6 +270,13 @@ int MicroBitMessageBus::deleteMarkedListeners()
     return removed;
 }
 
+MicroBitEvent last_event;
+void process_sequentially(void *param)
+{
+    MicroBitMessageBus *m = (MicroBitMessageBus *)param;
+    m->process(last_event);
+}
+
 /**
   * Periodic callback from MicroBit.
   *
@@ -278,7 +294,12 @@ void MicroBitMessageBus::idleTick()
     while (item)
     {
         // send the event to all standard event listeners.
+#if (MESSAGE_BUS_CONCURRENCY_MODE == MESSAGE_BUS_CONCURRENT_EVENTS)
+        last_event = item->evt;
+        invoke(process_sequentially,this);
+#else
         this->process(item->evt);
+#endif
 
         // Free the queue item.
         delete item;
@@ -337,7 +358,7 @@ int MicroBitMessageBus::send(MicroBitEvent evt)
   * @note It is recommended that all external code uses the send() function instead of this function,
   *       or the constructors provided by MicrobitEvent.
   */
-int MicroBitMessageBus::process(MicroBitEvent &evt, bool urgent)
+int MicroBitMessageBus::process(MicroBitEvent evt, bool urgent)
 {
     MicroBitListener *l;
     int complete = 1;
@@ -365,10 +386,12 @@ int MicroBitMessageBus::process(MicroBitEvent &evt, bool urgent)
                 // Otherwise, we invoke it in a 'fork on block' context, that will automatically create a fiber
                 // should the event handler attempt a blocking operation, but doesn't have the overhead
                 // of creating a fiber needlessly. (cool huh?)
-                if (l->flags & MESSAGE_BUS_LISTENER_NONBLOCKING || !fiber_scheduler_running())
-                    async_callback(l);
-                else
+#if (MESSAGE_BUS_CONCURRENCY_MODE == MESSAGE_BUS_CONCURRENT_LISTENERS)
+                if (!(l->flags & MESSAGE_BUS_LISTENER_NONBLOCKING) && fiber_scheduler_running())
                     invoke(async_callback, l);
+                else
+#endif
+                    async_callback(l);
             }
             else
             {