Initial Release

multicore/CMakeLists.txt

@@ -0,0 +1,5 @@
+if (NOT PICO_NO_HARDWARE)
+    add_subdirectory(hello_multicore)
+    add_subdirectory(multicore_runner)
+    add_subdirectory(multicore_fifo_irqs)
+endif ()

multicore/hello_multicore/CMakeLists.txt

@@ -0,0 +1,14 @@
+add_executable(hello_multicore
+        multicore.c
+        )
+
+# Add pico_multicore which is required for multicore functionality
+target_link_libraries(hello_multicore
+        pico_stdlib
+        pico_multicore)
+
+# create map/bin/hex file etc.
+pico_add_extra_outputs(hello_multicore)
+
+# add url via pico_set_program_url
+example_auto_set_url(hello_multicore)

multicore/hello_multicore/multicore.c

@@ -0,0 +1,48 @@
+/**
+ * Copyright (c) 2020 Raspberry Pi (Trading) Ltd.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#include <stdio.h>
+#include "pico/stdlib.h"
+#include "pico/multicore.h"
+
+#define FLAG_VALUE 123
+
+void core1_entry() {
+
+    multicore_fifo_push_blocking(FLAG_VALUE);
+
+    uint32_t g = multicore_fifo_pop_blocking();
+
+    if (g != FLAG_VALUE)
+        printf("Hmm, that's not right on core 1!\n");
+    else
+        printf("Its all gone well on core 1!");
+
+    while (1)
+        tight_loop_contents();
+}
+
+int main() {
+    stdio_init_all();
+    printf("Hello, multicore!\n");
+
+    ///tag::setup_multicore[]
+
+    multicore_launch_core1(core1_entry);
+
+    // Wait for it to start up
+
+    uint32_t g = multicore_fifo_pop_blocking();
+
+    if (g != FLAG_VALUE)
+        printf("Hmm, that's not right on core 0!\n");
+    else {
+        multicore_fifo_push_blocking(FLAG_VALUE);
+        printf("It's all gone well on core 0!");
+    }
+
+    ///end::setup_multicore[]
+}

multicore/multicore_fifo_irqs/CMakeLists.txt

@@ -0,0 +1,13 @@
+add_executable(multicore_fifo_irqs
+        multicore_fifo_irqs.c
+        )
+
+target_link_libraries(multicore_fifo_irqs
+        pico_multicore
+        pico_stdlib)
+
+# create map/bin/hex file etc.
+pico_add_extra_outputs(multicore_fifo_irqs)
+
+# add url via pico_set_program_url
+example_auto_set_url(multicore_fifo_irqs)

multicore/multicore_fifo_irqs/multicore_fifo_irqs.c

@@ -0,0 +1,76 @@
+/**
+ * Copyright (c) 2020 Raspberry Pi (Trading) Ltd.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#include <stdio.h>
+#include "pico/stdlib.h"
+#include "pico/multicore.h"
+#include "hardware/irq.h"
+
+///tag::multicore_fifo_irqs[]
+
+#define FLAG_VALUE1 123
+#define FLAG_VALUE2 321
+
+static int core0_rx_val = 0, core1_rx_val = 0;
+
+void core0_sio_irq() {
+    // Just record the latest entry
+    while (multicore_fifo_rvalid())
+        core0_rx_val = multicore_fifo_pop_blocking();
+
+    multicore_fifo_clear_irq();
+}
+
+void core1_sio_irq() {
+    // Just record the latest entry
+    while (multicore_fifo_rvalid())
+        core1_rx_val = multicore_fifo_pop_blocking();
+
+    multicore_fifo_clear_irq();
+}
+
+void core1_entry() {
+    multicore_fifo_clear_irq();
+    irq_set_exclusive_handler(SIO_IRQ_PROC1, core1_sio_irq);
+
+    irq_set_enabled(SIO_IRQ_PROC1, true);
+
+    // Send something to Core0, this should fire the interrupt.
+    multicore_fifo_push_blocking(FLAG_VALUE1);
+
+    while (1)
+        tight_loop_contents();
+}
+
+
+int main() {
+    stdio_init_all();
+    printf("Hello, multicore_fifo_irqs!\n");
+
+    // We MUST start the other core before we enabled FIFO interrupts.
+    // This is because the launch uses the FIFO's, enabling interrupts before
+    // they are used for the launch will result in unexpected behaviour.
+    multicore_launch_core1(core1_entry);
+
+    irq_set_exclusive_handler(SIO_IRQ_PROC0, core0_sio_irq);
+    irq_set_enabled(SIO_IRQ_PROC0, true);
+
+    // Wait for a bit for things to happen
+    sleep_ms(10);
+
+    // Send something back to the other core
+    multicore_fifo_push_blocking(FLAG_VALUE2);
+
+    // Wait for a bit for things to happen
+    sleep_ms(10);
+
+    printf("Irq handlers should have rx'd some stuff - core 0 got %d, core 1 got %d!\n", core0_rx_val, core1_rx_val);
+
+    while (1)
+        tight_loop_contents();
+}
+
+///end::multicore_fifo_irqs[]

multicore/multicore_runner/CMakeLists.txt

@@ -0,0 +1,13 @@
+add_executable(multicore_runner
+        multicore_runner.c
+        )
+
+target_link_libraries(multicore_runner
+        pico_multicore
+        pico_stdlib)
+
+# create map/bin/hex file etc.
+pico_add_extra_outputs(multicore_runner)
+
+# add url via pico_set_program_url
+example_auto_set_url(multicore_runner)

multicore/multicore_runner/multicore_runner.c

@@ -0,0 +1,83 @@
+/**
+ * Copyright (c) 2020 Raspberry Pi (Trading) Ltd.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#include <stdio.h>
+#include "pico/stdlib.h"
+#include "pico/multicore.h"
+
+///tag::multicore_dispatch[]
+
+#define FLAG_VALUE 123
+
+void core1_entry() {
+    while (1) {
+        // Function pointer is passed to us via the FIFO
+        // We have one incoming int32_t as a parameter, and will provide an
+        // int32_t return value by simply pushing it back on the FIFO
+        // which also indicates the result is ready.
+        int32_t (*func)() = (int32_t(*)()) multicore_fifo_pop_blocking();
+        int32_t p = multicore_fifo_pop_blocking();
+        int32_t result = (*func)(p);
+        multicore_fifo_push_blocking(result);
+    }
+}
+
+int32_t factorial(int32_t n) {
+    int32_t f = 1;
+    for (int i = 2; i <= n; i++) {
+        f *= i;
+    }
+    return f;
+}
+
+int32_t fibonacci(int32_t n) {
+    if (n == 0) return 0;
+    if (n == 1) return 1;
+
+    int n1 = 0, n2 = 1, n3;
+
+    for (int i = 2; i <= n; i++) {
+        n3 = n1 + n2;
+        n1 = n2;
+        n2 = n3;
+    }
+    return n3;
+}
+
+#define TEST_NUM 10
+
+int main() {
+    int res;
+
+    stdio_init_all();
+    printf("Hello, multicore_runner!\n");
+
+    // This example dispatches arbitrary functions to run on the second core
+    // To do this we run a dispatcher on the second core that accepts a function
+    // pointer and runs it
+    multicore_launch_core1(core1_entry);
+
+    multicore_fifo_push_blocking((uintptr_t) &factorial);
+    multicore_fifo_push_blocking(TEST_NUM);
+
+    // We could now do a load of stuff on core 0 and get our result later
+
+    res = multicore_fifo_pop_blocking();
+
+    printf("Factorial %d is %d\n", TEST_NUM, res);
+
+    // Now try a different function
+    multicore_fifo_push_blocking((uintptr_t) &fibonacci);
+    multicore_fifo_push_blocking(TEST_NUM);
+
+    res = multicore_fifo_pop_blocking();
+
+    printf("Fibonacci %d is %d\n", TEST_NUM, res);
+
+
+}
+
+///end::multicore_dispatch[]