And here is my app_freertos.c:
/**
******************************************************************************
* File Name : app_freertos.c
* Description : Code for freertos applications
******************************************************************************
*/
/* Includes ------------------------------------------------------------------*/
#include "FreeRTOS.h"
#include "task.h"
#include "main.h"
#include "cmsis_os.h"
/* Private includes ----------------------------------------------------------*/
#include "stm32mp15xx_disco.h"
#include "log.h"
#include "openamp.h"
#include <stdio.h>
/* Private define ------------------------------------------------------------*/
#define MAX_BUFFER_SIZE RPMSG_BUFFER_SIZE
/* Private variables ---------------------------------------------------------*/
VIRT_UART_HandleTypeDef hvuart0;
__IO FlagStatus VirtUart0RxMsg = RESET;
uint8_t VirtUart0ChannelBuffRx[MAX_BUFFER_SIZE];
uint16_t VirtUart0ChannelRxSize = 0;
osThreadId TaskIdleHandle;
osThreadId TaskLedBlinkHandle;
osThreadId TaskVUART0Handle;
osMessageQId QueueTxMP1Handle;
osMessageQId QueueRxMP1Handle;
osMutexId myMutex01Handle;
osSemaphoreId myBinarySem01Handle;
/* Private function prototypes -----------------------------------------------*/
void VIRT_UART0_RxCpltCallback(VIRT_UART_HandleTypeDef *huart);
void StartTaskIdle(void const * argument);
void StartTaskLedBlink(void const * argument);
void StartTaskVUART0(void const * argument);
void MX_FREERTOS_Init(void); /* (MISRA C 2004 rule 8.1) */
/* GetIdleTaskMemory prototype (linked to static allocation support) */
void vApplicationGetIdleTaskMemory( StaticTask_t **ppxIdleTaskTCBBuffer, StackType_t **ppxIdleTaskStackBuffer, uint32_t *pulIdleTaskStackSize );
static StaticTask_t xIdleTaskTCBBuffer;
static StackType_t xIdleStack[configMINIMAL_STACK_SIZE];
void vApplicationGetIdleTaskMemory( StaticTask_t **ppxIdleTaskTCBBuffer, StackType_t **ppxIdleTaskStackBuffer, uint32_t *pulIdleTaskStackSize )
{
*ppxIdleTaskTCBBuffer = &xIdleTaskTCBBuffer;
*ppxIdleTaskStackBuffer = &xIdleStack[0];
*pulIdleTaskStackSize = configMINIMAL_STACK_SIZE;
/* place for user code */
}
/**
* @brief FreeRTOS initialization
* @param None
* @retval None
*/
void MX_FREERTOS_Init(void) {
osStatus status;
/* Create the mutex(es) */
/* definition and creation of myMutex01 */
osMutexDef(myMutex01);
myMutex01Handle = osMutexCreate(osMutex(myMutex01));
//status = osMutexDelete (myMutex01Handle);
//if(status != osOK)
//{
// log_err("Mutex delete failed");
//}
/* Create the semaphores(s) */
/* definition and creation of myBinarySem01 */
osSemaphoreDef(myBinarySem01);
myBinarySem01Handle = osSemaphoreCreate(osSemaphore(myBinarySem01), 1);
//status = osSemaphoreDelete (myBinarySem01Handle);
//if(status != osOK)
//{
// log_err("Semaphore delete failed");
//}
/* Create the queue(s) */
/* definition and creation of QueueTxMP1 */
osMessageQDef(QueueTxMP1, 128, uint8_t);
QueueTxMP1Handle = osMessageCreate(osMessageQ(QueueTxMP1), NULL);
/* definition and creation of QueueRxMP1 */
osMessageQDef(QueueRxMP1, 128, uint8_t);
QueueRxMP1Handle = osMessageCreate(osMessageQ(QueueRxMP1), NULL);
/* Create the thread(s) */
/* definition and creation of TaskIdle */
osThreadDef(TaskIdle, StartTaskIdle, osPriorityIdle, 0, 128);
TaskIdleHandle = osThreadCreate(osThread(TaskIdle), NULL);
/* definition and creation of TaskLedBlink */
osThreadDef(TaskLedBlink, StartTaskLedBlink, osPriorityNormal, 0, 128);
TaskLedBlinkHandle = osThreadCreate(osThread(TaskLedBlink), NULL);
/* definition and creation of TaskVUART0 */
osThreadDef(TaskVUART0, StartTaskVUART0, osPriorityNormal, 0, 128);
TaskVUART0Handle = osThreadCreate(osThread(TaskVUART0), NULL);
}
/**
* @brief Function implementing the TaskIdle thread.
* @param argument: Not used
* @retval None
*/
void StartTaskIdle(void const * argument)
{
/* Infinite loop */
for(;;)
{
osDelay(1);
}
}
/**
* @brief Function implementing the TaskLedBlink thread.
* @param argument: Not used
* @retval None
*/
void StartTaskLedBlink(void const * argument)
{
log_info("TaskLedBlink Started");
log_info("TaskLedBlink Initialization Complete");
/* Infinite loop */
for(;;)
{
BSP_LED_Toggle(LED7);
osDelay(100);
}
}
/**
* @brief Function implementing the TaskVUART0 thread.
* @param argument: Not used
* @retval None
*/
void StartTaskVUART0(void const * argument)
{
log_info("TaskVUART0 Started");
if (VIRT_UART_Init(&hvuart0) != VIRT_UART_OK) {
log_err("VIRT_UART_Init UART0 failed");
Error_Handler();
}
/*Need to register callback for message reception by channels*/
if (VIRT_UART_RegisterCallback(&hvuart0, VIRT_UART_RXCPLT_CB_ID,
VIRT_UART0_RxCpltCallback) != VIRT_UART_OK) {
log_err("VIRT_UART_RegisterCallback UART0 failed");
Error_Handler();
}
log_info("TaskVUART0 Initialization Complete");
/* Infinite loop */
for(;;)
{
OPENAMP_check_for_message();
if (VirtUart0RxMsg) {
VirtUart0RxMsg = RESET;
VIRT_UART_Transmit(&hvuart0, VirtUart0ChannelBuffRx, VirtUart0ChannelRxSize);
}
osDelay(1);
}
}
/* Private application code --------------------------------------------------*/
void VIRT_UART0_RxCpltCallback(VIRT_UART_HandleTypeDef *huart)
{
log_info("Msg received on VIRTUAL UART0 channel: %s", (char *) huart->pRxBuffPtr);
/* copy received msg in a variable to sent it back to master processor in main infinite loop*/
VirtUart0ChannelRxSize = huart->RxXferSize < MAX_BUFFER_SIZE? huart->RxXferSize : MAX_BUFFER_SIZE-1;
memcpy(VirtUart0ChannelBuffRx, huart->pRxBuffPtr, VirtUart0ChannelRxSize);
VirtUart0RxMsg = SET;
}
