Best/easiest way to share data between cores in STM32H745

No, I'm afraid just putting variable definitions in a common .c source file won't work.

Code and data for both cores are linked separately, and they are put into separate memory areas for each core, even if they are defined in a common source file. CM7 variables are placed in DTCM RAM at 0x20000000, CM4 variables go into D2 SRAM at 0x30000000 (aliased to 0x10000000).

You have to explicitly specify the memory address for the shared data structure(s), and either do some linker trickery to have them placed at the exact same address for both cores, or simply access them through a fixed pointer.

struct shared_data {
 /* shared data goes here */
};
 
volatile struct shared_data * const shared_ptr = (struct shared_data *)0x30040000;

Chapter 2.4 of the reference manual recommends using AHB SRAM3 at 0x30040000 as shared memory between the two cores, so I've used that address, but it's not a hard rule, as there is an example projects that uses SRAM4 at 0x38001000 for this purpose.

You should ensure that the memory occupied by shared data is not touched by the linker, i.e. it doesn't appear in the linker definition for either core.

Thank you for the concise answer. I was in the process of trying to add a common segment to both linker scripts, but it wasn't working right. I'll use your answer.​

I hope STM is working on expanding the documentation and mx-cube examples for the h7 series. I know these chips are new and very complicated, but the mx-cube example code has an incomplete & untested feel to it & the integration in Eclipse is very confusing. I'm the sort of person that likes to dig into things and figure them out myself, but after a whole day of digging thru data sheets and importing examples to read, i was no less confused.​

In case anyone is still interested in this topic, this is what I did, and it seems to work. Many thanks to berendi for the recommendation, which I followed.

I wanted to share data between the 2 cores, CM4 and CM7, in an STM32H745, using the STM32CubeIDE to program a NUCLEO-H745ZI-Q board.

First, I defined the following struct and pointer in main.c for each of the cores. I used the same names in main.c for both CM4 and CM7. This made it easier for me to keep everything straight in my head. Note that I used the SRAM4 address at 0x38001000.

/* USER CODE BEGIN PV */
 
// inter-core buffers
struct shared_data
{
	uint8_t sts_4to7; // status: 0 = empty, 1 = has data, 2 = locked (CM4-CM7)
	uint8_t sts_7to4; // status: 0 = empty, 1 = has data, 2 = locked (CM7-CM4)
	uint32_t M4toM7[64]; // 256 bytes from CM4 to CM7
	uint32_t M7toM4[64]; // 256 bytes from CM7 to CM4
};
 
// pointer to shared_data struct (inter-core buffers and status)
volatile struct shared_data * const xfr_ptr = (struct shared_data *)0x38001000;
 
/* USER CODE END PV */

Next, to test the concept, I used the virtual UART connected to CM4. From a computer, I sent data to CM4, put the data into the CM4 to CM7 buffer, retrieved it from the CM7 to CM4 buffer, and printed it to the computer.

For this to work, I needed code in CM7 to copy the data from the CM4 to CM7 buffer to the CM7 to CM4 buffer. I wrote the following functions, which can be used in other applications.

/* USER CODE BEGIN PFP */
 
uint32_t * get_M4(); // get data from M4 to M7
 
void put_M7(uint32_t buffer[64]); // put data from M7 to M4
 
/* USER CODE END PFP */
 
/* USER CODE BEGIN 4 */
 
uint32_t * get_M4() // get data from M4 to M7 buffer
{
	static uint32_t buffer[64]; // buffer to receive data
	if (xfr_ptr->sts_4to7 == 1) // if M4 to M7 buffer has data
	{
		xfr_ptr->sts_4to7 = 2; // lock the M4 to M7 buffer
		for(int n = 0; n < 64; n++)
		{
			buffer[n] = xfr_ptr->M4toM7[n]; // transfer data
			xfr_ptr->M4toM7[n] = 0; // clear M4 to M7 buffer
		}
		xfr_ptr->sts_4to7 = 0; // M4 to M7 buffer is empty
	}
	return buffer; // return the buffer (pointer)
}
 
