add modbus slave support

add modbus slave support

components/connectivity/Modbus/3rdparty/freemodbus-v1.6/demo/STR71XTCP/freertos/include/FreeRTOS.h

@@ -0,0 +1,111 @@
+/*
+
+	FreeRTOS.org V4.1.0 - Copyright (C) 2003-2006 Richard Barry.
+
+
+
+	This file is part of the FreeRTOS.org distribution.
+
+
+
+	FreeRTOS.org is free software; you can redistribute it and/or modify
+
+	it under the terms of the GNU General Public License as published by
+
+	the Free Software Foundation; either version 2 of the License, or
+
+	(at your option) any later version.
+
+
+
+	FreeRTOS.org 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.  See the
+
+	GNU General Public License for more details.
+
+
+
+	You should have received a copy of the GNU General Public License
+
+	along with FreeRTOS.org; if not, write to the Free Software
+
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+
+
+	A special exception to the GPL can be applied should you wish to distribute
+
+	a combined work that includes FreeRTOS.org, without being obliged to provide
+
+	the source code for any proprietary components.  See the licensing section 
+
+	of http://www.FreeRTOS.org for full details of how and when the exception
+
+	can be applied.
+
+
+
+	***************************************************************************
+
+	See http://www.FreeRTOS.org for documentation, latest information, license 
+
+	and contact details.  Please ensure to read the configuration and relevant 
+
+	port sections of the online documentation.
+
+	***************************************************************************
+
+*/
+
+
+
+#ifndef INC_FREERTOS_H
+
+#define INC_FREERTOS_H
+
+
+
+
+
+/* 
+
+ * Include the generic headers required for the FreeRTOS port being used. 
+
+ */
+
+#include <stddef.h>
+
+
+
+/* Basic FreeRTOS definitions. */
+
+#include "projdefs.h"
+
+
+
+/* Application specific configuration options. */
+
+#include "FreeRTOSConfig.h"
+
+
+
+/* Definitions specific to the port being used. */
+
+#include "portable.h"
+
+
+
+
+
+
+
+
+
+
+
+
+
+

components/connectivity/Modbus/3rdparty/freemodbus-v1.6/demo/STR71XTCP/freertos/include/croutine.h

