Use BOTH Cores | Dual Core Programming on the Raspberry Pi Pico

Learn how to use both cores on your Raspberry Pi Pico in C using the Linux SDK! Multi core programming makes your projects more powerful! By using both processor cores on the ARM RP2040, we have the potential to make our code 100% more efficient. Check out this and more embedded programming topics on my channel!

Chapters:
0:00 Intro
0:18 What is Multicore?
0:50 How Do RP2040 Cores Communicate?
2:15 Lets Code!
7:39 Outro

===
the raspberry pico rp2040 is an arm cortex m0 based microprocessor equipped with two cores in this video i'll show you how to write code for the raspberry pico that uses a second core on the processor using the second core enables you to make your picot projects twice as powerful by using a completely separate thread of execution to talk about doing multi-core programming we first need to define what the word core means a core is a functional unit on the processor capable of executing program code by having multiple cores on a processor you can execute multiple segments of code at the same time whenever we write code for the raspberry pico for example core zero the first core executes the code the second core is on standby never doing anything here you see a depiction of two cores each core is separately running its own code completely independently they have separate program code and separate memory space there are cases however where the course can share program code and memory space sharing code is not problematic as fetching code is a read instruction and it does not create a race condition however sharing the same locations for data is problematic as it creates a possibility for a race condition to exist where mutual accesses to the memory is not assured so if the cores aren't supposed to share memory directly then how did the course communicate well the masterminds at raspberry pi figured this out and created two separate fifos or first in first out structures to act as a mechanism for communicating between the cores only one fifo is writable by core zero and only one fifo is writable by core one this way no core is ever writing to the same location at the same time in this example core zero has some memory it needs to communicate to core one for some kind of processing instead of writing that memory directly into core one's memory space which could introduce a race condition core zero uses its writable fifo to push that data to core one core one does its processing and then uses its fifo to get that process data back to core zero core zero could have been executing other tasks while waited for core one to finish processing this process of using fifo's to pass data around prevents weird cases where core zero is reaching into core one's memory or vice versa so with that being said let's write some code to make this happen in c okay so here we are in my linux build environment um if you haven't watched my previous video on how to set up a cmake build environment for the raspberry pico c sdk please go watch that it'll make this video much more easy to digest i know i keep beating this up but i do have to say i could not have done this tutorial if i didn't have the raspberry pi pico c sdk document in front of me the entire time they do a very good job of documenting all the functions i'll be using today in the tutorial so after this tutorial go give this a read and see what other trouble you can get yourself into anyway back to the code um so over on the right we're going to be writing the code that's going to go onto our raspberry pi pico um so this is a multi-core video so the first thing we need to do is initiate the second core uh and the way we do that with raspberry pi pico is first we have to pound the pico slash multi-core dot h library what that does is it includes the library of code that raspberry pi has produced to enable us to do multi-process programming on the raspberry pi pico next we need to tell the raspberry pi pico to launch code on its second core and just to prevent any confusion um the second core is called core one just so you're aware so the code starts this code will start in court zero and the rest of the code that we launch on the second core will be in core one just so we're all on the same page we're gonna call this function and we're gonna call it on the function name that's going to get ran by the second core and we're gonna call that second core code and then we have to define a function we're going to define it as a void second core code and then whatever we write in this area is going to get ran on the second core so that was pretty fast
===

[titoine]

Thanks for the explanation of this FIFO feature. Nevertheless, there is important note in the doc about the FIFO usage:
"The inter-core FIFOs are a very precious resource and are frequently used for SDK functionality (e.g. during core 1 launch or by the lockout functions). Additionally they are often required for the exclusive use of an RTOS (e.g. FreeRTOS SMP). For these reasons it is suggested that you do not use the FIFO for your own purposes unless none of the above concerns apply; the majority of cases for transferring data between cores can be eqaully well handled by using a queue"

[shahidriaz]

I searched so many videos but didn't got my concept cleared about RP2040 dual core coding. You have cleared my whole concept. Thanks.

[rbphilip]

I do embedded work for a living and just ordered a Pi pico to play with. In particular the programmable PIO looks interesting. This was a useful video for exposing the "C" apis for me. I had only ever seen micropython examples for the pico.

Now to start working out the details of hooking up a fancy JLINK pod and use a graphical debugger!

[joostvantilburg]

Great intro into multi-core programming especially the graphical explaination before the coding. 1K subs, well done! Could you take it a step further and do some deep-sleep explaination?

[ragdL]

This is extremely high quality content, thanks and all the best !!

[mgeo]

Thanks for this! Super useful! Gradually binge watching your entire channel! 😍

[TheDutchisGaming]

Damn this video immediately answered a question I was stuck with in my head after watching a pico beginner tutorial somewhere else. (1:27)

[sagar]

Great Scott!, Looking forward to another great video.

[loopinnerthe]

exactly what I was looking for. thanks! I need to figure out the non blocking way of doing it otherwise it doesn't actually increase the performance but that is a beautiful introduction.

[skf]

I like this very clear explanation. Sub'd. Thank you.

[chadkrause]

Is there a way to have a shared buffer? Maybe using spinlocks and what not? The use case would be having a class with a lot of data, and having the other core doing the communication with such data. So one core can manage the data, one core can send/receive that data

[anthonyheak]

Thanks for the tutorial, but I had to add the pico_multicore library in the target_link_libraries()

[fixfaxerify]

Is there an interrupt for when data is available on the FIFO?

[mohdrais]

Is there any reference about the data in multicore_fifo_push_blocking (uint32_t data)? How do you know GPIO_ON is 1 and GPIO_OFF is 0?. I tried to search in PICO C SDK but cannit found.

[mrenrollment]

so have I missed it? did you do a vid on-- how to do the same Except one core with C++ and the other Python.

[TT-itgg]

Shock to know that Pico uses FIFO design. It's an easy, low cost, low power way to combine two cores....
But for the performance and future scale up consideration, believe, the FIFO will not be the choice...

[pesho]

cant you use a simple semaphore to ensure the shared resource gets written by only one core at a time.A simple producer-consumer example might be good to demonstrate that.

[drewmalbica]

Thanks! Can’t wait to use both cores. So far I’ve got 2 separate instructions running on my project but this is helping me know how to push data between cores. I saw another video talk about having interrupts for each core that will run when it’s moving data over, is that going to work better when the cores are running more complex tasks?

[scharkalvin]

Will the example work in the Arduino core for the RP2040? The Arduino package includes the RP2040 SDK.

[zhitailiu]

Thanks for the great video!
Does anyone know how core1 can reconize the fifo commands and run the code spedcified by core0.
In the src file of multicore.c line 145, there is a specifal cmd sequence consisting vec_table, sp, and entry point for core1.
Core1 recognizes these cmds because there is already some code running in core1 after boot?