add RTOS examples

Move examples:
https://os.mbed.com/teams/mbed_example/code/rtos_mutex/
https://os.mbed.com/teams/mbed_example/code/rtos_signals/
https://os.mbed.com/teams/mbed_example/code/rtos_threading_with_callback/
https://os.mbed.com/teams/mbed_example/code/rtos_isr/
https://os.mbed.com/teams/mbed_example/code/rtos_semaphore/
to this repo

Update example code to latest API's

Author: maciejbocianski

APIs_RTOS/Flags/README.md

@@ -0,0 +1,4 @@
+# Flags example
+
+This example shows how to use Flags for threads communication.
+

APIs_RTOS/Flags/main.cpp

@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2020 Arm Limited and affiliates.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#include "mbed.h"
+ 
+Thread thread;
+DigitalOut led(LED1);
+ 
+void led_thread() {
+    while (true) {
+        // Signal flags that are reported as event are automatically cleared.
+        ThisThread::flags_wait_any(0x1);
+        led = !led;
+    }
+}
+ 
+int main (void) {
+    thread.start(callback(led_thread));
+ 
+    while (true) {
+        ThisThread::sleep_for(1000);
+        thread.flags_set(0x1);
+    }
+}

APIs_RTOS/Isr/README.md

@@ -0,0 +1,4 @@
+# Isr example
+
+This example shows how to use various isr mechanisms in MbedOS.
+

APIs_RTOS/Isr/main.cpp

@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) 2020 Arm Limited and affiliates.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#include "mbed.h"
+ 
+Ticker ticker;
+Thread thread;
+Queue<const char*, 5> trail;
+ 
+// Since we're printing from multiple threads, we need a mutex
+Mutex print_lock;
+ 
+enum ExecutionTypes {
+    IDLE,
+    USER,
+    ISR
+};
+ 
+const char* ExecutionMessages[] = {
+    "the idle thread",
+    "a user thread",
+    "interrupt context"
+};
+ 
+void handler() {
+    // Check to see if we're in interrupt context
+    if (core_util_is_isr_active()) {
+        // Do not print since we're in interrupt context
+        trail.put(&(ExecutionMessages[ISR]));
+    } else {
+        // Safe to print since we're in a user thread
+        print_lock.lock();
+        printf("Starting user thread\r\n");
+        print_lock.unlock();
+        while(true) {
+            trail.put(&(ExecutionMessages[USER]));
+            ThisThread::sleep_for(500);
+        }
+    }
+}
+ 
+void custom_idle_function() {
+    // Custom idle behavior would go here
+    // We won't print here since the default idle thread's stack is too small
+    trail.put(&(ExecutionMessages[IDLE]));
+ 
+    // Switch back to the default idle behavior
+    Kernel::attach_idle_hook(NULL);
+}
+ 
+int main() {
+    printf("Starting execution example\r\n");
+ 
+    // Attach the custom idle thread function
+    Kernel::attach_idle_hook(custom_idle_function);
+ 
+    // Trigger the interrupt every 3 seconds
+    ticker.attach(handler, 3);
+ 
+    // Start the user thread
+    thread.start(handler);
+ 
+    // Get the past exectuion trail
+    while (true) {
+        osEvent evt = trail.get();
+        if (evt.status != osEventMessage) {
+            print_lock.lock();
+            printf("Failed to retrieve the execution trail (returned %02lx)\r\n", evt.status);
+            print_lock.unlock();
+        } else {
+            print_lock.lock();
+            printf("Execution was in %s\r\n", *(const char**)evt.value.v);
+            print_lock.unlock();
+        }
+    }
+}

APIs_RTOS/Mutex/README.md

@@ -0,0 +1,4 @@
+# Mutex example
+
+This example shows how to use Mutex for threads synchronization.
+

APIs_RTOS/Mutex/main.cpp

@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2020 Arm Limited and affiliates.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#include "mbed.h"
+ 
+Mutex stdio_mutex;
+Thread t2;
+Thread t3;
+    
+void notify(const char* name, int state) {
+    stdio_mutex.lock();
+    printf("%s: %d\n\r", name, state);
+    stdio_mutex.unlock();
+}
+ 
+void test_thread(void const *args) {
+    while (true) {
+        notify((const char*)args, 0); 
+        ThisThread::sleep_for(1000);
+        notify((const char*)args, 1); 
+        ThisThread::sleep_for(1000);
+    }
+}
+ 
+int main() {
+    t2.start(callback(test_thread, (void *)"Th 2"));
+    t3.start(callback(test_thread, (void *)"Th 3"));
+ 
+    test_thread((void *)"Th 1");
+}

APIs_RTOS/Semaphore/README.md

@@ -0,0 +1,4 @@
+# Semaphore example
+
+This example shows how to use Semaphore for threads synchronization.
+

APIs_RTOS/Semaphore/main.cpp

@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2020 Arm Limited and affiliates.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#include "mbed.h"
+ 
+Semaphore one_slot(1);
+Thread t2;
+Thread t3;
+ 
+void test_thread(void const *name) {
+    while (true) {
+        one_slot.acquire();
+        printf("%s\n\r", (const char*)name);
+        ThisThread::sleep_for(1000);
+        one_slot.release();
+    }
+}
+ 
+int main (void) {
+    t2.start(callback(test_thread, (void *)"Th 2"));
+    t3.start(callback(test_thread, (void *)"Th 3"));
+ 
+    test_thread((void *)"Th 1");
+}

APIs_RTOS/Threading_with_callback/README.md

@@ -0,0 +1,4 @@
+# Simple threading example with callback
+
+This example shows how to run thread using callbacks.
+

APIs_RTOS/Threading_with_callback/main.cpp

@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2020 Arm Limited and affiliates.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#include "mbed.h"
+ 
+Thread thread;
+DigitalOut led1(LED1);
+volatile bool running = true;
+ 
+// Blink function toggles the led in a long running loop
+void blink(DigitalOut *led) {
+    while (running) {
+        *led = !*led;
+        ThisThread::sleep_for(1000);
+    }
+}
+ 
+// Spawns a thread to run blink for 5 seconds
+int main() {
+    thread.start(callback(blink, &led1));
+    ThisThread::sleep_for(5000);
+    running = false;
+    thread.join();
+}