@@ -0,0 +1,713 @@
+/*
+
+	FreeRTOS.org V4.1.0 - Copyright (C) 2003-2006 Richard Barry.
+
+
+
+	This file is part of the FreeRTOS.org distribution.
+
+
+
+	FreeRTOS.org is free software; you can redistribute it and/or modify
+
+	it under the terms of the GNU General Public License as published by
+
+	the Free Software Foundation; either version 2 of the License, or
+
+	(at your option) any later version.
+
+
+
+	FreeRTOS.org 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.  See the
+
+	GNU General Public License for more details.
+
+
+
+	You should have received a copy of the GNU General Public License
+
+	along with FreeRTOS.org; if not, write to the Free Software
+
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+
+
+	A special exception to the GPL can be applied should you wish to distribute
+
+	a combined work that includes FreeRTOS.org, without being obliged to provide
+
+	the source code for any proprietary components.  See the licensing section
+
+	of http://www.FreeRTOS.org for full details of how and when the exception
+
+	can be applied.
+
+
+
+	***************************************************************************
+
+	See http://www.FreeRTOS.org for documentation, latest information, license
+
+	and contact details.  Please ensure to read the configuration and relevant
+
+	port sections of the online documentation.
+
+	***************************************************************************
+
+*/
+
+#ifndef CO_ROUTINE_H
+
+#define CO_ROUTINE_H
+
+
+
+#include "list.h"
+
+
+
+/* Used to hide the implementation of the co-routine control block.  The
+
+control block structure however has to be included in the header due to
+
+the macro implementation of the co-routine functionality. */
+
+typedef void * xCoRoutineHandle;
+
+
+
+/* Defines the prototype to which co-routine functions must conform. */
+
+typedef void (*crCOROUTINE_CODE)( xCoRoutineHandle, unsigned portBASE_TYPE );
+
+
+
+typedef struct corCoRoutineControlBlock
+
+{
+
+	crCOROUTINE_CODE 		pxCoRoutineFunction;
+
+	xListItem				xGenericListItem;	/*< List item used to place the CRCB in ready and blocked queues. */
+
+	xListItem				xEventListItem;		/*< List item used to place the CRCB in event lists. */
+
+	unsigned portBASE_TYPE 	uxPriority;			/*< The priority of the co-routine in relation to other co-routines. */
+
+	unsigned portBASE_TYPE 	uxIndex;			/*< Used to distinguish between co-routines when multiple co-routines use the same co-routine function. */
+
+	unsigned portSHORT 		uxState;			/*< Used internally by the co-routine implementation. */
+
+} corCRCB; /* Co-routine control block.  Note must be identical in size down to uxPriority with tskTCB. */
+
+
+
+/**
+
+ * croutine. h
+
+ *<pre>
+
+ portBASE_TYPE xCoRoutineCreate(
+
+                                 crCOROUTINE_CODE pxCoRoutineCode,
+
+                                 unsigned portBASE_TYPE uxPriority,
+
+                                 unsigned portBASE_TYPE uxIndex
+
+                               );</pre>
+
+ *
+
+ * Create a new co-routine and add it to the list of co-routines that are
+
+ * ready to run.
+
+ *
+
+ * @param pxCoRoutineCode Pointer to the co-routine function.  Co-routine
+
+ * functions require special syntax - see the co-routine section of the WEB
+
+ * documentation for more information.
+
+ *
+
+ * @param uxPriority The priority with respect to other co-routines at which
+
+ *  the co-routine will run.
+
+ *
+
+ * @param uxIndex Used to distinguish between different co-routines that
+
+ * execute the same function.  See the example below and the co-routine section
+
+ * of the WEB documentation for further information.
+
+ *
+
+ * @return pdPASS if the co-routine was successfully created and added to a ready
+
+ * list, otherwise an error code defined with ProjDefs.h.
+
+ *
+
+ * Example usage:
+
+   <pre>
+
+ // Co-routine to be created.
+
+ void vFlashCoRoutine( xCoRoutineHandle xHandle, unsigned portBASE_TYPE uxIndex )
+
+ {
+
+ // Variables in co-routines must be declared static if they must maintain value across a blocking call.
+
+ // This may not be necessary for const variables.
+
+ static const char cLedToFlash[ 2 ] = { 5, 6 };
+
+ static const portTickType xTimeToDelay[ 2 ] = { 200, 400 };
+
+
+
+     // Must start every co-routine with a call to crSTART();
+
+     crSTART( xHandle );
+
+
+
+     for( ;; )
+
+     {
+
+         // This co-routine just delays for a fixed period, then toggles
+
+         // an LED.  Two co-routines are created using this function, so
+
+         // the uxIndex parameter is used to tell the co-routine which
+
+         // LED to flash and how long to delay.  This assumes xQueue has
+
+         // already been created.
+
+         vParTestToggleLED( cLedToFlash[ uxIndex ] );
+
+         crDELAY( xHandle, uxFlashRates[ uxIndex ] );
+
+     }
+
+
+
+     // Must end every co-routine with a call to crEND();
+
+     crEND();
+
+ }
+
+
+
+ // Function that creates two co-routines.
+
+ void vOtherFunction( void )
+
+ {
+
+ unsigned char ucParameterToPass;
+
+ xTaskHandle xHandle;
+
+		
+
+     // Create two co-routines at priority 0.  The first is given index 0
+
+     // so (from the code above) toggles LED 5 every 200 ticks.  The second
+
+     // is given index 1 so toggles LED 6 every 400 ticks.
+
+     for( uxIndex = 0; uxIndex < 2; uxIndex++ )
+
+     {
+
+         xCoRoutineCreate( vFlashCoRoutine, 0, uxIndex );
+
+     }
+
+ }
+
+   </pre>
+
+ * \defgroup xCoRoutineCreate xCoRoutineCreate
+
+ * \ingroup Tasks
+
+ */
+
+signed portBASE_TYPE xCoRoutineCreate( crCOROUTINE_CODE pxCoRoutineCode, unsigned portBASE_TYPE uxPriority, unsigned portBASE_TYPE uxIndex );
+
+
+
+
+
+/**
+
+ * croutine. h
+
+ *<pre>
+
+ void vCoRoutineSchedule( void );</pre>
+
+ *
+
+ * Run a co-routine.
+
+ *
+
+ * vCoRoutineSchedule() executes the highest priority co-routine that is able
+
+ * to run.  The co-routine will execute until it either blocks, yields or is
+
+ * preempted by a task.  Co-routines execute cooperatively so one
+
+ * co-routine cannot be preempted by another, but can be preempted by a task.
+
+ *
+
+ * If an application comprises of both tasks and co-routines then
+
+ * vCoRoutineSchedule should be called from the idle task (in an idle task
+
+ * hook).
+
+ *
+
+ * Example usage:
+
+   <pre>
+
+ // This idle task hook will schedule a co-routine each time it is called.
+
+ // The rest of the idle task will execute between co-routine calls.
+
+ void vApplicationIdleHook( void )
+
+ {
+
+	vCoRoutineSchedule();
+
+ }
+
+
+
+ // Alternatively, if you do not require any other part of the idle task to
+
+ // execute, the idle task hook can call vCoRoutineScheduler() within an
+
+ // infinite loop.
+
+ void vApplicationIdleHook( void )
+
+ {
+
+    for( ;; )
+
+    {
+
+        vCoRoutineSchedule();
+
+    }
+
+ }
+
+ </pre>
+
+ * \defgroup vCoRoutineSchedule vCoRoutineSchedule
+
+ * \ingroup Tasks
+
+ */
+
+void vCoRoutineSchedule( void );
+
+
+
+/**
+
+ * croutine. h
+
+ * <pre>
+
+ crSTART( xCoRoutineHandle xHandle );</pre>
+
+ *
+
+ * This macro MUST always be called at the start of a co-routine function.
+
+ *
+
+ * Example usage:
+
+   <pre>
+
+ // Co-routine to be created.
+
+ void vACoRoutine( xCoRoutineHandle xHandle, unsigned portBASE_TYPE uxIndex )
+
+ {
+
+ // Variables in co-routines must be declared static if they must maintain value across a blocking call.
+
+ static portLONG ulAVariable;
+
+
+
+     // Must start every co-routine with a call to crSTART();
+
+     crSTART( xHandle );
+
+
+
+     for( ;; )
+
+     {
+
+          // Co-routine functionality goes here.
+
+     }
+
+
+
+     // Must end every co-routine with a call to crEND();
+
+     crEND();
+
+ }</pre>
+
+ * \defgroup crSTART crSTART
+
+ * \ingroup Tasks
+
+ */
+
+#define crSTART( pxCRCB ) switch( ( ( corCRCB * )pxCRCB )->uxState ) { case 0:
+
+
+
+/**
+
+ * croutine. h
+
+ * <pre>
+
+ crEND();</pre>
+
+ *
+
+ * This macro MUST always be called at the end of a co-routine function.
+
+ *
+
+ * Example usage:
+
+   <pre>
+
+ // Co-routine to be created.
+
+ void vACoRoutine( xCoRoutineHandle xHandle, unsigned portBASE_TYPE uxIndex )
+
+ {
+
+ // Variables in co-routines must be declared static if they must maintain value across a blocking call.
+
+ static portLONG ulAVariable;
+
+
+
+     // Must start every co-routine with a call to crSTART();
+
+     crSTART( xHandle );
+
+
+
+     for( ;; )
+
+     {
+
+          // Co-routine functionality goes here.
+
+     }
+
+
+
+     // Must end every co-routine with a call to crEND();
+
+     crEND();
+
+ }</pre>
+
+ * \defgroup crSTART crSTART
+
+ * \ingroup Tasks
+
+ */
+
+#define crEND() }
+
+
+
+/*
+
+ * These macros are intended for internal use by the co-routine implementation
+
+ * only.  The macros should not be used directly by application writers.
+
+ */
+
+#define crSET_STATE0( xHandle ) ( ( corCRCB * )xHandle)->uxState = (__LINE__ * 2); return; case (__LINE__ * 2):
+
+#define crSET_STATE1( xHandle ) ( ( corCRCB * )xHandle)->uxState = ((__LINE__ * 2)+1); return; case ((__LINE__ * 2)+1):
+
+
+
+/**
+
+ * croutine. h
+
+ *<pre>
+
+ crDELAY( xCoRoutineHandle xHandle, portTickType xTicksToDelay );</pre>
+
+ *
+
+ * Delay a co-routine for a fixed period of time.
+
+ *
+
+ * crDELAY can only be called from the co-routine function itself - not
+
+ * from within a function called by the co-routine function.  This is because
+
+ * co-routines do not maintain their own stack.
+
+ *
+
+ * @param xHandle The handle of the co-routine to delay.  This is the xHandle
+
+ * parameter of the co-routine function.
+
+ *
+
+ * @param xTickToDelay The number of ticks that the co-routine should delay
+
+ * for.  The actual amount of time this equates to is defined by
+
+ * configTICK_RATE_HZ (set in FreeRTOSConfig.h).  The constant portTICK_RATE_MS
+
+ * can be used to convert ticks to milliseconds.
+
+ *
+
+ * Example usage:
+
+   <pre>
+
+ // Co-routine to be created.
+
+ void vACoRoutine( xCoRoutineHandle xHandle, unsigned portBASE_TYPE uxIndex )
+
+ {
+
+ // Variables in co-routines must be declared static if they must maintain value across a blocking call.
+
+ // This may not be necessary for const variables.
+
+ // We are to delay for 200ms.
+
+ static const xTickType xDelayTime = 200 / portTICK_RATE_MS;
+
+
+
+     // Must start every co-routine with a call to crSTART();
+
+     crSTART( xHandle );
+
+
+
+     for( ;; )
+
+     {
+
+        // Delay for 200ms.
+
+        crDELAY( xHandle, xDelayTime );
+
+
+
+        // Do something here.
+
+     }
+
+
+
+     // Must end every co-routine with a call to crEND();
+
+     crEND();
+
+ }</pre>
+
+ * \defgroup crDELAY crDELAY
+
+ * \ingroup Tasks
+
+ */
+
+#define crDELAY( xHandle, xTicksToDelay )												\
+
+	if( xTicksToDelay > 0 )																\
+
+	{																					\
+
+		vCoRoutineAddToDelayedList( xTicksToDelay, NULL );								\
+
+	}																					\
+
+	crSET_STATE0( xHandle );
+
+
+
+/**
+
+ * <pre>
+
+ crQUEUE_SEND(
+
+                  xCoRoutineHandle xHandle,
+
+                  xQueueHandle pxQueue,
+
+                  void *pvItemToQueue,
+
+                  portTickType xTicksToWait,
+
+                  portBASE_TYPE *pxResult
+
+             )</pre>
+
+ *
+
+ * The macro's crQUEUE_SEND() and crQUEUE_RECEIVE() are the co-routine
+
+ * equivalent to the xQueueSend() and xQueueReceive() functions used by tasks.
+
+ *
+
+ * crQUEUE_SEND and crQUEUE_RECEIVE can only be used from a co-routine whereas
+
+ * xQueueSend() and xQueueReceive() can only be used from tasks.
+
+ *
+
+ * crQUEUE_SEND can only be called from the co-routine function itself - not
+
+ * from within a function called by the co-routine function.  This is because
+
+ * co-routines do not maintain their own stack.
+
+ *
+
+ * See the co-routine section of the WEB documentation for information on
+
+ * passing data between tasks and co-routines and between ISR's and
+
+ * co-routines.
+
+ *
+
+ * @param xHandle The handle of the calling co-routine.  This is the xHandle
+
+ * parameter of the co-routine function.
+
+ *
+
+ * @param pxQueue The handle of the queue on which the data will be posted.
+
+ * The handle is obtained as the return value when the queue is created using
+
+ * the xQueueCreate() API function.
+
+ *
+
+ * @param pvItemToQueue A pointer to the data being posted onto the queue.
+
+ * The number of bytes of each queued item is specified when the queue is
+
+ * created.  This number of bytes is copied from pvItemToQueue into the queue
+
+ * itself.
+
+ *
+
+ * @param xTickToDelay The number of ticks that the co-routine should block
+
+ * to wait for space to become available on the queue, should space not be
+
+ * available immediately. The actual amount of time this equates to is defined
+
+ * by configTICK_RATE_HZ (set in FreeRTOSConfig.h).  The constant
+
+ * portTICK_RATE_MS can be used to convert ticks to milliseconds (see example
+
+ * below).
+
+ *
+
+ * @param pxResult The variable pointed to by pxResult will be set to pdPASS if
+
+ * data was successfully posted onto the queue, otherwise it will be set to an
+
+ * error defined within ProjDefs.h.
+
+ *
+
+ * Example usage:
+
+   <pre>
+
+ // Co-routine function that blocks for a fixed period then posts a number onto
+
+ // a queue.
+
+ static void prvCoRoutineFlashTask( xCoRoutineHandle xHandle, unsigned portBASE_TYPE uxIndex )
+
+ {
+
+ // Variables in co-routines must be declared static if they must maintain value across a blocking call.
+
+ static portBASE_TYPE xNumberToPost = 0;
+
+ static portBASE_TYPE xResult;
+
+
+
+    // Co-routines must begin with a call to crSTART().
+
+    crSTART( xHandle );
+
+
+
+    for( ;; )
+
+    {
+
+        // This assumes the queue has already been created.
+
+        crQUEUE_SEND( xHandle, xCoRoutineQueue, &xNumberToPost, NO_DELAY, &xResult );
+
+

components/connectivity/Modbus/3rdparty/freemodbus-v1.6/demo/STR71XTCP/freertos/include/list.h

@@ -0,0 +1,270 @@
+/*
+
+	FreeRTOS.org V4.1.0 - Copyright (C) 2003-2006 Richard Barry.
+
+
+
+	This file is part of the FreeRTOS.org distribution.
+
+
+
+	FreeRTOS.org is free software; you can redistribute it and/or modify
+
+	it under the terms of the GNU General Public License as published by
+
+	the Free Software Foundation; either version 2 of the License, or
+
+	(at your option) any later version.
+
+
+
+	FreeRTOS.org 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.  See the
+
+	GNU General Public License for more details.
+
+
+
+	You should have received a copy of the GNU General Public License
+
+	along with FreeRTOS.org; if not, write to the Free Software
+
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+
+
+	A special exception to the GPL can be applied should you wish to distribute
+
+	a combined work that includes FreeRTOS.org, without being obliged to provide
+
+	the source code for any proprietary components.  See the licensing section
+
+	of http://www.FreeRTOS.org for full details of how and when the exception
+
+	can be applied.
+
+
+
+	***************************************************************************
+
+	See http://www.FreeRTOS.org for documentation, latest information, license
+
+	and contact details.  Please ensure to read the configuration and relevant
+
+	port sections of the online documentation.
+
+	***************************************************************************
+
+*/
+
+
+
+/*
+
+ * This is the list implementation used by the scheduler.  While it is tailored
+
+ * heavily for the schedulers needs, it is also available for use by
+
+ * application code.
+
+ *
+
+ * xLists can only store pointers to xListItems.  Each xListItem contains a
+
+ * numeric value (xItemValue).  Most of the time the lists are sorted in
+
+ * descending item value order.
+
+ *
+
+ * Lists are created already containing one list item.  The value of this
+
+ * item is the maximum possible that can be stored, it is therefore always at
+
+ * the end of the list and acts as a marker.  The list member pxHead always
+
+ * points to this marker - even though it is at the tail of the list.  This
+
+ * is because the tail contains a wrap back pointer to the true head of
+
+ * the list.
+
+ *
+
+ * In addition to it's value, each list item contains a pointer to the next
+
+ * item in the list (pxNext), a pointer to the list it is in (pxContainer)
+
+ * and a pointer to back to the object that contains it.  These later two
+
+ * pointers are included for efficiency of list manipulation.  There is
+
+ * effectively a two way link between the object containing the list item and
+
+ * the list item itself.
+
+ *
+
+ *
+
+ * \page ListIntroduction List Implementation
+
+ * \ingroup FreeRTOSIntro
+
+ */
+
+
+
+
+
+#ifndef LIST_H
+
+#define LIST_H
+
+
+
+/*
+
+ * Definition of the only type of object that a list can contain.
+
+ */
+
+struct xLIST_ITEM
+
+{
+
+	portTickType xItemValue;				/*< The value being listed.  In most cases this is used to sort the list in descending order. */
+
+	volatile struct xLIST_ITEM * pxNext;	/*< Pointer to the next xListItem in the list. */
+
+	volatile struct xLIST_ITEM * pxPrevious;/*< Pointer to the previous xListItem in the list. */
+
+	void * pvOwner;							/*< Pointer to the object (normally a TCB) that contains the list item.  There is therefore a two way link between the object containing the list item and the list item itself. */
+
+	void * pvContainer;						/*< Pointer to the list in which this list item is placed (if any). */
+
+};
+
+typedef struct xLIST_ITEM xListItem;		/* For some reason lint wants this as two separate definitions. */
+
+
+
+struct xMINI_LIST_ITEM
+
+{
+
+	portTickType xItemValue;
+
+	volatile struct xLIST_ITEM *pxNext;
+
+	volatile struct xLIST_ITEM *pxPrevious;
+
+};
+
+typedef struct xMINI_LIST_ITEM xMiniListItem;
+
+
+
+/*
+
+ * Definition of the type of queue used by the scheduler.
+
+ */
+
+typedef struct xLIST
+
+{
+
+	volatile unsigned portBASE_TYPE uxNumberOfItems;
+
+	volatile xListItem * pxIndex;			/*< Used to walk through the list.  Points to the last item returned by a call to pvListGetOwnerOfNextEntry (). */
+
+	volatile xMiniListItem xListEnd;		/*< List item that contains the maximum possible item value meaning it is always at the end of the list and is therefore used as a marker. */
+
+} xList;
+
+
+
+/*
+
+ * Access macro to set the owner of a list item.  The owner of a list item
+
+ * is the object (usually a TCB) that contains the list item.
+
+ *
+
+ * \page listSET_LIST_ITEM_OWNER listSET_LIST_ITEM_OWNER
+
+ * \ingroup LinkedList
+
+ */
+
+#define listSET_LIST_ITEM_OWNER( pxListItem, pxOwner )		( pxListItem )->pvOwner = ( void * ) pxOwner
+
+
+
+/*
+
+ * Access macro to set the value of the list item.  In most cases the value is
+
+ * used to sort the list in descending order.
+
+ *
+
+ * \page listSET_LIST_ITEM_VALUE listSET_LIST_ITEM_VALUE
+
+ * \ingroup LinkedList
+
+ */
+
+#define listSET_LIST_ITEM_VALUE( pxListItem, xValue )		( pxListItem )->xItemValue = xValue
+
+
+
+/*
+
+ * Access macro the retrieve the value of the list item.  The value can
+
+ * represent anything - for example a the priority of a task, or the time at
+
+ * which a task should be unblocked.
+
+ *
+
+ * \page listGET_LIST_ITEM_VALUE listGET_LIST_ITEM_VALUE
+
+ * \ingroup LinkedList
+
+ */
+
+#define listGET_LIST_ITEM_VALUE( pxListItem )				( ( pxListItem )->xItemValue )
+
+
+
+/*
+
+ * Access macro to determine if a list contains any items.  The macro will
+
+ * only have the value true if the list is empty.
+
+ *
+
+ * \page listLIST_IS_EMPTY listLIST_IS_EMPTY
+
+ * \ingroup LinkedList
+
+ */
+
+#define listLIST_IS_EMPTY( pxList )				( ( pxList )->uxNumberOfItems == ( unsigned portBASE_TYPE ) 0 )
+
+
+
+/*
+
+ * Access macro to return the number of items in the list.
+
+ */
+

