freertos multiple task

[sachinn434]

Hi, all

I am using lpc54so18 and i am trying rtos project using multiple task but it is not running multiple task how to solve these problem 

best regards 

sachin nadugeri

/*
* Copyright (c) 2015, Freescale Semiconductor, Inc.
* Copyright 2016-2017 NXP
* All rights reserved.
*
* SPDX-License-Identifier: BSD-3-Clause
*/

/* FreeRTOS kernel includes. */
#include "FreeRTOS.h"
#include "task.h"
#include "queue.h"
#include "timers.h"

/* Freescale includes. */
#include "fsl_device_registers.h"
#include "fsl_debug_console.h"
#include "pin_mux.h"
#include "board.h"
#include "fsl_usart.h"

#include <stdbool.h>
/*******************************************************************************
* Definitions
******************************************************************************/
#define DEMO_USART USART0
#define DEMO_USART_CLK_FREQ CLOCK_GetFlexCommClkFreq(0U)
#define ECHO_BUFFER_LENGTH 10

#define USART_4 USART4
#define USART4_CLK_FREQ CLOCK_GetFlexCommClkFreq(0U)

/* Task priorities. */
#define USART0_task_PRIORITY (configMAX_PRIORITIES - 1)
#define USART1_task_PRIORITY (configMAX_PRIORITIES - 2)
#define USART2_task_PRIORITY (configMAX_PRIORITIES - 3)

/*******************************************************************************
* Prototypes
******************************************************************************/
static void USART_0(void *pvParameters);
static void USART_1(void *pvParameters);
static void USART_2(void *pvParameters);

uint8_t g_txBuffer[]={0};
uint8_t g_rxBuffer[]={0};

uint8_t g_txBuffer1[]={0};
uint8_t g_rxBuffer1[]={0};

volatile bool rxBufferEmpty = true;
volatile bool txBufferFull = false;
volatile bool txOnGoing = false;
volatile bool rxOnGoing = false;

volatile bool rxBufferEmpty1 = true;
volatile bool txBufferFull1 = false;
volatile bool txOnGoing1 = false;
volatile bool rxOnGoing1 = false;

/* USART user callback */
void USART_UserCallback(USART_Type *base, usart_handle_t *handle, status_t status, void *userData);
void USART_UserCallback1(USART_Type *base, usart_handle_t *handle, status_t status, void *userData);

usart_handle_t g_uartHandle;
usart_handle_t g_uartHandle1;

uint8_t g_tipString[] ="START please input:-\r\n";

void USART_UserCallback(USART_Type *base, usart_handle_t *handle, status_t status, void *userData)
{
//PRINTF(" USART_UserCallback done kStatus_USART_TxIdle=>%d ,status ->%d kStatus_USART_RxIdle=>%d\n",kStatus_USART_TxIdle,status,kStatus_USART_RxIdle);
userData = userData;
//PRINTF("userData %d\n",*(int*)userData);

if (kStatus_USART_TxIdle == status)
{
txBufferFull = false;
txOnGoing = false;
}

if (kStatus_USART_RxIdle == status)
{
rxBufferEmpty = false;
rxOnGoing = false;
// count=0;
}
}
void USART_UserCallback1(USART_Type *base, usart_handle_t *handle, status_t status, void *userData)
{
//PRINTF(" USART_UserCallback done kStatus_USART_TxIdle=>%d ,status ->%d kStatus_USART_RxIdle=>%d\n",kStatus_USART_TxIdle,status,kStatus_USART_RxIdle);
userData = userData;
//PRINTF("userData %d\n",*(int*)userData);

if (kStatus_USART_TxIdle == status)
{
txBufferFull1 = false;
txOnGoing1 = false;
}

if (kStatus_USART_RxIdle == status)
{
rxBufferEmpty1 = false;
rxOnGoing1 = false;
// count=0;
}
}
/*******************************************************************************
* Code
******************************************************************************/
/*!
* @brief Application entry point.
*/
int main(void)
{
/* Init board hardware. */
usart_config_t config,config1;
usart_transfer_t xfer;

/* attach 12 MHz clock to FLEXCOMM0 (debug console) */
CLOCK_AttachClk(BOARD_DEBUG_UART_CLK_ATTACH);
CLOCK_AttachClk(BOARD_DEBUG_UART4_CLK_FREQ);

BOARD_InitBootPins();
BOARD_InitBootClocks();
BOARD_InitDebugConsole();

/*
* config.baudRate_Bps = 115200U;
* config.parityMode = kUSART_ParityDisabled;
* config.stopBitCount = kUSART_OneStopBit;
* config.loopback = false;
* config.enableTx = false;
* config.enableRx = false;
*/

USART_GetDefaultConfig(&config);

config.baudRate_Bps = BOARD_DEBUG_UART_BAUDRATE;
config.enableTx = true;
config.enableRx = true;

USART_Init(DEMO_USART, &config, DEMO_USART_CLK_FREQ);
USART_TransferCreateHandle(DEMO_USART, &g_uartHandle, USART_UserCallback,
NULL);

USART_GetDefaultConfig(&config1);

config1.baudRate_Bps = BOARD_DEBUG_UART_BAUDRATE;
config1.enableTx = true;
config1.enableRx = true;

USART_Init(USART_4, &config, USART4_CLK_FREQ);
USART_TransferCreateHandle(USART_4, &g_uartHandle1, USART_UserCallback1,
NULL);

/* Send g_tipString out. */
xfer.data = g_tipString;
xfer.dataSize = sizeof(g_tipString) - 1;
txOnGoing = true;
PRINTF("\n");
USART_TransferSendNonBlocking(DEMO_USART, &g_uartHandle, &xfer);
USART_TransferSendNonBlocking(USART_4, &g_uartHandle1, &xfer);

/* Wait send finished */
while (txOnGoing)
{
}

if (xTaskCreate(USART_0, "Hello_task", configMINIMAL_STACK_SIZE + 100, NULL, USART0_task_PRIORITY, NULL) !=
pdPASS)
{
PRINTF("Task creation failed!.\r\n");
while (1)
;
}
if (xTaskCreate(USART_1, "Hello_task", configMINIMAL_STACK_SIZE + 100, NULL, USART1_task_PRIORITY, NULL) !=
pdPASS)
{
PRINTF("Task creation failed!.\r\n");
while (1)
;
}

if (xTaskCreate(USART_2, "Hello_task", configMINIMAL_STACK_SIZE + 100, NULL, USART2_task_PRIORITY, NULL) !=
pdPASS)
{
PRINTF("Task creation failed!.\r\n");
while (1)
;
}
vTaskStartScheduler();
for (;;)
;
}

