Add third_party libs

1 files changed, 383 insertions, 0 deletions

diff --git a/third_party/FreeRTOS/Demo/Common/Minimal/flop.c b/third_party/FreeRTOS/Demo/Common/Minimal/flop.c
new file mode 100644
index 0000000..e45ec64
--- /dev/null
+++ b/third_party/FreeRTOS/Demo/Common/Minimal/flop.c
@@ -0,0 +1,383 @@
+/*

+    FreeRTOS V7.6.0 - Copyright (C) 2013 Real Time Engineers Ltd. 

+    All rights reserved

+

+    VISIT http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION.

+

+    ***************************************************************************

+     *                                                                       *

+     *    FreeRTOS provides completely free yet professionally developed,    *

+     *    robust, strictly quality controlled, supported, and cross          *

+     *    platform software that has become a de facto standard.             *

+     *                                                                       *

+     *    Help yourself get started quickly and support the FreeRTOS         *

+     *    project by purchasing a FreeRTOS tutorial book, reference          *

+     *    manual, or both from: http://www.FreeRTOS.org/Documentation        *

+     *                                                                       *

+     *    Thank you!                                                         *

+     *                                                                       *

+    ***************************************************************************

+

+    This file is part of the FreeRTOS distribution.

+

+    FreeRTOS is free software; you can redistribute it and/or modify it under

+    the terms of the GNU General Public License (version 2) as published by the

+    Free Software Foundation >>!AND MODIFIED BY!<< the FreeRTOS exception.

+

+    >>! NOTE: The modification to the GPL is included to allow you to distribute

+    >>! a combined work that includes FreeRTOS without being obliged to provide

+    >>! the source code for proprietary components outside of the FreeRTOS

+    >>! kernel.

+

+    FreeRTOS is distributed in the hope that it will be useful, but WITHOUT ANY

+    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

+    FOR A PARTICULAR PURPOSE.  Full license text is available from the following

+    link: http://www.freertos.org/a00114.html

+

+    1 tab == 4 spaces!

+

+    ***************************************************************************

+     *                                                                       *

+     *    Having a problem?  Start by reading the FAQ "My application does   *

+     *    not run, what could be wrong?"                                     *

+     *                                                                       *

+     *    http://www.FreeRTOS.org/FAQHelp.html                               *

+     *                                                                       *

+    ***************************************************************************

+

+    http://www.FreeRTOS.org - Documentation, books, training, latest versions,

+    license and Real Time Engineers Ltd. contact details.

+

+    http://www.FreeRTOS.org/plus - A selection of FreeRTOS ecosystem products,

+    including FreeRTOS+Trace - an indispensable productivity tool, a DOS

+    compatible FAT file system, and our tiny thread aware UDP/IP stack.

+

+    http://www.OpenRTOS.com - Real Time Engineers ltd license FreeRTOS to High

+    Integrity Systems to sell under the OpenRTOS brand.  Low cost OpenRTOS

+    licenses offer ticketed support, indemnification and middleware.

+

+    http://www.SafeRTOS.com - High Integrity Systems also provide a safety

+    engineered and independently SIL3 certified version for use in safety and

+    mission critical applications that require provable dependability.

+

+    1 tab == 4 spaces!

+*/

+

+/*

+ * Creates eight tasks, each of which loops continuously performing a floating 

+ * point calculation.

+ *

+ * All the tasks run at the idle priority and never block or yield.  This causes

+ * all eight tasks to time slice with the idle task.  Running at the idle 

+ * priority means that these tasks will get pre-empted any time another task is 

+ * ready to run or a time slice occurs.  More often than not the pre-emption 

+ * will occur mid calculation, creating a good test of the schedulers context 

+ * switch mechanism - a calculation producing an unexpected result could be a 

+ * symptom of a corruption in the context of a task.

+ */

+

+#include <stdlib.h>

+#include <math.h>

+

+/* Scheduler include files. */

+#include "FreeRTOS.h"

+#include "task.h"

+

+/* Demo program include files. */

+#include "flop.h"

+

+#define mathSTACK_SIZE		configMINIMAL_STACK_SIZE

+#define mathNUMBER_OF_TASKS  ( 4 )

+

+/* Four tasks, each of which performs a different floating point calculation.

+Each of the four is created twice. */

+static portTASK_FUNCTION_PROTO( vCompetingMathTask1, pvParameters );

+static portTASK_FUNCTION_PROTO( vCompetingMathTask2, pvParameters );

+static portTASK_FUNCTION_PROTO( vCompetingMathTask3, pvParameters );

+static portTASK_FUNCTION_PROTO( vCompetingMathTask4, pvParameters );

+

+/* These variables are used to check that all the tasks are still running.  If a

+task gets a calculation wrong it will stop setting its check variable. */

+static volatile unsigned short usTaskCheck[ mathNUMBER_OF_TASKS ] = { ( unsigned short ) 0 };

+

+/*-----------------------------------------------------------*/

+

+void vStartMathTasks( unsigned portBASE_TYPE uxPriority )