components/connectivity/Modbus/3rdparty/freemodbus-v1.6/demo/STR71XTCP/freertos/include/portable.h

@@ -0,0 +1,193 @@
+/*
+	FreeRTOS.org V4.1.0 - Copyright (C) 2003-2006 Richard Barry.
+
+	This file is part of the FreeRTOS.org distribution.
+
+	FreeRTOS.org is free software; you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation; either version 2 of the License, or
+	(at your option) any later version.
+
+	FreeRTOS.org 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.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with FreeRTOS.org; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+	A special exception to the GPL can be applied should you wish to distribute
+	a combined work that includes FreeRTOS.org, without being obliged to provide
+	the source code for any proprietary components.  See the licensing section
+	of http:www.FreeRTOS.org for full details of how and when the exception
+	can be applied.
+
+	***************************************************************************
+	See http:www.FreeRTOS.org for documentation, latest information, license
+	and contact details.  Please ensure to read the configuration and relevant
+	port sections of the online documentation.
+	***************************************************************************
+*/
+
+/*-----------------------------------------------------------
+ * Portable layer API.  Each function must be defined for each port.
+ *----------------------------------------------------------*/
+
+#ifndef PORTABLE_H
+#define PORTABLE_H
+
+/* Include the macro file relevant to the port being used. */
+
+#ifdef OPEN_WATCOM_INDUSTRIAL_PC_PORT
+	#include "..\..\source\portable\owatcom\16bitdos\pc\portmacro.h"
+	typedef void ( __interrupt __far *pxISR )();
+#endif
+
+#ifdef OPEN_WATCOM_FLASH_LITE_186_PORT
+	#include "..\..\source\portable\owatcom\16bitdos\flsh186\portmacro.h"
+	typedef void ( __interrupt __far *pxISR )();
+#endif
+
+#ifdef GCC_MEGA_AVR
+	#include "../portable/GCC/ATMega323/portmacro.h"
+#endif
+
+#ifdef IAR_MEGA_AVR
+	#include "../portable/IAR/ATMega323/portmacro.h"
+#endif
+
+#ifdef MPLAB_PIC18F_PORT
+	#include "..\..\source\portable\MPLAB\PIC18F\portmacro.h"
+#endif
+
+#ifdef _FEDPICC
+	#include "libFreeRTOS/Include/portmacro.h"
+#endif
+
+#ifdef SDCC_CYGNAL
+	#include "../../Source/portable/SDCC/Cygnal/portmacro.h"
+#endif
+
+#ifdef GCC_ARM7
+	#include "../../Source/portable/GCC/ARM7_LPC2000/portmacro.h"
+#endif
+
+#ifdef GCC_MSP430
+	#include "../../Source/portable/GCC/MSP430F449/portmacro.h"
+#endif
+
+#ifdef ROWLEY_MSP430
+	#include "../../Source/portable/Rowley/MSP430F449/portmacro.h"
+#endif
+
+#ifdef KEIL_ARM7
+	#include "..\..\Source\portable\Keil\ARM7\portmacro.h"
+#endif
+
+#ifdef SAM7_GCC
+	#include "../../Source/portable/GCC/ARM7_AT91SAM7S/portmacro.h"
+#endif
+
+#ifdef SAM7_IAR
+	#include "..\..\Source\portable\IAR\AtmelSAM7S64\portmacro.h"
+#endif
+
+#ifdef LPC2000_IAR
+	#include "..\..\Source\portable\IAR\LPC2000\portmacro.h"
+#endif
+
+#ifdef STR71X_IAR
+	#include "..\..\Source\portable\IAR\STR71x\portmacro.h"
+#endif
+
+#ifdef STR91X_IAR
+	#include "..\..\Source\portable\IAR\STR91x\portmacro.h"
+#endif
+	
+#ifdef GCC_H8S
+	#include "../../Source/portable/GCC/H8S2329/portmacro.h"
+#endif
+
+#ifdef GCC_AT91FR40008
+	#include "../../Source/portable/GCC/ARM7_AT91FR40008/portmacro.h"
+#endif
+
+#ifdef RVDS_ARMCM3_LM3S102
+	#include "../../Source/portable/RVDS/ARM_CM3/portmacro.h"
+#endif
+
+#ifdef GCC_ARMCM3_LM3S102
+	#include "../../Source/portable/GCC/ARM_CM3/portmacro.h"
+#endif
+
+#ifdef IAR_ARMCM3_LM
+	#include "../../Source/portable/IAR/ARM_CM3/portmacro.h"
+#endif
+	
+#ifdef HCS12_CODE_WARRIOR
+	#include "../../Source/portable/CodeWarrior/HCS12/portmacro.h"
+#endif	
+
+#ifdef MICROBLAZE_GCC
+	#include "../../Source/portable/GCC/MicroBlaze/portmacro.h"
+#endif
+
+#ifdef TERN_EE
+	#include "..\..\Source\portable\Paradigm\Tern_EE\small\portmacro.h"
+#endif
+
+#ifdef GCC_HCS12
+	#include "../../Source/portable/GCC/HCS12/portmacro.h"
+#endif
+
+#ifdef GCC_STR71X
+        #include "../portable/GCC/ARM7_STR71X/portmacro.h"
+#endif
+
+
+#ifdef BCC_INDUSTRIAL_PC_PORT
+	/* A short file name has to be used in place of the normal
+	FreeRTOSConfig.h when using the Borland compiler. */
+	#include "frconfig.h"
+	#include "..\portable\BCC\16BitDOS\PC\prtmacro.h"
+    typedef void ( __interrupt __far *pxISR )();
+#endif
+
+#ifdef BCC_FLASH_LITE_186_PORT
+	/* A short file name has to be used in place of the normal
+	FreeRTOSConfig.h when using the Borland compiler. */
+	#include "frconfig.h"
+	#include "..\portable\BCC\16BitDOS\flsh186\prtmacro.h"
+    typedef void ( __interrupt __far *pxISR )();
+#endif
+/*
+ * Setup the stack of a new task so it is ready to be placed under the
+ * scheduler control.  The registers have to be placed on the stack in
+ * the order that the port expects to find them.
+ */
+portSTACK_TYPE *pxPortInitialiseStack( portSTACK_TYPE *pxTopOfStack, pdTASK_CODE pxCode, void *pvParameters );
+
+/*
+ * Map to the memory management routines required for the port.
+ */
+void *pvPortMalloc( size_t xSize );
+void vPortFree( void *pv );
+void vPortInitialiseBlocks( void );
+
+/*
+ * Setup the hardware ready for the scheduler to take control.  This generally
+ * sets up a tick interrupt and sets timers for the correct tick frequency.
+ */
+portBASE_TYPE xPortStartScheduler( void );
+
+/*
+ * Undo any hardware/ISR setup that was performed by xPortStartScheduler() so
+ * the hardware is left in its original condition after the scheduler stops
+ * executing.
+ */
+void vPortEndScheduler( void );
+
+
+#endif /* PORTABLE_H */
+