/*!
* @brief Task responsible for printing of "Hello world." message.
*/
static void USART_0(void *pvParameters)
{

usart_transfer_t sendXfer;
usart_transfer_t receiveXfer;

sendXfer.data = g_txBuffer;
sendXfer.dataSize = sizeof(g_txBuffer);
receiveXfer.data = g_rxBuffer;
receiveXfer.dataSize = sizeof(g_rxBuffer);
PRINTF("start USART_0 TASK.\r\n");

for (;;)
{

/* If RX is idle and g_rxBuffer is empty, start to read data to g_rxBuffer. */
if ((!rxOnGoing) && rxBufferEmpty) {
rxOnGoing = true;
USART_TransferReceiveNonBlocking(DEMO_USART,
&g_uartHandle, &receiveXfer, NULL);

}

/* If TX is idle and g_txBuffer is full, start to send data. */
if ((!txOnGoing) && txBufferFull) {
txOnGoing = true;
status_t val = USART_TransferSendNonBlocking(DEMO_USART,
&g_uartHandle, &sendXfer);

}

/* If g_txBuffer is empty and g_rxBuffer is full, copy g_rxBuffer to g_txBuffer. */
if ((!rxBufferEmpty) && (!txBufferFull)) {
// memcpy(g_txBuffer, g_rxBuffer,ECHO_BUFFER_LENGTH );//for fixed len
memcpy(g_txBuffer, g_rxBuffer, sizeof(g_rxBuffer)); // for dynamic len
rxBufferEmpty = true;
txBufferFull = true;

}

//vTaskSuspend(NULL);
}

}

static void USART_1(void *pvParameters)
{

PRINTF("second task running.\r\n");
usart_transfer_t sendXfer1;
usart_transfer_t receiveXfer1;

sendXfer1.data = g_txBuffer1;
sendXfer1.dataSize = sizeof(g_txBuffer1);
receiveXfer1.data = g_rxBuffer1;
receiveXfer1.dataSize = sizeof(g_rxBuffer1);
PRINTF("start USART_1 TASK.\r\n");

for (;;)
{

/* If RX is idle and g_rxBuffer is empty, start to read data to g_rxBuffer. */
if ((!rxOnGoing1) && rxBufferEmpty1) {
rxOnGoing1 = true;
USART_TransferReceiveNonBlocking(DEMO_USART,
&g_uartHandle1, &receiveXfer1, NULL);

}

/* If TX is idle and g_txBuffer is full, start to send data. */
if ((!txOnGoing1) && txBufferFull1) {
txOnGoing1 = true;
status_t val = USART_TransferSendNonBlocking(DEMO_USART,
&g_uartHandle1, &sendXfer1);

}

/* If g_txBuffer is empty and g_rxBuffer is full, copy g_rxBuffer to g_txBuffer. */
if ((!rxBufferEmpty) && (!txBufferFull)) {
// memcpy(g_txBuffer, g_rxBuffer,ECHO_BUFFER_LENGTH );//for fixed len
memcpy(g_txBuffer, g_rxBuffer, sizeof(g_rxBuffer)); // for dynamic len
rxBufferEmpty = true;
txBufferFull = true;

}

// vTaskSuspend(NULL);
}

}
static void USART_2(void *pvParameters)
{
for (;;)
{
PRINTF("USART_2.\r\n");
vTaskSuspend(NULL);
}
}

[ErichStyger]

what exactly is not running or working?

I suggest that you try a simpler example: just create a single task and run it. Set a breakpoint in the task to verify it is executed.

[CarlosGarabito]

HI @sachinn434 You can find some examples of FreeRTOS that can guide you on your design on SDK  ( https://mcuxpresso.nxp.com/en/welcome)