+{

+	xTaskCreate( vCompetingMathTask1, ( signed char * ) "Math1", mathSTACK_SIZE, ( void * ) &( usTaskCheck[ 0 ] ), uxPriority, NULL );

+	xTaskCreate( vCompetingMathTask2, ( signed char * ) "Math2", mathSTACK_SIZE, ( void * ) &( usTaskCheck[ 1 ] ), uxPriority, NULL );

+	xTaskCreate( vCompetingMathTask3, ( signed char * ) "Math3", mathSTACK_SIZE, ( void * ) &( usTaskCheck[ 2 ] ), uxPriority, NULL );

+	xTaskCreate( vCompetingMathTask4, ( signed char * ) "Math4", mathSTACK_SIZE, ( void * ) &( usTaskCheck[ 3 ] ), uxPriority, NULL );

+}

+/*-----------------------------------------------------------*/

+

+static portTASK_FUNCTION( vCompetingMathTask1, pvParameters )

+{

+volatile portDOUBLE d1, d2, d3, d4;

+volatile unsigned short *pusTaskCheckVariable;

+volatile portDOUBLE dAnswer;

+short sError = pdFALSE;

+

+	/* Some ports require that tasks that use a hardware floating point unit

+	tell the kernel that they require a floating point context before any

+	floating point instructions are executed. */

+	portTASK_USES_FLOATING_POINT();

+

+	d1 = 123.4567;

+	d2 = 2345.6789;

+	d3 = -918.222;

+

+	dAnswer = ( d1 + d2 ) * d3;

+

+	/* The variable this task increments to show it is still running is passed in

+	as the parameter. */

+	pusTaskCheckVariable = ( unsigned short * ) pvParameters;

+

+	/* Keep performing a calculation and checking the result against a constant. */

+	for(;;)

+	{

+		d1 = 123.4567;

+		d2 = 2345.6789;

+		d3 = -918.222;

+

+		d4 = ( d1 + d2 ) * d3;

+

+		#if configUSE_PREEMPTION == 0

+			taskYIELD();

+		#endif

+

+		/* If the calculation does not match the expected constant, stop the

+		increment of the check variable. */

+		if( fabs( d4 - dAnswer ) > 0.001 )

+		{

+			sError = pdTRUE;

+		}

+

+		if( sError == pdFALSE )

+		{

+			/* If the calculation has always been correct then set set the check

+			variable.  The check variable will get set to pdFALSE each time

+			xAreMathsTaskStillRunning() is executed. */

+			( *pusTaskCheckVariable ) = pdTRUE;

+		}

+

+		#if configUSE_PREEMPTION == 0

+			taskYIELD();

+		#endif

+

+	}

+}

+/*-----------------------------------------------------------*/

+

+static portTASK_FUNCTION( vCompetingMathTask2, pvParameters )

+{

+volatile portDOUBLE d1, d2, d3, d4;

+volatile unsigned short *pusTaskCheckVariable;

+volatile portDOUBLE dAnswer;

+short sError = pdFALSE;

+

+	/* Some ports require that tasks that use a hardware floating point unit

+	tell the kernel that they require a floating point context before any

+	floating point instructions are executed. */

+	portTASK_USES_FLOATING_POINT();

+

+	d1 = -389.38;

+	d2 = 32498.2;

+	d3 = -2.0001;

+

+	dAnswer = ( d1 / d2 ) * d3;

+

+

+	/* The variable this task increments to show it is still running is passed in

+	as the parameter. */

+	pusTaskCheckVariable = ( unsigned short * ) pvParameters;

+

+	/* Keep performing a calculation and checking the result against a constant. */

+	for( ;; )

+	{

+		d1 = -389.38;

+		d2 = 32498.2;

+		d3 = -2.0001;

+

+		d4 = ( d1 / d2 ) * d3;

+

+		#if configUSE_PREEMPTION == 0

+			taskYIELD();

+		#endif

+

+		/* If the calculation does not match the expected constant, stop the

+		increment of the check variable. */

+		if( fabs( d4 - dAnswer ) > 0.001 )

+		{

+			sError = pdTRUE;

+		}

+

+		if( sError == pdFALSE )

+		{

+			/* If the calculation has always been correct then set set the check

+			variable.  The check variable will get set to pdFALSE each time

+			xAreMathsTaskStillRunning() is executed. */

+			( *pusTaskCheckVariable ) = pdTRUE;

+		}

+

+		#if configUSE_PREEMPTION == 0

+			taskYIELD();

+		#endif

+	}

+}

+/*-----------------------------------------------------------*/

+

+static portTASK_FUNCTION( vCompetingMathTask3, pvParameters )