components/connectivity/Modbus/3rdparty/freemodbus-v1.6/demo/STR71XTCP/freertos/include/projdefs.h

@@ -0,0 +1,56 @@
+/*
+
+	FreeRTOS.org V4.1.0 - Copyright (C) 2003-2006 Richard Barry.
+
+
+
+	This file is part of the FreeRTOS.org distribution.
+
+
+
+	FreeRTOS.org is free software; you can redistribute it and/or modify
+
+	it under the terms of the GNU General Public License as published by
+
+	the Free Software Foundation; either version 2 of the License, or
+
+	(at your option) any later version.
+
+
+
+	FreeRTOS.org 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.  See the
+
+	GNU General Public License for more details.
+
+
+
+	You should have received a copy of the GNU General Public License
+
+	along with FreeRTOS.org; if not, write to the Free Software
+
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+
+
+	A special exception to the GPL can be applied should you wish to distribute
+
+	a combined work that includes FreeRTOS.org, without being obliged to provide
+
+	the source code for any proprietary components.  See the licensing section 
+
+	of http://www.FreeRTOS.org for full details of how and when the exception
+
+	can be applied.
+
+
+
+	***************************************************************************
+
+	See http://www.FreeRTOS.org for documentation, latest information, license 
+
+	and contact details.  Please ensure to read the configuration and relevant 
+

components/connectivity/Modbus/3rdparty/freemodbus-v1.6/demo/STR71XTCP/freertos/include/queue.h

@@ -0,0 +1,471 @@
+/*
+
+	FreeRTOS.org V4.1.0 - Copyright (C) 2003-2006 Richard Barry.
+
+
+
+	This file is part of the FreeRTOS.org distribution.
+
+
+
+	FreeRTOS.org is free software; you can redistribute it and/or modify
+
+	it under the terms of the GNU General Public License as published by
+
+	the Free Software Foundation; either version 2 of the License, or
+
+	(at your option) any later version.
+
+
+
+	FreeRTOS.org 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.  See the
+
+	GNU General Public License for more details.
+
+
+
+	You should have received a copy of the GNU General Public License
+
+	along with FreeRTOS.org; if not, write to the Free Software
+
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+
+
+	A special exception to the GPL can be applied should you wish to distribute
+
+	a combined work that includes FreeRTOS.org, without being obliged to provide
+
+	the source code for any proprietary components.  See the licensing section 
+
+	of http://www.FreeRTOS.org for full details of how and when the exception
+
+	can be applied.
+
+
+
+	***************************************************************************
+
+	See http://www.FreeRTOS.org for documentation, latest information, license 
+
+	and contact details.  Please ensure to read the configuration and relevant 
+
+	port sections of the online documentation.
+
+	***************************************************************************
+
+*/
+
+
+
+#ifndef QUEUE_H
+
+#define QUEUE_H
+
+
+
+typedef void * xQueueHandle;
+
+
+
+/**
+
+ * queue. h
+
+ * <pre>
+
+ xQueueHandle xQueueCreate( 
+
+                              unsigned portBASE_TYPE uxQueueLength, 
+
+                              unsigned portBASE_TYPE uxItemSize 
+
+                          );
+
+ * </pre>
+
+ *
+
+ * Creates a new queue instance.  This allocates the storage required by the
+
+ * new queue and returns a handle for the queue.
+
+ *
+
+ * @param uxQueueLength The maximum number of items that the queue can contain.
+
+ *
+
+ * @param uxItemSize The number of bytes each item in the queue will require.  
+
+ * Items are queued by copy, not by reference, so this is the number of bytes
+
+ * that will be copied for each posted item.  Each item on the queue must be
+
+ * the same size.
+
+ *
+
+ * @return If the queue is successfully create then a handle to the newly 
+
+ * created queue is returned.  If the queue cannot be created then 0 is
+
+ * returned.
+
+ * 
+
+ * Example usage:
+
+   <pre>
+
+ struct AMessage
+
+ {
+
+    portCHAR ucMessageID;
+
+    portCHAR ucData[ 20 ];
+
+ };
+
+
+
+ void vATask( void *pvParameters )
+
+ {
+
+ xQueueHandle xQueue1, xQueue2;
+
+
+
+    // Create a queue capable of containing 10 unsigned long values.
+
+    xQueue1 = xQueueCreate( 10, sizeof( unsigned portLONG ) );
+
+    if( xQueue1 == 0 )
+
+    {
+
+        // Queue was not created and must not be used.
+
+    }
+
+
+
+    // Create a queue capable of containing 10 pointers to AMessage structures.
+
+    // These should be passed by pointer as they contain a lot of data.
+
+    xQueue2 = xQueueCreate( 10, sizeof( struct AMessage * ) );
+
+    if( xQueue2 == 0 )
+
+    {
+
+        // Queue was not created and must not be used.
+
+    }
+
+
+
+    // ... Rest of task code.
+
+ }
+
+ </pre>
+
+ * \defgroup xQueueCreate xQueueCreate
+
+ * \ingroup QueueManagement
+
+ */
+
+xQueueHandle xQueueCreate( unsigned portBASE_TYPE uxQueueLength, unsigned portBASE_TYPE uxItemSize );
+
+
+
+/**
+
+ * queue. h
+
+ * <pre>
+
+ portBASE_TYPE xQueueSend( 
+
+                             xQueueHandle xQueue, 
+
+                             const void * pvItemToQueue, 
+
+                             portTickType xTicksToWait 
+
+                         );
+
+ * </pre>
+
+ *
+
+ * Post an item on a queue.  The item is queued by copy, not by reference.
+
+ * This function must not be called from an interrupt service routine.
+
+ * See xQueueSendFromISR () for an alternative which may be used in an ISR.
+
+ *
+
+ * @param xQueue The handle to the queue on which the item is to be posted.
+
+ * 
+
+ * @param pvItemToQueue A pointer to the item that is to be placed on the 
+
+ * queue.  The size of the items the queue will hold was defined when the
+
+ * queue was created, so this many bytes will be copied from pvItemToQueue
+
+ * into the queue storage area.
+
+ *
+
+ * @param xTicksToWait The maximum amount of time the task should block
+
+ * waiting for space to become available on the queue, should it already
+
+ * be full.  The call will return immediately if this is set to 0.  The
+
+ * time is defined in tick periods so the constant portTICK_RATE_MS 
+
+ * should be used to convert to real time if this is required.
+
+ *
+
+ * @return pdTRUE if the item was successfully posted, otherwise errQUEUE_FULL.
+
+ *
+
+ * Example usage:
+
+   <pre>
+
+ struct AMessage
+
+ {
+
+    portCHAR ucMessageID;
+
+    portCHAR ucData[ 20 ];
+
+ } xMessage;
+
+
+
+ unsigned portLONG ulVar = 10UL;
+
+
+
+ void vATask( void *pvParameters )
+
+ {
+
+ xQueueHandle xQueue1, xQueue2;
+
+ struct AMessage *pxMessage;
+
+
+
+    // Create a queue capable of containing 10 unsigned long values.
+
+    xQueue1 = xQueueCreate( 10, sizeof( unsigned portLONG ) );
+
+
+
+    // Create a queue capable of containing 10 pointers to AMessage structures.
+
+    // These should be passed by pointer as they contain a lot of data.
+
+    xQueue2 = xQueueCreate( 10, sizeof( struct AMessage * ) );
+
+
+
+    // ...
+
+
+
+    if( xQueue1 != 0 )
+
+    {
+
+        // Send an unsigned long.  Wait for 10 ticks for space to become 
+
+        // available if necessary.
+
+        if( xQueueSend( xQueue1, ( void * ) &ulVar, ( portTickType ) 10 ) != pdPASS )
+
+        {
+
+            // Failed to post the message, even after 10 ticks.
+
+        }
+
+    }
+
+
+
+    if( xQueue2 != 0 )
+
+    {
+
+        // Send a pointer to a struct AMessage object.  Don't block if the
+
+        // queue is already full.
+
+        pxMessage = & xMessage;
+
+        xQueueSend( xQueue2, ( void * ) &pxMessage, ( portTickType ) 0 );
+
+    }
+
+
+
+	// ... Rest of task code.
+
+ }
+
+ </pre>
+
+ * \defgroup xQueueSend xQueueSend
+
+ * \ingroup QueueManagement
+
+ */
+
+signed portBASE_TYPE xQueueSend( xQueueHandle xQueue, const void * pvItemToQueue, portTickType xTicksToWait );
+
+
+
+/**
+
+ * queue. h
+
+ * <pre>
+
+ portBASE_TYPE xQueueReceive( 
+
+                                xQueueHandle xQueue, 
+
+                                void *pvBuffer, 
+
+                                portTickType xTicksToWait 
+
+                            );</pre>
+
+ *
+
+ * Receive an item from a queue.  The item is received by copy so a buffer of 
+
+ * adequate size must be provided.  The number of bytes copied into the buffer
+
+ * was defined when the queue was created.
+
+ *
+
+ * This function must not be used in an interrupt service routine.  See
+
+ * xQueueReceiveFromISR for an alternative that can.
+
+ *
+
+ * @param pxQueue The handle to the queue from which the item is to be
+
+ * received.
+
+ *
+
+ * @param pvBuffer Pointer to the buffer into which the received item will
+
+ * be copied.
+
+ * 
+
+ * @param xTicksToWait The maximum amount of time the task should block
+
+ * waiting for an item to receive should the queue be empty at the time
+
+ * of the call.    The time is defined in tick periods so the constant 
+
+ * portTICK_RATE_MS should be used to convert to real time if this is required.
+
+ *
+
+ * @return pdTRUE if an item was successfully received from the queue,
+
+ * otherwise pdFALSE.
+
+ *
+
+ * Example usage:
+
+   <pre>
+
+ struct AMessage
+
+ {
+
+    portCHAR ucMessageID;
+
+    portCHAR ucData[ 20 ];
+
+ } xMessage;
+
+
+
+ xQueueHandle xQueue;
+
+ 
+
+ // Task to create a queue and post a value.
+
+ void vATask( void *pvParameters )
+
+ {
+
+ struct AMessage *pxMessage;
+
+
+
+    // Create a queue capable of containing 10 pointers to AMessage structures.
+
+    // These should be passed by pointer as they contain a lot of data.
+
+    xQueue = xQueueCreate( 10, sizeof( struct AMessage * ) );
+
+    if( xQueue == 0 )
+
+    {
+
+        // Failed to create the queue.
+
+    }
+
+
+
+    // ...
+
+
+
+    // Send a pointer to a struct AMessage object.  Don't block if the
+
+    // queue is already full.
+
+    pxMessage = & xMessage;
+
+    xQueueSend( xQueue, ( void * ) &pxMessage, ( portTickType ) 0 );
+
+
+
+	// ... Rest of task code.
+
+ }

components/connectivity/Modbus/3rdparty/freemodbus-v1.6/demo/STR71XTCP/freertos/include/semphr.h

@@ -0,0 +1,289 @@
+/*
+
+	FreeRTOS.org V4.1.0 - Copyright (C) 2003-2006 Richard Barry.
+
+
+
+	This file is part of the FreeRTOS.org distribution.
+
+
+
+	FreeRTOS.org is free software; you can redistribute it and/or modify
+
+	it under the terms of the GNU General Public License as published by
+
+	the Free Software Foundation; either version 2 of the License, or
+
+	(at your option) any later version.
+
+
+
+	FreeRTOS.org 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.  See the
+
+	GNU General Public License for more details.
+
+
+
+	You should have received a copy of the GNU General Public License
+
+	along with FreeRTOS.org; if not, write to the Free Software
+
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+
+
+	A special exception to the GPL can be applied should you wish to distribute
+
+	a combined work that includes FreeRTOS.org, without being obliged to provide
+
+	the source code for any proprietary components.  See the licensing section 
+
+	of http://www.FreeRTOS.org for full details of how and when the exception
+
+	can be applied.
+
+
+
+	***************************************************************************
+
+	See http://www.FreeRTOS.org for documentation, latest information, license 
+
+	and contact details.  Please ensure to read the configuration and relevant 
+
+	port sections of the online documentation.
+
+	***************************************************************************
+
+*/
+
+
+
+#include "queue.h"
+
+
+
+#ifndef SEMAPHORE_H
+
+#define SEMAPHORE_H
+
+
+
+typedef xQueueHandle xSemaphoreHandle;
+
+
+
+#define semBINARY_SEMAPHORE_QUEUE_LENGTH	( ( unsigned portCHAR ) 1 )
+
+#define semSEMAPHORE_QUEUE_ITEM_LENGTH		( ( unsigned portCHAR ) 0 )
+
+#define semGIVE_BLOCK_TIME					( ( portTickType ) 0 )
+
+
+
+
+
+/**
+
+ * semphr. h
+
+ * <pre>vSemaphoreCreateBinary( xSemaphoreHandle xSemaphore )</pre>
+
+ *
+
+ * <i>Macro</i> that implements a semaphore by using the existing queue mechanism.
+
+ * The queue length is 1 as this is a binary semaphore.  The data size is 0
+
+ * as we don't want to actually store any data - we just want to know if the
+
+ * queue is empty or full.
+
+ *
+
+ * @param xSemaphore Handle to the created semaphore.  Should be of type xSemaphoreHandle.
+
+ *
+
+ * Example usage:
+
+ <pre>
+
+ xSemaphoreHandle xSemaphore;
+
+
+
+ void vATask( void * pvParameters )
+
+ {
+
+    // Semaphore cannot be used before a call to vSemaphoreCreateBinary ().
+
+    // This is a macro so pass the variable in directly.
+
+    vSemaphoreCreateBinary( xSemaphore );
+
+
+
+    if( xSemaphore != NULL )
+
+    {
+
+        // The semaphore was created successfully.
+
+        // The semaphore can now be used.  
+
+    }
+
+ }
+
+ </pre>
+
+ * \defgroup vSemaphoreCreateBinary vSemaphoreCreateBinary
+
+ * \ingroup Semaphores
+
+ */
+
+#define vSemaphoreCreateBinary( xSemaphore )		{																							\
+
+														xSemaphore = xQueueCreate( ( unsigned portCHAR ) 1, semSEMAPHORE_QUEUE_ITEM_LENGTH );	\
+
+														if( xSemaphore != NULL )																\
+
+														{																						\
+
+															xSemaphoreGive( xSemaphore );														\
+
+														}																						\
+
+													}
+
+
+
+/**
+
+ * semphr. h
+
+ * xSemaphoreTake( 
+
+ *                   xSemaphoreHandle xSemaphore, 
+
+ *                   portTickType xBlockTime 
+
+ *               )</pre>
+
+ *
+
+ * <i>Macro</i> to obtain a semaphore.  The semaphore must of been created using 
+
+ * vSemaphoreCreateBinary ().
+
+ *
+
+ * @param xSemaphore A handle to the semaphore being obtained.  This is the
+
+ * handle returned by vSemaphoreCreateBinary ();
+
+ *
+
+ * @param xBlockTime The time in ticks to wait for the semaphore to become
+
+ * available.  The macro portTICK_RATE_MS can be used to convert this to a
+
+ * real time.  A block time of zero can be used to poll the semaphore.
+
+ *
+
+ * @return pdTRUE if the semaphore was obtained.  pdFALSE if xBlockTime
+
+ * expired without the semaphore becoming available.
+
+ *
+
+ * Example usage:
+
+ <pre>
+
+ xSemaphoreHandle xSemaphore = NULL;
+
+
+
+ // A task that creates a semaphore.
+
+ void vATask( void * pvParameters )
+
+ {
+
+    // Create the semaphore to guard a shared resource.
+
+    vSemaphoreCreateBinary( xSemaphore );
+
+ }
+
+
+
+ // A task that uses the semaphore.
+
+ void vAnotherTask( void * pvParameters )
+
+ {
+
+    // ... Do other things.
+
+
+
+    if( xSemaphore != NULL )
+
+    {
+
+        // See if we can obtain the semaphore.  If the semaphore is not available
+
+        // wait 10 ticks to see if it becomes free.	
+
+        if( xSemaphoreTake( xSemaphore, ( portTickType ) 10 ) == pdTRUE )
+
+        {
+
+            // We were able to obtain the semaphore and can now access the
+
+            // shared resource.
+
+
+
+            // ...
+
+
+
+            // We have finished accessing the shared resource.  Release the 
+
+            // semaphore.
+
+            xSemaphoreGive( xSemaphore );
+
+        }
+
+        else
+
+        {
+
+            // We could not obtain the semaphore and can therefore not access
+
+            // the shared resource safely.
+
+        }
+
+    }
+
+ }
+
+ </pre>
+
+ * \defgroup xSemaphoreTake xSemaphoreTake
+
+ * \ingroup Semaphores
+
+ */

