int main( void )
{
/* Before a semaphore is used it must be explicitly created. In this example
a counting semaphore is created. The semaphore is created to have a maximum
count value of 10, and an initial count value of 0. */
xCountingSemaphore = xSemaphoreCreateCounting( 10, 0 );
/* Check the semaphore was created successfully. */
if( xCountingSemaphore != NULL )
{
/* Enable the software interrupt and set its priority. */
prvSetupSoftwareInterrupt();
/* Create the 'handler' task. This is the task that will be synchronized
with the interrupt. The handler task is created with a high priority to
ensure it runs immediately after the interrupt exits. In this case a
priority of 3 is chosen. */
xTaskCreate( vHandlerTask, "Handler", 240, NULL, 3, NULL );
/* Create the task that will periodically generate a software interrupt.
This is created with a priority below the handler task to ensure it will
get preempted each time the handler task exist the Blocked state. */
xTaskCreate( vPeriodicTask, "Periodic", 240, NULL, 1, NULL );
/* Start the scheduler so the created tasks start executing. */
vTaskStartScheduler();
}
/* If all is well we will never reach here as the scheduler will now be
running the tasks. If we do reach here then it is likely that there was
insufficient heap memory available for a resource to be created. */
for( ;; );
return 0;
}
int main( void )
{
/* Before a queue can be used it must first be created. Create both queues
used by this example. One queue can hold variables of type unsigned long,
the other queue can hold variables of type char*. Both queues can hold a
maximum of 10 items. A real application should check the return values to
ensure the queues have been successfully created. */
xIntegerQueue = xQueueCreate( 10, sizeof( unsigned long ) );
xStringQueue = xQueueCreate( 10, sizeof( char * ) );
/* Enable the software interrupt and set its priority. */
prvSetupSoftwareInterrupt();
/* Create the task that uses a queue to pass integers to the interrupt service
routine. The task is created at priority 1. */
xTaskCreate( vIntegerGenerator, "IntGen", 240, NULL, 1, NULL );
/* Create the task that prints out the strings sent to it from the interrupt
service routine. This task is created at the higher priority of 2. */
xTaskCreate( vStringPrinter, "String", 240, NULL, 2, NULL );
/* Start the scheduler so the created tasks start executing. */
vTaskStartScheduler();
/* If all is well we will never reach here as the scheduler will now be
running the tasks. If we do reach here then it is likely that there was
insufficient heap memory available for a resource to be created. */
for( ;; );
return 0;
}
int main(void)
{
/* System Initialization. */
SystemInit();
SystemCoreClockUpdate();
// Create the debug task & print example number and system core clock.
vDebugInit(12);
/* Before a semaphore is used it must be explicitly created. In this example
a binary semaphore is created. */
vSemaphoreCreateBinary(xBinarySemaphore);
/* Check the semaphore was created successfully. */
if(xBinarySemaphore != NULL)
{
/* Enable the software interrupt and set its priority. */
prvSetupSoftwareInterrupt();
/* Create the 'handler' task. This is the task that will be synchronized
with the interrupt. The handler task is created with a high priority to
ensure it runs immediately after the interrupt exits. In this case a
priority of 3 is chosen. */
xTaskCreate(vHandlerTask, (const signed char * const)"Handler", 240, NULL, 3, NULL);
/* Create the task that will periodically generate a software interrupt.
This is created with a priority below the handler task to ensure it will
get preempted each time the handler task exits the Blocked state. */
xTaskCreate(vPeriodicTask, (const signed char * const)"Periodic", 240, NULL, 1, NULL);
/* Start the scheduler so the created tasks start executing. */
vTaskStartScheduler();
}
/* If all is well we will never reach here as the scheduler will now be
running the tasks. If we do reach here then it is likely that there was
insufficient heap memory available for a resource to be created. */
while(1);
}