void put_M7(uint32_t buffer[64]) // send data from M7 to M4
{
	if (xfr_ptr->sts_7to4 == 0) // if M7 to M4 buffer is empty
	{
		xfr_ptr->sts_7to4 = 2; // lock the M7 to M4 buffer
		for(int n = 0; n < 64; n++)
		{
			xfr_ptr->M7toM4[n] = buffer[n]; // transfer data
			buffer[n] = 0; // clear M7 to M4 buffer
		}
		xfr_ptr->sts_7to4 = 1; // M7 to M4 buffer has data
	}
}
 
/* USER CODE END 4 */

The get_M4() function checks to see if the M4 to M7 buffer has data, changes the status to locked, retrieves the data, clears the buffer, and changes the status to empty.

The put_M7 function checks to see if the M7 to M4 buffer is empty, changes the status to locked, stores the data, clears the incoming buffer, and changes the status to has data.

Finally, the following code in CM7 uses these 2 functions to retrieve the data from CM4 and return it to CM4.

/* USER CODE BEGIN 1 */
 
	uint32_t * xfr_data; // pointer to transfer data
	uint8_t sts_xfr = 0; // xfr_data status: 0 = empty, 1 = has data
 
	//initialize inter-core status pointers
	xfr_ptr->sts_4to7 = 0;
	xfr_ptr->sts_7to4 = 0;
 
 /* USER CODE END 1 */
 
 /* USER CODE BEGIN WHILE */
 while (1)
 {
 /* USER CODE END WHILE */
 
 /* USER CODE BEGIN 3 */
 
	 // if xfr_data buffer is empty and M4 to M7 buffer has data
	 if (sts_xfr == 0 && xfr_ptr->sts_4to7 == 1)
	 {
		 xfr_data = get_M4(); // get data sent from M4 to M7
		 sts_xfr = 1; // set xfr_data status to has data
	 }
	 // if transfer data buffer has data and M7 to M4 buffer is empty
	 if (sts_xfr == 1 && xfr_ptr->sts_7to4 == 0)
	 {
		 put_M7(xfr_data); // copy data to M7 to M4 buffer
		 sts_xfr = 0; // set xfr_data status to empty
	 }
 }
 
 /* USER CODE END 3 */

The main loop checks to see if the CM4 to CM7 buffer has data and the xfr_data buffer is empty. If so, the get_M4() function retrieves the data to the xfr_data buffer and sets the xfr_data buffer status to has data. Next, if the xfr_data buffer has data and the CM7 to CM4 buffer is empty, the put_M7 function puts the data from the xfr_data buffer into the CM7 to CM4 buffer and sets the xfr_data buffer status to empty.

I’m not the most experienced C programmer, but this is simple and it works. I like simple.

Please comment if I have made any mistakes or if you have a better way of moving data from one core to the other.

Hi , i use the next code, with "placement new", with board STM32H745ZI.

#include <new>
 
//BANK SRAM4
#define MEMORY_SHARED_INIT_ADDRESS 0x38000000
 
volatile void *pointerShared = (void *) MEMORY_SHARED_INIT_ADDRESS;
 
MemoryShared *memoryShared = new ( (void *) pointerShared) MemoryShared();
 
MemoryShared *MemoryShared::GetInstance() {
	return memoryShared;
}

MemoryShared.hpp:

class MemoryShared {
	private:
	Control control;
 
	public:
	static MemoryShared *GetInstance();
 
	MemoryShared() {
 
	}
 
	~MemoryShared() {
 
	}
 
	Control &getControl() {
		return control;
	}
};

Finally in main.cpp (CM7,CM4), i use:

MemoryShared *shared = MemoryShared::GetInstance();

All objects and members from MemoryShared can be shared, while is monolithic data like buffer arrays const, const instances, etc.

I used Majerle's example to share data between cores. But it does not fast enough to share huge data. I hope there will be more examples about that topic in the feature.

Hi AAnt.1,

Sorry, I do not have a project using this code that I can give you. However, what I did is very simple. You only need the first code fragment.

I created two 256 byte buffers (one for each direction) and two status bytes (one for each direction. Then I created a pointer to these. You use these just as you would any other buffer, except that they are shared between both cores instead of just one core.

All of the other code is what I used to test the buffers and confirm that they work. You can write your own code that uses these buffers.

Best regards,

I edited a little TSimo.1's code and put it in a repository.

https://github.com/adailtonjn68/STM32H7xx_inter-core_data_share