components/connectivity/Modbus/3rdparty/freemodbus-v1.6/demo/STR71XTCP/freertos/include/task.h

@@ -0,0 +1,951 @@
+/*
+
+	FreeRTOS.org V4.1.0 - Copyright (C) 2003-2006 Richard Barry.
+
+
+
+	This file is part of the FreeRTOS.org distribution.
+
+
+
+	FreeRTOS.org is free software; you can redistribute it and/or modify
+
+	it under the terms of the GNU General Public License as published by
+
+	the Free Software Foundation; either version 2 of the License, or
+
+	(at your option) any later version.
+
+
+
+	FreeRTOS.org 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.  See the
+
+	GNU General Public License for more details.
+
+
+
+	You should have received a copy of the GNU General Public License
+
+	along with FreeRTOS.org; if not, write to the Free Software
+
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+
+
+	A special exception to the GPL can be applied should you wish to distribute
+
+	a combined work that includes FreeRTOS.org, without being obliged to provide
+
+	the source code for any proprietary components.  See the licensing section
+
+	of http://www.FreeRTOS.org for full details of how and when the exception
+
+	can be applied.
+
+
+
+	***************************************************************************
+
+	See http://www.FreeRTOS.org for documentation, latest information, license
+
+	and contact details.  Please ensure to read the configuration and relevant
+
+	port sections of the online documentation.
+
+	***************************************************************************
+
+*/
+
+
+
+#ifndef TASK_H
+
+#define TASK_H
+
+
+
+#include "portable.h"
+
+#include "list.h"
+
+
+
+/*-----------------------------------------------------------
+
+ * MACROS AND DEFINITIONS
+
+ *----------------------------------------------------------*/
+
+
+
+#define tskKERNEL_VERSION_NUMBER "V4.1.0"
+
+
+
+/**
+
+ * task. h
+
+ *
+
+ * Type by which tasks are referenced.  For example, a call to xTaskCreate
+
+ * returns (via a pointer parameter) an xTaskHandle variable that can then
+
+ * be used as a parameter to vTaskDelete to delete the task.
+
+ *
+
+ * \page xTaskHandle xTaskHandle
+
+ * \ingroup Tasks
+
+ */
+
+typedef void * xTaskHandle;
+
+
+
+/*
+
+ * Used internally only.
+
+ */
+
+typedef struct xTIME_OUT
+
+{
+
+    portBASE_TYPE xOverflowCount;
+
+    portTickType  xTimeOnEntering;
+
+} xTimeOutType;
+
+
+
+/*
+
+ * Defines the priority used by the idle task.  This must not be modified.
+
+ *
+
+ * \ingroup TaskUtils
+
+ */
+
+#define tskIDLE_PRIORITY			( ( unsigned portBASE_TYPE ) 0 )
+
+
+
+/**
+
+ * task. h
+
+ *
+
+ * Macro for forcing a context switch.
+
+ *
+
+ * \page taskYIELD taskYIELD
+
+ * \ingroup SchedulerControl
+
+ */
+
+#define taskYIELD()					portYIELD()
+
+
+
+/**
+
+ * task. h
+
+ *
+
+ * Macro to mark the start of a critical code region.  Preemptive context
+
+ * switches cannot occur when in a critical region.
+
+ *
+
+ * NOTE: This may alter the stack (depending on the portable implementation)
+
+ * so must be used with care!
+
+ *
+
+ * \page taskENTER_CRITICAL taskENTER_CRITICAL
+
+ * \ingroup SchedulerControl
+
+ */
+
+#define taskENTER_CRITICAL()		portENTER_CRITICAL()
+
+
+
+/**
+
+ * task. h
+
+ *
+
+ * Macro to mark the end of a critical code region.  Preemptive context
+
+ * switches cannot occur when in a critical region.
+
+ *
+
+ * NOTE: This may alter the stack (depending on the portable implementation)
+
+ * so must be used with care!
+
+ *
+
+ * \page taskEXIT_CRITICAL taskEXIT_CRITICAL
+
+ * \ingroup SchedulerControl
+
+ */
+
+#define taskEXIT_CRITICAL()			portEXIT_CRITICAL()
+
+
+
+/**
+
+ * task. h
+
+ *
+
+ * Macro to disable all maskable interrupts.
+
+ *
+
+ * \page taskDISABLE_INTERRUPTS taskDISABLE_INTERRUPTS
+
+ * \ingroup SchedulerControl
+
+ */
+
+#define taskDISABLE_INTERRUPTS()	portDISABLE_INTERRUPTS()
+
+
+
+/**
+
+ * task. h
+
+ *
+
+ * Macro to enable microcontroller interrupts.
+
+ *
+
+ * \page taskENABLE_INTERRUPTS taskENABLE_INTERRUPTS
+
+ * \ingroup SchedulerControl
+
+ */
+
+#define taskENABLE_INTERRUPTS()		portENABLE_INTERRUPTS()
+
+
+
+
+
+/*-----------------------------------------------------------
+
+ * TASK CREATION API
+
+ *----------------------------------------------------------*/
+
+
+
+/**
+
+ * task. h
+
+ *<pre>
+
+ portBASE_TYPE xTaskCreate(
+
+                              pdTASK_CODE pvTaskCode,
+
+                              const portCHAR * const pcName,
+
+                              unsigned portSHORT usStackDepth,
+
+                              void *pvParameters,
+
+                              unsigned portBASE_TYPE uxPriority,
+
+                              xTaskHandle *pvCreatedTask
+
+                          );</pre>
+
+ *
+
+ * Create a new task and add it to the list of tasks that are ready to run.
+
+ *
+
+ * @param pvTaskCode Pointer to the task entry function.  Tasks
+
+ * must be implemented to never return (i.e. continuous loop).
+
+ *
+
+ * @param pcName A descriptive name for the task.  This is mainly used to
+
+ * facilitate debugging.  Max length defined by tskMAX_TASK_NAME_LEN - default
+
+ * is 16.
+
+ *
+
+ * @param usStackDepth The size of the task stack specified as the number of
+
+ * variables the stack can hold - not the number of bytes.  For example, if
+
+ * the stack is 16 bits wide and usStackDepth is defined as 100, 200 bytes
+
+ * will be allocated for stack storage.
+
+ *
+
+ * @param pvParameters Pointer that will be used as the parameter for the task
+
+ * being created.
+
+ *
+
+ * @param uxPriority The priority at which the task should run.
+
+ *
+
+ * @param pvCreatedTask Used to pass back a handle by which the created task
+
+ * can be referenced.
+
+ *
+
+ * @return pdPASS if the task was successfully created and added to a ready
+
+ * list, otherwise an error code defined in the file errors. h
+
+ *
+
+ * Example usage:
+
+   <pre>
+
+ // Task to be created.
+
+ void vTaskCode( void * pvParameters )
+
+ {
+
+     for( ;; )
+
+     {
+
+         // Task code goes here.
+
+     }
+
+ }
+
+
+
+ // Function that creates a task.
+
+ void vOtherFunction( void )
+
+ {
+
+ unsigned char ucParameterToPass;
+
+ xTaskHandle xHandle;
+
+		
+
+     // Create the task, storing the handle.
+
+     xTaskCreate( vTaskCode, "NAME", STACK_SIZE, &ucParameterToPass, tskIDLE_PRIORITY, &xHandle );
+
+		
+
+     // Use the handle to delete the task.
+
+     vTaskDelete( xHandle );
+
+ }
+
+   </pre>
+
+ * \defgroup xTaskCreate xTaskCreate
+
+ * \ingroup Tasks
+
+ */
+
+signed portBASE_TYPE xTaskCreate( pdTASK_CODE pvTaskCode, const signed portCHAR * const pcName, unsigned portSHORT usStackDepth, void *pvParameters, unsigned portBASE_TYPE uxPriority, xTaskHandle *pvCreatedTask );
+
+
+
+/**
+
+ * task. h
+
+ * <pre>void vTaskDelete( xTaskHandle pxTask );</pre>
+
+ *
+
+ * INCLUDE_vTaskDelete must be defined as 1 for this function to be available.
+
+ * See the configuration section for more information.
+
+ *
+
+ * Remove a task from the RTOS real time kernels management.  The task being
+
+ * deleted will be removed from all ready, blocked, suspended and event lists.
+
+ *
+
+ * NOTE:  The idle task is responsible for freeing the kernel allocated
+
+ * memory from tasks that have been deleted.  It is therefore important that
+
+ * the idle task is not starved of microcontroller processing time if your
+
+ * application makes any calls to vTaskDelete ().  Memory allocated by the
+
+ * task code is not automatically freed, and should be freed before the task
+
+ * is deleted.
+
+ *
+
+ * See the demo application file death.c for sample code that utilises
+
+ * vTaskDelete ().
+
+ *
+
+ * @param pxTask The handle of the task to be deleted.  Passing NULL will
+
+ * cause the calling task to be deleted.
+
+ *
+
+ * Example usage:
+
+   <pre>
+
+ void vOtherFunction( void )
+
+ {
+
+ xTaskHandle xHandle;
+
+		
+
+     // Create the task, storing the handle.
+
+     xTaskCreate( vTaskCode, "NAME", STACK_SIZE, NULL, tskIDLE_PRIORITY, &xHandle );
+
+		
+
+     // Use the handle to delete the task.
+
+     vTaskDelete( xHandle );
+
+ }
+
+   </pre>
+
+ * \defgroup vTaskDelete vTaskDelete
+
+ * \ingroup Tasks
+
+ */
+
+void vTaskDelete( xTaskHandle pxTask );
+
+
+
+
+
+/*-----------------------------------------------------------
+
+ * TASK CONTROL API
+
+ *----------------------------------------------------------*/
+
+
+
+/**
+
+ * task. h
+
+ * <pre>void vTaskDelay( portTickType xTicksToDelay );</pre>
+
+ *
+
+ * Delay a task for a given number of ticks.  The actual time that the
+
+ * task remains blocked depends on the tick rate.  The constant
+
+ * portTICK_RATE_MS can be used to calculate real time from the tick
+
+ * rate - with the resolution of one tick period.
+
+ *
+
+ * INCLUDE_vTaskDelay must be defined as 1 for this function to be available.
+
+ * See the configuration section for more information.
+
+ *
+
+ * @param xTicksToDelay The amount of time, in tick periods, that
+
+ * the calling task should block.
+
+ *
+
+ * Example usage:
+
+   <pre>
+
+ // Wait 10 ticks before performing an action.
+
+ // NOTE:
+
+ // This is for demonstration only and would be better achieved
+
+ // using vTaskDelayUntil ().
+
+ void vTaskFunction( void * pvParameters )
+
+ {
+
+ portTickType xDelay, xNextTime;
+
+
+
+     // Calc the time at which we want to perform the action
+
+     // next.
+
+     xNextTime = xTaskGetTickCount () + ( portTickType ) 10;
+
+
+
+     for( ;; )
+
+     {
+
+         xDelay = xNextTime - xTaskGetTickCount ();
+
+         xNextTime += ( portTickType ) 10;
+
+
+
+         // Guard against overflow
+
+         if( xDelay <= ( portTickType ) 10 )
+
+         {
+
+             vTaskDelay( xDelay );
+
+         }
+
+
+
+         // Perform action here.
+
+     }
+
+ }
+
+   </pre>
+
+ * \defgroup vTaskDelay vTaskDelay
+
+ * \ingroup TaskCtrl
+
+ */
+
+void vTaskDelay( portTickType xTicksToDelay );
+
+
+
+/**
+
+ * task. h
+
+ * <pre>void vTaskDelayUntil( portTickType *pxPreviousWakeTime, portTickType xTimeIncrement );</pre>
+
+ *
+
+ * INCLUDE_vTaskDelayUntil must be defined as 1 for this function to be available.
+
+ * See the configuration section for more information.
+
+ *
+
+ * Delay a task until a specified time.  This function can be used by cyclical
+
+ * tasks to ensure a constant execution frequency.
+
+ *
+
+ * This function differs from vTaskDelay () in one important aspect:  vTaskDelay () will
+
+ * cause a task to block for the specified number of ticks from the time vTaskDelay () is
+
+ * called.  It is therefore difficult to use vTaskDelay () by itself to generate a fixed
+
+ * execution frequency as the time between a task starting to execute and that task
+
+ * calling vTaskDelay () may not be fixed [the task may take a different path though the
+
+ * code between calls, or may get interrupted or preempted a different number of times
+
+ * each time it executes].
+
+ *
+
+ * Whereas vTaskDelay () specifies a wake time relative to the time at which the function
+
+ * is called, vTaskDelayUntil () specifies the absolute (exact) time at which it wishes to
+
+ * unblock.
+
+ *
+
+ * The constant portTICK_RATE_MS can be used to calculate real time from the tick
+
+ * rate - with the resolution of one tick period.
+
+ *
+
+ * @param pxPreviousWakeTime Pointer to a variable that holds the time at which the
+
+ * task was last unblocked.  The variable must be initialised with the current time
+
+ * prior to its first use (see the example below).  Following this the variable is
+
+ * automatically updated within vTaskDelayUntil ().
+
+ *
+
+ * @param xTimeIncrement The cycle time period.  The task will be unblocked at
+
+ * time *pxPreviousWakeTime + xTimeIncrement.  Calling vTaskDelayUntil with the
+
+ * same xTimeIncrement parameter value will cause the task to execute with
+
+ * a fixed interface period.
+
+ *
+
+ * Example usage:
+
+   <pre>
+
+ // Perform an action every 10 ticks.
+
+ void vTaskFunction( void * pvParameters )
+
+ {
+
+ portTickType xLastWakeTime;
+
+ const portTickType xFrequency = 10;
+
+
+
+     // Initialise the xLastWakeTime variable with the current time.
+
+     xLastWakeTime = xTaskGetTickCount ();
+
+     for( ;; )
+
+     {
+
+         // Wait for the next cycle.
+
+         vTaskDelayUntil( &xLastWakeTime, xFrequency );
+
+
+
+         // Perform action here.
+
+     }
+
+ }
+
+   </pre>
+
+ * \defgroup vTaskDelayUntil vTaskDelayUntil
+
+ * \ingroup TaskCtrl
+
+ */
+
+void vTaskDelayUntil( portTickType *pxPreviousWakeTime, portTickType xTimeIncrement );
+
+
+
+/**
+
+ * task. h
+
+ * <pre>unsigned portBASE_TYPE uxTaskPriorityGet( xTaskHandle pxTask );</pre>
+
+ *
+
+ * INCLUDE_xTaskPriorityGet must be defined as 1 for this function to be available.
+
+ * See the configuration section for more information.
+
+ *
+
+ * Obtain the priority of any task.
+
+ *
+
+ * @param pxTask Handle of the task to be queried.  Passing a NULL
+
+ * handle results in the priority of the calling task being returned.
+
+ *
+
+ * @return The priority of pxTask.
+
+ *
+
+ * Example usage:
+
+   <pre>
+
+ void vAFunction( void )
+
+ {
+
+ xTaskHandle xHandle;
+
+		
+
+     // Create a task, storing the handle.
+
+     xTaskCreate( vTaskCode, "NAME", STACK_SIZE, NULL, tskIDLE_PRIORITY, &xHandle );
+
+		
+
+     // ...
+
+
+
+     // Use the handle to obtain the priority of the created task.
+
+     // It was created with tskIDLE_PRIORITY, but may have changed
+
+     // it itself.
+
+     if( uxTaskPriorityGet( xHandle ) != tskIDLE_PRIORITY )
+
+     {
+
+         // The task has changed it's priority.
+
+     }
+
+
+
+     // ...
+
+
+
+     // Is our priority higher than the created task?
+
+     if( uxTaskPriorityGet( xHandle ) < uxTaskPriorityGet( NULL ) )
+
+     {
+
+         // Our priority (obtained using NULL handle) is higher.
+
+     }
+
+ }
+
+   </pre>
+
+ * \defgroup uxTaskPriorityGet uxTaskPriorityGet
+
+ * \ingroup TaskCtrl
+
+ */
+
+unsigned portBASE_TYPE uxTaskPriorityGet( xTaskHandle pxTask );
+
+
+
+/**
+
+ * task. h
+
+ * <pre>void vTaskPrioritySet( xTaskHandle pxTask, unsigned portBASE_TYPE uxNewPriority );</pre>
+
+ *
+
+ * INCLUDE_vTaskPrioritySet must be defined as 1 for this function to be available.
+
+ * See the configuration section for more information.
+
+ *
+
+ * Set the priority of any task.
+
+ *
+
+ * A context switch will occur before the function returns if the priority
+
+ * being set is higher than the currently executing task.
+
+ *
+
+ * @param pxTask Handle to the task for which the priority is being set.
+
+ * Passing a NULL handle results in the priority of the calling task being set.
+
+ *
+
+ * @param uxNewPriority The priority to which the task will be set.
+
+ *
+
+ * Example usage:
+
+   <pre>
+
+ void vAFunction( void )
+
+ {
+
+ xTaskHandle xHandle;
+
+		
+
+     // Create a task, storing the handle.
+
+     xTaskCreate( vTaskCode, "NAME", STACK_SIZE, NULL, tskIDLE_PRIORITY, &xHandle );
+
+
+
+     // ...
+
+
+
+     // Use the handle to raise the priority of the created task.
+
+     vTaskPrioritySet( xHandle, tskIDLE_PRIORITY + 1 );
+
+
+
+     // ...
+
+
+
+     // Use a NULL handle to raise our priority to the same value.
+
+     vTaskPrioritySet( NULL, tskIDLE_PRIORITY + 1 );
+
+ }
+
+   </pre>
+
+ * \defgroup vTaskPrioritySet vTaskPrioritySet
+
+ * \ingroup TaskCtrl
+
+ */
+
+void vTaskPrioritySet( xTaskHandle pxTask, unsigned portBASE_TYPE uxNewPriority );
+
+
+
+/**
+
+ * task. h
+
+ * <pre>void vTaskSuspend( xTaskHandle pxTaskToSuspend );</pre>
+
+ *
+
+ * INCLUDE_vTaskSuspend must be defined as 1 for this function to be available.
+
+ * See the configuration section for more information.
+
+ *
+
+ * Suspend any task.  When suspended a task will never get any microcontroller
+
+ * processing time, no matter what its priority.
+
+ *
+
+ * Calls to vTaskSuspend are not accumulative -
+
+ * i.e. calling vTaskSuspend () twice on the same task still only requires one
+
+ * call to vTaskResume () to ready the suspended task.
+
+ *
+
+ * @param pxTaskToSuspend Handle to the task being suspended.  Passing a NULL
+
+ * handle will cause the calling task to be suspended.
+
+ *
+
+ * Example usage:
+
+   <pre>
+
+ void vAFunction( void )
+
+ {
+
+ xTaskHandle xHandle;
+
+		
+
+     // Create a task, storing the handle.
+
+     xTaskCreate( vTaskCode, "NAME", STACK_SIZE, NULL, tskIDLE_PRIORITY, &xHandle );
+
+		
+
+     // ...
+
+
+
+     // Use the handle to suspend the created task.
+
+     vTaskSuspend( xHandle );
+
+
+
+     // ...