FreeRTOSConfig.h parameters editing

/* A variable that is incremented by the idle task hook function. */
static unsigned long ulIdleCycleCount = 0UL;

/* Define the strings that will be passed in as the task parameters. These are
defined const and off the stack to ensure they remain valid when the tasks are
executing. */
const char *pcTextForTask1 = "Task 1 is running\r\n";
const char *pcTextForTask2 = "Task 2 is running\t\n";

/*-----------------------------------------------------------*/

void setup()
{
/* Create the first task at priority 1... */
xTaskCreate( vTaskFunction, "Task 1", 1000, (void*)pcTextForTask1, 1, NULL );

/* ... and the second task at priority 2. The priority is the second to
last parameter. */
xTaskCreate( vTaskFunction, "Task 2", 1000, (void*)pcTextForTask2, 2, NULL );

/* Start the scheduler so our tasks start executing. */
vTaskStartScheduler();

for( ;; );
}
void loop() {}

void vTaskFunction( void *pvParameters )
{
char *pcTaskName;

/* The string to print out is passed in via the parameter. Cast this to a
character pointer. */
pcTaskName = ( char * ) pvParameters;

/* As per most tasks, this task is implemented in an infinite loop. */
for( ;; )
{
/* Print out the name of this task AND the number of times ulIdleCycleCount
has been incremented. */
Serial.println(pcTaskName);
Serial.println(ulIdleCycleCount);

/* Delay for a period. This time we use a call to vTaskDelay() which
puts the task into the Blocked state until the delay period has expired.
The delay period is specified in 'ticks'. */
vTaskDelay( 250 / portTICK_RATE_MS );
}
}
/*-----------------------------------------------------------*/

/* Idle hook functions MUST be called vApplicationIdleHook(), take no parameters,
and return void. */
void vApplicationIdleHook( void )
{
/* This hook function does nothing but increment a counter. */
ulIdleCycleCount++;
}

/* The task function. */
void vTaskFunction( void *pvParameters );

/* A variable that is incremented by the idle task hook function. */
static uint32_t ulIdleCycleCount = 0UL;

const char *pcTextForTask1 = "\n\rTask 1 is running, ulIdleCycleCount = ";
const char *pcTextForTask2 = "\n\rTask 2 is running, ulIdleCycleCount = ";

extern "C" void vApplicationIdleHook( void )
{
/* This hook function does nothing but increment a counter. */
ulIdleCycleCount++;
}

void vTaskFunction( void *pvParameters )
{
char *pcTaskName;
const TickType_t xDelay250ms = pdMS_TO_TICKS( 1UL );
/* The string to print out is passed in via the parameter. Cast this to a
character pointer. */
pcTaskName = ( char * ) pvParameters;
/* As per most tasks, this task is implemented in an infinite loop. */
for( ;; )
{
/* Print out the name of this task AND the number of times ulIdleCycleCount
has been incremented. */
Serial.print(pcTaskName);
Serial.print(ulIdleCycleCount);

/* Delay for a period of 250 milliseconds. */
digitalWrite(pinLED, HIGH);
vTaskDelay( xDelay250ms );
digitalWrite(pinLED, LOW);
vTaskDelay( xDelay250ms );
}
}

void setup()
{
// initialize the digital pin as an output:
pinMode(pinLED, OUTPUT);
Serial.begin(921600); //For Olimex Maple

// Now set up two tasks to run independently.
xTaskCreate(
vTaskFunction /* Pointer to the function that implements the task. */
, (const portCHAR *) "Task 1" /* Text name for the task. This is to facilitate debugging only. */
, configMINIMAL_STACK_SIZE /* Stack depth - most small microcontrollers will use much less stack than this. */
, (void*)pcTextForTask1 /* Pass the text to be printed into the task using the task parameter. */
, tskIDLE_PRIORITY + 1 /* Priority, with 3 (configMAX_PRIORITIES - 1) being the highest, and 0 being the lowest.*/
, NULL );/* We are not using the task handle. */

xTaskCreate(
vTaskFunction /* Pointer to the function that implements the task. */
, (const portCHAR *) "Task 2" /* Text name for the task. This is to facilitate debugging only. */
, configMINIMAL_STACK_SIZE /* Stack depth - most small microcontrollers will use much less stack than this. */
, (void*)pcTextForTask2 /* Pass the text to be printed into the task using the task parameter. */
, tskIDLE_PRIORITY + 1 /* Change priority looks at what happens*/
, NULL );/* We are not using the task handle. */

// Now the task scheduler, which takes over control of scheduling individual tasks, is automatically started.
vTaskStartScheduler();
/* If all is well we will never reach here as the scheduler will now be
running. If we do reach here then it is likely that there was insufficient
heap available for the idle task to be created. */
for( ;; );
}

void loop()
{
// Insert background code here
}