+{

+volatile portDOUBLE *pdArray, dTotal1, dTotal2, dDifference;

+volatile unsigned short *pusTaskCheckVariable;

+const size_t xArraySize = 10;

+size_t xPosition;

+short sError = pdFALSE;

+

+	/* Some ports require that tasks that use a hardware floating point unit

+	tell the kernel that they require a floating point context before any

+	floating point instructions are executed. */

+	portTASK_USES_FLOATING_POINT();

+

+	/* The variable this task increments to show it is still running is passed in

+	as the parameter. */

+	pusTaskCheckVariable = ( unsigned short * ) pvParameters;

+

+	pdArray = ( portDOUBLE * ) pvPortMalloc( xArraySize * sizeof( portDOUBLE ) );

+

+	/* Keep filling an array, keeping a running total of the values placed in the

+	array.  Then run through the array adding up all the values.  If the two totals

+	do not match, stop the check variable from incrementing. */

+	for( ;; )

+	{

+		dTotal1 = 0.0;

+		dTotal2 = 0.0;

+

+		for( xPosition = 0; xPosition < xArraySize; xPosition++ )

+		{

+			pdArray[ xPosition ] = ( portDOUBLE ) xPosition + 5.5;

+			dTotal1 += ( portDOUBLE ) xPosition + 5.5;

+		}

+

+		#if configUSE_PREEMPTION == 0

+			taskYIELD();

+		#endif

+

+		for( xPosition = 0; xPosition < xArraySize; xPosition++ )

+		{

+			dTotal2 += pdArray[ xPosition ];

+		}

+

+		dDifference = dTotal1 - dTotal2;

+		if( fabs( dDifference ) > 0.001 )

+		{

+			sError = pdTRUE;

+		}

+

+		#if configUSE_PREEMPTION == 0

+			taskYIELD();

+		#endif

+

+		if( sError == pdFALSE )

+		{

+			/* If the calculation has always been correct then set set the check

+			variable.  The check variable will get set to pdFALSE each time

+			xAreMathsTaskStillRunning() is executed. */

+			( *pusTaskCheckVariable ) = pdTRUE;

+		}

+	}

+}

+/*-----------------------------------------------------------*/

+

+static portTASK_FUNCTION( vCompetingMathTask4, pvParameters )

+{

+volatile portDOUBLE *pdArray, dTotal1, dTotal2, dDifference;

+volatile unsigned short *pusTaskCheckVariable;

+const size_t xArraySize = 10;

+size_t xPosition;

+short sError = pdFALSE;

+

+	/* Some ports require that tasks that use a hardware floating point unit

+	tell the kernel that they require a floating point context before any

+	floating point instructions are executed. */

+	portTASK_USES_FLOATING_POINT();

+

+	/* The variable this task increments to show it is still running is passed in

+	as the parameter. */

+	pusTaskCheckVariable = ( unsigned short * ) pvParameters;

+

+	pdArray = ( portDOUBLE * ) pvPortMalloc( xArraySize * sizeof( portDOUBLE ) );

+

+	/* Keep filling an array, keeping a running total of the values placed in the

+	array.  Then run through the array adding up all the values.  If the two totals

+	do not match, stop the check variable from incrementing. */

+	for( ;; )

+	{

+		dTotal1 = 0.0;

+		dTotal2 = 0.0;

+

+		for( xPosition = 0; xPosition < xArraySize; xPosition++ )

+		{

+			pdArray[ xPosition ] = ( portDOUBLE ) xPosition * 12.123;

+			dTotal1 += ( portDOUBLE ) xPosition * 12.123;

+		}

+

+		#if configUSE_PREEMPTION == 0

+			taskYIELD();

+		#endif

+

+		for( xPosition = 0; xPosition < xArraySize; xPosition++ )

+		{

+			dTotal2 += pdArray[ xPosition ];

+		}

+

+		dDifference = dTotal1 - dTotal2;

+		if( fabs( dDifference ) > 0.001 )

+		{

+			sError = pdTRUE;

+		}

+

+		#if configUSE_PREEMPTION == 0

+			taskYIELD();

+		#endif

+

+		if( sError == pdFALSE )

+		{

+			/* If the calculation has always been correct then set set the check

+			variable.  The check variable will get set to pdFALSE each time

+			xAreMathsTaskStillRunning() is executed. */

+			( *pusTaskCheckVariable ) = pdTRUE;

+		}

+	}

+}

+/*-----------------------------------------------------------*/

+

+/* This is called to check that all the created tasks are still running. */

+portBASE_TYPE xAreMathsTaskStillRunning( void )

+{

+portBASE_TYPE xReturn = pdPASS, xTask;

+

+	/* Check the maths tasks are still running by ensuring their check variables

+	have been set to pdPASS. */

+	for( xTask = 0; xTask < mathNUMBER_OF_TASKS; xTask++ )

+	{

+		if( usTaskCheck[ xTask ] != pdTRUE )

+		{

+			/* The check has not been set so the associated task has either

+			stalled or detected an error. */

+			xReturn = pdFAIL;

+		}

+		else

+		{

+			/* Reset the variable so it can be checked again the next time this

+			function is executed. */

+			usTaskCheck[ xTask ] = pdFALSE;

+		}

+	}

+		

+	return xReturn;

+}

+

+

+